<!-- webkit-test-runner [ enableMetalShaderValidation=true ] -->
<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();

const log = globalThis.$vm?.print ?? console.log;

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

/**
 * @param {GPUDevice} device
 */
function pseudoSubmit(device) {
  for (let i = 0; i < 63; i++) {
    device.createCommandEncoder();
  }
}

/**
 * @param {GPUDevice} device
 * @param {GPUBuffer} buffer
 */
function dissociateBuffer(device, buffer) {
  let commandEncoder = device.createCommandEncoder();
  if (buffer.usage & GPUBufferUsage.COPY_DST) {
    let writeBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
    commandEncoder.copyBufferToBuffer(writeBuffer, 0, buffer, 0, 0);
  } else if (buffer.usage & GPUBufferUsage.COPY_SRC) {
    let readBuffer = device.createBuffer({size: 16, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ});
    commandEncoder.copyBufferToBuffer(buffer, 0, readBuffer, 0, 0);
  }
}

/**
 * @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 promise0 = navigator.gpu.requestAdapter({powerPreference: 'high-performance'});
let adapter0 = await navigator.gpu.requestAdapter({});
let device0 = await adapter0.requestDevice({
  label: '\u5f2c\u4bc8',
  defaultQueue: {label: '\u{1fd58}\u0dd9\u75ba\u5628\uff4b\u803b\u4dea\u2863\u0221\u0987\u{1f9db}'},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
    'bgra8unorm-storage',
  ],
  requiredLimits: {
    maxBindGroups: 7,
    maxColorAttachmentBytesPerSample: 35,
    maxVertexBufferArrayStride: 32093,
    maxStorageTexturesPerShaderStage: 24,
    maxDynamicStorageBuffersPerPipelineLayout: 10983,
    maxDynamicUniformBuffersPerPipelineLayout: 7317,
    maxBindingsPerBindGroup: 3942,
    maxTextureArrayLayers: 1264,
    maxTextureDimension1D: 12030,
    maxTextureDimension2D: 14227,
    maxVertexBuffers: 12,
    minStorageBufferOffsetAlignment: 64,
    minUniformBufferOffsetAlignment: 64,
    maxUniformBufferBindingSize: 105226462,
    maxStorageBufferBindingSize: 156491256,
    maxUniformBuffersPerShaderStage: 43,
    maxSampledTexturesPerShaderStage: 30,
    maxInterStageShaderVariables: 75,
    maxInterStageShaderComponents: 60,
    maxSamplersPerShaderStage: 20,
  },
});
let commandEncoder0 = device0.createCommandEncoder();
let commandBuffer0 = commandEncoder0.finish({label: '\u7ee7\u{1f6fd}\u{1fd74}\u001c\u{1f904}\u213a\ue406'});
let promise1 = device0.popErrorScope();
try {
  await promise1;
} catch {}
let offscreenCanvas0 = new OffscreenCanvas(786, 408);
let commandEncoder1 = device0.createCommandEncoder({label: '\u6cea\u8435\u02b0\ua947\u0fc7\u{1fce4}\u0406'});
let commandBuffer1 = commandEncoder1.finish({label: '\u{1f9cf}\u{1fb1a}\u1672'});
let offscreenCanvas1 = new OffscreenCanvas(945, 305);
let imageData0 = new ImageData(172, 240);
let gpuCanvasContext0 = offscreenCanvas1.getContext('webgpu');
gc();
let commandEncoder2 = device0.createCommandEncoder({});
let renderBundleEncoder0 = device0.createRenderBundleEncoder({
  label: '\u9062\uf1c5\uaf79',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let videoFrame0 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let bindGroupLayout0 = device0.createBindGroupLayout({
  label: '\u0c91\ua744\u9a7a\u5d90\u{1fd01}\u0edd\u0fc1\u{1fdfc}\u61ae\u{1f828}\u2eef',
  entries: [
    {
      binding: 2198,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
    {
      binding: 55,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {binding: 1303, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let externalTexture0 = device0.importExternalTexture({
  label: '\u{1fff3}\u2a34\u08e9\u{1f83c}\u0d6f\u9003\u0fc0\u0a2e\uf038\u181d',
  source: videoFrame0,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder0.setVertexBuffer(7346, undefined, 2335776161, 252579667);
} catch {}
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let adapter1 = await promise0;
let renderBundleEncoder1 = device0.createRenderBundleEncoder({label: '\u{1fd33}\u4a5b\u95e7\u06e1\u0326\u9148\u4a0c', colorFormats: ['r32uint', 'r32uint']});
let renderBundle0 = renderBundleEncoder1.finish({});
let sampler0 = device0.createSampler({
  label: '\u007a\ub3cc\ua247\u0397\ub5b6\u081f\u4584\u09b2',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 85.92,
  lodMaxClamp: 86.40,
});
try {
renderBundleEncoder0.setVertexBuffer(5583, undefined, 1966748848, 600005531);
} catch {}
let img0 = await imageWithData(179, 245, '#c2ceed2c', '#940dc4e9');
try {
offscreenCanvas0.getContext('webgl2');
} catch {}
let bindGroupLayout1 = device0.createBindGroupLayout({
  label: '\u0c2d\u488e\u10bd\u{1f957}\uacc9\u0f06\u51d1\u1255\u{1fe4f}\u0dc5\u0fb7',
  entries: [{binding: 2477, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}}],
});
let commandEncoder3 = device0.createCommandEncoder({});
let bindGroup0 = device0.createBindGroup({
  label: '\u02ef\u8d87\u2fde',
  layout: bindGroupLayout0,
  entries: [
    {binding: 55, resource: sampler0},
    {binding: 1303, resource: externalTexture0},
    {binding: 2198, resource: sampler0},
  ],
});
let texture0 = device0.createTexture({
  label: '\u5f51\u09b4\ue54b\u7287\u{1fbd6}',
  size: {width: 240, height: 768, depthOrArrayLayers: 929},
  mipLevelCount: 5,
  format: 'astc-12x12-unorm-srgb',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let bindGroup1 = device0.createBindGroup({
  label: '\u5d24\uc9e3\u03c5',
  layout: bindGroupLayout0,
  entries: [
    {binding: 55, resource: sampler0},
    {binding: 2198, resource: sampler0},
    {binding: 1303, resource: externalTexture0},
  ],
});
let pipelineLayout0 = device0.createPipelineLayout({bindGroupLayouts: [bindGroupLayout1]});
let texture1 = device0.createTexture({
  size: {width: 1920, height: 1, depthOrArrayLayers: 342},
  mipLevelCount: 8,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let textureView0 = texture1.createView({
  label: '\ua3c0\u{1f90f}\u0053\u0e21\u799a\u6c80\ube9b\u0024\u0bed\u5283',
  dimension: '2d',
  baseMipLevel: 7,
  baseArrayLayer: 286,
});
let computePassEncoder0 = commandEncoder2.beginComputePass();
let sampler1 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 46.97,
  lodMaxClamp: 90.63,
  maxAnisotropy: 1,
});
try {
computePassEncoder0.setBindGroup(2, bindGroup0, new Uint32Array(6784), 2831, 0);
} catch {}
try {
renderBundleEncoder0.setVertexBuffer(7202, undefined, 3106359825, 1175901162);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 1,
  origin: {x: 6, y: 0, z: 74},
  aspect: 'all',
}, new Float32Array(new ArrayBuffer(48)), /* required buffer size: 7_702_335 */
{offset: 351, bytesPerRow: 1823, rowsPerImage: 128}, {width: 408, height: 1, depthOrArrayLayers: 34});
} catch {}
let shaderModule0 = device0.createShaderModule({
  label: '\u{1f9fa}\ubaa2\u7963',
  code: `@group(0) @binding(2477)
var<storage, read_write> type0: 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 S1 {
  @builtin(sample_mask) f0: u32
}
struct FragmentOutput0 {
  @location(4) f0: vec4<u32>,
  @location(1) f1: vec4<u32>,
  @location(0) f2: vec2<u32>,
  @location(7) f3: vec2<f32>
}

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

struct S0 {
  @location(2) f0: f16,
  @location(14) f1: vec4<f16>,
  @location(0) f2: vec2<f32>,
  @location(12) f3: vec2<u32>,
  @location(1) f4: i32,
  @location(3) f5: vec3<u32>,
  @location(9) f6: vec3<f32>
}

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

`,
  hints: {},
});
let bindGroupLayout2 = device0.createBindGroupLayout({entries: []});
let commandEncoder4 = device0.createCommandEncoder({});
let textureView1 = texture0.createView({label: '\u87d1\u{1fa9b}\u0655', dimension: '2d', baseMipLevel: 0, baseArrayLayer: 308});
let sampler2 = device0.createSampler({
  label: '\u0890\uf5ab\u0faa\u0a22\u0274\ub257\u018a\u0841',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.02,
  lodMaxClamp: 99.63,
  maxAnisotropy: 12,
});
try {
renderBundleEncoder0.setBindGroup(0, bindGroup0);
} catch {}
let shaderModule1 = device0.createShaderModule({
  label: '\uc157\u03ff\u5efd\u{1f6a8}\u12ea\uc2f5\u{1fe32}\u{1fa1a}\u0773\u52cc\u{1f6e0}',
  code: `@group(0) @binding(2477)
var<storage, read_write> parameter0: 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 S2 {
  @builtin(front_facing) f0: bool,
  @builtin(position) f1: vec4<f32>,
  @builtin(sample_mask) f2: u32,
  @builtin(sample_index) f3: u32
}
struct FragmentOutput0 {
  @location(1) f0: u32,
  @location(3) f1: u32,
  @location(0) f2: vec4<u32>,
  @location(6) f3: vec4<f32>
}

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


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

`,
  sourceMap: {},
  hints: {},
});
let bindGroup2 = device0.createBindGroup({
  label: '\ue598\u0b18\u{1fa10}\u03ed',
  layout: bindGroupLayout0,
  entries: [
    {binding: 2198, resource: sampler1},
    {binding: 1303, resource: externalTexture0},
    {binding: 55, resource: sampler0},
  ],
});
let commandEncoder5 = device0.createCommandEncoder({label: '\u9d48\u{1f754}\u2418\u2a73\u12da\u{1f6b6}\u0df6'});
let texture2 = device0.createTexture({
  label: '\u6d49\u27ea\u5213\u9635\u043a\u0367\u00a9\u4444\udfb8',
  size: {width: 1401, height: 1, depthOrArrayLayers: 1069},
  mipLevelCount: 10,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint'],
});
let textureView2 = texture0.createView({
  label: '\ua043\u5f39\u6909',
  baseMipLevel: 1,
  mipLevelCount: 3,
  baseArrayLayer: 719,
  arrayLayerCount: 12,
});
try {
renderBundleEncoder0.setBindGroup(3, bindGroup1, new Uint32Array(7084), 4489, 0);
} catch {}
let commandEncoder6 = device0.createCommandEncoder({label: '\u1a66\u4ed9\u0546\u0683\u9fd5\u35a0\u09d9\u06fc\u6af5'});
let computePassEncoder1 = commandEncoder5.beginComputePass({});
let renderBundle1 = renderBundleEncoder0.finish({label: '\u{1ff44}\u076e\uc8b4\uc9ff\uca7a\uc4f3\u0c8a\u847b\u{1f7b8}\u9a67'});
let sampler3 = device0.createSampler({
  label: '\u0286\ufc7d\uce35\uef91\u{1fa58}\u{1ff0d}\u5680\u0821\u69fb\u{1f94e}\u0031',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 85.70,
  lodMaxClamp: 92.39,
  maxAnisotropy: 13,
});
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float', 'rgba16float', 'rgba16float'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let commandEncoder7 = device0.createCommandEncoder();
let textureView3 = texture1.createView({
  label: '\u994d\u03c4\u{1fcb4}\u2662\u{1f9ba}\u0cef\u2de3\u7f86\u9013',
  baseMipLevel: 5,
  mipLevelCount: 1,
  baseArrayLayer: 182,
  arrayLayerCount: 56,
});
try {
computePassEncoder0.setBindGroup(5, bindGroup1);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 3,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(32), /* required buffer size: 49_091_917 */
{offset: 333, bytesPerRow: 764, rowsPerImage: 251}, {width: 123, height: 0, depthOrArrayLayers: 257});
} catch {}
offscreenCanvas0.width = 744;
let bindGroup3 = device0.createBindGroup({
  label: '\u4654\u259f\ude77\u07ef\u{1f7c4}',
  layout: bindGroupLayout0,
  entries: [
    {binding: 55, resource: sampler0},
    {binding: 2198, resource: sampler3},
    {binding: 1303, resource: externalTexture0},
  ],
});
let texture3 = device0.createTexture({
  label: '\u{1f8fd}\u708f\u{1fea5}\u{1f9b2}\u36d5',
  size: {width: 350, height: 1, depthOrArrayLayers: 1546},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['r32uint'],
});
let renderBundle2 = renderBundleEncoder0.finish({label: '\u0469\u02e1\u7e01\u{1f887}\u{1f811}\u1046\u42a9\u7854\u{1fcd9}\u23ad'});
let externalTexture1 = device0.importExternalTexture({label: '\ue1ea\u22d8\uf758\u{1ff16}', source: videoFrame0, colorSpace: 'srgb'});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline0 = device0.createComputePipeline({
  label: '\u54fb\u1852\u{1f6d6}\ud63b\u1867\u08c8\u{1fd15}\u7cd4\u0a74\u57de',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout3 = device0.createBindGroupLayout({label: '\u021b\u08b6', entries: []});
let commandEncoder8 = device0.createCommandEncoder({label: '\u0852\u0b6c\u0280\udcdb\u778c\u621f\u6064\u0f82\u098d\ud6dd\u5f4c'});
let pipeline1 = await device0.createRenderPipelineAsync({
  label: '\ue594\ub7de\uadea\uee18\u0836',
  layout: pipelineLayout0,
  multisample: {mask: 0x98d60d77},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'greater', failOp: 'decrement-clamp', passOp: 'increment-clamp'},
    stencilBack: {compare: 'less', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'replace'},
    stencilReadMask: 2912537652,
    depthBias: -1496461161,
    depthBiasSlopeScale: 227.52209491668606,
  },
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 4500,
        attributes: [
          {format: 'sint32x4', offset: 880, shaderLocation: 15},
          {format: 'sint32x4', offset: 168, shaderLocation: 5},
          {format: 'unorm8x4', offset: 656, shaderLocation: 9},
        ],
      },
      {arrayStride: 12168, attributes: [{format: 'sint8x2', offset: 5672, shaderLocation: 13}]},
      {
        arrayStride: 12076,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 2892, shaderLocation: 10},
          {format: 'float16x4', offset: 752, shaderLocation: 2},
          {format: 'unorm8x2', offset: 6852, shaderLocation: 6},
          {format: 'snorm8x4', offset: 648, shaderLocation: 4},
          {format: 'uint32x4', offset: 1036, shaderLocation: 3},
          {format: 'uint8x2', offset: 908, shaderLocation: 12},
          {format: 'unorm16x2', offset: 1604, shaderLocation: 0},
          {format: 'uint8x4', offset: 3896, shaderLocation: 7},
          {format: 'float16x2', offset: 928, shaderLocation: 11},
          {format: 'float32', offset: 3548, shaderLocation: 8},
          {format: 'snorm8x4', offset: 1580, shaderLocation: 14},
          {format: 'sint32x4', offset: 88, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back'},
});
let video0 = await videoWithData();
let bindGroup4 = device0.createBindGroup({label: '\u664a\u{1fd7f}\ub81d\u{1f8fe}', layout: bindGroupLayout3, entries: []});
let commandEncoder9 = device0.createCommandEncoder({});
let renderBundle3 = renderBundleEncoder1.finish({label: '\uafd2\u0d91\u{1fd32}\ucf34\u{1faa2}\u6df2\u{1fca2}\u46c2\u49d4\u34e0'});
try {
computePassEncoder0.end();
} catch {}
let offscreenCanvas2 = new OffscreenCanvas(706, 1004);
let imageBitmap0 = await createImageBitmap(videoFrame0);
let bindGroup5 = device0.createBindGroup({
  layout: bindGroupLayout0,
  entries: [
    {binding: 1303, resource: externalTexture1},
    {binding: 2198, resource: sampler3},
    {binding: 55, resource: sampler0},
  ],
});
let computePassEncoder2 = commandEncoder4.beginComputePass({});
let externalTexture2 = device0.importExternalTexture({
  label: '\u1412\u2f43\u1bf3\u6941\u02bb\udbb8\u{1fb81}\u9a7b\u{1f6bf}\u41ad',
  source: video0,
  colorSpace: 'srgb',
});
try {
computePassEncoder2.setBindGroup(3, bindGroup0);
} catch {}
try {
computePassEncoder2.setBindGroup(5, bindGroup5, new Uint32Array(2682), 2499, 0);
} catch {}
try {
offscreenCanvas2.getContext('bitmaprenderer');
} catch {}
let buffer0 = device0.createBuffer({
  label: '\u041c\u8952\u0077\u99e5\u007a\u{1fd92}\ub34f\u{1f60a}',
  size: 529896,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
let textureView4 = texture1.createView({
  label: '\ub681\u3ea7\u0ee4\u1d09\u00ee\u07ce',
  dimension: '2d',
  baseMipLevel: 5,
  mipLevelCount: 1,
  baseArrayLayer: 101,
});
let renderBundleEncoder2 = device0.createRenderBundleEncoder({
  label: '\u{1ff41}\u0c4c\u0b06\u8de0\u5d74\ucfa9',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
device0.pushErrorScope('internal');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 7,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new DataView(new ArrayBuffer(0)), /* required buffer size: 29_309_310 */
{offset: 48, bytesPerRow: 311, rowsPerImage: 278}, {width: 11, height: 0, depthOrArrayLayers: 340});
} catch {}
let promise2 = device0.queue.onSubmittedWorkDone();
offscreenCanvas1.height = 3294;
try {
  await adapter1.requestAdapterInfo();
} catch {}
let commandBuffer2 = commandEncoder9.finish({label: '\u{1ff4a}\u2ad4\u73a5\uaca7\u{1f850}'});
let texture4 = device0.createTexture({
  size: {width: 700, height: 1, depthOrArrayLayers: 1282},
  mipLevelCount: 6,
  sampleCount: 1,
  dimension: '3d',
  format: 'r16uint',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16uint', 'r16uint'],
});
let renderBundleEncoder3 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true});
let renderBundle4 = renderBundleEncoder3.finish({label: '\ubaa6\u028b\u2fae\u{1f79c}\udeb8\u{1ff1b}'});
try {
computePassEncoder2.setPipeline(pipeline0);
} catch {}
try {
renderBundleEncoder2.setBindGroup(4, bindGroup2, new Uint32Array(9890), 9207, 0);
} catch {}
try {
  await promise2;
} catch {}
let video1 = await videoWithData();
let textureView5 = texture0.createView({baseMipLevel: 1, baseArrayLayer: 215, arrayLayerCount: 205});
let renderBundle5 = renderBundleEncoder2.finish();
let externalTexture3 = device0.importExternalTexture({
  label: '\u2115\u{1f638}\u6c66\u{1fca6}\ufcee\u{1fbb2}\u59aa\u6c1e\u0fda\u{1fc8e}\u1be1',
  source: video0,
  colorSpace: 'display-p3',
});
try {
computePassEncoder1.setBindGroup(3, bindGroup4);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['bgra8unorm', 'bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
adapter0.label = '\u{1fd49}\u0e01';
} catch {}
let shaderModule2 = device0.createShaderModule({
  label: '\ua2f5\u{1f906}\u0d45\u{1f989}\u{1f95c}\ud6b0\u41cd',
  code: `@group(0) @binding(2477)
var<storage, read_write> field0: 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: u32,
  @location(1) f1: vec3<u32>
}

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

struct VertexOutput0 {
  @location(51) f0: vec2<f16>,
  @location(15) f1: vec4<f16>,
  @location(43) f2: f16,
  @location(19) f3: vec4<f16>,
  @location(16) f4: vec2<f16>,
  @location(20) f5: vec3<f16>,
  @location(67) f6: vec2<u32>,
  @location(18) f7: vec3<f32>,
  @location(34) f8: vec2<i32>,
  @location(58) f9: i32,
  @location(25) f10: vec4<f16>,
  @location(13) f11: i32,
  @location(35) f12: vec3<i32>,
  @location(32) f13: f16,
  @location(12) f14: i32,
  @location(55) f15: vec3<u32>,
  @location(24) f16: vec3<i32>,
  @location(60) f17: vec2<i32>,
  @location(1) f18: vec3<f32>,
  @location(54) f19: vec3<i32>,
  @location(10) f20: vec3<f32>,
  @location(63) f21: i32,
  @builtin(position) f22: vec4<f32>,
  @location(47) f23: vec3<f32>,
  @location(22) f24: vec2<f16>,
  @location(38) f25: vec2<i32>,
  @location(68) f26: f32
}

@vertex
fn vertex0(@builtin(instance_index) a0: u32, @location(9) a1: u32, @location(8) a2: vec4<f16>, @location(4) a3: vec3<i32>, @location(14) a4: vec4<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder10 = device0.createCommandEncoder({label: '\u{1fa65}\u8207\ua8b4\u0213\u0432\u555f\u{1fee9}'});
let textureView6 = texture1.createView({dimension: '2d', baseMipLevel: 6, baseArrayLayer: 312});
let renderBundleEncoder4 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true, stencilReadOnly: true});
let sampler4 = device0.createSampler({
  label: '\u{1f9d6}\uee7d\u9e3a\u9564\uafde\ua30e\u3424\u24e1\u7461\u{1ff62}\u2987',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 11.12,
  lodMaxClamp: 32.46,
  maxAnisotropy: 19,
});
try {
commandEncoder7.clearBuffer(buffer0, 304092, 39096);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline2 = device0.createComputePipeline({
  label: '\u{1fca3}\u{1fa08}\u016a\u7256\u0e37\uae6a',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let bindGroup6 = device0.createBindGroup({label: '\u1673\u{1feb5}', layout: bindGroupLayout3, entries: []});
let querySet0 = device0.createQuerySet({label: '\ua29b\u03de', type: 'occlusion', count: 814});
let texture5 = device0.createTexture({
  size: {width: 120, height: 384, depthOrArrayLayers: 171},
  mipLevelCount: 6,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32float', 'r32float'],
});
let textureView7 = texture1.createView({label: '\u05ad\u1988\u0843\u7c67\u992c\ud9c7', dimension: '2d', baseMipLevel: 6, baseArrayLayer: 264});
let renderBundleEncoder5 = device0.createRenderBundleEncoder({
  label: '\u8d90\u92f5\u57a4\ue7c9\u7206',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder4.setVertexBuffer(3965, undefined, 0);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture5,
  mipLevel: 2,
  origin: {x: 2, y: 51, z: 13},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 9, depthOrArrayLayers: 4});
} catch {}
try {
commandEncoder3.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let bindGroup7 = device0.createBindGroup({label: '\u4679\u201c\u{1fb14}\uc673', layout: bindGroupLayout3, entries: []});
let commandEncoder11 = device0.createCommandEncoder({label: '\uf1ae\u085b\u{1fd8d}'});
let commandBuffer3 = commandEncoder7.finish({label: '\u8385\u90a7\ue850\u7da0\u7c49'});
let renderBundleEncoder6 = device0.createRenderBundleEncoder({
  label: '\u646c\u04e8\u0616\u0b15\u{1fec2}\uab5d',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture4 = device0.importExternalTexture({
  label: '\u0af6\u{1fd16}\u{1f8e2}\u{1fcff}\u024a\u{1f6df}\u{1fa38}\ucbb3\uc66e\ub62c\u7002',
  source: videoFrame0,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder4.setBindGroup(5, bindGroup3, new Uint32Array(2354), 1048, 0);
} catch {}
try {
commandEncoder8.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline3 = await device0.createComputePipelineAsync({
  label: '\u70aa\u1d27\u41b7\u7550\u7c7c\u079a\u3c27\u{1fb0a}\u9301\uc1f2\u8ba6',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let videoFrame1 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let pipelineLayout1 = device0.createPipelineLayout({label: '\u30a3\u027c\uea97', bindGroupLayouts: []});
let computePassEncoder3 = commandEncoder3.beginComputePass({label: '\u3c05\u0f2e\u{1f619}\u{1f723}'});
try {
renderBundleEncoder6.setVertexBuffer(7666, undefined);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
try {
commandEncoder8.insertDebugMarker('\u6d48');
} catch {}
let commandEncoder12 = device0.createCommandEncoder({});
let textureView8 = texture1.createView({
  label: '\u01f7\u1208\u1989\uc1f0',
  baseMipLevel: 6,
  mipLevelCount: 1,
  baseArrayLayer: 191,
  arrayLayerCount: 147,
});
let computePassEncoder4 = commandEncoder6.beginComputePass({label: '\u707e\u4bde\u8d62\u3fc4\u0606'});
let renderBundle6 = renderBundleEncoder5.finish({label: '\u04c2\u0e49\u072a\uf1de\u5c8a\u0a30'});
let externalTexture5 = device0.importExternalTexture({
  label: '\u{1f7b4}\u0ca1\u{1f60b}\u7ca2\u0d1e\u{1fb56}\ucfa4\u74c4\ua790',
  source: videoFrame0,
  colorSpace: 'srgb',
});
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder4.setBindGroup(4, bindGroup3);
} catch {}
try {
commandEncoder10.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm-srgb', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let pipeline4 = device0.createComputePipeline({
  label: '\u{1fb2a}\u{1f776}\u85b2\u097c\u066d\u2cbe\u02a1',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let pipeline5 = await device0.createRenderPipelineAsync({
  label: '\u0384\u0e5a\u{1fea3}\u321b\u249c\u0b39\u0043\u{1fb55}\ub0ab\u0c91\u05d0',
  layout: pipelineLayout0,
  multisample: {count: 4, mask: 0xa998be1d},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint'}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less',
    stencilFront: {compare: 'greater-equal', failOp: 'zero', passOp: 'replace'},
    stencilBack: {compare: 'not-equal', failOp: 'decrement-clamp', depthFailOp: 'increment-clamp', passOp: 'invert'},
    stencilReadMask: 99745716,
    stencilWriteMask: 898694763,
    depthBiasSlopeScale: 0.0,
    depthBiasClamp: 176.07212433408068,
  },
  vertex: {module: shaderModule1, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'ccw', unclippedDepth: true},
});
gc();
let video2 = await videoWithData();
let bindGroupLayout4 = device0.createBindGroupLayout({
  entries: [
    {
      binding: 3796,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
    {binding: 3374, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let commandEncoder13 = device0.createCommandEncoder({label: '\uaa59\u{1fab1}\u{1f9d2}\u3372\udd89\udf1e\u3a7b\u{1f765}\u04f7\u{1f71a}\u{1fd2a}'});
let commandBuffer4 = commandEncoder10.finish({label: '\uc49c\ue976\u{1f8be}\u0ab7'});
let sampler5 = device0.createSampler({
  label: '\ud788\u06f1',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 85.02,
  lodMaxClamp: 96.79,
  maxAnisotropy: 3,
});
let externalTexture6 = device0.importExternalTexture({label: '\ub4ab\u02ed\u10b4', source: video1, colorSpace: 'display-p3'});
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
try {
device0.queue.submit([commandBuffer3, commandBuffer1, commandBuffer4, commandBuffer0]);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 0,
  origin: {x: 3, y: 31, z: 72},
  aspect: 'all',
}, new Int16Array(new ArrayBuffer(56)), /* required buffer size: 498_694 */
{offset: 294, bytesPerRow: 412, rowsPerImage: 502}, {width: 73, height: 206, depthOrArrayLayers: 3});
} catch {}
let pipeline6 = device0.createRenderPipeline({
  label: '\uc408\uce11\u{1fdf5}\u0ecc\u7e29\u4104',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint'}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 4888, attributes: []},
      {
        arrayStride: 10592,
        attributes: [
          {format: 'uint16x2', offset: 680, shaderLocation: 12},
          {format: 'sint32x2', offset: 580, shaderLocation: 13},
          {format: 'sint32x2', offset: 5096, shaderLocation: 15},
          {format: 'sint32x4', offset: 980, shaderLocation: 5},
          {format: 'uint16x4', offset: 1076, shaderLocation: 3},
        ],
      },
      {
        arrayStride: 640,
        attributes: [
          {format: 'unorm16x2', offset: 104, shaderLocation: 4},
          {format: 'float32x3', offset: 36, shaderLocation: 2},
          {format: 'unorm8x4', offset: 88, shaderLocation: 9},
          {format: 'snorm8x2', offset: 120, shaderLocation: 10},
          {format: 'float32x3', offset: 76, shaderLocation: 6},
          {format: 'unorm16x2', offset: 140, shaderLocation: 14},
          {format: 'unorm10-10-10-2', offset: 160, shaderLocation: 0},
          {format: 'sint32', offset: 4, shaderLocation: 1},
        ],
      },
      {
        arrayStride: 8516,
        attributes: [
          {format: 'snorm8x2', offset: 1408, shaderLocation: 11},
          {format: 'uint32x3', offset: 480, shaderLocation: 7},
          {format: 'float16x2', offset: 4080, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', cullMode: 'front'},
});
let offscreenCanvas3 = new OffscreenCanvas(88, 244);
let imageBitmap1 = await createImageBitmap(img0);
let textureView9 = texture2.createView({
  label: '\u21fc\u1278\ua02c\ue2e2\u13fb\u0034\u{1fe8f}\udcc7\u0343\u0b93',
  baseMipLevel: 4,
  mipLevelCount: 4,
  arrayLayerCount: 1,
});
let renderBundleEncoder7 = device0.createRenderBundleEncoder({
  label: '\u{1f6c8}\u4a7f\u02a9\uca82',
  colorFormats: ['r32uint', 'r32uint'],
  sampleCount: 1,
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle7 = renderBundleEncoder3.finish({label: '\u{1fa19}\uab21\u28b9'});
try {
computePassEncoder2.setPipeline(pipeline3);
} catch {}
try {
commandEncoder12.copyTextureToTexture({
  texture: texture5,
  mipLevel: 3,
  origin: {x: 2, y: 2, z: 10},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 1,
  origin: {x: 17, y: 5, z: 12},
  aspect: 'all',
},
{width: 4, height: 31, depthOrArrayLayers: 1});
} catch {}
let gpuCanvasContext1 = offscreenCanvas3.getContext('webgpu');
let buffer1 = device0.createBuffer({size: 96532, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder14 = device0.createCommandEncoder({label: '\u{1fcbd}\u818b\u{1f995}\u0f2b\uf372'});
let texture6 = device0.createTexture({
  label: '\u0366\ua925\ufde0',
  size: [960, 1, 589],
  mipLevelCount: 2,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let renderBundle8 = renderBundleEncoder5.finish();
try {
bindGroupLayout3.label = '\u020b\ub55f\u9f26\u0718';
} catch {}
let commandEncoder15 = device0.createCommandEncoder({label: '\u7a05\ue307\u0739'});
let textureView10 = texture5.createView({label: '\ued90\u77f5\u3a47\u9334\ud699\ua1ff\ud878\u2271', baseMipLevel: 3, mipLevelCount: 2});
try {
computePassEncoder1.setPipeline(pipeline0);
} catch {}
let pipeline7 = await device0.createComputePipelineAsync({
  label: '\u5807\u046f\uc706',
  layout: pipelineLayout0,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let canvas0 = document.createElement('canvas');
let pipelineLayout2 = device0.createPipelineLayout({
  label: '\u76a8\u1ed9\ueef9\uc24e\u{1fc40}\u09eb\u026d',
  bindGroupLayouts: [bindGroupLayout2, bindGroupLayout2, bindGroupLayout0, bindGroupLayout1, bindGroupLayout1, bindGroupLayout4, bindGroupLayout0],
});
try {
commandEncoder12.copyBufferToBuffer(buffer1, 41624, buffer0, 149572, 30820);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder11.insertDebugMarker('\ud6f1');
} catch {}
let imageData1 = new ImageData(4, 56);
let commandBuffer5 = commandEncoder12.finish({label: '\u9512\u0eea\u8b4d\u{1f98c}\u{1fb35}'});
let computePassEncoder5 = commandEncoder8.beginComputePass({label: '\u{1f8d6}\u6741\u00c3\u078f\u6b8d\u0c07\u3642'});
try {
computePassEncoder2.setBindGroup(4, bindGroup0, new Uint32Array(7651), 4156, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(3802, undefined, 1945201148);
} catch {}
let arrayBuffer0 = buffer0.getMappedRange(0, 462044);
try {
device0.queue.label = '\u8a22\u053f\u0f20\ue618\u6729';
} catch {}
let querySet1 = device0.createQuerySet({label: '\u01c0\ua702\u7bc2\u0cd4\u20f0\u9a0b', type: 'occlusion', count: 3231});
let commandBuffer6 = commandEncoder15.finish({});
let texture7 = device0.createTexture({
  label: '\u{1fb3c}\u03c9\u23c4\u5d4a\u02a0\u0778',
  size: {width: 3840},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint', 'r32uint'],
});
let textureView11 = texture1.createView({
  label: '\u{1f881}\u300d\u{1fa9a}\u39d7',
  dimension: '2d-array',
  baseMipLevel: 3,
  mipLevelCount: 4,
  baseArrayLayer: 212,
  arrayLayerCount: 109,
});
let computePassEncoder6 = commandEncoder2.beginComputePass();
let renderBundleEncoder8 = device0.createRenderBundleEncoder({label: '\uea04\udf68\u{1fca6}', colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true});
try {
renderBundleEncoder8.setPipeline(pipeline6);
} catch {}
try {
commandEncoder14.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let commandEncoder16 = device0.createCommandEncoder({label: '\u316b\u7e5e\u0f68\u{1f809}\u77ff'});
let renderBundle9 = renderBundleEncoder8.finish();
let externalTexture7 = device0.importExternalTexture({label: '\u08f8\u{1fbde}\u0e72\ud33b\u0edb\u1a16', source: video2, colorSpace: 'display-p3'});
try {
renderBundleEncoder7.setBindGroup(4, bindGroup7, new Uint32Array(8247), 1241, 0);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(3925, undefined, 0, 1679238757);
} catch {}
try {
device0.pushErrorScope('validation');
} catch {}
try {
commandEncoder14.copyBufferToBuffer(buffer1, 1788, buffer0, 343808, 90632);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.submit([commandBuffer5]);
} catch {}
let gpuCanvasContext2 = canvas0.getContext('webgpu');
let imageData2 = new ImageData(92, 96);
let bindGroup8 = device0.createBindGroup({
  label: '\u039e\u0820\u{1fcdc}\u{1fabf}\u{1fdd4}\u01a7\u{1f6de}',
  layout: bindGroupLayout0,
  entries: [
    {binding: 2198, resource: sampler0},
    {binding: 1303, resource: externalTexture0},
    {binding: 55, resource: sampler0},
  ],
});
let querySet2 = device0.createQuerySet({label: '\u{1fc27}\u{1fb89}\u3d49', type: 'occlusion', count: 3414});
let textureView12 = texture1.createView({label: '\u0b5f\u463d', baseMipLevel: 7, baseArrayLayer: 9, arrayLayerCount: 291});
try {
renderBundleEncoder4.setBindGroup(4, bindGroup8);
} catch {}
try {
commandEncoder13.copyBufferToBuffer(buffer1, 51740, buffer0, 204484, 27480);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer0);
} catch {}
try {
computePassEncoder4.insertDebugMarker('\u0f3d');
} catch {}
let imageData3 = new ImageData(52, 156);
let buffer2 = device0.createBuffer({size: 192112, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ, mappedAtCreation: true});
let computePassEncoder7 = commandEncoder16.beginComputePass({label: '\u8ac5\udf0c\u53a1\uad78\u{1f698}\u{1f9b1}\u3d7b\u0db5'});
try {
renderBundleEncoder4.setPipeline(pipeline6);
} catch {}
try {
commandEncoder14.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let promise3 = device0.queue.onSubmittedWorkDone();
let pipeline8 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  multisample: {mask: 0xe7fdf9bc},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE}, {format: 'r32uint'}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {
      compare: 'less-equal',
      failOp: 'decrement-clamp',
      depthFailOp: 'increment-wrap',
      passOp: 'increment-clamp',
    },
    stencilBack: {compare: 'equal', failOp: 'replace', depthFailOp: 'invert', passOp: 'zero'},
    stencilReadMask: 3741752631,
    stencilWriteMask: 888725712,
    depthBiasClamp: 460.390339684998,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 2932,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 708, shaderLocation: 14}],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x3', offset: 4040, shaderLocation: 9},
          {format: 'sint16x2', offset: 2284, shaderLocation: 4},
          {format: 'snorm16x2', offset: 5320, shaderLocation: 8},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'ccw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
try {
commandEncoder13.copyBufferToBuffer(buffer1, 1916, buffer2, 107348, 33992);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 4,
  origin: {x: 5, y: 0, z: 2},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 528_843 */
{offset: 175, bytesPerRow: 28, rowsPerImage: 239}, {width: 0, height: 1, depthOrArrayLayers: 80});
} catch {}
let promise4 = device0.queue.onSubmittedWorkDone();
let pipeline9 = await device0.createComputePipelineAsync({
  label: '\u0c95\u{1fee2}\u84a1\u6de4\u{1fd34}',
  layout: pipelineLayout0,
  compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}},
});
let img1 = await imageWithData(67, 74, '#fb95c76e', '#94d5f2a1');
let videoFrame2 = new VideoFrame(videoFrame0, {timestamp: 0});
let textureView13 = texture3.createView({baseMipLevel: 2, mipLevelCount: 1});
let externalTexture8 = device0.importExternalTexture({source: video2, colorSpace: 'display-p3'});
let pipeline10 = await device0.createComputePipelineAsync({
  label: '\u01ea\u4607',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let pipeline11 = device0.createRenderPipeline({
  layout: pipelineLayout0,
  multisample: {count: 4},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r32uint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'invert', depthFailOp: 'invert', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'not-equal', failOp: 'zero', depthFailOp: 'decrement-clamp', passOp: 'decrement-clamp'},
    stencilReadMask: 3650025643,
    stencilWriteMask: 2496916139,
    depthBiasSlopeScale: 387.2467537514775,
  },
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm10-10-10-2', offset: 84, shaderLocation: 9},
          {format: 'uint8x2', offset: 2910, shaderLocation: 12},
          {format: 'sint8x4', offset: 25824, shaderLocation: 1},
          {format: 'sint32x3', offset: 4108, shaderLocation: 15},
          {format: 'float32x4', offset: 320, shaderLocation: 8},
          {format: 'unorm16x4', offset: 1076, shaderLocation: 2},
          {format: 'snorm16x4', offset: 8844, shaderLocation: 6},
          {format: 'sint32x4', offset: 904, shaderLocation: 5},
          {format: 'float32x2', offset: 19016, shaderLocation: 10},
          {format: 'float32x2', offset: 984, shaderLocation: 4},
          {format: 'uint32x4', offset: 1796, shaderLocation: 7},
          {format: 'float16x4', offset: 6660, shaderLocation: 0},
          {format: 'float32x3', offset: 3620, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 2968,
        attributes: [
          {format: 'unorm16x2', offset: 1388, shaderLocation: 11},
          {format: 'sint16x2', offset: 708, shaderLocation: 13},
          {format: 'uint8x2', offset: 196, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'line-strip', cullMode: 'back', unclippedDepth: true},
});
let pipelineLayout3 = device0.createPipelineLayout({label: '\u{1f90e}\u080d\u027f\u097a', bindGroupLayouts: [bindGroupLayout0, bindGroupLayout1]});
let renderBundle10 = renderBundleEncoder8.finish({label: '\u3d07\u0742\ub2b1\u{1f9c2}\u009e\uab24\u09c1\u0a51\u0c98\u{1fbcb}\u{1fe9d}'});
try {
computePassEncoder7.setBindGroup(4, bindGroup3, new Uint32Array(914), 750, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(620, undefined, 605654637, 3085304421);
} catch {}
let textureView14 = texture3.createView({label: '\u6beb\ue34c', baseMipLevel: 2});
try {
commandEncoder11.copyTextureToTexture({
  texture: texture5,
  mipLevel: 2,
  origin: {x: 0, y: 11, z: 4},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 5,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 0, height: 2, depthOrArrayLayers: 1});
} catch {}
try {
  await promise3;
} catch {}
document.body.prepend(video2);
let canvas1 = document.createElement('canvas');
let imageBitmap2 = await createImageBitmap(offscreenCanvas0);
let texture8 = device0.createTexture({
  label: '\u3f2b\u2639\u66cd\u59a9\u045e\u0431',
  size: [7680, 1, 1],
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView15 = texture7.createView({label: '\u03a1\u{1fb15}\uc015\u{1fbb2}\u0f6c', dimension: '1d', arrayLayerCount: 1});
let computePassEncoder8 = commandEncoder14.beginComputePass({label: '\u8c70\u5a08\uf31f\u72a2\u0c52\u6620\u{1fe70}\uf23b\u261c\u{1fc57}\u01dc'});
try {
commandEncoder13.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 2212 */
  offset: 1696,
  bytesPerRow: 256,
  buffer: buffer1,
}, {
  texture: texture5,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 3, depthOrArrayLayers: 1});
dissociateBuffer(device0, buffer1);
} catch {}
try {
commandEncoder13.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline12 = await device0.createRenderPipelineAsync({
  label: '\uf3fe\u765e\u0984\u09fc\uf39a\u{1f606}\u217f\ud715\u{1f6d3}',
  layout: pipelineLayout0,
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: 0}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'not-equal', failOp: 'increment-wrap', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'less', failOp: 'keep', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilWriteMask: 944860058,
    depthBias: -804575044,
    depthBiasSlopeScale: 306.1584293558759,
    depthBiasClamp: 260.56673564009793,
  },
  vertex: {module: shaderModule1, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: true},
});
let querySet3 = device0.createQuerySet({type: 'occlusion', count: 448});
let externalTexture9 = device0.importExternalTexture({label: '\u3b2e\u00ce\u1b91', source: videoFrame2, colorSpace: 'srgb'});
try {
renderBundleEncoder6.setBindGroup(1, bindGroup6);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline6);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 1,
  origin: {x: 858, y: 0, z: 66},
  aspect: 'all',
}, new ArrayBuffer(64), /* required buffer size: 3_388_420 */
{offset: 740, bytesPerRow: 312, rowsPerImage: 141}, {width: 74, height: 1, depthOrArrayLayers: 78});
} catch {}
try {
  await promise4;
} catch {}
try {
canvas1.getContext('webgpu');
} catch {}
let renderBundle11 = renderBundleEncoder5.finish({});
try {
computePassEncoder4.setPipeline(pipeline2);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder7.setVertexBuffer(5091, undefined);
} catch {}
try {
  await buffer1.mapAsync(GPUMapMode.WRITE, 68440, 924);
} catch {}
try {
commandEncoder11.clearBuffer(buffer0, 429232);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline13 = device0.createComputePipeline({
  label: '\u08db\u0991\uaa38\u{1fe91}',
  layout: pipelineLayout3,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let pipeline14 = await device0.createRenderPipelineAsync({
  label: '\u{1f9b2}\u09a3',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {format: 'r32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 1420,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 124, shaderLocation: 4},
          {format: 'float32x3', offset: 168, shaderLocation: 11},
          {format: 'snorm8x4', offset: 484, shaderLocation: 2},
          {format: 'sint32x4', offset: 224, shaderLocation: 1},
          {format: 'uint32x3', offset: 896, shaderLocation: 3},
          {format: 'float16x4', offset: 652, shaderLocation: 8},
          {format: 'uint32x3', offset: 40, shaderLocation: 7},
        ],
      },
      {arrayStride: 5544, attributes: [{format: 'float32x3', offset: 1272, shaderLocation: 6}]},
      {
        arrayStride: 5100,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x2', offset: 1636, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 4800, shaderLocation: 9},
          {format: 'float32', offset: 28, shaderLocation: 0},
          {format: 'sint32', offset: 340, shaderLocation: 15},
          {format: 'float32x3', offset: 124, shaderLocation: 14},
          {format: 'uint16x4', offset: 2860, shaderLocation: 12},
          {format: 'sint16x2', offset: 628, shaderLocation: 13},
        ],
      },
      {arrayStride: 2220, attributes: [{format: 'sint32x3', offset: 60, shaderLocation: 5}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'back', unclippedDepth: true},
});
let offscreenCanvas4 = new OffscreenCanvas(565, 394);
let commandEncoder17 = device0.createCommandEncoder();
let commandBuffer7 = commandEncoder11.finish({label: '\u667e\uc184\u3927\u{1fdcb}'});
let renderBundleEncoder9 = device0.createRenderBundleEncoder({
  label: '\u{1fb10}\ue0f3\u0196\u0060\u8263\u6084\u3f7b\u0426\uf512',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: true,
});
try {
computePassEncoder8.setBindGroup(2, bindGroup8, new Uint32Array(2282), 1012, 0);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline14);
} catch {}
try {
commandEncoder17.copyBufferToBuffer(buffer1, 27104, buffer0, 329900, 14880);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder17.copyTextureToTexture({
  texture: texture5,
  mipLevel: 2,
  origin: {x: 1, y: 20, z: 2},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 1,
  origin: {x: 5, y: 7, z: 3},
  aspect: 'all',
},
{width: 16, height: 10, depthOrArrayLayers: 35});
} catch {}
try {
commandEncoder17.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline15 = device0.createComputePipeline({
  label: '\u0e88\ufe7d\u{1f850}\u0b64\u1e4b\u0f95\u12d7',
  layout: pipelineLayout2,
  compute: {module: shaderModule2, entryPoint: 'compute0'},
});
let canvas2 = document.createElement('canvas');
let bindGroup9 = device0.createBindGroup({
  label: '\u1bdf\u090a\u064f\u0856\u5aef\u01d0\u01a1\u0f80\u190f\u03b8\u{1fa4d}',
  layout: bindGroupLayout2,
  entries: [],
});
let textureView16 = texture4.createView({baseMipLevel: 2, mipLevelCount: 1});
let computePassEncoder9 = commandEncoder13.beginComputePass({label: '\uec23\u9c0c\ued29\u9c81\u{1fe67}\u06e5'});
let renderPassEncoder0 = commandEncoder17.beginRenderPass({
  colorAttachments: [{
  view: textureView13,
  depthSlice: 375,
  clearValue: { r: 355.0, g: -119.1, b: 762.9, a: -968.0, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView13,
  depthSlice: 36,
  clearValue: { r: -957.7, g: 833.4, b: -67.64, a: -227.8, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 91648402,
});
let renderBundleEncoder10 = device0.createRenderBundleEncoder({
  label: '\u3c86\u4924\u6f04\u062f\u{1f962}\u7336\u0a8a\u0b3a\u4a0c\u{1f7fa}\u088e',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle12 = renderBundleEncoder0.finish({label: '\uf8c3\u5fe4\u{1fa1d}\u6868\u760e\ufd07\uf602'});
try {
renderPassEncoder0.setBlendConstant({ r: -520.1, g: -820.2, b: 230.9, a: -880.1, });
} catch {}
try {
renderBundleEncoder10.setBindGroup(1, bindGroup2);
} catch {}
let pipeline16 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}});
let bindGroupLayout5 = device0.createBindGroupLayout({
  label: '\u0f3b\u1731\u0d9e',
  entries: [
    {
      binding: 3004,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
    },
    {binding: 424, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 186,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true },
    },
  ],
});
let buffer3 = device0.createBuffer({
  label: '\uca8e\ued5e\u{1f774}\u3596\u4e10\u3854',
  size: 295459,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder18 = device0.createCommandEncoder({label: '\udb6b\u0e9c\u0e3e\u04b1\u505c'});
let commandBuffer8 = commandEncoder18.finish();
try {
computePassEncoder4.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -351.5, g: 250.2, b: -361.3, a: -458.7, });
} catch {}
try {
renderPassEncoder0.setScissorRect(35, 1, 20, 0);
} catch {}
try {
renderPassEncoder0.setStencilReference(368);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline14);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let imageBitmap3 = await createImageBitmap(img0);
let textureView17 = texture3.createView({label: '\u{1fc6a}\u35f1\u010f\u098a', aspect: 'all', format: 'r32uint', baseMipLevel: 1});
try {
renderPassEncoder0.beginOcclusionQuery(947);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle4, renderBundle0, renderBundle0, renderBundle10, renderBundle4, renderBundle3, renderBundle3, renderBundle2]);
} catch {}
let textureView18 = texture7.createView({label: '\u04fc\u90e7', format: 'r32uint'});
let sampler6 = device0.createSampler({
  label: '\u{1fcc0}\u00d9\u{1ffb4}\u{1f607}\u0a5c\u{1f94f}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 80.47,
  lodMaxClamp: 89.55,
  compare: 'not-equal',
});
try {
renderPassEncoder0.setBlendConstant({ r: 149.2, g: 449.4, b: 553.0, a: 623.8, });
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder7.setBindGroup(1, bindGroup7, new Uint32Array(3092), 1235, 0);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder10.pushDebugGroup('\u{1f60d}');
} catch {}
let pipeline17 = await device0.createRenderPipelineAsync({
  label: '\u{1f7c7}\u0aa0\u050a\u0791\u05ca\u{1f9b1}\u1265\u{1fd76}\u6950',
  layout: pipelineLayout1,
  multisample: {},
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'r32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm8x2', offset: 4954, shaderLocation: 4},
          {format: 'snorm16x2', offset: 2812, shaderLocation: 9},
          {format: 'sint8x4', offset: 4104, shaderLocation: 1},
          {format: 'unorm16x2', offset: 820, shaderLocation: 10},
          {format: 'sint32x3', offset: 3424, shaderLocation: 15},
          {format: 'snorm16x4', offset: 3196, shaderLocation: 2},
          {format: 'sint32x2', offset: 3956, shaderLocation: 5},
          {format: 'sint8x2', offset: 102, shaderLocation: 13},
          {format: 'float32x2', offset: 312, shaderLocation: 6},
          {format: 'uint16x2', offset: 2524, shaderLocation: 7},
          {format: 'unorm16x2', offset: 1952, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 14572,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 4308, shaderLocation: 12},
          {format: 'float32x4', offset: 856, shaderLocation: 0},
        ],
      },
      {arrayStride: 5360, attributes: []},
      {
        arrayStride: 3020,
        stepMode: 'instance',
        attributes: [{format: 'uint32x2', offset: 72, shaderLocation: 3}],
      },
      {arrayStride: 768, attributes: []},
      {
        arrayStride: 16196,
        attributes: [
          {format: 'float32x2', offset: 2028, shaderLocation: 14},
          {format: 'float32x4', offset: 3016, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list'},
});
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView19 = texture4.createView({label: '\u9c2f\u{1f92d}\u01fc', baseMipLevel: 4, arrayLayerCount: 1});
try {
renderPassEncoder0.beginOcclusionQuery(2399);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 990.2, g: 7.475, b: 380.5, a: 934.5, });
} catch {}
try {
renderPassEncoder0.setStencilReference(965);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 10},
  aspect: 'all',
}, new Uint8Array(arrayBuffer0), /* required buffer size: 21_768_554 */
{offset: 786, bytesPerRow: 1108, rowsPerImage: 94}, {width: 215, height: 0, depthOrArrayLayers: 210});
} catch {}
let textureView20 = texture6.createView({
  label: '\u0470\u{1fdf2}\u{1fdcf}\uaa97\u{1f77a}\u4609\u0234\uadea\u6ff7\u{1f8f7}',
  baseArrayLayer: 120,
  arrayLayerCount: 294,
});
let externalTexture10 = device0.importExternalTexture({source: videoFrame1});
try {
computePassEncoder1.setBindGroup(5, bindGroup7);
} catch {}
try {
computePassEncoder9.end();
} catch {}
try {
computePassEncoder4.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
try {
buffer1.destroy();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 3,
  origin: {x: 2, y: 3, z: 0},
  aspect: 'all',
}, new Int16Array(arrayBuffer0), /* required buffer size: 374_198 */
{offset: 619, bytesPerRow: 255, rowsPerImage: 81}, {width: 1, height: 8, depthOrArrayLayers: 19});
} catch {}
let pipeline18 = device0.createComputePipeline({layout: pipelineLayout0, compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let imageBitmap4 = await createImageBitmap(offscreenCanvas4);
let textureView21 = texture1.createView({label: '\u00ea\u2130\u011d\u{1f605}\u383b', baseMipLevel: 7, baseArrayLayer: 103, arrayLayerCount: 53});
try {
computePassEncoder5.end();
} catch {}
try {
renderPassEncoder0.setStencilReference(196);
} catch {}
try {
renderBundleEncoder7.setBindGroup(3, bindGroup2);
} catch {}
try {
commandEncoder13.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture1,
  mipLevel: 4,
  origin: {x: 17, y: 0, z: 66},
  aspect: 'all',
}, new Int16Array(new ArrayBuffer(64)), /* required buffer size: 696_655 */
{offset: 107, bytesPerRow: 216, rowsPerImage: 104}, {width: 41, height: 1, depthOrArrayLayers: 32});
} catch {}
let pipeline19 = await device0.createRenderPipelineAsync({
  label: '\u{1fcdc}\u16f8\u14a1\uab93\ud44c\u{1fdc4}',
  layout: pipelineLayout1,
  multisample: {},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {module: shaderModule1, entryPoint: 'vertex0', buffers: []},
});
let gpuCanvasContext3 = offscreenCanvas4.getContext('webgpu');
let offscreenCanvas5 = new OffscreenCanvas(817, 843);
let bindGroupLayout6 = device0.createBindGroupLayout({
  label: '\uf328\uc8c9\u03d7\u8e2e\u32d6\u{1f915}\u09c9\u0a5b\u{1fed2}\ub230\udbfb',
  entries: [
    {
      binding: 832,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 3176,
      visibility: GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
    {
      binding: 1950,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba8unorm', access: 'read-only', viewDimension: '3d' },
    },
  ],
});
let commandBuffer9 = commandEncoder13.finish({label: '\uac18\u0977\u0016\u{1fe8a}\u6a44\u00b9\u6615'});
let textureView22 = texture6.createView({
  label: '\ue253\u{1f953}\u5fa5\u0efa\u05b3\u1f71\ue431\u03ea\ub718\u7f4c',
  dimension: '2d',
  aspect: 'all',
  baseMipLevel: 1,
  baseArrayLayer: 359,
});
let computePassEncoder10 = commandEncoder8.beginComputePass({label: '\uc0dd\ue6d2\u0934\u0287\u062d\uca9a\u6c80\uedeb\u024a\u7d7a\u43ad'});
try {
renderPassEncoder0.beginOcclusionQuery(2565);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -603.5, g: 462.0, b: -48.34, a: 879.1, });
} catch {}
try {
renderBundleEncoder9.setBindGroup(5, bindGroup9);
} catch {}
try {
renderBundleEncoder7.setPipeline(pipeline6);
} catch {}
let promise5 = device0.queue.onSubmittedWorkDone();
let gpuCanvasContext4 = canvas2.getContext('webgpu');
let bindGroupLayout7 = device0.createBindGroupLayout({
  label: '\u{1fef1}\u{1f79d}\u663a\u06d1\u6d2f',
  entries: [
    {binding: 3479, visibility: 0, sampler: { type: 'comparison' }},
    {
      binding: 2527,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      texture: { viewDimension: '2d', sampleType: 'unfilterable-float', multisampled: true },
    },
    {
      binding: 76,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'filtering' },
    },
  ],
});
let textureView23 = texture3.createView({label: '\u{1fd94}\u775f\u0b5a\ud271\u059a\u649b', dimension: '3d', baseMipLevel: 2});
let renderBundle13 = renderBundleEncoder0.finish({label: '\u{1fdfe}\ud435\u5419\u97c3\u408d\u4564'});
try {
renderPassEncoder0.setBindGroup(3, bindGroup2);
} catch {}
try {
renderPassEncoder0.setScissorRect(63, 1, 4, 0);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(8897, undefined, 0);
} catch {}
let gpuCanvasContext5 = offscreenCanvas5.getContext('webgpu');
try {
gpuCanvasContext2.unconfigure();
} catch {}
let shaderModule3 = device0.createShaderModule({
  label: '\u13e3\u{1f604}\uee6a\u0e81\u1d31',
  code: `@group(0) @binding(2477)
var<storage, read_write> field1: array<u32>;

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

struct S3 {
  @location(72) f0: vec4<u32>,
  @location(0) f1: vec3<f32>,
  @location(63) f2: i32,
  @location(59) f3: vec2<f32>,
  @location(27) f4: u32,
  @location(31) f5: vec4<f16>,
  @builtin(front_facing) f6: bool,
  @location(2) f7: vec4<f16>,
  @location(6) f8: vec4<f32>,
  @location(48) f9: vec3<i32>,
  @location(65) f10: vec3<u32>,
  @location(7) f11: vec3<i32>,
  @location(1) f12: vec2<f32>,
  @location(38) f13: vec2<f32>,
  @location(28) f14: vec2<u32>,
  @location(58) f15: i32,
  @location(61) f16: vec4<u32>,
  @location(8) f17: i32,
  @location(60) f18: u32,
  @location(13) f19: vec3<f16>
}
struct FragmentOutput0 {
  @location(1) f0: vec4<u32>,
  @location(0) f1: u32
}

@fragment
fn fragment0(a0: S3, @location(42) a1: vec3<f32>, @location(34) a2: vec2<u32>, @location(39) a3: vec4<u32>, @location(69) a4: vec3<u32>, @builtin(position) a5: vec4<f32>, @builtin(sample_mask) a6: u32, @builtin(sample_index) a7: u32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(58) f27: i32,
  @location(38) f28: vec2<f32>,
  @location(65) f29: vec3<u32>,
  @location(39) f30: vec4<u32>,
  @location(6) f31: vec4<f32>,
  @location(60) f32: u32,
  @location(0) f33: vec3<f32>,
  @location(13) f34: vec3<f16>,
  @location(7) f35: vec3<i32>,
  @location(31) f36: vec4<f16>,
  @location(1) f37: vec2<f32>,
  @location(34) f38: vec2<u32>,
  @location(48) f39: vec3<i32>,
  @location(42) f40: vec3<f32>,
  @location(2) f41: vec4<f16>,
  @builtin(position) f42: vec4<f32>,
  @location(61) f43: vec4<u32>,
  @location(27) f44: u32,
  @location(28) f45: vec2<u32>,
  @location(8) f46: i32,
  @location(69) f47: vec3<u32>,
  @location(59) f48: vec2<f32>,
  @location(63) f49: i32,
  @location(72) f50: vec4<u32>
}

@vertex
fn vertex0(@location(4) a0: vec3<f16>, @location(0) a1: vec2<f16>, @location(12) a2: i32, @location(9) a3: vec3<i32>, @location(8) a4: i32, @location(5) a5: vec3<i32>, @location(13) a6: vec2<u32>, @builtin(vertex_index) a7: u32, @location(3) a8: f32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder19 = device0.createCommandEncoder();
let commandBuffer10 = commandEncoder19.finish({});
let textureView24 = texture0.createView({label: '\u1f70\ubd77\ud40c', dimension: '2d', baseMipLevel: 2, mipLevelCount: 2, baseArrayLayer: 228});
try {
renderPassEncoder0.setBindGroup(1, bindGroup4);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -944.0, g: -779.2, b: 262.6, a: 768.2, });
} catch {}
let offscreenCanvas6 = new OffscreenCanvas(9, 311);
try {
offscreenCanvas6.getContext('webgpu');
} catch {}
let bindGroupLayout8 = device0.createBindGroupLayout({
  label: '\u{1fe8f}\u{1fd7d}\u75ca\u0ecc\u{1f962}',
  entries: [
    {
      binding: 853,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 1373,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
    {
      binding: 3027,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '1d' },
    },
  ],
});
let commandEncoder20 = device0.createCommandEncoder({});
let querySet4 = device0.createQuerySet({
  label: '\udb9d\ub735\u{1f8df}\u9e10\u0009\u6441\u{1fabd}\u3949\u536e\u011f',
  type: 'occlusion',
  count: 1521,
});
let texture9 = device0.createTexture({
  label: '\u0bf8\u021d\ufd2b\u0677\ue4c6\u5f16\u724a',
  size: {width: 30, height: 96, depthOrArrayLayers: 929},
  mipLevelCount: 7,
  sampleCount: 1,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32uint', 'r32uint'],
});
let textureView25 = texture1.createView({dimension: '2d-array', baseMipLevel: 7, baseArrayLayer: 76, arrayLayerCount: 233});
let computePassEncoder11 = commandEncoder20.beginComputePass({label: '\ud47b\u3e6c\u01c0\uac19\u5808\u03b0\ua553\u3657'});
let renderBundle14 = renderBundleEncoder7.finish({});
try {
renderPassEncoder0.setVertexBuffer(4015, undefined);
} catch {}
try {
renderBundleEncoder9.setBindGroup(2, bindGroup6, new Uint32Array(4534), 1807, 0);
} catch {}
let imageBitmap5 = await createImageBitmap(canvas2);
let imageData4 = new ImageData(116, 100);
let querySet5 = device0.createQuerySet({type: 'occlusion', count: 1494});
let textureView26 = texture7.createView({label: '\u1420\u{1fc7d}\u87fa\uf201\ub7a0\u0e0b\u5e1e\u0bd8', aspect: 'all'});
let renderBundleEncoder11 = device0.createRenderBundleEncoder({
  label: '\u{1fd88}\u{1fb80}\ueb3a\ua14c\u4886\u818d',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
});
try {
renderPassEncoder0.setBlendConstant({ r: -439.9, g: 367.9, b: -850.6, a: -568.2, });
} catch {}
try {
renderPassEncoder0.setViewport(81.43, 0.9818, 0.09494, 0.00974, 0.3995, 0.9745);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6508, undefined, 1255649032, 1644377350);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline6);
} catch {}
try {
device0.queue.submit([commandBuffer8, commandBuffer2]);
} catch {}
let pipeline20 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule1, entryPoint: 'compute0', constants: {}}});
try {
  await promise5;
} catch {}
document.body.prepend(video1);
let bindGroupLayout9 = device0.createBindGroupLayout({entries: []});
let textureView27 = texture9.createView({dimension: '2d', baseMipLevel: 6, baseArrayLayer: 98});
try {
renderPassEncoder0.setStencilReference(3266);
} catch {}
try {
renderBundleEncoder9.setPipeline(pipeline14);
} catch {}
offscreenCanvas1.height = 851;
let commandEncoder21 = device0.createCommandEncoder({label: '\ueb57\u67e1\u0a41\ufa91\u5c50\ud1a2\ub110'});
let textureView28 = texture3.createView({baseMipLevel: 2});
let renderPassEncoder1 = commandEncoder21.beginRenderPass({
  label: '\u3b1b\u5f4c',
  colorAttachments: [{view: textureView23, depthSlice: 319, loadOp: 'load', storeOp: 'discard'}, {
  view: textureView28,
  depthSlice: 192,
  clearValue: { r: 303.4, g: -147.1, b: 976.4, a: -961.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet0,
  maxDrawCount: 625695890,
});
try {
renderPassEncoder0.setScissorRect(56, 1, 11, 0);
} catch {}
try {
renderBundleEncoder9.setBindGroup(5, bindGroup3);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline6);
} catch {}
let renderBundle15 = renderBundleEncoder11.finish({label: '\u0d56\u{1f6f4}\ubdeb\u05c9\u05fc'});
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
let pipeline21 = device0.createComputePipeline({
  label: '\u30a6\u083f',
  layout: pipelineLayout1,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
document.body.prepend(img1);
let querySet6 = device0.createQuerySet({label: '\u8e68\uca57', type: 'occlusion', count: 538});
let texture10 = device0.createTexture({
  label: '\udd5e\uce30\ub386',
  size: [60],
  dimension: '1d',
  format: 'rgba8snorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundle16 = renderBundleEncoder9.finish({label: '\u15c4\ue7a4\u{1fcc7}\u9087\u042b\u72ae\u91be\u1201\ucd99\u{1f619}\u04c0'});
let externalTexture11 = device0.importExternalTexture({label: '\u7aec\u0fbb\u0a03\u56e4\u07f5\u07a7\u0bf9', source: video1, colorSpace: 'display-p3'});
try {
renderPassEncoder0.beginOcclusionQuery(870);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setViewport(1.605, 0.9158, 75.06, 0.00666, 0.7938, 0.9449);
} catch {}
let buffer4 = device0.createBuffer({label: '\ub46f\u{1f8ca}', size: 288664, usage: GPUBufferUsage.STORAGE});
let textureView29 = texture3.createView({format: 'r32uint', baseMipLevel: 2, arrayLayerCount: 1});
let renderBundle17 = renderBundleEncoder9.finish();
try {
computePassEncoder3.setBindGroup(4, bindGroup0, new Uint32Array(8374), 4178, 0);
} catch {}
try {
computePassEncoder11.end();
} catch {}
try {
renderPassEncoder0.setStencilReference(3332);
} catch {}
try {
renderPassEncoder0.setViewport(18.81, 0.09637, 65.13, 0.3124, 0.8231, 0.9780);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline6);
} catch {}
try {
commandEncoder20.copyBufferToTexture({
  /* bytesInLastRow: 7564 widthInBlocks: 1891 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18308 */
  offset: 10744,
  buffer: buffer3,
}, {
  texture: texture8,
  mipLevel: 0,
  origin: {x: 917, y: 0, z: 0},
  aspect: 'all',
}, {width: 1891, height: 1, depthOrArrayLayers: 1});
dissociateBuffer(device0, buffer3);
} catch {}
let pipeline22 = await device0.createComputePipelineAsync({layout: 'auto', compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}}});
let renderBundleEncoder12 = device0.createRenderBundleEncoder({
  label: '\u5751\u0c21\u357b\u1dec\ud5db\u232f\u207b\u{1febd}\u5fbd\u0f1a\u19ab',
  colorFormats: ['r32uint', 'r32uint'],
});
let sampler7 = device0.createSampler({
  label: '\ua868\u77a1\uf850\ua12e\ua929\u0105\u0a4e\uf78b\u{1ff36}\u9072',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 99.70,
  lodMaxClamp: 99.82,
  compare: 'less-equal',
  maxAnisotropy: 11,
});
try {
computePassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline17);
} catch {}
try {
commandEncoder20.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
let promise6 = device0.queue.onSubmittedWorkDone();
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
gc();
let bindGroupLayout10 = pipeline12.getBindGroupLayout(0);
let buffer5 = device0.createBuffer({size: 290602, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let querySet7 = device0.createQuerySet({label: '\u098b\ucda1', type: 'occlusion', count: 2781});
let renderPassEncoder2 = commandEncoder20.beginRenderPass({
  label: '\u{1fd60}\u233a\u05b1\u{1f8ae}',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 290,
  clearValue: { r: -367.1, g: -898.0, b: -333.3, a: 744.1, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView13,
  depthSlice: 87,
  clearValue: { r: -154.2, g: 831.4, b: 597.5, a: 816.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet2,
  maxDrawCount: 330885983,
});
let sampler8 = device0.createSampler({
  label: '\u3f90\u099e\u05c9\u3f87',
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'nearest',
  lodMinClamp: 11.42,
  lodMaxClamp: 71.13,
});
try {
renderPassEncoder0.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder1.setViewport(6.201, 0.1203, 80.66, 0.08662, 0.1583, 0.8769);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(9958, undefined, 3112194478, 216448601);
} catch {}
try {
renderBundleEncoder4.setBindGroup(0, bindGroup7, new Uint32Array(3612), 3438, 0);
} catch {}
let offscreenCanvas7 = new OffscreenCanvas(331, 886);
try {
offscreenCanvas7.getContext('webgl2');
} catch {}
let buffer6 = device0.createBuffer({label: '\u042e\u060f', size: 235958, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.UNIFORM});
let texture11 = device0.createTexture({
  label: '\u2d41\u9430\u0485\u{1fbb1}\uc727\uf388\u2a2d\u086b',
  size: {width: 1920, height: 1, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder13 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder1.setBindGroup(3, bindGroup3, new Uint32Array(5409), 3512, 0);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder12.setBindGroup(5, bindGroup7);
} catch {}
let arrayBuffer1 = buffer0.getMappedRange(462048, 40960);
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 0,
  origin: {x: 159, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer0), /* required buffer size: 789 */
{offset: 789, rowsPerImage: 108}, {width: 616, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline23 = device0.createComputePipeline({
  label: '\ub4d3\u8297\u47fd\u0d56\u{1ff8e}\u21df',
  layout: pipelineLayout3,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let img2 = await imageWithData(39, 196, '#5b61f397', '#ccc21185');
let bindGroup10 = device0.createBindGroup({
  label: '\ueb03\ud267\uc307\u0907\u{1fcc0}\u4e1d\u0a04\uefe3\u03c4\u0be7',
  layout: bindGroupLayout3,
  entries: [],
});
let querySet8 = device0.createQuerySet({label: '\u0205\u08d1\ub7eb', type: 'occlusion', count: 1061});
let renderBundleEncoder14 = device0.createRenderBundleEncoder({label: '\uf6ac\u{1fcad}\uefff', colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true});
let renderBundle18 = renderBundleEncoder14.finish({});
let sampler9 = device0.createSampler({
  label: '\u62da\u463f',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 47.96,
  lodMaxClamp: 81.29,
  compare: 'greater',
  maxAnisotropy: 2,
});
try {
renderPassEncoder1.executeBundles([renderBundle18]);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder13.setBindGroup(3, bindGroup10);
} catch {}
let pipeline24 = await device0.createComputePipelineAsync({
  label: '\u3c01\u{1fff9}\u03c7\u{1fe0d}',
  layout: pipelineLayout2,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
gc();
try {
computePassEncoder10.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle15, renderBundle18, renderBundle5]);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 648.2, g: -119.9, b: -530.9, a: -141.0, });
} catch {}
try {
renderPassEncoder0.setViewport(5.056, 0.6367, 9.851, 0.3054, 0.09629, 0.6391);
} catch {}
try {
renderBundleEncoder13.setBindGroup(1, bindGroup0);
} catch {}
let canvas3 = document.createElement('canvas');
let offscreenCanvas8 = new OffscreenCanvas(350, 77);
let commandEncoder22 = device0.createCommandEncoder({});
let renderPassEncoder3 = commandEncoder22.beginRenderPass({
  label: '\u37c5\u431b\u{1f691}\u4015',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 165,
  clearValue: { r: -919.3, g: 115.0, b: 648.0, a: 746.0, },
  loadOp: 'load',
  storeOp: 'store',
}, {view: textureView28, depthSlice: 333, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 1136761990,
});
let renderBundleEncoder15 = device0.createRenderBundleEncoder({
  label: '\u098a\u{1f90a}\u97d4\u00f3\uc115\u047d\u17ca\u8965',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
});
try {
computePassEncoder2.setBindGroup(1, bindGroup3, []);
} catch {}
try {
computePassEncoder1.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder2.beginOcclusionQuery(3321);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle11, renderBundle15, renderBundle9, renderBundle4, renderBundle4, renderBundle14, renderBundle1]);
} catch {}
try {
renderPassEncoder2.setBlendConstant({ r: -38.60, g: 701.2, b: 611.2, a: -120.3, });
} catch {}
try {
renderPassEncoder0.setScissorRect(20, 0, 28, 1);
} catch {}
try {
renderBundleEncoder10.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 3,
  origin: {x: 0, y: 1, z: 2},
  aspect: 'all',
}, new ArrayBuffer(178_659), /* required buffer size: 178_659 */
{offset: 575, bytesPerRow: 208, rowsPerImage: 210}, {width: 9, height: 17, depthOrArrayLayers: 5});
} catch {}
try {
adapter1.label = '\u6905\u2392\u04a2\ub832\u8d82\u{1f6dd}\u051a\u052a\u0be9\u4b36\u{1fa20}';
} catch {}
let shaderModule4 = device0.createShaderModule({
  label: '\u94f5\u0c95\ue664',
  code: `@group(6) @binding(2198)
var<storage, read_write> type1: array<u32>;
@group(4) @binding(2477)
var<storage, read_write> type2: array<u32>;
@group(6) @binding(55)
var<storage, read_write> n0: array<u32>;
@group(2) @binding(2198)
var<storage, read_write> local0: array<u32>;
@group(3) @binding(2477)
var<storage, read_write> local1: array<u32>;
@group(5) @binding(3374)
var<storage, read_write> parameter1: array<u32>;
@group(5) @binding(3796)
var<storage, read_write> parameter2: 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 S5 {
  @location(40) f0: vec2<i32>,
  @builtin(front_facing) f1: bool,
  @builtin(sample_index) f2: u32
}
struct FragmentOutput0 {
  @location(0) f0: vec2<u32>,
  @location(5) f1: i32,
  @location(1) f2: vec4<u32>,
  @location(4) f3: vec2<i32>
}

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

struct S4 {
  @location(9) f0: vec2<i32>
}
struct VertexOutput0 {
  @builtin(position) f51: vec4<f32>,
  @location(40) f52: vec2<i32>
}

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

`,
  hints: {},
});
let buffer7 = device0.createBuffer({
  label: '\u{1fdc4}\u{1f8b8}\u00b4\u0698\u0eda\u01ab\uf1a7\u1008\u04ef\u07e8\u{1f9c7}',
  size: 37817,
  usage: GPUBufferUsage.MAP_READ,
});
let commandEncoder23 = device0.createCommandEncoder({label: '\u{1fbd3}\u0bf6\u0ee9\ub6f3\u0e98\u0bf6\u2efd\u018e\u024d\u{1f6e9}\u0fce'});
let texture12 = device0.createTexture({
  size: {width: 2802},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let renderBundle19 = renderBundleEncoder2.finish({label: '\u7114\u08e2\ueaab\ubfdd\u9034\u0315\u0f72'});
try {
computePassEncoder10.setBindGroup(6, bindGroup3);
} catch {}
try {
renderPassEncoder2.executeBundles([renderBundle19, renderBundle5, renderBundle1, renderBundle8, renderBundle17, renderBundle12, renderBundle5, renderBundle19, renderBundle8, renderBundle13]);
} catch {}
try {
renderPassEncoder3.setStencilReference(3268);
} catch {}
try {
renderPassEncoder3.setPipeline(pipeline19);
} catch {}
try {
commandEncoder23.clearBuffer(buffer2, 115188);
dissociateBuffer(device0, buffer2);
} catch {}
try {
adapter1.label = '\u0efb\u0c73\uf056\u01fb\u{1fbfa}\ue003';
} catch {}
let texture13 = device0.createTexture({
  label: '\u0da6\ue9d6\u59d7\u92c1\u1528\u{1fa4b}\u87e2\u2f35\uffc1',
  size: {width: 1920, height: 1, depthOrArrayLayers: 129},
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let renderBundleEncoder16 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint'], sampleCount: 1});
let sampler10 = device0.createSampler({
  label: '\u00fb\u70d0\u7a90\u73f9\u0a5e',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 46.84,
  lodMaxClamp: 61.92,
});
try {
renderPassEncoder3.setBindGroup(2, bindGroup6);
} catch {}
try {
renderPassEncoder3.setBindGroup(2, bindGroup1, new Uint32Array(7557), 5390, 0);
} catch {}
try {
renderPassEncoder1.setViewport(38.74, 0.7168, 11.35, 0.1327, 0.3438, 0.7958);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer0, 421_702_213);
} catch {}
try {
renderPassEncoder3.drawIndirect(buffer4, 309_750_000);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline17);
} catch {}
try {
commandEncoder23.clearBuffer(buffer2, 22820, 40036);
dissociateBuffer(device0, buffer2);
} catch {}
try {
commandEncoder23.insertDebugMarker('\u{1fdfe}');
} catch {}
try {
gpuCanvasContext0.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float', 'rgba16float'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let canvas4 = document.createElement('canvas');
let commandEncoder24 = device0.createCommandEncoder({label: '\u02f7\ubc24\ufc95\u0bfc\uc312'});
let textureView30 = texture12.createView({label: '\u{1fd07}\ua87f\u05a4\u6322', aspect: 'all'});
try {
commandEncoder24.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline25 = await device0.createRenderPipelineAsync({
  label: '\uc9bb\ufc85\ue01f\u8764\u06a7',
  layout: pipelineLayout1,
  multisample: {mask: 0xee47ce88},
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint'}, {format: 'r32uint', writeMask: GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 8084,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 408, shaderLocation: 5},
          {format: 'float16x2', offset: 648, shaderLocation: 13},
          {format: 'sint32x2', offset: 1176, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 520, shaderLocation: 9},
          {format: 'uint32x4', offset: 304, shaderLocation: 8},
          {format: 'sint16x2', offset: 5168, shaderLocation: 12},
          {format: 'sint32x2', offset: 3564, shaderLocation: 7},
        ],
      },
      {
        arrayStride: 5604,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 80, shaderLocation: 1},
          {format: 'unorm16x2', offset: 408, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 580,
        stepMode: 'instance',
        attributes: [{format: 'uint8x2', offset: 70, shaderLocation: 14}],
      },
      {arrayStride: 7828, attributes: []},
      {
        arrayStride: 1216,
        stepMode: 'instance',
        attributes: [{format: 'uint32', offset: 148, shaderLocation: 3}, {format: 'uint8x4', offset: 72, shaderLocation: 6}],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let bindGroup11 = device0.createBindGroup({
  label: '\u6ff3\u0e09\u82a9\u{1f9dd}\u04c1\u0054\u13a4\u4a21\ue598\u{1fab9}\u{1fd24}',
  layout: bindGroupLayout0,
  entries: [
    {binding: 2198, resource: sampler0},
    {binding: 1303, resource: externalTexture10},
    {binding: 55, resource: sampler0},
  ],
});
let querySet9 = device0.createQuerySet({type: 'occlusion', count: 3124});
let renderBundleEncoder17 = device0.createRenderBundleEncoder({
  label: '\u6116\u13e2\u08f0\ud324\u{1fb40}\u8696\u{1ff25}\uc643\u0009',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: true,
});
let renderBundle20 = renderBundleEncoder17.finish({label: '\ua203\u9d9d'});
try {
renderPassEncoder3.setBindGroup(1, bindGroup7);
} catch {}
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline19);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(6939, undefined, 12065150, 1831184513);
} catch {}
let promise7 = device0.queue.onSubmittedWorkDone();
let commandEncoder25 = device0.createCommandEncoder({label: '\u5f14\ub938\u0f8b'});
let textureView31 = texture7.createView({label: '\ud308\u889f\u7827\u2023'});
let renderPassEncoder4 = commandEncoder23.beginRenderPass({
  colorAttachments: [{
  view: textureView14,
  depthSlice: 158,
  clearValue: { r: 88.96, g: -467.6, b: 317.3, a: -830.5, },
  loadOp: 'load',
  storeOp: 'store',
}, {view: textureView23, depthSlice: 117, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet3,
  maxDrawCount: 995124527,
});
let renderBundleEncoder18 = device0.createRenderBundleEncoder({label: '\u0678\uaf0c\u229d\u{1f73a}\u0ea6', colorFormats: ['r32uint', 'r32uint']});
try {
renderPassEncoder3.executeBundles([renderBundle10]);
} catch {}
try {
renderPassEncoder3.setStencilReference(568);
} catch {}
let arrayBuffer2 = buffer2.getMappedRange(0, 43948);
try {
commandEncoder24.clearBuffer(buffer0, 527972);
dissociateBuffer(device0, buffer0);
} catch {}
let gpuCanvasContext6 = canvas4.getContext('webgpu');
let canvas5 = document.createElement('canvas');
let textureView32 = texture11.createView({label: '\uaeaa\u0b58\u27d0\u834f\ufe5e', dimension: '2d', mipLevelCount: 1});
let sampler11 = device0.createSampler({
  label: '\u{1f994}\u088e\uf26f\u0e0a\u0bb9\uff95\u0853\u891f\u21c5\u7344\u{1f94f}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 67.66,
  lodMaxClamp: 88.41,
});
try {
renderPassEncoder4.setBindGroup(5, bindGroup11);
} catch {}
try {
renderPassEncoder3.setViewport(46.81, 0.7616, 19.50, 0.1596, 0.1404, 0.7030);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer4, 855_457_431);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer4, 733_846_933);
} catch {}
try {
renderBundleEncoder10.setBindGroup(6, bindGroup8);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
try {
querySet8.destroy();
} catch {}
try {
gpuCanvasContext5.configure({
  device: device0,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline26 = device0.createComputePipeline({
  label: '\u06cf\u{1fc22}\u262f',
  layout: pipelineLayout2,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
try {
window.someLabel = externalTexture10.label;
} catch {}
let textureView33 = texture4.createView({baseMipLevel: 2, mipLevelCount: 4});
try {
computePassEncoder4.end();
} catch {}
try {
renderPassEncoder2.setStencilReference(3687);
} catch {}
try {
renderPassEncoder3.draw(20, 5, 130_270_744, 380_455_539);
} catch {}
try {
renderPassEncoder3.setVertexBuffer(880, undefined, 0);
} catch {}
try {
commandEncoder25.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 33},
  aspect: 'all',
}, new ArrayBuffer(15_565_723), /* required buffer size: 15_565_723 */
{offset: 65, bytesPerRow: 6045, rowsPerImage: 143}, {width: 1457, height: 1, depthOrArrayLayers: 19});
} catch {}
let video3 = await videoWithData();
let bindGroupLayout11 = device0.createBindGroupLayout({
  label: '\u9d69\u064b',
  entries: [
    {
      binding: 1338,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
    },
    {binding: 1513, visibility: GPUShaderStage.VERTEX, sampler: { type: 'non-filtering' }},
  ],
});
let querySet10 = device0.createQuerySet({type: 'occlusion', count: 3168});
try {
computePassEncoder10.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(19);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle5, renderBundle5]);
} catch {}
try {
renderPassEncoder4.setScissorRect(35, 1, 6, 0);
} catch {}
try {
renderPassEncoder3.draw(28);
} catch {}
try {
renderPassEncoder3.drawIndexed(82, 9, 805_746_952, 141_834_471, 105_020_914);
} catch {}
try {
renderPassEncoder1.drawIndirect(buffer4, 1_794_095_933);
} catch {}
try {
renderBundleEncoder16.setBindGroup(6, bindGroup8, new Uint32Array(5775), 5233, 0);
} catch {}
try {
renderBundleEncoder15.setPipeline(pipeline17);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture8,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(16), /* required buffer size: 5_870 */
{offset: 846, rowsPerImage: 280}, {width: 1256, height: 1, depthOrArrayLayers: 1});
} catch {}
let pipeline27 = device0.createRenderPipeline({
  label: '\u4b0d\u99b1\u3ed8\u2174\u0416\u20b7\u05e4\u0faf\u8a85\u3055',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: 0}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 1272,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 380, shaderLocation: 2},
          {format: 'uint32x3', offset: 376, shaderLocation: 7},
          {format: 'uint32', offset: 12, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 524, shaderLocation: 0},
          {format: 'sint8x2', offset: 98, shaderLocation: 13},
          {format: 'sint16x2', offset: 816, shaderLocation: 15},
          {format: 'sint32x2', offset: 804, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 124, shaderLocation: 11},
          {format: 'unorm8x4', offset: 176, shaderLocation: 6},
          {format: 'float32', offset: 960, shaderLocation: 10},
          {format: 'float32x4', offset: 92, shaderLocation: 14},
          {format: 'snorm16x2', offset: 132, shaderLocation: 9},
          {format: 'float16x4', offset: 12, shaderLocation: 8},
          {format: 'uint8x2', offset: 108, shaderLocation: 12},
          {format: 'snorm16x2', offset: 172, shaderLocation: 4},
          {format: 'sint16x4', offset: 64, shaderLocation: 1},
        ],
      },
    ],
  },
});
let renderPassEncoder5 = commandEncoder6.beginRenderPass({
  label: '\ud90c\u7acd\u05c8\u6519\u199c\udd35\u10c1\u{1fb97}\u{1fede}',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 234,
  clearValue: { r: -746.5, g: 306.6, b: 823.4, a: -32.77, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {view: textureView29, depthSlice: 31, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 687052000,
});
try {
renderPassEncoder2.setBindGroup(3, bindGroup3);
} catch {}
try {
renderPassEncoder0.executeBundles([renderBundle12, renderBundle11, renderBundle13, renderBundle18, renderBundle13, renderBundle19]);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: 690.5, g: -234.4, b: 703.4, a: 768.9, });
} catch {}
try {
renderPassEncoder5.setStencilReference(3821);
} catch {}
try {
renderPassEncoder1.draw(24, 1, 751_703_563);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer5, 576_261_491);
} catch {}
try {
commandEncoder25.copyBufferToBuffer(buffer1, 74736, buffer2, 41180, 7660);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer2);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 1,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 287 */
{offset: 287, rowsPerImage: 42}, {width: 799, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline28 = device0.createRenderPipeline({
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0xbabe03fc},
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'r32uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 652,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32', offset: 44, shaderLocation: 7},
          {format: 'unorm10-10-10-2', offset: 212, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 108,
        attributes: [
          {format: 'snorm16x4', offset: 40, shaderLocation: 4},
          {format: 'sint32x4', offset: 0, shaderLocation: 2},
          {format: 'uint32', offset: 32, shaderLocation: 1},
          {format: 'uint32x4', offset: 0, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 23012,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 2844, shaderLocation: 5},
          {format: 'uint8x4', offset: 2308, shaderLocation: 3},
          {format: 'uint32x4', offset: 4284, shaderLocation: 14},
          {format: 'sint8x2', offset: 4936, shaderLocation: 12},
          {format: 'uint8x4', offset: 3900, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [{format: 'sint8x4', offset: 4180, shaderLocation: 9}],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
try {
gpuCanvasContext3.unconfigure();
} catch {}
try {
  await promise6;
} catch {}
gc();
try {
adapter1.label = '\ua52e\ue93f\u1f05\u0cdc\u0202\u046e';
} catch {}
let computePassEncoder12 = commandEncoder24.beginComputePass({label: '\u0af4\ubdd1\u{1fc6b}\uf057\u0438\u1137'});
let sampler12 = device0.createSampler({
  label: '\u05b2\u5250\ud1d3\u6fd7',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 27.26,
  lodMaxClamp: 47.12,
  maxAnisotropy: 20,
});
try {
renderPassEncoder2.executeBundles([renderBundle13, renderBundle16, renderBundle3, renderBundle20]);
} catch {}
try {
renderPassEncoder5.setStencilReference(547);
} catch {}
try {
renderPassEncoder3.drawIndexedIndirect(buffer0, 480_193_698);
} catch {}
try {
renderBundleEncoder4.setBindGroup(5, bindGroup10, new Uint32Array(7076), 3468, 0);
} catch {}
try {
  await buffer5.mapAsync(GPUMapMode.WRITE, 0, 26176);
} catch {}
try {
commandEncoder25.insertDebugMarker('\u{1f789}');
} catch {}
let querySet11 = device0.createQuerySet({label: '\u{1ff67}\uc093', type: 'occlusion', count: 2053});
let commandBuffer11 = commandEncoder25.finish({});
let renderBundleEncoder19 = device0.createRenderBundleEncoder({label: '\u1b8e\u0205\u{1ffc9}\ua8a5', colorFormats: ['r32uint', 'r32uint'], stencilReadOnly: true});
try {
renderPassEncoder5.setBindGroup(2, bindGroup7);
} catch {}
try {
renderPassEncoder2.beginOcclusionQuery(3169);
} catch {}
try {
renderPassEncoder2.setScissorRect(14, 1, 60, 0);
} catch {}
try {
renderPassEncoder5.setViewport(34.60, 0.1996, 5.251, 0.6251, 0.4249, 0.8222);
} catch {}
try {
renderPassEncoder1.drawIndexedIndirect(buffer5, 1_428_873_083);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline19);
} catch {}
let pipeline29 = device0.createRenderPipeline({
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule0,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint'}, {format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'less', passOp: 'zero'},
    stencilBack: {compare: 'equal', failOp: 'zero', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 460764796,
    stencilWriteMask: 3752607508,
    depthBiasSlopeScale: 786.2009159301084,
  },
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 592,
        attributes: [
          {format: 'unorm8x2', offset: 200, shaderLocation: 11},
          {format: 'snorm16x4', offset: 324, shaderLocation: 8},
          {format: 'snorm16x4', offset: 40, shaderLocation: 10},
          {format: 'unorm16x4', offset: 0, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 3004,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 704, shaderLocation: 12}],
      },
      {arrayStride: 6864, attributes: []},
      {
        arrayStride: 656,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 104, shaderLocation: 14},
          {format: 'sint16x4', offset: 224, shaderLocation: 15},
          {format: 'sint8x4', offset: 384, shaderLocation: 1},
          {format: 'uint32', offset: 160, shaderLocation: 7},
          {format: 'sint32x4', offset: 140, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 356, shaderLocation: 9},
          {format: 'float32', offset: 0, shaderLocation: 6},
          {format: 'snorm16x4', offset: 4, shaderLocation: 2},
          {format: 'uint16x4', offset: 108, shaderLocation: 3},
          {format: 'unorm8x2', offset: 114, shaderLocation: 0},
        ],
      },
      {arrayStride: 2932, attributes: [{format: 'sint32', offset: 436, shaderLocation: 13}]},
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'none', unclippedDepth: true},
});
let img3 = await imageWithData(98, 194, '#7fdd9684', '#ba2d70d3');
let bindGroupLayout12 = device0.createBindGroupLayout({
  label: '\u2ad5\u0ea9\u229b\u{1faf0}\u0088\u0823',
  entries: [
    {binding: 3765, visibility: GPUShaderStage.FRAGMENT, sampler: { type: 'filtering' }},
    {binding: 2930, visibility: 0, externalTexture: {}},
    {
      binding: 3769,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'filtering' },
    },
  ],
});
let pipelineLayout4 = device0.createPipelineLayout({
  bindGroupLayouts: [bindGroupLayout11, bindGroupLayout11, bindGroupLayout11, bindGroupLayout5, bindGroupLayout12, bindGroupLayout10],
});
let commandEncoder26 = device0.createCommandEncoder({});
try {
renderPassEncoder4.setBindGroup(0, bindGroup10, new Uint32Array(2598), 1514, 0);
} catch {}
try {
renderPassEncoder2.setViewport(66.97, 0.2844, 9.789, 0.4575, 0.9488, 0.9831);
} catch {}
try {
renderPassEncoder3.drawIndexed(26, 178, 60_468_357, 168_152_862, 312_012_464);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline25);
} catch {}
try {
renderBundleEncoder6.setBindGroup(2, bindGroup1);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(874, undefined);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 3,
  origin: {x: 0, y: 2, z: 39},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 9_101_575 */
{offset: 538, bytesPerRow: 83, rowsPerImage: 131}, {width: 1, height: 5, depthOrArrayLayers: 838});
} catch {}
let promise8 = device0.createRenderPipelineAsync({
  label: '\u7519\u008c\u{1faab}\u2775\u312b',
  layout: pipelineLayout4,
  multisample: {mask: 0xb41b08b9},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.BLUE}, {format: 'r32uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less',
    stencilFront: {compare: 'greater-equal', failOp: 'decrement-wrap', depthFailOp: 'zero', passOp: 'invert'},
    stencilBack: {compare: 'less', failOp: 'replace', depthFailOp: 'decrement-wrap', passOp: 'zero'},
    stencilReadMask: 1245190339,
    depthBias: -67603646,
    depthBiasClamp: 563.3656104168565,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 11880,
        stepMode: 'instance',
        attributes: [{format: 'uint32x4', offset: 1604, shaderLocation: 9}],
      },
      {
        arrayStride: 3044,
        attributes: [
          {format: 'sint32x4', offset: 96, shaderLocation: 14},
          {format: 'unorm8x4', offset: 0, shaderLocation: 8},
        ],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {
        arrayStride: 3336,
        stepMode: 'instance',
        attributes: [{format: 'sint32x4', offset: 988, shaderLocation: 4}],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
let commandEncoder27 = device0.createCommandEncoder({label: '\u0d6e\u9876\u0c5f\u0884\uf780\u31db\u0317\u01ee'});
try {
renderPassEncoder5.setBindGroup(4, bindGroup2);
} catch {}
try {
renderPassEncoder5.setBindGroup(6, bindGroup8, new Uint32Array(6093), 5483, 0);
} catch {}
try {
renderPassEncoder5.draw(84, 38, 815_192_498, 414_252_692);
} catch {}
try {
gpuCanvasContext2.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture11,
  mipLevel: 2,
  origin: {x: 47, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 2_427 */
{offset: 923}, {width: 376, height: 1, depthOrArrayLayers: 1});
} catch {}
let commandEncoder28 = device0.createCommandEncoder({label: '\u0ac1\u845f\u0165\uc0b5\ua78d\u6305\u0fac'});
let texture14 = device0.createTexture({
  label: '\u8e4a\u87c8\u5c50\u{1f7e3}\ucb4a',
  size: [1401, 1, 1794],
  mipLevelCount: 11,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let textureView34 = texture10.createView({});
let renderPassEncoder6 = commandEncoder28.beginRenderPass({
  label: '\u{1ff0a}\u3c77\u7656\u0460\u6fae\u0a77\ue3ac\u0d9f\u{1fa54}',
  colorAttachments: [{
  view: textureView23,
  depthSlice: 112,
  clearValue: { r: -761.7, g: -774.3, b: 269.7, a: 326.4, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView23,
  depthSlice: 44,
  clearValue: { r: 894.8, g: 883.4, b: -75.80, a: -56.22, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet3,
  maxDrawCount: 507917553,
});
let renderBundle21 = renderBundleEncoder15.finish({label: '\u0bc5\u{1ffed}\u0153\ud377\u{1f9c4}\ubbf4\ue477\ua4ea'});
try {
renderPassEncoder3.end();
} catch {}
try {
renderPassEncoder4.beginOcclusionQuery(7);
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: -655.3, g: -895.7, b: -451.4, a: -642.5, });
} catch {}
try {
renderPassEncoder5.draw(49, 398, 507_202_656, 1_572_367_926);
} catch {}
try {
renderPassEncoder5.drawIndexed(222, 161, 373_033_512);
} catch {}
try {
renderPassEncoder5.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder18.draw(204, 187);
} catch {}
try {
renderBundleEncoder10.setPipeline(pipeline27);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
let pipeline30 = await device0.createRenderPipelineAsync({
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32uint'}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {failOp: 'decrement-clamp', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'less', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    depthBias: 1076488394,
    depthBiasClamp: 65.37742851517311,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 4428,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 4, shaderLocation: 13},
          {format: 'sint32x2', offset: 1952, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 8164,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x4', offset: 188, shaderLocation: 0}],
      },
      {arrayStride: 4104, stepMode: 'instance', attributes: []},
      {
        arrayStride: 7384,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 1472, shaderLocation: 4},
          {format: 'sint32', offset: 1336, shaderLocation: 5},
          {format: 'sint32x2', offset: 280, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 14420,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x2', offset: 1444, shaderLocation: 3}],
      },
      {
        arrayStride: 6560,
        stepMode: 'vertex',
        attributes: [{format: 'sint32x4', offset: 1688, shaderLocation: 9}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', cullMode: 'back', unclippedDepth: true},
});
let shaderModule5 = device0.createShaderModule({
  label: '\u4f3c\u3f8e\u{1ffe3}\u4f57\ubb28\u6d1f',
  code: `@group(4) @binding(3769)
var<storage, read_write> parameter3: array<u32>;
@group(3) @binding(186)
var<storage, read_write> n1: array<u32>;
@group(1) @binding(1338)
var<storage, read_write> type3: array<u32>;
@group(3) @binding(424)
var<storage, read_write> function0: array<u32>;
@group(4) @binding(2930)
var<storage, read_write> global0: array<u32>;
@group(0) @binding(1513)
var<storage, read_write> function1: array<u32>;
@group(2) @binding(1338)
var<storage, read_write> parameter4: array<u32>;
@group(4) @binding(3765)
var<storage, read_write> type4: array<u32>;
@group(5) @binding(2477)
var<storage, read_write> local2: array<u32>;

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

struct S7 {
  @location(14) f0: i32,
  @location(25) f1: vec2<f32>,
  @builtin(sample_mask) f2: u32,
  @location(62) f3: vec4<i32>,
  @location(43) f4: vec4<u32>,
  @location(71) f5: vec3<f32>,
  @location(28) f6: vec4<f32>,
  @location(16) f7: u32,
  @location(60) f8: i32,
  @location(35) f9: vec3<f32>,
  @location(54) f10: vec3<i32>,
  @location(58) f11: vec2<u32>,
  @location(47) f12: f16,
  @location(66) f13: vec4<f16>,
  @location(55) f14: u32,
  @location(74) f15: vec3<i32>,
  @location(72) f16: f16,
  @builtin(front_facing) f17: bool
}
struct FragmentOutput0 {
  @location(2) f0: vec4<i32>,
  @location(3) f1: vec4<f32>,
  @location(0) f2: vec4<u32>,
  @location(1) f3: u32
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @location(61) a1: vec2<f32>, @location(13) a2: vec4<i32>, @location(9) a3: vec3<i32>, @location(19) a4: f16, @builtin(position) a5: vec4<f32>, @location(17) a6: vec2<f16>, a7: S7, @location(31) a8: vec2<u32>, @location(70) a9: vec2<f32>, @location(20) a10: vec4<i32>, @location(57) a11: vec2<i32>) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S6 {
  @location(4) f0: vec3<u32>,
  @location(0) f1: vec2<f16>,
  @location(15) f2: u32,
  @location(11) f3: i32,
  @location(5) f4: vec4<u32>,
  @location(14) f5: f32,
  @location(13) f6: vec4<f32>,
  @location(12) f7: vec4<i32>,
  @location(8) f8: f16,
  @location(2) f9: vec4<i32>,
  @location(6) f10: vec4<u32>,
  @location(1) f11: i32
}
struct VertexOutput0 {
  @location(66) f53: vec4<f16>,
  @location(20) f54: vec4<i32>,
  @location(61) f55: vec2<f32>,
  @location(72) f56: f16,
  @location(14) f57: i32,
  @location(58) f58: vec2<u32>,
  @location(55) f59: u32,
  @location(25) f60: vec2<f32>,
  @location(74) f61: vec3<i32>,
  @builtin(position) f62: vec4<f32>,
  @location(54) f63: vec3<i32>,
  @location(71) f64: vec3<f32>,
  @location(13) f65: vec4<i32>,
  @location(31) f66: vec2<u32>,
  @location(57) f67: vec2<i32>,
  @location(60) f68: i32,
  @location(9) f69: vec3<i32>,
  @location(17) f70: vec2<f16>,
  @location(19) f71: f16,
  @location(28) f72: vec4<f32>,
  @location(62) f73: vec4<i32>,
  @location(47) f74: f16,
  @location(70) f75: vec2<f32>,
  @location(35) f76: vec3<f32>,
  @location(16) f77: u32,
  @location(43) f78: vec4<u32>
}

@vertex
fn vertex0(@builtin(instance_index) a0: u32, @location(7) a1: u32, @location(10) a2: vec2<u32>, @location(9) a3: vec4<i32>, @location(3) a4: vec2<f32>, a5: S6, @builtin(vertex_index) a6: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout13 = device0.createBindGroupLayout({
  label: '\u5519\u4281\u5d42\u{1ff17}\u0f55\u{1fd99}\u0955\u51f8\ud77f\u6cef\u02cf',
  entries: [
    {
      binding: 1019,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'comparison' },
    },
    {
      binding: 673,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '3d' },
    },
    {
      binding: 1151,
      visibility: 0,
      texture: { viewDimension: '2d-array', sampleType: 'sint', multisampled: false },
    },
  ],
});
let textureView35 = texture8.createView({label: '\u{1f9c8}\u5e10\u{1fb3b}\u{1f74a}\u{1ff9d}'});
let computePassEncoder13 = commandEncoder26.beginComputePass({});
let renderPassEncoder7 = commandEncoder27.beginRenderPass({
  label: '\u067f\ubeea\u0976\ua609\u9f8e\u0423\u4136',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 53,
  clearValue: { r: -941.4, g: -373.2, b: 40.92, a: -19.99, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView23,
  depthSlice: 330,
  clearValue: { r: -372.1, g: -190.2, b: 598.9, a: 663.9, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 253657421,
});
let renderBundle22 = renderBundleEncoder10.finish({});
try {
computePassEncoder12.setPipeline(pipeline26);
} catch {}
try {
renderPassEncoder2.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder18.drawIndexed(58, 6, 432_615_844, 156_773_284);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let imageBitmap6 = await createImageBitmap(imageBitmap4);
let shaderModule6 = device0.createShaderModule({
  label: '\u0d00\u01a5\u2dcd\u8f50\u{1fe06}\ud7a4\u07db\uf562\u0d39',
  code: `@group(0) @binding(2198)
var<storage, read_write> parameter5: array<u32>;
@group(0) @binding(55)
var<storage, read_write> n2: array<u32>;
@group(0) @binding(1303)
var<storage, read_write> function2: array<u32>;
@group(1) @binding(2477)
var<storage, read_write> parameter6: 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(1) f0: u32,
  @location(0) f1: u32
}

@fragment
fn fragment0(@location(9) a0: f16, @location(1) a1: f32) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct VertexOutput0 {
  @location(34) f79: vec2<f32>,
  @location(63) f80: vec4<f16>,
  @location(9) f81: f16,
  @location(18) f82: vec4<u32>,
  @location(6) f83: vec2<f16>,
  @location(57) f84: i32,
  @location(1) f85: f32,
  @location(70) f86: vec3<i32>,
  @location(67) f87: vec2<f32>,
  @location(28) f88: u32,
  @location(33) f89: f32,
  @location(11) f90: u32,
  @builtin(position) f91: vec4<f32>
}

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

`,
  sourceMap: {},
  hints: {},
});
let textureView36 = texture11.createView({label: '\u0f45\u6970\u2d3d\u1b2c\u01be\u1e9b\u{1fcbe}', format: 'r32uint', baseMipLevel: 1});
let renderBundle23 = renderBundleEncoder3.finish();
let sampler13 = device0.createSampler({
  label: '\u0690\u0e8f\u7519\u0a4d\u0524\u0092',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 91.51,
  maxAnisotropy: 10,
});
try {
  await device0.queue.onSubmittedWorkDone();
} catch {}
gc();
let buffer8 = device0.createBuffer({
  label: '\u{1f9c3}\u87fc\u21ec\u0a81\u0d2e\u7001\u9894\u{1f6c2}',
  size: 104793,
  usage: GPUBufferUsage.QUERY_RESOLVE,
});
let texture15 = device0.createTexture({
  label: '\ue970\u5ff8\ub8e0\u02d5\u2095\u34a9\u0e79',
  size: [960, 1, 1770],
  mipLevelCount: 7,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let textureView37 = texture14.createView({format: 'r32uint', baseMipLevel: 4});
let renderBundleEncoder20 = device0.createRenderBundleEncoder({
  label: '\u{1fcaa}\ub1db\u6f04\u{1fa29}\u5078\u{1f60e}\u97c9\u41dc',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: true,
});
try {
computePassEncoder7.setPipeline(pipeline15);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setViewport(41.14, 0.08038, 42.31, 0.7994, 0.7359, 0.7395);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(5977, undefined, 4228627037, 57922496);
} catch {}
try {
renderBundleEncoder18.draw(49, 399, 59_170_524, 532_993_821);
} catch {}
try {
renderBundleEncoder18.setVertexBuffer(9065, undefined, 0, 1522064475);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let sampler14 = device0.createSampler({
  label: '\ue66d\u0f50',
  addressModeU: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 86.35,
  compare: 'not-equal',
});
try {
computePassEncoder3.setPipeline(pipeline13);
} catch {}
try {
renderPassEncoder5.end();
} catch {}
let textureView38 = texture13.createView({label: '\u00e4\uefd9\u7fae\u54be\u05b7'});
try {
renderPassEncoder4.beginOcclusionQuery(342);
} catch {}
try {
renderPassEncoder4.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([]);
} catch {}
try {
renderPassEncoder2.setStencilReference(1524);
} catch {}
try {
renderBundleEncoder4.setVertexBuffer(3407, undefined, 0, 2157223525);
} catch {}
try {
buffer3.destroy();
} catch {}
let gpuCanvasContext7 = canvas5.getContext('webgpu');
let commandEncoder29 = device0.createCommandEncoder();
let textureView39 = texture14.createView({baseMipLevel: 5, mipLevelCount: 2});
try {
computePassEncoder8.setBindGroup(0, bindGroup10, new Uint32Array(9471), 3471, 0);
} catch {}
try {
renderPassEncoder1.setBindGroup(4, bindGroup9);
} catch {}
try {
buffer1.unmap();
} catch {}
try {
commandEncoder29.copyBufferToBuffer(buffer5, 72140, buffer0, 456564, 24480);
dissociateBuffer(device0, buffer5);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder29.resolveQuerySet(querySet10, 2731, 381, buffer8, 62720);
} catch {}
let canvas6 = document.createElement('canvas');
let querySet12 = device0.createQuerySet({label: '\u74c6\u3b06\u5f97\u0c74\uc231', type: 'occlusion', count: 3116});
let commandBuffer12 = commandEncoder29.finish({label: '\ub629\u{1f864}\u{1f654}\ud8a7\u{1febf}\u8ffd\u7ba5\u{1fd7d}\u059e\u034e'});
let textureView40 = texture4.createView({label: '\u0edc\u0d80\u0843\u0305\u{1ffe7}', mipLevelCount: 1});
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setStencilReference(3415);
} catch {}
try {
renderPassEncoder1.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder18.setPipeline(pipeline27);
} catch {}
let pipeline31 = device0.createRenderPipeline({
  label: '\u{1f885}\u{1fb71}\u693e\u49e8\u2a73\ufa1b\ua43a',
  layout: pipelineLayout3,
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'r32uint', writeMask: GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1320,
        stepMode: 'instance',
        attributes: [{format: 'float32', offset: 0, shaderLocation: 5}],
      },
      {
        arrayStride: 15312,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 5020, shaderLocation: 12},
          {format: 'uint8x2', offset: 3564, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 2056,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x2', offset: 676, shaderLocation: 4},
          {format: 'unorm16x4', offset: 32, shaderLocation: 13},
          {format: 'uint32', offset: 36, shaderLocation: 3},
          {format: 'sint8x2', offset: 288, shaderLocation: 2},
          {format: 'uint32x2', offset: 336, shaderLocation: 14},
          {format: 'sint32', offset: 212, shaderLocation: 7},
          {format: 'sint32', offset: 12, shaderLocation: 9},
          {format: 'uint16x4', offset: 828, shaderLocation: 8},
        ],
      },
      {arrayStride: 2380, stepMode: 'instance', attributes: []},
      {arrayStride: 2084, stepMode: 'vertex', attributes: []},
      {arrayStride: 16580, stepMode: 'instance', attributes: []},
      {arrayStride: 2840, stepMode: 'vertex', attributes: []},
      {arrayStride: 6276, attributes: []},
      {
        arrayStride: 3296,
        stepMode: 'instance',
        attributes: [{format: 'uint8x4', offset: 340, shaderLocation: 1}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true},
});
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let videoFrame3 = new VideoFrame(offscreenCanvas2, {timestamp: 0});
let commandEncoder30 = device0.createCommandEncoder({label: '\u{1fe4f}\u{1fca2}\u{1f78d}\u{1fdae}\u03ab\u09f3\u0dde'});
let querySet13 = device0.createQuerySet({type: 'occlusion', count: 1156});
let renderBundleEncoder21 = device0.createRenderBundleEncoder({
  label: '\uece4\ub8de\u0e25\u36a8\u0802\u0151\ua71f\u14c3\u0903\u2eb7\ud8cc',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: true,
});
try {
renderBundleEncoder13.setPipeline(pipeline14);
} catch {}
try {
commandEncoder30.resolveQuerySet(querySet7, 1136, 831, buffer8, 89856);
} catch {}
let pipeline32 = await device0.createComputePipelineAsync({
  label: '\ubda3\ud85f\ua251\ua545\u09ee\u4a7a\ufd34\u010d\u052d',
  layout: pipelineLayout3,
  compute: {module: shaderModule4, entryPoint: 'compute0', constants: {}},
});
try {
  await promise7;
} catch {}
try {
  await adapter1.requestAdapterInfo();
} catch {}
try {
externalTexture1.label = '\u5fcd\u00aa\uc2e1\u3633\ub3ec\uf629\u2398\u01b6';
} catch {}
let commandEncoder31 = device0.createCommandEncoder({});
try {
renderPassEncoder6.setBindGroup(6, bindGroup8);
} catch {}
try {
renderPassEncoder0.setViewport(69.90, 0.8466, 6.281, 0.1223, 0.4506, 0.7662);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline17);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline31);
} catch {}
try {
commandEncoder31.copyBufferToBuffer(buffer6, 200192, buffer0, 216428, 29568);
dissociateBuffer(device0, buffer6);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder30.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline33 = device0.createComputePipeline({
  label: '\u0360\u{1f96b}\u{1ff4d}\u0d20\u53b5\u{1fcb2}\ua024\u7000',
  layout: 'auto',
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let commandEncoder32 = device0.createCommandEncoder();
let texture16 = device0.createTexture({
  label: '\u93d2\u{1fb12}\u{1fbc9}\u{1f79e}\u723f\u{1fc11}\u{1f787}\u9ff1',
  size: {width: 30, height: 96, depthOrArrayLayers: 47},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let computePassEncoder14 = commandEncoder31.beginComputePass({});
try {
renderPassEncoder2.end();
} catch {}
try {
renderPassEncoder6.setBlendConstant({ r: 276.4, g: -174.6, b: 263.1, a: -730.7, });
} catch {}
try {
renderPassEncoder0.setViewport(19.59, 0.1252, 40.51, 0.3826, 0.1908, 0.3670);
} catch {}
try {
renderBundleEncoder20.setPipeline(pipeline14);
} catch {}
try {
commandEncoder30.copyBufferToBuffer(buffer3, 274584, buffer0, 521580, 252);
dissociateBuffer(device0, buffer3);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder30.resolveQuerySet(querySet6, 335, 36, buffer8, 87040);
} catch {}
let gpuCanvasContext8 = offscreenCanvas8.getContext('webgpu');
let bindGroup12 = device0.createBindGroup({
  label: '\u77c8\ub1d6\ud970\u9c44\u{1fb00}\u785f',
  layout: bindGroupLayout1,
  entries: [{binding: 2477, resource: externalTexture0}],
});
let querySet14 = device0.createQuerySet({label: '\u{1fae2}\u{1fba1}\u0b71\u{1fce6}', type: 'occlusion', count: 1580});
let textureView41 = texture16.createView({
  label: '\u0916\u{1fb56}\u857c\u45e8\u{1fe8e}\ud42d\u09be\ue10f\u{1f849}\uef8c\uce1b',
  baseMipLevel: 1,
  mipLevelCount: 1,
});
try {
buffer6.unmap();
} catch {}
try {
commandEncoder30.copyBufferToBuffer(buffer1, 12268, buffer0, 112916, 74008);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder30.copyTextureToTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 337, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture15,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 17},
  aspect: 'all',
},
{width: 11, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder32.resolveQuerySet(querySet2, 231, 1275, buffer8, 56832);
} catch {}
try {
gpuCanvasContext7.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let videoFrame4 = new VideoFrame(img1, {timestamp: 0});
let textureView42 = texture15.createView({baseMipLevel: 4, mipLevelCount: 3, baseArrayLayer: 0});
let sampler15 = device0.createSampler({
  label: '\uc556\u5080\u07f2',
  addressModeU: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 53.86,
  lodMaxClamp: 94.51,
  compare: 'less',
  maxAnisotropy: 19,
});
let externalTexture12 = device0.importExternalTexture({label: '\u540f\u{1fe46}\u073f', source: videoFrame1, colorSpace: 'srgb'});
let arrayBuffer3 = buffer2.getMappedRange(43952, 43416);
try {
computePassEncoder1.insertDebugMarker('\u6124');
} catch {}
let gpuCanvasContext9 = canvas3.getContext('webgpu');
let imageBitmap7 = await createImageBitmap(videoFrame1);
let videoFrame5 = videoFrame0.clone();
let commandEncoder33 = device0.createCommandEncoder({label: '\uccdf\u0789\u5b75\u09ac\u69a3\u0106\u0a59\u{1faf9}\uba71\u{1f744}\u0655'});
let renderPassEncoder8 = commandEncoder32.beginRenderPass({
  label: '\u02db\u5d54\u{1fb3a}\ucb46\ua7c8\u0952\ua1a1\u0b64',
  colorAttachments: [{
  view: textureView14,
  depthSlice: 132,
  clearValue: { r: -797.6, g: 62.46, b: -821.9, a: 824.6, },
  loadOp: 'clear',
  storeOp: 'store',
}, {view: textureView23, depthSlice: 251, loadOp: 'load', storeOp: 'store'}],
});
try {
computePassEncoder13.setPipeline(pipeline18);
} catch {}
try {
renderPassEncoder7.setBindGroup(2, bindGroup10);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline14);
} catch {}
try {
commandEncoder30.resolveQuerySet(querySet7, 1448, 1297, buffer8, 92672);
} catch {}
let videoFrame6 = new VideoFrame(canvas0, {timestamp: 0});
let externalTexture13 = device0.importExternalTexture({label: '\u5edc\u{1fe16}\u{1fd21}\u0dc4\u0cfd', source: videoFrame5, colorSpace: 'srgb'});
try {
renderPassEncoder6.beginOcclusionQuery(188);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(1377, undefined, 0, 677744374);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline17);
} catch {}
try {
commandEncoder30.copyTextureToTexture({
  texture: texture11,
  mipLevel: 1,
  origin: {x: 346, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 6,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder33.resolveQuerySet(querySet8, 1056, 0, buffer8, 54784);
} catch {}
let promise9 = device0.createRenderPipelineAsync({
  label: '\udb4f\ufec9\u02d9',
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: 0}, {format: 'r32uint', writeMask: 0}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'equal', failOp: 'zero', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'not-equal', depthFailOp: 'decrement-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 3221563266,
    stencilWriteMask: 1878133937,
    depthBias: 849478166,
    depthBiasSlopeScale: 142.49562287773466,
  },
  vertex: {module: shaderModule6, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'none'},
});
let texture17 = device0.createTexture({
  label: '\u8be6\u{1faaa}\u0867\u{1fd05}',
  size: [700, 1, 679],
  mipLevelCount: 3,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let textureView43 = texture3.createView({label: '\uc1d6\u623f\u2429', baseMipLevel: 2});
let renderPassEncoder9 = commandEncoder30.beginRenderPass({
  colorAttachments: [{
  view: textureView14,
  depthSlice: 191,
  clearValue: { r: -211.2, g: 322.3, b: 633.9, a: -201.4, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView28,
  depthSlice: 354,
  clearValue: { r: -774.4, g: 817.7, b: 124.4, a: 192.2, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet8,
});
let renderBundleEncoder22 = device0.createRenderBundleEncoder({
  label: '\ue35e\u{1fbb8}\u{1fa6b}\u{1ffa1}\u01f6',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
});
let renderBundle24 = renderBundleEncoder14.finish({label: '\u010f\u0c1e\u{1fac7}\ue21d\u0140\u{1fdc5}'});
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: -215.5, g: 620.1, b: 579.3, a: -553.7, });
} catch {}
try {
renderPassEncoder1.setViewport(14.93, 0.1233, 10.84, 0.5885, 0.7186, 0.8875);
} catch {}
try {
renderBundleEncoder4.setBindGroup(4, bindGroup4);
} catch {}
let promise10 = device0.queue.onSubmittedWorkDone();
let imageBitmap8 = await createImageBitmap(imageBitmap7);
let externalTexture14 = device0.importExternalTexture({label: '\u0705\u05f3\u17db\u{1fd28}\uec45\ud1af', source: videoFrame0, colorSpace: 'display-p3'});
try {
renderPassEncoder9.executeBundles([renderBundle23, renderBundle10, renderBundle6, renderBundle18]);
} catch {}
try {
renderPassEncoder7.setScissorRect(2, 1, 47, 0);
} catch {}
try {
renderPassEncoder6.setVertexBuffer(6060, undefined);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(479, undefined);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
commandEncoder33.clearBuffer(buffer2, 146648);
dissociateBuffer(device0, buffer2);
} catch {}
let bindGroup13 = device0.createBindGroup({
  label: '\u0133\u9dd2\u0de8\u3f73\u762b\u{1f971}',
  layout: bindGroupLayout1,
  entries: [{binding: 2477, resource: externalTexture5}],
});
let commandEncoder34 = device0.createCommandEncoder({label: '\u06cf\ub179\u{1fed4}\u0926\u{1f924}\u{1fec5}'});
let computePassEncoder15 = commandEncoder33.beginComputePass({label: '\u0db0\u7168\u{1fae3}\u{1f7d9}\u03e6'});
let renderBundleEncoder23 = device0.createRenderBundleEncoder({
  label: '\u0cf3\u018e\ufc6a\uf7bb\ua1f7\u0e3a\u048d\uc896\u4756\ufa97\u3d72',
  colorFormats: ['r32uint', 'r32uint'],
});
let renderBundle25 = renderBundleEncoder10.finish({label: '\u03a6\u{1f623}'});
let externalTexture15 = device0.importExternalTexture({label: '\u0ddb\u31ef\u038d\u9417\u7013\u8a3e\ua7ba\u0acb\u12ed\ufe64\u0aa9', source: video2});
try {
computePassEncoder12.setPipeline(pipeline22);
} catch {}
try {
renderPassEncoder1.setBindGroup(2, bindGroup0);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(545);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.setScissorRect(25, 1, 14, 0);
} catch {}
try {
renderPassEncoder9.setViewport(80.97, 0.1533, 4.593, 0.8466, 0.1969, 0.7522);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline6);
} catch {}
try {
commandEncoder34.copyBufferToBuffer(buffer5, 261160, buffer2, 118204, 22932);
dissociateBuffer(device0, buffer5);
dissociateBuffer(device0, buffer2);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
canvas1.height = 1850;
let textureView44 = texture0.createView({
  label: '\u700a\u2aed\u153c\u6460\u{1f949}\u0930\u33e6\u{1f602}\u{1ffb8}\u00e8',
  baseMipLevel: 3,
  baseArrayLayer: 891,
  arrayLayerCount: 34,
});
let computePassEncoder16 = commandEncoder34.beginComputePass();
try {
renderPassEncoder7.setBindGroup(1, bindGroup2, new Uint32Array(2524), 1315, 0);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(36);
} catch {}
try {
renderPassEncoder6.setStencilReference(952);
} catch {}
try {
renderPassEncoder7.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder23.setPipeline(pipeline17);
} catch {}
let commandEncoder35 = device0.createCommandEncoder({});
let querySet15 = device0.createQuerySet({type: 'occlusion', count: 1285});
let textureView45 = texture4.createView({label: '\ucb78\u8661\u0f3e', dimension: '3d', baseMipLevel: 1, mipLevelCount: 4});
try {
renderPassEncoder0.setStencilReference(2423);
} catch {}
try {
renderPassEncoder7.setViewport(32.41, 0.6132, 31.59, 0.3714, 0.2898, 0.3509);
} catch {}
try {
renderBundleEncoder19.setPipeline(pipeline25);
} catch {}
try {
buffer6.unmap();
} catch {}
try {
commandEncoder35.resolveQuerySet(querySet5, 1018, 437, buffer8, 47360);
} catch {}
let pipeline34 = await device0.createComputePipelineAsync({
  label: '\u01bf\ubf27',
  layout: pipelineLayout0,
  compute: {module: shaderModule0, entryPoint: 'compute0'},
});
let commandEncoder36 = device0.createCommandEncoder({label: '\u{1f76e}\u{1f6f0}\uf210\u268c\u0fb1\u1b1c'});
let texture18 = device0.createTexture({
  label: '\u09a5\ud787\u7db6\u{1f82c}\u{1f868}\u0be1\u329c\u{1fc83}\u0e3e',
  size: {width: 350},
  sampleCount: 1,
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint', 'r32uint'],
});
let textureView46 = texture14.createView({label: '\ue5ec\ue35a\u7038\u0c8f\u{1fa5a}\ub5d2\u5655\u748c\u17b6', baseMipLevel: 2, mipLevelCount: 3});
let computePassEncoder17 = commandEncoder35.beginComputePass();
let renderPassEncoder10 = commandEncoder36.beginRenderPass({
  label: '\u0ca6\u0bcf',
  colorAttachments: [{view: textureView32, loadOp: 'load', storeOp: 'store'}, {
  view: textureView38,
  depthSlice: 80,
  clearValue: { r: 679.5, g: -526.0, b: 378.2, a: 166.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet1,
  maxDrawCount: 135941786,
});
let renderBundleEncoder24 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint']});
try {
computePassEncoder10.end();
} catch {}
try {
renderPassEncoder7.draw(2, 102, 10_148_319, 3_160_539_127);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline19);
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer3, 251140, buffer0, 276140, 33440);
dissociateBuffer(device0, buffer3);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 309, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture9,
  mipLevel: 1,
  origin: {x: 0, y: 9, z: 0},
  aspect: 'all',
},
{width: 10, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder8.resolveQuerySet(querySet12, 1229, 1769, buffer8, 17664);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let bindGroupLayout14 = device0.createBindGroupLayout({
  label: '\uae54\ud8f6',
  entries: [{binding: 3154, visibility: GPUShaderStage.VERTEX, externalTexture: {}}],
});
let renderBundleEncoder25 = device0.createRenderBundleEncoder({
  label: '\u0086\u9c8e\u0fe2',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let externalTexture16 = device0.importExternalTexture({label: '\u6fc7\u5a00\u7827\u{1f809}\u4bc2\u0dc7', source: videoFrame6, colorSpace: 'srgb'});
try {
computePassEncoder13.setPipeline(pipeline34);
} catch {}
try {
renderPassEncoder10.setStencilReference(3614);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline14);
} catch {}
try {
renderBundleEncoder6.draw(240, 2, 362_478_507);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture5,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 2,
  origin: {x: 0, y: 16, z: 0},
  aspect: 'all',
},
{width: 1, height: 4, depthOrArrayLayers: 1});
} catch {}
gc();
let img4 = await imageWithData(27, 66, '#64020410', '#9ebe6d20');
try {
canvas6.getContext('2d');
} catch {}
let commandEncoder37 = device0.createCommandEncoder();
let sampler16 = device0.createSampler({
  label: '\u10ff\u5515\ue826\uf8e0\u0c0a\u5b24',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 4.209,
  lodMaxClamp: 8.852,
  maxAnisotropy: 1,
});
try {
renderPassEncoder0.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder7.drawIndexed(427);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer7, 369_241_747);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer4, 1_125_280_363);
} catch {}
try {
commandEncoder8.copyBufferToBuffer(buffer1, 85592, buffer2, 182752, 9084);
dissociateBuffer(device0, buffer1);
dissociateBuffer(device0, buffer2);
} catch {}
try {
commandEncoder8.copyTextureToTexture({
  texture: texture5,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture5,
  mipLevel: 1,
  origin: {x: 3, y: 61, z: 8},
  aspect: 'all',
},
{width: 0, height: 11, depthOrArrayLayers: 0});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture9,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 47},
  aspect: 'all',
}, new ArrayBuffer(4_216_765), /* required buffer size: 4_216_765 */
{offset: 613, bytesPerRow: 96, rowsPerImage: 93}, {width: 6, height: 23, depthOrArrayLayers: 473});
} catch {}
let pipeline35 = await device0.createComputePipelineAsync({
  label: '\ucb6c\u9d05\u0e8f\u55ec\ub7c4\u{1f88d}\u2c2c\u{1f651}',
  layout: pipelineLayout4,
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
let offscreenCanvas9 = new OffscreenCanvas(1005, 517);
let bindGroupLayout15 = device0.createBindGroupLayout({
  label: '\uacd2\u8d04\u1099\u14d0\u{1fd9d}\u0109',
  entries: [{binding: 410, visibility: GPUShaderStage.COMPUTE, externalTexture: {}}],
});
let querySet16 = device0.createQuerySet({label: '\u62c0\u0590\u2f68', type: 'occlusion', count: 2679});
let textureView47 = texture8.createView({label: '\u05c0\u9e0d\u5571\u{1f753}\uf08a\u{1fcae}\u032b\u65db\u5c16', format: 'r32uint'});
let computePassEncoder18 = commandEncoder37.beginComputePass({label: '\ua886\u9270\ub2e2\u20f4\ube49\u{1fcfb}\u{1f70e}\uc247\u086e'});
let renderBundle26 = renderBundleEncoder13.finish();
let sampler17 = device0.createSampler({
  label: '\u24b7\u{1f727}\u07e0',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 80.85,
  lodMaxClamp: 92.76,
});
let externalTexture17 = device0.importExternalTexture({source: videoFrame6, colorSpace: 'srgb'});
try {
renderPassEncoder8.setScissorRect(29, 0, 40, 1);
} catch {}
try {
renderPassEncoder7.draw(110, 88, 231_239_772, 645_399_566);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer6, 16_526_390);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer8, 380_579_016);
} catch {}
try {
renderPassEncoder6.insertDebugMarker('\u0cb9');
} catch {}
try {
renderBundleEncoder21.insertDebugMarker('\u77f9');
} catch {}
try {
device0.queue.submit([commandBuffer10]);
} catch {}
let video4 = await videoWithData();
let pipelineLayout5 = device0.createPipelineLayout({
  label: '\u7b32\u{1fca5}\u06e1\u{1f866}\u5d03\uc82e\u4cc7',
  bindGroupLayouts: [bindGroupLayout14, bindGroupLayout10, bindGroupLayout4, bindGroupLayout4, bindGroupLayout13, bindGroupLayout5, bindGroupLayout1],
});
let buffer9 = device0.createBuffer({label: '\u94d7\u7f9b\u972c', size: 219594, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let commandEncoder38 = device0.createCommandEncoder({label: '\uf76d\u0965\ub2f4\u{1f92e}\u0086\uffd3\u150f'});
let renderBundle27 = renderBundleEncoder21.finish({label: '\ua36d\u{1fd0b}\u{1fdc6}\u0722\u32c2\u0307\u{1ff3d}\u032a\u0815\ue78d\u09af'});
try {
computePassEncoder3.setPipeline(pipeline35);
} catch {}
try {
renderPassEncoder8.setStencilReference(3195);
} catch {}
try {
renderPassEncoder7.draw(104, 331);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer1, 243_539_523);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer7, 1_367_289_288);
} catch {}
try {
renderBundleEncoder6.draw(78, 84, 167_834_799, 397_563_250);
} catch {}
try {
renderBundleEncoder6.drawIndexed(267, 440, 91_743_732, -2_047_491_183, 2_031_029_253);
} catch {}
try {
commandEncoder38.copyBufferToTexture({
  /* bytesInLastRow: 3284 widthInBlocks: 821 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 26660 */
  offset: 26660,
  buffer: buffer6,
}, {
  texture: texture11,
  mipLevel: 1,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {width: 821, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device0, buffer6);
} catch {}
gc();
let querySet17 = device0.createQuerySet({type: 'occlusion', count: 2041});
let renderBundle28 = renderBundleEncoder1.finish({label: '\u6e6c\u{1fd84}\u7a06\u9ced\u052f\u0440\u078d\u{1fe05}'});
let externalTexture18 = device0.importExternalTexture({label: '\u{1fa50}\u3b72\uef7a\u562f\u0ff5\u03d6\u{1f998}\u02dd\u88d1', source: video2});
try {
renderPassEncoder6.setBindGroup(0, bindGroup5);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(94);
} catch {}
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder0.setBlendConstant({ r: 639.2, g: 32.40, b: 333.7, a: -679.4, });
} catch {}
try {
renderPassEncoder7.setStencilReference(2797);
} catch {}
try {
renderPassEncoder7.draw(365, 127, 745_973_870);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer5, 3_067_266_434);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline25);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(3286, undefined, 0);
} catch {}
try {
renderBundleEncoder6.drawIndexed(125);
} catch {}
try {
renderBundleEncoder6.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(7116, undefined, 713891264, 2147508844);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 6},
  aspect: 'all',
}, arrayBuffer0, /* required buffer size: 2_623_858 */
{offset: 383, bytesPerRow: 611, rowsPerImage: 53}, {width: 113, height: 1, depthOrArrayLayers: 82});
} catch {}
let pipeline36 = await device0.createRenderPipelineAsync({
  label: '\u0b33\u1682\u88ea\u5d5b\u686e\ubc3c\u0543\u0749\u2ef8\u08a7\ufa04',
  layout: pipelineLayout5,
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'not-equal', failOp: 'invert', passOp: 'decrement-wrap'},
    stencilBack: {failOp: 'replace', depthFailOp: 'replace', passOp: 'zero'},
    stencilReadMask: 1554347706,
    stencilWriteMask: 2798836161,
    depthBias: -498781972,
    depthBiasSlopeScale: 362.921424968548,
  },
  vertex: {
    module: shaderModule0,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 536, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 0,
        attributes: [
          {format: 'uint32x3', offset: 8152, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 3004, shaderLocation: 6},
          {format: 'sint32x3', offset: 1996, shaderLocation: 13},
          {format: 'uint32', offset: 200, shaderLocation: 12},
          {format: 'sint32x2', offset: 5156, shaderLocation: 15},
          {format: 'unorm10-10-10-2', offset: 104, shaderLocation: 4},
          {format: 'float32', offset: 2904, shaderLocation: 11},
          {format: 'float32x4', offset: 328, shaderLocation: 0},
          {format: 'float32', offset: 432, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 10900,
        attributes: [
          {format: 'float16x2', offset: 1600, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 956, shaderLocation: 9},
          {format: 'snorm16x2', offset: 1736, shaderLocation: 10},
          {format: 'sint32', offset: 1300, shaderLocation: 1},
          {format: 'float16x4', offset: 580, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 2468,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 224, shaderLocation: 7}],
      },
      {arrayStride: 1092, stepMode: 'instance', attributes: []},
      {arrayStride: 252, attributes: []},
      {arrayStride: 2448, attributes: []},
      {arrayStride: 2252, stepMode: 'instance', attributes: []},
      {arrayStride: 1772, stepMode: 'vertex', attributes: []},
      {arrayStride: 1968, attributes: [{format: 'sint16x2', offset: 676, shaderLocation: 5}]},
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'back'},
});
let imageData5 = new ImageData(248, 212);
let commandEncoder39 = device0.createCommandEncoder({label: '\uc2c5\u5201\uff5a\u{1faa8}\u0874\u0dff\u{1f703}'});
let textureView48 = texture16.createView({label: '\uc893\u04e8\u{1f8c6}\u{1ffc2}\u23b8\uf80f\ud1bd\u{1f937}'});
let sampler18 = device0.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 96.39,
  lodMaxClamp: 99.05,
  maxAnisotropy: 1,
});
try {
renderPassEncoder1.setBindGroup(3, bindGroup13, []);
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle16, renderBundle27, renderBundle13, renderBundle16, renderBundle22, renderBundle15]);
} catch {}
try {
renderPassEncoder7.setStencilReference(3463);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer8, 2_862_283);
} catch {}
let promise11 = buffer7.mapAsync(GPUMapMode.READ, 0, 27220);
try {
commandEncoder8.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
let pipeline37 = await device0.createComputePipelineAsync({
  label: '\u0a23\ue918\uec68\u{1fdde}\u5029\u1c9d\u6263\ue8f4\u6873',
  layout: pipelineLayout2,
  compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}},
});
let pipeline38 = device0.createRenderPipeline({
  label: '\u0b4d\u{1f718}\ub786\u6fd8\u5ceb\u12b0\ue125\u0eb5',
  layout: pipelineLayout5,
  multisample: {count: 4},
  vertex: {module: shaderModule6, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', unclippedDepth: true},
});
let gpuCanvasContext10 = offscreenCanvas9.getContext('webgpu');
video3.width = 178;
try {
device0.label = '\u002a\u1ffa';
} catch {}
let bindGroupLayout16 = device0.createBindGroupLayout({
  label: '\u3710\u020b\u0110\u6c74\u4a87',
  entries: [
    {
      binding: 3647,
      visibility: GPUShaderStage.FRAGMENT,
      storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '2d-array' },
    },
  ],
});
let commandEncoder40 = device0.createCommandEncoder();
let commandBuffer13 = commandEncoder8.finish({label: '\u29a6\u0b89\u0f95\u0887\u{1fa1a}\u4926\u4b8d\ub25c'});
let texture19 = device0.createTexture({
  label: '\u5a22\u0efe\ubd7c\u227f\ued6c\u822f\u4da4\u0a1a\u3916\u150c\u5f73',
  size: {width: 1401, height: 1, depthOrArrayLayers: 1210},
  mipLevelCount: 9,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let renderPassEncoder11 = commandEncoder38.beginRenderPass({
  label: '\u8783\u{1fd4b}\u285f',
  colorAttachments: [{
  view: textureView23,
  depthSlice: 294,
  clearValue: { r: -136.8, g: -928.4, b: 235.9, a: -826.9, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView13,
  depthSlice: 366,
  clearValue: { r: -415.5, g: 594.1, b: 381.3, a: 136.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
});
let renderBundleEncoder26 = device0.createRenderBundleEncoder({
  label: '\u{1f865}\u5784\u6bf6\uf68e\ue0b7\u0f5e\u{1f960}\u24a9\u902f\uc521\ub676',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: false,
});
try {
computePassEncoder16.setPipeline(pipeline23);
} catch {}
try {
renderPassEncoder7.setBindGroup(0, bindGroup7, new Uint32Array(5268), 4508, 0);
} catch {}
try {
renderPassEncoder9.executeBundles([renderBundle25, renderBundle21, renderBundle8, renderBundle17, renderBundle19]);
} catch {}
try {
renderPassEncoder6.setScissorRect(39, 0, 48, 0);
} catch {}
try {
renderPassEncoder8.setVertexBuffer(9700, undefined, 3526195911, 126944455);
} catch {}
try {
commandEncoder40.copyBufferToBuffer(buffer6, 128312, buffer2, 85908, 39452);
dissociateBuffer(device0, buffer6);
dissociateBuffer(device0, buffer2);
} catch {}
try {
commandEncoder39.copyBufferToTexture({
  /* bytesInLastRow: 80 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 18676 */
  offset: 18676,
  rowsPerImage: 134,
  buffer: buffer3,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 83, y: 0, z: 0},
  aspect: 'all',
}, {width: 20, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device0, buffer3);
} catch {}
try {
commandEncoder40.resolveQuerySet(querySet15, 1117, 151, buffer8, 34560);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture18,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new Int8Array(arrayBuffer3), /* required buffer size: 419 */
{offset: 419}, {width: 329, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await promise11;
} catch {}
let bindGroup14 = device0.createBindGroup({
  label: '\u{1fe00}\u09f7\u0c76\u6782\u8c74',
  layout: bindGroupLayout12,
  entries: [
    {binding: 3765, resource: sampler17},
    {binding: 3769, resource: sampler0},
    {binding: 2930, resource: externalTexture18},
  ],
});
let sampler19 = device0.createSampler({addressModeU: 'mirror-repeat', addressModeV: 'clamp-to-edge', lodMinClamp: 38.39, lodMaxClamp: 79.01});
try {
renderPassEncoder7.drawIndexed(118);
} catch {}
let arrayBuffer4 = buffer0.getMappedRange(503008, 21880);
let commandEncoder41 = device0.createCommandEncoder({label: '\u0677\u08ea\u{1fd48}\ub0b5\u12dc\u80ec'});
let externalTexture19 = device0.importExternalTexture({label: '\u{1f6e7}\u0a34\u02b4\u83b2', source: videoFrame1, colorSpace: 'srgb'});
try {
computePassEncoder13.setPipeline(pipeline7);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(2817);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.executeBundles([renderBundle12, renderBundle17, renderBundle27, renderBundle26, renderBundle20, renderBundle8, renderBundle7, renderBundle28, renderBundle27]);
} catch {}
try {
renderPassEncoder11.setScissorRect(79, 0, 4, 0);
} catch {}
try {
renderPassEncoder6.setViewport(57.37, 0.6126, 18.12, 0.1507, 0.2967, 0.3950);
} catch {}
try {
renderPassEncoder7.drawIndexed(319);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer4, 566_615_373);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer7, 2_907_963_095);
} catch {}
try {
texture19.destroy();
} catch {}
try {
commandEncoder41.copyTextureToTexture({
  texture: texture6,
  mipLevel: 0,
  origin: {x: 88, y: 0, z: 76},
  aspect: 'all',
},
{
  texture: texture11,
  mipLevel: 0,
  origin: {x: 160, y: 0, z: 0},
  aspect: 'all',
},
{width: 483, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder39.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
try {
gpuCanvasContext9.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm-srgb', 'bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let pipeline39 = await device0.createComputePipelineAsync({
  label: '\u77cd\u2286\u0a4c\u{1f6ae}\u{1f7eb}\u89a5\u059c\u82f9\u0bae',
  layout: pipelineLayout5,
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
try {
gpuCanvasContext5.unconfigure();
} catch {}
let commandEncoder42 = device0.createCommandEncoder({label: '\u{1fe39}\u0db5\u0269\u8383\u{1fd78}\ue4fd\u{1f7bc}\u54bd\u0f68\u730f\u{1f9f8}'});
let textureView49 = texture9.createView({
  label: '\u{1fc19}\udbc1',
  dimension: '2d',
  baseMipLevel: 1,
  mipLevelCount: 3,
  baseArrayLayer: 713,
  arrayLayerCount: 1,
});
let computePassEncoder19 = commandEncoder42.beginComputePass({});
let renderPassEncoder12 = commandEncoder40.beginRenderPass({
  label: '\u{1fd44}\u9f57\ud938\u0ad6\u0e3e\u0449\u85ef\u9a1c\u{1ff91}\u05c5\uf07c',
  colorAttachments: [{
  view: textureView14,
  depthSlice: 385,
  clearValue: { r: 656.1, g: 346.7, b: -272.1, a: 178.3, },
  loadOp: 'clear',
  storeOp: 'store',
}, {view: textureView28, depthSlice: 169, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet6,
});
let renderBundle29 = renderBundleEncoder24.finish({label: '\u0a2c\ufa5f\u{1f670}\uc511'});
let externalTexture20 = device0.importExternalTexture({source: videoFrame2});
try {
renderPassEncoder8.setBindGroup(4, bindGroup2);
} catch {}
try {
renderPassEncoder10.setStencilReference(651);
} catch {}
try {
renderPassEncoder4.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder25.setBindGroup(3, bindGroup9);
} catch {}
try {
commandEncoder39.clearBuffer(buffer0, 227444);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder41.resolveQuerySet(querySet3, 46, 354, buffer8, 96000);
} catch {}
try {
computePassEncoder8.insertDebugMarker('\u0b52');
} catch {}
try {
device0.queue.writeTexture({
  texture: texture15,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 286},
  aspect: 'all',
}, new Int32Array(arrayBuffer1), /* required buffer size: 13_271_920 */
{offset: 760, bytesPerRow: 610, rowsPerImage: 294}, {width: 110, height: 0, depthOrArrayLayers: 75});
} catch {}
let pipeline40 = await device0.createComputePipelineAsync({
  label: '\ufee2\u4f71\u2040\ua788\u14e4\u0054\u24e9\u01d7\u4836\u9b94\u79af',
  layout: pipelineLayout4,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let canvas7 = document.createElement('canvas');
let computePassEncoder20 = commandEncoder41.beginComputePass({label: '\u0993\u{1fa16}\u86b5\u6b66'});
try {
renderPassEncoder6.setBlendConstant({ r: -699.7, g: 258.7, b: 318.6, a: -403.3, });
} catch {}
try {
renderPassEncoder7.drawIndexed(102, 333);
} catch {}
try {
computePassEncoder12.insertDebugMarker('\u04c6');
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let bindGroup15 = device0.createBindGroup({
  label: '\uc9dc\ub938\u7ee8\u{1f783}\u{1fe5f}\u04d3',
  layout: bindGroupLayout15,
  entries: [{binding: 410, resource: externalTexture4}],
});
let commandEncoder43 = device0.createCommandEncoder({label: '\uae3e\u765b\u75bd\uabcd\u{1f8df}\u096b\u0a24\u{1fece}\u91de'});
let querySet18 = device0.createQuerySet({label: '\u7542\u{1f614}\u65ba\u2118\u36d5\u9404\uf594\u088d', type: 'occlusion', count: 11});
let textureView50 = texture6.createView({
  label: '\u040d\u6cd2\u{1f826}\u99c0\u0bf8\u9135\u67f3\u25c9\u{1fff9}',
  dimension: '2d',
  baseArrayLayer: 44,
});
let computePassEncoder21 = commandEncoder43.beginComputePass({});
let renderPassEncoder13 = commandEncoder39.beginRenderPass({
  label: '\u06d2\u5c52\u{1f7af}\u{1fb24}\u0893\u055d\u6fe2\uae02\uc5d9\ufa60\u0b74',
  colorAttachments: [{
  view: textureView43,
  depthSlice: 47,
  clearValue: { r: 607.6, g: 652.4, b: 116.1, a: 993.2, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView43,
  depthSlice: 347,
  clearValue: { r: 80.04, g: -166.2, b: -826.5, a: -382.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 939034612,
});
let renderBundle30 = renderBundleEncoder2.finish({label: '\ua34e\u9695\ua6c7\u74e1\u53df\u{1fb1e}\u46aa\uc420\u4a55\u{1fbd4}'});
let sampler20 = device0.createSampler({
  label: '\u0333\u64f0\u{1fb6a}\u329d\ub643\u{1fee7}\u13a9\u89a3\u{1fa5b}',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 12.51,
  lodMaxClamp: 56.85,
});
try {
computePassEncoder13.setPipeline(pipeline0);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: 474.0, g: -694.8, b: -366.6, a: -217.6, });
} catch {}
try {
renderPassEncoder7.setViewport(0.6770, 0.05549, 46.08, 0.8085, 0.1106, 0.8987);
} catch {}
try {
renderPassEncoder7.drawIndexed(9, 94, 300_086_453, 1_118_602_461, 1_316_078_685);
} catch {}
try {
renderPassEncoder1.setVertexBuffer(7791, undefined, 0, 297939317);
} catch {}
try {
renderBundleEncoder16.setBindGroup(2, bindGroup1);
} catch {}
try {
device0.queue.submit([commandBuffer11, commandBuffer7, commandBuffer13]);
} catch {}
let pipeline41 = await device0.createComputePipelineAsync({
  label: '\u0a5b\u{1fa7d}\u3fbd\udcfe\u{1fe0b}\u3c42\u7cf7\u6d3e',
  layout: pipelineLayout0,
  compute: {module: shaderModule5, entryPoint: 'compute0', constants: {}},
});
let bindGroupLayout17 = device0.createBindGroupLayout({entries: []});
let textureView51 = texture19.createView({label: '\u30a3\ub11f', baseMipLevel: 6, mipLevelCount: 2});
let renderBundle31 = renderBundleEncoder1.finish();
let sampler21 = device0.createSampler({
  label: '\u08da\uc32d',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMaxClamp: 88.29,
  compare: 'less-equal',
});
let pipeline42 = device0.createComputePipeline({
  label: '\u02be\u7f84\ufb90\ucdbd\u0e2b',
  layout: pipelineLayout3,
  compute: {module: shaderModule2, entryPoint: 'compute0', constants: {}},
});
let pipeline43 = device0.createRenderPipeline({
  layout: pipelineLayout5,
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'not-equal', depthFailOp: 'invert', passOp: 'decrement-wrap'},
    stencilBack: {
      compare: 'less-equal',
      failOp: 'increment-wrap',
      depthFailOp: 'increment-clamp',
      passOp: 'decrement-wrap',
    },
    stencilReadMask: 3805811225,
    depthBias: -1483349935,
    depthBiasSlopeScale: 20.011148723474037,
  },
  vertex: {module: shaderModule6, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'line-list', unclippedDepth: true},
});
let querySet19 = device0.createQuerySet({label: '\u6705\udf09\u218f\u58e3\ua0b1\ub8dd\u84cd\u{1fb57}', type: 'occlusion', count: 4016});
let renderBundle32 = renderBundleEncoder17.finish({label: '\u{1fa60}\u233c'});
try {
renderPassEncoder1.setScissorRect(61, 1, 9, 0);
} catch {}
try {
renderPassEncoder1.setViewport(38.47, 0.3920, 16.41, 0.05854, 0.5583, 0.6475);
} catch {}
try {
renderPassEncoder7.drawIndexed(17);
} catch {}
try {
renderBundleEncoder26.setBindGroup(5, bindGroup1);
} catch {}
try {
renderBundleEncoder16.setPipeline(pipeline17);
} catch {}
let arrayBuffer5 = buffer2.getMappedRange(165408, 23720);
let pipeline44 = await device0.createComputePipelineAsync({layout: pipelineLayout2, compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}}});
let renderBundle33 = renderBundleEncoder1.finish({});
try {
computePassEncoder6.end();
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(441);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle15, renderBundle17, renderBundle3]);
} catch {}
try {
renderPassEncoder12.setScissorRect(60, 0, 20, 1);
} catch {}
try {
renderPassEncoder13.setViewport(12.07, 0.1669, 10.89, 0.7476, 0.8359, 0.9904);
} catch {}
try {
renderPassEncoder7.drawIndexed(42, 153, 1_354_231_470);
} catch {}
try {
renderPassEncoder13.setPipeline(pipeline31);
} catch {}
try {
  await device0.popErrorScope();
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
buffer0.unmap();
} catch {}
try {
commandEncoder2.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
try {
commandEncoder2.resolveQuerySet(querySet14, 964, 68, buffer8, 11520);
} catch {}
try {
renderPassEncoder9.pushDebugGroup('\u{1faf6}');
} catch {}
try {
  await promise10;
} catch {}
let imageBitmap9 = await createImageBitmap(video1);
let commandBuffer14 = commandEncoder2.finish();
let texture20 = device0.createTexture({
  label: '\u{1fc20}\ue795\ub431\u07d4\u{1f7ba}\u049e\u4c6d\u15d7\u3b06\u{1f9cb}',
  size: [700, 1, 67],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint'],
});
let textureView52 = texture7.createView({label: '\u3411\u09fb', dimension: '1d'});
let renderBundleEncoder27 = device0.createRenderBundleEncoder({
  label: '\u{1f86b}\u08b4\u05e5\ub707\ue434\u26c3\u967f\u{1f687}\u8604\u18f8',
  colorFormats: ['r32uint', 'r32uint'],
  sampleCount: 1,
});
let sampler22 = device0.createSampler({
  label: '\u{1fc6d}\u73d9\u088c\ueea1\u0ab5\uf232\u{1f91f}\uad1c\u00d0\uf348',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 86.43,
});
try {
renderPassEncoder7.setBindGroup(1, bindGroup2);
} catch {}
try {
renderPassEncoder9.setBindGroup(0, bindGroup10, new Uint32Array(6274), 3074, 0);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer5, 215_216_565);
} catch {}
try {
renderPassEncoder0.setPipeline(pipeline17);
} catch {}
let commandEncoder44 = device0.createCommandEncoder({label: '\u6820\u{1fe6b}\u0d64\u{1f7cc}'});
let commandBuffer15 = commandEncoder44.finish({label: '\u0c17\uc6e3\u0136\u2254\u0efc\u7af0\u7ed1'});
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder4.setScissorRect(30, 1, 13, 0);
} catch {}
try {
renderPassEncoder4.setStencilReference(2798);
} catch {}
try {
renderPassEncoder6.setViewport(70.01, 0.1993, 8.026, 0.7741, 0.3728, 0.8803);
} catch {}
let commandEncoder45 = device0.createCommandEncoder({label: '\u228b\u78e2\u0e5b'});
let renderBundleEncoder28 = device0.createRenderBundleEncoder({colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true});
try {
computePassEncoder8.setBindGroup(6, bindGroup8);
} catch {}
try {
renderPassEncoder1.setScissorRect(16, 0, 13, 0);
} catch {}
try {
renderPassEncoder7.draw(122, 210, 151_996_948, 810_406_174);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer2, 67_501_030);
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer5, 13348, buffer0, 390396, 11692);
dissociateBuffer(device0, buffer5);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder45.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
let promise12 = device0.queue.onSubmittedWorkDone();
let pipeline45 = device0.createRenderPipeline({
  label: '\u{1ff6f}\ue387\u508e\u4bef\ua1f3',
  layout: 'auto',
  multisample: {count: 4, mask: 0x59b3ffe9},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32uint', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 3188, attributes: []},
      {
        arrayStride: 4924,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x2', offset: 760, shaderLocation: 4},
          {format: 'sint32x2', offset: 440, shaderLocation: 14},
          {format: 'float32x2', offset: 236, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 7684,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 344, shaderLocation: 9}],
      },
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint16', frontFace: 'ccw'},
});
gc();
let imageData6 = new ImageData(168, 244);
try {
canvas7.getContext('webgpu');
} catch {}
let renderBundleEncoder29 = device0.createRenderBundleEncoder({label: '\u077a\ua6c8\u{1fd92}', colorFormats: ['r32uint', 'r32uint']});
try {
renderPassEncoder12.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder7.setScissorRect(20, 0, 64, 1);
} catch {}
try {
renderPassEncoder7.draw(34);
} catch {}
try {
commandEncoder45.copyBufferToBuffer(buffer9, 213100, buffer0, 413172, 2788);
dissociateBuffer(device0, buffer9);
dissociateBuffer(device0, buffer0);
} catch {}
try {
commandEncoder45.copyTextureToTexture({
  texture: texture20,
  mipLevel: 2,
  origin: {x: 3, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture17,
  mipLevel: 1,
  origin: {x: 67, y: 0, z: 0},
  aspect: 'all',
},
{width: 157, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder45.resolveQuerySet(querySet7, 2101, 246, buffer8, 44288);
} catch {}
try {
gpuCanvasContext9.unconfigure();
} catch {}
let offscreenCanvas10 = new OffscreenCanvas(442, 973);
try {
offscreenCanvas10.getContext('bitmaprenderer');
} catch {}
let textureView53 = texture1.createView({dimension: '2d', mipLevelCount: 1, baseArrayLayer: 53, arrayLayerCount: 1});
let renderPassEncoder14 = commandEncoder45.beginRenderPass({
  label: '\u0932\u8c01',
  colorAttachments: [{
  view: textureView14,
  depthSlice: 203,
  clearValue: { r: -835.9, g: 336.2, b: -224.9, a: -18.07, },
  loadOp: 'clear',
  storeOp: 'store',
}, {view: textureView29, depthSlice: 44, loadOp: 'load', storeOp: 'store'}],
  maxDrawCount: 49435682,
});
let renderBundle34 = renderBundleEncoder29.finish({label: '\u0005\u{1f8f0}\ud604\u6a06\u0050\u0758\u4ea8'});
let sampler23 = device0.createSampler({
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 3.268,
  maxAnisotropy: 1,
});
let externalTexture21 = device0.importExternalTexture({source: video4, colorSpace: 'display-p3'});
try {
renderPassEncoder1.setVertexBuffer(7754, undefined, 35615915);
} catch {}
try {
renderBundleEncoder4.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(730, undefined, 1697206960);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
gpuCanvasContext3.configure({
  device: device0,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
try {
device0.queue.writeBuffer(buffer0, 4212, new Float32Array(18006));
} catch {}
try {
  await promise12;
} catch {}
document.body.prepend(canvas7);
let imageData7 = new ImageData(28, 160);
try {
  await adapter0.requestAdapterInfo();
} catch {}
let textureView54 = texture11.createView({label: '\ub5fe\u2e47\u6bd4\u050f', baseMipLevel: 0, baseArrayLayer: 0});
try {
renderPassEncoder7.setBindGroup(5, bindGroup15, []);
} catch {}
try {
renderPassEncoder1.executeBundles([renderBundle20, renderBundle12, renderBundle3, renderBundle18, renderBundle34, renderBundle17]);
} catch {}
try {
renderPassEncoder1.setScissorRect(24, 1, 8, 0);
} catch {}
try {
renderPassEncoder7.draw(43);
} catch {}
try {
renderPassEncoder7.drawIndexed(310, 396, 636_307_163);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer4, 1_117_610_141);
} catch {}
try {
renderBundleEncoder4.draw(42, 293);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline14);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
renderPassEncoder9.popDebugGroup();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 4,
  origin: {x: 0, y: 8, z: 0},
  aspect: 'all',
}, new Uint32Array(arrayBuffer2), /* required buffer size: 25_151 */
{offset: 571, bytesPerRow: 80, rowsPerImage: 150}, {width: 5, height: 8, depthOrArrayLayers: 3});
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let offscreenCanvas11 = new OffscreenCanvas(330, 993);
let bindGroup16 = device0.createBindGroup({
  label: '\u1dc8\u2b91\uc641\uc3ff\u0304\ud08d\uf4f2',
  layout: bindGroupLayout15,
  entries: [{binding: 410, resource: externalTexture0}],
});
let textureView55 = texture1.createView({
  label: '\u05fd\u1d2e\u0c0a\u6cd5\u03be\u31e8\u{1fcf1}\u7bba\u{1f7b9}',
  dimension: '2d',
  baseMipLevel: 3,
  mipLevelCount: 4,
  baseArrayLayer: 218,
});
let externalTexture22 = device0.importExternalTexture({label: '\u856f\u2415\u{1fae5}\u{1fddd}\u926f', source: video0});
try {
computePassEncoder19.setBindGroup(1, bindGroup15);
} catch {}
try {
computePassEncoder21.end();
} catch {}
try {
computePassEncoder15.setPipeline(pipeline44);
} catch {}
try {
renderPassEncoder13.setBindGroup(2, bindGroup8);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(56);
} catch {}
try {
renderPassEncoder11.setViewport(37.29, 0.05321, 14.89, 0.6510, 0.6373, 0.7931);
} catch {}
try {
renderBundleEncoder4.draw(56, 9);
} catch {}
try {
device0.queue.writeBuffer(buffer0, 53004, new Int16Array(13203), 9227);
} catch {}
let pipeline46 = device0.createComputePipeline({
  label: '\u74bc\ubcb0\u0715\u2d94\u8fac\u50c6\u5f72\u{1fb34}\ud62a',
  layout: 'auto',
  compute: {module: shaderModule6, entryPoint: 'compute0', constants: {}},
});
let pipeline47 = device0.createRenderPipeline({
  label: '\u0d6a\u0330\u03f9\udbcc',
  layout: pipelineLayout1,
  multisample: {},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: 0}, {
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'increment-wrap'},
    stencilBack: {compare: 'always', failOp: 'decrement-clamp', passOp: 'increment-wrap'},
    stencilWriteMask: 2983651177,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {arrayStride: 11556, stepMode: 'vertex', attributes: []},
      {arrayStride: 1072, attributes: [{format: 'sint32x3', offset: 64, shaderLocation: 8}]},
      {
        arrayStride: 3244,
        attributes: [
          {format: 'uint8x4', offset: 36, shaderLocation: 13},
          {format: 'unorm16x4', offset: 640, shaderLocation: 3},
          {format: 'sint8x4', offset: 1184, shaderLocation: 12},
          {format: 'snorm8x4', offset: 852, shaderLocation: 0},
          {format: 'sint8x4', offset: 1872, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 2764,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 264, shaderLocation: 4},
          {format: 'sint16x2', offset: 596, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', cullMode: 'back'},
});
let gpuCanvasContext11 = offscreenCanvas11.getContext('webgpu');
let videoFrame7 = new VideoFrame(offscreenCanvas1, {timestamp: 0});
let commandEncoder46 = device0.createCommandEncoder({label: '\u0370\u0822\u8b3a\u110c\u{1fb54}\u4a72\ufadb\u{1fb96}'});
let querySet20 = device0.createQuerySet({type: 'occlusion', count: 411});
let renderBundleEncoder30 = device0.createRenderBundleEncoder({
  label: '\u0d7b\u78cf\u{1fb08}\u0ef2\u5c34\u05da\u{1f957}\u7177\uce64',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
});
let sampler24 = device0.createSampler({
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 73.52,
  maxAnisotropy: 9,
});
try {
renderPassEncoder1.setBindGroup(0, bindGroup1);
} catch {}
try {
renderPassEncoder9.setPipeline(pipeline6);
} catch {}
try {
renderBundleEncoder4.draw(21, 201, 250_556_643, 312_233_688);
} catch {}
try {
renderBundleEncoder4.drawIndexed(130, 115);
} catch {}
let arrayBuffer6 = buffer5.getMappedRange(14944, 10888);
let videoFrame8 = new VideoFrame(img1, {timestamp: 0});
let buffer10 = device0.createBuffer({
  label: '\u{1fbf6}\u0ca9\u243a\u5b59\u5640\u0ed9\u033d\u{1fdae}',
  size: 202627,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder47 = device0.createCommandEncoder({label: '\ua2a9\u9c68\u84dd'});
let texture21 = device0.createTexture({
  label: '\u2a26\u{1f925}\u{1f84c}\uaa0e\ue7f9\u{1fb84}\u11f7',
  size: [120, 384, 1949],
  mipLevelCount: 8,
  dimension: '3d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint', 'r32uint', 'r32uint'],
});
let renderPassEncoder15 = commandEncoder46.beginRenderPass({
  label: '\u8e77\u0b82\u4019\ua19c\ub225\ufe9c\u4d6a\u963a',
  colorAttachments: [{
  view: textureView14,
  depthSlice: 193,
  clearValue: { r: -302.5, g: -192.5, b: -992.6, a: -941.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView13,
  depthSlice: 302,
  clearValue: { r: 809.2, g: -457.7, b: 678.3, a: 751.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet20,
  maxDrawCount: 1091420177,
});
let renderBundle35 = renderBundleEncoder13.finish({label: '\u845d\u795d'});
try {
computePassEncoder1.end();
} catch {}
try {
renderPassEncoder4.setBindGroup(4, bindGroup4, new Uint32Array(2373), 1312, 0);
} catch {}
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.setBlendConstant({ r: -195.4, g: -175.8, b: 81.01, a: -962.4, });
} catch {}
try {
renderPassEncoder10.setScissorRect(550, 1, 713, 0);
} catch {}
try {
renderPassEncoder7.draw(139, 82);
} catch {}
try {
renderPassEncoder7.drawIndexed(351, 114, 607_902_871, 35_813_132, 393_338_043);
} catch {}
try {
renderBundleEncoder4.draw(48, 67, 215_138_152, 241_187_667);
} catch {}
let promise13 = buffer0.mapAsync(GPUMapMode.READ, 48688);
try {
commandEncoder47.resolveQuerySet(querySet0, 657, 144, buffer8, 20224);
} catch {}
let bindGroupLayout18 = device0.createBindGroupLayout({
  label: '\u682f\u44c5\u0a75\u056f\uadcc\uac7e',
  entries: [
    {binding: 40, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
    {binding: 1501, visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT, externalTexture: {}},
  ],
});
let commandEncoder48 = device0.createCommandEncoder({});
let querySet21 = device0.createQuerySet({
  label: '\u{1f9ae}\u00c9\uc27d\ua501\u1994\u{1fd50}\uf13d\u41c7\ua324\u0659\u5348',
  type: 'occlusion',
  count: 2925,
});
let renderBundle36 = renderBundleEncoder7.finish({label: '\u5d0c\ubc46\u4b6f\u6214\u0d27\u2612\u{1f891}'});
let sampler25 = device0.createSampler({
  label: '\u0a5c\u045f\u0e82\u{1f918}\ub34b\u{1fd6b}\u0e68',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  lodMinClamp: 43.00,
  lodMaxClamp: 87.35,
  compare: 'equal',
});
try {
computePassEncoder14.setPipeline(pipeline42);
} catch {}
try {
renderPassEncoder1.setBlendConstant({ r: 492.2, g: 503.7, b: 572.1, a: 446.4, });
} catch {}
try {
renderBundleEncoder4.draw(56);
} catch {}
try {
texture14.destroy();
} catch {}
try {
device0.queue.writeTexture({
  texture: texture13,
  mipLevel: 0,
  origin: {x: 215, y: 0, z: 6},
  aspect: 'all',
}, new ArrayBuffer(24), /* required buffer size: 26_800_377 */
{offset: 869, bytesPerRow: 2232, rowsPerImage: 174}, {width: 529, height: 1, depthOrArrayLayers: 70});
} catch {}
let promise14 = device0.createComputePipelineAsync({
  label: '\u0f74\ucbdc\u6e31\u0120\u0315\u403c\u0867\u{1f7f3}',
  layout: pipelineLayout1,
  compute: {module: shaderModule1, entryPoint: 'compute0'},
});
gc();
let shaderModule7 = device0.createShaderModule({
  label: '\u{1fe25}\u{1f9b2}',
  code: `@group(4) @binding(673)
var<storage, read_write> type5: array<u32>;
@group(5) @binding(3004)
var<storage, read_write> parameter7: array<u32>;
@group(4) @binding(1151)
var<storage, read_write> field2: array<u32>;
@group(2) @binding(3796)
var<storage, read_write> parameter8: array<u32>;
@group(5) @binding(186)
var<storage, read_write> n3: array<u32>;
@group(1) @binding(2477)
var<storage, read_write> local3: array<u32>;
@group(4) @binding(1019)
var<storage, read_write> type6: array<u32>;
@group(6) @binding(2477)
var<storage, read_write> global1: array<u32>;
@group(3) @binding(3796)
var<storage, read_write> global2: array<u32>;
@group(5) @binding(424)
var<storage, read_write> global3: array<u32>;
@group(3) @binding(3374)
var<storage, read_write> parameter9: 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(4) f0: f32,
  @location(0) f1: u32,
  @builtin(sample_mask) f2: u32,
  @location(1) f3: vec3<u32>
}

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

struct S8 {
  @location(1) f0: f16,
  @location(2) f1: vec3<f16>,
  @location(6) f2: vec2<f16>,
  @location(12) f3: vec3<f32>,
  @location(14) f4: u32,
  @location(11) f5: vec2<u32>,
  @location(13) f6: vec4<u32>,
  @location(9) f7: vec3<f16>,
  @location(3) f8: f32,
  @location(15) f9: vec3<u32>,
  @location(4) f10: i32
}

@vertex
fn vertex0(@location(7) a0: vec2<f16>, @location(8) a1: vec4<u32>, @location(0) a2: u32, a3: S8, @location(5) a4: f16, @location(10) a5: i32, @builtin(vertex_index) a6: u32, @builtin(instance_index) a7: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder49 = device0.createCommandEncoder();
try {
computePassEncoder12.setPipeline(pipeline37);
} catch {}
try {
renderPassEncoder13.setBindGroup(1, bindGroup10);
} catch {}
try {
renderBundleEncoder22.setBindGroup(2, bindGroup5);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(7713, undefined, 0);
} catch {}
try {
commandEncoder47.resolveQuerySet(querySet5, 394, 845, buffer8, 51968);
} catch {}
let canvas8 = document.createElement('canvas');
let buffer11 = device0.createBuffer({label: '\u05fa\u91b9\u3115\u6601\u{1ff00}\u3ef1', size: 159679, usage: GPUBufferUsage.MAP_WRITE});
let commandEncoder50 = device0.createCommandEncoder();
let querySet22 = device0.createQuerySet({label: '\u09e8\u0f76\u9a2d\u78e1', type: 'occlusion', count: 2558});
let texture22 = device0.createTexture({
  label: '\ud485\ue4ad\u20cf\u7e80\u046e\u{1f673}\u07e1\u0df0\u0f11',
  size: {width: 1920},
  dimension: '1d',
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['r32uint', 'r32uint'],
});
let textureView56 = texture15.createView({label: '\u1182\u4a6c\u202a\u05ad\u316f\u0671', aspect: 'all', baseMipLevel: 6});
let renderPassEncoder16 = commandEncoder5.beginRenderPass({
  label: '\u{1fabf}\u3eaa\ueaf2\u8763\u0029\ud0c4\u{1ffbc}\uf982\u{1fb7b}',
  colorAttachments: [{
  view: textureView23,
  depthSlice: 161,
  clearValue: { r: 89.33, g: 525.5, b: -113.5, a: 795.0, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView28,
  depthSlice: 14,
  clearValue: { r: 304.4, g: 526.2, b: -402.5, a: 103.2, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet11,
  maxDrawCount: 795706827,
});
try {
renderPassEncoder9.setScissorRect(85, 1, 1, 0);
} catch {}
try {
renderPassEncoder7.drawIndexed(495, 29, 430_391_709, -2_023_829_245, 174_312_482);
} catch {}
try {
renderBundleEncoder30.drawIndexed(24);
} catch {}
try {
renderBundleEncoder12.setVertexBuffer(6954, undefined, 3680864689, 39034145);
} catch {}
try {
commandEncoder48.copyTextureToTexture({
  texture: texture12,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 463, y: 0, z: 0},
  aspect: 'all',
},
{width: 1906, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device0.queue.writeTexture({
  texture: texture5,
  mipLevel: 4,
  origin: {x: 1, y: 2, z: 1},
  aspect: 'all',
}, new Uint8ClampedArray(arrayBuffer6), /* required buffer size: 41_529 */
{offset: 603, bytesPerRow: 259, rowsPerImage: 51}, {width: 1, height: 6, depthOrArrayLayers: 4});
} catch {}
let pipeline48 = await promise9;
video4.height = 149;
let pipelineLayout6 = device0.createPipelineLayout({
  bindGroupLayouts: [bindGroupLayout12, bindGroupLayout15, bindGroupLayout4, bindGroupLayout11, bindGroupLayout7, bindGroupLayout11],
});
let textureView57 = texture14.createView({baseMipLevel: 5});
let externalTexture23 = device0.importExternalTexture({label: '\u0967\ub171\u02db', source: video2, colorSpace: 'display-p3'});
try {
renderPassEncoder1.setVertexBuffer(4358, undefined);
} catch {}
try {
renderBundleEncoder12.setPipeline(pipeline27);
} catch {}
try {
buffer9.unmap();
} catch {}
try {
commandEncoder47.copyBufferToTexture({
  /* bytesInLastRow: 496 widthInBlocks: 124 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 15196 */
  offset: 15196,
  buffer: buffer3,
}, {
  texture: texture18,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
}, {width: 124, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device0, buffer3);
} catch {}
let pipeline49 = await promise8;
let renderPassEncoder17 = commandEncoder50.beginRenderPass({
  label: '\uf70f\u7c08\u0915\u{1fe85}\uc524\u6fcb\ub8f3\u751d',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 156,
  clearValue: { r: 620.7, g: 957.1, b: -793.5, a: -76.50, },
  loadOp: 'load',
  storeOp: 'discard',
}, {view: textureView43, depthSlice: 343, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet14,
  maxDrawCount: 1077976180,
});
let externalTexture24 = device0.importExternalTexture({label: '\u2e95\u{1fc24}', source: video2, colorSpace: 'display-p3'});
try {
renderPassEncoder11.setBindGroup(3, bindGroup15);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(546);
} catch {}
try {
renderPassEncoder10.setScissorRect(94, 1, 446, 0);
} catch {}
try {
renderBundleEncoder22.setBindGroup(0, bindGroup12, new Uint32Array(51), 14, 0);
} catch {}
try {
commandEncoder47.clearBuffer(buffer0);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture20,
  mipLevel: 3,
  origin: {x: 12, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(66_700), /* required buffer size: 66_700 */
{offset: 172, bytesPerRow: 252, rowsPerImage: 132}, {width: 36, height: 0, depthOrArrayLayers: 3});
} catch {}
let pipeline50 = device0.createRenderPipeline({
  label: '\u{1feef}\ue850\u1e3a\ua31e',
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0xa3b67d7a},
  fragment: {
  module: shaderModule4,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'r32uint', writeMask: GPUColorWrite.ALL}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'always', failOp: 'zero', depthFailOp: 'decrement-wrap'},
    stencilBack: {
      compare: 'less-equal',
      failOp: 'increment-clamp',
      depthFailOp: 'decrement-wrap',
      passOp: 'increment-wrap',
    },
    stencilReadMask: 2827681266,
    stencilWriteMask: 1697463802,
    depthBias: -462687772,
    depthBiasSlopeScale: 372.5515013090153,
    depthBiasClamp: 407.5727936087835,
  },
  vertex: {
    module: shaderModule4,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 15764,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 1916, shaderLocation: 1},
          {format: 'sint32', offset: 84, shaderLocation: 2},
          {format: 'snorm16x4', offset: 8704, shaderLocation: 4},
          {format: 'sint32x3', offset: 2440, shaderLocation: 9},
          {format: 'sint32x2', offset: 1152, shaderLocation: 7},
          {format: 'float32x4', offset: 4200, shaderLocation: 13},
          {format: 'sint32x2', offset: 160, shaderLocation: 12},
          {format: 'uint32x3', offset: 200, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 17392,
        attributes: [
          {format: 'uint8x2', offset: 8014, shaderLocation: 14},
          {format: 'uint32', offset: 3080, shaderLocation: 6},
          {format: 'uint8x2', offset: 9782, shaderLocation: 3},
        ],
      },
      {arrayStride: 14224, stepMode: 'instance', attributes: []},
      {arrayStride: 6712, stepMode: 'instance', attributes: []},
      {
        arrayStride: 10228,
        stepMode: 'instance',
        attributes: [{format: 'snorm8x4', offset: 172, shaderLocation: 5}],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
try {
device0.destroy();
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) };
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let img5 = await imageWithData(206, 152, '#c738eae1', '#75f2f8ac');
let video5 = await videoWithData();
let gpuCanvasContext12 = canvas8.getContext('webgpu');
let shaderModule8 = device0.createShaderModule({
  label: '\u02c0\ub9f9\u0375\u0439\uf320\u2439\u77df\u82be',
  code: `@group(0) @binding(1303)
var<storage, read_write> parameter10: array<u32>;
@group(0) @binding(2198)
var<storage, read_write> n4: array<u32>;
@group(0) @binding(55)
var<storage, read_write> local4: array<u32>;
@group(1) @binding(2477)
var<storage, read_write> field3: array<u32>;

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

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

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

struct S9 {
  @location(12) f0: vec3<i32>,
  @location(3) f1: vec2<u32>,
  @location(14) f2: i32,
  @location(9) f3: f32,
  @location(5) f4: u32,
  @location(11) f5: vec4<u32>
}

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

`,
  hints: {},
});
let buffer12 = device0.createBuffer({
  label: '\u6cba\u{1fd26}\u{1fe23}\u7999',
  size: 147291,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let commandEncoder51 = device0.createCommandEncoder();
let querySet23 = device0.createQuerySet({
  label: '\u{1f88c}\u{1fd21}\u9205\uf606\u6e33\u07c0\u07bd\uaa91\u8f1a\u{1f9fe}\u0305',
  type: 'occlusion',
  count: 1624,
});
let renderPassEncoder18 = commandEncoder47.beginRenderPass({
  label: '\uf7b4\u{1fbd8}\u7b6a\u514f\u06a4\u0cbf\u25ea\u70f6\u5f4d',
  colorAttachments: [{
  view: textureView43,
  depthSlice: 172,
  clearValue: { r: 917.3, g: 994.3, b: 243.6, a: 763.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView29,
  depthSlice: 208,
  clearValue: { r: -662.6, g: 181.0, b: -336.4, a: -150.6, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet3,
  maxDrawCount: 829227304,
});
let sampler26 = device0.createSampler({
  label: '\u03c8\ua8c3\u6b50\u1084\u03c0\u{1fc41}\u027b',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 31.75,
  lodMaxClamp: 38.96,
});
try {
renderPassEncoder1.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.executeBundles([renderBundle6, renderBundle33, renderBundle11, renderBundle21, renderBundle5, renderBundle22, renderBundle8, renderBundle6]);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer0, 718_954_273);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer12, 351_539_465);
} catch {}
try {
  await buffer10.mapAsync(GPUMapMode.WRITE, 124752, 21684);
} catch {}
try {
commandEncoder43.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
let pipeline51 = device0.createRenderPipeline({
  label: '\uc7a5\u894d\u{1feca}\u3c93\u3428\u35e6\u29df\ue5a9\u3432\uaae6',
  layout: pipelineLayout4,
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'r32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 13676,
        stepMode: 'instance',
        attributes: [
          {format: 'sint8x4', offset: 4356, shaderLocation: 9},
          {format: 'unorm8x4', offset: 1628, shaderLocation: 3},
          {format: 'sint16x4', offset: 8840, shaderLocation: 12},
          {format: 'sint16x4', offset: 132, shaderLocation: 5},
          {format: 'sint32x3', offset: 3252, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 292,
        attributes: [
          {format: 'uint32x4', offset: 12, shaderLocation: 13},
          {format: 'unorm8x2', offset: 0, shaderLocation: 4},
        ],
      },
      {arrayStride: 1440, attributes: [{format: 'unorm8x4', offset: 40, shaderLocation: 0}]},
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: true},
});
try {
renderBundleEncoder18.label = '\u06af\u{1f620}\u0a9c\ud89a\u{1fe42}\u03b8\u0778\u0046';
} catch {}
document.body.prepend(video3);
try {
texture18.label = '\u4c31\u0dff\u0088\u0f93\u0f72';
} catch {}
offscreenCanvas2.height = 319;
try {
gpuCanvasContext5.unconfigure();
} catch {}
try {
  await promise13;
} catch {}
gc();
let videoFrame9 = new VideoFrame(img1, {timestamp: 0});
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let imageData8 = new ImageData(160, 156);
let video6 = await videoWithData();
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
gc();
video0.width = 77;
gc();
let img6 = await imageWithData(285, 200, '#e9cf085c', '#b9d65c8b');
let videoFrame10 = videoFrame0.clone();
let offscreenCanvas12 = new OffscreenCanvas(764, 929);
let imageData9 = new ImageData(212, 116);
try {
adapter1.label = '\u{1fe4e}\ua21c\u{1ff2a}\u2026\u0a8f\u{1f727}\u06f9\u0095\u{1f8e0}\u{1f7d2}\u0adc';
} catch {}
document.body.prepend(canvas4);
let canvas9 = document.createElement('canvas');
let gpuCanvasContext13 = canvas9.getContext('webgpu');
canvas3.width = 7;
let canvas10 = document.createElement('canvas');
offscreenCanvas1.width = 677;
let offscreenCanvas13 = new OffscreenCanvas(531, 478);
try {
canvas10.getContext('webgl');
} catch {}
document.body.prepend(img0);
try {
window.someLabel = bindGroupLayout2.label;
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
try {
offscreenCanvas13.getContext('webgpu');
} catch {}
document.body.prepend(canvas7);
canvas4.height = 1731;
let offscreenCanvas14 = new OffscreenCanvas(686, 860);
let imageData10 = new ImageData(152, 84);
let img7 = await imageWithData(109, 283, '#63ec5b37', '#76863b1e');
let imageBitmap10 = await createImageBitmap(video4);
let bindGroupLayout19 = device0.createBindGroupLayout({entries: []});
let textureView58 = texture7.createView({label: '\ud6bf\u0145'});
let renderBundleEncoder31 = device0.createRenderBundleEncoder({
  label: '\ub5f3\ufe00\u0286\u{1fee7}\u7d1e',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: false,
});
try {
renderPassEncoder17.beginOcclusionQuery(764);
} catch {}
try {
renderPassEncoder7.draw(64, 89, 1_768_267_676, 132_585_739);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(4295, undefined, 327922182, 2953244259);
} catch {}
try {
renderBundleEncoder30.drawIndexed(118, 519, 41_916_488, 174_117_613, 852_784_136);
} catch {}
try {
renderBundleEncoder30.setVertexBuffer(8004, undefined);
} catch {}
let pipeline52 = device0.createComputePipeline({
  label: '\u4ebc\u20c6\u7c11\u385e\u2e92',
  layout: pipelineLayout3,
  compute: {module: shaderModule3, entryPoint: 'compute0', constants: {}},
});
let pipeline53 = device0.createRenderPipeline({
  label: '\u{1f877}\u0112\u9697\u1a05\u{1f7f4}\uaad1\u{1f7e0}\uf208',
  layout: pipelineLayout2,
  fragment: {
  module: shaderModule6,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALPHA}, {format: 'r32uint', writeMask: GPUColorWrite.BLUE}],
},
  depthStencil: {
    format: 'stencil8',
    depthWriteEnabled: false,
    stencilFront: {compare: 'less-equal', failOp: 'decrement-clamp', depthFailOp: 'replace', passOp: 'increment-clamp'},
    stencilBack: {compare: 'greater', failOp: 'replace', depthFailOp: 'zero', passOp: 'increment-wrap'},
    stencilReadMask: 3560280289,
    depthBiasSlopeScale: 672.6687743205991,
    depthBiasClamp: 782.9512575476951,
  },
  vertex: {module: shaderModule6, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
video5.height = 179;
try {
offscreenCanvas14.getContext('bitmaprenderer');
} catch {}
let imageBitmap11 = await createImageBitmap(canvas4);
let videoFrame11 = new VideoFrame(imageBitmap3, {timestamp: 0});
let offscreenCanvas15 = new OffscreenCanvas(611, 488);
let img8 = await imageWithData(175, 245, '#643b77c5', '#fb96d9b8');
document.body.prepend(img7);
let canvas11 = document.createElement('canvas');
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let imageBitmap12 = await createImageBitmap(canvas1);
let videoFrame12 = new VideoFrame(img8, {timestamp: 0});
let gpuCanvasContext14 = offscreenCanvas15.getContext('webgpu');
offscreenCanvas7.height = 265;
let gpuCanvasContext15 = offscreenCanvas12.getContext('webgpu');
let promise15 = adapter0.requestAdapterInfo();
try {
adapter0.label = '\u3ad8\u02a3\u526a\u{1f754}\u0c78\u{1fc32}';
} catch {}
document.body.prepend(video2);
try {
  await promise15;
} catch {}
try {
externalTexture3.label = '\u0a29\u{1fa31}\u0f9b\u0c56\uf647\u03e3\u0d6b';
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
let gpuCanvasContext16 = canvas11.getContext('webgpu');
let offscreenCanvas16 = new OffscreenCanvas(664, 757);
let offscreenCanvas17 = new OffscreenCanvas(217, 111);
let offscreenCanvas18 = new OffscreenCanvas(573, 850);
try {
window.someLabel = externalTexture6.label;
} catch {}
let imageData11 = new ImageData(112, 136);
try {
window.someLabel = externalTexture3.label;
} catch {}
let gpuCanvasContext17 = offscreenCanvas16.getContext('webgpu');
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let canvas12 = document.createElement('canvas');
video5.width = 146;
let textureView59 = texture11.createView({
  label: '\u{1fc71}\u515b\u{1f851}\u3d17\ua54a\u{1f931}\u{1f98c}\u3e0c\u{1ffed}\u43b4',
  dimension: '2d-array',
  baseMipLevel: 0,
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
let sampler27 = device0.createSampler({
  label: '\ua349\ub654\ua64a\u0d70\u06d8',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  lodMinClamp: 91.61,
  lodMaxClamp: 97.06,
  compare: 'less',
});
let externalTexture25 = device0.importExternalTexture({source: video6, colorSpace: 'display-p3'});
try {
renderPassEncoder9.setStencilReference(2719);
} catch {}
try {
renderPassEncoder7.draw(15, 87, 833_399_427, 945_363_368);
} catch {}
try {
renderPassEncoder7.drawIndexed(120, 22, 297_341_053, -1_383_866_748, 120_901_272);
} catch {}
try {
renderPassEncoder7.drawIndexedIndirect(buffer6, 1_604_325_891);
} catch {}
try {
renderPassEncoder10.setPipeline(pipeline19);
} catch {}
try {
renderBundleEncoder30.drawIndexed(85, 50);
} catch {}
try {
renderBundleEncoder30.setPipeline(pipeline6);
} catch {}
try {
commandEncoder49.copyTextureToTexture({
  texture: texture7,
  mipLevel: 0,
  origin: {x: 17, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 0,
  origin: {x: 2680, y: 0, z: 0},
  aspect: 'all',
},
{width: 174, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder51.clearBuffer(buffer2);
dissociateBuffer(device0, buffer2);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let device1 = await adapter1.requestDevice({
  label: '\u0891\u{1fca3}\u03e0\u11bc',
  defaultQueue: {label: '\ua4b5\u1d69\u4be6\u{1ffd5}\uea0e\u1686\u{1f843}\u0ce9\ub83f\u04af'},
  requiredFeatures: [
    'depth-clip-control',
    'depth32float-stencil8',
    'texture-compression-etc2',
    'texture-compression-astc',
    'indirect-first-instance',
    'shader-f16',
    'rg11b10ufloat-renderable',
  ],
  requiredLimits: {
    maxBindGroups: 8,
    maxVertexAttributes: 27,
    maxVertexBufferArrayStride: 10071,
    maxStorageTexturesPerShaderStage: 12,
    maxStorageBuffersPerShaderStage: 19,
    maxDynamicStorageBuffersPerPipelineLayout: 6972,
    maxDynamicUniformBuffersPerPipelineLayout: 8585,
    maxBindingsPerBindGroup: 5262,
    maxTextureArrayLayers: 1332,
    maxTextureDimension1D: 15751,
    maxTextureDimension2D: 16107,
    maxBindGroupsPlusVertexBuffers: 27,
    minStorageBufferOffsetAlignment: 64,
    minUniformBufferOffsetAlignment: 64,
    maxUniformBufferBindingSize: 180050035,
    maxStorageBufferBindingSize: 221049690,
    maxUniformBuffersPerShaderStage: 19,
    maxSampledTexturesPerShaderStage: 33,
    maxInterStageShaderVariables: 48,
    maxInterStageShaderComponents: 100,
    maxSamplersPerShaderStage: 22,
  },
});
let commandEncoder52 = device1.createCommandEncoder({});
let computePassEncoder22 = commandEncoder52.beginComputePass({label: '\ua631\u1434\u833f\u01fc\u0d97\u{1fffc}\u0d10\u96b9\u532c\u{1fd79}'});
let sampler28 = device1.createSampler({
  label: '\u0d54\u9ba9\u1f98\u0da0',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMaxClamp: 81.06,
});
try {
computePassEncoder22.end();
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
document.body.prepend(canvas7);
gc();
let computePassEncoder23 = commandEncoder52.beginComputePass({label: '\ue859\u{1fe07}\ud9b0\u3956\uc31e\u2f69\u{1f604}\ucb28\u2637\u{1fabc}'});
document.body.prepend(img5);
let bindGroupLayout20 = device1.createBindGroupLayout({label: '\u5381\u{1fbe1}', entries: []});
let commandEncoder53 = device1.createCommandEncoder({label: '\u074d\u1541\u{1f8da}\u2ee5\u7e74\u1190'});
let renderBundleEncoder32 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], stencilReadOnly: true});
let sampler29 = device1.createSampler({
  label: '\u7f59\u7d97',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 36.69,
  lodMaxClamp: 63.23,
  maxAnisotropy: 11,
});
try {
computePassEncoder23.insertDebugMarker('\u{1f72b}');
} catch {}
gc();
let commandEncoder54 = device1.createCommandEncoder({label: '\u3b8c\ubada\u0265\u60db\uff35\u9fc9'});
let computePassEncoder24 = commandEncoder54.beginComputePass({label: '\u{1fa00}\u00ac\u{1f756}'});
let renderBundleEncoder33 = device1.createRenderBundleEncoder({
  label: '\u0cf9\u3387\u6148\u0b91\u00b1\u{1ff11}\u2e7b',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  sampleCount: 1,
  depthReadOnly: true,
});
let renderBundle37 = renderBundleEncoder33.finish({label: '\ubcba\u4c5d\ua690\ufe6d\u5c16'});
try {
renderBundleEncoder32.setVertexBuffer(9324, undefined, 0, 144936190);
} catch {}
let pipelineLayout7 = device1.createPipelineLayout({label: '\u55c9\u29a6', bindGroupLayouts: [bindGroupLayout20, bindGroupLayout20, bindGroupLayout20]});
let querySet24 = device1.createQuerySet({label: '\u{1fda7}\uf629\u0e0e\ue0bc\u0580', type: 'occlusion', count: 2167});
let computePassEncoder25 = commandEncoder53.beginComputePass({label: '\u{1f861}\u06f3\u016e\ua1f1\u{1fd78}\u0650'});
let renderBundle38 = renderBundleEncoder32.finish({label: '\u3f1b\u0b0a\u68d1\u65a5\u0838\u8c2e'});
try {
adapter1.label = '\u343a\ue33a\uf6ad\u0bab\u6f6c';
} catch {}
try {
pipeline47.label = '\u04a8\u3f50\u08a0\u{1ffce}\uc1bc';
} catch {}
let video7 = await videoWithData();
let imageData12 = new ImageData(204, 240);
let bindGroup17 = device1.createBindGroup({label: '\u048d\u{1fce4}\u{1f6c9}\u58f6\u{1fd4c}\ue62e', layout: bindGroupLayout20, entries: []});
let commandEncoder55 = device1.createCommandEncoder({});
let computePassEncoder26 = commandEncoder55.beginComputePass({label: '\u{1f6d5}\u{1f8f6}\u{1fec9}\u{1fb48}\u073f\u6007'});
try {
window.someLabel = externalTexture4.label;
} catch {}
gc();
let querySet25 = device1.createQuerySet({label: '\u11a2\u69b4\u3bd8\u0099\u0f90\uaca2\u0a6e\u{1fe1f}\u0cde', type: 'occlusion', count: 1020});
let texture23 = device1.createTexture({
  label: '\u{1fb37}\u48e6\u{1fa97}\u5acf\u845d\u0b29\u3b74\u81f1\u{1fc5f}\u8758',
  size: {width: 48, height: 64, depthOrArrayLayers: 2},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32float'],
});
let externalTexture26 = device1.importExternalTexture({source: videoFrame9, colorSpace: 'srgb'});
let video8 = await videoWithData();
let texture24 = device1.createTexture({
  label: '\ue895\u{1f792}',
  size: {width: 48, height: 64, depthOrArrayLayers: 2},
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32float', 'rgba32float', 'rgba32float'],
});
let textureView60 = texture24.createView({format: 'rgba32float'});
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
let promise16 = device1.queue.onSubmittedWorkDone();
let gpuCanvasContext18 = offscreenCanvas18.getContext('webgpu');
let renderBundleEncoder34 = device1.createRenderBundleEncoder({
  label: '\u{1f639}\u{1f895}\ud2a2\u73e4',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
try {
  await promise16;
} catch {}
document.body.prepend(img4);
let buffer13 = device1.createBuffer({
  label: '\uf14e\u08eb\u42ec\u01f8\uc91f',
  size: 63900,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let texture25 = gpuCanvasContext3.getCurrentTexture();
let renderBundleEncoder35 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], depthReadOnly: true, stencilReadOnly: true});
try {
buffer13.unmap();
} catch {}
let bindGroupLayout21 = device1.createBindGroupLayout({
  label: '\u2202\ua16d\u2202\u3f0b\u0164\u5b58\u8e0c',
  entries: [
    {
      binding: 4560,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
    },
  ],
});
let bindGroup18 = device1.createBindGroup({label: '\u{1f7ea}\ube3c', layout: bindGroupLayout20, entries: []});
let buffer14 = device1.createBuffer({
  label: '\ub264\u43b6\u{1f743}\uc146\ufa5a\u0922\u9ca7\u6fa2\u8b7e',
  size: 71490,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.INDIRECT | GPUBufferUsage.VERTEX,
});
let renderBundle39 = renderBundleEncoder34.finish({label: '\u{1fd5f}\uf800\u452a\uc036\u0333\uc1c4\u6651'});
try {
gpuCanvasContext8.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let img9 = await imageWithData(127, 220, '#793563f4', '#29d0c64e');
let commandEncoder56 = device1.createCommandEncoder({label: '\uae46\u0f48\u97d4\u02e3\u6aa2\u27f7\u{1f95b}\u47f5'});
let commandBuffer16 = commandEncoder56.finish({label: '\ue371\u{1fcca}'});
let renderBundle40 = renderBundleEncoder34.finish({label: '\ub6f2\u049c\u079d\u054a\u{1fdde}\u1a96\u56db\ubd76\u23b6\u0c4b\ua4a3'});
let sampler30 = device1.createSampler({
  label: '\u7414\u9bed\u8376\ub821\u05a5\u55bd\u{1f71e}\u0dd2\u0b04',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 28.31,
  lodMaxClamp: 78.85,
});
let externalTexture27 = device1.importExternalTexture({label: '\u1a01\u0830', source: videoFrame12, colorSpace: 'srgb'});
try {
renderBundleEncoder35.setVertexBuffer(0, buffer14, 0, 21981);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 4860, new Float32Array(25807), 14767, 720);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 1, y: 18, z: 0},
  aspect: 'all',
}, new ArrayBuffer(175), /* required buffer size: 175 */
{offset: 175, bytesPerRow: 624}, {width: 37, height: 10, depthOrArrayLayers: 0});
} catch {}
let texture26 = device1.createTexture({
  label: '\u376f\u3af9\ub725\u92f0\u1355\u504d\u00ad\ubcda\u0c6d\u0497\u068f',
  size: [4900, 6, 38],
  mipLevelCount: 3,
  format: 'astc-10x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
try {
renderBundleEncoder35.setVertexBuffer(0, buffer14, 0, 46078);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Uint16Array(arrayBuffer4), /* required buffer size: 207_578 */
{offset: 66, bytesPerRow: 552, rowsPerImage: 332}, {width: 32, height: 44, depthOrArrayLayers: 2});
} catch {}
let video9 = await videoWithData();
let commandEncoder57 = device1.createCommandEncoder({});
try {
commandEncoder57.copyBufferToBuffer(buffer13, 52324, buffer14, 37192, 3160);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 220, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 2,
  origin: {x: 50, y: 0, z: 0},
  aspect: 'all',
},
{width: 840, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder57.clearBuffer(buffer14, 15040, 42956);
dissociateBuffer(device1, buffer14);
} catch {}
let gpuCanvasContext19 = canvas12.getContext('webgpu');
offscreenCanvas16.width = 416;
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let offscreenCanvas19 = new OffscreenCanvas(97, 786);
let video10 = await videoWithData();
try {
offscreenCanvas17.getContext('webgl2');
} catch {}
let commandEncoder58 = device1.createCommandEncoder({label: '\u5825\u{1f745}\uc363\u552f\ufe76\u6f8c'});
let renderBundleEncoder36 = device1.createRenderBundleEncoder({label: '\u0c40\u0d51', colorFormats: ['r16float', 'rg32float', 'rgba32float']});
try {
renderBundleEncoder36.setBindGroup(2, bindGroup18);
} catch {}
try {
commandEncoder57.copyBufferToTexture({
  /* bytesInLastRow: 704 widthInBlocks: 44 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 8304 */
  offset: 2480,
  bytesPerRow: 1024,
  buffer: buffer13,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 18, z: 0},
  aspect: 'all',
}, {width: 44, height: 6, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer13);
} catch {}
let bindGroup19 = device1.createBindGroup({
  label: '\u01ba\u0637\u038a\u{1fe74}\u{1fb8a}\u0103\u825a\u18eb',
  layout: bindGroupLayout20,
  entries: [],
});
let commandEncoder59 = device1.createCommandEncoder();
let textureView61 = texture26.createView({format: 'astc-10x6-unorm-srgb', baseArrayLayer: 10, arrayLayerCount: 11});
let renderBundle41 = renderBundleEncoder32.finish({});
offscreenCanvas11.height = 696;
let commandEncoder60 = device1.createCommandEncoder();
try {
renderBundleEncoder36.setBindGroup(6, bindGroup18, []);
} catch {}
try {
commandEncoder58.copyTextureToBuffer({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 5},
  aspect: 'all',
}, {
  /* bytesInLastRow: 5792 widthInBlocks: 362 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 27568 */
  offset: 21776,
  buffer: buffer14,
}, {width: 3620, height: 6, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder57.clearBuffer(buffer14, 22116, 47936);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 10, y: 0, z: 8},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 18_746_855 */
{offset: 535, bytesPerRow: 7559, rowsPerImage: 248}, {width: 4540, height: 0, depthOrArrayLayers: 11});
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
document.body.prepend(img9);
try {
offscreenCanvas19.getContext('webgl');
} catch {}
let commandEncoder61 = device1.createCommandEncoder({label: '\u59f2\u{1f8a8}\u0e2d'});
let querySet26 = device1.createQuerySet({label: '\ua0dd\u{1fa44}\u{1fd03}\u7744\u{1f959}', type: 'occlusion', count: 3125});
let textureView62 = texture26.createView({label: '\u6a99\u024a\u0634\u028b\uf2bb', baseMipLevel: 2, baseArrayLayer: 12, arrayLayerCount: 11});
let externalTexture28 = device1.importExternalTexture({label: '\u9b88\u0211\u{1f84c}\u19cd\u3c93', source: video6});
try {
renderBundleEncoder35.setBindGroup(3, bindGroup19, new Uint32Array(7559), 3140, 0);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(4, buffer14, 0, 1240);
} catch {}
try {
buffer13.destroy();
} catch {}
try {
commandEncoder60.copyBufferToBuffer(buffer13, 41904, buffer14, 59184, 2876);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder60.copyTextureToTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 220, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 250, y: 0, z: 0},
  aspect: 'all',
},
{width: 2530, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 90_224 */
{offset: 132, bytesPerRow: 582, rowsPerImage: 96}, {width: 29, height: 59, depthOrArrayLayers: 2});
} catch {}
let offscreenCanvas20 = new OffscreenCanvas(1, 831);
let video11 = await videoWithData();
let imageData13 = new ImageData(8, 172);
let commandEncoder62 = device1.createCommandEncoder();
let renderBundle42 = renderBundleEncoder32.finish();
try {
commandEncoder60.clearBuffer(buffer14, 33332, 27736);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 9240, new Float32Array(2610), 683, 256);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture26,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 5},
  aspect: 'all',
}, new ArrayBuffer(138_119), /* required buffer size: 138_119 */
{offset: 839, bytesPerRow: 330, rowsPerImage: 104}, {width: 160, height: 0, depthOrArrayLayers: 5});
} catch {}
let commandEncoder63 = device1.createCommandEncoder({label: '\u07aa\ub85b\u59e5\u142a\u0a2b\uc6be\u96eb'});
let renderBundleEncoder37 = device1.createRenderBundleEncoder({
  label: '\u1201\u25c3\u{1f9d0}\u2a6c\u{1f6f5}\u{1fd1b}\u6ffc\u07e5\ub49f',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let sampler31 = device1.createSampler({
  label: '\u{1f8b0}\u348d\ub922\u09d1\u{1fa0e}\u{1f6f9}\u0f26\u269d\ub05d',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMaxClamp: 98.38,
});
let externalTexture29 = device1.importExternalTexture({label: '\u8f36\u{1ff78}\u4b86\u5f5e', source: video10, colorSpace: 'srgb'});
try {
commandEncoder61.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 9352 */
  offset: 9352,
  bytesPerRow: 0,
  buffer: buffer13,
}, {
  texture: texture23,
  mipLevel: 3,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 2, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
gpuCanvasContext19.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let commandBuffer17 = commandEncoder62.finish({label: '\u95cc\u09b2\u036a\u08f5\u092d\u{1ffe6}\u9913\u8978'});
let textureView63 = texture25.createView({label: '\u492e\u0e41\u{1fec9}\u1368\u0e65\u6034', dimension: '2d-array'});
let renderBundleEncoder38 = device1.createRenderBundleEncoder({
  label: '\u9ce0\u1218\uf0dc\uc07c\u6c2b\u0757\ue09b',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
try {
commandEncoder57.copyBufferToBuffer(buffer13, 15552, buffer14, 9256, 32336);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 24, height: 32, depthOrArrayLayers: 1}
*/
{
  source: videoFrame6,
  origin: { x: 12, y: 51 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let canvas13 = document.createElement('canvas');
let bindGroup20 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let commandEncoder64 = device1.createCommandEncoder({label: '\u151e\u0d12\u{1f821}\u04b9\u05fb\u{1f653}\u17c9\u4a4e\u774e'});
let texture27 = device1.createTexture({
  size: [48, 64, 363],
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba32float', 'rgba32float'],
});
let computePassEncoder27 = commandEncoder64.beginComputePass({});
try {
renderBundleEncoder37.setBindGroup(1, bindGroup20, new Uint32Array(4194), 429, 0);
} catch {}
try {
renderBundleEncoder38.setVertexBuffer(2, buffer14, 68420, 2382);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
commandEncoder63.copyBufferToTexture({
  /* bytesInLastRow: 192 widthInBlocks: 24 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 15184 */
  offset: 15184,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture23,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 24, height: 23, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder60.copyTextureToTexture({
  texture: texture27,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 30},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 12, y: 11, z: 0},
  aspect: 'all',
},
{width: 1, height: 12, depthOrArrayLayers: 1});
} catch {}
let bindGroup21 = device1.createBindGroup({label: '\uab73\u05a3\u4e34', layout: bindGroupLayout20, entries: []});
let commandEncoder65 = device1.createCommandEncoder();
let textureView64 = texture23.createView({
  label: '\u0637\u{1f88b}\ua9ce\u00ff\u{1fb0c}\u{1feee}\u5d63\u0ed4\u28d6',
  baseMipLevel: 3,
  mipLevelCount: 1,
  baseArrayLayer: 0,
});
let computePassEncoder28 = commandEncoder59.beginComputePass({label: '\u06ab\u59ff\ud3a6\u04d2\u{1f651}\u{1f784}\uf669'});
let externalTexture30 = device1.importExternalTexture({
  label: '\u{1f76a}\u4170\u0cc6\u{1f9f0}\u{1fc64}\u09ac\u{1f70b}\uafa3\u0ad6\u{1fe6b}\u0d36',
  source: videoFrame4,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder37.setBindGroup(1, bindGroup17, new Uint32Array(1897), 1551, 0);
} catch {}
try {
commandEncoder65.copyTextureToTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 560, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 2,
  origin: {x: 110, y: 0, z: 0},
  aspect: 'all',
},
{width: 100, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 24, new Int16Array(10646), 1475, 2056);
} catch {}
let gpuCanvasContext20 = canvas13.getContext('webgpu');
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let img10 = await imageWithData(184, 115, '#bbd3040a', '#23dfcc4f');
let commandBuffer18 = commandEncoder43.finish({label: '\uf4e3\u{1f915}\u08e2\u{1fb6d}\u{1feb6}\u0520\ue0a2\u0776\u9964\uf3a0\u27c9'});
let textureView65 = texture13.createView({label: '\u{1fb58}\u{1f66a}\u{1ff0f}\ubc86\ud04c\ub9aa\u{1ffa5}\ued39\ueabf'});
let computePassEncoder29 = commandEncoder51.beginComputePass({label: '\ub3fc\u7ca7\u{1f9ea}\uac29'});
let sampler32 = device0.createSampler({
  label: '\uc41f\ua275\uf558\u0c5b\u{1fdea}\u98cf\u0980\uf98a\u49b7\u{1fc55}',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 84.25,
});
try {
renderPassEncoder15.beginOcclusionQuery(351);
} catch {}
try {
renderPassEncoder15.endOcclusionQuery();
} catch {}
try {
renderPassEncoder8.setBlendConstant({ r: 332.3, g: -243.2, b: 239.4, a: -596.9, });
} catch {}
try {
renderPassEncoder12.setStencilReference(504);
} catch {}
try {
renderPassEncoder16.setVertexBuffer(9215, undefined, 3304507808, 577345578);
} catch {}
try {
renderBundleEncoder4.drawIndexed(186, 37);
} catch {}
let arrayBuffer7 = buffer7.getMappedRange(0, 8956);
try {
commandEncoder49.copyBufferToBuffer(buffer12, 70548, buffer2, 54772, 61276);
dissociateBuffer(device0, buffer12);
dissociateBuffer(device0, buffer2);
} catch {}
try {
commandEncoder48.resolveQuerySet(querySet5, 630, 386, buffer8, 52992);
} catch {}
let pipeline54 = await promise14;
let bindGroupLayout22 = device0.createBindGroupLayout({label: '\u10f4\u8507\u{1fe50}\u0007\u154d\u440d\u0a14\u7f36\ud335\u0917', entries: []});
let commandEncoder66 = device0.createCommandEncoder({});
let computePassEncoder30 = commandEncoder66.beginComputePass({label: '\u{1fb14}\u512c\ue637'});
try {
renderPassEncoder10.setBindGroup(0, bindGroup9);
} catch {}
try {
renderPassEncoder0.beginOcclusionQuery(296);
} catch {}
try {
renderPassEncoder0.endOcclusionQuery();
} catch {}
try {
renderPassEncoder7.draw(512, 205, 809_028_603, 502_033_991);
} catch {}
try {
renderPassEncoder10.drawIndexed(28, 1, 339_847_982, 247_715_911, 603_782_551);
} catch {}
try {
renderBundleEncoder20.setBindGroup(3, bindGroup3, new Uint32Array(6096), 5706, 0);
} catch {}
let pipeline55 = device0.createRenderPipeline({
  label: '\u6190\uafa9\u0248\u510a\uac5d\u2e37\uda53\u22cd\u00ea\u3a3b',
  layout: pipelineLayout4,
  multisample: {count: 4, mask: 0xffffffff},
  fragment: {
  module: shaderModule3,
  entryPoint: 'fragment0',
  targets: [{format: 'r32uint', writeMask: 0}, {format: 'r32uint', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'increment-wrap'},
    stencilBack: {compare: 'greater-equal', failOp: 'replace', depthFailOp: 'replace'},
    stencilReadMask: 3731237750,
    stencilWriteMask: 1290530142,
    depthBiasSlopeScale: 981.6271425645816,
  },
  vertex: {
    module: shaderModule3,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 13776,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x4', offset: 2760, shaderLocation: 13},
          {format: 'sint8x4', offset: 2604, shaderLocation: 5},
          {format: 'sint8x4', offset: 972, shaderLocation: 8},
          {format: 'sint16x2', offset: 132, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 1848, shaderLocation: 4},
          {format: 'sint32x4', offset: 276, shaderLocation: 9},
        ],
      },
      {arrayStride: 6932, stepMode: 'instance', attributes: []},
      {arrayStride: 1884, attributes: []},
      {
        arrayStride: 6600,
        stepMode: 'instance',
        attributes: [
          {format: 'float32', offset: 684, shaderLocation: 0},
          {format: 'unorm10-10-10-2', offset: 948, shaderLocation: 3},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', frontFace: 'cw', cullMode: 'back'},
});
let img11 = await imageWithData(193, 92, '#a7ce70bb', '#f000d7da');
try {
adapter1.label = '\uc3de\u8805\uf74e\ua9cf\u0b46\u452b\u005b\uc100';
} catch {}
try {
offscreenCanvas20.getContext('webgl');
} catch {}
let textureView66 = texture27.createView({
  label: '\u2b5b\u183a\u5149\uf50b\u{1f796}',
  dimension: '2d',
  aspect: 'all',
  format: 'rgba32float',
  baseMipLevel: 2,
  baseArrayLayer: 92,
});
try {
computePassEncoder23.setBindGroup(3, bindGroup21, new Uint32Array(87), 43, 0);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
buffer13.destroy();
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture27,
  mipLevel: 2,
  origin: {x: 1, y: 2, z: 120},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 7, y: 2, z: 0},
  aspect: 'all',
},
{width: 7, height: 3, depthOrArrayLayers: 2});
} catch {}
try {
gpuCanvasContext3.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 19708, new BigUint64Array(33457), 29116, 1420);
} catch {}
let querySet27 = device1.createQuerySet({
  label: '\uf9ee\ufe90\u8ce7\u{1fc8a}\udf47\u{1fabc}\u{1f757}\u05c8\u488f\u9ca5',
  type: 'occlusion',
  count: 2836,
});
let renderBundleEncoder39 = device1.createRenderBundleEncoder({
  label: '\u5197\u9004\u01e8\ub1a3\u059a\u0330\uf583',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle43 = renderBundleEncoder37.finish({label: '\udb77\u{1f9a2}\u6600\u23db\u726b'});
try {
commandEncoder61.copyTextureToTexture({
  texture: texture27,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 307},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 3, y: 2, z: 0},
  aspect: 'all',
},
{width: 8, height: 12, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder60.clearBuffer(buffer14, 53928, 11192);
dissociateBuffer(device1, buffer14);
} catch {}
try {
renderBundleEncoder36.insertDebugMarker('\u9bd6');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: canvas3,
  origin: { x: 1, y: 5 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
window.someLabel = textureView7.label;
} catch {}
let texture28 = device0.createTexture({
  size: {width: 1401, height: 1, depthOrArrayLayers: 33},
  mipLevelCount: 9,
  format: 'r32uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r32uint'],
});
let renderPassEncoder19 = commandEncoder48.beginRenderPass({
  label: '\uf51a\u4d57',
  colorAttachments: [{
  view: textureView13,
  depthSlice: 130,
  clearValue: { r: -664.7, g: -0.2159, b: 796.2, a: 610.5, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView28,
  depthSlice: 21,
  clearValue: { r: 447.7, g: -190.2, b: -931.9, a: 56.77, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet22,
  maxDrawCount: 95674692,
});
let renderBundleEncoder40 = device0.createRenderBundleEncoder({label: '\u776c\u0379', colorFormats: ['r32uint', 'r32uint'], depthReadOnly: true});
try {
computePassEncoder2.setPipeline(pipeline24);
} catch {}
try {
renderPassEncoder6.setBindGroup(4, bindGroup14, new Uint32Array(4515), 3363, 0);
} catch {}
try {
renderPassEncoder7.draw(27, 43, 7_958_559, 69_658_929);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer9, 1_247_355_618);
} catch {}
try {
renderPassEncoder7.drawIndirect(buffer5, 825_728_200);
} catch {}
try {
renderBundleEncoder4.drawIndexed(194);
} catch {}
try {
renderBundleEncoder25.setPipeline(pipeline31);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(9630, undefined, 1778203637, 1858591802);
} catch {}
try {
commandEncoder49.resolveQuerySet(querySet0, 655, 84, buffer8, 7680);
} catch {}
try {
device0.queue.submit([commandBuffer9, commandBuffer18, commandBuffer14]);
} catch {}
try {
gpuCanvasContext7.unconfigure();
} catch {}
let commandEncoder67 = device1.createCommandEncoder();
let textureView67 = texture27.createView({
  label: '\u{1f6f4}\u0620\u05ed\ue9d0\u{1ff7b}\ub016\uec8c\u6b9c\u{1ffc2}\u07a2\u05cb',
  aspect: 'all',
  format: 'rgba32float',
  mipLevelCount: 1,
  baseArrayLayer: 62,
  arrayLayerCount: 58,
});
let renderBundle44 = renderBundleEncoder33.finish({label: '\u0ebc\u70c0'});
let offscreenCanvas21 = new OffscreenCanvas(54, 22);
try {
commandEncoder58.copyTextureToTexture({
  texture: texture26,
  mipLevel: 2,
  origin: {x: 20, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 1,
  origin: {x: 60, y: 0, z: 0},
  aspect: 'all',
},
{width: 520, height: 0, depthOrArrayLayers: 1});
} catch {}
let offscreenCanvas22 = new OffscreenCanvas(509, 999);
let promise17 = adapter0.requestAdapterInfo();
try {
window.someLabel = computePassEncoder28.label;
} catch {}
let commandEncoder68 = device1.createCommandEncoder({label: '\u37d1\u0733'});
let textureView68 = texture26.createView({
  label: '\u0e3d\uca19\u037b\u{1fcc9}\u01a1\u{1fb1a}',
  dimension: '2d',
  mipLevelCount: 1,
  baseArrayLayer: 30,
});
let renderBundleEncoder41 = device1.createRenderBundleEncoder({label: '\u0bd2\u{1fa71}', colorFormats: ['r16float', 'rg32float', 'rgba32float']});
let renderBundle45 = renderBundleEncoder35.finish({label: '\u0e23\u{1ffef}\u{1f723}\udc3d\u{1f875}\uc71a\ua85b\u64a5\ua926'});
try {
renderBundleEncoder39.setBindGroup(6, bindGroup17);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(7, buffer14, 5552, 10077);
} catch {}
try {
commandEncoder63.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 310, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 90, y: 0, z: 0},
  aspect: 'all',
},
{width: 720, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder68.clearBuffer(buffer14, 29896, 9932);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: img9,
  origin: { x: 60, y: 13 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext19.unconfigure();
} catch {}
let imageData14 = new ImageData(172, 108);
let commandEncoder69 = device1.createCommandEncoder({});
try {
computePassEncoder28.setBindGroup(7, bindGroup20, new Uint32Array(6953), 2525, 0);
} catch {}
let bindGroup22 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let pipelineLayout8 = device1.createPipelineLayout({bindGroupLayouts: [bindGroupLayout20, bindGroupLayout20, bindGroupLayout20, bindGroupLayout21]});
try {
computePassEncoder27.setBindGroup(6, bindGroup21, new Uint32Array(2233), 2193, 0);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
commandEncoder61.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 50, y: 0, z: 3},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 970, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
renderBundleEncoder38.insertDebugMarker('\u06c8');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 400, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 15_856_116 */
{offset: 964, bytesPerRow: 1642, rowsPerImage: 284}, {width: 990, height: 0, depthOrArrayLayers: 35});
} catch {}
let imageData15 = new ImageData(192, 32);
try {
gpuCanvasContext4.unconfigure();
} catch {}
let imageData16 = new ImageData(52, 76);
let bindGroupLayout23 = device1.createBindGroupLayout({
  label: '\u030f\uda70\u089d\u4419\u{1f6ed}\u062f',
  entries: [
    {binding: 127, visibility: GPUShaderStage.FRAGMENT, externalTexture: {}},
    {
      binding: 2104,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      storageTexture: { format: 'rgba8sint', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 2064,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let buffer15 = device1.createBuffer({
  label: '\u07c5\ub6a2\u0e92\uee2e\u93a7\u199c\u0efb\u{1fcec}',
  size: 133852,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
  mappedAtCreation: true,
});
let querySet28 = device1.createQuerySet({
  label: '\u{1fcd7}\u8e22\uc61c\u67b6\u{1f808}\u{1f77a}\u07d7\u0ce0\u3201\u0756\u2ca5',
  type: 'occlusion',
  count: 3316,
});
let textureView69 = texture25.createView({label: '\u{1f6cf}\u7133\u2174\u{1fd21}\u0579\u3abe\u59a6', dimension: '2d'});
let sampler33 = device1.createSampler({
  label: '\u0aba\u0982\u4dc2\u0fca\u9bf5\u2d1d\u09f1\ucc80\u08f0\u{1fa9c}\uee2b',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 30.63,
  lodMaxClamp: 56.31,
});
try {
commandEncoder57.copyBufferToBuffer(buffer15, 53244, buffer14, 13004, 41004);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder65.copyBufferToTexture({
  /* bytesInLastRow: 16 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 3840 */
  offset: 3312,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 3, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer13);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 12260, new BigUint64Array(9159), 1289, 1604);
} catch {}
let shaderModule9 = device1.createShaderModule({
  label: '\u{1fb01}\ubfdc',
  code: `

@compute @workgroup_size(5, 2, 1)
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(6) f1: vec2<i32>,
  @location(0) f2: vec3<f32>,
  @location(1) f3: vec2<f32>
}

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

struct S10 {
  @location(21) f0: vec3<f32>,
  @location(14) f1: vec4<i32>,
  @location(25) f2: i32,
  @location(1) f3: vec4<u32>,
  @location(18) f4: vec3<i32>,
  @location(5) f5: i32,
  @location(24) f6: f32,
  @location(26) f7: vec2<i32>,
  @location(2) f8: vec4<u32>
}

@vertex
fn vertex0(@location(17) a0: vec2<f16>, @location(19) a1: vec4<f16>, @builtin(vertex_index) a2: u32, @location(10) a3: vec2<f32>, @location(7) a4: vec3<u32>, @builtin(instance_index) a5: u32, @location(22) a6: vec4<f32>, @location(16) a7: vec3<i32>, @location(23) a8: vec4<f16>, @location(6) a9: vec2<u32>, @location(15) a10: vec2<i32>, @location(8) a11: vec3<u32>, a12: S10, @location(4) a13: vec3<u32>, @location(13) a14: f16, @location(20) a15: vec2<u32>, @location(0) a16: vec3<f32>, @location(11) a17: vec3<f32>, @location(9) a18: f32, @location(3) a19: vec4<f16>, @location(12) a20: vec4<u32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let querySet29 = device1.createQuerySet({label: '\udf57\u9104\u{1fa7b}\u{1fb0d}\ufb88\u4b6e', type: 'occlusion', count: 4025});
let textureView70 = texture25.createView({mipLevelCount: 1});
let externalTexture31 = device1.importExternalTexture({source: video11, colorSpace: 'display-p3'});
try {
computePassEncoder25.setBindGroup(3, bindGroup22, new Uint32Array(3396), 1374, 0);
} catch {}
try {
renderBundleEncoder41.setBindGroup(1, bindGroup21);
} catch {}
try {
commandEncoder69.clearBuffer(buffer14, 7864, 60068);
dissociateBuffer(device1, buffer14);
} catch {}
try {
gpuCanvasContext12.unconfigure();
} catch {}
let img12 = await imageWithData(148, 284, '#7f5ef012', '#09e991e6');
let promise18 = adapter1.requestAdapterInfo();
let commandEncoder70 = device1.createCommandEncoder();
let textureView71 = texture26.createView({
  label: '\u0604\u6233\u{1fff5}\u053d\u6790\u0634\uc527\u08a0\u7df5\ubad3',
  dimension: '2d',
  baseMipLevel: 1,
  baseArrayLayer: 22,
});
let renderBundleEncoder42 = device1.createRenderBundleEncoder({
  label: '\u462d\u09bf\ub55e\u38d0\u55cd\u0927\u{1fe2d}\u780c',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  sampleCount: 1,
  depthReadOnly: true,
});
let externalTexture32 = device1.importExternalTexture({label: '\u7113\u0aab', source: videoFrame0, colorSpace: 'srgb'});
try {
renderBundleEncoder41.setBindGroup(1, bindGroup17, new Uint32Array(9946), 7914, 0);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(1, buffer14, 0, 25602);
} catch {}
try {
commandEncoder69.copyTextureToTexture({
  texture: texture26,
  mipLevel: 2,
  origin: {x: 10, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 160, y: 0, z: 0},
  aspect: 'all',
},
{width: 910, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(video7);
offscreenCanvas13.height = 1885;
let gpuCanvasContext21 = offscreenCanvas22.getContext('webgpu');
let texture29 = device1.createTexture({
  label: '\u{1ffc7}\u459d\u8f31\u96dc\ucc82\u083d',
  size: {width: 96},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float', 'r16float'],
});
let textureView72 = texture27.createView({
  label: '\u5c44\u6883\u{1fa34}\u{1fd8b}\ua362\u4558\uf8fb\u5f44\u0df8\u33d1',
  mipLevelCount: 2,
  baseArrayLayer: 360,
  arrayLayerCount: 1,
});
try {
computePassEncoder25.setBindGroup(0, bindGroup17, new Uint32Array(6849), 2159, 0);
} catch {}
try {
renderBundleEncoder38.setBindGroup(0, bindGroup22);
} catch {}
let arrayBuffer8 = buffer15.getMappedRange(0, 48960);
try {
gpuCanvasContext8.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.submit([commandBuffer16]);
} catch {}
let pipeline56 = device1.createRenderPipeline({
  label: '\u0e75\u0e92\u074b\ud19d\u0942',
  layout: pipelineLayout7,
  multisample: {mask: 0xffffffff},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'rg32float'}, {format: 'rgba32float'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'equal',
    stencilFront: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'keep'},
    stencilBack: {compare: 'not-equal', failOp: 'invert', depthFailOp: 'increment-clamp'},
    stencilWriteMask: 4177364808,
    depthBias: -8250838,
    depthBiasSlopeScale: 588.7527919271602,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 3536,
        attributes: [
          {format: 'float16x4', offset: 708, shaderLocation: 23},
          {format: 'uint32x2', offset: 1528, shaderLocation: 2},
          {format: 'sint32', offset: 488, shaderLocation: 18},
          {format: 'uint16x2', offset: 460, shaderLocation: 20},
          {format: 'sint32x3', offset: 1296, shaderLocation: 5},
          {format: 'unorm10-10-10-2', offset: 8, shaderLocation: 22},
          {format: 'uint16x2', offset: 644, shaderLocation: 7},
          {format: 'snorm16x2', offset: 904, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 12},
          {format: 'uint32x2', offset: 216, shaderLocation: 4},
          {format: 'unorm10-10-10-2', offset: 340, shaderLocation: 17},
          {format: 'unorm8x4', offset: 112, shaderLocation: 24},
          {format: 'sint8x4', offset: 132, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 1872,
        attributes: [
          {format: 'snorm16x4', offset: 896, shaderLocation: 3},
          {format: 'sint32x2', offset: 312, shaderLocation: 25},
          {format: 'sint32x3', offset: 1024, shaderLocation: 16},
          {format: 'float32x4', offset: 72, shaderLocation: 19},
          {format: 'uint8x4', offset: 772, shaderLocation: 8},
          {format: 'unorm16x2', offset: 296, shaderLocation: 10},
          {format: 'sint16x2', offset: 212, shaderLocation: 15},
          {format: 'uint32x2', offset: 200, shaderLocation: 6},
          {format: 'float32', offset: 120, shaderLocation: 21},
          {format: 'unorm8x4', offset: 304, shaderLocation: 13},
        ],
      },
      {
        arrayStride: 5288,
        attributes: [
          {format: 'uint32x4', offset: 480, shaderLocation: 1},
          {format: 'sint32', offset: 2176, shaderLocation: 26},
          {format: 'float16x4', offset: 832, shaderLocation: 11},
          {format: 'snorm8x4', offset: 1652, shaderLocation: 9},
        ],
      },
    ],
  },
});
let img13 = await imageWithData(41, 98, '#8fb25774', '#31f735aa');
let commandEncoder71 = device1.createCommandEncoder();
let renderBundle46 = renderBundleEncoder32.finish({label: '\u98e4\u{1ffa2}\u6afb\u{1faac}'});
try {
renderBundleEncoder41.setBindGroup(3, bindGroup20);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(0, buffer14, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 5888, new Float32Array(28019), 383, 2368);
} catch {}
let gpuCanvasContext22 = offscreenCanvas21.getContext('webgpu');
let imageData17 = new ImageData(120, 192);
try {
adapter0.label = '\u0cff\u02fa\u065e';
} catch {}
let videoFrame13 = new VideoFrame(offscreenCanvas10, {timestamp: 0});
let bindGroupLayout24 = device1.createBindGroupLayout({
  label: '\u0cc1\u{1fb2f}\u84c5\u5176\u8c39\u0eb6\u{1f67c}\uaed1',
  entries: [
    {
      binding: 3642,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '1d', sampleType: 'sint', multisampled: false },
    },
  ],
});
let buffer16 = device1.createBuffer({size: 32597, usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder72 = device1.createCommandEncoder({label: '\u4401\u{1fe73}'});
let querySet30 = device1.createQuerySet({type: 'occlusion', count: 3452});
let textureView73 = texture27.createView({
  label: '\ub455\u{1ff5a}\u4a82\uca71\u6345\u6923\u0f35\u0314',
  dimension: '2d',
  baseMipLevel: 2,
  baseArrayLayer: 14,
});
let sampler34 = device1.createSampler({
  label: '\u0095\u{1fa1f}\u9bc3\u0397',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'nearest',
  lodMaxClamp: 95.56,
});
try {
commandEncoder71.copyBufferToBuffer(buffer13, 17168, buffer14, 53048, 6768);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 9564, new Int16Array(25553), 23554, 320);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 10, y: 1, z: 0},
  aspect: 'all',
}, new BigInt64Array(new ArrayBuffer(56)), /* required buffer size: 109_815 */
{offset: 871, bytesPerRow: 400, rowsPerImage: 236}, {width: 9, height: 37, depthOrArrayLayers: 2});
} catch {}
video0.height = 28;
let imageBitmap13 = await createImageBitmap(canvas8);
let commandEncoder73 = device1.createCommandEncoder({label: '\u0355\ud909\ub95b\u3ba9\uaae2\u0c1b\ue9d2\uf39a\u{1f8aa}'});
let texture30 = device1.createTexture({
  label: '\u8ada\u{1f6e6}\u2b60\u0bd0\u54cf',
  size: {width: 48, height: 64, depthOrArrayLayers: 2},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float', 'r16float'],
});
let sampler35 = device1.createSampler({
  label: '\uae48\u{1fdb4}\u0901\u07ce\u{1fe5a}\u01a1\u{1fdef}\u0f3c\u2d55\u0bed',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  minFilter: 'nearest',
  lodMinClamp: 69.77,
  lodMaxClamp: 97.71,
});
try {
renderBundleEncoder42.setBindGroup(0, bindGroup17);
} catch {}
try {
renderBundleEncoder42.setBindGroup(6, bindGroup20, new Uint32Array(6077), 2338, 0);
} catch {}
try {
renderBundleEncoder36.setVertexBuffer(0, buffer14, 0);
} catch {}
try {
commandEncoder57.copyBufferToBuffer(buffer13, 8232, buffer14, 59252, 6080);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder73.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 10, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 560, y: 0, z: 0},
  aspect: 'all',
},
{width: 2370, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder65.resolveQuerySet(querySet25, 252, 217, buffer16, 2304);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 14880, new Int16Array(61156), 5919, 7024);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: videoFrame11,
  origin: { x: 23, y: 150 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline57 = device1.createRenderPipeline({
  label: '\u08e2\u993e\u{1fee3}',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha', dstFactor: 'zero'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE,
}, {format: 'rg32float', writeMask: 0}, {format: 'rgba32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1088,
        attributes: [
          {format: 'float16x4', offset: 8, shaderLocation: 3},
          {format: 'float32x4', offset: 172, shaderLocation: 21},
          {format: 'unorm16x4', offset: 16, shaderLocation: 24},
          {format: 'sint16x2', offset: 112, shaderLocation: 18},
          {format: 'sint32x3', offset: 36, shaderLocation: 16},
          {format: 'unorm16x4', offset: 0, shaderLocation: 11},
          {format: 'uint16x2', offset: 284, shaderLocation: 12},
          {format: 'float32x2', offset: 220, shaderLocation: 23},
          {format: 'sint8x2', offset: 2, shaderLocation: 14},
          {format: 'unorm8x4', offset: 88, shaderLocation: 9},
          {format: 'sint32', offset: 96, shaderLocation: 15},
          {format: 'uint32x3', offset: 0, shaderLocation: 2},
          {format: 'uint32x3', offset: 508, shaderLocation: 4},
          {format: 'float32x2', offset: 232, shaderLocation: 10},
          {format: 'unorm8x2', offset: 74, shaderLocation: 0},
          {format: 'uint32x4', offset: 32, shaderLocation: 7},
          {format: 'sint8x4', offset: 32, shaderLocation: 26},
          {format: 'unorm16x4', offset: 244, shaderLocation: 17},
          {format: 'unorm10-10-10-2', offset: 104, shaderLocation: 19},
          {format: 'uint16x4', offset: 308, shaderLocation: 6},
          {format: 'uint32', offset: 40, shaderLocation: 20},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x2', offset: 1098, shaderLocation: 8},
          {format: 'sint32x3', offset: 2524, shaderLocation: 25},
          {format: 'sint32x2', offset: 2580, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 288,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x2', offset: 2, shaderLocation: 22},
          {format: 'float32x2', offset: 4, shaderLocation: 13},
          {format: 'uint16x2', offset: 80, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', unclippedDepth: true},
});
try {
sampler2.label = '\u{1fcb6}\u02a9\u491c\uc18c\u{1f892}\ued84\u{1fccc}\u7717\ud3a4';
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let img14 = await imageWithData(294, 169, '#24ed9223', '#4a57ceb0');
let commandBuffer19 = commandEncoder69.finish({});
let textureView74 = texture27.createView({
  label: '\u0149\u{1fe35}\uc754\ue1dd\u{1fc82}',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 153,
  arrayLayerCount: 171,
});
let renderBundle47 = renderBundleEncoder36.finish({});
try {
commandEncoder61.copyTextureToTexture({
  texture: texture27,
  mipLevel: 1,
  origin: {x: 0, y: 3, z: 167},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 2, y: 11, z: 0},
  aspect: 'all',
},
{width: 15, height: 17, depthOrArrayLayers: 1});
} catch {}
let commandEncoder74 = device1.createCommandEncoder();
let renderBundleEncoder43 = device1.createRenderBundleEncoder({
  label: '\u0a8e\ud1e4\u{1f712}\u4942\u6d6a\u0dfb\u{1f862}\u{1f945}\u0ee0\u{1f8da}\ufbba',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
});
try {
renderBundleEncoder41.setBindGroup(1, bindGroup20);
} catch {}
try {
buffer13.destroy();
} catch {}
try {
commandEncoder67.copyBufferToBuffer(buffer15, 73044, buffer16, 22980, 5604);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder67.clearBuffer(buffer16, 30648, 316);
dissociateBuffer(device1, buffer16);
} catch {}
try {
  await promise18;
} catch {}
let commandEncoder75 = device1.createCommandEncoder({label: '\u{1fc45}\ua5ed\u{1fb13}\uca81'});
let computePassEncoder31 = commandEncoder73.beginComputePass({label: '\u760c\u4c4b\udce4'});
try {
renderBundleEncoder42.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(7, buffer14, 0, 33615);
} catch {}
try {
commandEncoder75.copyBufferToBuffer(buffer15, 88648, buffer16, 8852, 19032);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer16);
} catch {}
let pipeline58 = device1.createRenderPipeline({
  label: '\u{1fdac}\u426f\ucc4d\u{1fa4f}\u{1f78a}\uf4e0\u{1f8e2}',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-src'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-src-alpha', dstFactor: 'src-alpha-saturated'},
  },
  writeMask: GPUColorWrite.BLUE,
}, {format: 'rg32float'}, {format: 'rgba32float', writeMask: GPUColorWrite.BLUE}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 164,
        attributes: [
          {format: 'uint32x3', offset: 0, shaderLocation: 7},
          {format: 'snorm16x4', offset: 0, shaderLocation: 9},
          {format: 'float32x2', offset: 4, shaderLocation: 19},
          {format: 'float32x3', offset: 68, shaderLocation: 13},
          {format: 'snorm8x4', offset: 60, shaderLocation: 24},
          {format: 'snorm16x2', offset: 36, shaderLocation: 11},
          {format: 'float32x4', offset: 0, shaderLocation: 22},
          {format: 'sint8x2', offset: 30, shaderLocation: 18},
          {format: 'uint32x2', offset: 20, shaderLocation: 8},
          {format: 'unorm10-10-10-2', offset: 20, shaderLocation: 21},
          {format: 'sint32x2', offset: 8, shaderLocation: 16},
          {format: 'uint32x2', offset: 56, shaderLocation: 4},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint32x3', offset: 852, shaderLocation: 14},
          {format: 'sint32x4', offset: 1692, shaderLocation: 26},
          {format: 'sint16x4', offset: 1004, shaderLocation: 15},
          {format: 'snorm16x2', offset: 2940, shaderLocation: 0},
          {format: 'float16x4', offset: 2796, shaderLocation: 3},
          {format: 'snorm8x4', offset: 2908, shaderLocation: 17},
          {format: 'uint32x4', offset: 116, shaderLocation: 12},
          {format: 'sint16x2', offset: 264, shaderLocation: 5},
          {format: 'float16x4', offset: 900, shaderLocation: 10},
          {format: 'uint16x2', offset: 148, shaderLocation: 2},
          {format: 'uint8x2', offset: 628, shaderLocation: 6},
          {format: 'float32', offset: 1272, shaderLocation: 23},
          {format: 'sint8x2', offset: 2632, shaderLocation: 25},
          {format: 'uint32x3', offset: 1548, shaderLocation: 1},
        ],
      },
      {arrayStride: 188, attributes: [{format: 'uint32x4', offset: 4, shaderLocation: 20}]},
    ],
  },
});
offscreenCanvas10.width = 864;
try {
  await promise17;
} catch {}
let videoFrame14 = new VideoFrame(videoFrame13, {timestamp: 0});
let externalTexture33 = device1.importExternalTexture({label: '\u02ed\u568b\u0001', source: videoFrame5, colorSpace: 'srgb'});
try {
renderBundleEncoder39.setBindGroup(0, bindGroup19, new Uint32Array(4563), 4262, 0);
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 4, y: 6, z: 23},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{width: 31, height: 28, depthOrArrayLayers: 2});
} catch {}
try {
gpuCanvasContext20.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 4908, new Float32Array(6806), 3423, 364);
} catch {}
let pipeline59 = await device1.createRenderPipelineAsync({
  layout: 'auto',
  multisample: {count: 4, mask: 0x620cb8a5},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: GPUColorWrite.BLUE}, {format: 'rg32float', writeMask: 0}, {format: 'rgba32float', writeMask: 0}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'greater-equal', depthFailOp: 'increment-clamp', passOp: 'increment-wrap'},
    stencilBack: {
      compare: 'greater',
      failOp: 'increment-clamp',
      depthFailOp: 'increment-clamp',
      passOp: 'decrement-clamp',
    },
    stencilReadMask: 3124399654,
    stencilWriteMask: 2479830251,
    depthBias: -487212981,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 284,
        stepMode: 'vertex',
        attributes: [
          {format: 'sint16x4', offset: 12, shaderLocation: 16},
          {format: 'sint32x2', offset: 76, shaderLocation: 26},
          {format: 'float32x3', offset: 8, shaderLocation: 3},
          {format: 'unorm10-10-10-2', offset: 120, shaderLocation: 13},
          {format: 'uint16x2', offset: 36, shaderLocation: 20},
          {format: 'unorm8x4', offset: 32, shaderLocation: 9},
          {format: 'uint32x4', offset: 72, shaderLocation: 2},
          {format: 'uint16x4', offset: 28, shaderLocation: 7},
          {format: 'unorm8x4', offset: 24, shaderLocation: 23},
          {format: 'sint16x2', offset: 8, shaderLocation: 5},
          {format: 'uint32x2', offset: 108, shaderLocation: 6},
          {format: 'float32', offset: 40, shaderLocation: 24},
          {format: 'uint16x4', offset: 32, shaderLocation: 8},
          {format: 'float32x4', offset: 44, shaderLocation: 0},
          {format: 'uint8x2', offset: 138, shaderLocation: 4},
          {format: 'float32', offset: 0, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 2228,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x2', offset: 312, shaderLocation: 17},
          {format: 'unorm8x4', offset: 528, shaderLocation: 11},
          {format: 'float32x2', offset: 76, shaderLocation: 22},
          {format: 'sint16x4', offset: 440, shaderLocation: 18},
          {format: 'float32x3', offset: 36, shaderLocation: 21},
        ],
      },
      {
        arrayStride: 1532,
        attributes: [
          {format: 'uint8x2', offset: 28, shaderLocation: 1},
          {format: 'sint8x2', offset: 458, shaderLocation: 25},
          {format: 'float32x2', offset: 728, shaderLocation: 19},
          {format: 'sint32', offset: 188, shaderLocation: 14},
          {format: 'sint32x3', offset: 620, shaderLocation: 15},
          {format: 'uint8x4', offset: 16, shaderLocation: 12},
        ],
      },
    ],
  },
});
let bindGroup23 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let renderBundle48 = renderBundleEncoder39.finish({label: '\uc251\u067f'});
let sampler36 = device1.createSampler({
  label: '\uedf8\u{1fc0d}\u0810\uf272\u00fa\u03d9\u8921\ubc84\u0727\udf85\ubf2d',
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 7.537,
  lodMaxClamp: 85.13,
});
try {
commandEncoder70.copyBufferToTexture({
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 17832 */
  offset: 17832,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture30,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 16, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
computePassEncoder27.insertDebugMarker('\u6c9c');
} catch {}
try {
device1.queue.writeTexture({
  texture: texture29,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 196 */
{offset: 196}, {width: 61, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline60 = device1.createComputePipeline({
  label: '\uce43\u{1fa0a}\u1d06\uce74\u1d13\u7a0e\u4d5a\u04ed\u0057',
  layout: pipelineLayout8,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let shaderModule10 = device1.createShaderModule({
  label: '\u87f5\ub3f4\u{1ff3b}',
  code: `@group(3) @binding(4560)
var<storage, read_write> parameter11: 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>) {}

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

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

struct S11 {
  @builtin(vertex_index) f0: u32,
  @location(10) f1: i32,
  @location(0) f2: vec2<f32>,
  @location(24) f3: vec4<f32>,
  @location(18) f4: vec4<u32>,
  @location(12) f5: vec2<u32>,
  @location(4) f6: vec4<i32>,
  @location(11) f7: vec3<u32>,
  @location(17) f8: vec2<i32>,
  @builtin(instance_index) f9: u32,
  @location(16) f10: vec2<u32>,
  @location(6) f11: vec2<f32>,
  @location(15) f12: f32,
  @location(1) f13: vec4<f32>,
  @location(2) f14: vec3<i32>,
  @location(22) f15: vec4<i32>,
  @location(13) f16: f32,
  @location(14) f17: vec2<i32>,
  @location(23) f18: vec3<i32>,
  @location(19) f19: vec3<u32>,
  @location(26) f20: vec2<u32>,
  @location(25) f21: vec3<f16>,
  @location(5) f22: vec4<f32>
}

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

`,
  sourceMap: {},
  hints: {},
});
let querySet31 = device1.createQuerySet({type: 'occlusion', count: 2286});
let texture31 = device1.createTexture({
  label: '\u4493\u245d\u0983\u0f94\u90a8\u9cb2\u{1fc68}\u9679\uf379',
  size: {width: 12},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['r16float', 'r16float', 'r16float'],
});
let renderBundleEncoder44 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], depthReadOnly: true, stencilReadOnly: true});
try {
computePassEncoder23.setBindGroup(0, bindGroup17, []);
} catch {}
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 22 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7656 */
  offset: 7656,
  buffer: buffer13,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 11, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 1650, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 1,
  origin: {x: 120, y: 0, z: 0},
  aspect: 'all',
},
{width: 620, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder65.resolveQuerySet(querySet29, 3675, 167, buffer16, 0);
} catch {}
let computePassEncoder32 = commandEncoder65.beginComputePass({label: '\u6b83\u08f2\ue9af\u{1fa6f}\u0782'});
let renderBundleEncoder45 = device1.createRenderBundleEncoder({
  label: '\u{1f689}\u059e\u01e3\u0518\ua33b',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
let externalTexture34 = device1.importExternalTexture({label: '\u{1f9a5}\u0206\u5241\u04d7\u{1fc70}\u93e9\uace9', source: videoFrame1, colorSpace: 'srgb'});
try {
computePassEncoder27.setBindGroup(6, bindGroup18);
} catch {}
try {
commandEncoder58.copyBufferToBuffer(buffer13, 14808, buffer16, 20276, 2360);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder68.copyBufferToTexture({
  /* bytesInLastRow: 4 widthInBlocks: 2 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 10134 */
  offset: 10134,
  buffer: buffer13,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 41, y: 0, z: 0},
  aspect: 'all',
}, {width: 2, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder72.resolveQuerySet(querySet28, 985, 2323, buffer16, 11520);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 9300, new Float32Array(41547), 26373, 3072);
} catch {}
let promise19 = adapter0.requestAdapterInfo();
let textureView75 = texture26.createView({label: '\u0b42\u6fca', dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 20});
let renderBundleEncoder46 = device1.createRenderBundleEncoder({
  label: '\u{1f87a}\u0af6\ua09c',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
commandEncoder58.clearBuffer(buffer14, 52940, 7348);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder57.resolveQuerySet(querySet24, 1839, 26, buffer16, 28672);
} catch {}
document.body.prepend(video8);
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let canvas14 = document.createElement('canvas');
let renderPassEncoder20 = commandEncoder49.beginRenderPass({
  label: '\ub589\ub9ef\u0a5b\ucdd8\u16a2\u{1fa83}\u9709\u3058\u5917',
  colorAttachments: [{
  view: textureView29,
  depthSlice: 274,
  clearValue: { r: -532.1, g: 268.7, b: -745.8, a: -437.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {view: textureView23, depthSlice: 368, loadOp: 'load', storeOp: 'store'}],
  occlusionQuerySet: querySet6,
  maxDrawCount: 1181123285,
});
try {
computePassEncoder13.setBindGroup(1, bindGroup2, new Uint32Array(9209), 1109, 0);
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: -104.7, g: 945.7, b: -905.2, a: 431.1, });
} catch {}
try {
renderPassEncoder0.setScissorRect(50, 1, 35, 0);
} catch {}
try {
renderPassEncoder10.drawIndexed(315, 663);
} catch {}
try {
renderBundleEncoder12.setBindGroup(0, bindGroup13, new Uint32Array(8952), 7356, 0);
} catch {}
try {
renderBundleEncoder4.draw(521, 128, 222_174_663, 1_100_629_809);
} catch {}
try {
renderBundleEncoder4.drawIndexed(84, 272, 409_279_839, -1_420_462_941, 268_122_521);
} catch {}
try {
device0.pushErrorScope('internal');
} catch {}
let promise20 = device0.queue.onSubmittedWorkDone();
let pipeline61 = await device0.createComputePipelineAsync({
  label: '\u{1fd80}\uaa80\u2537\ue5a3',
  layout: 'auto',
  compute: {module: shaderModule0, entryPoint: 'compute0', constants: {}},
});
canvas7.width = 428;
let querySet32 = device1.createQuerySet({label: '\u063d\u0551\ud2e6\u0f5b\u0cf6\u018b\uf795', type: 'occlusion', count: 705});
let textureView76 = texture27.createView({
  label: '\uf141\u{1fb9d}\ubaf5\u8cee\u0239\u0723\u0e33\ud04e\u018d\u160f',
  dimension: '2d',
  format: 'rgba32float',
  baseMipLevel: 2,
  baseArrayLayer: 27,
  arrayLayerCount: 1,
});
try {
renderBundleEncoder41.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(4, buffer14, 14928, 52929);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
commandEncoder75.copyTextureToBuffer({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12710 */
  offset: 12710,
  buffer: buffer14,
}, {width: 12, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder75.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 690, y: 0, z: 1},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 530, y: 0, z: 0},
  aspect: 'all',
},
{width: 100, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: img10,
  origin: { x: 10, y: 0 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 11, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise20;
} catch {}
let img15 = await imageWithData(87, 227, '#77073d48', '#90b70cf8');
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let imageData18 = new ImageData(180, 152);
try {
renderBundleEncoder43.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(5, buffer14, 41324, 12914);
} catch {}
try {
commandEncoder58.copyTextureToTexture({
  texture: texture27,
  mipLevel: 2,
  origin: {x: 1, y: 0, z: 129},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 6, y: 6, z: 0},
  aspect: 'all',
},
{width: 8, height: 5, depthOrArrayLayers: 2});
} catch {}
try {
device1.queue.writeBuffer(buffer16, 148, new DataView(new ArrayBuffer(33062)), 11310, 1240);
} catch {}
let promise21 = device1.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}});
let img16 = await imageWithData(93, 57, '#01fefa42', '#f35def53');
let commandEncoder76 = device1.createCommandEncoder({label: '\u6c1e\ue0b6\u776a\u9089\u7989\u0509\uf8ed'});
let renderBundleEncoder47 = device1.createRenderBundleEncoder({
  label: '\udc45\u{1f864}\u064b\u83d7\u0eca\u{1f7a3}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
commandEncoder70.clearBuffer(buffer14, 11264, 23300);
dissociateBuffer(device1, buffer14);
} catch {}
let canvas15 = document.createElement('canvas');
try {
  await promise19;
} catch {}
let video12 = await videoWithData();
let canvas16 = document.createElement('canvas');
let buffer17 = device1.createBuffer({
  label: '\ueeaa\ub0a8\uda24\u{1fbf6}\u0769\u13a0\u7748\ua649\ua005',
  size: 44044,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
let commandEncoder77 = device1.createCommandEncoder({});
let textureView77 = texture29.createView({label: '\u7728\u8812\u33fe\u{1fa00}\u392b', mipLevelCount: 1});
let computePassEncoder33 = commandEncoder63.beginComputePass({label: '\u82a4\u07e1\u{1f69c}\u0221\u05a9'});
let renderBundle49 = renderBundleEncoder39.finish({label: '\u0b58\u0869\u6219\ucf46\u06a8\u0ac1'});
try {
renderBundleEncoder38.setVertexBuffer(1, buffer14);
} catch {}
try {
commandEncoder70.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
canvas16.getContext('webgpu');
} catch {}
let gpuCanvasContext23 = canvas15.getContext('webgpu');
document.body.prepend(video6);
offscreenCanvas12.width = 457;
let gpuCanvasContext24 = canvas14.getContext('webgpu');
let texture32 = device1.createTexture({
  label: '\uad79\u045d\u0a62\u0c5f\u18ce\u57b6\u5da5\ud468\u53dd\u{1fa5f}',
  size: {width: 12, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
});
let textureView78 = texture24.createView({label: '\u{1fd66}\u36f3\u2d2b\u9bd5\u{1f621}', arrayLayerCount: 1});
let renderBundleEncoder48 = device1.createRenderBundleEncoder({
  label: '\uf37c\u{1f706}\u0c75\u{1fc50}\ua7c2\u{1f6d3}\u9a02\u07e3\u{1f692}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  sampleCount: 1,
});
let externalTexture35 = device1.importExternalTexture({label: '\u{1fd94}\u8e9e\u087d\u{1fdd2}\ucc51', source: video2, colorSpace: 'srgb'});
try {
computePassEncoder28.setBindGroup(2, bindGroup20, new Uint32Array(7199), 2591, 0);
} catch {}
try {
computePassEncoder25.setPipeline(pipeline60);
} catch {}
try {
commandEncoder75.resolveQuerySet(querySet27, 968, 102, buffer16, 28928);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let promise22 = adapter1.requestAdapterInfo();
let commandEncoder78 = device1.createCommandEncoder({});
let renderBundle50 = renderBundleEncoder39.finish({label: '\ub5cf\u2df1\uaf6c\u47cd\uc52b\u{1fc3e}\u{1fc35}\uf5ca\ua8ce\u{1fcb3}\u8a81'});
try {
renderBundleEncoder44.setPipeline(pipeline58);
} catch {}
try {
commandEncoder58.copyBufferToBuffer(buffer13, 45584, buffer14, 24132, 12400);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder72.copyBufferToTexture({
  /* bytesInLastRow: 48 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 10752 */
  offset: 8912,
  bytesPerRow: 256,
  buffer: buffer13,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 3, height: 8, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer13);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, new ArrayBuffer(27_980), /* required buffer size: 27_980 */
{offset: 440, bytesPerRow: 660}, {width: 30, height: 42, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline62 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout7,
  multisample: {count: 4},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rg32float', writeMask: 0}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'less', failOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'less-equal', failOp: 'decrement-wrap', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 4294967295,
    depthBiasClamp: 625.7539227667406,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 780,
        attributes: [
          {format: 'float16x4', offset: 100, shaderLocation: 0},
          {format: 'float16x2', offset: 280, shaderLocation: 10},
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 9},
          {format: 'sint32', offset: 132, shaderLocation: 25},
          {format: 'sint32x4', offset: 212, shaderLocation: 16},
          {format: 'sint8x2', offset: 164, shaderLocation: 15},
          {format: 'uint32x4', offset: 92, shaderLocation: 20},
          {format: 'float32x2', offset: 60, shaderLocation: 17},
          {format: 'uint32x3', offset: 20, shaderLocation: 4},
          {format: 'uint32x2', offset: 148, shaderLocation: 8},
          {format: 'uint32', offset: 80, shaderLocation: 1},
          {format: 'float32x4', offset: 40, shaderLocation: 22},
          {format: 'unorm16x2', offset: 152, shaderLocation: 21},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x4', offset: 1512, shaderLocation: 23},
          {format: 'float32', offset: 864, shaderLocation: 11},
          {format: 'float32x4', offset: 764, shaderLocation: 3},
          {format: 'sint8x4', offset: 276, shaderLocation: 18},
          {format: 'uint32x2', offset: 224, shaderLocation: 7},
          {format: 'uint16x4', offset: 260, shaderLocation: 2},
          {format: 'uint32x2', offset: 1668, shaderLocation: 12},
          {format: 'unorm16x4', offset: 28, shaderLocation: 24},
          {format: 'sint32x4', offset: 2960, shaderLocation: 14},
          {format: 'sint16x4', offset: 484, shaderLocation: 26},
        ],
      },
      {
        arrayStride: 112,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 28, shaderLocation: 13},
          {format: 'sint8x2', offset: 2, shaderLocation: 5},
          {format: 'uint32x2', offset: 20, shaderLocation: 6},
        ],
      },
      {arrayStride: 92, attributes: [{format: 'unorm8x2', offset: 8, shaderLocation: 19}]},
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'back',
  unclippedDepth: true,
},
});
video12.height = 197;
let bindGroup24 = device1.createBindGroup({label: '\u5ee1\u0b4c\u{1fe5c}\u0c40\u90e8\u0af7', layout: bindGroupLayout20, entries: []});
let buffer18 = device1.createBuffer({
  label: '\u010d\u3fba\u{1ff21}\ue925\u0929\u{1fa75}\u{1f952}\u699e\u7c4c',
  size: 53842,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.INDIRECT,
});
let commandEncoder79 = device1.createCommandEncoder({});
let renderBundleEncoder49 = device1.createRenderBundleEncoder({
  label: '\ue748\ua7a9\u8409\u6f94\u7ed5\u0747\ub20e\ua539\uc2fa\u0cc6',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
commandEncoder71.copyTextureToTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 3, z: 0},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 8, y: 4, z: 0},
  aspect: 'all',
},
{width: 8, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder79.resolveQuerySet(querySet27, 2752, 20, buffer16, 12032);
} catch {}
let promise23 = device1.createRenderPipelineAsync({
  label: '\u1a08\uac33\u0515\ua1f0\u1f5b\uec5e\ua0f2\u{1fa98}\u6c05\u0cf1\u{1f692}',
  layout: pipelineLayout8,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst', dstFactor: 'dst'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-constant'},
  },
  writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'rg32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'not-equal',
    stencilFront: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'never', failOp: 'replace', depthFailOp: 'increment-wrap', passOp: 'increment-wrap'},
    stencilReadMask: 725014256,
    stencilWriteMask: 4153977728,
    depthBias: 0,
    depthBiasSlopeScale: 865.7734239464902,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 796,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 36, shaderLocation: 6},
          {format: 'float32x3', offset: 288, shaderLocation: 21},
          {format: 'uint8x4', offset: 248, shaderLocation: 1},
          {format: 'unorm8x2', offset: 50, shaderLocation: 10},
          {format: 'unorm8x2', offset: 174, shaderLocation: 22},
          {format: 'uint16x4', offset: 236, shaderLocation: 8},
          {format: 'unorm8x4', offset: 120, shaderLocation: 9},
          {format: 'unorm16x4', offset: 88, shaderLocation: 17},
          {format: 'uint8x2', offset: 26, shaderLocation: 20},
          {format: 'unorm8x2', offset: 132, shaderLocation: 19},
          {format: 'sint32x3', offset: 32, shaderLocation: 5},
          {format: 'uint32', offset: 176, shaderLocation: 12},
          {format: 'unorm8x2', offset: 244, shaderLocation: 23},
          {format: 'sint32x3', offset: 12, shaderLocation: 25},
        ],
      },
      {
        arrayStride: 7252,
        attributes: [
          {format: 'float32x4', offset: 112, shaderLocation: 11},
          {format: 'sint16x4', offset: 484, shaderLocation: 16},
          {format: 'uint32', offset: 696, shaderLocation: 7},
          {format: 'sint8x4', offset: 1800, shaderLocation: 15},
          {format: 'sint16x4', offset: 540, shaderLocation: 18},
          {format: 'float32', offset: 620, shaderLocation: 24},
          {format: 'uint32x2', offset: 748, shaderLocation: 4},
          {format: 'sint32x2', offset: 396, shaderLocation: 14},
          {format: 'sint32x4', offset: 208, shaderLocation: 26},
          {format: 'uint32x3', offset: 1772, shaderLocation: 2},
          {format: 'snorm8x2', offset: 104, shaderLocation: 3},
          {format: 'float32x2', offset: 2376, shaderLocation: 13},
          {format: 'unorm16x2', offset: 332, shaderLocation: 0},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let querySet33 = device1.createQuerySet({label: '\u713d\u52d7\uff7c\ue3ed\u96e9\u489b\u8608', type: 'occlusion', count: 1561});
let textureView79 = texture30.createView({dimension: '3d', baseMipLevel: 3, mipLevelCount: 1});
let renderBundle51 = renderBundleEncoder34.finish();
try {
commandEncoder71.copyTextureToBuffer({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 10650 */
  offset: 10650,
  buffer: buffer16,
}, {width: 9, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder72.resolveQuerySet(querySet30, 3384, 64, buffer16, 3328);
} catch {}
let bindGroupLayout25 = device1.createBindGroupLayout({
  label: '\u27a6\u8b2c\u07dc\u{1f99c}\uef2d\u01d2\u{1f6a1}\u{1fa5f}\u02c1',
  entries: [
    {
      binding: 265,
      visibility: 0,
      texture: { viewDimension: '3d', sampleType: 'sint', multisampled: false },
    },
    {
      binding: 3584,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
    },
    {
      binding: 3814,
      visibility: GPUShaderStage.FRAGMENT,
      texture: { viewDimension: 'cube-array', sampleType: 'unfilterable-float', multisampled: false },
    },
  ],
});
let bindGroupLayout26 = pipeline57.getBindGroupLayout(2);
let textureView80 = texture26.createView({
  label: '\ubc53\u0e72\u0203\u{1f81a}\uee29\u066d\u426a\u11ab\u0e46',
  format: 'astc-10x6-unorm-srgb',
  mipLevelCount: 2,
  baseArrayLayer: 27,
  arrayLayerCount: 10,
});
let externalTexture36 = device1.importExternalTexture({label: '\u009e\u822a\ubf7e\u9e35\u2b75', source: video9, colorSpace: 'display-p3'});
try {
renderBundleEncoder46.setBindGroup(4, bindGroup17);
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(6, buffer14, 0, 61988);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint8Array(arrayBuffer8), /* required buffer size: 999 */
{offset: 999, bytesPerRow: 367}, {width: 10, height: 5, depthOrArrayLayers: 0});
} catch {}
let promise24 = device1.queue.onSubmittedWorkDone();
let offscreenCanvas23 = new OffscreenCanvas(1023, 347);
let video13 = await videoWithData();
let imageBitmap14 = await createImageBitmap(canvas8);
let commandEncoder80 = device1.createCommandEncoder({label: '\u4cd9\u7342\uf8c0\uc4da'});
try {
computePassEncoder23.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(0, buffer14, 0);
} catch {}
let promise25 = device1.createRenderPipelineAsync({
  label: '\u{1f6f8}\u5099',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'dst-alpha', dstFactor: 'src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALL}, {format: 'rgba32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'stencil8',
    stencilFront: {compare: 'never', failOp: 'decrement-clamp', depthFailOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'equal', failOp: 'decrement-wrap', depthFailOp: 'increment-wrap', passOp: 'zero'},
    stencilReadMask: 690177861,
    stencilWriteMask: 473858048,
    depthBiasSlopeScale: 236.94186887132736,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 3832,
        attributes: [
          {format: 'sint32x2', offset: 152, shaderLocation: 2},
          {format: 'snorm8x4', offset: 616, shaderLocation: 24},
          {format: 'float16x2', offset: 1504, shaderLocation: 9},
          {format: 'sint16x2', offset: 532, shaderLocation: 3},
          {format: 'sint32x2', offset: 2840, shaderLocation: 4},
          {format: 'float32', offset: 524, shaderLocation: 25},
          {format: 'sint32', offset: 756, shaderLocation: 23},
          {format: 'uint32x2', offset: 412, shaderLocation: 12},
          {format: 'snorm8x4', offset: 604, shaderLocation: 5},
          {format: 'uint32x2', offset: 2224, shaderLocation: 18},
          {format: 'sint8x2', offset: 180, shaderLocation: 17},
          {format: 'uint32x4', offset: 2252, shaderLocation: 26},
          {format: 'sint8x2', offset: 1066, shaderLocation: 10},
          {format: 'snorm8x4', offset: 492, shaderLocation: 7},
          {format: 'sint16x4', offset: 1856, shaderLocation: 14},
          {format: 'float32x3', offset: 96, shaderLocation: 20},
          {format: 'sint8x2', offset: 430, shaderLocation: 22},
          {format: 'snorm8x4', offset: 1392, shaderLocation: 15},
          {format: 'uint32', offset: 516, shaderLocation: 8},
          {format: 'unorm8x2', offset: 56, shaderLocation: 6},
          {format: 'snorm8x4', offset: 532, shaderLocation: 13},
          {format: 'float32x2', offset: 524, shaderLocation: 21},
        ],
      },
      {
        arrayStride: 516,
        stepMode: 'instance',
        attributes: [{format: 'float32', offset: 48, shaderLocation: 1}],
      },
      {
        arrayStride: 764,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x4', offset: 40, shaderLocation: 19},
          {format: 'unorm10-10-10-2', offset: 116, shaderLocation: 0},
          {format: 'uint8x4', offset: 0, shaderLocation: 16},
          {format: 'uint32x2', offset: 76, shaderLocation: 11},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
document.body.prepend(img5);
try {
gpuCanvasContext16.unconfigure();
} catch {}
try {
adapter0.label = '\u0e54\u0344';
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let videoFrame15 = new VideoFrame(video7, {timestamp: 0});
let textureView81 = texture24.createView({label: '\uaef2\u1281\u03d4\u0379\u4af0\u0d90\u01a1\u837b\u43cf\u0dba\u04c5'});
let sampler37 = device1.createSampler({
  addressModeU: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 17.70,
  lodMaxClamp: 56.30,
  maxAnisotropy: 2,
});
try {
computePassEncoder27.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder38.setBindGroup(4, bindGroup20, new Uint32Array(3523), 911, 0);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(6, buffer14);
} catch {}
try {
buffer15.destroy();
} catch {}
try {
commandEncoder80.copyBufferToBuffer(buffer18, 9748, buffer14, 62968, 6928);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder70.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 80 widthInBlocks: 5 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 11328 */
  offset: 11328,
  bytesPerRow: 256,
  buffer: buffer14,
}, {width: 5, height: 3, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer14);
} catch {}
let textureView82 = texture24.createView({label: '\udbf2\u0112', mipLevelCount: 1});
let renderBundleEncoder50 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], depthReadOnly: true, stencilReadOnly: true});
try {
renderBundleEncoder47.setBindGroup(5, bindGroup19);
} catch {}
try {
commandEncoder79.copyBufferToBuffer(buffer18, 7836, buffer14, 44940, 19892);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder71.copyTextureToBuffer({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 18 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 7286 */
  offset: 7286,
  bytesPerRow: 512,
  buffer: buffer16,
}, {width: 9, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer16);
} catch {}
let promise26 = device1.queue.onSubmittedWorkDone();
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap8,
  origin: { x: 23, y: 1725 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise22;
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
let renderBundleEncoder51 = device1.createRenderBundleEncoder({
  label: '\u{1fde9}\ub88e\u{1f842}\u{1fd98}\u3417\u083f\u{1fb48}\u095a',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
});
try {
renderBundleEncoder51.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(2, buffer14, 63500);
} catch {}
let imageData19 = new ImageData(216, 120);
try {
computePassEncoder25.setBindGroup(2, bindGroup23);
} catch {}
try {
commandEncoder61.copyBufferToBuffer(buffer15, 47888, buffer14, 37552, 4512);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder71.insertDebugMarker('\u{1fad2}');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap1,
  origin: { x: 0, y: 84 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageBitmap15 = await createImageBitmap(canvas0);
try {
  await promise26;
} catch {}
try {
window.someLabel = textureView28.label;
} catch {}
document.body.prepend(canvas1);
let video14 = await videoWithData();
let commandEncoder81 = device1.createCommandEncoder({label: '\u{1fd12}\ue33c\u0853\u{1f78d}\u0cc5\u0416\u5e08'});
let textureView83 = texture30.createView({mipLevelCount: 5});
try {
renderBundleEncoder47.setPipeline(pipeline58);
} catch {}
try {
buffer15.unmap();
} catch {}
try {
commandEncoder57.copyTextureToTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 20, y: 0, z: 2},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 520, y: 0, z: 0},
  aspect: 'all',
},
{width: 2080, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(438), /* required buffer size: 438 */
{offset: 438, bytesPerRow: 315}, {width: 12, height: 16, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 8, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas4,
  origin: { x: 80, y: 5 },
  flipY: false,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise27 = device1.createComputePipelineAsync({
  label: '\u08ea\ub663\u6d4b\ub174\uef8c',
  layout: pipelineLayout8,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let pipeline63 = device1.createRenderPipeline({
  label: '\u{1fbb6}\u{1fbaa}\u8cee\uf5c2',
  layout: pipelineLayout7,
  multisample: {mask: 0x20d08988},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-src', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one-minus-dst-alpha', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN}, {format: 'rgba32float', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'increment-wrap', passOp: 'increment-wrap'},
    stencilBack: {compare: 'never', failOp: 'zero', depthFailOp: 'replace', passOp: 'decrement-clamp'},
    stencilReadMask: 2394419495,
    stencilWriteMask: 1786971638,
    depthBias: -830556487,
    depthBiasSlopeScale: -54.755334536915065,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 552, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 5028,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 952, shaderLocation: 26},
          {format: 'unorm8x2', offset: 174, shaderLocation: 17},
          {format: 'uint32x2', offset: 248, shaderLocation: 8},
          {format: 'snorm8x4', offset: 576, shaderLocation: 19},
          {format: 'uint32x4', offset: 336, shaderLocation: 20},
          {format: 'float32', offset: 644, shaderLocation: 22},
          {format: 'uint16x2', offset: 388, shaderLocation: 6},
          {format: 'snorm16x4', offset: 932, shaderLocation: 0},
          {format: 'sint32x3', offset: 468, shaderLocation: 5},
          {format: 'snorm16x4', offset: 492, shaderLocation: 13},
          {format: 'uint32x2', offset: 112, shaderLocation: 2},
          {format: 'sint16x2', offset: 220, shaderLocation: 15},
          {format: 'sint32', offset: 616, shaderLocation: 18},
          {format: 'sint16x2', offset: 732, shaderLocation: 14},
          {format: 'sint32', offset: 704, shaderLocation: 25},
          {format: 'float32x4', offset: 340, shaderLocation: 11},
          {format: 'snorm16x2', offset: 28, shaderLocation: 21},
          {format: 'float16x2', offset: 900, shaderLocation: 3},
          {format: 'uint32x3', offset: 1224, shaderLocation: 4},
          {format: 'snorm16x4', offset: 496, shaderLocation: 24},
          {format: 'sint32x3', offset: 252, shaderLocation: 16},
          {format: 'float16x2', offset: 1320, shaderLocation: 9},
          {format: 'float32x3', offset: 704, shaderLocation: 23},
          {format: 'uint32x4', offset: 40, shaderLocation: 12},
          {format: 'uint32x2', offset: 992, shaderLocation: 7},
          {format: 'uint16x2', offset: 2244, shaderLocation: 1},
        ],
      },
      {arrayStride: 5528, attributes: []},
      {
        arrayStride: 1788,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x4', offset: 684, shaderLocation: 10}],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', unclippedDepth: true},
});
let img17 = await imageWithData(94, 167, '#2e15e1b6', '#4168b0d5');
let bindGroup25 = device1.createBindGroup({label: '\u0af3\ub604\u0aa1\u009d\ud210\u6d4c', layout: bindGroupLayout20, entries: []});
let commandEncoder82 = device1.createCommandEncoder({});
let commandBuffer20 = commandEncoder80.finish();
let texture33 = device1.createTexture({
  label: '\u{1fc37}\uedb1\u389a\u11ed\ubfa4\u{1f832}\ued37\u{1fcbe}\u{1fd46}\u70f4',
  size: {width: 96},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float', 'r16float'],
});
let textureView84 = texture30.createView({baseMipLevel: 3, mipLevelCount: 1});
let computePassEncoder34 = commandEncoder79.beginComputePass({label: '\uc12d\u45dd\ub683\u9a3c\uec7b\u52b4'});
let sampler38 = device1.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 63.22,
  lodMaxClamp: 88.93,
  compare: 'less-equal',
});
try {
computePassEncoder28.setBindGroup(0, bindGroup19);
} catch {}
try {
commandEncoder70.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 45, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 8, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder76.clearBuffer(buffer14, 70264, 16);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 8, depthOrArrayLayers: 1}
*/
{
  source: imageData10,
  origin: { x: 6, y: 29 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
  await promise24;
} catch {}
let renderBundle52 = renderBundleEncoder49.finish();
try {
renderBundleEncoder51.setPipeline(pipeline57);
} catch {}
try {
commandEncoder82.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 112 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 15232 */
  offset: 12560,
  bytesPerRow: 256,
  buffer: buffer14,
}, {width: 7, height: 11, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 17136, new BigUint64Array(38728), 16618, 144);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture30,
  mipLevel: 1,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(5_497), /* required buffer size: 5_497 */
{offset: 261, bytesPerRow: 187}, {width: 0, height: 29, depthOrArrayLayers: 1});
} catch {}
let imageData20 = new ImageData(48, 20);
document.body.prepend(img11);
try {
window.someLabel = computePassEncoder27.label;
} catch {}
let renderBundle53 = renderBundleEncoder38.finish({label: '\uf825\u7721\u008b\u051f\u0130\u0c09\u0950\ud409\u0d69\u{1f9a3}\u6566'});
try {
computePassEncoder24.setBindGroup(2, bindGroup20, new Uint32Array(3714), 76, 0);
} catch {}
try {
computePassEncoder32.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder43.setVertexBuffer(3, buffer14, 0, 34473);
} catch {}
let textureView85 = texture32.createView({label: '\uc4aa\u0e5a\ued65', baseMipLevel: 1});
try {
computePassEncoder33.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(1, buffer14, 0, 22072);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 48, height: 64, depthOrArrayLayers: 2}
*/
{
  source: canvas9,
  origin: { x: 132, y: 9 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 14, y: 9, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 16, depthOrArrayLayers: 0});
} catch {}
let commandEncoder83 = device1.createCommandEncoder({label: '\ucd0d\u6bd9\u1733\u0312\u07a4\u0124\u1905'});
let commandBuffer21 = commandEncoder68.finish({});
let texture34 = device1.createTexture({
  label: '\uc480\ub9be\uf685\uabb6\ub215\u1b6c\ue192\u4010\u{1fd81}',
  size: {width: 24, height: 32, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let computePassEncoder35 = commandEncoder60.beginComputePass({label: '\u1b86\u00f2\u{1fada}\u065d'});
let renderBundleEncoder52 = device1.createRenderBundleEncoder({
  label: '\u6239\u2ebc\u09c1\u9c6f\u{1ffa3}\u96c2',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle54 = renderBundleEncoder32.finish({label: '\u6049\u{1fcff}\uda9a'});
try {
renderBundleEncoder44.setBindGroup(4, bindGroup22, new Uint32Array(3777), 540, 0);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline58);
} catch {}
try {
commandEncoder70.clearBuffer(buffer14, 65112, 3996);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder67.resolveQuerySet(querySet25, 154, 75, buffer16, 12544);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture26,
  mipLevel: 1,
  origin: {x: 180, y: 0, z: 1},
  aspect: 'all',
}, new ArrayBuffer(10_071_081), /* required buffer size: 10_071_081 */
{offset: 111, bytesPerRow: 3689, rowsPerImage: 195}, {width: 2180, height: 0, depthOrArrayLayers: 15});
} catch {}
let textureView86 = texture27.createView({baseMipLevel: 2, baseArrayLayer: 116, arrayLayerCount: 40});
let renderBundleEncoder53 = device1.createRenderBundleEncoder({
  label: '\u09d2\u98bb\ud3fd\u0f70\u4e2b\u{1f6f5}\u08cd\ucd71\u4285\u9595',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
commandEncoder74.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 14524 */
  offset: 14524,
  buffer: buffer13,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder67.copyTextureToTexture({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture30,
  mipLevel: 0,
  origin: {x: 5, y: 29, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline64 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout7,
  multisample: {mask: 0x1fca5541},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN}, {
  format: 'rgba32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 48,
        attributes: [
          {format: 'float32x4', offset: 4, shaderLocation: 19},
          {format: 'sint16x2', offset: 8, shaderLocation: 14},
          {format: 'sint32x4', offset: 0, shaderLocation: 18},
          {format: 'unorm8x2', offset: 0, shaderLocation: 13},
          {format: 'unorm16x4', offset: 8, shaderLocation: 17},
          {format: 'uint8x2', offset: 6, shaderLocation: 6},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 11},
          {format: 'uint32x2', offset: 0, shaderLocation: 8},
          {format: 'uint8x2', offset: 12, shaderLocation: 4},
          {format: 'uint8x2', offset: 2, shaderLocation: 12},
          {format: 'float16x2', offset: 4, shaderLocation: 10},
          {format: 'snorm16x2', offset: 0, shaderLocation: 24},
          {format: 'uint8x2', offset: 6, shaderLocation: 7},
          {format: 'uint16x2', offset: 0, shaderLocation: 20},
          {format: 'float16x2', offset: 8, shaderLocation: 9},
        ],
      },
      {arrayStride: 3856, stepMode: 'instance', attributes: []},
      {
        arrayStride: 200,
        attributes: [
          {format: 'float32x3', offset: 24, shaderLocation: 23},
          {format: 'uint8x2', offset: 26, shaderLocation: 2},
          {format: 'sint8x2', offset: 36, shaderLocation: 15},
          {format: 'sint32', offset: 12, shaderLocation: 5},
          {format: 'sint8x2', offset: 6, shaderLocation: 16},
          {format: 'snorm8x2', offset: 70, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'unorm16x4', offset: 2484, shaderLocation: 21},
          {format: 'sint32x2', offset: 3436, shaderLocation: 25},
          {format: 'uint32x3', offset: 304, shaderLocation: 1},
          {format: 'float32x2', offset: 2592, shaderLocation: 3},
          {format: 'sint32x4', offset: 488, shaderLocation: 26},
        ],
      },
      {arrayStride: 0, attributes: [{format: 'unorm8x4', offset: 412, shaderLocation: 22}]},
    ],
  },
  primitive: {topology: 'triangle-strip', cullMode: 'back', unclippedDepth: true},
});
let offscreenCanvas24 = new OffscreenCanvas(248, 271);
let texture35 = device1.createTexture({
  label: '\u06f3\u4d39\u9525\uce28\ube68\uf361\uf5d6',
  size: [12, 16, 437],
  mipLevelCount: 4,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
});
try {
computePassEncoder33.setBindGroup(4, bindGroup20);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 448 widthInBlocks: 28 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 78944 */
  offset: 8352,
  bytesPerRow: 512,
  rowsPerImage: 111,
  buffer: buffer15,
}, {
  texture: texture24,
  mipLevel: 0,
  origin: {x: 2, y: 7, z: 0},
  aspect: 'all',
}, {width: 28, height: 27, depthOrArrayLayers: 2});
dissociateBuffer(device1, buffer15);
} catch {}
try {
commandEncoder74.clearBuffer(buffer16, 13260, 5236);
dissociateBuffer(device1, buffer16);
} catch {}
gc();
let bindGroup26 = device1.createBindGroup({label: '\uec37\u{1f653}\u7344\u0020\u0718\u{1fd82}', layout: bindGroupLayout20, entries: []});
let textureView87 = texture26.createView({
  label: '\u{1f9ee}\u076f\u42cc\u00d1\ua41a\u097c\u0ca2\u6b4a\u8156\uf27f\u39f8',
  aspect: 'all',
  baseMipLevel: 1,
  baseArrayLayer: 26,
  arrayLayerCount: 1,
});
let computePassEncoder36 = commandEncoder61.beginComputePass({label: '\u70d2\u056b\u515b\u2f01\ub034\u0703\u{1f925}\u25fb'});
let renderBundle55 = renderBundleEncoder34.finish({});
try {
computePassEncoder27.setBindGroup(7, bindGroup22);
} catch {}
try {
renderBundleEncoder43.setBindGroup(3, bindGroup20, new Uint32Array(781), 26, 0);
} catch {}
try {
gpuCanvasContext19.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float'],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData8,
  origin: { x: 14, y: 3 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline65 = device1.createRenderPipeline({
  label: '\u{1fcf4}\uee51\ufe1a\u48d1\ue782\u76d0',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'constant', dstFactor: 'dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL}],
},
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1724,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 160, shaderLocation: 22},
          {format: 'snorm16x4', offset: 708, shaderLocation: 13},
          {format: 'sint32x4', offset: 204, shaderLocation: 16},
          {format: 'sint32', offset: 240, shaderLocation: 5},
          {format: 'uint32x4', offset: 76, shaderLocation: 7},
          {format: 'float16x4', offset: 120, shaderLocation: 21},
          {format: 'sint16x2', offset: 944, shaderLocation: 26},
          {format: 'sint8x2', offset: 254, shaderLocation: 14},
          {format: 'snorm8x2', offset: 158, shaderLocation: 3},
          {format: 'uint32x4', offset: 172, shaderLocation: 4},
          {format: 'float16x2', offset: 380, shaderLocation: 19},
          {format: 'uint8x2', offset: 1362, shaderLocation: 12},
          {format: 'uint32', offset: 296, shaderLocation: 20},
          {format: 'float32x2', offset: 700, shaderLocation: 17},
          {format: 'uint8x4', offset: 1032, shaderLocation: 2},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint32x4', offset: 196, shaderLocation: 15},
          {format: 'snorm16x4', offset: 1064, shaderLocation: 24},
          {format: 'unorm8x2', offset: 1140, shaderLocation: 10},
          {format: 'float32x3', offset: 1232, shaderLocation: 9},
          {format: 'float16x2', offset: 420, shaderLocation: 11},
          {format: 'sint8x2', offset: 174, shaderLocation: 25},
          {format: 'uint8x4', offset: 1124, shaderLocation: 6},
          {format: 'sint8x4', offset: 232, shaderLocation: 18},
          {format: 'float16x4', offset: 2512, shaderLocation: 0},
          {format: 'uint8x4', offset: 568, shaderLocation: 1},
          {format: 'uint32x4', offset: 1460, shaderLocation: 8},
          {format: 'unorm8x4', offset: 2044, shaderLocation: 23},
        ],
      },
    ],
  },
});
let gpuCanvasContext25 = offscreenCanvas24.getContext('webgpu');
gc();
let imageData21 = new ImageData(60, 28);
try {
offscreenCanvas23.getContext('bitmaprenderer');
} catch {}
let texture36 = device1.createTexture({
  size: {width: 96, height: 128, depthOrArrayLayers: 1264},
  mipLevelCount: 2,
  sampleCount: 1,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
});
let textureView88 = texture36.createView({baseMipLevel: 1, baseArrayLayer: 1049, arrayLayerCount: 114});
let sampler39 = device1.createSampler({
  label: '\u9324\u0776\u{1fb74}',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 52.68,
  lodMaxClamp: 56.92,
});
try {
computePassEncoder32.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder46.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(1, buffer14);
} catch {}
try {
commandEncoder70.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
commandEncoder75.resolveQuerySet(querySet29, 3373, 188, buffer16, 23040);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 412, new Float32Array(35967), 21915, 36);
} catch {}
document.body.prepend(img11);
gc();
let canvas17 = document.createElement('canvas');
let promise28 = adapter0.requestAdapterInfo();
let canvas18 = document.createElement('canvas');
let textureView89 = texture30.createView({label: '\ud1d8\u2ea3\u0d0f\u2b86\u3ddd', dimension: '3d', aspect: 'all', baseMipLevel: 4});
let renderBundle56 = renderBundleEncoder48.finish({label: '\u{1fae7}\u0deb\ub408\uf79a\ucacf\u0747'});
try {
computePassEncoder27.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(1, buffer14);
} catch {}
try {
commandEncoder74.copyTextureToTexture({
  texture: texture27,
  mipLevel: 0,
  origin: {x: 0, y: 1, z: 61},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 48, height: 31, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext7.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture35,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 139},
  aspect: 'all',
}, new Uint8Array(new ArrayBuffer(48)), /* required buffer size: 965_130 */
{offset: 330, bytesPerRow: 40, rowsPerImage: 134}, {width: 0, height: 1, depthOrArrayLayers: 181});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 8, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas10,
  origin: { x: 227, y: 690 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 2, height: 0, depthOrArrayLayers: 0});
} catch {}
let commandEncoder84 = device1.createCommandEncoder({label: '\uf5eb\uc42b\u9515\u185e\u36c2'});
let textureView90 = texture33.createView({});
let computePassEncoder37 = commandEncoder75.beginComputePass({label: '\u0417\u0586\u859f\u074d'});
let pipeline66 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout7,
  multisample: {count: 4, mask: 0xf0dd8a80},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {
      compare: 'less-equal',
      failOp: 'increment-clamp',
      depthFailOp: 'decrement-clamp',
      passOp: 'increment-wrap',
    },
    stencilBack: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilReadMask: 1049171832,
    stencilWriteMask: 699058241,
    depthBias: 156379345,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 164,
        attributes: [
          {format: 'uint16x4', offset: 12, shaderLocation: 12},
          {format: 'sint32x3', offset: 0, shaderLocation: 5},
          {format: 'float32x4', offset: 0, shaderLocation: 9},
          {format: 'uint32', offset: 44, shaderLocation: 8},
          {format: 'sint32x4', offset: 24, shaderLocation: 15},
          {format: 'uint8x2', offset: 44, shaderLocation: 20},
        ],
      },
      {
        arrayStride: 4460,
        attributes: [
          {format: 'sint16x4', offset: 512, shaderLocation: 26},
          {format: 'uint32x4', offset: 292, shaderLocation: 7},
          {format: 'sint32x4', offset: 1912, shaderLocation: 14},
          {format: 'float32x3', offset: 1032, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 188,
        stepMode: 'instance',
        attributes: [
          {format: 'float16x4', offset: 24, shaderLocation: 19},
          {format: 'float16x2', offset: 32, shaderLocation: 0},
          {format: 'float32x3', offset: 36, shaderLocation: 21},
          {format: 'sint8x2', offset: 12, shaderLocation: 16},
          {format: 'uint8x2', offset: 62, shaderLocation: 1},
          {format: 'sint32x4', offset: 16, shaderLocation: 25},
          {format: 'float32x4', offset: 8, shaderLocation: 13},
          {format: 'float16x2', offset: 4, shaderLocation: 24},
          {format: 'float32x4', offset: 80, shaderLocation: 22},
          {format: 'float16x2', offset: 16, shaderLocation: 3},
          {format: 'sint32', offset: 92, shaderLocation: 18},
        ],
      },
      {
        arrayStride: 1556,
        stepMode: 'vertex',
        attributes: [{format: 'snorm8x4', offset: 100, shaderLocation: 17}],
      },
      {arrayStride: 808, stepMode: 'instance', attributes: []},
      {
        arrayStride: 420,
        stepMode: 'instance',
        attributes: [
          {format: 'uint8x4', offset: 192, shaderLocation: 4},
          {format: 'uint16x4', offset: 8, shaderLocation: 6},
        ],
      },
      {arrayStride: 2440, attributes: []},
      {
        arrayStride: 1368,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm16x2', offset: 188, shaderLocation: 23},
          {format: 'unorm8x2', offset: 56, shaderLocation: 10},
          {format: 'uint32', offset: 68, shaderLocation: 2},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', unclippedDepth: true},
});
let gpuCanvasContext26 = canvas17.getContext('webgpu');
let img18 = await imageWithData(220, 4, '#bb8f6485', '#d47213cc');
let gpuCanvasContext27 = canvas18.getContext('webgpu');
gc();
try {
  await promise28;
} catch {}
let video15 = await videoWithData();
let commandEncoder85 = device1.createCommandEncoder();
try {
renderBundleEncoder50.setVertexBuffer(6, buffer14);
} catch {}
try {
device1.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer13, 14548, buffer14, 20996, 20164);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder81.clearBuffer(buffer14, 40212, 12504);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 1120, new Float32Array(36371), 35073, 148);
} catch {}
let pipeline67 = await promise23;
let shaderModule11 = device1.createShaderModule({
  code: `

@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(2) f0: vec4<f32>,
  @location(0) f1: vec3<f32>,
  @location(1) f2: vec4<f32>
}

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

struct S12 {
  @location(7) f0: vec3<f32>,
  @location(23) f1: vec3<i32>,
  @location(6) f2: vec4<f32>,
  @location(8) f3: vec2<i32>
}

@vertex
fn vertex0(@location(2) a0: u32, @location(21) a1: vec3<f16>, @location(9) a2: vec4<f32>, @location(0) a3: vec4<f16>, @location(25) a4: i32, a5: S12, @location(19) a6: vec3<i32>, @location(14) a7: vec4<f16>, @location(15) a8: vec4<u32>, @location(3) a9: u32, @location(16) a10: vec4<u32>, @location(4) a11: vec3<f16>, @location(18) a12: vec3<f16>, @location(12) a13: vec2<i32>, @location(5) a14: f32, @location(1) a15: vec2<f32>, @builtin(instance_index) a16: u32, @location(20) a17: vec4<f32>, @location(22) a18: vec4<i32>, @location(13) a19: vec2<u32>, @location(11) a20: vec2<u32>, @location(26) a21: vec2<f16>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let textureView91 = texture32.createView({label: '\u8457\u{1fddb}\u5cfe\uedd6\u0e5e', baseMipLevel: 1});
try {
renderBundleEncoder42.setVertexBuffer(2, buffer14, 66364, 2263);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture32,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer5), /* required buffer size: 349 */
{offset: 86, bytesPerRow: 77, rowsPerImage: 216}, {width: 2, height: 4, depthOrArrayLayers: 1});
} catch {}
let pipeline68 = await promise25;
offscreenCanvas8.height = 1189;
let externalTexture37 = device1.importExternalTexture({
  label: '\u46a0\u31a0\u0193\u0f6f\u6594\u69ef\u81d7\u0d24\u1975\u0f12',
  source: videoFrame11,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder46.setVertexBuffer(5, buffer14);
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 1120 */
  offset: 1120,
  bytesPerRow: 0,
  rowsPerImage: 27,
  buffer: buffer15,
}, {
  texture: texture35,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 28},
  aspect: 'all',
}, {width: 0, height: 2, depthOrArrayLayers: 179});
dissociateBuffer(device1, buffer15);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture24,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 286 */
{offset: 286, bytesPerRow: 199, rowsPerImage: 92}, {width: 5, height: 61, depthOrArrayLayers: 0});
} catch {}
let offscreenCanvas25 = new OffscreenCanvas(265, 265);
try {
gpuCanvasContext13.unconfigure();
} catch {}
let offscreenCanvas26 = new OffscreenCanvas(920, 587);
let videoFrame16 = new VideoFrame(video3, {timestamp: 0});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
gc();
let canvas19 = document.createElement('canvas');
let buffer19 = device1.createBuffer({
  label: '\uee5b\u2d02\u{1fb71}\ud6ed',
  size: 446468,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.VERTEX,
  mappedAtCreation: true,
});
let commandEncoder86 = device1.createCommandEncoder({label: '\u82ff\uf1f7\ub1b2\u05ba\u07ef\u{1fe76}'});
let textureView92 = texture30.createView({
  label: '\u0bb3\u{1fe27}\u05f7\u6458\u08fb\u{1fb60}\u{1f805}',
  format: 'r16float',
  baseMipLevel: 3,
  mipLevelCount: 1,
});
let sampler40 = device1.createSampler({
  label: '\u036d\ua98b\u341d\u856f\ub858\u6ea8\u09db\u6b07\ua24a\uada3',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 45.92,
  lodMaxClamp: 54.16,
});
try {
renderBundleEncoder47.setBindGroup(7, bindGroup19);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(7, buffer14, 57612, 9224);
} catch {}
try {
commandEncoder82.clearBuffer(buffer16, 25488, 4036);
dissociateBuffer(device1, buffer16);
} catch {}
let textureView93 = texture25.createView({
  label: '\u25b9\u7221\u{1fb11}\uc4e8\u0901\u403b\uee94\u{1f991}\uceee\u084d\ua055',
  dimension: '2d-array',
});
let externalTexture38 = device1.importExternalTexture({
  label: '\u5a39\u88c0\u{1feb9}\u3a45\u{1ff9d}\u749e\u{1f90b}',
  source: videoFrame3,
  colorSpace: 'display-p3',
});
try {
computePassEncoder23.setBindGroup(5, bindGroup25, new Uint32Array(2444), 211, 0);
} catch {}
try {
commandEncoder77.copyBufferToTexture({
  /* bytesInLastRow: 12 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12518 */
  offset: 12518,
  buffer: buffer18,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 6, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer18);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas11,
  origin: { x: 3, y: 5 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline69 = await device1.createComputePipelineAsync({
  label: '\u82b3\u13a0\u{1fe18}\ucb06\ud98e\u09a6\u{1f8c2}\u{1f8f3}\u0988',
  layout: 'auto',
  compute: {module: shaderModule11, entryPoint: 'compute0'},
});
let videoFrame17 = new VideoFrame(videoFrame7, {timestamp: 0});
let commandBuffer22 = commandEncoder76.finish({label: '\u0e63\udfd5\u07bb\u252f\u{1faed}'});
let textureView94 = texture26.createView({
  label: '\u{1ff4d}\u1413\u{1fdf8}\u{1fb4b}\u{1f684}\u01cb\u{1f896}',
  dimension: '2d-array',
  mipLevelCount: 1,
  baseArrayLayer: 7,
  arrayLayerCount: 22,
});
let sampler41 = device1.createSampler({
  label: '\uc669\u011c\u0dff\u9995\u0efa\u60af\u07a8',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 15.47,
  maxAnisotropy: 6,
});
try {
renderBundleEncoder43.setVertexBuffer(5, buffer14, 0);
} catch {}
let pipeline70 = await device1.createComputePipelineAsync({
  label: '\uc650\u02d8\u394a\u0a0d\uea3c',
  layout: pipelineLayout7,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
let pipeline71 = device1.createRenderPipeline({
  label: '\ufefc\u0006\u{1ff10}\u73fb\u527d\ubba1\u04b6\uc110\u2475\u{1fd1f}\uee11',
  layout: pipelineLayout7,
  multisample: {mask: 0x57a115de},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'add', srcFactor: 'one-minus-src-alpha', dstFactor: 'one-minus-dst'},
  },
  writeMask: 0,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA}, {format: 'rgba32float', writeMask: 0}],
},
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1232,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 196, shaderLocation: 16},
          {format: 'sint16x4', offset: 200, shaderLocation: 22},
          {format: 'unorm10-10-10-2', offset: 92, shaderLocation: 1},
          {format: 'float32x3', offset: 60, shaderLocation: 18},
          {format: 'unorm16x2', offset: 36, shaderLocation: 9},
          {format: 'float32', offset: 56, shaderLocation: 21},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'snorm8x2', offset: 2594, shaderLocation: 26},
          {format: 'sint32x3', offset: 2188, shaderLocation: 12},
          {format: 'sint8x4', offset: 1936, shaderLocation: 25},
          {format: 'sint8x4', offset: 44, shaderLocation: 19},
          {format: 'sint8x4', offset: 256, shaderLocation: 23},
          {format: 'float16x4', offset: 784, shaderLocation: 14},
          {format: 'float32x2', offset: 2036, shaderLocation: 0},
          {format: 'uint16x2', offset: 2124, shaderLocation: 3},
          {format: 'sint8x2', offset: 542, shaderLocation: 8},
          {format: 'uint8x4', offset: 1952, shaderLocation: 2},
          {format: 'uint8x4', offset: 412, shaderLocation: 15},
          {format: 'uint32', offset: 1236, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 3308, shaderLocation: 7},
          {format: 'unorm16x2', offset: 4216, shaderLocation: 20},
          {format: 'unorm16x4', offset: 688, shaderLocation: 6},
          {format: 'snorm16x4', offset: 1784, shaderLocation: 5},
          {format: 'uint16x2', offset: 1704, shaderLocation: 11},
          {format: 'float32', offset: 748, shaderLocation: 4},
        ],
      },
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw'},
});
canvas1.height = 64;
let querySet34 = device1.createQuerySet({label: '\uf074\u08aa\u{1f78e}\ubf9c\u0336\u04b4', type: 'occlusion', count: 2992});
let computePassEncoder38 = commandEncoder78.beginComputePass({label: '\ua699\uf013\u2518\ub52e\u{1fc1d}\u7866\u0438\u639c\ub50a\u0abe\ua0d6'});
try {
device1.queue.writeBuffer(buffer14, 13392, new Float32Array(47464), 39456, 552);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: img14,
  origin: { x: 5, y: 19 },
  flipY: false,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
bindGroupLayout5.label = '\u4808\ub2cf\ude96\u8e18\u{1f821}';
} catch {}
let promise29 = adapter1.requestAdapterInfo();
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let buffer20 = device1.createBuffer({
  label: '\u3a6e\u0eea\u{1f8a2}\u2c22\ubfdf\u2b39\u4bde\u7473\u044e',
  size: 246342,
  usage: GPUBufferUsage.INDIRECT,
  mappedAtCreation: false,
});
let textureView95 = texture32.createView({
  label: '\u0ec8\ubb3d\u{1fb11}\u{1fcdf}\u2ae2\uf56b\u0268\u7fc2',
  dimension: '3d',
  aspect: 'all',
  baseMipLevel: 1,
});
try {
computePassEncoder35.setPipeline(pipeline60);
} catch {}
try {
renderBundleEncoder42.setBindGroup(5, bindGroup21);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder41.setVertexBuffer(6, buffer19, 191844, 2420);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
device1.queue.writeTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 844 */
{offset: 844}, {width: 23, height: 0, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext28 = offscreenCanvas25.getContext('webgpu');
let texture37 = device1.createTexture({
  label: '\u0e21\u0b51\u3832\u{1f618}\u8d79\u02ed',
  size: [12, 16, 1],
  mipLevelCount: 5,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let textureView96 = texture34.createView({dimension: '2d-array', baseMipLevel: 2});
let renderPassEncoder21 = commandEncoder77.beginRenderPass({
  label: '\u5362\u2446\uf372\u{1f8ba}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -875.5, g: -242.6, b: -29.62, a: -661.5, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 185.2, g: 416.2, b: -245.1, a: 293.3, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: -419.6, g: 6.351, b: 404.5, a: 72.42, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet26,
});
let renderBundleEncoder54 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], stencilReadOnly: true});
try {
renderPassEncoder21.beginOcclusionQuery(2327);
} catch {}
try {
renderPassEncoder21.setScissorRect(0, 8, 3, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint16', 347616, 78678);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(7, buffer19, 432288, 5981);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext29 = offscreenCanvas26.getContext('webgpu');
try {
  await promise29;
} catch {}
let offscreenCanvas27 = new OffscreenCanvas(602, 916);
let commandBuffer23 = commandEncoder57.finish({label: '\u61e1\u{1f926}\uf0f2\u3724\u0643\u0bc8\u{1fcaf}\u1e01\u049b\u0a1b\u32cc'});
let texture38 = device1.createTexture({
  label: '\uef8f\u02d8\u9661\u{1f9a8}\u06c8\uad82',
  size: [24, 32, 272],
  mipLevelCount: 6,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32float', 'rg32float', 'rg32float'],
});
try {
computePassEncoder32.setBindGroup(7, bindGroup25);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setStencilReference(2912);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(6, buffer19, 0, 36261);
} catch {}
try {
commandEncoder84.copyBufferToBuffer(buffer15, 24880, buffer16, 8976, 12164);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder74.resolveQuerySet(querySet28, 1114, 1062, buffer16, 13056);
} catch {}
let imageData22 = new ImageData(48, 64);
try {
window.someLabel = pipelineLayout0.label;
} catch {}
let querySet35 = device1.createQuerySet({label: '\ufda3\u{1ff18}\u0bde\udc8f', type: 'occlusion', count: 3566});
let texture39 = device1.createTexture({
  label: '\u{1f671}\u0e58\u094b\uda60\uba72',
  size: {width: 24, height: 32, depthOrArrayLayers: 966},
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundle57 = renderBundleEncoder37.finish({label: '\uc4ac\u0e0b\u{1fa4e}\uea51\u{1ff09}\u{1fcaa}\u{1f6a5}\u18e1'});
try {
renderPassEncoder21.executeBundles([renderBundle37, renderBundle38, renderBundle42, renderBundle38, renderBundle42, renderBundle54, renderBundle41, renderBundle51, renderBundle49]);
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: 944.4, g: -404.5, b: 670.6, a: 807.6, });
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint32', 368088);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer19, 'uint32', 357000, 50425);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 5248, new BigUint64Array(7034), 6560, 8);
} catch {}
try {
gpuCanvasContext29.unconfigure();
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let videoFrame18 = new VideoFrame(img15, {timestamp: 0});
try {
computePassEncoder37.setBindGroup(1, bindGroup25, new Uint32Array(5383), 1040, 0);
} catch {}
try {
computePassEncoder36.setPipeline(pipeline69);
} catch {}
try {
renderPassEncoder21.setBindGroup(3, bindGroup19);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(193, undefined, 487156238, 2428804549);
} catch {}
try {
renderBundleEncoder51.setBindGroup(6, bindGroup19, new Uint32Array(9967), 2224, 0);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(6, buffer19, 395072, 520);
} catch {}
let arrayBuffer9 = buffer19.getMappedRange(0, 218028);
try {
gpuCanvasContext28.configure({
  device: device1,
  format: 'rgba16float',
  usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba16float', 'rgba16float', 'rgba16float', 'rgba16float'],
});
} catch {}
let videoFrame19 = new VideoFrame(imageBitmap11, {timestamp: 0});
try {
offscreenCanvas27.getContext('webgl');
} catch {}
let gpuCanvasContext30 = canvas19.getContext('webgpu');
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) };
} catch {}
video8.width = 14;
let img19 = await imageWithData(146, 120, '#6f2eb482', '#b18f2cac');
let textureView97 = texture33.createView({label: '\u0d74\u{1f77c}\u41b5\u{1f94d}\u1096\u{1fd40}\ua1b8\u01e1\u05e8', baseMipLevel: 0});
let renderBundle58 = renderBundleEncoder38.finish({label: '\u270c\ua603\ue1b6\u8b42\u0747\u03b5\u2db8\uc3a1'});
let externalTexture39 = device1.importExternalTexture({source: video9, colorSpace: 'display-p3'});
try {
renderPassEncoder21.setScissorRect(4, 1, 2, 0);
} catch {}
try {
renderPassEncoder21.setViewport(0.1082, 0.2110, 1.203, 4.548, 0.5356, 0.5707);
} catch {}
try {
renderBundleEncoder51.setIndexBuffer(buffer19, 'uint32', 203088, 49092);
} catch {}
try {
commandEncoder67.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
let imageBitmap16 = await createImageBitmap(video11);
let textureView98 = texture23.createView({
  label: '\u4b83\u7310\ucb7a\u01c3\u{1fc56}\u5128\ub389\u7249\udba4\u0b7b\u{1fa34}',
  baseMipLevel: 2,
  mipLevelCount: 2,
});
try {
renderPassEncoder21.setBlendConstant({ r: 146.3, g: -843.4, b: -227.3, a: 137.9, });
} catch {}
try {
renderPassEncoder21.setViewport(4.604, 3.285, 0.7884, 1.615, 0.5962, 0.7377);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(0, buffer14, 1308, 46884);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(7, buffer19, 183104);
} catch {}
try {
commandEncoder58.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 22},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 4256 */
  offset: 4256,
  bytesPerRow: 0,
  rowsPerImage: 2,
  buffer: buffer16,
}, {width: 0, height: 0, depthOrArrayLayers: 35});
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder67.clearBuffer(buffer16, 9952, 784);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder83.resolveQuerySet(querySet27, 683, 402, buffer16, 15360);
} catch {}
try {
gpuCanvasContext0.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 8892, new Float32Array(35404), 24146, 3176);
} catch {}
try {
gpuCanvasContext27.unconfigure();
} catch {}
let imageBitmap17 = await createImageBitmap(canvas19);
let commandEncoder87 = device1.createCommandEncoder({label: '\u{1fc38}\u{1faec}\u67ee\u2504\ua826'});
let texture40 = device1.createTexture({
  label: '\u57b1\u199c\u{1fd63}\u{1fb1c}\u{1f90d}\uf87c\uadb8\uc666\u{1f8e2}\u0785\u00d4',
  size: {width: 24, height: 32, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  dimension: '3d',
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32float'],
});
let renderPassEncoder22 = commandEncoder86.beginRenderPass({
  label: '\ua47d\u{1fa02}\u0273\u7815\u{1fa45}\u0325\u{1fb91}\u659b\ueaf1\u0fd5\u{1fe73}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 104.1, g: 890.3, b: -391.4, a: 60.53, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -441.4, g: -818.1, b: -698.4, a: -198.3, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: 850.3, g: 67.45, b: -578.8, a: 909.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 537894017,
});
let renderBundleEncoder55 = device1.createRenderBundleEncoder({label: '\u018a\u5f03\u007b', colorFormats: ['r16float', 'rg32float', 'rgba32float']});
let externalTexture40 = device1.importExternalTexture({
  label: '\u0bd2\u{1f92e}\u{1f8c7}\u0d59\u48fd\u{1fdbe}\u232a\u{1ffcd}\uf197\u7ca5',
  source: videoFrame3,
  colorSpace: 'display-p3',
});
try {
computePassEncoder31.setPipeline(pipeline70);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(1613);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: -143.6, g: 877.3, b: 248.2, a: 824.2, });
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder44.setVertexBuffer(7, buffer14, 54828, 12741);
} catch {}
try {
commandEncoder74.copyBufferToBuffer(buffer18, 40692, buffer17, 12588, 12240);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer17);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 23984, new Float32Array(35866), 23721, 192);
} catch {}
let bindGroupLayout27 = device1.createBindGroupLayout({
  label: '\u026c\ufa6a\u0e31\u024e\u162e\u{1ff3e}',
  entries: [{binding: 154, visibility: 0, sampler: { type: 'comparison' }}],
});
let renderBundle59 = renderBundleEncoder37.finish({});
try {
renderPassEncoder21.setVertexBuffer(5, buffer19, 330972, 34220);
} catch {}
try {
renderBundleEncoder42.setBindGroup(7, bindGroup18);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(3, buffer14, 41532, 6516);
} catch {}
try {
commandEncoder84.copyTextureToTexture({
  texture: texture26,
  mipLevel: 0,
  origin: {x: 150, y: 0, z: 5},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 80, y: 0, z: 0},
  aspect: 'all',
},
{width: 3510, height: 6, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder83.clearBuffer(buffer17, 3180);
dissociateBuffer(device1, buffer17);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 48, height: 64, depthOrArrayLayers: 2}
*/
{
  source: videoFrame17,
  origin: { x: 97, y: 233 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 0,
  origin: {x: 3, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 9, height: 4, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) };
} catch {}
let querySet36 = device1.createQuerySet({
  label: '\u{1f737}\u0768\u7c1f\u76be\u{1fbb0}\u9f53\u01b9\u7005\u41d9\u0e6b\u0dc2',
  type: 'occlusion',
  count: 59,
});
let texture41 = device1.createTexture({
  label: '\udeb3\u{1ff27}\u0e6b',
  size: [2448, 6, 1255],
  mipLevelCount: 6,
  format: 'astc-6x6-unorm-srgb',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['astc-6x6-unorm', 'astc-6x6-unorm-srgb'],
});
let textureView99 = texture23.createView({label: '\u5878\u038e\u1a84\u8070\u{1f9f2}\u{1ffad}\u4105\u0917\u030d', baseMipLevel: 3});
try {
renderPassEncoder21.setScissorRect(4, 7, 0, 1);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer14, 0, 29715);
} catch {}
try {
renderBundleEncoder54.setBindGroup(3, bindGroup22);
} catch {}
try {
renderBundleEncoder55.setIndexBuffer(buffer19, 'uint16', 58692, 93984);
} catch {}
try {
renderBundleEncoder52.setVertexBuffer(61, undefined, 3138734876, 802329056);
} catch {}
try {
commandEncoder74.clearBuffer(buffer16, 17360, 7656);
dissociateBuffer(device1, buffer16);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 13092, new BigUint64Array(48831), 32243, 176);
} catch {}
document.body.prepend(video8);
let commandEncoder88 = device1.createCommandEncoder({label: '\u0938\ucd08\u{1fc10}'});
let commandBuffer24 = commandEncoder81.finish({label: '\u350d\u076b\ub3e8\u6c11\u2e44\u2e2b\u{1fe86}\u{1fee3}\uc62f\u{1f83a}'});
let texture42 = device1.createTexture({
  size: [24],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let computePassEncoder39 = commandEncoder71.beginComputePass({});
let renderBundle60 = renderBundleEncoder43.finish({label: '\u00bf\u048f\u0809\ua06b\ua14d\u{1faa3}\u26dc'});
try {
computePassEncoder26.setPipeline(pipeline60);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(701);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle41]);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint16', 376830, 39008);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline71);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(0, buffer14);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline71);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: videoFrame8,
  origin: { x: 1, y: 14 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let textureView100 = texture40.createView({
  label: '\u040b\udd68\udd7a\u{1fdeb}\u01d6\u001a\ub5e1\u090d\uaf1f',
  aspect: 'all',
  format: 'rgba32float',
  baseMipLevel: 1,
  baseArrayLayer: 0,
});
let renderBundle61 = renderBundleEncoder32.finish();
let sampler42 = device1.createSampler({
  label: '\u09f6\u0cd6\uf022\u79e7',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 11.21,
  lodMaxClamp: 32.18,
});
let externalTexture41 = device1.importExternalTexture({
  label: '\u1318\u719e\u18f5\u38e4\u8e2a\u5645\ucb9f\u9a0a\u4b6c',
  source: video5,
  colorSpace: 'display-p3',
});
try {
computePassEncoder38.setPipeline(pipeline60);
} catch {}
try {
renderPassEncoder22.executeBundles([renderBundle55, renderBundle51, renderBundle44, renderBundle47, renderBundle55, renderBundle57]);
} catch {}
try {
renderPassEncoder22.setBlendConstant({ r: 578.6, g: -879.6, b: -331.5, a: 830.1, });
} catch {}
try {
renderPassEncoder22.setViewport(1.520, 6.971, 0.1316, 0.2794, 0.1431, 0.5109);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint16', 341968, 29973);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas12,
  origin: { x: 1, y: 133 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 2, y: 7, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 5, height: 3, depthOrArrayLayers: 0});
} catch {}
try {
window.someLabel = externalTexture20.label;
} catch {}
let texture43 = device1.createTexture({
  label: '\ud756\u06d6\ub1fb\u{1fbae}\u3d3b\u{1fb65}\ue2d4\u{1f9bd}\u174c\u0f32',
  size: {width: 96, height: 128, depthOrArrayLayers: 675},
  mipLevelCount: 5,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32float', 'rg32float'],
});
let textureView101 = texture24.createView({label: '\u05dc\uf4d3\u{1fe19}\u68d0\u060d\u039e\u3b1d'});
let renderBundle62 = renderBundleEncoder52.finish({label: '\u0712\u76b8\uda8e\u{1fb06}\u2b57\u9974\u0d1f\u3aa1\u4855\u4a34\u7907'});
try {
computePassEncoder37.end();
} catch {}
try {
renderPassEncoder21.setVertexBuffer(5, buffer19);
} catch {}
try {
buffer13.destroy();
} catch {}
try {
buffer17.unmap();
} catch {}
try {
commandEncoder83.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 7, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 12, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas25,
  origin: { x: 6, y: 68 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
gc();
try {
gpuCanvasContext14.unconfigure();
} catch {}
document.body.prepend(canvas12);
let commandEncoder89 = device1.createCommandEncoder({label: '\uf0d5\u1a9f\u7424\u01b0\u02eb\u029a'});
let texture44 = device1.createTexture({
  label: '\ucc0f\u0ef0\u0289\u7a13\u{1fec2}\u0328\ud800\ud8c5\u{1fcb0}\u4d7a\uef65',
  size: {width: 96, height: 128, depthOrArrayLayers: 4},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'rgba8sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8sint', 'rgba8sint', 'rgba8sint'],
});
let textureView102 = texture30.createView({label: '\u1a50\u{1fc3c}', baseMipLevel: 3, baseArrayLayer: 0});
let computePassEncoder40 = commandEncoder72.beginComputePass({label: '\u9bbd\u1eb5'});
try {
renderPassEncoder22.setViewport(3.767, 1.811, 1.170, 0.1713, 0.9540, 0.9906);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder42.setBindGroup(6, bindGroup22);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline65);
} catch {}
try {
commandEncoder88.copyBufferToBuffer(buffer18, 42700, buffer17, 7456, 2244);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer17);
} catch {}
try {
commandEncoder84.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
gpuCanvasContext10.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline72 = await device1.createComputePipelineAsync({
  label: '\u0f6b\u89a8\u0d57\u074e\ub115\uc8e7\u{1f7d5}\u993d\u0765\u6eff',
  layout: pipelineLayout7,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
let texture45 = device1.createTexture({
  size: {width: 24, height: 32, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['r16float', 'r16float', 'r16float'],
});
let textureView103 = texture35.createView({
  label: '\u{1f60f}\ue695\ucf8d\u0f29\u7229\u4f57\u0c1d\ub833\u0b69\ua187\ud666',
  baseMipLevel: 3,
  baseArrayLayer: 248,
  arrayLayerCount: 124,
});
let computePassEncoder41 = commandEncoder74.beginComputePass({label: '\u0895\u0102\ubb73\u6cd8\u090c'});
try {
renderPassEncoder22.executeBundles([renderBundle38, renderBundle58, renderBundle39, renderBundle61, renderBundle60, renderBundle51]);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder45.setBindGroup(3, bindGroup19, new Uint32Array(753), 589, 0);
} catch {}
try {
renderBundleEncoder42.setPipeline(pipeline57);
} catch {}
try {
commandEncoder85.resolveQuerySet(querySet33, 1037, 203, buffer16, 20992);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: img5,
  origin: { x: 126, y: 1 },
  flipY: false,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 9, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline73 = await device1.createComputePipelineAsync({layout: pipelineLayout7, compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}}});
let canvas20 = document.createElement('canvas');
let video16 = await videoWithData();
let videoFrame20 = new VideoFrame(video16, {timestamp: 0});
let videoFrame21 = new VideoFrame(img3, {timestamp: 0});
let renderBundleEncoder56 = device1.createRenderBundleEncoder({
  label: '\u9c21\u58aa\uf724\u16d8\u0a51\u7d77\uc6bb\u{1f884}\u6911\u{1fec9}\u09b5',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  sampleCount: 1,
  stencilReadOnly: true,
});
try {
renderPassEncoder21.setBindGroup(1, bindGroup24);
} catch {}
try {
renderPassEncoder22.setScissorRect(5, 4, 0, 3);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline57);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(2, buffer14, 0, 19468);
} catch {}
try {
renderBundleEncoder42.setBindGroup(5, bindGroup26);
} catch {}
try {
renderBundleEncoder55.setBindGroup(5, bindGroup17, new Uint32Array(7599), 5927, 0);
} catch {}
try {
renderBundleEncoder51.setPipeline(pipeline57);
} catch {}
try {
commandEncoder70.copyBufferToBuffer(buffer13, 11360, buffer17, 36612, 2716);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer17);
} catch {}
document.body.prepend(video13);
let bindGroupLayout28 = device1.createBindGroupLayout({
  label: '\u0e37\u9e5d',
  entries: [
    {
      binding: 5075,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
    },
  ],
});
let querySet37 = device1.createQuerySet({label: '\u55ec\u00f5\u{1f950}\u6712', type: 'occlusion', count: 267});
let renderBundleEncoder57 = device1.createRenderBundleEncoder({
  label: '\uf012\u9f00\ud467\u9c52\uf9ab\uf111\u07ce\ub488\u5f7f\uf1f8\udc46',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  sampleCount: 1,
});
let externalTexture42 = device1.importExternalTexture({source: videoFrame0});
try {
renderPassEncoder21.setBlendConstant({ r: -538.2, g: -243.4, b: 747.6, a: 597.2, });
} catch {}
try {
renderPassEncoder22.setViewport(1.082, 6.505, 4.900, 1.076, 0.7842, 0.8734);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer19, 'uint32', 158300, 205797);
} catch {}
try {
commandEncoder70.copyBufferToTexture({
  /* bytesInLastRow: 160 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 17648 */
  offset: 17648,
  rowsPerImage: 10,
  buffer: buffer13,
}, {
  texture: texture37,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder85.resolveQuerySet(querySet32, 234, 210, buffer16, 29184);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageData2,
  origin: { x: 11, y: 41 },
  flipY: true,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 1, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline74 = await device1.createComputePipelineAsync({
  label: '\u004b\u8030\u670a\u{1fe9f}\u{1f9b7}\u823d\u6d25\u9f88\u{1f73a}',
  layout: 'auto',
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let pipeline75 = await device1.createRenderPipelineAsync({
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'zero', dstFactor: 'one-minus-constant'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba32float'}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'less-equal', failOp: 'decrement-clamp', passOp: 'increment-clamp'},
    stencilBack: {failOp: 'increment-wrap', passOp: 'increment-clamp'},
    stencilReadMask: 2091224619,
    stencilWriteMask: 1385521120,
    depthBiasSlopeScale: 765.2776802719122,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 3548,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 796, shaderLocation: 0},
          {format: 'uint32x3', offset: 1252, shaderLocation: 6},
          {format: 'uint8x4', offset: 332, shaderLocation: 4},
          {format: 'uint32', offset: 608, shaderLocation: 1},
          {format: 'sint32x2', offset: 68, shaderLocation: 25},
          {format: 'uint16x2', offset: 420, shaderLocation: 7},
          {format: 'sint32', offset: 48, shaderLocation: 16},
          {format: 'unorm8x2', offset: 96, shaderLocation: 11},
          {format: 'sint32x3', offset: 780, shaderLocation: 14},
          {format: 'float32x2', offset: 548, shaderLocation: 19},
          {format: 'sint16x4', offset: 872, shaderLocation: 18},
          {format: 'uint32', offset: 156, shaderLocation: 2},
          {format: 'unorm8x4', offset: 200, shaderLocation: 13},
          {format: 'unorm10-10-10-2', offset: 188, shaderLocation: 9},
          {format: 'snorm8x4', offset: 244, shaderLocation: 21},
          {format: 'unorm8x2', offset: 954, shaderLocation: 24},
          {format: 'snorm16x2', offset: 516, shaderLocation: 10},
        ],
      },
      {
        arrayStride: 56,
        stepMode: 'instance',
        attributes: [
          {format: 'sint32x3', offset: 0, shaderLocation: 26},
          {format: 'unorm10-10-10-2', offset: 0, shaderLocation: 22},
          {format: 'snorm8x2', offset: 0, shaderLocation: 3},
          {format: 'uint32x4', offset: 12, shaderLocation: 12},
          {format: 'unorm16x4', offset: 0, shaderLocation: 23},
          {format: 'sint16x2', offset: 0, shaderLocation: 5},
          {format: 'sint32', offset: 0, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 608,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 36, shaderLocation: 20}],
      },
      {arrayStride: 1712, attributes: [{format: 'float32', offset: 208, shaderLocation: 17}]},
      {arrayStride: 468, attributes: []},
      {arrayStride: 4200, attributes: []},
      {arrayStride: 1472, attributes: [{format: 'uint32x2', offset: 532, shaderLocation: 8}]},
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'none'},
});
let shaderModule12 = device0.createShaderModule({
  label: '\udd2b\u387b\uc19e\u2498\ue511\u0e4c',
  code: `@group(1) @binding(1513)
var<storage, read_write> n5: array<u32>;
@group(4) @binding(2930)
var<storage, read_write> n6: array<u32>;
@group(4) @binding(3769)
var<storage, read_write> field4: array<u32>;
@group(0) @binding(1338)
var<storage, read_write> field5: array<u32>;
@group(2) @binding(1513)
var<storage, read_write> type7: array<u32>;
@group(5) @binding(2477)
var<storage, read_write> field6: array<u32>;
@group(4) @binding(3765)
var<storage, read_write> n7: array<u32>;
@group(0) @binding(1513)
var<storage, read_write> type8: array<u32>;
@group(2) @binding(1338)
var<storage, read_write> parameter12: array<u32>;
@group(3) @binding(3004)
var<storage, read_write> function3: array<u32>;
@group(1) @binding(1338)
var<storage, read_write> n8: array<u32>;
@group(3) @binding(424)
var<storage, read_write> local5: array<u32>;
@group(3) @binding(186)
var<storage, read_write> n9: 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 {
  @builtin(sample_mask) f0: u32,
  @location(0) f1: vec2<u32>,
  @location(1) f2: vec2<u32>
}

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

struct VertexOutput0 {
  @location(32) f92: vec3<f16>,
  @builtin(position) f93: vec4<f32>,
  @location(38) f94: vec3<i32>,
  @location(37) f95: f32,
  @location(43) f96: vec4<u32>,
  @location(11) f97: f16,
  @location(6) f98: vec3<u32>,
  @location(45) f99: vec2<f32>,
  @location(12) f100: i32,
  @location(70) f101: vec4<i32>,
  @location(17) f102: u32,
  @location(65) f103: vec2<u32>,
  @location(54) f104: vec2<i32>,
  @location(20) f105: f16,
  @location(39) f106: vec3<i32>,
  @location(4) f107: f16,
  @location(30) f108: vec3<f16>,
  @location(67) f109: vec4<u32>,
  @location(23) f110: i32,
  @location(48) f111: f16,
  @location(63) f112: i32,
  @location(28) f113: vec4<i32>,
  @location(46) f114: vec4<f32>,
  @location(19) f115: u32,
  @location(51) f116: f32,
  @location(29) f117: vec4<f32>,
  @location(10) f118: f32,
  @location(25) f119: vec3<i32>
}

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

`,
  sourceMap: {},
  hints: {},
});
let bindGroupLayout29 = pipeline20.getBindGroupLayout(0);
let renderBundle63 = renderBundleEncoder21.finish({label: '\ubf61\u09b6'});
try {
renderPassEncoder7.end();
} catch {}
try {
renderPassEncoder17.endOcclusionQuery();
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer7, 432_054_140);
} catch {}
try {
renderBundleEncoder4.draw(344, 31, 2_575_846_158, 1_639_314_788);
} catch {}
try {
renderBundleEncoder27.setPipeline(pipeline51);
} catch {}
try {
gpuCanvasContext19.configure({
  device: device0,
  format: 'rgba16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let promise30 = device0.queue.onSubmittedWorkDone();
let pipeline76 = device0.createRenderPipeline({
  label: '\u96bf\u2dd6\u0a63\u0b10\u75a6\u464f\ue4d2\u58b1\u0095\u9b4f\u{1fd32}',
  layout: pipelineLayout1,
  fragment: {
  module: shaderModule5,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.BLUE}, {format: 'r32uint', writeMask: GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'invert', passOp: 'replace'},
    stencilBack: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'increment-wrap'},
    stencilReadMask: 75792146,
    stencilWriteMask: 4270536176,
    depthBiasSlopeScale: 0.26705943938102905,
    depthBiasClamp: 17.069680735132238,
  },
  vertex: {
    module: shaderModule5,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32x2', offset: 312, shaderLocation: 4},
          {format: 'snorm8x4', offset: 1024, shaderLocation: 8},
          {format: 'uint16x2', offset: 12620, shaderLocation: 7},
          {format: 'snorm16x2', offset: 2304, shaderLocation: 3},
          {format: 'sint32x3', offset: 4420, shaderLocation: 9},
          {format: 'sint16x2', offset: 3204, shaderLocation: 12},
          {format: 'sint16x4', offset: 9508, shaderLocation: 2},
          {format: 'snorm16x2', offset: 10432, shaderLocation: 13},
          {format: 'unorm8x2', offset: 3086, shaderLocation: 14},
          {format: 'uint16x4', offset: 584, shaderLocation: 6},
          {format: 'uint32x3', offset: 3940, shaderLocation: 10},
          {format: 'float16x2', offset: 11036, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint32x4', offset: 2544, shaderLocation: 11},
          {format: 'uint32x3', offset: 2224, shaderLocation: 5},
          {format: 'uint32x4', offset: 3840, shaderLocation: 15},
        ],
      },
      {
        arrayStride: 5280,
        stepMode: 'vertex',
        attributes: [{format: 'sint16x4', offset: 440, shaderLocation: 1}],
      },
    ],
  },
  primitive: {cullMode: 'front', unclippedDepth: true},
});
canvas9.height = 260;
let bindGroup27 = device1.createBindGroup({label: '\ucab4\u7de8\u05bd\ufb55\u{1facb}\uf6ca', layout: bindGroupLayout26, entries: []});
let buffer21 = device1.createBuffer({
  label: '\u{1f736}\u0e64\u0bd9\u0627\u3a97',
  size: 66896,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE,
  mappedAtCreation: true,
});
let textureView104 = texture43.createView({baseMipLevel: 4, baseArrayLayer: 541, arrayLayerCount: 78});
let renderPassEncoder23 = commandEncoder85.beginRenderPass({
  label: '\u060b\uc528\u{1ff36}\u0a05\u{1f815}\udb73\u{1f628}\u32c3\u0d0e\u9944',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 66.44, g: 97.22, b: 891.2, a: 498.8, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 194.5, g: 431.7, b: 840.3, a: -48.17, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: 619.1, g: -107.1, b: -990.8, a: 894.2, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet32,
  maxDrawCount: 161070436,
});
let renderBundleEncoder58 = device1.createRenderBundleEncoder({
  label: '\ua704\u{1f99b}\u{1feb2}\u{1f794}\u028f\u4d6e\u06f7\u{1f8c5}\ufc79',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
});
try {
renderPassEncoder23.end();
} catch {}
try {
renderPassEncoder22.setScissorRect(3, 0, 0, 7);
} catch {}
try {
renderPassEncoder21.setStencilReference(326);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
commandEncoder83.copyBufferToTexture({
  /* bytesInLastRow: 128 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 67328 */
  offset: 67328,
  bytesPerRow: 256,
  rowsPerImage: 243,
  buffer: buffer15,
}, {
  texture: texture32,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 8, height: 9, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer15);
} catch {}
try {
commandEncoder89.clearBuffer(buffer14, 69756, 700);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder84.resolveQuerySet(querySet25, 209, 150, buffer21, 45056);
} catch {}
let pipeline77 = device1.createRenderPipeline({
  label: '\u{1fa91}\u02f5\u66ce\u232a\uc70a\u{1f7bb}\u2970',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {
  format: 'rgba32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'never', failOp: 'replace', depthFailOp: 'increment-wrap', passOp: 'replace'},
    stencilBack: {compare: 'greater', failOp: 'increment-wrap', passOp: 'decrement-wrap'},
    stencilReadMask: 731875351,
    stencilWriteMask: 2216179971,
    depthBiasSlopeScale: 233.95447549688583,
    depthBiasClamp: 57.65716784568926,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 804,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 104, shaderLocation: 9},
          {format: 'snorm16x4', offset: 28, shaderLocation: 1},
          {format: 'uint16x4', offset: 4, shaderLocation: 11},
          {format: 'uint32x3', offset: 76, shaderLocation: 3},
          {format: 'float16x4', offset: 368, shaderLocation: 7},
          {format: 'snorm8x2', offset: 28, shaderLocation: 4},
          {format: 'uint32x4', offset: 48, shaderLocation: 13},
          {format: 'snorm8x4', offset: 60, shaderLocation: 20},
          {format: 'unorm16x2', offset: 8, shaderLocation: 0},
          {format: 'float32x4', offset: 36, shaderLocation: 6},
          {format: 'sint32x2', offset: 24, shaderLocation: 12},
          {format: 'uint32x2', offset: 248, shaderLocation: 16},
          {format: 'sint8x2', offset: 218, shaderLocation: 25},
          {format: 'unorm16x4', offset: 112, shaderLocation: 26},
          {format: 'sint16x4', offset: 68, shaderLocation: 19},
          {format: 'uint8x4', offset: 536, shaderLocation: 2},
          {format: 'uint32x2', offset: 408, shaderLocation: 15},
          {format: 'float16x2', offset: 52, shaderLocation: 21},
          {format: 'sint32x4', offset: 140, shaderLocation: 23},
        ],
      },
      {
        arrayStride: 776,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x2', offset: 128, shaderLocation: 8},
          {format: 'sint8x2', offset: 152, shaderLocation: 22},
          {format: 'float16x2', offset: 60, shaderLocation: 5},
          {format: 'snorm16x4', offset: 20, shaderLocation: 14},
        ],
      },
      {arrayStride: 2004, attributes: []},
      {
        arrayStride: 276,
        stepMode: 'instance',
        attributes: [{format: 'unorm8x4', offset: 56, shaderLocation: 18}],
      },
    ],
  },
});
let imageBitmap18 = await createImageBitmap(video13);
let gpuCanvasContext31 = canvas20.getContext('webgpu');
let adapter2 = await navigator.gpu.requestAdapter({});
let imageData23 = new ImageData(100, 184);
let bindGroup28 = device1.createBindGroup({
  label: '\u8821\u24f8\u09f9\u016d\u4df2\u24de\u{1f851}\u{1ff9f}\uf66d\u9ff4',
  layout: bindGroupLayout20,
  entries: [],
});
let textureView105 = texture36.createView({label: '\u04f7\u0b2e', dimension: '2d', aspect: 'all', baseMipLevel: 0, baseArrayLayer: 647});
let renderBundleEncoder59 = device1.createRenderBundleEncoder({label: '\u9194\u1b0e', colorFormats: ['r16float', 'rg32float', 'rgba32float'], depthReadOnly: true});
try {
computePassEncoder24.setPipeline(pipeline70);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(5, buffer14, 0, 71085);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 88 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 16132 */
  offset: 6316,
  bytesPerRow: 512,
  buffer: buffer18,
}, {
  texture: texture44,
  mipLevel: 2,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
}, {width: 22, height: 20, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer18);
} catch {}
let canvas21 = document.createElement('canvas');
let imageBitmap19 = await createImageBitmap(offscreenCanvas1);
let videoFrame22 = new VideoFrame(video16, {timestamp: 0});
let textureView106 = texture43.createView({dimension: '2d', baseMipLevel: 1, mipLevelCount: 1, baseArrayLayer: 33});
let renderPassEncoder24 = commandEncoder87.beginRenderPass({
  label: '\u8d17\u1028\u{1ff56}\ud33e\ufd39\u{1fd07}\ud695\u986b\u13f3',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -344.8, g: 409.7, b: 357.2, a: 668.6, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 532.9, g: -714.3, b: 552.9, a: -186.6, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView95,
  depthSlice: 0,
  clearValue: { r: 808.1, g: 304.6, b: 879.4, a: -647.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet35,
  maxDrawCount: 146168777,
});
let renderBundle64 = renderBundleEncoder56.finish({label: '\uf279\udc03\u018f\u8502\u{1f6d9}'});
try {
computePassEncoder39.setBindGroup(0, bindGroup18);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(3113);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline71);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(1, buffer14, 62128, 6331);
} catch {}
let promise31 = device1.queue.onSubmittedWorkDone();
let pipeline78 = await device1.createRenderPipelineAsync({
  label: '\u{1fa90}\u133a\u{1f78e}\u{1fdcf}\u0c46\u03b7\u005e\u01d4',
  layout: pipelineLayout8,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'zero'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA,
}, {format: 'rg32float'}, {format: 'rgba32float'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap', passOp: 'invert'},
    stencilBack: {compare: 'less', failOp: 'invert', depthFailOp: 'decrement-clamp', passOp: 'increment-clamp'},
    stencilWriteMask: 1422050415,
    depthBias: -269290765,
    depthBiasSlopeScale: 847.595920351803,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {arrayStride: 1300, attributes: []},
      {
        arrayStride: 4480,
        attributes: [
          {format: 'unorm16x2', offset: 540, shaderLocation: 0},
          {format: 'unorm8x2', offset: 1346, shaderLocation: 10},
          {format: 'sint16x4', offset: 252, shaderLocation: 16},
          {format: 'float16x4', offset: 128, shaderLocation: 17},
          {format: 'uint32x3', offset: 232, shaderLocation: 1},
          {format: 'unorm16x4', offset: 196, shaderLocation: 24},
          {format: 'sint8x4', offset: 340, shaderLocation: 15},
          {format: 'uint16x2', offset: 1984, shaderLocation: 12},
          {format: 'sint8x2', offset: 288, shaderLocation: 5},
          {format: 'uint16x2', offset: 364, shaderLocation: 8},
          {format: 'unorm16x4', offset: 520, shaderLocation: 11},
          {format: 'uint16x2', offset: 60, shaderLocation: 20},
          {format: 'sint8x4', offset: 888, shaderLocation: 14},
          {format: 'unorm8x4', offset: 272, shaderLocation: 13},
          {format: 'uint8x2', offset: 342, shaderLocation: 4},
          {format: 'float32', offset: 396, shaderLocation: 3},
          {format: 'snorm8x2', offset: 594, shaderLocation: 19},
          {format: 'unorm16x2', offset: 3212, shaderLocation: 23},
          {format: 'sint32x2', offset: 292, shaderLocation: 18},
          {format: 'uint16x4', offset: 580, shaderLocation: 2},
          {format: 'float32x2', offset: 36, shaderLocation: 21},
          {format: 'uint32x4', offset: 44, shaderLocation: 6},
          {format: 'float32x2', offset: 788, shaderLocation: 22},
          {format: 'uint32x3', offset: 1340, shaderLocation: 7},
          {format: 'sint32', offset: 396, shaderLocation: 25},
          {format: 'float32x3', offset: 420, shaderLocation: 9},
        ],
      },
      {arrayStride: 1420, attributes: []},
      {arrayStride: 0, attributes: [{format: 'sint32x2', offset: 1772, shaderLocation: 26}]},
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'cw', cullMode: 'back'},
});
try {
  await adapter1.requestAdapterInfo();
} catch {}
let bindGroupLayout30 = device1.createBindGroupLayout({label: '\uc527\u04f7\u18bf\u{1fe03}\u07f3\u0273', entries: []});
let textureView107 = texture25.createView({label: '\ub22c\uf95d\ue5be', baseMipLevel: 0});
let sampler43 = device1.createSampler({
  label: '\u{1f934}\u0d97\u09cb\u7bbe',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 97.05,
  lodMaxClamp: 99.20,
  maxAnisotropy: 13,
});
try {
renderPassEncoder21.setBlendConstant({ r: 56.48, g: -719.1, b: -705.2, a: 873.4, });
} catch {}
try {
renderBundleEncoder58.setBindGroup(5, bindGroup24, new Uint32Array(7747), 1214, 0);
} catch {}
try {
renderBundleEncoder57.setVertexBuffer(7, buffer19, 362232, 81334);
} catch {}
try {
commandEncoder82.resolveQuerySet(querySet36, 27, 22, buffer21, 8192);
} catch {}
try {
device1.queue.submit([commandBuffer23, commandBuffer20, commandBuffer22, commandBuffer21]);
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
let commandBuffer25 = commandEncoder82.finish({});
let texture46 = device1.createTexture({
  label: '\u3784\u8e87\uc584\u4b06\u0bf6\u363f',
  size: [96],
  dimension: '1d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView108 = texture41.createView({
  label: '\ucdf9\u6b63\u{1fe41}\u0302\u{1fba8}\u78cf\u13ab\u92ce\u0bb7\u{1fd68}\u01d7',
  dimension: '2d',
  baseMipLevel: 2,
  mipLevelCount: 3,
  baseArrayLayer: 1014,
});
let computePassEncoder42 = commandEncoder70.beginComputePass({label: '\u67ea\uc502\u{1f613}\u6e0d\u0c0c'});
let renderPassEncoder25 = commandEncoder84.beginRenderPass({
  label: '\u{1f8ba}\u7f6a\u0d07\u257a\u8df3\u{1fbac}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 963.1, g: -381.1, b: 976.0, a: 589.9, },
  loadOp: 'load',
  storeOp: 'discard',
}, {view: textureView64, depthSlice: 0, loadOp: 'load', storeOp: 'store'}, {
  view: textureView95,
  depthSlice: 0,
  clearValue: { r: -978.5, g: 471.1, b: -8.242, a: 722.9, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet27,
  maxDrawCount: 355449621,
});
try {
computePassEncoder40.setPipeline(pipeline60);
} catch {}
try {
renderPassEncoder25.setBindGroup(1, bindGroup25, []);
} catch {}
try {
renderPassEncoder25.setBindGroup(0, bindGroup26, new Uint32Array(952), 64, 0);
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: 867.7, g: 407.8, b: -392.4, a: 109.8, });
} catch {}
try {
renderPassEncoder24.setScissorRect(2, 1, 3, 3);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline71);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer14);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(4, buffer14, 57304);
} catch {}
try {
commandEncoder88.copyBufferToBuffer(buffer15, 66888, buffer14, 31900, 8208);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder67.copyBufferToTexture({
  /* bytesInLastRow: 36 widthInBlocks: 18 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 1244 */
  offset: 1244,
  bytesPerRow: 256,
  buffer: buffer18,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 18, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer18);
} catch {}
let pipeline79 = await promise21;
let offscreenCanvas28 = new OffscreenCanvas(260, 638);
let img20 = await imageWithData(211, 90, '#8691b2bf', '#627d1f8d');
try {
adapter0.label = '\u113f\uf541\u3b7a\u{1fbc6}\u228f\uc83b\u{1f835}\u0f79';
} catch {}
try {
canvas21.getContext('bitmaprenderer');
} catch {}
let bindGroup29 = device1.createBindGroup({layout: bindGroupLayout26, entries: []});
let commandEncoder90 = device1.createCommandEncoder({label: '\u0bed\u01e5\u0ba2\ub3f1\u08f9\u{1f8cb}\uc261\u0b9d\uf625\u6f44'});
let renderPassEncoder26 = commandEncoder67.beginRenderPass({
  label: '\ub5e5\ud4f4\u01ce\u04d6\u0d6b\u7a4d\u{1f82e}\u06e7\u{1f604}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 309.9, g: -312.1, b: 716.9, a: 450.7, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -723.4, g: -564.1, b: 376.3, a: 301.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: 281.5, g: -667.7, b: 132.4, a: 197.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet31,
});
let externalTexture43 = device1.importExternalTexture({label: '\uea10\u0a30\u{1f81a}\ub9cf\u01ac\u0cf0', source: video2});
try {
computePassEncoder32.setPipeline(pipeline70);
} catch {}
try {
renderPassEncoder21.drawIndexed(96, 31, 151_532_172, 502_002_938, 865_348_528);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer16, 331_603_126);
} catch {}
try {
renderBundleEncoder45.setBindGroup(3, bindGroup27, new Uint32Array(2819), 28, 0);
} catch {}
try {
renderBundleEncoder55.setPipeline(pipeline71);
} catch {}
let commandEncoder91 = device1.createCommandEncoder({label: '\u{1f683}\u03a6\u0462\u{1f69a}\u5572\u220c\u068c\ua869\u{1fd03}'});
let renderBundle65 = renderBundleEncoder43.finish();
try {
computePassEncoder38.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder26.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder26.setBlendConstant({ r: -575.6, g: -662.9, b: 835.7, a: -899.6, });
} catch {}
try {
renderPassEncoder25.setIndexBuffer(buffer19, 'uint16', 231768, 27327);
} catch {}
try {
renderPassEncoder22.setVertexBuffer(6, buffer19, 160996);
} catch {}
try {
buffer14.unmap();
} catch {}
try {
commandEncoder58.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture36,
  mipLevel: 0,
  origin: {x: 0, y: 15, z: 136},
  aspect: 'all',
}, new ArrayBuffer(6_021_499), /* required buffer size: 6_021_499 */
{offset: 453, bytesPerRow: 883, rowsPerImage: 194}, {width: 94, height: 29, depthOrArrayLayers: 36});
} catch {}
let querySet38 = device1.createQuerySet({
  label: '\u{1fb10}\u{1f912}\u8a36\u6ac8\u5bd0\u{1f8b0}\u04b6\u8e2e\u228d\udf67\u0012',
  type: 'occlusion',
  count: 1048,
});
let computePassEncoder43 = commandEncoder88.beginComputePass({label: '\ud469\u0444\u0523\u05da\u0769\u0ab5\u{1f6b4}\u{1ffc5}'});
let renderPassEncoder27 = commandEncoder75.beginRenderPass({
  label: '\u0d1b\u42d7\u0067\u0d3f',
  colorAttachments: [{view: textureView96, loadOp: 'clear', storeOp: 'discard'}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 891.1, g: 635.2, b: -450.1, a: 721.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: -305.8, g: 429.7, b: -22.67, a: 291.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet25,
  maxDrawCount: 1048803690,
});
try {
computePassEncoder32.setPipeline(pipeline73);
} catch {}
try {
renderPassEncoder24.setScissorRect(4, 0, 0, 5);
} catch {}
try {
renderPassEncoder24.setViewport(0.4304, 3.323, 4.027, 3.354, 0.8560, 0.9521);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer18, 134_942_074);
} catch {}
try {
renderPassEncoder27.setIndexBuffer(buffer19, 'uint32');
} catch {}
try {
renderPassEncoder27.setPipeline(pipeline57);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(3, buffer19);
} catch {}
try {
renderBundleEncoder58.setPipeline(pipeline64);
} catch {}
try {
commandEncoder83.resolveQuerySet(querySet27, 958, 1718, buffer16, 5120);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture23,
  mipLevel: 0,
  origin: {x: 1, y: 2, z: 0},
  aspect: 'all',
}, arrayBuffer2, /* required buffer size: 814 */
{offset: 814, bytesPerRow: 548}, {width: 36, height: 34, depthOrArrayLayers: 0});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let offscreenCanvas29 = new OffscreenCanvas(291, 472);
let imageData24 = new ImageData(12, 180);
let querySet39 = device1.createQuerySet({type: 'occlusion', count: 3454});
let textureView109 = texture41.createView({
  label: '\u5a89\u{1fc82}\u4eb1\u019a\u{1f7eb}\u0f0d\u{1ff07}\u{1fbeb}\ub760',
  format: 'astc-6x6-unorm',
  baseMipLevel: 3,
  mipLevelCount: 2,
  baseArrayLayer: 635,
  arrayLayerCount: 559,
});
try {
renderPassEncoder27.end();
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder25.setPipeline(pipeline71);
} catch {}
try {
renderPassEncoder21.setVertexBuffer(4, buffer19);
} catch {}
try {
renderBundleEncoder46.setIndexBuffer(buffer19, 'uint16', 24438, 193997);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(4155, undefined, 0, 1804278373);
} catch {}
let promise32 = device1.popErrorScope();
try {
commandEncoder89.copyTextureToTexture({
  texture: texture38,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
},
{
  texture: texture43,
  mipLevel: 3,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
},
{width: 6, height: 5, depthOrArrayLayers: 0});
} catch {}
try {
commandEncoder90.insertDebugMarker('\ua582');
} catch {}
try {
device1.queue.writeBuffer(buffer17, 876, new Float32Array(43420), 25518, 872);
} catch {}
let renderPassEncoder28 = commandEncoder83.beginRenderPass({
  label: '\u8066\u{1ffb6}\u011b\u987e\u{1f6c0}\u0ea6\ud3d1\u0357',
  colorAttachments: [{view: textureView96, loadOp: 'clear', storeOp: 'store'}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -32.96, g: 71.20, b: 766.5, a: -849.4, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: -723.2, g: 132.3, b: -312.4, a: -922.8, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  maxDrawCount: 330820248,
});
let renderBundleEncoder60 = device1.createRenderBundleEncoder({
  label: '\u2086\ucfe9\ue3e1\u402e\ub708\ue194',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
});
try {
computePassEncoder33.setBindGroup(4, bindGroup17, []);
} catch {}
try {
renderPassEncoder26.setViewport(5.599, 0.9763, 0.3380, 5.819, 0.00388, 0.3295);
} catch {}
try {
renderPassEncoder21.drawIndexed(59, 191);
} catch {}
try {
commandEncoder58.copyBufferToTexture({
  /* bytesInLastRow: 40 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 20844 */
  offset: 20844,
  bytesPerRow: 256,
  rowsPerImage: 211,
  buffer: buffer15,
}, {
  texture: texture44,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 10, height: 11, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer15);
} catch {}
let pipeline80 = device1.createRenderPipeline({
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float', writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rg32float'}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater-equal',
    stencilFront: {compare: 'never', failOp: 'increment-wrap', depthFailOp: 'decrement-clamp', passOp: 'decrement-wrap'},
    stencilBack: {compare: 'not-equal', depthFailOp: 'replace'},
    stencilReadMask: 457959939,
    stencilWriteMask: 412690138,
    depthBias: 332619557,
    depthBiasSlopeScale: 857.8270138843837,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1120,
        attributes: [
          {format: 'float16x2', offset: 148, shaderLocation: 7},
          {format: 'snorm16x4', offset: 260, shaderLocation: 5},
          {format: 'float16x2', offset: 120, shaderLocation: 0},
          {format: 'uint32', offset: 36, shaderLocation: 18},
          {format: 'unorm8x4', offset: 8, shaderLocation: 21},
          {format: 'uint8x4', offset: 96, shaderLocation: 26},
          {format: 'sint32', offset: 16, shaderLocation: 22},
          {format: 'sint32', offset: 80, shaderLocation: 17},
          {format: 'float32', offset: 308, shaderLocation: 1},
          {format: 'sint32x3', offset: 60, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 592,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 20, shaderLocation: 25},
          {format: 'sint8x2', offset: 72, shaderLocation: 3},
          {format: 'float32', offset: 16, shaderLocation: 20},
          {format: 'float32x4', offset: 36, shaderLocation: 9},
          {format: 'uint32x4', offset: 4, shaderLocation: 19},
          {format: 'snorm8x4', offset: 72, shaderLocation: 6},
          {format: 'unorm16x2', offset: 128, shaderLocation: 13},
          {format: 'uint16x2', offset: 44, shaderLocation: 8},
          {format: 'sint32x3', offset: 28, shaderLocation: 10},
          {format: 'uint32', offset: 60, shaderLocation: 12},
          {format: 'uint32', offset: 40, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 4080,
        stepMode: 'instance',
        attributes: [
          {format: 'sint16x4', offset: 2816, shaderLocation: 4},
          {format: 'uint8x2', offset: 938, shaderLocation: 16},
          {format: 'sint32x2', offset: 328, shaderLocation: 2},
          {format: 'sint8x2', offset: 400, shaderLocation: 23},
        ],
      },
      {arrayStride: 0, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 188,
        stepMode: 'instance',
        attributes: [{format: 'float32x4', offset: 36, shaderLocation: 24}],
      },
      {arrayStride: 0, stepMode: 'instance', attributes: []},
      {arrayStride: 72, attributes: [{format: 'unorm8x2', offset: 6, shaderLocation: 15}]},
    ],
  },
  primitive: {topology: 'triangle-list', frontFace: 'cw', cullMode: 'back', unclippedDepth: true},
});
canvas12.width = 2556;
let gpuCanvasContext32 = offscreenCanvas28.getContext('webgpu');
let videoFrame23 = new VideoFrame(imageBitmap16, {timestamp: 0});
try {
offscreenCanvas29.getContext('bitmaprenderer');
} catch {}
video13.height = 114;
let canvas22 = document.createElement('canvas');
try {
  await promise32;
} catch {}
let bindGroupLayout31 = device1.createBindGroupLayout({
  label: '\uc0e8\ue748\u1459',
  entries: [
    {
      binding: 2229,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 643,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      storageTexture: { format: 'r32float', access: 'read-only', viewDimension: '2d' },
    },
    {
      binding: 258,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let textureView110 = texture44.createView({label: '\u{1fc42}\u0cd9\u9048\u7f11\u{1f76a}\u00f8\u402d\ucf5f', baseMipLevel: 3});
let renderBundleEncoder61 = device1.createRenderBundleEncoder({
  label: '\u{1fb3b}\u{1f7bc}\u09f6\ub94c\u09cf\u2e94\u1879\u{1ff75}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle66 = renderBundleEncoder45.finish({});
try {
renderPassEncoder24.setBindGroup(6, bindGroup17, new Uint32Array(3555), 1794, 0);
} catch {}
try {
renderPassEncoder26.setStencilReference(3585);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer19, 640_234_466);
} catch {}
try {
renderBundleEncoder46.setBindGroup(6, bindGroup24);
} catch {}
try {
renderBundleEncoder57.setPipeline(pipeline64);
} catch {}
try {
commandEncoder90.clearBuffer(buffer21, 4028, 16860);
dissociateBuffer(device1, buffer21);
} catch {}
try {
device1.queue.writeBuffer(buffer17, 30000, new Int16Array(44349), 24629, 184);
} catch {}
let promise33 = device1.createRenderPipelineAsync({
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'one-minus-dst', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rg32float', writeMask: GPUColorWrite.GREEN}, {format: 'rgba32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'less-equal',
    stencilFront: {compare: 'greater-equal', failOp: 'increment-wrap', depthFailOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'greater', failOp: 'decrement-wrap', depthFailOp: 'increment-clamp', passOp: 'zero'},
    stencilReadMask: 3309942368,
    stencilWriteMask: 3117408413,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 924,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x4', offset: 288, shaderLocation: 16},
          {format: 'uint32', offset: 296, shaderLocation: 13},
          {format: 'unorm8x4', offset: 240, shaderLocation: 6},
          {format: 'float16x4', offset: 0, shaderLocation: 20},
          {format: 'uint32', offset: 108, shaderLocation: 2},
          {format: 'sint32x4', offset: 108, shaderLocation: 12},
          {format: 'sint8x4', offset: 44, shaderLocation: 22},
          {format: 'unorm8x4', offset: 160, shaderLocation: 1},
          {format: 'snorm16x4', offset: 36, shaderLocation: 18},
          {format: 'sint32x3', offset: 256, shaderLocation: 8},
          {format: 'sint8x4', offset: 24, shaderLocation: 19},
          {format: 'uint8x2', offset: 392, shaderLocation: 11},
          {format: 'uint8x4', offset: 24, shaderLocation: 3},
          {format: 'sint8x4', offset: 276, shaderLocation: 23},
          {format: 'snorm16x2', offset: 60, shaderLocation: 7},
          {format: 'float32x3', offset: 72, shaderLocation: 4},
          {format: 'float16x2', offset: 8, shaderLocation: 26},
          {format: 'sint16x4', offset: 80, shaderLocation: 25},
          {format: 'snorm8x2', offset: 274, shaderLocation: 9},
        ],
      },
      {arrayStride: 1364, attributes: [{format: 'uint32', offset: 24, shaderLocation: 15}]},
      {arrayStride: 736, attributes: [{format: 'unorm16x2', offset: 0, shaderLocation: 0}]},
      {arrayStride: 80, stepMode: 'instance', attributes: []},
      {
        arrayStride: 4116,
        stepMode: 'instance',
        attributes: [{format: 'float32', offset: 552, shaderLocation: 14}],
      },
      {
        arrayStride: 420,
        stepMode: 'instance',
        attributes: [{format: 'unorm10-10-10-2', offset: 52, shaderLocation: 5}],
      },
      {arrayStride: 8612, stepMode: 'instance', attributes: []},
      {arrayStride: 952, attributes: [{format: 'float16x4', offset: 244, shaderLocation: 21}]},
    ],
  },
  primitive: {cullMode: 'back', unclippedDepth: true},
});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let offscreenCanvas30 = new OffscreenCanvas(581, 809);
gc();
let imageBitmap20 = await createImageBitmap(imageBitmap9);
let bindGroup30 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let commandEncoder92 = device1.createCommandEncoder({label: '\u{1f8ac}\uf743\u{1f70c}\udb31\u10a3'});
let textureView111 = texture40.createView({aspect: 'all', mipLevelCount: 1});
let computePassEncoder44 = commandEncoder91.beginComputePass({label: '\u2661\u3029\u00b2\u{1faa2}\u9052\ua502\u09d5'});
let sampler44 = device1.createSampler({
  label: '\u0ea0\u015b\u36b5\u481d',
  addressModeU: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 73.96,
  lodMaxClamp: 82.17,
  maxAnisotropy: 4,
});
try {
renderPassEncoder21.setStencilReference(336);
} catch {}
try {
renderPassEncoder21.draw(66, 130, 380_818_081);
} catch {}
let pipeline81 = await promise27;
let pipeline82 = device1.createRenderPipeline({
  label: '\u0a11\ue21a\u0149\u134b',
  layout: pipelineLayout7,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'subtract', srcFactor: 'src', dstFactor: 'one-minus-src'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.RED,
}, {format: 'rg32float'}, {
  format: 'rgba32float',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 2212,
        attributes: [
          {format: 'sint32x4', offset: 928, shaderLocation: 14},
          {format: 'unorm16x2', offset: 988, shaderLocation: 13},
          {format: 'sint16x4', offset: 64, shaderLocation: 2},
          {format: 'sint16x4', offset: 916, shaderLocation: 22},
          {format: 'float32', offset: 584, shaderLocation: 24},
          {format: 'sint32x3', offset: 36, shaderLocation: 10},
          {format: 'float32x3', offset: 700, shaderLocation: 6},
          {format: 'uint32x4', offset: 484, shaderLocation: 16},
          {format: 'unorm8x2', offset: 116, shaderLocation: 9},
          {format: 'sint32', offset: 1004, shaderLocation: 23},
          {format: 'float32x2', offset: 268, shaderLocation: 1},
          {format: 'float32x3', offset: 248, shaderLocation: 5},
          {format: 'uint32x4', offset: 460, shaderLocation: 26},
          {format: 'unorm16x2', offset: 96, shaderLocation: 0},
          {format: 'uint32', offset: 36, shaderLocation: 8},
          {format: 'uint16x2', offset: 1784, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm8x4', offset: 1084, shaderLocation: 21},
          {format: 'uint32x3', offset: 1128, shaderLocation: 19},
          {format: 'sint16x4', offset: 5108, shaderLocation: 3},
          {format: 'float16x2', offset: 716, shaderLocation: 7},
          {format: 'float32x2', offset: 7488, shaderLocation: 25},
          {format: 'sint32x3', offset: 216, shaderLocation: 4},
          {format: 'snorm16x2', offset: 716, shaderLocation: 15},
          {format: 'uint8x2', offset: 1096, shaderLocation: 18},
          {format: 'uint8x2', offset: 426, shaderLocation: 12},
          {format: 'sint32x4', offset: 1724, shaderLocation: 17},
          {format: 'unorm10-10-10-2', offset: 780, shaderLocation: 20},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint32', cullMode: 'front', unclippedDepth: true},
});
try {
canvas22.getContext('2d');
} catch {}
try {
window.someLabel = externalTexture25.label;
} catch {}
let videoFrame24 = new VideoFrame(img7, {timestamp: 0});
try {
computePassEncoder25.setPipeline(pipeline74);
} catch {}
try {
renderPassEncoder21.beginOcclusionQuery(253);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer15, 2_533_272_826);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(4, buffer19, 160824);
} catch {}
try {
  await buffer17.mapAsync(GPUMapMode.READ, 13176);
} catch {}
try {
commandEncoder90.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 14 widthInBlocks: 7 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 4628 */
  offset: 4628,
  rowsPerImage: 141,
  buffer: buffer16,
}, {width: 7, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer16);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture43,
  mipLevel: 1,
  origin: {x: 3, y: 23, z: 49},
  aspect: 'all',
}, new DataView(new ArrayBuffer(8)), /* required buffer size: 3_869_106 */
{offset: 314, bytesPerRow: 432, rowsPerImage: 96}, {width: 29, height: 28, depthOrArrayLayers: 94});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 8, depthOrArrayLayers: 1}
*/
{
  source: videoFrame22,
  origin: { x: 2, y: 2 },
  flipY: false,
}, {
  texture: texture32,
  mipLevel: 1,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
offscreenCanvas30.getContext('webgl2');
} catch {}
let commandEncoder93 = device1.createCommandEncoder({label: '\u00e1\u02d4\u735f\u0091\u3139'});
let textureView112 = texture42.createView({});
let computePassEncoder45 = commandEncoder89.beginComputePass({});
let renderBundleEncoder62 = device1.createRenderBundleEncoder({
  label: '\u{1f611}\u{1fc5a}\u0ab1\u{1fa7a}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
let externalTexture44 = device1.importExternalTexture({
  label: '\ub78e\u0830\u3c7b\u6aea\u0213\u37c5\u{1f809}\u9af5\u5822',
  source: videoFrame9,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder26.setBindGroup(4, bindGroup17, []);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: 559.4, g: -55.82, b: -37.23, a: -532.0, });
} catch {}
try {
renderPassEncoder21.draw(70);
} catch {}
try {
renderPassEncoder21.drawIndexed(79);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer17, 694_465_029);
} catch {}
try {
renderBundleEncoder58.setBindGroup(2, bindGroup20, []);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(3, buffer19, 401568, 9526);
} catch {}
try {
commandEncoder92.copyBufferToTexture({
  /* bytesInLastRow: 64 widthInBlocks: 8 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 14800 */
  offset: 13200,
  bytesPerRow: 256,
  buffer: buffer15,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
}, {width: 8, height: 7, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer15);
} catch {}
try {
commandEncoder93.resolveQuerySet(querySet24, 1401, 542, buffer21, 57600);
} catch {}
try {
renderPassEncoder28.insertDebugMarker('\ue3a6');
} catch {}
let pipeline83 = device1.createComputePipeline({
  label: '\u2719\uf86e\u{1f8fd}\u0042\u{1f9c0}',
  layout: pipelineLayout7,
  compute: {module: shaderModule9, entryPoint: 'compute0'},
});
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let img21 = await imageWithData(297, 279, '#17ca094f', '#247049de');
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) };
} catch {}
let videoFrame25 = new VideoFrame(imageBitmap8, {timestamp: 0});
let renderBundleEncoder63 = device0.createRenderBundleEncoder({
  label: '\u{1f891}\u{1f7b3}\ue056\uf3ce\u0acc\u60e3\u09c6\uebeb\u0769\ufe0d',
  colorFormats: ['r32uint', 'r32uint'],
  depthReadOnly: true,
});
let sampler45 = device0.createSampler({
  label: '\udeca\u{1f8ca}\u{1fe07}\u171e\u{1fbf0}\u053b',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 58.43,
  lodMaxClamp: 88.14,
  compare: 'greater-equal',
});
try {
computePassEncoder20.end();
} catch {}
try {
renderPassEncoder9.setBindGroup(1, bindGroup16);
} catch {}
try {
renderPassEncoder10.drawIndexed(455, 106);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer0, 1_040_485_409);
} catch {}
try {
renderBundleEncoder4.draw(57, 0, 858_019_211, 265_116_326);
} catch {}
try {
renderBundleEncoder4.drawIndexed(165, 118, 935_877_776, 235_199_179);
} catch {}
let pipeline84 = await device0.createRenderPipelineAsync({
  label: '\u9be6\ud06f\u05b3\u48f1\u0216\u71b8\u08ff\u6749',
  layout: pipelineLayout2,
  multisample: {count: 4, mask: 0x19a393bf},
  fragment: {
  module: shaderModule2,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r32uint', writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE}, {format: 'r32uint'}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'never',
    stencilFront: {compare: 'greater', failOp: 'zero', depthFailOp: 'invert', passOp: 'zero'},
    stencilBack: {compare: 'equal', failOp: 'decrement-clamp', depthFailOp: 'decrement-wrap'},
    stencilWriteMask: 1327713840,
    depthBiasSlopeScale: 532.7174568025637,
  },
  vertex: {
    module: shaderModule2,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1728,
        attributes: [
          {format: 'sint8x4', offset: 96, shaderLocation: 4},
          {format: 'snorm8x4', offset: 196, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint32', offset: 1420, shaderLocation: 14},
          {format: 'uint32x2', offset: 40, shaderLocation: 9},
        ],
      },
    ],
  },
  primitive: {topology: 'line-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true},
});
let bindGroup31 = device1.createBindGroup({layout: bindGroupLayout27, entries: [{binding: 154, resource: sampler38}]});
let commandBuffer26 = commandEncoder93.finish({label: '\ub7ac\uf78f\u9862'});
let computePassEncoder46 = commandEncoder92.beginComputePass();
try {
renderPassEncoder22.setBindGroup(1, bindGroup26);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(951);
} catch {}
try {
renderPassEncoder21.draw(137, 376, 11_918_998, 374_586_730);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer21, 130_756_475);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer16, 249_832_639);
} catch {}
try {
commandEncoder90.copyTextureToTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 1, y: 7, z: 0},
  aspect: 'all',
},
{
  texture: texture39,
  mipLevel: 1,
  origin: {x: 0, y: 2, z: 0},
  aspect: 'all',
},
{width: 5, height: 0, depthOrArrayLayers: 0});
} catch {}
let promise34 = device1.createComputePipelineAsync({
  label: '\u0779\uac13\u82c7\u0f3d\uf24e\ud8f8\u1464\u{1fff0}',
  layout: pipelineLayout7,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let offscreenCanvas31 = new OffscreenCanvas(460, 115);
let videoFrame26 = new VideoFrame(canvas7, {timestamp: 0});
try {
offscreenCanvas31.getContext('webgl2');
} catch {}
let bindGroupLayout32 = device1.createBindGroupLayout({
  label: '\u{1f837}\u5b94',
  entries: [
    {
      binding: 5204,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let renderPassEncoder29 = commandEncoder90.beginRenderPass({
  label: '\u{1f67f}\u89af\u8253\u455f\ub2a3\uaf03\u54c4\ud691\u1f39',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -309.0, g: -511.2, b: -341.6, a: 178.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 989.9, g: 101.2, b: -980.9, a: -512.4, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: 151.8, g: -437.0, b: -440.6, a: 244.4, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet26,
  maxDrawCount: 422390210,
});
let renderBundle67 = renderBundleEncoder58.finish({label: '\u0d0b\u075c\u5ec7\u0fd5\u5111\u093c\uc463\u1dbe\u{1f734}\ua0fd\u021c'});
try {
computePassEncoder28.setPipeline(pipeline72);
} catch {}
try {
renderPassEncoder21.draw(67, 40);
} catch {}
try {
renderPassEncoder21.drawIndexed(60);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(3, buffer19, 0, 54483);
} catch {}
try {
renderBundleEncoder61.setVertexBuffer(2, buffer19, 360552, 17999);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
let arrayBuffer10 = buffer21.getMappedRange(0, 58240);
try {
commandEncoder58.copyTextureToBuffer({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 4, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 43856 */
  offset: 41296,
  bytesPerRow: 256,
  buffer: buffer14,
}, {width: 0, height: 11, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer14);
} catch {}
let textureView113 = texture46.createView({label: '\u016f\u0179', baseArrayLayer: 0});
try {
computePassEncoder25.setBindGroup(3, bindGroup28);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline70);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle54, renderBundle44, renderBundle57, renderBundle59, renderBundle38]);
} catch {}
try {
renderPassEncoder21.drawIndexed(190, 103, 1_918_072_137, 291_335_729, 456_339_229);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(5, buffer19, 135012, 164850);
} catch {}
try {
texture43.destroy();
} catch {}
try {
commandEncoder58.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
commandEncoder58.resolveQuerySet(querySet35, 1321, 929, buffer21, 16640);
} catch {}
try {
gpuCanvasContext21.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['bgra8unorm', 'bgra8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let offscreenCanvas32 = new OffscreenCanvas(660, 166);
let buffer22 = device1.createBuffer({
  label: '\u{1f72b}\u54b2\u87ac\u{1f73e}',
  size: 410352,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.QUERY_RESOLVE,
});
let textureView114 = texture42.createView({label: '\u0af6\u0121', mipLevelCount: 1});
let computePassEncoder47 = commandEncoder58.beginComputePass({});
let externalTexture45 = device1.importExternalTexture({label: '\u867e\u030c\ub8f8\u0511\u3e6a', source: video9, colorSpace: 'display-p3'});
try {
computePassEncoder38.setPipeline(pipeline60);
} catch {}
try {
renderPassEncoder25.setStencilReference(2056);
} catch {}
try {
renderPassEncoder21.draw(71, 39, 6_720_098, 355_284_668);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer17, 88_121_255);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer19, 'uint32', 172876);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(1, buffer14, 3120);
} catch {}
try {
buffer22.unmap();
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let promise35 = device1.createComputePipelineAsync({
  label: '\u0bbc\u2d9a\uea11\u7169\ub398\u0e38\udc52',
  layout: pipelineLayout7,
  compute: {module: shaderModule9, entryPoint: 'compute0'},
});
let pipeline85 = device1.createRenderPipeline({
  label: '\uef98\ud49e\u0803\u48e4\u{1fa34}\u{1f7f6}\uc644\uf6ad\u77f2\u02a4',
  layout: pipelineLayout8,
  multisample: {},
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  targets: [{format: 'r16float', writeMask: GPUColorWrite.RED}, {
  format: 'rg32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'greater',
    stencilFront: {failOp: 'replace', depthFailOp: 'decrement-clamp', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'always', failOp: 'decrement-wrap', depthFailOp: 'invert', passOp: 'zero'},
    stencilReadMask: 821903960,
    stencilWriteMask: 3066526633,
    depthBias: -1301225456,
    depthBiasSlopeScale: 917.141590913657,
    depthBiasClamp: 0.0,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 292, shaderLocation: 11},
          {format: 'snorm8x2', offset: 164, shaderLocation: 20},
          {format: 'unorm16x2', offset: 4856, shaderLocation: 5},
          {format: 'float16x2', offset: 712, shaderLocation: 1},
          {format: 'sint32', offset: 4240, shaderLocation: 10},
          {format: 'sint16x4', offset: 3824, shaderLocation: 2},
          {format: 'sint32x4', offset: 976, shaderLocation: 14},
          {format: 'snorm16x4', offset: 2312, shaderLocation: 15},
          {format: 'uint16x4', offset: 2132, shaderLocation: 26},
          {format: 'float32x2', offset: 132, shaderLocation: 21},
          {format: 'float16x2', offset: 1444, shaderLocation: 7},
          {format: 'unorm16x4', offset: 1196, shaderLocation: 13},
          {format: 'uint32x2', offset: 60, shaderLocation: 18},
          {format: 'uint16x4', offset: 1596, shaderLocation: 19},
          {format: 'unorm8x2', offset: 2696, shaderLocation: 6},
          {format: 'sint32', offset: 4960, shaderLocation: 23},
          {format: 'sint32x3', offset: 2816, shaderLocation: 17},
          {format: 'sint32x4', offset: 1020, shaderLocation: 4},
          {format: 'snorm16x2', offset: 2036, shaderLocation: 25},
          {format: 'snorm16x2', offset: 1128, shaderLocation: 24},
          {format: 'unorm16x2', offset: 3800, shaderLocation: 9},
          {format: 'uint32x2', offset: 1216, shaderLocation: 12},
          {format: 'uint32x2', offset: 520, shaderLocation: 8},
        ],
      },
      {
        arrayStride: 0,
        attributes: [
          {format: 'sint8x2', offset: 218, shaderLocation: 3},
          {format: 'snorm16x4', offset: 100, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 7128,
        stepMode: 'instance',
        attributes: [{format: 'uint16x2', offset: 900, shaderLocation: 16}],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [{format: 'sint16x2', offset: 496, shaderLocation: 22}],
      },
    ],
  },
});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let canvas23 = document.createElement('canvas');
let bindGroup32 = device1.createBindGroup({layout: bindGroupLayout32, entries: [{binding: 5204, resource: sampler40}]});
let querySet40 = device1.createQuerySet({
  label: '\u{1ff64}\u{1f7c1}\uc268\u{1fc38}\ucfb6\u23f6\u3227\u{1f808}\u00ad\u7a3b',
  type: 'occlusion',
  count: 621,
});
try {
computePassEncoder31.setBindGroup(2, bindGroup19, new Uint32Array(5806), 1658, 0);
} catch {}
try {
renderPassEncoder21.setBindGroup(0, bindGroup23);
} catch {}
try {
renderPassEncoder25.beginOcclusionQuery(957);
} catch {}
try {
renderPassEncoder25.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: 243.0, g: -711.1, b: 171.4, a: 273.5, });
} catch {}
try {
renderPassEncoder21.draw(253, 117, 21_624_427, 478_220_382);
} catch {}
try {
renderPassEncoder21.drawIndexed(206, 53, 1_011_477_963, -1_897_958_039);
} catch {}
try {
renderPassEncoder24.setVertexBuffer(3, buffer19, 0, 46097);
} catch {}
try {
renderBundleEncoder60.setBindGroup(5, bindGroup23, []);
} catch {}
try {
gpuCanvasContext12.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm-srgb', 'rgba8unorm'],
  alphaMode: 'premultiplied',
});
} catch {}
let buffer23 = device1.createBuffer({label: '\u{1f6e1}\u5386', size: 53565, usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE});
let commandEncoder94 = device1.createCommandEncoder({label: '\u0c3e\u75f9\uac41\uf5cf\u00df\ue71f\uc78b\u178b'});
let querySet41 = device1.createQuerySet({label: '\ub27d\u8432\u0505\u{1fcfe}', type: 'occlusion', count: 118});
let textureView115 = texture39.createView({
  label: '\u087a\u{1fa8e}\u0d02\u01f1\u924c\u7deb\u{1fce4}\u0fb9\u99c6\u7919\uac4c',
  dimension: '2d',
  baseMipLevel: 2,
  baseArrayLayer: 518,
});
let renderPassEncoder30 = commandEncoder94.beginRenderPass({
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 691.7, g: -857.0, b: 537.3, a: 532.0, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -544.1, g: 26.53, b: -114.8, a: -354.6, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: -51.08, g: -959.3, b: -865.3, a: 253.2, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet29,
  maxDrawCount: 395415513,
});
let renderBundle68 = renderBundleEncoder47.finish({label: '\u0453\u1df4\ud08f\u0741\u99e4\u507f\u8d9d\ubcb7\uf517\u43a2\u0599'});
try {
renderPassEncoder24.setBindGroup(1, bindGroup22);
} catch {}
try {
renderPassEncoder29.setStencilReference(751);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer14, 686_988_487);
} catch {}
try {
gpuCanvasContext16.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 5476, new BigUint64Array(59323), 54678, 512);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture32,
  mipLevel: 0,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, arrayBuffer10, /* required buffer size: 3_161 */
{offset: 408, bytesPerRow: 297}, {width: 5, height: 10, depthOrArrayLayers: 1});
} catch {}
try {
offscreenCanvas32.getContext('bitmaprenderer');
} catch {}
let commandEncoder95 = device1.createCommandEncoder({label: '\u6383\u4922\u535e\ub93d\u2e7f\u8718\u18e5\u{1fcee}'});
let commandBuffer27 = commandEncoder95.finish();
let renderBundle69 = renderBundleEncoder35.finish();
let sampler46 = device1.createSampler({
  label: '\u6c21\u0900\u885b',
  addressModeU: 'repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMaxClamp: 62.24,
});
try {
computePassEncoder34.setBindGroup(3, bindGroup28, new Uint32Array(267), 183, 0);
} catch {}
try {
renderPassEncoder26.setBlendConstant({ r: -261.5, g: -624.9, b: 680.9, a: -933.6, });
} catch {}
try {
renderPassEncoder28.setViewport(0.2700, 6.307, 0.02962, 0.5153, 0.6391, 0.8260);
} catch {}
try {
renderPassEncoder21.draw(203, 202, 361_322_457);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint16', 389690, 1999);
} catch {}
try {
renderBundleEncoder59.setBindGroup(2, bindGroup32);
} catch {}
try {
renderBundleEncoder54.setPipeline(pipeline65);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
try {
device1.queue.writeBuffer(buffer14, 13296, new DataView(new ArrayBuffer(46781)), 41901, 1796);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(1910);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.draw(404, 236, 978_149_937, 1_043_353_685);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer21, 1_846_305_667);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(5, buffer19, 42092, 94514);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 576, new DataView(new ArrayBuffer(56038)), 7769, 6192);
} catch {}
document.body.prepend(video4);
offscreenCanvas32.height = 434;
let commandEncoder96 = device1.createCommandEncoder({label: '\u0b00\u3f26\u6d2d\ue8b9\uc7b6\u087f\u03d3'});
let commandBuffer28 = commandEncoder96.finish({label: '\u{1fe85}\u13c0\u1f2e\u{1f757}\u2548\u2c77\u0a3d\u03fa\u{1ff91}'});
let renderBundleEncoder64 = device1.createRenderBundleEncoder({
  label: '\u1d84\u{1fa15}\u0ded\u0d81\uec0c\u44e1\u{1fe9a}\u582d\udf0b',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
let renderBundle70 = renderBundleEncoder54.finish({label: '\u{1fe94}\u2ac3\u{1fa13}\u0808\u040f\u7ee4\u{1fb0f}\u3af4\u9007'});
try {
computePassEncoder24.setPipeline(pipeline81);
} catch {}
try {
renderPassEncoder29.setBlendConstant({ r: -633.1, g: 822.8, b: 124.9, a: 55.35, });
} catch {}
try {
renderPassEncoder26.setScissorRect(1, 6, 0, 1);
} catch {}
try {
renderPassEncoder21.draw(51, 273, 139_306_889, 997_617_682);
} catch {}
try {
renderBundleEncoder41.setIndexBuffer(buffer19, 'uint16', 439632, 2362);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
try {
device1.queue.writeBuffer(buffer14, 6136, new Float32Array(41402), 37636, 8);
} catch {}
let pipeline86 = device1.createComputePipeline({
  label: '\ub68c\u{1faec}\u{1fe84}',
  layout: pipelineLayout8,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let textureView116 = texture36.createView({label: '\u814d\u6fb5\ufb28\u2c8a\u{1f893}', dimension: '2d', mipLevelCount: 1, baseArrayLayer: 997});
let externalTexture46 = device1.importExternalTexture({label: '\u71a1\u{1f72b}\u495b\u8c91\u004d\ue255', source: video5, colorSpace: 'display-p3'});
try {
renderPassEncoder25.end();
} catch {}
try {
renderPassEncoder24.setBlendConstant({ r: 380.6, g: 720.6, b: 641.2, a: -638.5, });
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder59.setBindGroup(5, bindGroup28, new Uint32Array(3578), 482, 0);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 23908, new BigUint64Array(37617), 35117, 80);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 48, height: 64, depthOrArrayLayers: 1264}
*/
{
  source: imageBitmap17,
  origin: { x: 164, y: 14 },
  flipY: false,
}, {
  texture: texture36,
  mipLevel: 1,
  origin: {x: 3, y: 4, z: 89},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 35, depthOrArrayLayers: 0});
} catch {}
let gpuCanvasContext33 = canvas23.getContext('webgpu');
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
  await promise31;
} catch {}
offscreenCanvas5.height = 3026;
document.body.prepend(canvas13);
let offscreenCanvas33 = new OffscreenCanvas(390, 600);
let gpuCanvasContext34 = offscreenCanvas33.getContext('webgpu');
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let videoFrame27 = new VideoFrame(video6, {timestamp: 0});
document.body.prepend(img8);
let commandEncoder97 = device1.createCommandEncoder({label: '\u3c2f\ufffe\u05cf\u2102\u3033'});
let querySet42 = device1.createQuerySet({label: '\u0fd2\u3232\u50e2', type: 'occlusion', count: 669});
let textureView117 = texture24.createView({label: '\u0b3e\u0d16\u9973\u399c\u90e1\u007c\u{1fa1d}', dimension: '3d'});
let computePassEncoder48 = commandEncoder97.beginComputePass({label: '\u{1fdd2}\u0cc5\u009a\u83bc\ub104'});
let externalTexture47 = device1.importExternalTexture({label: '\u0b44\u{1fa73}\u1ce7\u{1fe80}\u0be3', source: video0, colorSpace: 'srgb'});
try {
renderPassEncoder30.setBindGroup(1, bindGroup18);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(429);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.setBlendConstant({ r: -712.6, g: 280.3, b: -229.9, a: 95.50, });
} catch {}
try {
renderPassEncoder29.setStencilReference(2221);
} catch {}
try {
gpuCanvasContext21.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['rgba8unorm'],
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.writeTexture({
  texture: texture41,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 278},
  aspect: 'all',
}, new Uint8Array(new ArrayBuffer(32)), /* required buffer size: 16_114_683 */
{offset: 431, bytesPerRow: 5093, rowsPerImage: 226}, {width: 1848, height: 0, depthOrArrayLayers: 15});
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
canvas4.width = 1135;
let offscreenCanvas34 = new OffscreenCanvas(581, 30);
try {
gpuCanvasContext27.unconfigure();
} catch {}
offscreenCanvas2.width = 240;
let imageBitmap21 = await createImageBitmap(img8);
let imageData25 = new ImageData(68, 244);
document.body.prepend(video11);
try {
offscreenCanvas34.getContext('2d');
} catch {}
let commandEncoder98 = device1.createCommandEncoder();
let renderBundle71 = renderBundleEncoder38.finish({});
try {
renderPassEncoder22.executeBundles([renderBundle47, renderBundle42, renderBundle39, renderBundle39, renderBundle71, renderBundle56, renderBundle57]);
} catch {}
try {
renderPassEncoder21.draw(32);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder64.setBindGroup(5, bindGroup29);
} catch {}
try {
renderBundleEncoder41.setBindGroup(5, bindGroup19, new Uint32Array(6031), 741, 0);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture37,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer3, /* required buffer size: 517 */
{offset: 517}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas28,
  origin: { x: 153, y: 17 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let pipeline87 = await promise35;
document.body.prepend(canvas22);
video0.width = 119;
let img22 = await imageWithData(284, 135, '#d4bba11f', '#99d6817c');
canvas13.width = 1191;
let videoFrame28 = new VideoFrame(videoFrame18, {timestamp: 0});
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let computePassEncoder49 = commandEncoder98.beginComputePass({label: '\u{1fa05}\u{1fbee}\u84a8\u8056\u0160\u021e\u28cd'});
try {
computePassEncoder43.setBindGroup(3, bindGroup31, new Uint32Array(8232), 2292, 0);
} catch {}
try {
computePassEncoder40.setPipeline(pipeline86);
} catch {}
try {
renderPassEncoder29.setStencilReference(678);
} catch {}
try {
renderPassEncoder26.setViewport(5.776, 2.568, 0.1846, 4.279, 0.4967, 0.8829);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer21, 788_020_517);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder55.setBindGroup(5, bindGroup31);
} catch {}
let textureView118 = texture25.createView({label: '\u80bf\u8197\u0e0d\u0186\u0005\ub1cd', dimension: '2d-array', baseMipLevel: 0});
let renderBundleEncoder65 = device1.createRenderBundleEncoder({colorFormats: ['r16float', 'rg32float', 'rgba32float'], depthReadOnly: true, stencilReadOnly: false});
let renderBundle72 = renderBundleEncoder34.finish({label: '\u0166\u4ead\u3acf\u071d\u1e2a'});
try {
renderPassEncoder22.setBindGroup(1, bindGroup31);
} catch {}
try {
renderPassEncoder24.setScissorRect(5, 5, 1, 1);
} catch {}
try {
renderPassEncoder21.drawIndexed(62, 151, 691_364_753, 243_953_537, 385_548_604);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 2080, new BigUint64Array(53056), 41263, 56);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 24, height: 32, depthOrArrayLayers: 1}
*/
{
  source: imageData17,
  origin: { x: 22, y: 4 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 1,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 2, height: 3, depthOrArrayLayers: 0});
} catch {}
let bindGroup33 = device1.createBindGroup({label: '\u{1fa8c}\u{1f87d}', layout: bindGroupLayout20, entries: []});
let textureView119 = texture32.createView({label: '\u0b9f\ua38a\u0414\u0ab5\u03bd\u5ae9', baseMipLevel: 1});
let renderBundleEncoder66 = device1.createRenderBundleEncoder({
  label: '\u4ac8\uf9f5\ue02f\u8191\uc339\u61ed\u{1fa66}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
});
let renderBundle73 = renderBundleEncoder33.finish();
let externalTexture48 = device1.importExternalTexture({
  label: '\uce7c\u{1fb12}\u{1f84c}\u0116\uc65f\u601b\u0b47\u28c8\u6800',
  source: videoFrame27,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder21.draw(63);
} catch {}
try {
renderPassEncoder21.drawIndexed(657);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer21, 993_534_108);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(4, buffer19, 0, 362499);
} catch {}
try {
renderBundleEncoder55.setVertexBuffer(2, buffer19, 0, 254809);
} catch {}
try {
device1.pushErrorScope('out-of-memory');
} catch {}
let arrayBuffer11 = buffer19.getMappedRange(344664, 79836);
try {
renderBundleEncoder46.insertDebugMarker('\ue3b5');
} catch {}
try {
device1.queue.submit([commandBuffer17]);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 2156, new BigUint64Array(2674), 487, 88);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: img15,
  origin: { x: 25, y: 8 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline88 = device1.createRenderPipeline({
  label: '\uab35\u0cf4\u344d\u0c61\u8ed2\u{1f94c}',
  layout: 'auto',
  multisample: {count: 4},
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'zero', dstFactor: 'one-minus-dst'},
    alpha: {operation: 'subtract', srcFactor: 'dst', dstFactor: 'one-minus-dst'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}, {format: 'rg32float', writeMask: 0}, {format: 'rgba32float'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'never',
    stencilFront: {compare: 'not-equal', depthFailOp: 'decrement-clamp', passOp: 'invert'},
    stencilBack: {compare: 'greater', failOp: 'decrement-clamp', depthFailOp: 'invert', passOp: 'keep'},
    stencilReadMask: 4125211046,
    stencilWriteMask: 3638400563,
    depthBiasClamp: 411.28875984916095,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 2144,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 196, shaderLocation: 10},
          {format: 'sint16x4', offset: 196, shaderLocation: 15},
          {format: 'uint32x3', offset: 72, shaderLocation: 20},
          {format: 'sint32x4', offset: 172, shaderLocation: 26},
          {format: 'float32x4', offset: 348, shaderLocation: 24},
          {format: 'unorm10-10-10-2', offset: 52, shaderLocation: 23},
          {format: 'sint8x4', offset: 344, shaderLocation: 18},
          {format: 'uint8x2', offset: 1046, shaderLocation: 1},
          {format: 'unorm8x2', offset: 14, shaderLocation: 11},
          {format: 'snorm16x4', offset: 12, shaderLocation: 21},
          {format: 'sint8x2', offset: 240, shaderLocation: 25},
          {format: 'float32x3', offset: 84, shaderLocation: 22},
          {format: 'unorm10-10-10-2', offset: 40, shaderLocation: 13},
          {format: 'sint32x2', offset: 412, shaderLocation: 16},
          {format: 'float16x4', offset: 508, shaderLocation: 3},
          {format: 'snorm8x2', offset: 772, shaderLocation: 17},
        ],
      },
      {
        arrayStride: 44,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x4', offset: 4, shaderLocation: 19},
          {format: 'unorm8x4', offset: 0, shaderLocation: 0},
          {format: 'uint32x3', offset: 4, shaderLocation: 4},
          {format: 'uint8x2', offset: 20, shaderLocation: 8},
          {format: 'uint32x4', offset: 0, shaderLocation: 6},
        ],
      },
      {
        arrayStride: 1628,
        attributes: [
          {format: 'uint32x3', offset: 72, shaderLocation: 12},
          {format: 'uint32x4', offset: 76, shaderLocation: 7},
          {format: 'sint32x4', offset: 96, shaderLocation: 5},
          {format: 'float32x3', offset: 436, shaderLocation: 9},
        ],
      },
      {
        arrayStride: 772,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x2', offset: 36, shaderLocation: 2},
          {format: 'sint16x4', offset: 76, shaderLocation: 14},
        ],
      },
    ],
  },
});
let commandEncoder99 = device1.createCommandEncoder();
let textureView120 = texture45.createView({label: '\u0d5c\u0e4e\u0e6d\u278b\u6595\u{1ff58}\u0a24\u{1fb77}', baseMipLevel: 2});
let renderBundleEncoder67 = device1.createRenderBundleEncoder({
  label: '\u0c25\u2a2a\u{1f76a}\u6afb\u0836\u98db\u{1fb24}\u4b8b\ue397',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
try {
renderPassEncoder29.setBindGroup(3, bindGroup27);
} catch {}
try {
renderPassEncoder21.drawIndexed(12, 26, 124_520_474, 1_130_405_226, 1_071_973_832);
} catch {}
try {
renderBundleEncoder46.setBindGroup(7, bindGroup26);
} catch {}
try {
renderBundleEncoder55.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder59.setVertexBuffer(5, buffer14, 70092, 1327);
} catch {}
try {
commandEncoder99.copyTextureToTexture({
  texture: texture38,
  mipLevel: 0,
  origin: {x: 0, y: 5, z: 30},
  aspect: 'all',
},
{
  texture: texture46,
  mipLevel: 0,
  origin: {x: 8, y: 0, z: 0},
  aspect: 'all',
},
{width: 20, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.writeBuffer(buffer14, 3472, new DataView(new ArrayBuffer(45540)), 1011, 10208);
} catch {}
let pipeline89 = await device1.createComputePipelineAsync({layout: pipelineLayout8, compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}}});
let bindGroup34 = device1.createBindGroup({
  label: '\u8276\u775e\u2880\u0cce\ue2b6\u{1fefa}\uda89\u{1f6bb}\u0141\u7d99\u8bd6',
  layout: bindGroupLayout26,
  entries: [],
});
try {
renderPassEncoder21.setBindGroup(6, bindGroup18);
} catch {}
try {
renderPassEncoder24.setViewport(3.610, 0.3314, 0.1326, 7.085, 0.3986, 0.6571);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer16, 3_191_240_246);
} catch {}
try {
renderBundleEncoder67.setBindGroup(0, bindGroup26);
} catch {}
let arrayBuffer12 = buffer21.getMappedRange(59600, 5584);
try {
commandEncoder99.copyTextureToTexture({
  texture: texture26,
  mipLevel: 2,
  origin: {x: 30, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture26,
  mipLevel: 0,
  origin: {x: 150, y: 0, z: 0},
  aspect: 'all',
},
{width: 990, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder99.clearBuffer(buffer14, 25400, 15664);
dissociateBuffer(device1, buffer14);
} catch {}
let commandEncoder100 = device1.createCommandEncoder({label: '\u87e8\u5346\u0ec6\ud7db\u7cc3\u{1fa4a}\ud4dd\u6bd5\u0c2f'});
try {
renderPassEncoder26.setStencilReference(2062);
} catch {}
try {
renderPassEncoder26.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(0, buffer19, 232808, 165373);
} catch {}
try {
commandEncoder99.clearBuffer(buffer14, 66704, 1336);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder99.resolveQuerySet(querySet37, 111, 138, buffer23, 512);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 4084, new Int16Array(62371), 38561, 6764);
} catch {}
let pipeline90 = await promise34;
let commandEncoder101 = device1.createCommandEncoder({label: '\u5ec4\u{1f902}\uf2d0\u5de6'});
let texture47 = device1.createTexture({
  label: '\uf77c\u{1fc4f}\u539d\u0100\u8996\ub7a4\u838a',
  size: {width: 24},
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView121 = texture40.createView({baseMipLevel: 1});
let computePassEncoder50 = commandEncoder100.beginComputePass();
let renderPassEncoder31 = commandEncoder101.beginRenderPass({
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -193.9, g: -688.4, b: 633.5, a: -996.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -798.1, g: -285.0, b: -905.7, a: 295.8, },
  loadOp: 'load',
  storeOp: 'discard',
}, {view: textureView95, depthSlice: 0, loadOp: 'load', storeOp: 'discard'}],
  occlusionQuerySet: querySet40,
  maxDrawCount: 124094035,
});
let sampler47 = device1.createSampler({
  label: '\u0fec\u016a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  lodMaxClamp: 83.33,
});
let externalTexture49 = device1.importExternalTexture({source: videoFrame22, colorSpace: 'srgb'});
try {
renderPassEncoder21.drawIndirect(buffer13, 3_530_940_434);
} catch {}
try {
renderPassEncoder29.setIndexBuffer(buffer23, 'uint16', 15126, 14105);
} catch {}
try {
renderBundleEncoder61.setBindGroup(6, bindGroup29, new Uint32Array(6903), 4556, 0);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(225, undefined, 0);
} catch {}
try {
commandEncoder99.clearBuffer(buffer14, 12892, 4452);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer5, /* required buffer size: 696 */
{offset: 696}, {width: 11, height: 0, depthOrArrayLayers: 1});
} catch {}
let pipeline91 = device1.createRenderPipeline({
  layout: pipelineLayout7,
  multisample: {mask: 0x143872c6},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED}, {
  format: 'rgba32float',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'less',
    stencilFront: {compare: 'not-equal', failOp: 'replace', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilBack: {compare: 'always', failOp: 'invert', depthFailOp: 'zero', passOp: 'decrement-clamp'},
    stencilReadMask: 60388748,
    depthBiasSlopeScale: 972.8563616738224,
    depthBiasClamp: 6.776282150329607,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1212,
        attributes: [
          {format: 'unorm10-10-10-2', offset: 312, shaderLocation: 9},
          {format: 'uint32x3', offset: 36, shaderLocation: 11},
          {format: 'snorm16x2', offset: 92, shaderLocation: 5},
          {format: 'sint32x3', offset: 308, shaderLocation: 19},
          {format: 'uint32x4', offset: 420, shaderLocation: 2},
          {format: 'unorm16x2', offset: 524, shaderLocation: 7},
          {format: 'uint8x2', offset: 198, shaderLocation: 3},
          {format: 'snorm8x2', offset: 132, shaderLocation: 0},
          {format: 'sint32x4', offset: 176, shaderLocation: 22},
          {format: 'float32', offset: 200, shaderLocation: 20},
          {format: 'sint32x3', offset: 636, shaderLocation: 23},
          {format: 'uint16x4', offset: 20, shaderLocation: 15},
          {format: 'sint16x4', offset: 64, shaderLocation: 12},
          {format: 'float32x2', offset: 164, shaderLocation: 14},
          {format: 'unorm8x2', offset: 486, shaderLocation: 21},
          {format: 'snorm16x2', offset: 168, shaderLocation: 18},
          {format: 'sint8x2', offset: 92, shaderLocation: 25},
          {format: 'uint8x4', offset: 28, shaderLocation: 16},
          {format: 'unorm10-10-10-2', offset: 12, shaderLocation: 4},
        ],
      },
      {arrayStride: 264, stepMode: 'instance', attributes: []},
      {arrayStride: 1104, attributes: []},
      {
        arrayStride: 616,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 412, shaderLocation: 6},
          {format: 'snorm16x2', offset: 108, shaderLocation: 1},
          {format: 'sint16x4', offset: 16, shaderLocation: 8},
          {format: 'snorm16x2', offset: 12, shaderLocation: 26},
          {format: 'uint8x2', offset: 390, shaderLocation: 13},
        ],
      },
    ],
  },
  primitive: {frontFace: 'cw'},
});
pseudoSubmit(device1);
let sampler48 = device1.createSampler({
  label: '\u6c57\u3e88\u{1ffd0}\u{1fcd9}\u19e6\u2a4d\ud866\u0e0d\u09ff\ude16',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  mipmapFilter: 'nearest',
  lodMinClamp: 10.76,
  lodMaxClamp: 44.79,
});
let externalTexture50 = device1.importExternalTexture({label: '\u297c\u8b89\u{1f9f6}\u09c5\u4e8a\u6f5f\u2708\u{1f9b6}', source: videoFrame19});
try {
computePassEncoder36.setPipeline(pipeline90);
} catch {}
try {
renderPassEncoder26.setBindGroup(6, bindGroup20);
} catch {}
try {
renderPassEncoder22.setScissorRect(2, 0, 4, 4);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer15, 35_208_880);
} catch {}
try {
renderPassEncoder26.setVertexBuffer(0, buffer14, 0, 48195);
} catch {}
try {
renderBundleEncoder59.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder67.setVertexBuffer(0, buffer19, 0, 156510);
} catch {}
try {
commandEncoder99.resolveQuerySet(querySet37, 66, 166, buffer23, 41216);
} catch {}
let pipeline92 = device1.createComputePipeline({
  label: '\u349c\u{1f6a2}\uf397\u91bf\u0ded\u{1f890}\u001b\u00a0',
  layout: pipelineLayout7,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
try {
  await promise30;
} catch {}
gc();
let textureView122 = texture29.createView({label: '\u{1fd0f}\u2538\u2a97\ue05a\u{1ff2d}'});
let sampler49 = device1.createSampler({
  addressModeU: 'mirror-repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'nearest',
  mipmapFilter: 'linear',
  lodMinClamp: 18.48,
});
try {
renderPassEncoder22.setScissorRect(2, 7, 0, 1);
} catch {}
try {
renderPassEncoder21.drawIndexed(119, 39);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer19, 1_498_100_021);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer21, 473_411_775);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder64.setVertexBuffer(6, buffer19);
} catch {}
try {
  await device1.popErrorScope();
} catch {}
try {
commandEncoder99.copyBufferToBuffer(buffer22, 324984, buffer14, 14208, 56548);
dissociateBuffer(device1, buffer22);
dissociateBuffer(device1, buffer14);
} catch {}
try {
commandEncoder99.copyBufferToTexture({
  /* bytesInLastRow: 180 widthInBlocks: 90 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 906 */
  offset: 906,
  buffer: buffer18,
}, {
  texture: texture29,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 90, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer18);
} catch {}
try {
commandEncoder99.insertDebugMarker('\uc760');
} catch {}
let adapter3 = await navigator.gpu.requestAdapter({});
let offscreenCanvas35 = new OffscreenCanvas(427, 172);
let textureView123 = texture46.createView({label: '\u7412\u0f3c\u2983'});
let sampler50 = device1.createSampler({
  label: '\u0fe1\u5a2d\ufc0b\u{1fcc0}\u1117\u7c0f\u3e73\u050c\ud990\u90f7\uf9fa',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 66.06,
  maxAnisotropy: 17,
});
try {
renderPassEncoder30.setViewport(2.587, 6.726, 3.372, 0.7530, 0.1446, 0.5480);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer23, 1_655_328_614);
} catch {}
try {
renderPassEncoder24.setIndexBuffer(buffer19, 'uint32', 315832, 14112);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline71);
} catch {}
try {
commandEncoder99.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 2272 */
  offset: 2272,
  bytesPerRow: 0,
  rowsPerImage: 104,
  buffer: buffer22,
}, {
  texture: texture39,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 23},
  aspect: 'all',
}, {width: 0, height: 4, depthOrArrayLayers: 654});
dissociateBuffer(device1, buffer22);
} catch {}
try {
commandEncoder99.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 6 widthInBlocks: 3 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 12930 */
  offset: 12930,
  bytesPerRow: 256,
  buffer: buffer16,
}, {width: 3, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer16);
} catch {}
try {
device1.queue.submit([commandBuffer25]);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let videoFrame29 = new VideoFrame(offscreenCanvas31, {timestamp: 0});
let bindGroup35 = device1.createBindGroup({label: '\u0ddb\u{1fe74}\ud13f', layout: bindGroupLayout20, entries: []});
let commandEncoder102 = device1.createCommandEncoder({label: '\u{1fde3}\u{1ffe0}\uc886\u0d41\u{1f8b7}'});
let querySet43 = device1.createQuerySet({type: 'occlusion', count: 3713});
let computePassEncoder51 = commandEncoder99.beginComputePass();
let renderPassEncoder32 = commandEncoder102.beginRenderPass({
  label: '\u{1f89f}\u30c4\u3aa0',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -732.5, g: 296.2, b: -857.3, a: -889.8, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 465.4, g: -780.3, b: 301.6, a: 659.1, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView95,
  depthSlice: 0,
  clearValue: { r: -158.6, g: 232.1, b: -835.4, a: 263.7, },
  loadOp: 'load',
  storeOp: 'discard',
}],
});
try {
renderPassEncoder21.draw(534, 251);
} catch {}
try {
renderPassEncoder21.drawIndexed(227, 102, 121_285_077, 184_617_772, 792_366_281);
} catch {}
try {
renderPassEncoder32.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder44.setBindGroup(4, bindGroup26);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture41,
  mipLevel: 4,
  origin: {x: 18, y: 0, z: 45},
  aspect: 'all',
}, arrayBuffer6, /* required buffer size: 11_067_875 */
{offset: 637, bytesPerRow: 73, rowsPerImage: 221}, {width: 24, height: 0, depthOrArrayLayers: 687});
} catch {}
let pipeline93 = device1.createComputePipeline({
  label: '\ubc97\u80d8\u0feb\ue291\u{1febc}\ua52d\u03e5',
  layout: pipelineLayout7,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let pipeline94 = device1.createRenderPipeline({
  label: '\u07a8\u0888\ud35a\u0c58\u{1f848}\u711a\udccc\u{1f7f5}\u16ee',
  layout: pipelineLayout7,
  multisample: {count: 4, mask: 0x95274cee},
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'src-alpha-saturated', dstFactor: 'one-minus-src-alpha'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}, {format: 'rg32float'}, {format: 'rgba32float', writeMask: GPUColorWrite.ALPHA}],
},
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 2032,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 24, shaderLocation: 2},
          {format: 'unorm10-10-10-2', offset: 552, shaderLocation: 6},
          {format: 'uint32x2', offset: 264, shaderLocation: 11},
        ],
      },
      {
        arrayStride: 1232,
        stepMode: 'vertex',
        attributes: [
          {format: 'float32x3', offset: 48, shaderLocation: 14},
          {format: 'uint32x4', offset: 40, shaderLocation: 3},
          {format: 'unorm8x2', offset: 196, shaderLocation: 20},
          {format: 'sint32x3', offset: 20, shaderLocation: 8},
          {format: 'unorm8x4', offset: 940, shaderLocation: 7},
          {format: 'float16x2', offset: 292, shaderLocation: 26},
          {format: 'uint32x4', offset: 792, shaderLocation: 15},
          {format: 'sint16x4', offset: 532, shaderLocation: 22},
          {format: 'sint16x2', offset: 136, shaderLocation: 23},
          {format: 'snorm8x2', offset: 122, shaderLocation: 21},
          {format: 'sint32', offset: 56, shaderLocation: 25},
          {format: 'unorm10-10-10-2', offset: 588, shaderLocation: 18},
          {format: 'sint32x3', offset: 356, shaderLocation: 12},
          {format: 'uint32x2', offset: 164, shaderLocation: 16},
        ],
      },
      {
        arrayStride: 2688,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint32x3', offset: 160, shaderLocation: 13},
          {format: 'snorm8x4', offset: 292, shaderLocation: 0},
        ],
      },
      {
        arrayStride: 2300,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x4', offset: 28, shaderLocation: 9},
          {format: 'unorm16x4', offset: 256, shaderLocation: 5},
          {format: 'sint16x4', offset: 792, shaderLocation: 19},
          {format: 'unorm8x4', offset: 32, shaderLocation: 4},
          {format: 'snorm8x2', offset: 116, shaderLocation: 1},
        ],
      },
    ],
  },
  primitive: {
  topology: 'triangle-strip',
  stripIndexFormat: 'uint16',
  frontFace: 'cw',
  cullMode: 'none',
  unclippedDepth: true,
},
});
let bindGroupLayout33 = device1.createBindGroupLayout({
  label: '\u05e2\uf80d\ufa92\u{1f6aa}\uaf74\ud4b9\u2d34\u4d41',
  entries: [
    {
      binding: 4361,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 134995801, hasDynamicOffset: false },
    },
    {
      binding: 4285,
      visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
      sampler: { type: 'non-filtering' },
    },
  ],
});
let commandEncoder103 = device1.createCommandEncoder({label: '\u{1ff7b}\u5abe\u{1f861}\u{1fd23}\u663a\u3de6\u53a9\uabb1\u6fdf\u81ac\u0921'});
let textureView124 = texture45.createView({
  label: '\u085e\ub159\u{1fff7}\uc8a1\u432a\u{1f681}\u{1fb78}\u{1fdd7}\u{1f7da}\u{1f78d}\u0df8',
  baseMipLevel: 1,
  mipLevelCount: 2,
});
let renderPassEncoder33 = commandEncoder103.beginRenderPass({
  label: '\u{1f80e}\uadd2\u3d61\ua7c9\u{1fd9a}\u07f1\u5a78\u0e7b\u07c1',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 294.5, g: 37.52, b: -888.6, a: 779.8, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -530.8, g: 229.1, b: -825.7, a: -296.9, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: -25.02, g: -315.8, b: -27.40, a: -960.3, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet28,
  maxDrawCount: 1189589563,
});
let renderBundleEncoder68 = device1.createRenderBundleEncoder({
  label: '\u841c\u1d11\ud36a\uded1',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderPassEncoder21.draw(322, 50, 1_849_610_297);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer20, 790_255_676);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer14, 4_294_967_295);
} catch {}
try {
renderBundleEncoder65.setVertexBuffer(3, buffer19, 199744, 190689);
} catch {}
let gpuCanvasContext35 = offscreenCanvas35.getContext('webgpu');
let device2 = await adapter3.requestDevice({
  label: '\u01ed\u{1fcd0}\u1d21\u98cb\ucd87',
  defaultQueue: {label: '\u35d9\u1601\ub3d9\u3799\u{1fa97}\u0958\u1122\u45f9'},
});
let imageBitmap22 = await createImageBitmap(canvas3);
let commandEncoder104 = device1.createCommandEncoder();
let renderPassEncoder34 = commandEncoder104.beginRenderPass({
  label: '\u9e7b\u04a1\u9679\u72ea\u2ae9\u{1f937}\u1969\u01bc',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -856.4, g: 135.5, b: -37.22, a: -635.7, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 431.0, g: 253.9, b: -272.2, a: -418.8, },
  loadOp: 'load',
  storeOp: 'discard',
}, {view: textureView85, depthSlice: 0, loadOp: 'load', storeOp: 'discard'}],
  maxDrawCount: 852776544,
});
try {
computePassEncoder34.setPipeline(pipeline86);
} catch {}
try {
renderPassEncoder21.setViewport(4.649, 2.646, 0.1698, 4.256, 0.08900, 0.6456);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer22, 1_291_064_173);
} catch {}
try {
renderPassEncoder31.setIndexBuffer(buffer23, 'uint16');
} catch {}
try {
querySet32.destroy();
} catch {}
let arrayBuffer13 = buffer17.getMappedRange(36280, 616);
try {
device1.queue.writeBuffer(buffer14, 5604, new Float32Array(36012), 2622, 572);
} catch {}
let imageBitmap23 = await createImageBitmap(imageData5);
let buffer24 = device2.createBuffer({size: 208288, usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE});
let renderBundleEncoder69 = device2.createRenderBundleEncoder({
  label: '\u0175\u7cb8\uedc5\ud88e\uf651\uc324\u0dbd',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
});
let sampler51 = device2.createSampler({
  label: '\u7618\u{1f733}\u673c\u{1fe22}\u0c3f',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  lodMinClamp: 61.58,
  lodMaxClamp: 61.98,
  compare: 'greater-equal',
});
let externalTexture51 = device2.importExternalTexture({label: '\u0f14\uc723\u8551\u96a2\ue675', source: videoFrame26, colorSpace: 'srgb'});
let promise36 = device2.queue.onSubmittedWorkDone();
try {
  await promise36;
} catch {}
let buffer25 = device2.createBuffer({
  label: '\u{1fc34}\u065a\u1b2e\u0063\u{1f92b}\u990f',
  size: 186076,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
let commandEncoder105 = device2.createCommandEncoder({label: '\ub9af\u0484\uf7d5\u1f49\u{1f862}\u{1fc97}\u6a1b'});
let texture48 = device2.createTexture({
  label: '\u{1ff1e}\u{1fa90}\ucd2a\u{1fbb3}\u0bc7\u61df\u0d03\u9bf1',
  size: {width: 14, height: 8, depthOrArrayLayers: 30},
  mipLevelCount: 3,
  dimension: '3d',
  format: 'r8sint',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['r8sint', 'r8sint'],
});
let computePassEncoder52 = commandEncoder105.beginComputePass({label: '\u32ac\u5d38\u0958\u64e1\u{1f720}\ua021'});
try {
window.someLabel = externalTexture4.label;
} catch {}
let shaderModule13 = device0.createShaderModule({
  code: `@group(0) @binding(3765)
var<storage, read_write> n10: array<u32>;
@group(3) @binding(1338)
var<storage, read_write> global4: array<u32>;
@group(5) @binding(1513)
var<storage, read_write> type9: array<u32>;
@group(5) @binding(1338)
var<storage, read_write> n11: array<u32>;
@group(3) @binding(1513)
var<storage, read_write> type10: array<u32>;
@group(0) @binding(3769)
var<storage, read_write> type11: array<u32>;
@group(4) @binding(3479)
var<storage, read_write> type12: array<u32>;
@group(0) @binding(2930)
var<storage, read_write> n12: array<u32>;
@group(2) @binding(3796)
var<storage, read_write> n13: array<u32>;
@group(4) @binding(2527)
var<storage, read_write> n14: array<u32>;
@group(1) @binding(410)
var<storage, read_write> n15: array<u32>;
@group(4) @binding(76)
var<storage, read_write> type13: array<u32>;
@group(2) @binding(3374)
var<storage, read_write> type14: 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: vec3<u32>,
  @location(1) f1: vec3<u32>,
  @builtin(sample_mask) f2: u32
}

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

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

@vertex
fn vertex0(@location(15) a0: vec3<f32>, @location(5) a1: vec2<i32>, @location(1) a2: vec2<f16>, a3: S13, @builtin(instance_index) a4: u32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
  sourceMap: {},
  hints: {},
});
let renderPassEncoder35 = commandEncoder41.beginRenderPass({
  label: '\u0019\u846c\u{1f678}\uc5e9\u01f5\uc673',
  colorAttachments: [{
  view: textureView28,
  depthSlice: 382,
  clearValue: { r: 992.7, g: -586.5, b: 579.7, a: -69.71, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView29,
  depthSlice: 37,
  clearValue: { r: -522.9, g: -552.6, b: -317.3, a: 464.5, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet21,
  maxDrawCount: 1153471148,
});
let renderBundleEncoder70 = device0.createRenderBundleEncoder({
  label: '\ud859\u02d2\u4c41\u5a08\u{1fd28}\u{1fd9d}',
  colorFormats: ['r32uint', 'r32uint'],
  stencilReadOnly: true,
});
let sampler52 = device0.createSampler({
  label: '\uaae2\u2cad\u0a0c\u9bb8\u058a\u02bc\u0767\u{1fc27}\u{1f8d4}\u{1fa1b}',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'repeat',
  magFilter: 'linear',
  lodMinClamp: 51.34,
  lodMaxClamp: 75.93,
});
let externalTexture52 = device0.importExternalTexture({source: videoFrame15, colorSpace: 'srgb'});
try {
renderPassEncoder1.beginOcclusionQuery(694);
} catch {}
try {
renderPassEncoder0.setScissorRect(54, 0, 29, 0);
} catch {}
try {
renderPassEncoder10.drawIndexedIndirect(buffer1, 544_043_693);
} catch {}
try {
renderPassEncoder10.drawIndirect(buffer7, 903_927_485);
} catch {}
try {
renderBundleEncoder70.setBindGroup(4, bindGroup0);
} catch {}
try {
renderBundleEncoder12.setBindGroup(4, bindGroup12, new Uint32Array(2494), 2434, 0);
} catch {}
try {
renderBundleEncoder4.draw(69, 165);
} catch {}
try {
renderBundleEncoder70.setPipeline(pipeline27);
} catch {}
try {
renderBundleEncoder31.setVertexBuffer(708, undefined, 0, 3421477834);
} catch {}
try {
device0.queue.writeTexture({
  texture: texture21,
  mipLevel: 5,
  origin: {x: 0, y: 1, z: 4},
  aspect: 'all',
}, new Uint8ClampedArray(arrayBuffer8), /* required buffer size: 484_703 */
{offset: 571, bytesPerRow: 41, rowsPerImage: 227}, {width: 1, height: 5, depthOrArrayLayers: 53});
} catch {}
let promise37 = device0.createComputePipelineAsync({
  label: '\u{1fe94}\u66da',
  layout: pipelineLayout3,
  compute: {module: shaderModule13, entryPoint: 'compute0', constants: {}},
});
let pipeline95 = await device0.createRenderPipelineAsync({
  label: '\ubd7a\u03c7\u2644\u00a4\u345f\u0317',
  layout: 'auto',
  multisample: {count: 4, mask: 0x4b24837f},
  fragment: {
  module: shaderModule1,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r32uint',
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {
  format: 'r32uint',
  writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
}],
},
  vertex: {module: shaderModule1, entryPoint: 'vertex0', buffers: []},
  primitive: {topology: 'point-list', frontFace: 'cw', cullMode: 'front', unclippedDepth: true},
});
let imageBitmap24 = await createImageBitmap(offscreenCanvas2);
let device3 = await adapter2.requestDevice({label: '\u1474\u6f30\uedd4\u0145\u00e2\u03aa\ubb52\u06fc\u{1feb0}'});
let video17 = await videoWithData();
let commandEncoder106 = device2.createCommandEncoder();
let querySet44 = device2.createQuerySet({label: '\uca9f\u463c\u0ef3\u{1fc44}', type: 'occlusion', count: 3343});
let textureView125 = texture48.createView({label: '\uff7c\u0f54', mipLevelCount: 1});
let arrayBuffer14 = buffer25.getMappedRange(0, 174132);
try {
commandEncoder106.copyBufferToTexture({
  /* bytesInLastRow: 1 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 47140 */
  offset: 13091,
  bytesPerRow: 256,
  rowsPerImage: 44,
  buffer: buffer24,
}, {
  texture: texture48,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, {width: 1, height: 2, depthOrArrayLayers: 4});
dissociateBuffer(device2, buffer24);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Uint32Array(arrayBuffer11), /* required buffer size: 455_199 */
{offset: 259, bytesPerRow: 119, rowsPerImage: 273}, {width: 3, height: 2, depthOrArrayLayers: 15});
} catch {}
try {
window.someLabel = sampler51.label;
} catch {}
let commandEncoder107 = device2.createCommandEncoder({label: '\u0e41\u4088\u{1f986}\u29e9'});
let texture49 = device2.createTexture({
  label: '\u0b1e\u256c\ua70c\u99e0\u022c\u2465\u{1f8f6}\ub416\u525f\u5b61\u186a',
  size: {width: 14, height: 8, depthOrArrayLayers: 202},
  mipLevelCount: 3,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let externalTexture53 = device2.importExternalTexture({label: '\ud6df\uc8a5\u0d88\u{1f60a}\u65a2\ue85d', source: videoFrame13, colorSpace: 'display-p3'});
try {
buffer25.unmap();
} catch {}
try {
commandEncoder106.copyBufferToBuffer(buffer24, 170600, buffer25, 152720, 16724);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
try {
commandEncoder106.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 1 */
  /* end: 35 */
  offset: 35,
  bytesPerRow: 0,
  rowsPerImage: 149,
  buffer: buffer24,
}, {
  texture: texture48,
  mipLevel: 0,
  origin: {x: 5, y: 0, z: 3},
  aspect: 'all',
}, {width: 0, height: 5, depthOrArrayLayers: 20});
dissociateBuffer(device2, buffer24);
} catch {}
try {
commandEncoder107.clearBuffer(buffer25);
dissociateBuffer(device2, buffer25);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(763), /* required buffer size: 763 */
{offset: 762, bytesPerRow: 274}, {width: 1, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) };
} catch {}
let textureView126 = texture39.createView({label: '\u0775\u011f\ubdb7\u0c1b', dimension: '2d', baseMipLevel: 2, baseArrayLayer: 300});
try {
renderPassEncoder21.drawIndexed(48, 22, 252_701_305, 284_655_854, 250_605_928);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer21, 759_962_783);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder65.setPipeline(pipeline58);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 96, height: 128, depthOrArrayLayers: 1264}
*/
{
  source: imageBitmap8,
  origin: { x: 126, y: 108 },
  flipY: true,
}, {
  texture: texture36,
  mipLevel: 0,
  origin: {x: 9, y: 12, z: 801},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 1, depthOrArrayLayers: 0});
} catch {}
let img23 = await imageWithData(130, 183, '#3b5c2aa5', '#97d73774');
let texture50 = device3.createTexture({
  label: '\u0a48\u6d06',
  size: [190, 320, 46],
  mipLevelCount: 9,
  dimension: '2d',
  format: 'rgba32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderBundleEncoder71 = device3.createRenderBundleEncoder({
  label: '\u4b97\u07d4\u5445\u017c\u801e\u960c\u1c19',
  colorFormats: ['r32uint', undefined, 'rg8uint', 'rg32float', 'rgba8uint', 'rg16uint'],
  depthReadOnly: true,
});
let sampler53 = device3.createSampler({
  label: '\u{1fbb4}\u0771\ucca6\u084c\u4a00\u0595\ubb8e\u5cf7',
  addressModeU: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 14.01,
  lodMaxClamp: 79.30,
});
let querySet45 = device3.createQuerySet({type: 'occlusion', count: 1004});
let texture51 = device3.createTexture({
  label: '\u7913\u95c5\u{1fbe6}\ue383\u441a\u60c2\u{1ff26}\ua285\ub785\u{1fb9a}',
  size: {width: 380, height: 640, depthOrArrayLayers: 43},
  mipLevelCount: 8,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg32float', 'rg32float'],
});
let externalTexture54 = device3.importExternalTexture({label: '\u2a92\u{1fe24}\u{1fdd5}\ub625\u{1f7b1}\u0f88', source: videoFrame20, colorSpace: 'srgb'});
try {
gpuCanvasContext10.configure({
  device: device3,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  colorSpace: 'srgb',
});
} catch {}
let bindGroup36 = device1.createBindGroup({label: '\u0e86\ua16d\u{1f9ea}\u03b8\uc5b8\uad2a\u059e', layout: bindGroupLayout30, entries: []});
let commandEncoder108 = device1.createCommandEncoder({label: '\u0a58\uac0a\u4fdc\uf81a\u0714\u4544\u{1f9c0}\u69d9\u3372\u{1f884}'});
let texture52 = device1.createTexture({
  label: '\ue18c\u017e\u815a\u{1fb33}\ua70a\u0ccd\u{1fdda}\u7d60',
  size: {width: 12, height: 16, depthOrArrayLayers: 791},
  mipLevelCount: 3,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32float'],
});
let externalTexture55 = device1.importExternalTexture({label: '\u2dd8\ucd01\ue86a\u8a86\u{1fde7}\u8177\uf7ac\ua537', source: video6, colorSpace: 'srgb'});
try {
renderPassEncoder33.setBlendConstant({ r: -520.6, g: -666.5, b: 617.0, a: 230.1, });
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline82);
} catch {}
try {
renderPassEncoder28.setVertexBuffer(0, buffer19, 0);
} catch {}
try {
commandEncoder108.copyBufferToBuffer(buffer15, 105292, buffer16, 26772, 404);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder108.copyBufferToTexture({
  /* bytesInLastRow: 24 widthInBlocks: 12 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 17054 */
  offset: 17054,
  buffer: buffer22,
}, {
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 12, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer22);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 18, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture31,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{width: 7, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
commandEncoder108.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
try {
commandEncoder108.resolveQuerySet(querySet40, 317, 300, buffer22, 89600);
} catch {}
let computePassEncoder53 = commandEncoder107.beginComputePass({label: '\ubdb7\u{1f717}\u0e32\u054f\u2d71\u{1fb50}\u24a1\u8572'});
let renderBundle74 = renderBundleEncoder69.finish();
try {
commandEncoder106.copyBufferToBuffer(buffer24, 161288, buffer25, 13064, 30140);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
try {
gpuCanvasContext3.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder109 = device2.createCommandEncoder({label: '\u30f7\uc9df'});
let querySet46 = device2.createQuerySet({label: '\u{1f756}\u0135', type: 'occlusion', count: 513});
let texture53 = device2.createTexture({
  label: '\u{1fa00}\u{1ff5e}',
  size: {width: 14, height: 8, depthOrArrayLayers: 1},
  mipLevelCount: 3,
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32sint'],
});
let textureView127 = texture48.createView({mipLevelCount: 2});
let renderBundleEncoder72 = device2.createRenderBundleEncoder({
  label: '\u5407\u987c\u98de\u951e\u823e',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle75 = renderBundleEncoder72.finish({label: '\u01b2\u{1fd39}'});
try {
computePassEncoder52.end();
} catch {}
try {
device2.pushErrorScope('internal');
} catch {}
try {
  await buffer24.mapAsync(GPUMapMode.WRITE);
} catch {}
try {
commandEncoder105.clearBuffer(buffer25);
dissociateBuffer(device2, buffer25);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 5},
  aspect: 'all',
}, new ArrayBuffer(80), /* required buffer size: 2_994 */
{offset: 703, bytesPerRow: 33, rowsPerImage: 7}, {width: 14, height: 7, depthOrArrayLayers: 10});
} catch {}
let img24 = await imageWithData(225, 157, '#8fb28dfa', '#d83b391c');
let renderBundleEncoder73 = device3.createRenderBundleEncoder({
  label: '\udecd\ub6d5',
  colorFormats: ['r32uint', undefined, 'rg8uint', 'rg32float', 'rgba8uint', 'rg16uint'],
  stencilReadOnly: true,
});
let externalTexture56 = device3.importExternalTexture({label: '\u{1f925}\u6ae7\u7f6a\uad0c\uc444\u0aa0\u35cf', source: video17, colorSpace: 'display-p3'});
let promise38 = adapter3.requestAdapterInfo();
let pipelineLayout9 = device1.createPipelineLayout({
  bindGroupLayouts: [bindGroupLayout32, bindGroupLayout28, bindGroupLayout26, bindGroupLayout31, bindGroupLayout26],
});
let commandEncoder110 = device1.createCommandEncoder();
let renderBundleEncoder74 = device1.createRenderBundleEncoder({
  label: '\ubc18\u584e\u9a25',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderPassEncoder31.beginOcclusionQuery(211);
} catch {}
try {
renderPassEncoder34.setIndexBuffer(buffer19, 'uint32', 342828, 87232);
} catch {}
try {
renderBundleEncoder42.setIndexBuffer(buffer23, 'uint32', 16008);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(5, buffer19);
} catch {}
try {
commandEncoder108.copyTextureToTexture({
  texture: texture44,
  mipLevel: 1,
  origin: {x: 1, y: 5, z: 0},
  aspect: 'all',
},
{
  texture: texture44,
  mipLevel: 0,
  origin: {x: 6, y: 7, z: 0},
  aspect: 'all',
},
{width: 24, height: 42, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: canvas15,
  origin: { x: 31, y: 0 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 1, y: 1, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 6, depthOrArrayLayers: 0});
} catch {}
let commandEncoder111 = device2.createCommandEncoder();
let renderBundle76 = renderBundleEncoder69.finish({});
let sampler54 = device2.createSampler({
  addressModeU: 'clamp-to-edge',
  addressModeV: 'repeat',
  addressModeW: 'clamp-to-edge',
  lodMinClamp: 61.05,
  lodMaxClamp: 87.06,
});
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(77_082), /* required buffer size: 77_082 */
{offset: 780, bytesPerRow: 157, rowsPerImage: 18}, {width: 10, height: 0, depthOrArrayLayers: 28});
} catch {}
let commandEncoder112 = device3.createCommandEncoder({label: '\u0f67\u6ff8\ud3c3\u{1fa6e}\u089f\u74b9\u0f86'});
let texture54 = device3.createTexture({
  label: '\u02df\u8345\u0893\u08ca',
  size: [95, 160, 46],
  sampleCount: 1,
  format: 'rg16uint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: ['rg16uint', 'rg16uint', 'rg16uint'],
});
let textureView128 = texture50.createView({
  label: '\ua8df\u3bb0\u09f6\u44b8\u{1ffe8}\u{1f930}',
  dimension: '2d',
  baseMipLevel: 4,
  mipLevelCount: 3,
  baseArrayLayer: 21,
});
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) };
} catch {}
let renderPassEncoder36 = commandEncoder108.beginRenderPass({
  label: '\u4716\u9664\u{1f6ca}\u0cb8\uc87e',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 101.0, g: 552.5, b: 922.7, a: -614.6, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 427.8, g: -531.4, b: -23.06, a: 31.51, },
  loadOp: 'load',
  storeOp: 'store',
}, {view: textureView95, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}],
  maxDrawCount: 1213944061,
});
let renderBundleEncoder75 = device1.createRenderBundleEncoder({
  label: '\uc44e\ubf02\u5d72\u{1f93e}\u{1f666}',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: false,
  stencilReadOnly: true,
});
let renderBundle77 = renderBundleEncoder45.finish({label: '\ude0e\u7908\ub29b\u065e\u4af1\u{1fa0b}\u{1fe1e}\u294f'});
try {
computePassEncoder31.setBindGroup(5, bindGroup17);
} catch {}
try {
renderPassEncoder24.setBindGroup(5, bindGroup35);
} catch {}
try {
renderPassEncoder21.setPipeline(pipeline71);
} catch {}
try {
commandEncoder110.resolveQuerySet(querySet24, 1078, 269, buffer22, 232704);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture35,
  mipLevel: 0,
  origin: {x: 4, y: 8, z: 2},
  aspect: 'all',
}, new Uint8ClampedArray(new ArrayBuffer(80)), /* required buffer size: 42_677 */
{offset: 635, bytesPerRow: 231, rowsPerImage: 1}, {width: 3, height: 0, depthOrArrayLayers: 183});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 48, height: 64, depthOrArrayLayers: 1264}
*/
{
  source: videoFrame8,
  origin: { x: 17, y: 12 },
  flipY: true,
}, {
  texture: texture36,
  mipLevel: 1,
  origin: {x: 4, y: 2, z: 67},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 13, height: 12, depthOrArrayLayers: 0});
} catch {}
let pipeline96 = device1.createComputePipeline({
  label: '\u097e\u0686\u0977\u041b\u5100\u7768\u371f\u{1f9e5}',
  layout: pipelineLayout8,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
let pipeline97 = device1.createRenderPipeline({
  label: '\u25cb\u6335\u078e\u5840\u583a\u03fc\uba1f\ucb7f',
  layout: pipelineLayout8,
  fragment: {
  module: shaderModule9,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'src'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
}, {format: 'rg32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED}, {format: 'rgba32float'}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'equal',
    stencilFront: {compare: 'greater', failOp: 'increment-clamp', passOp: 'increment-clamp'},
    stencilBack: {compare: 'not-equal', depthFailOp: 'increment-clamp'},
    stencilReadMask: 2051578362,
    stencilWriteMask: 3264339445,
    depthBiasClamp: 309.3044939015202,
  },
  vertex: {
    module: shaderModule9,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1480,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x4', offset: 36, shaderLocation: 8},
          {format: 'float32x2', offset: 332, shaderLocation: 22},
          {format: 'uint16x4', offset: 176, shaderLocation: 7},
          {format: 'uint16x2', offset: 188, shaderLocation: 20},
          {format: 'sint8x4', offset: 48, shaderLocation: 15},
          {format: 'uint16x2', offset: 588, shaderLocation: 12},
          {format: 'float32x2', offset: 280, shaderLocation: 11},
          {format: 'float16x2', offset: 84, shaderLocation: 17},
          {format: 'snorm8x2', offset: 200, shaderLocation: 13},
          {format: 'snorm16x2', offset: 456, shaderLocation: 3},
          {format: 'float16x2', offset: 144, shaderLocation: 9},
          {format: 'float32x2', offset: 88, shaderLocation: 10},
          {format: 'float32x2', offset: 460, shaderLocation: 24},
          {format: 'uint8x2', offset: 466, shaderLocation: 4},
          {format: 'unorm16x2', offset: 196, shaderLocation: 19},
          {format: 'float32x3', offset: 20, shaderLocation: 0},
          {format: 'sint32x3', offset: 248, shaderLocation: 14},
        ],
      },
      {
        arrayStride: 0,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 308, shaderLocation: 2},
          {format: 'sint32x3', offset: 4844, shaderLocation: 16},
          {format: 'sint32x2', offset: 3512, shaderLocation: 18},
        ],
      },
      {
        arrayStride: 2536,
        stepMode: 'instance',
        attributes: [{format: 'sint8x4', offset: 168, shaderLocation: 25}],
      },
      {
        arrayStride: 3760,
        attributes: [
          {format: 'sint32x4', offset: 84, shaderLocation: 26},
          {format: 'unorm8x2', offset: 632, shaderLocation: 21},
          {format: 'uint32', offset: 88, shaderLocation: 1},
          {format: 'sint32x3', offset: 276, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 232,
        stepMode: 'instance',
        attributes: [{format: 'snorm16x4', offset: 60, shaderLocation: 23}],
      },
      {arrayStride: 10068, attributes: [{format: 'uint8x2', offset: 2364, shaderLocation: 6}]},
    ],
  },
  primitive: {topology: 'triangle-strip', stripIndexFormat: 'uint16', frontFace: 'cw', unclippedDepth: true},
});
try {
if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) };
} catch {}
let commandEncoder113 = device1.createCommandEncoder({label: '\u{1fa48}\u{1fa74}\uc835\u0cc1\u3ee4\u6428'});
let textureView129 = texture27.createView({
  label: '\u{1f79e}\u0847\u05a4\u{1fc2a}\u38fb\u57a0\uee3e\u3dfb\u6f0a\u7d7c',
  baseArrayLayer: 245,
  arrayLayerCount: 117,
});
let computePassEncoder54 = commandEncoder113.beginComputePass();
let renderPassEncoder37 = commandEncoder110.beginRenderPass({
  label: '\ued42\u0257\u00eb\uc28a\u{1fa05}\u04c4\u0dc2\u07fe\u372c\ub3db\u{1f6ac}',
  colorAttachments: [{view: textureView96, loadOp: 'load', storeOp: 'store'}, {view: textureView64, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: 93.12, g: 574.3, b: -992.8, a: -336.1, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet27,
});
let sampler55 = device1.createSampler({
  label: '\u0475\u1cb6\u0255',
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 67.78,
  lodMaxClamp: 80.51,
  maxAnisotropy: 9,
});
try {
renderPassEncoder26.beginOcclusionQuery(1301);
} catch {}
try {
renderPassEncoder28.setScissorRect(2, 6, 1, 1);
} catch {}
try {
renderPassEncoder21.setStencilReference(3488);
} catch {}
try {
renderPassEncoder21.draw(264, 364, 155_921_382, 474_979_976);
} catch {}
try {
renderPassEncoder21.drawIndexed(69, 419, 286_829_865, 148_799_934, 913_050_123);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer13, 109_504_722);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline65);
} catch {}
gc();
let texture55 = device3.createTexture({
  label: '\u9581\u0123\u0b8f\ub4f1\ub3ac\u4099',
  size: [380, 640, 93],
  mipLevelCount: 3,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rg32float'],
});
let renderBundleEncoder76 = device3.createRenderBundleEncoder({
  colorFormats: ['r32uint', undefined, 'rg8uint', 'rg32float', 'rgba8uint', 'rg16uint'],
  depthReadOnly: false,
});
let sampler56 = device3.createSampler({
  label: '\u0050\u{1f777}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 27.65,
  lodMaxClamp: 73.74,
  compare: 'greater',
});
try {
device3.queue.writeTexture({
  texture: texture54,
  mipLevel: 0,
  origin: {x: 8, y: 18, z: 12},
  aspect: 'all',
}, new ArrayBuffer(519_501), /* required buffer size: 519_501 */
{offset: 688, bytesPerRow: 225, rowsPerImage: 372}, {width: 47, height: 74, depthOrArrayLayers: 7});
} catch {}
try {
device3.destroy();
} catch {}
let video18 = await videoWithData();
let commandEncoder114 = device2.createCommandEncoder({label: '\uc9b7\u3334\ua6ea\u{1fe14}\uc8d9\uc8de\udbc1\u69ff\u2c66\u305d'});
let externalTexture57 = device2.importExternalTexture({
  label: '\u{1f60a}\ub3b1\uff14\u{1fd19}\u{1f817}\u19e3\ub712\u{1f791}',
  source: videoFrame1,
  colorSpace: 'srgb',
});
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
gc();
let commandEncoder115 = device1.createCommandEncoder();
let textureView130 = texture52.createView({
  label: '\u244a\uc786\u47b3\u0a95\u36f6\uba3b\u769a\u5c8c\u0248\u4a9d',
  baseMipLevel: 1,
  mipLevelCount: 1,
  baseArrayLayer: 214,
  arrayLayerCount: 328,
});
let renderBundle78 = renderBundleEncoder75.finish({});
let externalTexture58 = device1.importExternalTexture({
  label: '\u0e11\u1bf3\uae0e\u247b\u{1ff83}\u0123\u04f2\u0b58\udc26',
  source: videoFrame16,
  colorSpace: 'display-p3',
});
try {
renderPassEncoder37.setBindGroup(6, bindGroup26);
} catch {}
try {
renderPassEncoder34.setViewport(2.126, 6.667, 2.513, 0.02763, 0.05602, 0.4460);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer21, 4_294_967_295);
} catch {}
try {
renderBundleEncoder59.setPipeline(pipeline65);
} catch {}
try {
renderBundleEncoder42.setVertexBuffer(6, buffer14);
} catch {}
let arrayBuffer15 = buffer19.getMappedRange(425496, 19092);
try {
commandEncoder115.copyTextureToBuffer({
  texture: texture52,
  mipLevel: 1,
  origin: {x: 1, y: 1, z: 94},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 51952 */
  offset: 51952,
  bytesPerRow: 0,
  rowsPerImage: 193,
  buffer: buffer14,
}, {width: 0, height: 1, depthOrArrayLayers: 84});
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 1224, new DataView(new ArrayBuffer(55642)), 1565, 3892);
} catch {}
let computePassEncoder55 = commandEncoder114.beginComputePass({label: '\u097e\uc78e\ua2a5\u08ba\u98a2'});
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 7},
  aspect: 'all',
}, new ArrayBuffer(56), /* required buffer size: 8_630 */
{offset: 340, bytesPerRow: 224, rowsPerImage: 18}, {width: 2, height: 2, depthOrArrayLayers: 3});
} catch {}
video17.width = 10;
let pipelineLayout10 = device1.createPipelineLayout({label: '\ueee8\u{1ffb4}\u06e6\u0190\u0be1\u{1fa46}', bindGroupLayouts: []});
let renderBundle79 = renderBundleEncoder53.finish({label: '\u06f7\u936a\u{1f89a}\u98bc\u1b2b\ud750\u0427'});
let externalTexture59 = device1.importExternalTexture({
  label: '\u{1fd94}\u9cf3\u7529\u8cfc\udf05\u0ecc\u{1fbc1}\u0087\u7cab\uee92',
  source: videoFrame16,
  colorSpace: 'srgb',
});
try {
computePassEncoder36.end();
} catch {}
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle72, renderBundle56, renderBundle77, renderBundle42, renderBundle42, renderBundle49]);
} catch {}
try {
renderPassEncoder32.setStencilReference(2507);
} catch {}
try {
buffer13.unmap();
} catch {}
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) };
} catch {}
gc();
let videoFrame30 = new VideoFrame(videoFrame10, {timestamp: 0});
try {
  await promise38;
} catch {}
let offscreenCanvas36 = new OffscreenCanvas(586, 134);
try {
offscreenCanvas36.getContext('webgpu');
} catch {}
let commandEncoder116 = device2.createCommandEncoder({label: '\u5aa7\u{1f874}\u7c17\u9a80\u8c41'});
let texture56 = device2.createTexture({
  label: '\uf65d\u0bc7\uf951\u0327\u{1faf5}\u867c',
  size: [56, 32, 120],
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
});
let computePassEncoder56 = commandEncoder116.beginComputePass({label: '\ua475\uccc0\u{1fe01}\ud7ad\u{1f622}\u07f4\ua5d3\u0988'});
let renderBundleEncoder77 = device2.createRenderBundleEncoder({
  label: '\u0c59\u0494\u177c\u{1fd63}\u0318',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  depthReadOnly: true,
});
let sampler57 = device2.createSampler({
  label: '\u92bf\u01fb\u063b',
  addressModeV: 'mirror-repeat',
  addressModeW: 'repeat',
  minFilter: 'nearest',
  lodMinClamp: 68.97,
  lodMaxClamp: 72.78,
});
let sampler58 = device2.createSampler({
  label: '\u01f4\u0b5b\uce9c\u9f1f',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 33.75,
  lodMaxClamp: 68.13,
});
try {
commandEncoder111.clearBuffer(buffer25);
dissociateBuffer(device2, buffer25);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let textureView131 = texture53.createView({label: '\ub5b1\uae8d\u{1f61c}', dimension: '2d', mipLevelCount: 1});
try {
renderBundleEncoder77.setVertexBuffer(5980, undefined, 925276833, 2971033732);
} catch {}
try {
device2.pushErrorScope('out-of-memory');
} catch {}
try {
commandEncoder109.copyBufferToBuffer(buffer24, 206576, buffer25, 186036, 20);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
try {
device2.queue.writeBuffer(buffer25, 45416, new BigUint64Array(45024), 30413);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 1},
  aspect: 'all',
}, new ArrayBuffer(265_380), /* required buffer size: 265_380 */
{offset: 815, bytesPerRow: 236, rowsPerImage: 224}, {width: 9, height: 2, depthOrArrayLayers: 6});
} catch {}
let textureView132 = texture42.createView({label: '\u{1fbab}\u{1f9f4}\uc721\u{1f773}\u{1ff97}\u{1f7af}'});
let renderPassEncoder38 = commandEncoder61.beginRenderPass({
  label: '\u8018\u0a0b\u{1fd89}\uc83d\u1fd6\u3306',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -509.2, g: -528.3, b: 149.4, a: -390.7, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 703.2, g: 460.1, b: -207.9, a: 0.5882, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView119,
  depthSlice: 0,
  clearValue: { r: 227.1, g: -794.1, b: 434.4, a: -401.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet39,
  maxDrawCount: 1160911270,
});
let externalTexture60 = device1.importExternalTexture({label: '\u{1f75d}\ua4ed\uf200\uda09\u59d3\u7759\ua4e4\u9f6c', source: videoFrame24});
try {
renderPassEncoder32.executeBundles([renderBundle61, renderBundle56, renderBundle54, renderBundle48, renderBundle62, renderBundle38, renderBundle43, renderBundle41, renderBundle71, renderBundle55]);
} catch {}
try {
renderPassEncoder33.setViewport(5.876, 6.269, 0.04908, 0.9040, 0.7813, 0.9569);
} catch {}
try {
renderPassEncoder21.draw(21, 151);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer19, 1_496_842_924);
} catch {}
try {
computePassEncoder40.pushDebugGroup('\u1336');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap9,
  origin: { x: 2, y: 0 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
document.body.prepend(img12);
try {
window.someLabel = renderBundle52.label;
} catch {}
let bindGroup37 = device1.createBindGroup({label: '\u026f\u4ebe\u46c8\u072a\u{1f6c5}\u8592', layout: bindGroupLayout20, entries: []});
let buffer26 = device1.createBuffer({
  label: '\u09a1\ucddc',
  size: 13464,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
  mappedAtCreation: true,
});
let texture57 = device1.createTexture({
  size: [24, 32, 1],
  mipLevelCount: 6,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: [],
});
let textureView133 = texture33.createView({label: '\u59cc\u05b3\u00c5\u{1f6f5}\u9371\udba5\u0bc4\uc871', dimension: '1d', mipLevelCount: 1});
let renderBundle80 = renderBundleEncoder61.finish();
try {
computePassEncoder43.setPipeline(pipeline60);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer16, 662_573_322);
} catch {}
try {
commandEncoder115.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 532 */
  offset: 532,
  buffer: buffer13,
}, {
  texture: texture57,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder115.resolveQuerySet(querySet26, 2473, 581, buffer23, 18688);
} catch {}
try {
computePassEncoder40.popDebugGroup();
} catch {}
let querySet47 = device1.createQuerySet({label: '\u{1fbfd}\u0b48', type: 'occlusion', count: 36});
let commandBuffer29 = commandEncoder115.finish({});
try {
renderPassEncoder24.beginOcclusionQuery(1169);
} catch {}
try {
renderPassEncoder26.setScissorRect(6, 8, 0, 0);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer19, 'uint16', 149378, 14804);
} catch {}
try {
renderBundleEncoder44.setBindGroup(5, bindGroup27);
} catch {}
try {
renderBundleEncoder64.setVertexBuffer(0, buffer14, 0);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let imageData26 = new ImageData(76, 128);
offscreenCanvas12.width = 1010;
let offscreenCanvas37 = new OffscreenCanvas(666, 927);
try {
offscreenCanvas37.getContext('webgl');
} catch {}
try {
if (!arrayBuffer9.detached) { new Uint8Array(arrayBuffer9).fill(0x55) };
} catch {}
let bindGroupLayout34 = device2.createBindGroupLayout({entries: []});
let pipelineLayout11 = device2.createPipelineLayout({bindGroupLayouts: [bindGroupLayout34]});
let externalTexture61 = device2.importExternalTexture({
  label: '\u0283\u0475\u0858\u{1f949}\u{1fc7c}\u1aa7\u1470\u228d',
  source: video2,
  colorSpace: 'display-p3',
});
try {
commandEncoder105.copyBufferToBuffer(buffer24, 110176, buffer25, 72272, 55804);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
try {
commandEncoder105.clearBuffer(buffer25, 40064);
dissociateBuffer(device2, buffer25);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer1, /* required buffer size: 188_750 */
{offset: 642, bytesPerRow: 87, rowsPerImage: 127}, {width: 14, height: 4, depthOrArrayLayers: 18});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder117 = device1.createCommandEncoder({});
let textureView134 = texture29.createView({label: '\u417f\u{1f79a}\u{1f609}\uf95a'});
let renderPassEncoder39 = commandEncoder117.beginRenderPass({
  label: '\u022a\u{1fba9}\u028b\u0b35\u0469\u{1f958}\u02d0\u7c69\u1c9a',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 854.9, g: -841.8, b: 856.9, a: 49.65, },
  loadOp: 'clear',
  storeOp: 'store',
}, {view: textureView64, depthSlice: 0, loadOp: 'load', storeOp: 'store'}, {view: textureView95, depthSlice: 0, loadOp: 'clear', storeOp: 'store'}],
  occlusionQuerySet: querySet33,
  maxDrawCount: 310639580,
});
try {
renderPassEncoder34.setBlendConstant({ r: 319.1, g: 937.6, b: 281.2, a: 431.6, });
} catch {}
try {
renderPassEncoder33.setScissorRect(1, 8, 3, 0);
} catch {}
try {
renderPassEncoder38.setViewport(5.308, 1.314, 0.5940, 4.035, 0.1150, 0.1761);
} catch {}
try {
renderPassEncoder21.drawIndexed(192);
} catch {}
try {
renderBundleEncoder59.setIndexBuffer(buffer19, 'uint32', 162380);
} catch {}
try {
renderBundleEncoder65.setVertexBuffer(6, buffer19, 0, 302297);
} catch {}
try {
device1.pushErrorScope('internal');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: videoFrame21,
  origin: { x: 7, y: 0 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
gc();
let video19 = await videoWithData();
let buffer27 = device1.createBuffer({size: 165112, usage: GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.STORAGE, mappedAtCreation: true});
let texture58 = device1.createTexture({
  label: '\u{1fc38}\u7cc2\ue90a\u{1f94f}\u7e84\u{1fd57}',
  size: {width: 48, height: 64, depthOrArrayLayers: 2},
  mipLevelCount: 4,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: [],
});
let textureView135 = texture30.createView({
  label: '\u0e1d\uc8ce\ud498\u04c6\u91c7\u6c58\u0304\u6b27',
  aspect: 'all',
  baseMipLevel: 0,
  mipLevelCount: 4,
});
try {
computePassEncoder32.setPipeline(pipeline73);
} catch {}
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.draw(82, 9, 80_281_914, 456_567_183);
} catch {}
try {
renderPassEncoder21.drawIndexed(415, 32, 481_044_041, 147_084_858, 1_099_740_506);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer23, 1_097_337_829);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer19, 319_805_571);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(6, buffer14, 2396, 3897);
} catch {}
try {
device1.queue.submit([commandBuffer24, commandBuffer19]);
} catch {}
let offscreenCanvas38 = new OffscreenCanvas(927, 423);
try {
offscreenCanvas38.getContext('2d');
} catch {}
try {
externalTexture23.label = '\u0898\uc640\ua39b\u{1f749}\u0e8d\ub71c\u{1f8c4}\ue4a5\u{1f989}';
} catch {}
offscreenCanvas23.width = 97;
let canvas24 = document.createElement('canvas');
let video20 = await videoWithData();
gc();
let videoFrame31 = new VideoFrame(offscreenCanvas31, {timestamp: 0});
let textureView136 = texture48.createView({label: '\u3f9f\u0e4c\u0ea7\u551c\u0db6\ubb2f\u07ad', baseMipLevel: 2});
try {
computePassEncoder55.end();
} catch {}
try {
device2.queue.writeBuffer(buffer25, 29268, new Float32Array(62185), 15854, 148);
} catch {}
let gpuCanvasContext36 = canvas24.getContext('webgpu');
canvas5.height = 1788;
try {
window.someLabel = commandEncoder112.label;
} catch {}
let canvas25 = document.createElement('canvas');
let videoFrame32 = new VideoFrame(canvas6, {timestamp: 0});
let texture59 = device1.createTexture({
  label: '\u0df9\ue43f\u4d6f\u0147\u0497\ud187\uf5f7\uc6dd\u{1faba}\ue163\u{1f8f1}',
  size: [48, 64, 2],
  dimension: '3d',
  format: 'rgba32uint',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
});
let textureView137 = texture45.createView({label: '\u0c84\u0005\u{1f6b0}', baseMipLevel: 1});
try {
computePassEncoder34.setBindGroup(2, bindGroup18);
} catch {}
try {
renderPassEncoder37.beginOcclusionQuery(907);
} catch {}
try {
renderPassEncoder36.setStencilReference(2642);
} catch {}
try {
renderBundleEncoder51.setBindGroup(4, bindGroup36);
} catch {}
try {
renderBundleEncoder66.setIndexBuffer(buffer23, 'uint16', 23830);
} catch {}
try {
renderBundleEncoder46.setVertexBuffer(3, buffer19, 0, 307224);
} catch {}
let arrayBuffer16 = buffer19.getMappedRange(445720, 308);
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 2, depthOrArrayLayers: 1}
*/
{
  source: imageData7,
  origin: { x: 2, y: 14 },
  flipY: false,
}, {
  texture: texture37,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline98 = device1.createComputePipeline({layout: pipelineLayout9, compute: {module: shaderModule9, entryPoint: 'compute0'}});
let gpuCanvasContext37 = canvas25.getContext('webgpu');
let sampler59 = device1.createSampler({
  label: '\ud8d7\uf655\u379f\u0af9\u{1fe87}\u0c30\u{1fc0a}\u08c5\u0f6f\ub83b',
  addressModeU: 'mirror-repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'nearest',
  lodMinClamp: 97.15,
  lodMaxClamp: 98.03,
  compare: 'always',
});
try {
renderPassEncoder21.drawIndirect(buffer15, 37_175_025);
} catch {}
try {
renderPassEncoder32.setIndexBuffer(buffer23, 'uint16', 42838, 6323);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder57.setBindGroup(7, bindGroup21);
} catch {}
try {
window.someLabel = renderBundleEncoder44.label;
} catch {}
let shaderModule14 = device1.createShaderModule({
  code: `

@compute @workgroup_size(6, 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: vec4<f32>,
  @location(2) f1: vec4<f32>,
  @location(0) f2: vec4<f32>,
  @builtin(sample_mask) f3: u32
}

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

struct S14 {
  @location(6) f0: vec4<f16>,
  @location(23) f1: vec4<i32>,
  @location(22) f2: vec3<u32>,
  @location(9) f3: i32
}
struct VertexOutput0 {
  @location(35) f120: vec2<f32>,
  @builtin(position) f121: vec4<f32>
}

@vertex
fn vertex0(@location(16) a0: vec2<u32>, @builtin(vertex_index) a1: u32, @location(2) a2: u32, @location(26) a3: vec4<i32>, @location(14) a4: vec4<f16>, @location(5) a5: vec2<u32>, @builtin(instance_index) a6: u32, @location(11) a7: vec2<f32>, @location(18) a8: vec2<f16>, @location(10) a9: vec2<i32>, @location(21) a10: vec2<f32>, @location(12) a11: u32, @location(7) a12: vec3<f16>, @location(1) a13: vec3<u32>, @location(0) a14: i32, @location(8) a15: vec4<f16>, @location(25) a16: i32, @location(4) a17: vec2<f32>, @location(13) a18: i32, @location(19) a19: vec3<i32>, @location(20) a20: u32, @location(24) a21: vec3<f16>, @location(17) a22: vec4<f32>, @location(3) a23: vec4<u32>, a24: S14, @location(15) a25: u32) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let commandEncoder118 = device1.createCommandEncoder();
let querySet48 = device1.createQuerySet({label: '\u03c8\ub516\ub9da\u39d7\u0842\u13ee\uc551\u71f8\u0c88\u0664', type: 'occlusion', count: 1892});
let textureView138 = texture41.createView({dimension: '2d', baseMipLevel: 5, baseArrayLayer: 1200});
try {
renderPassEncoder29.setBindGroup(7, bindGroup23, []);
} catch {}
try {
renderPassEncoder34.setBlendConstant({ r: -458.3, g: -607.7, b: -0.7603, a: 821.9, });
} catch {}
try {
renderPassEncoder37.setViewport(0.6988, 6.400, 0.01823, 1.072, 0.3874, 0.8414);
} catch {}
try {
renderPassEncoder31.setPipeline(pipeline82);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(7, buffer14, 9224, 43403);
} catch {}
try {
renderBundleEncoder46.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(3, buffer19, 442684, 1422);
} catch {}
try {
commandEncoder118.copyBufferToBuffer(buffer18, 19572, buffer21, 4920, 33848);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer21);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 22620, new Float32Array(60215), 5512, 8);
} catch {}
let pipeline99 = device1.createComputePipeline({
  label: '\u028e\u{1fd68}',
  layout: pipelineLayout8,
  compute: {module: shaderModule14, entryPoint: 'compute0'},
});
try {
textureView128.label = '\u0fa1\u97d2\ubc58\u04f9\u{1ff7a}\u0c42';
} catch {}
let offscreenCanvas39 = new OffscreenCanvas(866, 230);
let texture60 = device2.createTexture({
  label: '\uc56f\u{1fa3c}\u693e\ufb97',
  size: {width: 7, height: 4, depthOrArrayLayers: 15},
  dimension: '3d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32sint', 'rg32sint'],
});
let renderBundle81 = renderBundleEncoder77.finish({});
try {
commandEncoder111.copyTextureToBuffer({
  texture: texture53,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 72 widthInBlocks: 9 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 29176 */
  offset: 27568,
  bytesPerRow: 512,
  buffer: buffer25,
}, {width: 9, height: 4, depthOrArrayLayers: 1});
dissociateBuffer(device2, buffer25);
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55) };
} catch {}
let querySet49 = device1.createQuerySet({
  label: '\u8d50\u59f5\u0d37\u{1f620}\u{1fefd}\u0a45\u015a\u0d5d\uf16c\u07fb\u00e0',
  type: 'occlusion',
  count: 1723,
});
let commandBuffer30 = commandEncoder118.finish();
let textureView139 = texture59.createView({label: '\uedc9\ubec6', baseArrayLayer: 0});
let renderBundle82 = renderBundleEncoder61.finish({label: '\u{1fafa}\u5bdd\ub887\u0307\u6777'});
try {
renderPassEncoder34.setBindGroup(5, bindGroup29, new Uint32Array(972), 678, 0);
} catch {}
try {
renderPassEncoder30.setBlendConstant({ r: -228.8, g: -60.48, b: 724.9, a: -813.0, });
} catch {}
try {
renderPassEncoder21.drawIndexed(9, 49, 148_247_445, 626_647_770, 983_824_628);
} catch {}
try {
renderPassEncoder36.setPipeline(pipeline64);
} catch {}
try {
renderBundleEncoder74.setIndexBuffer(buffer23, 'uint32', 19340, 29202);
} catch {}
let videoFrame33 = new VideoFrame(img24, {timestamp: 0});
gc();
let imageBitmap25 = await createImageBitmap(imageData9);
let bindGroup38 = device1.createBindGroup({label: '\u0dbc\u{1fccf}\u75ac\u09d6\ua8ec', layout: bindGroupLayout20, entries: []});
let querySet50 = device1.createQuerySet({type: 'occlusion', count: 3595});
let renderBundleEncoder78 = device1.createRenderBundleEncoder({
  label: '\uc5eb\u3113\uadd4\u{1fe32}\u{1ffd9}\u0eee\u99e6\u42a7\u{1fd9e}\u5eb7',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  stencilReadOnly: true,
});
try {
computePassEncoder33.setBindGroup(2, bindGroup24);
} catch {}
try {
renderPassEncoder39.setBindGroup(6, bindGroup35, new Uint32Array(1846), 1569, 0);
} catch {}
try {
renderPassEncoder38.beginOcclusionQuery(3258);
} catch {}
try {
renderPassEncoder29.executeBundles([renderBundle68, renderBundle58, renderBundle43, renderBundle60, renderBundle54]);
} catch {}
try {
renderPassEncoder32.setViewport(3.853, 6.736, 1.909, 1.252, 0.6042, 0.7449);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline57);
} catch {}
let canvas26 = document.createElement('canvas');
try {
offscreenCanvas39.getContext('webgl');
} catch {}
let commandEncoder119 = device2.createCommandEncoder({label: '\u{1fb82}\u71d3\u06de\ud4ed\u0116\uaf6c\ud260\u49ff'});
let texture61 = device2.createTexture({
  label: '\u{1f9ca}\u{1fe79}\u5e7a\u0684\u2363',
  size: {width: 7, height: 4, depthOrArrayLayers: 1},
  mipLevelCount: 2,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rg32float', 'rg32float'],
});
let textureView140 = texture53.createView({label: '\u06aa\u63a6\u{1fe54}\u6f9e\u0aa9\ua098\u{1f6c7}\u037c\ueff1\u042a'});
let computePassEncoder57 = commandEncoder119.beginComputePass({label: '\u2fba\u{1f78c}\u0ea0\u0279\ucc2b\u8954\u6402\u1ee6\u385a'});
let renderBundleEncoder79 = device2.createRenderBundleEncoder({
  label: '\u4467\u{1fcb9}\ucd4b',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
});
try {
commandEncoder111.copyBufferToBuffer(buffer24, 191880, buffer25, 182080, 2252);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 1,
  origin: {x: 1, y: 0, z: 27},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer7), /* required buffer size: 430_526 */
{offset: 774, bytesPerRow: 214, rowsPerImage: 222}, {width: 10, height: 11, depthOrArrayLayers: 10});
} catch {}
canvas15.width = 2218;
let videoFrame34 = new VideoFrame(img6, {timestamp: 0});
let gpuCanvasContext38 = canvas26.getContext('webgpu');
document.body.prepend(img2);
gc();
try {
texture50.label = '\uf617\u9f7c\u2978\u06a5\u57fb\u4b07\ubc68\u0acf\u6ead';
} catch {}
let pipelineLayout12 = device2.createPipelineLayout({
  label: '\u0fc4\u{1fbc0}\u{1fa8d}\u{1f81f}\u8503\u{1fb82}\u{1ff2b}\u8442',
  bindGroupLayouts: [bindGroupLayout34, bindGroupLayout34],
});
let buffer28 = device2.createBuffer({size: 18840, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: true});
let textureView141 = texture56.createView({label: '\u0b98\u840b\u88a5', baseMipLevel: 3});
let computePassEncoder58 = commandEncoder111.beginComputePass();
let externalTexture62 = device2.importExternalTexture({
  label: '\ufb79\uf143\u1d92\u0379\u552b\u834f\ud53f\uf83d\u537e\u052b\ucd2f',
  source: video10,
  colorSpace: 'srgb',
});
let promise39 = device2.popErrorScope();
let arrayBuffer17 = buffer24.getMappedRange(0, 33836);
let promise40 = buffer25.mapAsync(GPUMapMode.READ, 0, 136728);
try {
renderPassEncoder38.endOcclusionQuery();
} catch {}
try {
renderPassEncoder26.executeBundles([renderBundle44, renderBundle57, renderBundle37]);
} catch {}
try {
renderPassEncoder33.setIndexBuffer(buffer19, 'uint32', 349948, 3231);
} catch {}
try {
renderBundleEncoder44.setPipeline(pipeline58);
} catch {}
let promise41 = device1.createComputePipelineAsync({
  label: '\u{1fac8}\udfb7\ue3ca',
  layout: pipelineLayout10,
  compute: {module: shaderModule9, entryPoint: 'compute0'},
});
let img25 = await imageWithData(200, 231, '#15e1dc86', '#c99c7852');
let commandEncoder120 = device1.createCommandEncoder({label: '\u{1fdc0}\u58cb\u{1f8a0}'});
let texture62 = device1.createTexture({
  label: '\u{1ffe2}\u0bbb\u040b\uc7d8\u3727\u0d38',
  size: [24, 32, 580],
  mipLevelCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32float', 'rgba32float'],
});
let renderPassEncoder40 = commandEncoder120.beginRenderPass({
  label: '\ua8e3\ua66f\u0bdc\u05f2\u1732',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 367.9, g: -964.4, b: -912.9, a: -625.0, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 779.7, g: 363.8, b: 941.0, a: 758.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: -244.4, g: -164.7, b: -895.1, a: -368.0, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  maxDrawCount: 1203710381,
});
let renderBundle83 = renderBundleEncoder66.finish({label: '\u0250\ud711\u0f4e\u{1f874}\u8f8b\u18cd\u0da3\ua6cf\u54a3\u37e3\u54ef'});
try {
computePassEncoder24.setBindGroup(0, bindGroup31, []);
} catch {}
try {
renderPassEncoder37.endOcclusionQuery();
} catch {}
try {
renderPassEncoder24.setViewport(3.108, 5.177, 1.853, 1.674, 0.7370, 0.9850);
} catch {}
try {
renderPassEncoder21.drawIndexed(309, 147);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer15, 213_768_413);
} catch {}
try {
renderPassEncoder39.setPipeline(pipeline58);
} catch {}
try {
renderBundleEncoder78.setPipeline(pipeline82);
} catch {}
try {
renderBundleEncoder60.setVertexBuffer(2, buffer14, 7116);
} catch {}
try {
device1.queue.submit([commandBuffer26]);
} catch {}
gc();
try {
gpuCanvasContext31.unconfigure();
} catch {}
let video21 = await videoWithData();
offscreenCanvas38.height = 656;
let offscreenCanvas40 = new OffscreenCanvas(507, 225);
offscreenCanvas16.width = 243;
gc();
let canvas27 = document.createElement('canvas');
let videoFrame35 = new VideoFrame(offscreenCanvas12, {timestamp: 0});
let textureView142 = texture58.createView({
  label: '\u0603\uc886\u{1f869}\u0fe9\u{1fc54}\uecd3\u0a7e\ue32c\u{1f871}\u{1fe59}\u306b',
  dimension: '3d',
  baseMipLevel: 1,
  mipLevelCount: 2,
  arrayLayerCount: 1,
});
let renderBundle84 = renderBundleEncoder57.finish();
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer16, 391_938_327);
} catch {}
let pipeline100 = await promise33;
let texture63 = device1.createTexture({
  size: {width: 48, height: 64, depthOrArrayLayers: 2},
  mipLevelCount: 7,
  dimension: '3d',
  format: 'rg32float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let texture64 = gpuCanvasContext0.getCurrentTexture();
let textureView143 = texture42.createView({
  label: '\u01fe\u085f\u{1f706}\ua557\u8b14\u{1f88b}\u{1fc7a}\u2f85\udc32\u06d0\u86db',
  arrayLayerCount: 1,
});
try {
renderPassEncoder31.setBindGroup(7, bindGroup26);
} catch {}
try {
renderPassEncoder24.beginOcclusionQuery(107);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer21, 238_972_774);
} catch {}
try {
renderPassEncoder37.setVertexBuffer(1, buffer19, 81608, 69353);
} catch {}
let img26 = await imageWithData(202, 63, '#503e0d4b', '#5452357b');
try {
offscreenCanvas40.getContext('webgpu');
} catch {}
let commandEncoder121 = device1.createCommandEncoder({label: '\u{1fb2e}\uf63d\u{1ff7f}\u25d6\u{1fec2}\u1f02\u2f0d\u086d\u3239'});
try {
renderPassEncoder31.beginOcclusionQuery(150);
} catch {}
try {
renderPassEncoder21.draw(522, 318);
} catch {}
try {
renderPassEncoder21.drawIndexed(192);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer16, 8_166_893);
} catch {}
try {
renderBundleEncoder50.setBindGroup(3, bindGroup19);
} catch {}
try {
renderBundleEncoder55.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder74.setVertexBuffer(7592, undefined);
} catch {}
try {
commandEncoder121.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
let pipeline101 = await device1.createComputePipelineAsync({
  label: '\u8a77\ue73d',
  layout: pipelineLayout9,
  compute: {module: shaderModule10, entryPoint: 'compute0', constants: {}},
});
let imageBitmap26 = await createImageBitmap(img3);
let commandEncoder122 = device1.createCommandEncoder({label: '\u91da\u19d6\ua3ef'});
let texture65 = device1.createTexture({
  label: '\u012e\u0e7c\u{1faac}\u6514\u049a',
  size: {width: 96, height: 128, depthOrArrayLayers: 318},
  mipLevelCount: 3,
  format: 'rg32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
try {
renderPassEncoder26.setBindGroup(2, bindGroup37);
} catch {}
try {
renderPassEncoder26.beginOcclusionQuery(950);
} catch {}
try {
renderPassEncoder30.setPipeline(pipeline64);
} catch {}
try {
renderPassEncoder38.setVertexBuffer(2, buffer14, 0, 16651);
} catch {}
try {
commandEncoder121.copyTextureToBuffer({
  texture: texture38,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 14},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 768 */
  offset: 768,
  bytesPerRow: 0,
  rowsPerImage: 296,
  buffer: buffer16,
}, {width: 0, height: 0, depthOrArrayLayers: 144});
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder122.resolveQuerySet(querySet30, 2503, 133, buffer22, 189440);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 32, new Float32Array(29665), 5541, 1332);
} catch {}
let pipeline102 = device1.createComputePipeline({
  label: '\u8647\ud12a\ub3d7\u9df1',
  layout: pipelineLayout10,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
try {
if (!arrayBuffer7.detached) { new Uint8Array(arrayBuffer7).fill(0x55) };
} catch {}
let bindGroup39 = device2.createBindGroup({label: '\u0738\u2d39\u2333\u{1fb79}\u0d94\u65b4', layout: bindGroupLayout34, entries: []});
let querySet51 = device2.createQuerySet({
  label: '\uf6bb\ud7f4\u1f42\u345c\u{1fa9a}\u{1f9d2}\ue9c9\u2292\uecb1\ue855\u96c4',
  type: 'occlusion',
  count: 2392,
});
let renderBundle85 = renderBundleEncoder69.finish({label: '\u0627\uc228\u0c2a\u07d7\u{1ff31}\ua702\u624d\u0c9d\u09cd\udfd8\u011e'});
let sampler60 = device2.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'nearest',
  mipmapFilter: 'nearest',
  lodMinClamp: 50.14,
  lodMaxClamp: 90.27,
});
try {
gpuCanvasContext7.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let buffer29 = device2.createBuffer({label: '\u0931\u{1f908}\ue167\u055a\u2690\ua758\u5853', size: 93804, usage: GPUBufferUsage.STORAGE});
let commandEncoder123 = device2.createCommandEncoder({label: '\u292e\u1ebb\u0d69\u{1fa26}\u{1ff99}\ufda1\u{1fa36}\u070d'});
let textureView144 = texture49.createView({label: '\u0699\u7270\u05f1\u353a', mipLevelCount: 2, baseArrayLayer: 47, arrayLayerCount: 23});
let sampler61 = device2.createSampler({
  label: '\u{1fdc9}\u0fea\u0591\ueb24\u034c\udf91\u022a',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 93.63,
  maxAnisotropy: 3,
});
try {
renderBundleEncoder79.setBindGroup(2, bindGroup39, []);
} catch {}
try {
renderBundleEncoder79.setVertexBuffer(6363, undefined, 2351625236);
} catch {}
try {
device2.queue.submit([]);
} catch {}
document.body.prepend(video21);
try {
device3.queue.label = '\u9932\u016f\u033c\ua031\ue57b\u005a\u0b08\uc8ef\u{1fcbf}\u9541';
} catch {}
let gpuCanvasContext39 = canvas27.getContext('webgpu');
try {
  await promise39;
} catch {}
let videoFrame36 = new VideoFrame(offscreenCanvas28, {timestamp: 0});
let computePassEncoder59 = commandEncoder109.beginComputePass({label: '\udd58\u441c\u141f\u06d1\u1a1c\u3773\u{1f9c0}\uec92\u{1fe7d}\u{1f606}'});
let imageBitmap27 = await createImageBitmap(imageData2);
let querySet52 = device1.createQuerySet({label: '\u32b5\u5afc\u9565\u{1f81b}\u{1f76f}\u284d', type: 'occlusion', count: 3941});
let textureView145 = texture32.createView({label: '\u8fac\u7c90\u0ffd\u{1f8e9}', mipLevelCount: 1});
let externalTexture63 = device1.importExternalTexture({label: '\u182f\u0f42\ua9cd\u0a5c\u8dc1\u{1fb43}', source: videoFrame25, colorSpace: 'display-p3'});
try {
computePassEncoder34.setBindGroup(7, bindGroup21, new Uint32Array(5224), 899, 0);
} catch {}
try {
renderPassEncoder29.beginOcclusionQuery(1380);
} catch {}
try {
renderPassEncoder30.executeBundles([renderBundle71, renderBundle39, renderBundle71, renderBundle52, renderBundle69, renderBundle53]);
} catch {}
try {
renderPassEncoder21.draw(13, 150, 215_895_960);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer14, 188_234_022);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(4, buffer14, 0, 33333);
} catch {}
try {
renderBundleEncoder59.setBindGroup(4, bindGroup19, new Uint32Array(6788), 14, 0);
} catch {}
try {
commandEncoder121.copyBufferToBuffer(buffer18, 48396, buffer21, 46888, 3232);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer21);
} catch {}
try {
commandEncoder122.copyBufferToTexture({
  /* bytesInLastRow: 8 widthInBlocks: 4 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 58630 */
  offset: 58630,
  buffer: buffer13,
}, {
  texture: texture57,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 4, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer13);
} catch {}
try {
commandEncoder122.clearBuffer(buffer14, 69824, 928);
dissociateBuffer(device1, buffer14);
} catch {}
try {
device1.queue.writeBuffer(buffer16, 3244, new BigUint64Array(26799), 23775, 300);
} catch {}
try {
computePassEncoder53.setBindGroup(0, bindGroup39, new Uint32Array(6654), 6101, 0);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 1},
  aspect: 'all',
}, new Uint8Array(arrayBuffer5), /* required buffer size: 139_773 */
{offset: 85, bytesPerRow: 291, rowsPerImage: 120}, {width: 2, height: 1, depthOrArrayLayers: 5});
} catch {}
let imageBitmap28 = await createImageBitmap(videoFrame31);
let pipelineLayout13 = device2.createPipelineLayout({label: '\u{1fb25}\u{1ff3c}\u448b\u5baf', bindGroupLayouts: []});
let commandEncoder124 = device2.createCommandEncoder({label: '\u15e3\u4ffb\u86f5\u0938\u231e\ua157\u{1f739}\uf4d2\u377c\ud407\u082d'});
let commandBuffer31 = commandEncoder123.finish({label: '\u{1faf0}\ue385\u0bc3\u0eec\uf15a\u6880\u03b8\u3f88'});
let renderBundleEncoder80 = device2.createRenderBundleEncoder({
  label: '\u{1f9ef}\u062e\uce9a\u8384',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  stencilReadOnly: true,
});
let sampler62 = device2.createSampler({
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 38.14,
  lodMaxClamp: 77.03,
});
try {
renderBundleEncoder80.setBindGroup(3, bindGroup39);
} catch {}
try {
gpuCanvasContext13.configure({
  device: device2,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.COPY_DST,
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer11), /* required buffer size: 56_113 */
{offset: 880, bytesPerRow: 235, rowsPerImage: 18}, {width: 2, height: 2, depthOrArrayLayers: 14});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
gc();
let bindGroup40 = device2.createBindGroup({label: '\u0e79\u{1fbd1}\u{1fc68}', layout: bindGroupLayout34, entries: []});
let buffer30 = device2.createBuffer({
  label: '\u0680\udbd2\u{1fafa}\u7899\u4fb3\u01f7\u0c6d\u{1f96e}\u89d9',
  size: 451652,
  usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
});
let textureView146 = texture53.createView({
  label: '\u{1fb63}\u034b\u{1fdb7}\u{1f937}\u90f1\ub072\u063a',
  dimension: '2d-array',
  aspect: 'all',
  baseMipLevel: 2,
});
let externalTexture64 = device2.importExternalTexture({label: '\ub021\ub5c7\uf3e9\u0c28\u0d9c\u8a7f\uc3ce\u5199', source: video6, colorSpace: 'srgb'});
try {
computePassEncoder57.setBindGroup(0, bindGroup39);
} catch {}
try {
renderBundleEncoder79.setBindGroup(3, bindGroup40);
} catch {}
try {
commandEncoder105.copyBufferToBuffer(buffer24, 17464, buffer30, 255248, 18032);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer30);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, arrayBuffer12, /* required buffer size: 20_203 */
{offset: 139, bytesPerRow: 33, rowsPerImage: 76}, {width: 13, height: 0, depthOrArrayLayers: 9});
} catch {}
try {
if (!arrayBuffer12.detached) { new Uint8Array(arrayBuffer12).fill(0x55) };
} catch {}
offscreenCanvas36.width = 499;
let pipelineLayout14 = device1.createPipelineLayout({
  bindGroupLayouts: [bindGroupLayout26, bindGroupLayout27, bindGroupLayout20, bindGroupLayout30, bindGroupLayout21, bindGroupLayout20],
});
let commandEncoder125 = device1.createCommandEncoder({label: '\u0b15\u0268\u8280\u9be1\ua608'});
let renderPassEncoder41 = commandEncoder122.beginRenderPass({
  label: '\u1dbe\ua443\u18c5\uc506\u05d9\uc8c0\u7205\u0200\u{1f9da}\u0562',
  colorAttachments: [{view: textureView96, loadOp: 'clear', storeOp: 'store'}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 249.2, g: 933.7, b: 750.4, a: 362.7, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView91,
  depthSlice: 0,
  clearValue: { r: 911.0, g: 911.3, b: 957.0, a: -562.4, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet40,
  maxDrawCount: 844155374,
});
let externalTexture65 = device1.importExternalTexture({label: '\u{1fc1c}\u07e5\u5334\u5a21\u2017', source: video7, colorSpace: 'srgb'});
try {
renderPassEncoder26.endOcclusionQuery();
} catch {}
try {
renderPassEncoder32.executeBundles([renderBundle51, renderBundle53, renderBundle39, renderBundle45]);
} catch {}
try {
renderPassEncoder28.setScissorRect(5, 1, 1, 7);
} catch {}
try {
renderPassEncoder32.setViewport(3.598, 3.349, 1.052, 0.2666, 0.1758, 0.6938);
} catch {}
try {
renderPassEncoder21.drawIndexed(21, 154, 1_579_408_679, 384_701_973, 171_027_241);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer18, 269_885_004);
} catch {}
try {
commandEncoder121.resolveQuerySet(querySet27, 1233, 1339, buffer22, 112128);
} catch {}
try {
renderBundleEncoder68.pushDebugGroup('\u{1f954}');
} catch {}
try {
gpuCanvasContext30.configure({
  device: device1,
  format: 'rgba8unorm',
  usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['rgba8unorm-srgb', 'rgba8unorm', 'rgba8unorm-srgb'],
  colorSpace: 'display-p3',
  alphaMode: 'premultiplied',
});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap7,
  origin: { x: 43, y: 702 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroup41 = device2.createBindGroup({
  label: '\ubc4b\u{1f767}\u6e98\u14e7\u0752\ue9f9\u{1f7c3}\u{1ff10}\udb59',
  layout: bindGroupLayout34,
  entries: [],
});
let commandEncoder126 = device2.createCommandEncoder();
let commandBuffer32 = commandEncoder126.finish({});
let renderBundle86 = renderBundleEncoder77.finish({label: '\ue4c0\u79dc\u5768\ue2cf\u4342\u0124\u{1f644}\u{1ffe0}\u{1fd78}\u6d44\u0284'});
try {
renderBundleEncoder79.setVertexBuffer(7919, undefined);
} catch {}
let videoFrame37 = new VideoFrame(img13, {timestamp: 0});
try {
adapter2.label = '\u90cc\u8907\u07c8\ue6be\u07cf\u0359\u{1fb71}\ub279';
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
let video22 = await videoWithData();
let textureView147 = texture65.createView({label: '\u{1f7cb}\u0bbd\u66f2', mipLevelCount: 1, baseArrayLayer: 175, arrayLayerCount: 118});
let sampler63 = device1.createSampler({
  label: '\ub2fe\u{1fc28}\ub81e\u1410\u0ddc\uea03\u0362\uc5ac\u03f6',
  addressModeU: 'mirror-repeat',
  addressModeV: 'repeat',
  addressModeW: 'mirror-repeat',
  magFilter: 'nearest',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMaxClamp: 81.39,
});
try {
computePassEncoder51.setBindGroup(6, bindGroup26, new Uint32Array(6622), 2834, 0);
} catch {}
try {
renderPassEncoder31.endOcclusionQuery();
} catch {}
try {
renderPassEncoder22.setScissorRect(1, 3, 3, 0);
} catch {}
try {
renderPassEncoder21.drawIndexed(27, 67);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer26, 63_289_496);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer23, 87_838_050);
} catch {}
try {
renderPassEncoder21.setIndexBuffer(buffer23, 'uint32', 32976, 16926);
} catch {}
try {
renderBundleEncoder74.setBindGroup(2, bindGroup20);
} catch {}
try {
renderBundleEncoder51.setBindGroup(4, bindGroup17, new Uint32Array(768), 218, 0);
} catch {}
try {
renderBundleEncoder64.setIndexBuffer(buffer23, 'uint32');
} catch {}
try {
renderBundleEncoder74.setPipeline(pipeline71);
} catch {}
try {
renderBundleEncoder51.setVertexBuffer(1, buffer14, 0, 3048);
} catch {}
try {
buffer18.destroy();
} catch {}
try {
buffer14.unmap();
} catch {}
try {
commandEncoder121.copyTextureToBuffer({
  texture: texture57,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 2356 */
  offset: 2356,
  rowsPerImage: 223,
  buffer: buffer16,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
dissociateBuffer(device1, buffer16);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 28256, new Int16Array(22745), 2834, 632);
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 48, height: 64, depthOrArrayLayers: 1264}
*/
{
  source: offscreenCanvas12,
  origin: { x: 24, y: 5 },
  flipY: true,
}, {
  texture: texture36,
  mipLevel: 1,
  origin: {x: 3, y: 4, z: 172},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 10, height: 30, depthOrArrayLayers: 0});
} catch {}
let pipeline103 = device1.createComputePipeline({
  label: '\u4143\u{1fcfa}\uf093\ue8d1',
  layout: pipelineLayout14,
  compute: {module: shaderModule9, entryPoint: 'compute0', constants: {}},
});
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55) };
} catch {}
let imageBitmap29 = await createImageBitmap(videoFrame18);
let renderPassEncoder42 = commandEncoder121.beginRenderPass({
  label: '\u{1f686}\u{1fd96}\u060a\u0595\u32ab\u7d64\u{1fe75}\uf7d5\u1260\ua102\u{1fe74}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 226.5, g: -174.1, b: -967.6, a: -656.7, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 746.4, g: 546.9, b: 732.1, a: 841.9, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: -348.2, g: -610.2, b: 634.5, a: 882.3, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet50,
  maxDrawCount: 1086054530,
});
let sampler64 = device1.createSampler({
  label: '\u0b01\u{1f895}\u{1fbfe}',
  addressModeU: 'repeat',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  mipmapFilter: 'nearest',
  lodMinClamp: 79.25,
  lodMaxClamp: 79.55,
});
try {
computePassEncoder32.setPipeline(pipeline98);
} catch {}
try {
renderPassEncoder34.setBindGroup(1, bindGroup36, []);
} catch {}
try {
renderPassEncoder21.draw(178, 29, 570_421_423, 55_539_974);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer23, 304_417_802);
} catch {}
try {
renderBundleEncoder59.setBindGroup(5, bindGroup35, new Uint32Array(4835), 4148, 0);
} catch {}
try {
commandEncoder125.copyBufferToBuffer(buffer22, 65240, buffer26, 6536, 4400);
dissociateBuffer(device1, buffer22);
dissociateBuffer(device1, buffer26);
} catch {}
try {
renderPassEncoder41.pushDebugGroup('\u037e');
} catch {}
let pipeline104 = await device1.createComputePipelineAsync({
  label: '\u{1fbb7}\u7ed6\u28e0\u0b8c\u0669\u6e2a\u0f2e\ud94f\u0412\u160f',
  layout: pipelineLayout10,
  compute: {module: shaderModule14, entryPoint: 'compute0', constants: {}},
});
try {
adapter2.label = '\u089c\ub36b\u0b5c\udb18\u04e9';
} catch {}
offscreenCanvas0.width = 2859;
let commandEncoder127 = device2.createCommandEncoder({label: '\u0dcd\u0b01\u0422\u0215\u{1fa23}'});
let renderBundleEncoder81 = device2.createRenderBundleEncoder({
  label: '\u{1fb3d}\u684f\u0d9c\u{1ff34}\u9f7a\u{1f89f}\uc536\u{1fe64}\u8ec5\uc5c3',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
renderBundleEncoder81.setBindGroup(3, bindGroup41, new Uint32Array(883), 56, 0);
} catch {}
try {
commandEncoder106.copyBufferToBuffer(buffer24, 182272, buffer28, 6184, 7740);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer28);
} catch {}
let commandEncoder128 = device1.createCommandEncoder();
let textureView148 = texture43.createView({
  label: '\u009b\uc187\u33c9\u0bdd\u07fe\u7ba1\u9174\u{1faa7}',
  aspect: 'all',
  baseMipLevel: 1,
  mipLevelCount: 3,
  baseArrayLayer: 70,
  arrayLayerCount: 88,
});
let renderPassEncoder43 = commandEncoder125.beginRenderPass({
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -72.17, g: 394.1, b: -537.6, a: 220.3, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 153.7, g: 501.1, b: -681.6, a: -18.29, },
  loadOp: 'clear',
  storeOp: 'discard',
}, {
  view: textureView119,
  depthSlice: 0,
  clearValue: { r: -708.5, g: -112.9, b: -582.2, a: -794.0, },
  loadOp: 'load',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet25,
});
try {
renderPassEncoder21.beginOcclusionQuery(2712);
} catch {}
try {
renderPassEncoder22.setViewport(1.192, 4.446, 2.188, 3.364, 0.7867, 0.8506);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer26, 1_240_971_253);
} catch {}
try {
renderBundleEncoder67.setIndexBuffer(buffer23, 'uint32', 51056, 1508);
} catch {}
try {
renderBundleEncoder74.setVertexBuffer(3945, undefined, 0, 1290939323);
} catch {}
try {
renderPassEncoder41.popDebugGroup();
} catch {}
try {
gpuCanvasContext17.unconfigure();
} catch {}
let imageBitmap30 = await createImageBitmap(imageData16);
let imageData27 = new ImageData(132, 200);
let imageData28 = new ImageData(92, 140);
let commandEncoder129 = device2.createCommandEncoder({label: '\u0ebe\uf39b\u0aaa\u68a1\u3f96\u0735\u{1f804}\u{1f9fa}'});
let querySet53 = device2.createQuerySet({type: 'occlusion', count: 1625});
let texture66 = device2.createTexture({
  label: '\u8635\u0d24\u01ae\uca9d\u0772',
  size: [28],
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_SRC,
});
try {
renderBundleEncoder79.setBindGroup(1, bindGroup39);
} catch {}
let offscreenCanvas41 = new OffscreenCanvas(568, 928);
try {
offscreenCanvas41.getContext('webgl');
} catch {}
let commandEncoder130 = device1.createCommandEncoder({label: '\u{1f754}\u1757\u{1fe2f}\u0df0\u6fe9'});
let querySet54 = device1.createQuerySet({label: '\uf8ce\u{1f6b3}\u367e\u{1fb6a}\u0bde\u7a71', type: 'occlusion', count: 101});
let textureView149 = texture59.createView({label: '\u87b3\u0f20\u4161\u0b77\u{1f7d7}\u6fe2\uf731', arrayLayerCount: 1});
let renderPassEncoder44 = commandEncoder128.beginRenderPass({
  label: '\u09b2\uf0b9\u04ce\u0200\u57ac\u8baf',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: -51.73, g: -551.2, b: 201.5, a: 906.1, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 672.4, g: 358.4, b: 460.8, a: 570.1, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView95,
  depthSlice: 0,
  clearValue: { r: -818.2, g: 15.99, b: 652.6, a: 326.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet39,
});
try {
renderPassEncoder43.setBindGroup(4, bindGroup23);
} catch {}
try {
renderPassEncoder36.setPipeline(pipeline65);
} catch {}
try {
renderBundleEncoder55.setBindGroup(4, bindGroup32);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer22, 41840, buffer26, 5120, 2072);
dissociateBuffer(device1, buffer22);
dissociateBuffer(device1, buffer26);
} catch {}
try {
commandEncoder130.copyTextureToBuffer({
  texture: texture64,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 4364 */
  offset: 4360,
  buffer: buffer14,
}, {width: 1, height: 1, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer14);
} catch {}
try {
renderBundleEncoder65.insertDebugMarker('\u{1f96d}');
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: canvas18,
  origin: { x: 149, y: 44 },
  flipY: false,
}, {
  texture: texture23,
  mipLevel: 2,
  origin: {x: 1, y: 6, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline105 = await promise41;
try {
  await promise40;
} catch {}
let video23 = await videoWithData();
let imageBitmap31 = await createImageBitmap(imageData16);
try {
window.someLabel = texture53.label;
} catch {}
let bindGroup42 = device2.createBindGroup({label: '\ua4b3\u022e\u3529\u0cd4\u89a0\u9895\u0961\uf12c', layout: bindGroupLayout34, entries: []});
let commandEncoder131 = device2.createCommandEncoder();
let computePassEncoder60 = commandEncoder106.beginComputePass();
try {
renderBundleEncoder81.setBindGroup(3, bindGroup39);
} catch {}
try {
commandEncoder105.copyTextureToBuffer({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 160 widthInBlocks: 20 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 32624 */
  offset: 32624,
  buffer: buffer30,
}, {width: 20, height: 1, depthOrArrayLayers: 0});
dissociateBuffer(device2, buffer30);
} catch {}
try {
commandEncoder131.clearBuffer(buffer25, 3292);
dissociateBuffer(device2, buffer25);
} catch {}
let commandEncoder132 = device1.createCommandEncoder({label: '\u8c62\u00ba\u627c\u09fe\u0504\ub6f6\uf553\u4fc7\ub8ff\u080e'});
let querySet55 = device1.createQuerySet({type: 'occlusion', count: 2406});
let texture67 = device1.createTexture({
  label: '\u{1fb3a}\u{1fca6}\u{1fa08}\u6238\u0ca9\u{1fece}',
  size: [96, 128, 1],
  mipLevelCount: 5,
  sampleCount: 1,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
  viewFormats: [],
});
let renderPassEncoder45 = commandEncoder132.beginRenderPass({
  label: '\u0431\u0bb5\uf878\udb4d\u8b9e\u{1fa88}\u{1f987}\u7fa1',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 299.1, g: 918.9, b: 647.4, a: -295.3, },
  loadOp: 'clear',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: -809.6, g: 634.6, b: -788.1, a: 453.7, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView119,
  depthSlice: 0,
  clearValue: { r: -941.5, g: -460.4, b: 36.88, a: -424.0, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 247543170,
});
try {
renderPassEncoder45.setBindGroup(6, bindGroup34, new Uint32Array(3130), 2486, 0);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline58);
} catch {}
try {
commandEncoder130.clearBuffer(buffer17);
dissociateBuffer(device1, buffer17);
} catch {}
let promise42 = device1.queue.onSubmittedWorkDone();
let pipeline106 = await device1.createRenderPipelineAsync({
  label: '\u766c\u836d',
  layout: pipelineLayout8,
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'max', srcFactor: 'one', dstFactor: 'one'},
    alpha: {operation: 'reverse-subtract', srcFactor: 'one', dstFactor: 'src'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.RED,
}, {format: 'rg32float'}, {format: 'rgba32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}],
},
  depthStencil: {
    format: 'depth32float-stencil8',
    depthWriteEnabled: false,
    depthCompare: 'always',
    stencilFront: {compare: 'equal', failOp: 'increment-clamp', depthFailOp: 'zero'},
    stencilBack: {compare: 'less', failOp: 'decrement-clamp', depthFailOp: 'zero', passOp: 'replace'},
    stencilWriteMask: 3297471864,
    depthBias: -2004466368,
    depthBiasSlopeScale: 508.36188087668916,
  },
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1068,
        attributes: [
          {format: 'sint32', offset: 8, shaderLocation: 22},
          {format: 'uint16x4', offset: 0, shaderLocation: 26},
          {format: 'sint8x4', offset: 232, shaderLocation: 23},
          {format: 'unorm16x2', offset: 60, shaderLocation: 1},
          {format: 'sint32x3', offset: 44, shaderLocation: 17},
          {format: 'uint32x3', offset: 112, shaderLocation: 8},
          {format: 'uint16x2', offset: 36, shaderLocation: 19},
          {format: 'snorm16x2', offset: 368, shaderLocation: 15},
          {format: 'unorm8x4', offset: 192, shaderLocation: 20},
          {format: 'snorm16x4', offset: 328, shaderLocation: 9},
          {format: 'float16x4', offset: 16, shaderLocation: 5},
          {format: 'uint32x2', offset: 16, shaderLocation: 12},
          {format: 'unorm10-10-10-2', offset: 380, shaderLocation: 0},
          {format: 'float32', offset: 256, shaderLocation: 7},
          {format: 'uint32', offset: 204, shaderLocation: 18},
          {format: 'float16x2', offset: 36, shaderLocation: 13},
          {format: 'sint8x2', offset: 258, shaderLocation: 10},
          {format: 'sint32x3', offset: 60, shaderLocation: 2},
          {format: 'sint32x2', offset: 36, shaderLocation: 3},
          {format: 'unorm16x2', offset: 232, shaderLocation: 21},
          {format: 'unorm16x2', offset: 304, shaderLocation: 24},
          {format: 'snorm8x4', offset: 4, shaderLocation: 6},
          {format: 'sint16x2', offset: 360, shaderLocation: 4},
          {format: 'float32x2', offset: 880, shaderLocation: 25},
        ],
      },
      {
        arrayStride: 192,
        stepMode: 'instance',
        attributes: [{format: 'sint16x4', offset: 32, shaderLocation: 14}],
      },
      {
        arrayStride: 1236,
        stepMode: 'instance',
        attributes: [{format: 'uint16x4', offset: 520, shaderLocation: 11}],
      },
      {arrayStride: 1292, attributes: [{format: 'uint8x2', offset: 2, shaderLocation: 16}]},
    ],
  },
  primitive: {topology: 'point-list', frontFace: 'ccw', cullMode: 'back'},
});
let canvas28 = document.createElement('canvas');
try {
gpuCanvasContext33.unconfigure();
} catch {}
offscreenCanvas27.height = 1901;
let querySet56 = device2.createQuerySet({label: '\u045d\u0efd\u3f7d\uedcc\u084a\u8710\u6274\u{1f720}\u98af', type: 'occlusion', count: 736});
let computePassEncoder61 = commandEncoder124.beginComputePass();
let renderBundleEncoder82 = device2.createRenderBundleEncoder({
  label: '\u5a7b\u903e\ua8a1\u5b03\u{1f85d}\u1460\u034f\ubfc4\u0518\u062a\u2334',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  sampleCount: 1,
  depthReadOnly: true,
});
let renderBundle87 = renderBundleEncoder77.finish({label: '\ua53e\u{1fb9b}\u7db2\ucd60\u{1fa6f}'});
let externalTexture66 = device2.importExternalTexture({
  label: '\u0aba\u0f60\u8368\u{1f75d}\u4e60\u9ef7\u0b89\u8748',
  source: video19,
  colorSpace: 'display-p3',
});
try {
renderBundleEncoder81.setBindGroup(0, bindGroup41);
} catch {}
let arrayBuffer18 = buffer24.getMappedRange(33840, 54812);
let canvas29 = document.createElement('canvas');
try {
canvas28.getContext('webgl2');
} catch {}
let commandEncoder133 = device3.createCommandEncoder({label: '\u1f82\u845e\ued65\u{1fd6a}\uf4e7\u3335\u75f3\u{1fba4}'});
let querySet57 = device3.createQuerySet({label: '\u05f9\u{1f738}\u18ee\u854b\u143e\u{1fea9}\u032f\u{1f7b9}', type: 'occlusion', count: 4090});
let externalTexture67 = device3.importExternalTexture({label: '\u{1fe60}\ude32\u4647\ue357\u6570\u06f8\u098c', source: videoFrame18, colorSpace: 'srgb'});
try {
renderBundleEncoder71.setVertexBuffer(8345, undefined, 2469935848, 1211343566);
} catch {}
try {
commandEncoder112.copyTextureToTexture({
  texture: texture51,
  mipLevel: 2,
  origin: {x: 11, y: 8, z: 0},
  aspect: 'all',
},
{
  texture: texture55,
  mipLevel: 0,
  origin: {x: 19, y: 11, z: 17},
  aspect: 'all',
},
{width: 29, height: 81, depthOrArrayLayers: 3});
} catch {}
let img27 = await imageWithData(295, 227, '#6570847d', '#1f5f5ee7');
let videoFrame38 = new VideoFrame(video15, {timestamp: 0});
let commandEncoder134 = device2.createCommandEncoder({label: '\u5e01\u{1fc27}\ucdf9'});
try {
renderBundleEncoder82.setVertexBuffer(6091, undefined);
} catch {}
try {
commandEncoder127.clearBuffer(buffer28);
dissociateBuffer(device2, buffer28);
} catch {}
try {
device2.queue.writeBuffer(buffer30, 141388, new Int16Array(39870), 25782);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 8},
  aspect: 'all',
}, new ArrayBuffer(16), /* required buffer size: 4_612_967 */
{offset: 270, bytesPerRow: 299, rowsPerImage: 302}, {width: 6, height: 26, depthOrArrayLayers: 52});
} catch {}
let gpuCanvasContext40 = canvas29.getContext('webgpu');
let imageData29 = new ImageData(68, 132);
let buffer31 = device1.createBuffer({
  label: '\u{1fc01}\u13c7\u{1fd7b}\u66bb\ufaaa\u35a2\u5637\u957c',
  size: 63069,
  usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
});
let texture68 = device1.createTexture({
  label: '\u0c1f\u4909\u{1f614}\u5eac\u{1fd61}\u0528\u7acd\u{1fda6}\ub2f1\u7bfe\uca7f',
  size: [12, 16, 1],
  mipLevelCount: 2,
  dimension: '2d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
  viewFormats: [],
});
let sampler65 = device1.createSampler({
  label: '\u3f80\u544e\u0b7b\u92f8',
  addressModeU: 'clamp-to-edge',
  addressModeW: 'repeat',
  magFilter: 'nearest',
  lodMinClamp: 23.29,
  compare: 'never',
});
try {
renderPassEncoder24.endOcclusionQuery();
} catch {}
try {
renderPassEncoder41.setStencilReference(3579);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer19, 225_732_145);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer13, 739_343_478);
} catch {}
try {
renderPassEncoder43.setVertexBuffer(4, buffer19, 0, 37787);
} catch {}
try {
renderBundleEncoder68.setVertexBuffer(412, undefined, 0, 1956845772);
} catch {}
try {
commandEncoder130.copyTextureToTexture({
  texture: texture62,
  mipLevel: 0,
  origin: {x: 1, y: 0, z: 59},
  aspect: 'all',
},
{
  texture: texture24,
  mipLevel: 0,
  origin: {x: 0, y: 39, z: 0},
  aspect: 'all',
},
{width: 1, height: 2, depthOrArrayLayers: 2});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 6, height: 8, depthOrArrayLayers: 1}
*/
{
  source: imageData14,
  origin: { x: 7, y: 26 },
  flipY: false,
}, {
  texture: texture37,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer11.detached) { new Uint8Array(arrayBuffer11).fill(0x55) };
} catch {}
let videoFrame39 = new VideoFrame(offscreenCanvas35, {timestamp: 0});
let pipelineLayout15 = device2.createPipelineLayout({label: '\ue825\u00ac', bindGroupLayouts: []});
let commandEncoder135 = device2.createCommandEncoder({label: '\u{1fbcb}\u0222\u{1fac3}\u5269\u{1f86d}\u2cbf'});
let texture69 = device2.createTexture({
  label: '\u0222\u0a57\u{1f66b}\u0601\u0aa6\u048b',
  size: {width: 7, height: 4, depthOrArrayLayers: 202},
  format: 'r32float',
  usage: GPUTextureUsage.STORAGE_BINDING,
  viewFormats: ['r32float'],
});
let textureView150 = texture60.createView({baseMipLevel: 0});
let renderBundleEncoder83 = device2.createRenderBundleEncoder({
  label: '\u2e3b\ua63a\u8b59',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
});
try {
commandEncoder127.copyBufferToBuffer(buffer24, 142680, buffer25, 101436, 12828);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer25);
} catch {}
let shaderModule15 = device1.createShaderModule({
  label: '\u6580\u8db3\u573d\u{1fde1}\u0638\u9d88',
  code: `@group(1) @binding(154)
var<storage, read_write> global5: array<u32>;
@group(4) @binding(4560)
var<storage, read_write> local6: array<u32>;

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

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

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

struct S15 {
  @location(22) f0: vec3<f16>,
  @location(7) f1: vec3<f32>,
  @location(13) f2: vec4<u32>,
  @location(2) f3: vec4<f16>,
  @location(1) f4: u32
}

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

`,
  sourceMap: {},
  hints: {},
});
let buffer32 = device1.createBuffer({
  label: '\u7b96\u4b19\u{1ffdb}\u0d7d\u3d3e\u709e',
  size: 23774,
  usage: GPUBufferUsage.INDEX | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.VERTEX,
});
let textureView151 = texture62.createView({
  label: '\u09ed\u655c\u{1f99b}\u0cbe\u8a58',
  format: 'rgba32float',
  baseArrayLayer: 75,
  arrayLayerCount: 75,
});
let renderBundle88 = renderBundleEncoder34.finish();
try {
computePassEncoder50.setBindGroup(0, bindGroup28);
} catch {}
try {
renderPassEncoder26.setBindGroup(4, bindGroup37);
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle72, renderBundle84, renderBundle51]);
} catch {}
try {
renderPassEncoder40.setBlendConstant({ r: 338.0, g: -773.2, b: 705.2, a: 787.8, });
} catch {}
try {
renderPassEncoder40.setStencilReference(37);
} catch {}
try {
renderPassEncoder41.setIndexBuffer(buffer19, 'uint32', 74376);
} catch {}
try {
renderPassEncoder29.setPipeline(pipeline64);
} catch {}
try {
renderPassEncoder32.setVertexBuffer(3, buffer19);
} catch {}
try {
renderBundleEncoder78.setIndexBuffer(buffer19, 'uint32', 335848, 36421);
} catch {}
try {
renderBundleEncoder50.setVertexBuffer(5, buffer19);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer18, 23420, buffer21, 65576, 1304);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer21);
} catch {}
try {
commandEncoder130.copyBufferToTexture({
  /* bytesInLastRow: 176 widthInBlocks: 11 aspectSpecificFormat.texelBlockSize: 16 */
  /* end: 3184 */
  offset: 1216,
  bytesPerRow: 256,
  buffer: buffer31,
}, {
  texture: texture40,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
}, {width: 11, height: 8, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer31);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture57,
  mipLevel: 4,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new Float32Array(arrayBuffer2), /* required buffer size: 556 */
{offset: 556}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let pipeline107 = device1.createRenderPipeline({
  label: '\u5586\u{1f7cf}\u3f10\u0ed2\u{1f677}\u88d3\ue668\u7d83\u{1ff47}\ubefd\u92b7',
  layout: pipelineLayout9,
  fragment: {
  module: shaderModule11,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{format: 'r16float'}, {format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED}, {format: 'rgba32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'depth24plus-stencil8',
    depthWriteEnabled: true,
    depthCompare: 'greater',
    stencilFront: {compare: 'less', depthFailOp: 'decrement-clamp', passOp: 'zero'},
    stencilBack: {
      compare: 'less-equal',
      failOp: 'increment-wrap',
      depthFailOp: 'increment-clamp',
      passOp: 'decrement-wrap',
    },
    depthBias: -733819323,
    depthBiasClamp: 194.9373030329462,
  },
  vertex: {
    module: shaderModule11,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 1412,
        stepMode: 'vertex',
        attributes: [
          {format: 'unorm8x4', offset: 260, shaderLocation: 21},
          {format: 'sint32', offset: 388, shaderLocation: 22},
        ],
      },
      {
        arrayStride: 264,
        stepMode: 'instance',
        attributes: [
          {format: 'uint16x2', offset: 0, shaderLocation: 15},
          {format: 'snorm8x2', offset: 0, shaderLocation: 26},
          {format: 'float32x3', offset: 12, shaderLocation: 18},
          {format: 'unorm10-10-10-2', offset: 36, shaderLocation: 9},
          {format: 'sint32x3', offset: 0, shaderLocation: 12},
          {format: 'uint16x4', offset: 4, shaderLocation: 13},
          {format: 'float32x2', offset: 48, shaderLocation: 20},
          {format: 'sint8x2', offset: 18, shaderLocation: 8},
          {format: 'uint8x2', offset: 10, shaderLocation: 2},
          {format: 'snorm16x2', offset: 0, shaderLocation: 14},
          {format: 'sint32x3', offset: 68, shaderLocation: 19},
          {format: 'uint32x3', offset: 0, shaderLocation: 11},
          {format: 'snorm16x2', offset: 12, shaderLocation: 7},
          {format: 'sint32x3', offset: 16, shaderLocation: 23},
          {format: 'snorm8x4', offset: 60, shaderLocation: 4},
          {format: 'float32', offset: 8, shaderLocation: 0},
          {format: 'sint8x2', offset: 32, shaderLocation: 25},
          {format: 'float32x3', offset: 4, shaderLocation: 6},
          {format: 'uint32x3', offset: 0, shaderLocation: 16},
          {format: 'unorm8x4', offset: 140, shaderLocation: 1},
          {format: 'uint16x4', offset: 36, shaderLocation: 3},
          {format: 'unorm16x2', offset: 24, shaderLocation: 5},
        ],
      },
    ],
  },
  primitive: {topology: 'triangle-list', frontFace: 'ccw', cullMode: 'back', unclippedDepth: true},
});
try {
  await promise42;
} catch {}
gc();
let img28 = await imageWithData(92, 169, '#69618e3b', '#6b7762c3');
try {
if (!arrayBuffer8.detached) { new Uint8Array(arrayBuffer8).fill(0x55) };
} catch {}
let offscreenCanvas42 = new OffscreenCanvas(438, 263);
let bindGroup43 = device1.createBindGroup({layout: bindGroupLayout20, entries: []});
let pipelineLayout16 = device1.createPipelineLayout({bindGroupLayouts: [bindGroupLayout21, bindGroupLayout27]});
let commandEncoder136 = device1.createCommandEncoder({label: '\u07c2\u6c4b\u{1fa32}\u0aca\uf4a3'});
let texture70 = device1.createTexture({
  label: '\u5447\u033c',
  size: {width: 12, height: 16, depthOrArrayLayers: 1},
  mipLevelCount: 5,
  dimension: '3d',
  format: 'r16float',
  usage: GPUTextureUsage.RENDER_ATTACHMENT,
});
let textureView152 = texture37.createView({label: '\u0698\u04d4\u{1ff4d}\ud69c'});
let computePassEncoder62 = commandEncoder136.beginComputePass({label: '\ued26\udb7f\u{1f67e}\uc1a1\u76b5\u4ebd'});
let externalTexture68 = device1.importExternalTexture({label: '\u06e2\u2a68\u0b16\u016a\u{1f6a9}\u945c', source: videoFrame15});
try {
computePassEncoder33.setPipeline(pipeline96);
} catch {}
try {
renderPassEncoder37.beginOcclusionQuery(2291);
} catch {}
try {
renderPassEncoder37.endOcclusionQuery();
} catch {}
try {
renderPassEncoder45.executeBundles([]);
} catch {}
try {
renderPassEncoder43.setViewport(1.630, 0.5643, 1.614, 5.990, 0.3343, 0.8063);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer31, 54_688_258);
} catch {}
try {
renderPassEncoder42.setVertexBuffer(7, buffer14, 54560, 4044);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 1, height: 2, depthOrArrayLayers: 1}
*/
{
  source: canvas6,
  origin: { x: 86, y: 2 },
  flipY: false,
}, {
  texture: texture37,
  mipLevel: 3,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: true,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let canvas30 = document.createElement('canvas');
let pipelineLayout17 = device1.createPipelineLayout({
  label: '\udca0\ua2f2\u{1ffd8}\u{1f771}',
  bindGroupLayouts: [bindGroupLayout31, bindGroupLayout26, bindGroupLayout30, bindGroupLayout30, bindGroupLayout33],
});
let commandEncoder137 = device1.createCommandEncoder({label: '\u351b\u0d0a\u9e23\u0ba4\u0c5c'});
let querySet58 = device1.createQuerySet({label: '\u9887\u0169\u023d\ubf9d\ub99b\u{1f938}\ub8c8', type: 'occlusion', count: 1406});
try {
renderPassEncoder45.setBlendConstant({ r: -959.4, g: -719.9, b: 581.2, a: -478.7, });
} catch {}
try {
renderPassEncoder21.draw(4, 9, 2_790_229_265, 156_563_319);
} catch {}
try {
renderPassEncoder21.drawIndexed(11, 200, 106_412_314, 396_001_538);
} catch {}
try {
renderBundleEncoder74.setIndexBuffer(buffer19, 'uint16');
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer18, 15008, buffer21, 48744, 1052);
dissociateBuffer(device1, buffer18);
dissociateBuffer(device1, buffer21);
} catch {}
try {
commandEncoder130.copyTextureToBuffer({
  texture: texture45,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 20 widthInBlocks: 10 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 8304 */
  offset: 4956,
  bytesPerRow: 256,
  buffer: buffer16,
}, {width: 10, height: 14, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer16);
} catch {}
try {
gpuCanvasContext40.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['bgra8unorm'],
  colorSpace: 'srgb',
  alphaMode: 'opaque',
});
} catch {}
let pipeline108 = await device1.createRenderPipelineAsync({
  label: '\u182a\u{1fc91}\u0447\ua56d\u{1fd8b}',
  layout: 'auto',
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  constants: {},
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-constant', dstFactor: 'zero'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}, {format: 'rg32float'}, {format: 'rgba32float'}],
},
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 3652,
        stepMode: 'vertex',
        attributes: [
          {format: 'float16x4', offset: 1000, shaderLocation: 0},
          {format: 'sint8x4', offset: 480, shaderLocation: 23},
          {format: 'snorm16x4', offset: 272, shaderLocation: 6},
          {format: 'sint32x4', offset: 736, shaderLocation: 3},
          {format: 'float32x3', offset: 16, shaderLocation: 20},
          {format: 'snorm16x2', offset: 360, shaderLocation: 1},
          {format: 'unorm8x2', offset: 232, shaderLocation: 13},
          {format: 'uint8x2', offset: 178, shaderLocation: 12},
          {format: 'snorm16x2', offset: 420, shaderLocation: 7},
          {format: 'uint32x3', offset: 28, shaderLocation: 8},
          {format: 'snorm16x2', offset: 2292, shaderLocation: 9},
          {format: 'sint16x2', offset: 436, shaderLocation: 2},
          {format: 'uint32x2', offset: 1312, shaderLocation: 19},
          {format: 'sint8x4', offset: 848, shaderLocation: 14},
          {format: 'sint32', offset: 880, shaderLocation: 17},
          {format: 'unorm16x2', offset: 56, shaderLocation: 15},
          {format: 'uint32', offset: 856, shaderLocation: 18},
          {format: 'sint8x4', offset: 1392, shaderLocation: 4},
          {format: 'uint32x2', offset: 20, shaderLocation: 16},
          {format: 'float32x3', offset: 496, shaderLocation: 21},
          {format: 'uint16x2', offset: 920, shaderLocation: 26},
          {format: 'sint32x3', offset: 1296, shaderLocation: 22},
        ],
      },
      {
        arrayStride: 1892,
        attributes: [
          {format: 'sint32x2', offset: 132, shaderLocation: 10},
          {format: 'float32x3', offset: 260, shaderLocation: 5},
          {format: 'uint16x4', offset: 16, shaderLocation: 11},
        ],
      },
      {arrayStride: 104, attributes: []},
      {arrayStride: 456, stepMode: 'instance', attributes: []},
      {arrayStride: 360, attributes: []},
      {arrayStride: 2240, stepMode: 'instance', attributes: []},
      {
        arrayStride: 1216,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 188, shaderLocation: 25},
          {format: 'float32', offset: 212, shaderLocation: 24},
        ],
      },
    ],
  },
});
document.body.prepend(img9);
let canvas31 = document.createElement('canvas');
let bindGroupLayout35 = device1.createBindGroupLayout({
  label: '\u1cc4\u6344\u{1f99f}\u5546',
  entries: [{binding: 2563, visibility: GPUShaderStage.COMPUTE, sampler: { type: 'filtering' }}],
});
let texture71 = device1.createTexture({
  size: [96],
  dimension: '1d',
  format: 'r16float',
  usage: GPUTextureUsage.COPY_DST,
  viewFormats: ['r16float', 'r16float'],
});
let renderPassEncoder46 = commandEncoder137.beginRenderPass({
  label: '\u0adf\u0280\uf2e6',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 158.6, g: 451.1, b: -614.9, a: 657.2, },
  loadOp: 'clear',
  storeOp: 'store',
}, {view: textureView64, depthSlice: 0, loadOp: 'clear', storeOp: 'discard'}, {
  view: textureView119,
  depthSlice: 0,
  clearValue: { r: 425.3, g: 209.5, b: -440.5, a: 885.4, },
  loadOp: 'load',
  storeOp: 'discard',
}],
  occlusionQuerySet: querySet35,
  maxDrawCount: 1204108646,
});
let sampler66 = device1.createSampler({
  label: '\u0d3b\u{1fb23}\u05ff\u0d3a\u0f8c\u5f9b\u{1f9db}\u1eac\uda9b\ub27b\u3e08',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'mirror-repeat',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 55.36,
  lodMaxClamp: 89.25,
  compare: 'greater',
});
try {
computePassEncoder45.setPipeline(pipeline74);
} catch {}
try {
renderPassEncoder33.setBindGroup(1, bindGroup24);
} catch {}
try {
renderPassEncoder42.setStencilReference(2242);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer27, 1_505_266_077);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer15, 754_583_548);
} catch {}
try {
renderBundleEncoder74.setPipeline(pipeline82);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer15, 59072, buffer21, 43236, 16168);
dissociateBuffer(device1, buffer15);
dissociateBuffer(device1, buffer21);
} catch {}
try {
commandEncoder130.copyTextureToBuffer({
  texture: texture47,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 17610 */
  offset: 17610,
  buffer: buffer16,
}, {width: 0, height: 1, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer16);
} catch {}
let promise43 = device1.queue.onSubmittedWorkDone();
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap16,
  origin: { x: 0, y: 1 },
  flipY: false,
}, {
  texture: texture68,
  mipLevel: 0,
  origin: {x: 1, y: 3, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
try {
adapter3.label = '\ua688\u{1fc4c}\u5401\u324e\ucf63\ub660\u34b8';
} catch {}
try {
if (!arrayBuffer10.detached) { new Uint8Array(arrayBuffer10).fill(0x55) };
} catch {}
let buffer33 = device2.createBuffer({size: 64092, usage: GPUBufferUsage.COPY_DST, mappedAtCreation: true});
let commandEncoder138 = device2.createCommandEncoder({label: '\u3ee1\u7c40\u9567\u8456\u0d7c'});
let textureView153 = texture61.createView({
  label: '\u697c\u040c\uc6cb\u01f0\uc564\ua85e\u35fc\u0b5d\uea90',
  dimension: '2d-array',
  format: 'rg32float',
  baseArrayLayer: 0,
});
let externalTexture69 = device2.importExternalTexture({
  label: '\u{1fbd7}\u71a6\ud411\uc325\u{1f8e2}\u0c5b\u255f\u18e8\u{1fbfc}\uf3f2\u{1fb17}',
  source: videoFrame13,
  colorSpace: 'srgb',
});
try {
renderBundleEncoder81.setBindGroup(2, bindGroup41, new Uint32Array(5184), 388, 0);
} catch {}
try {
buffer24.unmap();
} catch {}
try {
commandEncoder114.clearBuffer(buffer28);
dissociateBuffer(device2, buffer28);
} catch {}
try {
commandEncoder131.insertDebugMarker('\u0b60');
} catch {}
try {
window.someLabel = externalTexture67.label;
} catch {}
let offscreenCanvas43 = new OffscreenCanvas(925, 847);
let shaderModule16 = device1.createShaderModule({
  label: '\uaa09\ua3db\u1942\uf975\u5645\ua37a',
  code: `@group(1) @binding(154)
var<storage, read_write> local7: array<u32>;

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

struct S17 {
  @location(33) f0: i32,
  @location(10) f1: vec2<i32>,
  @location(14) f2: vec3<f16>,
  @location(42) f3: vec2<i32>,
  @location(13) f4: f16,
  @location(22) f5: u32,
  @location(8) f6: vec4<i32>,
  @builtin(sample_mask) f7: u32,
  @location(28) f8: vec4<i32>,
  @location(0) f9: vec3<f32>,
  @location(12) f10: f32,
  @builtin(front_facing) f11: bool,
  @location(38) f12: vec2<u32>,
  @location(27) f13: vec2<f16>,
  @builtin(sample_index) f14: u32,
  @location(32) f15: vec4<f16>,
  @location(44) f16: vec2<f32>,
  @location(4) f17: vec4<f32>,
  @location(16) f18: vec3<f16>,
  @builtin(position) f19: vec4<f32>,
  @location(25) f20: vec3<f16>,
  @location(9) f21: f32,
  @location(21) f22: vec3<u32>,
  @location(41) f23: vec3<u32>,
  @location(5) f24: vec3<u32>,
  @location(35) f25: i32,
  @location(6) f26: f32,
  @location(26) f27: vec4<f32>,
  @location(43) f28: vec4<i32>,
  @location(31) f29: vec2<f16>,
  @location(19) f30: i32,
  @location(3) f31: f16,
  @location(11) f32: i32,
  @location(15) f33: vec4<u32>,
  @location(39) f34: vec4<u32>,
  @location(18) f35: vec2<i32>,
  @location(7) f36: vec3<u32>,
  @location(36) f37: vec2<u32>,
  @location(34) f38: f32
}
struct FragmentOutput0 {
  @location(0) f0: vec4<f32>,
  @location(2) f1: vec4<f32>,
  @location(1) f2: vec2<f32>
}

@fragment
fn fragment0(@location(23) a0: vec2<f32>, @location(1) a1: vec2<u32>, a2: S17) -> FragmentOutput0 {
  return FragmentOutput0();
}

struct S16 {
  @location(15) f0: vec4<f16>,
  @location(25) f1: vec2<u32>
}
struct VertexOutput0 {
  @location(39) f122: vec4<u32>,
  @location(14) f123: vec3<f16>,
  @location(21) f124: vec3<u32>,
  @location(23) f125: vec2<f32>,
  @location(26) f126: vec4<f32>,
  @location(1) f127: vec2<u32>,
  @location(27) f128: vec2<f16>,
  @location(8) f129: vec4<i32>,
  @location(36) f130: vec2<u32>,
  @location(32) f131: vec4<f16>,
  @location(28) f132: vec4<i32>,
  @location(24) f133: vec4<i32>,
  @location(9) f134: f32,
  @location(33) f135: i32,
  @location(40) f136: i32,
  @location(47) f137: vec3<i32>,
  @location(34) f138: f32,
  @location(38) f139: vec2<u32>,
  @location(37) f140: vec4<u32>,
  @location(3) f141: f16,
  @location(43) f142: vec4<i32>,
  @location(19) f143: i32,
  @location(18) f144: vec2<i32>,
  @location(42) f145: vec2<i32>,
  @location(15) f146: vec4<u32>,
  @location(4) f147: vec4<f32>,
  @location(16) f148: vec3<f16>,
  @location(31) f149: vec2<f16>,
  @location(30) f150: f16,
  @location(7) f151: vec3<u32>,
  @location(35) f152: i32,
  @location(25) f153: vec3<f16>,
  @location(10) f154: vec2<i32>,
  @location(22) f155: u32,
  @location(12) f156: f32,
  @location(13) f157: f16,
  @location(5) f158: vec3<u32>,
  @location(6) f159: f32,
  @location(41) f160: vec3<u32>,
  @location(11) f161: i32,
  @location(44) f162: vec2<f32>,
  @builtin(position) f163: vec4<f32>,
  @location(0) f164: vec3<f32>
}

@vertex
fn vertex0(@location(21) a0: vec3<f32>, @location(23) a1: vec4<f16>, @location(14) a2: f32, @location(12) a3: vec3<i32>, @location(9) a4: i32, a5: S16, @location(1) a6: vec4<f32>, @location(5) a7: vec2<f16>, @location(19) a8: vec2<i32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
  sourceMap: {},
  hints: {},
});
let bindGroup44 = device1.createBindGroup({
  label: '\u{1fd8e}\uce09\u{1f6c5}',
  layout: bindGroupLayout27,
  entries: [{binding: 154, resource: sampler65}],
});
try {
renderPassEncoder29.setBindGroup(1, bindGroup38, new Uint32Array(6958), 4777, 0);
} catch {}
try {
renderBundleEncoder46.setPipeline(pipeline82);
} catch {}
try {
commandEncoder130.copyBufferToBuffer(buffer13, 52696, buffer16, 14488, 10236);
dissociateBuffer(device1, buffer13);
dissociateBuffer(device1, buffer16);
} catch {}
try {
commandEncoder130.copyTextureToTexture({
  texture: texture33,
  mipLevel: 0,
  origin: {x: 3, y: 0, z: 0},
  aspect: 'all',
},
{
  texture: texture31,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
},
{width: 10, height: 0, depthOrArrayLayers: 1});
} catch {}
try {
renderBundleEncoder68.popDebugGroup();
} catch {}
try {
device1.queue.writeTexture({
  texture: texture46,
  mipLevel: 0,
  origin: {x: 11, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(16), /* required buffer size: 707 */
{offset: 339, rowsPerImage: 133}, {width: 46, height: 1, depthOrArrayLayers: 1});
} catch {}
try {
  await promise43;
} catch {}
let imageBitmap32 = await createImageBitmap(imageData26);
let bindGroup45 = device1.createBindGroup({label: '\u6b0d\u0ebb', layout: bindGroupLayout20, entries: []});
let renderPassEncoder47 = commandEncoder130.beginRenderPass({
  label: '\u0ddf\ueb9b\uaa0f\u55dd\u26dd\ub0fc\u{1f6f0}',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 516.5, g: 356.4, b: -560.3, a: -815.2, },
  loadOp: 'load',
  storeOp: 'store',
}, {view: textureView64, depthSlice: 0, loadOp: 'load', storeOp: 'discard'}, {
  view: textureView95,
  depthSlice: 0,
  clearValue: { r: -142.7, g: -517.5, b: 525.5, a: -462.1, },
  loadOp: 'clear',
  storeOp: 'store',
}],
  occlusionQuerySet: querySet39,
  maxDrawCount: 69723782,
});
let renderBundleEncoder84 = device1.createRenderBundleEncoder({
  label: '\ud20a\u07c3\u{1fd4d}\u0d40\u3b60\ud166\u8adc\u05f0\u01b5\u7d06\u51f1',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
});
let externalTexture70 = device1.importExternalTexture({source: videoFrame26});
try {
renderPassEncoder40.setBlendConstant({ r: 513.5, g: -951.8, b: 492.5, a: -876.5, });
} catch {}
try {
renderPassEncoder26.setIndexBuffer(buffer32, 'uint16', 13124, 3220);
} catch {}
try {
renderPassEncoder47.setPipeline(pipeline65);
} catch {}
try {
renderBundleEncoder50.setBindGroup(6, bindGroup37);
} catch {}
try {
buffer17.unmap();
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 3, height: 4, depthOrArrayLayers: 1}
*/
{
  source: videoFrame16,
  origin: { x: 0, y: 0 },
  flipY: true,
}, {
  texture: texture37,
  mipLevel: 2,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
let videoFrame40 = new VideoFrame(offscreenCanvas6, {timestamp: 0});
try {
canvas30.getContext('webgpu');
} catch {}
let texture72 = gpuCanvasContext40.getCurrentTexture();
let textureView154 = texture60.createView({label: '\u7ca8\uca12\uf6cf\u0703\u{1f93b}\ubb35\ub01b\u6562\u48a2\ua2a7\u03e8'});
let computePassEncoder63 = commandEncoder127.beginComputePass({});
let externalTexture71 = device2.importExternalTexture({label: '\uc0a0\uff7d\u1db7\uac47', source: videoFrame22, colorSpace: 'srgb'});
try {
renderBundleEncoder83.setVertexBuffer(5646, undefined, 0, 1127976678);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 0,
  origin: {x: 2, y: 6, z: 35},
  aspect: 'all',
}, new DataView(arrayBuffer6), /* required buffer size: 267_254 */
{offset: 414, bytesPerRow: 416, rowsPerImage: 213}, {width: 46, height: 3, depthOrArrayLayers: 4});
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
try {
renderPassEncoder29.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.setBlendConstant({ r: -846.9, g: 96.30, b: -53.09, a: -650.8, });
} catch {}
try {
renderPassEncoder21.drawIndexed(405, 378);
} catch {}
try {
renderPassEncoder24.setPipeline(pipeline57);
} catch {}
try {
renderBundleEncoder50.insertDebugMarker('\u37c9');
} catch {}
try {
gpuCanvasContext29.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_SRC,
  colorSpace: 'display-p3',
  alphaMode: 'opaque',
});
} catch {}
try {
device1.queue.submit([commandBuffer29, commandBuffer27]);
} catch {}
let pipeline109 = await device1.createRenderPipelineAsync({
  label: '\u6e5f\u9edf\u8bfc\u0e48\u2068\u0b54\u0f22',
  layout: pipelineLayout17,
  multisample: {},
  fragment: {
  module: shaderModule10,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'reverse-subtract', srcFactor: 'one-minus-src', dstFactor: 'zero'},
    alpha: {operation: 'add', srcFactor: 'src', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rg32float', writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED}, {format: 'rgba32float', writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN}],
},
  vertex: {
    module: shaderModule10,
    entryPoint: 'vertex0',
    buffers: [
      {
        arrayStride: 928,
        stepMode: 'instance',
        attributes: [{format: 'unorm10-10-10-2', offset: 156, shaderLocation: 9}],
      },
      {
        arrayStride: 4024,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm8x2', offset: 112, shaderLocation: 6},
          {format: 'sint32', offset: 1148, shaderLocation: 14},
          {format: 'unorm8x2', offset: 582, shaderLocation: 21},
          {format: 'uint32x4', offset: 1068, shaderLocation: 19},
          {format: 'float32x3', offset: 528, shaderLocation: 5},
        ],
      },
      {
        arrayStride: 1204,
        attributes: [
          {format: 'sint16x4', offset: 220, shaderLocation: 22},
          {format: 'unorm16x2', offset: 164, shaderLocation: 1},
          {format: 'float32x3', offset: 204, shaderLocation: 25},
          {format: 'sint32x2', offset: 276, shaderLocation: 10},
          {format: 'sint16x2', offset: 448, shaderLocation: 3},
          {format: 'uint16x2', offset: 272, shaderLocation: 8},
          {format: 'sint16x4', offset: 0, shaderLocation: 17},
        ],
      },
      {
        arrayStride: 1256,
        attributes: [
          {format: 'sint32', offset: 416, shaderLocation: 2},
          {format: 'uint32x3', offset: 52, shaderLocation: 18},
        ],
      },
      {
        arrayStride: 968,
        stepMode: 'instance',
        attributes: [
          {format: 'float32x3', offset: 12, shaderLocation: 24},
          {format: 'uint32x4', offset: 268, shaderLocation: 26},
          {format: 'sint16x2', offset: 180, shaderLocation: 4},
          {format: 'unorm16x2', offset: 368, shaderLocation: 20},
        ],
      },
      {
        arrayStride: 2020,
        attributes: [
          {format: 'unorm8x4', offset: 44, shaderLocation: 15},
          {format: 'sint8x4', offset: 420, shaderLocation: 23},
        ],
      },
      {
        arrayStride: 1112,
        stepMode: 'instance',
        attributes: [
          {format: 'unorm16x2', offset: 140, shaderLocation: 13},
          {format: 'uint32x4', offset: 188, shaderLocation: 12},
        ],
      },
      {
        arrayStride: 424,
        stepMode: 'instance',
        attributes: [
          {format: 'uint32', offset: 0, shaderLocation: 11},
          {format: 'float16x2', offset: 376, shaderLocation: 0},
          {format: 'uint32x4', offset: 60, shaderLocation: 16},
          {format: 'float32x2', offset: 44, shaderLocation: 7},
        ],
      },
    ],
  },
  primitive: {
  topology: 'line-strip',
  stripIndexFormat: 'uint32',
  frontFace: 'cw',
  cullMode: 'front',
  unclippedDepth: true,
},
});
try {
if (!arrayBuffer14.detached) { new Uint8Array(arrayBuffer14).fill(0x55) };
} catch {}
let bindGroup46 = device2.createBindGroup({label: '\u0e17\u05db\u71a6\u5a01', layout: bindGroupLayout34, entries: []});
let querySet59 = device2.createQuerySet({type: 'occlusion', count: 2415});
try {
commandEncoder131.copyBufferToBuffer(buffer24, 194248, buffer33, 13488, 10856);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer33);
} catch {}
try {
commandEncoder105.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 5548 */
  offset: 5548,
  buffer: buffer24,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {width: 0, height: 1, depthOrArrayLayers: 1});
dissociateBuffer(device2, buffer24);
} catch {}
try {
commandEncoder114.clearBuffer(buffer30);
dissociateBuffer(device2, buffer30);
} catch {}
let gpuCanvasContext41 = offscreenCanvas42.getContext('webgpu');
let textureView155 = texture61.createView({label: '\u57b6\uaa9e\u{1ff97}\u0c64\ud4c2\u0697\u2c33\u{1f886}\u86b0\u3ce6'});
let renderBundleEncoder85 = device2.createRenderBundleEncoder({
  label: '\u{1ff19}\u7da9',
  colorFormats: ['rg32float', 'rg32sint', 'r32float', 'r8sint', 'rg32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
try {
computePassEncoder56.setBindGroup(1, bindGroup40, new Uint32Array(9225), 3208, 0);
} catch {}
try {
computePassEncoder60.end();
} catch {}
let commandEncoder139 = device2.createCommandEncoder({});
let querySet60 = device2.createQuerySet({type: 'occlusion', count: 3768});
let commandBuffer33 = commandEncoder138.finish({label: '\u{1fcbf}\u092f\ubb6b\uec39'});
let textureView156 = texture72.createView({label: '\u082c\uc092\ufa0c\u00ed\uc0c2\ua305\u0bc6\uefb9', dimension: '2d-array', mipLevelCount: 1});
try {
commandEncoder105.copyBufferToBuffer(buffer24, 162960, buffer33, 12368, 24824);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer33);
} catch {}
try {
commandEncoder131.clearBuffer(buffer33, 35312);
dissociateBuffer(device2, buffer33);
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas34,
  origin: { x: 62, y: 4 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let imageData30 = new ImageData(172, 96);
let shaderModule17 = device1.createShaderModule({
  label: '\u80d8\u41e9\u0dc9\u80b0',
  code: `@group(4) @binding(4285)
var<storage, read_write> function4: array<u32>;
@group(0) @binding(643)
var<storage, read_write> field7: array<u32>;
@group(4) @binding(4361)
var<storage, read_write> function5: array<u32>;

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

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

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

struct VertexOutput0 {
  @location(37) f165: vec4<u32>,
  @location(24) f166: vec4<f32>,
  @builtin(position) f167: vec4<f32>,
  @location(41) f168: vec2<u32>,
  @location(29) f169: vec3<f32>,
  @location(8) f170: vec4<u32>,
  @location(28) f171: u32,
  @location(38) f172: f16,
  @location(22) f173: vec4<u32>,
  @location(32) f174: vec3<u32>,
  @location(23) f175: i32,
  @location(45) f176: vec2<f16>,
  @location(47) f177: vec2<u32>,
  @location(6) f178: vec4<f32>,
  @location(31) f179: vec2<u32>,
  @location(40) f180: vec4<i32>,
  @location(4) f181: vec2<f32>,
  @location(14) f182: vec2<i32>,
  @location(26) f183: u32,
  @location(27) f184: vec3<f32>,
  @location(3) f185: vec3<i32>,
  @location(7) f186: vec4<u32>,
  @location(42) f187: vec2<f16>,
  @location(39) f188: f32,
  @location(43) f189: i32,
  @location(21) f190: f16,
  @location(46) f191: i32,
  @location(25) f192: vec2<i32>,
  @location(34) f193: vec2<u32>,
  @location(5) f194: vec4<f16>,
  @location(12) f195: vec2<f16>,
  @location(19) f196: vec3<u32>,
  @location(33) f197: vec2<f32>
}

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

`,
  sourceMap: {},
  hints: {},
});
let bindGroup47 = device1.createBindGroup({
  label: '\u{1fb45}\u2152\u{1fa05}\ubca5\u6311',
  layout: bindGroupLayout27,
  entries: [{binding: 154, resource: sampler65}],
});
let textureView157 = texture65.createView({
  label: '\u{1fae3}\u0b7b\u049e\u02df\uc0a7\u7637\u03d7\u9117\u14f8\u0f5e',
  dimension: '2d',
  baseMipLevel: 2,
  baseArrayLayer: 123,
});
let sampler67 = device1.createSampler({
  label: '\u5af1\u033a\u0a25\uf4e7\uc8df\ud9ee\udbe0\u884b\u1ceb',
  addressModeW: 'mirror-repeat',
  lodMinClamp: 82.26,
  lodMaxClamp: 83.20,
});
try {
computePassEncoder45.setPipeline(pipeline72);
} catch {}
try {
renderPassEncoder42.executeBundles([renderBundle61, renderBundle53, renderBundle77, renderBundle52, renderBundle46]);
} catch {}
try {
renderPassEncoder44.setStencilReference(862);
} catch {}
try {
renderBundleEncoder46.setIndexBuffer(buffer19, 'uint32', 394148, 4225);
} catch {}
try {
renderBundleEncoder41.setPipeline(pipeline109);
} catch {}
let arrayBuffer19 = buffer19.getMappedRange(444920, 508);
try {
buffer26.unmap();
} catch {}
let promise44 = device1.createRenderPipelineAsync({
  label: '\u{1f7d0}\u{1fffb}\uad7f',
  layout: pipelineLayout7,
  multisample: {mask: 0x8b214bc1},
  fragment: {
  module: shaderModule16,
  entryPoint: 'fragment0',
  targets: [{
  format: 'r16float',
  blend: {
    color: {operation: 'add', srcFactor: 'dst', dstFactor: 'one-minus-dst-alpha'},
    alpha: {operation: 'min', srcFactor: 'one', dstFactor: 'one'},
  },
  writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
}, {format: 'rg32float', writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA}, {format: 'rgba32float', writeMask: GPUColorWrite.GREEN}],
},
  depthStencil: {
    format: 'stencil8',
    depthCompare: 'always',
    stencilFront: {compare: 'equal', failOp: 'invert', depthFailOp: 'decrement-wrap', passOp: 'replace'},
    stencilBack: {failOp: 'zero', depthFailOp: 'decrement-wrap', passOp: 'decrement-clamp'},
    stencilReadMask: 1561714954,
    stencilWriteMask: 2253333985,
    depthBias: 0,
  },
  vertex: {
    module: shaderModule16,
    entryPoint: 'vertex0',
    constants: {},
    buffers: [
      {
        arrayStride: 264,
        stepMode: 'vertex',
        attributes: [
          {format: 'uint16x4', offset: 104, shaderLocation: 25},
          {format: 'snorm16x4', offset: 20, shaderLocation: 5},
          {format: 'unorm8x4', offset: 16, shaderLocation: 14},
          {format: 'float32x2', offset: 12, shaderLocation: 15},
          {format: 'sint8x2', offset: 4, shaderLocation: 19},
          {format: 'unorm8x2', offset: 30, shaderLocation: 1},
        ],
      },
      {arrayStride: 0, stepMode: 'vertex', attributes: []},
      {
        arrayStride: 396,
        stepMode: 'instance',
        attributes: [
          {format: 'snorm16x4', offset: 28, shaderLocation: 21},
          {format: 'sint32x3', offset: 92, shaderLocation: 12},
          {format: 'sint16x2', offset: 16, shaderLocation: 9},
        ],
      },
      {arrayStride: 3936, attributes: [{format: 'snorm8x2', offset: 526, shaderLocation: 23}]},
    ],
  },
  primitive: {topology: 'line-strip', stripIndexFormat: 'uint32', frontFace: 'cw', unclippedDepth: true},
});
try {
adapter0.label = '\uf5c7\ue2ad\u{1fc41}\u0e14\u0148\u{1fda2}\u03d8\uddc3\u3bf6\ub743\u3554';
} catch {}
let bindGroupLayout36 = device2.createBindGroupLayout({
  label: '\u7eba\u5718\u{1f91d}\u388c\u{1f996}\u8b22\u787a\uffc4',
  entries: [
    {binding: 105, visibility: 0, externalTexture: {}},
    {
      binding: 47,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
      sampler: { type: 'non-filtering' },
    },
    {
      binding: 752,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
    },
  ],
});
let texture73 = device2.createTexture({
  size: {width: 28},
  sampleCount: 1,
  dimension: '1d',
  format: 'rg32sint',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
  viewFormats: ['rg32sint'],
});
let textureView158 = texture60.createView({label: '\uba06\u0104\ub877\u0ca3\u4397\u2d14', baseArrayLayer: 0});
let sampler68 = device2.createSampler({
  addressModeU: 'repeat',
  addressModeV: 'mirror-repeat',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 24.25,
  lodMaxClamp: 50.37,
  maxAnisotropy: 11,
});
try {
commandEncoder129.copyBufferToTexture({
  /* bytesInLastRow: 0 widthInBlocks: 0 aspectSpecificFormat.texelBlockSize: 4 */
  /* end: 6744 */
  offset: 6744,
  bytesPerRow: 0,
  rowsPerImage: 274,
  buffer: buffer24,
}, {
  texture: texture56,
  mipLevel: 1,
  origin: {x: 2, y: 1, z: 0},
  aspect: 'all',
}, {width: 0, height: 7, depthOrArrayLayers: 59});
dissociateBuffer(device2, buffer24);
} catch {}
try {
device2.queue.submit([commandBuffer32, commandBuffer31]);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture48,
  mipLevel: 1,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new BigUint64Array(arrayBuffer19), /* required buffer size: 99_551 */
{offset: 592, bytesPerRow: 211, rowsPerImage: 67}, {width: 6, height: 0, depthOrArrayLayers: 8});
} catch {}
gc();
let imageData31 = new ImageData(80, 200);
try {
canvas31.getContext('webgpu');
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
let img29 = await imageWithData(184, 105, '#9d1a0cf7', '#cc7f0880');
let imageBitmap33 = await createImageBitmap(imageData28);
let querySet61 = device1.createQuerySet({label: '\u0dad\u{1fe0c}\u{1fe30}\u83ff\u{1fcb9}\u0fc6', type: 'occlusion', count: 3161});
let textureView159 = texture35.createView({
  label: '\u01c3\u{1f8c9}\u06dc\ub218\u81a0',
  mipLevelCount: 1,
  baseArrayLayer: 106,
  arrayLayerCount: 191,
});
try {
renderPassEncoder37.executeBundles([renderBundle42, renderBundle88]);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer21, 536_597_361);
} catch {}
try {
renderPassEncoder22.setIndexBuffer(buffer19, 'uint16', 177154, 139870);
} catch {}
try {
renderBundleEncoder84.setPipeline(pipeline71);
} catch {}
let arrayBuffer20 = buffer21.getMappedRange(65184, 1652);
let pipeline110 = device1.createComputePipeline({
  label: '\u{1fbaf}\u{1f7e6}',
  layout: pipelineLayout7,
  compute: {module: shaderModule11, entryPoint: 'compute0', constants: {}},
});
try {
offscreenCanvas43.getContext('2d');
} catch {}
try {
buffer29.label = '\udd38\u{1fb29}\u9474';
} catch {}
let textureView160 = texture73.createView({label: '\u0afe\u09f7'});
try {
computePassEncoder61.end();
} catch {}
try {
device2.queue.writeBuffer(buffer30, 6172, new Float32Array(33445));
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 1,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
}, new ArrayBuffer(2_541_758), /* required buffer size: 2_541_758 */
{offset: 794, bytesPerRow: 314, rowsPerImage: 202}, {width: 19, height: 13, depthOrArrayLayers: 41});
} catch {}
let commandEncoder140 = device1.createCommandEncoder({label: '\u{1f9c9}\u0184\u{1f9f0}\u11a8\u{1fb18}\udee9\u02e9\u03c5\u2f04\uc219\u00d5'});
let querySet62 = device1.createQuerySet({
  label: '\ufda6\u0b09\u0e21\u091d\u9760\u{1fd6a}\u{1fde9}\u8c37\u{1ff85}\u{1f746}\u2ed9',
  type: 'occlusion',
  count: 2424,
});
let textureView161 = texture70.createView({label: '\u08ca\u9fd3\u09bf\u8a87\u0ca6\u772c\u{1ff2b}', mipLevelCount: 2});
let renderPassEncoder48 = commandEncoder140.beginRenderPass({
  label: '\u0c15\uecef\u0aa5\u0669\u{1f933}\u4fcc\u427d\uaed4\u00cb\u22d6\u7b16',
  colorAttachments: [{
  view: textureView96,
  clearValue: { r: 863.7, g: -204.8, b: -421.6, a: -954.8, },
  loadOp: 'load',
  storeOp: 'store',
}, {
  view: textureView64,
  depthSlice: 0,
  clearValue: { r: 967.0, g: 802.6, b: -163.3, a: -799.2, },
  loadOp: 'load',
  storeOp: 'discard',
}, {
  view: textureView85,
  depthSlice: 0,
  clearValue: { r: 693.0, g: 208.1, b: 983.7, a: 13.74, },
  loadOp: 'clear',
  storeOp: 'discard',
}],
  maxDrawCount: 1200050262,
});
let renderBundle89 = renderBundleEncoder68.finish({label: '\uaa1f\u{1fd87}\u0b16\u6397\u0a01\u3e09\u0136\u65b4\ubd8a\u{1fb7b}'});
try {
renderPassEncoder21.setBlendConstant({ r: -462.5, g: -193.0, b: -108.9, a: -981.1, });
} catch {}
try {
renderPassEncoder21.draw(12, 118, 151_504_937, 244_070_694);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 1764, new BigUint64Array(6675), 3451, 912);
} catch {}
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
gc();
let img30 = await imageWithData(41, 168, '#ec80c076', '#d68dbc88');
let buffer34 = device1.createBuffer({
  label: '\u0b29\u{1f971}\u0fc6\ufa4e\u9ec0\uf874\ucae5\u3f1e\u5b57\u57c8\u0e93',
  size: 163305,
  usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
});
let querySet63 = device1.createQuerySet({type: 'occlusion', count: 2679});
let textureView162 = texture59.createView({label: '\u413d\u0fb4\u{1fa69}\u{1fe2c}\u1014\u042c\u7b26\u{1fb99}\u{1fc54}'});
try {
computePassEncoder25.setBindGroup(0, bindGroup31, new Uint32Array(2949), 789, 0);
} catch {}
try {
renderPassEncoder21.draw(129);
} catch {}
try {
renderPassEncoder30.setVertexBuffer(7, buffer32, 8336, 8693);
} catch {}
try {
renderBundleEncoder50.setPipeline(pipeline82);
} catch {}
try {
device1.queue.writeBuffer(buffer14, 4488, new Float32Array(56471), 24612, 4520);
} catch {}
let commandBuffer34 = commandEncoder129.finish({label: '\u059f\u4c17\u8f69\u6531\ub528\u08b6'});
let texture74 = gpuCanvasContext0.getCurrentTexture();
let textureView163 = texture48.createView({
  label: '\uce5f\u06a9\uffc5\u8db2\u{1fd38}\u58e0\u{1fe02}\uf010\u{1fc98}\u0b46\ue48a',
  mipLevelCount: 2,
});
let computePassEncoder64 = commandEncoder131.beginComputePass();
let renderBundle90 = renderBundleEncoder83.finish({});
try {
renderBundleEncoder82.setVertexBuffer(255, undefined, 1880187328);
} catch {}
gc();
let adapter4 = await navigator.gpu.requestAdapter({});
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let offscreenCanvas44 = new OffscreenCanvas(359, 549);
let promise45 = adapter2.requestAdapterInfo();
let textureView164 = texture42.createView({label: '\u{1fdf7}\u43bb\u{1f8d7}\u3568\u0830\uc566\u3f63\ua013', baseArrayLayer: 0});
let renderBundleEncoder86 = device1.createRenderBundleEncoder({
  label: '\u7bac\u0849\uc956',
  colorFormats: ['r16float', 'rg32float', 'rgba32float'],
  depthReadOnly: true,
  stencilReadOnly: true,
});
let renderBundle91 = renderBundleEncoder57.finish({});
try {
renderPassEncoder37.setViewport(4.076, 1.562, 1.497, 1.292, 0.8084, 0.9660);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer22, 769_452_112);
} catch {}
try {
renderBundleEncoder65.setVertexBuffer(3, buffer19, 0, 203472);
} catch {}
let pipelineLayout18 = device1.createPipelineLayout({label: '\u263c\ud64e\u{1fbec}\u01f3\ua0d3\u9c7c\ubcc2', bindGroupLayouts: [bindGroupLayout21]});
let textureView165 = texture59.createView({label: '\u0970\u7d54\u6921\u{1fe3d}\u055e\u0c30\u0f5b\u7f17\u053a\u2ae4', mipLevelCount: 1});
try {
renderPassEncoder21.draw(8);
} catch {}
try {
renderPassEncoder21.drawIndexed(66, 23, 279_083_323, 118_431_923, 58_399_087);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer19, 866_171);
} catch {}
try {
renderPassEncoder43.setPipeline(pipeline82);
} catch {}
try {
renderPassEncoder40.setVertexBuffer(6, buffer14);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
let promise46 = buffer17.mapAsync(GPUMapMode.READ, 4856, 23256);
try {
  await device1.queue.onSubmittedWorkDone();
} catch {}
let gpuCanvasContext42 = offscreenCanvas44.getContext('webgpu');
try {
  await promise45;
} catch {}
let canvas32 = document.createElement('canvas');
let img31 = await imageWithData(149, 215, '#534e7755', '#e56f53fc');
let imageData32 = new ImageData(4, 136);
let commandEncoder141 = device2.createCommandEncoder({label: '\u6195\u6ca9\u75a6\u0a4a\u0cb7\u0f72\u{1f917}'});
try {
renderBundleEncoder80.setVertexBuffer(3492, undefined, 1713433447, 2518037145);
} catch {}
try {
device2.queue.writeBuffer(buffer30, 56560, new DataView(new ArrayBuffer(60564)));
} catch {}
try {
  await promise46;
} catch {}
let imageBitmap34 = await createImageBitmap(canvas18);
let offscreenCanvas45 = new OffscreenCanvas(912, 701);
offscreenCanvas27.height = 1167;
let imageData33 = new ImageData(100, 168);
let gpuCanvasContext43 = canvas32.getContext('webgpu');
let commandBuffer35 = commandEncoder105.finish({});
let textureView166 = texture53.createView({
  label: '\u20fc\u1408\u7b44\u200a\u{1fb79}',
  dimension: '2d-array',
  format: 'rg32sint',
  mipLevelCount: 1,
});
try {
computePassEncoder58.setBindGroup(3, bindGroup41);
} catch {}
try {
commandEncoder106.copyBufferToBuffer(buffer24, 138696, buffer28, 12404, 5068);
dissociateBuffer(device2, buffer24);
dissociateBuffer(device2, buffer28);
} catch {}
try {
commandEncoder106.copyTextureToBuffer({
  texture: texture66,
  mipLevel: 0,
  origin: {x: 6, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 48 widthInBlocks: 6 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 2008 */
  offset: 2008,
  buffer: buffer30,
}, {width: 6, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device2, buffer30);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap13,
  origin: { x: 10, y: 39 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let video24 = await videoWithData();
try {
sampler56.label = '\u{1fb70}\u{1fe5b}\u15a2\uad35\u7eec\u604f\u6476';
} catch {}
try {
gpuCanvasContext18.unconfigure();
} catch {}
let commandEncoder142 = device2.createCommandEncoder({label: '\ucfcc\u9858\u{1f915}\u0017\u0110\u018b\ua9ca\u0fd3'});
let querySet64 = device2.createQuerySet({label: '\u9fab\u{1fe17}\ud0b8\u{1f7d5}\uce3c', type: 'occlusion', count: 1261});
let textureView167 = texture49.createView({
  label: '\u05b5\u666d\u{1fef4}\u1515\u0d7c\u4b1e\u447c',
  mipLevelCount: 1,
  baseArrayLayer: 97,
  arrayLayerCount: 104,
});
let computePassEncoder65 = commandEncoder141.beginComputePass({label: '\u074b\u014f\ufd95\ubf2b\u{1fac7}\u8d88'});
try {
renderBundleEncoder82.setBindGroup(3, bindGroup42);
} catch {}
try {
commandEncoder106.clearBuffer(buffer30);
dissociateBuffer(device2, buffer30);
} catch {}
try {
  await device2.queue.onSubmittedWorkDone();
} catch {}
let renderBundle92 = renderBundleEncoder37.finish();
try {
computePassEncoder42.setPipeline(pipeline98);
} catch {}
try {
renderPassEncoder26.setBindGroup(6, bindGroup31);
} catch {}
try {
renderPassEncoder21.endOcclusionQuery();
} catch {}
try {
renderPassEncoder21.executeBundles([renderBundle92, renderBundle46, renderBundle57, renderBundle92, renderBundle64, renderBundle92]);
} catch {}
try {
renderPassEncoder36.setStencilReference(2570);
} catch {}
try {
renderPassEncoder21.drawIndexedIndirect(buffer34, 957_600_697);
} catch {}
try {
renderBundleEncoder62.setBindGroup(7, bindGroup34);
} catch {}
try {
renderBundleEncoder62.setBindGroup(6, bindGroup33, new Uint32Array(9902), 7588, 0);
} catch {}
let arrayBuffer21 = buffer27.getMappedRange(15848);
try {
device1.queue.writeTexture({
  texture: texture57,
  mipLevel: 5,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer7), /* required buffer size: 862 */
{offset: 862, rowsPerImage: 73}, {width: 1, height: 0, depthOrArrayLayers: 0});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 24, height: 32, depthOrArrayLayers: 1}
*/
{
  source: imageData15,
  origin: { x: 93, y: 0 },
  flipY: true,
}, {
  texture: texture23,
  mipLevel: 1,
  origin: {x: 0, y: 4, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 5, height: 3, depthOrArrayLayers: 0});
} catch {}
let canvas33 = document.createElement('canvas');
let gpuCanvasContext44 = canvas33.getContext('webgpu');
let bindGroupLayout37 = device2.createBindGroupLayout({
  entries: [
    {
      binding: 202,
      visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
      texture: { viewDimension: '3d', sampleType: 'float', multisampled: false },
    },
  ],
});
try {
renderBundleEncoder80.setBindGroup(2, bindGroup42, new Uint32Array(3296), 671, 0);
} catch {}
try {
commandEncoder142.copyTextureToBuffer({
  texture: texture73,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
}, {
  /* bytesInLastRow: 176 widthInBlocks: 22 aspectSpecificFormat.texelBlockSize: 8 */
  /* end: 51864 */
  offset: 51864,
  buffer: buffer30,
}, {width: 22, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device2, buffer30);
} catch {}
try {
gpuCanvasContext1.configure({
  device: device2,
  format: 'rgba16float',
  usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
  alphaMode: 'premultiplied',
});
} catch {}
try {
device2.queue.writeBuffer(buffer30, 138180, new DataView(new ArrayBuffer(26062)), 23283, 40);
} catch {}
try {
device2.queue.writeTexture({
  texture: texture56,
  mipLevel: 2,
  origin: {x: 5, y: 0, z: 0},
  aspect: 'all',
}, new DataView(arrayBuffer2), /* required buffer size: 776 */
{offset: 776, bytesPerRow: 280}, {width: 6, height: 6, depthOrArrayLayers: 0});
} catch {}
try {
device2.queue.copyExternalImageToTexture(/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas18,
  origin: { x: 190, y: 66 },
  flipY: true,
}, {
  texture: texture72,
  mipLevel: 0,
  origin: {x: 0, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
}, {width: 0, height: 0, depthOrArrayLayers: 0});
} catch {}
let bindGroupLayout38 = device1.createBindGroupLayout({
  label: '\u1cb6\u7f2d\u{1f6ef}\u06dc\u{1f9d1}\u0d87\ucae1\u0235\u0f89\ub18e',
  entries: [
    {
      binding: 2981,
      visibility: GPUShaderStage.COMPUTE,
      texture: { viewDimension: 'cube', sampleType: 'float', multisampled: false },
    },
    {
      binding: 4574,
      visibility: GPUShaderStage.COMPUTE,
      storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '3d' },
    },
    {binding: 5113, visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX, externalTexture: {}},
  ],
});
let renderBundle93 = renderBundleEncoder52.finish({label: '\u0589\ueb9e\ub7c2\u5317'});
let sampler69 = device1.createSampler({
  label: '\u04c4\u{1fde9}\u52de\u{1fc7d}\u{1f60e}\ub41a',
  addressModeU: 'clamp-to-edge',
  addressModeV: 'clamp-to-edge',
  addressModeW: 'clamp-to-edge',
  magFilter: 'linear',
  lodMaxClamp: 96.76,
  compare: 'greater',
});
try {
computePassEncoder27.setBindGroup(7, bindGroup27);
} catch {}
try {
renderPassEncoder33.setScissorRect(3, 6, 1, 1);
} catch {}
try {
renderPassEncoder21.draw(135, 335, 1_130_684_537);
} catch {}
try {
renderPassEncoder21.drawIndexed(172, 433);
} catch {}
try {
renderPassEncoder21.drawIndirect(buffer23, 466_116_171);
} catch {}
try {
renderPassEncoder22.setPipeline(pipeline57);
} catch {}
try {
  await buffer26.mapAsync(GPUMapMode.READ, 9600, 264);
} catch {}
try {
gpuCanvasContext18.configure({
  device: device1,
  format: 'bgra8unorm',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: [],
  colorSpace: 'srgb',
  alphaMode: 'premultiplied',
});
} catch {}
let pipeline111 = device1.createComputePipeline({
  label: '\u27b6\u0857\ub31f\u7a2c\u{1fac2}\u9184\u0f33\u80dc\u00f4',
  layout: pipelineLayout7,
  compute: {module: shaderModule9, entryPoint: 'compute0'},
});
try {
offscreenCanvas45.getContext('webgl');
} catch {}
let texture75 = device1.createTexture({
  label: '\u8f50\u06d0',
  size: [12, 16, 1],
  mipLevelCount: 5,
  format: 'rgba32float',
  usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
  viewFormats: ['rgba32float', 'rgba32float', 'rgba32float'],
});
let textureView168 = texture29.createView({label: '\u5354\u853f\u2622\u719a\ubf7f\u{1f611}\u07ab\u{1fef1}', baseMipLevel: 0});
let renderBundle94 = renderBundleEncoder58.finish({label: '\u0d47\uc9a5\udd28'});
let sampler70 = device1.createSampler({
  label: '\u66b8\u{1f6a1}\u670b',
  addressModeV: 'clamp-to-edge',
  magFilter: 'linear',
  minFilter: 'linear',
  mipmapFilter: 'linear',
  lodMinClamp: 0.1658,
  maxAnisotropy: 16,
});
let externalTexture72 = device1.importExternalTexture({
  label: '\u16d6\u576f\u0c44\ud26b\u3718\u{1f73d}\u0d5d\u0a92',
  source: video11,
  colorSpace: 'display-p3',
});
try {
computePassEncoder47.end();
} catch {}
try {
renderPassEncoder46.setViewport(4.959, 2.749, 0.06019, 3.440, 0.7784, 0.9751);
} catch {}
try {
renderPassEncoder21.drawIndexed(119, 68, 3_868_979, 770_090_009, 2_514_812_121);
} catch {}
try {
renderPassEncoder46.setPipeline(pipeline108);
} catch {}
try {
commandEncoder58.copyBufferToTexture({
  /* bytesInLastRow: 2 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 2 */
  /* end: 3206 */
  offset: 3206,
  buffer: buffer15,
}, {
  texture: texture58,
  mipLevel: 3,
  origin: {x: 1, y: 0, z: 0},
  aspect: 'all',
}, {width: 1, height: 0, depthOrArrayLayers: 1});
dissociateBuffer(device1, buffer15);
} catch {}
try {
device1.queue.writeTexture({
  texture: texture30,
  mipLevel: 2,
  origin: {x: 0, y: 1, z: 0},
  aspect: 'all',
}, new ArrayBuffer(0), /* required buffer size: 1_348 */
{offset: 960, bytesPerRow: 38, rowsPerImage: 263}, {width: 4, height: 11, depthOrArrayLayers: 1});
} catch {}
try {
device1.queue.copyExternalImageToTexture(/*
{width: 12, height: 16, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap34,
  origin: { x: 134, y: 21 },
  flipY: true,
}, {
  texture: texture67,
  mipLevel: 3,
  origin: {x: 2, y: 0, z: 0},
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
}, {width: 1, height: 2, depthOrArrayLayers: 0});
} catch {}
try {
gpuCanvasContext31.unconfigure();
} catch {}
video13.width = 101;
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();
  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>