LayoutTests/fast/webgpu/nocrash/fuzz-273323.html

<style>
  :root { background: #102030e0; color: #99ddbbcc; font-size: 15px; }
</style>
<script>
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
 * @param {GPUCommandEncoder} commandEncoder
 */
function pseudoSubmit(device, commandEncoder) {
  device.pushErrorScope('validation');
  commandEncoder.clearBuffer(device.createBuffer({size: 0, usage: 0}), 0, 0);
  device.popErrorScope().then(() => {});
}

/**
 * @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 adapter0 = await navigator.gpu.requestAdapter(
{
}
);
let device0 = await adapter0.requestDevice({
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'shader-f16',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 4,
maxColorAttachmentBytesPerSample: 57,
maxVertexAttributes: 22,
maxVertexBufferArrayStride: 41093,
maxStorageTexturesPerShaderStage: 44,
maxStorageBuffersPerShaderStage: 35,
maxDynamicStorageBuffersPerPipelineLayout: 9462,
maxBindingsPerBindGroup: 2153,
maxTextureDimension1D: 10480,
maxTextureDimension2D: 13445,
maxVertexBuffers: 12,
minUniformBufferOffsetAlignment: 128,
maxUniformBufferBindingSize: 24866923,
maxUniformBuffersPerShaderStage: 30,
maxInterStageShaderVariables: 82,
maxInterStageShaderComponents: 92,
maxSamplersPerShaderStage: 22,
},
});
let texture0 = device0.createTexture(
{
label: '\u077c\u717d\u0daf\u{1fe85}\u{1fcca}\uce5a\u0702\u0075\u0ec6',
size: [2811],
sampleCount: 1,
dimension: '1d',
format: 'bgra8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'bgra8unorm-srgb'
],
}
);
let renderBundleEncoder0 = device0.createRenderBundleEncoder(
{
label: '\u0031\u{1f807}\u{1f889}\u260a\u2bff\ub703\u9441\u2793\ud3ed\u7204',
colorFormats: [
undefined,
'rg16uint',
'rg11b10ufloat',
'rg8uint'
],
sampleCount: 641,
stencilReadOnly: true,
}
);
let canvas0 = document.createElement('canvas');
let texture1 = device0.createTexture(
{
label: '\u3965\uc6c2\u0ef3\ua3af',
size: {width: 561, height: 1, depthOrArrayLayers: 69},
mipLevelCount: 2,
dimension: '3d',
format: 'rg16sint',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'rg16sint',
'rg16sint',
'rg16sint'
],
}
);
let renderBundle0 = renderBundleEncoder0.finish(
{
label: '\u{1ffa7}\uc15b'
}
);
let renderBundleEncoder1 = device0.createRenderBundleEncoder(
{
colorFormats: [
'rgba32uint'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 40,
stencilReadOnly: false,
}
);
let imageBitmap0 = await createImageBitmap(canvas0);
let querySet0 = device0.createQuerySet({
type: 'occlusion',
count: 428,
});
try {
await device0.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(canvas0);
canvas0.width = 489;
let videoFrame0 = new VideoFrame(canvas0, {timestamp: 0});
let commandEncoder0 = device0.createCommandEncoder(
{
}
);
let texture2 = device0.createTexture(
{
label: '\u784e\u5c78\u174d\ua274\u057e\uea34\u8ed8\u08cd\u{1f75a}\u09b3\ufaa0',
size: {width: 10306, height: 45, depthOrArrayLayers: 44},
mipLevelCount: 3,
format: 'rg8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
}
);
let offscreenCanvas0 = new OffscreenCanvas(808, 121);
let img0 = await imageWithData(128, 118, '#58b79216', '#12f08c9d');
let imageBitmap1 = await createImageBitmap(canvas0);
try {
renderBundleEncoder1.setVertexBuffer(
86,
undefined,
3840574286
);
} catch {}
let querySet1 = device0.createQuerySet({
label: '\u{1fe9c}\u6c7e\ua8ba\u{1f8f5}\u32e6\ube48\u{1f97e}',
type: 'occlusion',
count: 2316,
});
let textureView0 = texture1.createView(
{
label: '\u{1f81f}\u0c16\u09fe\u108f\u490e\u{1fd7b}\u02d3\u0f10',
aspect: 'all',
baseMipLevel: 1,
}
);
let renderBundleEncoder2 = device0.createRenderBundleEncoder(
{
label: '\u0289\u05b7\ud84f\u7cac\ud01d\u2494\uaf65\u{1f629}\u{1fb99}\ucd03\u{1f951}',
colorFormats: [
undefined,
'rgb10a2unorm',
'rgba8uint',
'bgra8unorm',
'rgb10a2uint',
'r32float',
'rg8sint',
'r16sint'
],
sampleCount: 989,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let gpuCanvasContext0 = canvas0.getContext('webgpu');
let querySet2 = device0.createQuerySet({
type: 'occlusion',
count: 1597,
});
let computePassEncoder0 = commandEncoder0.beginComputePass(
{

}
);
try {
gpuCanvasContext0.unconfigure();
} catch {}
gc();
let adapter1 = await navigator.gpu.requestAdapter();
pseudoSubmit(device0, commandEncoder0);
let sampler0 = device0.createSampler(
{
label: '\ue6ac\ud42c',
addressModeU: 'mirror-repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 93.043,
lodMaxClamp: 93.250,
maxAnisotropy: 1,
}
);
let sampler1 = device0.createSampler(
{
label: '\ua9d6\ua977\u{1ff86}\u{1fdd8}\uddff',
addressModeU: 'mirror-repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 85.629,
lodMaxClamp: 90.777,
maxAnisotropy: 17,
}
);
try {
renderBundleEncoder2.setVertexBuffer(
86,
undefined,
1680654657
);
} catch {}
try {
await device0.queue.onSubmittedWorkDone();
} catch {}
let texture3 = device0.createTexture(
{
label: '\u59af\u0db8\u{1fd5c}\ub5bc\u5fbe\u063e\u{1fd48}',
size: [689, 1, 207],
mipLevelCount: 10,
dimension: '3d',
format: 'r32sint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r32sint',
'r32sint',
'r32sint'
],
}
);
let renderBundle1 = renderBundleEncoder2.finish(
{
label: '\u{1ff3d}\u45d7\uc776\ub5bc\u{1faef}\u{1fb4a}\u0f02\u0526\uda50\u0a76'
}
);
let imageData0 = new ImageData(140, 168);
try {
offscreenCanvas0.getContext('webgl2');
} catch {}
let bindGroupLayout0 = device0.createBindGroupLayout(
{
label: '\ud9a8\u{1f923}\u456e\ud0ce\u{1fb14}\u{1f95c}\u{1fb46}\u{1f9dd}',
entries: [
{
binding: 1287,
visibility: GPUShaderStage.FRAGMENT,
sampler: { type: 'filtering' },
},
{
binding: 1264,
visibility: GPUShaderStage.VERTEX,
externalTexture: {},
},
{
binding: 619,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
texture: { viewDimension: '2d', sampleType: 'depth', multisampled: true },
}
],
}
);
let pipelineLayout0 = device0.createPipelineLayout(
{
label: '\u00a5\u{1f916}\uecf4\ue42d\u{1fdb2}\u0f9d\u{1fb3e}\u05c1\ub392\u{1f91e}\uf6be',
bindGroupLayouts: [
bindGroupLayout0
]
}
);
let querySet3 = device0.createQuerySet({
label: '\u6d95\u0636\ufbd4\u{1fbb9}\uf07a\u3015\u0438\ub8a9\u54c8\ue4d5',
type: 'occlusion',
count: 53,
});
let renderBundle2 = renderBundleEncoder0.finish(
{

}
);
let sampler2 = device0.createSampler(
{
label: '\u6c35\u4c4a\u0e8f\u0396\u0466\u0902\u{1fb63}',
addressModeU: 'repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
mipmapFilter: 'nearest',
lodMinClamp: 92.955,
lodMaxClamp: 93.609,
compare: 'never',
}
);
let externalTexture0 = device0.importExternalTexture(
{
label: '\ufabe\u03fd',
source: videoFrame0,
colorSpace: 'srgb',
}
);
document.body.prepend(canvas0);
let shaderModule0 = device0.createShaderModule(
{
code: `@group(0) @binding(1287)
var<storage, read_write> global0: array<u32>;
@group(0) @binding(619)
var<storage, read_write> parameter0: array<u32>;
@group(0) @binding(1264)
var<storage, read_write> global1: array<u32>;

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

struct S1 {
@location(65) f0: vec3<i32>,
@location(4) f1: i32,
@location(40) f2: vec4<u32>,
@location(24) f3: f16,
@location(20) f4: vec4<f32>,
@location(61) f5: f16,
@location(11) f6: vec4<i32>,
@location(17) f7: f32,
@location(75) f8: f32,
@location(43) f9: vec4<f16>,
@location(19) f10: vec4<i32>,
@builtin(sample_index) f11: u32,
@location(69) f12: f16,
@location(80) f13: i32,
@location(67) f14: vec3<f16>,
@location(23) f15: vec2<f16>,
@location(14) f16: u32,
@builtin(front_facing) f17: bool,
@location(34) f18: f32,
@location(27) f19: vec2<f32>,
@location(12) f20: vec3<u32>,
@location(16) f21: vec2<u32>,
@location(13) f22: i32,
@builtin(sample_mask) f23: u32,
@location(42) f24: u32,
@location(74) f25: vec3<i32>,
@location(57) f26: vec3<i32>,
@location(22) f27: vec2<i32>,
@location(45) f28: vec2<f16>,
@location(7) f29: vec2<f16>,
@builtin(position) f30: vec4<f32>,
@location(9) f31: vec4<u32>,
@location(54) f32: vec3<u32>,
@location(37) f33: vec3<u32>
}
struct FragmentOutput0 {
@location(5) f0: vec2<i32>,
@location(6) f1: vec3<u32>
}

@fragment
fn fragment0(a0: S1, @location(26) a1: vec3<f16>, @location(53) a2: vec4<f32>, @location(50) a3: vec2<u32>, @location(48) a4: vec3<u32>, @location(66) a5: vec3<u32>, @location(18) a6: i32, @location(35) a7: vec2<u32>, @location(63) a8: f32, @location(60) a9: vec4<f32>) -> FragmentOutput0 {
return FragmentOutput0();
}

struct S0 {
@builtin(instance_index) f0: u32,
@location(16) f1: f32,
@location(7) f2: vec3<f16>,
@location(15) f3: f16,
@location(21) f4: vec3<f32>,
@location(18) f5: vec4<i32>
}
struct VertexOutput0 {
@location(60) f0: vec4<f32>,
@location(24) f1: f16,
@location(80) f2: i32,
@location(43) f3: vec4<f16>,
@location(35) f4: vec2<u32>,
@location(57) f5: vec3<i32>,
@location(20) f6: vec4<f32>,
@location(11) f7: vec4<i32>,
@location(63) f8: f32,
@location(19) f9: vec4<i32>,
@location(12) f10: vec3<u32>,
@location(54) f11: vec3<u32>,
@location(37) f12: vec3<u32>,
@location(65) f13: vec3<i32>,
@location(69) f14: f16,
@location(40) f15: vec4<u32>,
@builtin(position) f16: vec4<f32>,
@location(16) f17: vec2<u32>,
@location(14) f18: u32,
@location(22) f19: vec2<i32>,
@location(45) f20: vec2<f16>,
@location(27) f21: vec2<f32>,
@location(7) f22: vec2<f16>,
@location(23) f23: vec2<f16>,
@location(61) f24: f16,
@location(13) f25: i32,
@location(42) f26: u32,
@location(4) f27: i32,
@location(53) f28: vec4<f32>,
@location(66) f29: vec3<u32>,
@location(48) f30: vec3<u32>,
@location(67) f31: vec3<f16>,
@location(34) f32: f32,
@location(17) f33: f32,
@location(9) f34: vec4<u32>,
@location(50) f35: vec2<u32>,
@location(74) f36: vec3<i32>,
@location(18) f37: i32,
@location(26) f38: vec3<f16>,
@location(75) f39: f32
}

@vertex
fn vertex0(@location(3) a0: vec2<u32>, @location(4) a1: vec2<f16>, a2: S0, @location(0) a3: vec2<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
sourceMap: {},
hints: {},
}
);
let renderBundle3 = renderBundleEncoder2.finish(
{
label: '\u{1f703}\u06c7\u3b3f\uaa86\u04ff\u0163\u{1f6df}\u0939\u5d11'
}
);
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let canvas1 = document.createElement('canvas');
let pipelineLayout1 = device0.createPipelineLayout(
{
label: '\u{1f6da}\u0e7d\u38af\u0f58\u37ea\u2847',
bindGroupLayouts: [
bindGroupLayout0,
bindGroupLayout0,
bindGroupLayout0
]
}
);
let texture4 = device0.createTexture(
{
size: {width: 132, height: 211, depthOrArrayLayers: 245},
mipLevelCount: 5,
format: 'bgra8unorm-srgb',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'bgra8unorm',
'bgra8unorm',
'bgra8unorm-srgb'
],
}
);
let textureView1 = texture0.createView(
{
format: 'bgra8unorm-srgb',
}
);
let renderBundleEncoder3 = device0.createRenderBundleEncoder(
{
label: '\u{1fa97}\u{1fa86}\uf9a5\u0ddc\ud8a1\u6b2c',
colorFormats: [
'rgba32uint',
'bgra8unorm',
'rg8sint',
'rgba8unorm',
'r32sint',
'r32uint'
],
sampleCount: 416,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle4 = renderBundleEncoder0.finish(
{
label: '\u{1f84a}\u047b\uae81\u6aa5\ud9ad\u0add\u7fd3\uf472\ue2dc'
}
);
let sampler3 = device0.createSampler(
{
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMaxClamp: 44.923,
}
);
try {
renderBundleEncoder1.setVertexBuffer(
66,
undefined,
735869037,
479321587
);
} catch {}
let shaderModule1 = device0.createShaderModule(
{
label: '\uaed7\u0a4c\u48b4\u{1ffcd}\u{1fe27}\u{1f763}\u57e5\u4db9\u{1feeb}\u1e01',
code: `@group(0) @binding(619)
var<storage, read_write> global2: array<u32>;
@group(0) @binding(1264)
var<storage, read_write> field0: array<u32>;
@group(0) @binding(1287)
var<storage, read_write> function0: array<u32>;

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

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

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

struct S2 {
@location(6) f0: u32,
@location(17) f1: vec2<f32>,
@location(2) f2: vec4<u32>,
@location(0) f3: vec4<i32>
}

@vertex
fn vertex0(@location(8) a0: vec3<f16>, @location(16) a1: u32, @location(7) a2: vec3<f16>, @location(20) a3: vec2<u32>, @location(19) a4: vec4<f32>, @location(3) a5: vec2<f16>, @location(10) a6: u32, a7: S2, @location(11) a8: vec2<i32>, @location(14) a9: i32) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
sourceMap: {},
hints: {},
}
);
let sampler4 = device0.createSampler(
{
label: '\ud64c\u0dff\u016a',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 78.997,
lodMaxClamp: 89.584,
compare: 'greater',
}
);
try {
gpuCanvasContext0.configure(
{
device: device0,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [
'eac-rg11unorm',
'rgba8unorm'
],
colorSpace: 'display-p3',
}
);
} catch {}
let promise0 = device0.createRenderPipelineAsync(
{
layout: pipelineLayout1,
vertex: {
module: shaderModule1,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint32x3',
offset: 22468,
shaderLocation: 2,
},
{
format: 'uint8x2',
offset: 12876,
shaderLocation: 10,
},
{
format: 'float32x2',
offset: 12320,
shaderLocation: 3,
},
{
format: 'uint32',
offset: 33396,
shaderLocation: 20,
},
{
format: 'snorm16x2',
offset: 36288,
shaderLocation: 8,
},
{
format: 'unorm8x4',
offset: 20632,
shaderLocation: 19,
},
{
format: 'float32',
offset: 36124,
shaderLocation: 7,
},
{
format: 'sint8x4',
offset: 35872,
shaderLocation: 14,
}
],
},
{
arrayStride: 3604,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x4',
offset: 2312,
shaderLocation: 6,
},
{
format: 'sint32x2',
offset: 2928,
shaderLocation: 11,
},
{
format: 'unorm8x4',
offset: 516,
shaderLocation: 17,
},
{
format: 'sint32x3',
offset: 2564,
shaderLocation: 0,
}
],
},
{
arrayStride: 2640,
attributes: [

],
},
{
arrayStride: 27932,
attributes: [

],
},
{
arrayStride: 25740,
stepMode: 'vertex',
attributes: [
{
format: 'uint32x2',
offset: 14564,
shaderLocation: 16,
}
],
}
]
},
fragment: {
module: shaderModule1,
entryPoint: 'fragment0',
constants: {},
targets: [
{
blend: {
color: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
},
format: 'rg16float',
}
],
},
depthStencil: {
format: 'stencil8',
depthWriteEnabled: false,
depthCompare: 'always',
stencilFront: {
compare: 'greater-equal',
failOp: 'replace',
depthFailOp: 'zero',
passOp: 'increment-clamp',
},
stencilBack: {
compare: 'greater',
failOp: 'decrement-clamp',
depthFailOp: 'decrement-wrap',
passOp: 'replace',
},
stencilReadMask: 1525,
stencilWriteMask: 1804,
depthBiasSlopeScale: 13,
depthBiasClamp: 69,
},
}
);
let img1 = await imageWithData(111, 49, '#e547a6d9', '#45a3c9b0');
let renderBundleEncoder4 = device0.createRenderBundleEncoder(
{
colorFormats: [
'rgba8unorm',
'rgb10a2uint',
'rgba16sint',
'rg8uint',
undefined
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 190,
stencilReadOnly: false,
}
);
try {
renderBundleEncoder3.setVertexBuffer(
22,
undefined
);
} catch {}
let commandEncoder1 = device0.createCommandEncoder(
{
label: '\ue5bf\u2c92\u7d51\u0b8b\u{1fcc8}\ud8c2\u1674\ue577\u{1fdc6}\u5497\u3c06',
}
);
let computePassEncoder1 = commandEncoder1.beginComputePass(
{
label: '\u0562\u{1f93b}\u9c96\u{1fc44}\u{1ffe7}\u4524\u369b\u0597'
}
);
try {
renderBundleEncoder3.setVertexBuffer(
75,
undefined,
1414454643,
2016163141
);
} catch {}
let pipeline0 = device0.createRenderPipeline(
{
label: '\uef85\u{1ffeb}\u{1fbf8}\u{1f782}',
layout: pipelineLayout0,
vertex: {
module: shaderModule1,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 8496,
attributes: [
{
format: 'sint32x2',
offset: 1464,
shaderLocation: 0,
},
{
format: 'uint32x4',
offset: 5008,
shaderLocation: 16,
},
{
format: 'float16x2',
offset: 144,
shaderLocation: 19,
},
{
format: 'snorm8x2',
offset: 7174,
shaderLocation: 7,
},
{
format: 'uint16x4',
offset: 7832,
shaderLocation: 6,
}
],
},
{
arrayStride: 18804,
stepMode: 'instance',
attributes: [
{
format: 'unorm8x2',
offset: 5078,
shaderLocation: 17,
},
{
format: 'uint8x2',
offset: 11020,
shaderLocation: 10,
},
{
format: 'sint16x2',
offset: 9020,
shaderLocation: 11,
},
{
format: 'float32x3',
offset: 9152,
shaderLocation: 8,
},
{
format: 'uint16x4',
offset: 12120,
shaderLocation: 20,
},
{
format: 'unorm16x2',
offset: 10844,
shaderLocation: 3,
},
{
format: 'sint8x2',
offset: 2572,
shaderLocation: 14,
}
],
},
{
arrayStride: 17624,
attributes: [

],
},
{
arrayStride: 27016,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 36512,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 2336,
shaderLocation: 2,
}
],
}
]
},
multisample: {
count: 4,
},
fragment: {
module: shaderModule1,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r8unorm',
writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
{
format: 'r32uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'stencil8',
stencilFront: {
compare: 'equal',
failOp: 'invert',
depthFailOp: 'increment-wrap',
passOp: 'decrement-clamp',
},
stencilBack: {
failOp: 'decrement-clamp',
depthFailOp: 'increment-clamp',
passOp: 'zero',
},
stencilWriteMask: 678,
depthBias: 64,
depthBiasSlopeScale: 3,
depthBiasClamp: 27,
},
}
);
gc();
let pipelineLayout2 = device0.createPipelineLayout(
{
label: '\u170d\u{1fba6}\u08f1\uad10\u03ab\uf915\u232d\u0636\uc945\u0050\u08cd',
bindGroupLayouts: [
bindGroupLayout0
]
}
);
let querySet4 = device0.createQuerySet({
label: '\u0542\ued5a\u{1f8b6}\u41c0\u68de\u0a65\u{1f64c}\u8764\u{1fe69}\u054c',
type: 'occlusion',
count: 2629,
});
let renderBundle5 = renderBundleEncoder1.finish(
{
label: '\u0bc4\u84dc\u7eb7\u0ea0\u086c\u{1fb6c}\uc56c\u{1ff56}\ufccc'
}
);
try {
renderBundleEncoder4.setVertexBuffer(
8,
undefined,
852779166,
2119715626
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 1026, y: 0, z: 0 },
  aspect: 'all',
},
new Float64Array(new ArrayBuffer(8)),
/* required buffer size: 500 */{
offset: 500,
},
{width: 1581, height: 1, depthOrArrayLayers: 0}
);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
let canvas2 = document.createElement('canvas');
let texture5 = device0.createTexture(
{
size: {width: 7506, height: 235, depthOrArrayLayers: 180},
mipLevelCount: 11,
format: 'depth32float-stencil8',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
}
);
let renderBundleEncoder5 = device0.createRenderBundleEncoder(
{
colorFormats: [
'rgba16sint',
'r32float',
'r16float',
'rg32float',
'r16float',
'rgba32sint'
],
sampleCount: 838,
depthReadOnly: true,
}
);
try {
device0.queue.writeTexture(
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 1940, y: 0, z: 1 },
  aspect: 'all',
},
new ArrayBuffer(48),
/* required buffer size: 958 */{
offset: 958,
},
{width: 136, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let bindGroupLayout1 = device0.createBindGroupLayout(
{
label: '\u8b65\u{1f7c6}\u{1fa45}\u9cb2\u0b09\ue452\u7abf',
entries: [
{
binding: 1032,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
storageTexture: { format: 'rgba16sint', access: 'write-only', viewDimension: '2d' },
},
{
binding: 1192,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
}
],
}
);
pseudoSubmit(device0, commandEncoder1);
let pipeline1 = device0.createComputePipeline(
{
label: '\u06d2\u0d33\u{1fb90}',
layout: pipelineLayout2,
compute: {
module: shaderModule1,
entryPoint: 'compute0',
constants: {},
},
}
);
let adapter2 = await navigator.gpu.requestAdapter(
{
}
);
let texture6 = device0.createTexture(
{
label: '\u76bf\u9c82\u08ef\u{1f63d}\u{1f8d1}\u057c',
size: [18, 115, 1],
mipLevelCount: 5,
format: 'rgb10a2unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgb10a2unorm'
],
}
);
let sampler5 = device0.createSampler(
{
label: '\u0983\u0b0d\u0b68\u8aa5\u{1f601}\u{1fe47}\ud3c4\ua340\u0ae0\u{1fc8c}\u{1fc44}',
addressModeU: 'clamp-to-edge',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 4.744,
lodMaxClamp: 20.139,
compare: 'never',
maxAnisotropy: 2,
}
);
let gpuCanvasContext1 = canvas1.getContext('webgpu');
let imageBitmap2 = await createImageBitmap(canvas0);
let renderBundle6 = renderBundleEncoder3.finish(
{
label: '\u{1f9e1}\u011b\u{1feea}\u0537\u74ed\uf589\u09a0\u0967\u0787'
}
);
let promise1 = device0.popErrorScope();
try {
gpuCanvasContext0.configure(
{
device: device0,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'astc-12x10-unorm'
],
alphaMode: 'opaque',
}
);
} catch {}
let gpuCanvasContext2 = canvas2.getContext('webgpu');
let buffer0 = device0.createBuffer(
{
label: '\uc823\u{1f917}\u{1fa41}\ucccd\u{1f8c7}\u0b31\u02a0\u3229\ub025\u0e56\u2d7b',
size: 47584,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
mappedAtCreation: true,
}
);
try {
device0.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext0.configure(
{
device: device0,
format: 'bgra8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r8snorm',
'eac-rg11snorm'
],
colorSpace: 'srgb',
alphaMode: 'opaque',
}
);
} catch {}
let shaderModule2 = device0.createShaderModule(
{
label: '\u{1faaf}\u3370\u86bd\ue182\u0e2e\ue5e5\u{1f77f}\u{1febb}\ud2ad\u{1fc96}',
code: `@group(0) @binding(1264)
var<storage, read_write> local0: array<u32>;
@group(0) @binding(619)
var<storage, read_write> i0: array<u32>;
@group(0) @binding(1287)
var<storage, read_write> i1: array<u32>;

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

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

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

struct S3 {
@location(15) f0: f16,
@location(12) f1: vec3<u32>,
@location(2) f2: u32,
@location(6) f3: vec3<i32>,
@location(18) f4: vec4<u32>,
@location(8) f5: vec4<u32>
}
struct VertexOutput0 {
@location(72) f40: vec2<f32>,
@location(46) f41: vec2<f16>,
@location(68) f42: vec4<i32>,
@location(56) f43: i32,
@location(23) f44: u32,
@location(6) f45: vec3<f32>,
@location(70) f46: vec4<f16>,
@location(24) f47: vec2<u32>,
@location(73) f48: vec2<f32>,
@builtin(position) f49: vec4<f32>,
@location(37) f50: vec3<f16>,
@location(0) f51: vec4<f32>,
@location(3) f52: i32,
@location(14) f53: vec2<u32>,
@location(66) f54: vec2<u32>,
@location(5) f55: i32,
@location(80) f56: i32,
@location(8) f57: vec3<i32>,
@location(17) f58: u32,
@location(52) f59: i32,
@location(7) f60: vec3<i32>,
@location(13) f61: vec2<f16>,
@location(78) f62: vec2<u32>,
@location(40) f63: i32,
@location(42) f64: vec4<f32>,
@location(38) f65: vec2<u32>,
@location(48) f66: f16,
@location(9) f67: vec2<f16>,
@location(2) f68: vec3<f16>,
@location(49) f69: vec2<i32>,
@location(58) f70: vec2<f32>,
@location(65) f71: u32,
@location(76) f72: vec3<i32>,
@location(11) f73: vec3<f32>
}

@vertex
fn vertex0(@location(19) a0: vec4<f16>, @location(0) a1: vec2<u32>, @location(5) a2: vec3<i32>, @location(4) a3: vec4<i32>, @location(17) a4: vec3<f16>, a5: S3, @builtin(vertex_index) a6: u32, @location(20) a7: vec3<f32>, @location(7) a8: vec4<f32>, @location(13) a9: vec4<f16>, @builtin(instance_index) a10: u32, @location(21) a11: f32, @location(16) a12: vec2<f32>, @location(11) a13: i32, @location(1) a14: vec3<f32>, @location(3) a15: vec4<i32>, @location(10) a16: vec4<u32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
sourceMap: {},
}
);
let texture7 = device0.createTexture(
{
label: '\u0594\u743e\u5121\u552d',
size: {width: 234, height: 1, depthOrArrayLayers: 944},
mipLevelCount: 6,
dimension: '3d',
format: 'r32float',
usage: GPUTextureUsage.STORAGE_BINDING,
viewFormats: [

],
}
);
let sampler6 = device0.createSampler(
{
label: '\u8de7\u5094\u4748',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 25.524,
lodMaxClamp: 43.371,
}
);
try {
device0.pushErrorScope('out-of-memory');
} catch {}
let videoFrame1 = new VideoFrame(offscreenCanvas0, {timestamp: 0});
let bindGroupLayout2 = pipeline0.getBindGroupLayout(0);
let texture8 = device0.createTexture(
{
label: '\u{1fd2e}\u{1f9dc}\u04f6\u96ce',
size: [9257, 233, 1],
mipLevelCount: 4,
dimension: '2d',
format: 'depth32float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
}
);
try {
buffer0.unmap();
} catch {}
try {
adapter1.label = '\ub76f\u{1f935}\u0ac7\udd10\u{1fc24}\u{1fb74}\u0d70';
} catch {}
let sampler7 = device0.createSampler(
{
label: '\u0d82\u{1f646}\u982e\ub2f1\u444d\u06dd',
addressModeU: 'repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMaxClamp: 68.789,
}
);
try {
renderBundleEncoder4.setVertexBuffer(
10,
undefined,
1521712523
);
} catch {}
try {
renderBundleEncoder5.pushDebugGroup(
'\u0eb0'
);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
gc();
let videoFrame2 = new VideoFrame(imageBitmap0, {timestamp: 0});
let shaderModule3 = device0.createShaderModule(
{
label: '\u{1f724}\u5bce',
code: `@group(0) @binding(1264)
var<storage, read_write> local1: array<u32>;
@group(0) @binding(1287)
var<storage, read_write> field1: array<u32>;

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

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

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

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

@vertex
fn vertex0(@location(17) a0: vec3<f32>, a1: S4, @location(8) a2: u32, @location(0) a3: vec3<f16>, @location(6) a4: i32, @location(20) a5: vec4<i32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
sourceMap: {},
hints: {},
}
);
let sampler8 = device0.createSampler(
{
label: '\u0216\ud233',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
minFilter: 'nearest',
compare: 'always',
}
);
try {
buffer0.unmap();
} catch {}
try {
renderBundleEncoder4.insertDebugMarker(
'\u6227'
);
} catch {}
let pipeline2 = await device0.createRenderPipelineAsync(
{
label: '\u{1fd88}\u{1f7d6}\u0a69\ud5a6\u0db6\u{1f95a}\u4534',
layout: pipelineLayout0,
vertex: {
module: shaderModule0,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 9448,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x2',
offset: 7892,
shaderLocation: 3,
},
{
format: 'unorm8x4',
offset: 2812,
shaderLocation: 16,
},
{
format: 'sint32x3',
offset: 2068,
shaderLocation: 18,
},
{
format: 'float32x3',
offset: 6592,
shaderLocation: 7,
},
{
format: 'unorm8x2',
offset: 9126,
shaderLocation: 15,
},
{
format: 'snorm16x4',
offset: 952,
shaderLocation: 21,
}
],
},
{
arrayStride: 34652,
stepMode: 'instance',
attributes: [
{
format: 'float32x3',
offset: 8396,
shaderLocation: 0,
},
{
format: 'float32',
offset: 15368,
shaderLocation: 4,
}
],
}
]
},
primitive: {
frontFace: 'ccw',
cullMode: 'back',
unclippedDepth: true,
},
fragment: {
module: shaderModule0,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined,
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'always',
stencilFront: {
compare: 'less-equal',
failOp: 'decrement-wrap',
depthFailOp: 'invert',
passOp: 'increment-clamp',
},
stencilBack: {
compare: 'greater',
failOp: 'replace',
depthFailOp: 'increment-wrap',
passOp: 'decrement-clamp',
},
stencilWriteMask: 3295,
depthBias: 93,
depthBiasClamp: 5,
},
}
);
try {
await promise1;
} catch {}
let texture9 = device0.createTexture(
{
label: '\u5eb0\u3961\u2dc1\u4873\u{1fd22}\u0495\u0fa5\u3575\ub076\u{1fc9e}',
size: {width: 130, height: 1, depthOrArrayLayers: 589},
mipLevelCount: 4,
dimension: '3d',
format: 'rg8sint',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'rg8sint',
'rg8sint',
'rg8sint'
],
}
);
let textureView2 = texture7.createView(
{
label: '\u530f\u{1f7cd}\u{1fab8}',
baseMipLevel: 1,
mipLevelCount: 1,
}
);
let renderBundleEncoder6 = device0.createRenderBundleEncoder(
{
label: '\u04b5\uc146\u07e4\u{1fac0}\u79fe\u7b72\u{1f8c1}',
colorFormats: [
'rgba8unorm',
'rgba8unorm',
'rg16sint',
'rg16sint'
],
sampleCount: 313,
}
);
try {
texture2.destroy();
} catch {}
let buffer1 = device0.createBuffer(
{
label: '\udf6b\u{1f7d9}',
size: 47576,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.UNIFORM,
}
);
let renderBundleEncoder7 = device0.createRenderBundleEncoder(
{
label: '\u0a50\u0fc4\u{1f94c}\u{1fa1c}',
colorFormats: [
'rg11b10ufloat'
],
sampleCount: 862,
depthReadOnly: true,
}
);
let renderBundle7 = renderBundleEncoder1.finish(
{
label: '\u09cf\u9ff0\u0ec8\u0aa1\u51d6\u08d2\u9fe0\ubea4'
}
);
try {
await buffer0.mapAsync(
GPUMapMode.READ
);
} catch {}
try {
gpuCanvasContext2.configure(
{
device: device0,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [

],
colorSpace: 'display-p3',
}
);
} catch {}
let pipeline3 = device0.createComputePipeline(
{
label: '\u{1f764}\u238a\u9437\u{1f622}\u0da5\u0b39\u6efd\u7294\u3cd6\u{1f9c3}',
layout: pipelineLayout0,
compute: {
module: shaderModule3,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline4 = device0.createRenderPipeline(
{
label: '\u6e8a\u{1f6a1}\ua9e7',
layout: pipelineLayout2,
vertex: {
module: shaderModule0,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 37764,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 2204,
attributes: [
{
format: 'unorm8x4',
offset: 1252,
shaderLocation: 0,
},
{
format: 'unorm8x4',
offset: 220,
shaderLocation: 4,
},
{
format: 'sint32x4',
offset: 1176,
shaderLocation: 18,
}
],
},
{
arrayStride: 26040,
attributes: [
{
format: 'unorm16x4',
offset: 17848,
shaderLocation: 21,
},
{
format: 'uint8x2',
offset: 7790,
shaderLocation: 3,
}
],
},
{
arrayStride: 6492,
attributes: [
{
format: 'float32',
offset: 1364,
shaderLocation: 15,
}
],
},
{
arrayStride: 5076,
stepMode: 'instance',
attributes: [
{
format: 'float16x2',
offset: 1408,
shaderLocation: 16,
},
{
format: 'unorm16x2',
offset: 612,
shaderLocation: 7,
}
],
}
]
},
primitive: {
topology: 'line-list',
frontFace: 'ccw',
cullMode: 'front',
unclippedDepth: true,
},
multisample: {
mask: 0xd3b843e,
},
fragment: {
module: shaderModule0,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined,
undefined,
undefined,
undefined,
undefined,
{
format: 'rg32sint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
},
{
format: 'rg16uint',
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'less',
stencilFront: {
compare: 'equal',
failOp: 'increment-clamp',
depthFailOp: 'invert',
passOp: 'invert',
},
stencilBack: {
failOp: 'increment-wrap',
depthFailOp: 'increment-wrap',
passOp: 'decrement-clamp',
},
stencilReadMask: 1770,
stencilWriteMask: 2589,
depthBiasSlopeScale: 19,
},
}
);
let commandEncoder2 = device0.createCommandEncoder(
{
label: '\u822b\ua380\u8479\u6d3e\u1298\uaf4a',
}
);
let sampler9 = device0.createSampler(
{
label: '\u830c\u{1f6d5}\u06bb\u{1ffef}\u9d0b\u0fde\u{1f60b}\ufddb',
addressModeU: 'mirror-repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 25.228,
lodMaxClamp: 41.937,
compare: 'less',
maxAnisotropy: 18,
}
);
try {
commandEncoder2.copyTextureToTexture(
{
  texture: texture8,
  mipLevel: 1,
  origin: { x: 2291, y: 92, z: 0 },
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 3,
  origin: { x: 0, y: 2, z: 0 },
  aspect: 'all',
},
{width: 1157, height: 0, depthOrArrayLayers: 1}
);
} catch {}
try {
commandEncoder2.clearBuffer(
buffer0
);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture3,
  mipLevel: 9,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
new ArrayBuffer(0),
/* required buffer size: 564 */{
offset: 560,
},
{width: 1, height: 1, depthOrArrayLayers: 1}
);
} catch {}
try {
await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline5 = device0.createRenderPipeline(
{
label: '\u390a\ub7e9',
layout: pipelineLayout2,
vertex: {
module: shaderModule3,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 13428,
stepMode: 'instance',
attributes: [
{
format: 'unorm16x2',
offset: 4168,
shaderLocation: 2,
},
{
format: 'uint32x2',
offset: 4788,
shaderLocation: 13,
},
{
format: 'snorm8x4',
offset: 2040,
shaderLocation: 1,
},
{
format: 'sint32x4',
offset: 2280,
shaderLocation: 20,
},
{
format: 'sint32',
offset: 12136,
shaderLocation: 11,
},
{
format: 'sint32',
offset: 9952,
shaderLocation: 3,
},
{
format: 'float32x3',
offset: 9268,
shaderLocation: 0,
},
{
format: 'float16x2',
offset: 9560,
shaderLocation: 7,
},
{
format: 'sint8x2',
offset: 9704,
shaderLocation: 9,
},
{
format: 'unorm16x4',
offset: 1296,
shaderLocation: 12,
},
{
format: 'unorm16x4',
offset: 10396,
shaderLocation: 17,
},
{
format: 'uint32x4',
offset: 7976,
shaderLocation: 8,
},
{
format: 'uint32x4',
offset: 2740,
shaderLocation: 14,
},
{
format: 'float32',
offset: 9376,
shaderLocation: 21,
},
{
format: 'snorm8x4',
offset: 8648,
shaderLocation: 4,
},
{
format: 'sint32x4',
offset: 436,
shaderLocation: 10,
},
{
format: 'sint16x2',
offset: 4244,
shaderLocation: 15,
},
{
format: 'sint16x4',
offset: 8576,
shaderLocation: 6,
},
{
format: 'sint8x2',
offset: 8104,
shaderLocation: 16,
},
{
format: 'uint16x4',
offset: 10256,
shaderLocation: 18,
}
],
},
{
arrayStride: 24016,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 31512,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 30800,
stepMode: 'instance',
attributes: [
{
format: 'uint8x4',
offset: 19468,
shaderLocation: 5,
},
{
format: 'float16x2',
offset: 7672,
shaderLocation: 19,
}
],
}
]
},
primitive: {
frontFace: 'cw',
cullMode: 'front',
unclippedDepth: true,
},
multisample: {
count: 1,
},
fragment: {
module: shaderModule3,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r32float',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
}
],
},
}
);
document.body.prepend(img0);
let renderBundleEncoder8 = device0.createRenderBundleEncoder(
{
label: '\u02f4\uf0a0\u973b\u3416\u0955\u4247',
colorFormats: [
'rg32float',
'r8uint',
'rg8uint',
'rg32float',
'r8sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 842,
depthReadOnly: true,
}
);
let renderBundle8 = renderBundleEncoder3.finish(
{
label: '\ue235\u860e\u9c11\u{1f7b0}\u5e75\u0b8b\ufa3a\u2bef\u{1fddc}\u90bb\ueb35'
}
);
let canvas3 = document.createElement('canvas');
let img2 = await imageWithData(33, 28, '#fc6d013f', '#bbe53883');
try {
window.someLabel = pipeline5.label;
} catch {}
let commandEncoder3 = device0.createCommandEncoder(
{
}
);
let textureView3 = texture1.createView(
{
label: '\u0a00\u{1ff38}\u0574\uf0ae\u{1f69d}\u2837\uea39',
mipLevelCount: 1,
}
);
let renderBundle9 = renderBundleEncoder8.finish(
{

}
);
let pipeline6 = device0.createRenderPipeline(
{
label: '\u0372\u779a\u0e49\u{1f6d9}\ub481\ub6b5\u20c0',
layout: pipelineLayout0,
vertex: {
module: shaderModule2,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 22300,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x4',
offset: 1612,
shaderLocation: 0,
},
{
format: 'uint16x4',
offset: 19380,
shaderLocation: 10,
},
{
format: 'sint16x2',
offset: 9376,
shaderLocation: 3,
},
{
format: 'snorm16x2',
offset: 14272,
shaderLocation: 16,
},
{
format: 'sint16x2',
offset: 16124,
shaderLocation: 11,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'unorm8x2',
offset: 8220,
shaderLocation: 21,
},
{
format: 'uint8x2',
offset: 11692,
shaderLocation: 18,
},
{
format: 'unorm16x2',
offset: 40344,
shaderLocation: 13,
},
{
format: 'uint32',
offset: 9528,
shaderLocation: 12,
},
{
format: 'sint32',
offset: 232,
shaderLocation: 4,
},
{
format: 'unorm10-10-10-2',
offset: 8684,
shaderLocation: 15,
},
{
format: 'snorm16x2',
offset: 3788,
shaderLocation: 19,
},
{
format: 'uint32x2',
offset: 13304,
shaderLocation: 8,
},
{
format: 'unorm16x2',
offset: 37824,
shaderLocation: 1,
}
],
},
{
arrayStride: 37096,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint32x4',
offset: 37968,
shaderLocation: 2,
},
{
format: 'snorm8x4',
offset: 20224,
shaderLocation: 17,
}
],
},
{
arrayStride: 5288,
stepMode: 'vertex',
attributes: [
{
format: 'unorm8x2',
offset: 1042,
shaderLocation: 7,
}
],
},
{
arrayStride: 0,
attributes: [
{
format: 'sint16x4',
offset: 26508,
shaderLocation: 6,
},
{
format: 'sint32',
offset: 10404,
shaderLocation: 5,
}
],
},
{
arrayStride: 1548,
stepMode: 'instance',
attributes: [
{
format: 'float32x2',
offset: 1308,
shaderLocation: 20,
}
],
}
]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint16',
cullMode: 'back',
unclippedDepth: true,
},
fragment: {
module: shaderModule2,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r32sint',
},
{
format: 'r8uint',
writeMask: 0,
},
{
format: 'r8sint',
writeMask: GPUColorWrite.ALL,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'less-equal',
stencilFront: {
compare: 'greater-equal',
depthFailOp: 'replace',
passOp: 'increment-wrap',
},
stencilBack: {
failOp: 'increment-clamp',
depthFailOp: 'invert',
passOp: 'increment-clamp',
},
stencilWriteMask: 3698,
depthBias: 3,
depthBiasSlopeScale: 21,
},
}
);
document.body.prepend(img1);
try {
canvas3.getContext('bitmaprenderer');
} catch {}
let commandEncoder4 = device0.createCommandEncoder(
{
label: '\ub81f\u{1f94a}\u38fc\uf9e5\u{1f92a}',
}
);
let texture10 = device0.createTexture(
{
label: '\u5fcd\u0645\ub259',
size: {width: 744, height: 137, depthOrArrayLayers: 211},
mipLevelCount: 6,
dimension: '2d',
format: 'r16uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r16uint',
'r16uint',
'r16uint'
],
}
);
let sampler10 = device0.createSampler(
{
label: '\u0619\u0d92\u{1f727}\u03c5\u0e36\u0bd6\u2c35\ua13a\u8c0a\u03db\u080f',
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
minFilter: 'nearest',
lodMinClamp: 73.660,
lodMaxClamp: 78.011,
}
);
try {
renderBundleEncoder7.setVertexBuffer(
29,
undefined,
2852743007,
106371616
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture1,
  mipLevel: 1,
  origin: { x: 17, y: 0, z: 4 },
  aspect: 'all',
},
new Int32Array(new ArrayBuffer(72)),
/* required buffer size: 369220 */{
offset: 264,
bytesPerRow: 944,
rowsPerImage: 15,
},
{width: 199, height: 1, depthOrArrayLayers: 27}
);
} catch {}
try {
await device0.queue.onSubmittedWorkDone();
} catch {}
let pipeline7 = device0.createComputePipeline(
{
label: '\uae65\u0206\u03e5',
layout: pipelineLayout0,
compute: {
module: shaderModule2,
entryPoint: 'compute0',
constants: {},
},
}
);
let commandEncoder5 = device0.createCommandEncoder(
{
label: '\u27cf\u{1fb47}\u8ddf\u9d74\u075e\udcfb\u0116\ue6e2\u0de6',
}
);
let textureView4 = texture0.createView(
{
label: '\u{1f7ae}\u6b01\uaa41\u0da1\u0c37\u{1f6cf}\u0a4c\u76dd\u56f6\u41a2\u0ef6',
aspect: 'all',
format: 'bgra8unorm-srgb',
}
);
try {
renderBundleEncoder6.setVertexBuffer(
10,
undefined,
3779349023,
370274507
);
} catch {}
let pipeline8 = device0.createRenderPipeline(
{
label: '\u{1f828}\u775b\u0faf',
layout: pipelineLayout1,
vertex: {
module: shaderModule3,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 20812,
stepMode: 'instance',
attributes: [
{
format: 'uint8x2',
offset: 19232,
shaderLocation: 18,
},
{
format: 'float32x3',
offset: 9032,
shaderLocation: 21,
}
],
},
{
arrayStride: 27728,
stepMode: 'vertex',
attributes: [
{
format: 'sint32x4',
offset: 20484,
shaderLocation: 9,
},
{
format: 'unorm16x2',
offset: 6564,
shaderLocation: 1,
},
{
format: 'sint32x2',
offset: 7392,
shaderLocation: 3,
},
{
format: 'float32x3',
offset: 9032,
shaderLocation: 19,
},
{
format: 'uint32x2',
offset: 19584,
shaderLocation: 5,
},
{
format: 'sint8x2',
offset: 11582,
shaderLocation: 16,
},
{
format: 'sint8x4',
offset: 21456,
shaderLocation: 15,
},
{
format: 'uint32x2',
offset: 19508,
shaderLocation: 13,
},
{
format: 'snorm8x4',
offset: 10764,
shaderLocation: 0,
},
{
format: 'float16x4',
offset: 25624,
shaderLocation: 2,
},
{
format: 'sint16x2',
offset: 17408,
shaderLocation: 11,
},
{
format: 'sint32',
offset: 21404,
shaderLocation: 6,
},
{
format: 'uint16x4',
offset: 21380,
shaderLocation: 8,
}
],
},
{
arrayStride: 2132,
stepMode: 'vertex',
attributes: [
{
format: 'snorm16x4',
offset: 1076,
shaderLocation: 4,
},
{
format: 'float32x4',
offset: 1364,
shaderLocation: 17,
},
{
format: 'sint16x4',
offset: 700,
shaderLocation: 20,
},
{
format: 'snorm8x4',
offset: 964,
shaderLocation: 12,
},
{
format: 'uint16x4',
offset: 384,
shaderLocation: 14,
},
{
format: 'unorm16x4',
offset: 1052,
shaderLocation: 7,
}
],
},
{
arrayStride: 26684,
attributes: [

],
},
{
arrayStride: 22484,
stepMode: 'vertex',
attributes: [
{
format: 'sint16x4',
offset: 14380,
shaderLocation: 10,
}
],
}
]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint16',
frontFace: 'cw',
unclippedDepth: true,
},
fragment: {
module: shaderModule3,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r16float',
writeMask: GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'never',
stencilFront: {
compare: 'less-equal',
failOp: 'decrement-wrap',
depthFailOp: 'increment-wrap',
passOp: 'keep',
},
stencilBack: {
compare: 'less',
failOp: 'zero',
depthFailOp: 'replace',
},
stencilReadMask: 1530,
stencilWriteMask: 2146,
depthBiasSlopeScale: 57,
depthBiasClamp: 4,
},
}
);
document.body.prepend(canvas0);
try {
device0.label = '\u6274\u{1f668}\u0802\u{1fdb4}\u{1f860}';
} catch {}
let shaderModule4 = device0.createShaderModule(
{
label: '\uacf0\u{1fe08}\u266b\ucc14\u0645\u00aa',
code: `@group(1) @binding(619)
var<storage, read_write> parameter1: array<u32>;
@group(0) @binding(1264)
var<storage, read_write> global3: array<u32>;
@group(1) @binding(1264)
var<storage, read_write> i2: array<u32>;
@group(1) @binding(1287)
var<storage, read_write> parameter2: array<u32>;
@group(0) @binding(1287)
var<storage, read_write> function1: array<u32>;

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

struct S7 {
@builtin(sample_mask) f0: u32,
@builtin(sample_index) f1: u32
}
struct FragmentOutput0 {
@location(2) f0: vec3<i32>,
@location(4) f1: i32
}

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

struct S6 {
@builtin(instance_index) f0: u32,
@builtin(vertex_index) f1: u32,
@location(17) f2: vec2<i32>,
@location(20) f3: vec4<u32>,
@location(4) f4: vec3<i32>,
@location(7) f5: vec3<i32>,
@location(19) f6: vec3<u32>,
@location(12) f7: vec2<i32>,
@location(8) f8: vec3<u32>,
@location(10) f9: vec4<f32>,
@location(16) f10: vec4<u32>,
@location(15) f11: vec4<u32>,
@location(5) f12: vec3<f32>,
@location(9) f13: f32,
@location(21) f14: vec4<i32>,
@location(13) f15: vec3<f16>,
@location(0) f16: vec4<u32>,
@location(1) f17: f32,
@location(11) f18: vec2<i32>,
@location(14) f19: vec3<i32>,
@location(2) f20: vec2<f16>
}

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

`,
hints: {},
}
);
let texture11 = device0.createTexture(
{
label: '\u{1ff4a}\ud7e9\u{1fd91}\u0e9f',
size: [56, 24, 1],
format: 'astc-8x6-unorm',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'astc-8x6-unorm-srgb',
'astc-8x6-unorm-srgb',
'astc-8x6-unorm-srgb'
],
}
);
let renderBundleEncoder9 = device0.createRenderBundleEncoder(
{
colorFormats: [
'rg16sint',
'r32sint',
'rgb10a2unorm',
'r8uint',
'rgba32float'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 696,
depthReadOnly: false,
stencilReadOnly: true,
}
);
let externalTexture1 = device0.importExternalTexture(
{
label: '\u0229\u{1fe1c}\u{1f654}\ud1b9',
source: videoFrame1,
colorSpace: 'srgb',
}
);
try {
commandEncoder3.clearBuffer(
buffer0
);
dissociateBuffer(device0, buffer0);
} catch {}
let pipeline9 = device0.createComputePipeline(
{
label: '\u{1f8aa}\ud854\u9b31\u4866',
layout: pipelineLayout0,
compute: {
module: shaderModule2,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
gpuCanvasContext0.unconfigure();
} catch {}
let imageData1 = new ImageData(204, 16);
let querySet5 = device0.createQuerySet({
label: '\u{1f9a6}\u4189',
type: 'occlusion',
count: 4064,
});
let commandEncoder6 = device0.createCommandEncoder();
let commandBuffer0 = commandEncoder2.finish(
{
}
);
let renderBundleEncoder10 = device0.createRenderBundleEncoder(
{
label: '\u{1fd9b}\ue1d0\u03b9\u24f7',
colorFormats: [
'rgb10a2uint'
],
sampleCount: 844,
}
);
try {
renderBundleEncoder4.setVertexBuffer(
55,
undefined,
2448845835
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture1,
  mipLevel: 1,
  origin: { x: 48, y: 0, z: 16 },
  aspect: 'all',
},
new Int16Array(new ArrayBuffer(48)),
/* required buffer size: 991516 */{
offset: 796,
bytesPerRow: 1152,
rowsPerImage: 172,
},
{width: 218, height: 0, depthOrArrayLayers: 6}
);
} catch {}
let texture12 = device0.createTexture(
{
label: '\u7729\u{1fe2f}\u0294\udbe1',
size: [8129],
dimension: '1d',
format: 'r8sint',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'r8sint',
'r8sint'
],
}
);
let textureView5 = texture6.createView(
{
label: '\u{1f895}\u{1f78c}\ud935\u5774\u{1fe90}\u0750\u7ac4\u4c6f\u75f2\u5c92',
dimension: '2d-array',
baseMipLevel: 3,
mipLevelCount: 1,
}
);
try {
renderBundleEncoder6.setVertexBuffer(
60,
undefined,
3222400463,
373876601
);
} catch {}
let pipeline10 = device0.createRenderPipeline(
{
label: '\u0a2e\udbb8\u5745\u72d9\u{1fdde}\u0b17\u{1f701}\u{1fd40}\u0952\u00b8',
layout: pipelineLayout1,
vertex: {
module: shaderModule0,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 18052,
stepMode: 'vertex',
attributes: [
{
format: 'sint8x4',
offset: 7872,
shaderLocation: 18,
},
{
format: 'unorm16x4',
offset: 17464,
shaderLocation: 16,
},
{
format: 'unorm10-10-10-2',
offset: 2948,
shaderLocation: 0,
},
{
format: 'float32x4',
offset: 14488,
shaderLocation: 21,
}
],
},
{
arrayStride: 28808,
stepMode: 'instance',
attributes: [
{
format: 'uint16x4',
offset: 28700,
shaderLocation: 3,
},
{
format: 'unorm8x4',
offset: 24864,
shaderLocation: 15,
},
{
format: 'float16x4',
offset: 15728,
shaderLocation: 7,
}
],
},
{
arrayStride: 6204,
stepMode: 'vertex',
attributes: [
{
format: 'snorm8x4',
offset: 4316,
shaderLocation: 4,
}
],
}
]
},
primitive: {
topology: 'point-list',
frontFace: 'cw',
cullMode: 'front',
unclippedDepth: true,
},
fragment: {
module: shaderModule0,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined,
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'never',
stencilFront: {
compare: 'greater-equal',
failOp: 'increment-clamp',
depthFailOp: 'increment-wrap',
passOp: 'invert',
},
stencilBack: {
compare: 'not-equal',
failOp: 'increment-wrap',
depthFailOp: 'zero',
passOp: 'decrement-wrap',
},
stencilReadMask: 3055,
depthBias: 31,
depthBiasSlopeScale: 51,
depthBiasClamp: 45,
},
}
);
let bindGroupLayout3 = pipeline4.getBindGroupLayout(0);
let renderBundleEncoder11 = device0.createRenderBundleEncoder(
{
label: '\ucacf\u09a0',
colorFormats: [
'rgba16sint',
'rgba8sint',
undefined
],
sampleCount: 217,
depthReadOnly: true,
}
);
try {
renderBundleEncoder5.setVertexBuffer(
19,
undefined,
1331799770
);
} catch {}
try {
commandEncoder5.copyTextureToTexture(
{
  texture: texture4,
  mipLevel: 4,
  origin: { x: 4, y: 1, z: 185 },
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 1615, y: 0, z: 0 },
  aspect: 'all',
},
{width: 3, height: 1, depthOrArrayLayers: 1}
);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let canvas4 = document.createElement('canvas');
let texture13 = device0.createTexture(
{
label: '\u{1fddf}\u7db0\u7cd0\u{1ff61}\uce80\u{1f617}\ue5a2\u7ab3\u{1fb09}\u{1f6b1}\u5a39',
size: {width: 142, height: 1, depthOrArrayLayers: 196},
mipLevelCount: 8,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
try {
commandEncoder3.clearBuffer(
buffer0,
2912
);
dissociateBuffer(device0, buffer0);
} catch {}
let promise2 = adapter1.requestDevice({
label: '\u23b2\u9088\u17c6\u{1fee1}\ubd3a\uf8cd\u05dc\u1db2\u0022\u0fc9\uca0f',
requiredFeatures: [
'depth-clip-control',
'texture-compression-etc2',
'indirect-first-instance',
'shader-f16',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 9,
maxColorAttachmentBytesPerSample: 53,
maxVertexAttributes: 19,
maxVertexBufferArrayStride: 65242,
maxStorageTexturesPerShaderStage: 40,
maxStorageBuffersPerShaderStage: 25,
maxDynamicStorageBuffersPerPipelineLayout: 17172,
maxBindingsPerBindGroup: 3749,
maxTextureArrayLayers: 256,
maxTextureDimension1D: 11208,
maxTextureDimension2D: 15930,
maxVertexBuffers: 9,
minStorageBufferOffsetAlignment: 32,
maxUniformBufferBindingSize: 21732000,
maxUniformBuffersPerShaderStage: 20,
maxInterStageShaderVariables: 94,
maxInterStageShaderComponents: 100,
maxSamplersPerShaderStage: 19,
},
});
let commandEncoder7 = device0.createCommandEncoder(
{
label: '\uc7bc\ub8c9\u4255\u{1f668}\ue4a5\u74ed\u0a5e\u0983\udb44',
}
);
let commandBuffer1 = commandEncoder6.finish(
{
}
);
let renderPassEncoder0 = commandEncoder5.beginRenderPass(
{
label: '\u97a3\u008f\u08c4\u0be7\u{1f81c}\u881d\ud29e',
colorAttachments: [
{
view: textureView5,
clearValue: { r: 33.92, g: 385.1, b: -85.06, a: -748.4, },
loadOp: 'clear',
storeOp: 'store'
}
],
occlusionQuerySet: querySet1,
maxDrawCount: 39456,
}
);
try {
buffer1.unmap();
} catch {}
let commandEncoder8 = device0.createCommandEncoder();
let sampler11 = device0.createSampler(
{
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 92.689,
lodMaxClamp: 93.372,
maxAnisotropy: 12,
}
);
let externalTexture2 = device0.importExternalTexture(
{
label: '\u8701\u8236\u0395\u09c4\ua54b\u641a\u9cfe\u4caf\u0081\u0d90',
source: videoFrame2,
colorSpace: 'srgb',
}
);
let promise3 = device0.createComputePipelineAsync(
{
label: '\u{1fb42}\u0fd1\u0120\u{1f640}\u{1f79a}\u6f2d\uf285\u0216\ue2fd\u0be5\u1dcf',
layout: pipelineLayout1,
compute: {
module: shaderModule0,
entryPoint: 'compute0',
constants: {},
},
}
);
let bindGroupLayout4 = device0.createBindGroupLayout(
{
label: '\u4349\u22ee\u2e9c\u4438\u182c\uccea\u6971\uce28',
entries: [
{
binding: 1025,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
externalTexture: {},
}
],
}
);
try {
renderPassEncoder0.setStencilReference(
1888
);
} catch {}
try {
commandEncoder4.clearBuffer(
buffer0
);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture12,
  mipLevel: 0,
  origin: { x: 3490, y: 1, z: 1 },
  aspect: 'all',
},
new BigUint64Array(new ArrayBuffer(80)),
/* required buffer size: 500 */{
offset: 500,
rowsPerImage: 276,
},
{width: 2349, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let canvas5 = document.createElement('canvas');
try {
canvas4.getContext('bitmaprenderer');
} catch {}
try {
renderBundle4.label = '\u2585\u0fdd\u035e\u5d24\u{1f6e6}\uda96';
} catch {}
let querySet6 = device0.createQuerySet({
label: '\u0cd0\u79c5\u0c61\u2c87\u7f22\u97c5\ufa74\u071f\u1fe8\u1c4f',
type: 'occlusion',
count: 2952,
});
try {
renderPassEncoder0.executeBundles([]);
} catch {}
try {
renderPassEncoder0.setStencilReference(
1658
);
} catch {}
try {
renderPassEncoder0.setVertexBuffer(
4,
undefined
);
} catch {}
try {
commandEncoder3.copyTextureToTexture(
{
  texture: texture8,
  mipLevel: 1,
  origin: { x: 453, y: 19, z: 0 },
  aspect: 'all',
},
{
  texture: texture8,
  mipLevel: 2,
  origin: { x: 0, y: 40, z: 0 },
  aspect: 'all',
},
{width: 2314, height: 0, depthOrArrayLayers: 1}
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 656, y: 0, z: 0 },
  aspect: 'all',
},
new Float32Array(new ArrayBuffer(56)),
/* required buffer size: 361 */{
offset: 361,
},
{width: 1956, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let pipeline11 = device0.createRenderPipeline(
{
layout: pipelineLayout2,
vertex: {
module: shaderModule1,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 20476,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x2',
offset: 20232,
shaderLocation: 20,
},
{
format: 'float32x3',
offset: 11024,
shaderLocation: 8,
}
],
},
{
arrayStride: 9980,
attributes: [
{
format: 'unorm16x4',
offset: 9588,
shaderLocation: 17,
},
{
format: 'unorm10-10-10-2',
offset: 5016,
shaderLocation: 19,
},
{
format: 'uint8x4',
offset: 1800,
shaderLocation: 6,
},
{
format: 'sint32x2',
offset: 6912,
shaderLocation: 11,
}
],
},
{
arrayStride: 24340,
stepMode: 'vertex',
attributes: [
{
format: 'sint8x2',
offset: 2470,
shaderLocation: 0,
},
{
format: 'uint16x2',
offset: 18244,
shaderLocation: 16,
}
],
},
{
arrayStride: 3116,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 1388,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 8192,
stepMode: 'instance',
attributes: [
{
format: 'float16x2',
offset: 1376,
shaderLocation: 7,
},
{
format: 'uint16x4',
offset: 5184,
shaderLocation: 2,
}
],
},
{
arrayStride: 34720,
stepMode: 'vertex',
attributes: [
{
format: 'uint32x4',
offset: 880,
shaderLocation: 10,
},
{
format: 'sint8x2',
offset: 8530,
shaderLocation: 14,
}
],
},
{
arrayStride: 17044,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'unorm8x2',
offset: 4294,
shaderLocation: 3,
}
],
}
]
},
fragment: {
module: shaderModule1,
entryPoint: 'fragment0',
targets: [
{
format: 'r8unorm',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
{
format: 'r16uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE,
}
],
},
}
);
let renderBundle10 = renderBundleEncoder11.finish(
{
label: '\u0714\u0cc1'
}
);
let sampler12 = device0.createSampler(
{
addressModeU: 'repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
lodMinClamp: 73.629,
lodMaxClamp: 84.414,
}
);
try {
renderPassEncoder0.end();
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(
47,
undefined,
1621990566
);
} catch {}
try {
computePassEncoder0.pushDebugGroup(
'\u7b60'
);
} catch {}
let bindGroupLayout5 = device0.createBindGroupLayout(
{
label: '\u65c1\u{1fd10}\ube68\ud8cc\u{1f96b}\u5fe0\u{1fb23}\ua738',
entries: [
{
binding: 644,
visibility: GPUShaderStage.FRAGMENT,
texture: { viewDimension: '2d', sampleType: 'sint', multisampled: true },
},
{
binding: 636,
visibility: GPUShaderStage.FRAGMENT,
storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d-array' },
},
{
binding: 1467,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
storageTexture: { format: 'r32sint', access: 'write-only', viewDimension: '1d' },
}
],
}
);
let bindGroup0 = device0.createBindGroup({
label: '\u0212\uc2c9\u5a1b',
layout: bindGroupLayout4,
entries: [
{
binding: 1025,
resource: externalTexture0
}
],
});
let querySet7 = device0.createQuerySet({
label: '\u4ff8\u4314',
type: 'occlusion',
count: 3459,
});
let texture14 = device0.createTexture(
{
size: {width: 62, height: 1, depthOrArrayLayers: 255},
dimension: '3d',
format: 'rgba16sint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba16sint',
'rgba16sint'
],
}
);
try {
renderBundleEncoder5.setVertexBuffer(
62,
undefined,
3124137207
);
} catch {}
try {
commandEncoder4.clearBuffer(
buffer0
);
dissociateBuffer(device0, buffer0);
} catch {}
try {
device0.queue.submit([
commandBuffer1,
commandBuffer0,
]);
} catch {}
try {
await device0.queue.onSubmittedWorkDone();
} catch {}
let shaderModule5 = device0.createShaderModule(
{
label: '\uf66a\ud457\u326a\u{1f82f}\u6f4d\u476c\ue0a4\u{1fdf7}\u5705\ue539',
code: `@group(0) @binding(1287)
var<storage, read_write> type0: array<u32>;
@group(0) @binding(1264)
var<storage, read_write> function2: array<u32>;
@group(0) @binding(619)
var<storage, read_write> parameter3: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
let commandEncoder9 = device0.createCommandEncoder();
try {
commandEncoder4.clearBuffer(
buffer0
);
dissociateBuffer(device0, buffer0);
} catch {}
let commandBuffer2 = commandEncoder8.finish(
{
label: '\u7abc\u8d22',
}
);
let textureView6 = texture11.createView(
{
label: '\u95c0\ud938\u{1fe6b}\u{1fd83}',
format: 'astc-8x6-unorm-srgb',
baseMipLevel: 0,
}
);
let renderBundleEncoder12 = device0.createRenderBundleEncoder(
{
label: '\u{1f8a6}\u0442\u8b48',
colorFormats: [
'r16sint',
'bgra8unorm-srgb',
'rg32uint',
'rg16sint',
'rgb10a2uint',
'rgb10a2unorm',
'rgba32sint'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 391,
stencilReadOnly: false,
}
);
let renderBundle11 = renderBundleEncoder11.finish(
{
label: '\u0dbb\u{1fc34}\uf638'
}
);
try {
renderBundleEncoder12.setBindGroup(
0,
bindGroup0,
new Uint32Array(1536),
1286,
0
);
} catch {}
try {
adapter1.label = '\u0c3b\uda5f';
} catch {}
let bindGroupLayout6 = device0.createBindGroupLayout(
{
label: '\u{1fd59}\u795e\u{1fd11}\u36fc\u{1fe72}\u2ba6\u{1fc1c}',
entries: [
{
binding: 344,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
}
],
}
);
let bindGroup1 = device0.createBindGroup({
label: '\u{1fbb3}\u03ed\u0885\u862d\u391f\ua8ec',
layout: bindGroupLayout4,
entries: [
{
binding: 1025,
resource: externalTexture1
}
],
});
let querySet8 = device0.createQuerySet({
label: '\u{1fb43}\u0c87\u0ef3\ubbbb\u{1f6e1}',
type: 'occlusion',
count: 1871,
});
let renderBundle12 = renderBundleEncoder4.finish(
{
label: '\uc648\u{1ffd1}\u08a5\u076a\ucc52\u66d6\u08c9\ue1a2'
}
);
try {
renderBundleEncoder10.setBindGroup(
1,
bindGroup0
);
} catch {}
let imageData2 = new ImageData(248, 212);
try {
canvas5.getContext('webgl2');
} catch {}
let textureView7 = texture13.createView(
{
dimension: '2d',
baseMipLevel: 7,
mipLevelCount: 1,
baseArrayLayer: 99,
}
);
let arrayBuffer0 = buffer0.getMappedRange(
0,
12448
);
let commandBuffer3 = commandEncoder9.finish(
{
}
);
let computePassEncoder2 = commandEncoder7.beginComputePass();
let renderPassEncoder1 = commandEncoder4.beginRenderPass(
{
label: '\u04f8\u136d\u{1f875}\u8376\u0474\ufad5\u{1f75c}\u{1fd70}\u{1fab0}\ub507\u03e5',
colorAttachments: [
undefined,
{
view: textureView5,
clearValue: { r: 349.0, g: 162.2, b: -855.1, a: -517.0, },
loadOp: 'clear',
storeOp: 'store'
}
],
occlusionQuerySet: querySet7,
maxDrawCount: 11160,
}
);
let renderBundleEncoder13 = device0.createRenderBundleEncoder(
{
label: '\u97b4\u035d\u{1fef8}\u57bd\u0a6e\ub146\u95e1',
colorFormats: [
'r8unorm'
],
sampleCount: 321,
stencilReadOnly: true,
}
);
let renderBundle13 = renderBundleEncoder12.finish();
let sampler13 = device0.createSampler(
{
label: '\ud9e4\u{1f8bd}',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 75.117,
lodMaxClamp: 95.060,
}
);
try {
computePassEncoder2.end();
} catch {}
try {
renderPassEncoder1.setBindGroup(
2,
bindGroup1
);
} catch {}
try {
renderPassEncoder1.beginOcclusionQuery(3173);
} catch {}
try {
renderBundleEncoder10.setVertexBuffer(
96,
undefined,
1490224732,
290200025
);
} catch {}
let arrayBuffer1 = buffer0.getMappedRange(
12448,
96
);
let pipeline12 = device0.createComputePipeline(
{
label: '\uce2a\ud649\u{1f7e3}\udb7d\u0614',
layout: pipelineLayout1,
compute: {
module: shaderModule4,
entryPoint: 'compute0',
constants: {},
},
}
);
let device1 = await adapter2.requestDevice({
label: '\uf67f\u40db\u0e9f\u0a2c\ud37d\u083c\u024d\u1731\u594d\u{1ffba}',
requiredLimits: {
maxBindGroups: 11,
maxColorAttachmentBytesPerSample: 51,
maxVertexAttributes: 20,
maxVertexBufferArrayStride: 7601,
maxStorageTexturesPerShaderStage: 8,
maxStorageBuffersPerShaderStage: 9,
maxDynamicStorageBuffersPerPipelineLayout: 51878,
maxBindingsPerBindGroup: 8679,
maxTextureDimension1D: 15753,
maxTextureDimension2D: 15584,
minStorageBufferOffsetAlignment: 32,
minUniformBufferOffsetAlignment: 32,
maxUniformBufferBindingSize: 128700188,
maxUniformBuffersPerShaderStage: 21,
maxInterStageShaderVariables: 73,
maxInterStageShaderComponents: 76,
maxSamplersPerShaderStage: 18,
},
});
let buffer2 = device0.createBuffer(
{
size: 24374,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let commandEncoder10 = device0.createCommandEncoder(
{
}
);
let querySet9 = device0.createQuerySet({
label: '\u6fa1\u{1fc5f}\ua69b\u0e1c\u388a\u{1fc92}\u13c5\ua068\u0d63',
type: 'occlusion',
count: 3263,
});
let renderBundleEncoder14 = device0.createRenderBundleEncoder(
{
label: '\u0426\u0973\u2008\ucdc2\u{1fe4f}\u{1ff35}\u9be7\u014d\u1ec8\u015c',
colorFormats: [
'rg16float',
'rg16sint',
'rgba32uint',
'rg8uint',
'rg32sint',
'rg32uint',
'r32uint'
],
sampleCount: 513,
stencilReadOnly: true,
}
);
let sampler14 = device0.createSampler(
{
label: '\u41b3\u0de0\u025a\u053c\u63ee\u2155\ufe17',
addressModeU: 'mirror-repeat',
addressModeV: 'repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 71.659,
lodMaxClamp: 82.053,
}
);
try {
renderPassEncoder1.setViewport(
0.6724,
10.85,
0.3148,
1.482,
0.1486,
0.5206
);
} catch {}
try {
renderBundleEncoder5.setBindGroup(
3,
bindGroup1
);
} catch {}
try {
gpuCanvasContext1.unconfigure();
} catch {}
let textureView8 = texture1.createView(
{
format: 'rg16sint',
}
);
let renderBundle14 = renderBundleEncoder14.finish(
{
label: '\u5d68\u2505\u{1f841}\u9db9\u0229\u0e36'
}
);
try {
renderBundleEncoder13.setBindGroup(
0,
bindGroup0
);
} catch {}
try {
renderBundleEncoder9.setVertexBuffer(
54,
undefined,
2015933850,
1784634238
);
} catch {}
try {
gpuCanvasContext0.configure(
{
device: device0,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r8uint',
'r32uint'
],
colorSpace: 'display-p3',
alphaMode: 'opaque',
}
);
} catch {}
let pipeline13 = await promise3;
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let querySet10 = device1.createQuerySet({
label: '\ud553\u0736\u8cc5\ucf2f',
type: 'occlusion',
count: 2308,
});
let video0 = await videoWithData();
let sampler15 = device1.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
addressModeW: 'mirror-repeat',
lodMaxClamp: 85.582,
}
);
canvas2.height = 395;
let commandEncoder11 = device1.createCommandEncoder();
let computePassEncoder3 = commandEncoder11.beginComputePass();
let canvas6 = document.createElement('canvas');
let computePassEncoder4 = commandEncoder7.beginComputePass(
{

}
);
try {
renderPassEncoder1.setStencilReference(
760
);
} catch {}
try {
texture3.destroy();
} catch {}
try {
await buffer2.mapAsync(
GPUMapMode.READ,
18760,
4316
);
} catch {}
try {
commandEncoder10.copyTextureToTexture(
{
  texture: texture4,
  mipLevel: 2,
  origin: { x: 5, y: 28, z: 156 },
  aspect: 'all',
},
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 90, y: 0, z: 0 },
  aspect: 'all',
},
{width: 6, height: 1, depthOrArrayLayers: 1}
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture11,
  mipLevel: 0,
  origin: { x: 0, y: 6, z: 1 },
  aspect: 'all',
},
new Float64Array(arrayBuffer0),
/* required buffer size: 74 */{
offset: 74,
rowsPerImage: 159,
},
{width: 48, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let pipeline14 = await device0.createRenderPipelineAsync(
{
label: '\u054d\ud4c0\u0464\u{1fe93}\u8c1d\u862f\u33da',
layout: pipelineLayout1,
vertex: {
module: shaderModule4,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 4188,
stepMode: 'vertex',
attributes: [
{
format: 'sint8x2',
offset: 1710,
shaderLocation: 21,
},
{
format: 'uint8x4',
offset: 2200,
shaderLocation: 16,
}
],
},
{
arrayStride: 4792,
stepMode: 'instance',
attributes: [
{
format: 'unorm10-10-10-2',
offset: 4380,
shaderLocation: 10,
},
{
format: 'sint8x4',
offset: 484,
shaderLocation: 17,
},
{
format: 'unorm16x2',
offset: 2412,
shaderLocation: 2,
},
{
format: 'sint16x2',
offset: 3584,
shaderLocation: 12,
},
{
format: 'float32x3',
offset: 2560,
shaderLocation: 6,
},
{
format: 'uint32x3',
offset: 2040,
shaderLocation: 8,
},
{
format: 'float32x2',
offset: 1124,
shaderLocation: 1,
},
{
format: 'snorm8x4',
offset: 2072,
shaderLocation: 18,
}
],
},
{
arrayStride: 304,
attributes: [
{
format: 'sint8x4',
offset: 40,
shaderLocation: 4,
},
{
format: 'uint8x4',
offset: 28,
shaderLocation: 20,
},
{
format: 'sint32x4',
offset: 144,
shaderLocation: 7,
},
{
format: 'uint32x2',
offset: 272,
shaderLocation: 19,
},
{
format: 'uint8x4',
offset: 104,
shaderLocation: 15,
},
{
format: 'float16x2',
offset: 204,
shaderLocation: 9,
}
],
},
{
arrayStride: 18428,
attributes: [
{
format: 'snorm8x2',
offset: 14330,
shaderLocation: 13,
}
],
},
{
arrayStride: 18880,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x4',
offset: 32,
shaderLocation: 0,
},
{
format: 'unorm16x4',
offset: 6804,
shaderLocation: 5,
},
{
format: 'sint16x2',
offset: 5876,
shaderLocation: 14,
}
],
},
{
arrayStride: 4304,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 2988,
stepMode: 'instance',
attributes: [
{
format: 'sint16x2',
offset: 708,
shaderLocation: 11,
}
],
}
]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint16',
frontFace: 'cw',
unclippedDepth: true,
},
fragment: {
module: shaderModule4,
entryPoint: 'fragment0',
targets: [
undefined,
undefined,
{
format: 'rg32sint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
},
undefined,
{
format: 'r32sint',
writeMask: GPUColorWrite.BLUE,
},
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'less',
stencilFront: {
compare: 'less',
failOp: 'decrement-clamp',
depthFailOp: 'invert',
},
stencilBack: {
compare: 'never',
failOp: 'decrement-wrap',
passOp: 'invert',
},
stencilWriteMask: 3605,
depthBias: 31,
depthBiasSlopeScale: 51,
depthBiasClamp: 45,
},
}
);
let gpuCanvasContext3 = canvas6.getContext('webgpu');
let bindGroupLayout7 = device0.createBindGroupLayout(
{
label: '\u{1fe88}\u0e6f\u{1f673}\u05a8\u9338\u{1f7da}\u{1f8e8}\u0db7\u6663\u{1f948}\u026d',
entries: [

],
}
);
let commandEncoder12 = device0.createCommandEncoder(
{
label: '\u{1fe6c}\u{1fd11}\u072d',
}
);
let querySet11 = device0.createQuerySet({
label: '\u{1ff4a}\u6941\u9293\u2e90\u9d93\u9ae2\ud93e\u82f3\u0269\u{1fb35}\u0584',
type: 'occlusion',
count: 1939,
});
try {
renderPassEncoder1.setScissorRect(
2,
6,
0,
4
);
} catch {}
try {
renderPassEncoder1.setStencilReference(
683
);
} catch {}
gc();
let adapter3 = await navigator.gpu.requestAdapter(
{
powerPreference: 'high-performance',
}
);
let renderPassEncoder2 = commandEncoder3.beginRenderPass(
{
label: '\ufff9\u0c2d',
colorAttachments: [
undefined,
undefined,
undefined,
undefined,
undefined,
{
view: textureView5,
clearValue: { r: -451.5, g: 739.3, b: -157.0, a: -197.2, },
loadOp: 'clear',
storeOp: 'store'
},
undefined,
undefined
],
occlusionQuerySet: querySet1,
maxDrawCount: 41600,
}
);
try {
renderPassEncoder1.executeBundles([]);
} catch {}
try {
renderPassEncoder1.setScissorRect(
0,
1,
1,
9
);
} catch {}
try {
renderBundleEncoder13.setBindGroup(
0,
bindGroup0,
new Uint32Array(2947),
1640,
0
);
} catch {}
let device2 = await promise2;
let texture15 = device0.createTexture(
{
label: '\u{1fc09}\u0c78\u817f\udb22',
size: [240, 100, 1],
mipLevelCount: 2,
format: 'astc-5x5-unorm-srgb',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'astc-5x5-unorm-srgb',
'astc-5x5-unorm-srgb'
],
}
);
let renderBundleEncoder15 = device0.createRenderBundleEncoder(
{
label: '\ufb60\u28ae\u040c\u2519\u082e\uf2ad\u02d1\uf108\u{1f84f}',
colorFormats: [
'rg32uint',
'rg16float',
'rgb10a2unorm',
'r8unorm',
'rgba8unorm-srgb',
'rgba8unorm',
'rgba8sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 537,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle15 = renderBundleEncoder4.finish();
try {
renderBundleEncoder13.setVertexBuffer(
13,
undefined
);
} catch {}
try {
computePassEncoder4.insertDebugMarker(
'\u5f09'
);
} catch {}
try {
gpuCanvasContext3.configure(
{
device: device0,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r8snorm',
'astc-5x4-unorm-srgb',
'rgba16float'
],
alphaMode: 'opaque',
}
);
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 413, y: 0, z: 0 },
  aspect: 'all',
},
new Uint8Array(arrayBuffer0),
/* required buffer size: 292 */{
offset: 292,
},
{width: 342, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let commandEncoder13 = device0.createCommandEncoder(
{
label: '\u{1f681}\u{1fd9e}\ud0c2\ud02c\u5eaa\u{1fbc1}\u{1fde8}\u294b\u8a40\u{1fdaf}\uf79d',
}
);
let sampler16 = device0.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 38.592,
lodMaxClamp: 41.025,
maxAnisotropy: 1,
}
);
try {
renderPassEncoder2.setScissorRect(
2,
12,
0,
2
);
} catch {}
try {
renderPassEncoder1.setStencilReference(
1584
);
} catch {}
try {
renderPassEncoder1.setViewport(
0.1154,
7.296,
0.5509,
6.144,
0.9968,
0.9975
);
} catch {}
try {
device0.addEventListener('uncapturederror', e => { log('device0.uncapturederror'); log(e); e.label = device0.label; });
} catch {}
try {
texture1.destroy();
} catch {}
try {
device0.queue.writeTexture(
{
  texture: texture0,
  mipLevel: 0,
  origin: { x: 1989, y: 0, z: 1 },
  aspect: 'all',
},
new Float32Array(arrayBuffer1),
/* required buffer size: 705 */{
offset: 705,
},
{width: 120, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let pipeline15 = await device0.createComputePipelineAsync(
{
label: '\u0bd1\u{1f627}\u0dbb\u{1fbe0}\u02e4\u0a30\u0fde\u3143\ueb7b\u3549\u10f8',
layout: 'auto',
compute: {
module: shaderModule2,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let offscreenCanvas1 = new OffscreenCanvas(508, 496);
let textureView9 = texture14.createView(
{
label: '\ua9e8\ua0c3',
}
);
let sampler17 = device0.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeV: 'mirror-repeat',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 82.561,
lodMaxClamp: 95.217,
maxAnisotropy: 20,
}
);
try {
computePassEncoder4.setBindGroup(
3,
bindGroup1,
new Uint32Array(2251),
2106,
0
);
} catch {}
try {
renderPassEncoder2.executeBundles([]);
} catch {}
try {
renderPassEncoder1.setScissorRect(
2,
5,
0,
1
);
} catch {}
try {
renderBundleEncoder15.setVertexBuffer(
58,
undefined,
1766124617,
1681347829
);
} catch {}
try {
device0.queue.submit([
commandBuffer2,
]);
} catch {}
try {
offscreenCanvas1.getContext('webgl');
} catch {}
let video1 = await videoWithData();
let bindGroupLayout8 = device2.createBindGroupLayout(
{
label: '\u{1f973}\ub519\u2dfa\ued84\u07a0\u0c93\u0542\u0718\u0469\u{1f6a2}\u068e',
entries: [
{
binding: 2768,
visibility: GPUShaderStage.VERTEX,
sampler: { type: 'filtering' },
},
{
binding: 175,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
sampler: { type: 'non-filtering' },
}
],
}
);
let texture16 = device1.createTexture(
{
label: '\u{1ff46}\u{1fe54}\ua5df\u8d86\u0a9f\u30e4',
size: [9815],
dimension: '1d',
format: 'rg8snorm',
usage: GPUTextureUsage.COPY_SRC,
}
);
let textureView10 = texture16.createView(
{
mipLevelCount: 1,
}
);
let renderBundleEncoder16 = device1.createRenderBundleEncoder(
{
label: '\u96d8\u{1f9c5}\u01f1\u4d21\udb4a',
colorFormats: [
'rgb10a2uint',
'rgba16float',
'r16uint',
undefined
],
sampleCount: 387,
stencilReadOnly: true,
}
);
try {
renderBundleEncoder16.setVertexBuffer(
2,
undefined
);
} catch {}
let buffer3 = device1.createBuffer(
{
label: '\u{1fc83}\ubc78\u0fdf\u85f0\u774b\u8210\u0e2e\ua2ee\ua3b4\u59d2\u97ba',
size: 39787,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
}
);
let texture17 = device1.createTexture(
{
label: '\u3886\u0f9d\ua1cb\u56ab\u5905\ub558',
size: {width: 1615, height: 1, depthOrArrayLayers: 1009},
mipLevelCount: 11,
dimension: '3d',
format: 'rg16sint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
viewFormats: [

],
}
);
try {
renderBundleEncoder16.setVertexBuffer(
2,
undefined,
879735905,
2665254086
);
} catch {}
try {
gpuCanvasContext2.unconfigure();
} catch {}
let canvas7 = document.createElement('canvas');
let commandEncoder14 = device1.createCommandEncoder(
{
}
);
let querySet12 = device1.createQuerySet({
label: '\u{1f656}\u{1f990}\u{1fd1f}\u{1fab9}',
type: 'occlusion',
count: 15,
});
let texture18 = device1.createTexture(
{
size: {width: 3969},
dimension: '1d',
format: 'rg32float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rg32float'
],
}
);
let computePassEncoder5 = commandEncoder14.beginComputePass(
{
label: '\u7202\u54dd\u033e'
}
);
try {
gpuCanvasContext3.unconfigure();
} catch {}
let adapter4 = await navigator.gpu.requestAdapter(
{
}
);
let commandEncoder15 = device2.createCommandEncoder(
{
label: '\u7ab7\u4ec1\u0960',
}
);
let querySet13 = device2.createQuerySet({
label: '\u{1ff40}\u0906\u{1f6cb}\u9025\uf7c9\u8123\u530c\u0413\udc35',
type: 'occlusion',
count: 1703,
});
let texture19 = device2.createTexture(
{
size: [180, 28, 1],
mipLevelCount: 8,
format: 'etc2-rgb8a1unorm',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'etc2-rgb8a1unorm-srgb',
'etc2-rgb8a1unorm'
],
}
);
let textureView11 = texture19.createView(
{
label: '\u48cf\u26a2\u0dae\u70e1\u0b76',
format: 'etc2-rgb8a1unorm-srgb',
}
);
let computePassEncoder6 = commandEncoder15.beginComputePass(
{

}
);
gc();
let commandEncoder16 = device0.createCommandEncoder(
{
label: '\u004c\u159c\ua380',
}
);
try {
renderPassEncoder1.setBindGroup(
3,
bindGroup1
);
} catch {}
try {
renderPassEncoder1.setStencilReference(
2979
);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
await adapter3.requestAdapterInfo();
} catch {}
let texture20 = device1.createTexture(
{
label: '\u0929\uedcf\u0cef\ua76b\u44d2\u{1f63c}',
size: [94, 185, 89],
mipLevelCount: 3,
format: 'depth24plus',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [
'depth24plus',
'depth24plus'
],
}
);
try {
await buffer3.mapAsync(
GPUMapMode.WRITE,
0,
3596
);
} catch {}
let canvas8 = document.createElement('canvas');
let bindGroupLayout9 = device1.createBindGroupLayout(
{
entries: [
{
binding: 1832,
visibility: 0,
sampler: { type: 'filtering' },
},
{
binding: 1199,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
}
],
}
);
let texture21 = device1.createTexture(
{
label: '\u835d\u{1f6a5}\u{1f7ac}\ub624\u69ca\u{1fa8b}\uf244',
size: {width: 202, height: 249, depthOrArrayLayers: 1},
mipLevelCount: 6,
format: 'depth24plus',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let textureView12 = texture20.createView(
{
label: '\u63ca\u06d9\ucdea\u06b4\u22d1',
dimension: '2d',
baseMipLevel: 2,
baseArrayLayer: 13,
arrayLayerCount: 1,
}
);
let renderBundle16 = renderBundleEncoder16.finish(
{
label: '\u{1fb4e}\u{1f699}\u3927\uc696\u8a77\u7ee7\u{1f6eb}\u{1fec9}'
}
);
try {
texture20.destroy();
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture17,
  mipLevel: 9,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer1,
/* required buffer size: 774 */{
offset: 766,
rowsPerImage: 54,
},
{width: 2, height: 1, depthOrArrayLayers: 1}
);
} catch {}
let bindGroupLayout10 = device0.createBindGroupLayout(
{
entries: [

],
}
);
let buffer4 = device0.createBuffer(
{
size: 53793,
usage: GPUBufferUsage.INDIRECT,
mappedAtCreation: false,
}
);
let commandBuffer4 = commandEncoder16.finish(
{
label: '\u56f0\u33e2\u{1fe3d}\u0d11\u{1fb83}\u0c71\u7347\u{1f92d}\u524d',
}
);
let texture22 = device0.createTexture(
{
size: {width: 9565},
dimension: '1d',
format: 'rg32uint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rg32uint',
'rg32uint',
'rg32uint'
],
}
);
let textureView13 = texture10.createView(
{
baseMipLevel: 5,
baseArrayLayer: 32,
arrayLayerCount: 49,
}
);
let renderBundleEncoder17 = device0.createRenderBundleEncoder(
{
label: '\u{1f657}\u06d1\u38c9\u47c3\ua110',
colorFormats: [
'r32uint'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 198,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle17 = renderBundleEncoder4.finish();
try {
renderBundleEncoder5.setVertexBuffer(
57,
undefined,
684891188,
3139171500
);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let renderBundleEncoder18 = device2.createRenderBundleEncoder(
{
label: '\u63f0\u9e8a\ue9f1\u063f\u801a\u8690\u550e\ub978',
colorFormats: [
'rgba8sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 101,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle18 = renderBundleEncoder18.finish(
{
label: '\u36e3\u6d8f\u75d7\u0236\u012a\u04da\u8ebd\u4121\u{1f83b}'
}
);
try {
device2.queue.writeTexture(
{
  texture: texture19,
  mipLevel: 6,
  origin: { x: 4, y: 4, z: 0 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 859 */{
offset: 859,
rowsPerImage: 23,
},
{width: 0, height: 0, depthOrArrayLayers: 1}
);
} catch {}
let video2 = await videoWithData();
try {
sampler15.label = '\u079b\u6935\udca9\u{1fd12}\u7246\u0270\u0cbc\uf369\u3b39\u2186';
} catch {}
let pipelineLayout3 = device1.createPipelineLayout(
{
bindGroupLayouts: [
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout9
]
}
);
let commandEncoder17 = device1.createCommandEncoder(
{
label: '\u{1fda5}\u2498\u7edf\u5c8c\uab36\uc736\u1dcb\ubd0e\u02b1',
}
);
let texture23 = device1.createTexture(
{
size: {width: 1501, height: 1, depthOrArrayLayers: 216},
mipLevelCount: 7,
dimension: '3d',
format: 'rgba8uint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
}
);
let renderPassEncoder3 = commandEncoder17.beginRenderPass(
{
label: '\u65aa\u052e',
colorAttachments: [
undefined,
undefined,
undefined,
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: -2.3715811295008855,
depthLoadOp: 'load',
depthStoreOp: 'discard',
stencilClearValue: 39448,
},
occlusionQuerySet: querySet10,
maxDrawCount: 190600,
}
);
let renderBundleEncoder19 = device1.createRenderBundleEncoder(
{
label: '\u{1fd93}\ua64e\u1e81\u2e91\u6007',
colorFormats: [
'rg16uint',
'rgba32sint'
],
sampleCount: 831,
stencilReadOnly: false,
}
);
let renderBundle19 = renderBundleEncoder19.finish(
{
label: '\uc23c\u0c08\u0220\ub19f\u0aa2\u98f4\u06c3'
}
);
try {
renderPassEncoder3.setStencilReference(
1678
);
} catch {}
try {
buffer3.unmap();
} catch {}
try {
computePassEncoder3.insertDebugMarker(
'\ucf66'
);
} catch {}
try {
gpuCanvasContext2.configure(
{
device: device1,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
colorSpace: 'srgb',
}
);
} catch {}
let gpuCanvasContext4 = canvas8.getContext('webgpu');
video2.height = 230;
let pipelineLayout4 = device2.createPipelineLayout(
{
label: '\ua7a9\u{1f802}\u{1faee}\u{1fbfb}\u{1ff66}\u{1fe2c}\u{1fc27}\uf2f8',
bindGroupLayouts: [
bindGroupLayout8,
bindGroupLayout8,
bindGroupLayout8,
bindGroupLayout8,
bindGroupLayout8
]
}
);
let renderBundle20 = renderBundleEncoder18.finish(
{
label: '\u0435\u09f4\u4e62\u49ce\u5ce4\u708c\u0ddf\u0597'
}
);
let sampler18 = device2.createSampler(
{
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 76.580,
lodMaxClamp: 81.148,
}
);
let offscreenCanvas2 = new OffscreenCanvas(942, 176);
let texture24 = device2.createTexture(
{
label: '\u0bfc\u{1fdf6}\u0b6f\ubf89\u026a',
size: [15111, 122, 14],
mipLevelCount: 6,
format: 'stencil8',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'stencil8',
'stencil8'
],
}
);
try {
device2.queue.writeTexture(
{
  texture: texture19,
  mipLevel: 6,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 429 */{
offset: 429,
bytesPerRow: 130,
},
{width: 4, height: 0, depthOrArrayLayers: 1}
);
} catch {}
canvas8.height = 892;
try {
computePassEncoder4.setBindGroup(
2,
bindGroup1
);
} catch {}
try {
renderPassEncoder2.beginOcclusionQuery(2097);
} catch {}
try {
renderPassEncoder2.setViewport(
0.9693,
9.360,
0.4791,
3.205,
0.07005,
0.9627
);
} catch {}
try {
commandEncoder12.clearBuffer(
buffer2,
2592,
20136
);
dissociateBuffer(device0, buffer2);
} catch {}
try {
renderBundleEncoder17.insertDebugMarker(
'\u842d'
);
} catch {}
try {
computePassEncoder3.end();
} catch {}
try {
renderPassEncoder3.setStencilReference(
3467
);
} catch {}
try {
renderPassEncoder3.insertDebugMarker(
'\u024e'
);
} catch {}
let gpuCanvasContext5 = offscreenCanvas2.getContext('webgpu');
let querySet14 = device0.createQuerySet({
type: 'occlusion',
count: 1509,
});
let textureView14 = texture4.createView(
{
label: '\u702d\u{1fcfe}\uf836\u02e6\u01ba\ub9e5\u{1feeb}\u{1f9b8}\uce6d',
dimension: '2d',
baseMipLevel: 4,
baseArrayLayer: 85,
}
);
let renderBundleEncoder20 = device0.createRenderBundleEncoder(
{
label: '\uafb7\ub712\ubbaf\u8532\u0258',
colorFormats: [
'rgba32uint',
undefined
],
sampleCount: 89,
}
);
try {
renderPassEncoder1.executeBundles([]);
} catch {}
let pipeline16 = device0.createComputePipeline(
{
label: '\u{1fe1f}\u6d90\u{1fb09}\u050e\u0ddc\uab3c\u0664\u{1fffd}\u5343\ue95b\u432a',
layout: pipelineLayout1,
compute: {
module: shaderModule0,
entryPoint: 'compute0',
},
}
);
try {
device0.destroy();
} catch {}
let shaderModule6 = device1.createShaderModule(
{
label: '\u0ee6\uaf62\u00db\u{1fa85}\u0a4e\u0a89\ua651\u0440\ud10c\u0045\u{1ffcd}',
code: `@group(5) @binding(1832)
var<storage, read_write> type1: array<u32>;
@group(6) @binding(1199)
var<storage, read_write> global4: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> i3: array<u32>;
@group(7) @binding(1832)
var<storage, read_write> field2: array<u32>;
@group(3) @binding(1199)
var<storage, read_write> function3: array<u32>;
@group(4) @binding(1199)
var<storage, read_write> function4: array<u32>;
@group(5) @binding(1199)
var<storage, read_write> type2: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> parameter4: 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(7) f0: vec3<f32>,
@location(0) f1: vec3<i32>,
@location(1) f2: u32,
@location(6) f3: vec4<i32>,
@location(4) f4: vec3<i32>,
@location(3) f5: vec2<u32>,
@location(5) f6: vec2<f32>
}

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

struct S8 {
@location(6) f0: vec3<i32>,
@location(1) f1: vec4<f16>,
@location(2) f2: vec2<f32>,
@location(19) f3: vec3<u32>,
@location(14) f4: vec2<f16>,
@location(5) f5: vec4<i32>,
@location(8) f6: f32,
@location(10) f7: vec4<f16>,
@location(12) f8: u32,
@location(15) f9: vec2<f32>
}
struct VertexOutput0 {
@location(50) f74: u32,
@location(53) f75: vec4<f32>,
@location(0) f76: vec4<u32>,
@location(47) f77: vec4<i32>,
@location(12) f78: vec4<u32>,
@location(3) f79: u32,
@location(25) f80: vec2<u32>,
@location(18) f81: vec4<i32>,
@location(9) f82: vec3<f16>,
@location(17) f83: i32,
@location(71) f84: vec2<i32>,
@location(49) f85: vec3<f32>,
@location(30) f86: vec4<f32>,
@location(57) f87: vec3<f16>,
@location(61) f88: f16,
@location(15) f89: vec4<u32>,
@location(38) f90: vec3<u32>,
@location(26) f91: vec4<f32>,
@location(29) f92: vec2<i32>,
@location(7) f93: f16,
@location(31) f94: vec3<f32>,
@location(13) f95: f16,
@builtin(position) f96: vec4<f32>
}

@vertex
fn vertex0(@location(16) a0: vec4<f16>, @location(13) a1: vec2<f16>, @location(17) a2: vec4<f16>, @location(4) a3: f32, @builtin(instance_index) a4: u32, @builtin(vertex_index) a5: u32, @location(0) a6: f32, a7: S8, @location(7) a8: vec4<i32>, @location(3) a9: vec3<i32>, @location(11) a10: vec4<u32>, @location(9) a11: vec2<f32>, @location(18) a12: vec2<f32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
sourceMap: {},
hints: {},
}
);
let computePassEncoder7 = commandEncoder11.beginComputePass();
let renderBundle21 = renderBundleEncoder16.finish(
{
label: '\ued3b\udb07\u61a7\u0d90\u6553\u{1fe59}\u135a\u{1f675}'
}
);
try {
renderPassEncoder3.setScissorRect(
6,
11,
5,
1
);
} catch {}
let gpuCanvasContext6 = canvas7.getContext('webgpu');
gc();
let buffer5 = device2.createBuffer(
{
label: '\u0472\u06e3\u{1f67c}\uc039\uaa0c\ub257\u00bd\u5924\u{1f7b4}\u021c\u0490',
size: 722,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
mappedAtCreation: false,
}
);
let commandEncoder18 = device2.createCommandEncoder(
{
label: '\uf24f\u0e26\u0679\ub587\u6f69\u077d\u0f27\u{1fa4e}\u0cfe\ub59c',
}
);
try {
gpuCanvasContext0.unconfigure();
} catch {}
try {
texture21.label = '\u{1ffbe}\uea77\u0fc1';
} catch {}
let bindGroupLayout11 = device1.createBindGroupLayout(
{
label: '\ud1d7\u0b70\u{1f694}\u{1fa0c}\ue17d\u6c58\u3888\ub5e6',
entries: [
{
binding: 5363,
visibility: GPUShaderStage.VERTEX,
sampler: { type: 'filtering' },
},
{
binding: 7532,
visibility: GPUShaderStage.COMPUTE,
sampler: { type: 'comparison' },
}
],
}
);
let querySet15 = device1.createQuerySet({
label: '\ub4d2\ua4f7\ubc2f',
type: 'occlusion',
count: 2802,
});
try {
renderPassEncoder3.beginOcclusionQuery(1019);
} catch {}
try {
renderPassEncoder3.endOcclusionQuery();
} catch {}
try {
renderPassEncoder3.executeBundles([]);
} catch {}
try {
buffer3.destroy();
} catch {}
pseudoSubmit(device1, commandEncoder17);
let texture25 = device1.createTexture(
{
label: '\u10f6\uc4a5\ue4d6\uef8a\u{1f8b5}\u7b06\u{1fc53}\u08ba\u4aee',
size: {width: 15048},
dimension: '1d',
format: 'r8uint',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'r8uint',
'r8uint'
],
}
);
let renderBundleEncoder21 = device1.createRenderBundleEncoder(
{
label: '\u0185\u43e6\uf739\ub008',
colorFormats: [
'rg16float',
'rg32sint',
'rgba8sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 520,
stencilReadOnly: true,
}
);
let renderBundle22 = renderBundleEncoder21.finish(
{
label: '\u7ddc\u436c\u5f31\u{1fa78}\ufd85\ud661\u0ef6\u01cd\u62e2\u0244\u{1f927}'
}
);
try {
renderPassEncoder3.end();
} catch {}
try {
device1.pushErrorScope('validation');
} catch {}
let pipeline17 = await device1.createComputePipelineAsync(
{
label: '\u{1ffcb}\ub537\u066c\u{1f9cd}\u{1f6b9}',
layout: pipelineLayout3,
compute: {
module: shaderModule6,
entryPoint: 'compute0',
},
}
);
gc();
let videoFrame3 = new VideoFrame(canvas3, {timestamp: 0});
let commandEncoder19 = device2.createCommandEncoder(
{
label: '\u252f\ub712\ub94e\u9174\u3dca\u{1fcf7}\u026b\u{1fc61}\u0762',
}
);
let commandBuffer5 = commandEncoder19.finish(
{
label: '\udd9b\u4cf4\u9d1f\u0300\u{1f8c5}\uabcb\u0865',
}
);
let texture26 = device2.createTexture(
{
label: '\u{1fbbf}\u010a\u6222\udb08\u0f0c\u246f\u{1fab8}\u{1fc39}',
size: [15315, 246, 1],
mipLevelCount: 1,
sampleCount: 4,
format: 'depth24plus-stencil8',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
}
);
let computePassEncoder8 = commandEncoder18.beginComputePass(
{
label: '\u3c3a\u3c01\u01b6\u{1f606}\ub665\ucb38\u46f4'
}
);
let renderBundleEncoder22 = device2.createRenderBundleEncoder(
{
label: '\u21ce\u26d9\ufcf2\u0203\u0d48\u{1febe}\u2cdd',
colorFormats: [
'r16sint',
'rg8sint',
undefined,
'rg11b10ufloat',
'rgba32sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 399,
depthReadOnly: true,
stencilReadOnly: true,
}
);
try {
renderBundleEncoder22.setVertexBuffer(
34,
undefined,
3551239995
);
} catch {}
let imageData3 = new ImageData(224, 136);
let bindGroupLayout12 = device2.createBindGroupLayout(
{
entries: [
{
binding: 1393,
visibility: 0,
buffer: { type: 'read-only-storage', minBindingSize: 0, hasDynamicOffset: false },
},
{
binding: 1303,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
},
{
binding: 3670,
visibility: GPUShaderStage.FRAGMENT,
buffer: { type: 'storage', minBindingSize: 0, hasDynamicOffset: false },
}
],
}
);
let bindGroup2 = device2.createBindGroup({
layout: bindGroupLayout8,
entries: [
{
binding: 175,
resource: sampler18
},
{
binding: 2768,
resource: sampler18
}
],
});
let renderBundleEncoder23 = device2.createRenderBundleEncoder(
{
label: '\u{1f6ec}\ubb76\u6c26\ub08d\uac55\u861b\u497e\u{1f95f}\u4ca4\u37c3',
colorFormats: [
'r16float',
'r16sint',
'rgba8sint',
'rgb10a2unorm',
'r8unorm',
'r32uint',
'rg32sint',
'rg32uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 825,
depthReadOnly: true,
}
);
let renderBundle23 = renderBundleEncoder23.finish(
{
label: '\u{1f906}\u03ab\u{1f9ad}'
}
);
try {
renderBundleEncoder22.setBindGroup(
4,
bindGroup2
);
} catch {}
let pipelineLayout5 = device1.createPipelineLayout(
{
label: '\uc3c9\u{1fa56}\u00fb',
bindGroupLayouts: [
bindGroupLayout11,
bindGroupLayout9,
bindGroupLayout9,
bindGroupLayout11,
bindGroupLayout11,
bindGroupLayout11
]
}
);
let commandEncoder20 = device1.createCommandEncoder(
{
label: '\u3679\ufc1c\u90eb\ud307',
}
);
let querySet16 = device1.createQuerySet({
label: '\u35f5\u09c0\u0cf6\u{1fd5c}\uce0f\u1aab\u0333\u03f0\u{1fe0c}',
type: 'occlusion',
count: 1349,
});
let texture27 = device1.createTexture(
{
label: '\u0726\u{1fc7b}\u221b\uf2f8\u{1f6de}\u{1f789}\u{1f919}',
size: {width: 14473, height: 177, depthOrArrayLayers: 24},
mipLevelCount: 5,
format: 'depth32float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
}
);
try {
computePassEncoder5.setPipeline(
pipeline17
);
} catch {}
canvas5.width = 21;
let pipelineLayout6 = device1.createPipelineLayout(
{
label: '\u257d\u0b3b\u04c6\uc8f4',
bindGroupLayouts: [
bindGroupLayout9,
bindGroupLayout11,
bindGroupLayout11,
bindGroupLayout9,
bindGroupLayout11,
bindGroupLayout11
]
}
);
let renderPassEncoder4 = commandEncoder20.beginRenderPass(
{
label: '\u0fc2\u{1fa19}\ud0ed\u0578\u{1fe0e}\u54d8',
colorAttachments: [
undefined,
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: 0.2387826659529393,
depthLoadOp: 'clear',
depthStoreOp: 'store',
depthReadOnly: false,
stencilClearValue: 65389,
},
occlusionQuerySet: querySet15,
maxDrawCount: 48616,
}
);
let sampler19 = device1.createSampler(
{
label: '\uec92\uf4fd\u70f1\u2d3b\ue693\u049b\u{1fb23}\ueac6\u{1f655}\ubc6b',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 99.225,
lodMaxClamp: 99.581,
}
);
try {
renderPassEncoder4.executeBundles([]);
} catch {}
try {
renderPassEncoder4.setVertexBuffer(
49,
undefined,
3199817043,
766908855
);
} catch {}
document.body.prepend(img0);
let textureView15 = texture26.createView(
{
}
);
try {
computePassEncoder7.setPipeline(
pipeline17
);
} catch {}
try {
renderPassEncoder4.end();
} catch {}
try {
computePassEncoder5.pushDebugGroup(
'\u91bf'
);
} catch {}
let pipeline18 = device1.createComputePipeline(
{
label: '\u10da\u{1fe75}\u{1febc}\u0ae4\u2925',
layout: pipelineLayout5,
compute: {
module: shaderModule6,
entryPoint: 'compute0',
},
}
);
let img3 = await imageWithData(222, 134, '#8944fcce', '#0ea83fcd');
let video3 = await videoWithData();
let shaderModule7 = device2.createShaderModule(
{
label: '\u0321\uea19\u{1fa94}\u0262\u0530\u82d2\u10f8\u00b9',
code: `@group(3) @binding(175)
var<storage, read_write> i4: array<u32>;
@group(4) @binding(2768)
var<storage, read_write> function5: array<u32>;
@group(2) @binding(175)
var<storage, read_write> type3: array<u32>;
@group(3) @binding(2768)
var<storage, read_write> global5: array<u32>;
@group(1) @binding(175)
var<storage, read_write> type4: array<u32>;
@group(1) @binding(2768)
var<storage, read_write> global6: array<u32>;
@group(0) @binding(2768)
var<storage, read_write> parameter5: array<u32>;
@group(4) @binding(175)
var<storage, read_write> i5: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
let commandEncoder21 = device2.createCommandEncoder(
{
label: '\u0e60\uc08b\u{1fd59}\u26a6',
}
);
let querySet17 = device2.createQuerySet({
label: '\u{1f835}\u{1ff59}\u64c9\u0b78\u0249\ue1a3\u07a1',
type: 'occlusion',
count: 3782,
});
let renderPassEncoder5 = commandEncoder21.beginRenderPass(
{
label: '\ud78b\u131a',
colorAttachments: [
undefined,
undefined
],
depthStencilAttachment: {
view: textureView15,
depthLoadOp: 'load',
depthStoreOp: 'discard',
depthReadOnly: false,
stencilLoadOp: 'load',
stencilStoreOp: 'store',
},
occlusionQuerySet: querySet13,
}
);
try {
renderPassEncoder5.beginOcclusionQuery(797);
} catch {}
try {
renderBundleEncoder22.setBindGroup(
3,
bindGroup2
);
} catch {}
let pipeline19 = await device2.createComputePipelineAsync(
{
label: '\u0864\u0c4f\u85f1\u{1fa99}\u548c\u{1f9b8}\u39d4\u09de\u025c',
layout: pipelineLayout4,
compute: {
module: shaderModule7,
entryPoint: 'compute0',
constants: {},
},
}
);
let bindGroupLayout13 = device1.createBindGroupLayout(
{
label: '\u9346\ud590\u00ac\u{1fc36}',
entries: [
{
binding: 5301,
visibility: GPUShaderStage.VERTEX,
externalTexture: {},
},
{
binding: 3079,
visibility: GPUShaderStage.FRAGMENT,
storageTexture: { format: 'r32uint', access: 'write-only', viewDimension: '3d' },
}
],
}
);
let querySet18 = device1.createQuerySet({
type: 'occlusion',
count: 3572,
});
pseudoSubmit(device1, commandEncoder11);
let texture28 = device1.createTexture(
{
label: '\u07e9\u0a6f\u7c0b\u0970\u{1f890}',
size: [12973],
dimension: '1d',
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let textureView16 = texture27.createView(
{
label: '\u938a\u{1fbc2}\u08b6\u0bc4\ud108\u0102\u{1f670}\u055f\u{1f6b2}\u{1ff7a}\u0d10',
dimension: '2d',
aspect: 'depth-only',
baseMipLevel: 2,
mipLevelCount: 2,
baseArrayLayer: 3,
}
);
let promise4 = device1.popErrorScope();
let video4 = await videoWithData();
let shaderModule8 = device2.createShaderModule(
{
label: '\u0522\ub6ee\u{1fb30}\u{1fc99}\u0679\u{1fe75}\u06c9\u03b9\u040d\ud616\u0de1',
code: `@group(0) @binding(175)
var<storage, read_write> i6: array<u32>;
@group(1) @binding(175)
var<storage, read_write> field3: array<u32>;
@group(4) @binding(2768)
var<storage, read_write> parameter6: array<u32>;
@group(2) @binding(2768)
var<storage, read_write> field4: array<u32>;
@group(3) @binding(175)
var<storage, read_write> global7: array<u32>;
@group(2) @binding(175)
var<storage, read_write> function6: array<u32>;
@group(3) @binding(2768)
var<storage, read_write> field5: array<u32>;
@group(1) @binding(2768)
var<storage, read_write> local2: array<u32>;

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

struct S10 {
@location(57) f0: u32,
@location(19) f1: vec4<i32>,
@location(48) f2: vec4<f32>,
@location(89) f3: vec3<f16>,
@location(50) f4: f32,
@location(54) f5: vec3<f16>,
@location(80) f6: f32,
@builtin(sample_index) f7: u32,
@location(36) f8: vec4<i32>,
@location(58) f9: vec3<i32>,
@location(41) f10: vec2<f32>,
@location(84) f11: vec4<f32>,
@location(93) f12: vec2<u32>,
@location(90) f13: vec4<f32>,
@location(33) f14: vec2<f16>,
@location(62) f15: vec4<u32>,
@location(77) f16: vec4<f16>,
@location(13) f17: vec2<f16>,
@builtin(front_facing) f18: bool,
@location(0) f19: vec2<u32>,
@location(49) f20: vec2<f32>,
@location(67) f21: i32
}
struct FragmentOutput0 {
@location(0) f0: vec4<u32>,
@location(5) f1: vec2<u32>
}

@fragment
fn fragment0(@location(91) a0: vec3<f32>, @location(44) a1: vec4<u32>, @location(30) a2: u32, @location(56) a3: vec2<f16>, a4: S10, @location(1) a5: vec4<f16>, @location(68) a6: vec4<i32>, @location(86) a7: vec4<f32>, @builtin(position) a8: vec4<f32>, @location(10) a9: u32, @location(18) a10: i32, @location(34) a11: vec3<i32>, @location(45) a12: vec3<u32>, @location(46) a13: vec4<f32>, @location(39) a14: vec4<u32>, @location(71) a15: vec4<f16>, @location(63) a16: vec4<i32>, @builtin(sample_mask) a17: u32) -> FragmentOutput0 {
return FragmentOutput0();
}

struct S9 {
@location(10) f0: vec2<u32>,
@location(1) f1: vec4<f32>,
@location(0) f2: vec3<i32>,
@location(9) f3: u32,
@location(15) f4: vec4<f32>,
@location(7) f5: vec2<i32>,
@location(16) f6: vec2<u32>,
@location(4) f7: vec4<i32>,
@location(2) f8: f16,
@location(6) f9: vec3<f16>,
@location(11) f10: vec2<u32>,
@location(18) f11: vec2<i32>,
@location(12) f12: vec2<u32>,
@location(3) f13: vec3<f16>,
@location(17) f14: i32,
@location(5) f15: vec4<f16>
}
struct VertexOutput0 {
@location(36) f97: vec4<i32>,
@location(33) f98: vec2<f16>,
@builtin(position) f99: vec4<f32>,
@location(67) f100: i32,
@location(50) f101: f32,
@location(62) f102: vec4<u32>,
@location(44) f103: vec4<u32>,
@location(84) f104: vec4<f32>,
@location(56) f105: vec2<f16>,
@location(39) f106: vec4<u32>,
@location(89) f107: vec3<f16>,
@location(41) f108: vec2<f32>,
@location(86) f109: vec4<f32>,
@location(1) f110: vec4<f16>,
@location(58) f111: vec3<i32>,
@location(63) f112: vec4<i32>,
@location(45) f113: vec3<u32>,
@location(30) f114: u32,
@location(93) f115: vec2<u32>,
@location(77) f116: vec4<f16>,
@location(49) f117: vec2<f32>,
@location(46) f118: vec4<f32>,
@location(57) f119: u32,
@location(10) f120: u32,
@location(13) f121: vec2<f16>,
@location(90) f122: vec4<f32>,
@location(18) f123: i32,
@location(68) f124: vec4<i32>,
@location(54) f125: vec3<f16>,
@location(19) f126: vec4<i32>,
@location(48) f127: vec4<f32>,
@location(34) f128: vec3<i32>,
@location(0) f129: vec2<u32>,
@location(71) f130: vec4<f16>,
@location(91) f131: vec3<f32>,
@location(80) f132: f32
}

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

`,
sourceMap: {},
}
);
let textureView17 = texture26.createView(
{
label: '\ue67e\uc6a5\ufc4e\u05a9\uf24f\u5d4b\u0f95\u0496',
aspect: 'stencil-only',
baseArrayLayer: 0,
}
);
try {
computePassEncoder6.setBindGroup(
1,
bindGroup2,
new Uint32Array(200),
136,
0
);
} catch {}
try {
renderPassEncoder5.setBindGroup(
2,
bindGroup2
);
} catch {}
try {
renderPassEncoder5.endOcclusionQuery();
} catch {}
try {
renderPassEncoder5.executeBundles([]);
} catch {}
try {
renderBundleEncoder22.insertDebugMarker(
'\uae2d'
);
} catch {}
let pipeline20 = await device2.createRenderPipelineAsync(
{
label: '\u{1fbd9}\u0d5d\u84f7\u{1f9af}\u0820\ue6d0\u09d3',
layout: 'auto',
vertex: {
module: shaderModule8,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 49048,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint16x4',
offset: 53480,
shaderLocation: 12,
},
{
format: 'sint32x3',
offset: 32700,
shaderLocation: 4,
},
{
format: 'uint8x2',
offset: 25010,
shaderLocation: 10,
},
{
format: 'float32x3',
offset: 10800,
shaderLocation: 3,
},
{
format: 'uint32x4',
offset: 33716,
shaderLocation: 11,
},
{
format: 'uint32x4',
offset: 48520,
shaderLocation: 9,
},
{
format: 'sint32x3',
offset: 8712,
shaderLocation: 18,
},
{
format: 'snorm8x4',
offset: 33836,
shaderLocation: 15,
},
{
format: 'float32x4',
offset: 47476,
shaderLocation: 5,
},
{
format: 'float32x4',
offset: 700,
shaderLocation: 13,
},
{
format: 'unorm8x2',
offset: 51058,
shaderLocation: 14,
}
],
},
{
arrayStride: 37760,
stepMode: 'vertex',
attributes: [
{
format: 'sint8x4',
offset: 17824,
shaderLocation: 0,
},
{
format: 'sint8x4',
offset: 604,
shaderLocation: 7,
},
{
format: 'sint32x3',
offset: 28488,
shaderLocation: 17,
},
{
format: 'uint16x2',
offset: 33764,
shaderLocation: 8,
},
{
format: 'float32x2',
offset: 24756,
shaderLocation: 6,
}
],
},
{
arrayStride: 44708,
stepMode: 'instance',
attributes: [
{
format: 'unorm10-10-10-2',
offset: 40600,
shaderLocation: 1,
}
],
},
{
arrayStride: 26912,
stepMode: 'instance',
attributes: [
{
format: 'float16x2',
offset: 25852,
shaderLocation: 2,
},
{
format: 'uint32x4',
offset: 12732,
shaderLocation: 16,
}
],
}
]
},
primitive: {
topology: 'point-list',
frontFace: 'cw',
cullMode: 'back',
unclippedDepth: true,
},
fragment: {
module: shaderModule8,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r32uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
undefined,
undefined,
undefined,
{
format: 'r32uint',
writeMask: GPUColorWrite.GREEN,
},
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'less',
stencilFront: {
passOp: 'decrement-clamp',
},
stencilBack: {
compare: 'equal',
failOp: 'decrement-wrap',
depthFailOp: 'increment-clamp',
passOp: 'zero',
},
stencilWriteMask: 2248,
depthBias: 16,
depthBiasSlopeScale: 45,
},
}
);
try {
device2.destroy();
} catch {}
let offscreenCanvas3 = new OffscreenCanvas(139, 690);
let imageBitmap3 = await createImageBitmap(canvas2);
canvas0.height = 251;
try {
adapter3.label = '\u{1ff3f}\u1484\uc2e5\u{1ffdd}\u0aac\u4553\u026e\u{1ffe0}\u0fee';
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
let video5 = await videoWithData();
try {
offscreenCanvas3.getContext('webgl');
} catch {}
try {
adapter2.label = '\udc83\u400c\u54b8\ude6c\u07b9\u0167';
} catch {}
let commandEncoder22 = device1.createCommandEncoder(
{
label: '\ud238\u0caf\u{1face}',
}
);
let texture29 = device1.createTexture(
{
label: '\u0f54\uaf2e\u3efc\u{1f737}\u1eff\u582d\u0c4b\u1c5f\u{1f883}',
size: [5024, 171, 1],
mipLevelCount: 12,
sampleCount: 1,
format: 'rg8sint',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
}
);
let textureView18 = texture25.createView(
{
label: '\u03a9\u8a83\u0955\u0d2d\ud5b5\u0e83\u21a5\ue788\uda57',
mipLevelCount: 1,
}
);
let renderPassEncoder6 = commandEncoder22.beginRenderPass(
{
label: '\u1cd3\u0c84',
colorAttachments: [
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthReadOnly: true,
stencilReadOnly: true,
},
occlusionQuerySet: querySet18,
maxDrawCount: 75328,
}
);
try {
renderPassEncoder6.setBlendConstant({ r: -564.1, g: 606.5, b: 216.9, a: 839.7, });
} catch {}
try {
renderPassEncoder6.setViewport(
6.371,
42.48,
2.575,
0.7367,
0.9892,
0.9955
);
} catch {}
let pipeline21 = device1.createRenderPipeline(
{
label: '\u94bf\udafd\u0047\u0957\u5ad3\u0f5e\u80ec\u0a4c\u03f0\u06b7',
layout: 'auto',
vertex: {
module: shaderModule6,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 3788,
stepMode: 'instance',
attributes: [
{
format: 'float16x2',
offset: 3132,
shaderLocation: 18,
},
{
format: 'uint32x2',
offset: 2844,
shaderLocation: 12,
},
{
format: 'snorm16x2',
offset: 2128,
shaderLocation: 14,
},
{
format: 'float16x4',
offset: 1904,
shaderLocation: 4,
},
{
format: 'float32',
offset: 1464,
shaderLocation: 0,
},
{
format: 'sint32x4',
offset: 3044,
shaderLocation: 3,
},
{
format: 'uint32x3',
offset: 940,
shaderLocation: 19,
},
{
format: 'sint8x2',
offset: 376,
shaderLocation: 7,
},
{
format: 'float32',
offset: 3240,
shaderLocation: 16,
},
{
format: 'sint8x4',
offset: 2880,
shaderLocation: 5,
},
{
format: 'float32x2',
offset: 1152,
shaderLocation: 17,
},
{
format: 'snorm16x4',
offset: 2848,
shaderLocation: 13,
},
{
format: 'snorm16x4',
offset: 3048,
shaderLocation: 1,
},
{
format: 'snorm16x2',
offset: 2772,
shaderLocation: 8,
},
{
format: 'float16x2',
offset: 1716,
shaderLocation: 9,
},
{
format: 'unorm10-10-10-2',
offset: 788,
shaderLocation: 15,
},
{
format: 'uint8x4',
offset: 3292,
shaderLocation: 11,
},
{
format: 'sint16x4',
offset: 3288,
shaderLocation: 6,
},
{
format: 'unorm16x4',
offset: 3064,
shaderLocation: 10,
}
],
},
{
arrayStride: 644,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 5276,
stepMode: 'instance',
attributes: [
{
format: 'float32x3',
offset: 2784,
shaderLocation: 2,
}
],
}
]
},
multisample: {
mask: 0x1d8235c3,
},
fragment: {
module: shaderModule6,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rg16sint',
writeMask: GPUColorWrite.GREEN,
},
{
format: 'r16uint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
{
format: 'r32uint',
writeMask: GPUColorWrite.BLUE | GPUColorWrite.RED,
},
{
format: 'r8sint',
},
{
blend: {
color: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'reverse-subtract',
srcFactor: 'one-minus-dst',
dstFactor: 'dst-alpha'
},
},
format: 'rg8unorm',
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'greater-equal',
stencilFront: {
compare: 'not-equal',
failOp: 'zero',
depthFailOp: 'replace',
passOp: 'decrement-wrap',
},
stencilBack: {
compare: 'never',
failOp: 'decrement-clamp',
depthFailOp: 'increment-wrap',
passOp: 'decrement-wrap',
},
stencilWriteMask: 3233,
depthBias: 1,
depthBiasSlopeScale: 27,
depthBiasClamp: 74,
},
}
);
let offscreenCanvas4 = new OffscreenCanvas(91, 321);
let imageData4 = new ImageData(12, 140);
video1.height = 174;
gc();
document.body.prepend(img3);
try {
offscreenCanvas4.getContext('webgl2');
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
try {
commandEncoder19.label = '\u{1fe85}\u97ba\u0396\u04d4\ue252\u0686\u{1f902}\u482a\u0bd8\u649d\u94c6';
} catch {}
let imageBitmap4 = await createImageBitmap(video4);
gc();
let imageBitmap5 = await createImageBitmap(video5);
document.body.prepend(canvas1);
let imageData5 = new ImageData(112, 148);
let videoFrame4 = new VideoFrame(video1, {timestamp: 0});
let offscreenCanvas5 = new OffscreenCanvas(946, 323);
let querySet19 = device1.createQuerySet({
label: '\u50e7\u08d3\u0226\u0dce\u3f6b\u{1fdfe}\uefff\uec62\u{1fafb}\u0321',
type: 'occlusion',
count: 1477,
});
canvas0.height = 384;
let imageBitmap6 = await createImageBitmap(canvas3);
let imageData6 = new ImageData(116, 40);
let video6 = await videoWithData();
let texture30 = device1.createTexture(
{
label: '\u01e9\u{1fdb3}\ua05f\u5a08\u049a\u{1ffbe}\ub1fc\ud32c\u0b54',
size: {width: 3371, height: 223, depthOrArrayLayers: 50},
mipLevelCount: 11,
format: 'depth16unorm',
usage: GPUTextureUsage.COPY_SRC,
}
);
try {
renderPassEncoder6.executeBundles([]);
} catch {}
let promise5 = device1.queue.onSubmittedWorkDone();
let offscreenCanvas6 = new OffscreenCanvas(188, 398);
let img4 = await imageWithData(201, 70, '#0434943d', '#72c0a642');
let offscreenCanvas7 = new OffscreenCanvas(806, 363);
try {
await promise4;
} catch {}
document.body.prepend(canvas3);
try {
adapter2.label = '\ua2f4\u6854\u{1f79f}\u72f8\ud87c\u74a0';
} catch {}
let offscreenCanvas8 = new OffscreenCanvas(658, 379);
let adapter5 = await navigator.gpu.requestAdapter(
{
}
);
let gpuCanvasContext7 = offscreenCanvas8.getContext('webgpu');
let bindGroupLayout14 = device1.createBindGroupLayout(
{
label: '\uad6b\u7b4f\uc039\u03a0\u{1fe15}\u90b0\u{1f94e}\u0d31',
entries: [
{
binding: 5460,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
storageTexture: { format: 'rg32sint', access: 'write-only', viewDimension: '1d' },
},
{
binding: 6961,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
storageTexture: { format: 'r32uint', access: 'read-only', viewDimension: '3d' },
}
],
}
);
let querySet20 = device1.createQuerySet({
type: 'occlusion',
count: 2432,
});
let externalTexture3 = device1.importExternalTexture(
{
label: '\u0659\u{1fb07}\u604a\u8125\u{1fbc0}\u09a9\u99f5\u0820\u074f\u{1ff04}\u{1f617}',
source: video0,
colorSpace: 'srgb',
}
);
try {
renderPassEncoder6.setStencilReference(
490
);
} catch {}
try {
gpuCanvasContext6.configure(
{
device: device1,
format: 'bgra8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
alphaMode: 'opaque',
}
);
} catch {}
let pipeline22 = device1.createComputePipeline(
{
label: '\u2107\u9462',
layout: 'auto',
compute: {
module: shaderModule6,
entryPoint: 'compute0',
},
}
);
let video7 = await videoWithData();
try {
offscreenCanvas7.getContext('2d');
} catch {}
let shaderModule9 = device1.createShaderModule(
{
label: '\u5249\uf8e0\u0903\u0d74\u47b7\ua8fa\u008f\u0942',
code: `@group(1) @binding(1199)
var<storage, read_write> global8: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> type5: array<u32>;
@group(4) @binding(5363)
var<storage, read_write> global9: array<u32>;
@group(5) @binding(5363)
var<storage, read_write> function7: array<u32>;
@group(0) @binding(5363)
var<storage, read_write> function8: array<u32>;
@group(3) @binding(7532)
var<storage, read_write> type6: array<u32>;
@group(2) @binding(1199)
var<storage, read_write> function9: array<u32>;
@group(1) @binding(1832)
var<storage, read_write> function10: array<u32>;
@group(5) @binding(7532)
var<storage, read_write> global10: array<u32>;
@group(0) @binding(7532)
var<storage, read_write> function11: array<u32>;
@group(3) @binding(5363)
var<storage, read_write> global11: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> field6: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
let buffer6 = device1.createBuffer(
{
label: '\u2461\u{1fea8}\u497f\u1edc\uc13e\u0a75\ub1b7\u025d\u{1fd0c}',
size: 2340,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
mappedAtCreation: true,
}
);
try {
renderPassEncoder6.beginOcclusionQuery(3126);
} catch {}
try {
renderPassEncoder6.setViewport(
6.271,
17.24,
10.11,
22.49,
0.1419,
0.4708
);
} catch {}
let pipeline23 = await device1.createComputePipelineAsync(
{
label: '\ub5a2\u{1f90e}\u{1fa2f}\u628d\u8685\u0568\u{1ffac}\u0f8d\u27c2',
layout: 'auto',
compute: {
module: shaderModule6,
entryPoint: 'compute0',
},
}
);
let pipeline24 = device1.createRenderPipeline(
{
label: '\u0771\u0612\u02a0\ud434\u{1fa3c}\u7a63\uf7cf\ua7a6\ucea6\u01fb',
layout: pipelineLayout3,
vertex: {
module: shaderModule6,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 7224,
stepMode: 'vertex',
attributes: [
{
format: 'sint32x3',
offset: 3024,
shaderLocation: 7,
},
{
format: 'uint16x4',
offset: 1036,
shaderLocation: 12,
},
{
format: 'sint32x2',
offset: 5088,
shaderLocation: 3,
},
{
format: 'unorm10-10-10-2',
offset: 3912,
shaderLocation: 16,
},
{
format: 'unorm16x4',
offset: 1780,
shaderLocation: 15,
},
{
format: 'float32',
offset: 4424,
shaderLocation: 1,
},
{
format: 'uint32',
offset: 2080,
shaderLocation: 11,
},
{
format: 'float16x4',
offset: 24,
shaderLocation: 0,
},
{
format: 'unorm8x4',
offset: 1840,
shaderLocation: 13,
},
{
format: 'uint8x4',
offset: 2904,
shaderLocation: 19,
},
{
format: 'sint32x2',
offset: 5860,
shaderLocation: 5,
},
{
format: 'snorm16x2',
offset: 264,
shaderLocation: 18,
},
{
format: 'unorm10-10-10-2',
offset: 6112,
shaderLocation: 2,
},
{
format: 'float32',
offset: 2148,
shaderLocation: 4,
}
],
},
{
arrayStride: 0,
stepMode: 'vertex',
attributes: [
{
format: 'snorm8x2',
offset: 3576,
shaderLocation: 17,
},
{
format: 'snorm8x2',
offset: 2086,
shaderLocation: 8,
},
{
format: 'snorm8x4',
offset: 988,
shaderLocation: 9,
},
{
format: 'unorm10-10-10-2',
offset: 6304,
shaderLocation: 10,
}
],
},
{
arrayStride: 5944,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 7376,
stepMode: 'vertex',
attributes: [
{
format: 'sint32x2',
offset: 6232,
shaderLocation: 6,
}
],
},
{
arrayStride: 6836,
stepMode: 'instance',
attributes: [
{
format: 'snorm8x4',
offset: 5396,
shaderLocation: 14,
}
],
}
]
},
primitive: {
frontFace: 'ccw',
cullMode: 'back',
unclippedDepth: false,
},
fragment: {
module: shaderModule6,
entryPoint: 'fragment0',
targets: [
{
format: 'r16sint',
},
{
format: 'r16uint',
},
undefined,
{
format: 'r8uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
},
{
format: 'rg32sint',
writeMask: GPUColorWrite.GREEN,
},
{
format: 'rg8unorm',
writeMask: GPUColorWrite.RED,
},
{
format: 'rgba32sint',
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'equal',
stencilFront: {
compare: 'not-equal',
failOp: 'zero',
depthFailOp: 'increment-clamp',
passOp: 'replace',
},
stencilBack: {
compare: 'less',
failOp: 'decrement-wrap',
depthFailOp: 'zero',
passOp: 'replace',
},
stencilReadMask: 620,
stencilWriteMask: 2586,
depthBias: 28,
depthBiasSlopeScale: 79,
depthBiasClamp: 9,
},
}
);
let gpuCanvasContext8 = offscreenCanvas6.getContext('webgpu');
let videoFrame5 = new VideoFrame(imageBitmap3, {timestamp: 0});
try {
offscreenCanvas5.getContext('2d');
} catch {}
let texture31 = device1.createTexture(
{
label: '\u{1fa94}\u1bd8\u829a\u09da\u5221',
size: [13018, 172, 1],
mipLevelCount: 9,
sampleCount: 1,
format: 'depth16unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
}
);
let renderBundle24 = renderBundleEncoder16.finish(
{
label: '\u{1fdc8}\u{1fb82}\u0ae3\uf46a\ud762\u013e\u06f9\u0fe3\u0404'
}
);
try {
gpuCanvasContext7.configure(
{
device: device1,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [
'rgba8unorm-srgb'
],
colorSpace: 'srgb',
alphaMode: 'premultiplied',
}
);
} catch {}
let pipeline25 = device1.createComputePipeline(
{
label: '\u034c\u0dfe\u09b9\u{1fe72}\u4827\u{1febf}\u0dd9\u{1fc39}',
layout: pipelineLayout5,
compute: {
module: shaderModule6,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline26 = device1.createRenderPipeline(
{
label: '\u{1f6c1}\u1528\u03b3',
layout: pipelineLayout3,
vertex: {
module: shaderModule6,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 2692,
shaderLocation: 12,
},
{
format: 'sint16x2',
offset: 1652,
shaderLocation: 6,
},
{
format: 'float32x2',
offset: 732,
shaderLocation: 10,
},
{
format: 'sint8x4',
offset: 4688,
shaderLocation: 7,
},
{
format: 'float16x4',
offset: 4584,
shaderLocation: 13,
},
{
format: 'float32x3',
offset: 420,
shaderLocation: 18,
}
],
},
{
arrayStride: 4556,
attributes: [
{
format: 'float32x4',
offset: 1264,
shaderLocation: 2,
},
{
format: 'uint32',
offset: 1704,
shaderLocation: 11,
},
{
format: 'snorm8x4',
offset: 4516,
shaderLocation: 0,
},
{
format: 'unorm8x4',
offset: 656,
shaderLocation: 9,
},
{
format: 'snorm16x4',
offset: 4504,
shaderLocation: 14,
},
{
format: 'unorm10-10-10-2',
offset: 828,
shaderLocation: 17,
},
{
format: 'float32x4',
offset: 2908,
shaderLocation: 4,
},
{
format: 'unorm16x4',
offset: 196,
shaderLocation: 15,
},
{
format: 'unorm10-10-10-2',
offset: 3084,
shaderLocation: 1,
},
{
format: 'uint8x2',
offset: 1872,
shaderLocation: 19,
},
{
format: 'float16x4',
offset: 2556,
shaderLocation: 8,
}
],
},
{
arrayStride: 2152,
stepMode: 'vertex',
attributes: [
{
format: 'sint32',
offset: 2144,
shaderLocation: 3,
},
{
format: 'float32x2',
offset: 1244,
shaderLocation: 16,
},
{
format: 'sint8x4',
offset: 1168,
shaderLocation: 5,
}
],
}
]
},
primitive: {
topology: 'line-strip',
stripIndexFormat: 'uint16',
cullMode: 'back',
unclippedDepth: false,
},
multisample: {
count: 4,
mask: 0x43532948,
},
fragment: {
module: shaderModule6,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r8sint',
writeMask: GPUColorWrite.BLUE,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'not-equal',
stencilFront: {
compare: 'equal',
depthFailOp: 'zero',
passOp: 'zero',
},
stencilBack: {
compare: 'equal',
failOp: 'increment-clamp',
depthFailOp: 'invert',
passOp: 'increment-wrap',
},
stencilWriteMask: 1299,
depthBias: 30,
depthBiasSlopeScale: 78,
depthBiasClamp: 23,
},
}
);
let img5 = await imageWithData(51, 43, '#4fd65f6e', '#22a1bb02');
let canvas9 = document.createElement('canvas');
let gpuCanvasContext9 = canvas9.getContext('webgpu');
gc();
let buffer7 = device1.createBuffer(
{
size: 49205,
usage: GPUBufferUsage.QUERY_RESOLVE,
}
);
let texture32 = device1.createTexture(
{
label: '\u0d9f\u2b5d\u59f1\u10c7\ue2bd',
size: [8121],
dimension: '1d',
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
}
);
let renderBundle25 = renderBundleEncoder19.finish(
{
label: '\u021c\u{1ff76}\u{1f85e}'
}
);
try {
computePassEncoder5.setPipeline(
pipeline25
);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.setVertexBuffer(
82,
undefined
);
} catch {}
try {
computePassEncoder5.popDebugGroup();
} catch {}
let promise6 = navigator.gpu.requestAdapter(
{
}
);
let querySet21 = device0.createQuerySet({
label: '\u0ac4\ubb20\u{1fb0c}',
type: 'occlusion',
count: 3733,
});
let commandBuffer6 = commandEncoder10.finish(
{
}
);
let texture33 = device0.createTexture(
{
size: [110, 68, 188],
mipLevelCount: 7,
sampleCount: 1,
format: 'astc-5x4-unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
viewFormats: [
'astc-5x4-unorm',
'astc-5x4-unorm-srgb'
],
}
);
let textureView19 = texture11.createView(
{
label: '\u5b55\u002a\u07ba\ud864\u0d7b\u0842\uf2bf\u0183',
dimension: '2d-array',
}
);
try {
renderPassEncoder1.setBlendConstant({ r: 740.5, g: -296.4, b: 360.7, a: 223.3, });
} catch {}
try {
renderPassEncoder2.setScissorRect(
1,
3,
1,
3
);
} catch {}
try {
renderBundleEncoder20.setVertexBuffer(
95,
undefined,
222608422
);
} catch {}
try {
await promise5;
} catch {}
let video8 = await videoWithData();
try {
window.someLabel = device0.label;
} catch {}
let buffer8 = device1.createBuffer(
{
size: 46432,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.UNIFORM,
mappedAtCreation: true,
}
);
let querySet22 = device1.createQuerySet({
label: '\u7915\u7336\u3737\u6093\u0921\u0861\u035f\u209d\ue7b2\u0e11',
type: 'occlusion',
count: 3728,
});
try {
renderPassEncoder6.executeBundles([]);
} catch {}
try {
renderPassEncoder6.setViewport(
18.57,
8.094,
2.112,
22.53,
0.7056,
0.8573
);
} catch {}
try {
gpuCanvasContext3.unconfigure();
} catch {}
offscreenCanvas1.width = 763;
try {
adapter5.label = '\u0453\ua579\u{1fa6e}';
} catch {}
let shaderModule10 = device1.createShaderModule(
{
label: '\u{1f9d8}\uf4bc\ueb2d\uc6a3\ue946\u5878\u0c74\u{1fee8}\ucd00\u{1ff6b}\u5854',
code: `@group(3) @binding(1832)
var<storage, read_write> field7: array<u32>;
@group(5) @binding(1832)
var<storage, read_write> parameter7: array<u32>;
@group(6) @binding(1832)
var<storage, read_write> function12: array<u32>;
@group(1) @binding(1199)
var<storage, read_write> i7: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> type7: array<u32>;
@group(1) @binding(1832)
var<storage, read_write> parameter8: array<u32>;
@group(2) @binding(1199)
var<storage, read_write> global12: array<u32>;
@group(7) @binding(1199)
var<storage, read_write> global13: array<u32>;
@group(6) @binding(1199)
var<storage, read_write> local3: array<u32>;
@group(5) @binding(1199)
var<storage, read_write> global14: array<u32>;
@group(0) @binding(1832)
var<storage, read_write> global15: array<u32>;
@group(4) @binding(1199)
var<storage, read_write> i8: array<u32>;
@group(3) @binding(1199)
var<storage, read_write> i9: array<u32>;
@group(7) @binding(1832)
var<storage, read_write> i10: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> i11: array<u32>;

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

struct S12 {
@builtin(position) f0: vec4<f32>,
@location(69) f1: f16,
@location(44) f2: vec4<i32>,
@location(64) f3: u32,
@location(8) f4: vec2<i32>,
@location(35) f5: vec4<f16>,
@builtin(sample_mask) f6: u32,
@location(4) f7: vec2<f32>,
@builtin(sample_index) f8: u32,
@location(22) f9: vec3<i32>
}
struct FragmentOutput0 {
@location(6) f0: vec3<i32>,
@location(4) f1: vec4<i32>
}

@fragment
fn fragment0(@location(43) a0: vec4<u32>, @location(41) a1: vec4<f32>, @location(59) a2: vec3<i32>, @location(23) a3: f16, @location(34) a4: vec2<u32>, @location(25) a5: vec2<f16>, a6: S12, @location(30) a7: vec2<f16>, @location(14) a8: i32, @location(11) a9: u32, @location(16) a10: i32, @location(51) a11: vec4<f16>, @location(55) a12: vec2<f16>, @location(29) a13: vec2<u32>, @location(47) a14: i32, @location(48) a15: vec2<u32>) -> FragmentOutput0 {
return FragmentOutput0();
}

struct S11 {
@location(2) f0: vec2<i32>,
@location(11) f1: vec4<f32>,
@location(9) f2: vec2<i32>,
@location(10) f3: f16,
@location(16) f4: vec4<i32>,
@builtin(instance_index) f5: u32,
@location(6) f6: vec4<f16>,
@location(3) f7: u32,
@location(17) f8: vec3<f32>,
@location(7) f9: vec2<i32>
}
struct VertexOutput0 {
@location(44) f133: vec4<i32>,
@location(29) f134: vec2<u32>,
@location(58) f135: u32,
@location(16) f136: i32,
@location(59) f137: vec3<i32>,
@location(48) f138: vec2<u32>,
@location(4) f139: vec2<f32>,
@location(47) f140: i32,
@location(51) f141: vec4<f16>,
@builtin(position) f142: vec4<f32>,
@location(23) f143: f16,
@location(64) f144: u32,
@location(14) f145: i32,
@location(34) f146: vec2<u32>,
@location(30) f147: vec2<f16>,
@location(41) f148: vec4<f32>,
@location(11) f149: u32,
@location(25) f150: vec2<f16>,
@location(55) f151: vec2<f16>,
@location(22) f152: vec3<i32>,
@location(43) f153: vec4<u32>,
@location(21) f154: f16,
@location(6) f155: vec4<f16>,
@location(8) f156: vec2<i32>,
@location(35) f157: vec4<f16>,
@location(69) f158: f16
}

@vertex
fn vertex0(@location(19) a0: f16, @location(15) a1: vec4<f16>, @location(4) a2: i32, @location(12) a3: f16, @location(8) a4: vec4<u32>, @location(18) a5: vec3<u32>, @location(5) a6: f32, @location(1) a7: vec2<f16>, @location(0) a8: vec3<f16>, a9: S11) -> VertexOutput0 {
  return VertexOutput0();
}

`,
sourceMap: {},
hints: {},
}
);
try {
computePassEncoder5.setPipeline(
pipeline18
);
} catch {}
try {
renderPassEncoder6.beginOcclusionQuery(1715);
} catch {}
try {
renderPassEncoder6.setScissorRect(
3,
31,
8,
6
);
} catch {}
try {
renderPassEncoder6.setIndexBuffer(
buffer8,
'uint32'
);
} catch {}
try {
computePassEncoder7.pushDebugGroup(
'\ub952'
);
} catch {}
let shaderModule11 = device1.createShaderModule(
{
label: '\u1fcc\u352c\u04bd\ubc6a\u{1fbdc}\u03a5\u{1fa2d}\u9828\u84ff\u51b3',
code: `@group(2) @binding(1199)
var<storage, read_write> field8: array<u32>;
@group(5) @binding(5363)
var<storage, read_write> field9: array<u32>;
@group(5) @binding(7532)
var<storage, read_write> i12: array<u32>;
@group(1) @binding(1832)
var<storage, read_write> field10: array<u32>;
@group(3) @binding(7532)
var<storage, read_write> type8: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> i13: array<u32>;
@group(4) @binding(5363)
var<storage, read_write> function13: array<u32>;
@group(0) @binding(7532)
var<storage, read_write> type9: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> i14: array<u32>;
@group(3) @binding(5363)
var<storage, read_write> local4: array<u32>;

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

struct S14 {
@location(15) f0: f32,
@location(39) f1: u32,
@location(16) f2: vec2<i32>,
@location(14) f3: vec4<f32>,
@location(1) f4: u32,
@location(31) f5: f32,
@location(41) f6: f16,
@location(63) f7: i32,
@location(4) f8: f32,
@location(59) f9: f32,
@location(28) f10: vec2<f16>,
@location(70) f11: vec3<u32>
}
struct FragmentOutput0 {
@location(1) f0: vec2<u32>,
@builtin(frag_depth) f1: f32,
@location(7) f2: f32,
@location(6) f3: i32,
@location(4) f4: f32,
@location(2) f5: vec4<f32>,
@builtin(sample_mask) f6: u32,
@location(0) f7: vec2<f32>,
@location(5) f8: i32,
@location(3) f9: vec4<f32>
}

@fragment
fn fragment0(@builtin(front_facing) a0: bool, a1: S14, @location(2) a2: vec3<f32>, @location(56) a3: vec2<u32>, @location(11) a4: f32, @location(66) a5: vec2<i32>, @location(48) a6: vec3<u32>, @location(22) a7: i32, @location(0) a8: f32, @location(36) a9: vec2<u32>, @location(33) a10: vec3<f16>, @location(7) a11: vec2<f32>, @location(34) a12: vec3<f16>, @location(40) a13: vec4<i32>, @location(23) a14: vec2<f16>, @builtin(position) a15: vec4<f32>, @builtin(sample_index) a16: u32, @builtin(sample_mask) a17: u32) -> FragmentOutput0 {
return FragmentOutput0();
}

struct S13 {
@location(0) f0: i32
}
struct VertexOutput0 {
@location(31) f159: f32,
@location(28) f160: vec2<f16>,
@location(14) f161: vec4<f32>,
@location(7) f162: vec2<f32>,
@location(70) f163: vec3<u32>,
@location(4) f164: f32,
@location(2) f165: vec3<f32>,
@location(48) f166: vec3<u32>,
@location(66) f167: vec2<i32>,
@location(15) f168: f32,
@location(16) f169: vec2<i32>,
@builtin(position) f170: vec4<f32>,
@location(0) f171: f32,
@location(41) f172: f16,
@location(59) f173: f32,
@location(1) f174: u32,
@location(36) f175: vec2<u32>,
@location(63) f176: i32,
@location(23) f177: vec2<f16>,
@location(56) f178: vec2<u32>,
@location(11) f179: f32,
@location(22) f180: i32,
@location(34) f181: vec3<f16>,
@location(39) f182: u32,
@location(40) f183: vec4<i32>,
@location(33) f184: vec3<f16>
}

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

`,
sourceMap: {},
hints: {},
}
);
let renderBundle26 = renderBundleEncoder19.finish(
{
label: '\u08d3\u7664\ud3a5\u{1fe52}\u0781'
}
);
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
try {
renderPassEncoder6.insertDebugMarker(
'\ue8b1'
);
} catch {}
canvas9.width = 263;
let device3 = await adapter5.requestDevice({
label: '\u8042\u3f1c\u2428\u30cf\u85a1\ua0b4\u3548\u33cc\u5a01\ud22a',
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'shader-f16',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 6,
maxColorAttachmentBytesPerSample: 40,
maxVertexAttributes: 18,
maxVertexBufferArrayStride: 52590,
maxStorageTexturesPerShaderStage: 16,
maxStorageBuffersPerShaderStage: 32,
maxDynamicStorageBuffersPerPipelineLayout: 5718,
maxBindingsPerBindGroup: 4259,
maxTextureArrayLayers: 256,
maxTextureDimension1D: 12144,
maxTextureDimension2D: 8817,
maxVertexBuffers: 12,
minStorageBufferOffsetAlignment: 64,
minUniformBufferOffsetAlignment: 128,
maxUniformBufferBindingSize: 3884253,
maxUniformBuffersPerShaderStage: 29,
maxInterStageShaderVariables: 95,
maxInterStageShaderComponents: 70,
maxSamplersPerShaderStage: 21,
},
});
let commandEncoder23 = device3.createCommandEncoder(
{
label: '\u1408\u{1fc8b}\u08af\u{1f8c4}\u50af\u6820\u02e3',
}
);
let promise7 = device3.queue.onSubmittedWorkDone();
try {
gpuCanvasContext8.unconfigure();
} catch {}
let video9 = await videoWithData();
video9.height = 294;
document.body.prepend(canvas1);
let offscreenCanvas9 = new OffscreenCanvas(324, 905);
let texture34 = device3.createTexture(
{
size: [62, 1, 1141],
mipLevelCount: 10,
dimension: '3d',
format: 'rgba16sint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba16sint'
],
}
);
let gpuCanvasContext10 = offscreenCanvas9.getContext('webgpu');
let texture35 = device0.createTexture(
{
label: '\u113b\u{1f93c}\u0462\u3676',
size: {width: 11058, height: 1, depthOrArrayLayers: 1},
mipLevelCount: 7,
format: 'r8snorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r8snorm'
],
}
);
let renderBundle27 = renderBundleEncoder21.finish(
{
label: '\u0084\u0ee5\u013f\u{1fff0}'
}
);
try {
renderPassEncoder6.beginOcclusionQuery(1866);
} catch {}
try {
renderPassEncoder6.endOcclusionQuery();
} catch {}
let video10 = await videoWithData();
try {
device3.queue.label = '\u5962\ue98d\ue358\u{1ffab}\u3683';
} catch {}
let commandEncoder24 = device3.createCommandEncoder(
{
label: '\u76a4\u1969\u0784\u0394\u834f\u2774\u0a59\u06ec',
}
);
let textureView20 = texture34.createView(
{
label: '\u0186\uca8f\u1f03\uf1f7\ubf94\u03ab\ubd13\u1945\u07fb\u3fd1',
baseMipLevel: 7,
mipLevelCount: 2,
}
);
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let bindGroupLayout15 = pipeline18.getBindGroupLayout(2);
let texture36 = device1.createTexture(
{
size: {width: 8192, height: 1, depthOrArrayLayers: 93},
mipLevelCount: 3,
format: 'depth24plus-stencil8',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'depth24plus-stencil8',
'depth24plus-stencil8'
],
}
);
try {
computePassEncoder5.setPipeline(
pipeline23
);
} catch {}
try {
renderPassEncoder6.end();
} catch {}
try {
gpuCanvasContext7.configure(
{
device: device1,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'bgra8unorm-srgb',
'rgba8unorm-srgb',
'rgba8unorm'
],
colorSpace: 'srgb',
alphaMode: 'opaque',
}
);
} catch {}
let querySet23 = device3.createQuerySet({
label: '\ua28e\u8fc0\u0a6a\u7a54\u7428\u0e96\ue043\u09f1\u3228',
type: 'occlusion',
count: 1187,
});
let texture37 = device3.createTexture(
{
label: '\u{1fbb9}\u{1fdc3}\u0403\u9f12\u9713',
size: {width: 204, height: 200, depthOrArrayLayers: 1},
format: 'etc2-rgb8a1unorm',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'etc2-rgb8a1unorm',
'etc2-rgb8a1unorm',
'etc2-rgb8a1unorm'
],
}
);
let textureView21 = texture37.createView(
{
label: '\u0cb5\ua6a9',
}
);
try {
device3.queue.writeTexture(
{
  texture: texture34,
  mipLevel: 0,
  origin: { x: 1, y: 0, z: 161 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 52697803 */{
offset: 647,
bytesPerRow: 700,
rowsPerImage: 83,
},
{width: 57, height: 1, depthOrArrayLayers: 908}
);
} catch {}
let bindGroupLayout16 = device1.createBindGroupLayout(
{
label: '\u04ba\u{1f984}\u{1f95e}\uaefa\u09bc\udfe6\u{1ff6d}',
entries: [
{
binding: 1495,
visibility: GPUShaderStage.COMPUTE,
buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: false },
},
{
binding: 7164,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
externalTexture: {},
}
],
}
);
pseudoSubmit(device1, commandEncoder22);
let sampler20 = device1.createSampler(
{
label: '\u{1fdcb}\udd79\uc03a\u{1f80b}\ua410\u91a2\u0096\u7989\u{1ff8c}\u2e13\ue6f4',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 30.189,
maxAnisotropy: 19,
}
);
let pipeline27 = device1.createRenderPipeline(
{
label: '\uaaf7\ufd1c\u{1f9d6}\ue62e\uc081\ue4b7\u7709\u{1f802}\u47d7\u992d',
layout: pipelineLayout6,
vertex: {
module: shaderModule9,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 44,
stepMode: 'instance',
attributes: [
{
format: 'snorm16x2',
offset: 36,
shaderLocation: 9,
},
{
format: 'unorm16x4',
offset: 20,
shaderLocation: 6,
},
{
format: 'uint8x4',
offset: 28,
shaderLocation: 1,
},
{
format: 'snorm16x2',
offset: 8,
shaderLocation: 2,
}
],
},
{
arrayStride: 4912,
stepMode: 'instance',
attributes: [
{
format: 'float32x3',
offset: 152,
shaderLocation: 13,
},
{
format: 'uint16x4',
offset: 4624,
shaderLocation: 16,
}
],
},
{
arrayStride: 4208,
stepMode: 'instance',
attributes: [
{
format: 'sint16x2',
offset: 4112,
shaderLocation: 4,
},
{
format: 'uint32',
offset: 980,
shaderLocation: 10,
}
],
}
]
},
primitive: {
topology: 'line-strip',
stripIndexFormat: 'uint16',
frontFace: 'ccw',
cullMode: 'back',
},
multisample: {
count: 4,
mask: 0x3da1de93,
},
fragment: {
module: shaderModule9,
entryPoint: 'fragment0',
constants: {},
targets: [

],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'less',
stencilFront: {
compare: 'greater',
failOp: 'decrement-clamp',
depthFailOp: 'increment-clamp',
passOp: 'decrement-wrap',
},
stencilBack: {
compare: 'greater-equal',
depthFailOp: 'decrement-wrap',
passOp: 'zero',
},
stencilWriteMask: 2459,
depthBiasClamp: 79,
},
}
);
let imageData7 = new ImageData(212, 40);
let textureView22 = texture34.createView(
{
label: '\u{1fdc0}\ud209\u0de6\u011b\u8d64\u2412\u0a8c\ub873\u7d15\u4bab',
baseMipLevel: 4,
mipLevelCount: 1,
}
);
let computePassEncoder9 = commandEncoder24.beginComputePass(
{

}
);
try {
await device3.queue.onSubmittedWorkDone();
} catch {}
let videoFrame6 = new VideoFrame(video2, {timestamp: 0});
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let videoFrame7 = videoFrame5.clone();
let commandEncoder25 = device1.createCommandEncoder(
{
label: '\udffc\u7d05',
}
);
let computePassEncoder10 = commandEncoder25.beginComputePass(
{
label: '\u09f5\u0d96\uc47e\u12ed\u89bf\u{1fcac}\ua0f5'
}
);
let renderBundleEncoder24 = device1.createRenderBundleEncoder(
{
label: '\uecb7\u06eb\u{1fc97}\u0162',
colorFormats: [
'rgba16sint',
'rgb10a2uint',
'r16sint',
'rg16float',
'rgba32uint',
'rg8sint',
'rgba8sint',
'r8unorm'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 704,
}
);
let renderBundle28 = renderBundleEncoder19.finish(
{
label: '\u{1f836}\u0ffe\u922e\u2654\u0305'
}
);
try {
computePassEncoder10.setPipeline(
pipeline17
);
} catch {}
let pipeline28 = await device1.createRenderPipelineAsync(
{
label: '\uebb7\u{1fbbd}\u{1f9f9}\u{1ff3d}\ub321\u5021',
layout: pipelineLayout5,
vertex: {
module: shaderModule6,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1504,
stepMode: 'instance',
attributes: [
{
format: 'sint8x4',
offset: 452,
shaderLocation: 5,
},
{
format: 'unorm10-10-10-2',
offset: 448,
shaderLocation: 10,
},
{
format: 'float32x4',
offset: 940,
shaderLocation: 16,
},
{
format: 'sint32',
offset: 180,
shaderLocation: 7,
},
{
format: 'unorm16x4',
offset: 340,
shaderLocation: 1,
},
{
format: 'sint16x4',
offset: 348,
shaderLocation: 3,
},
{
format: 'unorm16x2',
offset: 196,
shaderLocation: 18,
},
{
format: 'sint16x4',
offset: 1292,
shaderLocation: 6,
},
{
format: 'float16x4',
offset: 920,
shaderLocation: 13,
},
{
format: 'float32x3',
offset: 16,
shaderLocation: 14,
},
{
format: 'uint16x2',
offset: 1496,
shaderLocation: 11,
},
{
format: 'unorm10-10-10-2',
offset: 1204,
shaderLocation: 9,
},
{
format: 'float32x2',
offset: 448,
shaderLocation: 4,
},
{
format: 'snorm8x4',
offset: 1168,
shaderLocation: 8,
},
{
format: 'uint16x4',
offset: 892,
shaderLocation: 12,
},
{
format: 'unorm16x4',
offset: 360,
shaderLocation: 0,
},
{
format: 'uint8x2',
offset: 698,
shaderLocation: 19,
},
{
format: 'float32',
offset: 1080,
shaderLocation: 17,
}
],
},
{
arrayStride: 4992,
attributes: [

],
},
{
arrayStride: 5248,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 2300,
stepMode: 'instance',
attributes: [
{
format: 'float16x2',
offset: 1020,
shaderLocation: 2,
},
{
format: 'unorm16x2',
offset: 928,
shaderLocation: 15,
}
],
}
]
},
multisample: {
count: 4,
mask: 0x43cbb4ee,
},
fragment: {
module: shaderModule6,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r16sint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'r16uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}
],
},
}
);
let commandEncoder26 = device2.createCommandEncoder();
try {
renderPassEncoder5.setScissorRect(
14312,
76,
349,
15
);
} catch {}
let imageBitmap7 = await createImageBitmap(imageBitmap4);
let texture38 = device3.createTexture(
{
label: '\ufc7f\u{1ff23}\u0fdc\u9aea\u0636',
size: [40, 212, 1],
mipLevelCount: 2,
format: 'etc2-rgba8unorm-srgb',
usage: 0,
}
);
let renderBundleEncoder25 = device3.createRenderBundleEncoder(
{
label: '\u0686\ua25d\u{1f8c2}\u{1fb4c}\u09ef',
colorFormats: [
'rg32float'
],
sampleCount: 164,
depthReadOnly: true,
stencilReadOnly: true,
}
);
document.body.prepend(video3);
document.body.prepend(video0);
let imageData8 = new ImageData(56, 20);
let pipeline29 = device1.createRenderPipeline(
{
label: '\u{1fb3c}\u0a13\u815d\u5b83\u{1fca9}\u0a0e\u7fd2\ub9c8\u67ac\u0685',
layout: pipelineLayout5,
vertex: {
module: shaderModule10,
entryPoint: 'vertex0',
constants: {},
buffers: [
{
arrayStride: 2204,
stepMode: 'vertex',
attributes: [
{
format: 'unorm8x4',
offset: 1980,
shaderLocation: 5,
},
{
format: 'snorm8x4',
offset: 1768,
shaderLocation: 1,
}
],
},
{
arrayStride: 2044,
stepMode: 'vertex',
attributes: [
{
format: 'float32',
offset: 360,
shaderLocation: 19,
},
{
format: 'sint32',
offset: 944,
shaderLocation: 9,
},
{
format: 'float32x4',
offset: 400,
shaderLocation: 17,
},
{
format: 'float16x4',
offset: 600,
shaderLocation: 12,
},
{
format: 'sint16x4',
offset: 536,
shaderLocation: 4,
},
{
format: 'uint16x2',
offset: 244,
shaderLocation: 8,
},
{
format: 'float32x2',
offset: 1468,
shaderLocation: 0,
},
{
format: 'unorm10-10-10-2',
offset: 1036,
shaderLocation: 11,
},
{
format: 'snorm16x4',
offset: 160,
shaderLocation: 6,
},
{
format: 'uint32x4',
offset: 64,
shaderLocation: 18,
},
{
format: 'sint8x4',
offset: 416,
shaderLocation: 2,
},
{
format: 'sint32',
offset: 864,
shaderLocation: 7,
},
{
format: 'float32x4',
offset: 1732,
shaderLocation: 10,
},
{
format: 'uint32x2',
offset: 760,
shaderLocation: 3,
},
{
format: 'snorm8x4',
offset: 576,
shaderLocation: 15,
}
],
},
{
arrayStride: 6500,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 0,
attributes: [
{
format: 'sint32x3',
offset: 2216,
shaderLocation: 16,
}
],
}
]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint32',
cullMode: 'front',
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'not-equal',
stencilFront: {
compare: 'greater',
failOp: 'replace',
depthFailOp: 'decrement-clamp',
passOp: 'increment-clamp',
},
stencilBack: {
failOp: 'increment-wrap',
depthFailOp: 'increment-wrap',
passOp: 'zero',
},
stencilReadMask: 3977,
stencilWriteMask: 1844,
depthBias: 19,
depthBiasSlopeScale: 32,
depthBiasClamp: 93,
},
}
);
document.body.prepend(img3);
try {
adapter5.label = '\u{1f627}\u0f7c\u0a0d\ud230\u0e07\u9146\u{1fdf2}\ua3dc\ub99d\u0c0e\u059e';
} catch {}
let offscreenCanvas10 = new OffscreenCanvas(909, 683);
let textureView23 = texture38.createView(
{
label: '\u{1fb70}\u08e3\u7d5a\ue4dd\u0a9e\u{1fcbc}',
mipLevelCount: 1,
}
);
try {
computePassEncoder9.end();
} catch {}
try {
renderBundleEncoder25.setVertexBuffer(
72,
undefined,
1496753704,
2140911860
);
} catch {}
try {
await device3.queue.onSubmittedWorkDone();
} catch {}
try {
offscreenCanvas10.getContext('webgl');
} catch {}
let textureView24 = texture37.createView(
{
}
);
let renderPassEncoder7 = commandEncoder23.beginRenderPass(
{
label: '\u{1f623}\u7815\uc118\u{1f7cd}',
colorAttachments: [
undefined,
{
view: textureView22,
depthSlice: 26,
loadOp: 'clear',
storeOp: 'discard'
},
undefined,
{
view: textureView22,
depthSlice: 17,
clearValue: { r: -222.3, g: 815.5, b: -87.10, a: 405.8, },
loadOp: 'load',
storeOp: 'store'
},
undefined
],
occlusionQuerySet: querySet23,
maxDrawCount: 9472,
}
);
try {
renderBundleEncoder25.insertDebugMarker(
'\u397e'
);
} catch {}
try {
renderPassEncoder7.setStencilReference(
2549
);
} catch {}
try {
renderPassEncoder7.setViewport(
2.857,
0.4905,
0.00868,
0.4150,
0.6781,
0.9780
);
} catch {}
try {
await device3.popErrorScope();
} catch {}
try {
if (!arrayBuffer1.detached) { new Uint8Array(arrayBuffer1).fill(0x55) };
} catch {}
let buffer9 = device3.createBuffer(
{
label: '\u0207\u3ceb\u1d35\ucbbc\uc7f7',
size: 33886,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let commandEncoder27 = device3.createCommandEncoder();
let querySet24 = device3.createQuerySet({
label: '\u{1f93b}\u{1f870}\u277c\u66ec\uf351\u187e\u6053\u1f9b\uff55',
type: 'occlusion',
count: 2548,
});
try {
renderPassEncoder7.setScissorRect(
0,
0,
0,
0
);
} catch {}
try {
gpuCanvasContext3.configure(
{
device: device3,
format: 'rgba8sint',
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
colorSpace: 'srgb',
}
);
} catch {}
try {
await device3.queue.onSubmittedWorkDone();
} catch {}
try {
gpuCanvasContext8.unconfigure();
} catch {}
try {
await promise7;
} catch {}
let texture39 = device3.createTexture(
{
label: '\u{1fc22}\u1087',
size: [73, 73, 1],
mipLevelCount: 4,
format: 'stencil8',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [
'stencil8',
'stencil8',
'stencil8'
],
}
);
let computePassEncoder11 = commandEncoder24.beginComputePass(
{
label: '\u0f46\u001f\u615a\ud547\u0201\u0381\u33da\u0632\u{1fc38}\u9362\u0f6e'
}
);
try {
renderPassEncoder7.setScissorRect(
1,
0,
0,
0
);
} catch {}
try {
renderPassEncoder7.setViewport(
1.502,
0.03908,
0.5562,
0.6331,
0.2745,
0.9805
);
} catch {}
try {
device3.queue.writeTexture(
{
  texture: texture34,
  mipLevel: 8,
  origin: { x: 1, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer1,
/* required buffer size: 145268 */{
offset: 46,
bytesPerRow: 253,
rowsPerImage: 287,
},
{width: 0, height: 1, depthOrArrayLayers: 3}
);
} catch {}
let offscreenCanvas11 = new OffscreenCanvas(40, 243);
let imageData9 = new ImageData(4, 148);
let commandEncoder28 = device1.createCommandEncoder();
let querySet25 = device1.createQuerySet({
label: '\ub728\u4fdf\udf8f\u{1f889}\u06d2\u1e7f\u3289\u4e4b\u{1f6e6}\uf0c5\u0f4d',
type: 'occlusion',
count: 461,
});
try {
commandEncoder28.copyBufferToBuffer(
buffer3,
18212,
buffer6,
1328,
100
);
dissociateBuffer(device1, buffer3);
dissociateBuffer(device1, buffer6);
} catch {}
document.body.prepend(canvas7);
try {
adapter4.label = '\u{1fc05}\u3ef0\u{1fac7}';
} catch {}
try {
renderBundleEncoder24.setVertexBuffer(
75,
undefined,
2462618553,
838490477
);
} catch {}
let arrayBuffer2 = buffer6.getMappedRange(
0,
492
);
try {
computePassEncoder7.insertDebugMarker(
'\u8d15'
);
} catch {}
let adapter6 = await navigator.gpu.requestAdapter(
{
}
);
let offscreenCanvas12 = new OffscreenCanvas(507, 173);
let imageData10 = new ImageData(224, 212);
let commandEncoder29 = device3.createCommandEncoder(
{
}
);
let textureView25 = texture38.createView(
{
label: '\u4d58\u9677\u0615\u{1faa7}\uea08\u{1fc1c}',
dimension: '2d',
}
);
let computePassEncoder12 = commandEncoder29.beginComputePass();
let renderBundleEncoder26 = device3.createRenderBundleEncoder(
{
label: '\u{1ff34}\u35d5\uad20\u1b42\ua9ea\u03f2\ue27a\u0c4d\u{1f981}\u{1fe1e}',
colorFormats: [
'rg32sint',
'r32sint',
'r32uint',
undefined,
'rgba16uint',
undefined,
'rg32uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 530,
stencilReadOnly: true,
}
);
try {
renderPassEncoder7.beginOcclusionQuery(99);
} catch {}
try {
renderPassEncoder7.setVertexBuffer(
11,
undefined,
3215388387,
16773556
);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(
17,
undefined,
2587575995,
121555032
);
} catch {}
gc();
video7.width = 149;
try {
adapter6.label = '\u57c5\u{1fcfd}\u{1f650}\ua236\u06ba\u405b\u9623\u883d';
} catch {}
let video11 = await videoWithData();
let commandEncoder30 = device3.createCommandEncoder(
{
}
);
try {
gpuCanvasContext6.configure(
{
device: device3,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [
'rgba16float'
],
alphaMode: 'premultiplied',
}
);
} catch {}
try {
device3.queue.writeTexture(
{
  texture: texture34,
  mipLevel: 8,
  origin: { x: 0, y: 0, z: 3 },
  aspect: 'all',
},
new Uint8ClampedArray(arrayBuffer2),
/* required buffer size: 128 */{
offset: 128,
},
{width: 0, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let img6 = await imageWithData(119, 212, '#18600389', '#ca14bbab');
let bindGroupLayout17 = device3.createBindGroupLayout(
{
label: '\u0014\u8cbe\u0976\u065b\u{1f777}\u{1f8f0}\u{1f67c}',
entries: [

],
}
);
let commandEncoder31 = device3.createCommandEncoder(
{
}
);
let querySet26 = device3.createQuerySet({
label: '\u153c\u506c\u{1feea}\u4ec4\u0d2a',
type: 'occlusion',
count: 2245,
});
let renderPassEncoder8 = commandEncoder27.beginRenderPass(
{
label: '\u0a08\u{1fa46}\u9650\uf765\uc352\u027d\u{1f7c1}\u{1fe70}\ud522\u0a95',
colorAttachments: [
undefined,
{
view: textureView22,
depthSlice: 20,
loadOp: 'load',
storeOp: 'store'
},
undefined,
{
view: textureView22,
depthSlice: 61,
clearValue: { r: -962.5, g: 231.6, b: 496.7, a: 78.55, },
loadOp: 'load',
storeOp: 'discard'
},
{
view: textureView22,
depthSlice: 39,
clearValue: { r: -805.2, g: 898.6, b: -639.0, a: -863.6, },
loadOp: 'load',
storeOp: 'store'
},
{
view: textureView22,
depthSlice: 6,
loadOp: 'load',
storeOp: 'discard'
},
{
view: textureView22,
depthSlice: 53,
clearValue: { r: -235.8, g: -361.4, b: 576.2, a: 648.8, },
loadOp: 'load',
storeOp: 'discard'
}
],
occlusionQuerySet: querySet26,
maxDrawCount: 58728,
}
);
let renderBundleEncoder27 = device3.createRenderBundleEncoder(
{
label: '\u0269\ud74c\u{1fba2}\u0a8a\u8edb',
colorFormats: [
'rg8unorm',
'rg16float',
'rg16sint',
'rg16float',
'r32uint',
'r16sint'
],
sampleCount: 88,
stencilReadOnly: true,
}
);
let renderBundle29 = renderBundleEncoder25.finish(
{
label: '\u8e26\u{1f896}\u84d4\ue0b0'
}
);
try {
renderPassEncoder7.setStencilReference(
1730
);
} catch {}
try {
await device3.queue.onSubmittedWorkDone();
} catch {}
let bindGroupLayout18 = device1.createBindGroupLayout(
{
label: '\u25cb\ub9a9\u{1f919}\u241b\u082b\u5264',
entries: [
{
binding: 490,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
sampler: { type: 'filtering' },
},
{
binding: 2202,
visibility: GPUShaderStage.FRAGMENT,
texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
}
],
}
);
let commandEncoder32 = device1.createCommandEncoder(
{
}
);
let renderPassEncoder9 = commandEncoder28.beginRenderPass(
{
label: '\u{1fe8d}\u{1fb50}\u4a82\u0c30\u9953\u{1fa30}\ub116\u04d2\u8f71',
colorAttachments: [
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: -8.558060447596398,
depthReadOnly: true,
stencilClearValue: 5861,
stencilReadOnly: true,
},
occlusionQuerySet: querySet15,
}
);
let sampler21 = device1.createSampler(
{
label: '\u0d4d\u49d8\u{1fe79}\u{1fd54}\uf2ed\ube9c\u0eca',
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 41.321,
lodMaxClamp: 72.741,
maxAnisotropy: 3,
}
);
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setScissorRect(
16,
7,
5,
18
);
} catch {}
try {
commandEncoder32.clearBuffer(
buffer6
);
dissociateBuffer(device1, buffer6);
} catch {}
let imageData11 = new ImageData(20, 132);
let querySet27 = device1.createQuerySet({
label: '\u{1fee1}\u0995\u5f01\uf829\u0bc1\u0aaa\u{1f746}\uae3c',
type: 'occlusion',
count: 4070,
});
let renderPassEncoder10 = commandEncoder32.beginRenderPass(
{
label: '\u34c7\u01f3\u{1febb}\u3fd8\ue4f0\u0fb0\ued1f\u0cb5\u0dd1\u4691',
colorAttachments: [
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: -0.23973528284528633,
depthReadOnly: true,
stencilClearValue: 44227,
stencilReadOnly: true,
},
occlusionQuerySet: querySet19,
maxDrawCount: 61296,
}
);
try {
computePassEncoder5.end();
} catch {}
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(
buffer8,
'uint16',
31008,
1887
);
} catch {}
let promise8 = device1.queue.onSubmittedWorkDone();
let pipeline30 = await device1.createComputePipelineAsync(
{
label: '\u979e\u4bb0',
layout: 'auto',
compute: {
module: shaderModule11,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline31 = await device1.createRenderPipelineAsync(
{
label: '\u3e89\u83f3\u6ab5\u{1fc4f}\u83d1\u0ee9',
layout: pipelineLayout3,
vertex: {
module: shaderModule9,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 596,
stepMode: 'vertex',
attributes: [
{
format: 'float16x4',
offset: 296,
shaderLocation: 9,
}
],
},
{
arrayStride: 1616,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 1044,
shaderLocation: 10,
},
{
format: 'float32x4',
offset: 1060,
shaderLocation: 13,
},
{
format: 'sint32x4',
offset: 284,
shaderLocation: 4,
},
{
format: 'uint32x4',
offset: 968,
shaderLocation: 16,
},
{
format: 'uint16x4',
offset: 1204,
shaderLocation: 1,
}
],
},
{
arrayStride: 4120,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 4436,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 5036,
stepMode: 'instance',
attributes: [
{
format: 'float32x3',
offset: 1120,
shaderLocation: 2,
}
],
},
{
arrayStride: 520,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 0,
attributes: [

],
},
{
arrayStride: 2900,
stepMode: 'vertex',
attributes: [
{
format: 'float32x3',
offset: 1468,
shaderLocation: 6,
}
],
}
]
},
multisample: {
count: 4,
mask: 0x7b511cf2,
},
fragment: {
module: shaderModule9,
entryPoint: 'fragment0',
constants: {},
targets: [
{
blend: {
color: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'reverse-subtract',
srcFactor: 'dst',
dstFactor: 'src'
},
},
format: 'rg8unorm',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'greater',
stencilFront: {
failOp: 'increment-clamp',
depthFailOp: 'replace',
passOp: 'increment-clamp',
},
stencilBack: {
compare: 'always',
failOp: 'decrement-clamp',
depthFailOp: 'zero',
passOp: 'replace',
},
stencilReadMask: 739,
stencilWriteMask: 1464,
depthBias: 65,
depthBiasSlopeScale: 12,
depthBiasClamp: 16,
},
}
);
let video12 = await videoWithData();
try {
offscreenCanvas11.getContext('webgl');
} catch {}
try {
await promise8;
} catch {}
offscreenCanvas8.width = 27;
let videoFrame8 = new VideoFrame(videoFrame0, {timestamp: 0});
let shaderModule12 = device1.createShaderModule(
{
label: '\u{1f6d2}\uae08\u69ef\u3f71\u4e9b\u9220\u0038\u7938',
code: `@group(3) @binding(7532)
var<storage, read_write> field11: array<u32>;
@group(1) @binding(1199)
var<storage, read_write> type10: array<u32>;
@group(5) @binding(7532)
var<storage, read_write> field12: array<u32>;
@group(5) @binding(5363)
var<storage, read_write> local5: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> parameter9: array<u32>;
@group(0) @binding(5363)
var<storage, read_write> function14: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> global16: array<u32>;
@group(2) @binding(1199)
var<storage, read_write> function15: array<u32>;

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

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

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

struct S15 {
@location(13) f0: vec4<f32>,
@location(10) f1: i32,
@location(8) f2: vec2<i32>,
@location(18) f3: u32,
@location(15) f4: vec2<f32>,
@builtin(vertex_index) f5: u32,
@location(17) f6: vec4<f32>,
@location(1) f7: vec2<f32>,
@location(7) f8: vec2<i32>,
@location(0) f9: vec3<f32>,
@location(5) f10: vec2<i32>,
@location(14) f11: vec4<i32>,
@location(2) f12: u32
}

@vertex
fn vertex0(@location(19) a0: vec3<i32>, @location(6) a1: vec2<f32>, @builtin(instance_index) a2: u32, @location(4) a3: vec3<u32>, a4: S15, @location(11) a5: vec3<i32>, @location(3) a6: vec2<f32>, @location(16) a7: vec4<i32>, @location(12) a8: i32, @location(9) a9: vec4<i32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
sourceMap: {},
hints: {},
}
);
let bindGroupLayout19 = device1.createBindGroupLayout(
{
entries: [
{
binding: 3926,
visibility: GPUShaderStage.COMPUTE,
storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '1d' },
},
{
binding: 5558,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
}
],
}
);
let renderBundleEncoder28 = device1.createRenderBundleEncoder(
{
label: '\u7263\u5fca\udbc6\u12d1\u0608\ucfde\u431e\u01df',
colorFormats: [
'rg16float',
'rg16uint',
'rgba16uint',
'rgba32sint',
'r32uint',
'r32float'
],
sampleCount: 908,
depthReadOnly: true,
stencilReadOnly: false,
}
);
try {
renderPassEncoder10.setBlendConstant({ r: -229.0, g: -198.0, b: 179.1, a: 611.1, });
} catch {}
let pipeline32 = await device1.createComputePipelineAsync(
{
label: '\ucc62\ua9e1\u{1fdb0}\ua00f\u0990\u33e3\ufeb3\u78f9\u0753\u{1fb53}',
layout: pipelineLayout5,
compute: {
module: shaderModule11,
entryPoint: 'compute0',
constants: {},
},
}
);
let gpuCanvasContext11 = offscreenCanvas12.getContext('webgpu');
try {
querySet5.label = '\ufbf4\u{1fbe7}\uf82c\u181c\u0fb2\ud052\u{1fc67}\u0bf4\u1803';
} catch {}
let buffer10 = device0.createBuffer(
{
label: '\u247a\u09d0\u0653\ubd68\uc7a4\ubdc6',
size: 4840,
usage: GPUBufferUsage.VERTEX,
mappedAtCreation: true,
}
);
let renderPassEncoder11 = commandEncoder13.beginRenderPass(
{
label: '\u093d\u2760\u0b4e\u{1f88a}',
colorAttachments: [
undefined,
undefined,
undefined,
undefined,
{
view: textureView5,
clearValue: { r: 426.0, g: 950.5, b: 427.5, a: -366.9, },
loadOp: 'clear',
storeOp: 'store'
},
undefined
],
occlusionQuerySet: querySet5,
maxDrawCount: 67536,
}
);
let renderBundle30 = renderBundleEncoder9.finish(
{
label: '\uff1a\u7c3b\u{1fc72}\u{1ffaf}\u9b0e\u{1fd1e}\u{1fab7}\u{1f8f7}\u092f'
}
);
try {
renderPassEncoder2.endOcclusionQuery();
} catch {}
try {
renderPassEncoder11.setScissorRect(
1,
10,
0,
2
);
} catch {}
try {
renderPassEncoder2.setVertexBuffer(
5,
buffer10
);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(
7,
buffer10,
2112,
2170
);
} catch {}
let offscreenCanvas13 = new OffscreenCanvas(246, 147);
let pipelineLayout7 = device3.createPipelineLayout(
{
label: '\u0e31\u0834\u3343\u0404\u{1fc89}\u4a85\u0093\u{1f7c9}\u1814',
bindGroupLayouts: [
bindGroupLayout17,
bindGroupLayout17,
bindGroupLayout17,
bindGroupLayout17
]
}
);
let computePassEncoder13 = commandEncoder31.beginComputePass(
{
label: '\u9916\u8f16\u0e9b\u4721\uddea\u0b1c'
}
);
let renderBundle31 = renderBundleEncoder27.finish();
try {
renderPassEncoder8.beginOcclusionQuery(131);
} catch {}
try {
renderBundleEncoder26.setVertexBuffer(
36,
undefined
);
} catch {}
try {
renderPassEncoder8.insertDebugMarker(
'\u0c93'
);
} catch {}
try {
device3.destroy();
} catch {}
video10.width = 202;
let imageData12 = new ImageData(84, 228);
try {
await adapter5.requestAdapterInfo();
} catch {}
let buffer11 = device1.createBuffer(
{
size: 13660,
usage: GPUBufferUsage.INDEX | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
mappedAtCreation: false,
}
);
let querySet28 = device1.createQuerySet({
label: '\u0d05\u1cef\u2bd6\ue7ea',
type: 'occlusion',
count: 434,
});
let texture40 = device1.createTexture(
{
label: '\u{1fbe1}\u0a80',
size: [1000, 1, 1821],
mipLevelCount: 11,
sampleCount: 1,
dimension: '3d',
format: 'rgba32float',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'rgba32float',
'rgba32float',
'rgba32float'
],
}
);
let renderBundle32 = renderBundleEncoder16.finish(
{

}
);
try {
computePassEncoder10.setPipeline(
pipeline25
);
} catch {}
try {
renderPassEncoder10.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setViewport(
5.959,
34.20,
13.71,
1.569,
0.6755,
0.9800
);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(
buffer8,
'uint32',
24892,
5283
);
} catch {}
try {
buffer8.unmap();
} catch {}
try {
computePassEncoder7.popDebugGroup();
} catch {}
let promise9 = device1.queue.onSubmittedWorkDone();
document.body.prepend(canvas9);
try {
await promise9;
} catch {}
let offscreenCanvas14 = new OffscreenCanvas(678, 9);
try {
offscreenCanvas13.getContext('webgpu');
} catch {}
let device4 = await adapter4.requestDevice({
label: '\udee5\u{1f73a}\ue197\u{1fdd4}',
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
});
try {
renderPassEncoder10.end();
} catch {}
try {
renderPassEncoder9.beginOcclusionQuery(996);
} catch {}
try {
renderPassEncoder9.setBlendConstant({ r: -508.7, g: 992.4, b: -184.8, a: 173.6, });
} catch {}
try {
renderPassEncoder9.setViewport(
10.41,
40.99,
10.01,
2.083,
0.07882,
0.7586
);
} catch {}
try {
commandEncoder14.clearBuffer(
buffer6
);
dissociateBuffer(device1, buffer6);
} catch {}
try {
commandEncoder14.insertDebugMarker(
'\uf547'
);
} catch {}
try {
gpuCanvasContext4.configure(
{
device: device1,
format: 'bgra8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rg16uint',
'bgra8unorm'
],
alphaMode: 'opaque',
}
);
} catch {}
try {
window.someLabel = texture20.label;
} catch {}
let bindGroupLayout20 = device1.createBindGroupLayout(
{
label: '\u{1fea9}\ud803\uc981\u7e95\u0a3b',
entries: [

],
}
);
let pipelineLayout8 = device1.createPipelineLayout(
{
label: '\u05b9\ube58',
bindGroupLayouts: [
bindGroupLayout20,
bindGroupLayout14
]
}
);
let querySet29 = device1.createQuerySet({
label: '\u1ae0\uaecc\uca12\u2a18\u05bb\u042e',
type: 'occlusion',
count: 1788,
});
pseudoSubmit(device1, commandEncoder32);
let renderPassEncoder12 = commandEncoder14.beginRenderPass(
{
label: '\u9ac8\ubeed\u{1f942}\u0dee',
colorAttachments: [
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: -5.469348585567133,
depthLoadOp: 'load',
depthStoreOp: 'discard',
depthReadOnly: false,
stencilClearValue: 4064,
},
occlusionQuerySet: querySet18,
}
);
let renderBundleEncoder29 = device1.createRenderBundleEncoder(
{
colorFormats: [
'rgba16sint',
'r8unorm',
undefined,
'rgba32uint',
'r16uint',
'rgba16sint'
],
sampleCount: 496,
}
);
try {
computePassEncoder10.setPipeline(
pipeline23
);
} catch {}
try {
renderPassEncoder9.setStencilReference(
512
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture28,
  mipLevel: 0,
  origin: { x: 1420, y: 0, z: 1 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 269 */{
offset: 269,
rowsPerImage: 29,
},
{width: 10979, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let buffer12 = device1.createBuffer(
{
label: '\u0742\u04b4\u{1fc51}\u56fc\u0336\u{1f81b}\u{1fef6}\u{1faa4}\u{1fc6c}\uf78d',
size: 57608,
usage: GPUBufferUsage.MAP_WRITE,
mappedAtCreation: true,
}
);
let renderBundleEncoder30 = device1.createRenderBundleEncoder(
{
label: '\u0c13\u0162\u{1f9fe}\u01f1\u0e84',
colorFormats: [
'r8uint',
'rgba32sint'
],
sampleCount: 990,
depthReadOnly: false,
stencilReadOnly: true,
}
);
try {
renderPassEncoder12.executeBundles([]);
} catch {}
try {
renderPassEncoder12.setViewport(
2.912,
31.57,
6.281,
1.586,
0.4682,
0.4801
);
} catch {}
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture17,
  mipLevel: 5,
  origin: { x: 13, y: 0, z: 0 },
  aspect: 'all',
},
new DataView(new ArrayBuffer(80)),
/* required buffer size: 449545 */{
offset: 725,
bytesPerRow: 88,
rowsPerImage: 204,
},
{width: 5, height: 1, depthOrArrayLayers: 26}
);
} catch {}
let commandEncoder33 = device4.createCommandEncoder(
{
label: '\u031b\ud902\u73c5\u{1f8e3}\u{1f7d3}',
}
);
let texture41 = device4.createTexture(
{
size: {width: 164, height: 1, depthOrArrayLayers: 11},
mipLevelCount: 7,
format: 'stencil8',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'stencil8',
'stencil8',
'stencil8'
],
}
);
let videoFrame9 = new VideoFrame(canvas8, {timestamp: 0});
gc();
try {
offscreenCanvas14.getContext('webgpu');
} catch {}
let canvas10 = document.createElement('canvas');
try {
device3.label = '\u49cb\u{1ff72}';
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
let imageBitmap8 = await createImageBitmap(offscreenCanvas0);
try {
canvas10.getContext('webgpu');
} catch {}
let canvas11 = document.createElement('canvas');
let shaderModule13 = device1.createShaderModule(
{
label: '\u0e68\ud6fc\u{1f88d}\u050b',
code: `@group(5) @binding(7532)
var<storage, read_write> function16: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> global17: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> i15: array<u32>;
@group(1) @binding(5363)
var<storage, read_write> local6: array<u32>;
@group(4) @binding(5363)
var<storage, read_write> i16: array<u32>;
@group(2) @binding(7532)
var<storage, read_write> local7: array<u32>;
@group(2) @binding(5363)
var<storage, read_write> type11: array<u32>;
@group(1) @binding(7532)
var<storage, read_write> i17: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> local8: array<u32>;
@group(0) @binding(1832)
var<storage, read_write> parameter10: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
let renderBundleEncoder31 = device1.createRenderBundleEncoder(
{
label: '\ude85\u0564\ue4e2\u61ca',
colorFormats: [
'r32uint',
'rgba8uint',
'rgba32sint',
'rgba8unorm',
'rgba16sint'
],
sampleCount: 793,
depthReadOnly: true,
}
);
try {
renderPassEncoder9.executeBundles([]);
} catch {}
let promise10 = device1.queue.onSubmittedWorkDone();
let pipeline33 = await device1.createComputePipelineAsync(
{
label: '\u4457\u1bba\u0978\u0695\u4d8a\u{1f99b}\u{1ffe4}\u04b7\u691d\u{1feb2}',
layout: 'auto',
compute: {
module: shaderModule13,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
gpuCanvasContext4.unconfigure();
} catch {}
let device5 = await adapter6.requestDevice({
requiredFeatures: [
'depth-clip-control',
'texture-compression-etc2',
'texture-compression-astc',
'shader-f16',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
});
let imageBitmap9 = await createImageBitmap(canvas3);
let bindGroupLayout21 = device5.createBindGroupLayout(
{
entries: [
{
binding: 167,
visibility: GPUShaderStage.VERTEX,
storageTexture: { format: 'rgba32float', access: 'read-only', viewDimension: '2d' },
}
],
}
);
let buffer13 = device5.createBuffer(
{
size: 46348,
usage: GPUBufferUsage.UNIFORM | GPUBufferUsage.VERTEX,
}
);
let commandEncoder34 = device5.createCommandEncoder(
{
label: '\u029d\u813a\uad7c\uef26\u06db',
}
);
let texture42 = gpuCanvasContext7.getCurrentTexture();
let textureView26 = texture42.createView(
{
label: '\u80a4\u47b2\ub711\u79fe\u54dc\u5930',
dimension: '2d',
format: 'rgba8unorm-srgb',
}
);
let imageData13 = new ImageData(48, 96);
let textureView27 = texture41.createView(
{
baseMipLevel: 2,
mipLevelCount: 1,
baseArrayLayer: 10,
}
);
let sampler22 = device4.createSampler(
{
label: '\u0e76\u3d9f',
addressModeU: 'clamp-to-edge',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 27.579,
lodMaxClamp: 61.012,
}
);
video7.height = 228;
offscreenCanvas8.height = 499;
gc();
let querySet30 = device1.createQuerySet({
label: '\u0fe8\u81d0\u1748\uc99e',
type: 'occlusion',
count: 2291,
});
let texture43 = device1.createTexture(
{
size: {width: 184, height: 1, depthOrArrayLayers: 136},
mipLevelCount: 2,
dimension: '3d',
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [

],
}
);
try {
renderPassEncoder12.setScissorRect(
15,
2,
7,
42
);
} catch {}
try {
renderPassEncoder12.setIndexBuffer(
buffer11,
'uint32',
8996,
1043
);
} catch {}
try {
canvas11.getContext('webgl');
} catch {}
try {
await adapter6.requestAdapterInfo();
} catch {}
let canvas12 = document.createElement('canvas');
let videoFrame10 = new VideoFrame(img6, {timestamp: 0});
try {
canvas12.getContext('webgl');
} catch {}
offscreenCanvas12.height = 969;
let video13 = await videoWithData();
let pipelineLayout9 = device5.createPipelineLayout(
{
label: '\u33e6\u{1fd64}\u0cf8\u2524\uff6e\u{1fc2a}\u{1fd1a}',
bindGroupLayouts: [
bindGroupLayout21,
bindGroupLayout21,
bindGroupLayout21,
bindGroupLayout21
]
}
);
let commandEncoder35 = device5.createCommandEncoder();
let texture44 = gpuCanvasContext2.getCurrentTexture();
let computePassEncoder14 = commandEncoder34.beginComputePass(
{
label: '\u5931\u0131\u0be1\u27ab\u7c2c\u13f4\ud160'
}
);
try {
await device5.popErrorScope();
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 1, y: 0, z: 1 },
  aspect: 'all',
},
new BigUint64Array(new ArrayBuffer(24)),
/* required buffer size: 379 */{
offset: 379,
},
{width: 0, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let canvas13 = document.createElement('canvas');
let imageBitmap10 = await createImageBitmap(imageBitmap5);
let imageData14 = new ImageData(28, 20);
try {
computePassEncoder10.label = '\u0a2a\u0c4a\u4b06\u{1feea}\u0967';
} catch {}
let renderBundle33 = renderBundleEncoder19.finish(
{
label: '\ue72c\u{1fbd4}\u0298\u{1f75a}\u4271\u{1fc41}\u7d12'
}
);
let sampler23 = device1.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 67.065,
lodMaxClamp: 93.278,
maxAnisotropy: 11,
}
);
try {
renderPassEncoder12.executeBundles([]);
} catch {}
try {
renderPassEncoder12.setBlendConstant({ r: 918.6, g: -268.7, b: 429.7, a: -661.9, });
} catch {}
try {
renderPassEncoder12.setStencilReference(
1205
);
} catch {}
canvas5.width = 435;
let textureView28 = texture42.createView(
{
dimension: '2d',
format: 'rgba8unorm-srgb',
}
);
try {
device5.queue.writeTexture(
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 1, y: 1, z: 0 },
  aspect: 'all',
},
arrayBuffer1,
/* required buffer size: 751 */{
offset: 751,
},
{width: 0, height: 0, depthOrArrayLayers: 1}
);
} catch {}
let offscreenCanvas15 = new OffscreenCanvas(1011, 494);
let shaderModule14 = device1.createShaderModule(
{
code: `@group(6) @binding(1832)
var<storage, read_write> function17: array<u32>;
@group(6) @binding(1199)
var<storage, read_write> local9: array<u32>;
@group(5) @binding(1199)
var<storage, read_write> parameter11: array<u32>;
@group(7) @binding(1832)
var<storage, read_write> function18: array<u32>;
@group(1) @binding(1199)
var<storage, read_write> function19: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> function20: array<u32>;
@group(2) @binding(1199)
var<storage, read_write> function21: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> parameter12: array<u32>;
@group(4) @binding(1832)
var<storage, read_write> i18: array<u32>;
@group(5) @binding(1832)
var<storage, read_write> type12: array<u32>;
@group(7) @binding(1199)
var<storage, read_write> type13: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> local10: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
pseudoSubmit(device1, commandEncoder14);
try {
renderPassEncoder12.beginOcclusionQuery(1806);
} catch {}
try {
renderPassEncoder9.setStencilReference(
1254
);
} catch {}
try {
renderPassEncoder9.setViewport(
21.98,
42.51,
0.02973,
2.854,
0.7819,
0.8028
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture28,
  mipLevel: 0,
  origin: { x: 5224, y: 0, z: 0 },
  aspect: 'all',
},
new Uint8Array(arrayBuffer0),
/* required buffer size: 4196 */{
offset: 476,
bytesPerRow: 3997,
rowsPerImage: 39,
},
{width: 465, height: 1, depthOrArrayLayers: 1}
);
} catch {}
let pipeline34 = await device1.createComputePipelineAsync(
{
layout: pipelineLayout6,
compute: {
module: shaderModule10,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
offscreenCanvas15.getContext('webgl2');
} catch {}
let shaderModule15 = device5.createShaderModule(
{
code: `@group(1) @binding(167)
var<storage, read_write> type14: array<u32>;
@group(3) @binding(167)
var<storage, read_write> function22: array<u32>;
@group(0) @binding(167)
var<storage, read_write> parameter13: array<u32>;
@group(2) @binding(167)
var<storage, read_write> field13: array<u32>;

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

struct S17 {
@builtin(front_facing) f0: bool,
@location(14) f1: vec3<f32>,
@location(6) f2: vec2<f32>,
@location(12) f3: vec4<i32>,
@location(15) f4: vec3<u32>,
@location(11) f5: vec2<i32>,
@location(9) f6: vec3<u32>,
@location(13) f7: f16,
@location(2) f8: vec4<i32>,
@location(8) f9: vec3<u32>
}
struct FragmentOutput0 {
@location(0) f0: vec2<f32>,
@location(6) f1: vec3<i32>
}

@fragment
fn fragment0(@builtin(sample_index) a0: u32, @builtin(sample_mask) a1: u32, @location(7) a2: u32, @location(4) a3: vec4<i32>, @location(3) a4: f16, @location(10) a5: vec3<u32>, a6: S17) -> FragmentOutput0 {
return FragmentOutput0();
}

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

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

`,
sourceMap: {},
hints: {},
}
);
let bindGroupLayout22 = device5.createBindGroupLayout(
{
label: '\u0d49\u{1f765}\u39ed\u381e\u06e0\u{1fad8}',
entries: [
{
binding: 704,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.VERTEX,
sampler: { type: 'comparison' },
}
],
}
);
pseudoSubmit(device5, commandEncoder34);
let texture45 = gpuCanvasContext3.getCurrentTexture();
try {
texture42.destroy();
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
new Float64Array(new ArrayBuffer(40)),
/* required buffer size: 858 */{
offset: 858,
},
{width: 1, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let pipeline35 = await device5.createComputePipelineAsync(
{
layout: pipelineLayout9,
compute: {
module: shaderModule15,
entryPoint: 'compute0',
constants: {},
},
}
);
let renderBundle34 = renderBundleEncoder28.finish(
{
label: '\u0d49\ud854\u09d3\u0baa\u0ee0'
}
);
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder12.executeBundles([]);
} catch {}
try {
buffer11.unmap();
} catch {}
let renderBundleEncoder32 = device5.createRenderBundleEncoder(
{
label: '\u{1f920}\u6a5d',
colorFormats: [
'rg32float',
'rg32sint',
'r16uint',
'rgb10a2unorm',
'rg16float'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 912,
}
);
let sampler24 = device5.createSampler(
{
label: '\u04f0\u50db\u002a\ud72c\u0c29\u1120\u{1fbcf}',
addressModeU: 'clamp-to-edge',
lodMinClamp: 35.392,
lodMaxClamp: 77.432,
}
);
document.body.prepend(img5);
offscreenCanvas10.height = 512;
let img7 = await imageWithData(105, 44, '#4c6d36b3', '#aba62771');
let imageData15 = new ImageData(188, 160);
let querySet31 = device4.createQuerySet({
label: '\u05d5\u{1ff3f}\u{1fc11}\u14a0\u15de\u6226\u{1fce6}\ue66e',
type: 'occlusion',
count: 1276,
});
let offscreenCanvas16 = new OffscreenCanvas(36, 407);
let video14 = await videoWithData();
let imageBitmap11 = await createImageBitmap(canvas4);
let gpuCanvasContext12 = canvas13.getContext('webgpu');
try {
gpuCanvasContext5.unconfigure();
} catch {}
let shaderModule16 = device5.createShaderModule(
{
label: '\ufe6a\u050f\u{1f629}\u5faa\u1e6d\u0827\ua41c\u6c19',
code: `@group(1) @binding(167)
var<storage, read_write> i19: array<u32>;
@group(3) @binding(167)
var<storage, read_write> parameter14: array<u32>;
@group(2) @binding(167)
var<storage, read_write> function23: array<u32>;
@group(0) @binding(167)
var<storage, read_write> field14: array<u32>;

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

struct S18 {
@builtin(sample_index) f0: u32
}
struct FragmentOutput0 {
@builtin(sample_mask) f0: u32,
@location(4) f1: vec3<u32>,
@location(6) f2: vec3<u32>,
@builtin(frag_depth) f3: f32,
@location(0) f4: f32,
@location(7) f5: vec2<f32>
}

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



@vertex
fn vertex0(@location(1) a0: vec4<f16>, @location(8) a1: vec3<u32>, @location(3) a2: i32, @location(7) a3: vec3<f32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
sourceMap: {},
}
);
let buffer14 = device5.createBuffer(
{
label: '\ud6eb\u{1ff31}\u0b95\ucdf7',
size: 6346,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.QUERY_RESOLVE | GPUBufferUsage.UNIFORM,
}
);
let commandBuffer7 = commandEncoder35.finish();
let texture46 = device5.createTexture(
{
label: '\u0805\u05ba\u{1fc67}\u{1fa7f}\u3f7b\u06f8\u{1f813}',
size: [168, 78, 198],
mipLevelCount: 4,
format: 'astc-8x6-unorm',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [

],
}
);
let promise11 = device5.createRenderPipelineAsync(
{
label: '\u0c3d\u0591\u011e\ua98e\u{1fa2a}\u5bc4\ua527\u{1f608}\u0d4d\ua04d\ud4f9',
layout: pipelineLayout9,
vertex: {
module: shaderModule15,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 16,
stepMode: 'instance',
attributes: [
{
format: 'snorm8x4',
offset: 0,
shaderLocation: 12,
},
{
format: 'snorm8x2',
offset: 4,
shaderLocation: 3,
},
{
format: 'unorm8x2',
offset: 10,
shaderLocation: 7,
},
{
format: 'float16x2',
offset: 4,
shaderLocation: 13,
},
{
format: 'float32x4',
offset: 0,
shaderLocation: 0,
},
{
format: 'sint8x4',
offset: 8,
shaderLocation: 2,
},
{
format: 'float32x4',
offset: 0,
shaderLocation: 14,
},
{
format: 'uint32x4',
offset: 0,
shaderLocation: 8,
},
{
format: 'uint8x2',
offset: 12,
shaderLocation: 9,
}
],
},
{
arrayStride: 1332,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 360,
shaderLocation: 11,
}
],
},
{
arrayStride: 1524,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x2',
offset: 1044,
shaderLocation: 15,
},
{
format: 'snorm8x4',
offset: 712,
shaderLocation: 5,
}
],
}
]
},
primitive: {
topology: 'line-strip',
stripIndexFormat: 'uint32',
frontFace: 'ccw',
cullMode: 'back',
unclippedDepth: true,
},
fragment: {
module: shaderModule15,
entryPoint: 'fragment0',
constants: {},
targets: [
{
blend: {
color: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'subtract',
srcFactor: 'one-minus-src',
dstFactor: 'one-minus-src'
},
},
format: 'rg8unorm',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
},
undefined,
undefined,
undefined,
undefined,
undefined
],
},
}
);
try {
await promise10;
} catch {}
let adapter7 = await promise6;
let img8 = await imageWithData(121, 214, '#c38a8b58', '#3a912d9f');
let sampler25 = device5.createSampler(
{
label: '\u51ec\ubd4a\u0232\u6948\u23cd\u04ac\u96ad\u0df3\u{1f720}\u{1fcaa}\u6eae',
addressModeU: 'repeat',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
lodMaxClamp: 42.350,
maxAnisotropy: 1,
}
);
try {
gpuCanvasContext5.configure(
{
device: device5,
format: 'rgba16float',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'etc2-rgba8unorm',
'r32sint',
'rgba16float'
],
colorSpace: 'srgb',
alphaMode: 'premultiplied',
}
);
} catch {}
let pipeline36 = await device5.createComputePipelineAsync(
{
label: '\u0e81\u{1ff96}\u1506',
layout: pipelineLayout9,
compute: {
module: shaderModule16,
entryPoint: 'compute0',
constants: {},
},
}
);
let imageData16 = new ImageData(144, 180);
let texture47 = device4.createTexture(
{
label: '\ue9ce\u3f98\u0d3a\u{1f7da}\u01e4\u21e4',
size: [1714, 1, 28],
mipLevelCount: 9,
dimension: '3d',
format: 'rgba32uint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba32uint',
'rgba32uint',
'rgba32uint'
],
}
);
try {
device4.queue.writeTexture(
{
  texture: texture47,
  mipLevel: 3,
  origin: { x: 127, y: 0, z: 0 },
  aspect: 'all',
},
new DataView(new ArrayBuffer(16)),
/* required buffer size: 121650 */{
offset: 220,
bytesPerRow: 665,
rowsPerImage: 182,
},
{width: 25, height: 1, depthOrArrayLayers: 2}
);
} catch {}
try {
await device4.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder36 = device4.createCommandEncoder(
{
label: '\u0244\u61e6\u4d9d\u0c4b\uef42\u0098\u1a49\u{1f622}\u{1f6e4}\ue7e0\u{1fe54}',
}
);
let sampler26 = device4.createSampler(
{
label: '\uf56f\ubb0e\u0ddf\u{1ff27}\u098a\u388a\u4879\uf021\ufa77\ua814\ua874',
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 91.543,
lodMaxClamp: 97.347,
maxAnisotropy: 18,
}
);
try {
await device4.queue.onSubmittedWorkDone();
} catch {}
let img9 = await imageWithData(123, 213, '#1dc727e8', '#a3e51227');
let shaderModule17 = device1.createShaderModule(
{
label: '\u01ca\u8d13\u7399',
code: `@group(1) @binding(1832)
var<storage, read_write> field15: array<u32>;
@group(3) @binding(1199)
var<storage, read_write> function24: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> type15: array<u32>;
@group(4) @binding(1832)
var<storage, read_write> i20: array<u32>;
@group(5) @binding(1199)
var<storage, read_write> i21: array<u32>;
@group(7) @binding(1199)
var<storage, read_write> field16: array<u32>;
@group(6) @binding(1832)
var<storage, read_write> i22: array<u32>;
@group(2) @binding(1832)
var<storage, read_write> type16: array<u32>;
@group(7) @binding(1832)
var<storage, read_write> field17: array<u32>;
@group(5) @binding(1832)
var<storage, read_write> i23: array<u32>;
@group(0) @binding(1832)
var<storage, read_write> local11: array<u32>;
@group(1) @binding(1199)
var<storage, read_write> local12: array<u32>;
@group(2) @binding(1199)
var<storage, read_write> local13: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> global18: array<u32>;

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

struct S19 {
@location(60) f0: vec4<i32>,
@location(15) f1: vec4<u32>,
@location(32) f2: u32,
@location(25) f3: vec4<i32>,
@location(6) f4: vec4<f32>,
@location(11) f5: vec4<u32>,
@builtin(position) f6: vec4<f32>,
@location(17) f7: i32,
@location(36) f8: f16,
@builtin(sample_mask) f9: u32,
@location(68) f10: u32,
@location(0) f11: vec3<u32>,
@location(56) f12: f32,
@location(63) f13: vec4<f32>
}
struct FragmentOutput0 {
@location(4) f0: vec2<i32>,
@location(7) f1: vec2<i32>,
@location(3) f2: u32,
@location(2) f3: f32,
@location(1) f4: vec4<u32>,
@location(0) f5: vec3<f32>,
@location(6) f6: vec2<f32>,
@location(5) f7: vec2<u32>,
@builtin(frag_depth) f8: f32
}

@fragment
fn fragment0(@location(50) a0: vec4<f32>, @location(10) a1: vec4<f16>, @location(59) a2: vec3<i32>, @location(67) a3: u32, @location(9) a4: vec2<f32>, @location(52) a5: vec3<i32>, @location(19) a6: vec3<f32>, @location(41) a7: vec4<f16>, @location(7) a8: vec3<u32>, @location(46) a9: vec2<i32>, a10: S19) -> FragmentOutput0 {
return FragmentOutput0();
}

struct VertexOutput0 {
@location(50) f200: vec4<f32>,
@location(6) f201: vec4<f32>,
@location(35) f202: vec3<i32>,
@location(39) f203: vec3<f32>,
@location(55) f204: i32,
@location(0) f205: vec3<u32>,
@builtin(position) f206: vec4<f32>,
@location(10) f207: vec4<f16>,
@location(20) f208: f32,
@location(59) f209: vec3<i32>,
@location(7) f210: vec3<u32>,
@location(17) f211: i32,
@location(36) f212: f16,
@location(19) f213: vec3<f32>,
@location(52) f214: vec3<i32>,
@location(56) f215: f32,
@location(15) f216: vec4<u32>,
@location(45) f217: vec3<i32>,
@location(60) f218: vec4<i32>,
@location(63) f219: vec4<f32>,
@location(41) f220: vec4<f16>,
@location(47) f221: u32,
@location(9) f222: vec2<f32>,
@location(25) f223: vec4<i32>,
@location(46) f224: vec2<i32>,
@location(67) f225: u32,
@location(68) f226: u32,
@location(64) f227: vec2<f16>,
@location(32) f228: u32,
@location(11) f229: vec4<u32>
}

@vertex
fn vertex0(@location(13) a0: u32, @location(1) a1: vec3<u32>, @location(10) a2: vec3<i32>, @location(12) a3: vec4<f16>, @location(4) a4: vec4<i32>, @location(5) a5: vec2<u32>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
hints: {},
}
);
try {
renderPassEncoder9.setBlendConstant({ r: -664.5, g: 801.9, b: 390.9, a: 699.6, });
} catch {}
try {
renderPassEncoder9.setScissorRect(
18,
39,
0,
5
);
} catch {}
let offscreenCanvas17 = new OffscreenCanvas(536, 147);
let querySet32 = device1.createQuerySet({
label: '\u0d3e\u04e0\u5b8e\ud87f\u899e\u{1fc88}\u426d\u1f87',
type: 'occlusion',
count: 1658,
});
try {
computePassEncoder10.setPipeline(
pipeline34
);
} catch {}
try {
renderPassEncoder9.setViewport(
18.99,
34.40,
3.231,
1.358,
0.7317,
0.9495
);
} catch {}
let pipeline37 = await device1.createRenderPipelineAsync(
{
label: '\u{1fa51}\uccac\u047a\ua0dc\uf7b8\u0ff7',
layout: pipelineLayout5,
vertex: {
module: shaderModule17,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 0,
attributes: [
{
format: 'sint8x4',
offset: 1020,
shaderLocation: 10,
},
{
format: 'sint8x4',
offset: 1368,
shaderLocation: 4,
}
],
},
{
arrayStride: 900,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x2',
offset: 540,
shaderLocation: 13,
},
{
format: 'float32x2',
offset: 268,
shaderLocation: 12,
}
],
},
{
arrayStride: 516,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 2528,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x2',
offset: 1380,
shaderLocation: 5,
}
],
},
{
arrayStride: 3824,
attributes: [

],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint32x2',
offset: 2688,
shaderLocation: 1,
}
],
}
]
},
primitive: {
frontFace: 'cw',
cullMode: 'back',
},
multisample: {
count: 4,
mask: 0x803a2c0b,
},
fragment: {
module: shaderModule17,
entryPoint: 'fragment0',
targets: [
{
blend: {
color: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'subtract',
srcFactor: 'one-minus-src',
dstFactor: 'src'
},
},
format: 'rg8unorm',
},
{
format: 'r32uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'r8unorm',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'r16uint',
},
{
format: 'rg16sint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.RED,
},
{
format: 'rg8uint',
},
{
blend: {
color: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'add',
srcFactor: 'src',
dstFactor: 'one-minus-src'
},
},
format: 'r8unorm',
writeMask: GPUColorWrite.ALL | GPUColorWrite.RED,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'greater-equal',
stencilFront: {
compare: 'greater',
failOp: 'replace',
depthFailOp: 'increment-clamp',
passOp: 'replace',
},
stencilBack: {
compare: 'greater-equal',
failOp: 'increment-wrap',
depthFailOp: 'increment-wrap',
passOp: 'increment-clamp',
},
stencilWriteMask: 1851,
depthBias: 42,
depthBiasSlopeScale: 90,
depthBiasClamp: 59,
},
}
);
let imageData17 = new ImageData(252, 60);
try {
window.someLabel = device0.queue.label;
} catch {}
let commandEncoder37 = device0.createCommandEncoder(
{
label: '\u{1fcab}\u064c\u2087\u{1f78c}\u3329\u3ecf\u26eb\u0d79\u802e\u6e40\u9790',
}
);
let querySet33 = device0.createQuerySet({
label: '\uabd4\u3433\u{1f9d2}',
type: 'occlusion',
count: 2929,
});
let renderBundleEncoder33 = device0.createRenderBundleEncoder(
{
label: '\ue2c0\u61e6\u0f1e\u578c\uf30a',
colorFormats: [
'r8uint',
'rg32uint',
undefined,
'rg8uint'
],
sampleCount: 617,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle35 = renderBundleEncoder13.finish(
{
label: '\u587b\u{1fd33}\u02f5\u0860'
}
);
try {
computePassEncoder4.setBindGroup(
0,
bindGroup0
);
} catch {}
try {
renderPassEncoder11.setStencilReference(
2328
);
} catch {}
try {
renderBundleEncoder6.setVertexBuffer(
1,
buffer10
);
} catch {}
let promise12 = device0.popErrorScope();
try {
device0.queue.writeTexture(
{
  texture: texture33,
  mipLevel: 0,
  origin: { x: 10, y: 44, z: 2 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 10025271 */{
offset: 140,
bytesPerRow: 315,
rowsPerImage: 221,
},
{width: 80, height: 8, depthOrArrayLayers: 145}
);
} catch {}
let device6 = await adapter7.requestDevice({
label: '\uc2e3\u8337\u0e4e\u6cba\uee73\u0b76\u43d4\ucd68\u0722\ubedc',
requiredFeatures: [
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'shader-f16',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
});
try {
offscreenCanvas16.getContext('2d');
} catch {}
let buffer15 = device5.createBuffer(
{
label: '\u4b0b\u0d8d\u{1f6bd}\u10fd',
size: 33442,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let texture48 = device5.createTexture(
{
label: '\uf1e9\u544e\u{1f891}\u3c11\u0ead\u0c7a\uca48\u{1ff13}\u{1fd9a}',
size: {width: 1240, height: 252, depthOrArrayLayers: 29},
mipLevelCount: 8,
format: 'etc2-rgb8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
viewFormats: [
'etc2-rgb8unorm',
'etc2-rgb8unorm-srgb'
],
}
);
try {
renderBundleEncoder32.setVertexBuffer(
3,
buffer13,
42164,
954
);
} catch {}
try {
device5.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageBitmap2,
  origin: { x: 24, y: 147 },
  flipY: true,
},
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 1, z: 0 },
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: true,
},
{width: 1, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let pipeline38 = await device5.createRenderPipelineAsync(
{
label: '\u05f2\u0044\u42de\u0e74\u0976\u{1ff48}\u0a68\uf2ec\u77cd',
layout: pipelineLayout9,
vertex: {
module: shaderModule16,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1996,
attributes: [
{
format: 'unorm16x2',
offset: 660,
shaderLocation: 1,
},
{
format: 'unorm10-10-10-2',
offset: 32,
shaderLocation: 7,
},
{
format: 'sint16x2',
offset: 972,
shaderLocation: 3,
}
],
},
{
arrayStride: 0,
attributes: [

],
},
{
arrayStride: 940,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 192,
shaderLocation: 8,
}
],
}
]
},
primitive: {
topology: 'point-list',
frontFace: 'cw',
cullMode: 'back',
unclippedDepth: false,
},
multisample: {
count: 4,
},
fragment: {
module: shaderModule16,
entryPoint: 'fragment0',
constants: {},
targets: [
{
blend: {
color: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
},
format: 'r8unorm',
writeMask: GPUColorWrite.ALL,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'not-equal',
stencilFront: {
failOp: 'replace',
depthFailOp: 'zero',
passOp: 'zero',
},
stencilBack: {
failOp: 'decrement-wrap',
depthFailOp: 'zero',
passOp: 'replace',
},
stencilReadMask: 3345,
stencilWriteMask: 103,
depthBias: 100,
depthBiasSlopeScale: 16,
depthBiasClamp: 37,
},
}
);
let querySet34 = device4.createQuerySet({
label: '\u{1fd89}\u{1fca3}\ue8e0\u51e5\uc0ee\ud73d\ue190\u4604\ub41e\u{1f6b3}',
type: 'occlusion',
count: 899,
});
let computePassEncoder15 = commandEncoder33.beginComputePass(
{
label: '\u{1fe25}\ue997\u0efd\u0305\u230d\u{1f9ec}\u0371'
}
);
try {
await device4.queue.onSubmittedWorkDone();
} catch {}
document.body.prepend(img0);
let commandEncoder38 = device6.createCommandEncoder(
{
}
);
try {
commandEncoder38.insertDebugMarker(
'\ufc18'
);
} catch {}
try {
await device6.queue.onSubmittedWorkDone();
} catch {}
try {
await promise12;
} catch {}
gc();
let img10 = await imageWithData(185, 28, '#d8dad2b8', '#6e777316');
let videoFrame11 = new VideoFrame(canvas10, {timestamp: 0});
let commandEncoder39 = device4.createCommandEncoder(
{
label: '\u2f87\u{1f846}\uc5e4\u0667\u4cd1\u9562\ue31d\u08d3\u23b3\uaa4a',
}
);
let querySet35 = device4.createQuerySet({
label: '\u7591\u7080\u{1fa64}\ub2db\u{1f95c}\u1b05\uf00c\u5d30\ubbad\u14ab',
type: 'occlusion',
count: 459,
});
let texture49 = device4.createTexture(
{
size: {width: 3660, height: 4, depthOrArrayLayers: 170},
sampleCount: 1,
format: 'eac-r11snorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'eac-r11snorm'
],
}
);
let computePassEncoder16 = commandEncoder39.beginComputePass(
{

}
);
let sampler27 = device4.createSampler(
{
label: '\u7f64\ua5a7\u00c8\uefb6',
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 94.449,
lodMaxClamp: 95.073,
compare: 'always',
}
);
try {
device4.queue.writeTexture(
{
  texture: texture47,
  mipLevel: 5,
  origin: { x: 5, y: 0, z: 0 },
  aspect: 'all',
},
new Int8Array(arrayBuffer2),
/* required buffer size: 978 */{
offset: 274,
},
{width: 44, height: 1, depthOrArrayLayers: 1}
);
} catch {}
gc();
try {
buffer3.label = '\u00a9\u{1fd9b}\u073c\u0bcd\ud2eb\u{1f79d}\u0792\u{1fd99}';
} catch {}
let texture50 = device1.createTexture(
{
label: '\u0ea1\u0403\u0638\u7219\ud8ff\u8e52',
size: {width: 7075},
dimension: '1d',
format: 'rgba32sint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba32sint',
'rgba32sint',
'rgba32sint'
],
}
);
let sampler28 = device1.createSampler(
{
addressModeU: 'mirror-repeat',
addressModeV: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 48.059,
lodMaxClamp: 90.595,
compare: 'not-equal',
maxAnisotropy: 16,
}
);
try {
computePassEncoder10.setPipeline(
pipeline25
);
} catch {}
try {
renderPassEncoder12.beginOcclusionQuery(857);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(
5,
undefined,
3460399357
);
} catch {}
let arrayBuffer3 = buffer12.getMappedRange(
49800,
1076
);
try {
await device1.queue.onSubmittedWorkDone();
} catch {}
let imageBitmap12 = await createImageBitmap(video10);
let querySet36 = device4.createQuerySet({
label: '\u33df\ub244\u0046\u01ea\u0338\u869f\u{1fcc4}\u0b6d\u0c4e\u7502\u6f57',
type: 'occlusion',
count: 3009,
});
let sampler29 = device4.createSampler(
{
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 97.563,
lodMaxClamp: 99.368,
}
);
let gpuCanvasContext13 = offscreenCanvas17.getContext('webgpu');
let shaderModule18 = device1.createShaderModule(
{
label: '\ufbf7\udd55\u0064\u832f\u{1feed}\u0d8b\u097e\u0a09\u6aec\u0896',
code: `@group(0) @binding(1199)
var<storage, read_write> field18: array<u32>;
@group(0) @binding(1832)
var<storage, read_write> i24: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> function25: array<u32>;
@group(1) @binding(5363)
var<storage, read_write> function26: array<u32>;
@group(2) @binding(5363)
var<storage, read_write> parameter15: array<u32>;
@group(5) @binding(7532)
var<storage, read_write> field19: array<u32>;
@group(3) @binding(1199)
var<storage, read_write> field20: array<u32>;
@group(5) @binding(5363)
var<storage, read_write> i25: array<u32>;
@group(2) @binding(7532)
var<storage, read_write> field21: array<u32>;
@group(4) @binding(5363)
var<storage, read_write> global19: array<u32>;
@group(1) @binding(7532)
var<storage, read_write> global20: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> type17: array<u32>;

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

struct S21 {
@location(27) f0: vec3<i32>,
@builtin(sample_mask) f1: u32,
@location(50) f2: vec3<u32>,
@builtin(sample_index) f3: u32,
@builtin(position) f4: vec4<f32>,
@location(38) f5: vec3<u32>,
@location(62) f6: vec2<i32>,
@location(71) f7: vec4<i32>,
@location(55) f8: u32,
@location(14) f9: f16,
@location(12) f10: vec4<u32>,
@location(41) f11: vec3<f32>,
@location(1) f12: vec4<f32>,
@location(42) f13: vec3<f16>,
@builtin(front_facing) f14: bool,
@location(72) f15: f16,
@location(35) f16: vec4<u32>,
@location(31) f17: vec3<f32>,
@location(34) f18: vec4<f32>,
@location(6) f19: vec2<u32>,
@location(40) f20: vec3<i32>,
@location(68) f21: i32,
@location(0) f22: vec2<f32>,
@location(60) f23: vec3<u32>,
@location(16) f24: vec4<u32>,
@location(33) f25: vec4<i32>,
@location(59) f26: vec2<i32>,
@location(47) f27: vec4<f32>
}
struct FragmentOutput0 {
@location(0) f0: vec4<u32>,
@location(6) f1: vec4<u32>,
@location(1) f2: f32,
@location(3) f3: vec2<f32>,
@location(2) f4: vec4<i32>,
@location(5) f5: vec4<f32>,
@location(7) f6: vec2<u32>,
@location(4) f7: vec2<u32>
}

@fragment
fn fragment0(@location(8) a0: vec2<f32>, @location(13) a1: vec3<f32>, @location(4) a2: vec2<u32>, a3: S21) -> FragmentOutput0 {
return FragmentOutput0();
}

struct S20 {
@location(15) f0: vec2<i32>,
@builtin(vertex_index) f1: u32,
@location(3) f2: vec3<f16>,
@location(7) f3: vec3<f32>,
@location(19) f4: vec2<f16>,
@location(5) f5: vec4<u32>,
@builtin(instance_index) f6: u32,
@location(8) f7: vec2<i32>,
@location(1) f8: vec3<i32>,
@location(4) f9: vec2<f32>,
@location(12) f10: f16
}
struct VertexOutput0 {
@location(62) f230: vec2<i32>,
@location(60) f231: vec3<u32>,
@location(55) f232: u32,
@location(27) f233: vec3<i32>,
@location(71) f234: vec4<i32>,
@location(35) f235: vec4<u32>,
@location(50) f236: vec3<u32>,
@location(72) f237: f16,
@location(59) f238: vec2<i32>,
@location(0) f239: vec2<f32>,
@location(42) f240: vec3<f16>,
@location(41) f241: vec3<f32>,
@location(6) f242: vec2<u32>,
@location(13) f243: vec3<f32>,
@location(12) f244: vec4<u32>,
@location(16) f245: vec4<u32>,
@location(14) f246: f16,
@location(1) f247: vec4<f32>,
@location(8) f248: vec2<f32>,
@location(33) f249: vec4<i32>,
@location(68) f250: i32,
@location(31) f251: vec3<f32>,
@builtin(position) f252: vec4<f32>,
@location(34) f253: vec4<f32>,
@location(47) f254: vec4<f32>,
@location(38) f255: vec3<u32>,
@location(40) f256: vec3<i32>,
@location(4) f257: vec2<u32>
}

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

`,
sourceMap: {},
}
);
let renderBundle36 = renderBundleEncoder21.finish(
{
label: '\u0e98\u0da9\u{1fccc}\u{1ffdf}\u068a\u{1f7d6}\ubbc0\u0bfe\ub88f'
}
);
let sampler30 = device1.createSampler(
{
label: '\ub3c8\u{1fb2d}\uee19\ufeac',
addressModeU: 'repeat',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 52.450,
lodMaxClamp: 86.194,
maxAnisotropy: 4,
}
);
try {
renderPassEncoder12.setBlendConstant({ r: -546.0, g: 90.10, b: -715.1, a: 489.6, });
} catch {}
try {
renderPassEncoder9.setViewport(
9.388,
11.15,
10.35,
16.27,
0.3097,
0.3761
);
} catch {}
try {
buffer7.destroy();
} catch {}
try {
await device1.queue.onSubmittedWorkDone();
} catch {}
let commandEncoder40 = device6.createCommandEncoder();
let computePassEncoder17 = commandEncoder38.beginComputePass(
{
label: '\u0368\u15b4\u4242\u0827\u02cb\u{1f720}\u8da9\u0d5a\u917f\uc099'
}
);
let buffer16 = device1.createBuffer(
{
label: '\u06f8\ue0d2\u0217\u6710\ue49b\u{1f8e6}\u82cd',
size: 10929,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let sampler31 = device1.createSampler(
{
label: '\ue2af\u9975\u1c8b\u{1feb5}',
addressModeU: 'clamp-to-edge',
addressModeV: 'mirror-repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 11.222,
lodMaxClamp: 34.813,
}
);
try {
renderPassEncoder12.setIndexBuffer(
buffer11,
'uint32',
2360,
4751
);
} catch {}
try {
computePassEncoder7.insertDebugMarker(
'\u02aa'
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
1800,
new DataView(new ArrayBuffer(48501)),
43739,
3088
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture31,
  mipLevel: 7,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
new Uint8ClampedArray(arrayBuffer2),
/* required buffer size: 794 */{
offset: 794,
rowsPerImage: 151,
},
{width: 101, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let promise13 = device1.createComputePipelineAsync(
{
label: '\u{1fe5c}\u7e24\u1624\u{1faa6}\u069a\u5472\u7f62\u3a11',
layout: 'auto',
compute: {
module: shaderModule17,
entryPoint: 'compute0',
},
}
);
let pipeline39 = device1.createRenderPipeline(
{
label: '\u0b08\u2b72\u0b61\u0c6b',
layout: pipelineLayout8,
vertex: {
module: shaderModule14,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 704,
attributes: [

],
},
{
arrayStride: 1088,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 1424,
stepMode: 'vertex',
attributes: [
{
format: 'float32',
offset: 648,
shaderLocation: 16,
}
],
}
]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint32',
frontFace: 'ccw',
},
multisample: {
count: 1,
mask: 0x1279579f,
},
fragment: {
module: shaderModule14,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rg16uint',
},
{
format: 'r16sint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'r16sint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
undefined,
{
format: 'r32sint',
writeMask: GPUColorWrite.RED,
},
{
blend: {
color: {
operation: 'reverse-subtract',
srcFactor: 'one-minus-dst-alpha',
dstFactor: 'one-minus-src'
},
alpha: {
operation: 'subtract',
srcFactor: 'one-minus-src-alpha',
dstFactor: 'dst-alpha'
},
},
format: 'rg8unorm',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'greater-equal',
stencilFront: {
compare: 'not-equal',
failOp: 'increment-clamp',
depthFailOp: 'increment-wrap',
passOp: 'replace',
},
stencilBack: {
compare: 'less-equal',
failOp: 'invert',
depthFailOp: 'zero',
passOp: 'increment-clamp',
},
stencilReadMask: 582,
stencilWriteMask: 1504,
depthBias: 79,
depthBiasClamp: 67,
},
}
);
let videoFrame12 = new VideoFrame(offscreenCanvas12, {timestamp: 0});
let img11 = await imageWithData(211, 176, '#270150f2', '#4be511cf');
let bindGroupLayout23 = device6.createBindGroupLayout(
{
label: '\u04d7\u9f18\u{1fd84}\uf9ca\u0caf\uab50\u{1fe88}\u2df1\u01d8',
entries: [
{
binding: 432,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
externalTexture: {},
},
{
binding: 536,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
texture: { viewDimension: '2d', sampleType: 'uint', multisampled: true },
}
],
}
);
let pipelineLayout10 = device6.createPipelineLayout(
{
label: '\u05ff\u0940\u0682\u{1fd6d}\u{1fbb2}',
bindGroupLayouts: [

]
}
);
let commandEncoder41 = device6.createCommandEncoder(
{
label: '\u0640\uacd1\u0be5\ua985',
}
);
let querySet37 = device6.createQuerySet({
label: '\u2cf3\uf946\u0aa1\u4cc9\u{1fd94}\u0084',
type: 'occlusion',
count: 1866,
});
let computePassEncoder18 = commandEncoder40.beginComputePass(
{
label: '\u0978\uab81\u{1fc3e}\ueb6c\ud86c\ucce0\u25fc'
}
);
let canvas14 = document.createElement('canvas');
try {
await adapter4.requestAdapterInfo();
} catch {}
let texture51 = device5.createTexture(
{
label: '\u0929\u{1fcd4}\u0a06\u{1f7ed}\u68fe\u0572\u0a0a\u0228\u0040\ue923\u3766',
size: {width: 7720, height: 20, depthOrArrayLayers: 71},
format: 'astc-10x10-unorm-srgb',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'astc-10x10-unorm',
'astc-10x10-unorm-srgb'
],
}
);
let textureView29 = texture46.createView(
{
label: '\ud1f6\u651a\u0784\ue0c6\u1d31\u4812\u0d0d',
dimension: '2d',
baseMipLevel: 1,
baseArrayLayer: 42,
}
);
let sampler32 = device5.createSampler(
{
label: '\ub8db\u{1fcca}\u{1f6b0}\u{1f7ae}',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 49.505,
lodMaxClamp: 58.834,
compare: 'greater-equal',
maxAnisotropy: 4,
}
);
try {
await device5.popErrorScope();
} catch {}
let imageData18 = new ImageData(32, 256);
try {
renderPassEncoder12.end();
} catch {}
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(
14,
undefined,
1023455973,
2181389070
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
3208,
new Float32Array(43769),
35495,
180
);
} catch {}
let imageBitmap13 = await createImageBitmap(imageData14);
try {
gpuCanvasContext12.unconfigure();
} catch {}
let video15 = await videoWithData();
let commandEncoder42 = device1.createCommandEncoder(
{
label: '\u849c\uc6cb\u37d1\u{1fe18}',
}
);
let texture52 = device1.createTexture(
{
size: [859, 1, 184],
mipLevelCount: 2,
dimension: '3d',
format: 'rgba8unorm-srgb',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba8unorm',
'rgba8unorm-srgb',
'rgba8unorm'
],
}
);
let renderBundle37 = renderBundleEncoder19.finish();
try {
renderPassEncoder9.executeBundles([]);
} catch {}
try {
renderPassEncoder9.setScissorRect(
13,
37,
0,
3
);
} catch {}
try {
renderPassEncoder9.setStencilReference(
3129
);
} catch {}
let pipeline40 = device1.createRenderPipeline(
{
label: '\uebc1\ucb4a\u{1f8a6}\u0895',
layout: pipelineLayout8,
vertex: {
module: shaderModule17,
entryPoint: 'vertex0',
constants: {},
buffers: [
{
arrayStride: 3408,
stepMode: 'vertex',
attributes: [
{
format: 'float32x3',
offset: 2252,
shaderLocation: 12,
},
{
format: 'sint16x4',
offset: 1212,
shaderLocation: 10,
},
{
format: 'uint8x2',
offset: 2386,
shaderLocation: 5,
},
{
format: 'uint32x3',
offset: 1692,
shaderLocation: 1,
},
{
format: 'uint32x4',
offset: 1972,
shaderLocation: 13,
},
{
format: 'sint8x2',
offset: 3254,
shaderLocation: 4,
}
],
}
]
},
multisample: {
count: 4,
mask: 0x5a79b5b6,
},
fragment: {
module: shaderModule17,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r32float',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.RED,
},
{
format: 'rgba8uint',
},
{
format: 'r32float',
writeMask: GPUColorWrite.ALPHA,
},
{
format: 'r16uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'rg16sint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'rg16uint',
writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
blend: {
color: {
operation: 'max',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
},
format: 'r8unorm',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.RED,
},
{
format: 'r32sint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'equal',
stencilFront: {
depthFailOp: 'increment-clamp',
passOp: 'decrement-clamp',
},
stencilBack: {
compare: 'never',
failOp: 'decrement-wrap',
depthFailOp: 'invert',
passOp: 'zero',
},
stencilWriteMask: 1789,
depthBias: 33,
depthBiasClamp: 20,
},
}
);
offscreenCanvas14.width = 710;
let commandEncoder43 = device4.createCommandEncoder();
let texture53 = device4.createTexture(
{
label: '\u2efe\ua17f\u59cd\ucbdf\u974e\ua6b5\ub5d4\ubfb9\ua4fd\u{1ff36}\u{1fe25}',
size: [60, 10, 153],
mipLevelCount: 3,
format: 'astc-12x10-unorm',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'astc-12x10-unorm-srgb',
'astc-12x10-unorm'
],
}
);
let renderBundleEncoder34 = device4.createRenderBundleEncoder(
{
label: '\u{1f7f3}\u4e3d\u646c\uc00c\u4616\u2f14\u{1fd2f}',
colorFormats: [
'rgba32uint'
],
sampleCount: 333,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle38 = renderBundleEncoder34.finish(
{
label: '\u00d2\u{1ff32}\u049f\u0550\u{1f7d1}\ue82c\u{1fd50}\u{1f90c}'
}
);
let pipelineLayout11 = device1.createPipelineLayout(
{
label: '\u{1fd84}\u{1ffb5}\uec37\u{1fabd}\u01ab\u9fd4\u7a63\u5fb4\u71c5\ufbe8\u{1f8af}',
bindGroupLayouts: [
bindGroupLayout13,
bindGroupLayout16,
bindGroupLayout18,
bindGroupLayout9,
bindGroupLayout15,
bindGroupLayout11,
bindGroupLayout11,
bindGroupLayout14,
bindGroupLayout11,
bindGroupLayout14,
bindGroupLayout18
]
}
);
let commandEncoder44 = device1.createCommandEncoder(
{
label: '\u14cd\u{1fc13}\u80cb\u5c20\u{1fdad}\u4316\u7d0f\uccf7\u82fd',
}
);
let textureView30 = texture43.createView(
{
label: '\u{1fe01}\u8a13\u0442\uc925\uad7f\u0756\u{1f900}\u37f8\u9a4d\u0992',
baseMipLevel: 1,
}
);
let renderPassEncoder13 = commandEncoder42.beginRenderPass(
{
label: '\u44f2\ufc07\ube66\u{1f6e3}',
colorAttachments: [
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: 0.4372405103974264,
depthLoadOp: 'clear',
depthStoreOp: 'discard',
stencilReadOnly: false,
},
occlusionQuerySet: querySet15,
maxDrawCount: 5032,
}
);
try {
renderPassEncoder12.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setViewport(
13.25,
4.713,
7.352,
18.55,
0.4304,
0.9837
);
} catch {}
try {
commandEncoder44.clearBuffer(
buffer6
);
dissociateBuffer(device1, buffer6);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture31,
  mipLevel: 1,
  origin: { x: 0, y: 32, z: 1 },
  aspect: 'all',
},
new Uint8ClampedArray(new ArrayBuffer(16)),
/* required buffer size: 492 */{
offset: 492,
},
{width: 6509, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let promise14 = device1.queue.onSubmittedWorkDone();
try {
gpuCanvasContext0.unconfigure();
} catch {}
let adapter8 = await navigator.gpu.requestAdapter();
let img12 = await imageWithData(181, 16, '#8b145ea8', '#014f105f');
let shaderModule19 = device5.createShaderModule(
{
code: `@group(3) @binding(167)
var<storage, read_write> function27: array<u32>;
@group(2) @binding(167)
var<storage, read_write> local14: array<u32>;
@group(1) @binding(167)
var<storage, read_write> parameter16: array<u32>;
@group(0) @binding(167)
var<storage, read_write> field22: array<u32>;

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



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

struct VertexOutput0 {
@location(10) f258: vec4<u32>,
@location(11) f259: vec4<i32>,
@location(6) f260: vec4<u32>,
@location(1) f261: vec2<u32>,
@location(12) f262: vec3<u32>,
@location(4) f263: vec2<f32>,
@location(7) f264: vec4<u32>,
@location(15) f265: vec2<u32>,
@location(3) f266: i32,
@location(0) f267: u32,
@location(9) f268: vec3<i32>,
@location(2) f269: vec2<f16>,
@builtin(position) f270: vec4<f32>
}

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

`,
sourceMap: {},
hints: {},
}
);
let sampler33 = device5.createSampler(
{
label: '\ub341\ud1f2\u39ba\u0a0e\uea7c\u7054\u1c89\u41f7\u0bed',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 77.103,
lodMaxClamp: 81.757,
maxAnisotropy: 2,
}
);
let promise15 = device5.createRenderPipelineAsync(
{
label: '\u1687\u0c7b\u257b\u5dcf\u8e01\u6abe\u0403\udec3\u0000\ue3e0\ue2d3',
layout: pipelineLayout9,
vertex: {
module: shaderModule16,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 396,
stepMode: 'vertex',
attributes: [
{
format: 'float16x2',
offset: 252,
shaderLocation: 1,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'uint8x4',
offset: 1596,
shaderLocation: 8,
},
{
format: 'sint16x2',
offset: 1948,
shaderLocation: 3,
},
{
format: 'snorm8x2',
offset: 910,
shaderLocation: 7,
}
],
}
]
},
fragment: {
module: shaderModule16,
entryPoint: 'fragment0',
constants: {},
targets: [
{
blend: {
color: {
operation: 'min',
srcFactor: 'one',
dstFactor: 'one'
},
alpha: {
operation: 'reverse-subtract',
srcFactor: 'dst-alpha',
dstFactor: 'dst'
},
},
format: 'r16float',
writeMask: GPUColorWrite.BLUE,
},
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'less',
stencilFront: {
compare: 'greater',
depthFailOp: 'invert',
passOp: 'zero',
},
stencilBack: {
compare: 'never',
failOp: 'replace',
depthFailOp: 'decrement-clamp',
},
stencilReadMask: 2092,
stencilWriteMask: 540,
depthBias: 8,
depthBiasSlopeScale: 68,
depthBiasClamp: 95,
},
}
);
canvas8.height = 692;
let imageData19 = new ImageData(128, 28);
document.body.prepend(canvas11);
let computePassEncoder19 = commandEncoder44.beginComputePass(
{

}
);
let renderBundleEncoder35 = device1.createRenderBundleEncoder(
{
label: '\uf585\ud2e8\u0ff0\u0459',
colorFormats: [
'r32float',
undefined,
'rg8uint',
'r16uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 153,
depthReadOnly: false,
stencilReadOnly: true,
}
);
try {
renderPassEncoder9.setBlendConstant({ r: 257.9, g: 798.5, b: -484.3, a: 469.3, });
} catch {}
try {
renderPassEncoder9.setScissorRect(
1,
46,
13,
0
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
2432,
new DataView(new ArrayBuffer(28575)),
8356,
148
);
} catch {}
gc();
let texture54 = device4.createTexture(
{
label: '\u{1f95a}\u{1f88c}\u04ee\u1a2e\u165c\ue6fa',
size: [4, 4, 240],
mipLevelCount: 3,
format: 'etc2-rgb8unorm-srgb',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
try {
computePassEncoder16.insertDebugMarker(
'\u084a'
);
} catch {}
let imageBitmap14 = await createImageBitmap(videoFrame10);
let texture55 = device1.createTexture(
{
label: '\u0e77\u0a70',
size: [25, 6, 109],
mipLevelCount: 7,
dimension: '3d',
format: 'r32sint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [

],
}
);
let sampler34 = device1.createSampler(
{
label: '\u5a44\u4b4e\u94f4\u3ab8\u0f53',
addressModeU: 'repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'linear',
mipmapFilter: 'nearest',
lodMinClamp: 14.860,
lodMaxClamp: 85.088,
}
);
try {
renderPassEncoder9.setIndexBuffer(
buffer11,
'uint16',
11814,
302
);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(
21,
undefined,
2623610581,
587562855
);
} catch {}
try {
renderBundleEncoder30.setIndexBuffer(
buffer8,
'uint32'
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
4216,
new DataView(new ArrayBuffer(191)),
109,
40
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture55,
  mipLevel: 3,
  origin: { x: 0, y: 0, z: 5 },
  aspect: 'all',
},
new ArrayBuffer(32832),
/* required buffer size: 32832 */{
offset: 860,
bytesPerRow: 122,
rowsPerImage: 131,
},
{width: 2, height: 1, depthOrArrayLayers: 3}
);
} catch {}
let querySet38 = device5.createQuerySet({
label: '\u{1fa0b}\u0d8a\u{1fed4}\u06bd\u{1f976}',
type: 'occlusion',
count: 3733,
});
let pipeline41 = await device5.createComputePipelineAsync(
{
label: '\u9631\u0eb0\u{1f9f1}',
layout: pipelineLayout9,
compute: {
module: shaderModule15,
entryPoint: 'compute0',
constants: {},
},
}
);
let gpuCanvasContext14 = canvas14.getContext('webgpu');
let offscreenCanvas18 = new OffscreenCanvas(108, 415);
let sampler35 = device6.createSampler(
{
label: '\u7b45\u3172\u{1fdd4}\u7f8d\u0b00\u0391',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 58.470,
lodMaxClamp: 64.563,
maxAnisotropy: 17,
}
);
try {
commandEncoder41.insertDebugMarker(
'\ud162'
);
} catch {}
canvas3.height = 976;
let imageData20 = new ImageData(120, 152);
let querySet39 = device4.createQuerySet({
label: '\u{1faa2}\u{1ff04}\u1582\u0452\u{1f81c}\u0d92\u{1f79b}\u79a5',
type: 'occlusion',
count: 1848,
});
let textureView31 = texture49.createView(
{
label: '\u2019\u142f\u6553\ue6a5\u91f2',
dimension: '2d',
baseArrayLayer: 39,
}
);
let renderBundle39 = renderBundleEncoder34.finish(
{
label: '\u0915\ub699\u815c'
}
);
try {
device4.pushErrorScope('internal');
} catch {}
let imageBitmap15 = await createImageBitmap(img10);
let commandEncoder45 = device4.createCommandEncoder(
{
}
);
let textureView32 = texture54.createView(
{
label: '\u7d10\u{1fbbe}\udb0b',
baseMipLevel: 2,
baseArrayLayer: 157,
arrayLayerCount: 8,
}
);
let promise16 = device4.queue.onSubmittedWorkDone();
try {
offscreenCanvas18.getContext('webgl2');
} catch {}
let bindGroupLayout24 = device6.createBindGroupLayout(
{
label: '\ue38e\u0706\u0a44\u2db0\u{1f957}\u0bd5\u01d5\uc813',
entries: [
{
binding: 108,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
texture: { viewDimension: '2d-array', sampleType: 'depth', multisampled: false },
},
{
binding: 111,
visibility: GPUShaderStage.VERTEX,
sampler: { type: 'non-filtering' },
}
],
}
);
let renderBundleEncoder36 = device6.createRenderBundleEncoder(
{
label: '\u0bc8\u010a\ubf23\u5ca3\ubde3',
colorFormats: [
'rgba32sint',
'r16sint',
'r32uint',
'r16uint',
'rg16float',
'rg8uint'
],
sampleCount: 751,
depthReadOnly: true,
}
);
let renderBundle40 = renderBundleEncoder36.finish(
{
label: '\u0d2c\u600d\u{1ff7c}\u0b96'
}
);
let sampler36 = device6.createSampler(
{
label: '\u{1f7ce}\u4b8a\u77a3\u{1f788}\u7185\u1923\u{1f796}',
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
addressModeW: 'mirror-repeat',
mipmapFilter: 'nearest',
lodMinClamp: 73.808,
lodMaxClamp: 93.117,
}
);
try {
gpuCanvasContext1.configure(
{
device: device6,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r8uint'
],
colorSpace: 'srgb',
alphaMode: 'premultiplied',
}
);
} catch {}
try {
device5.queue.label = '\u094a\u0464\u3244\u5a25\u{1f830}\u{1fc1e}\u{1f8f9}\u49f2';
} catch {}
let bindGroupLayout25 = device5.createBindGroupLayout(
{
label: '\u0c9a\u{1fd99}\u780a\u650e\u8733\u0ce3\uae01\u{1fa15}\u0134',
entries: [
{
binding: 378,
visibility: GPUShaderStage.VERTEX,
externalTexture: {},
},
{
binding: 59,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
sampler: { type: 'filtering' },
}
],
}
);
let buffer17 = device5.createBuffer(
{
size: 43534,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
}
);
let textureView33 = texture45.createView(
{
}
);
let renderBundleEncoder37 = device5.createRenderBundleEncoder(
{
colorFormats: [
'rg16float',
'rg32sint',
'r32uint',
'rgba8unorm-srgb',
'rg32uint'
],
sampleCount: 174,
stencilReadOnly: true,
}
);
let pipeline42 = device5.createComputePipeline(
{
label: '\ubbe4\ubeae\u{1f684}\ub489\udc05\u{1fb59}\u5e17',
layout: pipelineLayout9,
compute: {
module: shaderModule16,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline43 = await promise15;
let renderBundleEncoder38 = device5.createRenderBundleEncoder(
{
label: '\u0aad\u081f\u93bd\uf82e',
colorFormats: [
'rgba32sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 461,
depthReadOnly: true,
}
);
try {
renderBundleEncoder32.setVertexBuffer(
1,
buffer13,
20256,
21989
);
} catch {}
let pipeline44 = device5.createComputePipeline(
{
label: '\u99b3\u{1fffe}',
layout: pipelineLayout9,
compute: {
module: shaderModule16,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let commandEncoder46 = device6.createCommandEncoder(
{
label: '\u3da5\u{1fdce}\u0b48\u68c3\u011a\u{1fa15}\u{1fdf3}\u8093\u469a\u{1fda8}\u{1f975}',
}
);
let renderBundleEncoder39 = device6.createRenderBundleEncoder(
{
label: '\u599c\u1330\u{1fe63}\u{1face}\ua9da\u3982\u7468\ud200\ube08\u0b05',
colorFormats: [
'r8sint',
undefined,
'rg32float',
undefined,
'r32float',
'r8unorm',
'rgb10a2unorm'
],
sampleCount: 620,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let externalTexture4 = device6.importExternalTexture(
{
label: '\u{1fb38}\u{1fc57}\u6834\u0d4e',
source: videoFrame1,
colorSpace: 'srgb',
}
);
try {
gpuCanvasContext4.configure(
{
device: device6,
format: 'rgba16float',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [

],
colorSpace: 'display-p3',
alphaMode: 'premultiplied',
}
);
} catch {}
gc();
try {
renderBundleEncoder18.label = '\u3911\u0a36\u0e60\u0a41\u0acc\u0fb8\u06f9\u40aa\u0517\u0c0c';
} catch {}
try {
renderPassEncoder5.setScissorRect(
3780,
142,
9889,
68
);
} catch {}
try {
await device2.queue.onSubmittedWorkDone();
} catch {}
let video16 = await videoWithData();
let imageData21 = new ImageData(52, 112);
offscreenCanvas1.width = 156;
let texture56 = device4.createTexture(
{
label: '\u07f2\u8f0d\ua7fa',
size: {width: 766},
dimension: '1d',
format: 'rg16float',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'rg16float',
'rg16float',
'rg16float'
],
}
);
try {
computePassEncoder15.end();
} catch {}
let querySet40 = device1.createQuerySet({
label: '\u{1f72d}\u{1f634}\u1d39\u33de\u0691\u{1fb6f}\u6e13',
type: 'occlusion',
count: 1441,
});
try {
renderPassEncoder13.setBlendConstant({ r: -741.9, g: 505.1, b: 539.8, a: 371.7, });
} catch {}
try {
renderPassEncoder13.setIndexBuffer(
buffer8,
'uint32',
44968,
162
);
} catch {}
try {
renderBundleEncoder35.setVertexBuffer(
82,
undefined,
1262650262,
978898828
);
} catch {}
let arrayBuffer4 = buffer6.getMappedRange(
496,
944
);
try {
device1.queue.writeTexture(
{
  texture: texture43,
  mipLevel: 0,
  origin: { x: 8, y: 0, z: 74 },
  aspect: 'all',
},
new Int8Array(arrayBuffer4),
/* required buffer size: 1007122 */{
offset: 280,
bytesPerRow: 842,
rowsPerImage: 239,
},
{width: 163, height: 1, depthOrArrayLayers: 6}
);
} catch {}
let imageBitmap16 = await createImageBitmap(imageBitmap15);
let renderBundleEncoder40 = device1.createRenderBundleEncoder(
{
label: '\u90d3\u{1fa2e}\u{1fe2f}\u{1fcb6}\ue923\u0296\u8e82\u9092\u9aa6\u{1ff1d}',
colorFormats: [
'r16uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 118,
stencilReadOnly: false,
}
);
try {
renderPassEncoder13.beginOcclusionQuery(1922);
} catch {}
try {
renderPassEncoder13.setViewport(
17.24,
2.748,
3.697,
20.10,
0.5865,
0.7506
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
1828,
new Float32Array(54293),
45538,
1512
);
} catch {}
let renderBundleEncoder41 = device4.createRenderBundleEncoder(
{
label: '\u0bbe\u3621\u0b9e\uf95b\uab8b',
colorFormats: [
'rgba32float',
undefined,
'r16float',
undefined,
'rg8sint',
'r32float'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 886,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let externalTexture5 = device4.importExternalTexture(
{
label: '\u24be\u{1f847}\u69ab\u0146\ub312\u6b11\ua841\u09d2\u{1f65f}\u0860\u03ee',
source: videoFrame9,
colorSpace: 'display-p3',
}
);
try {
computePassEncoder16.insertDebugMarker(
'\u3c4f'
);
} catch {}
try {
device4.queue.writeTexture(
{
  texture: texture53,
  mipLevel: 2,
  origin: { x: 0, y: 0, z: 42 },
  aspect: 'all',
},
new Int8Array(arrayBuffer1),
/* required buffer size: 2367113 */{
offset: 833,
bytesPerRow: 313,
rowsPerImage: 90,
},
{width: 12, height: 0, depthOrArrayLayers: 85}
);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let renderBundleEncoder42 = device1.createRenderBundleEncoder(
{
label: '\u00a8\u05c8\u8892\u{1f864}\uf079\u4139\u0629\uadf1',
colorFormats: [
'r32sint',
'r32sint',
'rgba8uint',
'rgba8unorm-srgb',
'rgba32float',
'r8unorm',
'r8sint',
'rgba8unorm-srgb'
],
sampleCount: 282,
depthReadOnly: true,
}
);
let sampler37 = device1.createSampler(
{
label: '\u9b81\u03d8',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 23.510,
lodMaxClamp: 35.971,
}
);
try {
renderPassEncoder13.setViewport(
22.72,
12.32,
0.1750,
26.42,
0.3538,
0.9757
);
} catch {}
try {
renderPassEncoder9.setVertexBuffer(
88,
undefined,
2572415750,
930914353
);
} catch {}
try {
gpuCanvasContext13.configure(
{
device: device1,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [
'bgra8unorm',
'r8sint'
],
colorSpace: 'display-p3',
alphaMode: 'opaque',
}
);
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
1836,
new Float32Array(63492),
29387,
1932
);
} catch {}
let imageData22 = new ImageData(32, 204);
try {
await adapter8.requestAdapterInfo();
} catch {}
let imageData23 = new ImageData(168, 172);
let texture57 = device6.createTexture(
{
size: {width: 562},
dimension: '1d',
format: 'rgba8sint',
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba8sint',
'rgba8sint',
'rgba8sint'
],
}
);
let renderBundleEncoder43 = device6.createRenderBundleEncoder(
{
colorFormats: [
'rg32float',
'r16sint',
'rg16uint'
],
sampleCount: 449,
stencilReadOnly: true,
}
);
let commandBuffer8 = commandEncoder36.finish(
{
label: '\ubf4d\u20e3',
}
);
let texture58 = device4.createTexture(
{
label: '\u02df\uc660',
size: [7160],
dimension: '1d',
format: 'rg32float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
}
);
let sampler38 = device4.createSampler(
{
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'clamp-to-edge',
lodMinClamp: 67.716,
lodMaxClamp: 92.330,
}
);
try {
renderBundleEncoder41.setVertexBuffer(
12,
undefined,
4183070401,
865251
);
} catch {}
try {
await device4.queue.onSubmittedWorkDone();
} catch {}
try {
await promise16;
} catch {}
let bindGroup3 = device5.createBindGroup({
label: '\u{1f979}\u{1f90f}\u7e0d\uf37a\u{1ff94}\u{1ffae}',
layout: bindGroupLayout22,
entries: [
{
binding: 704,
resource: sampler32
}
],
});
let renderBundleEncoder44 = device5.createRenderBundleEncoder(
{
label: '\u0fd3\u0888\ua2e8\u0edb\u{1ff3f}\u8b5d\u078c\u{1fbf9}\u03db\u{1fbf0}',
colorFormats: [
'r8uint',
'rg32float',
'rgba32uint',
'rg16uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 649,
depthReadOnly: true,
stencilReadOnly: true,
}
);
try {
renderBundleEncoder32.setVertexBuffer(
4,
buffer13,
36248,
7539
);
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture46,
  mipLevel: 2,
  origin: { x: 0, y: 6, z: 17 },
  aspect: 'all',
},
arrayBuffer4,
/* required buffer size: 2014064 */{
offset: 180,
bytesPerRow: 124,
rowsPerImage: 149,
},
{width: 40, height: 0, depthOrArrayLayers: 110}
);
} catch {}
let videoFrame13 = new VideoFrame(imageBitmap16, {timestamp: 0});
try {
computePassEncoder16.insertDebugMarker(
'\u11d1'
);
} catch {}
let querySet41 = device4.createQuerySet({
type: 'occlusion',
count: 3707,
});
let textureView34 = texture54.createView(
{
label: '\u2d14\u4f7f\u6805\ud8dd',
baseMipLevel: 1,
mipLevelCount: 1,
baseArrayLayer: 79,
arrayLayerCount: 140,
}
);
let sampler39 = device4.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 50.677,
lodMaxClamp: 61.405,
compare: 'never',
}
);
try {
renderBundleEncoder41.setVertexBuffer(
38,
undefined
);
} catch {}
let texture59 = device1.createTexture(
{
label: '\u0d54\u0d14\u2980\u{1ffa5}\u242b\u{1fb43}\u81b3\u0c30\u3441\u0a02',
size: [185, 1, 166],
mipLevelCount: 5,
format: 'depth16unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
}
);
let renderBundle41 = renderBundleEncoder28.finish(
{
label: '\u020b\u6424\u0a68\u2115'
}
);
try {
renderPassEncoder9.setStencilReference(
2132
);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(
buffer11,
'uint16',
13050,
515
);
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let commandEncoder47 = device1.createCommandEncoder(
{
label: '\u45dd\u02f0\u7864\u{1f918}\uf7ea',
}
);
let querySet42 = device1.createQuerySet({
label: '\u0e20\u2d8e\ucb2c',
type: 'occlusion',
count: 330,
});
let textureView35 = texture29.createView(
{
label: '\u0854\u{1fb0a}\u0787\u42b7\u019d',
baseMipLevel: 6,
mipLevelCount: 2,
}
);
try {
await device1.queue.onSubmittedWorkDone();
} catch {}
let pipeline45 = await promise13;
let device7 = await adapter8.requestDevice({
label: '\u3d3e\ud2a6\u026e\u4ea7',
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'shader-f16',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 11,
maxColorAttachmentBytesPerSample: 60,
maxVertexAttributes: 25,
maxVertexBufferArrayStride: 34530,
maxStorageTexturesPerShaderStage: 16,
maxStorageBuffersPerShaderStage: 22,
maxDynamicStorageBuffersPerPipelineLayout: 39150,
maxBindingsPerBindGroup: 9269,
maxTextureDimension1D: 14890,
maxTextureDimension2D: 10866,
maxVertexBuffers: 12,
minStorageBufferOffsetAlignment: 64,
minUniformBufferOffsetAlignment: 64,
maxUniformBufferBindingSize: 185746955,
maxUniformBuffersPerShaderStage: 43,
maxInterStageShaderVariables: 63,
maxInterStageShaderComponents: 116,
maxSamplersPerShaderStage: 17,
},
});
try {
renderBundleEncoder43.setVertexBuffer(
17,
undefined,
4207557307
);
} catch {}
try {
device6.pushErrorScope('internal');
} catch {}
try {
await promise14;
} catch {}
let video17 = await videoWithData();
let commandBuffer9 = commandEncoder33.finish(
{
label: '\u01cf\u1819\ub4ac\u8589\uf299\u9a78\u4a8a\u{1fc62}',
}
);
let textureView36 = texture49.createView(
{
label: '\u418e\u05e8\ua892\u{1fa80}',
baseMipLevel: 0,
baseArrayLayer: 4,
arrayLayerCount: 158,
}
);
let renderBundle42 = renderBundleEncoder41.finish(
{

}
);
try {
computePassEncoder16.end();
} catch {}
let commandEncoder48 = device5.createCommandEncoder();
let querySet43 = device5.createQuerySet({
label: '\u83f7\ue704\u3a11\u1e49\ue3ed\ua8c8\u0fcb\u79e4\u06f6\u840f\u103d',
type: 'occlusion',
count: 2304,
});
try {
buffer15.unmap();
} catch {}
try {
commandEncoder48.copyTextureToTexture(
{
  texture: texture48,
  mipLevel: 5,
  origin: { x: 4, y: 0, z: 7 },
  aspect: 'all',
},
{
  texture: texture48,
  mipLevel: 3,
  origin: { x: 112, y: 24, z: 0 },
  aspect: 'all',
},
{width: 28, height: 0, depthOrArrayLayers: 22}
);
} catch {}
try {
commandEncoder48.resolveQuerySet(
querySet43,
1196,
157,
buffer14,
2048
);
} catch {}
try {
computePassEncoder14.insertDebugMarker(
'\u0b24'
);
} catch {}
try {
device5.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData22,
  origin: { x: 27, y: 20 },
  flipY: true,
},
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 1 },
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
},
{width: 1, height: 1, depthOrArrayLayers: 0}
);
} catch {}
offscreenCanvas14.width = 909;
gc();
let querySet44 = device5.createQuerySet({
label: '\u5174\u8bf5\u0512\u{1f783}\u32e2\uacaa',
type: 'occlusion',
count: 1634,
});
let sampler40 = device5.createSampler(
{
label: '\ud291\u8ed2\u32ba\u9df6\u043b\u9882\u0c7f\u{1fd8a}',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 92.873,
lodMaxClamp: 94.818,
maxAnisotropy: 8,
}
);
try {
renderBundleEncoder37.setVertexBuffer(
2,
buffer13
);
} catch {}
try {
device5.addEventListener('uncapturederror', e => { log('device5.uncapturederror'); log(e); e.label = device5.label; });
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
new BigInt64Array(new ArrayBuffer(8)),
/* required buffer size: 357 */{
offset: 357,
bytesPerRow: 133,
},
{width: 1, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let pipeline46 = await promise11;
gc();
let renderBundle43 = renderBundleEncoder41.finish(
{
label: '\u58d7\u0d4c\u108e'
}
);
let sampler41 = device4.createSampler(
{
label: '\ucd61\u{1f7bf}\u{1f70d}\ufbdb\u8b7e\u0cc1\u8463\u05cc\uc9f7\u53b6\u54cd',
addressModeU: 'mirror-repeat',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMaxClamp: 49.232,
}
);
document.body.prepend(canvas0);
try {
window.someLabel = textureView24.label;
} catch {}
let img13 = await imageWithData(183, 205, '#279a39f0', '#ec522a27');
let imageData24 = new ImageData(96, 188);
try {
device7.destroy();
} catch {}
video3.width = 67;
let bindGroupLayout26 = device6.createBindGroupLayout(
{
entries: [

],
}
);
let pipelineLayout12 = device6.createPipelineLayout(
{
label: '\u44c1\u0906\u53b2',
bindGroupLayouts: [
bindGroupLayout26
]
}
);
let commandEncoder49 = device6.createCommandEncoder(
{
label: '\u001e\ubd0d\u{1f93b}\u{1f8e5}',
}
);
pseudoSubmit(device6, commandEncoder40);
let renderBundle44 = renderBundleEncoder43.finish();
let sampler42 = device6.createSampler(
{
label: '\u51e0\u0fa3\u{1feec}',
addressModeU: 'repeat',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
lodMaxClamp: 95.008,
compare: 'always',
}
);
let textureView37 = texture57.createView(
{
}
);
let offscreenCanvas19 = new OffscreenCanvas(624, 751);
let gpuCanvasContext15 = offscreenCanvas19.getContext('webgpu');
document.body.prepend(canvas6);
canvas1.width = 339;
video13.height = 86;
let img14 = await imageWithData(68, 154, '#9dbb81c4', '#e5c2a2ed');
try {
gpuCanvasContext6.unconfigure();
} catch {}
let buffer18 = device4.createBuffer(
{
label: '\u4c6b\u3dc2\ue4b4\u{1fba9}',
size: 12412,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
}
);
let commandEncoder50 = device4.createCommandEncoder(
{
label: '\u{1fa4c}\ue00f\u01d6\ucce8\u5de8',
}
);
let querySet45 = device4.createQuerySet({
type: 'occlusion',
count: 630,
});
let renderBundle45 = renderBundleEncoder41.finish(
{
label: '\u0675\uddb4\u0edc\u017b\u85d2\u{1fa36}\ucd68\u057b\u{1fc72}\u0e2a\u{1ff89}'
}
);
try {
gpuCanvasContext7.configure(
{
device: device4,
format: 'rgb10a2unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
colorSpace: 'srgb',
alphaMode: 'premultiplied',
}
);
} catch {}
try {
device4.queue.writeTexture(
{
  texture: texture49,
  mipLevel: 0,
  origin: { x: 896, y: 0, z: 149 },
  aspect: 'all',
},
arrayBuffer4,
/* required buffer size: 641444 */{
offset: 87,
bytesPerRow: 3865,
rowsPerImage: 165,
},
{width: 1816, height: 4, depthOrArrayLayers: 2}
);
} catch {}
let imageData25 = new ImageData(144, 96);
pseudoSubmit(device5, commandEncoder48);
let texture60 = device5.createTexture(
{
label: '\u04c0\u0c32\u{1fd61}\u{1fb0b}\u{1f9d8}\uc5d0\u060d\ua971\u51ec\u2d76\u9564',
size: {width: 2440, height: 120, depthOrArrayLayers: 1},
mipLevelCount: 12,
format: 'astc-8x8-unorm-srgb',
usage: GPUTextureUsage.COPY_DST,
}
);
let sampler43 = device5.createSampler(
{
label: '\u02d3\uc48c',
addressModeV: 'repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
lodMinClamp: 77.642,
lodMaxClamp: 83.366,
}
);
try {
device5.queue.writeBuffer(
buffer17,
14036,
new Float32Array(26367),
4877,
1680
);
} catch {}
canvas9.width = 764;
let bindGroupLayout27 = device1.createBindGroupLayout(
{
label: '\u9f1b\u{1ff79}',
entries: [
{
binding: 5887,
visibility: GPUShaderStage.FRAGMENT,
storageTexture: { format: 'rgba32float', access: 'write-only', viewDimension: '2d-array' },
},
{
binding: 5765,
visibility: 0,
externalTexture: {},
}
],
}
);
let commandEncoder51 = device1.createCommandEncoder(
{
label: '\u4da4\u{1f954}\u{1f66a}\u0d91',
}
);
let textureView38 = texture28.createView(
{
label: '\u007c\u0cca\u1716\u5bc0\u643a\ue0eb\u3ed8\ue3b7',
}
);
let computePassEncoder20 = commandEncoder51.beginComputePass(
{
label: '\u098f\udec4\u42c4\u{1f62f}'
}
);
let renderBundleEncoder45 = device1.createRenderBundleEncoder(
{
label: '\u0282\u{1f6ac}\u07e7\u{1fe0a}\u0d50',
colorFormats: [
undefined,
'rgba16float',
'bgra8unorm',
'r8unorm',
'rg16sint',
'rgba32uint',
'rgba16uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 124,
stencilReadOnly: true,
}
);
try {
renderPassEncoder13.setBlendConstant({ r: 378.1, g: 838.9, b: 440.5, a: 899.5, });
} catch {}
try {
commandEncoder47.copyBufferToBuffer(
buffer3,
7476,
buffer16,
9396,
948
);
dissociateBuffer(device1, buffer3);
dissociateBuffer(device1, buffer16);
} catch {}
let bindGroupLayout28 = device5.createBindGroupLayout(
{
label: '\u8278\ud5ea\uf294\ua5c8\u9196\u{1fd44}',
entries: [
{
binding: 736,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
storageTexture: { format: 'rgba16uint', access: 'read-only', viewDimension: '3d' },
}
],
}
);
try {
renderBundleEncoder32.insertDebugMarker(
'\u6177'
);
} catch {}
try {
device5.queue.writeBuffer(
buffer17,
7344,
new BigUint64Array(50921),
41086,
3820
);
} catch {}
let pipeline47 = await device5.createComputePipelineAsync(
{
label: '\u{1f789}\u{1fc3d}\u9ebe\u3719\u0a4d',
layout: pipelineLayout9,
compute: {
module: shaderModule15,
entryPoint: 'compute0',
constants: {},
},
}
);
let buffer19 = device5.createBuffer(
{
label: '\u1392\u{1f8c9}\u0227\u9921\ua6f0\uc720\u0d68',
size: 53440,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
}
);
let commandEncoder52 = device5.createCommandEncoder(
{
label: '\uf21f\uf698\u4924\u{1fae2}\u{1f7a6}\u093c\u4a35\u0e95\u0295',
}
);
let renderBundle46 = renderBundleEncoder44.finish(
{

}
);
let sampler44 = device5.createSampler(
{
label: '\u{1f71d}\u{1ff61}\u6961\u9486\u{1f988}\udac8\u7b4b',
addressModeU: 'mirror-repeat',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
mipmapFilter: 'nearest',
lodMaxClamp: 87.702,
compare: 'not-equal',
}
);
try {
device5.queue.writeTexture(
{
  texture: texture46,
  mipLevel: 1,
  origin: { x: 40, y: 18, z: 31 },
  aspect: 'all',
},
new BigUint64Array(arrayBuffer4),
/* required buffer size: 1010545 */{
offset: 91,
bytesPerRow: 230,
rowsPerImage: 244,
},
{width: 32, height: 12, depthOrArrayLayers: 19}
);
} catch {}
let buffer20 = device5.createBuffer(
{
size: 45594,
usage: GPUBufferUsage.INDIRECT | GPUBufferUsage.STORAGE,
}
);
pseudoSubmit(device5, commandEncoder52);
try {
renderBundleEncoder38.setBindGroup(
3,
bindGroup3,
[]
);
} catch {}
try {
await device5.queue.onSubmittedWorkDone();
} catch {}
gc();
pseudoSubmit(device6, commandEncoder46);
let textureView39 = texture57.createView(
{
}
);
let sampler45 = device6.createSampler(
{
label: '\uff6d\u0a59\uac54\ua2ed\u7df5\ueee7\u{1f76e}\u0eea\u0f5e\u93b7\u0c01',
addressModeU: 'clamp-to-edge',
addressModeV: 'repeat',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 76.660,
lodMaxClamp: 87.361,
}
);
try {
await device6.queue.onSubmittedWorkDone();
} catch {}
try {
navigator.gpu.getPreferredCanvasFormat();
} catch {}
let offscreenCanvas20 = new OffscreenCanvas(255, 687);
let imageData26 = new ImageData(256, 20);
let texture61 = device5.createTexture(
{
size: [163, 1, 215],
mipLevelCount: 7,
dimension: '3d',
format: 'rgba32float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [
'rgba32float',
'rgba32float',
'rgba32float'
],
}
);
let textureView40 = texture45.createView(
{
label: '\u23fd\uff75\u92c3',
dimension: '2d-array',
}
);
let img15 = await imageWithData(173, 177, '#5a220a3c', '#0e49c02a');
let pipelineLayout13 = device6.createPipelineLayout(
{
label: '\ue125\uc27f\u771b\u{1fedf}\u08e1\u98b4\u{1fcb7}\u88e1\u1a87',
bindGroupLayouts: [
bindGroupLayout24,
bindGroupLayout24,
bindGroupLayout24
]
}
);
let externalTexture6 = device6.importExternalTexture(
{
label: '\u4e48\u{1f71f}\u0f47',
source: video16,
colorSpace: 'srgb',
}
);
document.body.prepend(canvas5);
let videoFrame14 = new VideoFrame(offscreenCanvas20, {timestamp: 0});
let shaderModule20 = device2.createShaderModule(
{
label: '\uc182\ub029',
code: `@group(0) @binding(2768)
var<storage, read_write> type18: array<u32>;
@group(4) @binding(2768)
var<storage, read_write> i26: array<u32>;
@group(4) @binding(175)
var<storage, read_write> i27: array<u32>;
@group(2) @binding(2768)
var<storage, read_write> parameter17: array<u32>;
@group(3) @binding(175)
var<storage, read_write> parameter18: array<u32>;
@group(2) @binding(175)
var<storage, read_write> type19: array<u32>;

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

struct S22 {
@location(11) f0: vec3<i32>,
@location(58) f1: vec2<f32>,
@location(4) f2: vec3<f16>,
@location(80) f3: vec4<f16>,
@location(43) f4: vec3<u32>,
@location(49) f5: vec2<u32>,
@location(57) f6: vec3<f16>,
@builtin(position) f7: vec4<f32>,
@location(85) f8: vec2<f32>,
@location(18) f9: vec3<f32>,
@location(88) f10: f32,
@location(55) f11: vec3<f32>,
@location(48) f12: u32,
@location(65) f13: vec2<f32>,
@location(51) f14: vec3<i32>,
@location(9) f15: vec3<f32>,
@location(15) f16: vec2<f16>,
@location(34) f17: vec3<i32>
}
struct FragmentOutput0 {
@location(3) f0: vec3<f32>,
@location(5) f1: vec4<f32>,
@location(2) f2: f32,
@builtin(sample_mask) f3: u32,
@location(6) f4: vec4<i32>,
@location(4) f5: i32
}

@fragment
fn fragment0(@location(7) a0: vec2<i32>, @location(12) a1: f32, @location(38) a2: vec4<f32>, @location(75) a3: vec3<f32>, @location(59) a4: vec2<f16>, @builtin(front_facing) a5: bool, @location(37) a6: vec3<u32>, @location(82) a7: vec3<i32>, @location(52) a8: vec4<f16>, a9: S22, @location(76) a10: vec2<f32>, @location(78) a11: i32, @builtin(sample_mask) a12: u32, @location(92) a13: vec2<i32>, @location(30) a14: vec3<i32>, @location(56) a15: vec3<u32>, @location(28) a16: vec4<f32>, @location(40) a17: vec4<i32>, @location(27) a18: u32, @location(41) a19: vec2<i32>, @location(47) a20: vec4<u32>, @location(61) a21: vec4<i32>, @location(93) a22: f32, @location(68) a23: vec3<u32>, @builtin(sample_index) a24: u32) -> FragmentOutput0 {
return FragmentOutput0();
}

struct VertexOutput0 {
@builtin(position) f271: vec4<f32>,
@location(93) f272: f32,
@location(41) f273: vec2<i32>,
@location(59) f274: vec2<f16>,
@location(30) f275: vec3<i32>,
@location(37) f276: vec3<u32>,
@location(88) f277: f32,
@location(38) f278: vec4<f32>,
@location(92) f279: vec2<i32>,
@location(55) f280: vec3<f32>,
@location(7) f281: vec2<i32>,
@location(27) f282: u32,
@location(68) f283: vec3<u32>,
@location(82) f284: vec3<i32>,
@location(52) f285: vec4<f16>,
@location(11) f286: vec3<i32>,
@location(9) f287: vec3<f32>,
@location(56) f288: vec3<u32>,
@location(85) f289: vec2<f32>,
@location(4) f290: vec3<f16>,
@location(15) f291: vec2<f16>,
@location(51) f292: vec3<i32>,
@location(49) f293: vec2<u32>,
@location(61) f294: vec4<i32>,
@location(80) f295: vec4<f16>,
@location(65) f296: vec2<f32>,
@location(43) f297: vec3<u32>,
@location(76) f298: vec2<f32>,
@location(12) f299: f32,
@location(47) f300: vec4<u32>,
@location(78) f301: i32,
@location(48) f302: u32,
@location(34) f303: vec3<i32>,
@location(18) f304: vec3<f32>,
@location(40) f305: vec4<i32>,
@location(75) f306: vec3<f32>,
@location(28) f307: vec4<f32>,
@location(58) f308: vec2<f32>,
@location(57) f309: vec3<f16>
}

@vertex
fn vertex0(@location(15) a0: vec2<u32>, @location(3) a1: vec3<f16>, @location(12) a2: vec3<i32>, @location(2) a3: vec3<f16>) -> VertexOutput0 {
  return VertexOutput0();
}

`,
sourceMap: {},
hints: {},
}
);
let commandEncoder53 = device2.createCommandEncoder(
{
label: '\u068f\u0d70\u1d2e\u0dd4\u{1f9de}\u06dd',
}
);
let computePassEncoder21 = commandEncoder26.beginComputePass(
{

}
);
let sampler46 = device2.createSampler(
{
label: '\udb2e\u9c1a\ub530\u071f\u703a\ua94c\uf6f1',
addressModeU: 'repeat',
addressModeV: 'repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 20.998,
maxAnisotropy: 14,
}
);
try {
renderPassEncoder5.setBindGroup(
6,
bindGroup2
);
} catch {}
try {
renderPassEncoder5.setScissorRect(
5521,
152,
3491,
0
);
} catch {}
try {
renderBundleEncoder22.setVertexBuffer(
27,
undefined,
2300277329,
896016286
);
} catch {}
try {
await device2.queue.onSubmittedWorkDone();
} catch {}
let pipeline48 = await device2.createRenderPipelineAsync(
{
label: '\u0411\u0741\u0317',
layout: pipelineLayout4,
vertex: {
module: shaderModule8,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'unorm10-10-10-2',
offset: 2396,
shaderLocation: 1,
},
{
format: 'unorm16x2',
offset: 8396,
shaderLocation: 2,
}
],
},
{
arrayStride: 9868,
stepMode: 'vertex',
attributes: [
{
format: 'sint32',
offset: 292,
shaderLocation: 17,
},
{
format: 'unorm16x4',
offset: 8656,
shaderLocation: 5,
}
],
},
{
arrayStride: 38492,
stepMode: 'vertex',
attributes: [
{
format: 'sint32',
offset: 2728,
shaderLocation: 18,
},
{
format: 'uint32',
offset: 14708,
shaderLocation: 11,
},
{
format: 'snorm8x4',
offset: 28296,
shaderLocation: 13,
},
{
format: 'float16x4',
offset: 18940,
shaderLocation: 6,
},
{
format: 'uint16x4',
offset: 4944,
shaderLocation: 9,
},
{
format: 'uint16x4',
offset: 32368,
shaderLocation: 16,
},
{
format: 'uint32x3',
offset: 19288,
shaderLocation: 10,
},
{
format: 'float16x4',
offset: 12292,
shaderLocation: 3,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 38728,
stepMode: 'instance',
attributes: [
{
format: 'uint16x4',
offset: 8624,
shaderLocation: 8,
},
{
format: 'sint8x4',
offset: 24452,
shaderLocation: 0,
},
{
format: 'sint32x4',
offset: 14444,
shaderLocation: 4,
},
{
format: 'uint8x4',
offset: 30296,
shaderLocation: 12,
},
{
format: 'unorm8x2',
offset: 35146,
shaderLocation: 14,
},
{
format: 'sint16x4',
offset: 18848,
shaderLocation: 7,
},
{
format: 'float16x2',
offset: 3124,
shaderLocation: 15,
}
],
}
]
},
primitive: {
topology: 'triangle-list',
unclippedDepth: false,
},
fragment: {
module: shaderModule8,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rgb10a2uint',
},
undefined,
undefined,
undefined,
undefined,
{
format: 'r8uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
},
undefined
],
},
}
);
let gpuCanvasContext16 = offscreenCanvas20.getContext('webgpu');
let renderBundleEncoder46 = device4.createRenderBundleEncoder(
{
colorFormats: [
'rgba32uint',
undefined
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 271,
depthReadOnly: true,
}
);
try {
buffer18.unmap();
} catch {}
try {
device4.queue.submit([
commandBuffer9,
commandBuffer8,
]);
} catch {}
document.body.prepend(video3);
let adapter9 = await navigator.gpu.requestAdapter(
{
}
);
let canvas15 = document.createElement('canvas');
canvas5.width = 935;
let imageData27 = new ImageData(204, 236);
let textureView41 = texture49.createView(
{
label: '\u{1f723}\u4aec\u5194\u0c40\u06da\u0f8d\u52a2\u813a\u88a4',
baseArrayLayer: 25,
arrayLayerCount: 48,
}
);
let renderBundle47 = renderBundleEncoder46.finish(
{
label: '\u5a52\u477a'
}
);
try {
commandEncoder39.pushDebugGroup(
'\u5aed'
);
} catch {}
try {
device4.queue.writeTexture(
{
  texture: texture58,
  mipLevel: 0,
  origin: { x: 1075, y: 1, z: 0 },
  aspect: 'all',
},
new ArrayBuffer(172),
/* required buffer size: 172 */{
offset: 172,
},
{width: 5399, height: 0, depthOrArrayLayers: 1}
);
} catch {}
let commandEncoder54 = device5.createCommandEncoder(
{
label: '\u3cc0\u44b7\ubf09\u0f85\u07b3\uc428\ue2c1\u07a0\u0853',
}
);
let querySet46 = device5.createQuerySet({
label: '\uc5b7\u8407\u{1f755}\ue9fd\u0e08',
type: 'occlusion',
count: 344,
});
let textureView42 = texture51.createView(
{
dimension: '2d',
format: 'astc-10x10-unorm',
baseArrayLayer: 62,
}
);
try {
renderBundleEncoder37.setBindGroup(
1,
bindGroup3
);
} catch {}
try {
renderBundleEncoder32.setBindGroup(
0,
bindGroup3,
new Uint32Array(8700),
8279,
0
);
} catch {}
try {
renderBundleEncoder32.setVertexBuffer(
2,
buffer13
);
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture48,
  mipLevel: 5,
  origin: { x: 8, y: 0, z: 2 },
  aspect: 'all',
},
new ArrayBuffer(72),
/* required buffer size: 44245 */{
offset: 149,
bytesPerRow: 136,
rowsPerImage: 81,
},
{width: 16, height: 4, depthOrArrayLayers: 5}
);
} catch {}
try {
gpuCanvasContext0.unconfigure();
} catch {}
offscreenCanvas2.width = 347;
let video18 = await videoWithData();
document.body.prepend(canvas14);
let offscreenCanvas21 = new OffscreenCanvas(969, 947);
let video19 = await videoWithData();
let video20 = await videoWithData();
let bindGroupLayout29 = device1.createBindGroupLayout(
{
label: '\u{1ff66}\u6440\u02b3\u8df9\u{1f90c}\u9bdd',
entries: [
{
binding: 1803,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
sampler: { type: 'filtering' },
},
{
binding: 1997,
visibility: 0,
externalTexture: {},
},
{
binding: 1570,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
texture: { viewDimension: 'cube', sampleType: 'sint', multisampled: false },
}
],
}
);
let texture62 = device1.createTexture(
{
label: '\u0450\udf68\u0c27\u068b',
size: {width: 6164},
dimension: '1d',
format: 'rg8sint',
usage: GPUTextureUsage.TEXTURE_BINDING,
}
);
let renderBundleEncoder47 = device1.createRenderBundleEncoder(
{
label: '\u0695\u55ef',
colorFormats: [
'rgba8unorm',
'rgba32sint',
'r8sint',
undefined,
'rg16sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 78,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle48 = renderBundleEncoder30.finish(
{
label: '\u5708\ud060\u0e3e\u4fb3\u6db1\udc4b\u337a\u039e'
}
);
try {
renderPassEncoder13.setScissorRect(
19,
36,
3,
6
);
} catch {}
try {
commandEncoder47.resolveQuerySet(
querySet16,
174,
784,
buffer7,
11520
);
} catch {}
let texture63 = device4.createTexture(
{
size: {width: 1830},
dimension: '1d',
format: 'rgba16float',
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba16float',
'rgba16float'
],
}
);
canvas4.width = 657;
let img16 = await imageWithData(266, 27, '#9d8878ff', '#a5450169');
let bindGroup4 = device5.createBindGroup({
label: '\u274c\u0fdf\u0835\u{1fd1f}\u{1f9f3}\u046c\u{1f77a}\u{1f703}\u0f66',
layout: bindGroupLayout22,
entries: [
{
binding: 704,
resource: sampler32
}
],
});
let renderBundleEncoder48 = device5.createRenderBundleEncoder(
{
label: '\u62d3\u{1f6b9}\u990a',
colorFormats: [
'r16float',
'rg8uint',
undefined,
'rg16float',
'rg32float'
],
sampleCount: 265,
depthReadOnly: true,
}
);
let sampler47 = device5.createSampler(
{
label: '\u05d2\u{1fdff}\u035c\uae4b\u50f0',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMaxClamp: 99.178,
maxAnisotropy: 12,
}
);
try {
device5.queue.submit([
]);
} catch {}
try {
device5.queue.writeBuffer(
buffer17,
26264,
new BigUint64Array(9395),
1689,
1112
);
} catch {}
let pipeline49 = device5.createComputePipeline(
{
label: '\ue9d3\u0432\u7c8f\u78ca\u1996\u0ca5\u1ae7\u58fa\u{1fca0}',
layout: pipelineLayout9,
compute: {
module: shaderModule16,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline50 = await device5.createRenderPipelineAsync(
{
label: '\u0121\u6924',
layout: pipelineLayout9,
vertex: {
module: shaderModule19,
entryPoint: 'vertex0',
buffers: [

]
},
fragment: {
module: shaderModule19,
entryPoint: 'fragment0',
targets: [
{
format: 'r16uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
}
],
},
}
);
let offscreenCanvas22 = new OffscreenCanvas(740, 973);
let imageData28 = new ImageData(152, 120);
let buffer21 = device1.createBuffer(
{
label: '\u0031\u3546\u3e82\u1d63\u0a42\ufdf4\u0cae\u03ac\u0086\u0fe0\uf30e',
size: 22200,
usage: GPUBufferUsage.STORAGE,
mappedAtCreation: true,
}
);
let texture64 = device1.createTexture(
{
label: '\u0602\u08e7\u5b03\u524e\u{1fd78}',
size: [175, 1, 1723],
mipLevelCount: 5,
dimension: '3d',
format: 'rgb10a2uint',
usage: GPUTextureUsage.RENDER_ATTACHMENT,
viewFormats: [
'rgb10a2uint',
'rgb10a2uint',
'rgb10a2uint'
],
}
);
let renderBundleEncoder49 = device1.createRenderBundleEncoder(
{
label: '\u1087\u{1f8b2}\u1f27\u8ae9\u778d\u38de\u9018\u0790',
colorFormats: [
'rg32sint',
'rg32float',
'r16float',
'r8unorm'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 745,
depthReadOnly: true,
}
);
try {
computePassEncoder10.setPipeline(
pipeline30
);
} catch {}
try {
renderPassEncoder9.setIndexBuffer(
buffer8,
'uint16',
29768,
6664
);
} catch {}
try {
commandEncoder47.copyTextureToTexture(
{
  texture: texture30,
  mipLevel: 5,
  origin: { x: 0, y: 2, z: 0 },
  aspect: 'all',
},
{
  texture: texture59,
  mipLevel: 0,
  origin: { x: 22, y: 0, z: 32 },
  aspect: 'depth-only',
},
{width: 105, height: 0, depthOrArrayLayers: 32}
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture23,
  mipLevel: 4,
  origin: { x: 28, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer1,
/* required buffer size: 451309 */{
offset: 453,
bytesPerRow: 313,
rowsPerImage: 120,
},
{width: 34, height: 1, depthOrArrayLayers: 13}
);
} catch {}
let pipeline51 = device1.createComputePipeline(
{
label: '\u25e3\u022c\uc0f4\ua1d9\u80fc\ucd9d\u9580\u9089\uc31f\u0555\u{1fae2}',
layout: pipelineLayout6,
compute: {
module: shaderModule14,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline52 = device1.createRenderPipeline(
{
layout: pipelineLayout8,
vertex: {
module: shaderModule18,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 368,
attributes: [
{
format: 'uint32x4',
offset: 48,
shaderLocation: 2,
},
{
format: 'snorm8x2',
offset: 24,
shaderLocation: 7,
},
{
format: 'sint32',
offset: 80,
shaderLocation: 15,
},
{
format: 'float16x4',
offset: 20,
shaderLocation: 4,
},
{
format: 'sint8x2',
offset: 356,
shaderLocation: 17,
},
{
format: 'sint32',
offset: 232,
shaderLocation: 16,
},
{
format: 'snorm16x2',
offset: 8,
shaderLocation: 9,
},
{
format: 'snorm16x4',
offset: 148,
shaderLocation: 6,
},
{
format: 'sint32x4',
offset: 44,
shaderLocation: 0,
},
{
format: 'snorm16x2',
offset: 312,
shaderLocation: 12,
},
{
format: 'sint8x4',
offset: 156,
shaderLocation: 8,
},
{
format: 'snorm8x4',
offset: 44,
shaderLocation: 13,
},
{
format: 'unorm16x4',
offset: 112,
shaderLocation: 14,
},
{
format: 'uint32',
offset: 212,
shaderLocation: 5,
},
{
format: 'sint32',
offset: 352,
shaderLocation: 1,
},
{
format: 'sint32x3',
offset: 40,
shaderLocation: 10,
},
{
format: 'float32x2',
offset: 64,
shaderLocation: 19,
},
{
format: 'sint8x4',
offset: 0,
shaderLocation: 18,
},
{
format: 'sint32x3',
offset: 292,
shaderLocation: 11,
},
{
format: 'snorm8x2',
offset: 330,
shaderLocation: 3,
}
],
}
]
},
multisample: {
mask: 0xf0d3a902,
},
fragment: {
module: shaderModule18,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rgba32uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'r32float',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
},
{
format: 'rg16sint',
},
{
format: 'rg16float',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.GREEN,
},
{
format: 'rg8uint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
},
{
format: 'rg32float',
},
{
format: 'r16uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.GREEN,
},
{
format: 'rg8uint',
writeMask: 0,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'greater-equal',
stencilFront: {
compare: 'not-equal',
failOp: 'increment-clamp',
depthFailOp: 'invert',
passOp: 'replace',
},
stencilBack: {
compare: 'less-equal',
failOp: 'replace',
depthFailOp: 'replace',
passOp: 'decrement-clamp',
},
stencilWriteMask: 210,
depthBias: 84,
depthBiasSlopeScale: 64,
depthBiasClamp: 5,
},
}
);
try {
gpuCanvasContext8.unconfigure();
} catch {}
try {
canvas15.getContext('2d');
} catch {}
try {
adapter5.label = '\u{1f662}\ufb3a\u079e';
} catch {}
let device8 = await adapter9.requestDevice({
label: '\u{1f782}\u{1fddf}\u5c09\u0f25\ua97d\u{1fb7a}',
requiredFeatures: [
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'shader-f16',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 11,
maxColorAttachmentBytesPerSample: 35,
maxVertexAttributes: 21,
maxVertexBufferArrayStride: 12115,
maxStorageTexturesPerShaderStage: 13,
maxStorageBuffersPerShaderStage: 42,
maxDynamicStorageBuffersPerPipelineLayout: 41229,
maxBindingsPerBindGroup: 1420,
maxTextureDimension1D: 14875,
maxTextureDimension2D: 9789,
maxVertexBuffers: 10,
minStorageBufferOffsetAlignment: 64,
minUniformBufferOffsetAlignment: 32,
maxUniformBufferBindingSize: 263204759,
maxUniformBuffersPerShaderStage: 42,
maxInterStageShaderVariables: 124,
maxInterStageShaderComponents: 84,
maxSamplersPerShaderStage: 21,
},
});
let offscreenCanvas23 = new OffscreenCanvas(174, 217);
let gpuCanvasContext17 = offscreenCanvas22.getContext('webgpu');
offscreenCanvas10.height = 931;
let img17 = await imageWithData(258, 40, '#0c13af87', '#55a8c25b');
let buffer22 = device8.createBuffer(
{
label: '\u620f\u{1ff7a}\ueee3\u15da\ud54a\u{1ffbb}\ua3d7\u601e\u0beb\u02fe',
size: 55283,
usage: GPUBufferUsage.COPY_SRC,
}
);
let renderBundleEncoder50 = device8.createRenderBundleEncoder(
{
colorFormats: [
'bgra8unorm-srgb',
'rgba8sint',
'rg16float',
'rg32sint',
'r32float'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 786,
depthReadOnly: true,
stencilReadOnly: true,
}
);
try {
await device8.queue.onSubmittedWorkDone();
} catch {}
let imageData29 = new ImageData(156, 112);
let gpuCanvasContext18 = offscreenCanvas21.getContext('webgpu');
let imageBitmap17 = await createImageBitmap(videoFrame4);
let buffer23 = device6.createBuffer(
{
label: '\u0ac1\ua6f4\u6d9a\u{1f95a}\u9f02\u5187\u0aa4\u05ef\u0f6a\ud1ee\ufcd6',
size: 31986,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
}
);
pseudoSubmit(device6, commandEncoder38);
let textureView43 = texture57.createView(
{
label: '\u{1ffb6}\u0dbb\u00e3\u0900\u9820\u6035\u4230\u82a5\ua478\u{1ff90}\u03b6',
baseMipLevel: 0,
mipLevelCount: 1,
baseArrayLayer: 0,
}
);
let videoFrame15 = new VideoFrame(video18, {timestamp: 0});
let commandEncoder55 = device4.createCommandEncoder(
{
label: '\u0dbd\u{1f661}\ued06\u8147\u{1fc07}\u06d7\ub80b\u0616\uc04e\u977c\u{1fec3}',
}
);
let querySet47 = device4.createQuerySet({
label: '\u0fee\u9b1a\u8629\u3a9b\u0f11\u6396\u{1f803}\u{1fc02}\u0a57',
type: 'occlusion',
count: 3451,
});
let textureView44 = texture56.createView(
{
baseArrayLayer: 0,
}
);
let renderBundleEncoder51 = device4.createRenderBundleEncoder(
{
label: '\u{1fcbd}\u0bad\u{1f889}\uc24f\u361e\ua27a\u685d\u04e0\ua365\uf2a4\u274f',
colorFormats: [
undefined,
undefined,
'rg11b10ufloat',
'rgba8unorm-srgb',
'rg8uint'
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 9,
stencilReadOnly: true,
}
);
let promise17 = adapter3.requestAdapterInfo();
try {
await promise17;
} catch {}
let adapter10 = await navigator.gpu.requestAdapter(
{
powerPreference: 'low-power',
}
);
let offscreenCanvas24 = new OffscreenCanvas(629, 138);
try {
offscreenCanvas24.getContext('webgl2');
} catch {}
let textureView45 = texture57.createView(
{
label: '\u{1f97b}\u{1f8bb}\u7f25\u0848\u2f6c\u1de6',
aspect: 'all',
}
);
let computePassEncoder22 = commandEncoder49.beginComputePass(
{

}
);
let renderBundle49 = renderBundleEncoder39.finish(
{
label: '\u0b24\u{1f916}\u0ed7\u572f'
}
);
let bindGroupLayout30 = device8.createBindGroupLayout(
{
label: '\u6c64\u75bb\u8528\u{1f8c0}\u858c\ue0b8\u06af\u0737',
entries: [

],
}
);
let querySet48 = device8.createQuerySet({
label: '\ua8cc\u{1fe3f}\u{1ff54}\u8ea9\uac7b\uaa6a\uc238\u494d\u{1fcfa}',
type: 'occlusion',
count: 3020,
});
let renderBundleEncoder52 = device8.createRenderBundleEncoder(
{
colorFormats: [
'rgba32float',
'rgba8uint',
'r32float',
'r32sint',
undefined,
'r8sint'
],
sampleCount: 447,
stencilReadOnly: true,
}
);
try {
renderBundleEncoder50.setVertexBuffer(
40,
undefined,
3464583727,
440002951
);
} catch {}
let promise18 = device8.queue.onSubmittedWorkDone();
try {
offscreenCanvas23.getContext('webgl');
} catch {}
let texture65 = device1.createTexture(
{
label: '\uc5b7\u0788\u{1f968}\u45a7\u{1fdcb}\u{1fe2d}',
size: {width: 102, height: 1, depthOrArrayLayers: 157},
mipLevelCount: 5,
dimension: '3d',
format: 'rgba16uint',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.TEXTURE_BINDING,
}
);
let renderBundle50 = renderBundleEncoder29.finish();
try {
renderPassEncoder13.setScissorRect(
12,
3,
5,
10
);
} catch {}
try {
gpuCanvasContext14.unconfigure();
} catch {}
let commandEncoder56 = device5.createCommandEncoder(
{
}
);
let computePassEncoder23 = commandEncoder56.beginComputePass(
{
label: '\u0d19\ub0bf\uc431\u31ee\u3e67\u0bd0\u0848'
}
);
let renderBundleEncoder53 = device5.createRenderBundleEncoder(
{
label: '\u9c39\u{1f61b}\u{1fea3}\ud478\uff25\ud8ec\ud0fd\u6cf5\u{1f929}\u02b9\u0760',
colorFormats: [
'rgba16uint',
'rgba8unorm',
'rg16uint',
'rgba16uint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 163,
depthReadOnly: true,
}
);
let externalTexture7 = device5.importExternalTexture(
{
label: '\u0630\u6e36\u3aa9',
source: videoFrame12,
colorSpace: 'display-p3',
}
);
try {
computePassEncoder23.setPipeline(
pipeline49
);
} catch {}
try {
renderBundleEncoder53.setBindGroup(
2,
bindGroup4
);
} catch {}
let pipeline53 = device5.createComputePipeline(
{
layout: pipelineLayout9,
compute: {
module: shaderModule19,
entryPoint: 'compute0',
constants: {},
},
}
);
let imageData30 = new ImageData(108, 44);
try {
computePassEncoder23.setPipeline(
pipeline41
);
} catch {}
try {
renderBundleEncoder53.setVertexBuffer(
1,
buffer13
);
} catch {}
try {
texture48.destroy();
} catch {}
try {
device5.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: imageData18,
  origin: { x: 8, y: 181 },
  flipY: true,
},
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
},
{width: 0, height: 1, depthOrArrayLayers: 1}
);
} catch {}
let pipeline54 = device5.createComputePipeline(
{
label: '\u5292\ufda3\u4267\u0185\u660d\ubaad\u08eb\uf213\u9073\u09e7',
layout: pipelineLayout9,
compute: {
module: shaderModule19,
entryPoint: 'compute0',
constants: {},
},
}
);
let computePassEncoder24 = commandEncoder41.beginComputePass(
{
label: '\u0647\u0c4a\u02ba\u0f4e\ub8dd'
}
);
let renderBundleEncoder54 = device6.createRenderBundleEncoder(
{
label: '\u0f34\u22a7\u47bf\u2681\u9211\u084a',
colorFormats: [
'rg16uint',
undefined,
'rg16sint',
'rgba32sint',
'rg32float',
undefined
],
depthStencilFormat: 'depth32float-stencil8',
sampleCount: 446,
}
);
let videoFrame16 = new VideoFrame(img1, {timestamp: 0});
let querySet49 = device6.createQuerySet({
label: '\u000e\u77fb\ua1ad',
type: 'occlusion',
count: 593,
});
try {
renderBundleEncoder54.setVertexBuffer(
42,
undefined,
1973689288,
1888392382
);
} catch {}
try {
device6.pushErrorScope('out-of-memory');
} catch {}
try {
gpuCanvasContext10.configure(
{
device: device6,
format: 'rgba8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING,
colorSpace: 'srgb',
alphaMode: 'premultiplied',
}
);
} catch {}
let promise19 = device6.queue.onSubmittedWorkDone();
canvas2.width = 810;
let canvas16 = document.createElement('canvas');
let bindGroupLayout31 = device8.createBindGroupLayout(
{
entries: [
{
binding: 1170,
visibility: GPUShaderStage.VERTEX,
texture: { viewDimension: '2d-array', sampleType: 'uint', multisampled: false },
}
],
}
);
let querySet50 = device8.createQuerySet({
label: '\u3532\u{1f74c}\uf841\u{1f6ad}\u0767\u94e6\uc88e\ua720\u8ff8',
type: 'occlusion',
count: 1462,
});
let texture66 = device8.createTexture(
{
size: [128, 176, 1],
mipLevelCount: 3,
format: 'astc-8x8-unorm-srgb',
usage: GPUTextureUsage.COPY_DST,
viewFormats: [
'astc-8x8-unorm-srgb'
],
}
);
let sampler48 = device8.createSampler(
{
label: '\u3d7d\uf5da\u27e2\u{1f99b}\u796e\u9f69\u0748\u041b\u1e2f\ubb81',
addressModeU: 'clamp-to-edge',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
lodMinClamp: 3.121,
lodMaxClamp: 72.716,
}
);
try {
renderBundleEncoder50.setVertexBuffer(
50,
undefined,
3496702864,
437527625
);
} catch {}
let renderBundleEncoder55 = device4.createRenderBundleEncoder(
{
label: '\u01e8\u06dd\u{1f98a}\u081d\u08b2\u5fa4\ue5e6\u42d7\u0e39\u{1f6a4}',
colorFormats: [
'r32uint',
'rgba32sint',
'r8uint',
'rg16uint'
],
sampleCount: 650,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle51 = renderBundleEncoder34.finish();
let sampler49 = device4.createSampler(
{
addressModeU: 'mirror-repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
mipmapFilter: 'nearest',
lodMinClamp: 22.113,
lodMaxClamp: 68.903,
maxAnisotropy: 1,
}
);
let promise20 = device4.queue.onSubmittedWorkDone();
try {
await promise18;
} catch {}
let commandEncoder57 = device1.createCommandEncoder(
{
}
);
let commandBuffer10 = commandEncoder57.finish(
{
}
);
let renderPassEncoder14 = commandEncoder47.beginRenderPass(
{
label: '\u8551\uc69f\u37fd',
colorAttachments: [
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: 0.8249143241193726,
depthLoadOp: 'clear',
depthStoreOp: 'discard',
},
occlusionQuerySet: querySet30,
maxDrawCount: 66472,
}
);
let renderBundle52 = renderBundleEncoder30.finish();
let sampler50 = device1.createSampler(
{
label: '\uc7ad\u770b\uc4dd\u8717\u{1fc46}',
addressModeU: 'clamp-to-edge',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 91.312,
lodMaxClamp: 98.233,
}
);
try {
renderPassEncoder9.setScissorRect(
19,
46,
4,
0
);
} catch {}
try {
renderPassEncoder13.setStencilReference(
3609
);
} catch {}
try {
renderPassEncoder9.setViewport(
11.97,
12.48,
5.286,
29.49,
0.6957,
0.9298
);
} catch {}
try {
renderPassEncoder14.setIndexBuffer(
buffer11,
'uint16'
);
} catch {}
let buffer24 = device4.createBuffer(
{
label: '\u{1ff2e}\u41b7',
size: 58123,
usage: GPUBufferUsage.COPY_SRC,
}
);
let texture67 = device4.createTexture(
{
size: [12, 192, 1],
mipLevelCount: 2,
format: 'astc-12x12-unorm',
usage: GPUTextureUsage.COPY_SRC,
}
);
let renderBundle53 = renderBundleEncoder55.finish(
{

}
);
try {
renderBundleEncoder51.setVertexBuffer(
60,
undefined,
943636274,
3253006056
);
} catch {}
try {
commandEncoder39.popDebugGroup();
} catch {}
let gpuCanvasContext19 = canvas16.getContext('webgpu');
let pipelineLayout14 = device8.createPipelineLayout(
{
bindGroupLayouts: [
bindGroupLayout31,
bindGroupLayout30,
bindGroupLayout31,
bindGroupLayout30,
bindGroupLayout30
]
}
);
let textureView46 = texture66.createView(
{
label: '\u{1fc9a}\u004c\u03eb\ufb3c\u0317\u6bb0\u{1fdcf}\u0fab',
baseMipLevel: 2,
}
);
let sampler51 = device8.createSampler(
{
label: '\u0e52\u0b74\u43b1\u{1fb1b}\u0440\u{1fcbe}\u89b0\uf8fb',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 38.909,
lodMaxClamp: 39.235,
compare: 'less-equal',
maxAnisotropy: 11,
}
);
try {
renderBundleEncoder52.setVertexBuffer(
52,
undefined
);
} catch {}
try {
device8.pushErrorScope('internal');
} catch {}
try {
await device8.queue.onSubmittedWorkDone();
} catch {}
try {
if (!arrayBuffer3.detached) { new Uint8Array(arrayBuffer3).fill(0x55) };
} catch {}
let video21 = await videoWithData();
let adapter11 = await navigator.gpu.requestAdapter(
{
}
);
let imageBitmap18 = await createImageBitmap(offscreenCanvas9);
let offscreenCanvas25 = new OffscreenCanvas(950, 207);
try {
await promise19;
} catch {}
try {
adapter8.label = '\u{1f661}\ua203\u{1f8e0}\u04e8\uc3d8\u{1ffa5}\u8577\udcc5';
} catch {}
let texture68 = device1.createTexture(
{
label: '\u4ed3\u{1f714}\u0727\u6223\u06e8\u297b\uf9d7\uf739\u9015\u0aaf\u76e6',
size: [192, 1, 47],
mipLevelCount: 4,
format: 'rgba8snorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
}
);
let renderBundle54 = renderBundleEncoder21.finish(
{
label: '\u697c\u5b4e\u{1f673}'
}
);
try {
renderPassEncoder14.setScissorRect(
17,
1,
1,
39
);
} catch {}
try {
renderPassEncoder14.setViewport(
1.371,
18.89,
6.446,
5.713,
0.4803,
0.9976
);
} catch {}
try {
texture21.destroy();
} catch {}
let gpuCanvasContext20 = offscreenCanvas25.getContext('webgpu');
let bindGroup5 = device8.createBindGroup({
label: '\u2eca\ufb7f',
layout: bindGroupLayout30,
entries: [

],
});
let commandEncoder58 = device8.createCommandEncoder(
{
label: '\u{1f9d8}\u9ce4\u094b\u{1fb92}\u9463\u2a57\ubd9e\u0f7b',
}
);
let querySet51 = device8.createQuerySet({
type: 'occlusion',
count: 497,
});
let renderBundleEncoder56 = device8.createRenderBundleEncoder(
{
colorFormats: [
'rgb10a2unorm',
'rgba8unorm-srgb',
'rgba16sint',
'r32uint',
'r8uint',
undefined
],
sampleCount: 685,
}
);
let offscreenCanvas26 = new OffscreenCanvas(341, 450);
try {
offscreenCanvas26.getContext('2d');
} catch {}
try {
renderBundleEncoder48.setBindGroup(
2,
bindGroup3,
[]
);
} catch {}
try {
buffer20.destroy();
} catch {}
try {
commandEncoder54.clearBuffer(
buffer15,
2924,
26924
);
dissociateBuffer(device5, buffer15);
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture46,
  mipLevel: 0,
  origin: { x: 0, y: 42, z: 99 },
  aspect: 'all',
},
new ArrayBuffer(1193664),
/* required buffer size: 1193664 */{
offset: 208,
bytesPerRow: 424,
rowsPerImage: 281,
},
{width: 160, height: 30, depthOrArrayLayers: 11}
);
} catch {}
try {
device5.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: video16,
  origin: { x: 12, y: 15 },
  flipY: true,
},
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 1 },
  aspect: 'all',
  colorSpace: 'srgb',
  premultipliedAlpha: false,
},
{width: 1, height: 1, depthOrArrayLayers: 0}
);
} catch {}
try {
await promise20;
} catch {}
gc();
let bindGroupLayout32 = device8.createBindGroupLayout(
{
entries: [

],
}
);
let commandEncoder59 = device8.createCommandEncoder(
{
label: '\u{1f89a}\u003c\u{1fac7}\uddd1\u07d8',
}
);
let querySet52 = device8.createQuerySet({
label: '\u9d4d\u{1fdd8}\u697b\u09dc\u80ca\u0fab\uc08b\u{1fee9}\ue848',
type: 'occlusion',
count: 2719,
});
let textureView47 = texture66.createView(
{
baseMipLevel: 2,
mipLevelCount: 1,
}
);
let sampler52 = device8.createSampler(
{
label: '\u1815\u1832\u0545\u{1fd2f}\u01bb\u2130\u5f5e\u5ece\udda5\u{1f812}\u0d1d',
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 61.986,
lodMaxClamp: 77.316,
maxAnisotropy: 3,
}
);
try {
device8.queue.writeTexture(
{
  texture: texture66,
  mipLevel: 2,
  origin: { x: 16, y: 8, z: 1 },
  aspect: 'all',
},
new Uint8ClampedArray(arrayBuffer0),
/* required buffer size: 806 */{
offset: 806,
bytesPerRow: 221,
rowsPerImage: 177,
},
{width: 0, height: 24, depthOrArrayLayers: 0}
);
} catch {}
try {
if (!arrayBuffer0.detached) { new Uint8Array(arrayBuffer0).fill(0x55) };
} catch {}
try {
window.someLabel = textureView10.label;
} catch {}
let commandEncoder60 = device1.createCommandEncoder();
let texture69 = device1.createTexture(
{
label: '\u09e1\u0cc6\u0938\u4fd2\u0a4e\u20b6',
size: [4299],
dimension: '1d',
format: 'rg8snorm',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'rg8snorm'
],
}
);
let computePassEncoder25 = commandEncoder60.beginComputePass(
{

}
);
try {
renderPassEncoder13.endOcclusionQuery();
} catch {}
try {
renderPassEncoder13.setViewport(
14.93,
7.896,
4.636,
9.794,
0.9158,
0.9290
);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let computePassEncoder26 = commandEncoder54.beginComputePass(
{

}
);
let renderBundleEncoder57 = device5.createRenderBundleEncoder(
{
label: '\u{1f9ac}\u{1f953}\u04a8\u{1f8b9}\uf578\u0b82',
colorFormats: [
'rgba16float',
'rgba8uint',
'rg16float',
'rg8sint',
'r8uint'
],
sampleCount: 823,
depthReadOnly: true,
}
);
try {
renderBundleEncoder38.setVertexBuffer(
5,
buffer13,
42632,
2265
);
} catch {}
try {
device5.queue.writeTexture(
{
  texture: texture44,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
new Float64Array(arrayBuffer4),
/* required buffer size: 977 */{
offset: 977,
},
{width: 1, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let pipeline55 = await device5.createRenderPipelineAsync(
{
layout: pipelineLayout9,
vertex: {
module: shaderModule16,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 908,
stepMode: 'instance',
attributes: [
{
format: 'uint8x2',
offset: 88,
shaderLocation: 8,
}
],
},
{
arrayStride: 832,
stepMode: 'instance',
attributes: [
{
format: 'sint32',
offset: 112,
shaderLocation: 3,
}
],
},
{
arrayStride: 1408,
attributes: [
{
format: 'float32x3',
offset: 716,
shaderLocation: 7,
},
{
format: 'unorm10-10-10-2',
offset: 292,
shaderLocation: 1,
}
],
}
]
},
primitive: {
topology: 'line-strip',
frontFace: 'cw',
cullMode: 'front',
unclippedDepth: true,
},
multisample: {
mask: 0xc6f43171,
},
fragment: {
module: shaderModule16,
entryPoint: 'fragment0',
constants: {},
targets: [

],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'never',
stencilFront: {
compare: 'greater-equal',
depthFailOp: 'replace',
passOp: 'invert',
},
stencilBack: {
compare: 'never',
failOp: 'decrement-clamp',
depthFailOp: 'decrement-wrap',
passOp: 'invert',
},
stencilReadMask: 1283,
depthBias: 64,
depthBiasSlopeScale: 14,
},
}
);
offscreenCanvas16.height = 544;
let renderBundle55 = renderBundleEncoder51.finish(
{
label: '\u02cf\uf1d8\ua8c3\u0044\u7ada\u0690\u0467\u{1ff6d}'
}
);
let sampler53 = device4.createSampler(
{
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
mipmapFilter: 'linear',
lodMaxClamp: 67.947,
maxAnisotropy: 1,
}
);
try {
commandEncoder39.copyBufferToTexture(
{
/* bytesInLastRow: 2912 widthInBlocks: 364 aspectSpecificFormat.texelBlockSize: 8 */
/* end: 34808 */
offset: 34808,
bytesPerRow: 3072,
buffer: buffer24,
},
{
  texture: texture58,
  mipLevel: 0,
  origin: { x: 4008, y: 0, z: 0 },
  aspect: 'all',
},
{width: 364, height: 1, depthOrArrayLayers: 0}
);
dissociateBuffer(device4, buffer24);
} catch {}
try {
if (!arrayBuffer2.detached) { new Uint8Array(arrayBuffer2).fill(0x55) };
} catch {}
let imageData31 = new ImageData(176, 52);
let bindGroup6 = device8.createBindGroup({
label: '\u034f\u{1fcf5}\u0c85\u{1ffe9}\ue903',
layout: bindGroupLayout30,
entries: [

],
});
let computePassEncoder27 = commandEncoder58.beginComputePass(
{
label: '\u1c66\u453a\u039f\u0882\u{1f8db}\u{1f835}\ue425\u{1fa59}\u{1f949}\u50c0\ufa73'
}
);
try {
renderBundleEncoder52.setVertexBuffer(
27,
undefined,
1892312023
);
} catch {}
try {
gpuCanvasContext18.unconfigure();
} catch {}
let device9 = await adapter10.requestDevice({
label: '\u97ff\u{1fa8c}\u05ff\u09f4\ub2fc\uc477\u{1fe0a}\uc9d4\uaf46\u{1fbb6}',
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'texture-compression-astc',
'indirect-first-instance',
'rg11b10ufloat-renderable',
'bgra8unorm-storage'
],
requiredLimits: {
maxBindGroups: 8,
maxColorAttachmentBytesPerSample: 54,
maxVertexAttributes: 17,
maxVertexBufferArrayStride: 65370,
maxStorageBuffersPerShaderStage: 24,
maxDynamicStorageBuffersPerPipelineLayout: 58660,
maxBindingsPerBindGroup: 5478,
maxTextureDimension1D: 11548,
maxTextureDimension2D: 8934,
maxVertexBuffers: 9,
minStorageBufferOffsetAlignment: 128,
minUniformBufferOffsetAlignment: 32,
maxUniformBufferBindingSize: 17016132,
maxUniformBuffersPerShaderStage: 23,
maxInterStageShaderVariables: 93,
maxInterStageShaderComponents: 99,
maxSamplersPerShaderStage: 19,
},
});
offscreenCanvas12.height = 531;
let imageData32 = new ImageData(232, 64);
let commandEncoder61 = device7.createCommandEncoder(
{
label: '\uc18c\u9f91\ub575\ube55\u0c89\u61c0\ua25e\u0d66\u0cde\u0f81',
}
);
let texture70 = device7.createTexture(
{
label: '\uf1e8\uf579\uf65e\u3bb7\u0378\uebc1\u430e\u{1fa17}\uc965',
size: {width: 6360, height: 6, depthOrArrayLayers: 1},
mipLevelCount: 2,
format: 'astc-10x6-unorm',
usage: GPUTextureUsage.TEXTURE_BINDING,
}
);
let computePassEncoder28 = commandEncoder61.beginComputePass(
{
label: '\u0baf\u0f97\ufc0e\u{1fe44}\u01f5\u{1f905}\u03b2'
}
);
let videoFrame17 = new VideoFrame(offscreenCanvas10, {timestamp: 0});
let bindGroupLayout33 = device5.createBindGroupLayout(
{
label: '\u{1ff83}\u{1fbce}\uc017\u{1f87d}\u{1fb1d}',
entries: [
{
binding: 820,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '2d' },
},
{
binding: 555,
visibility: GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
buffer: { type: 'uniform', minBindingSize: 0, hasDynamicOffset: true },
},
{
binding: 634,
visibility: 0,
texture: { viewDimension: '2d', sampleType: 'float', multisampled: false },
}
],
}
);
let buffer25 = device5.createBuffer(
{
label: '\u011d\ue7f1\u2ed2\u6eb7\u0c7e\u044f',
size: 18949,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let texture71 = device5.createTexture(
{
label: '\u{1fdb7}\u002c',
size: {width: 6794},
mipLevelCount: 1,
dimension: '1d',
format: 'rg16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rg16float',
'rg16float'
],
}
);
let sampler54 = device5.createSampler(
{
addressModeU: 'repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 96.128,
lodMaxClamp: 97.067,
compare: 'equal',
}
);
try {
renderBundleEncoder37.setBindGroup(
2,
bindGroup3
);
} catch {}
try {
renderBundleEncoder48.setVertexBuffer(
3,
buffer13,
18672,
17376
);
} catch {}
let commandEncoder62 = device5.createCommandEncoder(
{
label: '\u0c58\u03e8\u6461\u555d\u67df\ubf8b\u3339\u5c18',
}
);
let textureView48 = texture61.createView(
{
baseMipLevel: 5,
}
);
let computePassEncoder29 = commandEncoder62.beginComputePass(
{
label: '\u2838\u7488\u05e7\u0dc8\uc656\ue3d1\u{1fb26}\uaecc'
}
);
try {
computePassEncoder26.setPipeline(
pipeline35
);
} catch {}
let renderBundleEncoder58 = device6.createRenderBundleEncoder(
{
label: '\u{1f9df}\u7d3f\u{1fabf}',
colorFormats: [
'rgb10a2unorm',
undefined,
undefined
],
sampleCount: 422,
depthReadOnly: true,
}
);
gc();
let querySet53 = device9.createQuerySet({
label: '\u{1fb46}\u4b39\u013c\u9ceb\u{1fb3a}\u3428\u0d2b\u23b7\uefc7\u09ba\uc041',
type: 'occlusion',
count: 3725,
});
let sampler55 = device9.createSampler(
{
label: '\u{1ffe1}\ua244\u3240',
addressModeU: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
minFilter: 'nearest',
lodMaxClamp: 93.540,
}
);
try {
gpuCanvasContext20.configure(
{
device: device9,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_SRC,
viewFormats: [
'rg16uint',
'rgba16float',
'rgb9e5ufloat'
],
colorSpace: 'display-p3',
}
);
} catch {}
let offscreenCanvas27 = new OffscreenCanvas(617, 1023);
let texture72 = device4.createTexture(
{
label: '\ue6fa\u7f49\u1cf4',
size: {width: 8037, height: 194, depthOrArrayLayers: 1},
mipLevelCount: 5,
sampleCount: 1,
dimension: '2d',
format: 'rgba32sint',
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba32sint',
'rgba32sint',
'rgba32sint'
],
}
);
try {
device4.queue.writeTexture(
{
  texture: texture47,
  mipLevel: 7,
  origin: { x: 3, y: 0, z: 0 },
  aspect: 'all',
},
new Uint16Array(arrayBuffer2),
/* required buffer size: 290 */{
offset: 290,
bytesPerRow: 325,
},
{width: 2, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let gpuCanvasContext21 = offscreenCanvas27.getContext('webgpu');
let shaderModule21 = device8.createShaderModule(
{
label: '\u062e\u{1fc81}\uf8d4\u65c7\u{1fa92}\u89dc',
code: `@group(0) @binding(1170)
var<storage, read_write> global21: array<u32>;

@compute @workgroup_size(3, 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: vec3<i32>,
@location(7) f1: vec4<i32>,
@location(3) f2: vec4<u32>
}

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

struct S23 {
@location(11) f0: u32,
@location(1) f1: f16,
@location(18) f2: f32,
@location(15) f3: vec2<i32>,
@location(16) f4: vec2<f16>,
@location(10) f5: vec3<f32>,
@location(9) f6: f16
}

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

`,
sourceMap: {},
hints: {},
}
);
let renderBundle56 = renderBundleEncoder52.finish(
{
label: '\u9c2c\u3d77\uf0fe\u{1fa4a}\u04ed'
}
);
try {
adapter4.label = '\u{1f6d5}\u{1ffb6}\u1ba6\u3fa0\u0860\ubc0d\u5335\u14d2\ub5c3';
} catch {}
let querySet54 = device5.createQuerySet({
label: '\u6bbb\u0efa\uba45\u91ec\uc45b\uc5b9\u5d17\u9184\ud633\ud293',
type: 'occlusion',
count: 872,
});
let textureView49 = texture61.createView(
{
label: '\u{1f70c}\u0fe4\u8319',
baseMipLevel: 4,
}
);
let sampler56 = device5.createSampler(
{
label: '\u5608\u014b\u8c07',
addressModeU: 'clamp-to-edge',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
magFilter: 'nearest',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 69.750,
lodMaxClamp: 99.730,
}
);
try {
renderBundleEncoder37.setBindGroup(
0,
bindGroup3
);
} catch {}
try {
device5.queue.submit([
commandBuffer7,
]);
} catch {}
try {
device5.queue.writeBuffer(
buffer17,
19196,
new Int16Array(991),
480,
372
);
} catch {}
try {
adapter1.label = '\ubeed\u5adc\u2526\uf455\u0c55\u0c95\u2d0f\u0454\u0062\u{1fb50}\u4893';
} catch {}
let buffer26 = device9.createBuffer(
{
label: '\u3e15\ue719\ubc5c\u3c6f\ua2c3\ucd7f\uc6b9\u0c76',
size: 920,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
}
);
let bindGroup7 = device8.createBindGroup({
label: '\u6479\u{1f977}',
layout: bindGroupLayout32,
entries: [

],
});
let textureView50 = texture66.createView(
{
label: '\u066f\uc196\ucfe8\u0d15\u0bc7\u{1f9a4}',
aspect: 'all',
baseMipLevel: 0,
mipLevelCount: 1,
}
);
try {
renderBundleEncoder50.setBindGroup(
2,
bindGroup7
);
} catch {}
try {
commandEncoder59.copyBufferToTexture(
{
/* bytesInLastRow: 16 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 16 */
/* end: 54320 */
offset: 54320,
bytesPerRow: 256,
buffer: buffer22,
},
{
  texture: texture66,
  mipLevel: 2,
  origin: { x: 16, y: 0, z: 0 },
  aspect: 'all',
},
{width: 8, height: 40, depthOrArrayLayers: 0}
);
dissociateBuffer(device8, buffer22);
} catch {}
try {
device8.queue.writeTexture(
{
  texture: texture66,
  mipLevel: 1,
  origin: { x: 8, y: 16, z: 1 },
  aspect: 'all',
},
new Float64Array(new ArrayBuffer(0)),
/* required buffer size: 115 */{
offset: 115,
bytesPerRow: 18,
},
{width: 8, height: 56, depthOrArrayLayers: 0}
);
} catch {}
let bindGroup8 = device8.createBindGroup({
label: '\u{1f815}\u3f50\u5aed\u{1ffb7}\u{1f802}\u2f62\u6ce8\u{1f9f1}\u3c79\ue623',
layout: bindGroupLayout30,
entries: [

],
});
let device10 = await adapter11.requestDevice({
label: '\u8f5e\u{1fdda}',
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'rg11b10ufloat-renderable'
],
requiredLimits: {
maxBindGroups: 9,
maxColorAttachmentBytesPerSample: 60,
maxVertexAttributes: 21,
maxVertexBufferArrayStride: 38213,
maxStorageTexturesPerShaderStage: 29,
maxStorageBuffersPerShaderStage: 10,
maxDynamicStorageBuffersPerPipelineLayout: 13260,
maxBindingsPerBindGroup: 4218,
maxTextureDimension1D: 8398,
maxTextureDimension2D: 14953,
maxVertexBuffers: 9,
minStorageBufferOffsetAlignment: 64,
maxUniformBufferBindingSize: 99204218,
maxUniformBuffersPerShaderStage: 40,
maxInterStageShaderVariables: 87,
maxInterStageShaderComponents: 68,
maxSamplersPerShaderStage: 20,
},
});
try {
buffer22.destroy();
} catch {}
let texture73 = gpuCanvasContext7.getCurrentTexture();
let textureView51 = texture47.createView(
{
label: '\u24eb\u1a8f\ud91d',
baseMipLevel: 5,
mipLevelCount: 2,
baseArrayLayer: 0,
}
);
try {
commandEncoder55.copyBufferToTexture(
{
/* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
/* end: 41072 */
offset: 41072,
buffer: buffer24,
},
{
  texture: texture73,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 1}
);
dissociateBuffer(device4, buffer24);
} catch {}
try {
gpuCanvasContext12.unconfigure();
} catch {}
let commandEncoder63 = device1.createCommandEncoder(
{
label: '\u8f50\u05d0\u{1fb4b}\u1e97\u9776\u52ca',
}
);
let renderBundleEncoder59 = device1.createRenderBundleEncoder(
{
label: '\u{1fab0}\uccf6\u9c4d',
colorFormats: [
'rg32float',
'r16uint',
'r16sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 145,
stencilReadOnly: false,
}
);
try {
commandEncoder63.clearBuffer(
buffer16,
1176,
4456
);
dissociateBuffer(device1, buffer16);
} catch {}
try {
device1.queue.submit([
]);
} catch {}
let imageBitmap19 = await createImageBitmap(offscreenCanvas15);
let videoFrame18 = new VideoFrame(videoFrame8, {timestamp: 0});
let textureView52 = texture46.createView(
{
label: '\uef58\u{1f984}\u0a01\ud1f3\u7571\u09f8\u086e\u0e94\u423a\u{1fd4f}',
baseMipLevel: 1,
mipLevelCount: 2,
baseArrayLayer: 92,
arrayLayerCount: 84,
}
);
let renderBundle57 = renderBundleEncoder38.finish(
{
label: '\u{1f8d5}\u1120\u0ba6\u05e8\u9a4b\u97e2\u0276\u140e\u{1fc3f}\u0740'
}
);
try {
computePassEncoder23.setBindGroup(
1,
bindGroup4,
new Uint32Array(3008),
2590,
0
);
} catch {}
let promise21 = device5.createComputePipelineAsync(
{
label: '\u7bb8\u09a8\u294e\u{1fbcb}\u64e0\u{1fec1}\u0776',
layout: pipelineLayout9,
compute: {
module: shaderModule19,
entryPoint: 'compute0',
constants: {},
},
}
);
let commandEncoder64 = device6.createCommandEncoder(
{
label: '\u24e1\u53e9\u9122\u51ab',
}
);
try {
computePassEncoder22.insertDebugMarker(
'\ufa2a'
);
} catch {}
let imageBitmap20 = await createImageBitmap(offscreenCanvas23);
let texture74 = device9.createTexture(
{
size: {width: 6800, height: 192, depthOrArrayLayers: 161},
mipLevelCount: 3,
sampleCount: 1,
format: 'astc-5x4-unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
}
);
try {
gpuCanvasContext20.configure(
{
device: device9,
format: 'bgra8unorm',
usage: GPUTextureUsage.RENDER_ATTACHMENT | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'eac-rg11snorm',
'rg16sint',
'bgra8unorm',
'bgra8unorm'
],
colorSpace: 'srgb',
alphaMode: 'opaque',
}
);
} catch {}
let offscreenCanvas28 = new OffscreenCanvas(523, 264);
let buffer27 = device1.createBuffer(
{
label: '\u0109\u0e7a\u1d7c\u{1f660}\u5331\u{1fb4e}',
size: 5959,
usage: GPUBufferUsage.COPY_DST,
mappedAtCreation: false,
}
);
let querySet55 = device1.createQuerySet({
label: '\u{1f975}\u{1ff78}\u{1fc89}',
type: 'occlusion',
count: 3104,
});
let texture75 = device1.createTexture(
{
label: '\u0d21\u{1fdda}\u05f4\u5d9f\u{1fbe0}\u39e9\ud1a0\u7136\u21a5',
size: [374, 1, 467],
mipLevelCount: 6,
dimension: '3d',
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rgba16float'
],
}
);
let renderPassEncoder15 = commandEncoder63.beginRenderPass(
{
colorAttachments: [
undefined,
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthLoadOp: 'load',
depthStoreOp: 'discard',
},
occlusionQuerySet: querySet28,
maxDrawCount: 159392,
}
);
let renderBundleEncoder60 = device1.createRenderBundleEncoder(
{
colorFormats: [
'r32uint',
undefined,
'rg32uint',
'r32float',
undefined
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 831,
}
);
let renderBundle58 = renderBundleEncoder28.finish(
{
label: '\u2971\u0155\u51f0\u41be\u00a0\u{1ffd5}\u514a\u0957\u7dbd\u{1fcf9}\u51ef'
}
);
try {
computePassEncoder10.setPipeline(
pipeline33
);
} catch {}
try {
renderPassEncoder15.setViewport(
17.18,
39.44,
5.539,
2.442,
0.4497,
0.7509
);
} catch {}
let pipeline56 = await device1.createComputePipelineAsync(
{
label: '\u{1fb29}\u57fe',
layout: pipelineLayout3,
compute: {
module: shaderModule17,
entryPoint: 'compute0',
},
}
);
let bindGroupLayout34 = device9.createBindGroupLayout(
{
label: '\u0c61\ue4df\u05ac\u{1fb97}\u1606\u{1fc61}\ubfaa\u4e00',
entries: [
{
binding: 1921,
visibility: GPUShaderStage.COMPUTE,
storageTexture: { format: 'rgba8uint', access: 'read-only', viewDimension: '2d-array' },
},
{
binding: 2626,
visibility: GPUShaderStage.FRAGMENT,
sampler: { type: 'filtering' },
}
],
}
);
let querySet56 = device9.createQuerySet({
type: 'occlusion',
count: 3101,
});
let texture76 = device9.createTexture(
{
label: '\ue95b\u{1fd31}\u0280\u{1f65d}\udaa4\u09d2\u9117\u3a4f\u0e1b\u{1f83e}\u{1ff84}',
size: [114, 114, 1],
mipLevelCount: 2,
format: 'astc-6x6-unorm',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let bindGroup9 = device8.createBindGroup({
label: '\u2f66\u{1f6e5}\u0685\u5ce1\u5a89\u27c2\u4a0e',
layout: bindGroupLayout32,
entries: [

],
});
let commandEncoder65 = device8.createCommandEncoder(
{
label: '\ud2f4\u8164\ub3e5\u059b\u5fd1',
}
);
pseudoSubmit(device8, commandEncoder58);
try {
await device8.popErrorScope();
} catch {}
try {
renderBundleEncoder56.insertDebugMarker(
'\u5a2a'
);
} catch {}
let promise22 = device8.queue.onSubmittedWorkDone();
let offscreenCanvas29 = new OffscreenCanvas(314, 484);
let commandEncoder66 = device10.createCommandEncoder(
{
label: '\u{1f9f0}\u{1f727}\u8e15',
}
);
let texture77 = device10.createTexture(
{
label: '\u0a95\u{1fd48}\u{1fdc4}\uc3bf\u0e4a',
size: [7641],
dimension: '1d',
format: 'r32uint',
usage: GPUTextureUsage.STORAGE_BINDING,
viewFormats: [
'r32uint'
],
}
);
let textureView53 = texture77.createView(
{
label: '\u8520\u2666\u{1f97c}\u0a75\u48e3\ucde6\ue6a0\u071f',
mipLevelCount: 1,
}
);
let computePassEncoder30 = commandEncoder66.beginComputePass(
{
label: '\u{1f859}\u167f'
}
);
try {
await device10.queue.onSubmittedWorkDone();
} catch {}
try {
await promise22;
} catch {}
document.body.prepend(video3);
try {
offscreenCanvas28.getContext('webgpu');
} catch {}
let commandEncoder67 = device10.createCommandEncoder(
{
}
);
let texture78 = device10.createTexture(
{
label: '\u{1fb75}\u7200\uf589\u0d48\u002d\udddd\u{1f6f3}\u48c1',
size: [3745],
dimension: '1d',
format: 'r16float',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
}
);
try {
device10.addEventListener('uncapturederror', e => { log('device10.uncapturederror'); log(e); e.label = device10.label; });
} catch {}
let texture79 = device1.createTexture(
{
size: [6436, 5, 1],
mipLevelCount: 11,
sampleCount: 1,
format: 'rgb10a2unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
}
);
let sampler57 = device1.createSampler(
{
label: '\ub01b\ubcd9\u580c\u8e64\u{1fb4f}\u0c25\ud675\u0d0f\ubbf1\u73c4',
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 34.633,
lodMaxClamp: 72.523,
}
);
try {
renderPassEncoder9.endOcclusionQuery();
} catch {}
try {
renderPassEncoder14.setBlendConstant({ r: 4.975, g: -755.5, b: 247.6, a: 139.9, });
} catch {}
try {
renderBundleEncoder49.setVertexBuffer(
88,
undefined,
1364935253,
1337309996
);
} catch {}
try {
device1.pushErrorScope('out-of-memory');
} catch {}
let arrayBuffer5 = buffer12.getMappedRange(
17376,
15868
);
try {
device1.queue.writeTexture(
{
  texture: texture17,
  mipLevel: 0,
  origin: { x: 644, y: 1, z: 916 },
  aspect: 'all',
},
new DataView(arrayBuffer1),
/* required buffer size: 2842405 */{
offset: 995,
bytesPerRow: 3974,
rowsPerImage: 143,
},
{width: 935, height: 0, depthOrArrayLayers: 6}
);
} catch {}
let pipeline57 = await device1.createRenderPipelineAsync(
{
label: '\ue1a4\u39b7\ubd7c\uf762\udbe7\u0562\u0ce5\ua472\u27a9\u{1fbc7}\u{1ff87}',
layout: pipelineLayout3,
vertex: {
module: shaderModule10,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1348,
stepMode: 'instance',
attributes: [
{
format: 'sint16x2',
offset: 340,
shaderLocation: 2,
},
{
format: 'unorm10-10-10-2',
offset: 788,
shaderLocation: 17,
},
{
format: 'snorm16x4',
offset: 8,
shaderLocation: 15,
},
{
format: 'uint32x3',
offset: 712,
shaderLocation: 3,
},
{
format: 'unorm10-10-10-2',
offset: 688,
shaderLocation: 10,
},
{
format: 'float32',
offset: 508,
shaderLocation: 6,
},
{
format: 'sint32x4',
offset: 580,
shaderLocation: 9,
},
{
format: 'snorm16x2',
offset: 716,
shaderLocation: 1,
},
{
format: 'unorm16x4',
offset: 396,
shaderLocation: 11,
},
{
format: 'uint32',
offset: 4,
shaderLocation: 8,
},
{
format: 'snorm8x2',
offset: 792,
shaderLocation: 0,
},
{
format: 'snorm8x2',
offset: 606,
shaderLocation: 5,
},
{
format: 'snorm16x4',
offset: 684,
shaderLocation: 12,
},
{
format: 'sint32x3',
offset: 760,
shaderLocation: 4,
}
],
},
{
arrayStride: 48,
stepMode: 'vertex',
attributes: [
{
format: 'float32x3',
offset: 24,
shaderLocation: 19,
}
],
},
{
arrayStride: 3716,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 4368,
stepMode: 'instance',
attributes: [
{
format: 'sint32',
offset: 120,
shaderLocation: 16,
}
],
},
{
arrayStride: 6884,
stepMode: 'instance',
attributes: [
{
format: 'uint32x2',
offset: 6372,
shaderLocation: 18,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'sint16x4',
offset: 6344,
shaderLocation: 7,
}
],
}
]
},
primitive: {
topology: 'point-list',
frontFace: 'cw',
cullMode: 'back',
},
fragment: {
module: shaderModule10,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined,
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'never',
stencilFront: {
compare: 'less',
failOp: 'invert',
depthFailOp: 'zero',
passOp: 'decrement-wrap',
},
stencilBack: {
compare: 'greater',
depthFailOp: 'replace',
passOp: 'replace',
},
stencilReadMask: 574,
stencilWriteMask: 439,
depthBiasSlopeScale: 18,
depthBiasClamp: 88,
},
}
);
let video22 = await videoWithData();
let imageBitmap21 = await createImageBitmap(img11);
let canvas17 = document.createElement('canvas');
let img18 = await imageWithData(164, 107, '#9b666ac9', '#4b4225a3');
let video23 = await videoWithData();
let shaderModule22 = device6.createShaderModule(
{
label: '\uc14e\u{1fc6b}\u4801\u{1fb69}\u29fb\u{1f829}\uef04\u0c33\u9c68\u084c',
code: `@group(1) @binding(111)
var<storage, read_write> local15: array<u32>;
@group(0) @binding(108)
var<storage, read_write> i28: array<u32>;
@group(2) @binding(108)
var<storage, read_write> i29: array<u32>;
@group(2) @binding(111)
var<storage, read_write> type20: array<u32>;
@group(0) @binding(111)
var<storage, read_write> i30: array<u32>;
@group(1) @binding(108)
var<storage, read_write> type21: array<u32>;

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

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

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

struct S24 {
@location(15) f0: vec3<i32>,
@location(9) f1: i32,
@location(8) f2: vec3<f16>,
@location(5) f3: vec4<f16>,
@builtin(vertex_index) f4: u32,
@location(2) f5: vec3<f16>,
@location(3) f6: vec3<u32>
}

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

`,
sourceMap: {},
hints: {},
}
);
let textureView54 = texture57.createView(
{
label: '\u{1f8c5}\u{1fd41}\u09bc\u{1fa72}\u9386',
baseArrayLayer: 0,
arrayLayerCount: 1,
}
);
let renderBundleEncoder61 = device6.createRenderBundleEncoder(
{
label: '\u6180\u688a\u07b0\u{1ff92}\u131a\u04c4\u{1f8d0}',
colorFormats: [
'rg32uint',
'r32float',
'rgb10a2uint',
'r32float'
],
sampleCount: 300,
stencilReadOnly: true,
}
);
let adapter12 = await navigator.gpu.requestAdapter(
{
powerPreference: 'high-performance',
}
);
let gpuCanvasContext22 = canvas17.getContext('webgpu');
let bindGroupLayout35 = device6.createBindGroupLayout(
{
label: '\u7235\udb04\u52f3\u5d1f\u4604\u093d\udbc0\u7593',
entries: [

],
}
);
let querySet57 = device6.createQuerySet({
label: '\u09c8\u{1fb6b}\u097d\u48ca',
type: 'occlusion',
count: 704,
});
let textureView55 = texture57.createView(
{
label: '\u0782\u7ab7\ud32d\u0264\ucb6a\ue7d0\u01f5\u0294\uf924',
}
);
let renderBundle59 = renderBundleEncoder58.finish();
try {
renderBundleEncoder61.setVertexBuffer(
74,
undefined,
1670066320,
1266255063
);
} catch {}
try {
await buffer23.mapAsync(
GPUMapMode.WRITE,
17704,
10920
);
} catch {}
try {
gpuCanvasContext5.unconfigure();
} catch {}
let pipelineLayout15 = device1.createPipelineLayout(
{
label: '\u0ade\u367a\u7b79\uc7dc\ub2fb\u3026\u{1fd65}\u{1faa4}\u0872\u{1fa6f}',
bindGroupLayouts: [
bindGroupLayout14
]
}
);
let renderBundleEncoder62 = device1.createRenderBundleEncoder(
{
label: '\u{1fc13}\udee2\u0b84',
colorFormats: [
'r8unorm',
'rg8sint',
'rgba16sint',
'r8uint',
'r8sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 995,
stencilReadOnly: true,
}
);
try {
renderPassEncoder9.end();
} catch {}
try {
device1.queue.writeBuffer(
buffer16,
6588,
new Int16Array(14520),
5706,
1792
);
} catch {}
let buffer28 = device6.createBuffer(
{
label: '\ua4cd\u{1fa2e}\u{1fafa}\ue061\u0b48\u0b1b\u1c3c\u04a7\u{1fa68}\ufc22\u0667',
size: 62576,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
mappedAtCreation: true,
}
);
let commandEncoder68 = device6.createCommandEncoder(
{
label: '\uda34\u03d5\ud6d8\ubf54\u0e0c\u9191',
}
);
let textureView56 = texture57.createView(
{
label: '\u8aef\u{1fdba}\uf5aa\u052b\u62f0\u37bb\u035a\u{1fc32}\u669a\u{1f75e}',
}
);
let sampler58 = device6.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
lodMinClamp: 94.266,
lodMaxClamp: 96.068,
}
);
try {
computePassEncoder22.end();
} catch {}
let pipeline58 = device6.createRenderPipeline(
{
label: '\u31e4\u{1fd2f}\u{1f6aa}\u8c7d\u{1fb74}\u0ccb\ud9f5\u95b5',
layout: pipelineLayout13,
vertex: {
module: shaderModule22,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1968,
stepMode: 'instance',
attributes: [
{
format: 'sint8x4',
offset: 1000,
shaderLocation: 7,
},
{
format: 'uint8x4',
offset: 660,
shaderLocation: 0,
},
{
format: 'float16x4',
offset: 204,
shaderLocation: 5,
},
{
format: 'sint32',
offset: 1680,
shaderLocation: 9,
},
{
format: 'unorm16x4',
offset: 1388,
shaderLocation: 8,
},
{
format: 'snorm8x2',
offset: 688,
shaderLocation: 6,
},
{
format: 'sint8x2',
offset: 1928,
shaderLocation: 12,
},
{
format: 'unorm8x4',
offset: 520,
shaderLocation: 4,
}
],
},
{
arrayStride: 964,
stepMode: 'instance',
attributes: [
{
format: 'float32x2',
offset: 592,
shaderLocation: 1,
}
],
},
{
arrayStride: 0,
stepMode: 'vertex',
attributes: [

],
},
{
arrayStride: 936,
attributes: [
{
format: 'float32x3',
offset: 216,
shaderLocation: 2,
},
{
format: 'sint32x4',
offset: 224,
shaderLocation: 15,
},
{
format: 'uint8x2',
offset: 290,
shaderLocation: 14,
}
],
},
{
arrayStride: 1228,
attributes: [
{
format: 'uint8x2',
offset: 726,
shaderLocation: 3,
}
],
}
]
},
primitive: {
topology: 'line-list',
cullMode: 'back',
unclippedDepth: true,
},
multisample: {
mask: 0x71aa2602,
},
fragment: {
module: shaderModule22,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined,
undefined,
undefined,
undefined,
undefined
],
},
depthStencil: {
format: 'depth32float-stencil8',
depthWriteEnabled: false,
depthCompare: 'greater',
stencilFront: {
compare: 'always',
failOp: 'invert',
depthFailOp: 'replace',
},
stencilBack: {
compare: 'greater',
failOp: 'invert',
depthFailOp: 'increment-clamp',
},
stencilReadMask: 15,
stencilWriteMask: 2170,
depthBias: 86,
depthBiasSlopeScale: 85,
depthBiasClamp: 63,
},
}
);
let canvas18 = document.createElement('canvas');
let buffer29 = device5.createBuffer(
{
label: '\u0d9b\u087f\u9560\u0a17',
size: 48978,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
}
);
let sampler59 = device5.createSampler(
{
addressModeU: 'clamp-to-edge',
addressModeW: 'clamp-to-edge',
mipmapFilter: 'nearest',
maxAnisotropy: 1,
}
);
try {
renderBundleEncoder37.setBindGroup(
0,
bindGroup4
);
} catch {}
try {
buffer13.unmap();
} catch {}
let pipeline59 = device5.createRenderPipeline(
{
label: '\u0ff9\ub49a\u0c2e\u{1fc05}\ua786\u5d93\u31be\ucc6a\uc66e\u{1fdcb}',
layout: pipelineLayout9,
vertex: {
module: shaderModule19,
entryPoint: 'vertex0',
buffers: [

]
},
primitive: {
topology: 'triangle-strip',
stripIndexFormat: 'uint32',
frontFace: 'cw',
cullMode: 'back',
unclippedDepth: true,
},
fragment: {
module: shaderModule19,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r32uint',
writeMask: GPUColorWrite.GREEN,
}
],
},
}
);
let texture80 = device4.createTexture(
{
label: '\u0ae7\u08ac\uc758\u0d2a\u{1f624}\u2864\u{1ff21}\u2a6d\udec6\u{1ff2c}',
size: {width: 3420, height: 180, depthOrArrayLayers: 199},
mipLevelCount: 12,
format: 'astc-10x10-unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'astc-10x10-unorm'
],
}
);
let computePassEncoder31 = commandEncoder39.beginComputePass(
{

}
);
let renderBundleEncoder63 = device4.createRenderBundleEncoder(
{
label: '\udb48\u7651\u5832\ube38\u1a46\u050d\uc15b',
colorFormats: [
undefined,
'bgra8unorm-srgb',
'rg32float',
'rg16float',
'rgba8sint',
'rg16sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 342,
}
);
let sampler60 = device4.createSampler(
{
label: '\u{1f76c}\u0c4d\ubcdb\u8d46',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 48.636,
lodMaxClamp: 75.262,
maxAnisotropy: 20,
}
);
let texture81 = device10.createTexture(
{
label: '\u0a32\u{1fd5e}',
size: [1244, 1, 202],
mipLevelCount: 2,
dimension: '3d',
format: 'r32sint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'r32sint'
],
}
);
let textureView57 = texture77.createView(
{
label: '\u08f9\u53d3\u4d2a\u022b\u{1fef6}\u044e\ubea7\u{1fc25}\u4c49\u0fa8\ud031',
format: 'r32uint',
}
);
let sampler61 = device10.createSampler(
{
label: '\u0454\u247b',
addressModeU: 'repeat',
addressModeV: 'clamp-to-edge',
minFilter: 'nearest',
lodMinClamp: 32.439,
lodMaxClamp: 44.159,
compare: 'less',
}
);
let gpuCanvasContext23 = offscreenCanvas29.getContext('webgpu');
let pipelineLayout16 = device8.createPipelineLayout(
{
label: '\u4346\u163d\ud441\u8a81\u0347\u{1f7df}\u50ec\u0d40\u06db',
bindGroupLayouts: [
bindGroupLayout30,
bindGroupLayout32,
bindGroupLayout32,
bindGroupLayout30,
bindGroupLayout31,
bindGroupLayout30,
bindGroupLayout32
]
}
);
let texture82 = device8.createTexture(
{
label: '\u{1f659}\u{1fe2a}\u2034\u0522\uab49\u78ab',
size: [197, 3, 1],
mipLevelCount: 2,
format: 'rg8unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'rg8unorm'
],
}
);
let sampler62 = device8.createSampler(
{
label: '\u{1f77d}\ua9a3\u{1fc8f}\u0413\u54e8\u36dc\u{1ffc1}',
addressModeV: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 24.372,
lodMaxClamp: 40.373,
maxAnisotropy: 15,
}
);
try {
renderBundleEncoder56.setVertexBuffer(
52,
undefined,
2490807536,
1391654661
);
} catch {}
try {
buffer22.destroy();
} catch {}
let video24 = await videoWithData();
let bindGroup10 = device5.createBindGroup({
layout: bindGroupLayout25,
entries: [
{
binding: 59,
resource: sampler24
},
{
binding: 378,
resource: externalTexture7
}
],
});
let querySet58 = device5.createQuerySet({
type: 'occlusion',
count: 1630,
});
let sampler63 = device5.createSampler(
{
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'nearest',
mipmapFilter: 'nearest',
lodMaxClamp: 80.111,
}
);
let pipeline60 = device5.createComputePipeline(
{
label: '\u0b3f\u37a3\u0819\ud86f\ud52d\uf566',
layout: pipelineLayout9,
compute: {
module: shaderModule19,
entryPoint: 'compute0',
constants: {},
},
}
);
let promise23 = device5.createRenderPipelineAsync(
{
label: '\u{1fbe4}\u0c0e\u83fe',
layout: pipelineLayout9,
vertex: {
module: shaderModule16,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1084,
stepMode: 'vertex',
attributes: [
{
format: 'sint16x2',
offset: 484,
shaderLocation: 3,
},
{
format: 'unorm16x4',
offset: 1060,
shaderLocation: 1,
},
{
format: 'uint32x3',
offset: 476,
shaderLocation: 8,
},
{
format: 'snorm16x2',
offset: 392,
shaderLocation: 7,
}
],
}
]
},
primitive: {
topology: 'line-strip',
stripIndexFormat: 'uint16',
frontFace: 'cw',
cullMode: 'front',
unclippedDepth: true,
},
fragment: {
module: shaderModule16,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'r16float',
writeMask: GPUColorWrite.ALL | GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
},
undefined,
undefined,
undefined,
{
format: 'r32uint',
writeMask: GPUColorWrite.ALL | GPUColorWrite.BLUE | GPUColorWrite.GREEN,
},
undefined,
{
format: 'r16uint',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE,
},
{
format: 'r32float',
writeMask: GPUColorWrite.ALPHA | GPUColorWrite.BLUE | GPUColorWrite.GREEN | GPUColorWrite.RED,
}
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: true,
depthCompare: 'less-equal',
stencilFront: {
compare: 'greater',
failOp: 'replace',
depthFailOp: 'zero',
passOp: 'invert',
},
stencilBack: {
compare: 'less',
failOp: 'replace',
depthFailOp: 'invert',
},
stencilReadMask: 1359,
stencilWriteMask: 443,
depthBias: 88,
depthBiasSlopeScale: 59,
},
}
);
let video25 = await videoWithData();
let pipelineLayout17 = device9.createPipelineLayout(
{
label: '\u0aa0\udbd8\uf3ad\u09f2\u{1fab0}\u8be1\ua244\u6386',
bindGroupLayouts: [
bindGroupLayout34,
bindGroupLayout34
]
}
);
let sampler64 = device9.createSampler(
{
label: '\u0420\u0192\u605d\ufcc4\u{1fccd}\u092d\u{1fcf1}\uba11\u{1fc91}\u0e91',
addressModeV: 'clamp-to-edge',
addressModeW: 'mirror-repeat',
magFilter: 'nearest',
minFilter: 'nearest',
mipmapFilter: 'nearest',
lodMinClamp: 18.384,
lodMaxClamp: 70.686,
}
);
let pipelineLayout18 = device5.createPipelineLayout(
{
label: '\u697c\ude0c\u83e6',
bindGroupLayouts: [

]
}
);
try {
computePassEncoder26.setPipeline(
pipeline36
);
} catch {}
try {
buffer29.destroy();
} catch {}
try {
await buffer15.mapAsync(
GPUMapMode.READ,
0,
15720
);
} catch {}
let img19 = await imageWithData(7, 207, '#270a66ed', '#29eee68d');
let bindGroupLayout36 = device10.createBindGroupLayout(
{
entries: [
{
binding: 329,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT | GPUShaderStage.VERTEX,
storageTexture: { format: 'rg32float', access: 'read-only', viewDimension: '3d' },
}
],
}
);
try {
device10.queue.writeTexture(
{
  texture: texture81,
  mipLevel: 1,
  origin: { x: 127, y: 0, z: 10 },
  aspect: 'all',
},
new ArrayBuffer(7426477),
/* required buffer size: 7426477 */{
offset: 19,
bytesPerRow: 1937,
rowsPerImage: 71,
},
{width: 473, height: 0, depthOrArrayLayers: 55}
);
} catch {}
document.body.prepend(canvas1);
gc();
let texture83 = device4.createTexture(
{
label: '\uedd9\u{1ff95}\u{1fa40}\u{1fd47}\u{1feed}\uc867\uc8fc\u0cd5\u5dac\u5571',
size: {width: 236, height: 168, depthOrArrayLayers: 116},
mipLevelCount: 2,
format: 'eac-r11unorm',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [
'eac-r11unorm',
'eac-r11unorm',
'eac-r11unorm'
],
}
);
let sampler65 = device4.createSampler(
{
label: '\u458b\u{1fa94}',
addressModeU: 'mirror-repeat',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 19.744,
lodMaxClamp: 55.151,
}
);
try {
commandEncoder55.copyBufferToTexture(
{
/* bytesInLastRow: 4 widthInBlocks: 1 aspectSpecificFormat.texelBlockSize: 4 */
/* end: 47060 */
offset: 47060,
buffer: buffer24,
},
{
  texture: texture73,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
},
{width: 1, height: 0, depthOrArrayLayers: 1}
);
dissociateBuffer(device4, buffer24);
} catch {}
canvas7.width = 912;
let commandEncoder69 = device1.createCommandEncoder(
{
}
);
let texture84 = device1.createTexture(
{
label: '\u05bb\u9e93\uba9e\u{1fb2e}\u3dbf\u0a1d\u{1fccd}\u0a1c\ub44f\u81dc',
size: [35, 167, 1],
mipLevelCount: 7,
format: 'rgba16float',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
}
);
let renderPassEncoder16 = commandEncoder69.beginRenderPass(
{
colorAttachments: [
undefined,
undefined,
undefined
],
depthStencilAttachment: {
view: textureView12,
depthClearValue: 0.904328166503807,
depthLoadOp: 'clear',
depthStoreOp: 'discard',
depthReadOnly: false,
stencilClearValue: 5880,
},
maxDrawCount: 52888,
}
);
try {
renderPassEncoder13.setIndexBuffer(
buffer8,
'uint16',
22298,
3447
);
} catch {}
try {
renderBundleEncoder47.setVertexBuffer(
79,
undefined,
2814930907
);
} catch {}
try {
renderBundleEncoder47.pushDebugGroup(
'\u684b'
);
} catch {}
try {
computePassEncoder19.insertDebugMarker(
'\u8534'
);
} catch {}
try {
device1.queue.writeTexture(
{
  texture: texture32,
  mipLevel: 0,
  origin: { x: 806, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer4,
/* required buffer size: 185 */{
offset: 185,
},
{width: 488, height: 0, depthOrArrayLayers: 1}
);
} catch {}
let promise24 = device1.createComputePipelineAsync(
{
label: '\u02a9\u{1fa00}',
layout: pipelineLayout3,
compute: {
module: shaderModule13,
entryPoint: 'compute0',
constants: {},
},
}
);
let offscreenCanvas30 = new OffscreenCanvas(163, 940);
let pipelineLayout19 = device9.createPipelineLayout(
{
bindGroupLayouts: [

]
}
);
let commandEncoder70 = device9.createCommandEncoder();
let computePassEncoder32 = commandEncoder70.beginComputePass(
{
label: '\u{1fe4a}\u5f00\u{1f8ee}\u{1fb33}\u0f87\u2cc2\u06ad\u9e15\u{1fcf6}\u2e99'
}
);
let commandEncoder71 = device4.createCommandEncoder();
let texture85 = device4.createTexture(
{
size: {width: 576, height: 12, depthOrArrayLayers: 1},
mipLevelCount: 10,
dimension: '2d',
format: 'astc-12x12-unorm-srgb',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC,
viewFormats: [
'astc-12x12-unorm'
],
}
);
let externalTexture8 = device4.importExternalTexture(
{
label: '\u5c98\ua7fd\u1ff4\u95ae\u2be3\u7d92\u9368\u{1fbfe}\u21ad\u{1f915}',
source: video8,
colorSpace: 'display-p3',
}
);
try {
device4.queue.writeTexture(
{
  texture: texture83,
  mipLevel: 0,
  origin: { x: 24, y: 120, z: 43 },
  aspect: 'all',
},
new Uint16Array(arrayBuffer0),
/* required buffer size: 274231 */{
offset: 143,
bytesPerRow: 561,
rowsPerImage: 48,
},
{width: 160, height: 36, depthOrArrayLayers: 11}
);
} catch {}
let renderBundleEncoder64 = device9.createRenderBundleEncoder(
{
label: '\u{1f7ed}\ue73c\u91dc\u{1f91c}\u4285\u{1fe66}\u24cf\u2e12\u3daa',
colorFormats: [
'rgba32uint',
'rg8sint',
'r32sint',
'r16sint',
'rg16uint',
undefined
],
sampleCount: 365,
depthReadOnly: true,
}
);
let video26 = await videoWithData();
let videoFrame19 = new VideoFrame(imageBitmap6, {timestamp: 0});
let buffer30 = device5.createBuffer(
{
label: '\u080f\u2a3a\ud6b1\u03f1\uf460',
size: 26701,
usage: GPUBufferUsage.STORAGE | GPUBufferUsage.UNIFORM,
}
);
let renderBundleEncoder65 = device5.createRenderBundleEncoder(
{
label: '\u0a78\u03e9\u9cea\u07a9\u6455',
colorFormats: [
'r32sint'
],
sampleCount: 357,
depthReadOnly: true,
}
);
let sampler66 = device5.createSampler(
{
label: '\ucca3\u8974\u7472\u365d\u05a4',
addressModeU: 'clamp-to-edge',
addressModeV: 'clamp-to-edge',
addressModeW: 'repeat',
minFilter: 'nearest',
lodMinClamp: 84.294,
lodMaxClamp: 93.338,
compare: 'less',
}
);
try {
renderBundleEncoder65.setVertexBuffer(
7,
buffer13,
33548
);
} catch {}
try {
device5.queue.writeBuffer(
buffer17,
38796,
new Int16Array(30276),
17450,
840
);
} catch {}
let pipeline61 = device5.createComputePipeline(
{
label: '\u51fc\u0da5\u8bb1\uf902\u{1ffe0}\u6b89\u0043\uf087\u0cd4\ue52e',
layout: pipelineLayout18,
compute: {
module: shaderModule19,
entryPoint: 'compute0',
constants: {},
},
}
);
try {
computePassEncoder23.setBindGroup(
0,
bindGroup3
);
} catch {}
let gpuCanvasContext24 = offscreenCanvas30.getContext('webgpu');
let imageData33 = new ImageData(244, 128);
let pipelineLayout20 = device10.createPipelineLayout(
{
label: '\u04e0\ufdb9\u0ceb\uf116',
bindGroupLayouts: [
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36,
bindGroupLayout36
]
}
);
let buffer31 = device10.createBuffer(
{
size: 16080,
usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
mappedAtCreation: true,
}
);
let computePassEncoder33 = commandEncoder67.beginComputePass(
{
label: '\u{1f960}\ub850\ufb6c\uc4b9\u0dad\u0395\u0b58\u1a2c\udb47\u0a0b\u08ee'
}
);
try {
gpuCanvasContext2.configure(
{
device: device10,
format: 'rgba8unorm',
usage: GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
colorSpace: 'srgb',
}
);
} catch {}
let pipelineLayout21 = device6.createPipelineLayout(
{
label: '\u0e05\u67cb\u0387\u2bc3\u92b5\u1f53\u93d8',
bindGroupLayouts: [

]
}
);
let renderBundle60 = renderBundleEncoder54.finish(
{
label: '\ufb54\u0c6a\u{1fc49}\u{1fe70}\u09a9\u05a4\ua76a\u{1fa39}\ud1d4'
}
);
try {
computePassEncoder24.end();
} catch {}
try {
renderBundleEncoder61.setVertexBuffer(
55,
undefined,
459110992,
3188943697
);
} catch {}
let pipeline62 = await device6.createComputePipelineAsync(
{
label: '\u3912\u1648\u7457\u0e56\u0b71\u31da\u{1fe49}\u86c7\u0f4b\u0dbf',
layout: pipelineLayout13,
compute: {
module: shaderModule22,
entryPoint: 'compute0',
constants: {},
},
}
);
let imageData34 = new ImageData(24, 128);
let shaderModule23 = device8.createShaderModule(
{
label: '\u0c56\u05e5\uc3ed\u7c70\u7aa1\ue9fb\u3202',
code: `@group(4) @binding(1170)
var<storage, read_write> global22: array<u32>;

@compute @workgroup_size(1, 3, 4)
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
}

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



@vertex
fn vertex0(@location(17) a0: vec4<f16>, @builtin(instance_index) a1: u32, @location(20) a2: vec4<f32>, @location(4) a3: vec2<u32>, @location(13) a4: vec4<u32>, @location(15) a5: vec3<u32>, @location(0) a6: vec3<u32>, @location(18) a7: vec4<i32>) -> @builtin(position) vec4<f32> {
  return vec4<f32>(0.0, 0.0, 0.0, 1.0);
}

`,
sourceMap: {},
}
);
let texture86 = device8.createTexture(
{
label: '\u{1f998}\uc576\u4dee\u67fd\u1726\ue62f\u74cc\uec43',
size: {width: 6552},
sampleCount: 1,
dimension: '1d',
format: 'rg16uint',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let renderBundleEncoder66 = device8.createRenderBundleEncoder(
{
label: '\u0db0\u0462\ud5a7\uee7e\ubf7a',
colorFormats: [
'r8sint',
'rgba16sint'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 589,
depthReadOnly: false,
stencilReadOnly: false,
}
);
try {
commandEncoder65.copyBufferToTexture(
{
/* bytesInLastRow: 380 widthInBlocks: 190 aspectSpecificFormat.texelBlockSize: 2 */
/* end: 38306 */
offset: 38306,
buffer: buffer22,
},
{
  texture: texture82,
  mipLevel: 0,
  origin: { x: 5, y: 1, z: 0 },
  aspect: 'all',
},
{width: 190, height: 0, depthOrArrayLayers: 0}
);
dissociateBuffer(device8, buffer22);
} catch {}
try {
device8.queue.writeTexture(
{
  texture: texture82,
  mipLevel: 1,
  origin: { x: 12, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer4,
/* required buffer size: 97 */{
offset: 97,
},
{width: 31, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let pipeline63 = device8.createRenderPipeline(
{
label: '\uc42e\u0a7e\u0f35\u{1fe32}\ud67b\u941a\u577a',
layout: 'auto',
vertex: {
module: shaderModule23,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 1524,
stepMode: 'instance',
attributes: [
{
format: 'snorm8x2',
offset: 462,
shaderLocation: 20,
},
{
format: 'unorm10-10-10-2',
offset: 184,
shaderLocation: 17,
},
{
format: 'sint32x2',
offset: 300,
shaderLocation: 18,
},
{
format: 'uint32x2',
offset: 1456,
shaderLocation: 15,
},
{
format: 'uint8x4',
offset: 1348,
shaderLocation: 13,
}
],
},
{
arrayStride: 9644,
stepMode: 'instance',
attributes: [

],
},
{
arrayStride: 3812,
stepMode: 'vertex',
attributes: [
{
format: 'uint32x4',
offset: 756,
shaderLocation: 0,
}
],
},
{
arrayStride: 440,
stepMode: 'vertex',
attributes: [
{
format: 'uint16x4',
offset: 428,
shaderLocation: 4,
}
],
}
]
},
fragment: {
module: shaderModule23,
entryPoint: 'fragment0',
targets: [

],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'greater',
stencilFront: {
compare: 'greater-equal',
failOp: 'zero',
depthFailOp: 'decrement-clamp',
},
stencilBack: {
compare: 'greater',
failOp: 'replace',
depthFailOp: 'increment-wrap',
passOp: 'increment-clamp',
},
stencilReadMask: 1622,
depthBias: 19,
depthBiasSlopeScale: 72,
depthBiasClamp: 30,
},
}
);
let device11 = await adapter12.requestDevice({
requiredFeatures: [
'depth-clip-control',
'depth32float-stencil8',
'texture-compression-etc2',
'indirect-first-instance',
'shader-f16',
'rg11b10ufloat-renderable'
],
requiredLimits: {
maxColorAttachmentBytesPerSample: 54,
maxVertexAttributes: 24,
maxVertexBufferArrayStride: 17136,
maxStorageTexturesPerShaderStage: 31,
maxStorageBuffersPerShaderStage: 16,
maxDynamicStorageBuffersPerPipelineLayout: 44730,
maxBindingsPerBindGroup: 1325,
maxTextureDimension1D: 9872,
maxTextureDimension2D: 8280,
maxVertexBuffers: 11,
minStorageBufferOffsetAlignment: 32,
minUniformBufferOffsetAlignment: 64,
maxUniformBufferBindingSize: 45722691,
maxUniformBuffersPerShaderStage: 33,
maxInterStageShaderVariables: 116,
maxInterStageShaderComponents: 112,
maxSamplersPerShaderStage: 18,
},
});
try {
buffer18.unmap();
} catch {}
try {
device4.queue.writeTexture(
{
  texture: texture49,
  mipLevel: 0,
  origin: { x: 364, y: 0, z: 93 },
  aspect: 'all',
},
arrayBuffer3,
/* required buffer size: 43731981 */{
offset: 481,
bytesPerRow: 5870,
rowsPerImage: 298,
},
{width: 2820, height: 0, depthOrArrayLayers: 26}
);
} catch {}
try {
device4.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: offscreenCanvas21,
  origin: { x: 573, y: 304 },
  flipY: true,
},
{
  texture: texture73,
  mipLevel: 0,
  origin: { x: 0, y: 1, z: 0 },
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
},
{width: 1, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let renderBundle61 = renderBundleEncoder64.finish();
let gpuCanvasContext25 = canvas18.getContext('webgpu');
let shaderModule24 = device1.createShaderModule(
{
label: '\u{1ff67}\u3520\u0e86\u0af6\u6c8b\u8a66\u55c1\u{1fda1}\u3976\ua523\ufdae',
code: `@group(1) @binding(7532)
var<storage, read_write> function28: array<u32>;
@group(3) @binding(1199)
var<storage, read_write> function29: array<u32>;
@group(0) @binding(1832)
var<storage, read_write> global23: array<u32>;
@group(2) @binding(7532)
var<storage, read_write> i31: array<u32>;
@group(2) @binding(5363)
var<storage, read_write> global24: array<u32>;
@group(5) @binding(7532)
var<storage, read_write> global25: array<u32>;
@group(0) @binding(1199)
var<storage, read_write> field23: array<u32>;
@group(4) @binding(7532)
var<storage, read_write> type22: array<u32>;
@group(4) @binding(5363)
var<storage, read_write> global26: array<u32>;
@group(5) @binding(5363)
var<storage, read_write> i32: array<u32>;
@group(3) @binding(1832)
var<storage, read_write> i33: array<u32>;
@group(1) @binding(5363)
var<storage, read_write> type23: array<u32>;

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

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

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



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

`,
sourceMap: {},
hints: {},
}
);
let textureView58 = texture36.createView(
{
label: '\u{1f9e5}\ua8bb\udcce\u0383\u0c58\u{1f957}',
aspect: 'stencil-only',
format: 'stencil8',
baseArrayLayer: 83,
arrayLayerCount: 8,
}
);
let renderBundle62 = renderBundleEncoder28.finish(
{

}
);
try {
renderPassEncoder13.setIndexBuffer(
buffer11,
'uint32'
);
} catch {}
let arrayBuffer6 = buffer21.getMappedRange(
80,
2456
);
let pipeline64 = device1.createComputePipeline(
{
label: '\u0e6b\u3a11\u{1fac5}\ufea6\u{1fe3c}',
layout: pipelineLayout3,
compute: {
module: shaderModule17,
entryPoint: 'compute0',
constants: {},
},
}
);
let pipeline65 = device1.createRenderPipeline(
{
label: '\u0ceb\ue38c',
layout: pipelineLayout3,
vertex: {
module: shaderModule6,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 3712,
stepMode: 'instance',
attributes: [
{
format: 'float32x3',
offset: 316,
shaderLocation: 4,
},
{
format: 'sint16x4',
offset: 3308,
shaderLocation: 3,
},
{
format: 'uint8x4',
offset: 2488,
shaderLocation: 19,
},
{
format: 'uint8x2',
offset: 2848,
shaderLocation: 11,
},
{
format: 'snorm8x2',
offset: 3526,
shaderLocation: 10,
},
{
format: 'snorm16x2',
offset: 2516,
shaderLocation: 16,
}
],
},
{
arrayStride: 140,
stepMode: 'instance',
attributes: [
{
format: 'float16x4',
offset: 20,
shaderLocation: 18,
},
{
format: 'float32x3',
offset: 24,
shaderLocation: 8,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'unorm16x2',
offset: 7424,
shaderLocation: 15,
}
],
},
{
arrayStride: 0,
stepMode: 'instance',
attributes: [
{
format: 'sint16x2',
offset: 2796,
shaderLocation: 7,
},
{
format: 'snorm8x4',
offset: 7228,
shaderLocation: 17,
},
{
format: 'float32x2',
offset: 5248,
shaderLocation: 9,
}
],
},
{
arrayStride: 3116,
stepMode: 'vertex',
attributes: [
{
format: 'snorm16x2',
offset: 1088,
shaderLocation: 14,
},
{
format: 'sint8x4',
offset: 184,
shaderLocation: 5,
},
{
format: 'unorm8x2',
offset: 1744,
shaderLocation: 13,
},
{
format: 'uint16x4',
offset: 2604,
shaderLocation: 12,
}
],
},
{
arrayStride: 5288,
stepMode: 'vertex',
attributes: [
{
format: 'snorm8x4',
offset: 2272,
shaderLocation: 0,
},
{
format: 'snorm16x2',
offset: 20,
shaderLocation: 2,
},
{
format: 'unorm16x2',
offset: 4468,
shaderLocation: 1,
},
{
format: 'sint8x4',
offset: 4872,
shaderLocation: 6,
}
],
}
]
},
primitive: {
topology: 'line-list',
cullMode: 'back',
unclippedDepth: false,
},
multisample: {
mask: 0xe686d3fa,
},
fragment: {
module: shaderModule6,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rg32sint',
writeMask: GPUColorWrite.ALPHA,
},
{
format: 'r8uint',
},
undefined
],
},
}
);
document.body.prepend(video15);
let shaderModule25 = device9.createShaderModule(
{
label: '\u0c20\u6ac9\u{1fea5}\u4779\u26e1\u{1fdb4}',
code: `@group(1) @binding(2626)
var<storage, read_write> global27: array<u32>;
@group(0) @binding(2626)
var<storage, read_write> i34: array<u32>;
@group(0) @binding(1921)
var<storage, read_write> global28: array<u32>;
@group(1) @binding(1921)
var<storage, read_write> local16: array<u32>;

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

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

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



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

`,
}
);
let bindGroupLayout37 = device9.createBindGroupLayout(
{
entries: [

],
}
);
let texture87 = device9.createTexture(
{
label: '\u{1fb2e}\u0ac9\u0445\ufe12\u{1ff78}\u{1fd63}\u5a25',
size: {width: 7660},
dimension: '1d',
format: 'bgra8unorm',
usage: GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING,
viewFormats: [
'bgra8unorm-srgb',
'bgra8unorm-srgb'
],
}
);
let textureView59 = texture76.createView(
{
label: '\uc89b\u97e3\u7cb5\u03ed',
dimension: '2d-array',
baseMipLevel: 1,
}
);
let renderBundleEncoder67 = device9.createRenderBundleEncoder(
{
colorFormats: [
'bgra8unorm',
'r32sint',
'rg11b10ufloat'
],
sampleCount: 247,
stencilReadOnly: true,
}
);
let renderBundle63 = renderBundleEncoder64.finish(
{
label: '\u{1fc9e}\u8602\u{1ffbb}\u61d9\u7051\u{1f93c}\u6697'
}
);
let pipeline66 = await device9.createRenderPipelineAsync(
{
label: '\ucd2e\u91f5\u{1f6c3}\u{1fb0b}\u{1f9a3}\u02af\u05a1\uc0af',
layout: pipelineLayout19,
vertex: {
module: shaderModule25,
entryPoint: 'vertex0',
buffers: [

]
},
primitive: {
topology: 'line-strip',
stripIndexFormat: 'uint16',
frontFace: 'ccw',
cullMode: 'front',
unclippedDepth: true,
},
multisample: {
count: 4,
mask: 0x41034818,
},
fragment: {
module: shaderModule25,
entryPoint: 'fragment0',
constants: {},
targets: [
undefined
],
},
depthStencil: {
format: 'depth24plus-stencil8',
depthWriteEnabled: false,
depthCompare: 'equal',
stencilFront: {
compare: 'equal',
failOp: 'decrement-clamp',
depthFailOp: 'increment-clamp',
passOp: 'decrement-wrap',
},
stencilBack: {
compare: 'equal',
failOp: 'increment-clamp',
depthFailOp: 'zero',
},
stencilReadMask: 2967,
depthBias: 28,
depthBiasSlopeScale: 5,
depthBiasClamp: 62,
},
}
);
let commandEncoder72 = device11.createCommandEncoder();
let texture88 = device11.createTexture(
{
label: '\u0b61\u{1f894}\u018e\ue6d9\u02f5\u8a18',
size: [25, 4, 210],
format: 'r32uint',
usage: GPUTextureUsage.COPY_DST | GPUTextureUsage.COPY_SRC | GPUTextureUsage.STORAGE_BINDING | GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let sampler67 = device11.createSampler(
{
label: '\u{1f601}\u4a65\u{1fb34}\u6e0f\u0316',
addressModeU: 'repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
lodMinClamp: 24.888,
lodMaxClamp: 53.418,
compare: 'equal',
}
);
let querySet59 = device4.createQuerySet({
label: '\u0739\u95a5\u8769\u{1fc5f}\u0973\u90e6',
type: 'occlusion',
count: 749,
});
let sampler68 = device4.createSampler(
{
label: '\udd5e\u0ed1\u67d0\ufccf',
addressModeU: 'mirror-repeat',
addressModeV: 'mirror-repeat',
addressModeW: 'repeat',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 30.853,
maxAnisotropy: 19,
}
);
try {
gpuCanvasContext15.unconfigure();
} catch {}
try {
if (!arrayBuffer6.detached) { new Uint8Array(arrayBuffer6).fill(0x55) };
} catch {}
let bindGroupLayout38 = device5.createBindGroupLayout(
{
label: '\uf52c\ubcad\u090c',
entries: [
{
binding: 7,
visibility: GPUShaderStage.COMPUTE,
storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d' },
},
{
binding: 369,
visibility: GPUShaderStage.FRAGMENT,
storageTexture: { format: 'r32sint', access: 'read-write', viewDimension: '2d-array' },
},
{
binding: 490,
visibility: GPUShaderStage.COMPUTE | GPUShaderStage.FRAGMENT,
sampler: { type: 'non-filtering' },
}
],
}
);
let commandEncoder73 = device5.createCommandEncoder(
{
}
);
let sampler69 = device5.createSampler(
{
label: '\u8fc1\u{1fc54}\u2871',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'nearest',
minFilter: 'nearest',
lodMinClamp: 20.027,
lodMaxClamp: 84.279,
}
);
let promise25 = device5.popErrorScope();
try {
device5.queue.writeTexture(
{
  texture: texture71,
  mipLevel: 0,
  origin: { x: 1384, y: 0, z: 0 },
  aspect: 'all',
},
arrayBuffer0,
/* required buffer size: 566 */{
offset: 566,
rowsPerImage: 205,
},
{width: 1681, height: 1, depthOrArrayLayers: 0}
);
} catch {}
let textureView60 = texture73.createView(
{
dimension: '2d-array',
baseMipLevel: 0,
}
);
let renderBundle64 = renderBundleEncoder55.finish(
{
label: '\u94b2\u09cc\u0594\u0c47\u3357\u{1fce5}\u8ad1'
}
);
try {
await device4.queue.onSubmittedWorkDone();
} catch {}
let querySet60 = device10.createQuerySet({
label: '\u6999\u{1f915}',
type: 'occlusion',
count: 1678,
});
let querySet61 = device6.createQuerySet({
label: '\u{1f7f2}\u00fe\uac85\uc70e',
type: 'occlusion',
count: 3538,
});
pseudoSubmit(device6, commandEncoder41);
let texture89 = device6.createTexture(
{
label: '\ud967\u233a\u{1fd98}',
size: [8028, 232, 1],
mipLevelCount: 6,
format: 'etc2-rgb8a1unorm-srgb',
usage: GPUTextureUsage.TEXTURE_BINDING,
viewFormats: [

],
}
);
let computePassEncoder34 = commandEncoder64.beginComputePass(
{
label: '\u{1fab6}\ud419\u1c42\u05ef'
}
);
let renderBundleEncoder68 = device6.createRenderBundleEncoder(
{
label: '\u0ca5\u{1f6a4}\u0e6d\u0d2d\u49fd\u2f2c\u00c3\u02ac\u045a\u0b40',
colorFormats: [
'rgba8sint',
'rgba8unorm'
],
depthStencilFormat: 'depth24plus-stencil8',
sampleCount: 783,
depthReadOnly: true,
stencilReadOnly: true,
}
);
try {
await adapter1.requestAdapterInfo();
} catch {}
try {
adapter9.label = '\u0be5\u{1fad6}\u3763\u3307\u0531\u4cfa';
} catch {}
let buffer32 = device11.createBuffer(
{
label: '\u{1fb39}\u9963\u{1fced}\u0add\u8c2f\u{1ff89}\ud317\ue2ab\u{1ffc8}\u98bb\u8af9',
size: 13420,
usage: GPUBufferUsage.COPY_SRC | GPUBufferUsage.MAP_WRITE,
mappedAtCreation: true,
}
);
let sampler70 = device11.createSampler(
{
label: '\u06c4\u0e1c\ua6c3\u02aa',
addressModeU: 'mirror-repeat',
addressModeV: 'repeat',
addressModeW: 'clamp-to-edge',
magFilter: 'linear',
minFilter: 'linear',
mipmapFilter: 'linear',
lodMinClamp: 37.227,
lodMaxClamp: 58.255,
compare: 'less-equal',
maxAnisotropy: 12,
}
);
try {
buffer32.unmap();
} catch {}
let offscreenCanvas31 = new OffscreenCanvas(713, 90);
let videoFrame20 = new VideoFrame(video4, {timestamp: 0});
let commandEncoder74 = device4.createCommandEncoder(
{
label: '\u3b4a\u9e4d\u6987\u3a96\uddf2\u0164\u02eb',
}
);
let renderBundleEncoder69 = device4.createRenderBundleEncoder(
{
colorFormats: [
'bgra8unorm',
'rg16sint',
'rgba16sint',
'rgba8sint',
'rg16sint',
undefined
],
sampleCount: 684,
depthReadOnly: true,
stencilReadOnly: true,
}
);
let renderBundle65 = renderBundleEncoder34.finish(
{
label: '\u{1f6a9}\u0b93\u50c0\u0e32\u{1fc50}\u{1f8a1}\u{1fe97}\u75ff'
}
);
try {
commandEncoder50.copyTextureToTexture(
{
  texture: texture67,
  mipLevel: 0,
  origin: { x: 0, y: 84, z: 1 },
  aspect: 'all',
},
{
  texture: texture85,
  mipLevel: 8,
  origin: { x: 0, y: 0, z: 1 },
  aspect: 'all',
},
{width: 0, height: 0, depthOrArrayLayers: 0}
);
} catch {}
try {
device4.queue.copyExternalImageToTexture(
/*
{width: 1, height: 1, depthOrArrayLayers: 1}
*/
{
  source: canvas15,
  origin: { x: 77, y: 55 },
  flipY: false,
},
{
  texture: texture73,
  mipLevel: 0,
  origin: { x: 0, y: 0, z: 0 },
  aspect: 'all',
  colorSpace: 'display-p3',
  premultipliedAlpha: false,
},
{width: 0, height: 0, depthOrArrayLayers: 0}
);
} catch {}
let gpuCanvasContext26 = offscreenCanvas31.getContext('webgpu');
try {
if (!arrayBuffer5.detached) { new Uint8Array(arrayBuffer5).fill(0x55) };
} catch {}
let renderBundle66 = renderBundleEncoder60.finish(
{
label: '\u57f9\ua253'
}
);
try {
renderPassEncoder13.setVertexBuffer(
13,
undefined,
2968159170,
701314660
);
} catch {}
let promise26 = device1.popErrorScope();
try {
device1.addEventListener('uncapturederror', e => { log('device1.uncapturederror'); log(e); e.label = device1.label; });
} catch {}
try {
device1.queue.submit([
]);
} catch {}
let pipeline67 = await device1.createRenderPipelineAsync(
{
label: '\u4767\u629b\u3a75\ubcaa\u0126\u09b1',
layout: pipelineLayout15,
vertex: {
module: shaderModule18,
entryPoint: 'vertex0',
buffers: [
{
arrayStride: 916,
stepMode: 'vertex',
attributes: [
{
format: 'snorm8x4',
offset: 892,
shaderLocation: 13,
},
{
format: 'sint16x4',
offset: 536,
shaderLocation: 1,
},
{
format: 'sint32x3',
offset: 744,
shaderLocation: 10,
},
{
format: 'unorm16x4',
offset: 404,
shaderLocation: 3,
},
{
format: 'sint16x4',
offset: 160,
shaderLocation: 0,
}
],
},
{
arrayStride: 580,
stepMode: 'instance',
attributes: [
{
format: 'float32x4',
offset: 304,
shaderLocation: 6,
},
{
format: 'sint16x4',
offset: 492,
shaderLocation: 11,
}
],
},
{
arrayStride: 4620,
stepMode: 'instance',
attributes: [
{
format: 'uint16x2',
offset: 164,
shaderLocation: 5,
},
{
format: 'uint8x4',
offset: 336,
shaderLocation: 2,
},
{
format: 'sint32x4',
offset: 3484,
shaderLocation: 17,
},
{
format: 'unorm10-10-10-2',
offset: 1452,
shaderLocation: 9,
},
{
format: 'unorm16x4',
offset: 2588,
shaderLocation: 12,
},
{
format: 'float16x2',
offset: 1580,
shaderLocation: 7,
},
{
format: 'snorm8x2',
offset: 3304,
shaderLocation: 14,
},
{
format: 'sint32',
offset: 1764,
shaderLocation: 18,
},
{
format: 'sint32x4',
offset: 3512,
shaderLocation: 16,
},
{
format: 'float32x2',
offset: 1936,
shaderLocation: 19,
},
{
format: 'unorm16x2',
offset: 1420,
shaderLocation: 4,
},
{
format: 'sint8x4',
offset: 444,
shaderLocation: 8,
},
{
format: 'sint32x3',
offset: 2556,
shaderLocation: 15,
}
],
}
]
},
fragment: {
module: shaderModule18,
entryPoint: 'fragment0',
constants: {},
targets: [
{
format: 'rg32uint',
writeMask: GPUColorWrite.RED,
},
{
format: 'r16float',
writeMask: GPUColorWrite.GREEN | GPUColorWrite.RED,
}
],
},
}
);
let offscreenCanvas32 = new OffscreenCanvas(117, 933);
let shaderModule26 = device1.createShaderModule(
{
label: '\u09df\u9792\uc302\u239e\u0b56',
code: `@group(1) @binding(6961)
var<storage, read_write> function30: array<u32>;
@group(1) @binding(5460)
var<storage, read_write> global29: 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>) {}



@fragment
fn fragment0() -> @location(2) vec3<i32> {
return vec3<i32>();
}

struct S26 {
@location(4) f0: vec4<f32>,
@builtin(vertex_index) f1: u32,
@location(2) f2: vec2<f32>,
@location(17) f3: vec4<u32>,
@location(9) f4: vec2<f32>,
@location(18) f5: vec4<i32>,
@location(8) f6: vec3<i32>
}

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

`,
sourceMap: {},
hints: {},
}
);
let querySet62 = device1.createQuerySet({
label: '\u0761\u0568\ued15',
type: 'occlusion',
count: 1269,
});
try {
renderBundleEncoder31.setVertexBuffer(
55,
undefined,
194918748,
921861089
);
} catch {}
try {
texture52.destroy();
} catch {}
try {
device1.queue.submit([
]);
} catch {}
try {
device1.queue.writeBuffer(
buffer27,
2692,
new Float32Array(31425),
25913,
108
);
} catch {}
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();
  log('the end')
  } 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);
      
    }
  }
  globalThis.testRunner?.notifyDone();
};
</script>