parcelRequire=function(e,r,t,n){var i,o="function"==typeof parcelRequire&&parcelRequire,u="function"==typeof require&&require;function f(t,n){if(!r[t]){if(!e[t]){var i="function"==typeof parcelRequire&&parcelRequire;if(!n&&i)return i(t,!0);if(o)return o(t,!0);if(u&&"string"==typeof t)return u(t);var c=new Error("Cannot find module '"+t+"'");throw c.code="MODULE_NOT_FOUND",c}p.resolve=function(r){return e[t][1][r]||r},p.cache={};var l=r[t]=new f.Module(t);e[t][0].call(l.exports,p,l,l.exports,this)}return r[t].exports;function p(e){return f(p.resolve(e))}}f.isParcelRequire=!0,f.Module=function(e){this.id=e,this.bundle=f,this.exports={}},f.modules=e,f.cache=r,f.parent=o,f.register=function(r,t){e[r]=[function(e,r){r.exports=t},{}]};for(var c=0;c<t.length;c++)try{f(t[c])}catch(e){i||(i=e)}if(t.length){var l=f(t[t.length-1]);"object"==typeof exports&&"undefined"!=typeof module?module.exports=l:"function"==typeof define&&define.amd?define(function(){return l}):n&&(this[n]=l)}if(parcelRequire=f,i)throw i;return f}({"Focm":[function(require,module,exports) {
var n={};!function(n){"use strict";var t=function(n){this.compose=n},e=new t(function(n){return function(t){return function(e){return n(t(e))}}});n.compose=function(n){return n.compose},n.Semigroupoid=t,n.semigroupoidFn=e}(n["Control.Semigroupoid"]=n["Control.Semigroupoid"]||{}),function(t){"use strict";var e=n["Control.Semigroupoid"],r=function(n,t){this.Semigroupoid0=n,this.identity=t},a=new r(function(){return e.semigroupoidFn},function(n){return n});t.Category=r,t.identity=function(n){return n.identity},t.categoryFn=a}(n["Control.Category"]=n["Control.Category"]||{}),function(t){"use strict";(n["Data.Boolean"]=n["Data.Boolean"]||{}).otherwise=!0}(),function(t){"use strict";(n["Data.Eq"]=n["Data.Eq"]||{}).refEq=function(n){return function(t){return n===t}}}(),function(t){"use strict";(n["Data.Unit"]=n["Data.Unit"]||{}).unit={}}(),function(t){"use strict";(n["Data.Show"]=n["Data.Show"]||{}).showIntImpl=function(n){return n.toString()}}(),function(t){"use strict";var e=n["Data.Show"],r=(n["Data.Symbol"],n["Record.Unsafe"],n["Type.Data.RowList"],function(n){this.show=n}),a=new r(e.showIntImpl);t.Show=r,t.show=function(n){return n.show},t.showInt=a}(n["Data.Show"]=n["Data.Show"]||{}),function(t){"use strict";var e=n["Data.Unit"];n["Data.Show"];t.unit=e.unit}(n["Data.Unit"]=n["Data.Unit"]||{}),function(t){"use strict";var e=n["Data.Eq"],r=(n["Data.HeytingAlgebra"],n["Data.Symbol"],n["Data.Unit"],n["Data.Void"],n["Record.Unsafe"],n["Type.Data.RowList"],function(n){this.eq=n}),a=new r(e.refEq),o=new r(e.refEq);t.Eq=r,t.eq=function(n){return n.eq},t.eqInt=a,t.eqChar=o}(n["Data.Eq"]=n["Data.Eq"]||{}),function(t){"use strict";(n["Data.Ord.Unsafe"]=n["Data.Ord.Unsafe"]||{}).unsafeCompareImpl=function(n){return function(t){return function(e){return function(r){return function(a){return r<a?n:r===a?t:e}}}}}}(),function(t){"use strict";n["Data.Semigroup"],n["Data.Symbol"],n["Data.Unit"],n["Data.Void"],n["Record.Unsafe"],n["Type.Data.RowList"];t.Semigroup=function(n){this.append=n},t.append=function(n){return n.append}}(n["Data.Semigroup"]=n["Data.Semigroup"]||{}),function(t){"use strict";n["Data.Eq"],n["Data.Semigroup"],n["Data.Show"];var e=function(){function n(){}return n.value=new n,n}(),r=function(){function n(){}return n.value=new n,n}(),a=function(){function n(){}return n.value=new n,n}();t.LT=e,t.GT=r,t.EQ=a}(n["Data.Ordering"]=n["Data.Ordering"]||{}),function(t){"use strict";var e=n["Data.Ord.Unsafe"],r=n["Data.Ordering"],a=e.unsafeCompareImpl(r.LT.value)(r.EQ.value)(r.GT.value);t.unsafeCompare=a}(n["Data.Ord.Unsafe"]=n["Data.Ord.Unsafe"]||{}),function(t){"use strict";n["Data.Ord"];var e=n["Data.Eq"],r=n["Data.Ord.Unsafe"],a=n["Data.Ordering"],o=(n["Data.Ring"],n["Data.Semiring"],n["Data.Symbol"],n["Data.Unit"],n["Data.Void"],n["Record.Unsafe"],n["Type.Data.RowList"],function(n,t){this.Eq0=n,this.compare=t}),u=new o(function(){return e.eqInt},r.unsafeCompare),i=new o(function(){return e.eqChar},r.unsafeCompare),l=function(n){return n.compare};t.Ord=o,t.compare=l,t.max=function(n){return function(t){return function(e){var r=l(n)(t)(e);if(r instanceof a.LT)return e;if(r instanceof a.EQ)return t;if(r instanceof a.GT)return t;throw new Error("Failed pattern match at Data.Ord (line 128, column 3 - line 131, column 12): "+[r.constructor.name])}}},t.ordInt=u,t.ordChar=i}(n["Data.Ord"]=n["Data.Ord"]||{}),function(t){"use strict";n["Control.Category"],n["Data.Boolean"],n["Data.Ord"],n["Data.Ring"];t.flip=function(n){return function(t){return function(e){return n(e)(t)}}},t.const=function(n){return function(t){return n}}}(n["Data.Function"]=n["Data.Function"]||{}),function(t){"use strict";n["Data.Functor"],n["Control.Semigroupoid"];var e=n["Data.Function"],r=n["Data.Unit"],a=function(n){return n.map};t.Functor=function(n){this.map=n},t.map=a,t.void=function(n){return a(n)(e.const(r.unit))}}(n["Data.Functor"]=n["Data.Functor"]||{}),function(t){"use strict";n["Control.Apply"];var e=n["Control.Category"],r=n["Data.Function"],a=n["Data.Functor"],o=function(n){return n.apply};t.Apply=function(n,t){this.Functor0=n,this.apply=t},t.apply=o,t.applySecond=function(n){return function(t){return function(u){return o(n)(a.map(n.Functor0())(r.const(e.identity(e.categoryFn)))(t))(u)}}}}(n["Control.Apply"]=n["Control.Apply"]||{}),function(t){"use strict";var e=n["Control.Apply"],r=(n["Data.Functor"],n["Data.Unit"],function(n){return n.pure});t.Applicative=function(n,t){this.Apply0=n,this.pure=t},t.pure=r,t.liftA1=function(n){return function(t){return function(a){return e.apply(n.Apply0())(r(n)(t))(a)}}}}(n["Control.Applicative"]=n["Control.Applicative"]||{}),function(t){"use strict";n["Control.Bind"],n["Control.Applicative"],n["Control.Apply"],n["Control.Category"];var e=n["Data.Function"],r=(n["Data.Functor"],n["Data.Unit"],function(n){this.discard=n}),a=function(n){return n.bind},o=function(n){return e.flip(a(n))},u=new r(function(n){return a(n)});t.Bind=function(n,t){this.Apply0=n,this.bind=t},t.bind=a,t.bindFlipped=o,t.Discard=r,t.discard=function(n){return n.discard},t.composeKleisliFlipped=function(n){return function(t){return function(e){return function(r){return o(n)(t)(e(r))}}}},t.discardUnit=u}(n["Control.Bind"]=n["Control.Bind"]||{}),function(t){"use strict";var e=n["Control.Applicative"],r=(n["Control.Apply"],n["Control.Bind"]);n["Data.Functor"],n["Data.Unit"];t.Monad=function(n,t){this.Applicative0=n,this.Bind1=t},t.ap=function(n){return function(t){return function(a){return r.bind(n.Bind1())(t)(function(t){return r.bind(n.Bind1())(a)(function(r){return e.pure(n.Applicative0())(t(r))})})}}}}(n["Control.Monad"]=n["Control.Monad"]||{}),function(n){"use strict";n.foldrArray=function(n){return function(t){return function(e){for(var r=t,a=e.length-1;a>=0;a--)r=n(e[a])(r);return r}}},n.foldlArray=function(n){return function(t){return function(e){for(var r=t,a=e.length,o=0;o<a;o++)r=n(r)(e[o]);return r}}}}(n["Data.Foldable"]=n["Data.Foldable"]||{}),function(t){"use strict";n["Data.Boolean"],n["Data.Eq"],n["Data.EuclideanRing"],n["Data.Ord"],n["Data.Ordering"],n["Data.Semigroup"],n["Data.Symbol"],n["Data.Unit"],n["Record.Unsafe"],n["Type.Data.RowList"];t.Monoid=function(n,t){this.Semigroup0=n,this.mempty=t},t.mempty=function(n){return n.mempty}}(n["Data.Monoid"]=n["Data.Monoid"]||{}),function(t){"use strict";n["Control.Alt"],n["Control.Alternative"],n["Control.Applicative"];var e=n["Control.Apply"],r=n["Control.Bind"],a=(n["Control.Category"],n["Control.Extend"],n["Control.Monad"],n["Control.MonadZero"],n["Control.Plus"],n["Data.Bounded"],n["Data.Eq"],n["Data.Function"],n["Data.Functor"]),o=(n["Data.Functor.Invariant"],n["Data.Monoid"],n["Data.Ord"],n["Data.Ordering"],n["Data.Semigroup"],n["Data.Show"],n["Data.Unit"],n.Prelude,function(){function n(){}return n.value=new n,n}()),u=function(){function n(n){this.value0=n}return n.create=function(t){return new n(t)},n}(),i=new a.Functor(function(n){return function(t){return t instanceof u?new u(n(t.value0)):o.value}}),l=new e.Apply(function(){return i},function(n){return function(t){if(n instanceof u)return a.map(i)(n.value0)(t);if(n instanceof o)return o.value;throw new Error("Failed pattern match at Data.Maybe (line 67, column 1 - line 67, column 35): "+[n.constructor.name,t.constructor.name])}}),c=new r.Bind(function(){return l},function(n){return function(t){if(n instanceof u)return t(n.value0);if(n instanceof o)return o.value;throw new Error("Failed pattern match at Data.Maybe (line 125, column 1 - line 125, column 33): "+[n.constructor.name,t.constructor.name])}});t.Nothing=o,t.Just=u,t.maybe=function(n){return function(t){return function(e){if(e instanceof o)return n;if(e instanceof u)return t(e.value0);throw new Error("Failed pattern match at Data.Maybe (line 217, column 1 - line 217, column 51): "+[n.constructor.name,t.constructor.name,e.constructor.name])}}},t.functorMaybe=i,t.applyMaybe=l,t.bindMaybe=c}(n["Data.Maybe"]=n["Data.Maybe"]||{}),function(t){"use strict";var e=n["Data.Foldable"],r=(n["Control.Alt"],n["Control.Applicative"]),a=n["Control.Apply"],o=(n["Control.Bind"],n["Control.Category"],n["Control.Plus"],n["Control.Semigroupoid"],n["Data.Eq"],n["Data.Function"],n["Data.Functor"],n["Data.HeytingAlgebra"],n["Data.Maybe"],n["Data.Maybe.First"],n["Data.Maybe.Last"],n["Data.Monoid"]),u=(n["Data.Monoid.Additive"],n["Data.Monoid.Conj"],n["Data.Monoid.Disj"],n["Data.Monoid.Dual"],n["Data.Monoid.Endo"],n["Data.Monoid.Multiplicative"],n["Data.Newtype"],n["Data.Ord"],n["Data.Ordering"],n["Data.Semigroup"]),i=(n["Data.Semiring"],n["Data.Unit"]),l=(n.Prelude,function(n,t,e){this.foldMap=n,this.foldl=t,this.foldr=e}),c=function(n){return n.foldr},f=function(n){return function(t){return function(e){return c(n)(function(n){return function(r){return u.append(t.Semigroup0())(e(n))(r)}})(o.mempty(t))}}},s=new l(function(n){return f(s)(n)},e.foldlArray,e.foldrArray);t.Foldable=l,t.foldr=c,t.foldl=function(n){return n.foldl},t.foldMap=function(n){return n.foldMap},t.foldMapDefaultR=f,t.traverse_=function(n){return function(t){return function(e){return c(t)(function(t){return a.applySecond(n.Apply0())(e(t))})(r.pure(n)(i.unit))}}},t.foldableArray=s}(n["Data.Foldable"]=n["Data.Foldable"]||{}),function(t){"use strict";n["Control.Alt"];var e=n["Control.Applicative"],r=n["Control.Apply"],a=n["Control.Bind"],o=(n["Control.Extend"],n["Control.Monad"],n["Control.Semigroupoid"],n["Data.Bifoldable"],n["Data.Bifunctor"],n["Data.Bitraversable"],n["Data.Bounded"],n["Data.Eq"],n["Data.Foldable"],n["Data.FoldableWithIndex"],n["Data.Function"],n["Data.Functor"]),u=(n["Data.Functor.Invariant"],n["Data.FunctorWithIndex"],n["Data.Maybe"]),i=(n["Data.Monoid"],n["Data.Ord"],n["Data.Ordering"],n["Data.Semigroup"],n["Data.Show"],n["Data.Traversable"],n["Data.TraversableWithIndex"],n["Data.Unit"],n.Prelude,function(){function n(n){this.value0=n}return n.create=function(t){return new n(t)},n}()),l=function(){function n(n){this.value0=n}return n.create=function(t){return new n(t)},n}(),c=new o.Functor(function(n){return function(t){if(t instanceof i)return new i(t.value0);if(t instanceof l)return new l(n(t.value0));throw new Error("Failed pattern match at Data.Either (line 38, column 8 - line 38, column 52): "+[t.constructor.name])}}),f=function(n){return function(t){return function(e){if(e instanceof i)return n(e.value0);if(e instanceof l)return t(e.value0);throw new Error("Failed pattern match at Data.Either (line 238, column 1 - line 238, column 64): "+[n.constructor.name,t.constructor.name,e.constructor.name])}}},s=new r.Apply(function(){return c},function(n){return function(t){if(n instanceof i)return new i(n.value0);if(n instanceof l)return o.map(c)(n.value0)(t);throw new Error("Failed pattern match at Data.Either (line 82, column 1 - line 82, column 41): "+[n.constructor.name,t.constructor.name])}}),d=new a.Bind(function(){return s},f(function(n){return function(t){return new i(n)}})(function(n){return function(t){return t(n)}})),p=new e.Applicative(function(){return s},l.create);t.Left=i,t.Right=l,t.either=f,t.note=function(n){return u.maybe(new i(n))(l.create)},t.functorEither=c,t.applyEither=s,t.applicativeEither=p,t.bindEither=d}(n["Data.Either"]=n["Data.Either"]||{}),function(n){"use strict";n.pureE=function(n){return function(){return n}},n.bindE=function(n){return function(t){return function(){return t(n())()}}}}(n.Effect=n.Effect||{}),function(t){"use strict";var e=n.Effect,r=n["Control.Applicative"],a=n["Control.Apply"],o=n["Control.Bind"],u=n["Control.Monad"],i=n["Data.Functor"],l=(n["Data.Monoid"],n["Data.Semigroup"],n.Prelude,new u.Monad(function(){return s},function(){return c})),c=new o.Bind(function(){return f},e.bindE),f=new a.Apply(function(){return d},u.ap(l)),s=new r.Applicative(function(){return f},e.pureE),d=new i.Functor(r.liftA1(s));t.functorEffect=d,t.applyEffect=f,t.applicativeEffect=s,t.bindEffect=c,t.monadEffect=l}(n.Effect=n.Effect||{}),function(n){"use strict";n.new=function(n){return function(){return{value:n}}},n.read=function(n){return function(){return n.value}},n.write=function(n){return function(t){return function(){return t.value=n,{}}}}}(n["Effect.Ref"]=n["Effect.Ref"]||{}),function(t){"use strict";var e=n["Effect.Ref"];n["Data.Function"],n["Data.Functor"],n.Effect,n.Prelude;t.new=e.new,t.read=e.read,t.write=e.write}(n["Effect.Ref"]=n["Effect.Ref"]||{}),function(t){"use strict";(n["Partial.Unsafe"]=n["Partial.Unsafe"]||{}).unsafePartial=function(n){return n()}}(),function(t){"use strict";(n["Partial"]=n["Partial"]||{}).crashWith=function(){return function(n){throw new Error(n)}}}(),function(t){"use strict";var e=n.Partial;t.crashWith=e.crashWith}(n.Partial=n.Partial||{}),function(t){"use strict";var e=n["Partial.Unsafe"],r=n.Partial;t.unsafeCrashWith=function(n){return e.unsafePartial(function(t){return r.crashWith(t)(n)})}}(n["Partial.Unsafe"]=n["Partial.Unsafe"]||{}),function(t){"use strict";n["Control.Applicative"],n["Control.Bind"],n["Control.Monad"],n["Control.Semigroupoid"],n["Data.Bifunctor"],n["Data.Either"],n["Data.Functor"],n["Data.Identity"],n["Data.Maybe"],n["Data.Unit"],n.Effect,n["Effect.Ref"],n["Partial.Unsafe"],n.Prelude;var e=function(){function n(n){this.value0=n}return n.create=function(t){return new n(t)},n}(),r=function(){function n(n){this.value0=n}return n.create=function(t){return new n(t)},n}(),a=function(n){return n.tailRecM};t.Loop=e,t.Done=r,t.MonadRec=function(n,t){this.Monad0=n,this.tailRecM=t},t.tailRec=function(n){return function(t){return function(t){var a,o=!1;function u(a){if(!(a instanceof e)){if(a instanceof r)return o=!0,a.value0;throw new Error("Failed pattern match at Control.Monad.Rec.Class (line 91, column 3 - line 91, column 25): "+[a.constructor.name])}t=n(a.value0)}for(;!o;)a=u(t);return a}(n(t))}},t.tailRecM=a,t.tailRecM2=function(n){return function(t){return function(e){return function(r){return a(n)(function(n){return t(n.a)(n.b)})({a:e,b:r})}}}}}(n["Control.Monad.Rec.Class"]=n["Control.Monad.Rec.Class"]||{}),function(t){"use strict";(n["Data.Int"]=n["Data.Int"]||{}).fromStringAsImpl=function(n){return function(t){return function(e){var r;r=e<11?"[0-"+(e-1).toString()+"]":11===e?"[0-9a]":"[0-9a-"+String.fromCharCode(86+e)+"]";var a=new RegExp("^[\\+\\-]?"+r+"+$","i");return function(r){if(a.test(r)){var o=parseInt(r,e);return(0|o)===o?n(o):t}return t}}}}}(),function(t){"use strict";var e=n["Data.Int"],r=(n["Control.Category"],n["Control.Semigroupoid"],n["Data.Boolean"],n["Data.Bounded"],n["Data.CommutativeRing"],n["Data.DivisionRing"],n["Data.Eq"],n["Data.EuclideanRing"],n["Data.HeytingAlgebra"],n["Data.Int.Bits"],n["Data.Maybe"]),a=(n["Data.Ord"],n["Data.Ordering"],n["Data.Ring"],n["Data.Semiring"],n["Data.Show"],n.Global,n.Math,n.Prelude,e.fromStringAsImpl(r.Just.create)(r.Nothing.value)),o=a(10);t.fromString=o,t.fromStringAs=a}(n["Data.Int"]=n["Data.Int"]||{}),function(n){"use strict";n.map_=function(n){return function(t){return function(){return n(t())}}},n.pure_=function(n){return function(){return n}},n.bind_=function(n){return function(t){return function(){return t(n())()}}},n.while=function(n){return function(t){return function(){for(;n();)t()}}},n.new=function(n){return function(){return{value:n}}},n.read=function(n){return function(){return n.value}},n.write=function(n){return function(t){return function(){return t.value=n}}}}(n["Control.Monad.ST.Internal"]=n["Control.Monad.ST.Internal"]||{}),function(t){"use strict";var e=n["Control.Monad.ST.Internal"],r=n["Control.Applicative"],a=n["Control.Apply"],o=n["Control.Bind"],u=n["Control.Monad"],i=n["Control.Monad.Rec.Class"],l=n["Data.Functor"],c=n["Data.Unit"],f=(n["Partial.Unsafe"],n.Prelude,new l.Functor(e.map_)),s=new u.Monad(function(){return v},function(){return d}),d=new o.Bind(function(){return p},e.bind_),p=new a.Apply(function(){return f},u.ap(s)),v=new r.Applicative(function(){return p},e.pure_),D=new i.MonadRec(function(){return s},function(n){return function(t){var a=function(n){return n instanceof i.Loop},u=function(n){if(n instanceof i.Done)return n.value0;throw new Error("Failed pattern match at Control.Monad.ST.Internal (line 54, column 32 - line 54, column 46): "+[n.constructor.name])};return o.bind(d)(o.bindFlipped(d)(e.new)(n(t)))(function(t){return o.discard(o.discardUnit)(d)(e.while(l.map(f)(a)(e.read(t)))(o.bind(d)(e.read(t))(function(a){if(a instanceof i.Loop)return o.bind(d)(n(a.value0))(function(n){return l.void(f)(e.write(n)(t))});if(a instanceof i.Done)return r.pure(v)(c.unit);throw new Error("Failed pattern match at Control.Monad.ST.Internal (line 46, column 18 - line 50, column 28): "+[a.constructor.name])})))(function(){return l.map(f)(u)(e.read(t))})})}});t.functorST=f,t.applyST=p,t.applicativeST=v,t.bindST=d,t.monadST=s,t.monadRecST=D}(n["Control.Monad.ST.Internal"]=n["Control.Monad.ST.Internal"]||{}),function(n){"use strict";n.fromFoldableImpl=function(){function n(n,t){this.head=n,this.tail=t}var t={};function e(t){return function(e){return new n(t,e)}}return function(n){return function(r){return function(n){for(var e=[],r=0,a=n;a!==t;)e[r++]=a.head,a=a.tail;return e}(n(e)(t)(r))}}}(),n.length=function(n){return n.length}}(n["Data.Array"]=n["Data.Array"]||{}),function(n){"use strict";n.empty=function(){return[]},n.pushAll=function(n){return function(t){return function(){return t.push.apply(t,n)}}}}(n["Data.Array.ST"]=n["Data.Array.ST"]||{}),function(t){"use strict";(n["Unsafe.Coerce"]=n["Unsafe.Coerce"]||{}).unsafeCoerce=function(n){return n}}(),function(t){"use strict";var e=n["Unsafe.Coerce"];t.unsafeCoerce=e.unsafeCoerce}(n["Unsafe.Coerce"]=n["Unsafe.Coerce"]||{}),function(t){"use strict";var e=n["Data.Array.ST"],r=n["Control.Applicative"],a=(n["Control.Bind"],n["Control.Monad.ST"],n["Control.Monad.ST.Internal"]);n["Control.Semigroupoid"],n["Data.Maybe"],n["Data.Ord"],n["Data.Ordering"],n["Data.Ring"],n.Prelude,n["Unsafe.Coerce"];t.push=function(n){return e.pushAll([n])},t.unsafeFreeze=function(n){return r.pure(a.applicativeST)(n)},t.empty=e.empty}(n["Data.Array.ST"]=n["Data.Array.ST"]||{}),function(t){"use strict";n["Control.Applicative"],n["Control.Apply"],n["Control.Biapplicative"],n["Control.Biapply"],n["Control.Bind"],n["Control.Comonad"],n["Control.Extend"],n["Control.Lazy"],n["Control.Monad"],n["Control.Semigroupoid"],n["Data.Bifoldable"],n["Data.Bifunctor"],n["Data.Bitraversable"],n["Data.BooleanAlgebra"],n["Data.Bounded"],n["Data.CommutativeRing"],n["Data.Distributive"],n["Data.Eq"],n["Data.Foldable"],n["Data.FoldableWithIndex"],n["Data.Function"],n["Data.Functor"],n["Data.Functor.Invariant"],n["Data.FunctorWithIndex"],n["Data.HeytingAlgebra"],n["Data.Maybe"],n["Data.Maybe.First"],n["Data.Monoid"],n["Data.Newtype"],n["Data.Ord"],n["Data.Ordering"],n["Data.Ring"],n["Data.Semigroup"],n["Data.Semigroup.Foldable"],n["Data.Semigroup.Traversable"],n["Data.Semiring"],n["Data.Show"],n["Data.Traversable"],n["Data.TraversableWithIndex"],n["Data.Unit"],n.Prelude,n["Type.Equality"];var e=function(){function n(n,t){this.value0=n,this.value1=t}return n.create=function(t){return function(e){return new n(t,e)}},n}();t.Tuple=e}(n["Data.Tuple"]=n["Data.Tuple"]||{}),function(t){"use strict";var e=n["Data.Array"],r=(n["Control.Alt"],n["Control.Alternative"],n["Control.Applicative"],n["Control.Apply"],n["Control.Bind"],n["Control.Category"],n["Control.Lazy"],n["Control.Monad.Rec.Class"],n["Control.Monad.ST"],n["Control.Monad.ST.Internal"],n["Control.Semigroupoid"],n["Data.Array.NonEmpty.Internal"],n["Data.Array.ST"],n["Data.Array.ST.Iterator"],n["Data.Boolean"],n["Data.Eq"],n["Data.Foldable"]);n["Data.Function"],n["Data.Functor"],n["Data.HeytingAlgebra"],n["Data.Maybe"],n["Data.Ord"],n["Data.Ordering"],n["Data.Ring"],n["Data.Semigroup"],n["Data.Semiring"],n["Data.Traversable"],n["Data.Tuple"],n["Data.Unfoldable"],n["Partial.Unsafe"],n.Prelude,n["Unsafe.Coerce"];t.fromFoldable=function(n){return e.fromFoldableImpl(r.foldr(n))},t.length=e.length}(n["Data.Array"]=n["Data.Array"]||{}),function(t){"use strict";n["Control.Alt"],n["Control.Alternative"];var e=n["Control.Applicative"],r=n["Control.Apply"],a=(n["Control.Bind"],n["Control.Category"],n["Control.Comonad"],n["Control.Extend"],n["Control.Monad"],n["Control.MonadPlus"],n["Control.MonadZero"],n["Control.Plus"],n["Control.Semigroupoid"],n["Data.Eq"],n["Data.Foldable"]),o=(n["Data.FoldableWithIndex"],n["Data.Function"]),u=n["Data.Functor"],i=(n["Data.FunctorWithIndex"],n["Data.HeytingAlgebra"],n["Data.Maybe"],n["Data.Monoid"]),l=(n["Data.Newtype"],n["Data.NonEmpty"],n["Data.Ord"],n["Data.Ordering"],n["Data.Ring"],n["Data.Semigroup"]),c=(n["Data.Semigroup.Foldable"],n["Data.Semigroup.Traversable"],n["Data.Semiring"],n["Data.Show"],n["Data.Traversable"],n["Data.TraversableWithIndex"],n["Data.Tuple"],n["Data.Unfoldable"],n["Data.Unfoldable1"],n.Prelude,function(){function n(){}return n.value=new n,n}()),f=function(){function n(n,t){this.value0=n,this.value1=t}return n.create=function(t){return function(e){return new n(t,e)}},n}(),s=new a.Foldable(function(n){return function(t){return a.foldl(s)(function(e){return function(r){return l.append(n.Semigroup0())(e)(t(r))}})(i.mempty(n))}},function(n){return function(t){return function(e){var r,a=t,o=!1;function u(t,r){if(r instanceof c)return o=!0,t;if(r instanceof f)return a=n(t)(r.value0),void(e=r.value1);throw new Error("Failed pattern match at Data.List.Types (line 81, column 12 - line 83, column 30): "+[r.constructor.name])}for(;!o;)r=u(a,e);return r}}},function(n){return function(t){var e=a.foldl(s)(o.flip(f.create))(c.value);return function(r){return a.foldl(s)(o.flip(n))(t)(e(r))}}}),d=new u.Functor(function(n){return a.foldr(s)(function(t){return function(e){return new f(n(t),e)}})(c.value)}),p=new l.Semigroup(function(n){return function(t){return a.foldr(s)(f.create)(t)(n)}}),v=new r.Apply(function(){return d},function(n){return function(t){if(n instanceof c)return c.value;if(n instanceof f)return l.append(p)(u.map(d)(n.value0)(t))(r.apply(v)(n.value1)(t));throw new Error("Failed pattern match at Data.List.Types (line 127, column 1 - line 127, column 33): "+[n.constructor.name,t.constructor.name])}}),D=new e.Applicative(function(){return v},function(n){return new f(n,c.value)});t.Nil=c,t.Cons=f,t.semigroupList=p,t.functorList=d,t.foldableList=s,t.applyList=v,t.applicativeList=D}(n["Data.List.Types"]=n["Data.List.Types"]||{}),function(t){"use strict";var e=n["Control.Applicative"],r=(n["Control.Apply"],n["Control.Category"],n["Control.Semigroupoid"],n["Data.Eq"],n["Data.Foldable"],n["Data.FoldableWithIndex"],n["Data.Function"],n["Data.Functor"],n["Data.FunctorWithIndex"],n["Data.HeytingAlgebra"],n["Data.List"],n["Data.List.Lazy"],n["Data.List.Lazy.Types"],n["Data.List.Types"]),a=(n["Data.Maybe"],n["Data.Monoid"],n["Data.Ord"]),o=n["Data.Ordering"],u=n["Data.Semigroup"],i=(n["Data.Semiring"],n["Data.Show"],n["Data.Traversable"],n["Data.TraversableWithIndex"],n["Data.Tuple"],n["Data.Unfoldable"],n["Partial.Unsafe"],n.Prelude,function(){function n(){}return n.value=new n,n}()),l=function(){function n(n,t,e,r){this.value0=n,this.value1=t,this.value2=e,this.value3=r}return n.create=function(t){return function(e){return function(r){return function(a){return new n(t,e,r,a)}}}},n}(),c=function(){function n(n,t,e,r,a,o,u){this.value0=n,this.value1=t,this.value2=e,this.value3=r,this.value4=a,this.value5=o,this.value6=u}return n.create=function(t){return function(e){return function(r){return function(a){return function(o){return function(u){return function(i){return new n(t,e,r,a,o,u,i)}}}}}}},n}(),f=function(){function n(n,t,e){this.value0=n,this.value1=t,this.value2=e}return n.create=function(t){return function(e){return function(r){return new n(t,e,r)}}},n}(),s=function(){function n(n,t,e){this.value0=n,this.value1=t,this.value2=e}return n.create=function(t){return function(e){return function(r){return new n(t,e,r)}}},n}(),d=function(){function n(n,t,e,r,a,o){this.value0=n,this.value1=t,this.value2=e,this.value3=r,this.value4=a,this.value5=o}return n.create=function(t){return function(e){return function(r){return function(a){return function(o){return function(u){return new n(t,e,r,a,o,u)}}}}}},n}(),p=function(){function n(n,t,e,r,a,o){this.value0=n,this.value1=t,this.value2=e,this.value3=r,this.value4=a,this.value5=o}return n.create=function(t){return function(e){return function(r){return function(a){return function(o){return function(u){return new n(t,e,r,a,o,u)}}}}}},n}(),v=function(){function n(n,t,e,r,a,o){this.value0=n,this.value1=t,this.value2=e,this.value3=r,this.value4=a,this.value5=o}return n.create=function(t){return function(e){return function(r){return function(a){return function(o){return function(u){return new n(t,e,r,a,o,u)}}}}}},n}(),D=function(){function n(n,t,e,r){this.value0=n,this.value1=t,this.value2=e,this.value3=r}return n.create=function(t){return function(e){return function(r){return function(a){return new n(t,e,r,a)}}}},n}(),m=function(n){if(n instanceof i)return 0;if(n instanceof l)return(1+m(n.value0)|0)+m(n.value3)|0;if(n instanceof c)return((2+m(n.value0)|0)+m(n.value3)|0)+m(n.value6)|0;throw new Error("Failed pattern match at Data.Map.Internal (line 662, column 1 - line 662, column 35): "+[n.constructor.name])},h=function(n){if(n instanceof i)return r.Nil.value;if(n instanceof l)return u.append(r.semigroupList)(h(n.value0))(u.append(r.semigroupList)(e.pure(r.applicativeList)(n.value1))(h(n.value3)));if(n instanceof c)return u.append(r.semigroupList)(h(n.value0))(u.append(r.semigroupList)(e.pure(r.applicativeList)(n.value1))(u.append(r.semigroupList)(h(n.value3))(u.append(r.semigroupList)(e.pure(r.applicativeList)(n.value4))(h(n.value6)))));throw new Error("Failed pattern match at Data.Map.Internal (line 606, column 1 - line 606, column 38): "+[n.constructor.name])},w=function(n){return function(t){return function(e){var a,o=n,u=t,i=!1;function D(n,t,a){if(t instanceof r.Nil)return i=!0,a;if(t instanceof r.Cons){if(t.value0 instanceof f)return o=n,u=t.value1,void(e=new l(a,t.value0.value0,t.value0.value1,t.value0.value2));if(t.value0 instanceof s)return o=n,u=t.value1,void(e=new l(t.value0.value0,t.value0.value1,t.value0.value2,a));if(t.value0 instanceof d)return o=n,u=t.value1,void(e=new c(a,t.value0.value0,t.value0.value1,t.value0.value2,t.value0.value3,t.value0.value4,t.value0.value5));if(t.value0 instanceof p)return o=n,u=t.value1,void(e=new c(t.value0.value0,t.value0.value1,t.value0.value2,a,t.value0.value3,t.value0.value4,t.value0.value5));if(t.value0 instanceof v)return o=n,u=t.value1,void(e=new c(t.value0.value0,t.value0.value1,t.value0.value2,t.value0.value3,t.value0.value4,t.value0.value5,a));throw new Error("Failed pattern match at Data.Map.Internal (line 418, column 3 - line 423, column 88): "+[t.value0.constructor.name])}throw new Error("Failed pattern match at Data.Map.Internal (line 415, column 1 - line 415, column 80): "+[t.constructor.name,a.constructor.name])}for(;!i;)a=D(o,u,e);return a}}},C=i.value;t.empty=C,t.insert=function(n){return function(t){return function(e){var u,m=function(t){return function(e){var a,o=t,u=!1;function i(t,a){if(t instanceof r.Nil)return u=!0,new l(a.value0,a.value1,a.value2,a.value3);if(t instanceof r.Cons){if(t.value0 instanceof f)return u=!0,w(n)(t.value1)(new c(a.value0,a.value1,a.value2,a.value3,t.value0.value0,t.value0.value1,t.value0.value2));if(t.value0 instanceof s)return u=!0,w(n)(t.value1)(new c(t.value0.value0,t.value0.value1,t.value0.value2,a.value0,a.value1,a.value2,a.value3));if(t.value0 instanceof d)return o=t.value1,void(e=new D(new l(a.value0,a.value1,a.value2,a.value3),t.value0.value0,t.value0.value1,new l(t.value0.value2,t.value0.value3,t.value0.value4,t.value0.value5)));if(t.value0 instanceof p)return o=t.value1,void(e=new D(new l(t.value0.value0,t.value0.value1,t.value0.value2,a.value0),a.value1,a.value2,new l(a.value3,t.value0.value3,t.value0.value4,t.value0.value5)));if(t.value0 instanceof v)return o=t.value1,void(e=new D(new l(t.value0.value0,t.value0.value1,t.value0.value2,t.value0.value3),t.value0.value4,t.value0.value5,new l(a.value0,a.value1,a.value2,a.value3)));throw new Error("Failed pattern match at Data.Map.Internal (line 454, column 5 - line 459, column 108): "+[t.value0.constructor.name,a.constructor.name])}throw new Error("Failed pattern match at Data.Map.Internal (line 451, column 3 - line 451, column 56): "+[t.constructor.name,a.constructor.name])}for(;!u;)a=i(o,e);return a}},h=a.compare(n);return u=r.Nil.value,function(a){var C,g=u,y=!1;function E(u,C){if(C instanceof i)return y=!0,m(u)(new D(i.value,t,e,i.value));if(C instanceof l){var E=h(t)(C.value1);return E instanceof o.EQ?(y=!0,w(n)(u)(new l(C.value0,t,e,C.value3))):E instanceof o.LT?(g=new r.Cons(new f(C.value1,C.value2,C.value3),u),void(a=C.value0)):(g=new r.Cons(new s(C.value0,C.value1,C.value2),u),void(a=C.value3))}if(C instanceof c){var b=h(t)(C.value1);if(b instanceof o.EQ)return y=!0,w(n)(u)(new c(C.value0,t,e,C.value3,C.value4,C.value5,C.value6));var S=h(t)(C.value4);return S instanceof o.EQ?(y=!0,w(n)(u)(new c(C.value0,C.value1,C.value2,C.value3,t,e,C.value6))):b instanceof o.LT?(g=new r.Cons(new d(C.value1,C.value2,C.value3,C.value4,C.value5,C.value6),u),void(a=C.value0)):b instanceof o.GT&&S instanceof o.LT?(g=new r.Cons(new p(C.value0,C.value1,C.value2,C.value4,C.value5,C.value6),u),void(a=C.value3)):(g=new r.Cons(new v(C.value0,C.value1,C.value2,C.value3,C.value4,C.value5),u),void(a=C.value6))}throw new Error("Failed pattern match at Data.Map.Internal (line 434, column 3 - line 434, column 55): "+[u.constructor.name,C.constructor.name])}for(;!y;)C=E(g,a);return C}}}},t.keys=h,t.size=m}(n["Data.Map.Internal"]=n["Data.Map.Internal"]||{}),function(t){"use strict";var e=n["Control.Applicative"],r=n["Control.Bind"],a=n["Control.Monad.Rec.Class"],o=(n["Control.Monad.ST"],n["Control.Monad.ST.Internal"]),u=(n["Control.Semigroupoid"],n["Data.Array"]),i=n["Data.Array.ST"],l=(n["Data.Eq"],n["Data.Foldable"]),c=(n["Data.Function"],n["Data.Functor"],n["Data.HeytingAlgebra"],n["Data.List"],n["Data.List.Types"]),f=n["Data.Map.Internal"],s=(n["Data.Maybe"],n["Data.Monoid"],n["Data.Ord"]),d=n["Data.Ordering"],p=(n["Data.Semigroup"],n["Data.Semiring"],n["Data.Show"],n["Data.Unfoldable"],n["Data.Unit"]),v=(n["Partial.Unsafe"],n.Prelude,function(n){return function(t){return function(e){return f.insert(n)(t)(p.unit)(e)}}}),D=f.empty,m=function(n){return function(t){return l.foldl(n)(function(n){return function(e){return v(t)(e)(n)}})(D)}};t.fromFoldable=m,t.empty=D,t.insert=v,t.size=function(n){return f.size(n)},t.intersection=function(n){return function(t){return function(p){var v=function(n){return u.fromFoldable(c.foldableList)((t=n,f.keys(t)));var t},D=v(p),h=u.length(D),w=v(t),C=u.length(w);return m(l.foldableArray)(n)(r.bind(o.bindST)(r.bind(o.bindST)(i.empty)(function(t){return a.tailRecM2(o.monadRecST)(function(r){return function(u){if(r<C&&u<h){var l=s.compare(n)(w[r])(D[u]);if(l instanceof d.EQ)return function(){return i.push(w[r])(t)(),new a.Loop({a:r+1|0,b:u+1|0})};if(l instanceof d.LT)return e.pure(o.applicativeST)(new a.Loop({a:r+1|0,b:u}));if(l instanceof d.GT)return e.pure(o.applicativeST)(new a.Loop({a:r,b:u+1|0}));throw new Error("Failed pattern match at Data.Set (line 176, column 12 - line 181, column 43): "+[l.constructor.name])}return e.pure(o.applicativeST)(new a.Done(t))}})(0)(0)}))(i.unsafeFreeze)())}}}}(n["Data.Set"]=n["Data.Set"]||{}),function(n){"use strict";n.toCharArray=function(n){return n.split("")},n.length=function(n){return n.length},n.splitAt=function(n){return function(t){return{before:t.substring(0,n),after:t.substring(n)}}}}(n["Data.String.CodeUnits"]=n["Data.String.CodeUnits"]||{}),function(t){"use strict";var e=n["Data.String.CodeUnits"];n["Control.Semigroupoid"],n["Data.Boolean"],n["Data.Eq"],n["Data.Function"],n["Data.HeytingAlgebra"],n["Data.Maybe"],n["Data.Ord"],n["Data.Ring"],n["Data.Semiring"],n["Data.String.Pattern"],n["Data.String.Unsafe"],n.Prelude;t.toCharArray=e.toCharArray,t.length=e.length,t.splitAt=e.splitAt}(n["Data.String.CodeUnits"]=n["Data.String.CodeUnits"]||{}),function(n){"use strict";n.split=function(n){return function(t){return t.split(n)}},n.trim=function(n){return n.trim()}}(n["Data.String.Common"]=n["Data.String.Common"]||{}),function(t){"use strict";var e=n["Data.String.Common"];n["Data.Eq"],n["Data.Ordering"],n["Data.String.Pattern"],n.Prelude;t.split=e.split,t.trim=e.trim}(n["Data.String.Common"]=n["Data.String.Common"]||{}),function(n){"use strict";var t=function(){var n={},t="Pure",e="Throw",r="Catch",a="Sync",o="Async",u="Bind",i="Bracket",l="Fork",c="Sequential",f="Map",s="Apply",d="Alt",p="Cons",v="Resume",D="Release",m="Finalizer",h="Finalized",w="Forked";function C(n,t,e,r){this.tag=n,this._1=t,this._2=e,this._3=r}function g(n){var t=function(t,e,r){return new C(n,t,e,r)};return t.tag=n,t}function y(n){return new C(t,void 0)}function E(n){try{n()}catch(t){setTimeout(function(){throw t},0)}}function b(n,t,e){try{return t(e())}catch(r){return n(r)}}function S(n,t,e){try{return t(e)()}catch(r){return e(n(r))(),y}}var A=function(){var n=1024,t=0,e=0,r=new Array(n),a=!1;function o(){var o;for(a=!0;0!==t;)t--,o=r[e],r[e]=void 0,e=(e+1)%n,o();a=!1}return{isDraining:function(){return a},enqueue:function(u){var i;t===n&&(i=a,o(),a=i),r[(e+t)%n]=u,t++,a||o()}}}();var F=0,M=1,_=2,T=3,P=4,L=5,U=6;function B(n,f,s){var d=0,w=F,g=s,y=null,I=null,k=null,O=null,q=null,N=0,x=0,W=null,z=!0;function H(s){for(var x,Q,G;;)switch(x=null,Q=null,G=null,w){case _:w=M,g=k(g),null===O?k=null:(k=O._1,O=O._2);break;case T:n.isLeft(g)?(w=L,y=g,g=null):null===k?w=L:(w=_,g=n.fromRight(g));break;case M:switch(g.tag){case u:k&&(O=new C(p,k,O)),k=g._2,w=M,g=g._1;break;case t:null===k?(w=L,g=n.right(g._1)):(w=_,g=g._1);break;case a:w=T,g=b(n.left,n.right,g._1);break;case o:return w=P,void(g=S(n.left,g._1,function(n){return function(){d===s&&(d++,A.enqueue(function(){d===s+1&&(w=T,g=n,H(d))}))}}));case e:w=L,y=n.left(g._1),g=null;break;case r:q=new C(p,g,null===k?q:new C(p,new C(v,k,O),q,I),I),k=null,O=null,w=M,g=g._1;break;case i:N++,q=new C(p,g,null===k?q:new C(p,new C(v,k,O),q,I),I),k=null,O=null,w=M,g=g._1;break;case l:w=T,x=B(n,f,g._2),f&&f.register(x),g._1&&x.run(),g=n.right(x);break;case c:w=M,g=R(n,f,g._1)}break;case L:if(k=null,O=null,null===q)w=U,g=I||y||g;else switch(x=q._3,G=q._1,q=q._2,G.tag){case r:I&&I!==x?w=L:y&&(w=M,g=G._2(n.fromLeft(y)),y=null);break;case v:I&&I!==x||y?w=L:(k=G._1,O=G._2,w=_,g=n.fromRight(g));break;case i:N--,null===y&&(Q=n.fromRight(g),q=new C(p,new C(D,G._2,Q),q,x),(I===x||N>0)&&(w=M,g=G._3(Q)));break;case D:N++,q=new C(p,new C(h,g,y),q,I),w=M,g=I&&I!==x?G._1.killed(n.fromLeft(I))(G._2):y?G._1.failed(n.fromLeft(y))(G._2):G._1.completed(n.fromRight(g))(G._2),y=null;break;case m:N++,q=new C(p,new C(h,g,y),q,I),w=M,g=G._1;break;case h:N--,w=L,g=G._1,y=G._2}break;case U:for(var j in W)W.hasOwnProperty(j)&&(z=z&&W[j].rethrow,E(W[j].handler(g)));return W=null,void(I&&y?setTimeout(function(){throw n.fromLeft(y)},0):n.isLeft(g)&&z&&setTimeout(function(){if(z)throw n.fromLeft(g)},0));case F:w=M;break;case P:return}}function Q(n){return function(){if(w===U)return z=z&&n.rethrow,n.handler(g)(),function(){};var t=x++;return(W=W||{})[t]=n,function(){null!==W&&delete W[t]}}}return{kill:function(t,e){return function(){if(w===U)return e(n.right(void 0))(),function(){};var r=Q({rethrow:!1,handler:function(){return e(n.right(void 0))}})();switch(w){case F:I=n.left(t),w=U,g=I,H(d);break;case P:null===I&&(I=n.left(t)),0===N&&(w===P&&(q=new C(p,new C(m,g(t)),q,I)),w=L,g=null,y=null,H(++d));break;default:null===I&&(I=n.left(t)),0===N&&(w=L,g=null,y=null)}return r}},join:function(n){return function(){var t=Q({rethrow:!1,handler:n})();return w===F&&H(d),t}},onComplete:Q,isSuspended:function(){return w===F},run:function(){w===F&&(A.isDraining()?H(d):A.enqueue(function(){H(d)}))}}}function I(t,e,r,a){var u=0,i={},l=0,c={},v=new Error("[ParAff] Early exit"),D=null,m=n;function h(e,r,a){var o,u,l=r,c=null,v=null,D=0,m={};n:for(;;)switch(o=null,l.tag){case w:if(l._3===n&&(o=i[l._1],m[D++]=o.kill(e,function(n){return function(){0===--D&&a(n)()}})),null===c)break n;l=c._2,null===v?c=null:(c=v._1,v=v._2);break;case f:l=l._2;break;case s:case d:c&&(v=new C(p,c,v)),c=l,l=l._1}if(0===D)a(t.right(void 0))();else for(u=0,o=D;u<o;u++)m[u]=m[u]();return m}function g(e){return function(r){return function(){delete i[e._1],e._3=r,function e(r,o,u){var i,p,m,w,C,g;for(t.isLeft(r)?(i=r,p=null):(p=r,i=null);;){if(m=null,w=null,C=null,g=null,null!==D)return;if(null===o)return void a(i||p)();if(o._3!==n)return;switch(o.tag){case f:null===i?(o._3=t.right(o._1(t.fromRight(p))),p=o._3):o._3=i;break;case s:if(m=o._1._3,w=o._2._3,i){if(o._3=i,C=!0,g=l++,c[g]=h(v,i===m?o._2:o._1,function(){return function(){delete c[g],C?C=!1:null===u?e(i,null,null):e(i,u._1,u._2)}}),C)return void(C=!1)}else{if(m===n||w===n)return;p=t.right(t.fromRight(m)(t.fromRight(w))),o._3=p}break;case d:if(m=o._1._3,w=o._2._3,m===n&&t.isLeft(w)||w===n&&t.isLeft(m))return;if(m!==n&&t.isLeft(m)&&w!==n&&t.isLeft(w))i=p===m?w:m,p=null,o._3=i;else if(o._3=p,C=!0,g=l++,c[g]=h(v,p===m?o._2:o._1,function(){return function(){delete c[g],C?C=!1:null===u?e(p,null,null):e(p,u._1,u._2)}}),C)return void(C=!1)}null===u?o=null:(o=u._1,u=u._2)}}(r,e._2._1,e._2._2)}}}return function(){var a,o,l=M,c=r,v=null,D=null;n:for(;;)switch(a=null,o=null,l){case M:switch(c.tag){case f:v&&(D=new C(p,v,D)),v=new C(f,c._1,n,n),c=c._2;break;case s:v&&(D=new C(p,v,D)),v=new C(s,n,c._2,n),c=c._1;break;case d:v&&(D=new C(p,v,D)),v=new C(d,n,c._2,n),c=c._1;break;default:o=u++,l=L,a=c,c=new C(w,o,new C(p,v,D),n),(a=B(t,e,a)).onComplete({rethrow:!1,handler:g(c)})(),i[o]=a,e&&e.register(a)}break;case L:if(null===v)break n;v._1===n?(v._1=c,l=M,c=v._2,v._2=n):(v._2=c,c=v,null===D?v=null:(v=D._1,D=D._2))}for(m=c,o=0;o<u;o++)i[o].run()}(),function(n){return new C(o,function(e){return function(){return function(n,e){var r;for(var a in D=t.left(n),c)if(c.hasOwnProperty(a))for(a in r=c[a])r.hasOwnProperty(a)&&r[a]();c=null;var u=h(n,m,e);return function(n){return new C(o,function(n){return function(){for(var n in u)u.hasOwnProperty(n)&&u[n]();return y}})}}(n,e)}})}}function R(n,t,e){return new C(o,function(r){return function(){return I(n,t,e,r)}})}return C.EMPTY=n,C.Pure=g(t),C.Throw=g(e),C.Catch=g(r),C.Sync=g(a),C.Async=g(o),C.Bind=g(u),C.Bracket=g(i),C.Fork=g(l),C.Seq=g(c),C.ParMap=g(f),C.ParApply=g(s),C.ParAlt=g(d),C.Fiber=B,C.Supervisor=function(n){var t={},e=0,r=0;return{register:function(n){var a=e++;n.onComplete({rethrow:!0,handler:function(n){return function(){r--,delete t[a]}}}),t[a]=n,r++},isEmpty:function(){return 0===r},killAll:function(o,u){return function(){var i=0,l={};function c(e){l[e]=t[e].kill(o,function(t){return function(){delete l[e],i--,n.isLeft(t)&&n.fromLeft(t)&&setTimeout(function(){throw n.fromLeft(t)},0),0===i&&u()}})()}for(var f in t)t.hasOwnProperty(f)&&(i++,c(f));return t={},e=0,r=0,function(n){return new C(a,function(){for(var n in l)l.hasOwnProperty(n)&&l[n]()})}}}}},C.Scheduler=A,C.nonCanceler=y,C}();n._pure=t.Pure,n._map=function(n){return function(e){return e.tag===t.Pure.tag?t.Pure(n(e._1)):t.Bind(e,function(e){return t.Pure(n(e))})}},n._bind=function(n){return function(e){return t.Bind(n,e)}},n._liftEffect=t.Sync,n._parAffMap=function(n){return function(e){return t.ParMap(n,e)}},n._parAffApply=function(n){return function(e){return t.ParApply(n,e)}},n.makeAff=t.Async,n._makeFiber=function(n,e){return function(){return t.Fiber(n,null,e)}},n._sequential=t.Seq}(n["Effect.Aff"]=n["Effect.Aff"]||{}),function(t){"use strict";n["Control.Category"],n["Control.Monad"],n.Effect;t.liftEffect=function(n){return n.liftEffect},t.MonadEffect=function(n,t){this.Monad0=n,this.liftEffect=t}}(n["Effect.Class"]=n["Effect.Class"]||{}),function(t){"use strict";n["Control.Alt"],n["Control.Alternative"],n["Control.Applicative"],n["Control.Apply"],n["Control.Bind"],n["Control.Monad.Cont.Trans"],n["Control.Monad.Except.Trans"],n["Control.Monad.Maybe.Trans"],n["Control.Monad.Reader.Trans"],n["Control.Monad.Writer.Trans"],n["Control.Plus"],n["Control.Semigroupoid"],n["Data.Either"],n["Data.Function"],n["Data.Functor"],n["Data.Functor.Compose"],n["Data.Maybe"],n["Data.Newtype"],n["Data.Unit"],n["Effect.Class"],n["Effect.Ref"],n.Prelude;t.parallel=function(n){return n.parallel},t.sequential=function(n){return n.sequential},t.Parallel=function(n,t,e,r){this.Applicative1=n,this.Monad0=t,this.parallel=e,this.sequential=r}}(n["Control.Parallel.Class"]=n["Control.Parallel.Class"]||{}),function(t){"use strict";n["Control.Alternative"],n["Control.Apply"];var e=n["Control.Category"],r=n["Control.Parallel.Class"],a=(n["Control.Semigroupoid"],n["Data.Foldable"]),o=(n["Data.Traversable"],n.Prelude,function(n){return function(t){return function(e){return function(o){return r.sequential(n)(a.traverse_(n.Applicative1())(t)(function(t){return r.parallel(n)(e(t))})(o))}}}});t.parTraverse_=o,t.parSequence_=function(n){return function(t){return o(n)(t)(e.identity(e.categoryFn))}}}(n["Control.Parallel"]=n["Control.Parallel"]||{}),function(n){"use strict";n.error=function(n){return new Error(n)},n.throwException=function(n){return function(){throw n}}}(n["Effect.Exception"]=n["Effect.Exception"]||{}),function(t){"use strict";var e=n["Effect.Exception"];n["Control.Applicative"],n["Control.Semigroupoid"],n["Data.Either"],n["Data.Functor"],n["Data.Maybe"],n["Data.Show"],n.Effect,n.Prelude;t.throw=function(n){return e.throwException(e.error(n))}}(n["Effect.Exception"]=n["Effect.Exception"]||{}),function(t){"use strict";var e=n["Effect.Aff"],r=(n["Control.Alt"],n["Control.Alternative"],n["Control.Applicative"]),a=n["Control.Apply"],o=n["Control.Bind"],u=(n["Control.Lazy"],n["Control.Monad"]),i=(n["Control.Monad.Error.Class"],n["Control.Monad.Rec.Class"],n["Control.Parallel"]),l=n["Control.Parallel.Class"],c=(n["Control.Plus"],n["Control.Semigroupoid"],n["Data.Either"]),f=n["Data.Foldable"],s=n["Data.Function"],d=(n["Data.Function.Uncurried"],n["Data.Functor"]),p=n["Data.Monoid"],v=(n["Data.Newtype"],n["Data.Semigroup"]),D=(n["Data.Time.Duration"],n["Data.Unit"]),m=n.Effect,h=n["Effect.Class"],w=(n["Effect.Exception"],n["Effect.Unsafe"],n["Partial.Unsafe"]),C=(n.Prelude,n["Unsafe.Coerce"]),g=new d.Functor(e._parAffMap),y=new d.Functor(e._map),E={isLeft:function(n){if(n instanceof c.Left)return!0;if(n instanceof c.Right)return!1;throw new Error("Failed pattern match at Effect.Aff (line 390, column 12 - line 392, column 20): "+[n.constructor.name])},fromLeft:function(n){if(n instanceof c.Left)return n.value0;if(n instanceof c.Right)return w.unsafeCrashWith("unsafeFromLeft: Right");throw new Error("Failed pattern match at Effect.Aff (line 395, column 20 - line 399, column 3): "+[n.constructor.name])},fromRight:function(n){if(n instanceof c.Right)return n.value0;if(n instanceof c.Left)return w.unsafeCrashWith("unsafeFromRight: Left");throw new Error("Failed pattern match at Effect.Aff (line 400, column 21 - line 402, column 31): "+[n.constructor.name])},left:c.Left.create,right:c.Right.create},b=function(n){return function(){var t=function(n){return e._makeFiber(E,n)}(n)();return t.run(),t}},S=new a.Apply(function(){return g},e._parAffApply),A=new u.Monad(function(){return _},function(){return F}),F=new o.Bind(function(){return M},e._bind),M=new a.Apply(function(){return y},u.ap(A)),_=new r.Applicative(function(){return M},e._pure),T=new h.MonadEffect(function(){return A},e._liftEffect),P=new l.Parallel(function(){return L},function(){return A},C.unsafeCoerce,e._sequential),L=new r.Applicative(function(){return S},function(n){return l.parallel(P)(r.pure(_)(n))}),U=new v.Semigroup(function(n){return function(t){return function(e){return i.parSequence_(P)(f.foldableArray)([n(e),t(e)])}}}),B=s.const(r.pure(_)(D.unit)),I=new p.Monoid(function(){return U},B);t.launchAff=b,t.launchAff_=function(n){return d.void(m.functorEffect)(b(n))},t.nonCanceler=B,t.functorAff=y,t.applyAff=M,t.applicativeAff=_,t.bindAff=F,t.monadAff=A,t.monadEffectAff=T,t.functorParAff=g,t.applyParAff=S,t.applicativeParAff=L,t.parallelAff=P,t.semigroupCanceler=U,t.monoidCanceler=I,t.makeAff=e.makeAff}(n["Effect.Aff"]=n["Effect.Aff"]||{}),function(t){"use strict";n["Node.Encoding"];var e=n["Data.Show"],r=(n.Prelude,function(){function n(){}return n.value=new n,n}()),a=function(){function n(){}return n.value=new n,n}(),o=function(){function n(){}return n.value=new n,n}(),u=function(){function n(){}return n.value=new n,n}(),i=function(){function n(){}return n.value=new n,n}(),l=function(){function n(){}return n.value=new n,n}(),c=function(){function n(){}return n.value=new n,n}(),f=function(){function n(){}return n.value=new n,n}(),s=new e.Show(function(n){if(n instanceof r)return"ASCII";if(n instanceof a)return"UTF8";if(n instanceof o)return"UTF16LE";if(n instanceof u)return"UCS2";if(n instanceof i)return"Base64";if(n instanceof l)return"Latin1";if(n instanceof c)return"Binary";if(n instanceof f)return"Hex";throw new Error("Failed pattern match at Node.Encoding (line 19, column 1 - line 19, column 39): "+[n.constructor.name])});t.ASCII=r,t.UTF8=a,t.UTF16LE=o,t.UCS2=u,t.Base64=i,t.Latin1=l,t.Binary=c,t.Hex=f,t.encodingToNode=function(n){if(n instanceof r)return"ascii";if(n instanceof a)return"utf8";if(n instanceof o)return"utf16le";if(n instanceof u)return"ucs2";if(n instanceof i)return"base64";if(n instanceof l)return"latin1";if(n instanceof c)return"binary";if(n instanceof f)return"hex";throw new Error("Failed pattern match at Node.Encoding (line 31, column 1 - line 31, column 37): "+[n.constructor.name])},t.showEncoding=s}(n["Node.Encoding"]=n["Node.Encoding"]||{}),function(t){"use strict";(n["Node.Process"]=n["Node.Process"]||{}).process=process}(),function(n){"use strict";n.readChunkImpl=function(n){return function(t){return function(e){if(e instanceof Buffer)return t(e);if("string"==typeof e)return n(e);throw new Error("Node.Stream.readChunkImpl: Unrecognised chunk type; expected String or Buffer, got: "+e)}}},n.onDataEitherImpl=function(n){return function(t){return function(e){return function(){t.on("data",function(t){e(n(t))()})}}}},n.onEnd=function(n){return function(t){return function(){n.on("end",t)}}},n.write=function(n){return function(t){return function(e){return function(){return n.write(t,null,e)}}}},n.writeStringImpl=function(n){return function(t){return function(e){return function(r){return function(){return n.write(e,t,r)}}}}}}(n["Node.Stream"]=n["Node.Stream"]||{}),function(t){"use strict";(n["Node.Buffer"]=n["Node.Buffer"]||{}).toStringImpl=function(n){return function(t){return function(){return t.toString(n)}}}}(),function(t){"use strict";var e=n["Node.Buffer"],r=(n["Control.Semigroupoid"],n["Data.ArrayBuffer.Types"],n["Data.Maybe"],n["Data.Show"],n.Effect,n["Node.Encoding"]);n.Prelude;t.toString=function(n){return e.toStringImpl(r.encodingToNode(n))}}(n["Node.Buffer"]=n["Node.Buffer"]||{}),function(t){"use strict";var e=n["Node.Stream"],r=n["Control.Applicative"],a=n["Control.Bind"],o=n["Data.Either"],u=(n["Data.Functor"],n["Data.Maybe"],n["Data.Show"]),i=n.Effect,l=n["Effect.Exception"],c=n["Node.Buffer"],f=n["Node.Encoding"],s=(n.Prelude,e.readChunkImpl(o.Left.create)(o.Right.create)),d=function(n){return function(t){return e.onDataEitherImpl(s)(n)(t)}},p=function(n){return function(t){return d(n)(a.composeKleisliFlipped(i.bindEffect)(t)(function(n){if(n instanceof o.Left)return l.throw("Stream encoding should not be set");if(n instanceof o.Right)return r.pure(i.applicativeEffect)(n.value0);throw new Error("Failed pattern match at Node.Stream (line 94, column 5 - line 98, column 17): "+[n.constructor.name])}))}};t.onData=p,t.onDataString=function(n){return function(t){return function(e){return p(n)(a.composeKleisliFlipped(i.bindEffect)(e)(c.toString(t)))}}},t.onDataEither=d,t.writeString=function(n){return function(t){return e.writeStringImpl(n)(u.show(f.showEncoding)(t))}},t.onEnd=e.onEnd}(n["Node.Stream"]=n["Node.Stream"]||{}),function(t){"use strict";var e=n["Node.Process"],r=(n["Data.Functor"],n["Data.Maybe"],n["Data.Posix"],n["Data.Posix.Signal"],n.Effect,n["Foreign.Object"],n["Node.Platform"],n["Node.Stream"],n.Prelude,n["Unsafe.Coerce"],e.process.stdout),a=e.process.stdin;t.stdin=a,t.stdout=r}(n["Node.Process"]=n["Node.Process"]||{}),function(t){"use strict";var e=n["Control.Applicative"],r=n["Control.Bind"],a=n["Control.Category"],o=n["Control.Monad.Rec.Class"],u=n["Data.Boolean"],i=n["Data.Either"],l=(n["Data.Eq"],n["Data.Foldable"]),c=n["Data.Functor"],f=n["Data.Int"],s=n["Data.Maybe"],d=n["Data.Monoid"],p=n["Data.Ord"],v=(n["Data.Ring"],n["Data.Semigroup"],n["Data.Semiring"],n["Data.Set"]),D=n["Data.Show"],m=(n["Data.String"],n["Data.String.CodeUnits"]),h=n["Data.String.Common"],w=(n["Data.String.Pattern"],n["Data.Tuple"]),C=n["Data.Unit"],g=n.Effect,y=n["Effect.Aff"],E=n["Effect.Class"],b=n["Effect.Ref"],S=n["Node.Encoding"],A=n["Node.Process"],F=n["Node.Stream"],M=n["Partial.Unsafe"],_=(n.Prelude,function(n){return i.either(function(n){return M.unsafeCrashWith(n)})(a.identity(a.categoryFn))(r.bind(i.bindEither)(i.note("n s")((t=n,2===(c=h.split("\n")(h.trim(t))).length?r.bind(s.bindMaybe)(f.fromString(c[0]))(function(n){return new s.Just(new w.Tuple(n,c[1]))}):s.Nothing.value)))(function(n){return e.pure(i.applicativeEither)(D.show(D.showInt)((n.value0,function(n){return o.tailRec(function(t){if(t.value0===(m.length(n)-1|0))return new o.Done(t.value1);if(u.otherwise){var e=m.splitAt(t.value0)(n),r=v.fromFoldable(l.foldableArray)(p.ordChar)(m.toCharArray(e.before)),a=v.fromFoldable(l.foldableArray)(p.ordChar)(m.toCharArray(e.after));return new o.Loop(new w.Tuple(t.value0+1|0,p.max(p.ordInt)(t.value1)(v.size(v.intersection(p.ordChar)(r)(a)))))}throw new Error("Failed pattern match at ABC098B (line 68, column 5 - line 79, column 72): "+[t.constructor.name])})(new w.Tuple(1,1))})(n.value1))+"\n")}));var t,c}),T=y.makeAff(function(n){return function(){var t=b.new("")();return F.onDataString(A.stdin)(S.UTF8.value)(function(n){return function(){var e=b.read(t)();return b.write(e+n)(t)()}})(),F.onEnd(A.stdin)(function(){var r=b.read(t)();return n(e.pure(i.applicativeEither)(r))()})(),d.mempty(y.monoidCanceler)}}),P=y.launchAff_(r.bind(y.bindAff)(T)(function(n){return r.bind(y.bindAff)(e.pure(y.applicativeAff)(_(n)))(function(n){return E.liftEffect(y.monadEffectAff)((t=n,c.void(g.functorEffect)(F.writeString(A.stdout)(S.UTF8.value)(t)(e.pure(g.applicativeEffect)(C.unit)))));var t})}));t.main=P,t.solve=_}(n.ABC098B=n.ABC098B||{}),n.ABC098B.main();
},{}]},{},["Focm"], null)


package main

import (
  "fmt"
)

func maxInt(a ...int) int {m := a[0]; for _, x := range a {if x > m {m = x}}; return m}
func minInt(a ...int) int {m := a[0]; for _, x := range a {if x < m {m = x}}; return m}

func main() {
  var n int
  var s string
  fmt.Scan(&n, &s)
  l := make([]int, n); l[0] |= 1 << uint(s[0] - 'a')
  r := make([]int, n); r[n-1] |= 1 << uint(s[n-1] - 'a')
  for i := 0; i < n - 1; i++ {
    l[i+1] = l[i] | (1 << uint(s[i+1] - 'a'))
  }
  for i := n - 1; i > 0; i-- {
    r[i-1] = r[i] | (1 << uint(s[i-1] - 'a'))
  }

  ans := 0
  for i := 0; i < n - 1; i++ {
    res := l[i] & r[i+1]
    cnt := 0
    for j := uint(0); j < 26; j++ {
      if res >> j & 1 == 1 {
        cnt++
      }
    }
    ans = maxInt(ans, cnt)
  }
  fmt.Println(ans)
}


package main

import (
        "fmt"
)

func solution(n int, s string) int {
        out := -1 << 31
        for i := 1; i < n; i++ {
                x := count(s[:i])
                y := count(s[i:])
                t := 0
                for j := 0; j < 26; j++ {
                        if x[j] > 0 && y[j] > 0 {
                                t++
                        }
                }
                out = max(out, t)
        }
        return out
}

func count(s string) [26]int {
        var a [26]int
        for _, r := range s {
                a[r-'a']++
        }
        return a
}

func max(x, y int) int {
        if x > y {
                return x
        }
        return y
}

func main() {
        var n int
        var s string
        fmt.Scan(&n, &s)
        fmt.Println(solution(n, s))
}


package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

var sc = bufio.NewScanner(os.Stdin)

func main() {
	sc.Split(bufio.ScanWords)
	sc.Scan()
	n, _ := strconv.Atoi(sc.Text())
	sc.Scan()
	s := sc.Text()

	ans := 0
	for i := 1; i < n-1; i++ {
		s1 := s[:i]
		s2 := s[i:]

		cnt := 0
		for c := 'a'; c <= 'z'; c++ {
			if strings.Contains(s1, string(c)) && strings.Contains(s2, string(c)) {
				cnt++
			}
		}
		if ans < cnt {
			ans = cnt
		}
	}
	fmt.Println(ans)
}


package main

import (
	"bufio"
	"fmt"
	"math"
	"os"
	"strconv"
	"strings"
)

//Util
func nextStr() string {
	sc.Scan()
	return sc.Text()
}

func nextInt() int {
	sc.Scan()
	i, e := strconv.Atoi(sc.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func maxInt(a, b int) int {
	if a > b {
		return a
	} else {
		return b
	}
}

func minInt(a, b int) int {
	if a > b {
		return b
	} else {
		return a
	}
}

func absInt(a int) int {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func absFloat64(a float64) float64 {
	if a >= 0 {
		return a
	} else {
		return -a
	}
}

func maxFloat64(a, b float64) float64 {
	if a > b {
		return a
	} else {
		return b
	}
}

func minFloat64(a, b float64) float64 {
	if a > b {
		return b
	} else {
		return a
	}
}

func str2Int(s string) int {
	n, _ := strconv.Atoi(s)
	return n
}

func reverse(s string) string {
	runes := []rune(s)
	for i, j := 0, len(runes)-1; i < j; i, j = i+1, j-1 {
		runes[i], runes[j] = runes[j], runes[i]
	}
	return string(runes)
}

func powInt(p, q int) int {
	return int(math.Pow(float64(p), float64(q)))
}

func isPrime(x int) bool {
	if x == 1 {
		return false
	}
	if x == 2 {
		return true
	}
	if x%2 == 0 {
		return false
	}

	b := true
	rootx := int(math.Sqrt(float64(x)))
	i := 3
	for i <= rootx {
		if x%i == 0 {
			b = false
			break
		}
		i += 2
	}
	return b
}

func PrimeFactors(n int) (pfs []int) {
	// Get the number of 2s that divide n
	for n%2 == 0 {
		pfs = append(pfs, 2)
		n = n / 2
	}

	// n must be odd at this point. so we can skip one element
	// (note i = i + 2)
	for i := 3; i*i <= n; i = i + 2 {
		// while i divides n, append i and divide n
		for n%i == 0 {
			pfs = append(pfs, i)
			n = n / i
		}
	}

	// This condition is to handle the case when n is a prime number
	// greater than 2
	if n > 2 {
		pfs = append(pfs, n)
	}

	return
}

func sumInts(x []int) int {

	total := 0
	for _, v := range x {
		total += v
	}

	return total
}

//Main
const (
	initialBufSize = 10000
	maxBufSize     = 1000000
	mod            = 1e9 + 7
)

var (
	sc *bufio.Scanner = func() *bufio.Scanner {
		sc := bufio.NewScanner(os.Stdin)
		buf := make([]byte, initialBufSize)
		sc.Buffer(buf, maxBufSize)
		return sc
	}()
)

var N int
var S string

func main() {
	sc.Split(bufio.ScanWords)

	N = nextInt()
	S = nextStr()

	ans := -1
	for i := 1; i < N-1; i++ {
		tmp := 0
		for j := 0; j < i; j++ {
			if !strings.Contains(string(S[:j]), string(S[j])) && strings.Contains(string(S[i:]), string(S[j])) {
				tmp++
			}
		}

		ans = maxInt(ans, tmp)
	}

	fmt.Println(ans)
}


package main

import (
	"fmt"
)

func main() {
	var n int
	var s string
	ans := 0

	fmt.Scan(&n)
	fmt.Scan(&s)

	n = 6
	s = "aabbca"

	r := []rune(s)

	for i := 1; i < n; i++ {
		cnt := 0

		for c := 'a'; c <= 'z'; c++ {
			left := false
			right := false

			for j := 0; j < i; j++ {
				if r[j] == c {
					left = true
				}
			}

			for j := 1; j < i; j++ {
				if r[j] == c {
					right = true
				}
			}

			if left && right {
				cnt++
			}
		}

		if ans < cnt {
			ans = cnt
		}

	}

	fmt.Println(ans)
}


package main

import (
	"bufio"
	"errors"
	"fmt"
	"io"
	"math"
	"os"
	"strconv"
	"strings"
)

/*********** I/O ***********/

var (
	ReadString func() string // ReadString returns a WORD string.
	stdout     *bufio.Writer
)

func init() {
	ReadString = newReadString(os.Stdin)
	stdout = bufio.NewWriter(os.Stdout)
}

func newReadString(ior io.Reader) func() string {
	r := bufio.NewScanner(ior)
	r.Buffer(make([]byte, 1024), int(1e+11))
	// Split sets the split function for the Scanner. The default split function is ScanLines.
	// Split panics if it is called after scanning has started.
	r.Split(bufio.ScanWords)

	return func() string {
		if !r.Scan() {
			panic("Scan failed")
		}
		return r.Text()
	}
}

// ReadInt returns an integer.
func ReadInt() int {
	return int(readInt64())
}

func readInt64() int64 {
	i, err := strconv.ParseInt(ReadString(), 0, 64)
	if err != nil {
		panic(err.Error())
	}
	return i
}

// ReadIntSlice returns an integer slice that has n integers.
func ReadIntSlice(n int) []int {
	b := make([]int, n)
	for i := 0; i < n; i++ {
		b[i] = ReadInt()
	}
	return b
}

// ReadRuneSlice returns a rune slice.
func ReadRuneSlice() []rune {
	return []rune(ReadString())
}

/*********** Arithmetic ***********/

// Max returns the max integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Max(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m < integer {
			m = integer
		}
	}
	return m
}

// Min returns the min integer among input set.
// This function needs at least 1 argument (no argument causes panic).
func Min(integers ...int) int {
	m := integers[0]
	for i, integer := range integers {
		if i == 0 {
			continue
		}
		if m > integer {
			m = integer
		}
	}
	return m
}

// PowInt is integer version of math.Pow
func PowInt(a, e int) int {
	if a < 0 || e < 0 {
		panic(errors.New("[argument error]: PowInt does not accept negative integers"))
	}
	fa := float64(a)
	fe := float64(e)
	fanswer := math.Pow(fa, fe)
	return int(fanswer)
}

// AbsInt is integer version of math.Abs
func AbsInt(a int) int {
	fa := float64(a)
	fanswer := math.Abs(fa)
	return int(fanswer)
}

/*********** Utilities ***********/

// DeleteElement returns a *NEW* slice, that have the same and minimum length and capacity.
// DeleteElement makes a new slice by using easy slice literal.
func DeleteElement(s []int, i int) []int {
	if i < 0 || len(s) <= i {
		panic(errors.New("[index error]"))
	}
	// appendのみの実装
	n := make([]int, 0, len(s)-1)
	n = append(n, s[:i]...)
	n = append(n, s[i+1:]...)
	return n
}

// Concat returns a *NEW* slice, that have the same and minimum length and capacity.
func Concat(s, t []rune) []rune {
	n := make([]rune, 0, len(s)+len(t))
	n = append(n, s...)
	n = append(n, t...)
	return n
}

// UpperRune is rune version of `strings.ToUpper()`.
func UpperRune(r rune) rune {
	str := strings.ToUpper(string(r))
	return []rune(str)[0]
}

// LowerRune is rune version of `strings.ToLower()`.
func LowerRune(r rune) rune {
	str := strings.ToLower(string(r))
	return []rune(str)[0]
}

// ToggleRune returns a upper case if an input is a lower case, v.v.
func ToggleRune(r rune) rune {
	var str string
	if 'a' <= r && r <= 'z' {
		str = strings.ToUpper(string(r))
	} else if 'A' <= r && r <= 'Z' {
		str = strings.ToLower(string(r))
	} else {
		str = string(r)
	}
	return []rune(str)[0]
}

// ToggleString iteratively calls ToggleRune, and returns the toggled string.
func ToggleString(s string) string {
	inputRunes := []rune(s)
	outputRunes := make([]rune, 0, len(inputRunes))
	for _, r := range inputRunes {
		outputRunes = append(outputRunes, ToggleRune(r))
	}
	return string(outputRunes)
}

// Strtoi is a wrapper of `strconv.Atoi()`.
// If `strconv.Atoi()` returns an error, Strtoi calls panic.
func Strtoi(s string) int {
	if i, err := strconv.Atoi(s); err != nil {
		panic(errors.New("[argument error]: Strtoi only accepts integer string"))
	} else {
		return i
	}
}

// LowerBound returns an index of a slice whose value is EQUAL TO AND LARGER THAN A KEY VALUE.
func LowerBound(s []int, key int) int {
	isLarger := func(index, key int) bool {
		if s[index] >= key {
			return true
		} else {
			return false
		}
	}

	left, right := -1, len(s)

	for right-left > 1 {
		mid := left + (right-left)/2
		if isLarger(mid, key) {
			right = mid
		} else {
			left = mid
		}
	}

	return right
}

// UpperBound returns an index of a slice whose value is EQUAL TO AND SMALLER THAN A KEY VALUE.
func UpperBound(s []int, key int) int {
	isSmaller := func(index, key int) bool {
		if s[index] <= key {
			return true
		} else {
			return false
		}
	}

	left, right := -1, len(s)

	for right-left > 1 {
		mid := left + (right-left)/2
		if isSmaller(mid, key) {
			left = mid
		} else {
			right = mid
		}
	}

	return left
}

/********** sort package (snippets) **********/
//sort.Sort(sort.IntSlice(s))
//sort.Sort(sort.Reverse(sort.IntSlice(s)))
//sort.Sort(sort.Float64Slice(s))
//sort.Sort(sort.StringSlice(s))

/********** copy function **********/
//a = []int{0, 1, 2}
//b = make([]int, len(a))
//copy(b, a)

/********** I/O usage **********/

/*******************************************************************/

var n int
var S []rune

func main() {
	n, S = ReadInt(), ReadRuneSlice()
	ans := -1
	for i := 1; i < len(S)-1; i++ {
		amemo, bmemo := make(map[rune]int), make(map[rune]int)
		A, B := S[:i], S[i:]
		for _, a := range A {
			amemo[a] = 1
		}
		for _, b := range B {
			bmemo[b] = 1
		}
		tmp := 0
		for i := 'a'; i <= 'z'; i++ {
			if amemo[i] == 1 && bmemo[i] == 1 {
				tmp++
			}
		}
		ans = Max(ans, tmp)
	}
	fmt.Println(ans)
}


n = gets.to_i
s = gets.chomp.chars
hs = Hash.new
s.each_with_index do |c, i|
  hs[c] ||= []
  hs[c] << i
end

# imos method
res =  Array.new(n, 0)
hs.to_a.each do |k, v|
  next if v.size < 2
  l = v[0]
  r = v[-1]
  res[l] += 1
  res[r] -= 1
end
(1...n).each do |i|
  res[i] += res[i - 1]
end
puts res.max


gets
h = {}
a = gets.scan(/./)
a.each {|e| h[e] = (h[e]||0) + 1 }
x = m = 0
a.reverse_each {|e|
  if h[e] > 0
    x += 1
    h[e] *= -1
  end
  x -= 1  if 0 == h[e] += 1
  m = x  if m < x
}
p m


n = gets.to_i
s = gets.chomp.chars

left = {}
right = {}
s.each { |c| right[c] = right[c].to_i + 1 }
('a'..'z').each { |c| left[c] = 0 }
('a'..'z').each { |c| right[c] = 0 if right[c].nil? }

ans = 0
cnt = 0
s.each do |c|
  b1 = left[c] > 0 && right[c] > 0
  left[c] += 1
  right[c] -= 1
  b2 = left[c] > 0 && right[c] > 0

  if !b1 && b2
    cnt += 1
  elsif b1 && !b2
    cnt -= 1
  end
  ans = cnt if ans < cnt
end
puts ans


n = gets.chomp.to_i
s = gets.chomp.split("")
a = []
b = s
ans = 0
(n-1).times do
    hash_a = Hash.new(0)
    hash_b = Hash.new(0)
    a << b.shift
    a.each do |i|
        hash_a[i] += 1
    end
    b.each do |i|
        hash_b[i] += 1
    end
    max = [hash_b.size,hash_a.size].max
    min = [hash_b.size,hash_a.size].min
    if max == hash_b.size
        big = hash_b
        small = hash_a
    elsif max == hash_a
        big = hash_a
        small = hash_b
    end
    if big == nil || small == nil
        break
    end
    #  p big
    #  p small
    count = 0
    small.each do |i|
        # p big[i[0]]
        if big.include?(i[0])
            count += 1
           # [i[1],big[i[0]]].min
        end
    end
    ans = [ans,count].max
end
puts ans


n=gets.to_i
s=gets
ans=0
n.times{|l|
  a=Hash.new(0)
  for i in 0..l do
    a[s[i].ord-'a'.ord]=1
  end
  b=Hash.new(0)
  for i in l..n do
    b[s[i].ord-'a'.ord]=1
  end
  tans=0
  a.each{|k,v|
    tans+=1 if b[k]==1
  }
  ans=[ans,tans].max
}
p ans


def get_i() #空白区切の入力を数値(整数)の配列で返す
  return gets.chomp.split(" ").map(&:to_i)
end
def get_f() #空白区切の入力を数値(実数)の配列で返す
  return gets.chomp.split(" ").map(&:to_f)
end
def get() #空白区切の入力を文字列の配列で返す
  return gets.chomp.split(" ")
end
def get_nsp() #入力されたものを一文字ずつに区切った文字列の配列で返す
  return gets.chomp.split("")
end
def yn_judge(bool,y="Yes",n="No") #boolに真偽を投げることで、trueならy、falseならnの値を出力する
  return bool ? y : n
end
def array(size1,init=nil,size2=-1) #size2に二次元配列時の最初の要素数、size1に次の配列の大きさ、initに初期値を投げることでその配列を返す
  if size2==-1
    return Array.new(size1){init}
  else
    return Array.new(size2){Array.new(size1){init}}
  end
end

N=gets.to_i
S=get_nsp
ans=0
1.upto(N-1) do|i|
  x=S[0..i-1]
  y=S[i..]
  val=(x&y).size
  ans=val if ans<val
end
puts ans


use std::cmp::max;
use std::collections::HashMap;
use std::collections::HashSet;
use std::io::prelude::*;
fn main() {
    let stdin = std::io::stdin();
    let s: String = stdin
        .lock()
        .lines()
        .skip(1)
        .next()
        .expect("not two lines")
        .expect("read error");
    println!("{}", solve(&s.trim()));
}

fn solve(s: &str) -> u32 {
    let mut right: HashMap<char, u32> = HashMap::new();
    let mut left: HashSet<char> = HashSet::new();
    for c in s.chars() {
        let count = right.entry(c).or_insert(0);
        *count += 1;
    }
    let mut commons_max = 0;
    let mut commons = 0;
    for c in s.chars() {
        let right_count = right.get_mut(&c).unwrap();
        *right_count -= 1;
        if left.insert(c) {
            if *right_count > 0 {
                commons += 1;
                commons_max = max(commons, commons_max);
            }
        } else {
            if *right_count == 0 {
                commons -= 1;
            }
        }
    }
    commons_max
}


// input! macro is published in the following URLs.
// https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
// https://github.com/tanakh/competitive-rs.git
#[allow(unused_macros)]
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        let mut next = || { iter.next().unwrap() };
        input_inner!{next, $($r)*}
    };
    ($($r:tt)*) => {
        let stdin = std::io::stdin();
        let mut bytes = std::io::Read::bytes(std::io::BufReader::new(stdin.lock()));
        let mut next = move || -> String{
            bytes
                .by_ref()
                .map(|r|r.unwrap() as char)
                .skip_while(|c|c.is_whitespace())
                .take_while(|c|!c.is_whitespace())
                .collect()
        };
        input_inner!{next, $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! input_inner {
    ($next:expr) => {};
    ($next:expr, ) => {};

    ($next:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };

    ($next:expr, mut $var:ident : $t:tt $($r:tt)*) => {
        let mut $var = read_value!($next, $t);
        input_inner!{$next $($r)*}
    };
}

#[allow(unused_macros)]
macro_rules! read_value {
    ($next:expr, ( $($t:tt),* )) => {
        ( $(read_value!($next, $t)),* )
    };

    ($next:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
    };

    ($next:expr, [ $t:tt ]) => {
        {
            let len = read_value!($next, usize);
            (0..len).map(|_| read_value!($next, $t)).collect::<Vec<_>>()
        }
    };

    ($next:expr, chars) => {
        read_value!($next, String).chars().collect::<Vec<char>>()
    };

    ($next:expr, bytes) => {
        read_value!($next, String).into_bytes()
    };

    ($next:expr, usize1) => {
        read_value!($next, usize) - 1
    };

    ($next:expr, $t:ty) => {
        $next().parse::<$t>().expect("Parse error")
    };
}

fn main() {
    input! {
        n: usize,
        s: chars,
    }
    let mut max_count = 0;
    for i in 0..n {
        let (left, right) = s.split_at(i);
        let l = left.iter().collect::<std::collections::HashSet<_>>();
        let r = right.iter().collect::<std::collections::HashSet<_>>();
        let count = l.iter().filter(|x| r.get(*x).is_some()).count();
        max_count = std::cmp::max(max_count, count);
    }
    println!("{}", max_count);
}


#[allow(unused_imports)]
use std::char::*;
#[allow(unused_imports)]
use std::cmp::*;
use std::io::*;
use std::str::FromStr;
#[allow(unused_imports)]
use std::collections::*;

#[allow(unused_macros)]
macro_rules! debug {
    ($($a:expr),*) => {
        println!(concat!($(stringify!($a), " = {:?}, "),*), $($a),*);
    }
}

fn read<T: FromStr>() -> T {
    let stdin = stdin();
    let stdin = stdin.lock();
    let token: String = stdin
        .bytes()
        .map(|c| c.expect("failed to read char") as char)
        .skip_while(|c| c.is_whitespace())
        .take_while(|c| !c.is_whitespace())
        .collect();
    token.parse().ok().expect("failed to parse token")
}

#[derive(PartialEq, PartialOrd)]
pub struct Total<T>(pub T);

impl<T: PartialEq> Eq for Total<T> {}

impl<T: PartialOrd> Ord for Total<T> {
    fn cmp(&self, other: &Total<T>) -> std::cmp::Ordering {
        self.0.partial_cmp(&other.0).unwrap()
    }
}

#[allow(dead_code)]
const MAX:usize = 100006;
#[allow(dead_code)]
const INF_U32:u32 = 1 << 31;
#[allow(dead_code)]
const INF_I32:i32 = 1 << 30;
#[allow(dead_code)]
const INF_U64:u64 = 1 << 63;
#[allow(dead_code)]
const INF_I64:i64 = 1 << 62;

fn main() {
    let n:u32=read();
    let s:Vec<char>=read::<String>().chars().collect();

    let mut ans:i32 = 0;
    for i in 0..n {
        let mut map1 = HashMap::new();
        let mut map2 = HashMap::new();
        for j in 0..i {
            let cnt = map1.entry(s[j as usize]).or_insert(0);
            *cnt += 1;
        }
        for j in i..n {
            let cnt = map2.entry(s[j as usize]).or_insert(0);
            *cnt += 1;
        }

        let mut cnt:i32 = 0;
        for (k,_v) in &map1 {
            //debug!(i, k, cnt);
            if map2.contains_key(k) { cnt += 1; }
        }
        ans = max(ans, cnt);
    }

    println!("{}", ans);

}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

#[allow(unused_imports)]
use std::io::{stdout, Write, BufWriter};

fn main() {
    input! {
        _n: usize,
        s: String,
    }
    let s: Vec<_> = s.bytes().map(|c| c - b'a').collect();
    let lefts: Vec<_> = s.iter().scan(0i32, |state, i| {
        *state |= 1 << i;
        Some(*state)
    }).collect();
    let rights: Vec<_> = s.iter().rev().scan(0i32, |state, i| {
        *state |= 1 << i;
        Some(*state)
    }).collect();
    println!("{}", lefts.iter().zip(rights.iter().rev()).map(|(l, r)| (l & r).count_ones()).max().unwrap());
}


macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};

    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };

    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };

    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };

    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };

    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

use std::collections::HashMap;

fn main() {
    input! {
        _n: usize,
        s: chars,
    }
    let mut called_time = Vec::new();
    for i in 1..s.len() {
        let mut m1 = (b'a'..=b'z')
                    .map(|c| c as char)
                    .filter(|c| c.is_alphabetic())
                    .map(|c| (c, 0)).collect::<HashMap<_, _>>();
        let mut m2 = (b'a'..=b'z')
                    .map(|c| c as char)
                    .filter(|c| c.is_alphabetic())
                    .map(|c| (c, 0)).collect::<HashMap<_, _>>();
        let v = (b'a'..=b'z').map(|c| c as char).collect::<Vec<_>>();
        for j in 0..i {
            if let Some(x) = m1.get_mut(&s[j]) {
                *x += 1;
            }
        }
        for j in i..s.len() {
            if let Some(x) = m2.get_mut(&s[j]) {
                *x += 1;
            }
        }
        let mut time = 0;
        for j in 0..v.len() {
            if m2[&v[j]] != 0 && m1[&v[j]] != 0 {
                time+=1;
            }
        }
        called_time.push(time);
    }
    if let Some(x) = called_time.iter().max() {
        println!("{}", x);
    }
}


use std::collections::HashSet;

fn main() {
    let s = std::io::stdin();
    let mut sc = Scanner { stdin: s.lock() };
    let n: usize = sc.read();
    let s = sc.chars();

    let result = (1..n - 1).map(|i| {
        let a: HashSet<&char> = s[0..i].iter().collect();
        let b: HashSet<&char> = s[i..n].iter().collect();

        let res = a.intersection(&b).count();
        res
    }).max_by(|x, y| x.cmp(y)).unwrap();

    println!("{}", result);
}

//snippet from kenkoooo
pub struct Scanner<R> {
    stdin: R,
}

impl<R: std::io::Read> Scanner<R> {
    pub fn read<T: std::str::FromStr>(&mut self) -> T {
        use std::io::Read;
        let buf = self.stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r')
            .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn read_line(&mut self) -> String {
        use std::io::Read;
        let buf = self.stdin
            .by_ref()
            .bytes()
            .map(|b| b.unwrap())
            .skip_while(|&b| b == b'\n' || b == b'\r')
            .take_while(|&b| b != b'\n' && b != b'\r')
            .collect::<Vec<_>>();
        unsafe { std::str::from_utf8_unchecked(&buf) }
            .parse()
            .ok()
            .expect("Parse error.")
    }
    pub fn vec<T: std::str::FromStr>(&mut self, n: usize) -> Vec<T> {
        (0..n).map(|_| self.read()).collect()
    }

    pub fn chars(&mut self) -> Vec<char> {
        self.read::<String>().chars().collect()
    }
}


import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension [String] {
//    func joined() -> String {
//        return self.joinWithSeparator("")
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

/*************** メインプログラム ***************/

let N = readInt()!
let S = readLine()!.toArray()
let alphabet = "abcdefghijklmnopqrstuvwxyz".toArray()
var ans = [Int]()

for i in 1..<N {
    ans += [0]
    for c in alphabet {
        var left = false
        var right = false
        for j in 0..<i {
            if S[j] == c {
                left = true
            }
        }
        for j in i..<N {
            if S[j] == c {
                right = true
            }
        }
        if left && right {
            ans[i-1] += 1
        }
    }
}

print(ans.max())


import Foundation

let n = Int(readLine()!)!
let s = readLine()!
var ss: [String] = []
var ans = 0
s.forEach { ss.append(String($0)) }
for i in 0..<n-1 {
  let s1 = ss[0...i]
  let s2 = ss[i+1...n-1]
  ans = max(Set(s1).intersection(Set(s2)).count, ans)
}
print(ans)


import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension [String] {
//    func joined() -> String {
//        return self.joinWithSeparator("")
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

/*************** メインプログラム ***************/

let N = readInt()!
let S = readLine()!.toArray()
let alphabet = "abcdefghijklmnopqrstuvwxyz".toArray()
var ans = [Int](repeating: 0, count: N-1)

for i in 1..<N {
    for c in alphabet {
        var left = false
        var right = false
        for j in 0..<i {
            if S[j] == c {
                left = true
            }
        }
        for j in 1..<N {
            if S[j] == c {
                right = true
            }
        }
        if left && right {
            ans[i-1] += 1
        }
    }
}

print(ans.max())


import Foundation

#if swift(>=4.0)
extension String {
    func split(by separator: String) -> [String] {
        return self.components(separatedBy: separator)
    }
    func toArray() -> [String] {
        return self.map{String($0)}
    }
}
#else
extension String {
    func split(by separator: String) -> [String] {
        return self.componentsSeparatedByString(separator)
    }
    var count: Int {
        return self.characters.count
    }
    func toArray() -> [String] {
        return self.characters.map{String($0)}
    }
    func uppercased() -> String {
        return self.uppercaseString
    }
    func lowercased() -> String {
        return self.lowercaseString
    }
}
//extension [String] {
//    func joined() -> String {
//        return self.joinWithSeparator("")
//    }
//}
extension Array where Element: Comparable {
    func max() -> Element {
        return self.maxElement()!
    }
    func min() -> Element {
        return self.minElement()!
    }
    func sorted() -> Array {
        return self.sort()
    }
    func reversed() -> Array {
        return self.reverse()
    }
    mutating func sort() {
        self.sortInPlace()
    }
}
extension Array {
    init(repeating: Element, count: Int) {
        self.init(count: count, repeatedValue: repeating)
    }
}
func stride<T: Strideable>(from start: T, to end: T, by stride: T.Stride) -> StrideTo<T> {
    return start.stride(to: end, by: stride)
}
#endif
func readInt() -> Int? {
    return Int(readLine()!)
}
func readStringSplit(by separator: String) -> [String] {
    return readLine()!.split(by: separator)
}
func readIntSplit(by separator: String) -> [Int] {
    return readLine()!.split(by: separator).map{Int($0)!}
}

/*************** テストスペース ***************/

/*************** メインプログラム ***************/

let N = readInt()!
let S = readLine()!.toArray()
let alphabet = "abcdefghijklmnopqrstuvwxyz".toArray()
var ans = [Int](repeating: 0, count: N-1)

for i in 1..<N {
    var left = false
    var right = false
    for c in alphabet {
        for j in 0..<i {
            if S[j] == c {
                left = true
            }
        }
        for j in 1..<N {
            if S[j] == c {
                right = true
            }
        }
        if left && right {
            ans[i-1] += 1
        }
    }
}

print(ans.max())


import { ifError } from "assert";

const input=require('fs').readFileSync('/dev/stdin','utf8').split(/[\s]/);const tn=():number=>{const a=input[0];input.shift();return Number(a)};const tnn=(n:number):number[]=>{const a=[];for(let i=0;i<n;i++){a.push(tn())}return a};const ts=():string=>{const a=input[0];input.shift();return String(a)};const tss=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(ts())}return a};const tc=():string=>{let a=input[0].split('');const b=a[0];a.shift();if(a.length>0){input[0]=a.join('')}else{input.shift()}return String(b)};const tcc=(n:number):string[]=>{const a=[];for(let i=0;i<n;i++){a.push(tc())}return a};const to=(...arg)=>{console.log(...arg)};const abs=(a)=>{return Math.abs(a)};const min=(...a)=>{return Math.min(...a)};const max=(...a)=>{return Math.max(...a)};const floor=(a)=>{return Math.floor(a)};const asc=(ar:number[])=>{return ar.sort((a,b)=>{return a-b})};const desc=(ar:number[])=>{return ar.sort((a,b)=>{return b-a})};const sw=(a,arr:any[],op:'=='|'>='|'>'|'<='|'<'='==')=>{for(let i=0;i<arr.length-1;i+=2){if(eval(a+op+arr[i])){return arr[i+1];}}return arr[arr.length-1]};const near=(n:number,arr:number[]):number=>{let ne=arr[0],ni=0;for(let i=1;i<arr.length;i++){if(Math.abs(n-ne)>Math.abs(n-arr[i])){ne=arr[i];ni=i}}return ni};const objvs =(a)=>{const b=[];for(const v in a){b.push(a[v])}return b};
const main=()=>{
  let n=tn()
  let s=ts().split('')
  let ans=0
  for(let i=1;i<n-1;i++){
    let t={}
    for(let j=0;j<i;j++){
      for(let k=i;k<n;k++){
        if(s[j]==s[k])t[s[j]]=true
      }
    }
    ans=max(Object.keys(t).length,ans)
  }
  to(ans)
}
main()


'use strict'

function main(input) {
  input = input.trim().split('\n')
  // .map(v => v.split(''))

  const n = Number(input[0])
  const str = input[1].split('')
  let max = 0
  for (let i = 1; i < n; i++) {
    const a = str.slice(0, i)
    const b = str.slice(i)
    const set = {}

    a.forEach(el => {
      set[el] = el
    })
    let tmp = 0
    Object.keys(set).forEach(el => {
      // console.log(el)
      if (b.find(v => v == el)) tmp++
    })
    max = Math.max(tmp, max)
  }
  console.log(max)
}
main(require('fs').readFileSync('/dev/stdin', 'utf8'))


import * as fs from 'fs';

const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n');

const N = +input[0];
const S = input[1];

const ans = {
  x: 0,
  y: 0,
  index: -1,
};
let maxCnt = 0;
for (let i = 0; i < N; i++) {
  const set = new Set();
  let cnt = 0;
  const x = S.substr(0, i);
  const y = S.substr(i);
  for (const c of x) {
    set.add(c);
  }
  for (const c of y) {
    if (set.has(c)) {
      set.delete(c);
      cnt += 1;
    }
  }
  maxCnt = Math.max(maxCnt, cnt);
}
console.log(maxCnt);


const stdin = require('fs').readFileSync('/dev/stdin', 'utf8').trim()

const [n, s] = stdin.split('\n')

const getCount = (sSet, lSet) => {
  const lArr = [...lSet]

  return lArr.filter(v => sSet.has(v)).length
}

const ans = _ => {
  const strArr = s.split('')

  let count = 0
  for (let i = 1; i < n; i++) {
    const firstHalf = strArr.slice(0, i)
    const lastHalf = strArr.slice(i)

    const fSet = new Set(firstHalf)
    const lSet = new Set(lastHalf)

    let tmpCount = 0
    if (fSet.size < lSet.size) {
      tmpCount = getCount(fSet, lSet)
    } else {
      tmpCount = getCount(lSet, fSet)
    }

    count = Math.max(tmpCount, count)
  }

  console.log(count)
}

ans()


import * as fs from 'fs';

const input = (fs.readFileSync('/dev/stdin', 'utf8') as string).split('\n');

const N = +input[0];
const S = input[1];

const ans = {
  x: 0,
  y: 0,
  index: -1,
};
let maxCnt = 0;
for (let i = 0; i < N; i++) {
  const set = new Set();
  let cnt = 0;
  const x = S.substr(0, i);
  const y = S.substr(i);
  for (const c of x) {
    set.add(c);
  }
  for (const c of y) {
    if (set.has(c)) {
      cnt += 1;
    }
  }
  maxCnt = Math.max(maxCnt, cnt);
}
console.log(maxCnt);


/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
/* eslint-env es6, mocha, node */
/* eslint-extends: eslint:recommended */
'use strict';

// Import modules
import fs = require("fs");

// Read stdin
const data = fs.readFileSync("/dev/stdin", "utf-8").split("\n").filter((v) => !!v);

// Main
let result = 0;
for (let i = 1; i < data[0].length; ++i) {
    const left = Array.from(new Set(data[0].substring(0, i))).reduce((collection: {[index: string]: number}, char: string) => {
        collection[char] = 1;

        return collection;
    }, {});
    const max = Array.from(new Set(data[0].substring(i))).reduce((collection: number, char: string) => {
        if (char in left) {
            collection = collection + 1;
        }

        return collection;
    }, 0);

    result = (result > max) ? result : max;
}

// Output
console.log(result);

/*
 * Local variables:
 * tab-width: 4
 * c-basic-offset: 4
 * c-hanging-comment-ender-p: nil
 * End:
 */


n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
print(sum(a[:k]))


n,k=list(map(int, input().split()))
p=list(map(int, input().strip().split()))
new_p=sorted(p)
ans = 0
for num in range(k):
  ans+=new_p[num]
print(ans)


input_list = list(map(int, input().split()))
n, k = input_list
input_list = list(map(int, input().split()))
p_list = sorted(input_list)

print(sum(p_list[:k]))


N,K = map(int,input().split())

p=list(map(int,input().split()))

p.sort()
print(p)

sum = 0

for i in range(K):
    print(i)
    sum += p[i]

print(sum)


N,K = map(int,input().split())
fruit = [int(i) for i in input().split()]

fruit.sort()
price = 0
for i in range(N) :
    if i>2 :
        break
    price += fruit[i]

print(price)


N,K = map(int,input().split())
fruit = [int(i) for i in input().split()]

fruit.sort()
price = 0
for i in range(N) :
    if i>3 :
        break
    price += fruit[i]

print(price)


import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.TreeSet;

public class Main {
  public static void main(String[] args) {
    InputReader sc = new InputReader(System.in);

    int n = sc.nextInt();
    int k = sc.nextInt();
    int[] prices = new int[n];
    for(int i = 0; i < n; i++){
      prices[i] = sc.nextInt();
    }
    Arrays.sort(prices);
    int ans = 0;
    for(int i = 0; i < k; i++){
      ans += prices[i];
    }

    System.out.println(ans);

  }

 //ここからテンプレ
  static class InputReader {
      private InputStream stream;
      private byte[] buf = new byte[1024];
      private int curChar;
      private int numChars;
      private SpaceCharFilter filter;

      public InputReader(InputStream stream) {
          this.stream = stream;
      }

      public int next() {
          if (numChars == -1)
              throw new InputMismatchException();
          if (curChar >= numChars) {
              curChar = 0;
              try {
                  numChars = stream.read(buf);
              } catch (IOException e) {
                  throw new InputMismatchException();
              }
              if (numChars <= 0)
                  return -1;
          }
          return buf[curChar++];
      }

      public String nextStr() {
        int c = next();
        while(isSpaceChar(c)){c = next();}
        StringBuffer str = new StringBuffer();
        do{
          str.append((char)c);
          c = next();
        }while(!isSpaceChar(c));
        return str.toString();
      }

      public char nextChar() {
        int c = next();
        while(isSpaceChar(c)){c = next();}
        char ret;
        do{
          ret = (char)c;
          c = next();
        }while(!isSpaceChar(c));
        return ret;
      }

      public int nextInt() {
          int c = next();
          while (isSpaceChar(c))
              c = next();
          int sgn = 1;
          if (c == '-') {
              sgn = -1;
              c = next();
          }
          int res = 0;
          do {
              if (c < '0' || c > '9')
                  throw new InputMismatchException();
              res *= 10;
              res += c - '0';
              c = next();
          } while (!isSpaceChar(c));
          return res * sgn;
      }

      public boolean isSpaceChar(int c) {
          if (filter != null)
              return filter.isSpaceChar(c);
          return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
      }

      public interface SpaceCharFilter {
          public boolean isSpaceChar(int ch);
      }
  }
}


import java.io.*;
import java.util.*;
import java.lang.*;

public class Main {
    public static MyScanner scan;
    public static PrintWriter out;
    public static void main(String[] args) {
        scan=new MyScanner();
        out=new PrintWriter(new BufferedOutputStream(System.out));

        int t=1;
//        int t=scan.nextInt();
        while(t-->0) {

            int n=scan.nextInt(),k=scan.nextInt();
            int[] a=nextIntArray(n);

            Arrays.sort(a);
            int sum=0;
            for(int c=0;c<k;c++) {
                sum+=a[c];
            }
            out.println(sum);
        }
        out.close();
    }

    //-----------------------------------------------------COMP-SPACE-----------------------------------------------------

    //--------------------------------------------------------------------------------------------------------------------

    //node
    static class Node implements Comparable<Node> {
        public int x,y;
        public Node(int x,int y) {
            this.x=x;
            this.y=y;
        }

        public int compareTo(Node other) {
            if(this.x==other.x) return 0;
            else if(this.x>other.x) return 1;
            else return -1;
        }

        public boolean equals(Node other) {
            return this.x==other.x;
        }

//        public int compareTo(Node other) {
//            if(this.y==other.y) return 0;
//            else if(this.y>other.y) return 1;
//            else return -1;
//        }
//
//        public boolean equals(Node other) {
//            return this.y==other.y;
//        }
    }
    //edge
    static class Edge implements Comparable<Edge> {
        public Node a,b;
        public int weight;

        public Edge(Node a,Node b,int weight) {
            this.a=a;
            this.b=b;
            this.weight=weight;
        }

        public int compareTo(Edge other) {
            if(this.weight==other.weight) return 0;
            else if(this.weight>other.weight) return 1;
            else return -1;
        }
    }

    //util
    public static int gcd(int a, int b) {
        if (b == 0)
            return a;
        if (a == 0)
            return b;
        return (a > b) ? gcd(a % b, b) : gcd(a, b % a);
    }

    public static int lcm(int a, int b) {
        return a * b / gcd(a, b);
    }

    public static int min(int a,int b) {
        if(a<=b) return a;
        else return b;
    }

    public static int max(int a,int b) {
        if(a>=b) return a;
        else return b;
    }

    public static int abs(int a) {
        if(a<0) return a*-1;
        else return a;
    }

    public static ArrayList<Integer> getPrimes(int n) {
        boolean prime[]=new boolean[n+1];
        Arrays.fill(prime,true);
        for (int p=2;p*p<=n;p++) {
            if (prime[p]) {
                for (int i=p*2;i<=n;i+=p) {
                    prime[i]=false;
                }
            }
        }
        ArrayList<Integer> primeNumbers=new ArrayList<Integer>();
        for (int i = 2; i <= n; i++) {
            if (prime[i]) {
                primeNumbers.add(i);
            }
        }
        return primeNumbers;
    }

    public static boolean isPrime(int a) {
        if (a == 0 || a == 1) {
            return false;
        }
        if (a == 2) {
            return true;
        }
        for (int i = 2; i < Math.sqrt(a) + 1; i++) {
            if (a % i == 0) {
                return false;
            }
        }
        return true;
    }

    public static ArrayList<Integer> getDivisors(int n) {
        ArrayList<Integer> div = new ArrayList<Integer>();
        for (int i=1;i*i<=n;i++) {
            if (n%i==0) {
                div.add(i);
                if (n/i!=i)
                    div.add(n/i);
            }
        }
        return div;
    }

    //scanner
    public static class MyScanner {
        BufferedReader br;
        StringTokenizer st;

        public MyScanner() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }

    public static int[] nextIntArray(int n) {
        int[] a=new int[n];
        for(int c=0;c<n;c++) a[c]=scan.nextInt();
        return a;
    }

    public static Integer[] nextIntegerArray(int n) {
        Integer[] a=new Integer[n];
        for(int c=0;c<n;c++) a[c]=scan.nextInt();
        return a;
    }

    public static int[][] nextIntMatrix(int n,int m) {
        int[][] a=new int[n][m];
        for(int i=0;i<n;i++) for(int j=0;j<m;j++) a[i][j]=scan.nextInt();
        return a;
    }

    public static Integer[][] nextIntegerMatrix(int n,int m) {
        Integer[][] a=new Integer[n][m];
        for(int i=0;i<n;i++) for(int j=0;j<m;j++) a[i][j]=scan.nextInt();
        return a;
    }

    //print
    public static void printIntArray(int[] a) {
        for(int c:a) out.print(c+" ");
        out.println();
    }

    public static void printIntegerArray(Integer[] a) {
        for(int c:a) out.print(c+" ");
        out.println();
    }

    public static void printIntMatrix(int[][] a) {
        for(int[] i:a) {
            for(int j:i) out.print(j+" ");
            out.println();
        }
    }

    public static void printIntegerMatrix(Integer[][] a) {
        for(Integer[] i:a) {
            for(Integer j:i) out.print(j+" ");
            out.println();
        }
    }

    public static void help(int t,int n) { out.println("Test Case: "+(t+1)+" | Variable Output: "+n); }
    public static void help(int t,String n) { out.println("Test Case: "+(t+1)+" | Variable Output: "+n); }
    public static void help(int t,char[] n) { out.print("Test Case: "+(t+1)+" | Variable Output: "); for(char c:n) out.print(c+" "); out.println(); }
}