{"version":3,"file":"npm.apollo.js?version=a36fd16dd528c21d6807","mappings":"spBAEAA,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBC,EAAQ,EAAQ,wBAChBC,EAAY,EAAQ,wBACpBC,EAAQ,EAAQ,wBAEpB,SAASC,EAAkBC,GACvB,GAAIA,GAAKA,EAAEC,WAAY,OAAOD,EAC9B,IAAIE,EAAIX,OAAOY,OAAO,MACtB,GAAIH,EACA,IAAK,IAAII,KAAKJ,EACVE,EAAEE,GAAKJ,EAAEI,GAIjB,OADAF,EAAW,QAAIF,EACRT,OAAOc,OAAOH,EACzB,CAEA,IAAII,EAAgCP,EAAkBH,GAElDW,EAAaV,EAAUW,aAAeC,OAAOC,IAAI,sBAAwB,qBAC7E,SAASC,IACLhB,EAAQiB,UAAU,kBAAmBN,EAAkB,IACvD,IAAIO,EAAUP,EAAiBQ,cAAcP,GAU7C,OATKM,IACDtB,OAAOC,eAAec,EAAiBQ,cAAeP,EAAY,CAC9Db,MAAQmB,EAAUP,EAAiBQ,cAAc,CAAC,GAClDC,YAAY,EACZC,UAAU,EACVC,cAAc,IAElBJ,EAAQK,YAAc,iBAEnBL,CACX,CA2BApB,EAAQ0B,eAnBa,SAAUC,GAC3B,IAAIC,EAAgBV,IACpB,OAAQL,EAAiBgB,cAAcD,EAAcE,SAAU,KAAM,SAAUV,GAE3E,OADAlB,EAAQiB,UAAUC,GAAWA,EAAQW,OAAQ,IACtCJ,EAAMK,SAASZ,EAAQW,OAClC,EACJ,EAcA/B,EAAQiC,eAZa,SAAUC,GAC3B,IAAIH,EAASG,EAAGH,OAAQC,EAAWE,EAAGF,SAClCJ,EAAgBV,IAChBiB,EAAgBtB,EAAiBuB,WAAWR,GAC5CR,EAAUP,EAAiBwB,QAAQ,WACnC,OAAOhC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGH,GAAgB,CAAEJ,OAAQA,GAAUI,EAAcJ,QAC/F,EAAG,CAACI,EAAeJ,IAEnB,OADA7B,EAAQiB,UAAUC,EAAQW,OAAQ,IAC1BlB,EAAiBgB,cAAcD,EAAcW,SAAU,CAAEtC,MAAOmB,GAAWY,EACvF,EAIAhC,EAAQkB,iBAAmBA,EAC3BlB,EAAQwC,mBA7BiB,WAIrB,OAH2B,IAAvBC,WAAWC,UACY,IAAvBD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAEpDzB,GACX,C,yCCzCApB,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBE,EAAY,EAAQ,wBACpBC,EAAQ,EAAQ,wBAChBuC,EAAW,EAAQ,wBAEnBC,EAAe,CAAC,EAKpB,IAoBWC,EAKPC,EA7B+BC,EAI/BC,EAAsBjC,OAAOC,IAAI,uBACjCiC,EAAShD,EAAQgD,OACjBC,EAAO,IAAIP,EAASQ,KAWxB,SAASC,EAAeC,EAAMC,IAV9B,SAAiBD,GACb,OAAOJ,EAAOD,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC3E,EASSI,CAAQJ,IACTC,GAER,CASA,SAASI,EAAcC,GACnB,IAAIN,EACJ,OAAQM,GACJ,KAAK5D,EAAQ8C,aAAae,MACtBP,EAAO,QACP,MACJ,KAAKtD,EAAQ8C,aAAagB,SACtBR,EAAO,WACP,MACJ,KAAKtD,EAAQ8C,aAAaiB,aACtBT,EAAO,eAGf,OAAOA,CACX,CACA,SAASU,EAAOC,GACZZ,EAAe,SAAU,YACE,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,GACKI,IACDA,EAAQ,IAAI3C,EAAU8D,qBAAqB9D,EAAU+D,WAAWH,QAAU,MAE9E,IAGII,EAAWR,EAHXS,EAAStB,EAAMuB,IAAIL,GACvB,GAAII,EACA,OAAOA,EAEXnE,EAAQiB,YAAY8C,KAAcA,EAASM,KAAM,GAAIN,GAKrD,IAJA,IAAIO,EAAY,GACZC,EAAU,GACVC,EAAY,GACZC,EAAgB,GACXC,EAAK,EAAG1C,EAAK+B,EAASY,YAAaD,EAAK1C,EAAG4C,OAAQF,IAAM,CAC9D,IAAIG,EAAI7C,EAAG0C,GACX,GAAe,uBAAXG,EAAER,MAIN,GAAe,wBAAXQ,EAAER,KACF,OAAQQ,EAAEC,WACN,IAAK,QACDP,EAAQQ,KAAKF,GACb,MACJ,IAAK,WACDL,EAAUO,KAAKF,GACf,MACJ,IAAK,eACDJ,EAAcM,KAAKF,SAZ3BP,EAAUS,KAAKF,EAgBvB,CACA7E,EAAQiB,WAAWqD,EAAUM,QACzBL,EAAQK,QACRJ,EAAUI,QACVH,EAAcG,OAAQ,IAC1B5E,EAAQiB,UACJsD,EAAQK,OAASJ,EAAUI,OAASH,EAAcG,QAAU,EAC5D,GACAb,EACAQ,EAAQK,OACRH,EAAcG,OACdJ,EAAUI,QAEdlB,EAAOa,EAAQK,OAAS9E,EAAQ8C,aAAae,MAAQ7D,EAAQ8C,aAAagB,SACrEW,EAAQK,QAAWJ,EAAUI,SAC9BlB,EAAO5D,EAAQ8C,aAAaiB,cAChC,IAAIc,EAAcJ,EAAQK,OAASL,EAC7BC,EAAUI,OAASJ,EACfC,EACVzE,EAAQiB,UAAiC,IAAvB0D,EAAYC,OAAc,GAAIb,EAAUY,EAAYC,QACtE,IAAII,EAAaL,EAAY,GAC7BT,EAAYc,EAAWC,qBAAuB,GAO9C,IAAIC,EAAU,CAAE9B,KANZ4B,EAAW5B,MAAiC,SAAzB4B,EAAW5B,KAAKiB,KAC5BW,EAAW5B,KAAKrD,MAGhB,OAEiB2D,KAAMA,EAAMQ,UAAWA,GAEnD,OADArB,EAAMsC,IAAIpB,EAAUmB,GACbA,CACX,CAxFApF,EAAQ8C,kBAAe,GACZA,EAIR9C,EAAQ8C,eAAiB9C,EAAQ8C,aAAe,CAAC,IAHnCA,EAAoB,MAAI,GAAK,QAC1CA,EAAaA,EAAuB,SAAI,GAAK,WAC7CA,EAAaA,EAA2B,aAAI,GAAK,eAqFrDkB,EAAOsB,WAAa,WAChBvC,OAAQwC,CACZ,GAC2B,IAAvB9C,WAAWC,UAnHoBM,EAoHD,WAAc,OAAQD,EAAQA,EAAMyC,KAAO,CAAI,EAnH7E3C,EAmHoB,UAnHCG,GAkIzBhD,EAAQ2D,cAAgBA,EACxB3D,EAAQgE,OAASA,EACjBhE,EAAQyF,mBAfR,SAA4BxB,EAAUL,GAClC,IAAIoB,EA7GR,SAA0B1B,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,OAAOzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CAuGoBO,CAAiB,SAAUjC,EAAQ,CAACC,IAChDiC,EAAwBvC,EAAcC,GACtCuC,EAAoBxC,EAAcqB,EAAUpB,MAChD1D,EAAQiB,UACJ6D,EAAUpB,OAASA,EACnB,GACAsC,EACAA,EACAC,EAER,C,yCCzIArG,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAI2C,EAAW,EAAQ,wBACnB1C,EAAU,EAAQ,wBAClBE,EAAY,EAAQ,wBACpBgG,EAAU,EAAQ,wBAGtB,SAASC,EAAuB9F,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAW,QAAIA,CAAG,CAE7G,IAAI+F,EAA8BD,EAJtB,EAAQ,yBAMhBE,EAAUnG,EAAUoG,cAAgBC,QAAUC,IAC9CC,EAAUvG,EAAUwG,cAAgBC,QAAUC,IAC9CC,EAAsB,IAAInE,EAASQ,KACnC4D,GAAgB,EACpB,SAASC,IACAD,IACDA,GAAgB,GACO,IAAvBvE,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAE/D,CAEA,SAASuE,EAAeC,EAAMC,EAAchG,GACxC,OAAO2F,EAAoBnB,WAAU,EAAM,WACvC,IAAIyB,EAASC,EAAiBH,EAAMC,EAAchG,GAAS,GAI3D,OAHItB,OAAOyH,SAASJ,IAChB/G,EAAUoH,gBAAgBH,GAEvBA,CACX,EACJ,CASA,SAASC,EAAiBH,EAAMC,EAAchG,EAASqG,EAAWC,GAC9D,IAAIxF,EACAyF,EAAevG,EAAQuG,aACvBC,EAXR,SAA0BT,EAAMU,GAC5B,GAAIA,EAAeC,IAAIX,GACnB,OAAOU,EAAevD,IAAI6C,GAE9B,IAAIY,EAAgBhC,MAAMC,QAAQmB,GAAQ,GAAKrH,OAAOY,OAAO,MAE7D,OADAmH,EAAexC,IAAI8B,EAAMY,GAClBA,CACX,CAIeC,CAAiBb,EAAM/F,EAAQyG,gBAC1C,GAAI9B,MAAMC,QAAQmB,GAAO,CACrB,IAAK,IAAIvC,EAAK,EAAGqD,EAAKlC,MAAMmC,KAAKf,EAAKgB,WAAYvD,EAAKqD,EAAGnD,OAAQF,IAAM,CACpE,IAAIwD,EAAKH,EAAGrD,GAAKyD,EAAQD,EAAG,GAAIE,EAAOF,EAAG,GAC1C,GAAa,OAATE,EAAJ,CAIA,IAAIjB,EAASC,EAAiBgB,EAAMlB,EAAchG,EAASqG,GAAkC,IAAvBhF,WAAWC,QAAoB,GAAG6F,OAAOb,GAAQ,GAAI,KAAKa,OAAOF,EAAO,UAAO,GACjJV,EAAaG,IAAIT,IACjBM,EAAaa,IAAIZ,GAErBA,EAAKS,GAAShB,CALd,MAFIO,EAAKS,GAAS,IAQtB,CACA,OAAOV,EAAaG,IAAIF,GAAQA,EAAOT,CAC3C,CACA,IAAK,IAAIsB,EAAK,EAAGC,EAAKtB,EAAauB,WAAYF,EAAKC,EAAG5D,OAAQ2D,IAAM,CACjE,IAAIG,EAAYF,EAAGD,GACfxI,OAAQ,EAIZ,GAHIwH,GACAE,EAAaa,IAAIZ,GAEjBgB,EAAUrE,OAAS6B,EAAQyC,KAAKC,MAAO,CACvC,IAAIC,EAAU3I,EAAU4I,uBAAuBJ,GAC3CK,EAAoBL,EAAUxB,aAElC,QAAc,KADdnH,EAAQ2H,EAAKmB,IAAY5B,EAAK4B,IAE1B,SAEJ,GAAIE,GAA+B,OAAVhJ,EAAgB,CACjCoH,EAASC,EAAiBH,EAAK4B,GAAUE,EAAmB7H,EAASqG,GAAkC,IAAvBhF,WAAWC,QAAoB,GAAG6F,OAAOb,GAAQ,GAAI,KAAKa,OAAOQ,QAAW,GAC5JpB,EAAaG,IAAIT,KACjBpH,EAAQoH,EAEhB,EAC6B,IAAvB5E,WAAWC,UACbkF,EAAKmB,GAAW9I,IAEO,IAAvBwC,WAAWC,UACP+E,GACY,eAAZsB,KAC4D,QAAzD7G,EAAKpC,OAAOoJ,yBAAyBtB,EAAMmB,UAA6B,IAAP7G,OAAgB,EAASA,EAAGjC,OAChGH,OAAOC,eAAe6H,EAAMmB,EAASI,EAA6BJ,EAAS9I,EAAOyH,GAAQ,GAAItG,EAAQuC,cAAevC,EAAQgI,wBAGtHxB,EAAKmB,GACZnB,EAAKmB,GAAW9I,GAG5B,CAMA,GALI2I,EAAUrE,OAAS6B,EAAQyC,KAAKQ,iBAC9BT,EAAUU,gBACRlI,EAAQ2B,MAAMwG,gBAAgBX,EAAWzB,EAAKqC,cAClDvJ,EAAQqH,EAAiBH,EAAMyB,EAAUxB,aAAchG,EAASqG,EAAWC,IAE3EkB,EAAUrE,OAAS6B,EAAQyC,KAAKY,gBAAiB,CACjD,IAAIC,EAAed,EAAUtF,KAAKrD,MAC9B0J,EAAWvI,EAAQwI,YAAYF,KAC9BtI,EAAQwI,YAAYF,GACjBtI,EAAQ2B,MAAM8G,eAAeH,IACrCxJ,EAAQiB,UAAUwI,EAAU,GAAID,GAChC,IAAII,EAAO1J,EAAU2J,oBAAoBnB,GAC5B,SAATkB,IACA7J,EAAQqH,EAAiBH,EAAMwC,EAASvC,aAAchG,EAAkB,YAAT0I,EAAoBpC,GAE3F,CACIC,EAAaG,IAAI7H,IACjB0H,EAAaa,IAAIZ,EAEzB,CAOA,MANI,eAAgBT,KAAU,eAAgBS,KAC1CA,EAAK4B,WAAarC,EAAKqC,YAEvB1J,OAAOkK,KAAKpC,GAAM9C,SAAWhF,OAAOkK,KAAK7C,GAAMrC,QAC/C6C,EAAaa,IAAIZ,GAEdD,EAAaG,IAAIF,GAAQA,EAAOT,CAC3C,CACA,SAASgC,EAA6Bc,EAAWhK,EAAOyH,EAAM/D,EAAeyF,GACzE,IAAI5F,EAAW,WACX,OAAIuD,EAAoBvD,cAGD,IAAvBf,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAAIgB,EACvD,GAAG4E,OAAOa,EAAe,MAAMb,OAAO5E,EAAe,KACnD,aAAa4E,OAAOa,GAAgB,GAAGb,OAAOb,EAAM,KAAKa,OAAO0B,GAAWC,QAAQ,MAAO,KAChG1G,EAAW,WAAc,OAAOvD,CAAO,GAL5BA,CAOf,EACA,MAAO,CACHqE,IAAK,WACD,OAAOd,GACX,EACA6B,IAAK,SAAU8E,GACX3G,EAAW,WAAc,OAAO2G,CAAU,CAC9C,EACA7I,YAAY,EACZE,cAAc,EAEtB,CAyDAxB,EAAQ+G,oBAAsBA,EAC9B/G,EAAQoK,aAxDR,SAAsBjD,EAAMlD,EAAUlB,EAAO2G,GACzC,IAAK3G,EAAMwG,gBAIP,OAH2B,IAAvB9G,WAAWC,SACXuE,IAEGE,EAEX,IAAI3C,EAAYP,EAASY,YAAYwF,OAAO,SAAUC,GAClD,OAAOA,EAAK/F,OAAS6B,EAAQyC,KAAK0B,mBACtC,GAC4B,qBAAjBb,IACPxJ,EAAQiB,UAA+B,IAArBqD,EAAUM,OAAc,GAAIN,EAAUM,QACxD4E,EAAelF,EAAU,GAAGlB,KAAKrD,OAErC,IAAI0J,EAAWnF,EAAUgG,KAAK,SAAUb,GAAY,OAAOA,EAASrG,KAAKrD,QAAUyJ,CAAc,GAEjG,OADAxJ,EAAQiB,YAAYwI,EAAU,GAAID,GACtB,MAARvC,GAGAb,EAAea,EAAM,CAAC,GAFfA,EAKJD,EAAeC,EAAMwC,EAASvC,aAAc,CAC/CgC,cAAe,WACfzF,cAAegG,EAASrG,KAAKrD,MAC7B2J,YAAaxJ,EAAUqK,kBAAkBrK,EAAUsK,uBAAuBzG,IAC1ElB,MAAOA,EACP8E,eAAgB,IAAItB,EACpBoB,aAAc,IAAIhB,GAE1B,EA2BA3G,EAAQ2K,cAzBR,SAAuBxD,EAAMlD,EAAUlB,GACnC,IAAIb,EACJ,IAAKa,EAAMwG,gBAIP,OAH2B,IAAvB9G,WAAWC,SACXuE,IAEGE,EAEX,IAAIjC,EAAa9E,EAAUwK,uBAAuB3G,GAElD,OADA/D,EAAQiB,UAAU+D,EAAY,IAClB,MAARiC,EACOA,EAEJD,EAAeC,EAAMjC,EAAWkC,aAAc,CACjDgC,cAAelE,EAAWF,UAC1BrB,cAA0C,QAA1BzB,EAAKgD,EAAW5B,YAAyB,IAAPpB,OAAgB,EAASA,EAAGjC,MAC9E2J,YAAaxJ,EAAUqK,kBAAkBrK,EAAUsK,uBAAuBzG,IAC1ElB,MAAOA,EACP8E,eAAgB,IAAItB,EACpBoB,aAAc,IAAIhB,GAE1B,C,yCCrMA7G,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBG,EAAQ,EAAQ,wBAChBD,EAAY,EAAQ,wBACpByK,EAAQ,EAAQ,wBAChBC,EAAS,EAAQ,wBACjBC,EAAO,EAAQ,wBAgBnB,SAASC,EAAmBC,GACxB,IAAIC,EAAU,KACVC,EAAQ,KACRC,GAAO,EACPjE,EAAO,GACPkE,EAAU,GACd,SAASC,EAAOC,GACZ,IAAIJ,EAAJ,CAEA,GAAIE,EAAQvG,OAAQ,CAChB,IAAI0G,EAAaH,EAAQI,QACzB,GAAI1F,MAAMC,QAAQwF,IAAeA,EAAW,GACxC,OAAOA,EAAW,GAAG,CAAEvL,MAAOsL,EAAOH,MAAM,GAEnD,CACAjE,EAAKlC,KAAKsG,EAPA,CAQd,CACA,SAASG,EAAQC,GACbR,EAAQQ,EACEN,EAAQO,QACdC,QAAQ,SAAUC,GAClBA,EAAK,GAAGH,EACZ,IACCT,GAAWA,GAChB,CACA,SAASa,IACLX,GAAO,EACGC,EAAQO,QACdC,QAAQ,SAAUC,GAClBA,EAAK,GAAG,CAAE7L,WAAOsF,EAAW6F,MAAM,GACtC,IACCF,GAAWA,GAChB,CACAA,EAAU,WACNA,EAAU,KACVD,EAAOe,eAAe,OAAQV,GAC9BL,EAAOe,eAAe,QAASN,GAC/BT,EAAOe,eAAe,MAAOD,GAC7Bd,EAAOe,eAAe,SAAUD,GAChCd,EAAOe,eAAe,QAASD,EACnC,EACAd,EAAOgB,GAAG,OAAQX,GAClBL,EAAOgB,GAAG,QAASP,GACnBT,EAAOgB,GAAG,MAAOF,GACjBd,EAAOgB,GAAG,SAAUF,GACpBd,EAAOgB,GAAG,QAASF,GAYnB,IAAIG,EAAW,CACXC,KAAM,WACF,OAZG,IAAIC,QAAQ,SAAUC,EAASC,GAClC,OAAInB,EACOmB,EAAOnB,GACdhE,EAAKrC,OACEuH,EAAQ,CAAEpM,MAAOkH,EAAKsE,QAASL,MAAM,IAC5CA,EACOiB,EAAQ,CAAEpM,WAAOsF,EAAW6F,MAAM,SAC7CC,EAAQpG,KAAK,CAACoH,EAASC,GAC3B,EAKA,GAOJ,OALIlM,EAAUmM,4BACVL,EAASlL,OAAOwL,eAAiB,WAC7B,OAAOC,IACX,GAEGP,CACX,CA6BA,SAASQ,EAAeC,GACpB,IAAIT,EAAW,CACXC,KAAM,WACF,OAAOQ,EAAOC,MAClB,GAOJ,OALIxM,EAAUmM,4BACVL,EAASlL,OAAOwL,eAAiB,WAC7B,OAAOC,IACX,GAEGP,CACX,CAqBA,SAASW,EAAiBC,GACtB,IAhJI5K,EACAgK,EA+IAa,EAAOD,EAGX,GAFmBA,EApBJC,OAqBXA,EAAOD,EAASC,MAhBxB,SAAiC9M,GAC7B,SAAUG,EAAUmM,4BAChBtM,EAAMe,OAAOwL,eACrB,CAcQQ,CAAwBD,GACxB,OAnJAb,EAmJqBa,EAnJH/L,OAAOwL,kBACtBtK,EAAK,CACJiK,KAAM,WACF,OAAOD,EAASC,MACpB,IAEDnL,OAAOwL,eAAiB,WACvB,OAAOC,IACX,EACAvK,EA2IJ,GAtBJ,SAA0BjC,GACtB,QAASA,EAAMgN,SACnB,CAoBQC,CAAiBH,GACjB,OAAOL,EAAeK,EAAKE,aAC/B,GAjBJ,SAA0BhN,GACtB,QAASA,EAAMgL,MACnB,CAeQkC,CAAiBJ,GACjB,OAAOL,EAAeK,EAAK9B,SAASgC,aAExC,GAjBJ,SAAgBhN,GACZ,QAASA,EAAMmN,WACnB,CAeQC,CAAON,GACP,OAxER,SAAyBO,GACrB,IAAIC,GAAW,EACXrB,EAAW,CACXC,KAAM,WACF,OAAIoB,EACOnB,QAAQC,QAAQ,CACnBpM,WAAOsF,EACP6F,MAAM,KAEdmC,GAAW,EACJ,IAAInB,QAAQ,SAAUC,EAASC,GAClCgB,EACKE,KAAK,SAAUvN,GAChBoM,EAAQ,CAAEpM,MAAOA,EAAOmL,MAAM,GAClC,GACKqC,MAAMnB,EACf,GACJ,GAOJ,OALIlM,EAAUmM,4BACVL,EAASlL,OAAOwL,eAAiB,WAC7B,OAAOC,IACX,GAEGP,CACX,CA+CewB,CAAgBX,EAAKK,eAChC,GAhBJ,SAA8BnN,GAC1B,QAASA,EAAM0N,IACnB,CAcQC,CAAqBb,GACrB,OAAO/B,EAAmB+B,GAC9B,MAAM,IAAIc,MAAM,6EACpB,CAMA,SAASC,EAAsB7N,GAC3B,OAJe,QADM8N,EAKE9N,IAJe,kBAAR8N,GAIG,YAAa9N,EALlD,IAAyB8N,CAMzB,CAEA,IAAIC,EAAiBlO,OAAOmO,UAAUD,eAsFtC,SAASE,EAAaC,GAClB,IAAIC,EAAc,CAAC,EASnB,OARAD,EAAWE,MAAM,MAAMxC,QAAQ,SAAUyC,GACrC,IAAIC,EAAID,EAAKE,QAAQ,KACrB,GAAID,GAAK,EAAG,CACR,IAAIE,EAASH,EAAK1C,MAAM,EAAG2C,GAAGG,OAAOC,cACjC1O,EAAQqO,EAAK1C,MAAM2C,EAAI,GAAGG,OAC9BN,EAAYK,GAAUxO,CAC1B,CACJ,GACOmO,CACX,CACA,SAASQ,EAAc9B,EAAU+B,GAC7B,GAAI/B,EAASgC,QAAU,IAAK,CASxBjE,EAAMkE,iBAAiBjC,EARP,WACZ,IACI,OAAOkC,KAAKC,MAAMJ,EACtB,CACA,MAAOlD,GACH,OAAOkD,CACX,CACJ,CACiCK,GAAa,iDAAiD3G,OAAOuE,EAASgC,QACnH,CACA,IACI,OAAOE,KAAKC,MAAMJ,EACtB,CACA,MAAOlD,GACH,IAAIwD,EAAaxD,EAKjB,MAJAwD,EAAW7L,KAAO,mBAClB6L,EAAWrC,SAAWA,EACtBqC,EAAWC,WAAatC,EAASgC,OACjCK,EAAWN,SAAWA,EAChBM,CACV,CACJ,CAOA,SAASE,EAA0BC,GAC/B,OAAO,SAAUxC,GACb,OAAOA,EACFyC,OACA/B,KAAK,SAAUqB,GAAY,OAAOD,EAAc9B,EAAU+B,EAAW,GACrErB,KAAK,SAAUgC,GAQhB,OAPKzJ,MAAMC,QAAQwJ,IACdxB,EAAeyB,KAAKD,EAAQ,SAC5BxB,EAAeyB,KAAKD,EAAQ,WAC7B3E,EAAMkE,iBAAiBjC,EAAU0C,EAAQ,0CAA0CjH,OAAOxC,MAAMC,QAAQsJ,GACpGA,EAAWI,IAAI,SAAUC,GAAM,OAAOA,EAAGhM,aAAe,GACtD2L,EAAW3L,cAAe,OAE7B6L,CACX,EACJ,CACJ,CAEA,IAAII,EAA0B,SAAUC,EAAGC,GACvC,IAAIC,EACJ,IACIA,EAAaf,KAAKgB,UAAUH,EAChC,CACA,MAAOtP,GACH,IAAI4O,EAAajP,EAAQ+P,kBAAkB,GAAIH,EAAOvP,EAAE2P,SAExD,MADAf,EAAWA,WAAa5O,EAClB4O,CACV,CACA,OAAOY,CACX,EAcII,EAAqB,CACrBC,KAbqB,CACrBC,cAAc,EACdC,mBAAmB,EACnBC,oBAAoB,GAWpBC,QATiB,CACjBC,OAAQ,MACR,eAAgB,oBAQhBC,QANiB,CACjBC,OAAQ,SAORC,EAAiB,SAAUC,EAAKC,GAAW,OAAOA,EAAQD,EAAM,EAUpE,SAASE,EAAiC/L,EAAW8L,GAEjD,IADA,IAAIE,EAAU,GACLpM,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCoM,EAAQpM,EAAK,GAAKe,UAAUf,GAEhC,IAAI8L,EAAU,CAAC,EACXN,EAAO,CAAC,EACZY,EAAQnF,QAAQ,SAAUoF,GACtBP,EAAUrQ,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAUO,EAAOP,SAAU,CAAEF,QAASnQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,EAAQF,SAAUS,EAAOT,WACxJS,EAAOC,cACPR,EAAQQ,YAAcD,EAAOC,aAEjCd,EAAO/P,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG8N,GAAOa,EAAOb,KAC3D,GACIM,EAAQF,UACRE,EAAQF,QAahB,SAAgCA,EAASD,GACrC,IAAKA,EAAoB,CACrB,IAAIY,EAAsB,CAAC,EAI3B,OAHArR,OAAOkK,KAAKlK,OAAO0Q,IAAU3E,QAAQ,SAAUvI,GAC3C6N,EAAoB7N,EAAKqL,eAAiB6B,EAAQlN,EACtD,GACO6N,CACX,CACA,IAAIC,EAAa,CAAC,EAClBtR,OAAOkK,KAAKlK,OAAO0Q,IAAU3E,QAAQ,SAAUvI,GAC3C8N,EAAW9N,EAAKqL,eAAiB,CAC7B0C,aAAc/N,EACdrD,MAAOuQ,EAAQlN,GAEvB,GACA,IAAIgO,EAAoB,CAAC,EAIzB,OAHAxR,OAAOkK,KAAKoH,GAAYvF,QAAQ,SAAUvI,GACtCgO,EAAkBF,EAAW9N,GAAM+N,cAAgBD,EAAW9N,GAAMrD,KACxE,GACOqR,CACX,CAjC0BC,CAAuBb,EAAQF,QAASJ,EAAKG,qBAEnE,IAAI5M,EAAgBqB,EAAUrB,cAAe6N,EAAaxM,EAAUwM,WAAYpN,EAAYY,EAAUZ,UAAWqN,EAAQzM,EAAUyM,MAC/H1E,EAAO,CAAEpJ,cAAeA,EAAeS,UAAWA,GAKtD,OAJIgM,EAAKE,oBACLvD,EAAKyE,WAAaA,GAClBpB,EAAKC,eACLtD,EAAK0E,MAAQX,EAAQW,EAAOrR,EAAUsR,QACnC,CACHhB,QAASA,EACT3D,KAAMA,EAEd,CAuBA,IAAI4E,EAAe,SAAUC,GACzB,IAAKA,GAA4B,qBAAVC,MACnB,MAAM3R,EAAQ+P,kBAAkB,GAExC,EAUI6B,EAAY,SAAU9M,EAAW+M,GACjC,IACIC,EADUhN,EAAUiN,aACCC,IACzB,OAAIF,IAG4B,oBAAhBD,EACLA,EAAY/M,GAGZ+M,GAAe,WAE9B,EAEA,SAASI,EAAiBC,EAAWrF,GACjC,IAAIsF,EAAc,GACdC,EAAgB,SAAUC,EAAKtS,GAC/BoS,EAAYpN,KAAK,GAAGsD,OAAOgK,EAAK,KAAKhK,OAAOiK,mBAAmBvS,IACnE,EAOA,GANI,UAAW8M,GACXuF,EAAc,QAASvF,EAAK0E,OAE5B1E,EAAKpJ,eACL2O,EAAc,gBAAiBvF,EAAKpJ,eAEpCoJ,EAAK3I,UAAW,CAChB,IAAIqO,OAAsB,EAC1B,IACIA,EAAsB7C,EAAwB7C,EAAK3I,UAAW,gBAClE,CACA,MAAO+K,GACH,MAAO,CAAEA,WAAYA,EACzB,CACAmD,EAAc,YAAaG,EAC/B,CACA,GAAI1F,EAAKyE,WAAY,CACjB,IAAIkB,OAAuB,EAC3B,IACIA,EAAuB9C,EAAwB7C,EAAKyE,WAAY,iBACpE,CACA,MAAOrC,GACH,MAAO,CAAEA,WAAYA,EACzB,CACAmD,EAAc,aAAcI,EAChC,CACA,IAAI/I,EAAW,GAAIgJ,EAAcP,EAC7BQ,EAAgBR,EAAU5D,QAAQ,MACf,IAAnBoE,IACAjJ,EAAWyI,EAAUS,OAAOD,GAC5BD,EAAcP,EAAUS,OAAO,EAAGD,IAEtC,IAAIE,GAAkD,IAA9BH,EAAYnE,QAAQ,KAAc,IAAM,IAEhE,MAAO,CAAEuE,OADIJ,EAAcG,EAAoBT,EAAYW,KAAK,KAAOrJ,EAE3E,CAEA,IAAIsJ,EAAc7S,EAAU8S,MAAM,WAAc,OAAOrB,KAAO,GAC1DsB,EAAiB,SAAUC,QACP,IAAhBA,IAA0BA,EAAc,CAAC,GAC7C,IAAIlR,EAAKkR,EAAYlB,IAAKA,OAAa,IAAPhQ,EAAgB,WAAaA,EAC7DmR,EAAiBD,EAAYvB,MAAO5J,EAAKmL,EAAY1B,MAAOA,OAAe,IAAPzJ,EAAgB2I,EAAiB3I,EAAIqI,EAAoB8C,EAAY9C,kBAAmBC,EAAqB6C,EAAY7C,mBAAoB+C,EAAmBF,EAAYE,iBAAkBlL,EAAKgL,EAAYG,uBAAwBA,OAAgC,IAAPnL,GAAwBA,EAAIoL,EAAiBnT,EAAMoT,OAAOL,EAAa,CAAC,MAAO,QAAS,QAAS,oBAAqB,qBAAsB,mBAAoB,4BACzc,IAAvB3Q,WAAWC,SACXiP,EAAa0B,GAAkBJ,GAEnC,IAAIS,EAAa,CACbtD,KAAM,CAAEE,kBAAmBA,EAAmBC,mBAAoBA,GAClEG,QAAS8C,EAAeG,aACxBzC,YAAasC,EAAetC,YAC5BV,QAASgD,EAAehD,SAE5B,OAAO,IAAIzF,EAAK6I,WAAW,SAAU5O,GACjC,IAAIoN,EAAYN,EAAU9M,EAAWkN,GACjC9Q,EAAU4D,EAAUiN,aACpB4B,EAAyB,CAAC,EAC9B,GAAIzS,EAAQ0S,gBAAiB,CACzB,IAAI5R,EAAKd,EAAQ0S,gBAAiBrF,EAASvM,EAAGoB,KAAMyQ,EAAU7R,EAAG6R,QAC7DtF,IACAoF,EAAuB,6BAA+BpF,GAEtDsF,IACAF,EAAuB,gCAAkCE,EAEjE,CACA,IAAIC,EAAiB3T,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGuR,GAAyBzS,EAAQoP,SACpFyD,EAAgB,CAChB7D,KAAMhP,EAAQgP,KACdM,QAAStP,EAAQuS,aACjBzC,YAAa9P,EAAQ8P,YACrBV,QAASwD,GAEb,GAAI5T,EAAU8T,cAAc,CAAC,UAAWlP,EAAUyM,OAAQ,EAC3B,IAAvBhP,WAAWC,UACY,IAAvBD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAE3D,IAAIwR,EAAmB/T,EAAUgU,6BAA6BpP,EAAUyM,OACxE,IAAK0C,EACD,OAAOtJ,EAAMwJ,UAAU,IAAIxG,MAAM,0MAErC7I,EAAUyM,MAAQ0C,CACtB,CACA,IAIIG,EAJArM,EAAK8I,EAAiC/L,EAAW0M,EAAOvB,EAAoBuD,EAAYO,GAAgBvD,EAAUzI,EAAGyI,QAAS3D,EAAO9E,EAAG8E,KACxIA,EAAK3I,YAAcmP,IACnBxG,EAAK3I,UAAYyG,EAAM0J,yBAAyBxH,EAAK3I,UAAWY,EAAUyM,QAGzEf,EAAQ8D,QAAqC,qBAApBC,kBAC1BH,EAAa,IAAIG,gBACjB/D,EAAQ8D,OAASF,EAAWE,QAEhC,IAGyCE,EAGrCC,EAFkB,yBADmBD,EAGKtU,EAAUwU,kBAAkB5P,EAAUyM,QAFvElN,MAAkD,iBAAhBmQ,EAAE1P,UAG7C6P,EAAWzU,EAAU8T,cAAc,CAAC,SAAUlP,EAAUyM,OAK5D,GAJI6B,IACCtO,EAAUyM,MAAM5M,YAAYiQ,KATN,SAAUJ,GACjC,MAAkB,wBAAXA,EAAEnQ,MAAkD,aAAhBmQ,EAAE1P,SACjD,KAQI0L,EAAQC,OAAS,OAEjBkE,GAAYF,EAAgB,CAC5BjE,EAAQF,QAAUE,EAAQF,SAAW,CAAC,EACtC,IAAIuE,EAAe,mBACfJ,GAAkBE,IACK,IAAvBpS,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAEvDgS,EACAI,GACI,yDAECF,IACLE,GAAgB,uCAEpBrE,EAAQF,QAAQC,OAASsE,CAC7B,CACA,GAAuB,QAAnBrE,EAAQC,OAAkB,CAC1B,IAAIvI,EAAK+J,EAAiBC,EAAWrF,GAAOgG,EAAS3K,EAAG2K,OAAQ5D,EAAa/G,EAAG+G,WAChF,GAAIA,EACA,OAAOtE,EAAMwJ,UAAUlF,GAE3BiD,EAAYW,CAChB,MAEI,IACIrC,EAAQ3D,KAAO6C,EAAwB7C,EAAM,UACjD,CACA,MAAOoC,GACH,OAAOtE,EAAMwJ,UAAUlF,EAC3B,CAEJ,OAAO,IAAI/O,EAAU4U,WAAW,SAAUC,GACtC,IAAIC,EAAe7B,GAAkBjT,EAAU8S,MAAM,WAAc,OAAOrB,KAAO,IAAMoB,EACnFkC,EAAeF,EAAS9I,KAAKiJ,KAAKH,GAqBtC,OApBAC,EAAa9C,EAAW1B,GACnBlD,KAAK,SAAUV,GAChB,IAAI5K,EACJ8C,EAAUqQ,WAAW,CAAEvI,SAAUA,IACjC,IAAIwI,EAAoC,QAA3BpT,EAAK4K,EAAS0D,eAA4B,IAAPtO,OAAgB,EAASA,EAAGoC,IAAI,gBAChF,OAAc,OAAVgR,GAAkB,qBAAqBC,KAAKD,GAxZhE,SAA2BxI,EAAU0I,GACjC,OAAOnV,EAAMoV,UAAUhJ,UAAM,OAAQ,EAAQ,WACzC,IAAIiJ,EAASC,EAAaC,EAAWC,EAAaC,EAAUC,EAAQ7J,EAAU8J,EAAS9T,EAAIjC,EAAOmL,EAAMG,EAAO0K,EAAYC,EAAIhG,EAAS3B,EAAGiC,EAAS2F,EAAepJ,EAAMyC,EAAQrD,EAC7KlE,EAAIG,EACJK,EACJ,OAAOpI,EAAM+V,YAAY3J,KAAM,SAAU/D,GACrC,OAAQA,EAAGoH,OACP,KAAK,EACD,QAAoBvK,IAAhB8Q,YACA,MAAM,IAAIxI,MAAM,6EAEpB6H,EAAU,IAAIW,YAAY,SAC1BV,EAA0C,QAA3BlN,EAAKqE,EAAS0D,eAA4B,IAAP/H,OAAgB,EAASA,EAAGnE,IAAI,gBAClFsR,EAAY,YACZC,GAA+B,OAAhBF,QAAwC,IAAhBA,OAAyB,EAASA,EAAYlS,SAASmS,IAC1E,OAAhBD,QAAwC,IAAhBA,OAAyB,EAASA,EAAYW,WAA2B,OAAhBX,QAAwC,IAAhBA,OAAyB,EAASA,EAAYnH,QAAQoH,IAAcA,GAAkB1L,QAAQ,QAAS,IAAIA,QAAQ,WAAY,IAAIwE,OAC1O,IACNoH,EAAW,SAASvN,OAAOsN,GAC3BE,EAAS,GACT7J,EAAWW,EAAiBC,GAC5BkJ,GAAU,EACVtN,EAAGoH,MAAQ,EACf,KAAK,EACD,OAAKkG,EACE,CAAC,EAAI9J,EAASC,QADA,CAAC,EAAI,GAE9B,KAAK,EAOD,IANAjK,EAAKwG,EAAG6N,OAAQtW,EAAQiC,EAAGjC,MAAOmL,EAAOlJ,EAAGkJ,KAC5CG,EAAyB,kBAAVtL,EAAqBA,EAAQyV,EAAQc,OAAOvW,GAC3DgW,EAAaF,EAAOjR,OAASgR,EAAShR,OAAS,EAC/CkR,GAAW5K,EAEX8K,GADAH,GAAUxK,GACEiD,QAAQsH,EAAUG,GACvBC,GAAM,GAAG,CASZ,GARAhG,OAAU,EACVjI,EAAK,CACD8N,EAAOnK,MAAM,EAAGsK,GAChBH,EAAOnK,MAAMsK,EAAKJ,EAAShR,SACXiR,EAAS9N,EAAG,GAChCsG,GADG2B,EAAUjI,EAAG,IACJuG,QAAQ,YACpBgC,EAAUtC,EAAagC,EAAQtE,MAAM,EAAG2C,KACxC4H,EAAgB3F,EAAQ,mBAEyC,IAA7D2F,EAAcxH,cAAcH,QAAQ,oBACpC,MAAM,IAAIX,MAAM,iEAGpB,GADAd,EAAOmD,EAAQtE,MAAM2C,GAGjB,GADAiB,EAASZ,EAAc9B,EAAUC,GAC7BjN,OAAOkK,KAAKwF,GAAQ1K,OAAS,GAC7B,SAAU0K,GACV,gBAAiBA,GACjB,WAAYA,GACZ,YAAaA,EACb,GAAI1B,EAAsB0B,GAAS,CAE/B,GADArD,EAAO,CAAC,EACJ,YAAaqD,EAAQ,CACrB,GAAmC,IAA/B1P,OAAOkK,KAAKwF,GAAQ1K,QAAmC,OAAnB0K,EAAOpK,QAC3C,MAAO,CAAC,GAEZ+G,EAAO9L,EAAMiC,SAAS,CAAC,EAAGkN,EAAOpK,QACrC,CACI,WAAYoK,IACZrD,EAAO9L,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG6J,GAAO,CAAEqF,WAAYnR,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAI,eAAgB6J,EAAOA,EAAKqF,WAAa,OAASpJ,EAAK,CAAC,EAAGA,EAAG0C,EAAO2L,wBAA0BjH,EAAO1E,OAAQ1C,OAEnNoN,EAAUrJ,EACd,MAEIqJ,EAAUhG,QAGb,GAC0B,IAA/B1P,OAAOkK,KAAKwF,GAAQ1K,QAChB,YAAa0K,IACZA,EAAOkH,QACR,MAAO,CAAC,GAGhBR,EAAKH,EAAOvH,QAAQsH,EACxB,CACA,MAAO,CAAC,EAAI,GAChB,KAAK,EAAG,MAAO,CAAC,GAExB,EACJ,EACJ,CAqU2Ba,CAAkB7J,EAAUqI,GAG5B9F,EAA0BrK,EAA1BqK,CAAqCvC,GAAUU,KAAK2H,EAEnE,GACK3H,KAAK,WACN8G,OAAa/O,EACb0P,EAAS2B,UACb,GACKnJ,MAAM,SAAU9B,GACjB2I,OAAa/O,EA3S7B,SAAqBoG,EAAKsJ,GAClBtJ,EAAI6D,QAAU7D,EAAI6D,OAAO1E,QAAUa,EAAI6D,OAAOrI,MAC9C8N,EAAS9I,KAAKR,EAAI6D,QAEtByF,EAAS9J,MAAMQ,EACnB,CAuSgBkL,CAAYlL,EAAKsJ,EACrB,GACO,WACCX,GACAA,EAAWwC,OACnB,CACJ,EACJ,EACJ,EAEIC,EAAa,SAAUC,GAEvB,SAASD,EAASrG,QACE,IAAZA,IAAsBA,EAAU,CAAC,GACrC,IAAIuG,EAAQD,EAAOvH,KAAKhD,KAAM0G,EAAezC,GAASwG,UAAYzK,KAElE,OADAwK,EAAMvG,QAAUA,EACTuG,CACX,CACA,OAPA5W,EAAM8W,UAAUJ,EAAUC,GAOnBD,CACX,CATgB,CASdhM,EAAK6I,YAEP5T,EAAQ+W,SAAWA,EACnB/W,EAAQ2R,aAAeA,EACvB3R,EAAQmT,eAAiBA,EACzBnT,EAAQoX,wBA5MsB,WAC1B,GAA+B,qBAApB3C,gBACP,MAAO,CAAEH,YAAY,EAAOE,QAAQ,GACxC,IAAIF,EAAa,IAAIG,gBAErB,MAAO,CAAEH,WAAYA,EAAYE,OADpBF,EAAWE,OAE5B,EAuMAxU,EAAQ4Q,eAAiBA,EACzB5Q,EAAQmQ,mBAAqBA,EAC7BnQ,EAAQqP,0BAA4BA,EACpCrP,EAAQmS,iBAAmBA,EAC3BnS,EAAQqX,yBAlRR,SAAkCrS,EAAWsS,GAEzC,IADA,IAAItG,EAAU,GACLpM,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCoM,EAAQpM,EAAK,GAAKe,UAAUf,GAGhC,OADAoM,EAAQuG,QAAQD,GACTvG,EAAiClL,WAAM,EAAQxF,EAAMyF,cAAc,CAACd,EACvE4L,GAAiBI,GAAS,GAClC,EA2QAhR,EAAQ+Q,iCAAmCA,EAC3C/Q,EAAQ8R,UAAYA,EACpB9R,EAAQ4P,wBAA0BA,C,yCCznBlC9P,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBkG,EAAU,EAAQ,wBAClBoR,EAAO,EAAQ,wBACfnX,EAAQ,EAAQ,wBAChBoX,EAAS,EAAQ,wBACjB7U,EAAW,EAAQ,wBACnB8U,EAAkB,EAAQ,wBAC9B,EAAQ,wBAoCR,SAASxD,EAAcyD,EAAOC,EAAMC,GAChC,IAAIC,EAAU,IAAIhR,IAAI6Q,GAClBI,EAAcD,EAAQtS,KAQ1B,OAPAY,EAAQ4R,MAAMJ,EAAM,CAChBK,UAAW,SAAU3N,GACjB,GAAIwN,EAAQI,OAAO5N,EAAKhH,KAAKrD,UAAY4X,IAAQC,EAAQtS,MACrD,OAAOY,EAAQ+R,KAEvB,IAEGN,GAAOC,EAAQtS,KAAOsS,EAAQtS,KAAOuS,CAChD,CAQA,SAASK,EAAuBC,GAC5B,IAAI7I,EAAS,GAgBb,OAfI6I,GAAcA,EAAWvT,QACzBuT,EAAWxM,QAAQ,SAAUyM,GACzB,GANS,UADbrY,EAO8BqY,EAPnBhV,KAAKrD,QACiB,YAAVA,EAMnB,CARZ,IACQA,EASQsY,EAAqBD,EAAU3S,UAC/B6S,EAAgBF,EAAUhV,KAAKrD,MACnCC,EAAQiB,UAAUoX,GAAoD,IAA9BA,EAAmBzT,OAAc,IAAK0T,GAC9E,IAAIC,EAAaF,EAAmB,GACpCrY,EAAQiB,UAAUsX,EAAWnV,MAAkC,OAA1BmV,EAAWnV,KAAKrD,MAAgB,IAAKuY,GAC1E,IAAIE,EAAUD,EAAWxY,MACzBC,EAAQiB,UAAUuX,IACI,aAAjBA,EAAQnU,MAAwC,iBAAjBmU,EAAQnU,MAA0B,IAAKiU,GAC3EhJ,EAAOvK,KAAK,CAAEqT,UAAWA,EAAWG,WAAYA,GATtC,CAUd,GAEGjJ,CACX,CAmCA,IAAImJ,EAA4E,eAA5DzY,EAAQgT,MAAM,WAAc,OAAO0F,UAAUC,OAAS,GACtErS,EAAmC,oBAAZC,WACrBkS,IAAkB,EAAAG,EAAOC,gBAC3BnS,EAAmC,oBAAZC,QACvB9F,EAAiC,oBAAXC,QAA+C,oBAAfA,OAAOC,IAC7DsL,EAA4BxL,GAAgBC,OAAOwL,cACnDwM,EAA4F,oBAAzE9Y,EAAQgT,MAAM,WAAc,OAAO+F,OAAOhV,SAASpC,aAAe,GACrFqX,EACJhZ,EAAQgT,MAAM,WAAc,OAAO0F,UAAUO,UAAU3K,QAAQ,UAAY,CAAG,KAAM,EAChF4K,GAAsBJ,GAAaL,KAAmBO,EAE1D,SAASG,EAAgBtL,GACrB,OAAe,OAARA,GAA+B,kBAARA,CAClC,CACA,SAASuL,EAAcvL,GACnB,OAAgB,OAARA,GACW,kBAARA,IACNjO,OAAOyZ,eAAexL,KAASjO,OAAOmO,WACJ,OAA/BnO,OAAOyZ,eAAexL,GAClC,CAyCA,SAAStD,EAAkBjG,QACL,IAAdA,IAAwBA,EAAY,IACxC,IAAIgV,EAAW,CAAC,EAIhB,OAHAhV,EAAUqH,QAAQ,SAAUlC,GACxB6P,EAAS7P,EAASrG,KAAKrD,OAAS0J,CACpC,GACO6P,CACX,CACA,SAASC,EAAyB7Q,EAAWgB,GACzC,OAAQhB,EAAUrE,MACd,IAAK,iBACD,OAAOqE,EACX,IAAK,iBACD,IAAIc,EAAed,EAAUtF,KAAKrD,MAClC,GAA2B,oBAAhB2J,EACP,OAAOA,EAAYF,GAEvB,IAAIC,EAAWC,GAAeA,EAAYF,GAE1C,OADAxJ,EAAQiB,UAAUwI,EAAU,IAAKD,GAC1BC,GAAY,KAEvB,QACI,OAAO,KAEnB,CAgBA,IAAI+P,EAAmB,IAAI7S,QAC3B,SAAS8S,EAAS5W,GACVA,EAAMyC,OAASzC,EAAM6W,MAAQ,IAG5BF,EAAiB5R,IAAI/E,KACtB2W,EAAiBlR,IAAIzF,GACrB8W,WAAW,WACP9W,EAAM+W,QACNJ,EAAiBxB,OAAOnV,EAC5B,EAAG,KAEX,CACA,IAAImB,EAAuB,SAAU0V,EAAKG,GACtC,IAAIhX,EAAQ,IAAI0U,EAAOuC,UAAUJ,EAAKG,GAMtC,OALAhX,EAAMsC,IAAM,SAAUkN,EAAKtS,GACvB,IAAIga,EAAMxC,EAAOuC,UAAU/L,UAAU5I,IAAIoK,KAAKhD,KAAM8F,EAAKtS,GAEzD,OADA0Z,EAASlN,MACFwN,CACX,EACOlX,CACX,EACImX,EAAyB,SAAUN,EAAKG,GACxC,IAAIhX,EAAQ,IAAI0U,EAAO0C,YAAYP,EAAKG,GAMxC,OALAhX,EAAMsC,IAAM,SAAUkN,EAAKtS,GACvB,IAAIga,EAAMxC,EAAO0C,YAAYlM,UAAU5I,IAAIoK,KAAKhD,KAAM8F,EAAKtS,GAE3D,OADA0Z,EAASlN,MACFwN,CACX,EACOlX,CACX,EAEIqX,EAAkBpZ,OAAOC,IAAI,oBAC7BkD,EAAa9D,EAAMiC,SAAS,CAAC,EAAGpC,EAAQgD,OAAOkX,IAE/CvX,EAAe,CAAC,EACpB,SAASwX,EAAoB/W,EAAMN,GAC/BH,EAAaS,GAAQN,CACzB,CAEA,IAUIsX,EAVAC,EAAqBza,OAAO0a,OAAO,SAA4Bva,GAC/D,OAAO+O,KAAKgB,UAAU/P,EAAOwa,EACjC,EAAG,CACCC,MAAO,WACHJ,EAAa,IAAIJ,EAAuB/V,EAAWoW,oBAAsB,IAC7E,IAOJ,SAASE,EAAqBlI,EAAKtS,GAC/B,GAAIA,GAA0B,kBAAVA,EAAoB,CACpC,IAAI0a,EAAQ7a,OAAOyZ,eAAetZ,GAClC,GAAI0a,IAAU7a,OAAOmO,WAAuB,OAAV0M,EAAgB,CAC9C,IAAI3Q,EAAOlK,OAAOkK,KAAK/J,GACvB,GAAI+J,EAAK4Q,MAAMC,GACX,OAAO5a,EACX,IAAI6a,EAAc9L,KAAKgB,UAAUhG,GAC7B+Q,EAAaT,EAAWhW,IAAIwW,GAChC,IAAKC,EAAY,CACb/Q,EAAKgR,OACL,IAAIC,EAAYjM,KAAKgB,UAAUhG,GAC/B+Q,EAAaT,EAAWhW,IAAI2W,IAAcjR,EAC1CsQ,EAAWjV,IAAIyV,EAAaC,GAC5BT,EAAWjV,IAAI4V,EAAWF,EAC9B,CACA,IAAIG,EAAiBpb,OAAOY,OAAOia,GAInC,OAHAI,EAAWlP,QAAQ,SAAU0G,GACzB2I,EAAe3I,GAAOtS,EAAMsS,EAChC,GACO2I,CACX,CACJ,CACA,OAAOjb,CACX,CACA,SAAS4a,EAAgBtI,EAAKhE,EAAGvE,GAC7B,OAAa,IAANuE,GAAWvE,EAAKuE,EAAI,IAAMgE,CACrC,CAwCA,SAAS4I,EAA4BC,EAAQ9X,EAAMrD,EAAOmE,GACtD,GAtBJ,SAAoBnE,GAChB,MAAsB,aAAfA,EAAMsE,IACjB,CAoBQ8W,CAAWpb,IAnBnB,SAAsBA,GAClB,MAAsB,eAAfA,EAAMsE,IACjB,CAiB6B+W,CAAarb,GAClCmb,EAAO9X,EAAKrD,OAASsb,OAAOtb,EAAMA,YAEjC,GA5BT,SAAwBA,GACpB,MAAsB,iBAAfA,EAAMsE,IACjB,CA0BaiX,CAAevb,IA/B5B,SAAuBA,GACnB,MAAsB,gBAAfA,EAAMsE,IACjB,CA6BsCkX,CAAcxb,GAC5Cmb,EAAO9X,EAAKrD,OAASA,EAAMA,WAE1B,GAnBT,SAAuBA,GACnB,MAAsB,gBAAfA,EAAMsE,IACjB,CAiBamX,CAAczb,GAAQ,CAC3B,IAAI0b,EAAiB,CAAC,EACtB1b,EAAM2b,OAAOlM,IAAI,SAAU3B,GACvB,OAAOoN,EAA4BQ,EAAgB5N,EAAIzK,KAAMyK,EAAI9N,MAAOmE,EAC5E,GACAgX,EAAO9X,EAAKrD,OAAS0b,CACzB,MACK,GA7BT,SAAoB1b,GAChB,MAAsB,aAAfA,EAAMsE,IACjB,CA2BasX,CAAW5b,GAAQ,CACxB,IAAI6b,GAAiB1X,GAAa,CAAC,GAAGnE,EAAMqD,KAAKrD,OACjDmb,EAAO9X,EAAKrD,OAAS6b,CACzB,MACK,GA3BT,SAAqB7b,GACjB,MAAsB,cAAfA,EAAMsE,IACjB,CAyBawX,CAAY9b,GACjBmb,EAAO9X,EAAKrD,OAASA,EAAM+b,OAAOtM,IAAI,SAAUuM,GAC5C,IAAIC,EAAoB,CAAC,EAEzB,OADAf,EAA4Be,EAAmB5Y,EAAM2Y,EAAW7X,GACzD8X,EAAkB5Y,EAAKrD,MAClC,QAEC,GA/BT,SAAqBA,GACjB,MAAsB,cAAfA,EAAMsE,IACjB,CA6Ba4X,CAAYlc,GACjBmb,EAAO9X,EAAKrD,OAASA,EAAMA,UAE1B,KA/BT,SAAqBA,GACjB,MAAsB,cAAfA,EAAMsE,IACjB,CA6Ba6X,CAAYnc,GAIjB,MAAMC,EAAQ+P,kBAAkB,IAAK3M,EAAKrD,MAAOA,EAAMsE,MAHvD6W,EAAO9X,EAAKrD,OAAS,IAIzB,CACJ,EA1G2B,IAAvBwC,WAAWC,SACX2X,EAAoB,qBAAsB,WAAc,OAAOC,EAAW9U,IAAM,GAGpF+U,EAAmBG,QA+HnB,IAAI2B,EAAmB,CACnB,aACA,UACA,OACA,SACA,OACA,SACA,eAEAC,EAAwB/B,EACxBgC,EAAkBzc,OAAO0a,OAAO,SAAUvQ,EAAWvE,EAAM2S,GAC3D,GAAI3S,GACA2S,GACAA,EAAuB,YACvBA,EAAuB,WAAO,IAAG,CACjC,GAAIA,EAAuB,WAAU,QACjCA,EAAuB,WAAU,OAAEvT,OAAS,EAAG,CAC/C,IAAI0X,EAAanE,EAAuB,WAAU,OAC9CA,EAAuB,WAAU,OAC/B,GACNmE,EAAWxB,OACX,IAAIyB,EAAiB,CAAC,EAItB,OAHAD,EAAW3Q,QAAQ,SAAU0G,GACzBkK,EAAelK,GAAO7M,EAAK6M,EAC/B,GACO,GAAGhK,OAAO8P,EAAuB,WAAO,IAAG,KAAK9P,OAAO+T,EAAsBG,GAAiB,IACzG,CAEI,OAAOpE,EAAuB,WAAO,GAE7C,CACA,IAAIqE,EAAoBzS,EACxB,GAAIvE,EAAM,CACN,IAAIiX,EAAkBL,EAAsB5W,GAC5CgX,GAAqB,IAAInU,OAAOoU,EAAiB,IACrD,CAaA,OAZItE,GACAvY,OAAOkK,KAAKqO,GAAYxM,QAAQ,SAAU0G,IACC,IAAnC8J,EAAiB7N,QAAQ+D,KAEzB8F,EAAW9F,IAAQzS,OAAOkK,KAAKqO,EAAW9F,IAAMzN,OAChD4X,GAAqB,IAAInU,OAAOgK,EAAK,KAAKhK,OAAO+T,EAAsBjE,EAAW9F,IAAO,KAGzFmK,GAAqB,IAAInU,OAAOgK,GAExC,GAEGmK,CACX,EAAG,CACCE,aAAc,SAAUC,GACpB,IAAIC,EAAWR,EAEf,OADAA,EAAwBO,EACjBC,CACX,IAaJ,SAAS9T,EAAuB+T,GAC5B,OAAOA,EAAMC,MAAQD,EAAMC,MAAM/c,MAAQ8c,EAAMzZ,KAAKrD,KACxD,CA8BA,SAASgd,EAAQrU,GACb,MAA0B,UAAnBA,EAAUrE,IACrB,CAKA,SAAS2Y,EAAcC,GACnBjd,EAAQiB,UAAUgc,GAAoB,aAAbA,EAAI5Y,KAAqB,KAClD,IAAI+K,EAAa6N,EAAItY,YAChBwF,OAAO,SAAUqK,GAAK,MAAkB,uBAAXA,EAAEnQ,IAA+B,GAC9DmL,IAAI,SAAUxK,GACf,GAAwB,wBAApBA,EAAWX,KACX,MAAMrE,EAAQ+P,kBAAkB,IAAK/K,EAAWX,MAEpD,OAAOW,CACX,GAEA,OADAhF,EAAQiB,UAAUmO,EAAWxK,QAAU,EAAG,IAAKwK,EAAWxK,QACnDqY,CACX,CACA,SAASvS,EAAuBuS,GAE5B,OADAD,EAAcC,GACPA,EAAItY,YAAYwF,OAAO,SAAUnF,GACpC,MAA2B,wBAApBA,EAAWX,IACtB,GAAG,EACP,CAQA,SAASmG,EAAuByS,GAC5B,OAAOA,EAAItY,YAAYwF,OAAO,SAAUnF,GACpC,MAA2B,uBAApBA,EAAWX,IACtB,EACJ,CAMA,SAAS6Y,EAAsBD,GAC3Bjd,EAAQiB,UAAuB,aAAbgc,EAAI5Y,KAAqB,KAC3CrE,EAAQiB,UAAUgc,EAAItY,YAAYC,QAAU,EAAG,KAC/C,IAAIuY,EAAcF,EAAItY,YAAY,GAElC,OADA3E,EAAQiB,UAA+B,uBAArBkc,EAAY9Y,KAA+B,KACtD8Y,CACX,CACA,SAASzI,EAAkB0I,GAEvB,IAAIC,EADJL,EAAcI,GAEd,IAAK,IAAI1Y,EAAK,EAAG1C,EAAKob,EAASzY,YAAaD,EAAK1C,EAAG4C,OAAQF,IAAM,CAC9D,IAAIM,EAAahD,EAAG0C,GACpB,GAAwB,wBAApBM,EAAWX,KAAgC,CAC3C,IAAIS,EAAYE,EAAWF,UAC3B,GAAkB,UAAdA,GACc,aAAdA,GACc,iBAAdA,EACA,OAAOE,CAEf,CACwB,uBAApBA,EAAWX,MAAkCgZ,IAC7CA,EAAqBrY,EAE7B,CACA,GAAIqY,EACA,OAAOA,EAEX,MAAMrd,EAAQ+P,kBAAkB,IACpC,CAcA,SAASuN,EAASvZ,GACd,OAAOA,CACX,CACA,IAmEIwZ,EAnEAC,EAAsB,WACtB,SAASA,EAAkBC,EAAWjN,QAClB,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAClD+L,KAAKmR,YAAchX,EAAgB,IAAIC,QAAY,IAAIC,IACvD2F,KAAKkR,UAAYA,EACbjN,EAAQmN,cACRpR,KAAKoR,YAAcnN,EAAQmN,aAE/BpR,KAAKpI,QAA2B,IAAlBqM,EAAQ3N,MACtB0J,KAAKnH,YACT,CAsDA,OArDAoY,EAAkBzP,UAAU4P,YAAc,SAAU5Z,GAChD,MAAO,CAACA,EACZ,EACAyZ,EAAkBF,SAAW,WACzB,OAAO,IAAIE,EAAkBF,EAAU,CAAEza,OAAO,GACpD,EACA2a,EAAkBrP,MAAQ,SAAUyP,EAAWC,EAAMC,GAEjD,YADc,IAAVA,IAAoBA,EAAQN,EAAkBF,YAC3C1d,OAAO0a,OAAO,IAAIkD,EAAkB,SAAUzZ,GAEjD,OADwB6Z,EAAU7Z,GAAY8Z,EAAOC,GAC5BC,kBAAkBha,EAC/C,EACA,CAAElB,OAAO,IAAU,CAAEgb,KAAMA,EAAMC,MAAOA,GAC5C,EACAN,EAAkBzP,UAAU3I,WAAa,WACrC,IAAI2R,EAAQxK,KACZ,GAAIA,KAAKpI,OAAQ,CACb,IAAI6Z,EAAoB,IAAI1G,EAAK2G,KAAK3X,GACtCiG,KAAK2R,YAAcxb,EAASyb,KAAKX,EAAkBzP,UAAUmQ,YAAYhJ,KAAK3I,MAAO,CACjF6R,aAAc,SAAUra,GACpB,IAAIsa,EAAYtH,EAAM4G,YAAY5Z,GAClC,GAAIsa,EAEA,OADAre,EAAQiB,UAAU4E,MAAMC,QAAQuY,GAAY,KACrCL,EAAkBM,YAAYD,EAE7C,EACA3E,IAAKzV,EAAW,2BAChBpB,MAAQ0U,EAAgB,WAEhC,CACJ,EACAiG,EAAkBzP,UAAUmQ,YAAc,SAAUna,GAEhD,OADAiZ,EAAcjZ,GACPwI,KAAKkR,UAAU1Z,EAC1B,EACAyZ,EAAkBzP,UAAUgQ,kBAAoB,SAAUha,GACtD,GAAIwI,KAAKmR,YAAY9V,IAAI7D,GACrB,OAAOA,EAEX,IAAIwa,EAAsBhS,KAAK2R,YAAYna,GAE3C,OADAwI,KAAKmR,YAAYpV,IAAIiW,GACdA,CACX,EACAf,EAAkBzP,UAAU1F,OAAS,SAAUmW,GAC3C,IAAIzH,EAAQxK,KACZ,OAAO3M,OAAO0a,OAAO,IAAIkD,EAAkB,SAAUzZ,GACjD,OAAOya,EAAeT,kBAAkBhH,EAAMgH,kBAAkBha,GACpE,EACA,CAAElB,OAAO,IAAU,CACfgb,KAAMtR,KACNuR,MAAOU,GAEf,EACOhB,CACX,CAjEyB,GAoErBhM,EAAQ5R,OAAO0a,OAAO,SAAU3J,GAChC,IAAIrB,EAASiO,EAAWnZ,IAAIuM,GAK5B,OAJKrB,IACDA,EAASpJ,EAAQsL,MAAMb,GACvB4M,EAAWpY,IAAIwL,EAAKrB,IAEjBA,CACX,EAAG,CACCkL,MAAO,WACH+C,EAAa,IAAIvZ,EAAqBC,EAAWuN,OAAS,IAC9D,IAEJA,EAAMgJ,SACqB,IAAvBjY,WAAWC,SACX2X,EAAoB,QAAS,WAAc,OAAQoD,EAAaA,EAAWjY,KAAO,CAAI,GAG1F,IAAIQ,EAAUD,MAAMC,QACpB,SAAS2Y,EAAgB1e,GACrB,OAAO8F,MAAMC,QAAQ/F,IAAUA,EAAM6E,OAAS,CAClD,CAEA,IAAI8Z,EAAiB,CACjBra,KAAM6B,EAAQyC,KAAKC,MACnBxF,KAAM,CACFiB,KAAM6B,EAAQyC,KAAKgW,KACnB5e,MAAO,eAGf,SAAS6e,GAAQnP,EAAI/F,GACjB,OAAS+F,GACLA,EAAGvI,aAAauB,WAAWiS,MAAM,SAAUhS,GACvC,OAAOA,EAAUrE,OAAS6B,EAAQyC,KAAKY,iBACnCqV,GAAQlV,EAAYhB,EAAUtF,KAAKrD,OAAQ2J,EACnD,EACR,CACA,SAASmV,GAAiB5B,GACtB,OAAQ2B,GAAQlU,EAAuBuS,IAAQC,EAAsBD,GAAM1S,EAAkBC,EAAuByS,KAChH,KACEA,CACV,CA0BA,SAAS6B,GAAwBC,GAC7B,IAAIvP,EAAM,IAAIhJ,IACd,OAAO,SAA6B6L,QACpB,IAARA,IAAkBA,EAAM0M,GAC5B,IAAIC,EAAQxP,EAAIpL,IAAIiO,GAOpB,OANK2M,GACDxP,EAAIrK,IAAIkN,EAAM2M,EAAQ,CAClB9a,UAAW,IAAI0C,IACfqY,gBAAiB,IAAIrY,MAGtBoY,CACX,CACJ,CACA,SAASE,GAA6B/G,EAAY8E,GAC9CD,EAAcC,GAkBd,IAjBA,IAAIkC,EAA0BL,GAAwB,IAClDM,EAAyBN,GAAwB,IACjDO,EAAW,SAAUC,GACrB,IAAK,IAAI3P,EAAI,EAAG4P,OAAW,EAAQ5P,EAAI2P,EAAU1a,SAAW2a,EAAWD,EAAU3P,MAAOA,EACpF,IAAI7J,EAAQyZ,GAAZ,CAEA,GAAIA,EAASlb,OAAS6B,EAAQyC,KAAK6W,qBAC/B,OAAOL,EAAwBI,EAASnc,MAAQmc,EAASnc,KAAKrD,OAElE,GAAIwf,EAASlb,OAAS6B,EAAQyC,KAAK0B,oBAC/B,OAAO+U,EAAuBG,EAASnc,KAAKrD,MALpC,CAShB,OADuB,IAAvBwC,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAM,KACjD,IACX,EACIwU,EAAiB,EACZpR,EAAI4O,EAAItY,YAAYC,OAAS,EAAGyJ,GAAK,IAAKA,EAC3C4O,EAAItY,YAAY0J,GAAGhK,OAAS6B,EAAQyC,KAAK6W,wBACvCC,EAGV,IA/DyB3O,EACrB2G,EACAiI,EA6DAC,GA/DqB7O,EA+DkBqH,EA9DvCV,EAAQ,IAAIjR,IACZkZ,EAAQ,IAAIlZ,IAChBsK,EAAQnF,QAAQ,SAAUyM,GAClBA,IACIA,EAAUhV,KACVqU,EAAMtS,IAAIiT,EAAUhV,KAAMgV,GAErBA,EAAU/C,MACfqK,EAAMva,IAAIiT,EAAU/C,KAAM+C,GAGtC,GACO,SAAUA,GACb,IAAIrH,EAAS0G,EAAMrT,IAAIgU,EAAUhV,KAAKrD,OAQtC,OAPKgR,GAAU2O,EAAMpa,MACjBoa,EAAM/T,QAAQ,SAAUiU,EAAYvK,GAC5BA,EAAK+C,KACLrH,EAAS6O,EAEjB,GAEG7O,CACX,GAyCI8O,EAAoB,SAAUC,GAC9B,OAAOrB,EAAgBqB,IACnBA,EACKtQ,IAAImQ,GACJ/K,KAAK,SAAU7D,GAAU,OAAOA,GAAUA,EAAOgP,MAAQ,EACtE,EACIC,EAA6B,IAAIxZ,IACjCyZ,GAAwB,EACxBC,EAA+B,CAC/BC,MAAO,SAAU/V,GACb,GAAIyV,EAAkBzV,EAAK+N,YAEvB,OADA8H,GAAwB,EACjB,IAEf,GAEAG,EAA8Bla,EAAQ4R,MAAMmF,EAAK,CACjDoD,MAAOH,EACPI,eAAgBJ,EAChBK,mBAAoB,CAChBJ,MAAO,WACH,OAAO,CACX,GAEJK,SAAU,CACNL,MAAO,SAAU/V,EAAMqW,EAAMC,EAASC,EAAOrB,GACzC,IAAIN,EAAQK,EAASC,GACjBN,GACAA,EAAM9a,UAAUoE,IAAI8B,EAAKhH,KAAKrD,MAEtC,GAEJ6gB,eAAgB,CACZT,MAAO,SAAU/V,EAAMqW,EAAMC,EAASC,EAAOrB,GACzC,GAAIO,EAAkBzV,EAAK+N,YAEvB,OADA8H,GAAwB,EACjB,KAEX,IAAIjB,EAAQK,EAASC,GACjBN,GACAA,EAAMC,gBAAgB3W,IAAI8B,EAAKhH,KAAKrD,MAE5C,GAEJ8gB,mBAAoB,CAChBV,MAAO,SAAU/V,EAAMqW,EAAMC,EAASlZ,GAClCwY,EAA2B7a,IAAI2J,KAAKgB,UAAUtI,GAAO4C,EACzD,EACA0W,MAAO,SAAU1W,EAAMqW,EAAMC,EAASlZ,GAElC,OAAI4C,IADe4V,EAA2B5b,IAAI0K,KAAKgB,UAAUtI,IAEtD4C,EAGXqV,EAAiB,GACbrV,EAAKlD,aAAauB,WAAWiS,MAAM,SAAUhS,GACzC,OAAOA,EAAUrE,OAAS6B,EAAQyC,KAAKC,OACV,eAAzBF,EAAUtF,KAAKrD,KACvB,IACAqf,EAAuBhV,EAAKhH,KAAKrD,OAAOghB,SAAU,EAClDd,GAAwB,EACjB,WARX,CAUJ,GAEJlI,UAAW,CACP+I,MAAO,SAAU1W,GACb,GAAIuV,EAAiBvV,GAEjB,OADA6V,GAAwB,EACjB,IAEf,KAGR,IAAKA,EACD,OAAOhD,EAEX,IAAI+D,EAAyB,SAAUhC,GAWnC,OAVKA,EAAMiC,iBACPjC,EAAMiC,eAAiB,IAAIra,IAAIoY,EAAM9a,WAChC8a,EAAM+B,SACP/B,EAAMC,gBAAgBtT,QAAQ,SAAUuV,GACpCF,EAAuB5B,EAAuB8B,IAAoBD,eAAetV,QAAQ,SAAUwV,GAC/FnC,EAAMiC,eAAe3Y,IAAI6Y,EAC7B,EACJ,IAGDnC,CACX,EACIoC,EAAuB,IAAIxa,IAC/BwZ,EAA4Bzb,YAAYgH,QAAQ,SAAU0V,GAClDA,EAAIhd,OAAS6B,EAAQyC,KAAK6W,qBAC1BwB,EAAuB7B,EAAwBkC,EAAIje,MAAQie,EAAIje,KAAKrD,QAAQkf,gBAAgBtT,QAAQ,SAAUuV,GAC1GE,EAAqB9Y,IAAI4Y,EAC7B,GAEKG,EAAIhd,OAAS6B,EAAQyC,KAAK0B,qBACZ,IAAnBoV,GACCL,EAAuBiC,EAAIje,KAAKrD,OAAOghB,SACxCK,EAAqB9Y,IAAI+Y,EAAIje,KAAKrD,MAE1C,GACAqhB,EAAqBzV,QAAQ,SAAUnC,GACnCwX,EAAuB5B,EAAuB5V,IAAeyV,gBAAgBtT,QAAQ,SAAUuV,GAC3FE,EAAqB9Y,IAAI4Y,EAC7B,EACJ,GACA,IAKII,EAAe,CACfnB,MAAO,SAAU/V,GACb,GAP8BZ,EAOJY,EAAKhH,KAAKrD,OALtCqhB,EAAqBxZ,IAAI4B,IACvB4V,EAAuB5V,GAAcuX,QAKjC,OAAO,KARS,IAAUvX,CAUlC,GAEJ,OAAOqV,GAAiB3Y,EAAQ4R,MAAMsI,EAA6B,CAC/DQ,eAAgBU,EAChBT,mBAAoBS,EACpBC,oBAAqB,CACjBT,MAAO,SAAU1W,GACb,GAAIA,EAAKnF,oBAAqB,CAC1B,IAAIuc,EAAsBR,EAC1B7B,EAAwB/U,EAAKhH,MAAQgH,EAAKhH,KAAKrD,QAAQkhB,eACvD,GAAIO,EAAoBlc,KAAO8E,EAAKnF,oBAAoBL,OACpD,OAAOzE,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgI,GAAO,CAAEnF,oBAAqBmF,EAAKnF,oBAAoBkF,OAAO,SAAUsX,GACzG,OAAOD,EAAoB5Z,IAAI6Z,EAAOC,SAASte,KAAKrD,MACxD,IAEZ,CACJ,KAGZ,CACA,IAAI4hB,GAAwB/hB,OAAO0a,OAAO,SAAU2C,GAChD,OAAO/W,EAAQ4R,MAAMmF,EAAK,CACtB2E,aAAc,CACVzB,MAAO,SAAU/V,EAAMqW,EAAMoB,GACzB,IAAIA,GACAA,EAAOxd,OACH6B,EAAQyC,KAAK6W,qBAFrB,CAKA,IAAI/W,EAAa2B,EAAK3B,WACtB,GAAKA,EAQL,IALWA,EAAWmM,KAAK,SAAUlM,GACjC,OAAQqU,EAAQrU,KACc,eAAzBA,EAAUtF,KAAKrD,OACkC,IAA9C2I,EAAUtF,KAAKrD,MAAM+hB,YAAY,KAAM,GACnD,GACA,CAGA,IAAIjF,EAAQgF,EACZ,KAAI9E,EAAQF,IACRA,EAAM1E,YACN0E,EAAM1E,WAAWvD,KAAK,SAAUJ,GAAK,MAAwB,WAAjBA,EAAEpR,KAAKrD,KAAoB,IAG3E,OAAOI,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgI,GAAO,CAAE3B,WAAYtI,EAAMyF,cAAczF,EAAMyF,cAAc,GAAI6C,GAAY,GAAO,CAACiW,IAAiB,IAP/I,CAZA,CAoBJ,IAGZ,EAAG,CACCqD,MAAO,SAAUlF,GACb,OAAOA,IAAU6B,CACrB,IAEAsD,GAAyB,CACzB3M,KAAM,SAAU+C,GACZ,IAAI6J,EAAsC,eAAzB7J,EAAUhV,KAAKrD,MAOhC,OANIkiB,IACK7J,EAAU3S,WACV2S,EAAU3S,UAAUmP,KAAK,SAAUsN,GAAO,MAA0B,QAAnBA,EAAI9e,KAAKrD,KAAiB,KACrD,IAAvBwC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,MAGxDwf,CACX,GA8GJ,SAASE,GAAYpe,EAAUe,GAC3B,IAAI9C,EACJ,OAAoD,QAA3CA,EAAK0I,EAAuB3G,UAA8B,IAAP/B,OAAgB,EAASA,EAAG8C,aAAeA,CAC3G,CAWA,IAAIgJ,GAAiBlO,OAAOmO,UAAUD,eACtC,SAASsU,KAEL,IADA,IAAIC,EAAU,GACL3d,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpC2d,EAAQ3d,GAAMe,UAAUf,GAE5B,OAAO4d,GAAeD,EAC1B,CACA,SAASC,GAAeD,GACpB,IAAIE,EAASF,EAAQ,IAAM,CAAC,EACxBG,EAAQH,EAAQzd,OACpB,GAAI4d,EAAQ,EAER,IADA,IAAIC,EAAS,IAAIC,GACRrU,EAAI,EAAGA,EAAImU,IAASnU,EACzBkU,EAASE,EAAOE,MAAMJ,EAAQF,EAAQhU,IAG9C,OAAOkU,CACX,CACA,IAAIK,GAAoB,SAAUL,EAAQM,EAAQC,GAC9C,OAAOvW,KAAKoW,MAAMJ,EAAOO,GAAWD,EAAOC,GAC/C,EACIJ,GAAe,WACf,SAASA,EAAWK,QACG,IAAfA,IAAyBA,EAAaH,IAC1CrW,KAAKwW,WAAaA,EAClBxW,KAAKyW,SAAW7J,EAChB5M,KAAK0W,WAAa,IAAIrc,GAC1B,CA4CA,OA3CA8b,EAAW3U,UAAU4U,MAAQ,SAAUJ,EAAQM,GAG3C,IAFA,IAAI9L,EAAQxK,KACRrL,EAAU,GACLwD,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCxD,EAAQwD,EAAK,GAAKe,UAAUf,GAEhC,OAAIyU,EAAgB0J,IAAW1J,EAAgBoJ,IAC3C3iB,OAAOkK,KAAK+Y,GAAQlX,QAAQ,SAAUuX,GAClC,GAAIpV,GAAeyB,KAAKgT,EAAQW,GAAY,CACxC,IAAIC,EAAcZ,EAAOW,GACzB,GAAIL,EAAOK,KAAeC,EAAa,CACnC,IAAI7T,EAASyH,EAAMgM,WAAWpd,MAAMoR,EAAO5W,EAAMyF,cAAc,CAAC2c,EAC5DM,EACAK,GAAYhiB,GAAS,IACrBoO,IAAW6T,KACXZ,EAASxL,EAAMqM,oBAAoBb,IAC5BW,GAAa5T,EAE5B,CACJ,MAEIiT,EAASxL,EAAMqM,oBAAoBb,IAC5BW,GAAaL,EAAOK,EAEnC,GACOX,GAEJM,CACX,EACAH,EAAW3U,UAAUqV,oBAAsB,SAAUrjB,GAYjD,OAXIoZ,EAAgBpZ,KACXwM,KAAK0W,WAAWrb,IAAI7H,KAEjBA,EADA8F,MAAMC,QAAQ/F,GACNA,EAAM2L,MAAM,GAGZvL,EAAMiC,SAAS,CAAEihB,UAAWzjB,OAAOyZ,eAAetZ,IAAUA,GAExEwM,KAAK0W,WAAW3a,IAAIvI,KAGrBA,CACX,EACO2iB,CACX,CAnDkB,GAiMlB,IAAIY,GAAY,SAAUzV,GAAO,OAAO1N,EAAMoT,OAAO1F,EAAK0V,GAAY,EAClEA,GAAY,CAAC,QAAS,YA0B1B,SAASC,GAAkBpW,GACvB,MAAO,WAAYA,CACvB,CA4BA,IAAIqW,GAAW7jB,OAAOmO,UAAU0V,SAIhC,SAASC,GAAgBC,EAAKC,GAC1B,OAAQH,GAASlU,KAAKoU,IAClB,IAAK,iBAED,IADAC,EAAOA,GAAQ,IAAIpd,KACVoB,IAAI+b,GACT,OAAOC,EAAKxf,IAAIuf,GACpB,IAAIE,EAASF,EAAIjY,MAAM,GAKvB,OAJAkY,EAAKze,IAAIwe,EAAKE,GACdA,EAAOlY,QAAQ,SAAUmY,EAAOzV,GAC5BwV,EAAOxV,GAAKqV,GAAgBI,EAAOF,EACvC,GACOC,EAEX,IAAK,kBAED,IADAD,EAAOA,GAAQ,IAAIpd,KACVoB,IAAI+b,GACT,OAAOC,EAAKxf,IAAIuf,GACpB,IAAII,EAASnkB,OAAOY,OAAOZ,OAAOyZ,eAAesK,IAKjD,OAJAC,EAAKze,IAAIwe,EAAKI,GACdnkB,OAAOkK,KAAK6Z,GAAKhY,QAAQ,SAAU0G,GAC/B0R,EAAO1R,GAAOqR,GAAgBC,EAAItR,GAAMuR,EAC5C,GACOG,EAEX,QACI,OAAOJ,EAEnB,CAEA,SAASK,GAAWjkB,GAChB,IAAIkkB,EAAU,IAAIrd,IAAI,CAAC7G,IASvB,OARAkkB,EAAQtY,QAAQ,SAAUkC,GAClBsL,EAAgBtL,IAS5B,SAAuBA,GACnB,IAA2B,IAAvBtL,WAAWC,UAAsB5C,OAAOyH,SAASwG,GACjD,IACIjO,OAAOc,OAAOmN,EAClB,CACA,MAAOxN,GACH,GAAIA,aAAa6jB,UACb,OAAO,KACX,MAAM7jB,CACV,CAEJ,OAAOwN,CACX,CArBoCsW,CAActW,KAASA,GAC/CjO,OAAOwkB,oBAAoBvW,GAAKlC,QAAQ,SAAUvI,GAC1C+V,EAAgBtL,EAAIzK,KACpB6gB,EAAQ3b,IAAIuF,EAAIzK,GACxB,EAER,GACOrD,CACX,CAqBA,SAASskB,GAAuBC,EAAW7T,EAAQ8T,GAC/C,IAAIC,EAAsB,GAC1BF,EAAU3Y,QAAQ,SAAU8Y,GAAO,OAAOA,EAAIhU,IAAW+T,EAAoBzf,KAAK0f,EAAM,GACxFD,EAAoB7Y,QAAQ,SAAU8Y,GAAO,OAAOA,EAAIhU,GAAQ8T,EAAW,EAC/E,CAoCA,SAASG,GAAsBC,GAC3B,SAASxf,EAAIkN,GACTzS,OAAOC,eAAe8kB,EAAUtS,EAAK,CAAEtS,MAAOyX,EAAgB1C,YAClE,CAKA,OAJIjU,GAAgBC,OAAO8jB,SACvBzf,EAAIrE,OAAO8jB,SAEfzf,EAAI,aACGwf,CACX,CAEA,SAASE,GAAc9kB,GACnB,OAAOA,GAA+B,oBAAfA,EAAMuN,IACjC,CACA,IAAIwX,GAAY,SAAUhO,GAEtB,SAASgO,EAAQzC,GACb,IAAItL,EAAQD,EAAOvH,KAAKhD,KAAM,SAAUwI,GAEpC,OADAgC,EAAMgO,YAAYhQ,GACX,WAAc,OAAOgC,EAAMiO,eAAejQ,EAAW,CAChE,IAAMxI,KAoEN,OAnEAwK,EAAMuN,UAAY,IAAI1d,IACtBmQ,EAAM3J,QAAU,IAAIlB,QAAQ,SAAUC,EAASC,GAC3C2K,EAAM5K,QAAUA,EAChB4K,EAAM3K,OAASA,CACnB,GACA2K,EAAMkO,SAAW,CACbhZ,KAAM,SAAUqD,GACM,OAAdyH,EAAMmO,MACNnO,EAAMoO,OAAS,CAAC,OAAQ7V,GACxByH,EAAMqO,OAAO,OAAQ9V,GACrB+U,GAAuBtN,EAAMuN,UAAW,OAAQhV,GAExD,EACArE,MAAO,SAAUA,GACb,IAAIia,EAAMnO,EAAMmO,IACJ,OAARA,IACIA,GACAvL,WAAW,WAAc,OAAOuL,EAAIG,aAAe,GACvDtO,EAAMmO,IAAM,KACZnO,EAAMoO,OAAS,CAAC,QAASla,GACzB8L,EAAM3K,OAAOnB,GACb8L,EAAMqO,OAAO,QAASna,GACtBoZ,GAAuBtN,EAAMuN,UAAW,QAASrZ,GAEzD,EACAyL,SAAU,WACN,IAAI1U,EAAK+U,EAAOmO,EAAMljB,EAAGkjB,IAAKnd,EAAK/F,EAAGqgB,QACtC,GAAY,OAAR6C,EAAc,CACd,IAAInlB,QAFwD,IAAPgI,EAAgB,GAAKA,GAEtDwD,QACfxL,EAaI8kB,GAAc9kB,GACnBA,EAAMuN,KAAK,SAAUmX,GAAO,OAAQ1N,EAAMmO,IAAMT,EAAIa,UAAUvO,EAAMkO,SAAY,EAAGlO,EAAMkO,SAASha,OAGlG8L,EAAMmO,IAAMnlB,EAAMulB,UAAUvO,EAAMkO,WAhB9BC,GACAvL,WAAW,WAAc,OAAOuL,EAAIG,aAAe,GACvDtO,EAAMmO,IAAM,KACRnO,EAAMoO,QAA8B,SAApBpO,EAAMoO,OAAO,GAC7BpO,EAAM5K,QAAQ4K,EAAMoO,OAAO,IAG3BpO,EAAM5K,UAEV4K,EAAMqO,OAAO,YACbf,GAAuBtN,EAAMuN,UAAW,YAQhD,CACJ,GAEJvN,EAAMwO,oBAAsB,IAAI3e,IAChCmQ,EAAMyO,OAAS,SAAUC,GACrB1O,EAAM3K,OAAOqZ,GACb1O,EAAMsL,QAAU,GAChBtL,EAAMkO,SAASha,MAAMwa,EACzB,EACA1O,EAAM3J,QAAQG,MAAM,SAAUmY,GAAK,GACZ,oBAAZrD,IACPA,EAAU,CAAC,IAAI7K,EAAgB1C,WAAWuN,KAE1CwC,GAAcxC,GACdA,EAAQ/U,KAAK,SAAUqY,GAAY,OAAO5O,EAAM6O,MAAMD,EAAW,EAAG5O,EAAMkO,SAASha,OAGnF8L,EAAM6O,MAAMvD,GAETtL,CACX,CA8CA,OAxHA5W,EAAM8W,UAAU6N,EAAShO,GA2EzBgO,EAAQ/W,UAAU6X,MAAQ,SAAUvD,QACf,IAAb9V,KAAK2Y,MAET3Y,KAAK8V,QAAUxc,MAAMmC,KAAKqa,GAC1B9V,KAAK0Y,SAASvO,WAClB,EACAoO,EAAQ/W,UAAU8X,mBAAqB,SAAU9Q,GAC7C,GAAIxI,KAAK4Y,OAAQ,CACb,IAAIW,EAAcvZ,KAAK4Y,OAAO,GAC1B1U,EAASsE,EAAS+Q,GAClBrV,GACAA,EAAOlB,KAAKwF,EAAUxI,KAAK4Y,OAAO,IAErB,OAAb5Y,KAAK2Y,KAAgC,SAAhBY,GAA0B/Q,EAAS2B,UACxD3B,EAAS2B,UAEjB,CACJ,EACAoO,EAAQ/W,UAAUgX,YAAc,SAAUhQ,GACjCxI,KAAK+X,UAAU1c,IAAImN,KACpBxI,KAAKsZ,mBAAmB9Q,GACxBxI,KAAK+X,UAAUhc,IAAIyM,GAE3B,EACA+P,EAAQ/W,UAAUiX,eAAiB,SAAUjQ,GACrCxI,KAAK+X,UAAUtM,OAAOjD,IAAaxI,KAAK+X,UAAUhf,KAAO,GACzDiH,KAAK0Y,SAASvO,UAEtB,EACAoO,EAAQ/W,UAAUqX,OAAS,SAAU3U,EAAQyR,GACzC,IAAIqD,EAAsBhZ,KAAKgZ,oBAC3BA,EAAoBjgB,OACpBiH,KAAKgZ,oBAAsB,IAAI3e,IAC/B2e,EAAoB5Z,QAAQ,SAAUoa,GAAY,OAAOA,EAAStV,EAAQyR,EAAM,GAExF,EACA4C,EAAQ/W,UAAUiY,WAAa,SAAUC,GACrC,IAAIC,GAAS,EACb3Z,KAAKgZ,oBAAoBjd,IAAI,SAAUmI,EAAQyR,GACtCgE,IACDA,GAAS,EACTD,EAASxV,EAAQyR,GAEzB,EACJ,EACO4C,CACX,CA1He,CA0HbtN,EAAgB1C,YAGlB,SAASqR,GAAkCpmB,GACvC,MAAO,gBAAiBA,CAC5B,CACA,SAASqmB,GAA8BrmB,GACnC,MAAO,YAAaA,GAAS,SAAUA,CAC3C,CAgCA,SAASsmB,GAA2B/W,GAChC,IAAIgX,EAAgB7H,EAAgBnP,EAAO1E,QAAU0E,EAAO1E,OAAOc,MAAM,GAAK,GAS9E,OARIya,GAAkC7W,IAClCmP,EAAgBnP,EAAOiX,cACvBjX,EAAOiX,YAAY5a,QAAQ,SAAU6a,GAC7BA,EAAkB5b,QAClB0b,EAAcvhB,KAAKY,MAAM2gB,EAAeE,EAAkB5b,OAElE,GAEG0b,CACX,CAEA,SAASG,KAEL,IADA,IAAIC,EAAU,GACLhiB,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCgiB,EAAQhiB,GAAMe,UAAUf,GAE5B,IAAI4K,EAAS1P,OAAOY,OAAO,MAW3B,OAVAkmB,EAAQ/a,QAAQ,SAAUkC,GACjBA,GAELjO,OAAOkK,KAAK+D,GAAKlC,QAAQ,SAAU0G,GAC/B,IAAItS,EAAQ8N,EAAIwE,QACF,IAAVtS,IACAuP,EAAO+C,GAAOtS,EAEtB,EACJ,GACOuP,CACX,CArEAoV,GAAsBI,IAuEtB,IAAI6B,GAAe,IAAIngB,IACvB,SAASogB,GAAaC,GAClB,IAAIrE,EAAQmE,GAAaviB,IAAIyiB,IAAW,EAExC,OADAF,GAAaxhB,IAAI0hB,EAAQrE,EAAQ,GAC1B,GAAGna,OAAOwe,EAAQ,KAAKxe,OAAOma,EAAO,KAAKna,OAAOye,KAAKC,SAAStD,SAAS,IAAI/X,MAAM,GAC7F,CAkBA,SAASsb,GAASjnB,EAAOsS,GACrB,OAAO4U,GAAWlnB,EAAOsS,EAC7B,CACA,SAAS4U,GAAWlnB,EAAOsS,EAAK6U,GAE5B,QADc,IAAVA,IAAoBA,EAAQ,IAAI1gB,KAChC0gB,EAAMtf,IAAI7H,GACV,OAAOmnB,EAAM9iB,IAAIrE,GAErB,IAAIonB,GAAW,EACf,GAAIthB,MAAMC,QAAQ/F,GAAQ,CACtB,IAAIqnB,EAAU,GAOd,GANAF,EAAM/hB,IAAIpF,EAAOqnB,GACjBrnB,EAAM4L,QAAQ,SAAU5L,EAAOoI,GAC3B,IAAImH,EAAS2X,GAAWlnB,EAAOsS,EAAK6U,GACpCC,IAAaA,EAAW7X,IAAWvP,GACnCqnB,EAAQjf,GAASmH,CACrB,GACI6X,EACA,OAAOC,CAEf,MACK,GAAIhO,EAAcrZ,GAAQ,CAC3B,IAAIsnB,EAAQznB,OAAOY,OAAOZ,OAAOyZ,eAAetZ,IAWhD,GAVAmnB,EAAM/hB,IAAIpF,EAAOsnB,GACjBznB,OAAOkK,KAAK/J,GAAO4L,QAAQ,SAAUlL,GACjC,GAAIA,IAAM4R,EAAV,CAIA,IAAI/C,EAAS2X,GAAWlnB,EAAMU,GAAI4R,EAAK6U,GACvCC,IAAaA,EAAW7X,IAAWvP,EAAMU,IACzC4mB,EAAM5mB,GAAK6O,CAHX,MAFI6X,GAAW,CAMnB,GACIA,EACA,OAAOE,CAEf,CACA,OAAOtnB,CACX,CAMAD,EAAQwnB,IAAMtnB,EAAQsnB,IACtBxnB,EAAQkT,MAAQhT,EAAQgT,MACxBlT,EAAQgV,WAAa0C,EAAgB1C,WACrChV,EAAQka,uBAAyBA,EACjCla,EAAQkE,qBAAuBA,EAC/BlE,EAAQglB,QAAUA,GAClBhlB,EAAQ4iB,WAAaA,GACrB5iB,EAAQ0d,kBAAoBA,EAC5B1d,EAAQynB,+BAprBR,SAAwCxjB,GAEpC,OADAiZ,EAAcjZ,GACPmC,EAAQ4R,MAAM/T,EAAU,CAC3B6c,eAAgB,SAAUxW,GACtB,IAAIpI,EACJ,KAA+B,QAA1BA,EAAKoI,EAAK+N,kBAA+B,IAAPnW,OAAgB,EAASA,EAAG4S,KAAK,SAAUwD,GAAa,MAAgC,WAAzBA,EAAUhV,KAAKrD,KAAoB,IAGzI,OAAOI,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgI,GAAO,CAAE+N,WAAYhY,EAAMyF,cAAczF,EAAMyF,cAAc,GAAKwE,EAAK+N,YAAc,IAAK,GAAO,CAClI,CACI9T,KAAM6B,EAAQyC,KAAK6e,UACnBpkB,KAAM,CAAEiB,KAAM6B,EAAQyC,KAAKgW,KAAM5e,MAAO,kBAE7C,IACX,GAER,EAqqBAD,EAAQ6hB,sBAAwBA,GAChC7hB,EAAQ2nB,yBA1vCR,SAAkC5K,EAAO3Y,GACrC,GAAI2Y,EAAMpX,WAAaoX,EAAMpX,UAAUb,OAAQ,CAC3C,IAAI8iB,EAAW,CAAC,EAKhB,OAJA7K,EAAMpX,UAAUkG,QAAQ,SAAU3J,GAC9B,IAAIoB,EAAOpB,EAAGoB,KAAMrD,EAAQiC,EAAGjC,MAC/B,OAAOkb,EAA4ByM,EAAUtkB,EAAMrD,EAAOmE,EAC9D,GACOwjB,CACX,CACA,OAAO,IACX,EAivCA5nB,EAAQ6nB,SAhUR,SAAkBC,EAAYC,EAAOC,GACjC,OAAO,IAAItQ,EAAgB1C,WAAW,SAAUC,GAC5C,IAAIgT,EAAe,CACfza,KAAM,SAAU2Y,GACZ,OAAO,IAAI/Z,QAAQ,SAAUC,GAAW,OAAOA,EAAQ8Z,IAAa,EACxE,GAEJ,SAAS+B,EAAaC,EAAU5V,GAC5B,OAAO,SAAU6P,GACb,GAAI+F,EAAU,CACV,IAAIC,EAAO,WACP,OAAOnT,EAASoT,OACX,EACCF,EAAS/F,EACnB,EACA6F,EAAeA,EAAaza,KAAK4a,EAAMA,GAAM5a,KAAK,SAAUgC,GAAU,OAAOyF,EAAS9I,KAAKqD,EAAS,EAAG,SAAUrE,GAAS,OAAO8J,EAAS9J,MAAMA,EAAQ,EAC5J,MAEI8J,EAAS1C,GAAK6P,EAEtB,CACJ,CACA,IAAIkG,EAAU,CACVnc,KAAM+b,EAAaH,EAAO,QAC1B5c,MAAO+c,EAAaF,EAAS,SAC7BpR,SAAU,WACLqR,EAAaza,KAAK,WAAc,OAAOyH,EAAS2B,UAAY,EACjE,GAEAwO,EAAM0C,EAAWtC,UAAU8C,GAC/B,OAAO,WAAc,OAAOlD,EAAIG,aAAe,CACnD,EACJ,EAiSAvlB,EAAQuoB,2BAjtBR,SAAoCtkB,GAGhC,MAA4B,UAFX2Q,EAAkB3Q,GACEe,UAE1Bf,EAEOmC,EAAQ4R,MAAM/T,EAAU,CACtCwd,oBAAqB,CACjBpB,MAAO,SAAU/V,GACb,OAAOjK,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgI,GAAO,CAAEtF,UAAW,SACjE,IAIZ,EAosBAhF,EAAQmE,WAAaA,EACrBnE,EAAQuM,0BAA4BA,EACpCvM,EAAQgZ,UAAYA,EACpBhZ,EAAQoZ,mBAAqBA,EAC7BpZ,EAAQe,aAAeA,EACvBf,EAAQwG,cAAgBA,EACxBxG,EAAQ4G,cAAgBA,EACxB5G,EAAQua,mBAAqBA,EAC7Bva,EAAQkd,cAAgBA,EACxBld,EAAQwoB,UAjZR,SAAmBvoB,GACf,OAAO2jB,GAAgB3jB,EAC3B,EAgZAD,EAAQ2mB,QAAUA,GAClB3mB,EAAQyoB,iBAzlBR,SAA0BC,GAEtB,YADgB,IAAZA,IAAsBA,GAAU,GAC7B,CACHA,QAASA,EACT7F,MAAO,SAAU8F,EAAUC,GACvB,OAAOD,EAAWtoB,EAAMyF,cAAczF,EAAMyF,cAAc,GAAI6iB,GAAU,GAAOC,GAAU,GAAQA,CACrG,EAER,EAklBA5oB,EAAQyK,kBAAoBA,EAC5BzK,EAAQ6oB,uBAjcR,SAAgC5oB,GAC5B,IAAIqN,EAAUlB,QAAQC,QAAQpM,GAG9B,OAFAqN,EAAQwB,OAAS,YACjBxB,EAAQrN,MAAQA,EACTqN,CACX,EA6bAtN,EAAQ8oB,sBA5bR,SAA+BnD,GAC3B,IAAIrY,EAAUlB,QAAQE,OAAOqZ,GAI7B,OAHArY,EAAQG,MAAM,WAAc,GAC5BH,EAAQwB,OAAS,WACjBxB,EAAQqY,OAASA,EACVrY,CACX,EAubAtN,EAAQ4kB,sBAAwBA,GAChC5kB,EAAQ+oB,iBA1pCR,SAA0B7jB,GACtB,IAAI8jB,EAAgBlpB,OAAOY,OAAO,MAC9BuoB,EAAO/jB,GAAcA,EAAWC,oBAQpC,OAPI8jB,GAAQA,EAAKnkB,QACbmkB,EAAKpd,QAAQ,SAAU0V,GACfA,EAAI2H,cACJ/N,EAA4B6N,EAAezH,EAAIK,SAASte,KAAMie,EAAI2H,aAE1E,GAEGF,CACX,EAgpCAhpB,EAAQmpB,kBAnrDR,SAA2BvR,GACvB,IAAID,EAAQ,GAMZ,OALAvR,EAAQ4R,MAAMJ,EAAM,CAChBK,UAAW,SAAU3N,GACjBqN,EAAM1S,KAAKqF,EAAKhH,KAAKrD,MACzB,IAEG0X,CACX,EA4qDA3X,EAAQod,sBAAwBA,EAChCpd,EAAQ0K,uBAAyBA,EACjC1K,EAAQyZ,yBAA2BA,EACnCzZ,EAAQ+J,oBAloDR,SAA6BJ,GACzB,IAAIzH,EAAI+F,EACJqQ,EAA2C,QAA9BpW,EAAKyH,EAAS0O,kBAA+B,IAAPnW,OAAgB,EAASA,EAAGsI,KAAK,SAAUtI,GAE9F,MAAsB,WADXA,EAAGoB,KACFrD,KAChB,GACA,IAAKqY,EACD,MAAO,OAEX,IAAI8Q,EAAyC,QAA9BnhB,EAAKqQ,EAAU3S,iBAA8B,IAAPsC,OAAgB,EAASA,EAAGuC,KAAK,SAAUtI,GAE5F,MAAsB,SADXA,EAAGoB,KACFrD,KAChB,GAcA,OAb2B,IAAvBwC,WAAWC,SACP0mB,IACIA,EAAQnpB,MAAMsE,OAAS6B,EAAQyC,KAAKwgB,UACb,IAAvB5mB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,KAElDymB,EAAQnpB,MAAMsE,OAAS6B,EAAQyC,KAAKygB,QAClB,IAAvB7mB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,KAE1B,YAAxBymB,EAAQnpB,MAAMA,QACI,IAAvBwC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAAKymB,EAAQnpB,MAAMA,QAIlFmpB,GACA,UAAWA,EAAQnpB,OACK,YAAxBmpB,EAAQnpB,MAAMA,MACP,UAEJ,QACX,EAmmDAD,EAAQupB,yBA5kDR,SAAkCtlB,EAAUyF,GACxC,IAAI8f,EAAqB9f,EACrBlF,EAAY,GAmChB,OAlCAP,EAASY,YAAYgH,QAAQ,SAAU3G,GACnC,GAAwB,wBAApBA,EAAWX,KACX,MAAMrE,EAAQ+P,kBACV,IACA/K,EAAWF,UACXE,EAAW5B,KAAO,WAAWiF,OAAOrD,EAAW5B,KAAKrD,MAAO,KAAO,IAGlD,uBAApBiF,EAAWX,MACXC,EAAUS,KAAKC,EAEvB,GACkC,qBAAvBskB,IACPtpB,EAAQiB,UAA+B,IAArBqD,EAAUM,OAAc,IAAKN,EAAUM,QACzD0kB,EAAqBhlB,EAAU,GAAGlB,KAAKrD,OAE/BI,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2B,GAAW,CAAEY,YAAaxE,EAAMyF,cAAc,CACpF,CACIvB,KAAM,sBACNS,UAAW,QACXoC,aAAc,CACV7C,KAAM,eACNoE,WAAY,CACR,CACIpE,KAAM,iBACNjB,KAAM,CACFiB,KAAM,OACNtE,MAAOupB,QAM5BvlB,EAASY,aAAa,IAEjC,EAuiDA7E,EAAQumB,2BAA6BA,GACrCvmB,EAAQoY,uBAAyBA,EACjCpY,EAAQ4U,kBAAoBA,EAC5B5U,EAAQ4K,uBAAyBA,EACjC5K,EAAQypB,iBAntCR,SAA0BtM,GACtB,OAAQA,EAAItY,YACPwF,OAAO,SAAUnF,GAClB,MAA2B,wBAApBA,EAAWX,QAAoCW,EAAW5B,IACrE,GACKoM,IAAI,SAAU3K,GAAK,OAAOA,EAAEzB,KAAKrD,KAAO,GAAG,IAAM,IAC1D,EA8sCAD,EAAQ0pB,mBAxsCR,SAA4BvM,GACxB,IAAIwM,EAAW/e,EAAuBuS,GAEtC,OADAjd,EAAQiB,UAAUwoB,GAAmC,UAAvBA,EAAS3kB,UAAuB,KACvD2kB,CACX,EAqsCA3pB,EAAQuc,gBAAkBA,EAC1Bvc,EAAQ4pB,sBA7wCR,SAASA,EAAsBpa,EAAQpI,EAAcwC,GAEjD,IADA,IAAIpF,EACKI,EAAK,EAAG1C,EAAKkF,EAAauB,WAAY/D,EAAK1C,EAAG4C,OAAQF,IAAM,CAEjE,GAAIqY,EADArU,EAAY1G,EAAG0C,KAEf,GAA6B,eAAzBgE,EAAUtF,KAAKrD,MACf,OAAOuP,EAAOxG,EAAuBJ,SAGpCpE,EACLA,EAAUS,KAAK2D,GAGfpE,EAAY,CAACoE,EAErB,CACA,GAAiC,kBAAtB4G,EAAOhG,WACd,OAAOgG,EAAOhG,WAElB,GAAIhF,EACA,IAAK,IAAIyD,EAAK,EAAG4hB,EAAcrlB,EAAWyD,EAAK4hB,EAAY/kB,OAAQmD,IAAM,CACrE,IAAIW,EACAkhB,EAAWF,EAAsBpa,EAAQiK,EADzC7Q,EAAYihB,EAAY5hB,GACqD2B,GAAaxC,aAAcwC,GAC5G,GAAwB,kBAAbkgB,EACP,OAAOA,CAEf,CAER,EAkvCA9pB,EAAQ+pB,sBAnJR,SAA+Bva,GAE3B,OAAOmP,EADM4H,GAA2B/W,GAE5C,EAiJAxP,EAAQgqB,iBAtrDe,SAAUrS,EAAOC,GACpC,OAAO1D,EAAcyD,EAAOC,GAAM,EACtC,EAqrDA5X,EAAQiqB,iBA1rDe,SAAUtS,EAAOC,GACpC,OAAO1D,EAAcyD,EAAOC,GAAM,EACtC,EAyrDA5X,EAAQkqB,iBAzqDR,SAA0BjmB,GACtB,OAAOA,GAAYiQ,EAAc,CAAC,SAAU,UAAWjQ,GAAU,EACrE,EAwqDAjE,EAAQkU,cAAgBA,EACxBlU,EAAQ8N,sBA/KR,SAA+B7N,GAC3B,OAAOoZ,EAAgBpZ,IAAU,YAAaA,CAClD,EA8KAD,EAAQgG,QAAUA,EAClBhG,EAAQmqB,eAt7CR,SAAwBlqB,GACpB,OAAQoZ,EAAgBpZ,IACL,aAAfA,EAAMsE,MACNwB,MAAMC,QAAQ/F,EAAM4E,YAC5B,EAm7CA7E,EAAQqmB,kCAAoCA,GAC5CrmB,EAAQsmB,8BAAgCA,GACxCtmB,EAAQoqB,uBAxLR,SAAgCnqB,GAC5B,OAAQomB,GAAkCpmB,IACtCqmB,GAA8BrmB,EACtC,EAsLAD,EAAQid,QAAUA,EAClBjd,EAAQqqB,yBAjiDR,SAAkCpmB,GAC9B,IAAIqmB,GAAa,EAWjB,OAVAlkB,EAAQ4R,MAAM/T,EAAU,CACpB6c,eAAgB,SAAUxW,GAItB,KAHAggB,IACMhgB,EAAK+N,YACH/N,EAAK+N,WAAWvD,KAAK,SAAUwD,GAAa,MAAgC,WAAzBA,EAAUhV,KAAKrD,KAAoB,IAE1F,OAAOmG,EAAQ+R,KAEvB,IAEGmS,CACX,EAqhDAtqB,EAAQuqB,iBA3vCR,SAA0B3hB,GACtB,MAA0B,mBAAnBA,EAAUrE,IACrB,EA0vCAvE,EAAQwqB,oBAhtBR,SAA6BvmB,GACzB,OAAOoe,GAAYpe,EAAU,WACjC,EA+sBAjE,EAAQ2e,gBAAkBA,EAC1B3e,EAAQqZ,gBAAkBA,EAC1BrZ,EAAQsZ,cAAgBA,EACxBtZ,EAAQyqB,iBAjtBR,SAA0BxmB,GACtB,OAAOoe,GAAYpe,EAAU,QACjC,EAgtBAjE,EAAQ0qB,YAr8CR,SAAqB3c,GACjB,OAAO4c,QAAQ5c,GAAsB,kBAARA,GAAyC,kBAAdA,EAAI6c,MAChE,EAo8CA5qB,EAAQ0jB,kBAAoBA,GAC5B1jB,EAAQ6qB,wBAjtBR,SAAiC5mB,GAC7B,OAAOoe,GAAYpe,EAAU,eACjC,EAgtBAjE,EAAQukB,uBAAyBA,GACjCvkB,EAAQ8qB,cA58CR,SAAuBC,GACnB,MAAO,CAAEH,MAAOI,OAAOD,GAC3B,EA28CA/qB,EAAQ8mB,aAAeA,GACvB9mB,EAAQwH,gBAvYR,SAAyBuG,GAIrB,OAH2B,IAAvBtL,WAAWC,SACXwhB,GAAWnW,GAERA,CACX,EAmYA/N,EAAQsiB,UAAYA,GACpBtiB,EAAQwiB,eAAiBA,GACzBxiB,EAAQirB,qBAnMR,SAA8BC,EAAY1b,GACtC,IAAI2b,EAAaD,EACbvI,EAAS,IAAIC,GAejB,OAdIyD,GAAkC7W,IAClCmP,EAAgBnP,EAAOiX,cACvBjX,EAAOiX,YAAY5a,QAAQ,SAAU3J,GAEjC,IADA,IAAIiF,EAAOjF,EAAGiF,KAAMO,EAAOxF,EAAGwF,KACrB6G,EAAI7G,EAAK5C,OAAS,EAAGyJ,GAAK,IAAKA,EAAG,CACvC,IAAIgE,EAAM7K,EAAK6G,GAEX6c,GADgBC,OAAO9Y,GACG,GAAK,CAAC,EACpC6Y,EAAS7Y,GAAOpL,EAChBA,EAAOikB,CACX,CACAD,EAAaxI,EAAOE,MAAMsI,EAAYhkB,EAC1C,GAEGgkB,CACX,EAkLAnrB,EAAQsrB,aA3HR,SAAsBC,EAAU7a,GAC5B,OAAOiW,GAAQ4E,EAAU7a,EAASA,EAAQtM,WAAa,CACnDA,UAAWuiB,GAAQtmB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAIipB,GAAYA,EAASnnB,WAAasM,EAAQtM,aAExG,EAwHApE,EAAQwrB,sBAloBR,SAA+B9C,GAE3B,YADgB,IAAZA,IAAsBA,GAAU,GAC7B,CACHA,QAASA,EACT7F,MAAO,SAAU8F,EAAUC,EAAU1mB,GACjC,IAAIwD,EAAOxD,EAAGwD,KACV+lB,EAAS9C,EAAWA,EAAS/c,MAAM,GAAK,GAC5C,GAAIgd,EACA,GAAIljB,EAEA,IADA,IAAIuC,EAAKvC,EAAKgmB,OAAQA,OAAgB,IAAPzjB,EAAgB,EAAIA,EAC1CsG,EAAI,EAAGA,EAAIqa,EAAS9jB,SAAUyJ,EACnCkd,EAAOC,EAASnd,GAAKqa,EAASra,QAIlCkd,EAAOxmB,KAAKY,MAAM4lB,EAAQ7C,GAGlC,OAAO6C,CACX,EAER,EA8mBAzrB,EAAQknB,SAAWA,GACnBlnB,EAAQ2rB,0BA7cR,SAAmCre,GAE/B,OADAA,EAAQG,MAAM,WAAc,GACrBH,CACX,EA2cAtN,EAAQ0R,MAAQA,EAChB1R,EAAQ4rB,qBAhnBR,SAA8BlD,GAE1B,YADgB,IAAZA,IAAsBA,GAAU,GAC7B,CACHA,QAASA,EACT9b,KAAM,SAAU+b,EAAUzmB,GACtB,IAAI2pB,EAAU3pB,EAAG2pB,QAASC,EAAY5pB,EAAG4pB,UACzC,IAAKnD,EACD,OAAOA,EACX,IAAIoD,EAAQ,GACRC,EAAkB,GAClBC,EAAiB,GACrBtD,EAASoD,MAAMlgB,QAAQ,SAAUqgB,GACzBL,EAAQC,EAAU,OAAQI,MAC1BH,EAAM9mB,KAAKinB,GACPA,EAAKC,SACLH,EAAkBA,GAAmBE,EAAKC,QAAU,GACpDF,EAAiBC,EAAKC,QAAUF,GAG5C,GACIF,EAAMjnB,OAAS,GAAKknB,IAAoBC,IACxCD,EAAkB,IAEtB,IAAI/jB,EAAK0gB,EAASyD,UAAY,CAAC,EAAGC,EAAcpkB,EAAGokB,YAAaC,EAAYrkB,EAAGqkB,UAC/E,OAAOjsB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkhB,GAAUmF,IAAY,CAAEoD,MAAOA,EAAOK,SAAU/rB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGqmB,EAASyD,UAAW,CACvIC,YAAaA,GAAeL,EAAiBM,UAAWA,GAAaL,KACjF,EACApJ,MAAO,SAAU8F,EAAUC,EAAU1mB,GACjC,IAAIwD,EAAOxD,EAAGwD,KAAMglB,EAAcxoB,EAAGwoB,YAAaoB,EAAY5pB,EAAG4pB,UAIjE,GAHKnD,IACDA,EAkFL,CACHoD,MAAO,GACPK,SAAU,CACNG,iBAAiB,EACjBC,aAAa,EACbH,YAAa,GACbC,UAAW,OAtFN1D,EACD,OAAOD,EAEX,IAAI8D,EAAgB7D,EAASmD,MACzBnD,EAASmD,MAAMrc,IAAI,SAAUwc,GAIzB,OAHIxB,EAAawB,EAAO7rB,EAAMiC,SAAS,CAAC,EAAG4pB,MACvCA,EAAKC,OAASL,EAAU,SAAUI,IAE/BA,CACX,GACE,GACN,GAAItD,EAASwD,SAAU,CACnB,IAAIM,EAAa9D,EAASwD,SACtBC,EAAcK,EAAWL,YAAaC,EAAYI,EAAWJ,UAC7DK,EAAYF,EAAc,GAC1BG,EAAWH,EAAcA,EAAc3nB,OAAS,GAChD6nB,GAAaN,IACbM,EAAUR,OAASE,GAEnBO,GAAYN,IACZM,EAAST,OAASG,GAEtB,IAAIO,EAAcF,GAAaA,EAAUR,OACrCU,IAAgBR,IAChBzD,EAAWtG,GAAUsG,EAAU,CAC3BwD,SAAU,CACNC,YAAaQ,MAIzB,IAAIC,EAAaF,GAAYA,EAAST,OAClCW,IAAeR,IACf1D,EAAWtG,GAAUsG,EAAU,CAC3BwD,SAAU,CACNE,UAAWQ,KAI3B,CACA,IAAI/F,EAAS4B,EAASoD,MAClBgB,EAAS,GACb,GAAIrnB,GAAQA,EAAKsnB,OACT3kB,EAAQ0e,EAAOkG,UAAU,SAAUf,GAAQ,OAAOA,EAAKC,SAAWzmB,EAAKsnB,KAAO,KACrE,IACTjG,EAASA,EAAOnb,MAAM,EAAGvD,EAAQ,SAGpC,GAAI3C,GAAQA,EAAKwnB,OAAQ,CAC1B,IAAI7kB,EACJ0kB,GADI1kB,EAAQ0e,EAAOkG,UAAU,SAAUf,GAAQ,OAAOA,EAAKC,SAAWzmB,EAAKwnB,MAAQ,IAClE,EAAInG,EAASA,EAAOnb,MAAMvD,GAC3C0e,EAAS,EACb,MACS6B,EAASmD,QACdhF,EAAS,IAEb,IAAIgF,EAAQ1rB,EAAMyF,cAAczF,EAAMyF,cAAczF,EAAMyF,cAAc,GAAIihB,GAAQ,GAAO0F,GAAe,GAAOM,GAAQ,GACrHX,EAAW/rB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGsmB,EAASwD,UAAWzD,EAASyD,UAC9E,GAAIxD,EAASwD,SAAU,CACnB,IAAInkB,EAAK2gB,EAASwD,SAAUG,EAAkBtkB,EAAGskB,gBAAiBC,EAAcvkB,EAAGukB,YAAqEW,GAAxDd,EAAcpkB,EAAGokB,YAAaC,EAAYrkB,EAAGqkB,UAAoBjsB,EAAMoT,OAAOxL,EAAI,CAAC,kBAAmB,cAAe,cAAe,eACpOnI,OAAO0a,OAAO4R,EAAUe,GACnBpG,EAAOjiB,cACJ,IAAWynB,IACXH,EAASG,gBAAkBA,QAC3B,IAAWF,IACXD,EAASC,YAAcA,IAE1BU,EAAOjoB,cACJ,IAAW0nB,IACXJ,EAASI,YAAcA,QACvB,IAAWF,IACXF,EAASE,UAAYA,GAEjC,CACA,OAAOjsB,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkhB,GAAUmF,IAAYnF,GAAUoF,IAAY,CAAEmD,MAAOA,EAAOK,SAAUA,GAClI,EAER,EAqgBApsB,EAAQotB,4BAv0BR,SAAqCnc,EAAQkM,GACzC,IAAIkQ,EAZR,SAA4Bpc,GACxB,OAAO,SAAyBwT,GAC5B,OAAOxT,EAAO6D,KAAK,SAAUwY,GACzB,OAAO7I,EAASxkB,OACZwkB,EAASxkB,MAAMsE,OAAS6B,EAAQyC,KAAKwgB,UACrC5E,EAASxkB,MAAMqD,OACdgqB,EAAQhqB,OAASmhB,EAASxkB,MAAMqD,KAAKrD,OACjCqtB,EAAQ/X,MAAQ+X,EAAQ/X,KAAKkP,GAC1C,EACJ,CACJ,CAEqB8I,CAAmBtc,GACpC,OAAO8N,GAAiB3Y,EAAQ4R,MAAMmF,EAAK,CACvCsE,oBAAqB,CACjBpB,MAAO,SAAU/V,GACb,OAAOjK,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgI,GAAO,CAC5CnF,oBAAqBmF,EAAKnF,oBACtBmF,EAAKnF,oBAAoBkF,OAAO,SAAUsX,GACtC,OAAQ1Q,EAAO6D,KAAK,SAAUsN,GAAO,OAAOA,EAAI9e,OAASqe,EAAOC,SAASte,KAAKrD,KAAO,EACzF,GACE,IACd,GAEJsgB,MAAO,CACHF,MAAO,SAAU/V,GAEb,GADwB2G,EAAO6D,KAAK,SAAU0Y,GAAa,OAAOA,EAAUvN,MAAQ,GAC7D,CACnB,IAAIwN,EAAkB,EAQtB,GAPInjB,EAAK3E,WACL2E,EAAK3E,UAAUkG,QAAQ,SAAUuW,GACzBiL,EAAWjL,KACXqL,GAAmB,EAE3B,GAEoB,IAApBA,EACA,OAAO,IAEf,CACJ,GAEJC,SAAU,CACNrN,MAAO,SAAU/V,GACb,GAAI+iB,EAAW/iB,GACX,OAAO,IAEf,KAGZ,EAiyBAtK,EAAQoU,6BAtwBR,SAAsCnQ,GAQlC,OAPAiZ,EAAcjZ,GACImb,GAA6B,CAC3C,CACI7J,KAAM,SAAU+C,GAAa,MAAgC,WAAzBA,EAAUhV,KAAKrD,KAAoB,EACvEggB,QAAQ,IAEbhc,EAEP,EA8vBAjE,EAAQ2tB,sCAv1BR,SAA+CxQ,GAC3C,OAAOiC,GAA6B,CAAC8C,IAAyBhF,EAAcC,GAChF,EAs1BAnd,EAAQof,6BAA+BA,GACvCpf,EAAQ4tB,iCAnyBR,SAA0C3c,EAAQkM,GAC9C,SAASkD,EAAM/V,GACX,GAAI2G,EAAO6D,KAAK,SAAUyM,GAAO,OAAOA,EAAIje,OAASgH,EAAKhH,KAAKrD,KAAO,GAClE,OAAO,IAEf,CACA,OAAO8e,GAAiB3Y,EAAQ4R,MAAMmF,EAAK,CACvC2D,eAAgB,CAAET,MAAOA,GACzBU,mBAAoB,CAAEV,MAAOA,KAErC,EA0xBArgB,EAAQgJ,uBAAyBA,EACjChJ,EAAQ6tB,cA7vDR,SAAuB3rB,EAAIkC,GACvB,IAAIiU,EAAanW,EAAGmW,WACpB,OAAKA,IAAeA,EAAWvT,QAGxBsT,EAAuBC,GAAYuC,MAAM,SAAU1Y,GACtD,IAAIoW,EAAYpW,EAAGoW,UAAWG,EAAavW,EAAGuW,WAC1CqV,GAAc,EASlB,MAR8B,aAA1BrV,EAAWxY,MAAMsE,MACjBupB,EACI1pB,GAAaA,EAAUqU,EAAWxY,MAAMqD,KAAKrD,OACjDC,EAAQiB,eAA0B,IAAhB2sB,EAAwB,IAAKxV,EAAUhV,KAAKrD,QAG9D6tB,EAAcrV,EAAWxY,MAAMA,MAEH,SAAzBqY,EAAUhV,KAAKrD,OAAoB6tB,EAAcA,CAC5D,EACJ,EA4uDA9tB,EAAQ+tB,sBAt5CR,SAA+BhR,EAAO3Y,GAClC,IAAI4pB,EAAgB,KAChBjR,EAAM1E,aACN2V,EAAgB,CAAC,EACjBjR,EAAM1E,WAAWxM,QAAQ,SAAUyM,GAC/B0V,EAAc1V,EAAUhV,KAAKrD,OAAS,CAAC,EACnCqY,EAAU3S,WACV2S,EAAU3S,UAAUkG,QAAQ,SAAU3J,GAClC,IAAIoB,EAAOpB,EAAGoB,KAAMrD,EAAQiC,EAAGjC,MAC/B,OAAOkb,EAA4B6S,EAAc1V,EAAUhV,KAAKrD,OAAQqD,EAAMrD,EAAOmE,EACzF,EAER,IAEJ,IAAIgX,EAAS,KAQb,OAPI2B,EAAMpX,WAAaoX,EAAMpX,UAAUb,SACnCsW,EAAS,CAAC,EACV2B,EAAMpX,UAAUkG,QAAQ,SAAU3J,GAC9B,IAAIoB,EAAOpB,EAAGoB,KAAMrD,EAAQiC,EAAGjC,MAC/B,OAAOkb,EAA4BC,EAAQ9X,EAAMrD,EAAOmE,EAC5D,IAEGmY,EAAgBQ,EAAMzZ,KAAKrD,MAAOmb,EAAQ4S,EACrD,EAg4CAhuB,EAAQiuB,oBAnJR,SAA6BhuB,EAAOiuB,QAClB,IAAVA,IAAoBA,EAAQ,GAChC,IAAIC,EAAUrH,GAAa,uBAC3B,OAAO9X,KAAKgB,UAAU/P,EAAO,SAAUsS,EAAKtS,GACxC,YAAiB,IAAVA,EAAmBkuB,EAAUluB,CACxC,EAAGiuB,GACE7f,MAAMW,KAAKgB,UAAUme,IACrBnb,KAAK,cACd,EA4IAhT,EAAQouB,cA5FR,SAAuBnuB,GACnB,OAAOinB,GAASjnB,EAAO,aAC3B,EA2FAD,EAAQmb,4BAA8BA,EACtCnb,EAAQquB,qBAjfR,SAA8B/gB,GAC1B,GAAIoW,GAAkBpW,GAClB,OAAOA,EAEX,IAAIghB,EAAiBhhB,EAerB,OAdAghB,EAAexf,OAAS,UACxBwf,EAAe9gB,KAAK,SAAUvN,GAC1B,GAA8B,YAA1BquB,EAAexf,OAAsB,CACrC,IAAIyf,EAAmBD,EACvBC,EAAiBzf,OAAS,YAC1Byf,EAAiBtuB,MAAQA,CAC7B,CACJ,EAAG,SAAU0lB,GACT,GAA8B,YAA1B2I,EAAexf,OAAsB,CACrC,IAAI0f,EAAkBF,EACtBE,EAAgB1f,OAAS,WACzB0f,EAAgB7I,OAASA,CAC7B,CACJ,GACOrY,CACX,C,yCChzCAxN,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIwuB,EAAc,EAAQ,wBAEtB1a,EAAU,SAEd,SAASb,EAAMwb,GACX,IACI,OAAOA,GACX,CACA,MAAOxsB,GAAM,CACjB,CAEA,IAAIysB,EAAYzb,EAAM,WAAc,OAAOzQ,UAAY,IACnDyQ,EAAM,WAAc,OAAO+F,MAAQ,IACnC/F,EAAM,WAAc,OAAO0b,IAAM,IACjC1b,EAAM,WAAc,OAAO,EAAA4F,CAAQ,IACvC5F,EAAM,WACF,OAAOA,EAAM2b,YAAY,cAAlB3b,EACX,GAEI2T,EAAe,IAAIngB,IAOvB,SAASunB,EAAoBhuB,EAAOiuB,QAClB,IAAVA,IAAoBA,EAAQ,GAChC,IARkBnH,EACdrE,EAOAyL,GARcpH,EAQS,sBAPvBrE,EAAQmE,EAAaviB,IAAIyiB,IAAW,EACxCF,EAAaxhB,IAAI0hB,EAAQrE,EAAQ,GAC1B,GAAGna,OAAOwe,EAAQ,KAAKxe,OAAOma,EAAO,KAAKna,OAAOye,KAAKC,SAAStD,SAAS,IAAI/X,MAAM,KAMzF,OAAOoD,KAAKgB,UAAU/P,EAAO,SAAUsS,EAAKtS,GACxC,YAAiB,IAAVA,EAAmBkuB,EAAUluB,CACxC,EAAGiuB,GACE7f,MAAMW,KAAKgB,UAAUme,IACrBnb,KAAK,cACd,CAEA,SAASqL,EAAKyQ,GACV,OAAO,SAAU5e,GAEb,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,GAAuB,kBAAZsL,EAAsB,CAC7B,IAAI6e,EAAO7e,GACXA,EAAU8e,EAAmBD,MAEzB7e,EAAU+e,EAAoBF,EAAMrpB,GACpCA,EAAO,GAEf,CACAopB,EAAGjpB,WAAM,EAAQ,CAACqK,GAAS3H,OAAO7C,GACtC,CACJ,CACA,IAAIvE,EAAYrB,OAAO0a,OAAO,SAAmB0U,EAAWhf,GAExD,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAExBsqB,GACDT,EAAYttB,UAAU+tB,EAAWF,EAAmB9e,EAASxK,IAASupB,EAAoB/e,EAASxK,GAE3G,EAAG,CACCypB,MAAO9Q,EAAKoQ,EAAYttB,UAAUguB,OAClCC,IAAK/Q,EAAKoQ,EAAYttB,UAAUiuB,KAChCzsB,KAAM0b,EAAKoQ,EAAYttB,UAAUwB,MACjCwI,MAAOkT,EAAKoQ,EAAYttB,UAAUgK,SAUtC,IAAIkkB,EAA4BruB,OAAOC,IAAI,6BAA+B8S,GAC1E,SAAS/D,EAAUoS,GACf,GAAkB,iBAAPA,EACP,OAAOA,EAEX,IACI,OAAO6L,EAAoB7L,EAAK,GAAGxW,MAAM,EAAG,IAChD,CACA,MAAO1J,GACH,MAAO,oBACX,CACJ,CACA,SAAS8sB,EAAmB9e,EAASof,GAEjC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,OAAQye,EAASU,IACbV,EAASU,GAA2Bnf,EAASof,EAAY5f,IAAIM,GACrE,CACA,SAASif,EAAoB/e,EAASof,GAElC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,MAAO,+FAA+F3H,OAAOiK,mBAAmBxD,KAAKgB,UAAU,CAC3I+D,QAASA,EACT7D,QAASA,EACTxK,KAAM4pB,EAAY5f,IAAIM,MAE9B,CAEA,IAAIwX,GAA6B,IAAvB/kB,WAAWC,QAErB1C,EAAQuvB,eAAiBd,EAAYc,eACrCvvB,EAAQwnB,IAAMA,EACdxnB,EAAQ0C,QAAU8kB,EAClBxnB,EAAQkD,OAASyrB,EACjB3uB,EAAQmB,UAAYA,EACpBnB,EAAQkT,MAAQA,EAChBlT,EAAQiQ,kBA9CR,SAA2BC,GAEvB,IADA,IAAIsf,EAAiB,GACZ5qB,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpC4qB,EAAe5qB,EAAK,GAAKe,UAAUf,GAEvC,OAAO,IAAI6pB,EAAYc,eAAeP,EAAmB9e,EAASsf,IAC9DP,EAAoB/e,EAASsf,GACrC,C,yCC5EA1vB,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBC,EAAQ,EAAQ,wBAChBiB,EAAU,EAAQ,wBAClBf,EAAQ,EAAQ,wBAChBD,EAAY,EAAQ,wBACpBqvB,EAAQ,EAAQ,wBAChB3kB,EAAS,EAAQ,wBACjBC,EAAO,EAAQ,wBACf/G,EAAS,EAAQ,wBACjBpB,EAAW,EAAQ,wBACnB6rB,EAAc,EAAQ,wBACtBiB,EAAW,EAAQ,wBACnB3sB,EAAQ,EAAQ,wBAEpB,SAASsD,EAAuB9F,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAW,QAAIA,CAAG,CAE7G,SAASD,EAAkBC,GACvB,GAAIA,GAAKA,EAAEC,WAAY,OAAOD,EAC9B,IAAIE,EAAIX,OAAOY,OAAO,MACtB,GAAIH,EACA,IAAK,IAAII,KAAKJ,EACVE,EAAEE,GAAKJ,EAAEI,GAIjB,OADAF,EAAW,QAAIF,EACRT,OAAOc,OAAOH,EACzB,CAEA,IAAII,EAAgCP,EAAkBH,GAClDmG,EAA8BD,EAAsBopB,GAExD,SAASE,EAAgBC,GACrB,IAAIC,EAAYhvB,EAAiBuB,WAAWhB,EAAQF,oBAChDa,EAAS6tB,GAAYC,EAAU9tB,OAEnC,OADA7B,EAAQiB,YAAYY,EAAQ,IACrBA,CACX,CAEA,IAAI+tB,GAA6B,EAG7BC,EADalvB,EAAwB,sBAErC,SAAW2kB,EAAWwK,EAAaC,GAC/B,IAAIhwB,EAAQ+vB,KAEW,IAAvBvtB,WAAWC,SACNotB,GACD7vB,IAAU+vB,MACVF,GAA6B,GACN,IAAvBrtB,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAM,KAE5D,IAAIjJ,EAAKrB,EAAiBqvB,SAAS,CAC/BC,KAAM,CAAElwB,MAAOA,EAAO+vB,YAAaA,KACnCG,EAAOjuB,EAAG,GAAGiuB,KAAMC,EAAcluB,EAAG,GAsBxC,OArBI9B,EAAUgZ,mBACVvY,EAAiBwvB,gBAAgB,WAC7BvwB,OAAO0a,OAAO2V,EAAM,CAAElwB,MAAOA,EAAO+vB,YAAaA,IAC7CM,EAAuBH,IACvBC,EAAY,CAAED,KAAMA,GAE5B,EAAG,CAAC3K,EAAWvlB,EAAO+vB,IAGtBlwB,OAAO0a,OAAO2V,EAAM,CAAElwB,MAAOA,EAAO+vB,YAAaA,IAErDnvB,EAAiB0vB,UAAU,WAIvB,OAHID,EAAuBH,IACvBC,EAAY,CAAED,KAAMA,IAEjB3K,EAAU,WACT8K,EAAuBH,IACvBC,EAAY,CAAED,KAAMA,GAE5B,EACJ,EAAG,CAAC3K,IACGvlB,CACV,EACL,SAASqwB,EAAuBpuB,GAC5B,IAAIjC,EAAQiC,EAAGjC,MAAO+vB,EAAc9tB,EAAG8tB,YACvC,IACI,OAAO/vB,IAAU+vB,GACrB,CACA,MAAO/nB,GACH,OAAO,CACX,CACJ,CAEA,SAASuoB,EAAYC,EAAQC,GACzB,IAAIC,EAAM9vB,EAAiB+vB,YAAO,GAIlC,OAHKD,EAAIE,SAAYpB,EAAMA,MAAMkB,EAAIE,QAAQH,KAAMA,KAC/CC,EAAIE,QAAU,CAAE5wB,MAAOwwB,IAAUC,KAAMA,IAEpCC,EAAIE,QAAQ5wB,KACvB,CAEA,IAEI6wB,EAFAC,EAA4B3wB,EAAU4Y,UAAYnY,EAAiBwvB,gBAAkBxvB,EAAiB0vB,UAG1G,SAASS,IAAW,CACpB,SAASC,IAIL,OAHKH,IACDA,EAAMjwB,EAAiBQ,cAAc,OAElCR,EAAiBqwB,YAC3B,WACO,IAAIC,EAAOC,QAAQjmB,MACnB,IAGI,OAFAimB,QAAQjmB,MAAQ6lB,EAChBnwB,EAA8B,WAAEiwB,IACzB,CACX,CACA,MAAOvwB,GACH,OAAO,CACX,CACA,QACI6wB,QAAQjmB,MAAQgmB,CACpB,CACJ,EAAG,GACP,CAEA,IAAIluB,EAAsBjC,OAAOC,IAAI,uBACjCowB,EAAWnxB,EAAQgD,OACnBC,EAAO,IAAIP,EAASQ,KAIxB,SAAS6C,EAAiB3C,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,OAAOzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CACA,SAAS4rB,EAAkB5gB,EAASpN,EAAMiuB,EAAUC,QACzB,IAAnBA,IAA6BA,EAAiB,8BAOtD,SAAwBluB,EAAMC,IAlB9B,SAAiBD,GACb,OAAO+tB,EAASpuB,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC7E,EAiBSI,CAAQJ,IACTC,GAER,CAVIF,CAAeC,EAAM,WACbA,KAAQoN,IACe,IAAvBjO,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAAK4uB,EAAUjuB,EAAMkuB,EAEpF,EACJ,CAOA,SAASC,EAAqB/gB,EAASpN,EAAMiuB,EAAUC,QAE5B,IAAnBA,IAA6BA,EAAiB,8BAClD,IAAIE,EAAU7wB,EAAiB+vB,QAAO,GAClCttB,KAAQoN,IAAYghB,EAAQb,WACL,IAAvBpuB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAAI4uB,EAAUjuB,EAAMkuB,GAC3EE,EAAQb,SAAU,EAE1B,CAEA,IAEIc,EADW9wB,EAAuB,KAElC,SAAeyM,GACX,IAAIskB,EAAkBxxB,EAAUiuB,qBAAqB/gB,GACrD,OAAQskB,EAAgB9iB,QACpB,IAAK,UACD,MAAM8iB,EACV,IAAK,WACD,MAAMA,EAAgBjM,OAC1B,IAAK,YACD,OAAOiM,EAAgB3xB,MAEnC,EAEA4xB,EAAgB7wB,OAAOC,IAAI,wBAC/B,SAAS6wB,EAASC,EAAUC,EAASC,GACjC,IAAIC,EAAeD,EAA+B,aAC9CE,EAAWD,GAAgBA,EAAaL,GACxCO,EAAUD,GAAYA,EAASJ,GACnC,OAAOK,EAAUA,EAAQJ,GAAWA,CACxC,CAEA,IAAIhkB,EAAiBlO,OAAOmO,UAAUD,eACtC,SAASqkB,IAAS,CAClB,IAAIC,EAAmBtxB,SAKvB,SAASuxB,EAAU9gB,EAAOf,IACK,IAAvBjO,WAAWC,UACX+uB,EAAqB/gB,EAAS,kBAAmB,YACjD+gB,EAAqB/gB,EAAS,iBAAkB,YAChD+gB,EAAqB/gB,EAAS,iBAAkB,WAAY,kDAC5D+gB,EAAqB/gB,EAAS,cAAe,WAAY,uMACzD+gB,EAAqB/gB,EAAS,UAAW,WAAY,0PAEzD,IAAIxO,EAAKswB,EAAkB/gB,EAAOf,GAAUlB,EAAStN,EAAGsN,OAAQijB,EAAiBvwB,EAAGuwB,eACpF,OAAO5xB,EAAiBwB,QAAQ,WAAc,OAAQhC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAASijB,EAAkB,EAAG,CAACjjB,EAAQijB,GACnI,CA2CA,SAASD,EAAkB/gB,EAAOf,GAC9B,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjC2wB,EAAiB7xB,EAAiBuB,WAAWhB,EAAQF,oBAAoBwxB,eACzEC,IAAcD,EACdE,EAAwB7wB,EAAO6wB,sBAC/BC,GAA6B,IAAhBniB,EAAQoiB,MAAkBpiB,EAAQqiB,KAC/CC,EAAiBtiB,EAAQsiB,eACzBC,EAAwBC,EAA4BnxB,EAAQ0P,EAAOf,EAASiiB,GAC5EzwB,EAlDR,SAA0BH,EAAQ0P,EAAOf,EAASgiB,EAAgBO,GAC9D,SAASE,EAAoBrW,GACzB,IAAI5a,EAiBJ,OAhBA8B,EAAOyB,mBAAmBgM,EAAOzN,EAAOlB,aAAae,OACjC,CAChB9B,OAAQA,EACR0P,MAAOA,EACPqW,WACC4K,GACGA,EAAeU,iBAAiBH,MAChCloB,EAAKsoB,gBAAoC,mBAAEztB,WAAW8sB,EAAgB,WAClE,OAAOzsB,EAAiB,kBAAmB,WACvC,OAAOlE,EAAOuxB,WAAWC,OAAmB,EAAQxxB,EAAQ2O,EAASuiB,KACzE,EACJ,GACJO,WAAY,CACRC,aAAyG,QAA1FvxB,EAAkB,OAAb4a,QAAkC,IAAbA,OAAsB,EAASA,EAAS0W,WAAW3C,eAA4B,IAAP3uB,OAAgB,EAASA,EAAGiF,MAIzJ,CACA,IAAIjF,EAAKrB,EAAiBqvB,SAASiD,GAAsBO,EAAgBxxB,EAAG,GAAIyxB,EAAsBzxB,EAAG,GACzG,SAAS0xB,EAAgBC,GACrB,IAAI3xB,EACA+F,EACJnI,OAAO0a,OAAOkZ,EAAc5L,aAAa5lB,EAAK,CAAC,GACxCowB,GAAoBuB,EACvB3xB,IACJ,IAAIsxB,EAAaE,EAAcF,WAC/BG,EAAoBtzB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoxB,GAAgB,CAClEjiB,MAAOoiB,EAAkBpiB,MAAO+hB,WAAY1zB,OAAO0a,OAAOgZ,EAAY,CAClEC,cAA6C,QAA7BxrB,EAAKurB,EAAW3C,eAA4B,IAAP5oB,OAAgB,EAASA,EAAGd,OAASqsB,EAAWC,aACrG5C,aAAStrB,MAErB,CACA,GAAIxD,IAAW2xB,EAAc3xB,QAAU0P,IAAUiiB,EAAcjiB,MAAO,CAClE,IAAIqiB,EAAmBX,EAAoBO,GAE3C,OADAC,EAAoBG,GACb,CAACA,EAAkBF,EAC9B,CACA,MAAO,CAACF,EAAeE,EAC3B,CASaG,CAAiBhyB,EAAQ0P,EAAOf,EAASgiB,EAAgBO,GAAwBhrB,EAAK/F,EAAG,GAAI4lB,EAAa7f,EAAG6f,WAAY0L,EAAavrB,EAAGurB,WAAYI,EAAkB1xB,EAAG,GAC/K2xB,EAAoBZ,EAAsBnL,IAiGlD,SACA0L,EACA1L,EAAY/lB,EAAQ2O,EAASmjB,GACzB,IAAI3xB,EACA4lB,EAAWwK,KACV7C,EAAMA,MAAM3H,EAAWwK,GAAmBuB,KAC3C/L,EAAWkM,UAAUT,EAAmBzL,EAAY/lB,EAAQ2O,EAASmjB,IACrEL,EAAWC,cACwB,QAA7BvxB,EAAKsxB,EAAW3C,eAA4B,IAAP3uB,OAAgB,EAASA,EAAGiF,OAASqsB,EAAWC,aAC3FD,EAAW3C,aAAU,GAEzB/I,EAAWwK,GAAoBuB,CACnC,CA5GII,CAA0BT,EAC1B1L,EACA/lB,EAAQ2O,EAASmjB,GACjB,IAAIpB,EAAiB5xB,EAAiBwB,QAAQ,WAAc,OA8NhE,SAA+BylB,GAC3B,MAAO,CACHoM,QAASpM,EAAWoM,QAAQ9e,KAAK0S,GACjCkM,UAAW,WAEP,IADA,IAAItuB,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,GAAMe,UAAUf,GAKzB,OAH2B,IAAvBnC,WAAWC,UACY,IAAvBD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAEpDmlB,EAAWkM,UAAUnuB,MAAMiiB,EAAYpiB,EAClD,EACAyuB,UAAWrM,EAAWqM,UAAU/e,KAAK0S,GACrCsM,YAAatM,EAAWsM,YAAYhf,KAAK0S,GACzCuM,aAAcvM,EAAWuM,aAAajf,KAAK0S,GAC3CwM,YAAaxM,EAAWwM,YAAYlf,KAAK0S,GACzCyM,gBAAiBzM,EAAWyM,gBAAgBnf,KAAK0S,GAEzD,CAjPuE0M,CAAsB1M,EAAa,EAAG,CAACA,KAqF9G,SAAkCA,EAAY4K,EAAgBG,GACtDH,GAAkBG,IAClBH,EAAe+B,sBAAsB3M,GACjCA,EAAW4M,mBAAmBC,SAC9BjC,EAAekC,0BAA0B9M,GAGrD,CA3FI+M,CAAyB/M,EAAY4K,EAAgBG,GACrD,IAAIrjB,EAaR,SAAyCgkB,EAAY1L,EAAY/lB,EAAQ2O,EAASmjB,EAAmBjB,EAAuBI,EAAgBL,EAAWmC,GACnJ,IAAIC,EAAcl0B,EAAiB+vB,OAAOkE,GAC1Cj0B,EAAiB0vB,UAAU,WACvBwE,EAAYlE,QAAUiE,CAC1B,GACA,IAAIE,GAAmBrC,IAAaC,IAChB,IAAhBliB,EAAQoiB,KACPpiB,EAAQqiB,KAEPriB,EAAQqiB,MAA0C,YAAlCc,EAAkBoB,YAChCC,OACE,EAHNC,EAIA1B,EAAeD,EAAWC,aAC1B2B,EAAwBv0B,EAAiBwB,QAAQ,WACjD,OAAO2yB,GACHK,EAAcL,EAAgBvB,EAAc3L,EAAY/lB,EAChE,EAAG,CAACA,EAAQ+lB,EAAYkN,EAAgBvB,IACxC,OAAO1D,EAAqBlvB,EAAiBqwB,YAAY,SAAUoE,GAC/D,GAAI3C,EACA,OAAO,WAAc,EAEzB,IAAI4C,EAAS,WACT,IAAIC,EAAiBhC,EAAW3C,QAC5BrhB,EAASsY,EAAW4M,mBACpBc,GACAA,EAAeb,UAAYnlB,EAAOmlB,SAClCa,EAAeC,gBAAkBjmB,EAAOimB,eACxChG,EAAMA,MAAM+F,EAAeruB,KAAMqI,EAAOrI,OAG5CuuB,EAAUlmB,EAAQgkB,EAAY1L,EAAY/lB,EAAQixB,EAAgBsC,EAAmBP,EAAYlE,QACrG,EACInlB,EAAU,SAAUP,GAGpB,GAFAwqB,EAAa9E,QAAQtL,cACrBoQ,EAAa9E,QAAU/I,EAAW8N,sBAAsBL,EAAQ7pB,IAC3DsC,EAAeyB,KAAKtE,EAAO,iBAC5B,MAAMA,EAEV,IAAIqqB,EAAiBhC,EAAW3C,UAC3B2E,GACAA,GAAkBA,EAAeb,UACjClF,EAAMA,MAAMtkB,EAAOqqB,EAAerqB,SACnCuqB,EAAU,CACNvuB,KAAOquB,GACHA,EAAeruB,KACnBgE,MAAOA,EACPwpB,SAAS,EACTc,cAAe1qB,EAAK8qB,cAAc1qB,OACnCqoB,EAAY1L,EAAY/lB,EAAQixB,EAAgBsC,EAAmBP,EAAYlE,QAE1F,EACI8E,EAAe,CAAE9E,QAAS/I,EAAWtC,UAAU+P,EAAQ7pB,IAC3D,OAAO,WACHmO,WAAW,WAAc,OAAO8b,EAAa9E,QAAQtL,aAAe,EACxE,CACJ,EAAG,CACCqN,EACAD,EACA7K,EACA0L,EACAR,EACAjxB,IACA,WACA,OAAOqzB,GACHV,EAAiBlB,EAAY1L,EAAYiN,EAAYlE,QAASmC,EAAgBjxB,EACtF,EAAG,WACC,OAAOqzB,GACHV,EAAiBlB,EAAY1L,EAAYiN,EAAYlE,QAASmC,EAAgBjxB,EACtF,EACJ,CAlFiB+zB,CAAgCtC,EAAY1L,EAAY/lB,EAAQ2O,EAASmjB,EAAmBjB,EAAuBI,EAAgBL,EAAW,CACvJoD,YAAarlB,EAAQqlB,aAAe1D,EACpC3mB,QAASgF,EAAQhF,SAAW2mB,IAEhC,MAAO,CACH7iB,OAAQA,EACRijB,eAAgBA,EAChB3K,WAAYA,EACZ0L,WAAYA,EACZzxB,OAAQA,EACR6xB,gBAAiBA,EAEzB,CA4FA,SAASV,EAA4BnxB,EAAQ0P,EAAOvP,EAAIywB,QACzC,IAAPzwB,IAAiBA,EAAK,CAAC,GAC3B,IAAI6wB,EAAO7wB,EAAG6wB,KAAM7wB,EAAG4wB,IAAK5wB,EAAG6zB,YAAa7zB,EAAGwJ,QAAS,IAAIsqB,EAAiB9zB,EAAG8zB,eAChFC,EAAe51B,EAAMoT,OAAOvR,EAAI,CAAC,OAAQ,MAAO,cAAe,UAAW,mBAC1E,OAAO,SAAU4lB,GACb,IAAI+L,EAAoB/zB,OAAO0a,OAAOyb,EAAc,CAAExkB,MAAOA,IAqB7D,OApBIkhB,GACmC,iBAAlCkB,EAAkBoB,aACmB,sBAAlCpB,EAAkBoB,cACtBpB,EAAkBoB,YAAc,eAE/BpB,EAAkBzvB,YACnByvB,EAAkBzvB,UAAY,CAAC,GAE/B2uB,GACAc,EAAkBqC,mBACdrC,EAAkBqC,oBACdrC,EAAkBoB,aAClBkB,EAAsBH,EAAgBj0B,EAAOi0B,gBACrDnC,EAAkBoB,YAAc,WAE1BpB,EAAkBoB,cACxBpB,EAAkBoB,aACE,OAAfnN,QAAsC,IAAfA,OAAwB,EAASA,EAAWpX,QAAQwlB,qBACxEC,EAAsBH,EAAgBj0B,EAAOi0B,iBAElDnC,CACX,CACJ,CACA,SAASN,EAAmBzL,EAAY/lB,EAAQq0B,EAAkBvC,GAC9D,IAAIwC,EAAU,GACVC,EAAiBv0B,EAAOi0B,eAAe1C,WAO3C,OANIgD,GACAD,EAAQpxB,KAAKqxB,GACbF,EAAiBJ,gBACjBK,EAAQpxB,KAAKmxB,EAAiBJ,gBAElCK,EAAQpxB,KAAK7E,EAAUumB,QAAQmB,GAAcA,EAAWpX,QAASmjB,IAC1DwC,EAAQE,OAAOn2B,EAAUkrB,aACpC,CACA,SAASoK,EAAUc,EAAYhD,EAAY1L,EAAY/lB,EAAQixB,EAAgB5C,EAAa0E,GACxF,IAAIU,EAAiBhC,EAAW3C,QAC5B2E,GAAkBA,EAAeruB,OACjCqsB,EAAWC,aAAe+B,EAAeruB,OAExCqvB,EAAWrrB,OAAS/K,EAAUue,gBAAgB6X,EAAW1rB,UAC1D0rB,EAAWrrB,MAAQ,IAAIL,EAAO2rB,YAAY,CAAEjQ,cAAegQ,EAAW1rB,UAE1E0oB,EAAW3C,QAAUwE,EA6CzB,SAAoC7lB,EAAQsY,EAAYkL,GACpD,GAAIxjB,EAAOknB,SACP1D,IACCxjB,EAAOmlB,WACNnlB,EAAOrI,MAA4C,IAApCrH,OAAOkK,KAAKwF,EAAOrI,MAAMrC,SACP,eAAnCgjB,EAAWpX,QAAQukB,YAEnB,OADAnN,EAAWoM,UACJ7zB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAAS,CAAEmlB,SAAS,EAAMc,cAAe1qB,EAAK8qB,cAAc3B,UAEzG,OAAO1kB,CACX,CAvDuCmnB,CAA2BH,EAAY1O,EAAYkL,GAAiBQ,EAAWC,aAAc3L,EAAY/lB,GAC5IquB,IAGJ,SAAgC5gB,EAAQonB,EAAuB9B,GAC3D,IAAKtlB,EAAOmlB,QAAS,CACjB,IAAIkC,EAAUC,EAAgBtnB,GAC9BpD,QAAQC,UACHmB,KAAK,WACFqpB,EACA/B,EAAUppB,QAAQmrB,GAEbrnB,EAAOrI,MACZyvB,IAA0BpnB,EAAOimB,eACjCjmB,EAAOimB,gBAAkB1qB,EAAK8qB,cAAckB,OAC5CjC,EAAUiB,YAAYvmB,EAAOrI,KAErC,GACKsG,MAAM,SAAUtC,IACM,IAAvB1I,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAKwI,EAC3D,EACJ,CACJ,CApBI6rB,CAAuBR,EAA+B,OAAnBhB,QAA8C,IAAnBA,OAA4B,EAASA,EAAeC,cAAeX,EACrI,CAoBA,SAASJ,EAAiBlB,EAAY1L,EAAYgN,EAAW9B,EAAgBjxB,GAIzE,OAHKyxB,EAAW3C,SACZ6E,EAAU5N,EAAW4M,mBAAoBlB,EAAY1L,EAAY/lB,EAAQixB,EAAgB,WAAc,EAAG8B,GAEvGtB,EAAW3C,OACtB,CACA,SAASsF,EAAsBc,EAAyBC,GACpD,IAAIh1B,EACJ,OAAqC,OAA5B+0B,QAAgE,IAA5BA,OAAqC,EAASA,EAAwBhC,eACS,QAAtH/yB,EAA8B,OAAzBg1B,QAA0D,IAAzBA,OAAkC,EAASA,EAAqB5D,kBAA+B,IAAPpxB,OAAgB,EAASA,EAAG+yB,cAC5J,aACR,CACA,SAAS6B,EAAgBtnB,GACrB,OAAOpP,EAAUue,gBAAgBnP,EAAO1E,QACpC,IAAIA,EAAO2rB,YAAY,CAAEjQ,cAAehX,EAAO1E,SAC7C0E,EAAOrE,KACjB,CACA,SAASkqB,EAAc7lB,EAAQikB,EAAc3L,EAAY/lB,GACrD,IAAIoF,EAAOqI,EAAOrI,KAAMqI,EAAOknB,QAAS,IAAIS,EAAuB92B,EAAMoT,OAAOjE,EAAQ,CAAC,OAAQ,YAEjG,OADkBnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAE6E,KAAMA,GAAQgwB,GAAuB,CAAEp1B,OAAQA,EAAQ+lB,WAAYA,EAAY1jB,UAAW0jB,EAAW1jB,UAAWgiB,OAAQ5W,IAAW2lB,GAAqB3lB,IAAW0lB,EAAmBzB,aAAcA,GAE1P,CAYA,IAAI0B,EAAoB/0B,EAAUoH,gBAAgB,CAC9CmtB,SAAS,EACTxtB,UAAM,EACNgE,WAAO,EACPsqB,cAAe1qB,EAAK8qB,cAAclB,UAElCO,EAAoB90B,EAAUoH,gBAAgB,CAC9CmtB,SAAS,EACTxtB,UAAM,EACNgE,WAAO,EACPsqB,cAAe1qB,EAAK8qB,cAAckB,QAuBtC,IAAIhjB,EAAU,SAEd,SAASb,EAAMwb,GACX,IACI,OAAOA,GACX,CACA,MAAOxsB,GAAM,CACjB,CAEA,IAAIysB,GAAYzb,EAAM,WAAc,OAAOzQ,UAAY,IACnDyQ,EAAM,WAAc,OAAO+F,MAAQ,IACnC/F,EAAM,WAAc,OAAO0b,IAAM,IACjC1b,EAAM,WAAc,OAAO,EAAA4F,CAAQ,IACvC5F,EAAM,WACF,OAAOA,EAAM2b,YAAY,cAAlB3b,EACX,GAEI2T,GAAe,IAAIngB,IAOvB,SAASunB,GAAoBhuB,EAAOiuB,QAClB,IAAVA,IAAoBA,EAAQ,GAChC,IARkBnH,EACdrE,EAOAyL,GARcpH,EAQS,sBAPvBrE,EAAQmE,GAAaviB,IAAIyiB,IAAW,EACxCF,GAAaxhB,IAAI0hB,EAAQrE,EAAQ,GAC1B,GAAGna,OAAOwe,EAAQ,KAAKxe,OAAOma,EAAO,KAAKna,OAAOye,KAAKC,SAAStD,SAAS,IAAI/X,MAAM,KAMzF,OAAOoD,KAAKgB,UAAU/P,EAAO,SAAUsS,EAAKtS,GACxC,YAAiB,IAAVA,EAAmBkuB,EAAUluB,CACxC,EAAGiuB,GACE7f,MAAMW,KAAKgB,UAAUme,IACrBnb,KAAK,cACd,CAEA,SAASqL,GAAKyQ,GACV,OAAO,SAAU5e,GAEb,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,GAAuB,kBAAZsL,EAAsB,CAC7B,IAAI6e,EAAO7e,GACXA,EAAU8e,GAAmBD,MAEzB7e,EAAU+e,GAAoBF,EAAMrpB,GACpCA,EAAO,GAEf,CACAopB,EAAGjpB,WAAM,EAAQ,CAACqK,GAAS3H,OAAO7C,GACtC,CACJ,CACA,IAAIvE,GAAYrB,OAAO0a,OAAO,SAAmB0U,EAAWhf,GAExD,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAExBsqB,GACDT,EAAYttB,UAAU+tB,EAAWF,GAAmB9e,EAASxK,IAASupB,GAAoB/e,EAASxK,GAE3G,EAAG,CACCypB,MAAO9Q,GAAKoQ,EAAYttB,UAAUguB,OAClCC,IAAK/Q,GAAKoQ,EAAYttB,UAAUiuB,KAChCzsB,KAAM0b,GAAKoQ,EAAYttB,UAAUwB,MACjCwI,MAAOkT,GAAKoQ,EAAYttB,UAAUgK,SAElCkkB,GAA4BruB,OAAOC,IAAI,6BAA+B8S,GAC1E,SAAS/D,GAAUoS,GACf,GAAkB,iBAAPA,EACP,OAAOA,EAEX,IACI,OAAO6L,GAAoB7L,EAAK,GAAGxW,MAAM,EAAG,IAChD,CACA,MAAO1J,GACH,MAAO,oBACX,CACJ,CACA,SAAS8sB,GAAmB9e,EAASof,GAEjC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,OAAQye,GAASU,KACbV,GAASU,IAA2Bnf,EAASof,EAAY5f,IAAIM,IACrE,CACA,SAASif,GAAoB/e,EAASof,GAElC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,MAAO,+FAA+F3H,OAAOiK,mBAAmBxD,KAAKgB,UAAU,CAC3I+D,QAASA,EACT7D,QAASA,EACTxK,KAAM4pB,EAAY5f,IAAIM,OAE9B,CAEA,IAAIonB,GAAgB,CAChB,UACA,YACA,YACA,cACA,eACA,cACA,mBAEAC,GAA0B,CAC1B,qBACA,cACA,UACA,iBACA,iBACA,mBAEAC,GAA6B,CAC7B,QACA,MACA,SACA,cACA,kBACA,qBACA,cACA,eACA,8BACA,oBACA,mBAmaJ,SAASC,GAAa7mB,IACS,IAAvBjO,WAAWC,SACX+uB,EAAqB/gB,EAAS,kBAAmB,eAErD,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjCgB,EAAQhB,EAAOgB,MACfmF,EAAOwI,EAAQxI,KAAMsvB,EAAOn3B,EAAMoT,OAAO/C,EAAS,CAAC,SACnDqa,EAAKlqB,EAAiBwB,QAAQ,WAC9B,MAAuB,kBAAT6F,EAAoBA,EACnB,OAATA,EAAgB,KACZnF,EAAM00B,SAASvvB,EAC7B,EAAG,CAACnF,EAAOmF,IACPwvB,EAAgBlH,EAAY,WAAc,OAAQnwB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGk1B,GAAO,CAAEtvB,KAAM6iB,GAAQ,EAAG,CAACyM,EAAMzM,IACrH4M,EAAO92B,EAAiBwB,QAAQ,WAChC,IAAIsH,EAAW+tB,EAAc/tB,SAAUD,EAAeguB,EAAchuB,aAAcxB,EAAOwvB,EAAcxvB,KAAMhG,EAAKw1B,EAAcE,WAAYA,OAAoB,IAAP11B,GAAuBA,EAChL,GAAa,OAATgG,EACA,MAAO,CACHsH,OAAQqoB,GAAa,CACjBroB,OAAQ,CAAC,EACToH,UAAU,KAItB,IAAI7T,EAAQhB,EAAOgB,MACf40B,EAAO1xB,EAAiB,kBAAmB,WAC3C,OAAOlD,EAAM40B,KAAKt3B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGo1B,GAAgB,CAAEI,mBAAmB,EAAM/M,GAAI7iB,EAAMuJ,MAAO1O,EAAsB,eAAE4G,EAAUD,GAAekuB,WAAYA,IACjL,GACA,MAAO,CACHpoB,OAAQqoB,GAAax3B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGq1B,GAAO,CAAEnoB,OAAQzN,EAAqB,aAAEqI,aAAa,CACpGT,SAAUA,EACVD,aAAcA,EACdvC,KAAMwwB,EAAKnoB,YAG3B,EAAG,CAACzN,EAAQ21B,IACR1H,EAAcnvB,EAAiBqwB,YAAY,WAAc,OAAOyG,EAAKnoB,MAAQ,EAAG,CAACmoB,IACrF,OAAO5H,EAAqBlvB,EAAiBqwB,YAAY,SAAUd,GAC/D,IAAI2H,EAAc,EACdpC,EAAe1vB,EAAiB,kBAAmB,WACnD,OAA8B,OAAvByxB,EAAcxvB,KACjB,KACEnG,EAAOi2B,cAAcN,GAAelS,UAAU,CAC5CrZ,KAAM,SAAUqD,GACRlJ,EAAekJ,EAAQmoB,EAAKnoB,UAEhCmoB,EAAKnoB,OAASA,EACdyoB,aAAaF,GACbA,EAAcle,WAAWuW,GAC7B,GAEZ,GACA,OAAO,WACc,OAAjBuF,QAA0C,IAAjBA,GAAmCA,EAAapQ,cACzE0S,aAAaF,EACjB,CACJ,EAAG,CAACh2B,EAAQ21B,EAAeC,IAAQ3H,EAAaA,EACpD,CACA,SAAS6H,GAAaF,GAClB,IAAInoB,EAAS,CACTrI,KAAMwwB,EAAKnoB,OACXoH,WAAY+gB,EAAK/gB,UAKrB,OAHI+gB,EAAKO,UACL1oB,EAAO0oB,QAAU93B,EAAUoiB,eAAemV,EAAKO,QAAQxoB,IAAI,SAAUvE,GAAS,OAAOA,EAAM+sB,OAAS,KAEjG1oB,CACX,CAEA,IAAI2oB,GAAYn3B,OAAOC,IAAI,oBAO3B,SAASm3B,GAAkB3mB,EAAOf,IACH,IAAvBjO,WAAWC,SACX+uB,EAAwC,kBAAZ/gB,EAAuB,CAAC,EAAIA,EAAS,kBAAmB,oBAExF,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjCs2B,EAAgB3I,EAAS4I,iBAAiBv2B,GAC1C8xB,EAAoB0E,GAAqB,CACzCx2B,OAAQA,EACR0P,MAAOA,EACPf,QAASA,IAETukB,EAAcpB,EAAkBoB,YAAa7wB,EAAYyvB,EAAkBzvB,UAC3ElC,EAAKwO,EAAQ8nB,SAAUA,OAAkB,IAAPt2B,EAAgB,GAAKA,EACvDu2B,EAAWp4B,EAAMyF,cAAc,CAC/B2L,EACA1O,EAAMwX,mBAAmBnW,IAC1B,GAAGmE,OAAOiwB,IAAW,GACpBE,EAAWzyB,EAAiB,kBAAmB,WAC/C,OAAOoyB,EAAcM,YAAYF,EAAU,WACvC,OAAO12B,EAAOuxB,WAAWO,EAC7B,EACJ,GACI5rB,EAAKpH,EAAiBqvB,SAAS,CAACwI,EAASnmB,IAAKmmB,EAASprB,UAAWujB,EAAU5oB,EAAG,GAAI2wB,EAAa3wB,EAAG,GACnG4oB,EAAQ,KAAO6H,EAASnmB,MACxBse,EAAQ,GAAK6H,EAASnmB,IACtBse,EAAQ,GAAK6H,EAASprB,SAE1B,IAAIA,EAAUujB,EAAQ,GAClB6H,EAASG,iBAAiBhF,KAC1BhD,EAAQ,GAAKvjB,EAAUorB,EAASI,aAAajF,IAEjDhzB,EAAiB0vB,UAAU,WACvB,IAAIxW,EAAU2e,EAASK,SACnB/sB,EAAiB0sB,EAASM,OAAO,SAAU1rB,GAC3CsrB,EAAW,CAACF,EAASnmB,IAAKjF,GAC9B,GACA,OAAO,WACHtB,IACA+N,GACJ,CACJ,EAAG,CAAC2e,IACJ,IAAIO,EAAap4B,EAAiBwB,QAAQ,WACtC,IAAI8I,EAAQ+tB,GAAcR,EAASlpB,QACnC,MAAO,CACHmlB,SAAS,EACTxtB,KAAMuxB,EAASlpB,OAAOrI,KACtBsuB,cAAetqB,EAAQJ,EAAK8qB,cAAc1qB,MAAQJ,EAAK8qB,cAAckB,MACrE5rB,MAAOA,EAEf,EAAG,CAACutB,EAASlpB,SACTA,EAAyB,YAAhBylB,EAA4BgE,EAAatH,EAAMrkB,GACxD6mB,EAAYtzB,EAAiBqwB,YAAY,SAAUxgB,GACnD,IAAIpD,EAAUorB,EAASvE,UAAUzjB,GAEjC,OADAkoB,EAAW,CAACF,EAASnmB,IAAKmmB,EAASprB,UAC5BA,CACX,EAAG,CAACorB,IACAxE,EAAUrzB,EAAiBqwB,YAAY,SAAU9sB,GACjD,IAAIkJ,EAAUorB,EAASxE,QAAQ9vB,GAE/B,OADAw0B,EAAW,CAACF,EAASnmB,IAAKmmB,EAASprB,UAC5BA,CACX,EAAG,CAACorB,IACAnE,EAAkBmE,EAAS5Q,WAC1ByM,gBACL,OAAO1zB,EAAiBwB,QAAQ,WAC5B,MAAO,CACHN,OAAQA,EACRoF,KAAMqI,EAAOrI,KACbgE,MAAO+tB,GAAc1pB,GACrBimB,cAAejmB,EAAOimB,cACtBtB,UAAWA,EACXD,QAASA,EACTK,gBAAiBA,EAEzB,EAAG,CAACxyB,EAAQoyB,EAAWD,EAAS1kB,EAAQ+kB,GAC5C,CACA,SAAS4E,GAAgBzoB,GACrB,IAAIe,EAAQf,EAAQe,MAAOwjB,EAAcvkB,EAAQukB,YAAa6C,EAAoBpnB,EAAQonB,kBAC1F9zB,EAAOyB,mBAAmBgM,EAAOzN,EAAOlB,aAAae,OAIzD,SAA6BoxB,QACL,IAAhBA,IAA0BA,EAAc,eAC5C,IAAImE,EAAyB,CACzB,cACA,eACA,WACA,qBAEJl5B,EAAQiB,UAAUi4B,EAAuB31B,SAASwxB,GAAc,GAAIA,EACxE,CAZIoE,CAAoBpE,GAaxB,SAAmCA,EAAa6C,GACxB,aAAhB7C,GAA8B6C,IACP,IAAvBr1B,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAE/D,CAhBI22B,CAA0BrE,EAAa6C,EAC3C,CAgBA,SAASoB,GAAc1pB,GACnB,OAAOpP,EAAUue,gBAAgBnP,EAAO1E,QACpC,IAAIC,EAAK0rB,YAAY,CAAEjQ,cAAehX,EAAO1E,SAC3C0E,EAAOrE,KACjB,CACA,SAASotB,GAAqBr2B,GAC1B,IAAIH,EAASG,EAAGH,OAAQ0P,EAAQvP,EAAGuP,MAAOf,EAAUxO,EAAGwO,QACvD,OAAO8f,EAAY,WACf,IAAItuB,EACJ,GAAIwO,IAAYynB,GACZ,MAAO,CAAE1mB,MAAOA,EAAOwjB,YAAa,WAExC,IAAIA,EAAcvkB,EAAQukB,cACuB,QAA3C/yB,EAAKH,EAAOi0B,eAAe1C,kBAA+B,IAAPpxB,OAAgB,EAASA,EAAG+yB,cACjF,cACApB,EAAoBxzB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEukB,YAAaA,EAAaxjB,MAAOA,EAAO8nB,6BAA6B,EAAOC,qBAAiB,IAOnK,OAN2B,IAAvB/2B,WAAWC,SACXy2B,GAAgBtF,GAEhBnjB,EAAQqiB,OACRc,EAAkBoB,YAAc,WAE7BpB,CACX,EAAG,CAAC9xB,EAAQ2O,EAASe,GACzB,CAOA,SAASgoB,GAAoBhoB,EAAOf,IACL,IAAvBjO,WAAWC,SACX+uB,EAAwC,kBAAZ/gB,EAAuB,CAAC,EAAIA,EAAS,kBAAmB,sBAExF,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjCs2B,EAAgB3I,EAAS4I,iBAAiBv2B,GAC1C8xB,EAAoB0E,GAAqB,CAAEx2B,OAAQA,EAAQ0P,MAAOA,EAAOf,QAASA,IAClFukB,EAAcpB,EAAkBoB,YAAa7wB,EAAYyvB,EAAkBzvB,UAC3ElC,EAAKwO,EAAQ8nB,SAAUA,OAAkB,IAAPt2B,EAAgB,GAAKA,EACvDw3B,EAAiB74B,EAAiB+vB,OAAuB,YAAhBqE,GAC7CyE,EAAe7I,UAAY6I,EAAe7I,QAA0B,YAAhBoE,GACpD,IAAIwD,EAAWp4B,EAAMyF,cAAc,CAC/B2L,EACA1O,EAAMwX,mBAAmBnW,IAC1B,GAAGmE,OAAOiwB,IAAW,GACpBE,EAAWzyB,EAAiB,kBAAmB,WAC/C,OAAOoyB,EAAcM,YAAYF,EAAU,WACvC,OAAO12B,EAAOuxB,WAAWO,EAC7B,EACJ,GACI5rB,EAAKpH,EAAiBqvB,SAASR,EAASiK,aAAajB,IAAYkB,EAAkB3xB,EAAG,GAAI4xB,EAAqB5xB,EAAG,GAItH,GAHIynB,EAASoK,eAAeF,KAAqBlB,GAC7CmB,EAAmBnK,EAASiK,aAAajB,IAEzCA,EAASG,iBAAiBhF,GAAoB,CAC9C,IAAIvmB,EAAUorB,EAASI,aAAajF,GACpCnE,EAASqK,sBAAsBH,EAAiBtsB,EACpD,CACAzM,EAAiB0vB,UAAU,WACvB,IAAIxF,EAAKlR,WAAW,WACZ6e,EAASsB,UACT3B,EAAc7vB,IAAIiwB,EAAUC,EAEpC,GACA,OAAO,WAAc,OAAOT,aAAalN,EAAK,CAClD,GACA,IAAIoJ,EAAYtzB,EAAiBqwB,YAAY,SAAUxgB,GACnD,IAAIpD,EAAUorB,EAASvE,UAAUzjB,GAEjC,OADAmpB,EAAmBnK,EAASiK,aAAajB,IAClCprB,CACX,EAAG,CAACorB,IACAxE,EAAUrzB,EAAiBqwB,YAAY,SAAU9sB,GACjD,IAAIkJ,EAAUorB,EAASxE,QAAQ9vB,GAE/B,OADAy1B,EAAmBnK,EAASiK,aAAajB,IAClCprB,CACX,EAAG,CAACorB,IAEJ,OADA73B,EAAiB0vB,UAAU,WAAc,OAAOmI,EAASuB,YAAc,EAAG,CAACvB,IACpE,CACHgB,EAAe7I,QAAU+I,OAAkB,EAC3C,CACIzF,UAAWA,EACXD,QAASA,EACTK,gBAAiBmE,EAAS5Q,WACrByM,iBAGjB,CAEA,IAAI2F,GAAmB,GAKvB,SAASC,GAAqBzpB,GAC1B,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjCmG,EAAOwI,EAAQxI,KAAM9D,EAAYsM,EAAQtM,UACzCg2B,EAAUr4B,EAAOgB,MACjBgoB,EAAKlqB,EAAiBwB,QAAQ,WAC9B,MAAuB,kBAAT6F,EAAoBA,EACnB,OAATA,EAAgB,KACZkyB,EAAQ3C,SAASvvB,EAC/B,EAAG,CAACkyB,EAASlyB,IACTmyB,EAAqB,OAAPtP,EAAc,KAAQ2E,EAAS4I,iBAAiBv2B,GAAQu4B,eAAe,CAACvP,EAAIra,EAAQ/G,SAAU5G,EAAMwX,mBAAmBnW,IAAarC,EAAQ1B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEtM,UAAWA,EAAW8D,KAAM6iB,KACpO7oB,EAAKrB,EAAiBqvB,SAAyB,OAAhBmK,EAAuBH,GAAmB,CAAEG,EAAY9nB,IAAK8nB,EAAY/sB,UAAYujB,EAAU3uB,EAAG,GAAI02B,EAAa12B,EAAG,GAczJ,OAbArB,EAAiB0vB,UAAU,WACvB,GAAoB,OAAhB8J,EAAJ,CAGA,IAAItgB,EAAUsgB,EAAYtB,SACtB/sB,EAAiBquB,EAAYrB,OAAO,SAAU1rB,GAC9CsrB,EAAW,CAACyB,EAAY9nB,IAAKjF,GACjC,GACA,OAAO,WACHyM,IACA/N,GACJ,CARA,CASJ,EAAG,CAACquB,IACgB,OAAhBA,EACO,CAAElzB,KAAM,OAEf0pB,EAAQ,KAAOwJ,EAAY9nB,MAC3Bse,EAAQ,GAAKwJ,EAAY9nB,IACzBse,EAAQ,GAAKwJ,EAAY/sB,SAGtB,CAAEnG,KADEwqB,EAAMd,EAAQ,KAE7B,CA+EA,SAAS0J,GAAqB7B,GAC1BhJ,EAAS8K,sBAAsB9B,GAC/B,IAAIx2B,EAAKrB,EAAiBqvB,SAASwI,GAAW+B,EAAmBv4B,EAAG,GAAIw4B,EAAsBx4B,EAAG,GAC7F+F,EAAKpH,EAAiBqvB,SAASwI,GAAWkB,EAAkB3xB,EAAG,GAAI4xB,EAAqB5xB,EAAG,GAC3F0yB,EAAmBjL,EAASoK,eAAepB,GAkB/C,OAjBI+B,IAAqB/B,GACrBgC,EAAoBhC,GACpBmB,EAAmBnB,IAGnBhJ,EAASqK,sBAAsBrB,EAAUhJ,EAASkL,kBAAkBhB,IAYjE,CACH1F,QAXUrzB,EAAiBqwB,YAAY,SAAU9sB,GACjD,IAAIkJ,EAAUqtB,EAAiBzG,QAAQ9vB,GAEvC,OADAy1B,EAAmBnK,EAASiK,aAAagB,IAClCrtB,CACX,EAAG,CAACqtB,IAQAxG,UAPYtzB,EAAiBqwB,YAAY,SAAUxgB,GACnD,IAAIpD,EAAUqtB,EAAiBxG,UAAUzjB,GAEzC,OADAmpB,EAAmBnK,EAASiK,aAAagB,IAClCrtB,CACX,EAAG,CAACqtB,IAIApG,gBAAiBoG,EAAiB7S,WAC7ByM,gBAEb,CAUA,SAASsG,GAAcnC,GACnBhJ,EAAS8K,sBAAsB9B,GAC/B,IAAIiC,EAAmB95B,EAAiBwB,QAAQ,WAAc,OAAOqtB,EAASoK,eAAepB,EAAW,EAAG,CAACA,IACxGoC,EAAaj6B,EAAiBqwB,YAAY,WAAc,OAAOxB,EAASkL,kBAAkBlC,EAAW,EAAG,CAACA,IACzGiC,EAAiBX,WACjBW,EAAiBI,eACjBrL,EAASqK,sBAAsBrB,EAAUiC,EAAiBrtB,UAE9DzM,EAAiB0vB,UAAU,WAAc,OAAOoK,EAAiB5B,QAAU,EAAG,CAAC4B,IAC/E,IAAIrtB,EAAUyiB,EAAqBlvB,EAAiBqwB,YAAY,SAAUd,GACtE,OAAOuK,EAAiB3B,OAAO,SAAU1rB,GACrCoiB,EAASqK,sBAAsBrB,EAAUprB,GACzC8iB,GACJ,EACJ,EAAG,CAACuK,EAAkBjC,IAAYoC,EAAYA,GAC1CtrB,EAASmiB,EAAMrkB,GACnB,OAAOzM,EAAiBwB,QAAQ,WAC5B,MAAO,CACH8E,KAAMqI,EAAOrI,KACbsuB,cAAejmB,EAAOimB,cACtBtqB,MAAO+tB,GAAc1pB,GAE7B,EAAG,CAACA,GACR,CAEAxP,EAAQm4B,UAAYA,GACpBn4B,EAAQ2vB,gBAAkBA,EAC1B3vB,EAAQg7B,mBArPR,SAA4BvpB,EAAOf,GAE/B,YADgB,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAC3CoxB,EAAS,qBAChB2H,GAAqB9J,EAAmC,kBAAZjf,EAAuBA,EAAQ3O,YAASwD,GAD7EusB,CACyFrgB,EAAOf,EAC3G,EAkPA1Q,EAAQi7B,YA/bR,SAAqBvqB,GACjB,OAAOohB,EAAS,cAChByF,GAAc5H,EAAgBjf,EAAQ3O,QAD/B+vB,CACwCphB,EACnD,EA6bA1Q,EAAQk7B,aA71BR,SAAsBzpB,EAAOf,GACzB,IAAIxO,EACJ,IAA2B,IAAvBO,WAAWC,QAAmB,CAC9B,IAAIy4B,EAAWzqB,GAAW,CAAC,EAC3B+gB,EAAqB0J,EAAU,kBAAmB,gBAClD1J,EAAqB0J,EAAU,YAAa,eAAgB,oEAC5D1J,EAAqB0J,EAAU,UAAW,eAAgB,8DAC1D1J,EAAqB0J,EAAU,cAAe,eAAgB,uMAC9D1J,EAAqB0J,EAAU,UAAW,eAAgB,yPAC1D1J,EAAqB0J,EAAU,iBAAkB,eAAgB,kDACjE1J,EAAqB0J,EAAU,qBAAsB,eAAgB,yCACrE1J,EAAqB0J,EAAU,iBAAkB,eACrD,CACA,IAAIC,EAAiBv6B,EAAiB+vB,YAAO,GACzCyK,EAAax6B,EAAiB+vB,YAAO,GACrC8H,EAAW73B,EAAiB+vB,YAAO,GACnCnF,EAASrrB,EAAUkrB,aAAa5a,EAAS0qB,EAAevK,SAAW,CAAC,GACpE5sB,EAAmF,QAAvE/B,EAAgB,OAAXupB,QAA8B,IAAXA,OAAoB,EAASA,EAAOha,aAA0B,IAAPvP,EAAgBA,EAAKuP,EACpH4pB,EAAWxK,QAAUngB,EACrBgoB,EAAS7H,QAAU5sB,EACnB,IAAImyB,EAAmB/1B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmpB,GAAS,CAAEsH,MAAOqI,EAAevK,UACtF5oB,EAAKuqB,EAAkBvuB,EAAUmyB,GAAmB3D,EAAiBxqB,EAAGwqB,eAAgB6I,EAAiBrzB,EAAGuH,OAAQzN,EAASkG,EAAGlG,OAAQyxB,EAAavrB,EAAGurB,WAAY1L,EAAa7f,EAAG6f,WAAY8L,EAAkB3rB,EAAG2rB,gBACrNsC,EAAqBpO,EAAWpX,QAAQwlB,oBACxCC,EAAsBC,EAAiBJ,eAAgBj0B,EAAOi0B,gBAC9DuF,EAAmB16B,EAAiB26B,WAAW,SAAUC,GAAQ,OAAOA,EAAO,CAAG,EAAG,GAAG,GACxFC,EAAe76B,EAAiBwB,QAAQ,WAiBxC,IAhBA,IAAIq5B,EAAe,CAAC,EAChBC,EAAU,SAAUppB,GACpB,IAAI5B,EAAS8hB,EAAelgB,GAC5BmpB,EAAanpB,GAAO,WAUhB,OAT2B,IAAvB9P,WAAWC,SACC,cAAR6P,IACuB,IAAvB9P,WAAWC,SAAqBvB,GAAUwB,KAAK,IAGlDy4B,EAAevK,UAChBuK,EAAevK,QAAU/wB,OAAOY,OAAO,MACvC66B,KAEG5qB,EAAO9K,MAAM4G,KAAM9G,UAC9B,CACJ,EACSf,EAAK,EAAGg3B,EAAkBxE,GAAexyB,EAAKg3B,EAAgB92B,OAAQF,IAAM,CAEjF+2B,EADUC,EAAgBh3B,GAE9B,CACA,OAAO82B,CACX,EAAG,CAACH,EAAkB9I,IAClBrM,IAAWgV,EAAevK,QAC1BrhB,EAAS3O,EAAiBwB,QAAQ,WAAc,OAAQhC,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGg5B,GAAiBI,GAAe,CAAEtV,OAAQA,GAAY,EAAG,CAACkV,EAAgBI,EAActV,IACjMyV,EAAqB5K,IACrB6K,EAAUj7B,EAAiB+vB,OAAO,IAAI9pB,KACtCi1B,EAAUl7B,EAAiBqwB,YAAY,SAAU8K,GACjD,IAA2B,IAAvBv5B,WAAWC,QAAmB,CAC1Bm5B,MACuB,IAAvBp5B,WAAWC,SAAqBvB,GAAUwB,KAAK,IAEnD,IAAK,IAAIiC,EAAK,EAAGq3B,EAA4B5E,GAAyBzyB,EAAKq3B,EAA0Bn3B,OAAQF,IAAM,CAC/G,IAAI6J,EAASwtB,EAA0Br3B,GAClCk3B,EAAQjL,QAAQ/oB,IAAI2G,KACrB6iB,EAAkB0K,GAAkB,CAAC,EAAGvtB,EAAQ,wBAChDqtB,EAAQjL,QAAQroB,IAAIiG,GAE5B,CACA,IAAK,IAAIvM,EAAK,EAAGg6B,EAA+B5E,GAA4Bp1B,EAAKg6B,EAA6Bp3B,OAAQ5C,IAAM,CACxH,IAAIi6B,EAASD,EAA6Bh6B,GACrC45B,EAAQjL,QAAQ/oB,IAAIq0B,KACrB7K,EAAkB0K,GAAkB,CAAC,EAAGG,EAAQ,uBAAwB,8DACxEL,EAAQjL,QAAQroB,IAAI2zB,GAE5B,CACJ,CACAf,EAAevK,QACXmL,EAAiB37B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG05B,GAAiB,CAAE/G,YAAa+G,EAAe/G,aAAeiB,IAAwB,CACrIjB,YAAaiB,GAErB,IAAIxlB,EAAUtQ,EAAUkrB,aAAa+P,EAAWxK,QAASxwB,EAAMiC,SAAS,CAAEmP,MAAOinB,EAAS7H,SAAWuK,EAAevK,UAChHvjB,EA0BZ,SAAsBkmB,EAAY1L,EAAY/lB,EAAQq6B,EAAc1rB,EAASkjB,GACzE,IAAIniB,EAAQf,EAAQe,OAAS2qB,EACzBvI,EAAoBX,EAA4BnxB,EAAQ0P,EAAOf,GAAS,EAApDwiB,CAA2DpL,GAC/EuU,EAAUvU,EAAWwU,mBAAmB/I,EAAmBzL,EAAY/lB,EAAQ2O,EAASmjB,IAE5F,OADAD,EAAgBC,GACT,IAAIznB,QAAQ,SAAUC,GACzB,IAAImD,EACJ6sB,EAAQ7W,UAAU,CACdrZ,KAAM,SAAUlM,GACZuP,EAASvP,CACb,EACAkL,MAAO,WACHkB,EAAQgpB,EAAcvN,EAAW4M,mBAAoBlB,EAAWC,aAAc3L,EAAY/lB,GAC9F,EACA6U,SAAU,WACNvK,EAAQgpB,EAAcvN,EAAuB,WAAEtY,GAASgkB,EAAWC,aAAc3L,EAAY/lB,GACjG,GAER,EACJ,CA7CsBw6B,CAAa/I,EAAY1L,EAAY/lB,EAAQkC,EAAU5D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEqiB,MAAM,IAAUa,GAAiBpmB,KAAK,SAAUgvB,GAAe,OAAO18B,OAAO0a,OAAOgiB,EAAad,EAAe,GAEnO,OADApuB,EAAQG,MAAM,WAAc,GACrBH,CACX,EAAG,CACCuuB,EACA95B,EACAkC,EACAy3B,EACAxF,EACApO,EACA0L,EACAI,IAEA6I,EAAa57B,EAAiB+vB,OAAOmL,GACzChL,EAA0B,WACtB0L,EAAW5L,QAAUkL,CACzB,GACA,IAAIW,EAAgB77B,EAAiBqwB,YAAY,WAE7C,IADA,IAAIxrB,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,GAAMe,UAAUf,GAEzB,OAAO63B,EAAW5L,QAAQhrB,MAAM42B,EAAY/2B,EAChD,EAAG,IACH,MAAO,CAACg3B,EAAeltB,EAC3B,EAwvBAxP,EAAQ28B,iBAjJR,SAA0BlrB,EAAOf,QACb,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,QACvB,IAAvB+B,WAAWC,SACX+uB,EAAqB/gB,EAAS,kBAAmB,oBAErD,IAAI3O,EAAS4tB,EAAgBjf,EAAQ3O,QACjCs2B,EAAgB3I,EAAS4I,iBAAiBv2B,GAC1C8xB,EAAoB0E,GAAqB,CAAEx2B,OAAQA,EAAQ0P,MAAOA,EAAOf,QAASA,IAClFxO,EAAKwO,EAAQ8nB,SAAUA,OAAkB,IAAPt2B,EAAgB,GAAKA,EACvD+F,EAAKpH,EAAiBqvB,SAAS,MAAOwI,EAAWzwB,EAAG,GAAI20B,EAAc30B,EAAG,GAC7EynB,EAAS8K,sBAAsB9B,GAC/B,IAAIiC,EAAmBjC,GAAYhJ,EAASoK,eAAepB,GAC3D,GAAIA,IAAkC,OAArBiC,QAAkD,IAArBA,OAA8B,EAASA,EAAiB9B,iBAAiBhF,IAAqB,CACxI,IAAIvmB,EAAUqtB,EAAiB7B,aAAajF,GAC5CnE,EAASqK,sBAAsBrB,EAAUprB,EAC7C,CACA,IAAIuuB,EAAqB5K,IACrBkD,EAAYtzB,EAAiBqwB,YAAY,SAAUxgB,GACnD,IAAKiqB,EACD,MAAM,IAAI9sB,MAAM,yDAEpB,IAAIP,EAAUqtB,EAAiBxG,UAAUzjB,GAEzC,OADAksB,EAAYlN,EAASiK,aAAagB,IAC3BrtB,CACX,EAAG,CAACqtB,IACAzG,EAAUrzB,EAAiBqwB,YAAY,SAAUxgB,GACjD,IAAKiqB,EACD,MAAM,IAAI9sB,MAAM,yDAEpB,IAAIP,EAAUqtB,EAAiBzG,QAAQxjB,GAEvC,OADAksB,EAAYlN,EAASiK,aAAagB,IAC3BrtB,CACX,EAAG,CAACqtB,IACAkC,EAAYh8B,EAAiBqwB,YAAY,WAEzC,IADA,IAAIxrB,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,GAAMe,UAAUf,GAEzB1E,EAAQiB,WAAW06B,IAAsB,IACzC,IAAIz3B,EAAYsB,EAAK,GACjB+yB,EAAWp4B,EAAMyF,cAAc,CAC/B2L,EACA1O,EAAMwX,mBAAmBnW,IAC1B,GAAGmE,OAAOiwB,IAAW,GACpBE,EAAWzyB,EAAiB,kBAAmB,WAC/C,OAAOoyB,EAAcM,YAAYF,EAAU,WACvC,OAAO12B,EAAOuxB,WAAWjzB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGuxB,GAAoB,CAAEzvB,UAAWA,IAChG,EACJ,GACAw4B,EAAYlN,EAASiK,aAAajB,GACtC,EAAG,CACCjnB,EACA+mB,EACAH,EACAxE,EACAgI,EACA95B,IAEAwyB,EAAkB1zB,EAAiBqwB,YAAY,SAAUxgB,GAEzD,OADAxQ,EAAQiB,UAAUw5B,EAAkB,IAC7BA,EAAiB7S,WAAWyM,gBACnC7jB,EACJ,EAAG,CAACiqB,IAIJ,MAAO,CAACkC,EAAWnE,EAAU,CAAEvE,UAAWA,EAAWD,QAASA,EAASxZ,MAH3D7Z,EAAiBqwB,YAAY,WACrC0L,EAAY,KAChB,EAAG,IACkFrI,gBAAiBA,GAC1G,EA+EAv0B,EAAQ88B,YAnuBR,SAAqBC,EAAUrsB,IACA,IAAvBjO,WAAWC,SACX+uB,EAAqB/gB,GAAW,CAAC,EAAG,gBAAiB,cAAe,2KAExE,IAAI3O,EAAS4tB,EAA4B,OAAZjf,QAAgC,IAAZA,OAAqB,EAASA,EAAQ3O,QACvFiC,EAAOyB,mBAAmBs3B,EAAU/4B,EAAOlB,aAAagB,UACxD,IAAI5B,EAAKrB,EAAiBqvB,SAAS,CAC/B9J,QAAQ,EACRuO,SAAS,EACT5yB,OAAQA,IACRyN,EAAStN,EAAG,GAAIwzB,EAAYxzB,EAAG,GAC/ByuB,EAAM9vB,EAAiB+vB,OAAO,CAC9BphB,OAAQA,EACRwtB,WAAY,EACZC,WAAW,EACXl7B,OAAQA,EACRg7B,SAAUA,EACVrsB,QAASA,IAEbqgB,EAA0B,WACtBjxB,OAAO0a,OAAOmW,EAAIE,QAAS,CAAE9uB,OAAQA,EAAQ2O,QAASA,EAASqsB,SAAUA,GAC7E,GACA,IAAIhB,EAAUl7B,EAAiBqwB,YAAY,SAAU8K,QAC1B,IAAnBA,IAA6BA,EAAiB,CAAC,GACnD,IAAI95B,EAAKyuB,EAAIE,QAASngB,EAAUxO,EAAGwO,QAASqsB,EAAW76B,EAAG66B,SACtDG,EAAc78B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEqsB,SAAUA,IACtEh7B,EAASi6B,EAAej6B,QAAU4uB,EAAIE,QAAQ9uB,OAC7C4uB,EAAIE,QAAQrhB,OAAOmlB,SACnBuI,EAAYC,gBACbxM,EAAIE,QAAQoM,WACZvH,EAAW/E,EAAIE,QAAQrhB,OAAS,CAC5BmlB,SAAS,EACTxpB,WAAO,EACPhE,UAAM,EACNif,QAAQ,EACRrkB,OAAQA,IAGhB,IAAIi7B,IAAerM,EAAIE,QAAQmM,WAC3BI,EAAgBh9B,EAAUkrB,aAAa4R,EAAalB,GACxD,OAAOj6B,EACFs7B,OAAOD,GACP5vB,KAAK,SAAUV,GAChB,IAAI5K,EAAI+F,EACJd,EAAO2F,EAAS3F,KAAMm2B,EAAWxwB,EAAShC,OAC1CK,EAAQmyB,GAAYA,EAASx4B,OAAS,EACtC,IAAIgG,EAAO2rB,YAAY,CAAEjQ,cAAe8W,SACtC,EACF5xB,EAAUswB,EAAetwB,UAA2C,QAA9BxJ,EAAKyuB,EAAIE,QAAQngB,eAA4B,IAAPxO,OAAgB,EAASA,EAAGwJ,SAI5G,GAHIP,GAASO,GACTA,EAAQP,EAAOiyB,GAEfJ,IAAerM,EAAIE,QAAQmM,aAC1BI,EAAcD,cAAe,CAC9B,IAAII,EAAW,CACXnX,QAAQ,EACRuO,SAAS,EACTxtB,KAAMA,EACNgE,MAAOA,EACPpJ,OAAQA,GAER4uB,EAAIE,QAAQoM,YAAcxN,EAAMA,MAAMkB,EAAIE,QAAQrhB,OAAQ+tB,IAC1D7H,EAAW/E,EAAIE,QAAQrhB,OAAS+tB,EAExC,CACA,IAAIxH,EAAciG,EAAejG,cAA+C,QAA9B9tB,EAAK0oB,EAAIE,QAAQngB,eAA4B,IAAPzI,OAAgB,EAASA,EAAG8tB,aAIpH,OAHK5qB,GACe,OAAhB4qB,QAAwC,IAAhBA,GAAkCA,EAAYjpB,EAAS3F,KAAMi2B,GAElFtwB,CACX,EAAG,SAAU3B,GACT,IAAIjJ,EACJ,GAAI86B,IAAerM,EAAIE,QAAQmM,YAC3BrM,EAAIE,QAAQoM,UAAW,CACvB,IAAIO,EAAW,CACX7I,SAAS,EACTxpB,MAAOA,EACPhE,UAAM,EACNif,QAAQ,EACRrkB,OAAQA,GAEP0tB,EAAMA,MAAMkB,EAAIE,QAAQrhB,OAAQguB,IACjC9H,EAAW/E,EAAIE,QAAQrhB,OAASguB,EAExC,CACA,IAAI9xB,EAAUswB,EAAetwB,UAA2C,QAA9BxJ,EAAKyuB,EAAIE,QAAQngB,eAA4B,IAAPxO,OAAgB,EAASA,EAAGwJ,SAC5G,GAAIA,EAEA,OADAA,EAAQP,EAAOiyB,GACR,CAAEj2B,UAAM,EAAQ2D,OAAQK,GAEnC,MAAMA,CACV,EACJ,EAAG,IACCuP,EAAQ7Z,EAAiBqwB,YAAY,WACrC,GAAIP,EAAIE,QAAQoM,UAAW,CACvB,IAAIQ,EAAW,CACXrX,QAAQ,EACRuO,SAAS,EACT5yB,OAAQ4uB,EAAIE,QAAQ9uB,QAExBjC,OAAO0a,OAAOmW,EAAIE,QAAS,CAAEmM,WAAY,EAAGxtB,OAAQiuB,IACpD/H,EAAU+H,EACd,CACJ,EAAG,IAQH,OAPA58B,EAAiB0vB,UAAU,WACvB,IAAIM,EAAUF,EAAIE,QAElB,OADAA,EAAQoM,WAAY,EACb,WACHpM,EAAQoM,WAAY,CACxB,CACJ,EAAG,IACI,CAAClB,EAAS17B,EAAMiC,SAAS,CAAEoY,MAAOA,GAASlL,GACtD,EAonBAxP,EAAQ09B,SAtxCR,SAAkBjsB,EAAOf,GAErB,YADgB,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAC3CoxB,EAAS,WAAYS,EAAW5C,EAAgBjf,GAAWA,EAAQ3O,QAAnE+vB,CAA4ErgB,EAAOf,EAC9F,EAoxCA1Q,EAAQ29B,oBA/ER,SAA6BjF,GACzB,IAAIkF,EAAYlO,EAASoK,eAAepB,GAIxC,OAAO5G,EAAS,sBAChByI,GAJuB5K,EAAgBiO,EACnCA,EAAsB,gBACpBr4B,GACCusB,CACiC4G,EAC5C,EAyEA14B,EAAQ69B,eA9cR,SAAwBC,GACpB,OAAO/N,EAAqBlvB,EAAiBqwB,YAAY,SAAU6M,GAC/D,OAAOD,EAAGE,aAAa,SAASzI,IAC5BwI,IACAD,EAAGE,aAAazI,EACpB,EACJ,EAAG,CAACuI,IAAMA,EAAIA,EAClB,EAwcA99B,EAAQi+B,aA3CR,SAAsBvF,GAClB,IAAIkF,EAAYlO,EAASoK,eAAepB,GAIxC,OAAO5G,EAAS,eAChB+I,GAJuBlL,EAAgBiO,EACnCA,EAAsB,gBACpBr4B,GACCusB,CAC0B4G,EACrC,EAqCA14B,EAAQk+B,gBAtnBR,SAAyBvI,EAAcjlB,QACnB,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAClD,IAAIy9B,EAAiCt9B,EAAiB+vB,QAAO,GACzD7uB,EAAS4tB,EAAgBjf,EAAQ3O,QACrCiC,EAAOyB,mBAAmBkwB,EAAc3xB,EAAOlB,aAAaiB,cACvDo6B,EAA+BtN,UAChCsN,EAA+BtN,SAAU,EACrCngB,EAAQ0tB,qBACe,IAAvB37B,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK+N,EAAQpF,OAAS,GAAK,IAE7EoF,EAAQ2tB,yBACe,IAAvB57B,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK+N,EAAQ4tB,WAAa,GAAK,KAGzF,IAAIvL,EAAOriB,EAAQqiB,KAAMkC,EAAcvkB,EAAQukB,YAAasJ,EAAc7tB,EAAQ6tB,YAAaC,EAAoB9tB,EAAQ8tB,kBAAmBp9B,EAAUsP,EAAQtP,QAASoQ,EAAad,EAAQc,WAAY2rB,EAAgBzsB,EAAQysB,cAC9N/4B,EAAYosB,EAAY,WAAc,OAAO9f,EAAQtM,SAAW,EAAG,CAACsM,EAAQtM,YAC5Eq6B,EAAW,WACX,OAwHR,SAA4B18B,EAAQ0P,EAAOrN,EAAW6wB,EAAasJ,EAAan9B,EAASoQ,GACrF,IAAId,EAAU,CACVe,MAAOA,EACPrN,UAAWA,EACX6wB,YAAaA,EACbsJ,YAAaA,EACbn9B,QAASA,EACToQ,WAAYA,GAEZktB,EAAKr+B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAE3O,OAAQA,EAAQyN,OAAQ,CACvEmlB,SAAS,EACTxtB,UAAM,EACNgE,WAAO,EACP/G,UAAWA,GACZsxB,UAAW,SAAUlmB,GACpBkvB,EAAGlvB,OAASA,CAChB,IACAsY,EAAa,KACjB,OAAOhoB,OAAO0a,OAAO,IAAIzP,EAAKiK,WAAW,SAAUC,GAC1C6S,IACDA,EAAa/lB,EAAOyjB,UAAU9U,IAElC,IAAI0U,EAAM0C,EAAWtC,UAAUvQ,GAC/B,OAAO,WAAc,OAAOmQ,EAAIG,aAAe,CACnD,GAAI,CACAmZ,GAAIA,GAEZ,CAnJeC,CAAmB58B,EAAQ4zB,EAAcvxB,EAAW6wB,EAAasJ,EAAan9B,EAASoQ,EAClG,EACItP,EAAKrB,EAAiBqvB,SAASxf,EAAQqiB,KAAO,KAAO0L,GAAW3W,EAAa5lB,EAAG,GAAI08B,EAAgB18B,EAAG,GACvG28B,EAAch+B,EAAiB+vB,OAAO6N,GAC1C1N,EAA0B,WACtB8N,EAAYhO,QAAU4N,CAC1B,GACI1L,EACIjL,GACA8W,EAAe9W,EAAa,MAG1BA,IACJ/lB,IAAW+lB,EAAW4W,GAAG38B,QACvB4zB,IAAiB7N,EAAW4W,GAAGjtB,OAC/BwjB,IAAgBnN,EAAW4W,GAAGzJ,aAC9BsJ,IAAgBzW,EAAW4W,GAAGH,aAC7B9O,EAAMA,MAAMrrB,EAAW0jB,EAAW4W,GAAGt6B,aAGT,KAFC,oBAAtBo6B,IACFA,EAAkB9tB,GAClB8tB,KACVI,EAAe9W,EAAa2W,KAEhC,IAAIpD,EAAax6B,EAAiB+vB,OAAOlgB,GACzC7P,EAAiB0vB,UAAU,WACvB8K,EAAWxK,QAAUngB,CACzB,GACA,IAAIouB,GAAmB/L,IAASoK,EAC5B4B,EAAiBl+B,EAAiBwB,QAAQ,WAAc,MAAO,CAC/DsyB,QAASmK,EACT3zB,WAAO,EACPhE,UAAM,EACN/C,UAAWA,EACX,EAAG,CAAC06B,EAAiB16B,IACrB46B,EAAmBn+B,EAAiB+vB,OAAOuM,GAC/CpM,EAA0B,WACtBiO,EAAiBnO,QAAUsM,CAC/B,GACA,IAAIljB,EAAM8V,EAAqBlvB,EAAiBqwB,YAAY,SAAU6M,GAClE,IAAKjW,EACD,OAAO,WAAc,EAEzB,IAAImX,GAAsB,EACtB76B,EAAY0jB,EAAW4W,GAAGt6B,UAC1BrC,EAAS+lB,EAAW4W,GAAG38B,OACvB4zB,EAAe7N,EAAWtC,UAAU,CACpCrZ,KAAM,SAAU+yB,GACZ,IAAIh9B,EAAI+F,EACR,IAAIg3B,EAAJ,CAGA,IAAIzvB,EAAS,CACTmlB,SAAS,EACTxtB,KAAM+3B,EAAY/3B,KAClBgE,MAAO2rB,EAAgBoI,GACvB96B,UAAWA,GAEf0jB,EAAW4W,GAAGhJ,UAAUlmB,GACnBwvB,EAAiBnO,SAClBkN,IACAvuB,EAAOrE,MACsC,QAA5ClD,GAAM/F,EAAKm5B,EAAWxK,SAASnlB,eAA4B,IAAPzD,GAAyBA,EAAGwH,KAAKvN,EAAIsN,EAAOrE,OAE5FkwB,EAAWxK,QAAQvlB,OACxB+vB,EAAWxK,QAAQvlB,OAAO,CACtBvJ,OAAQA,EACRoF,KAAMqI,IAGL6rB,EAAWxK,QAAQuN,oBACxB/C,EAAWxK,QAAQuN,mBAAmB,CAClCr8B,OAAQA,EACRo9B,iBAAkB3vB,GAtB1B,CAyBJ,EACArE,MAAO,SAAUA,GACb,IAAIjJ,EAAI+F,EACRkD,EACIA,aAAiBJ,EAAK0rB,YAActrB,EAAQ,IAAKJ,EAAK0rB,YAAY,CAAE2I,eAAgB,CAACj0B,KACpF8zB,IACDnX,EAAW4W,GAAGhJ,UAAU,CACpBf,SAAS,EACTxtB,UAAM,EACNgE,MAAOA,EACP/G,UAAWA,IAEV46B,EAAiBnO,SAClBkN,IACyC,QAA5C91B,GAAM/F,EAAKm5B,EAAWxK,SAASnlB,eAA4B,IAAPzD,GAAyBA,EAAGwH,KAAKvN,EAAIiJ,GAElG,EACAyL,SAAU,WACDqoB,IACG5D,EAAWxK,QAAQyN,WACnBjD,EAAWxK,QAAQyN,aAEdjD,EAAWxK,QAAQwN,wBACxBhD,EAAWxK,QAAQwN,yBAG/B,IAEJ,OAAO,WACHY,GAAsB,EACtBplB,WAAW,WACP8b,EAAapQ,aACjB,EACJ,CACJ,EAAG,CAACuC,IAAc,WACd,OAAOA,GAAeiL,GAASoK,EAEzB4B,EADFjX,EAAW4W,GAAGlvB,MAEtB,EAAG,WAAc,OAAOuvB,CAAgB,GACpCM,EAAUx+B,EAAiBqwB,YAAY,WACvChxB,EAAQiB,WAAWk6B,EAAWxK,QAAQkC,KAAM,IAC5C6L,EAAcC,EAAYhO,UAC9B,EAAG,CAACwK,EAAYwD,IAChB,OAAOh+B,EAAiBwB,QAAQ,WAAc,OAAQhC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2X,GAAM,CAAEolB,QAASA,GAAa,EAAG,CAACplB,EAAKolB,GACnI,EA+eAr/B,EAAQs/B,oBA/LR,SAA6B5uB,GACzB,OAAOohB,EAAS,sBAChBqI,GAAsBxK,EAAmC,kBAAZjf,EAAuBA,EAAQ3O,YAASwD,GAD9EusB,CAC0FphB,EACrG,EA6LA1Q,EAAQu/B,iBA/XR,SAA0B9tB,EAAOf,GAE7B,YADgB,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAC3CoxB,EAAS,mBAChBsG,GAAmBzI,EAAmC,kBAAZjf,EAAuBA,EAAQ3O,YAASwD,GAD3EusB,CACuFrgB,EAAOf,EACzG,C,yCC1lCA5Q,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIuX,EAAO,EAAQ,wBACfpX,EAAY,EAAQ,wBACpBC,EAAQ,EAAQ,wBAChBm/B,EAAW,EAAQ,wBACnB/Q,EAAc,EAAQ,wBACtB7rB,EAAW,EAAQ,wBACvB,EAAQ,wBAER,IAAImR,EAAU,SAEd,SAASb,EAAMwb,GACX,IACI,OAAOA,GACX,CACA,MAAOxsB,GAAM,CACjB,CAEA,IAAIysB,EAAYzb,EAAM,WAAc,OAAOzQ,UAAY,IACnDyQ,EAAM,WAAc,OAAO+F,MAAQ,IACnC/F,EAAM,WAAc,OAAO0b,IAAM,IACjC1b,EAAM,WAAc,OAAO,EAAA4F,CAAQ,IACvC5F,EAAM,WACF,OAAOA,EAAM2b,YAAY,cAAlB3b,EACX,GAEI2T,EAAe,IAAIngB,IAOvB,SAASunB,EAAoBhuB,EAAOiuB,QAClB,IAAVA,IAAoBA,EAAQ,GAChC,IARkBnH,EACdrE,EAOAyL,GARcpH,EAQS,sBAPvBrE,EAAQmE,EAAaviB,IAAIyiB,IAAW,EACxCF,EAAaxhB,IAAI0hB,EAAQrE,EAAQ,GAC1B,GAAGna,OAAOwe,EAAQ,KAAKxe,OAAOma,EAAO,KAAKna,OAAOye,KAAKC,SAAStD,SAAS,IAAI/X,MAAM,KAMzF,OAAOoD,KAAKgB,UAAU/P,EAAO,SAAUsS,EAAKtS,GACxC,YAAiB,IAAVA,EAAmBkuB,EAAUluB,CACxC,EAAGiuB,GACE7f,MAAMW,KAAKgB,UAAUme,IACrBnb,KAAK,cACd,CAEA,SAASqL,EAAKyQ,GACV,OAAO,SAAU5e,GAEb,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,GAAuB,kBAAZsL,EAAsB,CAC7B,IAAI6e,EAAO7e,GACXA,EAAU8e,EAAmBD,MAEzB7e,EAAU+e,EAAoBF,EAAMrpB,GACpCA,EAAO,GAEf,CACAopB,EAAGjpB,WAAM,EAAQ,CAACqK,GAAS3H,OAAO7C,GACtC,CACJ,CACA,IAAIvE,EAAYrB,OAAO0a,OAAO,SAAmB0U,EAAWhf,GAExD,IADA,IAAIxK,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAExBsqB,GACDT,EAAYttB,UAAU+tB,EAAWF,EAAmB9e,EAASxK,IAASupB,EAAoB/e,EAASxK,GAE3G,EAAG,CACCypB,MAAO9Q,EAAKoQ,EAAYttB,UAAUguB,OAClCC,IAAK/Q,EAAKoQ,EAAYttB,UAAUiuB,KAChCzsB,KAAM0b,EAAKoQ,EAAYttB,UAAUwB,MACjCwI,MAAOkT,EAAKoQ,EAAYttB,UAAUgK,SAElCkkB,EAA4BruB,OAAOC,IAAI,6BAA+B8S,GAC1E,SAAS/D,EAAUoS,GACf,GAAkB,iBAAPA,EACP,OAAOA,EAEX,IACI,OAAO6L,EAAoB7L,EAAK,GAAGxW,MAAM,EAAG,IAChD,CACA,MAAO1J,GACH,MAAO,oBACX,CACJ,CACA,SAAS8sB,EAAmB9e,EAASof,GAEjC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,OAAQye,EAASU,IACbV,EAASU,GAA2Bnf,EAASof,EAAY5f,IAAIM,GACrE,CACA,SAASif,EAAoB/e,EAASof,GAElC,QADoB,IAAhBA,IAA0BA,EAAc,IACvCpf,EAEL,MAAO,+FAA+F3H,OAAOiK,mBAAmBxD,KAAKgB,UAAU,CAC3I+D,QAASA,EACT7D,QAASA,EACTxK,KAAM4pB,EAAY5f,IAAIM,MAE9B,CAEA,IAAI7M,EAAO,IAAIP,EAASQ,KASxB,IAAIq8B,EAAyBz+B,OAAOC,IAAI,4BACpCy+B,EAAiB1+B,OAAOC,IAAI,8BAgBhC,SAAS25B,EAAkBlC,GACvB,IAAIiC,EAAmBb,EAAepB,GACtC,MAA2C,cAApCiC,EAAiBrtB,QAAQwB,OAC5B6rB,EAAiBrtB,QACforB,EAASgH,EACnB,CACA,SAAS5F,EAAepB,GACpB,OAAOA,EAAS+G,EACpB,CAIA,IAAIE,EAA2B,CAC3B,kBACA,UACA,cACA,cACA,qBACA,qBAEAC,EAA2B,WAC3B,SAASA,EAAuB9X,EAAYpX,GACxC,IAAIuG,EAAQxK,KACZA,KAAK8F,IAAM,CAAC,EACZ9F,KAAKozB,UAAY,IAAI/4B,IACrB2F,KAAKqzB,WAAa,EAClBrzB,KAAKszB,eAAiB,EACtBtzB,KAAKuzB,WAAavzB,KAAKuzB,WAAW5qB,KAAK3I,MACvCA,KAAKoK,YAAcpK,KAAKoK,YAAYzB,KAAK3I,MACzCA,KAAKsN,QAAUtN,KAAKsN,QAAQ3E,KAAK3I,MACjCA,KAAKqb,WAAaA,EACdpX,EAAQuvB,YACRxzB,KAAKwzB,UAAYvvB,EAAQuvB,WAE7BxzB,KAAKipB,YACLjpB,KAAKyzB,mBACL,IAAIC,EAAoB,WACpB,IAAIj+B,EACC+U,EAAM6oB,aACP7oB,EAAMmpB,qBAAuBvmB,WAAW5C,EAAM8C,QAAiD,QAAvC7X,EAAKwO,EAAQ2vB,4BAAyC,IAAPn+B,EAAgBA,EAAK,KAEpI,EACAuK,KAAKa,QAAQE,KAAK2yB,EAAmBA,EACzC,CA0MA,OAzMArgC,OAAOC,eAAe6/B,EAAuB3xB,UAAW,WAAY,CAChE3J,IAAK,WACD,OAAOmI,KAAKkpB,aAAatN,MAC7B,EACA/mB,YAAY,EACZE,cAAc,IAElB1B,OAAOC,eAAe6/B,EAAuB3xB,UAAW,oBAAqB,CACzE3J,IAAK,WACD,OAAOmI,KAAKqb,WAAWpX,OAC3B,EACApP,YAAY,EACZE,cAAc,IAElBo+B,EAAuB3xB,UAAU8sB,aAAe,WAC5C,IAAIjT,EAAarb,KAAKqb,WAClBwY,EAAsB7zB,KAAKonB,kBAAkBoB,YAC7CsL,EAA+C,aAAxBD,GAA8D,YAAxBA,EACjE,IAWI,GAVIC,EACAzY,EAAW0Y,iBAAiB,CAAEvL,YAAa,cAzF3D,SAA0B3xB,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAEtBzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CAsFgBO,CAAiB,mBAAoB,WACjC,OAAO6hB,EAAW2Y,kBACtB,GACA3Y,EAAW0Y,iBAAiB,CAAEvL,YAAa,iBAE/CxoB,KAAKyzB,mBACDK,EACA,OAEJzY,EAAW4Y,YACXj0B,KAAKipB,WACT,CACA,QACI5N,EAAW0Y,iBAAiB,CAAEvL,YAAaqL,GAC/C,CACJ,EACAV,EAAuB3xB,UAAU8qB,OAAS,WACtC,IAAI9hB,EAAQxK,KACZA,KAAKqzB,aACL7H,aAAaxrB,KAAK2zB,sBAClB,IAAIpG,GAAW,EACf,OAAO,WACCA,IAGJA,GAAW,EACX/iB,EAAM6oB,aACNjmB,WAAW,WACF5C,EAAM6oB,YACP7oB,EAAM8C,SAEd,GACJ,CACJ,EACA6lB,EAAuB3xB,UAAUgsB,WAAa,WAC1C,IAAIhjB,EAAQxK,KACZA,KAAKszB,iBACL,IAAI/F,GAAW,EACf,OAAO,WACCA,IAGJA,GAAW,EACX/iB,EAAM8oB,iBACNlmB,WAAW,WACF5C,EAAM8oB,gBAAmB9oB,EAAM6oB,YAChC7oB,EAAM8C,SAEd,GACJ,CACJ,EACA6lB,EAAuB3xB,UAAU4qB,iBAAmB,SAAUhF,GAC1D,IAAI5c,EAAQxK,KACZ,OAAOkzB,EAAyB7qB,KAAK,SAAU6rB,GAC3C,OAAOA,KAAU9M,IACZ2L,EAAS/P,MAAMxY,EAAM4c,kBAAkB8M,GAAS9M,EAAkB8M,GAC3E,EACJ,EACAf,EAAuB3xB,UAAU6qB,aAAe,SAAUjF,GACtD,IAAI3xB,EAAKuK,KAAKonB,kBAAmB+M,EAAqB1+B,EAAG+yB,YAAa4L,EAAyB3+B,EAAG4+B,gBAYlG,MAX2B,YAAvBF,GACAA,IAAuB/M,EAAkBoB,YACzCxoB,KAAKs0B,cAAct0B,KAAKqb,WAAWkM,UAAUH,KAG7CpnB,KAAKqb,WAAW0Y,iBAAiB3M,GAC7BgN,IAA2BhN,EAAkBiN,kBAC7Cr0B,KAAK+C,OAASnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAK+C,QAAS/C,KAAKqb,WAAW4M,oBAC9EjoB,KAAKa,QAAUlN,EAAUyoB,uBAAuBpc,KAAK+C,UAGtD/C,KAAKa,OAChB,EACAsyB,EAAuB3xB,UAAU+qB,OAAS,SAAU/S,GAChD,IAAIhP,EAAQxK,KAEZ,OADAA,KAAKozB,UAAUr3B,IAAIyd,GACZ,WACHhP,EAAM4oB,UAAU3nB,OAAO+N,EAC3B,CACJ,EACA2Z,EAAuB3xB,UAAUimB,QAAU,SAAU9vB,GACjD,OAAOqI,KAAKs0B,cAAct0B,KAAKqb,WAAWoM,QAAQ9vB,GACtD,EACAw7B,EAAuB3xB,UAAUkmB,UAAY,SAAUzjB,GACnD,OAAOjE,KAAKs0B,cAAct0B,KAAKqb,WAAWqM,UAAUzjB,GACxD,EACAkvB,EAAuB3xB,UAAU8L,QAAU,WACvCtN,KAAKkpB,aAAapQ,cAClB9Y,KAAKwzB,WACT,EACAL,EAAuB3xB,UAAUgyB,UAAY,WAC7C,EACAL,EAAuB3xB,UAAU+xB,WAAa,SAAUxwB,GACpD,IAAItN,EACJ,GACS,YADDuK,KAAKa,QAAQwB,YAEO,IAAhBU,EAAOrI,OACPqI,EAAOrI,KAAOsF,KAAK+C,OAAOrI,MAE9BsF,KAAK+C,OAASA,EACU,QAAvBtN,EAAKuK,KAAKJ,eAA4B,IAAPnK,GAAyBA,EAAGuN,KAAKhD,KAAM+C,OAG3E,CACI,GAAIA,EAAOrI,OAASsF,KAAK+C,OAAOrI,MAC5BqI,EAAOimB,gBAAkBhpB,KAAK+C,OAAOimB,cACrC,YAEgB,IAAhBjmB,EAAOrI,OACPqI,EAAOrI,KAAOsF,KAAK+C,OAAOrI,MAE9BsF,KAAK+C,OAASA,EACd/C,KAAKa,QAAUlN,EAAUyoB,uBAAuBrZ,GAChD/C,KAAKu0B,QAAQv0B,KAAKa,QAEtB,CAER,EACAsyB,EAAuB3xB,UAAU4I,YAAc,SAAU1L,GACrD,IAAIjJ,EAGJ,GAFAuK,KAAKkpB,aAAapQ,cAClB9Y,KAAKkpB,aAAelpB,KAAKqb,WAAW8N,sBAAsBnpB,KAAKuzB,WAAYvzB,KAAKoK,aAEvE,YADDpK,KAAKa,QAAQwB,OAEU,QAAtB5M,EAAKuK,KAAKH,cAA2B,IAAPpK,GAAyBA,EAAGuN,KAAKhD,KAAMtB,QAItEsB,KAAKa,QAAUlN,EAAU0oB,sBAAsB3d,GAC/CsB,KAAKu0B,QAAQv0B,KAAKa,QAG9B,EACAsyB,EAAuB3xB,UAAU+yB,QAAU,SAAU1zB,GACjDb,KAAKozB,UAAUh0B,QAAQ,SAAUoa,GAAY,OAAOA,EAAS3Y,EAAU,EAC3E,EACAsyB,EAAuB3xB,UAAU8yB,cAAgB,SAAUE,GACvD,IAAIhqB,EAAQxK,KAcZ,OAbAA,KAAKa,QAAUb,KAAKy0B,uBACpBz0B,KAAKa,QAAQG,MAAM,WAAc,GACjCwzB,EACKzzB,KAAK,WACNqM,WAAW,WACP,IAAI3X,EACyB,YAAzB+U,EAAM3J,QAAQwB,SACdmI,EAAMzH,OAASyH,EAAM6Q,WAAW4M,mBACP,QAAxBxyB,EAAK+U,EAAM5K,eAA4B,IAAPnK,GAAyBA,EAAGuN,KAAKwH,EAAOA,EAAMzH,QAEvF,EACJ,GACK/B,MAAM,SAAUtC,GAAS,IAAIjJ,EAAI,OAA+B,QAAvBA,EAAK+U,EAAM3K,cAA2B,IAAPpK,OAAgB,EAASA,EAAGuN,KAAKwH,EAAO9L,EAAQ,GACtH81B,CACX,EACArB,EAAuB3xB,UAAUiyB,iBAAmB,WAChD,IAAIjpB,EAAQxK,KACZA,KAAKkpB,aAAelpB,KAAKqb,WACpBzd,OAAO,SAAUmF,GAAU,OAAQgwB,EAAS/P,MAAMjgB,EAAOrI,KAAM,CAAC,KAAOq4B,EAAS/P,MAAMjgB,EAAQyH,EAAMzH,OAAS,GAC7GgW,UAAU/Y,KAAKuzB,WAAYvzB,KAAKoK,YACzC,EACA+oB,EAAuB3xB,UAAUynB,UAAY,WACzC,IAAIlmB,EAAS/C,KAAKqb,WAAW4M,kBAAiB,GAC1C8K,EAAS/P,MAAMjgB,EAAQ/C,KAAK+C,UAGhC/C,KAAK+C,OAASA,EACd/C,KAAKa,SACAkC,EAAOrI,MACFqI,EAAOknB,UAAWjqB,KAAKonB,kBAAkBiE,kBAEzCrrB,KAAKy0B,uBADP9gC,EAAUyoB,uBAAuBrZ,GAE7C,EACAowB,EAAuB3xB,UAAUizB,qBAAuB,WACpD,IAAIjqB,EAAQxK,KACZ,OAAOrM,EAAUiuB,qBAAqB,IAAIjiB,QAAQ,SAAUC,EAASC,GACjE2K,EAAM5K,QAAUA,EAChB4K,EAAM3K,OAASA,CACnB,GACJ,EACOszB,CACX,CAlO8B,GAoO1BuB,EAAsB,WACtB,SAASA,EAAkBp/B,EAAQq/B,EAAsB1wB,GACrD,IAAIuG,EAAQxK,KACZA,KAAK8F,IAAM,CAAC,EACZ9F,KAAKozB,UAAY,IAAI/4B,IACrB2F,KAAKqzB,WAAa,EAClBrzB,KAAKsN,QAAUtN,KAAKsN,QAAQ3E,KAAK3I,MACjCA,KAAKuzB,WAAavzB,KAAKuzB,WAAW5qB,KAAK3I,MACvCA,KAAKoK,YAAcpK,KAAKoK,YAAYzB,KAAK3I,MACzCA,KAAKqb,WAAa/lB,EAAOi2B,cAAcoJ,GACnC1wB,EAAQuvB,YACRxzB,KAAKwzB,UAAYvvB,EAAQuvB,WAE7B,IAAItI,EAAOlrB,KAAK40B,QAAQt/B,EAAQq/B,GAC5BjB,EAAoB,WACpB,IAAIj+B,EACC+U,EAAM6oB,aACP7oB,EAAMmpB,qBAAuBvmB,WAAW5C,EAAM8C,QAAiD,QAAvC7X,EAAKwO,EAAQ2vB,4BAAyC,IAAPn+B,EAAgBA,EAAK,KAEpI,EACAuK,KAAKa,QACDqqB,EAAK/gB,SACDxW,EAAUyoB,uBAAuB8O,EAAKnoB,QACpC/C,KAAKy0B,uBACfz0B,KAAK60B,sBACL70B,KAAKa,QAAQE,KAAK2yB,EAAmBA,EACzC,CAiFA,OAhFAgB,EAAkBlzB,UAAU+qB,OAAS,SAAU/S,GAC3C,IAAIhP,EAAQxK,KAEZ,OADAA,KAAKozB,UAAUr3B,IAAIyd,GACZ,WACHhP,EAAM4oB,UAAU3nB,OAAO+N,EAC3B,CACJ,EACAkb,EAAkBlzB,UAAU8qB,OAAS,WACjC,IAAI9hB,EAAQxK,KACZA,KAAKqzB,aACL7H,aAAaxrB,KAAK2zB,sBAClB,IAAIpG,GAAW,EACf,OAAO,WACCA,IAGJA,GAAW,EACX/iB,EAAM6oB,aACNjmB,WAAW,WACF5C,EAAM6oB,YACP7oB,EAAM8C,SAEd,GACJ,CACJ,EACAonB,EAAkBlzB,UAAU8L,QAAU,WAClCtN,KAAKkpB,aAAapQ,cAClB9Y,KAAKwzB,WACT,EACAkB,EAAkBlzB,UAAUgyB,UAAY,WACxC,EACAkB,EAAkBlzB,UAAUqzB,oBAAsB,WAC9C70B,KAAKkpB,aAAelpB,KAAKqb,WAAWtC,UAAU/Y,KAAKuzB,WAAW5qB,KAAK3I,MAAOA,KAAKoK,YAAYzB,KAAK3I,MACpG,EACA00B,EAAkBlzB,UAAU+xB,WAAa,SAAUxwB,GAC/C,IAAItN,EACJ,OAAQuK,KAAKa,QAAQwB,QACjB,IAAK,UACD,GAAIU,EAAOoH,SACP,OAA+B,QAAvB1U,EAAKuK,KAAKJ,eAA4B,IAAPnK,OAAgB,EAASA,EAAGuN,KAAKhD,KAAM+C,EAAOrI,MAEzFsF,KAAKu0B,QAAQv0B,KAAKa,SAClB,MAEJ,IAAK,YACD,GAAIkyB,EAAS/P,MAAMhjB,KAAKa,QAAQrN,MAAOuP,EAAOrI,MAC1C,OAEJsF,KAAKa,QACDkC,EAAOoH,SACHxW,EAAUyoB,uBAAuBrZ,EAAOrI,MACtCsF,KAAKy0B,uBACfz0B,KAAKu0B,QAAQv0B,KAAKa,SAG9B,EACA6zB,EAAkBlzB,UAAU4I,YAAc,SAAU1L,GAChD,IAAIjJ,EACmB,QAAtBA,EAAKuK,KAAKH,cAA2B,IAAPpK,GAAyBA,EAAGuN,KAAKhD,KAAMtB,EAC1E,EACAg2B,EAAkBlzB,UAAU+yB,QAAU,SAAU1zB,GAC5Cb,KAAKozB,UAAUh0B,QAAQ,SAAUoa,GAAY,OAAOA,EAAS3Y,EAAU,EAC3E,EACA6zB,EAAkBlzB,UAAUizB,qBAAuB,WAC/C,IAAIjqB,EAAQxK,KACZ,OAAOrM,EAAUiuB,qBAAqB,IAAIjiB,QAAQ,SAAUC,EAASC,GACjE2K,EAAM5K,QAAUA,EAChB4K,EAAM3K,OAASA,CACnB,GACJ,EACA60B,EAAkBlzB,UAAUozB,QAAU,SAAUt/B,EAAQ2O,GACpD,IAAI3N,EAAQhB,EAAOgB,MACfmF,EAAOwI,EAAQxI,KAAMyB,EAAW+G,EAAQ/G,SAAUD,EAAegH,EAAQhH,aACzEiuB,EAAO50B,EAAM40B,KAAKt3B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEe,MAAO1O,EAAsB,eAAE4G,EAAUD,GAAeouB,mBAAmB,EAAM/M,GAAI7iB,EAAM0vB,YAAY,KAC3K,OAAOv3B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGq1B,GAAO,CAAEnoB,OAAQzN,EAAqB,aAAEqI,aAAa,CACtFT,SAAUA,EACVD,aAAcA,EACdvC,KAAMwwB,EAAKnoB,UAEvB,EACO2xB,CACX,CA5GyB,GA8GrBI,EAAkB,WAClB,SAASA,EAAc7wB,QACH,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAClD+L,KAAK+0B,UAAY,IAAIhqB,EAAK2G,KAAK/d,EAAUoG,eACzCiG,KAAKg1B,aAAe,IAAIjqB,EAAK2G,KAAK/d,EAAUoG,eAC5CiG,KAAKiE,QAAUA,CACnB,CA6BA,OA5BA6wB,EAActzB,UAAU0qB,YAAc,SAAUF,EAAUiJ,GACtD,IAAI/Q,EAAMlkB,KAAK+0B,UAAUhjB,YAAYia,GASrC,OARK9H,EAAIE,UACLF,EAAIE,QAAU,IAAI+O,EAAuB8B,IAAoB,CACzDrB,qBAAsB5zB,KAAKiE,QAAQ2vB,qBACnCJ,UAAW,kBACAtP,EAAIE,OACf,KAGDF,EAAIE,OACf,EACA0Q,EAActzB,UAAUqsB,eAAiB,SAAU7B,EAAU12B,EAAQ2O,GACjE,IAAIigB,EAAMlkB,KAAKg1B,aAAajjB,YAAYia,GASxC,OARK9H,EAAIE,UACLF,EAAIE,QAAU,IAAIsQ,EAAkBp/B,EAAQ2O,EAAS,CACjD2vB,qBAAsB5zB,KAAKiE,QAAQ2vB,qBACnCJ,UAAW,kBACAtP,EAAIE,OACf,KAGDF,EAAIE,OACf,EACA0Q,EAActzB,UAAUzF,IAAM,SAAUiwB,EAAUC,GACpCjsB,KAAK+0B,UAAUhjB,YAAYia,GACjC5H,QAAU6H,CAClB,EACO6I,CACX,CApCqB,GAsCjBI,EAAsB3gC,OAAOC,IAAI,wBASrCjB,EAAQ4/B,uBAAyBA,EACjC5/B,EAAQw6B,sBAzZR,SAA+B9B,GAC3Bv3B,GAAWu3B,GAAY+G,KAA0B/G,EAAU,GAC/D,EAwZA14B,EAAQs4B,iBAVR,SAA0Bv2B,GACtB,IAAIG,EAIJ,OAHKH,EAAO4/B,KACR5/B,EAAO4/B,GAAuB,IAAIJ,EAAqD,QAAtCr/B,EAAKH,EAAOi0B,eAAe4L,aAA0B,IAAP1/B,OAAgB,EAASA,EAAG2/B,WAExH9/B,EAAO4/B,EAClB,EAKA3hC,EAAQ46B,kBAAoBA,EAC5B56B,EAAQ85B,eAAiBA,EACzB95B,EAAQ+5B,sBAjZR,SAA+BrB,EAAUprB,GACrCorB,EAASgH,GAAkBpyB,CAC/B,EAgZAtN,EAAQ25B,aA1aR,SAAsBgB,GAClB,IAAIz4B,EACAyuB,IAAOzuB,EAAK,CACR4/B,UAAW,WACP,OAAOlH,EAAkBjK,GAAKnjB,KAAK,WAAc,OAAOmjB,CAAK,EACjE,IAED8O,GAA0B9E,EAC7Bz4B,EAAGw9B,GAAkB/E,EAAiBrtB,QACtCpL,GACJ,OAAOyuB,CACX,C,yCC/HA7wB,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBG,EAAQ,EAAQ,wBAChBuC,EAAW,EAAQ,wBACnBxC,EAAY,EAAQ,wBACpBqX,EAAS,EAAQ,wBACjBgY,EAAQ,EAAQ,wBAChBsS,EAAU,EAAQ,wBAClBvqB,EAAO,EAAQ,wBACfpR,EAAU,EAAQ,wBAEtB,SAASC,EAAuB9F,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAW,QAAIA,CAAG,CAE7G,IAAI+F,EAA8BD,EAAsBopB,GAEpDuS,GAAyD,IAAvBv/B,WAAWC,QAajD,WACI,IAAI8B,EAAYiI,KAAKwE,OAAOzM,UAC5B,OAAOnE,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2/B,EAA+Bp8B,MAAM4G,OAAQ,CAAEy1B,8BAmBrEvkB,EAnBiHlR,KAA2B,qBAoBxJ01B,EAAqBxkB,GAAWjO,IAAI,SAAU3M,GAAS,MAAO,CAAGA,MAAOA,EAAU,IApB0Eq/B,cAAe,CAC1KC,oBAAqBC,EAAsB71B,KAAkB,YAAuB,qBACpF81B,wBAAyBD,EAAsB71B,KAAkB,YAA2B,yBAC5F+1B,oBAAqBF,EAAsB71B,KAA0B,sBACtEg2B,iBAAkB,CACjBC,oBAAqBJ,EAAoC,OAAd99B,QAAoC,IAAdA,OAAuB,EAASA,EAAUk+B,qBAC3GC,OAAQL,EAAoC,OAAd99B,QAAoC,IAAdA,OAAuB,EAASA,EAAUm+B,QAC9FhlB,UAAW2kB,EAAoC,OAAd99B,QAAoC,IAAdA,OAAuB,EAASA,EAAUmZ,cAY7G,IAAuBA,CAVvB,OAtBMpY,EACFq9B,GAAuD,IAAvBngC,WAAWC,QAC3Cu/B,OACE18B,EACN,SAAS08B,IACL,MAAO,CACHl/B,MAAO,CACH8/B,uBAAwBP,EAAsB71B,KAAqB,iBAG/E,CAgBA,SAAS61B,EAAsBQ,GAC3B,OAJJ,SAAmBA,GACf,QAASA,GAAK,aAAcA,CAChC,CAEWC,CAAUD,GAAKA,EAAEt9B,UAAOD,CACnC,CACA,SAASy9B,EAAU/iC,GACf,OAAgB,MAATA,CACX,CAIA,SAASkiC,EAAqBxkB,GAC1B,OAAOA,EACHtd,EAAMyF,cAAczF,EAAMyF,cAAc,CACpCw8B,EAAoC,OAAd3kB,QAAoC,IAAdA,OAAuB,EAASA,EAAuB,cACpGwkB,EAAmC,OAAdxkB,QAAoC,IAAdA,OAAuB,EAASA,EAAgB,OAAI,GAAOwkB,EAAmC,OAAdxkB,QAAoC,IAAdA,OAAuB,EAASA,EAAiB,QAAI,GAAMtT,OAAO24B,GACpN,EACV,CAEA,SAASC,EAAaxxB,EAAOvP,EAAI+F,EAAI7D,GACjC,IAAI8+B,EAAQhhC,EAAGiF,KAAMg8B,EAAQ9iC,EAAMoT,OAAOvR,EAAI,CAAC,SAC3CkhC,EAAQn7B,EAAGd,KAAMk8B,EAAQhjC,EAAMoT,OAAOxL,EAAI,CAAC,SAC/C,OAAQ3B,EAAe68B,EAAOE,IAC1BC,EAAoBljC,EAAUwU,kBAAkBnD,GAAOrK,aAAc87B,EAAOE,EAAO,CAC/Ex5B,YAAaxJ,EAAUqK,kBAAkBrK,EAAUsK,uBAAuB+G,IAC1ErN,UAAWA,GAEvB,CACA,SAASk/B,EAAoBl8B,EAAcm8B,EAASC,EAASpiC,GACzD,GAAImiC,IAAYC,EACZ,OAAO,EAEX,IAAIC,EAAiB,IAAI38B,IACzB,OAAOM,EAAauB,WAAWiS,MAAM,SAAUhS,GAC3C,GAAI66B,EAAe37B,IAAIc,GACnB,OAAO,EAEX,GADA66B,EAAej7B,IAAII,IACdxI,EAAUytB,cAAcjlB,EAAWxH,EAAQgD,WAC5C,OAAO,EACX,GAAIs/B,EAAiC96B,GACjC,OAAO,EACX,GAAIxI,EAAU6c,QAAQrU,GAAY,CAC9B,IAAI+6B,EAAYvjC,EAAU4I,uBAAuBJ,GAC7Cg7B,EAAeL,GAAWA,EAAQI,GAClCE,EAAeL,GAAWA,EAAQG,GAClC16B,EAAoBL,EAAUxB,aAClC,IAAK6B,EACD,OAAO3C,EAAes9B,EAAcC,GAExC,IAAIC,EAAgB/9B,MAAMC,QAAQ49B,GAC9BG,EAAgBh+B,MAAMC,QAAQ69B,GAClC,GAAIC,IAAkBC,EAClB,OAAO,EACX,GAAID,GAAiBC,EAAe,CAChC,IAAIC,EAAWJ,EAAa9+B,OAC5B,GAAI++B,EAAa/+B,SAAWk/B,EACxB,OAAO,EAEX,IAAK,IAAIz1B,EAAI,EAAGA,EAAIy1B,IAAYz1B,EAC5B,IAAK+0B,EAAoBr6B,EAAmB26B,EAAar1B,GAAIs1B,EAAat1B,GAAInN,GAC1E,OAAO,EAGf,OAAO,CACX,CACA,OAAOkiC,EAAoBr6B,EAAmB26B,EAAcC,EAAcziC,EAC9E,CAEI,IAAIuI,EAAWvJ,EAAUqZ,yBAAyB7Q,EAAWxH,EAAQwI,aACrE,OAAID,IACI+5B,EAAiC/5B,IAE9B25B,EAAoB35B,EAASvC,aACpCm8B,EAASC,EAASpiC,QAJtB,CAOR,EACJ,CACA,SAASsiC,EAAiC96B,GACtC,QAAUA,EAAUyP,YAAczP,EAAUyP,WAAWvD,KAAKmvB,EAChE,CACA,SAASA,EAAuBC,GAC5B,MAA0B,gBAAnBA,EAAI5gC,KAAKrD,KACpB,CAEA,IAAIgD,EAAsBjC,OAAOC,IAAI,uBACjCiC,EAAShD,EAAQgD,OACjBC,EAAO,IAAIP,EAASQ,KAIxB,SAAS6C,EAAiB3C,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,OAAOzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CACA,SAAS4rB,EAAkB5gB,EAASpN,EAAMiuB,EAAUC,QACzB,IAAnBA,IAA6BA,EAAiB,8BAOtD,SAAwBluB,EAAMC,IAlB9B,SAAiBD,GACb,OAAOJ,EAAOD,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC3E,EAiBSI,CAAQJ,IACTC,GAER,CAVIF,CAAeC,EAAM,WACbA,KAAQoN,IACe,IAAvBjO,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAAK4uB,EAAUjuB,EAAMkuB,EAEpF,EACJ,CAOA,IAAI2S,EAAgB,WAChB,SAASA,IACL13B,KAAK23B,wBAAyB,EAC9B33B,KAAK43B,eAAiBzhC,EAASyb,KAAKje,EAAUmpB,yBAA0B,CACpE3P,IAAKxZ,EAAU+D,WAAW,iCACtB,IACJpB,MAAO0U,EAAOuC,WAEtB,CA2IA,OA1IAmqB,EAAYl2B,UAAUpE,eAAiB,SAAUH,GAC7C,OAAO,IACX,EACAy6B,EAAYl2B,UAAUq2B,MAAQ,SAAU5zB,GACpC,IAII6zB,EAJAttB,EAAQxK,KACR+3B,EAA6C,kBAAvB9zB,EAAQknB,WAA0BlnB,EAAQknB,YACvC,IAAvBlnB,EAAQknB,WAAuB,UAC3B,EAGV,OADAnrB,KAAKg4B,mBAAmB,WAAc,OAAQF,EAAe7zB,EAAQqtB,OAAO9mB,EAAS,EAAGutB,GACjFD,CACX,EACAJ,EAAYl2B,UAAUy2B,4BAA8B,SAAUC,EAAaH,GACvE/3B,KAAKg4B,mBAAmBE,EAAaH,EACzC,EACAL,EAAYl2B,UAAUgQ,kBAAoB,SAAUha,GAChD,OAAOA,CACX,EACAkgC,EAAYl2B,UAAU22B,iBAAmB,SAAU3gC,GAC/C,OAAOA,CACX,EACAkgC,EAAYl2B,UAAUwpB,SAAW,SAAUoN,GAE3C,EACAV,EAAYl2B,UAAU62B,GAAK,WACvB,MAAO,EACX,EACAX,EAAYl2B,UAAU82B,OAAS,SAAUr0B,GACrC,OAAO,CACX,EACAyzB,EAAYl2B,UAAU+2B,UAAY,SAAUt0B,EAASknB,GACjD,IAAI3gB,EAAQxK,KAKZ,YAJmB,IAAfmrB,IAAyBA,IAAelnB,EAAQknB,aACzB,IAAvBn1B,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,mBAE3CzK,EAAiB,kBAAmB,WACvC,OAAOgR,EAAMrK,KAAKvM,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEu0B,OAAQv0B,EAAQqa,IAAM,aAAc6M,WAAYA,IACpH,EACJ,EACAuM,EAAYl2B,UAAU+pB,cAAgB,SAAUtnB,GAC5C,IAAIuG,EAAQxK,KACR9C,EAAW+G,EAAQ/G,SAAUD,EAAegH,EAAQhH,aAAcxB,EAAOwI,EAAQxI,KAAMhG,EAAKwO,EAAQknB,WAAYA,OAAoB,IAAP11B,GAAuBA,EAAI+zB,EAAe51B,EAAMoT,OAAO/C,EAAS,CAAC,WAAY,eAAgB,OAAQ,eAClOe,EAAQhF,KAAK43B,eAAe16B,EAAUD,GACtCqhB,EAAqB,qBAAT7iB,GAAwC,kBAATA,EAC3CA,EACEuE,KAAKgrB,SAASvvB,GAChBg9B,IAAgBx0B,EAAQ1P,OAAOC,IAAI,uBACvC,IAA2B,IAAvBwB,WAAWC,QAAmB,CAC9B,IAAI8mB,EAAqB9f,GAAgBtJ,EAAUgd,sBAAsBzT,GAAUrG,KAAKrD,MACnF8qB,IACsB,IAAvBtoB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,EAAG6mB,EAElE,CACA,IACI2b,EADAC,EAAc/kC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2zB,GAAe,CAAE6B,mBAAmB,EAAM/M,GAAIA,EAAItZ,MAAOA,EAAOmmB,WAAYA,IAEhI,OAAO,IAAIx3B,EAAU4U,WAAW,SAAUC,GACtC,OAAOgC,EAAMouB,MAAMhlC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG8iC,GAAc,CAAEE,WAAW,EAAMnf,SAAU,SAAUwR,GAClG,IAAIxwB,EAAO+9B,EACPnD,EAAQ33B,aAAautB,EAAKnoB,OAAQ7F,EAAUsN,EAAOvN,GACjDiuB,EAAKnoB,OACX,IACA21B,IACIlC,EAAaxxB,EAAO,CAAEtK,KAAMg+B,EAAW31B,QAAU,CAAErI,KAAMA,GACzDuJ,EAAQtM,WAHZ,CAMA,IAAIoL,EAAS,CACTrI,KAAMA,EACNyP,WAAY+gB,EAAK/gB,UAEjB+gB,EAAKO,UACL1oB,EAAO0oB,QAAU93B,EAAUoiB,eAAemV,EAAKO,QAAQxoB,IAAI,SAAUvE,GAAS,OAAOA,EAAM+sB,OAAS,KAExGiN,EAAa9kC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGq1B,GAAO,CAAEnoB,OAAQrI,IAChE8N,EAAS9I,KAAKqD,EATd,CAUJ,IACR,EACJ,EACA20B,EAAYl2B,UAAUs3B,aAAe,SAAU70B,EAASknB,GACpD,IAAI3gB,EAAQxK,KAKZ,YAJmB,IAAfmrB,IAAyBA,IAAelnB,EAAQknB,aACzB,IAAvBn1B,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,sBAE3CzK,EAAiB,kBAAmB,WACvC,OAAOgR,EAAMrK,KAAKvM,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEe,MAAOwF,EAAMotB,eAAe3zB,EAAQ/G,SAAU+G,EAAQhH,cAAeu7B,OAAQv0B,EAAQqa,GAAI6M,WAAYA,IACzK,EACJ,EACAuM,EAAYl2B,UAAUu3B,WAAa,SAAUtjC,GACzC,IAAI6oB,EAAK7oB,EAAG6oB,GAAI5jB,EAAOjF,EAAGiF,KAAMuJ,EAAUrQ,EAAMoT,OAAOvR,EAAI,CAAC,KAAM,SAClE,OAAOuK,KAAKg5B,MAAM3lC,OAAO0a,OAAO9J,EAAS,CACrCg1B,OAAQ3a,GAAM,aACdvb,OAAQrI,IAEhB,EACAg9B,EAAYl2B,UAAU03B,cAAgB,SAAUzjC,GAC5C,IAAI6oB,EAAK7oB,EAAG6oB,GAAI5jB,EAAOjF,EAAGiF,KAAMwC,EAAWzH,EAAGyH,SAAUD,EAAexH,EAAGwH,aAAcgH,EAAUrQ,EAAMoT,OAAOvR,EAAI,CAAC,KAAM,OAAQ,WAAY,iBAC9I,OAAOuK,KAAKg5B,MAAM3lC,OAAO0a,OAAO9J,EAAS,CACrCe,MAAOhF,KAAK43B,eAAe16B,EAAUD,GACrCg8B,OAAQ3a,EACRvb,OAAQrI,IAEhB,EACAg9B,EAAYl2B,UAAUmmB,YAAc,SAAU1jB,EAASqtB,GAInD,OAH2B,IAAvBt7B,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,qBAE3CjE,KAAK63B,MAAM,CACdvG,OAAQ,SAAUh7B,GACd,IAAI9C,EAAQgG,EAAiB,kBAAmB,WAC5C,OAAOlD,EAAMiiC,UAAUt0B,EAC3B,GACIvJ,EAAO42B,EAAO99B,GAClB,YAAa,IAATkH,GAA4B,OAATA,EACZlH,GACX8C,EAAMyiC,WAAWnlC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEvJ,KAAMA,KAC9DA,EACX,GAER,EACAg9B,EAAYl2B,UAAU23B,eAAiB,SAAUl1B,EAASqtB,GAItD,OAH2B,IAAvBt7B,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,wBAE3CjE,KAAK63B,MAAM,CACdvG,OAAQ,SAAUh7B,GACd,IAAI9C,EAAQgG,EAAiB,kBAAmB,WAC5C,OAAOlD,EAAMwiC,aAAa70B,EAC9B,GACIvJ,EAAO42B,EAAO99B,GAClB,YAAa,IAATkH,GAA4B,OAATA,EACZlH,GACX8C,EAAM4iC,cAActlC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEvJ,KAAMA,KACjEA,EACX,GAER,EACOg9B,CACX,CApJmB,IAqJQ,IAAvB1hC,WAAWC,UACXyhC,EAAYl2B,UAAU43B,mBAAqBjD,GAG/C5iC,EAAQ8lC,WAAQ,EAEb9lC,EAAQ8lC,QAAU9lC,EAAQ8lC,MAAQ,CAAC,GAEtC,IAAIC,EAAsB,SAAU/uB,GAEhC,SAAS+uB,EAAkB71B,EAASxI,EAAM+J,EAAOrN,GAC7C,IAAIlC,EACA+U,EAAQD,EAAOvH,KAAKhD,KAAMyD,IAAYzD,KAK1C,GAJAwK,EAAM/G,QAAUA,EAChB+G,EAAMvP,KAAOA,EACbuP,EAAMxF,MAAQA,EACdwF,EAAM7S,UAAYA,EACd2B,MAAMC,QAAQiR,EAAMvP,MAAO,CAC3BuP,EAAMihB,QAAUjhB,EAAM/G,QACtB,IAAK,IAAI3B,EAAI0I,EAAMvP,KAAK5C,OAAS,EAAGyJ,GAAK,IAAKA,EAC1C0I,EAAMihB,UAAWh2B,EAAK,CAAC,GAAM+U,EAAMvP,KAAK6G,IAAM0I,EAAMihB,QAASh2B,EAErE,MAEI+U,EAAMihB,QAAUjhB,EAAMvP,KAG1B,OADAuP,EAAMsM,UAAYwiB,EAAkB93B,UAC7BgJ,CACX,CACA,OApBA5W,EAAM8W,UAAU4uB,EAAmB/uB,GAoB5B+uB,CACX,CAtByB,CAsBvBl4B,OAEEm4B,EAASlmC,OAAOmO,UAAUD,eAC9B,SAASi4B,EAAUhmC,GACf,OAAiB,OAAVA,QAA4B,IAAVA,CAC7B,CACA,SAASimC,EAAwBhkC,EAAId,GACjC,IAAIoI,EAAatH,EAAGsH,WAAYuhB,EAAK7oB,EAAG6oB,GAAIob,EAAMjkC,EAAGikC,IACrD,GAA0B,kBAAf38B,IACHpI,IACAA,EAAQglC,UACHH,EAAUlb,GACJkb,EAAUE,QACP,EADc,CAAEA,IAAKA,GADd,CAAEpb,GAAIA,IAI3Bkb,EAAUlb,KAAQkb,EAAUE,KAC5Bpb,EAAKob,IAEJF,EAAUlb,IACX,MAAO,GAAGxiB,OAAOiB,EAAY,KAAKjB,OAAqB,kBAAPwiB,GAAiC,kBAAPA,EACtEA,EACE/b,KAAKgB,UAAU+a,GAGjC,CACA,IAAIsb,EAAgB,CAChBC,iBAAkBJ,EAClBK,aAAa,EACbC,eAAe,EACf1F,iBAAiB,GAKrB,SAAS2F,EAAsBx1B,GAC3B,IAAIhR,EAAQgR,EAAO6vB,gBACnB,YAAiB,IAAV7gC,EAAmBomC,EAAcvF,gBAAkB7gC,CAC9D,CAMA,IAAIymC,EAAwB,qBAC5B,SAASC,EAAuBC,GAC5B,IAAIC,EAAQD,EAAeC,MAAMH,GACjC,OAAOG,EAAQA,EAAM,GAAKD,CAC9B,CACA,SAASE,EAA0B1/B,EAAcoI,EAAQpL,GACrD,QAAIhE,EAAUiZ,gBAAgB7J,KACnBpP,EAAU4F,QAAQwJ,GACrBA,EAAOoL,MAAM,SAAUtS,GACnB,OAAOw+B,EAA0B1/B,EAAckB,EAAMlE,EACzD,GACEgD,EAAauB,WAAWiS,MAAM,SAAUmC,GACtC,GAAI3c,EAAU6c,QAAQF,IAAU3c,EAAUytB,cAAc9Q,EAAO3Y,GAAY,CACvE,IAAImO,EAAMnS,EAAU4I,uBAAuB+T,GAC3C,OAAQipB,EAAOv2B,KAAKD,EAAQ+C,MACtBwK,EAAM3V,cACJ0/B,EAA0B/pB,EAAM3V,aAAcoI,EAAO+C,GAAMnO,GACvE,CACA,OAAO,CACX,GAGZ,CACA,SAAS2iC,EAAwB9mC,GAC7B,OAAOG,EAAUiZ,gBAAgBpZ,KAAWG,EAAUsqB,YAAYzqB,KAAWG,EAAU4F,QAAQ/F,EACnG,CAIA,SAAS+mC,EAAuB/iC,EAAUO,GACtC,IAAIoF,EAAcxJ,EAAUqK,kBAAkBrK,EAAUsK,uBAAuBzG,IAC/E,MAAO,CACH2F,YAAaA,EACbC,eAAgB,SAAUvG,GACtB,IAAIie,EAAM3X,EAAYtG,GAItB,OAHKie,GAAO/c,IACR+c,EAAM/c,EAAUm+B,OAAOr/B,IAEpBie,GAAO,IAClB,EAER,CAEA,IAAI0lB,EAASnnC,OAAOY,OAAO,MACvBwmC,EAAc,WAAc,OAAOD,CAAQ,EAC3CE,EAAarnC,OAAOY,OAAO,MAC/BV,EAAQonC,YAAgB,WACpB,SAASA,EAAYC,EAAUC,GAC3B,IAAIrwB,EAAQxK,KACZA,KAAK46B,SAAWA,EAChB56B,KAAK66B,MAAQA,EACb76B,KAAKtF,KAAOrH,OAAOY,OAAO,MAC1B+L,KAAK86B,QAAUznC,OAAOY,OAAO,MAC7B+L,KAAK+6B,KAAO1nC,OAAOY,OAAO,MAC1B+L,KAAKg7B,cAAgB,SAAUC,EAAmBd,GAC9C,OAAOxmC,EAAUoH,gBAAgBpH,EAAUsqB,YAAYgd,GACnDzwB,EAAM3S,IAAIojC,EAAkB9c,MAAOgc,GACjCc,GAAqBA,EAAkBd,GACjD,EACAn6B,KAAKof,QAAU,SAAU8b,GACrB,OAAOvnC,EAAUsqB,YAAYid,GACzB1wB,EAAMnP,IAAI6/B,EAAS/c,OACG,kBAAb+c,CACjB,EACAl7B,KAAKm7B,YAAc,SAAUC,EAAcC,GACvC,GAA4B,kBAAjBD,EACP,OAAOznC,EAAU0qB,cAAc+c,GAEnC,GAAIznC,EAAUsqB,YAAYmd,GACtB,OAAOA,EAEX,IAAI9c,EAAK9T,EAAMowB,SAAS5P,SAASoQ,GAAc,GAC/C,GAAI9c,EAAI,CACJ,IAAI4F,EAAMvwB,EAAU0qB,cAAcC,GAIlC,OAHI+c,GACA7wB,EAAM4L,MAAMkI,EAAI8c,GAEblX,CACX,CACJ,CACJ,CAsTA,OArTAyW,EAAYn5B,UAAU85B,SAAW,WAC7B,OAAO1nC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKtF,KACnC,EACAigC,EAAYn5B,UAAUnG,IAAM,SAAU49B,GAClC,YAAqC,IAA9Bj5B,KAAKk2B,OAAO+C,GAAQ,EAC/B,EACA0B,EAAYn5B,UAAU3J,IAAM,SAAUohC,EAAQz7B,GAE1C,GADAwC,KAAK66B,MAAMU,OAAOtC,EAAQz7B,GACtB+7B,EAAOv2B,KAAKhD,KAAKtF,KAAMu+B,GAAS,CAChC,IAAIuC,EAAcx7B,KAAKtF,KAAKu+B,GAC5B,GAAIuC,GAAejC,EAAOv2B,KAAKw4B,EAAah+B,GACxC,OAAOg+B,EAAYh+B,EAE3B,CACA,MAAkB,eAAdA,GACA+7B,EAAOv2B,KAAKhD,KAAK46B,SAASa,kBAAmBxC,GACtCj5B,KAAK46B,SAASa,kBAAkBxC,GAEvCj5B,gBAAgB07B,EACT17B,KAAKsV,OAAOzd,IAAIohC,EAAQz7B,QADnC,CAGJ,EACAm9B,EAAYn5B,UAAU00B,OAAS,SAAU+C,EAAQ0C,GAG7C,OAFIA,GACA37B,KAAK66B,MAAMU,OAAOtC,EAAQ,YAC1BM,EAAOv2B,KAAKhD,KAAKtF,KAAMu+B,GAChBj5B,KAAKtF,KAAKu+B,GAEjBj5B,gBAAgB07B,EACT17B,KAAKsV,OAAO4gB,OAAO+C,EAAQ0C,GAElC37B,KAAK46B,SAASa,kBAAkBxC,GACzB5lC,OAAOY,OAAO,WADzB,CAGJ,EACA0mC,EAAYn5B,UAAU4U,MAAQ,SAAUwlB,EAAOC,GAC3C,IACI5C,EADAzuB,EAAQxK,KAERrM,EAAUsqB,YAAY2d,KACtBA,EAAQA,EAAMzd,OACdxqB,EAAUsqB,YAAY4d,KACtBA,EAAQA,EAAM1d,OAClB,IAAIjC,EAA4B,kBAAV0f,EAAqB57B,KAAKk2B,OAAQ+C,EAAS2C,GAAUA,EACvEzf,EAA4B,kBAAV0f,EAAqB77B,KAAKk2B,OAAQ+C,EAAS4C,GAAUA,EAC3E,GAAK1f,EAAL,CAEA1oB,EAAQiB,UAA4B,kBAAXukC,EAAqB,GAC9C,IAAIja,EAAS,IAAIrrB,EAAUwiB,WAAW2lB,GAAuB1lB,MAAM8F,EAAUC,GAE7E,GADAnc,KAAKtF,KAAKu+B,GAAUja,EAChBA,IAAW9C,WACJlc,KAAK+6B,KAAK9B,GACbj5B,KAAK66B,MAAMkB,SAAS,CACpB,IAAIC,EAAkB3oC,OAAOY,OAAO,MAC/BioB,IACD8f,EAAgBC,SAAW,GAC/B5oC,OAAOkK,KAAK4e,GAAU/c,QAAQ,SAAU+6B,GACpC,IAAKje,GACDA,EAASie,KAAoBnb,EAAOmb,GAAiB,CACrD6B,EAAgB7B,GAAkB,EAClC,IAAI38B,EAAY08B,EAAuBC,GACnC38B,IAAc28B,GACb3vB,EAAMowB,SAASsB,WAAWld,EAAOjiB,WAAYS,KAC9Cw+B,EAAgBx+B,GAAa,QAEF,IAA3BwhB,EAAOmb,IAAgC3vB,aAAiBkxB,UACjD1c,EAAOmb,EAEtB,CACJ,IACI6B,EAAgBj/B,YACdmf,GAAYA,EAASnf,YACvBiD,KAAK46B,SAASa,kBAAkBxC,KAAYja,EAAOjiB,mBAC5Ci/B,EAAgBj/B,WAE3B1J,OAAOkK,KAAKy+B,GAAiB58B,QAAQ,SAAU5B,GAC3C,OAAOgN,EAAMqwB,MAAMsB,MAAMlD,EAAQz7B,EACrC,EACJ,CAhCM,CAkCd,EACAm9B,EAAYn5B,UAAU82B,OAAS,SAAUW,EAAQ9pB,GAC7C,IAAI3E,EAAQxK,KACRw7B,EAAcx7B,KAAKk2B,OAAO+C,GAC9B,GAAIuC,EAAa,CACb,IAAIY,EAAkB/oC,OAAOY,OAAO,MAChCooC,GAAgB,EAChBC,GAAe,EACfC,EAAkB,CAClB/B,OAAQA,EACRE,WAAYA,EACZzc,YAAatqB,EAAUsqB,YACvBkd,YAAan7B,KAAKm7B,YAClB/b,QAASpf,KAAKof,QACdC,UAAW,SAAUmd,EAAoB/gC,GACrC,OAAO+O,EAAMowB,SAASvb,UAAwC,kBAAvBmd,EACnC,CACIh/B,UAAWg/B,EACX/gC,KAAMA,GAAQ9H,EAAU0qB,cAAc4a,IAExCuD,EAAoB,CAAEC,MAAOjyB,GACvC,GA8DJ,GA5DAnX,OAAOkK,KAAKi+B,GAAap8B,QAAQ,SAAU+6B,GACvC,IAAI38B,EAAY08B,EAAuBC,GACnCuC,EAAalB,EAAYrB,GAC7B,QAAmB,IAAfuC,EAAJ,CAEA,IAAIpE,EAA2B,oBAAXnpB,EAAwBA,EAAUA,EAAOgrB,IAAmBhrB,EAAO3R,GACvF,GAAI86B,EAAQ,CACR,IAAI56B,EAAW46B,IAAWmC,EAAcD,EAAUlC,EAAO3kC,EAAUoH,gBAAgB2hC,GAAa9oC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG0mC,GAAkB,CAAE/+B,UAAWA,EAAW28B,eAAgBA,EAAgBwC,QAASnyB,EAAMoyB,WAAW3D,EAAQkB,MAC9O,GAAIz8B,IAAag9B,EACblwB,EAAMqwB,MAAMsB,MAAMlD,EAAQkB,QAK1B,GAFIz8B,IAAa88B,IACb98B,OAAW,GACXA,IAAag/B,IACbN,EAAgBjC,GAAkBz8B,EAClC2+B,GAAgB,EAChBK,EAAah/B,GACc,IAAvB1H,WAAWC,SAAmB,CAC9B,IAAI4mC,EAAiB,SAAU3Y,GAC3B,QAAgCprB,IAA5B0R,EAAM0rB,OAAOhS,EAAI/F,OAEjB,OADuB,IAAvBnoB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,EAAGguB,IACnD,CAEf,EACA,GAAIvwB,EAAUsqB,YAAYvgB,GACtBm/B,EAAen/B,QAEd,GAAIpE,MAAMC,QAAQmE,GAGnB,IAFA,IAAIo/B,GAAgB,EAChBC,OAAmB,EACd5kC,EAAK,EAAG6kC,EAAat/B,EAAUvF,EAAK6kC,EAAW3kC,OAAQF,IAAM,CAClE,IAAI3E,EAAQwpC,EAAW7kC,GACvB,GAAIxE,EAAUsqB,YAAYzqB,IAEtB,GADAspC,GAAgB,EACZD,EAAerpC,GACf,WAGJ,GAAqB,kBAAVA,GAAwBA,EACtBgX,EAAMowB,SAAS5P,SAASx3B,GAAO,KAEpCupC,EAAmBvpC,GAI/B,GAAIspC,QAAsChkC,IAArBikC,EAAgC,EAC1B,IAAvB/mC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,EAAG6mC,GAC1D,KACJ,CACJ,CAER,CAGZ,MACmB,IAAfL,IACAJ,GAAe,EArDT,CAuDd,GACID,EAWA,OAVAr8B,KAAKoW,MAAM6iB,EAAQmD,GACfE,IACIt8B,gBAAgB07B,EAChB17B,KAAKtF,KAAKu+B,QAAU,SAGbj5B,KAAKtF,KAAKu+B,GAErBj5B,KAAK66B,MAAMsB,MAAMlD,EAAQ,cAEtB,CAEf,CACA,OAAO,CACX,EACA0B,EAAYn5B,UAAUiK,OAAS,SAAUwtB,EAAQz7B,EAAWvE,GACxD,IAAIxD,EACA+lC,EAAcx7B,KAAKk2B,OAAO+C,GAC9B,GAAIuC,EAAa,CACb,IAAIne,EAAWrd,KAAKg7B,cAAcQ,EAAa,cAC3CrB,EAAiB38B,GAAavE,EAC9B+G,KAAK46B,SAASqC,kBAAkB,CAAE5f,SAAUA,EAAU7f,UAAWA,EAAWvE,KAAMA,IAChFuE,EACN,OAAOwC,KAAKs4B,OAAOW,EAAQkB,IAAkB1kC,EAAK,CAAC,GAC5C0kC,GAAkBM,EACrBhlC,GAAMglC,EACd,CACA,OAAO,CACX,EACAE,EAAYn5B,UAAU07B,MAAQ,SAAUj5B,EAASk5B,GAC7C,IAAIC,GAAU,EAYd,OAXIn5B,EAAQqa,KACJib,EAAOv2B,KAAKhD,KAAKtF,KAAMuJ,EAAQqa,MAC/B8e,EAAUp9B,KAAKyL,OAAOxH,EAAQqa,GAAIra,EAAQzG,UAAWyG,EAAQhL,OAE7D+G,gBAAgB07B,GAAS17B,OAASm9B,IAClCC,EAAUp9B,KAAKsV,OAAO4nB,MAAMj5B,EAASk5B,IAAUC,IAE/Cn5B,EAAQzG,WAAa4/B,IACrBp9B,KAAK66B,MAAMsB,MAAMl4B,EAAQqa,GAAIra,EAAQzG,WAAa,aAGnD4/B,CACX,EACAzC,EAAYn5B,UAAU67B,MAAQ,WAC1Br9B,KAAKvC,QAAQ,KACjB,EACAk9B,EAAYn5B,UAAU87B,QAAU,WAC5B,IAAI9yB,EAAQxK,KACRsB,EAAMtB,KAAKs7B,WACXiC,EAAe,GASnB,OARAv9B,KAAKw9B,eAAep+B,QAAQ,SAAUkf,GAC7Bib,EAAOv2B,KAAKwH,EAAMowB,SAASa,kBAAmBnd,IAC/Cif,EAAa/kC,KAAK8lB,EAE1B,GACIif,EAAallC,SACbiJ,EAAIm8B,OAAS,CAAEF,aAAcA,EAAahvB,SAEvCjN,CACX,EACAq5B,EAAYn5B,UAAU/D,QAAU,SAAUigC,GACtC,IAAIlzB,EAAQxK,KAMZ,GALA3M,OAAOkK,KAAKyC,KAAKtF,MAAM0E,QAAQ,SAAU65B,GAC/ByE,GAAWnE,EAAOv2B,KAAK06B,EAASzE,IAClCzuB,EAAMiB,OAAOwtB,EAErB,GACIyE,EAAS,CACT,IAAID,EAASC,EAAQD,OAAQE,EAAS/pC,EAAMoT,OAAO02B,EAAS,CAAC,WAC7DrqC,OAAOkK,KAAKogC,GAAQv+B,QAAQ,SAAU65B,GAClCzuB,EAAM4L,MAAM6iB,EAAQ0E,EAAO1E,GAC/B,GACIwE,GACAA,EAAOF,aAAan+B,QAAQY,KAAKssB,OAAQtsB,KAEjD,CACJ,EACA26B,EAAYn5B,UAAU8qB,OAAS,SAAUkM,GACrC,OAAQx4B,KAAK86B,QAAQtC,IAAWx4B,KAAK86B,QAAQtC,IAAW,GAAK,CACjE,EACAmC,EAAYn5B,UAAUo8B,QAAU,SAAUpF,GACtC,GAAIx4B,KAAK86B,QAAQtC,GAAU,EAAG,CAC1B,IAAIviB,IAAUjW,KAAK86B,QAAQtC,GAG3B,OAFKviB,UACMjW,KAAK86B,QAAQtC,GACjBviB,CACX,CACA,OAAO,CACX,EACA0kB,EAAYn5B,UAAUg8B,aAAe,SAAUK,GAS3C,YARY,IAARA,IAAkBA,EAAM,IAAIxjC,KAChChH,OAAOkK,KAAKyC,KAAK86B,SAAS17B,QAAQy+B,EAAI9hC,IAAK8hC,GACvC79B,gBAAgB07B,EAChB17B,KAAKsV,OAAOkoB,aAAaK,GAGzBxqC,OAAOkK,KAAKyC,KAAK46B,SAASa,mBAAmBr8B,QAAQy+B,EAAI9hC,IAAK8hC,GAE3DA,CACX,EACAlD,EAAYn5B,UAAU62B,GAAK,WACvB,IAAI7tB,EAAQxK,KACR69B,EAAM79B,KAAKw9B,eACXM,EAAW99B,KAAKs7B,WACpBuC,EAAIz+B,QAAQ,SAAUkf,GACdib,EAAOv2B,KAAK86B,EAAUxf,KACtBjrB,OAAOkK,KAAKiN,EAAMuzB,gBAAgBzf,IAAKlf,QAAQy+B,EAAI9hC,IAAK8hC,UACjDC,EAASxf,GAExB,GACA,IAAI0f,EAAc3qC,OAAOkK,KAAKugC,GAC9B,GAAIE,EAAY3lC,OAAQ,CAEpB,IADA,IAAI4lC,EAASj+B,KACNi+B,aAAkBvC,GACrBuC,EAASA,EAAO3oB,OACpB0oB,EAAY5+B,QAAQ,SAAUkf,GAAM,OAAO2f,EAAOxyB,OAAO6S,EAAK,EAClE,CACA,OAAO0f,CACX,EACArD,EAAYn5B,UAAUu8B,gBAAkB,SAAU9E,GAC9C,IAAKM,EAAOv2B,KAAKhD,KAAK+6B,KAAM9B,GAAS,CACjC,IAAIiF,EAAWl+B,KAAK+6B,KAAK9B,GAAU5lC,OAAOY,OAAO,MAC7CkX,EAAOnL,KAAKtF,KAAKu+B,GACrB,IAAK9tB,EACD,OAAO+yB,EACX,IAAIC,EAAY,IAAI9jC,IAAI,CAAC8Q,IACzBgzB,EAAU/+B,QAAQ,SAAUkC,GACpB3N,EAAUsqB,YAAY3c,KACtB48B,EAAQ58B,EAAI6c,QAAS,GAErBxqB,EAAUiZ,gBAAgBtL,IAC1BjO,OAAOkK,KAAK+D,GAAKlC,QAAQ,SAAU0G,GAC/B,IAAIyR,EAAQjW,EAAIwE,GACZnS,EAAUiZ,gBAAgB2K,IAC1B4mB,EAAUpiC,IAAIwb,EAEtB,EAER,EACJ,CACA,OAAOvX,KAAK+6B,KAAK9B,EACrB,EACA0B,EAAYn5B,UAAUqQ,aAAe,WACjC,OAAO7R,KAAK66B,MAAMuD,SAASrsB,YAAY7Y,UAC3C,EACOyhC,CACX,CAzVuB,GA0VvB,IAwCWA,EACH0D,EAzCJC,EAAe,WACf,SAASA,EAAWvC,EAASzmB,QACV,IAAXA,IAAqBA,EAAS,MAClCtV,KAAK+7B,QAAUA,EACf/7B,KAAKsV,OAASA,EACdtV,KAAKiI,EAAI,KACTjI,KAAKu+B,cACT,CAuBA,OAtBAD,EAAW98B,UAAU+8B,aAAe,WAChCv+B,KAAKiI,EAAIjI,KAAK+7B,QAAU5lC,EAASqoC,MAAQ,KACzCx+B,KAAKo+B,SAAW,IAAIrzB,EAAK2G,KAAK/d,EAAUoG,cAC5C,EACAukC,EAAW98B,UAAU+5B,OAAS,SAAUtC,EAAQkB,GAC5C,GAAIn6B,KAAKiI,EAAG,CACRjI,KAAKiI,EAAEw2B,EAAWxF,EAAQkB,IAC1B,IAAI38B,EAAY08B,EAAuBC,GACnC38B,IAAc28B,GACdn6B,KAAKiI,EAAEw2B,EAAWxF,EAAQz7B,IAE1BwC,KAAKsV,QACLtV,KAAKsV,OAAOimB,OAAOtC,EAAQkB,EAEnC,CACJ,EACAmE,EAAW98B,UAAU26B,MAAQ,SAAUlD,EAAQkB,GACvCn6B,KAAKiI,GACLjI,KAAKiI,EAAEk0B,MAAMsC,EAAWxF,EAAQkB,GACb,aAAnBA,EAAgC,SAAW,WAEnD,EACOmE,CACX,CA/BkB,GAgClB,SAASG,EAAWxF,EAAQkB,GACxB,OAAOA,EAAiB,IAAMlB,CAClC,CACA,SAASyF,EAA+BjC,EAAOkC,GACvCC,EAAsBnC,IACtBA,EAAM5B,MAAMU,OAAOoD,EAAU,WAErC,CACWhE,EAwBRpnC,EAAQonC,cAAgBpnC,EAAQonC,YAAc,CAAC,GAvB1C0D,EAAS,SAAU9zB,GAEnB,SAAS8zB,EAAK5oC,GACV,IAAImlC,EAAWnlC,EAAGmlC,SAAUp/B,EAAK/F,EAAGskC,cAAeA,OAAuB,IAAPv+B,GAAuBA,EAAIqjC,EAAOppC,EAAGopC,KACpGr0B,EAAQD,EAAOvH,KAAKhD,KAAM46B,EAAU,IAAI0D,EAAWvE,KAAmB/5B,KAK1E,OAJAwK,EAAMs0B,MAAQ,IAAIC,EAAMv0B,GACxBA,EAAMw0B,YAAc,IAAIj0B,EAAK2G,KAAK/d,EAAUoG,eACxC8kC,GACAr0B,EAAM/M,QAAQohC,GACXr0B,CACX,CAUA,OAnBA5W,EAAM8W,UAAU2zB,EAAM9zB,GAUtB8zB,EAAK78B,UAAUy9B,SAAW,SAAUC,EAASC,GACzC,OAAOn/B,KAAK8+B,MAAMG,SAASC,EAASC,EACxC,EACAd,EAAK78B,UAAU49B,YAAc,WACzB,OAAOp/B,IACX,EACAq+B,EAAK78B,UAAUo7B,WAAa,WACxB,OAAO58B,KAAKg/B,YAAYjtB,YAAY7Y,UACxC,EACOmlC,CACX,CArBY,CAqBV1D,GACFA,EAAY0D,KAAOA,EAEvB,IAAI3C,EAAU,SAAUnxB,GAEpB,SAASmxB,EAAMpd,EAAIhJ,EAAQ6pB,EAAQtE,GAC/B,IAAIrwB,EAAQD,EAAOvH,KAAKhD,KAAMsV,EAAOslB,SAAUC,IAAU76B,KAMzD,OALAwK,EAAM8T,GAAKA,EACX9T,EAAM8K,OAASA,EACf9K,EAAM20B,OAASA,EACf30B,EAAMqwB,MAAQA,EACdsE,EAAO30B,GACAA,CACX,CAkDA,OA3DA5W,EAAM8W,UAAUgxB,EAAOnxB,GAUvBmxB,EAAMl6B,UAAUy9B,SAAW,SAAUC,EAASC,GAC1C,OAAO,IAAIzD,EAAMwD,EAASl/B,KAAMm/B,EAAQn/B,KAAK66B,MACjD,EACAa,EAAMl6B,UAAU49B,YAAc,SAAUF,GACpC,IAAI10B,EAAQxK,KACRsV,EAAStV,KAAKsV,OAAO8pB,YAAYF,GACrC,OAAIA,IAAYl/B,KAAKse,IACbte,KAAK66B,MAAMkB,SACX1oC,OAAOkK,KAAKyC,KAAKtF,MAAM0E,QAAQ,SAAU65B,GACrC,IAAIoG,EAAiB70B,EAAM9P,KAAKu+B,GAC5BqG,EAAoBhqB,EAAe,OAAE2jB,GACpCqG,EAGKD,EAMDA,IAAmBC,GACxBjsC,OAAOkK,KAAK8hC,GAAgBjgC,QAAQ,SAAU+6B,GACrCnX,EAAMA,MAAMqc,EAAelF,GAAiBmF,EAAkBnF,KAC/D3vB,EAAMqwB,MAAMsB,MAAMlD,EAAQkB,EAElC,IAVA3vB,EAAMqwB,MAAMsB,MAAMlD,EAAQ,YAC1B5lC,OAAOkK,KAAK+hC,GAAmBlgC,QAAQ,SAAU+6B,GAC7C3vB,EAAMqwB,MAAMsB,MAAMlD,EAAQkB,EAC9B,IANA3vB,EAAMiB,OAAOwtB,EAerB,GAEG3jB,GAEPA,IAAWtV,KAAKsV,OACTtV,KACJsV,EAAO2pB,SAASj/B,KAAKse,GAAIte,KAAKm/B,OACzC,EACAzD,EAAMl6B,UAAU85B,SAAW,WACvB,OAAO1nC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKsV,OAAOgmB,YAAat7B,KAAKtF,KAC3E,EACAghC,EAAMl6B,UAAUu8B,gBAAkB,SAAU9E,GACxC,IAAIsG,EAAav/B,KAAKsV,OAAOyoB,gBAAgB9E,GAC7C,OAAOM,EAAOv2B,KAAKhD,KAAKtF,KAAMu+B,GAAUrlC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG0pC,GAAah1B,EAAO/I,UAAUu8B,gBAAgB/6B,KAAKhD,KAAMi5B,IAAWsG,CAClJ,EACA7D,EAAMl6B,UAAUo7B,WAAa,WAEzB,IADA,IAAIx5B,EAAIpD,KAAKsV,OACNlS,EAAEkS,QACLlS,EAAIA,EAAEkS,OACV,OAAOlS,EAAEw5B,WAAWxjC,MAAMgK,EAC1BlK,UACJ,EACOwiC,CACX,CA7Da,CA6DXnoC,EAAQonC,aACNoE,EAAU,SAAUx0B,GAEpB,SAASw0B,EAAM5zB,GACX,OAAOZ,EAAOvH,KAAKhD,KAAM,oBAAqBmL,EAAM,WAAc,EAAG,IAAImzB,EAAWnzB,EAAK0vB,MAAMkB,QAAS5wB,EAAK0vB,SAAW76B,IAC5H,CAOA,OAVApM,EAAM8W,UAAUq0B,EAAOx0B,GAIvBw0B,EAAMv9B,UAAU49B,YAAc,WAC1B,OAAOp/B,IACX,EACA++B,EAAMv9B,UAAU4U,MAAQ,SAAUwlB,EAAOC,GACrC,OAAO77B,KAAKsV,OAAOc,MAAMwlB,EAAOC,EACpC,EACOkD,CACX,CAZa,CAYXrD,GACF,SAASI,EAAsB0D,EAAgBC,EAAgBlpB,GAC3D,IAAImpB,EAAgBF,EAAejpB,GAC/BopB,EAAgBF,EAAelpB,GACnC,OAAOyM,EAAMA,MAAM0c,EAAeC,GAAiBD,EAAgBC,CACvE,CACA,SAASf,EAAsBnC,GAC3B,SAAUA,aAAiBlpC,EAAQonC,aAAe8B,EAAM5B,MAAMkB,QAClE,CAUA,IAAI6D,EAAgB,WAChB,SAASA,IACL5/B,KAAK2a,MAAQ,IAAKhnB,EAAUwG,cAAgBC,QAAUC,KACtD2F,KAAK6/B,KAAO,IAAI90B,EAAK2G,KAAK/d,EAAUoG,eACpCiG,KAAK8/B,OAAS,IAAI9lC,QAClBgG,KAAK+/B,WAAa,IAAI9lC,IACtB+F,KAAKggC,MAAQhgC,KAAKigC,MAAM,CAAC,EAC7B,CA0EA,OAzEAL,EAAYp+B,UAAU0+B,QAAU,SAAU1sC,GACtC,OAAOG,EAAUiZ,gBAAgBpZ,IAAUwM,KAAK2a,MAAMtf,IAAI7H,EAC9D,EACAosC,EAAYp+B,UAAU2+B,KAAO,SAAU3sC,GACnC,GAAIG,EAAUiZ,gBAAgBpZ,GAAQ,CAClC,IAAI4sC,EArBhB,SAAqB5sC,GACjB,OAAIG,EAAUiZ,gBAAgBpZ,GACnBG,EAAU4F,QAAQ/F,GACrBA,EAAM2L,MAAM,GACVvL,EAAMiC,SAAS,CAAEihB,UAAWzjB,OAAOyZ,eAAetZ,IAAUA,GAE/DA,CACX,CAcuB6sC,CAAY7sC,GAEvB,OADAwM,KAAK8/B,OAAOlnC,IAAIwnC,EAAM5sC,GACf4sC,CACX,CACA,OAAO5sC,CACX,EACAosC,EAAYp+B,UAAUy+B,MAAQ,SAAUzsC,GACpC,IAAIgX,EAAQxK,KACZ,GAAIrM,EAAUiZ,gBAAgBpZ,GAAQ,CAClC,IAAI8sC,EAAWtgC,KAAK8/B,OAAOjoC,IAAIrE,GAC/B,GAAI8sC,EACA,OAAOA,EAEX,OADYjtC,OAAOyZ,eAAetZ,IAE9B,KAAK8F,MAAMkI,UACP,GAAIxB,KAAK2a,MAAMtf,IAAI7H,GACf,OAAOA,EACX,IAAI+sC,EAAQ/sC,EAAMyP,IAAIjD,KAAKigC,MAAOjgC,MAQlC,OAPInC,EAAOmC,KAAK6/B,KAAK9tB,YAAYwuB,IACvBA,QACNvgC,KAAK2a,MAAM5e,IAAK8B,EAAK0iC,MAAQA,IACF,IAAvBvqC,WAAWC,SACX5C,OAAOc,OAAOosC,IAGf1iC,EAAK0iC,MAEhB,KAAK,KACL,KAAKltC,OAAOmO,UACR,GAAIxB,KAAK2a,MAAMtf,IAAI7H,GACf,OAAOA,EACX,IAAIgtC,EAAUntC,OAAOyZ,eAAetZ,GAChCqnB,EAAU,CAAC2lB,GACXjjC,EAAOyC,KAAKsO,WAAW9a,GAC3BqnB,EAAQriB,KAAK+E,EAAKkjC,MAClB,IAII5iC,EAJA6iC,EAAoB7lB,EAAQxiB,OAKhC,GAJAkF,EAAKojC,OAAOvhC,QAAQ,SAAU0G,GAC1B+U,EAAQriB,KAAKgS,EAAMy1B,MAAMzsC,EAAMsS,IACnC,KACIjI,EAAOmC,KAAK6/B,KAAK9tB,YAAY8I,IACvBud,OAAQ,CACd,IAAItd,EAASjd,EAAKu6B,OAAS/kC,OAAOY,OAAOusC,GACzCxgC,KAAK2a,MAAM5e,IAAI+e,GACfvd,EAAKojC,OAAOvhC,QAAQ,SAAU0G,EAAKhE,GAC/BgZ,EAAMhV,GAAO+U,EAAQ6lB,EAAoB5+B,EAC7C,IAC2B,IAAvB9L,WAAWC,SACX5C,OAAOc,OAAO2mB,EAEtB,CACA,OAAOjd,EAAKu6B,OAGxB,CACA,OAAO5kC,CACX,EACAosC,EAAYp+B,UAAU8M,WAAa,SAAUhN,GACzC,IAAI/D,EAAOlK,OAAOkK,KAAK+D,GACnBzD,EAAOmC,KAAK6/B,KAAK9tB,YAAYxU,GACjC,IAAKM,EAAKN,KAAM,CACZA,EAAKgR,OACL,IAAIkyB,EAAOl+B,KAAKgB,UAAUhG,IACpBM,EAAKN,KAAOyC,KAAK+/B,WAAWloC,IAAI4oC,KAClCzgC,KAAK+/B,WAAWnnC,IAAI6nC,EAAO5iC,EAAKN,KAAO,CAAEojC,OAAQpjC,EAAMkjC,KAAMA,GAErE,CACA,OAAO5iC,EAAKN,IAChB,EACOqiC,CACX,CAlFmB,GAoFnB,SAASgB,GAAwB38B,GAC7B,MAAO,CACHA,EAAQtJ,aACRsJ,EAAQg3B,kBACRh3B,EAAQtP,QACRsP,EAAQtP,QAAQ0/B,gBAExB,CACA,IAAIwM,GAAgB,WAChB,SAASA,EAAYr8B,GACjB,IAAIgG,EAAQxK,KACZA,KAAK8gC,aAAe,IAAKntC,EAAUoG,cAAgBC,QAAUC,KAC7D+F,KAAKwE,OAAS7Q,EAAUumB,QAAQ1V,EAAQ,CACpCs1B,aAAoC,IAAvBt1B,EAAOs1B,YACpBzF,gBAAiB2F,EAAsBx1B,KAE3CxE,KAAK+gC,MAAQv8B,EAAOu8B,OAAS,IAAInB,EACjC5/B,KAAK41B,oBAAsBz/B,EAASyb,KAAK,SAAU3N,GAC/C,IAAIxO,EACA4+B,EAAkBpwB,EAAQtP,QAAQ0/B,gBAClC2M,EAAWJ,GAAwB38B,GACvC+8B,EAAS,IAAM3M,EACf,IAAI4M,GAASxrC,EAAK+U,EAAMorB,qBAAqBsL,KAAK9nC,MAAM3D,EAAIurC,GAC5D,OAAIC,EACI5M,EACOzgC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGorC,GAAQ,CAC7Cl+B,OAAQyH,EAAMu2B,MAAMd,MAAMgB,EAAMl+B,UAEjCk+B,GAEXvC,EAA+Bz6B,EAAQtP,QAAQ8nC,MAAOx4B,EAAQk9B,aAAahjB,OACpE3T,EAAM42B,qBAAqBn9B,GACtC,EAAG,CACCkJ,IAAKnN,KAAKwE,OAAO68B,oBACb1tC,EAAU+D,WAAW,sCACrB,IACJukB,QAAS2kB,GACT/uB,aAAc,SAAUlX,EAAc2a,EAAQ3gB,EAAS0/B,GACnD,GAAIuK,EAAsBjqC,EAAQ8nC,OAC9B,OAAO9nC,EAAQ8nC,MAAM5qB,aAAalX,EAAchH,EAAUsqB,YAAY3I,GAAUA,EAAO6I,MAAQ7I,EAAQ3gB,EAAQ2sC,UAAWjN,EAElI,IAEJr0B,KAAK81B,wBAA0B3/B,EAASyb,KAAK,SAAU3N,GAEnD,OADAy6B,EAA+Bz6B,EAAQtP,QAAQ8nC,MAAOx4B,EAAQk9B,aAAahjB,OACpE3T,EAAM+2B,yBAAyBt9B,EAC1C,EAAG,CACCkJ,IAAKnN,KAAKwE,OAAO68B,oBACb1tC,EAAU+D,WAAW,0CACrB,IACJma,aAAc,SAAUpc,GACpB,IAAI6a,EAAQ7a,EAAG6a,MAAOiwB,EAAQ9qC,EAAG8qC,MAAO5rC,EAAUc,EAAGd,QACrD,GAAIiqC,EAAsBjqC,EAAQ8nC,OAC9B,OAAO9nC,EAAQ8nC,MAAM5qB,aAAavB,EAAOiwB,EAAO5rC,EAAQ2sC,UAEhE,GAER,CAyLA,OAxLAT,EAAYr/B,UAAUggC,WAAa,WAC/BxhC,KAAK+gC,MAAQ,IAAInB,CACrB,EACAiB,EAAYr/B,UAAUigC,sBAAwB,SAAUhsC,GACpD,IAAIgnC,EAAQhnC,EAAGgnC,MAAOz3B,EAAQvP,EAAGuP,MAAOxJ,EAAK/F,EAAG+iC,OAAQA,OAAgB,IAAPh9B,EAAgB,aAAeA,EAAI7D,EAAYlC,EAAGkC,UAAWgE,EAAKlG,EAAG41B,kBAAmBA,OAA2B,IAAP1vB,GAAuBA,EAAIK,EAAKvG,EAAG4+B,gBAAiBA,OAAyB,IAAPr4B,EAAgBgE,KAAKwE,OAAO6vB,gBAAkBr4B,EAC7R4+B,EAAW56B,KAAKwE,OAAOlO,MAAMskC,SACjCjjC,EAAY/D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlC,EAAU2oB,iBAAiB3oB,EAAUspB,mBAAmBjY,KAAUrN,GAChH,IAOI8zB,EAPAiW,EAAU/tC,EAAU0qB,cAAcma,GAClCmJ,EAAa3hC,KAAK41B,oBAAoB,CACtCj7B,aAAchH,EAAUwU,kBAAkBnD,GAAOrK,aACjDsgC,kBAAmByG,EACnBP,aAAcO,EACd/sC,QAASf,EAAMiC,SAAS,CAAE4mC,MAAOA,EAAOz3B,MAAOA,EAAO41B,SAAUA,EAAUjjC,UAAWA,EAAW2pC,UAAW3tC,EAAUma,mBAAmBnW,GAAY08B,gBAAiBA,GAAmBkG,EAAuBv1B,EAAOhF,KAAKwE,OAAOzM,cAGtO,GAAI4pC,EAAWlW,UACXA,EAAU,CACN,IAAI6N,EAAkBsI,GAAaD,EAAWlW,SAAUkW,EAAWlW,QAASzmB,EAAOrN,KAElF0zB,GACD,MAAMI,EAAQ,GAGtB,MAAO,CACH1oB,OAAQ4+B,EAAW5+B,OACnBoH,UAAWshB,EACXA,QAASA,EAEjB,EACAoV,EAAYr/B,UAAUqgC,QAAU,SAAU9+B,EAAQuS,EAAQ3a,EAAchG,GACpE,GAAIiqC,EAAsBjqC,EAAQ8nC,QAC9Bz8B,KAAK8gC,aAAajpC,IAAIkL,KAAYpI,EAAc,CAChD,IAAIie,EAAS5Y,KAAK41B,oBAAoBsL,KAAKvmC,EAAc2a,EAAQ3gB,EACjEqL,KAAK+gC,MAAMb,QAAQn9B,IACnB,GAAI6V,GAAU7V,IAAW6V,EAAO7V,OAC5B,OAAO,CAEf,CACA,OAAO,CACX,EACA89B,EAAYr/B,UAAU4/B,qBAAuB,SAAU3rC,GACnD,IAAI+U,EAAQxK,KACRrF,EAAelF,EAAGkF,aAAcsgC,EAAoBxlC,EAAGwlC,kBAAmBkG,EAAe1rC,EAAG0rC,aAAcxsC,EAAUc,EAAGd,QAC3H,GAAIhB,EAAUsqB,YAAYgd,KACrBtmC,EAAQimC,SAASa,kBAAkBR,EAAkB9c,SACrDxpB,EAAQ8nC,MAAMphC,IAAI4/B,EAAkB9c,OACrC,MAAO,CACHpb,OAAQ/C,KAAK+gC,MAAMf,MACnBvU,QAAS,iCAAiC3vB,OAAOm/B,EAAkB9c,MAAO,YAGlF,IAGIsN,EAHA9zB,EAAYhD,EAAQgD,UAAWijC,EAAWjmC,EAAQimC,SAClDvd,EADoE1oB,EAAQ8nC,MAC3DzB,cAAcC,EAAmB,cAClD6G,EAAiB,GAEjBC,EAAgB,IAAIpuC,EAAUwiB,WAMlC,SAAS6rB,EAAcj/B,EAAQk/B,GAC3B,IAAIxsC,EAMJ,OALIsN,EAAO0oB,UACPA,EAAUsW,EAAc3rB,MAAMqV,IAAUh2B,EAAK,CAAC,GACvCwsC,GAAcl/B,EAAO0oB,QACxBh2B,KAEDsN,EAAOA,MAClB,CAbI/C,KAAKwE,OAAOs1B,aACQ,kBAAbzc,IACNud,EAASsH,kBAAkB7kB,IAC5BykB,EAAetpC,KAAK,CAAEuE,WAAYsgB,IAWtC,IAAI3F,EAAU,IAAIrd,IAAIM,EAAauB,YACnCwb,EAAQtY,QAAQ,SAAUjD,GACtB,IAAI1G,EAAI+F,EACR,GAAK7H,EAAUytB,cAAcjlB,EAAWxE,GAExC,GAAIhE,EAAU6c,QAAQrU,GAAY,CAC9B,IAAIugC,EAAa9B,EAASvb,UAAU,CAChC7hB,UAAWrB,EAAUtF,KAAKrD,MAC1B8c,MAAOnU,EACPxE,UAAWhD,EAAQgD,UACnB8D,KAAMw/B,GACPtmC,GACCstC,EAAatuC,EAAU4I,uBAAuBJ,QAC/B,IAAfugC,EACK/oC,EAAUyhB,sBAAsBI,MAAMrZ,KACvCsvB,EAAUsW,EAAc3rB,MAAMqV,IAAUh2B,EAAK,CAAC,GACvCwsC,GAAc,qBAAqBnmC,OAAOK,EAAUtF,KAAKrD,MAAO,SAASsI,OAAOnI,EAAUsqB,YAAYgd,GACrGA,EAAkB9c,MAAQ,UACxB,UAAY5b,KAAKgB,UAAU03B,EAAmB,KAAM,IAC1DxlC,KAGH9B,EAAU4F,QAAQmjC,GACnBA,EAAWrkC,OAAS,IACpBqkC,EAAasF,EAAcx3B,EAAMsrB,wBAAwB,CACrDxlB,MAAOnU,EACPokC,MAAO7D,EACPyE,aAAcA,EACdxsC,QAASA,IACTstC,IAGF9lC,EAAUxB,aAKG,MAAd+hC,IACLA,EAAasF,EAAcx3B,EAAMorB,oBAAoB,CACjDj7B,aAAcwB,EAAUxB,aACxBsgC,kBAAmByB,EACnByE,aAAcxtC,EAAUsqB,YAAYye,GAAcA,EAAayE,EAC/DxsC,QAASA,IACTstC,IAVAttC,EAAQ0/B,kBACRqI,EAAalyB,EAAMu2B,MAAMZ,KAAKzD,SAWnB,IAAfA,GACAoF,EAAetpC,OAAMgD,EAAK,CAAC,GAAMymC,GAAcvF,EAAYlhC,GAEnE,KACK,CACD,IAAI0B,EAAWvJ,EAAUqZ,yBAAyB7Q,EAAWxH,EAAQyI,gBACrE,IAAKF,GAAYf,EAAUrE,OAAS6B,EAAQyC,KAAKY,gBAC7C,MAAMvJ,EAAQ+P,kBAAkB,GAAIrH,EAAUtF,KAAKrD,OAEnD0J,GAAY09B,EAAS99B,gBAAgBI,EAAUmgB,IAC/CngB,EAASvC,aAAauB,WAAWkD,QAAQsY,EAAQ3b,IAAK2b,EAE9D,CACJ,GACA,IACIyqB,EAAc,CAAEp/B,OADPpP,EAAUoiB,eAAe+rB,GACFrW,QAASA,GACzC2W,EAASztC,EAAQ0/B,gBACjBr0B,KAAK+gC,MAAMd,MAAMkC,GACfxuC,EAAUoH,gBAAgBonC,GAIhC,OAHIC,EAAOr/B,QACP/C,KAAK8gC,aAAaloC,IAAIwpC,EAAOr/B,OAAQpI,GAElCynC,CACX,EACAvB,EAAYr/B,UAAU+/B,yBAA2B,SAAU9rC,GACvD,IAEIg2B,EAFAjhB,EAAQxK,KACRsQ,EAAQ7a,EAAG6a,MAAOiwB,EAAQ9qC,EAAG8qC,MAAOY,EAAe1rC,EAAG0rC,aAAcxsC,EAAUc,EAAGd,QAEjFotC,EAAgB,IAAIpuC,EAAUwiB,WAClC,SAAS6rB,EAAcK,EAAavgC,GAChC,IAAIrM,EAIJ,OAHI4sC,EAAY5W,UACZA,EAAUsW,EAAc3rB,MAAMqV,IAAUh2B,EAAK,CAAC,GAAMqM,GAAKugC,EAAY5W,QAASh2B,KAE3E4sC,EAAYt/B,MACvB,CA6BA,OA5BIuN,EAAM3V,eACN4lC,EAAQA,EAAM3iC,OAAOjJ,EAAQ8nC,MAAMrd,UAEvCmhB,EAAQA,EAAMt9B,IAAI,SAAUpH,EAAMiG,GAC9B,OAAa,OAATjG,EACO,KAEPlI,EAAU4F,QAAQsC,GACXmmC,EAAcx3B,EAAMsrB,wBAAwB,CAC/CxlB,MAAOA,EACPiwB,MAAO1kC,EACPslC,aAAcA,EACdxsC,QAASA,IACTmN,GAEJwO,EAAM3V,aACCqnC,EAAcx3B,EAAMorB,oBAAoB,CAC3Cj7B,aAAc2V,EAAM3V,aACpBsgC,kBAAmBp/B,EACnBslC,aAAcxtC,EAAUsqB,YAAYpiB,GAAQA,EAAOslC,EACnDxsC,QAASA,IACTmN,KAEmB,IAAvB9L,WAAWC,SAwB3B,SAAsCwmC,EAAOnsB,EAAOosB,GAChD,IAAKpsB,EAAM3V,aAAc,CACrB,IAAIwjC,EAAY,IAAI9jC,IAAI,CAACqiC,IACzByB,EAAU/+B,QAAQ,SAAU5L,GACpBG,EAAUiZ,gBAAgBpZ,KAC1BC,EAAQiB,WACHf,EAAUsqB,YAAYzqB,GACvB,GAr4BpB,SAAoCipC,EAAOxB,GACvC,OAAOtnC,EAAUsqB,YAAYgd,GACzBwB,EAAM5kC,IAAIojC,EAAkB9c,MAAO,cACjC8c,GAAqBA,EAAkBl+B,UACjD,CAk4BoBulC,CAA2B7F,EAAOjpC,GAClC8c,EAAMzZ,KAAKrD,OAEfH,OAAOkc,OAAO/b,GAAO4L,QAAQ++B,EAAUpiC,IAAKoiC,GAEpD,EACJ,CACJ,CAtCgBoE,CAA6B5tC,EAAQ8nC,MAAOnsB,EAAOzU,GAEhDA,EACX,GACO,CACHkH,OAAQpO,EAAQ0/B,gBAAkBr0B,KAAK+gC,MAAMd,MAAMM,GAASA,EAC5D9U,QAASA,EAEjB,EACOoV,CACX,CA3OmB,GA4OnB,SAASe,GAAaY,GAClB,IACIjgC,KAAKgB,UAAUi/B,EAAM,SAAUrpB,EAAG3lB,GAC9B,GAAqB,kBAAVA,EACP,MAAMA,EACV,OAAOA,CACX,EACJ,CACA,MAAOuP,GACH,OAAOA,CACX,CACJ,CAkBA,IAAI0/B,GAAY,IAAItsC,EAASQ,KACzB+rC,GAAe,IAAI1oC,QACvB,SAAS2oC,GAAarsC,GAClB,IAAIssC,EAAOF,GAAa7qC,IAAIvB,GAO5B,OANKssC,GACDF,GAAa9pC,IAAItC,EAAQssC,EAAO,CAC5BC,KAAM,IAAIxoC,IACVmkC,IAAKroC,EAASqoC,QAGfoE,CACX,CACA,SAASE,GAAYxsC,GACjBqsC,GAAarsC,GAAOusC,KAAKzjC,QAAQ,SAAUiyB,GAAM,OAAOA,EAAGyR,YAAYxsC,EAAQ,EACnF,CAIA,SAASysC,GAAQvvC,GACb,IAAIwX,EAAS,IAAI3Q,IACb+4B,EAAY,IAAI/4B,IAChBg3B,EAAK,SAAU3zB,GACf,GAAIxE,UAAUb,OAAS,GACnB,GAAI7E,IAAUkK,EAAU,CACpBlK,EAAQkK,EACRsN,EAAO5L,QAAQ,SAAU9I,GACrBqsC,GAAarsC,GAAOkoC,IAAIrC,MAAM9K,GA+BlD,SAAmB/6B,GACXA,EAAM0sC,kBACN1sC,EAAM0sC,kBAEd,CAlCoBC,CAAU3sC,EACd,GACA,IAAI4sC,EAAe5pC,MAAMmC,KAAK23B,GAC9BA,EAAUiK,QACV6F,EAAa9jC,QAAQ,SAAUoa,GAAY,OAAOA,EAAShmB,EAAQ,EACvE,MAEC,CACD,IAAI8C,EAAQmsC,GAAU1rC,WAClBT,IACA6sC,EAAO7sC,GACPqsC,GAAarsC,GAAOkoC,IAAInN,GAEhC,CACA,OAAO79B,CACX,EACA69B,EAAGE,aAAe,SAAU/X,GAExB,OADA4Z,EAAUr3B,IAAIyd,GACP,WACH4Z,EAAU3nB,OAAO+N,EACrB,CACJ,EACA,IAAI2pB,EAAU9R,EAAG+R,YAAc,SAAU9sC,GAGrC,OAFA0U,EAAOjP,IAAIzF,GACXqsC,GAAarsC,GAAOusC,KAAK9mC,IAAIs1B,GACtBA,CACX,EAEA,OADAA,EAAGyR,YAAc,SAAUxsC,GAAS,OAAO0U,EAAOS,OAAOnV,EAAQ,EAC1D+6B,CACX,CAOA,IAAIgS,GAAqBhwC,OAAOY,OAAO,MACvC,SAASqvC,GAAoBC,GACzB,IAAIvX,EAAWzpB,KAAKgB,UAAUggC,GAC9B,OAAQF,GAAmBrX,KACtBqX,GAAmBrX,GAAY34B,OAAOY,OAAO,MACtD,CACA,SAASuvC,GAAyBC,GAC9B,IAAIb,EAAOU,GAAoBG,GAC/B,OAAQb,EAAKc,cAAgBd,EAAKc,YAAc,SAAUtL,EAAQzjC,GAC1D,IAAI2oC,EAAU,SAAU7hC,EAAMqK,GAC1B,OAAOnR,EAAQ0qB,UAAUvZ,EAAKrK,EAClC,EACIk+B,EAAahlC,EAAQglC,UAAYgK,GAAsBF,EAAW,SAAUG,GAC5E,IAAIC,EAAYC,GAAenvC,EAAQ6mC,YAAaoI,EACpDtG,GAOA,YANkB,IAAduG,GACAzL,IAAWzjC,EAAQ6mC,aACnBjC,EAAOv2B,KAAKo1B,EAAQwL,EAAc,MAClCC,EAAYC,GAAe1L,EAAQwL,EAAeG,KAEtDtwC,EAAQiB,eAAwB,IAAdmvC,EAAsB,EAAGD,EAAcr9B,KAAK,KAAM6xB,GAC7DyL,CACX,GACA,MAAO,GAAG/nC,OAAOnH,EAAQ0oB,SAAU,KAAKvhB,OAAOyG,KAAKgB,UAAUo2B,GAClE,EACR,CACA,SAASqK,GAAuBP,GAC5B,IAAIb,EAAOU,GAAoBG,GAC/B,OAAQb,EAAKqB,YACRrB,EAAKqB,UAAY,SAAUhrC,EAAMxD,GAC9B,IAAI6a,EAAQ7a,EAAG6a,MAAO3Y,EAAYlC,EAAGkC,UAAW6F,EAAY/H,EAAG+H,UAC3D0mC,EAAYP,GAAsBF,EAAW,SAAUU,GACvD,IAAIC,EAAWD,EAAQ,GACnBE,EAAYD,EAASE,OAAO,GAChC,GAAkB,MAAdD,EAWJ,GAAkB,MAAdA,GASJ,GAAIprC,EACA,OAAO6qC,GAAe7qC,EAAMkrC,OAVhC,CACI,IAAII,EAAeH,EAASjlC,MAAM,GAClC,GAAIxH,GAAa4hC,EAAOv2B,KAAKrL,EAAW4sC,GAAe,CACnD,IAAIC,EAAaL,EAAQhlC,MAAM,GAE/B,OADAqlC,EAAW,GAAKD,EACTT,GAAensC,EAAW6sC,EACrC,CAEJ,MAlBI,GAAIl0B,GAAS3c,EAAUue,gBAAgB5B,EAAM1E,YAAa,CACtD,IAAI64B,EAAkBL,EAASjlC,MAAM,GACjC8I,EAAIqI,EAAM1E,WAAW7N,KAAK,SAAUkK,GAAK,OAAOA,EAAEpR,KAAKrD,QAAUixC,CAAiB,GAClFC,EAAgBz8B,GAAKtU,EAAUunB,yBAAyBjT,EAAGtQ,GAC/D,OAAQ+sC,GACJZ,GAAeY,EACfP,EAAQhlC,MAAM,GACtB,CAeR,GACImhB,EAAS/d,KAAKgB,UAAU2gC,GAI5B,OAHIjrC,GAAmB,OAAXqnB,KACR9iB,GAAa,IAAM8iB,GAEhB9iB,CACX,EACR,CACA,SAASmmC,GAAsBF,EAAWkB,GACtC,IAAIzuB,EAAS,IAAIviB,EAAUwiB,WAC3B,OAAOyuB,GAAkBnB,GAAW3Z,OAAO,SAAUoa,EAAWjpC,GAC5D,IAAIxF,EACAm0B,EAAU+a,EAAU1pC,GACxB,QAAgB,IAAZ2uB,EAAoB,CACpB,IAAK,IAAI9nB,EAAI7G,EAAK5C,OAAS,EAAGyJ,GAAK,IAAKA,GACzBrM,EAAK,CAAC,GAAMwF,EAAK6G,IAAM8nB,EAAlCA,EAA2Cn0B,EAE/CyuC,EAAYhuB,EAAOE,MAAM8tB,EAAWta,EACxC,CACA,OAAOsa,CACX,EAAG7wC,OAAOY,OAAO,MACrB,CACA,SAAS2wC,GAAkBrB,GACvB,IAAIX,EAAOU,GAAoBC,GAC/B,IAAKX,EAAKiC,MAAO,CACb,IAAIC,EAAWlC,EAAKiC,MAAQ,GACxBE,EAAgB,GACpBxB,EAAKnkC,QAAQ,SAAUgR,EAAGtO,GAClBnO,EAAU4F,QAAQ6W,IAClBw0B,GAAkBx0B,GAAGhR,QAAQ,SAAUgE,GAAK,OAAO0hC,EAAQtsC,KAAKusC,EAAcjpC,OAAOsH,GAAK,GAC1F2hC,EAAc1sC,OAAS,IAGvB0sC,EAAcvsC,KAAK4X,GACdzc,EAAU4F,QAAQgqC,EAAKzhC,EAAI,MAC5BgjC,EAAQtsC,KAAKusC,EAAc5lC,MAAM,IACjC4lC,EAAc1sC,OAAS,GAGnC,EACJ,CACA,OAAOuqC,EAAKiC,KAChB,CACA,SAASd,GAAW3L,EAAQtyB,GACxB,OAAOsyB,EAAOtyB,EAClB,CACA,SAASg+B,GAAe1L,EAAQn9B,EAAMqiC,GAElC,OADAA,EAAUA,GAAWyG,GACdiB,GAAU/pC,EAAK6uB,OAAO,SAASmb,EAAQ3jC,EAAKwE,GAC/C,OAAOnS,EAAU4F,QAAQ+H,GACrBA,EAAI2B,IAAI,SAAUsU,GAAS,OAAO0tB,EAAQ1tB,EAAOzR,EAAM,GACrDxE,GAAOg8B,EAAQh8B,EAAKwE,EAC9B,EAAGsyB,GACP,CACA,SAAS4M,GAAUxxC,GACf,OAAIG,EAAUiZ,gBAAgBpZ,GACtBG,EAAU4F,QAAQ/F,GACXA,EAAMyP,IAAI+hC,IAEdrB,GAAsBtwC,OAAOkK,KAAK/J,GAAO+a,OAAQ,SAAUtT,GAC9D,OAAO6oC,GAAetwC,EAAOyH,EACjC,GAEGzH,CACX,CAEA,SAAS0xC,GAAuB3B,GAC5B,YAAsB,IAAdA,EAAKtqC,KAAkBsqC,EAAKtqC,KAC9BsqC,EAAKjzB,MAAQ3c,EAAUunB,yBAAyBqoB,EAAKjzB,MAAOizB,EAAK5rC,WAC7D,IACd,CACA,IAAIwtC,GAAkB,WAA6B,EAC/CC,GAAkB,SAAUC,EAAO1wC,GAAW,OAAOA,EAAQ6I,SAAW,EACxE8nC,GAAc,SAAUppB,EAAUC,EAAU1mB,GAE5C,OAAO8vC,EADY9vC,EAAG8vC,cACFrpB,EAAUC,EAClC,EACIqpB,GAAe,SAAUrsB,EAAGgD,GAAY,OAAOA,CAAU,EACzDspB,GAAa,WACb,SAASA,EAASjhC,GACdxE,KAAKwE,OAASA,EACdxE,KAAK0lC,aAAeryC,OAAOY,OAAO,MAClC+L,KAAK2lC,UAAYtyC,OAAOY,OAAO,MAC/B+L,KAAK4lC,aAAe,IAAI3rC,IACxB+F,KAAK6lC,cAAgB,IAAI5rC,IACzB+F,KAAKkiC,kBAAoB7uC,OAAOY,OAAO,MACvC+L,KAAKy7B,kBAAoBpoC,OAAOY,OAAO,MACvC+L,KAAK8lC,oBAAqB,EAC1B9lC,KAAKwE,OAAS5Q,EAAMiC,SAAS,CAAEgkC,iBAAkBJ,GAA2Bj1B,GAC5ExE,KAAK1J,MAAQ0J,KAAKwE,OAAOlO,MACzB0J,KAAK+lC,gBAAgB,SACrB/lC,KAAK+lC,gBAAgB,YACrB/lC,KAAK+lC,gBAAgB,gBACjBvhC,EAAOwhC,eACPhmC,KAAKimC,iBAAiBzhC,EAAOwhC,eAE7BxhC,EAAOkhC,cACP1lC,KAAKkmC,gBAAgB1hC,EAAOkhC,aAEpC,CAkUA,OAjUAD,EAASjkC,UAAUwpB,SAAW,SAAUoN,EAAQ+N,GAC5C,IAAI1wC,EACAmlC,EAAW56B,KACXqd,EAAY8oB,IACXA,EAAe9oB,WAAmD,QAArC5nB,EAAK0wC,EAAe3K,mBAAgC,IAAP/lC,OAAgB,EAASA,EAAGsH,cACvGq7B,EAAOr7B,WACX,GAAIsgB,IAAard,KAAKy7B,kBAAkB2K,WACpC,MAAO,CAAC,cAEZ,IASI9nB,EATAkd,EAAe2K,GAAkBA,EAAe3K,aAAgBpD,EAChEzjC,EAAUf,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGswC,GAAiB,CAAE9oB,SAAUA,EAAUme,YAAaA,EAAanc,UAAY8mB,GAAkBA,EAAe9mB,WACtJ,WACI,IAAIpb,EAAUoiC,GAA0BntC,UAAWsiC,GACnD,OAAOZ,EAASvb,UAAUpb,EAAS,CAC/Bw4B,MAAO7B,EAAStkC,MAAY,KAC5BqB,UAAWsM,EAAQtM,WAE3B,IAEJ2uC,EAASjpB,GAAYrd,KAAKumC,cAAclpB,GACxCmpB,EAASF,GAAUA,EAAOE,OAAUxmC,KAAKwE,OAAOq1B,iBAcpD,OAbAvE,EAAQh7B,oBAAoBnB,WAAU,EAAM,WACxC,KAAOqtC,GAAO,CACV,IAAIC,EAAgBD,EAAM5yC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGuiC,GAASoD,GAAc7mC,GACnF,IAAIhB,EAAU4F,QAAQktC,GAGjB,CACDnoB,EAAKmoB,EACL,KACJ,CALID,EAAQhD,GAAyBiD,EAMzC,CACJ,GACAnoB,EAAKA,EAAKC,OAAOD,QAAM,EAChB3pB,EAAQglC,UAAY,CAACrb,EAAI3pB,EAAQglC,WAAa,CAACrb,EAC1D,EACAmnB,EAASjkC,UAAU0kC,gBAAkB,SAAUR,GAC3C,IAAIl7B,EAAQxK,KACZ3M,OAAOkK,KAAKmoC,GAActmC,QAAQ,SAAUie,GACxC,IAAI5nB,EAAKiwC,EAAaroB,GAAWqpB,EAAYjxC,EAAGixC,UAAWC,EAAelxC,EAAGkxC,aAAcC,EAAmBnxC,EAAGmxC,iBAAkBzqB,EAAWvoB,EAAMoT,OAAOvR,EAAI,CAAC,YAAa,eAAgB,qBACzLixC,GACAl8B,EAAMu7B,gBAAgB,QAAS1oB,GAC/BspB,GACAn8B,EAAMu7B,gBAAgB,WAAY1oB,GAClCupB,GACAp8B,EAAMu7B,gBAAgB,eAAgB1oB,GACtCkc,EAAOv2B,KAAKwH,EAAMm7B,UAAWtoB,GAC7B7S,EAAMm7B,UAAUtoB,GAAU7kB,KAAK2jB,GAG/B3R,EAAMm7B,UAAUtoB,GAAY,CAAClB,EAErC,EACJ,EACAspB,EAASjkC,UAAUqlC,iBAAmB,SAAUxpB,EAAUlB,EAAU2qB,GAChE,IAAI5qB,EAAWlc,KAAKumC,cAAclpB,GAC9B0pB,EAAY5qB,EAAS4qB,UAAW53B,EAASgN,EAAShN,OACtD,SAAS63B,EAAS9qB,EAAU9F,GACxB8F,EAAS9F,MACY,oBAAVA,EAAuBA,GACd,IAAVA,EAAiBkvB,IACH,IAAVlvB,EAAkBovB,GACdtpB,EAAS9F,KAC/B,CACA4wB,EAAS9qB,EAAUC,EAAS/F,OAC5B8F,EAASsqB,OACS,IAAdO,EAAsB5B,GAChBxxC,EAAU4F,QAAQwtC,GAAavD,GAAyBuD,GAC/B,oBAAdA,EAA2BA,EAC9B7qB,EAASsqB,MACvBr3B,GACA9b,OAAOkK,KAAK4R,GAAQ/P,QAAQ,SAAU5B,GAClC,IAAI0e,EAAW4qB,EAAsBtpC,GAChC0e,IAA0B,OAAbA,QAAkC,IAAbA,OAAsB,EAASA,EAASmB,YAAcA,IACzFnB,EAAW4qB,EAAsBtpC,GAAa,CAAE6f,SAAUA,IAE9D,IAAIlB,EAAWhN,EAAO3R,GACtB,GAAwB,oBAAb2e,EACPD,EAAS/b,KAAOgc,MAEf,CACD,IAAIF,EAAUE,EAASF,QAAS9b,EAAOgc,EAAShc,KAAMiW,EAAQ+F,EAAS/F,MACvE8F,EAASsqB,OACO,IAAZvqB,EAAoBmpB,GACdzxC,EAAU4F,QAAQ0iB,GAAW+nB,GAAuB/nB,GAC7B,oBAAZA,EAAyBA,EAC5BC,EAASsqB,MACP,oBAATrmC,IACP+b,EAAS/b,KAAOA,GAEpB6mC,EAAS9qB,EAAU9F,EACvB,CACI8F,EAAS/b,MAAQ+b,EAAS9F,QAC1B8F,EAASsqB,MAAQtqB,EAASsqB,OAASpB,GAE3C,EAER,EACAK,EAASjkC,UAAUukC,gBAAkB,SAAUkB,EAAO5pB,QACjC,IAAbA,IAAuBA,EAAW4pB,GACtC,IAAIzO,EAAS,QAAUyO,EAAMC,cACzBC,EAAMnnC,KAAKy7B,kBAAkBjD,GAC7Bnb,IAAa8pB,IACb1zC,EAAQiB,WAAWyyC,GAAOA,IAAQF,EAAO,EAAGA,GACxCE,UACOnnC,KAAKkiC,kBAAkBiF,GAClCnnC,KAAKkiC,kBAAkB7kB,GAAYmb,EACnCx4B,KAAKy7B,kBAAkBjD,GAAUnb,EAEzC,EACAooB,EAASjkC,UAAUykC,iBAAmB,SAAUD,GAC5C,IAAIx7B,EAAQxK,KACZA,KAAK8lC,oBAAqB,EAC1BzyC,OAAOkK,KAAKyoC,GAAe5mC,QAAQ,SAAUgoC,GACzC58B,EAAM68B,gBAAgBD,GAAW,GACjCpB,EAAcoB,GAAWhoC,QAAQ,SAAUkoC,GACvC98B,EAAM68B,gBAAgBC,GAAS,GAAMvrC,IAAIqrC,GACzC,IAAIhN,EAAQkN,EAAQlN,MAAMH,GACrBG,GAASA,EAAM,KAAOkN,GACvB98B,EAAMq7B,cAAcjtC,IAAI0uC,EAAS,IAAIC,OAAOD,GAEpD,EACJ,EACJ,EACA7B,EAASjkC,UAAU+kC,cAAgB,SAAUlpB,GACzC,IAAI7S,EAAQxK,KACZ,IAAKu5B,EAAOv2B,KAAKhD,KAAK0lC,aAAcroB,GAAW,CAC3C,IAAImqB,EAAYxnC,KAAK0lC,aAAaroB,GAAYhqB,OAAOY,OAAO,MAC5DuzC,EAASr4B,OAAS9b,OAAOY,OAAO,MAChC,IAAIwzC,EAAeznC,KAAK4lC,aAAa/tC,IAAIwlB,IACpCoqB,GAAgBznC,KAAK6lC,cAAc9sC,OACpC0uC,EAAeznC,KAAKqnC,gBAAgBhqB,GAAU,GAC9Crd,KAAK6lC,cAAczmC,QAAQ,SAAUsoC,EAAQC,GACzC,GAAID,EAAO5+B,KAAKuU,GAAW,CACvB,IAAIuqB,EAAkBp9B,EAAMo7B,aAAa/tC,IAAI8vC,GACzCC,GACAA,EAAgBxoC,QAAQ,SAAUgoC,GAC9B,OAAOK,EAAa1rC,IAAIqrC,EAC5B,EAER,CACJ,IAEAK,GAAgBA,EAAa1uC,MAC7B0uC,EAAaroC,QAAQ,SAAUgoC,GAC3B,IAAI3xC,EAAK+U,EAAM+7B,cAAca,GAAYj4B,EAAS1Z,EAAG0Z,OAAQ4b,EAAOn3B,EAAMoT,OAAOvR,EAAI,CAAC,WACtFpC,OAAO0a,OAAOy5B,EAAUzc,GACxB13B,OAAO0a,OAAOy5B,EAASr4B,OAAQA,EACnC,EAER,CACA,IAAI04B,EAAQ7nC,KAAK2lC,UAAUtoB,GAM3B,OALIwqB,GAASA,EAAMxvC,QACfwvC,EAAMC,OAAO,GAAG1oC,QAAQ,SAAUknC,GAC9B97B,EAAMq8B,iBAAiBxpB,EAAUipB,EAAQ97B,EAAMk7B,aAAaroB,GAAUlO,OAC1E,GAEGnP,KAAK0lC,aAAaroB,EAC7B,EACAooB,EAASjkC,UAAUumC,eAAiB,SAAU1qB,EAAU7f,GACpD,GAAI6f,EACA,OAAOrd,KAAKumC,cAAclpB,GAAUlO,OAAO3R,EAEnD,EACAioC,EAASjkC,UAAU6lC,gBAAkB,SAAUC,EAASU,GACpD,IAAIC,EAAejoC,KAAK4lC,aAAa/tC,IAAIyvC,GAIzC,OAHKW,GAAgBD,GACjBhoC,KAAK4lC,aAAahtC,IAAI0uC,EAAUW,EAAe,IAAI5tC,KAEhD4tC,CACX,EACAxC,EAASjkC,UAAU1E,gBAAkB,SAAUI,EAAUmgB,EAAUta,EAAQpL,GACvE,IAAI6S,EAAQxK,KACZ,IAAK9C,EAASL,cACV,OAAO,EACX,IAAKwgB,EACD,OAAO,EACX,IAAI+pB,EAAYlqC,EAASL,cAAchG,KAAKrD,MAC5C,GAAI6pB,IAAa+pB,EACb,OAAO,EACX,GAAIpnC,KAAK8lC,oBAAsB9lC,KAAK4lC,aAAavqC,IAAI+rC,GAajD,IAZA,IAAIc,EAAuBloC,KAAKqnC,gBAAgBhqB,GAAU,GACtD8qB,EAAc,CAACD,GACfE,EAAiB,SAAUd,GAC3B,IAAIW,EAAez9B,EAAM68B,gBAAgBC,GAAS,GAC9CW,GACAA,EAAalvC,MACbovC,EAAYpmC,QAAQkmC,GAAgB,GACpCE,EAAY3vC,KAAKyvC,EAEzB,EACII,KAA8BtlC,IAAU/C,KAAK6lC,cAAc9sC,MAC3DuvC,GAAwB,EACnBxmC,EAAI,EAAGA,EAAIqmC,EAAY9vC,SAAUyJ,EAAG,CACzC,IAAImmC,EAAeE,EAAYrmC,GAC/B,GAAImmC,EAAa5sC,IAAI+rC,GAOjB,OANKc,EAAqB7sC,IAAI+rC,KACtBkB,IACuB,IAAvBtyC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,EAAGmnB,EAAU+pB,GAExEc,EAAqBnsC,IAAIqrC,KAEtB,EAEXa,EAAa7oC,QAAQgpC,GACjBC,GACAvmC,IAAMqmC,EAAY9vC,OAAS,GAC3BgiC,EAA0Bn9B,EAASvC,aAAcoI,EAAQpL,KACzD0wC,GAA2B,EAC3BC,GAAwB,EACxBtoC,KAAK6lC,cAAczmC,QAAQ,SAAUsoC,EAAQa,GACzC,IAAInO,EAAQ/c,EAAS+c,MAAMsN,GACvBtN,GAASA,EAAM,KAAO/c,GACtB+qB,EAAeG,EAEvB,GAER,CAEJ,OAAO,CACX,EACA9C,EAASjkC,UAAU06B,WAAa,SAAU7e,EAAU7f,GAChD,IAAI8oC,EAAStmC,KAAK+nC,eAAe1qB,EAAU7f,GAC3C,SAAU8oC,IAAUA,EAAOE,MAC/B,EACAf,EAASjkC,UAAUy7B,kBAAoB,SAAUuL,GAC7C,IAEIrO,EAFA9c,EAAWmrB,EAAUnrB,SAAU7f,EAAYgrC,EAAUhrC,UACrD8oC,EAAStmC,KAAK+nC,eAAe1qB,EAAU7f,GAEvCgpC,EAAQF,GAAUA,EAAOE,MAC7B,GAAIA,GAASnpB,EAQT,IAPA,IAAI1oB,EAAU,CACV0oB,SAAUA,EACV7f,UAAWA,EACX8S,MAAOk4B,EAAUl4B,OAAS,KAC1B3Y,UAAW6wC,EAAU7wC,WAErBsB,EAAOisC,GAAuBsD,GAC3BhC,GAAO,CACV,IAAIiC,EAAoBjC,EAAMvtC,EAAMtE,GACpC,IAAIhB,EAAU4F,QAAQkvC,GAGjB,CACDtO,EAAiBsO,GAAqBjrC,EACtC,KACJ,CALIgpC,EAAQxC,GAAuByE,EAMvC,CAQJ,YANuB,IAAnBtO,IACAA,EACIqO,EAAUl4B,MACN3c,EAAU2tB,sBAAsBknB,EAAUl4B,MAAOk4B,EAAU7wC,WACzDhE,EAAUmc,gBAAgBtS,EAAW0nC,GAAuBsD,MAEnD,IAAnBrO,EACO38B,EAEJA,IAAc08B,EAAuBC,GAAkBA,EACxD38B,EAAY,IAAM28B,CAC5B,EACAsL,EAASjkC,UAAU6d,UAAY,SAAUpb,EAAStP,GAC9C,IAAIsmC,EAAoBh3B,EAAQxI,KAChC,GAAKw/B,IAEah3B,EAAQqM,OAASrM,EAAQzG,WAC3C,CAEA,QAAyB,IAArByG,EAAQoZ,SAAqB,CAC7B,IAAIA,EAAW1oB,EAAQ8nC,MAAMzB,cAAcC,EAAmB,cAC1D5d,IACApZ,EAAQoZ,SAAWA,EAC3B,CACA,IAAI8c,EAAiBn6B,KAAKi9B,kBAAkBh5B,GACxCzG,EAAY08B,EAAuBC,GACnCje,EAAWvnB,EAAQ8nC,MAAMzB,cAAcC,EAAmBd,GAC1DmM,EAAStmC,KAAK+nC,eAAe9jC,EAAQoZ,SAAU7f,GAC/C2C,EAAOmmC,GAAUA,EAAOnmC,KAC5B,GAAIA,EAAM,CACN,IAAIuoC,EAAcC,GAAyB3oC,KAAMi7B,EAAmBh3B,EAAStP,EAASA,EAAQ8nC,MAAMG,WAAWjpC,EAAUsqB,YAAYgd,GACjIA,EAAkB9c,MAChB8c,EAAmBd,IACzB,OAAOsI,GAAUtpC,UAAU6G,KAAK1J,MAAO6J,EAAM,CACzC+b,EACAwsB,GAER,CACA,OAAOxsB,CApBG,CAqBd,EACAupB,EAASjkC,UAAUonC,gBAAkB,SAAUvrB,EAAU7f,GACrD,IAAI8oC,EAAStmC,KAAK+nC,eAAe1qB,EAAU7f,GAC3C,OAAO8oC,GAAUA,EAAOnmC,IAC5B,EACAslC,EAASjkC,UAAUqnC,iBAAmB,SAAUC,EAAgBtrC,EAAWurC,GACvE,IAAIzC,EAAStmC,KAAK+nC,eAAee,EAAgBtrC,GAC7C4Y,EAAQkwB,GAAUA,EAAOlwB,MAK7B,OAJKA,GAAS2yB,IAEV3yB,GADAkwB,EAAStmC,KAAKumC,cAAcwC,KACVzC,EAAOlwB,OAEtBA,CACX,EACAqvB,EAASjkC,UAAUwnC,iBAAmB,SAAU9sB,EAAUC,EAAU1mB,EAAId,EAASgoC,GAC7E,IAAIrsB,EAAQ7a,EAAG6a,MAAO+M,EAAW5nB,EAAG4nB,SAAUjH,EAAQ3gB,EAAG2gB,MACzD,OAAIA,IAAUkvB,GACH2D,GAAyBt0C,EAAQ8nC,MAAjCwM,CAAwC/sB,EAAUC,GAEzD/F,IAAUovB,GACHrpB,GAEPxnB,EAAQu0C,YACRhtB,OAAW,GAER9F,EAAM8F,EAAUC,EAAUwsB,GAAyB3oC,UAC1D,EAAQ,CACJqd,SAAUA,EACV7f,UAAW8S,EAAMzZ,KAAKrD,MACtB8c,MAAOA,EACP3Y,UAAWhD,EAAQgD,WACpBhD,EAASgoC,GAAWtpC,OAAOY,OAAO,QACzC,EACOwxC,CACX,CAxVgB,GAyVhB,SAASkD,GAAyB/N,EAAUK,EAAmBuN,EAAW7zC,EAASgoC,GAC/E,IAAIxC,EAAiBS,EAASqC,kBAAkBuL,GAC5ChrC,EAAY08B,EAAuBC,GACnCxiC,EAAY6wC,EAAU7wC,WAAahD,EAAQgD,UAC3ClC,EAAKd,EAAQ8nC,MAAOtB,EAAc1lC,EAAG0lC,YAAa/b,EAAU3pB,EAAG2pB,QACnE,MAAO,CACHnmB,KAAMisC,GAAuBsD,GAC7Bl4B,MAAOk4B,EAAUl4B,OAAS,KAC1B9S,UAAWA,EACX28B,eAAgBA,EAChBxiC,UAAWA,EACXsmB,YAAatqB,EAAUsqB,YACvBkd,YAAaA,EACbwB,QAASA,EACTrmC,MAAOskC,EAAStkC,MAChB8oB,QAASA,EACTC,UAAW,WACP,OAAOub,EAASvb,UAAUgnB,GAA0BntC,UAAW+hC,EAAmBtjC,GAAYhD,EAClG,EACA4wC,aAAc0D,GAAyBt0C,EAAQ8nC,OAEvD,CACA,SAAS4J,GAA0B8C,EAAelO,EAAmBtjC,GACjE,IACIsM,EADAu4B,EAAqB2M,EAAc,GAAI1tC,EAAO0tC,EAAc,GAAIC,EAAOD,EAAc9wC,OAoBzF,MAlBkC,kBAAvBmkC,EACPv4B,EAAU,CACNzG,UAAWg/B,EACX/gC,KAAM2tC,EAAO,EAAI3tC,EAAOw/B,IAI5Bh3B,EAAUrQ,EAAMiC,SAAS,CAAC,EAAG2mC,GACxBjD,EAAOv2B,KAAKiB,EAAS,UACtBA,EAAQxI,KAAOw/B,KAGI,IAAvBjlC,WAAWC,cAAsC,IAAjBgO,EAAQxI,OACjB,IAAvBzF,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,EAAGvC,EAAU6tB,oBAAoBloB,MAAMmC,KAAK0tC,UAEnG,IAAWllC,EAAQtM,YACnBsM,EAAQtM,UAAYA,GAEjBsM,CACX,CACA,SAASglC,GAAyBxM,GAC9B,OAAO,SAAsBvgB,EAAUC,GACnC,GAAIxoB,EAAU4F,QAAQ2iB,IAAavoB,EAAU4F,QAAQ4iB,GACjD,MAAM1oB,EAAQ+P,kBAAkB,GAEpC,GAAI7P,EAAUiZ,gBAAgBsP,IAAavoB,EAAUiZ,gBAAgBuP,GAAW,CAC5E,IAAIktB,EAAQ5M,EAAMzB,cAAc9e,EAAU,cACtCotB,EAAQ7M,EAAMzB,cAAc7e,EAAU,cAE1C,GADkBktB,GAASC,GAASD,IAAUC,EAE1C,OAAOntB,EAEX,GAAIxoB,EAAUsqB,YAAY/B,IAAaoe,EAAwBne,GAE3D,OADAsgB,EAAMrmB,MAAM8F,EAASiC,MAAOhC,GACrBD,EAEX,GAAIoe,EAAwBpe,IAAavoB,EAAUsqB,YAAY9B,GAE3D,OADAsgB,EAAMrmB,MAAM8F,EAAUC,EAASgC,OACxBhC,EAEX,GAAIme,EAAwBpe,IACxBoe,EAAwBne,GACxB,OAAOvoB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGqmB,GAAWC,EAE5D,CACA,OAAOA,CACX,CACJ,CAEA,SAASotB,GAAiB50C,EAAS60C,EAAYC,GAC3C,IAAI3jC,EAAM,GAAGhK,OAAO0tC,GAAY1tC,OAAO2tC,GACnCC,EAAW/0C,EAAQg1C,QAAQ9xC,IAAIiO,GAOnC,OANK4jC,GACD/0C,EAAQg1C,QAAQ/wC,IAAIkN,EAAM4jC,EACtB/0C,EAAQ60C,aAAeA,GAAc70C,EAAQ80C,WAAaA,EACtD90C,EACEf,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU,CAAE60C,WAAYA,EAAYC,SAAUA,KAEvFC,CACX,CACA,IAAIE,GAAgB,WAChB,SAASA,EAAYtzC,EAAO4J,EAAQnI,GAChCiI,KAAK1J,MAAQA,EACb0J,KAAKE,OAASA,EACdF,KAAKjI,UAAYA,CACrB,CAsSA,OArSA6xC,EAAYpoC,UAAUqoC,aAAe,SAAUpN,EAAOhnC,GAClD,IAAI+U,EAAQxK,KACRgF,EAAQvP,EAAGuP,MAAOjC,EAAStN,EAAGsN,OAAQk2B,EAASxjC,EAAGwjC,OAAQthC,EAAYlC,EAAGkC,UAAWuxC,EAAYzzC,EAAGyzC,UACnGY,EAAsBn2C,EAAUwK,uBAAuB6G,GACvDkR,EA7+CD,IAAIviB,EAAUwiB,WA8+CjBxe,EAAY/D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlC,EAAU2oB,iBAAiBwtB,IAAuBnyC,GAChG,IAAIhD,EAAUf,EAAMiC,SAASjC,EAAMiC,SAAS,CAAE4mC,MAAOA,EAAOsN,QAAS12C,OAAOY,OAAO,MAAOmiB,MAAO,SAAU8F,EAAUC,GAC7G,OAAOjG,EAAOE,MAAM8F,EAAUC,EAClC,EAAGxkB,UAAWA,EAAW2pC,UAAW3tC,EAAUma,mBAAmBnW,IAAc4iC,EAAuBv1B,EAAOhF,KAAKjI,YAAa,CAAEmxC,YAAaA,EAAWc,aAAc,IAAI/vC,IAAOuvC,YAAY,EAAOC,UAAU,EAAOE,QAAS,IAAI1vC,MACnOiqB,EAAMlkB,KAAKiqC,oBAAoB,CAC/BlnC,OAAQA,GAAU1P,OAAOY,OAAO,MAChCglC,OAAQA,EACRt+B,aAAcmvC,EAAoBnvC,aAClCuvC,UAAW,CAAEjnC,IAAK,IAAIhJ,KACtBtF,QAASA,IAEb,IAAKhB,EAAUsqB,YAAYiG,GACvB,MAAMzwB,EAAQ+P,kBAAkB,GAAIT,GAqCxC,OAnCApO,EAAQq1C,aAAa5qC,QAAQ,SAAU3J,EAAIwjC,GACvC,IAAIuC,EAAc/lC,EAAG+lC,YAAa0O,EAAYz0C,EAAGy0C,UAAWC,EAAe10C,EAAG00C,aAC1EC,EAAYz2C,EAAU0qB,cAAc4a,GACxC,GAAIiR,GAAaA,EAAUjnC,IAAIlK,KAAM,CACjC,IAAIsxC,EAAU7/B,EAAM8/B,YAAYJ,EAAWE,EAAW5O,EAAa7mC,GACnE,GAAIhB,EAAUsqB,YAAYosB,GACtB,OAEJ7O,EAAc6O,CAClB,CACA,IAA2B,IAAvBr0C,WAAWC,UAAsBtB,EAAQu0C,UAAW,CACpD,IAAIqB,EAA4Bl3C,OAAOY,OAAO,MAC9Ck2C,EAAa/qC,QAAQ,SAAUkR,GACvBA,EAAM3V,eACN4vC,EAA0Bj6B,EAAMzZ,KAAKrD,QAAS,EAEtD,GASAH,OAAOkK,KAAKi+B,GAAap8B,QAAQ,SAAU+6B,IARnB,SAAUA,GAC9B,OACI,IADGoQ,EAA0BrQ,EAAuBC,GAE5D,EAMQqQ,CAAkBrQ,KALD,SAAUA,GAC/B,IAAIsQ,EAAYP,GAAaA,EAAUjnC,IAAIpL,IAAIsiC,GAC/C,OAAOjc,QAAQusB,GAAaA,EAAU7H,MAAQ6H,EAAU7H,KAAKxsB,MACjE,CAGSs0B,CAAmBvQ,IAoS5C,SAA2BwQ,EAAaC,EAAazQ,EAAgBsC,GACjE,IAAIoO,EAAW,SAAU3P,GACrB,IAAI3jB,EAAQklB,EAAMzB,cAAcE,EAAUf,GAC1C,MAAwB,kBAAV5iB,GAAsBA,CACxC,EACI2E,EAAW2uB,EAASF,GACxB,IAAKzuB,EACD,OACJ,IAAIC,EAAW0uB,EAASD,GACxB,IAAKzuB,EACD,OACJ,GAAIxoB,EAAUsqB,YAAY/B,GACtB,OACJ,GAAI8G,EAAMA,MAAM9G,EAAUC,GACtB,OACJ,GAAI9oB,OAAOkK,KAAK2e,GAAU/N,MAAM,SAAUrI,GAAO,YAA8C,IAAvC22B,EAAMzB,cAAc7e,EAAUrW,EAAiB,GACnG,OAEJ,IAAIglC,EAAarO,EAAMzB,cAAc2P,EAAa,eAC9ClO,EAAMzB,cAAc4P,EAAa,cACjCptC,EAAY08B,EAAuBC,GACnC4Q,EAAc,GAAGjvC,OAAOgvC,EAAY,KAAKhvC,OAAO0B,GACpD,GAAIwtC,GAAS3vC,IAAI0vC,GACb,OACJC,GAASjvC,IAAIgvC,GACb,IAAIE,EAAiB,GAChBt3C,EAAU4F,QAAQ2iB,IAAcvoB,EAAU4F,QAAQ4iB,IACnD,CAACD,EAAUC,GAAU/c,QAAQ,SAAUmY,GACnC,IAAI8F,EAAWof,EAAMzB,cAAczjB,EAAO,cAClB,kBAAb8F,GAA0B4tB,EAAej0C,SAASqmB,IACzD4tB,EAAezyC,KAAK6kB,EAE5B,IAEmB,IAAvBrnB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAAIsH,EAAWstC,EAAYG,EAAe5yC,OAC7F,qCACI4yC,EAAe1kC,KAAK,SACpB,8CACF,GAAIwkC,EAAan3C,EAAMiC,SAAS,CAAC,EAAGqmB,GAAWtoB,EAAMiC,SAAS,CAAC,EAAGsmB,GAC5E,CA1UwB+uB,CAAkBd,EAAW5O,EAAarB,EAAgBxlC,EAAQ8nC,MAE1E,EACJ,CACAA,EAAMrmB,MAAM6iB,EAAQuC,EACxB,GACAiB,EAAMnQ,OAAOpI,EAAI/F,OACV+F,CACX,EACA0lB,EAAYpoC,UAAUyoC,oBAAsB,SAAUx0C,GAClD,IAAI+U,EAAQxK,KACRi5B,EAASxjC,EAAGwjC,OAAQl2B,EAAStN,EAAGsN,OAAQpI,EAAelF,EAAGkF,aAAchG,EAAUc,EAAGd,QACzFu1C,EAAYz0C,EAAGy0C,UACXtP,EAAW56B,KAAK1J,MAAMskC,SACtBze,EAAW9oB,OAAOY,OAAO,MACzBopB,EAAY4b,GAAU2B,EAASa,kBAAkBxC,IACjDtlC,EAAUwpB,sBAAsBpa,EAAQpI,EAAchG,EAAQwI,cAC7D87B,GAAUtkC,EAAQ8nC,MAAM5kC,IAAIohC,EAAQ,cACrC,kBAAoB5b,IACpBlB,EAASpf,WAAasgB,GAE1B,IAAIgC,EAAY,WACZ,IAAIpb,EAAUoiC,GAA0BntC,UAAWijB,EAAUxnB,EAAQgD,WACrE,GAAIhE,EAAUsqB,YAAYha,EAAQxI,MAAO,CACrC,IAAImnC,EAAOjuC,EAAQq1C,aAAanyC,IAAIoM,EAAQxI,KAAK0iB,OACjD,GAAIykB,EAAM,CACN,IAAI9R,EAAW8J,EAASvb,UAAUzrB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAExI,KAAMmnC,EAAKpH,cAAgB7mC,GAC3G,QAAiB,IAAbm8B,EACA,OAAOA,CAEf,CACJ,CACA,OAAO8J,EAASvb,UAAUpb,EAAStP,EACvC,EACIw1C,EAAe,IAAI9vC,IACvB2F,KAAKmrC,cAAcxwC,EAAcoI,EACjCpO,EAAS0oB,GAAUje,QAAQ,SAAUzK,EAAS2b,GAC1C,IAAI7a,EACA21C,EAAiBz3C,EAAU4I,uBAAuB+T,GAClD9c,EAAQuP,EAAOqoC,GAEnB,GADAjB,EAAapuC,IAAIuU,QACH,IAAV9c,EAAkB,CAClB,IAAI2mC,EAAiBS,EAASqC,kBAAkB,CAC5C5f,SAAUA,EACV7f,UAAW8S,EAAMzZ,KAAKrD,MACtB8c,MAAOA,EACP3Y,UAAWhD,EAAQgD,YAEnB8yC,EAAYY,GAAkBnB,EAAW/P,GACzCwF,EAAgBn1B,EAAM8gC,kBAAkB93C,EAAO8c,EACnDA,EAAM3V,aACF4uC,GAAiB50C,GAAS,GAAO,GAC/BA,EAAS81C,GACX1B,OAAgB,EAChBz4B,EAAM3V,eACLhH,EAAUsqB,YAAY0hB,IAAkBrF,EAAwBqF,MACjEoJ,EAAgB1pB,EAAU,aAAcsgB,IAE5C,IAAIvpB,EAAQwkB,EAASiO,iBAAiBxrB,EAAU/M,EAAMzZ,KAAKrD,MAAOu1C,GAC9D3yB,EACAq0B,EAAU7H,KAAO,CACbtyB,MAAOA,EACP+M,SAAUA,EACVjH,MAAOA,GAIXm1B,GAA2BrB,EAAW/P,GAE1Che,EAAWxnB,EAAQyhB,MAAM+F,IAAW1mB,EAAK,CAAC,GACnC0kC,GAAkBwF,EACrBlqC,GACR,MACgC,IAAvBO,WAAWC,SACftB,EAAQ60C,YACR70C,EAAQ80C,UACR91C,EAAUyhB,sBAAsBI,MAAMlF,IACtCsqB,EAASgO,gBAAgBvrB,EAAU/M,EAAMzZ,KAAKrD,SACxB,IAAvBwC,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAM,GAAI/K,EAAU4I,uBAAuB+T,GAAQvN,EAE7G,GACA,IACI,IAAIvH,EAAKo/B,EAAS5P,SAASjoB,EAAQ,CAC/Bsa,SAAUA,EACV1iB,aAAcA,EACdwC,YAAaxI,EAAQwI,YACrBq+B,YAAarf,EACbkD,UAAWA,IACXf,EAAK9iB,EAAG,GAAIm+B,EAAYn+B,EAAG,GAC/By9B,EAASA,GAAU3a,EACfqb,IACAxd,EAAWxnB,EAAQyhB,MAAM+F,EAAUwd,GAE3C,CACA,MAAO7lC,GACH,IAAKmlC,EACD,MAAMnlC,CACd,CACA,GAAI,kBAAoBmlC,EAAQ,CAC5B,IAAIuS,EAAU73C,EAAU0qB,cAAc4a,GAClCwS,EAAO92C,EAAQo1C,QAAQ9Q,KAAYtkC,EAAQo1C,QAAQ9Q,GAAU,IACjE,GAAIwS,EAAK1pC,QAAQpH,IAAiB,EAC9B,OAAO6wC,EAEX,GADAC,EAAKjzC,KAAKmC,GACNqF,KAAKE,QACLF,KAAKE,OAAO2hC,QAAQ9+B,EAAQyoC,EAAS7wC,EAAchG,GACnD,OAAO62C,EAEX,IAAIE,EAAa/2C,EAAQq1C,aAAanyC,IAAIohC,GAa1C,OAZIyS,GACAA,EAAWlQ,YAAc7mC,EAAQyhB,MAAMs1B,EAAWlQ,YAAarf,GAC/DuvB,EAAWxB,UAAYyB,GAAgBD,EAAWxB,UAAWA,GAC7DC,EAAa/qC,QAAQ,SAAUkR,GAAS,OAAOo7B,EAAWvB,aAAapuC,IAAIuU,EAAQ,IAGnF3b,EAAQq1C,aAAapxC,IAAIqgC,EAAQ,CAC7BuC,YAAarf,EACb+tB,UAAW0B,GAAiB1B,QAAa,EAASA,EAClDC,aAAcA,IAGfqB,CACX,CACA,OAAOrvB,CACX,EACAytB,EAAYpoC,UAAU8pC,kBAAoB,SAAU93C,EAAO8c,EAAO3b,EAASu1C,GACvE,IAAI1/B,EAAQxK,KACZ,OAAKsQ,EAAM3V,cAA0B,OAAVnH,EAGvBG,EAAU4F,QAAQ/F,GACXA,EAAMyP,IAAI,SAAUpH,EAAMiG,GAC7B,IAAItO,EAAQgX,EAAM8gC,kBAAkBzvC,EAAMyU,EAAO3b,EAAS02C,GAAkBnB,EAAWpoC,IAEvF,OADAypC,GAA2BrB,EAAWpoC,GAC/BtO,CACX,GAEGwM,KAAKiqC,oBAAoB,CAC5BlnC,OAAQvP,EACRmH,aAAc2V,EAAM3V,aACpBhG,QAASA,EACTu1C,UAAWA,KAbmB,IAAvBl0C,WAAWC,QAAoBtC,EAAUooB,UAAUvoB,GAASA,CAe3E,EACAo2C,EAAYpoC,UAAU2pC,cAAgB,SAAUxwC,EAAcoI,EAAQpO,EAAS0oB,QAC1D,IAAbA,IAAuBA,EAAW1pB,EAAUwpB,sBAAsBpa,EAAQpI,EAAchG,EAAQwI,cACpG,IAAI0uC,EAAW,IAAI5xC,IACf2gC,EAAW56B,KAAK1J,MAAMskC,SACtBkR,EAAe,IAAI/gC,EAAK2G,MAAK,GA8CjC,OA7CA,SAAUq6B,EAAQpxC,EAAcqxC,GAC5B,IAAIC,EAAcH,EAAa5V,OAAOv7B,EACtCqxC,EAAiBxC,WAAYwC,EAAiBvC,UAC1CwC,EAAYC,UAEhBD,EAAYC,SAAU,EACtBvxC,EAAauB,WAAWkD,QAAQ,SAAUjD,GACtC,GAAKxI,EAAUytB,cAAcjlB,EAAWxH,EAAQgD,WAAhD,CAEA,IAAI6xC,EAAawC,EAAiBxC,WAAYC,EAAWuC,EAAiBvC,SAgB1E,GAdED,GAAcC,IACZ91C,EAAUue,gBAAgB/V,EAAUyP,aACpCzP,EAAUyP,WAAWxM,QAAQ,SAAUq4B,GACnC,IAAI5gC,EAAO4gC,EAAI5gC,KAAKrD,MAGpB,GAFa,WAATqD,IACA2yC,GAAa,GACJ,UAAT3yC,EAAkB,CAClB,IAAIoC,EAAOtF,EAAUunB,yBAAyBuc,EAAK9iC,EAAQgD,WACtDsB,IAAoB,IAAZA,EAAKkzC,KACd1C,GAAW,EAEnB,CACJ,GAEA91C,EAAU6c,QAAQrU,GAAY,CAC9B,IAAI+f,EAAW2vB,EAASh0C,IAAIsE,GACxB+f,IACAstB,EAAaA,GAActtB,EAASstB,WACpCC,EAAWA,GAAYvtB,EAASutB,UAEpCoC,EAASjzC,IAAIuD,EAAWotC,GAAiB50C,EAAS60C,EAAYC,GAClE,KACK,CACD,IAAIvsC,EAAWvJ,EAAUqZ,yBAAyB7Q,EAAWxH,EAAQyI,gBACrE,IAAKF,GAAYf,EAAUrE,OAAS6B,EAAQyC,KAAKY,gBAC7C,MAAMvJ,EAAQ+P,kBAAkB,GAAIrH,EAAUtF,KAAKrD,OAEnD0J,GACA09B,EAAS99B,gBAAgBI,EAAUmgB,EAAUta,EAAQpO,EAAQgD,YAC7Do0C,EAAQ7uC,EAASvC,aAAc4uC,GAAiB50C,EAAS60C,EAAYC,GAE7E,CAlCU,CAmCd,GACH,CA5CD,CA4CG9uC,EAAchG,GACVk3C,CACX,EACAjC,EAAYpoC,UAAU8oC,YAAc,SAAUJ,EAAWhuB,EAAUC,EAAUxnB,EAASy3C,GAClF,IAAI32C,EACA+U,EAAQxK,KACZ,GAAIkqC,EAAUjnC,IAAIlK,OAASpF,EAAUsqB,YAAY9B,GAAW,CACxD,IASIigB,EATAiQ,EACF14C,EAAU4F,QAAQ4iB,KACfxoB,EAAUsqB,YAAY/B,KAAaoe,EAAwBpe,QAE1D,EADFA,EAEAowB,EAAMnwB,EACNkwB,IAAQD,IACRA,EAAiB,CAACz4C,EAAUsqB,YAAYouB,GAAOA,EAAIluB,MAAQkuB,IAG/D,IAAIE,EAAa,SAAU9wC,EAAM5E,GAC7B,OAAQlD,EAAU4F,QAAQkC,GACN,kBAAT5E,EACH4E,EAAK5E,QACH,EACJlC,EAAQ8nC,MAAMzB,cAAcv/B,EAAM8iB,OAAO1nB,GACnD,EACAqzC,EAAUjnC,IAAI7D,QAAQ,SAAUqrC,EAAWtQ,GACvC,IAAIqS,EAAOD,EAAWF,EAAKlS,GACvBsS,EAAOF,EAAWD,EAAKnS,GAC3B,QAAI,IAAWsS,EAAf,CAEIL,GACAA,EAAe5zC,KAAK2hC,GAExB,IAAIuS,EAAOliC,EAAM8/B,YAAYG,EAAW+B,EAAMC,EAAM93C,EAASy3C,GACzDM,IAASD,IACTrQ,EAAkBA,GAAmB,IAAIniC,KACzBrB,IAAIuhC,EAAgBuS,GAEpCN,GACA34C,EAAQiB,UAAU03C,EAAeO,QAAUxS,EAVrC,CAYd,GACIiC,IACAjgB,EAAYxoB,EAAU4F,QAAQ+yC,GAAOA,EAAIntC,MAAM,GAAKvL,EAAMiC,SAAS,CAAC,EAAGy2C,GACvElQ,EAAgBh9B,QAAQ,SAAU5L,EAAOqD,GACrCslB,EAAStlB,GAAQrD,CACrB,GAER,CACA,OAAI02C,EAAUtH,KACH5iC,KAAK1J,MAAMskC,SAASoO,iBAAiB9sB,EAAUC,EAAU+tB,EAAUtH,KAAMjuC,EAASy3C,IAAmB32C,EAAKd,EAAQ8nC,OAAOG,WAAWxjC,MAAM3D,EAAI22C,IAElJjwB,CACX,EACOytB,CACX,CA5SmB,GA6SfgD,GAAqB,GACzB,SAASvB,GAAkB51C,EAAIoB,GAC3B,IAAIoM,EAAMxN,EAAGwN,IAIb,OAHKA,EAAI5H,IAAIxE,IACToM,EAAIrK,IAAI/B,EAAM+1C,GAAmBD,OAAS,CAAE1pC,IAAK,IAAIhJ,MAElDgJ,EAAIpL,IAAIhB,EACnB,CACA,SAAS80C,GAAgBr6B,EAAMC,GAC3B,GAAID,IAASC,IAAUA,GAASq6B,GAAiBr6B,GAC7C,OAAOD,EACX,IAAKA,GAAQs6B,GAAiBt6B,GAC1B,OAAOC,EACX,IAAIqxB,EAAOtxB,EAAKsxB,MAAQrxB,EAAMqxB,KAAOhvC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGyb,EAAKsxB,MAAOrxB,EAAMqxB,MAAQtxB,EAAKsxB,MAAQrxB,EAAMqxB,KAChHiK,EAAkBv7B,EAAKrO,IAAIlK,MAAQwY,EAAMtO,IAAIlK,KAI7CimB,EAAS,CAAE4jB,KAAMA,EAAM3/B,IAHjB4pC,EAAkB,IAAI5yC,IAC1BqX,EAAKrO,IAAIlK,KAAOuY,EAAKrO,IACjBsO,EAAMtO,KAEhB,GAAI4pC,EAAiB,CACjB,IAAIC,EAAuB,IAAIzyC,IAAIkX,EAAMtO,IAAI1F,QAC7C+T,EAAKrO,IAAI7D,QAAQ,SAAU2tC,EAAUjnC,GACjCkZ,EAAO/b,IAAIrK,IAAIkN,EAAK6lC,GAAgBoB,EAAUx7B,EAAMtO,IAAIpL,IAAIiO,KAC5DgnC,EAAqBrhC,OAAO3F,EAChC,GACAgnC,EAAqB1tC,QAAQ,SAAU0G,GACnCkZ,EAAO/b,IAAIrK,IAAIkN,EAAK6lC,GAAgBp6B,EAAMtO,IAAIpL,IAAIiO,GAAMwL,EAAKrO,IAAIpL,IAAIiO,IACzE,EACJ,CACA,OAAOkZ,CACX,CACA,SAAS4sB,GAAiBpJ,GACtB,OAAQA,KAAUA,EAAKI,MAAQJ,EAAKv/B,IAAIlK,KAC5C,CACA,SAASwyC,GAA2B91C,EAAIoB,GACpC,IAAIoM,EAAMxN,EAAGwN,IACTwnC,EAAYxnC,EAAIpL,IAAIhB,GACpB4zC,GAAamB,GAAiBnB,KAC9BmC,GAAmBp0C,KAAKiyC,GACxBxnC,EAAIwI,OAAO5U,GAEnB,CACA,IAAIm0C,GAAW,IAAI3wC,IA0CnB,IAAI2yC,GAAkB,SAAUziC,GAE5B,SAASyiC,EAAcxoC,QACJ,IAAXA,IAAqBA,EAAS,CAAC,GACnC,IAAIgG,EAAQD,EAAOvH,KAAKhD,OAASA,KAmBjC,OAlBAwK,EAAMyiC,QAAU,IAAI5yC,IACpBmQ,EAAM0iC,qBAAuB,IAAIv5C,EAAUsd,kBAAkBtd,EAAUyhB,uBACvE5K,EAAMmtB,wBAAyB,EAC/BntB,EAAMu4B,QAAUA,GAChBv4B,EAAM2iC,QAAU,GACW,IAAvBn3C,WAAWC,UACX4uB,EAAkBrgB,EAAQ,cAAe,gBAAiB,6EAC1DqgB,EAAkBrgB,EAAQ,kBAAmB,gBAAiB,kFAElEgG,EAAMhG,OAz5Dd,SAAyBA,GACrB,OAAO7Q,EAAUumB,QAAQ0f,EAAep1B,EAC5C,CAu5DuB4oC,CAAgB5oC,GAC/BgG,EAAMsvB,cAAgBtvB,EAAMhG,OAAOs1B,YACnCtvB,EAAMowB,SAAW,IAAI6K,GAAS,CAC1BnvC,MAAOkU,EACPqvB,iBAAkBrvB,EAAMhG,OAAOq1B,iBAC/BmM,cAAex7B,EAAMhG,OAAOwhC,cAC5BN,aAAcl7B,EAAMhG,OAAOkhC,eAE/Bl7B,EAAM6iC,OACC7iC,CACX,CAuSA,OA9TA5W,EAAM8W,UAAUsiC,EAAeziC,GAwB/ByiC,EAAcxrC,UAAU6rC,KAAO,WAC3B,IAAIC,EAAattC,KAAKtF,KAAO,IAAInH,EAAQonC,YAAY0D,KAAK,CACtDzD,SAAU56B,KAAK46B,SACfb,cAAe/5B,KAAKwE,OAAOu1B,gBAE/B/5B,KAAKutC,eAAiBD,EAAUxO,MAChC9+B,KAAKwtC,kBACT,EACAR,EAAcxrC,UAAUgsC,iBAAmB,SAAUC,GACjD,IAAIjjC,EAAQxK,KACR0tC,EAAiB1tC,KAAK2tC,YACtB51C,EAAYiI,KAAKwE,OAAOzM,UAC5BiI,KAAKktC,qBAAqBr0C,aACZ,OAAdd,QAAoC,IAAdA,GAAgCA,EAAU61C,cAChE5tC,KAAK6tC,YAAc,IAAIjE,GAAY5pC,KAAOA,KAAK2tC,YAAc,IAAI9M,GAAY,CACzEvqC,MAAO0J,KACP85B,YAAa95B,KAAK85B,YAClBuH,mBAAoBrhC,KAAKwE,OAAO68B,mBAChChN,gBAAiB2F,EAAsBh6B,KAAKwE,QAC5Cu8B,MAAO0M,OAAwB,EAAUC,GAAkBA,EAAe3M,MAC1EhpC,UAAWA,IACVA,GACLiI,KAAK+1B,oBAAsB5/B,EAASyb,KAAK,SAAUk8B,EAAG7pC,GAClD,OAAOuG,EAAMujC,eAAeD,EAAG7pC,EACnC,EAAG,CACCkJ,IAAKnN,KAAKwE,OAAO68B,oBACb1tC,EAAU+D,WAAW,sCACrB,IACJma,aAAc,SAAUi8B,GACpB,IAAIrR,EAAQqR,EAAE3iB,WAAa3gB,EAAM+iC,eAAiB/iC,EAAM9P,KACxD,GAAIkkC,EAAsBnC,GAAQ,CAC9B,IAAItR,EAAa2iB,EAAE3iB,WAAY7M,EAAKwvB,EAAExvB,GAAI3mB,EAAYm2C,EAAEn2C,UACxD,OAAO8kC,EAAM5qB,aAAai8B,EAAE9oC,MAC5B8oC,EAAEp0B,SAAU/lB,EAAUma,mBAAmB,CAAEqd,WAAYA,EAAY7M,GAAIA,EAAI3mB,UAAWA,IAC1F,CACJ,IAEJ,IAAI0C,IAAI,CAAC2F,KAAKtF,KAAKmgC,MAAO76B,KAAKutC,eAAe1S,QAAQz7B,QAAQ,SAAUy7B,GACpE,OAAOA,EAAM0D,cACjB,EACJ,EACAyO,EAAcxrC,UAAUwsC,QAAU,SAAUtzC,GAIxC,OAHAsF,KAAKqtC,OACD3yC,GACAsF,KAAKtF,KAAK+C,QAAQ/C,GACfsF,IACX,EACAgtC,EAAcxrC,UAAU87B,QAAU,SAAUnS,GAExC,YADmB,IAAfA,IAAyBA,GAAa,IAClCA,EAAanrB,KAAKutC,eAAiBvtC,KAAKtF,MAAM4iC,SAC1D,EACA0P,EAAcxrC,UAAUrB,KAAO,SAAU8D,IACV,IAAvBjO,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,cAElD,IACAxO,EAAKwO,EAAQonB,kBACbA,OAA2B,IAAP51B,GAAwBA,EAC5C,IACI,OAAQuK,KAAK2tC,YAAYlM,sBAAsB7tC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEw4B,MAAOx4B,EAAQknB,WAAanrB,KAAKutC,eAAiBvtC,KAAKtF,KAAM8J,OAAQxE,KAAKwE,OAAQ6mB,kBAAmBA,KAAsBtoB,QAAU,IACtO,CACA,MAAOjP,GACH,GAAIA,aAAawlC,EACb,OAAO,KAEX,MAAMxlC,CACV,CACJ,EACAk5C,EAAcxrC,UAAUw3B,MAAQ,SAAU/0B,GACtC,IAEI,QADEjE,KAAKmtC,QACAntC,KAAK6tC,YAAYhE,aAAa7pC,KAAKtF,KAAMuJ,EACpD,CACA,UACWjE,KAAKmtC,UAAiC,IAAtBlpC,EAAQg/B,WAC3BjjC,KAAKgjC,kBAEb,CACJ,EACAgK,EAAcxrC,UAAU82B,OAAS,SAAUr0B,GACvC,GAAIs1B,EAAOv2B,KAAKiB,EAAS,QAAUA,EAAQqa,GACvC,OAAO,EAEX,IAAIme,EAAUx4B,EACd,WACIjE,KAAKutC,eACHvtC,KAAKtF,KACX,IAEI,QADEsF,KAAKmtC,QACA1Q,EAAMnE,OAAOr0B,EAAQqa,IAAM,aAAcra,EAAQkL,OAC5D,CACA,UACWnP,KAAKmtC,UAAiC,IAAtBlpC,EAAQg/B,WAC3BjjC,KAAKgjC,kBAEb,CACJ,EACAgK,EAAcxrC,UAAU0pB,KAAO,SAAUjnB,GAIrC,OAH2B,IAAvBjO,WAAWC,SACX4uB,EAAkB5gB,EAAS,kBAAmB,cAE3CjE,KAAK2tC,YAAYlM,sBAAsB7tC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEw4B,MAAOx4B,EAAQknB,WAAanrB,KAAKutC,eAAiBvtC,KAAKtF,KAAM89B,OAAQv0B,EAAQqa,IAAM,aAAc9Z,OAAQxE,KAAKwE,SAC9M,EACAwoC,EAAcxrC,UAAUo3B,MAAQ,SAAUA,GACtC,IAvmCatiC,EAumCTkU,EAAQxK,KAQZ,OAPKA,KAAKitC,QAAQl0C,MAvmCtB4pC,GADiBrsC,EAymCG0J,MAxmCA6iC,KAAKzjC,QAAQ,SAAUiyB,GAAM,OAAOA,EAAG+R,YAAY9sC,EAAQ,GA0mC3E0J,KAAKitC,QAAQlxC,IAAI68B,GACbA,EAAMC,WACN74B,KAAK+1B,oBAAoB6C,GAEtB,WACCpuB,EAAMyiC,QAAQxhC,OAAOmtB,KAAWpuB,EAAMyiC,QAAQl0C,MAC9C+pC,GAAYt4B,GAEhBA,EAAMurB,oBAAoBkY,OAAOrV,EACrC,CACJ,EACAoU,EAAcxrC,UAAU62B,GAAK,SAAUp0B,IACR,IAAvBjO,WAAWC,SACX4uB,EAAkB5gB,GAAW,CAAC,EAAG,wBAAyB,WAAY,sFAE1EtQ,EAAUma,mBAAmBG,QAC7Bta,EAAUsR,MAAMgJ,QAChB,IAAI4vB,EAAM79B,KAAKutC,eAAelV,KAS9B,OARIp0B,IAAYjE,KAAKmtC,UACblpC,EAAQupC,iBACRxtC,KAAKwtC,iBAAiBvpC,EAAQwpC,uBAEzBxpC,EAAQwpC,uBACbztC,KAAK2tC,YAAYnM,cAGlB3D,CACX,EACAmP,EAAcxrC,UAAU8qB,OAAS,SAAUkM,EAAQrN,GAC/C,OAAQA,EAAanrB,KAAKutC,eAAiBvtC,KAAKtF,MAAM4xB,OAAOkM,EACjE,EACAwU,EAAcxrC,UAAUo8B,QAAU,SAAUpF,EAAQrN,GAChD,OAAQA,EAAanrB,KAAKutC,eAAiBvtC,KAAKtF,MAAMkjC,QAAQpF,EAClE,EACAwU,EAAcxrC,UAAUwpB,SAAW,SAAUoN,GACzC,GAAIzkC,EAAUsqB,YAAYma,GACtB,OAAOA,EAAOja,MAClB,IACI,OAAOne,KAAK46B,SAAS5P,SAASoN,GAAQ,EAC1C,CACA,MAAOtkC,IACoB,IAAvBkC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAKpC,EAC3D,CACJ,EACAk5C,EAAcxrC,UAAU07B,MAAQ,SAAUj5B,GACtC,IAAKA,EAAQqa,GAAI,CACb,GAAIib,EAAOv2B,KAAKiB,EAAS,MACrB,OAAO,EAEXA,EAAUrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEqa,GAAI,cAChE,CACA,IAEI,QADEte,KAAKmtC,QACAntC,KAAKutC,eAAerQ,MAAMj5B,EAASjE,KAAKtF,KACnD,CACA,UACWsF,KAAKmtC,UAAiC,IAAtBlpC,EAAQg/B,WAC3BjjC,KAAKgjC,kBAEb,CACJ,EACAgK,EAAcxrC,UAAUyM,MAAQ,SAAUhK,GACtC,IAAIuG,EAAQxK,KAWZ,OAVAA,KAAKqtC,OACL15C,EAAUma,mBAAmBG,QACzBhK,GAAWA,EAAQiqC,gBACnBluC,KAAKitC,QAAQ7tC,QAAQ,SAAUw5B,GAAS,OAAOpuB,EAAMurB,oBAAoBkY,OAAOrV,EAAQ,GACxF54B,KAAKitC,QAAQ5P,QACbyF,GAAY9iC,OAGZA,KAAKgjC,mBAEFrjC,QAAQC,SACnB,EACAotC,EAAcxrC,UAAU2sC,iBAAmB,SAAUC,GACjD,IAAIC,EAAoBruC,KAAKutC,eAAenO,YAAYgP,GACpDC,IAAsBruC,KAAKutC,iBAC3BvtC,KAAKutC,eAAiBc,EACtBruC,KAAKgjC,mBAEb,EACAgK,EAAcxrC,UAAUq2B,MAAQ,SAAU5zB,GACtC,IAEI6zB,EAFAttB,EAAQxK,KACRsxB,EAASrtB,EAAQqtB,OAAQ77B,EAAKwO,EAAQknB,WAAYA,OAAoB,IAAP11B,GAAuBA,EAAI04C,EAAmBlqC,EAAQkqC,iBAAkBG,EAAiBrqC,EAAQqqC,eAEhKC,EAAU,SAAUC,GACpB,IAAI/4C,EAAK+U,EAAO9P,EAAOjF,EAAGiF,KAAM6yC,EAAiB93C,EAAG83C,iBAClD/iC,EAAM2iC,QACJqB,IACAhkC,EAAM9P,KAAO8P,EAAM+iC,eAAiBiB,GAExC,IACI,OAAQ1W,EAAexG,EAAO9mB,EAClC,CACA,UACMA,EAAM2iC,QACR3iC,EAAM9P,KAAOA,EACb8P,EAAM+iC,eAAiBA,CAC3B,CACJ,EACIkB,EAAe,IAAIp0C,IAkCvB,OAjCIi0C,IAAmBtuC,KAAKmtC,SACxBntC,KAAKgjC,iBAAiBpvC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEqqC,eAAgB,SAAU1V,GAEtF,OADA6V,EAAa1yC,IAAI68B,IACV,CACX,KAEkB,kBAAfzN,EACPnrB,KAAKutC,eAAiBvtC,KAAKutC,eAAetO,SAAS9T,EAAYojB,IAE3C,IAAfpjB,EACLojB,EAAQvuC,KAAKtF,MAGb6zC,IAE4B,kBAArBJ,IACPnuC,KAAKutC,eAAiBvtC,KAAKutC,eAAenO,YAAY+O,IAEtDG,GAAkBG,EAAa11C,MAC/BiH,KAAKgjC,iBAAiBpvC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEqqC,eAAgB,SAAU1V,EAAO1N,GAC7F,IAAInoB,EAASurC,EAAetrC,KAAKhD,KAAM44B,EAAO1N,GAI9C,OAHe,IAAXnoB,GACA0rC,EAAahjC,OAAOmtB,GAEjB71B,CACX,KACA0rC,EAAa11C,MACb01C,EAAarvC,QAAQ,SAAUw5B,GAAS,OAAOpuB,EAAMurB,oBAAoBoG,MAAMvD,EAAQ,IAI3F54B,KAAKgjC,iBAAiB/+B,GAEnB6zB,CACX,EACAkV,EAAcxrC,UAAUw2B,mBAAqB,SAAU1G,EAAQyG,GAC3D,OAAO/3B,KAAK63B,MAAM,CACdvG,OAAQA,EACRnG,WAAY4M,GAAiC,OAAjBA,GAEpC,EACAiV,EAAcxrC,UAAUgQ,kBAAoB,SAAUha,GAClD,OAAOwI,KAAKoV,sBAAsBpV,KAAK0uC,uBAAuBl3C,GAClE,EACAw1C,EAAcxrC,UAAU1E,gBAAkB,SAAUI,EAAUmgB,GAC1D,OAAOrd,KAAK46B,SAAS99B,gBAAgBI,EAAUmgB,EACnD,EACA2vB,EAAcxrC,UAAUpE,eAAiB,SAAUH,GAC/C,IAAIxH,EACJ,OAAyC,QAAhCA,EAAKuK,KAAKwE,OAAOzM,iBAA8B,IAAPtC,OAAgB,EAASA,EAAGygC,OAAOj5B,KAAkB,IAC1G,EACA+vC,EAAcxrC,UAAUwhC,iBAAmB,SAAU/+B,GACjD,IAAIuG,EAAQxK,KACPA,KAAKmtC,SACNntC,KAAKitC,QAAQ7tC,QAAQ,SAAU0uC,GAAK,OAAOtjC,EAAMurB,oBAAoB+X,EAAG7pC,EAAU,EAE1F,EACA+oC,EAAcxrC,UAAUktC,uBAAyB,SAAUl3C,GACvD,IAAIO,EAAYiI,KAAKwE,OAAOzM,UAC5B,OAAOA,EAAYA,EAAUmZ,UAAU1Z,GAAYA,CACvD,EACAw1C,EAAcxrC,UAAU4T,sBAAwB,SAAU5d,GACtD,OAAIwI,KAAK85B,YACE95B,KAAKktC,qBAAqB17B,kBAAkBha,GAEhDA,CACX,EACAw1C,EAAcxrC,UAAUusC,eAAiB,SAAUD,EAAG7pC,GAClD,IAAIuG,EAAQxK,KACR2uC,EAAWb,EAAEa,SACbzjB,EAAO1xB,EAAiB,kBAAmB,WAAc,OAAOgR,EAAM0gB,KAAK4iB,EAAI,GAC/E7pC,IACI6pC,EAAE3iB,YAA4C,kBAAvBlnB,EAAQknB,aAC/BD,EAAK0jB,2BAA4B,GAEjC3qC,EAAQqqC,iBACiD,IAAzDrqC,EAAQqqC,eAAetrC,KAAKhD,KAAM8tC,EAAG5iB,EAAMyjB,KAI9CA,GAAa3rB,EAAMA,MAAM2rB,EAAS5rC,OAAQmoB,EAAKnoB,SAChD+qC,EAAEp0B,SAAUo0B,EAAEa,SAAWzjB,EAAOyjB,EAExC,EACO3B,CACX,CAhUqB,CAgUnBtV,IACyB,IAAvB1hC,WAAWC,UACX+2C,GAAcxrC,UAAU43B,mBAAqB7D,GAUjD,IAAIsZ,GAAqB,WACrB,SAASA,IAEL,IADA,IAAI92C,EAAY,GACPI,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCJ,EAAUI,GAAMe,UAAUf,GAE9B6H,KAAK8uC,SAAWz7C,OAAOY,OAAO,MAC9B+L,KAAK4tC,cACD71C,EAAUM,QACV2H,KAAK+uC,SAAS31C,MAAM4G,KAAMjI,EAElC,CAiGA,OAhGA82C,EAAiBrtC,UAAUutC,SAAW,WAGlC,IAFA,IAAIvkC,EAAQxK,KACRjI,EAAY,GACPI,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCJ,EAAUI,GAAMe,UAAUf,GAE9B,IAAIC,EAAc,IAAI6B,IAYtB,OAXAlC,EAAUqH,QAAQ,SAAUsR,GACxB/c,EAAUsK,uBAAuByS,GAAKtR,QAAQ,SAAUvB,GACpDzF,EAAYQ,IAAIiF,EAAKhH,KAAKrD,MAAOqK,EACrC,EACJ,GACAzF,EAAYgH,QAAQ,SAAUvB,EAAMhH,GAC5BgH,IAAS2M,EAAMskC,SAASj4C,KACxB2T,EAAMskC,SAASj4C,GAAQgH,EACvB2M,EAAMwkC,WAAWn4C,GAEzB,GACOmJ,IACX,EACA6uC,EAAiBrtC,UAAUwtC,WAAa,SAAUn4C,GAAQ,EAC1Dg4C,EAAiBrtC,UAAUosC,YAAc,WACrC,IAAI1/B,EAAQ2gC,EAAiBrtC,UAC7BxB,KAAKgvC,YAAchvC,KAAKk2B,OAAS//B,EAASyb,KAAK1D,EAAMgoB,OAAOvtB,KAAK3I,MAAO,CACpE6R,aAAc,SAAU8D,GAAO,OAAOA,CAAK,EAC3CxI,IAAKxZ,EAAU+D,WAAW,4BACtB,OACJykC,MACJn8B,KAAKkR,UAAY/a,EAASyb,KAAK1D,EAAMgD,UAAUvI,KAAK3I,MAAO,CACvD1J,MAAO0U,EAAOuC,UACdJ,IAAKxZ,EAAU+D,WAAW,+BACtB,MAERsI,KAAKi2B,oBAAsB9/B,EAASyb,KAAK1D,EAAM+nB,oBAAoBttB,KAAK3I,MAAO,CAC3E1J,MAAO0U,EAAOuC,UACdJ,IAAKxZ,EAAU+D,WAAW,yCACtB,KAEZ,EACAm3C,EAAiBrtC,UAAU00B,OAAS,SAAUj5B,GAC1C,OAAO+C,KAAK8uC,SAAS7xC,IAAiB,IAC1C,EACA4xC,EAAiBrtC,UAAU0P,UAAY,SAAU1Z,GAC7C,IAAIgT,EAAQxK,KACRivC,EAAU,IAAIh1C,IAClBtG,EAAUsK,uBAAuBzG,GAAU4H,QAAQ,SAAU0V,GACzDm6B,EAAQr2C,IAAIkc,EAAIje,KAAKrD,MAAOshB,EAChC,GACA,IAAIo6B,EAAU,IAAI70C,IACd80C,EAAU,SAAUC,GACfH,EAAQ5zC,IAAI+zC,IACbF,EAAQnzC,IAAIqzC,EAEpB,EACIC,EAAsB,SAAUxxC,GAChC,OAAOxK,OAAOkK,KAAKiN,EAAMyrB,oBAAoBp4B,IAAOuB,QAAQ+vC,EAChE,EACAE,EAAoB73C,GACpB,IAAIi0B,EAAU,GACVxoB,EAAM5P,OAAOY,OAAO,MAcxB,GAbAi7C,EAAQ9vC,QAAQ,SAAUnC,GACtB,IAAIqyC,EAAmBL,EAAQp3C,IAAIoF,GACnC,GAAIqyC,EACAD,EAAqBpsC,EAAIhG,GAAgBqyC,OAExC,CACD7jB,EAAQjzB,KAAKyE,GACb,IAAI6X,EAAMtK,EAAM0rB,OAAOj5B,GACnB6X,GACAu6B,EAAqBpsC,EAAIhG,GAAgB6X,EAEjD,CACJ,GACI2W,EAAQpzB,OAAQ,CAChB,IAAIk3C,EAAiB,GACrB9jB,EAAQrsB,QAAQ,SAAUvI,GACtB,IAAIie,EAAM7R,EAAIpM,GACVie,GACAy6B,EAAe/2C,KAAKsc,EAE5B,GACIy6B,EAAel3C,SACfb,EAAW5D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2B,GAAW,CAAEY,YAAaZ,EAASY,YAAY0D,OAAOyzC,KAE3G,CACA,OAAO/3C,CACX,EACAq3C,EAAiBrtC,UAAUy0B,oBAAsB,SAAU9qB,GACvD,IAAIqkC,EAAUn8C,OAAOY,OAAO,MAM5B,OALA0F,EAAQ4R,MAAMJ,EAAM,CAChBkJ,eAAgB,SAAUxW,GACtB2xC,EAAQ3xC,EAAKhH,KAAKrD,OAASqK,CAC/B,IAEG2xC,CACX,EACOX,CACX,CA7GwB,GA+GxBt7C,EAAQua,mBAAqBna,EAAUma,mBACvCva,EAAQ0qB,YAActqB,EAAUsqB,YAChC1qB,EAAQ8qB,cAAgB1qB,EAAU0qB,cAClC9qB,EAAQmkC,YAAcA,EACtBnkC,EAAQy5C,cAAgBA,GACxBz5C,EAAQ+lC,kBAAoBA,EAC5B/lC,EAAQkyC,SAAWA,GACnBlyC,EAAQkvC,UAAYA,GACpBlvC,EAAQk8C,uBA9HR,WAEI,IADA,IAAI13C,EAAY,GACPI,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCJ,EAAUI,GAAMe,UAAUf,GAE9B,OAAO,IAAK02C,GAAiBlmC,KAAKvP,MAAMy1C,GAAkBj7C,EAAMyF,cAAc,MAAC,GAAStB,GAAW,IACvG,EAyHAxE,EAAQkmC,wBAA0BA,EAClClmC,EAAQ2mC,uBAAyBA,EACjC3mC,EAAQwvC,QAAUA,E,uCC7rFlB1vC,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAII,EAAQ,EAAQ,wBAChBH,EAAU,EAAQ,wBAClB6K,EAAO,EAAQ,wBACfqF,EAAO,EAAQ,wBACfqf,EAAQ,EAAQ,wBAChBrvB,EAAY,EAAQ,wBACpB2C,EAAQ,EAAQ,wBAChB+H,EAAS,EAAQ,wBACjBlI,EAAW,EAAQ,wBACnB4U,EAAO,EAAQ,wBACfuqB,EAAU,EAAQ,wBAClB37B,EAAU,EAAQ,wBAClByE,EAAQ,EAAQ,wBAChB4jB,EAAc,EAAQ,wBACtB0tB,EAAa,EAAQ,wBAEzB,SAAS91C,EAAuB9F,GAAK,OAAOA,GAAkB,kBAANA,GAAkB,YAAaA,EAAIA,EAAW,QAAIA,CAAG,CAE7G,IAAI+F,EAA8BD,EAAsBopB,GAIxD,SAASpW,EAAgBtL,GACrB,OAAe,OAARA,GAA+B,kBAARA,CAClC,CAMA,IAiFW8nB,EAjFPumB,EAAmBt8C,OAAOmO,UAAUD,eACpC8U,EAAoB,SAAUL,EAAQM,EAAQC,GAC9C,OAAOvW,KAAKoW,MAAMJ,EAAOO,GAAWD,EAAOC,GAC/C,EACIJ,EAAe,WACf,SAASA,EAAWK,QACG,IAAfA,IAAyBA,EAAaH,GAC1CrW,KAAKwW,WAAaA,EAClBxW,KAAKyW,SAAW7J,EAChB5M,KAAK0W,WAAa,IAAIrc,GAC1B,CA4CA,OA3CA8b,EAAW3U,UAAU4U,MAAQ,SAAUJ,EAAQM,GAG3C,IAFA,IAAI9L,EAAQxK,KACRrL,EAAU,GACLwD,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCxD,EAAQwD,EAAK,GAAKe,UAAUf,GAEhC,OAAIyU,EAAgB0J,IAAW1J,EAAgBoJ,IAC3C3iB,OAAOkK,KAAK+Y,GAAQlX,QAAQ,SAAUuX,GAClC,GAAIg5B,EAAiB3sC,KAAKgT,EAAQW,GAAY,CAC1C,IAAIC,EAAcZ,EAAOW,GACzB,GAAIL,EAAOK,KAAeC,EAAa,CACnC,IAAI7T,EAASyH,EAAMgM,WAAWpd,MAAMoR,EAAO5W,EAAMyF,cAAc,CAAC2c,EAC5DM,EACAK,GAAYhiB,GAAS,IACrBoO,IAAW6T,KACXZ,EAASxL,EAAMqM,oBAAoBb,IAC5BW,GAAa5T,EAE5B,CACJ,MAEIiT,EAASxL,EAAMqM,oBAAoBb,IAC5BW,GAAaL,EAAOK,EAEnC,GACOX,GAEJM,CACX,EACAH,EAAW3U,UAAUqV,oBAAsB,SAAUrjB,GAYjD,OAXIoZ,EAAgBpZ,KACXwM,KAAK0W,WAAWrb,IAAI7H,KAEjBA,EADA8F,MAAMC,QAAQ/F,GACNA,EAAM2L,MAAM,GAGZvL,EAAMiC,SAAS,CAAEihB,UAAWzjB,OAAOyZ,eAAetZ,IAAUA,GAExEwM,KAAK0W,WAAW3a,IAAIvI,KAGrBA,CACX,EACO2iB,CACX,CAnDkB,GAwDlB,SAASqI,EAAqBC,EAAY1b,GACtC,IAAI2b,EAAaD,EACbvI,EAAS,IAAIC,EAejB,MAnBO,gBAK+BpT,GAnE1C,SAAyBvP,GACrB,OAAO8F,MAAMC,QAAQ/F,IAAUA,EAAM6E,OAAS,CAClD,CAkEQ6Z,CAAgBnP,EAAOiX,cACvBjX,EAAOiX,YAAY5a,QAAQ,SAAU3J,GAEjC,IADA,IAAIiF,EAAOjF,EAAGiF,KAAMO,EAAOxF,EAAGwF,KACrB6G,EAAI7G,EAAK5C,OAAS,EAAGyJ,GAAK,IAAKA,EAAG,CACvC,IAAIgE,EAAM7K,EAAK6G,GAEX6c,GADgBC,OAAO9Y,GACG,GAAK,CAAC,EACpC6Y,EAAS7Y,GAAOpL,EAChBA,EAAOikB,CACX,CACAD,EAAaxI,EAAOE,MAAMsI,EAAYhkB,EAC1C,GAEGgkB,CACX,CAYA,SAASkxB,EAAyB5mB,GAC9B,QAAOA,GAAgBA,EAAgB,CAC3C,CAKA,SAASwN,EAAaxxB,EAAOvP,EAAI+F,EAAI7D,GACjC,IAAI8+B,EAAQhhC,EAAGiF,KAAMg8B,EAAQ9iC,EAAMoT,OAAOvR,EAAI,CAAC,SAC3CkhC,EAAQn7B,EAAGd,KAAMk8B,EAAQhjC,EAAMoT,OAAOxL,EAAI,CAAC,SAC/C,OAAQ3B,EAAe68B,EAAOE,IAC1BC,EAAoBljC,EAAUwU,kBAAkBnD,GAAOrK,aAAc87B,EAAOE,EAAO,CAC/Ex5B,YAAaxJ,EAAUqK,kBAAkBrK,EAAUsK,uBAAuB+G,IAC1ErN,UAAWA,GAEvB,CACA,SAASk/B,EAAoBl8B,EAAcm8B,EAASC,EAASpiC,GACzD,GAAImiC,IAAYC,EACZ,OAAO,EAEX,IAAIC,EAAiB,IAAI38B,IACzB,OAAOM,EAAauB,WAAWiS,MAAM,SAAUhS,GAC3C,GAAI66B,EAAe37B,IAAIc,GACnB,OAAO,EAEX,GADA66B,EAAej7B,IAAII,IACdxI,EAAUytB,cAAcjlB,EAAWxH,EAAQgD,WAC5C,OAAO,EACX,GAAIs/B,EAAiC96B,GACjC,OAAO,EACX,GAAIxI,EAAU6c,QAAQrU,GAAY,CAC9B,IAAI+6B,EAAYvjC,EAAU4I,uBAAuBJ,GAC7Cg7B,EAAeL,GAAWA,EAAQI,GAClCE,EAAeL,GAAWA,EAAQG,GAClC16B,EAAoBL,EAAUxB,aAClC,IAAK6B,EACD,OAAO3C,EAAes9B,EAAcC,GAExC,IAAIC,EAAgB/9B,MAAMC,QAAQ49B,GAC9BG,EAAgBh+B,MAAMC,QAAQ69B,GAClC,GAAIC,IAAkBC,EAClB,OAAO,EACX,GAAID,GAAiBC,EAAe,CAChC,IAAIC,EAAWJ,EAAa9+B,OAC5B,GAAI++B,EAAa/+B,SAAWk/B,EACxB,OAAO,EAEX,IAAK,IAAIz1B,EAAI,EAAGA,EAAIy1B,IAAYz1B,EAC5B,IAAK+0B,EAAoBr6B,EAAmB26B,EAAar1B,GAAIs1B,EAAat1B,GAAInN,GAC1E,OAAO,EAGf,OAAO,CACX,CACA,OAAOkiC,EAAoBr6B,EAAmB26B,EAAcC,EAAcziC,EAC9E,CAEI,IAAIuI,EAAWvJ,EAAUqZ,yBAAyB7Q,EAAWxH,EAAQwI,aACrE,OAAID,IACI+5B,EAAiC/5B,IAE9B25B,EAAoB35B,EAASvC,aACpCm8B,EAASC,EAASpiC,QAJtB,CAOR,EACJ,CACA,SAASsiC,EAAiC96B,GACtC,QAAUA,EAAUyP,YAAczP,EAAUyP,WAAWvD,KAAKmvB,EAChE,CACA,SAASA,EAAuBC,GAC5B,MAA0B,gBAAnBA,EAAI5gC,KAAKrD,KACpB,CAjFAD,EAAQ61B,mBAAgB,GACbA,EAQR71B,EAAQ61B,gBAAkB71B,EAAQ61B,cAAgB,CAAC,IAPpCA,EAAuB,QAAI,GAAK,UAC9CA,EAAcA,EAA4B,aAAI,GAAK,eACnDA,EAAcA,EAAyB,UAAI,GAAK,YAChDA,EAAcA,EAAuB,QAAI,GAAK,UAC9CA,EAAcA,EAAoB,KAAI,GAAK,OAC3CA,EAAcA,EAAqB,MAAI,GAAK,QAC5CA,EAAcA,EAAqB,MAAI,GAAK,QA2EhD,IAAI5yB,EAAsBjC,OAAOC,IAAI,uBACjCiC,EAAShD,EAAQgD,OACjBC,EAAO,IAAIP,EAASQ,KAIxB,SAAS6C,EAAiB3C,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,OAAOzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CACA,SAAS4rB,EAAkB5gB,EAASpN,EAAMiuB,EAAUC,QACzB,IAAnBA,IAA6BA,EAAiB,8BAClDnuB,EAAeC,EAAM,WACbA,KAAQoN,IACe,IAAvBjO,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAAK4uB,EAAUjuB,EAAMkuB,EAEpF,EACJ,CACA,SAASnuB,EAAeC,EAAMC,IAlB9B,SAAiBD,GACb,OAAOJ,EAAOD,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC3E,EAiBSI,CAAQJ,IACTC,GAER,CAEA,IAAIiX,EAAS1a,OAAO0a,OAAQ8hC,EAAmBx8C,OAAOkO,eAClDqlB,EAAoB,SAAUrc,GAE9B,SAASqc,EAAgBnxB,GACrB,IAAIgwB,EAAehwB,EAAGgwB,aAAcqqB,EAAYr6C,EAAGq6C,UAAW7rC,EAAUxO,EAAGwO,QACvEuG,EAAQxK,KACR+vC,EAAkBnpB,EAAgBopB,mBAAmBj5C,YACzDyT,EAAQD,EAAOvH,KAAKhD,KAAM,SAAUwI,GAChCgC,EAAMylC,oBACN,IACI,IAAIC,EAAc1nC,EAAS2nC,cAAcC,UACrCF,IAAgBA,EAAYxxC,QAC5BwxC,EAAYxxC,MAAQ2xC,EAE5B,CACA,MAAO56C,GAAM,CACb,IAAI66C,GAAS9lC,EAAMuN,UAAUhf,KAC7ByR,EAAMuN,UAAUhc,IAAIyM,GACpB,IAAI+nC,EAAO/lC,EAAM+lC,KAUjB,OATIA,GAAQA,EAAK7xC,MACb8J,EAAS9J,OAAS8J,EAAS9J,MAAM6xC,EAAK7xC,OAEjC6xC,GAAQA,EAAKxtC,QAClByF,EAAS9I,MAAQ8I,EAAS9I,KAAK8K,EAAMgmC,WAAWD,EAAKxtC,SAErDutC,GACA9lC,EAAM+c,YAAYvmB,MAAM,WAAc,GAEnC,WACCwJ,EAAMuN,UAAUtM,OAAOjD,KAAcgC,EAAMuN,UAAUhf,MACrDyR,EAAMimC,eAEd,CACJ,IAAMzwC,MACA+X,UAAY,IAAI1d,IACtBmQ,EAAMtS,cAAgB,IAAImC,IAC1BmQ,EAAM2xB,OAAQ,EACd3xB,EAAMylC,kBAAoB,WAKtB,OAJIF,IACAtqB,EAAsB,QAAE7sB,IAAI4R,EAAMkmC,QAASZ,GAC3CC,GAAkB,GAEfvlC,EAAMib,aAAakrB,iBAAiBnmC,EAAMkmC,QACrD,EACAlmC,EAAMslC,UAAYA,EAClBtlC,EAAMib,aAAeA,EACrBjb,EAAMomC,iBAAmBC,EAAiB5sC,EAAQukB,aAClDhe,EAAMsmC,YAAa,EACnBtmC,EAAMsd,gBAAkBtd,EAAMsd,gBAAgBnf,KAAK6B,GACnDA,EAAMgmC,WAAahmC,EAAMgmC,WAAW7nC,KAAK6B,GACzC,IAAIhP,EAAKiqB,EAAa8D,eAAe1C,WAA0C7qB,QAAlB,IAAPR,EAAgB,CAAC,EAAIA,GAAYgtB,YAAauoB,OAA4B,IAAP/0C,EAAgB,cAAgBA,EACrJC,EAAKgI,EAAQukB,YAAaA,OAAqB,IAAPvsB,EAAgB80C,EAAqB90C,EACjF+0C,EAAK/sC,EAAQwlB,mBACbA,OAA4B,IAAPunB,EAAgC,YAAhBxoB,EAA4BuoB,EAAqB,EAAgBC,EACtGxmC,EAAMvG,QAAUrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CACxDwlB,mBAAoBA,EACpBjB,YAAaA,IACjBhe,EAAMkmC,QAAUZ,EAAUY,SAAWjrB,EAAawrB,kBAClD,IAAIC,EAAQv9C,EAAUwK,uBAAuBqM,EAAMxF,OAEnD,OADAwF,EAAM2mC,UAAYD,GAASA,EAAMr6C,MAAQq6C,EAAMr6C,KAAKrD,MAC7CgX,CACX,CAumBA,OAlqBA5W,EAAM8W,UAAUkc,EAAiBrc,GA4DjClX,OAAOC,eAAeszB,EAAgBplB,UAAW,QAAS,CACtD3J,IAAK,WACD,OAAOmI,KAAKoxC,WAAapxC,KAAKiE,QAAQe,KAC1C,EACAnQ,YAAY,EACZE,cAAc,IAElB1B,OAAOC,eAAeszB,EAAgBplB,UAAW,YAAa,CAC1D3J,IAAK,WACD,OAAOmI,KAAKiE,QAAQtM,SACxB,EACA9C,YAAY,EACZE,cAAc,IAElB6xB,EAAgBplB,UAAUuB,OAAS,WAC/B,IAAIyH,EAAQxK,KAMZ,OAL2B,IAAvBhK,WAAWC,SACXW,EAAe,yBAA0B,YACd,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,GAEG,IAAIyJ,QAAQ,SAAUC,EAASC,GAClC,IAAI2I,EAAW,CACX9I,KAAM,SAAUqD,GACZnD,EAAQmD,GACRyH,EAAMuN,UAAUtM,OAAOjD,GAClBgC,EAAMuN,UAAUhf,MACjByR,EAAMib,aAAa4rB,YAAY7mC,EAAMkmC,SAEzCtjC,WAAW,WACP8b,EAAapQ,aACjB,EAAG,EACP,EACApa,MAAOmB,GAEPqpB,EAAe1e,EAAMuO,UAAUvQ,EACvC,EACJ,EACAoe,EAAgBplB,UAAUyyB,UAAY,WAClCj0B,KAAK8vC,UAAU7b,WACnB,EACArN,EAAgBplB,UAAU8vC,qBAAuB,SAAUC,GACvD,IAAI/mC,EAAQxK,UACa,IAArBuxC,IAA+BA,GAAmB,GACtD,IAAIC,EAAah4C,EAAiB,gBAAiB,WAC/C,OAAOgR,EAAMinC,eAAc,EAC/B,GACIzoB,EAAgBhpB,KAAK8vC,UAAU9mB,eAC9BwoB,GAAcA,EAAWxoB,eAC1Bz1B,EAAQ61B,cAAckB,MACtBvnB,EAASnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG27C,GAAa,CAAEtpB,QAAS0nB,EAAyB5mB,GAAgBA,cAAeA,IAC3HvzB,EAAKuK,KAAKiE,QAAQukB,YAAaA,OAAqB,IAAP/yB,EAAgB,cAAgBA,EACjF,GACAo7C,EAAiBroB,IACbxoB,KAAKylB,aAAaisB,gBAAgB1xC,KAAKgF,OAAO2sC,yBAC7C,GAAI3xC,KAAK4wC,iBACV5wC,KAAK8vC,UAAuB,kBAE3B,CACD,IAAI5kB,EAAOlrB,KAAK8vC,UAAUlb,WACtB1J,EAAK/gB,UAAYnK,KAAKiE,QAAQonB,qBAC9BtoB,EAAOrI,KAAOwwB,EAAKnoB,QAEnBigB,EAAMA,MAAMjgB,EAAOrI,KAAM,CAAC,KAC1BqI,EAAOrI,UAAO,GAEdwwB,EAAK/gB,iBACEpH,EAAOknB,SACViB,EAAK/gB,UACLpH,EAAOimB,gBAAkBz1B,EAAQ61B,cAAclB,SAC9B,gBAAhBM,GAAiD,eAAhBA,IAClCzlB,EAAOimB,cAAgBz1B,EAAQ61B,cAAckB,MAC7CvnB,EAAOmlB,SAAU,IAIrBnlB,EAAOknB,SAAU,EAEjBlnB,EAAOimB,gBAAkBz1B,EAAQ61B,cAAckB,QAC9CvnB,EAAOrE,OAASqE,EAAO1E,UACxB0E,EAAOimB,cAAgBz1B,EAAQ61B,cAAc1qB,QAEtB,IAAvB1I,WAAWC,SACVi1B,EAAK/gB,UACLnK,KAAKiE,QAAQsiB,gBACbxjB,EAAOmlB,SACPnlB,EAAOrI,MACPqI,EAAOrE,OACRkzC,EAAsB1mB,EAAKO,QAEnC,CAIA,OAHI8lB,GACAvxC,KAAK6xC,iBAAiB9uC,GAEnBA,CACX,EACA6jB,EAAgBplB,UAAUymB,iBAAmB,SAAUspB,GAEnD,YADyB,IAArBA,IAA+BA,GAAmB,GAC/CvxC,KAAKwwC,WAAWxwC,KAAKsxC,qBAAqBC,GACrD,EACA3qB,EAAgBplB,UAAUswC,0BAA4B,SAAUC,EAAWp6C,GACvE,IAAKqI,KAAKuwC,KACN,OAAO,EAEX,IAAIyB,EAAehyC,KAAKylB,aAAaisB,gBAAgB1xC,KAAKgF,OACtDyzB,EAAcz4B,KAAKylB,aAAagT,YAChCzzB,EAAQyzB,EAAcuZ,EAAaC,iBAAmBjyC,KAAKgF,MAI/D,OAHwByzB,GAAeuZ,EAAaE,yBAC/C1b,EAAaxxB,EAAOhF,KAAKuwC,KAAKxtC,OAAQgvC,EAAW/xC,KAAKrI,YACpDqrB,EAAMA,MAAMhjB,KAAKuwC,KAAKxtC,OAAQgvC,KACPp6C,IAAcqrB,EAAMA,MAAMhjB,KAAKuwC,KAAK54C,UAAWA,EACjF,EACAivB,EAAgBplB,UAAU2wC,QAAU,SAAUrsC,EAAKssC,GAC/C,IAAI7B,EAAOvwC,KAAKuwC,KAChB,GAAIA,GACAA,EAAKzqC,MACHssC,GAAsBpvB,EAAMA,MAAMutB,EAAK54C,UAAWqI,KAAKrI,YACzD,OAAO44C,EAAKzqC,EAEpB,EACA8gB,EAAgBplB,UAAUiwC,cAAgB,SAAUW,GAMhD,OAL2B,IAAvBp8C,WAAWC,SACXW,EAAe,gBAAiB,YACL,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,GAEG8J,KAAKmyC,QAAQ,SAAUC,EAClC,EACAxrB,EAAgBplB,UAAU6wC,aAAe,SAAUD,GAM/C,OAL2B,IAAvBp8C,WAAWC,SACXW,EAAe,eAAgB,YACJ,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,GAEG8J,KAAKmyC,QAAQ,QAASC,EACjC,EACAxrB,EAAgBplB,UAAUwyB,iBAAmB,YACd,IAAvBh+B,WAAWC,SACXW,EAAe,mBAAoB,YACR,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,UAEG8J,KAAKuwC,KACZvwC,KAAK8wC,YAAa,CACtB,EACAlqB,EAAgBplB,UAAU8wC,sBAAwB,YACnB,IAAvBt8C,WAAWC,UACY,IAAvBD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAE3D8J,KAAKylB,aAAa8sB,YAAYvyC,KAAK0wC,QACvC,EACA9pB,EAAgBplB,UAAUimB,QAAU,SAAU9vB,GAC1C,IAAIlC,EACA+8C,EAAmB,CACnBC,aAAc,GAEdjqB,EAAcxoB,KAAKiE,QAAQukB,YAO/B,GALIgqB,EAAiBhqB,YADD,aAAhBA,EAC+B,WAGA,gBAER,IAAvBxyB,WAAWC,SAAqB0B,GAAak4C,EAAiB7sC,KAAKrL,EAAW,aAAc,CAC5F,IAAIulB,EAAWvpB,EAAUspB,mBAAmBjd,KAAKgF,OAC7C69B,EAAO3lB,EAASxkB,oBACfmqC,GAASA,EAAKx6B,KAAK,SAAUqqC,GAAK,MAAiC,cAA1BA,EAAEv9B,SAASte,KAAKrD,KAAuB,KAC1D,IAAvBwC,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAC9C,GACAyB,GAC0B,QAAxBlC,EAAKynB,EAASrmB,YAAyB,IAAPpB,OAAgB,EAASA,EAAGjC,QAAU0pB,EAGpF,CAKA,OAJIvlB,IAAcqrB,EAAMA,MAAMhjB,KAAKiE,QAAQtM,UAAWA,KAClD66C,EAAiB76C,UAAYqI,KAAKiE,QAAQtM,UAAY/D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKiE,QAAQtM,WAAYA,IAErHqI,KAAK8vC,UAAU6C,iBACR3yC,KAAKunB,UAAUirB,EAAkBj/C,EAAQ61B,cAAc3B,QAClE,EACAb,EAAgBplB,UAAUkmB,UAAY,SAAUkrB,GAC5C,IAAIpoC,EAAQxK,KACR6yC,EAAkBj/C,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAI+8C,EAAiB5tC,MAAQ4tC,EAAoBh/C,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKiE,SAAU,CAAEe,MAAOhF,KAAKiE,QAAQe,QAAU4tC,GAAmB,CAAEj7C,UAAW/D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKiE,QAAQtM,WAAYi7C,EAAiBj7C,cAAkB,CAC/U6wB,YAAa,aACjBqqB,EAAgB7tC,MAAQhF,KAAKwR,kBAAkBqhC,EAAgB7tC,OAC/D,IAAI8tC,EAAM9yC,KAAKylB,aAAawrB,kBAC5BjxC,KAAKoxC,UACDwB,EAAiB5tC,MACbhF,KAAKwR,kBAAkBxR,KAAKiE,QAAQe,OAClC6tC,EAAgB7tC,MAC1B,IAAI8qC,EAAY9vC,KAAK8vC,UACjBiD,EAAwBjD,EAAU9mB,cACtC8mB,EAAU9mB,cAAgBz1B,EAAQ61B,cAAc1B,UAC5CmrB,EAAgB/lB,6BAChB9sB,KAAKgzC,UAET,IAAIC,EAAkB,IAAI54C,IACtBstB,EAAmC,OAArBirB,QAAkD,IAArBA,OAA8B,EAASA,EAAiBjrB,YACnGurB,EAAwC,aAA7BlzC,KAAKiE,QAAQukB,YAI5B,OAHK0qB,GACDz/C,EAAQiB,UAAUizB,EAAa,IAE5B3nB,KAAKylB,aACP0tB,WAAWL,EAAKD,EAAiBt/C,EAAQ61B,cAAc1B,WACvD3mB,KAAK,SAAUqyC,GAKhB,GAJA5oC,EAAMib,aAAa4rB,YAAYyB,GAC3BhD,EAAU9mB,gBAAkBz1B,EAAQ61B,cAAc1B,YAClDooB,EAAU9mB,cAAgB+pB,GAE1BG,EACA1oC,EAAMib,aAAanvB,MAAMuhC,MAAM,CAC3BvG,OAAQ,SAAUh7B,GACd,IAAIqxB,EAAcirB,EAAiBjrB,YAC/BA,EACArxB,EAAMqxB,YAAY,CACd3iB,MAAOwF,EAAMxF,MACbrN,UAAW6S,EAAM7S,UACjB0zB,mBAAmB,EACnBF,YAAY,GACb,SAAU9a,GACT,OAAOsX,EAAYtX,EAAU,CACzB+iC,gBAAiBA,EAAgB14C,KACjC/C,UAAWk7C,EAAgBl7C,WAEnC,GAGArB,EAAMyiC,WAAW,CACb/zB,MAAO6tC,EAAgB7tC,MACvBrN,UAAWk7C,EAAgBl7C,UAC3B+C,KAAM04C,EAAgB14C,MAGlC,EACA4zC,eAAgB,SAAU1V,GACtBqa,EAAgBl3C,IAAI68B,EAAM5zB,MAC9B,QAGH,CACD,IAAIwsC,EAAahnC,EAAM2nC,QAAQ,UAC3Bz3C,EAAOitB,EAAY6pB,EAAW92C,KAAM,CACpC04C,gBAAiBA,EAAgB14C,KACjC/C,UAAWk7C,EAAgBl7C,YAE/B6S,EAAM6oC,aAAaz/C,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG27C,GAAa,CAAExoB,cAAe+pB,EAAuB7qB,QAAS0nB,EAAyBmD,GAAwBr4C,KAAMA,IAAS8P,EAAM7S,UAC7L,CACA,OAAO6S,EAAMgmC,WAAW4C,EAC5B,GACKE,QAAQ,WACLJ,IAAaD,EAAgB53C,IAAImP,EAAMxF,QACvCwF,EAAM+oC,qBAEd,EACJ,EACA3sB,EAAgBplB,UAAUsmB,gBAAkB,SAAU7jB,GAClD,IAAIuG,EAAQxK,KACRkpB,EAAelpB,KAAKylB,aACnB+tB,yBAAyB,CAC1BxuC,MAAOf,EAAQzM,SACfG,UAAWsM,EAAQtM,UACnBhD,QAASsP,EAAQtP,UAEhBokB,UAAU,CACXrZ,KAAM,SAAUgzB,GACZ,IAAI/K,EAAc1jB,EAAQ0jB,YACtBA,GACAnd,EAAMmd,YAAY,SAAUtX,EAAUojC,GAClC,OAAO9rB,EAAYtX,EAAUzc,EAAMiC,SAAS,CAAE68B,iBAAkBA,GAAoB+gB,GACxF,EAER,EACA/0C,MAAO,SAAUQ,GACT+E,EAAQhF,QACRgF,EAAQhF,QAAQC,IAGG,IAAvBlJ,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAM,GAAIQ,EAChE,IAGJ,OADAc,KAAK9H,cAAc6D,IAAImtB,GAChB,WACC1e,EAAMtS,cAAcuT,OAAOyd,IAC3BA,EAAapQ,aAErB,CACJ,EACA8N,EAAgBplB,UAAUkyC,WAAa,SAAUC,GAO7C,OAN2B,IAAvB39C,WAAWC,UACX4uB,EAAkB8uB,EAAY,kBAAmB,cACjD/8C,EAAe,aAAc,YACF,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,IAEG8J,KAAKunB,UAAUosB,EAC1B,EACA/sB,EAAgBplB,UAAUuyB,iBAAmB,SAAU4f,GACnD,IAAIC,EAAgBjgD,EAAUumB,QAAQla,KAAKiE,QAAS0vC,GAAc,CAAC,GACnE5lC,EAAO/N,KAAKiE,QAAS2vC,EACzB,EACAhtB,EAAgBplB,UAAUqyC,aAAe,SAAUl8C,GAC/C,IAAI6S,EAAQxK,KACZ,OAAIgjB,EAAMA,MAAMhjB,KAAKrI,UAAWA,GACrBqI,KAAK+X,UAAUhf,KAClBS,EAAiB,yBAA0B,WAAc,OAAOgR,EAAMzH,QAAU,GAC9EpD,QAAQC,WAElBI,KAAKiE,QAAQtM,UAAYA,EACpBqI,KAAK+X,UAAUhf,KAGbiH,KAAKunB,UAAU,CAClBiB,YAAaxoB,KAAKiE,QAAQwlB,mBAC1B9xB,UAAWA,GACZpE,EAAQ61B,cAAcyqB,cALdl0C,QAAQC,UAMvB,EACAgnB,EAAgBplB,UAAUmmB,YAAc,SAAUrM,GAC9C,IAAImK,EAAezlB,KAAKylB,aACpBhwB,EAAKgwB,EAAanvB,MAAM40B,KAAK,CAC7BlmB,MAAOhF,KAAKiE,QAAQe,MACpBrN,UAAWqI,KAAKrI,UAChB0zB,mBAAmB,EACnBF,YAAY,IACZpoB,EAAStN,EAAGsN,OAAQoH,EAAW1U,EAAG0U,SAClC4nC,EAAYz2B,EAAMvY,EAAQ,CAC1BpL,UAAWqI,KAAKrI,UAChBwS,WAAYA,EACZ6c,aAAcjkB,IAEdgvC,IACAtsB,EAAanvB,MAAMyiC,WAAW,CAC1B/zB,MAAOhF,KAAKiE,QAAQe,MACpBtK,KAAMq3C,EACNp6C,UAAWqI,KAAKrI,YAEpB8tB,EAAaquB,mBAErB,EACAltB,EAAgBplB,UAAUomB,aAAe,SAAU6qB,GAC/CzyC,KAAKiE,QAAQwuC,aAAeA,EAC5BzyC,KAAK+zC,eACT,EACAntB,EAAgBplB,UAAUqmB,YAAc,WACpC7nB,KAAKiE,QAAQwuC,aAAe,EAC5BzyC,KAAK+zC,eACT,EACAntB,EAAgBplB,UAAUwyC,qBAAuB,SAAU96B,EAC3DjV,GACI,GAAIA,EAAQ8oB,gBAAiB,CACzB,IAAIt3B,EAAKwO,EAAQukB,YAAaA,OAAqB,IAAP/yB,EAAgB,cAAgBA,EAAI+F,EAAKyI,EAAQwlB,mBAAoBA,OAA4B,IAAPjuB,EAAgBgtB,EAAchtB,EAChJ,YAAhBgtB,IACwC,oBAA5BvkB,EAAQ8oB,gBACpB9oB,EAAQukB,YAAcvkB,EAAQ8oB,gBAAgBvE,EAAa,CACvDtP,OAAQA,EACRjV,QAASA,EACToX,WAAYrb,KACZypB,mBAAoBA,IAIxBxlB,EAAQukB,YADQ,sBAAXtP,EACiBuQ,EAGAxlB,EAAQ8oB,gBAEtC,CACA,OAAO9oB,EAAQukB,WACnB,EACA5B,EAAgBplB,UAAU4D,MAAQ,SAAUnB,EAASgwC,EAAkBjvC,GACnE,IAAI8qC,EAAY9vC,KAAKiwC,oBAErB,OADAH,EAAUoE,mBAAmBl0C,MACtBA,KAAKylB,aAAmC,qBAAEqqB,EAAW7rC,EAASgwC,EAAkBjvC,EAC3F,EACA4hB,EAAgBplB,UAAUuyC,cAAgB,WACtC,IAAIvpC,EAAQxK,KACZ,IAAIA,KAAKylB,aAAa0uB,QAAtB,CAGA,IAAeC,EAANp0C,KAAuBo0C,YAAa3B,EAApCzyC,KAAsDiE,QAAQwuC,aACvE,GAAKA,GAAiBzyC,KAAKq0C,gBAO3B,IAAID,GAAeA,EAAYE,WAAa7B,EAA5C,CAGAh/C,EAAQiB,UAAU+9C,EAAc,KACrB2B,IAAgBp0C,KAAKo0C,YAAc,CAAC,IAC1CE,SAAW7B,EAChB,IAAI8B,EAAa,WACb,IAAI9+C,EAAI+F,EACJgP,EAAM4pC,cACDxE,EAAyBplC,EAAMslC,UAAU9mB,iBACQ,QAA/CxtB,GAAM/F,EAAK+U,EAAMvG,SAASuwC,uBAAoC,IAAPh5C,OAAgB,EAASA,EAAGwH,KAAKvN,IAQ3Fg/C,IAPAjqC,EAAM+c,UAAU,CACZiB,YAAkD,aAArChe,EAAMvG,QAAQwlB,mBACvB,WACE,gBACPl2B,EAAQ61B,cAAcqrB,MAAM1zC,KAAK0zC,EAAMA,GAMtD,EACIA,EAAO,WACP,IAAI7R,EAAOp4B,EAAM4pC,YACbxR,IACApX,aAAaoX,EAAK8R,SAClB9R,EAAK8R,QAAUtnC,WAAWmnC,EAAY3R,EAAK0R,UAEnD,EACAG,GA3BA,OARQL,IACA5oB,aAAa4oB,EAAYM,gBAClB10C,KAAKo0C,YALpB,CAuCJ,EACAxtB,EAAgBplB,UAAUqwC,iBAAmB,SAAUE,EAAWp6C,GAC9D,IAAI6S,EAAQxK,UACM,IAAdrI,IAAwBA,EAAYqI,KAAKrI,WAC7C,IAAI+G,EAAQlF,EAAiB,eAAgB,WACzC,OAAOgR,EAAM6nC,cACjB,GAIA,OAHI3zC,GAASsB,KAAKuwC,OAASvtB,EAAMA,MAAMrrB,EAAWqI,KAAKuwC,KAAK54C,aACxD+G,OAAQ,GAEJsB,KAAKuwC,KAAO38C,EAAMiC,SAAS,CAAEkN,OAAQ/C,KAAKylB,aAAakS,uBACvDoa,EACEp+C,EAAUooB,UAAUg2B,GAAYp6C,UAAWA,GAAc+G,EAAQ,CAAEA,MAAOA,GAAU,KAClG,EACAkoB,EAAgBplB,UAAUquB,mBAAqB,SAAU8jB,EAAYM,GACjE,IAAIzpC,EAAQxK,KACZA,KAAK8wC,YAAa,EAClB,IAAI6D,EACJV,IAAqB1gD,EAAQ61B,cAAc3B,SACvCwsB,IAAqB1gD,EAAQ61B,cAAc1B,WAC3CusB,IAAqB1gD,EAAQ61B,cAAcqrB,KAC3CG,EAAe50C,KAAKiE,QAAQtM,UAC5Bk9C,EAAiB70C,KAAKiE,QAAQukB,YAC9BorB,EAAgBjgD,EAAUumB,QAAQla,KAAKiE,QAAS0vC,GAAc,CAAC,GAC/D1vC,EAAU0wC,EACVf,EACE7lC,EAAO/N,KAAKiE,QAAS2vC,GACvB5uC,EAAQhF,KAAKwR,kBAAkBvN,EAAQe,OAC3ChF,KAAKoxC,UAAYpsC,EACZ2vC,IACD30C,KAAK+zC,iBACDJ,IACAA,EAAWh8C,WACVqrB,EAAMA,MAAM2wB,EAAWh8C,UAAWi9C,IACX,YAAxB3wC,EAAQukB,aACPvkB,EAAQukB,cAAgBqsB,GACc,oBAA5B5wC,EAAQ8oB,kBACnB/sB,KAAKg0C,qBAAqB,oBAAqB/vC,QACtB,IAArBgwC,IACAA,EAAmB1gD,EAAQ61B,cAAcyqB,gBAIrD7zC,KAAK4wC,mBAAqB5wC,KAAK4wC,iBAAmBC,EAAiB5sC,EAAQukB,cAC3E,IAAIssB,EAA4B,WACxBtqC,EAAMolB,UAAYA,IAClBplB,EAAMomC,kBAAmB,EAEjC,EACIj5C,EAAYsM,EAAQtM,WAAa/D,EAAMiC,SAAS,CAAC,EAAGoO,EAAQtM,WAC5DlC,EAAKuK,KAAKoF,MAAMnB,EAASgwC,EAAkBjvC,GAAQ4qB,EAAUn6B,EAAGm6B,QAASmlB,EAAWt/C,EAAGs/C,SACvFvsC,EAAW,CACX9I,KAAM,SAAUqD,GACRigB,EAAMA,MAAMxY,EAAM7S,UAAWA,KAC7Bm9C,IACAtqC,EAAM6oC,aAAatwC,EAAQpL,GAEnC,EACA+G,MAAO,SAAUA,GACTskB,EAAMA,MAAMxY,EAAM7S,UAAWA,KACxB0G,EAAO22C,cAAct2C,KACtBA,EAAQ,IAAIL,EAAO2rB,YAAY,CAAEirB,aAAcv2C,KAEnDo2C,IACAtqC,EAAM0qC,YAAYx2C,EAAO/G,GAEjC,GAUJ,OARKg9C,IAAyBI,GAAa/0C,KAAK4vB,UACxC5vB,KAAK4vB,SAAW5vB,KAAKwI,UACrBxI,KAAK4vB,QAAQnX,eAAezY,KAAKwI,UAErCxI,KAAK4vB,QAAUA,EACf5vB,KAAKwI,SAAWA,GAEpBonB,EAAQpX,YAAYhQ,GACbonB,CACX,EACAhJ,EAAgBplB,UAAU+lB,UAAY,SAAUosB,EAAYM,GACxD,OAAOtgD,EAAUurB,0BAA0Blf,KAAK6vB,mBAAmB8jB,EAAYM,GAAkBpzC,QAAQE,KAAKf,KAAKwwC,YACvH,EACA5pB,EAAgBplB,UAAU2nB,sBAAwB,WAG9C,IAFA,IAAI3e,EAAQxK,KACR/G,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,GAAMe,UAAUf,GAEzB,IAAIo4C,EAAOvwC,KAAKuwC,KAChB/2C,EAAiB,mBAAoB,WAAc,OAAOgR,EAAMwpB,kBAAoB,GACpF,IAAI9K,EAAelpB,KAAK+Y,UAAU3f,MAAM4G,KAAM/G,GAE9C,OADA+G,KAAKuwC,KAAOA,EACLrnB,CACX,EACAtC,EAAgBplB,UAAUwxC,QAAU,WAChChzC,KAAKqzC,aACLrzC,KAAKsxC,sBAAqB,GAAQtxC,KAAKrI,UAC3C,EACAivB,EAAgBplB,UAAU6xC,aAAe,SAAUtwC,EAAQpL,GACvD,IAAI6S,EAAQxK,KACRm1C,EAAY37C,EAAiB,eAAgB,WAC7C,OAAOgR,EAAM6nC,cACjB,GACI+C,EAAcp1C,KAAK8xC,0BAA0B/uC,EAAQpL,IACrDw9C,IAAcpyC,EAAOknB,SAAWjqB,KAAKiE,QAAQonB,oBAC7CrrB,KAAK6xC,iBAAiB9uC,EAAQpL,IAE9Bw9C,GAAaC,IACbzhD,EAAUmkB,uBAAuB9X,KAAK+X,UAAW,OAAQ/X,KAAKwwC,WAAWztC,GAEjF,EACA6jB,EAAgBplB,UAAU0zC,YAAc,SAAUx2C,EAAO/G,GACrD,IAAI6S,EAAQxK,KACRq1C,EAAczhD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2D,EAAiB,gBAAiB,WAAc,OAAOgR,EAAMinC,eAAiB,IAAK,CAAE/yC,MAAOA,EAAOL,OAAQK,EAAMqb,cAAeiP,cAAez1B,EAAQ61B,cAAc1qB,MAAOwpB,SAAS,IACzOloB,KAAK6xC,iBAAiBwD,EAAa19C,GACnChE,EAAUmkB,uBAAuB9X,KAAK+X,UAAW,QAAU/X,KAAKuwC,KAAK7xC,MAAQA,EACjF,EACAkoB,EAAgBplB,UAAU6yC,aAAe,WACrC,OAAOr0C,KAAK+X,UAAUhf,KAAO,CACjC,EACA6tB,EAAgBplB,UAAUivC,cAAgB,WAClCzwC,KAAK8wC,aAEL9wC,KAAK4vB,SAAW5vB,KAAKwI,WACrBxI,KAAK4vB,QAAQnX,eAAezY,KAAKwI,iBAC1BxI,KAAK4vB,eACL5vB,KAAKwI,UAEhBxI,KAAK6nB,cACL7nB,KAAK9H,cAAckH,QAAQ,SAAUuZ,GAAO,OAAOA,EAAIG,aAAe,GACtE9Y,KAAK9H,cAAcmlC,QACnBr9B,KAAKylB,aAAa6vB,UAAUt1C,KAAK0wC,SACjC1wC,KAAK+X,UAAUslB,QACfr9B,KAAK8wC,YAAa,EACtB,EACAlqB,EAAgBplB,UAAUgQ,kBAAoB,SAAUha,GACpD,OAAOwI,KAAKylB,aAAavU,UAAU1Z,EACvC,EACAovB,EAAgBplB,UAAUgvC,WAAa,SAAUztC,GAC7C,OAAOA,GAAU,SAAUA,EAASnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAAS,CAAErI,KAAMsF,KAAKylB,aAAavnB,cAAc,CAC/G1G,SAAUwI,KAAKgF,MACftK,KAAMqI,EAAOrI,KACb8tB,YAAaxoB,KAAKiE,QAAQukB,YAC1BlK,GAAIte,KAAK0wC,YACL3tC,CAChB,EACA6jB,EAAgBplB,UAAU+zC,mBAAqB,WAC3Cv1C,KAAKw1C,sBACLx1C,KAAKm8B,OAAQ,CACjB,EACAvV,EAAgBplB,UAAUg0C,oBAAsB,WACxCx1C,KAAKy1C,gBACLjqB,aAAaxrB,KAAKy1C,eAClBz1C,KAAKy1C,mBAAgB,EAE7B,EACA7uB,EAAgBplB,UAAUk0C,eAAiB,WACvC,IAAIlrC,EAAQxK,KACRA,KAAKm8B,QAETn8B,KAAKm8B,OAAQ,EACRn8B,KAAKy1C,gBACNz1C,KAAKy1C,cAAgBroC,WAAW,WAAc,OAAO5C,EAAMqO,QAAU,EAAG,IAEhF,EACA+N,EAAgBplB,UAAUqX,OAAS,YAC/B7Y,KAAKw1C,sBACDx1C,KAAKm8B,SAC2B,cAA5Bn8B,KAAKiE,QAAQukB,aACe,qBAA5BxoB,KAAKiE,QAAQukB,aACZonB,EAAyB5vC,KAAK8vC,UAAU9mB,iBAC9BhpB,KAAK8vC,UAAUlb,UACjBga,0BACL5uC,KAAKgzC,UAGLhzC,KAAKuzC,wBAIjBvzC,KAAKm8B,OAAQ,CACjB,EACAvV,EAAgBplB,UAAU+xC,oBAAsB,WAC5C,IAAI99C,EAAKuK,KAAKiE,QAASukB,EAAc/yB,EAAG+yB,YAAauE,EAAkBt3B,EAAGs3B,gBAC1E,MAAoB,sBAAhBvE,GAAuD,iBAAhBA,EAChCxoB,KAAKunB,UAAU,CAClBiB,YAAa,cACbuE,gBAAiB,SAAUoH,EAAoBx/B,GAE3C,OADAqL,KAAK+sB,gBAAkBA,EACa,oBAAzB/sB,KAAK+sB,gBACL/sB,KAAK+sB,gBAAgBoH,EAAoBx/B,GAE7C6zB,CACX,IAGDxoB,KAAKunB,WAChB,EACAX,EAAgBopB,mBAAqB,IAAI75C,EAASQ,KAC3CiwB,CACX,CApqBuB,CAoqBrBjzB,EAAU4U,YAEZ,SAAS8nC,EAAyC3xC,IACvB,IAAvB1I,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAM,GAAIA,EAAM+E,QAAS/E,EAAMi3C,MACrF,CACA,SAAS/D,EAAsBnmB,IACA,IAAvBz1B,WAAWC,SAAqBw1B,IACT,IAAvBz1B,WAAWC,SAAqBxC,EAAQiB,UAAUguB,MAAM,GAAI+I,EAEpE,CACA,SAASolB,EAAiBroB,GACtB,MAAwB,iBAAhBA,GACY,aAAhBA,GACgB,YAAhBA,CACR,CAbA70B,EAAUwkB,sBAAsByO,GAehC,IAAIgvB,EAA0B,IAAKjiD,EAAUoG,cAAgBC,QAAUC,KACvE,SAAS47C,EAA2Bv/C,EAAOw/C,GACvC,IAAIxV,EAAWhqC,EAAMw/C,GACG,oBAAbxV,IACPhqC,EAAMw/C,GAAc,WAGhB,OAFAF,EAAwBh9C,IAAItC,GAC3Bs/C,EAAwB/9C,IAAIvB,GAAS,GAAK,MACpCgqC,EAASlnC,MAAM4G,KAAM9G,UAChC,EAER,CACA,IAAI68C,EAAc,WACd,SAASA,EAAUtwB,EAAcirB,QACb,IAAZA,IAAsBA,EAAUjrB,EAAawrB,mBACjDjxC,KAAK0wC,QAAUA,EACf1wC,KAAKxI,SAAW,KAChBwI,KAAKg2C,cAAgB,EACrBh2C,KAAKi2C,SAAU,EACfj2C,KAAKk2C,gBAAkB,KACvB,IAAI5/C,EAAS0J,KAAK1J,MAAQmvB,EAAanvB,MAClCs/C,EAAwBv6C,IAAI/E,KAC7Bs/C,EAAwBh9C,IAAItC,EAAO,GACnCu/C,EAA2Bv/C,EAAO,SAClCu/C,EAA2Bv/C,EAAO,UAClCu/C,EAA2Bv/C,EAAO,SAE1C,CA2MA,OA1MAy/C,EAAUv0C,UAAU6rC,KAAO,SAAUroC,GACjC,IAAIgkB,EAAgBhkB,EAAMgkB,eAAiBz1B,EAAQ61B,cAAclB,QAuBjE,OAtBIloB,KAAKrI,WACLqI,KAAKgpB,gBAAkBz1B,EAAQ61B,cAAclB,UAC5ClF,EAAMA,MAAMhjB,KAAKrI,UAAWqN,EAAMrN,aACnCqxB,EAAgBz1B,EAAQ61B,cAAcyqB,cAErC7wB,EAAMA,MAAMhe,EAAMrN,UAAWqI,KAAKrI,aACnCqI,KAAK2uC,cAAW,EAChB3uC,KAAKiZ,UAET5lB,OAAO0a,OAAO/N,KAAM,CAChBxI,SAAUwN,EAAMxN,SAChBG,UAAWqN,EAAMrN,UACjBs9C,aAAc,KACdl7B,cAAe/Z,KAAK+Z,eAAiB,GACrCiP,cAAeA,IAEfhkB,EAAMkxC,iBACNl2C,KAAKk0C,mBAAmBlvC,EAAMkxC,iBAE9BlxC,EAAMgxC,gBACNh2C,KAAKg2C,cAAgBhxC,EAAMgxC,eAExBh2C,IACX,EACA+1C,EAAUv0C,UAAUyyB,UAAY,WAC5Bj0B,KAAK2uC,cAAW,CACpB,EACAoH,EAAUv0C,UAAUozB,QAAU,WAC1B,IAAIpqB,EAAQxK,KACRiE,EAAUjE,KAAKm2C,iBACnB,GAAIn2C,KAAK2uC,UAAY3rB,EAAMA,MAAM/e,EAASjE,KAAK2uC,SAAS1qC,SACpD,OAAOjE,KAAK2uC,SAASzjB,KAEzBlrB,KAAKo2C,YAAYp2C,KAAKrI,WACtB,IAAI0+C,EAAKr2C,KAAKk2C,gBACd,GAAIG,GAAiC,aAA3BA,EAAGpyC,QAAQukB,YACjB,MAAO,CAAEre,UAAU,GAEvB,IAAI+gB,EAAO1xB,EAAiB,kBAAmB,WAC3C,OAAOgR,EAAMlU,MAAM40B,KAAKjnB,EAC5B,GAEA,OADAjE,KAAKs2C,eAAeprB,EAAMjnB,GACnBinB,CACX,EACA6qB,EAAUv0C,UAAU80C,eAAiB,SAAUprB,EAAMjnB,GACjDjE,KAAK2uC,SACDzjB,EACI,CACIA,KAAMA,EACNjnB,QAASA,GAAWjE,KAAKm2C,uBAE3B,CACd,EACAJ,EAAUv0C,UAAU20C,eAAiB,SAAUx+C,GAC3C,IAAIlC,EAEJ,YADkB,IAAdkC,IAAwBA,EAAYqI,KAAKrI,WACtC,CACHqN,MAAOhF,KAAKxI,SACZG,UAAWA,EACX0zB,mBAAmB,EACnBF,YAAY,EACZkJ,gBAAiD,QAA/B5+B,EAAKuK,KAAKk2C,uBAAoC,IAAPzgD,OAAgB,EAASA,EAAGwO,QAAQowB,gBAErG,EACA0hB,EAAUv0C,UAAU+0C,QAAU,SAAUrrB,GACpC,IACIz1B,EADA+U,EAAQxK,KAERw2C,EAAUx2C,KAAK2uC,UAAY3uC,KAAK2uC,SAASzjB,KACzCA,IACCA,EAAK/gB,UACN3Q,EAAiB,eAAgB,WAAc,IAAI/D,EAAI,OAAwC,QAAhCA,EAAK+U,EAAM0rC,uBAAoC,IAAPzgD,OAAgB,EAASA,EAAG48C,cAAgB,KAGvJryC,KAAKs2C,eAAeprB,GACflI,EAAMA,MAAMwzB,GAAWA,EAAQzzC,OAAQmoB,GAAQA,EAAKnoB,SACrB,QAA/BtN,EAAKuK,KAAKk2C,uBAAoC,IAAPzgD,GAAyBA,EAAmB,iBAE5F,EACAsgD,EAAUv0C,UAAU0yC,mBAAqB,SAAUmC,GAC3CA,IAAOr2C,KAAKk2C,kBAEhBl2C,KAAKk2C,gBAAkBG,EACnBA,IACAA,EAAc,UAAIr2C,MAE1B,EACA+1C,EAAUv0C,UAAUi1C,KAAO,WACvB,IAAIhhD,EACJ,IAAKuK,KAAKi2C,QAAS,CACfj2C,KAAKi2C,SAAU,EACiB,QAA/BxgD,EAAKuK,KAAKk2C,uBAAoC,IAAPzgD,GAAyBA,EAAuB,qBACxFuK,KAAKiZ,SACL,IAAIo9B,EAAKr2C,KAAKk2C,gBACVG,GACAA,EAAGxuB,aACX,CACJ,EACAkuB,EAAUv0C,UAAUyX,OAAS,WACzB,IAAIxjB,EACwB,QAA3BA,EAAKuK,KAAK02C,mBAAgC,IAAPjhD,GAAyBA,EAAGuN,KAAKhD,MACrEA,KAAK02C,iBAAc,CACvB,EACAX,EAAUv0C,UAAU40C,YAAc,SAAUz+C,GACxC,IAAI6S,EAAQxK,UACM,IAAdrI,IAAwBA,EAAYqI,KAAKrI,WAC7C,IAAI0+C,EAAKr2C,KAAKk2C,gBACd,IAAIG,GAAiC,aAA3BA,EAAGpyC,QAAQukB,YAArB,CAGA,IAAImuB,EAAe/iD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKm2C,eAAex+C,IAAa,CAAEi/C,QAAS52C,KAAM0Z,SAAU,SAAUwR,GAAQ,OAAO1gB,EAAM+rC,QAAQrrB,EAAO,IAC1JlrB,KAAK62C,WAAc7zB,EAAMA,MAAM2zB,EAAc32C,KAAK62C,aACnD72C,KAAKiZ,SACLjZ,KAAK02C,YAAc12C,KAAK1J,MAAMsiC,MAAO54B,KAAK62C,UAAYF,GAJ1D,CAMJ,EACAZ,EAAUv0C,UAAUmxC,eAAiB,WACjC3yC,KAAK82C,eAAY,CACrB,EACAf,EAAUv0C,UAAUu1C,YAAc,SAAUh0C,EAAQpL,GAChD,IAAIm/C,EAAY92C,KAAK82C,UACrB,QAASA,GACLA,EAAUE,UAAYpB,EAAwB/9C,IAAImI,KAAK1J,QACvD0sB,EAAMA,MAAMrrB,EAAWm/C,EAAUn/C,YACjCqrB,EAAMA,MAAMjgB,EAAOrI,KAAMo8C,EAAU/zC,OAAOrI,MAClD,EACAq7C,EAAUv0C,UAAUy1C,WAAa,SAAUl0C,EAAQvL,EAAUyM,EAASizC,GAClE,IACIzhD,EADA+U,EAAQxK,KAERkW,EAAS,IAAIviB,EAAUwiB,WACvB4D,EAAgBpmB,EAAUue,gBAAgBnP,EAAO1E,QAAU0E,EAAO1E,OAAOc,MAAM,GAAK,GAExF,GADgC,QAA/B1J,EAAKuK,KAAKk2C,uBAAoC,IAAPzgD,GAAyBA,EAAuB,qBACpF,gBAAiBsN,GAAUpP,EAAUue,gBAAgBnP,EAAOiX,aAAc,CAC1E,IAAI0E,EAAa/qB,EAAU6qB,qBAAqBxe,KAAK40B,UAAU7xB,OAAQA,GACvEA,EAAOrI,KAAOgkB,CAClB,MACK,GAAI,YAAa3b,GAAUA,EAAOkH,QAAS,CAC5C,IAAIihB,EAAOlrB,KAAK40B,UAChB7xB,EAAOrI,KAAOwb,EAAOE,MAAM8U,EAAKnoB,OAAQA,EAAOrI,KACnD,CACAsF,KAAK+Z,cAAgBA,EACO,aAAxB9V,EAAQukB,YACRxoB,KAAKs2C,eAAe,CAAEvzC,OAAQA,EAAOrI,KAAMyP,UAAU,GAAQnK,KAAKm2C,eAAelyC,EAAQtM,YAE7D,IAAvBu/C,IACDC,EAAkBp0C,EAAQkB,EAAQ6tB,aAClC9xB,KAAK1J,MAAM0hC,mBAAmB,SAAU1hC,GACpC,GAAIkU,EAAMusC,YAAYh0C,EAAQkB,EAAQtM,WAClCrB,EAAMyiC,WAAW,CACb/zB,MAAOxN,EACPkD,KAAMqI,EAAOrI,KACb/C,UAAWsM,EAAQtM,UACnBuxC,UAAkC,IAAvBgO,IAEf1sC,EAAMssC,UAAY,CACd/zC,OAAQA,EACRpL,UAAWsM,EAAQtM,UACnBq/C,QAASpB,EAAwB/9C,IAAI2S,EAAMlU,aAI/C,GAAIkU,EAAMmkC,UAAYnkC,EAAMmkC,SAASzjB,KAAK/gB,SAEtC,YADApH,EAAOrI,KAAO8P,EAAMmkC,SAASzjB,KAAKnoB,QAI1C,IAAI41B,EAAcnuB,EAAM2rC,eAAelyC,EAAQtM,WAC3CuzB,EAAO1xB,EAAiB,kBAAmB,WAC3C,OAAOlD,EAAM40B,KAAKyN,EACtB,IACKnuB,EAAMyrC,SAAWjzB,EAAMA,MAAMxY,EAAM7S,UAAWsM,EAAQtM,YACvD6S,EAAM4rC,YAAYnyC,EAAQtM,WAE9B6S,EAAM8rC,eAAeprB,EAAMyN,GACvBzN,EAAK/gB,WACLpH,EAAOrI,KAAOwwB,EAAKnoB,OAE3B,GAGA/C,KAAK82C,eAAY,EAG7B,EACAf,EAAUv0C,UAAU41C,UAAY,WAE5B,OADAp3C,KAAKi1C,aAAe,KACZj1C,KAAKgpB,cAAgBz1B,EAAQ61B,cAAckB,KACvD,EACAyrB,EAAUv0C,UAAU61C,UAAY,SAAU34C,GACtC,IAAIjJ,EAUJ,OATAuK,KAAKgpB,cAAgBz1B,EAAQ61B,cAAc1qB,MAC3CsB,KAAK82C,eAAY,EACe,QAA/BrhD,EAAKuK,KAAKk2C,uBAAoC,IAAPzgD,GAAyBA,EAAuB,qBACpFiJ,EAAMqb,gBACN/Z,KAAK+Z,cAAgBrb,EAAMqb,eAE3Brb,EAAMu2C,eACNj1C,KAAKi1C,aAAev2C,EAAMu2C,cAEvBv2C,CACX,EACOq3C,CACX,CA3NiB,GA4NjB,SAASoB,EAAkBp0C,EAAQ+uB,QACX,IAAhBA,IAA0BA,EAAc,QAC5C,IAAIwlB,EAA+B,WAAhBxlB,GAA4C,QAAhBA,EAC3CylB,GAAmB5jD,EAAU2pB,sBAAsBva,GAIvD,OAHKw0C,GAAmBD,GAAgBv0C,EAAOrI,OAC3C68C,GAAkB,GAEfA,CACX,CAEA,IAAIh2C,EAAiBlO,OAAOmO,UAAUD,eAClCi2C,EAASnkD,OAAOY,OAAO,MACvBwjD,EAAiB,WACjB,SAASA,EAAaxzC,GAClB,IAAIuG,EAAQxK,KACZA,KAAKqH,gBAAkB,CAAC,EACxBrH,KAAKhI,QAAU,IAAIiC,IACnB+F,KAAK03C,eAAiB,IAAIz9C,IAC1B+F,KAAK23C,eAAiB,IAAIhkD,EAAU8D,qBAAqB9D,EAAU+D,WAAW,iCAC1E,KACJsI,KAAK43C,eAAiB,EACtB53C,KAAK63C,iBAAmB,EACxB73C,KAAK83C,kBAAoB,EACzB93C,KAAK+3C,wBAA0B,IAAIhtC,EAAK2G,MAAK,GAC7C1R,KAAKg4C,yBAA2B,IAAI39C,IACpC,IAAI49C,EAA2B,IAAItkD,EAAUsd,kBAAkB,SAAUzZ,GAAY,OAAOgT,EAAMlU,MAAMkb,kBAAkBha,EAAW,EACrI,CAAElB,OAAO,IACT0J,KAAK1J,MAAQ2N,EAAQ3N,MACrB0J,KAAKk4C,KAAOj0C,EAAQi0C,KACpBl4C,KAAKupB,eAAiBtlB,EAAQslB,eAC9BvpB,KAAKm4C,mBAAqBl0C,EAAQk0C,mBAClCn4C,KAAKqH,gBAAkBpD,EAAQoD,gBAC/BrH,KAAKo4C,WAAan0C,EAAQm0C,WAC1Bp4C,KAAKm0C,QAAUlwC,EAAQkwC,QACvBn0C,KAAK23B,uBAAyB1zB,EAAQ0zB,uBACtC33B,KAAKy4B,YAAcx0B,EAAQw0B,YAC3B,IAAI4f,EAAoBp0C,EAAQo0C,kBAChCr4C,KAAKq4C,kBACDA,EACIJ,EACKn8C,OAAOu8C,GACPv8C,OAAOm8C,GACVA,EACVj4C,KAAKs4C,eAAiBr0C,EAAQq0C,gBAAkBjlD,OAAOY,OAAO,OACzD+L,KAAKu4C,YAAct0C,EAAQs0C,eAC5Bv4C,KAAKw4C,cAAgBnlD,OAAOY,OAAO,MAE3C,CAy6BA,OAx6BAwjD,EAAaj2C,UAAUi1C,KAAO,WAC1B,IAAIjsC,EAAQxK,KACZA,KAAKhI,QAAQoH,QAAQ,SAAUq5C,EAAO/H,GAClClmC,EAAMkuC,qBAAqBhI,EAC/B,GACA1wC,KAAK24C,qBAAqBllD,EAAQ+P,kBAAkB,IACxD,EACAi0C,EAAaj2C,UAAUm3C,qBAAuB,SAAUj6C,GACpDsB,KAAK03C,eAAet4C,QAAQ,SAAU6Z,GAAU,OAAOA,EAAOva,EAAQ,GACtEsB,KAAK03C,eAAera,OACxB,EACAoa,EAAaj2C,UAAUovB,OAAS,SAAUn7B,GACtC,OAAO7B,EAAMoV,UAAUhJ,KAAM9G,eAAW,EAAQ,SAAUsC,GACtD,IAAI+0B,EAAY9S,EAAkBm7B,EAAoBC,EAAc12B,EAChExmB,EAAIK,EACJs0B,EAAW90B,EAAG80B,SAAU34B,EAAY6D,EAAG7D,UAAWmhD,EAAqBt9C,EAAGs9C,mBAAoBC,EAAgBv9C,EAAGu9C,cAAe98C,EAAKT,EAAGw9C,eAAgBA,OAAwB,IAAP/8C,EAAgB,GAAKA,EAAI+0C,EAAKx1C,EAAGy9C,oBAAqBA,OAA6B,IAAPjI,GAAwBA,EAAIkI,EAAoB19C,EAAG81B,OAAQ6nB,EAAiB39C,EAAG29C,eAAgBC,EAAK59C,EAAGgtB,YAAaA,OAAqB,IAAP4wB,GAAuD,QAArCz9C,EAAKqE,KAAKupB,eAAeqH,cAA2B,IAAPj1B,OAAgB,EAASA,EAAG6sB,cAAgB,eAAiB4wB,EAAIC,EAAK79C,EAAGs2B,YAAaA,OAAqB,IAAPunB,GAAuD,QAArCr9C,EAAKgE,KAAKupB,eAAeqH,cAA2B,IAAP50B,OAAgB,EAASA,EAAG81B,cAAgB,OAASunB,EAAIC,EAAiB99C,EAAG89C,eAAgB3kD,EAAU6G,EAAG7G,QACvsB,OAAOf,EAAM+V,YAAY3J,KAAM,SAAUu5C,GACrC,OAAQA,EAAGl2C,OACP,KAAK,EAOD,OANA5P,EAAQiB,UAAU47B,EAAU,IAC5B78B,EAAQiB,UAA0B,iBAAhB8zB,GAAkD,aAAhBA,EAA4B,IAChF+H,EAAavwB,KAAKw5C,qBAClBlpB,EAAWtwB,KAAK1J,MAAM6hC,iBAAiBn4B,KAAKkR,UAAUof,IACtD7S,EAAmBzd,KAAK0xC,gBAAgBphB,GAAU7S,iBAClD9lB,EAAYqI,KAAKy5C,aAAanpB,EAAU34B,GACnC8lB,EACE,CAAC,EAAIzd,KAAKo4C,WAAWsB,qBAAqBppB,EAAU34B,EAAWhD,IADxC,CAAC,EAAI,GAEvC,KAAK,EACDgD,EAAa4hD,EAAGzvC,OAChByvC,EAAGl2C,MAAQ,EACf,KAAK,EAsBD,OArBAu1C,EAAqB54C,KAAKw4C,gBACrBx4C,KAAKw4C,cAAcjoB,GAAc,CAC9BD,SAAUA,EACV34B,UAAWA,EACXuwB,SAAS,EACTxpB,MAAO,OAEfm6C,EAAeC,GACX94C,KAAK25C,uBAAuBb,EAAoB,CAC5CvoB,WAAYA,EACZ/4B,SAAU84B,EACV34B,UAAWA,EACX6wB,YAAaA,EACbsJ,YAAaA,EACbn9B,QAASA,EACTokD,cAAeA,EACfznB,OAAQ4nB,EACRI,eAAgBA,IAExBt5C,KAAK8zC,mBACL3xB,EAAOniB,KACA,CAAC,EAAI,IAAIL,QAAQ,SAAUC,EAASC,GACnC,OAAOlM,EAAUynB,SAAS+G,EAAKy3B,sBAAsBtpB,EAAU18B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU,CAAEmkD,mBAAoBD,EAAeC,OAAqB,IAAWnhD,EAAW,CAAC,GAAG,GAAQ,SAAUoL,GAC7M,GAAIpP,EAAU2pB,sBAAsBva,IAA2B,SAAhB+uB,EAC3C,MAAM,IAAIzzB,EAAO2rB,YAAY,CACzBjQ,cAAepmB,EAAUmmB,2BAA2B/W,KAGxD61C,IACAA,EAAmB1wB,SAAU,EAC7B0wB,EAAmBl6C,MAAQ,MAE/B,IAAIm7C,EAAcjmD,EAAMiC,SAAS,CAAC,EAAGkN,GAOrC,MAN8B,oBAAnBi2C,IACPA,EAAiBA,EAAea,IAEhB,WAAhB/nB,GAA4Bn+B,EAAU2pB,sBAAsBu8B,WACrDA,EAAYx7C,OAEhB8jB,EAAK23B,mBAAmB,CAC3BvpB,WAAYA,EACZxtB,OAAQ82C,EACRriD,SAAU84B,EACV34B,UAAWA,EACX6wB,YAAaA,EACbsJ,YAAaA,EACbn9B,QAASA,EACT28B,OAAQ4nB,EACRH,cAAeA,EACfE,oBAAqBA,EACrBD,eAAgBA,EAChB7K,iBAAkB0K,EAAetoB,OAAa,EAC9C4oB,eAAgBA,EAChBG,eAAgBA,GAExB,GAAGvgC,UAAU,CACTrZ,KAAM,SAAUm6C,GACZ13B,EAAK2xB,mBACC,YAAa+F,IAAwC,IAAxBA,EAAY5vC,SAC3CrK,EAAQhM,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGgkD,GAAc,CAAEn/C,KAAMynB,EAAKjkB,cAAc,CAC3E1G,SAAU84B,EACV51B,KAAMm/C,EAAYn/C,KAClB8tB,YAAaA,EACblK,GAAIiS,MAGpB,EACA7xB,MAAO,SAAUQ,GACT05C,IACAA,EAAmB1wB,SAAU,EAC7B0wB,EAAmBl6C,MAAQQ,GAE3B25C,GACA12B,EAAK7rB,MAAM63C,iBAAiB5d,GAEhCpO,EAAK2xB,mBACLj0C,EAAOX,aAAeb,EAAO2rB,YAAc9qB,EAAM,IAAKb,EAAO2rB,YAAY,CACrEirB,aAAc/1C,IAEtB,GAER,IAEhB,EACJ,EACJ,EACAu4C,EAAaj2C,UAAUs4C,mBAAqB,SAAUxpB,EAAUh6B,GAC5D,IAAIkU,EAAQxK,UACE,IAAV1J,IAAoBA,EAAQ0J,KAAK1J,OACrC,IAAIyM,EAASutB,EAASvtB,OAClBg3C,EAAc,GACdC,EAAqC,aAAzB1pB,EAAS9H,YACzB,IAAKwxB,GAAa7C,EAAkBp0C,EAAQutB,EAASwB,aAAc,CAS/D,GARKn+B,EAAUimB,kCAAkC7W,IAC7Cg3C,EAAYvhD,KAAK,CACbuK,OAAQA,EAAOrI,KACfu+B,OAAQ,gBACRj0B,MAAOsrB,EAAS94B,SAChBG,UAAW24B,EAAS34B,YAGxBhE,EAAUimB,kCAAkC7W,IAC5CpP,EAAUue,gBAAgBnP,EAAOiX,aAAc,CAC/C,IAAIkR,EAAO50B,EAAM40B,KAAK,CAClB5M,GAAI,gBACJtZ,MAAOhF,KAAK0xC,gBAAgBphB,EAAS94B,UAAUyiD,QAC/CtiD,UAAW24B,EAAS34B,UACpBwzB,YAAY,EACZE,mBAAmB,IAEnB3M,OAAa,EACbwM,EAAKnoB,SACL2b,EAAaF,EAAqB0M,EAAKnoB,OAAQA,IAEzB,qBAAf2b,IACP3b,EAAOrI,KAAOgkB,EACdq7B,EAAYvhD,KAAK,CACbuK,OAAQ2b,EACRua,OAAQ,gBACRj0B,MAAOsrB,EAAS94B,SAChBG,UAAW24B,EAAS34B,YAGhC,CACA,IAAIuiD,EAAkB5pB,EAASyoB,cAC3BmB,GACAl6C,KAAKhI,QAAQoH,QAAQ,SAAU3J,EAAIi7C,GAC/B,IAAIwF,EAAkBzgD,EAAGygD,gBACrB/E,EAAY+E,GAAmBA,EAAgB/E,UACnD,GAAKA,GAAc5vC,EAAeyB,KAAKk3C,EAAiB/I,GAAxD,CAGA,IAAIgJ,EAAUD,EAAgB/I,GAC1B31C,EAAKgP,EAAMxS,QAAQH,IAAI64C,GAAUl5C,EAAWgE,EAAGhE,SAAUG,EAAY6D,EAAG7D,UACxEgE,EAAKrF,EAAM40B,KAAK,CAChBlmB,MAAOxN,EACPG,UAAWA,EACX0zB,mBAAmB,EACnBF,YAAY,IACZivB,EAAqBz+C,EAAGoH,OAC5B,GAD+CpH,EAAGwO,UAClCiwC,EAAoB,CAChC,IAAIC,EAAkBF,EAAQC,EAAoB,CAC9CE,eAAgBv3C,EAChBouC,UAAY35C,GAAY7D,EAAUqpB,iBAAiBxlB,SAAc,EACjE+iD,eAAgB5iD,IAEhB0iD,GACAN,EAAYvhD,KAAK,CACbuK,OAAQs3C,EACRphB,OAAQ,aACRj0B,MAAOxN,EACPG,UAAWA,GAGvB,CAvBA,CAwBJ,EAER,CACA,GAAIoiD,EAAY1hD,OAAS,IACpBi4B,EAAS0oB,gBAAkB,IAAI3gD,OAAS,GACzCi4B,EAASgB,QACThB,EAAS6oB,gBACT7oB,EAAS6d,iBAAkB,CAC3B,IAAIqM,EAAY,GAkDhB,GAjDAx6C,KAAKg5C,eAAe,CAChByB,YAAa,SAAUnkD,GACd0jD,GACDD,EAAY36C,QAAQ,SAAU45B,GAAS,OAAO1iC,EAAM0iC,MAAMA,EAAQ,GAEtE,IAAI1H,EAAShB,EAASgB,OAClBopB,GAAiB/mD,EAAUgqB,uBAAuB5a,IACjDpP,EAAUimB,kCAAkC7W,KAAYA,EAAOkH,QACpE,GAAIqnB,EAAQ,CACR,IAAK0oB,EAAW,CACZ,IAAI9uB,EAAO50B,EAAM40B,KAAK,CAClB5M,GAAI,gBACJtZ,MAAOwF,EAAMknC,gBAAgBphB,EAAS94B,UAAUyiD,QAChDtiD,UAAW24B,EAAS34B,UACpBwzB,YAAY,EACZE,mBAAmB,IAEnBH,EAAK/gB,WAED,gBADJpH,EAASnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAAS,CAAErI,KAAMwwB,EAAKnoB,kBAEtDA,EAAOiX,YAEd,YAAajX,UACNA,EAAOkH,QAG1B,CACIywC,GACAppB,EAAOh7B,EAAOyM,EAAQ,CAClBpO,QAAS27B,EAAS37B,QAClBgD,UAAW24B,EAAS34B,WAGhC,CACKqiD,GAAc1pB,EAASgpB,iBAAkBoB,GAC1CpkD,EAAMgiC,OAAO,CACTha,GAAI,gBACJnP,OAAQ,SAAU3b,EAAOiC,GACrB,IAAI+H,EAAY/H,EAAG+H,UAAWg9B,EAAS/kC,EAAG+kC,OAC1C,MAAqB,eAAdh9B,EAA6BhK,EAAQgnC,CAChD,GAGZ,EACAmgB,QAASrqB,EAAS0oB,eAClB7tB,YAAY,EACZgjB,iBAAkB7d,EAAS6d,iBAC3BgL,eAAgB7oB,EAAS6oB,gBAAkB,OAC5C/5C,QAAQ,SAAU2D,GAAU,OAAOy3C,EAAUhiD,KAAKuK,EAAS,GAC1DutB,EAAS2oB,qBAAuB3oB,EAAS6oB,eACzC,OAAOx5C,QAAQyL,IAAIovC,GAAWz5C,KAAK,WAAc,OAAOgC,CAAQ,EAExE,CACA,OAAOpD,QAAQC,QAAQmD,EAC3B,EACA00C,EAAaj2C,UAAUm4C,uBAAyB,SAAUb,EAAoBxoB,GAC1E,IAAI9lB,EAAQxK,KACRtF,EAAqC,oBAAvBo+C,EACdA,EAAmBxoB,EAAS34B,UAAW,CAAE6/C,OAAQA,IAC/CsB,EACN,OAAIp+C,IAAS88C,IAGbx3C,KAAK1J,MAAM2hC,4BAA4B,SAAU3hC,GAC7C,IACIkU,EAAMsvC,mBAAmBlmD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGy6B,GAAW,CAAEvtB,OAAQ,CAAErI,KAAMA,KAAWpE,EACvG,CACA,MAAOoI,IACoB,IAAvB1I,WAAWC,SAAqBxC,EAAQiB,UAAUgK,MAAMA,EAC5D,CACJ,EAAG4xB,EAASC,aACL,EACX,EACAknB,EAAaj2C,UAAU2xC,WAAa,SAAUzC,EAASzsC,EAAS+kB,GAC5D,OAAOhpB,KAAK46C,qBAAqB56C,KAAK2wC,iBAAiBD,GAAUzsC,EAAS+kB,GAAe4G,QAAQ/uB,OACrG,EACA42C,EAAaj2C,UAAUq5C,cAAgB,WACnC,IAAIpe,EAAQppC,OAAOY,OAAO,MAS1B,OARA+L,KAAKhI,QAAQoH,QAAQ,SAAUwjC,EAAM8N,GACjCjU,EAAMiU,GAAW,CACb/4C,UAAWirC,EAAKjrC,UAChBqxB,cAAe4Z,EAAK5Z,cACpBisB,aAAcrS,EAAKqS,aACnBl7B,cAAe6oB,EAAK7oB,cAE5B,GACO0iB,CACX,EACAgb,EAAaj2C,UAAU+wC,YAAc,SAAU7B,GAC3C,IAAIZ,EAAY9vC,KAAKhI,QAAQH,IAAI64C,GAC7BZ,IACAA,EAAUmF,kBAAen8C,EACzBg3C,EAAU/1B,cAAgB,GAElC,EACA09B,EAAaj2C,UAAU0P,UAAY,SAAU1Z,GACzC,OAAOwI,KAAKq4C,kBAAkB7mC,kBAAkBha,EACpD,EACAigD,EAAaj2C,UAAUkwC,gBAAkB,SAAUl6C,GAC/C,IAAImgD,EAAiB33C,KAAK23C,eAC1B,IAAKA,EAAet8C,IAAI7D,GAAW,CAC/B,IAAIsjD,EAAa,CACbr9B,iBAAkB9pB,EAAU8pB,iBAAiBjmB,GAC7Cm6C,mBAAoB3xC,KAAKo4C,WAAW2C,qBAAqBvjD,GACzD06C,wBAAyBv+C,EAAU8T,cAAc,CAAC,eAAgBjQ,GAClEy6C,iBAAkBt+C,EAAUqnB,+BAA+BxjB,GAC3DwjD,YAAah7C,KAAKo4C,WAAW4C,YAAYxjD,GACzCyjD,YAAatnD,EAAUgf,6BAA6B,CAChD,CAAE9b,KAAM,SAAU2c,QAAQ,GAC1B,CAAE3c,KAAM,cACR,CAAEA,KAAM,eACR,CAAEA,KAAM,WACTW,GACH0jD,YAAavnD,EAAU2oB,iBAAiB3oB,EAAUwK,uBAAuB3G,IACzEyiD,QAASrmD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG2B,GAAW,CAAEY,YAAaZ,EAASY,YAAY6K,IAAI,SAAU6R,GAChG,MAAiB,wBAAbA,EAAIhd,MACc,UAAlBgd,EAAIvc,UACG3E,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGif,GAAM,CAAEvc,UAAW,UAEzDuc,CACX,MAER6iC,EAAe/+C,IAAIpB,EAAUsjD,EACjC,CACA,OAAOnD,EAAe9/C,IAAIL,EAC9B,EACAigD,EAAaj2C,UAAUi4C,aAAe,SAAUjiD,EAAUG,GACtD,OAAO/D,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAK0xC,gBAAgBl6C,GAAU0jD,aAAcvjD,EAC1F,EACA8/C,EAAaj2C,UAAUqlB,WAAa,SAAU5iB,GAC1C,IAAIe,EAAQhF,KAAKkR,UAAUjN,EAAQe,OAEgB,qBADnDf,EAAUrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEtM,UAAWqI,KAAKy5C,aAAaz0C,EAAOf,EAAQtM,cACjFm1B,8BACf7oB,EAAQ6oB,6BAA8B,GAE1C,IAAIgjB,EAAY,IAAIiG,EAAU/1C,MAC1Bqb,EAAa,IAAIuL,EAAgB,CACjCnB,aAAczlB,KACd8vC,UAAWA,EACX7rC,QAASA,IAWb,OATAoX,EAAsB,UAAIrW,EACrB4hB,EAAoC,mBAAE7vB,YACvCiJ,KAAKhI,QAAQY,IAAIyiB,EAAWq1B,QAASZ,GAEzCA,EAAUzC,KAAK,CACX71C,SAAUwN,EACVkxC,gBAAiB76B,EACjB1jB,UAAW0jB,EAAW1jB,YAEnB0jB,CACX,EACAo8B,EAAaj2C,UAAUwD,MAAQ,SAAUf,EAASysC,GAC9C,IAAIlmC,EAAQxK,UACI,IAAZ0wC,IAAsBA,EAAU1wC,KAAKixC,mBACzCx9C,EAAQiB,UAAUuP,EAAQe,MAAO,IACjCvR,EAAQiB,UAAiC,aAAvBuP,EAAQe,MAAMlN,KAAqB,IACrDrE,EAAQiB,WAAWuP,EAAQonB,kBAAmB,IAC9C53B,EAAQiB,WAAWuP,EAAQwuC,aAAc,IACzC,IAAIztC,EAAQhF,KAAKkR,UAAUjN,EAAQe,OACnC,OAAOhF,KAAKmzC,WAAWzC,EAAS98C,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEe,MAAOA,KAChFjE,KAAK,SAAUgC,GAChB,OAAOA,GAAUnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAAS,CAAErI,KAAM8P,EAAMtM,cAAc,CAChF1G,SAAUwN,EACVtK,KAAMqI,EAAOrI,KACb8tB,YAAavkB,EAAQukB,YACrBlK,GAAIoyB,KAEhB,GACK4C,QAAQ,WAAc,OAAO9oC,EAAM8qC,UAAU5E,EAAU,EAChE,EACA+G,EAAaj2C,UAAUyvC,gBAAkB,WACrC,OAAO1yB,OAAOve,KAAK43C,iBACvB,EACAH,EAAaj2C,UAAU25C,kBAAoB,WACvC,OAAOn7C,KAAK63C,kBAChB,EACAJ,EAAaj2C,UAAUg4C,mBAAqB,WACxC,OAAOj7B,OAAOve,KAAK83C,oBACvB,EACAL,EAAaj2C,UAAU45C,iBAAmB,SAAU1K,GAChD1wC,KAAKq7C,4BAA4B3K,GACjC1wC,KAAK8zC,kBACT,EACA2D,EAAaj2C,UAAU65C,4BAA8B,SAAU3K,GAC3D,IAAIZ,EAAY9vC,KAAKhI,QAAQH,IAAI64C,GAC7BZ,GACAA,EAAU2G,MAClB,EACAgB,EAAaj2C,UAAU85C,WAAa,SAAUr3C,GAgB1C,YAfgB,IAAZA,IAAsBA,EAAU,CAChCiqC,gBAAgB,IAEpBluC,KAAK24C,qBAAqBllD,EAAQ+P,kBAAkB,KACpDxD,KAAKhI,QAAQoH,QAAQ,SAAU0wC,GACvBA,EAAUoG,gBACVpG,EAAU9mB,cAAgBz1B,EAAQ61B,cAAclB,QAGhD4nB,EAAU2G,MAElB,GACIz2C,KAAKw4C,gBACLx4C,KAAKw4C,cAAgBnlD,OAAOY,OAAO,OAEhC+L,KAAK1J,MAAM2X,MAAMhK,EAC5B,EACAwzC,EAAaj2C,UAAU+5C,qBAAuB,SAAUZ,GACpD,IAAInwC,EAAQxK,UACI,IAAZ26C,IAAsBA,EAAU,UACpC,IAAI3iD,EAAU,IAAIiC,IACduhD,EAAa,IAAIvhD,IACjBwhD,EAA4B,IAAIxhD,IAChCyhD,EAAqB,IAAIrhD,IAsE7B,OArEIf,MAAMC,QAAQohD,IACdA,EAAQv7C,QAAQ,SAAUu8C,GACtB,GAAoB,kBAATA,EACPH,EAAW5iD,IAAI+iD,EAAMA,GACrBF,EAA0B7iD,IAAI+iD,GAAM,QAEnC,GAAIhoD,EAAU+pB,eAAei+B,GAAO,CACrC,IAAIC,EAAcjoD,EAAUsR,MAAMuF,EAAM0G,UAAUyqC,IAClDH,EAAW5iD,IAAIgjD,EAAajoD,EAAUqpB,iBAAiB2+B,IACvDF,EAA0B7iD,IAAIgjD,GAAa,EAC/C,MACSjoD,EAAUiZ,gBAAgB+uC,IAASA,EAAK32C,OAC7C02C,EAAmB3/C,IAAI4/C,EAE/B,GAEJ37C,KAAKhI,QAAQoH,QAAQ,SAAU3J,EAAIi7C,GAC/B,IAAI2F,EAAK5gD,EAAGygD,gBAAiB1+C,EAAW/B,EAAG+B,SAC3C,GAAI6+C,EAAI,CACJ,GAAgB,QAAZsE,EAEA,YADA3iD,EAAQY,IAAI83C,EAAS2F,GAGzB,IAAIlF,EAAYkF,EAAGlF,UACnB,GAAoB,YADwBkF,EAAGpyC,QAAQukB,aAEtC,WAAZmyB,IAAyBtE,EAAGhC,eAC7B,QAEY,WAAZsG,GACCxJ,GAAasK,EAA0BpgD,IAAI81C,IAC3C35C,GAAYikD,EAA0BpgD,IAAI1H,EAAUsR,MAAMzN,OAC3DQ,EAAQY,IAAI83C,EAAS2F,GACjBlF,GACAsK,EAA0B7iD,IAAIu4C,GAAW,GACzC35C,GACAikD,EAA0B7iD,IAAIjF,EAAUsR,MAAMzN,IAAW,GAErE,CACJ,GACIkkD,EAAmB3iD,MACnB2iD,EAAmBt8C,QAAQ,SAAU6E,GACjC,IAAIysC,EAAU/8C,EAAU0mB,aAAa,sBACjCy1B,EAAYtlC,EAAMmmC,iBAAiBD,GAASrD,KAAK,CACjD71C,SAAUyM,EAAQe,MAClBrN,UAAWsM,EAAQtM,YAEnB0+C,EAAK,IAAIzvB,EAAgB,CACzBnB,aAAcjb,EACdslC,UAAWA,EACX7rC,QAASrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEukB,YAAa,mBAExE/0B,EAAQiB,UAAU2hD,EAAG3F,UAAYA,GACjCZ,EAAUoE,mBAAmBmC,GAC7Br+C,EAAQY,IAAI83C,EAAS2F,EACzB,IAEuB,IAAvBrgD,WAAWC,SAAqBwlD,EAA0B1iD,MAC1D0iD,EAA0Br8C,QAAQ,SAAUy8C,EAAUC,GAClD,IAAKD,EAAU,CACX,IAAI1K,EAAYqK,EAAW3jD,IAAIikD,GAC3B3K,GACuB,IAAvBn7C,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAAIi7C,IAGpC,IAAvBn7C,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAE/D,CACJ,GAEG8B,CACX,EACAy/C,EAAaj2C,UAAUu6C,yBAA2B,SAAUC,GACxD,IAAIxxC,EAAQxK,UACW,IAAnBg8C,IAA6BA,GAAiB,GAClD,IAAIC,EAA0B,GAa9B,OAZAj8C,KAAKu7C,qBAAqBS,EAAiB,MAAQ,UAAU58C,QAAQ,SAAU82C,EAAiBxF,GAC5F,IAAIloB,EAAc0tB,EAAgBjyC,QAAQukB,YAC1ChvB,EAAiB,mBAAoB,WACjC,OAAO08C,EAAgBliB,kBAC3B,IACIgoB,GACiB,YAAhBxzB,GAA6C,eAAhBA,IAC9ByzB,EAAwBzjD,KAAK09C,EAAgBzuB,YAEhDjd,EAAMxS,QAAQH,IAAI64C,IAAYwF,EAA2B,WAAGK,QAAQ,KACzE,GACAv2C,KAAK8zC,mBACEn0C,QAAQyL,IAAI6wC,EACvB,EACAxE,EAAaj2C,UAAUgyC,yBAA2B,SAAUvvC,GACxD,IAAIuG,EAAQxK,KACRgF,EAAQf,EAAQe,MAAOrN,EAAYsM,EAAQtM,UAC3C6wB,EAAcvkB,EAAQukB,YAAa/yB,EAAKwO,EAAQ6tB,YAAaA,OAAqB,IAAPr8B,EAAgB,OAASA,EAAI+F,EAAKyI,EAAQtP,QAASA,OAAiB,IAAP6G,EAAgB,CAAC,EAAIA,EAAIG,EAAKsI,EAAQc,WAAYA,OAAoB,IAAPpJ,EAAgB,CAAC,EAAIA,EAChOqJ,EAAQhF,KAAKkR,UAAUlM,GACvBrN,EAAYqI,KAAKy5C,aAAaz0C,EAAOrN,GACrC,IAAIukD,EAAiB,SAAUvkD,GAC3B,OAAO6S,EAAMovC,sBAAsB50C,EAAOrQ,EAASgD,EAAWoN,GAAY9B,IAAI,SAAUF,GAChE,aAAhBylB,IACI2uB,EAAkBp0C,EAAQ+uB,IAC1BtnB,EAAMlU,MAAM0iC,MAAM,CACdh0B,MAAOA,EACPjC,OAAQA,EAAOrI,KACfu+B,OAAQ,oBACRthC,UAAWA,IAGnB6S,EAAMspC,oBAEV,IAAIqI,EAAYxoD,EAAU2pB,sBAAsBva,GAC5Cq5C,EAAoB/9C,EAAOg+C,+BAA+Bt5C,GAC9D,GAAIo5C,GAAaC,EAAmB,CAChC,IAAIvrB,EAAW,CAAC,EAOhB,GANIsrB,IACAtrB,EAAS9W,cAAgBhX,EAAO1E,QAEhC+9C,IACAvrB,EAAS8B,eAAiB5vB,EAAOgC,WAAW1G,EAAO2L,yBAEnC,SAAhB8nB,GAA0BsqB,EAC1B,MAAM,IAAI/9C,EAAO2rB,YAAY6G,EAErC,CAIA,MAHoB,WAAhBiB,UACO/uB,EAAO1E,OAEX0E,CACX,EACJ,EACA,GAAI/C,KAAK0xC,gBAAgB1sC,GAAOyY,iBAAkB,CAC9C,IAAI6+B,EAAsBt8C,KAAKo4C,WAC1BsB,qBAAqB10C,EAAOrN,EAAWhD,GACvCoM,KAAKm7C,GACV,OAAO,IAAIvoD,EAAU4U,WAAW,SAAUC,GACtC,IAAImQ,EAAM,KAEV,OADA2jC,EAAoBv7C,KAAK,SAAUsa,GAAc,OAAQ1C,EAAM0C,EAAWtC,UAAUvQ,EAAY,EAAGA,EAAS9J,OACrG,WAAc,OAAOia,GAAOA,EAAIG,aAAe,CAC1D,EACJ,CACA,OAAOojC,EAAevkD,EAC1B,EACA8/C,EAAaj2C,UAAU8zC,UAAY,SAAU5E,GACzC1wC,KAAK04C,qBAAqBhI,GAC1B1wC,KAAK8zC,kBACT,EACA2D,EAAaj2C,UAAUk3C,qBAAuB,SAAUhI,GACpD1wC,KAAKq7C,4BAA4B3K,GACjC1wC,KAAKqxC,YAAYX,EACrB,EACA+G,EAAaj2C,UAAU6vC,YAAc,SAAUX,GAC3C,IAAIj7C,EACJuK,KAAK03C,eAAejsC,OAAOilC,GACvB1wC,KAAKhI,QAAQqD,IAAIq1C,KACoB,QAApCj7C,EAAKuK,KAAKhI,QAAQH,IAAI64C,UAA6B,IAAPj7C,GAAyBA,EAAGghD,OACzEz2C,KAAKhI,QAAQyT,OAAOilC,GAE5B,EACA+G,EAAaj2C,UAAUsyC,iBAAmB,WAClC9zC,KAAKu4C,aACLv4C,KAAKu4C,cACTv4C,KAAKhI,QAAQoH,QAAQ,SAAUwjC,GAAQ,IAAIntC,EAAI,OAAuC,QAA/BA,EAAKmtC,EAAKsT,uBAAoC,IAAPzgD,OAAgB,EAASA,EAAW,QAAK,EAC3I,EACAgiD,EAAaj2C,UAAU+6C,cAAgB,WACnC,OAAOv8C,KAAKo4C,UAChB,EACAX,EAAaj2C,UAAUo4C,sBAAwB,SAAU50C,EAAOrQ,EAASgD,EAAWoN,EACpFy3C,GACI,IACI/mD,EAEA4lB,EAHA7Q,EAAQxK,UAEU,IAAlBw8C,IAA4BA,EAAwG,QAAvF/mD,EAAiB,OAAZd,QAAgC,IAAZA,OAAqB,EAASA,EAAQwjD,0BAAuC,IAAP1iD,EAAgBA,EAAKuK,KAAKm4C,oBAE1K,IAAI38C,EAAKwE,KAAK0xC,gBAAgB1sC,GAAQi2C,EAAcz/C,EAAGy/C,YAAaD,EAAcx/C,EAAGw/C,YACrF,GAAIC,EAAa,CACb,IAAewB,EAANz8C,KAAqC+3C,wBAAyBG,EAA9Dl4C,KAAwEk4C,KAC7E3/C,EAAY,CACZyM,MAAOi2C,EACPtjD,UAAWA,EACXT,cAAevD,EAAUqpB,iBAAiBi+B,SAAgB,EAC1DtmD,QAASqL,KAAK08C,eAAe9oD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU,CAAEgoD,YAAaH,KACxFz3C,WAAYA,GAGhB,GADApQ,EAAU4D,EAAU5D,QAChB6nD,EAAe,CACf,IAAII,EAAuBjpD,EAAUsR,MAAMg2C,GACvC4B,EAAYvmD,EAAMwX,mBAAmBnW,GACrCmlD,EAAQL,EAA0BvmB,OAAO0mB,EAAsBC,GAEnE,KADAxhC,EAAayhC,EAAMzhC,YACF,CACb,IAAI0hC,EAAY,IAAIppD,EAAU4kB,QAAQ,CAClCja,EAAKgxB,QAAQ4oB,EAAM3/C,KAEvB8iB,EAAayhC,EAAMzhC,WAAa0hC,EAChCA,EAAUtjC,WAAW,SAAS3iB,EAAGoN,EAAQyR,GACtB,SAAXzR,GAAqB,YAAayR,GAAOA,EAAI1L,QAC7C8yC,EAAUtjC,WAAW3iB,GAGrB2lD,EAA0BjpC,OAAOopC,EAAsBC,EAE/D,EACJ,CACJ,MAEIxhC,EAAa,IAAI1nB,EAAU4kB,QAAQ,CAC/Bja,EAAKgxB,QAAQ4oB,EAAM3/C,IAG/B,MAEI8iB,EAAa,IAAI1nB,EAAU4kB,QAAQ,CAAC5kB,EAAU4U,WAAWy0C,GAAG,CAAEtiD,KAAM,CAAC,MACrE/F,EAAUqL,KAAK08C,eAAe/nD,GAYlC,OAVIqmD,IACA3/B,EAAa1nB,EAAUynB,SAASC,EAAY,SAAUtY,GAClD,OAAOyH,EAAM4tC,WAAW6E,aAAa,CACjCzlD,SAAUwjD,EACVkC,aAAcn6C,EACdpO,QAASA,EACTgD,UAAWA,GAEnB,IAEG0jB,CACX,EACAo8B,EAAaj2C,UAAU27C,mBAAqB,SAAUrN,EAAWoH,EAAoBjzC,GACjF,IAAIm5C,EAAatN,EAAUkG,cAAgBh2C,KAAKm7C,oBAC5CkC,EAAer9C,KAAK1J,MAAM6hC,iBAAiBl0B,EAAQe,OACvD,OAAOrR,EAAUynB,SAASpb,KAAK45C,sBAAsByD,EAAcp5C,EAAQtP,QAASsP,EAAQtM,WAAY,SAAUoL,GAC9G,IAAIgX,EAAgBpmB,EAAUmmB,2BAA2B/W,GACrDo5C,EAAYpiC,EAAc1hB,OAAS,EACnCy5B,EAAc7tB,EAAQ6tB,YAC1B,GAAIsrB,GAAatN,EAAUkG,cAAe,CACtC,GAAImG,GAA6B,SAAhBrqB,EACb,MAAMge,EAAUuH,UAAU,IAAIh5C,EAAO2rB,YAAY,CAC7CjQ,cAAeA,KAGvB+1B,EAAUmH,WAAWl0C,EAAQs6C,EAAcp5C,EAASizC,GACpDpH,EAAUsH,WACd,CACA,IAAIkG,EAAM,CACN5iD,KAAMqI,EAAOrI,KACbwtB,SAAS,EACTc,cAAez1B,EAAQ61B,cAAckB,OASzC,OAPI6xB,GAA6B,SAAhBrqB,IACbwrB,EAAI5iD,UAAO,GAEXyhD,GAA6B,WAAhBrqB,IACbwrB,EAAIj/C,OAAS0b,EACbujC,EAAIt0B,cAAgBz1B,EAAQ61B,cAAc1qB,OAEvC4+C,CACX,EAAG,SAAUrI,GACT,IAAIv2C,EAAQL,EAAO22C,cAAcC,GAAgBA,EAAe,IAAK52C,EAAO2rB,YAAY,CAAEirB,aAAcA,IAIxG,MAHImI,GAAatN,EAAUkG,eACvBlG,EAAUuH,UAAU34C,GAElBA,CACV,EACJ,EACA+4C,EAAaj2C,UAAUo5C,qBAAuB,SAAU9K,EAAW7rC,EACnE+kB,EAAehkB,GACX,IAAIwF,EAAQxK,UACU,IAAlBgpB,IAA4BA,EAAgBz1B,EAAQ61B,cAAclB,cACxD,IAAVljB,IAAoBA,EAAQf,EAAQe,OACxC,IA4BI4qB,EAAS2tB,EA5BT5lD,EAAYqI,KAAKy5C,aAAaz0C,EAAOf,EAAQtM,WAC7CmnB,EAAW9e,KAAKupB,eAAe1C,WAC/BpxB,EAAKwO,EAAQukB,YAAaA,OAAqB,IAAP/yB,EAAiBqpB,GAAYA,EAAS0J,aAAgB,cAAgB/yB,EAAI+F,EAAKyI,EAAQ6tB,YAAaA,OAAqB,IAAPt2B,EAAiBsjB,GAAYA,EAASgT,aAAgB,OAASt2B,EAAIG,EAAKsI,EAAQonB,kBAAmBA,OAA2B,IAAP1vB,GAAwBA,EAAIK,EAAKiI,EAAQ6oB,4BAA6BA,OAAqC,IAAP9wB,GAAwBA,EAAIC,EAAKgI,EAAQtP,QAASA,OAAiB,IAAPsH,EAAgB,CAAC,EAAIA,EACtcuhD,EAAanqD,OAAO0a,OAAO,CAAC,EAAG9J,EAAS,CACxCe,MAAOA,EACPrN,UAAWA,EACX6wB,YAAaA,EACbsJ,YAAaA,EACbzG,kBAAmBA,EACnByB,4BAA6BA,EAC7Bn4B,QAASA,IAET8oD,EAAgB,SAAU9lD,GAC1B6lD,EAAW7lD,UAAYA,EACvB,IAAI+lD,EAAkBlzC,EAAMmzC,mBAAmB7N,EAAW0N,EAAYx0B,GAOtE,MAL2B,YAA3Bw0B,EAAWh1B,aACPk1B,EAAgB5nC,QAAQzd,OAAS,GACjCy3C,EAAUoG,iBACVpG,EAAUoG,gBAAsC,qBAAE,cAAejyC,GAE9Dy5C,CACX,EACIE,EAAkB,WAAc,OAAOpzC,EAAMktC,eAAejsC,OAAOqkC,EAAUY,QAAU,EAM3F,GALA1wC,KAAK03C,eAAe9+C,IAAIk3C,EAAUY,QAAS,SAAUx3B,GACjD0kC,IACAxwC,WAAW,WAAc,OAAOwiB,EAAQ3W,OAAOC,EAAS,EAC5D,GAEIlZ,KAAK0xC,gBAAgB8L,EAAWx4C,OAAOyY,iBACvCmS,EAAU,IAAIj8B,EAAU4kB,QAAQvY,KAAKo4C,WAChCsB,qBAAqB8D,EAAWx4C,MAAOw4C,EAAW7lD,UAAW6lD,EAAW7oD,SACxEoM,KAAK08C,GACL18C,KAAK,SAAU28C,GAAmB,OAAOA,EAAgB5nC,OAAS,IACvEynC,GAAuB,MAEtB,CACD,IAAIG,EAAkBD,EAAcD,EAAW7lD,WAC/C4lD,EAAuBG,EAAgB3I,SACvCnlB,EAAU,IAAIj8B,EAAU4kB,QAAQmlC,EAAgB5nC,QACpD,CAEA,OADA8Z,EAAQ/uB,QAAQE,KAAK68C,EAAiBA,GAC/B,CACHhuB,QAASA,EACTmlB,SAAUwI,EAElB,EACA9F,EAAaj2C,UAAUw3C,eAAiB,SAAUvjD,GAC9C,IAAI+U,EAAQxK,KACRy6C,EAAchlD,EAAGglD,YAAaE,EAAUllD,EAAGklD,QAASn/C,EAAK/F,EAAG01B,WAAYA,OAAoB,IAAP3vB,GAAwBA,EAAIG,EAAKlG,EAAG04C,iBAAkBA,OAA0B,IAAPxyC,EAAgBwvB,EAAax3B,EAAU0mB,aAAa,uBAAoB,EAAS1e,EAAIw9C,EAAiB1jD,EAAG0jD,eACvQ0E,EAAsB,IAAI5jD,IAC1B0gD,GACA36C,KAAKu7C,qBAAqBZ,GAASv7C,QAAQ,SAAUi3C,EAAI3F,GACrDmN,EAAoBjlD,IAAI83C,EAAS,CAC7B2F,GAAIA,EACJ1H,UAAWnkC,EAAMxS,QAAQH,IAAI64C,IAAY2F,EAAc,WAAGzhB,WAElE,GAEJ,IAAIkpB,EAAU,IAAI7jD,IAqDlB,OApDIwgD,GACAz6C,KAAK1J,MAAMuhC,MAAM,CACbvG,OAAQmpB,EACRtvB,WAAaA,GAAcgjB,IAAqB,EAChDA,iBAAkBA,EAClBG,eAAgB,SAAU1V,EAAO1N,EAAMyjB,GACnC,IAAI0H,EAAKzd,EAAMge,mBAAmBb,GAAand,EAAMge,QAAQV,gBAC7D,GAAIG,EAAI,CACJ,GAAI8C,EAAgB,CAChB0E,EAAoBpyC,OAAO4qC,EAAG3F,SAC9B,IAAI3tC,EAASo2C,EAAe9C,EAAInrB,EAAMyjB,GAOtC,OANe,IAAX5rC,IACAA,EAASszC,EAAG5uB,YAED,IAAX1kB,GACA+6C,EAAQllD,IAAIy9C,EAAItzC,GAEbA,CACX,CACuB,OAAnBo2C,GACA0E,EAAoBjlD,IAAIy9C,EAAG3F,QAAS,CAAE2F,GAAIA,EAAI1H,SAAUA,EAAUzjB,KAAMA,GAEhF,CACJ,IAGJ2yB,EAAoB9kD,MACpB8kD,EAAoBz+C,QAAQ,SAAU3J,EAAIi7C,GACtC,IACI3tC,EADAszC,EAAK5gD,EAAG4gD,GAAI1H,EAAWl5C,EAAGk5C,SAAUzjB,EAAOz1B,EAAGy1B,KAE9CiuB,IACKjuB,IACDA,EAAO1xB,EAAiB,kBAAmB,WACvC,OAAOgR,EAAMlU,MAAM40B,KAAKmrB,EAAc,UAAkB,iBAC5D,IAEJtzC,EAASo2C,EAAe9C,EAAInrB,EAAMyjB,IAEjCwK,IAA6B,IAAXp2C,IACnBA,EAASszC,EAAG5uB,YAED,IAAX1kB,GACA+6C,EAAQllD,IAAIy9C,EAAItzC,GAEhB2tC,EAAQ3uC,QAAQ,uBAAyB,GACzCyI,EAAMkuC,qBAAqBhI,EAEnC,GAEAvC,GACAnuC,KAAK1J,MAAM63C,iBAAiBA,GAEzB2P,CACX,EACArG,EAAaj2C,UAAUtD,cAAgB,SAAU+F,GAC7C,IAAIxO,EAAI+F,EAAIG,EACRnE,EAAWyM,EAAQzM,SAAUkD,EAAOuJ,EAAQvJ,KAChD,IAA2B,IAAvB1E,WAAWC,QAAmB,CAC9B,IAAIuyB,EAAcvkB,EAAQukB,YAAalK,EAAKra,EAAQqa,GAChD3hB,EAAsE,QAArDlH,EAAK9B,EAAUwK,uBAAuB3G,UAA8B,IAAP/B,OAAgB,EAASA,EAAG8C,UAC1GwlD,GAAyG,QAAzFviD,EAAuB,OAAlBmB,QAA4C,IAAlBA,OAA2B,EAASA,EAAc,UAAuB,IAAPnB,EAAgBA,EAAK,KAAO8iB,GAC7Ite,KAAKy4B,aACW,aAAhBjQ,GACC70B,EAAUiqB,yBAAyBpmB,IACnCwI,KAAKg4C,yBAAyB38C,IAAI0iD,KACnC/9C,KAAKg4C,yBAAyBj8C,IAAIgiD,IACX,IAAvB/nD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAC9C,GACgD,QAA/CyF,EAAKhI,EAAUqpB,iBAAiBxlB,UAA8B,IAAPmE,EAAgBA,EAAK,WAAWG,OAAyB,OAAlBa,QAA4C,IAAlBA,EAA2BA,EAAgB,cAGhL,CACA,OAAQqD,KAAKy4B,YACTnD,EAAQp3B,cAAcxD,EAAMlD,EAAUwI,KAAK1J,OACzCoE,CACV,EACA+8C,EAAaj2C,UAAU7D,aAAe,SAAUsG,GAC5C,IAAIvJ,EAAOuJ,EAAQvJ,KAAMwC,EAAW+G,EAAQ/G,SAAUD,EAAegH,EAAQhH,aAC7E,OAAO+C,KAAKy4B,YACRnD,EAAQ33B,aAAajD,EAAMwC,EAAU8C,KAAK1J,MAAO2G,GAC/CvC,CACV,EACA+8C,EAAaj2C,UAAUm8C,mBAAqB,SAAU7N,EAAWr6C,EACjEuzB,GACI,IAAIxe,EAAQxK,KACRgF,EAAQvP,EAAGuP,MAAOrN,EAAYlC,EAAGkC,UAAW6wB,EAAc/yB,EAAG+yB,YAAaw1B,EAAqBvoD,EAAGuoD,mBAAoBlsB,EAAcr8B,EAAGq8B,YAAazG,EAAoB51B,EAAG41B,kBAAmB12B,EAAUc,EAAGd,QAASm4B,EAA8Br3B,EAAGq3B,4BACrPmxB,EAAmBnO,EAAU9mB,cACjC8mB,EAAUzC,KAAK,CACX71C,SAAUwN,EACVrN,UAAWA,EACXqxB,cAAeA,IAEnB,IAAIk1B,EAAY,WAAc,OAAOpO,EAAUlb,SAAW,EACtDupB,EAAmB,SAAUjzB,EAAMlC,QACb,IAAlBA,IAA4BA,EAAgB8mB,EAAU9mB,eAAiBz1B,EAAQ61B,cAAclB,SACjG,IAAIxtB,EAAOwwB,EAAKnoB,QACW,IAAvB/M,WAAWC,SAAsBo1B,GAAsBrI,EAAMA,MAAMtoB,EAAM,CAAC,IAC1Ek3C,EAAsB1mB,EAAKO,SAE/B,IAAI2yB,EAAW,SAAU1jD,GACrB,OAAO/G,EAAU4U,WAAWy0C,GAAGppD,EAAMiC,SAAS,CAAE6E,KAAMA,EAAMwtB,QAAS0nB,EAAyB5mB,GAAgBA,cAAeA,GAAkBkC,EAAK/gB,SAAW,KAAO,CAAE8f,SAAS,IACrL,EACA,OAAIvvB,GAAQ8P,EAAMknC,gBAAgB1sC,GAAO2sC,mBAC9BnnC,EAAM4tC,WACR6E,aAAa,CACdzlD,SAAUwN,EACVk4C,aAAc,CAAExiD,KAAMA,GACtB/F,QAASA,EACTgD,UAAWA,EACX0mD,wBAAwB,IAEvBt9C,KAAK,SAAUD,GAAY,OAAOs9C,EAASt9C,EAASpG,WAAQ,EAAS,GAE1D,SAAhBo3B,GACA9I,IAAkBz1B,EAAQ61B,cAAc3B,SACxCnuB,MAAMC,QAAQ2xB,EAAKO,SACZ2yB,OAAS,GAEbA,EAAS1jD,EACpB,EACIw8C,EAAqC,aAAhB1uB,EAA6B,EAC/CQ,IAAkBz1B,EAAQ61B,cAAc3B,SAChB,UAAvBu2B,EACA,EACE,EACNM,EAAkB,WAClB,OAAO9zC,EAAM2yC,mBAAmBrN,EAAWoH,EAAoB,CAC3DlyC,MAAOA,EACPrN,UAAWA,EACXhD,QAASA,EACT6zB,YAAaA,EACbsJ,YAAaA,GAErB,EACIysB,EAAezxB,GACa,kBAArBmxB,GACPA,IAAqBj1B,GACrB4mB,EAAyB5mB,GAC7B,OAAQR,GACJ,QACA,IAAK,cAED,OADI0C,EAAOgzB,KACF/zC,SACE,CACH4qC,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBjzB,EAAM4kB,EAAUsH,eAG/C/rB,GAAqBkzB,EACd,CACHxJ,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBjzB,GAAOozB,MAGnC,CAAEvJ,UAAU,EAAMj/B,QAAS,CAACwoC,MAEvC,IAAK,oBACD,IAAIpzB,EACJ,OADIA,EAAOgzB,KACF/zC,UAAYkhB,GAAqBkzB,EAC/B,CACHxJ,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBjzB,GAAOozB,MAGnC,CAAEvJ,UAAU,EAAMj/B,QAAS,CAACwoC,MAEvC,IAAK,aACD,MAAO,CACHvJ,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBD,IAAapO,EAAUsH,eAE1D,IAAK,eACD,OAAImH,EACO,CACHxJ,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBD,KAAcI,MAG1C,CAAEvJ,UAAU,EAAMj/B,QAAS,CAACwoC,MACvC,IAAK,WACD,OAAIC,EACO,CACHxJ,UAAU,EACVj/B,QAAS,CAACqoC,EAAiBrO,EAAUlb,WAAY0pB,MAGlD,CAAEvJ,UAAU,EAAMj/B,QAAS,CAACwoC,MACvC,IAAK,UACD,MAAO,CAAEvJ,UAAU,EAAOj/B,QAAS,IAE/C,EACA2hC,EAAaj2C,UAAUmvC,iBAAmB,SAAUD,GAIhD,OAHIA,IAAY1wC,KAAKhI,QAAQqD,IAAIq1C,IAC7B1wC,KAAKhI,QAAQY,IAAI83C,EAAS,IAAIqF,EAAU/1C,KAAM0wC,IAE3C1wC,KAAKhI,QAAQH,IAAI64C,EAC5B,EACA+G,EAAaj2C,UAAUk7C,eAAiB,SAAU/nD,QAC9B,IAAZA,IAAsBA,EAAU,CAAC,GACrC,IAAI6pD,EAAax+C,KAAKo4C,WAAWsE,eAAe/nD,GAChD,OAAOf,EAAMiC,SAASjC,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGmK,KAAKs4C,gBAAiBkG,GAAa,CAAEn3C,gBAAiBrH,KAAKqH,iBACvH,EACOowC,CACX,CA78BoB,GA+8BhBgH,EAAe,WACf,SAASA,EAAWhpD,GAChB,IAAIa,EAAQb,EAAGa,MAAOhB,EAASG,EAAGH,OAAQopD,EAAYjpD,EAAGipD,UAAWC,EAAkBlpD,EAAGkpD,gBACzF3+C,KAAK4+C,yBAA2B,IAAI5kD,QACpCgG,KAAK1J,MAAQA,EACThB,IACA0K,KAAK1K,OAASA,GAEdopD,GACA1+C,KAAK6+C,aAAaH,GAElBC,GACA3+C,KAAK8+C,mBAAmBH,EAEhC,CAySA,OAxSAF,EAAWj9C,UAAUq9C,aAAe,SAAUH,GAC1C,IAAIl0C,EAAQxK,KACZA,KAAK0+C,UAAY1+C,KAAK0+C,WAAa,CAAC,EAChCplD,MAAMC,QAAQmlD,GACdA,EAAUt/C,QAAQ,SAAU2/C,GACxBv0C,EAAMk0C,UAAY/qD,EAAUkiB,UAAUrL,EAAMk0C,UAAWK,EAC3D,GAGA/+C,KAAK0+C,UAAY/qD,EAAUkiB,UAAU7V,KAAK0+C,UAAWA,EAE7D,EACAD,EAAWj9C,UAAUw9C,aAAe,SAAUN,GAC1C1+C,KAAK0+C,UAAY,CAAC,EAClB1+C,KAAK6+C,aAAaH,EACtB,EACAD,EAAWj9C,UAAUy9C,aAAe,WAChC,OAAOj/C,KAAK0+C,WAAa,CAAC,CAC9B,EACAD,EAAWj9C,UAAUy7C,aAAe,SAAUxnD,GAC1C,OAAO7B,EAAMoV,UAAUhJ,KAAM9G,eAAW,EAAQ,SAAUsC,GACtD,IAAIhE,EAAWgE,EAAGhE,SAAU0lD,EAAe1hD,EAAG0hD,aAAcvoD,EAAU6G,EAAG7G,QAASgD,EAAY6D,EAAG7D,UAAWgE,EAAKH,EAAG6iD,uBAAwBA,OAAgC,IAAP1iD,GAAwBA,EAC7L,OAAO/H,EAAM+V,YAAY3J,KAAM,SAAUhE,GACrC,OAAIxE,EACO,CAAC,EAAIwI,KAAKk/C,gBAAgB1nD,EAAU0lD,EAAaxiD,KAAM/F,EAASgD,EAAWqI,KAAK2+C,gBAAiBN,GAAwBt9C,KAAK,SAAUo+C,GAAe,OAAQvrD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGqnD,GAAe,CAAExiD,KAAMykD,EAAYp8C,QAAY,IAEpP,CAAC,EAAIm6C,EAChB,EACJ,EACJ,EACAuB,EAAWj9C,UAAUs9C,mBAAqB,SAAUH,GAChD3+C,KAAK2+C,gBAAkBA,CAC3B,EACAF,EAAWj9C,UAAU49C,mBAAqB,WACtC,OAAOp/C,KAAK2+C,eAChB,EACAF,EAAWj9C,UAAUw5C,YAAc,SAAUxjD,GACzC,OAAI7D,EAAU8T,cAAc,CAAC,UAAWjQ,IAChCwI,KAAK0+C,UACElnD,EAGR,IACX,EACAinD,EAAWj9C,UAAUy5C,YAAc,SAAUzjD,GACzC,OAAO7D,EAAUgU,6BAA6BnQ,EAClD,EACAinD,EAAWj9C,UAAUk7C,eAAiB,SAAU/nD,GAC5C,IAAI2B,EAAQ0J,KAAK1J,MACjB,OAAO1C,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU,CAAE2B,MAAOA,EACxD8a,YAAa,SAAU9P,GACnB,OAAOhL,EAAM00B,SAAS1pB,EAC1B,GACR,EACAm9C,EAAWj9C,UAAUk4C,qBAAuB,SAAU2F,GAClD,OAAOzrD,EAAMoV,UAAUhJ,KAAM9G,eAAW,EAAQ,SAAU1B,EAAUG,EAAWhD,GAG3E,YAFkB,IAAdgD,IAAwBA,EAAY,CAAC,QACzB,IAAZhD,IAAsBA,EAAU,CAAC,GAC9Bf,EAAM+V,YAAY3J,KAAM,SAAUvK,GACrC,OAAI+B,EACO,CAAC,EAAIwI,KAAKk/C,gBAAgB1nD,EAAUwI,KAAKs/C,wBAAwB9nD,EAAUG,IAAc,CAAC,EAAGqI,KAAK08C,eAAe/nD,GAAUgD,GAAWoJ,KAAK,SAAUrG,GAAQ,OAAQ9G,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG8B,GAAY+C,EAAK6kD,kBAAqB,IAEjP,CAAC,EAAI3rD,EAAMiC,SAAS,CAAC,EAAG8B,GACnC,EACJ,EACJ,EACA8mD,EAAWj9C,UAAUu5C,qBAAuB,SAAUvjD,GAClD,IAAIgoD,GAAiB,EAiBrB,OAhBA7lD,EAAQ4R,MAAM/T,EAAU,CACpBgU,UAAW,CACPoI,MAAO,SAAU/V,GACb,GAAwB,WAApBA,EAAKhH,KAAKrD,OAAsBqK,EAAK3E,YACrCsmD,EAAiB3hD,EAAK3E,UAAUmP,KAAK,SAAUsN,GAC3C,MAA0B,WAAnBA,EAAI9e,KAAKrD,OACO,iBAAnBmiB,EAAIniB,MAAMsE,OACU,IAApB6d,EAAIniB,MAAMA,KAClB,IAEI,OAAOmG,EAAQ+R,KAG3B,KAGD8zC,CACX,EACAf,EAAWj9C,UAAU89C,wBAA0B,SAAU9nD,EAAUG,GAC/D,OAAOqI,KAAK1J,MAAM40B,KAAK,CACnBlmB,MAAOrR,EAAUmoB,2BAA2BtkB,GAC5CG,UAAWA,EACX0zB,mBAAmB,EACnBF,YAAY,IACbpoB,MACP,EACA07C,EAAWj9C,UAAU09C,gBAAkB,SAAUG,EAAYI,GACzD,OAAO7rD,EAAMoV,UAAUhJ,KAAM9G,eAAW,EAAQ,SAAU1B,EAAUkoD,EAAW/qD,EAASgD,EAAWgnD,EAAiBN,GAChH,IAAIsB,EAAgB5nD,EAAWoF,EAAayiD,EAAqBC,EAAqBC,EAAsBrqD,EAAIa,EAAOhB,EAAQyqD,EAK/H,YAJgB,IAAZprD,IAAsBA,EAAU,CAAC,QACnB,IAAdgD,IAAwBA,EAAY,CAAC,QACjB,IAApBgnD,IAA8BA,EAAkB,WAAc,OAAO,CAAM,QAChD,IAA3BN,IAAqCA,GAAyB,GAC3DzqD,EAAM+V,YAAY3J,KAAM,SAAUxE,GAsBrC,OArBAmkD,EAAiBhsD,EAAUwU,kBAAkB3Q,GAC7CO,EAAYpE,EAAUsK,uBAAuBzG,GAC7C2F,EAAcxJ,EAAUqK,kBAAkBjG,GAC1C6nD,EAAsB5/C,KAAKggD,2BAA2BL,EAAgBxiD,GACtE0iD,EAAsBF,EAAepnD,UACrCunD,EAAuBD,EACnBA,EAAoBvb,OAAO,GAAG4C,cAC1B2Y,EAAoB1gD,MAAM,GAC5B,QACK7I,GAAXb,EAAKuK,MAAiB1J,MAAOhB,EAASG,EAAGH,OACzCyqD,EAAc,CACV5iD,YAAaA,EACbxI,QAASf,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU,CAAE2B,MAAOA,EAAOhB,OAAQA,IAC7EqC,UAAWA,EACXgnD,gBAAiBA,EACjBmB,qBAAsBA,EACtBP,kBAAmB,CAAC,EACpBK,oBAAqBA,EACrBvB,uBAAwBA,GAGrB,CAAC,EAAIr+C,KAAKigD,oBAAoBN,EAAehlD,aAD1B,MACiE+kD,EAAWK,GAAah/C,KAAK,SAAUgC,GAAU,MAAO,CAC3IA,OAAQA,EACRw8C,kBAAmBQ,EAAYR,kBAC/B,GACZ,EACJ,EACJ,EACAd,EAAWj9C,UAAUy+C,oBAAsB,SAAUtlD,EAAculD,EAAyBR,EAAWK,GACnG,OAAOnsD,EAAMoV,UAAUhJ,UAAM,OAAQ,EAAQ,WACzC,IAAI7C,EAAaxI,EAASgD,EAAWwoD,EAAgB7wB,EACjD9kB,EAAQxK,KACZ,OAAOpM,EAAM+V,YAAY3J,KAAM,SAAUvK,GAyCrC,OAxCA0H,EAAc4iD,EAAY5iD,YAAaxI,EAAUorD,EAAYprD,QAASgD,EAAYooD,EAAYpoD,UAC9FwoD,EAAiB,CAACT,GAClBpwB,EAAU,SAAUnzB,GAAa,OAAOvI,EAAMoV,UAAUwB,OAAO,OAAQ,EAAQ,WAC3E,IAAItN,EAAUL,EACd,OAAOjJ,EAAM+V,YAAY3J,KAAM,SAAUvK,GACrC,OAAKyqD,GACAH,EAAYH,oBAAoBvkD,IAAIc,KAGpCxI,EAAUytB,cAAcjlB,EAAWxE,GAGpChE,EAAU6c,QAAQrU,GACX,CAAC,EAAI6D,KAAKogD,aAAajkD,EAAW+jD,EAAyBR,EAAWK,GAAah/C,KAAK,SAAUs/C,GACjG,IAAI5qD,EACuB,qBAAhB4qD,GACPF,EAAe3nD,OAAM/C,EAAK,CAAC,GACpB9B,EAAU4I,uBAAuBJ,IAAckkD,EAClD5qD,GAEZ,KAEJ9B,EAAUmqB,iBAAiB3hB,GAC3Be,EAAWf,GAGXe,EAAWC,EAAYhB,EAAUtF,KAAKrD,OACtCC,EAAQiB,UAAUwI,EAAU,GAAIf,EAAUtF,KAAKrD,QAE/C0J,GAAYA,EAASL,gBACrBA,EAAgBK,EAASL,cAAchG,KAAKrD,MACxCusD,EAAYpB,gBAAgBe,EAAW7iD,EAAelI,IAC/C,CAAC,EAAIqL,KAAKigD,oBAAoB/iD,EAASvC,aAAculD,EAAyBR,EAAWK,GAAah/C,KAAK,SAAUu/C,GACpHH,EAAe3nD,KAAK8nD,EACxB,IAGL,CAAC,IA9BG,CAAC,EA+BhB,EACJ,EAAI,EACG,CAAC,EAAI3gD,QAAQyL,IAAIzQ,EAAauB,WAAW+G,IAAIqsB,IAAUvuB,KAAK,WAC3D,OAAOpN,EAAUoiB,eAAeoqC,EACpC,GACR,EACJ,EACJ,EACA1B,EAAWj9C,UAAU4+C,aAAe,SAAU9vC,EAAO4vC,EAAyBR,EAAWK,GACrF,OAAOnsD,EAAMoV,UAAUhJ,UAAM,OAAQ,EAAQ,WACzC,IAAIrI,EAAW6F,EAAW+iD,EAAkBC,EAAWC,EAAeC,EAAeC,EAAcC,EAAahhD,EAC5G4K,EAAQxK,KACZ,OAAOpM,EAAM+V,YAAY3J,KAAM,SAAUvK,GACrC,OAAKiqD,GAGL/nD,EAAYooD,EAAYpoD,UACxB6F,EAAY8S,EAAMzZ,KAAKrD,MACvB+sD,EAAmB5sD,EAAU4I,uBAAuB+T,GACpDkwC,EAAYhjD,IAAc+iD,EAC1BE,EAAgBf,EAAUa,IAAqBb,EAAUliD,GACzDkjD,EAAgB/gD,QAAQC,QAAQ6gD,GAC3BV,EAAY1B,yBACbr+C,KAAK+6C,qBAAqBzqC,KAC1BqwC,EAAejB,EAAU3iD,YAAcgjD,EAAYD,sBACnDc,EAAc5gD,KAAK0+C,WAAa1+C,KAAK0+C,UAAUiC,MAE3C/gD,EAAUghD,EAAYJ,EAAYhjD,EAAY+iD,MAE1CG,EAAgB/gD,QAAQC,QACxBtJ,EAAMmsC,UAAUtpC,UAAU6G,KAAK1J,MAAOsJ,EAAS,CAC3C8/C,EACA/rD,EAAUunB,yBAAyB5K,EAAO3Y,GAC1CooD,EAAYprD,QACZ,CAAE2b,MAAOA,EAAOnT,YAAa4iD,EAAY5iD,kBAKlD,CAAC,EAAIujD,EAAc3/C,KAAK,SAAUgC,GACjC,IAAItN,EAAI+F,EAaR,QAZe,IAAXuH,IAAqBA,EAAS09C,GAC9BnwC,EAAM1E,YACN0E,EAAM1E,WAAWxM,QAAQ,SAAUyM,GACF,WAAzBA,EAAUhV,KAAKrD,OAAsBqY,EAAU3S,WAC/C2S,EAAU3S,UAAUkG,QAAQ,SAAUuW,GACX,OAAnBA,EAAI9e,KAAKrD,OAAqC,gBAAnBmiB,EAAIniB,MAAMsE,OACrCioD,EAAYR,kBAAkB5pC,EAAIniB,MAAMA,OAASuP,EAEzD,EAER,IAECuN,EAAM3V,aACP,OAAOoI,EAEX,GAAc,MAAVA,EACA,OAAOA,EAEX,IAAI89C,EAAoJ,QAAnIrlD,EAAiC,QAA3B/F,EAAK6a,EAAM1E,kBAA+B,IAAPnW,OAAgB,EAASA,EAAG4S,KAAK,SAAUJ,GAAK,MAAwB,WAAjBA,EAAEpR,KAAKrD,KAAoB,UAAuB,IAAPgI,GAAgBA,EAChL,OAAIlC,MAAMC,QAAQwJ,GACPyH,EAAMs2C,wBAAwBxwC,EAAO4vC,GAA2BW,EAAe99C,EAAQg9C,GAE9FzvC,EAAM3V,aACC6P,EAAMy1C,oBAAoB3vC,EAAM3V,aAAculD,GAA2BW,EAAe99C,EAAQg9C,QAD3G,CAGJ,KApDO,CAAC,EAAI,KAqDpB,EACJ,EACJ,EACAtB,EAAWj9C,UAAUs/C,wBAA0B,SAAUxwC,EAAO4vC,EAAyBn9C,EAAQg9C,GAC7F,IAAIv1C,EAAQxK,KACZ,OAAOL,QAAQyL,IAAIrI,EAAOE,IAAI,SAAUpH,GACpC,OAAa,OAATA,EACO,KAEPvC,MAAMC,QAAQsC,GACP2O,EAAMs2C,wBAAwBxwC,EAAO4vC,EAAyBrkD,EAAMkkD,GAE3EzvC,EAAM3V,aACC6P,EAAMy1C,oBAAoB3vC,EAAM3V,aAAculD,EAAyBrkD,EAAMkkD,QADxF,CAGJ,GACJ,EACAtB,EAAWj9C,UAAUw+C,2BAA6B,SAAUL,EAAgBxiD,GACxE,IAAI4jD,EAAkB,SAAUljD,GAAQ,OAAQvE,MAAMC,QAAQsE,EAAO,EACjE+gD,EAA2B5+C,KAAK4+C,yBAmCpC,OAlCA,SAASoC,EAAoBC,GACzB,IAAKrC,EAAyBvjD,IAAI4lD,GAAiB,CAC/C,IAAIC,EAAY,IAAI7mD,IACpBukD,EAAyBhmD,IAAIqoD,EAAgBC,GAC7CvnD,EAAQ4R,MAAM01C,EAAgB,CAC1Bz1C,UAAW,SAAU3N,EAAMsb,EAAG8Y,EAAIkvB,EAAKpuC,GACX,WAApBlV,EAAKhH,KAAKrD,OACVuf,EAAU3T,QAAQ,SAAUvB,GACpBkjD,EAAgBljD,IAASlE,EAAQynD,gBAAgBvjD,IACjDqjD,EAAUnlD,IAAI8B,EAEtB,EAER,EACAwW,eAAgB,SAAUgtC,EAAQloC,EAAG8Y,EAAIkvB,EAAKpuC,GAC1C,IAAI7V,EAAWC,EAAYkkD,EAAOxqD,KAAKrD,OACvCC,EAAQiB,UAAUwI,EAAU,GAAImkD,EAAOxqD,KAAKrD,OAC5C,IAAI8tD,EAAqBN,EAAoB9jD,GACzCokD,EAAmBvoD,KAAO,IAC1Bga,EAAU3T,QAAQ,SAAUvB,GACpBkjD,EAAgBljD,IAASlE,EAAQynD,gBAAgBvjD,IACjDqjD,EAAUnlD,IAAI8B,EAEtB,GACAqjD,EAAUnlD,IAAIslD,GACdC,EAAmBliD,QAAQ,SAAUjD,GACjC+kD,EAAUnlD,IAAII,EAClB,GAER,GAER,CACA,OAAOyiD,EAAyB/mD,IAAIopD,EACxC,CACOD,CAAoBrB,EAC/B,EACOlB,CACX,CAxTkB,GA0Td9wC,EAAkBpZ,OAAOC,IAAI,oBAC7BkD,EAAa9D,EAAMiC,SAAS,CAAC,EAAGpC,EAAQgD,OAAOkX,IAE/CvX,EAAe,CAAC,EAChBmrD,IAAwD,IAAvBvrD,WAAWC,QA4BhD,WACI,IAAIR,EAAI+F,EAAIG,EAAIK,EAAIC,EACpB,IAA6B,IAAvBjG,WAAWC,QACb,MAAM,IAAImL,MAAM,sCACpB,MAAO,CACHogD,OAbGnuD,OAAOouD,YAAYpuD,OAAOqI,QAhBlB,CACXnE,OAAQ,IACRuW,mBAAoB,IACpB7I,MAAO,IACP,0BAA2B,IAC3B,+BAAgC,IAChC,0CAA2C,IAC3C,6BAA8B,IAC9B,0BAA2B,IAC3B,uCAAwC,IACxC,+BAAgC,IAChC,qDAAsD,IACtD,oCAAqC,IACrC,oCAAqC,IACrC,wCAAyC,MAEMhC,IAAI,SAAUxN,GAC7D,IAAIvB,EAAIuB,EAAG,GAAIi9C,EAAIj9C,EAAG,GACtB,MAAO,CACHvB,EACAwD,EAAWxD,IAAMw+C,EAEzB,IAQIgP,MAAO9tD,EAAMiC,SAAS,CAAEoP,MAAqC,QAA7BxP,EAAKW,EAAa6O,aAA0B,IAAPxP,OAAgB,EAASA,EAAGuN,KAAK5M,GAAemB,OAAuC,QAA9BiE,EAAKpF,EAAamB,cAA2B,IAAPiE,OAAgB,EAASA,EAAGwH,KAAK5M,GAAe0X,mBAA+D,QAA1CnS,EAAKvF,EAAa0X,0BAAuC,IAAPnS,OAAgB,EAASA,EAAGqH,KAAK5M,GAAeurD,MAAOC,GAAS5hD,KAAKk4C,MAAOzyB,aAAc,CAC7WisB,gBAAiB1xC,KAAmB,aAAkB,eAAEjH,KACxD8oD,oBAaO3wC,EAb2BlR,KAAmB,aAAEq4C,kBAc5D3iB,GAAqBxkB,GAAWjO,IAAI,SAAU3M,GAAS,MAAO,CAAGA,MAAOA,EAAU,MAb5B,QAA/C2F,GAAMD,EAAKgE,KAAK1J,OAAO8iC,0BAAuC,IAAPn9B,OAAgB,EAASA,EAAG+G,KAAKhH,KAY1G,IAAuBkV,CAVvB,OArCMpY,EA4CN,SAASy9B,GAAU/iC,GACf,OAAgB,MAATA,CACX,CAIA,SAASkiC,GAAqBxkB,GAC1B,OAAOA,EACHtd,EAAMyF,cAAczF,EAAMyF,cAAc,EAXjBg9B,EAYiB,OAAdnlB,QAAoC,IAAdA,OAAuB,EAASA,EAAuB,YAf/G,SAAmBmlB,GACf,QAASA,GAAK,aAAcA,CAChC,CAEWC,CAAUD,GAAKA,EAAEt9B,UAAOD,IAYxB48B,GAAmC,OAAdxkB,QAAoC,IAAdA,OAAuB,EAASA,EAAgB,OAAI,GAAOwkB,GAAmC,OAAdxkB,QAAoC,IAAdA,OAAuB,EAASA,EAAiB,QAAI,GAAMtT,OAAO24B,IACpN,GAdV,IAA+BF,CAe/B,CACA,SAASurB,GAAS1J,GACd,IAAIziD,EACJ,OAAOyiD,EACHtkD,EAAMyF,cAAczF,EAAMyF,cAAc,CAC2C,QAA9E5D,EAAc,OAATyiD,QAA0B,IAATA,OAAkB,EAASA,EAAK9e,0BAAuC,IAAP3jC,OAAgB,EAASA,EAAGuN,KAAKk1C,IACzH0J,GAAkB,OAAT1J,QAA0B,IAATA,OAAkB,EAASA,EAAK5mC,OAAO,GAAOswC,GAAkB,OAAT1J,QAA0B,IAATA,OAAkB,EAASA,EAAK3mC,QAAQ,GAAM3T,OAAO24B,IACxJ,EACV,CAEA,IAAIurB,IAAuB,EACvBC,GAAiB,WACjB,SAASA,EAAa99C,GAClB,IACIxO,EAAI+F,EAAIG,EADR6O,EAAQxK,KAIZ,GAFAA,KAAKgiD,oBAAsB,GAC3BhiD,KAAKiiD,oBAAsB,IACtBh+C,EAAQ3N,MACT,MAAM7C,EAAQ+P,kBAAkB,IAEpC,IAAIiC,EAAMxB,EAAQwB,IAAKhB,EAAcR,EAAQQ,YAAaV,EAAUE,EAAQF,QAASzN,EAAQ2N,EAAQ3N,MAAO+hD,EAAoBp0C,EAAQo0C,kBAAmBr8C,EAAKiI,EAAQkwC,QAASA,OAAiB,IAAPn4C,GAAwBA,EAAIC,EAAKgI,EAAQi+C,mBAAoBA,OAA4B,IAAPjmD,EAAgB,EAAIA,EACjSkmD,EAAoBl+C,EAAQk+C,kBAAmBnR,EAAK/sC,EAAQk0C,mBAAoBA,OAA4B,IAAPnH,GAAuBA,EAAIznB,EAAiBtlB,EAAQslB,eAAgB+uB,EAAiBr0C,EAAQq0C,eAAgBc,EAAKn1C,EAAQ0zB,uBAAwBA,OAAgC,IAAPyhB,EAAgB9iD,EAAMqhC,uBAAyByhB,EAAIsF,EAAYz6C,EAAQy6C,UAAW0D,EAAWn+C,EAAQm+C,SAAUzD,EAAkB16C,EAAQ06C,gBAAiBt3C,EAAkBpD,EAAQoD,gBAAiBg7C,EAAsBp+C,EAAQpN,KAAMyrD,EAAyBr+C,EAAQqD,QAASi7C,EAAWt+C,EAAQs+C,SAAU9pB,EAAcx0B,EAAQw0B,aAC3jB,IAAvBziC,WAAWC,UACX4uB,EAAkB5gB,EAAS,oBAAqB,eAAgB,0CAChE4gB,EAAkB5gB,EAAS,MAAO,eAAgB,mEAClD4gB,EAAkB5gB,EAAS,cAAe,eAAgB,2EAC1D4gB,EAAkB5gB,EAAS,UAAW,eAAgB,uEACtD4gB,EAAkB5gB,EAAS,OAAQ,eAAgB,yDACnD4gB,EAAkB5gB,EAAS,UAAW,eAAgB,4DACtD4gB,EAAkB5gB,EAAS,WAAY,gBAClCA,EAAQi0C,OACc,IAAvBliD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,KAG/D,IAAIgiD,EAAOj0C,EAAQi0C,KACdA,IACDA,EACIzyC,EAAM,IAAI9B,EAAK2G,SAAS,CAAE7E,IAAKA,EAAKhB,YAAaA,EAAaV,QAASA,IAAazF,EAAK6I,WAAW64B,SAE5GhgC,KAAKk4C,KAAOA,EACZl4C,KAAK1J,MAAQA,EACb0J,KAAKmmB,sBAAwBguB,GAAW+N,EAAqB,EAC7DliD,KAAKm4C,mBAAqBA,EAC1Bn4C,KAAKupB,eAAiBA,GAAkBl2B,OAAOY,OAAO,MACtD+L,KAAKoiD,SAAWA,EAChBpiD,KAAKwiD,eAAiB5uD,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAG0sD,GAAW,CAAEE,QAAyF,QAA/EhtD,EAAkB,OAAb8sD,QAAkC,IAAbA,OAAsB,EAASA,EAASE,eAA4B,IAAPhtD,EAAgBA,EAAK0sD,SACvJrpD,IAAhCkH,KAAKwiD,eAAeC,UACpBziD,KAAKwiD,eAAeC,SAAiC,IAAvBzsD,WAAWC,SAEzCisD,GACA90C,WAAW,WAAc,OAAQ5C,EAAM2b,uBAAwB,CAAQ,EAAG+7B,GAE9EliD,KAAK6mB,WAAa7mB,KAAK6mB,WAAWle,KAAK3I,MACvCA,KAAKgF,MAAQhF,KAAKgF,MAAM2D,KAAK3I,MAC7BA,KAAK4wB,OAAS5wB,KAAK4wB,OAAOjoB,KAAK3I,MAC/BA,KAAKurB,cAAgBvrB,KAAKurB,cAAc5iB,KAAK3I,MAC7CA,KAAK0iD,WAAa1iD,KAAK0iD,WAAW/5C,KAAK3I,MACvCA,KAAK+7C,yBAA2B/7C,KAAK+7C,yBAAyBpzC,KAAK3I,MACnEA,KAAKsH,QAj/EC,SAk/ENtH,KAAKo4C,WAAa,IAAIqG,EAAW,CAC7BnoD,MAAOA,EACPhB,OAAQ0K,KACR0+C,UAAWA,EACXC,gBAAiBA,IAErB3+C,KAAKylB,aAAe,IAAIgyB,EAAa,CACjCnhD,MAAO0J,KAAK1J,MACZ4hD,KAAMl4C,KAAKk4C,KACX3uB,eAAgBvpB,KAAKupB,eACrB+uB,eAAgBA,EAChBD,kBAAmBA,EACnBF,mBAAoBA,EACpBhE,QAASA,EACT1b,cAAeA,EACfpxB,gBAAiB,CACbxQ,KAAwG,QAAjG2E,EAAyB,OAApB6L,QAAgD,IAApBA,OAA6B,EAASA,EAAgBxQ,YAAyB,IAAP2E,EAAgBA,EAAK6mD,EACrI/6C,QAA8G,QAApG3L,EAAyB,OAApB0L,QAAgD,IAApBA,OAA6B,EAASA,EAAgBC,eAA4B,IAAP3L,EAAgBA,EAAK2mD,GAE/IlK,WAAYp4C,KAAKo4C,WACjBzgB,uBAAwBA,EACxB4gB,YAAav4C,KAAKwiD,eAAeC,QAC7B,WACQj4C,EAAMm4C,gBACNn4C,EAAMm4C,eAAe,CACjBC,OAAQ,CAAC,EACTC,MAAO,CACH7qD,QAASwS,EAAMib,aAAao1B,gBAC5B5iD,UAAWuS,EAAMib,aAAa+yB,eAAiB,CAAC,GAEpDsK,0BAA2Bt4C,EAAMlU,MAAMgnC,SAAQ,IAG3D,OACE,IAENt9B,KAAKwiD,eAAeC,SACpBziD,KAAKmiD,mBACb,CAoOA,OAnOA9uD,OAAOC,eAAeyuD,EAAavgD,UAAW,wBAAyB,CACnE3J,IAAK,WACD,OAAOmI,KAAKmmB,qBAChB,EACAvtB,IAAK,SAAUpF,GACXwM,KAAKmmB,sBAAwB3yB,CACjC,EACAqB,YAAY,EACZE,cAAc,IAElBgtD,EAAavgD,UAAU2gD,kBAAoB,WACvC,GAAsB,qBAAX31C,OAAX,CAGA,IAAIu2C,EAAqBv2C,OACrBw2C,EAAiBzuD,OAAOC,IAAI,oBAC/BuuD,EAAmBC,GAChBD,EAAmBC,IAAmB,IAAIxqD,KAAKwH,MACnD+iD,EAAmBE,kBAAoBjjD,KAClC8hD,KAA+C,IAAvB9rD,WAAWC,UACpC6rD,IAAuB,EACnBt1C,OAAOhV,UACPgV,OAAO02C,MAAQ12C,OAAO2V,MACtB,mBAAmBrZ,KAAK0D,OAAO22C,SAASC,WACxCh2C,WAAW,WACP,IAAKZ,OAAO62C,gCAAiC,CACzC,IAAIC,EAAM92C,OAAOL,UACbo3C,EAAKD,GAAOA,EAAI52C,UAChB82C,OAAM,EACQ,kBAAPD,IACHA,EAAGxhD,QAAQ,YAAc,EACzByhD,EACI,uGAGCD,EAAGxhD,QAAQ,aAAe,IAC/ByhD,EACI,2EAGRA,IACuB,IAAvBxtD,WAAWC,SAAqBxC,EAAQiB,UAAUiuB,IAAI,uEAChC6gC,EAE9B,CACJ,EAAG,KAhCX,CAmCJ,EACAnwD,OAAOC,eAAeyuD,EAAavgD,UAAW,oBAAqB,CAC/D3J,IAAK,WACD,OAAOmI,KAAKylB,aAAa4yB,iBAC7B,EACAxjD,YAAY,EACZE,cAAc,IAElBgtD,EAAavgD,UAAUi1C,KAAO,WAC1Bz2C,KAAKylB,aAAagxB,MACtB,EACAsL,EAAavgD,UAAUqlB,WAAa,SAAU5iB,GAa1C,OAZIjE,KAAKupB,eAAe1C,aACpB5iB,EAAUtQ,EAAUkrB,aAAa7e,KAAKupB,eAAe1C,WAAY5iB,KAEjEjE,KAAKmmB,uBACoB,iBAAxBliB,EAAQukB,aACmB,sBAAxBvkB,EAAQukB,cACZvkB,EAAUrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEukB,YAAa,kBAE9C,IAAvBxyB,WAAWC,UACX4uB,EAAkB5gB,EAAS,kBAAmB,qBAC9C4gB,EAAkB5gB,EAAS,iBAAkB,sBAE1CjE,KAAKylB,aAAaoB,WAAW5iB,EACxC,EACA89C,EAAavgD,UAAUwD,MAAQ,SAAUf,GAerC,OAdIjE,KAAKupB,eAAevkB,QACpBf,EAAUtQ,EAAUkrB,aAAa7e,KAAKupB,eAAevkB,MAAOf,IAEhExQ,EAAQiB,UAAkC,sBAAxBuP,EAAQukB,YAAqC,IAC3DxoB,KAAKmmB,uBAAiD,iBAAxBliB,EAAQukB,cACtCvkB,EAAUrQ,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEukB,YAAa,kBAE9C,IAAvBxyB,WAAWC,UACX4uB,EAAkB5gB,EAAS,kBAAmB,gBAC9C4gB,EAAkB5gB,EAAS,8BAA+B,eAAgB,yEAC9C,YAAxBA,EAAQukB,cACe,IAAvBxyB,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,KAGxD8J,KAAKylB,aAAazgB,MAAMf,EACnC,EACA89C,EAAavgD,UAAUovB,OAAS,SAAU3sB,GAItC,OAHIjE,KAAKupB,eAAeqH,SACpB3sB,EAAUtQ,EAAUkrB,aAAa7e,KAAKupB,eAAeqH,OAAQ3sB,IAE1DjE,KAAKylB,aAAamL,OAAO3sB,EACpC,EACA89C,EAAavgD,UAAUuX,UAAY,SAAU9U,GACzC,IAAIuG,EAAQxK,KACRse,EAAKte,KAAKylB,aAAawrB,kBAC3B,OAAOjxC,KAAKylB,aACP+tB,yBAAyBvvC,GACzBhB,IAAI,SAAUF,GAAU,OAAQnP,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGkN,GAAS,CAAErI,KAAM8P,EAAMib,aAAavnB,cAAc,CACjH1G,SAAUyM,EAAQe,MAClBtK,KAAMqI,EAAOrI,KACb8tB,YAAavkB,EAAQukB,YACrBlK,GAAIA,KACA,EAChB,EACAyjC,EAAavgD,UAAU+2B,UAAY,SAAUt0B,EAASknB,GAElD,YADmB,IAAfA,IAAyBA,GAAa,GACnCnrB,KAAK1J,MAAMiiC,UAAUt0B,EAASknB,EACzC,EACA42B,EAAavgD,UAAU+pB,cAAgB,SAAUtnB,GAC7C,IAAIxO,EACJ,OAAOuK,KAAK1J,MAAMi1B,cAAc33B,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,KAAWxO,EAAK,CAAC,GAAMlB,OAAOC,IAAI,uBAAyBwL,KAAKylB,aAAagT,YAAahjC,IAChK,EACAssD,EAAavgD,UAAUs3B,aAAe,SAAU70B,EAASknB,GAErD,YADmB,IAAfA,IAAyBA,GAAa,GACnCnrB,KAAK1J,MAAMwiC,aAAa70B,EAASknB,EAC5C,EACA42B,EAAavgD,UAAUu3B,WAAa,SAAU90B,GAC1C,IAAIigB,EAAMlkB,KAAK1J,MAAMyiC,WAAW90B,GAIhC,OAH0B,IAAtBA,EAAQg/B,WACRjjC,KAAKylB,aAAaquB,mBAEf5vB,CACX,EACA69B,EAAavgD,UAAU03B,cAAgB,SAAUj1B,GAC7C,IAAIigB,EAAMlkB,KAAK1J,MAAM4iC,cAAcj1B,GAInC,OAH0B,IAAtBA,EAAQg/B,WACRjjC,KAAKylB,aAAaquB,mBAEf5vB,CACX,EACA69B,EAAavgD,UAAUiiD,wBAA0B,SAAU3sD,GACvDkJ,KAAK2iD,eAAiB7rD,CAC1B,EACAirD,EAAavgD,UAAUkiD,aAAe,SAAU/qD,GAC5C,OAAO2F,EAAKgxB,QAAQtvB,KAAKk4C,KAAMv/C,EACnC,EACAopD,EAAavgD,UAAUkhD,WAAa,WAChC,IAAIl4C,EAAQxK,KACZ,OAAOL,QAAQC,UACVmB,KAAK,WACN,OAAOyJ,EAAMib,aAAa61B,WAAW,CACjCpN,gBAAgB,GAExB,GACKntC,KAAK,WAAc,OAAOpB,QAAQyL,IAAIZ,EAAMw3C,oBAAoB/+C,IAAI,SAAUof,GAAM,OAAOA,GAAM,GAAK,GACtGthB,KAAK,WAAc,OAAOyJ,EAAMuxC,0BAA4B,EACrE,EACAgG,EAAavgD,UAAU85C,WAAa,WAChC,IAAI9wC,EAAQxK,KACZ,OAAOL,QAAQC,UACVmB,KAAK,WACN,OAAOyJ,EAAMib,aAAa61B,WAAW,CACjCpN,gBAAgB,GAExB,GACKntC,KAAK,WAAc,OAAOpB,QAAQyL,IAAIZ,EAAMy3C,oBAAoBh/C,IAAI,SAAUof,GAAM,OAAOA,GAAM,GAAK,EAC/G,EACA0/B,EAAavgD,UAAUmiD,aAAe,SAAU7sD,GAC5C,IAAI0T,EAAQxK,KAEZ,OADAA,KAAKgiD,oBAAoBxpD,KAAK1B,GACvB,WACH0T,EAAMw3C,oBAAsBx3C,EAAMw3C,oBAAoBpkD,OAAO,SAAUkwC,GAAK,OAAOA,IAAMh3C,CAAI,EACjG,CACJ,EACAirD,EAAavgD,UAAUoiD,aAAe,SAAU9sD,GAC5C,IAAI0T,EAAQxK,KAEZ,OADAA,KAAKiiD,oBAAoBzpD,KAAK1B,GACvB,WACH0T,EAAMy3C,oBAAsBz3C,EAAMy3C,oBAAoBrkD,OAAO,SAAUkwC,GAAK,OAAOA,IAAMh3C,CAAI,EACjG,CACJ,EACAirD,EAAavgD,UAAUu6C,yBAA2B,SAAUC,GACxD,OAAOh8C,KAAKylB,aAAas2B,yBAAyBC,EACtD,EACA+F,EAAavgD,UAAUw3C,eAAiB,SAAU/0C,GAC9C,IAAIhB,EAAMjD,KAAKylB,aAAauzB,eAAe/0C,GACvCjM,EAAU,GACV8lD,EAAU,GACd76C,EAAI7D,QAAQ,SAAU2D,EAAQ8gD,GAC1B7rD,EAAQQ,KAAKqrD,GACb/F,EAAQtlD,KAAKuK,EACjB,GACA,IAAIA,EAASpD,QAAQyL,IAAI0yC,GAMzB,OALA/6C,EAAO/K,QAAUA,EACjB+K,EAAO+6C,QAAUA,EACjB/6C,EAAO/B,MAAM,SAAUtC,IACI,IAAvB1I,WAAWC,SAAqBxC,EAAQiB,UAAUguB,MAAM,GAAIhkB,EAChE,GACOqE,CACX,EACAg/C,EAAavgD,UAAU+5C,qBAAuB,SAAUZ,GAEpD,YADgB,IAAZA,IAAsBA,EAAU,UAC7B36C,KAAKylB,aAAa81B,qBAAqBZ,EAClD,EACAoH,EAAavgD,UAAU87B,QAAU,SAAUnS,GACvC,OAAOnrB,KAAK1J,MAAMgnC,QAAQnS,EAC9B,EACA42B,EAAavgD,UAAUwsC,QAAU,SAAU8V,GACvC,OAAO9jD,KAAK1J,MAAM03C,QAAQ8V,EAC9B,EACA/B,EAAavgD,UAAUq9C,aAAe,SAAUH,GAC5C1+C,KAAKo4C,WAAWyG,aAAaH,EACjC,EACAqD,EAAavgD,UAAUw9C,aAAe,SAAUN,GAC5C1+C,KAAKo4C,WAAW4G,aAAaN,EACjC,EACAqD,EAAavgD,UAAUy9C,aAAe,WAClC,OAAOj/C,KAAKo4C,WAAW6G,cAC3B,EACA8C,EAAavgD,UAAUuiD,6BAA+B,SAAUpF,GAC5D3+C,KAAKo4C,WAAW0G,mBAAmBH,EACvC,EACAoD,EAAavgD,UAAUwiD,QAAU,SAAUC,GACvCjkD,KAAKk4C,KAAOl4C,KAAKylB,aAAayyB,KAAO+L,CACzC,EACA5wD,OAAOC,eAAeyuD,EAAavgD,UAAW,iBAAkB,CAC5D3J,IAAK,WACD,OAAOmI,KAAKylB,aAAa6yB,cAC7B,EACAzjD,YAAY,EACZE,cAAc,IAEXgtD,CACX,CA3ToB,GA4VpB,IAAK,IAAI7tD,MAhCkB,IAAvB8B,WAAWC,UACX8rD,GAAavgD,UAAU43B,mBAAqBmoB,IAGhDv/B,EAAYkiC,cAAoC,IAAvBluD,WAAWC,QAAoB,MAAQ,UAEhE1C,EAAQ0d,kBAAoBtd,EAAUsd,kBACtC1d,EAAQgV,WAAa5U,EAAU4U,WAC/BhV,EAAQ0qB,YAActqB,EAAUsqB,YAChC1qB,EAAQ8qB,cAAgB1qB,EAAU0qB,cAClC9qB,EAAQsrB,aAAelrB,EAAUkrB,aACjCtrB,EAAQmkC,YAAcphC,EAAMohC,YAC5BnkC,EAAQ8lC,MAAQ/iC,EAAM+iC,MACtB9lC,EAAQy5C,cAAgB12C,EAAM02C,cAC9Bz5C,EAAQ+lC,kBAAoBhjC,EAAMgjC,kBAClC/lC,EAAQkmC,wBAA0BnjC,EAAMmjC,wBACxClmC,EAAQwvC,QAAUzsC,EAAMysC,QACxBxvC,EAAQy2B,YAAc3rB,EAAO2rB,YAC7Bz2B,EAAQyhD,cAAgB32C,EAAO22C,cAC/BzhD,EAAQqU,UAAYxJ,EAAMwJ,UAC1BrU,EAAQ4wD,YAAc/lD,EAAM+lD,YAC5B5wD,EAAQ+O,iBAAmBlE,EAAMkE,iBACjC/O,EAAQ8hC,UAAYj3B,EAAMi3B,UAC1B9hC,EAAQ6wD,gBAAkBpiC,EAAYkiC,aACtC3wD,EAAQ8wD,qCAAuC3U,EAAW2U,qCAC1D9wD,EAAQ+wD,wBAA0B5U,EAAW4U,wBAC7C/wD,EAAQgxD,oCAAsC7U,EAAW6U,oCACzDhxD,EAAQixD,IAAM9U,EAAW8U,IACzBjxD,EAAQq6C,YAAc8B,EAAW9B,YACjCr6C,EAAQwuD,aAAeA,GACvBxuD,EAAQqzB,gBAAkBA,EAC1BrzB,EAAQkxD,wBAtrFR,SAAiCz7B,GAC7B,OAAyB,IAAlBA,GAAyC,IAAlBA,CAClC,EAqrFc1qB,EACA,YAANpK,IAAoBX,EAAQgO,eAAerN,MAAIX,EAAQW,IAAKoK,EAAKpK,KAEzE,IAAK,IAAIA,MAAKyP,EACA,YAANzP,IAAoBX,EAAQgO,eAAerN,MAAIX,EAAQW,IAAKyP,EAAKzP,I,uCCxzFzEb,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBE,EAAY,EAAQ,wBACpBC,EAAQ,EAAQ,wBAChB+F,EAAU,EAAQ,wBAsHtBpG,EAAQmxD,gBAvDR,SAAyBC,EAAUpsD,GAC/B,IAAI5D,EAAUf,EAAMiC,SAAS,CAAC,EAAG8uD,GAkBjC,OARAtxD,OAAOC,eAAeiF,EAAW,aAAc,CAC3C1D,YAAY,EACZrB,MAXa,SAAUkM,GAEnB/K,EADgB,oBAAT+K,EACG9L,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU+K,EAAK/K,IAGjDf,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGlB,GAAU+K,EAE9D,IAMArM,OAAOC,eAAeiF,EAAW,aAAc,CAC3C1D,YAAY,EACZrB,MAPa,WAAc,OAAQI,EAAMiC,SAAS,CAAC,EAAGlB,EAAW,IAS9D4D,CACX,EAoCAhF,EAAQuU,yBAlBR,SAAkCnQ,EAAWqN,GACzC,IAAIjC,EAASnP,EAAMiC,SAAS,CAAC,EAAG8B,GAC5BitD,EAAc,IAAIvqD,IAAIhH,OAAOkK,KAAK5F,IAYtC,OAXAgC,EAAQ4R,MAAMvG,EAAO,CACjBiP,SAAU,SAAUpW,EAAMqW,EAAMoB,GACxBA,GACgB,uBAAhBA,EAAOxd,MACP8sD,EAAYn5C,OAAO5N,EAAKhH,KAAKrD,MAErC,IAEJoxD,EAAYxlD,QAAQ,SAAUvI,UACnBkM,EAAOlM,EAClB,GACOkM,CACX,EAIAxP,EAAQqU,UAtHR,SAAmBi9C,GACf,OAAO,IAAIlxD,EAAU4U,WAAW,SAAUC,GACtCA,EAAS9J,MAAMmmD,EACnB,EACJ,EAmHAtxD,EAAQ4wD,YA/FR,SAAqBtjD,GACjB,OAAO,IAAIlN,EAAU4U,WAAW,SAAUC,GACtC3H,EACKE,KAAK,SAAUvN,GAChBgV,EAAS9I,KAAKlM,GACdgV,EAAS2B,UACb,GACKnJ,MAAMwH,EAAS9J,MAAMiK,KAAKH,GACnC,EACJ,EAuFAjV,EAAQ+O,iBArFe,SAAUjC,EAAU0C,EAAQU,GAC/C,IAAI/E,EAAQ,IAAI0C,MAAMqC,GAKtB,MAJA/E,EAAM7H,KAAO,cACb6H,EAAM2B,SAAWA,EACjB3B,EAAMiE,WAAatC,EAASgC,OAC5B3D,EAAMqE,OAASA,EACTrE,CACV,EA+EAnL,EAAQ8hC,UAnHR,SAAmBha,GACf,IAAIypC,GAAY,EAChB,OAAO,IAAInlD,QAAQ,SAAUC,EAASC,GAClCwb,EAAWtC,UAAU,CACjBrZ,KAAM,SAAUhF,GACRoqD,GACuB,IAAvB9uD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,KAGvD4uD,GAAY,EACZllD,EAAQlF,GAEhB,EACAgE,MAAOmB,GAEf,EACJ,EAoGAtM,EAAQwxD,mBAvCR,SAA4BxsD,GACxB,IAAIysD,EAAuB,CACvBrtD,UAAWY,EAAUZ,WAAa,CAAC,EACnCoN,WAAYxM,EAAUwM,YAAc,CAAC,EACrC7N,cAAeqB,EAAUrB,cACzB8N,MAAOzM,EAAUyM,OAQrB,OANKggD,EAAqB9tD,gBACtB8tD,EAAqB9tD,cACqB,kBAA/B8tD,EAAqBhgD,MACxBrR,EAAUqpB,iBAAiBgoC,EAAqBhgD,aAAUlM,EACxD,IAEPksD,CACX,EA0BAzxD,EAAQ0xD,kBA/ER,SAA2B1sD,GAQvB,IAPA,IAAI2sD,EAAmB,CACnB,QACA,gBACA,YACA,aACA,WAEK/sD,EAAK,EAAG1C,EAAKpC,OAAOkK,KAAKhF,GAAYJ,EAAK1C,EAAG4C,OAAQF,IAAM,CAChE,IAAI2N,EAAMrQ,EAAG0C,GACb,GAAI+sD,EAAiBnjD,QAAQ+D,GAAO,EAChC,MAAMrS,EAAQ+P,kBAAkB,GAAIsC,EAE5C,CACA,OAAOvN,CACX,C,uCClEAlF,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBE,EAAY,EAAQ,wBACpByK,EAAQ,EAAQ,wBACpB,EAAQ,wBACR,IAAIjI,EAAW,EAAQ,wBAEnBK,EAAsBjC,OAAOC,IAAI,uBACjCiC,EAAShD,EAAQgD,OACjBC,EAAO,IAAIP,EAASQ,KAIxB,SAASC,EAAeC,EAAMC,IAH9B,SAAiBD,GACb,OAAOJ,EAAOD,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC3E,EAESI,CAAQJ,IACTC,GAER,CAEA,SAASquD,EAAYjiD,EAAIkiD,GACrB,OAAQA,EAAUA,EAAQliD,GAAMvP,EAAU4U,WAAWy0C,IACzD,CACA,SAASqI,EAAOxpC,GACZ,MAA0B,oBAAZA,EAAyB,IAAI1U,EAAW0U,GAAWA,CACrE,CACA,SAASypC,EAAcpN,GACnB,OAAOA,EAAKztC,QAAQpS,QAAU,CAClC,CACA,IAAI8O,EAAe,WACf,SAASA,EAAWsD,GACZA,IACAzK,KAAKyK,QAAUA,EACvB,CAkFA,OAjFAtD,EAAW64B,MAAQ,WACf,OAAO,IAAI74B,EAAW,WAAc,OAAOxT,EAAU4U,WAAWy0C,IAAM,EAC1E,EACA71C,EAAW1L,KAAO,SAAUkmD,GACxB,OAAqB,IAAjBA,EAAMtpD,OACC8O,EAAW64B,QACf2hB,EAAM1+C,IAAIoiD,GAAQv7B,OAAO,SAAUxxB,EAAGitD,GAAK,OAAOjtD,EAAEwD,OAAOypD,EAAI,EAC1E,EACAp+C,EAAWvF,MAAQ,SAAUkH,EAAMwI,EAAMC,GACrC,IAEI/D,EAFAg4C,EAAWH,EAAO/zC,GAClBm0C,EAAYJ,EAAO9zC,GAAS,IAAIpK,EAAWg+C,IAgB/C,OAbI33C,EADA83C,EAAcE,IAAaF,EAAcG,GACnC,IAAIt+C,EAAW,SAAU5O,GAC3B,OAAOuQ,EAAKvQ,GACRitD,EAAS/6C,QAAQlS,IAAc5E,EAAU4U,WAAWy0C,KAClDyI,EAAUh7C,QAAQlS,IAAc5E,EAAU4U,WAAWy0C,IAC/D,GAGM,IAAI71C,EAAW,SAAU5O,EAAW6sD,GACtC,OAAOt8C,EAAKvQ,GACRitD,EAAS/6C,QAAQlS,EAAW6sD,IAAYzxD,EAAU4U,WAAWy0C,KAC3DyI,EAAUh7C,QAAQlS,EAAW6sD,IAAYzxD,EAAU4U,WAAWy0C,IACxE,GAEG3pD,OAAO0a,OAAOP,EAAK,CAAE8D,KAAMk0C,EAAUj0C,MAAOk0C,GACvD,EACAt+C,EAAWmoB,QAAU,SAAU4oB,EAAM3/C,GACjC,OAAQ2/C,EAAKztC,QAAQrM,EAAMsmD,gBAAgBnsD,EAAU5D,QAASyJ,EAAM2mD,mBAAmB3mD,EAAM6mD,kBAAkB1sD,OAAiB5E,EAAU4U,WAAWy0C,IACzJ,EACA71C,EAAWrL,OAAS,SAAUw0C,EAAOoV,GACjC,IAAIC,EAAYN,EAAO/U,GACvB,GAAIgV,EAAcK,GAEd,OADuB,IAAvB3vD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAAIyvD,GACpDA,EAEX,IACIn4C,EADAo4C,EAAWP,EAAOK,GActB,OAXIl4C,EADA83C,EAAcM,GACR,IAAIz+C,EAAW,SAAU5O,GAC3B,OAAOotD,EAAUl7C,QAAQlS,EAAW,SAAU2K,GAAM,OAAO0iD,EAASn7C,QAAQvH,IAAOvP,EAAU4U,WAAWy0C,IAAM,IAAMrpD,EAAU4U,WAAWy0C,IAC7I,GAGM,IAAI71C,EAAW,SAAU5O,EAAW6sD,GACtC,OAAQO,EAAUl7C,QAAQlS,EAAW,SAAU2K,GAC3C,OAAO0iD,EAASn7C,QAAQvH,EAAIkiD,IAAYzxD,EAAU4U,WAAWy0C,IACjE,IAAMrpD,EAAU4U,WAAWy0C,IAC/B,GAEG3pD,OAAO0a,OAAOP,EAAK,CAAE8D,KAAMq0C,EAAWp0C,MAAOq0C,GACxD,EACAz+C,EAAW3F,UAAUI,MAAQ,SAAUkH,EAAMwI,EAAMC,GAC/C,OAAOvR,KAAKlE,OAAOqL,EAAWvF,MAAMkH,EAAMwI,EAAMC,GAAS,IAAIpK,EAAWg+C,IAC5E,EACAh+C,EAAW3F,UAAU1F,OAAS,SAAU4D,GACpC,OAAOyH,EAAWrL,OAAOkE,KAAMN,EACnC,EACAyH,EAAW3F,UAAUiJ,QAAU,SAAUlS,EAAW6sD,GAChD,MAAM3xD,EAAQ+P,kBAAkB,GACpC,EACA2D,EAAW3F,UAAUvC,QAAU,SAAUP,EAAO8J,GAM5C,IAL2B,IAAvBxS,WAAWC,SACXW,EAAe,UAAW,YACC,IAAvBZ,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,GAC3D,GAEAsS,GAAYA,EAAS9J,MAErB,OADA8J,EAAS9J,MAAMA,IACR,EAEX,MAAMA,CACV,EACAyI,EAAW3F,UAAUqkD,WAAa,SAAUxjC,GAKxC,OAJ2B,IAAvBrsB,WAAWC,UACY,IAAvBD,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAE3D8J,KAAKf,QAAUojB,EACRriB,IACX,EACOmH,CACX,CAvFkB,GAyFd64B,EAAQ74B,EAAW64B,MAEnBvkC,EAAO0L,EAAW1L,KAElBmG,EAAQuF,EAAWvF,MAEnB9F,EAASqL,EAAWrL,OAEpBwzB,EAAUnoB,EAAWmoB,QAEzB/7B,EAAQ4T,WAAaA,EACrB5T,EAAQuI,OAASA,EACjBvI,EAAQysC,MAAQA,EAChBzsC,EAAQ+7B,QAAUA,EAClB/7B,EAAQkI,KAAOA,EACflI,EAAQqO,MAAQA,C,uCCrIhBvO,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAII,EAAQ,EAAQ,wBACpB,EAAQ,wBACR,IAAID,EAAY,EAAQ,wBAEpBqW,EAAyBzV,SAU7B,IAUIy1B,EAAgB,SAAUzf,GAE1B,SAASyf,EAAYv0B,GACjB,IAb6ByJ,EAC7Bb,EAYI0b,EAAgBtkB,EAAGskB,cAAe4Y,EAAiBl9B,EAAGk9B,eAAgBmzB,EAAerwD,EAAGqwD,aAAc7Q,EAAex/C,EAAGw/C,aAAc8Q,EAAetwD,EAAGswD,aAAcC,EAAYvwD,EAAGuwD,UACrLx7C,EAAQD,EAAOvH,KAAKhD,KAAM+lD,IAAiB/lD,KAa/C,OAZAwK,EAAM3T,KAAO,cACb2T,EAAMuP,cAAgBA,GAAiB,GACvCvP,EAAMmoB,eAAiBA,GAAkB,GACzCnoB,EAAMs7C,aAAeA,GAAgB,GACrCt7C,EAAMyqC,aAAeA,GAAgB,KACrCzqC,EAAM/G,QAAUsiD,IApBa7mD,EAoBwBsL,EAnBrDnM,EAASzK,EAAMyF,cAAczF,EAAMyF,cAAczF,EAAMyF,cAAc,GAAI6F,EAAI6a,eAAe,GAAO7a,EAAI4mD,cAAc,GAAO5mD,EAAIyzB,gBAAgB,GAChJzzB,EAAI+1C,cACJ52C,EAAO7F,KAAK0G,EAAI+1C,cACZ52C,EACH4E,IAAI,SAAU/D,GACf,OAAQvL,EAAUiZ,gBAAgB1N,IAAQA,EAAIuE,SAAY,0BAC9D,GACK8C,KAAK,OAaNiE,EAAMw7C,UAAYA,EAClBx7C,EAAMy7C,MACFryD,EAAMyF,cAAczF,EAAMyF,cAAczF,EAAMyF,cAAc,CACxD47C,GACAl7B,GAAiB,IAAK,GAAQ4Y,GAAkB,IAAK,GAAQmzB,GAAgB,IAAK,GAAM/nD,KAAK,SAAUjK,GAAK,QAASA,CAAG,IAAM,KACtI0W,EAAMsM,UAAYkT,EAAYxoB,UACvBgJ,CACX,CACA,OAlBA5W,EAAM8W,UAAUsf,EAAazf,GAkBtByf,CACX,CApBmB,CAoBjB5oB,OAEF7N,EAAQy2B,YAAcA,EACtBz2B,EAAQyW,uBAAyBA,EACjCzW,EAAQ8oD,+BA3CR,SAAwCt5C,GACpC,QAAIA,EAAOgC,YACAzL,MAAMC,QAAQwJ,EAAOgC,WAAWiF,GAG/C,EAuCAzW,EAAQyhD,cAtCR,SAAuB91C,GACnB,OAAOA,EAAIqC,eAAe,gBAC9B,C,uCCfAlO,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAI8K,EAAO,EAAQ,wBACf62B,EAAQ,EAAQ,wBAIpB,IAAK,IAAIjhC,KAAKoK,EACH,YAANpK,GAAoBX,EAAQgO,eAAerN,KAAIX,EAAQW,GAAKoK,EAAKpK,IAEtE,IAAK,IAAIA,KAAKihC,EACH,YAANjhC,GAAoBX,EAAQgO,eAAerN,KAAIX,EAAQW,GAAKihC,EAAMjhC,G,uCCXvEb,OAAOC,eAAeC,EAAS,aAA/B,CAA+CC,OAAO,IAEtD,IAAIC,EAAU,EAAQ,wBAClBkB,EAAU,EAAQ,wBAClBuxD,EAAQ,EAAQ,wBAChB3uD,EAAS,EAAQ,wBACjB3D,EAAQ,EAAQ,wBAChBqvB,EAAW,EAAQ,wBACnB9sB,EAAW,EAAQ,wBAEnBK,EAAsBjC,OAAOC,IAAI,uBACjCiC,EAAShD,EAAQgD,OACjBC,EAAO,IAAIP,EAASQ,KAWxB,SAASkuB,EAAkB5gB,EAASpN,EAAMiuB,EAAUC,QACzB,IAAnBA,IAA6BA,EAAiB,8BAOtD,SAAwBluB,EAAMC,IAlB9B,SAAiBD,GACb,OAAOJ,EAAOD,KAAyBE,EAAKK,YAAc,IAAIC,SAASH,EAC3E,EAiBSI,CAAQJ,IACTC,GAER,CAVIF,CAAeC,EAAM,WACbA,KAAQoN,IACe,IAAvBjO,WAAWC,SAAqBxC,EAAQiB,UAAUwB,KAAK,IAAK4uB,EAAUjuB,EAAMkuB,EAEpF,EACJ,CAOA,IAAIK,EAAgB7wB,OAAOC,IAAI,wBAW/B,IAAI2xD,EAAwB,SAAU7wD,GAYlC,OAAOjC,OAAO0a,OAXd,SAAsB/I,EAAOf,QACT,IAAZA,IAAsBA,EAAU5Q,OAAOY,OAAO,OAClD4wB,EAAkB5gB,EAAS,kBAAmB,gBAC9C,IAAIgoB,EApCZ,SAA0Bp1B,GAEtB,IADA,IAAIoC,EAAO,GACFd,EAAK,EAAGA,EAAKe,UAAUb,OAAQF,IACpCc,EAAKd,EAAK,GAAKe,UAAUf,GAE7B,OAAOzB,EAAKyC,UAAUC,MAAM1C,EAAM9C,EAAMyF,cAAc,CAACC,MAAMC,QAAQ1C,GAAQA,EAAO,CAACA,IAAQoC,GAAM,GACvG,CA8BuBO,CAAiB,kBAAmB,WAC/C,IAAI/D,EAAI+F,EACR,OAAO,IAAIynB,EAASkQ,uBAAuB79B,EAAOuxB,WAAWjzB,EAAMiC,SAASjC,EAAMiC,SAAS,CAAC,EAAGoO,GAAU,CAAEe,MAAOA,KAAW,CACzH4uB,qBAAqH,QAA9Fp4B,EAA4C,QAAtC/F,EAAKH,EAAOi0B,eAAe4L,aAA0B,IAAP1/B,OAAgB,EAASA,EAAG2/B,gBAA6B,IAAP55B,OAAgB,EAASA,EAAGo4B,sBAEjK,GACA,OAAO3Q,EAASiK,aAAajB,EACjC,EACmC,CAC/BoJ,UAAW,SAAUpJ,GACjB,OAAOA,EAASoJ,WACpB,GAER,EAUA,IAAK,IAAInhC,KARTX,EAAQ0B,eAAiBN,EAAQM,eACjC1B,EAAQiC,eAAiBb,EAAQa,eACjCjC,EAAQkB,iBAAmBE,EAAQF,iBACnClB,EAAQwC,mBAAqBpB,EAAQoB,mBACrCxC,EAAQ8C,aAAekB,EAAOlB,aAC9B9C,EAAQ2D,cAAgBK,EAAOL,cAC/B3D,EAAQgE,OAASA,EAAOA,OACxBhE,EAAQ6yD,qBA7BR,SAA8B9wD,GAC1B,OARcgwB,EAQE,uBARQC,EAQgB4gC,EAPpC1gC,EAO2DnwB,EAPb,aAC9CowB,EAAWD,GAAgBA,EAAaL,IACxCO,EAAUD,GAAYA,EAASJ,IAClBK,EAAQJ,GAAWA,GAImCjwB,GAR3E,IAAkBgwB,EAAUC,EACpBE,EACAC,EACAC,CAMR,EA4BcugC,EACA,YAANhyD,GAAoBX,EAAQgO,eAAerN,KAAIX,EAAQW,GAAKgyD,EAAMhyD,G,uCC1E1E,IAAIN,EAAQ,EAAQ,wBAChB0K,EAAO,EAAQ,wBACf3K,EAAY,EAAQ,wBA8BxBJ,EAAQ,EA5BR,SAAoB8yD,GAChB,OAAO,IAAI/nD,EAAK6I,WAAW,SAAU5O,EAAW6sD,GAC5C,IAAI36C,EAAU7W,EAAMoT,OAAOzO,EAAW,IACtC,OAAO,IAAI5E,EAAU4U,WAAW,SAAUC,GACtC,IAAI89C,EACA1qC,GAAS,EAcb,OAbAjc,QAAQC,QAAQ6K,GACX1J,KAAK,SAAUwlD,GAAO,OAAOF,EAAOE,EAAKhuD,EAAUiN,aAAe,GAClEzE,KAAKxI,EAAUqQ,YACf7H,KAAK,WACF6a,IAEJ0qC,EAASlB,EAAQ7sD,GAAWwgB,UAAU,CAClCrZ,KAAM8I,EAAS9I,KAAKiJ,KAAKH,GACzB9J,MAAO8J,EAAS9J,MAAMiK,KAAKH,GAC3B2B,SAAU3B,EAAS2B,SAASxB,KAAKH,KAEzC,GACKxH,MAAMwH,EAAS9J,MAAMiK,KAAKH,IACxB,WACHoT,GAAS,EACL0qC,GACAA,EAAOxtC,aACf,CACJ,EACJ,EACJ,C,uCC9BA,IAAIllB,EAAQ,EAAQ,wBAChByK,EAAS,EAAQ,wBACjB1K,EAAY,EAAQ,wBACpB2K,EAAO,EAAQ,wBAEnB,SAASW,EAAQunD,GACb,OAAO,IAAIloD,EAAK6I,WAAW,SAAU5O,EAAW6sD,GAC5C,OAAO,IAAIzxD,EAAU4U,WAAW,SAAUC,GACtC,IAAImQ,EACA8tC,EACAC,EACJ,IACI/tC,EAAMysC,EAAQ7sD,GAAWwgB,UAAU,CAC/BrZ,KAAM,SAAUqD,GACRA,EAAO1E,OACPqoD,EAAgBF,EAAa,CACzBzsC,cAAehX,EAAO1E,OACtBgC,SAAU0C,EACVxK,UAAWA,EACX6sD,QAASA,IAGR/mD,EAAOg+C,+BAA+Bt5C,KAC3C2jD,EAAgBF,EAAa,CACzB7zB,eAAgB5vB,EAAOgC,WAAW1G,EAAO2L,wBACzC3J,SAAU0C,EACVxK,UAAWA,EACX6sD,QAASA,KAGbsB,EACAD,EAAaC,EAAc3tC,UAAU,CACjCrZ,KAAM8I,EAAS9I,KAAKiJ,KAAKH,GACzB9J,MAAO8J,EAAS9J,MAAMiK,KAAKH,GAC3B2B,SAAU3B,EAAS2B,SAASxB,KAAKH,KAIzCA,EAAS9I,KAAKqD,EAClB,EACArE,MAAO,SAAUu2C,IACbyR,EAAgBF,EAAa,CACzBjuD,UAAWA,EACX08C,aAAcA,EACdl7B,cAAgBk7B,GACZA,EAAalyC,QACbkyC,EAAalyC,OAAO1E,aACpB,EACJ+mD,QAASA,KAGTqB,EAAaC,EAAc3tC,UAAU,CACjCrZ,KAAM8I,EAAS9I,KAAKiJ,KAAKH,GACzB9J,MAAO8J,EAAS9J,MAAMiK,KAAKH,GAC3B2B,SAAU3B,EAAS2B,SAASxB,KAAKH,KAIzCA,EAAS9J,MAAMu2C,EACnB,EACA9qC,SAAU,WACDu8C,GACDl+C,EAAS2B,SAASxB,KAAKH,EAAvBA,EAER,GAER,CACA,MAAO1U,GACH0yD,EAAa,CAAEvR,aAAcnhD,EAAGyE,UAAWA,EAAW6sD,QAASA,IAC/D58C,EAAS9J,MAAM5K,EACnB,CACA,OAAO,WACC6kB,GACAA,EAAIG,cACJ2tC,GACA9tC,EAAIG,aACZ,CACJ,EACJ,EACJ,EACkB,SAAUvO,GAExB,SAASo8C,EAAUH,GACf,IAAIh8C,EAAQD,EAAOvH,KAAKhD,OAASA,KAEjC,OADAwK,EAAM0tC,KAAOj5C,EAAQunD,GACdh8C,CACX,CALA5W,EAAM8W,UAAUi8C,EAAWp8C,GAM3Bo8C,EAAUnlD,UAAUiJ,QAAU,SAAUlS,EAAW6sD,GAC/C,OAAOplD,KAAKk4C,KAAKztC,QAAQlS,EAAW6sD,EACxC,CAEJ,EAXiB,CAWf9mD,EAAK6I,YAGP5T,EAAQ,GAAU0L,C","sources":["webpack://garage-app/./node_modules/@apollo/client/react/context/context.cjs","webpack://garage-app/./node_modules/@apollo/client/react/parser/parser.cjs","webpack://garage-app/./node_modules/@apollo/client/masking/masking.cjs","webpack://garage-app/./node_modules/@apollo/client/link/http/http.cjs","webpack://garage-app/./node_modules/@apollo/client/utilities/utilities.cjs","webpack://garage-app/./node_modules/@apollo/client/utilities/globals/globals.cjs","webpack://garage-app/./node_modules/@apollo/client/react/hooks/hooks.cjs","webpack://garage-app/./node_modules/@apollo/client/react/internal/internal.cjs","webpack://garage-app/./node_modules/@apollo/client/cache/cache.cjs","webpack://garage-app/./node_modules/@apollo/client/core/core.cjs","webpack://garage-app/./node_modules/@apollo/client/link/utils/utils.cjs","webpack://garage-app/./node_modules/@apollo/client/link/core/core.cjs","webpack://garage-app/./node_modules/@apollo/client/errors/errors.cjs","webpack://garage-app/./node_modules/@apollo/client/main.cjs","webpack://garage-app/./node_modules/@apollo/client/react/react.cjs","webpack://garage-app/./node_modules/@apollo/client/link/context/context.cjs","webpack://garage-app/./node_modules/@apollo/client/link/error/error.cjs"],"sourcesContent":["'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar React = require('rehackt');\nvar utilities = require('../../utilities');\nvar tslib = require('tslib');\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        for (var k in e) {\n            n[k] = e[k];\n        }\n    }\n    n[\"default\"] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\n\nvar contextKey = utilities.canUseSymbol ? Symbol.for(\"__APOLLO_CONTEXT__\") : \"__APOLLO_CONTEXT__\";\nfunction getApolloContext() {\n    globals.invariant(\"createContext\" in React__namespace, 69);\n    var context = React__namespace.createContext[contextKey];\n    if (!context) {\n        Object.defineProperty(React__namespace.createContext, contextKey, {\n            value: (context = React__namespace.createContext({})),\n            enumerable: false,\n            writable: false,\n            configurable: true,\n        });\n        context.displayName = \"ApolloContext\";\n    }\n    return context;\n}\nvar resetApolloContext = function () {\n    if (globalThis.__DEV__ !== false) {\n        globalThis.__DEV__ !== false && globals.invariant.warn(70);\n    }\n    return getApolloContext();\n};\n\nvar ApolloConsumer = function (props) {\n    var ApolloContext = getApolloContext();\n    return (React__namespace.createElement(ApolloContext.Consumer, null, function (context) {\n        globals.invariant(context && context.client, 68);\n        return props.children(context.client);\n    }));\n};\n\nvar ApolloProvider = function (_a) {\n    var client = _a.client, children = _a.children;\n    var ApolloContext = getApolloContext();\n    var parentContext = React__namespace.useContext(ApolloContext);\n    var context = React__namespace.useMemo(function () {\n        return tslib.__assign(tslib.__assign({}, parentContext), { client: client || parentContext.client });\n    }, [parentContext, client]);\n    globals.invariant(context.client, 71);\n    return (React__namespace.createElement(ApolloContext.Provider, { value: context }, children));\n};\n\nexports.ApolloConsumer = ApolloConsumer;\nexports.ApolloProvider = ApolloProvider;\nexports.getApolloContext = getApolloContext;\nexports.resetApolloContext = resetApolloContext;\n//# sourceMappingURL=context.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar utilities = require('../../utilities');\nvar tslib = require('tslib');\nvar optimism = require('optimism');\n\nvar globalCaches = {};\nfunction registerGlobalCache(name, getSize) {\n    globalCaches[name] = getSize;\n}\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nexports.DocumentType = void 0;\n(function (DocumentType) {\n    DocumentType[DocumentType[\"Query\"] = 0] = \"Query\";\n    DocumentType[DocumentType[\"Mutation\"] = 1] = \"Mutation\";\n    DocumentType[DocumentType[\"Subscription\"] = 2] = \"Subscription\";\n})(exports.DocumentType || (exports.DocumentType = {}));\nvar cache;\nfunction operationName(type) {\n    var name;\n    switch (type) {\n        case exports.DocumentType.Query:\n            name = \"Query\";\n            break;\n        case exports.DocumentType.Mutation:\n            name = \"Mutation\";\n            break;\n        case exports.DocumentType.Subscription:\n            name = \"Subscription\";\n            break;\n    }\n    return name;\n}\nfunction parser(document) {\n    warnDeprecated(\"parser\", function () {\n        globalThis.__DEV__ !== false && globals.invariant.warn(94);\n    });\n    if (!cache) {\n        cache = new utilities.AutoCleanedWeakCache(utilities.cacheSizes.parser || 1000 );\n    }\n    var cached = cache.get(document);\n    if (cached)\n        return cached;\n    var variables, type, name;\n    globals.invariant(!!document && !!document.kind, 95, document);\n    var fragments = [];\n    var queries = [];\n    var mutations = [];\n    var subscriptions = [];\n    for (var _i = 0, _a = document.definitions; _i < _a.length; _i++) {\n        var x = _a[_i];\n        if (x.kind === \"FragmentDefinition\") {\n            fragments.push(x);\n            continue;\n        }\n        if (x.kind === \"OperationDefinition\") {\n            switch (x.operation) {\n                case \"query\":\n                    queries.push(x);\n                    break;\n                case \"mutation\":\n                    mutations.push(x);\n                    break;\n                case \"subscription\":\n                    subscriptions.push(x);\n                    break;\n            }\n        }\n    }\n    globals.invariant(!fragments.length ||\n        queries.length ||\n        mutations.length ||\n        subscriptions.length, 96);\n    globals.invariant(\n        queries.length + mutations.length + subscriptions.length <= 1,\n        97,\n        document,\n        queries.length,\n        subscriptions.length,\n        mutations.length\n    );\n    type = queries.length ? exports.DocumentType.Query : exports.DocumentType.Mutation;\n    if (!queries.length && !mutations.length)\n        type = exports.DocumentType.Subscription;\n    var definitions = queries.length ? queries\n        : mutations.length ? mutations\n            : subscriptions;\n    globals.invariant(definitions.length === 1, 98, document, definitions.length);\n    var definition = definitions[0];\n    variables = definition.variableDefinitions || [];\n    if (definition.name && definition.name.kind === \"Name\") {\n        name = definition.name.value;\n    }\n    else {\n        name = \"data\";\n    }\n    var payload = { name: name, type: type, variables: variables };\n    cache.set(document, payload);\n    return payload;\n}\nparser.resetCache = function () {\n    cache = undefined;\n};\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"parser\", function () { return (cache ? cache.size : 0); });\n}\nfunction verifyDocumentType(document, type) {\n    var operation = muteDeprecations(\"parser\", parser, [document]);\n    var requiredOperationName = operationName(type);\n    var usedOperationName = operationName(operation.type);\n    globals.invariant(\n        operation.type === type,\n        99,\n        requiredOperationName,\n        requiredOperationName,\n        usedOperationName\n    );\n}\n\nexports.operationName = operationName;\nexports.parser = parser;\nexports.verifyDocumentType = verifyDocumentType;\n//# sourceMappingURL=parser.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar optimism = require('optimism');\nvar globals = require('../utilities/globals');\nvar utilities = require('../utilities');\nvar graphql = require('graphql');\nvar equal = require('@wry/equality');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e[\"default\"] : e; }\n\nvar equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);\n\nvar MapImpl = utilities.canUseWeakMap ? WeakMap : Map;\nvar SetImpl = utilities.canUseWeakSet ? WeakSet : Set;\nvar disableWarningsSlot = new optimism.Slot();\nvar issuedWarning = false;\nfunction warnOnImproperCacheImplementation() {\n    if (!issuedWarning) {\n        issuedWarning = true;\n        globalThis.__DEV__ !== false && globals.invariant.warn(64);\n    }\n}\n\nfunction maskDefinition(data, selectionSet, context) {\n    return disableWarningsSlot.withValue(true, function () {\n        var masked = maskSelectionSet(data, selectionSet, context, false);\n        if (Object.isFrozen(data)) {\n            utilities.maybeDeepFreeze(masked);\n        }\n        return masked;\n    });\n}\nfunction getMutableTarget(data, mutableTargets) {\n    if (mutableTargets.has(data)) {\n        return mutableTargets.get(data);\n    }\n    var mutableTarget = Array.isArray(data) ? [] : Object.create(null);\n    mutableTargets.set(data, mutableTarget);\n    return mutableTarget;\n}\nfunction maskSelectionSet(data, selectionSet, context, migration, path) {\n    var _a;\n    var knownChanged = context.knownChanged;\n    var memo = getMutableTarget(data, context.mutableTargets);\n    if (Array.isArray(data)) {\n        for (var _i = 0, _b = Array.from(data.entries()); _i < _b.length; _i++) {\n            var _c = _b[_i], index = _c[0], item = _c[1];\n            if (item === null) {\n                memo[index] = null;\n                continue;\n            }\n            var masked = maskSelectionSet(item, selectionSet, context, migration, globalThis.__DEV__ !== false ? \"\".concat(path || \"\", \"[\").concat(index, \"]\") : void 0);\n            if (knownChanged.has(masked)) {\n                knownChanged.add(memo);\n            }\n            memo[index] = masked;\n        }\n        return knownChanged.has(memo) ? memo : data;\n    }\n    for (var _d = 0, _e = selectionSet.selections; _d < _e.length; _d++) {\n        var selection = _e[_d];\n        var value = void 0;\n        if (migration) {\n            knownChanged.add(memo);\n        }\n        if (selection.kind === graphql.Kind.FIELD) {\n            var keyName = utilities.resultKeyNameFromField(selection);\n            var childSelectionSet = selection.selectionSet;\n            value = memo[keyName] || data[keyName];\n            if (value === void 0) {\n                continue;\n            }\n            if (childSelectionSet && value !== null) {\n                var masked = maskSelectionSet(data[keyName], childSelectionSet, context, migration, globalThis.__DEV__ !== false ? \"\".concat(path || \"\", \".\").concat(keyName) : void 0);\n                if (knownChanged.has(masked)) {\n                    value = masked;\n                }\n            }\n            if (!(globalThis.__DEV__ !== false)) {\n                memo[keyName] = value;\n            }\n            if (globalThis.__DEV__ !== false) {\n                if (migration &&\n                    keyName !== \"__typename\" &&\n                    !((_a = Object.getOwnPropertyDescriptor(memo, keyName)) === null || _a === void 0 ? void 0 : _a.value)) {\n                    Object.defineProperty(memo, keyName, getAccessorWarningDescriptor(keyName, value, path || \"\", context.operationName, context.operationType));\n                }\n                else {\n                    delete memo[keyName];\n                    memo[keyName] = value;\n                }\n            }\n        }\n        if (selection.kind === graphql.Kind.INLINE_FRAGMENT &&\n            (!selection.typeCondition ||\n                context.cache.fragmentMatches(selection, data.__typename))) {\n            value = maskSelectionSet(data, selection.selectionSet, context, migration, path);\n        }\n        if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {\n            var fragmentName = selection.name.value;\n            var fragment = context.fragmentMap[fragmentName] ||\n                (context.fragmentMap[fragmentName] =\n                    context.cache.lookupFragment(fragmentName));\n            globals.invariant(fragment, 59, fragmentName);\n            var mode = utilities.getFragmentMaskMode(selection);\n            if (mode !== \"mask\") {\n                value = maskSelectionSet(data, fragment.selectionSet, context, mode === \"migrate\", path);\n            }\n        }\n        if (knownChanged.has(value)) {\n            knownChanged.add(memo);\n        }\n    }\n    if (\"__typename\" in data && !(\"__typename\" in memo)) {\n        memo.__typename = data.__typename;\n    }\n    if (Object.keys(memo).length !== Object.keys(data).length) {\n        knownChanged.add(memo);\n    }\n    return knownChanged.has(memo) ? memo : data;\n}\nfunction getAccessorWarningDescriptor(fieldName, value, path, operationName, operationType) {\n    var getValue = function () {\n        if (disableWarningsSlot.getValue()) {\n            return value;\n        }\n        globalThis.__DEV__ !== false && globals.invariant.warn(60, operationName ?\n            \"\".concat(operationType, \" '\").concat(operationName, \"'\")\n            : \"anonymous \".concat(operationType), \"\".concat(path, \".\").concat(fieldName).replace(/^\\./, \"\"));\n        getValue = function () { return value; };\n        return value;\n    };\n    return {\n        get: function () {\n            return getValue();\n        },\n        set: function (newValue) {\n            getValue = function () { return newValue; };\n        },\n        enumerable: true,\n        configurable: true,\n    };\n}\n\nfunction maskFragment(data, document, cache, fragmentName) {\n    if (!cache.fragmentMatches) {\n        if (globalThis.__DEV__ !== false) {\n            warnOnImproperCacheImplementation();\n        }\n        return data;\n    }\n    var fragments = document.definitions.filter(function (node) {\n        return node.kind === graphql.Kind.FRAGMENT_DEFINITION;\n    });\n    if (typeof fragmentName === \"undefined\") {\n        globals.invariant(fragments.length === 1, 61, fragments.length);\n        fragmentName = fragments[0].name.value;\n    }\n    var fragment = fragments.find(function (fragment) { return fragment.name.value === fragmentName; });\n    globals.invariant(!!fragment, 62, fragmentName);\n    if (data == null) {\n        return data;\n    }\n    if (equal__default(data, {})) {\n        return data;\n    }\n    return maskDefinition(data, fragment.selectionSet, {\n        operationType: \"fragment\",\n        operationName: fragment.name.value,\n        fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(document)),\n        cache: cache,\n        mutableTargets: new MapImpl(),\n        knownChanged: new SetImpl(),\n    });\n}\n\nfunction maskOperation(data, document, cache) {\n    var _a;\n    if (!cache.fragmentMatches) {\n        if (globalThis.__DEV__ !== false) {\n            warnOnImproperCacheImplementation();\n        }\n        return data;\n    }\n    var definition = utilities.getOperationDefinition(document);\n    globals.invariant(definition, 63);\n    if (data == null) {\n        return data;\n    }\n    return maskDefinition(data, definition.selectionSet, {\n        operationType: definition.operation,\n        operationName: (_a = definition.name) === null || _a === void 0 ? void 0 : _a.value,\n        fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(document)),\n        cache: cache,\n        mutableTargets: new MapImpl(),\n        knownChanged: new SetImpl(),\n    });\n}\n\nexports.disableWarningsSlot = disableWarningsSlot;\nexports.maskFragment = maskFragment;\nexports.maskOperation = maskOperation;\n//# sourceMappingURL=masking.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar tslib = require('tslib');\nvar utilities = require('../../utilities');\nvar utils = require('../utils');\nvar errors = require('../../errors');\nvar core = require('../core');\n\nfunction asyncIterator(source) {\n    var _a;\n    var iterator = source[Symbol.asyncIterator]();\n    return _a = {\n            next: function () {\n                return iterator.next();\n            }\n        },\n        _a[Symbol.asyncIterator] = function () {\n            return this;\n        },\n        _a;\n}\n\nfunction nodeStreamIterator(stream) {\n    var cleanup = null;\n    var error = null;\n    var done = false;\n    var data = [];\n    var waiting = [];\n    function onData(chunk) {\n        if (error)\n            return;\n        if (waiting.length) {\n            var shiftedArr = waiting.shift();\n            if (Array.isArray(shiftedArr) && shiftedArr[0]) {\n                return shiftedArr[0]({ value: chunk, done: false });\n            }\n        }\n        data.push(chunk);\n    }\n    function onError(err) {\n        error = err;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[1](err);\n        });\n        !cleanup || cleanup();\n    }\n    function onEnd() {\n        done = true;\n        var all = waiting.slice();\n        all.forEach(function (pair) {\n            pair[0]({ value: undefined, done: true });\n        });\n        !cleanup || cleanup();\n    }\n    cleanup = function () {\n        cleanup = null;\n        stream.removeListener(\"data\", onData);\n        stream.removeListener(\"error\", onError);\n        stream.removeListener(\"end\", onEnd);\n        stream.removeListener(\"finish\", onEnd);\n        stream.removeListener(\"close\", onEnd);\n    };\n    stream.on(\"data\", onData);\n    stream.on(\"error\", onError);\n    stream.on(\"end\", onEnd);\n    stream.on(\"finish\", onEnd);\n    stream.on(\"close\", onEnd);\n    function getNext() {\n        return new Promise(function (resolve, reject) {\n            if (error)\n                return reject(error);\n            if (data.length)\n                return resolve({ value: data.shift(), done: false });\n            if (done)\n                return resolve({ value: undefined, done: true });\n            waiting.push([resolve, reject]);\n        });\n    }\n    var iterator = {\n        next: function () {\n            return getNext();\n        },\n    };\n    if (utilities.canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n\nfunction promiseIterator(promise) {\n    var resolved = false;\n    var iterator = {\n        next: function () {\n            if (resolved)\n                return Promise.resolve({\n                    value: undefined,\n                    done: true,\n                });\n            resolved = true;\n            return new Promise(function (resolve, reject) {\n                promise\n                    .then(function (value) {\n                    resolve({ value: value, done: false });\n                })\n                    .catch(reject);\n            });\n        },\n    };\n    if (utilities.canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n\nfunction readerIterator(reader) {\n    var iterator = {\n        next: function () {\n            return reader.read();\n        },\n    };\n    if (utilities.canUseAsyncIteratorSymbol) {\n        iterator[Symbol.asyncIterator] = function () {\n            return this;\n        };\n    }\n    return iterator;\n}\n\nfunction isNodeResponse(value) {\n    return !!value.body;\n}\nfunction isReadableStream(value) {\n    return !!value.getReader;\n}\nfunction isAsyncIterableIterator(value) {\n    return !!(utilities.canUseAsyncIteratorSymbol &&\n        value[Symbol.asyncIterator]);\n}\nfunction isStreamableBlob(value) {\n    return !!value.stream;\n}\nfunction isBlob(value) {\n    return !!value.arrayBuffer;\n}\nfunction isNodeReadableStream(value) {\n    return !!value.pipe;\n}\nfunction responseIterator(response) {\n    var body = response;\n    if (isNodeResponse(response))\n        body = response.body;\n    if (isAsyncIterableIterator(body))\n        return asyncIterator(body);\n    if (isReadableStream(body))\n        return readerIterator(body.getReader());\n    if (isStreamableBlob(body)) {\n        return readerIterator(body.stream().getReader());\n    }\n    if (isBlob(body))\n        return promiseIterator(body.arrayBuffer());\n    if (isNodeReadableStream(body))\n        return nodeStreamIterator(body);\n    throw new Error(\"Unknown body type for responseIterator. Please pass a streamable response.\");\n}\n\nfunction isNonNullObject(obj) {\n    return obj !== null && typeof obj === \"object\";\n}\n\nfunction isApolloPayloadResult(value) {\n    return isNonNullObject(value) && \"payload\" in value;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction readMultipartBody(response, nextValue) {\n    return tslib.__awaiter(this, void 0, void 0, function () {\n        var decoder, contentType, delimiter, boundaryVal, boundary, buffer, iterator, running, _a, value, done, chunk, searchFrom, bi, message, i, headers, contentType_1, body, result, next;\n        var _b, _c;\n        var _d;\n        return tslib.__generator(this, function (_e) {\n            switch (_e.label) {\n                case 0:\n                    if (TextDecoder === undefined) {\n                        throw new Error(\"TextDecoder must be defined in the environment: please import a polyfill.\");\n                    }\n                    decoder = new TextDecoder(\"utf-8\");\n                    contentType = (_d = response.headers) === null || _d === void 0 ? void 0 : _d.get(\"content-type\");\n                    delimiter = \"boundary=\";\n                    boundaryVal = (contentType === null || contentType === void 0 ? void 0 : contentType.includes(delimiter)) ?\n                        contentType === null || contentType === void 0 ? void 0 : contentType.substring((contentType === null || contentType === void 0 ? void 0 : contentType.indexOf(delimiter)) + delimiter.length).replace(/['\"]/g, \"\").replace(/\\;(.*)/gm, \"\").trim()\n                        : \"-\";\n                    boundary = \"\\r\\n--\".concat(boundaryVal);\n                    buffer = \"\";\n                    iterator = responseIterator(response);\n                    running = true;\n                    _e.label = 1;\n                case 1:\n                    if (!running) return [3 , 3];\n                    return [4 , iterator.next()];\n                case 2:\n                    _a = _e.sent(), value = _a.value, done = _a.done;\n                    chunk = typeof value === \"string\" ? value : decoder.decode(value);\n                    searchFrom = buffer.length - boundary.length + 1;\n                    running = !done;\n                    buffer += chunk;\n                    bi = buffer.indexOf(boundary, searchFrom);\n                    while (bi > -1) {\n                        message = void 0;\n                        _b = [\n                            buffer.slice(0, bi),\n                            buffer.slice(bi + boundary.length),\n                        ], message = _b[0], buffer = _b[1];\n                        i = message.indexOf(\"\\r\\n\\r\\n\");\n                        headers = parseHeaders(message.slice(0, i));\n                        contentType_1 = headers[\"content-type\"];\n                        if (contentType_1 &&\n                            contentType_1.toLowerCase().indexOf(\"application/json\") === -1) {\n                            throw new Error(\"Unsupported patch content type: application/json is required.\");\n                        }\n                        body = message.slice(i);\n                        if (body) {\n                            result = parseJsonBody(response, body);\n                            if (Object.keys(result).length > 1 ||\n                                \"data\" in result ||\n                                \"incremental\" in result ||\n                                \"errors\" in result ||\n                                \"payload\" in result) {\n                                if (isApolloPayloadResult(result)) {\n                                    next = {};\n                                    if (\"payload\" in result) {\n                                        if (Object.keys(result).length === 1 && result.payload === null) {\n                                            return [2 ];\n                                        }\n                                        next = tslib.__assign({}, result.payload);\n                                    }\n                                    if (\"errors\" in result) {\n                                        next = tslib.__assign(tslib.__assign({}, next), { extensions: tslib.__assign(tslib.__assign({}, (\"extensions\" in next ? next.extensions : null)), (_c = {}, _c[errors.PROTOCOL_ERRORS_SYMBOL] = result.errors, _c)) });\n                                    }\n                                    nextValue(next);\n                                }\n                                else {\n                                    nextValue(result);\n                                }\n                            }\n                            else if (\n                            Object.keys(result).length === 1 &&\n                                \"hasNext\" in result &&\n                                !result.hasNext) {\n                                return [2 ];\n                            }\n                        }\n                        bi = buffer.indexOf(boundary);\n                    }\n                    return [3 , 1];\n                case 3: return [2 ];\n            }\n        });\n    });\n}\nfunction parseHeaders(headerText) {\n    var headersInit = {};\n    headerText.split(\"\\n\").forEach(function (line) {\n        var i = line.indexOf(\":\");\n        if (i > -1) {\n            var name_1 = line.slice(0, i).trim().toLowerCase();\n            var value = line.slice(i + 1).trim();\n            headersInit[name_1] = value;\n        }\n    });\n    return headersInit;\n}\nfunction parseJsonBody(response, bodyText) {\n    if (response.status >= 300) {\n        var getResult = function () {\n            try {\n                return JSON.parse(bodyText);\n            }\n            catch (err) {\n                return bodyText;\n            }\n        };\n        utils.throwServerError(response, getResult(), \"Response not successful: Received status code \".concat(response.status));\n    }\n    try {\n        return JSON.parse(bodyText);\n    }\n    catch (err) {\n        var parseError = err;\n        parseError.name = \"ServerParseError\";\n        parseError.response = response;\n        parseError.statusCode = response.status;\n        parseError.bodyText = bodyText;\n        throw parseError;\n    }\n}\nfunction handleError(err, observer) {\n    if (err.result && err.result.errors && err.result.data) {\n        observer.next(err.result);\n    }\n    observer.error(err);\n}\nfunction parseAndCheckHttpResponse(operations) {\n    return function (response) {\n        return response\n            .text()\n            .then(function (bodyText) { return parseJsonBody(response, bodyText); })\n            .then(function (result) {\n            if (!Array.isArray(result) &&\n                !hasOwnProperty.call(result, \"data\") &&\n                !hasOwnProperty.call(result, \"errors\")) {\n                utils.throwServerError(response, result, \"Server response was missing for query '\".concat(Array.isArray(operations) ?\n                    operations.map(function (op) { return op.operationName; })\n                    : operations.operationName, \"'.\"));\n            }\n            return result;\n        });\n    };\n}\n\nvar serializeFetchParameter = function (p, label) {\n    var serialized;\n    try {\n        serialized = JSON.stringify(p);\n    }\n    catch (e) {\n        var parseError = globals.newInvariantError(54, label, e.message);\n        parseError.parseError = e;\n        throw parseError;\n    }\n    return serialized;\n};\n\nvar defaultHttpOptions = {\n    includeQuery: true,\n    includeExtensions: false,\n    preserveHeaderCase: false,\n};\nvar defaultHeaders = {\n    accept: \"*/*\",\n    \"content-type\": \"application/json\",\n};\nvar defaultOptions = {\n    method: \"POST\",\n};\nvar fallbackHttpConfig = {\n    http: defaultHttpOptions,\n    headers: defaultHeaders,\n    options: defaultOptions,\n};\nvar defaultPrinter = function (ast, printer) { return printer(ast); };\nfunction selectHttpOptionsAndBody(operation, fallbackConfig) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    configs.unshift(fallbackConfig);\n    return selectHttpOptionsAndBodyInternal.apply(void 0, tslib.__spreadArray([operation,\n        defaultPrinter], configs, false));\n}\nfunction selectHttpOptionsAndBodyInternal(operation, printer) {\n    var configs = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        configs[_i - 2] = arguments[_i];\n    }\n    var options = {};\n    var http = {};\n    configs.forEach(function (config) {\n        options = tslib.__assign(tslib.__assign(tslib.__assign({}, options), config.options), { headers: tslib.__assign(tslib.__assign({}, options.headers), config.headers) });\n        if (config.credentials) {\n            options.credentials = config.credentials;\n        }\n        http = tslib.__assign(tslib.__assign({}, http), config.http);\n    });\n    if (options.headers) {\n        options.headers = removeDuplicateHeaders(options.headers, http.preserveHeaderCase);\n    }\n    var operationName = operation.operationName, extensions = operation.extensions, variables = operation.variables, query = operation.query;\n    var body = { operationName: operationName, variables: variables };\n    if (http.includeExtensions)\n        body.extensions = extensions;\n    if (http.includeQuery)\n        body.query = printer(query, utilities.print);\n    return {\n        options: options,\n        body: body,\n    };\n}\nfunction removeDuplicateHeaders(headers, preserveHeaderCase) {\n    if (!preserveHeaderCase) {\n        var normalizedHeaders_1 = {};\n        Object.keys(Object(headers)).forEach(function (name) {\n            normalizedHeaders_1[name.toLowerCase()] = headers[name];\n        });\n        return normalizedHeaders_1;\n    }\n    var headerData = {};\n    Object.keys(Object(headers)).forEach(function (name) {\n        headerData[name.toLowerCase()] = {\n            originalName: name,\n            value: headers[name],\n        };\n    });\n    var normalizedHeaders = {};\n    Object.keys(headerData).forEach(function (name) {\n        normalizedHeaders[headerData[name].originalName] = headerData[name].value;\n    });\n    return normalizedHeaders;\n}\n\nvar checkFetcher = function (fetcher) {\n    if (!fetcher && typeof fetch === \"undefined\") {\n        throw globals.newInvariantError(51);\n    }\n};\n\nvar createSignalIfSupported = function () {\n    if (typeof AbortController === \"undefined\")\n        return { controller: false, signal: false };\n    var controller = new AbortController();\n    var signal = controller.signal;\n    return { controller: controller, signal: signal };\n};\n\nvar selectURI = function (operation, fallbackURI) {\n    var context = operation.getContext();\n    var contextURI = context.uri;\n    if (contextURI) {\n        return contextURI;\n    }\n    else if (typeof fallbackURI === \"function\") {\n        return fallbackURI(operation);\n    }\n    else {\n        return fallbackURI || \"/graphql\";\n    }\n};\n\nfunction rewriteURIForGET(chosenURI, body) {\n    var queryParams = [];\n    var addQueryParam = function (key, value) {\n        queryParams.push(\"\".concat(key, \"=\").concat(encodeURIComponent(value)));\n    };\n    if (\"query\" in body) {\n        addQueryParam(\"query\", body.query);\n    }\n    if (body.operationName) {\n        addQueryParam(\"operationName\", body.operationName);\n    }\n    if (body.variables) {\n        var serializedVariables = void 0;\n        try {\n            serializedVariables = serializeFetchParameter(body.variables, \"Variables map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"variables\", serializedVariables);\n    }\n    if (body.extensions) {\n        var serializedExtensions = void 0;\n        try {\n            serializedExtensions = serializeFetchParameter(body.extensions, \"Extensions map\");\n        }\n        catch (parseError) {\n            return { parseError: parseError };\n        }\n        addQueryParam(\"extensions\", serializedExtensions);\n    }\n    var fragment = \"\", preFragment = chosenURI;\n    var fragmentStart = chosenURI.indexOf(\"#\");\n    if (fragmentStart !== -1) {\n        fragment = chosenURI.substr(fragmentStart);\n        preFragment = chosenURI.substr(0, fragmentStart);\n    }\n    var queryParamsPrefix = preFragment.indexOf(\"?\") === -1 ? \"?\" : \"&\";\n    var newURI = preFragment + queryParamsPrefix + queryParams.join(\"&\") + fragment;\n    return { newURI: newURI };\n}\n\nvar backupFetch = utilities.maybe(function () { return fetch; });\nvar createHttpLink = function (linkOptions) {\n    if (linkOptions === void 0) { linkOptions = {}; }\n    var _a = linkOptions.uri, uri = _a === void 0 ? \"/graphql\" : _a,\n    preferredFetch = linkOptions.fetch, _b = linkOptions.print, print = _b === void 0 ? defaultPrinter : _b, includeExtensions = linkOptions.includeExtensions, preserveHeaderCase = linkOptions.preserveHeaderCase, useGETForQueries = linkOptions.useGETForQueries, _c = linkOptions.includeUnusedVariables, includeUnusedVariables = _c === void 0 ? false : _c, requestOptions = tslib.__rest(linkOptions, [\"uri\", \"fetch\", \"print\", \"includeExtensions\", \"preserveHeaderCase\", \"useGETForQueries\", \"includeUnusedVariables\"]);\n    if (globalThis.__DEV__ !== false) {\n        checkFetcher(preferredFetch || backupFetch);\n    }\n    var linkConfig = {\n        http: { includeExtensions: includeExtensions, preserveHeaderCase: preserveHeaderCase },\n        options: requestOptions.fetchOptions,\n        credentials: requestOptions.credentials,\n        headers: requestOptions.headers,\n    };\n    return new core.ApolloLink(function (operation) {\n        var chosenURI = selectURI(operation, uri);\n        var context = operation.getContext();\n        var clientAwarenessHeaders = {};\n        if (context.clientAwareness) {\n            var _a = context.clientAwareness, name_1 = _a.name, version = _a.version;\n            if (name_1) {\n                clientAwarenessHeaders[\"apollographql-client-name\"] = name_1;\n            }\n            if (version) {\n                clientAwarenessHeaders[\"apollographql-client-version\"] = version;\n            }\n        }\n        var contextHeaders = tslib.__assign(tslib.__assign({}, clientAwarenessHeaders), context.headers);\n        var contextConfig = {\n            http: context.http,\n            options: context.fetchOptions,\n            credentials: context.credentials,\n            headers: contextHeaders,\n        };\n        if (utilities.hasDirectives([\"client\"], operation.query)) {\n            if (globalThis.__DEV__ !== false) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(52);\n            }\n            var transformedQuery = utilities.removeClientSetsFromDocument(operation.query);\n            if (!transformedQuery) {\n                return utils.fromError(new Error(\"HttpLink: Trying to send a client-only query to the server. To send to the server, ensure a non-client field is added to the query or set the `transformOptions.removeClientFields` option to `true`.\"));\n            }\n            operation.query = transformedQuery;\n        }\n        var _b = selectHttpOptionsAndBodyInternal(operation, print, fallbackHttpConfig, linkConfig, contextConfig), options = _b.options, body = _b.body;\n        if (body.variables && !includeUnusedVariables) {\n            body.variables = utils.filterOperationVariables(body.variables, operation.query);\n        }\n        var controller;\n        if (!options.signal && typeof AbortController !== \"undefined\") {\n            controller = new AbortController();\n            options.signal = controller.signal;\n        }\n        var definitionIsMutation = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"mutation\";\n        };\n        var definitionIsSubscription = function (d) {\n            return d.kind === \"OperationDefinition\" && d.operation === \"subscription\";\n        };\n        var isSubscription = definitionIsSubscription(utilities.getMainDefinition(operation.query));\n        var hasDefer = utilities.hasDirectives([\"defer\"], operation.query);\n        if (useGETForQueries &&\n            !operation.query.definitions.some(definitionIsMutation)) {\n            options.method = \"GET\";\n        }\n        if (hasDefer || isSubscription) {\n            options.headers = options.headers || {};\n            var acceptHeader = \"multipart/mixed;\";\n            if (isSubscription && hasDefer) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(53);\n            }\n            if (isSubscription) {\n                acceptHeader +=\n                    \"boundary=graphql;subscriptionSpec=1.0,application/json\";\n            }\n            else if (hasDefer) {\n                acceptHeader += \"deferSpec=20220824,application/json\";\n            }\n            options.headers.accept = acceptHeader;\n        }\n        if (options.method === \"GET\") {\n            var _c = rewriteURIForGET(chosenURI, body), newURI = _c.newURI, parseError = _c.parseError;\n            if (parseError) {\n                return utils.fromError(parseError);\n            }\n            chosenURI = newURI;\n        }\n        else {\n            try {\n                options.body = serializeFetchParameter(body, \"Payload\");\n            }\n            catch (parseError) {\n                return utils.fromError(parseError);\n            }\n        }\n        return new utilities.Observable(function (observer) {\n            var currentFetch = preferredFetch || utilities.maybe(function () { return fetch; }) || backupFetch;\n            var observerNext = observer.next.bind(observer);\n            currentFetch(chosenURI, options)\n                .then(function (response) {\n                var _a;\n                operation.setContext({ response: response });\n                var ctype = (_a = response.headers) === null || _a === void 0 ? void 0 : _a.get(\"content-type\");\n                if (ctype !== null && /^multipart\\/mixed/i.test(ctype)) {\n                    return readMultipartBody(response, observerNext);\n                }\n                else {\n                    return parseAndCheckHttpResponse(operation)(response).then(observerNext);\n                }\n            })\n                .then(function () {\n                controller = undefined;\n                observer.complete();\n            })\n                .catch(function (err) {\n                controller = undefined;\n                handleError(err, observer);\n            });\n            return function () {\n                if (controller)\n                    controller.abort();\n            };\n        });\n    });\n};\n\nvar HttpLink =  (function (_super) {\n    tslib.__extends(HttpLink, _super);\n    function HttpLink(options) {\n        if (options === void 0) { options = {}; }\n        var _this = _super.call(this, createHttpLink(options).request) || this;\n        _this.options = options;\n        return _this;\n    }\n    return HttpLink;\n}(core.ApolloLink));\n\nexports.HttpLink = HttpLink;\nexports.checkFetcher = checkFetcher;\nexports.createHttpLink = createHttpLink;\nexports.createSignalIfSupported = createSignalIfSupported;\nexports.defaultPrinter = defaultPrinter;\nexports.fallbackHttpConfig = fallbackHttpConfig;\nexports.parseAndCheckHttpResponse = parseAndCheckHttpResponse;\nexports.rewriteURIForGET = rewriteURIForGET;\nexports.selectHttpOptionsAndBody = selectHttpOptionsAndBody;\nexports.selectHttpOptionsAndBodyInternal = selectHttpOptionsAndBodyInternal;\nexports.selectURI = selectURI;\nexports.serializeFetchParameter = serializeFetchParameter;\n//# sourceMappingURL=http.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('./globals');\nvar graphql = require('graphql');\nvar trie = require('@wry/trie');\nvar tslib = require('tslib');\nvar caches = require('@wry/caches');\nvar optimism = require('optimism');\nvar zenObservableTs = require('zen-observable-ts');\nrequire('symbol-observable');\n\nfunction shouldInclude(_a, variables) {\n    var directives = _a.directives;\n    if (!directives || !directives.length) {\n        return true;\n    }\n    return getInclusionDirectives(directives).every(function (_a) {\n        var directive = _a.directive, ifArgument = _a.ifArgument;\n        var evaledValue = false;\n        if (ifArgument.value.kind === \"Variable\") {\n            evaledValue =\n                variables && variables[ifArgument.value.name.value];\n            globals.invariant(evaledValue !== void 0, 106, directive.name.value);\n        }\n        else {\n            evaledValue = ifArgument.value.value;\n        }\n        return directive.name.value === \"skip\" ? !evaledValue : evaledValue;\n    });\n}\nfunction getDirectiveNames(root) {\n    var names = [];\n    graphql.visit(root, {\n        Directive: function (node) {\n            names.push(node.name.value);\n        },\n    });\n    return names;\n}\nvar hasAnyDirectives = function (names, root) {\n    return hasDirectives(names, root, false);\n};\nvar hasAllDirectives = function (names, root) {\n    return hasDirectives(names, root, true);\n};\nfunction hasDirectives(names, root, all) {\n    var nameSet = new Set(names);\n    var uniqueCount = nameSet.size;\n    graphql.visit(root, {\n        Directive: function (node) {\n            if (nameSet.delete(node.name.value) && (!all || !nameSet.size)) {\n                return graphql.BREAK;\n            }\n        },\n    });\n    return all ? !nameSet.size : nameSet.size < uniqueCount;\n}\nfunction hasClientExports(document) {\n    return document && hasDirectives([\"client\", \"export\"], document, true);\n}\nfunction isInclusionDirective(_a) {\n    var value = _a.name.value;\n    return value === \"skip\" || value === \"include\";\n}\nfunction getInclusionDirectives(directives) {\n    var result = [];\n    if (directives && directives.length) {\n        directives.forEach(function (directive) {\n            if (!isInclusionDirective(directive))\n                return;\n            var directiveArguments = directive.arguments;\n            var directiveName = directive.name.value;\n            globals.invariant(directiveArguments && directiveArguments.length === 1, 107, directiveName);\n            var ifArgument = directiveArguments[0];\n            globals.invariant(ifArgument.name && ifArgument.name.value === \"if\", 108, directiveName);\n            var ifValue = ifArgument.value;\n            globals.invariant(ifValue &&\n                (ifValue.kind === \"Variable\" || ifValue.kind === \"BooleanValue\"), 109, directiveName);\n            result.push({ directive: directive, ifArgument: ifArgument });\n        });\n    }\n    return result;\n}\nfunction getFragmentMaskMode(fragment) {\n    var _a, _b;\n    var directive = (_a = fragment.directives) === null || _a === void 0 ? void 0 : _a.find(function (_a) {\n        var name = _a.name;\n        return name.value === \"unmask\";\n    });\n    if (!directive) {\n        return \"mask\";\n    }\n    var modeArg = (_b = directive.arguments) === null || _b === void 0 ? void 0 : _b.find(function (_a) {\n        var name = _a.name;\n        return name.value === \"mode\";\n    });\n    if (globalThis.__DEV__ !== false) {\n        if (modeArg) {\n            if (modeArg.value.kind === graphql.Kind.VARIABLE) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(110);\n            }\n            else if (modeArg.value.kind !== graphql.Kind.STRING) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(111);\n            }\n            else if (modeArg.value.value !== \"migrate\") {\n                globalThis.__DEV__ !== false && globals.invariant.warn(112, modeArg.value.value);\n            }\n        }\n    }\n    if (modeArg &&\n        \"value\" in modeArg.value &&\n        modeArg.value.value === \"migrate\") {\n        return \"migrate\";\n    }\n    return \"unmask\";\n}\n\nvar isReactNative = globals.maybe(function () { return navigator.product; }) == \"ReactNative\";\nvar canUseWeakMap = typeof WeakMap === \"function\" &&\n    !(isReactNative && !global.HermesInternal);\nvar canUseWeakSet = typeof WeakSet === \"function\";\nvar canUseSymbol = typeof Symbol === \"function\" && typeof Symbol.for === \"function\";\nvar canUseAsyncIteratorSymbol = canUseSymbol && Symbol.asyncIterator;\nvar canUseDOM = typeof globals.maybe(function () { return window.document.createElement; }) === \"function\";\nvar usingJSDOM =\nglobals.maybe(function () { return navigator.userAgent.indexOf(\"jsdom\") >= 0; }) || false;\nvar canUseLayoutEffect = (canUseDOM || isReactNative) && !usingJSDOM;\n\nfunction isNonNullObject(obj) {\n    return obj !== null && typeof obj === \"object\";\n}\nfunction isPlainObject(obj) {\n    return (obj !== null &&\n        typeof obj === \"object\" &&\n        (Object.getPrototypeOf(obj) === Object.prototype ||\n            Object.getPrototypeOf(obj) === null));\n}\n\nfunction getFragmentQueryDocument(document, fragmentName) {\n    var actualFragmentName = fragmentName;\n    var fragments = [];\n    document.definitions.forEach(function (definition) {\n        if (definition.kind === \"OperationDefinition\") {\n            throw globals.newInvariantError(\n                113,\n                definition.operation,\n                definition.name ? \" named '\".concat(definition.name.value, \"'\") : \"\"\n            );\n        }\n        if (definition.kind === \"FragmentDefinition\") {\n            fragments.push(definition);\n        }\n    });\n    if (typeof actualFragmentName === \"undefined\") {\n        globals.invariant(fragments.length === 1, 114, fragments.length);\n        actualFragmentName = fragments[0].name.value;\n    }\n    var query = tslib.__assign(tslib.__assign({}, document), { definitions: tslib.__spreadArray([\n            {\n                kind: \"OperationDefinition\",\n                operation: \"query\",\n                selectionSet: {\n                    kind: \"SelectionSet\",\n                    selections: [\n                        {\n                            kind: \"FragmentSpread\",\n                            name: {\n                                kind: \"Name\",\n                                value: actualFragmentName,\n                            },\n                        },\n                    ],\n                },\n            }\n        ], document.definitions, true) });\n    return query;\n}\nfunction createFragmentMap(fragments) {\n    if (fragments === void 0) { fragments = []; }\n    var symTable = {};\n    fragments.forEach(function (fragment) {\n        symTable[fragment.name.value] = fragment;\n    });\n    return symTable;\n}\nfunction getFragmentFromSelection(selection, fragmentMap) {\n    switch (selection.kind) {\n        case \"InlineFragment\":\n            return selection;\n        case \"FragmentSpread\": {\n            var fragmentName = selection.name.value;\n            if (typeof fragmentMap === \"function\") {\n                return fragmentMap(fragmentName);\n            }\n            var fragment = fragmentMap && fragmentMap[fragmentName];\n            globals.invariant(fragment, 115, fragmentName);\n            return fragment || null;\n        }\n        default:\n            return null;\n    }\n}\nfunction isFullyUnmaskedOperation(document) {\n    var isUnmasked = true;\n    graphql.visit(document, {\n        FragmentSpread: function (node) {\n            isUnmasked =\n                !!node.directives &&\n                    node.directives.some(function (directive) { return directive.name.value === \"unmask\"; });\n            if (!isUnmasked) {\n                return graphql.BREAK;\n            }\n        },\n    });\n    return isUnmasked;\n}\n\nvar scheduledCleanup = new WeakSet();\nfunction schedule(cache) {\n    if (cache.size <= (cache.max || -1)) {\n        return;\n    }\n    if (!scheduledCleanup.has(cache)) {\n        scheduledCleanup.add(cache);\n        setTimeout(function () {\n            cache.clean();\n            scheduledCleanup.delete(cache);\n        }, 100);\n    }\n}\nvar AutoCleanedWeakCache = function (max, dispose) {\n    var cache = new caches.WeakCache(max, dispose);\n    cache.set = function (key, value) {\n        var ret = caches.WeakCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\nvar AutoCleanedStrongCache = function (max, dispose) {\n    var cache = new caches.StrongCache(max, dispose);\n    cache.set = function (key, value) {\n        var ret = caches.StrongCache.prototype.set.call(this, key, value);\n        schedule(this);\n        return ret;\n    };\n    return cache;\n};\n\nvar cacheSizeSymbol = Symbol.for(\"apollo.cacheSize\");\nvar cacheSizes = tslib.__assign({}, globals.global[cacheSizeSymbol]);\n\nvar globalCaches = {};\nfunction registerGlobalCache(name, getSize) {\n    globalCaches[name] = getSize;\n}\n\nvar canonicalStringify = Object.assign(function canonicalStringify(value) {\n    return JSON.stringify(value, stableObjectReplacer);\n}, {\n    reset: function () {\n        sortingMap = new AutoCleanedStrongCache(cacheSizes.canonicalStringify || 1000 );\n    },\n});\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"canonicalStringify\", function () { return sortingMap.size; });\n}\nvar sortingMap;\ncanonicalStringify.reset();\nfunction stableObjectReplacer(key, value) {\n    if (value && typeof value === \"object\") {\n        var proto = Object.getPrototypeOf(value);\n        if (proto === Object.prototype || proto === null) {\n            var keys = Object.keys(value);\n            if (keys.every(everyKeyInOrder))\n                return value;\n            var unsortedKey = JSON.stringify(keys);\n            var sortedKeys = sortingMap.get(unsortedKey);\n            if (!sortedKeys) {\n                keys.sort();\n                var sortedKey = JSON.stringify(keys);\n                sortedKeys = sortingMap.get(sortedKey) || keys;\n                sortingMap.set(unsortedKey, sortedKeys);\n                sortingMap.set(sortedKey, sortedKeys);\n            }\n            var sortedObject_1 = Object.create(proto);\n            sortedKeys.forEach(function (key) {\n                sortedObject_1[key] = value[key];\n            });\n            return sortedObject_1;\n        }\n    }\n    return value;\n}\nfunction everyKeyInOrder(key, i, keys) {\n    return i === 0 || keys[i - 1] <= key;\n}\n\nfunction makeReference(id) {\n    return { __ref: String(id) };\n}\nfunction isReference(obj) {\n    return Boolean(obj && typeof obj === \"object\" && typeof obj.__ref === \"string\");\n}\nfunction isDocumentNode(value) {\n    return (isNonNullObject(value) &&\n        value.kind === \"Document\" &&\n        Array.isArray(value.definitions));\n}\nfunction isStringValue(value) {\n    return value.kind === \"StringValue\";\n}\nfunction isBooleanValue(value) {\n    return value.kind === \"BooleanValue\";\n}\nfunction isIntValue(value) {\n    return value.kind === \"IntValue\";\n}\nfunction isFloatValue(value) {\n    return value.kind === \"FloatValue\";\n}\nfunction isVariable(value) {\n    return value.kind === \"Variable\";\n}\nfunction isObjectValue(value) {\n    return value.kind === \"ObjectValue\";\n}\nfunction isListValue(value) {\n    return value.kind === \"ListValue\";\n}\nfunction isEnumValue(value) {\n    return value.kind === \"EnumValue\";\n}\nfunction isNullValue(value) {\n    return value.kind === \"NullValue\";\n}\nfunction valueToObjectRepresentation(argObj, name, value, variables) {\n    if (isIntValue(value) || isFloatValue(value)) {\n        argObj[name.value] = Number(value.value);\n    }\n    else if (isBooleanValue(value) || isStringValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isObjectValue(value)) {\n        var nestedArgObj_1 = {};\n        value.fields.map(function (obj) {\n            return valueToObjectRepresentation(nestedArgObj_1, obj.name, obj.value, variables);\n        });\n        argObj[name.value] = nestedArgObj_1;\n    }\n    else if (isVariable(value)) {\n        var variableValue = (variables || {})[value.name.value];\n        argObj[name.value] = variableValue;\n    }\n    else if (isListValue(value)) {\n        argObj[name.value] = value.values.map(function (listValue) {\n            var nestedArgArrayObj = {};\n            valueToObjectRepresentation(nestedArgArrayObj, name, listValue, variables);\n            return nestedArgArrayObj[name.value];\n        });\n    }\n    else if (isEnumValue(value)) {\n        argObj[name.value] = value.value;\n    }\n    else if (isNullValue(value)) {\n        argObj[name.value] = null;\n    }\n    else {\n        throw globals.newInvariantError(124, name.value, value.kind);\n    }\n}\nfunction storeKeyNameFromField(field, variables) {\n    var directivesObj = null;\n    if (field.directives) {\n        directivesObj = {};\n        field.directives.forEach(function (directive) {\n            directivesObj[directive.name.value] = {};\n            if (directive.arguments) {\n                directive.arguments.forEach(function (_a) {\n                    var name = _a.name, value = _a.value;\n                    return valueToObjectRepresentation(directivesObj[directive.name.value], name, value, variables);\n                });\n            }\n        });\n    }\n    var argObj = null;\n    if (field.arguments && field.arguments.length) {\n        argObj = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj, name, value, variables);\n        });\n    }\n    return getStoreKeyName(field.name.value, argObj, directivesObj);\n}\nvar KNOWN_DIRECTIVES = [\n    \"connection\",\n    \"include\",\n    \"skip\",\n    \"client\",\n    \"rest\",\n    \"export\",\n    \"nonreactive\",\n];\nvar storeKeyNameStringify = canonicalStringify;\nvar getStoreKeyName = Object.assign(function (fieldName, args, directives) {\n    if (args &&\n        directives &&\n        directives[\"connection\"] &&\n        directives[\"connection\"][\"key\"]) {\n        if (directives[\"connection\"][\"filter\"] &&\n            directives[\"connection\"][\"filter\"].length > 0) {\n            var filterKeys = directives[\"connection\"][\"filter\"] ?\n                directives[\"connection\"][\"filter\"]\n                : [];\n            filterKeys.sort();\n            var filteredArgs_1 = {};\n            filterKeys.forEach(function (key) {\n                filteredArgs_1[key] = args[key];\n            });\n            return \"\".concat(directives[\"connection\"][\"key\"], \"(\").concat(storeKeyNameStringify(filteredArgs_1), \")\");\n        }\n        else {\n            return directives[\"connection\"][\"key\"];\n        }\n    }\n    var completeFieldName = fieldName;\n    if (args) {\n        var stringifiedArgs = storeKeyNameStringify(args);\n        completeFieldName += \"(\".concat(stringifiedArgs, \")\");\n    }\n    if (directives) {\n        Object.keys(directives).forEach(function (key) {\n            if (KNOWN_DIRECTIVES.indexOf(key) !== -1)\n                return;\n            if (directives[key] && Object.keys(directives[key]).length) {\n                completeFieldName += \"@\".concat(key, \"(\").concat(storeKeyNameStringify(directives[key]), \")\");\n            }\n            else {\n                completeFieldName += \"@\".concat(key);\n            }\n        });\n    }\n    return completeFieldName;\n}, {\n    setStringify: function (s) {\n        var previous = storeKeyNameStringify;\n        storeKeyNameStringify = s;\n        return previous;\n    },\n});\nfunction argumentsObjectFromField(field, variables) {\n    if (field.arguments && field.arguments.length) {\n        var argObj_1 = {};\n        field.arguments.forEach(function (_a) {\n            var name = _a.name, value = _a.value;\n            return valueToObjectRepresentation(argObj_1, name, value, variables);\n        });\n        return argObj_1;\n    }\n    return null;\n}\nfunction resultKeyNameFromField(field) {\n    return field.alias ? field.alias.value : field.name.value;\n}\nfunction getTypenameFromResult(result, selectionSet, fragmentMap) {\n    var fragments;\n    for (var _i = 0, _a = selectionSet.selections; _i < _a.length; _i++) {\n        var selection = _a[_i];\n        if (isField(selection)) {\n            if (selection.name.value === \"__typename\") {\n                return result[resultKeyNameFromField(selection)];\n            }\n        }\n        else if (fragments) {\n            fragments.push(selection);\n        }\n        else {\n            fragments = [selection];\n        }\n    }\n    if (typeof result.__typename === \"string\") {\n        return result.__typename;\n    }\n    if (fragments) {\n        for (var _b = 0, fragments_1 = fragments; _b < fragments_1.length; _b++) {\n            var selection = fragments_1[_b];\n            var typename = getTypenameFromResult(result, getFragmentFromSelection(selection, fragmentMap).selectionSet, fragmentMap);\n            if (typeof typename === \"string\") {\n                return typename;\n            }\n        }\n    }\n}\nfunction isField(selection) {\n    return selection.kind === \"Field\";\n}\nfunction isInlineFragment(selection) {\n    return selection.kind === \"InlineFragment\";\n}\n\nfunction checkDocument(doc) {\n    globals.invariant(doc && doc.kind === \"Document\", 116);\n    var operations = doc.definitions\n        .filter(function (d) { return d.kind !== \"FragmentDefinition\"; })\n        .map(function (definition) {\n        if (definition.kind !== \"OperationDefinition\") {\n            throw globals.newInvariantError(117, definition.kind);\n        }\n        return definition;\n    });\n    globals.invariant(operations.length <= 1, 118, operations.length);\n    return doc;\n}\nfunction getOperationDefinition(doc) {\n    checkDocument(doc);\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"OperationDefinition\";\n    })[0];\n}\nfunction getOperationName(doc) {\n    return (doc.definitions\n        .filter(function (definition) {\n        return definition.kind === \"OperationDefinition\" && !!definition.name;\n    })\n        .map(function (x) { return x.name.value; })[0] || null);\n}\nfunction getFragmentDefinitions(doc) {\n    return doc.definitions.filter(function (definition) {\n        return definition.kind === \"FragmentDefinition\";\n    });\n}\nfunction getQueryDefinition(doc) {\n    var queryDef = getOperationDefinition(doc);\n    globals.invariant(queryDef && queryDef.operation === \"query\", 119);\n    return queryDef;\n}\nfunction getFragmentDefinition(doc) {\n    globals.invariant(doc.kind === \"Document\", 120);\n    globals.invariant(doc.definitions.length <= 1, 121);\n    var fragmentDef = doc.definitions[0];\n    globals.invariant(fragmentDef.kind === \"FragmentDefinition\", 122);\n    return fragmentDef;\n}\nfunction getMainDefinition(queryDoc) {\n    checkDocument(queryDoc);\n    var fragmentDefinition;\n    for (var _i = 0, _a = queryDoc.definitions; _i < _a.length; _i++) {\n        var definition = _a[_i];\n        if (definition.kind === \"OperationDefinition\") {\n            var operation = definition.operation;\n            if (operation === \"query\" ||\n                operation === \"mutation\" ||\n                operation === \"subscription\") {\n                return definition;\n            }\n        }\n        if (definition.kind === \"FragmentDefinition\" && !fragmentDefinition) {\n            fragmentDefinition = definition;\n        }\n    }\n    if (fragmentDefinition) {\n        return fragmentDefinition;\n    }\n    throw globals.newInvariantError(123);\n}\nfunction getDefaultValues(definition) {\n    var defaultValues = Object.create(null);\n    var defs = definition && definition.variableDefinitions;\n    if (defs && defs.length) {\n        defs.forEach(function (def) {\n            if (def.defaultValue) {\n                valueToObjectRepresentation(defaultValues, def.variable.name, def.defaultValue);\n            }\n        });\n    }\n    return defaultValues;\n}\n\nfunction identity(document) {\n    return document;\n}\nvar DocumentTransform =  (function () {\n    function DocumentTransform(transform, options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.resultCache = canUseWeakSet ? new WeakSet() : new Set();\n        this.transform = transform;\n        if (options.getCacheKey) {\n            this.getCacheKey = options.getCacheKey;\n        }\n        this.cached = options.cache !== false;\n        this.resetCache();\n    }\n    DocumentTransform.prototype.getCacheKey = function (document) {\n        return [document];\n    };\n    DocumentTransform.identity = function () {\n        return new DocumentTransform(identity, { cache: false });\n    };\n    DocumentTransform.split = function (predicate, left, right) {\n        if (right === void 0) { right = DocumentTransform.identity(); }\n        return Object.assign(new DocumentTransform(function (document) {\n            var documentTransform = predicate(document) ? left : right;\n            return documentTransform.transformDocument(document);\n        },\n        { cache: false }), { left: left, right: right });\n    };\n    DocumentTransform.prototype.resetCache = function () {\n        var _this = this;\n        if (this.cached) {\n            var stableCacheKeys_1 = new trie.Trie(canUseWeakMap);\n            this.performWork = optimism.wrap(DocumentTransform.prototype.performWork.bind(this), {\n                makeCacheKey: function (document) {\n                    var cacheKeys = _this.getCacheKey(document);\n                    if (cacheKeys) {\n                        globals.invariant(Array.isArray(cacheKeys), 105);\n                        return stableCacheKeys_1.lookupArray(cacheKeys);\n                    }\n                },\n                max: cacheSizes[\"documentTransform.cache\"],\n                cache: (caches.WeakCache),\n            });\n        }\n    };\n    DocumentTransform.prototype.performWork = function (document) {\n        checkDocument(document);\n        return this.transform(document);\n    };\n    DocumentTransform.prototype.transformDocument = function (document) {\n        if (this.resultCache.has(document)) {\n            return document;\n        }\n        var transformedDocument = this.performWork(document);\n        this.resultCache.add(transformedDocument);\n        return transformedDocument;\n    };\n    DocumentTransform.prototype.concat = function (otherTransform) {\n        var _this = this;\n        return Object.assign(new DocumentTransform(function (document) {\n            return otherTransform.transformDocument(_this.transformDocument(document));\n        },\n        { cache: false }), {\n            left: this,\n            right: otherTransform,\n        });\n    };\n    return DocumentTransform;\n}());\n\nvar printCache;\nvar print = Object.assign(function (ast) {\n    var result = printCache.get(ast);\n    if (!result) {\n        result = graphql.print(ast);\n        printCache.set(ast, result);\n    }\n    return result;\n}, {\n    reset: function () {\n        printCache = new AutoCleanedWeakCache(cacheSizes.print || 2000 );\n    },\n});\nprint.reset();\nif (globalThis.__DEV__ !== false) {\n    registerGlobalCache(\"print\", function () { return (printCache ? printCache.size : 0); });\n}\n\nvar isArray = Array.isArray;\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nvar TYPENAME_FIELD = {\n    kind: graphql.Kind.FIELD,\n    name: {\n        kind: graphql.Kind.NAME,\n        value: \"__typename\",\n    },\n};\nfunction isEmpty(op, fragmentMap) {\n    return (!op ||\n        op.selectionSet.selections.every(function (selection) {\n            return selection.kind === graphql.Kind.FRAGMENT_SPREAD &&\n                isEmpty(fragmentMap[selection.name.value], fragmentMap);\n        }));\n}\nfunction nullIfDocIsEmpty(doc) {\n    return (isEmpty(getOperationDefinition(doc) || getFragmentDefinition(doc), createFragmentMap(getFragmentDefinitions(doc)))) ?\n        null\n        : doc;\n}\nfunction getDirectiveMatcher(configs) {\n    var names = new Map();\n    var tests = new Map();\n    configs.forEach(function (directive) {\n        if (directive) {\n            if (directive.name) {\n                names.set(directive.name, directive);\n            }\n            else if (directive.test) {\n                tests.set(directive.test, directive);\n            }\n        }\n    });\n    return function (directive) {\n        var config = names.get(directive.name.value);\n        if (!config && tests.size) {\n            tests.forEach(function (testConfig, test) {\n                if (test(directive)) {\n                    config = testConfig;\n                }\n            });\n        }\n        return config;\n    };\n}\nfunction makeInUseGetterFunction(defaultKey) {\n    var map = new Map();\n    return function inUseGetterFunction(key) {\n        if (key === void 0) { key = defaultKey; }\n        var inUse = map.get(key);\n        if (!inUse) {\n            map.set(key, (inUse = {\n                variables: new Set(),\n                fragmentSpreads: new Set(),\n            }));\n        }\n        return inUse;\n    };\n}\nfunction removeDirectivesFromDocument(directives, doc) {\n    checkDocument(doc);\n    var getInUseByOperationName = makeInUseGetterFunction(\"\");\n    var getInUseByFragmentName = makeInUseGetterFunction(\"\");\n    var getInUse = function (ancestors) {\n        for (var p = 0, ancestor = void 0; p < ancestors.length && (ancestor = ancestors[p]); ++p) {\n            if (isArray(ancestor))\n                continue;\n            if (ancestor.kind === graphql.Kind.OPERATION_DEFINITION) {\n                return getInUseByOperationName(ancestor.name && ancestor.name.value);\n            }\n            if (ancestor.kind === graphql.Kind.FRAGMENT_DEFINITION) {\n                return getInUseByFragmentName(ancestor.name.value);\n            }\n        }\n        globalThis.__DEV__ !== false && globals.invariant.error(125);\n        return null;\n    };\n    var operationCount = 0;\n    for (var i = doc.definitions.length - 1; i >= 0; --i) {\n        if (doc.definitions[i].kind === graphql.Kind.OPERATION_DEFINITION) {\n            ++operationCount;\n        }\n    }\n    var directiveMatcher = getDirectiveMatcher(directives);\n    var shouldRemoveField = function (nodeDirectives) {\n        return isNonEmptyArray(nodeDirectives) &&\n            nodeDirectives\n                .map(directiveMatcher)\n                .some(function (config) { return config && config.remove; });\n    };\n    var originalFragmentDefsByPath = new Map();\n    var firstVisitMadeChanges = false;\n    var fieldOrInlineFragmentVisitor = {\n        enter: function (node) {\n            if (shouldRemoveField(node.directives)) {\n                firstVisitMadeChanges = true;\n                return null;\n            }\n        },\n    };\n    var docWithoutDirectiveSubtrees = graphql.visit(doc, {\n        Field: fieldOrInlineFragmentVisitor,\n        InlineFragment: fieldOrInlineFragmentVisitor,\n        VariableDefinition: {\n            enter: function () {\n                return false;\n            },\n        },\n        Variable: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.variables.add(node.name.value);\n                }\n            },\n        },\n        FragmentSpread: {\n            enter: function (node, _key, _parent, _path, ancestors) {\n                if (shouldRemoveField(node.directives)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n                var inUse = getInUse(ancestors);\n                if (inUse) {\n                    inUse.fragmentSpreads.add(node.name.value);\n                }\n            },\n        },\n        FragmentDefinition: {\n            enter: function (node, _key, _parent, path) {\n                originalFragmentDefsByPath.set(JSON.stringify(path), node);\n            },\n            leave: function (node, _key, _parent, path) {\n                var originalNode = originalFragmentDefsByPath.get(JSON.stringify(path));\n                if (node === originalNode) {\n                    return node;\n                }\n                if (\n                operationCount > 0 &&\n                    node.selectionSet.selections.every(function (selection) {\n                        return selection.kind === graphql.Kind.FIELD &&\n                            selection.name.value === \"__typename\";\n                    })) {\n                    getInUseByFragmentName(node.name.value).removed = true;\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n        Directive: {\n            leave: function (node) {\n                if (directiveMatcher(node)) {\n                    firstVisitMadeChanges = true;\n                    return null;\n                }\n            },\n        },\n    });\n    if (!firstVisitMadeChanges) {\n        return doc;\n    }\n    var populateTransitiveVars = function (inUse) {\n        if (!inUse.transitiveVars) {\n            inUse.transitiveVars = new Set(inUse.variables);\n            if (!inUse.removed) {\n                inUse.fragmentSpreads.forEach(function (childFragmentName) {\n                    populateTransitiveVars(getInUseByFragmentName(childFragmentName)).transitiveVars.forEach(function (varName) {\n                        inUse.transitiveVars.add(varName);\n                    });\n                });\n            }\n        }\n        return inUse;\n    };\n    var allFragmentNamesUsed = new Set();\n    docWithoutDirectiveSubtrees.definitions.forEach(function (def) {\n        if (def.kind === graphql.Kind.OPERATION_DEFINITION) {\n            populateTransitiveVars(getInUseByOperationName(def.name && def.name.value)).fragmentSpreads.forEach(function (childFragmentName) {\n                allFragmentNamesUsed.add(childFragmentName);\n            });\n        }\n        else if (def.kind === graphql.Kind.FRAGMENT_DEFINITION &&\n            operationCount === 0 &&\n            !getInUseByFragmentName(def.name.value).removed) {\n            allFragmentNamesUsed.add(def.name.value);\n        }\n    });\n    allFragmentNamesUsed.forEach(function (fragmentName) {\n        populateTransitiveVars(getInUseByFragmentName(fragmentName)).fragmentSpreads.forEach(function (childFragmentName) {\n            allFragmentNamesUsed.add(childFragmentName);\n        });\n    });\n    var fragmentWillBeRemoved = function (fragmentName) {\n        return !!(\n        (!allFragmentNamesUsed.has(fragmentName) ||\n            getInUseByFragmentName(fragmentName).removed));\n    };\n    var enterVisitor = {\n        enter: function (node) {\n            if (fragmentWillBeRemoved(node.name.value)) {\n                return null;\n            }\n        },\n    };\n    return nullIfDocIsEmpty(graphql.visit(docWithoutDirectiveSubtrees, {\n        FragmentSpread: enterVisitor,\n        FragmentDefinition: enterVisitor,\n        OperationDefinition: {\n            leave: function (node) {\n                if (node.variableDefinitions) {\n                    var usedVariableNames_1 = populateTransitiveVars(\n                    getInUseByOperationName(node.name && node.name.value)).transitiveVars;\n                    if (usedVariableNames_1.size < node.variableDefinitions.length) {\n                        return tslib.__assign(tslib.__assign({}, node), { variableDefinitions: node.variableDefinitions.filter(function (varDef) {\n                                return usedVariableNames_1.has(varDef.variable.name.value);\n                            }) });\n                    }\n                }\n            },\n        },\n    }));\n}\nvar addTypenameToDocument = Object.assign(function (doc) {\n    return graphql.visit(doc, {\n        SelectionSet: {\n            enter: function (node, _key, parent) {\n                if (parent &&\n                    parent.kind ===\n                        graphql.Kind.OPERATION_DEFINITION) {\n                    return;\n                }\n                var selections = node.selections;\n                if (!selections) {\n                    return;\n                }\n                var skip = selections.some(function (selection) {\n                    return (isField(selection) &&\n                        (selection.name.value === \"__typename\" ||\n                            selection.name.value.lastIndexOf(\"__\", 0) === 0));\n                });\n                if (skip) {\n                    return;\n                }\n                var field = parent;\n                if (isField(field) &&\n                    field.directives &&\n                    field.directives.some(function (d) { return d.name.value === \"export\"; })) {\n                    return;\n                }\n                return tslib.__assign(tslib.__assign({}, node), { selections: tslib.__spreadArray(tslib.__spreadArray([], selections, true), [TYPENAME_FIELD], false) });\n            },\n        },\n    });\n}, {\n    added: function (field) {\n        return field === TYPENAME_FIELD;\n    },\n});\nvar connectionRemoveConfig = {\n    test: function (directive) {\n        var willRemove = directive.name.value === \"connection\";\n        if (willRemove) {\n            if (!directive.arguments ||\n                !directive.arguments.some(function (arg) { return arg.name.value === \"key\"; })) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(126);\n            }\n        }\n        return willRemove;\n    },\n};\nfunction removeConnectionDirectiveFromDocument(doc) {\n    return removeDirectivesFromDocument([connectionRemoveConfig], checkDocument(doc));\n}\nfunction getArgumentMatcher(config) {\n    return function argumentMatcher(argument) {\n        return config.some(function (aConfig) {\n            return argument.value &&\n                argument.value.kind === graphql.Kind.VARIABLE &&\n                argument.value.name &&\n                (aConfig.name === argument.value.name.value ||\n                    (aConfig.test && aConfig.test(argument)));\n        });\n    };\n}\nfunction removeArgumentsFromDocument(config, doc) {\n    var argMatcher = getArgumentMatcher(config);\n    return nullIfDocIsEmpty(graphql.visit(doc, {\n        OperationDefinition: {\n            enter: function (node) {\n                return tslib.__assign(tslib.__assign({}, node), {\n                    variableDefinitions: node.variableDefinitions ?\n                        node.variableDefinitions.filter(function (varDef) {\n                            return !config.some(function (arg) { return arg.name === varDef.variable.name.value; });\n                        })\n                        : [] });\n            },\n        },\n        Field: {\n            enter: function (node) {\n                var shouldRemoveField = config.some(function (argConfig) { return argConfig.remove; });\n                if (shouldRemoveField) {\n                    var argMatchCount_1 = 0;\n                    if (node.arguments) {\n                        node.arguments.forEach(function (arg) {\n                            if (argMatcher(arg)) {\n                                argMatchCount_1 += 1;\n                            }\n                        });\n                    }\n                    if (argMatchCount_1 === 1) {\n                        return null;\n                    }\n                }\n            },\n        },\n        Argument: {\n            enter: function (node) {\n                if (argMatcher(node)) {\n                    return null;\n                }\n            },\n        },\n    }));\n}\nfunction removeFragmentSpreadFromDocument(config, doc) {\n    function enter(node) {\n        if (config.some(function (def) { return def.name === node.name.value; })) {\n            return null;\n        }\n    }\n    return nullIfDocIsEmpty(graphql.visit(doc, {\n        FragmentSpread: { enter: enter },\n        FragmentDefinition: { enter: enter },\n    }));\n}\nfunction buildQueryFromSelectionSet(document) {\n    var definition = getMainDefinition(document);\n    var definitionOperation = definition.operation;\n    if (definitionOperation === \"query\") {\n        return document;\n    }\n    var modifiedDoc = graphql.visit(document, {\n        OperationDefinition: {\n            enter: function (node) {\n                return tslib.__assign(tslib.__assign({}, node), { operation: \"query\" });\n            },\n        },\n    });\n    return modifiedDoc;\n}\nfunction removeClientSetsFromDocument(document) {\n    checkDocument(document);\n    var modifiedDoc = removeDirectivesFromDocument([\n        {\n            test: function (directive) { return directive.name.value === \"client\"; },\n            remove: true,\n        },\n    ], document);\n    return modifiedDoc;\n}\nfunction addNonReactiveToNamedFragments(document) {\n    checkDocument(document);\n    return graphql.visit(document, {\n        FragmentSpread: function (node) {\n            var _a;\n            if ((_a = node.directives) === null || _a === void 0 ? void 0 : _a.some(function (directive) { return directive.name.value === \"unmask\"; })) {\n                return;\n            }\n            return tslib.__assign(tslib.__assign({}, node), { directives: tslib.__spreadArray(tslib.__spreadArray([], (node.directives || []), true), [\n                    {\n                        kind: graphql.Kind.DIRECTIVE,\n                        name: { kind: graphql.Kind.NAME, value: \"nonreactive\" },\n                    },\n                ], false) });\n        },\n    });\n}\n\nfunction isOperation(document, operation) {\n    var _a;\n    return ((_a = getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation) === operation;\n}\nfunction isMutationOperation(document) {\n    return isOperation(document, \"mutation\");\n}\nfunction isQueryOperation(document) {\n    return isOperation(document, \"query\");\n}\nfunction isSubscriptionOperation(document) {\n    return isOperation(document, \"subscription\");\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction mergeDeep() {\n    var sources = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        sources[_i] = arguments[_i];\n    }\n    return mergeDeepArray(sources);\n}\nfunction mergeDeepArray(sources) {\n    var target = sources[0] || {};\n    var count = sources.length;\n    if (count > 1) {\n        var merger = new DeepMerger();\n        for (var i = 1; i < count; ++i) {\n            target = merger.merge(target, sources[i]);\n        }\n    }\n    return target;\n}\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger =  (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, tslib.__spreadArray([target,\n                            source,\n                            sourceKey], context, false));\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\n\nfunction concatPagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        merge: function (existing, incoming) {\n            return existing ? tslib.__spreadArray(tslib.__spreadArray([], existing, true), incoming, true) : incoming;\n        },\n    };\n}\nfunction offsetLimitPagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        merge: function (existing, incoming, _a) {\n            var args = _a.args;\n            var merged = existing ? existing.slice(0) : [];\n            if (incoming) {\n                if (args) {\n                    var _b = args.offset, offset = _b === void 0 ? 0 : _b;\n                    for (var i = 0; i < incoming.length; ++i) {\n                        merged[offset + i] = incoming[i];\n                    }\n                }\n                else {\n                    merged.push.apply(merged, incoming);\n                }\n            }\n            return merged;\n        },\n    };\n}\nfunction relayStylePagination(keyArgs) {\n    if (keyArgs === void 0) { keyArgs = false; }\n    return {\n        keyArgs: keyArgs,\n        read: function (existing, _a) {\n            var canRead = _a.canRead, readField = _a.readField;\n            if (!existing)\n                return existing;\n            var edges = [];\n            var firstEdgeCursor = \"\";\n            var lastEdgeCursor = \"\";\n            existing.edges.forEach(function (edge) {\n                if (canRead(readField(\"node\", edge))) {\n                    edges.push(edge);\n                    if (edge.cursor) {\n                        firstEdgeCursor = firstEdgeCursor || edge.cursor || \"\";\n                        lastEdgeCursor = edge.cursor || lastEdgeCursor;\n                    }\n                }\n            });\n            if (edges.length > 1 && firstEdgeCursor === lastEdgeCursor) {\n                firstEdgeCursor = \"\";\n            }\n            var _b = existing.pageInfo || {}, startCursor = _b.startCursor, endCursor = _b.endCursor;\n            return tslib.__assign(tslib.__assign({}, getExtras(existing)), { edges: edges, pageInfo: tslib.__assign(tslib.__assign({}, existing.pageInfo), {\n                    startCursor: startCursor || firstEdgeCursor, endCursor: endCursor || lastEdgeCursor }) });\n        },\n        merge: function (existing, incoming, _a) {\n            var args = _a.args, isReference = _a.isReference, readField = _a.readField;\n            if (!existing) {\n                existing = makeEmptyData();\n            }\n            if (!incoming) {\n                return existing;\n            }\n            var incomingEdges = incoming.edges ?\n                incoming.edges.map(function (edge) {\n                    if (isReference((edge = tslib.__assign({}, edge)))) {\n                        edge.cursor = readField(\"cursor\", edge);\n                    }\n                    return edge;\n                })\n                : [];\n            if (incoming.pageInfo) {\n                var pageInfo_1 = incoming.pageInfo;\n                var startCursor = pageInfo_1.startCursor, endCursor = pageInfo_1.endCursor;\n                var firstEdge = incomingEdges[0];\n                var lastEdge = incomingEdges[incomingEdges.length - 1];\n                if (firstEdge && startCursor) {\n                    firstEdge.cursor = startCursor;\n                }\n                if (lastEdge && endCursor) {\n                    lastEdge.cursor = endCursor;\n                }\n                var firstCursor = firstEdge && firstEdge.cursor;\n                if (firstCursor && !startCursor) {\n                    incoming = mergeDeep(incoming, {\n                        pageInfo: {\n                            startCursor: firstCursor,\n                        },\n                    });\n                }\n                var lastCursor = lastEdge && lastEdge.cursor;\n                if (lastCursor && !endCursor) {\n                    incoming = mergeDeep(incoming, {\n                        pageInfo: {\n                            endCursor: lastCursor,\n                        },\n                    });\n                }\n            }\n            var prefix = existing.edges;\n            var suffix = [];\n            if (args && args.after) {\n                var index = prefix.findIndex(function (edge) { return edge.cursor === args.after; });\n                if (index >= 0) {\n                    prefix = prefix.slice(0, index + 1);\n                }\n            }\n            else if (args && args.before) {\n                var index = prefix.findIndex(function (edge) { return edge.cursor === args.before; });\n                suffix = index < 0 ? prefix : prefix.slice(index);\n                prefix = [];\n            }\n            else if (incoming.edges) {\n                prefix = [];\n            }\n            var edges = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], prefix, true), incomingEdges, true), suffix, true);\n            var pageInfo = tslib.__assign(tslib.__assign({}, incoming.pageInfo), existing.pageInfo);\n            if (incoming.pageInfo) {\n                var _b = incoming.pageInfo, hasPreviousPage = _b.hasPreviousPage, hasNextPage = _b.hasNextPage, startCursor = _b.startCursor, endCursor = _b.endCursor, extras = tslib.__rest(_b, [\"hasPreviousPage\", \"hasNextPage\", \"startCursor\", \"endCursor\"]);\n                Object.assign(pageInfo, extras);\n                if (!prefix.length) {\n                    if (void 0 !== hasPreviousPage)\n                        pageInfo.hasPreviousPage = hasPreviousPage;\n                    if (void 0 !== startCursor)\n                        pageInfo.startCursor = startCursor;\n                }\n                if (!suffix.length) {\n                    if (void 0 !== hasNextPage)\n                        pageInfo.hasNextPage = hasNextPage;\n                    if (void 0 !== endCursor)\n                        pageInfo.endCursor = endCursor;\n                }\n            }\n            return tslib.__assign(tslib.__assign(tslib.__assign({}, getExtras(existing)), getExtras(incoming)), { edges: edges, pageInfo: pageInfo });\n        },\n    };\n}\nvar getExtras = function (obj) { return tslib.__rest(obj, notExtras); };\nvar notExtras = [\"edges\", \"pageInfo\"];\nfunction makeEmptyData() {\n    return {\n        edges: [],\n        pageInfo: {\n            hasPreviousPage: false,\n            hasNextPage: true,\n            startCursor: \"\",\n            endCursor: \"\",\n        },\n    };\n}\n\nfunction createFulfilledPromise(value) {\n    var promise = Promise.resolve(value);\n    promise.status = \"fulfilled\";\n    promise.value = value;\n    return promise;\n}\nfunction createRejectedPromise(reason) {\n    var promise = Promise.reject(reason);\n    promise.catch(function () { });\n    promise.status = \"rejected\";\n    promise.reason = reason;\n    return promise;\n}\nfunction isStatefulPromise(promise) {\n    return \"status\" in promise;\n}\nfunction wrapPromiseWithState(promise) {\n    if (isStatefulPromise(promise)) {\n        return promise;\n    }\n    var pendingPromise = promise;\n    pendingPromise.status = \"pending\";\n    pendingPromise.then(function (value) {\n        if (pendingPromise.status === \"pending\") {\n            var fulfilledPromise = pendingPromise;\n            fulfilledPromise.status = \"fulfilled\";\n            fulfilledPromise.value = value;\n        }\n    }, function (reason) {\n        if (pendingPromise.status === \"pending\") {\n            var rejectedPromise = pendingPromise;\n            rejectedPromise.status = \"rejected\";\n            rejectedPromise.reason = reason;\n        }\n    });\n    return promise;\n}\n\nfunction preventUnhandledRejection(promise) {\n    promise.catch(function () { });\n    return promise;\n}\n\nvar toString = Object.prototype.toString;\nfunction cloneDeep(value) {\n    return cloneDeepHelper(value);\n}\nfunction cloneDeepHelper(val, seen) {\n    switch (toString.call(val)) {\n        case \"[object Array]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_1 = val.slice(0);\n            seen.set(val, copy_1);\n            copy_1.forEach(function (child, i) {\n                copy_1[i] = cloneDeepHelper(child, seen);\n            });\n            return copy_1;\n        }\n        case \"[object Object]\": {\n            seen = seen || new Map();\n            if (seen.has(val))\n                return seen.get(val);\n            var copy_2 = Object.create(Object.getPrototypeOf(val));\n            seen.set(val, copy_2);\n            Object.keys(val).forEach(function (key) {\n                copy_2[key] = cloneDeepHelper(val[key], seen);\n            });\n            return copy_2;\n        }\n        default:\n            return val;\n    }\n}\n\nfunction deepFreeze(value) {\n    var workSet = new Set([value]);\n    workSet.forEach(function (obj) {\n        if (isNonNullObject(obj) && shallowFreeze(obj) === obj) {\n            Object.getOwnPropertyNames(obj).forEach(function (name) {\n                if (isNonNullObject(obj[name]))\n                    workSet.add(obj[name]);\n            });\n        }\n    });\n    return value;\n}\nfunction shallowFreeze(obj) {\n    if (globalThis.__DEV__ !== false && !Object.isFrozen(obj)) {\n        try {\n            Object.freeze(obj);\n        }\n        catch (e) {\n            if (e instanceof TypeError)\n                return null;\n            throw e;\n        }\n    }\n    return obj;\n}\nfunction maybeDeepFreeze(obj) {\n    if (globalThis.__DEV__ !== false) {\n        deepFreeze(obj);\n    }\n    return obj;\n}\n\nfunction iterateObserversSafely(observers, method, argument) {\n    var observersWithMethod = [];\n    observers.forEach(function (obs) { return obs[method] && observersWithMethod.push(obs); });\n    observersWithMethod.forEach(function (obs) { return obs[method](argument); });\n}\n\nfunction asyncMap(observable, mapFn, catchFn) {\n    return new zenObservableTs.Observable(function (observer) {\n        var promiseQueue = {\n            then: function (callback) {\n                return new Promise(function (resolve) { return resolve(callback()); });\n            },\n        };\n        function makeCallback(examiner, key) {\n            return function (arg) {\n                if (examiner) {\n                    var both = function () {\n                        return observer.closed ?\n                             0\n                            : examiner(arg);\n                    };\n                    promiseQueue = promiseQueue.then(both, both).then(function (result) { return observer.next(result); }, function (error) { return observer.error(error); });\n                }\n                else {\n                    observer[key](arg);\n                }\n            };\n        }\n        var handler = {\n            next: makeCallback(mapFn, \"next\"),\n            error: makeCallback(catchFn, \"error\"),\n            complete: function () {\n                 promiseQueue.then(function () { return observer.complete(); });\n            },\n        };\n        var sub = observable.subscribe(handler);\n        return function () { return sub.unsubscribe(); };\n    });\n}\n\nfunction fixObservableSubclass(subclass) {\n    function set(key) {\n        Object.defineProperty(subclass, key, { value: zenObservableTs.Observable });\n    }\n    if (canUseSymbol && Symbol.species) {\n        set(Symbol.species);\n    }\n    set(\"@@species\");\n    return subclass;\n}\n\nfunction isPromiseLike(value) {\n    return value && typeof value.then === \"function\";\n}\nvar Concast =  (function (_super) {\n    tslib.__extends(Concast, _super);\n    function Concast(sources) {\n        var _this = _super.call(this, function (observer) {\n            _this.addObserver(observer);\n            return function () { return _this.removeObserver(observer); };\n        }) || this;\n        _this.observers = new Set();\n        _this.promise = new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        });\n        _this.handlers = {\n            next: function (result) {\n                if (_this.sub !== null) {\n                    _this.latest = [\"next\", result];\n                    _this.notify(\"next\", result);\n                    iterateObserversSafely(_this.observers, \"next\", result);\n                }\n            },\n            error: function (error) {\n                var sub = _this.sub;\n                if (sub !== null) {\n                    if (sub)\n                        setTimeout(function () { return sub.unsubscribe(); });\n                    _this.sub = null;\n                    _this.latest = [\"error\", error];\n                    _this.reject(error);\n                    _this.notify(\"error\", error);\n                    iterateObserversSafely(_this.observers, \"error\", error);\n                }\n            },\n            complete: function () {\n                var _a = _this, sub = _a.sub, _b = _a.sources, sources = _b === void 0 ? [] : _b;\n                if (sub !== null) {\n                    var value = sources.shift();\n                    if (!value) {\n                        if (sub)\n                            setTimeout(function () { return sub.unsubscribe(); });\n                        _this.sub = null;\n                        if (_this.latest && _this.latest[0] === \"next\") {\n                            _this.resolve(_this.latest[1]);\n                        }\n                        else {\n                            _this.resolve();\n                        }\n                        _this.notify(\"complete\");\n                        iterateObserversSafely(_this.observers, \"complete\");\n                    }\n                    else if (isPromiseLike(value)) {\n                        value.then(function (obs) { return (_this.sub = obs.subscribe(_this.handlers)); }, _this.handlers.error);\n                    }\n                    else {\n                        _this.sub = value.subscribe(_this.handlers);\n                    }\n                }\n            },\n        };\n        _this.nextResultListeners = new Set();\n        _this.cancel = function (reason) {\n            _this.reject(reason);\n            _this.sources = [];\n            _this.handlers.error(reason);\n        };\n        _this.promise.catch(function (_) { });\n        if (typeof sources === \"function\") {\n            sources = [new zenObservableTs.Observable(sources)];\n        }\n        if (isPromiseLike(sources)) {\n            sources.then(function (iterable) { return _this.start(iterable); }, _this.handlers.error);\n        }\n        else {\n            _this.start(sources);\n        }\n        return _this;\n    }\n    Concast.prototype.start = function (sources) {\n        if (this.sub !== void 0)\n            return;\n        this.sources = Array.from(sources);\n        this.handlers.complete();\n    };\n    Concast.prototype.deliverLastMessage = function (observer) {\n        if (this.latest) {\n            var nextOrError = this.latest[0];\n            var method = observer[nextOrError];\n            if (method) {\n                method.call(observer, this.latest[1]);\n            }\n            if (this.sub === null && nextOrError === \"next\" && observer.complete) {\n                observer.complete();\n            }\n        }\n    };\n    Concast.prototype.addObserver = function (observer) {\n        if (!this.observers.has(observer)) {\n            this.deliverLastMessage(observer);\n            this.observers.add(observer);\n        }\n    };\n    Concast.prototype.removeObserver = function (observer) {\n        if (this.observers.delete(observer) && this.observers.size < 1) {\n            this.handlers.complete();\n        }\n    };\n    Concast.prototype.notify = function (method, arg) {\n        var nextResultListeners = this.nextResultListeners;\n        if (nextResultListeners.size) {\n            this.nextResultListeners = new Set();\n            nextResultListeners.forEach(function (listener) { return listener(method, arg); });\n        }\n    };\n    Concast.prototype.beforeNext = function (callback) {\n        var called = false;\n        this.nextResultListeners.add(function (method, arg) {\n            if (!called) {\n                called = true;\n                callback(method, arg);\n            }\n        });\n    };\n    return Concast;\n}(zenObservableTs.Observable));\nfixObservableSubclass(Concast);\n\nfunction isExecutionPatchIncrementalResult(value) {\n    return \"incremental\" in value;\n}\nfunction isExecutionPatchInitialResult(value) {\n    return \"hasNext\" in value && \"data\" in value;\n}\nfunction isExecutionPatchResult(value) {\n    return (isExecutionPatchIncrementalResult(value) ||\n        isExecutionPatchInitialResult(value));\n}\nfunction isApolloPayloadResult(value) {\n    return isNonNullObject(value) && \"payload\" in value;\n}\nfunction mergeIncrementalData(prevResult, result) {\n    var mergedData = prevResult;\n    var merger = new DeepMerger();\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (_a) {\n            var data = _a.data, path = _a.path;\n            for (var i = path.length - 1; i >= 0; --i) {\n                var key = path[i];\n                var isNumericKey = !isNaN(+key);\n                var parent_1 = isNumericKey ? [] : {};\n                parent_1[key] = data;\n                data = parent_1;\n            }\n            mergedData = merger.merge(mergedData, data);\n        });\n    }\n    return mergedData;\n}\n\nfunction graphQLResultHasError(result) {\n    var errors = getGraphQLErrorsFromResult(result);\n    return isNonEmptyArray(errors);\n}\nfunction getGraphQLErrorsFromResult(result) {\n    var graphQLErrors = isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (incrementalResult) {\n            if (incrementalResult.errors) {\n                graphQLErrors.push.apply(graphQLErrors, incrementalResult.errors);\n            }\n        });\n    }\n    return graphQLErrors;\n}\n\nfunction compact() {\n    var objects = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        objects[_i] = arguments[_i];\n    }\n    var result = Object.create(null);\n    objects.forEach(function (obj) {\n        if (!obj)\n            return;\n        Object.keys(obj).forEach(function (key) {\n            var value = obj[key];\n            if (value !== void 0) {\n                result[key] = value;\n            }\n        });\n    });\n    return result;\n}\n\nvar prefixCounts = new Map();\nfunction makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n\nfunction stringifyForDisplay(value, space) {\n    if (space === void 0) { space = 0; }\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }, space)\n        .split(JSON.stringify(undefId))\n        .join(\"<undefined>\");\n}\n\nfunction mergeOptions(defaults, options) {\n    return compact(defaults, options, options.variables && {\n        variables: compact(tslib.__assign(tslib.__assign({}, (defaults && defaults.variables)), options.variables)),\n    });\n}\n\nfunction omitDeep(value, key) {\n    return __omitDeep(value, key);\n}\nfunction __omitDeep(value, key, known) {\n    if (known === void 0) { known = new Map(); }\n    if (known.has(value)) {\n        return known.get(value);\n    }\n    var modified = false;\n    if (Array.isArray(value)) {\n        var array_1 = [];\n        known.set(value, array_1);\n        value.forEach(function (value, index) {\n            var result = __omitDeep(value, key, known);\n            modified || (modified = result !== value);\n            array_1[index] = result;\n        });\n        if (modified) {\n            return array_1;\n        }\n    }\n    else if (isPlainObject(value)) {\n        var obj_1 = Object.create(Object.getPrototypeOf(value));\n        known.set(value, obj_1);\n        Object.keys(value).forEach(function (k) {\n            if (k === key) {\n                modified = true;\n                return;\n            }\n            var result = __omitDeep(value[k], key, known);\n            modified || (modified = result !== value[k]);\n            obj_1[k] = result;\n        });\n        if (modified) {\n            return obj_1;\n        }\n    }\n    return value;\n}\n\nfunction stripTypename(value) {\n    return omitDeep(value, \"__typename\");\n}\n\nexports.DEV = globals.DEV;\nexports.maybe = globals.maybe;\nexports.Observable = zenObservableTs.Observable;\nexports.AutoCleanedStrongCache = AutoCleanedStrongCache;\nexports.AutoCleanedWeakCache = AutoCleanedWeakCache;\nexports.Concast = Concast;\nexports.DeepMerger = DeepMerger;\nexports.DocumentTransform = DocumentTransform;\nexports.addNonReactiveToNamedFragments = addNonReactiveToNamedFragments;\nexports.addTypenameToDocument = addTypenameToDocument;\nexports.argumentsObjectFromField = argumentsObjectFromField;\nexports.asyncMap = asyncMap;\nexports.buildQueryFromSelectionSet = buildQueryFromSelectionSet;\nexports.cacheSizes = cacheSizes;\nexports.canUseAsyncIteratorSymbol = canUseAsyncIteratorSymbol;\nexports.canUseDOM = canUseDOM;\nexports.canUseLayoutEffect = canUseLayoutEffect;\nexports.canUseSymbol = canUseSymbol;\nexports.canUseWeakMap = canUseWeakMap;\nexports.canUseWeakSet = canUseWeakSet;\nexports.canonicalStringify = canonicalStringify;\nexports.checkDocument = checkDocument;\nexports.cloneDeep = cloneDeep;\nexports.compact = compact;\nexports.concatPagination = concatPagination;\nexports.createFragmentMap = createFragmentMap;\nexports.createFulfilledPromise = createFulfilledPromise;\nexports.createRejectedPromise = createRejectedPromise;\nexports.fixObservableSubclass = fixObservableSubclass;\nexports.getDefaultValues = getDefaultValues;\nexports.getDirectiveNames = getDirectiveNames;\nexports.getFragmentDefinition = getFragmentDefinition;\nexports.getFragmentDefinitions = getFragmentDefinitions;\nexports.getFragmentFromSelection = getFragmentFromSelection;\nexports.getFragmentMaskMode = getFragmentMaskMode;\nexports.getFragmentQueryDocument = getFragmentQueryDocument;\nexports.getGraphQLErrorsFromResult = getGraphQLErrorsFromResult;\nexports.getInclusionDirectives = getInclusionDirectives;\nexports.getMainDefinition = getMainDefinition;\nexports.getOperationDefinition = getOperationDefinition;\nexports.getOperationName = getOperationName;\nexports.getQueryDefinition = getQueryDefinition;\nexports.getStoreKeyName = getStoreKeyName;\nexports.getTypenameFromResult = getTypenameFromResult;\nexports.graphQLResultHasError = graphQLResultHasError;\nexports.hasAllDirectives = hasAllDirectives;\nexports.hasAnyDirectives = hasAnyDirectives;\nexports.hasClientExports = hasClientExports;\nexports.hasDirectives = hasDirectives;\nexports.isApolloPayloadResult = isApolloPayloadResult;\nexports.isArray = isArray;\nexports.isDocumentNode = isDocumentNode;\nexports.isExecutionPatchIncrementalResult = isExecutionPatchIncrementalResult;\nexports.isExecutionPatchInitialResult = isExecutionPatchInitialResult;\nexports.isExecutionPatchResult = isExecutionPatchResult;\nexports.isField = isField;\nexports.isFullyUnmaskedOperation = isFullyUnmaskedOperation;\nexports.isInlineFragment = isInlineFragment;\nexports.isMutationOperation = isMutationOperation;\nexports.isNonEmptyArray = isNonEmptyArray;\nexports.isNonNullObject = isNonNullObject;\nexports.isPlainObject = isPlainObject;\nexports.isQueryOperation = isQueryOperation;\nexports.isReference = isReference;\nexports.isStatefulPromise = isStatefulPromise;\nexports.isSubscriptionOperation = isSubscriptionOperation;\nexports.iterateObserversSafely = iterateObserversSafely;\nexports.makeReference = makeReference;\nexports.makeUniqueId = makeUniqueId;\nexports.maybeDeepFreeze = maybeDeepFreeze;\nexports.mergeDeep = mergeDeep;\nexports.mergeDeepArray = mergeDeepArray;\nexports.mergeIncrementalData = mergeIncrementalData;\nexports.mergeOptions = mergeOptions;\nexports.offsetLimitPagination = offsetLimitPagination;\nexports.omitDeep = omitDeep;\nexports.preventUnhandledRejection = preventUnhandledRejection;\nexports.print = print;\nexports.relayStylePagination = relayStylePagination;\nexports.removeArgumentsFromDocument = removeArgumentsFromDocument;\nexports.removeClientSetsFromDocument = removeClientSetsFromDocument;\nexports.removeConnectionDirectiveFromDocument = removeConnectionDirectiveFromDocument;\nexports.removeDirectivesFromDocument = removeDirectivesFromDocument;\nexports.removeFragmentSpreadFromDocument = removeFragmentSpreadFromDocument;\nexports.resultKeyNameFromField = resultKeyNameFromField;\nexports.shouldInclude = shouldInclude;\nexports.storeKeyNameFromField = storeKeyNameFromField;\nexports.stringifyForDisplay = stringifyForDisplay;\nexports.stripTypename = stripTypename;\nexports.valueToObjectRepresentation = valueToObjectRepresentation;\nexports.wrapPromiseWithState = wrapPromiseWithState;\n//# sourceMappingURL=utilities.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tsInvariant = require('ts-invariant');\n\nvar version = \"3.14.0\";\n\nfunction maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch (_a) { }\n}\n\nvar global$1 = (maybe(function () { return globalThis; }) ||\n    maybe(function () { return window; }) ||\n    maybe(function () { return self; }) ||\n    maybe(function () { return global; }) ||\nmaybe(function () {\n    return maybe.constructor(\"return this\")();\n}));\n\nvar prefixCounts = new Map();\nfunction makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n\nfunction stringifyForDisplay(value, space) {\n    if (space === void 0) { space = 0; }\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }, space)\n        .split(JSON.stringify(undefId))\n        .join(\"<undefined>\");\n}\n\nfunction wrap(fn) {\n    return function (message) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        if (typeof message === \"number\") {\n            var arg0 = message;\n            message = getHandledErrorMsg(arg0);\n            if (!message) {\n                message = getFallbackErrorMsg(arg0, args);\n                args = [];\n            }\n        }\n        fn.apply(void 0, [message].concat(args));\n    };\n}\nvar invariant = Object.assign(function invariant(condition, message) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    if (!condition) {\n        tsInvariant.invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));\n    }\n}, {\n    debug: wrap(tsInvariant.invariant.debug),\n    log: wrap(tsInvariant.invariant.log),\n    warn: wrap(tsInvariant.invariant.warn),\n    error: wrap(tsInvariant.invariant.error),\n});\nfunction newInvariantError(message) {\n    var optionalParams = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        optionalParams[_i - 1] = arguments[_i];\n    }\n    return new tsInvariant.InvariantError(getHandledErrorMsg(message, optionalParams) ||\n        getFallbackErrorMsg(message, optionalParams));\n}\nvar ApolloErrorMessageHandler = Symbol.for(\"ApolloErrorMessageHandler_\" + version);\nfunction stringify(arg) {\n    if (typeof arg == \"string\") {\n        return arg;\n    }\n    try {\n        return stringifyForDisplay(arg, 2).slice(0, 1000);\n    }\n    catch (_a) {\n        return \"<non-serializable>\";\n    }\n}\nfunction getHandledErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return (global$1[ApolloErrorMessageHandler] &&\n        global$1[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));\n}\nfunction getFallbackErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return \"An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#\".concat(encodeURIComponent(JSON.stringify({\n        version: version,\n        message: message,\n        args: messageArgs.map(stringify),\n    })));\n}\n\nvar DEV = globalThis.__DEV__ !== false;\n\nexports.InvariantError = tsInvariant.InvariantError;\nexports.DEV = DEV;\nexports.__DEV__ = DEV;\nexports.global = global$1;\nexports.invariant = invariant;\nexports.maybe = maybe;\nexports.newInvariantError = newInvariantError;\n//# sourceMappingURL=globals.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar React = require('rehackt');\nvar context = require('../context');\nvar tslib = require('tslib');\nvar utilities = require('../../utilities');\nvar equal = require('@wry/equality');\nvar errors = require('../../errors');\nvar core = require('../../core');\nvar parser = require('../parser');\nvar optimism = require('optimism');\nvar tsInvariant = require('ts-invariant');\nvar internal = require('../internal');\nvar cache = require('../../cache');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e[\"default\"] : e; }\n\nfunction _interopNamespace(e) {\n    if (e && e.__esModule) return e;\n    var n = Object.create(null);\n    if (e) {\n        for (var k in e) {\n            n[k] = e[k];\n        }\n    }\n    n[\"default\"] = e;\n    return Object.freeze(n);\n}\n\nvar React__namespace = /*#__PURE__*/_interopNamespace(React);\nvar equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);\n\nfunction useApolloClient(override) {\n    var context$1 = React__namespace.useContext(context.getApolloContext());\n    var client = override || context$1.client;\n    globals.invariant(!!client, 79);\n    return client;\n}\n\nvar didWarnUncachedGetSnapshot = false;\nvar uSESKey = \"useSyncExternalStore\";\nvar realHook$1 = React__namespace[uSESKey];\nvar useSyncExternalStore = realHook$1 ||\n    (function (subscribe, getSnapshot, getServerSnapshot) {\n        var value = getSnapshot();\n        if (\n        globalThis.__DEV__ !== false &&\n            !didWarnUncachedGetSnapshot &&\n            value !== getSnapshot()) {\n            didWarnUncachedGetSnapshot = true;\n            globalThis.__DEV__ !== false && globals.invariant.error(92);\n        }\n        var _a = React__namespace.useState({\n            inst: { value: value, getSnapshot: getSnapshot },\n        }), inst = _a[0].inst, forceUpdate = _a[1];\n        if (utilities.canUseLayoutEffect) {\n            React__namespace.useLayoutEffect(function () {\n                Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n                if (checkIfSnapshotChanged(inst)) {\n                    forceUpdate({ inst: inst });\n                }\n            }, [subscribe, value, getSnapshot]);\n        }\n        else {\n            Object.assign(inst, { value: value, getSnapshot: getSnapshot });\n        }\n        React__namespace.useEffect(function () {\n            if (checkIfSnapshotChanged(inst)) {\n                forceUpdate({ inst: inst });\n            }\n            return subscribe(function handleStoreChange() {\n                if (checkIfSnapshotChanged(inst)) {\n                    forceUpdate({ inst: inst });\n                }\n            });\n        }, [subscribe]);\n        return value;\n    });\nfunction checkIfSnapshotChanged(_a) {\n    var value = _a.value, getSnapshot = _a.getSnapshot;\n    try {\n        return value !== getSnapshot();\n    }\n    catch (_b) {\n        return true;\n    }\n}\n\nfunction useDeepMemo(memoFn, deps) {\n    var ref = React__namespace.useRef(void 0);\n    if (!ref.current || !equal.equal(ref.current.deps, deps)) {\n        ref.current = { value: memoFn(), deps: deps };\n    }\n    return ref.current.value;\n}\n\nvar useIsomorphicLayoutEffect = utilities.canUseDOM ? React__namespace.useLayoutEffect : React__namespace.useEffect;\n\nvar Ctx;\nfunction noop$1() { }\nfunction useRenderGuard() {\n    if (!Ctx) {\n        Ctx = React__namespace.createContext(null);\n    }\n    return React__namespace.useCallback(\n function () {\n        var orig = console.error;\n        try {\n            console.error = noop$1;\n            React__namespace[\"useContext\" ](Ctx);\n            return true;\n        }\n        catch (e) {\n            return false;\n        }\n        finally {\n            console.error = orig;\n        }\n    }, []);\n}\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global$2 = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global$2[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\nfunction warnRemovedOption(options, name, callSite, recommendation) {\n    if (recommendation === void 0) { recommendation = \"Please remove this option.\"; }\n    warnDeprecated(name, function () {\n        if (name in options) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(104, callSite, name, recommendation);\n        }\n    });\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nfunction useWarnRemovedOption(options, name, callSite, recommendation) {\n    \"use no memo\";\n    if (recommendation === void 0) { recommendation = \"Please remove this option.\"; }\n    var didWarn = React__namespace.useRef(false);\n    if (name in options && !didWarn.current) {\n        globalThis.__DEV__ !== false && globals.invariant.warn(78, callSite, name, recommendation);\n        didWarn.current = true;\n    }\n}\n\nvar useKey = \"use\";\nvar realHook = React__namespace[useKey];\nvar __use = realHook ||\n    function __use(promise) {\n        var statefulPromise = utilities.wrapPromiseWithState(promise);\n        switch (statefulPromise.status) {\n            case \"pending\":\n                throw statefulPromise;\n            case \"rejected\":\n                throw statefulPromise.reason;\n            case \"fulfilled\":\n                return statefulPromise.value;\n        }\n    };\n\nvar wrapperSymbol = Symbol.for(\"apollo.hook.wrappers\");\nfunction wrapHook(hookName, useHook, clientOrObsQuery) {\n    var queryManager = clientOrObsQuery[\"queryManager\"];\n    var wrappers = queryManager && queryManager[wrapperSymbol];\n    var wrapper = wrappers && wrappers[hookName];\n    return wrapper ? wrapper(useHook) : useHook;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nfunction noop() { }\nvar lastWatchOptions = Symbol();\nfunction useQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return wrapHook(\"useQuery\", useQuery_, useApolloClient(options && options.client))(query, options);\n}\nfunction useQuery_(query, options) {\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(options, \"canonizeResults\", \"useQuery\");\n        useWarnRemovedOption(options, \"partialRefetch\", \"useQuery\");\n        useWarnRemovedOption(options, \"defaultOptions\", \"useQuery\", \"Pass the options directly to the hook instead.\");\n        useWarnRemovedOption(options, \"onCompleted\", \"useQuery\", \"If your `onCompleted` callback sets local state, switch to use derived state using `data` returned from the hook instead. Use `useEffect` to perform side-effects as a result of updates to `data`.\");\n        useWarnRemovedOption(options, \"onError\", \"useQuery\", \"If your `onError` callback sets local state, switch to use derived state using `data`, `error` or `errors` returned from the hook instead. Use `useEffect` if you need to perform side-effects as a result of updates to `data`, `error` or `errors`.\");\n    }\n    var _a = useQueryInternals(query, options), result = _a.result, obsQueryFields = _a.obsQueryFields;\n    return React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign({}, result), obsQueryFields)); }, [result, obsQueryFields]);\n}\nfunction useInternalState(client, query, options, renderPromises, makeWatchQueryOptions) {\n    function createInternalState(previous) {\n        var _a;\n        parser.verifyDocumentType(query, parser.DocumentType.Query);\n        var internalState = {\n            client: client,\n            query: query,\n            observable:\n            (renderPromises &&\n                renderPromises.getSSRObservable(makeWatchQueryOptions())) ||\n                core.ObservableQuery[\"inactiveOnCreation\"].withValue(!renderPromises, function () {\n                    return muteDeprecations(\"canonizeResults\", function () {\n                        return client.watchQuery(getObsQueryOptions(void 0, client, options, makeWatchQueryOptions()));\n                    });\n                }),\n            resultData: {\n                previousData: (_a = previous === null || previous === void 0 ? void 0 : previous.resultData.current) === null || _a === void 0 ? void 0 : _a.data,\n            },\n        };\n        return internalState;\n    }\n    var _a = React__namespace.useState(createInternalState), internalState = _a[0], updateInternalState = _a[1];\n    function onQueryExecuted(watchQueryOptions) {\n        var _a;\n        var _b;\n        Object.assign(internalState.observable, (_a = {},\n            _a[lastWatchOptions] = watchQueryOptions,\n            _a));\n        var resultData = internalState.resultData;\n        updateInternalState(tslib.__assign(tslib.__assign({}, internalState), {\n            query: watchQueryOptions.query, resultData: Object.assign(resultData, {\n                previousData: ((_b = resultData.current) === null || _b === void 0 ? void 0 : _b.data) || resultData.previousData,\n                current: undefined,\n            }) }));\n    }\n    if (client !== internalState.client || query !== internalState.query) {\n        var newInternalState = createInternalState(internalState);\n        updateInternalState(newInternalState);\n        return [newInternalState, onQueryExecuted];\n    }\n    return [internalState, onQueryExecuted];\n}\nfunction useQueryInternals(query, options) {\n    var client = useApolloClient(options.client);\n    var renderPromises = React__namespace.useContext(context.getApolloContext()).renderPromises;\n    var isSyncSSR = !!renderPromises;\n    var disableNetworkFetches = client.disableNetworkFetches;\n    var ssrAllowed = options.ssr !== false && !options.skip;\n    var partialRefetch = options.partialRefetch;\n    var makeWatchQueryOptions = createMakeWatchQueryOptions(client, query, options, isSyncSSR);\n    var _a = useInternalState(client, query, options, renderPromises, makeWatchQueryOptions), _b = _a[0], observable = _b.observable, resultData = _b.resultData, onQueryExecuted = _a[1];\n    var watchQueryOptions = makeWatchQueryOptions(observable);\n    useResubscribeIfNecessary(resultData,\n    observable,\n    client, options, watchQueryOptions);\n    var obsQueryFields = React__namespace.useMemo(function () { return bindObservableMethods(observable); }, [observable]);\n    useRegisterSSRObservable(observable, renderPromises, ssrAllowed);\n    var result = useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, {\n        onCompleted: options.onCompleted || noop,\n        onError: options.onError || noop,\n    });\n    return {\n        result: result,\n        obsQueryFields: obsQueryFields,\n        observable: observable,\n        resultData: resultData,\n        client: client,\n        onQueryExecuted: onQueryExecuted,\n    };\n}\nfunction useObservableSubscriptionResult(resultData, observable, client, options, watchQueryOptions, disableNetworkFetches, partialRefetch, isSyncSSR, callbacks) {\n    var callbackRef = React__namespace.useRef(callbacks);\n    React__namespace.useEffect(function () {\n        callbackRef.current = callbacks;\n    });\n    var resultOverride = ((isSyncSSR || disableNetworkFetches) &&\n        options.ssr === false &&\n        !options.skip) ?\n        ssrDisabledResult\n        : options.skip || watchQueryOptions.fetchPolicy === \"standby\" ?\n            skipStandbyResult\n            : void 0;\n    var previousData = resultData.previousData;\n    var currentResultOverride = React__namespace.useMemo(function () {\n        return resultOverride &&\n            toQueryResult(resultOverride, previousData, observable, client);\n    }, [client, observable, resultOverride, previousData]);\n    return useSyncExternalStore(React__namespace.useCallback(function (handleStoreChange) {\n        if (isSyncSSR) {\n            return function () { };\n        }\n        var onNext = function () {\n            var previousResult = resultData.current;\n            var result = observable.getCurrentResult();\n            if (previousResult &&\n                previousResult.loading === result.loading &&\n                previousResult.networkStatus === result.networkStatus &&\n                equal.equal(previousResult.data, result.data)) {\n                return;\n            }\n            setResult(result, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);\n        };\n        var onError = function (error) {\n            subscription.current.unsubscribe();\n            subscription.current = observable.resubscribeAfterError(onNext, onError);\n            if (!hasOwnProperty.call(error, \"graphQLErrors\")) {\n                throw error;\n            }\n            var previousResult = resultData.current;\n            if (!previousResult ||\n                (previousResult && previousResult.loading) ||\n                !equal.equal(error, previousResult.error)) {\n                setResult({\n                    data: (previousResult &&\n                        previousResult.data),\n                    error: error,\n                    loading: false,\n                    networkStatus: core.NetworkStatus.error,\n                }, resultData, observable, client, partialRefetch, handleStoreChange, callbackRef.current);\n            }\n        };\n        var subscription = { current: observable.subscribe(onNext, onError) };\n        return function () {\n            setTimeout(function () { return subscription.current.unsubscribe(); });\n        };\n    }, [\n        disableNetworkFetches,\n        isSyncSSR,\n        observable,\n        resultData,\n        partialRefetch,\n        client,\n    ]), function () {\n        return currentResultOverride ||\n            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);\n    }, function () {\n        return currentResultOverride ||\n            getCurrentResult(resultData, observable, callbackRef.current, partialRefetch, client);\n    });\n}\nfunction useRegisterSSRObservable(observable, renderPromises, ssrAllowed) {\n    if (renderPromises && ssrAllowed) {\n        renderPromises.registerSSRObservable(observable);\n        if (observable.getCurrentResult().loading) {\n            renderPromises.addObservableQueryPromise(observable);\n        }\n    }\n}\nfunction useResubscribeIfNecessary(\nresultData,\nobservable, client, options, watchQueryOptions) {\n    var _a;\n    if (observable[lastWatchOptions] &&\n        !equal.equal(observable[lastWatchOptions], watchQueryOptions)) {\n        observable.reobserve(getObsQueryOptions(observable, client, options, watchQueryOptions));\n        resultData.previousData =\n            ((_a = resultData.current) === null || _a === void 0 ? void 0 : _a.data) || resultData.previousData;\n        resultData.current = void 0;\n    }\n    observable[lastWatchOptions] = watchQueryOptions;\n}\nfunction createMakeWatchQueryOptions(client, query, _a, isSyncSSR) {\n    if (_a === void 0) { _a = {}; }\n    var skip = _a.skip; _a.ssr; _a.onCompleted; _a.onError; var defaultOptions = _a.defaultOptions,\n    otherOptions = tslib.__rest(_a, [\"skip\", \"ssr\", \"onCompleted\", \"onError\", \"defaultOptions\"]);\n    return function (observable) {\n        var watchQueryOptions = Object.assign(otherOptions, { query: query });\n        if (isSyncSSR &&\n            (watchQueryOptions.fetchPolicy === \"network-only\" ||\n                watchQueryOptions.fetchPolicy === \"cache-and-network\")) {\n            watchQueryOptions.fetchPolicy = \"cache-first\";\n        }\n        if (!watchQueryOptions.variables) {\n            watchQueryOptions.variables = {};\n        }\n        if (skip) {\n            watchQueryOptions.initialFetchPolicy =\n                watchQueryOptions.initialFetchPolicy ||\n                    watchQueryOptions.fetchPolicy ||\n                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        else if (!watchQueryOptions.fetchPolicy) {\n            watchQueryOptions.fetchPolicy =\n                (observable === null || observable === void 0 ? void 0 : observable.options.initialFetchPolicy) ||\n                    getDefaultFetchPolicy(defaultOptions, client.defaultOptions);\n        }\n        return watchQueryOptions;\n    };\n}\nfunction getObsQueryOptions(observable, client, queryHookOptions, watchQueryOptions) {\n    var toMerge = [];\n    var globalDefaults = client.defaultOptions.watchQuery;\n    if (globalDefaults)\n        toMerge.push(globalDefaults);\n    if (queryHookOptions.defaultOptions) {\n        toMerge.push(queryHookOptions.defaultOptions);\n    }\n    toMerge.push(utilities.compact(observable && observable.options, watchQueryOptions));\n    return toMerge.reduce(utilities.mergeOptions);\n}\nfunction setResult(nextResult, resultData, observable, client, partialRefetch, forceUpdate, callbacks) {\n    var previousResult = resultData.current;\n    if (previousResult && previousResult.data) {\n        resultData.previousData = previousResult.data;\n    }\n    if (!nextResult.error && utilities.isNonEmptyArray(nextResult.errors)) {\n        nextResult.error = new errors.ApolloError({ graphQLErrors: nextResult.errors });\n    }\n    resultData.current = toQueryResult(unsafeHandlePartialRefetch(nextResult, observable, partialRefetch), resultData.previousData, observable, client);\n    forceUpdate();\n    handleErrorOrCompleted(nextResult, previousResult === null || previousResult === void 0 ? void 0 : previousResult.networkStatus, callbacks);\n}\nfunction handleErrorOrCompleted(result, previousNetworkStatus, callbacks) {\n    if (!result.loading) {\n        var error_1 = toApolloError$1(result);\n        Promise.resolve()\n            .then(function () {\n            if (error_1) {\n                callbacks.onError(error_1);\n            }\n            else if (result.data &&\n                previousNetworkStatus !== result.networkStatus &&\n                result.networkStatus === core.NetworkStatus.ready) {\n                callbacks.onCompleted(result.data);\n            }\n        })\n            .catch(function (error) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(error);\n        });\n    }\n}\nfunction getCurrentResult(resultData, observable, callbacks, partialRefetch, client) {\n    if (!resultData.current) {\n        setResult(observable.getCurrentResult(), resultData, observable, client, partialRefetch, function () { }, callbacks);\n    }\n    return resultData.current;\n}\nfunction getDefaultFetchPolicy(queryHookDefaultOptions, clientDefaultOptions) {\n    var _a;\n    return ((queryHookDefaultOptions === null || queryHookDefaultOptions === void 0 ? void 0 : queryHookDefaultOptions.fetchPolicy) ||\n        ((_a = clientDefaultOptions === null || clientDefaultOptions === void 0 ? void 0 : clientDefaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n        \"cache-first\");\n}\nfunction toApolloError$1(result) {\n    return utilities.isNonEmptyArray(result.errors) ?\n        new errors.ApolloError({ graphQLErrors: result.errors })\n        : result.error;\n}\nfunction toQueryResult(result, previousData, observable, client) {\n    var data = result.data; result.partial; var resultWithoutPartial = tslib.__rest(result, [\"data\", \"partial\"]);\n    var queryResult = tslib.__assign(tslib.__assign({ data: data }, resultWithoutPartial), { client: client, observable: observable, variables: observable.variables, called: result !== ssrDisabledResult && result !== skipStandbyResult, previousData: previousData });\n    return queryResult;\n}\nfunction unsafeHandlePartialRefetch(result, observable, partialRefetch) {\n    if (result.partial &&\n        partialRefetch &&\n        !result.loading &&\n        (!result.data || Object.keys(result.data).length === 0) &&\n        observable.options.fetchPolicy !== \"cache-only\") {\n        observable.refetch();\n        return tslib.__assign(tslib.__assign({}, result), { loading: true, networkStatus: core.NetworkStatus.refetch });\n    }\n    return result;\n}\nvar ssrDisabledResult = utilities.maybeDeepFreeze({\n    loading: true,\n    data: void 0,\n    error: void 0,\n    networkStatus: core.NetworkStatus.loading,\n});\nvar skipStandbyResult = utilities.maybeDeepFreeze({\n    loading: false,\n    data: void 0,\n    error: void 0,\n    networkStatus: core.NetworkStatus.ready,\n});\nfunction bindObservableMethods(observable) {\n    return {\n        refetch: observable.refetch.bind(observable),\n        reobserve: function () {\n            var args = [];\n            for (var _i = 0; _i < arguments.length; _i++) {\n                args[_i] = arguments[_i];\n            }\n            if (globalThis.__DEV__ !== false) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(84);\n            }\n            return observable.reobserve.apply(observable, args);\n        },\n        fetchMore: observable.fetchMore.bind(observable),\n        updateQuery: observable.updateQuery.bind(observable),\n        startPolling: observable.startPolling.bind(observable),\n        stopPolling: observable.stopPolling.bind(observable),\n        subscribeToMore: observable.subscribeToMore.bind(observable),\n    };\n}\n\nvar version = \"3.14.0\";\n\nfunction maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch (_a) { }\n}\n\nvar global$1 = (maybe(function () { return globalThis; }) ||\n    maybe(function () { return window; }) ||\n    maybe(function () { return self; }) ||\n    maybe(function () { return global; }) ||\nmaybe(function () {\n    return maybe.constructor(\"return this\")();\n}));\n\nvar prefixCounts = new Map();\nfunction makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n\nfunction stringifyForDisplay(value, space) {\n    if (space === void 0) { space = 0; }\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }, space)\n        .split(JSON.stringify(undefId))\n        .join(\"<undefined>\");\n}\n\nfunction wrap(fn) {\n    return function (message) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        if (typeof message === \"number\") {\n            var arg0 = message;\n            message = getHandledErrorMsg(arg0);\n            if (!message) {\n                message = getFallbackErrorMsg(arg0, args);\n                args = [];\n            }\n        }\n        fn.apply(void 0, [message].concat(args));\n    };\n}\nvar invariant = Object.assign(function invariant(condition, message) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    if (!condition) {\n        tsInvariant.invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));\n    }\n}, {\n    debug: wrap(tsInvariant.invariant.debug),\n    log: wrap(tsInvariant.invariant.log),\n    warn: wrap(tsInvariant.invariant.warn),\n    error: wrap(tsInvariant.invariant.error),\n});\nvar ApolloErrorMessageHandler = Symbol.for(\"ApolloErrorMessageHandler_\" + version);\nfunction stringify(arg) {\n    if (typeof arg == \"string\") {\n        return arg;\n    }\n    try {\n        return stringifyForDisplay(arg, 2).slice(0, 1000);\n    }\n    catch (_a) {\n        return \"<non-serializable>\";\n    }\n}\nfunction getHandledErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return (global$1[ApolloErrorMessageHandler] &&\n        global$1[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));\n}\nfunction getFallbackErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return \"An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#\".concat(encodeURIComponent(JSON.stringify({\n        version: version,\n        message: message,\n        args: messageArgs.map(stringify),\n    })));\n}\n\nvar EAGER_METHODS = [\n    \"refetch\",\n    \"reobserve\",\n    \"fetchMore\",\n    \"updateQuery\",\n    \"startPolling\",\n    \"stopPolling\",\n    \"subscribeToMore\",\n];\nvar REMOVED_EXECUTE_OPTIONS = [\n    \"initialFetchPolicy\",\n    \"onCompleted\",\n    \"onError\",\n    \"defaultOptions\",\n    \"partialRefetch\",\n    \"canonizeResults\",\n];\nvar DEPRECATED_EXECUTE_OPTIONS = [\n    \"query\",\n    \"ssr\",\n    \"client\",\n    \"fetchPolicy\",\n    \"nextFetchPolicy\",\n    \"refetchWritePolicy\",\n    \"errorPolicy\",\n    \"pollInterval\",\n    \"notifyOnNetworkStatusChange\",\n    \"returnPartialData\",\n    \"skipPollAttempt\",\n];\nfunction useLazyQuery(query, options) {\n    var _a;\n    if (globalThis.__DEV__ !== false) {\n        var warnOpts = options || {};\n        useWarnRemovedOption(warnOpts, \"canonizeResults\", \"useLazyQuery\");\n        useWarnRemovedOption(warnOpts, \"variables\", \"useLazyQuery\", \"Pass all `variables` to the returned `execute` function instead.\");\n        useWarnRemovedOption(warnOpts, \"context\", \"useLazyQuery\", \"Pass `context` to the returned `execute` function instead.\");\n        useWarnRemovedOption(warnOpts, \"onCompleted\", \"useLazyQuery\", \"If your `onCompleted` callback sets local state, switch to use derived state using `data` returned from the hook instead. Use `useEffect` to perform side-effects as a result of updates to `data`.\");\n        useWarnRemovedOption(warnOpts, \"onError\", \"useLazyQuery\", \"If your `onError` callback sets local state, switch to use derived state using `data`, `error` or `errors` returned from the hook instead. Use `useEffect` if you need to perform side-effects as a result of updates to `data`, `error` or `errors`.\");\n        useWarnRemovedOption(warnOpts, \"defaultOptions\", \"useLazyQuery\", \"Pass the options directly to the hook instead.\");\n        useWarnRemovedOption(warnOpts, \"initialFetchPolicy\", \"useLazyQuery\", \"Use the `fetchPolicy` option instead.\");\n        useWarnRemovedOption(warnOpts, \"partialRefetch\", \"useLazyQuery\");\n    }\n    var execOptionsRef = React__namespace.useRef(void 0);\n    var optionsRef = React__namespace.useRef(void 0);\n    var queryRef = React__namespace.useRef(void 0);\n    var merged = utilities.mergeOptions(options, execOptionsRef.current || {});\n    var document = (_a = merged === null || merged === void 0 ? void 0 : merged.query) !== null && _a !== void 0 ? _a : query;\n    optionsRef.current = options;\n    queryRef.current = document;\n    var queryHookOptions = tslib.__assign(tslib.__assign({}, merged), { skip: !execOptionsRef.current });\n    var _b = useQueryInternals(document, queryHookOptions), obsQueryFields = _b.obsQueryFields, useQueryResult = _b.result, client = _b.client, resultData = _b.resultData, observable = _b.observable, onQueryExecuted = _b.onQueryExecuted;\n    var initialFetchPolicy = observable.options.initialFetchPolicy ||\n        getDefaultFetchPolicy(queryHookOptions.defaultOptions, client.defaultOptions);\n    var forceUpdateState = React__namespace.useReducer(function (tick) { return tick + 1; }, 0)[1];\n    var eagerMethods = React__namespace.useMemo(function () {\n        var eagerMethods = {};\n        var _loop_1 = function (key) {\n            var method = obsQueryFields[key];\n            eagerMethods[key] = function () {\n                if (globalThis.__DEV__ !== false) {\n                    if (key === \"reobserve\") {\n                        globalThis.__DEV__ !== false && invariant.warn(80);\n                    }\n                }\n                if (!execOptionsRef.current) {\n                    execOptionsRef.current = Object.create(null);\n                    forceUpdateState();\n                }\n                return method.apply(this, arguments);\n            };\n        };\n        for (var _i = 0, EAGER_METHODS_1 = EAGER_METHODS; _i < EAGER_METHODS_1.length; _i++) {\n            var key = EAGER_METHODS_1[_i];\n            _loop_1(key);\n        }\n        return eagerMethods;\n    }, [forceUpdateState, obsQueryFields]);\n    var called = !!execOptionsRef.current;\n    var result = React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign(tslib.__assign({}, useQueryResult), eagerMethods), { called: called })); }, [useQueryResult, eagerMethods, called]);\n    var calledDuringRender = useRenderGuard();\n    var warnRef = React__namespace.useRef(new Set());\n    var execute = React__namespace.useCallback(function (executeOptions) {\n        if (globalThis.__DEV__ !== false) {\n            if (calledDuringRender()) {\n                globalThis.__DEV__ !== false && invariant.warn(81);\n            }\n            for (var _i = 0, REMOVED_EXECUTE_OPTIONS_1 = REMOVED_EXECUTE_OPTIONS; _i < REMOVED_EXECUTE_OPTIONS_1.length; _i++) {\n                var name_1 = REMOVED_EXECUTE_OPTIONS_1[_i];\n                if (!warnRef.current.has(name_1)) {\n                    warnRemovedOption(executeOptions || {}, name_1, \"useLazyQuery.execute\");\n                    warnRef.current.add(name_1);\n                }\n            }\n            for (var _a = 0, DEPRECATED_EXECUTE_OPTIONS_1 = DEPRECATED_EXECUTE_OPTIONS; _a < DEPRECATED_EXECUTE_OPTIONS_1.length; _a++) {\n                var name_2 = DEPRECATED_EXECUTE_OPTIONS_1[_a];\n                if (!warnRef.current.has(name_2)) {\n                    warnRemovedOption(executeOptions || {}, name_2, \"useLazyQuery.execute\", \"Please pass the option to the `useLazyQuery` hook instead.\");\n                    warnRef.current.add(name_2);\n                }\n            }\n        }\n        execOptionsRef.current =\n            executeOptions ? tslib.__assign(tslib.__assign({}, executeOptions), { fetchPolicy: executeOptions.fetchPolicy || initialFetchPolicy }) : {\n                fetchPolicy: initialFetchPolicy,\n            };\n        var options = utilities.mergeOptions(optionsRef.current, tslib.__assign({ query: queryRef.current }, execOptionsRef.current));\n        var promise = executeQuery(resultData, observable, client, document, tslib.__assign(tslib.__assign({}, options), { skip: false }), onQueryExecuted).then(function (queryResult) { return Object.assign(queryResult, eagerMethods); });\n        promise.catch(function () { });\n        return promise;\n    }, [\n        calledDuringRender,\n        client,\n        document,\n        eagerMethods,\n        initialFetchPolicy,\n        observable,\n        resultData,\n        onQueryExecuted,\n    ]);\n    var executeRef = React__namespace.useRef(execute);\n    useIsomorphicLayoutEffect(function () {\n        executeRef.current = execute;\n    });\n    var stableExecute = React__namespace.useCallback(function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        return executeRef.current.apply(executeRef, args);\n    }, []);\n    return [stableExecute, result];\n}\nfunction executeQuery(resultData, observable, client, currentQuery, options, onQueryExecuted) {\n    var query = options.query || currentQuery;\n    var watchQueryOptions = createMakeWatchQueryOptions(client, query, options, false)(observable);\n    var concast = observable.reobserveAsConcast(getObsQueryOptions(observable, client, options, watchQueryOptions));\n    onQueryExecuted(watchQueryOptions);\n    return new Promise(function (resolve) {\n        var result;\n        concast.subscribe({\n            next: function (value) {\n                result = value;\n            },\n            error: function () {\n                resolve(toQueryResult(observable.getCurrentResult(), resultData.previousData, observable, client));\n            },\n            complete: function () {\n                resolve(toQueryResult(observable[\"maskResult\"](result), resultData.previousData, observable, client));\n            },\n        });\n    });\n}\n\nfunction useMutation(mutation, options) {\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(options || {}, \"ignoreResults\", \"useMutation\", \"If you don't want to synchronize component state with the mutation, please use the `useApolloClient` hook to get the client instance and call `client.mutate` directly.\");\n    }\n    var client = useApolloClient(options === null || options === void 0 ? void 0 : options.client);\n    parser.verifyDocumentType(mutation, parser.DocumentType.Mutation);\n    var _a = React__namespace.useState({\n        called: false,\n        loading: false,\n        client: client,\n    }), result = _a[0], setResult = _a[1];\n    var ref = React__namespace.useRef({\n        result: result,\n        mutationId: 0,\n        isMounted: true,\n        client: client,\n        mutation: mutation,\n        options: options,\n    });\n    useIsomorphicLayoutEffect(function () {\n        Object.assign(ref.current, { client: client, options: options, mutation: mutation });\n    });\n    var execute = React__namespace.useCallback(function (executeOptions) {\n        if (executeOptions === void 0) { executeOptions = {}; }\n        var _a = ref.current, options = _a.options, mutation = _a.mutation;\n        var baseOptions = tslib.__assign(tslib.__assign({}, options), { mutation: mutation });\n        var client = executeOptions.client || ref.current.client;\n        if (!ref.current.result.loading &&\n            !baseOptions.ignoreResults &&\n            ref.current.isMounted) {\n            setResult((ref.current.result = {\n                loading: true,\n                error: void 0,\n                data: void 0,\n                called: true,\n                client: client,\n            }));\n        }\n        var mutationId = ++ref.current.mutationId;\n        var clientOptions = utilities.mergeOptions(baseOptions, executeOptions);\n        return client\n            .mutate(clientOptions)\n            .then(function (response) {\n            var _a, _b;\n            var data = response.data, errors$1 = response.errors;\n            var error = errors$1 && errors$1.length > 0 ?\n                new errors.ApolloError({ graphQLErrors: errors$1 })\n                : void 0;\n            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);\n            if (error && onError) {\n                onError(error, clientOptions);\n            }\n            if (mutationId === ref.current.mutationId &&\n                !clientOptions.ignoreResults) {\n                var result_1 = {\n                    called: true,\n                    loading: false,\n                    data: data,\n                    error: error,\n                    client: client,\n                };\n                if (ref.current.isMounted && !equal.equal(ref.current.result, result_1)) {\n                    setResult((ref.current.result = result_1));\n                }\n            }\n            var onCompleted = executeOptions.onCompleted || ((_b = ref.current.options) === null || _b === void 0 ? void 0 : _b.onCompleted);\n            if (!error) {\n                onCompleted === null || onCompleted === void 0 ? void 0 : onCompleted(response.data, clientOptions);\n            }\n            return response;\n        }, function (error) {\n            var _a;\n            if (mutationId === ref.current.mutationId &&\n                ref.current.isMounted) {\n                var result_2 = {\n                    loading: false,\n                    error: error,\n                    data: void 0,\n                    called: true,\n                    client: client,\n                };\n                if (!equal.equal(ref.current.result, result_2)) {\n                    setResult((ref.current.result = result_2));\n                }\n            }\n            var onError = executeOptions.onError || ((_a = ref.current.options) === null || _a === void 0 ? void 0 : _a.onError);\n            if (onError) {\n                onError(error, clientOptions);\n                return { data: void 0, errors: error };\n            }\n            throw error;\n        });\n    }, []);\n    var reset = React__namespace.useCallback(function () {\n        if (ref.current.isMounted) {\n            var result_3 = {\n                called: false,\n                loading: false,\n                client: ref.current.client,\n            };\n            Object.assign(ref.current, { mutationId: 0, result: result_3 });\n            setResult(result_3);\n        }\n    }, []);\n    React__namespace.useEffect(function () {\n        var current = ref.current;\n        current.isMounted = true;\n        return function () {\n            current.isMounted = false;\n        };\n    }, []);\n    return [execute, tslib.__assign({ reset: reset }, result)];\n}\n\nfunction useSubscription(subscription, options) {\n    if (options === void 0) { options = Object.create(null); }\n    var hasIssuedDeprecationWarningRef = React__namespace.useRef(false);\n    var client = useApolloClient(options.client);\n    parser.verifyDocumentType(subscription, parser.DocumentType.Subscription);\n    if (!hasIssuedDeprecationWarningRef.current) {\n        hasIssuedDeprecationWarningRef.current = true;\n        if (options.onSubscriptionData) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(options.onData ? 85 : 86);\n        }\n        if (options.onSubscriptionComplete) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(options.onComplete ? 87 : 88);\n        }\n    }\n    var skip = options.skip, fetchPolicy = options.fetchPolicy, errorPolicy = options.errorPolicy, shouldResubscribe = options.shouldResubscribe, context = options.context, extensions = options.extensions, ignoreResults = options.ignoreResults;\n    var variables = useDeepMemo(function () { return options.variables; }, [options.variables]);\n    var recreate = function () {\n        return createSubscription(client, subscription, variables, fetchPolicy, errorPolicy, context, extensions);\n    };\n    var _a = React__namespace.useState(options.skip ? null : recreate), observable = _a[0], setObservable = _a[1];\n    var recreateRef = React__namespace.useRef(recreate);\n    useIsomorphicLayoutEffect(function () {\n        recreateRef.current = recreate;\n    });\n    if (skip) {\n        if (observable) {\n            setObservable((observable = null));\n        }\n    }\n    else if (!observable ||\n        ((client !== observable.__.client ||\n            subscription !== observable.__.query ||\n            fetchPolicy !== observable.__.fetchPolicy ||\n            errorPolicy !== observable.__.errorPolicy ||\n            !equal.equal(variables, observable.__.variables)) &&\n            (typeof shouldResubscribe === \"function\" ?\n                !!shouldResubscribe(options)\n                : shouldResubscribe) !== false)) {\n        setObservable((observable = recreate()));\n    }\n    var optionsRef = React__namespace.useRef(options);\n    React__namespace.useEffect(function () {\n        optionsRef.current = options;\n    });\n    var fallbackLoading = !skip && !ignoreResults;\n    var fallbackResult = React__namespace.useMemo(function () { return ({\n        loading: fallbackLoading,\n        error: void 0,\n        data: void 0,\n        variables: variables,\n    }); }, [fallbackLoading, variables]);\n    var ignoreResultsRef = React__namespace.useRef(ignoreResults);\n    useIsomorphicLayoutEffect(function () {\n        ignoreResultsRef.current = ignoreResults;\n    });\n    var ret = useSyncExternalStore(React__namespace.useCallback(function (update) {\n        if (!observable) {\n            return function () { };\n        }\n        var subscriptionStopped = false;\n        var variables = observable.__.variables;\n        var client = observable.__.client;\n        var subscription = observable.subscribe({\n            next: function (fetchResult) {\n                var _a, _b;\n                if (subscriptionStopped) {\n                    return;\n                }\n                var result = {\n                    loading: false,\n                    data: fetchResult.data,\n                    error: toApolloError$1(fetchResult),\n                    variables: variables,\n                };\n                observable.__.setResult(result);\n                if (!ignoreResultsRef.current)\n                    update();\n                if (result.error) {\n                    (_b = (_a = optionsRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, result.error);\n                }\n                else if (optionsRef.current.onData) {\n                    optionsRef.current.onData({\n                        client: client,\n                        data: result,\n                    });\n                }\n                else if (optionsRef.current.onSubscriptionData) {\n                    optionsRef.current.onSubscriptionData({\n                        client: client,\n                        subscriptionData: result,\n                    });\n                }\n            },\n            error: function (error) {\n                var _a, _b;\n                error =\n                    error instanceof core.ApolloError ? error : (new core.ApolloError({ protocolErrors: [error] }));\n                if (!subscriptionStopped) {\n                    observable.__.setResult({\n                        loading: false,\n                        data: void 0,\n                        error: error,\n                        variables: variables,\n                    });\n                    if (!ignoreResultsRef.current)\n                        update();\n                    (_b = (_a = optionsRef.current).onError) === null || _b === void 0 ? void 0 : _b.call(_a, error);\n                }\n            },\n            complete: function () {\n                if (!subscriptionStopped) {\n                    if (optionsRef.current.onComplete) {\n                        optionsRef.current.onComplete();\n                    }\n                    else if (optionsRef.current.onSubscriptionComplete) {\n                        optionsRef.current.onSubscriptionComplete();\n                    }\n                }\n            },\n        });\n        return function () {\n            subscriptionStopped = true;\n            setTimeout(function () {\n                subscription.unsubscribe();\n            });\n        };\n    }, [observable]), function () {\n        return observable && !skip && !ignoreResults ?\n            observable.__.result\n            : fallbackResult;\n    }, function () { return fallbackResult; });\n    var restart = React__namespace.useCallback(function () {\n        globals.invariant(!optionsRef.current.skip, 89);\n        setObservable(recreateRef.current());\n    }, [optionsRef, recreateRef]);\n    return React__namespace.useMemo(function () { return (tslib.__assign(tslib.__assign({}, ret), { restart: restart })); }, [ret, restart]);\n}\nfunction createSubscription(client, query, variables, fetchPolicy, errorPolicy, context, extensions) {\n    var options = {\n        query: query,\n        variables: variables,\n        fetchPolicy: fetchPolicy,\n        errorPolicy: errorPolicy,\n        context: context,\n        extensions: extensions,\n    };\n    var __ = tslib.__assign(tslib.__assign({}, options), { client: client, result: {\n            loading: true,\n            data: void 0,\n            error: void 0,\n            variables: variables,\n        }, setResult: function (result) {\n            __.result = result;\n        } });\n    var observable = null;\n    return Object.assign(new core.Observable(function (observer) {\n        if (!observable) {\n            observable = client.subscribe(options);\n        }\n        var sub = observable.subscribe(observer);\n        return function () { return sub.unsubscribe(); };\n    }), {\n        __: __,\n    });\n}\n\nfunction useReactiveVar(rv) {\n    return useSyncExternalStore(React__namespace.useCallback(function (update) {\n        return rv.onNextChange(function onNext() {\n            update();\n            rv.onNextChange(onNext);\n        });\n    }, [rv]), rv, rv);\n}\n\nfunction useFragment(options) {\n    return wrapHook(\"useFragment\",\n    useFragment_, useApolloClient(options.client))(options);\n}\nfunction useFragment_(options) {\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(options, \"canonizeResults\", \"useFragment\");\n    }\n    var client = useApolloClient(options.client);\n    var cache = client.cache;\n    var from = options.from, rest = tslib.__rest(options, [\"from\"]);\n    var id = React__namespace.useMemo(function () {\n        return typeof from === \"string\" ? from\n            : from === null ? null\n                : cache.identify(from);\n    }, [cache, from]);\n    var stableOptions = useDeepMemo(function () { return (tslib.__assign(tslib.__assign({}, rest), { from: id })); }, [rest, id]);\n    var diff = React__namespace.useMemo(function () {\n        var fragment = stableOptions.fragment, fragmentName = stableOptions.fragmentName, from = stableOptions.from, _a = stableOptions.optimistic, optimistic = _a === void 0 ? true : _a;\n        if (from === null) {\n            return {\n                result: diffToResult({\n                    result: {},\n                    complete: false,\n                }),\n            };\n        }\n        var cache = client.cache;\n        var diff = muteDeprecations(\"canonizeResults\", function () {\n            return cache.diff(tslib.__assign(tslib.__assign({}, stableOptions), { returnPartialData: true, id: from, query: cache[\"getFragmentDoc\"](fragment, fragmentName), optimistic: optimistic }));\n        });\n        return {\n            result: diffToResult(tslib.__assign(tslib.__assign({}, diff), { result: client[\"queryManager\"].maskFragment({\n                    fragment: fragment,\n                    fragmentName: fragmentName,\n                    data: diff.result,\n                }) })),\n        };\n    }, [client, stableOptions]);\n    var getSnapshot = React__namespace.useCallback(function () { return diff.result; }, [diff]);\n    return useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {\n        var lastTimeout = 0;\n        var subscription = muteDeprecations(\"canonizeResults\", function () {\n            return stableOptions.from === null ?\n                null\n                : client.watchFragment(stableOptions).subscribe({\n                    next: function (result) {\n                        if (equal__default(result, diff.result))\n                            return;\n                        diff.result = result;\n                        clearTimeout(lastTimeout);\n                        lastTimeout = setTimeout(forceUpdate);\n                    },\n                });\n        });\n        return function () {\n            subscription === null || subscription === void 0 ? void 0 : subscription.unsubscribe();\n            clearTimeout(lastTimeout);\n        };\n    }, [client, stableOptions, diff]), getSnapshot, getSnapshot);\n}\nfunction diffToResult(diff) {\n    var result = {\n        data: diff.result,\n        complete: !!diff.complete,\n    };\n    if (diff.missing) {\n        result.missing = utilities.mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));\n    }\n    return result;\n}\n\nvar skipToken = Symbol.for(\"apollo.skipToken\");\n\nfunction useSuspenseQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return wrapHook(\"useSuspenseQuery\",\n    useSuspenseQuery_, useApolloClient(typeof options === \"object\" ? options.client : undefined))(query, options);\n}\nfunction useSuspenseQuery_(query, options) {\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(typeof options === \"symbol\" ? {} : options, \"canonizeResults\", \"useSuspenseQuery\");\n    }\n    var client = useApolloClient(options.client);\n    var suspenseCache = internal.getSuspenseCache(client);\n    var watchQueryOptions = useWatchQueryOptions({\n        client: client,\n        query: query,\n        options: options,\n    });\n    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;\n    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;\n    var cacheKey = tslib.__spreadArray([\n        query,\n        cache.canonicalStringify(variables)\n    ], [].concat(queryKey), true);\n    var queryRef = muteDeprecations(\"canonizeResults\", function () {\n        return suspenseCache.getQueryRef(cacheKey, function () {\n            return client.watchQuery(watchQueryOptions);\n        });\n    });\n    var _b = React__namespace.useState([queryRef.key, queryRef.promise]), current = _b[0], setPromise = _b[1];\n    if (current[0] !== queryRef.key) {\n        current[0] = queryRef.key;\n        current[1] = queryRef.promise;\n    }\n    var promise = current[1];\n    if (queryRef.didChangeOptions(watchQueryOptions)) {\n        current[1] = promise = queryRef.applyOptions(watchQueryOptions);\n    }\n    React__namespace.useEffect(function () {\n        var dispose = queryRef.retain();\n        var removeListener = queryRef.listen(function (promise) {\n            setPromise([queryRef.key, promise]);\n        });\n        return function () {\n            removeListener();\n            dispose();\n        };\n    }, [queryRef]);\n    var skipResult = React__namespace.useMemo(function () {\n        var error = toApolloError(queryRef.result);\n        return {\n            loading: false,\n            data: queryRef.result.data,\n            networkStatus: error ? core.NetworkStatus.error : core.NetworkStatus.ready,\n            error: error,\n        };\n    }, [queryRef.result]);\n    var result = fetchPolicy === \"standby\" ? skipResult : __use(promise);\n    var fetchMore = React__namespace.useCallback(function (options) {\n        var promise = queryRef.fetchMore(options);\n        setPromise([queryRef.key, queryRef.promise]);\n        return promise;\n    }, [queryRef]);\n    var refetch = React__namespace.useCallback(function (variables) {\n        var promise = queryRef.refetch(variables);\n        setPromise([queryRef.key, queryRef.promise]);\n        return promise;\n    }, [queryRef]);\n    var subscribeToMore = queryRef.observable\n        .subscribeToMore;\n    return React__namespace.useMemo(function () {\n        return {\n            client: client,\n            data: result.data,\n            error: toApolloError(result),\n            networkStatus: result.networkStatus,\n            fetchMore: fetchMore,\n            refetch: refetch,\n            subscribeToMore: subscribeToMore,\n        };\n    }, [client, fetchMore, refetch, result, subscribeToMore]);\n}\nfunction validateOptions(options) {\n    var query = options.query, fetchPolicy = options.fetchPolicy, returnPartialData = options.returnPartialData;\n    parser.verifyDocumentType(query, parser.DocumentType.Query);\n    validateFetchPolicy(fetchPolicy);\n    validatePartialDataReturn(fetchPolicy, returnPartialData);\n}\nfunction validateFetchPolicy(fetchPolicy) {\n    if (fetchPolicy === void 0) { fetchPolicy = \"cache-first\"; }\n    var supportedFetchPolicies = [\n        \"cache-first\",\n        \"network-only\",\n        \"no-cache\",\n        \"cache-and-network\",\n    ];\n    globals.invariant(supportedFetchPolicies.includes(fetchPolicy), 90, fetchPolicy);\n}\nfunction validatePartialDataReturn(fetchPolicy, returnPartialData) {\n    if (fetchPolicy === \"no-cache\" && returnPartialData) {\n        globalThis.__DEV__ !== false && globals.invariant.warn(91);\n    }\n}\nfunction toApolloError(result) {\n    return utilities.isNonEmptyArray(result.errors) ?\n        new core.ApolloError({ graphQLErrors: result.errors })\n        : result.error;\n}\nfunction useWatchQueryOptions(_a) {\n    var client = _a.client, query = _a.query, options = _a.options;\n    return useDeepMemo(function () {\n        var _a;\n        if (options === skipToken) {\n            return { query: query, fetchPolicy: \"standby\" };\n        }\n        var fetchPolicy = options.fetchPolicy ||\n            ((_a = client.defaultOptions.watchQuery) === null || _a === void 0 ? void 0 : _a.fetchPolicy) ||\n            \"cache-first\";\n        var watchQueryOptions = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: fetchPolicy, query: query, notifyOnNetworkStatusChange: false, nextFetchPolicy: void 0 });\n        if (globalThis.__DEV__ !== false) {\n            validateOptions(watchQueryOptions);\n        }\n        if (options.skip) {\n            watchQueryOptions.fetchPolicy = \"standby\";\n        }\n        return watchQueryOptions;\n    }, [client, options, query]);\n}\n\nfunction useBackgroundQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    return wrapHook(\"useBackgroundQuery\",\n    useBackgroundQuery_, useApolloClient(typeof options === \"object\" ? options.client : undefined))(query, options);\n}\nfunction useBackgroundQuery_(query, options) {\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(typeof options === \"symbol\" ? {} : options, \"canonizeResults\", \"useBackgroundQuery\");\n    }\n    var client = useApolloClient(options.client);\n    var suspenseCache = internal.getSuspenseCache(client);\n    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });\n    var fetchPolicy = watchQueryOptions.fetchPolicy, variables = watchQueryOptions.variables;\n    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;\n    var didFetchResult = React__namespace.useRef(fetchPolicy !== \"standby\");\n    didFetchResult.current || (didFetchResult.current = fetchPolicy !== \"standby\");\n    var cacheKey = tslib.__spreadArray([\n        query,\n        cache.canonicalStringify(variables)\n    ], [].concat(queryKey), true);\n    var queryRef = muteDeprecations(\"canonizeResults\", function () {\n        return suspenseCache.getQueryRef(cacheKey, function () {\n            return client.watchQuery(watchQueryOptions);\n        });\n    });\n    var _b = React__namespace.useState(internal.wrapQueryRef(queryRef)), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];\n    if (internal.unwrapQueryRef(wrappedQueryRef) !== queryRef) {\n        setWrappedQueryRef(internal.wrapQueryRef(queryRef));\n    }\n    if (queryRef.didChangeOptions(watchQueryOptions)) {\n        var promise = queryRef.applyOptions(watchQueryOptions);\n        internal.updateWrappedQueryRef(wrappedQueryRef, promise);\n    }\n    React__namespace.useEffect(function () {\n        var id = setTimeout(function () {\n            if (queryRef.disposed) {\n                suspenseCache.add(cacheKey, queryRef);\n            }\n        });\n        return function () { return clearTimeout(id); };\n    });\n    var fetchMore = React__namespace.useCallback(function (options) {\n        var promise = queryRef.fetchMore(options);\n        setWrappedQueryRef(internal.wrapQueryRef(queryRef));\n        return promise;\n    }, [queryRef]);\n    var refetch = React__namespace.useCallback(function (variables) {\n        var promise = queryRef.refetch(variables);\n        setWrappedQueryRef(internal.wrapQueryRef(queryRef));\n        return promise;\n    }, [queryRef]);\n    React__namespace.useEffect(function () { return queryRef.softRetain(); }, [queryRef]);\n    return [\n        didFetchResult.current ? wrappedQueryRef : void 0,\n        {\n            fetchMore: fetchMore,\n            refetch: refetch,\n            subscribeToMore: queryRef.observable\n                .subscribeToMore,\n        },\n    ];\n}\n\nvar NULL_PLACEHOLDER = [];\nfunction useSuspenseFragment(options) {\n    return wrapHook(\"useSuspenseFragment\",\n    useSuspenseFragment_, useApolloClient(typeof options === \"object\" ? options.client : undefined))(options);\n}\nfunction useSuspenseFragment_(options) {\n    var client = useApolloClient(options.client);\n    var from = options.from, variables = options.variables;\n    var cache$1 = client.cache;\n    var id = React__namespace.useMemo(function () {\n        return typeof from === \"string\" ? from\n            : from === null ? null\n                : cache$1.identify(from);\n    }, [cache$1, from]);\n    var fragmentRef = id === null ? null : (internal.getSuspenseCache(client).getFragmentRef([id, options.fragment, cache.canonicalStringify(variables)], client, tslib.__assign(tslib.__assign({}, options), { variables: variables, from: id })));\n    var _a = React__namespace.useState(fragmentRef === null ? NULL_PLACEHOLDER : ([fragmentRef.key, fragmentRef.promise])), current = _a[0], setPromise = _a[1];\n    React__namespace.useEffect(function () {\n        if (fragmentRef === null) {\n            return;\n        }\n        var dispose = fragmentRef.retain();\n        var removeListener = fragmentRef.listen(function (promise) {\n            setPromise([fragmentRef.key, promise]);\n        });\n        return function () {\n            dispose();\n            removeListener();\n        };\n    }, [fragmentRef]);\n    if (fragmentRef === null) {\n        return { data: null };\n    }\n    if (current[0] !== fragmentRef.key) {\n        current[0] = fragmentRef.key;\n        current[1] = fragmentRef.promise;\n    }\n    var data = __use(current[1]);\n    return { data: data };\n}\n\nfunction useLoadableQuery(query, options) {\n    if (options === void 0) { options = Object.create(null); }\n    if (globalThis.__DEV__ !== false) {\n        useWarnRemovedOption(options, \"canonizeResults\", \"useLoadableQuery\");\n    }\n    var client = useApolloClient(options.client);\n    var suspenseCache = internal.getSuspenseCache(client);\n    var watchQueryOptions = useWatchQueryOptions({ client: client, query: query, options: options });\n    var _a = options.queryKey, queryKey = _a === void 0 ? [] : _a;\n    var _b = React__namespace.useState(null), queryRef = _b[0], setQueryRef = _b[1];\n    internal.assertWrappedQueryRef(queryRef);\n    var internalQueryRef = queryRef && internal.unwrapQueryRef(queryRef);\n    if (queryRef && (internalQueryRef === null || internalQueryRef === void 0 ? void 0 : internalQueryRef.didChangeOptions(watchQueryOptions))) {\n        var promise = internalQueryRef.applyOptions(watchQueryOptions);\n        internal.updateWrappedQueryRef(queryRef, promise);\n    }\n    var calledDuringRender = useRenderGuard();\n    var fetchMore = React__namespace.useCallback(function (options) {\n        if (!internalQueryRef) {\n            throw new Error(\"The query has not been loaded. Please load the query.\");\n        }\n        var promise = internalQueryRef.fetchMore(options);\n        setQueryRef(internal.wrapQueryRef(internalQueryRef));\n        return promise;\n    }, [internalQueryRef]);\n    var refetch = React__namespace.useCallback(function (options) {\n        if (!internalQueryRef) {\n            throw new Error(\"The query has not been loaded. Please load the query.\");\n        }\n        var promise = internalQueryRef.refetch(options);\n        setQueryRef(internal.wrapQueryRef(internalQueryRef));\n        return promise;\n    }, [internalQueryRef]);\n    var loadQuery = React__namespace.useCallback(function () {\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        globals.invariant(!calledDuringRender(), 82);\n        var variables = args[0];\n        var cacheKey = tslib.__spreadArray([\n            query,\n            cache.canonicalStringify(variables)\n        ], [].concat(queryKey), true);\n        var queryRef = muteDeprecations(\"canonizeResults\", function () {\n            return suspenseCache.getQueryRef(cacheKey, function () {\n                return client.watchQuery(tslib.__assign(tslib.__assign({}, watchQueryOptions), { variables: variables }));\n            });\n        });\n        setQueryRef(internal.wrapQueryRef(queryRef));\n    }, [\n        query,\n        queryKey,\n        suspenseCache,\n        watchQueryOptions,\n        calledDuringRender,\n        client,\n    ]);\n    var subscribeToMore = React__namespace.useCallback(function (options) {\n        globals.invariant(internalQueryRef, 83);\n        return internalQueryRef.observable.subscribeToMore(\n        options);\n    }, [internalQueryRef]);\n    var reset = React__namespace.useCallback(function () {\n        setQueryRef(null);\n    }, []);\n    return [loadQuery, queryRef, { fetchMore: fetchMore, refetch: refetch, reset: reset, subscribeToMore: subscribeToMore }];\n}\n\nfunction useQueryRefHandlers(queryRef) {\n    var unwrapped = internal.unwrapQueryRef(queryRef);\n    var clientOrObsQuery = useApolloClient(unwrapped ?\n        unwrapped[\"observable\"]\n        : undefined);\n    return wrapHook(\"useQueryRefHandlers\",\n    useQueryRefHandlers_, clientOrObsQuery)(queryRef);\n}\nfunction useQueryRefHandlers_(queryRef) {\n    internal.assertWrappedQueryRef(queryRef);\n    var _a = React__namespace.useState(queryRef), previousQueryRef = _a[0], setPreviousQueryRef = _a[1];\n    var _b = React__namespace.useState(queryRef), wrappedQueryRef = _b[0], setWrappedQueryRef = _b[1];\n    var internalQueryRef = internal.unwrapQueryRef(queryRef);\n    if (previousQueryRef !== queryRef) {\n        setPreviousQueryRef(queryRef);\n        setWrappedQueryRef(queryRef);\n    }\n    else {\n        internal.updateWrappedQueryRef(queryRef, internal.getWrappedPromise(wrappedQueryRef));\n    }\n    var refetch = React__namespace.useCallback(function (variables) {\n        var promise = internalQueryRef.refetch(variables);\n        setWrappedQueryRef(internal.wrapQueryRef(internalQueryRef));\n        return promise;\n    }, [internalQueryRef]);\n    var fetchMore = React__namespace.useCallback(function (options) {\n        var promise = internalQueryRef.fetchMore(options);\n        setWrappedQueryRef(internal.wrapQueryRef(internalQueryRef));\n        return promise;\n    }, [internalQueryRef]);\n    return {\n        refetch: refetch,\n        fetchMore: fetchMore,\n        subscribeToMore: internalQueryRef.observable\n            .subscribeToMore,\n    };\n}\n\nfunction useReadQuery(queryRef) {\n    var unwrapped = internal.unwrapQueryRef(queryRef);\n    var clientOrObsQuery = useApolloClient(unwrapped ?\n        unwrapped[\"observable\"]\n        : undefined);\n    return wrapHook(\"useReadQuery\",\n    useReadQuery_, clientOrObsQuery)(queryRef);\n}\nfunction useReadQuery_(queryRef) {\n    internal.assertWrappedQueryRef(queryRef);\n    var internalQueryRef = React__namespace.useMemo(function () { return internal.unwrapQueryRef(queryRef); }, [queryRef]);\n    var getPromise = React__namespace.useCallback(function () { return internal.getWrappedPromise(queryRef); }, [queryRef]);\n    if (internalQueryRef.disposed) {\n        internalQueryRef.reinitialize();\n        internal.updateWrappedQueryRef(queryRef, internalQueryRef.promise);\n    }\n    React__namespace.useEffect(function () { return internalQueryRef.retain(); }, [internalQueryRef]);\n    var promise = useSyncExternalStore(React__namespace.useCallback(function (forceUpdate) {\n        return internalQueryRef.listen(function (promise) {\n            internal.updateWrappedQueryRef(queryRef, promise);\n            forceUpdate();\n        });\n    }, [internalQueryRef, queryRef]), getPromise, getPromise);\n    var result = __use(promise);\n    return React__namespace.useMemo(function () {\n        return {\n            data: result.data,\n            networkStatus: result.networkStatus,\n            error: toApolloError(result),\n        };\n    }, [result]);\n}\n\nexports.skipToken = skipToken;\nexports.useApolloClient = useApolloClient;\nexports.useBackgroundQuery = useBackgroundQuery;\nexports.useFragment = useFragment;\nexports.useLazyQuery = useLazyQuery;\nexports.useLoadableQuery = useLoadableQuery;\nexports.useMutation = useMutation;\nexports.useQuery = useQuery;\nexports.useQueryRefHandlers = useQueryRefHandlers;\nexports.useReactiveVar = useReactiveVar;\nexports.useReadQuery = useReadQuery;\nexports.useSubscription = useSubscription;\nexports.useSuspenseFragment = useSuspenseFragment;\nexports.useSuspenseQuery = useSuspenseQuery;\n//# sourceMappingURL=hooks.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar trie = require('@wry/trie');\nvar utilities = require('../../utilities');\nvar tslib = require('tslib');\nvar equality = require('@wry/equality');\nvar tsInvariant = require('ts-invariant');\nvar optimism = require('optimism');\nrequire('../../utilities/globals');\n\nvar version = \"3.14.0\";\n\nfunction maybe(thunk) {\n    try {\n        return thunk();\n    }\n    catch (_a) { }\n}\n\nvar global$1 = (maybe(function () { return globalThis; }) ||\n    maybe(function () { return window; }) ||\n    maybe(function () { return self; }) ||\n    maybe(function () { return global; }) ||\nmaybe(function () {\n    return maybe.constructor(\"return this\")();\n}));\n\nvar prefixCounts = new Map();\nfunction makeUniqueId(prefix) {\n    var count = prefixCounts.get(prefix) || 1;\n    prefixCounts.set(prefix, count + 1);\n    return \"\".concat(prefix, \":\").concat(count, \":\").concat(Math.random().toString(36).slice(2));\n}\n\nfunction stringifyForDisplay(value, space) {\n    if (space === void 0) { space = 0; }\n    var undefId = makeUniqueId(\"stringifyForDisplay\");\n    return JSON.stringify(value, function (key, value) {\n        return value === void 0 ? undefId : value;\n    }, space)\n        .split(JSON.stringify(undefId))\n        .join(\"<undefined>\");\n}\n\nfunction wrap(fn) {\n    return function (message) {\n        var args = [];\n        for (var _i = 1; _i < arguments.length; _i++) {\n            args[_i - 1] = arguments[_i];\n        }\n        if (typeof message === \"number\") {\n            var arg0 = message;\n            message = getHandledErrorMsg(arg0);\n            if (!message) {\n                message = getFallbackErrorMsg(arg0, args);\n                args = [];\n            }\n        }\n        fn.apply(void 0, [message].concat(args));\n    };\n}\nvar invariant = Object.assign(function invariant(condition, message) {\n    var args = [];\n    for (var _i = 2; _i < arguments.length; _i++) {\n        args[_i - 2] = arguments[_i];\n    }\n    if (!condition) {\n        tsInvariant.invariant(condition, getHandledErrorMsg(message, args) || getFallbackErrorMsg(message, args));\n    }\n}, {\n    debug: wrap(tsInvariant.invariant.debug),\n    log: wrap(tsInvariant.invariant.log),\n    warn: wrap(tsInvariant.invariant.warn),\n    error: wrap(tsInvariant.invariant.error),\n});\nvar ApolloErrorMessageHandler = Symbol.for(\"ApolloErrorMessageHandler_\" + version);\nfunction stringify(arg) {\n    if (typeof arg == \"string\") {\n        return arg;\n    }\n    try {\n        return stringifyForDisplay(arg, 2).slice(0, 1000);\n    }\n    catch (_a) {\n        return \"<non-serializable>\";\n    }\n}\nfunction getHandledErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return (global$1[ApolloErrorMessageHandler] &&\n        global$1[ApolloErrorMessageHandler](message, messageArgs.map(stringify)));\n}\nfunction getFallbackErrorMsg(message, messageArgs) {\n    if (messageArgs === void 0) { messageArgs = []; }\n    if (!message)\n        return;\n    return \"An error occurred! For more details, see the full error text at https://go.apollo.dev/c/err#\".concat(encodeURIComponent(JSON.stringify({\n        version: version,\n        message: message,\n        args: messageArgs.map(stringify),\n    })));\n}\n\nvar slot = new optimism.Slot();\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\n\nvar QUERY_REFERENCE_SYMBOL = Symbol.for(\"apollo.internal.queryRef\");\nvar PROMISE_SYMBOL = Symbol.for(\"apollo.internal.refPromise\");\nfunction wrapQueryRef(internalQueryRef) {\n    var _a;\n    var ref = (_a = {\n            toPromise: function () {\n                return getWrappedPromise(ref).then(function () { return ref; });\n            }\n        },\n        _a[QUERY_REFERENCE_SYMBOL] = internalQueryRef,\n        _a[PROMISE_SYMBOL] = internalQueryRef.promise,\n        _a);\n    return ref;\n}\nfunction assertWrappedQueryRef(queryRef) {\n    invariant(!queryRef || QUERY_REFERENCE_SYMBOL in queryRef, 93);\n}\nfunction getWrappedPromise(queryRef) {\n    var internalQueryRef = unwrapQueryRef(queryRef);\n    return internalQueryRef.promise.status === \"fulfilled\" ?\n        internalQueryRef.promise\n        : queryRef[PROMISE_SYMBOL];\n}\nfunction unwrapQueryRef(queryRef) {\n    return queryRef[QUERY_REFERENCE_SYMBOL];\n}\nfunction updateWrappedQueryRef(queryRef, promise) {\n    queryRef[PROMISE_SYMBOL] = promise;\n}\nvar OBSERVED_CHANGED_OPTIONS = [\n    \"canonizeResults\",\n    \"context\",\n    \"errorPolicy\",\n    \"fetchPolicy\",\n    \"refetchWritePolicy\",\n    \"returnPartialData\",\n];\nvar InternalQueryReference =  (function () {\n    function InternalQueryReference(observable, options) {\n        var _this = this;\n        this.key = {};\n        this.listeners = new Set();\n        this.references = 0;\n        this.softReferences = 0;\n        this.handleNext = this.handleNext.bind(this);\n        this.handleError = this.handleError.bind(this);\n        this.dispose = this.dispose.bind(this);\n        this.observable = observable;\n        if (options.onDispose) {\n            this.onDispose = options.onDispose;\n        }\n        this.setResult();\n        this.subscribeToQuery();\n        var startDisposeTimer = function () {\n            var _a;\n            if (!_this.references) {\n                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);\n            }\n        };\n        this.promise.then(startDisposeTimer, startDisposeTimer);\n    }\n    Object.defineProperty(InternalQueryReference.prototype, \"disposed\", {\n        get: function () {\n            return this.subscription.closed;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(InternalQueryReference.prototype, \"watchQueryOptions\", {\n        get: function () {\n            return this.observable.options;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    InternalQueryReference.prototype.reinitialize = function () {\n        var observable = this.observable;\n        var originalFetchPolicy = this.watchQueryOptions.fetchPolicy;\n        var avoidNetworkRequests = originalFetchPolicy === \"no-cache\" || originalFetchPolicy === \"standby\";\n        try {\n            if (avoidNetworkRequests) {\n                observable.silentSetOptions({ fetchPolicy: \"standby\" });\n            }\n            else {\n                muteDeprecations(\"resetLastResults\", function () {\n                    return observable.resetLastResults();\n                });\n                observable.silentSetOptions({ fetchPolicy: \"cache-first\" });\n            }\n            this.subscribeToQuery();\n            if (avoidNetworkRequests) {\n                return;\n            }\n            observable.resetDiff();\n            this.setResult();\n        }\n        finally {\n            observable.silentSetOptions({ fetchPolicy: originalFetchPolicy });\n        }\n    };\n    InternalQueryReference.prototype.retain = function () {\n        var _this = this;\n        this.references++;\n        clearTimeout(this.autoDisposeTimeoutId);\n        var disposed = false;\n        return function () {\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.references--;\n            setTimeout(function () {\n                if (!_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    InternalQueryReference.prototype.softRetain = function () {\n        var _this = this;\n        this.softReferences++;\n        var disposed = false;\n        return function () {\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.softReferences--;\n            setTimeout(function () {\n                if (!_this.softReferences && !_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    InternalQueryReference.prototype.didChangeOptions = function (watchQueryOptions) {\n        var _this = this;\n        return OBSERVED_CHANGED_OPTIONS.some(function (option) {\n            return option in watchQueryOptions &&\n                !equality.equal(_this.watchQueryOptions[option], watchQueryOptions[option]);\n        });\n    };\n    InternalQueryReference.prototype.applyOptions = function (watchQueryOptions) {\n        var _a = this.watchQueryOptions, currentFetchPolicy = _a.fetchPolicy, currentCanonizeResults = _a.canonizeResults;\n        if (currentFetchPolicy === \"standby\" &&\n            currentFetchPolicy !== watchQueryOptions.fetchPolicy) {\n            this.initiateFetch(this.observable.reobserve(watchQueryOptions));\n        }\n        else {\n            this.observable.silentSetOptions(watchQueryOptions);\n            if (currentCanonizeResults !== watchQueryOptions.canonizeResults) {\n                this.result = tslib.__assign(tslib.__assign({}, this.result), this.observable.getCurrentResult());\n                this.promise = utilities.createFulfilledPromise(this.result);\n            }\n        }\n        return this.promise;\n    };\n    InternalQueryReference.prototype.listen = function (listener) {\n        var _this = this;\n        this.listeners.add(listener);\n        return function () {\n            _this.listeners.delete(listener);\n        };\n    };\n    InternalQueryReference.prototype.refetch = function (variables) {\n        return this.initiateFetch(this.observable.refetch(variables));\n    };\n    InternalQueryReference.prototype.fetchMore = function (options) {\n        return this.initiateFetch(this.observable.fetchMore(options));\n    };\n    InternalQueryReference.prototype.dispose = function () {\n        this.subscription.unsubscribe();\n        this.onDispose();\n    };\n    InternalQueryReference.prototype.onDispose = function () {\n    };\n    InternalQueryReference.prototype.handleNext = function (result) {\n        var _a;\n        switch (this.promise.status) {\n            case \"pending\": {\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.result = result;\n                (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result);\n                break;\n            }\n            default: {\n                if (result.data === this.result.data &&\n                    result.networkStatus === this.result.networkStatus) {\n                    return;\n                }\n                if (result.data === void 0) {\n                    result.data = this.result.data;\n                }\n                this.result = result;\n                this.promise = utilities.createFulfilledPromise(result);\n                this.deliver(this.promise);\n                break;\n            }\n        }\n    };\n    InternalQueryReference.prototype.handleError = function (error) {\n        var _a;\n        this.subscription.unsubscribe();\n        this.subscription = this.observable.resubscribeAfterError(this.handleNext, this.handleError);\n        switch (this.promise.status) {\n            case \"pending\": {\n                (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);\n                break;\n            }\n            default: {\n                this.promise = utilities.createRejectedPromise(error);\n                this.deliver(this.promise);\n            }\n        }\n    };\n    InternalQueryReference.prototype.deliver = function (promise) {\n        this.listeners.forEach(function (listener) { return listener(promise); });\n    };\n    InternalQueryReference.prototype.initiateFetch = function (returnedPromise) {\n        var _this = this;\n        this.promise = this.createPendingPromise();\n        this.promise.catch(function () { });\n        returnedPromise\n            .then(function () {\n            setTimeout(function () {\n                var _a;\n                if (_this.promise.status === \"pending\") {\n                    _this.result = _this.observable.getCurrentResult();\n                    (_a = _this.resolve) === null || _a === void 0 ? void 0 : _a.call(_this, _this.result);\n                }\n            });\n        })\n            .catch(function (error) { var _a; return (_a = _this.reject) === null || _a === void 0 ? void 0 : _a.call(_this, error); });\n        return returnedPromise;\n    };\n    InternalQueryReference.prototype.subscribeToQuery = function () {\n        var _this = this;\n        this.subscription = this.observable\n            .filter(function (result) { return !equality.equal(result.data, {}) && !equality.equal(result, _this.result); })\n            .subscribe(this.handleNext, this.handleError);\n    };\n    InternalQueryReference.prototype.setResult = function () {\n        var result = this.observable.getCurrentResult(false);\n        if (equality.equal(result, this.result)) {\n            return;\n        }\n        this.result = result;\n        this.promise =\n            (result.data &&\n                (!result.partial || this.watchQueryOptions.returnPartialData)) ?\n                utilities.createFulfilledPromise(result)\n                : this.createPendingPromise();\n    };\n    InternalQueryReference.prototype.createPendingPromise = function () {\n        var _this = this;\n        return utilities.wrapPromiseWithState(new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        }));\n    };\n    return InternalQueryReference;\n}());\n\nvar FragmentReference =  (function () {\n    function FragmentReference(client, watchFragmentOptions, options) {\n        var _this = this;\n        this.key = {};\n        this.listeners = new Set();\n        this.references = 0;\n        this.dispose = this.dispose.bind(this);\n        this.handleNext = this.handleNext.bind(this);\n        this.handleError = this.handleError.bind(this);\n        this.observable = client.watchFragment(watchFragmentOptions);\n        if (options.onDispose) {\n            this.onDispose = options.onDispose;\n        }\n        var diff = this.getDiff(client, watchFragmentOptions);\n        var startDisposeTimer = function () {\n            var _a;\n            if (!_this.references) {\n                _this.autoDisposeTimeoutId = setTimeout(_this.dispose, (_a = options.autoDisposeTimeoutMs) !== null && _a !== void 0 ? _a : 30000);\n            }\n        };\n        this.promise =\n            diff.complete ?\n                utilities.createFulfilledPromise(diff.result)\n                : this.createPendingPromise();\n        this.subscribeToFragment();\n        this.promise.then(startDisposeTimer, startDisposeTimer);\n    }\n    FragmentReference.prototype.listen = function (listener) {\n        var _this = this;\n        this.listeners.add(listener);\n        return function () {\n            _this.listeners.delete(listener);\n        };\n    };\n    FragmentReference.prototype.retain = function () {\n        var _this = this;\n        this.references++;\n        clearTimeout(this.autoDisposeTimeoutId);\n        var disposed = false;\n        return function () {\n            if (disposed) {\n                return;\n            }\n            disposed = true;\n            _this.references--;\n            setTimeout(function () {\n                if (!_this.references) {\n                    _this.dispose();\n                }\n            });\n        };\n    };\n    FragmentReference.prototype.dispose = function () {\n        this.subscription.unsubscribe();\n        this.onDispose();\n    };\n    FragmentReference.prototype.onDispose = function () {\n    };\n    FragmentReference.prototype.subscribeToFragment = function () {\n        this.subscription = this.observable.subscribe(this.handleNext.bind(this), this.handleError.bind(this));\n    };\n    FragmentReference.prototype.handleNext = function (result) {\n        var _a;\n        switch (this.promise.status) {\n            case \"pending\": {\n                if (result.complete) {\n                    return (_a = this.resolve) === null || _a === void 0 ? void 0 : _a.call(this, result.data);\n                }\n                this.deliver(this.promise);\n                break;\n            }\n            case \"fulfilled\": {\n                if (equality.equal(this.promise.value, result.data)) {\n                    return;\n                }\n                this.promise =\n                    result.complete ?\n                        utilities.createFulfilledPromise(result.data)\n                        : this.createPendingPromise();\n                this.deliver(this.promise);\n            }\n        }\n    };\n    FragmentReference.prototype.handleError = function (error) {\n        var _a;\n        (_a = this.reject) === null || _a === void 0 ? void 0 : _a.call(this, error);\n    };\n    FragmentReference.prototype.deliver = function (promise) {\n        this.listeners.forEach(function (listener) { return listener(promise); });\n    };\n    FragmentReference.prototype.createPendingPromise = function () {\n        var _this = this;\n        return utilities.wrapPromiseWithState(new Promise(function (resolve, reject) {\n            _this.resolve = resolve;\n            _this.reject = reject;\n        }));\n    };\n    FragmentReference.prototype.getDiff = function (client, options) {\n        var cache = client.cache;\n        var from = options.from, fragment = options.fragment, fragmentName = options.fragmentName;\n        var diff = cache.diff(tslib.__assign(tslib.__assign({}, options), { query: cache[\"getFragmentDoc\"](fragment, fragmentName), returnPartialData: true, id: from, optimistic: true }));\n        return tslib.__assign(tslib.__assign({}, diff), { result: client[\"queryManager\"].maskFragment({\n                fragment: fragment,\n                fragmentName: fragmentName,\n                data: diff.result,\n            }) });\n    };\n    return FragmentReference;\n}());\n\nvar SuspenseCache =  (function () {\n    function SuspenseCache(options) {\n        if (options === void 0) { options = Object.create(null); }\n        this.queryRefs = new trie.Trie(utilities.canUseWeakMap);\n        this.fragmentRefs = new trie.Trie(utilities.canUseWeakMap);\n        this.options = options;\n    }\n    SuspenseCache.prototype.getQueryRef = function (cacheKey, createObservable) {\n        var ref = this.queryRefs.lookupArray(cacheKey);\n        if (!ref.current) {\n            ref.current = new InternalQueryReference(createObservable(), {\n                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,\n                onDispose: function () {\n                    delete ref.current;\n                },\n            });\n        }\n        return ref.current;\n    };\n    SuspenseCache.prototype.getFragmentRef = function (cacheKey, client, options) {\n        var ref = this.fragmentRefs.lookupArray(cacheKey);\n        if (!ref.current) {\n            ref.current = new FragmentReference(client, options, {\n                autoDisposeTimeoutMs: this.options.autoDisposeTimeoutMs,\n                onDispose: function () {\n                    delete ref.current;\n                },\n            });\n        }\n        return ref.current;\n    };\n    SuspenseCache.prototype.add = function (cacheKey, queryRef) {\n        var ref = this.queryRefs.lookupArray(cacheKey);\n        ref.current = queryRef;\n    };\n    return SuspenseCache;\n}());\n\nvar suspenseCacheSymbol = Symbol.for(\"apollo.suspenseCache\");\nfunction getSuspenseCache(client) {\n    var _a;\n    if (!client[suspenseCacheSymbol]) {\n        client[suspenseCacheSymbol] = new SuspenseCache((_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense);\n    }\n    return client[suspenseCacheSymbol];\n}\n\nexports.InternalQueryReference = InternalQueryReference;\nexports.assertWrappedQueryRef = assertWrappedQueryRef;\nexports.getSuspenseCache = getSuspenseCache;\nexports.getWrappedPromise = getWrappedPromise;\nexports.unwrapQueryRef = unwrapQueryRef;\nexports.updateWrappedQueryRef = updateWrappedQueryRef;\nexports.wrapQueryRef = wrapQueryRef;\n//# sourceMappingURL=internal.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../utilities/globals');\nvar tslib = require('tslib');\nvar optimism = require('optimism');\nvar utilities = require('../utilities');\nvar caches = require('@wry/caches');\nvar equal = require('@wry/equality');\nvar masking = require('../masking');\nvar trie = require('@wry/trie');\nvar graphql = require('graphql');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e[\"default\"] : e; }\n\nvar equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);\n\nvar getInMemoryCacheMemoryInternals = globalThis.__DEV__ !== false ?\n    _getInMemoryCacheMemoryInternals\n    : undefined;\nvar getApolloCacheMemoryInternals = globalThis.__DEV__ !== false ?\n    _getApolloCacheMemoryInternals\n    : undefined;\nfunction _getApolloCacheMemoryInternals() {\n    return {\n        cache: {\n            fragmentQueryDocuments: getWrapperInformation(this[\"getFragmentDoc\"]),\n        },\n    };\n}\nfunction _getInMemoryCacheMemoryInternals() {\n    var fragments = this.config.fragments;\n    return tslib.__assign(tslib.__assign({}, _getApolloCacheMemoryInternals.apply(this)), { addTypenameDocumentTransform: transformInfo(this[\"addTypenameTransform\"]), inMemoryCache: {\n            executeSelectionSet: getWrapperInformation(this[\"storeReader\"][\"executeSelectionSet\"]),\n            executeSubSelectedArray: getWrapperInformation(this[\"storeReader\"][\"executeSubSelectedArray\"]),\n            maybeBroadcastWatch: getWrapperInformation(this[\"maybeBroadcastWatch\"]),\n        }, fragmentRegistry: {\n            findFragmentSpreads: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.findFragmentSpreads),\n            lookup: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.lookup),\n            transform: getWrapperInformation(fragments === null || fragments === void 0 ? void 0 : fragments.transform),\n        } });\n}\nfunction isWrapper(f) {\n    return !!f && \"dirtyKey\" in f;\n}\nfunction getWrapperInformation(f) {\n    return isWrapper(f) ? f.size : undefined;\n}\nfunction isDefined(value) {\n    return value != null;\n}\nfunction transformInfo(transform) {\n    return recurseTransformInfo(transform).map(function (cache) { return ({ cache: cache }); });\n}\nfunction recurseTransformInfo(transform) {\n    return transform ?\n        tslib.__spreadArray(tslib.__spreadArray([\n            getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform[\"performWork\"])\n        ], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform[\"left\"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform[\"right\"]), true).filter(isDefined)\n        : [];\n}\n\nfunction equalByQuery(query, _a, _b, variables) {\n    var aData = _a.data, aRest = tslib.__rest(_a, [\"data\"]);\n    var bData = _b.data, bRest = tslib.__rest(_b, [\"data\"]);\n    return (equal__default(aRest, bRest) &&\n        equalBySelectionSet(utilities.getMainDefinition(query).selectionSet, aData, bData, {\n            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),\n            variables: variables,\n        }));\n}\nfunction equalBySelectionSet(selectionSet, aResult, bResult, context) {\n    if (aResult === bResult) {\n        return true;\n    }\n    var seenSelections = new Set();\n    return selectionSet.selections.every(function (selection) {\n        if (seenSelections.has(selection))\n            return true;\n        seenSelections.add(selection);\n        if (!utilities.shouldInclude(selection, context.variables))\n            return true;\n        if (selectionHasNonreactiveDirective(selection))\n            return true;\n        if (utilities.isField(selection)) {\n            var resultKey = utilities.resultKeyNameFromField(selection);\n            var aResultChild = aResult && aResult[resultKey];\n            var bResultChild = bResult && bResult[resultKey];\n            var childSelectionSet = selection.selectionSet;\n            if (!childSelectionSet) {\n                return equal__default(aResultChild, bResultChild);\n            }\n            var aChildIsArray = Array.isArray(aResultChild);\n            var bChildIsArray = Array.isArray(bResultChild);\n            if (aChildIsArray !== bChildIsArray)\n                return false;\n            if (aChildIsArray && bChildIsArray) {\n                var length_1 = aResultChild.length;\n                if (bResultChild.length !== length_1) {\n                    return false;\n                }\n                for (var i = 0; i < length_1; ++i) {\n                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);\n        }\n        else {\n            var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);\n            if (fragment) {\n                if (selectionHasNonreactiveDirective(fragment))\n                    return true;\n                return equalBySelectionSet(fragment.selectionSet,\n                aResult, bResult, context);\n            }\n        }\n    });\n}\nfunction selectionHasNonreactiveDirective(selection) {\n    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));\n}\nfunction directiveIsNonreactive(dir) {\n    return dir.name.value === \"nonreactive\";\n}\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\nfunction warnRemovedOption(options, name, callSite, recommendation) {\n    if (recommendation === void 0) { recommendation = \"Please remove this option.\"; }\n    warnDeprecated(name, function () {\n        if (name in options) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(104, callSite, name, recommendation);\n        }\n    });\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nvar ApolloCache =  (function () {\n    function ApolloCache() {\n        this.assumeImmutableResults = false;\n        this.getFragmentDoc = optimism.wrap(utilities.getFragmentQueryDocument, {\n            max: utilities.cacheSizes[\"cache.fragmentQueryDocuments\"] ||\n                1000 ,\n            cache: caches.WeakCache,\n        });\n    }\n    ApolloCache.prototype.lookupFragment = function (fragmentName) {\n        return null;\n    };\n    ApolloCache.prototype.batch = function (options) {\n        var _this = this;\n        var optimisticId = typeof options.optimistic === \"string\" ? options.optimistic\n            : options.optimistic === false ? null\n                : void 0;\n        var updateResult;\n        this.performTransaction(function () { return (updateResult = options.update(_this)); }, optimisticId);\n        return updateResult;\n    };\n    ApolloCache.prototype.recordOptimisticTransaction = function (transaction, optimisticId) {\n        this.performTransaction(transaction, optimisticId);\n    };\n    ApolloCache.prototype.transformDocument = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.transformForLink = function (document) {\n        return document;\n    };\n    ApolloCache.prototype.identify = function (object) {\n        return;\n    };\n    ApolloCache.prototype.gc = function () {\n        return [];\n    };\n    ApolloCache.prototype.modify = function (options) {\n        return false;\n    };\n    ApolloCache.prototype.readQuery = function (options, optimistic) {\n        var _this = this;\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.readQuery\");\n        }\n        return muteDeprecations(\"canonizeResults\", function () {\n            return _this.read(tslib.__assign(tslib.__assign({}, options), { rootId: options.id || \"ROOT_QUERY\", optimistic: optimistic }));\n        });\n    };\n    ApolloCache.prototype.watchFragment = function (options) {\n        var _this = this;\n        var fragment = options.fragment, fragmentName = options.fragmentName, from = options.from, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, otherOptions = tslib.__rest(options, [\"fragment\", \"fragmentName\", \"from\", \"optimistic\"]);\n        var query = this.getFragmentDoc(fragment, fragmentName);\n        var id = typeof from === \"undefined\" || typeof from === \"string\" ?\n            from\n            : this.identify(from);\n        var dataMasking = !!options[Symbol.for(\"apollo.dataMasking\")];\n        if (globalThis.__DEV__ !== false) {\n            var actualFragmentName = fragmentName || utilities.getFragmentDefinition(fragment).name.value;\n            if (!id) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(1, actualFragmentName);\n            }\n        }\n        var diffOptions = tslib.__assign(tslib.__assign({}, otherOptions), { returnPartialData: true, id: id, query: query, optimistic: optimistic });\n        var latestDiff;\n        return new utilities.Observable(function (observer) {\n            return _this.watch(tslib.__assign(tslib.__assign({}, diffOptions), { immediate: true, callback: function (diff) {\n                    var data = dataMasking ?\n                        masking.maskFragment(diff.result, fragment, _this, fragmentName)\n                        : diff.result;\n                    if (\n                    latestDiff &&\n                        equalByQuery(query, { data: latestDiff.result }, { data: data },\n                        options.variables)) {\n                        return;\n                    }\n                    var result = {\n                        data: data,\n                        complete: !!diff.complete,\n                    };\n                    if (diff.missing) {\n                        result.missing = utilities.mergeDeepArray(diff.missing.map(function (error) { return error.missing; }));\n                    }\n                    latestDiff = tslib.__assign(tslib.__assign({}, diff), { result: data });\n                    observer.next(result);\n                } }));\n        });\n    };\n    ApolloCache.prototype.readFragment = function (options, optimistic) {\n        var _this = this;\n        if (optimistic === void 0) { optimistic = !!options.optimistic; }\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.readFragment\");\n        }\n        return muteDeprecations(\"canonizeResults\", function () {\n            return _this.read(tslib.__assign(tslib.__assign({}, options), { query: _this.getFragmentDoc(options.fragment, options.fragmentName), rootId: options.id, optimistic: optimistic }));\n        });\n    };\n    ApolloCache.prototype.writeQuery = function (_a) {\n        var id = _a.id, data = _a.data, options = tslib.__rest(_a, [\"id\", \"data\"]);\n        return this.write(Object.assign(options, {\n            dataId: id || \"ROOT_QUERY\",\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.writeFragment = function (_a) {\n        var id = _a.id, data = _a.data, fragment = _a.fragment, fragmentName = _a.fragmentName, options = tslib.__rest(_a, [\"id\", \"data\", \"fragment\", \"fragmentName\"]);\n        return this.write(Object.assign(options, {\n            query: this.getFragmentDoc(fragment, fragmentName),\n            dataId: id,\n            result: data,\n        }));\n    };\n    ApolloCache.prototype.updateQuery = function (options, update) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.updateQuery\");\n        }\n        return this.batch({\n            update: function (cache) {\n                var value = muteDeprecations(\"canonizeResults\", function () {\n                    return cache.readQuery(options);\n                });\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeQuery(tslib.__assign(tslib.__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    ApolloCache.prototype.updateFragment = function (options, update) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.updateFragment\");\n        }\n        return this.batch({\n            update: function (cache) {\n                var value = muteDeprecations(\"canonizeResults\", function () {\n                    return cache.readFragment(options);\n                });\n                var data = update(value);\n                if (data === void 0 || data === null)\n                    return value;\n                cache.writeFragment(tslib.__assign(tslib.__assign({}, options), { data: data }));\n                return data;\n            },\n        });\n    };\n    return ApolloCache;\n}());\nif (globalThis.__DEV__ !== false) {\n    ApolloCache.prototype.getMemoryInternals = getApolloCacheMemoryInternals;\n}\n\nexports.Cache = void 0;\n(function (Cache) {\n})(exports.Cache || (exports.Cache = {}));\n\nvar MissingFieldError =  (function (_super) {\n    tslib.__extends(MissingFieldError, _super);\n    function MissingFieldError(message, path, query, variables) {\n        var _a;\n        var _this = _super.call(this, message) || this;\n        _this.message = message;\n        _this.path = path;\n        _this.query = query;\n        _this.variables = variables;\n        if (Array.isArray(_this.path)) {\n            _this.missing = _this.message;\n            for (var i = _this.path.length - 1; i >= 0; --i) {\n                _this.missing = (_a = {}, _a[_this.path[i]] = _this.missing, _a);\n            }\n        }\n        else {\n            _this.missing = _this.path;\n        }\n        _this.__proto__ = MissingFieldError.prototype;\n        return _this;\n    }\n    return MissingFieldError;\n}(Error));\n\nvar hasOwn = Object.prototype.hasOwnProperty;\nfunction isNullish(value) {\n    return value === null || value === void 0;\n}\nfunction defaultDataIdFromObject(_a, context) {\n    var __typename = _a.__typename, id = _a.id, _id = _a._id;\n    if (typeof __typename === \"string\") {\n        if (context) {\n            context.keyObject =\n                !isNullish(id) ? { id: id }\n                    : !isNullish(_id) ? { _id: _id }\n                        : void 0;\n        }\n        if (isNullish(id) && !isNullish(_id)) {\n            id = _id;\n        }\n        if (!isNullish(id)) {\n            return \"\".concat(__typename, \":\").concat(typeof id === \"number\" || typeof id === \"string\" ?\n                id\n                : JSON.stringify(id));\n        }\n    }\n}\nvar defaultConfig = {\n    dataIdFromObject: defaultDataIdFromObject,\n    addTypename: true,\n    resultCaching: true,\n    canonizeResults: false,\n};\nfunction normalizeConfig(config) {\n    return utilities.compact(defaultConfig, config);\n}\nfunction shouldCanonizeResults(config) {\n    var value = config.canonizeResults;\n    return value === void 0 ? defaultConfig.canonizeResults : value;\n}\nfunction getTypenameFromStoreObject(store, objectOrReference) {\n    return utilities.isReference(objectOrReference) ?\n        store.get(objectOrReference.__ref, \"__typename\")\n        : objectOrReference && objectOrReference.__typename;\n}\nvar TypeOrFieldNameRegExp = /^[_a-z][_0-9a-z]*/i;\nfunction fieldNameFromStoreName(storeFieldName) {\n    var match = storeFieldName.match(TypeOrFieldNameRegExp);\n    return match ? match[0] : storeFieldName;\n}\nfunction selectionSetMatchesResult(selectionSet, result, variables) {\n    if (utilities.isNonNullObject(result)) {\n        return utilities.isArray(result) ?\n            result.every(function (item) {\n                return selectionSetMatchesResult(selectionSet, item, variables);\n            })\n            : selectionSet.selections.every(function (field) {\n                if (utilities.isField(field) && utilities.shouldInclude(field, variables)) {\n                    var key = utilities.resultKeyNameFromField(field);\n                    return (hasOwn.call(result, key) &&\n                        (!field.selectionSet ||\n                            selectionSetMatchesResult(field.selectionSet, result[key], variables)));\n                }\n                return true;\n            });\n    }\n    return false;\n}\nfunction storeValueIsStoreObject(value) {\n    return utilities.isNonNullObject(value) && !utilities.isReference(value) && !utilities.isArray(value);\n}\nfunction makeProcessedFieldsMerger() {\n    return new utilities.DeepMerger();\n}\nfunction extractFragmentContext(document, fragments) {\n    var fragmentMap = utilities.createFragmentMap(utilities.getFragmentDefinitions(document));\n    return {\n        fragmentMap: fragmentMap,\n        lookupFragment: function (name) {\n            var def = fragmentMap[name];\n            if (!def && fragments) {\n                def = fragments.lookup(name);\n            }\n            return def || null;\n        },\n    };\n}\n\nvar DELETE = Object.create(null);\nvar delModifier = function () { return DELETE; };\nvar INVALIDATE = Object.create(null);\nexports.EntityStore =  (function () {\n    function EntityStore(policies, group) {\n        var _this = this;\n        this.policies = policies;\n        this.group = group;\n        this.data = Object.create(null);\n        this.rootIds = Object.create(null);\n        this.refs = Object.create(null);\n        this.getFieldValue = function (objectOrReference, storeFieldName) {\n            return utilities.maybeDeepFreeze(utilities.isReference(objectOrReference) ?\n                _this.get(objectOrReference.__ref, storeFieldName)\n                : objectOrReference && objectOrReference[storeFieldName]);\n        };\n        this.canRead = function (objOrRef) {\n            return utilities.isReference(objOrRef) ?\n                _this.has(objOrRef.__ref)\n                : typeof objOrRef === \"object\";\n        };\n        this.toReference = function (objOrIdOrRef, mergeIntoStore) {\n            if (typeof objOrIdOrRef === \"string\") {\n                return utilities.makeReference(objOrIdOrRef);\n            }\n            if (utilities.isReference(objOrIdOrRef)) {\n                return objOrIdOrRef;\n            }\n            var id = _this.policies.identify(objOrIdOrRef)[0];\n            if (id) {\n                var ref = utilities.makeReference(id);\n                if (mergeIntoStore) {\n                    _this.merge(id, objOrIdOrRef);\n                }\n                return ref;\n            }\n        };\n    }\n    EntityStore.prototype.toObject = function () {\n        return tslib.__assign({}, this.data);\n    };\n    EntityStore.prototype.has = function (dataId) {\n        return this.lookup(dataId, true) !== void 0;\n    };\n    EntityStore.prototype.get = function (dataId, fieldName) {\n        this.group.depend(dataId, fieldName);\n        if (hasOwn.call(this.data, dataId)) {\n            var storeObject = this.data[dataId];\n            if (storeObject && hasOwn.call(storeObject, fieldName)) {\n                return storeObject[fieldName];\n            }\n        }\n        if (fieldName === \"__typename\" &&\n            hasOwn.call(this.policies.rootTypenamesById, dataId)) {\n            return this.policies.rootTypenamesById[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.get(dataId, fieldName);\n        }\n    };\n    EntityStore.prototype.lookup = function (dataId, dependOnExistence) {\n        if (dependOnExistence)\n            this.group.depend(dataId, \"__exists\");\n        if (hasOwn.call(this.data, dataId)) {\n            return this.data[dataId];\n        }\n        if (this instanceof Layer) {\n            return this.parent.lookup(dataId, dependOnExistence);\n        }\n        if (this.policies.rootTypenamesById[dataId]) {\n            return Object.create(null);\n        }\n    };\n    EntityStore.prototype.merge = function (older, newer) {\n        var _this = this;\n        var dataId;\n        if (utilities.isReference(older))\n            older = older.__ref;\n        if (utilities.isReference(newer))\n            newer = newer.__ref;\n        var existing = typeof older === \"string\" ? this.lookup((dataId = older)) : older;\n        var incoming = typeof newer === \"string\" ? this.lookup((dataId = newer)) : newer;\n        if (!incoming)\n            return;\n        globals.invariant(typeof dataId === \"string\", 2);\n        var merged = new utilities.DeepMerger(storeObjectReconciler).merge(existing, incoming);\n        this.data[dataId] = merged;\n        if (merged !== existing) {\n            delete this.refs[dataId];\n            if (this.group.caching) {\n                var fieldsToDirty_1 = Object.create(null);\n                if (!existing)\n                    fieldsToDirty_1.__exists = 1;\n                Object.keys(incoming).forEach(function (storeFieldName) {\n                    if (!existing ||\n                        existing[storeFieldName] !== merged[storeFieldName]) {\n                        fieldsToDirty_1[storeFieldName] = 1;\n                        var fieldName = fieldNameFromStoreName(storeFieldName);\n                        if (fieldName !== storeFieldName &&\n                            !_this.policies.hasKeyArgs(merged.__typename, fieldName)) {\n                            fieldsToDirty_1[fieldName] = 1;\n                        }\n                        if (merged[storeFieldName] === void 0 && !(_this instanceof Layer)) {\n                            delete merged[storeFieldName];\n                        }\n                    }\n                });\n                if (fieldsToDirty_1.__typename &&\n                    !(existing && existing.__typename) &&\n                    this.policies.rootTypenamesById[dataId] === merged.__typename) {\n                    delete fieldsToDirty_1.__typename;\n                }\n                Object.keys(fieldsToDirty_1).forEach(function (fieldName) {\n                    return _this.group.dirty(dataId, fieldName);\n                });\n            }\n        }\n    };\n    EntityStore.prototype.modify = function (dataId, fields) {\n        var _this = this;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var changedFields_1 = Object.create(null);\n            var needToMerge_1 = false;\n            var allDeleted_1 = true;\n            var sharedDetails_1 = {\n                DELETE: DELETE,\n                INVALIDATE: INVALIDATE,\n                isReference: utilities.isReference,\n                toReference: this.toReference,\n                canRead: this.canRead,\n                readField: function (fieldNameOrOptions, from) {\n                    return _this.policies.readField(typeof fieldNameOrOptions === \"string\" ?\n                        {\n                            fieldName: fieldNameOrOptions,\n                            from: from || utilities.makeReference(dataId),\n                        }\n                        : fieldNameOrOptions, { store: _this });\n                },\n            };\n            Object.keys(storeObject).forEach(function (storeFieldName) {\n                var fieldName = fieldNameFromStoreName(storeFieldName);\n                var fieldValue = storeObject[storeFieldName];\n                if (fieldValue === void 0)\n                    return;\n                var modify = typeof fields === \"function\" ? fields : (fields[storeFieldName] || fields[fieldName]);\n                if (modify) {\n                    var newValue = modify === delModifier ? DELETE : (modify(utilities.maybeDeepFreeze(fieldValue), tslib.__assign(tslib.__assign({}, sharedDetails_1), { fieldName: fieldName, storeFieldName: storeFieldName, storage: _this.getStorage(dataId, storeFieldName) })));\n                    if (newValue === INVALIDATE) {\n                        _this.group.dirty(dataId, storeFieldName);\n                    }\n                    else {\n                        if (newValue === DELETE)\n                            newValue = void 0;\n                        if (newValue !== fieldValue) {\n                            changedFields_1[storeFieldName] = newValue;\n                            needToMerge_1 = true;\n                            fieldValue = newValue;\n                            if (globalThis.__DEV__ !== false) {\n                                var checkReference = function (ref) {\n                                    if (_this.lookup(ref.__ref) === undefined) {\n                                        globalThis.__DEV__ !== false && globals.invariant.warn(3, ref);\n                                        return true;\n                                    }\n                                };\n                                if (utilities.isReference(newValue)) {\n                                    checkReference(newValue);\n                                }\n                                else if (Array.isArray(newValue)) {\n                                    var seenReference = false;\n                                    var someNonReference = void 0;\n                                    for (var _i = 0, newValue_1 = newValue; _i < newValue_1.length; _i++) {\n                                        var value = newValue_1[_i];\n                                        if (utilities.isReference(value)) {\n                                            seenReference = true;\n                                            if (checkReference(value))\n                                                break;\n                                        }\n                                        else {\n                                            if (typeof value === \"object\" && !!value) {\n                                                var id = _this.policies.identify(value)[0];\n                                                if (id) {\n                                                    someNonReference = value;\n                                                }\n                                            }\n                                        }\n                                        if (seenReference && someNonReference !== undefined) {\n                                            globalThis.__DEV__ !== false && globals.invariant.warn(4, someNonReference);\n                                            break;\n                                        }\n                                    }\n                                }\n                            }\n                        }\n                    }\n                }\n                if (fieldValue !== void 0) {\n                    allDeleted_1 = false;\n                }\n            });\n            if (needToMerge_1) {\n                this.merge(dataId, changedFields_1);\n                if (allDeleted_1) {\n                    if (this instanceof Layer) {\n                        this.data[dataId] = void 0;\n                    }\n                    else {\n                        delete this.data[dataId];\n                    }\n                    this.group.dirty(dataId, \"__exists\");\n                }\n                return true;\n            }\n        }\n        return false;\n    };\n    EntityStore.prototype.delete = function (dataId, fieldName, args) {\n        var _a;\n        var storeObject = this.lookup(dataId);\n        if (storeObject) {\n            var typename = this.getFieldValue(storeObject, \"__typename\");\n            var storeFieldName = fieldName && args ?\n                this.policies.getStoreFieldName({ typename: typename, fieldName: fieldName, args: args })\n                : fieldName;\n            return this.modify(dataId, storeFieldName ? (_a = {},\n                _a[storeFieldName] = delModifier,\n                _a) : delModifier);\n        }\n        return false;\n    };\n    EntityStore.prototype.evict = function (options, limit) {\n        var evicted = false;\n        if (options.id) {\n            if (hasOwn.call(this.data, options.id)) {\n                evicted = this.delete(options.id, options.fieldName, options.args);\n            }\n            if (this instanceof Layer && this !== limit) {\n                evicted = this.parent.evict(options, limit) || evicted;\n            }\n            if (options.fieldName || evicted) {\n                this.group.dirty(options.id, options.fieldName || \"__exists\");\n            }\n        }\n        return evicted;\n    };\n    EntityStore.prototype.clear = function () {\n        this.replace(null);\n    };\n    EntityStore.prototype.extract = function () {\n        var _this = this;\n        var obj = this.toObject();\n        var extraRootIds = [];\n        this.getRootIdSet().forEach(function (id) {\n            if (!hasOwn.call(_this.policies.rootTypenamesById, id)) {\n                extraRootIds.push(id);\n            }\n        });\n        if (extraRootIds.length) {\n            obj.__META = { extraRootIds: extraRootIds.sort() };\n        }\n        return obj;\n    };\n    EntityStore.prototype.replace = function (newData) {\n        var _this = this;\n        Object.keys(this.data).forEach(function (dataId) {\n            if (!(newData && hasOwn.call(newData, dataId))) {\n                _this.delete(dataId);\n            }\n        });\n        if (newData) {\n            var __META = newData.__META, rest_1 = tslib.__rest(newData, [\"__META\"]);\n            Object.keys(rest_1).forEach(function (dataId) {\n                _this.merge(dataId, rest_1[dataId]);\n            });\n            if (__META) {\n                __META.extraRootIds.forEach(this.retain, this);\n            }\n        }\n    };\n    EntityStore.prototype.retain = function (rootId) {\n        return (this.rootIds[rootId] = (this.rootIds[rootId] || 0) + 1);\n    };\n    EntityStore.prototype.release = function (rootId) {\n        if (this.rootIds[rootId] > 0) {\n            var count = --this.rootIds[rootId];\n            if (!count)\n                delete this.rootIds[rootId];\n            return count;\n        }\n        return 0;\n    };\n    EntityStore.prototype.getRootIdSet = function (ids) {\n        if (ids === void 0) { ids = new Set(); }\n        Object.keys(this.rootIds).forEach(ids.add, ids);\n        if (this instanceof Layer) {\n            this.parent.getRootIdSet(ids);\n        }\n        else {\n            Object.keys(this.policies.rootTypenamesById).forEach(ids.add, ids);\n        }\n        return ids;\n    };\n    EntityStore.prototype.gc = function () {\n        var _this = this;\n        var ids = this.getRootIdSet();\n        var snapshot = this.toObject();\n        ids.forEach(function (id) {\n            if (hasOwn.call(snapshot, id)) {\n                Object.keys(_this.findChildRefIds(id)).forEach(ids.add, ids);\n                delete snapshot[id];\n            }\n        });\n        var idsToRemove = Object.keys(snapshot);\n        if (idsToRemove.length) {\n            var root_1 = this;\n            while (root_1 instanceof Layer)\n                root_1 = root_1.parent;\n            idsToRemove.forEach(function (id) { return root_1.delete(id); });\n        }\n        return idsToRemove;\n    };\n    EntityStore.prototype.findChildRefIds = function (dataId) {\n        if (!hasOwn.call(this.refs, dataId)) {\n            var found_1 = (this.refs[dataId] = Object.create(null));\n            var root = this.data[dataId];\n            if (!root)\n                return found_1;\n            var workSet_1 = new Set([root]);\n            workSet_1.forEach(function (obj) {\n                if (utilities.isReference(obj)) {\n                    found_1[obj.__ref] = true;\n                }\n                if (utilities.isNonNullObject(obj)) {\n                    Object.keys(obj).forEach(function (key) {\n                        var child = obj[key];\n                        if (utilities.isNonNullObject(child)) {\n                            workSet_1.add(child);\n                        }\n                    });\n                }\n            });\n        }\n        return this.refs[dataId];\n    };\n    EntityStore.prototype.makeCacheKey = function () {\n        return this.group.keyMaker.lookupArray(arguments);\n    };\n    return EntityStore;\n}());\nvar CacheGroup =  (function () {\n    function CacheGroup(caching, parent) {\n        if (parent === void 0) { parent = null; }\n        this.caching = caching;\n        this.parent = parent;\n        this.d = null;\n        this.resetCaching();\n    }\n    CacheGroup.prototype.resetCaching = function () {\n        this.d = this.caching ? optimism.dep() : null;\n        this.keyMaker = new trie.Trie(utilities.canUseWeakMap);\n    };\n    CacheGroup.prototype.depend = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d(makeDepKey(dataId, storeFieldName));\n            var fieldName = fieldNameFromStoreName(storeFieldName);\n            if (fieldName !== storeFieldName) {\n                this.d(makeDepKey(dataId, fieldName));\n            }\n            if (this.parent) {\n                this.parent.depend(dataId, storeFieldName);\n            }\n        }\n    };\n    CacheGroup.prototype.dirty = function (dataId, storeFieldName) {\n        if (this.d) {\n            this.d.dirty(makeDepKey(dataId, storeFieldName),\n            storeFieldName === \"__exists\" ? \"forget\" : \"setDirty\");\n        }\n    };\n    return CacheGroup;\n}());\nfunction makeDepKey(dataId, storeFieldName) {\n    return storeFieldName + \"#\" + dataId;\n}\nfunction maybeDependOnExistenceOfEntity(store, entityId) {\n    if (supportsResultCaching(store)) {\n        store.group.depend(entityId, \"__exists\");\n    }\n}\n(function (EntityStore) {\n    var Root =  (function (_super) {\n        tslib.__extends(Root, _super);\n        function Root(_a) {\n            var policies = _a.policies, _b = _a.resultCaching, resultCaching = _b === void 0 ? true : _b, seed = _a.seed;\n            var _this = _super.call(this, policies, new CacheGroup(resultCaching)) || this;\n            _this.stump = new Stump(_this);\n            _this.storageTrie = new trie.Trie(utilities.canUseWeakMap);\n            if (seed)\n                _this.replace(seed);\n            return _this;\n        }\n        Root.prototype.addLayer = function (layerId, replay) {\n            return this.stump.addLayer(layerId, replay);\n        };\n        Root.prototype.removeLayer = function () {\n            return this;\n        };\n        Root.prototype.getStorage = function () {\n            return this.storageTrie.lookupArray(arguments);\n        };\n        return Root;\n    }(EntityStore));\n    EntityStore.Root = Root;\n})(exports.EntityStore || (exports.EntityStore = {}));\nvar Layer =  (function (_super) {\n    tslib.__extends(Layer, _super);\n    function Layer(id, parent, replay, group) {\n        var _this = _super.call(this, parent.policies, group) || this;\n        _this.id = id;\n        _this.parent = parent;\n        _this.replay = replay;\n        _this.group = group;\n        replay(_this);\n        return _this;\n    }\n    Layer.prototype.addLayer = function (layerId, replay) {\n        return new Layer(layerId, this, replay, this.group);\n    };\n    Layer.prototype.removeLayer = function (layerId) {\n        var _this = this;\n        var parent = this.parent.removeLayer(layerId);\n        if (layerId === this.id) {\n            if (this.group.caching) {\n                Object.keys(this.data).forEach(function (dataId) {\n                    var ownStoreObject = _this.data[dataId];\n                    var parentStoreObject = parent[\"lookup\"](dataId);\n                    if (!parentStoreObject) {\n                        _this.delete(dataId);\n                    }\n                    else if (!ownStoreObject) {\n                        _this.group.dirty(dataId, \"__exists\");\n                        Object.keys(parentStoreObject).forEach(function (storeFieldName) {\n                            _this.group.dirty(dataId, storeFieldName);\n                        });\n                    }\n                    else if (ownStoreObject !== parentStoreObject) {\n                        Object.keys(ownStoreObject).forEach(function (storeFieldName) {\n                            if (!equal.equal(ownStoreObject[storeFieldName], parentStoreObject[storeFieldName])) {\n                                _this.group.dirty(dataId, storeFieldName);\n                            }\n                        });\n                    }\n                });\n            }\n            return parent;\n        }\n        if (parent === this.parent)\n            return this;\n        return parent.addLayer(this.id, this.replay);\n    };\n    Layer.prototype.toObject = function () {\n        return tslib.__assign(tslib.__assign({}, this.parent.toObject()), this.data);\n    };\n    Layer.prototype.findChildRefIds = function (dataId) {\n        var fromParent = this.parent.findChildRefIds(dataId);\n        return hasOwn.call(this.data, dataId) ? tslib.__assign(tslib.__assign({}, fromParent), _super.prototype.findChildRefIds.call(this, dataId)) : fromParent;\n    };\n    Layer.prototype.getStorage = function () {\n        var p = this.parent;\n        while (p.parent)\n            p = p.parent;\n        return p.getStorage.apply(p,\n        arguments);\n    };\n    return Layer;\n}(exports.EntityStore));\nvar Stump =  (function (_super) {\n    tslib.__extends(Stump, _super);\n    function Stump(root) {\n        return _super.call(this, \"EntityStore.Stump\", root, function () { }, new CacheGroup(root.group.caching, root.group)) || this;\n    }\n    Stump.prototype.removeLayer = function () {\n        return this;\n    };\n    Stump.prototype.merge = function (older, newer) {\n        return this.parent.merge(older, newer);\n    };\n    return Stump;\n}(Layer));\nfunction storeObjectReconciler(existingObject, incomingObject, property) {\n    var existingValue = existingObject[property];\n    var incomingValue = incomingObject[property];\n    return equal.equal(existingValue, incomingValue) ? existingValue : incomingValue;\n}\nfunction supportsResultCaching(store) {\n    return !!(store instanceof exports.EntityStore && store.group.caching);\n}\n\nfunction shallowCopy(value) {\n    if (utilities.isNonNullObject(value)) {\n        return utilities.isArray(value) ?\n            value.slice(0)\n            : tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);\n    }\n    return value;\n}\nvar ObjectCanon =  (function () {\n    function ObjectCanon() {\n        this.known = new (utilities.canUseWeakSet ? WeakSet : Set)();\n        this.pool = new trie.Trie(utilities.canUseWeakMap);\n        this.passes = new WeakMap();\n        this.keysByJSON = new Map();\n        this.empty = this.admit({});\n    }\n    ObjectCanon.prototype.isKnown = function (value) {\n        return utilities.isNonNullObject(value) && this.known.has(value);\n    };\n    ObjectCanon.prototype.pass = function (value) {\n        if (utilities.isNonNullObject(value)) {\n            var copy = shallowCopy(value);\n            this.passes.set(copy, value);\n            return copy;\n        }\n        return value;\n    };\n    ObjectCanon.prototype.admit = function (value) {\n        var _this = this;\n        if (utilities.isNonNullObject(value)) {\n            var original = this.passes.get(value);\n            if (original)\n                return original;\n            var proto = Object.getPrototypeOf(value);\n            switch (proto) {\n                case Array.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var array = value.map(this.admit, this);\n                    var node = this.pool.lookupArray(array);\n                    if (!node.array) {\n                        this.known.add((node.array = array));\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(array);\n                        }\n                    }\n                    return node.array;\n                }\n                case null:\n                case Object.prototype: {\n                    if (this.known.has(value))\n                        return value;\n                    var proto_1 = Object.getPrototypeOf(value);\n                    var array_1 = [proto_1];\n                    var keys = this.sortedKeys(value);\n                    array_1.push(keys.json);\n                    var firstValueIndex_1 = array_1.length;\n                    keys.sorted.forEach(function (key) {\n                        array_1.push(_this.admit(value[key]));\n                    });\n                    var node = this.pool.lookupArray(array_1);\n                    if (!node.object) {\n                        var obj_1 = (node.object = Object.create(proto_1));\n                        this.known.add(obj_1);\n                        keys.sorted.forEach(function (key, i) {\n                            obj_1[key] = array_1[firstValueIndex_1 + i];\n                        });\n                        if (globalThis.__DEV__ !== false) {\n                            Object.freeze(obj_1);\n                        }\n                    }\n                    return node.object;\n                }\n            }\n        }\n        return value;\n    };\n    ObjectCanon.prototype.sortedKeys = function (obj) {\n        var keys = Object.keys(obj);\n        var node = this.pool.lookupArray(keys);\n        if (!node.keys) {\n            keys.sort();\n            var json = JSON.stringify(keys);\n            if (!(node.keys = this.keysByJSON.get(json))) {\n                this.keysByJSON.set(json, (node.keys = { sorted: keys, json: json }));\n            }\n        }\n        return node.keys;\n    };\n    return ObjectCanon;\n}());\n\nfunction execSelectionSetKeyArgs(options) {\n    return [\n        options.selectionSet,\n        options.objectOrReference,\n        options.context,\n        options.context.canonizeResults,\n    ];\n}\nvar StoreReader =  (function () {\n    function StoreReader(config) {\n        var _this = this;\n        this.knownResults = new (utilities.canUseWeakMap ? WeakMap : Map)();\n        this.config = utilities.compact(config, {\n            addTypename: config.addTypename !== false,\n            canonizeResults: shouldCanonizeResults(config),\n        });\n        this.canon = config.canon || new ObjectCanon();\n        this.executeSelectionSet = optimism.wrap(function (options) {\n            var _a;\n            var canonizeResults = options.context.canonizeResults;\n            var peekArgs = execSelectionSetKeyArgs(options);\n            peekArgs[3] = !canonizeResults;\n            var other = (_a = _this.executeSelectionSet).peek.apply(_a, peekArgs);\n            if (other) {\n                if (canonizeResults) {\n                    return tslib.__assign(tslib.__assign({}, other), {\n                        result: _this.canon.admit(other.result) });\n                }\n                return other;\n            }\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSelectionSetImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                utilities.cacheSizes[\"inMemoryCache.executeSelectionSet\"] ||\n                50000 ,\n            keyArgs: execSelectionSetKeyArgs,\n            makeCacheKey: function (selectionSet, parent, context, canonizeResults) {\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(selectionSet, utilities.isReference(parent) ? parent.__ref : parent, context.varString, canonizeResults);\n                }\n            },\n        });\n        this.executeSubSelectedArray = optimism.wrap(function (options) {\n            maybeDependOnExistenceOfEntity(options.context.store, options.enclosingRef.__ref);\n            return _this.execSubSelectedArrayImpl(options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                utilities.cacheSizes[\"inMemoryCache.executeSubSelectedArray\"] ||\n                10000 ,\n            makeCacheKey: function (_a) {\n                var field = _a.field, array = _a.array, context = _a.context;\n                if (supportsResultCaching(context.store)) {\n                    return context.store.makeCacheKey(field, array, context.varString);\n                }\n            },\n        });\n    }\n    StoreReader.prototype.resetCanon = function () {\n        this.canon = new ObjectCanon();\n    };\n    StoreReader.prototype.diffQueryAgainstStore = function (_a) {\n        var store = _a.store, query = _a.query, _b = _a.rootId, rootId = _b === void 0 ? \"ROOT_QUERY\" : _b, variables = _a.variables, _c = _a.returnPartialData, returnPartialData = _c === void 0 ? true : _c, _d = _a.canonizeResults, canonizeResults = _d === void 0 ? this.config.canonizeResults : _d;\n        var policies = this.config.cache.policies;\n        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(utilities.getQueryDefinition(query))), variables);\n        var rootRef = utilities.makeReference(rootId);\n        var execResult = this.executeSelectionSet({\n            selectionSet: utilities.getMainDefinition(query).selectionSet,\n            objectOrReference: rootRef,\n            enclosingRef: rootRef,\n            context: tslib.__assign({ store: store, query: query, policies: policies, variables: variables, varString: utilities.canonicalStringify(variables), canonizeResults: canonizeResults }, extractFragmentContext(query, this.config.fragments)),\n        });\n        var missing;\n        if (execResult.missing) {\n            missing = [\n                new MissingFieldError(firstMissing(execResult.missing), execResult.missing, query, variables),\n            ];\n            if (!returnPartialData) {\n                throw missing[0];\n            }\n        }\n        return {\n            result: execResult.result,\n            complete: !missing,\n            missing: missing,\n        };\n    };\n    StoreReader.prototype.isFresh = function (result, parent, selectionSet, context) {\n        if (supportsResultCaching(context.store) &&\n            this.knownResults.get(result) === selectionSet) {\n            var latest = this.executeSelectionSet.peek(selectionSet, parent, context,\n            this.canon.isKnown(result));\n            if (latest && result === latest.result) {\n                return true;\n            }\n        }\n        return false;\n    };\n    StoreReader.prototype.execSelectionSetImpl = function (_a) {\n        var _this = this;\n        var selectionSet = _a.selectionSet, objectOrReference = _a.objectOrReference, enclosingRef = _a.enclosingRef, context = _a.context;\n        if (utilities.isReference(objectOrReference) &&\n            !context.policies.rootTypenamesById[objectOrReference.__ref] &&\n            !context.store.has(objectOrReference.__ref)) {\n            return {\n                result: this.canon.empty,\n                missing: \"Dangling reference to missing \".concat(objectOrReference.__ref, \" object\"),\n            };\n        }\n        var variables = context.variables, policies = context.policies, store = context.store;\n        var typename = store.getFieldValue(objectOrReference, \"__typename\");\n        var objectsToMerge = [];\n        var missing;\n        var missingMerger = new utilities.DeepMerger();\n        if (this.config.addTypename &&\n            typeof typename === \"string\" &&\n            !policies.rootIdsByTypename[typename]) {\n            objectsToMerge.push({ __typename: typename });\n        }\n        function handleMissing(result, resultName) {\n            var _a;\n            if (result.missing) {\n                missing = missingMerger.merge(missing, (_a = {},\n                    _a[resultName] = result.missing,\n                    _a));\n            }\n            return result.result;\n        }\n        var workSet = new Set(selectionSet.selections);\n        workSet.forEach(function (selection) {\n            var _a, _b;\n            if (!utilities.shouldInclude(selection, variables))\n                return;\n            if (utilities.isField(selection)) {\n                var fieldValue = policies.readField({\n                    fieldName: selection.name.value,\n                    field: selection,\n                    variables: context.variables,\n                    from: objectOrReference,\n                }, context);\n                var resultName = utilities.resultKeyNameFromField(selection);\n                if (fieldValue === void 0) {\n                    if (!utilities.addTypenameToDocument.added(selection)) {\n                        missing = missingMerger.merge(missing, (_a = {},\n                            _a[resultName] = \"Can't find field '\".concat(selection.name.value, \"' on \").concat(utilities.isReference(objectOrReference) ?\n                                objectOrReference.__ref + \" object\"\n                                : \"object \" + JSON.stringify(objectOrReference, null, 2)),\n                            _a));\n                    }\n                }\n                else if (utilities.isArray(fieldValue)) {\n                    if (fieldValue.length > 0) {\n                        fieldValue = handleMissing(_this.executeSubSelectedArray({\n                            field: selection,\n                            array: fieldValue,\n                            enclosingRef: enclosingRef,\n                            context: context,\n                        }), resultName);\n                    }\n                }\n                else if (!selection.selectionSet) {\n                    if (context.canonizeResults) {\n                        fieldValue = _this.canon.pass(fieldValue);\n                    }\n                }\n                else if (fieldValue != null) {\n                    fieldValue = handleMissing(_this.executeSelectionSet({\n                        selectionSet: selection.selectionSet,\n                        objectOrReference: fieldValue,\n                        enclosingRef: utilities.isReference(fieldValue) ? fieldValue : enclosingRef,\n                        context: context,\n                    }), resultName);\n                }\n                if (fieldValue !== void 0) {\n                    objectsToMerge.push((_b = {}, _b[resultName] = fieldValue, _b));\n                }\n            }\n            else {\n                var fragment = utilities.getFragmentFromSelection(selection, context.lookupFragment);\n                if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {\n                    throw globals.newInvariantError(10, selection.name.value);\n                }\n                if (fragment && policies.fragmentMatches(fragment, typename)) {\n                    fragment.selectionSet.selections.forEach(workSet.add, workSet);\n                }\n            }\n        });\n        var result = utilities.mergeDeepArray(objectsToMerge);\n        var finalResult = { result: result, missing: missing };\n        var frozen = context.canonizeResults ?\n            this.canon.admit(finalResult)\n            : utilities.maybeDeepFreeze(finalResult);\n        if (frozen.result) {\n            this.knownResults.set(frozen.result, selectionSet);\n        }\n        return frozen;\n    };\n    StoreReader.prototype.execSubSelectedArrayImpl = function (_a) {\n        var _this = this;\n        var field = _a.field, array = _a.array, enclosingRef = _a.enclosingRef, context = _a.context;\n        var missing;\n        var missingMerger = new utilities.DeepMerger();\n        function handleMissing(childResult, i) {\n            var _a;\n            if (childResult.missing) {\n                missing = missingMerger.merge(missing, (_a = {}, _a[i] = childResult.missing, _a));\n            }\n            return childResult.result;\n        }\n        if (field.selectionSet) {\n            array = array.filter(context.store.canRead);\n        }\n        array = array.map(function (item, i) {\n            if (item === null) {\n                return null;\n            }\n            if (utilities.isArray(item)) {\n                return handleMissing(_this.executeSubSelectedArray({\n                    field: field,\n                    array: item,\n                    enclosingRef: enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (field.selectionSet) {\n                return handleMissing(_this.executeSelectionSet({\n                    selectionSet: field.selectionSet,\n                    objectOrReference: item,\n                    enclosingRef: utilities.isReference(item) ? item : enclosingRef,\n                    context: context,\n                }), i);\n            }\n            if (globalThis.__DEV__ !== false) {\n                assertSelectionSetForIdValue(context.store, field, item);\n            }\n            return item;\n        });\n        return {\n            result: context.canonizeResults ? this.canon.admit(array) : array,\n            missing: missing,\n        };\n    };\n    return StoreReader;\n}());\nfunction firstMissing(tree) {\n    try {\n        JSON.stringify(tree, function (_, value) {\n            if (typeof value === \"string\")\n                throw value;\n            return value;\n        });\n    }\n    catch (result) {\n        return result;\n    }\n}\nfunction assertSelectionSetForIdValue(store, field, fieldValue) {\n    if (!field.selectionSet) {\n        var workSet_1 = new Set([fieldValue]);\n        workSet_1.forEach(function (value) {\n            if (utilities.isNonNullObject(value)) {\n                globals.invariant(\n                    !utilities.isReference(value),\n                    11,\n                    getTypenameFromStoreObject(store, value),\n                    field.name.value\n                );\n                Object.values(value).forEach(workSet_1.add, workSet_1);\n            }\n        });\n    }\n}\n\nvar cacheSlot = new optimism.Slot();\nvar cacheInfoMap = new WeakMap();\nfunction getCacheInfo(cache) {\n    var info = cacheInfoMap.get(cache);\n    if (!info) {\n        cacheInfoMap.set(cache, (info = {\n            vars: new Set(),\n            dep: optimism.dep(),\n        }));\n    }\n    return info;\n}\nfunction forgetCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.forgetCache(cache); });\n}\nfunction recallCache(cache) {\n    getCacheInfo(cache).vars.forEach(function (rv) { return rv.attachCache(cache); });\n}\nfunction makeVar(value) {\n    var caches = new Set();\n    var listeners = new Set();\n    var rv = function (newValue) {\n        if (arguments.length > 0) {\n            if (value !== newValue) {\n                value = newValue;\n                caches.forEach(function (cache) {\n                    getCacheInfo(cache).dep.dirty(rv);\n                    broadcast(cache);\n                });\n                var oldListeners = Array.from(listeners);\n                listeners.clear();\n                oldListeners.forEach(function (listener) { return listener(value); });\n            }\n        }\n        else {\n            var cache = cacheSlot.getValue();\n            if (cache) {\n                attach(cache);\n                getCacheInfo(cache).dep(rv);\n            }\n        }\n        return value;\n    };\n    rv.onNextChange = function (listener) {\n        listeners.add(listener);\n        return function () {\n            listeners.delete(listener);\n        };\n    };\n    var attach = (rv.attachCache = function (cache) {\n        caches.add(cache);\n        getCacheInfo(cache).vars.add(rv);\n        return rv;\n    });\n    rv.forgetCache = function (cache) { return caches.delete(cache); };\n    return rv;\n}\nfunction broadcast(cache) {\n    if (cache.broadcastWatches) {\n        cache.broadcastWatches();\n    }\n}\n\nvar specifierInfoCache = Object.create(null);\nfunction lookupSpecifierInfo(spec) {\n    var cacheKey = JSON.stringify(spec);\n    return (specifierInfoCache[cacheKey] ||\n        (specifierInfoCache[cacheKey] = Object.create(null)));\n}\nfunction keyFieldsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyFieldsFn || (info.keyFieldsFn = function (object, context) {\n            var extract = function (from, key) {\n                return context.readField(key, from);\n            };\n            var keyObject = (context.keyObject = collectSpecifierPaths(specifier, function (schemaKeyPath) {\n                var extracted = extractKeyPath(context.storeObject, schemaKeyPath,\n                extract);\n                if (extracted === void 0 &&\n                    object !== context.storeObject &&\n                    hasOwn.call(object, schemaKeyPath[0])) {\n                    extracted = extractKeyPath(object, schemaKeyPath, extractKey);\n                }\n                globals.invariant(extracted !== void 0, 5, schemaKeyPath.join(\".\"), object);\n                return extracted;\n            }));\n            return \"\".concat(context.typename, \":\").concat(JSON.stringify(keyObject));\n        }));\n}\nfunction keyArgsFnFromSpecifier(specifier) {\n    var info = lookupSpecifierInfo(specifier);\n    return (info.keyArgsFn ||\n        (info.keyArgsFn = function (args, _a) {\n            var field = _a.field, variables = _a.variables, fieldName = _a.fieldName;\n            var collected = collectSpecifierPaths(specifier, function (keyPath) {\n                var firstKey = keyPath[0];\n                var firstChar = firstKey.charAt(0);\n                if (firstChar === \"@\") {\n                    if (field && utilities.isNonEmptyArray(field.directives)) {\n                        var directiveName_1 = firstKey.slice(1);\n                        var d = field.directives.find(function (d) { return d.name.value === directiveName_1; });\n                        var directiveArgs = d && utilities.argumentsObjectFromField(d, variables);\n                        return (directiveArgs &&\n                            extractKeyPath(directiveArgs,\n                            keyPath.slice(1)));\n                    }\n                    return;\n                }\n                if (firstChar === \"$\") {\n                    var variableName = firstKey.slice(1);\n                    if (variables && hasOwn.call(variables, variableName)) {\n                        var varKeyPath = keyPath.slice(0);\n                        varKeyPath[0] = variableName;\n                        return extractKeyPath(variables, varKeyPath);\n                    }\n                    return;\n                }\n                if (args) {\n                    return extractKeyPath(args, keyPath);\n                }\n            });\n            var suffix = JSON.stringify(collected);\n            if (args || suffix !== \"{}\") {\n                fieldName += \":\" + suffix;\n            }\n            return fieldName;\n        }));\n}\nfunction collectSpecifierPaths(specifier, extractor) {\n    var merger = new utilities.DeepMerger();\n    return getSpecifierPaths(specifier).reduce(function (collected, path) {\n        var _a;\n        var toMerge = extractor(path);\n        if (toMerge !== void 0) {\n            for (var i = path.length - 1; i >= 0; --i) {\n                toMerge = (_a = {}, _a[path[i]] = toMerge, _a);\n            }\n            collected = merger.merge(collected, toMerge);\n        }\n        return collected;\n    }, Object.create(null));\n}\nfunction getSpecifierPaths(spec) {\n    var info = lookupSpecifierInfo(spec);\n    if (!info.paths) {\n        var paths_1 = (info.paths = []);\n        var currentPath_1 = [];\n        spec.forEach(function (s, i) {\n            if (utilities.isArray(s)) {\n                getSpecifierPaths(s).forEach(function (p) { return paths_1.push(currentPath_1.concat(p)); });\n                currentPath_1.length = 0;\n            }\n            else {\n                currentPath_1.push(s);\n                if (!utilities.isArray(spec[i + 1])) {\n                    paths_1.push(currentPath_1.slice(0));\n                    currentPath_1.length = 0;\n                }\n            }\n        });\n    }\n    return info.paths;\n}\nfunction extractKey(object, key) {\n    return object[key];\n}\nfunction extractKeyPath(object, path, extract) {\n    extract = extract || extractKey;\n    return normalize(path.reduce(function reducer(obj, key) {\n        return utilities.isArray(obj) ?\n            obj.map(function (child) { return reducer(child, key); })\n            : obj && extract(obj, key);\n    }, object));\n}\nfunction normalize(value) {\n    if (utilities.isNonNullObject(value)) {\n        if (utilities.isArray(value)) {\n            return value.map(normalize);\n        }\n        return collectSpecifierPaths(Object.keys(value).sort(), function (path) {\n            return extractKeyPath(value, path);\n        });\n    }\n    return value;\n}\n\nfunction argsFromFieldSpecifier(spec) {\n    return (spec.args !== void 0 ? spec.args\n        : spec.field ? utilities.argumentsObjectFromField(spec.field, spec.variables)\n            : null);\n}\nvar nullKeyFieldsFn = function () { return void 0; };\nvar simpleKeyArgsFn = function (_args, context) { return context.fieldName; };\nvar mergeTrueFn = function (existing, incoming, _a) {\n    var mergeObjects = _a.mergeObjects;\n    return mergeObjects(existing, incoming);\n};\nvar mergeFalseFn = function (_, incoming) { return incoming; };\nvar Policies =  (function () {\n    function Policies(config) {\n        this.config = config;\n        this.typePolicies = Object.create(null);\n        this.toBeAdded = Object.create(null);\n        this.supertypeMap = new Map();\n        this.fuzzySubtypes = new Map();\n        this.rootIdsByTypename = Object.create(null);\n        this.rootTypenamesById = Object.create(null);\n        this.usingPossibleTypes = false;\n        this.config = tslib.__assign({ dataIdFromObject: defaultDataIdFromObject }, config);\n        this.cache = this.config.cache;\n        this.setRootTypename(\"Query\");\n        this.setRootTypename(\"Mutation\");\n        this.setRootTypename(\"Subscription\");\n        if (config.possibleTypes) {\n            this.addPossibleTypes(config.possibleTypes);\n        }\n        if (config.typePolicies) {\n            this.addTypePolicies(config.typePolicies);\n        }\n    }\n    Policies.prototype.identify = function (object, partialContext) {\n        var _a;\n        var policies = this;\n        var typename = (partialContext &&\n            (partialContext.typename || ((_a = partialContext.storeObject) === null || _a === void 0 ? void 0 : _a.__typename))) ||\n            object.__typename;\n        if (typename === this.rootTypenamesById.ROOT_QUERY) {\n            return [\"ROOT_QUERY\"];\n        }\n        var storeObject = (partialContext && partialContext.storeObject) || object;\n        var context = tslib.__assign(tslib.__assign({}, partialContext), { typename: typename, storeObject: storeObject, readField: (partialContext && partialContext.readField) ||\n                function () {\n                    var options = normalizeReadFieldOptions(arguments, storeObject);\n                    return policies.readField(options, {\n                        store: policies.cache[\"data\"],\n                        variables: options.variables,\n                    });\n                } });\n        var id;\n        var policy = typename && this.getTypePolicy(typename);\n        var keyFn = (policy && policy.keyFn) || this.config.dataIdFromObject;\n        masking.disableWarningsSlot.withValue(true, function () {\n            while (keyFn) {\n                var specifierOrId = keyFn(tslib.__assign(tslib.__assign({}, object), storeObject), context);\n                if (utilities.isArray(specifierOrId)) {\n                    keyFn = keyFieldsFnFromSpecifier(specifierOrId);\n                }\n                else {\n                    id = specifierOrId;\n                    break;\n                }\n            }\n        });\n        id = id ? String(id) : void 0;\n        return context.keyObject ? [id, context.keyObject] : [id];\n    };\n    Policies.prototype.addTypePolicies = function (typePolicies) {\n        var _this = this;\n        Object.keys(typePolicies).forEach(function (typename) {\n            var _a = typePolicies[typename], queryType = _a.queryType, mutationType = _a.mutationType, subscriptionType = _a.subscriptionType, incoming = tslib.__rest(_a, [\"queryType\", \"mutationType\", \"subscriptionType\"]);\n            if (queryType)\n                _this.setRootTypename(\"Query\", typename);\n            if (mutationType)\n                _this.setRootTypename(\"Mutation\", typename);\n            if (subscriptionType)\n                _this.setRootTypename(\"Subscription\", typename);\n            if (hasOwn.call(_this.toBeAdded, typename)) {\n                _this.toBeAdded[typename].push(incoming);\n            }\n            else {\n                _this.toBeAdded[typename] = [incoming];\n            }\n        });\n    };\n    Policies.prototype.updateTypePolicy = function (typename, incoming, existingFieldPolicies) {\n        var existing = this.getTypePolicy(typename);\n        var keyFields = incoming.keyFields, fields = incoming.fields;\n        function setMerge(existing, merge) {\n            existing.merge =\n                typeof merge === \"function\" ? merge\n                    : merge === true ? mergeTrueFn\n                        : merge === false ? mergeFalseFn\n                            : existing.merge;\n        }\n        setMerge(existing, incoming.merge);\n        existing.keyFn =\n            keyFields === false ? nullKeyFieldsFn\n                : utilities.isArray(keyFields) ? keyFieldsFnFromSpecifier(keyFields)\n                    : typeof keyFields === \"function\" ? keyFields\n                        : existing.keyFn;\n        if (fields) {\n            Object.keys(fields).forEach(function (fieldName) {\n                var existing = existingFieldPolicies[fieldName];\n                if (!existing || (existing === null || existing === void 0 ? void 0 : existing.typename) !== typename) {\n                    existing = existingFieldPolicies[fieldName] = { typename: typename };\n                }\n                var incoming = fields[fieldName];\n                if (typeof incoming === \"function\") {\n                    existing.read = incoming;\n                }\n                else {\n                    var keyArgs = incoming.keyArgs, read = incoming.read, merge = incoming.merge;\n                    existing.keyFn =\n                        keyArgs === false ? simpleKeyArgsFn\n                            : utilities.isArray(keyArgs) ? keyArgsFnFromSpecifier(keyArgs)\n                                : typeof keyArgs === \"function\" ? keyArgs\n                                    : existing.keyFn;\n                    if (typeof read === \"function\") {\n                        existing.read = read;\n                    }\n                    setMerge(existing, merge);\n                }\n                if (existing.read && existing.merge) {\n                    existing.keyFn = existing.keyFn || simpleKeyArgsFn;\n                }\n            });\n        }\n    };\n    Policies.prototype.setRootTypename = function (which, typename) {\n        if (typename === void 0) { typename = which; }\n        var rootId = \"ROOT_\" + which.toUpperCase();\n        var old = this.rootTypenamesById[rootId];\n        if (typename !== old) {\n            globals.invariant(!old || old === which, 6, which);\n            if (old)\n                delete this.rootIdsByTypename[old];\n            this.rootIdsByTypename[typename] = rootId;\n            this.rootTypenamesById[rootId] = typename;\n        }\n    };\n    Policies.prototype.addPossibleTypes = function (possibleTypes) {\n        var _this = this;\n        this.usingPossibleTypes = true;\n        Object.keys(possibleTypes).forEach(function (supertype) {\n            _this.getSupertypeSet(supertype, true);\n            possibleTypes[supertype].forEach(function (subtype) {\n                _this.getSupertypeSet(subtype, true).add(supertype);\n                var match = subtype.match(TypeOrFieldNameRegExp);\n                if (!match || match[0] !== subtype) {\n                    _this.fuzzySubtypes.set(subtype, new RegExp(subtype));\n                }\n            });\n        });\n    };\n    Policies.prototype.getTypePolicy = function (typename) {\n        var _this = this;\n        if (!hasOwn.call(this.typePolicies, typename)) {\n            var policy_1 = (this.typePolicies[typename] = Object.create(null));\n            policy_1.fields = Object.create(null);\n            var supertypes_1 = this.supertypeMap.get(typename);\n            if (!supertypes_1 && this.fuzzySubtypes.size) {\n                supertypes_1 = this.getSupertypeSet(typename, true);\n                this.fuzzySubtypes.forEach(function (regExp, fuzzy) {\n                    if (regExp.test(typename)) {\n                        var fuzzySupertypes = _this.supertypeMap.get(fuzzy);\n                        if (fuzzySupertypes) {\n                            fuzzySupertypes.forEach(function (supertype) {\n                                return supertypes_1.add(supertype);\n                            });\n                        }\n                    }\n                });\n            }\n            if (supertypes_1 && supertypes_1.size) {\n                supertypes_1.forEach(function (supertype) {\n                    var _a = _this.getTypePolicy(supertype), fields = _a.fields, rest = tslib.__rest(_a, [\"fields\"]);\n                    Object.assign(policy_1, rest);\n                    Object.assign(policy_1.fields, fields);\n                });\n            }\n        }\n        var inbox = this.toBeAdded[typename];\n        if (inbox && inbox.length) {\n            inbox.splice(0).forEach(function (policy) {\n                _this.updateTypePolicy(typename, policy, _this.typePolicies[typename].fields);\n            });\n        }\n        return this.typePolicies[typename];\n    };\n    Policies.prototype.getFieldPolicy = function (typename, fieldName) {\n        if (typename) {\n            return this.getTypePolicy(typename).fields[fieldName];\n        }\n    };\n    Policies.prototype.getSupertypeSet = function (subtype, createIfMissing) {\n        var supertypeSet = this.supertypeMap.get(subtype);\n        if (!supertypeSet && createIfMissing) {\n            this.supertypeMap.set(subtype, (supertypeSet = new Set()));\n        }\n        return supertypeSet;\n    };\n    Policies.prototype.fragmentMatches = function (fragment, typename, result, variables) {\n        var _this = this;\n        if (!fragment.typeCondition)\n            return true;\n        if (!typename)\n            return false;\n        var supertype = fragment.typeCondition.name.value;\n        if (typename === supertype)\n            return true;\n        if (this.usingPossibleTypes && this.supertypeMap.has(supertype)) {\n            var typenameSupertypeSet = this.getSupertypeSet(typename, true);\n            var workQueue_1 = [typenameSupertypeSet];\n            var maybeEnqueue_1 = function (subtype) {\n                var supertypeSet = _this.getSupertypeSet(subtype, false);\n                if (supertypeSet &&\n                    supertypeSet.size &&\n                    workQueue_1.indexOf(supertypeSet) < 0) {\n                    workQueue_1.push(supertypeSet);\n                }\n            };\n            var needToCheckFuzzySubtypes = !!(result && this.fuzzySubtypes.size);\n            var checkingFuzzySubtypes = false;\n            for (var i = 0; i < workQueue_1.length; ++i) {\n                var supertypeSet = workQueue_1[i];\n                if (supertypeSet.has(supertype)) {\n                    if (!typenameSupertypeSet.has(supertype)) {\n                        if (checkingFuzzySubtypes) {\n                            globalThis.__DEV__ !== false && globals.invariant.warn(7, typename, supertype);\n                        }\n                        typenameSupertypeSet.add(supertype);\n                    }\n                    return true;\n                }\n                supertypeSet.forEach(maybeEnqueue_1);\n                if (needToCheckFuzzySubtypes &&\n                    i === workQueue_1.length - 1 &&\n                    selectionSetMatchesResult(fragment.selectionSet, result, variables)) {\n                    needToCheckFuzzySubtypes = false;\n                    checkingFuzzySubtypes = true;\n                    this.fuzzySubtypes.forEach(function (regExp, fuzzyString) {\n                        var match = typename.match(regExp);\n                        if (match && match[0] === typename) {\n                            maybeEnqueue_1(fuzzyString);\n                        }\n                    });\n                }\n            }\n        }\n        return false;\n    };\n    Policies.prototype.hasKeyArgs = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName);\n        return !!(policy && policy.keyFn);\n    };\n    Policies.prototype.getStoreFieldName = function (fieldSpec) {\n        var typename = fieldSpec.typename, fieldName = fieldSpec.fieldName;\n        var policy = this.getFieldPolicy(typename, fieldName);\n        var storeFieldName;\n        var keyFn = policy && policy.keyFn;\n        if (keyFn && typename) {\n            var context = {\n                typename: typename,\n                fieldName: fieldName,\n                field: fieldSpec.field || null,\n                variables: fieldSpec.variables,\n            };\n            var args = argsFromFieldSpecifier(fieldSpec);\n            while (keyFn) {\n                var specifierOrString = keyFn(args, context);\n                if (utilities.isArray(specifierOrString)) {\n                    keyFn = keyArgsFnFromSpecifier(specifierOrString);\n                }\n                else {\n                    storeFieldName = specifierOrString || fieldName;\n                    break;\n                }\n            }\n        }\n        if (storeFieldName === void 0) {\n            storeFieldName =\n                fieldSpec.field ?\n                    utilities.storeKeyNameFromField(fieldSpec.field, fieldSpec.variables)\n                    : utilities.getStoreKeyName(fieldName, argsFromFieldSpecifier(fieldSpec));\n        }\n        if (storeFieldName === false) {\n            return fieldName;\n        }\n        return fieldName === fieldNameFromStoreName(storeFieldName) ? storeFieldName\n            : fieldName + \":\" + storeFieldName;\n    };\n    Policies.prototype.readField = function (options, context) {\n        var objectOrReference = options.from;\n        if (!objectOrReference)\n            return;\n        var nameOrField = options.field || options.fieldName;\n        if (!nameOrField)\n            return;\n        if (options.typename === void 0) {\n            var typename = context.store.getFieldValue(objectOrReference, \"__typename\");\n            if (typename)\n                options.typename = typename;\n        }\n        var storeFieldName = this.getStoreFieldName(options);\n        var fieldName = fieldNameFromStoreName(storeFieldName);\n        var existing = context.store.getFieldValue(objectOrReference, storeFieldName);\n        var policy = this.getFieldPolicy(options.typename, fieldName);\n        var read = policy && policy.read;\n        if (read) {\n            var readOptions = makeFieldFunctionOptions(this, objectOrReference, options, context, context.store.getStorage(utilities.isReference(objectOrReference) ?\n                objectOrReference.__ref\n                : objectOrReference, storeFieldName));\n            return cacheSlot.withValue(this.cache, read, [\n                existing,\n                readOptions,\n            ]);\n        }\n        return existing;\n    };\n    Policies.prototype.getReadFunction = function (typename, fieldName) {\n        var policy = this.getFieldPolicy(typename, fieldName);\n        return policy && policy.read;\n    };\n    Policies.prototype.getMergeFunction = function (parentTypename, fieldName, childTypename) {\n        var policy = this.getFieldPolicy(parentTypename, fieldName);\n        var merge = policy && policy.merge;\n        if (!merge && childTypename) {\n            policy = this.getTypePolicy(childTypename);\n            merge = policy && policy.merge;\n        }\n        return merge;\n    };\n    Policies.prototype.runMergeFunction = function (existing, incoming, _a, context, storage) {\n        var field = _a.field, typename = _a.typename, merge = _a.merge;\n        if (merge === mergeTrueFn) {\n            return makeMergeObjectsFunction(context.store)(existing, incoming);\n        }\n        if (merge === mergeFalseFn) {\n            return incoming;\n        }\n        if (context.overwrite) {\n            existing = void 0;\n        }\n        return merge(existing, incoming, makeFieldFunctionOptions(this,\n        void 0, {\n            typename: typename,\n            fieldName: field.name.value,\n            field: field,\n            variables: context.variables,\n        }, context, storage || Object.create(null)));\n    };\n    return Policies;\n}());\nfunction makeFieldFunctionOptions(policies, objectOrReference, fieldSpec, context, storage) {\n    var storeFieldName = policies.getStoreFieldName(fieldSpec);\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var variables = fieldSpec.variables || context.variables;\n    var _a = context.store, toReference = _a.toReference, canRead = _a.canRead;\n    return {\n        args: argsFromFieldSpecifier(fieldSpec),\n        field: fieldSpec.field || null,\n        fieldName: fieldName,\n        storeFieldName: storeFieldName,\n        variables: variables,\n        isReference: utilities.isReference,\n        toReference: toReference,\n        storage: storage,\n        cache: policies.cache,\n        canRead: canRead,\n        readField: function () {\n            return policies.readField(normalizeReadFieldOptions(arguments, objectOrReference, variables), context);\n        },\n        mergeObjects: makeMergeObjectsFunction(context.store),\n    };\n}\nfunction normalizeReadFieldOptions(readFieldArgs, objectOrReference, variables) {\n    var fieldNameOrOptions = readFieldArgs[0], from = readFieldArgs[1], argc = readFieldArgs.length;\n    var options;\n    if (typeof fieldNameOrOptions === \"string\") {\n        options = {\n            fieldName: fieldNameOrOptions,\n            from: argc > 1 ? from : objectOrReference,\n        };\n    }\n    else {\n        options = tslib.__assign({}, fieldNameOrOptions);\n        if (!hasOwn.call(options, \"from\")) {\n            options.from = objectOrReference;\n        }\n    }\n    if (globalThis.__DEV__ !== false && options.from === void 0) {\n        globalThis.__DEV__ !== false && globals.invariant.warn(8, utilities.stringifyForDisplay(Array.from(readFieldArgs)));\n    }\n    if (void 0 === options.variables) {\n        options.variables = variables;\n    }\n    return options;\n}\nfunction makeMergeObjectsFunction(store) {\n    return function mergeObjects(existing, incoming) {\n        if (utilities.isArray(existing) || utilities.isArray(incoming)) {\n            throw globals.newInvariantError(9);\n        }\n        if (utilities.isNonNullObject(existing) && utilities.isNonNullObject(incoming)) {\n            var eType = store.getFieldValue(existing, \"__typename\");\n            var iType = store.getFieldValue(incoming, \"__typename\");\n            var typesDiffer = eType && iType && eType !== iType;\n            if (typesDiffer) {\n                return incoming;\n            }\n            if (utilities.isReference(existing) && storeValueIsStoreObject(incoming)) {\n                store.merge(existing.__ref, incoming);\n                return existing;\n            }\n            if (storeValueIsStoreObject(existing) && utilities.isReference(incoming)) {\n                store.merge(existing, incoming.__ref);\n                return incoming;\n            }\n            if (storeValueIsStoreObject(existing) &&\n                storeValueIsStoreObject(incoming)) {\n                return tslib.__assign(tslib.__assign({}, existing), incoming);\n            }\n        }\n        return incoming;\n    };\n}\n\nfunction getContextFlavor(context, clientOnly, deferred) {\n    var key = \"\".concat(clientOnly).concat(deferred);\n    var flavored = context.flavors.get(key);\n    if (!flavored) {\n        context.flavors.set(key, (flavored =\n            context.clientOnly === clientOnly && context.deferred === deferred ?\n                context\n                : tslib.__assign(tslib.__assign({}, context), { clientOnly: clientOnly, deferred: deferred })));\n    }\n    return flavored;\n}\nvar StoreWriter =  (function () {\n    function StoreWriter(cache, reader, fragments) {\n        this.cache = cache;\n        this.reader = reader;\n        this.fragments = fragments;\n    }\n    StoreWriter.prototype.writeToStore = function (store, _a) {\n        var _this = this;\n        var query = _a.query, result = _a.result, dataId = _a.dataId, variables = _a.variables, overwrite = _a.overwrite;\n        var operationDefinition = utilities.getOperationDefinition(query);\n        var merger = makeProcessedFieldsMerger();\n        variables = tslib.__assign(tslib.__assign({}, utilities.getDefaultValues(operationDefinition)), variables);\n        var context = tslib.__assign(tslib.__assign({ store: store, written: Object.create(null), merge: function (existing, incoming) {\n                return merger.merge(existing, incoming);\n            }, variables: variables, varString: utilities.canonicalStringify(variables) }, extractFragmentContext(query, this.fragments)), { overwrite: !!overwrite, incomingById: new Map(), clientOnly: false, deferred: false, flavors: new Map() });\n        var ref = this.processSelectionSet({\n            result: result || Object.create(null),\n            dataId: dataId,\n            selectionSet: operationDefinition.selectionSet,\n            mergeTree: { map: new Map() },\n            context: context,\n        });\n        if (!utilities.isReference(ref)) {\n            throw globals.newInvariantError(12, result);\n        }\n        context.incomingById.forEach(function (_a, dataId) {\n            var storeObject = _a.storeObject, mergeTree = _a.mergeTree, fieldNodeSet = _a.fieldNodeSet;\n            var entityRef = utilities.makeReference(dataId);\n            if (mergeTree && mergeTree.map.size) {\n                var applied = _this.applyMerges(mergeTree, entityRef, storeObject, context);\n                if (utilities.isReference(applied)) {\n                    return;\n                }\n                storeObject = applied;\n            }\n            if (globalThis.__DEV__ !== false && !context.overwrite) {\n                var fieldsWithSelectionSets_1 = Object.create(null);\n                fieldNodeSet.forEach(function (field) {\n                    if (field.selectionSet) {\n                        fieldsWithSelectionSets_1[field.name.value] = true;\n                    }\n                });\n                var hasSelectionSet_1 = function (storeFieldName) {\n                    return fieldsWithSelectionSets_1[fieldNameFromStoreName(storeFieldName)] ===\n                        true;\n                };\n                var hasMergeFunction_1 = function (storeFieldName) {\n                    var childTree = mergeTree && mergeTree.map.get(storeFieldName);\n                    return Boolean(childTree && childTree.info && childTree.info.merge);\n                };\n                Object.keys(storeObject).forEach(function (storeFieldName) {\n                    if (hasSelectionSet_1(storeFieldName) &&\n                        !hasMergeFunction_1(storeFieldName)) {\n                        warnAboutDataLoss(entityRef, storeObject, storeFieldName, context.store);\n                    }\n                });\n            }\n            store.merge(dataId, storeObject);\n        });\n        store.retain(ref.__ref);\n        return ref;\n    };\n    StoreWriter.prototype.processSelectionSet = function (_a) {\n        var _this = this;\n        var dataId = _a.dataId, result = _a.result, selectionSet = _a.selectionSet, context = _a.context,\n        mergeTree = _a.mergeTree;\n        var policies = this.cache.policies;\n        var incoming = Object.create(null);\n        var typename = (dataId && policies.rootTypenamesById[dataId]) ||\n            utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap) ||\n            (dataId && context.store.get(dataId, \"__typename\"));\n        if (\"string\" === typeof typename) {\n            incoming.__typename = typename;\n        }\n        var readField = function () {\n            var options = normalizeReadFieldOptions(arguments, incoming, context.variables);\n            if (utilities.isReference(options.from)) {\n                var info = context.incomingById.get(options.from.__ref);\n                if (info) {\n                    var result_1 = policies.readField(tslib.__assign(tslib.__assign({}, options), { from: info.storeObject }), context);\n                    if (result_1 !== void 0) {\n                        return result_1;\n                    }\n                }\n            }\n            return policies.readField(options, context);\n        };\n        var fieldNodeSet = new Set();\n        this.flattenFields(selectionSet, result,\n        context, typename).forEach(function (context, field) {\n            var _a;\n            var resultFieldKey = utilities.resultKeyNameFromField(field);\n            var value = result[resultFieldKey];\n            fieldNodeSet.add(field);\n            if (value !== void 0) {\n                var storeFieldName = policies.getStoreFieldName({\n                    typename: typename,\n                    fieldName: field.name.value,\n                    field: field,\n                    variables: context.variables,\n                });\n                var childTree = getChildMergeTree(mergeTree, storeFieldName);\n                var incomingValue = _this.processFieldValue(value, field,\n                field.selectionSet ?\n                    getContextFlavor(context, false, false)\n                    : context, childTree);\n                var childTypename = void 0;\n                if (field.selectionSet &&\n                    (utilities.isReference(incomingValue) || storeValueIsStoreObject(incomingValue))) {\n                    childTypename = readField(\"__typename\", incomingValue);\n                }\n                var merge = policies.getMergeFunction(typename, field.name.value, childTypename);\n                if (merge) {\n                    childTree.info = {\n                        field: field,\n                        typename: typename,\n                        merge: merge,\n                    };\n                }\n                else {\n                    maybeRecycleChildMergeTree(mergeTree, storeFieldName);\n                }\n                incoming = context.merge(incoming, (_a = {},\n                    _a[storeFieldName] = incomingValue,\n                    _a));\n            }\n            else if (globalThis.__DEV__ !== false &&\n                !context.clientOnly &&\n                !context.deferred &&\n                !utilities.addTypenameToDocument.added(field) &&\n                !policies.getReadFunction(typename, field.name.value)) {\n                globalThis.__DEV__ !== false && globals.invariant.error(13, utilities.resultKeyNameFromField(field), result);\n            }\n        });\n        try {\n            var _b = policies.identify(result, {\n                typename: typename,\n                selectionSet: selectionSet,\n                fragmentMap: context.fragmentMap,\n                storeObject: incoming,\n                readField: readField,\n            }), id = _b[0], keyObject = _b[1];\n            dataId = dataId || id;\n            if (keyObject) {\n                incoming = context.merge(incoming, keyObject);\n            }\n        }\n        catch (e) {\n            if (!dataId)\n                throw e;\n        }\n        if (\"string\" === typeof dataId) {\n            var dataRef = utilities.makeReference(dataId);\n            var sets = context.written[dataId] || (context.written[dataId] = []);\n            if (sets.indexOf(selectionSet) >= 0)\n                return dataRef;\n            sets.push(selectionSet);\n            if (this.reader &&\n                this.reader.isFresh(result, dataRef, selectionSet, context)) {\n                return dataRef;\n            }\n            var previous_1 = context.incomingById.get(dataId);\n            if (previous_1) {\n                previous_1.storeObject = context.merge(previous_1.storeObject, incoming);\n                previous_1.mergeTree = mergeMergeTrees(previous_1.mergeTree, mergeTree);\n                fieldNodeSet.forEach(function (field) { return previous_1.fieldNodeSet.add(field); });\n            }\n            else {\n                context.incomingById.set(dataId, {\n                    storeObject: incoming,\n                    mergeTree: mergeTreeIsEmpty(mergeTree) ? void 0 : mergeTree,\n                    fieldNodeSet: fieldNodeSet,\n                });\n            }\n            return dataRef;\n        }\n        return incoming;\n    };\n    StoreWriter.prototype.processFieldValue = function (value, field, context, mergeTree) {\n        var _this = this;\n        if (!field.selectionSet || value === null) {\n            return globalThis.__DEV__ !== false ? utilities.cloneDeep(value) : value;\n        }\n        if (utilities.isArray(value)) {\n            return value.map(function (item, i) {\n                var value = _this.processFieldValue(item, field, context, getChildMergeTree(mergeTree, i));\n                maybeRecycleChildMergeTree(mergeTree, i);\n                return value;\n            });\n        }\n        return this.processSelectionSet({\n            result: value,\n            selectionSet: field.selectionSet,\n            context: context,\n            mergeTree: mergeTree,\n        });\n    };\n    StoreWriter.prototype.flattenFields = function (selectionSet, result, context, typename) {\n        if (typename === void 0) { typename = utilities.getTypenameFromResult(result, selectionSet, context.fragmentMap); }\n        var fieldMap = new Map();\n        var policies = this.cache.policies;\n        var limitingTrie = new trie.Trie(false);\n        (function flatten(selectionSet, inheritedContext) {\n            var visitedNode = limitingTrie.lookup(selectionSet,\n            inheritedContext.clientOnly, inheritedContext.deferred);\n            if (visitedNode.visited)\n                return;\n            visitedNode.visited = true;\n            selectionSet.selections.forEach(function (selection) {\n                if (!utilities.shouldInclude(selection, context.variables))\n                    return;\n                var clientOnly = inheritedContext.clientOnly, deferred = inheritedContext.deferred;\n                if (\n                !(clientOnly && deferred) &&\n                    utilities.isNonEmptyArray(selection.directives)) {\n                    selection.directives.forEach(function (dir) {\n                        var name = dir.name.value;\n                        if (name === \"client\")\n                            clientOnly = true;\n                        if (name === \"defer\") {\n                            var args = utilities.argumentsObjectFromField(dir, context.variables);\n                            if (!args || args.if !== false) {\n                                deferred = true;\n                            }\n                        }\n                    });\n                }\n                if (utilities.isField(selection)) {\n                    var existing = fieldMap.get(selection);\n                    if (existing) {\n                        clientOnly = clientOnly && existing.clientOnly;\n                        deferred = deferred && existing.deferred;\n                    }\n                    fieldMap.set(selection, getContextFlavor(context, clientOnly, deferred));\n                }\n                else {\n                    var fragment = utilities.getFragmentFromSelection(selection, context.lookupFragment);\n                    if (!fragment && selection.kind === graphql.Kind.FRAGMENT_SPREAD) {\n                        throw globals.newInvariantError(14, selection.name.value);\n                    }\n                    if (fragment &&\n                        policies.fragmentMatches(fragment, typename, result, context.variables)) {\n                        flatten(fragment.selectionSet, getContextFlavor(context, clientOnly, deferred));\n                    }\n                }\n            });\n        })(selectionSet, context);\n        return fieldMap;\n    };\n    StoreWriter.prototype.applyMerges = function (mergeTree, existing, incoming, context, getStorageArgs) {\n        var _a;\n        var _this = this;\n        if (mergeTree.map.size && !utilities.isReference(incoming)) {\n            var e_1 =\n            (!utilities.isArray(incoming) &&\n                (utilities.isReference(existing) || storeValueIsStoreObject(existing))) ?\n                existing\n                : void 0;\n            var i_1 = incoming;\n            if (e_1 && !getStorageArgs) {\n                getStorageArgs = [utilities.isReference(e_1) ? e_1.__ref : e_1];\n            }\n            var changedFields_1;\n            var getValue_1 = function (from, name) {\n                return (utilities.isArray(from) ?\n                    typeof name === \"number\" ?\n                        from[name]\n                        : void 0\n                    : context.store.getFieldValue(from, String(name)));\n            };\n            mergeTree.map.forEach(function (childTree, storeFieldName) {\n                var eVal = getValue_1(e_1, storeFieldName);\n                var iVal = getValue_1(i_1, storeFieldName);\n                if (void 0 === iVal)\n                    return;\n                if (getStorageArgs) {\n                    getStorageArgs.push(storeFieldName);\n                }\n                var aVal = _this.applyMerges(childTree, eVal, iVal, context, getStorageArgs);\n                if (aVal !== iVal) {\n                    changedFields_1 = changedFields_1 || new Map();\n                    changedFields_1.set(storeFieldName, aVal);\n                }\n                if (getStorageArgs) {\n                    globals.invariant(getStorageArgs.pop() === storeFieldName);\n                }\n            });\n            if (changedFields_1) {\n                incoming = (utilities.isArray(i_1) ? i_1.slice(0) : tslib.__assign({}, i_1));\n                changedFields_1.forEach(function (value, name) {\n                    incoming[name] = value;\n                });\n            }\n        }\n        if (mergeTree.info) {\n            return this.cache.policies.runMergeFunction(existing, incoming, mergeTree.info, context, getStorageArgs && (_a = context.store).getStorage.apply(_a, getStorageArgs));\n        }\n        return incoming;\n    };\n    return StoreWriter;\n}());\nvar emptyMergeTreePool = [];\nfunction getChildMergeTree(_a, name) {\n    var map = _a.map;\n    if (!map.has(name)) {\n        map.set(name, emptyMergeTreePool.pop() || { map: new Map() });\n    }\n    return map.get(name);\n}\nfunction mergeMergeTrees(left, right) {\n    if (left === right || !right || mergeTreeIsEmpty(right))\n        return left;\n    if (!left || mergeTreeIsEmpty(left))\n        return right;\n    var info = left.info && right.info ? tslib.__assign(tslib.__assign({}, left.info), right.info) : left.info || right.info;\n    var needToMergeMaps = left.map.size && right.map.size;\n    var map = needToMergeMaps ? new Map()\n        : left.map.size ? left.map\n            : right.map;\n    var merged = { info: info, map: map };\n    if (needToMergeMaps) {\n        var remainingRightKeys_1 = new Set(right.map.keys());\n        left.map.forEach(function (leftTree, key) {\n            merged.map.set(key, mergeMergeTrees(leftTree, right.map.get(key)));\n            remainingRightKeys_1.delete(key);\n        });\n        remainingRightKeys_1.forEach(function (key) {\n            merged.map.set(key, mergeMergeTrees(right.map.get(key), left.map.get(key)));\n        });\n    }\n    return merged;\n}\nfunction mergeTreeIsEmpty(tree) {\n    return !tree || !(tree.info || tree.map.size);\n}\nfunction maybeRecycleChildMergeTree(_a, name) {\n    var map = _a.map;\n    var childTree = map.get(name);\n    if (childTree && mergeTreeIsEmpty(childTree)) {\n        emptyMergeTreePool.push(childTree);\n        map.delete(name);\n    }\n}\nvar warnings = new Set();\nfunction warnAboutDataLoss(existingRef, incomingObj, storeFieldName, store) {\n    var getChild = function (objOrRef) {\n        var child = store.getFieldValue(objOrRef, storeFieldName);\n        return typeof child === \"object\" && child;\n    };\n    var existing = getChild(existingRef);\n    if (!existing)\n        return;\n    var incoming = getChild(incomingObj);\n    if (!incoming)\n        return;\n    if (utilities.isReference(existing))\n        return;\n    if (equal.equal(existing, incoming))\n        return;\n    if (Object.keys(existing).every(function (key) { return store.getFieldValue(incoming, key) !== void 0; })) {\n        return;\n    }\n    var parentType = store.getFieldValue(existingRef, \"__typename\") ||\n        store.getFieldValue(incomingObj, \"__typename\");\n    var fieldName = fieldNameFromStoreName(storeFieldName);\n    var typeDotName = \"\".concat(parentType, \".\").concat(fieldName);\n    if (warnings.has(typeDotName))\n        return;\n    warnings.add(typeDotName);\n    var childTypenames = [];\n    if (!utilities.isArray(existing) && !utilities.isArray(incoming)) {\n        [existing, incoming].forEach(function (child) {\n            var typename = store.getFieldValue(child, \"__typename\");\n            if (typeof typename === \"string\" && !childTypenames.includes(typename)) {\n                childTypenames.push(typename);\n            }\n        });\n    }\n    globalThis.__DEV__ !== false && globals.invariant.warn(15, fieldName, parentType, childTypenames.length ?\n        \"either ensure all objects of type \" +\n            childTypenames.join(\" and \") +\n            \" have an ID or a custom merge function, or \"\n        : \"\", typeDotName, tslib.__assign({}, existing), tslib.__assign({}, incoming));\n}\n\nvar InMemoryCache =  (function (_super) {\n    tslib.__extends(InMemoryCache, _super);\n    function InMemoryCache(config) {\n        if (config === void 0) { config = {}; }\n        var _this = _super.call(this) || this;\n        _this.watches = new Set();\n        _this.addTypenameTransform = new utilities.DocumentTransform(utilities.addTypenameToDocument);\n        _this.assumeImmutableResults = true;\n        _this.makeVar = makeVar;\n        _this.txCount = 0;\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(config, \"addTypename\", \"InMemoryCache\", \"Please remove the `addTypename` option when initializing `InMemoryCache`.\");\n            warnRemovedOption(config, \"canonizeResults\", \"InMemoryCache\", \"Please remove the `canonizeResults` option when initializing `InMemoryCache`.\");\n        }\n        _this.config = normalizeConfig(config);\n        _this.addTypename = !!_this.config.addTypename;\n        _this.policies = new Policies({\n            cache: _this,\n            dataIdFromObject: _this.config.dataIdFromObject,\n            possibleTypes: _this.config.possibleTypes,\n            typePolicies: _this.config.typePolicies,\n        });\n        _this.init();\n        return _this;\n    }\n    InMemoryCache.prototype.init = function () {\n        var rootStore = (this.data = new exports.EntityStore.Root({\n            policies: this.policies,\n            resultCaching: this.config.resultCaching,\n        }));\n        this.optimisticData = rootStore.stump;\n        this.resetResultCache();\n    };\n    InMemoryCache.prototype.resetResultCache = function (resetResultIdentities) {\n        var _this = this;\n        var previousReader = this.storeReader;\n        var fragments = this.config.fragments;\n        this.addTypenameTransform.resetCache();\n        fragments === null || fragments === void 0 ? void 0 : fragments.resetCaches();\n        this.storeWriter = new StoreWriter(this, (this.storeReader = new StoreReader({\n            cache: this,\n            addTypename: this.addTypename,\n            resultCacheMaxSize: this.config.resultCacheMaxSize,\n            canonizeResults: shouldCanonizeResults(this.config),\n            canon: resetResultIdentities ? void 0 : (previousReader && previousReader.canon),\n            fragments: fragments,\n        })), fragments);\n        this.maybeBroadcastWatch = optimism.wrap(function (c, options) {\n            return _this.broadcastWatch(c, options);\n        }, {\n            max: this.config.resultCacheMaxSize ||\n                utilities.cacheSizes[\"inMemoryCache.maybeBroadcastWatch\"] ||\n                5000 ,\n            makeCacheKey: function (c) {\n                var store = c.optimistic ? _this.optimisticData : _this.data;\n                if (supportsResultCaching(store)) {\n                    var optimistic = c.optimistic, id = c.id, variables = c.variables;\n                    return store.makeCacheKey(c.query,\n                    c.callback, utilities.canonicalStringify({ optimistic: optimistic, id: id, variables: variables }));\n                }\n            },\n        });\n        new Set([this.data.group, this.optimisticData.group]).forEach(function (group) {\n            return group.resetCaching();\n        });\n    };\n    InMemoryCache.prototype.restore = function (data) {\n        this.init();\n        if (data)\n            this.data.replace(data);\n        return this;\n    };\n    InMemoryCache.prototype.extract = function (optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return (optimistic ? this.optimisticData : this.data).extract();\n    };\n    InMemoryCache.prototype.read = function (options) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.read\");\n        }\n        var\n        _a = options.returnPartialData,\n        returnPartialData = _a === void 0 ? false : _a;\n        try {\n            return (this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, config: this.config, returnPartialData: returnPartialData })).result || null);\n        }\n        catch (e) {\n            if (e instanceof MissingFieldError) {\n                return null;\n            }\n            throw e;\n        }\n    };\n    InMemoryCache.prototype.write = function (options) {\n        try {\n            ++this.txCount;\n            return this.storeWriter.writeToStore(this.data, options);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.modify = function (options) {\n        if (hasOwn.call(options, \"id\") && !options.id) {\n            return false;\n        }\n        var store = ((options.optimistic)\n        ) ?\n            this.optimisticData\n            : this.data;\n        try {\n            ++this.txCount;\n            return store.modify(options.id || \"ROOT_QUERY\", options.fields);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.diff = function (options) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"cache.diff\");\n        }\n        return this.storeReader.diffQueryAgainstStore(tslib.__assign(tslib.__assign({}, options), { store: options.optimistic ? this.optimisticData : this.data, rootId: options.id || \"ROOT_QUERY\", config: this.config }));\n    };\n    InMemoryCache.prototype.watch = function (watch) {\n        var _this = this;\n        if (!this.watches.size) {\n            recallCache(this);\n        }\n        this.watches.add(watch);\n        if (watch.immediate) {\n            this.maybeBroadcastWatch(watch);\n        }\n        return function () {\n            if (_this.watches.delete(watch) && !_this.watches.size) {\n                forgetCache(_this);\n            }\n            _this.maybeBroadcastWatch.forget(watch);\n        };\n    };\n    InMemoryCache.prototype.gc = function (options) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options || {}, \"resetResultIdentities\", \"cache.gc\", \"First ensure all usages of `canonizeResults` are removed, then remove this option.\");\n        }\n        utilities.canonicalStringify.reset();\n        utilities.print.reset();\n        var ids = this.optimisticData.gc();\n        if (options && !this.txCount) {\n            if (options.resetResultCache) {\n                this.resetResultCache(options.resetResultIdentities);\n            }\n            else if (options.resetResultIdentities) {\n                this.storeReader.resetCanon();\n            }\n        }\n        return ids;\n    };\n    InMemoryCache.prototype.retain = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).retain(rootId);\n    };\n    InMemoryCache.prototype.release = function (rootId, optimistic) {\n        return (optimistic ? this.optimisticData : this.data).release(rootId);\n    };\n    InMemoryCache.prototype.identify = function (object) {\n        if (utilities.isReference(object))\n            return object.__ref;\n        try {\n            return this.policies.identify(object)[0];\n        }\n        catch (e) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(e);\n        }\n    };\n    InMemoryCache.prototype.evict = function (options) {\n        if (!options.id) {\n            if (hasOwn.call(options, \"id\")) {\n                return false;\n            }\n            options = tslib.__assign(tslib.__assign({}, options), { id: \"ROOT_QUERY\" });\n        }\n        try {\n            ++this.txCount;\n            return this.optimisticData.evict(options, this.data);\n        }\n        finally {\n            if (!--this.txCount && options.broadcast !== false) {\n                this.broadcastWatches();\n            }\n        }\n    };\n    InMemoryCache.prototype.reset = function (options) {\n        var _this = this;\n        this.init();\n        utilities.canonicalStringify.reset();\n        if (options && options.discardWatches) {\n            this.watches.forEach(function (watch) { return _this.maybeBroadcastWatch.forget(watch); });\n            this.watches.clear();\n            forgetCache(this);\n        }\n        else {\n            this.broadcastWatches();\n        }\n        return Promise.resolve();\n    };\n    InMemoryCache.prototype.removeOptimistic = function (idToRemove) {\n        var newOptimisticData = this.optimisticData.removeLayer(idToRemove);\n        if (newOptimisticData !== this.optimisticData) {\n            this.optimisticData = newOptimisticData;\n            this.broadcastWatches();\n        }\n    };\n    InMemoryCache.prototype.batch = function (options) {\n        var _this = this;\n        var update = options.update, _a = options.optimistic, optimistic = _a === void 0 ? true : _a, removeOptimistic = options.removeOptimistic, onWatchUpdated = options.onWatchUpdated;\n        var updateResult;\n        var perform = function (layer) {\n            var _a = _this, data = _a.data, optimisticData = _a.optimisticData;\n            ++_this.txCount;\n            if (layer) {\n                _this.data = _this.optimisticData = layer;\n            }\n            try {\n                return (updateResult = update(_this));\n            }\n            finally {\n                --_this.txCount;\n                _this.data = data;\n                _this.optimisticData = optimisticData;\n            }\n        };\n        var alreadyDirty = new Set();\n        if (onWatchUpdated && !this.txCount) {\n            this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch) {\n                    alreadyDirty.add(watch);\n                    return false;\n                } }));\n        }\n        if (typeof optimistic === \"string\") {\n            this.optimisticData = this.optimisticData.addLayer(optimistic, perform);\n        }\n        else if (optimistic === false) {\n            perform(this.data);\n        }\n        else {\n            perform();\n        }\n        if (typeof removeOptimistic === \"string\") {\n            this.optimisticData = this.optimisticData.removeLayer(removeOptimistic);\n        }\n        if (onWatchUpdated && alreadyDirty.size) {\n            this.broadcastWatches(tslib.__assign(tslib.__assign({}, options), { onWatchUpdated: function (watch, diff) {\n                    var result = onWatchUpdated.call(this, watch, diff);\n                    if (result !== false) {\n                        alreadyDirty.delete(watch);\n                    }\n                    return result;\n                } }));\n            if (alreadyDirty.size) {\n                alreadyDirty.forEach(function (watch) { return _this.maybeBroadcastWatch.dirty(watch); });\n            }\n        }\n        else {\n            this.broadcastWatches(options);\n        }\n        return updateResult;\n    };\n    InMemoryCache.prototype.performTransaction = function (update, optimisticId) {\n        return this.batch({\n            update: update,\n            optimistic: optimisticId || optimisticId !== null,\n        });\n    };\n    InMemoryCache.prototype.transformDocument = function (document) {\n        return this.addTypenameToDocument(this.addFragmentsToDocument(document));\n    };\n    InMemoryCache.prototype.fragmentMatches = function (fragment, typename) {\n        return this.policies.fragmentMatches(fragment, typename);\n    };\n    InMemoryCache.prototype.lookupFragment = function (fragmentName) {\n        var _a;\n        return ((_a = this.config.fragments) === null || _a === void 0 ? void 0 : _a.lookup(fragmentName)) || null;\n    };\n    InMemoryCache.prototype.broadcastWatches = function (options) {\n        var _this = this;\n        if (!this.txCount) {\n            this.watches.forEach(function (c) { return _this.maybeBroadcastWatch(c, options); });\n        }\n    };\n    InMemoryCache.prototype.addFragmentsToDocument = function (document) {\n        var fragments = this.config.fragments;\n        return fragments ? fragments.transform(document) : document;\n    };\n    InMemoryCache.prototype.addTypenameToDocument = function (document) {\n        if (this.addTypename) {\n            return this.addTypenameTransform.transformDocument(document);\n        }\n        return document;\n    };\n    InMemoryCache.prototype.broadcastWatch = function (c, options) {\n        var _this = this;\n        var lastDiff = c.lastDiff;\n        var diff = muteDeprecations(\"canonizeResults\", function () { return _this.diff(c); });\n        if (options) {\n            if (c.optimistic && typeof options.optimistic === \"string\") {\n                diff.fromOptimisticTransaction = true;\n            }\n            if (options.onWatchUpdated &&\n                options.onWatchUpdated.call(this, c, diff, lastDiff) === false) {\n                return;\n            }\n        }\n        if (!lastDiff || !equal.equal(lastDiff.result, diff.result)) {\n            c.callback((c.lastDiff = diff), lastDiff);\n        }\n    };\n    return InMemoryCache;\n}(ApolloCache));\nif (globalThis.__DEV__ !== false) {\n    InMemoryCache.prototype.getMemoryInternals = getInMemoryCacheMemoryInternals;\n}\n\nfunction createFragmentRegistry() {\n    var fragments = [];\n    for (var _i = 0; _i < arguments.length; _i++) {\n        fragments[_i] = arguments[_i];\n    }\n    return new (FragmentRegistry.bind.apply(FragmentRegistry, tslib.__spreadArray([void 0], fragments, false)))();\n}\nvar FragmentRegistry =  (function () {\n    function FragmentRegistry() {\n        var fragments = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            fragments[_i] = arguments[_i];\n        }\n        this.registry = Object.create(null);\n        this.resetCaches();\n        if (fragments.length) {\n            this.register.apply(this, fragments);\n        }\n    }\n    FragmentRegistry.prototype.register = function () {\n        var _this = this;\n        var fragments = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            fragments[_i] = arguments[_i];\n        }\n        var definitions = new Map();\n        fragments.forEach(function (doc) {\n            utilities.getFragmentDefinitions(doc).forEach(function (node) {\n                definitions.set(node.name.value, node);\n            });\n        });\n        definitions.forEach(function (node, name) {\n            if (node !== _this.registry[name]) {\n                _this.registry[name] = node;\n                _this.invalidate(name);\n            }\n        });\n        return this;\n    };\n    FragmentRegistry.prototype.invalidate = function (name) { };\n    FragmentRegistry.prototype.resetCaches = function () {\n        var proto = FragmentRegistry.prototype;\n        this.invalidate = (this.lookup = optimism.wrap(proto.lookup.bind(this), {\n            makeCacheKey: function (arg) { return arg; },\n            max: utilities.cacheSizes[\"fragmentRegistry.lookup\"] ||\n                1000 ,\n        })).dirty;\n        this.transform = optimism.wrap(proto.transform.bind(this), {\n            cache: caches.WeakCache,\n            max: utilities.cacheSizes[\"fragmentRegistry.transform\"] ||\n                2000 ,\n        });\n        this.findFragmentSpreads = optimism.wrap(proto.findFragmentSpreads.bind(this), {\n            cache: caches.WeakCache,\n            max: utilities.cacheSizes[\"fragmentRegistry.findFragmentSpreads\"] ||\n                4000 ,\n        });\n    };\n    FragmentRegistry.prototype.lookup = function (fragmentName) {\n        return this.registry[fragmentName] || null;\n    };\n    FragmentRegistry.prototype.transform = function (document) {\n        var _this = this;\n        var defined = new Map();\n        utilities.getFragmentDefinitions(document).forEach(function (def) {\n            defined.set(def.name.value, def);\n        });\n        var unbound = new Set();\n        var enqueue = function (spreadName) {\n            if (!defined.has(spreadName)) {\n                unbound.add(spreadName);\n            }\n        };\n        var enqueueChildSpreads = function (node) {\n            return Object.keys(_this.findFragmentSpreads(node)).forEach(enqueue);\n        };\n        enqueueChildSpreads(document);\n        var missing = [];\n        var map = Object.create(null);\n        unbound.forEach(function (fragmentName) {\n            var knownFragmentDef = defined.get(fragmentName);\n            if (knownFragmentDef) {\n                enqueueChildSpreads((map[fragmentName] = knownFragmentDef));\n            }\n            else {\n                missing.push(fragmentName);\n                var def = _this.lookup(fragmentName);\n                if (def) {\n                    enqueueChildSpreads((map[fragmentName] = def));\n                }\n            }\n        });\n        if (missing.length) {\n            var defsToAppend_1 = [];\n            missing.forEach(function (name) {\n                var def = map[name];\n                if (def) {\n                    defsToAppend_1.push(def);\n                }\n            });\n            if (defsToAppend_1.length) {\n                document = tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.concat(defsToAppend_1) });\n            }\n        }\n        return document;\n    };\n    FragmentRegistry.prototype.findFragmentSpreads = function (root) {\n        var spreads = Object.create(null);\n        graphql.visit(root, {\n            FragmentSpread: function (node) {\n                spreads[node.name.value] = node;\n            },\n        });\n        return spreads;\n    };\n    return FragmentRegistry;\n}());\n\nexports.canonicalStringify = utilities.canonicalStringify;\nexports.isReference = utilities.isReference;\nexports.makeReference = utilities.makeReference;\nexports.ApolloCache = ApolloCache;\nexports.InMemoryCache = InMemoryCache;\nexports.MissingFieldError = MissingFieldError;\nexports.Policies = Policies;\nexports.cacheSlot = cacheSlot;\nexports.createFragmentRegistry = createFragmentRegistry;\nexports.defaultDataIdFromObject = defaultDataIdFromObject;\nexports.fieldNameFromStoreName = fieldNameFromStoreName;\nexports.makeVar = makeVar;\n//# sourceMappingURL=cache.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar globals = require('../utilities/globals');\nvar core = require('../link/core');\nvar http = require('../link/http');\nvar equal = require('@wry/equality');\nvar utilities = require('../utilities');\nvar cache = require('../cache');\nvar errors = require('../errors');\nvar optimism = require('optimism');\nvar trie = require('@wry/trie');\nvar masking = require('../masking');\nvar graphql = require('graphql');\nvar utils = require('../link/utils');\nvar tsInvariant = require('ts-invariant');\nvar graphqlTag = require('graphql-tag');\n\nfunction _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e[\"default\"] : e; }\n\nvar equal__default = /*#__PURE__*/_interopDefaultLegacy(equal);\n\nvar version = \"3.14.0\";\n\nfunction isNonNullObject(obj) {\n    return obj !== null && typeof obj === \"object\";\n}\n\nfunction isNonEmptyArray(value) {\n    return Array.isArray(value) && value.length > 0;\n}\n\nvar hasOwnProperty$2 = Object.prototype.hasOwnProperty;\nvar defaultReconciler = function (target, source, property) {\n    return this.merge(target[property], source[property]);\n};\nvar DeepMerger =  (function () {\n    function DeepMerger(reconciler) {\n        if (reconciler === void 0) { reconciler = defaultReconciler; }\n        this.reconciler = reconciler;\n        this.isObject = isNonNullObject;\n        this.pastCopies = new Set();\n    }\n    DeepMerger.prototype.merge = function (target, source) {\n        var _this = this;\n        var context = [];\n        for (var _i = 2; _i < arguments.length; _i++) {\n            context[_i - 2] = arguments[_i];\n        }\n        if (isNonNullObject(source) && isNonNullObject(target)) {\n            Object.keys(source).forEach(function (sourceKey) {\n                if (hasOwnProperty$2.call(target, sourceKey)) {\n                    var targetValue = target[sourceKey];\n                    if (source[sourceKey] !== targetValue) {\n                        var result = _this.reconciler.apply(_this, tslib.__spreadArray([target,\n                            source,\n                            sourceKey], context, false));\n                        if (result !== targetValue) {\n                            target = _this.shallowCopyForMerge(target);\n                            target[sourceKey] = result;\n                        }\n                    }\n                }\n                else {\n                    target = _this.shallowCopyForMerge(target);\n                    target[sourceKey] = source[sourceKey];\n                }\n            });\n            return target;\n        }\n        return source;\n    };\n    DeepMerger.prototype.shallowCopyForMerge = function (value) {\n        if (isNonNullObject(value)) {\n            if (!this.pastCopies.has(value)) {\n                if (Array.isArray(value)) {\n                    value = value.slice(0);\n                }\n                else {\n                    value = tslib.__assign({ __proto__: Object.getPrototypeOf(value) }, value);\n                }\n                this.pastCopies.add(value);\n            }\n        }\n        return value;\n    };\n    return DeepMerger;\n}());\n\nfunction isExecutionPatchIncrementalResult(value) {\n    return \"incremental\" in value;\n}\nfunction mergeIncrementalData(prevResult, result) {\n    var mergedData = prevResult;\n    var merger = new DeepMerger();\n    if (isExecutionPatchIncrementalResult(result) &&\n        isNonEmptyArray(result.incremental)) {\n        result.incremental.forEach(function (_a) {\n            var data = _a.data, path = _a.path;\n            for (var i = path.length - 1; i >= 0; --i) {\n                var key = path[i];\n                var isNumericKey = !isNaN(+key);\n                var parent_1 = isNumericKey ? [] : {};\n                parent_1[key] = data;\n                data = parent_1;\n            }\n            mergedData = merger.merge(mergedData, data);\n        });\n    }\n    return mergedData;\n}\n\nexports.NetworkStatus = void 0;\n(function (NetworkStatus) {\n    NetworkStatus[NetworkStatus[\"loading\"] = 1] = \"loading\";\n    NetworkStatus[NetworkStatus[\"setVariables\"] = 2] = \"setVariables\";\n    NetworkStatus[NetworkStatus[\"fetchMore\"] = 3] = \"fetchMore\";\n    NetworkStatus[NetworkStatus[\"refetch\"] = 4] = \"refetch\";\n    NetworkStatus[NetworkStatus[\"poll\"] = 6] = \"poll\";\n    NetworkStatus[NetworkStatus[\"ready\"] = 7] = \"ready\";\n    NetworkStatus[NetworkStatus[\"error\"] = 8] = \"error\";\n})(exports.NetworkStatus || (exports.NetworkStatus = {}));\nfunction isNetworkRequestInFlight(networkStatus) {\n    return networkStatus ? networkStatus < 7 : false;\n}\nfunction isNetworkRequestSettled(networkStatus) {\n    return networkStatus === 7 || networkStatus === 8;\n}\n\nfunction equalByQuery(query, _a, _b, variables) {\n    var aData = _a.data, aRest = tslib.__rest(_a, [\"data\"]);\n    var bData = _b.data, bRest = tslib.__rest(_b, [\"data\"]);\n    return (equal__default(aRest, bRest) &&\n        equalBySelectionSet(utilities.getMainDefinition(query).selectionSet, aData, bData, {\n            fragmentMap: utilities.createFragmentMap(utilities.getFragmentDefinitions(query)),\n            variables: variables,\n        }));\n}\nfunction equalBySelectionSet(selectionSet, aResult, bResult, context) {\n    if (aResult === bResult) {\n        return true;\n    }\n    var seenSelections = new Set();\n    return selectionSet.selections.every(function (selection) {\n        if (seenSelections.has(selection))\n            return true;\n        seenSelections.add(selection);\n        if (!utilities.shouldInclude(selection, context.variables))\n            return true;\n        if (selectionHasNonreactiveDirective(selection))\n            return true;\n        if (utilities.isField(selection)) {\n            var resultKey = utilities.resultKeyNameFromField(selection);\n            var aResultChild = aResult && aResult[resultKey];\n            var bResultChild = bResult && bResult[resultKey];\n            var childSelectionSet = selection.selectionSet;\n            if (!childSelectionSet) {\n                return equal__default(aResultChild, bResultChild);\n            }\n            var aChildIsArray = Array.isArray(aResultChild);\n            var bChildIsArray = Array.isArray(bResultChild);\n            if (aChildIsArray !== bChildIsArray)\n                return false;\n            if (aChildIsArray && bChildIsArray) {\n                var length_1 = aResultChild.length;\n                if (bResultChild.length !== length_1) {\n                    return false;\n                }\n                for (var i = 0; i < length_1; ++i) {\n                    if (!equalBySelectionSet(childSelectionSet, aResultChild[i], bResultChild[i], context)) {\n                        return false;\n                    }\n                }\n                return true;\n            }\n            return equalBySelectionSet(childSelectionSet, aResultChild, bResultChild, context);\n        }\n        else {\n            var fragment = utilities.getFragmentFromSelection(selection, context.fragmentMap);\n            if (fragment) {\n                if (selectionHasNonreactiveDirective(fragment))\n                    return true;\n                return equalBySelectionSet(fragment.selectionSet,\n                aResult, bResult, context);\n            }\n        }\n    });\n}\nfunction selectionHasNonreactiveDirective(selection) {\n    return (!!selection.directives && selection.directives.some(directiveIsNonreactive));\n}\nfunction directiveIsNonreactive(dir) {\n    return dir.name.value === \"nonreactive\";\n}\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\nfunction warnRemovedOption(options, name, callSite, recommendation) {\n    if (recommendation === void 0) { recommendation = \"Please remove this option.\"; }\n    warnDeprecated(name, function () {\n        if (name in options) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(104, callSite, name, recommendation);\n        }\n    });\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nvar assign = Object.assign, hasOwnProperty$1 = Object.hasOwnProperty;\nvar ObservableQuery =  (function (_super) {\n    tslib.__extends(ObservableQuery, _super);\n    function ObservableQuery(_a) {\n        var queryManager = _a.queryManager, queryInfo = _a.queryInfo, options = _a.options;\n        var _this = this;\n        var startedInactive = ObservableQuery.inactiveOnCreation.getValue();\n        _this = _super.call(this, function (observer) {\n            _this._getOrCreateQuery();\n            try {\n                var subObserver = observer._subscription._observer;\n                if (subObserver && !subObserver.error) {\n                    subObserver.error = defaultSubscriptionObserverErrorCallback;\n                }\n            }\n            catch (_a) { }\n            var first = !_this.observers.size;\n            _this.observers.add(observer);\n            var last = _this.last;\n            if (last && last.error) {\n                observer.error && observer.error(last.error);\n            }\n            else if (last && last.result) {\n                observer.next && observer.next(_this.maskResult(last.result));\n            }\n            if (first) {\n                _this.reobserve().catch(function () { });\n            }\n            return function () {\n                if (_this.observers.delete(observer) && !_this.observers.size) {\n                    _this.tearDownQuery();\n                }\n            };\n        }) || this;\n        _this.observers = new Set();\n        _this.subscriptions = new Set();\n        _this.dirty = false;\n        _this._getOrCreateQuery = function () {\n            if (startedInactive) {\n                queryManager[\"queries\"].set(_this.queryId, queryInfo);\n                startedInactive = false;\n            }\n            return _this.queryManager.getOrCreateQuery(_this.queryId);\n        };\n        _this.queryInfo = queryInfo;\n        _this.queryManager = queryManager;\n        _this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy);\n        _this.isTornDown = false;\n        _this.subscribeToMore = _this.subscribeToMore.bind(_this);\n        _this.maskResult = _this.maskResult.bind(_this);\n        var _b = queryManager.defaultOptions.watchQuery, _c = _b === void 0 ? {} : _b, _d = _c.fetchPolicy, defaultFetchPolicy = _d === void 0 ? \"cache-first\" : _d;\n        var _e = options.fetchPolicy, fetchPolicy = _e === void 0 ? defaultFetchPolicy : _e,\n        _f = options.initialFetchPolicy,\n        initialFetchPolicy = _f === void 0 ? fetchPolicy === \"standby\" ? defaultFetchPolicy : (fetchPolicy) : _f;\n        _this.options = tslib.__assign(tslib.__assign({}, options), {\n            initialFetchPolicy: initialFetchPolicy,\n            fetchPolicy: fetchPolicy });\n        _this.queryId = queryInfo.queryId || queryManager.generateQueryId();\n        var opDef = utilities.getOperationDefinition(_this.query);\n        _this.queryName = opDef && opDef.name && opDef.name.value;\n        return _this;\n    }\n    Object.defineProperty(ObservableQuery.prototype, \"query\", {\n        get: function () {\n            return this.lastQuery || this.options.query;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    Object.defineProperty(ObservableQuery.prototype, \"variables\", {\n        get: function () {\n            return this.options.variables;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ObservableQuery.prototype.result = function () {\n        var _this = this;\n        if (globalThis.__DEV__ !== false) {\n            warnDeprecated(\"observableQuery.result\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(23);\n            });\n        }\n        return new Promise(function (resolve, reject) {\n            var observer = {\n                next: function (result) {\n                    resolve(result);\n                    _this.observers.delete(observer);\n                    if (!_this.observers.size) {\n                        _this.queryManager.removeQuery(_this.queryId);\n                    }\n                    setTimeout(function () {\n                        subscription.unsubscribe();\n                    }, 0);\n                },\n                error: reject,\n            };\n            var subscription = _this.subscribe(observer);\n        });\n    };\n    ObservableQuery.prototype.resetDiff = function () {\n        this.queryInfo.resetDiff();\n    };\n    ObservableQuery.prototype.getCurrentFullResult = function (saveAsLastResult) {\n        var _this = this;\n        if (saveAsLastResult === void 0) { saveAsLastResult = true; }\n        var lastResult = muteDeprecations(\"getLastResult\", function () {\n            return _this.getLastResult(true);\n        });\n        var networkStatus = this.queryInfo.networkStatus ||\n            (lastResult && lastResult.networkStatus) ||\n            exports.NetworkStatus.ready;\n        var result = tslib.__assign(tslib.__assign({}, lastResult), { loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus });\n        var _a = this.options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a;\n        if (\n        skipCacheDataFor(fetchPolicy) ||\n            this.queryManager.getDocumentInfo(this.query).hasForcedResolvers) ;\n        else if (this.waitForOwnResult) {\n            this.queryInfo[\"updateWatch\"]();\n        }\n        else {\n            var diff = this.queryInfo.getDiff();\n            if (diff.complete || this.options.returnPartialData) {\n                result.data = diff.result;\n            }\n            if (equal.equal(result.data, {})) {\n                result.data = void 0;\n            }\n            if (diff.complete) {\n                delete result.partial;\n                if (diff.complete &&\n                    result.networkStatus === exports.NetworkStatus.loading &&\n                    (fetchPolicy === \"cache-first\" || fetchPolicy === \"cache-only\")) {\n                    result.networkStatus = exports.NetworkStatus.ready;\n                    result.loading = false;\n                }\n            }\n            else {\n                result.partial = true;\n            }\n            if (result.networkStatus === exports.NetworkStatus.ready &&\n                (result.error || result.errors)) {\n                result.networkStatus = exports.NetworkStatus.error;\n            }\n            if (globalThis.__DEV__ !== false &&\n                !diff.complete &&\n                !this.options.partialRefetch &&\n                !result.loading &&\n                !result.data &&\n                !result.error) {\n                logMissingFieldErrors(diff.missing);\n            }\n        }\n        if (saveAsLastResult) {\n            this.updateLastResult(result);\n        }\n        return result;\n    };\n    ObservableQuery.prototype.getCurrentResult = function (saveAsLastResult) {\n        if (saveAsLastResult === void 0) { saveAsLastResult = true; }\n        return this.maskResult(this.getCurrentFullResult(saveAsLastResult));\n    };\n    ObservableQuery.prototype.isDifferentFromLastResult = function (newResult, variables) {\n        if (!this.last) {\n            return true;\n        }\n        var documentInfo = this.queryManager.getDocumentInfo(this.query);\n        var dataMasking = this.queryManager.dataMasking;\n        var query = dataMasking ? documentInfo.nonReactiveQuery : this.query;\n        var resultIsDifferent = dataMasking || documentInfo.hasNonreactiveDirective ?\n            !equalByQuery(query, this.last.result, newResult, this.variables)\n            : !equal.equal(this.last.result, newResult);\n        return (resultIsDifferent || (variables && !equal.equal(this.last.variables, variables)));\n    };\n    ObservableQuery.prototype.getLast = function (key, variablesMustMatch) {\n        var last = this.last;\n        if (last &&\n            last[key] &&\n            (!variablesMustMatch || equal.equal(last.variables, this.variables))) {\n            return last[key];\n        }\n    };\n    ObservableQuery.prototype.getLastResult = function (variablesMustMatch) {\n        if (globalThis.__DEV__ !== false) {\n            warnDeprecated(\"getLastResult\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(24);\n            });\n        }\n        return this.getLast(\"result\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.getLastError = function (variablesMustMatch) {\n        if (globalThis.__DEV__ !== false) {\n            warnDeprecated(\"getLastError\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(25);\n            });\n        }\n        return this.getLast(\"error\", variablesMustMatch);\n    };\n    ObservableQuery.prototype.resetLastResults = function () {\n        if (globalThis.__DEV__ !== false) {\n            warnDeprecated(\"resetLastResults\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(26);\n            });\n        }\n        delete this.last;\n        this.isTornDown = false;\n    };\n    ObservableQuery.prototype.resetQueryStoreErrors = function () {\n        if (globalThis.__DEV__ !== false) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(27);\n        }\n        this.queryManager.resetErrors(this.queryId);\n    };\n    ObservableQuery.prototype.refetch = function (variables) {\n        var _a;\n        var reobserveOptions = {\n            pollInterval: 0,\n        };\n        var fetchPolicy = this.options.fetchPolicy;\n        if (fetchPolicy === \"no-cache\") {\n            reobserveOptions.fetchPolicy = \"no-cache\";\n        }\n        else {\n            reobserveOptions.fetchPolicy = \"network-only\";\n        }\n        if (globalThis.__DEV__ !== false && variables && hasOwnProperty$1.call(variables, \"variables\")) {\n            var queryDef = utilities.getQueryDefinition(this.query);\n            var vars = queryDef.variableDefinitions;\n            if (!vars || !vars.some(function (v) { return v.variable.name.value === \"variables\"; })) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(\n                    28,\n                    variables,\n                    ((_a = queryDef.name) === null || _a === void 0 ? void 0 : _a.value) || queryDef\n                );\n            }\n        }\n        if (variables && !equal.equal(this.options.variables, variables)) {\n            reobserveOptions.variables = this.options.variables = tslib.__assign(tslib.__assign({}, this.options.variables), variables);\n        }\n        this.queryInfo.resetLastWrite();\n        return this.reobserve(reobserveOptions, exports.NetworkStatus.refetch);\n    };\n    ObservableQuery.prototype.fetchMore = function (fetchMoreOptions) {\n        var _this = this;\n        var combinedOptions = tslib.__assign(tslib.__assign({}, (fetchMoreOptions.query ? fetchMoreOptions : (tslib.__assign(tslib.__assign(tslib.__assign(tslib.__assign({}, this.options), { query: this.options.query }), fetchMoreOptions), { variables: tslib.__assign(tslib.__assign({}, this.options.variables), fetchMoreOptions.variables) })))), {\n            fetchPolicy: \"no-cache\" });\n        combinedOptions.query = this.transformDocument(combinedOptions.query);\n        var qid = this.queryManager.generateQueryId();\n        this.lastQuery =\n            fetchMoreOptions.query ?\n                this.transformDocument(this.options.query)\n                : combinedOptions.query;\n        var queryInfo = this.queryInfo;\n        var originalNetworkStatus = queryInfo.networkStatus;\n        queryInfo.networkStatus = exports.NetworkStatus.fetchMore;\n        if (combinedOptions.notifyOnNetworkStatusChange) {\n            this.observe();\n        }\n        var updatedQuerySet = new Set();\n        var updateQuery = fetchMoreOptions === null || fetchMoreOptions === void 0 ? void 0 : fetchMoreOptions.updateQuery;\n        var isCached = this.options.fetchPolicy !== \"no-cache\";\n        if (!isCached) {\n            globals.invariant(updateQuery, 29);\n        }\n        return this.queryManager\n            .fetchQuery(qid, combinedOptions, exports.NetworkStatus.fetchMore)\n            .then(function (fetchMoreResult) {\n            _this.queryManager.removeQuery(qid);\n            if (queryInfo.networkStatus === exports.NetworkStatus.fetchMore) {\n                queryInfo.networkStatus = originalNetworkStatus;\n            }\n            if (isCached) {\n                _this.queryManager.cache.batch({\n                    update: function (cache) {\n                        var updateQuery = fetchMoreOptions.updateQuery;\n                        if (updateQuery) {\n                            cache.updateQuery({\n                                query: _this.query,\n                                variables: _this.variables,\n                                returnPartialData: true,\n                                optimistic: false,\n                            }, function (previous) {\n                                return updateQuery(previous, {\n                                    fetchMoreResult: fetchMoreResult.data,\n                                    variables: combinedOptions.variables,\n                                });\n                            });\n                        }\n                        else {\n                            cache.writeQuery({\n                                query: combinedOptions.query,\n                                variables: combinedOptions.variables,\n                                data: fetchMoreResult.data,\n                            });\n                        }\n                    },\n                    onWatchUpdated: function (watch) {\n                        updatedQuerySet.add(watch.query);\n                    },\n                });\n            }\n            else {\n                var lastResult = _this.getLast(\"result\");\n                var data = updateQuery(lastResult.data, {\n                    fetchMoreResult: fetchMoreResult.data,\n                    variables: combinedOptions.variables,\n                });\n                _this.reportResult(tslib.__assign(tslib.__assign({}, lastResult), { networkStatus: originalNetworkStatus, loading: isNetworkRequestInFlight(originalNetworkStatus), data: data }), _this.variables);\n            }\n            return _this.maskResult(fetchMoreResult);\n        })\n            .finally(function () {\n            if (isCached && !updatedQuerySet.has(_this.query)) {\n                _this.reobserveCacheFirst();\n            }\n        });\n    };\n    ObservableQuery.prototype.subscribeToMore = function (options) {\n        var _this = this;\n        var subscription = this.queryManager\n            .startGraphQLSubscription({\n            query: options.document,\n            variables: options.variables,\n            context: options.context,\n        })\n            .subscribe({\n            next: function (subscriptionData) {\n                var updateQuery = options.updateQuery;\n                if (updateQuery) {\n                    _this.updateQuery(function (previous, updateOptions) {\n                        return updateQuery(previous, tslib.__assign({ subscriptionData: subscriptionData }, updateOptions));\n                    });\n                }\n            },\n            error: function (err) {\n                if (options.onError) {\n                    options.onError(err);\n                    return;\n                }\n                globalThis.__DEV__ !== false && globals.invariant.error(30, err);\n            },\n        });\n        this.subscriptions.add(subscription);\n        return function () {\n            if (_this.subscriptions.delete(subscription)) {\n                subscription.unsubscribe();\n            }\n        };\n    };\n    ObservableQuery.prototype.setOptions = function (newOptions) {\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(newOptions, \"canonizeResults\", \"setOptions\");\n            warnDeprecated(\"setOptions\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(31);\n            });\n        }\n        return this.reobserve(newOptions);\n    };\n    ObservableQuery.prototype.silentSetOptions = function (newOptions) {\n        var mergedOptions = utilities.compact(this.options, newOptions || {});\n        assign(this.options, mergedOptions);\n    };\n    ObservableQuery.prototype.setVariables = function (variables) {\n        var _this = this;\n        if (equal.equal(this.variables, variables)) {\n            return this.observers.size ?\n                muteDeprecations(\"observableQuery.result\", function () { return _this.result(); })\n                : Promise.resolve();\n        }\n        this.options.variables = variables;\n        if (!this.observers.size) {\n            return Promise.resolve();\n        }\n        return this.reobserve({\n            fetchPolicy: this.options.initialFetchPolicy,\n            variables: variables,\n        }, exports.NetworkStatus.setVariables);\n    };\n    ObservableQuery.prototype.updateQuery = function (mapFn) {\n        var queryManager = this.queryManager;\n        var _a = queryManager.cache.diff({\n            query: this.options.query,\n            variables: this.variables,\n            returnPartialData: true,\n            optimistic: false,\n        }), result = _a.result, complete = _a.complete;\n        var newResult = mapFn(result, {\n            variables: this.variables,\n            complete: !!complete,\n            previousData: result,\n        });\n        if (newResult) {\n            queryManager.cache.writeQuery({\n                query: this.options.query,\n                data: newResult,\n                variables: this.variables,\n            });\n            queryManager.broadcastQueries();\n        }\n    };\n    ObservableQuery.prototype.startPolling = function (pollInterval) {\n        this.options.pollInterval = pollInterval;\n        this.updatePolling();\n    };\n    ObservableQuery.prototype.stopPolling = function () {\n        this.options.pollInterval = 0;\n        this.updatePolling();\n    };\n    ObservableQuery.prototype.applyNextFetchPolicy = function (reason,\n    options) {\n        if (options.nextFetchPolicy) {\n            var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? \"cache-first\" : _a, _b = options.initialFetchPolicy, initialFetchPolicy = _b === void 0 ? fetchPolicy : _b;\n            if (fetchPolicy === \"standby\") ;\n            else if (typeof options.nextFetchPolicy === \"function\") {\n                options.fetchPolicy = options.nextFetchPolicy(fetchPolicy, {\n                    reason: reason,\n                    options: options,\n                    observable: this,\n                    initialFetchPolicy: initialFetchPolicy,\n                });\n            }\n            else if (reason === \"variables-changed\") {\n                options.fetchPolicy = initialFetchPolicy;\n            }\n            else {\n                options.fetchPolicy = options.nextFetchPolicy;\n            }\n        }\n        return options.fetchPolicy;\n    };\n    ObservableQuery.prototype.fetch = function (options, newNetworkStatus, query) {\n        var queryInfo = this._getOrCreateQuery();\n        queryInfo.setObservableQuery(this);\n        return this.queryManager[\"fetchConcastWithInfo\"](queryInfo, options, newNetworkStatus, query);\n    };\n    ObservableQuery.prototype.updatePolling = function () {\n        var _this = this;\n        if (this.queryManager.ssrMode) {\n            return;\n        }\n        var _a = this, pollingInfo = _a.pollingInfo, pollInterval = _a.options.pollInterval;\n        if (!pollInterval || !this.hasObservers()) {\n            if (pollingInfo) {\n                clearTimeout(pollingInfo.timeout);\n                delete this.pollingInfo;\n            }\n            return;\n        }\n        if (pollingInfo && pollingInfo.interval === pollInterval) {\n            return;\n        }\n        globals.invariant(pollInterval, 32);\n        var info = pollingInfo || (this.pollingInfo = {});\n        info.interval = pollInterval;\n        var maybeFetch = function () {\n            var _a, _b;\n            if (_this.pollingInfo) {\n                if (!isNetworkRequestInFlight(_this.queryInfo.networkStatus) &&\n                    !((_b = (_a = _this.options).skipPollAttempt) === null || _b === void 0 ? void 0 : _b.call(_a))) {\n                    _this.reobserve({\n                        fetchPolicy: _this.options.initialFetchPolicy === \"no-cache\" ?\n                            \"no-cache\"\n                            : \"network-only\",\n                    }, exports.NetworkStatus.poll).then(poll, poll);\n                }\n                else {\n                    poll();\n                }\n            }\n        };\n        var poll = function () {\n            var info = _this.pollingInfo;\n            if (info) {\n                clearTimeout(info.timeout);\n                info.timeout = setTimeout(maybeFetch, info.interval);\n            }\n        };\n        poll();\n    };\n    ObservableQuery.prototype.updateLastResult = function (newResult, variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var error = muteDeprecations(\"getLastError\", function () {\n            return _this.getLastError();\n        });\n        if (error && this.last && !equal.equal(variables, this.last.variables)) {\n            error = void 0;\n        }\n        return (this.last = tslib.__assign({ result: this.queryManager.assumeImmutableResults ?\n                newResult\n                : utilities.cloneDeep(newResult), variables: variables }, (error ? { error: error } : null)));\n    };\n    ObservableQuery.prototype.reobserveAsConcast = function (newOptions, newNetworkStatus) {\n        var _this = this;\n        this.isTornDown = false;\n        var useDisposableConcast =\n        newNetworkStatus === exports.NetworkStatus.refetch ||\n            newNetworkStatus === exports.NetworkStatus.fetchMore ||\n            newNetworkStatus === exports.NetworkStatus.poll;\n        var oldVariables = this.options.variables;\n        var oldFetchPolicy = this.options.fetchPolicy;\n        var mergedOptions = utilities.compact(this.options, newOptions || {});\n        var options = useDisposableConcast ?\n            mergedOptions\n            : assign(this.options, mergedOptions);\n        var query = this.transformDocument(options.query);\n        this.lastQuery = query;\n        if (!useDisposableConcast) {\n            this.updatePolling();\n            if (newOptions &&\n                newOptions.variables &&\n                !equal.equal(newOptions.variables, oldVariables) &&\n                options.fetchPolicy !== \"standby\" &&\n                (options.fetchPolicy === oldFetchPolicy ||\n                    typeof options.nextFetchPolicy === \"function\")) {\n                this.applyNextFetchPolicy(\"variables-changed\", options);\n                if (newNetworkStatus === void 0) {\n                    newNetworkStatus = exports.NetworkStatus.setVariables;\n                }\n            }\n        }\n        this.waitForOwnResult && (this.waitForOwnResult = skipCacheDataFor(options.fetchPolicy));\n        var finishWaitingForOwnResult = function () {\n            if (_this.concast === concast) {\n                _this.waitForOwnResult = false;\n            }\n        };\n        var variables = options.variables && tslib.__assign({}, options.variables);\n        var _a = this.fetch(options, newNetworkStatus, query), concast = _a.concast, fromLink = _a.fromLink;\n        var observer = {\n            next: function (result) {\n                if (equal.equal(_this.variables, variables)) {\n                    finishWaitingForOwnResult();\n                    _this.reportResult(result, variables);\n                }\n            },\n            error: function (error) {\n                if (equal.equal(_this.variables, variables)) {\n                    if (!errors.isApolloError(error)) {\n                        error = new errors.ApolloError({ networkError: error });\n                    }\n                    finishWaitingForOwnResult();\n                    _this.reportError(error, variables);\n                }\n            },\n        };\n        if (!useDisposableConcast && (fromLink || !this.concast)) {\n            if (this.concast && this.observer) {\n                this.concast.removeObserver(this.observer);\n            }\n            this.concast = concast;\n            this.observer = observer;\n        }\n        concast.addObserver(observer);\n        return concast;\n    };\n    ObservableQuery.prototype.reobserve = function (newOptions, newNetworkStatus) {\n        return utilities.preventUnhandledRejection(this.reobserveAsConcast(newOptions, newNetworkStatus).promise.then(this.maskResult));\n    };\n    ObservableQuery.prototype.resubscribeAfterError = function () {\n        var _this = this;\n        var args = [];\n        for (var _i = 0; _i < arguments.length; _i++) {\n            args[_i] = arguments[_i];\n        }\n        var last = this.last;\n        muteDeprecations(\"resetLastResults\", function () { return _this.resetLastResults(); });\n        var subscription = this.subscribe.apply(this, args);\n        this.last = last;\n        return subscription;\n    };\n    ObservableQuery.prototype.observe = function () {\n        this.reportResult(\n        this.getCurrentFullResult(false), this.variables);\n    };\n    ObservableQuery.prototype.reportResult = function (result, variables) {\n        var _this = this;\n        var lastError = muteDeprecations(\"getLastError\", function () {\n            return _this.getLastError();\n        });\n        var isDifferent = this.isDifferentFromLastResult(result, variables);\n        if (lastError || !result.partial || this.options.returnPartialData) {\n            this.updateLastResult(result, variables);\n        }\n        if (lastError || isDifferent) {\n            utilities.iterateObserversSafely(this.observers, \"next\", this.maskResult(result));\n        }\n    };\n    ObservableQuery.prototype.reportError = function (error, variables) {\n        var _this = this;\n        var errorResult = tslib.__assign(tslib.__assign({}, muteDeprecations(\"getLastResult\", function () { return _this.getLastResult(); })), { error: error, errors: error.graphQLErrors, networkStatus: exports.NetworkStatus.error, loading: false });\n        this.updateLastResult(errorResult, variables);\n        utilities.iterateObserversSafely(this.observers, \"error\", (this.last.error = error));\n    };\n    ObservableQuery.prototype.hasObservers = function () {\n        return this.observers.size > 0;\n    };\n    ObservableQuery.prototype.tearDownQuery = function () {\n        if (this.isTornDown)\n            return;\n        if (this.concast && this.observer) {\n            this.concast.removeObserver(this.observer);\n            delete this.concast;\n            delete this.observer;\n        }\n        this.stopPolling();\n        this.subscriptions.forEach(function (sub) { return sub.unsubscribe(); });\n        this.subscriptions.clear();\n        this.queryManager.stopQuery(this.queryId);\n        this.observers.clear();\n        this.isTornDown = true;\n    };\n    ObservableQuery.prototype.transformDocument = function (document) {\n        return this.queryManager.transform(document);\n    };\n    ObservableQuery.prototype.maskResult = function (result) {\n        return result && \"data\" in result ? tslib.__assign(tslib.__assign({}, result), { data: this.queryManager.maskOperation({\n                document: this.query,\n                data: result.data,\n                fetchPolicy: this.options.fetchPolicy,\n                id: this.queryId,\n            }) }) : result;\n    };\n    ObservableQuery.prototype.resetNotifications = function () {\n        this.cancelNotifyTimeout();\n        this.dirty = false;\n    };\n    ObservableQuery.prototype.cancelNotifyTimeout = function () {\n        if (this.notifyTimeout) {\n            clearTimeout(this.notifyTimeout);\n            this.notifyTimeout = void 0;\n        }\n    };\n    ObservableQuery.prototype.scheduleNotify = function () {\n        var _this = this;\n        if (this.dirty)\n            return;\n        this.dirty = true;\n        if (!this.notifyTimeout) {\n            this.notifyTimeout = setTimeout(function () { return _this.notify(); }, 0);\n        }\n    };\n    ObservableQuery.prototype.notify = function () {\n        this.cancelNotifyTimeout();\n        if (this.dirty) {\n            if (this.options.fetchPolicy == \"cache-only\" ||\n                this.options.fetchPolicy == \"cache-and-network\" ||\n                !isNetworkRequestInFlight(this.queryInfo.networkStatus)) {\n                var diff = this.queryInfo.getDiff();\n                if (diff.fromOptimisticTransaction) {\n                    this.observe();\n                }\n                else {\n                    this.reobserveCacheFirst();\n                }\n            }\n        }\n        this.dirty = false;\n    };\n    ObservableQuery.prototype.reobserveCacheFirst = function () {\n        var _a = this.options, fetchPolicy = _a.fetchPolicy, nextFetchPolicy = _a.nextFetchPolicy;\n        if (fetchPolicy === \"cache-and-network\" || fetchPolicy === \"network-only\") {\n            return this.reobserve({\n                fetchPolicy: \"cache-first\",\n                nextFetchPolicy: function (currentFetchPolicy, context) {\n                    this.nextFetchPolicy = nextFetchPolicy;\n                    if (typeof this.nextFetchPolicy === \"function\") {\n                        return this.nextFetchPolicy(currentFetchPolicy, context);\n                    }\n                    return fetchPolicy;\n                },\n            });\n        }\n        return this.reobserve();\n    };\n    ObservableQuery.inactiveOnCreation = new optimism.Slot();\n    return ObservableQuery;\n}(utilities.Observable));\nutilities.fixObservableSubclass(ObservableQuery);\nfunction defaultSubscriptionObserverErrorCallback(error) {\n    globalThis.__DEV__ !== false && globals.invariant.error(33, error.message, error.stack);\n}\nfunction logMissingFieldErrors(missing) {\n    if (globalThis.__DEV__ !== false && missing) {\n        globalThis.__DEV__ !== false && globals.invariant.debug(34, missing);\n    }\n}\nfunction skipCacheDataFor(fetchPolicy ) {\n    return (fetchPolicy === \"network-only\" ||\n        fetchPolicy === \"no-cache\" ||\n        fetchPolicy === \"standby\");\n}\n\nvar destructiveMethodCounts = new (utilities.canUseWeakMap ? WeakMap : Map)();\nfunction wrapDestructiveCacheMethod(cache, methodName) {\n    var original = cache[methodName];\n    if (typeof original === \"function\") {\n        cache[methodName] = function () {\n            destructiveMethodCounts.set(cache,\n            (destructiveMethodCounts.get(cache) + 1) % 1e15);\n            return original.apply(this, arguments);\n        };\n    }\n}\nvar QueryInfo =  (function () {\n    function QueryInfo(queryManager, queryId) {\n        if (queryId === void 0) { queryId = queryManager.generateQueryId(); }\n        this.queryId = queryId;\n        this.document = null;\n        this.lastRequestId = 1;\n        this.stopped = false;\n        this.observableQuery = null;\n        var cache = (this.cache = queryManager.cache);\n        if (!destructiveMethodCounts.has(cache)) {\n            destructiveMethodCounts.set(cache, 0);\n            wrapDestructiveCacheMethod(cache, \"evict\");\n            wrapDestructiveCacheMethod(cache, \"modify\");\n            wrapDestructiveCacheMethod(cache, \"reset\");\n        }\n    }\n    QueryInfo.prototype.init = function (query) {\n        var networkStatus = query.networkStatus || exports.NetworkStatus.loading;\n        if (this.variables &&\n            this.networkStatus !== exports.NetworkStatus.loading &&\n            !equal.equal(this.variables, query.variables)) {\n            networkStatus = exports.NetworkStatus.setVariables;\n        }\n        if (!equal.equal(query.variables, this.variables)) {\n            this.lastDiff = void 0;\n            this.cancel();\n        }\n        Object.assign(this, {\n            document: query.document,\n            variables: query.variables,\n            networkError: null,\n            graphQLErrors: this.graphQLErrors || [],\n            networkStatus: networkStatus,\n        });\n        if (query.observableQuery) {\n            this.setObservableQuery(query.observableQuery);\n        }\n        if (query.lastRequestId) {\n            this.lastRequestId = query.lastRequestId;\n        }\n        return this;\n    };\n    QueryInfo.prototype.resetDiff = function () {\n        this.lastDiff = void 0;\n    };\n    QueryInfo.prototype.getDiff = function () {\n        var _this = this;\n        var options = this.getDiffOptions();\n        if (this.lastDiff && equal.equal(options, this.lastDiff.options)) {\n            return this.lastDiff.diff;\n        }\n        this.updateWatch(this.variables);\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return { complete: false };\n        }\n        var diff = muteDeprecations(\"canonizeResults\", function () {\n            return _this.cache.diff(options);\n        });\n        this.updateLastDiff(diff, options);\n        return diff;\n    };\n    QueryInfo.prototype.updateLastDiff = function (diff, options) {\n        this.lastDiff =\n            diff ?\n                {\n                    diff: diff,\n                    options: options || this.getDiffOptions(),\n                }\n                : void 0;\n    };\n    QueryInfo.prototype.getDiffOptions = function (variables) {\n        var _a;\n        if (variables === void 0) { variables = this.variables; }\n        return {\n            query: this.document,\n            variables: variables,\n            returnPartialData: true,\n            optimistic: true,\n            canonizeResults: (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a.options.canonizeResults,\n        };\n    };\n    QueryInfo.prototype.setDiff = function (diff) {\n        var _this = this;\n        var _a;\n        var oldDiff = this.lastDiff && this.lastDiff.diff;\n        if (diff &&\n            !diff.complete &&\n            muteDeprecations(\"getLastError\", function () { var _a; return (_a = _this.observableQuery) === null || _a === void 0 ? void 0 : _a.getLastError(); })) {\n            return;\n        }\n        this.updateLastDiff(diff);\n        if (!equal.equal(oldDiff && oldDiff.result, diff && diff.result)) {\n            (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a[\"scheduleNotify\"]();\n        }\n    };\n    QueryInfo.prototype.setObservableQuery = function (oq) {\n        if (oq === this.observableQuery)\n            return;\n        this.observableQuery = oq;\n        if (oq) {\n            oq[\"queryInfo\"] = this;\n        }\n    };\n    QueryInfo.prototype.stop = function () {\n        var _a;\n        if (!this.stopped) {\n            this.stopped = true;\n            (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a[\"resetNotifications\"]();\n            this.cancel();\n            var oq = this.observableQuery;\n            if (oq)\n                oq.stopPolling();\n        }\n    };\n    QueryInfo.prototype.cancel = function () {\n        var _a;\n        (_a = this.cancelWatch) === null || _a === void 0 ? void 0 : _a.call(this);\n        this.cancelWatch = void 0;\n    };\n    QueryInfo.prototype.updateWatch = function (variables) {\n        var _this = this;\n        if (variables === void 0) { variables = this.variables; }\n        var oq = this.observableQuery;\n        if (oq && oq.options.fetchPolicy === \"no-cache\") {\n            return;\n        }\n        var watchOptions = tslib.__assign(tslib.__assign({}, this.getDiffOptions(variables)), { watcher: this, callback: function (diff) { return _this.setDiff(diff); } });\n        if (!this.lastWatch || !equal.equal(watchOptions, this.lastWatch)) {\n            this.cancel();\n            this.cancelWatch = this.cache.watch((this.lastWatch = watchOptions));\n        }\n    };\n    QueryInfo.prototype.resetLastWrite = function () {\n        this.lastWrite = void 0;\n    };\n    QueryInfo.prototype.shouldWrite = function (result, variables) {\n        var lastWrite = this.lastWrite;\n        return !(lastWrite &&\n            lastWrite.dmCount === destructiveMethodCounts.get(this.cache) &&\n            equal.equal(variables, lastWrite.variables) &&\n            equal.equal(result.data, lastWrite.result.data));\n    };\n    QueryInfo.prototype.markResult = function (result, document, options, cacheWriteBehavior) {\n        var _this = this;\n        var _a;\n        var merger = new utilities.DeepMerger();\n        var graphQLErrors = utilities.isNonEmptyArray(result.errors) ? result.errors.slice(0) : [];\n        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a[\"resetNotifications\"]();\n        if (\"incremental\" in result && utilities.isNonEmptyArray(result.incremental)) {\n            var mergedData = utilities.mergeIncrementalData(this.getDiff().result, result);\n            result.data = mergedData;\n        }\n        else if (\"hasNext\" in result && result.hasNext) {\n            var diff = this.getDiff();\n            result.data = merger.merge(diff.result, result.data);\n        }\n        this.graphQLErrors = graphQLErrors;\n        if (options.fetchPolicy === \"no-cache\") {\n            this.updateLastDiff({ result: result.data, complete: true }, this.getDiffOptions(options.variables));\n        }\n        else if (cacheWriteBehavior !== 0 ) {\n            if (shouldWriteResult(result, options.errorPolicy)) {\n                this.cache.performTransaction(function (cache) {\n                    if (_this.shouldWrite(result, options.variables)) {\n                        cache.writeQuery({\n                            query: document,\n                            data: result.data,\n                            variables: options.variables,\n                            overwrite: cacheWriteBehavior === 1 ,\n                        });\n                        _this.lastWrite = {\n                            result: result,\n                            variables: options.variables,\n                            dmCount: destructiveMethodCounts.get(_this.cache),\n                        };\n                    }\n                    else {\n                        if (_this.lastDiff && _this.lastDiff.diff.complete) {\n                            result.data = _this.lastDiff.diff.result;\n                            return;\n                        }\n                    }\n                    var diffOptions = _this.getDiffOptions(options.variables);\n                    var diff = muteDeprecations(\"canonizeResults\", function () {\n                        return cache.diff(diffOptions);\n                    });\n                    if (!_this.stopped && equal.equal(_this.variables, options.variables)) {\n                        _this.updateWatch(options.variables);\n                    }\n                    _this.updateLastDiff(diff, diffOptions);\n                    if (diff.complete) {\n                        result.data = diff.result;\n                    }\n                });\n            }\n            else {\n                this.lastWrite = void 0;\n            }\n        }\n    };\n    QueryInfo.prototype.markReady = function () {\n        this.networkError = null;\n        return (this.networkStatus = exports.NetworkStatus.ready);\n    };\n    QueryInfo.prototype.markError = function (error) {\n        var _a;\n        this.networkStatus = exports.NetworkStatus.error;\n        this.lastWrite = void 0;\n        (_a = this.observableQuery) === null || _a === void 0 ? void 0 : _a[\"resetNotifications\"]();\n        if (error.graphQLErrors) {\n            this.graphQLErrors = error.graphQLErrors;\n        }\n        if (error.networkError) {\n            this.networkError = error.networkError;\n        }\n        return error;\n    };\n    return QueryInfo;\n}());\nfunction shouldWriteResult(result, errorPolicy) {\n    if (errorPolicy === void 0) { errorPolicy = \"none\"; }\n    var ignoreErrors = errorPolicy === \"ignore\" || errorPolicy === \"all\";\n    var writeWithErrors = !utilities.graphQLResultHasError(result);\n    if (!writeWithErrors && ignoreErrors && result.data) {\n        writeWithErrors = true;\n    }\n    return writeWithErrors;\n}\n\nvar hasOwnProperty = Object.prototype.hasOwnProperty;\nvar IGNORE = Object.create(null);\nvar QueryManager =  (function () {\n    function QueryManager(options) {\n        var _this = this;\n        this.clientAwareness = {};\n        this.queries = new Map();\n        this.fetchCancelFns = new Map();\n        this.transformCache = new utilities.AutoCleanedWeakCache(utilities.cacheSizes[\"queryManager.getDocumentInfo\"] ||\n            2000 );\n        this.queryIdCounter = 1;\n        this.requestIdCounter = 1;\n        this.mutationIdCounter = 1;\n        this.inFlightLinkObservables = new trie.Trie(false);\n        this.noCacheWarningsByQueryId = new Set();\n        var defaultDocumentTransform = new utilities.DocumentTransform(function (document) { return _this.cache.transformDocument(document); },\n        { cache: false });\n        this.cache = options.cache;\n        this.link = options.link;\n        this.defaultOptions = options.defaultOptions;\n        this.queryDeduplication = options.queryDeduplication;\n        this.clientAwareness = options.clientAwareness;\n        this.localState = options.localState;\n        this.ssrMode = options.ssrMode;\n        this.assumeImmutableResults = options.assumeImmutableResults;\n        this.dataMasking = options.dataMasking;\n        var documentTransform = options.documentTransform;\n        this.documentTransform =\n            documentTransform ?\n                defaultDocumentTransform\n                    .concat(documentTransform)\n                    .concat(defaultDocumentTransform)\n                : defaultDocumentTransform;\n        this.defaultContext = options.defaultContext || Object.create(null);\n        if ((this.onBroadcast = options.onBroadcast)) {\n            this.mutationStore = Object.create(null);\n        }\n    }\n    QueryManager.prototype.stop = function () {\n        var _this = this;\n        this.queries.forEach(function (_info, queryId) {\n            _this.stopQueryNoBroadcast(queryId);\n        });\n        this.cancelPendingFetches(globals.newInvariantError(35));\n    };\n    QueryManager.prototype.cancelPendingFetches = function (error) {\n        this.fetchCancelFns.forEach(function (cancel) { return cancel(error); });\n        this.fetchCancelFns.clear();\n    };\n    QueryManager.prototype.mutate = function (_a) {\n        return tslib.__awaiter(this, arguments, void 0, function (_b) {\n            var mutationId, hasClientExports, mutationStoreValue, isOptimistic, self;\n            var _c, _d;\n            var mutation = _b.mutation, variables = _b.variables, optimisticResponse = _b.optimisticResponse, updateQueries = _b.updateQueries, _e = _b.refetchQueries, refetchQueries = _e === void 0 ? [] : _e, _f = _b.awaitRefetchQueries, awaitRefetchQueries = _f === void 0 ? false : _f, updateWithProxyFn = _b.update, onQueryUpdated = _b.onQueryUpdated, _g = _b.fetchPolicy, fetchPolicy = _g === void 0 ? ((_c = this.defaultOptions.mutate) === null || _c === void 0 ? void 0 : _c.fetchPolicy) || \"network-only\" : _g, _h = _b.errorPolicy, errorPolicy = _h === void 0 ? ((_d = this.defaultOptions.mutate) === null || _d === void 0 ? void 0 : _d.errorPolicy) || \"none\" : _h, keepRootFields = _b.keepRootFields, context = _b.context;\n            return tslib.__generator(this, function (_j) {\n                switch (_j.label) {\n                    case 0:\n                        globals.invariant(mutation, 36);\n                        globals.invariant(fetchPolicy === \"network-only\" || fetchPolicy === \"no-cache\", 37);\n                        mutationId = this.generateMutationId();\n                        mutation = this.cache.transformForLink(this.transform(mutation));\n                        hasClientExports = this.getDocumentInfo(mutation).hasClientExports;\n                        variables = this.getVariables(mutation, variables);\n                        if (!hasClientExports) return [3 , 2];\n                        return [4 , this.localState.addExportedVariables(mutation, variables, context)];\n                    case 1:\n                        variables = (_j.sent());\n                        _j.label = 2;\n                    case 2:\n                        mutationStoreValue = this.mutationStore &&\n                            (this.mutationStore[mutationId] = {\n                                mutation: mutation,\n                                variables: variables,\n                                loading: true,\n                                error: null,\n                            });\n                        isOptimistic = optimisticResponse &&\n                            this.markMutationOptimistic(optimisticResponse, {\n                                mutationId: mutationId,\n                                document: mutation,\n                                variables: variables,\n                                fetchPolicy: fetchPolicy,\n                                errorPolicy: errorPolicy,\n                                context: context,\n                                updateQueries: updateQueries,\n                                update: updateWithProxyFn,\n                                keepRootFields: keepRootFields,\n                            });\n                        this.broadcastQueries();\n                        self = this;\n                        return [2 , new Promise(function (resolve, reject) {\n                                return utilities.asyncMap(self.getObservableFromLink(mutation, tslib.__assign(tslib.__assign({}, context), { optimisticResponse: isOptimistic ? optimisticResponse : void 0 }), variables, {}, false), function (result) {\n                                    if (utilities.graphQLResultHasError(result) && errorPolicy === \"none\") {\n                                        throw new errors.ApolloError({\n                                            graphQLErrors: utilities.getGraphQLErrorsFromResult(result),\n                                        });\n                                    }\n                                    if (mutationStoreValue) {\n                                        mutationStoreValue.loading = false;\n                                        mutationStoreValue.error = null;\n                                    }\n                                    var storeResult = tslib.__assign({}, result);\n                                    if (typeof refetchQueries === \"function\") {\n                                        refetchQueries = refetchQueries(storeResult);\n                                    }\n                                    if (errorPolicy === \"ignore\" && utilities.graphQLResultHasError(storeResult)) {\n                                        delete storeResult.errors;\n                                    }\n                                    return self.markMutationResult({\n                                        mutationId: mutationId,\n                                        result: storeResult,\n                                        document: mutation,\n                                        variables: variables,\n                                        fetchPolicy: fetchPolicy,\n                                        errorPolicy: errorPolicy,\n                                        context: context,\n                                        update: updateWithProxyFn,\n                                        updateQueries: updateQueries,\n                                        awaitRefetchQueries: awaitRefetchQueries,\n                                        refetchQueries: refetchQueries,\n                                        removeOptimistic: isOptimistic ? mutationId : void 0,\n                                        onQueryUpdated: onQueryUpdated,\n                                        keepRootFields: keepRootFields,\n                                    });\n                                }).subscribe({\n                                    next: function (storeResult) {\n                                        self.broadcastQueries();\n                                        if (!(\"hasNext\" in storeResult) || storeResult.hasNext === false) {\n                                            resolve(tslib.__assign(tslib.__assign({}, storeResult), { data: self.maskOperation({\n                                                    document: mutation,\n                                                    data: storeResult.data,\n                                                    fetchPolicy: fetchPolicy,\n                                                    id: mutationId,\n                                                }) }));\n                                        }\n                                    },\n                                    error: function (err) {\n                                        if (mutationStoreValue) {\n                                            mutationStoreValue.loading = false;\n                                            mutationStoreValue.error = err;\n                                        }\n                                        if (isOptimistic) {\n                                            self.cache.removeOptimistic(mutationId);\n                                        }\n                                        self.broadcastQueries();\n                                        reject(err instanceof errors.ApolloError ? err : (new errors.ApolloError({\n                                            networkError: err,\n                                        })));\n                                    },\n                                });\n                            })];\n                }\n            });\n        });\n    };\n    QueryManager.prototype.markMutationResult = function (mutation, cache) {\n        var _this = this;\n        if (cache === void 0) { cache = this.cache; }\n        var result = mutation.result;\n        var cacheWrites = [];\n        var skipCache = mutation.fetchPolicy === \"no-cache\";\n        if (!skipCache && shouldWriteResult(result, mutation.errorPolicy)) {\n            if (!utilities.isExecutionPatchIncrementalResult(result)) {\n                cacheWrites.push({\n                    result: result.data,\n                    dataId: \"ROOT_MUTATION\",\n                    query: mutation.document,\n                    variables: mutation.variables,\n                });\n            }\n            if (utilities.isExecutionPatchIncrementalResult(result) &&\n                utilities.isNonEmptyArray(result.incremental)) {\n                var diff = cache.diff({\n                    id: \"ROOT_MUTATION\",\n                    query: this.getDocumentInfo(mutation.document).asQuery,\n                    variables: mutation.variables,\n                    optimistic: false,\n                    returnPartialData: true,\n                });\n                var mergedData = void 0;\n                if (diff.result) {\n                    mergedData = mergeIncrementalData(diff.result, result);\n                }\n                if (typeof mergedData !== \"undefined\") {\n                    result.data = mergedData;\n                    cacheWrites.push({\n                        result: mergedData,\n                        dataId: \"ROOT_MUTATION\",\n                        query: mutation.document,\n                        variables: mutation.variables,\n                    });\n                }\n            }\n            var updateQueries_1 = mutation.updateQueries;\n            if (updateQueries_1) {\n                this.queries.forEach(function (_a, queryId) {\n                    var observableQuery = _a.observableQuery;\n                    var queryName = observableQuery && observableQuery.queryName;\n                    if (!queryName || !hasOwnProperty.call(updateQueries_1, queryName)) {\n                        return;\n                    }\n                    var updater = updateQueries_1[queryName];\n                    var _b = _this.queries.get(queryId), document = _b.document, variables = _b.variables;\n                    var _c = cache.diff({\n                        query: document,\n                        variables: variables,\n                        returnPartialData: true,\n                        optimistic: false,\n                    }), currentQueryResult = _c.result, complete = _c.complete;\n                    if (complete && currentQueryResult) {\n                        var nextQueryResult = updater(currentQueryResult, {\n                            mutationResult: result,\n                            queryName: (document && utilities.getOperationName(document)) || void 0,\n                            queryVariables: variables,\n                        });\n                        if (nextQueryResult) {\n                            cacheWrites.push({\n                                result: nextQueryResult,\n                                dataId: \"ROOT_QUERY\",\n                                query: document,\n                                variables: variables,\n                            });\n                        }\n                    }\n                });\n            }\n        }\n        if (cacheWrites.length > 0 ||\n            (mutation.refetchQueries || \"\").length > 0 ||\n            mutation.update ||\n            mutation.onQueryUpdated ||\n            mutation.removeOptimistic) {\n            var results_1 = [];\n            this.refetchQueries({\n                updateCache: function (cache) {\n                    if (!skipCache) {\n                        cacheWrites.forEach(function (write) { return cache.write(write); });\n                    }\n                    var update = mutation.update;\n                    var isFinalResult = !utilities.isExecutionPatchResult(result) ||\n                        (utilities.isExecutionPatchIncrementalResult(result) && !result.hasNext);\n                    if (update) {\n                        if (!skipCache) {\n                            var diff = cache.diff({\n                                id: \"ROOT_MUTATION\",\n                                query: _this.getDocumentInfo(mutation.document).asQuery,\n                                variables: mutation.variables,\n                                optimistic: false,\n                                returnPartialData: true,\n                            });\n                            if (diff.complete) {\n                                result = tslib.__assign(tslib.__assign({}, result), { data: diff.result });\n                                if (\"incremental\" in result) {\n                                    delete result.incremental;\n                                }\n                                if (\"hasNext\" in result) {\n                                    delete result.hasNext;\n                                }\n                            }\n                        }\n                        if (isFinalResult) {\n                            update(cache, result, {\n                                context: mutation.context,\n                                variables: mutation.variables,\n                            });\n                        }\n                    }\n                    if (!skipCache && !mutation.keepRootFields && isFinalResult) {\n                        cache.modify({\n                            id: \"ROOT_MUTATION\",\n                            fields: function (value, _a) {\n                                var fieldName = _a.fieldName, DELETE = _a.DELETE;\n                                return fieldName === \"__typename\" ? value : DELETE;\n                            },\n                        });\n                    }\n                },\n                include: mutation.refetchQueries,\n                optimistic: false,\n                removeOptimistic: mutation.removeOptimistic,\n                onQueryUpdated: mutation.onQueryUpdated || null,\n            }).forEach(function (result) { return results_1.push(result); });\n            if (mutation.awaitRefetchQueries || mutation.onQueryUpdated) {\n                return Promise.all(results_1).then(function () { return result; });\n            }\n        }\n        return Promise.resolve(result);\n    };\n    QueryManager.prototype.markMutationOptimistic = function (optimisticResponse, mutation) {\n        var _this = this;\n        var data = typeof optimisticResponse === \"function\" ?\n            optimisticResponse(mutation.variables, { IGNORE: IGNORE })\n            : optimisticResponse;\n        if (data === IGNORE) {\n            return false;\n        }\n        this.cache.recordOptimisticTransaction(function (cache) {\n            try {\n                _this.markMutationResult(tslib.__assign(tslib.__assign({}, mutation), { result: { data: data } }), cache);\n            }\n            catch (error) {\n                globalThis.__DEV__ !== false && globals.invariant.error(error);\n            }\n        }, mutation.mutationId);\n        return true;\n    };\n    QueryManager.prototype.fetchQuery = function (queryId, options, networkStatus) {\n        return this.fetchConcastWithInfo(this.getOrCreateQuery(queryId), options, networkStatus).concast.promise;\n    };\n    QueryManager.prototype.getQueryStore = function () {\n        var store = Object.create(null);\n        this.queries.forEach(function (info, queryId) {\n            store[queryId] = {\n                variables: info.variables,\n                networkStatus: info.networkStatus,\n                networkError: info.networkError,\n                graphQLErrors: info.graphQLErrors,\n            };\n        });\n        return store;\n    };\n    QueryManager.prototype.resetErrors = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo) {\n            queryInfo.networkError = undefined;\n            queryInfo.graphQLErrors = [];\n        }\n    };\n    QueryManager.prototype.transform = function (document) {\n        return this.documentTransform.transformDocument(document);\n    };\n    QueryManager.prototype.getDocumentInfo = function (document) {\n        var transformCache = this.transformCache;\n        if (!transformCache.has(document)) {\n            var cacheEntry = {\n                hasClientExports: utilities.hasClientExports(document),\n                hasForcedResolvers: this.localState.shouldForceResolvers(document),\n                hasNonreactiveDirective: utilities.hasDirectives([\"nonreactive\"], document),\n                nonReactiveQuery: utilities.addNonReactiveToNamedFragments(document),\n                clientQuery: this.localState.clientQuery(document),\n                serverQuery: utilities.removeDirectivesFromDocument([\n                    { name: \"client\", remove: true },\n                    { name: \"connection\" },\n                    { name: \"nonreactive\" },\n                    { name: \"unmask\" },\n                ], document),\n                defaultVars: utilities.getDefaultValues(utilities.getOperationDefinition(document)),\n                asQuery: tslib.__assign(tslib.__assign({}, document), { definitions: document.definitions.map(function (def) {\n                        if (def.kind === \"OperationDefinition\" &&\n                            def.operation !== \"query\") {\n                            return tslib.__assign(tslib.__assign({}, def), { operation: \"query\" });\n                        }\n                        return def;\n                    }) }),\n            };\n            transformCache.set(document, cacheEntry);\n        }\n        return transformCache.get(document);\n    };\n    QueryManager.prototype.getVariables = function (document, variables) {\n        return tslib.__assign(tslib.__assign({}, this.getDocumentInfo(document).defaultVars), variables);\n    };\n    QueryManager.prototype.watchQuery = function (options) {\n        var query = this.transform(options.query);\n        options = tslib.__assign(tslib.__assign({}, options), { variables: this.getVariables(query, options.variables) });\n        if (typeof options.notifyOnNetworkStatusChange === \"undefined\") {\n            options.notifyOnNetworkStatusChange = false;\n        }\n        var queryInfo = new QueryInfo(this);\n        var observable = new ObservableQuery({\n            queryManager: this,\n            queryInfo: queryInfo,\n            options: options,\n        });\n        observable[\"lastQuery\"] = query;\n        if (!ObservableQuery[\"inactiveOnCreation\"].getValue()) {\n            this.queries.set(observable.queryId, queryInfo);\n        }\n        queryInfo.init({\n            document: query,\n            observableQuery: observable,\n            variables: observable.variables,\n        });\n        return observable;\n    };\n    QueryManager.prototype.query = function (options, queryId) {\n        var _this = this;\n        if (queryId === void 0) { queryId = this.generateQueryId(); }\n        globals.invariant(options.query, 38);\n        globals.invariant(options.query.kind === \"Document\", 39);\n        globals.invariant(!options.returnPartialData, 40);\n        globals.invariant(!options.pollInterval, 41);\n        var query = this.transform(options.query);\n        return this.fetchQuery(queryId, tslib.__assign(tslib.__assign({}, options), { query: query }))\n            .then(function (result) {\n            return result && tslib.__assign(tslib.__assign({}, result), { data: _this.maskOperation({\n                    document: query,\n                    data: result.data,\n                    fetchPolicy: options.fetchPolicy,\n                    id: queryId,\n                }) });\n        })\n            .finally(function () { return _this.stopQuery(queryId); });\n    };\n    QueryManager.prototype.generateQueryId = function () {\n        return String(this.queryIdCounter++);\n    };\n    QueryManager.prototype.generateRequestId = function () {\n        return this.requestIdCounter++;\n    };\n    QueryManager.prototype.generateMutationId = function () {\n        return String(this.mutationIdCounter++);\n    };\n    QueryManager.prototype.stopQueryInStore = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryInStoreNoBroadcast = function (queryId) {\n        var queryInfo = this.queries.get(queryId);\n        if (queryInfo)\n            queryInfo.stop();\n    };\n    QueryManager.prototype.clearStore = function (options) {\n        if (options === void 0) { options = {\n            discardWatches: true,\n        }; }\n        this.cancelPendingFetches(globals.newInvariantError(42));\n        this.queries.forEach(function (queryInfo) {\n            if (queryInfo.observableQuery) {\n                queryInfo.networkStatus = exports.NetworkStatus.loading;\n            }\n            else {\n                queryInfo.stop();\n            }\n        });\n        if (this.mutationStore) {\n            this.mutationStore = Object.create(null);\n        }\n        return this.cache.reset(options);\n    };\n    QueryManager.prototype.getObservableQueries = function (include) {\n        var _this = this;\n        if (include === void 0) { include = \"active\"; }\n        var queries = new Map();\n        var queryNames = new Map();\n        var queryNamesAndQueryStrings = new Map();\n        var legacyQueryOptions = new Set();\n        if (Array.isArray(include)) {\n            include.forEach(function (desc) {\n                if (typeof desc === \"string\") {\n                    queryNames.set(desc, desc);\n                    queryNamesAndQueryStrings.set(desc, false);\n                }\n                else if (utilities.isDocumentNode(desc)) {\n                    var queryString = utilities.print(_this.transform(desc));\n                    queryNames.set(queryString, utilities.getOperationName(desc));\n                    queryNamesAndQueryStrings.set(queryString, false);\n                }\n                else if (utilities.isNonNullObject(desc) && desc.query) {\n                    legacyQueryOptions.add(desc);\n                }\n            });\n        }\n        this.queries.forEach(function (_a, queryId) {\n            var oq = _a.observableQuery, document = _a.document;\n            if (oq) {\n                if (include === \"all\") {\n                    queries.set(queryId, oq);\n                    return;\n                }\n                var queryName = oq.queryName, fetchPolicy = oq.options.fetchPolicy;\n                if (fetchPolicy === \"standby\" ||\n                    (include === \"active\" && !oq.hasObservers())) {\n                    return;\n                }\n                if (include === \"active\" ||\n                    (queryName && queryNamesAndQueryStrings.has(queryName)) ||\n                    (document && queryNamesAndQueryStrings.has(utilities.print(document)))) {\n                    queries.set(queryId, oq);\n                    if (queryName)\n                        queryNamesAndQueryStrings.set(queryName, true);\n                    if (document)\n                        queryNamesAndQueryStrings.set(utilities.print(document), true);\n                }\n            }\n        });\n        if (legacyQueryOptions.size) {\n            legacyQueryOptions.forEach(function (options) {\n                var queryId = utilities.makeUniqueId(\"legacyOneTimeQuery\");\n                var queryInfo = _this.getOrCreateQuery(queryId).init({\n                    document: options.query,\n                    variables: options.variables,\n                });\n                var oq = new ObservableQuery({\n                    queryManager: _this,\n                    queryInfo: queryInfo,\n                    options: tslib.__assign(tslib.__assign({}, options), { fetchPolicy: \"network-only\" }),\n                });\n                globals.invariant(oq.queryId === queryId);\n                queryInfo.setObservableQuery(oq);\n                queries.set(queryId, oq);\n            });\n        }\n        if (globalThis.__DEV__ !== false && queryNamesAndQueryStrings.size) {\n            queryNamesAndQueryStrings.forEach(function (included, nameOrQueryString) {\n                if (!included) {\n                    var queryName = queryNames.get(nameOrQueryString);\n                    if (queryName) {\n                        globalThis.__DEV__ !== false && globals.invariant.warn(43, queryName);\n                    }\n                    else {\n                        globalThis.__DEV__ !== false && globals.invariant.warn(44);\n                    }\n                }\n            });\n        }\n        return queries;\n    };\n    QueryManager.prototype.reFetchObservableQueries = function (includeStandby) {\n        var _this = this;\n        if (includeStandby === void 0) { includeStandby = false; }\n        var observableQueryPromises = [];\n        this.getObservableQueries(includeStandby ? \"all\" : \"active\").forEach(function (observableQuery, queryId) {\n            var fetchPolicy = observableQuery.options.fetchPolicy;\n            muteDeprecations(\"resetLastResults\", function () {\n                return observableQuery.resetLastResults();\n            });\n            if (includeStandby ||\n                (fetchPolicy !== \"standby\" && fetchPolicy !== \"cache-only\")) {\n                observableQueryPromises.push(observableQuery.refetch());\n            }\n            (_this.queries.get(queryId) || observableQuery[\"queryInfo\"]).setDiff(null);\n        });\n        this.broadcastQueries();\n        return Promise.all(observableQueryPromises);\n    };\n    QueryManager.prototype.startGraphQLSubscription = function (options) {\n        var _this = this;\n        var query = options.query, variables = options.variables;\n        var fetchPolicy = options.fetchPolicy, _a = options.errorPolicy, errorPolicy = _a === void 0 ? \"none\" : _a, _b = options.context, context = _b === void 0 ? {} : _b, _c = options.extensions, extensions = _c === void 0 ? {} : _c;\n        query = this.transform(query);\n        variables = this.getVariables(query, variables);\n        var makeObservable = function (variables) {\n            return _this.getObservableFromLink(query, context, variables, extensions).map(function (result) {\n                if (fetchPolicy !== \"no-cache\") {\n                    if (shouldWriteResult(result, errorPolicy)) {\n                        _this.cache.write({\n                            query: query,\n                            result: result.data,\n                            dataId: \"ROOT_SUBSCRIPTION\",\n                            variables: variables,\n                        });\n                    }\n                    _this.broadcastQueries();\n                }\n                var hasErrors = utilities.graphQLResultHasError(result);\n                var hasProtocolErrors = errors.graphQLResultHasProtocolErrors(result);\n                if (hasErrors || hasProtocolErrors) {\n                    var errors$1 = {};\n                    if (hasErrors) {\n                        errors$1.graphQLErrors = result.errors;\n                    }\n                    if (hasProtocolErrors) {\n                        errors$1.protocolErrors = result.extensions[errors.PROTOCOL_ERRORS_SYMBOL];\n                    }\n                    if (errorPolicy === \"none\" || hasProtocolErrors) {\n                        throw new errors.ApolloError(errors$1);\n                    }\n                }\n                if (errorPolicy === \"ignore\") {\n                    delete result.errors;\n                }\n                return result;\n            });\n        };\n        if (this.getDocumentInfo(query).hasClientExports) {\n            var observablePromise_1 = this.localState\n                .addExportedVariables(query, variables, context)\n                .then(makeObservable);\n            return new utilities.Observable(function (observer) {\n                var sub = null;\n                observablePromise_1.then(function (observable) { return (sub = observable.subscribe(observer)); }, observer.error);\n                return function () { return sub && sub.unsubscribe(); };\n            });\n        }\n        return makeObservable(variables);\n    };\n    QueryManager.prototype.stopQuery = function (queryId) {\n        this.stopQueryNoBroadcast(queryId);\n        this.broadcastQueries();\n    };\n    QueryManager.prototype.stopQueryNoBroadcast = function (queryId) {\n        this.stopQueryInStoreNoBroadcast(queryId);\n        this.removeQuery(queryId);\n    };\n    QueryManager.prototype.removeQuery = function (queryId) {\n        var _a;\n        this.fetchCancelFns.delete(queryId);\n        if (this.queries.has(queryId)) {\n            (_a = this.queries.get(queryId)) === null || _a === void 0 ? void 0 : _a.stop();\n            this.queries.delete(queryId);\n        }\n    };\n    QueryManager.prototype.broadcastQueries = function () {\n        if (this.onBroadcast)\n            this.onBroadcast();\n        this.queries.forEach(function (info) { var _a; return (_a = info.observableQuery) === null || _a === void 0 ? void 0 : _a[\"notify\"](); });\n    };\n    QueryManager.prototype.getLocalState = function () {\n        return this.localState;\n    };\n    QueryManager.prototype.getObservableFromLink = function (query, context, variables, extensions,\n    deduplication) {\n        var _this = this;\n        var _a;\n        if (deduplication === void 0) { deduplication = (_a = context === null || context === void 0 ? void 0 : context.queryDeduplication) !== null && _a !== void 0 ? _a : this.queryDeduplication; }\n        var observable;\n        var _b = this.getDocumentInfo(query), serverQuery = _b.serverQuery, clientQuery = _b.clientQuery;\n        if (serverQuery) {\n            var _c = this, inFlightLinkObservables_1 = _c.inFlightLinkObservables, link = _c.link;\n            var operation = {\n                query: serverQuery,\n                variables: variables,\n                operationName: utilities.getOperationName(serverQuery) || void 0,\n                context: this.prepareContext(tslib.__assign(tslib.__assign({}, context), { forceFetch: !deduplication })),\n                extensions: extensions,\n            };\n            context = operation.context;\n            if (deduplication) {\n                var printedServerQuery_1 = utilities.print(serverQuery);\n                var varJson_1 = cache.canonicalStringify(variables);\n                var entry = inFlightLinkObservables_1.lookup(printedServerQuery_1, varJson_1);\n                observable = entry.observable;\n                if (!observable) {\n                    var concast_1 = new utilities.Concast([\n                        core.execute(link, operation),\n                    ]);\n                    observable = entry.observable = concast_1;\n                    concast_1.beforeNext(function cb(method, arg) {\n                        if (method === \"next\" && \"hasNext\" in arg && arg.hasNext) {\n                            concast_1.beforeNext(cb);\n                        }\n                        else {\n                            inFlightLinkObservables_1.remove(printedServerQuery_1, varJson_1);\n                        }\n                    });\n                }\n            }\n            else {\n                observable = new utilities.Concast([\n                    core.execute(link, operation),\n                ]);\n            }\n        }\n        else {\n            observable = new utilities.Concast([utilities.Observable.of({ data: {} })]);\n            context = this.prepareContext(context);\n        }\n        if (clientQuery) {\n            observable = utilities.asyncMap(observable, function (result) {\n                return _this.localState.runResolvers({\n                    document: clientQuery,\n                    remoteResult: result,\n                    context: context,\n                    variables: variables,\n                });\n            });\n        }\n        return observable;\n    };\n    QueryManager.prototype.getResultsFromLink = function (queryInfo, cacheWriteBehavior, options) {\n        var requestId = (queryInfo.lastRequestId = this.generateRequestId());\n        var linkDocument = this.cache.transformForLink(options.query);\n        return utilities.asyncMap(this.getObservableFromLink(linkDocument, options.context, options.variables), function (result) {\n            var graphQLErrors = utilities.getGraphQLErrorsFromResult(result);\n            var hasErrors = graphQLErrors.length > 0;\n            var errorPolicy = options.errorPolicy;\n            if (requestId >= queryInfo.lastRequestId) {\n                if (hasErrors && errorPolicy === \"none\") {\n                    throw queryInfo.markError(new errors.ApolloError({\n                        graphQLErrors: graphQLErrors,\n                    }));\n                }\n                queryInfo.markResult(result, linkDocument, options, cacheWriteBehavior);\n                queryInfo.markReady();\n            }\n            var aqr = {\n                data: result.data,\n                loading: false,\n                networkStatus: exports.NetworkStatus.ready,\n            };\n            if (hasErrors && errorPolicy === \"none\") {\n                aqr.data = void 0;\n            }\n            if (hasErrors && errorPolicy !== \"ignore\") {\n                aqr.errors = graphQLErrors;\n                aqr.networkStatus = exports.NetworkStatus.error;\n            }\n            return aqr;\n        }, function (networkError) {\n            var error = errors.isApolloError(networkError) ? networkError : (new errors.ApolloError({ networkError: networkError }));\n            if (requestId >= queryInfo.lastRequestId) {\n                queryInfo.markError(error);\n            }\n            throw error;\n        });\n    };\n    QueryManager.prototype.fetchConcastWithInfo = function (queryInfo, options,\n    networkStatus, query) {\n        var _this = this;\n        if (networkStatus === void 0) { networkStatus = exports.NetworkStatus.loading; }\n        if (query === void 0) { query = options.query; }\n        var variables = this.getVariables(query, options.variables);\n        var defaults = this.defaultOptions.watchQuery;\n        var _a = options.fetchPolicy, fetchPolicy = _a === void 0 ? (defaults && defaults.fetchPolicy) || \"cache-first\" : _a, _b = options.errorPolicy, errorPolicy = _b === void 0 ? (defaults && defaults.errorPolicy) || \"none\" : _b, _c = options.returnPartialData, returnPartialData = _c === void 0 ? false : _c, _d = options.notifyOnNetworkStatusChange, notifyOnNetworkStatusChange = _d === void 0 ? false : _d, _e = options.context, context = _e === void 0 ? {} : _e;\n        var normalized = Object.assign({}, options, {\n            query: query,\n            variables: variables,\n            fetchPolicy: fetchPolicy,\n            errorPolicy: errorPolicy,\n            returnPartialData: returnPartialData,\n            notifyOnNetworkStatusChange: notifyOnNetworkStatusChange,\n            context: context,\n        });\n        var fromVariables = function (variables) {\n            normalized.variables = variables;\n            var sourcesWithInfo = _this.fetchQueryByPolicy(queryInfo, normalized, networkStatus);\n            if (\n            normalized.fetchPolicy !== \"standby\" &&\n                sourcesWithInfo.sources.length > 0 &&\n                queryInfo.observableQuery) {\n                queryInfo.observableQuery[\"applyNextFetchPolicy\"](\"after-fetch\", options);\n            }\n            return sourcesWithInfo;\n        };\n        var cleanupCancelFn = function () { return _this.fetchCancelFns.delete(queryInfo.queryId); };\n        this.fetchCancelFns.set(queryInfo.queryId, function (reason) {\n            cleanupCancelFn();\n            setTimeout(function () { return concast.cancel(reason); });\n        });\n        var concast, containsDataFromLink;\n        if (this.getDocumentInfo(normalized.query).hasClientExports) {\n            concast = new utilities.Concast(this.localState\n                .addExportedVariables(normalized.query, normalized.variables, normalized.context)\n                .then(fromVariables)\n                .then(function (sourcesWithInfo) { return sourcesWithInfo.sources; }));\n            containsDataFromLink = true;\n        }\n        else {\n            var sourcesWithInfo = fromVariables(normalized.variables);\n            containsDataFromLink = sourcesWithInfo.fromLink;\n            concast = new utilities.Concast(sourcesWithInfo.sources);\n        }\n        concast.promise.then(cleanupCancelFn, cleanupCancelFn);\n        return {\n            concast: concast,\n            fromLink: containsDataFromLink,\n        };\n    };\n    QueryManager.prototype.refetchQueries = function (_a) {\n        var _this = this;\n        var updateCache = _a.updateCache, include = _a.include, _b = _a.optimistic, optimistic = _b === void 0 ? false : _b, _c = _a.removeOptimistic, removeOptimistic = _c === void 0 ? optimistic ? utilities.makeUniqueId(\"refetchQueries\") : void 0 : _c, onQueryUpdated = _a.onQueryUpdated;\n        var includedQueriesById = new Map();\n        if (include) {\n            this.getObservableQueries(include).forEach(function (oq, queryId) {\n                includedQueriesById.set(queryId, {\n                    oq: oq,\n                    lastDiff: (_this.queries.get(queryId) || oq[\"queryInfo\"]).getDiff(),\n                });\n            });\n        }\n        var results = new Map();\n        if (updateCache) {\n            this.cache.batch({\n                update: updateCache,\n                optimistic: (optimistic && removeOptimistic) || false,\n                removeOptimistic: removeOptimistic,\n                onWatchUpdated: function (watch, diff, lastDiff) {\n                    var oq = watch.watcher instanceof QueryInfo && watch.watcher.observableQuery;\n                    if (oq) {\n                        if (onQueryUpdated) {\n                            includedQueriesById.delete(oq.queryId);\n                            var result = onQueryUpdated(oq, diff, lastDiff);\n                            if (result === true) {\n                                result = oq.refetch();\n                            }\n                            if (result !== false) {\n                                results.set(oq, result);\n                            }\n                            return result;\n                        }\n                        if (onQueryUpdated !== null) {\n                            includedQueriesById.set(oq.queryId, { oq: oq, lastDiff: lastDiff, diff: diff });\n                        }\n                    }\n                },\n            });\n        }\n        if (includedQueriesById.size) {\n            includedQueriesById.forEach(function (_a, queryId) {\n                var oq = _a.oq, lastDiff = _a.lastDiff, diff = _a.diff;\n                var result;\n                if (onQueryUpdated) {\n                    if (!diff) {\n                        diff = muteDeprecations(\"canonizeResults\", function () {\n                            return _this.cache.diff(oq[\"queryInfo\"][\"getDiffOptions\"]());\n                        });\n                    }\n                    result = onQueryUpdated(oq, diff, lastDiff);\n                }\n                if (!onQueryUpdated || result === true) {\n                    result = oq.refetch();\n                }\n                if (result !== false) {\n                    results.set(oq, result);\n                }\n                if (queryId.indexOf(\"legacyOneTimeQuery\") >= 0) {\n                    _this.stopQueryNoBroadcast(queryId);\n                }\n            });\n        }\n        if (removeOptimistic) {\n            this.cache.removeOptimistic(removeOptimistic);\n        }\n        return results;\n    };\n    QueryManager.prototype.maskOperation = function (options) {\n        var _a, _b, _c;\n        var document = options.document, data = options.data;\n        if (globalThis.__DEV__ !== false) {\n            var fetchPolicy = options.fetchPolicy, id = options.id;\n            var operationType = (_a = utilities.getOperationDefinition(document)) === null || _a === void 0 ? void 0 : _a.operation;\n            var operationId = ((_b = operationType === null || operationType === void 0 ? void 0 : operationType[0]) !== null && _b !== void 0 ? _b : \"o\") + id;\n            if (this.dataMasking &&\n                fetchPolicy === \"no-cache\" &&\n                !utilities.isFullyUnmaskedOperation(document) &&\n                !this.noCacheWarningsByQueryId.has(operationId)) {\n                this.noCacheWarningsByQueryId.add(operationId);\n                globalThis.__DEV__ !== false && globals.invariant.warn(\n                    45,\n                    (_c = utilities.getOperationName(document)) !== null && _c !== void 0 ? _c : \"Unnamed \".concat(operationType !== null && operationType !== void 0 ? operationType : \"operation\")\n                );\n            }\n        }\n        return (this.dataMasking ?\n            masking.maskOperation(data, document, this.cache)\n            : data);\n    };\n    QueryManager.prototype.maskFragment = function (options) {\n        var data = options.data, fragment = options.fragment, fragmentName = options.fragmentName;\n        return this.dataMasking ?\n            masking.maskFragment(data, fragment, this.cache, fragmentName)\n            : data;\n    };\n    QueryManager.prototype.fetchQueryByPolicy = function (queryInfo, _a,\n    networkStatus) {\n        var _this = this;\n        var query = _a.query, variables = _a.variables, fetchPolicy = _a.fetchPolicy, refetchWritePolicy = _a.refetchWritePolicy, errorPolicy = _a.errorPolicy, returnPartialData = _a.returnPartialData, context = _a.context, notifyOnNetworkStatusChange = _a.notifyOnNetworkStatusChange;\n        var oldNetworkStatus = queryInfo.networkStatus;\n        queryInfo.init({\n            document: query,\n            variables: variables,\n            networkStatus: networkStatus,\n        });\n        var readCache = function () { return queryInfo.getDiff(); };\n        var resultsFromCache = function (diff, networkStatus) {\n            if (networkStatus === void 0) { networkStatus = queryInfo.networkStatus || exports.NetworkStatus.loading; }\n            var data = diff.result;\n            if (globalThis.__DEV__ !== false && !returnPartialData && !equal.equal(data, {})) {\n                logMissingFieldErrors(diff.missing);\n            }\n            var fromData = function (data) {\n                return utilities.Observable.of(tslib.__assign({ data: data, loading: isNetworkRequestInFlight(networkStatus), networkStatus: networkStatus }, (diff.complete ? null : { partial: true })));\n            };\n            if (data && _this.getDocumentInfo(query).hasForcedResolvers) {\n                return _this.localState\n                    .runResolvers({\n                    document: query,\n                    remoteResult: { data: data },\n                    context: context,\n                    variables: variables,\n                    onlyRunForcedResolvers: true,\n                })\n                    .then(function (resolved) { return fromData(resolved.data || void 0); });\n            }\n            if (errorPolicy === \"none\" &&\n                networkStatus === exports.NetworkStatus.refetch &&\n                Array.isArray(diff.missing)) {\n                return fromData(void 0);\n            }\n            return fromData(data);\n        };\n        var cacheWriteBehavior = fetchPolicy === \"no-cache\" ? 0\n            : (networkStatus === exports.NetworkStatus.refetch &&\n                refetchWritePolicy !== \"merge\") ?\n                1\n                : 2 ;\n        var resultsFromLink = function () {\n            return _this.getResultsFromLink(queryInfo, cacheWriteBehavior, {\n                query: query,\n                variables: variables,\n                context: context,\n                fetchPolicy: fetchPolicy,\n                errorPolicy: errorPolicy,\n            });\n        };\n        var shouldNotify = notifyOnNetworkStatusChange &&\n            typeof oldNetworkStatus === \"number\" &&\n            oldNetworkStatus !== networkStatus &&\n            isNetworkRequestInFlight(networkStatus);\n        switch (fetchPolicy) {\n            default:\n            case \"cache-first\": {\n                var diff = readCache();\n                if (diff.complete) {\n                    return {\n                        fromLink: false,\n                        sources: [resultsFromCache(diff, queryInfo.markReady())],\n                    };\n                }\n                if (returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-and-network\": {\n                var diff = readCache();\n                if (diff.complete || returnPartialData || shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(diff), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            }\n            case \"cache-only\":\n                return {\n                    fromLink: false,\n                    sources: [resultsFromCache(readCache(), queryInfo.markReady())],\n                };\n            case \"network-only\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(readCache()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"no-cache\":\n                if (shouldNotify) {\n                    return {\n                        fromLink: true,\n                        sources: [resultsFromCache(queryInfo.getDiff()), resultsFromLink()],\n                    };\n                }\n                return { fromLink: true, sources: [resultsFromLink()] };\n            case \"standby\":\n                return { fromLink: false, sources: [] };\n        }\n    };\n    QueryManager.prototype.getOrCreateQuery = function (queryId) {\n        if (queryId && !this.queries.has(queryId)) {\n            this.queries.set(queryId, new QueryInfo(this, queryId));\n        }\n        return this.queries.get(queryId);\n    };\n    QueryManager.prototype.prepareContext = function (context) {\n        if (context === void 0) { context = {}; }\n        var newContext = this.localState.prepareContext(context);\n        return tslib.__assign(tslib.__assign(tslib.__assign({}, this.defaultContext), newContext), { clientAwareness: this.clientAwareness });\n    };\n    return QueryManager;\n}());\n\nvar LocalState =  (function () {\n    function LocalState(_a) {\n        var cache = _a.cache, client = _a.client, resolvers = _a.resolvers, fragmentMatcher = _a.fragmentMatcher;\n        this.selectionsToResolveCache = new WeakMap();\n        this.cache = cache;\n        if (client) {\n            this.client = client;\n        }\n        if (resolvers) {\n            this.addResolvers(resolvers);\n        }\n        if (fragmentMatcher) {\n            this.setFragmentMatcher(fragmentMatcher);\n        }\n    }\n    LocalState.prototype.addResolvers = function (resolvers) {\n        var _this = this;\n        this.resolvers = this.resolvers || {};\n        if (Array.isArray(resolvers)) {\n            resolvers.forEach(function (resolverGroup) {\n                _this.resolvers = utilities.mergeDeep(_this.resolvers, resolverGroup);\n            });\n        }\n        else {\n            this.resolvers = utilities.mergeDeep(this.resolvers, resolvers);\n        }\n    };\n    LocalState.prototype.setResolvers = function (resolvers) {\n        this.resolvers = {};\n        this.addResolvers(resolvers);\n    };\n    LocalState.prototype.getResolvers = function () {\n        return this.resolvers || {};\n    };\n    LocalState.prototype.runResolvers = function (_a) {\n        return tslib.__awaiter(this, arguments, void 0, function (_b) {\n            var document = _b.document, remoteResult = _b.remoteResult, context = _b.context, variables = _b.variables, _c = _b.onlyRunForcedResolvers, onlyRunForcedResolvers = _c === void 0 ? false : _c;\n            return tslib.__generator(this, function (_d) {\n                if (document) {\n                    return [2 , this.resolveDocument(document, remoteResult.data, context, variables, this.fragmentMatcher, onlyRunForcedResolvers).then(function (localResult) { return (tslib.__assign(tslib.__assign({}, remoteResult), { data: localResult.result })); })];\n                }\n                return [2 , remoteResult];\n            });\n        });\n    };\n    LocalState.prototype.setFragmentMatcher = function (fragmentMatcher) {\n        this.fragmentMatcher = fragmentMatcher;\n    };\n    LocalState.prototype.getFragmentMatcher = function () {\n        return this.fragmentMatcher;\n    };\n    LocalState.prototype.clientQuery = function (document) {\n        if (utilities.hasDirectives([\"client\"], document)) {\n            if (this.resolvers) {\n                return document;\n            }\n        }\n        return null;\n    };\n    LocalState.prototype.serverQuery = function (document) {\n        return utilities.removeClientSetsFromDocument(document);\n    };\n    LocalState.prototype.prepareContext = function (context) {\n        var cache = this.cache;\n        return tslib.__assign(tslib.__assign({}, context), { cache: cache,\n            getCacheKey: function (obj) {\n                return cache.identify(obj);\n            } });\n    };\n    LocalState.prototype.addExportedVariables = function (document_1) {\n        return tslib.__awaiter(this, arguments, void 0, function (document, variables, context) {\n            if (variables === void 0) { variables = {}; }\n            if (context === void 0) { context = {}; }\n            return tslib.__generator(this, function (_a) {\n                if (document) {\n                    return [2 , this.resolveDocument(document, this.buildRootValueFromCache(document, variables) || {}, this.prepareContext(context), variables).then(function (data) { return (tslib.__assign(tslib.__assign({}, variables), data.exportedVariables)); })];\n                }\n                return [2 , tslib.__assign({}, variables)];\n            });\n        });\n    };\n    LocalState.prototype.shouldForceResolvers = function (document) {\n        var forceResolvers = false;\n        graphql.visit(document, {\n            Directive: {\n                enter: function (node) {\n                    if (node.name.value === \"client\" && node.arguments) {\n                        forceResolvers = node.arguments.some(function (arg) {\n                            return arg.name.value === \"always\" &&\n                                arg.value.kind === \"BooleanValue\" &&\n                                arg.value.value === true;\n                        });\n                        if (forceResolvers) {\n                            return graphql.BREAK;\n                        }\n                    }\n                },\n            },\n        });\n        return forceResolvers;\n    };\n    LocalState.prototype.buildRootValueFromCache = function (document, variables) {\n        return this.cache.diff({\n            query: utilities.buildQueryFromSelectionSet(document),\n            variables: variables,\n            returnPartialData: true,\n            optimistic: false,\n        }).result;\n    };\n    LocalState.prototype.resolveDocument = function (document_1, rootValue_1) {\n        return tslib.__awaiter(this, arguments, void 0, function (document, rootValue, context, variables, fragmentMatcher, onlyRunForcedResolvers) {\n            var mainDefinition, fragments, fragmentMap, selectionsToResolve, definitionOperation, defaultOperationType, _a, cache, client, execContext, isClientFieldDescendant;\n            if (context === void 0) { context = {}; }\n            if (variables === void 0) { variables = {}; }\n            if (fragmentMatcher === void 0) { fragmentMatcher = function () { return true; }; }\n            if (onlyRunForcedResolvers === void 0) { onlyRunForcedResolvers = false; }\n            return tslib.__generator(this, function (_b) {\n                mainDefinition = utilities.getMainDefinition(document);\n                fragments = utilities.getFragmentDefinitions(document);\n                fragmentMap = utilities.createFragmentMap(fragments);\n                selectionsToResolve = this.collectSelectionsToResolve(mainDefinition, fragmentMap);\n                definitionOperation = mainDefinition.operation;\n                defaultOperationType = definitionOperation ?\n                    definitionOperation.charAt(0).toUpperCase() +\n                        definitionOperation.slice(1)\n                    : \"Query\";\n                _a = this, cache = _a.cache, client = _a.client;\n                execContext = {\n                    fragmentMap: fragmentMap,\n                    context: tslib.__assign(tslib.__assign({}, context), { cache: cache, client: client }),\n                    variables: variables,\n                    fragmentMatcher: fragmentMatcher,\n                    defaultOperationType: defaultOperationType,\n                    exportedVariables: {},\n                    selectionsToResolve: selectionsToResolve,\n                    onlyRunForcedResolvers: onlyRunForcedResolvers,\n                };\n                isClientFieldDescendant = false;\n                return [2 , this.resolveSelectionSet(mainDefinition.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (result) { return ({\n                        result: result,\n                        exportedVariables: execContext.exportedVariables,\n                    }); })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSelectionSet = function (selectionSet, isClientFieldDescendant, rootValue, execContext) {\n        return tslib.__awaiter(this, void 0, void 0, function () {\n            var fragmentMap, context, variables, resultsToMerge, execute;\n            var _this = this;\n            return tslib.__generator(this, function (_a) {\n                fragmentMap = execContext.fragmentMap, context = execContext.context, variables = execContext.variables;\n                resultsToMerge = [rootValue];\n                execute = function (selection) { return tslib.__awaiter(_this, void 0, void 0, function () {\n                    var fragment, typeCondition;\n                    return tslib.__generator(this, function (_a) {\n                        if (!isClientFieldDescendant &&\n                            !execContext.selectionsToResolve.has(selection)) {\n                            return [2 ];\n                        }\n                        if (!utilities.shouldInclude(selection, variables)) {\n                            return [2 ];\n                        }\n                        if (utilities.isField(selection)) {\n                            return [2 , this.resolveField(selection, isClientFieldDescendant, rootValue, execContext).then(function (fieldResult) {\n                                    var _a;\n                                    if (typeof fieldResult !== \"undefined\") {\n                                        resultsToMerge.push((_a = {},\n                                            _a[utilities.resultKeyNameFromField(selection)] = fieldResult,\n                                            _a));\n                                    }\n                                })];\n                        }\n                        if (utilities.isInlineFragment(selection)) {\n                            fragment = selection;\n                        }\n                        else {\n                            fragment = fragmentMap[selection.name.value];\n                            globals.invariant(fragment, 21, selection.name.value);\n                        }\n                        if (fragment && fragment.typeCondition) {\n                            typeCondition = fragment.typeCondition.name.value;\n                            if (execContext.fragmentMatcher(rootValue, typeCondition, context)) {\n                                return [2 , this.resolveSelectionSet(fragment.selectionSet, isClientFieldDescendant, rootValue, execContext).then(function (fragmentResult) {\n                                        resultsToMerge.push(fragmentResult);\n                                    })];\n                            }\n                        }\n                        return [2 ];\n                    });\n                }); };\n                return [2 , Promise.all(selectionSet.selections.map(execute)).then(function () {\n                        return utilities.mergeDeepArray(resultsToMerge);\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveField = function (field, isClientFieldDescendant, rootValue, execContext) {\n        return tslib.__awaiter(this, void 0, void 0, function () {\n            var variables, fieldName, aliasedFieldName, aliasUsed, defaultResult, resultPromise, resolverType, resolverMap, resolve;\n            var _this = this;\n            return tslib.__generator(this, function (_a) {\n                if (!rootValue) {\n                    return [2 , null];\n                }\n                variables = execContext.variables;\n                fieldName = field.name.value;\n                aliasedFieldName = utilities.resultKeyNameFromField(field);\n                aliasUsed = fieldName !== aliasedFieldName;\n                defaultResult = rootValue[aliasedFieldName] || rootValue[fieldName];\n                resultPromise = Promise.resolve(defaultResult);\n                if (!execContext.onlyRunForcedResolvers ||\n                    this.shouldForceResolvers(field)) {\n                    resolverType = rootValue.__typename || execContext.defaultOperationType;\n                    resolverMap = this.resolvers && this.resolvers[resolverType];\n                    if (resolverMap) {\n                        resolve = resolverMap[aliasUsed ? fieldName : aliasedFieldName];\n                        if (resolve) {\n                            resultPromise = Promise.resolve(\n                            cache.cacheSlot.withValue(this.cache, resolve, [\n                                rootValue,\n                                utilities.argumentsObjectFromField(field, variables),\n                                execContext.context,\n                                { field: field, fragmentMap: execContext.fragmentMap },\n                            ]));\n                        }\n                    }\n                }\n                return [2 , resultPromise.then(function (result) {\n                        var _a, _b;\n                        if (result === void 0) { result = defaultResult; }\n                        if (field.directives) {\n                            field.directives.forEach(function (directive) {\n                                if (directive.name.value === \"export\" && directive.arguments) {\n                                    directive.arguments.forEach(function (arg) {\n                                        if (arg.name.value === \"as\" && arg.value.kind === \"StringValue\") {\n                                            execContext.exportedVariables[arg.value.value] = result;\n                                        }\n                                    });\n                                }\n                            });\n                        }\n                        if (!field.selectionSet) {\n                            return result;\n                        }\n                        if (result == null) {\n                            return result;\n                        }\n                        var isClientField = (_b = (_a = field.directives) === null || _a === void 0 ? void 0 : _a.some(function (d) { return d.name.value === \"client\"; })) !== null && _b !== void 0 ? _b : false;\n                        if (Array.isArray(result)) {\n                            return _this.resolveSubSelectedArray(field, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                        if (field.selectionSet) {\n                            return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant || isClientField, result, execContext);\n                        }\n                    })];\n            });\n        });\n    };\n    LocalState.prototype.resolveSubSelectedArray = function (field, isClientFieldDescendant, result, execContext) {\n        var _this = this;\n        return Promise.all(result.map(function (item) {\n            if (item === null) {\n                return null;\n            }\n            if (Array.isArray(item)) {\n                return _this.resolveSubSelectedArray(field, isClientFieldDescendant, item, execContext);\n            }\n            if (field.selectionSet) {\n                return _this.resolveSelectionSet(field.selectionSet, isClientFieldDescendant, item, execContext);\n            }\n        }));\n    };\n    LocalState.prototype.collectSelectionsToResolve = function (mainDefinition, fragmentMap) {\n        var isSingleASTNode = function (node) { return !Array.isArray(node); };\n        var selectionsToResolveCache = this.selectionsToResolveCache;\n        function collectByDefinition(definitionNode) {\n            if (!selectionsToResolveCache.has(definitionNode)) {\n                var matches_1 = new Set();\n                selectionsToResolveCache.set(definitionNode, matches_1);\n                graphql.visit(definitionNode, {\n                    Directive: function (node, _, __, ___, ancestors) {\n                        if (node.name.value === \"client\") {\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                        }\n                    },\n                    FragmentSpread: function (spread, _, __, ___, ancestors) {\n                        var fragment = fragmentMap[spread.name.value];\n                        globals.invariant(fragment, 22, spread.name.value);\n                        var fragmentSelections = collectByDefinition(fragment);\n                        if (fragmentSelections.size > 0) {\n                            ancestors.forEach(function (node) {\n                                if (isSingleASTNode(node) && graphql.isSelectionNode(node)) {\n                                    matches_1.add(node);\n                                }\n                            });\n                            matches_1.add(spread);\n                            fragmentSelections.forEach(function (selection) {\n                                matches_1.add(selection);\n                            });\n                        }\n                    },\n                });\n            }\n            return selectionsToResolveCache.get(definitionNode);\n        }\n        return collectByDefinition(mainDefinition);\n    };\n    return LocalState;\n}());\n\nvar cacheSizeSymbol = Symbol.for(\"apollo.cacheSize\");\nvar cacheSizes = tslib.__assign({}, globals.global[cacheSizeSymbol]);\n\nvar globalCaches = {};\nvar getApolloClientMemoryInternals = globalThis.__DEV__ !== false ?\n    _getApolloClientMemoryInternals\n    : undefined;\nfunction getCurrentCacheSizes() {\n    var defaults = {\n        parser: 1000 ,\n        canonicalStringify: 1000 ,\n        print: 2000 ,\n        \"documentTransform.cache\": 2000 ,\n        \"queryManager.getDocumentInfo\": 2000 ,\n        \"PersistedQueryLink.persistedQueryHashes\": 2000 ,\n        \"fragmentRegistry.transform\": 2000 ,\n        \"fragmentRegistry.lookup\": 1000 ,\n        \"fragmentRegistry.findFragmentSpreads\": 4000 ,\n        \"cache.fragmentQueryDocuments\": 1000 ,\n        \"removeTypenameFromVariables.getVariableDefinitions\": 2000 ,\n        \"inMemoryCache.maybeBroadcastWatch\": 5000 ,\n        \"inMemoryCache.executeSelectionSet\": 50000 ,\n        \"inMemoryCache.executeSubSelectedArray\": 10000 ,\n    };\n    return Object.fromEntries(Object.entries(defaults).map(function (_a) {\n        var k = _a[0], v = _a[1];\n        return [\n            k,\n            cacheSizes[k] || v,\n        ];\n    }));\n}\nfunction _getApolloClientMemoryInternals() {\n    var _a, _b, _c, _d, _e;\n    if (!(globalThis.__DEV__ !== false))\n        throw new Error(\"only supported in development mode\");\n    return {\n        limits: getCurrentCacheSizes(),\n        sizes: tslib.__assign({ print: (_a = globalCaches.print) === null || _a === void 0 ? void 0 : _a.call(globalCaches), parser: (_b = globalCaches.parser) === null || _b === void 0 ? void 0 : _b.call(globalCaches), canonicalStringify: (_c = globalCaches.canonicalStringify) === null || _c === void 0 ? void 0 : _c.call(globalCaches), links: linkInfo(this.link), queryManager: {\n                getDocumentInfo: this[\"queryManager\"][\"transformCache\"].size,\n                documentTransforms: transformInfo(this[\"queryManager\"].documentTransform),\n            } }, (_e = (_d = this.cache).getMemoryInternals) === null || _e === void 0 ? void 0 : _e.call(_d)),\n    };\n}\nfunction isWrapper(f) {\n    return !!f && \"dirtyKey\" in f;\n}\nfunction getWrapperInformation(f) {\n    return isWrapper(f) ? f.size : undefined;\n}\nfunction isDefined(value) {\n    return value != null;\n}\nfunction transformInfo(transform) {\n    return recurseTransformInfo(transform).map(function (cache) { return ({ cache: cache }); });\n}\nfunction recurseTransformInfo(transform) {\n    return transform ?\n        tslib.__spreadArray(tslib.__spreadArray([\n            getWrapperInformation(transform === null || transform === void 0 ? void 0 : transform[\"performWork\"])\n        ], recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform[\"left\"]), true), recurseTransformInfo(transform === null || transform === void 0 ? void 0 : transform[\"right\"]), true).filter(isDefined)\n        : [];\n}\nfunction linkInfo(link) {\n    var _a;\n    return link ?\n        tslib.__spreadArray(tslib.__spreadArray([\n            (_a = link === null || link === void 0 ? void 0 : link.getMemoryInternals) === null || _a === void 0 ? void 0 : _a.call(link)\n        ], linkInfo(link === null || link === void 0 ? void 0 : link.left), true), linkInfo(link === null || link === void 0 ? void 0 : link.right), true).filter(isDefined)\n        : [];\n}\n\nvar hasSuggestedDevtools = false;\nvar ApolloClient =  (function () {\n    function ApolloClient(options) {\n        var _this = this;\n        var _a, _b, _c;\n        this.resetStoreCallbacks = [];\n        this.clearStoreCallbacks = [];\n        if (!options.cache) {\n            throw globals.newInvariantError(16);\n        }\n        var uri = options.uri, credentials = options.credentials, headers = options.headers, cache = options.cache, documentTransform = options.documentTransform, _d = options.ssrMode, ssrMode = _d === void 0 ? false : _d, _e = options.ssrForceFetchDelay, ssrForceFetchDelay = _e === void 0 ? 0 : _e,\n        connectToDevTools = options.connectToDevTools, _f = options.queryDeduplication, queryDeduplication = _f === void 0 ? true : _f, defaultOptions = options.defaultOptions, defaultContext = options.defaultContext, _g = options.assumeImmutableResults, assumeImmutableResults = _g === void 0 ? cache.assumeImmutableResults : _g, resolvers = options.resolvers, typeDefs = options.typeDefs, fragmentMatcher = options.fragmentMatcher, clientAwareness = options.clientAwareness, clientAwarenessName = options.name, clientAwarenessVersion = options.version, devtools = options.devtools, dataMasking = options.dataMasking;\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"connectToDevTools\", \"ApolloClient\", \"Please use `devtools.enabled` instead.\");\n            warnRemovedOption(options, \"uri\", \"ApolloClient\", \"Please initialize an instance of `HttpLink` with `uri` instead.\");\n            warnRemovedOption(options, \"credentials\", \"ApolloClient\", \"Please initialize an instance of `HttpLink` with `credentials` instead.\");\n            warnRemovedOption(options, \"headers\", \"ApolloClient\", \"Please initialize an instance of `HttpLink` with `headers` instead.\");\n            warnRemovedOption(options, \"name\", \"ApolloClient\", \"Please use the `clientAwareness.name` option instead.\");\n            warnRemovedOption(options, \"version\", \"ApolloClient\", \"Please use the `clientAwareness.version` option instead.\");\n            warnRemovedOption(options, \"typeDefs\", \"ApolloClient\");\n            if (!options.link) {\n                globalThis.__DEV__ !== false && globals.invariant.warn(17);\n            }\n        }\n        var link = options.link;\n        if (!link) {\n            link =\n                uri ? new http.HttpLink({ uri: uri, credentials: credentials, headers: headers }) : core.ApolloLink.empty();\n        }\n        this.link = link;\n        this.cache = cache;\n        this.disableNetworkFetches = ssrMode || ssrForceFetchDelay > 0;\n        this.queryDeduplication = queryDeduplication;\n        this.defaultOptions = defaultOptions || Object.create(null);\n        this.typeDefs = typeDefs;\n        this.devtoolsConfig = tslib.__assign(tslib.__assign({}, devtools), { enabled: (_a = devtools === null || devtools === void 0 ? void 0 : devtools.enabled) !== null && _a !== void 0 ? _a : connectToDevTools });\n        if (this.devtoolsConfig.enabled === undefined) {\n            this.devtoolsConfig.enabled = globalThis.__DEV__ !== false;\n        }\n        if (ssrForceFetchDelay) {\n            setTimeout(function () { return (_this.disableNetworkFetches = false); }, ssrForceFetchDelay);\n        }\n        this.watchQuery = this.watchQuery.bind(this);\n        this.query = this.query.bind(this);\n        this.mutate = this.mutate.bind(this);\n        this.watchFragment = this.watchFragment.bind(this);\n        this.resetStore = this.resetStore.bind(this);\n        this.reFetchObservableQueries = this.reFetchObservableQueries.bind(this);\n        this.version = version;\n        this.localState = new LocalState({\n            cache: cache,\n            client: this,\n            resolvers: resolvers,\n            fragmentMatcher: fragmentMatcher,\n        });\n        this.queryManager = new QueryManager({\n            cache: this.cache,\n            link: this.link,\n            defaultOptions: this.defaultOptions,\n            defaultContext: defaultContext,\n            documentTransform: documentTransform,\n            queryDeduplication: queryDeduplication,\n            ssrMode: ssrMode,\n            dataMasking: !!dataMasking,\n            clientAwareness: {\n                name: (_b = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.name) !== null && _b !== void 0 ? _b : clientAwarenessName,\n                version: (_c = clientAwareness === null || clientAwareness === void 0 ? void 0 : clientAwareness.version) !== null && _c !== void 0 ? _c : clientAwarenessVersion,\n            },\n            localState: this.localState,\n            assumeImmutableResults: assumeImmutableResults,\n            onBroadcast: this.devtoolsConfig.enabled ?\n                function () {\n                    if (_this.devToolsHookCb) {\n                        _this.devToolsHookCb({\n                            action: {},\n                            state: {\n                                queries: _this.queryManager.getQueryStore(),\n                                mutations: _this.queryManager.mutationStore || {},\n                            },\n                            dataWithOptimisticResults: _this.cache.extract(true),\n                        });\n                    }\n                }\n                : void 0,\n        });\n        if (this.devtoolsConfig.enabled)\n            this.connectToDevTools();\n    }\n    Object.defineProperty(ApolloClient.prototype, \"prioritizeCacheValues\", {\n        get: function () {\n            return this.disableNetworkFetches;\n        },\n        set: function (value) {\n            this.disableNetworkFetches = value;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ApolloClient.prototype.connectToDevTools = function () {\n        if (typeof window === \"undefined\") {\n            return;\n        }\n        var windowWithDevTools = window;\n        var devtoolsSymbol = Symbol.for(\"apollo.devtools\");\n        (windowWithDevTools[devtoolsSymbol] =\n            windowWithDevTools[devtoolsSymbol] || []).push(this);\n        windowWithDevTools.__APOLLO_CLIENT__ = this;\n        if (!hasSuggestedDevtools && globalThis.__DEV__ !== false) {\n            hasSuggestedDevtools = true;\n            if (window.document &&\n                window.top === window.self &&\n                /^(https?|file):$/.test(window.location.protocol)) {\n                setTimeout(function () {\n                    if (!window.__APOLLO_DEVTOOLS_GLOBAL_HOOK__) {\n                        var nav = window.navigator;\n                        var ua = nav && nav.userAgent;\n                        var url = void 0;\n                        if (typeof ua === \"string\") {\n                            if (ua.indexOf(\"Chrome/\") > -1) {\n                                url =\n                                    \"https://chrome.google.com/webstore/detail/\" +\n                                        \"apollo-client-developer-t/jdkknkkbebbapilgoeccciglkfbmbnfm\";\n                            }\n                            else if (ua.indexOf(\"Firefox/\") > -1) {\n                                url =\n                                    \"https://addons.mozilla.org/en-US/firefox/addon/apollo-developer-tools/\";\n                            }\n                        }\n                        if (url) {\n                            globalThis.__DEV__ !== false && globals.invariant.log(\"Download the Apollo DevTools for a better development \" +\n                                \"experience: %s\", url);\n                        }\n                    }\n                }, 10000);\n            }\n        }\n    };\n    Object.defineProperty(ApolloClient.prototype, \"documentTransform\", {\n        get: function () {\n            return this.queryManager.documentTransform;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    ApolloClient.prototype.stop = function () {\n        this.queryManager.stop();\n    };\n    ApolloClient.prototype.watchQuery = function (options) {\n        if (this.defaultOptions.watchQuery) {\n            options = utilities.mergeOptions(this.defaultOptions.watchQuery, options);\n        }\n        if (this.disableNetworkFetches &&\n            (options.fetchPolicy === \"network-only\" ||\n                options.fetchPolicy === \"cache-and-network\")) {\n            options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"client.watchQuery\");\n            warnRemovedOption(options, \"partialRefetch\", \"client.watchQuery\");\n        }\n        return this.queryManager.watchQuery(options);\n    };\n    ApolloClient.prototype.query = function (options) {\n        if (this.defaultOptions.query) {\n            options = utilities.mergeOptions(this.defaultOptions.query, options);\n        }\n        globals.invariant(options.fetchPolicy !== \"cache-and-network\", 18);\n        if (this.disableNetworkFetches && options.fetchPolicy === \"network-only\") {\n            options = tslib.__assign(tslib.__assign({}, options), { fetchPolicy: \"cache-first\" });\n        }\n        if (globalThis.__DEV__ !== false) {\n            warnRemovedOption(options, \"canonizeResults\", \"client.query\");\n            warnRemovedOption(options, \"notifyOnNetworkStatusChange\", \"client.query\", \"This option does not affect `client.query` and can be safely removed.\");\n            if (options.fetchPolicy === \"standby\") {\n                globalThis.__DEV__ !== false && globals.invariant.warn(19);\n            }\n        }\n        return this.queryManager.query(options);\n    };\n    ApolloClient.prototype.mutate = function (options) {\n        if (this.defaultOptions.mutate) {\n            options = utilities.mergeOptions(this.defaultOptions.mutate, options);\n        }\n        return this.queryManager.mutate(options);\n    };\n    ApolloClient.prototype.subscribe = function (options) {\n        var _this = this;\n        var id = this.queryManager.generateQueryId();\n        return this.queryManager\n            .startGraphQLSubscription(options)\n            .map(function (result) { return (tslib.__assign(tslib.__assign({}, result), { data: _this.queryManager.maskOperation({\n                document: options.query,\n                data: result.data,\n                fetchPolicy: options.fetchPolicy,\n                id: id,\n            }) })); });\n    };\n    ApolloClient.prototype.readQuery = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readQuery(options, optimistic);\n    };\n    ApolloClient.prototype.watchFragment = function (options) {\n        var _a;\n        return this.cache.watchFragment(tslib.__assign(tslib.__assign({}, options), (_a = {}, _a[Symbol.for(\"apollo.dataMasking\")] = this.queryManager.dataMasking, _a)));\n    };\n    ApolloClient.prototype.readFragment = function (options, optimistic) {\n        if (optimistic === void 0) { optimistic = false; }\n        return this.cache.readFragment(options, optimistic);\n    };\n    ApolloClient.prototype.writeQuery = function (options) {\n        var ref = this.cache.writeQuery(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    ApolloClient.prototype.writeFragment = function (options) {\n        var ref = this.cache.writeFragment(options);\n        if (options.broadcast !== false) {\n            this.queryManager.broadcastQueries();\n        }\n        return ref;\n    };\n    ApolloClient.prototype.__actionHookForDevTools = function (cb) {\n        this.devToolsHookCb = cb;\n    };\n    ApolloClient.prototype.__requestRaw = function (payload) {\n        return core.execute(this.link, payload);\n    };\n    ApolloClient.prototype.resetStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: false,\n            });\n        })\n            .then(function () { return Promise.all(_this.resetStoreCallbacks.map(function (fn) { return fn(); })); })\n            .then(function () { return _this.reFetchObservableQueries(); });\n    };\n    ApolloClient.prototype.clearStore = function () {\n        var _this = this;\n        return Promise.resolve()\n            .then(function () {\n            return _this.queryManager.clearStore({\n                discardWatches: true,\n            });\n        })\n            .then(function () { return Promise.all(_this.clearStoreCallbacks.map(function (fn) { return fn(); })); });\n    };\n    ApolloClient.prototype.onResetStore = function (cb) {\n        var _this = this;\n        this.resetStoreCallbacks.push(cb);\n        return function () {\n            _this.resetStoreCallbacks = _this.resetStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.onClearStore = function (cb) {\n        var _this = this;\n        this.clearStoreCallbacks.push(cb);\n        return function () {\n            _this.clearStoreCallbacks = _this.clearStoreCallbacks.filter(function (c) { return c !== cb; });\n        };\n    };\n    ApolloClient.prototype.reFetchObservableQueries = function (includeStandby) {\n        return this.queryManager.reFetchObservableQueries(includeStandby);\n    };\n    ApolloClient.prototype.refetchQueries = function (options) {\n        var map = this.queryManager.refetchQueries(options);\n        var queries = [];\n        var results = [];\n        map.forEach(function (result, obsQuery) {\n            queries.push(obsQuery);\n            results.push(result);\n        });\n        var result = Promise.all(results);\n        result.queries = queries;\n        result.results = results;\n        result.catch(function (error) {\n            globalThis.__DEV__ !== false && globals.invariant.debug(20, error);\n        });\n        return result;\n    };\n    ApolloClient.prototype.getObservableQueries = function (include) {\n        if (include === void 0) { include = \"active\"; }\n        return this.queryManager.getObservableQueries(include);\n    };\n    ApolloClient.prototype.extract = function (optimistic) {\n        return this.cache.extract(optimistic);\n    };\n    ApolloClient.prototype.restore = function (serializedState) {\n        return this.cache.restore(serializedState);\n    };\n    ApolloClient.prototype.addResolvers = function (resolvers) {\n        this.localState.addResolvers(resolvers);\n    };\n    ApolloClient.prototype.setResolvers = function (resolvers) {\n        this.localState.setResolvers(resolvers);\n    };\n    ApolloClient.prototype.getResolvers = function () {\n        return this.localState.getResolvers();\n    };\n    ApolloClient.prototype.setLocalStateFragmentMatcher = function (fragmentMatcher) {\n        this.localState.setFragmentMatcher(fragmentMatcher);\n    };\n    ApolloClient.prototype.setLink = function (newLink) {\n        this.link = this.queryManager.link = newLink;\n    };\n    Object.defineProperty(ApolloClient.prototype, \"defaultContext\", {\n        get: function () {\n            return this.queryManager.defaultContext;\n        },\n        enumerable: false,\n        configurable: true\n    });\n    return ApolloClient;\n}());\nif (globalThis.__DEV__ !== false) {\n    ApolloClient.prototype.getMemoryInternals = getApolloClientMemoryInternals;\n}\n\ntsInvariant.setVerbosity(globalThis.__DEV__ !== false ? \"log\" : \"silent\");\n\nexports.DocumentTransform = utilities.DocumentTransform;\nexports.Observable = utilities.Observable;\nexports.isReference = utilities.isReference;\nexports.makeReference = utilities.makeReference;\nexports.mergeOptions = utilities.mergeOptions;\nexports.ApolloCache = cache.ApolloCache;\nexports.Cache = cache.Cache;\nexports.InMemoryCache = cache.InMemoryCache;\nexports.MissingFieldError = cache.MissingFieldError;\nexports.defaultDataIdFromObject = cache.defaultDataIdFromObject;\nexports.makeVar = cache.makeVar;\nexports.ApolloError = errors.ApolloError;\nexports.isApolloError = errors.isApolloError;\nexports.fromError = utils.fromError;\nexports.fromPromise = utils.fromPromise;\nexports.throwServerError = utils.throwServerError;\nexports.toPromise = utils.toPromise;\nexports.setLogVerbosity = tsInvariant.setVerbosity;\nexports.disableExperimentalFragmentVariables = graphqlTag.disableExperimentalFragmentVariables;\nexports.disableFragmentWarnings = graphqlTag.disableFragmentWarnings;\nexports.enableExperimentalFragmentVariables = graphqlTag.enableExperimentalFragmentVariables;\nexports.gql = graphqlTag.gql;\nexports.resetCaches = graphqlTag.resetCaches;\nexports.ApolloClient = ApolloClient;\nexports.ObservableQuery = ObservableQuery;\nexports.isNetworkRequestSettled = isNetworkRequestSettled;\nfor (var k in core) {\n    if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];\n}\nfor (var k in http) {\n    if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = http[k];\n}\n//# sourceMappingURL=core.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar utilities = require('../../utilities');\nvar tslib = require('tslib');\nvar graphql = require('graphql');\n\nfunction fromError(errorValue) {\n    return new utilities.Observable(function (observer) {\n        observer.error(errorValue);\n    });\n}\n\nfunction toPromise(observable) {\n    var completed = false;\n    return new Promise(function (resolve, reject) {\n        observable.subscribe({\n            next: function (data) {\n                if (completed) {\n                    globalThis.__DEV__ !== false && globals.invariant.warn(57);\n                }\n                else {\n                    completed = true;\n                    resolve(data);\n                }\n            },\n            error: reject,\n        });\n    });\n}\n\nfunction fromPromise(promise) {\n    return new utilities.Observable(function (observer) {\n        promise\n            .then(function (value) {\n            observer.next(value);\n            observer.complete();\n        })\n            .catch(observer.error.bind(observer));\n    });\n}\n\nvar throwServerError = function (response, result, message) {\n    var error = new Error(message);\n    error.name = \"ServerError\";\n    error.response = response;\n    error.statusCode = response.status;\n    error.result = result;\n    throw error;\n};\n\nfunction validateOperation(operation) {\n    var OPERATION_FIELDS = [\n        \"query\",\n        \"operationName\",\n        \"variables\",\n        \"extensions\",\n        \"context\",\n    ];\n    for (var _i = 0, _a = Object.keys(operation); _i < _a.length; _i++) {\n        var key = _a[_i];\n        if (OPERATION_FIELDS.indexOf(key) < 0) {\n            throw globals.newInvariantError(58, key);\n        }\n    }\n    return operation;\n}\n\nfunction createOperation(starting, operation) {\n    var context = tslib.__assign({}, starting);\n    var setContext = function (next) {\n        if (typeof next === \"function\") {\n            context = tslib.__assign(tslib.__assign({}, context), next(context));\n        }\n        else {\n            context = tslib.__assign(tslib.__assign({}, context), next);\n        }\n    };\n    var getContext = function () { return (tslib.__assign({}, context)); };\n    Object.defineProperty(operation, \"setContext\", {\n        enumerable: false,\n        value: setContext,\n    });\n    Object.defineProperty(operation, \"getContext\", {\n        enumerable: false,\n        value: getContext,\n    });\n    return operation;\n}\n\nfunction transformOperation(operation) {\n    var transformedOperation = {\n        variables: operation.variables || {},\n        extensions: operation.extensions || {},\n        operationName: operation.operationName,\n        query: operation.query,\n    };\n    if (!transformedOperation.operationName) {\n        transformedOperation.operationName =\n            typeof transformedOperation.query !== \"string\" ?\n                utilities.getOperationName(transformedOperation.query) || undefined\n                : \"\";\n    }\n    return transformedOperation;\n}\n\nfunction filterOperationVariables(variables, query) {\n    var result = tslib.__assign({}, variables);\n    var unusedNames = new Set(Object.keys(variables));\n    graphql.visit(query, {\n        Variable: function (node, _key, parent) {\n            if (parent &&\n                parent.kind !== \"VariableDefinition\") {\n                unusedNames.delete(node.name.value);\n            }\n        },\n    });\n    unusedNames.forEach(function (name) {\n        delete result[name];\n    });\n    return result;\n}\n\nexports.createOperation = createOperation;\nexports.filterOperationVariables = filterOperationVariables;\nexports.fromError = fromError;\nexports.fromPromise = fromPromise;\nexports.throwServerError = throwServerError;\nexports.toPromise = toPromise;\nexports.transformOperation = transformOperation;\nexports.validateOperation = validateOperation;\n//# sourceMappingURL=utils.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../../utilities/globals');\nvar utilities = require('../../utilities');\nvar utils = require('../utils');\nrequire('tslib');\nvar optimism = require('optimism');\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nfunction passthrough(op, forward) {\n    return (forward ? forward(op) : utilities.Observable.of());\n}\nfunction toLink(handler) {\n    return typeof handler === \"function\" ? new ApolloLink(handler) : handler;\n}\nfunction isTerminating(link) {\n    return link.request.length <= 1;\n}\nvar ApolloLink =  (function () {\n    function ApolloLink(request) {\n        if (request)\n            this.request = request;\n    }\n    ApolloLink.empty = function () {\n        return new ApolloLink(function () { return utilities.Observable.of(); });\n    };\n    ApolloLink.from = function (links) {\n        if (links.length === 0)\n            return ApolloLink.empty();\n        return links.map(toLink).reduce(function (x, y) { return x.concat(y); });\n    };\n    ApolloLink.split = function (test, left, right) {\n        var leftLink = toLink(left);\n        var rightLink = toLink(right || new ApolloLink(passthrough));\n        var ret;\n        if (isTerminating(leftLink) && isTerminating(rightLink)) {\n            ret = new ApolloLink(function (operation) {\n                return test(operation) ?\n                    leftLink.request(operation) || utilities.Observable.of()\n                    : rightLink.request(operation) || utilities.Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return test(operation) ?\n                    leftLink.request(operation, forward) || utilities.Observable.of()\n                    : rightLink.request(operation, forward) || utilities.Observable.of();\n            });\n        }\n        return Object.assign(ret, { left: leftLink, right: rightLink });\n    };\n    ApolloLink.execute = function (link, operation) {\n        return (link.request(utils.createOperation(operation.context, utils.transformOperation(utils.validateOperation(operation)))) || utilities.Observable.of());\n    };\n    ApolloLink.concat = function (first, second) {\n        var firstLink = toLink(first);\n        if (isTerminating(firstLink)) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(47, firstLink);\n            return firstLink;\n        }\n        var nextLink = toLink(second);\n        var ret;\n        if (isTerminating(nextLink)) {\n            ret = new ApolloLink(function (operation) {\n                return firstLink.request(operation, function (op) { return nextLink.request(op) || utilities.Observable.of(); }) || utilities.Observable.of();\n            });\n        }\n        else {\n            ret = new ApolloLink(function (operation, forward) {\n                return (firstLink.request(operation, function (op) {\n                    return nextLink.request(op, forward) || utilities.Observable.of();\n                }) || utilities.Observable.of());\n            });\n        }\n        return Object.assign(ret, { left: firstLink, right: nextLink });\n    };\n    ApolloLink.prototype.split = function (test, left, right) {\n        return this.concat(ApolloLink.split(test, left, right || new ApolloLink(passthrough)));\n    };\n    ApolloLink.prototype.concat = function (next) {\n        return ApolloLink.concat(this, next);\n    };\n    ApolloLink.prototype.request = function (operation, forward) {\n        throw globals.newInvariantError(48);\n    };\n    ApolloLink.prototype.onError = function (error, observer) {\n        if (globalThis.__DEV__ !== false) {\n            warnDeprecated(\"onError\", function () {\n                globalThis.__DEV__ !== false && globals.invariant.warn(49);\n            });\n        }\n        if (observer && observer.error) {\n            observer.error(error);\n            return false;\n        }\n        throw error;\n    };\n    ApolloLink.prototype.setOnError = function (fn) {\n        if (globalThis.__DEV__ !== false) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(50);\n        }\n        this.onError = fn;\n        return this;\n    };\n    return ApolloLink;\n}());\n\nvar empty = ApolloLink.empty;\n\nvar from = ApolloLink.from;\n\nvar split = ApolloLink.split;\n\nvar concat = ApolloLink.concat;\n\nvar execute = ApolloLink.execute;\n\nexports.ApolloLink = ApolloLink;\nexports.concat = concat;\nexports.empty = empty;\nexports.execute = execute;\nexports.from = from;\nexports.split = split;\n//# sourceMappingURL=core.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nrequire('../utilities/globals');\nvar utilities = require('../utilities');\n\nvar PROTOCOL_ERRORS_SYMBOL = Symbol();\nfunction graphQLResultHasProtocolErrors(result) {\n    if (result.extensions) {\n        return Array.isArray(result.extensions[PROTOCOL_ERRORS_SYMBOL]);\n    }\n    return false;\n}\nfunction isApolloError(err) {\n    return err.hasOwnProperty(\"graphQLErrors\");\n}\nvar generateErrorMessage = function (err) {\n    var errors = tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([], err.graphQLErrors, true), err.clientErrors, true), err.protocolErrors, true);\n    if (err.networkError)\n        errors.push(err.networkError);\n    return (errors\n        .map(function (err) {\n        return (utilities.isNonNullObject(err) && err.message) || \"Error message not found.\";\n    })\n        .join(\"\\n\"));\n};\nvar ApolloError =  (function (_super) {\n    tslib.__extends(ApolloError, _super);\n    function ApolloError(_a) {\n        var graphQLErrors = _a.graphQLErrors, protocolErrors = _a.protocolErrors, clientErrors = _a.clientErrors, networkError = _a.networkError, errorMessage = _a.errorMessage, extraInfo = _a.extraInfo;\n        var _this = _super.call(this, errorMessage) || this;\n        _this.name = \"ApolloError\";\n        _this.graphQLErrors = graphQLErrors || [];\n        _this.protocolErrors = protocolErrors || [];\n        _this.clientErrors = clientErrors || [];\n        _this.networkError = networkError || null;\n        _this.message = errorMessage || generateErrorMessage(_this);\n        _this.extraInfo = extraInfo;\n        _this.cause =\n            tslib.__spreadArray(tslib.__spreadArray(tslib.__spreadArray([\n                networkError\n            ], (graphQLErrors || []), true), (protocolErrors || []), true), (clientErrors || []), true).find(function (e) { return !!e; }) || null;\n        _this.__proto__ = ApolloError.prototype;\n        return _this;\n    }\n    return ApolloError;\n}(Error));\n\nexports.ApolloError = ApolloError;\nexports.PROTOCOL_ERRORS_SYMBOL = PROTOCOL_ERRORS_SYMBOL;\nexports.graphQLResultHasProtocolErrors = graphQLResultHasProtocolErrors;\nexports.isApolloError = isApolloError;\n//# sourceMappingURL=errors.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar core = require('./core');\nvar react = require('./react');\n\n\n\nfor (var k in core) {\n\tif (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = core[k];\n}\nfor (var k in react) {\n\tif (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = react[k];\n}\n//# sourceMappingURL=main.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar globals = require('../utilities/globals');\nvar context = require('./context');\nvar hooks = require('./hooks');\nvar parser = require('./parser');\nvar tslib = require('tslib');\nvar internal = require('./internal');\nvar optimism = require('optimism');\n\nvar muteAllDeprecations = Symbol.for(\"apollo.deprecations\");\nvar global = globals.global;\nvar slot = new optimism.Slot();\nfunction isMuted(name) {\n    return global[muteAllDeprecations] || (slot.getValue() || []).includes(name);\n}\nfunction muteDeprecations(name) {\n    var args = [];\n    for (var _i = 1; _i < arguments.length; _i++) {\n        args[_i - 1] = arguments[_i];\n    }\n    return slot.withValue.apply(slot, tslib.__spreadArray([Array.isArray(name) ? name : [name]], args, false));\n}\nfunction warnRemovedOption(options, name, callSite, recommendation) {\n    if (recommendation === void 0) { recommendation = \"Please remove this option.\"; }\n    warnDeprecated(name, function () {\n        if (name in options) {\n            globalThis.__DEV__ !== false && globals.invariant.warn(104, callSite, name, recommendation);\n        }\n    });\n}\nfunction warnDeprecated(name, cb) {\n    if (!isMuted(name)) {\n        cb();\n    }\n}\n\nvar wrapperSymbol = Symbol.for(\"apollo.hook.wrappers\");\nfunction wrapHook(hookName, useHook, clientOrObsQuery) {\n    var queryManager = clientOrObsQuery[\"queryManager\"];\n    var wrappers = queryManager && queryManager[wrapperSymbol];\n    var wrapper = wrappers && wrappers[hookName];\n    return wrapper ? wrapper(useHook) : useHook;\n}\n\nfunction createQueryPreloader(client) {\n    return wrapHook(\"createQueryPreloader\", _createQueryPreloader, client)(client);\n}\nvar _createQueryPreloader = function (client) {\n    function preloadQuery(query, options) {\n        if (options === void 0) { options = Object.create(null); }\n        warnRemovedOption(options, \"canonizeResults\", \"preloadQuery\");\n        var queryRef = muteDeprecations(\"canonizeResults\", function () {\n            var _a, _b;\n            return new internal.InternalQueryReference(client.watchQuery(tslib.__assign(tslib.__assign({}, options), { query: query })), {\n                autoDisposeTimeoutMs: (_b = (_a = client.defaultOptions.react) === null || _a === void 0 ? void 0 : _a.suspense) === null || _b === void 0 ? void 0 : _b.autoDisposeTimeoutMs,\n            });\n        });\n        return internal.wrapQueryRef(queryRef);\n    }\n    return Object.assign(preloadQuery, {\n        toPromise: function (queryRef) {\n            return queryRef.toPromise();\n        },\n    });\n};\n\nexports.ApolloConsumer = context.ApolloConsumer;\nexports.ApolloProvider = context.ApolloProvider;\nexports.getApolloContext = context.getApolloContext;\nexports.resetApolloContext = context.resetApolloContext;\nexports.DocumentType = parser.DocumentType;\nexports.operationName = parser.operationName;\nexports.parser = parser.parser;\nexports.createQueryPreloader = createQueryPreloader;\nfor (var k in hooks) {\n    if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = hooks[k];\n}\n//# sourceMappingURL=react.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar core = require('../core');\nvar utilities = require('../../utilities');\n\nfunction setContext(setter) {\n    return new core.ApolloLink(function (operation, forward) {\n        var request = tslib.__rest(operation, []);\n        return new utilities.Observable(function (observer) {\n            var handle;\n            var closed = false;\n            Promise.resolve(request)\n                .then(function (req) { return setter(req, operation.getContext()); })\n                .then(operation.setContext)\n                .then(function () {\n                if (closed)\n                    return;\n                handle = forward(operation).subscribe({\n                    next: observer.next.bind(observer),\n                    error: observer.error.bind(observer),\n                    complete: observer.complete.bind(observer),\n                });\n            })\n                .catch(observer.error.bind(observer));\n            return function () {\n                closed = true;\n                if (handle)\n                    handle.unsubscribe();\n            };\n        });\n    });\n}\n\nexports.setContext = setContext;\n//# sourceMappingURL=context.cjs.map\n","'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nvar tslib = require('tslib');\nvar errors = require('../../errors');\nvar utilities = require('../../utilities');\nvar core = require('../core');\n\nfunction onError(errorHandler) {\n    return new core.ApolloLink(function (operation, forward) {\n        return new utilities.Observable(function (observer) {\n            var sub;\n            var retriedSub;\n            var retriedResult;\n            try {\n                sub = forward(operation).subscribe({\n                    next: function (result) {\n                        if (result.errors) {\n                            retriedResult = errorHandler({\n                                graphQLErrors: result.errors,\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                        }\n                        else if (errors.graphQLResultHasProtocolErrors(result)) {\n                            retriedResult = errorHandler({\n                                protocolErrors: result.extensions[errors.PROTOCOL_ERRORS_SYMBOL],\n                                response: result,\n                                operation: operation,\n                                forward: forward,\n                            });\n                        }\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.next(result);\n                    },\n                    error: function (networkError) {\n                        retriedResult = errorHandler({\n                            operation: operation,\n                            networkError: networkError,\n                            graphQLErrors: (networkError &&\n                                networkError.result &&\n                                networkError.result.errors) ||\n                                void 0,\n                            forward: forward,\n                        });\n                        if (retriedResult) {\n                            retriedSub = retriedResult.subscribe({\n                                next: observer.next.bind(observer),\n                                error: observer.error.bind(observer),\n                                complete: observer.complete.bind(observer),\n                            });\n                            return;\n                        }\n                        observer.error(networkError);\n                    },\n                    complete: function () {\n                        if (!retriedResult) {\n                            observer.complete.bind(observer)();\n                        }\n                    },\n                });\n            }\n            catch (e) {\n                errorHandler({ networkError: e, operation: operation, forward: forward });\n                observer.error(e);\n            }\n            return function () {\n                if (sub)\n                    sub.unsubscribe();\n                if (retriedSub)\n                    sub.unsubscribe();\n            };\n        });\n    });\n}\nvar ErrorLink =  (function (_super) {\n    tslib.__extends(ErrorLink, _super);\n    function ErrorLink(errorHandler) {\n        var _this = _super.call(this) || this;\n        _this.link = onError(errorHandler);\n        return _this;\n    }\n    ErrorLink.prototype.request = function (operation, forward) {\n        return this.link.request(operation, forward);\n    };\n    return ErrorLink;\n}(core.ApolloLink));\n\nexports.ErrorLink = ErrorLink;\nexports.onError = onError;\n//# sourceMappingURL=error.cjs.map\n"],"names":["Object","defineProperty","exports","value","globals","React","utilities","tslib","_interopNamespace","e","__esModule","n","create","k","freeze","React__namespace","contextKey","canUseSymbol","Symbol","for","getApolloContext","invariant","context","createContext","enumerable","writable","configurable","displayName","ApolloConsumer","props","ApolloContext","createElement","Consumer","client","children","ApolloProvider","_a","parentContext","useContext","useMemo","__assign","Provider","resetApolloContext","globalThis","__DEV__","warn","optimism","globalCaches","DocumentType","cache","getSize","muteAllDeprecations","global","slot","Slot","warnDeprecated","name","cb","getValue","includes","isMuted","operationName","type","Query","Mutation","Subscription","parser","document","AutoCleanedWeakCache","cacheSizes","variables","cached","get","kind","fragments","queries","mutations","subscriptions","_i","definitions","length","x","operation","push","definition","variableDefinitions","payload","set","resetCache","undefined","size","verifyDocumentType","args","arguments","withValue","apply","__spreadArray","Array","isArray","muteDeprecations","requiredOperationName","usedOperationName","graphql","_interopDefaultLegacy","equal__default","MapImpl","canUseWeakMap","WeakMap","Map","SetImpl","canUseWeakSet","WeakSet","Set","disableWarningsSlot","issuedWarning","warnOnImproperCacheImplementation","maskDefinition","data","selectionSet","masked","maskSelectionSet","isFrozen","maybeDeepFreeze","migration","path","knownChanged","memo","mutableTargets","has","mutableTarget","getMutableTarget","_b","from","entries","_c","index","item","concat","add","_d","_e","selections","selection","Kind","FIELD","keyName","resultKeyNameFromField","childSelectionSet","getOwnPropertyDescriptor","getAccessorWarningDescriptor","operationType","INLINE_FRAGMENT","typeCondition","fragmentMatches","__typename","FRAGMENT_SPREAD","fragmentName","fragment","fragmentMap","lookupFragment","mode","getFragmentMaskMode","keys","fieldName","replace","newValue","maskFragment","filter","node","FRAGMENT_DEFINITION","find","createFragmentMap","getFragmentDefinitions","maskOperation","getOperationDefinition","utils","errors","core","nodeStreamIterator","stream","cleanup","error","done","waiting","onData","chunk","shiftedArr","shift","onError","err","slice","forEach","pair","onEnd","removeListener","on","iterator","next","Promise","resolve","reject","canUseAsyncIteratorSymbol","asyncIterator","this","readerIterator","reader","read","responseIterator","response","body","isAsyncIterableIterator","getReader","isReadableStream","isStreamableBlob","arrayBuffer","isBlob","promise","resolved","then","catch","promiseIterator","pipe","isNodeReadableStream","Error","isApolloPayloadResult","obj","hasOwnProperty","prototype","parseHeaders","headerText","headersInit","split","line","i","indexOf","name_1","trim","toLowerCase","parseJsonBody","bodyText","status","throwServerError","JSON","parse","getResult","parseError","statusCode","parseAndCheckHttpResponse","operations","text","result","call","map","op","serializeFetchParameter","p","label","serialized","stringify","newInvariantError","message","fallbackHttpConfig","http","includeQuery","includeExtensions","preserveHeaderCase","headers","accept","options","method","defaultPrinter","ast","printer","selectHttpOptionsAndBodyInternal","configs","config","credentials","normalizedHeaders_1","headerData","originalName","normalizedHeaders","removeDuplicateHeaders","extensions","query","print","checkFetcher","fetcher","fetch","selectURI","fallbackURI","contextURI","getContext","uri","rewriteURIForGET","chosenURI","queryParams","addQueryParam","key","encodeURIComponent","serializedVariables","serializedExtensions","preFragment","fragmentStart","substr","queryParamsPrefix","newURI","join","backupFetch","maybe","createHttpLink","linkOptions","preferredFetch","useGETForQueries","includeUnusedVariables","requestOptions","__rest","linkConfig","fetchOptions","ApolloLink","clientAwarenessHeaders","clientAwareness","version","contextHeaders","contextConfig","hasDirectives","transformedQuery","removeClientSetsFromDocument","fromError","controller","filterOperationVariables","signal","AbortController","d","isSubscription","getMainDefinition","hasDefer","some","acceptHeader","Observable","observer","currentFetch","observerNext","bind","setContext","ctype","test","nextValue","__awaiter","decoder","contentType","delimiter","boundaryVal","boundary","buffer","running","searchFrom","bi","contentType_1","__generator","TextDecoder","substring","sent","decode","PROTOCOL_ERRORS_SYMBOL","hasNext","readMultipartBody","complete","handleError","abort","HttpLink","_super","_this","request","__extends","createSignalIfSupported","selectHttpOptionsAndBody","fallbackConfig","unshift","trie","caches","zenObservableTs","names","root","all","nameSet","uniqueCount","visit","Directive","delete","BREAK","getInclusionDirectives","directives","directive","directiveArguments","directiveName","ifArgument","ifValue","isReactNative","navigator","product","g","HermesInternal","canUseDOM","window","usingJSDOM","userAgent","canUseLayoutEffect","isNonNullObject","isPlainObject","getPrototypeOf","symTable","getFragmentFromSelection","scheduledCleanup","schedule","max","setTimeout","clean","dispose","WeakCache","ret","AutoCleanedStrongCache","StrongCache","cacheSizeSymbol","registerGlobalCache","sortingMap","canonicalStringify","assign","stableObjectReplacer","reset","proto","every","everyKeyInOrder","unsortedKey","sortedKeys","sort","sortedKey","sortedObject_1","valueToObjectRepresentation","argObj","isIntValue","isFloatValue","Number","isBooleanValue","isStringValue","isObjectValue","nestedArgObj_1","fields","isVariable","variableValue","isListValue","values","listValue","nestedArgArrayObj","isEnumValue","isNullValue","KNOWN_DIRECTIVES","storeKeyNameStringify","getStoreKeyName","filterKeys","filteredArgs_1","completeFieldName","stringifiedArgs","setStringify","s","previous","field","alias","isField","checkDocument","doc","getFragmentDefinition","fragmentDef","queryDoc","fragmentDefinition","identity","printCache","DocumentTransform","transform","resultCache","getCacheKey","predicate","left","right","transformDocument","stableCacheKeys_1","Trie","performWork","wrap","makeCacheKey","cacheKeys","lookupArray","transformedDocument","otherTransform","isNonEmptyArray","TYPENAME_FIELD","NAME","isEmpty","nullIfDocIsEmpty","makeInUseGetterFunction","defaultKey","inUse","fragmentSpreads","removeDirectivesFromDocument","getInUseByOperationName","getInUseByFragmentName","getInUse","ancestors","ancestor","OPERATION_DEFINITION","operationCount","tests","directiveMatcher","testConfig","shouldRemoveField","nodeDirectives","remove","originalFragmentDefsByPath","firstVisitMadeChanges","fieldOrInlineFragmentVisitor","enter","docWithoutDirectiveSubtrees","Field","InlineFragment","VariableDefinition","Variable","_key","_parent","_path","FragmentSpread","FragmentDefinition","leave","removed","populateTransitiveVars","transitiveVars","childFragmentName","varName","allFragmentNamesUsed","def","enterVisitor","OperationDefinition","usedVariableNames_1","varDef","variable","addTypenameToDocument","SelectionSet","parent","lastIndexOf","added","connectionRemoveConfig","willRemove","arg","isOperation","mergeDeep","sources","mergeDeepArray","target","count","merger","DeepMerger","merge","defaultReconciler","source","property","reconciler","isObject","pastCopies","sourceKey","targetValue","shallowCopyForMerge","__proto__","getExtras","notExtras","isStatefulPromise","toString","cloneDeepHelper","val","seen","copy_1","child","copy_2","deepFreeze","workSet","TypeError","shallowFreeze","getOwnPropertyNames","iterateObserversSafely","observers","argument","observersWithMethod","obs","fixObservableSubclass","subclass","species","isPromiseLike","Concast","addObserver","removeObserver","handlers","sub","latest","notify","unsubscribe","subscribe","nextResultListeners","cancel","reason","_","iterable","start","deliverLastMessage","nextOrError","listener","beforeNext","callback","called","isExecutionPatchIncrementalResult","isExecutionPatchInitialResult","getGraphQLErrorsFromResult","graphQLErrors","incremental","incrementalResult","compact","objects","prefixCounts","makeUniqueId","prefix","Math","random","omitDeep","__omitDeep","known","modified","array_1","obj_1","DEV","addNonReactiveToNamedFragments","DIRECTIVE","argumentsObjectFromField","argObj_1","asyncMap","observable","mapFn","catchFn","promiseQueue","makeCallback","examiner","both","closed","handler","buildQueryFromSelectionSet","cloneDeep","concatPagination","keyArgs","existing","incoming","createFulfilledPromise","createRejectedPromise","getDefaultValues","defaultValues","defs","defaultValue","getDirectiveNames","modeArg","VARIABLE","STRING","getFragmentQueryDocument","actualFragmentName","getOperationName","getQueryDefinition","queryDef","getTypenameFromResult","fragments_1","typename","graphQLResultHasError","hasAllDirectives","hasAnyDirectives","hasClientExports","isDocumentNode","isExecutionPatchResult","isFullyUnmaskedOperation","isUnmasked","isInlineFragment","isMutationOperation","isQueryOperation","isReference","Boolean","__ref","isSubscriptionOperation","makeReference","id","String","mergeIncrementalData","prevResult","mergedData","parent_1","isNaN","mergeOptions","defaults","offsetLimitPagination","merged","offset","preventUnhandledRejection","relayStylePagination","canRead","readField","edges","firstEdgeCursor","lastEdgeCursor","edge","cursor","pageInfo","startCursor","endCursor","hasPreviousPage","hasNextPage","incomingEdges","pageInfo_1","firstEdge","lastEdge","firstCursor","lastCursor","suffix","after","findIndex","before","extras","removeArgumentsFromDocument","argMatcher","aConfig","getArgumentMatcher","argConfig","argMatchCount_1","Argument","removeConnectionDirectiveFromDocument","removeFragmentSpreadFromDocument","shouldInclude","evaledValue","storeKeyNameFromField","directivesObj","stringifyForDisplay","space","undefId","stripTypename","wrapPromiseWithState","pendingPromise","fulfilledPromise","rejectedPromise","tsInvariant","thunk","global$1","self","constructor","fn","arg0","getHandledErrorMsg","getFallbackErrorMsg","condition","debug","log","ApolloErrorMessageHandler","messageArgs","InvariantError","optionalParams","equal","internal","useApolloClient","override","context$1","didWarnUncachedGetSnapshot","useSyncExternalStore","getSnapshot","getServerSnapshot","useState","inst","forceUpdate","useLayoutEffect","checkIfSnapshotChanged","useEffect","useDeepMemo","memoFn","deps","ref","useRef","current","Ctx","useIsomorphicLayoutEffect","noop$1","useRenderGuard","useCallback","orig","console","global$2","warnRemovedOption","callSite","recommendation","useWarnRemovedOption","didWarn","__use","statefulPromise","wrapperSymbol","wrapHook","hookName","useHook","clientOrObsQuery","queryManager","wrappers","wrapper","noop","lastWatchOptions","useQuery_","useQueryInternals","obsQueryFields","renderPromises","isSyncSSR","disableNetworkFetches","ssrAllowed","ssr","skip","partialRefetch","makeWatchQueryOptions","createMakeWatchQueryOptions","createInternalState","getSSRObservable","ObservableQuery","watchQuery","getObsQueryOptions","resultData","previousData","internalState","updateInternalState","onQueryExecuted","watchQueryOptions","newInternalState","useInternalState","reobserve","useResubscribeIfNecessary","refetch","fetchMore","updateQuery","startPolling","stopPolling","subscribeToMore","bindObservableMethods","registerSSRObservable","getCurrentResult","loading","addObservableQueryPromise","useRegisterSSRObservable","callbacks","callbackRef","resultOverride","fetchPolicy","skipStandbyResult","ssrDisabledResult","currentResultOverride","toQueryResult","handleStoreChange","onNext","previousResult","networkStatus","setResult","subscription","resubscribeAfterError","NetworkStatus","useObservableSubscriptionResult","onCompleted","defaultOptions","otherOptions","initialFetchPolicy","getDefaultFetchPolicy","queryHookOptions","toMerge","globalDefaults","reduce","nextResult","ApolloError","partial","unsafeHandlePartialRefetch","previousNetworkStatus","error_1","toApolloError$1","ready","handleErrorOrCompleted","queryHookDefaultOptions","clientDefaultOptions","resultWithoutPartial","EAGER_METHODS","REMOVED_EXECUTE_OPTIONS","DEPRECATED_EXECUTE_OPTIONS","useFragment_","rest","identify","stableOptions","diff","optimistic","diffToResult","returnPartialData","lastTimeout","watchFragment","clearTimeout","missing","skipToken","useSuspenseQuery_","suspenseCache","getSuspenseCache","useWatchQueryOptions","queryKey","cacheKey","queryRef","getQueryRef","setPromise","didChangeOptions","applyOptions","retain","listen","skipResult","toApolloError","validateOptions","supportedFetchPolicies","validateFetchPolicy","validatePartialDataReturn","notifyOnNetworkStatusChange","nextFetchPolicy","useBackgroundQuery_","didFetchResult","wrapQueryRef","wrappedQueryRef","setWrappedQueryRef","unwrapQueryRef","updateWrappedQueryRef","disposed","softRetain","NULL_PLACEHOLDER","useSuspenseFragment_","cache$1","fragmentRef","getFragmentRef","useQueryRefHandlers_","assertWrappedQueryRef","previousQueryRef","setPreviousQueryRef","internalQueryRef","getWrappedPromise","useReadQuery_","getPromise","reinitialize","useBackgroundQuery","useFragment","useLazyQuery","warnOpts","execOptionsRef","optionsRef","useQueryResult","forceUpdateState","useReducer","tick","eagerMethods","_loop_1","EAGER_METHODS_1","calledDuringRender","warnRef","execute","executeOptions","REMOVED_EXECUTE_OPTIONS_1","DEPRECATED_EXECUTE_OPTIONS_1","name_2","currentQuery","concast","reobserveAsConcast","executeQuery","queryResult","executeRef","stableExecute","useLoadableQuery","setQueryRef","loadQuery","useMutation","mutation","mutationId","isMounted","baseOptions","ignoreResults","clientOptions","mutate","errors$1","result_1","result_2","result_3","useQuery","useQueryRefHandlers","unwrapped","useReactiveVar","rv","update","onNextChange","useReadQuery","useSubscription","hasIssuedDeprecationWarningRef","onSubscriptionData","onSubscriptionComplete","onComplete","errorPolicy","shouldResubscribe","recreate","__","createSubscription","setObservable","recreateRef","fallbackLoading","fallbackResult","ignoreResultsRef","subscriptionStopped","fetchResult","subscriptionData","protocolErrors","restart","useSuspenseFragment","useSuspenseQuery","equality","QUERY_REFERENCE_SYMBOL","PROMISE_SYMBOL","OBSERVED_CHANGED_OPTIONS","InternalQueryReference","listeners","references","softReferences","handleNext","onDispose","subscribeToQuery","startDisposeTimer","autoDisposeTimeoutId","autoDisposeTimeoutMs","originalFetchPolicy","avoidNetworkRequests","silentSetOptions","resetLastResults","resetDiff","option","currentFetchPolicy","currentCanonizeResults","canonizeResults","initiateFetch","deliver","returnedPromise","createPendingPromise","FragmentReference","watchFragmentOptions","getDiff","subscribeToFragment","SuspenseCache","queryRefs","fragmentRefs","createObservable","suspenseCacheSymbol","react","suspense","toPromise","masking","getInMemoryCacheMemoryInternals","_getApolloCacheMemoryInternals","addTypenameDocumentTransform","recurseTransformInfo","inMemoryCache","executeSelectionSet","getWrapperInformation","executeSubSelectedArray","maybeBroadcastWatch","fragmentRegistry","findFragmentSpreads","lookup","getApolloCacheMemoryInternals","fragmentQueryDocuments","f","isWrapper","isDefined","equalByQuery","aData","aRest","bData","bRest","equalBySelectionSet","aResult","bResult","seenSelections","selectionHasNonreactiveDirective","resultKey","aResultChild","bResultChild","aChildIsArray","bChildIsArray","length_1","directiveIsNonreactive","dir","ApolloCache","assumeImmutableResults","getFragmentDoc","batch","updateResult","optimisticId","performTransaction","recordOptimisticTransaction","transaction","transformForLink","object","gc","modify","readQuery","rootId","dataMasking","latestDiff","diffOptions","watch","immediate","readFragment","writeQuery","write","dataId","writeFragment","updateFragment","getMemoryInternals","Cache","MissingFieldError","hasOwn","isNullish","defaultDataIdFromObject","_id","keyObject","defaultConfig","dataIdFromObject","addTypename","resultCaching","shouldCanonizeResults","TypeOrFieldNameRegExp","fieldNameFromStoreName","storeFieldName","match","selectionSetMatchesResult","storeValueIsStoreObject","extractFragmentContext","DELETE","delModifier","INVALIDATE","EntityStore","policies","group","rootIds","refs","getFieldValue","objectOrReference","objOrRef","toReference","objOrIdOrRef","mergeIntoStore","toObject","depend","storeObject","rootTypenamesById","Layer","dependOnExistence","older","newer","storeObjectReconciler","caching","fieldsToDirty_1","__exists","hasKeyArgs","dirty","changedFields_1","needToMerge_1","allDeleted_1","sharedDetails_1","fieldNameOrOptions","store","fieldValue","storage","getStorage","checkReference","seenReference","someNonReference","newValue_1","getStoreFieldName","evict","limit","evicted","clear","extract","extraRootIds","getRootIdSet","__META","newData","rest_1","release","ids","snapshot","findChildRefIds","idsToRemove","root_1","found_1","workSet_1","keyMaker","Root","CacheGroup","resetCaching","dep","makeDepKey","maybeDependOnExistenceOfEntity","entityId","supportsResultCaching","seed","stump","Stump","storageTrie","addLayer","layerId","replay","removeLayer","ownStoreObject","parentStoreObject","fromParent","existingObject","incomingObject","existingValue","incomingValue","ObjectCanon","pool","passes","keysByJSON","empty","admit","isKnown","pass","copy","shallowCopy","original","array","proto_1","json","firstValueIndex_1","sorted","execSelectionSetKeyArgs","StoreReader","knownResults","canon","peekArgs","other","peek","enclosingRef","execSelectionSetImpl","resultCacheMaxSize","varString","execSubSelectedArrayImpl","resetCanon","diffQueryAgainstStore","rootRef","execResult","firstMissing","isFresh","objectsToMerge","missingMerger","handleMissing","resultName","rootIdsByTypename","finalResult","frozen","childResult","getTypenameFromStoreObject","assertSelectionSetForIdValue","tree","cacheSlot","cacheInfoMap","getCacheInfo","info","vars","forgetCache","makeVar","broadcastWatches","broadcast","oldListeners","attach","attachCache","specifierInfoCache","lookupSpecifierInfo","spec","keyFieldsFnFromSpecifier","specifier","keyFieldsFn","collectSpecifierPaths","schemaKeyPath","extracted","extractKeyPath","extractKey","keyArgsFnFromSpecifier","keyArgsFn","collected","keyPath","firstKey","firstChar","charAt","variableName","varKeyPath","directiveName_1","directiveArgs","extractor","getSpecifierPaths","paths","paths_1","currentPath_1","normalize","reducer","argsFromFieldSpecifier","nullKeyFieldsFn","simpleKeyArgsFn","_args","mergeTrueFn","mergeObjects","mergeFalseFn","Policies","typePolicies","toBeAdded","supertypeMap","fuzzySubtypes","usingPossibleTypes","setRootTypename","possibleTypes","addPossibleTypes","addTypePolicies","partialContext","ROOT_QUERY","normalizeReadFieldOptions","policy","getTypePolicy","keyFn","specifierOrId","queryType","mutationType","subscriptionType","updateTypePolicy","existingFieldPolicies","keyFields","setMerge","which","toUpperCase","old","supertype","getSupertypeSet","subtype","RegExp","policy_1","supertypes_1","regExp","fuzzy","fuzzySupertypes","inbox","splice","getFieldPolicy","createIfMissing","supertypeSet","typenameSupertypeSet","workQueue_1","maybeEnqueue_1","needToCheckFuzzySubtypes","checkingFuzzySubtypes","fuzzyString","fieldSpec","specifierOrString","readOptions","makeFieldFunctionOptions","getReadFunction","getMergeFunction","parentTypename","childTypename","runMergeFunction","makeMergeObjectsFunction","overwrite","readFieldArgs","argc","eType","iType","getContextFlavor","clientOnly","deferred","flavored","flavors","StoreWriter","writeToStore","operationDefinition","written","incomingById","processSelectionSet","mergeTree","fieldNodeSet","entityRef","applied","applyMerges","fieldsWithSelectionSets_1","hasSelectionSet_1","childTree","hasMergeFunction_1","existingRef","incomingObj","getChild","parentType","typeDotName","warnings","childTypenames","warnAboutDataLoss","flattenFields","resultFieldKey","getChildMergeTree","processFieldValue","maybeRecycleChildMergeTree","dataRef","sets","previous_1","mergeMergeTrees","mergeTreeIsEmpty","fieldMap","limitingTrie","flatten","inheritedContext","visitedNode","visited","if","getStorageArgs","e_1","i_1","getValue_1","eVal","iVal","aVal","pop","emptyMergeTreePool","needToMergeMaps","remainingRightKeys_1","leftTree","InMemoryCache","watches","addTypenameTransform","txCount","normalizeConfig","init","rootStore","optimisticData","resetResultCache","resetResultIdentities","previousReader","storeReader","resetCaches","storeWriter","c","broadcastWatch","restore","forget","discardWatches","removeOptimistic","idToRemove","newOptimisticData","onWatchUpdated","perform","layer","alreadyDirty","addFragmentsToDocument","lastDiff","fromOptimisticTransaction","FragmentRegistry","registry","register","invalidate","defined","unbound","enqueue","spreadName","enqueueChildSpreads","knownFragmentDef","defsToAppend_1","spreads","createFragmentRegistry","graphqlTag","hasOwnProperty$2","isNetworkRequestInFlight","hasOwnProperty$1","queryInfo","startedInactive","inactiveOnCreation","_getOrCreateQuery","subObserver","_subscription","_observer","defaultSubscriptionObserverErrorCallback","first","last","maskResult","tearDownQuery","queryId","getOrCreateQuery","waitForOwnResult","skipCacheDataFor","isTornDown","defaultFetchPolicy","_f","generateQueryId","opDef","queryName","lastQuery","removeQuery","getCurrentFullResult","saveAsLastResult","lastResult","getLastResult","getDocumentInfo","hasForcedResolvers","logMissingFieldErrors","updateLastResult","isDifferentFromLastResult","newResult","documentInfo","nonReactiveQuery","hasNonreactiveDirective","getLast","variablesMustMatch","getLastError","resetQueryStoreErrors","resetErrors","reobserveOptions","pollInterval","v","resetLastWrite","fetchMoreOptions","combinedOptions","qid","originalNetworkStatus","observe","updatedQuerySet","isCached","fetchQuery","fetchMoreResult","reportResult","finally","reobserveCacheFirst","startGraphQLSubscription","updateOptions","setOptions","newOptions","mergedOptions","setVariables","broadcastQueries","updatePolling","applyNextFetchPolicy","newNetworkStatus","setObservableQuery","ssrMode","pollingInfo","hasObservers","interval","maybeFetch","skipPollAttempt","poll","timeout","useDisposableConcast","oldVariables","oldFetchPolicy","finishWaitingForOwnResult","fromLink","isApolloError","networkError","reportError","lastError","isDifferent","errorResult","stopQuery","resetNotifications","cancelNotifyTimeout","notifyTimeout","scheduleNotify","stack","destructiveMethodCounts","wrapDestructiveCacheMethod","methodName","QueryInfo","lastRequestId","stopped","observableQuery","getDiffOptions","updateWatch","oq","updateLastDiff","setDiff","oldDiff","stop","cancelWatch","watchOptions","watcher","lastWatch","lastWrite","shouldWrite","dmCount","markResult","cacheWriteBehavior","shouldWriteResult","markReady","markError","ignoreErrors","writeWithErrors","IGNORE","QueryManager","fetchCancelFns","transformCache","queryIdCounter","requestIdCounter","mutationIdCounter","inFlightLinkObservables","noCacheWarningsByQueryId","defaultDocumentTransform","link","queryDeduplication","localState","documentTransform","defaultContext","onBroadcast","mutationStore","_info","stopQueryNoBroadcast","cancelPendingFetches","mutationStoreValue","isOptimistic","optimisticResponse","updateQueries","refetchQueries","awaitRefetchQueries","updateWithProxyFn","onQueryUpdated","_g","_h","keepRootFields","_j","generateMutationId","getVariables","addExportedVariables","markMutationOptimistic","getObservableFromLink","storeResult","markMutationResult","cacheWrites","skipCache","asQuery","updateQueries_1","updater","currentQueryResult","nextQueryResult","mutationResult","queryVariables","results_1","updateCache","isFinalResult","include","fetchConcastWithInfo","getQueryStore","cacheEntry","shouldForceResolvers","clientQuery","serverQuery","defaultVars","generateRequestId","stopQueryInStore","stopQueryInStoreNoBroadcast","clearStore","getObservableQueries","queryNames","queryNamesAndQueryStrings","legacyQueryOptions","desc","queryString","included","nameOrQueryString","reFetchObservableQueries","includeStandby","observableQueryPromises","makeObservable","hasErrors","hasProtocolErrors","graphQLResultHasProtocolErrors","observablePromise_1","getLocalState","deduplication","inFlightLinkObservables_1","prepareContext","forceFetch","printedServerQuery_1","varJson_1","entry","concast_1","of","runResolvers","remoteResult","getResultsFromLink","requestId","linkDocument","aqr","containsDataFromLink","normalized","fromVariables","sourcesWithInfo","fetchQueryByPolicy","cleanupCancelFn","includedQueriesById","results","operationId","refetchWritePolicy","oldNetworkStatus","readCache","resultsFromCache","fromData","onlyRunForcedResolvers","resultsFromLink","shouldNotify","newContext","LocalState","resolvers","fragmentMatcher","selectionsToResolveCache","addResolvers","setFragmentMatcher","resolverGroup","setResolvers","getResolvers","resolveDocument","localResult","getFragmentMatcher","document_1","buildRootValueFromCache","exportedVariables","forceResolvers","rootValue_1","rootValue","mainDefinition","selectionsToResolve","definitionOperation","defaultOperationType","execContext","collectSelectionsToResolve","resolveSelectionSet","isClientFieldDescendant","resultsToMerge","resolveField","fieldResult","fragmentResult","aliasedFieldName","aliasUsed","defaultResult","resultPromise","resolverType","resolverMap","isClientField","resolveSubSelectedArray","isSingleASTNode","collectByDefinition","definitionNode","matches_1","___","isSelectionNode","spread","fragmentSelections","getApolloClientMemoryInternals","limits","fromEntries","sizes","links","linkInfo","documentTransforms","hasSuggestedDevtools","ApolloClient","resetStoreCallbacks","clearStoreCallbacks","ssrForceFetchDelay","connectToDevTools","typeDefs","clientAwarenessName","clientAwarenessVersion","devtools","devtoolsConfig","enabled","resetStore","devToolsHookCb","action","state","dataWithOptimisticResults","windowWithDevTools","devtoolsSymbol","__APOLLO_CLIENT__","top","location","protocol","__APOLLO_DEVTOOLS_GLOBAL_HOOK__","nav","ua","url","__actionHookForDevTools","__requestRaw","onResetStore","onClearStore","obsQuery","serializedState","setLocalStateFragmentMatcher","setLink","newLink","setVerbosity","fromPromise","setLogVerbosity","disableExperimentalFragmentVariables","disableFragmentWarnings","enableExperimentalFragmentVariables","gql","isNetworkRequestSettled","createOperation","starting","unusedNames","errorValue","completed","transformOperation","transformedOperation","validateOperation","OPERATION_FIELDS","passthrough","forward","toLink","isTerminating","y","leftLink","rightLink","second","firstLink","nextLink","setOnError","clientErrors","errorMessage","extraInfo","cause","hooks","_createQueryPreloader","createQueryPreloader","setter","handle","req","errorHandler","retriedSub","retriedResult","ErrorLink"],"ignoreList":[],"sourceRoot":""}