face-api/dist/tfjs.esm.js

  /*
  Face-API
  homepage: <https://github.com/vladmandic/face-api>
  author: <https://github.com/vladmandic>'
  */

var MB=Object.create,Lh=Object.defineProperty,LB=Object.getPrototypeOf,zB=Object.prototype.hasOwnProperty,BB=Object.getOwnPropertyNames,VB=Object.getOwnPropertyDescriptor;var GB=r=>Lh(r,"__esModule",{value:!0});var Br=(r,e)=>()=>(e||(e={exports:{}},r(e.exports,e)),e.exports),et=(r,e)=>{for(var t in e)Lh(r,t,{get:e[t],enumerable:!0})},WB=(r,e,t)=>{if(e&&typeof e=="object"||typeof e=="function")for(let o of BB(e))!zB.call(r,o)&&o!=="default"&&Lh(r,o,{get:()=>e[o],enumerable:!(t=VB(e,o))||t.enumerable});return r},Sc=r=>r&&r.__esModule?r:WB(GB(Lh(r!=null?MB(LB(r)):{},"default",{value:r,enumerable:!0})),r);var tN=Br(()=>{});var FN=Br((RN,S_)=>{(function(r,e,t){function o(i){var l=this,u=a();l.next=function(){var c=2091639*l.s0+l.c*23283064365386963e-26;return l.s0=l.s1,l.s1=l.s2,l.s2=c-(l.c=c|0)},l.c=1,l.s0=u(" "),l.s1=u(" "),l.s2=u(" "),l.s0-=u(i),l.s0<0&&(l.s0+=1),l.s1-=u(i),l.s1<0&&(l.s1+=1),l.s2-=u(i),l.s2<0&&(l.s2+=1),u=null}function n(i,l){return l.c=i.c,l.s0=i.s0,l.s1=i.s1,l.s2=i.s2,l}function s(i,l){var u=new o(i),c=l&&l.state,p=u.next;return p.int32=function(){return u.next()*4294967296|0},p.double=function(){return p()+(p()*2097152|0)*11102230246251565e-32},p.quick=p,c&&(typeof c=="object"&&n(c,u),p.state=function(){return n(u,{})}),p}function a(){var i=4022871197,l=function(u){u=u.toString();for(var c=0;c<u.length;c++){i+=u.charCodeAt(c);var p=.02519603282416938*i;i=p>>>0,p-=i,p*=i,i=p>>>0,p-=i,i+=p*4294967296}return(i>>>0)*23283064365386963e-26};return l}e&&e.exports?e.exports=s:t&&t.amd?t(function(){return s}):this.alea=s})(RN,typeof S_=="object"&&S_,typeof define=="function"&&define)});var PN=Br((ON,T_)=>{(function(r,e,t){function o(a){var i=this,l="";i.x=0,i.y=0,i.z=0,i.w=0,i.next=function(){var c=i.x^i.x<<11;return i.x=i.y,i.y=i.z,i.z=i.w,i.w^=i.w>>>19^c^c>>>8},a===(a|0)?i.x=a:l+=a;for(var u=0;u<l.length+64;u++)i.x^=l.charCodeAt(u)|0,i.next()}function n(a,i){return i.x=a.x,i.y=a.y,i.z=a.z,i.w=a.w,i}function s(a,i){var l=new o(a),u=i&&i.state,c=function(){return(l.next()>>>0)/4294967296};return c.double=function(){do var p=l.next()>>>11,m=(l.next()>>>0)/4294967296,f=(p+m)/(1<<21);while(f===0);return f},c.int32=l.next,c.quick=c,u&&(typeof u=="object"&&n(u,l),c.state=function(){return n(l,{})}),c}e&&e.exports?e.exports=s:t&&t.amd?t(function(){return s}):this.xor128=s})(ON,typeof T_=="object"&&T_,typeof define=="function"&&define)});var LN=Br((MN,E_)=>{(function(r,e,t){function o(a){var i=this,l="";i.next=function(){var c=i.x^i.x>>>2;return i.x=i.y,i.y=i.z,i.z=i.w,i.w=i.v,(i.d=i.d+362437|0)+(i.v=i.v^i.v<<4^(c^c<<1))|0},i.x=0,i.y=0,i.z=0,i.w=0,i.v=0,a===(a|0)?i.x=a:l+=a;for(var u=0;u<l.length+64;u++)i.x^=l.charCodeAt(u)|0,u==l.length&&(i.d=i.x<<10^i.x>>>4),i.next()}function n(a,i){return i.x=a.x,i.y=a.y,i.z=a.z,i.w=a.w,i.v=a.v,i.d=a.d,i}function s(a,i){var l=new o(a),u=i&&i.state,c=function(){return(l.next()>>>0)/4294967296};return c.double=function(){do var p=l.next()>>>11,m=(l.next()>>>0)/4294967296,f=(p+m)/(1<<21);while(f===0);return f},c.int32=l.next,c.quick=c,u&&(typeof u=="object"&&n(u,l),c.state=function(){return n(l,{})}),c}e&&e.exports?e.exports=s:t&&t.amd?t(function(){return s}):this.xorwow=s})(MN,typeof E_=="object"&&E_,typeof define=="function"&&define)});var BN=Br((zN,A_)=>{(function(r,e,t){function o(a){var i=this;i.next=function(){var u=i.x,c=i.i,p,m,f;return p=u[c],p^=p>>>7,m=p^p<<24,p=u[c+1&7],m^=p^p>>>10,p=u[c+3&7],m^=p^p>>>3,p=u[c+4&7],m^=p^p<<7,p=u[c+7&7],p=p^p<<13,m^=p^p<<9,u[c]=m,i.i=c+1&7,m};function l(u,c){var p,m,f=[];if(c===(c|0))m=f[0]=c;else for(c=""+c,p=0;p<c.length;++p)f[p&7]=f[p&7]<<15^c.charCodeAt(p)+f[p+1&7]<<13;for(;f.length<8;)f.push(0);for(p=0;p<8&&f[p]===0;++p);for(p==8?m=f[7]=-1:m=f[p],u.x=f,u.i=0,p=256;p>0;--p)u.next()}l(i,a)}function n(a,i){return i.x=a.x.slice(),i.i=a.i,i}function s(a,i){a==null&&(a=+new Date);var l=new o(a),u=i&&i.state,c=function(){return(l.next()>>>0)/4294967296};return c.double=function(){do var p=l.next()>>>11,m=(l.next()>>>0)/4294967296,f=(p+m)/(1<<21);while(f===0);return f},c.int32=l.next,c.quick=c,u&&(u.x&&n(u,l),c.state=function(){return n(l,{})}),
`)),l.join(`
`)}function b3(r,e,t,o){let n=ft(e),s=o[o.length-1],a=new Array(s).fill(0),i=e.length,l=t==="complex64"?_m(r):r;if(i>1)for(let u=0;u<n/s;u++){let c=u*s;for(let p=0;p<s;p++)a[p]=Math.max(a[p],bm(l[c+p],0,t).length)}return a}function bm(r,e,t){let o;return Array.isArray(r)?o=`${parseFloat(r[0].toFixed(Cb))} + ${parseFloat(r[1].toFixed(Cb))}j`:ns(r)?o=`'${r}'`:t==="bool"?o=TI(r):o=parseFloat(r.toFixed(Cb)).toString(),zl(o,e)}function TI(r){return r===0?"false":"true"}function Gh(r,e,t,o,n,s=!0){let a=t==="complex64"?2:1,i=e[0],l=e.length;if(l===0){if(t==="complex64"){let h=_m(r);return[bm(h[0],0,t)]}return t==="bool"?[TI(r[0])]:[r[0].toString()]}if(l===1){if(i>NI){let g=ym*a,x=Array.from(r.slice(0,g)),b=Array.from(r.slice((i-ym)*a,i*a));return t==="complex64"&&(x=_m(x),b=_m(b)),["["+x.map((_,w)=>bm(_,n[w],t)).join(", ")+", ..., "+b.map((_,w)=>bm(_,n[i-ym+w],t)).join(", ")+"]"]}let h=t==="complex64"?_m(r):Array.from(r);return["["+h.map((g,x)=>bm(g,n[x],t)).join(", ")+"]"]}let u=e.slice(1),c=o.slice(1),p=o[0]*a,m=[];if(i>NI){for(let h=0;h<ym;h++){let g=h*p,x=g+p;m.push(...Gh(r.slice(g,x),u,t,c,n,!1))}m.push("...");for(let h=i-ym;h<i;h++){let g=h*p,x=g+p;m.push(...Gh(r.slice(g,x),u,t,c,n,h===i-1))}}else for(let h=0;h<i;h++){let g=h*p,x=g+p;m.push(...Gh(r.slice(g,x),u,t,c,n,h===i-1))}let f=l===2?",":"";m[0]="["+m[0]+f;for(let h=1;h<m.length-1;h++)m[h]=" "+m[h]+f;let d=`,
`;for(let h=2;h<l;h++)d+=`
`;return m[m.length-1]=" "+m[m.length-1]+"]"+(s?"":d),m}function _m(r){let e=[];for(let t=0;t<r.length;t+=2)e.push([r[t],r[t+1]]);return e}var ct=class{constructor(e,t,o){if(this.dtype=t,this.shape=e.slice(),this.size=ft(e),o!=null){let n=o.length;T(n===this.size,()=>`Length of values '${n}' does not match the size inferred by the shape '${this.size}'.`)}if(t==="complex64")throw new Error("complex64 dtype TensorBuffers are not supported. Please create a TensorBuffer for the real and imaginary parts separately and call tf.complex(real, imag).");this.values=o||pb(t,this.size),this.strides=Hs(e)}set(e,...t){t.length===0&&(t=[0]),T(t.length===this.rank,()=>`The number of provided coordinates (${t.length}) must match the rank (${this.rank})`);let o=this.locToIndex(t);this.values[o]=e}get(...e){e.length===0&&(e=[0]);let t=0;for(let n of e){if(n<0||n>=this.shape[t]){let s=`Requested out of range element at ${e}.   Buffer shape=${this.shape}`;throw new Error(s)}t++}let o=e[e.length-1];for(let n=0;n<e.length-1;++n)o+=this.strides[n]*e[n];return this.values[o]}locToIndex(e){if(this.rank===0)return 0;if(this.rank===1)return e[0];let t=e[e.length-1];for(let o=0;o<e.length-1;++o)t+=this.strides[o]*e[o];return t}indexToLoc(e){if(this.rank===0)return[];if(this.rank===1)return[e];let t=new Array(this.shape.length);for(let o=0;o<t.length-1;++o)t[o]=Math.floor(e/this.strides[o]),e-=t[o]*this.strides[o];return t[t.length-1]=e,t}get rank(){return this.shape.length}toTensor(){return Fi().makeTensor(this.values,this.shape,this.dtype)}},Fi=null,zc=null,_3=null;function EI(r){Fi=r}function AI(r){zc=r}function DI(r){_3=r}var Ve=class{constructor(e,t,o,n){this.kept=!1,this.isDisposedInternal=!1,this.shape=e.slice(),this.dtype=t||"float32",this.size=ft(e),this.strides=Hs(e),this.dataId=o,this.id=n,this.rankType=this.rank<5?this.rank.toString():"higher"}get rank(){return this.shape.length}async buffer(){let e=await this.data();return zc.buffer(this.shape,this.dtype,e)}bufferSync(){return zc.buffer(this.shape,this.dtype,this.dataSync())}async array(){let e=await this.data();return Bl(this.shape,e)}arraySync(){return Bl(this.shape,this.dataSync())}async data(){this.throwIfDisposed();let e=Fi().read(this.dataId);if(this.dtype==="string"){let t=await e;try{return t.map(o=>Lc(o))}catch(o){throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().")}}return e}dataSync(){this.throwIfDisposed();let e=Fi().readSync(this.dataId);if(this.dtype==="string")try{return e.map(t=>Lc(t))}catch(t){throw new Error("Failed to decode the string bytes into utf-8. To get the original bytes, call tensor.bytes().")}return e}async bytes(){this.throwIfDisposed();let e=await Fi().read(this.dataId);return this.dtype==="string"?e:new Uint8Array(e.buffer)}dispose(){this.isDisposed||(Fi().disposeTensor(this),this.isDisposedInternal=!0)}get isDisposed(){return this.isDisposedInternal}throwIfDisposed(){if(this.isDisposed)throw new Error("Tensor is disposed.")}print(e=!1){return zc.print(this,e)}clone(){return this.throwIfDisposed(),zc.clone(this)}toString(e=!1){let t=this.dataSync();return SI(t,this.shape,this.dtype,e)}cast(e){return this.throwIfDisposed(),zc.cast(this,e)}variable(e=!0,t,o){return this.throwIfDisposed(),Fi().makeVariable(this,e,t,o)}};Object.defineProperty(Ve,Symbol.hasInstance,{value:r=>!!r&&r.data!=null&&r.dataSync!=null&&r.throwIfDisposed!=null});function F(){return hm("Tensor",()=>Ve)}F();var tl=class extends Ve{constructor(e,t,o,n){super(e.shape,e.dtype,e.dataId,n);this.trainable=t,this.name=o}assign(e){if(e.dtype!==this.dtype)throw new Error(`dtype of the new value (${e.dtype}) and previous value (${this.dtype}) must match`);if(!Vr(e.shape,this.shape))throw new Error(`shape of the new value (${e.shape}) and previous value (${this.shape}) must match`);Fi().disposeTensor(this),this.dataId=e.dataId,Fi().incRef(this,null)}dispose(){Fi().disposeVariable(this),this.isDisposedInternal=!0}};Object.defineProperty(tl,Symbol.hasInstance,{value:r=>r instanceof Ve&&r.assign!=null&&r.assign instanceof Function});var Fn={}
Manifest JSON has weights with names: ${i.join(", ")}.`)}let l=n.reduce((f,d,h)=>(d&&f.push(h),f),[]),u=[];l.forEach(f=>{e[f].paths.forEach(d=>{let h=t+(t.endsWith("/")?"":"/")+d;u.push(h)})});let c=await r(u),p={},m=0;return l.forEach(f=>{let d=e[f].paths.length,h=0;for(let w=0;w<d;w++)h+=c[m+w].byteLength;let g=new ArrayBuffer(h),x=new Uint8Array(g),b=0;for(let w=0;w<d;w++){let v=new Uint8Array(c[m+w]);x.set(v,b),b+=v.byteLength}s[f].forEach(w=>{let v=g.slice(w.groupOffset,w.groupOffset+w.sizeBytes),$=Uh(v,[w.manifestEntry]);for(let A in $)p[A]=$[A]}),m+=d}),p}}var J3="application/octet-stream",Q3="application/json",Hh=class{constructor(e,t){if(this.DEFAULT_METHOD="POST",t==null&&(t={}),this.weightPathPrefix=t.weightPathPrefix,this.onProgress=t.onProgress,this.weightUrlConverter=t.weightUrlConverter,t.fetchFunc!=null?(T(typeof t.fetchFunc=="function",()=>"Must pass a function that matches the signature of `fetch` (see https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API)"),this.fetch=t.fetchFunc):this.fetch=G().platform.fetch,T(e!=null&&e.length>0,()=>"URL path for http must not be null, undefined or empty."),Array.isArray(e)&&T(e.length===2,()=>`URL paths for http must have a length of 2, (actual length is ${e.length}).`),this.path=e,t.requestInit!=null&&t.requestInit.body!=null)throw new Error("requestInit is expected to have no pre-existing body, but has one.");this.requestInit=t.requestInit||{}}async save(e){if(e.modelTopology instanceof ArrayBuffer)throw new Error("BrowserHTTPRequest.save() does not support saving model topology in binary formats yet.");let t=Object.assign({method:this.DEFAULT_METHOD},this.requestInit);t.body=new FormData;let o=[{paths:["./model.weights.bin"],weights:e.weightSpecs}],n={modelTopology:e.modelTopology,format:e.format,generatedBy:e.generatedBy,convertedBy:e.convertedBy,weightsManifest:o};e.signature!=null&&(n.signature=e.signature),e.userDefinedMetadata!=null&&(n.userDefinedMetadata=e.userDefinedMetadata),e.modelInitializer!=null&&(n.modelInitializer=e.modelInitializer),t.body.append("model.json",new Blob([JSON.stringify(n)],{type:Q3}),"model.json"),e.weightData!=null&&t.body.append("model.weights.bin",new Blob([e.weightData],{type:J3}),"model.weights.bin");let s=await this.fetch(this.path,t);if(s.ok)return{modelArtifactsInfo:Pi(e),responses:[s]};throw new Error(`BrowserHTTPRequest.save() failed due to HTTP response status ${s.status}.`)}async load(){let e=await this.fetch(this.path,this.requestInit);if(!e.ok)throw new Error(`Request to ${this.path} failed with status code ${e.status}. Please verify this URL points to the model JSON of the model to load.`);let t;try{t=await e.json()}catch(d){let h=`Failed to parse model JSON of response from ${this.path}.`;throw this.path.endsWith(".pb")?h+=" Your path contains a .pb file extension. Support for .pb models have been removed in TensorFlow.js 1.0 in favor of .json models. You can re-convert your Python TensorFlow model using the TensorFlow.js 1.0 conversion scripts or you can convert your.pb models with the 'pb2json'NPM script in the tensorflow/tfjs-converter repository.":h+=" Please make sure the server is serving valid JSON for this request.",new Error(h)}let o=t.modelTopology,n=t.weightsManifest,s=t.generatedBy,a=t.convertedBy,i=t.format,l=t.signature,u=t.userDefinedMetadata;if(o==null&&n==null)throw new Error(`The JSON from HTTP path ${this.path} contains neither model topology or manifest for weights.`);let c,p;n!=null&&([c,p]=await this.loadWeights(n));let m={modelTopology:o,weightSpecs:c,weightData:p,generatedBy:s,convertedBy:a,format:i};l!=null&&(m.signature=l),u!=null&&(m.userDefinedMetadata=u);let f=t.modelInitializer;return f&&(m.modelInitializer=f),m}async loadWeights(e){let t=Array.isArray(this.path)?this.path[1]:this.path,[o,n]=eV(t),s=this.weightPathPrefix||o,a=[];for(let c of e)a.push(...c.weights);let i=[],l=[];for(let c of e)for(let p of c.paths)this.weightUrlConverter!=null?l.push(this.weightUrlConverter(p)):i.push(s+p+n);this.weightUrlConverter&&i.push(...await Promise.all(l));let u=await jb(i,{requestInit:this
Actual:   ${n}.
Expected: ${s}.`);for(let a=0;a<s.length;++a){let i=n[a],l=s[a];if(!t(i,l))throw new Error(`Arrays differ: actual[${a}] = ${i}, expected[${a}] = ${l}.
Actual:   ${n}.
Expected: ${s}.`)}}function hV(r,e){r().then(()=>e.fail(),()=>e())}function gV(r,e){let t=typeof e=="string"||typeof e=="number"||typeof e=="boolean"?[e]:e;return ns(r)||ns(r[0])||ns(e)||ns(e[0])?Zb(r,t,(o,n)=>o==n):Zb(r,e,(o,n)=>Jb(o,n,0))}function xV(r,e,t){if(t==null&&(t=Yb()),!Jb(r,e,t))throw new Error(`Numbers differ: actual === ${r}, expected === ${e}`)}function Jb(r,e,t){return!isFinite(r)&&!isFinite(e)?!0:!(isNaN(r)||isNaN(e)||Math.abs(r-e)>t)}function yV(r,e,t){for(let o=0;o<r.length;o++)if(r[o]<e||r[o]>t)throw new Error(`Value out of range:${r[o]} low: ${e}, high: ${t}`)}function bV(r,e){expect(new Float32Array(r)).toEqual(new Float32Array(e))}function SN(r){for(let e=0;e<r.length;e++){let t=r[e];Array.isArray(t)?SN(t):r[e]=el(t)}return r}var Qb="3.0.0";function _V(){G().set("PROD",!0)}function wV(){G().set("DEBUG",!0)}function kV(){G().set("DEPRECATION_WARNINGS_ENABLED",!1),console.warn("TensorFlow.js deprecation warnings have been disabled.")}function rg(r){G().getBool("DEPRECATION_WARNINGS_ENABLED")&&console.warn(r+" You can disable deprecation warnings with tf.disableDeprecationWarnings().")}DI(rg);function vV(){E.disposeVariables()}function vs(){return E}function jc(){return E.memory()}function CV(r){return E.profile(r)}function V(r,e){return E.tidy(r,e)}function Te(r){wm(r).forEach(t=>t.dispose())}function At(r){return E.keep(r)}function IV(r){return E.time(r)}function TN(r){return E.setBackend(r)}function NV(){return E.ready()}function SV(){return E.backendName}function TV(r){E.removeBackend(r)}function EV(r){return E.findBackend(r)}function AV(r){return E.findBackendFactory(r)}function yu(r,e,t=1){return E.registerBackend(r,e,t)}function e_(){return E.backend}function DV(r,e){G().setPlatform(r,e)}function $V(r,e){let t=k(r,"a","add"),o=k(e,"b","add");[t,o]=Ge(t,o);let n={a:t,b:o};return E.runKernel(xo,n)}var Q=S({add_:$V});function RV(r,e){let t=k(r,"a","floorDiv"),o=k(e,"b","floorDiv");[t,o]=Ge(t,o);let n={a:t,b:o};return E.runKernel(rn,n)}var bu=S({floorDiv_:RV});function FV(r,e){let t=k(r,"a","div"),o=k(e,"b","div");if([t,o]=Ge(t,o),t.dtype==="int32"&&o.dtype==="int32")return bu(t,o);let n={a:t,b:o},s={};return E.runKernel(Qo,n,s)}var de=S({div_:FV});function OV(r,e){let t=k(r,"a","mul"),o=k(e,"b","mul");[t,o]=Ge(t,o);let n={a:t,b:o};return E.runKernel(dn,n)}var O=S({mul_:OV});function PV(r){let e=k(r,"x","abs");if(e.dtype==="complex64"){let t={x:e};return E.runKernel(ia,t)}else{let t={x:e};return E.runKernel(ss,t)}}var Tt=S({abs_:PV});function MV(r){let t={x:k(r,"x","acos")};return E.runKernel(qs,t)}var vm=S({acos_:MV});function LV(r){let t={x:k(r,"x","acosh")};return E.runKernel(Ks,t)}var Cm=S({acosh_:LV});function zV(r){T(Array.isArray(r),()=>"The argument passed to tf.addN() must be a list of tensors"),T(r.length>=1,()=>`Must pass at least one tensor to tf.addN(), but got ${r.length}`);let e=r.map((n,s)=>k(n,`tensors${s}`,"addN")),t=e[0];e.forEach(n=>{if(n.dtype!==t.dtype)throw new Error("All tensors passed to tf.addN() must have the same dtype")}),e.forEach(n=>{if(!Vr(n.shape,t.shape))throw new Error("All tensors passed to tf.addN() must have the same shape")});let o=e;return E.runKernel(Uo,o)}var t_=S({addN_:zV});function BV(r,e=null,t=!1){let n={x:k(r,"x","all","bool")},s={axis:e,keepDims:t};return E.runKernel(Vl,n,s)}var _u=S({all_:BV});function VV(r,e=null,t=!1){let n={x:k(r,"x","any","bool")},s={axis:e,keepDims:t};return E.runKernel(Gl,n,s)}var nl=S({any_:VV});function GV(r,e=0){let o={x:k(r,"x","argMax")},n={axis:e};return E.runKernel(jo,o,n)}var sl=S({argMax_:GV});function WV(r,e=0){let o={x:k(r,"x","argMin")},n={axis:e};return E.runKernel(oa,o,n)}var Im=S({argMin_:WV});function UV(r){let t={x:k(r,"x","asin")};return E.runKernel(Xs,t)}var Nm=S({asin_:UV});function jV(r){let t={x:k(r,"x","asinh")};return E.runKernel(Ys,t)}var Sm=S({asinh_:jV});function HV(r){let t={x:k(r,"x","atan")};return E.runKernel(Zs,t)}var Tm=S({atan_:HV});function qV(r,e){let t=k(r,"a","atan2"),o=k(e,"b","atan2");[t,o]=Ge(t,o);let n={a:t,b:o};return E.runKernel(Qs,n)}var Em=S({atan2_:qV});function KV(r){let t={x:k(
          with dtype ${s.dtype}. `)}),t.length===1)return $o(t[0]);let o=t,n={axis:e};return E.runKernel(is,o,n)}var Je=S({concat_:nG});function sG(r){let t={x:k(r,"x","sigmoid")};return E.runKernel(Nn,t)}var Ur=S({sigmoid_:sG});function iG(r,e,t){let o=k(r,"x","slice","string_or_numeric");if(o.rank===0)throw new Error("Slicing scalar is not possible");let n={x:o},s={begin:e,size:t};return E.runKernel(hs,n,s)}var Fe=S({slice_:iG});function aG(r){let t={x:k(r,"x","tanh")};return E.runKernel($n,t)}var Mi=S({tanh_:aG});function lG(r,e,t,o,n,s){let a=k(r,"forgetBias","basicLSTMCell"),i=k(e,"lstmKernel","basicLSTMCell"),l=k(t,"lstmBias","basicLSTMCell"),u=k(o,"data","basicLSTMCell"),c=k(n,"c","basicLSTMCell"),p=k(s,"h","basicLSTMCell"),m=Je([u,p],1),f=We(m,i),d=Q(f,l),h=d.shape[0],g=d.shape[1]/4,x=[h,g],b=Fe(d,[0,0],x),_=Fe(d,[0,g],x),w=Fe(d,[0,g*2],x),v=Fe(d,[0,g*3],x),$=Q(O(Ur(b),Mi(_)),O(c,Ur(Q(a,w)))),A=O(Mi($),Ur(v));return[$,A]}var uG=S({basicLSTMCell_:lG});function cG(r,e,t){let o=k(r,"x","batchToSpaceND"),n=e.reduce((i,l)=>i*l);T(o.rank>=1+e.length,()=>`input rank is ${o.rank} but should be > than blockShape.length ${e.length}`),T(t.length===e.length,()=>`crops.length is ${t.length} but should be equal to blockShape.length  ${e.length}`),T(o.shape[0]%n==0,()=>`input tensor batch is ${o.shape[0]} but is not divisible by the product of the elements of blockShape ${e.join(" * ")} === ${n}`);let s={x:o},a={blockShape:e,crops:t};return E.runKernel(sa,s,a)}var Ca=S({batchToSpaceND_:cG});function DN(r){let e;return r.rank===0||r.rank===1?e=L(r,[1,1,1,r.size]):r.rank===2?e=L(r,[1,1,r.shape[0],r.shape[1]]):r.rank===3?e=L(r,[1,r.shape[0],r.shape[1],r.shape[2]]):e=r,e}function pG(r,e,t,o,n,s){s==null&&(s=.001);let a=k(r,"x","batchNorm"),i=k(e,"mean","batchNorm"),l=k(t,"variance","batchNorm"),u;n!=null&&(u=k(n,"scale","batchNorm"));let c;o!=null&&(c=k(o,"offset","batchNorm")),T(i.rank===l.rank,()=>"Batch normalization gradient requires mean and variance to have equal ranks."),T(c==null||i.rank===c.rank,()=>"Batch normalization gradient requires mean and offset to have equal ranks."),T(u==null||i.rank===u.rank,()=>"Batch normalization gradient requires mean and scale to have equal ranks.");let m={x:DN(a),scale:u,offset:c,mean:i,variance:l},f={varianceEpsilon:s},d=E.runKernel(on,m,f);return L(d,a.shape)}var On=S({batchNorm_:pG});function mG(r,e,t,o,n,s){let a=k(r,"x","batchNorm"),i=k(e,"mean","batchNorm"),l=k(t,"variance","batchNorm"),u;n!=null&&(u=k(n,"scale","batchNorm"));let c;return o!=null&&(c=k(o,"offset","batchNorm")),T(a.rank===2,()=>`Error in batchNorm2D: x must be rank 2 but got rank ${a.rank}.`),T(i.rank===2||i.rank===1,()=>`Error in batchNorm2D: mean must be rank 2 or rank 1 but got rank ${i.rank}.`),T(l.rank===2||l.rank===1,()=>`Error in batchNorm2D: variance must be rank 2 or rank 1 but got rank ${l.rank}.`),u!=null&&T(u.rank===2||u.rank===1,()=>`Error in batchNorm2D: scale must be rank 2 or rank 1 but got rank ${u.rank}.`),c!=null&&T(c.rank===2||c.rank===1,()=>`Error in batchNorm2D: offset must be rank 2 or rank 1 but got rank ${c.rank}.`),On(a,i,l,c,u,s)}var s_=S({batchNorm2d_:mG});function fG(r,e,t,o,n,s){let a=k(r,"x","batchNorm"),i=k(e,"mean","batchNorm"),l=k(t,"variance","batchNorm"),u;n!=null&&(u=k(n,"scale","batchNorm"));let c;return o!=null&&(c=k(o,"offset","batchNorm")),T(a.rank===3,()=>`Error in batchNorm3D: x must be rank 3 but got rank ${a.rank}.`),T(i.rank===3||i.rank===1,()=>`Error in batchNorm3D: mean must be rank 3 or rank 1 but got rank ${i.rank}.`),T(l.rank===3||l.rank===1,()=>`Error in batchNorm3D: variance must be rank 3 or rank 1 but got rank ${l.rank}.`),u!=null&&T(u.rank===3||u.rank===1,()=>`Error in batchNorm3D: scale must be rank 3 or rank 1 but got rank ${u.rank}.`),c!=null&&T(c.rank===3||c.rank===1,()=>`Error in batchNorm3D: offset must be rank 3 or rank 1 but got rank ${c.rank}.`),On(a,i,l,c,u,s)}var i_=S({batchNorm3d_:fG});function dG(r,e,t,o,n,s){let a=k(r,"x","batchNorm"),i=k(e,"mean","batchNorm"),l=k(t,"variance","batchNorm"),u;n!=null&&(u=k(n,"scale","batchNorm"));let c;return o!=nul
    ${n} and ${e}  for depthToSpace with input shape
    ${o.shape}`),T(s*e>=0,()=>`Negative dimension size caused by overflow when multiplying
    ${s} and ${e} for depthToSpace with input shape
        ${o.shape}`),T(a%(e*e)==0,()=>`Dimension size must be evenly divisible by ${e*e} but is ${a} for depthToSpace with input shape ${o.shape}`);let i={x:o},l={blockSize:e,dataFormat:t};return E.runKernel(oi,i,l)}var Fm=S({depthToSpace_:OG});function PG(r,e,t,o,n="NHWC",s=[1,1],a){let i=k(r,"x","depthwiseConv2d"),l=k(e,"filter","depthwiseConv2d"),u=i,c=!1;i.rank===3&&(c=!0,u=L(i,[1,i.shape[0],i.shape[1],i.shape[2]])),T(u.rank===4,()=>`Error in depthwiseConv2d: input must be rank 4, but got rank ${u.rank}.`),T(l.rank===4,()=>`Error in depthwiseConv2d: filter must be rank 4, but got rank ${l.rank}.`),T(u.shape[3]===l.shape[2],()=>`Error in depthwiseConv2d: number of input channels (${u.shape[3]}) must match the inChannels dimension in filter ${l.shape[2]}.`),a!=null&&T(st(o),()=>`Error in depthwiseConv2d: pad must be an integer when using, dimRoundingMode ${a} but got pad ${o}.`);let p={x:u,filter:l},m={strides:t,pad:o,dataFormat:n,dilations:s,dimRoundingMode:a},f=E.runKernel(Jo,p,m);return c?L(f,[f.shape[1],f.shape[2],f.shape[3]]):f}var Cs=S({depthwiseConv2d_:PG});function MG(r){let t={x:k(r,"x","diag")};return E.runKernel(Ql,t)}var LG=S({diag_:MG});function zG(r,e,t,o,n=[1,1],s="NHWC"){let a=k(r,"x","dilation2d"),i=k(e,"filter","dilation2d");T(a.rank===3||a.rank===4,()=>`Error in dilation2d: input must be rank 3 or 4, but got rank ${a.rank}.`),T(i.rank===3,()=>`Error in dilation2d: filter must be rank 3, but got rank ${i.rank}.`),T(s==="NHWC",()=>`Error in dilation2d: Only NHWC is currently supported, but got dataFormat of ${s}`);let l=a,u=!1;a.rank===3&&(l=L(a,[1,a.shape[0],a.shape[1],a.shape[2]]),u=!0);let c={x:l,filter:i},p={strides:t,pad:o,dilations:n},m=E.runKernel(la,c,p);return u?L(m,[m.shape[1],m.shape[2],m.shape[3]]):m}var Om=S({dilation2d_:zG});function BG(r,e){let t=r.length,o=[];for(let n=0;n<t;n++){let s=t-1-n,a=r[s]||1;(e[e.length-1-n]||1)>1&&a===1&&o.unshift(s)}return o}function Ct(r,e){let t=[];for(let o=0;o<e.length;o++){let n=r[r.length-o-1],s=e.length-o-1,a=e[s];(n==null||n===1&&a>1)&&t.unshift(s)}return t}function ze(r,e){let t=[],o=Math.max(r.length,e.length);for(let n=0;n<o;n++){let s=r[r.length-n-1];s==null&&(s=1);let a=e[e.length-n-1];if(a==null&&(a=1),s===1)t.unshift(a);else if(a===1)t.unshift(s);else if(s!==a){let i=`Operands could not be broadcast together with shapes ${r} and ${e}.`;throw Error(i)}else t.unshift(s)}return t}function VG(r,e){let t=k(r,"a","equal"),o=k(e,"b","equal");[t,o]=Ge(t,o),ze(t.shape,o.shape);let n={a:t,b:o};return E.runKernel(ii,n)}var _o=S({equal_:VG});function GG(r,e,t){let o=k(e,"a","where"),n=k(t,"b","where"),s=k(r,"condition","where","bool"),a=ze(o.shape,n.shape),i=il(o,a),l=il(n,a);s.rank===1&&T(s.shape[0]===o.shape[0],()=>"The first dimension of `a` must match the size of `condition`."),s.rank!==1&&Nt(s.shape,l.shape,"Error in where: ");let u={condition:s,t:i,e:l};return E.runKernel(ds,u)}var Dt=S({where_:GG});function WG(r){let t={x:k(r,"x","zerosLike")};return E.runKernel(ys,t)}var Ie=S({zerosLike_:WG});function UG(r,e){let t=k(r,"a","div"),o=k(e,"b","div");[t,o]=Ge(t,o);let n=de(t,o),s=Ie(n),a=_o(o,s);return Dt(a,s,n)}var Pm=S({divNoNan_:UG});function jG(r,e){let t=k(r,"t1","dot"),o=k(e,"t2","dot");T((t.rank===1||t.rank===2)&&(o.rank===1||o.rank===2),()=>`Error in dot: inputs must all be rank 1 or 2, but got ranks ${t.rank} and ${o.rank}.`);let n=t.rank===1?t.size:t.shape[1],s=o.rank===1?o.size:o.shape[0];if(T(n===s,()=>`Error in dot: inner dimensions of inputs must match, but got ${n} and ${s}.`),t.rank===1&&o.rank===1){let a=L(t,[1,-1]),i=L(o,[-1,1]),l=We(a,i);return L(l,[])}else if(t.rank===1&&o.rank===2){let a=L(t,[1,-1]),i=L(o,[o.shape[0],o.shape[1]]),l=We(a,i);return L(l,[l.size])}else if(t.rank===2&&o.rank===1){let a=L(o,[-1,1]),i=We(t,a);return L(i,[i.size])}else{let a=L(o,[o.shape[0],o.shape[1]]);return We(t,a)}}var d_=S({dot_:jG});function HG(r){let t={x:k(r,"x","elu")};return E.runKernel(ni,t)}var Is=S({elu_:HG});function qG(r){let e=k(r,"x","erf");T(e.dtype==="int32"||e.dtype==="float32",()=>"Input dtype must be `int32` or `float32`."),e.dtype=
               rank ${s.rank}.`),T(st(e),()=>`Error in localResponseNormalization: depthRadius must be an integer but got depthRadius ${e}.`);let a=s,i=!1;s.rank===3&&(i=!0,a=L(s,[1,s.shape[0],s.shape[1],s.shape[2]]));let l={x:a},u={depthRadius:e,bias:t,alpha:o,beta:n},c=E.runKernel(ca,l,u);return i?L(c,[c.shape[1],c.shape[2],c.shape[3]]):c}var zm=S({localResponseNormalization_:cW});function pW(r){let t={x:k(r,"x","log")};return E.runKernel(an,t)}var ir=S({log_:pW});function mW(r){let t={x:k(r,"x","log1p")};return E.runKernel(gi,t)}var Eu=S({log1p_:mW});function fW(r){return T(js(r),()=>"The f passed in grad(f) must be a function"),(e,t)=>{let o=k(e,"x","tf.grad","string_or_numeric"),n=t!=null?k(t,"dy","tf.grad"):null;return E.tidy(()=>{let{value:s,grads:a}=E.gradients(()=>r(o),[o],n);return n!=null&&Nt(s.shape,n.shape,"The shape of dy passed in grad(f)(x, dy) must match the shape returned by f(x)"),sg(a),a[0]})}}function dW(r){return T(js(r),()=>"The f passed in grads(f) must be a function"),(e,t)=>{T(Array.isArray(e),()=>"The args passed in grads(f)(args) must be an array of `Tensor`s or `TensorLike`s");let o=ya(e,"args","tf.grads","string_or_numeric"),n=t!=null?k(t,"dy","tf.grads"):null;return E.tidy(()=>{let{value:s,grads:a}=E.gradients(()=>r(...o),o,n);return n!=null&&Nt(s.shape,n.shape,"The shape of dy passed in grads(f)([x1,...], dy) must match the shape returned by f([x1,...])"),sg(a),a})}}function hW(r){return T(js(r),()=>"The f passed in valueAndGrad(f) must be a function"),(e,t)=>{T(e instanceof Ve,()=>"The x passed in valueAndGrad(f)(x) must be a tensor"),T(t==null||t instanceof Ve,()=>"The dy passed in valueAndGrad(f)(x, dy) must be a tensor");let{grads:o,value:n}=E.gradients(()=>r(e),[e],t);return sg(o),{grad:o[0],value:n}}}function gW(r){return T(js(r),()=>"The f passed in valueAndGrads(f) must be a function"),(e,t)=>{T(Array.isArray(e)&&e.every(n=>n instanceof Ve),()=>"The args passed in valueAndGrads(f)(args) must be array of tensors"),T(t==null||t instanceof Ve,()=>"The dy passed in valueAndGrads(f)(args, dy) must be a tensor");let o=E.gradients(()=>r(...e),e,t);return t!=null&&Nt(o.value.shape,t.shape,"The shape of dy passed in valueAndGrads(f)([x1,...], dy) must match the shape returned by f([x1,...])"),sg(o.grads),o}}function ig(r,e){T(js(r),()=>"The f passed in variableGrads(f) must be a function"),T(e==null||Array.isArray(e)&&e.every(u=>u instanceof tl),()=>"The varList passed in variableGrads(f, varList) must be an array of variables");let t=e!=null;if(!t){e=[];for(let u in E.registeredVariables)e.push(E.registeredVariables[u])}let o=t?e.filter(u=>!u.trainable):null,n=e.length;e=e.filter(u=>u.trainable),T(e.length>0,()=>`variableGrads() expects at least one of the input variables to be trainable, but none of the ${n} variables is trainable.`);let s=!0,{value:a,grads:i}=E.gradients(r,e,null,s);T(i.some(u=>u!=null),()=>"Cannot find a connection between any variable and the result of the loss function y=f(x). Please make sure the operations that use variables are inside the function f passed to minimize()."),T(a.rank===0,()=>`The f passed in variableGrads(f) must return a scalar, but it returned a rank-${a.rank} tensor`);let l={};return e.forEach((u,c)=>{i[c]!=null&&(l[u.name]=i[c])}),o!=null&&o.forEach(u=>l[u.name]=null),{value:a,grads:l}}function Hr(r){return E.customGrad(r)}function sg(r){if(r.filter(t=>t==null).length>0)throw new Error(`Cannot compute gradient of y=f(x) with respect to x. Make sure that
    the f you passed encloses all operations that lead from x to y.`)}function xW(r){let t={x:k(r,"x","neg")};return E.runKernel(cs,t)}var je=S({neg_:xW});function yW(r){let t={x:k(r,"x","softplus")};return E.runKernel(Ei,t)}var Ss=S({softplus_:yW});function bW(r){let e=k(r,"x","logSigmoid");return Hr(o=>({value:je(Ss(je(o))),gradFunc:a=>O(a,Ur(je(o)))}))(e)}var b_=S({logSigmoid_:bW});function _W(r,e=null,t=!1){let n={x:k(r,"x","max")},s={reductionIndices:e,keepDims:t};return E.runKernel(ln,n,s)}var ar=S({max_:_W});function wW(r,e){let t=k(r,"a","sub"),o=k(e,"b","sub");[t,o]=Ge(t,o);let n={a:t,b:o};return E.runKernel(Dn,n)}var ue=S({sub_:wW});function kW(r,e=null,t=!1){let o=k(r,"x","sum");o.dtype==="bool"&&(o=oe(o,"int32"));let n={x:o},s={axis:e,keepDims:t};return E.runKernel(Tn,n,s)}var ye=S({sum_:kW});function vW(r,e=-1){let t=k(r,"logits","logSoftmax");if(e===-1&&(e=t.rank-1),e!==t.rank-1)throw Error(`Log Softmax along a non-last dimension is not yet supported. Logits was rank ${t.rank} and axis was ${e}`);return Hr((n,s)=>{let a=!0,i=ar(n,e,!0),l=ue(n,i),u=ue(oe(l,"float32"),ir(ye(Xt(l),e,a)));return s([u]),{value:u,gradFunc:(p,m)=>{let[f]=m,d=!0,h=Xt(f);return ue(p,O(ye(p,e,d),h))}}})(t)}var Au=S({logSoftmax_:vW});function __(r,e){for(let t=0;t<r.length;++t)if(r[r.length-t-1]!==e-1-t)return!1;return!0}function $N(r,e,t){let o=r.length+e.length,n=[],s=0,a=0;for(let i=0;i<o;i++)t.indexOf(i)===-1?n.push(r[s++]):n.push(e[a++]);return n}function w_(r,e){let t=[],o=r.length;for(let s=0;s<o;s++)e.indexOf(s)===-1&&t.push(r[s]);let n=e.map(s=>r[s]);return[t,n]}function Mn(r,e){let t=e.map(o=>1);return $N(r,t,e)}function CW(r,e,t){T(__(e,t),()=>`${r} supports only inner-most axes for now. Got axes ${e} and rank-${t} input.`)}function k_(r,e){if(__(r,e))return null;let t=[];for(let o=0;o<e;++o)r.indexOf(o)===-1&&t.push(o);return r.forEach(o=>t.push(o)),t}function Bm(r){return r.map((e,t)=>[t,e]).sort((e,t)=>e[1]-t[1]).map(e=>e[0])}function IW(r,e){let t=[];for(let o=e-r;o<e;++o)t.push(o);return t}function NW(r,e=null,t=!1){let o=k(r,"x","logSumExp"),n=Jt(e,o.shape),s=ar(o,n,!0),a=ue(o,s),i=Xt(a),l=ye(i,n),u=ir(l),c=Q(L(s,u.shape),u);if(t){let p=Mn(c.shape,n);return L(c,p)}return c}var Vm=S({logSumExp_:NW});function SW(r,e){let t=k(r,"a","logicalAnd","bool"),o=k(e,"b","logicalAnd","bool");ze(t.shape,o.shape);let n={a:t,b:o};return E.runKernel(xi,n)}var fr=S({logicalAnd_:SW});function TW(r){let t={x:k(r,"x","logicalNot","bool")};return E.runKernel(Za,t)}var Ta=S({logicalNot_:TW});function EW(r,e){let t=k(r,"a","logicalOr","bool"),o=k(e,"b","logicalOr","bool");ze(t.shape,o.shape);let n={a:t,b:o};return E.runKernel(Ja,n)}var Du=S({logicalOr_:EW});function AW(r,e){let t=k(r,"a","logicalXor","bool"),o=k(e,"b","logicalXor","bool");return ze(t.shape,o.shape),fr(Du(r,e),Ta(fr(r,e)))}var v_=S({logicalXor_:AW});function DW(r,e,t,o,n){let s=k(r,"x","maxPool"),a=1,i=s,l=!1;s.rank===3&&(l=!0,i=L(s,[1,s.shape[0],s.shape[1],s.shape[2]])),T(i.rank===4,()=>`Error in maxPool: input must be rank 4 but got rank ${i.rank}.`),T(yr(t,a),()=>`Error in maxPool: Either strides or dilations must be 1. Got strides ${t} and dilations '${a}'`),n!=null&&T(st(o),()=>`Error in maxPool: pad must be an integer when using, dimRoundingMode ${n} but got pad ${o}.`);let u={x:i},c={filterSize:e,strides:t,pad:o,dimRoundingMode:n},p=E.runKernel(cn,u,c);return l?L(p,[p.shape[1],p.shape[2],p.shape[3]]):p}var Ea=S({maxPool_:DW});function $W(r,e=[1,1,1],t,o,n,s="NDHWC"){let a=k(r,"x","maxPool3d"),i=a,l=!1;a.rank===4&&(l=!0,i=L(a,[1,a.shape[0],a.shape[1],a.shape[2],a.shape[3]])),T(i.rank===5,()=>`Error in maxPool3d: x must be rank 5 but got rank ${i.rank}.`),T(s==="NDHWC",()=>`Error in maxPool3d: Only NDHWC is currently supported, but got dataFormat of ${s}`),n!=null&&T(st(o),()=>`Error in maxPool3d: pad must be an integer when using, dimRoundingMode ${n} but got pad ${o}.`);let u={x:i},c={filterSize:e,strides:t,pad:o,dimRoundingMode:n,dataFormat:s},p=E.runKernel(pa,u,c);return l?L(p,[p.shape[1],p.shape[2],p.shape[3],p.shape[4]]):p}var Gm=S({maxPool3d_:$W});function RW(r,
    ${s}).`);if(t<o)throw new Error(`batchDims (${o}) must be less than or equal to axis (${t}).`);for(let p=0;p<o;++p)if(r.shape[p]!==e.shape[p])throw new Error(`x.shape[${p}]: ${r.shape[p]} should be equal to indices.shape[${p}]: ${e.shape[p]}.`);let a=r.shape[t],i=[],l=1,u=1,c=1;for(let p=0;p<o;++p)i.push(r.shape[p]),l*=r.shape[p];for(let p=o;p<t;p++)i.push(r.shape[p]),u*=r.shape[p];for(let p=o;p<n;p++)i.push(e.shape[p]);for(let p=t+1;p<s;p++)i.push(r.shape[p]),c*=r.shape[p];return{batchSize:l,sliceSize:c,outerSize:u,dimSize:a,outputShape:i}}function Xj(r){try{return r.map(e=>Lc(e))}catch(e){throw new Error(`Failed to decode encoded string bytes into utf-8, error: ${e}`)}}function Yj(r){return r.map(e=>el(e))}var Sr={};et(Sr,{nonMaxSuppressionV3Impl:()=>W_,nonMaxSuppressionV4Impl:()=>U_,nonMaxSuppressionV5Impl:()=>j_,whereImpl:()=>M_});var yg={kernelName:ss,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>O(r,As(oe(t,"float32"),-1))}}};var v0={kernelName:qs,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>{let o=Pe(oe(t,"float32")),n=xt(ue(le(1),o));return je(de(r,n))}}}};var C0={kernelName:Ks,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>{let o=xt(ue(Pe(oe(t,"float32")),1));return de(r,o)}}}};var I0={kernelName:xo,inputsToSave:["a","b"],gradFunc:(r,e)=>{let[t,o]=e,n=ze(t.shape,o.shape);return{a:()=>{let i=r,l=Ct(t.shape,n);return l.length>0&&(i=ye(i,l)),L(i,t.shape)},b:()=>{let i=r,l=Ct(o.shape,n);return l.length>0&&(i=ye(i,l)),L(i,o.shape)}}}};var N0={kernelName:Uo,saveAllInputs:!0,gradFunc:(r,e)=>{let t={};return e.forEach((o,n)=>{t[n]=()=>r.clone()}),t}};var S0={kernelName:jo,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>Ie(t)}}};var T0={kernelName:oa,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>Ie(t)}}};var E0={kernelName:Xs,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>de(r,xt(ue(le(1),Pe(oe(t,"float32")))))}}};var A0={kernelName:Ys,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>{let o=xt(Q(le(1),Pe(oe(t,"float32"))));return de(r,o)}}}};var D0={kernelName:Qs,inputsToSave:["a","b"],gradFunc:(r,e)=>{let[t,o]=e,n=ze(t.shape,o.shape);return{a:()=>{let i=Q(Pe(t),Pe(o)),l=O(r,de(o,i)),u=Ct(t.shape,n);return u.length>0&&(l=ye(l,u)),L(l,t.shape)},b:()=>{let i=Q(Pe(t),Pe(o)),l=je(O(r,de(t,i))),u=Ct(o.shape,n);return u.length>0&&(l=ye(l,u)),L(l,o.shape)}}}};var $0={kernelName:Zs,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>de(r,Q(Pe(oe(t,"float32")),1))}}};var R0={kernelName:Js,inputsToSave:["x"],gradFunc:(r,e)=>{let[t]=e;return{x:()=>de(r,ue(le(1),Pe(oe(t,"float32"))))}}};function Zj(r,e,t,o,n,s){let a=k(r,"dy","avgPool3dGrad"),i=k(e,"input","avgPool3dGrad"),l=a,u=i,c=!1;i.rank===4&&(c=!0,l=L(a,[1,a.shape[0],a.shape[1],a.shape[2],a.shape[3]]),u=L(i,[1,i.shape[0],i.shape[1],i.shape[2],i.shape[3]])),T(l.rank===5,()=>`Error in avgPool3dGrad: dy must be rank 5 but got rank ${l.rank}.`),T(u.rank===5,()=>`Error in avgPool3dGrad: input must be rank 5 but got rank ${u.rank}.`),s!=null&&T(st(n),()=>`Error in avgPool3dGrad: pad must be an integer when using, dimRoundingMode ${s} but got pad ${n}.`);let p={dy:l,input:u},m={filterSize:t,strides:o,pad:n,dimRoundingMode:s},f=E.runKernel(Ul,p,m);return c?L(f,[f.shape[1],f.shape[2],f.shape[3],f.shape[4]]):f}var F0=S({avgPool3dGrad_:Zj});var O0={kernelName:na,inputsToSave:["x"],gradFunc:(r,e,t)=>{let[o]=e,{filterSize:n,strides:s,pad:a,dimRoundingMode:i}=t;return{x:()=>F0(r,o,n,s,a,i)}}};function Jj(r,e,t,o,n){let s=k(r,"dy","avgPoolGrad"),a=k(e,"input","avgPoolGrad");T(a.rank===s.rank,()=>`Rank of input (${a.rank}) does not match rank of dy (${s.rank})`);let i=a,l=s,u=!1;a.rank===3&&(u=!0,i=L(a,[1,a.shape[0],a.shape[1],a.shape[2]]),l=L(s,[1,s.shape[0],s.shape[1],s.shape[2]])),T(l.rank===4,()=>`Error in avgPoolGrad: dy must be rank 4 but got rank ${l.rank}.`),T(i.rank===4,()=>`Error in avgPoolGrad: input must be rank 4 but got rank ${i.rank}.`);let c={dy:l,input:i},p={filterSize:t,strides:o,pad:n},m=E.runKernel(Wl,c,p);return u?L(m,[m.shape[1],m.shape[2],m.shape[3]]):m}var P0=S({avgPoolGrad_:Jj});v
1. The ${o} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
2. The custom ${o} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);return a}else{let s=r;if(s.className==null||s.config==null)throw new B(`${o}: Improper config format: ${JSON.stringify(s)}.
'className' and 'config' must set.`);let a=s.className,i,l;if(a in t?[i,l]=t[a]:a in Wn?[i,l]=Wn.className:a in e&&([i,l]=e[a]),i==null)throw new B(`Unknown ${o}: ${a}. This may be due to one of the following reasons:
1. The ${o} is defined in Python, in which case it needs to be ported to TensorFlow.js or your JavaScript code.
2. The custom ${o} is defined in JavaScript, but is not registered properly with tf.serialization.registerClass().`);if(l!=null){let u={};for(let f of Object.keys(Wn))u[f]=Wn[f];for(let f of Object.keys(t))u[f]=t[f];let c=s.config;c.customObjects=u;let p=Object.assign({},Wn);for(let f of Object.keys(t))Wn[f]=t[f];rw(s.config);let m=l(i,s.config,t,n);return Wn=Object.assign({},p),m}else{let u=Object.assign({},Wn);for(let p of Object.keys(t))Wn[p]=t[p];let c=new i(s.config);return Wn=Object.assign({},u),c}}}function sH(r,e){return r<e?-1:r>e?1:0}function lf(r,e){return-1*sH(r,e)}function Un(r){if(r==null)return r;let e=[];for(let t of r)e.indexOf(t)===-1&&e.push(t);return e}function yT(r){if(r==null)throw new B(`Invalid value in obj: ${JSON.stringify(r)}`);for(let e in r)if(r.hasOwnProperty(e))return!1;return!0}function Gi(r,e,t){if(t!=null&&r.indexOf(t)<0)throw new B(`${t} is not a valid ${e}.  Valid values are ${r} or null/undefined.`)}function _g(r,e,t=0,o=Infinity){return Po(t>=0),Po(o>=t),Array.isArray(r)&&r.length>=t&&r.length<=o&&r.every(n=>typeof n===e)}function Wt(r,e){Array.isArray(r)?(y.assert(r.length>0,()=>`${e} is unexpectedly an empty array.`),r.forEach((t,o)=>Wt(t,`element ${o+1} of ${e}`))):y.assert(Number.isInteger(r)&&r>0,()=>`Expected ${e} to be a positive integer, but got ${bT(r)}.`)}function bT(r){return r===null?"null":Array.isArray(r)?"["+r.map(e=>bT(e)).join(",")+"]":typeof r=="string"?`"${r}"`:`${r}`}function _T(r,e){let t=y.now(),o;return(...s)=>{let a=y.now();return a-t<e||(t=a,o=r(...s)),o}}function wg(r){return r==="relu"?"relu":r==="linear"?"linear":r==="elu"?"elu":null}function ow(r,e){return V(()=>xt(ye(O(r,r),e,!0)))}var lp=class extends J.Serializable{getConfig(){return{}}},uf=class extends lp{constructor(e){super();this.defaultMaxValue=2,this.defaultAxis=0,this.maxValue=e.maxValue!=null?e.maxValue:this.defaultMaxValue,this.axis=e.axis!=null?e.axis:this.defaultAxis}apply(e){return V(()=>{let t=ow(e,this.axis),o=nr(t,0,this.maxValue);return O(e,de(o,Q(Yt(),t)))})}getConfig(){return{maxValue:this.maxValue,axis:this.axis}}};uf.className="MaxNorm";J.registerClass(uf);var cf=class extends lp{constructor(e){super();this.defaultAxis=0,this.axis=e.axis!=null?e.axis:this.defaultAxis}apply(e){return V(()=>de(e,Q(Yt(),ow(e,this.axis))))}getConfig(){return{axis:this.axis}}};cf.className="UnitNorm";J.registerClass(cf);var pf=class extends lp{apply(e){return Ir(e)}};pf.className="NonNeg";J.registerClass(pf);var mf=class extends lp{constructor(e){super();this.defaultMinValue=0,this.defaultMaxValue=1,this.defaultRate=1,this.defaultAxis=0,this.minValue=e.minValue!=null?e.minValue:this.defaultMinValue,this.maxValue=e.maxValue!=null?e.maxValue:this.defaultMaxValue,this.rate=e.rate!=null?e.rate:this.defaultRate,this.axis=e.axis!=null?e.axis:this.defaultAxis}apply(e){return V(()=>{let t=ow(e,this.axis),o=Q(O(this.rate,nr(t,this.minValue,this.maxValue)),O(1-this.rate,t));return O(e,de(o,Q(Yt(),t)))})}getConfig(){return{minValue:this.minValue,maxValue:this.maxValue,rate:this.rate,axis:this.axis}}};mf.className="MinMaxNorm";J.registerClass(mf);var wT={maxNorm:"MaxNorm",minMaxNorm:"MinMaxNorm",nonNeg:"NonNeg",unitNorm:"UnitNorm"};function Ot(r){return ap(r)}function kT(r,e={}){return Vi(r,J.SerializationMap.getMap().classNameMap,e,"constraint")}function Pt(r){if(r==null)return null;if(typeof r=="string"){let t={className:r in wT?wT[r]:r,config:{}};return kT(t)}else return r instanceof lp?r:kT(r)}function iH(r){return new uf(r)}function aH(r){return new cf(r)}function lH(){return new pf}function uH(r){return new mf(r)}var uw={};et(uw,{constant:()=>xH,glorotNormal:()=>CH,glorotUniform:()=>vH,heNormal:()=>IH,heUniform:()=>NH,identity:()=>wH,leCunNormal:()=>SH,leCunUniform:()=>TH,ones:()=>gH,orthogonal:()=>EH,randomNormal:()=>bH,randomUniform:()=>yH,truncatedNormal:()=>_H,varianceScaling:()=>kH,zeros:()=>hH});var vT=["channelsFirst","channelsLast"],CT=["nearest","bilinear"],IT=["valid","same","causal"],NT=["max","avg"],ST=["sum","mul","concat","ave"];var up=new Map;function $t(r){Gi(vT,"DataFormat",r)}function TT(r)
          because the value dtype is ${t.dtype}, but TensorArray dtype is ${this.dtype}.`);if(this.size()===0&&(this.elementShape==null||this.elementShape.length===0)&&(this.elementShape=t.shape),Co(this.elementShape,t.shape,`TensorArray ${this.name}: Could not write to TensorArray index ${e}.`),o.read)throw new Error(`TensorArray ${this.name}: Could not write to TensorArray index ${e}, because it has already been read.`);if(o.written)throw new Error(`TensorArray ${this.name}: Could not write to TensorArray index ${e}, because it has already been written.`);o.tensor=t,At(t),o.written=!0,this.tensors[e]=o}writeMany(e,t){if(e.length!==t.length)throw new Error(`TensorArray ${this.name}: could not write multiple tensors,because the index size: ${e.length} is not the same as tensors size: ${t.length}.`);e.forEach((o,n)=>this.write(o,t[n]))}gather(e,t){if(!!t&&t!==this.dtype)throw new Error(`TensorArray dtype is ${this.dtype} but gather requested dtype ${t}`);if(e)e=e.slice(0,this.size());else{e=[];for(let n=0;n<this.size();n++)e.push(n)}if(e.length===0)return Dr([],[0].concat(this.elementShape));let o=this.readMany(e);return Co(this.elementShape,o[0].shape,"TensorArray shape mismatch: "),Bt(o,0)}concat(e){if(!!e&&e!==this.dtype)throw new Error(`TensorArray dtype is ${this.dtype} but concat requested dtype ${e}`);if(this.size()===0)return Dr([],[0].concat(this.elementShape));let t=[];for(let n=0;n<this.size();n++)t.push(n);let o=this.readMany(t);return Co(this.elementShape,o[0].shape,`TensorArray shape mismatch: tensor array shape (${this.elementShape}) vs first tensor shape (${o[0].shape})`),Je(o,0)}scatter(e,t){if(t.dtype!==this.dtype)throw new Error(`TensorArray dtype is ${this.dtype} but tensor has dtype ${t.dtype}`);if(e.length!==t.shape[0])throw new Error(`Expected len(indices) == tensor.shape[0], but saw: ${e.length} vs. ${t.shape[0]}`);let o=Math.max(...e);if(!this.dynamicSize&&o>=this.maxSize)throw new Error(`Max index must be < array size (${o}  vs. ${this.maxSize})`);this.writeMany(e,ur(t,0))}split(e,t){if(t.dtype!==this.dtype)throw new Error(`TensorArray dtype is ${this.dtype} but tensor has dtype ${t.dtype}`);let o=0,n=e.map(l=>(o+=l,o));if(o!==t.shape[0])throw new Error(`Expected sum of lengths to be equal to
          tensor.shape[0], but sum of lengths is
        ${o}, and tensor's shape is: ${t.shape}`);if(!this.dynamicSize&&e.length!==this.maxSize)throw new Error(`TensorArray's size is not equal to the size of lengths (${this.maxSize} vs. ${e.length}), and the TensorArray is not marked as dynamically resizeable`);let s=o===0?0:t.size/o,a=[];V(()=>{t=L(t,[1,o,s]);for(let l=0;l<e.length;++l){let u=l===0?0:n[l-1],c=[0,u,0],p=[1,e[l],s];a[l]=L(Fe(t,c,p),this.elementShape)}return a});let i=[];for(let l=0;l<e.length;l++)i[l]=l;this.writeMany(i,a)}};var oc=class{constructor(e,t,o,n=-1){this.tensors=e,this.elementShape=t,this.elementDtype=o,e!=null&&e.forEach(s=>{if(o!==s.dtype)throw new Error(`Invalid data types; op elements ${o}, but list elements ${s.dtype}`);Co(t,s.shape,"TensorList shape mismatch: "),At(s)}),this.idTensor=le(0),this.maxNumElements=n,At(this.idTensor)}get id(){return this.idTensor.id}copy(){return new oc([...this.tensors],this.elementShape,this.elementDtype)}clearAndClose(e){this.tensors.forEach(t=>{(e==null||!e.has(t.id))&&t.dispose()}),this.tensors.length=0,this.idTensor.dispose()}size(){return this.tensors.length}stack(e,t,o=-1){if(t!==this.elementDtype)throw new Error(`Invalid data types; op elements ${t}, but list elements ${this.elementDtype}`);if(o!==-1&&this.tensors.length!==o)throw new Error(`Operation expected a list with ${o} elements but got a list with ${this.tensors.length} elements.`);return Co(e,this.elementShape,"TensorList shape mismatch: "),V(()=>{let n=this.tensors.map(s=>L(s,e));return Bt(n,0)})}popBack(e,t){if(t!==this.elementDtype)throw new Error(`Invalid data types; op elements ${t}, but list elements ${this.elementDtype}`);if(this.size()===0)throw new Error("Trying to pop from an empty list.");let o=this.tensors.pop();return Co(o.shape,e,"TensorList shape mismatch: "),L(o,e)}pushBack(e){if(e.dtype!==this.elementDtype)throw new Error(`Invalid data types; op elements ${e.dtype}, but list elements ${this.elementDtype}`);if(Co(e.shape,this.elementShape,"TensorList shape mismatch: "),this.maxNumElements===this.size())throw new Error("Trying to push element into a full list.");At(e),this.tensors.push(e)}resize(e){if(e<0)throw new Error(`TensorListResize expects size to be non-negative. Got: ${e}`);if(this.maxNumElements!==-1&&e>this.maxNumElements)throw new Error(`TensorListResize input size ${e} is greater maxNumElement ${this.maxNumElements}.`);this.tensors.length=e}getItem(e,t,o){if(o!==this.elementDtype)throw new Error(`Invalid data types; op elements ${o}, but list elements ${this.elementDtype}`);if(e<0||e>this.tensors.length)throw new Error(`Trying to access element ${e} in a list with ${this.tensors.length} elements.`);if(this.tensors[e]==null)throw new Error(`element at index ${e} is null.`);return Co(this.tensors[e].shape,t,"TensorList shape mismatch: "),this.tensors[e]}setItem(e,t){if(t.dtype!==this.elementDtype)throw new Error(`Invalid data types; op elements ${t.dtype}, but list elements ${this.elementDtype}`);if(e<0||this.maxNumElements!==-1&&e>=this.maxNumElements)throw new Error(`Trying to set element ${e} in a list with max ${this.maxNumElements} elements.`);Co(this.elementShape,t.shape,"TensorList shape mismatch: "),At(t),this.tensors[e]=t}gather(e,t,o){if(t!==this.elementDtype)throw new Error(`Invalid data types; op elements ${t}, but list elements ${this.elementDtype}`);return Co(this.elementShape,o,"TensorList shape mismatch: "),e=e.slice(0,this.size()),e.length===0?Dr([],[0].concat(this.elementShape)):V(()=>{let n=e.map(s=>L(this.tensors[s],o));return Bt(n,0)})}concat(e,t){if(!!e&&e!==this.elementDtype)throw new Error(`TensorList dtype is ${this.elementDtype} but concat requested dtype ${e}`);return Co(this.elementShape,t,"TensorList shape mismatch: "),this.size()===0?Dr([],[0].concat(this.elementShape)):V(()=>{let o=this.tensors.map(n=>L(n,t));return Je(o,0)})}};function L1(r,e,t){let o=r.dtype;if(r.shape.length<1)throw new Error(`Tensor must be at least a vector, but saw shape: ${r.shape}`);if(r.dtype!==t)throw new Error(`Invalid data types; op elements ${r.dtype}, but list elements ${t}`);let n=r.shape.slice(1);Co
          tensor.shape[0], but sum of lengths is
        ${o}, and tensor's shape is: ${r.shape}`);let s=o===0?0:r.size/o,a=V(()=>{let l=[];r=L(r,[1,o,s]);for(let u=0;u<e.length;++u){let c=u===0?0:n[u-1],p=[0,c,0],m=[1,e[u],s];l[u]=L(Fe(r,p,m),t)}return r.dispose(),l}),i=new oc([],t,r.dtype,e.length);for(let l=0;l<a.length;l++)i.setItem(l,a[l]);return i}var G1=async(r,e,t)=>{switch(r.op){case"If":case"StatelessIf":{let o=C("thenBranch",r,e,t),n=C("elseBranch",r,e,t),s=C("cond",r,e,t),a=C("args",r,e,t);return(await s.data())[0]?t.functionMap[o].executeFunctionAsync(a,t.tensorArrayMap,t.tensorListMap):t.functionMap[n].executeFunctionAsync(a,t.tensorArrayMap,t.tensorListMap)}case"While":case"StatelessWhile":{let o=C("body",r,e,t),n=C("cond",r,e,t),s=C("args",r,e,t),a=await t.functionMap[n].executeFunctionAsync(s,t.tensorArrayMap,t.tensorListMap),i=s.map(c=>c.id),l=await a[0].data();a.forEach(c=>{!c.kept&&i.indexOf(c.id)===-1&&c.dispose()});let u=s;for(;l[0];){let c=u;u=await t.functionMap[o].executeFunctionAsync(u,t.tensorArrayMap,t.tensorListMap);let p=u.map(f=>f.id);c.forEach(f=>{!f.kept&&i.indexOf(f.id)===-1&&p.indexOf(f.id)===-1&&f.dispose()});let m=await t.functionMap[n].executeFunctionAsync(u,t.tensorArrayMap,t.tensorListMap);l=await m[0].data(),m.forEach(f=>{!f.kept&&i.indexOf(f.id)===-1&&p.indexOf(f.id)===-1&&f.dispose()})}return u}case"LoopCond":{let o=C("pred",r,e,t);return[Ls(o)]}case"Switch":{let o=C("pred",r,e,t),n=C("data",r,e,t);return n.kept||(n=Ls(n)),(await o.data())[0]?[void 0,n]:[n,void 0]}case"Merge":{let o=r.inputNames.find(n=>hr(n,e,t)!==void 0);if(o){let n=hr(o,e,t);return[Ls(n)]}return}case"Enter":{let o=C("frameName",r,e,t),n=C("tensor",r,e,t);return t.enterFrame(o),[Ls(n)]}case"Exit":{let o=C("tensor",r,e,t);return t.exitFrame(),[Ls(o)]}case"NextIteration":{let o=C("tensor",r,e,t);return t.nextIteration(),[Ls(o)]}case"TensorArrayV3":{let o=C("size",r,e,t),n=C("dtype",r,e,t),s=C("elementShape",r,e,t),a=C("dynamicSize",r,e,t),i=C("clearAfterRead",r,e,t),l=C("identicalElementShapes",r,e,t),u=C("name",r,e,t),c=new yk(u,n,o,s,l,a,i);return t.addTensorArray(c),[c.idTensor,le(1)]}case"TensorArrayWriteV3":{let o=C("tensorArrayId",r,e,t),n=C("index",r,e,t),s=C("tensor",r,e,t),a=t.getTensorArray(o.id);return a.write(n,s),[a.idTensor]}case"TensorArrayReadV3":{let o=C("tensorArrayId",r,e,t),n=C("index",r,e,t);return[t.getTensorArray(o.id).read(n)]}case"TensorArrayGatherV3":{let o=C("tensorArrayId",r,e,t),n=C("indices",r,e,t),s=C("dtype",r,e,t);return[t.getTensorArray(o.id).gather(n,s)]}case"TensorArrayScatterV3":{let o=C("tensorArrayId",r,e,t),n=C("indices",r,e,t),s=C("tensor",r,e,t),a=t.getTensorArray(o.id);return a.scatter(n,s),[a.idTensor]}case"TensorArrayConcatV3":{let o=C("tensorArrayId",r,e,t),n=t.getTensorArray(o.id),s=C("dtype",r,e,t);return[n.concat(s)]}case"TensorArraySplitV3":{let o=C("tensorArrayId",r,e,t),n=C("tensor",r,e,t),s=C("lengths",r,e,t),a=t.getTensorArray(o.id);return a.split(s,n),[a.idTensor]}case"TensorArraySizeV3":{let o=C("tensorArrayId",r,e,t),n=t.getTensorArray(o.id);return[le(n.size(),"int32")]}case"TensorArrayCloseV3":{let o=C("tensorArrayId",r,e,t),n=t.getTensorArray(o.id);return n.clearAndClose(),[n.idTensor]}case"TensorListSetItem":{let o=C("tensorListId",r,e,t),n=C("index",r,e,t),s=C("tensor",r,e,t),a=t.getTensorList(o.id);return a.setItem(n,s),[a.idTensor]}case"TensorListGetItem":{let o=C("tensorListId",r,e,t),n=C("index",r,e,t),s=C("elementShape",r,e,t),a=C("elementDType",r,e,t);return[t.getTensorList(o.id).getItem(n,s,a)]}case"TensorListScatterV2":case"TensorListScatter":{let o=C("indices",r,e,t),n=C("tensor",r,e,t),s=C("elementShape",r,e,t),a=C("numElements",r,e,t),i=B1(n,o,s,a);return t.addTensorList(i),[i.idTensor]}case"TensorListReserve":case"EmptyTensorList":{let o=C("elementShape",r,e,t),n=C("elementDType",r,e,t),s;r.op==="TensorListReserve"?s="numElements":s="maxNumElements";let a=C(s,r,e,t),i=z1(o,n,a);return t.addTensorList(i),[i.idTensor]}case"TensorListGather":{let o=C("tensorListId",r,e,t),n=C("indices",r,e,t),s=C("elementShape",r,e,t),a=C("elementDType",r,e,t);return[t.getTensorList(o.id).gather(n,a,s)]}cas
      ${e}`);let n;return this.size===Infinity||this.size==null?n=this.size:t?n=Math.ceil(this.size/e):n=Math.floor(this.size/e),lo(async()=>(await o.iterator()).columnMajorBatch(e,t,F6),n)}concatenate(e){let t=this,o;return this.size===Infinity||e.size===Infinity?o=Infinity:this.size!=null&&e.size!=null?o=this.size+e.size:o=null,lo(async()=>(await t.iterator()).concatenate(await e.iterator()),o)}filter(e){let t=this,o;return this.size===Infinity?o=Infinity:o=null,lo(async()=>(await t.iterator()).filter(n=>V(()=>e(n))),o)}async forEachAsync(e){return(await this.iterator()).forEachAsync(e)}map(e){let t=this;return lo(async()=>(await t.iterator()).map(o=>V(()=>e(o))),this.size)}mapAsync(e){let t=this;return lo(async()=>(await t.iterator()).mapAsync(e),this.size)}prefetch(e){if(e==null)throw new RangeError("`Dataset.prefetch()` requires bufferSize to be specified.");let t=this;return lo(async()=>(await t.iterator()).prefetch(e),this.size)}repeat(e){let t=this,o;return this.size!=null&&e>0?o=this.size*e:e===0?o=0:this.size!=null&&(e===void 0||e<0)?o=Infinity:o=null,lo(async()=>{let n=Rd(async()=>({value:await t.iterator(),done:!1}));return dE(n.take(e))},o)}skip(e){let t=this,o;return this.size!=null&&e>=0&&this.size>=e?o=this.size-e:this.size!=null&&(this.size<e||e===void 0||e<0)?o=0:o=null,lo(async()=>(await t.iterator()).skip(e),o)}shuffle(e,t,o=!0){if(e==null||e<0)throw this.size==null?new RangeError("`Dataset.shuffle()` requires bufferSize to be specified."):new RangeError(`\`Dataset.shuffle()\` requires bufferSize to be specified.  If your data fits in main memory (for regular JS objects), and/or GPU memory (for \`tf.Tensor\`s), consider setting bufferSize to the dataset size (${this.size} elements)`);let n=this,s=NE.alea(t||y.now().toString());return lo(async()=>{let a=s.int32();return o&&(a+=s.int32()),(await n.iterator()).shuffle(e,a.toString())},this.size)}take(e){let t=this,o;return this.size!=null&&this.size>e?o=e:this.size!=null&&this.size<=e?o=this.size:o=null,lo(async()=>(await t.iterator()).take(e),o)}async toArray(){if(this.size===Infinity)throw new Error("Can not convert infinite data stream to array.");return(await this.iterator()).toArray()}async toArrayForTest(){if(this.size===Infinity)throw new Error("Can not convert infinite data stream to array.");return(await this.iterator()).toArrayForTest()}};qi.MAX_BUFFER_SIZE=1e4;function lo(r,e=null){return new class extends qi{constructor(){super(...arguments);this.size=e}async iterator(){return r()}}}function SE(r){return lo(async()=>Nk(r),r.length)}function TE(r){if(!kl(r))throw new Error("The argument to zip() must be an object or array.");let e;if(Array.isArray(r))for(let t=0;t<r.length;t++)e=e==null?r[t].size:Math.min(e,r[t].size);else if(r instanceof Object)for(let t in r)e=e==null?r[t].size:Math.min(e,r[t].size);return lo(async()=>{let t=await gx(r,o=>{if(o instanceof qi)return{value:o.iterator(),recurse:!1};if(kl(o))return{value:null,recurse:!0};throw new Error("Leaves of the structure passed to zip() must be Datasets, not primitives.")});return gE(t,Va.SHORTEST)},e)}function F6(r){if(r===null)return null;let e=r[0];return uE(e)?{value:O6(r),recurse:!1}:{value:null,recurse:!0}}function O6(r){if(r.length===0)throw new Error("Can't make a batch of zero elements.");return r[0]instanceof Ve?Bt(r):Dr(r)}var Fd=class extends qi{constructor(e){super();this.input=e}async iterator(){return(await this.input.iterator()).decodeUTF8().split(`
`).map(n=>(n.endsWith("\r")&&(n=n.slice(0,-1)),n))}};var xx='"',Od=Symbol("out"),EE=Symbol("field"),yx=Symbol("quote"),Ak=Symbol("quoteafterquote"),AE=Symbol("quoteinquote"),Pd=class extends qi{constructor(e,t){super();this.input=e,this.hasHeader=!0,this.fullColumnNames=null,this.columnNamesValidated=!1,this.columnConfigs=null,this.configuredColumnsOnly=!1,this.delimiter=",",this.delimWhitespace=!1,this.base=new Fd(e),t||(t={}),this.hasHeader=t.hasHeader!==!1,this.fullColumnNames=t.columnNames,this.columnConfigs=t.columnConfigs,this.configuredColumnsOnly=t.configuredColumnsOnly,t.delimWhitespace?(y.assert(t.delimiter==null,()=>"Delimiter should not be provided when delimWhitespace is true."),this.delimWhitespace=!0,this.delimiter=" "):this.delimiter=t.delimiter?t.delimiter:","}async columnNames(){return this.columnNamesValidated||await this.setColumnNames(),this.configuredColumnsOnly?Object.keys(this.columnConfigs):this.fullColumnNames}async setColumnNames(){let e=await this.maybeReadHeaderLine();if(!this.fullColumnNames&&!e)throw new Error("Column names must be provided if there is no header line.");this.fullColumnNames&&e&&y.assert(e.length===this.fullColumnNames.length,()=>"The length of provided columnNames ("+this.fullColumnNames.length.toString()+") does not match the length of the header line read from file ("+e.length.toString()+")."),this.fullColumnNames||(this.fullColumnNames=e);let t=this.fullColumnNames.reduce((n,s)=>(n[s]=n[s]+1||1,n),{}),o=Object.keys(t).filter(n=>t[n]>1);if(y.assert(o.length===0,()=>"Duplicate column names found: "+o.toString()),this.columnConfigs){for(let n of Object.keys(this.columnConfigs))if(this.fullColumnNames.indexOf(n)===-1)throw new Error('The key "'+n+'" provided in columnConfigs does not match any of the column names ('+this.fullColumnNames.toString()+").")}this.columnNamesValidated=!0}async maybeReadHeaderLine(){if(this.hasHeader){let t=await(await this.base.iterator()).next();if(t.done)throw new Error("No data was found for CSV parsing.");let o=t.value;return this.parseRow(o,!1)}else return null}async iterator(){this.columnNamesValidated||await this.setColumnNames();let e=await this.base.iterator();return this.hasHeader&&(e=e.skip(1)),e.map(t=>this.makeDataElement(t))}makeDataElement(e){let t=this.parseRow(e),o={},n={};for(let s=0;s<this.fullColumnNames.length;s++){let a=this.fullColumnNames[s],i=this.columnConfigs?this.columnConfigs[a]:null;if(!(this.configuredColumnsOnly&&!i)){let l=t[s],u=null;if(l==="")if(i&&i.default!==void 0)u=i.default;else{if(i&&(i.required||i.isLabel))throw new Error(`Required column ${a} is empty in this line: ${e}`);u=void 0}else{let c=Number(l);if(isNaN(c))i&&i.dtype==="bool"?u=this.getBoolean(l):u=l;else if(!i||!i.dtype)u=c;else switch(i.dtype){case"float32":u=c;break;case"int32":u=Math.floor(c);break;case"bool":u=this.getBoolean(l);break;default:u=c}}i&&i.isLabel?n[a]=u:o[a]=u}}return Object.keys(n).length===0?o:{xs:o,ys:n}}getBoolean(e){return e==="1"||e.toLowerCase()==="true"?1:0}parseRow(e,t=!0){let o=[],n=0,s=e.length,a=Od;for(let i=0;i<s;i++)switch(a){case Od:switch(e.charAt(i)){case xx:n=i+1,a=yx;break;case this.delimiter:if(n=i+1,this.delimiter===" "&&this.delimWhitespace)break;o.push(""),a=Od;break;default:a=EE,n=i;break}break;case EE:switch(e.charAt(i)){case this.delimiter:o.push(e.substring(n,i)),a=Od,n=i+1;break;default:}break;case yx:switch(e.charAt(i)){case xx:a=Ak;break;default:}break;case Ak:switch(e.charAt(i)){case this.delimiter:o.push(e.substring(n,i-1)),a=Od,n=i+1;break;case xx:a=yx;break;default:a=AE;break}break;case AE:switch(e.charAt(i)){case xx:a=yx;break;default:}break;default:}if(a===Ak?o.push(e.substring(n,s-1)):o.push(e.substring(n)),t&&o.length!==this.fullColumnNames.length)throw new Error(`Invalid row in csv file. Should have ${this.fullColumnNames.length} elements in a row, but got ${o}`);return o}};var Md=class extends Kt{constructor(e){super();this.microphoneConfig=e,this.isClosed=!1,this.fftSize=e.fftSize||1024;let t=Math.log2(this.fftSize);if(this.fftSize<0||t<4||t>14||!Number.isInteger(t))throw new Error(`Inval
============================
Hi there \u{1F44B}. Looks like you are running TensorFlow.js in Node.js. To speed things up dramatically, install our node backend, which binds to TensorFlow C++, by running npm i @tensorflow/tfjs-node, or npm i @tensorflow/tfjs-node-gpu if you have CUDA. Then call require('@tensorflow/tfjs-node'); (-gpu suffix for CUDA) at the start of your program. Visit https://github.com/tensorflow/tfjs-node for more details.
============================`));let n={};return this.data.set(n,{values:e,dtype:o,refCount:1}),n}makeTensorInfo(e,t,o){let n;if(t==="string"&&o!=null&&o.length>0&&y.isString(o[0])){let s=o.map(a=>y.encodeString(a));n=this.write(s,e,t)}else n=this.write(o,e,t);return{dataId:n,shape:e,dtype:t}}incRef(e){let t=this.data.get(e);t.refCount++}decRef(e){if(this.data.has(e)){let t=this.data.get(e);t.refCount--}}move(e,t,o,n){this.data.set(e,{values:t,dtype:n,refCount:1})}numDataIds(){return this.data.numDataIds()}async read(e){return this.readSync(e)}readSync(e){let{dtype:t,complexTensorInfos:o}=this.data.get(e);if(t==="complex64"){let n=this.readSync(o.real.dataId),s=this.readSync(o.imag.dataId);return N.mergeRealAndImagArrays(n,s)}return this.data.get(e).values}bufferSync(e){let t=this.readSync(e.dataId),o=t;if(e.dtype==="string")try{o=t.map(n=>y.decodeString(n))}catch(n){throw new Error("Failed to decode encoded string bytes into utf-8")}return Ce(e.shape,e.dtype,o)}makeOutput(e,t,o){let n=this.write(e,t,o);return vs().makeTensorFromDataId(n,t,o,this)}disposeData(e){if(this.data.has(e)){let{complexTensorInfos:t}=this.data.get(e);t!=null&&(this.disposeData(t.real.dataId),this.disposeData(t.imag.dataId)),this.data.delete(e)}}disposeIntermediateTensorInfo(e){let t=e.dataId;if(this.data.has(t)){let o=this.data.get(t);o.refCount--,o.refCount<1&&this.disposeData(t)}}async time(e){let t=y.now();return e(),{kernelMs:y.now()-t}}memory(){return{unreliable:!0,reasons:["The reported memory is an upper bound. Due to automatic garbage collection, the true allocated memory may be less."]}}where(e){ee([e],"where");let t=this.readSync(e.dataId);return M6(e.shape,t)}dispose(){}floatPrecision(){return 32}epsilon(){return super.epsilon()}};var Wk={};et(Wk,{addImpl:()=>KE,bincountImpl:()=>Wd,bincountReduceImpl:()=>Fk,ceilImpl:()=>YE,concatImpl:()=>Ud,expImpl:()=>JE,expm1Impl:()=>eA,floorImpl:()=>rA,gatherV2Impl:()=>Pk,greaterImpl:()=>nA,lessImpl:()=>iA,linSpaceImpl:()=>Mk,logImpl:()=>lA,maxImpl:()=>Lk,maximumImpl:()=>cA,minimumImpl:()=>mA,multiplyImpl:()=>kx,negImpl:()=>hA,notEqualImpl:()=>xA,prodImpl:()=>_A,rangeImpl:()=>qd,rsqrtImpl:()=>kA,simpleAbsImpl:()=>GE,sliceImpl:()=>Kd,squaredDifferenceImpl:()=>IA,stridedSliceImpl:()=>zk,subImpl:()=>SA,tileImpl:()=>Bk,topKImpl:()=>Vk,transposeImpl:()=>Hd,uniqueImpl:()=>Gk});function GE(r){let e=new Float32Array(r.length);for(let t=0;t<r.length;++t)e[t]=Math.abs(r[t]);return e}var L6=r=>{let{x:e}=r.inputs,t=r.backend;ee(e,"abs");let o=new Float32Array(y.sizeFromShape(e.shape)),n=t.data.get(e.dataId).values;return o=GE(n),t.makeOutput(o,e.shape,"float32")},WE={kernelName:ss,backendName:"cpu",kernelFunc:L6};function Ye(r){return(e,t,o,n,s)=>{let a=N.assertAndGetBroadcastShape(e,t),i=a.length,l=y.computeStrides(a),u=y.sizeFromShape(a),c=y.getTypedArrayFromDType(s,u),p=e.length,m=t.length,f=y.computeStrides(e),d=y.computeStrides(t),h=N.getBroadcastDims(e,a),g=N.getBroadcastDims(t,a);if(h.length+g.length===0)for(let x=0;x<c.length;++x)c[x]=r(o[x%o.length],n[x%n.length]);else for(let x=0;x<c.length;++x){let b=y.indexToLoc(x,i,l),_=b.slice(-p);h.forEach(A=>_[A]=0);let w=y.locToIndex(_,p,f),v=b.slice(-m);g.forEach(A=>v[A]=0);let $=y.locToIndex(v,m,d);c[x]=r(o[w],n[$])}return[c,a]}}function cr(r){let{inputs:e,backend:t}=r,{real:o,imag:n}=e,s=t.data.get(o.dataId).values,a=t.data.get(n.dataId).values,i=t.makeTensorInfo(o.shape,"complex64"),l=t.data.get(i.dataId);return l.complexTensorInfos={real:t.makeTensorInfo(o.shape,"float32",s),imag:t.makeTensorInfo(n.shape,"float32",a)},i}var UE={kernelName:Hl,backendName:"cpu",kernelFunc:cr};function Fp(r,e,t="float32"){if(t==="complex64"){let n=Fp(r,e,"float32"),s=Fp(r,e,"float32");return cr({inputs:{real:n,imag:s},backend:r})}let o=y.makeZerosTypedArray(y.sizeFromShape(e),t);return r.makeTensorInfo(e,t,o)}function Tr(r){let{inputs:e,backend:t}=r,{x:o}=e;return t.incRef(o.dataId),{dataId:o.dataId,shape:o.shape,dtype:o.dtype}}var jE={kernelName:us,backendName:"cpu",kernelFunc:Tr};function Kn(r){let{inputs:e,backend:t}=r,{input:o}=e,n=t.data.get(o.dataId).complexTensorInfos.
`),s=n.length.toString().length+2,a=n.map((p,m)=>y.rightPad((m+1).toString(),s)+p),i=0;for(let p=0;p<a.length;p++)i=Math.max(a[p].length,i);let l=a.slice(0,o-1),u=a.slice(o-1,o),c=a.slice(o);console.log(l.join(`
`)),console.log(e.split(`
`)[0]),console.log(`%c ${y.rightPad(u[0],i)}`,"border:1px solid red; background-color:#e3d2d2; color:#a61717"),console.log(c.join(`
`))}function i$(r){return Wa(r,()=>r.createProgram(),"Unable to create WebGLProgram.")}function a$(r,e){if(Ee(r,()=>r.linkProgram(e)),r.getProgramParameter(e,r.LINK_STATUS)===!1)throw console.log(r.getProgramInfoLog(e)),new Error("Failed to link vertex and fragment shaders.")}function Tx(r,e){if(Ee(r,()=>r.validateProgram(e)),r.getProgramParameter(e,r.VALIDATE_STATUS)===!1)throw console.log(r.getProgramInfoLog(e)),new Error("Shader program validation failed.")}function l$(r,e){let t=Wa(r,()=>r.createBuffer(),"Unable to create WebGLBuffer");return Ee(r,()=>r.bindBuffer(r.ARRAY_BUFFER,t)),Ee(r,()=>r.bufferData(r.ARRAY_BUFFER,e,r.STATIC_DRAW)),t}function u$(r,e){let t=Wa(r,()=>r.createBuffer(),"Unable to create WebGLBuffer");return Ee(r,()=>r.bindBuffer(r.ELEMENT_ARRAY_BUFFER,t)),Ee(r,()=>r.bufferData(r.ELEMENT_ARRAY_BUFFER,e,r.STATIC_DRAW)),t}function c$(r){return Wa(r,()=>r.createTexture(),"Unable to create WebGLTexture.")}function p$(r,e){let t=G().getNumber("WEBGL_MAX_TEXTURE_SIZE");if(r<=0||e<=0){let o=`[${r}x${e}]`;throw new Error("Requested texture size "+o+" is invalid.")}if(r>t||e>t){let o=`[${r}x${e}]`,n=`[${t}x${t}]`;throw new Error("Requested texture size "+o+" greater than WebGL maximum on this browser / GPU "+n+".")}}function m$(r){return Wa(r,()=>r.createFramebuffer(),"Unable to create WebGLFramebuffer.")}function nv(r,e,t,o,n,s,a){let i=r.getAttribLocation(e,t);return i===-1?!1:(Ee(r,()=>r.bindBuffer(r.ARRAY_BUFFER,o)),Ee(r,()=>r.vertexAttribPointer(i,n,r.FLOAT,!1,s,a)),Ee(r,()=>r.enableVertexAttribArray(i)),!0)}function D8(r,e,t){A8(r,t),Ee(r,()=>r.activeTexture(r.TEXTURE0+t)),Ee(r,()=>r.bindTexture(r.TEXTURE_2D,e))}function f$(r,e,t){return Wa(r,()=>r.getUniformLocation(e,t),'uniform "'+t+'" not present in program.')}function d$(r,e,t){return r.getUniformLocation(e,t)}function h$(r,e,t,o){Ee(r,()=>D8(r,e,o)),Ee(r,()=>r.uniform1i(t,o))}function Ex(r,e,t){Ee(r,()=>r.bindFramebuffer(r.FRAMEBUFFER,t)),Ee(r,()=>r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,e,0))}function sv(r,e){Ee(r,()=>r.bindFramebuffer(r.FRAMEBUFFER,e)),Ee(r,()=>r.framebufferTexture2D(r.FRAMEBUFFER,r.COLOR_ATTACHMENT0,r.TEXTURE_2D,null,0))}function rh(r){let e=r.checkFramebufferStatus(r.FRAMEBUFFER);if(e!==r.FRAMEBUFFER_COMPLETE)throw new Error("Error binding framebuffer: "+$8(r,e))}function $8(r,e){switch(e){case r.FRAMEBUFFER_INCOMPLETE_ATTACHMENT:return"FRAMEBUFFER_INCOMPLETE_ATTACHMENT";case r.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT:return"FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT";case r.FRAMEBUFFER_INCOMPLETE_DIMENSIONS:return"FRAMEBUFFER_INCOMPLETE_DIMENSIONS";case r.FRAMEBUFFER_UNSUPPORTED:return"FRAMEBUFFER_UNSUPPORTED";default:return`unknown error ${e}`}}function Wa(r,e,t){let o=Ee(r,()=>e());if(o==null)throw new Error(t);return o}function A8(r,e){let t=r.MAX_COMBINED_TEXTURE_IMAGE_UNITS-1,o=e+r.TEXTURE0;if(o<r.TEXTURE0||o>t){let n=`[gl.TEXTURE0, gl.TEXTURE${t}]`;throw new Error(`textureUnit must be in ${n}.`)}}function Nl(r,e=2){return y.sizeFromShape(r.slice(0,r.length-e))}function Sl(r){if(r.length===0)throw Error("Cannot get rows and columns of an empty shape array.");return[r.length>1?r[r.length-2]:1,r[r.length-1]]}function Ax(r){let e=[1,1,1];return r.length===0||r.length===1&&r[0]===1||(e=[Nl(r),...Sl(r)]),e}function g$(r,e=!1){let t=G().getNumber("WEBGL_MAX_TEXTURE_SIZE");e&&(t=t*2,r=r.map((n,s)=>s>=r.length-2?y.nearestLargerEven(r[s]):r[s]),r.length===1&&(r=[2,r[0]])),r.length!==2&&(r=y.squeezeShape(r).newShape);let o=y.sizeFromShape(r);if(r.length<=1&&o<=t)return[1,o];if(r.length===2&&r[0]<=t&&r[1]<=t)return r;if(r.length===3&&r[0]*r[1]<=t&&r[2]<=t)return[r[0]*r[1],r[2]];if(r.length===3&&r[0]<=t&&r[1]*r[2]<=t)return[r[0],r[1]*r[2]];if(r.length===4&&r[0]*r[1]*r[2]<=t&&r[3]<=t)return[r[0]*r[1]*r[2],r[3]];if(r.length===4&&r[0]<=t&&r[1]*r[2]*r[3]<=t)return[r[0],r[1]*r[2]*r[3]];if(e){let n=Nl(r),s=2,a=2;return r.length&&([s,a]=Sl(r)),o=n*(s/2)*(a/2),y.sizeToSquarishShape(o).map(i=>i*2)}return y.sizeToSquarishShape(o)}function Dx(r){return r%2==0}function ac(r,e){if(r=r.slice(-2),e=e.slice(-2),y.array
      bool isnan_custom(float val) {
        return (val > 0.0 || val < 0.0) ? false : val != 0.0;
      }

      bvec4 isnan_custom(vec4 val) {
        return bvec4(isnan_custom(val.x),
          isnan_custom(val.y), isnan_custom(val.z), isnan_custom(val.w));
      }

      #define isnan(value) isnan_custom(value)
    `,l="",u=`
      #define round(value) newRound(value)
      int newRound(float value) {
        return int(floor(value + 0.5));
      }

      ivec4 newRound(vec4 value) {
        return ivec4(floor(value + vec4(0.5)));
      }
    `):(r="",e="attribute",t="varying",o="varying",n="texture2D",s="gl_FragColor",a="",i=`
      #define isnan(value) isnan_custom(value)
      bool isnan_custom(float val) {
        return (val > 0. || val < 1. || val == 0.) ? false : true;
      }
      bvec4 isnan_custom(vec4 val) {
        return bvec4(isnan(val.x), isnan(val.y), isnan(val.z), isnan(val.w));
      }
    `,l=`
      uniform float INFINITY;

      bool isinf(float val) {
        return abs(val) == INFINITY;
      }
      bvec4 isinf(vec4 val) {
        return equal(abs(val), vec4(INFINITY));
      }
    `,u=`
      int round(float value) {
        return int(floor(value + 0.5));
      }

      ivec4 round(vec4 value) {
        return ivec4(floor(value + vec4(0.5)));
      }
    `),{version:r,attribute:e,varyingVs:t,varyingFs:o,texture2D:n,output:s,defineOutput:a,defineSpecialNaN:i,defineSpecialInf:l,defineRound:u}}function zs(r,e,t="index"){let o=y.computeStrides(e);return o.map((n,s)=>{let a=`int ${r[s]} = ${t} / ${n}`,i=s===o.length-1?`int ${r[s+1]} = ${t} - ${r[s]} * ${n}`:`index -= ${r[s]} * ${n}`;return`${a}; ${i};`}).join("")}function zp(r){let e=y.computeStrides(r).map(t=>t.toString());return`
  int getFlatIndex(ivec3 coords) {
    return coords.x * ${e[0]} + coords.y * ${e[1]} + coords.z;
  }
`}var $x=`
  const float FLOAT_MAX = 1.70141184e38;
  const float FLOAT_MIN = 1.17549435e-38;

  lowp vec4 encode_float(highp float v) {
    if (isnan(v)) {
      return vec4(255, 255, 255, 255);
    }

    highp float av = abs(v);

    if(av < FLOAT_MIN) {
      return vec4(0.0, 0.0, 0.0, 0.0);
    } else if(v > FLOAT_MAX) {
      return vec4(0.0, 0.0, 128.0, 127.0) / 255.0;
    } else if(v < -FLOAT_MAX) {
      return vec4(0.0, 0.0,  128.0, 255.0) / 255.0;
    }

    highp vec4 c = vec4(0,0,0,0);

    highp float e = floor(log2(av));
    highp float m = exp2(fract(log2(av))) - 1.0;

    c[2] = floor(128.0 * m);
    m -= c[2] / 128.0;
    c[1] = floor(32768.0 * m);
    m -= c[1] / 32768.0;
    c[0] = floor(8388608.0 * m);

    highp float ebias = e + 127.0;
    c[3] = floor(ebias / 2.0);
    ebias -= c[3] * 2.0;
    c[2] += floor(ebias) * 128.0;

    c[3] += 128.0 * step(0.0, -v);

    return c / 255.0;
  }
`;var cv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!1,this.packedOutput=!0,this.outPackingScheme=Cl.DENSE;let t=Il(e),o=Mt();this.outputShape=e,this.userCode=`
      ivec3 outCoordsFromFlatIndex(int index) {
        ${zs(["r","c","d"],e)}
        return ivec3(r, c, d);
      }

      void main() {
        ivec2 resTexRC = ivec2(resultUV.yx *
          vec2(${t[0]}, ${t[1]}));
        int index = 4 * (resTexRC.x * ${t[1]} + resTexRC.y);

        vec4 result = vec4(0.);

        for (int i=0; i<4; i++) {
          int flatIndex = index + i;
          ivec3 rc = outCoordsFromFlatIndex(flatIndex);
          result[i] = getA(rc.x, rc.y, rc.z);
        }

        ${o.output} = result;
      }
    `}};var pv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outPackingScheme=Cl.DENSE;let t=Il(e),o=Mt();this.outputShape=e,this.userCode=`
      ivec3 outCoordsFromFlatIndex(int index) {
        ${zs(["r","c","d"],e)}
        return ivec3(r, c, d);
      }

      void main() {
        ivec2 resTexRC = ivec2(resultUV.yx *
          vec2(${t[0]}, ${t[1]}));
        int index = 4 * (resTexRC.x * ${t[1]} + resTexRC.y);

        vec4 result = vec4(0.);

        for (int i=0; i<4; i++) {
          int flatIndex = index + i;
          ivec3 rc = outCoordsFromFlatIndex(flatIndex);
          result[i] = getChannel(getA(rc.x, rc.y, rc.z), vec2(rc.y, rc.z));
        }

        ${o.output} = result;
      }
    `}};var mv=class{constructor(e){this.variableNames=["A"],this.outTexUsage=Er.DOWNLOAD;let t=Mt();this.outputShape=e,this.userCode=`
      ${$x}

      void main() {
        float x = getAAtOutCoords();
        ${t.output} = encode_float(x);
      }
    `}};var fv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!1,this.outTexUsage=Er.DOWNLOAD;let t=Mt();this.outputShape=e,this.userCode=`
      ${$x}

      void main() {
        ivec3 coords = getOutputCoords();
        float x = getChannel(getAAtOutCoords(), vec2(coords.y, coords.z));
        ${t.output} = encode_float(x);
      }
    `}};var dv=class{constructor(e,t,o=!1){this.variableNames=["A"];let n=Mt(),[s,a]=t;this.outputShape=e;let i="result";o&&(i="floor(result * 255. + 0.5)"),this.userCode=`
      ${zp(e)}

      void main() {
        ivec3 coords = getOutputCoords();

        int flatIndex = getFlatIndex(coords);
        int offset = imod(flatIndex, 4);

        flatIndex = idiv(flatIndex, 4, 1.);

        int r = flatIndex / ${a};
        int c = imod(flatIndex, ${a});
        vec2 uv = (vec2(c, r) + halfCR) / vec2(${a}.0, ${s}.0);
        vec4 values = ${n.texture2D}(A, uv);

        float result;

        if(offset == 0) {
          result = values[0];
        } else if(offset == 1) {
          result = values[1];
        } else if(offset == 2) {
          result = values[2];
        } else {
          result = values[3];
        }

        ${n.output} = vec4(${i}, 0., 0., 0.);
      }
    `}};var hv=class{constructor(e,t,o=!1){this.variableNames=["A"],this.packedInputs=!1,this.packedOutput=!0;let n=Mt(),[s,a]=t;this.outputShape=e;let i="",l="result";o&&(l="floor(result * 255. + 0.5)");for(let u=0;u<=1;u++)for(let c=0;c<=1;c++){let p=u*2+c;i+=`
          localCoords = coords;
          if(localCoords[2] + ${c} < ${e[2]}) {
            localCoords[2] += ${c};
            if(localCoords[1] + ${u} < ${e[1]}) {
              localCoords[1] += ${u};

              flatIndex = getFlatIndex(localCoords);
              offset = imod(flatIndex, 4);

              flatIndex = idiv(flatIndex, 4, 1.);

              r = flatIndex / ${a};
              c = imod(flatIndex, ${a});
              uv = (vec2(c, r) + halfCR) / vec2(${a}.0, ${s}.0);
              values = ${n.texture2D}(A, uv);

              if(offset == 0) {
                result[${p}] = values[0];
              } else if(offset == 1) {
                result[${p}] = values[1];
              } else if(offset == 2) {
                result[${p}] = values[2];
              } else {
                result[${p}] = values[3];
              }
            }
          }
        `}this.userCode=`
      ${zp(e)}

      void main() {
        ivec3 coords = getOutputCoords();

        vec4 result = vec4(0.);
        int flatIndex, r, c, offset;
        ivec3 localCoords;
        vec2 uv;
        vec4 values;

        ${i}

        ${n.output} = ${l};
      }
    `}};function v$(r){let e=Mt(),t=`${e.version}
    precision highp float;
    ${e.attribute} vec3 clipSpacePos;
    ${e.attribute} vec2 uv;
    ${e.varyingVs} vec2 resultUV;

    void main() {
      gl_Position = vec4(clipSpacePos, 1);
      resultUV = uv;
    }`;return n$(r,t)}function C$(r){let e=new Float32Array([-1,1,0,0,1,-1,-1,0,0,0,1,1,0,1,1,1,-1,0,1,0]);return l$(r,e)}function I$(r){let e=new Uint16Array([0,1,2,2,1,3]);return u$(r,e)}function oh(r,e,t,o,n,s){p$(e,t);let a=c$(r),i=r.TEXTURE_2D;return Ee(r,()=>r.bindTexture(i,a)),Ee(r,()=>r.texParameteri(i,r.TEXTURE_WRAP_S,r.CLAMP_TO_EDGE)),Ee(r,()=>r.texParameteri(i,r.TEXTURE_WRAP_T,r.CLAMP_TO_EDGE)),Ee(r,()=>r.texParameteri(i,r.TEXTURE_MIN_FILTER,r.NEAREST)),Ee(r,()=>r.texParameteri(i,r.TEXTURE_MAG_FILTER,r.NEAREST)),Ee(r,()=>r.texImage2D(i,0,o,e,t,0,n,s,null)),Ee(r,()=>r.bindTexture(r.TEXTURE_2D,null)),a}function gv(r){return r.internalFormatFloat}function N$(r,e,t,o){let[n,s]=ic(e,t);return oh(r,n,s,gv(o),o.textureFormatFloat,r.FLOAT)}function xv(r){return r.internalFormatHalfFloat}function S$(r,e,t,o){let[n,s]=ic(e,t);return oh(r,n,s,xv(o),o.textureFormatFloat,o.textureTypeHalfFloat)}function yv(r){return r.downloadTextureFormat}function T$(r,e,t,o){let[n,s]=ic(e,t);return oh(r,n,s,yv(o),r.RGBA,r.UNSIGNED_BYTE)}function bv(r){return r.internalFormatPackedFloat}function E$(r,e,t,o){let[n,s]=Xi(e,t);return oh(r,n,s,bv(o),r.RGBA,r.FLOAT)}function _v(r){return r.internalFormatPackedHalfFloat}function A$(r,e,t,o){let[n,s]=Xi(e,t);return oh(r,n,s,_v(o),r.RGBA,o.textureTypeHalfFloat)}function D$(r,e,t){let o=0,n=3*4,s=3*4+2*4;return Ee(r,()=>r.bindBuffer(r.ARRAY_BUFFER,t)),nv(r,e,"clipSpacePos",t,3,s,o)&&nv(r,e,"uv",t,2,s,n)}function $$(r,e,t,o,n,s){Ee(r,()=>r.bindTexture(r.TEXTURE_2D,e));let a,i,l;n instanceof Uint8Array?(a=new Uint8Array(t*o*4),i=r.UNSIGNED_BYTE,l=r.RGBA):(a=new Float32Array(t*o*4),i=r.FLOAT,l=s.internalFormatPackedFloat),a.set(n),Ee(r,()=>r.texImage2D(r.TEXTURE_2D,0,l,t,o,0,r.RGBA,i,a)),Ee(r,()=>r.bindTexture(r.TEXTURE_2D,null))}function R$(r,e,t){Ee(r,()=>r.bindTexture(r.TEXTURE_2D,e)),t.data instanceof Uint8Array?Ee(r,()=>r.texImage2D(r.TEXTURE_2D,0,r.RGBA,t.width,t.height,0,r.RGBA,r.UNSIGNED_BYTE,t.data)):Ee(r,()=>r.texImage2D(r.TEXTURE_2D,0,r.RGBA,r.RGBA,r.UNSIGNED_BYTE,t)),Ee(r,()=>r.bindTexture(r.TEXTURE_2D,null))}function F$(r,e,t,o){let n=r.createBuffer();Ee(r,()=>r.bindBuffer(r.PIXEL_PACK_BUFFER,n));let i=4*4*e*t;return Ee(r,()=>r.bufferData(r.PIXEL_PACK_BUFFER,i,r.STREAM_READ)),Ee(r,()=>r.readPixels(0,0,t,e,r.RGBA,r.FLOAT,0)),Ee(r,()=>r.bindBuffer(r.PIXEL_PACK_BUFFER,null)),n}function O$(r,e,t){let o=r,n=new Float32Array(t);return o.bindBuffer(o.PIXEL_PACK_BUFFER,e),o.getBufferSubData(o.PIXEL_PACK_BUFFER,0,n),o.bindBuffer(o.PIXEL_PACK_BUFFER,null),n}function P$(r,e,t,o){let[n,s]=ic(e,t),a=4,i=new Uint8Array(t$(e*t,a));return Ee(r,()=>r.readPixels(0,0,n,s,o.downloadTextureFormat,r.UNSIGNED_BYTE,i)),new Float32Array(i.buffer)}function M$(r,e,t,o,n,s,a,i){let l=r,u=new Float32Array(r$(s,a));return l.bindBuffer(l.PIXEL_PACK_BUFFER,e),l.getBufferSubData(l.PIXEL_PACK_BUFFER,0,u),l.bindBuffer(l.PIXEL_PACK_BUFFER,null),u}function L$(r,e,t){let o=new Float32Array(e*t*4);return Ee(r,()=>r.readPixels(0,0,t,e,r.RGBA,r.FLOAT,o)),o}var wv=class{constructor(e){this.outputTexture=null,this.program=null,this.disposed=!1,this.vertexAttrsAreBound=!1,this.itemsToPoll=[];let t=G().getNumber("WEBGL_VERSION");e!=null?(this.gl=e,e$(t,e)):this.gl=Lo(t);let o="WEBGL_color_buffer_float",n="EXT_color_buffer_half_float";if(G().getNumber("WEBGL_VERSION")===1){let s="OES_texture_float",a="OES_texture_half_float";if(this.textureFloatExtension=th(this.gl,s),zo(this.gl,a))this.textureHalfFloatExtension=th(this.gl,a);else if(G().get("WEBGL_FORCE_F16_TEXTURES"))throw new Error("GL context does not support half float textures, yet the environment flag WEBGL_FORCE_F16_TEXTURES is set to true.");if(this.colorBufferFloatExtension=this.gl.getExtension(o),zo(this.gl,n))this.colorBufferHalfFloatExtension=th(this.gl,n);else if(G().get("WEBGL_FORCE_F16_TEXTURES"))throw new Error("GL context does not support color renderable half floats, yet the environment flag WEBGL_FORCE_F16_TEXTURES is set to true.")}else if(o="EXT_color_buffer_float",zo(this.gl,o))this.colorBufferFloatExtension=this.gl.getExtension(o);else if(zo(this.gl,n))this.
`),a=r.map(d=>O8(d,e,o)).join(`
`),i=e.texShape,l=Mt(),u=L8(l),c,p,m=V8(l);return e.isPacked?(c=P8(e.logicalShape,i),p=B8(l)):(c=M8(e.logicalShape,i),p=z8(l)),o&&(m+=G8),[m,u,p,s,c,a,t].join(`
`)}function Bp(r){let e=r.shapeInfo.logicalShape;switch(e.length){case 0:return W8(r);case 1:return U8(r);case 2:return j8(r);case 3:return H8(r);case 4:return q8(r);case 5:return K8(r);case 6:return X8(r);default:throw new Error(`${e.length}-D input sampling is not yet supported`)}}function V$(r){switch(r.shapeInfo.logicalShape.length){case 0:return Y8(r);case 1:return Z8(r);case 2:return J8(r);case 3:return Q8(r);default:return eY(r)}}function O8(r,e,t=!1){let o="";t?o+=V$(r):o+=Bp(r);let n=r.shapeInfo.logicalShape,s=e.logicalShape;return n.length<=s.length&&(t?o+=tY(r,e):o+=rY(r,e)),o}function P8(r,e){switch(r.length){case 0:return G$();case 1:return oY(r,e);case 2:return iY(r,e);case 3:return nY(r,e);default:return sY(r,e)}}function M8(r,e){switch(r.length){case 0:return G$();case 1:return aY(r,e);case 2:return mY(r,e);case 3:return lY(r,e);case 4:return uY(r,e);case 5:return cY(r,e);case 6:return pY(r,e);default:throw new Error(`${r.length}-D output sampling is not yet supported`)}}function L8(r){return`
    float sampleTexture(sampler2D textureSampler, vec2 uv) {
      return ${r.texture2D}(textureSampler, uv).r;
    }
  `}function z8(r){return`
    void setOutput(float val) {
      ${r.output} = vec4(val, 0, 0, 0);
    }
  `}function B8(r){return`
    void setOutput(vec4 val) {
      ${r.output} = val;
    }
  `}function V8(r){return`${r.version}
    precision highp float;
    precision highp int;
    precision highp sampler2D;
    ${r.varyingFs} vec2 resultUV;
    ${r.defineOutput}
    const vec2 halfCR = vec2(0.5, 0.5);

    struct ivec5
    {
      int x;
      int y;
      int z;
      int w;
      int u;
    };

    struct ivec6
    {
      int x;
      int y;
      int z;
      int w;
      int u;
      int v;
    };

    uniform float NAN;
    ${r.defineSpecialNaN}
    ${r.defineSpecialInf}
    ${r.defineRound}

    int imod(int x, int y) {
      return x - y * (x / y);
    }

    int idiv(int a, int b, float sign) {
      int res = a / b;
      int mod = imod(a, b);
      if (sign < 0. && mod != 0) {
        res -= 1;
      }
      return res;
    }

    //Based on the work of Dave Hoskins
    //https://www.shadertoy.com/view/4djSRW
    #define HASHSCALE1 443.8975
    float random(float seed){
      vec2 p = resultUV * seed;
      vec3 p3  = fract(vec3(p.xyx) * HASHSCALE1);
      p3 += dot(p3, p3.yzx + 19.19);
      return fract((p3.x + p3.y) * p3.z);
    }

    ${fY}
    ${dY}
    ${hY}
  `}var fY=`
vec2 uvFromFlat(int texNumR, int texNumC, int index) {
  int texR = index / texNumC;
  int texC = index - texR * texNumC;
  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
}
vec2 packedUVfrom1D(int texNumR, int texNumC, int index) {
  int texelIndex = index / 2;
  int texR = texelIndex / texNumC;
  int texC = texelIndex - texR * texNumC;
  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
}
`,dY=`
vec2 packedUVfrom2D(int texelsInLogicalRow, int texNumR,
  int texNumC, int row, int col) {
  int texelIndex = (row / 2) * texelsInLogicalRow + (col / 2);
  int texR = texelIndex / texNumC;
  int texC = texelIndex - texR * texNumC;
  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
}
`,hY=`
vec2 packedUVfrom3D(int texNumR, int texNumC,
    int texelsInBatch, int texelsInLogicalRow, int b,
    int row, int col) {
  int index = b * texelsInBatch + (row / 2) * texelsInLogicalRow + (col / 2);
  int texR = index / texNumC;
  int texC = index - texR * texNumC;
  return (vec2(texC, texR) + halfCR) / vec2(texNumC, texNumR);
}
`,G8=`
  float getChannel(vec4 frag, vec2 innerDims) {
    vec2 modCoord = mod(innerDims, 2.);
    return modCoord.x == 0. ?
      (modCoord.y == 0. ? frag.r : frag.g) :
      (modCoord.y == 0. ? frag.b : frag.a);
  }
  float getChannel(vec4 frag, int dim) {
    float modCoord = mod(float(dim), 2.);
    return modCoord == 0. ? frag.r : frag.g;
  }
`;function G$(){return`
    int getOutputCoords() {
      return 0;
    }
  `}function oY(r,e){let t=[Math.ceil(e[0]/2),Math.ceil(e[1]/2)];return t[0]===1?`
      int getOutputCoords() {
        return 2 * int(resultUV.x * ${t[1]}.0);
      }
    `:t[1]===1?`
      int getOutputCoords() {
        return 2 * int(resultUV.y * ${t[0]}.0);
      }
    `:`
    int getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${t[0]}, ${t[1]}));
      return 2 * (resTexRC.x * ${t[1]} + resTexRC.y);
    }
  `}function aY(r,e){return e[0]===1?`
      int getOutputCoords() {
        return int(resultUV.x * ${e[1]}.0);
      }
    `:e[1]===1?`
      int getOutputCoords() {
        return int(resultUV.y * ${e[0]}.0);
      }
    `:`
    int getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${e[0]}, ${e[1]}));
      return resTexRC.x * ${e[1]} + resTexRC.y;
    }
  `}function nY(r,e){let t=[Math.ceil(e[0]/2),Math.ceil(e[1]/2)],o=Math.ceil(r[2]/2),n=o*Math.ceil(r[1]/2);return`
    ivec3 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${t[0]}, ${t[1]}));
      int index = resTexRC.x * ${t[1]} + resTexRC.y;

      int b = index / ${n};
      index -= b * ${n};

      int r = 2 * (index / ${o});
      int c = imod(index, ${o}) * 2;

      return ivec3(b, r, c);
    }
  `}function lY(r,e){let t=zs(["r","c","d"],r);return`
    ivec3 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${e[0]}, ${e[1]}));
      int index = resTexRC.x * ${e[1]} + resTexRC.y;
      ${t}
      return ivec3(r, c, d);
    }
  `}function sY(r,e){let t=[Math.ceil(e[0]/2),Math.ceil(e[1]/2)],o=Math.ceil(r[r.length-1]/2),n=o*Math.ceil(r[r.length-2]/2),s=n,a="",i="b, r, c";for(let l=2;l<r.length-1;l++)s*=r[r.length-l-1],a=`
      int b${l} = index / ${s};
      index -= b${l} * ${s};
    `+a,i=`b${l}, `+i;return`
    ivec${r.length} getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${t[0]}, ${t[1]}));
      int index = resTexRC.x * ${t[1]} + resTexRC.y;

      ${a}

      int b = index / ${n};
      index -= b * ${n};

      int r = 2 * (index / ${o});
      int c = imod(index, ${o}) * 2;

      return ivec${r.length}(${i});
    }
  `}function uY(r,e){let t=zs(["r","c","d","d2"],r);return`
    ivec4 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
        vec2(${e[0]}, ${e[1]}));
      int index = resTexRC.x * ${e[1]} + resTexRC.y;
      ${t}
      return ivec4(r, c, d, d2);
    }
  `}function cY(r,e){let t=zs(["r","c","d","d2","d3"],r);return`
    ivec5 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx * vec2(${e[0]},
                             ${e[1]}));

      int index = resTexRC.x * ${e[1]} + resTexRC.y;

      ${t}

      ivec5 outShape = ivec5(r, c, d, d2, d3);
      return outShape;
    }
  `}function pY(r,e){let t=zs(["r","c","d","d2","d3","d4"],r);return`
    ivec6 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
        vec2(${e[0]}, ${e[1]}));
      int index = resTexRC.x * ${e[1]} + resTexRC.y;

      ${t}

      ivec6 result = ivec6(r, c, d, d2, d3, d4);
      return result;
    }
  `}function iY(r,e){let t=[Math.ceil(e[0]/2),Math.ceil(e[1]/2)];if(y.arraysEqual(r,e))return`
      ivec2 getOutputCoords() {
        return 2 * ivec2(resultUV.yx * vec2(${t[0]}, ${t[1]}));
      }
    `;let o=Math.ceil(r[1]/2);return`
    ivec2 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${t[0]}, ${t[1]}));

      int index = resTexRC.x * ${t[1]} + resTexRC.y;
      int r = 2 * (index / ${o});
      int c = imod(index, ${o}) * 2;

      return ivec2(r, c);
    }
  `}function mY(r,e){return y.arraysEqual(r,e)?`
      ivec2 getOutputCoords() {
        return ivec2(resultUV.yx * vec2(${e[0]}, ${e[1]}));
      }
    `:r[1]===1?`
      ivec2 getOutputCoords() {
        ivec2 resTexRC = ivec2(resultUV.yx *
                               vec2(${e[0]}, ${e[1]}));
        int index = resTexRC.x * ${e[1]} + resTexRC.y;
        return ivec2(index, 0);
      }
    `:r[0]===1?`
      ivec2 getOutputCoords() {
        ivec2 resTexRC = ivec2(resultUV.yx *
                               vec2(${e[0]}, ${e[1]}));
        int index = resTexRC.x * ${e[1]} + resTexRC.y;
        return ivec2(0, index);
      }
    `:`
    ivec2 getOutputCoords() {
      ivec2 resTexRC = ivec2(resultUV.yx *
                             vec2(${e[0]}, ${e[1]}));
      int index = resTexRC.x * ${e[1]} + resTexRC.y;
      int r = index / ${r[1]};
      int c = index - r * ${r[1]};
      return ivec2(r, c);
    }
  `}function lc(r){return`offset${r}`}function Y8(r){let e=r.name,t="get"+e.charAt(0).toUpperCase()+e.slice(1),o=Mt();return`
    vec4 ${t}() {
      return ${o.texture2D}(${e}, halfCR);
    }
  `}function W8(r){let e=r.name,t="get"+e.charAt(0).toUpperCase()+e.slice(1);if(r.shapeInfo.isUniform)return`float ${t}() {return ${e};}`;let[o,n]=r.shapeInfo.texShape;if(o===1&&n===1)return`
      float ${t}() {
        return sampleTexture(${e}, halfCR);
      }
    `;let[s,a]=r.shapeInfo.texShape,i=lc(e);return`
    float ${t}() {
      vec2 uv = uvFromFlat(${s}, ${a}, ${i});
      return sampleTexture(${e}, uv);
    }
  `}function Z8(r){let e=r.name,t="get"+e.charAt(0).toUpperCase()+e.slice(1),o=r.shapeInfo.texShape,n=[Math.ceil(o[0]/2),Math.ceil(o[1]/2)],s=Mt();return`
    vec4 ${t}(int index) {
      vec2 uv = packedUVfrom1D(
        ${n[0]}, ${n[1]}, index);
      return ${s.texture2D}(${e}, uv);
    }
  `}function U8(r){let e=r.name,t="get"+e.charAt(0).toUpperCase()+e.slice(1);if(r.shapeInfo.isUniform)return`
      float ${t}(int index) {
        ${Vp(r)}
      }
    `;let o=r.shapeInfo.texShape,n=o[0],s=o[1];if(s===1&&n===1)return`
      float ${t}(int index) {
        return sampleTexture(${e}, halfCR);
      }
    `;let a=lc(e);return s===1?`
      float ${t}(int index) {
        vec2 uv = vec2(0.5, (float(index + ${a}) + 0.5) / ${n}.0);
        return sampleTexture(${e}, uv);
      }
    `:n===1?`
      float ${t}(int index) {
        vec2 uv = vec2((float(index + ${a}) + 0.5) / ${s}.0, 0.5);
        return sampleTexture(${e}, uv);
      }
    `:`
    float ${t}(int index) {
      vec2 uv = uvFromFlat(${n}, ${s}, index + ${a});
      return sampleTexture(${e}, uv);
    }
  `}function J8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=r.shapeInfo.texShape,s=n[0],a=n[1],i=Mt();if(n!=null&&y.arraysEqual(e,n))return`
      vec4 ${o}(int row, int col) {
        vec2 uv = (vec2(col, row) + halfCR) / vec2(${a}.0, ${s}.0);

        return ${i.texture2D}(${t}, uv);
      }
    `;let l=[Math.ceil(n[0]/2),Math.ceil(n[1]/2)],u=Math.ceil(e[1]/2);return`
    vec4 ${o}(int row, int col) {
      vec2 uv = packedUVfrom2D(${u}, ${l[0]}, ${l[1]}, row, col);
      return ${i.texture2D}(${t}, uv);
    }
  `}function j8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=r.shapeInfo.texShape;if(n!=null&&y.arraysEqual(e,n)){let p=n[0],m=n[1];return`
    float ${o}(int row, int col) {
      vec2 uv = (vec2(col, row) + halfCR) / vec2(${m}.0, ${p}.0);
      return sampleTexture(${t}, uv);
    }
  `}let{newShape:s,keptDims:a}=y.squeezeShape(e),i=s;if(i.length<e.length){let p=Gp(r,i),m=["row","col"];return`
      ${Bp(p)}
      float ${o}(int row, int col) {
        return ${o}(${Wp(m,a)});
      }
    `}if(r.shapeInfo.isUniform)return`
      float ${o}(int row, int col) {
        int index = round(dot(vec2(row, col), vec2(${e[1]}, 1)));
        ${Vp(r)}
      }
    `;let l=n[0],u=n[1],c=lc(t);return u===1?`
    float ${o}(int row, int col) {
      float index = dot(vec3(row, col, ${c}), vec3(${e[1]}, 1, 1));
      vec2 uv = vec2(0.5, (index + 0.5) / ${l}.0);
      return sampleTexture(${t}, uv);
    }
  `:l===1?`
    float ${o}(int row, int col) {
      float index = dot(vec3(row, col, ${c}), vec3(${e[1]}, 1, 1));
      vec2 uv = vec2((index + 0.5) / ${u}.0, 0.5);
      return sampleTexture(${t}, uv);
    }
  `:`
  float ${o}(int row, int col) {
    // Explicitly use integer operations as dot() only works on floats.
    int index = row * ${e[1]} + col + ${c};
    vec2 uv = uvFromFlat(${l}, ${u}, index);
    return sampleTexture(${t}, uv);
  }
`}function Q8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=r.shapeInfo.texShape,s=[Math.ceil(n[0]/2),Math.ceil(n[1]/2)];if(e[0]===1){let p=e.slice(1),m=[1,2],f=Gp(r,p),d=["b","row","col"];return`
        ${V$(f)}
        vec4 ${o}(int b, int row, int col) {
          return ${o}(${Wp(d,m)});
        }
      `}let a=s[0],i=s[1],l=Math.ceil(e[2]/2),u=l*Math.ceil(e[1]/2),c=Mt();return`
    vec4 ${o}(int b, int row, int col) {
      vec2 uv = packedUVfrom3D(
        ${a}, ${i}, ${u}, ${l}, b, row, col);
      return ${c.texture2D}(${t}, uv);
    }
  `}function H8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=e[1]*e[2],s=e[2],{newShape:a,keptDims:i}=y.squeezeShape(e),l=a;if(l.length<e.length){let d=Gp(r,l),h=["row","col","depth"];return`
        ${Bp(d)}
        float ${o}(int row, int col, int depth) {
          return ${o}(${Wp(h,i)});
        }
      `}if(r.shapeInfo.isUniform)return`
      float ${o}(int row, int col, int depth) {
        int index = round(dot(vec3(row, col, depth),
                          vec3(${n}, ${s}, 1)));
        ${Vp(r)}
      }
    `;let u=r.shapeInfo.texShape,c=u[0],p=u[1],m=r.shapeInfo.flatOffset;if(p===n&&m==null)return`
        float ${o}(int row, int col, int depth) {
          float texR = float(row);
          float texC = dot(vec2(col, depth), vec2(${s}, 1));
          vec2 uv = (vec2(texC, texR) + halfCR) /
                     vec2(${p}.0, ${c}.0);
          return sampleTexture(${t}, uv);
        }
      `;if(p===s&&m==null)return`
    float ${o}(int row, int col, int depth) {
      float texR = dot(vec2(row, col), vec2(${e[1]}, 1));
      float texC = float(depth);
      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${p}.0, ${c}.0);
      return sampleTexture(${t}, uv);
    }
  `;let f=lc(t);return`
      float ${o}(int row, int col, int depth) {
        // Explicitly use integer operations as dot() only works on floats.
        int index = row * ${n} + col * ${s} + depth + ${f};
        vec2 uv = uvFromFlat(${c}, ${p}, index);
        return sampleTexture(${t}, uv);
      }
  `}function eY(r){let e=r.shapeInfo.logicalShape,t=e.length,o=r.name,n="get"+o.charAt(0).toUpperCase()+o.slice(1),s=r.shapeInfo.texShape,a=[Math.ceil(s[0]/2),Math.ceil(s[1]/2)],i=a[0],l=a[1],u=Math.ceil(e[t-1]/2),c=u*Math.ceil(e[t-2]/2),p="int b, int row, int col",m=`b * ${c} + (row / 2) * ${u} + (col / 2)`;for(let d=2;d<t-1;d++)p=`int b${d}, `+p,c*=e[t-d-1],m=`b${d} * ${c} + `+m;let f=Mt();return`
    vec4 ${n}(${p}) {
      int index = ${m};
      int texR = index / ${l};
      int texC = index - texR * ${l};
      vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${l}, ${i});
      return ${f.texture2D}(${o}, uv);
    }
  `}function q8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=e[3],s=e[2]*n,a=e[1]*s,{newShape:i,keptDims:l}=y.squeezeShape(e);if(i.length<e.length){let d=Gp(r,i),h=["row","col","depth","depth2"];return`
      ${Bp(d)}
      float ${o}(int row, int col, int depth, int depth2) {
        return ${o}(${Wp(h,l)});
      }
    `}if(r.shapeInfo.isUniform)return`
      float ${o}(int row, int col, int depth, int depth2) {
        int index = round(dot(vec4(row, col, depth, depth2),
                          vec4(${a}, ${s}, ${n}, 1)));
        ${Vp(r)}
      }
    `;let u=r.shapeInfo.flatOffset,c=r.shapeInfo.texShape,p=c[0],m=c[1];if(m===a&&u==null)return`
      float ${o}(int row, int col, int depth, int depth2) {
        float texR = float(row);
        float texC =
            dot(vec3(col, depth, depth2),
                vec3(${s}, ${n}, 1));
        vec2 uv = (vec2(texC, texR) + halfCR) /
                   vec2(${m}.0, ${p}.0);
        return sampleTexture(${t}, uv);
      }
    `;if(m===n&&u==null)return`
      float ${o}(int row, int col, int depth, int depth2) {
        float texR = dot(vec3(row, col, depth),
                         vec3(${e[1]*e[2]}, ${e[2]}, 1));
        float texC = float(depth2);
        vec2 uv = (vec2(texC, texR) + halfCR) /
                  vec2(${m}.0, ${p}.0);
        return sampleTexture(${t}, uv);
      }
    `;let f=lc(t);return`
    float ${o}(int row, int col, int depth, int depth2) {
      // Explicitly use integer operations as dot() only works on floats.
      int index = row * ${a} + col * ${s} +
          depth * ${n} + depth2;
      vec2 uv = uvFromFlat(${p}, ${m}, index + ${f});
      return sampleTexture(${t}, uv);
    }
  `}function K8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),n=e[4],s=e[3]*n,a=e[2]*s,i=e[1]*a,{newShape:l,keptDims:u}=y.squeezeShape(e);if(l.length<e.length){let h=Gp(r,l),g=["row","col","depth","depth2","depth3"];return`
      ${Bp(h)}
      float ${o}(int row, int col, int depth, int depth2, int depth3) {
        return ${o}(${Wp(g,u)});
      }
    `}if(r.shapeInfo.isUniform)return`
      float ${o}(int row, int col, int depth, int depth2, int depth3) {
        float index = dot(
          vec4(row, col, depth, depth2),
          vec4(${i}, ${a}, ${s}, ${n})) +
          depth3;
        ${Vp(r)}
      }
    `;let c=r.shapeInfo.flatOffset,p=r.shapeInfo.texShape,m=p[0],f=p[1];if(f===i&&c==null)return`
      float ${o}(int row, int col, int depth, int depth2, int depth3) {
        int texR = row;
        float texC = dot(vec4(col, depth, depth2, depth3),
                         vec4(${a}, ${s}, ${n}, 1));
        vec2 uv = (vec2(texC, texR) + halfCR) /
                   vec2(${f}.0, ${m}.0);
        return sampleTexture(${t}, uv);
      }
    `;if(f===n&&c==null)return`
      float ${o}(int row, int col, int depth, int depth2, int depth3) {
        float texR = dot(
          vec4(row, col, depth, depth2),
          vec4(${e[1]*e[2]*e[3]},
               ${e[2]*e[3]}, ${e[3]}, 1));
        int texC = depth3;
        vec2 uv = (vec2(texC, texR) + halfCR) /
                  vec2(${f}.0, ${m}.0);
        return sampleTexture(${t}, uv);
      }
    `;let d=lc(t);return`
    float ${o}(int row, int col, int depth, int depth2, int depth3) {
      // Explicitly use integer operations as dot() only works on floats.
      int index = row * ${i} + col * ${a} + depth * ${s} +
          depth2 * ${n} + depth3 + ${d};
      vec2 uv = uvFromFlat(${m}, ${f}, index);
      return sampleTexture(${t}, uv);
    }
  `}function X8(r){let e=r.shapeInfo.logicalShape,t=r.name,o="get"+t.charAt(0).toUpperCase()+t.slice(1),{newShape:n,keptDims:s}=y.squeezeShape(e);if(n.length<e.length){let g=Gp(r,n),x=["row","col","depth","depth2","depth3","depth4"];return`
      ${Bp(g)}
      float ${o}(int row, int col, int depth,
                    int depth2, int depth3, int depth4) {
        return ${o}(${Wp(x,s)});
      }
    `}let a=e[5],i=e[4]*a,l=e[3]*i,u=e[2]*l,c=e[1]*u;if(r.shapeInfo.isUniform)return`
      float ${o}(int row, int col, int depth,
                  int depth2, int depth3, int depth4) {
        int index = round(dot(
          vec4(row, col, depth, depth2),
          vec4(${c}, ${u}, ${l}, ${i})) +
          dot(
            vec2(depth3, depth4),
            vec2(${a}, 1)));
        ${Vp(r)}
      }
    `;let p=r.shapeInfo.flatOffset,m=r.shapeInfo.texShape,f=m[0],d=m[1];if(d===c&&p==null)return`
      float ${o}(int row, int col, int depth,
                    int depth2, int depth3, int depth4) {
        int texR = row;
        float texC = dot(vec4(col, depth, depth2, depth3),
          vec4(${u}, ${l}, ${i}, ${a})) +
               float(depth4);
        vec2 uv = (vec2(texC, texR) + halfCR) /
                   vec2(${d}.0, ${f}.0);
        return sampleTexture(${t}, uv);
      }
    `;if(d===a&&p==null)return`
      float ${o}(int row, int col, int depth,
                    int depth2, int depth3, int depth4) {
        float texR = dot(vec4(row, col, depth, depth2),
          vec4(${e[1]*e[2]*e[3]*e[4]},
               ${e[2]*e[3]*e[4]},
               ${e[3]*e[4]},
               ${e[4]})) + float(depth3);
        int texC = depth4;
        vec2 uv = (vec2(texC, texR) + halfCR) /
                  vec2(${d}.0, ${f}.0);
        return sampleTexture(${t}, uv);
      }
    `;let h=lc(t);return`
    float ${o}(int row, int col, int depth,
                  int depth2, int depth3, int depth4) {
      // Explicitly use integer operations as dot() only works on floats.
      int index = row * ${c} + col * ${u} + depth * ${l} +
          depth2 * ${i} + depth3 * ${a} + depth4 + ${h};
      vec2 uv = uvFromFlat(${f}, ${d}, index);
      return sampleTexture(${t}, uv);
    }
  `}function Vp(r){let e=r.name,t=y.sizeFromShape(r.shapeInfo.logicalShape);return t<2?`return ${e};`:`
    for (int i = 0; i < ${t}; i++) {
      if (i == index) {
        return ${e}[i];
      }
    }
  `}function tY(r,e){let t=r.name,o=t.charAt(0).toUpperCase()+t.slice(1),n="get"+o+"AtOutCoords",s=r.shapeInfo.logicalShape.length,a=e.logicalShape.length,i=z$(r.shapeInfo.logicalShape,e.logicalShape),l=Le(a),u=a-s,c,p=["x","y","z","w","u","v"];s===0?c="":a<2&&i.length>=1?c="coords = 0;":c=i.map(b=>`coords.${p[b+u]} = 0;`).join(`
`);let m="";a<2&&s>0?m="coords":m=r.shapeInfo.logicalShape.map((b,_)=>`coords.${p[_+u]}`).join(", ");let f="return outputValue;",h=y.sizeFromShape(r.shapeInfo.logicalShape)===1,x=y.sizeFromShape(e.logicalShape)===1;if(s===1&&!h&&!x)f=`
      return vec4(outputValue.xy, outputValue.xy);
    `;else if(h&&!x)a===1?f=`
        return vec4(outputValue.x, outputValue.x, 0., 0.);
      `:f=`
        return vec4(outputValue.x);
      `;else if(i.length){let b=s-2,_=s-1;i.indexOf(b)>-1&&i.indexOf(_)>-1?f="return vec4(outputValue.x);":i.indexOf(b)>-1?f="return vec4(outputValue.x, outputValue.y, outputValue.x, outputValue.y);":i.indexOf(_)>-1&&(f="return vec4(outputValue.xx, outputValue.zz);")}return`
    vec4 ${n}() {
      ${l} coords = getOutputCoords();
      ${c}
      vec4 outputValue = get${o}(${m});
      ${f}
    }
  `}function rY(r,e){let t=r.name,o=t.charAt(0).toUpperCase()+t.slice(1),n="get"+o+"AtOutCoords",s=e.texShape,a=r.shapeInfo.texShape,i=r.shapeInfo.logicalShape.length,l=e.logicalShape.length;if(!r.shapeInfo.isUniform&&i===l&&r.shapeInfo.flatOffset==null&&y.arraysEqual(a,s))return`
      float ${n}() {
        return sampleTexture(${t}, resultUV);
      }
    `;let u=Le(l),c=z$(r.shapeInfo.logicalShape,e.logicalShape),p=l-i,m,f=["x","y","z","w","u","v"];i===0?m="":l<2&&c.length>=1?m="coords = 0;":m=c.map(h=>`coords.${f[h+p]} = 0;`).join(`
`);let d="";return l<2&&i>0?d="coords":d=r.shapeInfo.logicalShape.map((h,g)=>`coords.${f[g+p]}`).join(", "),`
    float ${n}() {
      ${u} coords = getOutputCoords();
      ${m}
      return get${o}(${d});
    }
  `}function Le(r){if(r<=1)return"int";if(r===2)return"ivec2";if(r===3)return"ivec3";if(r===4)return"ivec4";if(r===5)return"ivec5";if(r===6)return"ivec6";throw Error(`GPU for rank ${r} is not yet supported`)}function Gp(r,e){let t=JSON.parse(JSON.stringify(r));return t.shapeInfo.logicalShape=e,t}function Wp(r,e){return e.map(t=>r[t]).join(", ")}function W$(r,e,t,o){let n=e.userCode,s=t.map((f,d)=>{let h={logicalShape:f.shape,texShape:f.isUniform?null:f.texData.texShape,isUniform:f.isUniform,isPacked:f.isUniform?!1:f.texData.isPacked,flatOffset:null};return f.texData!=null&&f.texData.slice!=null&&f.texData.slice.flatOffset>0&&(h.flatOffset=f.texData.slice.flatOffset),{name:e.variableNames[d],shapeInfo:h}}),a=s.map(f=>f.shapeInfo),i={logicalShape:o.shape,texShape:o.texData.texShape,isUniform:!1,isPacked:o.texData.isPacked,flatOffset:null},l=B$(s,i,n,e.packedInputs),u=r.createProgram(l),c=null,p=r.getUniformLocation(u,"NAN",!1);G().getNumber("WEBGL_VERSION")===1&&(c=r.getUniformLocation(u,"INFINITY",!1));let m={};for(let f=0;f<e.variableNames.length;f++){let d=e.variableNames[f],h=!1;m[d]=r.getUniformLocation(u,d,h),m[`offset${d}`]=r.getUniformLocation(u,`offset${d}`,h)}return{program:e,source:l,webGLProgram:u,uniformLocations:m,inShapeInfos:a,outShapeInfo:i,infLoc:c,nanLoc:p}}function U$(r,e){if(r.length!==e.length)throw Error(`Binary was compiled with ${r.length} inputs, but was executed with ${e.length} inputs`);r.forEach((t,o)=>{let n=t.logicalShape,s=e[o],a=s.shape;if(!y.arraysEqual(n,a))throw Error(`Binary was compiled with different shapes than the current args. Shapes ${n} and ${a} must match`);if(t.isUniform&&s.isUniform)return;let i=t.texShape,l=s.isUniform?null:s.texData.texShape;if(!y.arraysEqual(i,l))throw Error(`Binary was compiled with different texture shapes than the current args. Shape ${i} and ${l} must match`)})}function j$(r,e,t,o,n){U$(e.inShapeInfos,t),U$([e.outShapeInfo],[o]);let s=o.texData.texture,a=o.texData.texShape;o.texData.isPacked?r.setOutputPackedMatrixTexture(s,a[0],a[1]):r.setOutputMatrixTexture(s,a[0],a[1]),r.setProgram(e.webGLProgram),G().getNumber("WEBGL_VERSION")===1&&e.infLoc!==null&&r.gl.uniform1f(e.infLoc,Infinity),e.nanLoc!==null&&r.gl.uniform1f(e.nanLoc,NaN),t.forEach((i,l)=>{let u=e.program.variableNames[l],c=e.uniformLocations[u],p=e.uniformLocations[`offset${u}`];if(c!=null){if(i.isUniform){if(y.sizeFromShape(i.shape)<2)r.gl.uniform1f(c,i.uniformValues[0]);else{let m=i.uniformValues;m instanceof Float32Array||(m=new Float32Array(m)),r.gl.uniform1fv(c,m)}return}i.texData.slice!=null&&p!=null&&r.gl.uniform1i(p,i.texData.slice.flatOffset),r.setInputMatrixTexture(i.texData.texture,c,l)}}),n!=null&&n(r,e.webGLProgram),r.executeProgram()}function H$(r,e,t){let o="";e.concat(t).forEach(a=>{let i=a.texData!=null&&a.texData.slice!=null&&a.texData.slice.flatOffset>0,l=a.isUniform?"uniform":a.texData.texShape;o+=`${a.shape}_${l}_${i}`});let n=r.userCode,s=r.constructor.name;return s+="_"+o+"_"+n,s}var{addImpl:q$,bincountImpl:Rx,bincountReduceImpl:K$,ceilImpl:X$,concatImpl:Y$,expImpl:Z$,expm1Impl:J$,floorImpl:Q$,gatherV2Impl:eR,greaterImpl:tR,lessImpl:rR,linSpaceImpl:oR,logImpl:nR,maxImpl:sR,maximumImpl:iR,minimumImpl:aR,multiplyImpl:lR,negImpl:uR,prodImpl:cR,rangeImpl:pR,rsqrtImpl:mR,simpleAbsImpl:Fx,sliceImpl:fR,stridedSliceImpl:dR,subImpl:hR,tileImpl:gR,topKImpl:xR,transposeImpl:Up,uniqueImpl:yR}=Wk;function kv(r,e){return["x","y","z","w","u","v"].slice(0,e).map(t=>`${r}.${t}`)}function Ut(r,e){return e===1?[r]:kv(r,e)}function bR(r,e){if(r===1)return"rc";let t="";for(let o=0;o<r;o++)t+=e[o],o<r-1&&(t+=",");return t}var vv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!1,this.packedOutput=!0,this.outputShape=e;let t=e.length;if(t===0)this.userCode=`
        void main() {
          setOutput(vec4(getA(), 0., 0., 0.));
        }
      `;else{let o=Ut("rc",t),n=Le(t),s=gY(t,e,o),a=xY(t,e[e.length-1],e[e.length-2],o),i=yY(e,o);this.userCode=`
        void main() {
          ${n} rc = getOutputCoords();

          if(${s}) {
            setOutput(vec4(0));
          } else {
            ${a}

            setOutput(vec4(${i}));
          }
        }
      `}}};function bY(r,e){let t=[];for(let o=0;o<=1;o++)for(let n=0;n<=1;n++){let s=`${o===0?"r":"rp1"}, ${n===0?"c":"cp1"}`;for(let a=2;a<r;a++)s=`${e[e.length-1-a]},`+s;t.push(s)}return t}function gY(r,e,t){if(r===1)return`rc > ${e[0]}`;let o="";for(let n=r-2;n<r;n++)o+=`${t[n]} >= ${e[n]}`,n<r-1&&(o+="||");return o}function xY(r,e,t,o){if(r===1)return"";let n=o.slice(-2);return`
    int r = ${n[0]};
    int c = ${n[1]};
    int rp1 = r + 1;
    int cp1 = c + 1;

    bool cEdge = cp1 >= ${e};
    bool rEdge = rp1 >= ${t};
  `}function yY(r,e){let t=r.length,o=bY(t,e);return t===1?`getA(rc),
            rc + 1 >= ${r[0]} ? 0. : getA(rc + 1),
            0, 0`:`getA(${o[0]}),
          cEdge ? 0. : getA(${o[1]}),
          rEdge ? 0. : getA(${o[2]}),
          rEdge || cEdge ? 0. : getA(${o[3]})`}var nh=class{constructor(e,t){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e;let o="";for(let n=0;n<4;n++){let s="thisRC = rc;";n%2==1&&(s+="thisRC.z += 1;"),n>1&&(s+="thisRC.y += 1;"),o+=`
        ${s}
        ${n>0?"if(thisRC.y < rows && thisRC.z < cols){":""}
          int flatIndex = getFlatIndex(thisRC);

          ivec3 inputRC = inputCoordsFromReshapedOutCoords(flatIndex);
          vec2 inputRCInnerDims = vec2(float(inputRC.y),float(inputRC.z));

          result[${n}] =
            getChannel(getA(inputRC.x, inputRC.y, inputRC.z), inputRCInnerDims);
        ${n>0?"}":""}
      `}this.userCode=`
      ${_Y(t)}
      ${zp(e)}

      void main() {
        ivec3 rc = getOutputCoords();

        vec4 result = vec4(0.);

        ivec3 thisRC;
        int rows = ${e[1]};
        int cols = ${e[2]};

        ${o}

        setOutput(result);
      }
    `}};function _Y(r){return`
    ivec3 inputCoordsFromReshapedOutCoords(int index) {
      ${zs(["r","c","d"],r)}
      return ivec3(r, c, d);
    }
  `}var Cv=class{constructor(e){this.gpgpu=e,this.numUsedTextures=0,this.numFreeTextures=0,this._numBytesAllocated=0,this._numBytesFree=0,this.freeTextures={},this.logEnabled=!1,this.usedTextures={}}acquireTexture(e,t,o){let n=wR(t,o),s=kR(e,n,o);s in this.freeTextures||(this.freeTextures[s]=[]),s in this.usedTextures||(this.usedTextures[s]=[]);let a=_R(e,n,this.gpgpu.gl,this.gpgpu.textureConfig,o);if(this.freeTextures[s].length>0){this.numFreeTextures--,this.numUsedTextures++,this._numBytesFree-=a,this.log();let l=this.freeTextures[s].shift();return this.usedTextures[s].push(l),l}let i;return n===br.PACKED_2X2_FLOAT32?i=this.gpgpu.createPackedMatrixTexture(e[0],e[1]):n===br.PACKED_2X2_FLOAT16?i=this.gpgpu.createFloat16PackedMatrixTexture(e[0],e[1]):n===br.UNPACKED_FLOAT32?i=this.gpgpu.createFloat32MatrixTexture(e[0],e[1]):n===br.UNPACKED_FLOAT16?i=this.gpgpu.createFloat16MatrixTexture(e[0],e[1]):n===br.PACKED_4X1_UNSIGNED_BYTE&&(i=this.gpgpu.createUnsignedBytesMatrixTexture(e[0],e[1])),this.usedTextures[s].push(i),this.numUsedTextures++,this._numBytesAllocated+=a,this.log(),i}releaseTexture(e,t,o,n){if(this.freeTextures==null)return;let s=wR(o,n),a=kR(t,s,n);a in this.freeTextures||(this.freeTextures[a]=[]);let i=_R(t,s,this.gpgpu.gl,this.gpgpu.textureConfig,n),l=G().get("WEBGL_DELETE_TEXTURE_THRESHOLD");l!==-1&&this._numBytesAllocated>l?(this.gpgpu.deleteMatrixTexture(e),this._numBytesAllocated-=i):(this.freeTextures[a].push(e),this.numFreeTextures++,this._numBytesFree+=i),this.numUsedTextures--;let u=this.usedTextures[a],c=u.indexOf(e);if(c<0)throw new Error("Cannot release a texture that was never provided by this texture manager");u.splice(c,1),this.log()}log(){if(!this.logEnabled)return;let e=this.numFreeTextures+this.numUsedTextures;console.log("Free/Used",`${this.numFreeTextures} / ${this.numUsedTextures}`,`(${e})`);let t=this._numBytesFree/this._numBytesAllocated;console.log(`Bytes allocated: ${this._numBytesAllocated}`),console.log(`Bytes unused: ${this._numBytesFree} (${Math.round(100*t)}%)`)}get numBytesAllocated(){return this._numBytesAllocated}get numBytesFree(){return this._numBytesFree}getNumUsedTextures(){return this.numUsedTextures}getNumFreeTextures(){return this.numFreeTextures}dispose(){if(this.freeTextures!=null){for(let e in this.freeTextures)this.freeTextures[e].forEach(t=>{this.gpgpu.deleteMatrixTexture(t)});for(let e in this.usedTextures)this.usedTextures[e].forEach(t=>{this.gpgpu.deleteMatrixTexture(t)});this.freeTextures=null,this.usedTextures=null,this.numUsedTextures=0,this.numFreeTextures=0,this._numBytesAllocated=0,this._numBytesFree=0}}};function wY(r,e){let t=r;if(e===t.R32F)return 4;if(e===t.R16F)return 2;if(e===t.RGBA32F)return 16;if(e===r.RGBA)return 16;if(e===t.RGBA16F)return 8;throw new Error(`Unknown internal format ${e}`)}function _R(r,e,t,o,n){let s=kY(e,o),a;if(n){let[l,u]=Xi(r[0],r[1]);a=l*u}else{let[l,u]=ic(r[0],r[1]);a=l*u}let i=wY(t,s);return a*i}function kY(r,e){switch(r){case br.PACKED_2X2_FLOAT32:return bv(e);case br.PACKED_2X2_FLOAT16:return _v(e);case br.UNPACKED_FLOAT32:return gv(e);case br.UNPACKED_FLOAT16:return xv(e);case br.PACKED_4X1_UNSIGNED_BYTE:return yv(e);default:throw new Error(`Unknown physical texture type ${r}`)}}function vY(r){return G().getBool("WEBGL_RENDER_FLOAT32_ENABLED")?r?br.PACKED_2X2_FLOAT32:br.UNPACKED_FLOAT32:r?br.PACKED_2X2_FLOAT16:br.UNPACKED_FLOAT16}function wR(r,e){if(r===Er.UPLOAD)return br.PACKED_2X2_FLOAT32;if(r===Er.RENDER||r==null)return vY(e);if(r===Er.DOWNLOAD||r===Er.PIXELS)return br.PACKED_4X1_UNSIGNED_BYTE;throw new Error(`Unknown logical texture type ${r}`)}function kR(r,e,t){return`${r[0]}_${r[1]}_${e}_${t}`}var uo=class{constructor(e,t){this.variableNames=["A"],this.outputShape=e,this.userCode=`
      float unaryOperation(float x) {
        ${t}
      }

      void main() {
        float x = getAAtOutCoords();
        float y = unaryOperation(x);

        setOutput(y);
      }
    `}},gr="if (isnan(x)) return x;",vR="return x;",Iv="return abs(x);";var CR="return (x >= 0.0) ? x : (exp(x) - 1.0);",IR=gr+`
  return (x < 0.0) ? 0.0 : x;
`,NR=gr+`
  return (x < 0.0) ? 0.0 : min(6.0, x);
`,sh="return x;";var SR="return x;",TR=`
  vec4 result;

  result.r = (x.r >= 0.0) ? x.r : (exp(x.r) - 1.0);
  result.g = (x.g >= 0.0) ? x.g : (exp(x.g) - 1.0);
  result.b = (x.b >= 0.0) ? x.b : (exp(x.b) - 1.0);
  result.a = (x.a >= 0.0) ? x.a : (exp(x.a) - 1.0);

  return result;
`,ER=`
  vec4 result = x * vec4(greaterThanEqual(x, vec4(0.0)));
  bvec4 isNaN = isnan(x);

  result.r = isNaN.r ? x.r : result.r;
  result.g = isNaN.g ? x.g : result.g;
  result.b = isNaN.b ? x.b : result.b;
  result.a = isNaN.a ? x.a : result.a;

  return result;
`,AR=`
  vec4 result = min(x, vec4(6.)) * vec4(greaterThanEqual(x, vec4(0.0)));
  bvec4 isNaN = isnan(x);

  result.r = isNaN.r ? x.r : result.r;
  result.g = isNaN.g ? x.g : result.g;
  result.b = isNaN.b ? x.b : result.b;
  result.a = isNaN.a ? x.a : result.a;

  return result;
`,Bs=class{constructor(e,t){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e,this.userCode=`
      vec4 unaryOperation(vec4 x) {
        ${t}
      }

      void main() {
        vec4 x = getAAtOutCoords();
        vec4 y = unaryOperation(x);

        setOutput(y);
      }
    `}};var Nv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!1,this.outputShape=e;let t=e.length,o=Ut("rc",t),n=Le(t),s=bR(t,o),a=o.slice(-2),i=t<=1?"rc":`vec2(${a.join(",")})`;this.userCode=`
      void main() {
        ${n} rc = getOutputCoords();
        vec4 packedInput = getA(${s});

        setOutput(getChannel(packedInput, ${i}));
      }
    `}};var CY=Sr.whereImpl,IY=1e-7,NY=1e-4,Ox={};function SY(r){return r in Ox||(Ox[r]={}),Ox[r]}var TY=128,EY=600;function AY(){return G().global.screen==null?1024:G().global.screen.height*G().global.screen.width*window.devicePixelRatio*EY/1024/1024}var Sv=class extends Ws{constructor(e){super();if(this.pendingRead=new WeakMap,this.pendingDisposal=new WeakSet,this.dataRefCount=new WeakMap,this.numBytesInGPU=0,this.uploadWaitMs=0,this.downloadWaitMs=0,this.warnedAboutMemory=!1,this.warnedAboutCPUBackend=!1,this.pendingDeletes=0,this.disposed=!1,!G().getBool("HAS_WEBGL"))throw new Error("WebGL is not supported on this device");if(e==null){let t=Lo(G().getNumber("WEBGL_VERSION"));this.binaryCache=SY(G().getNumber("WEBGL_VERSION")),this.gpgpu=new wv(t),this.canvas=t.canvas,this.gpgpuCreatedLocally=!0}else this.gpgpu=e,this.binaryCache={},this.gpgpuCreatedLocally=!1,this.canvas=e.gl.canvas;this.textureManager=new Cv(this.gpgpu),this.numMBBeforeWarning=AY(),this.texData=new Ya(this,vs())}numDataIds(){return this.texData.numDataIds()+(this.cpuBackend?this.cpuBackend.numDataIds():0)-this.pendingDeletes}write(e,t,o){if((G().getBool("WEBGL_CHECK_NUMERICAL_PROBLEMS")||G().getBool("DEBUG"))&&this.checkNumericalProblems(e),o==="complex64"&&e!=null)throw new Error("Cannot write to a complex64 dtype. Please use tf.complex(real, imag).");let n={};return this.texData.set(n,{shape:t,dtype:o,values:e,usage:Er.UPLOAD,refCount:1,complexParentRefCount:0}),n}incRef(e){let t=this.texData.get(e);t.refCount++}decRef(e){if(this.texData.has(e)){let t=this.texData.get(e);t.refCount--}}decComplexRef(e){if(this.texData.has(e)){let t=this.texData.get(e);t.complexParentRefCount>0&&t.refCount--}}move(e,t,o,n){if(G().getBool("DEBUG")&&this.checkNumericalProblems(t),n==="complex64")throw new Error("Cannot write to a complex64 dtype. Please use tf.complex(real, imag).");this.texData.set(e,{shape:o,dtype:n,values:t,usage:Er.UPLOAD,refCount:1,complexParentRefCount:0})}disposeIntermediateTensorInfo(e){let t=e.dataId;if(this.texData.has(t)){let o=this.texData.get(t);o.refCount--,o.refCount<1&&this.disposeData(t)}}readSync(e){let t=this.texData.get(e),{values:o,dtype:n,complexTensorInfos:s,slice:a,shape:i,isPacked:l}=t;if(a!=null){let m;l?m=new Bs(i,sh):m=new uo(i,sh);let f=this.runWebGLProgram(m,[{dataId:e,shape:i,dtype:n}],n),d=this.readSync(f.dataId);return this.disposeIntermediateTensorInfo(f),d}if(o!=null)return this.convertAndCacheOnCPU(e);if(n==="string")return o;let u=this.activeTimers!=null,c;u&&(c=y.now());let p;if(n==="complex64"){let m=this.readSync(s.real.dataId),f=this.readSync(s.imag.dataId);p=N.mergeRealAndImagArrays(m,f)}else p=this.getValuesFromTexture(e);return u&&(this.downloadWaitMs+=y.now()-c),this.convertAndCacheOnCPU(e,p)}async read(e){if(this.pendingRead.has(e)){let d=this.pendingRead.get(e);return new Promise(h=>d.push(h))}let t=this.texData.get(e),{values:o,shape:n,slice:s,dtype:a,complexTensorInfos:i,isPacked:l}=t;if(s!=null){let d;l?d=new Bs(n,sh):d=new uo(n,sh);let h=this.runWebGLProgram(d,[{dataId:e,shape:n,dtype:a}],a),g=this.read(h.dataId);return this.disposeIntermediateTensorInfo(h),g}if(o!=null)return this.convertAndCacheOnCPU(e);if(!G().getBool("WEBGL_DOWNLOAD_FLOAT_ENABLED")&&G().getNumber("WEBGL_VERSION")===2)throw new Error("tensor.data() with WEBGL_DOWNLOAD_FLOAT_ENABLED=false and WEBGL_VERSION=2 not yet supported.");let u=null,c;if(a!=="complex64"&&G().get("WEBGL_BUFFER_SUPPORTED")){c=this.decode(e);let d=this.texData.get(c.dataId);u=this.gpgpu.createBufferFromTexture(d.texture,...Il(n))}this.pendingRead.set(e,[]),a!=="complex64"&&await this.gpgpu.createAndWaitForFence();let p;if(a==="complex64"){let d=await Promise.all([this.read(i.real.dataId),this.read(i.imag.dataId)]),h=d[0],g=d[1];p=N.mergeRealAndImagArrays(h,g)}else if(u==null)p=this.getValuesFromTexture(e);else{let d=y.sizeFromShape(n);p=this.gpgpu.downloadFloat32MatrixFromBuffer(u,d)}c!=null&&this.disposeIntermediateTensorInfo(c);let m=this.convertAndCacheOnCPU(e,p),f=this.pendingRead.get(e);return this.pendingRead.delete(e),f.forEach(d=>d(m)),this.pendingDispo
  if (isnan(a)) return a;
  if (isnan(b)) return b;
`;var Qn=class{constructor(e,t,o){this.variableNames=["A","B"],this.outputShape=N.assertAndGetBroadcastShape(t,o),this.userCode=`
      float binaryOperation(float a, float b) {
        ${e}
      }

      void main() {
        float a = getAAtOutCoords();
        float b = getBAtOutCoords();
        setOutput(binaryOperation(a, b));
      }
    `}};var Tl=`
  result.r = isNaN.r > 0. ? NAN : result.r;
  result.g = isNaN.g > 0. ? NAN : result.g;
  result.b = isNaN.b > 0. ? NAN : result.b;
  result.a = isNaN.a > 0. ? NAN : result.a;
`;var Vs=class{constructor(e,t,o,n=!1){this.variableNames=["A","B"],this.supportsBroadcasting=!0,this.packedInputs=!0,this.packedOutput=!0,this.outputShape=N.assertAndGetBroadcastShape(t,o);let s=this.outputShape.length,a="";if(n)if(s===0||y.sizeFromShape(this.outputShape)===1)a=`
          result.y = 0.;
          result.z = 0.;
          result.w = 0.;
        `;else if(a=`
          ${Le(s)} coords = getOutputCoords();
        `,s===1)a+=`
            result.y = (coords + 1) >= ${this.outputShape[0]} ? 0. : result.y;
            result.z = 0.;
            result.w = 0.;
          `;else{let l=Ut("coords",s);a+=`
            bool nextRowOutOfBounds =
              (${l[s-2]} + 1) >= ${this.outputShape[s-2]};
            bool nextColOutOfBounds =
              (${l[s-1]} + 1) >= ${this.outputShape[s-1]};
            result.y = nextColOutOfBounds ? 0. : result.y;
            result.z = nextRowOutOfBounds ? 0. : result.z;
            result.w = nextColOutOfBounds || nextRowOutOfBounds ? 0. : result.w;
          `}this.userCode=`
      vec4 binaryOperation(vec4 a, vec4 b) {
        ${e}
      }

      void main() {
        vec4 a = getAAtOutCoords();
        vec4 b = getBAtOutCoords();

        vec4 result = binaryOperation(a, b);
        ${a}

        setOutput(result);
      }
    `}};function jt(r){let{inputs:e,backend:t}=r,{x:o}=e;return t.incRef(o.dataId),{dataId:o.dataId,shape:o.shape,dtype:o.dtype}}var $R={kernelName:us,backendName:"webgl",kernelFunc:jt};function co(r){let{inputs:e,backend:t}=r,{real:o,imag:n}=e,s=t.makeTensorInfo(o.shape,"complex64"),a=t.texData.get(s.dataId),i=jt({inputs:{x:o},backend:t}),l=t.texData.get(i.dataId);l.complexParentRefCount++;let u=jt({inputs:{x:n},backend:t}),c=t.texData.get(u.dataId);return c.complexParentRefCount++,a.complexTensorInfos={real:i,imag:u},s}var RR={kernelName:Hl,backendName:"webgl",kernelFunc:co};var Tv="return (a < 0.) ? b * a : a;",Ev=`
  vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
  return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
`;function $Y(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{alpha:s}=o,a=t.makeTensorInfo([],"float32",y.createScalarValue(s,"float32")),i=G().getBool("WEBGL_PACK_BINARY_OPERATIONS")?new Vs(Ev,n.shape,a.shape):new Qn(Tv,n.shape,a.shape),l=t.runWebGLProgram(i,[n,a],n.dtype);return t.disposeIntermediateTensorInfo(a),l}var FR={kernelName:sn,backendName:"webgl",kernelFunc:$Y};var Av="return (a < 0.) ? b * a : a;",Dv=`
  vec4 aLessThanZero = vec4(lessThan(a, vec4(0.)));
  return (aLessThanZero * (b * a)) + ((vec4(1.0) - aLessThanZero) * a);
`;function RY(r){let{inputs:e,backend:t}=r,{x:o,alpha:n}=e,s=G().getBool("WEBGL_PACK_BINARY_OPERATIONS")?new Vs(Dv,o.shape,n.shape):new Qn(Av,o.shape,n.shape);return t.runWebGLProgram(s,[o,n],o.dtype)}var OR={kernelName:yn,backendName:"webgl",kernelFunc:RY};var Mx="if (isnan(x)) return x;",PR=`
  if (isnan(a)) return a;
  if (isnan(b)) return b;
`,MR=`
  result.r = isNaN.r > 0. ? NAN : result.r;
  result.g = isNaN.g > 0. ? NAN : result.g;
  result.b = isNaN.b > 0. ? NAN : result.b;
  result.a = isNaN.a > 0. ? NAN : result.a;
`;function ve({opSnippet:r,packedOpSnippet:e,cpuKernelImpl:t,dtype:o}){return({inputs:n,backend:s})=>{let{x:a}=n,i=s,l=o||a.dtype;if(i.shouldExecuteOnCPU([a])&&t!=null){let p=i.texData.get(a.dataId),m=t(p.values,l);return i.makeTensorInfo(a.shape,l,m)}let u=G().getBool("WEBGL_PACK_UNARY_OPERATIONS")&&e!=null,c;return u?c=new Bs(a.shape,e):c=new uo(a.shape,r),i.runWebGLProgram(c,[a],l)}}function it({opSnippet:r,packedOpSnippet:e,checkOutOfBounds:t=!1,supportsComplex:o=!1,cpuKernelImpl:n,dtype:s}){return({inputs:a,backend:i})=>{let{a:l,b:u}=a,c=i;if(o&&l.dtype==="complex64"){let d=c.texData.get(l.dataId),h=c.texData.get(u.dataId),[g,x]=[[d.complexTensorInfos.real,h.complexTensorInfos.real],[d.complexTensorInfos.imag,h.complexTensorInfos.imag]].map(_=>{let[w,v]=_,$={dataId:w.dataId,dtype:w.dtype,shape:l.shape},A={dataId:v.dataId,dtype:v.dtype,shape:u.shape},R=new Qn(r,l.shape,u.shape);return c.runWebGLProgram(R,[$,A],mr(w.dtype,v.dtype))}),b=co({inputs:{real:g,imag:x},backend:c});return c.disposeIntermediateTensorInfo(g),c.disposeIntermediateTensorInfo(x),b}let p=s||mr(l.dtype,u.dtype);if(c.shouldExecuteOnCPU([l,u])&&n!=null){let d=c.texData.get(l.dataId),h=c.texData.get(u.dataId),[g,x]=n(l.shape,u.shape,d.values,h.values,p),b=c.makeTensorInfo(x,p),_=c.texData.get(b.dataId);return _.values=g,b}let m=G().getBool("WEBGL_PACK_BINARY_OPERATIONS")&&e!=null,f;return m?f=new Vs(e,l.shape,u.shape,t):f=new Qn(r,l.shape,u.shape),c.runWebGLProgram(f,[l,u],p)}}function El(r,e=!1){if(r==="linear")return e?SR:vR;if(r==="relu")return e?ER:IR;if(r==="elu")return e?TR:CR;if(r==="relu6")return e?AR:NR;if(r==="prelu")return e?Dv:Av;if(r==="leakyrelu")return e?Ev:Tv;throw new Error(`Activation ${r} has not been implemented for the WebGL backend.`)}var ih=class{constructor(e,t,o,n=!1,s=!1,a=!1,i=null,l=!1,u=!1){this.variableNames=["matrixA","matrixB"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=o;let c=n?e[1]:e[2],p=Math.ceil(c/2),m=n?"i * 2, rc.y":"rc.y, i * 2",f=s?"rc.z, i * 2":"i * 2, rc.z",d=n?["a.xxyy","a.zzww"]:["a.xxzz","a.yyww"],h=s?["b.xzxz","b.ywyw"]:["b.xyxy","b.zwzw"],g="",x="";i&&(l?g=`vec4 activation(vec4 a) {
          vec4 b = getPreluActivationWeightsAtOutCoords();
          ${i}
        }`:u?g=`vec4 activation(vec4 a) {
          vec4 b = getLeakyreluAlphaAtOutCoords();
          ${i}
        }`:g=`vec4 activation(vec4 x) {
          ${i}
        }`,x="result = activation(result);");let b=a?"result += getBiasAtOutCoords();":"";a&&this.variableNames.push("bias"),l&&this.variableNames.push("preluActivationWeights"),u&&this.variableNames.push("leakyreluAlpha");let _="rc.x",w="rc.x";e[0]<t[0]?_=`int(min(float(rc.x), ${e[0]-1}.))`:t[0]<e[0]&&(w=`int(min(float(rc.x), ${t[0]-1}.))`),this.userCode=`
      ${g}

      const float sharedDimension = ${p}.0;

      vec4 dot2x2ARowBCol(ivec3 rc) {
        vec4 result = vec4(0);
        for (int i = 0; i < ${p}; i++) {
          int batchA = ${_};
          int batchB = ${w};
          vec4 a = getMatrixA(batchA, ${m});
          vec4 b = getMatrixB(batchB, ${f});

          // These swizzled products need to be separately added.
          // See: https://github.com/tensorflow/tfjs/issues/1735
          result += (${d[0]} * ${h[0]});
          result += (${d[1]} * ${h[1]});
        }
        return result;
      }

      void main() {
        ivec3 rc = getOutputCoords();
        vec4 result = dot2x2ARowBCol(rc);

        ${b}

        ${x}

        setOutput(result);
      }
    `}};var $v={REAL:"return areal * breal - aimag * bimag;",IMAG:"return areal * bimag + aimag * breal;"},Lx=class{constructor(e,t,o){this.variableNames=["AReal","AImag","BReal","BImag"],this.outputShape=N.assertAndGetBroadcastShape(t,o),this.userCode=`
      float binaryOpComplex(
          float areal, float aimag, float breal, float bimag) {
        ${e}
      }

      void main() {
        float areal = getARealAtOutCoords();
        float aimag = getAImagAtOutCoords();
        float breal = getBRealAtOutCoords();
        float bimag = getBImagAtOutCoords();
        setOutput(binaryOpComplex(areal, aimag, breal, bimag));
      }
    `}};var LR="return a * b;";function Rv(r){let{inputs:e,backend:t}=r,{a:o,b:n}=e,s=N.upcastType(o.dtype,n.dtype);if(o.dtype==="complex64"){let i=t.texData.get(o.dataId),l=t.texData.get(n.dataId),u=new Lx($v.REAL,o.shape,n.shape),c=new Lx($v.IMAG,o.shape,n.shape),p=[{dataId:i.complexTensorInfos.real.dataId,dtype:i.complexTensorInfos.real.dtype,shape:o.shape},{dataId:i.complexTensorInfos.imag.dataId,dtype:i.complexTensorInfos.imag.dtype,shape:o.shape},{dataId:l.complexTensorInfos.real.dataId,dtype:l.complexTensorInfos.real.dtype,shape:n.shape},{dataId:l.complexTensorInfos.imag.dataId,dtype:l.complexTensorInfos.imag.dtype,shape:n.shape}],m=t.runWebGLProgram(u,p,"float32"),f=t.runWebGLProgram(c,p,"float32"),d=co({inputs:{real:m,imag:f},backend:t});return t.disposeIntermediateTensorInfo(m),t.disposeIntermediateTensorInfo(f),d}if(t.shouldExecuteOnCPU([o,n])){let i=t.texData.get(o.dataId),l=t.texData.get(n.dataId),[u,c]=lR(o.shape,n.shape,i.values,l.values,s),p=t.makeTensorInfo(c,s),m=t.texData.get(p.dataId);return m.values=u,p}let a;return G().getBool("WEBGL_PACK_BINARY_OPERATIONS")?a=new Vs(LR,o.shape,n.shape):a=new Qn(LR,o.shape,n.shape),t.runWebGLProgram(a,[o,n],s)}var zR={kernelName:dn,backendName:"webgl",kernelFunc:Rv};function BR(r,e,t){let o=[Nl(r.shape),...Sl(r.shape)],n={dtype:r.dtype,shape:o,dataId:r.dataId},s=[Nl(e),...Sl(e)],a=new nh(s,o),i=!0,l=t.runWebGLProgram(a,[n],r.dtype,null,i);return{dataId:l.dataId,shape:e,dtype:l.dtype}}function ce(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{shape:s}=o,a=t,i=y.sizeFromShape(n.shape),l=y.inferFromImplicitShape(s,i),u=y.sizeFromShape(l);y.assert(i===u,()=>`The new shape (${l}) has ${u} elements and the old shape (${n.shape}) has ${i} elements. The new shape and old shape must have the same number of elements.`);let c=a.texData.get(n.dataId);return c.isPacked&&!ac(n.shape,l)&&!(c.texture!==null&&ac(c.shape,l))?BR(n,l,a):(a.incRef(n.dataId),{dataId:n.dataId,shape:l,dtype:n.dtype})}var VR={kernelName:fs,backendName:"webgl",kernelFunc:ce};var zx=class{constructor(e,t){this.variableNames=["x"];let{windowSize:o,batchSize:n,inSize:s,outSize:a}=e;this.outputShape=[n,a];let i=Math.floor(o/4)*4,l=o%4,u="sumValue += dot(values, ones);";if(t!=null){let p=1/t;u=`sumValue += dot(values * ${y.isInt(p)?p.toPrecision(2):p}, ones);`}let c="";s%o>0&&(c=`
        if (inIdx < 0 || inIdx >= ${s}) {
          return 0.0;
        }
      `),this.userCode=`
      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);

      float getValue(int batch, int inIdx) {
        ${c}
        return getX(batch, inIdx);
      }

      void main() {
        ivec2 coords = getOutputCoords();
        int batch = coords[0];
        int outIdx = coords[1];
        int inOffset = outIdx * ${o};

        float sumValue = 0.0;

        for (int i = 0; i < ${i}; i += 4) {
          int inIdx = inOffset + i;
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2),
            getValue(batch, inIdx + 3)
          );

          ${u}
        }

        int inIdx = inOffset + ${i};
        if (${l===1}) {
          vec4 values = vec4(getValue(batch, inIdx), 0.0, 0.0, 0.0);

          ${u}
        } else if (${l===2}) {
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1), 0.0, 0.0);

          ${u}
        } else if (${l===3}) {
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2), 0.0);

          ${u}
        }
        setOutput(sumValue);
      }
    `}};var Fv=class{constructor(e,t){this.variableNames=["x"];let{windowSize:o,batchSize:n,inSize:s,outSize:a}=e;this.outputShape=[n,a];let i="0.0",l="";t==="prod"?i="1.0":t==="min"?(i="1.0 / 1e-20",l="min"):t==="max"&&(i="-1.0 / 1e-20",l="max");let u=`${t}(${t}(${t}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;t==="sum"?u="sumValue":t==="prod"?u="prodValue":t==="all"?u="allValue":t==="any"&&(u="anyValue");let c=Math.floor(o/4)*4,p=o%4,m=`
      if (${t==="sum"}) {
        sumValue += dot(values, ones);
      } else if (${t==="prod"}) {
        vec2 tmp = vec2(values[0], values[1]) * vec2(values[2], values[3]);
        prodValue *= tmp[0] * tmp[1];
      } else {
        minMaxValue = ${l}(values, minMaxValue);
      }
    `,f="vec4";t==="all"?(i="1.0",m=`
        bool reducedAllValue = all(values);
        float floatedReducedAllValue = float(reducedAllValue);
        allValue = float(allValue >= 1.0 && floatedReducedAllValue >= 1.0);
      `,f="bvec4"):t==="any"&&(i="0.0",m=`
        bool reducedAnyValue = any(values);
        float floatedReducedAnyValue = float(reducedAnyValue);
        anyValue = float(anyValue >= 1.0 || floatedReducedAnyValue >= 1.0);
      `,f="bvec4");let d="";s%o>0&&(d=`
        if (inIdx < 0 || inIdx >= ${s}) {
          return initializationValue;
        }
      `),this.userCode=`
      const float initializationValue = ${i};
      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);

      float getValue(int batch, int inIdx) {
        ${d}
        return getX(batch, inIdx);
      }

      void main() {
        ivec2 coords = getOutputCoords();
        int batch = coords[0];
        int outIdx = coords[1];
        int inOffset = outIdx * ${o};

        vec4 minMaxValue = vec4(${i});
        float prodValue = 1.0;
        float sumValue = 0.0;
        float allValue = 1.0;
        float anyValue = 0.0;

        for (int i = 0; i < ${c}; i += 4) {
          int inIdx = inOffset + i;
          ${f} values = ${f}(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2),
            getValue(batch, inIdx + 3)
          );

          ${m}
        }

        int inIdx = inOffset + ${c};
        if (${p===1}) {
          ${f} values = ${f}(
            getValue(batch, inIdx),
            initializationValue,
            initializationValue,
            initializationValue
          );

          ${m}
        } else if (${p===2}) {
          ${f} values = ${f}(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            initializationValue,
            initializationValue
          );

          ${m}
        } else if (${p===3}) {
          ${f} values = ${f}(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2),
            initializationValue
          );

          ${m}
        }
        setOutput(${u});
      }
    `}};function FY(r){let e=[];for(;e.length===0||e[e.length-1].outSize!==1;){let t=e.length?e[e.length-1].outSize:r[1],o=N.computeOptimalWindowSize(t);e.push({inSize:t,windowSize:o,outSize:Math.ceil(t/o)})}return e}function Io(r,e,t,o){let n=FY(r.shape),s=r;for(let a=0;a<n.length;a++){let{inSize:i,windowSize:l,outSize:u}=n[a],c,p;t==="mean"?c=a===0?new zx({windowSize:l,inSize:i,batchSize:r.shape[0],outSize:u},i):new zx({windowSize:l,inSize:i,batchSize:r.shape[0],outSize:u}):c=new Fv({windowSize:l,inSize:i,batchSize:r.shape[0],outSize:u},t),p=s,s=o.runWebGLProgram(c,[s],e),p.dataId!==r.dataId&&o.disposeIntermediateTensorInfo(p)}return s}var Ov=class{constructor(e,t){this.variableNames=["A"];let o=new Array(e.length);for(let a=0;a<o.length;a++)o[a]=e[t[a]];this.outputShape=o,this.rank=o.length;let n=Le(this.rank),s=OY(t);this.userCode=`
    void main() {
      ${n} resRC = getOutputCoords();
      setOutput(getA(${s}));
    }
    `}};function OY(r){let e=r.length;if(e>6)throw Error(`Transpose for rank ${e} is not yet supported`);let t=["resRC.x","resRC.y","resRC.z","resRC.w","resRC.u","resRC.v"],o=new Array(e);for(let n=0;n<r.length;n++)o[r[n]]=t[n];return o.join()}var Pv=class{constructor(e,t){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0;let o=new Array(e.length);for(let c=0;c<o.length;c++)o[c]=e[t[c]];if(this.outputShape=o,this.rank=o.length,this.rank>6)throw Error(`Packed transpose for rank ${this.rank} is not yet supported.`);let n=Le(this.rank),s=kv("rc",this.rank),a=new Array(this.rank);for(let c=0;c<t.length;c++)a[t[c]]=s[c];let i=`vec2(${a.slice(-2).join()})`,l=`++${s[this.rank-1]} < ${o[this.rank-1]}`,u=`getChannel(getA(${a.join()}), ${i})`;this.userCode=`
    void main() {
      ${n} rc = getOutputCoords();
      vec4 result = vec4(0.);
      result[0] = ${u};
      if(${l}) {
        result[1] = ${u};
      }
      --${s[this.rank-1]};
      if(++${s[this.rank-2]} < ${o[this.rank-2]}) {
        result[2] = ${u};
        if(${l}) {
          result[3] = ${u};
        }
      }
      setOutput(result);
    }
    `}};function Al(r,e,t){let o=G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")?new Pv(r.shape,e):new Ov(r.shape,e);return t.runWebGLProgram(o,[r],r.dtype)}function GR(r,e,t,o){let n=e,s=r.shape.length,a=y.parseAxisParam(n,r.shape),i=a,l=N.getAxesPermutation(i,s),u=l!=null,c=r;u&&(c=Al(r,l,o),i=N.getInnerMostAxes(i.length,s)),N.assertAxesAreInnerMostDims("sum",i,s);let[p,m]=N.computeOutAndReduceShapes(c.shape,i),f=p;t&&(f=N.expandShapeToKeepDim(p,a));let d=y.sizeFromShape(m),g=y.sizeFromShape(r.shape)/d,x=ce({inputs:{x:c},attrs:{shape:[g,d]},backend:o}),b=hu(r.dtype),_=Io(x,b,"sum",o),w=ce({inputs:{x:_},attrs:{shape:f},backend:o});return o.disposeIntermediateTensorInfo(x),o.disposeIntermediateTensorInfo(_),u&&o.disposeIntermediateTensorInfo(c),w}function ah(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,keepDims:a}=o;return GR(n,s,a,t)}var WR={kernelName:Tn,backendName:"webgl",kernelFunc:ah};function Lt(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{perm:s}=o,a=t,i=n.shape.length,l=new Array(i);for(let c=0;c<l.length;c++)l[c]=n.shape[s[c]];let u;if(a.shouldExecuteOnCPU([n])){let p=a.texData.get(n.dataId).values,m=Up(p,n.shape,n.dtype,s,l);u=a.makeTensorInfo(l,n.dtype);let f=a.texData.get(u.dataId);f.values=m}else u=Al(n,s,a);return u}var UR={kernelName:Rn,backendName:"webgl",kernelFunc:Lt};var Mv=1e3;function uc({a:r,b:e,transposeA:t,transposeB:o,backend:n,bias:s=null,preluActivationWeights:a=null,leakyreluAlpha:i=0,activation:l=null}){let u=r.shape.length,c=e.shape.length,p=t?r.shape[u-2]:r.shape[u-1],m=o?e.shape[c-1]:e.shape[c-2],f=t?r.shape[u-1]:r.shape[u-2],d=o?e.shape[c-2]:e.shape[c-1],h=r.shape.slice(0,-2),g=e.shape.slice(0,-2),x=y.sizeFromShape(h),b=y.sizeFromShape(g),_=x===b||x===1||b===1;y.assert(u>=2&&c>=2&&_,()=>`Error in matMul: the input batch dimensions must either be the same or at least one input batch dimension must be 1. Got input batch dimensions of (${h}) and (${g}).`);let v=(x>b?r.shape.slice(0,-2):e.shape.slice(0,-2)).concat([f,d]);y.assert(p===m,()=>`Error in matMul: inner shapes (${p}) and (${m}) of Tensors with shapes ${r.shape} and ${e.shape} and transposeA=${t} and transposeB=${o} must match.`);let $=t?[x,p,f]:[x,f,p],A=o?[b,d,m]:[b,m,d],R=ce({inputs:{x:r},backend:n,attrs:{shape:$}}),M=ce({inputs:{x:e},backend:n,attrs:{shape:A}}),z=[R,M],W=Math.max(x,b),U=t?R.shape[1]:R.shape[2],q=s!=null,Z=a!=null,X=l==="leakyrelu",Y=l!=null?El(l,!0):null,te=q||Z||X||Y!=null,K;if((f===1||d===1)&&U>Mv&&te===!1){let ie=R,se=M;t&&(ie=Lt({inputs:{x:R},backend:n,attrs:{perm:[0,2,1]}}),z.push(ie)),o&&(se=Lt({inputs:{x:M},backend:n,attrs:{perm:[0,2,1]}}),z.push(se));let pe=d!==1,ae=d===1,xe=ie;pe&&(xe=ce({inputs:{x:ie},backend:n,attrs:{shape:[W,U,1]}}),z.push(xe));let ge=d===1?2:1,_e=se;ae&&(_e=ce({inputs:{x:se},backend:n,attrs:{shape:[W,1,U]}}),z.push(_e));let ke=Rv({inputs:{a:xe,b:_e},backend:n});K=ah({inputs:{x:ke},backend:n,attrs:{axis:ge,keepDims:!0}}),z.push(ke)}else{let ie=mr(r.dtype,e.dtype),se=new ih($,A,[W,f,d],t,o,q,Y,Z,X),pe=[R,M];if(s!=null&&pe.push(s),Z&&pe.push(a),X){let ae=n.makeTensorInfo([],"float32",y.createScalarValue(i,"float32"));pe.push(ae),z.push(ae)}K=n.runWebGLProgram(se,pe,ie)}let re=ce({inputs:{x:K},backend:n,attrs:{shape:v}});z.push(K);for(let ie of z)n.disposeIntermediateTensorInfo(ie);return re}function PY(r){let{inputs:e,backend:t,attrs:o}=r,{a:n,b:s,bias:a,preluActivationWeights:i}=e,{transposeA:l,transposeB:u,activation:c,leakyreluAlpha:p}=o;return uc({a:n,b:s,transposeA:l,transposeB:u,backend:t,bias:a,preluActivationWeights:i,leakyreluAlpha:p,activation:c})}var jR={kernelName:bs,backendName:"webgl",kernelFunc:PY};var HR="return abs(x);";function MY(r){let{inputs:e,backend:t}=r,{x:o}=e;if(t.shouldExecuteOnCPU([o])&&o.dtype!=="complex64"){let s=t.texData.get(o.dataId),a=Fx(s.values);return t.makeTensorInfo(o.shape,o.dtype,a)}let n;return G().getBool("WEBGL_PACK_UNARY_OPERATIONS")?n=new Bs(o.shape,HR):n=new uo(o.shape,HR),t.runWebGLProgram(n,[o],o.dtype)}var qR={kernelName:ss,backendName:"webgl",kernelFunc:MY};var LY=gr+`
  if (abs(x) > 1.) {
    return NAN;
  }
  return acos(x);
`,zY=ve({opSnippet:LY}),KR={kernelName:qs,backendName:"webgl",kernelFunc:zY};var BY=gr+`
  if (x < 1.0) return NAN;
return log(x + sqrt(x * x - 1.0));`,VY=ve({opSnippet:BY}),XR={kernelName:Ks,backendName:"webgl",kernelFunc:VY};var YR="return a + b;",GY=it({opSnippet:YR,packedOpSnippet:YR,supportsComplex:!0,cpuKernelImpl:q$}),ZR={kernelName:xo,backendName:"webgl",kernelFunc:GY};var Lv=class{constructor(e,t){this.outputShape=[],this.outputShape=e,this.variableNames=t.map((s,a)=>`T${a}`);let o=[];this.variableNames.forEach(s=>{o.push(`float v${s} = get${s}AtOutCoords();`)});let n=this.variableNames.map(s=>`v${s}`).join(" + ");this.userCode=`
      void main() {
        ${o.join(`
        `)}

        float result = ${n};
        setOutput(result);
      }
    `}};var zv=class{constructor(e,t){this.outputShape=[],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e,this.variableNames=t.map((s,a)=>`T${a}`);let o=[];this.variableNames.forEach(s=>{o.push(`vec4 v${s} = get${s}AtOutCoords();`)});let n=this.variableNames.map(s=>`v${s}`).join(" + ");this.userCode=`
      void main() {
        ${o.join(`
        `)}

        vec4 result = ${n};
        setOutput(result);
      }
    `}};function Bx(r){let{inputs:e,backend:t}=r,o=e;if(o.length===1)return jt({inputs:{x:o[0]},backend:t});if(o.length>G().get("WEBGL_MAX_TEXTURES_IN_SHADER")){let l=Math.floor(o.length/2),u=Bx({inputs:o.slice(0,l),backend:t}),c=Bx({inputs:o.slice(l),backend:t});return Bx({inputs:[u,c],backend:t})}let n=o.map(l=>l.dtype).reduce((l,u)=>mr(l,u)),s=o.map(l=>l.shape),i=G().getBool("WEBGL_PACK")?new zv(o[0].shape,s):new Lv(o[0].shape,s);return t.runWebGLProgram(i,o,n)}var JR={kernelName:Uo,backendName:"webgl",kernelFunc:Bx};function WY(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,keepDims:a}=o,i=n.shape.length,l=y.parseAxisParam(s,n.shape),u=l,c=N.getAxesPermutation(u,i),p=n;c!=null&&(p=Lt({inputs:{x:n},backend:t,attrs:{perm:c}}),u=N.getInnerMostAxes(u.length,i)),N.assertAxesAreInnerMostDims("all",u,i);let[m,f]=N.computeOutAndReduceShapes(p.shape,u),d=y.sizeFromShape(f),h=ce({inputs:{x:p},backend:t,attrs:{shape:[-1,d]}}),g=Io(h,h.dtype,"all",t),x;if(a){let b=N.expandShapeToKeepDim(m,l);x=ce({inputs:{x:g},backend:t,attrs:{shape:b}})}else x=ce({inputs:{x:g},backend:t,attrs:{shape:m}});return t.disposeIntermediateTensorInfo(h),t.disposeIntermediateTensorInfo(g),c!=null&&t.disposeIntermediateTensorInfo(p),x}var QR={kernelName:Vl,backendName:"webgl",kernelFunc:WY};function UY(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,keepDims:a}=o,i=n.shape.length,l=y.parseAxisParam(s,n.shape),u=l,c=N.getAxesPermutation(u,i),p=n;c!=null&&(p=Lt({inputs:{x:n},backend:t,attrs:{perm:c}}),u=N.getInnerMostAxes(u.length,i)),N.assertAxesAreInnerMostDims("any",u,i);let[m,f]=N.computeOutAndReduceShapes(p.shape,u),d=y.sizeFromShape(f),h=ce({inputs:{x:p},backend:t,attrs:{shape:[-1,d]}}),g=Io(h,h.dtype,"any",t),x;if(a){let b=N.expandShapeToKeepDim(m,l);x=ce({inputs:{x:g},backend:t,attrs:{shape:b}})}else x=ce({inputs:{x:g},backend:t,attrs:{shape:m}});return t.disposeIntermediateTensorInfo(h),t.disposeIntermediateTensorInfo(g),c!=null&&t.disposeIntermediateTensorInfo(p),x}var eF={kernelName:Gl,backendName:"webgl",kernelFunc:UY};var Bv=class{constructor(e,t,o){this.variableNames=["A"];let{windowSize:n,batchSize:s,outSize:a}=e;o||this.variableNames.push("bestIndicesA"),this.outputShape=[s,a];let i=t==="max"?">":"<",l=o?"inOffset + i;":"round(getBestIndicesA(batch, inOffset + i));";this.userCode=`
      void main() {
        ivec2 coords = getOutputCoords();
        int batch = coords[0];
        int outIdx = coords[1];
        int inOffset = outIdx * ${n};

        int bestIndex = inOffset;
        float bestValue = getA(batch, bestIndex);

        for (int i = 0; i < ${n}; i++) {
          int inIdx = ${l};
          float candidate = getA(batch, inIdx);
          if (candidate ${i} bestValue) {
            bestValue = candidate;
            bestIndex = inIdx;
          }
        }
        setOutput(float(bestIndex));
      }
    `}};var Vv=class{constructor(e,t,o,n){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,y.assert(e.length>2,()=>`Packed arg${o.charAt(0).toUpperCase()+o.slice(1)} supports only inputs with rank above 2.`);let s=e[e.length-1],a=Math.ceil(s/t);this.outputShape=e.slice(0,-1),a>1&&this.outputShape.push(a),n||this.variableNames.push("bestIndicesA");let i=this.outputShape,l=i.length,u=Le(l),c=Ut("coords",l),p,m;if(a===1){m=l+1;let R=Le(m);p=`
        ${R} sourceLocR = ${R}(${c.join()}, 0);
        ++${c[l-1]};
        ${R} sourceLocG = ${R}(${c.join()}, 0);
        ++${c[l-2]};
        ${R} sourceLocA = ${R}(${c.join()}, 0);
        --${c[l-1]};
        ${R} sourceLocB = ${R}(${c.join()}, 0);
        --${c[l-2]};`}else m=l,p=`
        ${u} sourceLocR = coords;
        ++${c[l-1]};
        ${u} sourceLocG = coords;
        ++${c[l-2]};
        ${u} sourceLocA = coords;
        --${c[l-1]};
        ${u} sourceLocB = coords;
        --${c[l-2]};`;let f=["x","y","z","w","u","v"].slice(0,m),d="."+f[m-1],h=f.map(R=>"int "+R),g=Ut("sourceLocR",m-1).concat("inIdx.r"),x=Ut("sourceLocG",m-1).concat("inIdx.g"),b=Ut("sourceLocB",m-1).concat("inIdx.b"),_=Ut("sourceLocA",m-1).concat("inIdx.a"),w=o==="max"?"greaterThan":"lessThan",v=n?"":`
          inIdx = round(vec4(getBestIndicesAChannel(${g.join()}),
                             getBestIndicesAChannel(${x.join()}),
                             getBestIndicesAChannel(${b.join()}),
                             getBestIndicesAChannel(${_.join()})));`,$=`vec4(
            getAChannel(${g.join()}),
            hasNextCol ? getAChannel(${x.join()}) : 0.,
            hasNextRow ? getAChannel(${b.join()}) : 0.,
            hasNextRow && hasNextCol ? getAChannel(${_.join()}) : 0.)`,A=n?"":`
      float getBestIndicesAChannel(${h.join()}) {
        return getChannel(getBestIndicesA(${f.join()}),
                                          vec2(${f.slice(-2).join()}));
      }`;this.userCode=`
      float getAChannel(${h.join()}) {
        return getChannel(getA(${f.join()}),
                               vec2(${f.slice(-2).join()}));
      }
      ${A}
      void main() {
        ${u} coords = getOutputCoords();
        bool hasNextCol = ${c[l-1]} < ${i[l-1]-1};
        bool hasNextRow = ${c[l-2]} < ${i[l-2]-1};
        ${p}
        ivec4 srcIdx = ivec4(sourceLocR${d}, sourceLocG${d},
          sourceLocB${d}, sourceLocA${d}) * ${t};
        ivec4 inIdx = srcIdx;
        vec4 bestIndex = vec4(inIdx);
        vec4 bestValue = ${$};

        for (int i = 0; i < ${t}; i++) {
          inIdx = srcIdx;
          ${v}
          vec4 candidate = ${$};
          bvec4 nan = isnan(candidate);
          bvec4 replace = bvec4(
            vec4(${w}(candidate, bestValue)) * (vec4(1.0) - vec4(nan)));

          bestValue = vec4(replace.x  ? candidate.x : bestValue.x,
                           replace.y  ? candidate.y : bestValue.y,
                           replace.z  ? candidate.z : bestValue.z,
                           replace.w  ? candidate.w : bestValue.w);
          bestIndex = mix(bestIndex, vec4(inIdx), vec4(replace));
          srcIdx++;
        }
        setOutput(bestIndex);
      }
    `}};function tF(r,e,t,o=null){let n=e.shape[0],s=e.shape[1];o!=null&&(n=o.shape[0],s=o.shape[1]);let a=N.computeOptimalWindowSize(s),i={windowSize:a,inSize:s,batchSize:n,outSize:Math.ceil(s/a)},l=new Bv(i,t,o==null),u=[e];o!=null&&u.push(o);let c=r.runWebGLProgram(l,u,"int32");if(c.shape[1]===1)return c;let p=tF(r,e,t,c);return r.disposeIntermediateTensorInfo(c),p}function rF(r,e,t,o=null){let n=o!=null?o.shape:e.shape,s=n[n.length-1],a=N.computeOptimalWindowSize(s),i=new Vv(n,a,t,o==null),l=o==null?[e]:[e,o],u=r.runWebGLProgram(i,l,"int32");if(u.shape.length===e.shape.length){let c=rF(r,e,t,u);return r.disposeIntermediateTensorInfo(u),c}return u}function Vx(r,e,t,o){let n=[t];if(N.assertAxesAreInnerMostDims("arg"+o.charAt(0).toUpperCase()+o.slice(1),n,e.shape.length),!G().getBool("WEBGL_PACK_REDUCE")||e.shape.length<=2){let s=[],[a,i]=N.computeOutAndReduceShapes(e.shape,n),l=y.sizeFromShape(i),u=ce({inputs:{x:e},backend:r,attrs:{shape:[-1,l]}});s.push(u);let c=tF(r,u,o);s.push(c);let p=ce({inputs:{x:c},backend:r,attrs:{shape:a}});return s.forEach(m=>r.disposeIntermediateTensorInfo(m)),p}return rF(r,e,o)}function jY(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s}=o,a=y.parseAxisParam(s,n.shape),i=N.getAxesPermutation(a,n.shape.length),l=n,u=[];i!=null&&(l=Lt({inputs:{x:n},backend:t,attrs:{perm:i}}),u.push(l),a=N.getInnerMostAxes(a.length,l.shape.length)),N.assertAxesAreInnerMostDims("argMax",[a[0]],l.shape.length);let c=Vx(t,l,a[0],"max");return u.forEach(p=>t.disposeIntermediateTensorInfo(p)),c}var oF={kernelName:jo,backendName:"webgl",kernelFunc:jY};function HY(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s}=o,a=y.parseAxisParam(s,n.shape),i=N.getAxesPermutation(a,n.shape.length),l=n,u=[];i!=null&&(l=Lt({inputs:{x:n},backend:t,attrs:{perm:i}}),u.push(l),a=N.getInnerMostAxes(a.length,l.shape.length)),N.assertAxesAreInnerMostDims("argMin",[a[0]],l.shape.length);let c=Vx(t,l,a[0],"min");return u.forEach(p=>t.disposeIntermediateTensorInfo(p)),c}var nF={kernelName:oa,backendName:"webgl",kernelFunc:HY};var qY=gr+`
  if (abs(x) > 1.) {
    return NAN;
  }
  return asin(x);
`,KY=ve({opSnippet:qY}),sF={kernelName:Xs,backendName:"webgl",kernelFunc:KY};var XY=gr+"return log(x + sqrt(x * x + 1.0));",YY=ve({opSnippet:XY}),iF={kernelName:Ys,backendName:"webgl",kernelFunc:YY};var ZY=gr+`
  return atan(x);
`,JY=ve({opSnippet:ZY}),aF={kernelName:Zs,backendName:"webgl",kernelFunc:JY};var QY=PR+`
  return atan(a, b);
`,e7=`
  vec4 result = atan(a, b);
  vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
  `+MR+`
  return result;
`,t7=it({opSnippet:QY,packedOpSnippet:e7}),lF={kernelName:Qs,backendName:"webgl",kernelFunc:t7};var r7=gr+`
  if ((x < -1.0) || (x > 1.0)) return NAN;
return (log(1.0 + x) - log(1.0 - x)) / 2.0;`,o7=ve({opSnippet:r7}),uF={kernelName:Js,backendName:"webgl",kernelFunc:o7};var Zi=class{constructor(e,t,o,n=!1,s=!1){if(this.variableNames=["x"],t==="avg"&&o)throw new Error("Cannot compute positions for average pool.");let a=e.filterWidth,i=e.strideHeight,l=e.strideWidth,u=e.dilationHeight,c=e.dilationWidth,p=e.effectiveFilterHeight,m=e.effectiveFilterWidth,f=e.padInfo.top,d=e.padInfo.left;this.outputShape=e.outShape;let h=t==="avg",g=`((batch  * ${e.inHeight} + xR) * ${e.inWidth} + xC) * ${e.inChannels} + d`,x=`(xR * ${e.inWidth} + xC) * ${e.inChannels} + d`,b="0.0";if(h||(b="-1.0 / 1e-20"),o){let R=">=";this.userCode=`
        const ivec2 strides = ivec2(${i}, ${l});
        const ivec2 pads = ivec2(${f}, ${d});

        void main() {
          ivec4 coords = getOutputCoords();
          int batch = coords[0];
          int d = coords[3];

          ivec2 xRCCorner = coords.yz * strides - pads;
          int xRCorner = xRCCorner.x;
          int xCCorner = xRCCorner.y;

          // max/min x(?, ?, d) to get y(yR, yC, d).
          // ? = to be determined
          float minMaxValue = 0.0;
          float minMaxValueFound = 0.0;
          int minMaxPosition = 0;
          float avgValue = 0.0;

          for (int wR = 0; wR < ${p};
              wR += ${u}) {
            int xR = xRCorner + wR;

            if (xR < 0 || xR >= ${e.inHeight}) {
              continue;
            }

            for (int wC = 0; wC < ${m};
                wC += ${c}) {
              int xC = xCCorner + wC;

              if (xC < 0 || xC >= ${e.inWidth}) {
                continue;
              }

              float value = getX(batch, xR, xC, d);

              // If a min / max value has already been found, use it. If not,
              // use the current value.
              float currMinMaxValue = mix(
                  value, minMaxValue, minMaxValueFound);
              if (value ${R} currMinMaxValue) {
                minMaxValue = value;
                minMaxValueFound = 1.0;
                minMaxPosition = ${n?s?g:x:`wR * ${m} + wC`};
              }
            }
          }
          setOutput(float(minMaxPosition));
        }
      `;return}let _="max",w=`${t}(${t}(${t}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;t==="avg"&&(w="avgValue / count");let v=Math.floor(a/4)*4,$=a%4,A=`
      if (${h}) {
        avgValue += dot(values, ones);
      } else {
        minMaxValue = ${_}(values, minMaxValue);
      }
    `;this.userCode=`
      const ivec2 strides = ivec2(${i}, ${l});
      const ivec2 pads = ivec2(${f}, ${d});
      const float initializationValue = ${b};
      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);

      float count = 0.0;

      float getValue(int batch, int xR, int xC, int d) {
        if (xC < 0 || xC >= ${e.inWidth}) {
          return initializationValue;
        }
        count += 1.0;
        return getX(batch, xR, xC, d);
      }

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords[0];
        int d = coords[3];

        ivec2 xRCCorner = coords.yz * strides - pads;
        int xRCorner = xRCCorner.x;
        int xCCorner = xRCCorner.y;

        // max/min x(?, ?, d) to get y(yR, yC, d).
        // ? = to be determined
        vec4 minMaxValue = vec4(${b});
        float avgValue = 0.0;
        count = 0.0;

        for (int wR = 0; wR < ${p};
            wR += ${u}) {
          int xR = xRCorner + wR;

          if (xR < 0 || xR >= ${e.inHeight}) {
            continue;
          }

          for (int wC = 0; wC < ${v}; wC += 4) {
            int xC = xCCorner + wC * ${c};

            vec4 values = vec4(
              getValue(batch, xR, xC, d),
              getValue(batch, xR, xC + ${c}, d),
              getValue(batch, xR, xC + 2 * ${c}, d),
              getValue(batch, xR, xC + 3 * ${c}, d)
            );

            ${A}
          }

          int xC = xCCorner + ${v};
          if (${$===1}) {
            vec4 values = vec4(
              getValue(batch, xR, xC, d),
              initializationValue,
              initializationValue,
              initializationValue
            );

            ${A}
          } else if (${$===2}) {
            vec4 values = vec4(
              getValue(batch, xR, xC, d),
              getValue(batch, xR, xC + ${c}, d),
              initializationValue,
              initializationValue
            );

            ${A}
          } else if (${$===3}) {
            vec4 values = vec4(
              getValue(batch, xR, xC, d),
              getValue(batch, xR, xC + ${c}, d),
              getValue(batch, xR, xC + 2 * ${c}, d),
              initializationValue
            );

            ${A}
          }
        }
        setOutput(${w});
      }
    `}},cc=class{constructor(e,t,o,n=!1,s=!1){if(this.variableNames=["x"],t==="avg"&&o)throw new Error("Cannot compute positions for average pool.");let a=e.filterWidth,i=e.strideDepth,l=e.strideHeight,u=e.strideWidth,c=e.dilationDepth,p=e.dilationHeight,m=e.dilationWidth,f=e.effectiveFilterDepth,d=e.effectiveFilterHeight,h=e.effectiveFilterWidth,g=e.padInfo.front,x=e.padInfo.top,b=e.padInfo.left;this.outputShape=e.outShape;let _=t==="avg",w="0.0";if(_||(w="-1.0 / 1e-20"),o){let z=">=";this.userCode=`
        const ivec3 strides =
            ivec3(${i}, ${l}, ${u});
        const ivec3 pads = ivec3(${g}, ${x}, ${b});

        void main() {
          ivec5 coords = getOutputCoords();
          int batch = coords.x;
          int ch = coords.u;

          ivec3 xCorner = ivec3(coords.y, coords.z, coords.w) * strides - pads;
          int xDCorner = xCorner.x;
          int xRCorner = xCorner.y;
          int xCCorner = xCorner.z;

          // max/min x(?, ?, ?, ch) to get y(yD, yR, yC, ch).
          // ? = to be determined
          float minMaxValue = 0.0;
          float minMaxValueFound = 0.0;
          int minMaxPosition = 0;

          for (int wD = 0; wD < ${f};
              wD += ${c}) {
            int xD = xDCorner + wD;

            if (xD < 0 || xD >= ${e.inDepth}) {
              continue;
            }

            for (int wR = 0; wR < ${d};
                wR += ${p}) {
              int xR = xRCorner + wR;

              if (xR < 0 || xR >= ${e.inHeight}) {
                continue;
              }

              for (int wC = 0; wC < ${h};
                  wC += ${m}) {
                int xC = xCCorner + wC;

                if (xC < 0 || xC >= ${e.inWidth}) {
                  continue;
                }

                float value = getX(batch, xD, xR, xC, ch);

                // If a min / max value has already been found, use it. If not,
                // use the current value.
                float currMinMaxValue = mix(
                    value, minMaxValue, minMaxValueFound);
                if (value ${z} currMinMaxValue) {
                  minMaxValue = value;
                  minMaxValueFound = 1.0;
                  minMaxPosition = ${n?s?`(((batch * ${e.inDepth} + xD) * ${e.inHeight} + xR) * ${e.inWidth} + xC) * ${e.inChannels} + ch`:`((xD * ${e.inHeight} + xR) * ${e.inWidth} + xC) * ${e.inChannels} + ch`:`wD * ${d} * ${h} +
                      wR * ${h} + wC`};
                }
              }
            }
          }
          setOutput(float(minMaxPosition));
        }
      `;return}let v="max",$=`${t}(${t}(${t}(minMaxValue[0], minMaxValue[1]), minMaxValue[2]), minMaxValue[3])`;t==="avg"&&($="avgValue / count");let A=Math.floor(a/4)*4,R=a%4,M=`
      if (${_}) {
        avgValue += dot(values, ones);
      } else {
        minMaxValue = ${v}(values, minMaxValue);
      }
    `;this.userCode=`
      const ivec3 strides =
        ivec3(${i}, ${l}, ${u});
      const ivec3 pads = ivec3(${g}, ${x}, ${b});
      const float initializationValue = ${w};
      const vec4 ones = vec4(1.0, 1.0, 1.0, 1.0);

      float count = 0.0;

      float getValue(int batch, int xD, int xR, int xC, int ch) {
        if (xC < 0 || xC >= ${e.inWidth}) {
          return initializationValue;
        }
        count += 1.0;
        return getX(batch, xD, xR, xC, ch);
      }

      void main() {
        ivec5 coords = getOutputCoords();
        int batch = coords.x;
        int ch = coords.u;

        ivec3 xCorner = ivec3(coords.y, coords.z, coords.w) * strides - pads;
        int xDCorner = xCorner.x;
        int xRCorner = xCorner.y;
        int xCCorner = xCorner.z;

        // max/min x(?, ?, ?, d) to get y(yD, yR, yC, ch).
        // ? = to be determined
        vec4 minMaxValue = vec4(${w});
        float avgValue = 0.0;
        count = 0.0;

        for (int wD = 0; wD < ${f};
            wD += ${c}) {
          int xD = xDCorner + wD;

          if (xD < 0 || xD >= ${e.inDepth}) {
            continue;
          }

          for (int wR = 0; wR < ${d};
            wR += ${p}) {
            int xR = xRCorner + wR;

            if (xR < 0 || xR >= ${e.inHeight}) {
              continue;
            }

            for (int wC = 0; wC < ${A}; wC += 4) {
              int xC = xCCorner + wC * ${m};

              vec4 values = vec4(
                getValue(batch, xD, xR, xC, ch),
                getValue(batch, xD, xR, xC + ${m}, ch),
                getValue(batch, xD, xR, xC + 2 * ${m}, ch),
                getValue(batch, xD, xR, xC + 3 * ${m}, ch)
              );

              ${M}
            }

            int xC = xCCorner + ${A};
            if (${R===1}) {
              vec4 values = vec4(
                getValue(batch, xD, xR, xC, ch),
                initializationValue,
                initializationValue,
                initializationValue
              );

              ${M}
            } else if (${R===2}) {
              vec4 values = vec4(
                getValue(batch, xD, xR, xC, ch),
                getValue(batch, xD, xR, xC + ${m}, ch),
                initializationValue,
                initializationValue
              );

              ${M}
            } else if (${R===3}) {
              vec4 values = vec4(
                getValue(batch, xD, xR, xC, ch),
                getValue(batch, xD, xR, xC + ${m}, ch),
                getValue(batch, xD, xR, xC + 2 * ${m}, ch),
                initializationValue
              );

              ${M}
            }
          }
          setOutput(${$});
        }
      }
    `}};function n7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e;Yi(n,"avgPool");let{filterSize:s,strides:a,pad:i,dimRoundingMode:l}=o,u=1;y.assert(N.eitherStridesOrDilationsAreOne(a,u),()=>`Error in avgPool: Either strides or dilations must be 1. Got strides ${a} and dilations '${u}'`);let c=N.computePool2DInfo(n.shape,s,a,u,i,l);if(c.filterWidth===1&&c.filterHeight===1&&y.arraysEqual(c.inShape,c.outShape))return jt({inputs:{x:n},backend:t});let p=new Zi(c,"avg",!1);return t.runWebGLProgram(p,[n],"float32")}var cF={kernelName:Ho,backendName:"webgl",kernelFunc:n7};function s7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{filterSize:s,strides:a,pad:i,dimRoundingMode:l,dataFormat:u}=o,c=[1,1,1],p=N.computePool3DInfo(n.shape,s,a,c,i,l,u),m=new cc(p,"avg",!1);return t.runWebGLProgram(m,[n],"float32")}var pF={kernelName:na,backendName:"webgl",kernelFunc:s7};var Gv=class{constructor(e){this.variableNames=["dy"],this.outputShape=e.inShape;let t=e.filterHeight,o=e.filterWidth,n=e.strideHeight,s=e.strideWidth,a=e.dilationHeight,i=e.dilationWidth,l=e.effectiveFilterHeight,u=e.effectiveFilterWidth,c=l-1-e.padInfo.top,p=u-1-e.padInfo.left,m=1/(t*o);this.userCode=`
      const ivec2 pads = ivec2(${c}, ${p});
      const float avgMultiplier = float(${m});

      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];

        ivec2 dyRCCorner = coords.yz - pads;
        int dyRCorner = dyRCCorner.x;
        int dyCCorner = dyRCCorner.y;

        // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(xR, xC, d).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;
        for (int wR = 0; wR < ${l};
            wR += ${a}) {
          float dyR = float(dyRCorner + wR) / ${n}.0;

          if (dyR < 0.0 || dyR >= ${e.outHeight}.0 || fract(dyR) > 0.0) {
            continue;
          }
          int idyR = int(dyR);

          for (int wC = 0; wC < ${u};
            wC+= ${i}) {
            float dyC = float(dyCCorner + wC) / ${s}.0;

            if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                fract(dyC) > 0.0) {
              continue;
            }
            int idyC = int(dyC);

            float dyValue = getDy(b, idyR, idyC, d);

            dotProd += dyValue * avgMultiplier;
          }
        }
        setOutput(dotProd);
      }
    `}},Wv=class{constructor(e){this.variableNames=["dy"],this.outputShape=e.inShape;let t=e.filterDepth,o=e.filterHeight,n=e.filterWidth,s=e.strideDepth,a=e.strideHeight,i=e.strideWidth,l=e.dilationDepth,u=e.dilationHeight,c=e.dilationWidth,p=e.effectiveFilterDepth,m=e.effectiveFilterHeight,f=e.effectiveFilterWidth,d=p-1-e.padInfo.front,h=m-1-e.padInfo.top,g=f-1-e.padInfo.left,x=1/(t*o*n);this.userCode=`
      const ivec3 pads = ivec3(${d}, ${h}, ${g});
      const float avgMultiplier = float(${x});

      void main() {
        ivec5 coords = getOutputCoords();
        int batch = coords.x;
        int ch = coords.u;

        ivec3 dyCorner = ivec3(coords.y, coords.z, coords.w) - pads;
        int dyDCorner = dyCorner.x;
        int dyRCorner = dyCorner.y;
        int dyCCorner = dyCorner.z;

        // Convolve dy(?, ?, ?, d) with pos mask(:, :, :, ch) to get
        // dx(xD, xR, xC, ch).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;

        for (int wD = 0; wD < ${p};
            wD += ${l}) {
          float dyD = float(dyDCorner + wD) / ${s}.0;

          if (dyD < 0.0 || dyD >= ${e.outDepth}.0 || fract(dyD) > 0.0) {
            continue;
          }
          int idyD = int(dyD);

          for (int wR = 0; wR < ${m};
              wR += ${u}) {
            float dyR = float(dyRCorner + wR) / ${a}.0;

            if (dyR < 0.0 || dyR >= ${e.outHeight}.0 ||
                fract(dyR) > 0.0) {
              continue;
            }
            int idyR = int(dyR);

            for (int wC = 0; wC < ${f};
                wC += ${c}) {
              float dyC = float(dyCCorner + wC) / ${i}.0;

              if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                  fract(dyC) > 0.0) {
                continue;
              }
              int idyC = int(dyC);

              float dyValue = getDy(batch, idyD, idyR, idyC, ch);

              dotProd += dyValue * avgMultiplier;
            }
          }
        }
        setOutput(dotProd);
      }
    `}};function i7(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,input:s}=e,a=s,{filterSize:i,strides:l,pad:u,dimRoundingMode:c}=o,p=[1,1,1],m=N.computePool3DInfo(a.shape,i,l,p,u,c),f=new Wv(m);return t.runWebGLProgram(f,[n],a.dtype)}var mF={kernelName:Ul,backendName:"webgl",kernelFunc:i7};function a7(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,input:s}=e,a=s;Yi([n,s],"avgPoolGrad");let{filterSize:i,strides:l,pad:u}=o,c=N.computePool2DInfo(a.shape,i,l,1,u),p=new Gv(c);return t.runWebGLProgram(p,[n],a.dtype)}var fF={kernelName:Wl,backendName:"webgl",kernelFunc:a7};function l7(r){let{inputs:e,backend:t,attrs:o}=r,{a:n,b:s}=e,{transposeA:a,transposeB:i}=o;return uc({a:n,b:s,transposeA:a,transposeB:i,backend:t})}var dF={kernelName:qo,backendName:"webgl",kernelFunc:l7};var Uv=class{constructor(e,t,o,n,s,a){this.outputShape=[],this.variableNames=["x","mean","variance"],N.assertAndGetBroadcastShape(e,t),N.assertAndGetBroadcastShape(e,o);let i="0.0";n!=null&&(N.assertAndGetBroadcastShape(e,n),this.variableNames.push("offset"),i="getOffsetAtOutCoords()");let l="1.0";s!=null&&(N.assertAndGetBroadcastShape(e,s),this.variableNames.push("scale"),l="getScaleAtOutCoords()"),this.outputShape=e,this.userCode=`
      void main() {
        float x = getXAtOutCoords();
        float mean = getMeanAtOutCoords();
        float variance = getVarianceAtOutCoords();
        float offset = ${i};
        float scale = ${l};
        float inv = scale * inversesqrt(variance + float(${a}));
        setOutput(dot(vec3(x, -mean, offset), vec3(inv, inv, 1)));
      }
    `}};var jv=class{constructor(e,t,o,n,s,a){this.packedInputs=!0,this.packedOutput=!0,this.variableNames=["x","mean","variance"],N.assertAndGetBroadcastShape(e,t),N.assertAndGetBroadcastShape(e,o);let i="vec4(0.0)";n!=null&&(N.assertAndGetBroadcastShape(e,n),this.variableNames.push("offset"),i="getOffsetAtOutCoords()");let l="vec4(1.0)";s!=null&&(N.assertAndGetBroadcastShape(e,s),this.variableNames.push("scale"),l="getScaleAtOutCoords()"),this.outputShape=e,this.userCode=`
      void main() {
        vec4 offset = ${i};
        vec4 scale = ${l};

        vec4 x = getXAtOutCoords();
        vec4 mean = getMeanAtOutCoords();
        vec4 variance = getVarianceAtOutCoords();

        vec4 inv = scale * inversesqrt(variance + vec4(${a}));

        setOutput((x - mean) * inv + offset);
      }
    `}};var u7=({inputs:r,backend:e,attrs:t})=>{let{x:o,mean:n,variance:s,offset:a,scale:i}=r;y.assert(n.shape.length===s.shape.length,()=>"Batch normalization gradient requires mean and variance to have equal ranks."),y.assert(a==null||n.shape.length===a.shape.length,()=>"Batch normalization gradient requires mean and offset to have equal ranks."),y.assert(i==null||n.shape.length===i.shape.length,()=>"Batch normalization gradient requires mean and scale to have equal ranks.");let{varianceEpsilon:l}=t;l==null&&(l=.001);let u=[o,n,s],c=null;a!=null&&(c=a.shape,u.push(a));let p=null;i!=null&&(p=i.shape,u.push(i));let m=G().getBool("WEBGL_PACK_NORMALIZATION")?new jv(o.shape,n.shape,s.shape,c,p,l):new Uv(o.shape,n.shape,s.shape,c,p,l);return e.runWebGLProgram(m,u,u[0].dtype)},hF={kernelName:on,backendName:"webgl",kernelFunc:u7};var Hv=class{constructor(e){this.variableNames=["source"],this.outputShape=e,this.rank=e.length;let t=Le(this.rank),o=`uniform int start[${this.rank}];`,n=c7(this.rank),s,a=e.map((i,l)=>`sourceLoc.${qv[l]} = start[${l}] + coords.${qv[l]};`);s=`
        ${t} sourceLoc;
        ${t} coords = getOutputCoords();
        ${a.join(`
`)}
      `,this.userCode=`
      ${o}
      void main() {
        ${s}
        setOutput(getSource(${n}));
      }
    `}getCustomSetupFunc(e){if(e.length!==this.rank)throw Error(`The rank (${this.rank}) of the program must match the length of start (${e.length})`);return(t,o)=>{this.startLoc==null&&(this.startLoc=t.getUniformLocationNoThrow(o,"start"),this.startLoc==null)||t.gl.uniform1iv(this.startLoc,e)}}},qv=["x","y","z","w","u","v"];function c7(r){if(r===1)return"sourceLoc";if(r<=6)return qv.slice(0,r).map(e=>"sourceLoc."+e).join(",");throw Error(`Slicing for rank ${r} is not yet supported`)}var Kv=class{constructor(e){this.variableNames=["source"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e,this.rank=e.length;let t=Le(this.rank),o=Ut("coords",this.rank),n=Ut("sourceLoc",this.rank),s=this.rank===1?"sourceLoc":`vec2(${n.slice(-2).join()})`,a=`getChannel(getSource(${n.join()}), ${s})`,i=`
      result.x = ${a};
      if (++${o[this.rank-1]} < ${e[this.rank-1]}) {
        ++${n[this.rank-1]};
        result.y = ${a};
        --${n[this.rank-1]};
      }
    `,l=this.rank===1?"":`
      --${o[this.rank-1]};
      if (++${o[this.rank-2]} < ${e[this.rank-2]}) {
        ++${n[this.rank-2]};
        result.z = ${a};
        if (++${o[this.rank-1]} < ${e[this.rank-1]}) {
          ++${n[this.rank-1]};
          result.w = ${a};
        }
      }
    `,u=this.rank<=4?`sourceLoc = coords +
            ${t}(${e.map((c,p)=>`start[${p}]`).join()});`:e.map((c,p)=>`${n[p]} = ${o[p]} + start[${p}];`).join(`
`);this.userCode=`
      uniform int start[${this.rank}];
      void main() {
        ${t} coords = getOutputCoords();
        ${t} sourceLoc;
        ${u}
        vec4 result = vec4(0.);
        ${i}
        ${l}
        setOutput(result);
      }
    `}getCustomSetupFunc(e){if(e.length!==this.rank)throw Error(`The rank (${this.rank}) of the program must match the length of start (${e.length})`);return(t,o)=>{this.startLoc==null&&(this.startLoc=t.getUniformLocationNoThrow(o,"start"),this.startLoc==null)||t.gl.uniform1iv(this.startLoc,e)}}};function p7(r,e,t,o){let n=o.texData.get(r.dataId),s=o.makeTensorInfo(t,r.dtype),a=o.texData.get(s.dataId);Object.assign(a,n),a.complexParentRefCount=0,a.refCount=1,a.shape=t,a.dtype=r.dtype;let i=or.computeFlatOffset(e,y.computeStrides(r.shape));n.slice&&(i+=n.slice.flatOffset),a.slice={flatOffset:i,origDataId:n.slice&&n.slice.origDataId||r.dataId};let l=o.dataRefCount.get(a.slice.origDataId)||1;return o.dataRefCount.set(a.slice.origDataId,l+1),s}function Ua(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{begin:s,size:a}=o,[i,l]=or.parseSliceParams(n,s,a);if(or.assertParamsValid(n,i,l),y.sizeFromShape(l)===0)return t.makeTensorInfo(l,n.dtype,[]);if(t.shouldExecuteOnCPU([n])||n.dtype==="string"){let p=t.texData.get(n.dataId),m=fR(p.values,i,l,n.shape,n.dtype);return t.makeTensorInfo(l,n.dtype,m)}let{isPacked:u}=t.texData.get(n.dataId),c=or.isSliceContinous(n.shape,i,l);if(u||!c){let p=G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")?new Kv(l):new Hv(l),m=p.getCustomSetupFunc(i);return t.runWebGLProgram(p,[n],n.dtype,m)}return t.uploadToGPU(n.dataId),p7(n,i,l,t)}var gF={kernelName:hs,backendName:"webgl",kernelFunc:Ua};var m7=r=>{let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{blockShape:s,crops:a}=o;y.assert(n.shape.length<=4,()=>"batchToSpaceND for rank > 4 with a WebGL backend not implemented yet");let i=s.reduce((b,_)=>b*_),l=N.getReshaped(n.shape,s,i),u=N.getPermuted(l.length,s.length),c=N.getReshapedPermuted(n.shape,s,i),p=N.getSliceBeginCoords(a,s.length),m=N.getSliceSize(c,a,s.length),f=[],d=ce({inputs:{x:n},backend:t,attrs:{shape:l}}),h=Lt({inputs:{x:d},backend:t,attrs:{perm:u}}),g=ce({inputs:{x:h},backend:t,attrs:{shape:c}}),x=Ua({inputs:{x:g},backend:t,attrs:{begin:p,size:m}});return f.push(d),f.push(h),f.push(g),f.forEach(b=>t.disposeIntermediateTensorInfo(b)),x},xF={kernelName:sa,backendName:"webgl",kernelFunc:m7};function f7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,weights:s}=e,{size:a}=o,i=t.readSync(n.dataId),l=t.readSync(s.dataId),u=Rx(i,l,s.dtype,s.shape,a);return t.makeTensorInfo([a],s.dtype,u)}var yF={kernelName:jl,backendName:"webgl",kernelFunc:f7};var d7="return float(a != b);",Xv=it({opSnippet:d7,dtype:"bool"}),bF={kernelName:bi,backendName:"webgl",kernelFunc:Xv};function ja(r){let{inputs:e,backend:t}=r,{input:o}=e,n=t.texData.get(o.dataId);return jt({inputs:{x:n.complexTensorInfos.real},backend:t})}var _F={kernelName:cu,backendName:"webgl",kernelFunc:ja};var h7="return float(int(x));";function wF(r,e){let t=new uo(r.shape,h7),o=e.runWebGLProgram(t,[r],"int32");return{dataId:o.dataId,shape:o.shape,dtype:o.dtype}}function Yv(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{dtype:s}=o;if(s==="complex64"){if(n.dtype==="complex64")return jt({inputs:{x:n},backend:t});let a=gt(n.shape),i=Yv({inputs:{x:n},backend:t,attrs:{dtype:"float32"}}),l=co({inputs:{real:i,imag:a},backend:t});return a.dispose(),t.disposeIntermediateTensorInfo(i),l}if(n.dtype==="complex64"){let a=ja({inputs:{input:n},backend:t}),i=Yv({inputs:{x:a},backend:t,attrs:{dtype:s}});return t.disposeIntermediateTensorInfo(a),i}if(!y.hasEncodingLoss(n.dtype,s)){let a=jt({inputs:{x:n},backend:t});return{dataId:a.dataId,shape:a.shape,dtype:s}}if(s==="int32")return wF(n,t);if(s==="bool"){let a=t.makeTensorInfo([],"bool",y.getTypedArrayFromDType("bool",1)),l=Xv({inputs:{a:n,b:a},backend:t});return t.disposeIntermediateTensorInfo(a),l}throw new Error(`Error in Cast: failed to cast ${n.dtype} to ${s}`)}var kF={kernelName:Eo,backendName:"webgl",kernelFunc:Yv};var vF="return ceil(x);",g7=ve({opSnippet:vF,packedOpSnippet:vF,cpuKernelImpl:X$}),CF={kernelName:ei,backendName:"webgl",kernelFunc:g7};var Zv=class{constructor(e){this.variableNames=["A"],this.outputShape=e,this.userCode=`
      uniform float minVal;
      uniform float maxVal;

      void main() {
        float value = getAAtOutCoords();
        if (isnan(value)) {
          setOutput(value);
          return;
        }

        setOutput(clamp(value, minVal, maxVal));
      }
    `}getCustomSetupFunc(e,t){return(o,n)=>{this.minLoc==null&&(this.minLoc=o.getUniformLocationNoThrow(n,"minVal"),this.maxLoc=o.getUniformLocationNoThrow(n,"maxVal")),o.gl.uniform1f(this.minLoc,e),o.gl.uniform1f(this.maxLoc,t)}}};var Jv=class{constructor(e){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e,this.userCode=`
      uniform float minVal;
      uniform float maxVal;

      void main() {
        vec4 value = getAAtOutCoords();

        if (any(isnan(value))) {
          setOutput(value);
          return;
        }

        setOutput(clamp(value, vec4(minVal), vec4(maxVal)));
      }
    `}getCustomSetupFunc(e,t){return(o,n)=>{this.minLoc==null&&(this.minLoc=o.getUniformLocationNoThrow(n,"minVal"),this.maxLoc=o.getUniformLocationNoThrow(n,"maxVal")),o.gl.uniform1f(this.minLoc,e),o.gl.uniform1f(this.maxLoc,t)}}};function x7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{clipValueMin:s,clipValueMax:a}=o,i;G().getBool("WEBGL_PACK_CLIP")?i=new Jv(n.shape):i=new Zv(n.shape);let l=i.getCustomSetupFunc(s,a);return t.runWebGLProgram(i,[n],n.dtype,l)}var IF={kernelName:Ao,backendName:"webgl",kernelFunc:x7};var Qv=class{constructor(e){this.variableNames=["real","imag"],this.outputShape=e,this.userCode=`
      void main() {
        float re = abs(getRealAtOutCoords());
        float im = abs(getImagAtOutCoords());
        float mx = max(re, im);

        // sadly the length function in glsl is not underflow-safe
        // (at least not on Intel GPUs). So the safe solution is
        // to ensure underflow-safety in all cases.
        setOutput(
          mx == 0.0 ? 0.0 : mx * length(vec2(1, min(re, im)/mx))
        );
      }
    `}};function NF(r,e){return{dataId:e.dataId,dtype:e.dtype,shape:r.shape}}function y7(r){let{inputs:e,backend:t}=r,{x:o}=e,n=t.texData.get(o.dataId),s=new Qv(o.shape),a=[NF(o,n.complexTensorInfos.real),NF(o,n.complexTensorInfos.imag)];return t.runWebGLProgram(s,a,a[0].dtype)}var SF={kernelName:ia,backendName:"webgl",kernelFunc:y7};var eC=class{constructor(e){this.outputShape=[],this.outputShape=N.computeOutShape(e,1),this.variableNames=e.map((a,i)=>`T${i}`);let t=new Array(e.length-1);t[0]=e[0][1];for(let a=1;a<t.length;a++)t[a]=t[a-1]+e[a][1];let o=[`if (yC < ${t[0]}) setOutput(getT0(yR, yC));`];for(let a=1;a<t.length;a++){let i=t[a-1];o.push(`else if (yC < ${t[a]}) setOutput(getT${a}(yR, yC-${i}));`)}let n=t.length,s=t[t.length-1];o.push(`else setOutput(getT${n}(yR, yC-${s}));`),this.userCode=`
      void main() {
        ivec2 coords = getOutputCoords();
        int yR = coords.x;
        int yC = coords.y;

        ${o.join(`
        `)}
      }
    `}};var tC=class{constructor(e,t){this.packedInputs=!0,this.packedOutput=!0,this.outputShape=[],this.outputShape=N.computeOutShape(e,t);let o=this.outputShape,n=o.length,s=Le(n),a=Ut("coords",n),i=["x","y","z","w","u","v"].slice(0,n);this.variableNames=e.map((h,g)=>`T${g}`);let l=new Array(e.length-1);l[0]=e[0][t];for(let h=1;h<l.length;h++)l[h]=l[h-1]+e[h][t];let u=i[t],c=i.slice(-2),p=i.join(),m=`if (${u} < ${l[0]}) {
        return getChannel(
            getT0(${p}), vec2(${c.join()}));
        }`;for(let h=1;h<l.length;h++){let g=l[h-1];m+=`
        if (${u} < ${l[h]}  && ${u} >= ${l[h-1]}) {
          return getChannel(
            getT${h}(${Gx(i,u,g)}),
            vec2(${Gx(c,u,g)}));
        }`}let f=l.length,d=l[l.length-1];m+=`
        return getChannel(
          getT${f}(${Gx(i,u,d)}),
          vec2(${Gx(c,u,d)}));`,this.userCode=`
      float getValue(${i.map(h=>"int "+h)}) {
        ${m}
      }

      void main() {
        ${s} coords = getOutputCoords();
        vec4 result = vec4(getValue(${a}), 0., 0., 0.);

        ${a[n-1]} = ${a[n-1]} + 1;
        if (${a[n-1]} < ${o[n-1]}) {
          result.g = getValue(${a});
        }

        ${a[n-2]} = ${a[n-2]} + 1;
        if (${a[n-2]} < ${o[n-2]}) {
          result.a = getValue(${a});
        }

        ${a[n-1]} = ${a[n-1]} - 1;
        if (${a[n-2]} < ${o[n-2]} &&
            ${a[n-1]} < ${o[n-1]}) {
          result.b = getValue(${a});
        }
        setOutput(result);
      }
    `}};function Gx(r,e,t){let o=r.indexOf(e);return r.map((s,a)=>a===o?`${s} - ${t}`:s).join()}function pc(r){let{inputs:e,backend:t}=r,{input:o}=e,n=t.texData.get(o.dataId);return jt({inputs:{x:n.complexTensorInfos.imag},backend:t})}var TF={kernelName:ou,backendName:"webgl",kernelFunc:pc};function mc(r,e,t){let o=r[0].dtype;if(o==="complex64"){let u=r.map(d=>ja({inputs:{input:d},backend:t})),c=r.map(d=>pc({inputs:{input:d},backend:t})),p=mc(u,e,t),m=mc(c,e,t),f=co({inputs:{real:p,imag:m},backend:t});return u.forEach(d=>t.disposeIntermediateTensorInfo(d)),c.forEach(d=>t.disposeIntermediateTensorInfo(d)),t.disposeIntermediateTensorInfo(p),t.disposeIntermediateTensorInfo(m),f}if(o==="string"){let{tensors2D:u,outShape:c}=EF(r,e,t),p=u.map(g=>({vals:t.readSync(g.dataId),shape:g.shape})),m=u[0].shape[0]===1,f=Y$(p,c,o,m),d=N.computeOutShape(r.map(g=>g.shape),e),h=t.makeTensorInfo(d,o,f);return u.forEach(g=>t.disposeIntermediateTensorInfo(g)),h}if(r.length>G().getNumber("WEBGL_MAX_TEXTURES_IN_SHADER")){let u=Math.floor(r.length/2),c=mc(r.slice(0,u),e,t),p=mc(r.slice(u),e,t),m=mc([c,p],e,t);return t.disposeIntermediateTensorInfo(c),t.disposeIntermediateTensorInfo(p),m}if(G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")&&r[0].shape.length>1){let u=new tC(r.map(c=>c.shape),e);return t.runWebGLProgram(u,r,o)}let{tensors2D:n,outShape:s}=EF(r,e,t),a=new eC(n.map(u=>u.shape)),i=t.runWebGLProgram(a,n,o);n.forEach(u=>t.disposeIntermediateTensorInfo(u));let l=ce({inputs:{x:i},attrs:{shape:s},backend:t});return t.disposeIntermediateTensorInfo(i),l}function EF(r,e,t){let o=N.computeOutShape(r.map(s=>s.shape),e);return{tensors2D:r.map(s=>ce({inputs:{x:s},attrs:{shape:[-1,y.sizeFromShape(s.shape.slice(e))]},backend:t})),outShape:o}}function rC(r){let{inputs:e,backend:t,attrs:o}=r,{axis:n}=o,s=y.parseAxisParam(n,e[0].shape)[0],a=N.computeOutShape(e.map(u=>u.shape),s);if(y.sizeFromShape(a)===0)return t.makeTensorInfo(a,e[0].dtype,[]);let i=e.filter(u=>y.sizeFromShape(u.shape)>0);if(i.length===1)return jt({inputs:{x:i[0]},backend:t});let l=i.map(u=>u.shape);return N.assertParamsConsistent(l,s),mc(i,s,t)}var AF={kernelName:is,backendName:"webgl",kernelFunc:rC};var lh=class{constructor(e,t=!1,o=null,n=!1,s=!1){this.variableNames=["x","W"],this.outputShape=e.outShape;let a=e.padInfo.top,i=e.padInfo.left,l=e.strideHeight,u=e.strideWidth,c=e.dilationHeight,p=e.dilationWidth,m=e.filterHeight,f=e.filterWidth,d=Math.floor(e.inChannels/4)*4,h=e.inChannels%4,g=e.dataFormat==="channelsLast",x=g?1:2,b=g?2:3,_=g?3:1,w="",v="";o&&(n?w=`float activation(float a) {
          float b = getPreluActivationWeightsAtOutCoords();
          ${o}
        }`:s?w=`float activation(float a) {
          float b = getLeakyreluAlphaAtOutCoords();
          ${o}
        }`:w=`
          float activation(float x) {
            ${o}
          }
        `,v="result = activation(result);");let $=t?"result += getBiasAtOutCoords();":"";t&&this.variableNames.push("bias"),n&&this.variableNames.push("preluActivationWeights"),s&&this.variableNames.push("leakyreluAlpha"),this.userCode=`
      ${w}

      const ivec2 strides = ivec2(${l}, ${u});
      const ivec2 pads = ivec2(${a}, ${i});

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords[0];
        int d2 = coords[${_}];

        ivec2 xRCCorner =
            ivec2(coords[${x}], coords[${b}]) * strides - pads;
        int xRCorner = xRCCorner.x;
        int xCCorner = xRCCorner.y;

        // Convolve x(?, ?, d1) with w(:, :, d1, d2) to get y(yR, yC, d2).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;
        for (int wR = 0; wR < ${m}; wR++) {
          int xR = xRCorner + wR * ${c};

          if (xR < 0 || xR >= ${e.inHeight}) {
            continue;
          }

          for (int wC = 0; wC < ${f}; wC++) {
            int xC = xCCorner + wC * ${p};

            if (xC < 0 || xC >= ${e.inWidth}) {
              continue;
            }

            for (int d1 = 0; d1 < ${d}; d1 += 4) {
              vec4 wValues = vec4(
                getW(wR, wC, d1, d2),
                getW(wR, wC, d1 + 1, d2),
                getW(wR, wC, d1 + 2, d2),
                getW(wR, wC, d1 + 3, d2)
              );

              if (${g}) {
                vec4 xValues = vec4(
                  getX(batch, xR, xC, d1),
                  getX(batch, xR, xC, d1 + 1),
                  getX(batch, xR, xC, d1 + 2),
                  getX(batch, xR, xC, d1 + 3)
                );
                dotProd += dot(xValues, wValues);
              } else {
                vec4 xValues = vec4(
                  getX(batch, d1, xR, xC),
                  getX(batch, d1 + 1, xR, xC),
                  getX(batch, d1 + 2, xR, xC),
                  getX(batch, d1 + 3, xR, xC)
                );
                dotProd += dot(xValues, wValues);
              }
            }

            if (${h===1}) {

              if (${g}) {
                dotProd +=
                    getX(batch, xR, xC, ${d}) *
                    getW(wR, wC, ${d}, d2);
              } else {
                dotProd +=
                    getX(batch, ${d}, xR, xC) *
                    getW(wR, wC, ${d}, d2);
              }

            } else if (${h===2}) {
              vec2 wValues = vec2(
                getW(wR, wC, ${d}, d2),
                getW(wR, wC, ${d} + 1, d2)
              );

              if (${g}) {
                vec2 xValues = vec2(
                  getX(batch, xR, xC, ${d}),
                  getX(batch, xR, xC, ${d} + 1)
                );
                dotProd += dot(xValues, wValues);
              } else {
                vec2 xValues = vec2(
                  getX(batch, ${d}, xR, xC),
                  getX(batch, ${d} + 1, xR, xC)
                );
                dotProd += dot(xValues, wValues);
              }

            } else if (${h===3}) {
              vec3 wValues = vec3(
                getW(wR, wC, ${d}, d2),
                getW(wR, wC, ${d} + 1, d2),
                getW(wR, wC, ${d} + 2, d2)
              );

              if (${g}) {
                vec3 xValues = vec3(
                  getX(batch, xR, xC, ${d}),
                  getX(batch, xR, xC, ${d} + 1),
                  getX(batch, xR, xC, ${d} + 2)
                );
                dotProd += dot(xValues, wValues);
              } else {
                vec3 xValues = vec3(
                  getX(batch, ${d}, xR, xC),
                  getX(batch, ${d} + 1, xR, xC),
                  getX(batch, ${d} + 2, xR, xC)
                );
                dotProd += dot(xValues, wValues);
              }

            }
          }
        }

        float result = dotProd;
        ${$}
        ${v}
        setOutput(result);
      }
    `}},oC=class{constructor(e){this.variableNames=["x","W"],this.outputShape=e.outShape;let t=e.padInfo.front,o=e.padInfo.top,n=e.padInfo.left,s=e.strideDepth,a=e.strideHeight,i=e.strideWidth,l=e.dilationDepth,u=e.dilationHeight,c=e.dilationWidth,p=e.filterDepth,m=e.filterHeight,f=e.filterWidth,d=Math.floor(e.inChannels/4)*4,h=e.inChannels%4;this.userCode=`
      const ivec3 strides = ivec3(${s}, ${a}, ${i});
      const ivec3 pads = ivec3(${t}, ${o}, ${n});

      void main() {
        ivec5 coords = getOutputCoords();
        int batch = coords.x;
        int d2 = coords.u;

        ivec3 xFRCCorner = ivec3(coords.y, coords.z, coords.w) * strides - pads;
        int xFCorner = xFRCCorner.x;
        int xRCorner = xFRCCorner.y;
        int xCCorner = xFRCCorner.z;

        // Convolve x(?, ?, ?, d1) with w(:, :, :, d1, d2) to get
        // y(yF, yR, yC, d2). ? = to be determined. : = across all
        // values in that axis.
        float dotProd = 0.0;
        for (int wF = 0; wF < ${p}; wF++) {
          int xF = xFCorner + wF * ${l};

          if (xF < 0 || xF >= ${e.inDepth}) {
            continue;
          }

          for (int wR = 0; wR < ${m}; wR++) {
            int xR = xRCorner + wR * ${u};

            if (xR < 0 || xR >= ${e.inHeight}) {
              continue;
            }

            for (int wC = 0; wC < ${f}; wC++) {
              int xC = xCCorner + wC * ${c};

              if (xC < 0 || xC >= ${e.inWidth}) {
                continue;
              }

              for (int d1 = 0; d1 < ${d}; d1 += 4) {
                vec4 xValues = vec4(
                  getX(batch, xF, xR, xC, d1),
                  getX(batch, xF, xR, xC, d1 + 1),
                  getX(batch, xF, xR, xC, d1 + 2),
                  getX(batch, xF, xR, xC, d1 + 3)
                );
                vec4 wValues = vec4(
                  getW(wF, wR, wC, d1, d2),
                  getW(wF, wR, wC, d1 + 1, d2),
                  getW(wF, wR, wC, d1 + 2, d2),
                  getW(wF, wR, wC, d1 + 3, d2)
                );

                dotProd += dot(xValues, wValues);
              }

              if (${h===1}) {
                dotProd +=
                  getX(batch, xF, xR, xC, ${d}) *
                  getW(wF, wR, wC, ${d}, d2);
              } else if (${h===2}) {
                vec2 xValues = vec2(
                  getX(batch, xF, xR, xC, ${d}),
                  getX(batch, xF, xR, xC, ${d} + 1)
                );
                vec2 wValues = vec2(
                  getW(wF, wR, wC, ${d}, d2),
                  getW(wF, wR, wC, ${d} + 1, d2)
                );
                dotProd += dot(xValues, wValues);
              } else if (${h===3}) {
                vec3 xValues = vec3(
                  getX(batch, xF, xR, xC, ${d}),
                  getX(batch, xF, xR, xC, ${d} + 1),
                  getX(batch, xF, xR, xC, ${d} + 2)
                );
                vec3 wValues = vec3(
                  getW(wF, wR, wC, ${d}, d2),
                  getW(wF, wR, wC, ${d} + 1, d2),
                  getW(wF, wR, wC, ${d} + 2, d2)
                );
                dotProd += dot(xValues, wValues);
              }
            }
          }
        }
        setOutput(dotProd);
      }
    `}};var nC=class{constructor(e,t,o){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e;let{filterWidth:n,inChannels:s,strideWidth:a,strideHeight:i,padInfo:l,outWidth:u,dilationWidth:c,dilationHeight:p,dataFormat:m}=o,{left:f,top:d}=l,h=s*n,g=Mt(),x=m==="channelsLast",b=x?0:1,_=x?1:2,w="";for(let v=0;v<=1;v++)for(let $=0;$<=1;$++)w+=`
          blockIndex = rc.y + ${$};
          pos = rc.x + ${v};

          if(blockIndex < ${e[1]} && pos < ${e[0]}) {
            offsetY = int(blockIndex / (${u})) * ${i} - ${d};
            d0 = offsetY + ${p} * (pos / ${h});

            if(d0 < ${t[b]} && d0 >= 0) {

              offsetX = int(mod(float(blockIndex), ${u}.) * ${a}. - ${f}.);
              d1 = offsetX + ${c} * (int(mod(float(pos), ${h}.) / ${s}.));

              if(d1 < ${t[_]} && d1 >= 0) {

                ch = int(mod(float(pos), ${s}.));

                if (${x}) {
                  innerDims = vec2(d1, ch);
                  result[${v*2+$}] = getChannel(
                    getA(d0, int(innerDims.x),
                    int(innerDims.y)), innerDims);
                } else {
                  innerDims = vec2(d0, d1);
                  result[${v*2+$}] = getChannel(
                    getA(ch, int(innerDims.x),
                    int(innerDims.y)), innerDims);
                }
              }
            }
          }
        `;this.userCode=`
      void main() {
        ivec2 rc = getOutputCoords();

        vec4 result = vec4(0);

        int blockIndex, pos, offsetY, d0, offsetX, d1, ch;
        vec2 innerDims;

        ${w}

        ${g.output} = result;
      }
    `}};function Wx({x:r,filter:e,convInfo:t,backend:o,bias:n=null,preluActivationWeights:s=null,leakyreluAlpha:a=0,activation:i=null}){let l=r.shape,u=o.texData.get(r.dataId),c=t.inChannels,p=l[0]*l[1]*l[2],m=t.outChannels,f=t.dataFormat==="channelsLast",d=!1,h=!1,g,x=[],b=(p===1||m===1)&&c>Mv,_=l[2]%2!=0&&!!u.isPacked;if(b||!G().getBool("WEBGL_LAZILY_UNPACK")||!G().getBool("WEBGL_PACK_BINARY_OPERATIONS")||!_){let w=f?l[0]*l[1]*l[2]:l[0]*l[2]*l[3],v=ce({inputs:{x:r},backend:o,attrs:{shape:[1,w,t.inChannels]}}),$=ce({inputs:{x:e},backend:o,attrs:{shape:[1,t.inChannels,t.outChannels]}}),A=uc({a:v,b:$,transposeA:d,transposeB:h,backend:o,bias:n,activation:i,preluActivationWeights:s,leakyreluAlpha:a});g=ce({inputs:{x:A},backend:o,attrs:{shape:t.outShape}}),x.push(v),x.push($),x.push(A)}else{let w=f?l[0]*l[1]*(l[2]+1):l[0]*l[2]*(l[3]+1),v={dataId:r.dataId,shape:[1,w,t.inChannels],dtype:r.dtype},$=u.shape;u.shape=u.shape.slice(),u.shape[u.shape.length-2]++,y.assert(ac(u.shape,v.shape),()=>`packed reshape ${u.shape} to ${v.shape} isn't free`);let A=ce({inputs:{x:e},backend:o,attrs:{shape:[1,t.inChannels,t.outChannels]}});x.push(A);let R=uc({a:v,b:A,backend:o,transposeA:d,transposeB:h,bias:n,activation:i,preluActivationWeights:s,leakyreluAlpha:a}),M=o.texData.get(R.dataId);y.assert(M.isPacked,()=>"batchMatMul result is expected to be packed"),u.shape=$,M.shape=t.outShape,g=jt({inputs:{x:R},backend:o}),g.shape=t.outShape,x.push(R)}for(let w of x)o.disposeIntermediateTensorInfo(w);return g}function Ux({x:r,filter:e,convInfo:t,backend:o,bias:n=null,preluActivationWeights:s=null,leakyreluAlpha:a=0,activation:i=null}){let{filterWidth:l,filterHeight:u,inChannels:c,outWidth:p,outHeight:m,dataFormat:f}=t,d=f==="channelsLast",h=l*u*c,g=m*p,x=[h,g],b=!0,_=!1,w=[],v=ce({inputs:{x:r},backend:o,attrs:{shape:r.shape.slice(1)}}),$=ce({inputs:{x:e},backend:o,attrs:{shape:[1,h,y.sizeFromShape(e.shape)/h]}});w.push(v),w.push($);let A=new nC(x,v.shape,t),R=o.runWebGLProgram(A,[v],"float32"),M=ce({inputs:{x:R},backend:o,attrs:{shape:[1,x[0],x[1]]}});w.push(R),w.push(M);let z=n!=null,W=s!=null,U=i==="leakyrelu",q=i?El(i,!0):null,Z=new ih(M.shape,$.shape,[1,g,t.outChannels],b,_,z,q,W,U),X=[M,$];if(n&&X.push(n),W&&X.push(s),U){let re=o.makeTensorInfo([],"float32",y.createScalarValue(a,"float32"));X.push(re),w.push(re)}let Y=o.runWebGLProgram(Z,X,"float32"),te=d?[1,m,p,t.outChannels]:[1,t.outChannels,m,p],K=ce({inputs:{x:Y},backend:o,attrs:{shape:te}});w.push(Y);for(let re of w)o.disposeIntermediateTensorInfo(re);return K}function b7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s}=e,{strides:a,pad:i,dataFormat:l,dilations:u,dimRoundingMode:c}=o,p=N.convertConv2DDataFormat(l),m=N.computeConv2DInfo(n.shape,s.shape,a,u,i,c,!1,p),f;if(m.filterHeight===1&&m.filterWidth===1&&m.dilationHeight===1&&m.dilationWidth===1&&m.strideHeight===1&&m.strideWidth===1&&(m.padInfo.type==="SAME"||m.padInfo.type==="VALID"))f=Wx({x:n,filter:s,convInfo:m,backend:t});else if(G().getBool("WEBGL_CONV_IM2COL")&&n.shape[0]===1)f=Ux({x:n,filter:s,convInfo:m,backend:t});else{let h=new lh(m);f=t.runWebGLProgram(h,[n,s],"float32")}let d=ce({inputs:{x:f},backend:t,attrs:{shape:m.outShape}});return t.disposeIntermediateTensorInfo(f),d}var DF={kernelName:Ko,backendName:"webgl",kernelFunc:b7};var sC=class{constructor(e){this.variableNames=["x","dy"],this.outputShape=e.filterShape;let t=e.strideHeight,o=e.strideWidth,n=e.padInfo.top,s=e.padInfo.left,a=e.dataFormat==="channelsLast";this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int wR = coords.x;
        int wC = coords.y;
        int d1 = coords.z;
        int d2 = coords.w;

        // Convolve x(?, ?, d1) with dy(:, :, d2) to get dw(wR, wC, d1, d2).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;

        for (int b = 0; b < ${e.batchSize}; b++) {
          for (int yR = 0; yR < ${e.outHeight}; yR++) {
            int xR = wR + yR * ${t} - ${n};

            if (xR < 0 || xR >= ${e.inHeight}) {
              continue;
            }

            for (int yC = 0; yC < ${e.outWidth}; yC++) {
              int xC = wC + yC * ${o} - ${s};

              if (xC < 0 || xC >= ${e.inWidth}) {
                continue;
              }

              if (${a}) {
                float dyValue = getDy(b, yR, yC, d2);
                float xValue = getX(b, xR, xC, d1);
                dotProd += (xValue * dyValue);
              } else {
                float dyValue = getDy(b, d2, yR, yC);
                float xValue = getX(b, d1, xR, xC);
                dotProd += (xValue * dyValue);
              }

            }
          }
        }
        setOutput(dotProd);
      }
    `}},iC=class{constructor(e){this.variableNames=["dy","W"],this.outputShape=e.inShape;let t=e.filterHeight,o=e.filterWidth,n=e.strideHeight,s=e.strideWidth,a=e.dataFormat==="channelsLast",i=t-1-e.padInfo.top,l=o-1-e.padInfo.left,u=a?1:2,c=a?2:3,p=a?3:1;this.userCode=`
      const ivec2 pads = ivec2(${i}, ${l});

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords[0];
        int d1 = coords[${p}];

        ivec2 dyCorner = ivec2(coords[${u}], coords[${c}]) - pads;
        int dyRCorner = dyCorner.x;
        int dyCCorner = dyCorner.y;

        // Convolve dy(?, ?, d2) with w(:, :, d1, d2) to compute dx(xR, xC, d1).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;
        for (int wR = 0; wR < ${t}; wR++) {
          float dyR = float(dyRCorner + wR) / ${n}.0;

          if (dyR < 0.0 || dyR >= ${e.outHeight}.0 || fract(dyR) > 0.0) {
            continue;
          }
          int idyR = int(dyR);

          int wRPerm = ${t} - 1 - wR;

          for (int wC = 0; wC < ${o}; wC++) {
            float dyC = float(dyCCorner + wC) / ${s}.0;

            if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                fract(dyC) > 0.0) {
              continue;
            }
            int idyC = int(dyC);

            int wCPerm = ${o} - 1 - wC;

            for (int d2 = 0; d2 < ${e.outChannels}; d2++) {

              if (${a}) {
                float xValue = getDy(batch, idyR, idyC, d2);
                float wValue = getW(wRPerm, wCPerm, d1, d2);
                dotProd += xValue * wValue;
              } else {
                float xValue = getDy(batch, d2, idyR, idyC);
                float wValue = getW(wRPerm, wCPerm, d1, d2);
                dotProd += xValue * wValue;
              }

            }
          }
        }
        setOutput(dotProd);
      }
    `}},aC=class{constructor(e){this.variableNames=["x","dy"],this.outputShape=e.filterShape;let t=e.strideDepth,o=e.strideHeight,n=e.strideWidth,s=e.padInfo.front,a=e.padInfo.top,i=e.padInfo.left;this.userCode=`
      void main() {
        ivec5 coords = getOutputCoords();
        int wF = coords.x;
        int wR = coords.y;
        int wC = coords.z;
        int d1 = coords.w;
        int d2 = coords.u;

        float dotProd = 0.0;

        for (int b = 0; b < ${e.batchSize}; b++) {
          for (int yF = 0; yF < ${e.outDepth}; yF++) {
            int xF = wF + yF * ${t} - ${s};

            if (xF < 0 || xF >= ${e.inDepth}) {
              continue;
            }

            for (int yR = 0; yR < ${e.outHeight}; yR++) {
              int xR = wR + yR * ${o} - ${a};

              if (xR < 0 || xR >= ${e.inHeight}) {
                continue;
              }

              for (int yC = 0; yC < ${e.outWidth}; yC++) {
                int xC = wC + yC * ${n} - ${i};

                if (xC < 0 || xC >= ${e.inWidth}) {
                  continue;
                }

                float dyValue = getDy(b, yF, yR, yC, d2);
                float xValue = getX(b, xF, xR, xC, d1);
                dotProd += (xValue * dyValue);
              }
            }
          }
        }
        setOutput(dotProd);
      }
    `}},lC=class{constructor(e){this.variableNames=["dy","W"],this.outputShape=e.inShape;let t=e.filterDepth,o=e.filterHeight,n=e.filterWidth,s=e.strideDepth,a=e.strideHeight,i=e.strideWidth,l=t-1-e.padInfo.front,u=o-1-e.padInfo.top,c=n-1-e.padInfo.left;this.userCode=`
      const ivec3 pads = ivec3(${l}, ${u}, ${c});

      void main() {
        ivec5 coords = getOutputCoords();
        int batch = coords.x;
        int d1 = coords.u;


        ivec3 dyCorner = ivec3(coords.y, coords.z, coords.w) - pads;
        int dyFCorner = dyCorner.x;
        int dyRCorner = dyCorner.y;
        int dyCCorner = dyCorner.z;

        float dotProd = 0.0;
        for (int wF = 0; wF < ${t}; wF++) {
          float dyF = float(dyFCorner + wF) / ${s}.0;

          if (dyF < 0.0 || dyF >= ${e.outDepth}.0 || fract(dyF) > 0.0) {
            continue;
          }
          int idyF = int(dyF);

          int wFPerm = ${t} - 1 - wF;

          for (int wR = 0; wR < ${o}; wR++) {
            float dyR = float(dyRCorner + wR) / ${a}.0;

            if (dyR < 0.0 || dyR >= ${e.outHeight}.0 ||
              fract(dyR) > 0.0) {
              continue;
            }
            int idyR = int(dyR);

            int wRPerm = ${o} - 1 - wR;

            for (int wC = 0; wC < ${n}; wC++) {
              float dyC = float(dyCCorner + wC) / ${i}.0;

              if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                  fract(dyC) > 0.0) {
                continue;
              }
              int idyC = int(dyC);

              int wCPerm = ${n} - 1 - wC;

              for (int d2 = 0; d2 < ${e.outChannels}; d2++) {
                float xValue = getDy(batch, idyF, idyR, idyC, d2);
                float wValue = getW(wFPerm, wRPerm, wCPerm, d1, d2);
                dotProd += xValue * wValue;
              }
            }
          }
        }
        setOutput(dotProd);
      }
    `}};function _7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,dy:s}=e,{strides:a,pad:i,dataFormat:l,dimRoundingMode:u,filterShape:c}=o,p=N.convertConv2DDataFormat(l),m=N.computeConv2DInfo(n.shape,c,a,1,i,u,!1,p),f=new sC(m);return t.runWebGLProgram(f,[n,s],"float32")}var $F={kernelName:ql,backendName:"webgl",kernelFunc:_7};function w7(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,filter:s}=e,{inputShape:a,strides:i,pad:l,dataFormat:u,dimRoundingMode:c}=o,p=N.convertConv2DDataFormat(u),m=N.computeConv2DInfo(a,s.shape,i,1,l,c,!1,p),f=new iC(m);return t.runWebGLProgram(f,[n,s],"float32")}var RF={kernelName:Xo,backendName:"webgl",kernelFunc:w7};function k7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s}=e,{strides:a,pad:i,dilations:l}=o,u=N.computeConv3DInfo(n.shape,s.shape,a,l,i),c=new oC(u);return t.runWebGLProgram(c,[n,s],"float32")}var FF={kernelName:aa,backendName:"webgl",kernelFunc:k7};function v7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,dy:s}=e,{strides:a,pad:i,filterShape:l}=o,u=N.computeConv3DInfo(n.shape,l,a,1,i),c=new aC(u);return t.runWebGLProgram(c,[n,s],"float32")}var OF={kernelName:Kl,backendName:"webgl",kernelFunc:v7};function C7(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,filter:s}=e,{pad:a,strides:i,inputShape:l}=o,u=N.computeConv3DInfo(l,s.shape,i,1,a),c=new lC(u);return t.runWebGLProgram(c,[n,s],"float32")}var PF={kernelName:Xl,backendName:"webgl",kernelFunc:C7};var I7=Mx+`
  return cos(x);
`,N7=ve({opSnippet:I7}),MF={kernelName:Yo,backendName:"webgl",kernelFunc:N7};var S7=`
  float e2x = exp(-x);
  return (e2x + 1.0 / e2x) / 2.0;
`,T7=ve({opSnippet:S7}),LF={kernelName:ti,backendName:"webgl",kernelFunc:T7};var uC=class{constructor(e,t,o,n,s){this.variableNames=["Image","Boxes","BoxInd"],this.outputShape=[];let[a,i,l,u]=e,[c]=t,[p,m]=o;this.outputShape=[c,p,m,u];let f=n==="bilinear"?1:0,[d,h]=[`${i-1}.0`,`${l-1}.0`],[g,x,b]=p>1?[`${(i-1)/(p-1)}`,"(y2-y1) * height_ratio",`y1*${d} + float(y)*(height_scale)`]:["0.0","0.0",`0.5 * (y1+y2) * ${d}`],[_,w,v]=m>1?[`${(l-1)/(m-1)}`,"(x2-x1) * width_ratio",`x1*${h} + float(x)*(width_scale)`]:["0.0","0.0",`0.5 * (x1+x2) * ${h}`];this.userCode=`
      const float height_ratio = float(${g});
      const float width_ratio = float(${_});
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int y = coords[1];
        int x = coords[2];
        int d = coords[3];

        // get box vals
        float y1 = getBoxes(b,0);
        float x1 = getBoxes(b,1);
        float y2 = getBoxes(b,2);
        float x2 = getBoxes(b,3);

        // get image in batch index
        int bInd = round(getBoxInd(b));
        if(bInd < 0 || bInd >= ${a}) {
          return;
        }

        float height_scale = ${x};
        float width_scale = ${w};

        float in_y = ${b};
        if( in_y < 0.0 || in_y > ${d} ) {
          setOutput(float(${s}));
          return;
        }
        float in_x = ${v};
        if( in_x < 0.0 || in_x > ${h} ) {
          setOutput(float(${s}));
          return;
        }

        vec2 sourceFracIndexCR = vec2(in_x,in_y);
        if(${f} == 1) {
          // Compute the four integer indices.
          ivec2 sourceFloorCR = ivec2(sourceFracIndexCR);
          ivec2 sourceCeilCR = ivec2(ceil(sourceFracIndexCR));

          float topLeft = getImage(b, sourceFloorCR.y, sourceFloorCR.x, d);
          float bottomLeft = getImage(b, sourceCeilCR.y, sourceFloorCR.x, d);
          float topRight = getImage(b, sourceFloorCR.y, sourceCeilCR.x, d);
          float bottomRight = getImage(b, sourceCeilCR.y, sourceCeilCR.x, d);

          vec2 fracCR = sourceFracIndexCR - vec2(sourceFloorCR);

          float top = topLeft + (topRight - topLeft) * fracCR.x;
          float bottom = bottomLeft + (bottomRight - bottomLeft) * fracCR.x;
          float newValue = top + (bottom - top) * fracCR.y;
          setOutput(newValue);
        } else {
          // Compute the coordinators of nearest neighbor point.
          ivec2 sourceNearestCR = ivec2(floor(
            sourceFracIndexCR + vec2(0.5,0.5)));
          float newValue = getImage(b, sourceNearestCR.y, sourceNearestCR.x, d);
          setOutput(newValue);
        }
      }
    `}};var E7=r=>{let{inputs:e,backend:t,attrs:o}=r,{image:n,boxes:s,boxInd:a}=e,{cropSize:i,method:l,extrapolationValue:u}=o,c=new uC(n.shape,s.shape,i,l,u);return t.runWebGLProgram(c,[n,s,a],"float32")},zF={kernelName:ri,backendName:"webgl",kernelFunc:E7};var jx=class{constructor(e,t,o){this.variableNames=["x"],this.outputShape=e;let n=e.length,s=t?"0.0":`getX(${BF(n,"coords")})`,a=e[e.length-1],i="",l="";t?(i=o?`end != ${a-1}`:"end != 0",l=o?"end + 1":"end - 1"):(i=o?`end + pow2 < ${a}`:"end >= pow2",l=o?"end + pow2":"end - pow2"),this.userCode=`
      uniform float index;
      void main() {
        ${Le(n)} coords = getOutputCoords();
        int end = ${VF(n,"coords")};
        float val = ${s};
        int pow2 = int(pow(2.0, index));
        if (${i}) {
          int idx = ${l};
          ${VF(n,"coords")} = idx;
          val += getX(${BF(n,"coords")});
        }
        setOutput(val);
      }
    `}getCustomSetupFunc(e){return(t,o)=>{this.index==null&&(this.index=t.getUniformLocation(o,"index")),t.gl.uniform1f(this.index,e)}}};function BF(r,e){if(r===1)return`${e}`;if(r===2)return`${e}.x, ${e}.y`;if(r===3)return`${e}.x, ${e}.y, ${e}.z`;if(r===4)return`${e}.x, ${e}.y, ${e}.z, ${e}.w`;throw Error(`Cumulative sum for rank ${r} is not yet supported`)}function VF(r,e){if(r===1)return`${e}`;if(r===2)return`${e}.y`;if(r===3)return`${e}.z`;if(r===4)return`${e}.w`;throw Error(`Cumulative sum for rank ${r} is not yet supported`)}function A7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,exclusive:a,reverse:i}=o,l=n.shape.length,u=N.getAxesPermutation([s],l),c=n;u!=null&&(c=Lt({inputs:{x:n},backend:t,attrs:{perm:u}}));let p=N.getInnerMostAxes(1,l)[0];if(p!==l-1)throw new Error(`WebGL cumsum shader expects an inner-most axis=${n.shape.length-1} but got axis=${s}`);let m=n.shape[p],f=jt({inputs:{x:c},backend:t});for(let d=0;d<=Math.ceil(Math.log2(m))-1;d++){let h=new jx(c.shape,!1,i),g=h.getCustomSetupFunc(d),x=f;f=t.runWebGLProgram(h,[f],f.dtype,g),t.disposeIntermediateTensorInfo(x)}if(a){let d=new jx(c.shape,a,i),h=f;f=t.runWebGLProgram(d,[f],f.dtype),t.disposeIntermediateTensorInfo(h)}if(u!=null){let d=N.getUndoAxesPermutation(u),h=Lt({inputs:{x:f},backend:t,attrs:{perm:d}});return t.disposeIntermediateTensorInfo(f),t.disposeIntermediateTensorInfo(c),h}return f}var GF={kernelName:Zo,backendName:"webgl",kernelFunc:A7};function D7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,weights:s}=e,{size:a,binaryOutput:i}=o;if(n.shape.length===1){let l=t.readSync(n.dataId),u=t.readSync(s.dataId),c=Rx(l,u,s.dtype,s.shape,a);return t.makeTensorInfo([a],s.dtype,c)}else if(n.shape.length===2){let l=t.bufferSync(n),u=t.bufferSync(s),c=K$(l,u,a,i);return t.makeTensorInfo(c.shape,s.dtype,c.values)}throw new Error(`Error in denseBincount: input must be at most rank 2, but got rank${n.shape.length}.`)}var WF={kernelName:Yl,backendName:"webgl",kernelFunc:D7};var cC=class{constructor(e,t,o){this.variableNames=["x"],this.outputShape=[],this.outputShape=e,this.blockSize=t,this.dataFormat=o,this.userCode=`
    void main() {
      ivec4 coords = getOutputCoords();
      int b = coords[0];
      int h = ${this.getHeightCoordString()};
      int w = ${this.getWidthCoordString()};
      int d = ${this.getDepthCoordString()};

      int in_h = h / ${t};
      int offset_h = imod(h, ${t});
      int in_w = w / ${t};
      int offset_w = imod(w, ${t});
      int offset_d = (offset_h * ${t} + offset_w) *
        ${this.getOutputDepthSize()};
      int in_d = d + offset_d;

      float result = ${this.getInputSamplingString()};
      setOutput(result);
    }
  `}getHeightCoordString(){return this.dataFormat==="NHWC"?"coords[1]":"coords[2]"}getWidthCoordString(){return this.dataFormat==="NHWC"?"coords[2]":"coords[3]"}getDepthCoordString(){return this.dataFormat==="NHWC"?"coords[3]":"coords[1]"}getOutputDepthSize(){return this.dataFormat==="NHWC"?this.outputShape[3]:this.outputShape[1]}getInputSamplingString(){return this.dataFormat==="NHWC"?"getX(b, in_h, in_w, in_d)":"getX(b, in_d, in_h, in_w)"}};function $7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{blockSize:s,dataFormat:a}=o;y.assert(s>1,()=>`blockSize should be > 1 for depthToSpace, but was: ${s}`);let i=n.shape[0],l=a==="NHWC"?n.shape[1]:n.shape[2],u=a==="NHWC"?n.shape[2]:n.shape[3],c=a==="NHWC"?n.shape[3]:n.shape[1],p=l*s,m=u*s,f=c/(s*s),d=a==="NHWC"?[i,p,m,f]:[i,f,p,m],h=new cC(d,s,a);return t.runWebGLProgram(h,[n],n.dtype)}var UF={kernelName:oi,backendName:"webgl",kernelFunc:$7};var uh=class{constructor(e,t=!1,o=null,n=!1,s=!1){this.variableNames=["x","W"],this.outputShape=e.outShape;let a=e.inHeight,i=e.inWidth,l=e.padInfo.top,u=e.padInfo.left,c=e.strideHeight,p=e.strideWidth,m=e.dilationHeight,f=e.dilationWidth,d=e.filterHeight,h=e.filterWidth,g=e.outChannels/e.inChannels,x="",b="";o&&(n?x=`float activation(float a) {
          float b = getPreluActivationWeightsAtOutCoords();
          ${o}
        }`:s?x=`float activation(float a) {
          float b = getLeakyreluAlphaAtOutCoords();
          ${o}
        }`:x=`
          float activation(float x) {
            ${o}
          }
        `,b="result = activation(result);");let _=t?"result += getBiasAtOutCoords();":"";t&&this.variableNames.push("bias"),n&&this.variableNames.push("preluActivationWeights"),s&&this.variableNames.push("leakyreluAlpha"),this.userCode=`
      ${x}

      const ivec2 strides = ivec2(${c}, ${p});
      const ivec2 pads = ivec2(${l}, ${u});

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords.x;
        ivec2 xRCCorner = coords.yz * strides - pads;
        int d2 = coords.w;
        int d1 = d2 / ${g};
        int q = d2 - d1 * ${g};

        int xRCorner = xRCCorner.x;
        int xCCorner = xRCCorner.y;

        // Convolve x(?, ?, d1) with w(:, :, d1, q) to get y(yR, yC, d2).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;
        // TO DO(dsmilkov): Flatten the two for loops and vec4 the operations.
        for (int wR = 0; wR < ${d}; wR++) {
          int xR = xRCorner + wR * ${m};

          if (xR < 0 || xR >= ${a}) {
            continue;
          }

          for (int wC = 0; wC < ${h}; wC++) {
            int xC = xCCorner + wC * ${f};

            if (xC < 0 || xC >= ${i}) {
              continue;
            }

            float xVal = getX(batch, xR, xC, d1);
            float wVal = getW(wR, wC, d1, q);
            dotProd += xVal * wVal;
          }
        }

        float result = dotProd;
        ${_}
        ${b}
        setOutput(result);
      }
    `}};var ch=class{constructor(e,t=!1,o=null,n=!1,s=!1){this.variableNames=["x","W"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=e.outShape;let a=e.inHeight,i=e.inWidth,l=e.padInfo.top,u=e.padInfo.left,c=e.strideHeight,p=e.strideWidth,m=e.dilationHeight,f=e.dilationWidth,d=e.filterHeight,h=e.filterWidth,g=h,x="int xR; int xC; int xCOffset;";for(let v=0;v<d;v++)for(let $=0;$<h;$++)x+=`
          vec4 xTexelR${v}C${$*2} = vec4(0.);
          vec4 wR${v}C${$} = vec4(0.);
          vec4 xR${v}C${$} = vec4(0.);`;for(let v=0;v<d;v++)for(let $=0;$<g;$++){let A=$*2;if(x+=`
          xR = xRCorner + ${v*m};
          xC = xCCorner + ${A*f};
        `,p===1){if(A<h&&(u%2==1?x+=`
                xCOffset = xC + 1;
                if(xR >= 0 && xR < ${a} && xCOffset >= 0 && xCOffset < ${i}) {
                  xTexelR${v}C${A} = getX(batch, xR, xCOffset, d1);

                  // Need to manually clear unused channels in case
                  // we're reading from recycled texture.
                  if(xCOffset + 1 >= ${i}) {
                    xTexelR${v}C${A}.zw = vec2(0.);
                  }
                } else {
                  xTexelR${v}C${A} = vec4(0.);
                }

                xCOffset = xC + 1 - 2;
                if(xR >= 0 && xR < ${a} && xCOffset >= 0 && xCOffset < ${i}) {
                  vec4 previous = getX(batch, xR, xCOffset, d1);

                  // Need to manually clear unused channels in case
                  // we're reading from recycled texture.
                  if(xCOffset + 1 >= ${i}) {
                    previous.zw = vec2(0.);
                  }

                  xR${v}C${A} = vec4(previous.zw, xTexelR${v}C${A}.xy);
                } else {
                  xR${v}C${A} = vec4(0, 0, xTexelR${v}C${A}.xy);
                }
              `:x+=`
                if(xR >= 0 && xR < ${a} && xC >= 0 && xC < ${i}) {
                  xTexelR${v}C${A} = getX(batch, xR, xC, d1);
                } else {
                  xTexelR${v}C${A} = vec4(0.);
                }

                xR${v}C${A} = xTexelR${v}C${A};
              `,A+1<h)){let R=u%2==0?y.nearestLargerEven(f):f;f%2==0&&u%2==1||f%2!=0&&u%2!=1?(x+=`
                  xCOffset = xC + ${u%2} + ${R};

                  if(xR >= 0 && xR < ${a} &&
                    xCOffset >= 0 && xCOffset < ${i}) {
                    xTexelR${v}C${A+2} = getX(batch, xR, xCOffset, d1);
                  }
                `,f>1&&(x+=`
                    xCOffset -= 2;
                    if(xR >= 0 && xR < ${a} &&
                      xCOffset >= 0 && xCOffset < ${i}) {
                      xTexelR${v}C${A} = getX(batch, xR, xCOffset, d1);
                    } else {
                      xTexelR${v}C${A} = vec4(0.);
                    }
                  `),x+=`
                  xR${v}C${A+1} = vec4(
                    xTexelR${v}C${A}.zw, xTexelR${v}C${A+2}.xy);
                `):x+=`
                  xCOffset = xC + ${R};

                  if(xR >= 0 && xR < ${a} &&
                    xCOffset >= 0 && xCOffset < ${i}) {
                    xTexelR${v}C${A+2} = getX(batch, xR, xCOffset, d1);
                  }

                  xR${v}C${A+1} = xTexelR${v}C${A+2};
                `}}else A<h&&(x+=`
              if(xR >= 0 && xR < ${a}) {
            `,u%2==1?(x+=`
                xCOffset = xC + 1 - ${p};
                if(xCOffset >= 0 && xCOffset < ${i}) {
                  xTexelR${v}C${A} = getX(batch, xR, xCOffset, d1);
                } else {
                  xTexelR${v}C${A} = vec4(0.);
                }

                if(xC + 1 >= 0 && xC + 1 < ${i}) {
                  xTexelR${v}C${A+2} = getX(batch, xR, xC + 1, d1);
                } else {
                  xTexelR${v}C${A+2} = vec4(0.);
                }

                xR${v}C${A} = vec4(
                  xTexelR${v}C${A}.zw, xTexelR${v}C${A+2}.zw);
              `,A+1<h&&(x+=`
                  vec4 final = vec4(0.);
                  xCOffset = xC + 1 + ${p};
                  if(xCOffset >= 0 && xCOffset < ${i}) {
                    final = getX(batch, xR, xCOffset, d1);
                  }
                  xR${v}C${A+1} = vec4(xTexelR${v}C${A+2}.xy, final.xy);
                `)):(x+=`
                if(xC >= 0 && xC < ${i}) {
                  xTexelR${v}C${A} = getX(batch, xR, xC, d1);
                } else {
                  xTexelR${v}C${A} = vec4(0.);
                }

                xCOffset = xC + ${p};
                if(xCOffset >= 0 && xCOffset < ${i}) {
                  xTexelR${v}C${A+2} = getX(batch, xR, xCOffset, d1);
                } else {
                  xTexelR${v}C${A+2} = vec4(0.);
                }

                xR${v}C${A} = vec4(
                  xTexelR${v}C${A}.xy, xTexelR${v}C${A+2}.xy);
              `,A+1<h&&(x+=`
                  xR${v}C${A+1} = vec4(
                    xTexelR${v}C${A}.zw, xTexelR${v}C${A+2}.zw);
                `)),x+="}");A<h&&(x+=`
            vec4 wTexelR${v}C${A} = getW(${v}, ${A}, d1, q);
            wR${v}C${A} = vec4(wTexelR${v}C${A}.xz, wTexelR${v}C${A}.xz);
          `,A+1<h&&(x+=`
              vec4 wTexelR${v}C${A+1} = getW(${v}, ${A+1}, d1, q);
              wR${v}C${A+1} =
                vec4(wTexelR${v}C${A+1}.xz, wTexelR${v}C${A+1}.xz);`))}for(let v=0;v<d;v++)for(let $=0;$<h;$++)x+=`dotProd += xR${v}C${$} * wR${v}C${$};`;let b="",_="";o&&(n?b=`vec4 activation(vec4 a) {
          vec4 b = getPreluActivationWeightsAtOutCoords();
          ${o}
        }`:s?b=`vec4 activation(vec4 a) {
          vec4 b = getLeakyreluAlphaAtOutCoords();
          ${o}
        }`:b=`vec4 activation(vec4 x) {
          ${o}
        }`,_="result = activation(result);");let w=t?"result += getBiasAtOutCoords();":"";t&&this.variableNames.push("bias"),n&&this.variableNames.push("preluActivationWeights"),s&&this.variableNames.push("leakyreluAlpha"),this.userCode=`
      ${b}

      const ivec2 strides = ivec2(${c}, ${p});
      const ivec2 pads = ivec2(${l}, ${u});

      void main() {

        ivec4 coords = getOutputCoords();
        int batch = coords.x;
        ivec2 xRCCorner = coords.yz * strides - pads;
        int d2 = coords.w;
        int d1 = d2;
        int q = 0;
        int xRCorner = xRCCorner.x;
        int xCCorner = xRCCorner.y;

        vec4 dotProd = vec4(0.);

        ${x}

        vec4 result = dotProd;
        ${w}
        ${_}
        setOutput(result);
      }
    `}};function R7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s}=e,{strides:a,pad:i,dilations:l,dimRoundingMode:u}=o,c=l;c==null&&(c=[1,1]),y.assert(N.eitherStridesOrDilationsAreOne(a,c),()=>`Error in depthwiseConv2d: Either strides or dilations must be 1. Got strides ${a} and dilations '${c}'`);let p=N.computeConv2DInfo(n.shape,s.shape,a,c,i,u,!0),m;return G().getBool("WEBGL_PACK_DEPTHWISECONV")&&p.strideWidth<=2&&p.outChannels/p.inChannels==1?m=new ch(p):m=new uh(p),t.runWebGLProgram(m,[n,s],"float32")}var jF={kernelName:Jo,backendName:"webgl",kernelFunc:R7};var pC=class{constructor(e){this.variableNames=["x","dy"],this.outputShape=e.filterShape;let t=e.strideHeight,o=e.strideWidth,n=e.padInfo.top,s=e.padInfo.left,a=e.outChannels/e.inChannels;this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int wR = coords.x;
        int wC = coords.y;
        int d1 = coords.z;
        int dm = coords.w;
        int d2 = d1 * ${a} + dm;

        float dotProd = 0.0;

        // TO DO: Vec4 over the batch size
        for (int b = 0; b < ${e.batchSize}; b++) {
          for (int yR = 0; yR < ${e.outHeight}; yR++) {
            int xR = wR + yR * ${t} - ${n};

            if (xR < 0 || xR >= ${e.inHeight}) {
              continue;
            }

            for (int yC = 0; yC < ${e.outWidth}; yC++) {
              int xC = wC + yC * ${o} - ${s};

              if (xC < 0 || xC >= ${e.inWidth}) {
                continue;
              }

              float dyValue = getDy(b, yR, yC, d2);
              float xValue = getX(b, xR, xC, d1);
              dotProd += (xValue * dyValue);
            }
          }
        }
        setOutput(dotProd);
      }
    `}},mC=class{constructor(e){this.variableNames=["dy","W"],this.outputShape=e.inShape;let t=e.filterHeight,o=e.filterWidth,n=e.strideHeight,s=e.strideWidth,a=t-1-e.padInfo.top,i=o-1-e.padInfo.left,l=e.outChannels/e.inChannels;this.userCode=`
      const ivec2 pads = ivec2(${a}, ${i});

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords[0];
        int d1 = coords[3];
        ivec2 dyCorner = coords.yz - pads;
        int dyRCorner = dyCorner.x;
        int dyCCorner = dyCorner.y;

        float dotProd = 0.0;

        for (int wR = 0; wR < ${t}; wR++) {
          float dyR = float(dyRCorner + wR) / ${n}.0;

          if (dyR < 0.0 || dyR >= ${e.outHeight}.0 || fract(dyR) > 0.0) {
            continue;
          }
          int idyR = int(dyR);

          int wRPerm = ${t} - 1 - wR;

          for (int wC = 0; wC < ${o}; wC++) {
            float dyC = float(dyCCorner + wC) / ${s}.0;

            if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                fract(dyC) > 0.0) {
              continue;
            }
            int idyC = int(dyC);

            int wCPerm = ${o} - 1 - wC;

            // TO DO: Vec4 over the channelMul
            for (int dm = 0; dm < ${l}; dm++) {
              int d2 = d1 * ${l} + dm;
              float xValue = getDy(batch, idyR, idyC, d2);
              float wValue = getW(wRPerm, wCPerm, d1, dm);
              dotProd += xValue * wValue;
            }
          }
        }
        setOutput(dotProd);
      }
    `}};function F7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,dy:s}=e,{strides:a,dilations:i,pad:l,dimRoundingMode:u,filterShape:c}=o,p=N.computeConv2DInfo(n.shape,c,a,i,l,u,!0),m=new pC(p);return t.runWebGLProgram(m,[n,s],"float32")}var HF={kernelName:Zl,backendName:"webgl",kernelFunc:F7};function O7(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,filter:s}=e,{strides:a,dilations:i,pad:l,dimRoundingMode:u,inputShape:c}=o,p=N.computeConv2DInfo(c,s.shape,a,i,l,u,!0),m=new mC(p);return t.runWebGLProgram(m,[n,s],"float32")}var qF={kernelName:Jl,backendName:"webgl",kernelFunc:O7};var fC=class{constructor(e){this.variableNames=["X"],this.outputShape=[e,e],this.userCode=`
      void main() {
          ivec2 coords = getOutputCoords();
          float val = coords[0] == coords[1] ? getX(coords[0]) : 0.0;
          setOutput(val);
      }
    `}};function P7(r){let{inputs:e,backend:t}=r,{x:o}=e,n=[...o.shape,...o.shape],s=y.sizeFromShape(o.shape),a=ce({inputs:{x:o},backend:t,attrs:{shape:[s]}}),i=new fC(s),l=t.runWebGLProgram(i,[a],a.dtype),u=ce({inputs:{x:l},backend:t,attrs:{shape:n}});return t.disposeIntermediateTensorInfo(a),t.disposeIntermediateTensorInfo(l),u}var KF={kernelName:Ql,backendName:"webgl",kernelFunc:P7};var dC=class{constructor(e){this.variableNames=["x","W"],this.outputShape=e.outShape;let{inHeight:t,inWidth:o,padInfo:n,strideHeight:s,strideWidth:a,filterHeight:i,filterWidth:l,dilationHeight:u,dilationWidth:c}=e,{top:p,left:m}=n;this.userCode=`
      const ivec2 strides = ivec2(${s}, ${a});
      const ivec2 pads = ivec2(${p}, ${m});
      const float neg_infinity = -3.4e38;

      void main() {
        ivec4 coords = getOutputCoords();
        int batch = coords.x;
        int d1 = coords.w;
        ivec2 outTopLeftCorner =
            coords.yz * strides - pads;
        int hBeg = outTopLeftCorner.x;
        int wBeg = outTopLeftCorner.y;

        float curVal = neg_infinity;
        for (int h = 0; h < ${i}; h++) {
          int hIn = hBeg + h * ${u};

          if (hIn >= 0 && hIn < ${t}) {
            for (int w = 0; w < ${l}; w++) {
              int wIn = wBeg + w * ${c};

              if (wIn >= 0 && wIn < ${o}) {
                float xVal = getX(batch, hIn, wIn, d1);
                float wVal = getW(h, w, d1);

                float val = xVal + wVal;
                if (val > curVal) {
                  curVal = val;
                }
              }
            }
          }
        }

        float result = curVal;
        setOutput(result);
      }
    `}};function M7(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s}=e,{strides:a,pad:i,dilations:l}=o,u=N.computeDilation2DInfo(n.shape,s.shape,a,i,"NHWC",l),c,p=new dC(u);c=t.runWebGLProgram(p,[n,s],"float32");let m=ce({inputs:{x:c},backend:t,attrs:{shape:u.outShape}});return t.disposeIntermediateTensorInfo(c),m}var XF={kernelName:la,backendName:"webgl",kernelFunc:M7};var L7="return (x >= 0.0) ? x : (exp(x) - 1.0);",z7=`
  vec4 result;

  result.r = (x.r >= 0.0) ? x.r : (exp(x.r) - 1.0);
  result.g = (x.g >= 0.0) ? x.g : (exp(x.g) - 1.0);
  result.b = (x.b >= 0.0) ? x.b : (exp(x.b) - 1.0);
  result.a = (x.a >= 0.0) ? x.a : (exp(x.a) - 1.0);

  return result;
`,B7=ve({opSnippet:L7,packedOpSnippet:z7}),YF={kernelName:ni,backendName:"webgl",kernelFunc:B7};var V7="return (b >= 1.0) ? a : a * (b + 1.0);",G7=`
  vec4 bGTEZero = vec4(greaterThanEqual(b, vec4(0.)));
  return (bGTEZero * a) + ((vec4(1.0) - bGTEZero) * (a * (b + vec4(1.0))));
`,W7=r=>{let{inputs:e,backend:t}=r,{dy:o,y:n}=e,s=G().getBool("WEBGL_PACK_BINARY_OPERATIONS")?new Vs(G7,o.shape,n.shape):new Qn(V7,o.shape,n.shape);return t.runWebGLProgram(s,[o,n],o.dtype)},ZF={kernelName:eu,backendName:"webgl",kernelFunc:W7};var U7=`
  return vec4(equal(a, b));
`,j7="return float(a == b);",H7=it({opSnippet:j7,packedOpSnippet:U7,dtype:"bool"}),JF={kernelName:ii,backendName:"webgl",kernelFunc:H7};var q7=`
  // Error function is calculated approximately with elementary function.
  // See "Handbook of Mathematical Functions with Formulas,
  // Graphs, and Mathematical Tables", Abramowitz and Stegun.
  float p = ${N.ERF_P};
  float a1 = ${N.ERF_A1};
  float a2 = ${N.ERF_A2};
  float a3 = ${N.ERF_A3};
  float a4 = ${N.ERF_A4};
  float a5 = ${N.ERF_A5};

  float sign = sign(x);
  x = abs(x);
  float t = 1.0 / (1.0 + p * x);
  return sign * (1.0 - (((((a5*t + a4)*t) + a3)*t + a2)*t + a1)*t*exp(-x*x));
`,K7=ve({opSnippet:q7}),QF={kernelName:si,backendName:"webgl",kernelFunc:K7};var eO="return exp(x);",hC=ve({opSnippet:eO,packedOpSnippet:eO,cpuKernelImpl:Z$}),tO={kernelName:en,backendName:"webgl",kernelFunc:hC};function Hx(r){let{inputs:e,attrs:t,backend:o}=r,{dim:n}=t,{input:s}=e,a=s.shape.length,i=s.shape.slice(),l=n;return n<0&&(y.assert(-(a+1)<=n,()=>`Axis must be in the interval [${-(a+1)}, ${a}]`),l=a+n+1),i.splice(l,0,1),ce({inputs:{x:s},backend:o,attrs:{shape:i}})}var rO={kernelName:as,backendName:"webgl",kernelFunc:Hx};var oO="return exp(x) - 1.0;",X7=ve({opSnippet:oO,packedOpSnippet:oO,cpuKernelImpl:J$}),nO={kernelName:ai,backendName:"webgl",kernelFunc:X7};var qx=class{constructor(e,t,o){this.variableNames=["real","imag"];let n=t[1];this.outputShape=t;let s=o?`2.0 * ${Math.PI}`:`-2.0 * ${Math.PI}`,a=o?`${n}.0`:"1.0",i;if(e==="real")i="return real * expR - imag * expI;";else if(e==="imag")i="return real * expI + imag * expR;";else throw new Error(`FFT component must be either "real" or "imag", got ${e}.`);this.userCode=`
      const float exponentMultiplier = ${s};

      float unaryOpComplex(float real, float expR, float imag, float expI) {
        ${i}
      }

      float mulMatDFT(int batch, int index) {
        float indexRatio = float(index) / float(${n});
        float exponentMultiplierTimesIndexRatio =
            exponentMultiplier * indexRatio;

        float result = 0.0;

        for (int i = 0; i < ${n}; i++) {
          // x = (-2|2 * PI / N) * index * i;
          float x = exponentMultiplierTimesIndexRatio * float(i);
          float expR = cos(x);
          float expI = sin(x);
          float real = getReal(batch, i);
          float imag = getImag(batch, i);

          result +=
              unaryOpComplex(real, expR, imag, expI) / ${a};
        }

        return result;
      }

      void main() {
        ivec2 coords = getOutputCoords();
        setOutput(mulMatDFT(coords[0], coords[1]));
      }
    `}};function Kx(r,e,t){let o=t.texData.get(r.dataId),n=y.sizeFromShape(r.shape),s=r.shape[r.shape.length-1],a=n/s,i=ce({inputs:{x:r},backend:t,attrs:{shape:[a,s]}}),l=i.shape,u=new qx("real",l,e),c=new qx("imag",l,e),p=[{dataId:o.complexTensorInfos.real.dataId,dtype:o.complexTensorInfos.real.dtype,shape:l},{dataId:o.complexTensorInfos.imag.dataId,dtype:o.complexTensorInfos.imag.dtype,shape:l}],m=t.runWebGLProgram(u,p,"float32"),f=t.runWebGLProgram(c,p,"float32"),d=co({inputs:{real:m,imag:f},backend:t});t.disposeIntermediateTensorInfo(m),t.disposeIntermediateTensorInfo(f);let h=ce({inputs:{x:d},backend:t,attrs:{shape:r.shape}});return t.disposeIntermediateTensorInfo(i),t.disposeIntermediateTensorInfo(d),h}function Y7(r){let{inputs:e,backend:t}=r,{input:o}=e;return Kx(o,!1,t)}var sO={kernelName:tu,backendName:"webgl",kernelFunc:Y7};var gC=class{constructor(e,t){this.outputShape=[],this.variableNames=["x"],this.outputShape=e,this.userCode=`
      uniform float value;
      void main() {
        // Input can be obtained from uniform value.
        setOutput(value);
      }
    `}getCustomSetupFunc(e){return(t,o)=>{this.valueLoc==null&&(this.valueLoc=t.getUniformLocationNoThrow(o,"value")),t.gl.uniform1f(this.valueLoc,e)}}};function ph(r){let{backend:e,attrs:t}=r,{shape:o,value:n}=t,{dtype:s}=t;if(s=s||y.inferDtype(n),s==="string"){let a=y.getArrayFromDType(s,y.sizeFromShape(o));return a.fill(n),e.makeTensorInfo(o,s,a)}else{let a=new gC(o,n),i=a.getCustomSetupFunc(n);return e.runWebGLProgram(a,[],s,i)}}var iO={kernelName:ua,backendName:"webgl",kernelFunc:ph};var xC=class{constructor(e){this.variableNames=["Image"],this.outputShape=[];let t=e[2];this.outputShape=e,this.userCode=`
        void main() {
          ivec4 coords = getOutputCoords();
          int x = coords[2];

          int coordX = ${t} - x;
          float outputValue;
          if(coordX >= 0 && coordX < ${t}) {
            outputValue = getImage(coords[0], coords[1], coordX, coords[3]);
          } else {
            outputValue = getImage(coords[0], coords[1], coords[2], coords[3]);
          }
          setOutput(outputValue);
        }
    `}};var aO={kernelName:li,backendName:"webgl",kernelFunc:({inputs:r,backend:e})=>{let{image:t}=r,o=e,n=new xC(t.shape);return o.runWebGLProgram(n,[t],t.dtype)}};var lO="return floor(x);",Z7=ve({opSnippet:lO,packedOpSnippet:lO,cpuKernelImpl:Q$}),uO={kernelName:tn,backendName:"webgl",kernelFunc:Z7};var J7=`
  float s = sign(a) * sign(b);
  int ia = round(a);
  int ib = round(b);
  if (ib != 0) {
    // Windows (D3D) wants guaranteed non-zero int division at compile-time.
    return float(idiv(ia, ib, s));
  } else {
    return NAN;
  }
`,Q7=`
  ivec4 ia = round(a);
  ivec4 ib = round(b);
  bvec4 cond = notEqual(ib, ivec4(0));
  ivec4 result = ivec4(0);
  vec4 s = sign(a) * sign(b);

  // Windows (D3D) wants guaranteed non-zero int division at compile-time.
  if (cond[0]) {
    result[0] = idiv(ia[0], ib[0], s[0]);
  }
  if (cond[1]) {
    result[1] = idiv(ia[1], ib[1], s[1]);
  }
  if (cond[2]) {
    result[2] = idiv(ia[2], ib[2], s[2]);
  }
  if (cond[3]) {
    result[3] = idiv(ia[3], ib[3], s[3]);
  }
  return vec4(result);
`,eZ=it({opSnippet:J7,packedOpSnippet:Q7,dtype:"int32"}),cO={kernelName:rn,backendName:"webgl",kernelFunc:eZ};var yC=class{constructor(e){this.variableNames=["A"];let t=Mt(),[o,n]=e;this.outputShape=e,this.userCode=`
      void main() {
        ivec3 coords = getOutputCoords();
        int texR = coords[0];
        int texC = coords[1];
        int depth = coords[2];
        vec2 uv = (vec2(texC, texR) + halfCR) / vec2(${n}.0, ${o}.0);

        vec4 values = ${t.texture2D}(A, uv);
        float value;
        if (depth == 0) {
          value = values.r;
        } else if (depth == 1) {
          value = values.g;
        } else if (depth == 2) {
          value = values.b;
        } else if (depth == 3) {
          value = values.a;
        }

        setOutput(floor(value * 255.0 + 0.5));
      }
    `}};var bC=class{constructor(e){this.variableNames=["A"],this.packedInputs=!1,this.packedOutput=!0;let t=Mt(),[o,n]=e;this.outputShape=e,this.userCode=`
      void main() {
        ivec3 coords = getOutputCoords();
        int texR = coords[0];
        int texC = coords[1];
        int depth = coords[2];

        vec4 result = vec4(0.);

        for(int row=0; row<=1; row++) {
          for(int col=0; col<=1; col++) {
            texC = coords[1] + row;
            depth = coords[2] + col;

            vec2 uv = (vec2(texC, texR) + halfCR) /
                       vec2(${n}.0, ${o}.0);
            vec4 values = ${t.texture2D}(A, uv);
            float value;
            if (depth == 0) {
              value = values.r;
            } else if (depth == 1) {
              value = values.g;
            } else if (depth == 2) {
              value = values.b;
            } else if (depth == 3) {
              value = values.a;
            }

            result[row * 2 + col] = floor(value * 255.0 + 0.5);
          }
        }

        ${t.output} = result;
      }
    `}};var pO={kernelName:Fc,backendName:"webgl",kernelFunc:tZ},jp;function tZ(r){let{inputs:e,backend:t,attrs:o}=r,{pixels:n}=e,{numChannels:s}=o,a=typeof HTMLVideoElement!="undefined"&&n instanceof HTMLVideoElement,i=typeof HTMLImageElement!="undefined"&&n instanceof HTMLImageElement,l=typeof ImageBitmap!="undefined"&&n instanceof ImageBitmap,[u,c]=a?[n.videoWidth,n.videoHeight]:[n.width,n.height],p=[c,u],m=[c,u,s];(i||a||l)&&(jp==null&&(jp=document.createElement("canvas").getContext("2d")),jp.canvas.width=u,jp.canvas.height=c,jp.drawImage(n,0,0,u,c),n=jp.canvas);let f=t.makeTensorInfo(p,"int32");t.texData.get(f.dataId).usage=Er.PIXELS,t.gpgpu.uploadPixelDataToTexture(t.getTexture(f.dataId),n);let d=G().getBool("WEBGL_PACK")?new bC(m):new yC(m),h=t.runWebGLProgram(d,[f],"int32");return t.disposeData(f.dataId),h}function rZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s,bias:a,preluActivationWeights:i}=e,{strides:l,pad:u,dataFormat:c,dilations:p,dimRoundingMode:m,activation:f,leakyreluAlpha:d}=o,h=N.convertConv2DDataFormat(c),g=N.computeConv2DInfo(n.shape,s.shape,l,p,u,m,!1,h),x,b=[];if(g.filterHeight===1&&g.filterWidth===1&&g.dilationHeight===1&&g.dilationWidth===1&&g.strideHeight===1&&g.strideWidth===1&&(g.padInfo.type==="SAME"||g.padInfo.type==="VALID"))x=Wx({x:n,filter:s,convInfo:g,backend:t,bias:a,activation:f,preluActivationWeights:i,leakyreluAlpha:d});else if(G().getBool("WEBGL_CONV_IM2COL")&&n.shape[0]===1)x=Ux({x:n,filter:s,convInfo:g,backend:t,bias:a,activation:f,preluActivationWeights:i,leakyreluAlpha:d});else{let w=a!=null,v=i!=null,$=f==="leakyrelu",A=f?El(f,!1):null,R=new lh(g,w,A,v,$),M=[n,s];if(a&&M.push(a),i&&M.push(i),$){let z=t.makeTensorInfo([],"float32",y.createScalarValue(d,"float32"));M.push(z),b.push(z)}x=t.runWebGLProgram(R,M,"float32")}let _=ce({inputs:{x},backend:t,attrs:{shape:g.outShape}});return b.push(x),b.forEach(w=>t.disposeIntermediateTensorInfo(w)),_}var mO={kernelName:_s,backendName:"webgl",kernelFunc:rZ};function oZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,filter:s,bias:a,preluActivationWeights:i}=e,{strides:l,pad:u,dilations:c,dimRoundingMode:p,activation:m,leakyreluAlpha:f}=o,d=[],h=c;h==null&&(h=[1,1]),y.assert(N.eitherStridesOrDilationsAreOne(l,h),()=>`Error in depthwiseConv2d: Either strides or dilations must be 1. Got strides ${l} and dilations '${h}'`);let g=N.computeConv2DInfo(n.shape,s.shape,l,h,u,p,!0),x=G().getBool("WEBGL_PACK_DEPTHWISECONV")&&g.strideWidth<=2&&g.outChannels/g.inChannels==1,b=m?El(m,x):null,_=[n,s],w=a!=null,v=i!=null,$=m==="leakyrelu";if(w&&_.push(a),v&&_.push(i),$){let M=t.makeTensorInfo([],"float32",y.createScalarValue(f,"float32"));_.push(M),d.push(M)}let A;x?A=new ch(g,w,b,v,$):A=new uh(g,w,b,v,$);let R=t.runWebGLProgram(A,_,"float32");return d.forEach(M=>t.disposeIntermediateTensorInfo(M)),R}var fO={kernelName:ws,backendName:"webgl",kernelFunc:oZ};var _C=class{constructor(e,t,o){this.sliceDim=e,this.strides=t,this.variableNames=["x","indices"],this.outputShape=o;let n=Le(t.length),s=Le(o.length),a=this.sliceDim>1?"strides[j]":"strides";this.userCode=`
        ${n} strides = ${n}(${this.strides});
         void main() {
          ${s} coords = getOutputCoords();
          int flattenIndex = 0;
          for (int j = 0; j < ${this.sliceDim}; j++) {
            int index = round(getIndices(coords[0], j));
            flattenIndex += index * ${a};
          }
          setOutput(getX(flattenIndex, coords[1]));
        }
      `}};function nZ(r){let{inputs:e,backend:t}=r,{params:o,indices:n}=e,s=n.shape,a=s[s.length-1],[i,l,u,c]=N.prepareAndValidate(o,n),p=ce({inputs:{x:n},backend:t,attrs:{shape:[l,a]}}),m=ce({inputs:{x:o},backend:t,attrs:{shape:[y.sizeFromShape(o.shape)/u,u]}}),f=new _C(a,c,[l,u]),d=t.runWebGLProgram(f,[m,p],m.dtype),h=ce({inputs:{x:d},backend:t,attrs:{shape:i}});return t.disposeIntermediateTensorInfo(p),t.disposeIntermediateTensorInfo(m),t.disposeIntermediateTensorInfo(d),h}var dO={kernelName:ui,backendName:"webgl",kernelFunc:nZ};var wC=class{constructor(e,t){this.variableNames=["A","indices"],this.outputShape=t,this.rank=t.length;let o=Le(this.rank),n=sZ(e,2);this.userCode=`
      void main() {
        ${o} resRC = getOutputCoords();
        setOutput(getA(${n}));
      }
    `}};function sZ(r,e){let t=["resRC.x","resRC.y","resRC.z","resRC.w"],o=[];for(let n=0;n<r.length;n++)n===2?o.push("int(getIndices(resRC.x, resRC.z))"):o.push(`${t[n]}`);return o.join()}function iZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,indices:s}=e,{axis:a,batchDims:i}=o,l=y.parseAxisParam(a,n.shape)[0],u=N.segment_util.collectGatherOpShapeInfo(n,s,l,i),c=y.sizeFromShape(s.shape),p=[],m=ce({inputs:{x:n},backend:t,attrs:{shape:[u.batchSize,u.outerSize,u.dimSize,u.sliceSize]}}),f=ce({inputs:{x:s},backend:t,attrs:{shape:[u.batchSize,c/u.batchSize]}});p.push(m),p.push(f);let d=[u.batchSize,u.outerSize,c/u.batchSize,u.sliceSize];if(t.shouldExecuteOnCPU([n,s])||n.dtype==="string"){let b=t.bufferSync(f),_=t.bufferSync(m),w=eR(_,b,d);return p.forEach(v=>t.disposeIntermediateTensorInfo(v)),t.makeTensorInfo(u.outputShape,w.dtype,w.values)}let h=new wC(m.shape,d),g=t.runWebGLProgram(h,[m,f],m.dtype);p.push(g);let x=ce({inputs:{x:g},backend:t,attrs:{shape:u.outputShape}});return p.forEach(b=>t.disposeIntermediateTensorInfo(b)),x}var hO={kernelName:ls,backendName:"webgl",kernelFunc:iZ};var aZ="return float(a > b);",lZ=`
  return vec4(greaterThan(a, b));
`,uZ=it({opSnippet:aZ,packedOpSnippet:lZ,cpuKernelImpl:tR,dtype:"bool"}),gO={kernelName:ci,backendName:"webgl",kernelFunc:uZ};var cZ="return float(a >= b);",pZ=`
  return vec4(greaterThanEqual(a, b));
`,mZ=it({opSnippet:cZ,packedOpSnippet:pZ,dtype:"bool"}),xO={kernelName:nn,backendName:"webgl",kernelFunc:mZ};function fZ(r){let{inputs:e,backend:t}=r,{input:o}=e;return Kx(o,!0,t)}var yO={kernelName:ru,backendName:"webgl",kernelFunc:fZ};var dZ="return float(!isnan(x) && !isinf(x));",hZ=ve({opSnippet:dZ,dtype:"bool"}),bO={kernelName:pi,backendName:"webgl",kernelFunc:hZ};var gZ="return float(isinf(x));",xZ=ve({opSnippet:gZ,dtype:"bool"}),_O={kernelName:mi,backendName:"webgl",kernelFunc:xZ};var yZ="return float(isnan(x));",bZ=ve({opSnippet:yZ,dtype:"bool"}),wO={kernelName:fi,backendName:"webgl",kernelFunc:bZ};var _Z="return float(a < b);",wZ=`
  return vec4(lessThan(a, b));
`,kZ=it({opSnippet:_Z,packedOpSnippet:wZ,cpuKernelImpl:rR,dtype:"bool"}),kO={kernelName:di,backendName:"webgl",kernelFunc:kZ};var vZ="return float(a <= b);",CZ=`
  return vec4(lessThanEqual(a, b));
`,IZ=it({opSnippet:vZ,packedOpSnippet:CZ,dtype:"bool"}),vO={kernelName:hi,backendName:"webgl",kernelFunc:IZ};function NZ(r){let{backend:e,attrs:t}=r,{start:o,stop:n,num:s}=t,a=oR(o,n,s);return e.makeTensorInfo([a.length],"float32",a)}var CO={kernelName:nu,backendName:"webgl",kernelFunc:NZ};var SZ=`if (x < 0.0) return NAN;
  return log(x);`,TZ=`
  vec4 result = log(x);
  vec4 isNaN = vec4(lessThan(x, vec4(0.0)));
  result.r = isNaN.r == 1.0 ? NAN : result.r;
  result.g = isNaN.g == 1.0 ? NAN : result.g;
  result.b = isNaN.b == 1.0 ? NAN : result.b;
  result.a = isNaN.a == 1.0 ? NAN : result.a;

  return result;
`,EZ=ve({opSnippet:SZ,packedOpSnippet:TZ,cpuKernelImpl:nR}),IO={kernelName:an,backendName:"webgl",kernelFunc:EZ};var AZ="return log(1.0 + x);",DZ=ve({opSnippet:AZ}),NO={kernelName:gi,backendName:"webgl",kernelFunc:DZ};var $Z="return float(a >= 1.0 && b >= 1.0);",RZ=`
  return vec4(
    vec4(greaterThanEqual(a, vec4(1.0))) *
    vec4(greaterThanEqual(b, vec4(1.0))));
`,FZ=it({opSnippet:$Z,packedOpSnippet:RZ,dtype:"bool"}),SO={kernelName:xi,backendName:"webgl",kernelFunc:FZ};var OZ="return float(!(x >= 1.0));",PZ=ve({opSnippet:OZ}),TO={kernelName:Za,backendName:"webgl",kernelFunc:PZ};var MZ="return float(a >= 1.0 || b >= 1.0);",LZ=`
  return min(
    vec4(greaterThanEqual(a, vec4(1.0))) +
    vec4(greaterThanEqual(b, vec4(1.0))),
    vec4(1.0));
`,zZ=it({opSnippet:MZ,packedOpSnippet:LZ,dtype:"bool"}),EO={kernelName:Ja,backendName:"webgl",kernelFunc:zZ};var kC=class{constructor(e,t,o,n,s){this.variableNames=["x"],this.outputShape=[];let a=t,i=e[3]-1;this.outputShape=e;let l,u=`float(${o}) + float(${n}) * sum`;s===.5?l=`inversesqrt(${u})`:s===1?l=`1.0/(${u})`:l=`exp(log(${u}) * float(-${s}));`,this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int r = coords[1];
        int c = coords[2];
        int d = coords[3];
        float x = getX(b, r, c, d);
        float sum = 0.0;
        for (int j = -${a}; j <= ${a}; j++) {
          int idx = d + j;
          if (idx >= 0 && idx <=  ${i}) {
            float z = getX(b, r, c, idx);
            sum += z * z;
          }
        }
        float val = x * ${l};
        setOutput(val);
      }
    `}};var vC=class{constructor(e,t,o,n,s){this.variableNames=["x"],this.outputShape=[],this.packedInputs=!0,this.packedOutput=!0;let a=t,i=e[3]-1;this.outputShape=e;let l,u=`float(${o}) + float(${n}) * sum`;s===.5?l=`inversesqrt(${u})`:s===1?l=`1.0/(${u})`:l=`exp(log(${u}) * float(-${s}));`,this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords.x;
        int r = coords.y;
        int c = coords.z;
        int d = coords.w;

        bool hasNextCol = d < ${this.outputShape[3]};
        bool hasNextRow = c < ${this.outputShape[2]};

        vec4 sum = vec4(0.);
        vec4 xFragAtOutputCoords = getX(b, r, c, d);

        vec4 xAtOutputCoords = vec4(
          getChannel(xFragAtOutputCoords, vec2(c, d)),
          hasNextCol ?
            getChannel(xFragAtOutputCoords, vec2(c, d + 1)) : 0.0,
          hasNextRow ?
            getChannel(xFragAtOutputCoords , vec2(c + 1, d)) : 0.0,
          (hasNextRow && hasNextCol) ?
            getChannel(xFragAtOutputCoords, vec2(c + 1, d + 1)) : 0.0
        );

        int firstChannel = d - ${a};
        vec2 cache = vec2(0.);
        if(firstChannel >= 0){
          vec4 firstChannelFrag = getX(b, r, c, firstChannel);
          cache.x = getChannel(firstChannelFrag, vec2(c, firstChannel));
            if(hasNextRow){
              cache.y = getChannel(firstChannelFrag, vec2(c + 1, firstChannel));
            }
        }

        ivec2 depth = ivec2(d, d + 1);
        for (int j = - ${a}; j <= ${a}; j++) {
          ivec2 idx = depth + j;
          bvec2 aboveLowerBound = greaterThanEqual(idx, ivec2(0));
          bvec2 belowUpperBound = lessThanEqual(idx, ivec2(${i}));

          bool depthInRange = aboveLowerBound.x && belowUpperBound.x;
          bool depthPlusOneInRange = aboveLowerBound.y && belowUpperBound.y;

          if(depthInRange || depthPlusOneInRange){
            vec4 z = vec4(0.);
            vec4 xFragAtCurrentDepth;
            z.xz = cache.xy;
            if(depthPlusOneInRange && hasNextCol){
              xFragAtCurrentDepth = idx.y != d ?
                getX(b, r, c, idx.y) : xFragAtOutputCoords;
              z.y = getChannel(xFragAtCurrentDepth, vec2(c, idx.y));
              if(hasNextRow){
                z.w = getChannel(xFragAtCurrentDepth, vec2(c + 1, idx.y));
              }
            }
            cache.xy = z.yw;
            sum += z * z;
          }
        }
        vec4 result = xAtOutputCoords * ${l};
        setOutput(result);
      }
    `}};var BZ=r=>{let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{depthRadius:s,bias:a,alpha:i,beta:l}=o,u=G().getBool("WEBGL_PACK_NORMALIZATION")?new vC(n.shape,s,a,i,l):new kC(n.shape,s,a,i,l);return t.runWebGLProgram(u,[n],n.dtype)},AO={kernelName:ca,backendName:"webgl",kernelFunc:BZ};var CC=class{constructor(e,t,o,n,s){this.variableNames=["inputImage","outputImage","dy"],this.outputShape=[],this.outputShape=e,this.depth=e[3],this.depthRadius=t,this.bias=o,this.alpha=n,this.beta=s,this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int r = coords[1];
        int c = coords[2];

        float result = 0.0;
        for (int d = 0; d < ${this.depth}; ++d) {
          int depthBegin = int(max(0.0, float(d - ${t})));
          int depthEnd = int(min(float(${this.depth}),
              float(d + ${t} + 1)));

          const int MIN_DEPTH_BEGIN = 0;
          const int MAX_DEPTH_END = ${this.depth};

          float norm = 0.0;
          for (int k = MIN_DEPTH_BEGIN; k < MAX_DEPTH_END; ++k) {
            if (k < depthBegin){
              continue;
            }
            else if (k >= depthBegin && k < depthEnd) {
              norm += getInputImage(b, r, c, k) * getInputImage(b, r, c, k);
            }
            else {
              break;
            }
          }

          norm = float(${n}) * norm + float(${o});

          for(int k = MIN_DEPTH_BEGIN; k < MAX_DEPTH_END; ++k){
            if (k < depthBegin){
              continue;
            }
            else if (k >= depthBegin && k < depthEnd){
              float dyi = -2.0 * float(${n})
                * float(${s})
                * getInputImage(b ,r ,c, k) * getOutputImage(b, r, c, d)
                / norm;
              if (k == d) {
                dyi += pow(norm, -1.0 * ${s});
              }
              if (k == coords[3]) {
                dyi *= getDy(b, r, c, d);
                result += dyi;
              }
            }
            else {
              break;
            }
          }
      }
      setOutput(result);
      }
    `}};var VZ=r=>{let{inputs:e,backend:t,attrs:o}=r,{x:n,y:s,dy:a}=e,{depthRadius:i,bias:l,alpha:u,beta:c}=o,p=new CC(n.shape,i,l,u,c);return t.runWebGLProgram(p,[n,s,a],n.dtype)},DO={kernelName:su,backendName:"webgl",kernelFunc:VZ};function $O(r,e,t,o){let n=y.sizeFromShape(e),a=y.sizeFromShape(r.shape)/n,i=ce({inputs:{x:r},attrs:{shape:[a,n]},backend:o}),l=Io(i,r.dtype,"max",o),u=ce({inputs:{x:l},attrs:{shape:t},backend:o});return o.disposeIntermediateTensorInfo(i),o.disposeIntermediateTensorInfo(l),u}function IC(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{reductionIndices:s,keepDims:a}=o,i=n.shape.length,l=y.parseAxisParam(s,n.shape),u=l,c=N.getAxesPermutation(u,i),p=c!=null,m=t.shouldExecuteOnCPU([n]),f=n;if(p){if(m){let _=t.texData.get(f.dataId).values,w=new Array(i);for(let A=0;A<w.length;A++)w[A]=n.shape[c[A]];let v=Up(_,n.shape,n.dtype,c,w);f=t.makeTensorInfo(w,n.dtype);let $=t.texData.get(f.dataId);$.values=v}else f=Al(n,c,t);u=N.getInnerMostAxes(u.length,i)}N.assertAxesAreInnerMostDims("max",u,i);let[d,h]=N.computeOutAndReduceShapes(f.shape,u),g=d;a&&(g=N.expandShapeToKeepDim(d,l));let x;if(m){let _=t.texData.get(f.dataId).values,w=sR(_,y.sizeFromShape(h),g,n.dtype);x=t.makeTensorInfo(g,n.dtype);let v=t.texData.get(x.dataId);v.values=w}else x=$O(f,h,g,t);return p&&t.disposeIntermediateTensorInfo(f),x}var RO={kernelName:ln,backendName:"webgl",kernelFunc:IC};var GZ=Px+`
  return max(a, b);
`,WZ=`
  vec4 result = vec4(max(a, b));
  vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
  `+Tl+`
  return result;
`,UZ=it({opSnippet:GZ,packedOpSnippet:WZ,cpuKernelImpl:iR}),FO={kernelName:un,backendName:"webgl",kernelFunc:UZ};function jZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e;Yi(n,"maxPool");let{filterSize:s,strides:a,pad:i,dimRoundingMode:l}=o,u=1;y.assert(N.eitherStridesOrDilationsAreOne(a,u),()=>`Error in maxPool: Either strides or dilations must be 1. Got strides ${a} and dilations '${u}'`);let c=N.computePool2DInfo(n.shape,s,a,u,i,l);if(c.filterWidth===1&&c.filterHeight===1&&y.arraysEqual(c.inShape,c.outShape))return jt({inputs:{x:n},backend:t});let p=new Zi(c,"max",!1);return t.runWebGLProgram(p,[n],n.dtype)}var OO={kernelName:cn,backendName:"webgl",kernelFunc:jZ};function HZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{filterSize:s,strides:a,pad:i,dataFormat:l,dimRoundingMode:u}=o,c=[1,1,1],p=N.computePool3DInfo(n.shape,s,a,c,i,u,l),m=new cc(p,"max",!1);return t.runWebGLProgram(m,[n],n.dtype)}var PO={kernelName:pa,backendName:"webgl",kernelFunc:HZ};var NC=class{constructor(e){this.variableNames=["dy","maxPos"],this.outputShape=e.inShape;let t=e.strideHeight,o=e.strideWidth,n=e.dilationHeight,s=e.effectiveFilterHeight,a=e.effectiveFilterWidth,i=s-1-e.padInfo.top,l=a-1-e.padInfo.left,u=s*a-1;this.userCode=`
      const ivec2 pads = ivec2(${i}, ${l});

      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];

        ivec2 dyRCCorner = coords.yz - pads;
        int dyRCorner = dyRCCorner.x;
        int dyCCorner = dyRCCorner.y;

        // Convolve dy(?, ?, d) with pos mask(:, :, d) to get dx(xR, xC, d).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;
        for (int wR = 0; wR < ${s};
          wR += ${n}) {
          float dyR = float(dyRCorner + wR) / ${t}.0;

          if (dyR < 0.0 || dyR >= ${e.outHeight}.0 || fract(dyR) > 0.0) {
            continue;
          }
          int idyR = int(dyR);

          for (int wC = 0; wC < ${a}; wC++) {
            float dyC = float(dyCCorner + wC) / ${o}.0;

            if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                fract(dyC) > 0.0) {
              continue;
            }
            int idyC = int(dyC);

            float dyValue = getDy(b, idyR, idyC, d);
            int maxPosValue = ${u} - int(getMaxPos(b, idyR, idyC, d));

            // Get the current value, check it against the value from the
            // position matrix.
            int curPosValue = wR * ${a} + wC;
            float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);

            dotProd += dyValue * mask;
          }
        }
        setOutput(dotProd);
      }
    `}},SC=class{constructor(e){this.variableNames=["dy","maxPos"],this.outputShape=e.inShape;let t=e.strideDepth,o=e.strideHeight,n=e.strideWidth,s=e.dilationDepth,a=e.dilationHeight,i=e.dilationWidth,l=e.effectiveFilterDepth,u=e.effectiveFilterHeight,c=e.effectiveFilterWidth,p=l-1-e.padInfo.front,m=u-1-e.padInfo.top,f=c-1-e.padInfo.left,d=l*u*c-1;this.userCode=`
      const ivec3 pads = ivec3(${p}, ${m}, ${f});

      void main() {
        ivec5 coords = getOutputCoords();
        int batch = coords.x;
        int ch = coords.u;

        ivec3 dyCorner = ivec3(coords.y, coords.z, coords.w) - pads;
        int dyDCorner = dyCorner.x;
        int dyRCorner = dyCorner.y;
        int dyCCorner = dyCorner.z;

        // Convolve dy(?, ?, ?, ch) with pos mask(:, :, :, d) to get
        // dx(xD, xR, xC, ch).
        // ? = to be determined. : = across all values in that axis.
        float dotProd = 0.0;

        for (int wD = 0; wD < ${l};
           wD += ${s}) {
          float dyD = float(dyDCorner + wD) / ${t}.0;

          if (dyD < 0.0 || dyD >= ${e.outDepth}.0 || fract(dyD) > 0.0) {
            continue;
          }
          int idyD = int(dyD);

          for (int wR = 0; wR < ${u};
              wR += ${a}) {
            float dyR = float(dyRCorner + wR) / ${o}.0;

            if (dyR < 0.0 || dyR >= ${e.outHeight}.0 ||
                fract(dyR) > 0.0) {
              continue;
            }
            int idyR = int(dyR);

            for (int wC = 0; wC < ${c};
                wC += ${i}) {
              float dyC = float(dyCCorner + wC) / ${n}.0;

              if (dyC < 0.0 || dyC >= ${e.outWidth}.0 ||
                  fract(dyC) > 0.0) {
                continue;
              }
              int idyC = int(dyC);

              float dyValue = getDy(batch, idyD, idyR, idyC, ch);
              int maxPosValue = ${d} -
                  int(getMaxPos(batch, idyD, idyR, idyC, ch));

              // Get the current value, check it against the value from the
              // position matrix.
              int curPosValue =
                  wD * ${u} * ${c} +
                  wR * ${c} + wC;
              float mask = float(maxPosValue == curPosValue ? 1.0 : 0.0);

              dotProd += dyValue * mask;
            }
          }
        }
        setOutput(dotProd);
      }
    `}};function qZ(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,input:s}=e,a=s,{filterSize:i,strides:l,pad:u,dimRoundingMode:c}=o,p=[1,1,1],m=N.computePool3DInfo(a.shape,i,l,p,u,c),f=new cc(m,"max",!0),d=t.runWebGLProgram(f,[a],a.dtype),h=new SC(m),g=t.runWebGLProgram(h,[n,d],a.dtype);return t.disposeIntermediateTensorInfo(d),g}var MO={kernelName:au,backendName:"webgl",kernelFunc:qZ};function KZ(r){let{inputs:e,backend:t,attrs:o}=r,{dy:n,input:s,output:a}=e,i=s;Yi([s,a],"maxPoolGrad");let{filterSize:l,strides:u,pad:c,dimRoundingMode:p}=o,m=N.computePool2DInfo(i.shape,l,u,1,c,p),f=!0,d=new Zi(m,"max",f),h=t.runWebGLProgram(d,[i],i.dtype),g=new NC(m),x=t.runWebGLProgram(g,[n,h],i.dtype);return t.disposeIntermediateTensorInfo(h),x}var LO={kernelName:iu,backendName:"webgl",kernelFunc:KZ};function zO(r,e,t,o){let n=new Zi(t,"max",!1),s=o.runWebGLProgram(n,[r],"float32");n=new Zi(t,"max",!0,!0,e);let a=o.runWebGLProgram(n,[r],"float32");return[s,a]}var BO={kernelName:lu,backendName:"webgl",kernelFunc:({inputs:r,attrs:e,backend:t})=>{let{x:o}=r,{filterSize:n,strides:s,pad:a,includeBatchInIndex:i}=e,l=t;y.assert(o.shape.length===4,()=>`Error in maxPool: input must be rank 4 but got rank ${o.shape.length}.`);let u=[1,1];y.assert(N.eitherStridesOrDilationsAreOne(s,u),()=>`Error in maxPool: Either strides or dilations must be 1. Got strides ${s} and dilations '${u}'`);let c=N.computePool2DInfo(o.shape,n,s,u,a),[p,m]=zO(o,i,c,l);return[p,m]}};function VO(r,e,t,o){let n=y.sizeFromShape(e),a=y.sizeFromShape(r.shape)/n,i=ce({inputs:{x:r},attrs:{shape:[a,n]},backend:o}),l=Io(i,"float32","mean",o),u=ce({inputs:{x:l},attrs:{shape:t},backend:o});return o.disposeIntermediateTensorInfo(i),o.disposeIntermediateTensorInfo(l),u}var GO={kernelName:pn,backendName:"webgl",kernelFunc:({inputs:r,attrs:e,backend:t})=>{let{x:o}=r,{keepDims:n,axis:s}=e,a=t,i=o.shape.length,l=y.parseAxisParam(s,o.shape),u=l,c=N.getAxesPermutation(u,i),p=c!=null,m=a.shouldExecuteOnCPU([o]),f=[],d=o;if(p){if(m){let w=a.texData.get(d.dataId).values,v=new Array(i);for(let R=0;R<v.length;R++)v[R]=o.shape[c[R]];let $=Up(w,o.shape,o.dtype,c,v);d=a.makeTensorInfo(v,o.dtype);let A=a.texData.get(d.dataId);A.values=$}else d=Al(o,c,a);f.push(d),u=N.getInnerMostAxes(u.length,i)}N.assertAxesAreInnerMostDims("sum",u,i);let[h,g]=N.computeOutAndReduceShapes(d.shape,u),x=h;n&&(x=N.expandShapeToKeepDim(h,l));let b=VO(d,g,x,a);for(let _ of f)a.disposeIntermediateTensorInfo(_);return b}};function XZ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,keepDims:a}=o,i=n.shape.length,l=y.parseAxisParam(s,n.shape),u=l,c=N.getAxesPermutation(u,i),p=n;c!=null&&(p=Lt({inputs:{x:n},backend:t,attrs:{perm:c}}),u=N.getInnerMostAxes(u.length,n.shape.length)),N.assertAxesAreInnerMostDims("min",u,i);let[m,f]=N.computeOutAndReduceShapes(p.shape,u),d=y.sizeFromShape(f),h=ce({inputs:{x:p},backend:t,attrs:{shape:[-1,d]}}),g=Io(h,h.dtype,"min",t),x;if(a){let b=N.expandShapeToKeepDim(m,l);x=ce({inputs:{x:g},backend:t,attrs:{shape:b}})}else x=ce({inputs:{x:g},backend:t,attrs:{shape:m}});return t.disposeIntermediateTensorInfo(h),t.disposeIntermediateTensorInfo(g),c!=null&&t.disposeIntermediateTensorInfo(p),x}var WO={kernelName:mn,backendName:"webgl",kernelFunc:XZ};var YZ=Px+`
  return min(a, b);
`,ZZ=`
  vec4 result = vec4(min(a, b));
  vec4 isNaN = min(vec4(isnan(a)) + vec4(isnan(b)), vec4(1.0));
  `+Tl+`
  return result;
`,JZ=it({opSnippet:YZ,packedOpSnippet:ZZ,cpuKernelImpl:aR}),UO={kernelName:fn,backendName:"webgl",kernelFunc:JZ};var TC=class{constructor(e,t,o){this.variableNames=["x"],this.outputShape=t.map((c,p)=>c[0]+e[p]+c[1]);let n=e.length,s=Le(n),a=t.map(c=>c[0]).join(","),i=t.map((c,p)=>c[0]+e[p]).join(","),l=["coords[0]","coords[1]","coords[2]","coords[3]"].slice(0,n),u=o==="reflect"?0:1;if(n===1){this.userCode=`
        int start = ${a};
        int end = ${i};

        void main() {
          int outC = getOutputCoords();
          if (outC < start) {
            outC = start * 2 - outC - ${u};
          } else if(outC >= end) {
            outC = (end - 1) * 2 - outC + ${u};
          }
          setOutput(getX(outC - start));
        }
      `;return}this.userCode=`
      ${s} start = ${s}(${a});
      ${s} end = ${s}(${i});

      void main() {
        ${s} outC = getOutputCoords();
        for (int i = 0; i < ${n}; i++) {
          if (outC[i] < start[i]) {
            outC[i] = start[i] * 2 - outC[i] - ${u};
          } else if(outC[i] >= end[i]) {
            outC[i] = (end[i] - 1) * 2 - outC[i] + ${u};
          }
        }
        ${s} coords = outC - start;
        setOutput(getX(${l}));
      }
    `}};var EC=class{constructor(e,t,o){this.variableNames=["x"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=t.map((d,h)=>d[0]+e[h]+d[1]);let n=e.length,s=Le(n),a=t.map(d=>d[0]).join(","),i=t.map((d,h)=>d[0]+e[h]).join(","),l=Ut("rc",n),u=Ut("source",n),c=`${l[n-1]} < ${this.outputShape[n-1]}`,p=n===1?"source":`vec2(${u.slice(-2).join()})`,m=o==="reflect"?0:1,f="";if(n===1){let d=`
        ${s} source = rc;
        if (source < start) {
          source = start * 2 - source - ${m};
        } else if (source >= end) {
          source = (end - 1) * 2 - source + ${m};
        }
        source -= start;
      `;f=`
        ${s} rc = outputLoc;
        ${d}
        result[0] = getChannel(getX(${u.join()}), ${p});
        ${l[n-1]} += 1;
        if(${c}) {
          ${d}
          result[1] = getChannel(getX(${u.join()}), ${p});
        }
      `}else{let d=`
        ${s} source = rc;
        ${s} lt = ${s}(lessThan(source, start));
        ${s} gte = ${s}(greaterThanEqual(source, end));
        ${s} orig = 1 - (lt + gte);
        source = orig * source +
                lt * (start * 2 - source - ${m}) +
                gte * ((end - 1) * 2 - source + ${m});
        source -= start;
      `;f=`
        ${s} rc = outputLoc;
        ${d}
        result[0] = getChannel(getX(${u.join()}), ${p});
        ${l[n-1]} += 1;
        if(${c}) {
          ${d}
          result[1] = getChannel(getX(${u.join()}), ${p});
        }
        rc = outputLoc;
        ${l[n-2]} += 1;
        if(${l[n-2]} < ${this.outputShape[n-2]}) {
          ${d}
          result[2] = getChannel(getX(${u.join()}), ${p});
          ${l[n-1]} += 1;
          if(${c}) {
            ${d}
            result[3] = getChannel(getX(${u.join()}), ${p});
          }
        }
      `}this.userCode=`
      const ${s} start = ${s}(${a});
      const ${s} end = ${s}(${i});

      void main() {
        ${s} outputLoc = getOutputCoords();
        vec4 result = vec4(0.);
        ${f}
        setOutput(result);
      }
    `}};var QZ=({inputs:r,backend:e,attrs:t})=>{let{x:o}=r,{paddings:n,mode:s}=t,a=G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")?new EC(o.shape,n,s):new TC(o.shape,n,s);return e.runWebGLProgram(a,[o],o.dtype)},jO={kernelName:ma,backendName:"webgl",kernelFunc:QZ};var e9=`if (b == 0.0) return NAN;
  return mod(a, b);`,t9=`
  vec4 result = mod(a, b);
  vec4 isNaN = vec4(equal(b, vec4(0.0)));
  `+Tl+`
  return result;
`,r9=it({opSnippet:e9,packedOpSnippet:t9}),HO={kernelName:yi,backendName:"webgl",kernelFunc:r9};var AC=class{constructor(e,t,o){this.variableNames=["probs"],this.outputShape=[e,o],this.userCode=`
      uniform float seed;

      void main() {
        ivec2 coords = getOutputCoords();
        int batch = coords[0];

        float r = random(seed);
        float cdf = 0.0;

        for (int i = 0; i < ${t-1}; i++) {
          cdf += getProbs(batch, i);

          if (r < cdf) {
            setOutput(float(i));
            return;
          }
        }

        // If no other event happened, last event happened.
        setOutput(float(${t-1}));
      }
    `}getCustomSetupFunc(e){return(t,o)=>{this.seedLoc==null&&(this.seedLoc=t.getUniformLocation(o,"seed")),t.gl.uniform1f(this.seedLoc,e)}}};var o9=`
if (a == b) {
  return 1.0;
};
return a / b;`,n9=`
  // vec4 one = vec4(equal(a, b));
  // return one + (vec4(1.0) - one) * a / b;
  vec4 result = a / b;
  if(a.x == b.x) {
    result.x = 1.;
  }
  if(a.y == b.y) {
    result.y = 1.;
  }
  if(a.z == b.z) {
    result.z = 1.;
  }
  if(a.w == b.w) {
    result.w = 1.;
  }

  return result;
`,DC=it({opSnippet:o9,packedOpSnippet:n9,checkOutOfBounds:!0}),qO={kernelName:Qo,backendName:"webgl",kernelFunc:DC};var KO="return a - b;",$C=it({opSnippet:KO,packedOpSnippet:KO,supportsComplex:!0,cpuKernelImpl:hR}),XO={kernelName:Dn,backendName:"webgl",kernelFunc:$C};function RC(r){let{inputs:e,backend:t,attrs:o}=r,{logits:n}=e,{dim:s}=o,a=y.parseAxisParam([s],n.shape),i=IC({inputs:{x:n},backend:t,attrs:{reductionIndices:a,keepDims:!1}}),l=N.expandShapeToKeepDim(i.shape,a),u=ce({inputs:{x:i},backend:t,attrs:{shape:l}}),c=$C({inputs:{a:n,b:u},backend:t}),p=hC({inputs:{x:c},backend:t}),m=ah({inputs:{x:p},backend:t,attrs:{axis:a,keepDims:!1}}),f=ce({inputs:{x:m},backend:t,attrs:{shape:l}}),d=DC({inputs:{a:p,b:f},backend:t});return t.disposeIntermediateTensorInfo(i),t.disposeIntermediateTensorInfo(u),t.disposeIntermediateTensorInfo(c),t.disposeIntermediateTensorInfo(p),t.disposeIntermediateTensorInfo(m),t.disposeIntermediateTensorInfo(f),d}var YO={kernelName:En,backendName:"webgl",kernelFunc:RC};function s9(r){let{inputs:e,backend:t,attrs:o}=r,{logits:n}=e,{numSamples:s,seed:a,normalized:i}=o,l=i?n:RC({inputs:{logits:n},backend:t,attrs:{dim:n.shape.length-1}}),u=l.shape[0],c=l.shape[1],p=new AC(u,c,s),m=p.getCustomSetupFunc(a),f=t.runWebGLProgram(p,[l],"int32",m);return i||t.disposeIntermediateTensorInfo(l),f}var ZO={kernelName:uu,backendName:"webgl",kernelFunc:s9};var JO="return -x;";function i9(r){let{inputs:e,backend:t}=r,{x:o}=e;if(t.shouldExecuteOnCPU([o])){let s=t.texData.get(o.dataId),[a,i]=uR(s.values,o.shape,o.dtype);return t.makeTensorInfo(i,o.dtype,a)}let n;return G().getBool("WEBGL_PACK_UNARY_OPERATIONS")?n=new Bs(o.shape,JO):n=new uo(o.shape,JO),t.runWebGLProgram(n,[o],o.dtype)}var QO={kernelName:cs,backendName:"webgl",kernelFunc:i9};var a9=Sr.nonMaxSuppressionV3Impl;function l9(r){N.warn("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");let{inputs:e,backend:t,attrs:o}=r,{boxes:n,scores:s}=e,{maxOutputSize:a,iouThreshold:i,scoreThreshold:l}=o,u=t.readSync(n.dataId),c=t.readSync(s.dataId),{selectedIndices:p}=a9(u,c,a,i,l);return t.makeTensorInfo([p.length],"int32",new Int32Array(p))}var eP={kernelName:_i,backendName:"webgl",kernelFunc:l9};var u9=Sr.nonMaxSuppressionV4Impl;function c9(r){N.warn("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");let{inputs:e,backend:t,attrs:o}=r,{boxes:n,scores:s}=e,{maxOutputSize:a,iouThreshold:i,scoreThreshold:l,padToMaxOutputSize:u}=o,c=t.readSync(n.dataId),p=t.readSync(s.dataId),{selectedIndices:m,validOutputs:f}=u9(c,p,a,i,l,u);return[t.makeTensorInfo([m.length],"int32",new Int32Array(m)),t.makeTensorInfo([],"int32",new Int32Array([f]))]}var tP={kernelName:wi,backendName:"webgl",kernelFunc:c9};var p9=Sr.nonMaxSuppressionV5Impl;function m9(r){N.warn("tf.nonMaxSuppression() in webgl locks the UI thread. Call tf.nonMaxSuppressionAsync() instead");let{inputs:e,backend:t,attrs:o}=r,{boxes:n,scores:s}=e,{maxOutputSize:a,iouThreshold:i,scoreThreshold:l,softNmsSigma:u}=o,c=t.readSync(n.dataId),p=t.readSync(s.dataId),m=a,f=i,d=l,h=u,{selectedIndices:g,selectedScores:x}=p9(c,p,m,f,d,h);return[t.makeTensorInfo([g.length],"int32",new Int32Array(g)),t.makeTensorInfo([x.length],"float32",new Float32Array(x))]}var rP={kernelName:ki,backendName:"webgl",kernelFunc:m9};var FC=class{constructor(e,t,o,n){this.variableNames=["indices"],this.outputShape=[e,t],this.userCode=`
      void main() {
        ivec2 coords = getOutputCoords();
        int index = round(getIndices(coords.x));
        setOutput(mix(float(${n}), float(${o}),
                      float(index == coords.y)));
      }
    `}};var f9=r=>{let{inputs:e,backend:t,attrs:o}=r,{indices:n}=e,{depth:s,onValue:a,offValue:i}=o,l=y.sizeFromShape(n.shape),u=new FC(l,s,a,i),c=ce({inputs:{x:n},backend:t,attrs:{shape:[l]}}),p=t.runWebGLProgram(u,[c],n.dtype);t.disposeIntermediateTensorInfo(c);let m=[...n.shape,s],f=ce({inputs:{x:p},backend:t,attrs:{shape:m}});return t.disposeIntermediateTensorInfo(p),f},oP={kernelName:hn,backendName:"webgl",kernelFunc:f9};function mh(r){let{inputs:e,backend:t}=r,{x:o}=e;if(o.dtype==="complex64"){let n=ja({inputs:{input:o},backend:t}),s=mh({inputs:{x:n},backend:t}),a=pc({inputs:{input:o},backend:t}),i=mh({inputs:{x:a},backend:t}),l=co({inputs:{real:s,imag:i},backend:t});return t.disposeIntermediateTensorInfo(n),t.disposeIntermediateTensorInfo(s),t.disposeIntermediateTensorInfo(a),t.disposeIntermediateTensorInfo(i),l}else return ph({attrs:{shape:o.shape,dtype:o.dtype,value:o.dtype==="string"?"":0},backend:t})}var nP={kernelName:ys,backendName:"webgl",kernelFunc:mh};function sP(r){let{inputs:e,backend:t}=r,{x:o}=e;if(o.dtype==="string")throw new Error("onesLike is not supported under string dtype");if(o.dtype==="complex64"){let n=ja({inputs:{input:o},backend:t}),s=sP({inputs:{x:n},backend:t}),a=pc({inputs:{input:o},backend:t}),i=mh({inputs:{x:a},backend:t}),l=co({inputs:{real:s,imag:i},backend:t});return t.disposeIntermediateTensorInfo(n),t.disposeIntermediateTensorInfo(s),t.disposeIntermediateTensorInfo(a),t.disposeIntermediateTensorInfo(i),l}else return ph({attrs:{shape:o.shape,dtype:o.dtype,value:1},backend:t})}var iP={kernelName:ps,backendName:"webgl",kernelFunc:sP};function d9(r){let{inputs:e,backend:t,attrs:o}=r,{axis:n}=o;if(e.length===1)return Hx({inputs:{input:e[0]},backend:t,attrs:{dim:n}});let s=e[0].shape,a=e[0].dtype;e.forEach(c=>{y.assertShapesMatch(s,c.shape,"All tensors passed to stack must have matching shapes"),y.assert(a===c.dtype,()=>"All tensors passed to stack must have matching dtypes")});let i=[],l=e.map(c=>{let p=Hx({inputs:{input:c},backend:t,attrs:{dim:n}});return i.push(p),p}),u=rC({inputs:l,backend:t,attrs:{axis:n}});return i.forEach(c=>t.disposeIntermediateTensorInfo(c)),u}var aP={kernelName:ms,backendName:"webgl",kernelFunc:d9};var OC=class{constructor(e,t,o){this.variableNames=["x"],this.outputShape=t.map((u,c)=>u[0]+e[c]+u[1]);let n=e.length,s=Le(n),a=t.map(u=>u[0]).join(","),i=t.map((u,c)=>u[0]+e[c]).join(","),l=["coords[0]","coords[1]","coords[2]","coords[3]"].slice(0,n);if(n===1){this.userCode=`
        int start = ${a};
        int end = ${i};

        void main() {
          int outC = getOutputCoords();
          if (outC < start || outC >= end) {
            setOutput(float(${o}));
          } else {
            setOutput(getX(outC - start));
          }
        }
      `;return}this.userCode=`
      ${s} start = ${s}(${a});
      ${s} end = ${s}(${i});

      void main() {
        ${s} outC = getOutputCoords();
        if (any(lessThan(outC, start)) || any(greaterThanEqual(outC, end))) {
          setOutput(float(${o}));
        } else {
          ${s} coords = outC - start;
          setOutput(getX(${l}));
        }
      }
    `}};var PC=class{constructor(e,t,o){this.variableNames=["x"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=t.map((h,g)=>h[0]+e[g]+h[1]);let n=e.length,s=Le(n),a=t.map(h=>h[0]).join(","),i=t.map((h,g)=>h[0]+e[g]).join(","),l=Ut("rc",n),u=Ut("source",n),c=`${l[n-1]} < ${this.outputShape[n-1]}`,p=n===1?"source":`vec2(${u.slice(-2).join()})`,m=[`${s} rc = outputLoc;`,`${l[n-1]} += 1;
       if(${c}) {
      `,n===1?"":`}
       rc = outputLoc;
       ${l[n-2]} += 1;
       if(${l[n-2]} < ${this.outputShape[n-2]}) {`,n===1?"":`  ${l[n-1]} += 1;
         if(${c}) {`],f=n===1?"rc < start || rc >= end":"any(lessThan(rc, start)) || any(greaterThanEqual(rc, end))",d="";for(let h=0,g=n===1?2:4;h<g;h++)d+=`
        ${m[h]}
        if (${f}) {
          result[${h}] = float(${o});
        } else {
          ${s} source = rc - start;
          result[${h}] = getChannel(getX(${u.join()}), ${p});
        }
      `;d+=n===1?"} ":"}}",this.userCode=`
      const ${s} start = ${s}(${a});
      const ${s} end = ${s}(${i});

      void main() {
        ${s} outputLoc = getOutputCoords();
        vec4 result = vec4(0.);
        ${d}
        setOutput(result);
      }
    `}};var MC=r=>{let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{paddings:s,constantValue:a}=o,i=G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")?new PC(n.shape,s,a):new OC(n.shape,s,a);return t.runWebGLProgram(i,[n],n.dtype)},lP={kernelName:gn,backendName:"webgl",kernelFunc:MC};var h9=`
  if(a < 0.0 && floor(b) < b){
    return NAN;
  }
  if (b == 0.0) {
    return 1.0;
  }
  return (round(mod(b, 2.0)) != 1) ?
      pow(abs(a), b) : sign(a) * pow(abs(a), b);
`,g9=`
  // isModRound1 has 1 for components with round(mod(b, 2.0)) == 1, 0 otherwise.
  vec4 isModRound1 = vec4(equal(round(mod(b, 2.0)), ivec4(1)));
  vec4 multiplier = sign(a) * isModRound1 + (vec4(1.0) - isModRound1);
  vec4 result = multiplier * pow(abs(a), b);

  // Ensure that a^0 = 1, including 0^0 = 1 as this correspond to TF and JS
  bvec4 isExpZero = equal(b, vec4(0.0));
  result.r = isExpZero.r ? 1.0 : result.r;
  result.g = isExpZero.g ? 1.0 : result.g;
  result.b = isExpZero.b ? 1.0 : result.b;
  result.a = isExpZero.a ? 1.0 : result.a;

  vec4 isNaN = vec4(lessThan(a, vec4(0.0))) * vec4(lessThan(floor(b), b));
  `+Tl+`
  return result;
`,x9=it({opSnippet:h9,packedOpSnippet:g9}),uP={kernelName:xn,backendName:"webgl",kernelFunc:x9};function y9(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{axis:s,keepDims:a}=o,i=n.shape.length,l=[],u=y.parseAxisParam(s,n.shape),c=u,p=N.getAxesPermutation(c,i),m=n;p!=null&&(m=Lt({inputs:{x:n},backend:t,attrs:{perm:p}}),c=N.getInnerMostAxes(c.length,i),l.push(m)),N.assertAxesAreInnerMostDims("prod",c,i);let f;if(t.shouldExecuteOnCPU([m])){let d=t.texData.get(m.dataId).values,{outVals:h,outShape:g,outDtype:x}=cR(m.shape,m.dtype,d,c);f=t.makeTensorInfo(g,x,h)}else{let[d,h]=N.computeOutAndReduceShapes(m.shape,c),g=y.sizeFromShape(h),x=ce({inputs:{x:m},backend:t,attrs:{shape:[-1,g]}}),b=hu(n.dtype),_=Io(x,b,"prod",t);f=ce({inputs:{x:_},backend:t,attrs:{shape:d}}),l.push(x),l.push(_)}if(a){l.push(f);let d=N.expandShapeToKeepDim(f.shape,u);f=ce({inputs:{x:f},backend:t,attrs:{shape:d}})}return l.forEach(d=>t.disposeIntermediateTensorInfo(d)),f}var cP={kernelName:vi,backendName:"webgl",kernelFunc:y9};var LC=r=>{let{backend:e,attrs:t}=r,{start:o,stop:n,step:s,dtype:a}=t,i=pR(o,n,s,a);return e.makeTensorInfo([i.length],a,i)},pP={kernelName:fa,backendName:"webgl",kernelFunc:LC};var b9="return 1.0 / x;",_9=ve({opSnippet:b9}),mP={kernelName:Ci,backendName:"webgl",kernelFunc:_9};var w9=gr+`
  return (x < 0.0) ? 0.0 : x;
`,k9=`
  vec4 result = x * vec4(greaterThanEqual(x, vec4(0.0)));
  bvec4 isNaN = isnan(x);

  result.r = isNaN.r ? x.r : result.r;
  result.g = isNaN.g ? x.g : result.g;
  result.b = isNaN.b ? x.b : result.b;
  result.a = isNaN.a ? x.a : result.a;

  return result;
`,v9=ve({opSnippet:w9,packedOpSnippet:k9}),fP={kernelName:bn,backendName:"webgl",kernelFunc:v9};var C9=gr+`
  return (x < 0.0) ? 0.0 : min(6.0, x);
`,I9=`
  vec4 result = min(x, vec4(6.)) * vec4(greaterThanEqual(x, vec4(0.0)));
  bvec4 isNaN = isnan(x);

  result.r = isNaN.r ? x.r : result.r;
  result.g = isNaN.g ? x.g : result.g;
  result.b = isNaN.b ? x.b : result.b;
  result.a = isNaN.a ? x.a : result.a;

  return result;
`,N9=ve({opSnippet:C9,packedOpSnippet:I9}),dP={kernelName:wn,backendName:"webgl",kernelFunc:N9};var zC=class{constructor(e,t,o,n,s){this.variableNames=["A"],this.outputShape=[];let[a,i,l,u]=e;this.outputShape=[a,t,o,u];let c=[n&&t>1?i-1:i,n&&o>1?l-1:l],p=[n&&t>1?t-1:t,n&&o>1?o-1:o],m;s?m="(vec2(yRC) + vec2(0.5)) * effectiveInputOverOutputRatioRC - vec2(0.5)":m="vec2(yRC) * effectiveInputOverOutputRatioRC",this.userCode=`
      const vec2 effectiveInputOverOutputRatioRC = vec2(
          ${c[0]/p[0]},
          ${c[1]/p[1]});
      const vec2 inputShapeRC = vec2(${i}.0, ${l}.0);

      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];
        ivec2 yRC = coords.yz;

        // Fractional source index.
        vec2 sourceFracIndexRC = ${m};

        // Compute the four integer indices.
        ivec2 sourceFloorRC = ivec2(max(sourceFracIndexRC, vec2(0.0)));
        ivec2 sourceCeilRC = ivec2(
          min(inputShapeRC - 1.0, ceil(sourceFracIndexRC)));

        float topLeft = getA(b, sourceFloorRC.x, sourceFloorRC.y, d);
        float bottomLeft = getA(b, sourceCeilRC.x, sourceFloorRC.y, d);
        float topRight = getA(b, sourceFloorRC.x, sourceCeilRC.y, d);
        float bottomRight = getA(b, sourceCeilRC.x, sourceCeilRC.y, d);

        vec2 fracRC = sourceFracIndexRC - vec2(sourceFloorRC);

        float top = topLeft + (topRight - topLeft) * fracRC.y;
        float bottom = bottomLeft + (bottomRight - bottomLeft) * fracRC.y;
        float newValue = top + (bottom - top) * fracRC.x;

        setOutput(newValue);
      }
    `}};var BC=class{constructor(e,t,o,n,s){this.variableNames=["A"],this.packedInputs=!0,this.packedOutput=!0,this.outputShape=[];let[a,i,l,u]=e;this.outputShape=[a,t,o,u];let c=[n&&t>1?i-1:i,n&&o>1?l-1:l],p=[n&&t>1?t-1:t,n&&o>1?o-1:o],m;s?m="(vec3(yRC) + vec3(0.5)) * effectiveInputOverOutputRatioRC - vec3(0.5)":m="vec3(yRC) * effectiveInputOverOutputRatioRC",this.userCode=`
      const vec3 effectiveInputOverOutputRatioRC = vec3(
          ${c[0]/p[0]},
          ${c[1]/p[1]},
          ${c[1]/p[1]});
      const vec3 inputShapeRC = vec3(${i}.0, ${l}.0,
                                     ${l}.0);

      float getAValue(int b, int r, int c, int d) {
        return getChannel(getA(b, r, c, d), vec2(c, d));
      }

      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];
        // Calculate values for next column in yRC.z.
        ivec3 yRC = coords.yzz + ivec3(0, 0, 1);

        // Fractional source index.
        vec3 sourceFracIndexRC = ${m};

        // Compute the four integer indices.
        ivec3 sourceFloorRC = ivec3(max(sourceFracIndexRC, vec3(0.0)));
        ivec3 sourceCeilRC = ivec3(
          min(inputShapeRC - 1.0, ceil(sourceFracIndexRC)));

        // Should we calculate next column and row elements in 2x2 packed cell.
        bool hasNextCol = d < ${u-1};
        bool hasNextRow = coords.z < ${o-1};

        // In parallel, construct four corners for all four components in
        // packed 2x2 cell.
        vec4 topLeft = vec4(
          getAValue(b, sourceFloorRC.x, sourceFloorRC.y, d),
          hasNextCol ? getAValue(b, sourceFloorRC.x, sourceFloorRC.y, d + 1)
                     : 0.0,
          hasNextRow ? getAValue(b, sourceFloorRC.x, sourceFloorRC.z, d)
                     : 0.0,
          (hasNextRow && hasNextCol) ?
            getAValue(b, sourceFloorRC.x, sourceFloorRC.z, d + 1) : 0.0);

        vec4 bottomLeft = vec4(
          getAValue(b, sourceCeilRC.x, sourceFloorRC.y, d),
          hasNextCol ? getAValue(b, sourceCeilRC.x, sourceFloorRC.y, d + 1)
                     : 0.0,
          hasNextRow ? getAValue(b, sourceCeilRC.x, sourceFloorRC.z, d)
                     : 0.0,
          (hasNextRow && hasNextCol) ?
            getAValue(b, sourceCeilRC.x, sourceFloorRC.z, d + 1) : 0.0);

        vec4 topRight = vec4(
          getAValue(b, sourceFloorRC.x, sourceCeilRC.y, d),
          hasNextCol ? getAValue(b, sourceFloorRC.x, sourceCeilRC.y, d + 1)
                     : 0.0,
          hasNextRow ? getAValue(b, sourceFloorRC.x, sourceCeilRC.z, d)
                     : 0.0,
          (hasNextRow && hasNextCol) ?
            getAValue(b, sourceFloorRC.x, sourceCeilRC.z, d + 1) : 0.0);

        vec4 bottomRight = vec4(
          getAValue(b, sourceCeilRC.x, sourceCeilRC.y, d),
          hasNextCol ? getAValue(b, sourceCeilRC.x, sourceCeilRC.y, d + 1)
                     : 0.0,
          hasNextRow ? getAValue(b, sourceCeilRC.x, sourceCeilRC.z, d)
                     : 0.0,
          (hasNextRow && hasNextCol) ?
            getAValue(b, sourceCeilRC.x, sourceCeilRC.z, d + 1) : 0.0);

        vec3 fracRC = sourceFracIndexRC - vec3(sourceFloorRC);

        vec4 top = mix(topLeft, topRight, fracRC.yyzz);
        vec4 bottom = mix(bottomLeft, bottomRight, fracRC.yyzz);
        vec4 newValue = mix(top, bottom, fracRC.x);

        setOutput(newValue);
      }
    `}};function S9(r){let{inputs:e,backend:t,attrs:o}=r,{images:n}=e,{alignCorners:s,halfPixelCenters:a,size:i}=o,[l,u]=i,c=G().getBool("WEBGL_PACK_IMAGE_OPERATIONS")?new BC(n.shape,l,u,s,a):new zC(n.shape,l,u,s,a);return t.runWebGLProgram(c,[n],"float32")}var hP={kernelName:_n,backendName:"webgl",kernelFunc:S9};var VC=class{constructor(e,t,o){this.variableNames=["dy"],this.outputShape=[],this.outputShape=t;let[,n,s]=t,[,a,i]=e,l=[o&&a>1?n-1:n,o&&i>1?s-1:s],u=[o&&a>1?a-1:a,o&&i>1?i-1:i],c=l[0]/u[0],p=l[1]/u[1],m=1/c,f=1/p,d=Math.ceil(m)*2+2,h=Math.ceil(f)*2+2;this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];
        int r = coords[1];
        int c = coords[2];

        float accumulator = 0.0;

        const float heightScale = float(${c});
        const float widthScale = float(${p});

        const float invHeightScale = float(${m});
        const float invWidthScale = float(${f});

        const int winHeight = int(${d});
        const int winWidth = int(${h});

        // Compute bounds for where in dy we will look
        float startRLerp = floor(float(r) * invHeightScale);
        int startDyR = int(startRLerp - float(winHeight / 2));

        float startCLerp = floor(float(c) * invWidthScale);
        int startDyC = int(startCLerp - float(winWidth / 2));

        // Loop over dy
        for (int dyROffset = 0; dyROffset < winHeight; dyROffset++) {
          int dyR = dyROffset + startDyR;

          // Guard against the window exceeding the bounds of dy
          if (dyR < 0 || dyR >= ${a}) {
            continue;
          }

          for (int dyCOffset = 0; dyCOffset < winWidth; dyCOffset++) {
            int dyC = dyCOffset + startDyC;

            // Guard against the window exceeding the bounds of dy
            if (dyC < 0 || dyC >= ${i}) {
              continue;
            }

            float dxR = float(dyR) * heightScale;
            int topDxRIndex = int(floor(dxR));
            int bottomDxRIndex = int(min(ceil(dxR), ${n-1}.0));
            float dxRLerp = dxR - float(topDxRIndex);
            float inverseDxRLerp = 1.0 - dxRLerp;

            float dxC = float(dyC) * widthScale;
            int leftDxCIndex = int(floor(dxC));
            int rightDxCIndex = int(min(ceil(dxC), ${s-1}.0));
            float dxCLerp = dxC - float(leftDxCIndex);
            float inverseDxCLerp = 1.0 - dxCLerp;

            if (r == topDxRIndex && c == leftDxCIndex) {
              // topLeft
              accumulator +=
                getDy(b, dyR, dyC, d) * inverseDxRLerp * inverseDxCLerp;
            }

            if (r == topDxRIndex && c == rightDxCIndex) {
              // topRight
              accumulator += getDy(b, dyR, dyC, d) * inverseDxRLerp * dxCLerp;
            }

            if (r == bottomDxRIndex && c == leftDxCIndex) {
              // bottomLeft
              accumulator += getDy(b, dyR, dyC, d) * dxRLerp * inverseDxCLerp;
            }

            if (r == bottomDxRIndex && c == rightDxCIndex) {
              // bottomRight
              accumulator += getDy(b, dyR, dyC, d) * dxRLerp * dxCLerp;
            }
          }
        }
        // End loop over dy

        setOutput(accumulator);
      }
    `}};function T9(r){let{inputs:e,backend:t,attrs:o}=r,{images:n,dy:s}=e,{alignCorners:a}=o,i=new VC(s.shape,n.shape,a);return t.runWebGLProgram(i,[s],s.dtype)}var gP={kernelName:mu,backendName:"webgl",kernelFunc:T9};var GC=class{constructor(e,t,o,n,s){this.variableNames=["A"],this.outputShape=[];let[a,i,l,u]=e;this.outputShape=[a,t,o,u];let c=[n&&t>1?i-1:i,n&&o>1?l-1:l],p=[n&&t>1?t-1:t,n&&o>1?o-1:o],m=n?"0.5":"0.0",f;s?f="max((vec2(yRC) + vec2(0.5)) * effectiveInputOverOutputRatioRC, vec2(0.0))":f="vec2(yRC) * effectiveInputOverOutputRatioRC",this.userCode=`
      const vec2 effectiveInputOverOutputRatioRC = vec2(
          ${c[0]/p[0]},
          ${c[1]/p[1]});
      const vec2 inputShapeRC = vec2(${i}.0, ${l}.0);

      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];
        ivec2 yRC = coords.yz;

        // Fractional source index.
        vec2 sourceFracIndexRC = ${f};

        // Compute the coordinators of nearest neighbor point.
        ivec2 sourceNearestRC = ivec2(
          min(inputShapeRC - 1.0, floor(sourceFracIndexRC + ${m})));
        float newValue = getA(b, sourceNearestRC.x, sourceNearestRC.y, d);

        setOutput(newValue);
      }
    `}};function E9(r){let{inputs:e,backend:t,attrs:o}=r,{images:n}=e,{alignCorners:s,halfPixelCenters:a,size:i}=o,[l,u]=i,c=new GC(n.shape,l,u,s,a);return t.runWebGLProgram(c,[n],n.dtype)}var xP={kernelName:da,backendName:"webgl",kernelFunc:E9};var WC=class{constructor(e,t,o){this.variableNames=["dy"],this.outputShape=[],this.outputShape=t;let[,n,s]=t,[,a,i]=e,l=[o&&a>1?n-1:n,o&&i>1?s-1:s],u=[o&&a>1?a-1:a,o&&i>1?i-1:i],c=l[0]/u[0],p=l[1]/u[1],m=1/c,f=1/p,d=Math.ceil(m)*2+2,h=Math.ceil(f)*2+2;this.userCode=`
      void main() {
        ivec4 coords = getOutputCoords();
        int b = coords[0];
        int d = coords[3];
        int r = coords[1];
        int c = coords[2];

        float accumulator = 0.0;

        const float heightScale = float(${c});
        const float widthScale = float(${p});

        const float invHeightScale = float(${m});
        const float invWidthScale = float(${f});

        const int winHeight = int(${d});
        const int winWidth = int(${h});

        // Compute bounds for where in dy we will look
        float startRLerp = floor(float(r) * invHeightScale);
        int startDyR = int(floor(startRLerp - float(winHeight / 2)));

        float startCLerp = floor(float(c) * invWidthScale);
        int startDyC = int(floor(startCLerp - float(winWidth / 2)));

        // Loop over dy
        for (int dyROffset = 0; dyROffset < winHeight; dyROffset++) {
          int dyR = dyROffset + startDyR;

          // Guard against the window exceeding the bounds of dy
          if (dyR < 0 || dyR >= ${a}) {
            continue;
          }

          for (int dyCOffset = 0; dyCOffset < winWidth; dyCOffset++) {
            int dyC = dyCOffset + startDyC;

            // Guard against the window exceeding the bounds of dy
            if (dyC < 0 || dyC >= ${i}) {
              continue;
            }

            float sourceFracRow =
              float(${l[0]}) *
                (float(dyR) / float(${u[0]}));

            float sourceFracCol =
                float(${l[1]}) *
                  (float(dyC) / float(${u[1]}));

            int sourceNearestRow = int(min(
                float(int(${n}) - 1),
                ${o} ? float(round(sourceFracRow)) :
                                  float(floor(sourceFracRow))));

            int sourceNearestCol = int(min(
                float(int(${s}) - 1),
                ${o} ? float(round(sourceFracCol)) :
                                  float(floor(sourceFracCol))));

            if (r == sourceNearestRow && c == sourceNearestCol) {
              accumulator += getDy(b, dyR, dyC, d);
            }
          }
        }
        // End loop over dy

        setOutput(accumulator);
      }
    `}};function A9(r){let{inputs:e,backend:t,attrs:o}=r,{images:n,dy:s}=e,{alignCorners:a}=o,i=new WC(s.shape,n.shape,a);return t.runWebGLProgram(i,[s],s.dtype)}var yP={kernelName:pu,backendName:"webgl",kernelFunc:A9};var UC=class{constructor(e,t){this.variableNames=["x"];let o=e.length;if(o>4)throw new Error(`WebGL backend: Reverse of rank-${o} tensor is not yet supported`);if(this.outputShape=e,o===1){this.userCode=`
        void main() {
          int coord = getOutputCoords();
          setOutput(getX(${e[0]} - coord - 1));
        }
      `;return}let n=i=>t.indexOf(i)!==-1&&e[i]!==1?`${e[i]} - coords[${i}] - 1`:`coords[${i}]`,s=e.map((i,l)=>n(l)).join(","),a=Le(o);this.userCode=`
      void main() {
        ${a} coords = getOutputCoords();
        setOutput(getX(${s}));
      }
    `}};var jC=class{constructor(e,t){this.variableNames=["x"],this.packedInputs=!0,this.packedOutput=!0;let o=e.length;if(o>4)throw new Error(`WebGL backend: Reverse of rank-${o} tensor is not yet supported`);this.outputShape=e;let n=Ut("rc",o),s=`${n[o-1]} + 1 < ${this.outputShape[o-1]}`,a=`${n[o-2]} + 1 < ${this.outputShape[o-2]}`,i=Le(o);o===1?this.userCode=`
        void main(){
          int rc = getOutputCoords();
          vec4 result = vec4(0.);
          result.r = getChannel(getX(${e[0]} - rc - 1),
            ${e[0]} - rc - 1);
          if(${s}){
              result.g = getChannel(getX(${e[0]} - (rc  + 1) - 1),
                ${e[0]} - (rc  + 1) - 1);
          }
          setOutput(result);
        }
      `:this.userCode=`
        void main() {
          ${i} rc = getOutputCoords();
          vec4 result = vec4(0.);
          result.r = ${l(n.slice())};
          if(${s}){
            result.g = ${u(n.slice())};
          }
          if(${a}) {
            result.b = ${c(n.slice())};
            if(${s}) {
              result.a = ${p(n.slice())};
            }
          }
          setOutput(result);
        }
    `;function l(d){return m(d)}function u(d){return d[o-1]="("+d[o-1]+" + 1)",m(d)}function c(d){return d[o-2]="("+d[o-2]+" + 1)",m(d)}function p(d){return d[o-1]="("+d[o-1]+" + 1)",d[o-2]="("+d[o-2]+" + 1)",m(d)}function m(d){let h=e.map((b,_)=>f(_,d)),g=h.join(","),x=h.slice(-2).join(",");return`getChannel(getX(${g}), vec2(${x}))`}function f(d,h){return t.indexOf(d)!==-1&&e[d]!==1?`${e[d]} - ${h[d]} - 1`:`${h[d]}`}}};function D9(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{dims:s}=o,a=n.shape.length,i=y.parseAxisParam(s,n.shape);if(a===0)return jt({inputs:{x:n},backend:t});let l=G().getBool("WEBGL_PACK_ARRAY_OPERATIONS")?new jC(n.shape,i):new UC(n.shape,i);return t.runWebGLProgram(l,[n],n.dtype)}var bP={kernelName:kn,backendName:"webgl",kernelFunc:D9};var HC=class{constructor(e,t,o,n){this.variableNames=["Image"],this.outputShape=[];let s=e[1],a=e[2],i=Math.sin(t).toFixed(3),l=Math.cos(t).toFixed(3);this.outputShape=e;let[u,c]=N.getImageCenter(n,s,a),p=u.toFixed(3),m=c.toFixed(3),f="";typeof o=="number"?f=`float outputValue = ${o.toFixed(2)};`:f=`
        vec3 fill = vec3(${o.join(",")});
        float outputValue = fill[coords[3]];`,this.userCode=`
        void main() {
          ivec4 coords = getOutputCoords();
          int x = coords[2];
          int y = coords[1];
          float coordXFloat = (float(x) - ${p}) * ${l} - (float(y) - ${m}) * ${i};
          float coordYFloat = (float(x) - ${p}) * ${i} + (float(y) - ${m}) * ${l};
          int coordX = int(round(coordXFloat + ${p}));
          int coordY = int(round(coordYFloat + ${m}));
          ${f}
          if(coordX >= 0 && coordX < ${a} && coordY >= 0 && coordY < ${s}) {
            outputValue = getImage(coords[0], coordY, coordX, coords[3]);
          }
          setOutput(outputValue);
        }
    `}};var _P={kernelName:Ri,backendName:"webgl",kernelFunc:({inputs:r,attrs:e,backend:t})=>{let{image:o}=r,{radians:n,fillValue:s,center:a}=e,i=t,l=new HC(o.shape,n,s,a);return i.runWebGLProgram(l,[o],o.dtype)}};var $9=`
  // OpenGL ES does not support round function.
  // The algorithm is based on banker's rounding.
  float base = floor(x);
  if ((x - base) < 0.5) {
    return floor(x);
  } else if ((x - base) > 0.5) {
    return ceil(x);
  } else {
    if (mod(base, 2.0) == 0.0) {
      return base;
    } else {
      return base + 1.0;
    }
  }
`,R9=ve({opSnippet:$9}),wP={kernelName:vn,backendName:"webgl",kernelFunc:R9};var F9="return inversesqrt(x);",O9=ve({opSnippet:F9,cpuKernelImpl:mR}),kP={kernelName:Cn,backendName:"webgl",kernelFunc:O9};var fh=class{constructor(e,t,o,n,s,a,i=!0){this.variableNames=["updates","indices","defaultValue"],this.outputShape=a;let l=Le(s.length),u=Le(a.length),c="";o===1?c="i":o===2&&(c="i, j");let p=`getIndices(${c})`,m="";n===1?m="i":n===2&&(m="i, coords[1]");let f=`getUpdates(${m})`,d=t>1?"strides[j]":"strides";this.userCode=`
        ${l} strides = ${l}(${s});

        void main() {
          ${u} coords = getOutputCoords();
          float sum = 0.0;
          bool found = false;
          for (int i = 0; i < ${e}; i++) {
            int flattenedIndex = 0;
            for (int j = 0; j < ${t}; j++) {
              int index = round(${p});
              flattenedIndex += index * ${d};
            }
            if (flattenedIndex == coords[0]) {
              sum += ${f};
              found = true;
            }
          }
          setOutput(mix(getDefaultValue(), sum, float(found)));
        }
      `}};function P9(r){let{inputs:e,backend:t,attrs:o}=r,{indices:n,updates:s}=e,{shape:a}=o,{sliceRank:i,numUpdates:l,sliceSize:u,strides:c,outputSize:p}=N.calculateShapes(s,n,a),m=[p/u,u];if(p===0)return t.makeTensorInfo(a,n.dtype);let f=ce({inputs:{x:n},backend:t,attrs:{shape:[l,i]}}),d=ce({inputs:{x:s},backend:t,attrs:{shape:[l,u]}}),h=t.makeTensorInfo([],"float32",new Float32Array([0])),g=new fh(l,i,f.shape.length,d.shape.length,c,m),x=t.runWebGLProgram(g,[d,f,h],d.dtype),b=ce({inputs:{x},backend:t,attrs:{shape:a}});return t.disposeIntermediateTensorInfo(f),t.disposeIntermediateTensorInfo(d),t.disposeIntermediateTensorInfo(x),t.disposeIntermediateTensorInfo(h),b}var vP={kernelName:Ii,backendName:"webgl",kernelFunc:P9};var qC=class{constructor(e,t,o){this.variableNames=["c","a","b"],this.outputShape=t;let n,s;if(o>4)throw Error(`Where for rank ${o} is not yet supported`);if(o===1)s="resRC",n="resRC";else{let i=["resRC.x","resRC.y","resRC.z","resRC.w"],l=[],u=[];for(let c=0;c<t.length;c++)u.push(`${i[c]}`),c<e&&l.push(`${i[c]}`);n=l.join(),s=u.join()}let a=Le(o);this.userCode=`
      void main() {
        ${a} resRC = getOutputCoords();
        float cVal = getC(${n});
        if (cVal >= 1.0) {
          setOutput(getA(${s}));
        } else {
          setOutput(getB(${s}));
        }
      }
    `}};function M9(r){let{inputs:e,backend:t}=r,{condition:o,t:n,e:s}=e,a=new qC(o.shape.length,n.shape,n.shape.length);return t.runWebGLProgram(a,[o,n,s],mr(n.dtype,s.dtype))}var CP={kernelName:ds,backendName:"webgl",kernelFunc:M9};var L9=`
  // Stable and Attracting Fixed Point (0, 1) for Normalized Weights.
  // see: https://arxiv.org/abs/1706.02515
  float scaleAlpha = ${N.SELU_SCALEALPHA};
  float scale = ${N.SELU_SCALE};
  return (x >= 0.0) ? scale * x : scaleAlpha * (exp(x) - 1.0);
`,z9=ve({opSnippet:L9}),IP={kernelName:Ni,backendName:"webgl",kernelFunc:z9};var B9="return 1.0 / (1.0 + exp(-1.0 * x));",V9=ve({opSnippet:B9}),NP={kernelName:Nn,backendName:"webgl",kernelFunc:V9};var G9=`
  if (isnan(x)) { return 0.0; }
  return sign(x);
`,W9=ve({opSnippet:G9}),SP={kernelName:Ti,backendName:"webgl",kernelFunc:W9};var U9=Mx+`
  return sin(x);
`,j9=ve({opSnippet:U9}),TP={kernelName:In,backendName:"webgl",kernelFunc:j9};var H9=`
  float e2x = exp(x);
  return (e2x - 1.0 / e2x) / 2.0;
`,q9=ve({opSnippet:H9}),EP={kernelName:Si,backendName:"webgl",kernelFunc:q9};var K9=`
  float epsilon = 1.1920928955078125e-7;
  float threshold = log(epsilon) + 2.0;

  bool too_large = x > -threshold;
  bool too_small = x < threshold;

  float result;
  float exp_x = exp(x);

  if (too_large){
    result = x;
  }
  else if (too_small){
    result = exp_x;
  }
  else{
    result = log(exp_x + 1.0);
  }
  return result;
`,X9=ve({opSnippet:K9}),AP={kernelName:Ei,backendName:"webgl",kernelFunc:X9};var Y9=r=>{let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{blockShape:s,paddings:a}=o;y.assert(n.shape.length<=4,()=>"spaceToBatchND for rank > 4 with a WebGL backend not implemented yet");let i=s.reduce((x,b)=>x*b),l=[[0,0]];l.push(...a);for(let x=1+s.length;x<n.shape.length;++x)l.push([0,0]);let u=[],c=MC({inputs:{x:n},backend:t,attrs:{paddings:l,constantValue:0}}),p=N.getReshaped(c.shape,s,i,!1),m=N.getPermuted(p.length,s.length,!1),f=N.getReshapedPermuted(c.shape,s,i,!1),d=ce({inputs:{x:c},backend:t,attrs:{shape:p}}),h=Lt({inputs:{x:d},backend:t,attrs:{perm:m}}),g=ce({inputs:{x:h},backend:t,attrs:{shape:f}});return u.push(c),u.push(d),u.push(h),u.forEach(x=>t.disposeIntermediateTensorInfo(x)),g},DP={kernelName:ha,backendName:"webgl",kernelFunc:Y9};function Z9(r){let{inputs:e,backend:t,attrs:o}=r,{sparseIndices:n,sparseValues:s,defaultValue:a}=e,{outputShape:i}=o,{sliceRank:l,numUpdates:u,strides:c,outputSize:p}=N.calculateShapes(s,n,i),m=!1,f=new fh(u,l,n.shape.length,s.shape.length,c,[p,1],m),d=t.runWebGLProgram(f,[s,n,a],s.dtype),h=ce({inputs:{x:d},backend:t,attrs:{shape:i}});return t.disposeIntermediateTensorInfo(d),h}var $P={kernelName:fu,backendName:"webgl",kernelFunc:Z9};function J9(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{numOrSizeSplits:s,axis:a}=o,i=y.parseAxisParam(a,n.shape)[0],l=N.prepareSplitSize(n,s,i),u=n.shape.length,c=new Array(u).fill(0),p=n.shape.slice();return l.map(m=>{let f=[...p];f[i]=m;let d=Ua({inputs:{x:n},backend:t,attrs:{begin:c,size:f}});return c[i]+=m,d})}var RP={kernelName:gs,backendName:"webgl",kernelFunc:J9};var Q9="return sqrt(x);",eJ=ve({opSnippet:Q9}),FP={kernelName:Sn,backendName:"webgl",kernelFunc:eJ};var tJ="return x * x;",rJ=ve({opSnippet:tJ}),OP={kernelName:ga,backendName:"webgl",kernelFunc:rJ};var PP="return (a - b) * (a - b);",oJ=it({opSnippet:PP,packedOpSnippet:PP}),MP={kernelName:An,backendName:"webgl",kernelFunc:oJ};function nJ({inputs:r,attrs:e,backend:t}){let{x:o}=r,n=gr+`
    return x > 0.0 ? 1.0 : float(${e.alpha});
  `,s=new uo(o.shape,n);return t.runWebGLProgram(s,[o],o.dtype)}var LP={kernelName:Do,backendName:"webgl",kernelFunc:nJ};var KC=class{constructor(e,t,o){this.variableNames=["x"],this.outputShape=o;let n=o.length,s=Le(o.length),a=Le(o.length),i="";if(n===1)i="coords * strides + begin";else{let l=0;i=o.map((u,c)=>(l++,o.length===1?`coords * strides[${c}] + begin[${c}]`:`coords[${l-1}] * strides[${c}] + begin[${c}]`)).join(",")}this.userCode=`
      ${s} begin = ${s}(${e});
      ${s} strides = ${s}(${t});

      void main() {
        ${a} coords = getOutputCoords();
        setOutput(getX(${i}));
      }
    `}};function sJ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{begin:s,end:a,strides:i,beginMask:l,endMask:u,ellipsisMask:c,newAxisMask:p,shrinkAxisMask:m}=o,{nonStrided:f,$begin:d,$strides:h,size:g,newShape:x,outShape:b}=or.sliceInfo(n.shape,s,a,i,l,u,c,p,m),_=ce({inputs:{x:n},backend:t,attrs:{shape:x}}),w;if(f){let $=Ua({inputs:{x:_},backend:t,attrs:{begin:d,size:g}});w=ce({inputs:{x:$},backend:t,attrs:{shape:b}}),t.disposeIntermediateTensorInfo($)}else if(b.some($=>$===0))w=t.makeTensorInfo(b,n.dtype,[]);else if(t.shouldExecuteOnCPU([_])){let R=t.texData.get(_.dataId).values,M=Ce(_.shape,_.dtype,R),z=dR(b,M,h,d);w=t.makeTensorInfo(b,_.dtype,z.values)}else{let A=new KC(d,h,b);w=t.runWebGLProgram(A,[_],_.dtype)}let v=ce({inputs:{x:w},backend:t,attrs:{shape:b}});return t.disposeIntermediateTensorInfo(_),t.disposeIntermediateTensorInfo(w),v}var zP={kernelName:Ai,backendName:"webgl",kernelFunc:sJ};var iJ="return tan(x);",aJ=ve({opSnippet:iJ}),BP={kernelName:Di,backendName:"webgl",kernelFunc:aJ};var lJ=`
  float e2x = exp(-2.0 * abs(x));
  return sign(x) * (1.0 - e2x) / (1.0 + e2x);
`,uJ=ve({opSnippet:lJ}),VP={kernelName:$n,backendName:"webgl",kernelFunc:uJ};var XC=class{constructor(e,t){this.variableNames=["A"];let o=new Array(e.length);for(let a=0;a<o.length;a++)o[a]=e[a]*t[a];this.outputShape=o,this.rank=o.length;let n=Le(this.rank),s=cJ(e);this.userCode=`
      void main() {
        ${n} resRC = getOutputCoords();
        setOutput(getA(${s}));
      }
    `}};function cJ(r){let e=r.length;if(e>5)throw Error(`Tile for rank ${e} is not yet supported`);if(e===1)return`imod(resRC, ${r[0]})`;let t=["resRC.x","resRC.y","resRC.z","resRC.w","resRC.u"],o=[];for(let n=0;n<r.length;n++)o.push(`imod(${t[n]}, ${r[n]})`);return o.join()}function YC(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{reps:s}=o;if(n.dtype==="string"){let u=t.readSync(n.dataId).map(m=>y.decodeString(m)),c=Ce(n.shape,n.dtype,u),p=gR(c,s);return t.makeTensorInfo(p.shape,p.dtype,p.values)}let a=new XC(n.shape,s);return t.runWebGLProgram(a,[n],n.dtype)}var GP={kernelName:yo,backendName:"webgl",kernelFunc:YC};function pJ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n}=e,{k:s,sorted:a}=o,i=t.readSync(n.dataId),[l,u]=xR(i,n.shape,n.dtype,s,a);return[t.makeTensorInfo(l.shape,l.dtype,l.values),t.makeTensorInfo(u.shape,u.dtype,u.values)]}var WP={kernelName:$i,backendName:"webgl",kernelFunc:pJ};function mJ(r){let{inputs:e,attrs:t,backend:o}=r,{axis:n}=t,{x:s}=e;Yi(s,"unique"),console.warn("WARNING: ","UI might be locked temporarily as data is being downloaded");let a=o.readSync(s.dataId),{outputValues:i,outputShape:l,indices:u}=yR(a,n,s.shape,s.dtype);return[o.makeTensorInfo(l,s.dtype,i),o.makeTensorInfo([u.length],"int32",u)]}var UP={kernelName:du,backendName:"webgl",kernelFunc:mJ};function fJ(r){let{inputs:e,backend:t,attrs:o}=r,{value:n}=e,{axis:s}=o;s<0&&(s+=n.shape.length);let a=n,i=a.shape.length,l=n.shape[s],u=new Array(i-1),c=0;for(let h=0;h<i;h++)h!==s&&(u[c++]=a.shape[h]);let p=[],m=new Array(i).fill(0),f=a.shape.slice();f[s]=1;let d=new Array(l);for(let h=0;h<d.length;h++){m[s]=h;let g=Ua({inputs:{x:a},backend:t,attrs:{begin:m,size:f}}),x=ce({inputs:{x:g},backend:t,attrs:{shape:u}});d[h]=x,p.push(g)}return p.forEach(h=>t.disposeIntermediateTensorInfo(h)),d}var jP={kernelName:xs,backendName:"webgl",kernelFunc:fJ};var ZC=class{constructor(e,t){this.variableNames=["x","segmentIds"];let o=e.windowSize,n=e.batchSize,s=e.inSize,a=e.numSegments,i=a*Math.ceil(s/o);this.outputShape=[n,i];let l="0.0",u="sumValue",c=Math.floor(o/4)*4,p=o%4,m=`
        sumValue += dot(values, segFilter);
    `,f="";s%o>0&&(f=`
        if (inIdx < 0 || inIdx >= ${s}) {
          return initializationValue;
        }
      `);let d="";s%o>0&&(d=`
        if (inIdx < 0 || inIdx >= ${s}) {
          return -1.0;
        }
      `),this.userCode=`
      const float initializationValue = ${l};

      float getValue(int batch, int inIdx) {
        ${f}
        return getX(batch, inIdx);
      }

      float getSegmentIdAtIndex(int inIdx) {
        ${d}
        return getSegmentIds(inIdx);
      }

      void main() {
        ivec2 coords = getOutputCoords();
        int batch = coords[0];
        int outIdx = coords[1];
        int inOffset = int(floor(float(outIdx) / float(
          ${a})) * float(${o}));
        int currentSeg = int(mod(float(outIdx), float(${a})));

        float sumValue = 0.0;

        for (int i = 0; i < ${c}; i += 4) {
          int inIdx = inOffset + i;
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2),
            getValue(batch, inIdx + 3)
          );

          vec4 segFilter = vec4(
            int(getSegmentIdAtIndex(inIdx)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 1)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 2)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 3)) == currentSeg ? 1 : 0
          );

          ${m}
        }

        int inIdx = inOffset + ${c};
        if (${p===1}) {
          vec4 values = vec4(
            getValue(batch, inIdx),
            initializationValue,
            initializationValue,
            initializationValue
          );

          int inIdxSeg = int(getSegmentIdAtIndex(inIdx));

          vec4 segFilter = vec4(
            int(getSegmentIdAtIndex(inIdx)) == currentSeg ? 1 : 0,
            0,
            0,
            0
          );

          ${m}
        } else if (${p===2}) {
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            initializationValue,
            initializationValue
          );

          vec4 segFilter = vec4(
            int(getSegmentIdAtIndex(inIdx)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 1)) == currentSeg ? 1 : 0,
              0,
              0
          );

          ${m}
        } else if (${p===3}) {
          vec4 values = vec4(
            getValue(batch, inIdx),
            getValue(batch, inIdx + 1),
            getValue(batch, inIdx + 2),
            initializationValue
          );

          vec4 segFilter = vec4(
            int(getSegmentIdAtIndex(inIdx)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 1)) == currentSeg ? 1 : 0,
            int(getSegmentIdAtIndex(inIdx + 2)) == currentSeg ? 1 : 0,
            0
          );

          ${m}
        }
        setOutput(${u});
      }
    `}};function dJ(r){let{inputs:e,backend:t,attrs:o}=r,{x:n,segmentIds:s}=e,{numSegments:a}=o,i=n.shape.length,l=[],u=0,c=N.getAxesPermutation([u],i),p=n;c!=null&&(p=Lt({inputs:{x:n},backend:t,attrs:{perm:c}}),l.push(p),u=N.getInnerMostAxes(1,i)[0]);let m=N.segment_util.computeOutShape(p.shape,u,a),f=y.sizeFromShape([p.shape[u]]),d=ce({inputs:{x:p},backend:t,attrs:{shape:[-1,f]}});l.push(d);let h=hu(n.dtype),g=(w,v,$,A,R)=>{let M=w.shape[0],z=w.shape[1],W=N.segment_util.segOpComputeOptimalWindowSize(z,R),U={windowSize:W,inSize:z,batchSize:M,numSegments:R},q=new ZC(U,v),Z=t.compileAndRun(q,[w,$],A);if(l.push(Z),Z.shape[1]===R)return Z;let X=LC({backend:t,attrs:{start:0,stop:R,step:1,dtype:"float32"}}),Y=YC({inputs:{x:X},backend:t,attrs:{reps:[z/W]}});return l.push(X),l.push(Y),g(Z,v,Y,A,R)},x=g(d,"unsortedSegmentSum",s,h,a),b=ce({inputs:{x},backend:t,attrs:{shape:m}}),_=b;if(c!=null){l.push(b);let w=N.getUndoAxesPermutation(c);_=Lt({inputs:{x:_},backend:t,attrs:{perm:w}})}return l.forEach(w=>t.disposeIntermediateTensorInfo(w)),_}var HP={kernelName:xa,backendName:"webgl",kernelFunc:dJ};var hJ=[AO,DO,jR,qR,KR,XR,ZR,JR,QR,eF,oF,nF,sF,iF,lF,aF,uF,pF,cF,mF,fF,dF,hF,xF,yF,kF,CF,IF,SF,RR,AF,$F,RF,DF,OF,PF,FF,MF,LF,zF,GF,WF,UF,HF,qF,jF,KF,XF,YF,ZF,JF,QF,tO,rO,nO,sO,iO,aO,uO,cO,pO,mO,fO,dO,hO,gO,xO,$R,yO,TF,bO,_O,wO,FR,kO,vO,CO,NO,IO,SO,TO,EO,RO,PO,OO,MO,LO,BO,FO,GO,WO,UO,jO,HO,ZO,zR,QO,eP,tP,rP,bF,oP,iP,aP,lP,uP,OR,cP,pP,_F,qO,mP,dP,fP,VR,hP,gP,xP,yP,bP,_P,wP,kP,vP,CP,IP,NP,SP,TP,EP,gF,YO,AP,DP,$P,RP,FP,OP,MP,LP,zP,XO,WR,BP,VP,GP,WP,UR,UP,jP,HP,nP];for(let r of hJ)Qa(r);var qP="3.0.0";var gJ={"tfjs-core":Qb,"tfjs-backend-cpu":EA,"tfjs-backend-webgl":DR,"tfjs-data":wx,"tfjs-layers":hl,"tfjs-converter":dx,tfjs:qP};var zt;(function(r){r[r.float32=0]="float32",r[r.int32=1]="int32",r[r.bool=2]="bool",r[r.string=3]="string",r[r.complex64=4]="complex64"})(zt||(zt={}));var Dl;(function(r){r[r.linear=0]="linear",r[r.relu=1]="relu",r[r.relu6=2]="relu6",r[r.prelu=3]="prelu",r[r.leakyrelu=4]="leakyrelu"})(Dl||(Dl={}));var KP;function xJ(r){KP=r.wasm.cwrap(bs,null,["number","array","number","number","array","number","number","number","number","number","number","number","number"])}function yJ(r){let{inputs:e,backend:t,attrs:o}=r,{a:n,b:s,bias:a,preluActivationWeights:i}=e;if(n.dtype!=="float32"||s.dtype!=="float32")throw new Error("_FusedMatMul for non non-float32 tensors not yet supported.");let{transposeA:l,transposeB:u,activation:c,leakyreluAlpha:p}=o,m=t.dataIdMap.get(n.dataId).id,f=t.dataIdMap.get(s.dataId).id,d=0;if(a!=null){let R=t.dataIdMap.get(a.dataId);if(R.shape.length!==1)throw new Error(`_FusedMatMul only supports rank-1 bias but got rank ${R.shape.length}.`);d=R.id}let h=i==null?0:t.dataIdMap.get(i.dataId).id,g=Dl[c];if(g==null)throw new Error(`${c} activation not yet supported for FusedConv2D in the wasm backend.`);let x=l?n.shape[2]:n.shape[1],b=u?s.shape[1]:s.shape[2],_=n.shape[0],w=t.makeOutput([_,x,b],n.dtype),v=t.dataIdMap.get(w.dataId).id,$=new Uint8Array(new Int32Array(n.shape).buffer),A=new Uint8Array(new Int32Array(s.shape).buffer);return KP(m,$,n.shape.length,f,A,s.shape.length,l,u,g,d,h,p||0,v),w}var XP={kernelName:bs,backendName:"wasm",setupFunc:xJ,kernelFunc:yJ};function Rt(r){let e;function t(n){e=n.wasm.cwrap(r,null,["number","number"])}function o(n){let{backend:s,inputs:{x:a}}=n,i=s.dataIdMap.get(a.dataId).id,l=s.makeOutput(a.shape,a.dtype),u=s.dataIdMap.get(l.dataId).id;return y.sizeFromShape(l.shape)===0||e(i,u),l}return{kernelName:r,backendName:"wasm",setupFunc:t,kernelFunc:o}}var YP=Rt(ss);function _t(r,e,t){let o;function n(a){o=a.wasm.cwrap(r,null,["number","array","number","number","array","number","number","number"])}function s(a){let{backend:i,inputs:l}=a,{a:u,b:c}=l,p=i.dataIdMap.get(u.dataId).id,m=i.dataIdMap.get(c.dataId).id,f=t!=null?t:u.dtype,d=N.assertAndGetBroadcastShape(u.shape,c.shape),h=i.makeOutput(d,f);if(y.sizeFromShape(d)===0)return h;let g=new Uint8Array(new Int32Array(u.shape).buffer),x=new Uint8Array(new Int32Array(c.shape).buffer),b=i.dataIdMap.get(h.dataId).id,_=()=>o(p,g,u.shape.le
/**
 * @license
 * Copyright 2017 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2018 Google LLC
 *
 * Use of this source code is governed by an MIT-style
 * license that can be found in the LICENSE file or at
 * https://opensource.org/licenses/MIT.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2018 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * =============================================================================
 */
/**
 * @license
 * Copyright 2018 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2019 Google LLC
 *
 * Use of this source code is governed by an MIT-style
 * license that can be found in the LICENSE file or at
 * https://opensource.org/licenses/MIT.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2019 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * =============================================================================
 */
/**
 * @license
 * Copyright 2019 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2020 Google Inc. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2020 Google LLC
 *
 * Use of this source code is governed by an MIT-style
 * license that can be found in the LICENSE file or at
 * https://opensource.org/licenses/MIT.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2020 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2020 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the License);
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an AS IS BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/**
 * @license
 * Copyright 2021 Google LLC. All Rights Reserved.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * =============================================================================
 */
/** @license See the LICENSE file. */
//# sourceMappingURL=tfjs.esm.js.map