{"version":3,"file":"component---src-pages-index-tsx-a85f8f3193c2795dbe6b.js","mappings":";wLAcIA,EACAC,EACAC,EACAC,EACAC,EAEAC,EACAC,EA8JAC,gCA1JAC,EAAkB,CAAC,EACnBC,EAAW,IAAMC,KAAKC,GACtBC,EAAWF,KAAKC,GAAK,IACrBE,EAASH,KAAKI,MAEdC,EAAW,WACXC,EAAiB,uCACjBC,EAAc,YACdC,EAAmB,CACrBC,UAAW,qBACXC,MAAO,gBACPC,MAAO,WAELC,EAAiB,SAAwBC,EAAOC,GAClD,OAAOA,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,EAAGjB,KAAKkB,MAAkC,KAA3BJ,EAAKK,EAAIL,EAAKM,EAAIP,IAAkB,IAAQC,EAAKO,EAAGP,EAClG,EACIQ,EAAqB,SAA4BT,EAAOC,GAC1D,OAAOA,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,EAAa,IAAVJ,EAAcC,EAAKS,EAAIvB,KAAKkB,MAAkC,KAA3BJ,EAAKK,EAAIL,EAAKM,EAAIP,IAAkB,IAAQC,EAAKO,EAAGP,EACzH,EACIU,EAA8B,SAAqCX,EAAOC,GAC5E,OAAOA,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,EAAGJ,EAAQb,KAAKkB,MAAkC,KAA3BJ,EAAKK,EAAIL,EAAKM,EAAIP,IAAkB,IAAQC,EAAKO,EAAIP,EAAKW,EAAGX,EACnH,EAEAY,EAAwB,SAA+Bb,EAAOC,GAC5D,IAAIa,EAAQb,EAAKK,EAAIL,EAAKM,EAAIP,EAC9BC,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,KAAMU,GAASA,EAAQ,GAAK,GAAK,KAAOb,EAAKO,EAAGP,EACxE,EACIc,EAA0B,SAAiCf,EAAOC,GACpE,OAAOA,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,EAAGJ,EAAQC,EAAKS,EAAIT,EAAKW,EAAGX,EAC3D,EACIe,EAAmC,SAA0ChB,EAAOC,GACtF,OAAOA,EAAKC,IAAID,EAAKE,EAAGF,EAAKG,EAAa,IAAVJ,EAAcC,EAAKW,EAAIX,EAAKS,EAAGT,EACjE,EACIgB,EAAkB,SAAyBC,EAAQC,EAAUL,GAC/D,OAAOI,EAAOE,MAAMD,GAAYL,CAClC,EACIO,EAAiB,SAAwBH,EAAQC,EAAUL,GAC7D,OAAOI,EAAOE,MAAME,YAAYH,EAAUL,EAC5C,EACIS,EAAmB,SAA0BL,EAAQC,EAAUL,GACjE,OAAOI,EAAOM,MAAML,GAAYL,CAClC,EACIW,EAAe,SAAsBP,EAAQC,EAAUL,GACzD,OAAOI,EAAOM,MAAME,OAASR,EAAOM,MAAMG,OAASb,CACrD,EACIc,EAAyB,SAAgCV,EAAQC,EAAUL,EAAOb,EAAMD,GAC1F,IAAI6B,EAAQX,EAAOM,MACnBK,EAAMH,OAASG,EAAMF,OAASb,EAC9Be,EAAMC,gBAAgB9B,EAAO6B,EAC/B,EACIE,EAA6B,SAAoCb,EAAQC,EAAUL,EAAOb,EAAMD,GAClG,IAAI6B,EAAQX,EAAOM,MACnBK,EAAMV,GAAYL,EAClBe,EAAMC,gBAAgB9B,EAAO6B,EAC/B,EACIG,EAAiB,YACjBC,EAAuBD,EAAiB,SACxCE,EAAa,SAASA,EAAWf,EAAUgB,GAC7C,IAAIC,EAAQC,KAERnB,EAASmB,KAAKnB,OACdE,EAAQF,EAAOE,MACfS,EAAQX,EAAOM,MAEnB,GAAIL,KAAYlC,GAAmBmC,EAAO,CAGxC,GAFAiB,KAAKC,IAAMD,KAAKC,KAAO,CAAC,EAEP,cAAbnB,EAQF,OAAOxB,EAAiB4C,UAAUC,MAAM,KAAKC,SAAQ,SAAUrC,GAC7D,OAAO8B,EAAWQ,KAAKN,EAAOhC,EAAG+B,EACnC,IAGF,KAZEhB,EAAWxB,EAAiBwB,IAAaA,GAC/BwB,QAAQ,KAAOxB,EAASqB,MAAM,KAAKC,SAAQ,SAAUG,GAC7D,OAAOR,EAAME,IAAIM,GAAKC,GAAK3B,EAAQ0B,EACrC,IAAKP,KAAKC,IAAInB,GAAYU,EAAMiB,EAAIjB,EAAMV,GAAY0B,GAAK3B,EAAQC,GAEnEA,IAAac,IAAyBI,KAAKC,IAAIS,QAAUlB,EAAMkB,SAO7DV,KAAKW,MAAML,QAAQX,IAAmB,EACxC,OAGEH,EAAMoB,MACRZ,KAAKa,KAAOhC,EAAOiC,aAAa,mBAChCd,KAAKW,MAAMI,KAAKnB,EAAsBE,EAAU,KAGlDhB,EAAWa,CACb,EAECZ,GAASe,IAAaE,KAAKW,MAAMI,KAAKjC,EAAUgB,EAAUf,EAAMD,GACnE,EACIkC,EAA+B,SAAsCjC,GACnEA,EAAMkC,YACRlC,EAAMmC,eAAe,aACrBnC,EAAMmC,eAAe,SACrBnC,EAAMmC,eAAe,UAEzB,EACIC,EAAe,WACjB,IAIIC,EACArD,EALA4C,EAAQX,KAAKW,MACb9B,EAASmB,KAAKnB,OACdE,EAAQF,EAAOE,MACfS,EAAQX,EAAOM,MAInB,IAAKiC,EAAI,EAAGA,EAAIT,EAAMU,OAAQD,GAAK,EAEjCT,EAAMS,EAAI,GAAKvC,EAAO8B,EAAMS,IAAMT,EAAMS,EAAI,GAAKT,EAAMS,EAAI,GAAKrC,EAAM4B,EAAMS,IAAMT,EAAMS,EAAI,GAAKrC,EAAMmC,eAAyC,OAA1BP,EAAMS,GAAGE,OAAO,EAAG,GAAcX,EAAMS,GAAKT,EAAMS,GAAGG,QAAQpE,EAAU,OAAOqE,eAGtM,GAAIxB,KAAKC,IAAK,CACZ,IAAKlC,KAAKiC,KAAKC,IACbT,EAAMzB,GAAKiC,KAAKC,IAAIlC,GAGlByB,EAAMoB,MACRpB,EAAMC,kBACNZ,EAAO4C,aAAa,kBAAmBzB,KAAKa,MAAQ,MAGtDO,EAAI1E,MAEQ0E,EAAEM,SAAa3C,EAAMY,KAC/BqB,EAA6BjC,GAEzBS,EAAMkB,SAAW3B,EAAMa,KACzBb,EAAMa,IAAyB,IAAMJ,EAAMkB,QAAU,KAErDlB,EAAMkB,QAAU,EAChBlB,EAAMC,mBAGRD,EAAMmC,QAAU,EAEpB,CACF,EACIC,EAAiB,SAAwB/C,EAAQgD,GACnD,IAAIC,EAAQ,CACVjD,OAAQA,EACR8B,MAAO,GACPoB,OAAQZ,EACRa,KAAMnC,GAOR,OALAhB,EAAOM,OAAS,mBAAmBN,GAEnCgD,GAAcA,EAAW1B,MAAM,KAAKC,SAAQ,SAAUrC,GACpD,OAAO+D,EAAME,KAAKjE,EACpB,IACO+D,CACT,EAEIG,EAAiB,SAAwBC,EAAMC,GACjD,IAAI9D,EAAIhC,EAAK+F,gBAAkB/F,EAAK+F,iBAAiBD,GAAM,gCAAgCZ,QAAQ,SAAU,QAASW,GAAQ7F,EAAKgG,cAAcH,GAEjJ,OAAO7D,GAAKA,EAAEU,MAAQV,EAAIhC,EAAKgG,cAAcH,EAC/C,EACII,EAAuB,SAASA,EAAqBzD,EAAQC,EAAUyD,GACzE,IAAIC,EAAKC,iBAAiB5D,GAC1B,OAAO2D,EAAG1D,IAAa0D,EAAGE,iBAAiB5D,EAASyC,QAAQpE,EAAU,OAAOqE,gBAAkBgB,EAAGE,iBAAiB5D,KAAcyD,GAAsBD,EAAqBzD,EAAQ8D,EAAiB7D,IAAaA,EAAU,IAAM,EACpO,EACI8D,EAAY,qBAAqBzC,MAAM,KACvCwC,EAAmB,SAA0B7D,EAAU+D,EAASC,GAClE,IACI7E,GADI4E,GAAWrG,GACTuC,MACNqC,EAAI,EAER,GAAItC,KAAYb,IAAM6E,EACpB,OAAOhE,EAKT,IAFAA,EAAWA,EAASiE,OAAO,GAAGC,cAAgBlE,EAASwC,OAAO,GAEvDF,OAASwB,EAAUxB,GAAKtC,KAAYb,KAE3C,OAAOmD,EAAI,EAAI,MAAc,IAANA,EAAU,KAAOA,GAAK,EAAIwB,EAAUxB,GAAK,IAAMtC,CACxE,EACImE,EAAY,WAtLW,oBAAXC,QAuLSA,OAAOC,WAC5B/G,EAAO8G,OACP7G,EAAOD,EAAK+G,SACZ7G,EAAcD,EAAK+G,gBACnB5G,EAAWyF,EAAe,QAAU,CAClClD,MAAO,CAAC,GAEOkD,EAAe,OAChCtC,EAAiBgD,EAAiBhD,GAClCC,EAAuBD,EAAiB,SACxCnD,EAASuC,MAAMsE,QAAU,2DAEzB1G,IAAgBgG,EAAiB,eACjCjG,EAAa,oBACbH,EAAiB,EAErB,EACI+G,EAAe,SAASA,EAAaC,GAEvC,IAIIC,EAJA5C,EAAMqB,EAAe,MAAOjC,KAAKyD,iBAAmBzD,KAAKyD,gBAAgB3C,aAAa,UAAY,8BAClG4C,EAAY1D,KAAK2D,WACjBC,EAAa5D,KAAK6D,YAClBC,EAAS9D,KAAKjB,MAAMsE,QAQxB,GALA/G,EAAYyH,YAAYnD,GAExBA,EAAImD,YAAY/D,MAChBA,KAAKjB,MAAMiF,QAAU,QAEjBT,EACF,IACEC,EAAOxD,KAAKiE,UACZjE,KAAKkE,UAAYlE,KAAKiE,QAEtBjE,KAAKiE,QAAUX,CACjB,CAAE,MAAOjF,GAAI,MACJ2B,KAAKkE,YACdV,EAAOxD,KAAKkE,aAcd,OAXIR,IACEE,EACFF,EAAUS,aAAanE,KAAM4D,GAE7BF,EAAUK,YAAY/D,OAI1B1D,EAAY8H,YAAYxD,GAExBZ,KAAKjB,MAAMsE,QAAUS,EACdN,CACT,EACIa,EAAyB,SAAgCxF,EAAQyF,GAGnE,IAFA,IAAIlD,EAAIkD,EAAgBjD,OAEjBD,KACL,GAAIvC,EAAO0F,aAAaD,EAAgBlD,IACtC,OAAOvC,EAAOiC,aAAawD,EAAgBlD,GAGjD,EACIoD,EAAW,SAAkB3F,GAC/B,IAAI4F,EAEJ,IACEA,EAAS5F,EAAOoF,SAClB,CAAE,MAAOS,GACPD,EAASnB,EAAajD,KAAKxB,GAAQ,EACrC,CAIA,OAFA4F,IAAWA,EAAOE,OAASF,EAAOG,SAAW/F,EAAOoF,UAAYX,IAAiBmB,EAASnB,EAAajD,KAAKxB,GAAQ,KAE7G4F,GAAWA,EAAOE,OAAUF,EAAOhE,GAAMgE,EAAOI,EAKnDJ,EALuD,CACzDhE,GAAI4D,EAAuBxF,EAAQ,CAAC,IAAK,KAAM,QAAU,EACzDgG,GAAIR,EAAuBxF,EAAQ,CAAC,IAAK,KAAM,QAAU,EACzD8F,MAAO,EACPC,OAAQ,EAEZ,EACIE,EAAS,SAAgBzG,GAC3B,SAAUA,EAAE0G,QAAY1G,EAAEsF,aAActF,EAAEoF,kBAAoBe,EAASnG,GACzE,EAEA2G,EAAkB,SAAyBnG,EAAQC,GACjD,GAAIA,EAAU,CACZ,IACImG,EADAlG,EAAQF,EAAOE,MAGfD,KAAYlC,GAAmBkC,IAAac,IAC9Cd,EAAWa,GAGTZ,EAAMmC,gBAGY,QAFpB+D,EAAcnG,EAASwC,OAAO,EAAG,KAEqB,WAA1BxC,EAASwC,OAAO,EAAG,KAE7CxC,EAAW,IAAMA,GAGnBC,EAAMmC,eAA+B,OAAhB+D,EAAuBnG,EAAWA,EAASyC,QAAQpE,EAAU,OAAOqE,gBAGzFzC,EAAMmG,gBAAgBpG,EAE1B,CACF,EACIqG,EAAoB,SAA2BC,EAAQvG,EAAQC,EAAUuG,EAAWC,EAAKC,GAC3F,IAAIC,EAAK,IAAI,KAAUJ,EAAOK,IAAK5G,EAAQC,EAAU,EAAG,EAAGyG,EAAe5G,EAAmCD,GAO7G,OANA0G,EAAOK,IAAMD,EACbA,EAAGjH,EAAI8G,EACPG,EAAGnH,EAAIiH,EAEPF,EAAOM,OAAO3E,KAAKjC,GAEZ0G,CACT,EACIG,EAAuB,CACzBC,IAAK,EACLC,IAAK,EACLC,KAAM,GAEJC,EAAsB,CACxBC,KAAM,EACNC,KAAM,GAGRC,EAAiB,SAASA,EAAerH,EAAQC,EAAUL,EAAO0H,GAChE,IAUIC,EACAC,EACA7G,EACA8G,EAbAC,EAAWC,WAAW/H,IAAU,EAChCgI,GAAWhI,EAAQ,IAAIiI,OAAOpF,QAAQiF,EAAW,IAAIlF,SAAW,KAEpEtC,EAAQvC,EAASuC,MACb4H,EAAavJ,EAAewJ,KAAK9H,GACjC+H,EAA6C,QAAjChI,EAAOiI,QAAQtF,cAC3BuF,GAAmBF,EAAY,SAAW,WAAaF,EAAa,QAAU,UAC9EK,EAAS,IACTC,EAAoB,OAATd,EACXe,EAAqB,MAATf,EAMhB,GAAIA,IAASM,IAAYF,GAAYZ,EAAqBQ,IAASR,EAAqBc,GACtF,OAAOF,EAMT,GAHY,OAAZE,IAAqBQ,IAAaV,EAAWL,EAAerH,EAAQC,EAAUL,EAAO,OACrF6H,EAAQzH,EAAOkG,QAAUD,EAAOjG,IAE3BqI,GAAyB,MAAZT,KAAqB7J,EAAgBkC,KAAcA,EAASwB,QAAQ,UAEpF,OADA8F,EAAKE,EAAQzH,EAAOoF,UAAU0C,EAAa,QAAU,UAAY9H,EAAOkI,IACjE,QAAOG,EAAYX,EAAWH,EAAKY,EAAST,EAAW,IAAMH,GAgBtE,GAbArH,EAAM4H,EAAa,QAAU,UAAYK,GAAUC,EAAWR,EAAUN,GACxEE,GAAUvH,EAASwB,QAAQ,UAAqB,OAAT6F,GAAiBtH,EAAOkF,cAAgB8C,EAAYhI,EAASA,EAAO8E,WAEvG2C,IACFD,GAAUxH,EAAO4E,iBAAmB,CAAC,GAAGE,YAGrC0C,GAAUA,IAAWhK,GAASgK,EAAOtC,cACxCsC,EAAShK,EAAK8K,OAGhB3H,EAAQ6G,EAAOlH,QAEF+H,GAAa1H,EAAMmF,OAASgC,GAAcnH,EAAM4H,OAAS,YAAiB5H,EAAMmC,QAC3F,OAAO,QAAO4E,EAAW/G,EAAMmF,MAAQqC,GAEvC,IAAIE,GAA2B,WAAbpI,GAAsC,UAAbA,GAOxCoI,GAAyB,MAAZT,KAAqBV,EAAoBzD,EAAqB+D,EAAQ,cAAgBtH,EAAMsI,SAAW/E,EAAqBzD,EAAQ,aAClJwH,IAAWxH,IAAWE,EAAMsI,SAAW,UAEvChB,EAAOtC,YAAYvH,GACnB4J,EAAK5J,EAASuK,GACdV,EAAOjC,YAAY5H,GACnBuC,EAAMsI,SAAW,eAb+C,CAEhE,IAAIC,EAAIzI,EAAOE,MAAMD,GACrBD,EAAOE,MAAMD,GAAYkI,EAASb,EAClCC,EAAKvH,EAAOkI,GACZO,EAAIzI,EAAOE,MAAMD,GAAYwI,EAAItC,EAAgBnG,EAAQC,EAC3D,CAiBF,OAPM6H,GAAcO,KAChB1H,GAAQ,QAAU6G,IACZe,KAAO,UACb5H,EAAMmF,MAAQ0B,EAAOU,KAIlB,QAAOE,EAAWb,EAAKG,EAAWS,EAASZ,GAAMG,EAAWS,EAASZ,EAAKG,EAAW,EAC9F,EACI/F,GAAO,SAAc3B,EAAQC,EAAUqH,EAAMxE,GAC/C,IAAIlD,EAsBJ,OArBAlC,GAAkB0G,IAEdnE,KAAYxB,GAAiC,cAAbwB,KAClCA,EAAWxB,EAAiBwB,IAEdwB,QAAQ,OACpBxB,EAAWA,EAASqB,MAAM,KAAK,IAI/BvD,EAAgBkC,IAA0B,cAAbA,GAC/BL,EAAQ8I,GAAgB1I,EAAQ8C,GAChClD,EAAqB,oBAAbK,EAAiCL,EAAMK,GAAYL,EAAMmC,IAAMnC,EAAM+I,OAASC,GAAcnF,EAAqBzD,EAAQe,IAAyB,IAAMnB,EAAMiC,QAAU,SAEhLjC,EAAQI,EAAOE,MAAMD,KAEG,SAAVL,GAAoBkD,KAAalD,EAAQ,IAAI6B,QAAQ,YACjE7B,EAAQiJ,GAAc5I,IAAa4I,GAAc5I,GAAUD,EAAQC,EAAUqH,IAAS7D,EAAqBzD,EAAQC,KAAa,QAAaD,EAAQC,KAA2B,YAAbA,EAAyB,EAAI,IAI7LqH,MAAW1H,EAAQ,IAAIiI,OAAOpG,QAAQ,KAAO4F,EAAerH,EAAQC,EAAUL,EAAO0H,GAAQA,EAAO1H,CAC7G,EACIkJ,GAAyB,SAAgC9I,EAAQ+I,EAAMC,EAAOvC,GAEhF,IAAKuC,GAAmB,SAAVA,EAAkB,CAE9B,IAAI9J,EAAI4E,EAAiBiF,EAAM/I,EAAQ,GACnCZ,EAAIF,GAAKuE,EAAqBzD,EAAQd,EAAG,GAEzCE,GAAKA,IAAM4J,GACbD,EAAO7J,EACP8J,EAAQ5J,GACU,gBAAT2J,IACTC,EAAQvF,EAAqBzD,EAAQ,kBAEzC,CAEA,IAGI0B,EACAuH,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAbA/C,EAAK,IAAI,KAAUxF,KAAKyF,IAAK5G,EAAOE,MAAO6I,EAAM,EAAG,EAAG,MACvDY,EAAQ,EACRC,EAAa,EAoCjB,GAvBAjD,EAAGjH,EAAIsJ,EACPrC,EAAGnH,EAAIiH,EACPuC,GAAS,GAIG,UAFZvC,GAAO,MAGL4C,EAAarJ,EAAOE,MAAM6I,GAC1B/I,EAAOE,MAAM6I,GAAQtC,EACrBA,EAAMhD,EAAqBzD,EAAQ+I,IAAStC,EAC5C4C,EAAarJ,EAAOE,MAAM6I,GAAQM,EAAalD,EAAgBnG,EAAQ+I,IAGzErH,EAAI,CAACsH,EAAOvC,IAEZ,QAAmB/E,GAInB+E,EAAM/E,EAAE,GACRwH,GAFAF,EAAQtH,EAAE,IAEUmI,MAAM,OAAoB,IAClCpD,EAAIoD,MAAM,OAAoB,IAE5BrH,OAAQ,CACpB,KAAOyG,EAAS,UAAqBxC,IACnC6C,EAAWL,EAAO,GAClBO,EAAQ/C,EAAIqD,UAAUH,EAAOV,EAAOU,OAEhCP,EACFA,GAASA,EAAQ,GAAK,EACQ,UAArBI,EAAM/G,QAAQ,IAAuC,UAArB+G,EAAM/G,QAAQ,KACvD2G,EAAQ,GAGNE,KAAcD,EAAaH,EAAYU,MAAiB,MAC1DT,EAAWxB,WAAW0B,IAAe,EACrCK,EAAYL,EAAW5G,QAAQ0G,EAAW,IAAI3G,QACvB,MAAvB8G,EAASpF,OAAO,KAAeoF,GAAW,QAAeH,EAAUG,GAAYI,GAC/EH,EAAS5B,WAAW2B,GACpBG,EAAUH,EAAS7G,QAAQ8G,EAAS,IAAI/G,QACxCmH,EAAQ,eAA4BF,EAAQjH,OAEvCiH,IAEHA,EAAUA,GAAW,WAAcV,IAASW,EAExCC,IAAUlD,EAAIjE,SAChBiE,GAAOgD,EACP9C,EAAGnH,GAAKiK,IAIRC,IAAcD,IAChBN,EAAW9B,EAAerH,EAAQ+I,EAAMM,EAAYI,IAAY,GAIlE9C,EAAGC,IAAM,CACPmD,MAAOpD,EAAGC,IACV1H,EAAGsK,GAAwB,IAAfI,EAAmBJ,EAAQ,IAEvCpK,EAAG+J,EACH9J,EAAGkK,EAASJ,EACZa,EAAGZ,GAASA,EAAQ,GAAc,WAATL,EAAoB9K,KAAKkB,MAAQ,IAKhEwH,EAAGtH,EAAIsK,EAAQlD,EAAIjE,OAASiE,EAAIqD,UAAUH,EAAOlD,EAAIjE,QAAU,EACjE,MACEmE,EAAGsD,EAAa,YAATlB,GAA8B,SAARtC,EAAiB3G,EAAmCD,EAOnF,OAJA,UAAa4G,KAASE,EAAGnH,EAAI,GAE7B2B,KAAKyF,IAAMD,EAEJA,CACT,EACIuD,GAAoB,CACtBC,IAAK,KACLC,OAAQ,OACRC,KAAM,KACNC,MAAO,OACPC,OAAQ,OAkBNC,GAAoB,SAA2B1L,EAAOC,GACxD,GAAIA,EAAK0L,OAAS1L,EAAK0L,MAAMC,QAAU3L,EAAK0L,MAAME,KAAM,CACtD,IAII5B,EACA6B,EACArI,EANAvC,EAASjB,EAAKE,EACdiB,EAAQF,EAAOE,MACf4B,EAAQ/C,EAAKO,EACbqB,EAAQX,EAAOM,MAKnB,GAAc,QAAVwB,IAA6B,IAAVA,EACrB5B,EAAMsE,QAAU,GAChBoG,EAAkB,OAKlB,IAFArI,GADAT,EAAQA,EAAMR,MAAM,MACVkB,SAEDD,GAAK,GACZwG,EAAOjH,EAAMS,GAETxE,EAAgBgL,KAClB6B,EAAkB,EAClB7B,EAAgB,oBAATA,EAA6BhI,EAAuBD,GAG7DqF,EAAgBnG,EAAQ+I,GAIxB6B,IACFzE,EAAgBnG,EAAQc,GAEpBH,IACFA,EAAMoB,KAAO/B,EAAOqG,gBAAgB,aAEpCqC,GAAgB1I,EAAQ,GAGxBW,EAAMmC,QAAU,EAEhBX,EAA6BjC,IAGnC,CACF,EAEA2I,GAAgB,CACdgC,WAAY,SAAoBtE,EAAQvG,EAAQC,EAAUqJ,EAAUmB,GAClE,GAAmB,gBAAfA,EAAM1L,KAAwB,CAChC,IAAI4H,EAAKJ,EAAOK,IAAM,IAAI,KAAUL,EAAOK,IAAK5G,EAAQC,EAAU,EAAG,EAAGuK,IAOxE,OANA7D,EAAGrH,EAAIgK,EACP3C,EAAGmE,IAAM,GACTnE,EAAG8D,MAAQA,EAEXlE,EAAOM,OAAO3E,KAAKjC,GAEZ,CACT,CACF,GAwEF8K,GAAoB,CAAC,EAAG,EAAG,EAAG,EAAG,EAAG,GAChCC,GAAwB,CAAC,EACzBC,GAAmB,SAA0BrL,GAC/C,MAAiB,6BAAVA,GAAkD,SAAVA,IAAqBA,CACtE,EACIsL,GAAqC,SAA4ClL,GACnF,IAAImL,EAAe1H,EAAqBzD,EAAQc,GAEhD,OAAOmK,GAAiBE,GAAgBJ,GAAoBI,EAAa1I,OAAO,GAAGoH,MAAM,MAASuB,IAAI,KACxG,EACIC,GAAa,SAAoBrL,EAAQsL,GAC3C,IAGI9D,EACAxC,EACAuG,EACAC,EANA7K,EAAQX,EAAOM,QAAS,QAAUN,GAClCE,EAAQF,EAAOE,MACfuL,EAASP,GAAmClL,GAMhD,OAAIW,EAAMoB,KAAO/B,EAAOiC,aAAa,aAIP,iBAD5BwJ,EAAS,EAFTF,EAAOvL,EAAOqB,UAAUqK,QAAQC,cAAcF,QAE/B/J,EAAG6J,EAAK7L,EAAG6L,EAAKlM,EAAGkM,EAAKK,EAAGL,EAAK/L,EAAG+L,EAAKM,IACzCC,KAAK,KAAyBf,GAAoBU,GACvDA,IAAWV,IAAsB/K,EAAO+L,cAAgB/L,IAAWvC,GAAgBkD,EAAMoB,MAGlGwJ,EAAOrL,EAAMiF,QACbjF,EAAMiF,QAAU,SAChBqC,EAASxH,EAAO8E,aAEA9E,EAAO+L,eAErBP,EAAa,EAEbxG,EAAchF,EAAOgM,mBAErBvO,EAAYyH,YAAYlF,IAI1ByL,EAASP,GAAmClL,GAC5CuL,EAAOrL,EAAMiF,QAAUoG,EAAOpF,EAAgBnG,EAAQ,WAElDwL,IACFxG,EAAcwC,EAAOlC,aAAatF,EAAQgF,GAAewC,EAASA,EAAOtC,YAAYlF,GAAUvC,EAAY8H,YAAYvF,KAIpHsL,GAAWG,EAAOjJ,OAAS,EAAI,CAACiJ,EAAO,GAAIA,EAAO,GAAIA,EAAO,GAAIA,EAAO,GAAIA,EAAO,IAAKA,EAAO,KAAOA,EAC/G,EACIQ,GAAkB,SAAyBjM,EAAQ2I,EAAQuD,EAAkBC,EAAQC,EAAaC,GACpG,IAeIzG,EACA0G,EAEAtG,EAlBArF,EAAQX,EAAOM,MACfmL,EAASW,GAAef,GAAWrL,GAAQ,GAC3CuM,EAAa5L,EAAM6L,SAAW,EAC9BC,EAAa9L,EAAM+L,SAAW,EAC9BC,EAAahM,EAAMiM,SAAW,EAC9BC,EAAalM,EAAMmM,SAAW,EAC9BpL,EAAI+J,EAAO,GACX/L,EAAI+L,EAAO,GACXpM,EAAIoM,EAAO,GACXG,EAAIH,EAAO,GACXsB,EAAKtB,EAAO,GACZuB,EAAKvB,EAAO,GACZwB,EAActE,EAAOrH,MAAM,KAC3BkL,EAAU7E,WAAWsF,EAAY,KAAO,EACxCP,EAAU/E,WAAWsF,EAAY,KAAO,EAMvCf,EAOMT,IAAWV,KAAsBuB,EAAc5K,EAAIkK,EAAIlM,EAAIL,KAGpE2G,EAAIwG,IAAY9M,EAAI4M,GAAeI,GAAWhL,EAAI4K,IAAgB5K,EAAIsL,EAAKtN,EAAIqN,GAAMT,EACrFE,EAFIA,GAAWZ,EAAIU,GAAeI,IAAYrN,EAAIiN,IAAgBjN,EAAI2N,EAAKpB,EAAImB,GAAMT,EAGrFI,EAAU1G,IAVVwG,GADA5G,EAASD,EAAS3F,IACD4B,IAAMqL,EAAY,GAAGxL,QAAQ,KAAO+K,EAAU,IAAM5G,EAAOE,MAAQ0G,GACpFE,EAAU9G,EAAOI,KAAOiH,EAAY,IAAMA,EAAY,IAAIxL,QAAQ,KAAOiL,EAAU,IAAM9G,EAAOG,OAAS2G,IAYvGP,IAAqB,IAAXA,GAAoBxL,EAAMwL,QACtCY,EAAKP,EAAUD,EACfS,EAAKN,EAAUD,EACf9L,EAAMiM,QAAUD,GAAcI,EAAKrL,EAAIsL,EAAK3N,GAAK0N,EACjDpM,EAAMmM,QAAUD,GAAcE,EAAKrN,EAAIsN,EAAKpB,GAAKoB,GAEjDrM,EAAMiM,QAAUjM,EAAMmM,QAAU,EAGlCnM,EAAM6L,QAAUA,EAChB7L,EAAM+L,QAAUA,EAChB/L,EAAMwL,SAAWA,EACjBxL,EAAMgI,OAASA,EACfhI,EAAMuL,mBAAqBA,EAC3BlM,EAAOE,MAAMa,GAAwB,UAEjCsL,IACF/F,EAAkB+F,EAAyB1L,EAAO,UAAW4L,EAAYC,GAEzElG,EAAkB+F,EAAyB1L,EAAO,UAAW8L,EAAYC,GAEzEpG,EAAkB+F,EAAyB1L,EAAO,UAAWgM,EAAYhM,EAAMiM,SAE/EtG,EAAkB+F,EAAyB1L,EAAO,UAAWkM,EAAYlM,EAAMmM,UAGjF9M,EAAO4C,aAAa,kBAAmB4J,EAAU,IAAME,EACzD,EACIhE,GAAkB,SAAyB1I,EAAQ8C,GACrD,IAAInC,EAAQX,EAAOM,OAAS,IAAI,KAAQN,GAExC,GAAI,MAAOW,IAAUmC,IAAYnC,EAAMmC,QACrC,OAAOnC,EAGT,IAMIiB,EACAoE,EACAkH,EACA1M,EACAC,EACA0M,EACAC,EACAC,EACAC,EACAC,EACAC,EACAhB,EACAE,EACAjB,EACAgC,EACAC,EACAC,EACAjM,EACAhC,EACAL,EACAuM,EACAgC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EArCApO,EAAQF,EAAOE,MACfqO,EAAiB5N,EAAMH,OAAS,EAChC+G,EAAK,KACLR,EAAM,MACNpD,EAAKC,iBAAiB5D,GACtB2I,EAASlF,EAAqBzD,EAAQe,IAAyB,IAyMnE,OAxKAa,EAAIoE,EAAIkH,EAAIC,EAAWC,EAAYC,EAAYC,EAAQC,EAAQC,EAAc,EAC7EhN,EAASC,EAAS,EAClBE,EAAMoB,OAAS/B,EAAOkG,SAAUD,EAAOjG,IAEnC2D,EAAGvB,YAEgB,SAAjBuB,EAAGvB,WAAqC,SAAbuB,EAAGhF,OAAkC,SAAdgF,EAAG6K,SACvDtO,EAAMY,IAAoC,SAAjB6C,EAAGvB,UAAuB,gBAAkBuB,EAAGvB,UAAY,QAAQd,MAAM,KAAKmN,MAAM,EAAG,GAAG3C,KAAK,MAAQ,KAAO,KAAqB,SAAdnI,EAAG6K,OAAoB,UAAY7K,EAAG6K,OAAS,KAAO,KAAoB,SAAb7K,EAAGhF,MAAmB,SAAWgF,EAAGhF,MAAM2C,MAAM,KAAKwK,KAAK,KAAO,KAAO,KAA8B,SAAvBnI,EAAG7C,GAA6B6C,EAAG7C,GAAkB,KAGjVZ,EAAMvB,MAAQuB,EAAMsO,OAAStO,EAAMkC,UAAY,QAGjDqJ,EAASJ,GAAWrL,EAAQW,EAAMoB,KAE9BpB,EAAMoB,MACJpB,EAAMmC,SAERiL,EAAK/N,EAAOoF,UACZuD,EAAShI,EAAM6L,QAAUuB,EAAGnM,EAAI,OAASjB,EAAM+L,QAAUqB,EAAG/H,GAAK,KACjE8H,EAAK,IAELA,GAAMhL,GAAW9C,EAAOiC,aAAa,mBAGvCgK,GAAgBjM,EAAQ8N,GAAMnF,IAAUmF,GAAMnN,EAAMuL,kBAAmC,IAAjBvL,EAAMwL,OAAkBV,IAGhGe,EAAU7L,EAAM6L,SAAW,EAC3BE,EAAU/L,EAAM+L,SAAW,EAEvBjB,IAAWV,KACbrJ,EAAI+J,EAAO,GAEX/L,EAAI+L,EAAO,GAEXpM,EAAIoM,EAAO,GAEXG,EAAIH,EAAO,GAEX7J,EAAIgM,EAAMnC,EAAO,GACjBzF,EAAI6H,EAAMpC,EAAO,GAEK,IAAlBA,EAAOjJ,QACThC,EAASvC,KAAKyQ,KAAKhN,EAAIA,EAAIhC,EAAIA,GAC/Be,EAASxC,KAAKyQ,KAAK9C,EAAIA,EAAIvM,EAAIA,GAC/B8N,EAAWzL,GAAKhC,EAAItB,EAAOsB,EAAGgC,GAAK1D,EAAW,GAE9CsP,EAAQjO,GAAKuM,EAAIxN,EAAOiB,EAAGuM,GAAK5N,EAAWmP,EAAW,KAC5C1M,GAAUxC,KAAK0Q,IAAI1Q,KAAKyP,IAAIJ,EAAQnP,KAE1CwC,EAAMoB,MACRH,GAAK4K,GAAWA,EAAU9K,EAAIgL,EAAUrN,GACxC2G,GAAK0G,GAAWF,EAAU9M,EAAIgN,EAAUd,MAI1C0C,EAAM7C,EAAO,GACb2C,EAAM3C,EAAO,GACbwC,EAAMxC,EAAO,GACbyC,EAAMzC,EAAO,GACb0C,EAAM1C,EAAO,IACb4C,EAAM5C,EAAO,IACb7J,EAAI6J,EAAO,IACXzF,EAAIyF,EAAO,IACXyB,EAAIzB,EAAO,IAEX2B,GADAK,EAAQrP,EAAOkQ,EAAKH,IACAnQ,EAEhByP,IAGFK,EAAKF,GAFLF,EAAMzP,KAAKyP,KAAKD,IAECQ,GADjBN,EAAM1P,KAAK0P,KAAKF,IAEhBM,EAAKF,EAAMH,EAAMQ,EAAMP,EACvBK,EAAKM,EAAMZ,EAAMS,EAAMR,EACvBM,EAAML,GAAOD,EAAMM,EAAMP,EACzBQ,EAAML,GAAOF,EAAMO,EAAMR,EACzBS,EAAMG,GAAOX,EAAMQ,EAAMT,EACzBW,EAAMD,GAAOT,EAAMU,EAAMX,EACzBE,EAAME,EACND,EAAME,EACNO,EAAMN,GAKRX,GADAI,EAAQrP,GAAQiB,EAAG8O,IACCnQ,EAEhByP,IACFC,EAAMzP,KAAKyP,KAAKD,GAKhBY,EAAMzC,GAJN+B,EAAM1P,KAAK0P,KAAKF,IAIAY,EAAMX,EACtBhM,EAJAoM,EAAKpM,EAAIgM,EAAMO,EAAMN,EAKrBjO,EAJAqO,EAAKrO,EAAIgO,EAAMQ,EAAMP,EAKrBtO,EAJA2O,EAAK3O,EAAIqO,EAAMS,EAAMR,GASvBR,GADAM,EAAQrP,EAAOsB,EAAGgC,IACC1D,EAEfyP,IAGFK,EAAKpM,GAFLgM,EAAMzP,KAAKyP,IAAID,IAEA/N,GADfiO,EAAM1P,KAAK0P,IAAIF,IAEfM,EAAKH,EAAMF,EAAMG,EAAMF,EACvBjO,EAAIA,EAAIgO,EAAMhM,EAAIiM,EAClBE,EAAMA,EAAMH,EAAME,EAAMD,EACxBjM,EAAIoM,EACJF,EAAMG,GAGJX,GAAanP,KAAK0Q,IAAIvB,GAAanP,KAAK0Q,IAAIxB,GAAY,QAE1DC,EAAYD,EAAW,EACvBE,EAAY,IAAMA,GAGpB7M,GAAS,QAAOvC,KAAKyQ,KAAKhN,EAAIA,EAAIhC,EAAIA,EAAIL,EAAIA,IAC9CoB,GAAS,QAAOxC,KAAKyQ,KAAKb,EAAMA,EAAMS,EAAMA,IAC5Cb,EAAQrP,EAAOwP,EAAKC,GACpBP,EAAQrP,KAAK0Q,IAAIlB,GAAS,KAASA,EAAQzP,EAAW,EACtDwP,EAAca,EAAM,GAAKA,EAAM,GAAKA,EAAMA,GAAO,GAG/C1N,EAAMoB,MAER+L,EAAK9N,EAAOiC,aAAa,aACzBtB,EAAMiO,SAAW5O,EAAO4C,aAAa,YAAa,MAAQqI,GAAiBxH,EAAqBzD,EAAQc,IACxGgN,GAAM9N,EAAO4C,aAAa,YAAakL,KAIvC7P,KAAK0Q,IAAIrB,GAAS,IAAMrP,KAAK0Q,IAAIrB,GAAS,MACxCiB,GACF/N,IAAW,EACX8M,GAASH,GAAY,EAAI,KAAO,IAChCA,GAAYA,GAAY,EAAI,KAAO,MAEnC1M,IAAW,EACX6M,GAASA,GAAS,EAAI,KAAO,MAIjCxK,EAAUA,GAAWnC,EAAMmC,QAC3BnC,EAAMiB,EAAIA,IAAMjB,EAAMkO,SAAWjN,KAAOkB,GAAWnC,EAAMkO,WAAa5Q,KAAKkB,MAAMa,EAAO8O,YAAc,KAAO7Q,KAAKkB,OAAOyC,IAAM,GAAK,KAAO5B,EAAO8O,YAAcnO,EAAMkO,SAAW,IAAM,GAAKtH,EAC5L5G,EAAMqF,EAAIA,IAAMrF,EAAMoO,SAAW/I,KAAOlD,GAAWnC,EAAMoO,WAAa9Q,KAAKkB,MAAMa,EAAOgP,aAAe,KAAO/Q,KAAKkB,OAAO6G,IAAM,GAAK,KAAOhG,EAAOgP,aAAerO,EAAMoO,SAAW,IAAM,GAAKxH,EAC9L5G,EAAMuM,EAAIA,EAAI3F,EACd5G,EAAMH,QAAS,QAAOA,GACtBG,EAAMF,QAAS,QAAOA,GACtBE,EAAMwM,UAAW,QAAOA,GAAYpG,EACpCpG,EAAMyM,WAAY,QAAOA,GAAarG,EACtCpG,EAAM0M,WAAY,QAAOA,GAAatG,EACtCpG,EAAM2M,MAAQA,EAAQvG,EACtBpG,EAAM4M,MAAQA,EAAQxG,EACtBpG,EAAMsO,qBAAuBzB,EAAcjG,GAEvC5G,EAAMkB,QAAU8F,WAAWgB,EAAOrH,MAAM,KAAK,MAAQwB,GAAWnC,EAAMkB,SAAW,KACnF3B,EAAMa,GAAwB6H,GAAcD,IAG9ChI,EAAMiM,QAAUjM,EAAMmM,QAAU,EAChCnM,EAAMuO,QAAU,aAChBvO,EAAMC,gBAAkBD,EAAMoB,IAAMoN,GAAuBrR,EAAcsR,GAAuBC,GAChG1O,EAAMmC,QAAU,EACTnC,CACT,EACIiI,GAAgB,SAAuBhJ,GACzC,OAAQA,EAAQA,EAAM0B,MAAM,MAAM,GAAK,IAAM1B,EAAM,EACrD,EAEA0P,GAAkB,SAAyBtP,EAAQgJ,EAAOpJ,GACxD,IAAI0H,GAAO,QAAQ0B,GACnB,OAAO,QAAOrB,WAAWqB,GAASrB,WAAWN,EAAerH,EAAQ,IAAKJ,EAAQ,KAAM0H,KAAUA,CACnG,EACI+H,GAAyB,SAAgCvQ,EAAO6B,GAClEA,EAAMuM,EAAI,MACVvM,EAAM0M,UAAY1M,EAAMyM,UAAY,OACpCzM,EAAMuO,QAAU,EAEhBE,GAAqBtQ,EAAO6B,EAC9B,EACI4O,GAAW,OACXC,GAAU,MACVC,GAAkB,KAClBL,GAAuB,SAA8BtQ,EAAO6B,GAC9D,IAAI+O,EAAO/O,GAASQ,KAChB0N,EAAWa,EAAKb,SAChBE,EAAWW,EAAKX,SAChBnN,EAAI8N,EAAK9N,EACToE,EAAI0J,EAAK1J,EACTkH,EAAIwC,EAAKxC,EACTC,EAAWuC,EAAKvC,SAChBE,EAAYqC,EAAKrC,UACjBD,EAAYsC,EAAKtC,UACjBE,EAAQoC,EAAKpC,MACbC,EAAQmC,EAAKnC,MACb/M,EAASkP,EAAKlP,OACdC,EAASiP,EAAKjP,OACdwO,EAAuBS,EAAKT,qBAC5BC,EAAUQ,EAAKR,QACflP,EAAS0P,EAAK1P,OACd6B,EAAU6N,EAAK7N,QACf8N,EAAa,GACbC,EAAoB,SAAZV,GAAsBpQ,GAAmB,IAAVA,IAA2B,IAAZoQ,EAG1D,GAAIrN,IAAYuL,IAAcmC,IAAYlC,IAAckC,IAAW,CACjE,IAGI7B,EAHAD,EAAQ9F,WAAW0F,GAAalP,EAChC8P,EAAMhQ,KAAK0P,IAAIF,GACfU,EAAMlQ,KAAKyP,IAAID,GAGnBA,EAAQ9F,WAAWyF,GAAajP,EAChCuP,EAAMzP,KAAKyP,IAAID,GACf7L,EAAI0N,GAAgBtP,EAAQ4B,EAAGqM,EAAMP,GAAO7L,GAC5CmE,EAAIsJ,GAAgBtP,EAAQgG,GAAI/H,KAAK0P,IAAIF,IAAU5L,GACnDqL,EAAIoC,GAAgBtP,EAAQkN,EAAGiB,EAAMT,GAAO7L,EAAUA,EACxD,CAEIoN,IAAyBO,KAC3BG,GAAc,eAAiBV,EAAuBQ,KAGpDZ,GAAYE,KACdY,GAAc,aAAed,EAAW,MAAQE,EAAW,QAGzDa,GAAShO,IAAM4N,IAAWxJ,IAAMwJ,IAAWtC,IAAMsC,MACnDG,GAAczC,IAAMsC,IAAWI,EAAQ,eAAiBhO,EAAI,KAAOoE,EAAI,KAAOkH,EAAI,KAAO,aAAetL,EAAI,KAAOoE,EAAIyJ,IAGrHtC,IAAaoC,KACfI,GAAc,UAAYxC,EAAWsC,IAGnCpC,IAAckC,KAChBI,GAAc,WAAatC,EAAYoC,IAGrCrC,IAAcmC,KAChBI,GAAc,WAAavC,EAAYqC,IAGrCnC,IAAUiC,IAAYhC,IAAUgC,KAClCI,GAAc,QAAUrC,EAAQ,KAAOC,EAAQkC,IAGlC,IAAXjP,GAA2B,IAAXC,IAClBkP,GAAc,SAAWnP,EAAS,KAAOC,EAASgP,IAGpDzP,EAAOE,MAAMY,GAAkB6O,GAAc,iBAC/C,EACIR,GAAuB,SAA8BrQ,EAAO6B,GAC9D,IAkBIkP,EACAC,EACAlC,EACAC,EACAtC,EAtBAwE,EAAQpP,GAASQ,KACjB0N,EAAWkB,EAAMlB,SACjBE,EAAWgB,EAAMhB,SACjBnN,EAAImO,EAAMnO,EACVoE,EAAI+J,EAAM/J,EACVmH,EAAW4C,EAAM5C,SACjBG,EAAQyC,EAAMzC,MACdC,EAAQwC,EAAMxC,MACd/M,EAASuP,EAAMvP,OACfC,EAASsP,EAAMtP,OACfT,EAAS+P,EAAM/P,OACfwM,EAAUuD,EAAMvD,QAChBE,EAAUqD,EAAMrD,QAChBE,EAAUmD,EAAMnD,QAChBE,EAAUiD,EAAMjD,QAChB8B,EAAWmB,EAAMnB,SACjB7B,EAAKpF,WAAW/F,GAChBoL,EAAKrF,WAAW3B,GAOpBmH,EAAWxF,WAAWwF,GACtBG,EAAQ3F,WAAW2F,IACnBC,EAAQ5F,WAAW4F,MAKjBD,GADAC,EAAQ5F,WAAW4F,GAEnBJ,GAAYI,GAGVJ,GAAYG,GACdH,GAAYhP,EACZmP,GAASnP,EACT0R,EAAM5R,KAAKyP,IAAIP,GAAY3M,EAC3BsP,EAAM7R,KAAK0P,IAAIR,GAAY3M,EAC3BoN,EAAM3P,KAAK0P,IAAIR,EAAWG,IAAU7M,EACpCoN,EAAM5P,KAAKyP,IAAIP,EAAWG,GAAS7M,EAE/B6M,IACFC,GAASpP,EACToN,EAAOtN,KAAK+R,IAAI1C,EAAQC,GAExBK,GADArC,EAAOtN,KAAKyQ,KAAK,EAAInD,EAAOA,GAE5BsC,GAAOtC,EAEHgC,IACFhC,EAAOtN,KAAK+R,IAAIzC,GAEhBsC,GADAtE,EAAOtN,KAAKyQ,KAAK,EAAInD,EAAOA,GAE5BuE,GAAOvE,IAIXsE,GAAM,QAAOA,GACbC,GAAM,QAAOA,GACblC,GAAM,QAAOA,GACbC,GAAM,QAAOA,KAEbgC,EAAMrP,EACNqN,EAAMpN,EACNqP,EAAMlC,EAAM,IAGVb,MAASnL,EAAI,IAAIH,QAAQ,OAASuL,MAAShH,EAAI,IAAIvE,QAAQ,SAC7DsL,EAAK1F,EAAerH,EAAQ,IAAK4B,EAAG,MACpCoL,EAAK3F,EAAerH,EAAQ,IAAKgG,EAAG,QAGlCwG,GAAWE,GAAWE,GAAWE,KACnCC,GAAK,QAAOA,EAAKP,GAAWA,EAAUqD,EAAMnD,EAAUkB,GAAOhB,GAC7DI,GAAK,QAAOA,EAAKN,GAAWF,EAAUsD,EAAMpD,EAAUmB,GAAOf,KAG3D+B,GAAYE,KAEdxD,EAAOvL,EAAOoF,UACd2H,GAAK,QAAOA,EAAK8B,EAAW,IAAMtD,EAAKzF,OACvCkH,GAAK,QAAOA,EAAK+B,EAAW,IAAMxD,EAAKxF,SAGzCwF,EAAO,UAAYsE,EAAM,IAAMC,EAAM,IAAMlC,EAAM,IAAMC,EAAM,IAAMd,EAAK,IAAMC,EAAK,IACnFhN,EAAO4C,aAAa,YAAa2I,GACjCqD,IAAa5O,EAAOE,MAAMY,GAAkByK,EAC9C,EACI0E,GAA0B,SAAiC1J,EAAQvG,EAAQC,EAAUkJ,EAAUG,GACjG,IAKI4G,EACAvJ,EANAwJ,EAAM,IACNC,GAAW,QAAU9G,GAErB+G,EADS1I,WAAW2B,IAAa8G,IAAa9G,EAAS7H,QAAQ,OAASzD,EAAW,GACjEmL,EAClBmH,EAAanH,EAAWkH,EAAS,MA4BrC,OAxBID,IAGgB,WAFlBF,EAAY5G,EAAShI,MAAM,KAAK,MAG9B+O,GAAUF,KAEKE,EAAS,MACtBA,GAAUA,EAAS,EAAIF,GAAM,KAIf,OAAdD,GAAsBG,EAAS,EACjCA,GAAUA,EAASF,MAAiBA,KAASE,EAASF,GAAOA,EACtC,QAAdD,GAAuBG,EAAS,IACzCA,GAAUA,EAASF,MAAiBA,KAASE,EAASF,GAAOA,IAIjE5J,EAAOK,IAAMD,EAAK,IAAI,KAAUJ,EAAOK,IAAK5G,EAAQC,EAAUkJ,EAAUkH,EAAQ9Q,GAChFoH,EAAGnH,EAAI8Q,EACP3J,EAAGrH,EAAI,MAEPiH,EAAOM,OAAO3E,KAAKjC,GAEZ0G,CACT,EACI4J,GAAU,SAAiBvQ,EAAQwQ,GAErC,IAAK,IAAItR,KAAKsR,EACZxQ,EAAOd,GAAKsR,EAAOtR,GAGrB,OAAOc,CACT,EACIyQ,GAAsB,SAA6BlK,EAAQoJ,EAAY3P,GAEzE,IAGI0Q,EACAxR,EACAmK,EACAC,EACAH,EACAI,EAEAE,EAVAkH,EAAaJ,GAAQ,CAAC,EAAGvQ,EAAOM,OAEhCJ,EAAQF,EAAOE,MA0BnB,IAAKhB,KAhBDyR,EAAW5O,KACbsH,EAAarJ,EAAOiC,aAAa,aACjCjC,EAAO4C,aAAa,YAAa,IACjC1C,EAAMY,GAAkB6O,EACxBe,EAAWhI,GAAgB1I,EAAQ,GAEnCmG,EAAgBnG,EAAQc,GAExBd,EAAO4C,aAAa,YAAayG,KAEjCA,EAAazF,iBAAiB5D,GAAQc,GACtCZ,EAAMY,GAAkB6O,EACxBe,EAAWhI,GAAgB1I,EAAQ,GACnCE,EAAMY,GAAkBuI,GAGhBtL,GACRsL,EAAasH,EAAWzR,OACxBoK,EAAWoH,EAASxR,KA7BR,gDA+B2BuC,QAAQvC,GAAK,IAIlDiK,GAFY,QAAQE,MACpBI,GAAU,QAAQH,IACiBjC,EAAerH,EAAQd,EAAGmK,EAAYI,GAAW9B,WAAW0B,GAC/FE,EAAS5B,WAAW2B,GACpB/C,EAAOK,IAAM,IAAI,KAAUL,EAAOK,IAAK8J,EAAUxR,EAAGiK,EAAUI,EAASJ,EAAUtK,GACjF0H,EAAOK,IAAItH,EAAImK,GAAW,EAE1BlD,EAAOM,OAAO3E,KAAKhD,IAIvBqR,GAAQG,EAAUC,EACpB,GAGA,QAAa,+BAA+B,SAAUC,EAAMjH,GAC1D,IAAI1K,EAAI,MACJgL,EAAI,QACJvK,EAAI,SACJmR,EAAI,OACJ/O,GAAS6H,EAAQ,EAAI,CAAC1K,EAAGgL,EAAGvK,EAAGmR,GAAK,CAAC5R,EAAI4R,EAAG5R,EAAIgL,EAAGvK,EAAIuK,EAAGvK,EAAImR,IAAIzF,KAAI,SAAU0F,GAClF,OAAOnH,EAAQ,EAAIiH,EAAOE,EAAO,SAAWA,EAAOF,CACrD,IAEA/H,GAAcc,EAAQ,EAAI,SAAWiH,EAAOA,GAAQ,SAAUrK,EAAQvG,EAAQC,EAAUqJ,EAAUmB,GAChG,IAAI/I,EAAGqP,EAEP,GAAIC,UAAUxO,OAAS,EAMrB,OAJAd,EAAII,EAAMsJ,KAAI,SAAUrC,GACtB,OAAOpH,GAAK4E,EAAQwC,EAAM9I,EAC5B,IAEmC,KADnC8Q,EAAOrP,EAAEoK,KAAK,MACFxK,MAAMI,EAAE,IAAIc,OAAed,EAAE,GAAKqP,EAGhDrP,GAAK4H,EAAW,IAAIhI,MAAM,KAC1ByP,EAAO,CAAC,EACRjP,EAAMP,SAAQ,SAAUwH,EAAMxG,GAC5B,OAAOwO,EAAKhI,GAAQrH,EAAEa,GAAKb,EAAEa,IAAMb,GAAGa,EAAI,GAAK,EAAI,EACrD,IACAgE,EAAO0K,KAAKjR,EAAQ+Q,EAAMtG,EAC5B,CACF,IAEO,IAuOIyG,GAAkB/D,GACvBgE,GAxOKC,GAAY,CACrBR,KAAM,MACNS,SAAUjN,EACVkN,WAAY,SAAoBtR,GAC9B,OAAOA,EAAOE,OAASF,EAAOuR,QAChC,EACAN,KAAM,SAAcjR,EAAQ+Q,EAAMtG,EAAOd,EAAO6H,GAC9C,IAGInI,EACAC,EACAC,EACAJ,EACA9F,EACAoO,EACAvS,EACAwK,EACAD,EACAiI,EACAC,EACAC,EACAjR,EACAwL,EACA0F,EACAC,EAlyBmElS,EACrE0B,EACAM,EACAoE,EA6wBElE,EAAQX,KAAK0F,OACb3G,EAAQF,EAAOE,MACf6R,EAAUtH,EAAMsG,KAAKgB,QAuBzB,IAAK7S,KANLxB,GAAkB0G,IAElBjD,KAAK6Q,OAAS7Q,KAAK6Q,QAAUjP,EAAe/C,GAC5C8R,EAAc3Q,KAAK6Q,OAAOlQ,MAC1BX,KAAKsJ,MAAQA,EAEHsG,EACR,GAAU,cAAN7R,IAIJoK,EAAWyH,EAAK7R,IAEZ,KAASA,MAAM,QAAaA,EAAG6R,EAAMtG,EAAOd,EAAO3J,EAAQwR,IAiB/D,GAZAnO,SAAciG,EACdmI,EAAc5I,GAAc3J,GAEf,aAATmE,IAEFA,SADAiG,EAAWA,EAAS9H,KAAKiJ,EAAOd,EAAO3J,EAAQwR,KAIpC,WAATnO,IAAsBiG,EAAS7H,QAAQ,aACzC6H,GAAW,QAAeA,IAGxBmI,EACFA,EAAYtQ,KAAMnB,EAAQd,EAAGoK,EAAUmB,KAAWoH,EAAc,QAC3D,GAAuB,OAAnB3S,EAAEuD,OAAO,EAAG,GAErB4G,GAAczF,iBAAiB5D,GAAQ6D,iBAAiB3E,GAAK,IAAI2I,OACjEyB,GAAY,GACZ,eAAsB,EAEjB,UAAeD,KAElBK,GAAY,QAAQL,GACpBI,GAAU,QAAQH,IAGpBG,EAAUC,IAAcD,IAAYJ,EAAahC,EAAerH,EAAQd,EAAGmK,EAAYI,GAAWA,GAAWC,IAAcJ,GAAYI,GACvIvI,KAAK8Q,IAAI/R,EAAO,cAAemJ,EAAYC,EAAUK,EAAO6H,EAAS,EAAG,EAAGtS,GAC3E4C,EAAMI,KAAKhD,GACX4S,EAAY5P,KAAKhD,EAAG,EAAGgB,EAAMhB,SACxB,GAAa,cAATmE,EAAsB,CAsC/B,GArCI0O,GAAW7S,KAAK6S,GAElB1I,EAAmC,mBAAf0I,EAAQ7S,GAAoB6S,EAAQ7S,GAAGsC,KAAKiJ,EAAOd,EAAO3J,EAAQwR,GAAWO,EAAQ7S,IACzG,QAAUmK,KAAgBA,EAAW5H,QAAQ,aAAe4H,GAAa,QAAeA,KACxF,QAAQA,EAAa,KAAsB,SAAfA,IAA0BA,GAAc,WAAcnK,KAAM,QAAQyC,GAAK3B,EAAQd,KAAO,IAEpF,OAA/BmK,EAAa,IAAInF,OAAO,KAAemF,EAAa1H,GAAK3B,EAAQd,KAElEmK,EAAa1H,GAAK3B,EAAQd,GAG5BiK,EAAWxB,WAAW0B,IACtBqI,EAAoB,WAATrO,GAA4C,MAAvBiG,EAASpF,OAAO,IAAcoF,EAAS7G,OAAO,EAAG,MACpE6G,EAAWA,EAAS7G,OAAO,IACxC8G,EAAS5B,WAAW2B,GAEhBpK,KAAKT,IACG,cAANS,IAEe,IAAbiK,GAAiD,WAA/BxH,GAAK3B,EAAQ,eAA8BuJ,IAE/DJ,EAAW,GAGb2I,EAAY5P,KAAK,aAAc,EAAGhC,EAAMgS,YAExC5L,EAAkBnF,KAAMjB,EAAO,aAAciJ,EAAW,UAAY,SAAUI,EAAS,UAAY,UAAWA,IAGtG,UAANrK,GAAuB,cAANA,KACnBA,EAAIT,EAAiBS,IAClBuC,QAAQ,OAASvC,EAAIA,EAAEoC,MAAM,KAAK,KAIzCqQ,EAAqBzS,KAAKnB,EAexB,GAZAoD,KAAK6Q,OAAO7O,KAAKjE,GAEZ0S,KACHjR,EAAQX,EAAOM,OACTM,kBAAoBmQ,EAAKoB,gBAAkBzJ,GAAgB1I,EAAQ+Q,EAAKoB,gBAE9EhG,GAA+B,IAAtB4E,EAAKqB,cAA0BzR,EAAMwL,QAC9CyF,EAAqBzQ,KAAKyF,IAAM,IAAI,KAAUzF,KAAKyF,IAAK1G,EAAOY,EAAgB,EAAG,EAAGH,EAAMC,gBAAiBD,EAAO,GAAI,IAEpG0R,IAAM,GAGjB,UAANnT,EACFiC,KAAKyF,IAAM,IAAI,KAAUzF,KAAKyF,IAAKjG,EAAO,SAAUA,EAAMF,QAASiR,GAAW,QAAe/Q,EAAMF,OAAQiR,EAAWnI,GAAUA,GAAU5I,EAAMF,QAAU,EAAG5B,GAC7JsC,KAAKyF,IAAItH,EAAI,EACbwC,EAAMI,KAAK,SAAUhD,GACrBA,GAAK,QACA,IAAU,oBAANA,EAAyB,CAClC4S,EAAY5P,KAAKnB,EAAsB,EAAGb,EAAMa,IA34BtDO,SACAM,SACAoE,SAFA1E,GADqE1B,EA64BtB0J,GA54BjChI,MAAM,KACpBM,EAAIN,EAAM,GACV0E,EAAI1E,EAAM,IAAM,MAEV,QAANM,GAAqB,WAANA,GAAwB,SAANoE,GAAsB,UAANA,IAEnDpG,EAAQgC,EACRA,EAAIoE,EACJA,EAAIpG,GAGN0B,EAAM,GAAK4I,GAAkBtI,IAAMA,EACnCN,EAAM,GAAK4I,GAAkBlE,IAAMA,EAg4BzBsD,EA/3BHhI,EAAMwK,KAAK,KAi4BJnL,EAAMoB,IACRkK,GAAgBjM,EAAQsJ,EAAU,EAAG6C,EAAQ,EAAGhL,QAEhDsI,EAAU9B,WAAW2B,EAAShI,MAAM,KAAK,KAAO,KAEpCX,EAAMkB,SAAWyE,EAAkBnF,KAAMR,EAAO,UAAWA,EAAMkB,QAAS4H,GAEtFnD,EAAkBnF,KAAMjB,EAAOhB,EAAG0J,GAAcS,GAAaT,GAAcU,KAG7E,QACF,CAAO,GAAU,cAANpK,EAAmB,CAC5B+M,GAAgBjM,EAAQsJ,EAAU,EAAG6C,EAAQ,EAAGhL,MAEhD,QACF,CAAO,GAAIjC,KAAK8L,GAAuB,CACrCiF,GAAwB9O,KAAMR,EAAOzB,EAAGiK,EAAUuI,GAAW,QAAevI,EAAUuI,EAAWpI,GAAYA,GAE7G,QACF,CAAO,GAAU,iBAANpK,EAAsB,CAC/BoH,EAAkBnF,KAAMR,EAAO,SAAUA,EAAMwL,OAAQ7C,GAEvD,QACF,CAAO,GAAU,YAANpK,EAAiB,CAC1ByB,EAAMzB,GAAKoK,EACX,QACF,CAAO,GAAU,cAANpK,EAAmB,CAC5BuR,GAAoBtP,KAAMmI,EAAUtJ,GAEpC,QACF,OACWd,KAAKgB,IAChBhB,EAAI4E,EAAiB5E,IAAMA,GAG7B,GAAIyS,IAAuBpI,GAAqB,IAAXA,KAAkBJ,GAAyB,IAAbA,KAAoB3K,EAAYuJ,KAAKuB,IAAapK,KAAKgB,EAExHqJ,IAAWA,EAAS,IADpBG,GAAaL,EAAa,IAAI5G,QAAQ0G,EAAW,IAAI3G,YAGrDiH,GAAU,QAAQH,KAAcpK,KAAK,WAAgB,WAAcA,GAAKwK,MAC9CP,EAAW9B,EAAerH,EAAQd,EAAGmK,EAAYI,IAC3EtI,KAAKyF,IAAM,IAAI,KAAUzF,KAAKyF,IAAK+K,EAAqBhR,EAAQT,EAAOhB,EAAGiK,GAAWuI,GAAW,QAAevI,EAAUuI,EAAWnI,GAAUA,GAAUJ,EAAWwI,GAAmC,OAAZlI,GAA0B,WAANvK,IAAsC,IAAnB6R,EAAKuB,UAA8CzT,EAAxBc,GAC5PwB,KAAKyF,IAAItH,EAAImK,GAAW,EAEpBC,IAAcD,GAAuB,MAAZA,IAE3BtI,KAAKyF,IAAIlH,EAAI2J,EACblI,KAAKyF,IAAIqD,EAAIxK,QAEV,GAAMP,KAAKgB,EAUhB4I,GAAuBtH,KAAKL,KAAMnB,EAAQd,EAAGmK,EAAYqI,EAAWA,EAAWpI,EAAWA,QAT1F,GAAIpK,KAAKc,EAEPmB,KAAK8Q,IAAIjS,EAAQd,EAAGmK,GAAcrJ,EAAOd,GAAIwS,EAAWA,EAAWpI,EAAWA,EAAUK,EAAO6H,QAC1F,GAAU,mBAANtS,EAAwB,EACjC,QAAeA,EAAGoK,GAElB,QACF,CAKFqI,IAAuBzS,KAAKgB,EAAQ4R,EAAY5P,KAAKhD,EAAG,EAAGgB,EAAMhB,IAAM4S,EAAY5P,KAAKhD,EAAG,EAAGmK,GAAcrJ,EAAOd,KACnH4C,EAAMI,KAAKhD,EACb,CAGF2S,IAAe,QAA0B1Q,KAC3C,EACAoR,OAAQ,SAAgBzT,EAAOC,GAC7B,GAAIA,EAAK0L,MAAMC,QAAU7M,IAGvB,IAFA,IAAI8I,EAAK5H,EAAK6H,IAEPD,GACLA,EAAGsD,EAAEnL,EAAO6H,EAAGiF,GACfjF,EAAKA,EAAGoD,WAGVhL,EAAKiT,OAAO9O,QAEhB,EACAsP,IAAK7Q,GACL8Q,QAAShU,EACTiU,UAAW,SAAmB1S,EAAQC,EAAUsG,GAE9C,IAAIrH,EAAIT,EAAiBwB,GAEzB,OADAf,GAAKA,EAAEuC,QAAQ,KAAO,IAAMxB,EAAWf,GAChCe,KAAYlC,GAAmBkC,IAAac,IAAyBf,EAAOM,MAAMsB,GAAKD,GAAK3B,EAAQ,MAAQuG,GAAU3I,IAAwB2I,EAAsB,UAAbtG,EAAuBM,EAAeF,GAAoBzC,EAAsB2I,GAAU,CAAC,KAAoB,UAAbtG,EAAuBS,EAAyBG,GAA8Bb,EAAOE,SAAU,QAAaF,EAAOE,MAAMD,IAAaF,GAAmBE,EAASwB,QAAQ,KAAOtB,GAAiB,QAAWH,EAAQC,EACvd,EACA0S,KAAM,CACJxM,gBAAiBA,EACjBkF,WAAYA,KAGhB,uBAAyBvH,EACzB,wBAA0Bf,EAEfmO,GAgBR,8CAhB0B/D,GAgBqB,2CAf5CgE,IAAM,QAAaD,GAAmB,IAAM/D,GAAzB+D,kFAAkD,SAAUN,GACjF7S,EAAgB6S,GAAQ,CAC1B,KAEA,QAAazD,IAAU,SAAUyD,GAC/B,WAAcA,GAAQ,MACtB5F,GAAsB4F,GAAQ,CAChC,IAEAnS,EAAiB0S,GAAI,KAAOD,GAAmB,IAAM/D,IAErD,QAI6K,8FAJvJ,SAAUyD,GAC9B,IAAItP,EAAQsP,EAAKtP,MAAM,KACvB7C,EAAiB6C,EAAM,IAAM6P,GAAI7P,EAAM,GACzC,KAGF,QAAa,gFAAgF,SAAUsP,GACrG,WAAcA,GAAQ,IACxB,IAEA,oBAAoBQ,ICriDpB,IAAIwB,GAAc,oBAAoBxB,KAAc,KAElCwB,GAAYD,KAAKE,MCJnC,SAASC,GAAkB9S,EAAQ8B,GAAS,IAAK,IAAIS,EAAI,EAAGA,EAAIT,EAAMU,OAAQD,IAAK,CAAE,IAAIwQ,EAAajR,EAAMS,GAAIwQ,EAAWC,WAAaD,EAAWC,aAAc,EAAOD,EAAWE,cAAe,EAAU,UAAWF,IAAYA,EAAWG,UAAW,GAAMC,OAAOC,eAAepT,EAAQ+S,EAAWM,IAAKN,EAAa,CAAE,CAe5T,IAAIO,GACAC,GAEA,GACA,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GAAW,WACb,OAAOX,IAA0B,oBAAXjP,SAA2BiP,GAAOjP,OAAOiP,OAASA,GAAKY,gBAAkBZ,EACjG,EACIa,GAAW,EACXC,GAAa,GACbC,GAAa,GACbC,GAAW,GACXC,GAAWC,KAAKC,IAChBC,GAAU,SAAiB9D,EAAMhR,GACnC,OAAOA,CACT,EAeI+U,GAAgB,SAAuB3Q,EAAS/D,GAClD,OAAQqU,GAAS7S,QAAQuC,IAAYsQ,GAASA,GAAS7S,QAAQuC,GAAW,GAAG/D,EAC/E,EACI2U,GAAc,SAAqBC,GACrC,SAAUhB,GAAMpS,QAAQoT,EAC1B,EACIC,GAAe,SAAsB9Q,EAASX,EAAM0R,EAAMC,EAASC,GACrE,OAAOjR,EAAQkR,iBAAiB7R,EAAM0R,EAAM,CAC1CC,SAAqB,IAAZA,EACTC,UAAWA,GAEf,EACIE,GAAkB,SAAyBnR,EAASX,EAAM0R,EAAME,GAClE,OAAOjR,EAAQoR,oBAAoB/R,EAAM0R,IAAQE,EACnD,EACII,GAAc,aACdC,GAAa,YACbC,GAAY,WACd,OAAOzB,IAAeA,GAAY0B,WAAanB,GAAW1T,OAC5D,EACI8U,GAAmB,SAA0B5J,EAAG6J,GAClD,IAAIC,EAAc,SAASA,EAAY/V,GAErC,GAAIA,GAAmB,IAAVA,EAAa,CACxBuU,KAAa,GAAKyB,QAAQC,kBAAoB,UAE9C,IAAIC,EAAgBhC,IAAeA,GAAY0B,UAC/C5V,EAAQ+V,EAAYlN,EAAIxK,KAAKkB,MAAMS,KAAWkU,IAAeA,GAAYiC,IAAM,EAAI,GAEnFlK,EAAEjM,GACF+V,EAAYK,QAAU3B,GAAW1T,MACjCmV,GAAiBpB,GAAQ,KAAM9U,EACjC,MAAW8V,GAAcrB,GAAW1T,QAAUgV,EAAYK,SAAWtB,GAAQ,UAC3EiB,EAAYK,QAAU3B,GAAW1T,MACjCgV,EAAYlN,EAAIoD,KAGlB,OAAO8J,EAAYlN,EAAIkN,EAAYM,MACrC,EAGA,OADAN,EAAYM,OAAS,EACdpK,GAAK8J,CACd,EACIO,GAAc,CAChB9W,EAAGiW,GACHnW,EAAG,OACHiX,GAAI,OACJC,GAAI,QACJC,IAAK,QACLzK,EAAG,QACH0K,GAAI,QACJ5U,EAAG,IACH6U,GAAId,IAAiB,SAAU7V,GAC7B,OAAOoR,UAAUxO,OAAS,GAAKgU,SAAS5W,EAAO6W,GAAUF,MAAQ,GAAKG,aAAe,GAAKrB,KAAgB7B,GAAO6B,KAAgB5B,GAAM4B,KAAgB,CACzJ,KAEEoB,GAAY,CACdrX,EAAGkW,GACHpW,EAAG,MACHiX,GAAI,MACJC,GAAI,SACJC,IAAK,SACLzK,EAAG,SACH0K,GAAI,SACJ5U,EAAG,IACHiV,GAAIT,GACJK,GAAId,IAAiB,SAAU7V,GAC7B,OAAOoR,UAAUxO,OAAS,GAAKgU,SAASN,GAAYK,KAAM3W,GAAS,GAAKgX,aAAe,GAAKtB,KAAe9B,GAAO8B,KAAe7B,GAAM6B,KAAe,CACxJ,KAEEuB,GAAa,SAAoB5X,EAAG6X,GACtC,OAAQA,GAAQA,EAAKC,MAAQD,EAAKC,KAAKC,UAAY1D,GAAK2D,MAAMC,SAASjY,GAAG,KAAoB,iBAANA,IAAmD,IAAjCqU,GAAK6D,SAASC,eAA2BC,QAAQC,KAAK,qBAAsBrY,GAAK,KAC7L,EACIsY,GAAiB,SAAwBvT,EAAS0L,GACpD,IAAItQ,EAAIsQ,EAAKtQ,EACTmX,EAAK7G,EAAK6G,GAEd3B,GAAY5Q,KAAaA,EAAU,GAAKwT,kBAAoBhE,IAE5D,IAAIjR,EAAI8R,GAAW5S,QAAQuC,GACvBiS,EAASM,IAAOE,GAAUF,GAAK,EAAI,IAErChU,IAAMA,EAAI8R,GAAWnS,KAAK8B,GAAW,GACvCqQ,GAAW9R,EAAI0T,IAAWnB,GAAa9Q,EAAS,SAAUuR,IAE1D,IAAIkC,EAAOpD,GAAW9R,EAAI0T,GACtBlB,EAAO0C,IAASpD,GAAW9R,EAAI0T,GAAUR,GAAiBd,GAAc3Q,EAAS5E,IAAI,KAAUwV,GAAY5Q,GAAWuS,EAAKd,IAAiB,SAAU7V,GACxJ,OAAOoR,UAAUxO,OAASwB,EAAQ5E,GAAKQ,EAAQoE,EAAQ5E,EACzD,MAIA,OAHA2V,EAAK/U,OAASgE,EACdyT,IAAS1C,EAAK5I,OAAyD,WAAhDmH,GAAKoE,YAAY1T,EAAS,mBAE1C+Q,CACT,EACI4C,GAAmB,SAA0B/X,EAAOgY,EAAgBC,GACtE,IAAIC,EAAKlY,EACLmY,EAAKnY,EACLkO,EAAKyG,KACLxG,EAAKD,EACLkK,EAAMJ,GAAkB,GACxBK,EAAiBha,KAAKia,IAAI,IAAW,EAANF,GAC/BG,EAAS,SAAgBvY,EAAOwY,GAClC,IAAInZ,EAAIsV,KAEJ6D,GAASnZ,EAAI6O,EAAKkK,GACpBD,EAAKD,EACLA,EAAKlY,EACLmO,EAAKD,EACLA,EAAK7O,GACI4Y,EACTC,GAAMlY,EAGNkY,EAAKC,GAAMnY,EAAQmY,IAAO9Y,EAAI8O,IAAOD,EAAKC,EAE9C,EAcA,MAAO,CACLoK,OAAQA,EACRE,MAfU,WACVN,EAAKD,EAAKD,EAAW,EAAIC,EACzB/J,EAAKD,EAAK,CACZ,EAaEwK,YAZgB,SAAqBC,GACrC,IAAIC,EAAOzK,EACP0K,EAAOV,EACP9Y,EAAIsV,KAGR,OADCgE,GAA+B,IAAhBA,IAAsBA,IAAgBT,GAAMK,EAAOI,GAC5DzK,IAAOC,GAAM9O,EAAI8O,EAAKkK,EAAiB,GAAKH,GAAMD,EAAWY,GAAQA,MAAWZ,EAAW5Y,EAAI6O,GAAM0K,GAAQ,GACtH,EAOF,EACIE,GAAY,SAAmBlZ,EAAGmZ,GAEpC,OADAA,IAAmBnZ,EAAEoZ,YAAcpZ,EAAEmZ,iBAC9BnZ,EAAEqZ,eAAiBrZ,EAAEqZ,eAAe,GAAKrZ,CAClD,EACIsZ,GAAkB,SAAyBpX,GAC7C,IAAIwW,EAAMja,KAAKia,IAAIa,MAAM9a,KAAMyD,GAC3BsW,EAAM/Z,KAAK+Z,IAAIe,MAAM9a,KAAMyD,GAC/B,OAAOzD,KAAK0Q,IAAIuJ,IAAQja,KAAK0Q,IAAIqJ,GAAOE,EAAMF,CAChD,EACIgB,GAAoB,WA9JP,IACXrG,EACA5T,EACAka,EACAC,GA2JJtF,GAAgBN,GAAKX,KAAKwG,UAAUvF,gBACnBA,GAAcjB,OA/J3BA,EAAOiB,GAAcjB,KACrB5T,EAAO4T,EAAKyG,QAAU,CAAC,EACvBH,EAAYtG,EAAK0B,WACjB6E,EAAUvG,EAAK2B,SACnB2E,EAAU/W,KAAK6W,MAAME,EAAW5E,IAChC6E,EAAQhX,KAAK6W,MAAMG,EAAS5E,IAC5BD,GAAa4E,EACb3E,GAAW4E,EAEXxE,GAAU,SAAiB9D,EAAMhR,GAC/B,OAAOb,EAAK6R,GAAMhR,EACpB,EAqJF,EACI,GAAY,SAAmB+S,GA0BjC,OAzBAW,GAAOX,GAAQsB,MAEVV,IAAgBD,IAA4B,oBAAbhP,UAA4BA,SAASgE,OACvE,GAAOjE,OACP,GAAOC,SACPkP,GAAS,GAAKjP,gBACdkP,GAAQ,GAAKnL,KACbuL,GAAQ,CAAC,GAAM,GAAML,GAAQC,IACpBH,GAAK2D,MAAMoC,MAEpBrF,GAAWV,GAAKX,KAAK2G,SAAW,WAAa,EAE7C3F,GAAe,mBAAoBF,GAAQ,UAAY,QAEvDC,GAAW6F,GAASC,QAAU,GAAKC,YAAc,GAAKA,WAAW,oCAAoCC,QAAU,EAAI,iBAAkB,IAAQC,UAAUC,eAAiB,GAAKD,UAAUE,iBAAmB,EAAI,EAAI,EAClN9F,GAAcwF,GAASO,YAAc,iBAAkBtG,GAAS,4CAAgD,kBAAmBA,GAAkD,kDAAxC,uCAA2FlS,MAAM,KAC9OyY,YAAW,WACT,OAAO5F,GAAW,CACpB,GAAG,KAEH6E,KAEAzF,GAAe,GAGVA,EACT,EAEA2C,GAAYS,GAAKF,GACjBpC,GAAW1T,MAAQ,EACZ,IAAI4Y,GAAwB,WACjC,SAASA,EAASxI,GAChB5P,KAAK8P,KAAKF,EACZ,CAEA,IA5OoBiJ,EAAaC,EAAYC,EAspB7C,OA1aaX,EAASY,UAEflJ,KAAO,SAAcF,GAC1BwC,IAAgB,GAAUD,KAAS+D,QAAQC,KAAK,wCAChD1D,IAAiBoF,KACjB,IAAIoB,EAAYrJ,EAAKqJ,UACjBC,EAActJ,EAAKsJ,YACnBhX,EAAO0N,EAAK1N,KACZrD,EAAS+Q,EAAK/Q,OACdsa,EAAavJ,EAAKuJ,WAClBC,EAAWxJ,EAAKwJ,SAChB5B,EAAiB5H,EAAK4H,eACtB6B,EAASzJ,EAAKyJ,OACdC,EAAc1J,EAAK0J,YACnBC,EAAS3J,EAAK2J,OACdC,EAAa5J,EAAK4J,WAClBC,EAAQ7J,EAAK6J,MACbC,EAAc9J,EAAK8J,YACnBC,EAAY/J,EAAK+J,UACjBC,EAAShK,EAAKgK,OACdC,EAAUjK,EAAKiK,QACfC,EAAYlK,EAAKkK,UACjBC,EAAUnK,EAAKmK,QACfC,EAASpK,EAAKoK,OACdC,EAAOrK,EAAKqK,KACZC,EAAStK,EAAKsK,OACdC,EAAYvK,EAAKuK,UACjBC,EAAYxK,EAAKwK,UACjBC,EAAWzK,EAAKyK,SAChBC,EAAY1K,EAAK0K,UACjBC,EAAY3K,EAAK2K,UACjBC,EAAU5K,EAAK4K,QACfC,EAAa7K,EAAK6K,WAClBC,EAAS9K,EAAK8K,OACdC,EAAc/K,EAAK+K,YACnBC,EAAehL,EAAKgL,aACpBC,EAAiBjL,EAAKiL,eACtBC,EAAelL,EAAKkL,aACpBC,EAAUnL,EAAKmL,QACfC,EAAWpL,EAAKoL,SAChBC,EAAYrL,EAAKqL,UACjBC,EAAUtL,EAAKsL,QACfC,EAAcvL,EAAKuL,YACnBrH,EAAUlE,EAAKkE,QACfsH,EAAcxL,EAAKwL,YACnBC,EAAWzL,EAAKyL,SAChBC,EAAa1L,EAAK0L,WACtBtb,KAAKnB,OAASA,EAAS6W,GAAW7W,IAAWwT,GAC7CrS,KAAK4P,KAAOA,EACZ2J,IAAWA,EAASpH,GAAK2D,MAAMC,QAAQwD,IACvCN,EAAYA,GAAa,KACzBC,EAAcA,GAAe,EAC7BM,EAAaA,GAAc,EAC3B2B,EAAcA,GAAe,EAC7BjZ,EAAOA,GAAQ,sBACfkX,GAAwB,IAAbA,EACXD,IAAeA,EAAa3S,WAAW,GAAK/D,iBAAiB6P,IAAO6G,aAAe,IAEnF,IAAIoC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAlG,EAAO3V,KACP8b,EAAa,EACbC,EAAa,EACblI,EAAUjE,EAAKiE,UAAY2D,EAC3BwE,GAAc5F,GAAevX,EAAQkW,IACrCkH,GAAc7F,GAAevX,EAAQyW,IACrC4G,GAAUF,KACVG,GAAUF,KACVG,IAAgBla,EAAK5B,QAAQ,YAAc4B,EAAK5B,QAAQ,YAAiC,gBAAnBsS,GAAY,GAEtFyJ,GAAa5I,GAAY5U,GACrByd,GAAWzd,EAAO0d,eAAiB,GACnCC,GAAS,CAAC,EAAG,EAAG,GAEpBC,GAAS,CAAC,EAAG,EAAG,GACZC,GAAc,EACdC,GAAe,WACjB,OAAOD,GAActJ,IACvB,EACIwJ,GAAe,SAAsBve,EAAGwe,GAC1C,OAAQlH,EAAK8D,MAAQpb,IAAMkb,IAAWA,EAAOjZ,QAAQjC,EAAEQ,SAAWge,GAAoBT,IAAkC,UAAlB/d,EAAEye,aAA2BnC,GAAeA,EAAYtc,EAAGwe,EACnK,EASI7F,GAAS,WACX,IAAI+F,EAAKpH,EAAK6G,OAAS7E,GAAgB6E,IACnCQ,EAAKrH,EAAK8G,OAAS9E,GAAgB8E,IACnCQ,EAAWngB,KAAK0Q,IAAIuP,IAAO9D,EAC3BiE,EAAWpgB,KAAK0Q,IAAIwP,IAAO/D,EAE/BoB,IAAa4C,GAAYC,IAAa7C,EAAS1E,EAAMoH,EAAIC,EAAIR,GAAQC,IAEjEQ,IACFlD,GAAWpE,EAAK6G,OAAS,GAAKzC,EAAQpE,GACtCqE,GAAUrE,EAAK6G,OAAS,GAAKxC,EAAOrE,GACpCwE,GAAaA,EAAUxE,GACvB2E,GAAa3E,EAAK6G,OAAS,GAAMV,EAAa,GAAKxB,EAAU3E,GAC7DmG,EAAanG,EAAK6G,OAClBA,GAAO,GAAKA,GAAO,GAAKA,GAAO,GAAK,GAGlCU,IACFhD,GAAUvE,EAAK8G,OAAS,GAAKvC,EAAOvE,GACpCsE,GAAQtE,EAAK8G,OAAS,GAAKxC,EAAKtE,GAChCyE,GAAaA,EAAUzE,GACvB4E,GAAa5E,EAAK8G,OAAS,GAAMV,EAAa,GAAKxB,EAAU5E,GAC7DoG,EAAapG,EAAK8G,OAClBA,GAAO,GAAKA,GAAO,GAAKA,GAAO,GAAK,IAGlCf,GAASD,KACXf,GAAUA,EAAO/E,GAEb8F,IACF7B,EAAOjE,GACP8F,GAAU,GAGZC,GAAQ,GAGVE,KAAYA,GAAS,IAAUN,GAAcA,EAAW3F,GAEpDgG,IACFZ,EAAQpF,GACRgG,GAAU,GAGZJ,EAAK,CACP,EACI4B,GAAU,SAAiB1c,EAAGoE,EAAG2D,GACnCgU,GAAOhU,IAAU/H,EACjBgc,GAAOjU,IAAU3D,EAEjB8Q,EAAKyH,IAAIpG,OAAOvW,GAEhBkV,EAAK0H,IAAIrG,OAAOnS,GAEhBuU,EAAWmC,IAAOA,EAAK+B,sBAAsBtG,KAAWA,IAC1D,EACIuG,GAAwB,SAA+B9c,EAAGoE,GACxDwW,IAAaQ,IACflG,EAAKkG,KAAOA,EAAO/e,KAAK0Q,IAAI/M,GAAK3D,KAAK0Q,IAAI3I,GAAK,IAAM,IACrD+W,GAAS,GAGE,MAATC,IACFW,GAAO,IAAM/b,EAEbkV,EAAKyH,IAAIpG,OAAOvW,GAAG,IAIR,MAATob,IACFY,GAAO,IAAM5X,EAEb8Q,EAAK0H,IAAIrG,OAAOnS,GAAG,IAGrBuU,EAAWmC,IAAOA,EAAK+B,sBAAsBtG,KAAWA,IAC1D,EACIwG,GAAU,SAAiBnf,GAC7B,IAAIue,GAAave,EAAG,GAApB,CAKA,IAAIoC,GADJpC,EAAIkZ,GAAUlZ,EAAGmZ,IACPiG,QACN5Y,EAAIxG,EAAEqf,QACNX,EAAKtc,EAAIkV,EAAKlV,EACduc,EAAKnY,EAAI8Q,EAAK9Q,EACd8Y,EAAahI,EAAKgI,WACtBhI,EAAKlV,EAAIA,EACTkV,EAAK9Q,EAAIA,GAEL8Y,GAAc7gB,KAAK0Q,IAAImI,EAAKiI,OAASnd,IAAMyY,GAAepc,KAAK0Q,IAAImI,EAAKkI,OAAShZ,IAAMqU,KACzFU,IAAW6B,GAAU,GACrBkC,IAAehI,EAAKgI,YAAa,GACjCJ,GAAsBR,EAAIC,GAC1BW,GAAcjE,GAAeA,EAAY/D,GAf3C,CAiBF,EACImI,GAAWnI,EAAKkE,QAAU,SAAUxb,GAClCue,GAAave,EAAG,IAAMA,GAAKA,EAAE0f,SAIjCpI,EAAKkG,KAAOA,EAAO,KACnBL,EAAkBwC,QAClBrI,EAAKtB,WAAY,EACjBhW,EAAIkZ,GAAUlZ,GAEdyd,EAAaC,EAAa,EAC1BpG,EAAKiI,OAASjI,EAAKlV,EAAIpC,EAAEof,QACzB9H,EAAKkI,OAASlI,EAAK9Q,EAAIxG,EAAEqf,QAEzB/H,EAAKyH,IAAIlG,QAGTvB,EAAK0H,IAAInG,QAETvD,GAAaiH,EAAe/b,EAASyd,GAAU1J,GAAY,GAAI4K,GAAS3J,GAAS,GAEjF8B,EAAK6G,OAAS7G,EAAK8G,OAAS,EAC5B5C,GAAWA,EAAQlE,GACrB,EACIsI,GAAatI,EAAKmE,UAAY,SAAUzb,GAC1C,IAAIue,GAAave,EAAG,GAApB,CAIA2V,GAAgB4G,EAAe/b,EAASyd,GAAU1J,GAAY,GAAI4K,IAAS,GAE3E,IAAIU,GAAkBC,MAAMxI,EAAK9Q,EAAI8Q,EAAKkI,QACtCO,EAAczI,EAAKgI,WACnBU,EAAiBD,IAAgBthB,KAAK0Q,IAAImI,EAAKlV,EAAIkV,EAAKiI,QAAU,GAAK9gB,KAAK0Q,IAAImI,EAAK9Q,EAAI8Q,EAAKkI,QAAU,GAE5GS,EAAY/G,GAAUlZ,IAEjBggB,GAAkBH,IACrBvI,EAAKyH,IAAIlG,QAETvB,EAAK0H,IAAInG,QAGLM,GAAkB4D,GACpBjJ,GAAKoM,YAAY,KAAM,WAErB,GAAInL,KAAasJ,GAAc,MAAQre,EAAEmgB,iBACvC,GAAIngB,EAAEQ,OAAO4f,MAEXpgB,EAAEQ,OAAO4f,aACJ,GAAInC,GAASoC,YAAa,CAC/B,IAAIC,EAAiBrC,GAASoC,YAAY,eAC1CC,EAAeC,eAAe,SAAS,GAAM,EAAM,GAAM,EAAGN,EAAUO,QAASP,EAAUQ,QAASR,EAAUb,QAASa,EAAUZ,SAAS,GAAO,GAAO,GAAO,EAAO,EAAG,MACvKrf,EAAEQ,OAAOkgB,cAAcJ,EACzB,CAEJ,KAIJhJ,EAAKgI,WAAahI,EAAKqJ,YAAcrJ,EAAKtB,WAAY,EACtDgF,GAAU+E,IAAgBxD,GAAgBY,EAAkByD,SAAQ,GACpEtF,GAAayE,GAAezE,EAAUhE,GACtCmE,GAAaA,EAAUnE,EAAM0I,EApC7B,CAqCF,EACIa,GAAkB,SAAyB7gB,GAC7C,OAAOA,EAAE8gB,SAAW9gB,EAAE8gB,QAAQ9d,OAAS,IAAMsU,EAAKqJ,aAAc,IAASnE,EAAexc,EAAGsX,EAAKgI,WAClG,EACIyB,GAAgB,WAClB,OAAQzJ,EAAKqJ,aAAc,IAAUlE,EAAanF,EACpD,EACI0J,GAAW,SAAkBhhB,GAC/B,IAAIue,GAAave,GAAjB,CAIA,IAAIoC,EAAIub,KACJnX,EAAIoX,KACRkB,IAAS1c,EAAIyb,IAAWf,GAActW,EAAIsX,IAAWhB,EAAa,GAClEe,GAAUzb,EACV0b,GAAUtX,EACVwU,GAAUmC,EAAkByD,SAAQ,EAPpC,CAQF,EACIK,GAAW,SAAkBjhB,GAC/B,IAAIue,GAAave,GAAjB,CAIAA,EAAIkZ,GAAUlZ,EAAGmZ,GACjBuD,IAAYY,GAAU,GACtB,IAAI4D,GAA8B,IAAhBlhB,EAAEmhB,UAAkBrG,EAA6B,IAAhB9a,EAAEmhB,UAAkB,GAAKC,YAAc,GAAKjG,EAC/F2D,GAAQ9e,EAAEme,OAAS+C,EAAYlhB,EAAEoe,OAAS8C,EAAY,GACtDlG,IAAWuB,GAAgBY,EAAkByD,SAAQ,EANrD,CAOF,EACIS,GAAU,SAAiBrhB,GAC7B,IAAIue,GAAave,GAAjB,CAIA,IAAIoC,EAAIpC,EAAEof,QACN5Y,EAAIxG,EAAEqf,QACNX,EAAKtc,EAAIkV,EAAKlV,EACduc,EAAKnY,EAAI8Q,EAAK9Q,EAClB8Q,EAAKlV,EAAIA,EACTkV,EAAK9Q,EAAIA,EACT6W,GAAQ,EACRrC,GAAUmC,EAAkByD,SAAQ,IACnClC,GAAMC,IAAOO,GAAsBR,EAAIC,EAVxC,CAWF,EACI2C,GAAW,SAAkBthB,GAC/BsX,EAAK8D,MAAQpb,EACbmc,EAAQ7E,EACV,EACIiK,GAAc,SAAqBvhB,GACrCsX,EAAK8D,MAAQpb,EACboc,EAAW9E,EACb,EACIkK,GAAW,SAAkBxhB,GAC/B,OAAOue,GAAave,IAAMkZ,GAAUlZ,EAAGmZ,IAAmB0D,EAAQvF,EACpE,EAEA6F,EAAoB7F,EAAKmK,IAAM3N,GAAKoM,YAAYjF,GAAe,KAnO9C,WACf3D,EAAKyH,IAAIlG,QAETvB,EAAK0H,IAAInG,QAETsE,EAAkBwC,QAClB3E,GAAUA,EAAO1D,EACnB,IA4NiFqI,QACjFrI,EAAK6G,OAAS7G,EAAK8G,OAAS,EAC5B9G,EAAKyH,IAAM5G,GAAiB,EAAG,IAAI,GACnCb,EAAK0H,IAAM7G,GAAiB,EAAG,IAAI,GACnCb,EAAKuG,QAAUF,GACfrG,EAAKwG,QAAUF,GACftG,EAAKgI,WAAahI,EAAKqJ,YAAcrJ,EAAKtB,WAAY,EAEtDxB,GAAS7S,MAET2V,EAAKoK,OAAS,SAAU1hB,GA4BtB,OA3BKsX,EAAKqK,YACRrM,GAAa0I,GAAaC,GAAWzd,EAAQ,SAAUuV,IAEvDlS,EAAK5B,QAAQ,WAAa,GAAKqT,GAAa0I,GAAaC,GAAWzd,EAAQ,SAAUwgB,GAAUxL,EAASC,GACzG5R,EAAK5B,QAAQ,UAAY,GAAKqT,GAAa9U,EAAQ,QAASygB,GAAUzL,EAASC,IAE3E5R,EAAK5B,QAAQ,UAAY,GAAKiS,IAAYrQ,EAAK5B,QAAQ,YAAc,KACvEqT,GAAa9U,EAAQ+T,GAAY,GAAIkL,GAAUjK,EAASC,GAExDH,GAAa2I,GAAU1J,GAAY,GAAIqL,IAEvCtK,GAAa2I,GAAU1J,GAAY,GAAIqL,IAEvC7C,GAAezH,GAAa9U,EAAQ,QAAS8d,IAAc,GAAM,GACjEzB,GAAWvH,GAAa9U,EAAQ,QAASghB,IACzChF,GAAkBlH,GAAa2I,GAAU,eAAgB4C,IACzDpE,GAAgBnH,GAAa2I,GAAU,aAAc8C,IACrD5E,GAAW7G,GAAa9U,EAAQ2T,GAAe,QAASmN,IACxDlF,GAAc9G,GAAa9U,EAAQ2T,GAAe,QAASoN,IAC3DlF,GAAU/G,GAAa9U,EAAQ2T,GAAe,OAAQkN,KAGxD/J,EAAKqK,WAAY,EACjB3hB,GAAKA,EAAE6D,MAAQ4b,GAASzf,GACxB2c,GAAYA,EAASrF,IAGhBA,CACT,EAEAA,EAAKsK,QAAU,WACTtK,EAAKqK,YAEP/M,GAAWiN,QAAO,SAAUC,GAC1B,OAAOA,IAAMxK,GAAQlC,GAAY0M,EAAEthB,OACrC,IAAGwC,QAAU2S,GAAgBqI,GAAaC,GAAWzd,EAAQ,SAAUuV,IAEnEuB,EAAKtB,YACPsB,EAAKyH,IAAIlG,QAETvB,EAAK0H,IAAInG,QAETlD,GAAgB4G,EAAe/b,EAASyd,GAAU1J,GAAY,GAAI4K,IAAS,IAG7ExJ,GAAgBqI,GAAaC,GAAWzd,EAAQ,SAAUwgB,GAAUvL,GAEpEE,GAAgBnV,EAAQ,QAASygB,GAAUxL,GAE3CE,GAAgBnV,EAAQ+T,GAAY,GAAIkL,GAAUhK,GAElDE,GAAgBsI,GAAU1J,GAAY,GAAIqL,IAE1CjK,GAAgBsI,GAAU1J,GAAY,GAAIqL,IAE1CjK,GAAgBnV,EAAQ,QAAS8d,IAAc,GAE/C3I,GAAgBnV,EAAQ,QAASghB,IAEjC7L,GAAgBsI,GAAU,eAAgB4C,IAE1ClL,GAAgBsI,GAAU,aAAc8C,IAExCpL,GAAgBnV,EAAQ2T,GAAe,QAASmN,IAEhD3L,GAAgBnV,EAAQ2T,GAAe,QAASoN,IAEhD5L,GAAgBnV,EAAQ2T,GAAe,OAAQkN,IAE/C/J,EAAKqK,UAAYrK,EAAKtB,UAAYsB,EAAKgI,YAAa,EACpD1C,GAAaA,EAAUtF,GAE3B,EAEAA,EAAKyK,KAAOzK,EAAK5T,OAAS,WACxB4T,EAAKsK,UAEL,IAAI7e,EAAI6R,GAAW3S,QAAQqV,GAE3BvU,GAAK,GAAK6R,GAAWoN,OAAOjf,EAAG,GAC/BuR,KAAgBgD,IAAShD,GAAc,EACzC,EAEAM,GAAWlS,KAAK4U,GAEhBiF,GAAgBnH,GAAY5U,KAAY8T,GAAcgD,GACtDA,EAAKoK,OAAOtG,EACd,EAxoBoBZ,EA0oBPT,GA1oBoBU,EA0oBV,CAAC,CACtB5G,IAAK,YACLb,IAAK,WACH,OAAOrR,KAAKod,IAAIjG,aAClB,GACC,CACDjF,IAAK,YACLb,IAAK,WACH,OAAOrR,KAAKqd,IAAIlG,aAClB,MAnpB0ExF,GAAkBkH,EAAYG,UAAWF,GAAiBC,GAAapH,GAAkBkH,EAAaE,GAspB3KX,CACT,CAhbmC,GAibnCA,GAASkI,QAAU,SAEnBlI,GAASmI,OAAS,SAAU3Q,GAC1B,OAAO,IAAIwI,GAASxI,EACtB,EAEAwI,GAASlI,SAAW,GAEpBkI,GAASoI,OAAS,WAChB,OAAOvN,GAAW3F,OACpB,EAEA8K,GAASqI,QAAU,SAAUlF,GAC3B,OAAOtI,GAAWiN,QAAO,SAAUC,GACjC,OAAOA,EAAEvQ,KAAK2L,KAAOA,CACvB,IAAG,EACL,EAEAzI,MAAcX,GAAKY,eAAeqF,IC/pBlC,IAAI,GACA,GACA,GACA,GACA,GACA,GACA,GACAsI,GACAC,GACA,GACAC,GACAC,GACAC,GACAC,GACA,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GACA,GACAC,GACAC,GACAC,GACAC,GACA,GACAC,GACAC,GACAC,GACAC,GACAC,GACAC,GAoUAC,GA8EAC,GAEAC,GAqHAC,GAvgBJ,GAAW,EACP,GAAW/O,KAAKC,IAChB+O,GAAS,KACTC,GAAkB,EAClBC,GAAW,EACXC,GAAc,SAAqB/jB,EAAOyD,EAAMyT,GAClD,IAAIuC,EAAQuK,GAAUhkB,KAAkC,WAAvBA,EAAM6C,OAAO,EAAG,IAAmB7C,EAAM6B,QAAQ,QAAU,GAE5F,OADAqV,EAAK,IAAMzT,EAAO,SAAWgW,EACtBA,EAAQzZ,EAAM6C,OAAO,EAAG7C,EAAM4C,OAAS,GAAK5C,CACrD,EACIikB,GAAa,SAAoBjkB,EAAOyZ,GAC1C,OAAOA,GAAWuK,GAAUhkB,IAAiC,WAAvBA,EAAM6C,OAAO,EAAG,GAA4C7C,EAAzB,SAAWA,EAAQ,GAC9F,EACIkkB,GAAa,SAASA,IACxB,OAAOJ,IAAYjF,sBAAsBqF,EAC3C,EAEAC,GAAsB,WACpB,OAAO7B,GAAiB,CAC1B,EACI8B,GAAoB,WACtB,OAAO9B,GAAiB,CAC1B,EACI+B,GAAe,SAAsBxb,GACvC,OAAOA,CACT,EACIyb,GAAS,SAAgBtkB,GAC3B,OAAO3B,KAAKkB,MAAc,IAARS,GAAkB,KAAU,CAChD,EACI,GAAgB,WAClB,MAAyB,oBAAXyE,MAChB,EACI,GAAW,WACb,OAAO,IAAQ,OAAoB,GAAOA,OAAOiP,OAAS,GAAKY,gBAAkB,EACnF,EACI,GAAc,SAAqB1U,GACrC,SAAU,GAAMiC,QAAQjC,EAC1B,EACI2kB,GAAwB,SAA+BC,GACzD,OAA8B,WAAtBA,EAAiCpB,GAAS,GAAK,QAAUoB,KAAuB,GAAO,SAAWA,IAAsB,GAAM,SAAWA,EACnJ,EACIC,GAAiB,SAAwBrgB,GAC3C,OAAO2Q,GAAc3Q,EAAS,2BAA6B,GAAYA,GAAW,WAGhF,OAFAsgB,GAAYxe,MAAQ,GAAKye,WACzBD,GAAYve,OAASid,GACdsB,EACT,EAAI,WACF,OAAOE,GAAWxgB,EACpB,EACF,EAgBIygB,GAAa,SAAoBzgB,EAAS+L,GAC5C,IAAI3Q,EAAI2Q,EAAM3Q,EACVkX,EAAKvG,EAAMuG,GACX1K,EAAImE,EAAMnE,EACVlK,EAAIqO,EAAMrO,EACd,OAAOzD,KAAKia,IAAI,GAAI9Y,EAAI,SAAWkX,KAAQ5U,EAAIiT,GAAc3Q,EAAS5E,IAAMsC,IAAM2iB,GAAergB,EAAfqgB,GAA0BzY,GAAK,GAAY5H,IAAY,GAAO5E,IAAM,GAAMA,IAAM+kB,GAAsB7N,GAAMtS,EAAQ5E,GAAK4E,EAAQ,SAAWsS,GAChO,EACIoO,GAAsB,SAA6B3P,EAAM4P,GAC3D,IAAK,IAAIpiB,EAAI,EAAGA,EAAI+f,GAAa9f,OAAQD,GAAK,IAC1CoiB,IAAWA,EAAOljB,QAAQ6gB,GAAa/f,EAAI,MAAQwS,EAAKuN,GAAa/f,GAAI+f,GAAa/f,EAAI,GAAI+f,GAAa/f,EAAI,GAErH,EACIqhB,GAAY,SAAmBhkB,GACjC,MAAwB,iBAAVA,CAChB,EACIglB,GAAc,SAAqBhlB,GACrC,MAAwB,mBAAVA,CAChB,EACIilB,GAAY,SAAmBjlB,GACjC,MAAwB,iBAAVA,CAChB,EACIklB,GAAY,SAAmBllB,GACjC,MAAwB,iBAAVA,CAChB,EACImlB,GAAgB,SAAuBC,EAAWC,EAAU9F,GAC9D,OAAO6F,GAAaA,EAAUE,SAASD,EAAW,EAAI,IAAM9F,GAAS6F,EAAU7F,OACjF,EACIgG,GAAY,SAAmBrO,EAAM/B,GACvC,GAAI+B,EAAKsO,QAAS,CAChB,IAAInc,EAAS6N,EAAKC,KAAOD,EAAKC,KAAK9E,KAAI,WACrC,OAAO8C,EAAK+B,EACd,IAAK/B,EAAK+B,GACV7N,GAAUA,EAAOoc,YAAcvO,EAAKwO,kBAAoBrc,EAC1D,CACF,EACIsc,GAAOtnB,KAAK0Q,IACZ6W,GAAQ,OAERC,GAAS,QACTC,GAAU,SACVC,GAAS,QACTC,GAAU,SACVC,GAAS,QACTC,GAAQ,OACRC,GAAO,MACPC,GAAU,SACVC,GAAW,UACXC,GAAU,SACVC,GAAS,QACTC,GAAU,SACVC,GAAM,KACNC,GAAoB,SAA2BtiB,GACjD,OAAO,GAAKJ,iBAAiBI,EAC/B,EAOIuiB,GAAe,SAAsBC,EAAKC,GAC5C,IAAK,IAAIvnB,KAAKunB,EACZvnB,KAAKsnB,IAAQA,EAAItnB,GAAKunB,EAASvnB,IAGjC,OAAOsnB,CACT,EACIhC,GAAa,SAAoBxgB,EAAS0iB,GAC5C,IAAIjc,EAAQic,GAAoE,6BAA/CJ,GAAkBtiB,GAAS,KAAkD,GAAK2iB,GAAG3iB,EAAS,CAC7HpC,EAAG,EACHoE,EAAG,EACH6I,SAAU,EACVE,SAAU,EACV5B,SAAU,EACVC,UAAW,EACXC,UAAW,EACX1O,MAAO,EACP2O,MAAO,EACPC,MAAO,IACN2X,SAAS,GACRtf,EAAS5B,EAAQ4iB,wBAErB,OADAnc,GAASA,EAAMya,SAAS,GAAG3D,OACpB3b,CACT,EACIihB,GAAW,SAAkB7iB,EAAS8iB,GACxC,IAAIxQ,EAAKwQ,EAAMxQ,GACf,OAAOtS,EAAQ,SAAWsS,IAAOtS,EAAQ,SAAWsS,IAAO,CAC7D,EACIyQ,GAAsB,SAA6BC,GACrD,IAGI9nB,EAHAwC,EAAI,GACJulB,EAASD,EAASC,OAClBC,EAAWF,EAASE,WAGxB,IAAKhoB,KAAK+nB,EACRvlB,EAAEQ,KAAK+kB,EAAO/nB,GAAKgoB,GAGrB,OAAOxlB,CACT,EAMIylB,GAAmB,SAA0BC,GAC/C,IAAIC,EAAO,GAAKpQ,MAAMoQ,KAAKD,GACvB1lB,EAAI4lB,MAAMC,QAAQH,IAAyBA,EAAqB3Y,MAAM,GAAG+Y,MAAK,SAAU9lB,EAAGhC,GAC7F,OAAOgC,EAAIhC,CACb,IACA,OAAOgC,EAAI,SAAU9B,EAAOsQ,EAAWuX,GAKrC,IAAIllB,EAEJ,QANkB,IAAdklB,IACFA,EAAY,OAKTvX,EACH,OAAOmX,EAAKznB,GAGd,GAAIsQ,EAAY,EAAG,CAGjB,IAFAtQ,GAAS6nB,EAEJllB,EAAI,EAAGA,EAAIb,EAAEc,OAAQD,IACxB,GAAIb,EAAEa,IAAM3C,EACV,OAAO8B,EAAEa,GAIb,OAAOb,EAAEa,EAAI,EACf,CAIE,IAHAA,EAAIb,EAAEc,OACN5C,GAAS6nB,EAEFllB,KACL,GAAIb,EAAEa,IAAM3C,EACV,OAAO8B,EAAEa,GAKf,OAAOb,EAAE,EACX,EAAI,SAAU9B,EAAOsQ,EAAWuX,QACZ,IAAdA,IACFA,EAAY,MAGd,IAAIC,EAAUL,EAAKznB,GACnB,OAAQsQ,GAAajS,KAAK0Q,IAAI+Y,EAAU9nB,GAAS6nB,GAAaC,EAAU9nB,EAAQ,GAAMsQ,EAAY,EAAIwX,EAAUL,EAAKnX,EAAY,EAAItQ,EAAQwnB,EAAuBxnB,EAAQwnB,EAC9K,CACF,EAMIO,GAAiB,SAAwB5S,EAAM/Q,EAAS4jB,EAAOC,GACjE,OAAOD,EAAMtmB,MAAM,KAAKC,SAAQ,SAAU8B,GACxC,OAAO0R,EAAK/Q,EAASX,EAAMwkB,EAC7B,GACF,EACI,GAAe,SAAsB7jB,EAASX,EAAM0R,EAAM+S,EAAY7S,GACxE,OAAOjR,EAAQkR,iBAAiB7R,EAAM0R,EAAM,CAC1CC,SAAU8S,EACV7S,UAAWA,GAEf,EACI,GAAkB,SAAyBjR,EAASX,EAAM0R,EAAME,GAClE,OAAOjR,EAAQoR,oBAAoB/R,EAAM0R,IAAQE,EACnD,EACI8S,GAAiB,SAAwBhT,EAAMF,EAAImT,IACrDA,EAAaA,GAAcA,EAAWC,gBAGpClT,EAAKF,EAAI,QAASmT,GAClBjT,EAAKF,EAAI,YAAamT,GAE1B,EACIE,GAAkB,CACpBC,WAAY,QACZC,SAAU,MACVC,OAAQ,EACRC,SAAU,OACVC,WAAY,UAEVC,GAAY,CACdC,cAAe,OACfC,cAAe,GAEbC,GAAY,CACdxe,IAAK,EACLE,KAAM,EACNE,OAAQ,GACRH,OAAQ,EACRE,MAAO,GAELse,GAAc,SAAqBhpB,EAAOipB,GAC5C,GAAIjF,GAAUhkB,GAAQ,CACpB,IAAIkpB,EAAUlpB,EAAM6B,QAAQ,KACxBiQ,GAAYoX,IAAYlpB,EAAMsE,OAAO4kB,EAAU,GAAK,GAAKnhB,WAAW/H,EAAM6C,OAAOqmB,EAAU,IAAM,GAEhGA,IACHlpB,EAAM6B,QAAQ,KAAOqnB,IAAYpX,GAAYmX,EAAO,KACpDjpB,EAAQA,EAAM6C,OAAO,EAAGqmB,EAAU,IAGpClpB,EAAQ8R,GAAY9R,KAAS+oB,GAAYA,GAAU/oB,GAASipB,GAAQjpB,EAAM6B,QAAQ,KAAOkG,WAAW/H,GAASipB,EAAO,IAAMlhB,WAAW/H,IAAU,EACjJ,CAEA,OAAOA,CACT,EACImpB,GAAgB,SAAuB1lB,EAAMuN,EAAMoY,EAAW9Y,EAAW+Y,EAAOhT,EAAQiT,EAAcC,GACxG,IAAIhB,EAAac,EAAMd,WACnBC,EAAWa,EAAMb,SACjBE,EAAWW,EAAMX,SACjBD,EAASY,EAAMZ,OACfE,EAAaU,EAAMV,WAEnB/oB,EAAI,GAAKgE,cAAc,OACvB4lB,EAAmB,GAAYJ,IAAsD,UAAxCrU,GAAcqU,EAAW,WACtEK,GAA2C,IAA9BhmB,EAAK5B,QAAQ,YAC1B+F,EAAS4hB,EAAmB,GAAQJ,EACpCnmB,GAAqC,IAA3BQ,EAAK5B,QAAQ,SACvB2H,EAAQvG,EAAUslB,EAAaC,EAC/BkB,EAAM,gBAAkBlgB,EAAQ,cAAgBkf,EAAW,UAAYlf,EAAQ,gBAAkBmf,EAAa,uIAclH,OAZAe,GAAO,cAAgBD,GAAcF,IAAuBC,EAAmB,SAAW,cACzFC,GAAcF,IAAuBC,KAAsBE,IAAQpZ,IAAcuG,GAAYgP,GAASC,IAAW,KAAOzP,EAAStO,WAAW0gB,IAAW,OACxJa,IAAiBI,GAAO,+CAAiDJ,EAAapa,YAAc,OACpGtP,EAAE+pB,SAAW1mB,EACbrD,EAAEoD,aAAa,QAAS,eAAiBS,GAAQuN,EAAO,WAAaA,EAAO,KAC5EpR,EAAEU,MAAMsE,QAAU8kB,EAClB9pB,EAAEgqB,UAAY5Y,GAAiB,IAATA,EAAavN,EAAO,IAAMuN,EAAOvN,EACvDmE,EAAOiiB,SAAS,GAAKjiB,EAAOlC,aAAa9F,EAAGgI,EAAOiiB,SAAS,IAAMjiB,EAAOtC,YAAY1F,GACrFA,EAAEkqB,QAAUlqB,EAAE,SAAW0Q,EAAUyG,GAAGL,IAEtCqT,GAAgBnqB,EAAG,EAAG0Q,EAAWrN,GAE1BrD,CACT,EACImqB,GAAkB,SAAyBC,EAAQ5gB,EAAOkH,EAAW2Z,GACvE,IAAI9Y,EAAO,CACT5L,QAAS,SAEP2L,EAAOZ,EAAU2Z,EAAU,MAAQ,MACnCC,EAAe5Z,EAAU2Z,EAAU,KAAO,OAC9CD,EAAOG,WAAaF,EACpB9Y,EAAKb,EAAUxO,EAAI,WAAamoB,GAAW,IAAM,EACjD9Y,EAAKb,EAAUxO,GAAKmoB,EAAU,MAAQ,EACtC9Y,EAAK,SAAWD,EAAOqV,IAAU,EACjCpV,EAAK,SAAW+Y,EAAe3D,IAAU,EACzCpV,EAAKb,EAAUhR,GAAK8J,EAAQ,KAC5B,GAAKhK,IAAI4qB,EAAQ7Y,EACnB,EACIiZ,GAAY,GACZC,GAAO,CAAC,EAERC,GAAQ,WACV,OAAO,KAAazG,GAAkB,KAAOL,KAAWA,GAAS3E,sBAAsB0L,KACzF,EACI,GAAY,aAET,KAAgB,GAAY3U,WAAa,GAAYuJ,OAAS,GAAMqL,eAEvE/V,GAAW1T,QAEP,GACFyiB,KAAWA,GAAS3E,sBAAsB0L,KAE1CA,KAIF1G,IAAmB4G,GAAU,eAC7B5G,GAAkB,KAEtB,EACI6G,GAAqB,WACvB1H,GAAmB,GAAK2B,WACxB5B,GAAoB,GAAK/B,WAC3B,EACI2J,GAAY,WACdlW,GAAW1T,SACVshB,KAAgBQ,KAAkB,GAAK+H,oBAAsB,GAAKC,2BAA6B/H,IAAuBE,KAAqB,GAAK2B,YAActmB,KAAK0Q,IAAI,GAAKiS,YAAc+B,IAAwC,IAAnB,GAAK/B,cAAuBiB,GAAazB,SAAQ,EACnQ,EAEAsK,GAAa,CAAC,EACVC,GAAc,GACdC,GAAe,SAASA,IAC1B,OAAO,GAAgB,GAAe,YAAaA,IAAiBC,IAAY,EAClF,EACIR,GAAY,SAAmBhnB,GACjC,OAAOqnB,GAAWrnB,IAASqnB,GAAWrnB,GAAM+H,KAAI,SAAUS,GACxD,OAAOA,GACT,KAAM8e,EACR,EACIG,GAAe,GAEnBC,GAAkB,SAAyBC,GACzC,IAAK,IAAIzoB,EAAI,EAAGA,EAAIuoB,GAAatoB,OAAQD,GAAK,IACvCyoB,GAASF,GAAavoB,EAAI,IAAMuoB,GAAavoB,EAAI,GAAG0oB,QAAUD,KACjEF,GAAavoB,GAAGrC,MAAMsE,QAAUsmB,GAAavoB,EAAI,GACjDuoB,GAAavoB,GAAG6C,SAAW0lB,GAAavoB,GAAGK,aAAa,YAAakoB,GAAavoB,EAAI,IAAM,IAC5FuoB,GAAavoB,EAAI,GAAGO,QAAU,EAGpC,EACIooB,GAAa,SAAoB3J,EAAMyJ,GACzC,IAAIG,EAEJ,IAAKhJ,GAAK,EAAGA,GAAK6H,GAAUxnB,OAAQ2f,OAClCgJ,EAAUnB,GAAU7H,MAEH6I,GAASG,EAAQpU,OAASiU,IACrCzJ,EACF4J,EAAQ5J,KAAK,GAEb4J,EAAQjoB,QAAO,GAAM,IAK3B+f,IAAc,EACd+H,GAASD,GAAgBC,GACzBA,GAASX,GAAU,SACrB,EACIe,GAAqB,SAA4BvV,EAAmBuC,GAEtE/D,GAAW1T,SACVyX,IAAUiL,KAAmBhP,GAAW9S,SAAQ,SAAUilB,GACzD,OAAO5B,GAAY4B,IAAQA,EAAIxQ,YAAcwQ,EAAI6E,IAAM,EACzD,IACAzH,GAAU/N,KAAuB,GAAKD,QAAQC,kBAAoBiN,GAAqBjN,EACzF,EAEIyV,GAAa,EAWbC,GAAgB,WAClB,GAAMrmB,YAAY6d,IAElBC,IAAU,IAAeD,GAAU/T,cAAgB,GAAK4R,YAExD,GAAMrb,YAAYwd,GACpB,EACIyI,GAAkB,SAAyBC,GAC7C,OAAO3J,GAAS,gGAAgGvgB,SAAQ,SAAUsT,GAChI,OAAOA,EAAG3U,MAAMiF,QAAUsmB,EAAO,OAAS,OAC5C,GACF,EACIZ,GAAc,SAAqBzS,EAAOsT,GAC5C,IAAIjI,IAAoBrL,GAAU6K,GAAlC,CAMAsI,KAEAlI,GAAiB,GAAcsI,cAAe,EAE9CtX,GAAW9S,SAAQ,SAAUilB,GAC3B,OAAO5B,GAAY4B,MAAUA,EAAIxQ,UAAYwQ,EAAI6E,IAAM7E,IACzD,IAGA,IAAIoF,EAAevB,GAAU,eAE7B9H,IAAS,GAAciF,OACvBkE,GAAcR,KAEd7W,GAAW9S,SAAQ,SAAUilB,GACvB5B,GAAY4B,KACdA,EAAIra,SAAWqa,EAAIxmB,OAAOE,MAAM2rB,eAAiB,QAEjDrF,EAAI,GAER,IAEAwD,GAAUvb,MAAM,GAAGlN,SAAQ,SAAUtC,GACnC,OAAOA,EAAE6sB,SACX,IAGA7I,IAAc,EAEd+G,GAAUzoB,SAAQ,SAAUtC,GAE1B,GAAIA,EAAE8sB,eAAiB9sB,EAAE+sB,IAAK,CAC5B,IAAIjjB,EAAO9J,EAAE8R,KAAKjJ,WAAa,cAAgB,eAC3CmkB,EAAWhtB,EAAE+sB,IAAIjjB,GACrB9J,EAAEiE,QAAO,EAAM,GACfjE,EAAEitB,iBAAiBjtB,EAAE+sB,IAAIjjB,GAAQkjB,GACjChtB,EAAE6sB,SACJ,CACF,IAEA5I,GAAe,EAEfsI,IAAgB,GAEhBxB,GAAUzoB,SAAQ,SAAUtC,GAE1B,IAAIiZ,EAAMuM,GAAWxlB,EAAEktB,SAAUltB,EAAEmtB,MAC/BC,EAA0B,QAAfptB,EAAE8R,KAAKtK,KAAiBxH,EAAEqtB,WAAartB,EAAEwH,IAAMyR,EAC1DqU,EAAattB,EAAEutB,aAAevtB,EAAE+J,OAASkP,GAE5CmU,GAAYE,IAAettB,EAAEwtB,aAAaF,EAAarU,EAAM,EAAIjZ,EAAE+J,MAAOqjB,EAAWpuB,KAAKia,IAAIqU,EAAarU,EAAMjZ,EAAE+J,MAAQ,EAAGkP,GAAOjZ,EAAEwH,KAAK,EAC/I,IAEA+kB,IAAgB,GAEhBtI,GAAe,EACf0I,EAAarqB,SAAQ,SAAU0H,GAC7B,OAAOA,GAAUA,EAAOsJ,QAAUtJ,EAAOsJ,QAAQ,EACnD,IAEA8B,GAAW9S,SAAQ,SAAUilB,GACvB5B,GAAY4B,KACdA,EAAIra,QAAUsS,uBAAsB,WAClC,OAAO+H,EAAIxmB,OAAOE,MAAM2rB,eAAiB,QAC3C,IACArF,EAAI6E,KAAO7E,EAAIA,EAAI6E,KAEvB,IAEAD,GAAmBtI,GAAoB,GAEvCjB,GAAa1C,QAEbmM,KACAjI,GAAiB,EAEjB8G,GAAW,GAEXH,GAAUzoB,SAAQ,SAAUtC,GAC1B,OAAO2lB,GAAY3lB,EAAE8R,KAAK2b,YAAcztB,EAAE8R,KAAK2b,UAAUztB,EAC3D,IAEAokB,GAAiB,GAAcsI,cAAe,EAE9CtB,GAAU,UAtFV,MAHE,GAAa,GAAe,YAAaO,GA0F7C,EACI+B,GAAc,EACdC,GAAa,EAEbzC,GAAa,SAAoB/R,GACnC,GAAc,IAAVA,IAAgBiL,KAAmBJ,GAAa,CAElD,GAAc4J,YAAa,EAC3BtJ,IAAYA,GAASpL,OAAO,GAE5B,IAAItH,EAAImZ,GAAUxnB,OACd+F,EAAO,KACPukB,EAAiBvkB,EAAOib,IAAU,GAClCuJ,EAASlc,GAAKmZ,GAAU,GAAG+C,SAgB/B,GAdAH,GAAaD,GAAcI,GAAU,EAAI,EACzC1J,KAAmBsJ,GAAcI,GAE7BD,IACErJ,KAAoBvB,IAAkB3Z,EAAOkb,GAAkB,MACjEA,GAAkB,EAElB4G,GAAU,cAGZtI,GAASyB,GACTA,GAASjb,GAGPqkB,GAAa,EAAG,CAGlB,IAFAzK,GAAKtR,EAEEsR,MAAO,GACZ6H,GAAU7H,KAAO6H,GAAU7H,IAAIhK,OAAO,EAAG2U,GAG3CF,GAAa,CACf,MACE,IAAKzK,GAAK,EAAGA,GAAKtR,EAAGsR,KACnB6H,GAAU7H,KAAO6H,GAAU7H,IAAIhK,OAAO,EAAG2U,GAI7C,GAAcD,YAAa,CAC7B,CAEAzJ,GAAS,CACX,EACI4J,GAAmB,CAACxH,GA9cb,MA8c0BE,GAASD,GAAQS,GAAUF,GAASE,GAAUL,GAAQK,GAAUH,GAAMG,GAAUJ,GAAO,UAAW,aAAc,QAAS,SAAU,kBAAmB,gBAAiB,eAAgB,aAAc,WAAY,cAAe,YAAa,YAAa,SAC3RmH,GAAcD,GAAiBE,OAAO,CAACvH,GAAQC,GAAS,YAAa,MAAQO,GAAQ,MAAQC,GAAS,WAAYF,GAASD,GAAUA,GAAWF,GAAME,GAAWJ,GAAQI,GAAWD,GAASC,GAAWH,KAmBxMqH,GAAa,SAAoBnB,EAAKoB,EAAQzpB,EAAI0pB,GACpD,IAAKrB,EAAI1rB,MAAMgtB,UAAW,CAMxB,IALA,IAGIpuB,EAHAqD,EAAIyqB,GAAiBxqB,OACrB+qB,EAAcH,EAAOltB,MACrBstB,EAAWxB,EAAI9rB,MAGZqC,KAELgrB,EADAruB,EAAI8tB,GAAiBzqB,IACJoB,EAAGzE,GAGtBquB,EAAY/kB,SAA2B,aAAhB7E,EAAG6E,SAA0B,WAAa,WAClD,WAAf7E,EAAGwB,UAAyBooB,EAAYpoB,QAAU,gBAClDqoB,EAAS9H,IAAW8H,EAAS/H,IAAU,OACvC8H,EAAYE,UAAY9pB,EAAG8pB,WAAa,OACxCF,EAAYG,SAAW,UACvBH,EAAYI,UAAY,aACxBJ,EAAY5H,IAAUkB,GAASmF,EAAK9V,IAAemQ,GACnDkH,EAAY3H,IAAWiB,GAASmF,EAAKvV,IAAa4P,GAClDkH,EAAYtH,IAAYuH,EAAStH,IAAWsH,EAAa,IAAIA,EAAShI,IAAS,IAE/EoI,GAAUP,GAEVG,EAAS7H,IAAU6H,EAAS,MAAQrH,IAAUxiB,EAAGgiB,IACjD6H,EAAS5H,IAAW4H,EAAS,MAAQpH,IAAWziB,EAAGiiB,IACnD4H,EAASvH,IAAYtiB,EAAGsiB,IAEpB+F,EAAIlnB,aAAesoB,IACrBpB,EAAIlnB,WAAWQ,aAAa8nB,EAAQpB,GACpCoB,EAAOloB,YAAY8mB,IAGrBA,EAAI1rB,MAAMgtB,WAAY,CACxB,CACF,EACI,GAAW,WACXM,GAAY,SAAmBC,GACjC,GAAIA,EAAO,CACT,IAGI3uB,EACAU,EAJAM,EAAQ2tB,EAAM5uB,EAAEiB,MAChB2Q,EAAIgd,EAAMrrB,OACVD,EAAI,EAKR,KAFCsrB,EAAM5uB,EAAEqB,OAAS,GAAKqS,KAAKmb,SAASD,EAAM5uB,IAAI6D,QAAU,EAElDP,EAAIsO,EAAGtO,GAAK,EACjB3C,EAAQiuB,EAAMtrB,EAAI,GAClBrD,EAAI2uB,EAAMtrB,GAEN3C,EACFM,EAAMhB,GAAKU,EACFM,EAAMhB,IACfgB,EAAMmC,eAAenD,EAAEwD,QAAQ,GAAU,OAAOC,cAGtD,CACF,EACIorB,GAAY,SAAmB/pB,GAOjC,IALA,IAAI6M,EAAIoc,GAAYzqB,OAChBtC,EAAQ8D,EAAQ9D,MAChB2tB,EAAQ,GACRtrB,EAAI,EAEDA,EAAIsO,EAAGtO,IACZsrB,EAAM3rB,KAAK+qB,GAAY1qB,GAAIrC,EAAM+sB,GAAY1qB,KAI/C,OADAsrB,EAAM5uB,EAAI+E,EACH6pB,CACT,EAgBIvJ,GAAc,CAChBja,KAAM,EACNF,IAAK,GAUP6jB,GAAiB,SAAwBpuB,EAAOurB,EAAS8C,EAAc/d,EAAW6c,EAAQnD,EAAQsE,EAAgBpX,EAAMqX,EAAgBC,EAAahF,EAAkBiF,EAAalF,EAAoBmF,GACtM1J,GAAYhlB,KAAWA,EAAQA,EAAMkX,IAEjC8M,GAAUhkB,IAAiC,QAAvBA,EAAM6C,OAAO,EAAG,KACtC7C,EAAQyuB,GAAmC,MAApBzuB,EAAMsE,OAAO,GAAa0kB,GAAY,IAAMhpB,EAAM6C,OAAO,GAAIwrB,GAAgB,IAGtG,IACIM,EACApY,EACAnS,EAHAuE,EAAO4gB,EAAqBA,EAAmB5gB,OAAS,EAO5D,GAHA4gB,GAAsBA,EAAmBqF,KAAK,GAC9ClP,MAAM1f,KAAWA,GAASA,GAErBilB,GAAUjlB,GAwBbupB,IAAuBvpB,EAAQ,GAAKqX,MAAMwX,SAAStF,EAAmBuF,cAAc1lB,MAAOmgB,EAAmBuF,cAAcjoB,IAAK,EAAG4nB,EAAazuB,IACjJsuB,GAAkBvE,GAAgBuE,EAAgBD,EAAc/d,GAAW,OAzBtD,CACrB0U,GAAYuG,KAAaA,EAAUA,EAAQrU,IAC3C,IACIlR,EACA+oB,EACAC,EACAzpB,EAJA0pB,GAAWjvB,GAAS,KAAK0B,MAAM,KAKnC0C,EAAU6S,GAAWsU,EAASrU,IAAS,IACvClR,EAAS4e,GAAWxgB,IAAY,CAAC,KAEhB4B,EAAOyE,MAASzE,EAAOuE,MAA+C,SAAvCmc,GAAkBtiB,GAASmB,UAEzEA,EAAUnB,EAAQ9D,MAAMiF,QACxBnB,EAAQ9D,MAAMiF,QAAU,QACxBS,EAAS4e,GAAWxgB,GACpBmB,EAAUnB,EAAQ9D,MAAMiF,QAAUA,EAAUnB,EAAQ9D,MAAMmC,eAAe,YAG3EssB,EAAc/F,GAAYiG,EAAQ,GAAIjpB,EAAOsK,EAAUtE,IACvDgjB,EAAehG,GAAYiG,EAAQ,IAAM,IAAKZ,GAC9CruB,EAAQgG,EAAOsK,EAAUhR,GAAKivB,EAAeje,EAAUhR,GAAKkvB,EAAcO,EAAc5B,EAAS6B,EACjGV,GAAkBvE,GAAgBuE,EAAgBU,EAAc1e,EAAW+d,EAAeW,EAAe,IAAMV,EAAe3E,UAAYqF,EAAe,IACzJX,GAAgBA,EAAeW,CACjC,CAUA,GALIN,IACFxX,EAAKwX,GAAiB1uB,IAAU,KAChCA,EAAQ,IAAMA,EAAQ,IAGpBgqB,EAAQ,CACV,IAAIphB,EAAW5I,EAAQquB,EACnBprB,EAAU+mB,EAAOL,SACrBgF,EAAK,SAAWre,EAAUoG,GAE1BqT,GAAgBC,EAAQphB,EAAU0H,EAAWrN,GAAW2F,EAAW,KAAO3F,IAAYumB,EAAmBnrB,KAAKia,IAAI,GAAMqW,GAAK,GAAOA,IAAO3E,EAAO9kB,WAAWypB,KAAQ/lB,EAAW,GAE5K4gB,IACF+E,EAAiB3J,GAAW0J,GAC5B9E,IAAqBQ,EAAO1pB,MAAMgQ,EAAUyG,GAAGzX,GAAKivB,EAAeje,EAAUyG,GAAGzX,GAAKgR,EAAUyG,GAAG3M,EAAI4f,EAAOF,QAAUrD,IAE3H,CAWA,OATI8C,GAAsBnlB,IACxBuqB,EAAK/J,GAAWxgB,GAChBmlB,EAAmBqF,KAAKH,GACxBlY,EAAKqO,GAAWxgB,GAChBmlB,EAAmB2F,cAAgBP,EAAGre,EAAUhR,GAAKiX,EAAGjG,EAAUhR,GAClEU,EAAQA,EAAQupB,EAAmB2F,cAAgBT,GAGrDlF,GAAsBA,EAAmBqF,KAAKjmB,GACvC4gB,EAAqBvpB,EAAQ3B,KAAKkB,MAAMS,EACjD,EACImvB,GAAa,qCACbC,GAAY,SAAmBhrB,EAASwD,EAAQ2C,EAAKE,GACvD,GAAIrG,EAAQc,aAAe0C,EAAQ,CACjC,IACItI,EACAyE,EAFAzD,EAAQ8D,EAAQ9D,MAIpB,GAAIsH,IAAW,GAAO,CAKpB,IAAKtI,KAJL8E,EAAQirB,QAAU/uB,EAAMsE,QAExBb,EAAK2iB,GAAkBtiB,IAIf9E,GAAM6vB,GAAWhnB,KAAK7I,KAAMyE,EAAGzE,IAA0B,iBAAbgB,EAAMhB,IAAyB,MAANA,IACzEgB,EAAMhB,GAAKyE,EAAGzE,IAIlBgB,EAAMiK,IAAMA,EACZjK,EAAMmK,KAAOA,CACf,MACEnK,EAAMsE,QAAUR,EAAQirB,QAG1B,GAAKtc,KAAKmb,SAAS9pB,GAASlB,QAAU,EACtC0E,EAAOtC,YAAYlB,EACrB,CACF,EACIkrB,GAAuB,SAA8BC,EAAcC,EAAcC,GACnF,IAAIC,EAAQF,EACRG,EAAQD,EACZ,OAAO,SAAU1vB,GACf,IAAI4vB,EAAUvxB,KAAKkB,MAAMgwB,KAUzB,OARIK,IAAYF,GAASE,IAAYD,GAAStxB,KAAK0Q,IAAI6gB,EAAUF,GAAS,GAAKrxB,KAAK0Q,IAAI6gB,EAAUD,GAAS,IAEzG3vB,EAAQ4vB,EACRH,GAAeA,KAGjBE,EAAQD,EACRA,EAAQ1vB,EACDA,CACT,CACF,EACI6vB,GAAe,SAAsB7F,EAAQ1Z,EAAWtQ,GAC1D,IAAImR,EAAO,CAAC,EACZA,EAAKb,EAAUhR,GAAK,KAAOU,EAC3B,GAAKZ,IAAI4qB,EAAQ7Y,EACnB,EAQA2e,GAAmB,SAA0BvD,EAAUjc,GACrD,IAAIyf,EAAYpY,GAAe4U,EAAUjc,GACrCnH,EAAO,UAAYmH,EAAUiG,GAEjCyZ,EAAW,SAASA,EAASpZ,EAAUzF,EAAMqe,EAAcS,EAASC,GAClE,IAAIrlB,EAAQmlB,EAASnlB,MACjBslB,EAAahf,EAAKgf,WAClBC,EAAY,CAAC,EACjBZ,EAAeA,GAAgBO,IAE/B,IAAIM,EAAuBf,GAAqBS,EAAWP,GAAc,WACvE3kB,EAAM8W,OACNqO,EAASnlB,MAAQ,CACnB,IAyBA,OAvBAqlB,EAAUD,GAAWC,GAAW,EAEhCD,EAAUA,GAAWrZ,EAAW4Y,EAChC3kB,GAASA,EAAM8W,OACfxQ,EAAKhI,GAAQyN,EACbzF,EAAKmf,SAAU,EACfnf,EAAKif,UAAYA,EAEjBA,EAAUjnB,GAAQ,WAChB,OAAOknB,EAAqBb,EAAeS,EAAUplB,EAAM3L,MAAQgxB,EAAUrlB,EAAM3L,MAAQ2L,EAAM3L,MACnG,EAEAiS,EAAKof,SAAW,WACd9b,GAAW1T,QACXivB,EAASnlB,OAAS0f,IACpB,EAEApZ,EAAKgf,WAAa,WAChBH,EAASnlB,MAAQ,EACjBslB,GAAcA,EAAWvuB,KAAKiJ,EAChC,EAEAA,EAAQmlB,EAASnlB,MAAQ,GAAKkc,GAAGwF,EAAUpb,EAE7C,EAYA,OAVAob,EAASpjB,GAAQ4mB,EAEjBA,EAAU1H,aAAe,WACvB,OAAO2H,EAASnlB,OAASmlB,EAASnlB,MAAM8W,SAAWqO,EAASnlB,MAAQ,EACtE,EAEA,GAAa0hB,EAAU,QAASwD,EAAU1H,cAG1C,GAAczO,SAAW,GAAa2S,EAAU,YAAawD,EAAU1H,cAChE2H,CACT,EAEW,GAA6B,WACtC,SAAShc,EAAc7C,EAAMiU,GAC3B,IAAgBpR,EAAcvC,SAAS,KAASgG,QAAQC,KAAK,6CAE7D,GAASnW,MAETA,KAAK8P,KAAKF,EAAMiU,EAClB,CAwvCA,OAtvCapR,EAAcuG,UAEpBlJ,KAAO,SAAcF,EAAMiU,GAIhC,GAHA7jB,KAAK+jB,SAAW/jB,KAAK6H,MAAQ,EAC7B7H,KAAK4P,MAAQ5P,KAAKogB,MAAK,GAAM,GAExBmC,GAAL,CASA,IAyCI0M,EACAC,EACAC,EACAC,EACAC,EACAxnB,EACAvC,EACAgqB,EACAC,EACAC,EACAC,EACAC,EACAC,EACAzgB,EACA0gB,EACAC,EACAC,EACA7D,EACAnX,EACAib,EACAC,EACAC,EACAC,EACAC,EACAjE,EACAkE,EACAC,EACAC,EACA9tB,EACA+tB,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAhvBiDnL,EAlGNhjB,EAE7CwE,EAiwBE4pB,EAJJrhB,EAAOwV,GAAa3C,GAAU7S,IAAS8T,GAAU9T,IAASA,EAAKQ,SAAW,CACxE4Z,QAASpa,GACPA,EAAMyX,IAGN2H,EAAWiC,EAAMjC,SACjBkC,EAAcD,EAAMC,YACpB3V,EAAK0V,EAAM1V,GACX4V,EAAWF,EAAME,SACjB5F,EAAY0F,EAAM1F,UAClB6F,EAAQH,EAAMG,MACdpH,EAAUiH,EAAMjH,QAChBa,EAAMoG,EAAMpG,IACZwG,GAAaJ,EAAMI,WACnBC,GAAsBL,EAAMK,oBAC5B/J,GAAgB0J,EAAM1J,cACtBgK,GAAkBN,EAAMM,gBACxBC,GAAiBP,EAAMO,eACvBC,GAAOR,EAAMQ,KACbvL,GAAO+K,EAAM/K,KACbwL,GAAcT,EAAMS,YACpBC,GAAYV,EAAMU,UAClB3J,GAAqBiJ,EAAMjJ,mBAC3B4J,GAAgBX,EAAMW,cACtBC,GAAkBZ,EAAMY,gBACxB9iB,GAAYa,EAAKjJ,YAAciJ,EAAKoY,qBAA0C,IAApBpY,EAAKjJ,WAAuBoO,GAAcO,GACpGwc,IAAYV,GAAmB,IAAVA,EACrBpG,GAAWtV,GAAW9F,EAAKob,UAAY,IACvC+G,GAAgB,GAAKvgB,KAAKmb,SAAS3B,IACnC3O,GAAa,GAAY2O,IACzB/C,GAAwH,WAApG,YAAarY,EAAOA,EAAKoiB,QAAUxe,GAAcwX,GAAU,YAAc3O,IAAc,SAC3G4V,GAAY,CAACriB,EAAKsiB,QAAStiB,EAAKuiB,QAASviB,EAAKwiB,YAAaxiB,EAAKyiB,aAChE/K,GAAgBwK,IAAYliB,EAAK0X,cAAcnnB,MAAM,KACrDmyB,GAAU,YAAa1iB,EAAOA,EAAK0iB,QAAUjL,GAAUiL,QACvDrF,GAAc5Q,GAAa,EAAI7V,WAAW2e,GAAkB6F,IAAU,SAAWjc,GAAUiG,GAAKgQ,MAAY,EAC5GrP,GAAO3V,KACPuyB,GAAgB3iB,EAAK2iB,eAAiB,WACxC,OAAO3iB,EAAK2iB,cAAc5c,GAC5B,EACI6c,GA32BW,SAAsBxH,EAAU3O,EAAY9N,GAC7D,IAAI9D,EAAI8D,EAAK9D,EACT0K,EAAK5G,EAAK4G,GACV5U,EAAIgO,EAAKhO,EACb,OAAQA,EAAIiT,GAAcwX,EAAU,0BAA4B,WAC9D,OAAOzqB,IAAIkK,EACb,EAAI,WACF,OAAQ4R,EAAa2G,GAAsB7N,GAAM6V,EAAS,SAAW7V,KAAQ,CAC/E,CACF,CAk2B0Bsd,CAAazH,GAAU3O,GAAYtN,IACrD2jB,GAl2Bc,SAAyB7vB,EAASwZ,GACtD,OAAQA,IAAelJ,GAAS7S,QAAQuC,GAAWqgB,GAAergB,GAAW,WAC3E,OAAOsgB,EACT,CACF,CA81B6BwP,CAAgB3H,GAAU3O,IAC/CuW,GAAW,EACXC,GAAc,EACdC,GAAe,EACfjM,GAAazQ,GAAe4U,GAAUjc,IAqO1C,GA3LA4G,GAAK0V,YAAc1V,GAAKwV,WAAY,EACpCxV,GAAKsV,KAAOlc,GACZwY,IAAiB,GACjB5R,GAAKqV,SAAWA,GAChBrV,GAAKiW,OAAS5D,GAAqBA,GAAmB5gB,KAAK2rB,KAAK/K,IAAsBnB,GACtFuI,EAAUvI,KACVlR,GAAK/F,KAAOA,EACZiU,EAAYA,GAAajU,EAAKiU,UAE1B,oBAAqBjU,IACvBwR,GAAQ,GACkB,OAA1BxR,EAAKojB,kBAA8B5Q,GAAWzM,KAGhDoc,GAAckB,YAAclB,GAAckB,aAAe,CACvDjqB,IAAKulB,GAAiBvD,GAAU1V,IAChCpM,KAAMqlB,GAAiBvD,GAAUjW,KAEnCY,GAAKsZ,QAAUA,EAAU8C,GAAckB,YAAYlkB,GAAUhR,GAE7D4X,GAAKud,cAAgB,SAAUz0B,IAC7BiyB,EAAchN,GAAUjlB,IAAUA,GAMhCgyB,EAAaA,EAAW1K,SAAStnB,GAASgyB,EAAa,GAAKjL,GAAG3B,EAAW,CACxEsP,KAAM,OACNC,cAAe,MACfrE,SAAS,EACThJ,SAAU2K,EACV2C,QAAQ,EACRzE,WAAY,WACV,OAAO2C,IAAmBA,GAAgB5b,GAC5C,KAXF8a,GAAcA,EAAW1M,SAAS,GAAG3D,OACrCqQ,EAAa,EAajB,EAEI5M,IACFA,EAAUjU,KAAK0jB,MAAO,EACtBzP,EAAU0P,WAAa5d,GAAK6d,aAAiD,IAAnC3P,EAAUjU,KAAK6jB,kBAAsD,IAAzB7jB,EAAK6jB,iBAA6B5P,EAAUkC,YAAclC,EAAUzS,OAAO,GAAG,GAAM,GAE1KuE,GAAKkO,UAAYA,EAAU7F,QAC3B6F,EAAU0J,cAAgB5X,GAC1BA,GAAKud,cAAc9B,GACnBb,EAAQ,EACRhV,IAAOA,EAAKsI,EAAUjU,KAAK2L,KAGzB2K,KAEGvC,GAAUuC,MAASA,GAAKnlB,OAC3BmlB,GAAO,CACLwN,OAAQxN,KAIZ,mBAAoB,GAAMnnB,OAAS,GAAKlB,IAAIwe,GAAa,CAAC,GAAO,IAAU2O,GAAU,CACnFN,eAAgB,SAGlBxX,GAAW9S,SAAQ,SAAU+f,GAC3B,OAAOsD,GAAYtD,IAAMA,EAAEthB,UAAYwd,GAAa,GAAKhG,kBAAoB,GAAS2U,MAAc7K,EAAEnV,QAAS,EACjH,IAGAmkB,EAAW1L,GAAYyC,GAAKwN,QAAUxN,GAAKwN,OAAyB,WAAhBxN,GAAKwN,OA32BxC,SAA0B7P,GAC/C,OAAO,SAAUplB,GACf,OAAO,GAAKqX,MAAMoQ,KAAKN,GAAoB/B,GAAYplB,EACzD,CACF,CAu2BqFk1B,CAAiB9P,GAA6B,sBAAhBqC,GAAKwN,QAvzB/D7N,EAuzBqHhC,EAtzBrK,SAAUplB,EAAOm1B,GACtB,OAAO5N,GAAiBJ,GAAoBC,GAArCG,CAAgDvnB,EAAOm1B,EAAG7kB,UACnE,IAozB8M,IAArBmX,GAAK2N,YAAwB,SAAUp1B,EAAOm1B,GACjO,OAAO5N,GAAiBE,GAAKwN,OAAtB1N,CAA8BvnB,EAAO,KAAao0B,GAAc,IAAM,EAAIe,EAAG7kB,UACtF,EAAI,GAAK+G,MAAMoQ,KAAKA,GAAKwN,QACzB/C,EAAezK,GAAKH,UAAY,CAC9BlP,IAAK,GACLE,IAAK,GAEP4Z,EAAehN,GAAUgN,GAAgB,GAAOA,EAAa9Z,IAAK8Z,EAAa5Z,KAAO,GAAO4Z,EAAcA,GAC3GC,EAAkB,GAAKrS,YAAY2H,GAAK4N,OAASpD,EAAc,GAAK,IAAK,WACvE,IAAI9E,EAAS/E,KACTkN,EAAoB,KAAalB,GAAc,IAC/CvpB,EAAQ2lB,EAAQ3lB,MAEpB,KAAKyqB,GAAqBj3B,KAAK0Q,IAAImI,GAAKwB,eAAiB,KAAQ7N,GAAUyX,IAAkB6R,KAAahH,EAmD/FjW,GAAKqe,UAAYpB,KAAahH,GACvCgF,EAAgB3R,SAAQ,OApDwF,CAChH,IAKI9W,EACA8rB,EANAlQ,GAAY6H,EAAS/jB,GAASqH,EAC9BkkB,EAAgBvP,IAAciO,GAAWjO,EAAUuP,gBAAkBrP,EACrEmQ,EAAWH,EAAoB,GAAKX,EAAgB5C,IAAU,KAAa5P,IAAU,KAAQ,EAC7F8N,EAAU,GAAK5Y,MAAMoC,OAAO6L,EAAU,EAAIA,EAAUK,GAAK8P,EAAW,GAAKA,EAAW,MACpFC,EAAapQ,IAA6B,IAAjBmC,GAAKkO,QAAoB,EAAI1F,GAGtD2F,EAAQnO,GACRoO,EAAUD,EAAMC,QAChBC,EAAeF,EAAMnG,YACrBsG,EAAcH,EAAMzF,WAMxB,GALAzmB,EAAWgnB,EAASgF,EAAYxe,IAChC+N,GAAUvb,KAAcA,EAAWgsB,GAEnCF,EAAYn3B,KAAKkB,MAAM6J,EAAQM,EAAW+G,GAEtC0c,GAAUtmB,GAAOsmB,GAAU/jB,GAASosB,IAAcrI,EAAQ,CAC5D,GAAItiB,IAAUA,EAAMiqB,UAAYjqB,EAAM1L,MAAQwmB,GAAK6P,EAAYrI,GAE7D,QAGmB,IAAjB1F,GAAKkO,UACP1F,EAAUvmB,EAAW4b,GAGvBkL,EAAQgF,EAAW,CACjBlO,SAAU4K,EAAavM,GAAkF,KAA7EtnB,KAAKia,IAAIqN,GAAK+P,EAAaf,GAAgBhP,GAAKjc,EAAWirB,IAA0Bc,EAAW,KAAQ,IACpIf,KAAMjN,GAAKiN,MAAQ,SACnBv1B,KAAMwmB,GAAK6P,EAAYrI,GAEvBsC,YAAa,WACX,OAAO0C,EAAgB3R,SAAQ,IAASsV,GAAgBA,EAAa5e,GACvE,EACAiZ,WAAY,WACVjZ,GAAKqB,SACL4b,GAAW/L,KAEPhD,IAEF4M,EAAaA,EAAWgE,QAAQ,gBAAiBtsB,EAAU0b,EAAU6Q,OAAS7Q,EAAU8Q,OAAS9Q,EAAUE,SAAS5b,IAGtHooB,EAAQC,EAAQ3M,IAAciO,GAAWjO,EAAUuP,gBAAkBzd,GAAKoO,SAC1EyN,IAAkBA,GAAe7b,IACjC6e,GAAeA,EAAY7e,GAC7B,GACCiW,EAAQ8C,EAAUxf,EAAQ+kB,EAAYrI,EAAS8C,EAAUxf,GAC5DolB,GAAWA,EAAQ3e,GAAMsZ,EAAQ3lB,MACnC,CACF,CAGF,IAAG0U,SAGLzC,IAAOuN,GAAKvN,GAAM5F,KAGlBqb,GAFAhH,EAAUrU,GAAKqU,QAAUtU,GAAWsU,IAAmB,IAARa,GAAgBA,KAE/Bb,EAAQ7qB,OAAS6qB,EAAQ7qB,MAAMy1B,YACxC5D,EAAqBA,EAAmBrb,KAC/DkV,GAAc,IAARA,EAAeb,EAAUtU,GAAWmV,GAC1CpI,GAAUyO,KAAiBA,EAAc,CACvC7gB,QAAS2Z,EACT6K,UAAW3D,IAGTrG,KACa,IAAfwG,IAAwBA,KAAetM,KAAYsM,MAAcA,IAAcxG,EAAIlnB,YAAcknB,EAAIlnB,WAAW5E,OAAuD,SAA9ComB,GAAkB0F,EAAIlnB,YAAYK,UAA6B8gB,IAExLnP,GAAKkV,IAAMA,GACXqE,EAAW,GAAK1d,KAAKmb,SAAS9B,IAEhBoB,OAeZ2D,EAAmBV,EAASY,UAbxB6B,MACFA,GAAYjc,GAAWic,OACTA,GAAUvhB,WAAauhB,GAAYA,GAAUtD,SAAWsD,GAAUmD,eAEhF5F,EAAS6F,iBAAmBpD,GAC5BA,KAAczC,EAAShD,YAAcU,GAAU+E,MAGjDzC,EAASjD,OAASA,EAAS0F,IAAa,GAAKtvB,cAAc,OAC3D4pB,EAAO+I,UAAUlkB,IAAI,cACrByK,GAAM0Q,EAAO+I,UAAUlkB,IAAI,cAAgByK,GAC3C2T,EAASY,SAAWF,EAAmBhD,GAAU/B,KAKlC,IAAjBjb,EAAK7B,SAAqB,GAAKlQ,IAAIgtB,EAAK,CACtC9c,SAAS,IAEX4H,GAAKsW,OAASA,EAASiD,EAASjD,OAChCzpB,EAAK2iB,GAAkB0F,GACvBsF,EAAe3tB,EAAG6uB,GAAatiB,GAAUmG,KACzC6a,EAAY,GAAKxZ,YAAYsU,GAC7BmF,EAAY,GAAKiF,YAAYpK,EAAK9b,GAAUxO,EAAG2kB,IAE/C8G,GAAWnB,EAAKoB,EAAQzpB,GAExBstB,EAAWlD,GAAU/B,IAGnByH,GAAS,CACX5C,EAAa/L,GAAU2O,IAAWlN,GAAakN,GAASvL,IAAmBA,GAC3EyI,EAAqB5H,GAAc,iBAAkBrM,EAAIyP,GAAUjc,GAAW2gB,EAAY,GAC1FD,EAAmB7H,GAAc,eAAgBrM,EAAIyP,GAAUjc,GAAW2gB,EAAY,EAAGF,GACzF1a,EAAS0a,EAAmB,SAAWzgB,GAAUyG,GAAGL,IAEpD,IAAI+f,GAAUxf,GAAWlC,GAAcwX,GAAU,YAAcA,IAE/DsE,EAActvB,KAAKsvB,YAAc1H,GAAc,QAASrM,EAAI2Z,GAASnmB,GAAW2gB,EAAY5a,EAAQ,EAAGkT,IACvGuH,EAAYvvB,KAAKuvB,UAAY3H,GAAc,MAAOrM,EAAI2Z,GAASnmB,GAAW2gB,EAAY5a,EAAQ,EAAGkT,IACjGA,KAAuB+I,EAAiB,GAAKkE,YAAY,CAAC3F,EAAaC,GAAYxgB,GAAUxO,EAAG2kB,KAE3F+C,IAAsB9U,GAAS9R,SAAsD,IAA5CmS,GAAcwX,GAAU,kBA1hCtE3jB,EAAW8d,GAFkCtiB,EA6hCzBwZ,GAAa,GAAQ2O,IA3hCH3jB,SAE1CxE,EAAQ9D,MAAMsI,SAAwB,aAAbA,GAAwC,UAAbA,EAAuBA,EAAW,WA2hChF,GAAKxJ,IAAI,CAAC2xB,EAAoBC,GAAmB,CAC/C1hB,SAAS,IAEXqiB,EAAoB,GAAK6E,YAAYzF,EAAoBzgB,GAAUxO,EAAG2kB,IACtEoL,EAAkB,GAAK2E,YAAYxF,EAAkB1gB,GAAUxO,EAAG2kB,IAEtE,CAEA,GAAI8C,GAAoB,CACtB,IAAImN,GAAcnN,GAAmBpY,KAAKof,SACtCoG,GAAYpN,GAAmBpY,KAAKylB,eACxCrN,GAAmBsN,cAAc,YAAY,WAC3C3f,GAAKqB,OAAO,EAAG,EAAG,GAClBme,IAAeA,GAAYvd,MAAMoQ,GAAoBoN,IAAa,GACpE,GACF,CA0qBA,GAxqBAzf,GAAK4f,SAAW,WACd,OAAO1M,GAAUA,GAAUvoB,QAAQqV,IAAQ,EAC7C,EAEAA,GAAK6f,KAAO,WACV,OAAO3M,GAAUA,GAAUvoB,QAAQqV,IAAQ,EAC7C,EAEAA,GAAK5T,OAAS,SAAUA,EAAQqI,GAC9B,IAAKA,EACH,OAAOuL,GAAKyK,MAAK,GAInB,IAAItX,GAAe,IAAX/G,IAAqB4T,GAAKsO,QAC9BwR,EAAiB3U,GAEjBhY,IAAM6M,GAAK6d,aACT1qB,IACF+nB,EAAa/zB,KAAKia,IAAI8P,KAAclR,GAAKiW,OAAO1B,KAAO,GAEvD4I,GAAend,GAAKoO,SACpB+M,EAAmBjN,GAAaA,EAAUE,YAG5CuL,GAAe,CAACA,EAAaC,EAAWC,EAAoBC,GAAkBrvB,SAAQ,SAAUyI,GAC9F,OAAOA,EAAE9J,MAAMiF,QAAU8E,EAAI,OAAS,OACxC,IAEIA,IACFgY,GAAcnL,GACdA,GAAKqB,OAAOlO,KAGV+hB,GAAS6G,IAAgB/b,GAAKqe,WAC5BlrB,EAppBI,SAAqB+hB,EAAKoB,EAAQS,GAClDD,GAAUC,GAEV,IAAIltB,EAAQqrB,EAAI1rB,MAEhB,GAAIK,EAAMu1B,eACRtI,GAAUjtB,EAAM0sB,kBACX,GAAIrB,EAAI1rB,MAAMgtB,UAAW,CAC9B,IAAI9lB,EAAS4lB,EAAOtoB,WAEhB0C,IACFA,EAAOlC,aAAa0mB,EAAKoB,GACzB5lB,EAAOjC,YAAY6nB,GAEvB,CAEApB,EAAI1rB,MAAMgtB,WAAY,CACxB,CAooBYuJ,CAAY7K,EAAKoB,EAAQ2D,GAEzB5D,GAAWnB,EAAKoB,EAAQ9G,GAAkB0F,GAAMqB,IAIpDpjB,GAAK6M,GAAKqB,OAAOlO,GAEjBgY,GAAc2U,EAEd9f,GAAK6d,WAAa1qB,EAEtB,EAEA6M,GAAKgV,QAAU,SAAUgL,EAAM1e,EAAO5P,EAAUuuB,GAE9C,IAAK9U,IAAgBnL,GAAKsO,SAAahN,EAIvC,GAAI4T,GAAO8K,GAAQrT,GACjB,GAAa7P,EAAe,YAAagX,QAD3C,EAMCvH,IAAkBqQ,IAAiBA,GAAc5c,IAClDmL,GAAcnL,GAEVsZ,EAAQ3lB,QAAUjC,IAEpB4nB,EAAQ3lB,MAAM8W,OACd6O,EAAQ3lB,MAAQ,GAGlBmnB,GAAcA,EAAWzS,QACzBsT,IAAuBzN,GAAaA,EAAU9hB,OAAO,CACnDqe,MAAM,IACLyV,aACHlgB,GAAK6d,YAAc7d,GAAK5T,QAAO,GAAM,GACrC4T,GAAKiV,eAAgB,EAErB,IAYIpoB,EACAiC,EACAmnB,EACAkK,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EACAC,EAxBA7O,EAAO8K,KACPxF,EAAiB0F,KACjB3b,EAAMiR,GAAqBA,GAAmBjC,WAAazC,GAAW0H,GAAUjc,IAChFynB,EAAiBtnB,GAAU,IAC3B4F,EAAS,EACT2hB,EAAiBb,GAAa,EAC9Bc,EAAY/S,GAAUtc,GAAYA,EAAS/B,IAAMsK,EAAKtK,IACtDqxB,GAAmB/mB,EAAKgnB,YAAc5M,EACtC6M,GAAclT,GAAUtc,GAAYA,EAASQ,MAAQ+H,EAAK/H,QAAyB,IAAf+H,EAAK/H,OAAgBmiB,EAAca,EAAM,MAAQ,SAAlB,GACnGiM,GAAkBnhB,GAAKmhB,gBAAkBlnB,EAAKknB,iBAAmBphB,GAAW9F,EAAKknB,gBAAiBnhB,IAClGohB,GAAe/M,GAAWltB,KAAKia,IAAI,EAAG8R,GAAUvoB,QAAQqV,MAAU,EAClEvU,GAAI21B,GAqBR,IANIzE,IAAW3O,GAAUtc,KAEvBivB,EAAoB,GAAK/f,YAAYiZ,EAAoBzgB,GAAUhR,GACnEw4B,EAAkB,GAAKhgB,YAAYkZ,EAAkB1gB,GAAUhR,IAG1DqD,OAEL40B,EAAanN,GAAUznB,KACZkE,KAAO0wB,EAAWrL,QAAQ,EAAG,KAAO7J,GAAcnL,MAE7DsgB,EAASD,EAAWnL,MAELoL,IAAWjM,GAAWiM,IAAWpL,GAAOoL,IAAWa,IAAqBd,EAAWxC,aAChG4C,IAAiBA,EAAe,IAChCA,EAAaY,QAAQhB,GAErBA,EAAWj0B,QAAO,GAAM,IAGtBi0B,IAAenN,GAAUznB,MAE3B21B,KACA31B,MAyBJ,IArBAqiB,GAAYoT,MAAiBA,GAAcA,GAAYlhB,KACvDkhB,GAAcrU,GAAYqU,GAAa,QAASlhB,IAChD9N,EAAQglB,GAAegK,GAAa7M,EAAStC,EAAM3Y,GAAW8X,KAAcyI,EAAaE,EAAoB7Z,GAAMqX,EAAgBC,GAAahF,GAAkBlR,EAAKiR,GAAoBrS,GAAK0V,aAAe,iBAAmBR,GAAO,KAAQ,GACjPpH,GAAYiT,KAAeA,EAAYA,EAAU/gB,KAE7C8M,GAAUiU,KAAeA,EAAUp2B,QAAQ,SACxCo2B,EAAUp2B,QAAQ,KACrBo2B,GAAajU,GAAUoU,IAAeA,GAAY12B,MAAM,KAAK,GAAK,IAAMu2B,GAExE5hB,EAAS2S,GAAYiP,EAAUp1B,OAAO,GAAIomB,GAC1CgP,EAAYjU,GAAUoU,IAAeA,IAAe7O,GAAqB,GAAKlS,MAAMwX,SAAS,EAAGtF,GAAmBjC,WAAYiC,GAAmBuF,cAAc1lB,MAAOmgB,GAAmBuF,cAAcjoB,IAAKuC,GAASA,GAASiN,EAE/N6hB,GAAmB3M,IAIvB0M,EAAYlU,GAAYkU,EAAW,MAAO/gB,IAC1CrQ,EAAMxI,KAAKia,IAAIlP,EAAOglB,GAAe6J,IAAcC,GAAmB,SAAW5f,GAAM4f,GAAkBjP,EAAM3Y,GAAW8X,KAAe/R,EAAQya,EAAWE,EAAkB9Z,GAAMqX,EAAgBC,GAAahF,GAAkBlR,EAAKiR,GAAoBrS,GAAKwV,WAAa,gBAAkB,KAChSrW,EAAS,EACT1T,GAAI21B,GAEG31B,OAEL60B,GADAD,EAAanN,GAAUznB,KACHypB,MAENmL,EAAWnuB,MAAQmuB,EAAWiB,UAAYpvB,IAAUmgB,IAAsBgO,EAAW1wB,IAAM,IACvG9C,EAAKwzB,EAAW1wB,KAAOqQ,GAAK0V,YAAcvuB,KAAKia,IAAI,EAAGif,EAAWnuB,OAASmuB,EAAWnuB,QAEhFouB,IAAWjM,GAAWgM,EAAWnuB,MAAQmuB,EAAWiB,SAAWpvB,GAASouB,IAAWa,KAAoB3Y,MAAM0Y,MAEhH/hB,GAAUtS,GAAM,EAAIwzB,EAAWjS,WAGjCkS,IAAWpL,IAAQ4L,GAAkBj0B,IA8BzC,GA1BAqF,GAASiN,EACTxP,GAAOwP,EACPa,GAAK0V,cAAgB1V,GAAK0V,aAAevW,GAErCa,GAAKwV,YAAcjJ,KACrBvM,GAAKwV,UAAY7lB,IAAQ,KACzBA,EAAMxI,KAAK+Z,IAAIvR,EAAKge,GAAW0H,GAAUjc,MAG3CG,EAAS5J,EAAMuC,IAAUA,GAAS,MAAS,KAEvC2uB,IAEF1D,GAAe,GAAKhd,MAAMoC,MAAM,EAAG,EAAG,GAAKpC,MAAMohB,UAAUrvB,EAAOvC,EAAKurB,KAGzElb,GAAKshB,SAAWR,EAEZnH,GAAexa,KAEjBtS,EAAK,CAAC,GACHuM,GAAUxO,GAAK,KAAOuU,EACzBgiB,KAAoBt0B,EAAGuM,GAAUhR,GAAK,KAAO8oB,MAC7C,GAAKhpB,IAAI,CAACyxB,EAAaC,GAAY/sB,KAGjCqoB,GAAS9I,IAAgBpM,GAAKrQ,KAAOge,GAAW0H,GAAUjc,KAgGvD,GAAIib,GAAWnD,OAAiBmB,GAIrC,IAFAvjB,EAASulB,EAAQrmB,WAEVc,GAAUA,IAAW,IACtBA,EAAO0yB,aACTtvB,GAASpD,EAAO0yB,WAChB7xB,GAAOb,EAAO0yB,YAGhB1yB,EAASA,EAAOd,gBAzGlBnB,EAAK2iB,GAAkB0F,GACvBiL,EAAa/mB,KAAcuG,GAC3BsW,EAAS/E,KAEToJ,EAAWzpB,WAAWupB,EAAUhhB,GAAUxO,IAAMk2B,GAE3C1f,GAAOzR,EAAM,IAGhB+wB,EAAiB,CACft3B,MAFFs3B,GAAkBha,GAAa,GAAKhG,kBAAoB,GAAS2U,IAAUjsB,MAGzEN,MAAO43B,EAAe,WAAatnB,GAAUxO,EAAEyC,gBAG7CqZ,IAAmF,WAArE8I,GAAkB,IAAO,WAAapW,GAAUxO,EAAEyC,iBAElEqzB,EAAet3B,MAAM,WAAagQ,GAAUxO,EAAEyC,eAAiB,WAInEgpB,GAAWnB,EAAKoB,EAAQzpB,GAExBstB,EAAWlD,GAAU/B,GAErBpmB,EAAS4e,GAAWwH,GAAK,GACzBqL,EAAiBjO,IAAoB7R,GAAe4U,GAAU8K,EAAa/gB,GAAcO,GAApDc,GAEjCib,KACFnF,EAAc,CAACmF,GAAatiB,GAAUmG,IAAKhG,EAASunB,EAAiBvR,KACzDpnB,EAAImuB,GAChB7qB,GAAIiwB,KAAevM,GAAWY,GAASmF,EAAK9b,IAAaG,EAASunB,EAAiB,KAGjFvK,EAAYnrB,KAAKgO,GAAUtE,EAAGrJ,GAAI8jB,IAEP,SAA3B+G,EAAOltB,MAAMutB,YAAyBL,EAAOltB,MAAMutB,UAAYlrB,GAAI8jB,KAGrEuH,GAAUP,GAEN4K,IAEFjO,GAAUzoB,SAAQ,SAAUtC,GACtBA,EAAE+sB,MAAQiM,KAAyC,IAAtBh5B,EAAE8R,KAAKyhB,aACtCvzB,EAAE8sB,eAAgB,EAEtB,IAGF3C,IAAoBpB,GAAWgK,KAE/BzvB,GAAIskB,GAASmF,EAAK9b,MACc,SAA3Bkd,EAAOltB,MAAMutB,YAAyBL,EAAOltB,MAAMutB,UAAYlrB,GAAI8jB,IAGtE+C,MACF8N,EAAW,CACT/sB,IAAKvE,EAAOuE,KAAO8sB,EAAalK,EAAS/jB,EAAQquB,GAAkBhR,GACnEhc,KAAMzE,EAAOyE,MAAQ4sB,EAAaI,EAAiBtK,EAAS/jB,GAASqd,GACrEsH,UAAW,aACXnlB,SAAU,UAEHmd,IAAUuR,EAAS,MAAQ/Q,IAAUloB,KAAKs6B,KAAK3yB,EAAOE,OAASugB,GACxE6Q,EAAStR,IAAWsR,EAAS,MAAQ9Q,IAAWnoB,KAAKs6B,KAAK3yB,EAAOG,QAAUsgB,GAC3E6Q,EAAShR,IAAWgR,EAAShR,GAAUH,IAAQmR,EAAShR,GAAUL,IAAUqR,EAAShR,GAAUF,IAAWkR,EAAShR,GAAUJ,IAAS,IACtIoR,EAASjR,IAAYtiB,EAAGsiB,IACxBiR,EAASjR,GAAWF,IAAQpiB,EAAGsiB,GAAWF,IAC1CmR,EAASjR,GAAWJ,IAAUliB,EAAGsiB,GAAWJ,IAC5CqR,EAASjR,GAAWD,IAAWriB,EAAGsiB,GAAWD,IAC7CkR,EAASjR,GAAWH,IAASniB,EAAGsiB,GAAWH,IAC3CkL,EAhyBO,SAAoBnD,EAAOqJ,EAAUsB,GAOpD,IANA,IAIAt5B,EAJI+J,EAAS,GACT4H,EAAIgd,EAAMrrB,OACVD,EAAIi2B,EAAc,EAAI,EAInBj2B,EAAIsO,EAAGtO,GAAK,EACjBrD,EAAI2uB,EAAMtrB,GACV0G,EAAO/G,KAAKhD,EAAGA,KAAKg4B,EAAWA,EAASh4B,GAAK2uB,EAAMtrB,EAAI,IAIzD,OADA0G,EAAOhK,EAAI4uB,EAAM5uB,EACVgK,CACT,CAkxB2BwvB,CAAW1H,EAAkBmG,EAAUrE,IACxDxP,IAAkB2E,GAAW,IAG3BhD,GAEFsS,EAAUtS,EAAU0P,SAEpBlS,GAAoB,GAEpBwC,EAAUzS,OAAOyS,EAAUkC,YAAY,GAAM,GAC7CmK,EAAYH,EAAUhhB,GAAUxO,GAAK0vB,EAAW/gB,EAASunB,EACzDpG,EAAWvzB,KAAK0Q,IAAI0B,EAASghB,GAAa,EAC1CjI,IAAoBoI,GAAYR,EAAexP,OAAOwP,EAAexuB,OAAS,EAAG,GAEjFwiB,EAAUzS,OAAO,GAAG,GAAM,GAC1B+kB,GAAWtS,EAAUgS,YAAW,GAChChS,EAAUxd,QAAUwd,EAAUK,UAAUL,EAAUK,aAElD7C,GAAoB,IAEpB6O,EAAYhhB,EAGdmnB,IAAmBA,EAAe53B,MAAQ43B,EAAet3B,MAAM,WAAagQ,GAAUxO,EAAEyC,eAAiBqzB,EAAe53B,MAAQ43B,EAAet3B,MAAMmC,eAAe,YAAc6N,GAAUxO,IAe9L61B,GAAgBA,EAAah2B,SAAQ,SAAUtC,GAC7C,OAAOA,EAAEiE,QAAO,GAAO,EACzB,IACA4T,GAAK9N,MAAQA,EACb8N,GAAKrQ,IAAMA,EACX8pB,EAAUC,EAAUnN,GAAiB2O,EAAahK,KAE7CmB,IAAuB9F,KAC1BkN,EAAUyB,GAAchK,GAAWgK,GACnClb,GAAKiW,OAAO1B,IAAM,GAGpBvU,GAAK5T,QAAO,GAAO,GACnB8wB,GAAc,KAEVjC,IACFgC,IAAY,EAGZhC,EAAgB3R,SAAQ,IAG1B6B,GAAc,EACd+C,GAAaiO,KAAajO,EAAU0P,UAAYzC,IAAqBjN,EAAUE,aAAe+M,GAAoBjN,EAAUE,SAAS+M,GAAoB,GAAG,GAAM1f,OAAOyS,EAAUzc,QAAQ,GAAM,IAE7LovB,GAAkB1D,KAAiBnd,GAAKoO,UAAYiE,IAAsBsJ,MAE5EzN,IAAciO,IAAYjO,EAAUuP,cAAcpL,IAAsBngB,GAAS,OAAUirB,GAAe,GAAKhd,MAAMohB,UAAUrvB,EAAOvC,EAAK,GAAKwtB,IAAc,GAE9Jnd,GAAKoO,SAAWyS,IAAmBpH,EAAUvnB,GAASqH,IAAW4jB,GAAe,EAAIA,IAGtFjI,GAAOwG,KAAepF,EAAOkL,WAAar6B,KAAKkB,MAAM2X,GAAKoO,SAAWmM,IACrEO,GAAcA,EAAWoF,aAEpB1X,MAAMmY,KAETA,GAAqB,GAAK/f,YAAYiZ,EAAoBzgB,GAAUhR,GACpEw4B,GAAmB,GAAKhgB,YAAYkZ,EAAkB1gB,GAAUhR,GAEhEuwB,GAAakB,EAAoBzgB,GAAWunB,GAE5ChI,GAAagB,EAAavgB,GAAWunB,GAAqBV,GAAa,IAEvEtH,GAAamB,EAAkB1gB,GAAWwnB,GAE1CjI,GAAaiB,EAAWxgB,GAAWwnB,GAAmBX,GAAa,KAGrEY,IAAmBtU,IAAkBvM,GAAKqB,UAEtCuU,GAAcrJ,IAAmByN,IAEnCA,GAAqB,EACrBpE,EAAU5V,IACVga,GAAqB,EA3SvB,CA6SF,EAEAha,GAAKwB,YAAc,WACjB,OAAQ0P,KAAewI,IAAY,KAAazO,IAAU,KAAQ,CACpE,EAEAjL,GAAK4hB,aAAe,WAClB3T,GAAcjO,GAAKwO,mBAEfN,IACF4M,EAAaA,EAAW1M,SAAS,GAAMF,EAAUwP,SAA4DvB,IAAYlO,GAAcC,EAAWlO,GAAK5G,UAAY,EAAG,GAA1G6U,GAAcC,EAAWA,EAAUC,YAEnG,EAEAnO,GAAK6hB,cAAgB,SAAUC,GAC7B,OAAO5T,GAAaA,EAAUiC,SAAWje,GAAS8N,GAAKgV,WAAa9iB,GAASgc,EAAUiC,OAAO2R,GAAS5T,EAAUkC,WAAa7W,GAAU,CAC1I,EAEAyG,GAAK+hB,YAAc,SAAUjoB,GAC3B,IAAIrO,EAAIynB,GAAUvoB,QAAQqV,IACtBpV,EAAIoV,GAAK5G,UAAY,EAAI8Z,GAAUvb,MAAM,EAAGlM,GAAGu2B,UAAY9O,GAAUvb,MAAMlM,EAAI,GAEnF,OAAQqhB,GAAUhT,GAAQlP,EAAE2f,QAAO,SAAUpiB,GAC3C,OAAOA,EAAE8R,KAAKiiB,kBAAoBpiB,CACpC,IAAKlP,GAAG2f,QAAO,SAAUpiB,GACvB,OAAO6X,GAAK5G,UAAY,EAAIjR,EAAEwH,KAAOuC,EAAQ/J,EAAE+J,OAASvC,CAC1D,GACF,EAEAqQ,GAAKqB,OAAS,SAAUE,EAAOyU,EAAgBiM,GAC7C,IAAI5P,IAAuB4P,GAAc1gB,EAAzC,CAIA,IAII8c,EAEA6D,EACAC,EACAC,EACAC,EACAC,EACAC,EAXAtM,GAA4B,IAAnB1J,GAA0B2O,EAAalb,GAAKiW,SACrD7tB,EAAImZ,EAAQ,GAAK0U,EAAS/jB,GAASqH,EACnCipB,EAAUp6B,EAAI,EAAI,EAAIA,EAAI,EAAI,EAAIA,GAAK,EACvC+0B,EAAend,GAAKoO,SA6BxB,GAnBI4H,IACF0D,EAAUD,EACVA,EAAUpH,GAAqBnB,KAAe+E,EAE1C1F,KACFsK,EAAQD,EACRA,EAAQ1M,IAAciO,GAAWjO,EAAUuP,gBAAkB+E,IAK7D5Q,IAAiBsD,IAAQ/J,KAAgB,IAAYwB,MAClD6V,GAAWtwB,EAAQ+jB,GAAUA,EAASyD,IAAY,KAAazO,IAAU2G,GAC5E4Q,EAAU,KACW,IAAZA,GAAiB7yB,EAAMsmB,GAAUA,EAASyD,IAAY,KAAazO,IAAU2G,KACtF4Q,EAAU,QAIVA,IAAYrF,GAAgBnd,GAAKsO,QAAS,CAuC5C,GAnCA8T,GADAC,GAFAhE,EAAWre,GAAKqe,WAAamE,GAAWA,EAAU,QACpCrF,GAAgBA,EAAe,OAEjBqF,KAAcrF,EAE1Cnd,GAAK5G,UAAYopB,EAAUrF,EAAe,GAAK,EAC/Cnd,GAAKoO,SAAWoU,EAEZJ,IAAiBjX,KACnB+W,EAAcM,IAAYrF,EAAe,EAAgB,IAAZqF,EAAgB,EAAqB,IAAjBrF,EAAqB,EAAI,EAEtFhB,KACFgG,GAAUE,GAA8C,SAAnC1Q,GAAcuQ,EAAc,IAAiBvQ,GAAcuQ,EAAc,IAAMvQ,GAAcuQ,GAElHK,EAAiBrU,IAAyB,aAAXiU,GAAoC,UAAXA,GAAsBA,KAAUjU,KAI5FgO,KAAoBmG,GAAWE,KAAoBA,GAAkB9G,IAAUvN,KAAeJ,GAAYoO,IAAmBA,GAAgBlc,IAAQA,GAAK+hB,YAAY7F,IAAiBzxB,SAAQ,SAAUtC,GACvM,OAAOA,EAAEy5B,cACX,KAEKzF,MACCrB,GAAe3P,IAAgB,GAUxB+C,GACTA,EAAUuP,cAAc+E,KAAYrX,KAAgB+R,KAAe3b,KAVnEuZ,EAAW2H,IAAI7uB,MAAQknB,EAAW4H,SAAW5H,EAAWlnB,OAASknB,EAAWrf,OAAOqf,EAAW2H,IAAI7uB,MAAQknB,EAAW4H,QAEjH5H,EAAWgE,QACbhE,EAAWgE,QAAQ,gBAAiB0D,EAAStU,EAAU6Q,OAAS7Q,EAAU8Q,QAG1ElE,EAAW7gB,KAAKwjB,cAAgB+E,EAChC1H,EAAWoF,aAAa5W,aAO1B4L,EAGF,GAFA3T,GAASma,KAAepF,EAAOltB,MAAMsyB,GAAatiB,GAAUmG,KAAOib,GAE9DlI,IAEE,GAAI8P,EAAc,CAGvB,GAFAE,GAAW/gB,GAASihB,EAAUrF,GAAgBxtB,EAAM,EAAIsmB,GAAUA,EAAS,GAAKtI,GAAW0H,GAAUjc,IAEjG2iB,GACF,GAAKxa,IAAU8c,IAAYiE,EAMzBpK,GAAUhD,EAAKoB,OANoB,CACnC,IAAIxnB,EAAS4e,GAAWwH,GAAK,GACzBtC,EAAUqD,EAAS/jB,EAEvBgmB,GAAUhD,EAAK,GAAOpmB,EAAOuE,KAAO+F,KAAcuG,GAAYiT,EAAU,GAAKrD,GAAKzgB,EAAOyE,MAAQ6F,KAAcuG,GAAY,EAAIiT,GAAWrD,GAC5I,CAKFuH,GAAUuH,GAAYiE,EAAUpI,EAAiBC,GAEjDO,GAAY8H,EAAU,GAAKnE,GAAYhE,EAAUC,GAAwB,IAAZkI,GAAkBF,EAAsB,EAAZ/H,GAC3F,OAlBEF,EAAUjN,GAAOkN,EAAWC,EAAYiI,IAqB5CjS,KAAS+I,EAAQ3lB,QAAUwX,KAAgB,IAAY8P,EAAgB3R,SAAQ,GAC/EiS,IAAgB8G,GAAWvG,IAAQ0G,IAAYA,EAAU,IAAMnW,MAAqBrB,GAASuQ,EAAY7gB,SAASjQ,SAAQ,SAAUsT,GAClI,OAAOA,EAAGshB,UAAUhB,GAAYvC,GAAO,MAAQ,UAAUP,EAAY2D,UACvE,IAEA7F,IAAa8C,KAAa5a,GAAS8X,EAASrZ,IAExCoiB,IAAiBjX,IACfgR,KACEoG,IACa,aAAXJ,EACFjU,EAAU7F,QAAQoV,cAAc,GACZ,UAAX0E,EACTjU,EAAU5E,SAAQ,GAAMjB,QACJ,YAAX8Z,EACTjU,EAAU5E,SAAQ,GAElB4E,EAAUiU,MAId9I,GAAYA,EAASrZ,MAGnBqiB,GAAYhW,KAEdmP,GAAY6G,GAAWhU,GAAUrO,GAAMwb,GACvCc,GAAU4F,IAAgB7T,GAAUrO,GAAMsc,GAAU4F,IACpDpG,KAAqB,IAAZ0G,EAAgBxiB,GAAKyK,MAAK,EAAO,GAAK6R,GAAU4F,GAAe,GAEnEG,GAGH/F,GADA4F,EAA0B,IAAZM,EAAgB,EAAI,IACRnU,GAAUrO,GAAMsc,GAAU4F,KAIpDjG,KAAkBoC,GAAYl3B,KAAK0Q,IAAImI,GAAKwB,gBAAkBuM,GAAUkO,IAAiBA,GAAgB,QAC3GhO,GAAcjO,GAAKwO,mBAEnBsM,EAAaA,EAAW1M,SAAS,GAAKH,GAAcC,EAAsB,YAAXiU,EAAuB,GAAKK,EAAS,KAE7FrG,IAAY9C,IAAalO,IAClCkO,EAASrZ,GAEb,CAGA,GAAI2a,EAAiB,CACnB,IAAIgI,EAAItQ,GAAqB4D,EAAS5D,GAAmBjC,YAAciC,GAAmB2F,eAAiB,GAAK/B,EAChHwE,EAAkBkI,GAAK9I,EAAmB5G,WAAa,EAAI,IAC3D0H,EAAgBgI,EAClB,CAEAvH,GAAkBA,GAAgBnF,EAAS5D,GAAmBjC,YAAciC,GAAmB2F,eAAiB,GAxJhH,CAyJF,EAEAhY,GAAKoK,OAAS,SAAU7I,EAAOyT,GACxBhV,GAAKsO,UACRtO,GAAKsO,SAAU,EAEf,GAAa+G,GAAU,SAAU5B,IAEjC/M,IAAc,GAAa2O,GAAU,SAAU,IAC/CuH,IAAiB,GAAa9f,EAAe,cAAe8f,KAE9C,IAAVrb,IACFvB,GAAKoO,SAAW+O,GAAe,EAC/B1D,EAAUC,EAAUuD,GAAW/L,OAGrB,IAAZ8D,GAAqBhV,GAAKgV,UAE9B,EAEAhV,GAAK8Y,SAAW,SAAUvI,GACxB,OAAOA,GAAQ+I,EAAUA,EAAQ3lB,MAAQmnB,CAC3C,EAEA9a,GAAK2V,aAAe,SAAUiN,EAAUC,EAAQC,EAAW7C,GAEzD,GAAI5N,GAAoB,CAEtB,IAAI4L,EAAK5L,GAAmBuF,cACxBxH,EAAWiC,GAAmBjC,WAC9B2S,EAAU9E,EAAGtuB,IAAMsuB,EAAG/rB,MAE1B0wB,EAAW3E,EAAG/rB,MAAQ6wB,EAAUH,EAAWxS,EAC3CyS,EAAS5E,EAAG/rB,MAAQ6wB,EAAUF,EAASzS,CACzC,CAEApQ,GAAKgV,SAAQ,GAAO,EAAO,CACzB9iB,MAAO6a,GAAW6V,EAAUE,KAAe9iB,GAAK0V,aAChD/lB,IAAKod,GAAW8V,EAAQC,KAAe9iB,GAAKwV,YAC3CyK,GACHjgB,GAAKqB,QACP,EAEArB,GAAKoV,iBAAmB,SAAU/jB,GAChC,GAAIklB,GAAellB,EAAQ,CACzB,IAAI5F,EAAI8qB,EAAY5rB,QAAQyO,GAAUtE,GAAK,EAC3CyhB,EAAY9qB,GAAKoF,WAAW0lB,EAAY9qB,IAAM4F,EAASke,GACvDgH,EAAY,GAAK1lB,WAAW0lB,EAAY,IAAMllB,EAASke,GAEvDuH,GAAUP,EACZ,CACF,EAEAvW,GAAKsK,QAAU,SAAU/I,EAAOyhB,GAC9B,GAAIhjB,GAAKsO,WACG,IAAV/M,GAAmBvB,GAAK5T,QAAO,GAAM,GACrC4T,GAAKsO,QAAUtO,GAAKqe,UAAW,EAC/B2E,GAAkBlI,GAAcA,EAAWzS,QAC3C6S,EAAa,EACb3B,IAAaA,EAASvtB,QAAU,GAChC4wB,IAAiB,GAAgB9f,EAAe,cAAe8f,IAE3D3B,IACFA,EAAgB5S,QAChBiR,EAAQ3lB,OAAS2lB,EAAQ3lB,MAAM8W,SAAW6O,EAAQ3lB,MAAQ,KAGvD+S,IAAY,CAGf,IAFA,IAAIjb,EAAIynB,GAAUxnB,OAEXD,KACL,GAAIynB,GAAUznB,GAAG4pB,WAAaA,IAAYnC,GAAUznB,KAAOuU,GACzD,OAIJ,GAAgBqV,GAAU,SAAU5B,IAEpC/M,IAAc,GAAgB2O,GAAU,SAAU,GACpD,CAEJ,EAEArV,GAAKyK,KAAO,SAAUre,EAAQ42B,GAC5BhjB,GAAKsK,QAAQle,EAAQ42B,GACrBlI,IAAekI,GAAkBlI,EAAWrQ,OAC5C7E,UAAauN,GAAKvN,GAElB,IAAIna,EAAIynB,GAAUvoB,QAAQqV,IAE1BvU,GAAK,GAAKynB,GAAUxI,OAAOjf,EAAG,GAC9BA,IAAM4f,IAAMyK,GAAa,GAAKzK,KAG9B5f,EAAI,EAEJynB,GAAUzoB,SAAQ,SAAUtC,GAC1B,OAAOA,EAAEktB,WAAarV,GAAKqV,WAAa5pB,EAAI,EAC9C,IAEAA,GAAK8gB,KAAmBvM,GAAKiW,OAAO1B,IAAM,GAEtCrG,IACFA,EAAU0J,cAAgB,KAC1BxrB,GAAU8hB,EAAU9hB,OAAO,CACzBqe,MAAM,IAERuY,GAAkB9U,EAAUzD,QAG9BkP,GAAe,CAACA,EAAaC,EAAWC,EAAoBC,GAAkBrvB,SAAQ,SAAUyI,GAC9F,OAAOA,EAAElF,YAAckF,EAAElF,WAAWS,YAAYyE,EAClD,IACAuZ,KAAazM,KAASyM,GAAW,GAE7ByI,IACFqE,IAAaA,EAASvtB,QAAU,GAChCP,EAAI,EAEJynB,GAAUzoB,SAAQ,SAAUtC,GAC1B,OAAOA,EAAE+sB,MAAQA,GAAOzpB,GAC1B,IAEAA,IAAM8tB,EAASjD,OAAS,IAG1Brc,EAAKgpB,QAAUhpB,EAAKgpB,OAAOjjB,GAC7B,EAEAkT,GAAU9nB,KAAK4U,IAEfA,GAAKoK,QAAO,GAAO,GACnBiR,GAAsBA,EAAmBrb,IAErCkO,GAAaA,EAAU/S,MAAQ5B,EAAQ,CAEzC,IAAI2pB,GAAaljB,GAAKqB,OAEtBrB,GAAKqB,OAAS,WACZrB,GAAKqB,OAAS6hB,GACdhxB,GAASvC,GAAOqQ,GAAKgV,SACvB,EAEA,GAAKpM,YAAY,IAAM5I,GAAKqB,QAC5B9H,EAAS,IACTrH,EAAQvC,EAAM,CAChB,MACEqQ,GAAKgV,UAGPE,GA58CmB,WAErB,GAAI1I,KAAoBgI,GAAY,CAClC,IAAI5O,EAAK4G,GAAkBgI,GAC3B7M,uBAAsB,WACpB,OAAO/B,IAAO4O,IAAcT,IAAY,EAC1C,GACF,CACF,CAo8CWoP,EA3+BP,MAFE94B,KAAKgX,OAAShX,KAAK2qB,QAAU3qB,KAAKogB,KAAO0C,EA8+B7C,EAEArQ,EAAcvC,SAAW,SAAkBsB,GAOzC,OANK,KACH,GAAOA,GAAQ,KACf,MAAmBtO,OAAOC,UAAYsP,EAAcsN,SACpD,GAAewC,IAGV,EACT,EAEA9P,EAAc6S,SAAW,SAAkBtP,GACzC,GAAIA,EACF,IAAK,IAAIjY,KAAKiY,EACZqR,GAAUtpB,GAAKiY,EAAOjY,GAI1B,OAAOspB,EACT,EAEA5U,EAAcwN,QAAU,SAAiB/I,EAAOkJ,GAC9CmC,GAAW,EAEXsG,GAAUzoB,SAAQ,SAAU4pB,GAC1B,OAAOA,EAAQ5J,EAAO,OAAS,WAAWlJ,EAC5C,IAEA,GAAgB,GAAM,QAAS,IAE/B,GAAgB,GAAM,SAAU,IAEhC6hB,cAAclY,IAEd,GAAgB,GAAM,cAAeiC,IAErC,GAAgB,GAAO,aAAcA,IAErC0D,GAAe,GAAiB,GAAM,mCAAoC5D,IAE1E4D,GAAe,GAAiB,GAAM,6BAA8B3D,IAEpEnC,GAAaN,OAEbmD,GAAoB,IAEpB,IAAK,IAAIniB,EAAI,EAAGA,EAAI8R,GAAW7R,OAAQD,GAAK,EAC1CwlB,GAAe,GAAiB1T,GAAW9R,GAAI8R,GAAW9R,EAAI,IAE9DwlB,GAAe,GAAiB1T,GAAW9R,GAAI8R,GAAW9R,EAAI,GAElE,EAEAqR,EAAcsN,OAAS,WAMrB,GALA,GAAO7c,OACP,GAAOC,SACP,GAAS,GAAKC,gBACd,GAAQ,GAAK+D,KAET,KACFwZ,GAAW,GAAK7K,MAAMC,QACtB,GAAS,GAAKD,MAAMoC,MACpB,GAAW,GAAK1G,KAAK2G,SAAW2K,GAChCzB,GAAsB,GAAK7P,KAAKwnB,oBAAsBlW,GACtDnB,GAAqB,GAAKlN,QAAQC,mBAAqB,OACvD8W,GAAc,GAAK/V,YACnB,GAAKjE,KAAKwG,QAAQ,gBAAiBvF,GAE/B,IAAO,CACT8P,GAAW,GACXX,GAAYze,SAASd,cAAc,QAEzBtD,MAAM6F,OAAS,QACzBgd,GAAU7iB,MAAMsI,SAAW,WAE3B+iB,KAEAzH,KAEAvK,GAASlI,SAAS,IAElBuC,EAAc4F,QAAUD,GAASC,QACjCqJ,GAAatJ,GAASC,SAAW,0BAA0BzR,KAAK4R,UAAUygB,WAE1E1X,GAA2C,IAArBnJ,GAASC,QAE/B,GAAa,GAAM,QAAS,IAG5B,GAAQ,CAAC,GAAM,GAAM,GAAQ,IAEzB,GAAKC,YACP7F,EAAc6F,WAAa,SAAU1I,GACnC,IACI7R,EADAm7B,EAAK,GAAK5gB,aAGd,IAAKva,KAAK6R,EACRspB,EAAGpoB,IAAI/S,EAAG6R,EAAK7R,IAGjB,OAAOm7B,CACT,EAEA,GAAKnlB,iBAAiB,kBAAkB,WACtC,OAAOgW,IACT,IACA,GAAKhW,iBAAiB,oBAAoB,WACxC,OAAO6V,IACT,IACA,GAAK7V,iBAAiB,cAAc,WAClC2V,GAAY,EAAG,GAEfR,GAAU,aACZ,IACA,GAAK5Q,WAAW,2BAA2B,WAIzC,OAFA6Q,KAEOA,EACT,KAEAjT,QAAQC,KAAK,iCAGfgT,KAEA,GAAa,GAAM,SAAU,IAG7B,IAGI1kB,EACArD,EAJA+3B,EAAY,GAAMp6B,MAClBq6B,EAASD,EAAUE,eACnBC,EAAiB,GAAK9nB,KAAK+nB,UAAUvgB,UAwDzC,IArDAsgB,EAAev3B,QAAUiQ,OAAOC,eAAeqnB,EAAgB,SAAU,CACvE76B,MAAO,WACL,OAAOuB,KAAKoH,MAAM,KAAM,EAC1B,IAGF+xB,EAAUE,eAAiB,QAE3B50B,EAAS4e,GAAW,IACpB/N,GAAUzM,EAAI/L,KAAKkB,MAAMyG,EAAOuE,IAAMsM,GAAUF,OAAS,EAEzDL,GAAYlM,EAAI/L,KAAKkB,MAAMyG,EAAOyE,KAAO6L,GAAYK,OAAS,EAC9DgkB,EAASD,EAAUE,eAAiBD,EAASD,EAAUj4B,eAAe,oBAEtE2f,GAAgB2Y,YAAYzQ,GAAO,KACnC,GAAKxK,YAAY,IAAK,WACpB,OAAO,GAAW,CACpB,IAEA,GAAa,GAAM,cAAeuE,IAGlC,GAAa,GAAO,aAAcA,IAGlC0D,GAAe,GAAc,GAAM,mCAAoC5D,IAEvE4D,GAAe,GAAc,GAAM,6BAA8B3D,IAEjE,GAAiB,GAAK/M,MAAM2jB,YAAY,aAExC3N,GAAY/qB,KAAK,IAEjB,GAAe,KACf2f,GAAe,GAAKnC,YAAY,GAAKmL,IAAa1L,QAClDmD,GAAe,CAAC,GAAM,mBAAoB,WACxC,IAAIuY,EAAI,GAAKtW,WACTuW,EAAI,GAAKla,YAET,GAAKma,QACP3Y,GAAayY,EACbxY,GAAcyY,GACL1Y,KAAeyY,GAAKxY,KAAgByY,GAC7CvQ,IAEJ,EAAG,GAAM,mBAAoBM,GAAa,GAAM,OAAQA,GAAa,GAAM,SAAUN,IAErF7F,GAAoB,IAEpBsF,GAAUzoB,SAAQ,SAAU4pB,GAC1B,OAAOA,EAAQjK,OAAO,EAAG,EAC3B,IAEK3e,EAAI,EAAGA,EAAI8R,GAAW7R,OAAQD,GAAK,EACtCwlB,GAAe,GAAiB1T,GAAW9R,GAAI8R,GAAW9R,EAAI,IAE9DwlB,GAAe,GAAiB1T,GAAW9R,GAAI8R,GAAW9R,EAAI,GAElE,CAEJ,EAEAqR,EAAcuD,OAAS,SAAgBpG,GACrC,mBAAoBA,IAASoS,KAAoBpS,EAAKiqB,gBACtD,IAAIC,EAAKlqB,EAAKmqB,aACdD,GAAMf,cAAclY,MAAmBA,GAAgBiZ,IAAON,YAAYzQ,GAAO+Q,GACjF,uBAAwBlqB,IAAS2R,GAAgD,IAA1B9O,EAAc4F,SAAiBzI,EAAKoqB,oBAEvF,sBAAuBpqB,IACzB2T,GAAoB,KAAoBA,GAAoB,GAAc3T,EAAKqqB,mBAAqB,QACpG3Y,IAAqE,KAApD1R,EAAKqqB,kBAAoB,IAAI35B,QAAQ,UAE1D,EAEAmS,EAAcynB,cAAgB,SAAuBr7B,EAAQ+Q,GAC3D,IAAI9R,EAAI4X,GAAW7W,GACfuC,EAAI8R,GAAW5S,QAAQxC,GACvBue,EAAa,GAAYve,IAExBsD,GACH8R,GAAWmN,OAAOjf,EAAGib,EAAa,EAAI,GAGpCzM,IACFyM,EAAalJ,GAAS6jB,QAAQ,GAAMpnB,EAAM,GAAOA,EAAM,GAAQA,GAAQuD,GAAS6jB,QAAQl5B,EAAG8R,GAE/F,EAEA6C,EAAc0nB,gBAAkB,SAAyBrQ,GACvDjB,GAAUzoB,SAAQ,SAAUtC,GAC1B,OAAOA,EAAE8X,MAAQ9X,EAAE8X,KAAKkU,QAAUA,GAAShsB,EAAE8X,KAAKwK,MAAK,GAAM,EAC/D,GACF,EAEA3N,EAAc2nB,aAAe,SAAsBv3B,EAASlF,EAAOgJ,GACjE,IAAIlC,GAAUge,GAAU5f,GAAW6S,GAAW7S,GAAWA,GAAS4iB,wBAC9D3Q,EAASrQ,EAAOkC,EAAa6d,GAASC,IAAW9mB,GAAS,EAC9D,OAAOgJ,EAAalC,EAAO0E,MAAQ2L,EAAS,GAAKrQ,EAAOyE,KAAO4L,EAAS,GAAKsO,WAAa3e,EAAOwE,OAAS6L,EAAS,GAAKrQ,EAAOuE,IAAM8L,EAAS,GAAK2K,WACrJ,EAEAhN,EAAc4nB,mBAAqB,SAA4Bx3B,EAASy3B,EAAgB3zB,GACtF8b,GAAU5f,KAAaA,EAAU6S,GAAW7S,IAC5C,IAAI4B,EAAS5B,EAAQ4iB,wBACjBiC,EAAOjjB,EAAOkC,EAAa6d,GAASC,IACpC3P,EAA2B,MAAlBwlB,EAAyB5S,EAAO,EAAI4S,KAAkB9S,GAAYA,GAAU8S,GAAkB5S,GAAQ4S,EAAeh6B,QAAQ,KAAOkG,WAAW8zB,GAAkB5S,EAAO,IAAMlhB,WAAW8zB,IAAmB,EACzN,OAAO3zB,GAAclC,EAAOyE,KAAO4L,GAAU,GAAKsO,YAAc3e,EAAOuE,IAAM8L,GAAU,GAAK2K,WAC9F,EAEAhN,EAAc8nB,QAAU,SAAiBC,GAKvC,GAJA3R,GAAUvb,MAAM,GAAGlN,SAAQ,SAAUtC,GACnC,MAAqB,mBAAdA,EAAE8R,KAAK2L,IAA2Bzd,EAAEsiB,MAC7C,KAEuB,IAAnBoa,EAAyB,CAC3B,IAAIC,EAAYlR,GAAWgR,SAAW,GACtChR,GAAa,CAAC,EACdkR,EAAUr6B,SAAQ,SAAUsK,GAC1B,OAAOA,GACT,GACF,CACF,EAEO+H,CACT,CAhwCwC,GAiwCxC,GAAc6N,QAAU,SAExB,GAAcoa,WAAa,SAAUrqB,GACnC,OAAOA,EAAUsQ,GAAStQ,GAASjQ,SAAQ,SAAUvB,GAEnD,GAAIA,GAAUA,EAAOE,MAAO,CAC1B,IAAIqC,EAAIuoB,GAAarpB,QAAQzB,GAE7BuC,GAAK,GAAKuoB,GAAatJ,OAAOjf,EAAG,GAEjCuoB,GAAa5oB,KAAKlC,EAAQA,EAAOE,MAAMsE,QAASxE,EAAOoF,SAAWpF,EAAOiC,aAAa,aAAc,GAAK0Q,KAAKmb,SAAS9tB,GAAS,KAClI,CACF,IAAK8qB,EACP,EAEA,GAAc5nB,OAAS,SAAU4zB,EAAM9L,GACrC,OAAOE,IAAY4L,EAAM9L,EAC3B,EAEA,GAActJ,OAAS,SAAU3Q,EAAMiU,GACrC,OAAO,IAAI,GAAcjU,EAAMiU,EACjC,EAEA,GAAc8G,QAAU,SAAUgQ,GAChC,OAAOA,EAAOvR,MAAe,IAAgB,GAAclZ,aAAewZ,IAAY,EACxF,EAEA,GAAc1S,OAAS,SAAUC,GAC/B,QAAS/D,GAAW1T,OAASwpB,IAAqB,IAAV/R,EAAiB,EAAI,EAC/D,EAEA,GAAc2jB,kBAAoB3Q,GAElC,GAAc4Q,UAAY,SAAUh4B,EAAS8D,GAC3C,OAAO2c,GAAWzgB,EAAS8D,EAAaoO,GAAcO,GACxD,EAEA,GAAcwlB,cAAgB,SAAUj4B,EAAS8D,GAC/C,OAAOyP,GAAeV,GAAW7S,GAAU8D,EAAaoO,GAAcO,GACxE,EAEA,GAAcmL,QAAU,SAAUlF,GAChC,OAAOuN,GAAKvN,EACd,EAEA,GAAciF,OAAS,WACrB,OAAOqI,GAAU3I,QAAO,SAAUpiB,GAChC,MAAqB,mBAAdA,EAAE8R,KAAK2L,EAChB,GACF,EAGA,GAAcwf,YAAc,WAC1B,QAASzY,EACX,EAEA,GAAc0Y,gBAAkBhV,GAEhC,GAAcjS,iBAAmB,SAAU7R,EAAMwkB,GAC/C,IAAInmB,EAAIgpB,GAAWrnB,KAAUqnB,GAAWrnB,GAAQ,KAC/C3B,EAAED,QAAQomB,IAAanmB,EAAEQ,KAAK2lB,EACjC,EAEA,GAAczS,oBAAsB,SAAU/R,EAAMwkB,GAClD,IAAInmB,EAAIgpB,GAAWrnB,GACfd,EAAIb,GAAKA,EAAED,QAAQomB,GACvBtlB,GAAK,GAAKb,EAAE8f,OAAOjf,EAAG,EACxB,EAEA,GAAc65B,MAAQ,SAAU5qB,EAAST,GACvC,IAmBI7R,EAnBA+J,EAAS,GACTozB,EAAW,CAAC,EACZC,EAAWvrB,EAAKurB,UAAY,KAC5BC,EAAWxrB,EAAKwrB,UAAY,IAC5BC,EAAgB,SAAuBn5B,EAAMwkB,GAC/C,IAAI4U,EAAW,GACXC,EAAW,GACXzH,EAAQ,GAAKvV,YAAY4c,GAAU,WACrCzU,EAAS4U,EAAUC,GACnBD,EAAW,GACXC,EAAW,EACb,IAAGvd,QACH,OAAO,SAAUrI,GACf2lB,EAASj6B,QAAUyyB,EAAM7U,SAAQ,GACjCqc,EAASv6B,KAAK4U,EAAKqU,SACnBuR,EAASx6B,KAAK4U,GACdylB,GAAYE,EAASj6B,QAAUyyB,EAAM/P,SAAS,EAChD,CACF,EAGA,IAAKhmB,KAAK6R,EACRsrB,EAASn9B,GAAwB,OAAnBA,EAAEuD,OAAO,EAAG,IAAemiB,GAAY7T,EAAK7R,KAAa,kBAANA,EAAwBs9B,EAAct9B,EAAG6R,EAAK7R,IAAM6R,EAAK7R,GAsB5H,OAnBI0lB,GAAY2X,KACdA,EAAWA,IAEX,GAAa,GAAe,WAAW,WACrC,OAAOA,EAAWxrB,EAAKwrB,UACzB,KAGFza,GAAStQ,GAASjQ,SAAQ,SAAUvB,GAClC,IAAImX,EAAS,CAAC,EAEd,IAAKjY,KAAKm9B,EACRllB,EAAOjY,GAAKm9B,EAASn9B,GAGvBiY,EAAOgU,QAAUnrB,EACjBiJ,EAAO/G,KAAK,GAAcwf,OAAOvK,GACnC,IAEOlO,CACT,EAGA,IA+DI0zB,GA/DAC,GAAuC,SAA8C5U,EAAYwH,EAAS/oB,EAAKyR,GAEjH,OADAsX,EAAUtX,EAAM8P,EAAW9P,GAAOsX,EAAU,GAAKxH,EAAW,GACrDvhB,EAAMyR,GAAOA,EAAMsX,IAAY/oB,EAAM+oB,GAAW/oB,EAAM,EAAI+oB,GAAWA,EAAU/oB,GAAO,CAC/F,EACIo2B,GAAsB,SAASA,EAAoB78B,EAAQkQ,IAC3C,IAAdA,EACFlQ,EAAOE,MAAMmC,eAAe,gBAE5BrC,EAAOE,MAAM48B,aAA4B,IAAd5sB,EAAqB,OAASA,EAAY,OAASA,GAAaqJ,GAASC,QAAU,cAAgB,IAAM,OAGtIxZ,IAAW,IAAU68B,EAAoB,GAAO3sB,EAClD,EACI6sB,GAAY,CACdC,KAAM,EACNjQ,OAAQ,GAENkQ,GAAgB,SAAuBC,GACzC,IAOIv5B,EAPAiX,EAAQsiB,EAAMtiB,MACd5a,EAASk9B,EAAMl9B,OACfgd,EAAOkgB,EAAMlgB,KAEbmgB,GAAQviB,EAAM/B,eAAiB+B,EAAM/B,eAAe,GAAK+B,GAAO5a,OAChEW,EAAQw8B,EAAK78B,OAAS,GAAKqS,KAAKmb,SAASqP,GACzC50B,EAAO,KAGX,IAAK5H,EAAMy8B,YAAc70B,EAAO5H,EAAMy8B,WAAa,IAAM,CAEvD,KAAOD,GAAQA,IAAS,KAAUA,EAAKE,cAAgBF,EAAKG,cAAgBH,EAAKI,aAAeJ,EAAK/S,cAAiB2S,IAAWp5B,EAAK2iB,GAAkB6W,IAAOK,aAAcT,GAAUp5B,EAAG85B,aACxLN,EAAOA,EAAKr4B,WAGdnE,EAAM+8B,UAAYP,GAAQA,IAASn9B,IAAW,GAAYm9B,KAAUJ,IAAWp5B,EAAK2iB,GAAkB6W,IAAOK,YAAcT,GAAUp5B,EAAG85B,YACxI98B,EAAMy8B,WAAa70B,CACrB,EAEI5H,EAAM+8B,WAAsB,MAAT1gB,KACrBpC,EAAM+iB,kBACN/iB,EAAMhC,YAAa,EAEvB,EAEAglB,GAAiB,SAAwB59B,EAAQqD,EAAMw6B,EAAQC,GAC7D,OAAOvkB,GAASmI,OAAO,CACrB1hB,OAAQA,EACRiV,SAAS,EACTsF,UAAU,EACViC,UAAU,EACVnZ,KAAMA,EACN6Y,QAAS4hB,EAASA,GAAUb,GAC5BjiB,QAAS8iB,EACT/iB,OAAQ+iB,EACRtd,SAAUsd,EACV3hB,SAAU,WACR,OAAO0hB,GAAU,GAAa,GAAMtkB,GAASO,WAAW,GAAIikB,IAAgB,GAAO,EACrF,EACA3hB,UAAW,WACT,OAAO,GAAgB,GAAM7C,GAASO,WAAW,GAAIikB,IAAgB,EACvE,GAEJ,EACIC,GAAY,iCAEZD,GAAiB,SAAwBv+B,GAC3C,IAAIy+B,EAAUD,GAAUj2B,KAAKvI,EAAEQ,OAAOiI,UAElCg2B,GAAWtB,MACbn9B,EAAEoZ,YAAa,EACf+jB,GAAkBsB,EAEtB,EACIC,GAAuB,SAA8BntB,GACvD+T,GAAU/T,KAAUA,EAAO,CAAC,GAC5BA,EAAK4H,eAAiB5H,EAAKgL,aAAehL,EAAKwL,aAAc,EAC7DxL,EAAK1N,OAAS0N,EAAK1N,KAAO,eAC1B0N,EAAKwJ,WAAaxJ,EAAKwJ,SACvBxJ,EAAK2L,GAAK3L,EAAK2L,IAAM,aAErB,IAKI5F,EACAqnB,EAeAC,EACAC,EA2CA5zB,EACA6zB,EACAC,EACA5hB,EApEA6hB,EAASztB,EACT0tB,EAAmBD,EAAOC,iBAC1BC,EAAWF,EAAOE,SAClBC,EAAoBH,EAAOG,kBAC3B1jB,EAAYujB,EAAOvjB,UAGnBjb,EAAS6W,GAAW9F,EAAK/Q,SAAW,GACpC4+B,EAAW,GAAKjsB,KAAKwG,UAAU0lB,eAC/BC,EAAmBF,GAAYA,EAASpsB,MACxC6jB,EAAUxT,KAAe9R,EAAKslB,SAAWxf,GAAW9F,EAAKslB,UAAYyI,IAAqC,IAAjB/tB,EAAKslB,UAAsByI,EAAiB3yB,UAAY2yB,EAAiBzI,WAClKjZ,EAAc7F,GAAevX,EAAQyW,IACrC0G,EAAc5F,GAAevX,EAAQkW,IACrCvX,EAAQ,EACRogC,GAAgBxlB,GAASC,SAAW,GAAKwlB,eAAiB,GAAKA,eAAergC,MAAQ,GAAKqgC,eAAel5B,MAAQ,GAAKm5B,YAAc,GAAK1a,WAC1I2a,EAAe,EACfC,EAA0Bva,GAAY8Z,GAAY,WACpD,OAAOA,EAAS5nB,EAClB,EAAI,WACF,OAAO4nB,GAAY,GACrB,EAGIU,EAAgBxB,GAAe59B,EAAQ+Q,EAAK1N,MAAM,EAAMs7B,GACxDU,EAAkB,WACpB,OAAOhB,GAAgB,CACzB,EACIiB,EAAerb,GACfsb,EAAetb,GACfub,EAAe,WACjBrB,EAAO1Z,GAAWzkB,EAAQyW,IAC1B8oB,EAAe,GAAO1c,GAAa,EAAI,EAAGsb,GAC1CM,IAAqBa,EAAe,GAAO,EAAG7a,GAAWzkB,EAAQkW,MACjEkoB,EAAgB9S,EAClB,EACImU,EAAsB,WACxBpJ,EAAQ/1B,MAAM0F,EAAIke,GAAOvc,WAAW0uB,EAAQ/1B,MAAM0F,GAAKoX,EAAYnH,QAAU,KAC7EogB,EAAQn2B,MAAMmB,UAAY,mDAAqDsG,WAAW0uB,EAAQ/1B,MAAM0F,GAAK,UAC7GoX,EAAYnH,OAASmH,EAAYpH,QAAU,CAC7C,EA8BI0pB,EAAW,WAEbF,IAEI/0B,EAAM0qB,YAAc1qB,EAAMsG,KAAKuM,QAAU6gB,IAC3C/gB,IAAgB+gB,EAAO1zB,EAAMya,SAAS,IAAM9H,EAAY+gB,GAAQ1zB,EAAMmrB,QAAQ,UAAWuI,GAE7F,EAwIA,OAtIA9H,GAAW,GAAKr3B,IAAIq3B,EAAS,CAC3BrwB,EAAG,QAGL+K,EAAK+K,YAAc,SAAUtc,GAC3B,OAAOqjB,IAAyB,cAAXrjB,EAAE6D,MA3CR,WACf,GAAIg7B,EAAe,CACjB5f,sBAAsB4gB,GAEtB,IAAIppB,EAASiO,GAAOpN,EAAK8G,OAAS,GAC9BmP,EAASwS,EAAaniB,EAAY3U,EAAIwN,GAE1C,GAAIogB,GAAWtJ,IAAW3P,EAAY3U,EAAI2U,EAAYnH,OAAQ,CAC5DmH,EAAYnH,OAAS8W,EAAS3P,EAAY3U,EAE1C,IAAIzC,EAAIke,IAAQvc,WAAW0uB,GAAWA,EAAQ/1B,MAAM0F,IAAM,GAAKoX,EAAYnH,QAE3EogB,EAAQn2B,MAAMmB,UAAY,mDAAqD2E,EAAI,UACnFqwB,EAAQ/1B,MAAM0F,EAAIA,EAAI,KACtBoX,EAAYpH,QAAU3B,GAAW1T,MAEjCwpB,IACF,CAEA,OAAO,CACT,CAEA/M,EAAYnH,QAAUwpB,IACtBpB,GAAgB,CAClB,CAmBiDsB,IAAiBhhC,EAAQ,MAAmB,eAAXa,EAAE6D,MAAyByT,EAAKqJ,aAAe3gB,EAAE8gB,SAAW9gB,EAAE8gB,QAAQ9d,OAAS,CACjK,EAEAuO,EAAKiK,QAAU,WACbqjB,GAAgB,EAChB,IAAIuB,EAAYjhC,EAChBA,EAAQulB,IAAQ,GAAK8a,gBAAkB,GAAKA,eAAergC,OAAS,GAAKogC,GACzEt0B,EAAM0U,QACNygB,IAAcjhC,GAASk+B,GAAoB78B,EAAQrB,EAAQ,OAAc8/B,GAA2B,KACpGH,EAAenhB,IACfohB,EAAenhB,IACfoiB,IACApB,EAAgB9S,EAClB,EAEAva,EAAKkK,UAAYlK,EAAKiL,eAAiB,SAAUlF,EAAMyI,GAGrD,GAFAnC,EAAYnH,QAAUwpB,IAEjBlgB,EAEE,CACLlL,GAAW1T,QAGX,IACIk/B,EACAzK,EAFA0K,EAAMX,IAINV,IAEFrJ,GADAyK,EAAgB1iB,KACkB,IAAN2iB,GAAchpB,EAAKipB,UAAY,KAE3DD,GAAOlD,GAAqCzf,EAAa0iB,EAAezK,EAAW3Q,GAAWzkB,EAAQkW,KACtGzL,EAAMsG,KAAKsM,QAAUiiB,EAAalK,IAIpCA,GADAyK,EAAgBziB,KACkB,IAAN0iB,GAAchpB,EAAKkpB,UAAY,KAE3DF,GAAOlD,GAAqCxf,EAAayiB,EAAezK,EAAW3Q,GAAWzkB,EAAQyW,KACtGhM,EAAMsG,KAAKuM,QAAUiiB,EAAanK,GAClC3qB,EAAMusB,aAAa9P,SAAS4Y,GAAKG,KAAK,MAElCpd,IAAcpY,EAAMsG,KAAKuM,SAAW6gB,GAAQ0B,GAAiB1B,EAAO,IAEtE,GAAKxX,GAAG,CAAC,EAAG,CACVwJ,SAAUuP,EACVxY,SAAU4Y,GAGhB,MA/BEnjB,EAAkByD,SAAQ,GAiC5BnF,GAAaA,EAAUnE,EACzB,EAEA/F,EAAKmL,QAAU,WACbzR,EAAMy1B,KAAOz1B,EAAM0U,QAEf,KAAa+f,EAAe,MAE9Bd,EAAgB,EAChBc,EAAe,KAEnB,EAEAnuB,EAAKyK,SAAW,SAAU1E,EAAMoH,EAAIC,EAAIgiB,EAAQC,GAI9C,GAHA9U,KAAe8S,GAAiBoB,IAChCthB,GAAMugB,GAAoBthB,EAAYmiB,EAAaa,EAAO,KAAOjiB,EAAKogB,GAAgBxnB,EAAKiI,OAASjI,EAAKlV,GAAKub,IAAgBe,EAAKiiB,EAAO,KAEtIhiB,EAAI,CACNf,EAAYnH,QAAUwpB,IACtB,IAAIjmB,EAAU4mB,EAAO,KAAOjiB,EACxBnY,EAAIwT,EAAU+kB,EAAeznB,EAAKkI,OAASlI,EAAK9Q,EAAIoX,IAAgBe,EAAKiiB,EAAO,GAChFC,EAAWd,EAAav5B,GAC5BwT,GAAWxT,IAAMq6B,IAAa9B,GAAgB8B,EAAWr6B,GACzDoX,EAAYijB,EACd,EAECliB,GAAMD,IAAOiM,IAChB,EAEApZ,EAAKoL,SAAW,WACd0gB,GAAoB78B,GAAQy+B,GAA2B,KAEvD,GAAcvpB,iBAAiB,UAAWwqB,GAE1C,GAAa,GAAM,SAAUA,GAEzBtiB,EAAYjR,SACdiR,EAAYpd,OAAOE,MAAM2rB,eAAiB,OAC1CzO,EAAYjR,OAASgR,EAAYhR,QAAS,GAG5CizB,EAAcle,QAChB,EAEAnQ,EAAKqL,UAAY,WACfygB,GAAoB78B,GAAQ,GAE5B,GAAgB,GAAM,SAAU0/B,GAEhC,GAActqB,oBAAoB,UAAWsqB,GAC7CN,EAAc7d,MAChB,EAEAxQ,EAAKyL,UAA6B,IAAlBzL,EAAKyL,UACrB1F,EAAO,IAAIyC,GAASxI,IACfgF,IAAM8M,GAEXA,KAAezF,KAAiBA,EAAY,GAE5CyF,IAAc,GAAKyd,OAAOruB,IAAIgS,IAE9BtH,EAAoB7F,EAAKmK,IACzBxW,EAAQ,GAAKkc,GAAG7P,EAAM,CACpBwd,KAAM,SACNE,QAAQ,EACRtE,SAAS,EACT7S,QAASohB,EAAmB,QAAU,MACtCnhB,QAAS,QACT0S,UAAW,CACT1S,QAAS4R,GAAqB9R,EAAaA,KAAe,WACxD,OAAO3S,EAAM0U,OACf,KAEFgR,SAAUhG,GACV4F,WAAYpT,EAAkB5L,KAAKgf,aAG9BjZ,CACT,EAEA,GAAc0Q,KAAO,SAAUzS,GAC7B,OAAOiV,GAAUxC,KAAKzS,GAAQ,SAAUrT,EAAGhC,GACzC,OAAwC,KAAhCgC,EAAEqP,KAAKojB,iBAAmB,GAAYzyB,EAAEsH,OAAStJ,EAAEsJ,OAAyC,KAAhCtJ,EAAEqR,KAAKojB,iBAAmB,GAChG,EACF,EAEA,GAAcoM,QAAU,SAAUxvB,GAChC,OAAO,IAAIwI,GAASxI,EACtB,EAEA,GAAcyvB,gBAAkB,SAAUzvB,GACxC,QAAoB,IAATA,EACT,OAAO,GAGT,IAAa,IAATA,GAAiB,GACnB,OAAO,GAAYmQ,SAGrB,IAAa,IAATnQ,EAGF,OAFA,IAAe,GAAYwQ,YAC3B,GAAcxQ,GAIhB,IAAI0vB,EAAa1vB,aAAgBwI,GAAWxI,EAAOmtB,GAAqBntB,GAGxE,OAFA,IAAe,GAAY/Q,SAAWygC,EAAWzgC,QAAU,GAAYuhB,OACvE,GAAYkf,EAAWzgC,UAAY,GAAcygC,GAC1CA,CACT,EAEA,GAAc9tB,KAAO,CAEnBgF,iBAAkBA,GAClBimB,eAAgBA,GAChBvpB,WAAYA,GACZC,SAAUA,GACV8E,OAAQ,CAENsnB,GAAI,WACFjd,IAAmB4G,GAAU,eAC7B5G,GAAkB,IACpB,EAEAkd,IAAK,WACH,OAAO1e,EACT,IAGJ,MAAc,GAAK/N,eAAe,mBC1lFlCZ,GAAAA,eAAoBM,IAkKpB,OAhKuCgtB,KACrC,MAAMC,GAAaC,EAAAA,EAAAA,QAAuB,OACpC,EAACC,EAAa,EAACC,IAAmBC,EAAAA,EAAAA,WAAS,GAC3CliC,GAAOmiC,EAAAA,GAAAA,gBAAe,cAmBtBC,EAAgC,oBAAdxnB,WAA6B,4BAA4B5R,KAAK4R,UAAUygB,YAEhGgH,EAAAA,EAAAA,YAAU,KACR,MAAMC,EAAiBR,EAAWrR,QAElC,GAAI6R,EAAgB,CACGC,KACnB,MAAMC,EAAWD,EAAYE,iBAAiB,QAE9CluB,GAAAA,IAASiuB,EAAU,CAAEE,QAAS,KAE9BnuB,GAAAA,GAAQiuB,EAAU,CAChBE,QAAS,EACTva,SAAU,GACVwH,cAAe,CACbvD,QAASkW,EACTr4B,MAAO,kBACPvC,IAAK,qBACL8rB,OAAO,GAET0C,MAAQtrB,GAAkB,IAARA,GAClB,EAGJ+3B,CAAYL,EACd,IACC,KAEHD,EAAAA,EAAAA,YAAU,KACR,GAAIL,EAAc,CAAC,IAADY,EAChB,MAAMC,EAAkC,QAArBD,EAAGd,EAAWrR,eAAO,IAAAmS,OAAA,EAAlBA,EAAoBH,iBAAiB,mBAEvDI,GACFA,EAAcrgC,SAASsgC,IACjBA,aAAqBC,aACvBJ,EAAYG,EACd,GAGN,KAAO,CAAC,IAADE,EACL,MAAMC,EAAsC,QAArBD,EAAGlB,EAAWrR,eAAO,IAAAuS,OAAA,EAAlBA,EAAoBP,iBAAiB,mBAE3DQ,GACFA,EAAkBzgC,SAAQ,CAACsgC,EAAWl4B,KAChCk4B,aAAqBC,aAAen4B,EAAQ,GAC9C+3B,EAAYG,EACd,GAGN,IACC,CAACd,IAEJ,MAAMW,EAAeJ,IACnB,MAAMW,EAAQX,EAAY9X,UAAUloB,MAAM,KAC1CggC,EAAYY,UAAY,GAExBD,EAAM1gC,SAAQ,CAAC4gC,EAAMC,KACnB,MAAMC,EAAW/9B,SAASd,cAAc,QAwBxC,GAvBA6+B,EAASlM,UAAUlkB,IAAI,QACvBqvB,EAAYp8B,YAAYm9B,GAExBF,EAAK7gC,MAAM,IAAIC,SAAQ,CAAC+gC,EAAQC,KAC9B,MAAMC,EAAal+B,SAASd,cAAc,QAC1Cg/B,EAAWhZ,UAAY8Y,EAEvBhvB,GAAAA,IAASkvB,EAAY,CAAEf,QADA,KAEvBY,EAASn9B,YAAYs9B,GAErBlvB,GAAAA,GAAQkvB,EAAY,CAClBf,QAAS,EACTva,SAAU,GACVwH,cAAe,CACbvD,QAASqX,EACTx5B,MAAO,kBACPvC,IAAK,qBACL8rB,OAAO,GAET0C,MAAqB,GAAdsN,GACP,IAGAH,EAAYH,EAAMz/B,OAAS,EAAG,CAChC,MAAMigC,EAAYn+B,SAASd,cAAc,QACzCi/B,EAAUjZ,UAAY,IACtB6Y,EAASn9B,YAAYu9B,EACvB,IACA,EAeJ,OACEC,EAAAA,cAAA,WACE/B,IAAKE,EACLnkB,GAAG,uBACHxc,MAAO,CACLyiC,gBAAiB5jC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYC,UAGvDL,EAAAA,cAAA,OACE1M,UAAU,oBACV91B,MAAO,CACLsI,SAAU,aAGZk6B,EAAAA,cAAA,KAAG1M,UAAU,iBAAiBgN,wBAAyB,CAAEC,OAAQ9B,EAAWpiC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYI,cAAgBnkC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYK,mBACpKT,EAAAA,cAAA,MAAI1M,UAAU,YAAY,IAAC0M,EAAAA,cAAA,MAAI1M,UAAU,YAAY,IAAC0M,EAAAA,cAAA,MAAI1M,UAAU,WAAW0M,EAAAA,cAAA,MAAI1M,UAAU,WAC7F0M,EAAAA,cAAA,KAAG1M,UAAU,iBAAiBgN,wBAAyB,CAAEC,OAAQ9B,EAAWpiC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYM,cAAgBrkC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYO,mBACpKX,EAAAA,cAAA,MAAI1M,UAAU,YAAY,IAAC0M,EAAAA,cAAA,MAAI1M,UAAU,YAAY0M,EAAAA,cAAA,MAAI1M,UAAU,WAAW0M,EAAAA,cAAA,MAAI1M,UAAU,WAC3F+K,EACC2B,EAAAA,cAAAA,EAAAA,SAAA,KACEA,EAAAA,cAAA,KAAG1M,UAAU,iBAAiBgN,wBAAyB,CAAEC,OAAQ9B,EAAWpiC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYQ,cAAgBvkC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYS,mBACpKb,EAAAA,cAAA,MAAI1M,UAAU,YAAY0M,EAAAA,cAAA,MAAI1M,UAAU,YAAY0M,EAAAA,cAAA,MAAI1M,UAAU,WAAW0M,EAAAA,cAAA,MAAI1M,UAAU,WAC3F0M,EAAAA,cAAA,KAAG1M,UAAU,iBAAiBgN,wBAAyB,CAAEC,OAAQ9B,EAAWpiC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYU,cAAgBzkC,EAAK6jC,UAAUC,MAAM,GAAGC,YAAYW,mBACpKf,EAAAA,cAAA,MAAI1M,UAAU,YAAY0M,EAAAA,cAAA,MAAI1M,UAAU,WACxC0M,EAAAA,cAAA,UAAQrmB,QAhCMqnB,KACtB1C,GAAgB,EAAM,GA+BoB,YAIpC0B,EAAAA,cAAA,UAAQ1M,UAAU,oBAAoB3Z,QAxClBsnB,KAC1B3C,GAAgB,EAAK,GAuCqD,aAKhE,kCC/Dd,OA9FmC4C,KACjC,MA2BMC,GA3BO3C,EAAAA,GAAAA,gBAAe,cA2BD0B,UAAUkB,MAAM,GAAG3G,KAAK2F,aAE7C,EAACiB,EAAQ,EAACC,IAAc/C,EAAAA,EAAAA,WAAS,GAUvC,OACEyB,EAAAA,cAAA,WACEhmB,GAAG,gBACHxc,MAAO,CACL+jC,gBAAgB,OAAQJ,EAAcK,kBAAkBC,aAAY,MAGtEzB,EAAAA,cAAA,OAAK1M,UAAU,qBACb0M,EAAAA,cAAA,OAAK1M,UAAU,6BACb0M,EAAAA,cAAA,UAAKmB,EAAcO,iBACnB1B,EAAAA,cAAA,OACE1M,UAAU,kBACVqO,IAAKC,GAAAA,EACLC,IAAI,oBAEN7B,EAAAA,cAAA,MACEM,wBAAyB,CACvBC,OAAQY,EAAcW,wBAG1B9B,EAAAA,cAAA,KACE+B,KAAMZ,EAAca,kBACpB1kC,OAAO,SACPg2B,UAAU,eACV2O,IAAI,sBACJC,aAjCgBC,KACxBb,GAAW,EAAK,EAiCRc,aA9BgBC,KACxBf,GAAW,EAAM,EA8BT9jC,MAAO,CACL8kC,OAAQ,UACRrC,gBAAiB,cACjBsC,eAAgB,SAGjBpB,EAAcqB,oBAAqB,IACpCxC,EAAAA,cAAA,OACE2B,IAAKN,EAAUoB,GAAAA,EAAqBC,GAAAA,EACpCb,IAAI,YACJrkC,MAAO,CAAEmlC,KAAM,gBAMvB3C,EAAAA,cAAA,mJAG0CmB,EAAcyB,wBAAwBnB,aAAY,yEAIpF,ECbd,OA7E+BoB,KAC7B,MAwBMC,GAxBOtE,EAAAA,GAAAA,gBAAe,cAwBJ0B,UAAUC,MAAM,GAAGC,aACrC,YAAE2C,EAAW,iBAAEC,EAAgB,gBAAEC,EAAe,cAAEC,EAAa,aAAEC,GAAiBL,GAElF,EAACM,EAAM,EAACC,IAAY9E,EAAAA,EAAAA,UAASuE,EAAWQ,oBAC9C5E,EAAAA,EAAAA,YAAU,KACR,MAAM6E,EAAeA,KACnBF,EAAS1hC,OAAOkgB,YAAc,IAAMihB,EAAWU,wBAA0BV,EAAWQ,kBAAkB,EAKxG,OAFA3hC,OAAO6Q,iBAAiB,SAAU+wB,GAE3B,KACL5hC,OAAO+Q,oBAAoB,SAAU6wB,EAAa,CACnD,GACA,CAACT,IAcJ,OACE9C,EAAAA,cAAA,OAAKhmB,GAAG,UAAUsZ,UAAU,iBAC1B0M,EAAAA,cAAA,OAAK1M,UAAU,qBAAqB91B,MAAO,CAAEyiC,gBAAiBkD,IAC5DnD,EAAAA,cAAA,OAAK1M,UAAU,sBACb0M,EAAAA,cAAA,MAAI1M,UAAU,sBAAsBgN,wBAAyB,CAAEC,OAAQwC,KACvE/C,EAAAA,cAAA,OAAK1M,UAAU,kBAAkBqO,IAAKC,GAAAA,EAAUC,IAAI,oBACpD7B,EAAAA,cAAA,KAAG1M,UAAU,4BAA4BgN,wBAAyB,CAAEC,OAAQyC,KAC5EhD,EAAAA,cAAA,KACE+B,KAAMmB,EACN5P,UAAU,iCACV4O,aAtBiBplC,IACzBA,EAAE2mC,cAAcC,cAAc,OAAO/B,IAAMc,GAAAA,CAAkB,EAsBrDL,aAnBiBtlC,IACzBA,EAAE2mC,cAAcC,cAAc,OAAO/B,IAAMe,GAAAA,CAAa,GAoB/CO,EAAgB,IAACjD,EAAAA,cAAA,OAAK2B,IAAKe,GAAAA,EAAeb,IAAI,iBAIrD7B,EAAAA,cAAA,OAAK1M,UAAU,uBACb0M,EAAAA,cAAA,OAAK2B,IAAKyB,EAAMO,UAAW9B,IAAKuB,EAAMQ,WAEpC,ECZV,OA/D6BC,KAC3B,MAAM,EAACC,EAAa,EAACC,IAAmBxF,EAAAA,EAAAA,UAAS,GAyB3CyF,GAxBOxF,EAAAA,GAAAA,gBAAe,cAwBJ0B,UAAUC,MAAM,GAAGC,YAAY4D,YAUjD,aAAEC,EAAY,MAAEC,EAAK,YAAEC,EAAW,QAAE9D,GAAY2D,EAAWF,GAEjE,OACE9D,EAAAA,cAAA,OAAK1M,UAAU,eACb0M,EAAAA,cAAA,OAAK1M,UAAU,oBACb0M,EAAAA,cAAA,OAAK2B,IAAKsC,EAAaN,UAAW9B,IAAKoC,EAAaL,WAEtD5D,EAAAA,cAAA,OAAK1M,UAAU,oBAAoB91B,MAAO,CAAEyiC,gBAAiBI,IAC3DL,EAAAA,cAAA,OAAK1M,UAAU,oBACb0M,EAAAA,cAAA,MAAI1M,UAAU,oBAAoBgN,wBAAyB,CAAEC,OAAQ2D,KACrElE,EAAAA,cAAA,KAAG1M,UAAU,2BAA2B6Q,GACvCH,EAAWlkC,OAAS,GACnBkgC,EAAAA,cAAA,OAAK1M,UAAU,0BACb0M,EAAAA,cAAA,UAAQ1M,UAAU,mBAAmB3Z,QArB9ByqB,KACjBL,GAAiBM,GAA6B,IAAdA,EAAkBL,EAAWlkC,OAAS,EAAIukC,EAAY,GAAG,GAqB7ErE,EAAAA,cAAA,OAAK2B,ICvDrB,qoEDuD0CE,IAAI,cAEhC7B,EAAAA,cAAA,UAAQ1M,UAAU,mBAAmB3Z,QApB9B2qB,KACjBP,GAAiBM,GAAeA,IAAcL,EAAWlkC,OAAS,EAAI,EAAIukC,EAAY,GAAG,GAoB7ErE,EAAAA,cAAA,OAAK2B,IE1DrB,ipEF0D2CE,IAAI,aAMrC,EG7DV,SAAS0C,GAASC,GAChB,OAJF,SAAkBA,GAChB,MAAmD,oBAA5C/zB,OAAOgH,UAAUgtB,SAAS3lC,KAAK0lC,EACxC,CAESE,CAASF,IAAY5f,MAAMC,QAAQ2f,EAC5C,CAIA,SAASG,GAAgBC,EAAUC,GACjC,MAAMC,EAAer0B,OAAOs0B,KAAKH,GAC3BI,EAAev0B,OAAOs0B,KAAKF,GACjC,GAAIC,EAAahlC,SAAWklC,EAAallC,OAAQ,OAAO,EAGxD,OAFqBmlC,KAAKC,UAAUz0B,OAAOs0B,KAAKH,EAASO,aAAe,CAAC,MACpDF,KAAKC,UAAUz0B,OAAOs0B,KAAKF,EAASM,aAAe,CAAC,KAElEL,EAAaM,OAAMz0B,IACxB,MAAM00B,EAAST,EAASj0B,GAClB20B,EAAST,EAASl0B,GACxB,MAAsB,mBAAX00B,EAA8B,GAAGA,KAAa,GAAGC,IACvDf,GAASc,IAAYd,GAASe,GAC5BX,GAAgBU,EAAQC,GADoBD,IAAWC,CACxB,GAE1C,CACA,SAASC,GAA0BC,GACjC,OAAOA,EAAQhb,SAAS1F,MAAK,CAAC9lB,EAAGhC,IAAMgC,EAAEkP,KAAOlR,EAAEkR,KAAO,GAAK,IAAGxF,KAAI7E,GAAUA,EAAO4hC,SACxF,CC1BA,SAASC,GAASlB,GAChB,MAA0B,iBAAZA,CAChB,CACA,SAAS92B,GAAS82B,GAChB,MAA0B,iBAAZA,CAChB,CACA,SAASmB,GAAUnB,GACjB,MAA0B,kBAAZA,CAChB,CACA,SAAS,GAASA,GAChB,MAAmD,oBAA5C/zB,OAAOgH,UAAUgtB,SAAS3lC,KAAK0lC,EACxC,CACA,SAASoB,GAAQ7O,GACf,OAAOx7B,KAAK0Q,IAAI8qB,EAClB,CACA,SAAS8O,GAAS9O,GAChB,OAAOx7B,KAAKuqC,KAAK/O,EACnB,CACA,SAASgP,GAAST,EAAQD,GACxB,OAAOO,GAAQN,EAASD,EAC1B,CAOA,SAASW,GAAUC,GACjB,OAAOC,GAAWD,GAAOv9B,IAAIy9B,OAC/B,CACA,SAASC,GAAUH,GACjB,OAAOA,EAAMI,GAAeJ,GAC9B,CACA,SAASI,GAAeJ,GACtB,OAAO1qC,KAAKia,IAAI,EAAGywB,EAAMnmC,OAAS,EACpC,CACA,SAASomC,GAAWI,GAClB,OAAO71B,OAAOs0B,KAAKuB,EACrB,CACA,SAASC,GAAiBC,EAASC,GACjC,MAAO,CAACD,EAASC,GAASC,QAAO,CAACC,EAAeC,KAC/CV,GAAWU,GAAe/nC,SAAQ8R,IAChC,MAAM00B,EAASsB,EAAch2B,GACvB20B,EAASsB,EAAcj2B,GACvBk2B,EAAa,GAASxB,IAAW,GAASC,GAChDqB,EAAch2B,GAAOk2B,EAAaN,GAAiBlB,EAAQC,GAAUA,CAAM,IAEtEqB,IACN,CAAC,EACN,CACA,SAASG,GAAaC,EAAKC,GACzB,YAAyC,IAA3BA,EAAYC,YAA8BF,aAAeC,EAAYC,UACrF,CAEA,SAASC,GAAUC,EAAOC,GACxB,MAAMC,EAAa,CACjB/gC,MAIF,WACE,OAAO,CACT,EALEuB,OAMF,SAAgBkvB,GACd,OAAOhzB,EAAIgzB,GAAK,CAClB,EAPEhzB,OAQF,SAASA,EAAIgzB,GACX,OAAOqQ,EAAWrQ,CACpB,CAWA,MAHa,CACXuQ,QALF,SAAiBvQ,GACf,OAAI2O,GAASyB,GAHNC,EAAWjB,OAAOgB,GAIlBE,EAAWF,GAAOpQ,EAC3B,EAKF,CAgCA,SAASwQ,GAAMjyB,EAAKE,GAClB,MAAM1V,EAAS8lC,GAAQtwB,EAAME,GAC7B,SAASgyB,EAAWzQ,GAClB,OAAOA,EAAIzhB,CACb,CACA,SAASmyB,EAAW1Q,GAClB,OAAOA,EAAIvhB,CACb,CACA,SAASkyB,EAAW3Q,GAClB,OAAOyQ,EAAWzQ,IAAM0Q,EAAW1Q,EACrC,CAmBA,MAVa,CACXj3B,SACA0V,MACAF,MACAqyB,UAZF,SAAmB5Q,GACjB,OAAK2Q,EAAW3Q,GACTyQ,EAAWzQ,GAAKzhB,EAAME,EADFuhB,CAE7B,EAUE2Q,aACAD,aACAD,aACAI,aAZF,SAAsB7Q,GACpB,OAAKj3B,EACEi3B,EAAIj3B,EAASvE,KAAKs6B,MAAMkB,EAAIvhB,GAAO1V,GADtBi3B,CAEtB,EAYF,CAEA,SAAS8Q,GAAQryB,EAAKlP,EAAOwhC,GAC3B,MAAM,UACJH,GACEJ,GAAM,EAAG/xB,GACPuyB,EAAUvyB,EAAM,EACtB,IAAIwyB,EAAUC,EAAY3hC,GAC1B,SAAS2hC,EAAYlR,GACnB,OAAQ+Q,EAAsBlC,IAASmC,EAAUhR,GAAKgR,GAAvCJ,EAAU5Q,EAC3B,CACA,SAASjnB,IACP,OAAOk4B,CACT,CAQA,SAASE,IACP,OAAOL,GAAQryB,EAAK1F,IAAOg4B,EAC7B,CACA,MAAM1zB,EAAO,CACXtE,MACAxT,IAZF,SAAay6B,GAEX,OADAiR,EAAUC,EAAYlR,GACf3iB,CACT,EAUE7E,IATF,SAAawnB,GACX,OAAOmR,IAAQ5rC,IAAIwT,IAAQinB,EAC7B,EAQEmR,SAEF,OAAO9zB,CACT,CAaA,SAAS+zB,KACP,IAAIjP,EAAY,GAWhB,MAAM9kB,EAAO,CACX7E,IAXF,SAAakrB,EAAM95B,EAAMynC,EAAS3C,EAAU,CAC1CnzB,SAAS,IAIT,OAFAmoB,EAAKjoB,iBAAiB7R,EAAMynC,EAAS3C,GACrCvM,EAAU15B,MAAK,IAAMi7B,EAAK/nB,oBAAoB/R,EAAMynC,EAAS3C,KACtDrxB,CACT,EAMEi0B,MALF,WACEnP,EAAYA,EAAUva,QAAO2pB,GAAUA,KACzC,GAKA,OAAOl0B,CACT,CAEA,SAASm0B,GAAYjuB,EAAM9M,EAAWg7B,EAAUxtB,EAAegsB,EAAa1pC,EAAQmrC,EAAaC,EAAUpmB,EAAWxO,EAAU60B,EAAYC,EAAc3hC,EAAO4hC,EAAcC,EAAeC,EAAUC,EAAeC,EAAWC,GAChO,MACEC,MAAOC,GACL9uB,EACE+uB,EAAa,CAAC,QAAS,SAAU,YACjCC,EAAkB,CACtBh3B,SAAS,GAELi3B,EAAapB,KACbqB,EAAarB,KACbsB,EAAoBlC,GAAM,GAAI,KAAKI,UAAUmB,EAAcxB,QAAQ,KACnEoC,EAAiB,CACrBC,MAAO,IACPC,MAAO,KAEHC,EAAiB,CACrBF,MAAO,IACPC,MAAO,KAEHE,EAAYf,EAAW,GAAK,GAClC,IAAIgB,GAAW,EACXC,EAAc,EACdC,EAAa,EACbC,GAAgB,EAChBC,GAAgB,EAChBC,GAAe,EACfC,GAAU,EAiDd,SAASC,EAAKvD,GACZ,MAAMwD,EAAa9B,EAAY+B,UAAUzD,GACnC0D,EAAYhC,EAAY+B,UAAUzD,EAAKqC,GACvCsB,EAAa3E,GAASwE,EAAYP,GAClCW,EAAY5E,GAAS0E,EAAWR,GACtC,IAAKE,IAAkBE,EAAS,CAC9B,IAAKtD,EAAI6D,WAAY,OAAOC,EAAG9D,GAE/B,GADAoD,EAAgBO,EAAaC,GACxBR,EAAe,OAAOU,EAAG9D,EAChC,CACA,MAAM+D,EAAOrC,EAAYsC,YAAYhE,GACjC2D,EAAa1B,IAAeoB,GAAe,GAC/CzB,EAAWqC,YAAY,IAAKC,YAAY,GACxC3oB,EAAUhc,QACVhJ,EAAOiS,IAAI/B,EAAU6I,MAAMy0B,IAC3B/D,EAAI9wB,gBACN,CACA,SAAS40B,EAAG9D,GACV,MACMmE,EADkBtC,EAAauC,WAAW,GAAG,GACblkC,QAAUA,EAAM6I,MAChDs7B,EAAW3C,EAAY4C,UAAUtE,IA/CzBgC,EAAWc,EAAiBH,GAC7BW,EAAU,QAAU,SA+C3B30B,EA5CR,SAAsBA,EAAOw1B,GAC3B,MAAMjX,EAAOhtB,EAAMsI,KAAuB,EAAnBs2B,GAASnwB,IAC1B41B,EAAY1C,EAAauC,WAAWz1B,GAAQqzB,GAAUwC,SAC5D,OAAIxC,GAAYnD,GAAQlwB,GAAS+zB,EAA0B6B,EACvDrC,GAAaiC,EAAkC,GAAZI,EAChC1C,EAAa4C,QAAQvX,EAAKnkB,MAAO,GAAGy7B,QAC7C,CAsCgBE,CAAaj+B,EAAU6I,MAAM+0B,GAAWF,GAChDQ,EAzRV,SAAmBpG,EAAQD,GACzB,GAAe,IAAXC,GAA2B,IAAXD,EAAc,OAAO,EACzC,GAAIO,GAAQN,IAAWM,GAAQP,GAAS,OAAO,EAC/C,MAAMyF,EAAO/E,GAASH,GAAQN,GAASM,GAAQP,IAC/C,OAAOO,GAAQkF,EAAOxF,EACxB,CAoRwBqG,CAAUP,EAAU11B,GAClCk2B,EAAQ9B,EAAY,GAAK4B,EACzBG,EAAW3C,EAAewC,EAAc,GAC9CvB,GAAgB,EAChBD,GAAgB,EAChBV,EAAWnB,QACXM,EAAWsC,YAAYW,GAAOZ,YAAYa,GAC1C/3B,EAASy3B,SAAS71B,GAAQqzB,GAC1BsB,GAAU,EACVxB,EAAaiD,KAAK,YACpB,CACA,SAAS5uB,EAAM6pB,GACTqD,IACFrD,EAAI9L,kBACJ8L,EAAI9wB,iBAER,CASA,MALa,CACX1H,KA3FF,SAAcw9B,EAAUC,GACtB,IAAKA,EAAW,OAChB,SAASC,EAAclF,IACjBpB,GAAUqG,IAAcA,EAAUD,EAAUhF,KA6BpD,SAAcA,GACZ,MAAMmF,EAAapF,GAAaC,EAAKC,GAErC,GADAqD,EAAU6B,EACNA,GAA6B,IAAfnF,EAAIvqB,OAAc,OACpC,GApBF,SAAqBie,GACnB,MAAM0R,EAAW1R,EAAK0R,UAAY,GAClC,OAAO9C,EAAW+C,SAASD,EAC7B,CAiBME,CAAYtF,EAAIzpC,QAAS,OAC7B8sC,EAAerB,GAAYmD,IAAenF,EAAIuF,SAAWvC,EACzDA,EAAWhE,GAASzoC,EAAOwS,MAAO44B,EAAS54B,QAAU,EACrDo6B,GAAgB,EAChBzB,EAAY8D,YAAYxF,GACxB4B,EAAWqC,YAAY,GAAGC,YAAY,GACtC3tC,EAAOhB,IAAIosC,GA9Bb,WACE,MAAMjO,EAAO4P,EAAUrvB,EAAgBwtB,EACvCgB,EAAWj6B,IAAIkrB,EAAM,YAAa6P,EAAMhB,GAAiB/5B,IAAIkrB,EAAM,WAAYoQ,GAAIt7B,IAAIkrB,EAAM,YAAa6P,EAAMhB,GAAiB/5B,IAAIkrB,EAAM,UAAWoQ,EACxJ,CA4BE2B,GACAxC,EAAcvB,EAAY+B,UAAUzD,GACpCkD,EAAaxB,EAAY+B,UAAUzD,EAAKqC,GACxCP,EAAaiD,KAAK,cACpB,CA5C0DW,CAAK1F,EAC7D,CACA,MAAMtM,EAAO+N,EACbe,EAAWh6B,IAAIkrB,EAAM,aAAasM,GAAOA,EAAI9wB,kBAAkBqzB,GAAiB/5B,IAAIkrB,EAAM,aAAa,KAAe,GAAE6O,GAAiB/5B,IAAIkrB,EAAM,YAAY,KAAe,IAAElrB,IAAIkrB,EAAM,aAAcwR,GAAe18B,IAAIkrB,EAAM,YAAawR,GAAe18B,IAAIkrB,EAAM,cAAeoQ,GAAIt7B,IAAIkrB,EAAM,cAAeoQ,GAAIt7B,IAAIkrB,EAAM,QAASvd,GAAO,EACnV,EAqFEqvB,YALF,WACE,OAAOrC,CACT,EAIEwC,QArFF,WACEnD,EAAWlB,QACXmB,EAAWnB,OACb,EAqFF,CAEA,SAASsE,GAAYryB,EAAM0sB,GAEzB,IAAI4F,EACAC,EACJ,SAASC,EAAS/F,GAChB,OAAOA,EAAIgG,SACb,CACA,SAASvC,EAAUzD,EAAKiG,GACtB,MACMC,EAAQ,UAAsB,OADnBD,GAAW1yB,EAAK+P,QACS,IAAM,KAChD,OAAQyc,GAAaC,EAAKC,GAAeD,EAAMA,EAAInpB,QAAQ,IAAIqvB,EACjE,CA4BA,MANa,CACXV,YAtBF,SAAqBxF,GAGnB,OAFA6F,EAAa7F,EACb8F,EAAY9F,EACLyD,EAAUzD,EACnB,EAmBEgE,YAlBF,SAAqBhE,GACnB,MAAM+D,EAAON,EAAUzD,GAAOyD,EAAUqC,GAClCK,EAAUJ,EAAS/F,GAAO+F,EAASF,GAlBvB,IAqBlB,OAFAC,EAAY9F,EACRmG,IAASN,EAAa7F,GACnB+D,CACT,EAaEO,UAZF,SAAmBtE,GACjB,IAAK6F,IAAeC,EAAW,OAAO,EACtC,MAAMM,EAAW3C,EAAUqC,GAAarC,EAAUoC,GAC5CQ,EAAWN,EAAS/F,GAAO+F,EAASF,GACpCM,EAAUJ,EAAS/F,GAAO+F,EAASD,GA3BvB,IA4BZn3B,EAAQy3B,EAAWC,EAEzB,OADgBA,IAAaF,GAAWtH,GAAQlwB,GAAS,GACxCA,EAAQ,CAC3B,EAKE80B,YAGJ,CAYA,SAAS6C,GAAc/mB,EAAWgnB,EAAQhzB,EAAMuuB,GAC9C,IAAI0E,EACAC,EACAC,EAAa,GACbC,GAAY,EAChB,SAASC,EAASlT,GAChB,OAAOngB,EAAKszB,YAAYnT,EAAKvW,wBAC/B,CAmCA,MAJa,CACX3V,KA/BF,SAAcw9B,EAAU8B,GACtB,IAAKA,EAAa,OAClBL,EAAgBG,EAASrnB,GACzBmnB,EAAaH,EAAO5kC,IAAIilC,GAcxBJ,EAAiB,IAAIO,gBAAeC,IAC9BL,IACA/H,GAAUkI,IAAgBA,EAAY9B,EAAUgC,KAftD,SAAyBA,GACvB,IAAK,MAAMC,KAASD,EAAS,CAC3B,MAAME,EAAcD,EAAM1wC,SAAWgpB,EAC/B4nB,EAAaZ,EAAOvuC,QAAQivC,EAAM1wC,QAGxC,IAFiB2wC,EAAcT,EAAgBC,EAAWS,MAC1CP,EAASM,EAAc3nB,EAAYgnB,EAAOY,IAChC,CACxBnC,EAASoC,SACTtF,EAAaiD,KAAK,UAClB,KACF,CACF,CACF,CAIIsC,CAAgBL,EAClB,IAEmB,CAACznB,GAAWkE,OAAO8iB,GAC3BzuC,SAAQ47B,GAAQ8S,EAAe1P,QAAQpD,IACtD,EAOEiS,QANF,WACMa,GAAgBA,EAAec,aACnCX,GAAY,CACd,EAMF,CA4DA,SAASY,GAAaC,EAAO7F,EAAUprC,EAAQqrC,EAAYG,GACzD,MAAM0F,EAAoB1F,EAAcxB,QAAQ,IAC1CmH,EAAsB3F,EAAcxB,QAAQ,IAC5CoH,EAAgBnH,GAAM,GAAK,KACjC,IAAIoH,GAAW,EA0Bf,MAJa,CACXhH,UAhBF,SAAmB4E,GACjB,GANIoC,IACCJ,EAAM7G,WAAWpqC,EAAOwS,SACxBy+B,EAAM7G,WAAWgB,EAAS54B,OAIP,OACxB,MAAM8+B,EAAOL,EAAM/G,WAAWkB,EAAS54B,OAAS,MAAQ,MAClD++B,EAAajJ,GAAQ2I,EAAMK,GAAQlG,EAAS54B,OAC5Cg/B,EAAexxC,EAAOwS,MAAQ44B,EAAS54B,MACvC+7B,EAAW6C,EAAc/G,UAAUkH,EAAaJ,GACtDnxC,EAAOyxC,SAASD,EAAejD,IAC1BU,GAAe3G,GAAQkJ,GAAgBN,IAC1ClxC,EAAOhB,IAAIiyC,EAAM5G,UAAUrqC,EAAOwS,QAClC64B,EAAWsC,YAAY,IAAI+D,kBAE/B,EAMEC,aALF,SAAsBC,GACpBP,GAAYO,CACd,EAMF,CAEA,SAASC,GAAc/H,EAAUgI,EAAaC,EAAcC,GAC1D,MAAMC,EAAehI,IAAO6H,EAAchI,EAAUiI,EAAa,IAC3DG,EAUGH,EAAa3mC,IAAI6mC,EAAa5H,WAAWj/B,KAAI+mC,GAAexqC,WAAWwqC,EAAYC,QAAQ,MAcpG,MAHa,CACXC,eAVF,WACE,GAAIP,GAAehI,EAAU,MAAO,CAACmI,EAAa/5B,KAClD,GAAsB,cAAlB85B,EAA+B,OAAOE,EAC1C,MAAM,IACJl6B,EAAG,IACHE,GAfJ,WACE,MAAMo6B,EAAYJ,EAAa,GACzBK,EAAUzJ,GAAUoJ,GACpBl6B,EAAMk6B,EAAaM,YAAYF,GAC/Bp6B,EAAMg6B,EAAazwC,QAAQ8wC,GAAW,EAC5C,OAAOtI,GAAMjyB,EAAKE,EACpB,CAUMu6B,GACJ,OAAOP,EAAazjC,MAAMuJ,EAAKE,EACjC,CAnBuBw6B,GAwBzB,CAYA,SAASC,GAAab,EAAab,EAAO7F,EAAUwH,GAClD,MACM56B,EAAMi5B,EAAMj5B,IADE,GAEdE,EAAM+4B,EAAM/4B,IAFE,IAGd,WACJgyB,EAAU,WACVC,GACEF,GAAMjyB,EAAKE,GAcf,MAHa,CACXsyB,KANF,SAAct6B,GACZ,IANF,SAAoBA,GAClB,OAAkB,IAAdA,EAAwBi6B,EAAWiB,EAAS54B,QAC7B,IAAftC,GAAyBg6B,EAAWkB,EAAS54B,MAEnD,CAEOqgC,CAAW3iC,GAAY,OAC5B,MAAM4iC,EAAehB,IAA4B,EAAb5hC,GACpC0iC,EAAQrxC,SAAQkH,GAAKA,EAAEwJ,IAAI6gC,IAC7B,EAKF,CAEA,SAASC,GAAe9B,GACtB,MAAM,IACJ/4B,EACA1V,OAAQwwC,GACN/B,EAQJ,MAHa,CACXz+B,IALF,SAAainB,GAEX,OADwBA,EAAIvhB,IACF86B,CAC5B,EAKF,CAqCA,SAASC,GAAazI,EAAM0I,EAAapB,EAAab,EAAOkC,GAC3D,MAAM,WACJ/I,EAAU,aACVE,EAAY,UACZD,GACE4G,EACJ,SAASmC,EAAYC,GACnB,OAAOA,EAAUnmB,SAAS1F,MAAK,CAAC9lB,EAAGhC,IAAM4oC,GAAQ5mC,GAAK4mC,GAAQ5oC,KAAI,EACpE,CAeA,SAAS4zC,EAAStzC,EAAQkQ,GACxB,MAAMsB,EAAU,CAACxR,EAAQA,EAAS8xC,EAAa9xC,EAAS8xC,GACxD,IAAKtH,EAAM,OAAOh5B,EAAQ,GAC1B,IAAKtB,EAAW,OAAOkjC,EAAY5hC,GAEnC,OAAO4hC,EADiB5hC,EAAQ6P,QAAOpiB,GAAKspC,GAAStpC,KAAOiR,IAE9D,CAgCA,MALa,CACX29B,WAnBF,SAAoBI,EAAU5mB,GAC5B,MAAMrnB,EAASmzC,EAAa3gC,MAAQy7B,GAC9B,MACJtkC,EACAskC,SAAUsF,GAjCd,SAAwBvzC,GACtB,MAAMiuC,EAAWzD,EAAOF,EAAatqC,GAAUqqC,EAAUrqC,GACnDwzC,EAAkBN,EAAY9nC,KAAIqoC,GAAcA,EAAaxF,IAAU7iC,KAAIsoC,GAAcJ,EAASI,EAAY,KAAItoC,KAAI,CAACoiC,EAAMjrC,KAAM,CACvIirC,OACA7jC,MAAOpH,MACLilB,MAAK,CAACmsB,EAAIr9B,IAAOgyB,GAAQqL,EAAGnG,MAAQlF,GAAQhyB,EAAGk3B,SAC7C,MACJ7jC,GACE6pC,EAAgB,GACpB,MAAO,CACL7pC,QACAskC,WAEJ,CAqBM2F,CAAe5zC,GACb6zC,GAAgBrJ,GAAQJ,EAAWpqC,GACzC,OAAKqnB,GAAQwsB,EAAqB,CAChClqC,QACAskC,YAIK,CACLtkC,QACAskC,SAHmBA,EAAWqF,EADbJ,EAAYvpC,GAAS4pC,EACa,GAKvD,EAGErF,QA5BF,SAAiBvkC,EAAOuG,GAGtB,MAAO,CACLvG,QACAskC,SAHeqF,EADEJ,EAAYvpC,GAASwpC,EAAa3gC,MACftC,GAKxC,EAsBEojC,WAGJ,CAgCA,SAASQ,GAAS1kB,GAChB,IAAIxvB,EAAQwvB,EAaZ,SAAS2kB,EAAeta,GACtB,OAAO2O,GAAS3O,GAAKA,EAAIA,EAAEjnB,KAC7B,CAOA,MANa,CACXA,IAhBF,WACE,OAAO5S,CACT,EAeEZ,IAdF,SAAay6B,GACX75B,EAAQm0C,EAAeta,EACzB,EAaExnB,IAZF,SAAawnB,GACX75B,GAASm0C,EAAeta,EAC1B,EAWEgY,SAVF,SAAkBhY,GAChB75B,GAASm0C,EAAeta,EAC1B,EAWF,CAEA,SAASua,GAAUh3B,EAAM9M,EAAW8Y,GAClC,MAAM5mB,EAA4B,MAAhB4a,EAAK+P,OAGvB,SAAW0M,GACT,MAAO,eAAeA,cACxB,EACA,SAAWA,GACT,MAAO,mBAAmBA,UAC5B,EAPMwa,EAAiBjrB,EAAU9oB,MACjC,IAAImxC,GAAW,EAwBf,MALa,CACXtG,MANF,WACMsG,IACJ4C,EAAe5yC,UAAY,GACtB2nB,EAAU/mB,aAAa,UAAU+mB,EAAU3iB,gBAAgB,SAClE,EAGEsgB,GAdF,SAAY3mB,GACNqxC,IACJ4C,EAAe5yC,UAAYe,EAAU8N,EAAU6I,MAAM/Y,IACvD,EAYE2xC,aAXF,SAAsBC,GACpBP,GAAYO,CACd,EAYF,CAEA,SAASsC,GAAYl3B,EAAM9M,EAAW45B,EAAUgI,EAAaqC,EAAoBjB,EAAakB,EAAcrnB,EAAQijB,GAClH,MAAMqE,EAAW3L,GAAUyL,GACrBG,EAAY5L,GAAUyL,GAAoBrb,UAC1Cyb,EAgCN,WACE,MAAMC,EAAMtB,EAAY,GAAK,EAE7B,OAAOuB,EADSC,EAAYJ,EAAWE,GACR,MACjC,CApCmBG,GAAcznB,OAqCjC,WACE,MAAMsnB,EAAM1K,EAAWoJ,EAAY,GAAK,EAExC,OAAOuB,EADSC,EAAYL,EAAUG,GACP,QACjC,CAzCwCI,IACxC,SAASC,EAAiBC,EAASC,GACjC,OAAOD,EAAQ1L,QAAO,CAAC1nC,EAAGa,IACjBb,EAAIyyC,EAAmB5xC,IAC7BwyC,EACL,CACA,SAASL,EAAYI,EAASN,GAC5B,OAAOM,EAAQ1L,QAAO,CAAC1nC,EAAGa,IACHsyC,EAAiBnzC,EAAG8yC,GACnB,EAAI9yC,EAAEwrB,OAAO,CAAC3qB,IAAMb,GACzC,GACL,CACA,SAAS+yC,EAAeK,EAASxD,GAC/B,MAAM0D,EAAuB,UAAT1D,EACdr7B,EAAS++B,GAAelD,EAAcA,EACtCmD,EAAcb,EAAac,gBAAgB,CAACj/B,IAClD,OAAO6+B,EAAQ1pC,KAAIzB,IACjB,MAAMwrC,EAAUH,EAAc,GAAKlD,EAC7BsD,EAAUJ,EAAclD,EAAc,EAEtCuD,EADSJ,EAAY5zB,QAAO3hB,GAAKA,EAAEiK,QAAUA,IAAO,GACrCqrC,EAAc,MAAQ,SACrC5J,EAAW0I,IAAU,GACrB1xC,EAAY4xC,GAAUh3B,EAAM9M,EAAW8/B,EAAOrmC,IAEpD,MAAO,CACLA,QACAyhC,WACAhpC,YACApC,OALa,IAAM+sB,EAAOva,MAAQ6iC,EAAQF,EAAUC,EAMrD,GAEL,CAyCA,MANa,CACXE,QAzBF,WACE,OAAOf,EAAWzM,OAAM,EACtBn+B,WAGOkrC,EADcR,EAAShzB,QAAO9e,GAAKA,IAAMoH,IACVmgC,IAAa,IAEvD,EAmBEiB,MALF,WACEwJ,EAAWhzC,SAAQg0C,GAAaA,EAAUnzC,UAAU2oC,SACtD,EAIEP,KAnBF,WACE+J,EAAWhzC,SAAQg0C,IACjB,MAAM,OACJv1C,EAAM,UACNoC,EAAS,SACTgpC,GACEmK,EACEC,EAAQx1C,IACVw1C,IAAUpK,EAAS54B,QACvBpQ,EAAUukB,GAAG6uB,GACbpK,EAASpsC,IAAIw2C,GAAM,GAEvB,EAQEjB,aAGJ,CAEA,SAASkB,GAAczsB,EAAWuiB,GAChC,IAAImK,EACAtF,GAAY,EA8BhB,MAJa,CACXn/B,KA1BF,SAAcw9B,EAAUkH,GACjBA,IAULD,EAAmB,IAAIE,kBAAiBC,IAClCzF,IACA/H,GAAUsN,IAAgBA,EAAYlH,EAAUoH,KAXtD,SAAyBA,GACvB,IAAK,MAAMC,KAAYD,EACrB,GAAsB,cAAlBC,EAASzyC,KAAsB,CACjCorC,EAASoC,SACTtF,EAAaiD,KAAK,iBAClB,KACF,CAEJ,CAIIsC,CAAgB+E,EAClB,IAEFH,EAAiBnV,QAAQvX,EAAW,CAClC+sB,WAAW,IAEf,EAOE3G,QANF,WACMsG,GAAkBA,EAAiB3E,aACvCX,GAAY,CACd,EAMF,CAEA,SAAS4F,GAAalM,EAAUgI,EAAa3B,EAAY8F,EAAOhF,EAAOzG,EAAM0L,GAC3E,MAAM,aACJ5L,EAAY,UACZD,GACE4G,EACEkF,EAAiB,GACjBC,EAAgB5L,EAAO,CAAC,EAAGsH,GAAcA,GAAe,CAAC,GACzDuE,EAAenB,EAAgBkB,EAAeF,GAQpD,SAAShB,EAAgBrmB,EAASpH,GAChC,MAAM6uB,EAAeznB,GAAWunB,EAC1BG,EATR,SAA6B9uB,GAC3B,MAAM+uB,EAAiB/uB,GAAa,EACpC,OAAO0oB,EAAW/kC,KAAIqrC,GACGxM,GAAMkM,EAAgBM,EAAYN,GACnC9L,UAAUoM,EAAYD,IAEhD,CAG0BE,CAAoBjvB,GAC5C,OAAO6uB,EAAalN,QAAO,CAACuN,EAAM1gC,KAChC,MAAMrQ,EAASqwC,EAAM7qC,KAAI,CAACic,EAAM1d,KAAU,CACxCX,MAAOqe,EAAO8oB,EAAWxmC,GAAS4sC,EAAgB5sC,GAASsM,EAC3DxP,IAAK4gB,EAAOyiB,EAAWyM,EAAgB5sC,GAASsM,EAChDtM,YAEF,OAAOgtC,EAAKzpB,OAAOtnB,EAAO,GACzB,GACL,CAmBA,MAJa,CACXgxC,MAfF,SAAexL,EAAUxlC,GACvB,MAAMixC,EAAkBrM,EAAOF,EAAac,GAAYf,EAAUe,GAElE,OADoBxlC,GAAUywC,GACXjN,QAAO,CAACuN,EAAMG,KAC/B,MAAM,MACJntC,EAAK,MACLX,EAAK,IACLvC,GACEqwC,EAGJ,OAFeH,EAAK7H,SAASnlC,KACdX,EAAQ6tC,GAAmBpwC,EAAMowC,GACrBF,EAAKzpB,OAAO,CAACvjB,IAAUgtC,CAAI,GACrD,GACL,EAGEzB,kBAGJ,CAuCA,SAAS6B,GAAejN,EAAUqK,EAAoB6C,GACpD,MAAMC,EAAgB7O,GAAS4O,GAiB/B,MAHa,CACXE,YAJF,SAAqBvO,GACnB,OAAOsO,EAXT,SAAkBtO,EAAOwO,GACvB,OAAOzO,GAAUC,GAAOtnB,QAAO9e,GAAKA,EAAI40C,GAAc,IAAG/rC,KAAI7I,GAAKomC,EAAMl6B,MAAMlM,EAAGA,EAAI40C,IACvF,CASyBC,CAASzO,EAAOqO,GARzC,SAAgBrO,GACd,OAAOD,GAAUC,GAAOS,QAAO,CAACiO,EAAY90C,KAC1C,MACM+0C,EADQnD,EAAmB1lC,MAAMq6B,GAAUuO,GAAa90C,EAAI,GAC1C6mC,QAAO,CAAC1nC,EAAGtC,IAAMsC,EAAItC,GAAG,GAChD,OAAQmD,GAAK+0C,EAAYxN,EAAWuN,EAAWnqB,OAAO3qB,GAAK80C,CAAU,GACpE,IAAIjsC,KAAI,CAACpC,EAAOzG,EAAG80C,IAAe1O,EAAMl6B,MAAMzF,EAAOquC,EAAW90C,EAAI,KACzE,CAE2Dg1C,CAAO5O,EAClE,EAKF,CAEA,SAAS6O,GAAOC,EAAMzuB,EAAWgnB,EAAQtyB,EAAegsB,EAAavB,EAASoD,EAAcmM,GAE1F,MAAM,MACJ7N,EACA7sB,KAAM26B,EACNznC,UAAW0nC,EAAgB,WAC3BC,EAAU,gBACV3B,EAAe,KACf1L,EAAI,SACJtjB,EAAQ,SACRukB,EAAQ,cACRC,EACAsL,eAAgBE,EAAW,UAC3BvL,EAAS,cACTqG,GACE7J,EAEE2P,EAAgB9uB,EAAUpC,wBAC1BmxB,EAAa/H,EAAO5kC,KAAI4sC,GAASA,EAAMpxB,0BACvC1W,EA50BR,SAAmBA,GACjB,MAAMs4B,EAAqB,QAAdt4B,GAAuB,EAAI,EAOxC,MAHa,CACX6I,MAJF,SAAe0gB,GACb,OAAOA,EAAI+O,CACb,EAKF,CAm0BoByP,CAAUL,GACtB56B,EA16BR,SAAcA,EAAM9M,GAClB,MAAM6c,EAAkB,MAAT/P,EAAe,IAAM,IA0BpC,MAPa,CACX+P,SACA8e,MApBqB,MAAT7uB,EAAe,IAAM,IAqBjCk7B,UAVe,MAAXnrB,EAAuB,MACN,QAAd7c,EAAsB,QAAU,OAUvCioC,QAPe,MAAXprB,EAAuB,SACN,QAAd7c,EAAsB,OAAS,QAOtCogC,YApBF,SAAqB8H,GACnB,MAAM,MACJtyC,EAAK,OACLC,GACEqyC,EACJ,MAAkB,MAAXrrB,EAAiBjnB,EAAQC,CAClC,EAiBF,CA84BesyC,CAAKV,EAAYC,GACxB9N,EAAW9sB,EAAKszB,YAAYwH,GAC5BtM,EA1oBR,SAAuB1B,GAOrB,MAHa,CACXE,QAJF,SAAiBvQ,GACf,OAAOqQ,GAAYrQ,EAAI,IACzB,EAKF,CAkoBwB6e,CAAcxO,GAC9ByO,EAAY3O,GAAUC,EAAOC,GAC7B0O,GAAgBhO,KAAUwH,EAC1ByG,EAAcjO,KAAUwH,GACxB,WACJ7B,EAAU,mBACVgE,GAtFJ,SAAoBn3B,EAAM86B,EAAeC,EAAY/H,EAAQyI,EAAa/O,GACxE,MAAM,YACJ4G,EAAW,UACX4H,EAAS,QACTC,GACEn7B,EACE07B,EAAcX,EAAW,IAAMU,EAC/BE,EAIN,WACE,IAAKD,EAAa,OAAO,EACzB,MAAME,EAAYb,EAAW,GAC7B,OAAOzP,GAAQwP,EAAcI,GAAaU,EAAUV,GACtD,CARiBW,GACXC,EAQN,WACE,IAAKJ,EAAa,OAAO,EACzB,MAAMx4C,EAAQwpC,EAAY9lC,iBAAiBklC,GAAUkH,IACrD,OAAOroC,WAAWzH,EAAM2D,iBAAiB,UAAUs0C,KACrD,CAZeY,GACT5I,EAAa4H,EAAW3sC,IAAIklC,GAC5B6D,EAYG4D,EAAW3sC,KAAI,CAACgtC,EAAMzuC,EAAOqvC,KAClC,MAAMC,GAAWtvC,EACXuvC,EAASvvC,IAAUo/B,GAAeiQ,GACxC,OAAIC,EAAgB9I,EAAWxmC,GAASgvC,EACpCO,EAAe/I,EAAWxmC,GAASmvC,EAChCE,EAAMrvC,EAAQ,GAAGuuC,GAAaE,EAAKF,EAAU,IACnD9sC,IAAIk9B,IAMT,MAJa,CACX6H,aACAgE,qBAGJ,CAoDMgF,CAAWn8B,EAAM86B,EAAeC,EAAY/H,EAAQyI,EAAa/O,GAC/DsN,EAAiBD,GAAejN,EAAUqK,EAAoB+C,IAC9D,MACJjB,EAAK,aACLlE,GArbJ,SAAqB/0B,EAAMu7B,EAAWT,EAAeC,EAAY5D,EAAoB6C,EAAgBhF,GACnG,MAAM,UACJkG,EAAS,QACTC,GACEn7B,GACE,YACJk6B,GACEF,EACEoC,EAIGlC,EAAYa,GAAY3sC,KAAI4tC,GAASlQ,GAAUkQ,GAAOb,GAAWa,EAAM,GAAGd,KAAY9sC,IAAIk9B,IAJjEl9B,IAAImtC,EAAUvO,SAC1CiM,EAMG8B,EAAW3sC,KAAIgtC,GAAQN,EAAcI,GAAaE,EAAKF,KAAY9sC,KAAIic,IAASihB,GAAQjhB,KAL3F0qB,EAON,WACE,MACMsH,EAAmBvQ,GAAUmN,GAASnN,GAAUqL,GACtD,OAAO+C,EAAYjB,GAAO7qC,KAAIkuC,GAAKA,EAAE,KAAIluC,KAAI,CAACic,EAAM1d,EAAO4vC,KACzD,MAAMN,GAAWtvC,EACXuvC,EAASvvC,IAAUo/B,GAAewQ,GACxC,OAAIvH,GAAiBiH,EALI,EAMrBjH,GAAiBkH,EAAeG,EAC7BhyB,EAAO+xB,EAAWzvC,EAAM,GAEnC,CAjBqB6vC,GAsBrB,MAJa,CACXvD,QACAlE,eAGJ,CAqZM0H,CAAYz8B,EAAMu7B,EAAWT,EAAeC,EAAY5D,EAAoB6C,EAAgBwB,GAC1F1G,GAAehJ,GAAUmN,GAASnN,GAAUqL,IAC5C,eACJ9B,GACER,GAAc/H,EAAUgI,EAAaC,EAAcC,GACjDkB,EAAcsF,EAAenG,EAAiBN,GAC9C,MACJd,GA9eJ,SAAqBa,EAAaoB,EAAa1I,GAC7C,MAAMtyB,EAAMg7B,EAAY,GAMxB,MAHa,CACXjC,MAFYhH,GADFO,EAAOtyB,EAAM45B,EAAchJ,GAAUoK,GACxBh7B,GAK3B,CAueMwhC,CAAY5H,EAAaoB,EAAa1I,GAEpC7gC,EAAQ4gC,GAAQxB,GAAemK,GAAc2E,EAAYrN,GACzDmP,EAAgBhwC,EAAMihC,QACtBgP,EAAelR,GAAUsH,GAsCzBhrB,EAAY,CAChB7M,OAAQ,IArCK,GACb0hC,cACAxO,aACA4G,eACA6H,eACAC,cACAxO,eACAvmB,YACAmjB,SACEqC,YAGF,MAAMyE,EAAc4K,EAAY5K,cAC3BzE,GAAMyH,EAAa5H,UAAU4E,GAClC,MAAM+K,EAAa3O,EAAW7c,OAAOyrB,UACjCD,IAAe/K,IACjBjqB,EAAUk1B,OACV3O,EAAaiD,KAAK,WAEfwL,GACHzO,EAAaiD,KAAK,UAEhBhE,IACFsP,EAAatP,KAAKa,EAAWn7B,aAC7B6pC,EAAYvP,OACd,EAYcryB,CAAOgiC,GACrB5nC,OAAQ6nC,GAXK,GACb/O,aACAjpC,YACAgpC,YACCgP,KACD,MAAM/kB,EAAWgW,EAAWhW,WACtBglB,EAAiBjP,EAAS54B,MAAQ6iB,EAAWA,EAAW+kB,EAC9Dh4C,EAAUukB,GAAG0zB,EAAe,EAIP9nC,CAAO4nC,EAAQC,GACpCpxC,MAAO,IAAM0uC,EAAW1uC,MAAMmxC,GAC9BD,KAAM,IAAMxC,EAAWwC,KAAKC,IAIxBG,EAAgBpH,EAAYvpC,EAAM6I,OAClC44B,EAAW0I,GAASwG,GACpBt6C,EAAS8zC,GAASwG,GAClBjP,EA5pBR,SAAoBD,EAAUprC,EAAQu6C,EAAc3O,GAClD,IAAIoO,GAAa,EACbQ,EAAe,EACfC,EAAkB,EAClBvzB,EAAWqzB,EACXhM,EAAW3C,EAgCf,SAAS+B,EAAYlU,GAEnB,OADAvS,EAAWuS,EACJ3iB,CACT,CACA,SAAS42B,EAAYjU,GAEnB,OADA8U,EAAW9U,EACJ3iB,CACT,CACA,MAAMA,EAAO,CACX5G,UAlBF,WACE,OAAOuqC,CACT,EAiBEjsB,KAzCF,WACE,MAAMgf,EAAOxtC,EAAOwS,MAAQ44B,EAAS54B,MAYrC,OAXmB+7B,GAAarnB,GAK9BszB,GAAgBhN,EAAOtmB,EACvBszB,GAAgBjM,EAChBnD,EAASn5B,IAAIuoC,KALbA,EAAe,EACfpP,EAASpsC,IAAIgB,IAMfy6C,EAAkBlS,GAASiS,GAAgBhN,GAC3CwM,EAAa1R,GAAQkF,GAAQ,KACtB12B,CACT,EA4BEmjC,QA3BF,WAEE,OADID,GAAY5O,EAASpsC,IAAIgB,GACtBg6C,CACT,EAyBEtI,gBAfF,WACE,OAAOhE,EAAY9B,EACrB,EAcE8O,gBAnBF,WACE,OAAO/M,EAAY4M,EACrB,EAkBE7M,cACAC,cACAtY,SA5BF,WACE,OAAOmlB,CACT,GA4BA,OAAO1jC,CACT,CAomBqB6jC,CAAWvP,EAAUprC,EAAQknB,EAJ/B,KAKXokB,EAAe2H,GAAazI,EAAM0I,EAAapB,EAAab,EAAOjxC,GACnEwW,EAlZR,SAAkBwO,EAAW41B,EAAcjB,EAAerO,EAAc6H,EAAc5H,GACpF,SAAS/0B,EAASxW,GAChB,MAAM66C,EAAe76C,EAAOiuC,SACtB6M,EAAY96C,EAAO2J,QAAUixC,EAAapoC,MAC5CqoC,IACF71B,EAAUhc,QACVmqC,EAAalhC,IAAI4oC,IAEfC,IACFnB,EAAc36C,IAAI47C,EAAapoC,OAC/BooC,EAAa57C,IAAIgB,EAAO2J,OACxB4hC,EAAaiD,KAAK,UAEtB,CAcA,MAJa,CACXP,SAVF,SAAkBxU,EAAGpS,GAEnB7Q,EADe80B,EAAauC,WAAWpU,EAAGpS,GAE5C,EAQE1d,MAPF,SAAe8vB,EAAGvpB,GAChB,MAAM6qC,EAAcH,EAAahQ,QAAQ5rC,IAAIy6B,GAE7CjjB,EADe80B,EAAa4C,QAAQ6M,EAAYvoC,MAAOtC,GAEzD,EAMF,CAsXmB8qC,CAASh2B,EAAWrb,EAAOgwC,EAAerO,EAActrC,EAAQurC,GAC3E6I,EAAe4B,GAAalM,EAAUgI,EAAa3B,EAAY8F,EAAOhF,EAAOzG,EAAM0L,GAEnFiE,EAAS,CACbz8B,gBACAgsB,cACA6B,eACAuM,gBACAC,aACA/yB,YACAhI,OACA9M,YACA2pC,YAAa5O,GAAYjuB,EAAM9M,EAAWunC,EAAM/5B,EAAegsB,EAAa1pC,EAAQqvC,GAAYryB,EAAM0sB,GAAc0B,EAAUpmB,EAAWxO,EAAU60B,EAAYC,EAAc3hC,EAAO4hC,EAAcC,EAAeC,EAAUC,EAAeC,EAlB3N,KAmBfsP,WAAYpQ,KACZW,gBACA7hC,QACAgwC,gBACA1I,QACA7F,WACAjD,UACA+S,cAAenL,GAAc/mB,EAAWgnB,EAAQhzB,EAAMuuB,GACtDF,aACA4G,aAAcjB,GAAaC,EAAO7F,EAAUprC,EAAQqrC,EAAYG,GAChEsO,aAAcnH,GAAab,EAAab,EAAO7F,EAAU,CAACA,EAAUprC,IACpEm7C,eAAgBpI,GAAe9B,GAC/BiC,cACA5H,eACA90B,WACAujC,YAAa7F,GAAYl3B,EAAM9M,EAAW45B,EAAUgI,EAAaqC,EAAoBjB,EAAakB,EAAchJ,EAAU4E,GAC1HoL,cAAe3F,GAAczsB,EAAWuiB,GACxC6I,eACAwF,eACA5C,iBACAh3C,SACAoC,UAAW4xC,GAAUh3B,EAAM9M,EAAW8Y,IAExC,OAAOmxB,CACT,CAiFA,MAAMkB,GAAiB,CACrBxR,MAAO,SACP7sB,KAAM,IACNgM,UAAW,KACXgnB,OAAQ,KACRgC,cAAe,KACf9hC,UAAW,MACX8mC,eAAgB,EAChBnP,YAAa,CAAC,EACd4D,UAAU,EACVC,cAAe,GACfwK,gBAAiB,EACjB1L,MAAM,EACNmB,WAAW,EACXzkB,SAAU,GACV2wB,WAAY,EACZjG,QAAQ,EACRlD,WAAW,EACX6B,aAAa,EACboF,aAAa,GAGf,SAAS2F,GAAe5R,GACtB,SAAS6R,EAAajU,EAAUC,GAC9B,OAAO0B,GAAiB3B,EAAUC,GAAY,CAAC,EACjD,CASA,MAAMzwB,EAAO,CACXykC,eACAC,eAVF,SAAwBrT,GACtB,MAAMqT,EAAiBrT,EAAQN,aAAe,CAAC,EACzC4T,EAAsB7S,GAAW4S,GAAgBn6B,QAAO2J,GAAS0e,EAAYjwB,WAAWuR,GAAOtR,UAAStO,KAAI4f,GAASwwB,EAAexwB,KAAQoe,QAAO,CAAC1nC,EAAGg6C,IAAgBH,EAAa75C,EAAGg6C,IAAc,CAAC,GAC5M,OAAOH,EAAapT,EAASsT,EAC/B,EAOEE,oBANF,SAA6BC,GAC3B,OAAOA,EAAYxwC,KAAI+8B,GAAWS,GAAWT,EAAQN,aAAe,CAAC,KAAIuB,QAAO,CAACyS,EAAKC,IAAiBD,EAAI3uB,OAAO4uB,IAAe,IAAI1wC,IAAIs+B,EAAYjwB,WACvJ,GAMA,OAAO3C,CACT,CAuBA,SAASilC,GAActE,EAAMuE,EAAaC,GACxC,MAAMv+B,EAAgB+5B,EAAK/5B,cACrBgsB,EAAchsB,EAAcw+B,YAC5BC,EAAiBb,GAAe5R,GAChC0S,EAzBR,SAAwBD,GACtB,IAAIE,EAAgB,GAiBpB,MAJa,CACXprC,KAbF,SAAci3B,EAASuG,GAKrB,OAJA4N,EAAgBnU,EAAQ7mB,QAAO,EAC7B8mB,cACsD,IAAlDgU,EAAeX,eAAerT,GAASyJ,SAC7CyK,EAAc96C,SAAQgF,GAAUA,EAAO0K,KAAKw9B,EAAU0N,KAC/CjU,EAAQkB,QAAO,CAACh+B,EAAK7E,IAAW4M,OAAOmpC,OAAOlxC,EAAK,CACxD,CAAC7E,EAAOqK,MAAOrK,KACb,CAAC,EACP,EAME6oC,QALF,WACEiN,EAAgBA,EAAch7B,QAAO9a,GAAUA,EAAO6oC,WACxD,EAMF,CAMyBmN,CAAeJ,GAChCK,EAAgB3R,KAChB4R,EAAyB5R,KACzBU,EApGR,WACE,MAAM3P,EAAY,CAAC,EACnB,IAAI8gB,EAIJ,SAASC,EAAalT,GACpB,OAAO7N,EAAU6N,IAAQ,EAC3B,CAaA,MAAM3yB,EAAO,CACX7F,KAnBF,SAAcw9B,GACZiO,EAAMjO,CACR,EAkBED,KAdF,SAAc/E,GAEZ,OADAkT,EAAalT,GAAKloC,SAAQ/B,GAAKA,EAAEk9C,EAAKjT,KAC/B3yB,CACT,EAYE8lC,IAPF,SAAanT,EAAKoT,GAEhB,OADAjhB,EAAU6N,GAAOkT,EAAalT,GAAKpoB,QAAO7hB,GAAKA,IAAMq9C,IAC9C/lC,CACT,EAKEgmC,GAZF,SAAYrT,EAAKoT,GAEf,OADAjhB,EAAU6N,GAAOkT,EAAalT,GAAKvc,OAAO,CAAC2vB,IACpC/lC,CACT,GAWA,OAAOA,CACT,CAwEuBimC,IACf,gBACJC,GACEjB,IACE,aACJR,EAAY,eACZC,EAAc,oBACdG,GACEQ,GACE,GACJW,EAAE,IACFF,EAAG,KACHpO,GACEjD,EACEsF,EAASoM,EACf,IACI9C,EAIA+C,EACAl0B,EACAgnB,EAPAI,GAAY,EAEZ+M,EAAc5B,EAAaF,GAAgBU,GAAcqB,eACzDjV,EAAUoT,EAAa4B,GACvBE,EAAa,GAcjB,SAASC,EAASC,EAAaC,GAC7B,GAAIpN,EAAW,OACf,MAAMqN,EAAiBT,EAAgBU,MAAKh8C,GAAKA,EAAE2C,SAAWqlC,IACxDgO,EAAa+F,GAzLvB,SAAoB/T,GAClB,MAAMiU,EAAW,IAAO,GACxB,IAAIC,EAAU,GACVC,EAAgB,KAChBC,EAAM,EACNC,EAAiB,EACrB,SAASC,EAAQvO,GACVoO,IAAeA,EAAgBpO,GACpC,MAAMwO,EAAUxO,EAAYoO,EAG5B,IAFAA,EAAgBpO,EAChBqO,GAAOG,EACAH,GAAOH,GACZC,EAAQr8C,SAAQ,EACdyjB,eACIA,EAAU7M,WAChB2lC,GAAOH,EAET,MAAMvD,EAAY9R,GAAQwV,EAAMH,GAChCC,EAAQr8C,SAAQ,EACdyjB,eACIA,EAAUzS,OAAO6nC,KACnB2D,GAAgBrU,EAAYjrB,sBAAsBu/B,EACxD,CAwBA,MANa,CACXh1C,MAlBF,SAAemxC,GACRyD,EAAQ9O,SAASqL,IAASyD,EAAQ17C,KAAKi4C,GACxC4D,IACJA,EAAiBrU,EAAYjrB,sBAAsBu/B,GACrD,EAeE9D,KAdF,SAAcC,GACZyD,EAAUA,EAAQv8B,QAAO7hB,GAAKA,IAAM26C,IAChCyD,EAAQp7C,SACZknC,EAAYwU,qBAAqBH,GACjCF,EAAgB,KAChBC,EAAM,EACNC,EAAiB,EACnB,EAQE1lC,MAPF,WACEwlC,EAAgB,KAChBC,EAAM,CACR,EAKEz5C,OAAQqlC,EAGZ,CA0IyCyU,CAAWzU,GAUhD,GATK+T,GAAgBT,EAAgB96C,KAAKw1C,GAC1CyF,EAAc5B,EAAa4B,EAAaI,GACxCpV,EAAUqT,EAAe2B,GACzBE,EAAaG,GAAeH,EAjB9B,WACE,MACEr0B,UAAWo1B,EACXpO,OAAQqO,GACNlW,EACEmW,EAAkBluC,GAASguC,GAAiB3G,EAAKrR,cAAcgY,GAAiBA,EACtFp1B,EAAYs1B,GAAmB7G,EAAKhuB,SAAS,GAC7C,MAAM80B,EAAenuC,GAASiuC,GAAcr1B,EAAUwY,iBAAiB6c,GAAcA,EACrFrO,EAAS,GAAGvhC,MAAMjN,KAAK+8C,GAAgBv1B,EAAUS,SACnD,CASE+0B,GACArE,EAAS3C,GAAOC,EAAMzuB,EAAWgnB,EAAQtyB,EAAegsB,EAAavB,EAASoD,EAAcmM,GAC5FiE,EAAoB,CAACwB,KAAgBE,EAAWjyC,KAAI,EAClD+8B,aACIA,MAAW5mC,SAAQ0pB,GAASuxB,EAAcvqC,IAAIgZ,EAAO,SAAUgyB,KAChE9U,EAAQyJ,OAAb,CAQA,GAPAuI,EAAO/3C,UAAUukB,GAAGwzB,EAAO/O,SAAS54B,OACpC2nC,EAAO5O,aAAat6B,KAAK6F,GACzBqjC,EAAOe,cAAcjqC,KAAK6F,EAAMqxB,EAAQoI,aACxC4J,EAAOiB,cAAcnqC,KAAK6F,EAAMqxB,EAAQwN,aACxC8G,EAAuBxqC,IAAIyL,EAAe,oBAAoB,KACxDA,EAAcqd,QAAQ2c,EAAWr/B,OAAO,IAE1C8vB,EAAQqC,KAAM,CAChB,IAAK2P,EAAOJ,YAAYzE,UAQtB,OAPAmJ,IACAnB,EAAS,CACP9S,MAAM,GACLgT,QACHL,EAAc5B,EAAa4B,EAAa,CACtC3S,MAAM,KAIV2P,EAAOJ,YAAYvP,MACrB,CACIxhB,EAAUjd,cAAgBikC,EAAOxtC,QACnC23C,EAAON,YAAY5oC,KAAK6F,EAAMqxB,EAAQuG,WAExCwO,EAAad,EAAenrC,KAAKosC,EAAYvmC,EAxBlB,CAyB7B,CACA,SAASmmC,EAAWM,EAAaC,GAC/B,MAAM3F,EAAa6G,IACnBD,IACAnB,EAAS/B,EAAa,CACpB1D,cACC0F,GAAcC,GACjBjS,EAAaiD,KAAK,SACpB,CACA,SAASiQ,IACPtE,EAAON,YAAYzK,UACnB+K,EAAOn1B,UAAUk1B,OACjBC,EAAOc,WAAWlQ,QAClBoP,EAAO/3C,UAAU2oC,QACjBoP,EAAOJ,YAAYhP,QACnBoP,EAAOe,cAAc9L,UACrB+K,EAAOiB,cAAchM,UACrBgN,EAAehN,UACfoN,EAAczR,QACd0R,EAAuB1R,OACzB,CAQA,SAASqJ,EAAap0C,GACpB,MAAMorC,EAAW+O,EAAOn6C,EAAS,SAAW,YAAYwS,MAClDnP,EAAO8kC,EAAQqC,KAAO,eAAiB,YAC7C,OAAO2P,EAAO/F,aAAawC,MAAMuD,EAAOlJ,MAAM5tC,GAAM+nC,GACtD,CAKA,SAAS50B,EAAS7M,EAAOg1C,EAAMzuC,GACxBi4B,EAAQyJ,SAAUxB,IACvB+J,EAAO9O,WAAWqG,kBAAkB/D,YAAYgR,EAAO,EAAIxW,EAAQjhB,UACnEizB,EAAO3jC,SAAS7M,MAAMA,EAAOuG,GAAa,GAC5C,CAuBA,SAASwuC,IACP,OAAOvE,EAAOxwC,MAAM6I,KACtB,CAmBA,MAAMsE,EAAO,CACX8nC,cApCF,WAEE,OADazE,EAAOxwC,MAAMsI,IAAI,GAAGO,QACjBksC,GAClB,EAkCEG,cAjCF,WAEE,OADa1E,EAAOxwC,MAAMsI,KAAK,GAAGO,QAClBksC,GAClB,EA+BEI,cATF,WACE,OAAO91B,CACT,EAQE+1B,eAhBF,WACE,OAAO5E,CACT,EAeE/K,QArEF,WACMgB,IACJA,GAAY,EACZoM,EAAczR,QACd0T,IACAlT,EAAaiD,KAAK,WACpB,EAgEEoO,MACAE,KACAtO,OACAtG,QAxBF,WACE,OAAOgV,CACT,EAuBE8B,mBA5BF,WACE,OAAO7E,EAAOR,cAAcnnC,KAC9B,EA2BEq+B,SACA3F,SArBF,WACE,OAAOuM,CACT,EAoBEwH,WAxDF,SAAoBN,GAElBnoC,EADa2jC,EAAOxwC,MAAMsI,IAAI,GAAGO,OACT,IAATmsC,GAAgB,EACjC,EAsDEO,WArDF,SAAoBP,GAElBnoC,EADa2jC,EAAOxwC,MAAMsI,KAAK,GAAGO,OACV,IAATmsC,EAAe,EAChC,EAmDExD,eAvCF,WACE,OAAOhB,EAAOgB,eAAe3oC,IAAI2nC,EAAO/O,SAAS54B,MACnD,EAsCE2sC,eA3CF,WACE,OAAOhF,EAAOjH,YAAY9nC,IAAI+uC,EAAOgB,eAAe3oC,IACtD,EA0CEgE,WACAkoC,qBACAU,WAtBF,WACE,OAAOpP,CACT,EAqBEoE,eACAiL,gBAzEF,SAAyBr/C,GACvB,MAAMs/C,EAASlL,EAAap0C,GAC5B,OAAOm6C,EAAOP,aAAav4B,QAAO1X,IAAU21C,EAAOxQ,SAASnlC,IAC9D,GA0EA,OAFA2zC,EAAStB,EAAaC,GACtBliC,YAAW,IAAMwxB,EAAaiD,KAAK,SAAS,GACrC13B,CACT,CCv7CA,SAASyoC,GAAiBpX,EAAU,CAAC,EAAGD,EAAU,IAChD,MAAMsX,GAAgB,IAAA1e,QAAOqH,GACvBsX,GAAgB,IAAA3e,QAAOoH,IACtBuG,EAAUiR,IAAe,IAAAze,aACzB0e,EAAUC,IAAe,IAAA3e,YAC1B4P,GAAS,IAAAgP,cAAY,KACrBpR,GAAUA,EAASoC,OAAO2O,EAAchwB,QAASiwB,EAAcjwB,QAAQ,GAC1E,CAACif,IAqBJ,OApBA,IAAArN,YAAU,KACR,GFN0B,oBAAX/8B,QAA0BA,OAAOC,UAAYD,OAAOC,SAASd,eEMzDm8C,EAAU,CAC3B5D,GAAcqB,cAAgBmC,GAAiBnC,cAC/C,MAAM0C,EAAc/D,GAAc4D,EAAUH,EAAchwB,QAASiwB,EAAcjwB,SAEjF,OADAkwB,EAAYI,GACL,IAAMA,EAAY1Q,SAC3B,CACEsQ,OAAYK,EACd,GACC,CAACJ,EAAUD,KACd,IAAAte,YAAU,KACJiG,GAAgBmY,EAAchwB,QAAS2Y,KAC3CqX,EAAchwB,QAAU2Y,EACxB0I,IAAQ,GACP,CAAC1I,EAAS0I,KACb,IAAAzP,YAAU,MFAZ,SAAyB4e,EAAUC,GACjC,GAAID,EAASx9C,SAAWy9C,EAASz9C,OAAQ,OAAO,EAChD,MAAM8kC,EAAWW,GAA0B+X,GACrCzY,EAAWU,GAA0BgY,GAC3C,OAAO3Y,EAASQ,OAAM,CAACoY,EAASv2C,IAEvB09B,GAAgB6Y,EADP3Y,EAAS59B,KAG7B,EEPQw2C,CAAgBV,EAAcjwB,QAAS0Y,KAC3CuX,EAAcjwB,QAAU0Y,EACxB2I,IAAQ,GACP,CAAC3I,EAAS2I,IACN,CAAC+O,EAAanR,EACvB,CD25CAsN,GAAciB,gBAAkB,GAChCjB,GAAcqB,mBAAgB2C,EC35C9BR,GAAiBnC,mBAAgB2C,ECzB1B,MAAMK,GAA0Ct+C,IACrD,MAAM,SAAEu+C,EAAQ,QAAEhkC,GAAYva,EAE9B,OACM4gC,EAAAA,cAAA,UACA1M,UAAW,aAAa9I,OAAOmzB,EAAW,wBAA0B,IACpEh9C,KAAK,SACLgZ,QAASA,GACP,EASGikC,GAAgDx+C,IAC3D,MAAM,QAAEsjB,EAAO,QAAE/I,GAAYva,EAE7B,OACM4gC,EAAAA,cAAA,UACI1M,UAAU,oCACV3Z,QAASA,EACTg1B,UAAWjsB,GAEPsd,EAAAA,cAAA,OAAK2B,ICnCrB,inEDmCqCE,IAAI,WAAWvO,UAAU,uBACzC,EAIRuqB,GAAgDz+C,IAC3D,MAAM,QAAEsjB,EAAO,QAAE/I,GAAYva,EAE7B,OACM4gC,EAAAA,cAAA,UACI1M,UAAU,oCACV3Z,QAASA,EACTg1B,UAAWjsB,GAEPsd,EAAAA,cAAA,OAAK2B,IEjDrB,qmEFiDsCE,IAAI,OAAOvO,UAAU,uBACtC,EGmGrB,OAlHgC+lB,KAC9B,MAuBM/L,GArBsB9O,EAAAA,GAAAA,gBAAe,cAqBV0B,UAAUC,MAAM,GAAGC,YAAY0d,YAEzDC,EAAUhS,GAAY8Q,GAzBK,CAAC,IA0B7B,EAACmB,EAAe,EAACC,IAAqB1f,EAAAA,EAAAA,WAAS,IAC/C,EAAC2f,EAAe,EAACC,IAAqB5f,EAAAA,EAAAA,WAAS,IAC/C,EAAC6f,EAAc,EAACC,IAAoB9f,EAAAA,EAAAA,UAAS,IAC7C,EAACiS,EAAY,EAAC8N,IAAkB/f,EAAAA,EAAAA,UAAmB,IAEnDie,GAAaW,EAAAA,EAAAA,cAAY,IAAMpR,aAAQ,EAARA,EAAUyQ,cAAc,CAACzQ,IACxDwQ,GAAaY,EAAAA,EAAAA,cAAY,IAAMpR,aAAQ,EAARA,EAAUwQ,cAAc,CAACxQ,IACxDj4B,GAAWqpC,EAAAA,EAAAA,cACdl2C,GAAkB8kC,aAAQ,EAARA,EAAUj4B,SAAS7M,IACtC,CAAC8kC,IAGGwS,GAASpB,EAAAA,EAAAA,cAAapR,IAC1BuS,EAAevS,EAAS0Q,iBAAiB,GACxC,IAEG+B,GAAWrB,EAAAA,EAAAA,cAAapR,IAC5BsS,EAAiBtS,EAASiQ,sBAC1BiC,EAAkBlS,EAASoQ,iBAC3BgC,EAAkBpS,EAASmQ,gBAAgB,GAC1C,IAmBH,OAjBAxd,EAAAA,EAAAA,YAAU,KACR,GAAKqN,EASL,OAPAwS,EAAOxS,GACPyS,EAASzS,GAETA,EAASqO,GAAG,SAAUmE,GACtBxS,EAASqO,GAAG,SAAUoE,GACtBzS,EAASqO,GAAG,SAAUoE,GAEf,KACLzS,EAASmO,IAAI,SAAUqE,GACvBxS,EAASmO,IAAI,SAAUsE,GACvBzS,EAASmO,IAAI,SAAUsE,EAAS,CACjC,GACA,CAACzS,EAAUwS,EAAQC,IAGpBxe,EAAAA,cAAAA,EAAAA,SAAA,KACEA,EAAAA,cAAA,OAAK1M,UAAU,oBACb0M,EAAAA,cAAA,OAAK1M,UAAU,SACb0M,EAAAA,cAAA,OAAK1M,UAAU,kBAAkB2K,IAAK8f,GACpC/d,EAAAA,cAAA,OAAK1M,UAAU,oBACZga,EAAO5kC,KAAI,CAAC4sC,EAAOruC,IAClB+4B,EAAAA,cAAA,OAAK1M,UAAU,eAAe3iB,IAAK1J,GACjC+4B,EAAAA,cAAA,OAAK1M,UAAU,wBACb0M,EAAAA,cAAA,YAAO/4B,EAAQ,IAEjB+4B,EAAAA,cAAA,eACEA,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQnJ,EAAMoJ,kBAAkB/a,YAElC3D,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQnJ,EAAMqJ,YAAYhb,YAE5B3D,EAAAA,cAAA,OACE2B,IAAK2T,EAAMqJ,YAAYhb,UACvB9B,IAAKyT,EAAMqJ,YAAY/a,QACvBtQ,UAAU,4BAQtB0M,EAAAA,cAAC4d,GAAU,CAACjkC,QAAS6iC,EAAY95B,QAASs7B,IAC1Che,EAAAA,cAAC6d,GAAU,CAAClkC,QAAS4iC,EAAY75B,QAASw7B,KAE5Cle,EAAAA,cAAA,OAAK1M,UAAU,eACZkd,EAAY9nC,KAAI,CAACk2C,EAAG33C,IACnB+4B,EAAAA,cAAC0d,GAAS,CACR/sC,IAAK1J,EACL02C,SAAU12C,IAAUm3C,EACpBzkC,QAASA,IAAM7F,EAAS7M,SAK/B,EC2BP,OAzK0B43C,KACxB,MAAMxiD,GAAOmiC,EAAAA,GAAAA,gBAAe,cAsCtB,OACJsgB,EAAM,QACNze,EAAO,WACP0e,EAAU,oBACVC,EAAmB,yBACnBC,EAAwB,mBACxBC,EAAkB,oBAClBC,GACE9iD,EAAK6jC,UAAUkB,MAAM,GAAG3G,KAAK2F,YAEjC,OACEJ,EAAAA,cAAA,WACEhmB,GAAG,WACHsZ,UAAU,eACV91B,MAAO,CAAEyiC,gBAAiBI,IAE1BL,EAAAA,cAAA,MAAI1M,UAAU,iBAAiByrB,GAC/B/e,EAAAA,cAAA,OAAK1M,UAAU,gBACb0M,EAAAA,cAAA,OAAK1M,UAAU,kBACb0M,EAAAA,cAAA,OAAK1M,UAAU,2BACb0M,EAAAA,cAAA,KAAG+B,KAAMod,EAAqB7rB,UAAU,gBACtC0M,EAAAA,cAAA,OAAK1M,UAAU,YACf0M,EAAAA,cAAA,eACEA,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQQ,EAAyBxd,eAEnCzB,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQO,EAAoBvd,eAE9BzB,EAAAA,cAAA,OACE2B,IAAKqd,EAAoBvd,aACzBI,IAAKmd,EAAoBpb,QACzBtQ,UAAU,4BAGd0M,EAAAA,cAAA,OAAK1M,UAAU,wBACb0M,EAAAA,cAAA,UACEA,EAAAA,cAAA,QACEM,wBAAyB,CAAEC,OAAQ2e,UAO/Clf,EAAAA,cAAA,OAAK1M,UAAU,kBACZwrB,EACE/yC,MAAM,EAAG,GACTrD,KAAI,CAAC02C,EAAYn4C,IAChB+4B,EAAAA,cAAA,OAAK1M,UAAU,0BAA0B3iB,IAAK1J,GAE5C+4B,EAAAA,cAAA,KAAG+B,KAAMqd,EAAMC,YAAa/rB,UAAU,gBACpC0M,EAAAA,cAAA,OAAK1M,UAAU,YACf0M,EAAAA,cAAA,eACEA,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQW,EAAME,iBAAiB7d,eAEjCzB,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQW,EAAMG,YAAY9d,eAE5BzB,EAAAA,cAAA,OACE2B,IAAKyd,EAAMG,YAAY9d,aACvBI,IAAKud,EAAMG,YAAY3b,QACvBtQ,UAAU,8BAGd0M,EAAAA,cAAA,OAAK1M,UAAU,wBACb0M,EAAAA,cAAA,UACEA,EAAAA,cAAA,QACEM,wBAAyB,CACvBC,OAC8B,iBAArB6e,EAAMI,WACTJ,EAAMI,WACN,aASxBxf,EAAAA,cAAA,OAAK1M,UAAU,kBACZwrB,EACE/yC,MAAM,GACNrD,KAAI,CAAC02C,EAAYn4C,IAChB+4B,EAAAA,cAAA,OAAK1M,UAAU,0BAA0B3iB,IAAK1J,GAE5C+4B,EAAAA,cAAA,KAAG+B,KAAMqd,EAAMC,YAAa/rB,UAAU,gBACpC0M,EAAAA,cAAA,OAAK1M,UAAU,YACf0M,EAAAA,cAAA,eACEA,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQW,EAAME,iBAAiB7d,eAEjCzB,EAAAA,cAAA,UACE1X,MAAM,qBACNm2B,OAAQW,EAAMG,YAAY9d,eAE5BzB,EAAAA,cAAA,OACE2B,IAAKyd,EAAMG,YAAY9d,aACvBI,IAAKud,EAAMG,YAAY3b,QACvBtQ,UAAU,8BAGd0M,EAAAA,cAAA,OAAK1M,UAAU,wBACb0M,EAAAA,cAAA,UACEA,EAAAA,cAAA,QACEM,wBAAyB,CACvBC,OAC8B,iBAArB6e,EAAMI,WACTJ,EAAMI,WACN,cAUlB,aC/Hd,OA5BuCC,IAEnCzf,EAAAA,cAAC0f,EAAAA,EAAM,CAACC,kBAAkB,GAExB3f,EAAAA,cAAA,WAAS1M,UAAU,qBACjB0M,EAAAA,cAACqZ,GAAa,OAEhBrZ,EAAAA,cAAA,WAAShmB,GAAG,wBACVgmB,EAAAA,cAAC9B,GAAoB,OAEvB8B,EAAAA,cAAA,eACEA,EAAAA,cAAA,WACEA,EAAAA,cAAC6D,GAAU,QAGf7D,EAAAA,cAAA,eACEA,EAAAA,cAAA,WACEA,EAAAA,cAAC6C,GAAY,QAGjB7C,EAAAA,cAAA,WAAShmB,GAAG,SACVgmB,EAAAA,cAAC6e,GAAO,OAEV7e,EAAAA,cAACkB,GAAgB,OAMhB,MAAM0e,GAAgC5yC,IAAc,IAAA6yC,EAAA,IAAb,KAAExjD,GAAM2Q,EACpD,MAAM,OAAE8yC,GAAWzjD,EACnB,OACE2jC,EAAAA,cAAC+f,GAAAA,EAAG,CACFC,eAAgBF,EAAOG,IAAIC,qBAC3BC,SAAmC,QAA3BN,EAAEC,EAAOG,IAAIG,sBAAc,IAAAP,OAAA,EAAzBA,EAA2BQ,UACrCC,gBAAiBR,EAAOG,IAAIM,SAC5BC,SAAUV,EAAOG,IAAIQ,eACrBC,QAASZ,EAAOG,IAAIU,cACpBC,OAAQd,EAAOG,IAAIY,aACnBC,UAAWhB,EAAOG,IAAI/b,OACtB,sBCrDN,ghDCAA,ihDCAA","sources":["webpack://tanta-web/./node_modules/gsap/CSSPlugin.js","webpack://tanta-web/./node_modules/gsap/index.js","webpack://tanta-web/./node_modules/gsap/Observer.js","webpack://tanta-web/./node_modules/gsap/ScrollTrigger.js","webpack://tanta-web/./src/components/pages/shared/text-animation/index.tsx","webpack://tanta-web/./src/components/pages/home/pizzarita/nuestra-pizarrita.tsx","webpack://tanta-web/./src/components/pages/shared/slider-images-right/index.tsx","webpack://tanta-web/./src/components/pages/shared/slider-images-left/index.tsx","webpack://tanta-web/./src/static/assets/icons/arrow-left-transparent.svg","webpack://tanta-web/./src/static/assets/icons/arrow-right-transparent.svg","webpack://tanta-web/./node_modules/embla-carousel-reactive-utils/embla-carousel-reactive-utils.esm.js","webpack://tanta-web/./node_modules/embla-carousel/embla-carousel.esm.js","webpack://tanta-web/./node_modules/embla-carousel-react/embla-carousel-react.esm.js","webpack://tanta-web/./src/components/pages/shared/EmblaCarouselArrowsDotsButtons.tsx","webpack://tanta-web/./src/static/assets/icons/arrow-left.svg","webpack://tanta-web/./src/static/assets/icons/arrow-right.svg","webpack://tanta-web/./src/components/pages/home/EmblaCarousel.tsx","webpack://tanta-web/./src/components/pages/home/gallery.tsx","webpack://tanta-web/./src/pages/index.tsx","webpack://tanta-web/./src/static/assets/icons/btn-right-white.svg","webpack://tanta-web/./src/static/assets/icons/btn-right.svg","webpack://tanta-web/./src/static/assets/icons/line.svg"],"sourcesContent":["/*!\n * CSSPlugin 3.12.5\n * https://gsap.com\n *\n * Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nimport { gsap, _getProperty, _numExp, _numWithUnitExp, getUnit, _isString, _isUndefined, _renderComplexString, _relExp, _forEachName, _sortPropTweensByPriority, _colorStringFilter, _checkPlugin, _replaceRandom, _plugins, GSCache, PropTween, _config, _ticker, _round, _missingPlugin, _getSetter, _getCache, _colorExp, _parseRelative, _setDefaults, _removeLinkedListItem //for the commented-out className feature.\n} from \"./gsap-core.js\";\n\nvar _win,\n    _doc,\n    _docElement,\n    _pluginInitted,\n    _tempDiv,\n    _tempDivStyler,\n    _recentSetterPlugin,\n    _reverting,\n    _windowExists = function _windowExists() {\n  return typeof window !== \"undefined\";\n},\n    _transformProps = {},\n    _RAD2DEG = 180 / Math.PI,\n    _DEG2RAD = Math.PI / 180,\n    _atan2 = Math.atan2,\n    _bigNum = 1e8,\n    _capsExp = /([A-Z])/g,\n    _horizontalExp = /(left|right|width|margin|padding|x)/i,\n    _complexExp = /[\\s,\\(]\\S/,\n    _propertyAliases = {\n  autoAlpha: \"opacity,visibility\",\n  scale: \"scaleX,scaleY\",\n  alpha: \"opacity\"\n},\n    _renderCSSProp = function _renderCSSProp(ratio, data) {\n  return data.set(data.t, data.p, Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);\n},\n    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {\n  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u, data);\n},\n    _renderCSSPropWithBeginning = function _renderCSSPropWithBeginning(ratio, data) {\n  return data.set(data.t, data.p, ratio ? Math.round((data.s + data.c * ratio) * 10000) / 10000 + data.u : data.b, data);\n},\n    //if units change, we need a way to render the original unit/value when the tween goes all the way back to the beginning (ratio:0)\n_renderRoundedCSSProp = function _renderRoundedCSSProp(ratio, data) {\n  var value = data.s + data.c * ratio;\n  data.set(data.t, data.p, ~~(value + (value < 0 ? -.5 : .5)) + data.u, data);\n},\n    _renderNonTweeningValue = function _renderNonTweeningValue(ratio, data) {\n  return data.set(data.t, data.p, ratio ? data.e : data.b, data);\n},\n    _renderNonTweeningValueOnlyAtEnd = function _renderNonTweeningValueOnlyAtEnd(ratio, data) {\n  return data.set(data.t, data.p, ratio !== 1 ? data.b : data.e, data);\n},\n    _setterCSSStyle = function _setterCSSStyle(target, property, value) {\n  return target.style[property] = value;\n},\n    _setterCSSProp = function _setterCSSProp(target, property, value) {\n  return target.style.setProperty(property, value);\n},\n    _setterTransform = function _setterTransform(target, property, value) {\n  return target._gsap[property] = value;\n},\n    _setterScale = function _setterScale(target, property, value) {\n  return target._gsap.scaleX = target._gsap.scaleY = value;\n},\n    _setterScaleWithRender = function _setterScaleWithRender(target, property, value, data, ratio) {\n  var cache = target._gsap;\n  cache.scaleX = cache.scaleY = value;\n  cache.renderTransform(ratio, cache);\n},\n    _setterTransformWithRender = function _setterTransformWithRender(target, property, value, data, ratio) {\n  var cache = target._gsap;\n  cache[property] = value;\n  cache.renderTransform(ratio, cache);\n},\n    _transformProp = \"transform\",\n    _transformOriginProp = _transformProp + \"Origin\",\n    _saveStyle = function _saveStyle(property, isNotCSS) {\n  var _this = this;\n\n  var target = this.target,\n      style = target.style,\n      cache = target._gsap;\n\n  if (property in _transformProps && style) {\n    this.tfm = this.tfm || {};\n\n    if (property !== \"transform\") {\n      property = _propertyAliases[property] || property;\n      ~property.indexOf(\",\") ? property.split(\",\").forEach(function (a) {\n        return _this.tfm[a] = _get(target, a);\n      }) : this.tfm[property] = cache.x ? cache[property] : _get(target, property); // note: scale would map to \"scaleX,scaleY\", thus we loop and apply them both.\n\n      property === _transformOriginProp && (this.tfm.zOrigin = cache.zOrigin);\n    } else {\n      return _propertyAliases.transform.split(\",\").forEach(function (p) {\n        return _saveStyle.call(_this, p, isNotCSS);\n      });\n    }\n\n    if (this.props.indexOf(_transformProp) >= 0) {\n      return;\n    }\n\n    if (cache.svg) {\n      this.svgo = target.getAttribute(\"data-svg-origin\");\n      this.props.push(_transformOriginProp, isNotCSS, \"\");\n    }\n\n    property = _transformProp;\n  }\n\n  (style || isNotCSS) && this.props.push(property, isNotCSS, style[property]);\n},\n    _removeIndependentTransforms = function _removeIndependentTransforms(style) {\n  if (style.translate) {\n    style.removeProperty(\"translate\");\n    style.removeProperty(\"scale\");\n    style.removeProperty(\"rotate\");\n  }\n},\n    _revertStyle = function _revertStyle() {\n  var props = this.props,\n      target = this.target,\n      style = target.style,\n      cache = target._gsap,\n      i,\n      p;\n\n  for (i = 0; i < props.length; i += 3) {\n    // stored like this: property, isNotCSS, value\n    props[i + 1] ? target[props[i]] = props[i + 2] : props[i + 2] ? style[props[i]] = props[i + 2] : style.removeProperty(props[i].substr(0, 2) === \"--\" ? props[i] : props[i].replace(_capsExp, \"-$1\").toLowerCase());\n  }\n\n  if (this.tfm) {\n    for (p in this.tfm) {\n      cache[p] = this.tfm[p];\n    }\n\n    if (cache.svg) {\n      cache.renderTransform();\n      target.setAttribute(\"data-svg-origin\", this.svgo || \"\");\n    }\n\n    i = _reverting();\n\n    if ((!i || !i.isStart) && !style[_transformProp]) {\n      _removeIndependentTransforms(style);\n\n      if (cache.zOrigin && style[_transformOriginProp]) {\n        style[_transformOriginProp] += \" \" + cache.zOrigin + \"px\"; // since we're uncaching, we must put the zOrigin back into the transformOrigin so that we can pull it out accurately when we parse again. Otherwise, we'd lose the z portion of the origin since we extract it to protect from Safari bugs.\n\n        cache.zOrigin = 0;\n        cache.renderTransform();\n      }\n\n      cache.uncache = 1; // if it's a startAt that's being reverted in the _initTween() of the core, we don't need to uncache transforms. This is purely a performance optimization.\n    }\n  }\n},\n    _getStyleSaver = function _getStyleSaver(target, properties) {\n  var saver = {\n    target: target,\n    props: [],\n    revert: _revertStyle,\n    save: _saveStyle\n  };\n  target._gsap || gsap.core.getCache(target); // just make sure there's a _gsap cache defined because we read from it in _saveStyle() and it's more efficient to just check it here once.\n\n  properties && properties.split(\",\").forEach(function (p) {\n    return saver.save(p);\n  });\n  return saver;\n},\n    _supports3D,\n    _createElement = function _createElement(type, ns) {\n  var e = _doc.createElementNS ? _doc.createElementNS((ns || \"http://www.w3.org/1999/xhtml\").replace(/^https/, \"http\"), type) : _doc.createElement(type); //some servers swap in https for http in the namespace which can break things, making \"style\" inaccessible.\n\n  return e && e.style ? e : _doc.createElement(type); //some environments won't allow access to the element's style when created with a namespace in which case we default to the standard createElement() to work around the issue. Also note that when GSAP is embedded directly inside an SVG file, createElement() won't allow access to the style object in Firefox (see https://gsap.com/forums/topic/20215-problem-using-tweenmax-in-standalone-self-containing-svg-file-err-cannot-set-property-csstext-of-undefined/).\n},\n    _getComputedProperty = function _getComputedProperty(target, property, skipPrefixFallback) {\n  var cs = getComputedStyle(target);\n  return cs[property] || cs.getPropertyValue(property.replace(_capsExp, \"-$1\").toLowerCase()) || cs.getPropertyValue(property) || !skipPrefixFallback && _getComputedProperty(target, _checkPropPrefix(property) || property, 1) || \"\"; //css variables may not need caps swapped out for dashes and lowercase.\n},\n    _prefixes = \"O,Moz,ms,Ms,Webkit\".split(\",\"),\n    _checkPropPrefix = function _checkPropPrefix(property, element, preferPrefix) {\n  var e = element || _tempDiv,\n      s = e.style,\n      i = 5;\n\n  if (property in s && !preferPrefix) {\n    return property;\n  }\n\n  property = property.charAt(0).toUpperCase() + property.substr(1);\n\n  while (i-- && !(_prefixes[i] + property in s)) {}\n\n  return i < 0 ? null : (i === 3 ? \"ms\" : i >= 0 ? _prefixes[i] : \"\") + property;\n},\n    _initCore = function _initCore() {\n  if (_windowExists() && window.document) {\n    _win = window;\n    _doc = _win.document;\n    _docElement = _doc.documentElement;\n    _tempDiv = _createElement(\"div\") || {\n      style: {}\n    };\n    _tempDivStyler = _createElement(\"div\");\n    _transformProp = _checkPropPrefix(_transformProp);\n    _transformOriginProp = _transformProp + \"Origin\";\n    _tempDiv.style.cssText = \"border-width:0;line-height:0;position:absolute;padding:0\"; //make sure to override certain properties that may contaminate measurements, in case the user has overreaching style sheets.\n\n    _supports3D = !!_checkPropPrefix(\"perspective\");\n    _reverting = gsap.core.reverting;\n    _pluginInitted = 1;\n  }\n},\n    _getBBoxHack = function _getBBoxHack(swapIfPossible) {\n  //works around issues in some browsers (like Firefox) that don't correctly report getBBox() on SVG elements inside a <defs> element and/or <mask>. We try creating an SVG, adding it to the documentElement and toss the element in there so that it's definitely part of the rendering tree, then grab the bbox and if it works, we actually swap out the original getBBox() method for our own that does these extra steps whenever getBBox is needed. This helps ensure that performance is optimal (only do all these extra steps when absolutely necessary...most elements don't need it).\n  var svg = _createElement(\"svg\", this.ownerSVGElement && this.ownerSVGElement.getAttribute(\"xmlns\") || \"http://www.w3.org/2000/svg\"),\n      oldParent = this.parentNode,\n      oldSibling = this.nextSibling,\n      oldCSS = this.style.cssText,\n      bbox;\n\n  _docElement.appendChild(svg);\n\n  svg.appendChild(this);\n  this.style.display = \"block\";\n\n  if (swapIfPossible) {\n    try {\n      bbox = this.getBBox();\n      this._gsapBBox = this.getBBox; //store the original\n\n      this.getBBox = _getBBoxHack;\n    } catch (e) {}\n  } else if (this._gsapBBox) {\n    bbox = this._gsapBBox();\n  }\n\n  if (oldParent) {\n    if (oldSibling) {\n      oldParent.insertBefore(this, oldSibling);\n    } else {\n      oldParent.appendChild(this);\n    }\n  }\n\n  _docElement.removeChild(svg);\n\n  this.style.cssText = oldCSS;\n  return bbox;\n},\n    _getAttributeFallbacks = function _getAttributeFallbacks(target, attributesArray) {\n  var i = attributesArray.length;\n\n  while (i--) {\n    if (target.hasAttribute(attributesArray[i])) {\n      return target.getAttribute(attributesArray[i]);\n    }\n  }\n},\n    _getBBox = function _getBBox(target) {\n  var bounds;\n\n  try {\n    bounds = target.getBBox(); //Firefox throws errors if you try calling getBBox() on an SVG element that's not rendered (like in a <symbol> or <defs>). https://bugzilla.mozilla.org/show_bug.cgi?id=612118\n  } catch (error) {\n    bounds = _getBBoxHack.call(target, true);\n  }\n\n  bounds && (bounds.width || bounds.height) || target.getBBox === _getBBoxHack || (bounds = _getBBoxHack.call(target, true)); //some browsers (like Firefox) misreport the bounds if the element has zero width and height (it just assumes it's at x:0, y:0), thus we need to manually grab the position in that case.\n\n  return bounds && !bounds.width && !bounds.x && !bounds.y ? {\n    x: +_getAttributeFallbacks(target, [\"x\", \"cx\", \"x1\"]) || 0,\n    y: +_getAttributeFallbacks(target, [\"y\", \"cy\", \"y1\"]) || 0,\n    width: 0,\n    height: 0\n  } : bounds;\n},\n    _isSVG = function _isSVG(e) {\n  return !!(e.getCTM && (!e.parentNode || e.ownerSVGElement) && _getBBox(e));\n},\n    //reports if the element is an SVG on which getBBox() actually works\n_removeProperty = function _removeProperty(target, property) {\n  if (property) {\n    var style = target.style,\n        first2Chars;\n\n    if (property in _transformProps && property !== _transformOriginProp) {\n      property = _transformProp;\n    }\n\n    if (style.removeProperty) {\n      first2Chars = property.substr(0, 2);\n\n      if (first2Chars === \"ms\" || property.substr(0, 6) === \"webkit\") {\n        //Microsoft and some Webkit browsers don't conform to the standard of capitalizing the first prefix character, so we adjust so that when we prefix the caps with a dash, it's correct (otherwise it'd be \"ms-transform\" instead of \"-ms-transform\" for IE9, for example)\n        property = \"-\" + property;\n      }\n\n      style.removeProperty(first2Chars === \"--\" ? property : property.replace(_capsExp, \"-$1\").toLowerCase());\n    } else {\n      //note: old versions of IE use \"removeAttribute()\" instead of \"removeProperty()\"\n      style.removeAttribute(property);\n    }\n  }\n},\n    _addNonTweeningPT = function _addNonTweeningPT(plugin, target, property, beginning, end, onlySetAtEnd) {\n  var pt = new PropTween(plugin._pt, target, property, 0, 1, onlySetAtEnd ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue);\n  plugin._pt = pt;\n  pt.b = beginning;\n  pt.e = end;\n\n  plugin._props.push(property);\n\n  return pt;\n},\n    _nonConvertibleUnits = {\n  deg: 1,\n  rad: 1,\n  turn: 1\n},\n    _nonStandardLayouts = {\n  grid: 1,\n  flex: 1\n},\n    //takes a single value like 20px and converts it to the unit specified, like \"%\", returning only the numeric amount.\n_convertToUnit = function _convertToUnit(target, property, value, unit) {\n  var curValue = parseFloat(value) || 0,\n      curUnit = (value + \"\").trim().substr((curValue + \"\").length) || \"px\",\n      // some browsers leave extra whitespace at the beginning of CSS variables, hence the need to trim()\n  style = _tempDiv.style,\n      horizontal = _horizontalExp.test(property),\n      isRootSVG = target.tagName.toLowerCase() === \"svg\",\n      measureProperty = (isRootSVG ? \"client\" : \"offset\") + (horizontal ? \"Width\" : \"Height\"),\n      amount = 100,\n      toPixels = unit === \"px\",\n      toPercent = unit === \"%\",\n      px,\n      parent,\n      cache,\n      isSVG;\n\n  if (unit === curUnit || !curValue || _nonConvertibleUnits[unit] || _nonConvertibleUnits[curUnit]) {\n    return curValue;\n  }\n\n  curUnit !== \"px\" && !toPixels && (curValue = _convertToUnit(target, property, value, \"px\"));\n  isSVG = target.getCTM && _isSVG(target);\n\n  if ((toPercent || curUnit === \"%\") && (_transformProps[property] || ~property.indexOf(\"adius\"))) {\n    px = isSVG ? target.getBBox()[horizontal ? \"width\" : \"height\"] : target[measureProperty];\n    return _round(toPercent ? curValue / px * amount : curValue / 100 * px);\n  }\n\n  style[horizontal ? \"width\" : \"height\"] = amount + (toPixels ? curUnit : unit);\n  parent = ~property.indexOf(\"adius\") || unit === \"em\" && target.appendChild && !isRootSVG ? target : target.parentNode;\n\n  if (isSVG) {\n    parent = (target.ownerSVGElement || {}).parentNode;\n  }\n\n  if (!parent || parent === _doc || !parent.appendChild) {\n    parent = _doc.body;\n  }\n\n  cache = parent._gsap;\n\n  if (cache && toPercent && cache.width && horizontal && cache.time === _ticker.time && !cache.uncache) {\n    return _round(curValue / cache.width * amount);\n  } else {\n    if (toPercent && (property === \"height\" || property === \"width\")) {\n      // if we're dealing with width/height that's inside a container with padding and/or it's a flexbox/grid container, we must apply it to the target itself rather than the _tempDiv in order to ensure complete accuracy, factoring in the parent's padding.\n      var v = target.style[property];\n      target.style[property] = amount + unit;\n      px = target[measureProperty];\n      v ? target.style[property] = v : _removeProperty(target, property);\n    } else {\n      (toPercent || curUnit === \"%\") && !_nonStandardLayouts[_getComputedProperty(parent, \"display\")] && (style.position = _getComputedProperty(target, \"position\"));\n      parent === target && (style.position = \"static\"); // like for borderRadius, if it's a % we must have it relative to the target itself but that may not have position: relative or position: absolute in which case it'd go up the chain until it finds its offsetParent (bad). position: static protects against that.\n\n      parent.appendChild(_tempDiv);\n      px = _tempDiv[measureProperty];\n      parent.removeChild(_tempDiv);\n      style.position = \"absolute\";\n    }\n\n    if (horizontal && toPercent) {\n      cache = _getCache(parent);\n      cache.time = _ticker.time;\n      cache.width = parent[measureProperty];\n    }\n  }\n\n  return _round(toPixels ? px * curValue / amount : px && curValue ? amount / px * curValue : 0);\n},\n    _get = function _get(target, property, unit, uncache) {\n  var value;\n  _pluginInitted || _initCore();\n\n  if (property in _propertyAliases && property !== \"transform\") {\n    property = _propertyAliases[property];\n\n    if (~property.indexOf(\",\")) {\n      property = property.split(\",\")[0];\n    }\n  }\n\n  if (_transformProps[property] && property !== \"transform\") {\n    value = _parseTransform(target, uncache);\n    value = property !== \"transformOrigin\" ? value[property] : value.svg ? value.origin : _firstTwoOnly(_getComputedProperty(target, _transformOriginProp)) + \" \" + value.zOrigin + \"px\";\n  } else {\n    value = target.style[property];\n\n    if (!value || value === \"auto\" || uncache || ~(value + \"\").indexOf(\"calc(\")) {\n      value = _specialProps[property] && _specialProps[property](target, property, unit) || _getComputedProperty(target, property) || _getProperty(target, property) || (property === \"opacity\" ? 1 : 0); // note: some browsers, like Firefox, don't report borderRadius correctly! Instead, it only reports every corner like  borderTopLeftRadius\n    }\n  }\n\n  return unit && !~(value + \"\").trim().indexOf(\" \") ? _convertToUnit(target, property, value, unit) + unit : value;\n},\n    _tweenComplexCSSString = function _tweenComplexCSSString(target, prop, start, end) {\n  // note: we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within a plugin too, thus \"this\" would refer to the plugin.\n  if (!start || start === \"none\") {\n    // some browsers like Safari actually PREFER the prefixed property and mis-report the unprefixed value like clipPath (BUG). In other words, even though clipPath exists in the style (\"clipPath\" in target.style) and it's set in the CSS properly (along with -webkit-clip-path), Safari reports clipPath as \"none\" whereas WebkitClipPath reports accurately like \"ellipse(100% 0% at 50% 0%)\", so in this case we must SWITCH to using the prefixed property instead. See https://gsap.com/forums/topic/18310-clippath-doesnt-work-on-ios/\n    var p = _checkPropPrefix(prop, target, 1),\n        s = p && _getComputedProperty(target, p, 1);\n\n    if (s && s !== start) {\n      prop = p;\n      start = s;\n    } else if (prop === \"borderColor\") {\n      start = _getComputedProperty(target, \"borderTopColor\"); // Firefox bug: always reports \"borderColor\" as \"\", so we must fall back to borderTopColor. See https://gsap.com/forums/topic/24583-how-to-return-colors-that-i-had-after-reverse/\n    }\n  }\n\n  var pt = new PropTween(this._pt, target.style, prop, 0, 1, _renderComplexString),\n      index = 0,\n      matchIndex = 0,\n      a,\n      result,\n      startValues,\n      startNum,\n      color,\n      startValue,\n      endValue,\n      endNum,\n      chunk,\n      endUnit,\n      startUnit,\n      endValues;\n  pt.b = start;\n  pt.e = end;\n  start += \"\"; // ensure values are strings\n\n  end += \"\";\n\n  if (end === \"auto\") {\n    startValue = target.style[prop];\n    target.style[prop] = end;\n    end = _getComputedProperty(target, prop) || end;\n    startValue ? target.style[prop] = startValue : _removeProperty(target, prop);\n  }\n\n  a = [start, end];\n\n  _colorStringFilter(a); // pass an array with the starting and ending values and let the filter do whatever it needs to the values. If colors are found, it returns true and then we must match where the color shows up order-wise because for things like boxShadow, sometimes the browser provides the computed values with the color FIRST, but the user provides it with the color LAST, so flip them if necessary. Same for drop-shadow().\n\n\n  start = a[0];\n  end = a[1];\n  startValues = start.match(_numWithUnitExp) || [];\n  endValues = end.match(_numWithUnitExp) || [];\n\n  if (endValues.length) {\n    while (result = _numWithUnitExp.exec(end)) {\n      endValue = result[0];\n      chunk = end.substring(index, result.index);\n\n      if (color) {\n        color = (color + 1) % 5;\n      } else if (chunk.substr(-5) === \"rgba(\" || chunk.substr(-5) === \"hsla(\") {\n        color = 1;\n      }\n\n      if (endValue !== (startValue = startValues[matchIndex++] || \"\")) {\n        startNum = parseFloat(startValue) || 0;\n        startUnit = startValue.substr((startNum + \"\").length);\n        endValue.charAt(1) === \"=\" && (endValue = _parseRelative(startNum, endValue) + startUnit);\n        endNum = parseFloat(endValue);\n        endUnit = endValue.substr((endNum + \"\").length);\n        index = _numWithUnitExp.lastIndex - endUnit.length;\n\n        if (!endUnit) {\n          //if something like \"perspective:300\" is passed in and we must add a unit to the end\n          endUnit = endUnit || _config.units[prop] || startUnit;\n\n          if (index === end.length) {\n            end += endUnit;\n            pt.e += endUnit;\n          }\n        }\n\n        if (startUnit !== endUnit) {\n          startNum = _convertToUnit(target, prop, startValue, endUnit) || 0;\n        } // these nested PropTweens are handled in a special way - we'll never actually call a render or setter method on them. We'll just loop through them in the parent complex string PropTween's render method.\n\n\n        pt._pt = {\n          _next: pt._pt,\n          p: chunk || matchIndex === 1 ? chunk : \",\",\n          //note: SVG spec allows omission of comma/space when a negative sign is wedged between two numbers, like 2.5-5.3 instead of 2.5,-5.3 but when tweening, the negative value may switch to positive, so we insert the comma just in case.\n          s: startNum,\n          c: endNum - startNum,\n          m: color && color < 4 || prop === \"zIndex\" ? Math.round : 0\n        };\n      }\n    }\n\n    pt.c = index < end.length ? end.substring(index, end.length) : \"\"; //we use the \"c\" of the PropTween to store the final part of the string (after the last number)\n  } else {\n    pt.r = prop === \"display\" && end === \"none\" ? _renderNonTweeningValueOnlyAtEnd : _renderNonTweeningValue;\n  }\n\n  _relExp.test(end) && (pt.e = 0); //if the end string contains relative values or dynamic random(...) values, delete the end it so that on the final render we don't actually set it to the string with += or -= characters (forces it to use the calculated value).\n\n  this._pt = pt; //start the linked list with this new PropTween. Remember, we call _tweenComplexCSSString.call(pluginInstance...) to ensure that it's scoped properly. We may call it from within another plugin too, thus \"this\" would refer to the plugin.\n\n  return pt;\n},\n    _keywordToPercent = {\n  top: \"0%\",\n  bottom: \"100%\",\n  left: \"0%\",\n  right: \"100%\",\n  center: \"50%\"\n},\n    _convertKeywordsToPercentages = function _convertKeywordsToPercentages(value) {\n  var split = value.split(\" \"),\n      x = split[0],\n      y = split[1] || \"50%\";\n\n  if (x === \"top\" || x === \"bottom\" || y === \"left\" || y === \"right\") {\n    //the user provided them in the wrong order, so flip them\n    value = x;\n    x = y;\n    y = value;\n  }\n\n  split[0] = _keywordToPercent[x] || x;\n  split[1] = _keywordToPercent[y] || y;\n  return split.join(\" \");\n},\n    _renderClearProps = function _renderClearProps(ratio, data) {\n  if (data.tween && data.tween._time === data.tween._dur) {\n    var target = data.t,\n        style = target.style,\n        props = data.u,\n        cache = target._gsap,\n        prop,\n        clearTransforms,\n        i;\n\n    if (props === \"all\" || props === true) {\n      style.cssText = \"\";\n      clearTransforms = 1;\n    } else {\n      props = props.split(\",\");\n      i = props.length;\n\n      while (--i > -1) {\n        prop = props[i];\n\n        if (_transformProps[prop]) {\n          clearTransforms = 1;\n          prop = prop === \"transformOrigin\" ? _transformOriginProp : _transformProp;\n        }\n\n        _removeProperty(target, prop);\n      }\n    }\n\n    if (clearTransforms) {\n      _removeProperty(target, _transformProp);\n\n      if (cache) {\n        cache.svg && target.removeAttribute(\"transform\");\n\n        _parseTransform(target, 1); // force all the cached values back to \"normal\"/identity, otherwise if there's another tween that's already set to render transforms on this element, it could display the wrong values.\n\n\n        cache.uncache = 1;\n\n        _removeIndependentTransforms(style);\n      }\n    }\n  }\n},\n    // note: specialProps should return 1 if (and only if) they have a non-zero priority. It indicates we need to sort the linked list.\n_specialProps = {\n  clearProps: function clearProps(plugin, target, property, endValue, tween) {\n    if (tween.data !== \"isFromStart\") {\n      var pt = plugin._pt = new PropTween(plugin._pt, target, property, 0, 0, _renderClearProps);\n      pt.u = endValue;\n      pt.pr = -10;\n      pt.tween = tween;\n\n      plugin._props.push(property);\n\n      return 1;\n    }\n  }\n  /* className feature (about 0.4kb gzipped).\n  , className(plugin, target, property, endValue, tween) {\n  \tlet _renderClassName = (ratio, data) => {\n  \t\t\tdata.css.render(ratio, data.css);\n  \t\t\tif (!ratio || ratio === 1) {\n  \t\t\t\tlet inline = data.rmv,\n  \t\t\t\t\ttarget = data.t,\n  \t\t\t\t\tp;\n  \t\t\t\ttarget.setAttribute(\"class\", ratio ? data.e : data.b);\n  \t\t\t\tfor (p in inline) {\n  \t\t\t\t\t_removeProperty(target, p);\n  \t\t\t\t}\n  \t\t\t}\n  \t\t},\n  \t\t_getAllStyles = (target) => {\n  \t\t\tlet styles = {},\n  \t\t\t\tcomputed = getComputedStyle(target),\n  \t\t\t\tp;\n  \t\t\tfor (p in computed) {\n  \t\t\t\tif (isNaN(p) && p !== \"cssText\" && p !== \"length\") {\n  \t\t\t\t\tstyles[p] = computed[p];\n  \t\t\t\t}\n  \t\t\t}\n  \t\t\t_setDefaults(styles, _parseTransform(target, 1));\n  \t\t\treturn styles;\n  \t\t},\n  \t\tstartClassList = target.getAttribute(\"class\"),\n  \t\tstyle = target.style,\n  \t\tcssText = style.cssText,\n  \t\tcache = target._gsap,\n  \t\tclassPT = cache.classPT,\n  \t\tinlineToRemoveAtEnd = {},\n  \t\tdata = {t:target, plugin:plugin, rmv:inlineToRemoveAtEnd, b:startClassList, e:(endValue.charAt(1) !== \"=\") ? endValue : startClassList.replace(new RegExp(\"(?:\\\\s|^)\" + endValue.substr(2) + \"(?![\\\\w-])\"), \"\") + ((endValue.charAt(0) === \"+\") ? \" \" + endValue.substr(2) : \"\")},\n  \t\tchangingVars = {},\n  \t\tstartVars = _getAllStyles(target),\n  \t\ttransformRelated = /(transform|perspective)/i,\n  \t\tendVars, p;\n  \tif (classPT) {\n  \t\tclassPT.r(1, classPT.d);\n  \t\t_removeLinkedListItem(classPT.d.plugin, classPT, \"_pt\");\n  \t}\n  \ttarget.setAttribute(\"class\", data.e);\n  \tendVars = _getAllStyles(target, true);\n  \ttarget.setAttribute(\"class\", startClassList);\n  \tfor (p in endVars) {\n  \t\tif (endVars[p] !== startVars[p] && !transformRelated.test(p)) {\n  \t\t\tchangingVars[p] = endVars[p];\n  \t\t\tif (!style[p] && style[p] !== \"0\") {\n  \t\t\t\tinlineToRemoveAtEnd[p] = 1;\n  \t\t\t}\n  \t\t}\n  \t}\n  \tcache.classPT = plugin._pt = new PropTween(plugin._pt, target, \"className\", 0, 0, _renderClassName, data, 0, -11);\n  \tif (style.cssText !== cssText) { //only apply if things change. Otherwise, in cases like a background-image that's pulled dynamically, it could cause a refresh. See https://gsap.com/forums/topic/20368-possible-gsap-bug-switching-classnames-in-chrome/.\n  \t\tstyle.cssText = cssText; //we recorded cssText before we swapped classes and ran _getAllStyles() because in cases when a className tween is overwritten, we remove all the related tweening properties from that class change (otherwise class-specific stuff can't override properties we've directly set on the target's style object due to specificity).\n  \t}\n  \t_parseTransform(target, true); //to clear the caching of transforms\n  \tdata.css = new gsap.plugins.css();\n  \tdata.css.init(target, changingVars, tween);\n  \tplugin._props.push(...data.css._props);\n  \treturn 1;\n  }\n  */\n\n},\n\n/*\n * --------------------------------------------------------------------------------------\n * TRANSFORMS\n * --------------------------------------------------------------------------------------\n */\n_identity2DMatrix = [1, 0, 0, 1, 0, 0],\n    _rotationalProperties = {},\n    _isNullTransform = function _isNullTransform(value) {\n  return value === \"matrix(1, 0, 0, 1, 0, 0)\" || value === \"none\" || !value;\n},\n    _getComputedTransformMatrixAsArray = function _getComputedTransformMatrixAsArray(target) {\n  var matrixString = _getComputedProperty(target, _transformProp);\n\n  return _isNullTransform(matrixString) ? _identity2DMatrix : matrixString.substr(7).match(_numExp).map(_round);\n},\n    _getMatrix = function _getMatrix(target, force2D) {\n  var cache = target._gsap || _getCache(target),\n      style = target.style,\n      matrix = _getComputedTransformMatrixAsArray(target),\n      parent,\n      nextSibling,\n      temp,\n      addedToDOM;\n\n  if (cache.svg && target.getAttribute(\"transform\")) {\n    temp = target.transform.baseVal.consolidate().matrix; //ensures that even complex values like \"translate(50,60) rotate(135,0,0)\" are parsed because it mashes it into a matrix.\n\n    matrix = [temp.a, temp.b, temp.c, temp.d, temp.e, temp.f];\n    return matrix.join(\",\") === \"1,0,0,1,0,0\" ? _identity2DMatrix : matrix;\n  } else if (matrix === _identity2DMatrix && !target.offsetParent && target !== _docElement && !cache.svg) {\n    //note: if offsetParent is null, that means the element isn't in the normal document flow, like if it has display:none or one of its ancestors has display:none). Firefox returns null for getComputedStyle() if the element is in an iframe that has display:none. https://bugzilla.mozilla.org/show_bug.cgi?id=548397\n    //browsers don't report transforms accurately unless the element is in the DOM and has a display value that's not \"none\". Firefox and Microsoft browsers have a partial bug where they'll report transforms even if display:none BUT not any percentage-based values like translate(-50%, 8px) will be reported as if it's translate(0, 8px).\n    temp = style.display;\n    style.display = \"block\";\n    parent = target.parentNode;\n\n    if (!parent || !target.offsetParent) {\n      // note: in 3.3.0 we switched target.offsetParent to _doc.body.contains(target) to avoid [sometimes unnecessary] MutationObserver calls but that wasn't adequate because there are edge cases where nested position: fixed elements need to get reparented to accurately sense transforms. See https://github.com/greensock/GSAP/issues/388 and https://github.com/greensock/GSAP/issues/375\n      addedToDOM = 1; //flag\n\n      nextSibling = target.nextElementSibling;\n\n      _docElement.appendChild(target); //we must add it to the DOM in order to get values properly\n\n    }\n\n    matrix = _getComputedTransformMatrixAsArray(target);\n    temp ? style.display = temp : _removeProperty(target, \"display\");\n\n    if (addedToDOM) {\n      nextSibling ? parent.insertBefore(target, nextSibling) : parent ? parent.appendChild(target) : _docElement.removeChild(target);\n    }\n  }\n\n  return force2D && matrix.length > 6 ? [matrix[0], matrix[1], matrix[4], matrix[5], matrix[12], matrix[13]] : matrix;\n},\n    _applySVGOrigin = function _applySVGOrigin(target, origin, originIsAbsolute, smooth, matrixArray, pluginToAddPropTweensTo) {\n  var cache = target._gsap,\n      matrix = matrixArray || _getMatrix(target, true),\n      xOriginOld = cache.xOrigin || 0,\n      yOriginOld = cache.yOrigin || 0,\n      xOffsetOld = cache.xOffset || 0,\n      yOffsetOld = cache.yOffset || 0,\n      a = matrix[0],\n      b = matrix[1],\n      c = matrix[2],\n      d = matrix[3],\n      tx = matrix[4],\n      ty = matrix[5],\n      originSplit = origin.split(\" \"),\n      xOrigin = parseFloat(originSplit[0]) || 0,\n      yOrigin = parseFloat(originSplit[1]) || 0,\n      bounds,\n      determinant,\n      x,\n      y;\n\n  if (!originIsAbsolute) {\n    bounds = _getBBox(target);\n    xOrigin = bounds.x + (~originSplit[0].indexOf(\"%\") ? xOrigin / 100 * bounds.width : xOrigin);\n    yOrigin = bounds.y + (~(originSplit[1] || originSplit[0]).indexOf(\"%\") ? yOrigin / 100 * bounds.height : yOrigin); // if (!(\"xOrigin\" in cache) && (xOrigin || yOrigin)) { // added in 3.12.3, reverted in 3.12.4; requires more exploration\n    // \txOrigin -= bounds.x;\n    // \tyOrigin -= bounds.y;\n    // }\n  } else if (matrix !== _identity2DMatrix && (determinant = a * d - b * c)) {\n    //if it's zero (like if scaleX and scaleY are zero), skip it to avoid errors with dividing by zero.\n    x = xOrigin * (d / determinant) + yOrigin * (-c / determinant) + (c * ty - d * tx) / determinant;\n    y = xOrigin * (-b / determinant) + yOrigin * (a / determinant) - (a * ty - b * tx) / determinant;\n    xOrigin = x;\n    yOrigin = y; // theory: we only had to do this for smoothing and it assumes that the previous one was not originIsAbsolute.\n  }\n\n  if (smooth || smooth !== false && cache.smooth) {\n    tx = xOrigin - xOriginOld;\n    ty = yOrigin - yOriginOld;\n    cache.xOffset = xOffsetOld + (tx * a + ty * c) - tx;\n    cache.yOffset = yOffsetOld + (tx * b + ty * d) - ty;\n  } else {\n    cache.xOffset = cache.yOffset = 0;\n  }\n\n  cache.xOrigin = xOrigin;\n  cache.yOrigin = yOrigin;\n  cache.smooth = !!smooth;\n  cache.origin = origin;\n  cache.originIsAbsolute = !!originIsAbsolute;\n  target.style[_transformOriginProp] = \"0px 0px\"; //otherwise, if someone sets  an origin via CSS, it will likely interfere with the SVG transform attribute ones (because remember, we're baking the origin into the matrix() value).\n\n  if (pluginToAddPropTweensTo) {\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"xOrigin\", xOriginOld, xOrigin);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"yOrigin\", yOriginOld, yOrigin);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"xOffset\", xOffsetOld, cache.xOffset);\n\n    _addNonTweeningPT(pluginToAddPropTweensTo, cache, \"yOffset\", yOffsetOld, cache.yOffset);\n  }\n\n  target.setAttribute(\"data-svg-origin\", xOrigin + \" \" + yOrigin);\n},\n    _parseTransform = function _parseTransform(target, uncache) {\n  var cache = target._gsap || new GSCache(target);\n\n  if (\"x\" in cache && !uncache && !cache.uncache) {\n    return cache;\n  }\n\n  var style = target.style,\n      invertedScaleX = cache.scaleX < 0,\n      px = \"px\",\n      deg = \"deg\",\n      cs = getComputedStyle(target),\n      origin = _getComputedProperty(target, _transformOriginProp) || \"0\",\n      x,\n      y,\n      z,\n      scaleX,\n      scaleY,\n      rotation,\n      rotationX,\n      rotationY,\n      skewX,\n      skewY,\n      perspective,\n      xOrigin,\n      yOrigin,\n      matrix,\n      angle,\n      cos,\n      sin,\n      a,\n      b,\n      c,\n      d,\n      a12,\n      a22,\n      t1,\n      t2,\n      t3,\n      a13,\n      a23,\n      a33,\n      a42,\n      a43,\n      a32;\n  x = y = z = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;\n  scaleX = scaleY = 1;\n  cache.svg = !!(target.getCTM && _isSVG(target));\n\n  if (cs.translate) {\n    // accommodate independent transforms by combining them into normal ones.\n    if (cs.translate !== \"none\" || cs.scale !== \"none\" || cs.rotate !== \"none\") {\n      style[_transformProp] = (cs.translate !== \"none\" ? \"translate3d(\" + (cs.translate + \" 0 0\").split(\" \").slice(0, 3).join(\", \") + \") \" : \"\") + (cs.rotate !== \"none\" ? \"rotate(\" + cs.rotate + \") \" : \"\") + (cs.scale !== \"none\" ? \"scale(\" + cs.scale.split(\" \").join(\",\") + \") \" : \"\") + (cs[_transformProp] !== \"none\" ? cs[_transformProp] : \"\");\n    }\n\n    style.scale = style.rotate = style.translate = \"none\";\n  }\n\n  matrix = _getMatrix(target, cache.svg);\n\n  if (cache.svg) {\n    if (cache.uncache) {\n      // if cache.uncache is true (and maybe if origin is 0,0), we need to set element.style.transformOrigin = (cache.xOrigin - bbox.x) + \"px \" + (cache.yOrigin - bbox.y) + \"px\". Previously we let the data-svg-origin stay instead, but when introducing revert(), it complicated things.\n      t2 = target.getBBox();\n      origin = cache.xOrigin - t2.x + \"px \" + (cache.yOrigin - t2.y) + \"px\";\n      t1 = \"\";\n    } else {\n      t1 = !uncache && target.getAttribute(\"data-svg-origin\"); //  Remember, to work around browser inconsistencies we always force SVG elements' transformOrigin to 0,0 and offset the translation accordingly.\n    }\n\n    _applySVGOrigin(target, t1 || origin, !!t1 || cache.originIsAbsolute, cache.smooth !== false, matrix);\n  }\n\n  xOrigin = cache.xOrigin || 0;\n  yOrigin = cache.yOrigin || 0;\n\n  if (matrix !== _identity2DMatrix) {\n    a = matrix[0]; //a11\n\n    b = matrix[1]; //a21\n\n    c = matrix[2]; //a31\n\n    d = matrix[3]; //a41\n\n    x = a12 = matrix[4];\n    y = a22 = matrix[5]; //2D matrix\n\n    if (matrix.length === 6) {\n      scaleX = Math.sqrt(a * a + b * b);\n      scaleY = Math.sqrt(d * d + c * c);\n      rotation = a || b ? _atan2(b, a) * _RAD2DEG : 0; //note: if scaleX is 0, we cannot accurately measure rotation. Same for skewX with a scaleY of 0. Therefore, we default to the previously recorded value (or zero if that doesn't exist).\n\n      skewX = c || d ? _atan2(c, d) * _RAD2DEG + rotation : 0;\n      skewX && (scaleY *= Math.abs(Math.cos(skewX * _DEG2RAD)));\n\n      if (cache.svg) {\n        x -= xOrigin - (xOrigin * a + yOrigin * c);\n        y -= yOrigin - (xOrigin * b + yOrigin * d);\n      } //3D matrix\n\n    } else {\n      a32 = matrix[6];\n      a42 = matrix[7];\n      a13 = matrix[8];\n      a23 = matrix[9];\n      a33 = matrix[10];\n      a43 = matrix[11];\n      x = matrix[12];\n      y = matrix[13];\n      z = matrix[14];\n      angle = _atan2(a32, a33);\n      rotationX = angle * _RAD2DEG; //rotationX\n\n      if (angle) {\n        cos = Math.cos(-angle);\n        sin = Math.sin(-angle);\n        t1 = a12 * cos + a13 * sin;\n        t2 = a22 * cos + a23 * sin;\n        t3 = a32 * cos + a33 * sin;\n        a13 = a12 * -sin + a13 * cos;\n        a23 = a22 * -sin + a23 * cos;\n        a33 = a32 * -sin + a33 * cos;\n        a43 = a42 * -sin + a43 * cos;\n        a12 = t1;\n        a22 = t2;\n        a32 = t3;\n      } //rotationY\n\n\n      angle = _atan2(-c, a33);\n      rotationY = angle * _RAD2DEG;\n\n      if (angle) {\n        cos = Math.cos(-angle);\n        sin = Math.sin(-angle);\n        t1 = a * cos - a13 * sin;\n        t2 = b * cos - a23 * sin;\n        t3 = c * cos - a33 * sin;\n        a43 = d * sin + a43 * cos;\n        a = t1;\n        b = t2;\n        c = t3;\n      } //rotationZ\n\n\n      angle = _atan2(b, a);\n      rotation = angle * _RAD2DEG;\n\n      if (angle) {\n        cos = Math.cos(angle);\n        sin = Math.sin(angle);\n        t1 = a * cos + b * sin;\n        t2 = a12 * cos + a22 * sin;\n        b = b * cos - a * sin;\n        a22 = a22 * cos - a12 * sin;\n        a = t1;\n        a12 = t2;\n      }\n\n      if (rotationX && Math.abs(rotationX) + Math.abs(rotation) > 359.9) {\n        //when rotationY is set, it will often be parsed as 180 degrees different than it should be, and rotationX and rotation both being 180 (it looks the same), so we adjust for that here.\n        rotationX = rotation = 0;\n        rotationY = 180 - rotationY;\n      }\n\n      scaleX = _round(Math.sqrt(a * a + b * b + c * c));\n      scaleY = _round(Math.sqrt(a22 * a22 + a32 * a32));\n      angle = _atan2(a12, a22);\n      skewX = Math.abs(angle) > 0.0002 ? angle * _RAD2DEG : 0;\n      perspective = a43 ? 1 / (a43 < 0 ? -a43 : a43) : 0;\n    }\n\n    if (cache.svg) {\n      //sense if there are CSS transforms applied on an SVG element in which case we must overwrite them when rendering. The transform attribute is more reliable cross-browser, but we can't just remove the CSS ones because they may be applied in a CSS rule somewhere (not just inline).\n      t1 = target.getAttribute(\"transform\");\n      cache.forceCSS = target.setAttribute(\"transform\", \"\") || !_isNullTransform(_getComputedProperty(target, _transformProp));\n      t1 && target.setAttribute(\"transform\", t1);\n    }\n  }\n\n  if (Math.abs(skewX) > 90 && Math.abs(skewX) < 270) {\n    if (invertedScaleX) {\n      scaleX *= -1;\n      skewX += rotation <= 0 ? 180 : -180;\n      rotation += rotation <= 0 ? 180 : -180;\n    } else {\n      scaleY *= -1;\n      skewX += skewX <= 0 ? 180 : -180;\n    }\n  }\n\n  uncache = uncache || cache.uncache;\n  cache.x = x - ((cache.xPercent = x && (!uncache && cache.xPercent || (Math.round(target.offsetWidth / 2) === Math.round(-x) ? -50 : 0))) ? target.offsetWidth * cache.xPercent / 100 : 0) + px;\n  cache.y = y - ((cache.yPercent = y && (!uncache && cache.yPercent || (Math.round(target.offsetHeight / 2) === Math.round(-y) ? -50 : 0))) ? target.offsetHeight * cache.yPercent / 100 : 0) + px;\n  cache.z = z + px;\n  cache.scaleX = _round(scaleX);\n  cache.scaleY = _round(scaleY);\n  cache.rotation = _round(rotation) + deg;\n  cache.rotationX = _round(rotationX) + deg;\n  cache.rotationY = _round(rotationY) + deg;\n  cache.skewX = skewX + deg;\n  cache.skewY = skewY + deg;\n  cache.transformPerspective = perspective + px;\n\n  if (cache.zOrigin = parseFloat(origin.split(\" \")[2]) || !uncache && cache.zOrigin || 0) {\n    style[_transformOriginProp] = _firstTwoOnly(origin);\n  }\n\n  cache.xOffset = cache.yOffset = 0;\n  cache.force3D = _config.force3D;\n  cache.renderTransform = cache.svg ? _renderSVGTransforms : _supports3D ? _renderCSSTransforms : _renderNon3DTransforms;\n  cache.uncache = 0;\n  return cache;\n},\n    _firstTwoOnly = function _firstTwoOnly(value) {\n  return (value = value.split(\" \"))[0] + \" \" + value[1];\n},\n    //for handling transformOrigin values, stripping out the 3rd dimension\n_addPxTranslate = function _addPxTranslate(target, start, value) {\n  var unit = getUnit(start);\n  return _round(parseFloat(start) + parseFloat(_convertToUnit(target, \"x\", value + \"px\", unit))) + unit;\n},\n    _renderNon3DTransforms = function _renderNon3DTransforms(ratio, cache) {\n  cache.z = \"0px\";\n  cache.rotationY = cache.rotationX = \"0deg\";\n  cache.force3D = 0;\n\n  _renderCSSTransforms(ratio, cache);\n},\n    _zeroDeg = \"0deg\",\n    _zeroPx = \"0px\",\n    _endParenthesis = \") \",\n    _renderCSSTransforms = function _renderCSSTransforms(ratio, cache) {\n  var _ref = cache || this,\n      xPercent = _ref.xPercent,\n      yPercent = _ref.yPercent,\n      x = _ref.x,\n      y = _ref.y,\n      z = _ref.z,\n      rotation = _ref.rotation,\n      rotationY = _ref.rotationY,\n      rotationX = _ref.rotationX,\n      skewX = _ref.skewX,\n      skewY = _ref.skewY,\n      scaleX = _ref.scaleX,\n      scaleY = _ref.scaleY,\n      transformPerspective = _ref.transformPerspective,\n      force3D = _ref.force3D,\n      target = _ref.target,\n      zOrigin = _ref.zOrigin,\n      transforms = \"\",\n      use3D = force3D === \"auto\" && ratio && ratio !== 1 || force3D === true; // Safari has a bug that causes it not to render 3D transform-origin values properly, so we force the z origin to 0, record it in the cache, and then do the math here to offset the translate values accordingly (basically do the 3D transform-origin part manually)\n\n\n  if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {\n    var angle = parseFloat(rotationY) * _DEG2RAD,\n        a13 = Math.sin(angle),\n        a33 = Math.cos(angle),\n        cos;\n\n    angle = parseFloat(rotationX) * _DEG2RAD;\n    cos = Math.cos(angle);\n    x = _addPxTranslate(target, x, a13 * cos * -zOrigin);\n    y = _addPxTranslate(target, y, -Math.sin(angle) * -zOrigin);\n    z = _addPxTranslate(target, z, a33 * cos * -zOrigin + zOrigin);\n  }\n\n  if (transformPerspective !== _zeroPx) {\n    transforms += \"perspective(\" + transformPerspective + _endParenthesis;\n  }\n\n  if (xPercent || yPercent) {\n    transforms += \"translate(\" + xPercent + \"%, \" + yPercent + \"%) \";\n  }\n\n  if (use3D || x !== _zeroPx || y !== _zeroPx || z !== _zeroPx) {\n    transforms += z !== _zeroPx || use3D ? \"translate3d(\" + x + \", \" + y + \", \" + z + \") \" : \"translate(\" + x + \", \" + y + _endParenthesis;\n  }\n\n  if (rotation !== _zeroDeg) {\n    transforms += \"rotate(\" + rotation + _endParenthesis;\n  }\n\n  if (rotationY !== _zeroDeg) {\n    transforms += \"rotateY(\" + rotationY + _endParenthesis;\n  }\n\n  if (rotationX !== _zeroDeg) {\n    transforms += \"rotateX(\" + rotationX + _endParenthesis;\n  }\n\n  if (skewX !== _zeroDeg || skewY !== _zeroDeg) {\n    transforms += \"skew(\" + skewX + \", \" + skewY + _endParenthesis;\n  }\n\n  if (scaleX !== 1 || scaleY !== 1) {\n    transforms += \"scale(\" + scaleX + \", \" + scaleY + _endParenthesis;\n  }\n\n  target.style[_transformProp] = transforms || \"translate(0, 0)\";\n},\n    _renderSVGTransforms = function _renderSVGTransforms(ratio, cache) {\n  var _ref2 = cache || this,\n      xPercent = _ref2.xPercent,\n      yPercent = _ref2.yPercent,\n      x = _ref2.x,\n      y = _ref2.y,\n      rotation = _ref2.rotation,\n      skewX = _ref2.skewX,\n      skewY = _ref2.skewY,\n      scaleX = _ref2.scaleX,\n      scaleY = _ref2.scaleY,\n      target = _ref2.target,\n      xOrigin = _ref2.xOrigin,\n      yOrigin = _ref2.yOrigin,\n      xOffset = _ref2.xOffset,\n      yOffset = _ref2.yOffset,\n      forceCSS = _ref2.forceCSS,\n      tx = parseFloat(x),\n      ty = parseFloat(y),\n      a11,\n      a21,\n      a12,\n      a22,\n      temp;\n\n  rotation = parseFloat(rotation);\n  skewX = parseFloat(skewX);\n  skewY = parseFloat(skewY);\n\n  if (skewY) {\n    //for performance reasons, we combine all skewing into the skewX and rotation values. Remember, a skewY of 10 degrees looks the same as a rotation of 10 degrees plus a skewX of 10 degrees.\n    skewY = parseFloat(skewY);\n    skewX += skewY;\n    rotation += skewY;\n  }\n\n  if (rotation || skewX) {\n    rotation *= _DEG2RAD;\n    skewX *= _DEG2RAD;\n    a11 = Math.cos(rotation) * scaleX;\n    a21 = Math.sin(rotation) * scaleX;\n    a12 = Math.sin(rotation - skewX) * -scaleY;\n    a22 = Math.cos(rotation - skewX) * scaleY;\n\n    if (skewX) {\n      skewY *= _DEG2RAD;\n      temp = Math.tan(skewX - skewY);\n      temp = Math.sqrt(1 + temp * temp);\n      a12 *= temp;\n      a22 *= temp;\n\n      if (skewY) {\n        temp = Math.tan(skewY);\n        temp = Math.sqrt(1 + temp * temp);\n        a11 *= temp;\n        a21 *= temp;\n      }\n    }\n\n    a11 = _round(a11);\n    a21 = _round(a21);\n    a12 = _round(a12);\n    a22 = _round(a22);\n  } else {\n    a11 = scaleX;\n    a22 = scaleY;\n    a21 = a12 = 0;\n  }\n\n  if (tx && !~(x + \"\").indexOf(\"px\") || ty && !~(y + \"\").indexOf(\"px\")) {\n    tx = _convertToUnit(target, \"x\", x, \"px\");\n    ty = _convertToUnit(target, \"y\", y, \"px\");\n  }\n\n  if (xOrigin || yOrigin || xOffset || yOffset) {\n    tx = _round(tx + xOrigin - (xOrigin * a11 + yOrigin * a12) + xOffset);\n    ty = _round(ty + yOrigin - (xOrigin * a21 + yOrigin * a22) + yOffset);\n  }\n\n  if (xPercent || yPercent) {\n    //The SVG spec doesn't support percentage-based translation in the \"transform\" attribute, so we merge it into the translation to simulate it.\n    temp = target.getBBox();\n    tx = _round(tx + xPercent / 100 * temp.width);\n    ty = _round(ty + yPercent / 100 * temp.height);\n  }\n\n  temp = \"matrix(\" + a11 + \",\" + a21 + \",\" + a12 + \",\" + a22 + \",\" + tx + \",\" + ty + \")\";\n  target.setAttribute(\"transform\", temp);\n  forceCSS && (target.style[_transformProp] = temp); //some browsers prioritize CSS transforms over the transform attribute. When we sense that the user has CSS transforms applied, we must overwrite them this way (otherwise some browser simply won't render the transform attribute changes!)\n},\n    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue) {\n  var cap = 360,\n      isString = _isString(endValue),\n      endNum = parseFloat(endValue) * (isString && ~endValue.indexOf(\"rad\") ? _RAD2DEG : 1),\n      change = endNum - startNum,\n      finalValue = startNum + change + \"deg\",\n      direction,\n      pt;\n\n  if (isString) {\n    direction = endValue.split(\"_\")[1];\n\n    if (direction === \"short\") {\n      change %= cap;\n\n      if (change !== change % (cap / 2)) {\n        change += change < 0 ? cap : -cap;\n      }\n    }\n\n    if (direction === \"cw\" && change < 0) {\n      change = (change + cap * _bigNum) % cap - ~~(change / cap) * cap;\n    } else if (direction === \"ccw\" && change > 0) {\n      change = (change - cap * _bigNum) % cap - ~~(change / cap) * cap;\n    }\n  }\n\n  plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);\n  pt.e = finalValue;\n  pt.u = \"deg\";\n\n  plugin._props.push(property);\n\n  return pt;\n},\n    _assign = function _assign(target, source) {\n  // Internet Explorer doesn't have Object.assign(), so we recreate it here.\n  for (var p in source) {\n    target[p] = source[p];\n  }\n\n  return target;\n},\n    _addRawTransformPTs = function _addRawTransformPTs(plugin, transforms, target) {\n  //for handling cases where someone passes in a whole transform string, like transform: \"scale(2, 3) rotate(20deg) translateY(30em)\"\n  var startCache = _assign({}, target._gsap),\n      exclude = \"perspective,force3D,transformOrigin,svgOrigin\",\n      style = target.style,\n      endCache,\n      p,\n      startValue,\n      endValue,\n      startNum,\n      endNum,\n      startUnit,\n      endUnit;\n\n  if (startCache.svg) {\n    startValue = target.getAttribute(\"transform\");\n    target.setAttribute(\"transform\", \"\");\n    style[_transformProp] = transforms;\n    endCache = _parseTransform(target, 1);\n\n    _removeProperty(target, _transformProp);\n\n    target.setAttribute(\"transform\", startValue);\n  } else {\n    startValue = getComputedStyle(target)[_transformProp];\n    style[_transformProp] = transforms;\n    endCache = _parseTransform(target, 1);\n    style[_transformProp] = startValue;\n  }\n\n  for (p in _transformProps) {\n    startValue = startCache[p];\n    endValue = endCache[p];\n\n    if (startValue !== endValue && exclude.indexOf(p) < 0) {\n      //tweening to no perspective gives very unintuitive results - just keep the same perspective in that case.\n      startUnit = getUnit(startValue);\n      endUnit = getUnit(endValue);\n      startNum = startUnit !== endUnit ? _convertToUnit(target, p, startValue, endUnit) : parseFloat(startValue);\n      endNum = parseFloat(endValue);\n      plugin._pt = new PropTween(plugin._pt, endCache, p, startNum, endNum - startNum, _renderCSSProp);\n      plugin._pt.u = endUnit || 0;\n\n      plugin._props.push(p);\n    }\n  }\n\n  _assign(endCache, startCache);\n}; // handle splitting apart padding, margin, borderWidth, and borderRadius into their 4 components. Firefox, for example, won't report borderRadius correctly - it will only do borderTopLeftRadius and the other corners. We also want to handle paddingTop, marginLeft, borderRightWidth, etc.\n\n\n_forEachName(\"padding,margin,Width,Radius\", function (name, index) {\n  var t = \"Top\",\n      r = \"Right\",\n      b = \"Bottom\",\n      l = \"Left\",\n      props = (index < 3 ? [t, r, b, l] : [t + l, t + r, b + r, b + l]).map(function (side) {\n    return index < 2 ? name + side : \"border\" + side + name;\n  });\n\n  _specialProps[index > 1 ? \"border\" + name : name] = function (plugin, target, property, endValue, tween) {\n    var a, vars;\n\n    if (arguments.length < 4) {\n      // getter, passed target, property, and unit (from _get())\n      a = props.map(function (prop) {\n        return _get(plugin, prop, property);\n      });\n      vars = a.join(\" \");\n      return vars.split(a[0]).length === 5 ? a[0] : vars;\n    }\n\n    a = (endValue + \"\").split(\" \");\n    vars = {};\n    props.forEach(function (prop, i) {\n      return vars[prop] = a[i] = a[i] || a[(i - 1) / 2 | 0];\n    });\n    plugin.init(target, vars, tween);\n  };\n});\n\nexport var CSSPlugin = {\n  name: \"css\",\n  register: _initCore,\n  targetTest: function targetTest(target) {\n    return target.style && target.nodeType;\n  },\n  init: function init(target, vars, tween, index, targets) {\n    var props = this._props,\n        style = target.style,\n        startAt = tween.vars.startAt,\n        startValue,\n        endValue,\n        endNum,\n        startNum,\n        type,\n        specialProp,\n        p,\n        startUnit,\n        endUnit,\n        relative,\n        isTransformRelated,\n        transformPropTween,\n        cache,\n        smooth,\n        hasPriority,\n        inlineProps;\n    _pluginInitted || _initCore(); // we may call init() multiple times on the same plugin instance, like when adding special properties, so make sure we don't overwrite the revert data or inlineProps\n\n    this.styles = this.styles || _getStyleSaver(target);\n    inlineProps = this.styles.props;\n    this.tween = tween;\n\n    for (p in vars) {\n      if (p === \"autoRound\") {\n        continue;\n      }\n\n      endValue = vars[p];\n\n      if (_plugins[p] && _checkPlugin(p, vars, tween, index, target, targets)) {\n        // plugins\n        continue;\n      }\n\n      type = typeof endValue;\n      specialProp = _specialProps[p];\n\n      if (type === \"function\") {\n        endValue = endValue.call(tween, index, target, targets);\n        type = typeof endValue;\n      }\n\n      if (type === \"string\" && ~endValue.indexOf(\"random(\")) {\n        endValue = _replaceRandom(endValue);\n      }\n\n      if (specialProp) {\n        specialProp(this, target, p, endValue, tween) && (hasPriority = 1);\n      } else if (p.substr(0, 2) === \"--\") {\n        //CSS variable\n        startValue = (getComputedStyle(target).getPropertyValue(p) + \"\").trim();\n        endValue += \"\";\n        _colorExp.lastIndex = 0;\n\n        if (!_colorExp.test(startValue)) {\n          // colors don't have units\n          startUnit = getUnit(startValue);\n          endUnit = getUnit(endValue);\n        }\n\n        endUnit ? startUnit !== endUnit && (startValue = _convertToUnit(target, p, startValue, endUnit) + endUnit) : startUnit && (endValue += startUnit);\n        this.add(style, \"setProperty\", startValue, endValue, index, targets, 0, 0, p);\n        props.push(p);\n        inlineProps.push(p, 0, style[p]);\n      } else if (type !== \"undefined\") {\n        if (startAt && p in startAt) {\n          // in case someone hard-codes a complex value as the start, like top: \"calc(2vh / 2)\". Without this, it'd use the computed value (always in px)\n          startValue = typeof startAt[p] === \"function\" ? startAt[p].call(tween, index, target, targets) : startAt[p];\n          _isString(startValue) && ~startValue.indexOf(\"random(\") && (startValue = _replaceRandom(startValue));\n          getUnit(startValue + \"\") || startValue === \"auto\" || (startValue += _config.units[p] || getUnit(_get(target, p)) || \"\"); // for cases when someone passes in a unitless value like {x: 100}; if we try setting translate(100, 0px) it won't work.\n\n          (startValue + \"\").charAt(1) === \"=\" && (startValue = _get(target, p)); // can't work with relative values\n        } else {\n          startValue = _get(target, p);\n        }\n\n        startNum = parseFloat(startValue);\n        relative = type === \"string\" && endValue.charAt(1) === \"=\" && endValue.substr(0, 2);\n        relative && (endValue = endValue.substr(2));\n        endNum = parseFloat(endValue);\n\n        if (p in _propertyAliases) {\n          if (p === \"autoAlpha\") {\n            //special case where we control the visibility along with opacity. We still allow the opacity value to pass through and get tweened.\n            if (startNum === 1 && _get(target, \"visibility\") === \"hidden\" && endNum) {\n              //if visibility is initially set to \"hidden\", we should interpret that as intent to make opacity 0 (a convenience)\n              startNum = 0;\n            }\n\n            inlineProps.push(\"visibility\", 0, style.visibility);\n\n            _addNonTweeningPT(this, style, \"visibility\", startNum ? \"inherit\" : \"hidden\", endNum ? \"inherit\" : \"hidden\", !endNum);\n          }\n\n          if (p !== \"scale\" && p !== \"transform\") {\n            p = _propertyAliases[p];\n            ~p.indexOf(\",\") && (p = p.split(\",\")[0]);\n          }\n        }\n\n        isTransformRelated = p in _transformProps; //--- TRANSFORM-RELATED ---\n\n        if (isTransformRelated) {\n          this.styles.save(p);\n\n          if (!transformPropTween) {\n            cache = target._gsap;\n            cache.renderTransform && !vars.parseTransform || _parseTransform(target, vars.parseTransform); // if, for example, gsap.set(... {transform:\"translateX(50vw)\"}), the _get() call doesn't parse the transform, thus cache.renderTransform won't be set yet so force the parsing of the transform here.\n\n            smooth = vars.smoothOrigin !== false && cache.smooth;\n            transformPropTween = this._pt = new PropTween(this._pt, style, _transformProp, 0, 1, cache.renderTransform, cache, 0, -1); //the first time through, create the rendering PropTween so that it runs LAST (in the linked list, we keep adding to the beginning)\n\n            transformPropTween.dep = 1; //flag it as dependent so that if things get killed/overwritten and this is the only PropTween left, we can safely kill the whole tween.\n          }\n\n          if (p === \"scale\") {\n            this._pt = new PropTween(this._pt, cache, \"scaleY\", cache.scaleY, (relative ? _parseRelative(cache.scaleY, relative + endNum) : endNum) - cache.scaleY || 0, _renderCSSProp);\n            this._pt.u = 0;\n            props.push(\"scaleY\", p);\n            p += \"X\";\n          } else if (p === \"transformOrigin\") {\n            inlineProps.push(_transformOriginProp, 0, style[_transformOriginProp]);\n            endValue = _convertKeywordsToPercentages(endValue); //in case something like \"left top\" or \"bottom right\" is passed in. Convert to percentages.\n\n            if (cache.svg) {\n              _applySVGOrigin(target, endValue, 0, smooth, 0, this);\n            } else {\n              endUnit = parseFloat(endValue.split(\" \")[2]) || 0; //handle the zOrigin separately!\n\n              endUnit !== cache.zOrigin && _addNonTweeningPT(this, cache, \"zOrigin\", cache.zOrigin, endUnit);\n\n              _addNonTweeningPT(this, style, p, _firstTwoOnly(startValue), _firstTwoOnly(endValue));\n            }\n\n            continue;\n          } else if (p === \"svgOrigin\") {\n            _applySVGOrigin(target, endValue, 1, smooth, 0, this);\n\n            continue;\n          } else if (p in _rotationalProperties) {\n            _addRotationalPropTween(this, cache, p, startNum, relative ? _parseRelative(startNum, relative + endValue) : endValue);\n\n            continue;\n          } else if (p === \"smoothOrigin\") {\n            _addNonTweeningPT(this, cache, \"smooth\", cache.smooth, endValue);\n\n            continue;\n          } else if (p === \"force3D\") {\n            cache[p] = endValue;\n            continue;\n          } else if (p === \"transform\") {\n            _addRawTransformPTs(this, endValue, target);\n\n            continue;\n          }\n        } else if (!(p in style)) {\n          p = _checkPropPrefix(p) || p;\n        }\n\n        if (isTransformRelated || (endNum || endNum === 0) && (startNum || startNum === 0) && !_complexExp.test(endValue) && p in style) {\n          startUnit = (startValue + \"\").substr((startNum + \"\").length);\n          endNum || (endNum = 0); // protect against NaN\n\n          endUnit = getUnit(endValue) || (p in _config.units ? _config.units[p] : startUnit);\n          startUnit !== endUnit && (startNum = _convertToUnit(target, p, startValue, endUnit));\n          this._pt = new PropTween(this._pt, isTransformRelated ? cache : style, p, startNum, (relative ? _parseRelative(startNum, relative + endNum) : endNum) - startNum, !isTransformRelated && (endUnit === \"px\" || p === \"zIndex\") && vars.autoRound !== false ? _renderRoundedCSSProp : _renderCSSProp);\n          this._pt.u = endUnit || 0;\n\n          if (startUnit !== endUnit && endUnit !== \"%\") {\n            //when the tween goes all the way back to the beginning, we need to revert it to the OLD/ORIGINAL value (with those units). We record that as a \"b\" (beginning) property and point to a render method that handles that. (performance optimization)\n            this._pt.b = startValue;\n            this._pt.r = _renderCSSPropWithBeginning;\n          }\n        } else if (!(p in style)) {\n          if (p in target) {\n            //maybe it's not a style - it could be a property added directly to an element in which case we'll try to animate that.\n            this.add(target, p, startValue || target[p], relative ? relative + endValue : endValue, index, targets);\n          } else if (p !== \"parseTransform\") {\n            _missingPlugin(p, endValue);\n\n            continue;\n          }\n        } else {\n          _tweenComplexCSSString.call(this, target, p, startValue, relative ? relative + endValue : endValue);\n        }\n\n        isTransformRelated || (p in style ? inlineProps.push(p, 0, style[p]) : inlineProps.push(p, 1, startValue || target[p]));\n        props.push(p);\n      }\n    }\n\n    hasPriority && _sortPropTweensByPriority(this);\n  },\n  render: function render(ratio, data) {\n    if (data.tween._time || !_reverting()) {\n      var pt = data._pt;\n\n      while (pt) {\n        pt.r(ratio, pt.d);\n        pt = pt._next;\n      }\n    } else {\n      data.styles.revert();\n    }\n  },\n  get: _get,\n  aliases: _propertyAliases,\n  getSetter: function getSetter(target, property, plugin) {\n    //returns a setter function that accepts target, property, value and applies it accordingly. Remember, properties like \"x\" aren't as simple as target.style.property = value because they've got to be applied to a proxy object and then merged into a transform string in a renderer.\n    var p = _propertyAliases[property];\n    p && p.indexOf(\",\") < 0 && (property = p);\n    return property in _transformProps && property !== _transformOriginProp && (target._gsap.x || _get(target, \"x\")) ? plugin && _recentSetterPlugin === plugin ? property === \"scale\" ? _setterScale : _setterTransform : (_recentSetterPlugin = plugin || {}) && (property === \"scale\" ? _setterScaleWithRender : _setterTransformWithRender) : target.style && !_isUndefined(target.style[property]) ? _setterCSSStyle : ~property.indexOf(\"-\") ? _setterCSSProp : _getSetter(target, property);\n  },\n  core: {\n    _removeProperty: _removeProperty,\n    _getMatrix: _getMatrix\n  }\n};\ngsap.utils.checkPrefix = _checkPropPrefix;\ngsap.core.getStyleSaver = _getStyleSaver;\n\n(function (positionAndScale, rotation, others, aliases) {\n  var all = _forEachName(positionAndScale + \",\" + rotation + \",\" + others, function (name) {\n    _transformProps[name] = 1;\n  });\n\n  _forEachName(rotation, function (name) {\n    _config.units[name] = \"deg\";\n    _rotationalProperties[name] = 1;\n  });\n\n  _propertyAliases[all[13]] = positionAndScale + \",\" + rotation;\n\n  _forEachName(aliases, function (name) {\n    var split = name.split(\":\");\n    _propertyAliases[split[1]] = all[split[0]];\n  });\n})(\"x,y,z,scale,scaleX,scaleY,xPercent,yPercent\", \"rotation,rotationX,rotationY,skewX,skewY\", \"transform,transformOrigin,svgOrigin,force3D,smoothOrigin,transformPerspective\", \"0:translateX,1:translateY,2:translateZ,8:rotate,8:rotationZ,8:rotateZ,9:rotateX,10:rotateY\");\n\n_forEachName(\"x,y,z,top,right,bottom,left,width,height,fontSize,padding,margin,perspective\", function (name) {\n  _config.units[name] = \"px\";\n});\n\ngsap.registerPlugin(CSSPlugin);\nexport { CSSPlugin as default, _getBBox, _createElement, _checkPropPrefix as checkPrefix };","import { gsap, Power0, Power1, Power2, Power3, Power4, Linear, Quad, Cubic, Quart, Quint, Strong, Elastic, Back, SteppedEase, Bounce, Sine, Expo, Circ, TweenLite, TimelineLite, TimelineMax } from \"./gsap-core.js\";\nimport { CSSPlugin } from \"./CSSPlugin.js\";\nvar gsapWithCSS = gsap.registerPlugin(CSSPlugin) || gsap,\n    // to protect from tree shaking\nTweenMaxWithCSS = gsapWithCSS.core.Tween;\nexport { gsapWithCSS as gsap, gsapWithCSS as default, CSSPlugin, TweenMaxWithCSS as TweenMax, TweenLite, TimelineMax, TimelineLite, Power0, Power1, Power2, Power3, Power4, Linear, Quad, Cubic, Quart, Quint, Strong, Elastic, Back, SteppedEase, Bounce, Sine, Expo, Circ };","function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if (\"value\" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }\n\nfunction _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }\n\n/*!\n * Observer 3.12.5\n * https://gsap.com\n *\n * @license Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nvar gsap,\n    _coreInitted,\n    _clamp,\n    _win,\n    _doc,\n    _docEl,\n    _body,\n    _isTouch,\n    _pointerType,\n    ScrollTrigger,\n    _root,\n    _normalizer,\n    _eventTypes,\n    _context,\n    _getGSAP = function _getGSAP() {\n  return gsap || typeof window !== \"undefined\" && (gsap = window.gsap) && gsap.registerPlugin && gsap;\n},\n    _startup = 1,\n    _observers = [],\n    _scrollers = [],\n    _proxies = [],\n    _getTime = Date.now,\n    _bridge = function _bridge(name, value) {\n  return value;\n},\n    _integrate = function _integrate() {\n  var core = ScrollTrigger.core,\n      data = core.bridge || {},\n      scrollers = core._scrollers,\n      proxies = core._proxies;\n  scrollers.push.apply(scrollers, _scrollers);\n  proxies.push.apply(proxies, _proxies);\n  _scrollers = scrollers;\n  _proxies = proxies;\n\n  _bridge = function _bridge(name, value) {\n    return data[name](value);\n  };\n},\n    _getProxyProp = function _getProxyProp(element, property) {\n  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];\n},\n    _isViewport = function _isViewport(el) {\n  return !!~_root.indexOf(el);\n},\n    _addListener = function _addListener(element, type, func, passive, capture) {\n  return element.addEventListener(type, func, {\n    passive: passive !== false,\n    capture: !!capture\n  });\n},\n    _removeListener = function _removeListener(element, type, func, capture) {\n  return element.removeEventListener(type, func, !!capture);\n},\n    _scrollLeft = \"scrollLeft\",\n    _scrollTop = \"scrollTop\",\n    _onScroll = function _onScroll() {\n  return _normalizer && _normalizer.isPressed || _scrollers.cache++;\n},\n    _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {\n  var cachingFunc = function cachingFunc(value) {\n    // since reading the scrollTop/scrollLeft/pageOffsetY/pageOffsetX can trigger a layout, this function allows us to cache the value so it only gets read fresh after a \"scroll\" event fires (or while we're refreshing because that can lengthen the page and alter the scroll position). when \"soft\" is true, that means don't actually set the scroll, but cache the new value instead (useful in ScrollSmoother)\n    if (value || value === 0) {\n      _startup && (_win.history.scrollRestoration = \"manual\"); // otherwise the new position will get overwritten by the browser onload.\n\n      var isNormalizing = _normalizer && _normalizer.isPressed;\n      value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); //TODO: iOS Bug: if you allow it to go to 0, Safari can start to report super strange (wildly inaccurate) touch positions!\n\n      f(value);\n      cachingFunc.cacheID = _scrollers.cache;\n      isNormalizing && _bridge(\"ss\", value); // set scroll (notify ScrollTrigger so it can dispatch a \"scrollStart\" event if necessary\n    } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge(\"ref\")) {\n      cachingFunc.cacheID = _scrollers.cache;\n      cachingFunc.v = f();\n    }\n\n    return cachingFunc.v + cachingFunc.offset;\n  };\n\n  cachingFunc.offset = 0;\n  return f && cachingFunc;\n},\n    _horizontal = {\n  s: _scrollLeft,\n  p: \"left\",\n  p2: \"Left\",\n  os: \"right\",\n  os2: \"Right\",\n  d: \"width\",\n  d2: \"Width\",\n  a: \"x\",\n  sc: _scrollCacheFunc(function (value) {\n    return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;\n  })\n},\n    _vertical = {\n  s: _scrollTop,\n  p: \"top\",\n  p2: \"Top\",\n  os: \"bottom\",\n  os2: \"Bottom\",\n  d: \"height\",\n  d2: \"Height\",\n  a: \"y\",\n  op: _horizontal,\n  sc: _scrollCacheFunc(function (value) {\n    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;\n  })\n},\n    _getTarget = function _getTarget(t, self) {\n  return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === \"string\" && gsap.config().nullTargetWarn !== false ? console.warn(\"Element not found:\", t) : null);\n},\n    _getScrollFunc = function _getScrollFunc(element, _ref) {\n  var s = _ref.s,\n      sc = _ref.sc;\n  // we store the scroller functions in an alternating sequenced Array like [element, verticalScrollFunc, horizontalScrollFunc, ...] so that we can minimize memory, maximize performance, and we also record the last position as a \".rec\" property in order to revert to that after refreshing to ensure things don't shift around.\n  _isViewport(element) && (element = _doc.scrollingElement || _docEl);\n\n  var i = _scrollers.indexOf(element),\n      offset = sc === _vertical.sc ? 1 : 2;\n\n  !~i && (i = _scrollers.push(element) - 1);\n  _scrollers[i + offset] || _addListener(element, \"scroll\", _onScroll); // clear the cache when a scroll occurs\n\n  var prev = _scrollers[i + offset],\n      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {\n    return arguments.length ? element[s] = value : element[s];\n  })));\n  func.target = element;\n  prev || (func.smooth = gsap.getProperty(element, \"scrollBehavior\") === \"smooth\"); // only set it the first time (don't reset every time a scrollFunc is requested because perhaps it happens during a refresh() when it's disabled in ScrollTrigger.\n\n  return func;\n},\n    _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {\n  var v1 = value,\n      v2 = value,\n      t1 = _getTime(),\n      t2 = t1,\n      min = minTimeRefresh || 50,\n      dropToZeroTime = Math.max(500, min * 3),\n      update = function update(value, force) {\n    var t = _getTime();\n\n    if (force || t - t1 > min) {\n      v2 = v1;\n      v1 = value;\n      t2 = t1;\n      t1 = t;\n    } else if (useDelta) {\n      v1 += value;\n    } else {\n      // not totally necessary, but makes it a bit more accurate by adjusting the v1 value according to the new slope. This way we're not just ignoring the incoming data. Removing for now because it doesn't seem to make much practical difference and it's probably not worth the kb.\n      v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);\n    }\n  },\n      reset = function reset() {\n    v2 = v1 = useDelta ? 0 : v1;\n    t2 = t1 = 0;\n  },\n      getVelocity = function getVelocity(latestValue) {\n    var tOld = t2,\n        vOld = v2,\n        t = _getTime();\n\n    (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);\n    return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;\n  };\n\n  return {\n    update: update,\n    reset: reset,\n    getVelocity: getVelocity\n  };\n},\n    _getEvent = function _getEvent(e, preventDefault) {\n  preventDefault && !e._gsapAllow && e.preventDefault();\n  return e.changedTouches ? e.changedTouches[0] : e;\n},\n    _getAbsoluteMax = function _getAbsoluteMax(a) {\n  var max = Math.max.apply(Math, a),\n      min = Math.min.apply(Math, a);\n  return Math.abs(max) >= Math.abs(min) ? max : min;\n},\n    _setScrollTrigger = function _setScrollTrigger() {\n  ScrollTrigger = gsap.core.globals().ScrollTrigger;\n  ScrollTrigger && ScrollTrigger.core && _integrate();\n},\n    _initCore = function _initCore(core) {\n  gsap = core || _getGSAP();\n\n  if (!_coreInitted && gsap && typeof document !== \"undefined\" && document.body) {\n    _win = window;\n    _doc = document;\n    _docEl = _doc.documentElement;\n    _body = _doc.body;\n    _root = [_win, _doc, _docEl, _body];\n    _clamp = gsap.utils.clamp;\n\n    _context = gsap.core.context || function () {};\n\n    _pointerType = \"onpointerenter\" in _body ? \"pointer\" : \"mouse\"; // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.\n\n    _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia(\"(hover: none), (pointer: coarse)\").matches ? 1 : \"ontouchstart\" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;\n    _eventTypes = Observer.eventTypes = (\"ontouchstart\" in _docEl ? \"touchstart,touchmove,touchcancel,touchend\" : !(\"onpointerdown\" in _docEl) ? \"mousedown,mousemove,mouseup,mouseup\" : \"pointerdown,pointermove,pointercancel,pointerup\").split(\",\");\n    setTimeout(function () {\n      return _startup = 0;\n    }, 500);\n\n    _setScrollTrigger();\n\n    _coreInitted = 1;\n  }\n\n  return _coreInitted;\n};\n\n_horizontal.op = _vertical;\n_scrollers.cache = 0;\nexport var Observer = /*#__PURE__*/function () {\n  function Observer(vars) {\n    this.init(vars);\n  }\n\n  var _proto = Observer.prototype;\n\n  _proto.init = function init(vars) {\n    _coreInitted || _initCore(gsap) || console.warn(\"Please gsap.registerPlugin(Observer)\");\n    ScrollTrigger || _setScrollTrigger();\n    var tolerance = vars.tolerance,\n        dragMinimum = vars.dragMinimum,\n        type = vars.type,\n        target = vars.target,\n        lineHeight = vars.lineHeight,\n        debounce = vars.debounce,\n        preventDefault = vars.preventDefault,\n        onStop = vars.onStop,\n        onStopDelay = vars.onStopDelay,\n        ignore = vars.ignore,\n        wheelSpeed = vars.wheelSpeed,\n        event = vars.event,\n        onDragStart = vars.onDragStart,\n        onDragEnd = vars.onDragEnd,\n        onDrag = vars.onDrag,\n        onPress = vars.onPress,\n        onRelease = vars.onRelease,\n        onRight = vars.onRight,\n        onLeft = vars.onLeft,\n        onUp = vars.onUp,\n        onDown = vars.onDown,\n        onChangeX = vars.onChangeX,\n        onChangeY = vars.onChangeY,\n        onChange = vars.onChange,\n        onToggleX = vars.onToggleX,\n        onToggleY = vars.onToggleY,\n        onHover = vars.onHover,\n        onHoverEnd = vars.onHoverEnd,\n        onMove = vars.onMove,\n        ignoreCheck = vars.ignoreCheck,\n        isNormalizer = vars.isNormalizer,\n        onGestureStart = vars.onGestureStart,\n        onGestureEnd = vars.onGestureEnd,\n        onWheel = vars.onWheel,\n        onEnable = vars.onEnable,\n        onDisable = vars.onDisable,\n        onClick = vars.onClick,\n        scrollSpeed = vars.scrollSpeed,\n        capture = vars.capture,\n        allowClicks = vars.allowClicks,\n        lockAxis = vars.lockAxis,\n        onLockAxis = vars.onLockAxis;\n    this.target = target = _getTarget(target) || _docEl;\n    this.vars = vars;\n    ignore && (ignore = gsap.utils.toArray(ignore));\n    tolerance = tolerance || 1e-9;\n    dragMinimum = dragMinimum || 0;\n    wheelSpeed = wheelSpeed || 1;\n    scrollSpeed = scrollSpeed || 1;\n    type = type || \"wheel,touch,pointer\";\n    debounce = debounce !== false;\n    lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); // note: browser may report \"normal\", so default to 22.\n\n    var id,\n        onStopDelayedCall,\n        dragged,\n        moved,\n        wheeled,\n        locked,\n        axis,\n        self = this,\n        prevDeltaX = 0,\n        prevDeltaY = 0,\n        passive = vars.passive || !preventDefault,\n        scrollFuncX = _getScrollFunc(target, _horizontal),\n        scrollFuncY = _getScrollFunc(target, _vertical),\n        scrollX = scrollFuncX(),\n        scrollY = scrollFuncY(),\n        limitToTouch = ~type.indexOf(\"touch\") && !~type.indexOf(\"pointer\") && _eventTypes[0] === \"pointerdown\",\n        // for devices that accommodate mouse events and touch events, we need to distinguish.\n    isViewport = _isViewport(target),\n        ownerDoc = target.ownerDocument || _doc,\n        deltaX = [0, 0, 0],\n        // wheel, scroll, pointer/touch\n    deltaY = [0, 0, 0],\n        onClickTime = 0,\n        clickCapture = function clickCapture() {\n      return onClickTime = _getTime();\n    },\n        _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {\n      return (self.event = e) && ignore && ~ignore.indexOf(e.target) || isPointerOrTouch && limitToTouch && e.pointerType !== \"touch\" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);\n    },\n        onStopFunc = function onStopFunc() {\n      self._vx.reset();\n\n      self._vy.reset();\n\n      onStopDelayedCall.pause();\n      onStop && onStop(self);\n    },\n        update = function update() {\n      var dx = self.deltaX = _getAbsoluteMax(deltaX),\n          dy = self.deltaY = _getAbsoluteMax(deltaY),\n          changedX = Math.abs(dx) >= tolerance,\n          changedY = Math.abs(dy) >= tolerance;\n\n      onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); // in ScrollTrigger.normalizeScroll(), we need to know if it was touch/pointer so we need access to the deltaX/deltaY Arrays before we clear them out.\n\n      if (changedX) {\n        onRight && self.deltaX > 0 && onRight(self);\n        onLeft && self.deltaX < 0 && onLeft(self);\n        onChangeX && onChangeX(self);\n        onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);\n        prevDeltaX = self.deltaX;\n        deltaX[0] = deltaX[1] = deltaX[2] = 0;\n      }\n\n      if (changedY) {\n        onDown && self.deltaY > 0 && onDown(self);\n        onUp && self.deltaY < 0 && onUp(self);\n        onChangeY && onChangeY(self);\n        onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);\n        prevDeltaY = self.deltaY;\n        deltaY[0] = deltaY[1] = deltaY[2] = 0;\n      }\n\n      if (moved || dragged) {\n        onMove && onMove(self);\n\n        if (dragged) {\n          onDrag(self);\n          dragged = false;\n        }\n\n        moved = false;\n      }\n\n      locked && !(locked = false) && onLockAxis && onLockAxis(self);\n\n      if (wheeled) {\n        onWheel(self);\n        wheeled = false;\n      }\n\n      id = 0;\n    },\n        onDelta = function onDelta(x, y, index) {\n      deltaX[index] += x;\n      deltaY[index] += y;\n\n      self._vx.update(x);\n\n      self._vy.update(y);\n\n      debounce ? id || (id = requestAnimationFrame(update)) : update();\n    },\n        onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {\n      if (lockAxis && !axis) {\n        self.axis = axis = Math.abs(x) > Math.abs(y) ? \"x\" : \"y\";\n        locked = true;\n      }\n\n      if (axis !== \"y\") {\n        deltaX[2] += x;\n\n        self._vx.update(x, true); // update the velocity as frequently as possible instead of in the debounced function so that very quick touch-scrolls (flicks) feel natural. If it's the mouse/touch/pointer, force it so that we get snappy/accurate momentum scroll.\n\n      }\n\n      if (axis !== \"x\") {\n        deltaY[2] += y;\n\n        self._vy.update(y, true);\n      }\n\n      debounce ? id || (id = requestAnimationFrame(update)) : update();\n    },\n        _onDrag = function _onDrag(e) {\n      if (_ignoreCheck(e, 1)) {\n        return;\n      }\n\n      e = _getEvent(e, preventDefault);\n      var x = e.clientX,\n          y = e.clientY,\n          dx = x - self.x,\n          dy = y - self.y,\n          isDragging = self.isDragging;\n      self.x = x;\n      self.y = y;\n\n      if (isDragging || Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum) {\n        onDrag && (dragged = true);\n        isDragging || (self.isDragging = true);\n        onTouchOrPointerDelta(dx, dy);\n        isDragging || onDragStart && onDragStart(self);\n      }\n    },\n        _onPress = self.onPress = function (e) {\n      if (_ignoreCheck(e, 1) || e && e.button) {\n        return;\n      }\n\n      self.axis = axis = null;\n      onStopDelayedCall.pause();\n      self.isPressed = true;\n      e = _getEvent(e); // note: may need to preventDefault(?) Won't side-scroll on iOS Safari if we do, though.\n\n      prevDeltaX = prevDeltaY = 0;\n      self.startX = self.x = e.clientX;\n      self.startY = self.y = e.clientY;\n\n      self._vx.reset(); // otherwise the t2 may be stale if the user touches and flicks super fast and releases in less than 2 requestAnimationFrame ticks, causing velocity to be 0.\n\n\n      self._vy.reset();\n\n      _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);\n\n      self.deltaX = self.deltaY = 0;\n      onPress && onPress(self);\n    },\n        _onRelease = self.onRelease = function (e) {\n      if (_ignoreCheck(e, 1)) {\n        return;\n      }\n\n      _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);\n\n      var isTrackingDrag = !isNaN(self.y - self.startY),\n          wasDragging = self.isDragging,\n          isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),\n          // some touch devices need some wiggle room in terms of sensing clicks - the finger may move a few pixels.\n      eventData = _getEvent(e);\n\n      if (!isDragNotClick && isTrackingDrag) {\n        self._vx.reset();\n\n        self._vy.reset(); //if (preventDefault && allowClicks && self.isPressed) { // check isPressed because in a rare edge case, the inputObserver in ScrollTrigger may stopPropagation() on the press/drag, so the onRelease may get fired without the onPress/onDrag ever getting called, thus it could trigger a click to occur on a link after scroll-dragging it.\n\n\n        if (preventDefault && allowClicks) {\n          gsap.delayedCall(0.08, function () {\n            // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular \"click\" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the \"real\"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the \"real\" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched.\n            if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {\n              if (e.target.click) {\n                //some browsers (like mobile Safari) don't properly trigger the click event\n                e.target.click();\n              } else if (ownerDoc.createEvent) {\n                var syntheticEvent = ownerDoc.createEvent(\"MouseEvents\");\n                syntheticEvent.initMouseEvent(\"click\", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);\n                e.target.dispatchEvent(syntheticEvent);\n              }\n            }\n          });\n        }\n      }\n\n      self.isDragging = self.isGesturing = self.isPressed = false;\n      onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);\n      onDragEnd && wasDragging && onDragEnd(self);\n      onRelease && onRelease(self, isDragNotClick);\n    },\n        _onGestureStart = function _onGestureStart(e) {\n      return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);\n    },\n        _onGestureEnd = function _onGestureEnd() {\n      return (self.isGesturing = false) || onGestureEnd(self);\n    },\n        onScroll = function onScroll(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      var x = scrollFuncX(),\n          y = scrollFuncY();\n      onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);\n      scrollX = x;\n      scrollY = y;\n      onStop && onStopDelayedCall.restart(true);\n    },\n        _onWheel = function _onWheel(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      e = _getEvent(e, preventDefault);\n      onWheel && (wheeled = true);\n      var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;\n      onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);\n      onStop && !isNormalizer && onStopDelayedCall.restart(true);\n    },\n        _onMove = function _onMove(e) {\n      if (_ignoreCheck(e)) {\n        return;\n      }\n\n      var x = e.clientX,\n          y = e.clientY,\n          dx = x - self.x,\n          dy = y - self.y;\n      self.x = x;\n      self.y = y;\n      moved = true;\n      onStop && onStopDelayedCall.restart(true);\n      (dx || dy) && onTouchOrPointerDelta(dx, dy);\n    },\n        _onHover = function _onHover(e) {\n      self.event = e;\n      onHover(self);\n    },\n        _onHoverEnd = function _onHoverEnd(e) {\n      self.event = e;\n      onHoverEnd(self);\n    },\n        _onClick = function _onClick(e) {\n      return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);\n    };\n\n    onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();\n    self.deltaX = self.deltaY = 0;\n    self._vx = _getVelocityProp(0, 50, true);\n    self._vy = _getVelocityProp(0, 50, true);\n    self.scrollX = scrollFuncX;\n    self.scrollY = scrollFuncY;\n    self.isDragging = self.isGesturing = self.isPressed = false;\n\n    _context(this);\n\n    self.enable = function (e) {\n      if (!self.isEnabled) {\n        _addListener(isViewport ? ownerDoc : target, \"scroll\", _onScroll);\n\n        type.indexOf(\"scroll\") >= 0 && _addListener(isViewport ? ownerDoc : target, \"scroll\", onScroll, passive, capture);\n        type.indexOf(\"wheel\") >= 0 && _addListener(target, \"wheel\", _onWheel, passive, capture);\n\n        if (type.indexOf(\"touch\") >= 0 && _isTouch || type.indexOf(\"pointer\") >= 0) {\n          _addListener(target, _eventTypes[0], _onPress, passive, capture);\n\n          _addListener(ownerDoc, _eventTypes[2], _onRelease);\n\n          _addListener(ownerDoc, _eventTypes[3], _onRelease);\n\n          allowClicks && _addListener(target, \"click\", clickCapture, true, true);\n          onClick && _addListener(target, \"click\", _onClick);\n          onGestureStart && _addListener(ownerDoc, \"gesturestart\", _onGestureStart);\n          onGestureEnd && _addListener(ownerDoc, \"gestureend\", _onGestureEnd);\n          onHover && _addListener(target, _pointerType + \"enter\", _onHover);\n          onHoverEnd && _addListener(target, _pointerType + \"leave\", _onHoverEnd);\n          onMove && _addListener(target, _pointerType + \"move\", _onMove);\n        }\n\n        self.isEnabled = true;\n        e && e.type && _onPress(e);\n        onEnable && onEnable(self);\n      }\n\n      return self;\n    };\n\n    self.disable = function () {\n      if (self.isEnabled) {\n        // only remove the _onScroll listener if there aren't any others that rely on the functionality.\n        _observers.filter(function (o) {\n          return o !== self && _isViewport(o.target);\n        }).length || _removeListener(isViewport ? ownerDoc : target, \"scroll\", _onScroll);\n\n        if (self.isPressed) {\n          self._vx.reset();\n\n          self._vy.reset();\n\n          _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);\n        }\n\n        _removeListener(isViewport ? ownerDoc : target, \"scroll\", onScroll, capture);\n\n        _removeListener(target, \"wheel\", _onWheel, capture);\n\n        _removeListener(target, _eventTypes[0], _onPress, capture);\n\n        _removeListener(ownerDoc, _eventTypes[2], _onRelease);\n\n        _removeListener(ownerDoc, _eventTypes[3], _onRelease);\n\n        _removeListener(target, \"click\", clickCapture, true);\n\n        _removeListener(target, \"click\", _onClick);\n\n        _removeListener(ownerDoc, \"gesturestart\", _onGestureStart);\n\n        _removeListener(ownerDoc, \"gestureend\", _onGestureEnd);\n\n        _removeListener(target, _pointerType + \"enter\", _onHover);\n\n        _removeListener(target, _pointerType + \"leave\", _onHoverEnd);\n\n        _removeListener(target, _pointerType + \"move\", _onMove);\n\n        self.isEnabled = self.isPressed = self.isDragging = false;\n        onDisable && onDisable(self);\n      }\n    };\n\n    self.kill = self.revert = function () {\n      self.disable();\n\n      var i = _observers.indexOf(self);\n\n      i >= 0 && _observers.splice(i, 1);\n      _normalizer === self && (_normalizer = 0);\n    };\n\n    _observers.push(self);\n\n    isNormalizer && _isViewport(target) && (_normalizer = self);\n    self.enable(event);\n  };\n\n  _createClass(Observer, [{\n    key: \"velocityX\",\n    get: function get() {\n      return this._vx.getVelocity();\n    }\n  }, {\n    key: \"velocityY\",\n    get: function get() {\n      return this._vy.getVelocity();\n    }\n  }]);\n\n  return Observer;\n}();\nObserver.version = \"3.12.5\";\n\nObserver.create = function (vars) {\n  return new Observer(vars);\n};\n\nObserver.register = _initCore;\n\nObserver.getAll = function () {\n  return _observers.slice();\n};\n\nObserver.getById = function (id) {\n  return _observers.filter(function (o) {\n    return o.vars.id === id;\n  })[0];\n};\n\n_getGSAP() && gsap.registerPlugin(Observer);\nexport { Observer as default, _isViewport, _scrollers, _getScrollFunc, _getProxyProp, _proxies, _getVelocityProp, _vertical, _horizontal, _getTarget };","/*!\n * ScrollTrigger 3.12.5\n * https://gsap.com\n *\n * @license Copyright 2008-2024, GreenSock. All rights reserved.\n * Subject to the terms at https://gsap.com/standard-license or for\n * Club GSAP members, the agreement issued with that membership.\n * @author: Jack Doyle, jack@greensock.com\n*/\n\n/* eslint-disable */\nimport { Observer, _getTarget, _vertical, _horizontal, _scrollers, _proxies, _getScrollFunc, _getProxyProp, _getVelocityProp } from \"./Observer.js\";\n\nvar gsap,\n    _coreInitted,\n    _win,\n    _doc,\n    _docEl,\n    _body,\n    _root,\n    _resizeDelay,\n    _toArray,\n    _clamp,\n    _time2,\n    _syncInterval,\n    _refreshing,\n    _pointerIsDown,\n    _transformProp,\n    _i,\n    _prevWidth,\n    _prevHeight,\n    _autoRefresh,\n    _sort,\n    _suppressOverwrites,\n    _ignoreResize,\n    _normalizer,\n    _ignoreMobileResize,\n    _baseScreenHeight,\n    _baseScreenWidth,\n    _fixIOSBug,\n    _context,\n    _scrollRestoration,\n    _div100vh,\n    _100vh,\n    _isReverted,\n    _clampingMax,\n    _limitCallbacks,\n    // if true, we'll only trigger callbacks if the active state toggles, so if you scroll immediately past both the start and end positions of a ScrollTrigger (thus inactive to inactive), neither its onEnter nor onLeave will be called. This is useful during startup.\n_startup = 1,\n    _getTime = Date.now,\n    _time1 = _getTime(),\n    _lastScrollTime = 0,\n    _enabled = 0,\n    _parseClamp = function _parseClamp(value, type, self) {\n  var clamp = _isString(value) && (value.substr(0, 6) === \"clamp(\" || value.indexOf(\"max\") > -1);\n  self[\"_\" + type + \"Clamp\"] = clamp;\n  return clamp ? value.substr(6, value.length - 7) : value;\n},\n    _keepClamp = function _keepClamp(value, clamp) {\n  return clamp && (!_isString(value) || value.substr(0, 6) !== \"clamp(\") ? \"clamp(\" + value + \")\" : value;\n},\n    _rafBugFix = function _rafBugFix() {\n  return _enabled && requestAnimationFrame(_rafBugFix);\n},\n    // in some browsers (like Firefox), screen repaints weren't consistent unless we had SOMETHING queued up in requestAnimationFrame()! So this just creates a super simple loop to keep it alive and smooth out repaints.\n_pointerDownHandler = function _pointerDownHandler() {\n  return _pointerIsDown = 1;\n},\n    _pointerUpHandler = function _pointerUpHandler() {\n  return _pointerIsDown = 0;\n},\n    _passThrough = function _passThrough(v) {\n  return v;\n},\n    _round = function _round(value) {\n  return Math.round(value * 100000) / 100000 || 0;\n},\n    _windowExists = function _windowExists() {\n  return typeof window !== \"undefined\";\n},\n    _getGSAP = function _getGSAP() {\n  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;\n},\n    _isViewport = function _isViewport(e) {\n  return !!~_root.indexOf(e);\n},\n    _getViewportDimension = function _getViewportDimension(dimensionProperty) {\n  return (dimensionProperty === \"Height\" ? _100vh : _win[\"inner\" + dimensionProperty]) || _docEl[\"client\" + dimensionProperty] || _body[\"client\" + dimensionProperty];\n},\n    _getBoundsFunc = function _getBoundsFunc(element) {\n  return _getProxyProp(element, \"getBoundingClientRect\") || (_isViewport(element) ? function () {\n    _winOffsets.width = _win.innerWidth;\n    _winOffsets.height = _100vh;\n    return _winOffsets;\n  } : function () {\n    return _getBounds(element);\n  });\n},\n    _getSizeFunc = function _getSizeFunc(scroller, isViewport, _ref) {\n  var d = _ref.d,\n      d2 = _ref.d2,\n      a = _ref.a;\n  return (a = _getProxyProp(scroller, \"getBoundingClientRect\")) ? function () {\n    return a()[d];\n  } : function () {\n    return (isViewport ? _getViewportDimension(d2) : scroller[\"client\" + d2]) || 0;\n  };\n},\n    _getOffsetsFunc = function _getOffsetsFunc(element, isViewport) {\n  return !isViewport || ~_proxies.indexOf(element) ? _getBoundsFunc(element) : function () {\n    return _winOffsets;\n  };\n},\n    _maxScroll = function _maxScroll(element, _ref2) {\n  var s = _ref2.s,\n      d2 = _ref2.d2,\n      d = _ref2.d,\n      a = _ref2.a;\n  return Math.max(0, (s = \"scroll\" + d2) && (a = _getProxyProp(element, s)) ? a() - _getBoundsFunc(element)()[d] : _isViewport(element) ? (_docEl[s] || _body[s]) - _getViewportDimension(d2) : element[s] - element[\"offset\" + d2]);\n},\n    _iterateAutoRefresh = function _iterateAutoRefresh(func, events) {\n  for (var i = 0; i < _autoRefresh.length; i += 3) {\n    (!events || ~events.indexOf(_autoRefresh[i + 1])) && func(_autoRefresh[i], _autoRefresh[i + 1], _autoRefresh[i + 2]);\n  }\n},\n    _isString = function _isString(value) {\n  return typeof value === \"string\";\n},\n    _isFunction = function _isFunction(value) {\n  return typeof value === \"function\";\n},\n    _isNumber = function _isNumber(value) {\n  return typeof value === \"number\";\n},\n    _isObject = function _isObject(value) {\n  return typeof value === \"object\";\n},\n    _endAnimation = function _endAnimation(animation, reversed, pause) {\n  return animation && animation.progress(reversed ? 0 : 1) && pause && animation.pause();\n},\n    _callback = function _callback(self, func) {\n  if (self.enabled) {\n    var result = self._ctx ? self._ctx.add(function () {\n      return func(self);\n    }) : func(self);\n    result && result.totalTime && (self.callbackAnimation = result);\n  }\n},\n    _abs = Math.abs,\n    _left = \"left\",\n    _top = \"top\",\n    _right = \"right\",\n    _bottom = \"bottom\",\n    _width = \"width\",\n    _height = \"height\",\n    _Right = \"Right\",\n    _Left = \"Left\",\n    _Top = \"Top\",\n    _Bottom = \"Bottom\",\n    _padding = \"padding\",\n    _margin = \"margin\",\n    _Width = \"Width\",\n    _Height = \"Height\",\n    _px = \"px\",\n    _getComputedStyle = function _getComputedStyle(element) {\n  return _win.getComputedStyle(element);\n},\n    _makePositionable = function _makePositionable(element) {\n  // if the element already has position: absolute or fixed, leave that, otherwise make it position: relative\n  var position = _getComputedStyle(element).position;\n\n  element.style.position = position === \"absolute\" || position === \"fixed\" ? position : \"relative\";\n},\n    _setDefaults = function _setDefaults(obj, defaults) {\n  for (var p in defaults) {\n    p in obj || (obj[p] = defaults[p]);\n  }\n\n  return obj;\n},\n    _getBounds = function _getBounds(element, withoutTransforms) {\n  var tween = withoutTransforms && _getComputedStyle(element)[_transformProp] !== \"matrix(1, 0, 0, 1, 0, 0)\" && gsap.to(element, {\n    x: 0,\n    y: 0,\n    xPercent: 0,\n    yPercent: 0,\n    rotation: 0,\n    rotationX: 0,\n    rotationY: 0,\n    scale: 1,\n    skewX: 0,\n    skewY: 0\n  }).progress(1),\n      bounds = element.getBoundingClientRect();\n  tween && tween.progress(0).kill();\n  return bounds;\n},\n    _getSize = function _getSize(element, _ref3) {\n  var d2 = _ref3.d2;\n  return element[\"offset\" + d2] || element[\"client\" + d2] || 0;\n},\n    _getLabelRatioArray = function _getLabelRatioArray(timeline) {\n  var a = [],\n      labels = timeline.labels,\n      duration = timeline.duration(),\n      p;\n\n  for (p in labels) {\n    a.push(labels[p] / duration);\n  }\n\n  return a;\n},\n    _getClosestLabel = function _getClosestLabel(animation) {\n  return function (value) {\n    return gsap.utils.snap(_getLabelRatioArray(animation), value);\n  };\n},\n    _snapDirectional = function _snapDirectional(snapIncrementOrArray) {\n  var snap = gsap.utils.snap(snapIncrementOrArray),\n      a = Array.isArray(snapIncrementOrArray) && snapIncrementOrArray.slice(0).sort(function (a, b) {\n    return a - b;\n  });\n  return a ? function (value, direction, threshold) {\n    if (threshold === void 0) {\n      threshold = 1e-3;\n    }\n\n    var i;\n\n    if (!direction) {\n      return snap(value);\n    }\n\n    if (direction > 0) {\n      value -= threshold; // to avoid rounding errors. If we're too strict, it might snap forward, then immediately again, and again.\n\n      for (i = 0; i < a.length; i++) {\n        if (a[i] >= value) {\n          return a[i];\n        }\n      }\n\n      return a[i - 1];\n    } else {\n      i = a.length;\n      value += threshold;\n\n      while (i--) {\n        if (a[i] <= value) {\n          return a[i];\n        }\n      }\n    }\n\n    return a[0];\n  } : function (value, direction, threshold) {\n    if (threshold === void 0) {\n      threshold = 1e-3;\n    }\n\n    var snapped = snap(value);\n    return !direction || Math.abs(snapped - value) < threshold || snapped - value < 0 === direction < 0 ? snapped : snap(direction < 0 ? value - snapIncrementOrArray : value + snapIncrementOrArray);\n  };\n},\n    _getLabelAtDirection = function _getLabelAtDirection(timeline) {\n  return function (value, st) {\n    return _snapDirectional(_getLabelRatioArray(timeline))(value, st.direction);\n  };\n},\n    _multiListener = function _multiListener(func, element, types, callback) {\n  return types.split(\",\").forEach(function (type) {\n    return func(element, type, callback);\n  });\n},\n    _addListener = function _addListener(element, type, func, nonPassive, capture) {\n  return element.addEventListener(type, func, {\n    passive: !nonPassive,\n    capture: !!capture\n  });\n},\n    _removeListener = function _removeListener(element, type, func, capture) {\n  return element.removeEventListener(type, func, !!capture);\n},\n    _wheelListener = function _wheelListener(func, el, scrollFunc) {\n  scrollFunc = scrollFunc && scrollFunc.wheelHandler;\n\n  if (scrollFunc) {\n    func(el, \"wheel\", scrollFunc);\n    func(el, \"touchmove\", scrollFunc);\n  }\n},\n    _markerDefaults = {\n  startColor: \"green\",\n  endColor: \"red\",\n  indent: 0,\n  fontSize: \"16px\",\n  fontWeight: \"normal\"\n},\n    _defaults = {\n  toggleActions: \"play\",\n  anticipatePin: 0\n},\n    _keywords = {\n  top: 0,\n  left: 0,\n  center: 0.5,\n  bottom: 1,\n  right: 1\n},\n    _offsetToPx = function _offsetToPx(value, size) {\n  if (_isString(value)) {\n    var eqIndex = value.indexOf(\"=\"),\n        relative = ~eqIndex ? +(value.charAt(eqIndex - 1) + 1) * parseFloat(value.substr(eqIndex + 1)) : 0;\n\n    if (~eqIndex) {\n      value.indexOf(\"%\") > eqIndex && (relative *= size / 100);\n      value = value.substr(0, eqIndex - 1);\n    }\n\n    value = relative + (value in _keywords ? _keywords[value] * size : ~value.indexOf(\"%\") ? parseFloat(value) * size / 100 : parseFloat(value) || 0);\n  }\n\n  return value;\n},\n    _createMarker = function _createMarker(type, name, container, direction, _ref4, offset, matchWidthEl, containerAnimation) {\n  var startColor = _ref4.startColor,\n      endColor = _ref4.endColor,\n      fontSize = _ref4.fontSize,\n      indent = _ref4.indent,\n      fontWeight = _ref4.fontWeight;\n\n  var e = _doc.createElement(\"div\"),\n      useFixedPosition = _isViewport(container) || _getProxyProp(container, \"pinType\") === \"fixed\",\n      isScroller = type.indexOf(\"scroller\") !== -1,\n      parent = useFixedPosition ? _body : container,\n      isStart = type.indexOf(\"start\") !== -1,\n      color = isStart ? startColor : endColor,\n      css = \"border-color:\" + color + \";font-size:\" + fontSize + \";color:\" + color + \";font-weight:\" + fontWeight + \";pointer-events:none;white-space:nowrap;font-family:sans-serif,Arial;z-index:1000;padding:4px 8px;border-width:0;border-style:solid;\";\n\n  css += \"position:\" + ((isScroller || containerAnimation) && useFixedPosition ? \"fixed;\" : \"absolute;\");\n  (isScroller || containerAnimation || !useFixedPosition) && (css += (direction === _vertical ? _right : _bottom) + \":\" + (offset + parseFloat(indent)) + \"px;\");\n  matchWidthEl && (css += \"box-sizing:border-box;text-align:left;width:\" + matchWidthEl.offsetWidth + \"px;\");\n  e._isStart = isStart;\n  e.setAttribute(\"class\", \"gsap-marker-\" + type + (name ? \" marker-\" + name : \"\"));\n  e.style.cssText = css;\n  e.innerText = name || name === 0 ? type + \"-\" + name : type;\n  parent.children[0] ? parent.insertBefore(e, parent.children[0]) : parent.appendChild(e);\n  e._offset = e[\"offset\" + direction.op.d2];\n\n  _positionMarker(e, 0, direction, isStart);\n\n  return e;\n},\n    _positionMarker = function _positionMarker(marker, start, direction, flipped) {\n  var vars = {\n    display: \"block\"\n  },\n      side = direction[flipped ? \"os2\" : \"p2\"],\n      oppositeSide = direction[flipped ? \"p2\" : \"os2\"];\n  marker._isFlipped = flipped;\n  vars[direction.a + \"Percent\"] = flipped ? -100 : 0;\n  vars[direction.a] = flipped ? \"1px\" : 0;\n  vars[\"border\" + side + _Width] = 1;\n  vars[\"border\" + oppositeSide + _Width] = 0;\n  vars[direction.p] = start + \"px\";\n  gsap.set(marker, vars);\n},\n    _triggers = [],\n    _ids = {},\n    _rafID,\n    _sync = function _sync() {\n  return _getTime() - _lastScrollTime > 34 && (_rafID || (_rafID = requestAnimationFrame(_updateAll)));\n},\n    _onScroll = function _onScroll() {\n  // previously, we tried to optimize performance by batching/deferring to the next requestAnimationFrame(), but discovered that Safari has a few bugs that make this unworkable (especially on iOS). See https://codepen.io/GreenSock/pen/16c435b12ef09c38125204818e7b45fc?editors=0010 and https://codepen.io/GreenSock/pen/JjOxYpQ/3dd65ccec5a60f1d862c355d84d14562?editors=0010 and https://codepen.io/GreenSock/pen/ExbrPNa/087cef197dc35445a0951e8935c41503?editors=0010\n  if (!_normalizer || !_normalizer.isPressed || _normalizer.startX > _body.clientWidth) {\n    // if the user is dragging the scrollbar, allow it.\n    _scrollers.cache++;\n\n    if (_normalizer) {\n      _rafID || (_rafID = requestAnimationFrame(_updateAll));\n    } else {\n      _updateAll(); // Safari in particular (on desktop) NEEDS the immediate update rather than waiting for a requestAnimationFrame() whereas iOS seems to benefit from waiting for the requestAnimationFrame() tick, at least when normalizing. See https://codepen.io/GreenSock/pen/qBYozqO?editors=0110\n\n    }\n\n    _lastScrollTime || _dispatch(\"scrollStart\");\n    _lastScrollTime = _getTime();\n  }\n},\n    _setBaseDimensions = function _setBaseDimensions() {\n  _baseScreenWidth = _win.innerWidth;\n  _baseScreenHeight = _win.innerHeight;\n},\n    _onResize = function _onResize() {\n  _scrollers.cache++;\n  !_refreshing && !_ignoreResize && !_doc.fullscreenElement && !_doc.webkitFullscreenElement && (!_ignoreMobileResize || _baseScreenWidth !== _win.innerWidth || Math.abs(_win.innerHeight - _baseScreenHeight) > _win.innerHeight * 0.25) && _resizeDelay.restart(true);\n},\n    // ignore resizes triggered by refresh()\n_listeners = {},\n    _emptyArray = [],\n    _softRefresh = function _softRefresh() {\n  return _removeListener(ScrollTrigger, \"scrollEnd\", _softRefresh) || _refreshAll(true);\n},\n    _dispatch = function _dispatch(type) {\n  return _listeners[type] && _listeners[type].map(function (f) {\n    return f();\n  }) || _emptyArray;\n},\n    _savedStyles = [],\n    // when ScrollTrigger.saveStyles() is called, the inline styles are recorded in this Array in a sequential format like [element, cssText, gsCache, media]. This keeps it very memory-efficient and fast to iterate through.\n_revertRecorded = function _revertRecorded(media) {\n  for (var i = 0; i < _savedStyles.length; i += 5) {\n    if (!media || _savedStyles[i + 4] && _savedStyles[i + 4].query === media) {\n      _savedStyles[i].style.cssText = _savedStyles[i + 1];\n      _savedStyles[i].getBBox && _savedStyles[i].setAttribute(\"transform\", _savedStyles[i + 2] || \"\");\n      _savedStyles[i + 3].uncache = 1;\n    }\n  }\n},\n    _revertAll = function _revertAll(kill, media) {\n  var trigger;\n\n  for (_i = 0; _i < _triggers.length; _i++) {\n    trigger = _triggers[_i];\n\n    if (trigger && (!media || trigger._ctx === media)) {\n      if (kill) {\n        trigger.kill(1);\n      } else {\n        trigger.revert(true, true);\n      }\n    }\n  }\n\n  _isReverted = true;\n  media && _revertRecorded(media);\n  media || _dispatch(\"revert\");\n},\n    _clearScrollMemory = function _clearScrollMemory(scrollRestoration, force) {\n  // zero-out all the recorded scroll positions. Don't use _triggers because if, for example, .matchMedia() is used to create some ScrollTriggers and then the user resizes and it removes ALL ScrollTriggers, and then go back to a size where there are ScrollTriggers, it would have kept the position(s) saved from the initial state.\n  _scrollers.cache++;\n  (force || !_refreshingAll) && _scrollers.forEach(function (obj) {\n    return _isFunction(obj) && obj.cacheID++ && (obj.rec = 0);\n  });\n  _isString(scrollRestoration) && (_win.history.scrollRestoration = _scrollRestoration = scrollRestoration);\n},\n    _refreshingAll,\n    _refreshID = 0,\n    _queueRefreshID,\n    _queueRefreshAll = function _queueRefreshAll() {\n  // we don't want to call _refreshAll() every time we create a new ScrollTrigger (for performance reasons) - it's better to batch them. Some frameworks dynamically load content and we can't rely on the window's \"load\" or \"DOMContentLoaded\" events to trigger it.\n  if (_queueRefreshID !== _refreshID) {\n    var id = _queueRefreshID = _refreshID;\n    requestAnimationFrame(function () {\n      return id === _refreshID && _refreshAll(true);\n    });\n  }\n},\n    _refresh100vh = function _refresh100vh() {\n  _body.appendChild(_div100vh);\n\n  _100vh = !_normalizer && _div100vh.offsetHeight || _win.innerHeight;\n\n  _body.removeChild(_div100vh);\n},\n    _hideAllMarkers = function _hideAllMarkers(hide) {\n  return _toArray(\".gsap-marker-start, .gsap-marker-end, .gsap-marker-scroller-start, .gsap-marker-scroller-end\").forEach(function (el) {\n    return el.style.display = hide ? \"none\" : \"block\";\n  });\n},\n    _refreshAll = function _refreshAll(force, skipRevert) {\n  if (_lastScrollTime && !force && !_isReverted) {\n    _addListener(ScrollTrigger, \"scrollEnd\", _softRefresh);\n\n    return;\n  }\n\n  _refresh100vh();\n\n  _refreshingAll = ScrollTrigger.isRefreshing = true;\n\n  _scrollers.forEach(function (obj) {\n    return _isFunction(obj) && ++obj.cacheID && (obj.rec = obj());\n  }); // force the clearing of the cache because some browsers take a little while to dispatch the \"scroll\" event and the user may have changed the scroll position and then called ScrollTrigger.refresh() right away\n\n\n  var refreshInits = _dispatch(\"refreshInit\");\n\n  _sort && ScrollTrigger.sort();\n  skipRevert || _revertAll();\n\n  _scrollers.forEach(function (obj) {\n    if (_isFunction(obj)) {\n      obj.smooth && (obj.target.style.scrollBehavior = \"auto\"); // smooth scrolling interferes\n\n      obj(0);\n    }\n  });\n\n  _triggers.slice(0).forEach(function (t) {\n    return t.refresh();\n  }); // don't loop with _i because during a refresh() someone could call ScrollTrigger.update() which would iterate through _i resulting in a skip.\n\n\n  _isReverted = false;\n\n  _triggers.forEach(function (t) {\n    // nested pins (pinnedContainer) with pinSpacing may expand the container, so we must accommodate that here.\n    if (t._subPinOffset && t.pin) {\n      var prop = t.vars.horizontal ? \"offsetWidth\" : \"offsetHeight\",\n          original = t.pin[prop];\n      t.revert(true, 1);\n      t.adjustPinSpacing(t.pin[prop] - original);\n      t.refresh();\n    }\n  });\n\n  _clampingMax = 1; // pinSpacing might be propping a page open, thus when we .setPositions() to clamp a ScrollTrigger's end we should leave the pinSpacing alone. That's what this flag is for.\n\n  _hideAllMarkers(true);\n\n  _triggers.forEach(function (t) {\n    // the scroller's max scroll position may change after all the ScrollTriggers refreshed (like pinning could push it down), so we need to loop back and correct any with end: \"max\". Same for anything with a clamped end\n    var max = _maxScroll(t.scroller, t._dir),\n        endClamp = t.vars.end === \"max\" || t._endClamp && t.end > max,\n        startClamp = t._startClamp && t.start >= max;\n\n    (endClamp || startClamp) && t.setPositions(startClamp ? max - 1 : t.start, endClamp ? Math.max(startClamp ? max : t.start + 1, max) : t.end, true);\n  });\n\n  _hideAllMarkers(false);\n\n  _clampingMax = 0;\n  refreshInits.forEach(function (result) {\n    return result && result.render && result.render(-1);\n  }); // if the onRefreshInit() returns an animation (typically a gsap.set()), revert it. This makes it easy to put things in a certain spot before refreshing for measurement purposes, and then put things back.\n\n  _scrollers.forEach(function (obj) {\n    if (_isFunction(obj)) {\n      obj.smooth && requestAnimationFrame(function () {\n        return obj.target.style.scrollBehavior = \"smooth\";\n      });\n      obj.rec && obj(obj.rec);\n    }\n  });\n\n  _clearScrollMemory(_scrollRestoration, 1);\n\n  _resizeDelay.pause();\n\n  _refreshID++;\n  _refreshingAll = 2;\n\n  _updateAll(2);\n\n  _triggers.forEach(function (t) {\n    return _isFunction(t.vars.onRefresh) && t.vars.onRefresh(t);\n  });\n\n  _refreshingAll = ScrollTrigger.isRefreshing = false;\n\n  _dispatch(\"refresh\");\n},\n    _lastScroll = 0,\n    _direction = 1,\n    _primary,\n    _updateAll = function _updateAll(force) {\n  if (force === 2 || !_refreshingAll && !_isReverted) {\n    // _isReverted could be true if, for example, a matchMedia() is in the process of executing. We don't want to update during the time everything is reverted.\n    ScrollTrigger.isUpdating = true;\n    _primary && _primary.update(0); // ScrollSmoother uses refreshPriority -9999 to become the primary that gets updated before all others because it affects the scroll position.\n\n    var l = _triggers.length,\n        time = _getTime(),\n        recordVelocity = time - _time1 >= 50,\n        scroll = l && _triggers[0].scroll();\n\n    _direction = _lastScroll > scroll ? -1 : 1;\n    _refreshingAll || (_lastScroll = scroll);\n\n    if (recordVelocity) {\n      if (_lastScrollTime && !_pointerIsDown && time - _lastScrollTime > 200) {\n        _lastScrollTime = 0;\n\n        _dispatch(\"scrollEnd\");\n      }\n\n      _time2 = _time1;\n      _time1 = time;\n    }\n\n    if (_direction < 0) {\n      _i = l;\n\n      while (_i-- > 0) {\n        _triggers[_i] && _triggers[_i].update(0, recordVelocity);\n      }\n\n      _direction = 1;\n    } else {\n      for (_i = 0; _i < l; _i++) {\n        _triggers[_i] && _triggers[_i].update(0, recordVelocity);\n      }\n    }\n\n    ScrollTrigger.isUpdating = false;\n  }\n\n  _rafID = 0;\n},\n    _propNamesToCopy = [_left, _top, _bottom, _right, _margin + _Bottom, _margin + _Right, _margin + _Top, _margin + _Left, \"display\", \"flexShrink\", \"float\", \"zIndex\", \"gridColumnStart\", \"gridColumnEnd\", \"gridRowStart\", \"gridRowEnd\", \"gridArea\", \"justifySelf\", \"alignSelf\", \"placeSelf\", \"order\"],\n    _stateProps = _propNamesToCopy.concat([_width, _height, \"boxSizing\", \"max\" + _Width, \"max\" + _Height, \"position\", _margin, _padding, _padding + _Top, _padding + _Right, _padding + _Bottom, _padding + _Left]),\n    _swapPinOut = function _swapPinOut(pin, spacer, state) {\n  _setState(state);\n\n  var cache = pin._gsap;\n\n  if (cache.spacerIsNative) {\n    _setState(cache.spacerState);\n  } else if (pin._gsap.swappedIn) {\n    var parent = spacer.parentNode;\n\n    if (parent) {\n      parent.insertBefore(pin, spacer);\n      parent.removeChild(spacer);\n    }\n  }\n\n  pin._gsap.swappedIn = false;\n},\n    _swapPinIn = function _swapPinIn(pin, spacer, cs, spacerState) {\n  if (!pin._gsap.swappedIn) {\n    var i = _propNamesToCopy.length,\n        spacerStyle = spacer.style,\n        pinStyle = pin.style,\n        p;\n\n    while (i--) {\n      p = _propNamesToCopy[i];\n      spacerStyle[p] = cs[p];\n    }\n\n    spacerStyle.position = cs.position === \"absolute\" ? \"absolute\" : \"relative\";\n    cs.display === \"inline\" && (spacerStyle.display = \"inline-block\");\n    pinStyle[_bottom] = pinStyle[_right] = \"auto\";\n    spacerStyle.flexBasis = cs.flexBasis || \"auto\";\n    spacerStyle.overflow = \"visible\";\n    spacerStyle.boxSizing = \"border-box\";\n    spacerStyle[_width] = _getSize(pin, _horizontal) + _px;\n    spacerStyle[_height] = _getSize(pin, _vertical) + _px;\n    spacerStyle[_padding] = pinStyle[_margin] = pinStyle[_top] = pinStyle[_left] = \"0\";\n\n    _setState(spacerState);\n\n    pinStyle[_width] = pinStyle[\"max\" + _Width] = cs[_width];\n    pinStyle[_height] = pinStyle[\"max\" + _Height] = cs[_height];\n    pinStyle[_padding] = cs[_padding];\n\n    if (pin.parentNode !== spacer) {\n      pin.parentNode.insertBefore(spacer, pin);\n      spacer.appendChild(pin);\n    }\n\n    pin._gsap.swappedIn = true;\n  }\n},\n    _capsExp = /([A-Z])/g,\n    _setState = function _setState(state) {\n  if (state) {\n    var style = state.t.style,\n        l = state.length,\n        i = 0,\n        p,\n        value;\n    (state.t._gsap || gsap.core.getCache(state.t)).uncache = 1; // otherwise transforms may be off\n\n    for (; i < l; i += 2) {\n      value = state[i + 1];\n      p = state[i];\n\n      if (value) {\n        style[p] = value;\n      } else if (style[p]) {\n        style.removeProperty(p.replace(_capsExp, \"-$1\").toLowerCase());\n      }\n    }\n  }\n},\n    _getState = function _getState(element) {\n  // returns an Array with alternating values like [property, value, property, value] and a \"t\" property pointing to the target (element). Makes it fast and cheap.\n  var l = _stateProps.length,\n      style = element.style,\n      state = [],\n      i = 0;\n\n  for (; i < l; i++) {\n    state.push(_stateProps[i], style[_stateProps[i]]);\n  }\n\n  state.t = element;\n  return state;\n},\n    _copyState = function _copyState(state, override, omitOffsets) {\n  var result = [],\n      l = state.length,\n      i = omitOffsets ? 8 : 0,\n      // skip top, left, right, bottom if omitOffsets is true\n  p;\n\n  for (; i < l; i += 2) {\n    p = state[i];\n    result.push(p, p in override ? override[p] : state[i + 1]);\n  }\n\n  result.t = state.t;\n  return result;\n},\n    _winOffsets = {\n  left: 0,\n  top: 0\n},\n    // // potential future feature (?) Allow users to calculate where a trigger hits (scroll position) like getScrollPosition(\"#id\", \"top bottom\")\n// _getScrollPosition = (trigger, position, {scroller, containerAnimation, horizontal}) => {\n// \tscroller = _getTarget(scroller || _win);\n// \tlet direction = horizontal ? _horizontal : _vertical,\n// \t\tisViewport = _isViewport(scroller);\n// \t_getSizeFunc(scroller, isViewport, direction);\n// \treturn _parsePosition(position, _getTarget(trigger), _getSizeFunc(scroller, isViewport, direction)(), direction, _getScrollFunc(scroller, direction)(), 0, 0, 0, _getOffsetsFunc(scroller, isViewport)(), isViewport ? 0 : parseFloat(_getComputedStyle(scroller)[\"border\" + direction.p2 + _Width]) || 0, 0, containerAnimation ? containerAnimation.duration() : _maxScroll(scroller), containerAnimation);\n// },\n_parsePosition = function _parsePosition(value, trigger, scrollerSize, direction, scroll, marker, markerScroller, self, scrollerBounds, borderWidth, useFixedPosition, scrollerMax, containerAnimation, clampZeroProp) {\n  _isFunction(value) && (value = value(self));\n\n  if (_isString(value) && value.substr(0, 3) === \"max\") {\n    value = scrollerMax + (value.charAt(4) === \"=\" ? _offsetToPx(\"0\" + value.substr(3), scrollerSize) : 0);\n  }\n\n  var time = containerAnimation ? containerAnimation.time() : 0,\n      p1,\n      p2,\n      element;\n  containerAnimation && containerAnimation.seek(0);\n  isNaN(value) || (value = +value); // convert a string number like \"45\" to an actual number\n\n  if (!_isNumber(value)) {\n    _isFunction(trigger) && (trigger = trigger(self));\n    var offsets = (value || \"0\").split(\" \"),\n        bounds,\n        localOffset,\n        globalOffset,\n        display;\n    element = _getTarget(trigger, self) || _body;\n    bounds = _getBounds(element) || {};\n\n    if ((!bounds || !bounds.left && !bounds.top) && _getComputedStyle(element).display === \"none\") {\n      // if display is \"none\", it won't report getBoundingClientRect() properly\n      display = element.style.display;\n      element.style.display = \"block\";\n      bounds = _getBounds(element);\n      display ? element.style.display = display : element.style.removeProperty(\"display\");\n    }\n\n    localOffset = _offsetToPx(offsets[0], bounds[direction.d]);\n    globalOffset = _offsetToPx(offsets[1] || \"0\", scrollerSize);\n    value = bounds[direction.p] - scrollerBounds[direction.p] - borderWidth + localOffset + scroll - globalOffset;\n    markerScroller && _positionMarker(markerScroller, globalOffset, direction, scrollerSize - globalOffset < 20 || markerScroller._isStart && globalOffset > 20);\n    scrollerSize -= scrollerSize - globalOffset; // adjust for the marker\n  } else {\n    containerAnimation && (value = gsap.utils.mapRange(containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, 0, scrollerMax, value));\n    markerScroller && _positionMarker(markerScroller, scrollerSize, direction, true);\n  }\n\n  if (clampZeroProp) {\n    self[clampZeroProp] = value || -0.001;\n    value < 0 && (value = 0);\n  }\n\n  if (marker) {\n    var position = value + scrollerSize,\n        isStart = marker._isStart;\n    p1 = \"scroll\" + direction.d2;\n\n    _positionMarker(marker, position, direction, isStart && position > 20 || !isStart && (useFixedPosition ? Math.max(_body[p1], _docEl[p1]) : marker.parentNode[p1]) <= position + 1);\n\n    if (useFixedPosition) {\n      scrollerBounds = _getBounds(markerScroller);\n      useFixedPosition && (marker.style[direction.op.p] = scrollerBounds[direction.op.p] - direction.op.m - marker._offset + _px);\n    }\n  }\n\n  if (containerAnimation && element) {\n    p1 = _getBounds(element);\n    containerAnimation.seek(scrollerMax);\n    p2 = _getBounds(element);\n    containerAnimation._caScrollDist = p1[direction.p] - p2[direction.p];\n    value = value / containerAnimation._caScrollDist * scrollerMax;\n  }\n\n  containerAnimation && containerAnimation.seek(time);\n  return containerAnimation ? value : Math.round(value);\n},\n    _prefixExp = /(webkit|moz|length|cssText|inset)/i,\n    _reparent = function _reparent(element, parent, top, left) {\n  if (element.parentNode !== parent) {\n    var style = element.style,\n        p,\n        cs;\n\n    if (parent === _body) {\n      element._stOrig = style.cssText; // record original inline styles so we can revert them later\n\n      cs = _getComputedStyle(element);\n\n      for (p in cs) {\n        // must copy all relevant styles to ensure that nothing changes visually when we reparent to the <body>. Skip the vendor prefixed ones.\n        if (!+p && !_prefixExp.test(p) && cs[p] && typeof style[p] === \"string\" && p !== \"0\") {\n          style[p] = cs[p];\n        }\n      }\n\n      style.top = top;\n      style.left = left;\n    } else {\n      style.cssText = element._stOrig;\n    }\n\n    gsap.core.getCache(element).uncache = 1;\n    parent.appendChild(element);\n  }\n},\n    _interruptionTracker = function _interruptionTracker(getValueFunc, initialValue, onInterrupt) {\n  var last1 = initialValue,\n      last2 = last1;\n  return function (value) {\n    var current = Math.round(getValueFunc()); // round because in some [very uncommon] Windows environments, scroll can get reported with decimals even though it was set without.\n\n    if (current !== last1 && current !== last2 && Math.abs(current - last1) > 3 && Math.abs(current - last2) > 3) {\n      // if the user scrolls, kill the tween. iOS Safari intermittently misreports the scroll position, it may be the most recently-set one or the one before that! When Safari is zoomed (CMD-+), it often misreports as 1 pixel off too! So if we set the scroll position to 125, for example, it'll actually report it as 124.\n      value = current;\n      onInterrupt && onInterrupt();\n    }\n\n    last2 = last1;\n    last1 = value;\n    return value;\n  };\n},\n    _shiftMarker = function _shiftMarker(marker, direction, value) {\n  var vars = {};\n  vars[direction.p] = \"+=\" + value;\n  gsap.set(marker, vars);\n},\n    // _mergeAnimations = animations => {\n// \tlet tl = gsap.timeline({smoothChildTiming: true}).startTime(Math.min(...animations.map(a => a.globalTime(0))));\n// \tanimations.forEach(a => {let time = a.totalTime(); tl.add(a); a.totalTime(time); });\n// \ttl.smoothChildTiming = false;\n// \treturn tl;\n// },\n// returns a function that can be used to tween the scroll position in the direction provided, and when doing so it'll add a .tween property to the FUNCTION itself, and remove it when the tween completes or gets killed. This gives us a way to have multiple ScrollTriggers use a central function for any given scroller and see if there's a scroll tween running (which would affect if/how things get updated)\n_getTweenCreator = function _getTweenCreator(scroller, direction) {\n  var getScroll = _getScrollFunc(scroller, direction),\n      prop = \"_scroll\" + direction.p2,\n      // add a tweenable property to the scroller that's a getter/setter function, like _scrollTop or _scrollLeft. This way, if someone does gsap.killTweensOf(scroller) it'll kill the scroll tween.\n  getTween = function getTween(scrollTo, vars, initialValue, change1, change2) {\n    var tween = getTween.tween,\n        onComplete = vars.onComplete,\n        modifiers = {};\n    initialValue = initialValue || getScroll();\n\n    var checkForInterruption = _interruptionTracker(getScroll, initialValue, function () {\n      tween.kill();\n      getTween.tween = 0;\n    });\n\n    change2 = change1 && change2 || 0; // if change1 is 0, we set that to the difference and ignore change2. Otherwise, there would be a compound effect.\n\n    change1 = change1 || scrollTo - initialValue;\n    tween && tween.kill();\n    vars[prop] = scrollTo;\n    vars.inherit = false;\n    vars.modifiers = modifiers;\n\n    modifiers[prop] = function () {\n      return checkForInterruption(initialValue + change1 * tween.ratio + change2 * tween.ratio * tween.ratio);\n    };\n\n    vars.onUpdate = function () {\n      _scrollers.cache++;\n      getTween.tween && _updateAll(); // if it was interrupted/killed, like in a context.revert(), don't force an updateAll()\n    };\n\n    vars.onComplete = function () {\n      getTween.tween = 0;\n      onComplete && onComplete.call(tween);\n    };\n\n    tween = getTween.tween = gsap.to(scroller, vars);\n    return tween;\n  };\n\n  scroller[prop] = getScroll;\n\n  getScroll.wheelHandler = function () {\n    return getTween.tween && getTween.tween.kill() && (getTween.tween = 0);\n  };\n\n  _addListener(scroller, \"wheel\", getScroll.wheelHandler); // Windows machines handle mousewheel scrolling in chunks (like \"3 lines per scroll\") meaning the typical strategy for cancelling the scroll isn't as sensitive. It's much more likely to match one of the previous 2 scroll event positions. So we kill any snapping as soon as there's a wheel event.\n\n\n  ScrollTrigger.isTouch && _addListener(scroller, \"touchmove\", getScroll.wheelHandler);\n  return getTween;\n};\n\nexport var ScrollTrigger = /*#__PURE__*/function () {\n  function ScrollTrigger(vars, animation) {\n    _coreInitted || ScrollTrigger.register(gsap) || console.warn(\"Please gsap.registerPlugin(ScrollTrigger)\");\n\n    _context(this);\n\n    this.init(vars, animation);\n  }\n\n  var _proto = ScrollTrigger.prototype;\n\n  _proto.init = function init(vars, animation) {\n    this.progress = this.start = 0;\n    this.vars && this.kill(true, true); // in case it's being initted again\n\n    if (!_enabled) {\n      this.update = this.refresh = this.kill = _passThrough;\n      return;\n    }\n\n    vars = _setDefaults(_isString(vars) || _isNumber(vars) || vars.nodeType ? {\n      trigger: vars\n    } : vars, _defaults);\n\n    var _vars = vars,\n        onUpdate = _vars.onUpdate,\n        toggleClass = _vars.toggleClass,\n        id = _vars.id,\n        onToggle = _vars.onToggle,\n        onRefresh = _vars.onRefresh,\n        scrub = _vars.scrub,\n        trigger = _vars.trigger,\n        pin = _vars.pin,\n        pinSpacing = _vars.pinSpacing,\n        invalidateOnRefresh = _vars.invalidateOnRefresh,\n        anticipatePin = _vars.anticipatePin,\n        onScrubComplete = _vars.onScrubComplete,\n        onSnapComplete = _vars.onSnapComplete,\n        once = _vars.once,\n        snap = _vars.snap,\n        pinReparent = _vars.pinReparent,\n        pinSpacer = _vars.pinSpacer,\n        containerAnimation = _vars.containerAnimation,\n        fastScrollEnd = _vars.fastScrollEnd,\n        preventOverlaps = _vars.preventOverlaps,\n        direction = vars.horizontal || vars.containerAnimation && vars.horizontal !== false ? _horizontal : _vertical,\n        isToggle = !scrub && scrub !== 0,\n        scroller = _getTarget(vars.scroller || _win),\n        scrollerCache = gsap.core.getCache(scroller),\n        isViewport = _isViewport(scroller),\n        useFixedPosition = (\"pinType\" in vars ? vars.pinType : _getProxyProp(scroller, \"pinType\") || isViewport && \"fixed\") === \"fixed\",\n        callbacks = [vars.onEnter, vars.onLeave, vars.onEnterBack, vars.onLeaveBack],\n        toggleActions = isToggle && vars.toggleActions.split(\" \"),\n        markers = \"markers\" in vars ? vars.markers : _defaults.markers,\n        borderWidth = isViewport ? 0 : parseFloat(_getComputedStyle(scroller)[\"border\" + direction.p2 + _Width]) || 0,\n        self = this,\n        onRefreshInit = vars.onRefreshInit && function () {\n      return vars.onRefreshInit(self);\n    },\n        getScrollerSize = _getSizeFunc(scroller, isViewport, direction),\n        getScrollerOffsets = _getOffsetsFunc(scroller, isViewport),\n        lastSnap = 0,\n        lastRefresh = 0,\n        prevProgress = 0,\n        scrollFunc = _getScrollFunc(scroller, direction),\n        tweenTo,\n        pinCache,\n        snapFunc,\n        scroll1,\n        scroll2,\n        start,\n        end,\n        markerStart,\n        markerEnd,\n        markerStartTrigger,\n        markerEndTrigger,\n        markerVars,\n        executingOnRefresh,\n        change,\n        pinOriginalState,\n        pinActiveState,\n        pinState,\n        spacer,\n        offset,\n        pinGetter,\n        pinSetter,\n        pinStart,\n        pinChange,\n        spacingStart,\n        spacerState,\n        markerStartSetter,\n        pinMoves,\n        markerEndSetter,\n        cs,\n        snap1,\n        snap2,\n        scrubTween,\n        scrubSmooth,\n        snapDurClamp,\n        snapDelayedCall,\n        prevScroll,\n        prevAnimProgress,\n        caMarkerSetter,\n        customRevertReturn; // for the sake of efficiency, _startClamp/_endClamp serve like a truthy value indicating that clamping was enabled on the start/end, and ALSO store the actual pre-clamped numeric value. We tap into that in ScrollSmoother for speed effects. So for example, if start=\"clamp(top bottom)\" results in a start of -100 naturally, it would get clamped to 0 but -100 would be stored in _startClamp.\n\n\n    self._startClamp = self._endClamp = false;\n    self._dir = direction;\n    anticipatePin *= 45;\n    self.scroller = scroller;\n    self.scroll = containerAnimation ? containerAnimation.time.bind(containerAnimation) : scrollFunc;\n    scroll1 = scrollFunc();\n    self.vars = vars;\n    animation = animation || vars.animation;\n\n    if (\"refreshPriority\" in vars) {\n      _sort = 1;\n      vars.refreshPriority === -9999 && (_primary = self); // used by ScrollSmoother\n    }\n\n    scrollerCache.tweenScroll = scrollerCache.tweenScroll || {\n      top: _getTweenCreator(scroller, _vertical),\n      left: _getTweenCreator(scroller, _horizontal)\n    };\n    self.tweenTo = tweenTo = scrollerCache.tweenScroll[direction.p];\n\n    self.scrubDuration = function (value) {\n      scrubSmooth = _isNumber(value) && value;\n\n      if (!scrubSmooth) {\n        scrubTween && scrubTween.progress(1).kill();\n        scrubTween = 0;\n      } else {\n        scrubTween ? scrubTween.duration(value) : scrubTween = gsap.to(animation, {\n          ease: \"expo\",\n          totalProgress: \"+=0\",\n          inherit: false,\n          duration: scrubSmooth,\n          paused: true,\n          onComplete: function onComplete() {\n            return onScrubComplete && onScrubComplete(self);\n          }\n        });\n      }\n    };\n\n    if (animation) {\n      animation.vars.lazy = false;\n      animation._initted && !self.isReverted || animation.vars.immediateRender !== false && vars.immediateRender !== false && animation.duration() && animation.render(0, true, true); // special case: if this ScrollTrigger gets re-initted, a from() tween with a stagger could get initted initially and then reverted on the re-init which means it'll need to get rendered again here to properly display things. Otherwise, See https://gsap.com/forums/topic/36777-scrollsmoother-splittext-nextjs/ and https://codepen.io/GreenSock/pen/eYPyPpd?editors=0010\n\n      self.animation = animation.pause();\n      animation.scrollTrigger = self;\n      self.scrubDuration(scrub);\n      snap1 = 0;\n      id || (id = animation.vars.id);\n    }\n\n    if (snap) {\n      // TODO: potential idea: use legitimate CSS scroll snapping by pushing invisible elements into the DOM that serve as snap positions, and toggle the document.scrollingElement.style.scrollSnapType onToggle. See https://codepen.io/GreenSock/pen/JjLrgWM for a quick proof of concept.\n      if (!_isObject(snap) || snap.push) {\n        snap = {\n          snapTo: snap\n        };\n      }\n\n      \"scrollBehavior\" in _body.style && gsap.set(isViewport ? [_body, _docEl] : scroller, {\n        scrollBehavior: \"auto\"\n      }); // smooth scrolling doesn't work with snap.\n\n      _scrollers.forEach(function (o) {\n        return _isFunction(o) && o.target === (isViewport ? _doc.scrollingElement || _docEl : scroller) && (o.smooth = false);\n      }); // note: set smooth to false on both the vertical and horizontal scroll getters/setters\n\n\n      snapFunc = _isFunction(snap.snapTo) ? snap.snapTo : snap.snapTo === \"labels\" ? _getClosestLabel(animation) : snap.snapTo === \"labelsDirectional\" ? _getLabelAtDirection(animation) : snap.directional !== false ? function (value, st) {\n        return _snapDirectional(snap.snapTo)(value, _getTime() - lastRefresh < 500 ? 0 : st.direction);\n      } : gsap.utils.snap(snap.snapTo);\n      snapDurClamp = snap.duration || {\n        min: 0.1,\n        max: 2\n      };\n      snapDurClamp = _isObject(snapDurClamp) ? _clamp(snapDurClamp.min, snapDurClamp.max) : _clamp(snapDurClamp, snapDurClamp);\n      snapDelayedCall = gsap.delayedCall(snap.delay || scrubSmooth / 2 || 0.1, function () {\n        var scroll = scrollFunc(),\n            refreshedRecently = _getTime() - lastRefresh < 500,\n            tween = tweenTo.tween;\n\n        if ((refreshedRecently || Math.abs(self.getVelocity()) < 10) && !tween && !_pointerIsDown && lastSnap !== scroll) {\n          var progress = (scroll - start) / change,\n              totalProgress = animation && !isToggle ? animation.totalProgress() : progress,\n              velocity = refreshedRecently ? 0 : (totalProgress - snap2) / (_getTime() - _time2) * 1000 || 0,\n              change1 = gsap.utils.clamp(-progress, 1 - progress, _abs(velocity / 2) * velocity / 0.185),\n              naturalEnd = progress + (snap.inertia === false ? 0 : change1),\n              endValue,\n              endScroll,\n              _snap = snap,\n              onStart = _snap.onStart,\n              _onInterrupt = _snap.onInterrupt,\n              _onComplete = _snap.onComplete;\n          endValue = snapFunc(naturalEnd, self);\n          _isNumber(endValue) || (endValue = naturalEnd); // in case the function didn't return a number, fall back to using the naturalEnd\n\n          endScroll = Math.round(start + endValue * change);\n\n          if (scroll <= end && scroll >= start && endScroll !== scroll) {\n            if (tween && !tween._initted && tween.data <= _abs(endScroll - scroll)) {\n              // there's an overlapping snap! So we must figure out which one is closer and let that tween live.\n              return;\n            }\n\n            if (snap.inertia === false) {\n              change1 = endValue - progress;\n            }\n\n            tweenTo(endScroll, {\n              duration: snapDurClamp(_abs(Math.max(_abs(naturalEnd - totalProgress), _abs(endValue - totalProgress)) * 0.185 / velocity / 0.05 || 0)),\n              ease: snap.ease || \"power3\",\n              data: _abs(endScroll - scroll),\n              // record the distance so that if another snap tween occurs (conflict) we can prioritize the closest snap.\n              onInterrupt: function onInterrupt() {\n                return snapDelayedCall.restart(true) && _onInterrupt && _onInterrupt(self);\n              },\n              onComplete: function onComplete() {\n                self.update();\n                lastSnap = scrollFunc();\n\n                if (animation) {\n                  // the resolution of the scrollbar is limited, so we should correct the scrubbed animation's playhead at the end to match EXACTLY where it was supposed to snap\n                  scrubTween ? scrubTween.resetTo(\"totalProgress\", endValue, animation._tTime / animation._tDur) : animation.progress(endValue);\n                }\n\n                snap1 = snap2 = animation && !isToggle ? animation.totalProgress() : self.progress;\n                onSnapComplete && onSnapComplete(self);\n                _onComplete && _onComplete(self);\n              }\n            }, scroll, change1 * change, endScroll - scroll - change1 * change);\n            onStart && onStart(self, tweenTo.tween);\n          }\n        } else if (self.isActive && lastSnap !== scroll) {\n          snapDelayedCall.restart(true);\n        }\n      }).pause();\n    }\n\n    id && (_ids[id] = self);\n    trigger = self.trigger = _getTarget(trigger || pin !== true && pin); // if a trigger has some kind of scroll-related effect applied that could contaminate the \"y\" or \"x\" position (like a ScrollSmoother effect), we needed a way to temporarily revert it, so we use the stRevert property of the gsCache. It can return another function that we'll call at the end so it can return to its normal state.\n\n    customRevertReturn = trigger && trigger._gsap && trigger._gsap.stRevert;\n    customRevertReturn && (customRevertReturn = customRevertReturn(self));\n    pin = pin === true ? trigger : _getTarget(pin);\n    _isString(toggleClass) && (toggleClass = {\n      targets: trigger,\n      className: toggleClass\n    });\n\n    if (pin) {\n      pinSpacing === false || pinSpacing === _margin || (pinSpacing = !pinSpacing && pin.parentNode && pin.parentNode.style && _getComputedStyle(pin.parentNode).display === \"flex\" ? false : _padding); // if the parent is display: flex, don't apply pinSpacing by default. We should check that pin.parentNode is an element (not shadow dom window)\n\n      self.pin = pin;\n      pinCache = gsap.core.getCache(pin);\n\n      if (!pinCache.spacer) {\n        // record the spacer and pinOriginalState on the cache in case someone tries pinning the same element with MULTIPLE ScrollTriggers - we don't want to have multiple spacers or record the \"original\" pin state after it has already been affected by another ScrollTrigger.\n        if (pinSpacer) {\n          pinSpacer = _getTarget(pinSpacer);\n          pinSpacer && !pinSpacer.nodeType && (pinSpacer = pinSpacer.current || pinSpacer.nativeElement); // for React & Angular\n\n          pinCache.spacerIsNative = !!pinSpacer;\n          pinSpacer && (pinCache.spacerState = _getState(pinSpacer));\n        }\n\n        pinCache.spacer = spacer = pinSpacer || _doc.createElement(\"div\");\n        spacer.classList.add(\"pin-spacer\");\n        id && spacer.classList.add(\"pin-spacer-\" + id);\n        pinCache.pinState = pinOriginalState = _getState(pin);\n      } else {\n        pinOriginalState = pinCache.pinState;\n      }\n\n      vars.force3D !== false && gsap.set(pin, {\n        force3D: true\n      });\n      self.spacer = spacer = pinCache.spacer;\n      cs = _getComputedStyle(pin);\n      spacingStart = cs[pinSpacing + direction.os2];\n      pinGetter = gsap.getProperty(pin);\n      pinSetter = gsap.quickSetter(pin, direction.a, _px); // pin.firstChild && !_maxScroll(pin, direction) && (pin.style.overflow = \"hidden\"); // protects from collapsing margins, but can have unintended consequences as demonstrated here: https://codepen.io/GreenSock/pen/1e42c7a73bfa409d2cf1e184e7a4248d so it was removed in favor of just telling people to set up their CSS to avoid the collapsing margins (overflow: hidden | auto is just one option. Another is border-top: 1px solid transparent).\n\n      _swapPinIn(pin, spacer, cs);\n\n      pinState = _getState(pin);\n    }\n\n    if (markers) {\n      markerVars = _isObject(markers) ? _setDefaults(markers, _markerDefaults) : _markerDefaults;\n      markerStartTrigger = _createMarker(\"scroller-start\", id, scroller, direction, markerVars, 0);\n      markerEndTrigger = _createMarker(\"scroller-end\", id, scroller, direction, markerVars, 0, markerStartTrigger);\n      offset = markerStartTrigger[\"offset\" + direction.op.d2];\n\n      var content = _getTarget(_getProxyProp(scroller, \"content\") || scroller);\n\n      markerStart = this.markerStart = _createMarker(\"start\", id, content, direction, markerVars, offset, 0, containerAnimation);\n      markerEnd = this.markerEnd = _createMarker(\"end\", id, content, direction, markerVars, offset, 0, containerAnimation);\n      containerAnimation && (caMarkerSetter = gsap.quickSetter([markerStart, markerEnd], direction.a, _px));\n\n      if (!useFixedPosition && !(_proxies.length && _getProxyProp(scroller, \"fixedMarkers\") === true)) {\n        _makePositionable(isViewport ? _body : scroller);\n\n        gsap.set([markerStartTrigger, markerEndTrigger], {\n          force3D: true\n        });\n        markerStartSetter = gsap.quickSetter(markerStartTrigger, direction.a, _px);\n        markerEndSetter = gsap.quickSetter(markerEndTrigger, direction.a, _px);\n      }\n    }\n\n    if (containerAnimation) {\n      var oldOnUpdate = containerAnimation.vars.onUpdate,\n          oldParams = containerAnimation.vars.onUpdateParams;\n      containerAnimation.eventCallback(\"onUpdate\", function () {\n        self.update(0, 0, 1);\n        oldOnUpdate && oldOnUpdate.apply(containerAnimation, oldParams || []);\n      });\n    }\n\n    self.previous = function () {\n      return _triggers[_triggers.indexOf(self) - 1];\n    };\n\n    self.next = function () {\n      return _triggers[_triggers.indexOf(self) + 1];\n    };\n\n    self.revert = function (revert, temp) {\n      if (!temp) {\n        return self.kill(true);\n      } // for compatibility with gsap.context() and gsap.matchMedia() which call revert()\n\n\n      var r = revert !== false || !self.enabled,\n          prevRefreshing = _refreshing;\n\n      if (r !== self.isReverted) {\n        if (r) {\n          prevScroll = Math.max(scrollFunc(), self.scroll.rec || 0); // record the scroll so we can revert later (repositioning/pinning things can affect scroll position). In the static refresh() method, we first record all the scroll positions as a reference.\n\n          prevProgress = self.progress;\n          prevAnimProgress = animation && animation.progress();\n        }\n\n        markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {\n          return m.style.display = r ? \"none\" : \"block\";\n        });\n\n        if (r) {\n          _refreshing = self;\n          self.update(r); // make sure the pin is back in its original position so that all the measurements are correct. do this BEFORE swapping the pin out\n        }\n\n        if (pin && (!pinReparent || !self.isActive)) {\n          if (r) {\n            _swapPinOut(pin, spacer, pinOriginalState);\n          } else {\n            _swapPinIn(pin, spacer, _getComputedStyle(pin), spacerState);\n          }\n        }\n\n        r || self.update(r); // when we're restoring, the update should run AFTER swapping the pin into its pin-spacer.\n\n        _refreshing = prevRefreshing; // restore. We set it to true during the update() so that things fire properly in there.\n\n        self.isReverted = r;\n      }\n    };\n\n    self.refresh = function (soft, force, position, pinOffset) {\n      // position is typically only defined if it's coming from setPositions() - it's a way to skip the normal parsing. pinOffset is also only from setPositions() and is mostly related to fancy stuff we need to do in ScrollSmoother with effects\n      if ((_refreshing || !self.enabled) && !force) {\n        return;\n      }\n\n      if (pin && soft && _lastScrollTime) {\n        _addListener(ScrollTrigger, \"scrollEnd\", _softRefresh);\n\n        return;\n      }\n\n      !_refreshingAll && onRefreshInit && onRefreshInit(self);\n      _refreshing = self;\n\n      if (tweenTo.tween && !position) {\n        // we skip this if a position is passed in because typically that's from .setPositions() and it's best to allow in-progress snapping to continue.\n        tweenTo.tween.kill();\n        tweenTo.tween = 0;\n      }\n\n      scrubTween && scrubTween.pause();\n      invalidateOnRefresh && animation && animation.revert({\n        kill: false\n      }).invalidate();\n      self.isReverted || self.revert(true, true);\n      self._subPinOffset = false; // we'll set this to true in the sub-pins if we find any\n\n      var size = getScrollerSize(),\n          scrollerBounds = getScrollerOffsets(),\n          max = containerAnimation ? containerAnimation.duration() : _maxScroll(scroller, direction),\n          isFirstRefresh = change <= 0.01,\n          offset = 0,\n          otherPinOffset = pinOffset || 0,\n          parsedEnd = _isObject(position) ? position.end : vars.end,\n          parsedEndTrigger = vars.endTrigger || trigger,\n          parsedStart = _isObject(position) ? position.start : vars.start || (vars.start === 0 || !trigger ? 0 : pin ? \"0 0\" : \"0 100%\"),\n          pinnedContainer = self.pinnedContainer = vars.pinnedContainer && _getTarget(vars.pinnedContainer, self),\n          triggerIndex = trigger && Math.max(0, _triggers.indexOf(self)) || 0,\n          i = triggerIndex,\n          cs,\n          bounds,\n          scroll,\n          isVertical,\n          override,\n          curTrigger,\n          curPin,\n          oppositeScroll,\n          initted,\n          revertedPins,\n          forcedOverflow,\n          markerStartOffset,\n          markerEndOffset;\n\n      if (markers && _isObject(position)) {\n        // if we alter the start/end positions with .setPositions(), it generally feeds in absolute NUMBERS which don't convey information about where to line up the markers, so to keep it intuitive, we record how far the trigger positions shift after applying the new numbers and then offset by that much in the opposite direction. We do the same to the associated trigger markers too of course.\n        markerStartOffset = gsap.getProperty(markerStartTrigger, direction.p);\n        markerEndOffset = gsap.getProperty(markerEndTrigger, direction.p);\n      }\n\n      while (i--) {\n        // user might try to pin the same element more than once, so we must find any prior triggers with the same pin, revert them, and determine how long they're pinning so that we can offset things appropriately. Make sure we revert from last to first so that things \"rewind\" properly.\n        curTrigger = _triggers[i];\n        curTrigger.end || curTrigger.refresh(0, 1) || (_refreshing = self); // if it's a timeline-based trigger that hasn't been fully initialized yet because it's waiting for 1 tick, just force the refresh() here, otherwise if it contains a pin that's supposed to affect other ScrollTriggers further down the page, they won't be adjusted properly.\n\n        curPin = curTrigger.pin;\n\n        if (curPin && (curPin === trigger || curPin === pin || curPin === pinnedContainer) && !curTrigger.isReverted) {\n          revertedPins || (revertedPins = []);\n          revertedPins.unshift(curTrigger); // we'll revert from first to last to make sure things reach their end state properly\n\n          curTrigger.revert(true, true);\n        }\n\n        if (curTrigger !== _triggers[i]) {\n          // in case it got removed.\n          triggerIndex--;\n          i--;\n        }\n      }\n\n      _isFunction(parsedStart) && (parsedStart = parsedStart(self));\n      parsedStart = _parseClamp(parsedStart, \"start\", self);\n      start = _parsePosition(parsedStart, trigger, size, direction, scrollFunc(), markerStart, markerStartTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._startClamp && \"_startClamp\") || (pin ? -0.001 : 0);\n      _isFunction(parsedEnd) && (parsedEnd = parsedEnd(self));\n\n      if (_isString(parsedEnd) && !parsedEnd.indexOf(\"+=\")) {\n        if (~parsedEnd.indexOf(\" \")) {\n          parsedEnd = (_isString(parsedStart) ? parsedStart.split(\" \")[0] : \"\") + parsedEnd;\n        } else {\n          offset = _offsetToPx(parsedEnd.substr(2), size);\n          parsedEnd = _isString(parsedStart) ? parsedStart : (containerAnimation ? gsap.utils.mapRange(0, containerAnimation.duration(), containerAnimation.scrollTrigger.start, containerAnimation.scrollTrigger.end, start) : start) + offset; // _parsePosition won't factor in the offset if the start is a number, so do it here.\n\n          parsedEndTrigger = trigger;\n        }\n      }\n\n      parsedEnd = _parseClamp(parsedEnd, \"end\", self);\n      end = Math.max(start, _parsePosition(parsedEnd || (parsedEndTrigger ? \"100% 0\" : max), parsedEndTrigger, size, direction, scrollFunc() + offset, markerEnd, markerEndTrigger, self, scrollerBounds, borderWidth, useFixedPosition, max, containerAnimation, self._endClamp && \"_endClamp\")) || -0.001;\n      offset = 0;\n      i = triggerIndex;\n\n      while (i--) {\n        curTrigger = _triggers[i];\n        curPin = curTrigger.pin;\n\n        if (curPin && curTrigger.start - curTrigger._pinPush <= start && !containerAnimation && curTrigger.end > 0) {\n          cs = curTrigger.end - (self._startClamp ? Math.max(0, curTrigger.start) : curTrigger.start);\n\n          if ((curPin === trigger && curTrigger.start - curTrigger._pinPush < start || curPin === pinnedContainer) && isNaN(parsedStart)) {\n            // numeric start values shouldn't be offset at all - treat them as absolute\n            offset += cs * (1 - curTrigger.progress);\n          }\n\n          curPin === pin && (otherPinOffset += cs);\n        }\n      }\n\n      start += offset;\n      end += offset;\n      self._startClamp && (self._startClamp += offset);\n\n      if (self._endClamp && !_refreshingAll) {\n        self._endClamp = end || -0.001;\n        end = Math.min(end, _maxScroll(scroller, direction));\n      }\n\n      change = end - start || (start -= 0.01) && 0.001;\n\n      if (isFirstRefresh) {\n        // on the very first refresh(), the prevProgress couldn't have been accurate yet because the start/end were never calculated, so we set it here. Before 3.11.5, it could lead to an inaccurate scroll position restoration with snapping.\n        prevProgress = gsap.utils.clamp(0, 1, gsap.utils.normalize(start, end, prevScroll));\n      }\n\n      self._pinPush = otherPinOffset;\n\n      if (markerStart && offset) {\n        // offset the markers if necessary\n        cs = {};\n        cs[direction.a] = \"+=\" + offset;\n        pinnedContainer && (cs[direction.p] = \"-=\" + scrollFunc());\n        gsap.set([markerStart, markerEnd], cs);\n      }\n\n      if (pin && !(_clampingMax && self.end >= _maxScroll(scroller, direction))) {\n        cs = _getComputedStyle(pin);\n        isVertical = direction === _vertical;\n        scroll = scrollFunc(); // recalculate because the triggers can affect the scroll\n\n        pinStart = parseFloat(pinGetter(direction.a)) + otherPinOffset;\n\n        if (!max && end > 1) {\n          // makes sure the scroller has a scrollbar, otherwise if something has width: 100%, for example, it would be too big (exclude the scrollbar). See https://gsap.com/forums/topic/25182-scrolltrigger-width-of-page-increase-where-markers-are-set-to-false/\n          forcedOverflow = (isViewport ? _doc.scrollingElement || _docEl : scroller).style;\n          forcedOverflow = {\n            style: forcedOverflow,\n            value: forcedOverflow[\"overflow\" + direction.a.toUpperCase()]\n          };\n\n          if (isViewport && _getComputedStyle(_body)[\"overflow\" + direction.a.toUpperCase()] !== \"scroll\") {\n            // avoid an extra scrollbar if BOTH <html> and <body> have overflow set to \"scroll\"\n            forcedOverflow.style[\"overflow\" + direction.a.toUpperCase()] = \"scroll\";\n          }\n        }\n\n        _swapPinIn(pin, spacer, cs);\n\n        pinState = _getState(pin); // transforms will interfere with the top/left/right/bottom placement, so remove them temporarily. getBoundingClientRect() factors in transforms.\n\n        bounds = _getBounds(pin, true);\n        oppositeScroll = useFixedPosition && _getScrollFunc(scroller, isVertical ? _horizontal : _vertical)();\n\n        if (pinSpacing) {\n          spacerState = [pinSpacing + direction.os2, change + otherPinOffset + _px];\n          spacerState.t = spacer;\n          i = pinSpacing === _padding ? _getSize(pin, direction) + change + otherPinOffset : 0;\n\n          if (i) {\n            spacerState.push(direction.d, i + _px); // for box-sizing: border-box (must include padding).\n\n            spacer.style.flexBasis !== \"auto\" && (spacer.style.flexBasis = i + _px);\n          }\n\n          _setState(spacerState);\n\n          if (pinnedContainer) {\n            // in ScrollTrigger.refresh(), we need to re-evaluate the pinContainer's size because this pinSpacing may stretch it out, but we can't just add the exact distance because depending on layout, it may not push things down or it may only do so partially.\n            _triggers.forEach(function (t) {\n              if (t.pin === pinnedContainer && t.vars.pinSpacing !== false) {\n                t._subPinOffset = true;\n              }\n            });\n          }\n\n          useFixedPosition && scrollFunc(prevScroll);\n        } else {\n          i = _getSize(pin, direction);\n          i && spacer.style.flexBasis !== \"auto\" && (spacer.style.flexBasis = i + _px);\n        }\n\n        if (useFixedPosition) {\n          override = {\n            top: bounds.top + (isVertical ? scroll - start : oppositeScroll) + _px,\n            left: bounds.left + (isVertical ? oppositeScroll : scroll - start) + _px,\n            boxSizing: \"border-box\",\n            position: \"fixed\"\n          };\n          override[_width] = override[\"max\" + _Width] = Math.ceil(bounds.width) + _px;\n          override[_height] = override[\"max\" + _Height] = Math.ceil(bounds.height) + _px;\n          override[_margin] = override[_margin + _Top] = override[_margin + _Right] = override[_margin + _Bottom] = override[_margin + _Left] = \"0\";\n          override[_padding] = cs[_padding];\n          override[_padding + _Top] = cs[_padding + _Top];\n          override[_padding + _Right] = cs[_padding + _Right];\n          override[_padding + _Bottom] = cs[_padding + _Bottom];\n          override[_padding + _Left] = cs[_padding + _Left];\n          pinActiveState = _copyState(pinOriginalState, override, pinReparent);\n          _refreshingAll && scrollFunc(0);\n        }\n\n        if (animation) {\n          // the animation might be affecting the transform, so we must jump to the end, check the value, and compensate accordingly. Otherwise, when it becomes unpinned, the pinSetter() will get set to a value that doesn't include whatever the animation did.\n          initted = animation._initted; // if not, we must invalidate() after this step, otherwise it could lock in starting values prematurely.\n\n          _suppressOverwrites(1);\n\n          animation.render(animation.duration(), true, true);\n          pinChange = pinGetter(direction.a) - pinStart + change + otherPinOffset;\n          pinMoves = Math.abs(change - pinChange) > 1;\n          useFixedPosition && pinMoves && pinActiveState.splice(pinActiveState.length - 2, 2); // transform is the last property/value set in the state Array. Since the animation is controlling that, we should omit it.\n\n          animation.render(0, true, true);\n          initted || animation.invalidate(true);\n          animation.parent || animation.totalTime(animation.totalTime()); // if, for example, a toggleAction called play() and then refresh() happens and when we render(1) above, it would cause the animation to complete and get removed from its parent, so this makes sure it gets put back in.\n\n          _suppressOverwrites(0);\n        } else {\n          pinChange = change;\n        }\n\n        forcedOverflow && (forcedOverflow.value ? forcedOverflow.style[\"overflow\" + direction.a.toUpperCase()] = forcedOverflow.value : forcedOverflow.style.removeProperty(\"overflow-\" + direction.a));\n      } else if (trigger && scrollFunc() && !containerAnimation) {\n        // it may be INSIDE a pinned element, so walk up the tree and look for any elements with _pinOffset to compensate because anything with pinSpacing that's already scrolled would throw off the measurements in getBoundingClientRect()\n        bounds = trigger.parentNode;\n\n        while (bounds && bounds !== _body) {\n          if (bounds._pinOffset) {\n            start -= bounds._pinOffset;\n            end -= bounds._pinOffset;\n          }\n\n          bounds = bounds.parentNode;\n        }\n      }\n\n      revertedPins && revertedPins.forEach(function (t) {\n        return t.revert(false, true);\n      });\n      self.start = start;\n      self.end = end;\n      scroll1 = scroll2 = _refreshingAll ? prevScroll : scrollFunc(); // reset velocity\n\n      if (!containerAnimation && !_refreshingAll) {\n        scroll1 < prevScroll && scrollFunc(prevScroll);\n        self.scroll.rec = 0;\n      }\n\n      self.revert(false, true);\n      lastRefresh = _getTime();\n\n      if (snapDelayedCall) {\n        lastSnap = -1; // just so snapping gets re-enabled, clear out any recorded last value\n        // self.isActive && scrollFunc(start + change * prevProgress); // previously this line was here to ensure that when snapping kicks in, it's from the previous progress but in some cases that's not desirable, like an all-page ScrollTrigger when new content gets added to the page, that'd totally change the progress.\n\n        snapDelayedCall.restart(true);\n      }\n\n      _refreshing = 0;\n      animation && isToggle && (animation._initted || prevAnimProgress) && animation.progress() !== prevAnimProgress && animation.progress(prevAnimProgress || 0, true).render(animation.time(), true, true); // must force a re-render because if saveStyles() was used on the target(s), the styles could have been wiped out during the refresh().\n\n      if (isFirstRefresh || prevProgress !== self.progress || containerAnimation || invalidateOnRefresh) {\n        // ensures that the direction is set properly (when refreshing, progress is set back to 0 initially, then back again to wherever it needs to be) and that callbacks are triggered.\n        animation && !isToggle && animation.totalProgress(containerAnimation && start < -0.001 && !prevProgress ? gsap.utils.normalize(start, end, 0) : prevProgress, true); // to avoid issues where animation callbacks like onStart aren't triggered.\n\n        self.progress = isFirstRefresh || (scroll1 - start) / change === prevProgress ? 0 : prevProgress;\n      }\n\n      pin && pinSpacing && (spacer._pinOffset = Math.round(self.progress * pinChange));\n      scrubTween && scrubTween.invalidate();\n\n      if (!isNaN(markerStartOffset)) {\n        // numbers were passed in for the position which are absolute, so instead of just putting the markers at the very bottom of the viewport, we figure out how far they shifted down (it's safe to assume they were originally positioned in closer relation to the trigger element with values like \"top\", \"center\", a percentage or whatever, so we offset that much in the opposite direction to basically revert them to the relative position thy were at previously.\n        markerStartOffset -= gsap.getProperty(markerStartTrigger, direction.p);\n        markerEndOffset -= gsap.getProperty(markerEndTrigger, direction.p);\n\n        _shiftMarker(markerStartTrigger, direction, markerStartOffset);\n\n        _shiftMarker(markerStart, direction, markerStartOffset - (pinOffset || 0));\n\n        _shiftMarker(markerEndTrigger, direction, markerEndOffset);\n\n        _shiftMarker(markerEnd, direction, markerEndOffset - (pinOffset || 0));\n      }\n\n      isFirstRefresh && !_refreshingAll && self.update(); // edge case - when you reload a page when it's already scrolled down, some browsers fire a \"scroll\" event before DOMContentLoaded, triggering an updateAll(). If we don't update the self.progress as part of refresh(), then when it happens next, it may record prevProgress as 0 when it really shouldn't, potentially causing a callback in an animation to fire again.\n\n      if (onRefresh && !_refreshingAll && !executingOnRefresh) {\n        // when refreshing all, we do extra work to correct pinnedContainer sizes and ensure things don't exceed the maxScroll, so we should do all the refreshes at the end after all that work so that the start/end values are corrected.\n        executingOnRefresh = true;\n        onRefresh(self);\n        executingOnRefresh = false;\n      }\n    };\n\n    self.getVelocity = function () {\n      return (scrollFunc() - scroll2) / (_getTime() - _time2) * 1000 || 0;\n    };\n\n    self.endAnimation = function () {\n      _endAnimation(self.callbackAnimation);\n\n      if (animation) {\n        scrubTween ? scrubTween.progress(1) : !animation.paused() ? _endAnimation(animation, animation.reversed()) : isToggle || _endAnimation(animation, self.direction < 0, 1);\n      }\n    };\n\n    self.labelToScroll = function (label) {\n      return animation && animation.labels && (start || self.refresh() || start) + animation.labels[label] / animation.duration() * change || 0;\n    };\n\n    self.getTrailing = function (name) {\n      var i = _triggers.indexOf(self),\n          a = self.direction > 0 ? _triggers.slice(0, i).reverse() : _triggers.slice(i + 1);\n\n      return (_isString(name) ? a.filter(function (t) {\n        return t.vars.preventOverlaps === name;\n      }) : a).filter(function (t) {\n        return self.direction > 0 ? t.end <= start : t.start >= end;\n      });\n    };\n\n    self.update = function (reset, recordVelocity, forceFake) {\n      if (containerAnimation && !forceFake && !reset) {\n        return;\n      }\n\n      var scroll = _refreshingAll === true ? prevScroll : self.scroll(),\n          p = reset ? 0 : (scroll - start) / change,\n          clipped = p < 0 ? 0 : p > 1 ? 1 : p || 0,\n          prevProgress = self.progress,\n          isActive,\n          wasActive,\n          toggleState,\n          action,\n          stateChanged,\n          toggled,\n          isAtMax,\n          isTakingAction;\n\n      if (recordVelocity) {\n        scroll2 = scroll1;\n        scroll1 = containerAnimation ? scrollFunc() : scroll;\n\n        if (snap) {\n          snap2 = snap1;\n          snap1 = animation && !isToggle ? animation.totalProgress() : clipped;\n        }\n      } // anticipate the pinning a few ticks ahead of time based on velocity to avoid a visual glitch due to the fact that most browsers do scrolling on a separate thread (not synced with requestAnimationFrame).\n\n\n      if (anticipatePin && pin && !_refreshing && !_startup && _lastScrollTime) {\n        if (!clipped && start < scroll + (scroll - scroll2) / (_getTime() - _time2) * anticipatePin) {\n          clipped = 0.0001;\n        } else if (clipped === 1 && end > scroll + (scroll - scroll2) / (_getTime() - _time2) * anticipatePin) {\n          clipped = 0.9999;\n        }\n      }\n\n      if (clipped !== prevProgress && self.enabled) {\n        isActive = self.isActive = !!clipped && clipped < 1;\n        wasActive = !!prevProgress && prevProgress < 1;\n        toggled = isActive !== wasActive;\n        stateChanged = toggled || !!clipped !== !!prevProgress; // could go from start all the way to end, thus it didn't toggle but it did change state in a sense (may need to fire a callback)\n\n        self.direction = clipped > prevProgress ? 1 : -1;\n        self.progress = clipped;\n\n        if (stateChanged && !_refreshing) {\n          toggleState = clipped && !prevProgress ? 0 : clipped === 1 ? 1 : prevProgress === 1 ? 2 : 3; // 0 = enter, 1 = leave, 2 = enterBack, 3 = leaveBack (we prioritize the FIRST encounter, thus if you scroll really fast past the onEnter and onLeave in one tick, it'd prioritize onEnter.\n\n          if (isToggle) {\n            action = !toggled && toggleActions[toggleState + 1] !== \"none\" && toggleActions[toggleState + 1] || toggleActions[toggleState]; // if it didn't toggle, that means it shot right past and since we prioritize the \"enter\" action, we should switch to the \"leave\" in this case (but only if one is defined)\n\n            isTakingAction = animation && (action === \"complete\" || action === \"reset\" || action in animation);\n          }\n        }\n\n        preventOverlaps && (toggled || isTakingAction) && (isTakingAction || scrub || !animation) && (_isFunction(preventOverlaps) ? preventOverlaps(self) : self.getTrailing(preventOverlaps).forEach(function (t) {\n          return t.endAnimation();\n        }));\n\n        if (!isToggle) {\n          if (scrubTween && !_refreshing && !_startup) {\n            scrubTween._dp._time - scrubTween._start !== scrubTween._time && scrubTween.render(scrubTween._dp._time - scrubTween._start); // if there's a scrub on both the container animation and this one (or a ScrollSmoother), the update order would cause this one not to have rendered yet, so it wouldn't make any progress before we .restart() it heading toward the new progress so it'd appear stuck thus we force a render here.\n\n            if (scrubTween.resetTo) {\n              scrubTween.resetTo(\"totalProgress\", clipped, animation._tTime / animation._tDur);\n            } else {\n              // legacy support (courtesy), before 3.10.0\n              scrubTween.vars.totalProgress = clipped;\n              scrubTween.invalidate().restart();\n            }\n          } else if (animation) {\n            animation.totalProgress(clipped, !!(_refreshing && (lastRefresh || reset)));\n          }\n        }\n\n        if (pin) {\n          reset && pinSpacing && (spacer.style[pinSpacing + direction.os2] = spacingStart);\n\n          if (!useFixedPosition) {\n            pinSetter(_round(pinStart + pinChange * clipped));\n          } else if (stateChanged) {\n            isAtMax = !reset && clipped > prevProgress && end + 1 > scroll && scroll + 1 >= _maxScroll(scroller, direction); // if it's at the VERY end of the page, don't switch away from position: fixed because it's pointless and it could cause a brief flash when the user scrolls back up (when it gets pinned again)\n\n            if (pinReparent) {\n              if (!reset && (isActive || isAtMax)) {\n                var bounds = _getBounds(pin, true),\n                    _offset = scroll - start;\n\n                _reparent(pin, _body, bounds.top + (direction === _vertical ? _offset : 0) + _px, bounds.left + (direction === _vertical ? 0 : _offset) + _px);\n              } else {\n                _reparent(pin, spacer);\n              }\n            }\n\n            _setState(isActive || isAtMax ? pinActiveState : pinState);\n\n            pinMoves && clipped < 1 && isActive || pinSetter(pinStart + (clipped === 1 && !isAtMax ? pinChange : 0));\n          }\n        }\n\n        snap && !tweenTo.tween && !_refreshing && !_startup && snapDelayedCall.restart(true);\n        toggleClass && (toggled || once && clipped && (clipped < 1 || !_limitCallbacks)) && _toArray(toggleClass.targets).forEach(function (el) {\n          return el.classList[isActive || once ? \"add\" : \"remove\"](toggleClass.className);\n        }); // classes could affect positioning, so do it even if reset or refreshing is true.\n\n        onUpdate && !isToggle && !reset && onUpdate(self);\n\n        if (stateChanged && !_refreshing) {\n          if (isToggle) {\n            if (isTakingAction) {\n              if (action === \"complete\") {\n                animation.pause().totalProgress(1);\n              } else if (action === \"reset\") {\n                animation.restart(true).pause();\n              } else if (action === \"restart\") {\n                animation.restart(true);\n              } else {\n                animation[action]();\n              }\n            }\n\n            onUpdate && onUpdate(self);\n          }\n\n          if (toggled || !_limitCallbacks) {\n            // on startup, the page could be scrolled and we don't want to fire callbacks that didn't toggle. For example onEnter shouldn't fire if the ScrollTrigger isn't actually entered.\n            onToggle && toggled && _callback(self, onToggle);\n            callbacks[toggleState] && _callback(self, callbacks[toggleState]);\n            once && (clipped === 1 ? self.kill(false, 1) : callbacks[toggleState] = 0); // a callback shouldn't be called again if once is true.\n\n            if (!toggled) {\n              // it's possible to go completely past, like from before the start to after the end (or vice-versa) in which case BOTH callbacks should be fired in that order\n              toggleState = clipped === 1 ? 1 : 3;\n              callbacks[toggleState] && _callback(self, callbacks[toggleState]);\n            }\n          }\n\n          if (fastScrollEnd && !isActive && Math.abs(self.getVelocity()) > (_isNumber(fastScrollEnd) ? fastScrollEnd : 2500)) {\n            _endAnimation(self.callbackAnimation);\n\n            scrubTween ? scrubTween.progress(1) : _endAnimation(animation, action === \"reverse\" ? 1 : !clipped, 1);\n          }\n        } else if (isToggle && onUpdate && !_refreshing) {\n          onUpdate(self);\n        }\n      } // update absolutely-positioned markers (only if the scroller isn't the viewport)\n\n\n      if (markerEndSetter) {\n        var n = containerAnimation ? scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0) : scroll;\n        markerStartSetter(n + (markerStartTrigger._isFlipped ? 1 : 0));\n        markerEndSetter(n);\n      }\n\n      caMarkerSetter && caMarkerSetter(-scroll / containerAnimation.duration() * (containerAnimation._caScrollDist || 0));\n    };\n\n    self.enable = function (reset, refresh) {\n      if (!self.enabled) {\n        self.enabled = true;\n\n        _addListener(scroller, \"resize\", _onResize);\n\n        isViewport || _addListener(scroller, \"scroll\", _onScroll);\n        onRefreshInit && _addListener(ScrollTrigger, \"refreshInit\", onRefreshInit);\n\n        if (reset !== false) {\n          self.progress = prevProgress = 0;\n          scroll1 = scroll2 = lastSnap = scrollFunc();\n        }\n\n        refresh !== false && self.refresh();\n      }\n    };\n\n    self.getTween = function (snap) {\n      return snap && tweenTo ? tweenTo.tween : scrubTween;\n    };\n\n    self.setPositions = function (newStart, newEnd, keepClamp, pinOffset) {\n      // doesn't persist after refresh()! Intended to be a way to override values that were set during refresh(), like you could set it in onRefresh()\n      if (containerAnimation) {\n        // convert ratios into scroll positions. Remember, start/end values on ScrollTriggers that have a containerAnimation refer to the time (in seconds), NOT scroll positions.\n        var st = containerAnimation.scrollTrigger,\n            duration = containerAnimation.duration(),\n            _change = st.end - st.start;\n\n        newStart = st.start + _change * newStart / duration;\n        newEnd = st.start + _change * newEnd / duration;\n      }\n\n      self.refresh(false, false, {\n        start: _keepClamp(newStart, keepClamp && !!self._startClamp),\n        end: _keepClamp(newEnd, keepClamp && !!self._endClamp)\n      }, pinOffset);\n      self.update();\n    };\n\n    self.adjustPinSpacing = function (amount) {\n      if (spacerState && amount) {\n        var i = spacerState.indexOf(direction.d) + 1;\n        spacerState[i] = parseFloat(spacerState[i]) + amount + _px;\n        spacerState[1] = parseFloat(spacerState[1]) + amount + _px;\n\n        _setState(spacerState);\n      }\n    };\n\n    self.disable = function (reset, allowAnimation) {\n      if (self.enabled) {\n        reset !== false && self.revert(true, true);\n        self.enabled = self.isActive = false;\n        allowAnimation || scrubTween && scrubTween.pause();\n        prevScroll = 0;\n        pinCache && (pinCache.uncache = 1);\n        onRefreshInit && _removeListener(ScrollTrigger, \"refreshInit\", onRefreshInit);\n\n        if (snapDelayedCall) {\n          snapDelayedCall.pause();\n          tweenTo.tween && tweenTo.tween.kill() && (tweenTo.tween = 0);\n        }\n\n        if (!isViewport) {\n          var i = _triggers.length;\n\n          while (i--) {\n            if (_triggers[i].scroller === scroller && _triggers[i] !== self) {\n              return; //don't remove the listeners if there are still other triggers referencing it.\n            }\n          }\n\n          _removeListener(scroller, \"resize\", _onResize);\n\n          isViewport || _removeListener(scroller, \"scroll\", _onScroll);\n        }\n      }\n    };\n\n    self.kill = function (revert, allowAnimation) {\n      self.disable(revert, allowAnimation);\n      scrubTween && !allowAnimation && scrubTween.kill();\n      id && delete _ids[id];\n\n      var i = _triggers.indexOf(self);\n\n      i >= 0 && _triggers.splice(i, 1);\n      i === _i && _direction > 0 && _i--; // if we're in the middle of a refresh() or update(), splicing would cause skips in the index, so adjust...\n      // if no other ScrollTrigger instances of the same scroller are found, wipe out any recorded scroll position. Otherwise, in a single page application, for example, it could maintain scroll position when it really shouldn't.\n\n      i = 0;\n\n      _triggers.forEach(function (t) {\n        return t.scroller === self.scroller && (i = 1);\n      });\n\n      i || _refreshingAll || (self.scroll.rec = 0);\n\n      if (animation) {\n        animation.scrollTrigger = null;\n        revert && animation.revert({\n          kill: false\n        });\n        allowAnimation || animation.kill();\n      }\n\n      markerStart && [markerStart, markerEnd, markerStartTrigger, markerEndTrigger].forEach(function (m) {\n        return m.parentNode && m.parentNode.removeChild(m);\n      });\n      _primary === self && (_primary = 0);\n\n      if (pin) {\n        pinCache && (pinCache.uncache = 1);\n        i = 0;\n\n        _triggers.forEach(function (t) {\n          return t.pin === pin && i++;\n        });\n\n        i || (pinCache.spacer = 0); // if there aren't any more ScrollTriggers with the same pin, remove the spacer, otherwise it could be contaminated with old/stale values if the user re-creates a ScrollTrigger for the same element.\n      }\n\n      vars.onKill && vars.onKill(self);\n    };\n\n    _triggers.push(self);\n\n    self.enable(false, false);\n    customRevertReturn && customRevertReturn(self);\n\n    if (animation && animation.add && !change) {\n      // if the animation is a timeline, it may not have been populated yet, so it wouldn't render at the proper place on the first refresh(), thus we should schedule one for the next tick. If \"change\" is defined, we know it must be re-enabling, thus we can refresh() right away.\n      var updateFunc = self.update; // some browsers may fire a scroll event BEFORE a tick elapses and/or the DOMContentLoaded fires. So there's a chance update() will be called BEFORE a refresh() has happened on a Timeline-attached ScrollTrigger which means the start/end won't be calculated yet. We don't want to add conditional logic inside the update() method (like check to see if end is defined and if not, force a refresh()) because that's a function that gets hit a LOT (performance). So we swap out the real update() method for this one that'll re-attach it the first time it gets called and of course forces a refresh().\n\n      self.update = function () {\n        self.update = updateFunc;\n        start || end || self.refresh();\n      };\n\n      gsap.delayedCall(0.01, self.update);\n      change = 0.01;\n      start = end = 0;\n    } else {\n      self.refresh();\n    }\n\n    pin && _queueRefreshAll(); // pinning could affect the positions of other things, so make sure we queue a full refresh()\n  };\n\n  ScrollTrigger.register = function register(core) {\n    if (!_coreInitted) {\n      gsap = core || _getGSAP();\n      _windowExists() && window.document && ScrollTrigger.enable();\n      _coreInitted = _enabled;\n    }\n\n    return _coreInitted;\n  };\n\n  ScrollTrigger.defaults = function defaults(config) {\n    if (config) {\n      for (var p in config) {\n        _defaults[p] = config[p];\n      }\n    }\n\n    return _defaults;\n  };\n\n  ScrollTrigger.disable = function disable(reset, kill) {\n    _enabled = 0;\n\n    _triggers.forEach(function (trigger) {\n      return trigger[kill ? \"kill\" : \"disable\"](reset);\n    });\n\n    _removeListener(_win, \"wheel\", _onScroll);\n\n    _removeListener(_doc, \"scroll\", _onScroll);\n\n    clearInterval(_syncInterval);\n\n    _removeListener(_doc, \"touchcancel\", _passThrough);\n\n    _removeListener(_body, \"touchstart\", _passThrough);\n\n    _multiListener(_removeListener, _doc, \"pointerdown,touchstart,mousedown\", _pointerDownHandler);\n\n    _multiListener(_removeListener, _doc, \"pointerup,touchend,mouseup\", _pointerUpHandler);\n\n    _resizeDelay.kill();\n\n    _iterateAutoRefresh(_removeListener);\n\n    for (var i = 0; i < _scrollers.length; i += 3) {\n      _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 1]);\n\n      _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 2]);\n    }\n  };\n\n  ScrollTrigger.enable = function enable() {\n    _win = window;\n    _doc = document;\n    _docEl = _doc.documentElement;\n    _body = _doc.body;\n\n    if (gsap) {\n      _toArray = gsap.utils.toArray;\n      _clamp = gsap.utils.clamp;\n      _context = gsap.core.context || _passThrough;\n      _suppressOverwrites = gsap.core.suppressOverwrites || _passThrough;\n      _scrollRestoration = _win.history.scrollRestoration || \"auto\";\n      _lastScroll = _win.pageYOffset;\n      gsap.core.globals(\"ScrollTrigger\", ScrollTrigger); // must register the global manually because in Internet Explorer, functions (classes) don't have a \"name\" property.\n\n      if (_body) {\n        _enabled = 1;\n        _div100vh = document.createElement(\"div\"); // to solve mobile browser address bar show/hide resizing, we shouldn't rely on window.innerHeight. Instead, use a <div> with its height set to 100vh and measure that since that's what the scrolling is based on anyway and it's not affected by address bar showing/hiding.\n\n        _div100vh.style.height = \"100vh\";\n        _div100vh.style.position = \"absolute\";\n\n        _refresh100vh();\n\n        _rafBugFix();\n\n        Observer.register(gsap); // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.\n\n        ScrollTrigger.isTouch = Observer.isTouch;\n        _fixIOSBug = Observer.isTouch && /(iPad|iPhone|iPod|Mac)/g.test(navigator.userAgent); // since 2017, iOS has had a bug that causes event.clientX/Y to be inaccurate when a scroll occurs, thus we must alternate ignoring every other touchmove event to work around it. See https://bugs.webkit.org/show_bug.cgi?id=181954 and https://codepen.io/GreenSock/pen/ExbrPNa/087cef197dc35445a0951e8935c41503\n\n        _ignoreMobileResize = Observer.isTouch === 1;\n\n        _addListener(_win, \"wheel\", _onScroll); // mostly for 3rd party smooth scrolling libraries.\n\n\n        _root = [_win, _doc, _docEl, _body];\n\n        if (gsap.matchMedia) {\n          ScrollTrigger.matchMedia = function (vars) {\n            var mm = gsap.matchMedia(),\n                p;\n\n            for (p in vars) {\n              mm.add(p, vars[p]);\n            }\n\n            return mm;\n          };\n\n          gsap.addEventListener(\"matchMediaInit\", function () {\n            return _revertAll();\n          });\n          gsap.addEventListener(\"matchMediaRevert\", function () {\n            return _revertRecorded();\n          });\n          gsap.addEventListener(\"matchMedia\", function () {\n            _refreshAll(0, 1);\n\n            _dispatch(\"matchMedia\");\n          });\n          gsap.matchMedia(\"(orientation: portrait)\", function () {\n            // when orientation changes, we should take new base measurements for the ignoreMobileResize feature.\n            _setBaseDimensions();\n\n            return _setBaseDimensions;\n          });\n        } else {\n          console.warn(\"Requires GSAP 3.11.0 or later\");\n        }\n\n        _setBaseDimensions();\n\n        _addListener(_doc, \"scroll\", _onScroll); // some browsers (like Chrome), the window stops dispatching scroll events on the window if you scroll really fast, but it's consistent on the document!\n\n\n        var bodyStyle = _body.style,\n            border = bodyStyle.borderTopStyle,\n            AnimationProto = gsap.core.Animation.prototype,\n            bounds,\n            i;\n        AnimationProto.revert || Object.defineProperty(AnimationProto, \"revert\", {\n          value: function value() {\n            return this.time(-0.01, true);\n          }\n        }); // only for backwards compatibility (Animation.revert() was added after 3.10.4)\n\n        bodyStyle.borderTopStyle = \"solid\"; // works around an issue where a margin of a child element could throw off the bounds of the _body, making it seem like there's a margin when there actually isn't. The border ensures that the bounds are accurate.\n\n        bounds = _getBounds(_body);\n        _vertical.m = Math.round(bounds.top + _vertical.sc()) || 0; // accommodate the offset of the <body> caused by margins and/or padding\n\n        _horizontal.m = Math.round(bounds.left + _horizontal.sc()) || 0;\n        border ? bodyStyle.borderTopStyle = border : bodyStyle.removeProperty(\"border-top-style\"); // TODO: (?) maybe move to leveraging the velocity mechanism in Observer and skip intervals.\n\n        _syncInterval = setInterval(_sync, 250);\n        gsap.delayedCall(0.5, function () {\n          return _startup = 0;\n        });\n\n        _addListener(_doc, \"touchcancel\", _passThrough); // some older Android devices intermittently stop dispatching \"touchmove\" events if we don't listen for \"touchcancel\" on the document.\n\n\n        _addListener(_body, \"touchstart\", _passThrough); //works around Safari bug: https://gsap.com/forums/topic/21450-draggable-in-iframe-on-mobile-is-buggy/\n\n\n        _multiListener(_addListener, _doc, \"pointerdown,touchstart,mousedown\", _pointerDownHandler);\n\n        _multiListener(_addListener, _doc, \"pointerup,touchend,mouseup\", _pointerUpHandler);\n\n        _transformProp = gsap.utils.checkPrefix(\"transform\");\n\n        _stateProps.push(_transformProp);\n\n        _coreInitted = _getTime();\n        _resizeDelay = gsap.delayedCall(0.2, _refreshAll).pause();\n        _autoRefresh = [_doc, \"visibilitychange\", function () {\n          var w = _win.innerWidth,\n              h = _win.innerHeight;\n\n          if (_doc.hidden) {\n            _prevWidth = w;\n            _prevHeight = h;\n          } else if (_prevWidth !== w || _prevHeight !== h) {\n            _onResize();\n          }\n        }, _doc, \"DOMContentLoaded\", _refreshAll, _win, \"load\", _refreshAll, _win, \"resize\", _onResize];\n\n        _iterateAutoRefresh(_addListener);\n\n        _triggers.forEach(function (trigger) {\n          return trigger.enable(0, 1);\n        });\n\n        for (i = 0; i < _scrollers.length; i += 3) {\n          _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 1]);\n\n          _wheelListener(_removeListener, _scrollers[i], _scrollers[i + 2]);\n        }\n      }\n    }\n  };\n\n  ScrollTrigger.config = function config(vars) {\n    \"limitCallbacks\" in vars && (_limitCallbacks = !!vars.limitCallbacks);\n    var ms = vars.syncInterval;\n    ms && clearInterval(_syncInterval) || (_syncInterval = ms) && setInterval(_sync, ms);\n    \"ignoreMobileResize\" in vars && (_ignoreMobileResize = ScrollTrigger.isTouch === 1 && vars.ignoreMobileResize);\n\n    if (\"autoRefreshEvents\" in vars) {\n      _iterateAutoRefresh(_removeListener) || _iterateAutoRefresh(_addListener, vars.autoRefreshEvents || \"none\");\n      _ignoreResize = (vars.autoRefreshEvents + \"\").indexOf(\"resize\") === -1;\n    }\n  };\n\n  ScrollTrigger.scrollerProxy = function scrollerProxy(target, vars) {\n    var t = _getTarget(target),\n        i = _scrollers.indexOf(t),\n        isViewport = _isViewport(t);\n\n    if (~i) {\n      _scrollers.splice(i, isViewport ? 6 : 2);\n    }\n\n    if (vars) {\n      isViewport ? _proxies.unshift(_win, vars, _body, vars, _docEl, vars) : _proxies.unshift(t, vars);\n    }\n  };\n\n  ScrollTrigger.clearMatchMedia = function clearMatchMedia(query) {\n    _triggers.forEach(function (t) {\n      return t._ctx && t._ctx.query === query && t._ctx.kill(true, true);\n    });\n  };\n\n  ScrollTrigger.isInViewport = function isInViewport(element, ratio, horizontal) {\n    var bounds = (_isString(element) ? _getTarget(element) : element).getBoundingClientRect(),\n        offset = bounds[horizontal ? _width : _height] * ratio || 0;\n    return horizontal ? bounds.right - offset > 0 && bounds.left + offset < _win.innerWidth : bounds.bottom - offset > 0 && bounds.top + offset < _win.innerHeight;\n  };\n\n  ScrollTrigger.positionInViewport = function positionInViewport(element, referencePoint, horizontal) {\n    _isString(element) && (element = _getTarget(element));\n    var bounds = element.getBoundingClientRect(),\n        size = bounds[horizontal ? _width : _height],\n        offset = referencePoint == null ? size / 2 : referencePoint in _keywords ? _keywords[referencePoint] * size : ~referencePoint.indexOf(\"%\") ? parseFloat(referencePoint) * size / 100 : parseFloat(referencePoint) || 0;\n    return horizontal ? (bounds.left + offset) / _win.innerWidth : (bounds.top + offset) / _win.innerHeight;\n  };\n\n  ScrollTrigger.killAll = function killAll(allowListeners) {\n    _triggers.slice(0).forEach(function (t) {\n      return t.vars.id !== \"ScrollSmoother\" && t.kill();\n    });\n\n    if (allowListeners !== true) {\n      var listeners = _listeners.killAll || [];\n      _listeners = {};\n      listeners.forEach(function (f) {\n        return f();\n      });\n    }\n  };\n\n  return ScrollTrigger;\n}();\nScrollTrigger.version = \"3.12.5\";\n\nScrollTrigger.saveStyles = function (targets) {\n  return targets ? _toArray(targets).forEach(function (target) {\n    // saved styles are recorded in a consecutive alternating Array, like [element, cssText, transform attribute, cache, matchMedia, ...]\n    if (target && target.style) {\n      var i = _savedStyles.indexOf(target);\n\n      i >= 0 && _savedStyles.splice(i, 5);\n\n      _savedStyles.push(target, target.style.cssText, target.getBBox && target.getAttribute(\"transform\"), gsap.core.getCache(target), _context());\n    }\n  }) : _savedStyles;\n};\n\nScrollTrigger.revert = function (soft, media) {\n  return _revertAll(!soft, media);\n};\n\nScrollTrigger.create = function (vars, animation) {\n  return new ScrollTrigger(vars, animation);\n};\n\nScrollTrigger.refresh = function (safe) {\n  return safe ? _onResize() : (_coreInitted || ScrollTrigger.register()) && _refreshAll(true);\n};\n\nScrollTrigger.update = function (force) {\n  return ++_scrollers.cache && _updateAll(force === true ? 2 : 0);\n};\n\nScrollTrigger.clearScrollMemory = _clearScrollMemory;\n\nScrollTrigger.maxScroll = function (element, horizontal) {\n  return _maxScroll(element, horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getScrollFunc = function (element, horizontal) {\n  return _getScrollFunc(_getTarget(element), horizontal ? _horizontal : _vertical);\n};\n\nScrollTrigger.getById = function (id) {\n  return _ids[id];\n};\n\nScrollTrigger.getAll = function () {\n  return _triggers.filter(function (t) {\n    return t.vars.id !== \"ScrollSmoother\";\n  });\n}; // it's common for people to ScrollTrigger.getAll(t => t.kill()) on page routes, for example, and we don't want it to ruin smooth scrolling by killing the main ScrollSmoother one.\n\n\nScrollTrigger.isScrolling = function () {\n  return !!_lastScrollTime;\n};\n\nScrollTrigger.snapDirectional = _snapDirectional;\n\nScrollTrigger.addEventListener = function (type, callback) {\n  var a = _listeners[type] || (_listeners[type] = []);\n  ~a.indexOf(callback) || a.push(callback);\n};\n\nScrollTrigger.removeEventListener = function (type, callback) {\n  var a = _listeners[type],\n      i = a && a.indexOf(callback);\n  i >= 0 && a.splice(i, 1);\n};\n\nScrollTrigger.batch = function (targets, vars) {\n  var result = [],\n      varsCopy = {},\n      interval = vars.interval || 0.016,\n      batchMax = vars.batchMax || 1e9,\n      proxyCallback = function proxyCallback(type, callback) {\n    var elements = [],\n        triggers = [],\n        delay = gsap.delayedCall(interval, function () {\n      callback(elements, triggers);\n      elements = [];\n      triggers = [];\n    }).pause();\n    return function (self) {\n      elements.length || delay.restart(true);\n      elements.push(self.trigger);\n      triggers.push(self);\n      batchMax <= elements.length && delay.progress(1);\n    };\n  },\n      p;\n\n  for (p in vars) {\n    varsCopy[p] = p.substr(0, 2) === \"on\" && _isFunction(vars[p]) && p !== \"onRefreshInit\" ? proxyCallback(p, vars[p]) : vars[p];\n  }\n\n  if (_isFunction(batchMax)) {\n    batchMax = batchMax();\n\n    _addListener(ScrollTrigger, \"refresh\", function () {\n      return batchMax = vars.batchMax();\n    });\n  }\n\n  _toArray(targets).forEach(function (target) {\n    var config = {};\n\n    for (p in varsCopy) {\n      config[p] = varsCopy[p];\n    }\n\n    config.trigger = target;\n    result.push(ScrollTrigger.create(config));\n  });\n\n  return result;\n}; // to reduce file size. clamps the scroll and also returns a duration multiplier so that if the scroll gets chopped shorter, the duration gets curtailed as well (otherwise if you're very close to the top of the page, for example, and swipe up really fast, it'll suddenly slow down and take a long time to reach the top).\n\n\nvar _clampScrollAndGetDurationMultiplier = function _clampScrollAndGetDurationMultiplier(scrollFunc, current, end, max) {\n  current > max ? scrollFunc(max) : current < 0 && scrollFunc(0);\n  return end > max ? (max - current) / (end - current) : end < 0 ? current / (current - end) : 1;\n},\n    _allowNativePanning = function _allowNativePanning(target, direction) {\n  if (direction === true) {\n    target.style.removeProperty(\"touch-action\");\n  } else {\n    target.style.touchAction = direction === true ? \"auto\" : direction ? \"pan-\" + direction + (Observer.isTouch ? \" pinch-zoom\" : \"\") : \"none\"; // note: Firefox doesn't support it pinch-zoom properly, at least in addition to a pan-x or pan-y.\n  }\n\n  target === _docEl && _allowNativePanning(_body, direction);\n},\n    _overflow = {\n  auto: 1,\n  scroll: 1\n},\n    _nestedScroll = function _nestedScroll(_ref5) {\n  var event = _ref5.event,\n      target = _ref5.target,\n      axis = _ref5.axis;\n\n  var node = (event.changedTouches ? event.changedTouches[0] : event).target,\n      cache = node._gsap || gsap.core.getCache(node),\n      time = _getTime(),\n      cs;\n\n  if (!cache._isScrollT || time - cache._isScrollT > 2000) {\n    // cache for 2 seconds to improve performance.\n    while (node && node !== _body && (node.scrollHeight <= node.clientHeight && node.scrollWidth <= node.clientWidth || !(_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]))) {\n      node = node.parentNode;\n    }\n\n    cache._isScroll = node && node !== target && !_isViewport(node) && (_overflow[(cs = _getComputedStyle(node)).overflowY] || _overflow[cs.overflowX]);\n    cache._isScrollT = time;\n  }\n\n  if (cache._isScroll || axis === \"x\") {\n    event.stopPropagation();\n    event._gsapAllow = true;\n  }\n},\n    // capture events on scrollable elements INSIDE the <body> and allow those by calling stopPropagation() when we find a scrollable ancestor\n_inputObserver = function _inputObserver(target, type, inputs, nested) {\n  return Observer.create({\n    target: target,\n    capture: true,\n    debounce: false,\n    lockAxis: true,\n    type: type,\n    onWheel: nested = nested && _nestedScroll,\n    onPress: nested,\n    onDrag: nested,\n    onScroll: nested,\n    onEnable: function onEnable() {\n      return inputs && _addListener(_doc, Observer.eventTypes[0], _captureInputs, false, true);\n    },\n    onDisable: function onDisable() {\n      return _removeListener(_doc, Observer.eventTypes[0], _captureInputs, true);\n    }\n  });\n},\n    _inputExp = /(input|label|select|textarea)/i,\n    _inputIsFocused,\n    _captureInputs = function _captureInputs(e) {\n  var isInput = _inputExp.test(e.target.tagName);\n\n  if (isInput || _inputIsFocused) {\n    e._gsapAllow = true;\n    _inputIsFocused = isInput;\n  }\n},\n    _getScrollNormalizer = function _getScrollNormalizer(vars) {\n  _isObject(vars) || (vars = {});\n  vars.preventDefault = vars.isNormalizer = vars.allowClicks = true;\n  vars.type || (vars.type = \"wheel,touch\");\n  vars.debounce = !!vars.debounce;\n  vars.id = vars.id || \"normalizer\";\n\n  var _vars2 = vars,\n      normalizeScrollX = _vars2.normalizeScrollX,\n      momentum = _vars2.momentum,\n      allowNestedScroll = _vars2.allowNestedScroll,\n      onRelease = _vars2.onRelease,\n      self,\n      maxY,\n      target = _getTarget(vars.target) || _docEl,\n      smoother = gsap.core.globals().ScrollSmoother,\n      smootherInstance = smoother && smoother.get(),\n      content = _fixIOSBug && (vars.content && _getTarget(vars.content) || smootherInstance && vars.content !== false && !smootherInstance.smooth() && smootherInstance.content()),\n      scrollFuncY = _getScrollFunc(target, _vertical),\n      scrollFuncX = _getScrollFunc(target, _horizontal),\n      scale = 1,\n      initialScale = (Observer.isTouch && _win.visualViewport ? _win.visualViewport.scale * _win.visualViewport.width : _win.outerWidth) / _win.innerWidth,\n      wheelRefresh = 0,\n      resolveMomentumDuration = _isFunction(momentum) ? function () {\n    return momentum(self);\n  } : function () {\n    return momentum || 2.8;\n  },\n      lastRefreshID,\n      skipTouchMove,\n      inputObserver = _inputObserver(target, vars.type, true, allowNestedScroll),\n      resumeTouchMove = function resumeTouchMove() {\n    return skipTouchMove = false;\n  },\n      scrollClampX = _passThrough,\n      scrollClampY = _passThrough,\n      updateClamps = function updateClamps() {\n    maxY = _maxScroll(target, _vertical);\n    scrollClampY = _clamp(_fixIOSBug ? 1 : 0, maxY);\n    normalizeScrollX && (scrollClampX = _clamp(0, _maxScroll(target, _horizontal)));\n    lastRefreshID = _refreshID;\n  },\n      removeContentOffset = function removeContentOffset() {\n    content._gsap.y = _round(parseFloat(content._gsap.y) + scrollFuncY.offset) + \"px\";\n    content.style.transform = \"matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, \" + parseFloat(content._gsap.y) + \", 0, 1)\";\n    scrollFuncY.offset = scrollFuncY.cacheID = 0;\n  },\n      ignoreDrag = function ignoreDrag() {\n    if (skipTouchMove) {\n      requestAnimationFrame(resumeTouchMove);\n\n      var offset = _round(self.deltaY / 2),\n          scroll = scrollClampY(scrollFuncY.v - offset);\n\n      if (content && scroll !== scrollFuncY.v + scrollFuncY.offset) {\n        scrollFuncY.offset = scroll - scrollFuncY.v;\n\n        var y = _round((parseFloat(content && content._gsap.y) || 0) - scrollFuncY.offset);\n\n        content.style.transform = \"matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, \" + y + \", 0, 1)\";\n        content._gsap.y = y + \"px\";\n        scrollFuncY.cacheID = _scrollers.cache;\n\n        _updateAll();\n      }\n\n      return true;\n    }\n\n    scrollFuncY.offset && removeContentOffset();\n    skipTouchMove = true;\n  },\n      tween,\n      startScrollX,\n      startScrollY,\n      onStopDelayedCall,\n      onResize = function onResize() {\n    // if the window resizes, like on an iPhone which Apple FORCES the address bar to show/hide even if we event.preventDefault(), it may be scrolling too far now that the address bar is showing, so we must dynamically adjust the momentum tween.\n    updateClamps();\n\n    if (tween.isActive() && tween.vars.scrollY > maxY) {\n      scrollFuncY() > maxY ? tween.progress(1) && scrollFuncY(maxY) : tween.resetTo(\"scrollY\", maxY);\n    }\n  };\n\n  content && gsap.set(content, {\n    y: \"+=0\"\n  }); // to ensure there's a cache (element._gsap)\n\n  vars.ignoreCheck = function (e) {\n    return _fixIOSBug && e.type === \"touchmove\" && ignoreDrag(e) || scale > 1.05 && e.type !== \"touchstart\" || self.isGesturing || e.touches && e.touches.length > 1;\n  };\n\n  vars.onPress = function () {\n    skipTouchMove = false;\n    var prevScale = scale;\n    scale = _round((_win.visualViewport && _win.visualViewport.scale || 1) / initialScale);\n    tween.pause();\n    prevScale !== scale && _allowNativePanning(target, scale > 1.01 ? true : normalizeScrollX ? false : \"x\");\n    startScrollX = scrollFuncX();\n    startScrollY = scrollFuncY();\n    updateClamps();\n    lastRefreshID = _refreshID;\n  };\n\n  vars.onRelease = vars.onGestureStart = function (self, wasDragging) {\n    scrollFuncY.offset && removeContentOffset();\n\n    if (!wasDragging) {\n      onStopDelayedCall.restart(true);\n    } else {\n      _scrollers.cache++; // make sure we're pulling the non-cached value\n      // alternate algorithm: durX = Math.min(6, Math.abs(self.velocityX / 800)),\tdur = Math.max(durX, Math.min(6, Math.abs(self.velocityY / 800))); dur = dur * (0.4 + (1 - _power4In(dur / 6)) * 0.6)) * (momentumSpeed || 1)\n\n      var dur = resolveMomentumDuration(),\n          currentScroll,\n          endScroll;\n\n      if (normalizeScrollX) {\n        currentScroll = scrollFuncX();\n        endScroll = currentScroll + dur * 0.05 * -self.velocityX / 0.227; // the constant .227 is from power4(0.05). velocity is inverted because scrolling goes in the opposite direction.\n\n        dur *= _clampScrollAndGetDurationMultiplier(scrollFuncX, currentScroll, endScroll, _maxScroll(target, _horizontal));\n        tween.vars.scrollX = scrollClampX(endScroll);\n      }\n\n      currentScroll = scrollFuncY();\n      endScroll = currentScroll + dur * 0.05 * -self.velocityY / 0.227; // the constant .227 is from power4(0.05)\n\n      dur *= _clampScrollAndGetDurationMultiplier(scrollFuncY, currentScroll, endScroll, _maxScroll(target, _vertical));\n      tween.vars.scrollY = scrollClampY(endScroll);\n      tween.invalidate().duration(dur).play(0.01);\n\n      if (_fixIOSBug && tween.vars.scrollY >= maxY || currentScroll >= maxY - 1) {\n        // iOS bug: it'll show the address bar but NOT fire the window \"resize\" event until the animation is done but we must protect against overshoot so we leverage an onUpdate to do so.\n        gsap.to({}, {\n          onUpdate: onResize,\n          duration: dur\n        });\n      }\n    }\n\n    onRelease && onRelease(self);\n  };\n\n  vars.onWheel = function () {\n    tween._ts && tween.pause();\n\n    if (_getTime() - wheelRefresh > 1000) {\n      // after 1 second, refresh the clamps otherwise that'll only happen when ScrollTrigger.refresh() is called or for touch-scrolling.\n      lastRefreshID = 0;\n      wheelRefresh = _getTime();\n    }\n  };\n\n  vars.onChange = function (self, dx, dy, xArray, yArray) {\n    _refreshID !== lastRefreshID && updateClamps();\n    dx && normalizeScrollX && scrollFuncX(scrollClampX(xArray[2] === dx ? startScrollX + (self.startX - self.x) : scrollFuncX() + dx - xArray[1])); // for more precision, we track pointer/touch movement from the start, otherwise it'll drift.\n\n    if (dy) {\n      scrollFuncY.offset && removeContentOffset();\n      var isTouch = yArray[2] === dy,\n          y = isTouch ? startScrollY + self.startY - self.y : scrollFuncY() + dy - yArray[1],\n          yClamped = scrollClampY(y);\n      isTouch && y !== yClamped && (startScrollY += yClamped - y);\n      scrollFuncY(yClamped);\n    }\n\n    (dy || dx) && _updateAll();\n  };\n\n  vars.onEnable = function () {\n    _allowNativePanning(target, normalizeScrollX ? false : \"x\");\n\n    ScrollTrigger.addEventListener(\"refresh\", onResize);\n\n    _addListener(_win, \"resize\", onResize);\n\n    if (scrollFuncY.smooth) {\n      scrollFuncY.target.style.scrollBehavior = \"auto\";\n      scrollFuncY.smooth = scrollFuncX.smooth = false;\n    }\n\n    inputObserver.enable();\n  };\n\n  vars.onDisable = function () {\n    _allowNativePanning(target, true);\n\n    _removeListener(_win, \"resize\", onResize);\n\n    ScrollTrigger.removeEventListener(\"refresh\", onResize);\n    inputObserver.kill();\n  };\n\n  vars.lockAxis = vars.lockAxis !== false;\n  self = new Observer(vars);\n  self.iOS = _fixIOSBug; // used in the Observer getCachedScroll() function to work around an iOS bug that wreaks havoc with TouchEvent.clientY if we allow scroll to go all the way back to 0.\n\n  _fixIOSBug && !scrollFuncY() && scrollFuncY(1); // iOS bug causes event.clientY values to freak out (wildly inaccurate) if the scroll position is exactly 0.\n\n  _fixIOSBug && gsap.ticker.add(_passThrough); // prevent the ticker from sleeping\n\n  onStopDelayedCall = self._dc;\n  tween = gsap.to(self, {\n    ease: \"power4\",\n    paused: true,\n    inherit: false,\n    scrollX: normalizeScrollX ? \"+=0.1\" : \"+=0\",\n    scrollY: \"+=0.1\",\n    modifiers: {\n      scrollY: _interruptionTracker(scrollFuncY, scrollFuncY(), function () {\n        return tween.pause();\n      })\n    },\n    onUpdate: _updateAll,\n    onComplete: onStopDelayedCall.vars.onComplete\n  }); // we need the modifier to sense if the scroll position is altered outside of the momentum tween (like with a scrollTo tween) so we can pause() it to prevent conflicts.\n\n  return self;\n};\n\nScrollTrigger.sort = function (func) {\n  return _triggers.sort(func || function (a, b) {\n    return (a.vars.refreshPriority || 0) * -1e6 + a.start - (b.start + (b.vars.refreshPriority || 0) * -1e6);\n  });\n};\n\nScrollTrigger.observe = function (vars) {\n  return new Observer(vars);\n};\n\nScrollTrigger.normalizeScroll = function (vars) {\n  if (typeof vars === \"undefined\") {\n    return _normalizer;\n  }\n\n  if (vars === true && _normalizer) {\n    return _normalizer.enable();\n  }\n\n  if (vars === false) {\n    _normalizer && _normalizer.kill();\n    _normalizer = vars;\n    return;\n  }\n\n  var normalizer = vars instanceof Observer ? vars : _getScrollNormalizer(vars);\n  _normalizer && _normalizer.target === normalizer.target && _normalizer.kill();\n  _isViewport(normalizer.target) && (_normalizer = normalizer);\n  return normalizer;\n};\n\nScrollTrigger.core = {\n  // smaller file size way to leverage in ScrollSmoother and Observer\n  _getVelocityProp: _getVelocityProp,\n  _inputObserver: _inputObserver,\n  _scrollers: _scrollers,\n  _proxies: _proxies,\n  bridge: {\n    // when normalizeScroll sets the scroll position (ss = setScroll)\n    ss: function ss() {\n      _lastScrollTime || _dispatch(\"scrollStart\");\n      _lastScrollTime = _getTime();\n    },\n    // a way to get the _refreshing value in Observer\n    ref: function ref() {\n      return _refreshing;\n    }\n  }\n};\n_getGSAP() && gsap.registerPlugin(ScrollTrigger);\nexport { ScrollTrigger as default };","import React, { useEffect, useRef, useState } from 'react'\nimport gsap from 'gsap'\nimport { ScrollTrigger } from 'gsap/ScrollTrigger'\nimport { useStaticQuery, graphql } from 'gatsby'\nimport Button from '../button'\n\ngsap.registerPlugin(ScrollTrigger);\n\nconst SectionWithAnimation: React.FC = () => {\n  const sectionRef = useRef<HTMLDivElement>(null);\n  const [showFullText, setShowFullText] = useState(false);\n  const data = useStaticQuery(graphql`\n    query PageHomeTextAnimation {\n      allWpPage(filter: {id: {eq: \"cG9zdDoxMg==\"}}) {\n        nodes {\n          slider_home {\n            parrafoDesktop1\n            parrafoDesktop2\n            parrafoDesktop3\n            parrafoDesktop4\n            parrafoMovil1\n            parrafoMovil2\n            parrafoMovil3\n            parrafoMovil4\n          }\n        }\n      }\n    }\n  `);\n\n  const isMobile = typeof navigator !== 'undefined' && /iPhone|iPad|iPod|Android/i.test(navigator.userAgent);\n\n  useEffect(() => {\n    const sectionElement = sectionRef.current;\n\n    if (sectionElement) {\n      const animateText = (textElement: HTMLElement) => {\n        const allSpans = textElement.querySelectorAll('span');\n\n        gsap.set(allSpans, { opacity: 0.1 }); \n\n        gsap.to(allSpans, {\n          opacity: 1,\n          duration: 0.5,\n          scrollTrigger: {\n            trigger: sectionElement,\n            start: 'top center+=100',\n            end: 'bottom center-=100',\n            scrub: true,\n          },\n          delay: (index) => index * 0.02, \n        });\n      };\n\n      animateText(sectionElement);\n    }\n  }, []);\n\n  useEffect(() => {\n    if (showFullText) {\n      const newParagraphs = sectionRef.current?.querySelectorAll('.new-paragraphs');\n\n      if (newParagraphs) {\n        newParagraphs.forEach((paragraph) => {\n          if (paragraph instanceof HTMLElement) {\n            animateText(paragraph);\n          }\n        });\n      }      \n    } else {\n      const initialParagraphs = sectionRef.current?.querySelectorAll('.new-paragraphs');\n\n      if (initialParagraphs) {\n        initialParagraphs.forEach((paragraph, index) => {\n          if (paragraph instanceof HTMLElement && index < 2) {\n            animateText(paragraph);\n          }\n        });\n      }      \n    }\n  }, [showFullText]);\n\n  const animateText = (textElement: HTMLElement) => {\n    const words = textElement.innerText.split(' ');\n    textElement.innerHTML = '';\n\n    words.forEach((word, wordIndex) => {\n      const wordSpan = document.createElement('span');\n      wordSpan.classList.add('word');\n      textElement.appendChild(wordSpan);\n\n      word.split('').forEach((letter, letterIndex) => {\n        const letterSpan = document.createElement('span');\n        letterSpan.innerText = letter;\n        const initialOpacity = 0.1; // Opacidad inicial en 0.1\n        gsap.set(letterSpan, { opacity: initialOpacity });\n        wordSpan.appendChild(letterSpan);\n\n        gsap.to(letterSpan, {\n          opacity: 1,\n          duration: 0.5,\n          scrollTrigger: {\n            trigger: letterSpan,\n            start: 'top center+=100',\n            end: 'bottom center-=100',\n            scrub: true,\n          },\n          delay: letterIndex * 0.2,\n        });\n      });\n\n      if (wordIndex < words.length - 1) {\n        const spaceSpan = document.createElement('span');\n        spaceSpan.innerText = ' ';\n        wordSpan.appendChild(spaceSpan);\n      }\n    });\n  };\n\n  const handleReadMoreClick = () => {\n    setShowFullText(true);\n  };\n\n  const handleHideClick = () => {\n    setShowFullText(false);\n  };\n\n  const handleButtonClick = () => {\n    console.log('Button clicked!');\n  };\n\n  return (\n    <section\n      ref={sectionRef}\n      id=\"section-bg-animation\"\n      style={{\n        backgroundColor: data.allWpPage.nodes[0].slider_home.bgColor,\n      }}\n    >\n      <div \n        className=\"section-animation\"\n        style={{\n          position: 'relative',\n        }}\n      >\n        <p className=\"new-paragraphs\" dangerouslySetInnerHTML={{ __html: isMobile ? data.allWpPage.nodes[0].slider_home.parrafoMovil1 : data.allWpPage.nodes[0].slider_home.parrafoDesktop1 }} />\n        <br className='desktop' /> <br className='desktop' /> <br className='mobile' /><br className='mobile' />\n        <p className=\"new-paragraphs\" dangerouslySetInnerHTML={{ __html: isMobile ? data.allWpPage.nodes[0].slider_home.parrafoMovil2 : data.allWpPage.nodes[0].slider_home.parrafoDesktop2 }} />\n        <br className='desktop' /> <br className='desktop' /><br className='mobile' /><br className='mobile' />\n        {showFullText ? (\n          <>\n            <p className=\"new-paragraphs\" dangerouslySetInnerHTML={{ __html: isMobile ? data.allWpPage.nodes[0].slider_home.parrafoMovil3 : data.allWpPage.nodes[0].slider_home.parrafoDesktop3 }} />\n            <br className='desktop' /><br className='desktop' /><br className='mobile' /><br className='mobile' />\n            <p className=\"new-paragraphs\" dangerouslySetInnerHTML={{ __html: isMobile ? data.allWpPage.nodes[0].slider_home.parrafoMovil4 : data.allWpPage.nodes[0].slider_home.parrafoDesktop4 }} />\n            <br className='desktop' /><br className='mobile' />\n            <button onClick={handleHideClick}>Ocultar</button>\n            \n          </>\n        ) : (\n          <button className='navigation-button' onClick={handleReadMoreClick}>Leer más</button>\n          \n          \n        )}\n      </div>\n    </section>\n  );\n};\n\nexport default SectionWithAnimation;\n","import React, { useState } from \"react\";\nimport rightBtnImage from \"../../../../static/assets/icons/btn-right.svg\";\nimport rightBtnImageWhite from \"../../../../static/assets/icons/btn-right-white.svg\";\nimport lineDeco from \"../../../../static/assets/icons/line.svg\";\nimport { graphql, useStaticQuery } from \"gatsby\";\nimport \"./index.scss\";\n\nconst NuestraPizarrita: React.FC = () => {\n  const data = useStaticQuery(graphql`\n    query HomePizarrita {\n      allWpPage(filter: { id: { eq: \"cG9zdDoxMg==\" } }) {\n        edges {\n          node {\n            id\n            slider_home {\n              bgImagenPizarrita {\n                altText\n                mediaItemUrl\n              }\n              bgImagenPizarritaMobile {\n                altText\n                mediaItemUrl\n              }\n              bgColorSeccionPizarrita\n              tituloPizarrita\n              descripcionPizarrita\n              textoBotonPizarrita\n              urlBotonPizarrita\n            }\n          }\n        }\n      }\n    }\n  `);\n\n  const pizarritaData = data.allWpPage.edges[0].node.slider_home;\n\n  const [hovered, setHovered] = useState(false);\n\n  const handleButtonHover = () => {\n    setHovered(true);\n  };\n\n  const handleButtonLeave = () => {\n    setHovered(false);\n  };\n\n  return (\n    <section\n      id=\"our-pizarrita\"\n      style={{\n        backgroundImage: `url(${pizarritaData.bgImagenPizarrita.mediaItemUrl})`,\n      }}\n    >\n      <div className=\"nuestra-pizarrita\">\n        <div className=\"nuestra-pizarrita-content\">\n          <h2>{pizarritaData.tituloPizarrita}</h2>\n          <img\n            className=\"line-decorative\"\n            src={lineDeco}\n            alt=\"Line decorative\"\n          />\n          <h3\n            dangerouslySetInnerHTML={{\n              __html: pizarritaData.descripcionPizarrita,\n            }}\n          />\n          <a\n            href={pizarritaData.urlBotonPizarrita}\n            target=\"_blank\"\n            className=\"booking-link\"\n            rel=\"noopener noreferrer\"\n            onMouseEnter={handleButtonHover}\n            onMouseLeave={handleButtonLeave}\n            style={{\n              cursor: \"pointer\",\n              backgroundColor: \"transparent\",\n              textDecoration: \"none\",\n            }}\n          >\n            {pizarritaData.textoBotonPizarrita}{\" \"}\n            <img\n              src={hovered ? rightBtnImageWhite : rightBtnImage}\n              alt=\"Right Btn\"\n              style={{ fill: \"#771111\" }}\n            />\n          </a>\n        </div>\n      </div>\n      {/* Mobile background */}\n      <style>{`\n                @media (max-width: 767px) {\n                    #our-pizarrita {\n                        background-image: url(${pizarritaData.bgImagenPizarritaMobile.mediaItemUrl}) !important;\n                    }\n                }\n            `}</style>\n    </section>\n  );\n};\n\nexport default NuestraPizarrita;\n","import React, { useEffect, useState } from 'react'\nimport rightBtnImage from '../../../../static/assets/icons/btn-right.svg'\nimport rightBtnImageWhite from '../../../../static/assets/icons/btn-right-white.svg'\nimport lineDeco from '../../../../static/assets/icons/line.svg'\nimport { graphql, useStaticQuery } from 'gatsby'\nimport Button from '../button'\n\nconst SliderLocals: React.FC = () => {\n  const data = useStaticQuery(graphql`\n    query PageHomeLocal {\n      allWpPage(filter: {id: {eq: \"cG9zdDoxMg==\"}}) {\n        nodes {\n          slider_home {\n            localTitulo\n            localBgColor\n            localDescripcion\n            localTextoBoton\n            localUrlBoton\n            localImagenSliderMobile {\n              altText\n              sourceUrl\n            }\n            localImagenSlider {\n              altText\n              sourceUrl\n            }\n          }\n        }\n      }\n    }\n  `);\n\n  const sliderData = data.allWpPage.nodes[0].slider_home;\n  const { localTitulo, localDescripcion, localTextoBoton, localUrlBoton, localBgColor } = sliderData;\n  \n  const [image, setImage] = useState(sliderData.localImagenSlider);\n  useEffect(() => {\n    const handleResize = () => {\n      setImage(window.innerWidth <= 768 ? sliderData.localImagenSliderMobile : sliderData.localImagenSlider);\n    };\n\n    window.addEventListener('resize', handleResize);\n\n    return () => {\n      window.removeEventListener('resize', handleResize);\n    };\n  }, [sliderData]);\n\n  const handleButtonHover = (e: { currentTarget: { querySelector: (arg0: string) => { (): any; new(): any; src: string; }; }; }) => {\n    e.currentTarget.querySelector('img').src = rightBtnImageWhite;\n  };\n\n  const handleButtonLeave = (e: { currentTarget: { querySelector: (arg0: string) => { (): any; new(): any; src: string; }; }; }) => {\n    e.currentTarget.querySelector('img').src = rightBtnImage;\n  };\n\n  const handleButtonClick = () => {\n    console.log('Button clicked!');\n  };\n\n  return (\n    <div id='locales' className=\"slider-locals\">\n      <div className=\"slider-locals-left\" style={{ backgroundColor: localBgColor }}>\n        <div className=\"slider-locals-info\">\n          <h2 className=\"slider-locals-title\" dangerouslySetInnerHTML={{ __html: localTitulo }}></h2>\n          <img className='line-decorative' src={lineDeco} alt=\"Line decorative\" />\n          <p className=\"slider-locals-description\" dangerouslySetInnerHTML={{ __html: localDescripcion }}></p>\n          <a \n            href={localUrlBoton} \n            className=\"slide-button navigation-button\" \n            onMouseEnter={handleButtonHover} \n            onMouseLeave={handleButtonLeave}\n          >\n            {localTextoBoton} <img src={rightBtnImage} alt=\"Right Btn\" />\n          </a>\n        </div>\n      </div>\n      <div className=\"slider-locals-right\">\n        <img src={image.sourceUrl} alt={image.altText} />\n      </div>\n    </div>\n  );\n};\n\nexport default SliderLocals;\n","import React, { useState } from 'react';\nimport leftArrowImage from '../../../../static/assets/icons/arrow-left-transparent.svg';\nimport rightArrowImage from '../../../../static/assets/icons/arrow-right-transparent.svg';\nimport { graphql, useStaticQuery } from 'gatsby';\n\nconst SliderFood: React.FC = () => {\n  const [currentIndex, setCurrentIndex] = useState(0);\n  const data = useStaticQuery(graphql`\n    query PageHomeFood {\n      allWpPage(filter: {id: {eq: \"cG9zdDoxMg==\"}}) {\n        nodes {\n          slider_home {\n            platosHome {\n              bgColor\n              description\n              title\n              imagenSlider {\n                altText\n                sourceUrl\n              }\n              imagenSliderMobile {\n                altText\n                sourceUrl\n              }\n            }\n          }\n        }\n      }\n    }\n  `);\n\n  const platosHome = data.allWpPage.nodes[0].slider_home.platosHome;\n\n  const handlePrev = (): void => {\n    setCurrentIndex((prevIndex) => (prevIndex === 0 ? platosHome.length - 1 : prevIndex - 1));\n  };\n\n  const handleNext = (): void => {\n    setCurrentIndex((prevIndex) => (prevIndex === platosHome.length - 1 ? 0 : prevIndex + 1));\n  };\n\n  const { imagenSlider, title, description, bgColor } = platosHome[currentIndex];\n\n  return (\n    <div className=\"slider-food\">\n      <div className=\"slider-food-left\">\n        <img src={imagenSlider.sourceUrl} alt={imagenSlider.altText} />\n      </div>\n      <div className=\"slider-food-right\" style={{ backgroundColor: bgColor }}>\n        <div className=\"slider-food-info\">\n          <h2 className=\"slider-food-title\" dangerouslySetInnerHTML={{ __html: title }}></h2>\n          <p className=\"slider-food-description\">{description}</p>\n          {platosHome.length > 1 && (\n            <div className=\"slider-food-navigation\">\n              <button className=\"slider-food-prev\" onClick={handlePrev}>\n                <img src={leftArrowImage} alt=\"Previous\" />\n              </button>\n              <button className=\"slider-food-next\" onClick={handleNext}>\n                <img src={rightArrowImage} alt=\"Next\" />\n              </button>\n            </div>\n          )}\n        </div>\n      </div>\n    </div>\n  );\n};\n\nexport default SliderFood;\n","export default \"data:image/svg+xml;base64,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\"","export default \"data:image/svg+xml;base64,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\"","function isObject(subject) {\n  return Object.prototype.toString.call(subject) === '[object Object]';\n}\nfunction isRecord(subject) {\n  return isObject(subject) || Array.isArray(subject);\n}\nfunction canUseDOM() {\n  return !!(typeof window !== 'undefined' && window.document && window.document.createElement);\n}\nfunction areOptionsEqual(optionsA, optionsB) {\n  const optionsAKeys = Object.keys(optionsA);\n  const optionsBKeys = Object.keys(optionsB);\n  if (optionsAKeys.length !== optionsBKeys.length) return false;\n  const breakpointsA = JSON.stringify(Object.keys(optionsA.breakpoints || {}));\n  const breakpointsB = JSON.stringify(Object.keys(optionsB.breakpoints || {}));\n  if (breakpointsA !== breakpointsB) return false;\n  return optionsAKeys.every(key => {\n    const valueA = optionsA[key];\n    const valueB = optionsB[key];\n    if (typeof valueA === 'function') return `${valueA}` === `${valueB}`;\n    if (!isRecord(valueA) || !isRecord(valueB)) return valueA === valueB;\n    return areOptionsEqual(valueA, valueB);\n  });\n}\nfunction sortAndMapPluginToOptions(plugins) {\n  return plugins.concat().sort((a, b) => a.name > b.name ? 1 : -1).map(plugin => plugin.options);\n}\nfunction arePluginsEqual(pluginsA, pluginsB) {\n  if (pluginsA.length !== pluginsB.length) return false;\n  const optionsA = sortAndMapPluginToOptions(pluginsA);\n  const optionsB = sortAndMapPluginToOptions(pluginsB);\n  return optionsA.every((optionA, index) => {\n    const optionB = optionsB[index];\n    return areOptionsEqual(optionA, optionB);\n  });\n}\n\nexport { areOptionsEqual, arePluginsEqual, canUseDOM, sortAndMapPluginToOptions };\n//# sourceMappingURL=embla-carousel-reactive-utils.esm.js.map\n","function isNumber(subject) {\n  return typeof subject === 'number';\n}\nfunction isString(subject) {\n  return typeof subject === 'string';\n}\nfunction isBoolean(subject) {\n  return typeof subject === 'boolean';\n}\nfunction isObject(subject) {\n  return Object.prototype.toString.call(subject) === '[object Object]';\n}\nfunction mathAbs(n) {\n  return Math.abs(n);\n}\nfunction mathSign(n) {\n  return Math.sign(n);\n}\nfunction deltaAbs(valueB, valueA) {\n  return mathAbs(valueB - valueA);\n}\nfunction factorAbs(valueB, valueA) {\n  if (valueB === 0 || valueA === 0) return 0;\n  if (mathAbs(valueB) <= mathAbs(valueA)) return 0;\n  const diff = deltaAbs(mathAbs(valueB), mathAbs(valueA));\n  return mathAbs(diff / valueB);\n}\nfunction arrayKeys(array) {\n  return objectKeys(array).map(Number);\n}\nfunction arrayLast(array) {\n  return array[arrayLastIndex(array)];\n}\nfunction arrayLastIndex(array) {\n  return Math.max(0, array.length - 1);\n}\nfunction objectKeys(object) {\n  return Object.keys(object);\n}\nfunction objectsMergeDeep(objectA, objectB) {\n  return [objectA, objectB].reduce((mergedObjects, currentObject) => {\n    objectKeys(currentObject).forEach(key => {\n      const valueA = mergedObjects[key];\n      const valueB = currentObject[key];\n      const areObjects = isObject(valueA) && isObject(valueB);\n      mergedObjects[key] = areObjects ? objectsMergeDeep(valueA, valueB) : valueB;\n    });\n    return mergedObjects;\n  }, {});\n}\nfunction isMouseEvent(evt, ownerWindow) {\n  return typeof ownerWindow.MouseEvent !== 'undefined' && evt instanceof ownerWindow.MouseEvent;\n}\n\nfunction Alignment(align, viewSize) {\n  const predefined = {\n    start,\n    center,\n    end\n  };\n  function start() {\n    return 0;\n  }\n  function center(n) {\n    return end(n) / 2;\n  }\n  function end(n) {\n    return viewSize - n;\n  }\n  function percent() {\n    return viewSize * Number(align);\n  }\n  function measure(n) {\n    if (isNumber(align)) return percent();\n    return predefined[align](n);\n  }\n  const self = {\n    measure\n  };\n  return self;\n}\n\nfunction Axis(axis, direction) {\n  const scroll = axis === 'y' ? 'y' : 'x';\n  const cross = axis === 'y' ? 'x' : 'y';\n  const startEdge = getStartEdge();\n  const endEdge = getEndEdge();\n  function measureSize(rect) {\n    const {\n      width,\n      height\n    } = rect;\n    return scroll === 'x' ? width : height;\n  }\n  function getStartEdge() {\n    if (scroll === 'y') return 'top';\n    return direction === 'rtl' ? 'right' : 'left';\n  }\n  function getEndEdge() {\n    if (scroll === 'y') return 'bottom';\n    return direction === 'rtl' ? 'left' : 'right';\n  }\n  const self = {\n    scroll,\n    cross,\n    startEdge,\n    endEdge,\n    measureSize\n  };\n  return self;\n}\n\nfunction Limit(min, max) {\n  const length = mathAbs(min - max);\n  function reachedMin(n) {\n    return n < min;\n  }\n  function reachedMax(n) {\n    return n > max;\n  }\n  function reachedAny(n) {\n    return reachedMin(n) || reachedMax(n);\n  }\n  function constrain(n) {\n    if (!reachedAny(n)) return n;\n    return reachedMin(n) ? min : max;\n  }\n  function removeOffset(n) {\n    if (!length) return n;\n    return n - length * Math.ceil((n - max) / length);\n  }\n  const self = {\n    length,\n    max,\n    min,\n    constrain,\n    reachedAny,\n    reachedMax,\n    reachedMin,\n    removeOffset\n  };\n  return self;\n}\n\nfunction Counter(max, start, loop) {\n  const {\n    constrain\n  } = Limit(0, max);\n  const loopEnd = max + 1;\n  let counter = withinLimit(start);\n  function withinLimit(n) {\n    return !loop ? constrain(n) : mathAbs((loopEnd + n) % loopEnd);\n  }\n  function get() {\n    return counter;\n  }\n  function set(n) {\n    counter = withinLimit(n);\n    return self;\n  }\n  function add(n) {\n    return clone().set(get() + n);\n  }\n  function clone() {\n    return Counter(max, get(), loop);\n  }\n  const self = {\n    get,\n    set,\n    add,\n    clone\n  };\n  return self;\n}\n\nfunction Direction(direction) {\n  const sign = direction === 'rtl' ? -1 : 1;\n  function apply(n) {\n    return n * sign;\n  }\n  const self = {\n    apply\n  };\n  return self;\n}\n\nfunction EventStore() {\n  let listeners = [];\n  function add(node, type, handler, options = {\n    passive: true\n  }) {\n    node.addEventListener(type, handler, options);\n    listeners.push(() => node.removeEventListener(type, handler, options));\n    return self;\n  }\n  function clear() {\n    listeners = listeners.filter(remove => remove());\n  }\n  const self = {\n    add,\n    clear\n  };\n  return self;\n}\n\nfunction DragHandler(axis, direction, rootNode, ownerDocument, ownerWindow, target, dragTracker, location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, baseFriction) {\n  const {\n    cross: crossAxis\n  } = axis;\n  const focusNodes = ['INPUT', 'SELECT', 'TEXTAREA'];\n  const nonPassiveEvent = {\n    passive: false\n  };\n  const initEvents = EventStore();\n  const dragEvents = EventStore();\n  const goToNextThreshold = Limit(50, 225).constrain(percentOfView.measure(20));\n  const snapForceBoost = {\n    mouse: 300,\n    touch: 400\n  };\n  const freeForceBoost = {\n    mouse: 500,\n    touch: 600\n  };\n  const baseSpeed = dragFree ? 43 : 25;\n  let isMoving = false;\n  let startScroll = 0;\n  let startCross = 0;\n  let pointerIsDown = false;\n  let preventScroll = false;\n  let preventClick = false;\n  let isMouse = false;\n  function init(emblaApi, watchDrag) {\n    if (!watchDrag) return;\n    function downIfAllowed(evt) {\n      if (isBoolean(watchDrag) || watchDrag(emblaApi, evt)) down(evt);\n    }\n    const node = rootNode;\n    initEvents.add(node, 'dragstart', evt => evt.preventDefault(), nonPassiveEvent).add(node, 'touchmove', () => undefined, nonPassiveEvent).add(node, 'touchend', () => undefined).add(node, 'touchstart', downIfAllowed).add(node, 'mousedown', downIfAllowed).add(node, 'touchcancel', up).add(node, 'contextmenu', up).add(node, 'click', click, true);\n  }\n  function destroy() {\n    initEvents.clear();\n    dragEvents.clear();\n  }\n  function addDragEvents() {\n    const node = isMouse ? ownerDocument : rootNode;\n    dragEvents.add(node, 'touchmove', move, nonPassiveEvent).add(node, 'touchend', up).add(node, 'mousemove', move, nonPassiveEvent).add(node, 'mouseup', up);\n  }\n  function isFocusNode(node) {\n    const nodeName = node.nodeName || '';\n    return focusNodes.includes(nodeName);\n  }\n  function forceBoost() {\n    const boost = dragFree ? freeForceBoost : snapForceBoost;\n    const type = isMouse ? 'mouse' : 'touch';\n    return boost[type];\n  }\n  function allowedForce(force, targetChanged) {\n    const next = index.add(mathSign(force) * -1);\n    const baseForce = scrollTarget.byDistance(force, !dragFree).distance;\n    if (dragFree || mathAbs(force) < goToNextThreshold) return baseForce;\n    if (skipSnaps && targetChanged) return baseForce * 0.5;\n    return scrollTarget.byIndex(next.get(), 0).distance;\n  }\n  function down(evt) {\n    const isMouseEvt = isMouseEvent(evt, ownerWindow);\n    isMouse = isMouseEvt;\n    if (isMouseEvt && evt.button !== 0) return;\n    if (isFocusNode(evt.target)) return;\n    preventClick = dragFree && isMouseEvt && !evt.buttons && isMoving;\n    isMoving = deltaAbs(target.get(), location.get()) >= 2;\n    pointerIsDown = true;\n    dragTracker.pointerDown(evt);\n    scrollBody.useFriction(0).useDuration(0);\n    target.set(location);\n    addDragEvents();\n    startScroll = dragTracker.readPoint(evt);\n    startCross = dragTracker.readPoint(evt, crossAxis);\n    eventHandler.emit('pointerDown');\n  }\n  function move(evt) {\n    const lastScroll = dragTracker.readPoint(evt);\n    const lastCross = dragTracker.readPoint(evt, crossAxis);\n    const diffScroll = deltaAbs(lastScroll, startScroll);\n    const diffCross = deltaAbs(lastCross, startCross);\n    if (!preventScroll && !isMouse) {\n      if (!evt.cancelable) return up(evt);\n      preventScroll = diffScroll > diffCross;\n      if (!preventScroll) return up(evt);\n    }\n    const diff = dragTracker.pointerMove(evt);\n    if (diffScroll > dragThreshold) preventClick = true;\n    scrollBody.useFriction(0.3).useDuration(1);\n    animation.start();\n    target.add(direction.apply(diff));\n    evt.preventDefault();\n  }\n  function up(evt) {\n    const currentLocation = scrollTarget.byDistance(0, false);\n    const targetChanged = currentLocation.index !== index.get();\n    const rawForce = dragTracker.pointerUp(evt) * forceBoost();\n    const force = allowedForce(direction.apply(rawForce), targetChanged);\n    const forceFactor = factorAbs(rawForce, force);\n    const speed = baseSpeed - 10 * forceFactor;\n    const friction = baseFriction + forceFactor / 50;\n    preventScroll = false;\n    pointerIsDown = false;\n    dragEvents.clear();\n    scrollBody.useDuration(speed).useFriction(friction);\n    scrollTo.distance(force, !dragFree);\n    isMouse = false;\n    eventHandler.emit('pointerUp');\n  }\n  function click(evt) {\n    if (preventClick) {\n      evt.stopPropagation();\n      evt.preventDefault();\n    }\n  }\n  function pointerDown() {\n    return pointerIsDown;\n  }\n  const self = {\n    init,\n    pointerDown,\n    destroy\n  };\n  return self;\n}\n\nfunction DragTracker(axis, ownerWindow) {\n  const logInterval = 170;\n  let startEvent;\n  let lastEvent;\n  function readTime(evt) {\n    return evt.timeStamp;\n  }\n  function readPoint(evt, evtAxis) {\n    const property = evtAxis || axis.scroll;\n    const coord = `client${property === 'x' ? 'X' : 'Y'}`;\n    return (isMouseEvent(evt, ownerWindow) ? evt : evt.touches[0])[coord];\n  }\n  function pointerDown(evt) {\n    startEvent = evt;\n    lastEvent = evt;\n    return readPoint(evt);\n  }\n  function pointerMove(evt) {\n    const diff = readPoint(evt) - readPoint(lastEvent);\n    const expired = readTime(evt) - readTime(startEvent) > logInterval;\n    lastEvent = evt;\n    if (expired) startEvent = evt;\n    return diff;\n  }\n  function pointerUp(evt) {\n    if (!startEvent || !lastEvent) return 0;\n    const diffDrag = readPoint(lastEvent) - readPoint(startEvent);\n    const diffTime = readTime(evt) - readTime(startEvent);\n    const expired = readTime(evt) - readTime(lastEvent) > logInterval;\n    const force = diffDrag / diffTime;\n    const isFlick = diffTime && !expired && mathAbs(force) > 0.1;\n    return isFlick ? force : 0;\n  }\n  const self = {\n    pointerDown,\n    pointerMove,\n    pointerUp,\n    readPoint\n  };\n  return self;\n}\n\nfunction PercentOfView(viewSize) {\n  function measure(n) {\n    return viewSize * (n / 100);\n  }\n  const self = {\n    measure\n  };\n  return self;\n}\n\nfunction ResizeHandler(container, slides, axis, eventHandler) {\n  let resizeObserver;\n  let containerSize;\n  let slideSizes = [];\n  let destroyed = false;\n  function readSize(node) {\n    return axis.measureSize(node.getBoundingClientRect());\n  }\n  function init(emblaApi, watchResize) {\n    if (!watchResize) return;\n    containerSize = readSize(container);\n    slideSizes = slides.map(readSize);\n    function defaultCallback(entries) {\n      for (const entry of entries) {\n        const isContainer = entry.target === container;\n        const slideIndex = slides.indexOf(entry.target);\n        const lastSize = isContainer ? containerSize : slideSizes[slideIndex];\n        const newSize = readSize(isContainer ? container : slides[slideIndex]);\n        if (lastSize !== newSize) {\n          emblaApi.reInit();\n          eventHandler.emit('resize');\n          break;\n        }\n      }\n    }\n    resizeObserver = new ResizeObserver(entries => {\n      if (destroyed) return;\n      if (isBoolean(watchResize) || watchResize(emblaApi, entries)) {\n        defaultCallback(entries);\n      }\n    });\n    const observeNodes = [container].concat(slides);\n    observeNodes.forEach(node => resizeObserver.observe(node));\n  }\n  function destroy() {\n    if (resizeObserver) resizeObserver.disconnect();\n    destroyed = true;\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction ScrollBody(location, target, baseDuration, baseFriction) {\n  let hasSettled = true;\n  let bodyVelocity = 0;\n  let scrollDirection = 0;\n  let duration = baseDuration;\n  let friction = baseFriction;\n  function seek() {\n    const diff = target.get() - location.get();\n    const isInstant = !friction || !duration;\n    if (isInstant) {\n      bodyVelocity = 0;\n      location.set(target);\n    } else {\n      bodyVelocity += diff / duration;\n      bodyVelocity *= friction;\n      location.add(bodyVelocity);\n    }\n    scrollDirection = mathSign(bodyVelocity || diff);\n    hasSettled = mathAbs(diff) < 0.001;\n    return self;\n  }\n  function settled() {\n    if (hasSettled) location.set(target);\n    return hasSettled;\n  }\n  function velocity() {\n    return bodyVelocity;\n  }\n  function direction() {\n    return scrollDirection;\n  }\n  function useBaseDuration() {\n    return useDuration(baseDuration);\n  }\n  function useBaseFriction() {\n    return useFriction(baseFriction);\n  }\n  function useDuration(n) {\n    duration = n;\n    return self;\n  }\n  function useFriction(n) {\n    friction = n;\n    return self;\n  }\n  const self = {\n    direction,\n    seek,\n    settled,\n    useBaseFriction,\n    useBaseDuration,\n    useFriction,\n    useDuration,\n    velocity\n  };\n  return self;\n}\n\nfunction ScrollBounds(limit, location, target, scrollBody, percentOfView) {\n  const pullBackThreshold = percentOfView.measure(10);\n  const edgeOffsetTolerance = percentOfView.measure(50);\n  const frictionLimit = Limit(0.1, 0.99);\n  let disabled = false;\n  function shouldConstrain() {\n    if (disabled) return false;\n    if (!limit.reachedAny(target.get())) return false;\n    if (!limit.reachedAny(location.get())) return false;\n    return true;\n  }\n  function constrain(pointerDown) {\n    if (!shouldConstrain()) return;\n    const edge = limit.reachedMin(location.get()) ? 'min' : 'max';\n    const diffToEdge = mathAbs(limit[edge] - location.get());\n    const diffToTarget = target.get() - location.get();\n    const friction = frictionLimit.constrain(diffToEdge / edgeOffsetTolerance);\n    target.subtract(diffToTarget * friction);\n    if (!pointerDown && mathAbs(diffToTarget) < pullBackThreshold) {\n      target.set(limit.constrain(target.get()));\n      scrollBody.useDuration(25).useBaseFriction();\n    }\n  }\n  function toggleActive(active) {\n    disabled = !active;\n  }\n  const self = {\n    constrain,\n    toggleActive\n  };\n  return self;\n}\n\nfunction ScrollContain(viewSize, contentSize, snapsAligned, containScroll) {\n  const scrollBounds = Limit(-contentSize + viewSize, snapsAligned[0]);\n  const snapsBounded = measureBounded();\n  const snapsContained = measureContained();\n  function findDuplicates() {\n    const startSnap = snapsBounded[0];\n    const endSnap = arrayLast(snapsBounded);\n    const min = snapsBounded.lastIndexOf(startSnap);\n    const max = snapsBounded.indexOf(endSnap) + 1;\n    return Limit(min, max);\n  }\n  function measureBounded() {\n    return snapsAligned.map(scrollBounds.constrain).map(scrollBound => parseFloat(scrollBound.toFixed(3)));\n  }\n  function measureContained() {\n    if (contentSize <= viewSize) return [scrollBounds.max];\n    if (containScroll === 'keepSnaps') return snapsBounded;\n    const {\n      min,\n      max\n    } = findDuplicates();\n    return snapsBounded.slice(min, max);\n  }\n  const self = {\n    snapsContained\n  };\n  return self;\n}\n\nfunction ScrollLimit(contentSize, scrollSnaps, loop) {\n  const max = scrollSnaps[0];\n  const min = loop ? max - contentSize : arrayLast(scrollSnaps);\n  const limit = Limit(min, max);\n  const self = {\n    limit\n  };\n  return self;\n}\n\nfunction ScrollLooper(contentSize, limit, location, vectors) {\n  const jointSafety = 0.1;\n  const min = limit.min + jointSafety;\n  const max = limit.max + jointSafety;\n  const {\n    reachedMin,\n    reachedMax\n  } = Limit(min, max);\n  function shouldLoop(direction) {\n    if (direction === 1) return reachedMax(location.get());\n    if (direction === -1) return reachedMin(location.get());\n    return false;\n  }\n  function loop(direction) {\n    if (!shouldLoop(direction)) return;\n    const loopDistance = contentSize * (direction * -1);\n    vectors.forEach(v => v.add(loopDistance));\n  }\n  const self = {\n    loop\n  };\n  return self;\n}\n\nfunction ScrollProgress(limit) {\n  const {\n    max,\n    length: scrollLength\n  } = limit;\n  function get(n) {\n    const currentLocation = n - max;\n    return currentLocation / -scrollLength;\n  }\n  const self = {\n    get\n  };\n  return self;\n}\n\nfunction ScrollSnaps(axis, alignment, containerRect, slideRects, slideSizesWithGaps, slidesToScroll, containScroll) {\n  const {\n    startEdge,\n    endEdge\n  } = axis;\n  const {\n    groupSlides\n  } = slidesToScroll;\n  const alignments = measureSizes().map(alignment.measure);\n  const snaps = measureUnaligned();\n  const snapsAligned = measureAligned();\n  function measureSizes() {\n    return groupSlides(slideRects).map(rects => arrayLast(rects)[endEdge] - rects[0][startEdge]).map(mathAbs);\n  }\n  function measureUnaligned() {\n    return slideRects.map(rect => containerRect[startEdge] - rect[startEdge]).map(snap => -mathAbs(snap));\n  }\n  function measureAligned() {\n    const containedStartSnap = 0;\n    const containedEndSnap = arrayLast(snaps) - arrayLast(slideSizesWithGaps);\n    return groupSlides(snaps).map(g => g[0]).map((snap, index, groupedSnaps) => {\n      const isFirst = !index;\n      const isLast = index === arrayLastIndex(groupedSnaps);\n      if (containScroll && isFirst) return containedStartSnap;\n      if (containScroll && isLast) return containedEndSnap;\n      return snap + alignments[index];\n    });\n  }\n  const self = {\n    snaps,\n    snapsAligned\n  };\n  return self;\n}\n\nfunction ScrollTarget(loop, scrollSnaps, contentSize, limit, targetVector) {\n  const {\n    reachedAny,\n    removeOffset,\n    constrain\n  } = limit;\n  function minDistance(distances) {\n    return distances.concat().sort((a, b) => mathAbs(a) - mathAbs(b))[0];\n  }\n  function findTargetSnap(target) {\n    const distance = loop ? removeOffset(target) : constrain(target);\n    const ascDiffsToSnaps = scrollSnaps.map(scrollSnap => scrollSnap - distance).map(diffToSnap => shortcut(diffToSnap, 0)).map((diff, i) => ({\n      diff,\n      index: i\n    })).sort((d1, d2) => mathAbs(d1.diff) - mathAbs(d2.diff));\n    const {\n      index\n    } = ascDiffsToSnaps[0];\n    return {\n      index,\n      distance\n    };\n  }\n  function shortcut(target, direction) {\n    const targets = [target, target + contentSize, target - contentSize];\n    if (!loop) return targets[0];\n    if (!direction) return minDistance(targets);\n    const matchingTargets = targets.filter(t => mathSign(t) === direction);\n    return minDistance(matchingTargets);\n  }\n  function byIndex(index, direction) {\n    const diffToSnap = scrollSnaps[index] - targetVector.get();\n    const distance = shortcut(diffToSnap, direction);\n    return {\n      index,\n      distance\n    };\n  }\n  function byDistance(distance, snap) {\n    const target = targetVector.get() + distance;\n    const {\n      index,\n      distance: targetSnapDistance\n    } = findTargetSnap(target);\n    const reachedBound = !loop && reachedAny(target);\n    if (!snap || reachedBound) return {\n      index,\n      distance\n    };\n    const diffToSnap = scrollSnaps[index] - targetSnapDistance;\n    const snapDistance = distance + shortcut(diffToSnap, 0);\n    return {\n      index,\n      distance: snapDistance\n    };\n  }\n  const self = {\n    byDistance,\n    byIndex,\n    shortcut\n  };\n  return self;\n}\n\nfunction ScrollTo(animation, indexCurrent, indexPrevious, scrollTarget, targetVector, eventHandler) {\n  function scrollTo(target) {\n    const distanceDiff = target.distance;\n    const indexDiff = target.index !== indexCurrent.get();\n    if (distanceDiff) {\n      animation.start();\n      targetVector.add(distanceDiff);\n    }\n    if (indexDiff) {\n      indexPrevious.set(indexCurrent.get());\n      indexCurrent.set(target.index);\n      eventHandler.emit('select');\n    }\n  }\n  function distance(n, snap) {\n    const target = scrollTarget.byDistance(n, snap);\n    scrollTo(target);\n  }\n  function index(n, direction) {\n    const targetIndex = indexCurrent.clone().set(n);\n    const target = scrollTarget.byIndex(targetIndex.get(), direction);\n    scrollTo(target);\n  }\n  const self = {\n    distance,\n    index\n  };\n  return self;\n}\n\nfunction Vector1D(initialValue) {\n  let value = initialValue;\n  function get() {\n    return value;\n  }\n  function set(n) {\n    value = normalizeInput(n);\n  }\n  function add(n) {\n    value += normalizeInput(n);\n  }\n  function subtract(n) {\n    value -= normalizeInput(n);\n  }\n  function normalizeInput(n) {\n    return isNumber(n) ? n : n.get();\n  }\n  const self = {\n    get,\n    set,\n    add,\n    subtract\n  };\n  return self;\n}\n\nfunction Translate(axis, direction, container) {\n  const translate = axis.scroll === 'x' ? x : y;\n  const containerStyle = container.style;\n  let disabled = false;\n  function x(n) {\n    return `translate3d(${n}px,0px,0px)`;\n  }\n  function y(n) {\n    return `translate3d(0px,${n}px,0px)`;\n  }\n  function to(target) {\n    if (disabled) return;\n    containerStyle.transform = translate(direction.apply(target));\n  }\n  function toggleActive(active) {\n    disabled = !active;\n  }\n  function clear() {\n    if (disabled) return;\n    containerStyle.transform = '';\n    if (!container.getAttribute('style')) container.removeAttribute('style');\n  }\n  const self = {\n    clear,\n    to,\n    toggleActive\n  };\n  return self;\n}\n\nfunction SlideLooper(axis, direction, viewSize, contentSize, slideSizesWithGaps, scrollSnaps, slidesInView, scroll, slides) {\n  const ascItems = arrayKeys(slideSizesWithGaps);\n  const descItems = arrayKeys(slideSizesWithGaps).reverse();\n  const loopPoints = startPoints().concat(endPoints());\n  function removeSlideSizes(indexes, from) {\n    return indexes.reduce((a, i) => {\n      return a - slideSizesWithGaps[i];\n    }, from);\n  }\n  function slidesInGap(indexes, gap) {\n    return indexes.reduce((a, i) => {\n      const remainingGap = removeSlideSizes(a, gap);\n      return remainingGap > 0 ? a.concat([i]) : a;\n    }, []);\n  }\n  function findLoopPoints(indexes, edge) {\n    const isStartEdge = edge === 'start';\n    const offset = isStartEdge ? -contentSize : contentSize;\n    const slideBounds = slidesInView.findSlideBounds([offset]);\n    return indexes.map(index => {\n      const initial = isStartEdge ? 0 : -contentSize;\n      const altered = isStartEdge ? contentSize : 0;\n      const bounds = slideBounds.filter(b => b.index === index)[0];\n      const point = bounds[isStartEdge ? 'end' : 'start'];\n      const location = Vector1D(-1);\n      const translate = Translate(axis, direction, slides[index]);\n      const target = () => scroll.get() > point ? initial : altered;\n      return {\n        index,\n        location,\n        translate,\n        target\n      };\n    });\n  }\n  function startPoints() {\n    const gap = scrollSnaps[0] - 1;\n    const indexes = slidesInGap(descItems, gap);\n    return findLoopPoints(indexes, 'end');\n  }\n  function endPoints() {\n    const gap = viewSize - scrollSnaps[0] - 1;\n    const indexes = slidesInGap(ascItems, gap);\n    return findLoopPoints(indexes, 'start');\n  }\n  function canLoop() {\n    return loopPoints.every(({\n      index\n    }) => {\n      const otherIndexes = ascItems.filter(i => i !== index);\n      return removeSlideSizes(otherIndexes, viewSize) <= 0.1;\n    });\n  }\n  function loop() {\n    loopPoints.forEach(loopPoint => {\n      const {\n        target,\n        translate,\n        location\n      } = loopPoint;\n      const shift = target();\n      if (shift === location.get()) return;\n      translate.to(shift);\n      location.set(shift);\n    });\n  }\n  function clear() {\n    loopPoints.forEach(loopPoint => loopPoint.translate.clear());\n  }\n  const self = {\n    canLoop,\n    clear,\n    loop,\n    loopPoints\n  };\n  return self;\n}\n\nfunction SlidesHandler(container, eventHandler) {\n  let mutationObserver;\n  let destroyed = false;\n  function init(emblaApi, watchSlides) {\n    if (!watchSlides) return;\n    function defaultCallback(mutations) {\n      for (const mutation of mutations) {\n        if (mutation.type === 'childList') {\n          emblaApi.reInit();\n          eventHandler.emit('slidesChanged');\n          break;\n        }\n      }\n    }\n    mutationObserver = new MutationObserver(mutations => {\n      if (destroyed) return;\n      if (isBoolean(watchSlides) || watchSlides(emblaApi, mutations)) {\n        defaultCallback(mutations);\n      }\n    });\n    mutationObserver.observe(container, {\n      childList: true\n    });\n  }\n  function destroy() {\n    if (mutationObserver) mutationObserver.disconnect();\n    destroyed = true;\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction SlidesInView(viewSize, contentSize, slideSizes, snaps, limit, loop, inViewThreshold) {\n  const {\n    removeOffset,\n    constrain\n  } = limit;\n  const roundingSafety = 0.5;\n  const cachedOffsets = loop ? [0, contentSize, -contentSize] : [0];\n  const cachedBounds = findSlideBounds(cachedOffsets, inViewThreshold);\n  function findSlideThresholds(threshold) {\n    const slideThreshold = threshold || 0;\n    return slideSizes.map(slideSize => {\n      const thresholdLimit = Limit(roundingSafety, slideSize - roundingSafety);\n      return thresholdLimit.constrain(slideSize * slideThreshold);\n    });\n  }\n  function findSlideBounds(offsets, threshold) {\n    const slideOffsets = offsets || cachedOffsets;\n    const slideThresholds = findSlideThresholds(threshold);\n    return slideOffsets.reduce((list, offset) => {\n      const bounds = snaps.map((snap, index) => ({\n        start: snap - slideSizes[index] + slideThresholds[index] + offset,\n        end: snap + viewSize - slideThresholds[index] + offset,\n        index\n      }));\n      return list.concat(bounds);\n    }, []);\n  }\n  function check(location, bounds) {\n    const limitedLocation = loop ? removeOffset(location) : constrain(location);\n    const slideBounds = bounds || cachedBounds;\n    return slideBounds.reduce((list, slideBound) => {\n      const {\n        index,\n        start,\n        end\n      } = slideBound;\n      const inList = list.includes(index);\n      const inView = start < limitedLocation && end > limitedLocation;\n      return !inList && inView ? list.concat([index]) : list;\n    }, []);\n  }\n  const self = {\n    check,\n    findSlideBounds\n  };\n  return self;\n}\n\nfunction SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow) {\n  const {\n    measureSize,\n    startEdge,\n    endEdge\n  } = axis;\n  const withEdgeGap = slideRects[0] && readEdgeGap;\n  const startGap = measureStartGap();\n  const endGap = measureEndGap();\n  const slideSizes = slideRects.map(measureSize);\n  const slideSizesWithGaps = measureWithGaps();\n  function measureStartGap() {\n    if (!withEdgeGap) return 0;\n    const slideRect = slideRects[0];\n    return mathAbs(containerRect[startEdge] - slideRect[startEdge]);\n  }\n  function measureEndGap() {\n    if (!withEdgeGap) return 0;\n    const style = ownerWindow.getComputedStyle(arrayLast(slides));\n    return parseFloat(style.getPropertyValue(`margin-${endEdge}`));\n  }\n  function measureWithGaps() {\n    return slideRects.map((rect, index, rects) => {\n      const isFirst = !index;\n      const isLast = index === arrayLastIndex(rects);\n      if (isFirst) return slideSizes[index] + startGap;\n      if (isLast) return slideSizes[index] + endGap;\n      return rects[index + 1][startEdge] - rect[startEdge];\n    }).map(mathAbs);\n  }\n  const self = {\n    slideSizes,\n    slideSizesWithGaps\n  };\n  return self;\n}\n\nfunction SlidesToScroll(viewSize, slideSizesWithGaps, slidesToScroll) {\n  const groupByNumber = isNumber(slidesToScroll);\n  function byNumber(array, groupSize) {\n    return arrayKeys(array).filter(i => i % groupSize === 0).map(i => array.slice(i, i + groupSize));\n  }\n  function bySize(array) {\n    return arrayKeys(array).reduce((groupSizes, i) => {\n      const chunk = slideSizesWithGaps.slice(arrayLast(groupSizes), i + 1);\n      const chunkSize = chunk.reduce((a, s) => a + s, 0);\n      return !i || chunkSize > viewSize ? groupSizes.concat(i) : groupSizes;\n    }, []).map((start, i, groupSizes) => array.slice(start, groupSizes[i + 1]));\n  }\n  function groupSlides(array) {\n    return groupByNumber ? byNumber(array, slidesToScroll) : bySize(array);\n  }\n  const self = {\n    groupSlides\n  };\n  return self;\n}\n\nfunction Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler, animations) {\n  // Options\n  const {\n    align,\n    axis: scrollAxis,\n    direction: contentDirection,\n    startIndex,\n    inViewThreshold,\n    loop,\n    duration,\n    dragFree,\n    dragThreshold,\n    slidesToScroll: groupSlides,\n    skipSnaps,\n    containScroll\n  } = options;\n  // Measurements\n  const containerRect = container.getBoundingClientRect();\n  const slideRects = slides.map(slide => slide.getBoundingClientRect());\n  const direction = Direction(contentDirection);\n  const axis = Axis(scrollAxis, contentDirection);\n  const viewSize = axis.measureSize(containerRect);\n  const percentOfView = PercentOfView(viewSize);\n  const alignment = Alignment(align, viewSize);\n  const containSnaps = !loop && !!containScroll;\n  const readEdgeGap = loop || !!containScroll;\n  const {\n    slideSizes,\n    slideSizesWithGaps\n  } = SlideSizes(axis, containerRect, slideRects, slides, readEdgeGap, ownerWindow);\n  const slidesToScroll = SlidesToScroll(viewSize, slideSizesWithGaps, groupSlides);\n  const {\n    snaps,\n    snapsAligned\n  } = ScrollSnaps(axis, alignment, containerRect, slideRects, slideSizesWithGaps, slidesToScroll, containSnaps);\n  const contentSize = -arrayLast(snaps) + arrayLast(slideSizesWithGaps);\n  const {\n    snapsContained\n  } = ScrollContain(viewSize, contentSize, snapsAligned, containScroll);\n  const scrollSnaps = containSnaps ? snapsContained : snapsAligned;\n  const {\n    limit\n  } = ScrollLimit(contentSize, scrollSnaps, loop);\n  // Indexes\n  const index = Counter(arrayLastIndex(scrollSnaps), startIndex, loop);\n  const indexPrevious = index.clone();\n  const slideIndexes = arrayKeys(slides);\n  // Animation\n  const update = ({\n    dragHandler,\n    scrollBody,\n    scrollBounds,\n    scrollLooper,\n    slideLooper,\n    eventHandler,\n    animation,\n    options: {\n      loop\n    }\n  }) => {\n    const pointerDown = dragHandler.pointerDown();\n    if (!loop) scrollBounds.constrain(pointerDown);\n    const hasSettled = scrollBody.seek().settled();\n    if (hasSettled && !pointerDown) {\n      animation.stop();\n      eventHandler.emit('settle');\n    }\n    if (!hasSettled) {\n      eventHandler.emit('scroll');\n    }\n    if (loop) {\n      scrollLooper.loop(scrollBody.direction());\n      slideLooper.loop();\n    }\n  };\n  const render = ({\n    scrollBody,\n    translate,\n    location\n  }, lagOffset) => {\n    const velocity = scrollBody.velocity();\n    const offsetLocation = location.get() - velocity + velocity * lagOffset;\n    translate.to(offsetLocation);\n  };\n  const animation = {\n    update: () => update(engine),\n    render: lagOffset => render(engine, lagOffset),\n    start: () => animations.start(engine),\n    stop: () => animations.stop(engine)\n  };\n  // Shared\n  const friction = 0.68;\n  const startLocation = scrollSnaps[index.get()];\n  const location = Vector1D(startLocation);\n  const target = Vector1D(startLocation);\n  const scrollBody = ScrollBody(location, target, duration, friction);\n  const scrollTarget = ScrollTarget(loop, scrollSnaps, contentSize, limit, target);\n  const scrollTo = ScrollTo(animation, index, indexPrevious, scrollTarget, target, eventHandler);\n  const slidesInView = SlidesInView(viewSize, contentSize, slideSizes, snaps, limit, loop, inViewThreshold);\n  // Engine\n  const engine = {\n    ownerDocument,\n    ownerWindow,\n    eventHandler,\n    containerRect,\n    slideRects,\n    animation,\n    axis,\n    direction,\n    dragHandler: DragHandler(axis, direction, root, ownerDocument, ownerWindow, target, DragTracker(axis, ownerWindow), location, animation, scrollTo, scrollBody, scrollTarget, index, eventHandler, percentOfView, dragFree, dragThreshold, skipSnaps, friction),\n    eventStore: EventStore(),\n    percentOfView,\n    index,\n    indexPrevious,\n    limit,\n    location,\n    options,\n    resizeHandler: ResizeHandler(container, slides, axis, eventHandler),\n    scrollBody,\n    scrollBounds: ScrollBounds(limit, location, target, scrollBody, percentOfView),\n    scrollLooper: ScrollLooper(contentSize, limit, location, [location, target]),\n    scrollProgress: ScrollProgress(limit),\n    scrollSnaps,\n    scrollTarget,\n    scrollTo,\n    slideLooper: SlideLooper(axis, direction, viewSize, contentSize, slideSizesWithGaps, scrollSnaps, slidesInView, location, slides),\n    slidesHandler: SlidesHandler(container, eventHandler),\n    slidesInView,\n    slideIndexes,\n    slidesToScroll,\n    target,\n    translate: Translate(axis, direction, container)\n  };\n  return engine;\n}\n\nfunction Animations(ownerWindow) {\n  const timeStep = 1000 / 60;\n  let engines = [];\n  let lastTimeStamp = null;\n  let lag = 0;\n  let animationFrame = 0;\n  function animate(timeStamp) {\n    if (!lastTimeStamp) lastTimeStamp = timeStamp;\n    const elapsed = timeStamp - lastTimeStamp;\n    lastTimeStamp = timeStamp;\n    lag += elapsed;\n    while (lag >= timeStep) {\n      engines.forEach(({\n        animation\n      }) => animation.update());\n      lag -= timeStep;\n    }\n    const lagOffset = mathAbs(lag / timeStep);\n    engines.forEach(({\n      animation\n    }) => animation.render(lagOffset));\n    if (animationFrame) ownerWindow.requestAnimationFrame(animate);\n  }\n  function start(engine) {\n    if (!engines.includes(engine)) engines.push(engine);\n    if (animationFrame) return;\n    animationFrame = ownerWindow.requestAnimationFrame(animate);\n  }\n  function stop(engine) {\n    engines = engines.filter(e => e !== engine);\n    if (engines.length) return;\n    ownerWindow.cancelAnimationFrame(animationFrame);\n    lastTimeStamp = null;\n    lag = 0;\n    animationFrame = 0;\n  }\n  function reset() {\n    lastTimeStamp = null;\n    lag = 0;\n  }\n  const self = {\n    start,\n    stop,\n    reset,\n    window: ownerWindow\n  };\n  return self;\n}\n\nfunction EventHandler() {\n  const listeners = {};\n  let api;\n  function init(emblaApi) {\n    api = emblaApi;\n  }\n  function getListeners(evt) {\n    return listeners[evt] || [];\n  }\n  function emit(evt) {\n    getListeners(evt).forEach(e => e(api, evt));\n    return self;\n  }\n  function on(evt, cb) {\n    listeners[evt] = getListeners(evt).concat([cb]);\n    return self;\n  }\n  function off(evt, cb) {\n    listeners[evt] = getListeners(evt).filter(e => e !== cb);\n    return self;\n  }\n  const self = {\n    init,\n    emit,\n    off,\n    on\n  };\n  return self;\n}\n\nconst defaultOptions = {\n  align: 'center',\n  axis: 'x',\n  container: null,\n  slides: null,\n  containScroll: null,\n  direction: 'ltr',\n  slidesToScroll: 1,\n  breakpoints: {},\n  dragFree: false,\n  dragThreshold: 10,\n  inViewThreshold: 0,\n  loop: false,\n  skipSnaps: false,\n  duration: 25,\n  startIndex: 0,\n  active: true,\n  watchDrag: true,\n  watchResize: true,\n  watchSlides: true\n};\n\nfunction OptionsHandler(ownerWindow) {\n  function mergeOptions(optionsA, optionsB) {\n    return objectsMergeDeep(optionsA, optionsB || {});\n  }\n  function optionsAtMedia(options) {\n    const optionsAtMedia = options.breakpoints || {};\n    const matchedMediaOptions = objectKeys(optionsAtMedia).filter(media => ownerWindow.matchMedia(media).matches).map(media => optionsAtMedia[media]).reduce((a, mediaOption) => mergeOptions(a, mediaOption), {});\n    return mergeOptions(options, matchedMediaOptions);\n  }\n  function optionsMediaQueries(optionsList) {\n    return optionsList.map(options => objectKeys(options.breakpoints || {})).reduce((acc, mediaQueries) => acc.concat(mediaQueries), []).map(ownerWindow.matchMedia);\n  }\n  const self = {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  };\n  return self;\n}\n\nfunction PluginsHandler(optionsHandler) {\n  let activePlugins = [];\n  function init(plugins, emblaApi) {\n    activePlugins = plugins.filter(({\n      options\n    }) => optionsHandler.optionsAtMedia(options).active !== false);\n    activePlugins.forEach(plugin => plugin.init(emblaApi, optionsHandler));\n    return plugins.reduce((map, plugin) => Object.assign(map, {\n      [plugin.name]: plugin\n    }), {});\n  }\n  function destroy() {\n    activePlugins = activePlugins.filter(plugin => plugin.destroy());\n  }\n  const self = {\n    init,\n    destroy\n  };\n  return self;\n}\n\nfunction EmblaCarousel(root, userOptions, userPlugins) {\n  const ownerDocument = root.ownerDocument;\n  const ownerWindow = ownerDocument.defaultView;\n  const optionsHandler = OptionsHandler(ownerWindow);\n  const pluginsHandler = PluginsHandler(optionsHandler);\n  const mediaHandlers = EventStore();\n  const documentVisibleHandler = EventStore();\n  const eventHandler = EventHandler();\n  const {\n    animationRealms\n  } = EmblaCarousel;\n  const {\n    mergeOptions,\n    optionsAtMedia,\n    optionsMediaQueries\n  } = optionsHandler;\n  const {\n    on,\n    off,\n    emit\n  } = eventHandler;\n  const reInit = reActivate;\n  let destroyed = false;\n  let engine;\n  let optionsBase = mergeOptions(defaultOptions, EmblaCarousel.globalOptions);\n  let options = mergeOptions(optionsBase);\n  let pluginList = [];\n  let pluginApis;\n  let container;\n  let slides;\n  function storeElements() {\n    const {\n      container: userContainer,\n      slides: userSlides\n    } = options;\n    const customContainer = isString(userContainer) ? root.querySelector(userContainer) : userContainer;\n    container = customContainer || root.children[0];\n    const customSlides = isString(userSlides) ? container.querySelectorAll(userSlides) : userSlides;\n    slides = [].slice.call(customSlides || container.children);\n  }\n  function activate(withOptions, withPlugins) {\n    if (destroyed) return;\n    const animationRealm = animationRealms.find(a => a.window === ownerWindow);\n    const animations = animationRealm || Animations(ownerWindow);\n    if (!animationRealm) animationRealms.push(animations);\n    optionsBase = mergeOptions(optionsBase, withOptions);\n    options = optionsAtMedia(optionsBase);\n    pluginList = withPlugins || pluginList;\n    storeElements();\n    engine = Engine(root, container, slides, ownerDocument, ownerWindow, options, eventHandler, animations);\n    optionsMediaQueries([optionsBase, ...pluginList.map(({\n      options\n    }) => options)]).forEach(query => mediaHandlers.add(query, 'change', reActivate));\n    if (!options.active) return;\n    engine.translate.to(engine.location.get());\n    engine.eventHandler.init(self);\n    engine.resizeHandler.init(self, options.watchResize);\n    engine.slidesHandler.init(self, options.watchSlides);\n    documentVisibleHandler.add(ownerDocument, 'visibilitychange', () => {\n      if (ownerDocument.hidden) animations.reset();\n    });\n    if (options.loop) {\n      if (!engine.slideLooper.canLoop()) {\n        deActivate();\n        activate({\n          loop: false\n        }, withPlugins);\n        optionsBase = mergeOptions(optionsBase, {\n          loop: true\n        });\n        return;\n      }\n      engine.slideLooper.loop();\n    }\n    if (container.offsetParent && slides.length) {\n      engine.dragHandler.init(self, options.watchDrag);\n    }\n    pluginApis = pluginsHandler.init(pluginList, self);\n  }\n  function reActivate(withOptions, withPlugins) {\n    const startIndex = selectedScrollSnap();\n    deActivate();\n    activate(mergeOptions({\n      startIndex\n    }, withOptions), withPlugins);\n    eventHandler.emit('reInit');\n  }\n  function deActivate() {\n    engine.dragHandler.destroy();\n    engine.animation.stop();\n    engine.eventStore.clear();\n    engine.translate.clear();\n    engine.slideLooper.clear();\n    engine.resizeHandler.destroy();\n    engine.slidesHandler.destroy();\n    pluginsHandler.destroy();\n    mediaHandlers.clear();\n    documentVisibleHandler.clear();\n  }\n  function destroy() {\n    if (destroyed) return;\n    destroyed = true;\n    mediaHandlers.clear();\n    deActivate();\n    eventHandler.emit('destroy');\n  }\n  function slidesInView(target) {\n    const location = engine[target ? 'target' : 'location'].get();\n    const type = options.loop ? 'removeOffset' : 'constrain';\n    return engine.slidesInView.check(engine.limit[type](location));\n  }\n  function slidesNotInView(target) {\n    const inView = slidesInView(target);\n    return engine.slideIndexes.filter(index => !inView.includes(index));\n  }\n  function scrollTo(index, jump, direction) {\n    if (!options.active || destroyed) return;\n    engine.scrollBody.useBaseFriction().useDuration(jump ? 0 : options.duration);\n    engine.scrollTo.index(index, direction || 0);\n  }\n  function scrollNext(jump) {\n    const next = engine.index.add(1).get();\n    scrollTo(next, jump === true, -1);\n  }\n  function scrollPrev(jump) {\n    const prev = engine.index.add(-1).get();\n    scrollTo(prev, jump === true, 1);\n  }\n  function canScrollNext() {\n    const next = engine.index.add(1).get();\n    return next !== selectedScrollSnap();\n  }\n  function canScrollPrev() {\n    const prev = engine.index.add(-1).get();\n    return prev !== selectedScrollSnap();\n  }\n  function scrollSnapList() {\n    return engine.scrollSnaps.map(engine.scrollProgress.get);\n  }\n  function scrollProgress() {\n    return engine.scrollProgress.get(engine.location.get());\n  }\n  function selectedScrollSnap() {\n    return engine.index.get();\n  }\n  function previousScrollSnap() {\n    return engine.indexPrevious.get();\n  }\n  function plugins() {\n    return pluginApis;\n  }\n  function internalEngine() {\n    return engine;\n  }\n  function rootNode() {\n    return root;\n  }\n  function containerNode() {\n    return container;\n  }\n  function slideNodes() {\n    return slides;\n  }\n  const self = {\n    canScrollNext,\n    canScrollPrev,\n    containerNode,\n    internalEngine,\n    destroy,\n    off,\n    on,\n    emit,\n    plugins,\n    previousScrollSnap,\n    reInit,\n    rootNode,\n    scrollNext,\n    scrollPrev,\n    scrollProgress,\n    scrollSnapList,\n    scrollTo,\n    selectedScrollSnap,\n    slideNodes,\n    slidesInView,\n    slidesNotInView\n  };\n  activate(userOptions, userPlugins);\n  setTimeout(() => eventHandler.emit('init'), 0);\n  return self;\n}\nEmblaCarousel.animationRealms = [];\nEmblaCarousel.globalOptions = undefined;\n\nexport { EmblaCarousel as default };\n//# sourceMappingURL=embla-carousel.esm.js.map\n","import { useRef, useState, useCallback, useEffect } from 'react';\nimport { canUseDOM, areOptionsEqual, arePluginsEqual } from 'embla-carousel-reactive-utils';\nimport EmblaCarousel from 'embla-carousel';\n\nfunction useEmblaCarousel(options = {}, plugins = []) {\n  const storedOptions = useRef(options);\n  const storedPlugins = useRef(plugins);\n  const [emblaApi, setEmblaApi] = useState();\n  const [viewport, setViewport] = useState();\n  const reInit = useCallback(() => {\n    if (emblaApi) emblaApi.reInit(storedOptions.current, storedPlugins.current);\n  }, [emblaApi]);\n  useEffect(() => {\n    if (canUseDOM() && viewport) {\n      EmblaCarousel.globalOptions = useEmblaCarousel.globalOptions;\n      const newEmblaApi = EmblaCarousel(viewport, storedOptions.current, storedPlugins.current);\n      setEmblaApi(newEmblaApi);\n      return () => newEmblaApi.destroy();\n    } else {\n      setEmblaApi(undefined);\n    }\n  }, [viewport, setEmblaApi]);\n  useEffect(() => {\n    if (areOptionsEqual(storedOptions.current, options)) return;\n    storedOptions.current = options;\n    reInit();\n  }, [options, reInit]);\n  useEffect(() => {\n    if (arePluginsEqual(storedPlugins.current, plugins)) return;\n    storedPlugins.current = plugins;\n    reInit();\n  }, [plugins, reInit]);\n  return [setViewport, emblaApi];\n}\nuseEmblaCarousel.globalOptions = undefined;\n\nexport { useEmblaCarousel as default };\n//# sourceMappingURL=embla-carousel-react.esm.js.map\n","import React from 'react'\nimport imageLeft from '../../../static/assets/icons/arrow-left.svg'\nimport imageRight from '../../../static/assets/icons/arrow-right.svg'\n\ninterface DotButtonPropType {\n  selected: boolean\n  onClick: () => void\n}\n\nexport const DotButton: React.FC<DotButtonPropType> = (props) => {\n  const { selected, onClick } = props\n\n  return (\n        <button\n        className={'embla__dot'.concat(selected ? ' embla__dot--selected' : '')}\n        type=\"button\"\n        onClick={onClick}\n        />\n  )\n}\n\ninterface PrevNextButtonPropType {\n  enabled: boolean\n  onClick: () => void\n}\n\nexport const PrevButton: React.FC<PrevNextButtonPropType> = (props) => {\n  const { enabled, onClick } = props\n\n  return (\n        <button\n            className=\"embla__button embla__button--prev\"\n            onClick={onClick}\n            disabled={!enabled}\n            >\n                <img src={imageLeft} alt=\"Previous\" className=\"embla__button__img\" />\n            </button>\n  )\n}\n\nexport const NextButton: React.FC<PrevNextButtonPropType> = (props) => {\n  const { enabled, onClick } = props\n\n  return (\n        <button\n            className=\"embla__button embla__button--next\"\n            onClick={onClick}\n            disabled={!enabled}\n            >\n                <img src={imageRight} alt=\"Next\" className=\"embla__button__img\" />\n            </button>\n  )\n}\n","export default \"data:image/svg+xml;base64,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\"","export default \"data:image/svg+xml;base64,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\"","import React, { useState, useEffect, useCallback } from \"react\";\nimport useEmblaCarousel, {\n  type EmblaCarouselType,\n  type EmblaOptionsType,\n} from \"embla-carousel-react\";\n\nimport {\n  DotButton,\n  NextButton,\n  PrevButton,\n} from \"../shared/EmblaCarouselArrowsDotsButtons\";\n\nimport { graphql, useStaticQuery } from \"gatsby\";\n\ninterface SlideType {\n  sliderImage: {\n    altText: string;\n    sourceUrl: string;\n  };\n  sliderImageMobile: {\n    altText: string;\n    sourceUrl: string;\n  };\n}\n\ninterface WPQueryResult {\n  allWpPage: {\n    nodes: {\n      slider_home: {\n        sliderHome: SlideType[];\n      };\n    }[];\n  };\n}\n\nconst EmblaCarousel: React.FC = () => {\n  const options: EmblaOptionsType = {};\n  // todo: se debería mover este query.\n  const data: WPQueryResult = useStaticQuery(graphql`\n    query PageHomeSlider {\n      allWpPage(filter: { id: { eq: \"cG9zdDoxMg==\" } }) {\n        nodes {\n          slider_home {\n            sliderHome {\n              sliderImage {\n                altText\n                sourceUrl\n              }\n              sliderImageMobile {\n                altText\n                sourceUrl\n              }\n            }\n          }\n        }\n      }\n    }\n  `);\n\n  const slides: SlideType[] = data.allWpPage.nodes[0].slider_home.sliderHome;\n\n  const [emblaRef, emblaApi] = useEmblaCarousel(options);\n  const [prevBtnEnabled, setPrevBtnEnabled] = useState(false);\n  const [nextBtnEnabled, setNextBtnEnabled] = useState(false);\n  const [selectedIndex, setSelectedIndex] = useState(0);\n  const [scrollSnaps, setScrollSnaps] = useState<number[]>([]);\n\n  const scrollPrev = useCallback(() => emblaApi?.scrollPrev(), [emblaApi]);\n  const scrollNext = useCallback(() => emblaApi?.scrollNext(), [emblaApi]);\n  const scrollTo = useCallback(\n    (index: number) => emblaApi?.scrollTo(index),\n    [emblaApi]\n  );\n\n  const onInit = useCallback((emblaApi: EmblaCarouselType) => {\n    setScrollSnaps(emblaApi.scrollSnapList());\n  }, []);\n\n  const onSelect = useCallback((emblaApi: EmblaCarouselType) => {\n    setSelectedIndex(emblaApi.selectedScrollSnap());\n    setPrevBtnEnabled(emblaApi.canScrollPrev());\n    setNextBtnEnabled(emblaApi.canScrollNext());\n  }, []);\n\n  useEffect(() => {\n    if (!emblaApi) return;\n\n    onInit(emblaApi);\n    onSelect(emblaApi);\n\n    emblaApi.on(\"reInit\", onInit);\n    emblaApi.on(\"reInit\", onSelect);\n    emblaApi.on(\"select\", onSelect);\n\n    return () => {\n      emblaApi.off(\"reInit\", onInit);\n      emblaApi.off(\"reInit\", onSelect);\n      emblaApi.off(\"select\", onSelect);\n    };\n  }, [emblaApi, onInit, onSelect]);\n\n  return (\n    <>\n      <div className=\"embla__container\">\n        <div className=\"embla\">\n          <div className=\"embla__viewport\" ref={emblaRef}>\n            <div className=\"embla__container\">\n              {slides.map((slide, index) => (\n                <div className=\"embla__slide\" key={index}>\n                  <div className=\"embla__slide__number\">\n                    <span>{index + 1}</span>\n                  </div>\n                  <picture>\n                    <source\n                      media=\"(max-width: 768px)\"\n                      srcSet={slide.sliderImageMobile.sourceUrl}\n                    />\n                    <source\n                      media=\"(min-width: 769px)\"\n                      srcSet={slide.sliderImage.sourceUrl}\n                    />\n                    <img\n                      src={slide.sliderImage.sourceUrl} // Fallback\n                      alt={slide.sliderImage.altText}\n                      className=\"embla__slide__img\"\n                    />\n                  </picture>\n                </div>\n              ))}\n            </div>\n          </div>\n\n          <PrevButton onClick={scrollPrev} enabled={prevBtnEnabled} />\n          <NextButton onClick={scrollNext} enabled={nextBtnEnabled} />\n        </div>\n        <div className=\"embla__dots\">\n          {scrollSnaps.map((_, index) => (\n            <DotButton\n              key={index}\n              selected={index === selectedIndex}\n              onClick={() => scrollTo(index)}\n            />\n          ))}\n        </div>\n      </div>\n    </>\n  );\n};\n\nexport default EmblaCarousel;\n","import React from \"react\";\nimport { graphql, useStaticQuery } from \"gatsby\";\n\nconst Gallery: React.FC = () => {\n  const data = useStaticQuery(graphql`\n    query HomePlatos {\n      allWpPage(filter: { id: { eq: \"cG9zdDoxMg==\" } }) {\n        edges {\n          node {\n            id\n            slider_home {\n              bgColor\n              titleCarta\n              imagenCartaVertical {\n                altText\n                mediaItemUrl\n              }\n              imagenCartaVerticalMovil {\n                altText\n                mediaItemUrl\n              }\n              textoCartaVertical\n              urlPdfCartaVertical\n              cartas {\n                textoCarta\n                urlPdfCarta\n                imagenCartaMovil {\n                  altText\n                  mediaItemUrl\n                }\n                imagenCarta {\n                  altText\n                  mediaItemUrl\n                }\n              }\n            }\n          }\n        }\n      }\n    }\n  `);\n\n  const {\n    cartas,\n    bgColor,\n    titleCarta,\n    imagenCartaVertical,\n    imagenCartaVerticalMovil,\n    textoCartaVertical,\n    urlPdfCartaVertical,\n  } = data.allWpPage.edges[0].node.slider_home;\n\n  return (\n    <section\n      id=\"la-carta\"\n      className=\"gallery-flex\"\n      style={{ backgroundColor: bgColor }}\n    >\n      <h2 className=\"gallery-title\">{titleCarta}</h2>\n      <div className=\"gallery-grid\">\n        <div className=\"gallery-column\">\n          <div className=\"gallery-image-container\">\n            <a href={urlPdfCartaVertical} className=\"gallery-link\">\n              <div className=\"overlay\"></div>\n              <picture>\n                <source\n                  media=\"(max-width: 600px)\"\n                  srcSet={imagenCartaVerticalMovil.mediaItemUrl}\n                />\n                <source\n                  media=\"(min-width: 601px)\"\n                  srcSet={imagenCartaVertical.mediaItemUrl}\n                />\n                <img\n                  src={imagenCartaVertical.mediaItemUrl} // Fallback\n                  alt={imagenCartaVertical.altText}\n                  className=\"gallery-image-vertical\"\n                />\n              </picture>\n              <div className=\"gallery-text-overlay\">\n                <h3>\n                  <span\n                    dangerouslySetInnerHTML={{ __html: textoCartaVertical }}\n                  />\n                </h3>\n              </div>\n            </a>\n          </div>\n        </div>\n        <div className=\"gallery-column\">\n          {cartas\n            .slice(0, 2)\n            .map((carta: any, index: React.Key | null | undefined) => (\n              <div className=\"gallery-image-container\" key={index}>\n\n                <a href={carta.urlPdfCarta} className=\"gallery-link\">\n                  <div className=\"overlay\"></div>\n                  <picture>\n                    <source\n                      media=\"(max-width: 600px)\"\n                      srcSet={carta.imagenCartaMovil.mediaItemUrl}\n                    />\n                    <source\n                      media=\"(min-width: 601px)\"\n                      srcSet={carta.imagenCarta.mediaItemUrl}\n                    />\n                    <img\n                      src={carta.imagenCarta.mediaItemUrl} // Fallback\n                      alt={carta.imagenCarta.altText}\n                      className=\"gallery-image-horizontal\"\n                    />\n                  </picture>\n                  <div className=\"gallery-text-overlay\">\n                    <h3>\n                      <span\n                        dangerouslySetInnerHTML={{\n                          __html:\n                            typeof carta.textoCarta === \"string\"\n                              ? carta.textoCarta\n                              : \"\",\n                        }}\n                      />\n                    </h3>\n                  </div>\n                </a>\n              </div>\n            ))}\n        </div>\n        <div className=\"gallery-column\">\n          {cartas\n            .slice(2)\n            .map((carta: any, index: React.Key | null | undefined) => (\n              <div className=\"gallery-image-container\" key={index}>\n\n                <a href={carta.urlPdfCarta} className=\"gallery-link\">\n                  <div className=\"overlay\"></div>\n                  <picture>\n                    <source\n                      media=\"(max-width: 600px)\"\n                      srcSet={carta.imagenCartaMovil.mediaItemUrl}\n                    />\n                    <source\n                      media=\"(min-width: 601px)\"\n                      srcSet={carta.imagenCarta.mediaItemUrl}\n                    />\n                    <img\n                      src={carta.imagenCarta.mediaItemUrl} // Fallback\n                      alt={carta.imagenCarta.altText}\n                      className=\"gallery-image-horizontal\"\n                    />\n                  </picture>\n                  <div className=\"gallery-text-overlay\">\n                    <h3>\n                      <span\n                        dangerouslySetInnerHTML={{\n                          __html:\n                            typeof carta.textoCarta === \"string\"\n                              ? carta.textoCarta\n                              : \"\",\n                        }}\n                      />\n                    </h3>\n                  </div>\n                </a>\n              </div>\n            ))}\n        </div>\n      </div>\n    </section>\n  );\n};\n\nexport default Gallery;\n","import * as React from \"react\";\nimport { graphql, type HeadFC, type PageProps } from \"gatsby\";\nimport { Layout } from \"../components/layout/layout\";\n\n//? Import de las secciones.\nimport SectionWithAnimation from \"../components/pages/shared/text-animation\";\nimport NuestraPizarrita from \"../components/pages/home/pizzarita/nuestra-pizarrita\";\nimport SliderLocals from \"../components/pages/shared/slider-images-right\";\nimport SliderFood from \"../components/pages/shared/slider-images-left\";\nimport EmblaCarousel from \"../components/pages/home/EmblaCarousel\";\nimport Gallery from \"../components/pages/home/gallery\";\nimport { Seo } from \"../components/pages/shared/seo/Seo\";\n\nconst IndexPage: React.FC<PageProps> = () => {\n  return (\n    <Layout headerTransition={true}>\n      {/* All sections must be on components. */}\n      <section className=\"sandbox__carousel\">\n        <EmblaCarousel />\n      </section>\n      <section id=\"sectionwithanimation\">\n        <SectionWithAnimation />\n      </section>\n      <section>\n        <div>\n          <SliderFood />\n        </div>\n      </section>\n      <section>\n        <div>\n          <SliderLocals />\n        </div>\n      </section>\n      <section id=\"carta\">\n        <Gallery />\n      </section>\n      <NuestraPizarrita />\n    </Layout>\n  );\n};\n\nexport default IndexPage;\nexport const Head: HeadFC<{ wpPage: any }> = ({ data }) => {\n  const { wpPage } = data;\n  return (\n    <Seo\n      seoDescription={wpPage.seo.opengraphDescription}\n      SeoImage={wpPage.seo.opengraphImage?.publicUrl}\n      metaDescription={wpPage.seo.metaDesc}\n      seoTitle={wpPage.seo.opengraphTitle}\n      seoType={wpPage.seo.opengraphType}\n      SeoUrl={wpPage.seo.opengraphUrl}\n      metatitle={wpPage.seo.title}\n    />\n  );\n};\n\nexport const pageQuery = graphql`\n  query IndexPageQuery {\n    wpPage(slug: { eq: \"home\" }) {\n      seo {\n        title\n        metaDesc\n        opengraphUrl\n        opengraphType\n        opengraphTitle\n        opengraphDescription\n        opengraphImage {\n          publicUrl\n        }\n      }\n    }\n  }\n`;\n","export default \"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB3aWR0aD0iMzNweCIgaGVpZ2h0PSIyNHB4IiB2aWV3Qm94PSIwIDAgMzMgMjQiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+CiAgICA8dGl0bGU+TmF2aWdhdGlvbi9BcnJvdy8zLnJpZ2h0LzEuT3V0bGluZTwvdGl0bGU+CiAgICA8ZyBpZD0iU3ltYm9scyIgc3Ryb2tlPSJub25lIiBzdHJva2Utd2lkdGg9IjEiIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCI+CiAgICAgICAgPGcgaWQ9Ik5hdmlnYXRpb24vQXJyb3cvMy5yaWdodC8xLk91dGxpbmUiIGZpbGw9IiNFRkU3RDQiIGZpbGwtcnVsZT0ibm9uemVybyI+CiAgICAgICAgICAgIDxnIGlkPSJBcnJvdy00LSgxKS1Db3B5IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxLjAwMDAwMCwgNi4wMDAwMDApIj4KICAgICAgICAgICAgICAgIDxwYXRoIGQ9Ik0zMC41MzAzMzE3LDQuOTkyNjM0MjUgQzMwLjgyMzIzMTcsNS4yODU1MzQyNSAzMC44MjMyMzE3LDUuNzYwNDA0MjUgMzAuNTMwMzMxNyw2LjA1MzI5NDI1IEwyNS43NTczMzE3LDEwLjgyNjI4NDMgQzI1LjQ2NDQzMTcsMTEuMTE5MTg0MyAyNC45ODk2MzE3LDExLjExOTE4NDMgMjQuNjk2NzMxNywxMC44MjYyODQzIEMyNC40MDM4MzE3LDEwLjUzMzM4NDMgMjQuNDAzODMxNywxMC4wNTg0ODQzIDI0LjY5NjczMTcsOS43NjU1ODQyNSBMMjguOTM5MzMxNyw1LjUyMjk2NDI1IEwyNC42OTY3MzE3LDEuMjgwMzM0MjUgQzI0LjQwMzgzMTcsMC45ODc0MzQyNSAyNC40MDM4MzE3LDAuNTEyNTYzMjUgMjQuNjk2NzMxNywwLjIxOTY3MDI1IEMyNC45ODk2MzE3LC0wLjA3MzIyMjc1IDI1LjQ2NDQzMTcsLTAuMDczMjIzNzUgMjUuNzU3MzMxNywwLjIxOTY2OTI1IEwzMC41MzAzMzE3LDQuOTkyNjM0MjUgWiBNMCw0Ljc3Mjk4NDI1IEwzMC4wMDAwMzE3LDQuNzcyOTY0MjUgTDMwLjAwMDAzMTcsNi4yNzI5NjQyNSBMMCw2LjI3Mjk4NDI1IEwwLDQuNzcyOTg0MjUgWiIgaWQ9IlNoYXBlIj48L3BhdGg+CiAgICAgICAgICAgIDwvZz4KICAgICAgICA8L2c+CiAgICA8L2c+Cjwvc3ZnPg==\"","export default \"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB3aWR0aD0iMzNweCIgaGVpZ2h0PSIyNHB4IiB2aWV3Qm94PSIwIDAgMzMgMjQiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+CiAgICA8dGl0bGU+TmF2aWdhdGlvbi9BcnJvdy8zLnJpZ2h0LzEuT3V0bGluZTwvdGl0bGU+CiAgICA8ZyBpZD0iU3ltYm9scyIgc3Ryb2tlPSJub25lIiBzdHJva2Utd2lkdGg9IjEiIGZpbGw9Im5vbmUiIGZpbGwtcnVsZT0iZXZlbm9kZCI+CiAgICAgICAgPGcgaWQ9Ik5hdmlnYXRpb24vQXJyb3cvMy5yaWdodC8xLk91dGxpbmUiIGZpbGw9IiM3NzExMTEiIGZpbGwtcnVsZT0ibm9uemVybyI+CiAgICAgICAgICAgIDxnIGlkPSJBcnJvdy00LSgxKS1Db3B5IiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgxLjAwMDAwMCwgNi4wMDAwMDApIj4KICAgICAgICAgICAgICAgIDxwYXRoIGQ9Ik0zMC41MzAzMzE3LDQuOTkyNjM0MjUgQzMwLjgyMzIzMTcsNS4yODU1MzQyNSAzMC44MjMyMzE3LDUuNzYwNDA0MjUgMzAuNTMwMzMxNyw2LjA1MzI5NDI1IEwyNS43NTczMzE3LDEwLjgyNjI4NDMgQzI1LjQ2NDQzMTcsMTEuMTE5MTg0MyAyNC45ODk2MzE3LDExLjExOTE4NDMgMjQuNjk2NzMxNywxMC44MjYyODQzIEMyNC40MDM4MzE3LDEwLjUzMzM4NDMgMjQuNDAzODMxNywxMC4wNTg0ODQzIDI0LjY5NjczMTcsOS43NjU1ODQyNSBMMjguOTM5MzMxNyw1LjUyMjk2NDI1IEwyNC42OTY3MzE3LDEuMjgwMzM0MjUgQzI0LjQwMzgzMTcsMC45ODc0MzQyNSAyNC40MDM4MzE3LDAuNTEyNTYzMjUgMjQuNjk2NzMxNywwLjIxOTY3MDI1IEMyNC45ODk2MzE3LC0wLjA3MzIyMjc1IDI1LjQ2NDQzMTcsLTAuMDczMjIzNzUgMjUuNzU3MzMxNywwLjIxOTY2OTI1IEwzMC41MzAzMzE3LDQuOTkyNjM0MjUgWiBNMCw0Ljc3Mjk4NDI1IEwzMC4wMDAwMzE3LDQuNzcyOTY0MjUgTDMwLjAwMDAzMTcsNi4yNzI5NjQyNSBMMCw2LjI3Mjk4NDI1IEwwLDQuNzcyOTg0MjUgWiIgaWQ9IlNoYXBlIj48L3BhdGg+CiAgICAgICAgICAgIDwvZz4KICAgICAgICA8L2c+CiAgICA8L2c+Cjwvc3ZnPg==\"","export default \"data:image/svg+xml;base64,PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KPHN2ZyB3aWR0aD0iMzc3cHgiIGhlaWdodD0iMnB4IiB2aWV3Qm94PSIwIDAgMzc3IDIiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIiB4bWxuczp4bGluaz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94bGluayI+CiAgICA8dGl0bGU+TGluZTwvdGl0bGU+CiAgICA8ZyBpZD0iRGVza3RvcC0yLjAiIHN0cm9rZT0ibm9uZSIgc3Ryb2tlLXdpZHRoPSIxIiBmaWxsPSJub25lIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIHN0cm9rZS1kYXNoYXJyYXk9IjgiIHN0cm9rZS1saW5lY2FwPSJzcXVhcmUiPgogICAgICAgIDxnIGlkPSIwLjEuMC4wLVRhbnRhLURlc2t0b3AtV2lyZWZyYW1lIiB0cmFuc2Zvcm09InRyYW5zbGF0ZSgtMTA0LCAtNDM1OCkiIHN0cm9rZT0iIzc3MTExMSI+CiAgICAgICAgICAgIDxnIGlkPSJHcm91cCIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoNjQsIDQxNTkpIj4KICAgICAgICAgICAgICAgIDxsaW5lIHgxPSI0MC41IiB5MT0iMjAwIiB4Mj0iNDI0LjUiIHkyPSIyMDAiIGlkPSJMaW5lIj48L2xpbmU+CiAgICAgICAgICAgIDwvZz4KICAgICAgICA8L2c+CiAgICA8L2c+Cjwvc3ZnPg==\""],"names":["_win","_doc","_docElement","_pluginInitted","_tempDiv","_recentSetterPlugin","_reverting","_supports3D","_transformProps","_RAD2DEG","Math","PI","_DEG2RAD","_atan2","atan2","_capsExp","_horizontalExp","_complexExp","_propertyAliases","autoAlpha","scale","alpha","_renderCSSProp","ratio","data","set","t","p","round","s","c","u","_renderPropWithEnd","e","_renderCSSPropWithBeginning","b","_renderRoundedCSSProp","value","_renderNonTweeningValue","_renderNonTweeningValueOnlyAtEnd","_setterCSSStyle","target","property","style","_setterCSSProp","setProperty","_setterTransform","_gsap","_setterScale","scaleX","scaleY","_setterScaleWithRender","cache","renderTransform","_setterTransformWithRender","_transformProp","_transformOriginProp","_saveStyle","isNotCSS","_this","this","tfm","transform","split","forEach","call","indexOf","a","_get","x","zOrigin","props","svg","svgo","getAttribute","push","_removeIndependentTransforms","translate","removeProperty","_revertStyle","i","length","substr","replace","toLowerCase","setAttribute","isStart","uncache","_getStyleSaver","properties","saver","revert","save","_createElement","type","ns","createElementNS","createElement","_getComputedProperty","skipPrefixFallback","cs","getComputedStyle","getPropertyValue","_checkPropPrefix","_prefixes","element","preferPrefix","charAt","toUpperCase","_initCore","window","document","documentElement","cssText","_getBBoxHack","swapIfPossible","bbox","ownerSVGElement","oldParent","parentNode","oldSibling","nextSibling","oldCSS","appendChild","display","getBBox","_gsapBBox","insertBefore","removeChild","_getAttributeFallbacks","attributesArray","hasAttribute","_getBBox","bounds","error","width","height","y","_isSVG","getCTM","_removeProperty","first2Chars","removeAttribute","_addNonTweeningPT","plugin","beginning","end","onlySetAtEnd","pt","_pt","_props","_nonConvertibleUnits","deg","rad","turn","_nonStandardLayouts","grid","flex","_convertToUnit","unit","px","parent","isSVG","curValue","parseFloat","curUnit","trim","horizontal","test","isRootSVG","tagName","measureProperty","amount","toPixels","toPercent","body","time","position","v","_parseTransform","origin","_firstTwoOnly","_specialProps","_tweenComplexCSSString","prop","start","result","startValues","startNum","color","startValue","endValue","endNum","chunk","endUnit","startUnit","index","matchIndex","match","substring","_next","m","r","_keywordToPercent","top","bottom","left","right","center","_renderClearProps","tween","_time","_dur","clearTransforms","clearProps","pr","_identity2DMatrix","_rotationalProperties","_isNullTransform","_getComputedTransformMatrixAsArray","matrixString","map","_getMatrix","force2D","temp","addedToDOM","matrix","baseVal","consolidate","d","f","join","offsetParent","nextElementSibling","_applySVGOrigin","originIsAbsolute","smooth","matrixArray","pluginToAddPropTweensTo","determinant","xOriginOld","xOrigin","yOriginOld","yOrigin","xOffsetOld","xOffset","yOffsetOld","yOffset","tx","ty","originSplit","z","rotation","rotationX","rotationY","skewX","skewY","perspective","angle","cos","sin","a12","a22","t1","t2","t3","a13","a23","a33","a42","a43","a32","invertedScaleX","rotate","slice","sqrt","abs","forceCSS","xPercent","offsetWidth","yPercent","offsetHeight","transformPerspective","force3D","_renderSVGTransforms","_renderCSSTransforms","_renderNon3DTransforms","_addPxTranslate","_zeroDeg","_zeroPx","_endParenthesis","_ref","transforms","use3D","a11","a21","_ref2","tan","_addRotationalPropTween","direction","cap","isString","change","finalValue","_assign","source","_addRawTransformPTs","endCache","startCache","name","l","side","vars","arguments","init","positionAndScale","all","CSSPlugin","register","targetTest","nodeType","targets","specialProp","relative","isTransformRelated","transformPropTween","hasPriority","inlineProps","startAt","styles","add","visibility","parseTransform","smoothOrigin","dep","autoRound","render","get","aliases","getSetter","core","gsapWithCSS","Tween","_defineProperties","descriptor","enumerable","configurable","writable","Object","defineProperty","key","gsap","_coreInitted","_docEl","_body","_isTouch","_pointerType","ScrollTrigger","_root","_normalizer","_eventTypes","_context","_getGSAP","registerPlugin","_startup","_observers","_scrollers","_proxies","_getTime","Date","now","_bridge","_getProxyProp","_isViewport","el","_addListener","func","passive","capture","addEventListener","_removeListener","removeEventListener","_scrollLeft","_scrollTop","_onScroll","isPressed","_scrollCacheFunc","doNotCache","cachingFunc","history","scrollRestoration","isNormalizing","iOS","cacheID","offset","_horizontal","p2","os","os2","d2","sc","scrollTo","_vertical","pageXOffset","op","pageYOffset","_getTarget","self","_ctx","selector","utils","toArray","config","nullTargetWarn","console","warn","_getScrollFunc","scrollingElement","prev","getProperty","_getVelocityProp","minTimeRefresh","useDelta","v1","v2","min","dropToZeroTime","max","update","force","reset","getVelocity","latestValue","tOld","vOld","_getEvent","preventDefault","_gsapAllow","changedTouches","_getAbsoluteMax","apply","_setScrollTrigger","scrollers","proxies","globals","bridge","clamp","context","Observer","isTouch","matchMedia","matches","navigator","maxTouchPoints","msMaxTouchPoints","eventTypes","setTimeout","Constructor","protoProps","staticProps","prototype","tolerance","dragMinimum","lineHeight","debounce","onStop","onStopDelay","ignore","wheelSpeed","event","onDragStart","onDragEnd","onDrag","onPress","onRelease","onRight","onLeft","onUp","onDown","onChangeX","onChangeY","onChange","onToggleX","onToggleY","onHover","onHoverEnd","onMove","ignoreCheck","isNormalizer","onGestureStart","onGestureEnd","onWheel","onEnable","onDisable","onClick","scrollSpeed","allowClicks","lockAxis","onLockAxis","id","onStopDelayedCall","dragged","moved","wheeled","locked","axis","prevDeltaX","prevDeltaY","scrollFuncX","scrollFuncY","scrollX","scrollY","limitToTouch","isViewport","ownerDoc","ownerDocument","deltaX","deltaY","onClickTime","clickCapture","_ignoreCheck","isPointerOrTouch","pointerType","dx","dy","changedX","changedY","onDelta","_vx","_vy","requestAnimationFrame","onTouchOrPointerDelta","_onDrag","clientX","clientY","isDragging","startX","startY","_onPress","button","pause","_onRelease","isTrackingDrag","isNaN","wasDragging","isDragNotClick","eventData","delayedCall","defaultPrevented","click","createEvent","syntheticEvent","initMouseEvent","screenX","screenY","dispatchEvent","isGesturing","restart","_onGestureStart","touches","_onGestureEnd","onScroll","_onWheel","multiplier","deltaMode","innerHeight","_onMove","_onHover","_onHoverEnd","_onClick","_dc","enable","isEnabled","disable","filter","o","kill","splice","version","create","getAll","getById","_resizeDelay","_toArray","_time2","_syncInterval","_refreshing","_pointerIsDown","_i","_prevWidth","_prevHeight","_autoRefresh","_sort","_suppressOverwrites","_ignoreResize","_ignoreMobileResize","_baseScreenHeight","_baseScreenWidth","_fixIOSBug","_scrollRestoration","_div100vh","_100vh","_isReverted","_clampingMax","_limitCallbacks","_rafID","_refreshingAll","_queueRefreshID","_primary","_time1","_lastScrollTime","_enabled","_parseClamp","_isString","_keepClamp","_rafBugFix","_pointerDownHandler","_pointerUpHandler","_passThrough","_round","_getViewportDimension","dimensionProperty","_getBoundsFunc","_winOffsets","innerWidth","_getBounds","_maxScroll","_iterateAutoRefresh","events","_isFunction","_isNumber","_isObject","_endAnimation","animation","reversed","progress","_callback","enabled","totalTime","callbackAnimation","_abs","_left","_right","_bottom","_width","_height","_Right","_Left","_Top","_Bottom","_padding","_margin","_Width","_Height","_px","_getComputedStyle","_setDefaults","obj","defaults","withoutTransforms","to","getBoundingClientRect","_getSize","_ref3","_getLabelRatioArray","timeline","labels","duration","_snapDirectional","snapIncrementOrArray","snap","Array","isArray","sort","threshold","snapped","_multiListener","types","callback","nonPassive","_wheelListener","scrollFunc","wheelHandler","_markerDefaults","startColor","endColor","indent","fontSize","fontWeight","_defaults","toggleActions","anticipatePin","_keywords","_offsetToPx","size","eqIndex","_createMarker","container","_ref4","matchWidthEl","containerAnimation","useFixedPosition","isScroller","css","_isStart","innerText","children","_offset","_positionMarker","marker","flipped","oppositeSide","_isFlipped","_triggers","_ids","_sync","_updateAll","clientWidth","_dispatch","_setBaseDimensions","_onResize","fullscreenElement","webkitFullscreenElement","_listeners","_emptyArray","_softRefresh","_refreshAll","_savedStyles","_revertRecorded","media","query","_revertAll","trigger","_clearScrollMemory","rec","_refreshID","_refresh100vh","_hideAllMarkers","hide","skipRevert","isRefreshing","refreshInits","scrollBehavior","refresh","_subPinOffset","pin","original","adjustPinSpacing","scroller","_dir","endClamp","_endClamp","startClamp","_startClamp","setPositions","onRefresh","_lastScroll","_direction","isUpdating","recordVelocity","scroll","_propNamesToCopy","_stateProps","concat","_swapPinIn","spacer","spacerState","swappedIn","spacerStyle","pinStyle","flexBasis","overflow","boxSizing","_setState","state","getCache","_getState","_parsePosition","scrollerSize","markerScroller","scrollerBounds","borderWidth","scrollerMax","clampZeroProp","p1","seek","mapRange","scrollTrigger","localOffset","globalOffset","offsets","_caScrollDist","_prefixExp","_reparent","_stOrig","_interruptionTracker","getValueFunc","initialValue","onInterrupt","last1","last2","current","_shiftMarker","_getTweenCreator","getScroll","getTween","change1","change2","onComplete","modifiers","checkForInterruption","inherit","onUpdate","tweenTo","pinCache","snapFunc","scroll1","scroll2","markerStart","markerEnd","markerStartTrigger","markerEndTrigger","markerVars","executingOnRefresh","pinOriginalState","pinActiveState","pinState","pinGetter","pinSetter","pinStart","pinChange","spacingStart","markerStartSetter","pinMoves","markerEndSetter","snap1","snap2","scrubTween","scrubSmooth","snapDurClamp","snapDelayedCall","prevScroll","prevAnimProgress","caMarkerSetter","customRevertReturn","_vars","toggleClass","onToggle","scrub","pinSpacing","invalidateOnRefresh","onScrubComplete","onSnapComplete","once","pinReparent","pinSpacer","fastScrollEnd","preventOverlaps","isToggle","scrollerCache","pinType","callbacks","onEnter","onLeave","onEnterBack","onLeaveBack","markers","onRefreshInit","getScrollerSize","_getSizeFunc","getScrollerOffsets","_getOffsetsFunc","lastSnap","lastRefresh","prevProgress","bind","refreshPriority","tweenScroll","scrubDuration","ease","totalProgress","paused","lazy","_initted","isReverted","immediateRender","snapTo","_getClosestLabel","st","directional","delay","refreshedRecently","isActive","endScroll","velocity","naturalEnd","inertia","_snap","onStart","_onInterrupt","_onComplete","resetTo","_tTime","_tDur","stRevert","className","nativeElement","spacerIsNative","classList","quickSetter","content","oldOnUpdate","oldParams","onUpdateParams","eventCallback","previous","next","prevRefreshing","_swapPinOut","soft","pinOffset","invalidate","isVertical","override","curTrigger","curPin","oppositeScroll","initted","revertedPins","forcedOverflow","markerStartOffset","markerEndOffset","isFirstRefresh","otherPinOffset","parsedEnd","parsedEndTrigger","endTrigger","parsedStart","pinnedContainer","triggerIndex","unshift","_pinPush","normalize","_pinOffset","ceil","omitOffsets","_copyState","endAnimation","labelToScroll","label","getTrailing","reverse","forceFake","toggleState","action","stateChanged","toggled","isAtMax","isTakingAction","clipped","_dp","_start","n","newStart","newEnd","keepClamp","_change","allowAnimation","onKill","updateFunc","_queueRefreshAll","clearInterval","suppressOverwrites","userAgent","mm","bodyStyle","border","borderTopStyle","AnimationProto","Animation","setInterval","checkPrefix","w","h","hidden","limitCallbacks","ms","syncInterval","ignoreMobileResize","autoRefreshEvents","scrollerProxy","clearMatchMedia","isInViewport","positionInViewport","referencePoint","killAll","allowListeners","listeners","saveStyles","safe","clearScrollMemory","maxScroll","getScrollFunc","isScrolling","snapDirectional","batch","varsCopy","interval","batchMax","proxyCallback","elements","triggers","_inputIsFocused","_clampScrollAndGetDurationMultiplier","_allowNativePanning","touchAction","_overflow","auto","_nestedScroll","_ref5","node","_isScrollT","scrollHeight","clientHeight","scrollWidth","overflowY","overflowX","_isScroll","stopPropagation","_inputObserver","inputs","nested","_captureInputs","_inputExp","isInput","_getScrollNormalizer","maxY","lastRefreshID","skipTouchMove","startScrollX","startScrollY","_vars2","normalizeScrollX","momentum","allowNestedScroll","smoother","ScrollSmoother","smootherInstance","initialScale","visualViewport","outerWidth","wheelRefresh","resolveMomentumDuration","inputObserver","resumeTouchMove","scrollClampX","scrollClampY","updateClamps","removeContentOffset","onResize","ignoreDrag","prevScale","currentScroll","dur","velocityX","velocityY","play","_ts","xArray","yArray","yClamped","ticker","observe","normalizeScroll","normalizer","ss","ref","SectionWithAnimation","sectionRef","useRef","showFullText","setShowFullText","useState","useStaticQuery","isMobile","useEffect","sectionElement","textElement","allSpans","querySelectorAll","opacity","animateText","_sectionRef$current","newParagraphs","paragraph","HTMLElement","_sectionRef$current2","initialParagraphs","words","innerHTML","word","wordIndex","wordSpan","letter","letterIndex","letterSpan","spaceSpan","React","backgroundColor","allWpPage","nodes","slider_home","bgColor","dangerouslySetInnerHTML","__html","parrafoMovil1","parrafoDesktop1","parrafoMovil2","parrafoDesktop2","parrafoMovil3","parrafoDesktop3","parrafoMovil4","parrafoDesktop4","handleHideClick","handleReadMoreClick","NuestraPizarrita","pizarritaData","edges","hovered","setHovered","backgroundImage","bgImagenPizarrita","mediaItemUrl","tituloPizarrita","src","lineDeco","alt","descripcionPizarrita","href","urlBotonPizarrita","rel","onMouseEnter","handleButtonHover","onMouseLeave","handleButtonLeave","cursor","textDecoration","textoBotonPizarrita","rightBtnImageWhite","rightBtnImage","fill","bgImagenPizarritaMobile","SliderLocals","sliderData","localTitulo","localDescripcion","localTextoBoton","localUrlBoton","localBgColor","image","setImage","localImagenSlider","handleResize","localImagenSliderMobile","currentTarget","querySelector","sourceUrl","altText","SliderFood","currentIndex","setCurrentIndex","platosHome","imagenSlider","title","description","handlePrev","prevIndex","handleNext","isRecord","subject","toString","isObject","areOptionsEqual","optionsA","optionsB","optionsAKeys","keys","optionsBKeys","JSON","stringify","breakpoints","every","valueA","valueB","sortAndMapPluginToOptions","plugins","options","isNumber","isBoolean","mathAbs","mathSign","sign","deltaAbs","arrayKeys","array","objectKeys","Number","arrayLast","arrayLastIndex","object","objectsMergeDeep","objectA","objectB","reduce","mergedObjects","currentObject","areObjects","isMouseEvent","evt","ownerWindow","MouseEvent","Alignment","align","viewSize","predefined","measure","Limit","reachedMin","reachedMax","reachedAny","constrain","removeOffset","Counter","loop","loopEnd","counter","withinLimit","clone","EventStore","handler","clear","remove","DragHandler","rootNode","dragTracker","location","scrollBody","scrollTarget","eventHandler","percentOfView","dragFree","dragThreshold","skipSnaps","baseFriction","cross","crossAxis","focusNodes","nonPassiveEvent","initEvents","dragEvents","goToNextThreshold","snapForceBoost","mouse","touch","freeForceBoost","baseSpeed","isMoving","startScroll","startCross","pointerIsDown","preventScroll","preventClick","isMouse","move","lastScroll","readPoint","lastCross","diffScroll","diffCross","cancelable","up","diff","pointerMove","useFriction","useDuration","targetChanged","byDistance","rawForce","pointerUp","baseForce","distance","byIndex","allowedForce","forceFactor","factorAbs","speed","friction","emit","emblaApi","watchDrag","downIfAllowed","isMouseEvt","nodeName","includes","isFocusNode","buttons","pointerDown","addDragEvents","down","destroy","DragTracker","startEvent","lastEvent","readTime","timeStamp","evtAxis","coord","expired","diffDrag","diffTime","ResizeHandler","slides","resizeObserver","containerSize","slideSizes","destroyed","readSize","measureSize","watchResize","ResizeObserver","entries","entry","isContainer","slideIndex","reInit","defaultCallback","disconnect","ScrollBounds","limit","pullBackThreshold","edgeOffsetTolerance","frictionLimit","disabled","edge","diffToEdge","diffToTarget","subtract","useBaseFriction","toggleActive","active","ScrollContain","contentSize","snapsAligned","containScroll","scrollBounds","snapsBounded","scrollBound","toFixed","snapsContained","startSnap","endSnap","lastIndexOf","findDuplicates","measureContained","ScrollLooper","vectors","shouldLoop","loopDistance","ScrollProgress","scrollLength","ScrollTarget","scrollSnaps","targetVector","minDistance","distances","shortcut","targetSnapDistance","ascDiffsToSnaps","scrollSnap","diffToSnap","d1","findTargetSnap","reachedBound","Vector1D","normalizeInput","Translate","containerStyle","SlideLooper","slideSizesWithGaps","slidesInView","ascItems","descItems","loopPoints","gap","findLoopPoints","slidesInGap","startPoints","endPoints","removeSlideSizes","indexes","from","isStartEdge","slideBounds","findSlideBounds","initial","altered","point","canLoop","loopPoint","shift","SlidesHandler","mutationObserver","watchSlides","MutationObserver","mutations","mutation","childList","SlidesInView","snaps","inViewThreshold","roundingSafety","cachedOffsets","cachedBounds","slideOffsets","slideThresholds","slideThreshold","slideSize","findSlideThresholds","list","check","limitedLocation","slideBound","SlidesToScroll","slidesToScroll","groupByNumber","groupSlides","groupSize","byNumber","groupSizes","chunkSize","bySize","Engine","root","animations","scrollAxis","contentDirection","startIndex","containerRect","slideRects","slide","Direction","startEdge","endEdge","rect","Axis","PercentOfView","alignment","containSnaps","readEdgeGap","withEdgeGap","startGap","slideRect","measureStartGap","endGap","measureEndGap","rects","isFirst","isLast","SlideSizes","alignments","containedEndSnap","g","groupedSnaps","measureAligned","ScrollSnaps","ScrollLimit","indexPrevious","slideIndexes","dragHandler","scrollLooper","slideLooper","hasSettled","settled","stop","engine","lagOffset","offsetLocation","startLocation","baseDuration","bodyVelocity","scrollDirection","useBaseDuration","ScrollBody","indexCurrent","distanceDiff","indexDiff","targetIndex","ScrollTo","eventStore","resizeHandler","scrollProgress","slidesHandler","defaultOptions","OptionsHandler","mergeOptions","optionsAtMedia","matchedMediaOptions","mediaOption","optionsMediaQueries","optionsList","acc","mediaQueries","EmblaCarousel","userOptions","userPlugins","defaultView","optionsHandler","pluginsHandler","activePlugins","assign","PluginsHandler","mediaHandlers","documentVisibleHandler","api","getListeners","off","cb","on","EventHandler","animationRealms","reActivate","pluginApis","optionsBase","globalOptions","pluginList","activate","withOptions","withPlugins","animationRealm","find","timeStep","engines","lastTimeStamp","lag","animationFrame","animate","elapsed","cancelAnimationFrame","Animations","userContainer","userSlides","customContainer","customSlides","storeElements","deActivate","selectedScrollSnap","jump","canScrollNext","canScrollPrev","containerNode","internalEngine","previousScrollSnap","scrollNext","scrollPrev","scrollSnapList","slideNodes","slidesNotInView","inView","useEmblaCarousel","storedOptions","storedPlugins","setEmblaApi","viewport","setViewport","useCallback","newEmblaApi","undefined","pluginsA","pluginsB","optionA","arePluginsEqual","DotButton","selected","PrevButton","NextButton","sliderHome","emblaRef","prevBtnEnabled","setPrevBtnEnabled","nextBtnEnabled","setNextBtnEnabled","selectedIndex","setSelectedIndex","setScrollSnaps","onInit","onSelect","srcSet","sliderImageMobile","sliderImage","_","Gallery","cartas","titleCarta","imagenCartaVertical","imagenCartaVerticalMovil","textoCartaVertical","urlPdfCartaVertical","carta","urlPdfCarta","imagenCartaMovil","imagenCarta","textoCarta","IndexPage","Layout","headerTransition","Head","_wpPage$seo$opengraph","wpPage","Seo","seoDescription","seo","opengraphDescription","SeoImage","opengraphImage","publicUrl","metaDescription","metaDesc","seoTitle","opengraphTitle","seoType","opengraphType","SeoUrl","opengraphUrl","metatitle"],"sourceRoot":""}