rayzee 11.9.0 → 11.11.0

package/dist/SolarLimb-ZYl-Pwl0.js

@@ -0,0 +1,821 @@
+import { i as e, r as t } from "./Logger-dDDGj9Av.js";
+import { l as n } from "./BufferLayout-BROyMqO1.js";
+import { ContextNode as r, StorageInstancedBufferAttribute as i, WebGPUBackend as a } from "three/webgpu";
+import { Fn as o, If as s, bool as c, clamp as l, context as u, dot as d, exp2 as f, float as p, floatBitsToUint as m, floor as h, int as g, log2 as _, mat3 as v, max as y, packSnorm2x16 as b, packUnorm2x16 as x, select as S, storage as C, struct as ee, uint as w, uintBitsToFloat as T, unpackSnorm2x16 as te, unpackUnorm2x16 as E, uvec2 as ne, uvec4 as D, vec2 as O, vec3 as k, vec4 as A, wgslFn as j } from "three/tsl";
+//#region src/TSL/patches.js
+var re = a.prototype.createNodeBuilder;
+a.prototype.createNodeBuilder = function(e, t) {
+	let n = re.call(this, e, t);
+	return Object.defineProperty(n, "allowGlobalVariables", {
+		get() {
+			return this.material !== null;
+		},
+		set() {},
+		configurable: !0
+	}), n;
+};
+function M(e, t, n = Float32Array) {
+	let r = new i(new n(0), t);
+	return r.count = e, r.gpuByteLength = e * t * n.BYTES_PER_ELEMENT, r.isGPUOnly = !0, r;
+}
+var N = a.prototype.createStorageAttribute;
+a.prototype.createStorageAttribute = function(e) {
+	let t = this.attributeUtils._getBufferAttribute(e);
+	if (!t.isGPUOnly) return N.call(this, e);
+	let n = this.get(t);
+	n.buffer === void 0 && (n.buffer = this.device.createBuffer({
+		label: t.name,
+		size: t.gpuByteLength,
+		usage: GPUBufferUsage.STORAGE | GPUBufferUsage.VERTEX | GPUBufferUsage.COPY_SRC | GPUBufferUsage.COPY_DST
+	}));
+};
+var P = class {
+	constructor(e, t, n, r = Float32Array, i = 4) {
+		this.LaneType = r, this.itemSize = i, this.lanesPerPart = Math.max(1, Math.floor(n / (t * r.BYTES_PER_ELEMENT))) * t, this.totalLanes = e, this.attrs = [];
+		for (let n = 0; n < e || this.attrs.length === 0; n += this.lanesPerPart) {
+			let a = Math.max(t, Math.min(this.lanesPerPart, e - n));
+			this.attrs.push(M(a / i, i, r));
+		}
+	}
+	get elementsPerPart() {
+		return this.lanesPerPart / this.itemSize;
+	}
+	create(e) {
+		for (let t of this.attrs) e.createStorageAttribute(t);
+	}
+	write(e, t, n, r, i) {
+		let a = this.LaneType.BYTES_PER_ELEMENT;
+		for (; i > 0;) {
+			let o = Math.floor(t / this.lanesPerPart), s = t - o * this.lanesPerPart, c = Math.min(i, this.lanesPerPart - s), l = this.attrs[o];
+			e.createStorageAttribute(l), e.device.queue.writeBuffer(e.get(l).buffer, s * a, n, r, c), t += c, r += c, i -= c;
+		}
+	}
+	writeRecords(e, t, n, r) {
+		let i = t.recordsPerChunk * t.lanesPerRecord;
+		for (let a = n, o = n + r; a < o;) {
+			let n = Math.floor(a / i), r = t.chunks[n];
+			if (!r) throw Error(`chunk ${n} is on disk and was never uploaded`);
+			let s = a - n * i, c = Math.min(r.length - s, o - a);
+			this.write(e, a, r, s, c), a += c;
+		}
+	}
+}, F = a.prototype.updateAttribute;
+a.prototype.updateAttribute = function(e) {
+	if (!this.attributeUtils._getBufferAttribute(e).isGPUOnly) return F.call(this, e);
+};
+var I = 4096;
+function L(e) {
+	if (!this.trackTimestamp || this.isDisposed || this.currentQueryIndex + 2 > this.maxQueries) return null;
+	let t = this.currentQueryIndex;
+	return this.currentQueryIndex += 2, this.queryOffsets.set(e, t), t;
+}
+var ie = a.prototype.initTimestampQuery;
+a.prototype.initTimestampQuery = function(e, t, n) {
+	let r = this.trackTimestamp && !this.timestampQueryPool[e];
+	if (ie.call(this, e, t, n), r) {
+		let r = this.timestampQueryPool[e];
+		if (r && r.maxQueries < I && n.timestampWrites) {
+			let i = r.constructor, a = new i(this.device, e, I);
+			a.allocateQueriesForContext = L, a.allocateQueriesForContext(t), this.timestampQueryPool[e] = a, n.timestampWrites.querySet = a.querySet, r.dispose();
+		}
+	}
+	let i = n.timestampWrites;
+	i && i.beginningOfPassWriteIndex == null && (n.timestampWrites = void 0);
+};
+function ae(e, t) {
+	return new Proxy(e, { get(e, n, r) {
+		if (typeof n == "string" && t.has(n)) return e.get(n);
+		let i = Reflect.get(e, n, r);
+		return n === "toVar" && typeof i == "function" ? (...n) => ae(i.apply(e, n), t) : i;
+	} });
+}
+function R(e, t = null) {
+	let n = ee(e, t), r = new Set(Object.keys(e)), i = (...e) => ae(n(...e), r);
+	return i.layout = n.layout, i.isStruct = !0, i.wrap = (e) => ae(e, r), i;
+}
+r.prototype.setup = function(e) {
+	let t = e.addContext(this.value);
+	this.node.build(e), e.setContext(t);
+};
+//#endregion
+//#region src/TSL/SceneResources.js
+var z = "rayzeeScene", oe = (e, t) => u(e, { [z]: t });
+function se(e) {
+	let t = e.context[z];
+	if (!t) throw Error("this kernel samples scene resources: build its root with withSceneResources()");
+	return t;
+}
+var ce = Object.freeze([
+	"clearcoat",
+	"sheen",
+	"iridescence",
+	"anisotropy",
+	"subsurface",
+	"dispersion",
+	"diffuseTransmission",
+	"diffuseRoughness"
+]), le = Object.freeze(Object.fromEntries(ce.map((e) => [e, !0])));
+function ue(e) {
+	return e.context[z]?.materialLayers ?? le;
+}
+function de(e) {
+	return e.context[z]?.lightRadius ?? !0;
+}
+function fe(e) {
+	return e.context[z]?.transmissionMaps ?? !0;
+}
+function B(e) {
+	return e.context[z]?.clearcoatNormals ?? !0;
+}
+//#endregion
+//#region src/TSL/Struct.js
+var pe = R({
+	origin: "vec3",
+	direction: "vec3"
+}), V = R({
+	color: "vec4",
+	emissive: "vec3",
+	emissiveIntensity: "float",
+	roughness: "float",
+	metalness: "float",
+	ior: "float",
+	transmission: "float",
+	thickness: "float",
+	clearcoat: "float",
+	clearcoatRoughness: "float",
+	clearcoatNormalMapIndex: "int",
+	clearcoatNormalScale: "float",
+	clearcoatNormal: "vec3",
+	opacity: "float",
+	transparent: "bool",
+	attenuationColor: "vec3",
+	attenuationDistance: "float",
+	dispersion: "float",
+	sheen: "float",
+	sheenRoughness: "float",
+	sheenColor: "vec3",
+	specularIntensity: "float",
+	specularColor: "vec3",
+	alphaTest: "float",
+	alphaMode: "int",
+	side: "int",
+	depthWrite: "int",
+	albedoMapIndex: "int",
+	emissiveMapIndex: "int",
+	normalMapIndex: "int",
+	bumpMapIndex: "int",
+	bumpScale: "float",
+	displacementScale: "float",
+	displacementBias: "float",
+	metalnessMapIndex: "int",
+	roughnessMapIndex: "int",
+	displacementMapIndex: "int",
+	normalScale: "vec2",
+	albedoTransform: "mat3",
+	emissiveTransform: "mat3",
+	normalTransform: "mat3",
+	bumpTransform: "mat3",
+	metalnessTransform: "mat3",
+	roughnessTransform: "mat3",
+	displacementTransform: "mat3",
+	iridescence: "float",
+	iridescenceIOR: "float",
+	iridescenceThicknessRange: "vec2",
+	subsurface: "float",
+	subsurfaceColor: "vec3",
+	subsurfaceRadius: "vec3",
+	subsurfaceRadiusScale: "float",
+	subsurfaceAnisotropy: "float",
+	anisotropy: "float",
+	anisotropyRotation: "float",
+	anisotropyMapIndex: "int",
+	transmissionMapIndex: "int",
+	clearcoatMapIndex: "int",
+	clearcoatRoughnessMapIndex: "int",
+	sheenColorMapIndex: "int",
+	sheenRoughnessMapIndex: "int",
+	iridescenceMapIndex: "int",
+	iridescenceThicknessMapIndex: "int",
+	specularIntensityMapIndex: "int",
+	specularColorMapIndex: "int",
+	diffuseTransmission: "float",
+	diffuseTransmissionColor: "vec3",
+	diffuseTransmissionMapIndex: "int",
+	diffuseTransmissionColorMapIndex: "int",
+	diffuseRoughness: "float"
+}), me = R({
+	transmission: "float",
+	clearcoat: "float",
+	clearcoatRoughness: "float",
+	sheenColor: "vec3",
+	sheenRoughness: "float",
+	iridescence: "float",
+	iridescenceThickness: "float",
+	specularIntensity: "float",
+	specularColor: "vec3",
+	diffuseTransmission: "float",
+	diffuseTransmissionColor: "vec3"
+}), he = R({
+	color: "vec4",
+	ior: "float",
+	transmission: "float",
+	attenuationColor: "vec3",
+	attenuationDistance: "float",
+	albedoMapIndex: "int",
+	opacity: "float",
+	transparent: "bool",
+	alphaTest: "float",
+	alphaMode: "int",
+	albedoTransform: "mat3"
+}), ge = R({
+	shadowed: "vec3",
+	unoccluded: "vec3"
+});
+R({
+	position: "vec3",
+	radius: "float",
+	material: V
+});
+var _e = R({
+	didHit: "bool",
+	dst: "float",
+	hitPoint: "vec3",
+	normal: "vec3",
+	uv: "vec2",
+	materialIndex: "int",
+	meshIndex: "int",
+	instanceLeaf: "int",
+	triangleIndex: "int",
+	boxTests: "int",
+	triTests: "int"
+});
+R({
+	posA: "vec3",
+	posB: "vec3",
+	posC: "vec3",
+	uvA: "vec2",
+	uvB: "vec2",
+	uvC: "vec2",
+	normalA: "vec3",
+	normalB: "vec3",
+	normalC: "vec3",
+	material: V,
+	materialIndex: "int",
+	meshIndex: "int"
+}), R({
+	color: "vec4",
+	samples: "int"
+});
+var ve = R({
+	direction: "vec3",
+	value: "vec3",
+	pdf: "float",
+	isTransmission: "bool",
+	colorWeight: "vec3",
+	isDiffuseTransmission: "bool"
+}), ye = R({
+	specular: "float",
+	diffuse: "float",
+	sheen: "float",
+	clearcoat: "float",
+	transmission: "float",
+	iridescence: "float",
+	diffuseTransmission: "float"
+}), be = R({
+	Ta: "vec3",
+	Ba: "vec3"
+}), xe = R({
+	NoL: "float",
+	NoV: "float",
+	NoH: "float",
+	VoH: "float",
+	LoH: "float",
+	ToH: "float",
+	BoH: "float",
+	ToV: "float",
+	BoV: "float",
+	ToL: "float",
+	BoL: "float",
+	coatNoL: "float",
+	coatNoV: "float",
+	coatNoH: "float"
+}), Se = R({
+	compensation: "vec3",
+	E_total: "vec3"
+}), Ce = R({
+	f0: "vec3",
+	f90: "float",
+	eta: "float",
+	F0m: "vec3",
+	F0: "vec3"
+}), we = R({
+	albedo: "vec4",
+	emissive: "vec3",
+	metalness: "float",
+	roughness: "float",
+	normal: "vec3",
+	hasTextures: "bool"
+}), Te = R({
+	isMetallic: "bool",
+	isRough: "bool",
+	isSmooth: "bool",
+	isTransmissive: "bool",
+	hasClearcoat: "bool",
+	isEmissive: "bool",
+	complexityScore: "float"
+}), Ee = R({
+	albedoUV: "vec2",
+	normalUV: "vec2",
+	metalnessUV: "vec2",
+	emissiveUV: "vec2",
+	bumpUV: "vec2",
+	roughnessUV: "vec2",
+	normalBumpSameUV: "bool",
+	metalRoughSameUV: "bool",
+	albedoEmissiveSameUV: "bool",
+	allSameUV: "bool"
+}), De = R({
+	invRoughness: "float",
+	metalFactor: "float",
+	iorFactor: "float",
+	maxSheenColor: "float"
+});
+R({
+	traversals: "int",
+	transmissiveTraversals: "int",
+	rayType: "int",
+	isPrimaryRay: "bool",
+	actualBounceDepth: "int"
+});
+//#endregion
+//#region src/TSL/Common.js
+var Oe = /* @__PURE__ */ j("\n	fn offsetRayOrigin( p: vec3f, n: vec3f ) -> vec3f {\n		let step = select( vec3<i32>( 32 ), vec3<i32>( -32 ), ( p < vec3f( 0.0 ) ) != ( n < vec3f( 0.0 ) ) );\n		let far = bitcast<vec3f>( bitcast<vec3<i32>>( p ) + step );\n		return select( far, p + n * 1e-5, abs( p ) < vec3f( 1.0 ) );\n	}\n"), ke = .9999, Ae = 3.14159, je = 1 / Ae, Me = 2 * Ae, Ne = 1e-6, Pe = .05, Fe = .089, Ie = .001, Le = k(.2126, .7152, .0722), Re = 65504, H = (e, t = 1e7) => S(e.equal(e), e, p(0)).clamp(0, t), ze = (e, t = 1e7) => k(H(e.x, t), H(e.y, t), H(e.z, t)), U = n.SLOTS_PER_MATERIAL, Be = n.SLOT, W = Be, Ve = v(3.2404542, -.969266, .0556434, -1.5371385, 1.8760108, -.2040259, -.4985314, .041556, 1.0572252);
+j("\n	fn sRGBToLinear( srgbColor: vec3f ) -> vec3f {\n\n		return pow( srgbColor, vec3f( 2.2 ) );\n\n	}\n"), j("\n	fn gammaCorrection( color: vec3f ) -> vec3f {\n\n		return pow( color, vec3f( 1.0 / 2.2 ) );\n\n	}\n");
+var He = j("\n	fn square( x: f32 ) -> f32 {\n\n		return x * x;\n\n	}\n");
+j("\n	fn squareVec3( x: vec3f ) -> vec3f {\n\n		return x * x;\n\n	}\n"), j("\n	fn maxComponent( v: vec3f ) -> f32 {\n\n		return max( max( v.r, v.g ), v.b );\n\n	}\n"), j("\n	fn minComponent( v: vec3f ) -> f32 {\n\n		return min( min( v.r, v.g ), v.b );\n\n	}\n");
+var Ue = j("\n	fn luminance( color: vec3f ) -> f32 {\n\n		return dot( color, vec3f( 0.2126, 0.7152, 0.0722 ) );\n\n	}\n"), We = j(`
+	fn powerHeuristic( pdf1: f32, pdf2: f32 ) -> f32 {
+
+		let p1 = pdf1 * pdf1;
+		let p2 = pdf2 * pdf2;
+		return p1 / max( p1 + p2, ${Ie} );
+
+	}
+`), Ge = j(`
+	fn balanceHeuristic( pdf1: f32, pdf2: f32 ) -> f32 {
+
+		return pdf1 / max( pdf1 + pdf2, ${Ie} );
+
+	}
+`);
+j("\n	fn applyDithering( color: vec3f, uv: vec2f, ditheringAmount: f32, resolution: vec2f ) -> vec3f {\n\n		let bayerRow0 = vec4f( 0.0 / 16.0, 8.0 / 16.0, 2.0 / 16.0, 10.0 / 16.0 );\n		let bayerRow1 = vec4f( 12.0 / 16.0, 4.0 / 16.0, 14.0 / 16.0, 6.0 / 16.0 );\n		let bayerRow2 = vec4f( 3.0 / 16.0, 11.0 / 16.0, 1.0 / 16.0, 9.0 / 16.0 );\n		let bayerRow3 = vec4f( 15.0 / 16.0, 7.0 / 16.0, 13.0 / 16.0, 5.0 / 16.0 );\n		let bayer = mat4x4f( bayerRow0, bayerRow1, bayerRow2, bayerRow3 );\n\n		let pixelCoord = vec2i( uv * resolution );\n		let dither = bayer[ pixelCoord.x % 4 ][ pixelCoord.y % 4 ];\n\n		return color + ( dither - 0.5 ) * ditheringAmount / 255.0;\n\n	}\n");
+var Ke = j("\n	fn constructTBN( N: vec3f ) -> mat3x3f {\n\n		var majorAxis: vec3f;\n		if ( abs( N.x ) < 0.999 ) {\n			majorAxis = vec3f( 1.0, 0.0, 0.0 );\n		} else {\n			majorAxis = vec3f( 0.0, 1.0, 0.0 );\n		}\n		let T = normalize( cross( N, majorAxis ) );\n		let B = normalize( cross( N, T ) );\n		return mat3x3f( T, B, N );\n\n	}\n"), qe = (e, t, n) => {
+	if (!B(n)) return e;
+	let r = t.clearcoatNormal;
+	return S(d(r, r).equal(0), e, S(d(e, r).lessThan(0), r.negate(), r));
+}, Je = o(([e, t]) => {
+	let n = e.x.abs().lessThan(.999).select(k(1, 0, 0), k(0, 1, 0)), r = e.cross(n).normalize(), i = e.cross(r).normalize(), a = t.cos(), o = t.sin();
+	return be({
+		Ta: r.mul(a).add(i.mul(o)),
+		Ba: i.mul(a).sub(r.mul(o))
+	});
+}), Ye = o(([e, t, n, r], i) => {
+	let a = t.add(n).toVar(), o = d(a, a).toVar();
+	a.assign(o.greaterThan(Ne).select(a.div(o.sqrt()), k(0, 0, 1)));
+	let c = p(0).toVar(), l = p(0).toVar(), u = p(0).toVar(), f = p(0).toVar(), m = p(0).toVar(), h = p(0).toVar();
+	s(r.anisotropy.greaterThan(0), () => {
+		let i = be.wrap(Je(e, r.anisotropyRotation));
+		c.assign(d(i.Ta, a)), l.assign(d(i.Ba, a)), u.assign(d(i.Ta, t)), f.assign(d(i.Ba, t)), m.assign(d(i.Ta, n)), h.assign(d(i.Ba, n));
+	});
+	let g = y(d(e, n), .001), _ = y(d(e, t), .001), v = y(d(e, a), .001), b = {
+		coatNoL: g,
+		coatNoV: _,
+		coatNoH: v
+	};
+	if (B(i)) {
+		let o = qe(e, r, i).toVar();
+		b = {
+			coatNoL: y(d(o, n), .001),
+			coatNoV: y(d(o, t), .001),
+			coatNoH: y(d(o, a), .001)
+		};
+	}
+	return xe({
+		NoL: g,
+		NoV: _,
+		NoH: v,
+		VoH: y(d(t, a), .001),
+		LoH: y(d(n, a), .001),
+		ToH: c,
+		BoH: l,
+		ToV: u,
+		BoV: f,
+		ToL: m,
+		BoL: h,
+		...b
+	});
+}), Xe = j("\n	fn calculateFireflyThreshold( baseThreshold: f32, bounceIndex: i32, frame: i32 ) -> f32 {\n\n		let depthFactor = 1.0 / ( 1.0 + f32( bounceIndex ) * 0.1 );\n		let relaxation = sqrt( f32( frame + 1 ) );\n		return baseThreshold * depthFactor * relaxation;\n\n	}\n"), Ze = j("\n	fn applySoftSuppression( value: f32, threshold: f32, dampingFactor: f32 ) -> f32 {\n\n		if ( value <= threshold ) {\n			return value;\n		}\n		let excess = value - threshold;\n		let suppressionFactor = threshold / ( threshold + excess * dampingFactor );\n		return value * suppressionFactor;\n\n	}\n"), Qe = j(`
+	fn applySoftSuppressionRGB( color: vec3f, threshold: f32, dampingFactor: f32 ) -> vec3f {
+
+		let lum = dot( color, vec3f( 0.2126, 0.7152, 0.0722 ) );
+		if ( lum <= threshold ) {
+			return color;
+		}
+		let suppressedLum = applySoftSuppression( lum, threshold, dampingFactor );
+		if ( lum > ${Ne} ) {
+			return color * ( suppressedLum / lum );
+		}
+		return color;
+
+	}
+`, [Ze]), $e = o(([e, t, n, r, i, a]) => {
+	let o = e.greaterThan(.7).toVar(), c = t.greaterThan(.8), u = t.lessThan(.3).toVar(), d = n.greaterThan(.5).toVar(), f = r.greaterThan(.5).toVar(), m = a.greaterThan(0), h = i.x.add(i.y).add(i.z).greaterThan(0).toVar(), g = p(.15).mul(p(o)).add(p(.25).mul(p(u))).add(p(.45).mul(p(d))).add(p(.35).mul(p(f))).add(p(.3).mul(p(h))).add(p(.4).mul(p(m))), _ = p(0).toVar();
+	return s(o.and(u), () => {
+		_.addAssign(.15);
+	}), s(d.and(f), () => {
+		_.addAssign(.2);
+	}), s(h.and(d.or(o)), () => {
+		_.addAssign(.1);
+	}), Te({
+		isMetallic: o,
+		isRough: c,
+		isSmooth: u,
+		isTransmissive: d,
+		hasClearcoat: f,
+		isEmissive: h,
+		complexityScore: l(g.add(_), 0, 1)
+	});
+});
+function et(e, t, n) {
+	return e.length === 1 ? e[0] : {
+		isSplitStorage: !0,
+		parts: e,
+		perPart: t,
+		type: n,
+		value: e[0].value
+	};
+}
+function tt(e, t, n) {
+	let { parts: r, perPart: i } = e, a = g(t).toVar(), o = n.map(() => ({
+		uvec4: D,
+		uvec2: ne
+	}[e.type] ?? A)(0).toVar()), c = (e) => () => {
+		let t = e === 0 ? a : a.sub(g(i * e));
+		n.forEach((n, i) => o[i].assign(r[e].element(n === 0 ? t : t.add(g(n)))));
+	}, l = s(a.lessThan(g(i)), c(0));
+	for (let e = 1; e < r.length - 1; e++) l = l.ElseIf(a.lessThan(g(i * (e + 1))), c(e));
+	return l.Else(c(r.length - 1)), o;
+}
+function nt(e, t) {
+	return e.isSplitStorage ? tt(e, t, [0])[0] : e.element(t);
+}
+var G = (e) => e?.isNode ? e : g(e), K = (e, t, n, r) => nt(e, G(r).mul(G(t)).add(G(n))), rt = (e, t, n) => {
+	if (n < 3) return K(e.geo, t, g(n), g(3));
+	if (!e.withoutUV) return K(e.shade, t, g(n - 3), g(2));
+	if (n === 3) return D(0);
+	let r = nt(e.shade, G(t));
+	return D(0, 0, r.x, r.y);
+}, q = /* @__PURE__ */ j("\n	fn packNormalOct( n: vec3f ) -> u32 {\n\n		let s = abs( n.x ) + abs( n.y ) + abs( n.z );\n		var p = n.xy / max( s, 1e-20 );\n\n		if ( n.z < 0.0 ) {\n\n			let px = ( 1.0 - abs( p.y ) ) * select( -1.0, 1.0, p.x >= 0.0 );\n			let py = ( 1.0 - abs( p.x ) ) * select( -1.0, 1.0, p.y >= 0.0 );\n			p = vec2f( px, py );\n\n		}\n\n		return pack2x16snorm( p );\n\n	}\n"), J = /* @__PURE__ */ j("\n	fn unpackTriangleNormal( packed: u32 ) -> vec3f {\n\n		let e = unpack2x16snorm( packed );\n		var nx = e.x;\n		var ny = e.y;\n		let nz = 1.0 - abs( e.x ) - abs( e.y );\n\n		if ( nz < 0.0 ) {\n\n			let tx = ( 1.0 - abs( ny ) ) * select( -1.0, 1.0, nx >= 0.0 );\n			let ty = ( 1.0 - abs( nx ) ) * select( -1.0, 1.0, ny >= 0.0 );\n			nx = tx;\n			ny = ty;\n\n		}\n\n		return normalize( vec3f( nx, ny, nz ) );\n\n	}\n"), Y = j("\n	fn arrayToMat3( data1: vec4f, data2: vec4f ) -> mat3x3f {\n\n		return mat3x3f(\n			data1.xyz,\n			vec3f( data1.w, data2.xy ),\n			vec3f( data2.zw, 1.0 )\n		);\n\n	}\n"), it = o(([e, t], n) => {
+	let r = K(t, e, g(W.COLOR_METALNESS), g(U)).toVar(), i = K(t, e, g(W.EMISSIVE_ROUGHNESS), g(U)).toVar(), a = K(t, e, g(W.IOR_TRANSMISSION), g(U)).toVar(), o = K(t, e, g(W.ATTENUATION), g(U)).toVar(), c = K(t, e, g(W.DISPERSION_SHEEN), g(U)).toVar(), l = K(t, e, g(W.SHEEN_COLOR), g(U)).toVar(), u = K(t, e, g(W.SPECULAR), g(U)).toVar(), d = K(t, e, g(W.IRIDESCENCE), g(U)).toVar(), f = K(t, e, g(W.MAP_INDICES_A), g(U)).toVar(), p = K(t, e, g(W.MAP_INDICES_B), g(U)).toVar(), m = K(t, e, g(W.OPACITY_ALPHA), g(U)).toVar(), h = K(t, e, g(W.ALPHA_MODE), g(U)).toVar(), _ = K(t, e, g(W.BUMP_DISPLACEMENT), g(U)).toVar(), v = K(t, e, g(W.ALBEDO_TRANSFORM_A), g(U)).toVar(), y = K(t, e, g(W.ALBEDO_TRANSFORM_B), g(U)).toVar(), b = K(t, e, g(W.NORMAL_TRANSFORM_A), g(U)).toVar(), x = K(t, e, g(W.NORMAL_TRANSFORM_B), g(U)).toVar(), S = K(t, e, g(W.ROUGHNESS_TRANSFORM_A), g(U)).toVar(), C = K(t, e, g(W.ROUGHNESS_TRANSFORM_B), g(U)).toVar(), ee = K(t, e, g(W.METALNESS_TRANSFORM_A), g(U)).toVar(), w = K(t, e, g(W.METALNESS_TRANSFORM_B), g(U)).toVar(), T = K(t, e, g(W.EMISSIVE_TRANSFORM_A), g(U)).toVar(), te = K(t, e, g(W.EMISSIVE_TRANSFORM_B), g(U)).toVar(), E = K(t, e, g(W.BUMP_TRANSFORM_A), g(U)).toVar(), ne = K(t, e, g(W.BUMP_TRANSFORM_B), g(U)).toVar(), D = K(t, e, g(W.DISPLACEMENT_TRANSFORM_A), g(U)).toVar(), j = K(t, e, g(W.DISPLACEMENT_TRANSFORM_B), g(U)).toVar(), re = K(t, e, g(W.SUBSURFACE_A), g(U)).toVar(), M = K(t, e, g(W.SUBSURFACE_B), g(U)).toVar(), N = K(t, e, g(W.SUBSURFACE_C), g(U)).toVar(), P = K(t, e, g(W.EXT_MAP_INDICES_A), g(U)).toVar(), F = K(t, e, g(W.EXT_MAP_INDICES_B), g(U)).toVar(), I = K(t, e, g(W.EXT_MAP_INDICES_C), g(U)).toVar(), L = A(-1, -1, -1, 1).toVar(), ie = l.a.greaterThan(0);
+	return s(B(n) ? ie.or(p.b.greaterThan(0)) : ie, () => {
+		L.assign(K(t, e, g(W.EXT_MAP_INDICES_D), g(U)));
+	}), V({
+		color: A(r.rgb, 1),
+		metalness: r.a,
+		emissive: i.rgb,
+		roughness: i.a,
+		ior: a.r,
+		transmission: a.g,
+		thickness: a.b,
+		emissiveIntensity: a.a,
+		attenuationColor: o.rgb,
+		attenuationDistance: o.a,
+		dispersion: c.r,
+		sheen: c.b,
+		sheenRoughness: c.a,
+		sheenColor: l.rgb,
+		specularIntensity: u.r,
+		specularColor: u.gba,
+		iridescence: d.r,
+		iridescenceIOR: d.g,
+		iridescenceThicknessRange: d.ba,
+		subsurfaceColor: re.rgb,
+		subsurface: re.a,
+		subsurfaceRadius: M.rgb,
+		subsurfaceRadiusScale: M.a,
+		subsurfaceAnisotropy: N.r,
+		anisotropy: N.g,
+		anisotropyRotation: N.b,
+		anisotropyMapIndex: g(N.a),
+		transmissionMapIndex: g(P.r),
+		clearcoatMapIndex: g(P.g),
+		clearcoatRoughnessMapIndex: g(P.b),
+		sheenColorMapIndex: g(P.a),
+		sheenRoughnessMapIndex: g(F.r),
+		iridescenceMapIndex: g(F.g),
+		iridescenceThicknessMapIndex: g(F.b),
+		specularIntensityMapIndex: g(F.a),
+		specularColorMapIndex: g(I.r),
+		diffuseTransmission: l.a,
+		diffuseTransmissionColor: I.gba,
+		diffuseTransmissionMapIndex: g(L.r),
+		diffuseTransmissionColorMapIndex: g(L.g),
+		diffuseRoughness: c.g,
+		albedoMapIndex: g(f.r),
+		normalMapIndex: g(f.g),
+		roughnessMapIndex: g(f.b),
+		metalnessMapIndex: g(f.a),
+		emissiveMapIndex: g(p.r),
+		bumpMapIndex: g(p.g),
+		clearcoat: p.b,
+		clearcoatRoughness: p.a,
+		clearcoatNormalMapIndex: g(L.b),
+		clearcoatNormalScale: L.a,
+		clearcoatNormal: k(0),
+		opacity: m.r,
+		side: g(m.g),
+		transparent: m.b,
+		alphaTest: m.a,
+		alphaMode: g(h.r),
+		depthWrite: g(h.g),
+		normalScale: O(h.b, h.b),
+		bumpScale: _.r,
+		displacementScale: _.g,
+		displacementMapIndex: g(_.b),
+		displacementBias: _.a,
+		albedoTransform: Y({
+			data1: v,
+			data2: y
+		}),
+		normalTransform: Y({
+			data1: b,
+			data2: x
+		}),
+		roughnessTransform: Y({
+			data1: S,
+			data2: C
+		}),
+		metalnessTransform: Y({
+			data1: ee,
+			data2: w
+		}),
+		emissiveTransform: Y({
+			data1: T,
+			data2: te
+		}),
+		bumpTransform: Y({
+			data1: E,
+			data2: ne
+		}),
+		displacementTransform: Y({
+			data1: D,
+			data2: j
+		})
+	});
+}), at = o(() => {
+	let e = v(1, 0, 0, 0, 1, 0, 0, 0, 1);
+	return V({
+		color: A(1, 1, 1, 1),
+		emissive: k(0),
+		emissiveIntensity: p(0),
+		roughness: p(1),
+		metalness: p(0),
+		ior: p(1.5),
+		transmission: p(0),
+		thickness: p(0),
+		clearcoat: p(0),
+		clearcoatRoughness: p(0),
+		clearcoatNormalMapIndex: g(-1),
+		clearcoatNormalScale: p(1),
+		clearcoatNormal: k(0),
+		opacity: p(1),
+		transparent: p(0),
+		attenuationColor: k(1),
+		attenuationDistance: p(0),
+		dispersion: p(0),
+		sheen: p(0),
+		sheenRoughness: p(1),
+		sheenColor: k(0),
+		specularIntensity: p(1),
+		specularColor: k(1),
+		alphaTest: p(0),
+		alphaMode: g(0),
+		side: g(0),
+		depthWrite: g(1),
+		albedoMapIndex: g(-1),
+		emissiveMapIndex: g(-1),
+		normalMapIndex: g(-1),
+		bumpMapIndex: g(-1),
+		bumpScale: p(1),
+		displacementScale: p(0),
+		displacementBias: p(0),
+		metalnessMapIndex: g(-1),
+		roughnessMapIndex: g(-1),
+		displacementMapIndex: g(-1),
+		normalScale: O(1, 1),
+		albedoTransform: e,
+		emissiveTransform: e,
+		normalTransform: e,
+		bumpTransform: e,
+		metalnessTransform: e,
+		roughnessTransform: e,
+		displacementTransform: e,
+		iridescence: p(0),
+		iridescenceIOR: p(1.3),
+		iridescenceThicknessRange: O(100, 400),
+		subsurface: p(0),
+		subsurfaceColor: k(1),
+		subsurfaceRadius: k(1, .2, .1),
+		subsurfaceRadiusScale: p(1),
+		subsurfaceAnisotropy: p(0),
+		anisotropy: p(0),
+		anisotropyRotation: p(0),
+		anisotropyMapIndex: g(-1),
+		transmissionMapIndex: g(-1),
+		clearcoatMapIndex: g(-1),
+		clearcoatRoughnessMapIndex: g(-1),
+		sheenColorMapIndex: g(-1),
+		sheenRoughnessMapIndex: g(-1),
+		iridescenceMapIndex: g(-1),
+		iridescenceThicknessMapIndex: g(-1),
+		specularIntensityMapIndex: g(-1),
+		specularColorMapIndex: g(-1),
+		diffuseTransmission: p(0),
+		diffuseTransmissionColor: k(1),
+		diffuseTransmissionMapIndex: g(-1),
+		diffuseTransmissionColorMapIndex: g(-1),
+		diffuseRoughness: p(0)
+	});
+}), ot = o(([e, t]) => {
+	let n = K(t, e, g(W.IOR_TRANSMISSION), g(U)).toVar(), r = K(t, e, g(W.ATTENUATION), g(U)).toVar(), i = K(t, e, g(W.MAP_INDICES_A), g(U)).toVar(), a = K(t, e, g(W.OPACITY_ALPHA), g(U)).toVar(), o = K(t, e, g(W.ALPHA_MODE), g(U)).toVar(), s = K(t, e, g(W.ALBEDO_TRANSFORM_A), g(U)).toVar(), c = K(t, e, g(W.ALBEDO_TRANSFORM_B), g(U)).toVar();
+	return he({
+		color: A(1),
+		ior: n.r,
+		transmission: n.g,
+		attenuationColor: r.rgb,
+		attenuationDistance: r.a,
+		albedoMapIndex: g(i.r),
+		opacity: a.r,
+		transparent: a.b,
+		alphaTest: a.a,
+		alphaMode: g(o.r),
+		albedoTransform: Y({
+			data1: s,
+			data2: c
+		})
+	});
+}), st = (e, t) => {
+	let n = (t) => e.shiftRight(w(t)).bitAnd(w(1)).equal(w(1)), r = t ? t.equal(g(0)) : c(!0);
+	return n(26).or(n(27).and(r));
+}, ct = (e, t) => {
+	let n = e.value?.copyRecordBase;
+	return n === void 0 ? e.isSplitStorage ? tt(e, g(t).mul(4), [
+		1,
+		2,
+		3
+	]) : [
+		K(e, t, g(1), g(4)),
+		K(e, t, g(2), g(4)),
+		K(e, t, g(3), g(4))
+	] : [
+		0,
+		1,
+		2
+	].map((r) => K(e, t, g(n + r), g(3)));
+}, lt = (e, t) => k(k(e[0].x, e[1].x, e[2].x).dot(t), k(e[0].y, e[1].y, e[2].y).dot(t), k(e[0].z, e[1].z, e[2].z).dot(t)), ut = (e, t) => {
+	let n = e[0].xyz.dot(e[1].xyz.cross(e[2].xyz));
+	return lt(e, t).mul(n.sign());
+}, dt = /* @__PURE__ */ j("\n	fn instanceDirToWorld( r0: vec3f, r1: vec3f, r2: vec3f, v: vec3f ) -> vec3f {\n\n		// Rows of world-to-object; its inverse has columns cross(r1,r2), cross(r2,r0), cross(r0,r1).\n		let c0 = cross( r1, r2 );\n		let det = dot( r0, c0 );\n		// Relative: for a uniform scale s this determinant is s⁻³, so a fixed floor would call a\n		// heavily scaled-up instance singular and leave the direction untransformed.\n		let magnitude = length( r0 ) * length( r1 ) * length( r2 );\n		if ( abs( det ) <= 1e-12f * magnitude ) { return v; }\n\n		let inv = 1.0f / det;\n		return ( c0 * v.x + cross( r2, r0 ) * v.y + cross( r0, r1 ) * v.z ) * inv;\n\n	}\n"), ft = (e, t) => dt({
+	r0: e[0].xyz,
+	r1: e[1].xyz,
+	r2: e[2].xyz,
+	v: t.sub(k(e[0].w, e[1].w, e[2].w))
+}), pt = t("gpu"), X = {
+	ORIGIN_META: 0,
+	DIR_FLAGS: 1,
+	THROUGHPUT_PDF: 2,
+	RADIANCE_ALPHA: 3,
+	MEDIUM_STACK: 4,
+	MEDIUM_SIGMA_A: 5,
+	SSS_SIGMA_S: 6
+}, Z = {
+	DIST_TRI_BARY: 0,
+	NORMAL_MAT: 1,
+	RNG: 2,
+	VERTEX: 3
+}, mt = 0, ht = 0, Q = 0, $ = (e, t) => t === 0 ? e : e.add(t * mt);
+function gt(e, t) {
+	t && e?._attributes?.delete?.(t);
+}
+var _t = class {
+	constructor(e = 0, t = null, n = 0) {
+		this.capacity = 0, this.lightVertices = 0, this._renderer = t, this._attrs = {}, this.rayBuffer = null, this.hitBuffer = null, e > 0 && this.allocate(e, n);
+	}
+	allocate(t, n = 0) {
+		this.dispose(), this.capacity = t, this.lightVertices = n, mt = t, ht = t * (n > 0 ? 7 : 3), Q = ht + n * 4;
+		let r = t * 7, i = M(r, 4);
+		this._attrs.ray = i, this.rayBuffer = {
+			rw: C(i, "vec4"),
+			ro: C(i, "vec4").toReadOnly()
+		};
+		let a = Q + t * 1, o = M(a, 4, Uint32Array);
+		this._attrs.hit = o, this.hitBuffer = {
+			rw: C(o, "uvec4"),
+			ro: C(o, "uvec4").toReadOnly()
+		}, this.rayBytes = r * 16, this.hitBytes = a * 16, this.totalBytes = this.rayBytes + this.hitBytes, pt.debug(`ray pool capacity ${e.n(t)} · ${e.mb(this.totalBytes)} (rays ${e.mb(this.rayBytes)} · hits ${e.mb(this.hitBytes)})`);
+	}
+	resize(e, t = 0) {
+		return e <= this.capacity && this.capacity > 0 && t === this.lightVertices ? !1 : (this.allocate(e, t), !0);
+	}
+	dispose() {
+		gt(this._renderer, this._attrs.ray), gt(this._renderer, this._attrs.hit), this._attrs = {}, this.rayBuffer = null, this.hitBuffer = null, this.capacity = 0, this.lightVertices = 0;
+	}
+}, vt = (e, t) => e.element($(t, X.ORIGIN_META)).xyz, yt = (e, t) => e.element($(t, X.DIR_FLAGS)).xyz, bt = (e, t) => m(e.element($(t, X.DIR_FLAGS)).w), xt = (e, t) => e.element($(t, X.THROUGHPUT_PDF)).xyz, St = (e, t) => e.element($(t, X.THROUGHPUT_PDF)).w, Ct = (e, t) => e.element($(t, X.RADIANCE_ALPHA)), wt = (e) => w(e).mul(1).add(Q), Tt = (e, t, n, r, i, a = null) => {
+	let o = wt(t), s = a === null ? E(e.element(o).w).y : p(a);
+	return e.element(o).assign(D(b(O(n.x, n.y)), b(O(n.z, r)), x(O(i.x, i.y)), x(O(i.z, s))));
+}, Et = (e, t, n) => {
+	let r = wt(t), i = e.element(r).toVar();
+	return e.element(r).assign(D(i.x, i.y, i.z, x(O(E(i.w).x, n))));
+}, Dt = (e, t) => e.element(wt(t)), Ot = (e) => E(e.w).y, kt = (e) => {
+	let t = te(e.x), n = te(e.y);
+	return A(k(t.x, t.y, n.x).mul(.5).add(.5), n.y);
+}, At = (e) => k(E(e.z), E(e.w).x), jt = (e) => {
+	let t = l(h(_(y(e, 1e-6))), -8, 7), n = l(p(e).mul(f(t.negate())).sub(1).mul(64), 0, 63);
+	return S(p(e).lessThan(.004), w(0), w(t.add(8)).shiftLeft(6).bitOr(w(n)));
+}, Mt = (e, t) => {
+	let n = m(e.element($(t, X.ORIGIN_META)).w).shiftRight(22), r = p(n.shiftRight(6).bitAnd(w(15))).sub(8), i = p(n.bitAnd(w(63))).div(64).add(1);
+	return S(n.equal(w(0)), p(0), i.mul(f(r)));
+}, Nt = (e, t, n, r, i, a = w(0), o = null) => {
+	let s = w(r).bitAnd(w(255)).bitOr(w(i).bitAnd(w(255)).shiftLeft(8)).bitOr(w(a).bitAnd(w(63)).shiftLeft(16));
+	return o !== null && (s = s.bitOr(jt(o).shiftLeft(22))), e.element($(t, X.ORIGIN_META)).assign(A(n, T(s)));
+}, Pt = (e, t, n, r) => e.element($(t, X.DIR_FLAGS)).assign(A(n, T(r))), Ft = (e, t, n, r) => e.element($(t, X.THROUGHPUT_PDF)).assign(A(n, r)), It = (e, t, n) => e.element($(t, X.RADIANCE_ALPHA)).assign(n), Lt = (e, t) => T(e.element($(t, Z.DIST_TRI_BARY)).x), Rt = (e, t) => e.element($(t, Z.DIST_TRI_BARY)).y, zt = (e, t) => T(e.element($(t, Z.DIST_TRI_BARY)).zw), Bt = (e, t) => J(e.element($(t, Z.NORMAL_MAT)).x), Vt = (e, t) => w(e.element($(t, Z.NORMAL_MAT)).y), Ht = (e, t) => g(e.element($(t, Z.NORMAL_MAT)).z).sub(g(1)), Ut = (e, t) => e.element($(t, Z.NORMAL_MAT)).w, Wt = (e, t) => e.element($(t, Z.RNG)).x, Gt = (e, t, n) => e.element($(t, Z.RNG)).assign(D(n, 0, 0, 0)), Kt = (e, t) => {
+	let n = e.element($(t, Z.RNG));
+	return {
+		dVCM: T(n.y),
+		dVC: T(n.z)
+	};
+}, qt = (e, t, n, r, i) => e.element($(t, Z.RNG)).assign(D(n, m(r), m(i), w(0))), Jt = (e) => (t) => $(e, Z.VERTEX + t), Yt = (e) => (t) => w(e).mul(4).add(ht + t), Xt = (e, t, n) => {
+	e.element(t(0)).assign(D(m(n.position), n.tag)), e.element(t(1)).assign(D(m(n.throughput), q(n.V))), e.element(t(2)).assign(D(q(n.N), q(n.facetN), w(n.materialIndex).bitOr(w(n.extra).bitAnd(w(255)).shiftLeft(w(24))), m(n.uv.x))), e.element(t(3)).assign(D(m(n.uv.y), m(n.dVCM), m(n.dVC), w(0)));
+}, Zt = (e, t) => e.element(t(0)).w, Qt = (e, t) => T(e.element(t(0)).xyz), $t = (e, t) => e.element(t(3)).w, en = (e, t, n) => e.element(t(3)).w.assign(n), tn = (e, t) => {
+	let n = e.element(t(0)).toVar(), r = e.element(t(1)).toVar(), i = e.element(t(2)).toVar(), a = e.element(t(3)).toVar();
+	return {
+		position: T(n.xyz),
+		tag: n.w,
+		throughput: T(r.xyz),
+		V: J(r.w),
+		N: J(i.x),
+		facetN: J(i.y),
+		materialIndex: i.z.bitAnd(w(16777215)),
+		uv: O(T(i.w), T(a.x)),
+		dVCM: T(a.y),
+		dVC: T(a.z),
+		extra: i.z.shiftRight(w(24))
+	};
+}, nn = (e, t, n) => {
+	let r = e.element(t(0)).w;
+	return S(r.shiftRight(w(8)).equal(n), r.bitAnd(w(255)), w(0));
+}, rn = (e, t, n, r) => {
+	let i = e.element(t(0)).xyz.toVar();
+	e.element(t(0)).assign(D(i, n.shiftLeft(w(8)).bitOr(w(r))));
+}, an = (e, t, n, r, i, a) => e.element($(t, Z.VERTEX)).assign(D(w(n), w(g(r).add(g(1))), m(i), m(a))), on = (e, t) => {
+	let n = e.element($(t, Z.VERTEX)).toVar();
+	return {
+		triangle: g(n.x),
+		instanceLeaf: g(n.y).sub(g(1)),
+		cosLight: T(n.z),
+		scale: T(n.w)
+	};
+}, sn = (e, t, n, r, i, a, o, s, c, l = w(0)) => {
+	e.element($(t, Z.DIST_TRI_BARY)).assign(D(m(n), r, m(i), m(a))), e.element($(t, Z.NORMAL_MAT)).assign(D(q(o), s, c, l));
+}, cn = (e, t) => {
+	let n = e.element($(t, X.MEDIUM_STACK)), r = m(n.x);
+	return {
+		stackDepth: r.bitAnd(255),
+		transTraversals: r.shiftRight(8).bitAnd(255),
+		wavelength: r.shiftRight(16).bitAnd(65535),
+		ior1: n.y,
+		ior2: n.z,
+		ior3: n.w
+	};
+}, ln = (e, t, n, r, i, a, o, s = w(0)) => e.element($(t, X.MEDIUM_STACK)).assign(A(T(n.bitOr(r.shiftLeft(8)).bitOr(s.shiftLeft(16))), i, a, o)), un = (e, t) => e.element($(t, X.MEDIUM_SIGMA_A)).xyz, dn = (e, t, n) => {
+	let r = e.element($(t, X.MEDIUM_SIGMA_A)).w.toVar();
+	e.element($(t, X.MEDIUM_SIGMA_A)).assign(A(n, r));
+}, fn = (e) => {
+	let t = l(e, k(0), k(1)).mul(1023).add(.5);
+	return w(t.x).bitOr(w(t.y).shiftLeft(10)).bitOr(w(t.z).shiftLeft(20));
+}, pn = (e) => k(p(e.bitAnd(w(1023))), p(e.shiftRight(10).bitAnd(w(1023))), p(e.shiftRight(20).bitAnd(w(1023)))).div(1023), mn = (e, t) => pn(m(e.element($(t, X.MEDIUM_SIGMA_A)).w)), hn = (e, t, n) => {
+	let r = e.element($(t, X.MEDIUM_SIGMA_A)).xyz.toVar();
+	e.element($(t, X.MEDIUM_SIGMA_A)).assign(A(r, T(fn(n))));
+}, gn = (e, t) => g(m(e.element($(t, X.ORIGIN_META)).w).bitAnd(255)), _n = (e, t) => g(m(e.element($(t, X.ORIGIN_META)).w).shiftRight(8).bitAnd(255)), vn = (e, t) => g(m(e.element($(t, X.ORIGIN_META)).w).shiftRight(16).bitAnd(w(63))), yn = (e, t) => {
+	let n = e.element($(t, X.SSS_SIGMA_S));
+	return {
+		sigmaS: n.xyz,
+		g: n.w
+	};
+}, bn = (e, t, n, r) => e.element($(t, X.SSS_SIGMA_S)).assign(A(n, r)), xn = [
+	610,
+	550,
+	465
+].map((e) => -.023 + .292 / (e / 1e3));
+//#endregion
+export { bn as $, Te as $t, xt as A, ft as At, Tt as B, tt as Bt, Kt as C, at as Ct, vt as D, dt as Dt, yt as E, ot as Et, $t as F, H as Ft, dn as G, Ce as Gt, sn as H, J as Ht, Qt as I, ze as It, Nt as J, ve as Jt, ln as K, Se as Kt, tn as L, st as Lt, yn as M, Ue as Mt, _n as N, Oe as Nt, St as O, ut as Ot, vn as P, We as Pt, Gt as Q, De as Qt, Zt as R, et as Rt, Mt as S, Ke as St, bt as T, it as Tt, an as U, be as Ut, Et as V, rt as Vt, rn as W, ye as Wt, Ft as X, me as Xt, It as Y, xe as Yt, qt as Z, _e as Zt, Rt as _, Ge as _t, At as a, le as an, U as at, un as b, qe as bt, Jt as c, se as cn, Pe as ct, zt as d, fe as dn, Le as dt, we as en, en as et, Lt as f, oe as fn, ke as ft, Bt as g, Qe as gt, Vt as h, R as hn, Je as ht, gt as i, Ee as in, Be as it, Wt as j, ct as jt, Ct as k, lt as kt, mn as l, B as ln, Ae as lt, Ht as m, M as mn, Ve as mt, _t as n, V as nn, Ne as nt, Ot as o, ce as on, Fe as ot, Ut as p, P as pn, Me as pt, Pt as q, ge as qt, Yt as r, he as rn, Re as rt, kt as s, ue as sn, Ie as st, xn as t, pe as tn, Xt as tt, Dt as u, de as un, je as ut, on as v, Xe as vt, gn as w, K as wt, cn as x, Ye as xt, nn as y, $e as yt, hn as z, He as zt };