{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./src/client/.fable/fable-library.3.1.4/Util.js","webpack:///./src/client/.fable/fable-library.3.1.4/Types.js","webpack:///./src/client/.fable/fable-library.3.1.4/Reflection.js","webpack:///./src/client/.fable/fable-library.3.1.4/Option.js","webpack:///./src/client/.fable/fable-library.3.1.4/Numeric.js","webpack:///./src/client/.fable/fable-library.3.1.4/lib/big.js","webpack:///./src/client/.fable/fable-library.3.1.4/Decimal.js","webpack:///./src/client/.fable/fable-library.3.1.4/Int32.js","webpack:///./src/client/.fable/fable-library.3.1.4/lib/long.js","webpack:///./src/client/.fable/fable-library.3.1.4/Long.js","webpack:///./src/client/.fable/fable-library.3.1.4/Seq.js","webpack:///./src/client/.fable/fable-library.3.1.4/MapUtil.js","webpack:///./src/client/.fable/fable-library.3.1.4/Date.js","webpack:///./src/client/.fable/fable-library.3.1.4/RegExp.js","webpack:///./src/client/.fable/fable-library.3.1.4/String.js","webpack:///./src/client/.fable/fable-library.3.1.4/MutableMap.js","webpack:///./src/client/.fable/fable-library.3.1.4/MutableSet.js","webpack:///./src/client/.fable/fable-library.3.1.4/Array.js","webpack:///./src/client/.fable/fable-library.3.1.4/List.js","webpack:///./src/client/.fable/fable-library.3.1.4/AsyncBuilder.js","webpack:///./src/client/.fable/fable-library.3.1.4/Choice.js","webpack:///./src/client/.fable/fable-library.3.1.4/Async.js","webpack:///./src/client/.fable/Fable.Elmish.3.1.0/prelude.fs.js","webpack:///./src/client/.fable/Fable.Elmish.3.1.0/cmd.fs.js","webpack:///./src/client/.fable/Fable.Elmish.3.1.0/ring.fs.js","webpack:///./src/client/.fable/Fable.Elmish.3.1.0/program.fs.js","webpack:///./src/client/.fable/Fable.Elmish.React.3.0.1/common.fs.js","webpack:///./src/client/.fable/Fable.Elmish.React.3.0.1/react.fs.js","webpack:///./src/client/Global.fs.js","webpack:///./src/client/.fable/Fable.Elmish.Browser.3.0.4/navigation.fs.js","webpack:///./src/client/.fable/fable-library.3.1.4/FSharp.Collections.js","webpack:///./src/client/.fable/fable-library.3.1.4/System.Text.js","webpack:///./src/client/.fable/fable-library.3.1.4/FSharp.Core.js","webpack:///./src/client/.fable/fable-library.3.1.4/Map.js","webpack:///./src/client/.fable/Fable.Elmish.Browser.3.0.4/prelude.fs.js","webpack:///./src/client/.fable/Fable.Elmish.Browser.3.0.4/parser.fs.js","webpack:///./src/client/Domain.fs.js","webpack:///./src/Shared/Api.fs.js","webpack:///./src/client/.fable/Fable.Promise.3.1.3/Promise.fs.js","webpack:///./src/client/.fable/Fable.Fetch.2.4.0/Fetch.fs.js","webpack:///./src/client/.fable/fable-library.3.1.4/BigInt/n.js","webpack:///./src/client/.fable/fable-library.3.1.4/BigInt/z.js","webpack:///./src/client/.fable/fable-library.3.1.4/BigInt.js","webpack:///./src/client/.fable/fable-library.3.1.4/TimeSpan.js","webpack:///./src/client/.fable/Thoth.Json.4.1.0/Types.fs.js","webpack:///./src/client/.fable/Thoth.Json.4.1.0/Encode.fs.js","webpack:///./src/client/.fable/fable-library.3.1.4/Guid.js","webpack:///./src/client/.fable/fable-library.3.1.4/DateOffset.js","webpack:///./src/client/.fable/fable-library.3.1.4/Set.js","webpack:///./src/client/.fable/Thoth.Json.4.1.0/Decode.fs.js","webpack:///./src/client/.fable/Thoth.Fetch.2.0.0/Fetch.fs.js","webpack:///./src/client/.fable/Dnn.Fable.Fetch.2.0.0/fetch.fs.js","webpack:///./src/client/TagungsProgramm/Api.fs.js","webpack:///./src/client/TagungsProgramm/Types.fs.js","webpack:///./src/client/TagungsProgramm/Repository.fs.js","webpack:///./src/client/TagungsProgramm/State.fs.js","webpack:///./src/client/.fable/Fable.React.8.0.1/Fable.React.Props.fs.js","webpack:///./src/client/.fable/Fable.React.8.0.1/Fable.React.Helpers.fs.js","webpack:///./src/client/TagungsProgramm/Lokalisierung.fs.js","webpack:///./src/client/TagungsProgramm/View.fs.js","webpack:///./src/client/TagungsProgramm/Date.js","webpack:///./src/client/App.fs.js"],"names":["webpackJsonpCallback","data","moduleId","chunkId","chunkIds","moreModules","executeModules","i","resolves","length","Object","prototype","hasOwnProperty","call","installedChunks","push","modules","parentJsonpFunction","shift","deferredModules","apply","checkDeferredModules","result","deferredModule","fulfilled","j","depId","splice","__webpack_require__","s","installedModules","0","exports","module","l","m","c","d","name","getter","o","defineProperty","enumerable","get","r","Symbol","toStringTag","value","t","mode","__esModule","ns","create","key","bind","n","object","property","p","jsonpArray","window","oldJsonpFunction","slice","isArrayLike","x","Array","isArray","ArrayBuffer","isView","isHashable","GetHashCode","sameConstructor","y","getPrototypeOf","constructor","Lazy","factory","this","isValueCreated","createdValue","padWithZeros","str","toString","dateOffset","date","date1","offset","kind","getTimezoneOffset","int32ToString","radix","ObjectRef","idMap","has","set","count","stringHash","h","len","charCodeAt","numberHash","combineHashCodes","hashes","reduce","h1","h2","dateHash","getTime","arrayHash","structuralHash","Date","values","map","v","id","equalArraysWith","eq","equalArrays","equals","Equals","isEquatable","compareDates","xKeys","keys","yKeys","sort","equalObjects","xtime","ytime","comparePrimitives","compareArrays","comp","compareArraysWith","compare","CompareTo","isComparable","compareObjects","max","comparer","WeakMap","CURRIED_KEY","uncurry","arity","f","uncurriedFn","a1","a2","a3","a4","a5","a6","a7","a8","Error","curry","checkArity","args1","args2","undefined","concat","partialApply","args","mapCurriedArgs","fn","mappings","arg","mapArg","idx","mapping","expectedArity","actualArity","res","seqToString","self","callStack","iterator","cons","entries","join","String","compareList","other","tail","head","List","cur","next","done","from","Union","fields","withParens","field","indexOf","tag","cases","recordToJSON","recordToString","recordGetHashCode","recordEquals","thisNames","recordCompareTo","Record","FSharpRef","contentsOrGetter","setter","CaseInfo","declaringType","TypeInfo","fullname","generics","construct","parent","enumCases","fullName","getHashCode","getGenerics","fullnameHash","genHashes","t1","t2","getRecordElements","k1","v1","k2","v2","class_type","record_type","union_type","caseNames","tuple_type","option_type","generic","list_type","obj_type","unit_type","string_type","bool_type","int32_type","info","lastIndexOf","substr","gen","endsWith","getElementType","_a","isGenericType","isEnum","getGenericTypeDefinition","getEnumUnderlyingType","getEnumValues","kv","getEnumCase","parseEnum","parseInt","isNaN","getUnionCases","getTupleElements","isTuple","isUnion","isRecord","startsWith","getUnionCaseFields","uci","makeUnion","expectedLength","Some","some","defaultArg","opt","defaultValue","symbol","isNumeric","multiply","toFixed","dp","toPrecision","sd","toExponential","toHex","Number","P","_this","mul","e","cmp","DP","RM","MAX_DP","NE","PE","NAME","INVALID","INVALID_DP","INVALID_RM","UNDEFINED","NUMERIC","parse","nl","test","charAt","replace","search","substring","round","Big","rm","more","xc","isZero","findIndex","xci","unshift","pop","stringify","k","z","abs","isneg","yc","Math","div","a","b","bl","bt","ri","bz","ai","al","rl","q","qc","qi","gt","gte","lt","lte","minus","sub","xlty","plus","xe","ye","reverse","mod","ygtx","times","add","pow","one","sqrt","half","valueOf","toJSON","_Big_","normalize","version","Decimal","NumberStyles","getRange","unsigned","bitsize","isValid","style","exec","prefix","digits","getInvalidDigits","AllowHexSpecifier","getRadix","regexMatch","sign","validResponse","tryParse","defValue","contents","umin","umax","min","op_UnaryNegation_Int32","wasm","WebAssembly","Instance","Module","Uint8Array","Long","low","high","isLong","obj","fromBytes","toBytes","__isLong__","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromBits","fromNumber","UZERO","ZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","negate","TWO_PWR_32_DBL","lowBits","highBits","pow_dbl","fromString","RangeError","radixToPower","size","fromValue","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","toInt","$this","toNumber","isNegative","radixLong","divide","rem1","subtract","rem","remDiv","isOdd","lessThan","greaterThan","greaterThanOrEqual","thisNeg","otherNeg","not","addend","a48","a32","a16","a00","b48","b32","b16","c48","c32","c16","c00","subtrahend","multiplier","get_high","b00","divisor","approx","div_u","div_s","toUnsigned","shiftRightUnsigned","shiftLeft","shiftRight","floor","log2","ceil","log","LN2","delta","approxRes","approxRem","numBits","le","hi","lo","toBytesLE","toBytesBE","bytes","fromBytesLE","fromBytesBE","LongLib","op_Addition","op_Multiply","op_Division","op_Modulus","rem_u","rem_s","op_UnaryNegation","op_BitwiseAnd","fromInteger","xh","_bitsize","maxValue","getMaxValue","toUpperCase","padStart","Enumerator","iter","current","getEnumerator","GetEnumerator","toIterator","en","hasNext","Seq","makeSeq","isArrayOrBufferView","xs","append","ys","delay","firstDone","iters","unfold","_b","output","innerIter","hasFinished","collect","choose","empty","singleton","exists","contains","fold","acc","iterate","_","iterateIndexed","mapIndexed","rangeNumber","first","step","last","skip","sumBy","adder","Add","GetZero","take","truncate","tryPick","fst","CaseRules","None","LowerFirst","SnakeCase","SnakeCaseAllCaps","KebabCase","dashify","separator","toLowerCase","keyValueList","caseRule","definedCaseRule","fail","kvPair","assign","changeCase","tryGetValue","addToSet","addToDict","dict","getItemFromDict","offsetRegex","dateOffsetToString","isMinus","minutes","dateToHalfUTCString","toISOString","dateToStringWithCustomFormat","format","utc","match","rep","NaN","getUTCFullYear","getFullYear","getUTCMonth","getMonth","getUTCDate","getDate","getUTCHours","getHours","getUTCMinutes","getMinutes","getUTCSeconds","getSeconds","getUTCMilliseconds","getMilliseconds","dateToStringWithOffset","_c","dateWithOffset","dateToStringWithKind","toUTCString","toLocaleString","toLocaleDateString","toLocaleTimeString","printOffset","dateToISOString","_provider","DateTime","parseRaw","input","trim","baseDate","timeInSeconds","timeParts","split","parseFloat","offsetParts","offsetInMinutes","detectUTC","_err","year","month","day","ms","dateValue","UTC","setFullYear","daysInMonth","isLeapYear","dayOfWeek","getUTCDay","getDay","dayOfYear","_year","_month","_day","ts","newDate","oldTzOffset","newTzOffset","pattern","options","flags","RegExp","escape","matches","reg","lastIndex","global","fsFormatRegExp","formatRegExp","isLessThan","numericCompare","printf","cont","createPrinter","padRef","strCopy","formatOnce","continuePrint","toText","toFail","formatReplacement","padLength","precision","dateToString","zeroFlag","minusFlag","ch","padLeft","str2","intPart","decimalPart","isNullOrEmpty","isNullOrWhiteSpace","delimiter","isRight","startIndex","Dictionary","pairs","this$","hashMap","Map","enumerator","pair","Dictionary__Add_5BDDA1","Dispose","item","Dictionary__Clear","matchValue","Dictionary__TryFind_2B595","array","arrayIndex","Dictionary__get_Count","Dictionary__Remove_2B595","Dictionary__get_Item_2B595","Dictionary__TryFindIndex_2B595","Dictionary__ContainsKey_2B595","Dictionary__set_Item_5BDDA1","thisArg","outArg","clear","msg","HashSet","items","HashSet__Add_2B595","HashSet__Clear","HashSet__Contains_2B595","HashSet__get_Count","HashSet__Remove_2B595","HashSet__TryFindIndex_2B595","v_1","Helpers_allocateArrayFromCons","differentLengths","fill","target","targetIndex","start","source","initialize","initializer","folder","state","delegateArg0","delegateArg1","foldBack2","array1","array2","foldBackIndexed2","_arg1","tryHead","_arg1_mut","foldIndexed","f_mut","i_mut","acc_mut","foldIndexedAux","state_mut","xs_mut","List_1","ofSeq","fold_1","collect_1","unitVar0","ofArrayWithTail","tail_1","col","ofArray","tryPickIndexed","tryPickIndexedAux","tryFind","filter","sortBy","projection","xs_1","Compare","distinct","hashSet","distinctBy","groupBy","key_1","CancellationToken","cancelled","_id","_cancelled","_listeners","listener","$","addListener","removeListener","OperationCanceledError","setPrototypeOf","protectedCont","ctx","cancelToken","isCancelled","onCancel","trampoline","incrementAndCheck","hijack","err","onError","protectedBind","computation","binder","onSuccess","ex","protectedReturn","computation1","computation2","Bind","generator","sequence","body","While","Delay","compensation","catchHandler","ex2","resource","TryFinally","guard","Return","FSharpResult$2","Result_Map","Log_onError","text","console","error","Cmd_exec","dispatch","cmd","Cmd_none","Cmd_map","g","arg_1","Cmd_batch","cmds","lists","Cmd_OfFunc_result","Cmd_OfPromise_either","task","ofSuccess","ofError","then","arg_3","RingState$1","RingBuffer$1","RingBuffer$1__Push_2B595","__","wix_1","rix","items_1","wix$0027","ix","RingBuffer$1__doubleSize","wix","Program$4","init","update","subscribe","view","setState","syncDispatch","ProgramModule_withSetState","program","ProgramModule_view","ProgramModule_runWith","patternInput","model","rb","reentered","nextMsg","msg_1","value_1","patternInput_1","model$0027","ex_1","rix$0027","RingBuffer$1__Pop","ex_3","ex_2","LazyProps$1","render","equal","Components_LazyView$1","props","nextProps","_nextState","Component","Common_lazyView2With","react","Program_Internal_withReactBatchedUsing","lazyView2With","placeholderId","lastRequest","cancelAnimationFrame","requestAnimationFrame","react$002Ddom","document","getElementById","FableModule","Platzhalter","ModuleName","ServiceName","fableModule","Navigable$1","Navigation_modifyUrl","newUrl","history","replaceState","ProgramModule_Internal_onChangeRef","ProgramModule_Internal_toNavigableWith","parser","urlUpdate","onLocationChange","tupledArg","arg0","mapInit","mapUpdate","mapView","mapSetState","mapSubscribe","ProgramModule_map","userInit","unitVar1","location","userUpdate","model_1","userView","model_4","dispatch_1","userSetState","model_3","userSubscribe","model_2","arg0_1","ComparisonIdentity_Structural","e1","e2","x_1","LanguagePrimitives_FastGenericComparer","MapTreeLeaf$2","MapTreeLeaf$2_$ctor_5BDDA1","MapTreeLeaf$2__get_Key","MapTreeLeaf$2__get_Value","MapTreeNode$2","left","right","MapTreeNode$2_$ctor_499A11FD","MapTreeNode$2__get_Left","MapTreeNode$2__get_Right","MapTreeNode$2__get_Height","MapTreeModule_size","MapTreeModule_sizeAux","m_mut","m2","MapTreeModule_mk","hl","hr","m_2","MapTreeModule_rebalance","m2_2","m_3","m2_3","t1h","t2h","value_2","matchValue_1","matchValue_2","matchValue_3","MapTreeModule_add","MapTreeModule_empty","MapTreeModule_tryFind","comparer_mut","k_mut","MapTreeModule_iter","MapTreeModule_iterOpt","MapTreeModule_mapi","MapTreeModule_mapiOpt","l2","r2","MapTreeModule_toList","loop","m_1_mut","MapTreeModule_ofArray","arr","forLoopVar","MapTreeModule_ofSeq","MapTreeModule_ofList","ie","e_mut","MapTreeModule_mkFromEnumerator","MapTreeModule_MapIterator$2","stack","started","MapTreeModule_collapseLHS","stack_mut","rest","MapTreeModule_mkIterator","MapTreeModule_current","MapTreeModule_alreadyFinished","MapTreeModule_notStarted","MapTreeModule_mkIEnumerator","MapTreeModule_moveNext","FSharpMap","tree","combineHash","activePatternResult4293","FSharpMap__ComputeHashCode","that","m1","e1c","e2c","map_2","cur1","cur2","iter1","iter2","compareWith","kvp1","kvp2","FSharpMap__ContainsKey","FSharpMap__get_Item","MapTreeModule_copyToArray","FSharpMap__get_Count","iterate_1","FSharpMap_$ctor","FSharpMap_Create","MapTreeModule_find","MapTreeModule_mem","FSharpMap__TryFind","table","FSharpMap__Add","elements","toList","ofFunc","State$1","visited","unvisited","StateModule_mkState","custom","tipe","stringToSomething","str_1","subValue","parse_1","map_1","arg10$0040","StateModule_map","url","states_mut","parseHelp","states","pattern_matching_result","segments","segments_1","splitUrl","toKeyValuePair","segment","length1","length2","a_1","b_1","tuple","decodeURIComponent","parseParams","querystring","empty_1","Autor$0027","Name","Nachname","Vorname","Vortragender","FirmenIndex","Firma$0027","Land","Sitzungsleiter$0027","AnzeigeName","Raum$0027","Id","Raum","Raum$0027$reflection","Beitrag$0027","Uhrzeit","Zeiten","SessionNr","Dauer","Vortragsnummer","Kurzfassung","Titel","Autoren","Firmen","Abgesagt","Beitrag$0027$reflection","Session$0027","Bezeichnung","Beschreibung","K$00FCrzel","Vortragsk$00FCrzel","Startzeit","Startzeiten","Sitzungsleiter","AndererRaum","Session$0027$reflection","Programm$0027","Programm$0027$reflection","Termin","SessionId","Start","End","Description","Location","Url","WriteProtected","Termin$reflection","Rahmenprogramm$0027","Zeit","Startdatum","Enddatum","Rahmenprogramm$0027$reflection","Programmpunkt$0027","Achse$0027","Datum","Pause","Programmpunkte","Tag$0027","Wochentag","R$00E4ume","Achsen","Tag$0027$reflection","ManuskriptArt","Manuskript","Pnr","Art","Manuskript$reflection","ZeitenInOrtszeit","Command","Command$reflection","Query","Query$reflection","Result","Result$reflection","PromiseBuilder","PromiseBuilder__Delay_62FBFDE1","er","Promise","reject","resolve","er_1","catch","onError_1","er_2","er_3","PromiseBuilder__Run_212F1D4B","Types_HttpRequestHeaders","Types_RequestProperties","BigNat","bound","BigNatModule_FFT_pow32","x_mut","n_mut","BigNatModule_FFT_maxTwoPower","Int32Array","BigNatModule_bound","BigNatModule_coeff","BigNatModule_coeff64","BigNatModule_setCoeff","BigNatModule_pow64","BigNatModule_pow32","BigNatModule_baseBits","BigNatModule_baseN","BigNatModule_baseNi64","BigNatModule_baseMaski64","BigNatModule_createN","BigNatModule_normN","na_mut","na","findLeastBound","BigNatModule_boundInt","BigNatModule_boundInt64","BigNatModule_embed","r_1","BigNatModule_eval32","BigNatModule_one","BigNatModule_zero","BigNatModule_degree","BigNatModule_isZero","BigNatModule_equal","pa_mut","qa_mut","pa","qa","check","BigNatModule_compare","BigNatModule_lt","BigNatModule_mulSchoolBookCarry","r_mut","c_mut","rak","BigNatModule_mulSchoolBookOneSmall","bp","q_1","BigNatModule_mulSchoolBook","pSmall","qSmall","BigNatModule_mulSchoolBookBothSmall","ra","pai","qaj","BigNatModule_mulSchoolBookNeitherSmall","BigNatModule_encoding","bigL","twoToBigL","bigK","bigN","splits","BigNatModule_mkEncoding","BigNatModule_table","BigNatModule_mul","BigNatModule_scaleSubInPlace","ad","f_1","zLo","zHi","BigNatModule_scaleAddInPlace","BigNatModule_removeFactor","degx","dega","pn","qn","xa","aa","qai","BigNatModule_divmod","BigNatModule_copyN","finished","BigNatModule_ofInt32","BigNatModule_ofInt64","BigNatModule_embed64","BigNatModule_toString","degn","digits_4","isLeading_mut","digits_mut","n_1_mut","isLeading","n_1","n_2","prior_1","nL","nH","prior_mut","ten2k_mut","prior","ten2k","route","BigNatModule_isSmall","BigNatModule_getSmall","BigInteger","signInt","BigInteger__get_SignInt","BigInteger__get_V","BigInteger_op_Equality_56F059C0","BigNatModule_hash","nn","BigInteger_op_LessThan_56F059C0","BigInteger_$ctor_Z2BE94A1","BigInteger_nat_Z67CCE57D","smallLim","smallPosTab","BigInteger_$ctor_Z524259A4","BigInteger_get_One","BigInteger_get_Two","two","BigInteger_get_Zero","zero","signedRound","ticks","arguments","days","hours","seconds","milliseconds","lengthLeft","lengthRight","padLeftAndRightWithZeros","firstDot","firstColon","ErrorReason","CaseStrategy","Util_Cache$1","Util_Cache$1_$ctor","Util_Cache$1__GetOrAdd_43981464","Util_CachedEncoders","Util_CachedDecoders","Util_Casing_lowerFirst","Util_Casing_convert","caseStrategy","fieldName","replacement","limit","tmp","withGroups","pLast","index","groups","_s","sub1","_matches","sub2","nil","seq","sbyte","byte","int16","uint16","unit","space","JSON","option","encoder","defThunk","autoEncodeRecordsAndUnions","extra","skipNullField","encoderRef","extra_1","setters","fi","targetKey","encode_1","autoEncoder","getRecordField","source_1","target_1","set$","message","arg10","case_","getUnionFields","fieldTypes","target_2","encode_2","enumType","value_3","value_4","value_5","value_7","clo2","arg20","encoders","t_2","value_9","fullname_1","encoder_2","value_10","Value","encoder_3","value_11","keyType","valueEncoder","value_12","activePatternResult3410","keyEncoder","clo4","arg40","value_13","_arg2","activePatternResult3414","value_14","value_16","value_18","value_19","value_20","value_21","value_22","value_24","value_26","value_28","value_30","toString_3","datetime","value_31","datetimeOffset","value_32","toString_4","timespan","value_33","makeExtra","map_3","Coders","Auto_toString_5A41365E","resolver","caseStrategy_1","skipNullField_1","value_34","ResolveType","Auto_generateEncoder_Z127D9D79","guidRegex","guidRegexNoHyphen","guidRegexHex","hyphenateGuid","wsTrimAndLowered","chars","DateTimeOffset","offsetMatch","SetTreeLeaf$1","SetTreeLeaf$1_$ctor_2B595","SetTreeLeaf$1__get_Key","SetTreeNode$1","SetTreeNode$1_$ctor_Z6E7BE5F7","SetTreeNode$1__get_Left","SetTreeNode$1__get_Right","SetTreeNode$1__get_Height","SetTreeModule_count","SetTreeModule_countAux","t_mut","SetTreeModule_mk","SetTreeModule_rebalance","t2_3","t_3","t2_4","SetTreeModule_add","c_1","SetTreeModule_empty","SetTreeModule_mem","SetTreeModule_iter","SetTreeModule_SetIterator$1","SetTreeModule_collapseLHS","x2","SetTreeModule_mkIterator","SetTreeModule_current","SetTreeModule_alreadyFinished","SetTreeModule_notStarted","SetTreeModule_mkIEnumerator","SetTreeModule_moveNext","SetTreeModule_compare","l1_mut","l2_mut","SetTreeModule_compareStacks","l1","x1_3","x2_3","t1_6","x1_4","t2_6","x2_4","matchValue_4","pattern_matching_result_1","t1_7","x1_5","t2_7","x2_5","c_3","c_2","matchValue_5","pattern_matching_result_2","t1_8","x1_6","t2_8","x2_6","pattern_matching_result_3","t1_2","x1","t2_2","x2_1","pattern_matching_result_4","t1_4","x1_2","x2_2","SetTreeModule_copyToArray","SetTreeModule_ofSeq","SetTreeModule_mkFromEnumerator","FSharpSet","FSharpSet__ComputeHashCode","FSharpSet__get_Comparer","FSharpSet__get_Tree","FSharpSet__get_Count","FSharpSet__Contains","FSharpSet_$ctor","genericMsg","newLine","errorToString","path","reason_1","decoder","SyntaxError","path_1","isFinite","tryParse_3","name_1","int","uint32","tryParse_6","tryParse_7","requestedIndex","copyOfStruct","currentPath","vArray","list","list_1","tokens","acc_1","succeed","andThen","cb","ctor","d1","tuple2","decoder1","decoder2","decoder_3","path_3","decoder_2","decoder_1","path_2","arg20$0040","mixedArray","decoders","arg30","predicate","name_3","find","uci_1","makeUnion_1","values_1","autoDecoder","autoDecodeRecordsAndUnions","isOptional","decoderRef","makeRecord","decoderInfos","reduceRight","autoObject","decoder_15","tryFind_1","enumValue","path_4","path_5","value_8","enumValue_1","path_6","t_4","path_7","enumValue_2","path_8","t_5","path_9","enumValue_3","path_10","t_6","path_11","value_17","enumValue_4","path_12","t_7","path_13","matchValue_6","enumValue_5","clo3","t_8","path_14","decoder_13","path_15","decoder_14","path_16","value_23","keyDecoder","valueDecoder","decoders_1","path_17","fold_2","autoObject2","path_18","value_25","path_19","decoders_1_mut","errors_mut","errors","append_1","runner","oneOf","path_20","ar","ofSeq_1","decoder_16","path_21","value_29","matchValue_7","ofSeq_2","path_22","path_23","path_24","path_25","path_26","value_35","path_27","value_36","path_28","value_37","path_29","value_38","tryParse_8","path_30","value_39","tryParse_2","guid","_arg1_6","Auto_generateDecoder_7848D058","value_40","FetchError","Helper_withContentTypeJson","headers","Helper_encode","dataResolver","y_1","toString_5","Hash","Auto_generateEncoderCached_Z127D9D79","Helper_resolve","response","responseResolver","eitherUnitOr","toString_12","map_4","Auto_generateDecoderCached_7848D058","responseResolver_1","Helper_eitherUnit","promise","ok","Fetch_tryFetchAs_25B10BBE","httpMethod","properties","headers_2","properties_3","list2","Helper_withProperties","data_1","Helper_withBody","fetch","Helper_fetch","exn","Fetch_fetchAs_25B10BBE","response_1","status","statusText","Helper_message","ServicesFramework_moduleHeaders","sf","getModuleId","getTabId","getAntiForgeryValue","ServicesFramework_setup$0027","isGet","moduleName","ServicesFramework","serviceroot","getServiceRoot","props_1","Headers","Props","ServicesFramework_setup","Fetch_post_3817AB3A","Fetch_post_5760677E","Msg","dataset","query","query_1","query$0027","handle","command","handle$0027","Tab","Route","Subscription","Model","IstAngemeldet","AnmeldungAnfordern","EigenesProgramm","ProfileUrl","Tage","Ausgew$00E4hlt","Sprache","Beitr$00E4ge","Manuskripte","Session","Programm","Beitrag","Poster","TabSessions","Rahmenprogramm","Termine","Thema","RahmenprogrammPunkt","Model__IstSubscribed_2297AD2E","nummer","nummer_3","nummer_1","t_1","storage","localStorage","Termine_get","json","Auto_unsafeFromString_Z5CB6BD","getItem","parseBefore","parseBefore_2","parseBefore_4","parsers","Route_4","top","s_2","state_2","state_1","state_5","state_4","arg0_2","state_8","state_7","arg0_3","state_10","state_11","beitragCmd","pnr","pnr_1","b_2","tupledArg_1","sessionCmd","kuerzel","kuerzel_1","r$00E4ume","sessions","x_4","x_3","session","s_1","_arg1_1","tryPick_1","kvp","rahmenCmd","bezeichnung","bezeichnung_1","bez","route_1","toConsole","tohash","beitrag","clo1_1","clo1_2","arg10_1","arg10_2","alsTermin","raum","raum_1","session_1","dauer","raum_2","sessionId","titel","zeit","list_2","href","userId","tageMitprogramm","achse","tagMitprogramm","_arg3","containsKey","msg_2","model_5","_arg5","cmd_2","pnr_2","model_6","_arg6","cmd_3","model_8","_arg7","cmd_4","setItem","tage_1","_arg4","cmd_1","model_9","model_10","model_11","model_12","model_13","model_14","model_15","model_16","model_17","DangerousHtml","__html","DOMAttr","HTMLAttr","Helpers_nothing","Resourcen","Schliessen","BeginntUm","Sitzungsleitung","SitzungsleitungPlural","Posterbereich","Verschiedenes","WeitereInformationen","Ort","UhrZeitKurz","Locale","Und","TagKurz","AngabenInOrtszeit","EigenesProgrammHilfe","EigenesProgrammAbrufen","EigenedProgrammSync","EigenedProgrammSync2","Login","LoginPlease1","LoginPlease2","Subscribe","Unsubscribe","Deutsch","Englisch","toShortTimeString","locale","currentTimeZone","Intl","DateTimeFormat","resolvedOptions","timeZone","zeitAusgeben","zeiten","inOrtsZeit","local","daydiff","zeitAusgeben$0027","Dialog_toggleSubscription","subscribed","type","className","onClick","Dialog_render$0027","abbrechen","header","footer","content","tabIndex","role","display","paddingRight","Dialog_renderWithSubscription","eigenesProgramm","Dialog_toggleSubscriptionStars","Dialog_render","Beitrag_autoren","letzterAutor","autor","Beitrag_firmen","firma","Beitrag_render","manuskripte","inOrtszeit","istSubscribed","Beitrag_head","marginTop","fontSize","fontFamily","whiteSpace","margin","Beitrag_content","Session_renderBeitrag","testIfSubscribed","preventDefault","subscriptionStars","Session_render","beitr$00E4ge","letzterLeiter","leiter","Session_renderHead","dangerouslySetInnerHTML","Programm_render","programm","Programm_renderHead","TagesProgramm_render","pause","pause_1","TagesProgramm_renderPause","padding","TagesProgramm_renderSession","punkt_1","hatBeschreibung","TagesProgramm_renderProgramm","TagMitR$00E4umen_renderPunkt","punkt","height","TagMitR$00E4umen_renderSession","k_1","TagMitR$00E4umen_renderProgramm","Thema_renderBeitrag","Thema_render","thema","poster","Thema_renderHead","Posters_renderThema","Posters_render","RahmenprogrammPunkt_render","RahmenprogrammPunkt_head","singleton_1","RahmenprogrammPunkt_content","EigenesProgramm_render","termine","istAngemeldet","props_12","marginBottom","dow","datum_1","paddingTop","arg20_1","arg20_2","protocol","Rahmenprogramm_tagCaption","datum","wochentag","Rahmenprogramm_render","rahmenprogramm","props_3","x_2","Rahmenprogramm_renderPunkt","d2","renderProgramm","tabs_3","tabs_2","tabs_1","tabs","s_5","tag_14","mehrereTage","hatRahmenprogramm","hatPoster","tabs_4","tag_1","event","stopPropagation","d_1","event_1","event_2","event_3","event_4","ref","equalHeight","arg00","TagMitR$00E4umen_render","arg00_1","modalOffen","tupledArg_2","p_1","AnmeldungAnfordern_render","ProgramModule_run","Program_withReactBatched","hash","parseHash","arg0_4","arg0_5","lastLocation","addEventListener","ProgramModule_Internal_subscribe"],"mappings":"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","file":"app.c38b46bebb60469a27c9.js","sourcesContent":[" \t// install a JSONP callback for chunk loading\n \tfunction webpackJsonpCallback(data) {\n \t\tvar chunkIds = data[0];\n \t\tvar moreModules = data[1];\n \t\tvar executeModules = data[2];\n\n \t\t// add \"moreModules\" to the modules object,\n \t\t// then flag all \"chunkIds\" as loaded and fire callback\n \t\tvar moduleId, chunkId, i = 0, resolves = [];\n \t\tfor(;i < chunkIds.length; i++) {\n \t\t\tchunkId = chunkIds[i];\n \t\t\tif(Object.prototype.hasOwnProperty.call(installedChunks, chunkId) && installedChunks[chunkId]) {\n \t\t\t\tresolves.push(installedChunks[chunkId][0]);\n \t\t\t}\n \t\t\tinstalledChunks[chunkId] = 0;\n \t\t}\n \t\tfor(moduleId in moreModules) {\n \t\t\tif(Object.prototype.hasOwnProperty.call(moreModules, moduleId)) {\n \t\t\t\tmodules[moduleId] = moreModules[moduleId];\n \t\t\t}\n \t\t}\n \t\tif(parentJsonpFunction) parentJsonpFunction(data);\n\n \t\twhile(resolves.length) {\n \t\t\tresolves.shift()();\n \t\t}\n\n \t\t// add entry modules from loaded chunk to deferred list\n \t\tdeferredModules.push.apply(deferredModules, executeModules || []);\n\n \t\t// run deferred modules when all chunks ready\n \t\treturn checkDeferredModules();\n \t};\n \tfunction checkDeferredModules() {\n \t\tvar result;\n \t\tfor(var i = 0; i < deferredModules.length; i++) {\n \t\t\tvar deferredModule = deferredModules[i];\n \t\t\tvar fulfilled = true;\n \t\t\tfor(var j = 1; j < deferredModule.length; j++) {\n \t\t\t\tvar depId = deferredModule[j];\n \t\t\t\tif(installedChunks[depId] !== 0) fulfilled = false;\n \t\t\t}\n \t\t\tif(fulfilled) {\n \t\t\t\tdeferredModules.splice(i--, 1);\n \t\t\t\tresult = __webpack_require__(__webpack_require__.s = deferredModule[0]);\n \t\t\t}\n \t\t}\n\n \t\treturn result;\n \t}\n\n \t// The module cache\n \tvar installedModules = {};\n\n \t// object to store loaded and loading chunks\n \t// undefined = chunk not loaded, null = chunk preloaded/prefetched\n \t// Promise = chunk loading, 0 = chunk loaded\n \tvar installedChunks = {\n \t\t0: 0\n \t};\n\n \tvar deferredModules = [];\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"~/desktopModules/tagungPapers/tagungsprogramm\";\n\n \tvar jsonpArray = window[\"webpackJsonp\"] = window[\"webpackJsonp\"] || [];\n \tvar oldJsonpFunction = jsonpArray.push.bind(jsonpArray);\n \tjsonpArray.push = webpackJsonpCallback;\n \tjsonpArray = jsonpArray.slice();\n \tfor(var i = 0; i < jsonpArray.length; i++) webpackJsonpCallback(jsonpArray[i]);\n \tvar parentJsonpFunction = oldJsonpFunction;\n\n\n \t// add entry module to deferred list\n \tdeferredModules.push([198,1]);\n \t// run deferred modules when ready\n \treturn checkDeferredModules();\n","// tslint:disable:ban-types\nexport function isIterable(x) {\n    return x != null && typeof x === \"object\" && Symbol.iterator in x;\n}\nexport function isArrayLike(x) {\n    return Array.isArray(x) || ArrayBuffer.isView(x);\n}\nfunction isComparer(x) {\n    return typeof x.Compare === \"function\";\n}\nfunction isComparable(x) {\n    return typeof x.CompareTo === \"function\";\n}\nfunction isEquatable(x) {\n    return typeof x.Equals === \"function\";\n}\nfunction isHashable(x) {\n    return typeof x.GetHashCode === \"function\";\n}\nexport function isDisposable(x) {\n    return x != null && typeof x.Dispose === \"function\";\n}\nexport function sameConstructor(x, y) {\n    return Object.getPrototypeOf(x).constructor === Object.getPrototypeOf(y).constructor;\n}\nexport class Comparer {\n    constructor(f) {\n        this.Compare = f || compare;\n    }\n}\nexport function comparerFromEqualityComparer(comparer) {\n    // Sometimes IEqualityComparer also implements IComparer\n    if (isComparer(comparer)) {\n        return new Comparer(comparer.Compare);\n    }\n    else {\n        return new Comparer((x, y) => {\n            const xhash = comparer.GetHashCode(x);\n            const yhash = comparer.GetHashCode(y);\n            if (xhash === yhash) {\n                return comparer.Equals(x, y) ? 0 : -1;\n            }\n            else {\n                return xhash < yhash ? -1 : 1;\n            }\n        });\n    }\n}\nexport function assertEqual(actual, expected, msg) {\n    if (!equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport function assertNotEqual(actual, expected, msg) {\n    if (equals(actual, expected)) {\n        throw Object.assign(new Error(msg || `Expected: ${expected} - Actual: ${actual}`), {\n            actual,\n            expected,\n        });\n    }\n}\nexport class Lazy {\n    constructor(factory) {\n        this.factory = factory;\n        this.isValueCreated = false;\n    }\n    get Value() {\n        if (!this.isValueCreated) {\n            this.createdValue = this.factory();\n            this.isValueCreated = true;\n        }\n        return this.createdValue;\n    }\n    get IsValueCreated() {\n        return this.isValueCreated;\n    }\n}\nexport function lazyFromValue(v) {\n    return new Lazy(() => v);\n}\nexport function padWithZeros(i, length) {\n    let str = i.toString(10);\n    while (str.length < length) {\n        str = \"0\" + str;\n    }\n    return str;\n}\nexport function padLeftAndRightWithZeros(i, lengthLeft, lengthRight) {\n    let str = i.toString(10);\n    while (str.length < lengthLeft) {\n        str = \"0\" + str;\n    }\n    while (str.length < lengthRight) {\n        str = str + \"0\";\n    }\n    return str;\n}\nexport function dateOffset(date) {\n    const date1 = date;\n    return typeof date1.offset === \"number\"\n        ? date1.offset\n        : (date.kind === 1 /* UTC */\n            ? 0 : date.getTimezoneOffset() * -60000);\n}\nexport function int16ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport function int32ToString(i, radix) {\n    i = i < 0 && radix != null && radix !== 10 ? 0xFFFFFFFF + i + 1 : i;\n    return i.toString(radix);\n}\nexport class ObjectRef {\n    static id(o) {\n        if (!ObjectRef.idMap.has(o)) {\n            ObjectRef.idMap.set(o, ++ObjectRef.count);\n        }\n        return ObjectRef.idMap.get(o);\n    }\n}\nObjectRef.idMap = new WeakMap();\nObjectRef.count = 0;\nexport function stringHash(s) {\n    let i = 0;\n    let h = 5381;\n    const len = s.length;\n    while (i < len) {\n        h = (h * 33) ^ s.charCodeAt(i++);\n    }\n    return h;\n}\nexport function numberHash(x) {\n    return x * 2654435761 | 0;\n}\n// From https://stackoverflow.com/a/37449594\nexport function combineHashCodes(hashes) {\n    if (hashes.length === 0) {\n        return 0;\n    }\n    return hashes.reduce((h1, h2) => {\n        return ((h1 << 5) + h1) ^ h2;\n    });\n}\nexport function physicalHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default:\n            return numberHash(ObjectRef.id(x));\n    }\n}\nexport function identityHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    else if (isHashable(x)) {\n        return x.GetHashCode();\n    }\n    else {\n        return physicalHash(x);\n    }\n}\nexport function dateHash(x) {\n    return x.getTime();\n}\nexport function arrayHash(x) {\n    const len = x.length;\n    const hashes = new Array(len);\n    for (let i = 0; i < len; i++) {\n        hashes[i] = structuralHash(x[i]);\n    }\n    return combineHashCodes(hashes);\n}\nexport function structuralHash(x) {\n    if (x == null) {\n        return 0;\n    }\n    switch (typeof x) {\n        case \"boolean\":\n            return x ? 1 : 0;\n        case \"number\":\n            return numberHash(x);\n        case \"string\":\n            return stringHash(x);\n        default: {\n            if (isHashable(x)) {\n                return x.GetHashCode();\n            }\n            else if (isArrayLike(x)) {\n                return arrayHash(x);\n            }\n            else if (x instanceof Date) {\n                return dateHash(x);\n            }\n            else if (Object.getPrototypeOf(x).constructor === Object) {\n                // TODO: check call-stack to prevent cyclic objects?\n                const hashes = Object.values(x).map((v) => structuralHash(v));\n                return combineHashCodes(hashes);\n            }\n            else {\n                // Classes don't implement GetHashCode by default, but must use identity hashing\n                return numberHash(ObjectRef.id(x));\n                // return stringHash(String(x));\n            }\n        }\n    }\n}\n// Intended for custom numeric types, like long or decimal\nexport function fastStructuralHash(x) {\n    return stringHash(String(x));\n}\n// Intended for declared types that may or may not implement GetHashCode\nexport function safeHash(x) {\n    return x == null ? 0 : isHashable(x) ? x.GetHashCode() : numberHash(ObjectRef.id(x));\n}\nexport function equalArraysWith(x, y, eq) {\n    if (x == null) {\n        return y == null;\n    }\n    if (y == null) {\n        return false;\n    }\n    if (x.length !== y.length) {\n        return false;\n    }\n    for (let i = 0; i < x.length; i++) {\n        if (!eq(x[i], y[i])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equalArrays(x, y) {\n    return equalArraysWith(x, y, equals);\n}\nfunction equalObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return false;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0; i < xKeys.length; i++) {\n        if (xKeys[i] !== yKeys[i] || !equals(x[xKeys[i]], y[yKeys[i]])) {\n            return false;\n        }\n    }\n    return true;\n}\nexport function equals(x, y) {\n    if (x === y) {\n        return true;\n    }\n    else if (x == null) {\n        return y == null;\n    }\n    else if (y == null) {\n        return false;\n    }\n    else if (typeof x !== \"object\") {\n        return false;\n    }\n    else if (isEquatable(x)) {\n        return x.Equals(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) && equalArrays(x, y);\n    }\n    else if (x instanceof Date) {\n        return (y instanceof Date) && compareDates(x, y) === 0;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object && equalObjects(x, y);\n    }\n}\nexport function compareDates(x, y) {\n    let xtime;\n    let ytime;\n    // DateTimeOffset and DateTime deals with equality differently.\n    if (\"offset\" in x && \"offset\" in y) {\n        xtime = x.getTime();\n        ytime = y.getTime();\n    }\n    else {\n        xtime = x.getTime() + dateOffset(x);\n        ytime = y.getTime() + dateOffset(y);\n    }\n    return xtime === ytime ? 0 : (xtime < ytime ? -1 : 1);\n}\nexport function comparePrimitives(x, y) {\n    return x === y ? 0 : (x < y ? -1 : 1);\n}\nexport function compareArraysWith(x, y, comp) {\n    if (x == null) {\n        return y == null ? 0 : 1;\n    }\n    if (y == null) {\n        return -1;\n    }\n    if (x.length !== y.length) {\n        return x.length < y.length ? -1 : 1;\n    }\n    for (let i = 0, j = 0; i < x.length; i++) {\n        j = comp(x[i], y[i]);\n        if (j !== 0) {\n            return j;\n        }\n    }\n    return 0;\n}\nexport function compareArrays(x, y) {\n    return compareArraysWith(x, y, compare);\n}\nfunction compareObjects(x, y) {\n    const xKeys = Object.keys(x);\n    const yKeys = Object.keys(y);\n    if (xKeys.length !== yKeys.length) {\n        return xKeys.length < yKeys.length ? -1 : 1;\n    }\n    xKeys.sort();\n    yKeys.sort();\n    for (let i = 0, j = 0; i < xKeys.length; i++) {\n        const key = xKeys[i];\n        if (key !== yKeys[i]) {\n            return key < yKeys[i] ? -1 : 1;\n        }\n        else {\n            j = compare(x[key], y[key]);\n            if (j !== 0) {\n                return j;\n            }\n        }\n    }\n    return 0;\n}\nexport function compare(x, y) {\n    if (x === y) {\n        return 0;\n    }\n    else if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    else if (y == null) {\n        return 1;\n    }\n    else if (typeof x !== \"object\") {\n        return x < y ? -1 : 1;\n    }\n    else if (isComparable(x)) {\n        return x.CompareTo(y);\n    }\n    else if (isArrayLike(x)) {\n        return isArrayLike(y) ? compareArrays(x, y) : -1;\n    }\n    else if (x instanceof Date) {\n        return y instanceof Date ? compareDates(x, y) : -1;\n    }\n    else {\n        return Object.getPrototypeOf(x).constructor === Object ? compareObjects(x, y) : -1;\n    }\n}\nexport function min(comparer, x, y) {\n    return comparer(x, y) < 0 ? x : y;\n}\nexport function max(comparer, x, y) {\n    return comparer(x, y) > 0 ? x : y;\n}\nexport function clamp(comparer, value, min, max) {\n    return (comparer(value, min) < 0) ? min : (comparer(value, max) > 0) ? max : value;\n}\nexport function createAtom(value) {\n    let atom = value;\n    return (value, isSetter) => {\n        if (!isSetter) {\n            return atom;\n        }\n        else {\n            atom = value;\n            return void 0;\n        }\n    };\n}\nexport function createObj(fields) {\n    const obj = {};\n    for (const kv of fields) {\n        obj[kv[0]] = kv[1];\n    }\n    return obj;\n}\nexport function jsOptions(mutator) {\n    const opts = {};\n    mutator(opts);\n    return opts;\n}\nexport function round(value, digits = 0) {\n    const m = Math.pow(10, digits);\n    const n = +(digits ? value * m : value).toFixed(8);\n    const i = Math.floor(n);\n    const f = n - i;\n    const e = 1e-8;\n    const r = (f > 0.5 - e && f < 0.5 + e) ? ((i % 2 === 0) ? i : i + 1) : Math.round(n);\n    return digits ? r / m : r;\n}\nexport function sign(x) {\n    return x > 0 ? 1 : x < 0 ? -1 : 0;\n}\nexport function randomNext(min, max) {\n    return Math.floor(Math.random() * (max - min)) + min;\n}\nexport function randomBytes(buffer) {\n    if (buffer == null) {\n        throw new Error(\"Buffer cannot be null\");\n    }\n    for (let i = 0; i < buffer.length; i += 6) {\n        // Pick random 48-bit number. Fill buffer in 2 24-bit chunks to avoid bitwise truncation.\n        let r = Math.floor(Math.random() * 281474976710656); // Low 24 bits = chunk 1.\n        const rhi = Math.floor(r / 16777216); // High 24 bits shifted via division = chunk 2.\n        for (let j = 0; j < 6 && i + j < buffer.length; j++) {\n            if (j === 3) {\n                r = rhi;\n            }\n            buffer[i + j] = r & 255;\n            r >>>= 8;\n        }\n    }\n}\nexport function unescapeDataString(s) {\n    // https://stackoverflow.com/a/4458580/524236\n    return decodeURIComponent((s).replace(/\\+/g, \"%20\"));\n}\nexport function escapeDataString(s) {\n    return encodeURIComponent(s).replace(/!/g, \"%21\")\n        .replace(/'/g, \"%27\")\n        .replace(/\\(/g, \"%28\")\n        .replace(/\\)/g, \"%29\")\n        .replace(/\\*/g, \"%2A\");\n}\nexport function escapeUriString(s) {\n    return encodeURI(s);\n}\n// ICollection.Clear and Count members can be called on Arrays\n// or Dictionaries so we need a runtime check (see #1120)\nexport function count(col) {\n    if (isArrayLike(col)) {\n        return col.length;\n    }\n    else {\n        let count = 0;\n        for (const _ of col) {\n            count++;\n        }\n        return count;\n    }\n}\nexport function clear(col) {\n    if (isArrayLike(col)) {\n        col.splice(0);\n    }\n    else {\n        col.clear();\n    }\n}\nconst CURRIED_KEY = \"__CURRIED__\";\nexport function uncurry(arity, f) {\n    // f may be a function option with None value\n    if (f == null || f.length > 1) {\n        return f;\n    }\n    let uncurriedFn;\n    switch (arity) {\n        case 2:\n            uncurriedFn = (a1, a2) => f(a1)(a2);\n            break;\n        case 3:\n            uncurriedFn = (a1, a2, a3) => f(a1)(a2)(a3);\n            break;\n        case 4:\n            uncurriedFn = (a1, a2, a3, a4) => f(a1)(a2)(a3)(a4);\n            break;\n        case 5:\n            uncurriedFn = (a1, a2, a3, a4, a5) => f(a1)(a2)(a3)(a4)(a5);\n            break;\n        case 6:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6) => f(a1)(a2)(a3)(a4)(a5)(a6);\n            break;\n        case 7:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6, a7) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7);\n            break;\n        case 8:\n            uncurriedFn = (a1, a2, a3, a4, a5, a6, a7, a8) => f(a1)(a2)(a3)(a4)(a5)(a6)(a7)(a8);\n            break;\n        default:\n            throw new Error(\"Uncurrying to more than 8-arity is not supported: \" + arity);\n    }\n    uncurriedFn[CURRIED_KEY] = f;\n    return uncurriedFn;\n}\nexport function curry(arity, f) {\n    if (f == null || f.length === 1) {\n        return f;\n    }\n    if (CURRIED_KEY in f) {\n        return f[CURRIED_KEY];\n    }\n    switch (arity) {\n        case 2:\n            return (a1) => (a2) => f(a1, a2);\n        case 3:\n            return (a1) => (a2) => (a3) => f(a1, a2, a3);\n        case 4:\n            return (a1) => (a2) => (a3) => (a4) => f(a1, a2, a3, a4);\n        case 5:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => f(a1, a2, a3, a4, a5);\n        case 6:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f(a1, a2, a3, a4, a5, a6);\n        case 7:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f(a1, a2, a3, a4, a5, a6, a7);\n        case 8:\n            return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f(a1, a2, a3, a4, a5, a6, a7, a8);\n        default:\n            throw new Error(\"Currying to more than 8-arity is not supported: \" + arity);\n    }\n}\nexport function checkArity(arity, f) {\n    return f.length > arity\n        ? (...args1) => (...args2) => f.apply(undefined, args1.concat(args2))\n        : f;\n}\nexport function partialApply(arity, f, args) {\n    if (f == null) {\n        return undefined;\n    }\n    else if (CURRIED_KEY in f) {\n        f = f[CURRIED_KEY];\n        for (let i = 0; i < args.length; i++) {\n            f = f(args[i]);\n        }\n        return f;\n    }\n    else {\n        switch (arity) {\n            case 1:\n                // Wrap arguments to make sure .concat doesn't destruct arrays. Example\n                // [1,2].concat([3,4],5)   --> [1,2,3,4,5]    // fails\n                // [1,2].concat([[3,4],5]) --> [1,2,[3,4],5]  // ok\n                return (a1) => f.apply(undefined, args.concat([a1]));\n            case 2:\n                return (a1) => (a2) => f.apply(undefined, args.concat([a1, a2]));\n            case 3:\n                return (a1) => (a2) => (a3) => f.apply(undefined, args.concat([a1, a2, a3]));\n            case 4:\n                return (a1) => (a2) => (a3) => (a4) => f.apply(undefined, args.concat([a1, a2, a3, a4]));\n            case 5:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5]));\n            case 6:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6]));\n            case 7:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6, a7]));\n            case 8:\n                return (a1) => (a2) => (a3) => (a4) => (a5) => (a6) => (a7) => (a8) => f.apply(undefined, args.concat([a1, a2, a3, a4, a5, a6, a7, a8]));\n            default:\n                throw new Error(\"Partially applying to more than 8-arity is not supported: \" + arity);\n        }\n    }\n}\nexport function mapCurriedArgs(fn, mappings) {\n    function mapArg(fn, arg, mappings, idx) {\n        const mapping = mappings[idx];\n        if (mapping !== 0) {\n            const expectedArity = mapping[0];\n            const actualArity = mapping[1];\n            if (expectedArity > 1) {\n                arg = curry(expectedArity, arg);\n            }\n            if (actualArity > 1) {\n                arg = uncurry(actualArity, arg);\n            }\n        }\n        const res = fn(arg);\n        if (idx + 1 === mappings.length) {\n            return res;\n        }\n        else {\n            return (arg) => mapArg(res, arg, mappings, idx + 1);\n        }\n    }\n    return (arg) => mapArg(fn, arg, mappings, 0);\n}\n","import { combineHashCodes, compare, compareArrays, equalArrays, equals, sameConstructor, numberHash, structuralHash } from \"./Util.js\";\nexport function seqToString(self) {\n    let count = 0;\n    let str = \"[\";\n    for (const x of self) {\n        if (count === 0) {\n            str += toString(x);\n        }\n        else if (count === 100) {\n            str += \"; ...\";\n            break;\n        }\n        else {\n            str += \"; \" + toString(x);\n        }\n        count++;\n    }\n    return str + \"]\";\n}\nexport function toString(x, callStack = 0) {\n    if (x != null && typeof x === \"object\") {\n        if (typeof x.toString === \"function\") {\n            return x.toString();\n        }\n        else if (Symbol.iterator in x) {\n            return seqToString(x);\n        }\n        else { // TODO: Date?\n            const cons = Object.getPrototypeOf(x).constructor;\n            return cons === Object && callStack < 10\n                // Same format as recordToString\n                ? \"{ \" + Object.entries(x).map(([k, v]) => k + \" = \" + toString(v, callStack + 1)).join(\"\\n  \") + \" }\"\n                : cons.name;\n        }\n    }\n    return String(x);\n}\nfunction compareList(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else {\n        if (other == null) {\n            return -1;\n        }\n        while (self.tail != null) {\n            if (other.tail == null) {\n                return 1;\n            }\n            const res = compare(self.head, other.head);\n            if (res !== 0) {\n                return res;\n            }\n            self = self.tail;\n            other = other.tail;\n        }\n        return other.tail == null ? 0 : -1;\n    }\n}\nexport class List {\n    constructor(head, tail) {\n        this.head = head;\n        this.tail = tail;\n    }\n    [Symbol.iterator]() {\n        let cur = this;\n        return {\n            next: () => {\n                const value = cur === null || cur === void 0 ? void 0 : cur.head;\n                const done = (cur === null || cur === void 0 ? void 0 : cur.tail) == null;\n                cur = cur === null || cur === void 0 ? void 0 : cur.tail;\n                return { done, value };\n            },\n        };\n    }\n    toJSON() { return Array.from(this); }\n    toString() { return seqToString(this); }\n    GetHashCode() { return combineHashCodes(Array.from(this).map(structuralHash)); }\n    Equals(other) { return compareList(this, other) === 0; }\n    CompareTo(other) { return compareList(this, other); }\n}\nexport class Union {\n    get name() {\n        return this.cases()[this.tag];\n    }\n    toJSON() {\n        return this.fields.length === 0 ? this.name : [this.name].concat(this.fields);\n    }\n    toString() {\n        if (this.fields.length === 0) {\n            return this.name;\n        }\n        else {\n            let fields = \"\";\n            let withParens = true;\n            if (this.fields.length === 1) {\n                const field = toString(this.fields[0]);\n                withParens = field.indexOf(\" \") >= 0;\n                fields = field;\n            }\n            else {\n                fields = this.fields.map((x) => toString(x)).join(\", \");\n            }\n            return this.name + (withParens ? \" (\" : \" \") + fields + (withParens ? \")\" : \"\");\n        }\n    }\n    GetHashCode() {\n        const hashes = this.fields.map((x) => structuralHash(x));\n        hashes.splice(0, 0, numberHash(this.tag));\n        return combineHashCodes(hashes);\n    }\n    Equals(other) {\n        if (this === other) {\n            return true;\n        }\n        else if (!sameConstructor(this, other)) {\n            return false;\n        }\n        else if (this.tag === other.tag) {\n            return equalArrays(this.fields, other.fields);\n        }\n        else {\n            return false;\n        }\n    }\n    CompareTo(other) {\n        if (this === other) {\n            return 0;\n        }\n        else if (!sameConstructor(this, other)) {\n            return -1;\n        }\n        else if (this.tag === other.tag) {\n            return compareArrays(this.fields, other.fields);\n        }\n        else {\n            return this.tag < other.tag ? -1 : 1;\n        }\n    }\n}\nfunction recordToJSON(self) {\n    const o = {};\n    const keys = Object.keys(self);\n    for (let i = 0; i < keys.length; i++) {\n        o[keys[i]] = self[keys[i]];\n    }\n    return o;\n}\nfunction recordToString(self) {\n    return \"{ \" + Object.entries(self).map(([k, v]) => k + \" = \" + toString(v)).join(\"\\n  \") + \" }\";\n}\nfunction recordGetHashCode(self) {\n    const hashes = Object.values(self).map((v) => structuralHash(v));\n    return combineHashCodes(hashes);\n}\nfunction recordEquals(self, other) {\n    if (self === other) {\n        return true;\n    }\n    else if (!sameConstructor(self, other)) {\n        return false;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            if (!equals(self[thisNames[i]], other[thisNames[i]])) {\n                return false;\n            }\n        }\n        return true;\n    }\n}\nfunction recordCompareTo(self, other) {\n    if (self === other) {\n        return 0;\n    }\n    else if (!sameConstructor(self, other)) {\n        return -1;\n    }\n    else {\n        const thisNames = Object.keys(self);\n        for (let i = 0; i < thisNames.length; i++) {\n            const result = compare(self[thisNames[i]], other[thisNames[i]]);\n            if (result !== 0) {\n                return result;\n            }\n        }\n        return 0;\n    }\n}\nexport class Record {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class FSharpRef {\n    constructor(contentsOrGetter, setter) {\n        if (typeof setter === \"function\") {\n            this.getter = contentsOrGetter;\n            this.setter = setter;\n        }\n        else {\n            this.getter = () => contentsOrGetter;\n            this.setter = (v) => { contentsOrGetter = v; };\n        }\n    }\n    get contents() {\n        return this.getter();\n    }\n    set contents(v) {\n        this.setter(v);\n    }\n}\n// EXCEPTIONS\n// Exception is intentionally not derived from Error, for performance reasons (see #2160)\nexport class Exception {\n    constructor(message) {\n        this.message = message;\n    }\n}\nexport function isException(x) {\n    return x instanceof Exception || x instanceof Error;\n}\nexport class FSharpException extends Exception {\n    toJSON() { return recordToJSON(this); }\n    toString() { return recordToString(this); }\n    GetHashCode() { return recordGetHashCode(this); }\n    Equals(other) { return recordEquals(this, other); }\n    CompareTo(other) { return recordCompareTo(this, other); }\n}\nexport class MatchFailureException extends FSharpException {\n    constructor(arg1, arg2, arg3) {\n        super();\n        this.arg1 = arg1;\n        this.arg2 = arg2 | 0;\n        this.arg3 = arg3 | 0;\n        this.message = \"The match cases were incomplete\";\n    }\n}\nexport class Attribute {\n}\n","import { Record, Union } from \"./Types.js\";\nimport { combineHashCodes, equalArraysWith, stringHash } from \"./Util.js\";\nexport class CaseInfo {\n    constructor(declaringType, tag, name, fields) {\n        this.declaringType = declaringType;\n        this.tag = tag;\n        this.name = name;\n        this.fields = fields;\n    }\n}\nexport class TypeInfo {\n    constructor(fullname, generics, construct, parent, fields, cases, enumCases) {\n        this.fullname = fullname;\n        this.generics = generics;\n        this.construct = construct;\n        this.parent = parent;\n        this.fields = fields;\n        this.cases = cases;\n        this.enumCases = enumCases;\n    }\n    toString() {\n        return fullName(this);\n    }\n    GetHashCode() {\n        return getHashCode(this);\n    }\n    Equals(other) {\n        return equals(this, other);\n    }\n}\nexport function getGenerics(t) {\n    return t.generics != null ? t.generics : [];\n}\nexport function getHashCode(t) {\n    const fullnameHash = stringHash(t.fullname);\n    const genHashes = getGenerics(t).map(getHashCode);\n    return combineHashCodes([fullnameHash, ...genHashes]);\n}\nexport function equals(t1, t2) {\n    if (t1.fullname === \"\") { // Anonymous records\n        return t2.fullname === \"\"\n            && equalArraysWith(getRecordElements(t1), getRecordElements(t2), ([k1, v1], [k2, v2]) => k1 === k2 && equals(v1, v2));\n    }\n    else {\n        return t1.fullname === t2.fullname\n            && equalArraysWith(getGenerics(t1), getGenerics(t2), equals);\n    }\n}\nexport function class_type(fullname, generics, construct, parent) {\n    return new TypeInfo(fullname, generics, construct, parent);\n}\nexport function record_type(fullname, generics, construct, fields) {\n    return new TypeInfo(fullname, generics, construct, undefined, fields);\n}\nexport function anonRecord_type(...fields) {\n    return new TypeInfo(\"\", undefined, undefined, undefined, () => fields);\n}\nexport function union_type(fullname, generics, construct, cases) {\n    const t = new TypeInfo(fullname, generics, construct, undefined, undefined, () => {\n        const caseNames = construct.prototype.cases();\n        return cases().map((fields, i) => new CaseInfo(t, i, caseNames[i], fields));\n    });\n    return t;\n}\nexport function tuple_type(...generics) {\n    return new TypeInfo(\"System.Tuple`\" + generics.length, generics);\n}\nexport function delegate_type(...generics) {\n    return new TypeInfo(\"System.Func`\" + generics.length, generics);\n}\nexport function lambda_type(argType, returnType) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpFunc`2\", [argType, returnType]);\n}\nexport function option_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Core.FSharpOption`1\", [generic]);\n}\nexport function list_type(generic) {\n    return new TypeInfo(\"Microsoft.FSharp.Collections.FSharpList`1\", [generic]);\n}\nexport function array_type(generic) {\n    return new TypeInfo(generic.fullname + \"[]\", [generic]);\n}\nexport function enum_type(fullname, underlyingType, enumCases) {\n    return new TypeInfo(fullname, [underlyingType], undefined, undefined, undefined, undefined, enumCases);\n}\nexport const obj_type = new TypeInfo(\"System.Object\");\nexport const unit_type = new TypeInfo(\"Microsoft.FSharp.Core.Unit\");\nexport const char_type = new TypeInfo(\"System.Char\");\nexport const string_type = new TypeInfo(\"System.String\");\nexport const bool_type = new TypeInfo(\"System.Boolean\");\nexport const int8_type = new TypeInfo(\"System.SByte\");\nexport const uint8_type = new TypeInfo(\"System.Byte\");\nexport const int16_type = new TypeInfo(\"System.Int16\");\nexport const uint16_type = new TypeInfo(\"System.UInt16\");\nexport const int32_type = new TypeInfo(\"System.Int32\");\nexport const uint32_type = new TypeInfo(\"System.UInt32\");\nexport const float32_type = new TypeInfo(\"System.Single\");\nexport const float64_type = new TypeInfo(\"System.Double\");\nexport const decimal_type = new TypeInfo(\"System.Decimal\");\nexport function name(info) {\n    if (Array.isArray(info)) {\n        return info[0];\n    }\n    else if (info instanceof CaseInfo) {\n        return info.name;\n    }\n    else {\n        const i = info.fullname.lastIndexOf(\".\");\n        return i === -1 ? info.fullname : info.fullname.substr(i + 1);\n    }\n}\nexport function fullName(t) {\n    const gen = t.generics != null && !isArray(t) ? t.generics : [];\n    if (gen.length > 0) {\n        return t.fullname + \"[\" + gen.map((x) => fullName(x)).join(\",\") + \"]\";\n    }\n    else {\n        return t.fullname;\n    }\n}\nexport function namespace(t) {\n    const i = t.fullname.lastIndexOf(\".\");\n    return i === -1 ? \"\" : t.fullname.substr(0, i);\n}\nexport function isArray(t) {\n    return t.fullname.endsWith(\"[]\");\n}\nexport function getElementType(t) {\n    var _a;\n    return isArray(t) ? (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0] : undefined;\n}\nexport function isGenericType(t) {\n    return t.generics != null && t.generics.length > 0;\n}\nexport function isEnum(t) {\n    return t.enumCases != null && t.enumCases.length > 0;\n}\nexport function isSubclassOf(t1, t2) {\n    var _a, _b;\n    return (_b = (_a = t1.parent) === null || _a === void 0 ? void 0 : _a.Equals(t2)) !== null && _b !== void 0 ? _b : false;\n}\n/**\n * This doesn't replace types for fields (records) or cases (unions)\n * but it should be enough for type comparison purposes\n */\nexport function getGenericTypeDefinition(t) {\n    return t.generics == null ? t : new TypeInfo(t.fullname, t.generics.map(() => obj_type));\n}\nexport function getEnumUnderlyingType(t) {\n    var _a;\n    return (_a = t.generics) === null || _a === void 0 ? void 0 : _a[0];\n}\nexport function getEnumValues(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[1]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function getEnumNames(t) {\n    if (isEnum(t) && t.enumCases != null) {\n        return t.enumCases.map((kv) => kv[0]);\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nfunction getEnumCase(t, v) {\n    if (t.enumCases != null) {\n        if (typeof v === \"string\") {\n            for (const kv of t.enumCases) {\n                if (kv[0] === v) {\n                    return kv;\n                }\n            }\n            throw new Error(`'${v}' was not found in ${t.fullname}`);\n        }\n        else {\n            for (const kv of t.enumCases) {\n                if (kv[1] === v) {\n                    return kv;\n                }\n            }\n            // .NET returns the number even if it doesn't match any of the cases\n            return [\"\", v];\n        }\n    }\n    else {\n        throw new Error(`${t.fullname} is not an enum type`);\n    }\n}\nexport function parseEnum(t, str) {\n    // TODO: better int parsing here, parseInt ceils floats: \"4.8\" -> 4\n    const value = parseInt(str, 10);\n    return getEnumCase(t, isNaN(value) ? str : value)[1];\n}\nexport function tryParseEnum(t, str, defValue) {\n    try {\n        defValue.contents = parseEnum(t, str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function getEnumName(t, v) {\n    return getEnumCase(t, v)[0];\n}\nexport function isEnumDefined(t, v) {\n    try {\n        const kv = getEnumCase(t, v);\n        return kv[0] != null && kv[0] !== \"\";\n    }\n    catch (_a) {\n        // supress error\n    }\n    return false;\n}\n// FSharpType\nexport function getUnionCases(t) {\n    if (t.cases != null) {\n        return t.cases();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# union type`);\n    }\n}\nexport function getRecordElements(t) {\n    if (t.fields != null) {\n        return t.fields();\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# record type`);\n    }\n}\nexport function getTupleElements(t) {\n    if (isTuple(t) && t.generics != null) {\n        return t.generics;\n    }\n    else {\n        throw new Error(`${t.fullname} is not a tuple type`);\n    }\n}\nexport function getFunctionElements(t) {\n    if (isFunction(t) && t.generics != null) {\n        const gen = t.generics;\n        return [gen[0], gen[1]];\n    }\n    else {\n        throw new Error(`${t.fullname} is not an F# function type`);\n    }\n}\nexport function isUnion(t) {\n    return t instanceof TypeInfo ? t.cases != null : t instanceof Union;\n}\nexport function isRecord(t) {\n    return t instanceof TypeInfo ? t.fields != null : t instanceof Record;\n}\nexport function isTuple(t) {\n    return t.fullname.startsWith(\"System.Tuple\") && !isArray(t);\n}\n// In .NET this is false for delegates\nexport function isFunction(t) {\n    return t.fullname === \"Microsoft.FSharp.Core.FSharpFunc`2\";\n}\n// FSharpValue\nexport function getUnionFields(v, t) {\n    const cases = getUnionCases(t);\n    const case_ = cases[v.tag];\n    if (case_ == null) {\n        throw new Error(`Cannot find case ${v.name} in union type`);\n    }\n    return [case_, v.fields];\n}\nexport function getUnionCaseFields(uci) {\n    return uci.fields == null ? [] : uci.fields;\n}\n// This is used as replacement of `FSharpValue.GetRecordFields`\n// For `FSharpTypes.GetRecordFields` see `getRecordElements`\n// Object.keys returns keys in the order they were added to the object\nexport function getRecordFields(v) {\n    return Object.keys(v).map((k) => v[k]);\n}\nexport function getRecordField(v, field) {\n    return v[field[0]];\n}\nexport function getTupleFields(v) {\n    return v;\n}\nexport function getTupleField(v, i) {\n    return v[i];\n}\nexport function makeUnion(uci, values) {\n    const expectedLength = (uci.fields || []).length;\n    if (values.length !== expectedLength) {\n        throw new Error(`Expected an array of length ${expectedLength} but got ${values.length}`);\n    }\n    return uci.declaringType.construct != null\n        ? new uci.declaringType.construct(uci.tag, ...values)\n        : {};\n}\nexport function makeRecord(t, values) {\n    const fields = getRecordElements(t);\n    if (fields.length !== values.length) {\n        throw new Error(`Expected an array of length ${fields.length} but got ${values.length}`);\n    }\n    return t.construct != null\n        ? new t.construct(...values)\n        : fields.reduce((obj, [key, _t], i) => {\n            obj[key] = values[i];\n            return obj;\n        }, {});\n}\nexport function makeTuple(values, _t) {\n    return values;\n}\nexport function makeGenericType(t, generics) {\n    return new TypeInfo(t.fullname, generics, t.construct, t.parent, t.fields, t.cases);\n}\nexport function createInstance(t, consArgs) {\n    // TODO: Check if consArgs length is same as t.construct?\n    // (Arg types can still be different)\n    if (typeof t.construct === \"function\") {\n        return new t.construct(...(consArgs !== null && consArgs !== void 0 ? consArgs : []));\n    }\n    else {\n        throw new Error(`Cannot access constructor of ${t.fullname}`);\n    }\n}\nexport function getValue(propertyInfo, v) {\n    return v[propertyInfo[0]];\n}\n// Fable.Core.Reflection\nfunction assertUnion(x) {\n    if (!(x instanceof Union)) {\n        throw new Error(`Value is not an F# union type`);\n    }\n}\nexport function getCaseTag(x) {\n    assertUnion(x);\n    return x.tag;\n}\nexport function getCaseName(x) {\n    assertUnion(x);\n    return x.cases()[x.tag];\n}\nexport function getCaseFields(x) {\n    assertUnion(x);\n    return x.fields;\n}\n","import { compare, equals, structuralHash } from \"./Util.js\";\n// Using a class here for better compatibility with TS files importing Some\nexport class Some {\n    constructor(value) {\n        this.value = value;\n    }\n    toJSON() {\n        return this.value;\n    }\n    // Don't add \"Some\" for consistency with erased options\n    toString() {\n        return String(this.value);\n    }\n    GetHashCode() {\n        return structuralHash(this.value);\n    }\n    Equals(other) {\n        if (other == null) {\n            return false;\n        }\n        else {\n            return equals(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n    CompareTo(other) {\n        if (other == null) {\n            return 1;\n        }\n        else {\n            return compare(this.value, other instanceof Some ? other.value : other);\n        }\n    }\n}\nexport function some(x) {\n    return x == null || x instanceof Some ? new Some(x) : x;\n}\nexport function value(x) {\n    if (x == null) {\n        throw new Error(\"Option has no value\");\n    }\n    else {\n        return x instanceof Some ? x.value : x;\n    }\n}\nexport function ofNullable(x) {\n    // This will fail with unit probably, an alternative would be:\n    // return x === null ? undefined : (x === undefined ? new Some(x) : x);\n    return x == null ? undefined : x;\n}\nexport function toNullable(x) {\n    return x == null ? null : value(x);\n}\nexport function flatten(x) {\n    return x == null ? undefined : value(x);\n}\nexport function toArray(opt) {\n    return (opt == null) ? [] : [value(opt)];\n}\nexport function defaultArg(opt, defaultValue) {\n    return (opt != null) ? value(opt) : defaultValue;\n}\nexport function defaultArgWith(opt, defThunk) {\n    return (opt != null) ? value(opt) : defThunk();\n}\nexport function filter(predicate, opt) {\n    return (opt != null) ? (predicate(value(opt)) ? opt : undefined) : opt;\n}\nexport function map(mapping, opt) {\n    return (opt != null) ? some(mapping(value(opt))) : undefined;\n}\nexport function map2(mapping, opt1, opt2) {\n    return (opt1 != null && opt2 != null) ? mapping(value(opt1), value(opt2)) : undefined;\n}\nexport function map3(mapping, opt1, opt2, opt3) {\n    return (opt1 != null && opt2 != null && opt3 != null) ? mapping(value(opt1), value(opt2), value(opt3)) : undefined;\n}\nexport function bind(binder, opt) {\n    return opt != null ? binder(value(opt)) : undefined;\n}\nexport function tryOp(op, arg) {\n    try {\n        return some(op(arg));\n    }\n    catch (_a) {\n        return undefined;\n    }\n}\n","export const symbol = Symbol(\"numeric\");\nexport function isNumeric(x) {\n    return typeof x === \"number\" || (x === null || x === void 0 ? void 0 : x[symbol]);\n}\nexport function compare(x, y) {\n    if (typeof x === \"number\") {\n        return x < y ? -1 : (x > y ? 1 : 0);\n    }\n    else {\n        return x.CompareTo(y);\n    }\n}\nexport function multiply(x, y) {\n    if (typeof x === \"number\") {\n        return x * y;\n    }\n    else {\n        return x[symbol]().multiply(y);\n    }\n}\nexport function toFixed(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toFixed(dp);\n    }\n    else {\n        return x[symbol]().toFixed(dp);\n    }\n}\nexport function toPrecision(x, sd) {\n    if (typeof x === \"number\") {\n        return x.toPrecision(sd);\n    }\n    else {\n        return x[symbol]().toPrecision(sd);\n    }\n}\nexport function toExponential(x, dp) {\n    if (typeof x === \"number\") {\n        return x.toExponential(dp);\n    }\n    else {\n        return x[symbol]().toExponential(dp);\n    }\n}\nexport function toHex(x) {\n    if (typeof x === \"number\") {\n        return (Number(x) >>> 0).toString(16);\n    }\n    else {\n        return x[symbol]().toHex();\n    }\n}\n","// https://github.com/MikeMcl/big.js/blob/01b3ce3a6b0ba7b42442ea48ec4ffc88d1669ec4/big.mjs\n/* tslint:disable */\nimport { combineHashCodes } from \"../Util.js\";\nimport { symbol } from \"../Numeric.js\";\n// The shared prototype object.\nvar P = {\n    GetHashCode() { return combineHashCodes([this.s, this.e].concat(this.c)); },\n    Equals(x) { return !this.cmp(x); },\n    CompareTo(x) { return this.cmp(x); },\n    [symbol]() {\n        const _this = this;\n        return {\n            multiply: y => _this.mul(y),\n            toPrecision: sd => _this.toPrecision(sd),\n            toExponential: dp => _this.toExponential(dp),\n            toFixed: dp => _this.toFixed(dp),\n            toHex: () => (Number(_this) >>> 0).toString(16),\n        };\n    }\n};\n/*\n *  big.js v5.2.2\n *  A small, fast, easy-to-use library for arbitrary-precision decimal arithmetic.\n *  Copyright (c) 2018 Michael Mclaughlin <M8ch88l@gmail.com>\n *  https://github.com/MikeMcl/big.js/LICENCE\n */\n/************************************** EDITABLE DEFAULTS *****************************************/\n// The default values below must be integers within the stated ranges.\n/*\n * The maximum number of decimal places (DP) of the results of operations involving division:\n * div and sqrt, and pow with negative exponents.\n */\nvar DP = 28, // 0 to MAX_DP\n/*\n * The rounding mode (RM) used when rounding to the above decimal places.\n *\n *  0  Towards zero (i.e. truncate, no rounding).       (ROUND_DOWN)\n *  1  To nearest neighbour. If equidistant, round up.  (ROUND_HALF_UP)\n *  2  To nearest neighbour. If equidistant, to even.   (ROUND_HALF_EVEN)\n *  3  Away from zero.                                  (ROUND_UP)\n */\nRM = 1, // 0, 1, 2 or 3\n// The maximum value of DP and Big.DP.\nMAX_DP = 1E6, // 0 to 1000000\n// The maximum magnitude of the exponent argument to the pow method.\nMAX_POWER = 1E6, // 1 to 1000000\n/*\n * The negative exponent (NE) at and beneath which toString returns exponential notation.\n * (JavaScript numbers: -7)\n * -1000000 is the minimum recommended exponent value of a Big.\n */\nNE = -29, // 0 to -1000000\n/*\n * The positive exponent (PE) at and above which toString returns exponential notation.\n * (JavaScript numbers: 21)\n * 1000000 is the maximum recommended exponent value of a Big.\n * (This limit is not enforced or checked.)\n */\nPE = 29, // 0 to 1000000\n/**************************************************************************************************/\n// Error messages.\nNAME = '[big.js] ', INVALID = NAME + 'Invalid ', INVALID_DP = INVALID + 'decimal places', INVALID_RM = INVALID + 'rounding mode', DIV_BY_ZERO = NAME + 'Division by zero', UNDEFINED = void 0, NUMERIC = /^-?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i;\n/*\n * Create and return a Big constructor.\n *\n */\nfunction _Big_() {\n    /*\n     * The Big constructor and exported function.\n     * Create and return a new instance of a Big number object.\n     *\n     * n {number|string|Big} A numeric value.\n     */\n    function Big(n) {\n        var x = this;\n        // Enable constructor usage without new.\n        if (!(x instanceof Big))\n            return n === UNDEFINED ? _Big_() : new Big(n);\n        // Duplicate.\n        if (n instanceof Big) {\n            x.s = n.s;\n            x.e = n.e;\n            x.c = n.c.slice();\n            normalize(x);\n        }\n        else {\n            parse(x, n);\n        }\n        /*\n         * Retain a reference to this Big constructor, and shadow Big.prototype.constructor which\n         * points to Object.\n         */\n        x.constructor = Big;\n    }\n    Big.prototype = P;\n    Big.DP = DP;\n    Big.RM = RM;\n    Big.NE = NE;\n    Big.PE = PE;\n    Big.version = '5.2.2';\n    return Big;\n}\nfunction normalize(x) {\n    x = round(x, DP, 0);\n    if (x.c.length > 1 && !x.c[0]) {\n        let i = x.c.findIndex(x => x);\n        x.c = x.c.slice(i);\n        x.e = x.e - i;\n    }\n}\n/*\n * Parse the number or string value passed to a Big constructor.\n *\n * x {Big} A Big number instance.\n * n {number|string} A numeric value.\n */\nfunction parse(x, n) {\n    var e, i, nl;\n    // Minus zero?\n    if (n === 0 && 1 / n < 0)\n        n = '-0';\n    else if (!NUMERIC.test(n += ''))\n        throw Error(INVALID + 'number');\n    // Determine sign.\n    x.s = n.charAt(0) == '-' ? (n = n.slice(1), -1) : 1;\n    // Decimal point?\n    if ((e = n.indexOf('.')) > -1)\n        n = n.replace('.', '');\n    // Exponential form?\n    if ((i = n.search(/e/i)) > 0) {\n        // Determine exponent.\n        if (e < 0)\n            e = i;\n        e += +n.slice(i + 1);\n        n = n.substring(0, i);\n    }\n    else if (e < 0) {\n        // Integer.\n        e = n.length;\n    }\n    nl = n.length;\n    // Determine leading zeros before decimal point.\n    for (i = 0; i < e && i < nl && n.charAt(i) == '0';)\n        ++i;\n    // older version (ignores decimal point).\n    // // Determine leading zeros.\n    // for (i = 0; i < nl && n.charAt(i) == '0';) ++i;\n    if (i == nl) {\n        // Zero.\n        x.c = [x.e = 0];\n    }\n    else {\n        x.e = e - i - 1;\n        x.c = [];\n        // Convert string to array of digits without leading zeros\n        for (e = 0; i < nl;)\n            x.c[e++] = +n.charAt(i++);\n        // older version (doesn't keep trailing zeroes).\n        // // Determine trailing zeros.\n        // for (; nl > 0 && n.charAt(--nl) == '0';);\n        // // Convert string to array of digits without leading/trailing zeros.\n        // for (e = 0; i <= nl;) x.c[e++] = +n.charAt(i++);\n    }\n    x = round(x, Big.DP, Big.RM);\n    return x;\n}\n/*\n * Round Big x to a maximum of dp decimal places using rounding mode rm.\n * Called by stringify, P.div, P.round and P.sqrt.\n *\n * x {Big} The Big to round.\n * dp {number} Integer, 0 to MAX_DP inclusive.\n * rm {number} 0, 1, 2 or 3 (DOWN, HALF_UP, HALF_EVEN, UP)\n * [more] {boolean} Whether the result of division was truncated.\n */\nfunction round(x, dp, rm, more) {\n    var xc = x.c, i = x.e + dp + 1;\n    if (i < xc.length) {\n        if (rm === 1) {\n            // xc[i] is the digit after the digit that may be rounded up.\n            more = xc[i] >= 5;\n        }\n        else if (rm === 2) {\n            more = xc[i] > 5 || xc[i] == 5 &&\n                (more || i < 0 || xc[i + 1] !== UNDEFINED || xc[i - 1] & 1);\n        }\n        else if (rm === 3) {\n            const isZero = xc.findIndex((xci, idx) => idx >= i && xci > 0) < 0;\n            more = more || !isZero;\n        }\n        else {\n            more = false;\n            if (rm !== 0)\n                throw Error(INVALID_RM);\n        }\n        if (i < 1) {\n            xc.length = 1;\n            if (more) {\n                // 1, 0.1, 0.01, 0.001, 0.0001 etc.\n                x.e = -dp;\n                xc[0] = 1;\n            }\n            else {\n                // Zero.\n                xc[0] = x.e = 0;\n            }\n        }\n        else {\n            // Remove any digits after the required decimal places.\n            xc.length = i--;\n            // Round up?\n            if (more) {\n                // Rounding up may mean the previous digit has to be rounded up.\n                for (; ++xc[i] > 9;) {\n                    xc[i] = 0;\n                    if (!i--) {\n                        ++x.e;\n                        xc.unshift(1);\n                    }\n                }\n            }\n            // Remove trailing zeros.\n            for (i = xc.length; !xc[--i];)\n                xc.pop();\n        }\n    }\n    else if (rm < 0 || rm > 3 || rm !== ~~rm) {\n        throw Error(INVALID_RM);\n    }\n    return x;\n}\n/*\n * Return a string representing the value of Big x in normal or exponential notation.\n * Handles P.toExponential, P.toFixed, P.toJSON, P.toPrecision, P.toString and P.valueOf.\n *\n * x {Big}\n * id? {number} Caller id.\n *         1 toExponential\n *         2 toFixed\n *         3 toPrecision\n *         4 valueOf\n * n? {number|undefined} Caller's argument.\n * k? {number|undefined}\n */\nfunction stringify(x, id, n, k) {\n    var e, s, Big = x.constructor, z = !x.c[0];\n    if (n !== UNDEFINED) {\n        if (n !== ~~n || n < (id == 3) || n > MAX_DP) {\n            throw Error(id == 3 ? INVALID + 'precision' : INVALID_DP);\n        }\n        x = new Big(x);\n        // The index of the digit that may be rounded up.\n        n = k - x.e;\n        // Round?\n        if (x.c.length > ++k)\n            round(x, n, Big.RM);\n        // toFixed: recalculate k as x.e may have changed if value rounded up.\n        if (id == 2)\n            k = x.e + n + 1;\n        // Append zeros?\n        for (; x.c.length < k;)\n            x.c.push(0);\n    }\n    e = x.e;\n    s = x.c.join('');\n    n = s.length;\n    // Exponential notation?\n    if (id != 2 && (id == 1 || id == 3 && k <= e || e <= Big.NE || e >= Big.PE)) {\n        s = s.charAt(0) + (n > 1 ? '.' + s.slice(1) : '') + (e < 0 ? 'e' : 'e+') + e;\n        // Normal notation.\n    }\n    else if (e < 0) {\n        for (; ++e;)\n            s = '0' + s;\n        s = '0.' + s;\n    }\n    else if (e > 0) {\n        if (++e > n)\n            for (e -= n; e--;)\n                s += '0';\n        else if (e < n)\n            s = s.slice(0, e) + '.' + s.slice(e);\n    }\n    else if (n > 1) {\n        s = s.charAt(0) + '.' + s.slice(1);\n    }\n    return x.s < 0 && (!z || id == 4) ? '-' + s : s;\n}\n// Prototype/instance methods\n/*\n * Return a new Big whose value is the absolute value of this Big.\n */\nP.abs = function () {\n    var x = new this.constructor(this);\n    x.s = 1;\n    return x;\n};\n/*\n * Return 1 if the value of this Big is greater than the value of Big y,\n *       -1 if the value of this Big is less than the value of Big y, or\n *        0 if they have the same value.\n*/\nP.cmp = function (y) {\n    var isneg, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0])\n        return !xc[0] ? !yc[0] ? 0 : -j : i;\n    // Signs differ?\n    if (i != j)\n        return i;\n    isneg = i < 0;\n    // Compare exponents.\n    if (k != l)\n        return k > l ^ isneg ? 1 : -1;\n    // Compare digit by digit.\n    j = Math.max(xc.length, yc.length);\n    for (i = 0; i < j; i++) {\n        k = i < xc.length ? xc[i] : 0;\n        l = i < yc.length ? yc[i] : 0;\n        if (k != l)\n            return k > l ^ isneg ? 1 : -1;\n    }\n    return 0;\n    // old version (doesn't compare well trailing zeroes, e.g. 1.0 with 1.00)\n    // j = (k = xc.length) < (l = yc.length) ? k : l;\n    // // Compare digit by digit.\n    // for (i = -1; ++i < j;) {\n    //   if (xc[i] != yc[i]) return xc[i] > yc[i] ^ isneg ? 1 : -1;\n    // }\n    // // Compare lengths.\n    // return k == l ? 0 : k > l ^ isneg ? 1 : -1;\n};\n/*\n * Return a new Big whose value is the value of this Big divided by the value of Big y, rounded,\n * if necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.div = function (y) {\n    var Big = this.constructor, x = new Big(this), y = new Big(y), a = x.c, // dividend\n    b = y.c, // divisor\n    k = x.s == y.s ? 1 : -1, dp = Big.DP;\n    if (dp !== ~~dp || dp < 0 || dp > MAX_DP)\n        throw Error(INVALID_DP);\n    // Divisor is zero?\n    if (!b[0])\n        throw Error(DIV_BY_ZERO);\n    // Dividend is 0? Return +-0.\n    if (!a[0])\n        return new Big(k * 0);\n    var bl, bt, n, cmp, ri, bz = b.slice(), ai = bl = b.length, al = a.length, r = a.slice(0, bl), // remainder\n    rl = r.length, q = y, // quotient\n    qc = q.c = [], qi = 0, d = dp + (q.e = x.e - y.e) + 1; // number of digits of the result\n    q.s = k;\n    k = d < 0 ? 0 : d;\n    // Create version of divisor with leading zero.\n    bz.unshift(0);\n    // Add zeros to make remainder as long as divisor.\n    for (; rl++ < bl;)\n        r.push(0);\n    do {\n        // n is how many times the divisor goes into current remainder.\n        for (n = 0; n < 10; n++) {\n            // Compare divisor and remainder.\n            if (bl != (rl = r.length)) {\n                cmp = bl > rl ? 1 : -1;\n            }\n            else {\n                for (ri = -1, cmp = 0; ++ri < bl;) {\n                    if (b[ri] != r[ri]) {\n                        cmp = b[ri] > r[ri] ? 1 : -1;\n                        break;\n                    }\n                }\n            }\n            // If divisor < remainder, subtract divisor from remainder.\n            if (cmp < 0) {\n                // Remainder can't be more than 1 digit longer than divisor.\n                // Equalise lengths using divisor with extra leading zero?\n                for (bt = rl == bl ? b : bz; rl;) {\n                    if (r[--rl] < bt[rl]) {\n                        ri = rl;\n                        for (; ri && !r[--ri];)\n                            r[ri] = 9;\n                        --r[ri];\n                        r[rl] += 10;\n                    }\n                    r[rl] -= bt[rl];\n                }\n                for (; !r[0];)\n                    r.shift();\n            }\n            else {\n                break;\n            }\n        }\n        // Add the digit n to the result array.\n        qc[qi++] = cmp ? n : ++n;\n        // Update the remainder.\n        if (r[0] && cmp)\n            r[rl] = a[ai] || 0;\n        else\n            r = [a[ai]];\n    } while ((ai++ < al || r[0] !== UNDEFINED) && k--);\n    // Leading zero? Do not remove if result is simply zero (qi == 1).\n    if (!qc[0] && qi != 1) {\n        // There can't be more than one zero.\n        qc.shift();\n        q.e--;\n    }\n    // Round?\n    if (qi > d)\n        round(q, dp, Big.RM, r[0] !== UNDEFINED);\n    return q;\n};\n/*\n * Return true if the value of this Big is equal to the value of Big y, otherwise return false.\n */\nP.eq = function (y) {\n    return !this.cmp(y);\n};\n/*\n * Return true if the value of this Big is greater than the value of Big y, otherwise return\n * false.\n */\nP.gt = function (y) {\n    return this.cmp(y) > 0;\n};\n/*\n * Return true if the value of this Big is greater than or equal to the value of Big y, otherwise\n * return false.\n */\nP.gte = function (y) {\n    return this.cmp(y) > -1;\n};\n/*\n * Return true if the value of this Big is less than the value of Big y, otherwise return false.\n */\nP.lt = function (y) {\n    return this.cmp(y) < 0;\n};\n/*\n * Return true if the value of this Big is less than or equal to the value of Big y, otherwise\n * return false.\n */\nP.lte = function (y) {\n    return this.cmp(y) < 1;\n};\n/*\n * Return a new Big whose value is the value of this Big minus the value of Big y.\n */\nP.minus = P.sub = function (y) {\n    var i, j, t, xlty, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    // Signs differ?\n    if (a != b) {\n        y.s = -b;\n        return x.plus(y);\n    }\n    var xc = x.c.slice(), xe = x.e, yc = y.c, ye = y.e;\n    // Either zero?\n    if (!xc[0] || !yc[0]) {\n        // y is non-zero? x is non-zero? Or both are zero.\n        return yc[0] ? (y.s = -b, y) : new Big(xc[0] ? x : 0);\n    }\n    // Determine which is the bigger number. Prepend zeros to equalise exponents.\n    if (a = xe - ye) {\n        if (xlty = a < 0) {\n            a = -a;\n            t = xc;\n        }\n        else {\n            ye = xe;\n            t = yc;\n        }\n        t.reverse();\n        for (b = a; b--;)\n            t.push(0);\n        t.reverse();\n    }\n    else {\n        // Exponents equal. Check digit by digit.\n        j = ((xlty = xc.length < yc.length) ? xc : yc).length;\n        for (a = b = 0; b < j; b++) {\n            if (xc[b] != yc[b]) {\n                xlty = xc[b] < yc[b];\n                break;\n            }\n        }\n    }\n    // x < y? Point xc to the array of the bigger number.\n    if (xlty) {\n        t = xc;\n        xc = yc;\n        yc = t;\n        y.s = -y.s;\n    }\n    /*\n     * Append zeros to xc if shorter. No need to add zeros to yc if shorter as subtraction only\n     * needs to start at yc.length.\n     */\n    if ((b = (j = yc.length) - (i = xc.length)) > 0)\n        for (; b--;)\n            xc[i++] = 0;\n    // Subtract yc from xc.\n    for (b = i; j > a;) {\n        if (xc[--j] < yc[j]) {\n            for (i = j; i && !xc[--i];)\n                xc[i] = 9;\n            --xc[i];\n            xc[j] += 10;\n        }\n        xc[j] -= yc[j];\n    }\n    // Remove trailing zeros.\n    for (; xc[--b] === 0;)\n        xc.pop();\n    // Remove leading zeros and adjust exponent accordingly.\n    for (; xc[0] === 0;) {\n        xc.shift();\n        --ye;\n    }\n    if (!xc[0]) {\n        // n - n = +0\n        y.s = 1;\n        // Result must be zero.\n        xc = [ye = 0];\n    }\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a new Big whose value is the value of this Big modulo the value of Big y.\n */\nP.mod = function (y) {\n    var ygtx, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    if (!y.c[0])\n        throw Error(DIV_BY_ZERO);\n    x.s = y.s = 1;\n    ygtx = y.cmp(x) == 1;\n    x.s = a;\n    y.s = b;\n    if (ygtx)\n        return new Big(x);\n    a = Big.DP;\n    b = Big.RM;\n    Big.DP = Big.RM = 0;\n    x = x.div(y);\n    Big.DP = a;\n    Big.RM = b;\n    return this.minus(x.times(y));\n};\n/*\n * Return a new Big whose value is the value of this Big plus the value of Big y.\n */\nP.plus = P.add = function (y) {\n    var t, Big = this.constructor, x = new Big(this), y = new Big(y), a = x.s, b = y.s;\n    // Signs differ?\n    if (a != b) {\n        y.s = -b;\n        return x.minus(y);\n    }\n    var xe = x.e, xc = x.c, ye = y.e, yc = y.c;\n    // Either zero? y is non-zero? x is non-zero? Or both are zero.\n    if (!xc[0] || !yc[0])\n        return yc[0] ? y : new Big(xc[0] ? x : a * 0);\n    xc = xc.slice();\n    // Prepend zeros to equalise exponents.\n    // Note: reverse faster than unshifts.\n    if (a = xe - ye) {\n        if (a > 0) {\n            ye = xe;\n            t = yc;\n        }\n        else {\n            a = -a;\n            t = xc;\n        }\n        t.reverse();\n        for (; a--;)\n            t.push(0);\n        t.reverse();\n    }\n    // Point xc to the longer array.\n    if (xc.length - yc.length < 0) {\n        t = yc;\n        yc = xc;\n        xc = t;\n    }\n    a = yc.length;\n    // Only start adding at yc.length - 1 as the further digits of xc can be left as they are.\n    for (b = 0; a; xc[a] %= 10)\n        b = (xc[--a] = xc[a] + yc[a] + b) / 10 | 0;\n    // No need to check for zero, as +x + +y != 0 && -x + -y != 0\n    if (b) {\n        xc.unshift(b);\n        ++ye;\n    }\n    // Remove trailing zeros.\n    for (a = xc.length; xc[--a] === 0;)\n        xc.pop();\n    y.c = xc;\n    y.e = ye;\n    return y;\n};\n/*\n * Return a Big whose value is the value of this Big raised to the power n.\n * If n is negative, round to a maximum of Big.DP decimal places using rounding\n * mode Big.RM.\n *\n * n {number} Integer, -MAX_POWER to MAX_POWER inclusive.\n */\nP.pow = function (n) {\n    var Big = this.constructor, x = new Big(this), y = new Big(1), one = new Big(1), isneg = n < 0;\n    if (n !== ~~n || n < -MAX_POWER || n > MAX_POWER)\n        throw Error(INVALID + 'exponent');\n    if (isneg)\n        n = -n;\n    for (;;) {\n        if (n & 1)\n            y = y.times(x);\n        n >>= 1;\n        if (!n)\n            break;\n        x = x.times(x);\n    }\n    return isneg ? one.div(y) : y;\n};\n/*\n * Return a new Big whose value is the value of this Big rounded using rounding mode rm\n * to a maximum of dp decimal places, or, if dp is negative, to an integer which is a\n * multiple of 10**-dp.\n * If dp is not specified, round to 0 decimal places.\n * If rm is not specified, use Big.RM.\n *\n * dp? {number} Integer, -MAX_DP to MAX_DP inclusive.\n * rm? 0, 1, 2 or 3 (ROUND_DOWN, ROUND_HALF_UP, ROUND_HALF_EVEN, ROUND_UP)\n */\nP.round = function (dp, rm) {\n    var Big = this.constructor;\n    if (dp === UNDEFINED)\n        dp = 0;\n    else if (dp !== ~~dp || dp < -MAX_DP || dp > MAX_DP)\n        throw Error(INVALID_DP);\n    return round(new Big(this), dp, rm === UNDEFINED ? Big.RM : rm);\n};\n/*\n * Return a new Big whose value is the square root of the value of this Big, rounded, if\n * necessary, to a maximum of Big.DP decimal places using rounding mode Big.RM.\n */\nP.sqrt = function () {\n    var r, c, t, Big = this.constructor, x = new Big(this), s = x.s, e = x.e, half = new Big(0.5);\n    // Zero?\n    if (!x.c[0])\n        return new Big(x);\n    // Negative?\n    if (s < 0)\n        throw Error(NAME + 'No square root');\n    // Estimate.\n    s = Math.sqrt(x + '');\n    // Math.sqrt underflow/overflow?\n    // Re-estimate: pass x coefficient to Math.sqrt as integer, then adjust the result exponent.\n    if (s === 0 || s === 1 / 0) {\n        c = x.c.join('');\n        if (!(c.length + e & 1))\n            c += '0';\n        s = Math.sqrt(c);\n        e = ((e + 1) / 2 | 0) - (e < 0 || e & 1);\n        r = new Big((s == 1 / 0 ? '1e' : (s = s.toExponential()).slice(0, s.indexOf('e') + 1)) + e);\n    }\n    else {\n        r = new Big(s);\n    }\n    e = r.e + (Big.DP += 4);\n    // Newton-Raphson iteration.\n    do {\n        t = r;\n        r = half.times(t.plus(x.div(t)));\n    } while (t.c.slice(0, e).join('') !== r.c.slice(0, e).join(''));\n    return round(r, Big.DP -= 4, Big.RM);\n};\n/*\n * Return a new Big whose value is the value of this Big times the value of Big y.\n */\nP.times = P.mul = function (y) {\n    var c, Big = this.constructor, x = new Big(this), y = new Big(y), xc = x.c, yc = y.c, a = xc.length, b = yc.length, i = x.e, j = y.e;\n    // Determine sign of result.\n    y.s = x.s == y.s ? 1 : -1;\n    // Return signed 0 if either 0.\n    if (!xc[0] || !yc[0])\n        return new Big(y.s * 0);\n    // Initialise exponent of result as x.e + y.e.\n    y.e = i + j;\n    // If array xc has fewer digits than yc, swap xc and yc, and lengths.\n    if (a < b) {\n        c = xc;\n        xc = yc;\n        yc = c;\n        j = a;\n        a = b;\n        b = j;\n    }\n    // Initialise coefficient array of result with zeros.\n    for (c = new Array(j = a + b); j--;)\n        c[j] = 0;\n    // Multiply.\n    // i is initially xc.length.\n    for (i = b; i--;) {\n        b = 0;\n        // a is yc.length.\n        for (j = a + i; j > i;) {\n            // Current sum of products at this digit position, plus carry.\n            b = c[j] + yc[i] * xc[j - i - 1] + b;\n            c[j--] = b % 10;\n            // carry\n            b = b / 10 | 0;\n        }\n        c[j] = (c[j] + b) % 10;\n    }\n    // Increment result exponent if there is a final carry, otherwise remove leading zero.\n    if (b)\n        ++y.e;\n    else\n        c.shift();\n    // Remove trailing zeros.\n    for (i = c.length; !c[--i];)\n        c.pop();\n    y.c = c;\n    return y;\n};\n/*\n * Return a string representing the value of this Big in exponential notation to dp fixed decimal\n * places and rounded using Big.RM.\n *\n * dp? {number} Integer, 0 to MAX_DP inclusive.\n */\nP.toExponential = function (dp) {\n    return stringify(this, 1, dp, dp);\n};\n/*\n * Return a string representing the value of this Big in normal notation to dp fixed decimal\n * places and rounded using Big.RM.\n *\n * dp? {number} Integer, 0 to MAX_DP inclusive.\n *\n * (-0).toFixed(0) is '0', but (-0.1).toFixed(0) is '-0'.\n * (-0).toFixed(1) is '0.0', but (-0.01).toFixed(1) is '-0.0'.\n */\nP.toFixed = function (dp) {\n    return stringify(this, 2, dp, this.e + dp);\n};\n/*\n * Return a string representing the value of this Big rounded to sd significant digits using\n * Big.RM. Use exponential notation if sd is less than the number of digits necessary to represent\n * the integer part of the value in normal notation.\n *\n * sd {number} Integer, 1 to MAX_DP inclusive.\n */\nP.toPrecision = function (sd) {\n    return stringify(this, 3, sd, sd - 1);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Omit the sign for negative zero.\n */\nP.toString = function () {\n    return stringify(this);\n};\n/*\n * Return a string representing the value of this Big.\n * Return exponential notation if this Big has a positive exponent equal to or greater than\n * Big.PE, or a negative exponent equal to or less than Big.NE.\n * Include the sign for negative zero.\n */\nP.valueOf = P.toJSON = function () {\n    return stringify(this, 4);\n};\n// Export\nexport var Big = _Big_();\nexport default Big;\n","import Decimal from \"./lib/big.js\";\nimport { FSharpRef } from \"./Types.js\";\nexport default Decimal;\nexport const get_Zero = new Decimal(0);\nexport const get_One = new Decimal(1);\nexport const get_MinusOne = new Decimal(-1);\nexport const get_MaxValue = new Decimal(\"79228162514264337593543950335\");\nexport const get_MinValue = new Decimal(\"-79228162514264337593543950335\");\nexport function compare(x, y) {\n    return x.cmp(y);\n}\nexport function equals(x, y) {\n    return !x.cmp(y);\n}\nexport function abs(x) {\n    return x.abs();\n}\nexport function round(x, digits = 0) {\n    return x.round(digits, 2 /* ROUND_HALF_EVEN */);\n}\nexport function truncate(x) {\n    return x.round(0, 0 /* ROUND_DOWN */);\n}\nexport function ceiling(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 3 /* ROUND_UP */ : 0 /* ROUND_DOWN */);\n}\nexport function floor(x) {\n    return x.round(0, x.cmp(0) >= 0 ? 0 /* ROUND_DOWN */ : 3 /* ROUND_UP */);\n}\nexport function pow(x, n) {\n    return x.pow(n);\n}\nexport function sqrt(x) {\n    return x.sqrt();\n}\nexport function op_Addition(x, y) {\n    return x.add(y);\n}\nexport function op_Subtraction(x, y) {\n    return x.sub(y);\n}\nexport function op_Multiply(x, y) {\n    return x.mul(y);\n}\nexport function op_Division(x, y) {\n    return x.div(y);\n}\nexport function op_Modulus(x, y) {\n    return x.mod(y);\n}\nexport function op_UnaryNegation(x) {\n    const x2 = new Decimal(x);\n    x2.s = -x2.s || 0;\n    return x2;\n}\nexport const add = op_Addition;\nexport const subtract = op_Subtraction;\nexport const multiply = op_Multiply;\nexport const divide = op_Division;\nexport const remainder = op_Modulus;\nexport const negate = op_UnaryNegation;\nexport function toString(x) {\n    return x.toString();\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = new Decimal(str.trim());\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function parse(str) {\n    const defValue = new FSharpRef(get_Zero);\n    if (tryParse(str, defValue)) {\n        return defValue.contents;\n    }\n    else {\n        throw new Error(\"Input string was not in a correct format.\");\n    }\n}\nexport function toNumber(x) {\n    return +x;\n}\nfunction decimalToHex(dec, bitSize) {\n    const hex = new Uint8Array(bitSize / 4 | 0);\n    let hexCount = 1;\n    for (let d = 0; d < dec.length; d++) {\n        let value = dec[d];\n        for (let i = 0; i < hexCount; i++) {\n            const digit = hex[i] * 10 + value | 0;\n            hex[i] = digit & 0xF;\n            value = digit >> 4;\n        }\n        if (value !== 0) {\n            hex[hexCount++] = value;\n        }\n    }\n    return hex.slice(0, hexCount); // digits in reverse order\n}\nfunction hexToDecimal(hex, bitSize) {\n    const dec = new Uint8Array(bitSize * 301 / 1000 + 1 | 0);\n    let decCount = 1;\n    for (let d = hex.length - 1; d >= 0; d--) {\n        let carry = hex[d];\n        for (let i = 0; i < decCount; i++) {\n            const val = dec[i] * 16 + carry | 0;\n            dec[i] = (val % 10) | 0;\n            carry = (val / 10) | 0;\n        }\n        while (carry > 0) {\n            dec[decCount++] = (carry % 10) | 0;\n            carry = (carry / 10) | 0;\n        }\n    }\n    return dec.slice(0, decCount); // digits in reverse order\n}\nfunction setInt32Bits(hexDigits, bits, offset) {\n    for (let i = 0; i < 8; i++) {\n        hexDigits[offset + i] = (bits >> (i * 4)) & 0xF;\n    }\n}\nfunction getInt32Bits(hexDigits, offset) {\n    let bits = 0;\n    for (let i = 0; i < 8; i++) {\n        bits = bits | (hexDigits[offset + i] << (i * 4));\n    }\n    return bits;\n}\nexport function fromIntArray(bits) {\n    return fromInts(bits[0], bits[1], bits[2], bits[3]);\n}\nexport function fromInts(low, mid, high, signExp) {\n    const isNegative = signExp < 0;\n    const scale = (signExp >> 16) & 0x7F;\n    return fromParts(low, mid, high, isNegative, scale);\n}\nexport function fromParts(low, mid, high, isNegative, scale) {\n    const bitSize = 96;\n    const hexDigits = new Uint8Array(bitSize / 4);\n    setInt32Bits(hexDigits, low, 0);\n    setInt32Bits(hexDigits, mid, 8);\n    setInt32Bits(hexDigits, high, 16);\n    const decDigits = hexToDecimal(hexDigits, bitSize);\n    scale = scale & 0x7F;\n    const big = new Decimal(0);\n    big.c = Array.from(decDigits.reverse());\n    big.e = decDigits.length - scale - 1;\n    big.s = isNegative ? -1 : 1;\n    const d = new Decimal(big);\n    return d;\n}\nexport function getBits(d) {\n    const bitSize = 96;\n    const decDigits = Uint8Array.from(d.c);\n    const hexDigits = decimalToHex(decDigits, bitSize);\n    const low = getInt32Bits(hexDigits, 0);\n    const mid = getInt32Bits(hexDigits, 8);\n    const high = getInt32Bits(hexDigits, 16);\n    const decStr = d.toString();\n    const dotPos = decStr.indexOf(\".\");\n    const scale = dotPos < 0 ? 0 : decStr.length - dotPos - 1;\n    const signExp = ((scale & 0x7F) << 16) | (d.s < 0 ? 0x80000000 : 0);\n    return [low, mid, high, signExp];\n}\nexport function makeRangeStepFunction(step, last) {\n    const stepComparedWithZero = step.cmp(get_Zero);\n    if (stepComparedWithZero === 0) {\n        throw new Error(\"The step of a range cannot be zero\");\n    }\n    const stepGreaterThanZero = stepComparedWithZero > 0;\n    return (x) => {\n        const comparedWithLast = x.cmp(last);\n        if ((stepGreaterThanZero && comparedWithLast <= 0)\n            || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n            return [x, op_Addition(x, step)];\n        }\n        else {\n            return undefined;\n        }\n    };\n}\n","// export type decimal = Decimal;\nexport var NumberStyles;\n(function (NumberStyles) {\n    // None = 0x00000000,\n    // AllowLeadingWhite = 0x00000001,\n    // AllowTrailingWhite = 0x00000002,\n    // AllowLeadingSign = 0x00000004,\n    // AllowTrailingSign = 0x00000008,\n    // AllowParentheses = 0x00000010,\n    // AllowDecimalPoint = 0x00000020,\n    // AllowThousands = 0x00000040,\n    // AllowExponent = 0x00000080,\n    // AllowCurrencySymbol = 0x00000100,\n    NumberStyles[NumberStyles[\"AllowHexSpecifier\"] = 512] = \"AllowHexSpecifier\";\n    // Integer = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign,\n    // HexNumber = AllowLeadingWhite | AllowTrailingWhite | AllowHexSpecifier,\n    // Number = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //          AllowTrailingSign | AllowDecimalPoint | AllowThousands,\n    // Float = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign |\n    //         AllowDecimalPoint | AllowExponent,\n    // Currency = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //            AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol,\n    // Any = AllowLeadingWhite | AllowTrailingWhite | AllowLeadingSign | AllowTrailingSign |\n    //       AllowParentheses | AllowDecimalPoint | AllowThousands | AllowCurrencySymbol | AllowExponent,\n})(NumberStyles || (NumberStyles = {}));\nfunction validResponse(regexMatch, radix) {\n    const [/*all*/ , sign, prefix, digits] = regexMatch;\n    return {\n        sign: sign || \"\",\n        prefix: prefix || \"\",\n        digits,\n        radix,\n    };\n}\nfunction getRange(unsigned, bitsize) {\n    switch (bitsize) {\n        case 8: return unsigned ? [0, 255] : [-128, 127];\n        case 16: return unsigned ? [0, 65535] : [-32768, 32767];\n        case 32: return unsigned ? [0, 4294967295] : [-2147483648, 2147483647];\n        default: throw new Error(\"Invalid bit size.\");\n    }\n}\nfunction getInvalidDigits(radix) {\n    switch (radix) {\n        case 2: return /[^0-1]/;\n        case 8: return /[^0-7]/;\n        case 10: return /[^0-9]/;\n        case 16: return /[^0-9a-fA-F]/;\n        default:\n            throw new Error(\"Invalid Base.\");\n    }\n}\nfunction getRadix(prefix, style) {\n    if (style & NumberStyles.AllowHexSpecifier) {\n        return 16;\n    }\n    else {\n        switch (prefix) {\n            case \"0b\":\n            case \"0B\": return 2;\n            case \"0o\":\n            case \"0O\": return 8;\n            case \"0x\":\n            case \"0X\": return 16;\n            default: return 10;\n        }\n    }\n}\nexport function isValid(str, style, radix) {\n    const integerRegex = /^\\s*([\\+\\-])?(0[xXoObB])?([0-9a-fA-F]+)\\s*$/;\n    const res = integerRegex.exec(str.replace(/_/g, \"\"));\n    if (res != null) {\n        const [/*all*/ , /*sign*/ , prefix, digits] = res;\n        radix = radix || getRadix(prefix, style);\n        const invalidDigits = getInvalidDigits(radix);\n        if (!invalidDigits.test(digits)) {\n            return validResponse(res, radix);\n        }\n    }\n    return null;\n}\nexport function parse(str, style, unsigned, bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        let v = Number.parseInt(res.sign + res.digits, res.radix);\n        if (!Number.isNaN(v)) {\n            const [umin, umax] = getRange(true, bitsize);\n            if (!unsigned && res.radix !== 10 && v >= umin && v <= umax) {\n                v = v << (32 - bitsize) >> (32 - bitsize);\n            }\n            const [min, max] = getRange(unsigned, bitsize);\n            if (v >= min && v <= max) {\n                return v;\n            }\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function op_UnaryNegation_Int8(x) {\n    return x === -128 ? x : -x;\n}\nexport function op_UnaryNegation_Int16(x) {\n    return x === -32768 ? x : -x;\n}\nexport function op_UnaryNegation_Int32(x) {\n    return x === -2147483648 ? x : -x;\n}\n","// Adapted from: https://github.com/dcodeIO/long.js/blob/master/src/long.js\n// Apache License 2.0: https://github.com/dcodeIO/long.js/blob/master/LICENSE\n/* tslint:disable */\nimport { symbol } from \"../Numeric.js\";\n/**\n * wasm optimizations, to do native i64 multiplication and divide\n */\nvar wasm = null;\ntry {\n    wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([\n        0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11\n    ])), {}).exports;\n}\ncatch (e) {\n    // no wasm support :(\n}\n/**\n * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\n *  See the from* functions below for more convenient ways of constructing Longs.\n * @exports Long\n * @class A Long class for representing a 64 bit two's-complement integer value.\n * @param {number} low The low (signed) 32 bits of the long\n * @param {number} high The high (signed) 32 bits of the long\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @constructor\n */\nexport function Long(low, high, unsigned) {\n    /**\n     * The low 32 bits as a signed value.\n     * @type {number}\n     */\n    this.low = low | 0;\n    /**\n     * The high 32 bits as a signed value.\n     * @type {number}\n     */\n    this.high = high | 0;\n    /**\n     * Whether unsigned or not.\n     * @type {boolean}\n     */\n    this.unsigned = !!unsigned;\n}\nLong.prototype.GetHashCode = function () {\n    let h1 = this.unsigned ? 1 : 0;\n    h1 = ((h1 << 5) + h1) ^ this.high;\n    h1 = ((h1 << 5) + h1) ^ this.low;\n    return h1;\n};\nLong.prototype.Equals = function (x) { return equals(this, x); };\nLong.prototype.CompareTo = function (x) { return compare(this, x); };\nLong.prototype.toString = function (radix) { return toString(this, radix); };\nLong.prototype.toJSON = function () { return toString(this); };\nLong.prototype[symbol] = function () {\n    const x = this;\n    return {\n        multiply: y => multiply(x, y),\n        toPrecision: sd => String(x) + (0).toPrecision(sd).substr(1),\n        toExponential: dp => String(x) + (0).toExponential(dp).substr(1),\n        toFixed: dp => String(x) + (0).toFixed(dp).substr(1),\n        toHex: () => toString(x.unsigned ? x : fromBytes(toBytes(x), true), 16),\n    };\n};\n// The internal representation of a long is the two given signed, 32-bit values.\n// We use 32-bit pieces because these are the size of integers on which\n// Javascript performs bit-operations.  For operations like addition and\n// multiplication, we split each number into 16 bit pieces, which can easily be\n// multiplied within Javascript's floating-point representation without overflow\n// or change in sign.\n//\n// In the algorithms below, we frequently reduce the negative case to the\n// positive case by negating the input(s) and then post-processing the result.\n// Note that we must ALWAYS check specially whether those values are MIN_VALUE\n// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n// a positive number, it overflows back into a negative).  Not handling this\n// case would often result in infinite recursion.\n//\n// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\n// methods on which they depend.\n/**\n * An indicator used to reliably determine if an object is a Long or not.\n * @type {boolean}\n * @const\n * @private\n */\nLong.prototype.__isLong__;\nObject.defineProperty(Long.prototype, \"__isLong__\", { value: true });\n/**\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n * @inner\n */\nexport function isLong(obj) {\n    return (obj && obj[\"__isLong__\"]) === true;\n}\n/**\n * Tests if the specified object is a Long.\n * @function\n * @param {*} obj Object\n * @returns {boolean}\n */\n// Long.isLong = isLong;\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object}\n * @inner\n */\nvar INT_CACHE = {};\n/**\n * A cache of the Long representations of small unsigned integer values.\n * @type {!Object}\n * @inner\n */\nvar UINT_CACHE = {};\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromInt(value, unsigned) {\n    var obj, cachedObj, cache;\n    if (unsigned) {\n        value >>>= 0;\n        if (cache = (0 <= value && value < 256)) {\n            cachedObj = UINT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\n        if (cache)\n            UINT_CACHE[value] = obj;\n        return obj;\n    }\n    else {\n        value |= 0;\n        if (cache = (-128 <= value && value < 128)) {\n            cachedObj = INT_CACHE[value];\n            if (cachedObj)\n                return cachedObj;\n        }\n        obj = fromBits(value, value < 0 ? -1 : 0, false);\n        if (cache)\n            INT_CACHE[value] = obj;\n        return obj;\n    }\n}\n/**\n * Returns a Long representing the given 32 bit integer value.\n * @function\n * @param {number} value The 32 bit integer in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromInt = fromInt;\n/**\n * @param {number} value\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromNumber(value, unsigned) {\n    if (isNaN(value))\n        return unsigned ? UZERO : ZERO;\n    if (unsigned) {\n        if (value < 0)\n            return UZERO;\n        if (value >= TWO_PWR_64_DBL)\n            return MAX_UNSIGNED_VALUE;\n    }\n    else {\n        if (value <= -TWO_PWR_63_DBL)\n            return MIN_VALUE;\n        if (value + 1 >= TWO_PWR_63_DBL)\n            return MAX_VALUE;\n    }\n    if (value < 0)\n        return negate(fromNumber(-value, unsigned));\n    return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\n}\n/**\n * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\n * @function\n * @param {number} value The number in question\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromNumber = fromNumber;\n/**\n * @param {number} lowBits\n * @param {number} highBits\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromBits(lowBits, highBits, unsigned) {\n    return new Long(lowBits, highBits, unsigned);\n}\n/**\n * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\n *  assumed to use 32 bits.\n * @function\n * @param {number} lowBits The low 32 bits\n * @param {number} highBits The high 32 bits\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromBits = fromBits;\n/**\n * @function\n * @param {number} base\n * @param {number} exponent\n * @returns {number}\n * @inner\n */\nvar pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\n/**\n * @param {string} str\n * @param {(boolean|number)=} unsigned\n * @param {number=} radix\n * @returns {!Long}\n * @inner\n */\nexport function fromString(str, unsigned, radix) {\n    if (str.length === 0)\n        throw Error('empty string');\n    if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\n        return ZERO;\n    if (typeof unsigned === 'number') {\n        // For goog.math.long compatibility\n        radix = unsigned,\n            unsigned = false;\n    }\n    else {\n        unsigned = !!unsigned;\n    }\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    var p = str.indexOf('-');\n    if (p > 0)\n        throw Error('interior hyphen');\n    else if (p === 0) {\n        return negate(fromString(str.substring(1), unsigned, radix));\n    }\n    // Do several (8) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 8));\n    var result = ZERO;\n    for (var i = 0; i < str.length; i += 8) {\n        var size = Math.min(8, str.length - i), value = parseInt(str.substring(i, i + size), radix);\n        if (size < 8) {\n            var power = fromNumber(pow_dbl(radix, size));\n            result = add(multiply(result, power), fromNumber(value));\n        }\n        else {\n            result = multiply(result, radixToPower);\n            result = add(result, fromNumber(value));\n        }\n    }\n    result.unsigned = unsigned;\n    return result;\n}\n/**\n * Returns a Long representation of the given string, written using the specified radix.\n * @function\n * @param {string} str The textual representation of the Long\n * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to signed\n * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\n * @returns {!Long} The corresponding Long value\n */\n// Long.fromString = fromString;\n/**\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\n * @param {boolean=} unsigned\n * @returns {!Long}\n * @inner\n */\nexport function fromValue(val, unsigned) {\n    if (typeof val === 'number')\n        return fromNumber(val, unsigned);\n    if (typeof val === 'string')\n        return fromString(val, unsigned);\n    // Throws for non-objects, converts non-instanceof Long:\n    return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);\n}\n/**\n * Converts the specified value to a Long using the appropriate from* function for its type.\n * @function\n * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {!Long}\n */\n// Long.fromValue = fromValue;\n// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\n// no runtime penalty for these.\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_16_DBL = 1 << 16;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_24_DBL = 1 << 24;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\n/**\n * @type {number}\n * @const\n * @inner\n */\nvar TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\n/**\n * @type {!Long}\n * @const\n * @inner\n */\nvar TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\n/**\n * @type {!Long}\n * @inner\n */\nexport var ZERO = fromInt(0);\n/**\n * Signed zero.\n * @type {!Long}\n */\n// Long.ZERO = ZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UZERO = fromInt(0, true);\n/**\n * Unsigned zero.\n * @type {!Long}\n */\n// Long.UZERO = UZERO;\n/**\n * @type {!Long}\n * @inner\n */\nexport var ONE = fromInt(1);\n/**\n * Signed one.\n * @type {!Long}\n */\n// Long.ONE = ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var UONE = fromInt(1, true);\n/**\n * Unsigned one.\n * @type {!Long}\n */\n// Long.UONE = UONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var NEG_ONE = fromInt(-1);\n/**\n * Signed negative one.\n * @type {!Long}\n */\n// Long.NEG_ONE = NEG_ONE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_VALUE = fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0, false);\n/**\n * Maximum signed value.\n * @type {!Long}\n */\n// Long.MAX_VALUE = MAX_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF | 0, 0xFFFFFFFF | 0, true);\n/**\n * Maximum unsigned value.\n * @type {!Long}\n */\n// Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\n/**\n * @type {!Long}\n * @inner\n */\nexport var MIN_VALUE = fromBits(0, 0x80000000 | 0, false);\n/**\n * Minimum signed value.\n * @type {!Long}\n */\n// Long.MIN_VALUE = MIN_VALUE;\n/**\n * @alias Long.prototype\n * @inner\n */\n// var LongPrototype = Long.prototype;\n/**\n * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\n * @this {!Long}\n * @returns {number}\n */\nexport function toInt($this) {\n    return $this.unsigned ? $this.low >>> 0 : $this.low;\n}\n;\n/**\n * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\n * @this {!Long}\n * @returns {number}\n */\nexport function toNumber($this) {\n    if ($this.unsigned)\n        return (($this.high >>> 0) * TWO_PWR_32_DBL) + ($this.low >>> 0);\n    return $this.high * TWO_PWR_32_DBL + ($this.low >>> 0);\n}\n;\n/**\n * Converts the Long to a string written in the specified radix.\n * @this {!Long}\n * @param {number=} radix Radix (2-36), defaults to 10\n * @returns {string}\n * @override\n * @throws {RangeError} If `radix` is out of range\n */\nexport function toString($this, radix) {\n    radix = radix || 10;\n    if (radix < 2 || 36 < radix)\n        throw RangeError('radix');\n    if (isZero($this))\n        return '0';\n    if (isNegative($this)) { // Unsigned Longs are never negative\n        if (equals($this, MIN_VALUE)) {\n            // We need to change the Long value before it can be negated, so we remove\n            // the bottom-most digit in this base and then recurse to do the rest.\n            var radixLong = fromNumber(radix), div = divide($this, radixLong), rem1 = subtract(multiply(div, radixLong), $this);\n            return toString(div, radix) + toInt(rem1).toString(radix);\n        }\n        else\n            return '-' + toString(negate($this), radix);\n    }\n    // Do several (6) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated div.\n    var radixToPower = fromNumber(pow_dbl(radix, 6), $this.unsigned), rem = $this;\n    var result = '';\n    while (true) {\n        var remDiv = divide(rem, radixToPower), intval = toInt(subtract(rem, multiply(remDiv, radixToPower))) >>> 0, digits = intval.toString(radix);\n        rem = remDiv;\n        if (isZero(rem))\n            return digits + result;\n        else {\n            while (digits.length < 6)\n                digits = '0' + digits;\n            result = '' + digits + result;\n        }\n    }\n}\n;\n/**\n * Gets the high 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed high bits\n */\nexport function getHighBits($this) {\n    return $this.high;\n}\n;\n/**\n * Gets the high 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned high bits\n */\nexport function getHighBitsUnsigned($this) {\n    return $this.high >>> 0;\n}\n;\n/**\n * Gets the low 32 bits as a signed integer.\n * @this {!Long}\n * @returns {number} Signed low bits\n */\nexport function getLowBits($this) {\n    return $this.low;\n}\n;\n/**\n * Gets the low 32 bits as an unsigned integer.\n * @this {!Long}\n * @returns {number} Unsigned low bits\n */\nexport function getLowBitsUnsigned($this) {\n    return $this.low >>> 0;\n}\n;\n/**\n * Gets the number of bits needed to represent the absolute value of this Long.\n * @this {!Long}\n * @returns {number}\n */\nexport function getNumBitsAbs($this) {\n    if (isNegative($this)) // Unsigned Longs are never negative\n        return equals($this, MIN_VALUE) ? 64 : getNumBitsAbs(negate($this));\n    var val = $this.high != 0 ? $this.high : $this.low;\n    for (var bit = 31; bit > 0; bit--)\n        if ((val & (1 << bit)) != 0)\n            break;\n    return $this.high != 0 ? bit + 33 : bit + 1;\n}\n;\n/**\n * Tests if this Long's value equals zero.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isZero($this) {\n    return $this.high === 0 && $this.low === 0;\n}\n;\n/**\n * Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.\n * @returns {boolean}\n */\n// LongPrototype.eqz = LongPrototype.isZero;\n/**\n * Tests if this Long's value is negative.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isNegative($this) {\n    return !$this.unsigned && $this.high < 0;\n}\n;\n/**\n * Tests if this Long's value is positive.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isPositive($this) {\n    return $this.unsigned || $this.high >= 0;\n}\n;\n/**\n * Tests if this Long's value is odd.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isOdd($this) {\n    return ($this.low & 1) === 1;\n}\n;\n/**\n * Tests if this Long's value is even.\n * @this {!Long}\n * @returns {boolean}\n */\nexport function isEven($this) {\n    return ($this.low & 1) === 0;\n}\n;\n/**\n * Tests if this Long's value equals the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function equals($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if ($this.unsigned !== other.unsigned && ($this.high >>> 31) === 1 && (other.high >>> 31) === 1)\n        return false;\n    return $this.high === other.high && $this.low === other.low;\n}\n;\n/**\n * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.eq = LongPrototype.equals;\n/**\n * Tests if this Long's value differs from the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function notEquals($this, other) {\n    return !equals($this, /* validates */ other);\n}\n;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.neq = LongPrototype.notEquals;\n/**\n * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ne = LongPrototype.notEquals;\n/**\n * Tests if this Long's value is less than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThan($this, other) {\n    return compare($this, /* validates */ other) < 0;\n}\n;\n/**\n * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lt = LongPrototype.lessThan;\n/**\n * Tests if this Long's value is less than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function lessThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) <= 0;\n}\n;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.lte = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.le = LongPrototype.lessThanOrEqual;\n/**\n * Tests if this Long's value is greater than the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThan($this, other) {\n    return compare($this, /* validates */ other) > 0;\n}\n;\n/**\n * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gt = LongPrototype.greaterThan;\n/**\n * Tests if this Long's value is greater than or equal the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\nexport function greaterThanOrEqual($this, other) {\n    return compare($this, /* validates */ other) >= 0;\n}\n;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.gte = LongPrototype.greaterThanOrEqual;\n/**\n * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {boolean}\n */\n// LongPrototype.ge = LongPrototype.greaterThanOrEqual;\n/**\n * Compares this Long's value with the specified's.\n * @this {!Long}\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\nexport function compare($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    if (equals($this, other))\n        return 0;\n    var thisNeg = isNegative($this), otherNeg = isNegative(other);\n    if (thisNeg && !otherNeg)\n        return -1;\n    if (!thisNeg && otherNeg)\n        return 1;\n    // At this point the sign bits are the same\n    if (!$this.unsigned)\n        return isNegative(subtract($this, other)) ? -1 : 1;\n    // Both are positive if at least one is unsigned\n    return (other.high >>> 0) > ($this.high >>> 0) || (other.high === $this.high && (other.low >>> 0) > ($this.low >>> 0)) ? -1 : 1;\n}\n;\n/**\n * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\n * @function\n * @param {!Long|number|string} other Other value\n * @returns {number} 0 if they are the same, 1 if the this is greater and -1\n *  if the given one is greater\n */\n// LongPrototype.comp = LongPrototype.compare;\n/**\n * Negates this Long's value.\n * @this {!Long}\n * @returns {!Long} Negated Long\n */\nexport function negate($this) {\n    if (!$this.unsigned && equals($this, MIN_VALUE))\n        return MIN_VALUE;\n    return add(not($this), ONE);\n}\n;\n/**\n * Negates this Long's value. This is an alias of {@link Long#negate}.\n * @function\n * @returns {!Long} Negated Long\n */\n// LongPrototype.neg = LongPrototype.negate;\n/**\n * Returns the sum of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} addend Addend\n * @returns {!Long} Sum\n */\nexport function add($this, addend) {\n    if (!isLong(addend))\n        addend = fromValue(addend);\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = addend.high >>> 16;\n    var b32 = addend.high & 0xFFFF;\n    var b16 = addend.low >>> 16;\n    var b00 = addend.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 + b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 + b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 + b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 + b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the difference of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\nexport function subtract($this, subtrahend) {\n    if (!isLong(subtrahend))\n        subtrahend = fromValue(subtrahend);\n    return add($this, negate(subtrahend));\n}\n;\n/**\n * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\n * @function\n * @param {!Long|number|string} subtrahend Subtrahend\n * @returns {!Long} Difference\n */\n// LongPrototype.sub = LongPrototype.subtract;\n/**\n * Returns the product of this and the specified Long.\n * @this {!Long}\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\nexport function multiply($this, multiplier) {\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    if (!isLong(multiplier))\n        multiplier = fromValue(multiplier);\n    // use wasm support if present\n    if (wasm) {\n        var low = wasm.mul($this.low, $this.high, multiplier.low, multiplier.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero(multiplier))\n        return $this.unsigned ? UZERO : ZERO;\n    if (equals($this, MIN_VALUE))\n        return isOdd(multiplier) ? MIN_VALUE : ZERO;\n    if (equals(multiplier, MIN_VALUE))\n        return isOdd($this) ? MIN_VALUE : ZERO;\n    if (isNegative($this)) {\n        if (isNegative(multiplier))\n            return multiply(negate($this), negate(multiplier));\n        else\n            return negate(multiply(negate($this), multiplier));\n    }\n    else if (isNegative(multiplier))\n        return negate(multiply($this, negate(multiplier)));\n    // If both longs are small, use float multiplication\n    if (lessThan($this, TWO_PWR_24) && lessThan(multiplier, TWO_PWR_24))\n        return fromNumber(toNumber($this) * toNumber(multiplier), $this.unsigned);\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n    // We can skip products that would overflow.\n    var a48 = $this.high >>> 16;\n    var a32 = $this.high & 0xFFFF;\n    var a16 = $this.low >>> 16;\n    var a00 = $this.low & 0xFFFF;\n    var b48 = multiplier.high >>> 16;\n    var b32 = multiplier.high & 0xFFFF;\n    var b16 = multiplier.low >>> 16;\n    var b00 = multiplier.low & 0xFFFF;\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 * b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 * b00;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c16 += a00 * b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 * b00;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a16 * b16;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a00 * b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n    c48 &= 0xFFFF;\n    return fromBits((c16 << 16) | c00, (c48 << 16) | c32, $this.unsigned);\n}\n;\n/**\n * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\n * @function\n * @param {!Long|number|string} multiplier Multiplier\n * @returns {!Long} Product\n */\n// LongPrototype.mul = LongPrototype.multiply;\n/**\n * Returns this Long divided by the specified. The result is signed if this Long is signed or\n *  unsigned if this Long is unsigned.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\nexport function divide($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    if (isZero(divisor))\n        throw Error('division by zero');\n    // use wasm support if present\n    if (wasm) {\n        // guard against signed division overflow: the largest\n        // negative number / -1 would be 1 larger than the largest\n        // positive number, due to two's complement.\n        if (!$this.unsigned &&\n            $this.high === -0x80000000 &&\n            divisor.low === -1 && divisor.high === -1) {\n            // be consistent with non-wasm code path\n            return $this;\n        }\n        var low = ($this.unsigned ? wasm.div_u : wasm.div_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    if (isZero($this))\n        return $this.unsigned ? UZERO : ZERO;\n    var approx, rem, res;\n    if (!$this.unsigned) {\n        // This section is only relevant for signed longs and is derived from the\n        // closure library as a whole.\n        if (equals($this, MIN_VALUE)) {\n            if (equals(divisor, ONE) || equals(divisor, NEG_ONE))\n                return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE\n            else if (equals(divisor, MIN_VALUE))\n                return ONE;\n            else {\n                // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n                var halfThis = shiftRight($this, 1);\n                approx = shiftLeft(divide(halfThis, divisor), 1);\n                if (equals(approx, ZERO)) {\n                    return isNegative(divisor) ? ONE : NEG_ONE;\n                }\n                else {\n                    rem = subtract($this, multiply(divisor, approx));\n                    res = add(approx, divide(rem, divisor));\n                    return res;\n                }\n            }\n        }\n        else if (equals(divisor, MIN_VALUE))\n            return $this.unsigned ? UZERO : ZERO;\n        if (isNegative($this)) {\n            if (isNegative(divisor))\n                return divide(negate($this), negate(divisor));\n            return negate(divide(negate($this), divisor));\n        }\n        else if (isNegative(divisor))\n            return negate(divide($this, negate(divisor)));\n        res = ZERO;\n    }\n    else {\n        // The algorithm below has not been made for unsigned longs. It's therefore\n        // required to take special care of the MSB prior to running it.\n        if (!divisor.unsigned)\n            divisor = toUnsigned(divisor);\n        if (greaterThan(divisor, $this))\n            return UZERO;\n        if (greaterThan(divisor, shiftRightUnsigned($this, 1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\n            return UONE;\n        res = UZERO;\n    }\n    // Repeat the following until the remainder is less than other:  find a\n    // floating-point that approximates remainder / other *from below*, add this\n    // into the result, and subtract it from the remainder.  It is critical that\n    // the approximate value is less than or equal to the real value so that the\n    // remainder never becomes negative.\n    rem = $this;\n    while (greaterThanOrEqual(rem, divisor)) {\n        // Approximate the result of division. This may be a little greater or\n        // smaller than the actual value.\n        approx = Math.max(1, Math.floor(toNumber(rem) / toNumber(divisor)));\n        // We will tweak the approximate result by changing it in the 48-th digit or\n        // the smallest non-fractional digit, whichever is larger.\n        var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48), \n        // Decrease the approximation until it is smaller than the remainder.  Note\n        // that if it is too large, the product overflows and is negative.\n        approxRes = fromNumber(approx), approxRem = multiply(approxRes, divisor);\n        while (isNegative(approxRem) || greaterThan(approxRem, rem)) {\n            approx -= delta;\n            approxRes = fromNumber(approx, $this.unsigned);\n            approxRem = multiply(approxRes, divisor);\n        }\n        // We know the answer can't be zero... and actually, zero would cause\n        // infinite recursion since we would make no progress.\n        if (isZero(approxRes))\n            approxRes = ONE;\n        res = add(res, approxRes);\n        rem = subtract(rem, approxRem);\n    }\n    return res;\n}\n;\n/**\n * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Quotient\n */\n// LongPrototype.div = LongPrototype.divide;\n/**\n * Returns this Long modulo the specified.\n * @this {!Long}\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\nexport function modulo($this, divisor) {\n    if (!isLong(divisor))\n        divisor = fromValue(divisor);\n    // use wasm support if present\n    if (wasm) {\n        var low = ($this.unsigned ? wasm.rem_u : wasm.rem_s)($this.low, $this.high, divisor.low, divisor.high);\n        return fromBits(low, wasm.get_high(), $this.unsigned);\n    }\n    return subtract($this, multiply(divide($this, divisor), divisor));\n}\n;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.mod = LongPrototype.modulo;\n/**\n * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\n * @function\n * @param {!Long|number|string} divisor Divisor\n * @returns {!Long} Remainder\n */\n// LongPrototype.rem = LongPrototype.modulo;\n/**\n * Returns the bitwise NOT of this Long.\n * @this {!Long}\n * @returns {!Long}\n */\nexport function not($this) {\n    return fromBits(~$this.low, ~$this.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise AND of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function and($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low & other.low, $this.high & other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise OR of this Long and the specified.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function or($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low | other.low, $this.high | other.high, $this.unsigned);\n}\n;\n/**\n * Returns the bitwise XOR of this Long and the given one.\n * @this {!Long}\n * @param {!Long|number|string} other Other Long\n * @returns {!Long}\n */\nexport function xor($this, other) {\n    if (!isLong(other))\n        other = fromValue(other);\n    return fromBits($this.low ^ other.low, $this.high ^ other.high, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftLeft($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits($this.low << numBits, ($this.high << numBits) | ($this.low >>> (32 - numBits)), $this.unsigned);\n    else\n        return fromBits(0, $this.low << (numBits - 32), $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shl = LongPrototype.shiftLeft;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRight($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    if ((numBits &= 63) === 0)\n        return $this;\n    else if (numBits < 32)\n        return fromBits(($this.low >>> numBits) | ($this.high << (32 - numBits)), $this.high >> numBits, $this.unsigned);\n    else\n        return fromBits($this.high >> (numBits - 32), $this.high >= 0 ? 0 : -1, $this.unsigned);\n}\n;\n/**\n * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr = LongPrototype.shiftRight;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\nexport function shiftRightUnsigned($this, numBits) {\n    if (isLong(numBits))\n        numBits = toInt(numBits);\n    numBits &= 63;\n    if (numBits === 0)\n        return $this;\n    else {\n        var high = $this.high;\n        if (numBits < 32) {\n            var low = $this.low;\n            return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, $this.unsigned);\n        }\n        else if (numBits === 32)\n            return fromBits(high, 0, $this.unsigned);\n        else\n            return fromBits(high >>> (numBits - 32), 0, $this.unsigned);\n    }\n}\n;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shru = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Shifted Long\n */\n// LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;\n/**\n * Returns this Long with bits rotated to the left by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateLeft = function rotateLeft(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.low << numBits) | (this.high >>> b)), ((this.high << numBits) | (this.low >>> b)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.high << numBits) | (this.low >>> b)), ((this.low << numBits) | (this.high >>> b)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the left by the given amount. This is an alias of {@link Long#rotateLeft}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotl = LongPrototype.rotateLeft;\n/**\n * Returns this Long with bits rotated to the right by the given amount.\n * @this {!Long}\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\nexport const rotateRight = function rotateRight(numBits) {\n    var b;\n    if (isLong(numBits))\n        numBits = numBits.toInt();\n    if ((numBits &= 63) === 0)\n        return this;\n    if (numBits === 32)\n        return fromBits(this.high, this.low, this.unsigned);\n    if (numBits < 32) {\n        b = (32 - numBits);\n        return fromBits(((this.high << b) | (this.low >>> numBits)), ((this.low << b) | (this.high >>> numBits)), this.unsigned);\n    }\n    numBits -= 32;\n    b = (32 - numBits);\n    return fromBits(((this.low << b) | (this.high >>> numBits)), ((this.high << b) | (this.low >>> numBits)), this.unsigned);\n};\n/**\n * Returns this Long with bits rotated to the right by the given amount. This is an alias of {@link Long#rotateRight}.\n * @function\n * @param {number|!Long} numBits Number of bits\n * @returns {!Long} Rotated Long\n */\n// LongPrototype.rotr = LongPrototype.rotateRight;\n/**\n * Converts this Long to signed.\n * @this {!Long}\n * @returns {!Long} Signed long\n */\nexport function toSigned($this) {\n    if (!$this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, false);\n}\n;\n/**\n * Converts this Long to unsigned.\n * @this {!Long}\n * @returns {!Long} Unsigned long\n */\nexport function toUnsigned($this) {\n    if ($this.unsigned)\n        return $this;\n    return fromBits($this.low, $this.high, true);\n}\n;\n/**\n * Converts this Long to its byte representation.\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @this {!Long}\n * @returns {!Array.<number>} Byte representation\n */\nexport function toBytes($this, le) {\n    return le ? toBytesLE($this) : toBytesBE($this);\n}\n;\n/**\n * Converts this Long to its little endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Little endian byte representation\n */\nexport function toBytesLE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        lo & 0xff,\n        lo >>> 8 & 0xff,\n        lo >>> 16 & 0xff,\n        lo >>> 24,\n        hi & 0xff,\n        hi >>> 8 & 0xff,\n        hi >>> 16 & 0xff,\n        hi >>> 24\n    ];\n}\n;\n/**\n * Converts this Long to its big endian byte representation.\n * @this {!Long}\n * @returns {!Array.<number>} Big endian byte representation\n */\nexport function toBytesBE($this) {\n    var hi = $this.high, lo = $this.low;\n    return [\n        hi >>> 24,\n        hi >>> 16 & 0xff,\n        hi >>> 8 & 0xff,\n        hi & 0xff,\n        lo >>> 24,\n        lo >>> 16 & 0xff,\n        lo >>> 8 & 0xff,\n        lo & 0xff\n    ];\n}\n;\n/**\n * Creates a Long from its byte representation.\n * @param {!Array.<number>} bytes Byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @param {boolean=} le Whether little or big endian, defaults to big endian\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytes(bytes, unsigned, le) {\n    return le ? fromBytesLE(bytes, unsigned) : fromBytesBE(bytes, unsigned);\n}\n;\n/**\n * Creates a Long from its little endian byte representation.\n * @param {!Array.<number>} bytes Little endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesLE(bytes, unsigned) {\n    return new Long(bytes[0] |\n        bytes[1] << 8 |\n        bytes[2] << 16 |\n        bytes[3] << 24, bytes[4] |\n        bytes[5] << 8 |\n        bytes[6] << 16 |\n        bytes[7] << 24, unsigned);\n}\n;\n/**\n * Creates a Long from its big endian byte representation.\n * @param {!Array.<number>} bytes Big endian byte representation\n * @param {boolean=} unsigned Whether unsigned or not, defaults to signed\n * @returns {Long} The corresponding Long value\n */\nexport function fromBytesBE(bytes, unsigned) {\n    return new Long(bytes[4] << 24 |\n        bytes[5] << 16 |\n        bytes[6] << 8 |\n        bytes[7], bytes[0] << 24 |\n        bytes[1] << 16 |\n        bytes[2] << 8 |\n        bytes[3], unsigned);\n}\n;\n","import { isValid } from \"./Int32.js\";\nimport * as LongLib from \"./lib/long.js\";\nexport default LongLib.Long;\nexport const get_Zero = LongLib.ZERO;\nexport const get_One = LongLib.ONE;\nexport const op_Addition = LongLib.add;\nexport const op_Subtraction = LongLib.subtract;\nexport const op_Multiply = LongLib.multiply;\nexport const op_Division = LongLib.divide;\nexport const op_Modulus = LongLib.modulo;\nexport const op_UnaryNegation = LongLib.negate;\nexport const op_LeftShift = LongLib.shiftLeft;\nexport const op_RightShift = LongLib.shiftRight;\nexport const op_RightShiftUnsigned = LongLib.shiftRightUnsigned;\nexport const op_BitwiseAnd = LongLib.and;\nexport const op_BitwiseOr = LongLib.or;\nexport const op_ExclusiveOr = LongLib.xor;\nexport const op_LogicalNot = LongLib.not;\nexport const op_LessThan = LongLib.lessThan;\nexport const op_LessThanOrEqual = LongLib.lessThanOrEqual;\nexport const op_GreaterThan = LongLib.greaterThan;\nexport const op_GreaterThanOrEqual = LongLib.greaterThanOrEqual;\nexport const op_Equality = LongLib.equals;\nexport const op_Inequality = LongLib.notEquals;\nexport const equals = LongLib.equals;\nexport const compare = LongLib.compare;\nexport const fromInt = LongLib.fromInt;\nexport const fromBits = LongLib.fromBits;\nexport const fromBytes = LongLib.fromBytes;\nexport const fromNumber = LongLib.fromNumber;\nexport const fromString = LongLib.fromString;\nexport const fromValue = LongLib.fromValue;\nexport const toInt = LongLib.toInt;\nexport const toBytes = LongLib.toBytes;\nexport const toNumber = LongLib.toNumber;\nexport const toString = LongLib.toString;\nexport const getLowBits = LongLib.getLowBits;\nexport const getHighBits = LongLib.getHighBits;\nexport const getLowBitsUnsigned = LongLib.getLowBitsUnsigned;\nexport const getHighBitsUnsigned = LongLib.getHighBitsUnsigned;\nfunction getMaxValue(unsigned, radix, isNegative) {\n    switch (radix) {\n        case 2: return unsigned ?\n            \"1111111111111111111111111111111111111111111111111111111111111111\" :\n            (isNegative ? \"1000000000000000000000000000000000000000000000000000000000000000\"\n                : \"111111111111111111111111111111111111111111111111111111111111111\");\n        case 8: return unsigned ?\n            \"1777777777777777777777\" :\n            (isNegative ? \"1000000000000000000000\" : \"777777777777777777777\");\n        case 10: return unsigned ?\n            \"18446744073709551615\" :\n            (isNegative ? \"9223372036854775808\" : \"9223372036854775807\");\n        case 16: return unsigned ?\n            \"FFFFFFFFFFFFFFFF\" :\n            (isNegative ? \"8000000000000000\" : \"7FFFFFFFFFFFFFFF\");\n        default: throw new Error(\"Invalid radix.\");\n    }\n}\nexport function abs(x) {\n    if (!x.unsigned && LongLib.isNegative(x)) {\n        return op_UnaryNegation(x);\n    }\n    else {\n        return x;\n    }\n}\nexport function fromInteger(value, unsigned, kind) {\n    let x = value;\n    let xh = 0;\n    switch (kind) {\n        case 0:\n            x = value << 24 >> 24;\n            xh = x;\n            break;\n        case 4:\n            x = value << 24 >>> 24;\n            break;\n        case 1:\n            x = value << 16 >> 16;\n            xh = x;\n            break;\n        case 5:\n            x = value << 16 >>> 16;\n            break;\n        case 2:\n            x = value >> 0;\n            xh = x;\n            break;\n        case 6:\n            x = value >>> 0;\n            break;\n    }\n    return LongLib.fromBits(x, xh >> 31, unsigned);\n}\nexport function parse(str, style, unsigned, _bitsize, radix) {\n    const res = isValid(str, style, radix);\n    if (res != null) {\n        const lessOrEqual = (x, y) => {\n            const len = Math.max(x.length, y.length);\n            return x.padStart(len, \"0\") <= y.padStart(len, \"0\");\n        };\n        const isNegative = res.sign === \"-\";\n        const maxValue = getMaxValue(unsigned || res.radix !== 10, res.radix, isNegative);\n        if (lessOrEqual(res.digits.toUpperCase(), maxValue)) {\n            str = isNegative ? res.sign + res.digits : res.digits;\n            return LongLib.fromString(str, unsigned, res.radix);\n        }\n    }\n    throw new Error(\"Input string was not in a correct format.\");\n}\nexport function tryParse(str, style, unsigned, bitsize, defValue) {\n    try {\n        defValue.contents = parse(str, style, unsigned, bitsize);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\nexport function unixEpochMillisecondsToTicks(ms, offset) {\n    return op_Multiply(op_Addition(op_Addition(LongLib.fromNumber(ms), 62135596800000), offset), 10000);\n}\nexport function ticksToUnixEpochMilliseconds(ticks) {\n    return LongLib.toNumber(op_Subtraction(op_Division(ticks, 10000), 62135596800000));\n}\nexport function makeRangeStepFunction(step, last, unsigned) {\n    const stepComparedWithZero = LongLib.compare(step, unsigned ? LongLib.UZERO : LongLib.ZERO);\n    if (stepComparedWithZero === 0) {\n        throw new Error(\"The step of a range cannot be zero\");\n    }\n    const stepGreaterThanZero = stepComparedWithZero > 0;\n    return (x) => {\n        const comparedWithLast = LongLib.compare(x, last);\n        if ((stepGreaterThanZero && comparedWithLast <= 0)\n            || (!stepGreaterThanZero && comparedWithLast >= 0)) {\n            return [x, op_Addition(x, step)];\n        }\n        else {\n            return undefined;\n        }\n    };\n}\n","import { makeRangeStepFunction as makeDecimalRangeStepFunction } from \"./Decimal.js\";\nimport { makeRangeStepFunction as makeLongRangeStepFunction } from \"./Long.js\";\nimport { some, value } from \"./Option.js\";\nimport { compare, equals } from \"./Util.js\";\nexport class Enumerator {\n    constructor(iter) {\n        this.iter = iter;\n    }\n    [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.get_Current\"]() {\n        return this.current;\n    }\n    [\"System.Collections.IEnumerator.MoveNext\"]() {\n        const cur = this.iter.next();\n        this.current = cur.value;\n        return !cur.done;\n    }\n    [\"System.Collections.IEnumerator.Reset\"]() {\n        throw new Error(\"JS iterators cannot be reset\");\n    }\n    Dispose() {\n        return;\n    }\n}\nexport function getEnumerator(o) {\n    return typeof o.GetEnumerator === \"function\"\n        ? o.GetEnumerator()\n        : new Enumerator(o[Symbol.iterator]());\n}\nexport function toIterator(en) {\n    return {\n        [Symbol.iterator]() { return this; },\n        next() {\n            const hasNext = en[\"System.Collections.IEnumerator.MoveNext\"]();\n            const current = hasNext ? en[\"System.Collections.IEnumerator.get_Current\"]() : undefined;\n            return { done: !hasNext, value: current };\n        },\n    };\n}\n// export function toIterable<T>(en: IEnumerable<T>): Iterable<T> {\n//   return {\n//     [Symbol.iterator]() {\n//       return toIterator(en.GetEnumerator());\n//     },\n//   };\n// }\nfunction __failIfNone(res) {\n    if (res == null) {\n        throw new Error(\"Seq did not contain any matching element\");\n    }\n    return value(res);\n}\nclass Seq {\n    constructor(f) {\n        this.f = f;\n    }\n    [Symbol.iterator]() { return new Seq(this.f); }\n    next() {\n        var _a;\n        this.iter = (_a = this.iter) !== null && _a !== void 0 ? _a : this.f();\n        return this.iter.next();\n    }\n    toString() {\n        return \"seq [\" + Array.from(this).join(\"; \") + \"]\";\n    }\n}\nfunction makeSeq(f) {\n    return new Seq(f);\n}\nfunction isArrayOrBufferView(xs) {\n    return Array.isArray(xs) || ArrayBuffer.isView(xs);\n}\nexport function ofArray(xs) {\n    if (Array.isArray(xs)) {\n        return delay(() => xs);\n    }\n    else {\n        return delay(() => unfold((i) => i != null && i < xs.length ? [xs[i], i + 1] : undefined, 0));\n    }\n}\nexport function allPairs(xs, ys) {\n    let firstEl = true;\n    const ysCache = [];\n    return collect((x) => {\n        if (firstEl) {\n            firstEl = false;\n            return map((y) => {\n                ysCache.push(y);\n                return [x, y];\n            }, ys);\n        }\n        else {\n            return ysCache.map((y) => [x, y]);\n            // return map(function (i) {\n            //     return [x, ysCache[i]];\n            // }, rangeNumber(0, 1, ysCache.length - 1));\n        }\n    }, xs);\n}\nexport function append(xs, ys) {\n    return delay(() => {\n        let firstDone = false;\n        const i = xs[Symbol.iterator]();\n        let iters = [i, undefined];\n        return unfold(() => {\n            var _a, _b;\n            let cur;\n            if (!firstDone) {\n                cur = (_a = iters[0]) === null || _a === void 0 ? void 0 : _a.next();\n                if (cur != null && !cur.done) {\n                    return [cur.value, iters];\n                }\n                else {\n                    firstDone = true;\n                    iters = [undefined, ys[Symbol.iterator]()];\n                }\n            }\n            cur = (_b = iters[1]) === null || _b === void 0 ? void 0 : _b.next();\n            return cur != null && !cur.done ? [cur.value, iters] : undefined;\n        }, iters);\n    });\n}\nexport function average(xs, averager) {\n    let count = 0;\n    const total = fold((acc, x) => {\n        count++;\n        return averager.Add(acc, x);\n    }, averager.GetZero(), xs);\n    return averager.DivideByInt(total, count);\n}\nexport function averageBy(f, xs, averager) {\n    let count = 0;\n    const total = fold((acc, x) => {\n        count++;\n        return averager.Add(acc, f(x));\n    }, averager.GetZero(), xs);\n    return averager.DivideByInt(total, count);\n}\nexport function concat(xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        let output;\n        return unfold((innerIter) => {\n            let hasFinished = false;\n            while (!hasFinished) {\n                if (innerIter == null) {\n                    const cur = iter.next();\n                    if (!cur.done) {\n                        innerIter = cur.value[Symbol.iterator]();\n                    }\n                    else {\n                        hasFinished = true;\n                    }\n                }\n                else {\n                    const cur = innerIter.next();\n                    if (!cur.done) {\n                        output = cur.value;\n                        hasFinished = true;\n                    }\n                    else {\n                        innerIter = undefined;\n                    }\n                }\n            }\n            return innerIter != null ? [output, innerIter] : undefined;\n        }, undefined);\n    });\n}\nexport function collect(f, xs) {\n    return concat(map(f, xs));\n}\nexport function choose(f, xs) {\n    return delay(() => unfold((iter) => {\n        let cur = iter.next();\n        while (!cur.done) {\n            const y = f(cur.value);\n            if (y != null) {\n                return [value(y), iter];\n            }\n            cur = iter.next();\n        }\n        return undefined;\n    }, xs[Symbol.iterator]()));\n}\nexport function compareWith(f, xs, ys) {\n    if (xs === ys) {\n        return 0;\n    }\n    let cur1;\n    let cur2;\n    let c = 0;\n    for (const iter1 = xs[Symbol.iterator](), iter2 = ys[Symbol.iterator]();;) {\n        cur1 = iter1.next();\n        cur2 = iter2.next();\n        if (cur1.done || cur2.done) {\n            break;\n        }\n        c = f(cur1.value, cur2.value);\n        if (c !== 0) {\n            break;\n        }\n    }\n    return (c !== 0) ? c : (cur1.done && !cur2.done) ? -1 : (!cur1.done && cur2.done) ? 1 : 0;\n}\nexport function delay(f) {\n    return makeSeq(() => f()[Symbol.iterator]());\n}\nexport function empty() {\n    return delay(() => []);\n}\nexport function singleton(y) {\n    return delay(() => [y]);\n}\nexport function enumerateFromFunctions(factory, moveNext, current) {\n    return delay(() => unfold((e) => moveNext(e) ? [current(e), e] : undefined, factory()));\n}\nexport function enumerateWhile(cond, xs) {\n    return concat(unfold(() => cond() ? [xs, true] : undefined, undefined));\n}\nexport function enumerateThenFinally(xs, finalFn) {\n    return delay(() => {\n        let iter;\n        try {\n            iter = xs[Symbol.iterator]();\n        }\n        catch (err) {\n            try {\n                return empty();\n            }\n            finally {\n                finalFn();\n            }\n        }\n        return unfold((it) => {\n            try {\n                const cur = it.next();\n                return !cur.done ? [cur.value, it] : undefined;\n            }\n            catch (err) {\n                return undefined;\n            }\n            finally {\n                finalFn();\n            }\n        }, iter);\n    });\n}\nexport function enumerateUsing(disp, work) {\n    let isDisposed = false;\n    const disposeOnce = () => {\n        if (!isDisposed) {\n            isDisposed = true;\n            disp.Dispose();\n        }\n    };\n    try {\n        return enumerateThenFinally(work(disp), disposeOnce);\n    }\n    catch (err) {\n        return void 0;\n    }\n    finally {\n        disposeOnce();\n    }\n}\nexport function exactlyOne(xs) {\n    const iter = xs[Symbol.iterator]();\n    const fst = iter.next();\n    if (fst.done) {\n        throw new Error(\"Seq was empty\");\n    }\n    const snd = iter.next();\n    if (!snd.done) {\n        throw new Error(\"Seq had multiple items\");\n    }\n    return fst.value;\n}\nexport function except(itemsToExclude, source) {\n    const exclusionItems = Array.from(itemsToExclude);\n    const testIsNotInExclusionItems = (element) => !exclusionItems.some((excludedItem) => equals(excludedItem, element));\n    return filter(testIsNotInExclusionItems, source);\n}\nexport function exists(f, xs) {\n    let cur;\n    for (const iter = xs[Symbol.iterator]();;) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value)) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function exists2(f, xs, ys) {\n    let cur1;\n    let cur2;\n    for (const iter1 = xs[Symbol.iterator](), iter2 = ys[Symbol.iterator]();;) {\n        cur1 = iter1.next();\n        cur2 = iter2.next();\n        if (cur1.done || cur2.done) {\n            break;\n        }\n        if (f(cur1.value, cur2.value)) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function forAll(f, xs) {\n    return !exists((x) => !f(x), xs);\n}\nexport function forAll2(f, xs, ys) {\n    return !exists2((x, y) => !f(x, y), xs, ys);\n}\nexport function contains(i, xs) {\n    return exists((x) => equals(x, i), xs);\n}\nexport function filter(f, xs) {\n    return delay(() => unfold((iter) => {\n        let cur = iter.next();\n        while (!cur.done) {\n            if (f(cur.value)) {\n                return [cur.value, iter];\n            }\n            cur = iter.next();\n        }\n        return undefined;\n    }, xs[Symbol.iterator]()));\n}\nexport function where(f, xs) {\n    return filter(f, xs);\n}\nexport function fold(f, acc, xs) {\n    if (isArrayOrBufferView(xs)) {\n        return xs.reduce(f, acc);\n    }\n    else {\n        let cur;\n        for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n            cur = iter.next();\n            if (cur.done) {\n                break;\n            }\n            acc = f(acc, cur.value, i);\n        }\n        return acc;\n    }\n}\nexport function foldBack(f, xs, acc) {\n    const arr = isArrayOrBufferView(xs) ? xs : Array.from(xs);\n    for (let i = arr.length - 1; i >= 0; i--) {\n        acc = f(arr[i], acc, i);\n    }\n    return acc;\n}\nexport function fold2(f, acc, xs, ys) {\n    const iter1 = xs[Symbol.iterator]();\n    const iter2 = ys[Symbol.iterator]();\n    let cur1;\n    let cur2;\n    for (let i = 0;; i++) {\n        cur1 = iter1.next();\n        cur2 = iter2.next();\n        if (cur1.done || cur2.done) {\n            break;\n        }\n        acc = f(acc, cur1.value, cur2.value, i);\n    }\n    return acc;\n}\nexport function foldBack2(f, xs, ys, acc) {\n    const ar1 = isArrayOrBufferView(xs) ? xs : Array.from(xs);\n    const ar2 = isArrayOrBufferView(ys) ? ys : Array.from(ys);\n    for (let i = ar1.length - 1; i >= 0; i--) {\n        acc = f(ar1[i], ar2[i], acc, i);\n    }\n    return acc;\n}\nexport function tryHead(xs) {\n    const iter = xs[Symbol.iterator]();\n    const cur = iter.next();\n    return cur.done ? undefined : some(cur.value);\n}\nexport function head(xs) {\n    return __failIfNone(tryHead(xs));\n}\nexport function initialize(n, f) {\n    return delay(() => unfold((i) => i < n ? [f(i), i + 1] : undefined, 0));\n}\nexport function initializeInfinite(f) {\n    return delay(() => unfold((i) => [f(i), i + 1], 0));\n}\nexport function tryItem(i, xs) {\n    if (i < 0) {\n        return undefined;\n    }\n    if (isArrayOrBufferView(xs)) {\n        return i < xs.length ? some(xs[i]) : undefined;\n    }\n    for (let j = 0, iter = xs[Symbol.iterator]();; j++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (j === i) {\n            return some(cur.value);\n        }\n    }\n    return undefined;\n}\nexport function item(i, xs) {\n    return __failIfNone(tryItem(i, xs));\n}\nexport function iterate(f, xs) {\n    fold((_, x) => (f(x), undefined), undefined, xs);\n}\nexport function iterate2(f, xs, ys) {\n    fold2((_, x, y) => (f(x, y), undefined), undefined, xs, ys);\n}\nexport function iterateIndexed(f, xs) {\n    fold((_, x, i) => (f(i !== null && i !== void 0 ? i : 0, x), undefined), undefined, xs);\n}\nexport function iterateIndexed2(f, xs, ys) {\n    fold2((_, x, y, i) => (f(i !== null && i !== void 0 ? i : 0, x, y), undefined), undefined, xs, ys);\n}\nexport function isEmpty(xs) {\n    const i = xs[Symbol.iterator]();\n    return i.next().done;\n}\nexport function tryLast(xs) {\n    return isEmpty(xs) ? undefined : some(reduce((_, x) => x, xs));\n}\nexport function last(xs) {\n    return __failIfNone(tryLast(xs));\n}\nexport function length(xs) {\n    return isArrayOrBufferView(xs)\n        ? xs.length\n        : fold((acc, _x) => acc + 1, 0, xs);\n}\nexport function map(f, xs) {\n    return delay(() => unfold((iter) => {\n        const cur = iter.next();\n        return !cur.done ? [f(cur.value), iter] : undefined;\n    }, xs[Symbol.iterator]()));\n}\nexport function mapIndexed(f, xs) {\n    return delay(() => {\n        let i = 0;\n        return unfold((iter) => {\n            const cur = iter.next();\n            return !cur.done ? [f(i++, cur.value), iter] : undefined;\n        }, xs[Symbol.iterator]());\n    });\n}\nexport function indexed(xs) {\n    return mapIndexed((i, x) => [i, x], xs);\n}\nexport function map2(f, xs, ys) {\n    return delay(() => {\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            return !cur1.done && !cur2.done ? [f(cur1.value, cur2.value), undefined] : undefined;\n        }, undefined);\n    });\n}\nexport function mapIndexed2(f, xs, ys) {\n    return delay(() => {\n        let i = 0;\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            return !cur1.done && !cur2.done ? [f(i++, cur1.value, cur2.value), undefined] : undefined;\n        }, undefined);\n    });\n}\nexport function map3(f, xs, ys, zs) {\n    return delay(() => {\n        const iter1 = xs[Symbol.iterator]();\n        const iter2 = ys[Symbol.iterator]();\n        const iter3 = zs[Symbol.iterator]();\n        return unfold(() => {\n            const cur1 = iter1.next();\n            const cur2 = iter2.next();\n            const cur3 = iter3.next();\n            return !cur1.done && !cur2.done && !cur3.done ? [f(cur1.value, cur2.value, cur3.value), undefined] : undefined;\n        }, undefined);\n    });\n}\nexport function mapFold(f, acc, xs, transform) {\n    const result = [];\n    let r;\n    let cur;\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        [r, acc] = f(acc, cur.value);\n        result.push(r);\n    }\n    return transform !== void 0 ? [transform(result), acc] : [result, acc];\n}\nexport function mapFoldBack(f, xs, acc, transform) {\n    const arr = isArrayOrBufferView(xs) ? xs : Array.from(xs);\n    const result = [];\n    let r;\n    for (let i = arr.length - 1; i >= 0; i--) {\n        [r, acc] = f(arr[i], acc);\n        result.push(r);\n    }\n    return transform !== void 0 ? [transform(result), acc] : [result, acc];\n}\nexport function max(xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(acc, x) === 1 ? acc : x, xs);\n}\nexport function maxBy(f, xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(f(acc), f(x)) === 1 ? acc : x, xs);\n}\nexport function min(xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(acc, x) === -1 ? acc : x, xs);\n}\nexport function minBy(f, xs, comparer) {\n    const compareFn = comparer != null ? comparer.Compare : compare;\n    return reduce((acc, x) => compareFn(f(acc), f(x)) === -1 ? acc : x, xs);\n}\nexport function pairwise(xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        const cur = iter.next();\n        if (cur.done) {\n            return empty();\n        }\n        const hd = cur.value;\n        const tl = tail(xs);\n        const ys = scan(([_, last], next) => [last, next], [hd, hd], tl);\n        return skip(1, ys);\n    });\n}\nexport function rangeChar(first, last) {\n    const firstNum = first.charCodeAt(0);\n    const lastNum = last.charCodeAt(0);\n    return delay(() => unfold((x) => x <= lastNum ? [String.fromCharCode(x), x + 1] : undefined, firstNum));\n}\nexport function rangeLong(first, step, last, unsigned) {\n    const stepFn = makeLongRangeStepFunction(step, last, unsigned);\n    return delay(() => unfold(stepFn, first));\n}\nexport function rangeDecimal(first, step, last) {\n    const stepFn = makeDecimalRangeStepFunction(step, last);\n    return delay(() => unfold(stepFn, first));\n}\nexport function rangeNumber(first, step, last) {\n    if (step === 0) {\n        throw new Error(\"Step cannot be 0\");\n    }\n    return delay(() => unfold((x) => step > 0 && x <= last || step < 0 && x >= last ? [x, x + step] : undefined, first));\n}\nexport function readOnly(xs) {\n    return map((x) => x, xs);\n}\nexport function reduce(f, xs) {\n    if (isArrayOrBufferView(xs)) {\n        return xs.reduce(f);\n    }\n    const iter = xs[Symbol.iterator]();\n    let cur = iter.next();\n    if (cur.done) {\n        throw new Error(\"Seq was empty\");\n    }\n    let acc = cur.value;\n    while (true) {\n        cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        acc = f(acc, cur.value);\n    }\n    return acc;\n}\nexport function reduceBack(f, xs) {\n    const ar = isArrayOrBufferView(xs) ? xs : Array.from(xs);\n    if (ar.length === 0) {\n        throw new Error(\"Seq was empty\");\n    }\n    let acc = ar[ar.length - 1];\n    for (let i = ar.length - 2; i >= 0; i--) {\n        acc = f(ar[i], acc, i);\n    }\n    return acc;\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function reverse(xs) {\n    const ar = isArrayOrBufferView(xs) ? xs.slice(0) : Array.from(xs);\n    return ofArray(ar.reverse());\n}\nexport function scan(f, seed, xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold((acc) => {\n            if (acc == null) {\n                return [seed, seed];\n            }\n            const cur = iter.next();\n            if (!cur.done) {\n                acc = f(acc, cur.value);\n                return [acc, acc];\n            }\n            return undefined;\n        }, undefined);\n    });\n}\nexport function scanBack(f, xs, seed) {\n    return reverse(scan((acc, x) => f(x, acc), seed, reverse(xs)));\n}\nexport function skip(n, xs) {\n    return makeSeq(() => {\n        const iter = xs[Symbol.iterator]();\n        for (let i = 1; i <= n; i++) {\n            if (iter.next().done) {\n                throw new Error(\"Seq has not enough elements\");\n            }\n        }\n        return iter;\n    });\n}\nexport function skipWhile(f, xs) {\n    return delay(() => {\n        let hasPassed = false;\n        return filter((x) => hasPassed || (hasPassed = !f(x)), xs);\n    });\n}\nexport function sortWith(f, xs) {\n    const ys = Array.from(xs);\n    return ofArray(ys.sort(f));\n}\nexport function sum(xs, adder) {\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\n}\nexport function sumBy(f, xs, adder) {\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\n}\nexport function tail(xs) {\n    return skip(1, xs);\n}\nexport function take(n, xs, truncate = false) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold((i) => {\n            if (i < n) {\n                const cur = iter.next();\n                if (!cur.done) {\n                    return [cur.value, i + 1];\n                }\n                if (!truncate) {\n                    throw new Error(\"Seq has not enough elements\");\n                }\n            }\n            return undefined;\n        }, 0);\n    });\n}\nexport function truncate(n, xs) {\n    return take(n, xs, true);\n}\nexport function takeWhile(f, xs) {\n    return delay(() => {\n        const iter = xs[Symbol.iterator]();\n        return unfold(() => {\n            const cur = iter.next();\n            if (!cur.done && f(cur.value)) {\n                return [cur.value, undefined];\n            }\n            return undefined;\n        }, 0);\n    });\n}\nexport function tryFind(f, xs, defaultValue) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value, i)) {\n            return some(cur.value);\n        }\n    }\n    return defaultValue === void 0 ? undefined : some(defaultValue);\n}\nexport function find(f, xs) {\n    return __failIfNone(tryFind(f, xs));\n}\nexport function tryFindBack(f, xs, defaultValue) {\n    const arr = isArrayOrBufferView(xs) ? xs.slice(0) : Array.from(xs);\n    return tryFind(f, arr.reverse(), defaultValue);\n}\nexport function findBack(f, xs) {\n    return __failIfNone(tryFindBack(f, xs));\n}\nexport function tryFindIndex(f, xs) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        if (f(cur.value, i)) {\n            return i;\n        }\n    }\n    return undefined;\n}\nexport function findIndex(f, xs) {\n    return __failIfNone(tryFindIndex(f, xs));\n}\nexport function tryFindIndexBack(f, xs) {\n    const arr = isArrayOrBufferView(xs) ? xs.slice(0) : Array.from(xs);\n    for (let i = arr.length - 1; i >= 0; i--) {\n        if (f(arr[i], i)) {\n            return i;\n        }\n    }\n    return undefined;\n}\nexport function findIndexBack(f, xs) {\n    return __failIfNone(tryFindIndexBack(f, xs));\n}\nexport function tryPick(f, xs) {\n    for (let i = 0, iter = xs[Symbol.iterator]();; i++) {\n        const cur = iter.next();\n        if (cur.done) {\n            break;\n        }\n        const y = f(cur.value, i);\n        if (y != null) {\n            return y;\n        }\n    }\n    return undefined;\n}\nexport function pick(f, xs) {\n    return __failIfNone(tryPick(f, xs));\n}\nexport function unfold(f, fst) {\n    return makeSeq(() => {\n        // Capture a copy of the first value in the closure\n        // so the sequence is restarted every time, see #1230\n        let acc = fst;\n        const iter = {\n            next() {\n                const res = f(acc);\n                if (res != null) {\n                    const v = value(res);\n                    if (v != null) {\n                        acc = v[1];\n                        return { done: false, value: v[0] };\n                    }\n                }\n                return { done: true, value: undefined };\n            },\n        };\n        return iter;\n    });\n}\nexport function zip(xs, ys) {\n    return map2((x, y) => [x, y], xs, ys);\n}\nexport function zip3(xs, ys, zs) {\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\n}\nexport function windowed(windowSize, source) {\n    if (windowSize <= 0) {\n        throw new Error(\"windowSize must be positive\");\n    }\n    return makeSeq(() => {\n        let window = [];\n        const iter = source[Symbol.iterator]();\n        const iter2 = {\n            next() {\n                let cur;\n                while (window.length < windowSize) {\n                    if ((cur = iter.next()).done) {\n                        return { done: true, value: undefined };\n                    }\n                    window.push(cur.value);\n                }\n                const value = window;\n                window = window.slice(1);\n                return { done: false, value };\n            },\n        };\n        return iter2;\n    });\n}\nexport function transpose(source) {\n    return makeSeq(() => {\n        const iters = Array.from(source, (x) => x[Symbol.iterator]());\n        const iter = {\n            next() {\n                if (iters.length === 0) {\n                    return { done: true, value: undefined }; // empty sequence\n                }\n                const results = Array.from(iters, (iter) => iter.next());\n                if (results[0].done) {\n                    if (!results.every((x) => x.done)) {\n                        throw new Error(\"Sequences have different lengths\");\n                    }\n                    return { done: true, value: undefined };\n                }\n                else {\n                    if (!results.every((x) => !x.done)) {\n                        throw new Error(\"Sequences have different lengths\");\n                    }\n                    const values = results.map((x) => x.value);\n                    return { done: false, value: values };\n                }\n            },\n        };\n        return iter;\n    });\n}\n","import { equals } from \"./Util.js\";\nimport { Union } from \"./Types.js\";\nconst CaseRules = {\n    None: 0,\n    LowerFirst: 1,\n    SnakeCase: 2,\n    SnakeCaseAllCaps: 3,\n    KebabCase: 4,\n};\nfunction dashify(str, separator) {\n    return str.replace(/[a-z]?[A-Z]/g, (m) => m.length === 1\n        ? m.toLowerCase()\n        : m.charAt(0) + separator + m.charAt(1).toLowerCase());\n}\nfunction changeCase(str, caseRule) {\n    switch (caseRule) {\n        case CaseRules.LowerFirst:\n            return str.charAt(0).toLowerCase() + str.slice(1);\n        case CaseRules.SnakeCase:\n            return dashify(str, \"_\");\n        case CaseRules.SnakeCaseAllCaps:\n            return dashify(str, \"_\").toUpperCase();\n        case CaseRules.KebabCase:\n            return dashify(str, \"-\");\n        case CaseRules.None:\n        default:\n            return str;\n    }\n}\nexport function keyValueList(fields, caseRule = CaseRules.None) {\n    const obj = {};\n    const definedCaseRule = caseRule;\n    function fail(kvPair) {\n        throw new Error(\"Cannot infer key and value of \" + String(kvPair));\n    }\n    function assign(key, caseRule, value) {\n        key = changeCase(key, caseRule);\n        obj[key] = value;\n    }\n    for (let kvPair of fields) {\n        let caseRule = CaseRules.None;\n        if (kvPair == null) {\n            fail(kvPair);\n        }\n        // Deflate unions and use the defined case rule\n        if (kvPair instanceof Union) {\n            const name = kvPair.cases()[kvPair.tag];\n            kvPair = kvPair.fields.length === 0 ? name : [name].concat(kvPair.fields);\n            caseRule = definedCaseRule;\n        }\n        if (Array.isArray(kvPair)) {\n            switch (kvPair.length) {\n                case 0:\n                    fail(kvPair);\n                    break;\n                case 1:\n                    assign(kvPair[0], caseRule, true);\n                    break;\n                case 2:\n                    const value = kvPair[1];\n                    assign(kvPair[0], caseRule, value);\n                    break;\n                default:\n                    assign(kvPair[0], caseRule, kvPair.slice(1));\n            }\n        }\n        else if (typeof kvPair === \"string\") {\n            assign(kvPair, caseRule, true);\n        }\n        else {\n            fail(kvPair);\n        }\n    }\n    return obj;\n}\n// TODO: Move these methods to Map and Set modules\nexport function containsValue(v, map) {\n    for (const kv of map) {\n        if (equals(v, kv[1])) {\n            return true;\n        }\n    }\n    return false;\n}\nexport function tryGetValue(map, key, defaultValue) {\n    if (map.has(key)) {\n        defaultValue.contents = map.get(key);\n        return true;\n    }\n    return false;\n}\nexport function addToSet(v, set) {\n    if (set.has(v)) {\n        return false;\n    }\n    set.add(v);\n    return true;\n}\nexport function addToDict(dict, k, v) {\n    if (dict.has(k)) {\n        throw new Error(\"An item with the same key has already been added. Key: \" + k);\n    }\n    dict.set(k, v);\n}\nexport function getItemFromDict(map, key) {\n    if (map.has(key)) {\n        return map.get(key);\n    }\n    else {\n        throw new Error(`The given key '${key}' was not present in the dictionary.`);\n    }\n}\n","/**\n * DateTimeOffset functions.\n *\n * Note: Date instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, dateOffset, padWithZeros } from \"./Util.js\";\nexport const offsetRegex = /(?:Z|[+-](\\d+):?([0-5]?\\d)?)\\s*$/;\nexport function dateOffsetToString(offset) {\n    const isMinus = offset < 0;\n    offset = Math.abs(offset);\n    const hours = ~~(offset / 3600000);\n    const minutes = (offset % 3600000) / 60000;\n    return (isMinus ? \"-\" : \"+\") +\n        padWithZeros(hours, 2) + \":\" +\n        padWithZeros(minutes, 2);\n}\nexport function dateToHalfUTCString(date, half) {\n    const str = date.toISOString();\n    return half === \"first\"\n        ? str.substring(0, str.indexOf(\"T\"))\n        : str.substring(str.indexOf(\"T\") + 1, str.length - 1);\n}\nfunction dateToISOString(d, utc) {\n    if (utc) {\n        return d.toISOString();\n    }\n    else {\n        // JS Date is always local\n        const printOffset = d.kind == null ? true : d.kind === 2 /* Local */;\n        return padWithZeros(d.getFullYear(), 4) + \"-\" +\n            padWithZeros(d.getMonth() + 1, 2) + \"-\" +\n            padWithZeros(d.getDate(), 2) + \"T\" +\n            padWithZeros(d.getHours(), 2) + \":\" +\n            padWithZeros(d.getMinutes(), 2) + \":\" +\n            padWithZeros(d.getSeconds(), 2) + \".\" +\n            padWithZeros(d.getMilliseconds(), 3) +\n            (printOffset ? dateOffsetToString(d.getTimezoneOffset() * -60000) : \"\");\n    }\n}\nfunction dateToISOStringWithOffset(dateWithOffset, offset) {\n    const str = dateWithOffset.toISOString();\n    return str.substring(0, str.length - 1) + dateOffsetToString(offset);\n}\nfunction dateToStringWithCustomFormat(date, format, utc) {\n    return format.replace(/(\\w)\\1*/g, (match) => {\n        let rep = Number.NaN;\n        switch (match.substring(0, 1)) {\n            case \"y\":\n                const y = utc ? date.getUTCFullYear() : date.getFullYear();\n                rep = match.length < 4 ? y % 100 : y;\n                break;\n            case \"M\":\n                rep = (utc ? date.getUTCMonth() : date.getMonth()) + 1;\n                break;\n            case \"d\":\n                rep = utc ? date.getUTCDate() : date.getDate();\n                break;\n            case \"H\":\n                rep = utc ? date.getUTCHours() : date.getHours();\n                break;\n            case \"h\":\n                const h = utc ? date.getUTCHours() : date.getHours();\n                rep = h > 12 ? h % 12 : h;\n                break;\n            case \"m\":\n                rep = utc ? date.getUTCMinutes() : date.getMinutes();\n                break;\n            case \"s\":\n                rep = utc ? date.getUTCSeconds() : date.getSeconds();\n                break;\n            case \"f\":\n                rep = utc ? date.getUTCMilliseconds() : date.getMilliseconds();\n                break;\n        }\n        if (Number.isNaN(rep)) {\n            return match;\n        }\n        else {\n            return (rep < 10 && match.length > 1) ? \"0\" + rep : \"\" + rep;\n        }\n    });\n}\nfunction dateToStringWithOffset(date, format) {\n    var _a, _b, _c;\n    const d = new Date(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0));\n    if (typeof format !== \"string\") {\n        return d.toISOString().replace(/\\.\\d+/, \"\").replace(/[A-Z]|\\.\\d+/g, \" \") + dateOffsetToString(((_b = date.offset) !== null && _b !== void 0 ? _b : 0));\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\": return dateToHalfUTCString(d, \"first\");\n            case \"T\":\n            case \"t\": return dateToHalfUTCString(d, \"second\");\n            case \"O\":\n            case \"o\": return dateToISOStringWithOffset(d, ((_c = date.offset) !== null && _c !== void 0 ? _c : 0));\n            default: throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(d, format, true);\n    }\n}\nfunction dateToStringWithKind(date, format) {\n    const utc = date.kind === 1 /* UTC */;\n    if (typeof format !== \"string\") {\n        return utc ? date.toUTCString() : date.toLocaleString();\n    }\n    else if (format.length === 1) {\n        switch (format) {\n            case \"D\":\n            case \"d\":\n                return utc ? dateToHalfUTCString(date, \"first\") : date.toLocaleDateString();\n            case \"T\":\n            case \"t\":\n                return utc ? dateToHalfUTCString(date, \"second\") : date.toLocaleTimeString();\n            case \"O\":\n            case \"o\":\n                return dateToISOString(date, utc);\n            default:\n                throw new Error(\"Unrecognized Date print format\");\n        }\n    }\n    else {\n        return dateToStringWithCustomFormat(date, format, utc);\n    }\n}\nexport function toString(date, format, _provider) {\n    return date.offset != null\n        ? dateToStringWithOffset(date, format)\n        : dateToStringWithKind(date, format);\n}\nexport function DateTime(value, kind) {\n    const d = new Date(value);\n    d.kind = (kind == null ? 0 /* Unspecified */ : kind) | 0;\n    return d;\n}\nexport function fromTicks(ticks, kind) {\n    ticks = fromValue(ticks);\n    kind = kind != null ? kind : 0 /* Unspecified */;\n    let date = DateTime(ticksToUnixEpochMilliseconds(ticks), kind);\n    // Ticks are local to offset (in this case, either UTC or Local/Unknown).\n    // If kind is anything but UTC, that means that the tick number was not\n    // in utc, thus getTime() cannot return UTC, and needs to be shifted.\n    if (kind !== 1 /* UTC */) {\n        date = DateTime(date.getTime() - dateOffset(date), kind);\n    }\n    return date;\n}\nexport function fromDateTimeOffset(date, kind) {\n    var _a;\n    switch (kind) {\n        case 1 /* UTC */: return DateTime(date.getTime(), 1 /* UTC */);\n        case 2 /* Local */: return DateTime(date.getTime(), 2 /* Local */);\n        default:\n            const d = DateTime(date.getTime() + ((_a = date.offset) !== null && _a !== void 0 ? _a : 0), kind);\n            return DateTime(d.getTime() - dateOffset(d), kind);\n    }\n}\nexport function getTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), dateOffset(date));\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTime(-62135596800000, 0 /* Unspecified */);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTime(253402300799999, 0 /* Unspecified */);\n}\nexport function parseRaw(input) {\n    if (input === null) {\n        throw new Error(\"Value cannot be null when parsing DateTime\");\n    }\n    if (input.trim() === \"\") {\n        throw new Error(\"An empty string is not recognized as a valid DateTime\");\n    }\n    let date = new Date(input);\n    if (isNaN(date.getTime())) {\n        // Try to check strings JS Date cannot parse (see #1045, #1422)\n        // tslint:disable-next-line:max-line-length\n        const m = /^\\s*(\\d+[^\\w\\s:]\\d+[^\\w\\s:]\\d+)?\\s*(\\d+:\\d+(?::\\d+(?:\\.\\d+)?)?)?\\s*([AaPp][Mm])?\\s*([+-]\\d+(?::\\d+)?)?\\s*$/.exec(input);\n        if (m != null) {\n            let baseDate;\n            let timeInSeconds = 0;\n            if (m[2] != null) {\n                const timeParts = m[2].split(\":\");\n                timeInSeconds =\n                    parseInt(timeParts[0], 10) * 3600 +\n                        parseInt(timeParts[1] || \"0\", 10) * 60 +\n                        parseFloat(timeParts[2] || \"0\");\n                if (m[3] != null && m[3].toUpperCase() === \"PM\") {\n                    timeInSeconds += 720;\n                }\n            }\n            if (m[4] != null) { // There's an offset, parse as UTC\n                if (m[1] != null) {\n                    baseDate = new Date(m[1] + \" UTC\");\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getUTCFullYear() + \"/\" + (d.getUTCMonth() + 1) + \"/\" + d.getUTCDate());\n                }\n                const offsetParts = m[4].substr(1).split(\":\");\n                let offsetInMinutes = parseInt(offsetParts[0], 10) * 60 + parseInt(offsetParts[1] || \"0\", 10);\n                if (m[4][0] === \"+\") {\n                    offsetInMinutes *= -1;\n                }\n                timeInSeconds += offsetInMinutes * 60;\n            }\n            else {\n                if (m[1] != null) {\n                    baseDate = new Date(m[1]);\n                }\n                else {\n                    const d = new Date();\n                    baseDate = new Date(d.getFullYear() + \"/\" + (d.getMonth() + 1) + \"/\" + d.getDate());\n                }\n            }\n            date = new Date(baseDate.getTime() + timeInSeconds * 1000);\n            // correct for daylight savings time\n            date = new Date(date.getTime() + (date.getTimezoneOffset() - baseDate.getTimezoneOffset()) * 60000);\n        }\n        else {\n            throw new Error(\"The string is not a valid Date.\");\n        }\n    }\n    return date;\n}\nexport function parse(str, detectUTC = false) {\n    const date = parseRaw(str);\n    const offset = offsetRegex.exec(str);\n    // .NET always parses DateTime as Local if there's offset info (even \"Z\")\n    // Newtonsoft.Json uses UTC if the offset is \"Z\"\n    const kind = offset != null\n        ? (detectUTC && offset[0] === \"Z\" ? 1 /* UTC */ : 2 /* Local */)\n        : 0 /* Unspecified */;\n    return DateTime(date.getTime(), kind);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h = 0, m = 0, s = 0, ms = 0, kind) {\n    const dateValue = kind === 1 /* UTC */\n        ? Date.UTC(year, month - 1, day, h, m, s, ms)\n        : new Date(year, month - 1, day, h, m, s, ms).getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date.\");\n    }\n    const date = DateTime(dateValue, kind);\n    if (year <= 99) {\n        date.setFullYear(year, month - 1, day);\n    }\n    return date;\n}\nexport function now() {\n    return DateTime(Date.now(), 2 /* Local */);\n}\nexport function utcNow() {\n    return DateTime(Date.now(), 1 /* UTC */);\n}\nexport function today() {\n    return date(now());\n}\nexport function isLeapYear(year) {\n    return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0;\n}\nexport function daysInMonth(year, month) {\n    return month === 2\n        ? (isLeapYear(year) ? 29 : 28)\n        : (month >= 8 ? (month % 2 === 0 ? 31 : 30) : (month % 2 === 0 ? 30 : 31));\n}\nexport function toUniversalTime(date) {\n    return date.kind === 1 /* UTC */ ? date : DateTime(date.getTime(), 1 /* UTC */);\n}\nexport function toLocalTime(date) {\n    return date.kind === 2 /* Local */ ? date : DateTime(date.getTime(), 2 /* Local */);\n}\nexport function specifyKind(d, kind) {\n    return create(year(d), month(d), day(d), hour(d), minute(d), second(d), millisecond(d), kind);\n}\nexport function timeOfDay(d) {\n    return hour(d) * 3600000\n        + minute(d) * 60000\n        + second(d) * 1000\n        + millisecond(d);\n}\nexport function date(d) {\n    return create(year(d), month(d), day(d), 0, 0, 0, 0, d.kind);\n}\nexport function day(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDate() : d.getDate();\n}\nexport function hour(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCHours() : d.getHours();\n}\nexport function millisecond(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMilliseconds() : d.getMilliseconds();\n}\nexport function minute(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCMinutes() : d.getMinutes();\n}\nexport function month(d) {\n    return (d.kind === 1 /* UTC */ ? d.getUTCMonth() : d.getMonth()) + 1;\n}\nexport function second(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCSeconds() : d.getSeconds();\n}\nexport function year(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCFullYear() : d.getFullYear();\n}\nexport function dayOfWeek(d) {\n    return d.kind === 1 /* UTC */ ? d.getUTCDay() : d.getDay();\n}\nexport function dayOfYear(d) {\n    const _year = year(d);\n    const _month = month(d);\n    let _day = day(d);\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    const newDate = DateTime(d.getTime() + ts, d.kind);\n    if (d.kind === 2 /* Local */) {\n        const oldTzOffset = d.getTimezoneOffset();\n        const newTzOffset = newDate.getTimezoneOffset();\n        return oldTzOffset !== newTzOffset\n            ? DateTime(newDate.getTime() + (newTzOffset - oldTzOffset) * 60000, d.kind)\n            : newDate;\n    }\n    else {\n        return newDate;\n    }\n}\nexport function addDays(d, v) {\n    return add(d, v * 86400000);\n}\nexport function addHours(d, v) {\n    return add(d, v * 3600000);\n}\nexport function addMinutes(d, v) {\n    return add(d, v * 60000);\n}\nexport function addSeconds(d, v) {\n    return add(d, v * 1000);\n}\nexport function addMilliseconds(d, v) {\n    return add(d, v);\n}\nexport function addYears(d, v) {\n    const newMonth = month(d);\n    const newYear = year(d) + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function addMonths(d, v) {\n    let newMonth = month(d) + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = year(d) + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, day(d));\n    return create(newYear, newMonth, newDay, hour(d), minute(d), second(d), millisecond(d), d.kind);\n}\nexport function subtract(d, that) {\n    return typeof that === \"number\"\n        ? add(d, -that)\n        : d.getTime() - that.getTime();\n}\nexport function toLongDateString(d) {\n    return d.toDateString();\n}\nexport function toShortDateString(d) {\n    return d.toLocaleDateString();\n}\nexport function toLongTimeString(d) {\n    return d.toLocaleTimeString();\n}\nexport function toShortTimeString(d) {\n    return d.toLocaleTimeString().replace(/:\\d\\d(?!:)/, \"\");\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport const compare = compareDates;\nexport const compareTo = compareDates;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\nexport function isDaylightSavingTime(x) {\n    const jan = new Date(x.getFullYear(), 0, 1);\n    const jul = new Date(x.getFullYear(), 6, 1);\n    return isDST(jan.getTimezoneOffset(), jul.getTimezoneOffset(), x.getTimezoneOffset());\n}\nfunction isDST(janOffset, julOffset, tOffset) {\n    return Math.min(janOffset, julOffset) === tOffset;\n}\nexport default DateTime;\n","export function create(pattern, options = 0) {\n    // Supported RegexOptions\n    // * IgnoreCase:  0x0001\n    // * Multiline:   0x0002\n    // * Singleline:  0x0010\n    // * ECMAScript:  0x0100 (ignored)\n    if ((options & ~(1 ^ 2 ^ 16 ^ 256)) !== 0) {\n        throw new Error(\"RegexOptions only supports: IgnoreCase, Multiline, Singleline and ECMAScript\");\n    }\n    let flags = \"g\";\n    flags += options & 1 ? \"i\" : \"\"; // 0x0001 RegexOptions.IgnoreCase\n    flags += options & 2 ? \"m\" : \"\";\n    flags += options & 16 ? \"s\" : \"\";\n    return new RegExp(pattern, flags);\n}\n// From http://stackoverflow.com/questions/3446170/escape-string-for-use-in-javascript-regex\nexport function escape(str) {\n    return str.replace(/[\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|]/g, \"\\\\$&\");\n}\nexport function unescape(str) {\n    return str.replace(/\\\\([\\-\\[\\]\\/\\{\\}\\(\\)\\*\\+\\?\\.\\\\\\^\\$\\|])/g, \"$1\");\n}\nexport function isMatch(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    return reg.test(str);\n}\nexport function match(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    return reg.exec(str);\n}\nexport function matches(str, pattern, options = 0) {\n    let reg;\n    reg = str instanceof RegExp\n        ? (reg = str, str = pattern, reg.lastIndex = options, reg)\n        : reg = create(pattern, options);\n    if (!reg.global) {\n        throw new Error(\"Non-global RegExp\"); // Prevent infinite loop\n    }\n    let m = reg.exec(str);\n    const matches = [];\n    while (m !== null) {\n        matches.push(m);\n        m = reg.exec(str);\n    }\n    return matches;\n}\nexport function options(reg) {\n    let options = 256; // ECMAScript\n    options |= reg.ignoreCase ? 1 : 0;\n    options |= reg.multiline ? 2 : 0;\n    return options;\n}\nexport function replace(reg, input, replacement, limit, offset = 0) {\n    function replacer() {\n        let res = arguments[0];\n        if (limit) {\n            limit--;\n            const match = [];\n            const len = arguments.length;\n            // arguments: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace#specifying_a_function_as_a_parameter\n            // * match: matched substring\n            // * p1, p2, ...: nth capture group string\n            // * offset: offset of matched substring\n            // * string: whole string examined\n            // * groups: named capturing groups\n            //           ONLY if regex contains a named capture group AND browser supports named groups\n            // -> last element can be groups OR input string\n            // -> check if last element is string\n            const withGroups = typeof arguments[len - 1] !== \"string\";\n            let pLast = withGroups ? len - 3 : len - 2;\n            for (let i = 0; i < pLast; i++) {\n                match.push(arguments[i]);\n            }\n            match.index = arguments[pLast++];\n            match.input = arguments[pLast++];\n            if (withGroups) {\n                match.groups = arguments[pLast];\n            }\n            res = replacement(match);\n        }\n        return res;\n    }\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    if (typeof replacement === \"function\") {\n        limit = limit == null ? -1 : limit;\n        return input.substring(0, offset) + input.substring(offset).replace(reg, replacer);\n    }\n    else {\n        replacement =\n            replacement\n                // $0 doesn't work with JS regex, see #1155\n                .replace(/\\$0/g, (_s) => \"$&\")\n                // named groups in replacement are `${name}` in .Net, but `$<name>` in JS (in regex: groups are `(?<name>...)` in both)\n                .replace(/\\${([^}]+)}/g, \"\\$<$1>\");\n        if (limit != null) {\n            let m;\n            const sub1 = input.substring(offset);\n            const _matches = matches(reg, sub1);\n            const sub2 = matches.length > limit ? (m = _matches[limit - 1], sub1.substring(0, m.index + m[0].length)) : sub1;\n            return input.substring(0, offset) + sub2.replace(reg, replacement)\n                + input.substring(offset + sub2.length);\n        }\n        else {\n            return input.replace(reg, replacement);\n        }\n    }\n}\nexport function split(reg, input, limit, offset = 0) {\n    if (typeof reg === \"string\") {\n        const tmp = reg;\n        reg = create(input, limit !== null && limit !== void 0 ? limit : 0);\n        input = tmp;\n        limit = undefined;\n    }\n    input = input.substring(offset);\n    return input.split(reg, limit);\n}\n","import { toString as dateToString } from \"./Date.js\";\nimport { compare as numericCompare, isNumeric, multiply, toExponential, toFixed, toHex, toPrecision } from \"./Numeric.js\";\nimport { escape } from \"./RegExp.js\";\nimport { FSharpRef, toString } from \"./Types.js\";\nconst fsFormatRegExp = /(^|[^%])%([0+\\- ]*)(\\*|\\d+)?(?:\\.(\\d+))?(\\w)/;\nconst interpolateRegExp = /(?:(^|[^%])%([0+\\- ]*)(\\d+)?(?:\\.(\\d+))?(\\w))?%P\\(\\)/g;\nconst formatRegExp = /\\{(\\d+)(,-?\\d+)?(?:\\:([a-zA-Z])(\\d{0,2})|\\:(.+?))?\\}/g;\nfunction isLessThan(x, y) {\n    return numericCompare(x, y) < 0;\n}\nfunction cmp(x, y, ic) {\n    function isIgnoreCase(i) {\n        return i === true ||\n            i === 1 /* CurrentCultureIgnoreCase */ ||\n            i === 3 /* InvariantCultureIgnoreCase */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    function isOrdinal(i) {\n        return i === 4 /* Ordinal */ ||\n            i === 5 /* OrdinalIgnoreCase */;\n    }\n    if (x == null) {\n        return y == null ? 0 : -1;\n    }\n    if (y == null) {\n        return 1;\n    } // everything is bigger than null\n    if (isOrdinal(ic)) {\n        if (isIgnoreCase(ic)) {\n            x = x.toLowerCase();\n            y = y.toLowerCase();\n        }\n        return (x === y) ? 0 : (x < y ? -1 : 1);\n    }\n    else {\n        if (isIgnoreCase(ic)) {\n            x = x.toLocaleLowerCase();\n            y = y.toLocaleLowerCase();\n        }\n        return x.localeCompare(y);\n    }\n}\nexport function compare(...args) {\n    switch (args.length) {\n        case 2: return cmp(args[0], args[1], false);\n        case 3: return cmp(args[0], args[1], args[2]);\n        case 4: return cmp(args[0], args[1], args[2] === true);\n        case 5: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), false);\n        case 6: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5]);\n        case 7: return cmp(args[0].substr(args[1], args[4]), args[2].substr(args[3], args[4]), args[5] === true);\n        default: throw new Error(\"String.compare: Unsupported number of parameters\");\n    }\n}\nexport function compareOrdinal(x, y) {\n    return cmp(x, y, 4 /* Ordinal */);\n}\nexport function compareTo(x, y) {\n    return cmp(x, y, 0 /* CurrentCulture */);\n}\nexport function startsWith(str, pattern, ic) {\n    if (str.length >= pattern.length) {\n        return cmp(str.substr(0, pattern.length), pattern, ic) === 0;\n    }\n    return false;\n}\nexport function indexOfAny(str, anyOf, ...args) {\n    if (str == null || str === \"\") {\n        return -1;\n    }\n    const startIndex = (args.length > 0) ? args[0] : 0;\n    if (startIndex < 0) {\n        throw new Error(\"Start index cannot be negative\");\n    }\n    const length = (args.length > 1) ? args[1] : str.length - startIndex;\n    if (length < 0) {\n        throw new Error(\"Length cannot be negative\");\n    }\n    if (length > str.length - startIndex) {\n        throw new Error(\"Invalid startIndex and length\");\n    }\n    str = str.substr(startIndex, length);\n    for (const c of anyOf) {\n        const index = str.indexOf(c);\n        if (index > -1) {\n            return index + startIndex;\n        }\n    }\n    return -1;\n}\nexport function printf(input) {\n    return {\n        input,\n        cont: fsFormat(input),\n    };\n}\nexport function interpolate(input, values) {\n    let i = 0;\n    return input.replace(interpolateRegExp, (_, prefix, flags, padLength, precision, format) => {\n        return formatReplacement(values[i++], prefix, flags, padLength, precision, format);\n    });\n}\nfunction continuePrint(cont, arg) {\n    return typeof arg === \"string\" ? cont(arg) : arg.cont(cont);\n}\nexport function toConsole(arg) {\n    // Don't remove the lambda here, see #1357\n    return continuePrint((x) => console.log(x), arg);\n}\nexport function toConsoleError(arg) {\n    return continuePrint((x) => console.error(x), arg);\n}\nexport function toText(arg) {\n    return continuePrint((x) => x, arg);\n}\nexport function toFail(arg) {\n    return continuePrint((x) => {\n        throw new Error(x);\n    }, arg);\n}\nfunction formatReplacement(rep, prefix, flags, padLength, precision, format) {\n    let sign = \"\";\n    flags = flags || \"\";\n    format = format || \"\";\n    if (isNumeric(rep)) {\n        if (format.toLowerCase() !== \"x\") {\n            if (isLessThan(rep, 0)) {\n                rep = multiply(rep, -1);\n                sign = \"-\";\n            }\n            else {\n                if (flags.indexOf(\" \") >= 0) {\n                    sign = \" \";\n                }\n                else if (flags.indexOf(\"+\") >= 0) {\n                    sign = \"+\";\n                }\n            }\n        }\n        precision = precision == null ? null : parseInt(precision, 10);\n        switch (format) {\n            case \"f\":\n            case \"F\":\n                precision = precision != null ? precision : 6;\n                rep = toFixed(rep, precision);\n                break;\n            case \"g\":\n            case \"G\":\n                rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                break;\n            case \"e\":\n            case \"E\":\n                rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                break;\n            case \"x\":\n                rep = toHex(rep);\n                break;\n            case \"X\":\n                rep = toHex(rep).toUpperCase();\n                break;\n            default: // AOid\n                rep = String(rep);\n                break;\n        }\n    }\n    else if (rep instanceof Date) {\n        rep = dateToString(rep);\n    }\n    else {\n        rep = toString(rep);\n    }\n    padLength = typeof padLength === \"number\" ? padLength : parseInt(padLength, 10);\n    if (!isNaN(padLength)) {\n        const zeroFlag = flags.indexOf(\"0\") >= 0; // Use '0' for left padding\n        const minusFlag = flags.indexOf(\"-\") >= 0; // Right padding\n        const ch = minusFlag || !zeroFlag ? \" \" : \"0\";\n        if (ch === \"0\") {\n            rep = padLeft(rep, padLength - sign.length, ch, minusFlag);\n            rep = sign + rep;\n        }\n        else {\n            rep = padLeft(sign + rep, padLength, ch, minusFlag);\n        }\n    }\n    else {\n        rep = sign + rep;\n    }\n    return prefix ? prefix + rep : rep;\n}\nfunction formatOnce(str2, rep, padRef) {\n    return str2.replace(fsFormatRegExp, (match, prefix, flags, padLength, precision, format) => {\n        if (padRef.contents != null) {\n            padLength = padRef.contents;\n            padRef.contents = null;\n        }\n        else if (padLength === \"*\") {\n            if (rep < 0) {\n                throw new Error(\"Non-negative number required\");\n            }\n            padRef.contents = rep;\n            return match;\n        }\n        const once = formatReplacement(rep, prefix, flags, padLength, precision, format);\n        return once.replace(/%/g, \"%%\");\n    });\n}\nfunction createPrinter(str, cont, padRef = new FSharpRef(null)) {\n    return (...args) => {\n        // Make a copy as the function may be used several times\n        let strCopy = str;\n        for (const arg of args) {\n            strCopy = formatOnce(strCopy, arg, padRef);\n        }\n        return fsFormatRegExp.test(strCopy)\n            ? createPrinter(strCopy, cont, padRef)\n            : cont(strCopy.replace(/%%/g, \"%\"));\n    };\n}\nexport function fsFormat(str) {\n    return (cont) => {\n        return fsFormatRegExp.test(str)\n            ? createPrinter(str, cont)\n            : cont(str);\n    };\n}\nexport function format(str, ...args) {\n    if (typeof str === \"object\" && args.length > 0) {\n        // Called with culture info\n        str = args[0];\n        args.shift();\n    }\n    return str.replace(formatRegExp, (_, idx, padLength, format, precision, pattern) => {\n        let rep = args[idx];\n        if (isNumeric(rep)) {\n            precision = precision == null ? null : parseInt(precision, 10);\n            switch (format) {\n                case \"f\":\n                case \"F\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(rep, precision);\n                    break;\n                case \"g\":\n                case \"G\":\n                    rep = precision != null ? toPrecision(rep, precision) : toPrecision(rep);\n                    break;\n                case \"e\":\n                case \"E\":\n                    rep = precision != null ? toExponential(rep, precision) : toExponential(rep);\n                    break;\n                case \"p\":\n                case \"P\":\n                    precision = precision != null ? precision : 2;\n                    rep = toFixed(multiply(rep, 100), precision) + \" %\";\n                    break;\n                case \"d\":\n                case \"D\":\n                    rep = precision != null ? padLeft(String(rep), precision, \"0\") : String(rep);\n                    break;\n                case \"x\":\n                case \"X\":\n                    rep = precision != null ? padLeft(toHex(rep), precision, \"0\") : toHex(rep);\n                    if (format === \"X\") {\n                        rep = rep.toUpperCase();\n                    }\n                    break;\n                default:\n                    if (pattern) {\n                        let sign = \"\";\n                        rep = pattern.replace(/(0+)(\\.0+)?/, (_, intPart, decimalPart) => {\n                            if (isLessThan(rep, 0)) {\n                                rep = multiply(rep, -1);\n                                sign = \"-\";\n                            }\n                            rep = toFixed(rep, decimalPart != null ? decimalPart.length - 1 : 0);\n                            return padLeft(rep, (intPart || \"\").length - sign.length + (decimalPart != null ? decimalPart.length : 0), \"0\");\n                        });\n                        rep = sign + rep;\n                    }\n            }\n        }\n        else if (rep instanceof Date) {\n            rep = dateToString(rep, pattern || format);\n        }\n        else {\n            rep = toString(rep);\n        }\n        padLength = parseInt((padLength || \" \").substring(1), 10);\n        if (!isNaN(padLength)) {\n            rep = padLeft(String(rep), Math.abs(padLength), \" \", padLength < 0);\n        }\n        return rep;\n    });\n}\nexport function endsWith(str, search) {\n    const idx = str.lastIndexOf(search);\n    return idx >= 0 && idx === str.length - search.length;\n}\nexport function initialize(n, f) {\n    if (n < 0) {\n        throw new Error(\"String length must be non-negative\");\n    }\n    const xs = new Array(n);\n    for (let i = 0; i < n; i++) {\n        xs[i] = f(i);\n    }\n    return xs.join(\"\");\n}\nexport function insert(str, startIndex, value) {\n    if (startIndex < 0 || startIndex > str.length) {\n        throw new Error(\"startIndex is negative or greater than the length of this instance.\");\n    }\n    return str.substring(0, startIndex) + value + str.substring(startIndex);\n}\nexport function isNullOrEmpty(str) {\n    return typeof str !== \"string\" || str.length === 0;\n}\nexport function isNullOrWhiteSpace(str) {\n    return typeof str !== \"string\" || /^\\s*$/.test(str);\n}\nexport function concat(...xs) {\n    return xs.map((x) => String(x)).join(\"\");\n}\nexport function join(delimiter, xs) {\n    if (Array.isArray(xs)) {\n        return xs.join(delimiter);\n    }\n    else {\n        return Array.from(xs).join(delimiter);\n    }\n}\nexport function joinWithIndices(delimiter, xs, startIndex, count) {\n    const endIndexPlusOne = startIndex + count;\n    if (endIndexPlusOne > xs.length) {\n        throw new Error(\"Index and count must refer to a location within the buffer.\");\n    }\n    return xs.slice(startIndex, endIndexPlusOne).join(delimiter);\n}\nfunction notSupported(name) {\n    throw new Error(\"The environment doesn't support '\" + name + \"', please use a polyfill.\");\n}\nexport function toBase64String(inArray) {\n    let str = \"\";\n    for (let i = 0; i < inArray.length; i++) {\n        str += String.fromCharCode(inArray[i]);\n    }\n    return typeof btoa === \"function\" ? btoa(str) : notSupported(\"btoa\");\n}\nexport function fromBase64String(b64Encoded) {\n    const binary = typeof atob === \"function\" ? atob(b64Encoded) : notSupported(\"atob\");\n    const bytes = new Uint8Array(binary.length);\n    for (let i = 0; i < binary.length; i++) {\n        bytes[i] = binary.charCodeAt(i);\n    }\n    return bytes;\n}\nexport function padLeft(str, len, ch, isRight) {\n    ch = ch || \" \";\n    len = len - str.length;\n    for (let i = 0; i < len; i++) {\n        str = isRight ? str + ch : ch + str;\n    }\n    return str;\n}\nexport function padRight(str, len, ch) {\n    return padLeft(str, len, ch, true);\n}\nexport function remove(str, startIndex, count) {\n    if (startIndex >= str.length) {\n        throw new Error(\"startIndex must be less than length of string\");\n    }\n    if (typeof count === \"number\" && (startIndex + count) > str.length) {\n        throw new Error(\"Index and count must refer to a location within the string.\");\n    }\n    return str.slice(0, startIndex) + (typeof count === \"number\" ? str.substr(startIndex + count) : \"\");\n}\nexport function replace(str, search, replace) {\n    return str.replace(new RegExp(escape(search), \"g\"), replace);\n}\nexport function replicate(n, x) {\n    return initialize(n, () => x);\n}\nexport function getCharAtIndex(input, index) {\n    if (index < 0 || index >= input.length) {\n        throw new Error(\"Index was outside the bounds of the array.\");\n    }\n    return input[index];\n}\nexport function split(str, splitters, count, removeEmpty) {\n    count = typeof count === \"number\" ? count : undefined;\n    removeEmpty = typeof removeEmpty === \"number\" ? removeEmpty : undefined;\n    if (count && count < 0) {\n        throw new Error(\"Count cannot be less than zero\");\n    }\n    if (count === 0) {\n        return [];\n    }\n    if (!Array.isArray(splitters)) {\n        if (removeEmpty === 0) {\n            return str.split(splitters, count);\n        }\n        const len = arguments.length;\n        splitters = Array(len - 1);\n        for (let key = 1; key < len; key++) {\n            splitters[key - 1] = arguments[key];\n        }\n    }\n    splitters = splitters.map((x) => escape(x));\n    splitters = splitters.length > 0 ? splitters : [\" \"];\n    let i = 0;\n    const splits = [];\n    const reg = new RegExp(splitters.join(\"|\"), \"g\");\n    while (count == null || count > 1) {\n        const m = reg.exec(str);\n        if (m === null) {\n            break;\n        }\n        if (!removeEmpty || (m.index - i) > 0) {\n            count = count != null ? count - 1 : count;\n            splits.push(str.substring(i, m.index));\n        }\n        i = reg.lastIndex;\n    }\n    if (!removeEmpty || (str.length - i) > 0) {\n        splits.push(str.substring(i));\n    }\n    return splits;\n}\nexport function trim(str, ...chars) {\n    if (chars.length === 0) {\n        return str.trim();\n    }\n    const pattern = \"[\" + escape(chars.join(\"\")) + \"]+\";\n    return str.replace(new RegExp(\"^\" + pattern), \"\").replace(new RegExp(pattern + \"$\"), \"\");\n}\nexport function trimStart(str, ...chars) {\n    return chars.length === 0\n        ? str.trimStart()\n        : str.replace(new RegExp(\"^[\" + escape(chars.join(\"\")) + \"]+\"), \"\");\n}\nexport function trimEnd(str, ...chars) {\n    return chars.length === 0\n        ? str.trimEnd()\n        : str.replace(new RegExp(\"[\" + escape(chars.join(\"\")) + \"]+$\"), \"\");\n}\nexport function filter(pred, x) {\n    return x.split(\"\").filter((c) => pred(c)).join(\"\");\n}\nexport function substring(str, startIndex, length) {\n    if ((startIndex + (length || 0) > str.length)) {\n        throw new Error(\"Invalid startIndex and/or length\");\n    }\n    return length != null ? str.substr(startIndex, length) : str.substr(startIndex);\n}\n","import { sumBy, iterate, map, iterateIndexed, toIterator, concat, getEnumerator } from \"./Seq.js\";\nimport { equals } from \"./Util.js\";\nimport { FSharpRef } from \"./Types.js\";\nimport { class_type } from \"./Reflection.js\";\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\nimport { format } from \"./String.js\";\n\nexport class Dictionary {\n    constructor(pairs, comparer) {\n        const this$ = new FSharpRef(null);\n        this.comparer = comparer;\n        this$.contents = this;\n        this.hashMap = (new Map([]));\n        this[\"init@8-1\"] = 1;\n        const enumerator = getEnumerator(pairs);\n        try {\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                const pair = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                Dictionary__Add_5BDDA1(this$.contents, pair[0], pair[1]);\n            }\n        }\n        finally {\n            enumerator.Dispose();\n        }\n    }\n    get [Symbol.toStringTag]() {\n        return \"Dictionary\";\n    }\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\n        const this$ = this;\n        return getEnumerator(this$);\n    }\n    GetEnumerator() {\n        const this$ = this;\n        return getEnumerator(concat(this$.hashMap.values()));\n    }\n    [Symbol.iterator]() {\n        return toIterator(this.GetEnumerator());\n    }\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\n        const this$ = this;\n        Dictionary__Add_5BDDA1(this$, item[0], item[1]);\n    }\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\n        const this$ = this;\n        Dictionary__Clear(this$);\n    }\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\n        const this$ = this;\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\n        let pattern_matching_result;\n        if (matchValue != null) {\n            if (equals(matchValue[1], item[1])) {\n                pattern_matching_result = 0;\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return true;\n            }\n            case 1: {\n                return false;\n            }\n        }\n    }\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\n        const this$ = this;\n        iterateIndexed((i, e) => {\n            array[arrayIndex + i] = e;\n        }, this$);\n    }\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\n        const this$ = this;\n        return Dictionary__get_Count(this$) | 0;\n    }\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\n        return false;\n    }\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\n        const this$ = this;\n        const matchValue = Dictionary__TryFind_2B595(this$, item[0]);\n        if (matchValue != null) {\n            if (equals(matchValue[1], item[1])) {\n                const value = Dictionary__Remove_2B595(this$, item[0]);\n                void value;\n            }\n            return true;\n        }\n        else {\n            return false;\n        }\n    }\n    get size() {\n        const this$ = this;\n        return Dictionary__get_Count(this$) | 0;\n    }\n    clear() {\n        const this$ = this;\n        Dictionary__Clear(this$);\n    }\n    delete(k) {\n        const this$ = this;\n        return Dictionary__Remove_2B595(this$, k);\n    }\n    entries() {\n        const this$ = this;\n        return map((p) => [p[0], p[1]], this$);\n    }\n    get(k) {\n        const this$ = this;\n        return Dictionary__get_Item_2B595(this$, k);\n    }\n    has(k) {\n        const this$ = this;\n        return Dictionary__ContainsKey_2B595(this$, k);\n    }\n    keys() {\n        const this$ = this;\n        return map((p) => p[0], this$);\n    }\n    set(k, v) {\n        const this$ = this;\n        Dictionary__set_Item_5BDDA1(this$, k, v);\n        return this$;\n    }\n    values() {\n        const this$ = this;\n        return map((p) => p[1], this$);\n    }\n    forEach(f, thisArg) {\n        const this$ = this;\n        iterate((p) => {\n            f(p[1], p[0], this$);\n        }, this$);\n    }\n}\n\nexport function Dictionary$reflection(gen0, gen1) {\n    return class_type(\"Fable.Collections.Dictionary\", [gen0, gen1], Dictionary);\n}\n\nexport function Dictionary_$ctor_6623D9B3(pairs, comparer) {\n    return new Dictionary(pairs, comparer);\n}\n\nfunction Dictionary__TryFindIndex_2B595(this$, k) {\n    const h = this$.comparer.GetHashCode(k) | 0;\n    let matchValue;\n    let outArg = null;\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\n        outArg = v;\n    })), outArg];\n    if (matchValue[0]) {\n        return [true, h, matchValue[1].findIndex((pair) => this$.comparer.Equals(k, pair[0]))];\n    }\n    else {\n        return [false, h, -1];\n    }\n}\n\nexport function Dictionary__TryFind_2B595(this$, k) {\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]];\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function Dictionary__get_Comparer(this$) {\n    return this$.comparer;\n}\n\nexport function Dictionary__Clear(this$) {\n    this$.hashMap.clear();\n}\n\nexport function Dictionary__get_Count(this$) {\n    return sumBy((pairs) => pairs.length, this$.hashMap.values(), {\n        GetZero: () => 0,\n        Add: (x, y) => (x + y),\n    });\n}\n\nexport function Dictionary__get_Item_2B595(this$, k) {\n    const matchValue = Dictionary__TryFind_2B595(this$, k);\n    if (matchValue != null) {\n        return matchValue[1];\n    }\n    else {\n        throw (new Error(\"The item was not found in collection\"));\n    }\n}\n\nexport function Dictionary__set_Item_5BDDA1(this$, k, v) {\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]] = [k, v];\n            break;\n        }\n        case 1: {\n            if (matchValue[0]) {\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\n                void undefined;\n            }\n            else {\n                this$.hashMap.set(matchValue[1], [[k, v]]);\n            }\n            break;\n        }\n    }\n}\n\nexport function Dictionary__Add_5BDDA1(this$, k, v) {\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            const msg = format(\"An item with the same key has already been added. Key: {0}\", k);\n            throw (new Error(msg));\n            break;\n        }\n        case 1: {\n            if (matchValue[0]) {\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push([k, v]));\n                void undefined;\n            }\n            else {\n                this$.hashMap.set(matchValue[1], [[k, v]]);\n            }\n            break;\n        }\n    }\n}\n\nexport function Dictionary__ContainsKey_2B595(this$, k) {\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return true;\n        }\n        case 1: {\n            return false;\n        }\n    }\n}\n\nexport function Dictionary__Remove_2B595(this$, k) {\n    const matchValue = Dictionary__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\n            return true;\n        }\n        case 1: {\n            return false;\n        }\n    }\n}\n\n","import { sumBy, iterate, map, iterateIndexed, toIterator, concat, getEnumerator } from \"./Seq.js\";\nimport { FSharpRef } from \"./Types.js\";\nimport { class_type } from \"./Reflection.js\";\nimport { getItemFromDict, tryGetValue } from \"./MapUtil.js\";\nimport { some } from \"./Option.js\";\n\nexport class HashSet {\n    constructor(items, comparer) {\n        const this$ = new FSharpRef(null);\n        this.comparer = comparer;\n        this$.contents = this;\n        this.hashMap = (new Map([]));\n        this[\"init@8-2\"] = 1;\n        const enumerator = getEnumerator(items);\n        try {\n            while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                const value = HashSet__Add_2B595(this$.contents, enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\n                void value;\n            }\n        }\n        finally {\n            enumerator.Dispose();\n        }\n    }\n    get [Symbol.toStringTag]() {\n        return \"HashSet\";\n    }\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\n        const this$ = this;\n        return getEnumerator(this$);\n    }\n    GetEnumerator() {\n        const this$ = this;\n        return getEnumerator(concat(this$.hashMap.values()));\n    }\n    [Symbol.iterator]() {\n        return toIterator(this.GetEnumerator());\n    }\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](item) {\n        const this$ = this;\n        const value = HashSet__Add_2B595(this$, item);\n        void value;\n    }\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\n        const this$ = this;\n        HashSet__Clear(this$);\n    }\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](item) {\n        const this$ = this;\n        return HashSet__Contains_2B595(this$, item);\n    }\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](array, arrayIndex) {\n        const this$ = this;\n        iterateIndexed((i, e) => {\n            array[arrayIndex + i] = e;\n        }, this$);\n    }\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\n        const this$ = this;\n        return HashSet__get_Count(this$) | 0;\n    }\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\n        return false;\n    }\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](item) {\n        const this$ = this;\n        return HashSet__Remove_2B595(this$, item);\n    }\n    get size() {\n        const this$ = this;\n        return HashSet__get_Count(this$) | 0;\n    }\n    add(k) {\n        const this$ = this;\n        const value = HashSet__Add_2B595(this$, k);\n        void value;\n        return this$;\n    }\n    clear() {\n        const this$ = this;\n        HashSet__Clear(this$);\n    }\n    delete(k) {\n        const this$ = this;\n        return HashSet__Remove_2B595(this$, k);\n    }\n    has(k) {\n        const this$ = this;\n        return HashSet__Contains_2B595(this$, k);\n    }\n    keys() {\n        const this$ = this;\n        return map((x) => x, this$);\n    }\n    values() {\n        const this$ = this;\n        return map((x) => x, this$);\n    }\n    entries() {\n        const this$ = this;\n        return map((v) => [v, v], this$);\n    }\n    forEach(f, thisArg) {\n        const this$ = this;\n        iterate((x) => {\n            f(x, x, this$);\n        }, this$);\n    }\n}\n\nexport function HashSet$reflection(gen0) {\n    return class_type(\"Fable.Collections.HashSet\", [gen0], HashSet);\n}\n\nexport function HashSet_$ctor_Z6150332D(items, comparer) {\n    return new HashSet(items, comparer);\n}\n\nfunction HashSet__TryFindIndex_2B595(this$, k) {\n    const h = this$.comparer.GetHashCode(k) | 0;\n    let matchValue;\n    let outArg = null;\n    matchValue = [tryGetValue(this$.hashMap, h, new FSharpRef(() => outArg, (v) => {\n        outArg = v;\n    })), outArg];\n    if (matchValue[0]) {\n        return [true, h, matchValue[1].findIndex((v_1) => this$.comparer.Equals(k, v_1))];\n    }\n    else {\n        return [false, h, -1];\n    }\n}\n\nfunction HashSet__TryFind_2B595(this$, k) {\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return some(getItemFromDict(this$.hashMap, matchValue[1])[matchValue[2]]);\n        }\n        case 1: {\n            return void 0;\n        }\n    }\n}\n\nexport function HashSet__get_Comparer(this$) {\n    return this$.comparer;\n}\n\nexport function HashSet__Clear(this$) {\n    this$.hashMap.clear();\n}\n\nexport function HashSet__get_Count(this$) {\n    return sumBy((pairs) => pairs.length, this$.hashMap.values(), {\n        GetZero: () => 0,\n        Add: (x, y) => (x + y),\n    });\n}\n\nexport function HashSet__Add_2B595(this$, k) {\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return false;\n        }\n        case 1: {\n            if (matchValue[0]) {\n                const value = void (getItemFromDict(this$.hashMap, matchValue[1]).push(k));\n                void undefined;\n                return true;\n            }\n            else {\n                this$.hashMap.set(matchValue[1], [k]);\n                return true;\n            }\n        }\n    }\n}\n\nexport function HashSet__Contains_2B595(this$, k) {\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return true;\n        }\n        case 1: {\n            return false;\n        }\n    }\n}\n\nexport function HashSet__Remove_2B595(this$, k) {\n    const matchValue = HashSet__TryFindIndex_2B595(this$, k);\n    let pattern_matching_result;\n    if (matchValue[0]) {\n        if (matchValue[2] > -1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n    }\n    else {\n        pattern_matching_result = 1;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            getItemFromDict(this$.hashMap, matchValue[1]).splice(matchValue[2], 1);\n            return true;\n        }\n        case 1: {\n            return false;\n        }\n    }\n}\n\n","import { value as value_2, defaultArg, some } from \"./Option.js\";\nimport { min as min_1, compare, comparePrimitives, max as max_1 } from \"./Util.js\";\nimport { Dictionary } from \"./MutableMap.js\";\nimport { addToDict, addToSet, getItemFromDict, tryGetValue } from \"./MapUtil.js\";\nimport { FSharpRef } from \"./Types.js\";\nimport { HashSet } from \"./MutableSet.js\";\nimport { iterate as iterate_1 } from \"./Seq.js\";\n\nexport function Helpers_allocateArrayFromCons(cons, len) {\n    if ((typeof cons) === \"function\") {\n        return new cons(len);\n    }\n    else {\n        return new Array(len);\n    }\n}\n\nfunction indexNotFound() {\n    throw (new Error(\"An index satisfying the predicate was not found in the collection.\"));\n}\n\nfunction differentLengths() {\n    throw (new Error(\"Arrays had different lengths\"));\n}\n\nexport function append(array1, array2, cons) {\n    const len1 = array1.length | 0;\n    const len2 = array2.length | 0;\n    const newArray = Helpers_allocateArrayFromCons(cons, len1 + len2);\n    for (let i = 0; i <= (len1 - 1); i++) {\n        newArray[i] = array1[i];\n    }\n    for (let i_1 = 0; i_1 <= (len2 - 1); i_1++) {\n        newArray[i_1 + len1] = array2[i_1];\n    }\n    return newArray;\n}\n\nexport function filter(predicate, array) {\n    return array.filter(predicate);\n}\n\nexport function fill(target, targetIndex, count, value) {\n    const start = targetIndex | 0;\n    return target.fill(value, start, (start + count));\n}\n\nexport function getSubArray(array, start, count) {\n    const start_1 = start | 0;\n    return array.slice(start_1, (start_1 + count));\n}\n\nexport function last(array) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\n    }\n    return array[array.length - 1];\n}\n\nexport function tryLast(array) {\n    if (array.length === 0) {\n        return void 0;\n    }\n    else {\n        return some(array[array.length - 1]);\n    }\n}\n\nexport function mapIndexed(f, source, cons) {\n    const len = source.length | 0;\n    const target = Helpers_allocateArrayFromCons(cons, len);\n    for (let i = 0; i <= (len - 1); i++) {\n        target[i] = f(i, source[i]);\n    }\n    return target;\n}\n\nexport function map(f, source, cons) {\n    const len = source.length | 0;\n    const target = Helpers_allocateArrayFromCons(cons, len);\n    for (let i = 0; i <= (len - 1); i++) {\n        target[i] = f(source[i]);\n    }\n    return target;\n}\n\nexport function mapIndexed2(f, source1, source2, cons) {\n    if (source1.length !== source2.length) {\n        throw (new Error(\"Arrays had different lengths\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\n    for (let i = 0; i <= (source1.length - 1); i++) {\n        result[i] = f(i, source1[i], source2[i]);\n    }\n    return result;\n}\n\nexport function map2(f, source1, source2, cons) {\n    if (source1.length !== source2.length) {\n        throw (new Error(\"Arrays had different lengths\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\n    for (let i = 0; i <= (source1.length - 1); i++) {\n        result[i] = f(source1[i], source2[i]);\n    }\n    return result;\n}\n\nexport function mapIndexed3(f, source1, source2, source3, cons) {\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\n        throw (new Error(\"Arrays had different lengths\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\n    for (let i = 0; i <= (source1.length - 1); i++) {\n        result[i] = f(i, source1[i], source2[i], source3[i]);\n    }\n    return result;\n}\n\nexport function map3(f, source1, source2, source3, cons) {\n    if ((source1.length !== source2.length) ? true : (source2.length !== source3.length)) {\n        throw (new Error(\"Arrays had different lengths\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, source1.length);\n    for (let i = 0; i <= (source1.length - 1); i++) {\n        result[i] = f(source1[i], source2[i], source3[i]);\n    }\n    return result;\n}\n\nexport function mapFold(mapping, state, array, cons) {\n    const matchValue = array.length | 0;\n    if (matchValue === 0) {\n        return [[], state];\n    }\n    else {\n        let acc = state;\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\n        for (let i = 0; i <= (array.length - 1); i++) {\n            const patternInput = mapping(acc, array[i]);\n            res[i] = patternInput[0];\n            acc = patternInput[1];\n        }\n        return [res, acc];\n    }\n}\n\nexport function mapFoldBack(mapping, array, state, cons) {\n    const matchValue = array.length | 0;\n    if (matchValue === 0) {\n        return [[], state];\n    }\n    else {\n        let acc = state;\n        const res = Helpers_allocateArrayFromCons(cons, matchValue);\n        for (let i = array.length - 1; i >= 0; i--) {\n            const patternInput = mapping(array[i], acc);\n            res[i] = patternInput[0];\n            acc = patternInput[1];\n        }\n        return [res, acc];\n    }\n}\n\nexport function indexed(source) {\n    const len = source.length | 0;\n    const target = new Array(len);\n    for (let i = 0; i <= (len - 1); i++) {\n        target[i] = [i, source[i]];\n    }\n    return target;\n}\n\nexport function truncate(count, array) {\n    const count_1 = max_1((x, y) => comparePrimitives(x, y), 0, count) | 0;\n    const start = 0;\n    return array.slice(start, (start + count_1));\n}\n\nexport function concat(arrays, cons) {\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\n    const matchValue = arrays_1.length | 0;\n    switch (matchValue) {\n        case 0: {\n            return Helpers_allocateArrayFromCons(cons, 0);\n        }\n        case 1: {\n            return arrays_1[0];\n        }\n        default: {\n            let totalIdx = 0;\n            let totalLength = 0;\n            for (let idx = 0; idx <= (arrays_1.length - 1); idx++) {\n                const arr_1 = arrays_1[idx];\n                totalLength = (totalLength + arr_1.length);\n            }\n            const result = Helpers_allocateArrayFromCons(cons, totalLength);\n            for (let idx_1 = 0; idx_1 <= (arrays_1.length - 1); idx_1++) {\n                const arr_2 = arrays_1[idx_1];\n                for (let j = 0; j <= (arr_2.length - 1); j++) {\n                    result[totalIdx] = arr_2[j];\n                    totalIdx = (totalIdx + 1);\n                }\n            }\n            return result;\n        }\n    }\n}\n\nexport function collect(mapping, array, cons) {\n    return concat(map(mapping, array, null), cons);\n}\n\nexport function countBy(projection, array, eq) {\n    const dict = new Dictionary([], eq);\n    const keys = [];\n    for (let idx = 0; idx <= (array.length - 1); idx++) {\n        const key = projection(array[idx]);\n        let matchValue;\n        let outArg = 0;\n        matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v) => {\n            outArg = v;\n        })), outArg];\n        if (matchValue[0]) {\n            dict.set(key, matchValue[1] + 1);\n        }\n        else {\n            dict.set(key, 1);\n            const value_1 = keys.push(key);\n            void value_1;\n        }\n    }\n    return map((key_1) => [key_1, getItemFromDict(dict, key_1)], keys, null);\n}\n\nexport function distinctBy(projection, array, eq) {\n    const hashSet = new HashSet([], eq);\n    return filter((arg) => addToSet(projection(arg), hashSet), array);\n}\n\nexport function distinct(array, eq) {\n    return distinctBy((x) => x, array, eq);\n}\n\nexport function where(predicate, array) {\n    return array.filter(predicate);\n}\n\nexport function contains(value, array, eq) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i >= array.length) {\n                return false;\n            }\n            else if (eq.Equals(value, array[i])) {\n                return true;\n            }\n            else {\n                i_mut = (i + 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(0);\n}\n\nexport function except(itemsToExclude, array, eq) {\n    if (array.length === 0) {\n        return array;\n    }\n    else {\n        const cached = new HashSet(itemsToExclude, eq);\n        return array.filter(((arg00) => addToSet(arg00, cached)));\n    }\n}\n\nexport function groupBy(projection, array, eq) {\n    const dict = new Dictionary([], eq);\n    const keys = [];\n    for (let idx = 0; idx <= (array.length - 1); idx++) {\n        const v = array[idx];\n        const key = projection(v);\n        let matchValue;\n        let outArg = null;\n        matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v_1) => {\n            outArg = v_1;\n        })), outArg];\n        if (matchValue[0]) {\n            void (matchValue[1].push(v));\n        }\n        else {\n            addToDict(dict, key, [v]);\n            const value = keys.push(key);\n            void value;\n        }\n    }\n    return map((key_1) => [key_1, Array.from(getItemFromDict(dict, key_1))], keys, null);\n}\n\nexport function empty(cons) {\n    return Helpers_allocateArrayFromCons(cons, 0);\n}\n\nexport function singleton(value, cons) {\n    const ar = Helpers_allocateArrayFromCons(cons, 1);\n    ar[0] = value;\n    return ar;\n}\n\nexport function initialize(count, initializer, cons) {\n    if (count < 0) {\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, count);\n    for (let i = 0; i <= (count - 1); i++) {\n        result[i] = initializer(i);\n    }\n    return result;\n}\n\nexport function pairwise(array) {\n    if (array.length < 2) {\n        return [];\n    }\n    else {\n        const count = (array.length - 1) | 0;\n        const result = new Array(count);\n        for (let i = 0; i <= (count - 1); i++) {\n            result[i] = [array[i], array[i + 1]];\n        }\n        return result;\n    }\n}\n\nexport function replicate(count, initial, cons) {\n    if (count < 0) {\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\n    }\n    const result = Helpers_allocateArrayFromCons(cons, count);\n    for (let i = 0; i <= (result.length - 1); i++) {\n        result[i] = initial;\n    }\n    return result;\n}\n\nexport function copy(array) {\n    return array.slice();\n}\n\nexport function reverse(array) {\n    const array_2 = array.slice();\n    return array_2.reverse();\n}\n\nexport function scan(folder, state, array, cons) {\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\n    res[0] = state;\n    for (let i = 0; i <= (array.length - 1); i++) {\n        res[i + 1] = folder(res[i], array[i]);\n    }\n    return res;\n}\n\nexport function scanBack(folder, array, state, cons) {\n    const res = Helpers_allocateArrayFromCons(cons, array.length + 1);\n    res[array.length] = state;\n    for (let i = array.length - 1; i >= 0; i--) {\n        res[i] = folder(array[i], res[i + 1]);\n    }\n    return res;\n}\n\nexport function skip(count, array, cons) {\n    if (count > array.length) {\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\n    }\n    if (count === array.length) {\n        return Helpers_allocateArrayFromCons(cons, 0);\n    }\n    else {\n        const count_1 = ((count < 0) ? 0 : count) | 0;\n        return array.slice(count_1);\n    }\n}\n\nexport function skipWhile(predicate, array, cons) {\n    let count = 0;\n    while ((count < array.length) ? predicate(array[count]) : false) {\n        count = (count + 1);\n    }\n    if (count === array.length) {\n        return Helpers_allocateArrayFromCons(cons, 0);\n    }\n    else {\n        const count_1 = count | 0;\n        return array.slice(count_1);\n    }\n}\n\nexport function take(count, array, cons) {\n    if (count < 0) {\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: count\"));\n    }\n    if (count > array.length) {\n        throw (new Error(\"count is greater than array length\\\\nParameter name: count\"));\n    }\n    if (count === 0) {\n        return Helpers_allocateArrayFromCons(cons, 0);\n    }\n    else {\n        const start = 0;\n        return array.slice(start, (start + count));\n    }\n}\n\nexport function takeWhile(predicate, array, cons) {\n    let count = 0;\n    while ((count < array.length) ? predicate(array[count]) : false) {\n        count = (count + 1);\n    }\n    if (count === 0) {\n        return Helpers_allocateArrayFromCons(cons, 0);\n    }\n    else {\n        const start = 0;\n        const count_1 = count | 0;\n        return array.slice(start, (start + count_1));\n    }\n}\n\nexport function addInPlace(x, array) {\n    const value = array.push(x);\n    void value;\n}\n\nexport function addRangeInPlace(range, array) {\n    iterate_1((x) => {\n        const value = array.push(x);\n        void value;\n    }, range);\n}\n\nexport function removeInPlace(item_1, array) {\n    const i = array.indexOf(item_1, 0);\n    if (i > -1) {\n        const value = array.splice(i, 1);\n        void value;\n        return true;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function removeAllInPlace(predicate, array) {\n    const countRemoveAll = (count) => {\n        const i = array.findIndex(predicate);\n        if (i > -1) {\n            const value = array.splice(i, 1);\n            void value;\n            return (countRemoveAll(count) + 1) | 0;\n        }\n        else {\n            return count | 0;\n        }\n    };\n    return countRemoveAll(0) | 0;\n}\n\nexport function copyTo(source, sourceIndex, target, targetIndex, count) {\n    const diff = (targetIndex - sourceIndex) | 0;\n    for (let i = sourceIndex; i <= ((sourceIndex + count) - 1); i++) {\n        target[i + diff] = source[i];\n    }\n}\n\nexport function copyToTypedArray(source, sourceIndex, target, targetIndex, count) {\n    try {\n        target.set(source.subarray(sourceIndex, sourceIndex + count), targetIndex);\n    }\n    catch (matchValue) {\n        copyTo(source, sourceIndex, target, targetIndex, count);\n    }\n}\n\nexport function indexOf(array, item_1, start, count) {\n    const start_1 = defaultArg(start, 0) | 0;\n    const i = array.indexOf(item_1, start_1);\n    if ((count != null) ? (i >= (start_1 + value_2(count))) : false) {\n        return -1;\n    }\n    else {\n        return i | 0;\n    }\n}\n\nexport function partition(f, source, cons) {\n    const len = source.length | 0;\n    const res1 = Helpers_allocateArrayFromCons(cons, len);\n    const res2 = Helpers_allocateArrayFromCons(cons, len);\n    let iTrue = 0;\n    let iFalse = 0;\n    for (let i = 0; i <= (len - 1); i++) {\n        if (f(source[i])) {\n            res1[iTrue] = source[i];\n            iTrue = (iTrue + 1);\n        }\n        else {\n            res2[iFalse] = source[i];\n            iFalse = (iFalse + 1);\n        }\n    }\n    return [truncate(iTrue, res1), truncate(iFalse, res2)];\n}\n\nexport function find(predicate, array) {\n    const matchValue = array.find(predicate);\n    if (matchValue == null) {\n        return indexNotFound();\n    }\n    else {\n        return value_2(matchValue);\n    }\n}\n\nexport function tryFind(predicate, array) {\n    return array.find(predicate);\n}\n\nexport function findIndex(predicate, array) {\n    const matchValue = array.findIndex(predicate);\n    if (matchValue > -1) {\n        return matchValue | 0;\n    }\n    else {\n        return indexNotFound();\n    }\n}\n\nexport function tryFindIndex(predicate, array) {\n    const matchValue = array.findIndex(predicate);\n    if (matchValue > -1) {\n        return matchValue;\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function pick(chooser, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i >= array.length) {\n                return indexNotFound();\n            }\n            else {\n                const matchValue = chooser(array[i]);\n                if (matchValue != null) {\n                    return value_2(matchValue);\n                }\n                else {\n                    i_mut = (i + 1);\n                    continue loop;\n                }\n            }\n            break;\n        }\n    };\n    return loop(0);\n}\n\nexport function tryPick(chooser, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i >= array.length) {\n                return void 0;\n            }\n            else {\n                const matchValue = chooser(array[i]);\n                if (matchValue == null) {\n                    i_mut = (i + 1);\n                    continue loop;\n                }\n                else {\n                    return matchValue;\n                }\n            }\n            break;\n        }\n    };\n    return loop(0);\n}\n\nexport function findBack(predicate, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i < 0) {\n                return indexNotFound();\n            }\n            else if (predicate(array[i])) {\n                return array[i];\n            }\n            else {\n                i_mut = (i - 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(array.length - 1);\n}\n\nexport function tryFindBack(predicate, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i < 0) {\n                return void 0;\n            }\n            else if (predicate(array[i])) {\n                return some(array[i]);\n            }\n            else {\n                i_mut = (i - 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(array.length - 1);\n}\n\nexport function findLastIndex(predicate, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i < 0) {\n                return -1;\n            }\n            else if (predicate(array[i])) {\n                return i | 0;\n            }\n            else {\n                i_mut = (i - 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(array.length - 1) | 0;\n}\n\nexport function findIndexBack(predicate, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i < 0) {\n                return indexNotFound();\n            }\n            else if (predicate(array[i])) {\n                return i | 0;\n            }\n            else {\n                i_mut = (i - 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(array.length - 1) | 0;\n}\n\nexport function tryFindIndexBack(predicate, array) {\n    const loop = (i_mut) => {\n        loop:\n        while (true) {\n            const i = i_mut;\n            if (i < 0) {\n                return void 0;\n            }\n            else if (predicate(array[i])) {\n                return i;\n            }\n            else {\n                i_mut = (i - 1);\n                continue loop;\n            }\n            break;\n        }\n    };\n    return loop(array.length - 1);\n}\n\nexport function choose(chooser, array, cons) {\n    return map((x_1) => value_2(chooser(x_1)), array.filter(((x) => (chooser(x) != null))), cons);\n}\n\nexport function foldIndexed(folder, state, array) {\n    return array.reduce(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg0, delegateArg1)), state);\n}\n\nexport function fold(folder, state, array) {\n    return array.reduce(((delegateArg0, delegateArg1) => folder(delegateArg0, delegateArg1)), state);\n}\n\nexport function iterate(action, array) {\n    for (let i = 0; i <= (array.length - 1); i++) {\n        action(array[i]);\n    }\n}\n\nexport function iterateIndexed(action, array) {\n    for (let i = 0; i <= (array.length - 1); i++) {\n        action(i, array[i]);\n    }\n}\n\nexport function iterate2(action, array1, array2) {\n    if (array1.length !== array2.length) {\n        differentLengths();\n    }\n    for (let i = 0; i <= (array1.length - 1); i++) {\n        action(array1[i], array2[i]);\n    }\n}\n\nexport function iterateIndexed2(action, array1, array2) {\n    if (array1.length !== array2.length) {\n        differentLengths();\n    }\n    for (let i = 0; i <= (array1.length - 1); i++) {\n        action(i, array1[i], array2[i]);\n    }\n}\n\nexport function isEmpty(array) {\n    return array.length === 0;\n}\n\nexport function forAll(predicate, array) {\n    return array.every(predicate);\n}\n\nexport function permute(f, array) {\n    const size = array.length | 0;\n    const res = array.slice();\n    const checkFlags = new Array(size);\n    iterateIndexed((i, x) => {\n        const j = f(i) | 0;\n        if ((j < 0) ? true : (j >= size)) {\n            throw (new Error(\"Not a valid permutation\"));\n        }\n        res[j] = x;\n        checkFlags[j] = 1;\n    }, array);\n    if (!(checkFlags.every(((y) => (1 === y))))) {\n        throw (new Error(\"Not a valid permutation\"));\n    }\n    return res;\n}\n\nexport function setSlice(target, lower, upper, source) {\n    const lower_1 = defaultArg(lower, 0) | 0;\n    const upper_1 = defaultArg(upper, 0) | 0;\n    const length = (((upper_1 > 0) ? upper_1 : (target.length - 1)) - lower_1) | 0;\n    for (let i = 0; i <= length; i++) {\n        target[i + lower_1] = source[i];\n    }\n}\n\nexport function sortInPlaceBy(projection, xs, comparer) {\n    xs.sort(((x, y) => comparer.Compare(projection(x), projection(y))));\n}\n\nexport function sortInPlace(xs, comparer) {\n    xs.sort(((x, y) => comparer.Compare(x, y)));\n}\n\nexport function sort(xs, comparer) {\n    const xs_1 = xs.slice();\n    xs_1.sort(((x, y) => comparer.Compare(x, y)));\n    return xs_1;\n}\n\nexport function sortBy(projection, xs, comparer) {\n    const xs_1 = xs.slice();\n    xs_1.sort(((x, y) => comparer.Compare(projection(x), projection(y))));\n    return xs_1;\n}\n\nexport function sortDescending(xs, comparer) {\n    const xs_1 = xs.slice();\n    xs_1.sort(((x, y) => (comparer.Compare(x, y) * -1)));\n    return xs_1;\n}\n\nexport function sortByDescending(projection, xs, comparer) {\n    const xs_1 = xs.slice();\n    xs_1.sort(((x, y) => (comparer.Compare(projection(x), projection(y)) * -1)));\n    return xs_1;\n}\n\nexport function sortWith(comparer, xs) {\n    const comparer_1 = comparer;\n    const xs_1 = xs.slice();\n    xs_1.sort(comparer_1);\n    return xs_1;\n}\n\nexport function unfold(generator, state) {\n    const res = [];\n    const loop = (state_1_mut) => {\n        loop:\n        while (true) {\n            const state_1 = state_1_mut;\n            const matchValue = generator(state_1);\n            if (matchValue != null) {\n                const x = matchValue[0];\n                const s = matchValue[1];\n                const value = res.push(x);\n                void value;\n                state_1_mut = s;\n                continue loop;\n            }\n            break;\n        }\n    };\n    loop(state);\n    return res;\n}\n\nexport function unzip(array) {\n    const len = array.length | 0;\n    const res1 = new Array(len);\n    const res2 = new Array(len);\n    iterateIndexed((i, tupledArg) => {\n        res1[i] = tupledArg[0];\n        res2[i] = tupledArg[1];\n    }, array);\n    return [res1, res2];\n}\n\nexport function unzip3(array) {\n    const len = array.length | 0;\n    const res1 = new Array(len);\n    const res2 = new Array(len);\n    const res3 = new Array(len);\n    iterateIndexed((i, tupledArg) => {\n        res1[i] = tupledArg[0];\n        res2[i] = tupledArg[1];\n        res3[i] = tupledArg[2];\n    }, array);\n    return [res1, res2, res3];\n}\n\nexport function zip(array1, array2) {\n    if (array1.length !== array2.length) {\n        differentLengths();\n    }\n    const result = new Array(array1.length);\n    for (let i = 0; i <= (array1.length - 1); i++) {\n        result[i] = [array1[i], array2[i]];\n    }\n    return result;\n}\n\nexport function zip3(array1, array2, array3) {\n    if ((array1.length !== array2.length) ? true : (array2.length !== array3.length)) {\n        differentLengths();\n    }\n    const result = new Array(array1.length);\n    for (let i = 0; i <= (array1.length - 1); i++) {\n        result[i] = [array1[i], array2[i], array3[i]];\n    }\n    return result;\n}\n\nexport function chunkBySize(chunkSize, array) {\n    if (chunkSize < 1) {\n        throw (new Error(\"The input must be positive.\\\\nParameter name: size\"));\n    }\n    if (array.length === 0) {\n        return [[]];\n    }\n    else {\n        const result = [];\n        for (let x = 0; x <= ((~(~Math.ceil(array.length / chunkSize))) - 1); x++) {\n            let slice;\n            const start_1 = (x * chunkSize) | 0;\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\n            const value = result.push(slice);\n            void value;\n        }\n        return result;\n    }\n}\n\nexport function splitAt(index, array) {\n    let start;\n    if (index < 0) {\n        throw (new Error(\"The input must be non-negative\\\\nParameter name: index\"));\n    }\n    if (index > array.length) {\n        throw (new Error(\"The input sequence has an insufficient number of elements.\\\\nParameter name: index\"));\n    }\n    return [(start = 0, array.slice(start, (start + index))), array.slice(index)];\n}\n\nexport function compareWith(comparer, array1, array2) {\n    if (array1 == null) {\n        if (array2 == null) {\n            return 0;\n        }\n        else {\n            return -1;\n        }\n    }\n    else if (array2 == null) {\n        return 1;\n    }\n    else {\n        let i = 0;\n        let result = 0;\n        const length1 = array1.length | 0;\n        const length2 = array2.length | 0;\n        if (length1 > length2) {\n            return 1;\n        }\n        else if (length1 < length2) {\n            return -1;\n        }\n        else {\n            while ((i < length1) ? (result === 0) : false) {\n                result = comparer(array1[i], array2[i]);\n                i = (i + 1);\n            }\n            return result | 0;\n        }\n    }\n}\n\nexport function equalsWith(comparer, array1, array2) {\n    return compareWith((e1, e2) => compare(e1, e2), array1, array2) === 0;\n}\n\nexport function exactlyOne(array) {\n    if (array.length === 1) {\n        return array[0];\n    }\n    else if (array.length === 0) {\n        throw (new Error(\"The input sequence was empty\\\\nParameter name: array\"));\n    }\n    else {\n        throw (new Error(\"Input array too long\\\\nParameter name: array\"));\n    }\n}\n\nexport function head(array) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\n    }\n    else {\n        return array[0];\n    }\n}\n\nexport function tryHead(array) {\n    if (array.length === 0) {\n        return void 0;\n    }\n    else {\n        return some(array[0]);\n    }\n}\n\nexport function tail(array) {\n    if (array.length === 0) {\n        throw (new Error(\"Not enough elements\\\\nParameter name: array\"));\n    }\n    return array.slice(1);\n}\n\nexport function item(index, array) {\n    return array[index];\n}\n\nexport function tryItem(index, array) {\n    if ((index < 0) ? true : (index >= array.length)) {\n        return void 0;\n    }\n    else {\n        return some(array[index]);\n    }\n}\n\nexport function foldBackIndexed(folder, array, state) {\n    return array.reduceRight(((delegateArg0, delegateArg1, delegateArg2) => folder(delegateArg2, delegateArg1, delegateArg0)), state);\n}\n\nexport function foldBack(folder, array, state) {\n    return array.reduceRight(((delegateArg0, delegateArg1) => folder(delegateArg1, delegateArg0)), state);\n}\n\nexport function foldIndexed2(folder, state, array1, array2) {\n    let acc = state;\n    if (array1.length !== array2.length) {\n        throw (new Error(\"Arrays have different lengths\"));\n    }\n    for (let i = 0; i <= (array1.length - 1); i++) {\n        acc = folder(i, acc, array1[i], array2[i]);\n    }\n    return acc;\n}\n\nexport function fold2(folder, state, array1, array2) {\n    return foldIndexed2((_arg1, acc, x, y) => folder(acc, x, y), state, array1, array2);\n}\n\nexport function foldBackIndexed2(folder, array1, array2, state) {\n    let acc = state;\n    if (array1.length !== array2.length) {\n        differentLengths();\n    }\n    const size = array1.length | 0;\n    for (let i = 1; i <= size; i++) {\n        acc = folder(i - 1, array1[size - i], array2[size - i], acc);\n    }\n    return acc;\n}\n\nexport function foldBack2(f, array1, array2, state) {\n    return foldBackIndexed2((_arg1, x, y, acc) => f(x, y, acc), array1, array2, state);\n}\n\nexport function reduce(reduction, array) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\"));\n    }\n    const reduction_1 = reduction;\n    return array.reduce(reduction_1);\n}\n\nexport function reduceBack(reduction, array) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\"));\n    }\n    const reduction_1 = reduction;\n    return array.reduceRight(reduction_1);\n}\n\nexport function forAll2(predicate, array1, array2) {\n    return fold2((acc, x, y) => (acc ? predicate(x, y) : false), true, array1, array2);\n}\n\nexport function existsOffset(predicate_mut, array_mut, index_mut) {\n    existsOffset:\n    while (true) {\n        const predicate = predicate_mut, array = array_mut, index = index_mut;\n        if (index === array.length) {\n            return false;\n        }\n        else if (predicate(array[index])) {\n            return true;\n        }\n        else {\n            predicate_mut = predicate;\n            array_mut = array;\n            index_mut = (index + 1);\n            continue existsOffset;\n        }\n        break;\n    }\n}\n\nexport function exists(predicate, array) {\n    return existsOffset(predicate, array, 0);\n}\n\nexport function existsOffset2(predicate_mut, array1_mut, array2_mut, index_mut) {\n    existsOffset2:\n    while (true) {\n        const predicate = predicate_mut, array1 = array1_mut, array2 = array2_mut, index = index_mut;\n        if (index === array1.length) {\n            return false;\n        }\n        else if (predicate(array1[index], array2[index])) {\n            return true;\n        }\n        else {\n            predicate_mut = predicate;\n            array1_mut = array1;\n            array2_mut = array2;\n            index_mut = (index + 1);\n            continue existsOffset2;\n        }\n        break;\n    }\n}\n\nexport function exists2(predicate, array1, array2) {\n    if (array1.length !== array2.length) {\n        differentLengths();\n    }\n    return existsOffset2(predicate, array1, array2, 0);\n}\n\nexport function sum(array, adder) {\n    let acc = adder.GetZero();\n    for (let i = 0; i <= (array.length - 1); i++) {\n        acc = adder.Add(acc, array[i]);\n    }\n    return acc;\n}\n\nexport function sumBy(projection, array, adder) {\n    let acc = adder.GetZero();\n    for (let i = 0; i <= (array.length - 1); i++) {\n        acc = adder.Add(acc, projection(array[i]));\n    }\n    return acc;\n}\n\nexport function maxBy(projection, xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\n}\n\nexport function max(xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), xs);\n}\n\nexport function minBy(projection, xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\n}\n\nexport function min(xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\n}\n\nexport function average(array, averager) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\n    }\n    let total = averager.GetZero();\n    for (let i = 0; i <= (array.length - 1); i++) {\n        total = averager.Add(total, array[i]);\n    }\n    return averager.DivideByInt(total, array.length);\n}\n\nexport function averageBy(projection, array, averager) {\n    if (array.length === 0) {\n        throw (new Error(\"The input array was empty\\\\nParameter name: array\"));\n    }\n    let total = averager.GetZero();\n    for (let i = 0; i <= (array.length - 1); i++) {\n        total = averager.Add(total, projection(array[i]));\n    }\n    return averager.DivideByInt(total, array.length);\n}\n\nexport function windowed(windowSize, source) {\n    if (windowSize <= 0) {\n        throw (new Error(\"windowSize must be positive\"));\n    }\n    let res;\n    const len = max_1((x, y) => comparePrimitives(x, y), 0, source.length - windowSize) | 0;\n    res = (new Array(len));\n    for (let i = windowSize; i <= source.length; i++) {\n        res[i - windowSize] = source.slice(i - windowSize, (i - 1) + 1);\n    }\n    return res;\n}\n\nexport function splitInto(chunks, array) {\n    if (chunks < 1) {\n        throw (new Error(\"The input must be positive.\\\\nParameter name: chunks\"));\n    }\n    if (array.length === 0) {\n        return [[]];\n    }\n    else {\n        const result = [];\n        const chunks_1 = min_1((x, y) => comparePrimitives(x, y), chunks, array.length) | 0;\n        const minChunkSize = (~(~(array.length / chunks_1))) | 0;\n        const chunksWithExtraItem = (array.length % chunks_1) | 0;\n        for (let i = 0; i <= (chunks_1 - 1); i++) {\n            const chunkSize = ((i < chunksWithExtraItem) ? (minChunkSize + 1) : minChunkSize) | 0;\n            let slice;\n            const start_1 = ((i * minChunkSize) + min_1((x_1, y_1) => comparePrimitives(x_1, y_1), chunksWithExtraItem, i)) | 0;\n            slice = (array.slice(start_1, (start_1 + chunkSize)));\n            const value = result.push(slice);\n            void value;\n        }\n        return result;\n    }\n}\n\nexport function transpose(arrays, cons) {\n    const arrays_1 = Array.isArray(arrays) ? arrays : (Array.from(arrays));\n    const len = arrays_1.length | 0;\n    if (len === 0) {\n        return new Array(0);\n    }\n    else {\n        const lenInner = arrays_1[0].length | 0;\n        if (!forAll((a) => (a.length === lenInner), arrays_1)) {\n            differentLengths();\n        }\n        const result = new Array(lenInner);\n        for (let i = 0; i <= (lenInner - 1); i++) {\n            result[i] = Helpers_allocateArrayFromCons(cons, len);\n            for (let j = 0; j <= (len - 1); j++) {\n                result[i][j] = arrays_1[j][i];\n            }\n        }\n        return result;\n    }\n}\n\n","import { List } from \"./Types.js\";\nimport { defaultArg, value as value_1, some } from \"./Option.js\";\nimport { FSharpRef, List as List_1 } from \"./Types.js\";\nimport { transpose as transpose_1, pairwise as pairwise_1, collect as collect_1, scanBack as scanBack_1, scan as scan_1, foldBack2 as foldBack2_1, fold2 as fold2_1, fold as fold_1, map as map_1 } from \"./Seq.js\";\nimport { uncurry, count } from \"./Util.js\";\nimport { splitInto as splitInto_1, chunkBySize as chunkBySize_1, permute as permute_1, findIndexBack as findIndexBack_1, tryFindIndexBack as tryFindIndexBack_1 } from \"./Array.js\";\nimport { HashSet } from \"./MutableSet.js\";\nimport { getItemFromDict, addToDict, tryGetValue, addToSet } from \"./MapUtil.js\";\nimport { Dictionary } from \"./MutableMap.js\";\n\nexport function empty() {\n    return new List();\n}\n\nexport function singleton(x) {\n    return new List(x, empty());\n}\n\nexport function cons(x, xs) {\n    return new List(x, xs);\n}\n\nexport function head(_arg1) {\n    if (_arg1.tail != null) {\n        return _arg1.head;\n    }\n    else {\n        throw (new Error(\"List was empty\"));\n    }\n}\n\nexport function tryHead(_arg1) {\n    if (_arg1.tail != null) {\n        return some(_arg1.head);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function tail(_arg1) {\n    if (_arg1.tail != null) {\n        return _arg1.tail;\n    }\n    else {\n        throw (new Error(\"List was empty\"));\n    }\n}\n\nexport function last(_arg1_mut) {\n    last:\n    while (true) {\n        const _arg1 = _arg1_mut;\n        if (_arg1.tail != null) {\n            if (_arg1.tail.tail == null) {\n                return _arg1.head;\n            }\n            else {\n                _arg1_mut = _arg1.tail;\n                continue last;\n            }\n        }\n        else {\n            throw (new Error(\"List was empty\"));\n        }\n        break;\n    }\n}\n\nexport function tryLast(_arg1_mut) {\n    tryLast:\n    while (true) {\n        const _arg1 = _arg1_mut;\n        if (_arg1.tail != null) {\n            if (_arg1.tail.tail == null) {\n                return some(_arg1.head);\n            }\n            else {\n                _arg1_mut = _arg1.tail;\n                continue tryLast;\n            }\n        }\n        else {\n            return void 0;\n        }\n        break;\n    }\n}\n\nexport function compareWith(comparer, xs, ys) {\n    if (xs === ys) {\n        return 0;\n    }\n    else {\n        const loop = (xs_1_mut, ys_1_mut) => {\n            loop:\n            while (true) {\n                const xs_1 = xs_1_mut, ys_1 = ys_1_mut;\n                const matchValue = [xs_1, ys_1];\n                if (matchValue[0].tail != null) {\n                    if (matchValue[1].tail != null) {\n                        const matchValue_1 = comparer(matchValue[0].head, matchValue[1].head) | 0;\n                        if (matchValue_1 === 0) {\n                            xs_1_mut = matchValue[0].tail;\n                            ys_1_mut = matchValue[1].tail;\n                            continue loop;\n                        }\n                        else {\n                            return matchValue_1 | 0;\n                        }\n                    }\n                    else {\n                        return 1;\n                    }\n                }\n                else if (matchValue[1].tail == null) {\n                    return 0;\n                }\n                else {\n                    return -1;\n                }\n                break;\n            }\n        };\n        return loop(xs, ys) | 0;\n    }\n}\n\nexport function foldIndexedAux(f_mut, i_mut, acc_mut, _arg1_mut) {\n    foldIndexedAux:\n    while (true) {\n        const f = f_mut, i = i_mut, acc = acc_mut, _arg1 = _arg1_mut;\n        if (_arg1.tail != null) {\n            f_mut = f;\n            i_mut = (i + 1);\n            acc_mut = f(i, acc, _arg1.head);\n            _arg1_mut = _arg1.tail;\n            continue foldIndexedAux;\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function foldIndexed(f, state, xs) {\n    return foldIndexedAux(f, 0, state, xs);\n}\n\nexport function fold(f_mut, state_mut, xs_mut) {\n    fold:\n    while (true) {\n        const f = f_mut, state = state_mut, xs = xs_mut;\n        if (xs.tail != null) {\n            f_mut = f;\n            state_mut = f(state, xs.head);\n            xs_mut = xs.tail;\n            continue fold;\n        }\n        else {\n            return state;\n        }\n        break;\n    }\n}\n\nexport function reverse(xs) {\n    return fold((acc, x) => (new List_1(x, acc)), new List_1(), xs);\n}\n\nexport function foldBack(f, xs, state) {\n    return fold((acc, x) => f(x, acc), state, reverse(xs));\n}\n\nexport function toSeq(xs) {\n    return map_1((x) => x, xs);\n}\n\nexport function ofSeq(xs) {\n    return reverse(fold_1((acc, x) => (new List_1(x, acc)), new List_1(), xs));\n}\n\nexport function concat(lists) {\n    return reverse(fold_1((state, xs) => fold((acc, x) => (new List_1(x, acc)), state, xs), new List_1(), lists));\n}\n\nexport function foldIndexed2Aux(f_mut, i_mut, acc_mut, bs_mut, cs_mut) {\n    foldIndexed2Aux:\n    while (true) {\n        const f = f_mut, i = i_mut, acc = acc_mut, bs = bs_mut, cs = cs_mut;\n        const matchValue = [bs, cs];\n        let pattern_matching_result, x, xs, y, ys;\n        if (matchValue[0].tail != null) {\n            if (matchValue[1].tail != null) {\n                pattern_matching_result = 1;\n                x = matchValue[0].head;\n                xs = matchValue[0].tail;\n                y = matchValue[1].head;\n                ys = matchValue[1].tail;\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else if (matchValue[1].tail == null) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 2;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return acc;\n            }\n            case 1: {\n                f_mut = f;\n                i_mut = (i + 1);\n                acc_mut = f(i, acc, x, y);\n                bs_mut = xs;\n                cs_mut = ys;\n                continue foldIndexed2Aux;\n            }\n            case 2: {\n                throw (new Error(\"Lists had different lengths\"));\n            }\n        }\n        break;\n    }\n}\n\nexport function foldIndexed2(f, state, xs, ys) {\n    return foldIndexed2Aux(f, 0, state, xs, ys);\n}\n\nexport function fold2(f, state, xs, ys) {\n    return fold2_1(f, state, xs, ys);\n}\n\nexport function foldBack2(f, xs, ys, state) {\n    return foldBack2_1(f, xs, ys, state);\n}\n\nexport function unfold(f, state) {\n    const unfoldInner = (acc_mut, state_1_mut) => {\n        unfoldInner:\n        while (true) {\n            const acc = acc_mut, state_1 = state_1_mut;\n            const matchValue = f(state_1);\n            if (matchValue != null) {\n                acc_mut = (new List_1(matchValue[0], acc));\n                state_1_mut = matchValue[1];\n                continue unfoldInner;\n            }\n            else {\n                return reverse(acc);\n            }\n            break;\n        }\n    };\n    return unfoldInner(new List_1(), state);\n}\n\nexport function foldIndexed3Aux(f_mut, i_mut, acc_mut, bs_mut, cs_mut, ds_mut) {\n    foldIndexed3Aux:\n    while (true) {\n        const f = f_mut, i = i_mut, acc = acc_mut, bs = bs_mut, cs = cs_mut, ds = ds_mut;\n        const matchValue = [bs, cs, ds];\n        let pattern_matching_result, x, xs, y, ys, z, zs;\n        if (matchValue[0].tail != null) {\n            if (matchValue[1].tail != null) {\n                if (matchValue[2].tail != null) {\n                    pattern_matching_result = 1;\n                    x = matchValue[0].head;\n                    xs = matchValue[0].tail;\n                    y = matchValue[1].head;\n                    ys = matchValue[1].tail;\n                    z = matchValue[2].head;\n                    zs = matchValue[2].tail;\n                }\n                else {\n                    pattern_matching_result = 2;\n                }\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else if (matchValue[1].tail == null) {\n            if (matchValue[2].tail == null) {\n                pattern_matching_result = 0;\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return acc;\n            }\n            case 1: {\n                f_mut = f;\n                i_mut = (i + 1);\n                acc_mut = f(i, acc, x, y, z);\n                bs_mut = xs;\n                cs_mut = ys;\n                ds_mut = zs;\n                continue foldIndexed3Aux;\n            }\n            case 2: {\n                throw (new Error(\"Lists had different lengths\"));\n            }\n        }\n        break;\n    }\n}\n\nexport function foldIndexed3(f, seed, xs, ys, zs) {\n    return foldIndexed3Aux(f, 0, seed, xs, ys, zs);\n}\n\nexport function fold3(f, state, xs, ys, zs) {\n    return foldIndexed3((_arg1, acc, x, y, z) => f(acc, x, y, z), state, xs, ys, zs);\n}\n\nexport function scan(f, state, xs) {\n    return ofSeq(scan_1(f, state, xs));\n}\n\nexport function scanBack(f, xs, state) {\n    return ofSeq(scanBack_1(f, xs, state));\n}\n\nexport function length(xs) {\n    return fold((acc, _arg1) => (acc + 1), 0, xs);\n}\n\nexport function append(xs, ys) {\n    return fold((acc, x) => (new List_1(x, acc)), ys, reverse(xs));\n}\n\nexport function collect(f, xs) {\n    return ofSeq(collect_1(f, xs));\n}\n\nexport function map(f, xs) {\n    return reverse(fold((acc, x) => (new List_1(f(x), acc)), new List_1(), xs));\n}\n\nexport function mapIndexed(f, xs) {\n    return reverse(foldIndexed((i, acc, x) => (new List_1(f(i, x), acc)), new List_1(), xs));\n}\n\nexport function indexed(xs) {\n    return mapIndexed((i, x) => [i, x], xs);\n}\n\nexport function map2(f, xs, ys) {\n    return reverse(fold2((acc, x, y) => (new List_1(f(x, y), acc)), new List_1(), xs, ys));\n}\n\nexport function mapIndexed2(f, xs, ys) {\n    return reverse(foldIndexed2((i, acc, x, y) => (new List_1(f(i, x, y), acc)), new List_1(), xs, ys));\n}\n\nexport function map3(f, xs, ys, zs) {\n    return reverse(fold3((acc, x, y, z) => (new List_1(f(x, y, z), acc)), new List_1(), xs, ys, zs));\n}\n\nexport function mapIndexed3(f, xs, ys, zs) {\n    return reverse(foldIndexed3((i, acc, x, y, z) => (new List_1(f(i, x, y, z), acc)), new List_1(), xs, ys, zs));\n}\n\nexport function mapFold(f, s, xs) {\n    const patternInput_1 = fold((tupledArg, x) => {\n        const patternInput = f(tupledArg[1], x);\n        return [new List_1(patternInput[0], tupledArg[0]), patternInput[1]];\n    }, [new List_1(), s], xs);\n    return [reverse(patternInput_1[0]), patternInput_1[1]];\n}\n\nexport function mapFoldBack(f, xs, s) {\n    return mapFold((s_1, v) => f(v, s_1), s, reverse(xs));\n}\n\nexport function iterate(f, xs) {\n    return fold((unitVar0, x) => {\n        f(x);\n    }, void 0, xs);\n}\n\nexport function iterate2(f, xs, ys) {\n    return fold2((unitVar0, x, y) => {\n        f(x, y);\n    }, void 0, xs, ys);\n}\n\nexport function iterateIndexed(f, xs) {\n    return foldIndexed((i, unitVar1, x) => {\n        f(i, x);\n    }, void 0, xs);\n}\n\nexport function iterateIndexed2(f, xs, ys) {\n    return foldIndexed2((i, unitVar1, x, y) => {\n        f(i, x, y);\n    }, void 0, xs, ys);\n}\n\nexport function ofArrayWithTail(xs, tail_1) {\n    let res = tail_1;\n    for (let i = count(xs) - 1; i >= 0; i--) {\n        res = (new List_1(xs[i], res));\n    }\n    return res;\n}\n\nexport function ofArray(xs) {\n    return ofArrayWithTail(xs, new List_1());\n}\n\nexport function isEmpty(_arg1) {\n    if (_arg1.tail == null) {\n        return true;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function tryPickIndexedAux(f_mut, i_mut, _arg1_mut) {\n    tryPickIndexedAux:\n    while (true) {\n        const f = f_mut, i = i_mut, _arg1 = _arg1_mut;\n        if (_arg1.tail != null) {\n            const result = f(i, _arg1.head);\n            if (result == null) {\n                f_mut = f;\n                i_mut = (i + 1);\n                _arg1_mut = _arg1.tail;\n                continue tryPickIndexedAux;\n            }\n            else {\n                return result;\n            }\n        }\n        else {\n            return void 0;\n        }\n        break;\n    }\n}\n\nexport function tryPickIndexed(f, xs) {\n    return tryPickIndexedAux(f, 0, xs);\n}\n\nexport function tryPick(f, xs) {\n    return tryPickIndexed((_arg1, x) => f(x), xs);\n}\n\nexport function pick(f, xs) {\n    const matchValue = tryPick(f, xs);\n    if (matchValue != null) {\n        return value_1(matchValue);\n    }\n    else {\n        throw (new Error(\"List did not contain any matching elements\"));\n    }\n}\n\nexport function tryFindIndexed(f, xs) {\n    return tryPickIndexed((i, x) => (f(i, x) ? some(x) : (void 0)), xs);\n}\n\nexport function tryFind(f, xs) {\n    return tryPickIndexed((_arg1, x) => (f(x) ? some(x) : (void 0)), xs);\n}\n\nexport function findIndexed(f, xs) {\n    const matchValue = tryFindIndexed(f, xs);\n    if (matchValue != null) {\n        return value_1(matchValue);\n    }\n    else {\n        throw (new Error(\"List did not contain any matching elements\"));\n    }\n}\n\nexport function find(f, xs) {\n    return findIndexed((_arg1, x) => f(x), xs);\n}\n\nexport function findBack(f, xs) {\n    return find(f, reverse(xs));\n}\n\nexport function tryFindBack(f, xs) {\n    return tryFind(f, reverse(xs));\n}\n\nexport function tryFindIndex(f, xs) {\n    return tryPickIndexed((i, x) => (f(x) ? i : (void 0)), xs);\n}\n\nexport function tryFindIndexBack(f, xs) {\n    return tryFindIndexBack_1(f, Array.from(xs));\n}\n\nexport function findIndex(f, xs) {\n    const matchValue = tryFindIndex(f, xs);\n    if (matchValue != null) {\n        return matchValue | 0;\n    }\n    else {\n        throw (new Error(\"List did not contain any matching elements\"));\n    }\n}\n\nexport function findIndexBack(f, xs) {\n    return findIndexBack_1(f, Array.from(xs));\n}\n\nexport function item(n, xs) {\n    return findIndexed((i, _arg1) => (n === i), xs);\n}\n\nexport function tryItem(n, xs) {\n    return tryFindIndexed((i, _arg1) => (n === i), xs);\n}\n\nexport function filter(f, xs) {\n    return reverse(fold((acc, x) => (f(x) ? (new List_1(x, acc)) : acc), new List_1(), xs));\n}\n\nexport function partition(f, xs) {\n    return fold(uncurry(2, (tupledArg) => {\n        const lacc = tupledArg[0];\n        const racc = tupledArg[1];\n        return (x) => (f(x) ? [new List_1(x, lacc), racc] : [lacc, new List_1(x, racc)]);\n    }), [new List_1(), new List_1()], reverse(xs));\n}\n\nexport function choose(f, xs) {\n    return reverse(fold((acc, x) => {\n        const matchValue = f(x);\n        return (matchValue == null) ? acc : (new List_1(value_1(matchValue), acc));\n    }, new List_1(), xs));\n}\n\nexport function contains(value, list, eq) {\n    const loop = (xs_mut) => {\n        loop:\n        while (true) {\n            const xs = xs_mut;\n            if (xs.tail != null) {\n                if (eq.Equals(value, xs.head)) {\n                    return true;\n                }\n                else {\n                    xs_mut = xs.tail;\n                    continue loop;\n                }\n            }\n            else {\n                return false;\n            }\n            break;\n        }\n    };\n    return loop(list);\n}\n\nexport function except(itemsToExclude, array, eq) {\n    if (isEmpty(array)) {\n        return array;\n    }\n    else {\n        const cached = new HashSet(itemsToExclude, eq);\n        return filter((arg00) => addToSet(arg00, cached), array);\n    }\n}\n\nexport function initialize(n, f) {\n    let xs = new List_1();\n    for (let i = 0; i <= (n - 1); i++) {\n        xs = (new List_1(f(i), xs));\n    }\n    return reverse(xs);\n}\n\nexport function replicate(n, x) {\n    return initialize(n, (_arg1) => x);\n}\n\nexport function reduce(f, _arg1) {\n    if (_arg1.tail != null) {\n        return fold(f, _arg1.head, _arg1.tail);\n    }\n    else {\n        throw (new Error(\"List was empty\"));\n    }\n}\n\nexport function reduceBack(f, _arg1) {\n    if (_arg1.tail != null) {\n        return foldBack(f, _arg1.tail, _arg1.head);\n    }\n    else {\n        throw (new Error(\"List was empty\"));\n    }\n}\n\nexport function forAll(f, xs) {\n    return fold((acc, x) => (acc ? f(x) : false), true, xs);\n}\n\nexport function forAll2(f, xs, ys) {\n    return fold2((acc, x, y) => (acc ? f(x, y) : false), true, xs, ys);\n}\n\nexport function exists(f_mut, _arg1_mut) {\n    exists:\n    while (true) {\n        const f = f_mut, _arg1 = _arg1_mut;\n        if (_arg1.tail != null) {\n            if (f(_arg1.head)) {\n                return true;\n            }\n            else {\n                f_mut = f;\n                _arg1_mut = _arg1.tail;\n                continue exists;\n            }\n        }\n        else {\n            return false;\n        }\n        break;\n    }\n}\n\nexport function exists2(f_mut, bs_mut, cs_mut) {\n    exists2:\n    while (true) {\n        const f = f_mut, bs = bs_mut, cs = cs_mut;\n        const matchValue = [bs, cs];\n        let pattern_matching_result, x, xs, y, ys;\n        if (matchValue[0].tail != null) {\n            if (matchValue[1].tail != null) {\n                pattern_matching_result = 1;\n                x = matchValue[0].head;\n                xs = matchValue[0].tail;\n                y = matchValue[1].head;\n                ys = matchValue[1].tail;\n            }\n            else {\n                pattern_matching_result = 2;\n            }\n        }\n        else if (matchValue[1].tail == null) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 2;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return false;\n            }\n            case 1: {\n                if (f(x, y)) {\n                    return true;\n                }\n                else {\n                    f_mut = f;\n                    bs_mut = xs;\n                    cs_mut = ys;\n                    continue exists2;\n                }\n            }\n            case 2: {\n                throw (new Error(\"Lists had different lengths\"));\n            }\n        }\n        break;\n    }\n}\n\nexport function unzip(xs) {\n    return foldBack((tupledArg, tupledArg_1) => [new List_1(tupledArg[0], tupledArg_1[0]), new List_1(tupledArg[1], tupledArg_1[1])], xs, [new List_1(), new List_1()]);\n}\n\nexport function unzip3(xs) {\n    return foldBack((tupledArg, tupledArg_1) => [new List_1(tupledArg[0], tupledArg_1[0]), new List_1(tupledArg[1], tupledArg_1[1]), new List_1(tupledArg[2], tupledArg_1[2])], xs, [new List_1(), new List_1(), new List_1()]);\n}\n\nexport function zip(xs, ys) {\n    return map2((x, y) => [x, y], xs, ys);\n}\n\nexport function zip3(xs, ys, zs) {\n    return map3((x, y, z) => [x, y, z], xs, ys, zs);\n}\n\nexport function sort(xs, comparer) {\n    let xs_1;\n    return ofArray((xs_1 = Array.from(xs), (xs_1.sort(((x, y) => comparer.Compare(x, y))), xs_1)));\n}\n\nexport function sortBy(projection, xs, comparer) {\n    let xs_1;\n    return ofArray((xs_1 = Array.from(xs), (xs_1.sort(((x, y) => comparer.Compare(projection(x), projection(y)))), xs_1)));\n}\n\nexport function sortDescending(xs, comparer) {\n    let xs_1;\n    return ofArray((xs_1 = Array.from(xs), (xs_1.sort(((x, y) => (comparer.Compare(x, y) * -1))), xs_1)));\n}\n\nexport function sortByDescending(projection, xs, comparer) {\n    let xs_1;\n    return ofArray((xs_1 = Array.from(xs), (xs_1.sort(((x, y) => (comparer.Compare(projection(x), projection(y)) * -1))), xs_1)));\n}\n\nexport function sortWith(comparer, xs) {\n    let comparer_1, xs_1;\n    return ofArray((comparer_1 = comparer, (xs_1 = Array.from(xs), (xs_1.sort(comparer_1), xs_1))));\n}\n\nexport function sum(xs, adder) {\n    return fold((acc, x) => adder.Add(acc, x), adder.GetZero(), xs);\n}\n\nexport function sumBy(f, xs, adder) {\n    return fold((acc, x) => adder.Add(acc, f(x)), adder.GetZero(), xs);\n}\n\nexport function maxBy(projection, xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? y : x), xs);\n}\n\nexport function max(li, comparer) {\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? y : x), li);\n}\n\nexport function minBy(projection, xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(projection(y), projection(x)) > 0) ? x : y), xs);\n}\n\nexport function min(xs, comparer) {\n    return reduce((x, y) => ((comparer.Compare(y, x) > 0) ? x : y), xs);\n}\n\nexport function average(xs, averager) {\n    return averager.DivideByInt(fold((acc, x) => averager.Add(acc, x), averager.GetZero(), xs), length(xs));\n}\n\nexport function averageBy(f, xs, averager) {\n    return averager.DivideByInt(fold((acc, x) => averager.Add(acc, f(x)), averager.GetZero(), xs), length(xs));\n}\n\nexport function permute(f, xs) {\n    return ofArray(permute_1(f, Array.from(xs)));\n}\n\nexport function chunkBySize(chunkSize, xs) {\n    return map((xs_2) => ofArray(xs_2), ofArray(chunkBySize_1(chunkSize, Array.from(xs))));\n}\n\nexport function skip(i, xs) {\n    const skipInner = (i_1_mut, xs_1_mut) => {\n        skipInner:\n        while (true) {\n            const i_1 = i_1_mut, xs_1 = xs_1_mut;\n            const matchValue = [i_1, xs_1];\n            if (matchValue[0] === 0) {\n                return xs_1;\n            }\n            else if (matchValue[1].tail != null) {\n                i_1_mut = (i_1 - 1);\n                xs_1_mut = matchValue[1].tail;\n                continue skipInner;\n            }\n            else {\n                throw (new Error(\"The input sequence has an insufficient number of elements.\"));\n            }\n            break;\n        }\n    };\n    const matchValue_1 = [i, xs];\n    if (matchValue_1[0] < 0) {\n        throw (new Error(\"The input must be non-negative.\"));\n    }\n    else {\n        let pattern_matching_result, i_4, xs_4;\n        if (matchValue_1[0] === 0) {\n            pattern_matching_result = 0;\n        }\n        else if (matchValue_1[0] === 1) {\n            if (matchValue_1[1].tail != null) {\n                pattern_matching_result = 1;\n            }\n            else {\n                pattern_matching_result = 2;\n                i_4 = matchValue_1[0];\n                xs_4 = matchValue_1[1];\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n            i_4 = matchValue_1[0];\n            xs_4 = matchValue_1[1];\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return xs;\n            }\n            case 1: {\n                return matchValue_1[1].tail;\n            }\n            case 2: {\n                return skipInner(i_4, xs_4);\n            }\n        }\n    }\n}\n\nexport function skipWhile(predicate_mut, xs_mut) {\n    skipWhile:\n    while (true) {\n        const predicate = predicate_mut, xs = xs_mut;\n        let pattern_matching_result, h_1, t_1;\n        if (xs.tail != null) {\n            if (predicate(xs.head)) {\n                pattern_matching_result = 0;\n                h_1 = xs.head;\n                t_1 = xs.tail;\n            }\n            else {\n                pattern_matching_result = 1;\n            }\n        }\n        else {\n            pattern_matching_result = 1;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                predicate_mut = predicate;\n                xs_mut = t_1;\n                continue skipWhile;\n            }\n            case 1: {\n                return xs;\n            }\n        }\n        break;\n    }\n}\n\nexport function takeSplitAux(error_mut, i_mut, acc_mut, xs_mut) {\n    takeSplitAux:\n    while (true) {\n        const error = error_mut, i = i_mut, acc = acc_mut, xs = xs_mut;\n        const matchValue = [i, xs];\n        if (matchValue[0] === 0) {\n            return [reverse(acc), xs];\n        }\n        else if (matchValue[1].tail != null) {\n            error_mut = error;\n            i_mut = (i - 1);\n            acc_mut = (new List_1(matchValue[1].head, acc));\n            xs_mut = matchValue[1].tail;\n            continue takeSplitAux;\n        }\n        else if (error) {\n            throw (new Error(\"The input sequence has an insufficient number of elements.\"));\n        }\n        else {\n            return [reverse(acc), xs];\n        }\n        break;\n    }\n}\n\nexport function take(i, xs) {\n    const matchValue = [i, xs];\n    if (matchValue[0] < 0) {\n        throw (new Error(\"The input must be non-negative.\"));\n    }\n    else {\n        let pattern_matching_result, i_3, xs_1;\n        if (matchValue[0] === 0) {\n            pattern_matching_result = 0;\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1].tail != null) {\n                pattern_matching_result = 1;\n            }\n            else {\n                pattern_matching_result = 2;\n                i_3 = matchValue[0];\n                xs_1 = matchValue[1];\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n            i_3 = matchValue[0];\n            xs_1 = matchValue[1];\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return new List_1();\n            }\n            case 1: {\n                return new List_1(matchValue[1].head, new List_1());\n            }\n            case 2: {\n                return takeSplitAux(true, i_3, new List_1(), xs_1)[0];\n            }\n        }\n    }\n}\n\nexport function takeWhile(predicate, xs) {\n    if (xs.tail != null) {\n        if (xs.tail.tail == null) {\n            if (predicate(xs.head)) {\n                return xs;\n            }\n            else {\n                return xs.tail;\n            }\n        }\n        else if (!predicate(xs.head)) {\n            return new List_1();\n        }\n        else {\n            return new List_1(xs.head, takeWhile(predicate, xs.tail));\n        }\n    }\n    else {\n        return xs;\n    }\n}\n\nexport function truncate(i, xs) {\n    const matchValue = [i, xs];\n    if (matchValue[0] < 0) {\n        throw (new Error(\"The input must be non-negative.\"));\n    }\n    else {\n        let pattern_matching_result, i_3, xs_1;\n        if (matchValue[0] === 0) {\n            pattern_matching_result = 0;\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1].tail != null) {\n                pattern_matching_result = 1;\n            }\n            else {\n                pattern_matching_result = 2;\n                i_3 = matchValue[0];\n                xs_1 = matchValue[1];\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n            i_3 = matchValue[0];\n            xs_1 = matchValue[1];\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return new List_1();\n            }\n            case 1: {\n                return new List_1(matchValue[1].head, new List_1());\n            }\n            case 2: {\n                return takeSplitAux(false, i_3, new List_1(), xs_1)[0];\n            }\n        }\n    }\n}\n\nexport function splitAt(i, xs) {\n    const matchValue = [i, xs];\n    if (matchValue[0] < 0) {\n        throw (new Error(\"The input must be non-negative.\"));\n    }\n    else {\n        let pattern_matching_result, i_3, xs_2;\n        if (matchValue[0] === 0) {\n            pattern_matching_result = 0;\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1].tail != null) {\n                pattern_matching_result = 1;\n            }\n            else {\n                pattern_matching_result = 2;\n                i_3 = matchValue[0];\n                xs_2 = matchValue[1];\n            }\n        }\n        else {\n            pattern_matching_result = 2;\n            i_3 = matchValue[0];\n            xs_2 = matchValue[1];\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return [new List_1(), xs];\n            }\n            case 1: {\n                return [new List_1(matchValue[1].head, new List_1()), matchValue[1].tail];\n            }\n            case 2: {\n                return takeSplitAux(true, i_3, new List_1(), xs_2);\n            }\n        }\n    }\n}\n\nexport function outOfRange() {\n    throw (new Error(\"Index out of range\"));\n}\n\nexport function getSlice(lower, upper, xs) {\n    const lower_1 = defaultArg(lower, 0) | 0;\n    const hasUpper = upper != null;\n    if (lower_1 < 0) {\n        return outOfRange();\n    }\n    else if (hasUpper ? (value_1(upper) < lower_1) : false) {\n        return new List_1();\n    }\n    else {\n        let lastIndex = -1;\n        const res = foldIndexed((i, acc, x) => {\n            lastIndex = i;\n            if ((lower_1 <= i) ? ((!hasUpper) ? true : (i <= value_1(upper))) : false) {\n                return new List_1(x, acc);\n            }\n            else {\n                return acc;\n            }\n        }, new List_1(), xs);\n        if ((lower_1 > (lastIndex + 1)) ? true : (hasUpper ? (value_1(upper) > lastIndex) : false)) {\n            outOfRange();\n        }\n        return reverse(res);\n    }\n}\n\nexport function distinctBy(projection, xs, eq) {\n    const hashSet = new HashSet([], eq);\n    return filter((arg) => addToSet(projection(arg), hashSet), xs);\n}\n\nexport function distinct(xs, eq) {\n    return distinctBy((x) => x, xs, eq);\n}\n\nexport function exactlyOne(xs) {\n    if (xs.tail != null) {\n        if (xs.tail.tail != null) {\n            throw (new Error(\"Input list too long\\\\nParameter name: list\"));\n        }\n        else {\n            return xs.head;\n        }\n    }\n    else {\n        throw (new Error(\"The input sequence was empty\\\\nParameter name: list\"));\n    }\n}\n\nexport function groupBy(projection, xs, eq) {\n    const dict = new Dictionary([], eq);\n    let keys = new List_1();\n    iterate((v) => {\n        const key = projection(v);\n        let matchValue;\n        let outArg = null;\n        matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v_1) => {\n            outArg = v_1;\n        })), outArg];\n        if (matchValue[0]) {\n            dict.set(key, new List_1(v, matchValue[1]));\n        }\n        else {\n            addToDict(dict, key, new List_1(v, new List_1()));\n            keys = (new List_1(key, keys));\n        }\n    }, xs);\n    let result = new List_1();\n    iterate((key_1) => {\n        result = (new List_1([key_1, reverse(getItemFromDict(dict, key_1))], result));\n    }, keys);\n    return result;\n}\n\nexport function countBy(projection, xs, eq) {\n    const dict = new Dictionary([], eq);\n    let keys = new List_1();\n    iterate((v) => {\n        const key = projection(v);\n        let matchValue;\n        let outArg = 0;\n        matchValue = [tryGetValue(dict, key, new FSharpRef(() => outArg, (v_1) => {\n            outArg = v_1;\n        })), outArg];\n        if (matchValue[0]) {\n            dict.set(key, matchValue[1] + 1);\n        }\n        else {\n            dict.set(key, 1);\n            keys = (new List_1(key, keys));\n        }\n    }, xs);\n    let result = new List_1();\n    iterate((key_1) => {\n        result = (new List_1([key_1, getItemFromDict(dict, key_1)], result));\n    }, keys);\n    return result;\n}\n\nexport function where(predicate, source) {\n    return filter(predicate, source);\n}\n\nexport function pairwise(source) {\n    return ofSeq(pairwise_1(source));\n}\n\nexport function windowed(windowSize, source) {\n    if (windowSize <= 0) {\n        throw (new Error(\"windowSize must be positive\"));\n    }\n    let res = new List_1();\n    for (let i = length(source); i >= windowSize; i--) {\n        res = (new List_1(getSlice(i - windowSize, i - 1, source), res));\n    }\n    return res;\n}\n\nexport function splitInto(chunks, source) {\n    return map((xs_1) => ofArray(xs_1), ofArray(splitInto_1(chunks, Array.from(source))));\n}\n\nexport function transpose(lists) {\n    return ofSeq(map_1((xs) => ofSeq(xs), transpose_1(lists)));\n}\n\n","export class CancellationToken {\n    constructor(cancelled = false) {\n        this._id = 0;\n        this._cancelled = cancelled;\n        this._listeners = new Map();\n    }\n    get isCancelled() {\n        return this._cancelled;\n    }\n    cancel() {\n        if (!this._cancelled) {\n            this._cancelled = true;\n            for (const [, listener] of this._listeners) {\n                listener();\n            }\n        }\n    }\n    addListener(f) {\n        const id = this._id;\n        this._listeners.set(this._id++, f);\n        return id;\n    }\n    removeListener(id) {\n        return this._listeners.delete(id);\n    }\n    register(f, state) {\n        const $ = this;\n        const id = this.addListener(state == null ? f : () => f(state));\n        return { Dispose() { $.removeListener(id); } };\n    }\n}\nexport class OperationCanceledError extends Error {\n    constructor() {\n        super(\"The operation was canceled\");\n        Object.setPrototypeOf(this, OperationCanceledError.prototype);\n    }\n}\nexport class Trampoline {\n    constructor() {\n        this.callCount = 0;\n    }\n    static get maxTrampolineCallCount() {\n        return 2000;\n    }\n    incrementAndCheck() {\n        return this.callCount++ > Trampoline.maxTrampolineCallCount;\n    }\n    hijack(f) {\n        this.callCount = 0;\n        setTimeout(f, 0);\n    }\n}\nexport function protectedCont(f) {\n    return (ctx) => {\n        if (ctx.cancelToken.isCancelled) {\n            ctx.onCancel(new OperationCanceledError());\n        }\n        else if (ctx.trampoline.incrementAndCheck()) {\n            ctx.trampoline.hijack(() => {\n                try {\n                    f(ctx);\n                }\n                catch (err) {\n                    ctx.onError(err);\n                }\n            });\n        }\n        else {\n            try {\n                f(ctx);\n            }\n            catch (err) {\n                ctx.onError(err);\n            }\n        }\n    };\n}\nexport function protectedBind(computation, binder) {\n    return protectedCont((ctx) => {\n        computation({\n            onSuccess: (x) => {\n                try {\n                    binder(x)(ctx);\n                }\n                catch (ex) {\n                    ctx.onError(ex);\n                }\n            },\n            onError: ctx.onError,\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function protectedReturn(value) {\n    return protectedCont((ctx) => ctx.onSuccess(value));\n}\nexport class AsyncBuilder {\n    Bind(computation, binder) {\n        return protectedBind(computation, binder);\n    }\n    Combine(computation1, computation2) {\n        return this.Bind(computation1, () => computation2);\n    }\n    Delay(generator) {\n        return protectedCont((ctx) => generator()(ctx));\n    }\n    For(sequence, body) {\n        const iter = sequence[Symbol.iterator]();\n        let cur = iter.next();\n        return this.While(() => !cur.done, this.Delay(() => {\n            const res = body(cur.value);\n            cur = iter.next();\n            return res;\n        }));\n    }\n    Return(value) {\n        return protectedReturn(value);\n    }\n    ReturnFrom(computation) {\n        return computation;\n    }\n    TryFinally(computation, compensation) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: (x) => {\n                    compensation();\n                    ctx.onSuccess(x);\n                },\n                onError: (x) => {\n                    compensation();\n                    ctx.onError(x);\n                },\n                onCancel: (x) => {\n                    compensation();\n                    ctx.onCancel(x);\n                },\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n            });\n        });\n    }\n    TryWith(computation, catchHandler) {\n        return protectedCont((ctx) => {\n            computation({\n                onSuccess: ctx.onSuccess,\n                onCancel: ctx.onCancel,\n                cancelToken: ctx.cancelToken,\n                trampoline: ctx.trampoline,\n                onError: (ex) => {\n                    try {\n                        catchHandler(ex)(ctx);\n                    }\n                    catch (ex2) {\n                        ctx.onError(ex2);\n                    }\n                },\n            });\n        });\n    }\n    Using(resource, binder) {\n        return this.TryFinally(binder(resource), () => resource.Dispose());\n    }\n    While(guard, computation) {\n        if (guard()) {\n            return this.Bind(computation, () => this.While(guard, computation));\n        }\n        else {\n            return this.Return(void 0);\n        }\n    }\n    Zero() {\n        return protectedCont((ctx) => ctx.onSuccess(void 0));\n    }\n}\nexport const singleton = new AsyncBuilder();\n","import { Union } from \"./Types.js\";\nimport { union_type } from \"./Reflection.js\";\nimport { some } from \"./Option.js\";\n\nexport class FSharpResult$2 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Ok\", \"Error\"];\n    }\n}\n\nexport function FSharpResult$2$reflection(gen0, gen1) {\n    return union_type(\"FSharp.Core.FSharpResult`2\", [gen0, gen1], FSharpResult$2, () => [[[\"ResultValue\", gen0]], [[\"ErrorValue\", gen1]]]);\n}\n\nexport function Result_Map(mapping, result) {\n    if (result.tag === 0) {\n        return new FSharpResult$2(0, mapping(result.fields[0]));\n    }\n    else {\n        return new FSharpResult$2(1, result.fields[0]);\n    }\n}\n\nexport function Result_MapError(mapping, result) {\n    if (result.tag === 0) {\n        return new FSharpResult$2(0, result.fields[0]);\n    }\n    else {\n        return new FSharpResult$2(1, mapping(result.fields[0]));\n    }\n}\n\nexport function Result_Bind(binder, result) {\n    if (result.tag === 0) {\n        return binder(result.fields[0]);\n    }\n    else {\n        return new FSharpResult$2(1, result.fields[0]);\n    }\n}\n\nexport class FSharpChoice$2 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of2\", \"Choice2Of2\"];\n    }\n}\n\nexport function FSharpChoice$2$reflection(gen0, gen1) {\n    return union_type(\"FSharp.Core.FSharpChoice`2\", [gen0, gen1], FSharpChoice$2, () => [[[\"Item\", gen0]], [[\"Item\", gen1]]]);\n}\n\nexport class FSharpChoice$3 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of3\", \"Choice2Of3\", \"Choice3Of3\"];\n    }\n}\n\nexport function FSharpChoice$3$reflection(gen0, gen1, gen2) {\n    return union_type(\"FSharp.Core.FSharpChoice`3\", [gen0, gen1, gen2], FSharpChoice$3, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]]]);\n}\n\nexport class FSharpChoice$4 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of4\", \"Choice2Of4\", \"Choice3Of4\", \"Choice4Of4\"];\n    }\n}\n\nexport function FSharpChoice$4$reflection(gen0, gen1, gen2, gen3) {\n    return union_type(\"FSharp.Core.FSharpChoice`4\", [gen0, gen1, gen2, gen3], FSharpChoice$4, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]]]);\n}\n\nexport class FSharpChoice$5 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of5\", \"Choice2Of5\", \"Choice3Of5\", \"Choice4Of5\", \"Choice5Of5\"];\n    }\n}\n\nexport function FSharpChoice$5$reflection(gen0, gen1, gen2, gen3, gen4) {\n    return union_type(\"FSharp.Core.FSharpChoice`5\", [gen0, gen1, gen2, gen3, gen4], FSharpChoice$5, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]]]);\n}\n\nexport class FSharpChoice$6 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of6\", \"Choice2Of6\", \"Choice3Of6\", \"Choice4Of6\", \"Choice5Of6\", \"Choice6Of6\"];\n    }\n}\n\nexport function FSharpChoice$6$reflection(gen0, gen1, gen2, gen3, gen4, gen5) {\n    return union_type(\"FSharp.Core.FSharpChoice`6\", [gen0, gen1, gen2, gen3, gen4, gen5], FSharpChoice$6, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]]]);\n}\n\nexport class FSharpChoice$7 extends Union {\n    constructor(tag, ...fields) {\n        super();\n        this.tag = (tag | 0);\n        this.fields = fields;\n    }\n    cases() {\n        return [\"Choice1Of7\", \"Choice2Of7\", \"Choice3Of7\", \"Choice4Of7\", \"Choice5Of7\", \"Choice6Of7\", \"Choice7Of7\"];\n    }\n}\n\nexport function FSharpChoice$7$reflection(gen0, gen1, gen2, gen3, gen4, gen5, gen6) {\n    return union_type(\"FSharp.Core.FSharpChoice`7\", [gen0, gen1, gen2, gen3, gen4, gen5, gen6], FSharpChoice$7, () => [[[\"Item\", gen0]], [[\"Item\", gen1]], [[\"Item\", gen2]], [[\"Item\", gen3]], [[\"Item\", gen4]], [[\"Item\", gen5]], [[\"Item\", gen6]]]);\n}\n\nexport function Choice_makeChoice1Of2(x) {\n    return new FSharpChoice$2(0, x);\n}\n\nexport function Choice_makeChoice2Of2(x) {\n    return new FSharpChoice$2(1, x);\n}\n\nexport function Choice_tryValueIfChoice1Of2(x) {\n    if (x.tag === 0) {\n        return some(x.fields[0]);\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function Choice_tryValueIfChoice2Of2(x) {\n    if (x.tag === 1) {\n        return some(x.fields[0]);\n    }\n    else {\n        return void 0;\n    }\n}\n\n","import { OperationCanceledError, Trampoline } from \"./AsyncBuilder.js\";\nimport { CancellationToken } from \"./AsyncBuilder.js\";\nimport { protectedCont } from \"./AsyncBuilder.js\";\nimport { protectedBind } from \"./AsyncBuilder.js\";\nimport { protectedReturn } from \"./AsyncBuilder.js\";\nimport { Choice_makeChoice1Of2, Choice_makeChoice2Of2 } from \"./Choice.js\";\nimport { map } from \"./Seq.js\";\n// Implemented just for type references\nexport class Async {\n}\nfunction emptyContinuation(_x) {\n    // NOP\n}\n// MakeAsync: body:(AsyncActivation<'T> -> AsyncReturn) -> Async<'T>\nexport function makeAsync(body) {\n    return body;\n}\n// Invoke: computation: Async<'T> -> ctxt:AsyncActivation<'T> -> AsyncReturn\nexport function invoke(computation, ctx) {\n    return computation(ctx);\n}\n// CallThenInvoke: ctxt:AsyncActivation<'T> -> result1:'U -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function callThenInvoke(ctx, result1, part2) {\n    return part2(result1)(ctx);\n}\n// Bind: ctxt:AsyncActivation<'T> -> part1:Async<'U> -> part2:('U -> Async<'T>) -> AsyncReturn\nexport function bind(ctx, part1, part2) {\n    return protectedBind(part1, part2)(ctx);\n}\nexport function createCancellationToken(arg) {\n    const token = new CancellationToken(typeof arg === \"boolean\" ? arg : false);\n    if (typeof arg === \"number\") {\n        setTimeout(() => { token.cancel(); }, arg);\n    }\n    return token;\n}\nexport function cancel(token) {\n    token.cancel();\n}\nexport function cancelAfter(token, ms) {\n    setTimeout(() => { token.cancel(); }, ms);\n}\nexport function isCancellationRequested(token) {\n    return token != null && token.isCancelled;\n}\nexport function throwIfCancellationRequested(token) {\n    if (token != null && token.isCancelled) {\n        throw new Error(\"Operation is cancelled\");\n    }\n}\nexport function startChild(computation) {\n    const promise = startAsPromise(computation);\n    // JS Promises are hot, computation has already started\n    // but we delay returning the result\n    return protectedCont((ctx) => protectedReturn(awaitPromise(promise))(ctx));\n}\nexport function awaitPromise(p) {\n    return fromContinuations((conts) => p.then(conts[0]).catch((err) => (err instanceof OperationCanceledError\n        ? conts[2] : conts[1])(err)));\n}\nexport function cancellationToken() {\n    return protectedCont((ctx) => ctx.onSuccess(ctx.cancelToken));\n}\nexport const defaultCancellationToken = new CancellationToken();\nexport function catchAsync(work) {\n    return protectedCont((ctx) => {\n        work({\n            onSuccess: (x) => ctx.onSuccess(Choice_makeChoice1Of2(x)),\n            onError: (ex) => ctx.onSuccess(Choice_makeChoice2Of2(ex)),\n            onCancel: ctx.onCancel,\n            cancelToken: ctx.cancelToken,\n            trampoline: ctx.trampoline,\n        });\n    });\n}\nexport function fromContinuations(f) {\n    return protectedCont((ctx) => f([ctx.onSuccess, ctx.onError, ctx.onCancel]));\n}\nexport function ignore(computation) {\n    return protectedBind(computation, (_x) => protectedReturn(void 0));\n}\nexport function parallel(computations) {\n    return awaitPromise(Promise.all(map((w) => startAsPromise(w), computations)));\n}\nexport function sleep(millisecondsDueTime) {\n    return protectedCont((ctx) => {\n        let tokenId;\n        const timeoutId = setTimeout(() => {\n            ctx.cancelToken.removeListener(tokenId);\n            ctx.onSuccess(void 0);\n        }, millisecondsDueTime);\n        tokenId = ctx.cancelToken.addListener(() => {\n            clearTimeout(timeoutId);\n            ctx.onCancel(new OperationCanceledError());\n        });\n    });\n}\nexport function start(computation, cancellationToken) {\n    return startWithContinuations(computation, cancellationToken);\n}\nexport function startImmediate(computation, cancellationToken) {\n    return start(computation, cancellationToken);\n}\nexport function startWithContinuations(computation, continuation, exceptionContinuation, cancellationContinuation, cancelToken) {\n    if (typeof continuation !== \"function\") {\n        cancelToken = continuation;\n        continuation = undefined;\n    }\n    const trampoline = new Trampoline();\n    computation({\n        onSuccess: continuation ? continuation : emptyContinuation,\n        onError: exceptionContinuation ? exceptionContinuation : emptyContinuation,\n        onCancel: cancellationContinuation ? cancellationContinuation : emptyContinuation,\n        cancelToken: cancelToken ? cancelToken : defaultCancellationToken,\n        trampoline,\n    });\n}\nexport function startAsPromise(computation, cancellationToken) {\n    return new Promise((resolve, reject) => startWithContinuations(computation, resolve, reject, reject, cancellationToken ? cancellationToken : defaultCancellationToken));\n}\nexport default Async;\n","import { some } from \"../fable-library.3.1.4/Option.js\";\r\nimport Timer from \"../fable-library.3.1.4/Timer.js\";\r\nimport { add } from \"../fable-library.3.1.4/Observable.js\";\r\n\r\nexport function Log_onError(text, ex) {\r\n    console.error(some(text), ex);\r\n}\r\n\r\nexport function Log_toConsole(text, o) {\r\n    console.log(some(text), o);\r\n}\r\n\r\nexport function Timer_delay(interval, callback) {\r\n    let t;\r\n    let returnVal = new Timer(interval);\r\n    returnVal.AutoReset = false;\r\n    t = returnVal;\r\n    add(callback, t.Elapsed);\r\n    t.Enabled = true;\r\n    t.Start();\r\n}\r\n\r\n","import { singleton, concat, map, empty, iterate } from \"../fable-library.3.1.4/List.js\";\r\nimport { singleton as singleton_1 } from \"../fable-library.3.1.4/AsyncBuilder.js\";\r\nimport { startImmediate, catchAsync } from \"../fable-library.3.1.4/Async.js\";\r\nimport { Timer_delay } from \"./prelude.fs.js\";\r\n\r\nexport function Cmd_exec(onError, dispatch, cmd) {\r\n    iterate((call) => {\r\n        try {\r\n            call(dispatch);\r\n        }\r\n        catch (ex) {\r\n            onError(ex);\r\n        }\r\n    }, cmd);\r\n}\r\n\r\nexport function Cmd_none() {\r\n    return empty();\r\n}\r\n\r\nexport function Cmd_map(f, cmd) {\r\n    return map((g) => ((arg_1) => {\r\n        g((arg) => {\r\n            arg_1(f(arg));\r\n        });\r\n    }), cmd);\r\n}\r\n\r\nexport function Cmd_batch(cmds) {\r\n    return concat(cmds);\r\n}\r\n\r\nexport function Cmd_ofSub(sub) {\r\n    return singleton(sub);\r\n}\r\n\r\nexport function Cmd_OfFunc_either(task, arg, ofSuccess, ofError) {\r\n    return singleton((dispatch) => {\r\n        try {\r\n            return dispatch(ofSuccess(task(arg)));\r\n        }\r\n        catch (x) {\r\n            return dispatch(ofError(x));\r\n        }\r\n    });\r\n}\r\n\r\nexport function Cmd_OfFunc_perform(task, arg, ofSuccess) {\r\n    return singleton((dispatch) => {\r\n        try {\r\n            dispatch(ofSuccess(task(arg)));\r\n        }\r\n        catch (x) {\r\n        }\r\n    });\r\n}\r\n\r\nexport function Cmd_OfFunc_attempt(task, arg, ofError) {\r\n    return singleton((dispatch) => {\r\n        try {\r\n            task(arg);\r\n        }\r\n        catch (x) {\r\n            dispatch(ofError(x));\r\n        }\r\n    });\r\n}\r\n\r\nexport function Cmd_OfFunc_result(msg) {\r\n    return singleton((dispatch) => {\r\n        dispatch(msg);\r\n    });\r\n}\r\n\r\nexport function Cmd_OfAsyncWith_either(start, task, arg, ofSuccess, ofError) {\r\n    return singleton((arg_1) => {\r\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\r\n            const r = _arg1;\r\n            arg_1((r.tag === 1) ? ofError(r.fields[0]) : ofSuccess(r.fields[0]));\r\n            return singleton_1.Zero();\r\n        })));\r\n    });\r\n}\r\n\r\nexport function Cmd_OfAsyncWith_perform(start, task, arg, ofSuccess) {\r\n    return singleton((arg_1) => {\r\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\r\n            const r = _arg1;\r\n            if (r.tag === 0) {\r\n                arg_1(ofSuccess(r.fields[0]));\r\n                return singleton_1.Zero();\r\n            }\r\n            else {\r\n                return singleton_1.Zero();\r\n            }\r\n        })));\r\n    });\r\n}\r\n\r\nexport function Cmd_OfAsyncWith_attempt(start, task, arg, ofError) {\r\n    return singleton((arg_1) => {\r\n        start(singleton_1.Delay(() => singleton_1.Bind(catchAsync(task(arg)), (_arg1) => {\r\n            const r = _arg1;\r\n            if (r.tag === 1) {\r\n                arg_1(ofError(r.fields[0]));\r\n                return singleton_1.Zero();\r\n            }\r\n            else {\r\n                return singleton_1.Zero();\r\n            }\r\n        })));\r\n    });\r\n}\r\n\r\nexport function Cmd_OfAsyncWith_result(start, task) {\r\n    return singleton((arg) => {\r\n        start(singleton_1.Delay(() => singleton_1.Bind(task, (_arg1) => {\r\n            arg(_arg1);\r\n            return singleton_1.Zero();\r\n        })));\r\n    });\r\n}\r\n\r\nexport function Cmd_OfAsync_start(x) {\r\n    Timer_delay(0, (_arg1) => {\r\n        startImmediate(x);\r\n    });\r\n}\r\n\r\nexport function Cmd_OfPromise_either(task, arg, ofSuccess, ofError) {\r\n    return singleton((dispatch) => {\r\n        const value_1 = task(arg).then((arg_1) => dispatch(ofSuccess(arg_1))).catch((arg_3) => dispatch(ofError(arg_3)));\r\n        void value_1;\r\n    });\r\n}\r\n\r\nexport function Cmd_OfPromise_perform(task, arg, ofSuccess) {\r\n    return singleton((dispatch) => {\r\n        const value = task(arg).then((arg_1) => dispatch(ofSuccess(arg_1)));\r\n        void value;\r\n    });\r\n}\r\n\r\nexport function Cmd_OfPromise_attempt(task, arg, ofError) {\r\n    return singleton((dispatch) => {\r\n        const value_1 = task(arg).catch((arg_2) => {\r\n            dispatch(ofError(arg_2));\r\n        });\r\n        void value_1;\r\n    });\r\n}\r\n\r\nexport function Cmd_OfPromise_result(task) {\r\n    return singleton((dispatch) => {\r\n        const value = task.then(dispatch);\r\n        void value;\r\n    });\r\n}\r\n\r\nexport function Cmd_attemptFunc(task, arg, ofError) {\r\n    return Cmd_OfFunc_attempt(task, arg, ofError);\r\n}\r\n\r\n","import { Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { class_type, union_type, int32_type, array_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { fill } from \"../fable-library.3.1.4/Array.js\";\r\nimport { comparePrimitives, max } from \"../fable-library.3.1.4/Util.js\";\r\nimport { some } from \"../fable-library.3.1.4/Option.js\";\r\nimport { rangeNumber, singleton, collect, take, skip, append, delay } from \"../fable-library.3.1.4/Seq.js\";\r\n\r\nexport class RingState$1 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Writable\", \"ReadWritable\"];\r\n    }\r\n}\r\n\r\nexport function RingState$1$reflection(gen0) {\r\n    return union_type(\"Elmish.RingState`1\", [gen0], RingState$1, () => [[[\"wx\", array_type(gen0)], [\"ix\", int32_type]], [[\"rw\", array_type(gen0)], [\"wix\", int32_type], [\"rix\", int32_type]]]);\r\n}\r\n\r\nexport class RingBuffer$1 {\r\n    constructor(size) {\r\n        this.state = (new RingState$1(0, fill(new Array(max((x, y) => comparePrimitives(x, y), size, 10)), 0, max((x, y) => comparePrimitives(x, y), size, 10), null), 0));\r\n    }\r\n}\r\n\r\nexport function RingBuffer$1$reflection(gen0) {\r\n    return class_type(\"Elmish.RingBuffer`1\", [gen0], RingBuffer$1);\r\n}\r\n\r\nexport function RingBuffer$1_$ctor_Z524259A4(size) {\r\n    return new RingBuffer$1(size);\r\n}\r\n\r\nexport function RingBuffer$1__Pop(__) {\r\n    const matchValue = __.state;\r\n    if (matchValue.tag === 1) {\r\n        const wix = matchValue.fields[1] | 0;\r\n        const rix = matchValue.fields[2] | 0;\r\n        const items = matchValue.fields[0];\r\n        const rix$0027 = ((rix + 1) % items.length) | 0;\r\n        if (rix$0027 === wix) {\r\n            __.state = (new RingState$1(0, items, wix));\r\n        }\r\n        else {\r\n            __.state = (new RingState$1(1, items, wix, rix$0027));\r\n        }\r\n        return some(items[rix]);\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function RingBuffer$1__Push_2B595(__, item) {\r\n    const matchValue = __.state;\r\n    if (matchValue.tag === 1) {\r\n        const wix_1 = matchValue.fields[1] | 0;\r\n        const rix = matchValue.fields[2] | 0;\r\n        const items_1 = matchValue.fields[0];\r\n        items_1[wix_1] = item;\r\n        const wix$0027 = ((wix_1 + 1) % items_1.length) | 0;\r\n        if (wix$0027 === rix) {\r\n            __.state = (new RingState$1(1, RingBuffer$1__doubleSize(__, rix, items_1), items_1.length, 0));\r\n        }\r\n        else {\r\n            __.state = (new RingState$1(1, items_1, wix$0027, rix));\r\n        }\r\n    }\r\n    else {\r\n        const ix = matchValue.fields[1] | 0;\r\n        const items = matchValue.fields[0];\r\n        items[ix] = item;\r\n        const wix = ((ix + 1) % items.length) | 0;\r\n        __.state = (new RingState$1(1, items, wix, ix));\r\n    }\r\n}\r\n\r\nfunction RingBuffer$1__doubleSize(this$, ix, items) {\r\n    return Array.from(delay(() => append(skip(ix, items), delay(() => append(take(ix, items), delay(() => collect((matchValue) => singleton(null), rangeNumber(0, 1, items.length))))))));\r\n}\r\n\r\n","import { Record } from \"../fable-library.3.1.4/Types.js\";\r\nimport { record_type, class_type, string_type, tuple_type, list_type, lambda_type, unit_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { Cmd_exec, Cmd_batch, Cmd_none } from \"./cmd.fs.js\";\r\nimport { Log_toConsole, Log_onError } from \"./prelude.fs.js\";\r\nimport { curry, partialApply, checkArity, uncurry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { ofArray } from \"../fable-library.3.1.4/List.js\";\r\nimport { RingBuffer$1__Pop, RingBuffer$1__Push_2B595, RingBuffer$1_$ctor_Z524259A4 } from \"./ring.fs.js\";\r\nimport { value as value_1, some } from \"../fable-library.3.1.4/Option.js\";\r\nimport { printf, toText } from \"../fable-library.3.1.4/String.js\";\r\n\r\nexport class Program$4 extends Record {\r\n    constructor(init, update, subscribe, view, setState, onError, syncDispatch) {\r\n        super();\r\n        this.init = init;\r\n        this.update = update;\r\n        this.subscribe = subscribe;\r\n        this.view = view;\r\n        this.setState = setState;\r\n        this.onError = onError;\r\n        this.syncDispatch = syncDispatch;\r\n    }\r\n}\r\n\r\nexport function Program$4$reflection(gen0, gen1, gen2, gen3) {\r\n    return record_type(\"Elmish.Program`4\", [gen0, gen1, gen2, gen3], Program$4, () => [[\"init\", lambda_type(gen0, tuple_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type))))], [\"update\", lambda_type(gen2, lambda_type(gen1, tuple_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type)))))], [\"subscribe\", lambda_type(gen1, list_type(lambda_type(lambda_type(gen2, unit_type), unit_type)))], [\"view\", lambda_type(gen1, lambda_type(lambda_type(gen2, unit_type), gen3))], [\"setState\", lambda_type(gen1, lambda_type(lambda_type(gen2, unit_type), unit_type))], [\"onError\", lambda_type(tuple_type(string_type, class_type(\"System.Exception\")), unit_type)], [\"syncDispatch\", lambda_type(lambda_type(gen2, unit_type), lambda_type(gen2, unit_type))]]);\r\n}\r\n\r\nexport function ProgramModule_mkProgram(init, update, view) {\r\n    return new Program$4(init, update, (_arg1) => Cmd_none(), view, (model, arg) => {\r\n        const value = view(model, arg);\r\n        void value;\r\n    }, (tupledArg) => {\r\n        Log_onError(tupledArg[0], tupledArg[1]);\r\n    }, uncurry(2, (x) => x));\r\n}\r\n\r\nexport function ProgramModule_mkSimple(init, update, view) {\r\n    return new Program$4((arg) => [init(arg), Cmd_none()], (msg, arg_1) => [update(msg, arg_1), Cmd_none()], (_arg1) => Cmd_none(), view, (model, arg_2) => {\r\n        const value = view(model, arg_2);\r\n        void value;\r\n    }, (tupledArg) => {\r\n        Log_onError(tupledArg[0], tupledArg[1]);\r\n    }, uncurry(2, (x) => x));\r\n}\r\n\r\nexport function ProgramModule_withSubscription(subscribe, program) {\r\n    return new Program$4(program.init, program.update, (model) => Cmd_batch(ofArray([program.subscribe(model), subscribe(model)])), checkArity(2, program.view), program.setState, program.onError, program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_withConsoleTrace(program) {\r\n    return new Program$4((arg) => {\r\n        const patternInput = program.init(arg);\r\n        const initModel = patternInput[0];\r\n        Log_toConsole(\"Initial state:\", initModel);\r\n        return [initModel, patternInput[1]];\r\n    }, (msg, model) => {\r\n        Log_toConsole(\"New message:\", msg);\r\n        const patternInput_1 = program.update(msg, model);\r\n        const newModel = patternInput_1[0];\r\n        Log_toConsole(\"Updated state:\", newModel);\r\n        return [newModel, patternInput_1[1]];\r\n    }, program.subscribe, checkArity(2, program.view), program.setState, program.onError, program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_withTrace(trace, program) {\r\n    return new Program$4(program.init, (msg, model) => {\r\n        const patternInput = program.update(msg, model);\r\n        const state = patternInput[0];\r\n        trace(msg, state);\r\n        return [state, patternInput[1]];\r\n    }, program.subscribe, checkArity(2, program.view), program.setState, program.onError, program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_withErrorHandler(onError, program) {\r\n    return new Program$4(program.init, program.update, program.subscribe, checkArity(2, program.view), program.setState, onError, program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_mapErrorHandler(map, program) {\r\n    return new Program$4(program.init, program.update, program.subscribe, checkArity(2, program.view), program.setState, partialApply(1, map, [program.onError]), program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_onError(program) {\r\n    return program.onError;\r\n}\r\n\r\nexport function ProgramModule_withSetState(setState, program) {\r\n    return new Program$4(program.init, program.update, program.subscribe, checkArity(2, program.view), setState, program.onError, program.syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_setState(program) {\r\n    return curry(2, program.setState);\r\n}\r\n\r\nexport function ProgramModule_view(program) {\r\n    return curry(2, checkArity(2, program.view));\r\n}\r\n\r\nexport function ProgramModule_withSyncDispatch(syncDispatch, program) {\r\n    return new Program$4(program.init, program.update, program.subscribe, checkArity(2, program.view), program.setState, program.onError, syncDispatch);\r\n}\r\n\r\nexport function ProgramModule_map(mapInit, mapUpdate, mapView, mapSetState, mapSubscribe, program) {\r\n    const init = partialApply(1, mapInit, [program.init]);\r\n    const update = partialApply(2, mapUpdate, [program.update]);\r\n    const view = partialApply(2, mapView, [checkArity(2, program.view)]);\r\n    const setState = partialApply(2, mapSetState, [program.setState]);\r\n    return new Program$4(init, uncurry(2, update), partialApply(1, mapSubscribe, [program.subscribe]), uncurry(2, view), uncurry(2, setState), program.onError, uncurry(2, (x) => x));\r\n}\r\n\r\nexport function ProgramModule_runWith(arg, program) {\r\n    const patternInput = program.init(arg);\r\n    const model = patternInput[0];\r\n    const rb = RingBuffer$1_$ctor_Z524259A4(10);\r\n    let reentered = false;\r\n    let state = model;\r\n    const dispatch = (msg) => {\r\n        if (reentered) {\r\n            RingBuffer$1__Push_2B595(rb, msg);\r\n        }\r\n        else {\r\n            reentered = true;\r\n            let nextMsg = some(msg);\r\n            while (nextMsg != null) {\r\n                const msg_1 = value_1(nextMsg);\r\n                try {\r\n                    const patternInput_1 = program.update(msg_1, state);\r\n                    const model$0027 = patternInput_1[0];\r\n                    program.setState(model$0027, syncDispatch);\r\n                    Cmd_exec((ex) => {\r\n                        program.onError([toText(printf(\"Error in command while handling: %A\"))(msg_1), ex]);\r\n                    }, syncDispatch, patternInput_1[1]);\r\n                    state = model$0027;\r\n                }\r\n                catch (ex_1) {\r\n                    program.onError([toText(printf(\"Unable to process the message: %A\"))(msg_1), ex_1]);\r\n                }\r\n                nextMsg = RingBuffer$1__Pop(rb);\r\n            }\r\n            reentered = false;\r\n        }\r\n    };\r\n    const syncDispatch = partialApply(1, program.syncDispatch, [dispatch]);\r\n    program.setState(model, syncDispatch);\r\n    Cmd_exec((ex_3) => {\r\n        program.onError([\"Error intitializing:\", ex_3]);\r\n    }, syncDispatch, Cmd_batch(ofArray([(() => {\r\n        try {\r\n            return program.subscribe(model);\r\n        }\r\n        catch (ex_2) {\r\n            program.onError([\"Unable to subscribe:\", ex_2]);\r\n            return Cmd_none();\r\n        }\r\n    })(), patternInput[1]])));\r\n}\r\n\r\nexport function ProgramModule_run(program) {\r\n    ProgramModule_runWith(void 0, program);\r\n}\r\n\r\n","import { Record } from \"../fable-library.3.1.4/Types.js\";\r\nimport { obj_type, record_type, bool_type, lambda_type, class_type, unit_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { Component } from \"react\";\r\nimport * as react from \"react\";\r\nimport { equalArrays, equals } from \"../fable-library.3.1.4/Util.js\";\r\n\r\nexport class LazyProps$1 extends Record {\r\n    constructor(model, render, equal) {\r\n        super();\r\n        this.model = model;\r\n        this.render = render;\r\n        this.equal = equal;\r\n    }\r\n}\r\n\r\nexport function LazyProps$1$reflection(gen0) {\r\n    return record_type(\"Elmish.React.LazyProps`1\", [gen0], LazyProps$1, () => [[\"model\", gen0], [\"render\", lambda_type(unit_type, class_type(\"Fable.React.ReactElement\"))], [\"equal\", lambda_type(gen0, lambda_type(gen0, bool_type))]]);\r\n}\r\n\r\nexport class Components_LazyView$1 extends Component {\r\n    constructor(props) {\r\n        super(props);\r\n    }\r\n    shouldComponentUpdate(nextProps, _nextState) {\r\n        const this$ = this;\r\n        return !(this$.props).equal((this$.props).model, nextProps.model);\r\n    }\r\n    render() {\r\n        const this$ = this;\r\n        return (this$.props).render();\r\n    }\r\n}\r\n\r\nexport function Components_LazyView$1$reflection(gen0) {\r\n    return class_type(\"Elmish.React.Components.LazyView`1\", [gen0], Components_LazyView$1, class_type(\"Fable.React.Component`2\", [LazyProps$1$reflection(gen0), obj_type]));\r\n}\r\n\r\nexport function Components_LazyView$1_$ctor_Z7829D94B(props) {\r\n    return new Components_LazyView$1(props);\r\n}\r\n\r\nexport function Common_lazyViewWith(equal, view, state) {\r\n    return react.createElement(Components_LazyView$1, new LazyProps$1(state, () => view(state), equal));\r\n}\r\n\r\nexport function Common_lazyView2With(equal, view, state, dispatch) {\r\n    return react.createElement(Components_LazyView$1, new LazyProps$1(state, () => view(state, dispatch), equal));\r\n}\r\n\r\nexport function Common_lazyView3With(equal, view, state1, state2, dispatch) {\r\n    return react.createElement(Components_LazyView$1, new LazyProps$1([state1, state2], () => view(state1, state2, dispatch), equal));\r\n}\r\n\r\nexport function Common_lazyView(view) {\r\n    return (state) => Common_lazyViewWith((x, y) => equals(x, y), view, state);\r\n}\r\n\r\nexport function Common_lazyView2(view) {\r\n    return (state) => ((dispatch) => Common_lazyView2With((x, y) => equals(x, y), view, state, dispatch));\r\n}\r\n\r\nexport function Common_lazyView3(view) {\r\n    return (state1) => ((state2) => ((dispatch) => Common_lazyView3With((x, y) => equalArrays(x, y), view, state1, state2, dispatch)));\r\n}\r\n\r\n","import { ProgramModule_view, ProgramModule_withSetState } from \"../Fable.Elmish.3.1.0/program.fs.js\";\r\nimport * as react$002Ddom from \"react-dom\";\r\nimport { uncurry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { Common_lazyView2With } from \"./common.fs.js\";\r\n\r\nexport function Program_Internal_withReactBatchedUsing(lazyView2With, placeholderId, program) {\r\n    let lastRequest = void 0;\r\n    return ProgramModule_withSetState((model, dispatch) => {\r\n        if (lastRequest != null) {\r\n            window.cancelAnimationFrame(lastRequest);\r\n        }\r\n        lastRequest = window.requestAnimationFrame((_arg1) => {\r\n            react$002Ddom.render(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\r\n        });\r\n    }, program);\r\n}\r\n\r\nexport function Program_Internal_withReactSynchronousUsing(lazyView2With, placeholderId, program) {\r\n    return ProgramModule_withSetState((model, dispatch) => {\r\n        react$002Ddom.render(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\r\n    }, program);\r\n}\r\n\r\nexport function Program_Internal_withReactHydrateUsing(lazyView2With, placeholderId, program) {\r\n    return ProgramModule_withSetState((model, dispatch) => {\r\n        react$002Ddom.hydrate(lazyView2With((x, y) => (x === y), uncurry(2, ProgramModule_view(program)), model, dispatch), document.getElementById(placeholderId));\r\n    }, program);\r\n}\r\n\r\nexport function Program_withReactBatched(placeholderId, program) {\r\n    return Program_Internal_withReactBatchedUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\r\n}\r\n\r\nexport function Program_withReactSynchronous(placeholderId, program) {\r\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\r\n}\r\n\r\nexport function Program_withReact(placeholderId, program) {\r\n    return Program_Internal_withReactBatchedUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\r\n}\r\n\r\nexport function Program_withReactUnoptimized(placeholderId, program) {\r\n    return Program_Internal_withReactSynchronousUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\r\n}\r\n\r\nexport function Program_withReactHydrate(placeholderId, program) {\r\n    return Program_Internal_withReactHydrateUsing((equal, view, state, dispatch) => Common_lazyView2With(equal, view, state, dispatch), placeholderId, program);\r\n}\r\n\r\n","import { Record } from \"./.fable/fable-library.3.1.4/Types.js\";\r\nimport { record_type, string_type } from \"./.fable/fable-library.3.1.4/Reflection.js\";\r\n\r\nexport class FableModule extends Record {\r\n    constructor(Platzhalter, ModuleName, ServiceName) {\r\n        super();\r\n        this.Platzhalter = Platzhalter;\r\n        this.ModuleName = ModuleName;\r\n        this.ServiceName = ServiceName;\r\n    }\r\n}\r\n\r\nexport function FableModule$reflection() {\r\n    return record_type(\"TagungsProgramm.Global.FableModule\", [], FableModule, () => [[\"Platzhalter\", string_type], [\"ModuleName\", string_type], [\"ServiceName\", string_type]]);\r\n}\r\n\r\nexport const fableModule = new FableModule(\"TagungsProgramm\", \"TagungsProgramm\", \"Service\");\r\n\r\n","import { Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { union_type, class_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { ofArray, singleton } from \"../fable-library.3.1.4/List.js\";\r\nimport { Cmd_batch, Cmd_map } from \"../Fable.Elmish.3.1.0/cmd.fs.js\";\r\nimport { ProgramModule_map } from \"../Fable.Elmish.3.1.0/program.fs.js\";\r\n\r\nexport class Navigable$1 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Change\", \"UserMsg\"];\r\n    }\r\n}\r\n\r\nexport function Navigable$1$reflection(gen0) {\r\n    return union_type(\"Elmish.Navigation.Navigable`1\", [gen0], Navigable$1, () => [[[\"Item\", class_type(\"Browser.Types.Location\")]], [[\"Item\", gen0]]]);\r\n}\r\n\r\nexport function Navigation_modifyUrl(newUrl) {\r\n    return singleton((_arg1) => {\r\n        history.replaceState(void 0, \"\", newUrl);\r\n    });\r\n}\r\n\r\nexport function Navigation_newUrl(newUrl) {\r\n    return singleton((_arg1) => {\r\n        history.pushState(void 0, \"\", newUrl);\r\n        const value = window.dispatchEvent(new CustomEvent(\"NavigatedEvent\"));\r\n        void value;\r\n    });\r\n}\r\n\r\nexport function Navigation_jump(n) {\r\n    return singleton((_arg1) => {\r\n        history.go(n);\r\n    });\r\n}\r\n\r\nlet ProgramModule_Internal_onChangeRef = (_arg1) => {\r\n    throw (new Error(\"`onChangeRef` has not been initialized.\\nPlease make sure you used Elmish.Navigation.Program.Internal.subscribe\"));\r\n};\r\n\r\nexport function ProgramModule_Internal_subscribe(dispatch) {\r\n    let lastLocation = void 0;\r\n    ProgramModule_Internal_onChangeRef = ((_arg1) => {\r\n        let value;\r\n        let pattern_matching_result;\r\n        if (lastLocation != null) {\r\n            if (lastLocation === window.location.href) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                value = (void 0);\r\n                break;\r\n            }\r\n            case 1: {\r\n                lastLocation = window.location.href;\r\n                value = dispatch(new Navigable$1(0, window.location));\r\n                break;\r\n            }\r\n        }\r\n        return void 0;\r\n    });\r\n    window.addEventListener(\"popstate\", (arg10) => {\r\n        ProgramModule_Internal_onChangeRef(arg10);\r\n    });\r\n    window.addEventListener(\"hashchange\", (arg10_1) => {\r\n        ProgramModule_Internal_onChangeRef(arg10_1);\r\n    });\r\n    window.addEventListener(\"NavigatedEvent\", (arg10_2) => {\r\n        ProgramModule_Internal_onChangeRef(arg10_2);\r\n    });\r\n}\r\n\r\nexport function ProgramModule_Internal_unsubscribe() {\r\n    window.removeEventListener(\"popstate\", (arg10) => {\r\n        ProgramModule_Internal_onChangeRef(arg10);\r\n    });\r\n    window.removeEventListener(\"hashchange\", (arg10_1) => {\r\n        ProgramModule_Internal_onChangeRef(arg10_1);\r\n    });\r\n    window.removeEventListener(\"NavigatedEvent\", (arg10_2) => {\r\n        ProgramModule_Internal_onChangeRef(arg10_2);\r\n    });\r\n}\r\n\r\nexport function ProgramModule_Internal_toNavigableWith(parser, urlUpdate, program, onLocationChange) {\r\n    const map = (tupledArg) => [tupledArg[0], Cmd_map((arg0) => (new Navigable$1(1, arg0)), tupledArg[1])];\r\n    return ProgramModule_map((userInit, unitVar1) => map(userInit(parser(window.location))), (userUpdate, msg, model_1) => map((msg.tag === 1) ? userUpdate(msg.fields[0], model_1) : urlUpdate(parser(msg.fields[0]), model_1)), (userView, model_4, dispatch_1) => userView(model_4, (arg_1) => dispatch_1(new Navigable$1(1, arg_1))), (userSetState, model_3, dispatch) => userSetState(model_3, (arg) => dispatch(new Navigable$1(1, arg))), (userSubscribe, model_2) => Cmd_batch(ofArray([singleton(onLocationChange), Cmd_map((arg0_1) => (new Navigable$1(1, arg0_1)), userSubscribe(model_2))])), program);\r\n}\r\n\r\nexport function ProgramModule_toNavigable(parser, urlUpdate, program) {\r\n    return ProgramModule_Internal_toNavigableWith(parser, urlUpdate, program, (dispatch) => {\r\n        ProgramModule_Internal_subscribe(dispatch);\r\n    });\r\n}\r\n\r\n","import { compare, physicalHash, equals, structuralHash } from \"./Util.js\";\n\nexport function HashIdentity_FromFunctions(hash, eq) {\n    return {\n        Equals(x, y) {\n            return eq(x, y);\n        },\n        GetHashCode(x_1) {\n            return hash(x_1);\n        },\n    };\n}\n\nexport function HashIdentity_Structural() {\n    return HashIdentity_FromFunctions((obj) => structuralHash(obj), (e1, e2) => equals(e1, e2));\n}\n\nexport function HashIdentity_Reference() {\n    return HashIdentity_FromFunctions((obj) => physicalHash(obj), (e1, e2) => (e1 === e2));\n}\n\nexport function ComparisonIdentity_FromFunction(comparer) {\n    return {\n        Compare(x, y) {\n            return comparer(x, y);\n        },\n    };\n}\n\nexport function ComparisonIdentity_Structural() {\n    return ComparisonIdentity_FromFunction((e1, e2) => compare(e1, e2));\n}\n\n","import { substring, format, isNullOrEmpty, join } from \"./String.js\";\nimport { class_type } from \"./Reflection.js\";\nimport { clear, int32ToString } from \"./Util.js\";\nimport { toString } from \"./Types.js\";\nimport { sumBy } from \"./Seq.js\";\n\nexport class StringBuilder {\n    constructor(value, capacity) {\n        this.buf = [];\n        if (!isNullOrEmpty(value)) {\n            void (this.buf.push(value));\n        }\n    }\n    toString() {\n        const __ = this;\n        return join(\"\", __.buf);\n    }\n}\n\nexport function StringBuilder$reflection() {\n    return class_type(\"System.Text.StringBuilder\", void 0, StringBuilder);\n}\n\nexport function StringBuilder_$ctor_Z18115A39(value, capacity) {\n    return new StringBuilder(value, capacity);\n}\n\nexport function StringBuilder_$ctor_Z524259A4(capacity) {\n    return StringBuilder_$ctor_Z18115A39(\"\", capacity);\n}\n\nexport function StringBuilder_$ctor_Z721C83C5(value) {\n    return StringBuilder_$ctor_Z18115A39(value, 16);\n}\n\nexport function StringBuilder_$ctor() {\n    return StringBuilder_$ctor_Z18115A39(\"\", 16);\n}\n\nexport function StringBuilder__Append_Z721C83C5(x, s) {\n    void (x.buf.push(s));\n    return x;\n}\n\nexport function StringBuilder__Append_244C7CD6(x, c) {\n    void (x.buf.push(c));\n    return x;\n}\n\nexport function StringBuilder__Append_Z524259A4(x, o) {\n    void (x.buf.push(int32ToString(o)));\n    return x;\n}\n\nexport function StringBuilder__Append_5E38073B(x, o) {\n    void (x.buf.push(o.toString()));\n    return x;\n}\n\nexport function StringBuilder__Append_Z1FBCCD16(x, o) {\n    void (x.buf.push(toString(o)));\n    return x;\n}\n\nexport function StringBuilder__Append_4E60E31B(x, o) {\n    void (x.buf.push(toString(o)));\n    return x;\n}\n\nexport function StringBuilder__Append_695F1130(x, cs) {\n    void (x.buf.push(cs.join('')));\n    return x;\n}\n\nexport function StringBuilder__Append_43A65C09(x, s) {\n    void (x.buf.push(toString(s)));\n    return x;\n}\n\nexport function StringBuilder__AppendFormat_433E080(x, fmt, o) {\n    void (x.buf.push(format(fmt, o)));\n    return x;\n}\n\nexport function StringBuilder__AppendLine(x) {\n    void (x.buf.push(\"\\n\"));\n    return x;\n}\n\nexport function StringBuilder__AppendLine_Z721C83C5(x, s) {\n    void (x.buf.push(s));\n    void (x.buf.push(\"\\n\"));\n    return x;\n}\n\nexport function StringBuilder__get_Length(x) {\n    return sumBy((str) => str.length, x.buf, {\n        GetZero: () => 0,\n        Add: (x_1, y) => (x_1 + y),\n    });\n}\n\nexport function StringBuilder__ToString_Z37302880(x, firstIndex, length) {\n    return substring(toString(x), firstIndex, length);\n}\n\nexport function StringBuilder__Clear(x) {\n    clear(x.buf);\n    return x;\n}\n\n","import { structuralHash, equals } from \"./Util.js\";\nimport { HashIdentity_Structural, ComparisonIdentity_Structural } from \"./FSharp.Collections.js\";\nimport { StringBuilder__Append_Z721C83C5 } from \"./System.Text.js\";\n\nexport const LanguagePrimitives_GenericEqualityComparer = {\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\n        return equals(x, y);\n    },\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\n        return structuralHash(x_1);\n    },\n};\n\nexport const LanguagePrimitives_GenericEqualityERComparer = {\n    [\"System.Collections.IEqualityComparer.Equals541DA560\"](x, y) {\n        return equals(x, y);\n    },\n    [\"System.Collections.IEqualityComparer.GetHashCode4E60E31B\"](x_1) {\n        return structuralHash(x_1);\n    },\n};\n\nexport function LanguagePrimitives_FastGenericComparer() {\n    return ComparisonIdentity_Structural();\n}\n\nexport function LanguagePrimitives_FastGenericComparerFromTable() {\n    return ComparisonIdentity_Structural();\n}\n\nexport function LanguagePrimitives_FastGenericEqualityComparer() {\n    return HashIdentity_Structural();\n}\n\nexport function LanguagePrimitives_FastGenericEqualityComparerFromTable() {\n    return HashIdentity_Structural();\n}\n\nexport function Operators_Failure(message) {\n    return new Error(message);\n}\n\nexport function Operators_FailurePattern(exn) {\n    return exn.message;\n}\n\nexport function Operators_NullArg(x) {\n    throw (new Error(x));\n}\n\nexport function Operators_Using(resource, action) {\n    try {\n        return action(resource);\n    }\n    finally {\n        if (equals(resource, null)) {\n        }\n        else {\n            resource.Dispose();\n        }\n    }\n}\n\nexport function Operators_Lock(_lockObj, action) {\n    return action();\n}\n\nexport function ExtraTopLevelOperators_LazyPattern(input) {\n    return input.Value;\n}\n\nexport function PrintfModule_PrintFormatToStringBuilderThen(continuation, builder, format) {\n    return format.cont((s) => {\n        const value = StringBuilder__Append_Z721C83C5(builder, s);\n        void value;\n        return continuation();\n    });\n}\n\nexport function PrintfModule_PrintFormatToStringBuilder(builder, format) {\n    return PrintfModule_PrintFormatToStringBuilderThen(() => {\n        void undefined;\n    }, builder, format);\n}\n\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\nimport { some, value as value_2 } from \"./Option.js\";\nimport { Record, List } from \"./Types.js\";\nimport { fold as fold_1 } from \"./List.js\";\nimport { structuralHash, compare, equals, isArrayLike } from \"./Util.js\";\nimport { empty as empty_1, tryPick as tryPick_1, pick as pick_1, iterate as iterate_1, compareWith, toIterator, map as map_2, unfold, getEnumerator } from \"./Seq.js\";\nimport { format, join } from \"./String.js\";\nimport { LanguagePrimitives_FastGenericComparer } from \"./FSharp.Core.js\";\nimport { Dictionary_$ctor_6623D9B3 } from \"./MutableMap.js\";\n\nexport class MapTreeLeaf$2 {\n    constructor(k, v) {\n        this.k = k;\n        this.v = v;\n    }\n}\n\nexport function MapTreeLeaf$2$reflection(gen0, gen1) {\n    return class_type(\"Map.MapTreeLeaf`2\", [gen0, gen1], MapTreeLeaf$2);\n}\n\nexport function MapTreeLeaf$2_$ctor_5BDDA1(k, v) {\n    return new MapTreeLeaf$2(k, v);\n}\n\nexport function MapTreeLeaf$2__get_Key(_) {\n    return _.k;\n}\n\nexport function MapTreeLeaf$2__get_Value(_) {\n    return _.v;\n}\n\nexport class MapTreeNode$2 extends MapTreeLeaf$2 {\n    constructor(k, v, left, right, h) {\n        super(k, v);\n        this.left = left;\n        this.right = right;\n        this.h = h;\n    }\n}\n\nexport function MapTreeNode$2$reflection(gen0, gen1) {\n    return class_type(\"Map.MapTreeNode`2\", [gen0, gen1], MapTreeNode$2, MapTreeLeaf$2$reflection(gen0, gen1));\n}\n\nexport function MapTreeNode$2_$ctor_499A11FD(k, v, left, right, h) {\n    return new MapTreeNode$2(k, v, left, right, h);\n}\n\nexport function MapTreeNode$2__get_Left(_) {\n    return _.left;\n}\n\nexport function MapTreeNode$2__get_Right(_) {\n    return _.right;\n}\n\nexport function MapTreeNode$2__get_Height(_) {\n    return _.h;\n}\n\nexport function MapTreeModule_empty() {\n    return void 0;\n}\n\nexport function MapTreeModule_sizeAux(acc_mut, m_mut) {\n    MapTreeModule_sizeAux:\n    while (true) {\n        const acc = acc_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                acc_mut = MapTreeModule_sizeAux(acc + 1, MapTreeNode$2__get_Left(m2));\n                m_mut = MapTreeNode$2__get_Right(m2);\n                continue MapTreeModule_sizeAux;\n            }\n            else {\n                return (acc + 1) | 0;\n            }\n        }\n        else {\n            return acc | 0;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_size(x) {\n    return MapTreeModule_sizeAux(0, x);\n}\n\nexport function MapTreeModule_mk(l, k, v, r) {\n    let hl;\n    const m = l;\n    if (m != null) {\n        const m2 = m;\n        hl = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\n    }\n    else {\n        hl = 0;\n    }\n    let hr;\n    const m_1 = r;\n    if (m_1 != null) {\n        const m2_1 = m_1;\n        hr = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\n    }\n    else {\n        hr = 0;\n    }\n    const m_2 = ((hl < hr) ? hr : hl) | 0;\n    if (m_2 === 0) {\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\n    }\n    else {\n        return MapTreeNode$2_$ctor_499A11FD(k, v, l, r, m_2 + 1);\n    }\n}\n\nexport function MapTreeModule_rebalance(t1, k, v, t2) {\n    let m_2, m2_2, m_3, m2_3;\n    let t1h;\n    const m = t1;\n    if (m != null) {\n        const m2 = m;\n        t1h = ((m2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2) : 1);\n    }\n    else {\n        t1h = 0;\n    }\n    let t2h;\n    const m_1 = t2;\n    if (m_1 != null) {\n        const m2_1 = m_1;\n        t2h = ((m2_1 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_1) : 1);\n    }\n    else {\n        t2h = 0;\n    }\n    if (t2h > (t1h + 2)) {\n        const matchValue = value_2(t2);\n        if (matchValue instanceof MapTreeNode$2) {\n            if ((m_2 = MapTreeNode$2__get_Left(matchValue), (m_2 != null) ? (m2_2 = m_2, (m2_2 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_2) : 1) : 0) > (t1h + 1)) {\n                const matchValue_1 = value_2(MapTreeNode$2__get_Left(matchValue));\n                if (matchValue_1 instanceof MapTreeNode$2) {\n                    return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue_1)), MapTreeLeaf$2__get_Key(matchValue_1), MapTreeLeaf$2__get_Value(matchValue_1), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_1), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue)));\n                }\n                else {\n                    throw (new Error(\"internal error: Map.rebalance\"));\n                }\n            }\n            else {\n                return MapTreeModule_mk(MapTreeModule_mk(t1, k, v, MapTreeNode$2__get_Left(matchValue)), MapTreeLeaf$2__get_Key(matchValue), MapTreeLeaf$2__get_Value(matchValue), MapTreeNode$2__get_Right(matchValue));\n            }\n        }\n        else {\n            throw (new Error(\"internal error: Map.rebalance\"));\n        }\n    }\n    else if (t1h > (t2h + 2)) {\n        const matchValue_2 = value_2(t1);\n        if (matchValue_2 instanceof MapTreeNode$2) {\n            if ((m_3 = MapTreeNode$2__get_Right(matchValue_2), (m_3 != null) ? (m2_3 = m_3, (m2_3 instanceof MapTreeNode$2) ? MapTreeNode$2__get_Height(m2_3) : 1) : 0) > (t2h + 1)) {\n                const matchValue_3 = value_2(MapTreeNode$2__get_Right(matchValue_2));\n                if (matchValue_3 instanceof MapTreeNode$2) {\n                    return MapTreeModule_mk(MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeNode$2__get_Left(matchValue_3)), MapTreeLeaf$2__get_Key(matchValue_3), MapTreeLeaf$2__get_Value(matchValue_3), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_3), k, v, t2));\n                }\n                else {\n                    throw (new Error(\"internal error: Map.rebalance\"));\n                }\n            }\n            else {\n                return MapTreeModule_mk(MapTreeNode$2__get_Left(matchValue_2), MapTreeLeaf$2__get_Key(matchValue_2), MapTreeLeaf$2__get_Value(matchValue_2), MapTreeModule_mk(MapTreeNode$2__get_Right(matchValue_2), k, v, t2));\n            }\n        }\n        else {\n            throw (new Error(\"internal error: Map.rebalance\"));\n        }\n    }\n    else {\n        return MapTreeModule_mk(t1, k, v, t2);\n    }\n}\n\nexport function MapTreeModule_add(comparer, k, v, m) {\n    if (m != null) {\n        const m2 = m;\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n        if (m2 instanceof MapTreeNode$2) {\n            if (c < 0) {\n                return MapTreeModule_rebalance(MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\n            }\n            else if (c === 0) {\n                return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\n            }\n            else {\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_add(comparer, k, v, MapTreeNode$2__get_Right(m2)));\n            }\n        }\n        else if (c < 0) {\n            return MapTreeNode$2_$ctor_499A11FD(k, v, MapTreeModule_empty(), m, 2);\n        }\n        else if (c === 0) {\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\n        }\n        else {\n            return MapTreeNode$2_$ctor_499A11FD(k, v, m, MapTreeModule_empty(), 2);\n        }\n    }\n    else {\n        return MapTreeLeaf$2_$ctor_5BDDA1(k, v);\n    }\n}\n\nexport function MapTreeModule_tryFind(comparer_mut, k_mut, m_mut) {\n    MapTreeModule_tryFind:\n    while (true) {\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n            if (c === 0) {\n                return some(MapTreeLeaf$2__get_Value(m2));\n            }\n            else if (m2 instanceof MapTreeNode$2) {\n                comparer_mut = comparer;\n                k_mut = k;\n                m_mut = ((c < 0) ? MapTreeNode$2__get_Left(m2) : MapTreeNode$2__get_Right(m2));\n                continue MapTreeModule_tryFind;\n            }\n            else {\n                return void 0;\n            }\n        }\n        else {\n            return void 0;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_find(comparer, k, m) {\n    const matchValue = MapTreeModule_tryFind(comparer, k, m);\n    if (matchValue == null) {\n        throw (new Error());\n    }\n    else {\n        return value_2(matchValue);\n    }\n}\n\nexport function MapTreeModule_partition1(comparer, f, k, v, acc1, acc2) {\n    if (f(k, v)) {\n        return [MapTreeModule_add(comparer, k, v, acc1), acc2];\n    }\n    else {\n        return [acc1, MapTreeModule_add(comparer, k, v, acc2)];\n    }\n}\n\nexport function MapTreeModule_partitionAux(comparer_mut, f_mut, m_mut, acc_0_mut, acc_1_mut) {\n    MapTreeModule_partitionAux:\n    while (true) {\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\n        const acc = [acc_0, acc_1];\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                const acc_2 = MapTreeModule_partitionAux(comparer, f, MapTreeNode$2__get_Right(m2), acc[0], acc[1]);\n                const acc_3 = MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_2[0], acc_2[1]);\n                comparer_mut = comparer;\n                f_mut = f;\n                m_mut = MapTreeNode$2__get_Left(m2);\n                acc_0_mut = acc_3[0];\n                acc_1_mut = acc_3[1];\n                continue MapTreeModule_partitionAux;\n            }\n            else {\n                return MapTreeModule_partition1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc[0], acc[1]);\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_partition(comparer, f, m) {\n    return MapTreeModule_partitionAux(comparer, f, m, MapTreeModule_empty(), MapTreeModule_empty());\n}\n\nexport function MapTreeModule_filter1(comparer, f, k, v, acc) {\n    if (f(k, v)) {\n        return MapTreeModule_add(comparer, k, v, acc);\n    }\n    else {\n        return acc;\n    }\n}\n\nexport function MapTreeModule_filterAux(comparer_mut, f_mut, m_mut, acc_mut) {\n    MapTreeModule_filterAux:\n    while (true) {\n        const comparer = comparer_mut, f = f_mut, m = m_mut, acc = acc_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                const acc_1 = MapTreeModule_filterAux(comparer, f, MapTreeNode$2__get_Left(m2), acc);\n                const acc_2 = MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc_1);\n                comparer_mut = comparer;\n                f_mut = f;\n                m_mut = MapTreeNode$2__get_Right(m2);\n                acc_mut = acc_2;\n                continue MapTreeModule_filterAux;\n            }\n            else {\n                return MapTreeModule_filter1(comparer, f, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), acc);\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_filter(comparer, f, m) {\n    return MapTreeModule_filterAux(comparer, f, m, MapTreeModule_empty());\n}\n\nexport function MapTreeModule_spliceOutSuccessor(m) {\n    if (m != null) {\n        const m2 = m;\n        if (m2 instanceof MapTreeNode$2) {\n            if (MapTreeNode$2__get_Left(m2) == null) {\n                return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2)];\n            }\n            else {\n                const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Left(m2));\n                return [patternInput[0], patternInput[1], MapTreeModule_mk(patternInput[2], MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2))];\n            }\n        }\n        else {\n            return [MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_empty()];\n        }\n    }\n    else {\n        throw (new Error(\"internal error: Map.spliceOutSuccessor\"));\n    }\n}\n\nexport function MapTreeModule_remove(comparer, k, m) {\n    if (m != null) {\n        const m2 = m;\n        const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n        if (m2 instanceof MapTreeNode$2) {\n            if (c < 0) {\n                return MapTreeModule_rebalance(MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\n            }\n            else if (c === 0) {\n                if (MapTreeNode$2__get_Left(m2) == null) {\n                    return MapTreeNode$2__get_Right(m2);\n                }\n                else if (MapTreeNode$2__get_Right(m2) == null) {\n                    return MapTreeNode$2__get_Left(m2);\n                }\n                else {\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\n                }\n            }\n            else {\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_remove(comparer, k, MapTreeNode$2__get_Right(m2)));\n            }\n        }\n        else if (c === 0) {\n            return MapTreeModule_empty();\n        }\n        else {\n            return m;\n        }\n    }\n    else {\n        return MapTreeModule_empty();\n    }\n}\n\nexport function MapTreeModule_change(comparer, k, u, m) {\n    if (m != null) {\n        const m2 = m;\n        if (m2 instanceof MapTreeNode$2) {\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n            if (c < 0) {\n                return MapTreeModule_rebalance(MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeNode$2__get_Right(m2));\n            }\n            else if (c === 0) {\n                const matchValue_1 = u(some(MapTreeLeaf$2__get_Value(m2)));\n                if (matchValue_1 != null) {\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_2(matchValue_1), MapTreeNode$2__get_Left(m2), MapTreeNode$2__get_Right(m2), MapTreeNode$2__get_Height(m2));\n                }\n                else if (MapTreeNode$2__get_Left(m2) == null) {\n                    return MapTreeNode$2__get_Right(m2);\n                }\n                else if (MapTreeNode$2__get_Right(m2) == null) {\n                    return MapTreeNode$2__get_Left(m2);\n                }\n                else {\n                    const patternInput = MapTreeModule_spliceOutSuccessor(MapTreeNode$2__get_Right(m2));\n                    return MapTreeModule_mk(MapTreeNode$2__get_Left(m2), patternInput[0], patternInput[1], patternInput[2]);\n                }\n            }\n            else {\n                return MapTreeModule_rebalance(MapTreeNode$2__get_Left(m2), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), MapTreeModule_change(comparer, k, u, MapTreeNode$2__get_Right(m2)));\n            }\n        }\n        else {\n            const c_1 = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n            if (c_1 < 0) {\n                const matchValue_2 = u(void 0);\n                if (matchValue_2 != null) {\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_2(matchValue_2), MapTreeModule_empty(), m, 2);\n                }\n                else {\n                    return m;\n                }\n            }\n            else if (c_1 === 0) {\n                const matchValue_3 = u(some(MapTreeLeaf$2__get_Value(m2)));\n                if (matchValue_3 != null) {\n                    return MapTreeLeaf$2_$ctor_5BDDA1(k, value_2(matchValue_3));\n                }\n                else {\n                    return MapTreeModule_empty();\n                }\n            }\n            else {\n                const matchValue_4 = u(void 0);\n                if (matchValue_4 != null) {\n                    return MapTreeNode$2_$ctor_499A11FD(k, value_2(matchValue_4), m, MapTreeModule_empty(), 2);\n                }\n                else {\n                    return m;\n                }\n            }\n        }\n    }\n    else {\n        const matchValue = u(void 0);\n        if (matchValue != null) {\n            return MapTreeLeaf$2_$ctor_5BDDA1(k, value_2(matchValue));\n        }\n        else {\n            return m;\n        }\n    }\n}\n\nexport function MapTreeModule_mem(comparer_mut, k_mut, m_mut) {\n    MapTreeModule_mem:\n    while (true) {\n        const comparer = comparer_mut, k = k_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            const c = comparer.Compare(k, MapTreeLeaf$2__get_Key(m2)) | 0;\n            if (m2 instanceof MapTreeNode$2) {\n                if (c < 0) {\n                    comparer_mut = comparer;\n                    k_mut = k;\n                    m_mut = MapTreeNode$2__get_Left(m2);\n                    continue MapTreeModule_mem;\n                }\n                else if (c === 0) {\n                    return true;\n                }\n                else {\n                    comparer_mut = comparer;\n                    k_mut = k;\n                    m_mut = MapTreeNode$2__get_Right(m2);\n                    continue MapTreeModule_mem;\n                }\n            }\n            else {\n                return c === 0;\n            }\n        }\n        else {\n            return false;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_iterOpt(f_mut, m_mut) {\n    MapTreeModule_iterOpt:\n    while (true) {\n        const f = f_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                MapTreeModule_iterOpt(f, MapTreeNode$2__get_Left(m2));\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n                f_mut = f;\n                m_mut = MapTreeNode$2__get_Right(m2);\n                continue MapTreeModule_iterOpt;\n            }\n            else {\n                f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            }\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_iter(f, m) {\n    MapTreeModule_iterOpt(f, m);\n}\n\nexport function MapTreeModule_tryPickOpt(f_mut, m_mut) {\n    MapTreeModule_tryPickOpt:\n    while (true) {\n        const f = f_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                const matchValue = MapTreeModule_tryPickOpt(f, MapTreeNode$2__get_Left(m2));\n                if (matchValue == null) {\n                    const matchValue_1 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n                    if (matchValue_1 == null) {\n                        f_mut = f;\n                        m_mut = MapTreeNode$2__get_Right(m2);\n                        continue MapTreeModule_tryPickOpt;\n                    }\n                    else {\n                        return matchValue_1;\n                    }\n                }\n                else {\n                    return matchValue;\n                }\n            }\n            else {\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            }\n        }\n        else {\n            return void 0;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_tryPick(f, m) {\n    return MapTreeModule_tryPickOpt(f, m);\n}\n\nexport function MapTreeModule_existsOpt(f_mut, m_mut) {\n    MapTreeModule_existsOpt:\n    while (true) {\n        const f = f_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                if (MapTreeModule_existsOpt(f, MapTreeNode$2__get_Left(m2)) ? true : f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2))) {\n                    return true;\n                }\n                else {\n                    f_mut = f;\n                    m_mut = MapTreeNode$2__get_Right(m2);\n                    continue MapTreeModule_existsOpt;\n                }\n            }\n            else {\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            }\n        }\n        else {\n            return false;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_exists(f, m) {\n    return MapTreeModule_existsOpt(f, m);\n}\n\nexport function MapTreeModule_forallOpt(f_mut, m_mut) {\n    MapTreeModule_forallOpt:\n    while (true) {\n        const f = f_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                if (MapTreeModule_forallOpt(f, MapTreeNode$2__get_Left(m2)) ? f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)) : false) {\n                    f_mut = f;\n                    m_mut = MapTreeNode$2__get_Right(m2);\n                    continue MapTreeModule_forallOpt;\n                }\n                else {\n                    return false;\n                }\n            }\n            else {\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            }\n        }\n        else {\n            return true;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_forall(f, m) {\n    return MapTreeModule_forallOpt(f, m);\n}\n\nexport function MapTreeModule_map(f, m) {\n    if (m != null) {\n        const m2 = m;\n        if (m2 instanceof MapTreeNode$2) {\n            const l2 = MapTreeModule_map(f, MapTreeNode$2__get_Left(m2));\n            const v2 = f(MapTreeLeaf$2__get_Value(m2));\n            const r2 = MapTreeModule_map(f, MapTreeNode$2__get_Right(m2));\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\n        }\n        else {\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Value(m2)));\n        }\n    }\n    else {\n        return MapTreeModule_empty();\n    }\n}\n\nexport function MapTreeModule_mapiOpt(f, m) {\n    if (m != null) {\n        const m2 = m;\n        if (m2 instanceof MapTreeNode$2) {\n            const l2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Left(m2));\n            const v2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            const r2 = MapTreeModule_mapiOpt(f, MapTreeNode$2__get_Right(m2));\n            return MapTreeNode$2_$ctor_499A11FD(MapTreeLeaf$2__get_Key(m2), v2, l2, r2, MapTreeNode$2__get_Height(m2));\n        }\n        else {\n            return MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)));\n        }\n    }\n    else {\n        return MapTreeModule_empty();\n    }\n}\n\nexport function MapTreeModule_mapi(f, m) {\n    return MapTreeModule_mapiOpt(f, m);\n}\n\nexport function MapTreeModule_foldBackOpt(f_mut, m_mut, x_mut) {\n    MapTreeModule_foldBackOpt:\n    while (true) {\n        const f = f_mut, m = m_mut, x = x_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                const x_1 = MapTreeModule_foldBackOpt(f, MapTreeNode$2__get_Right(m2), x);\n                const x_2 = f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\n                f_mut = f;\n                m_mut = MapTreeNode$2__get_Left(m2);\n                x_mut = x_2;\n                continue MapTreeModule_foldBackOpt;\n            }\n            else {\n                return f(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x);\n            }\n        }\n        else {\n            return x;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_foldBack(f, m, x) {\n    return MapTreeModule_foldBackOpt(f, m, x);\n}\n\nexport function MapTreeModule_foldOpt(f_mut, x_mut, m_mut) {\n    MapTreeModule_foldOpt:\n    while (true) {\n        const f = f_mut, x = x_mut, m = m_mut;\n        if (m != null) {\n            const m2 = m;\n            if (m2 instanceof MapTreeNode$2) {\n                f_mut = f;\n                x_mut = f(MapTreeModule_foldOpt(f, x, MapTreeNode$2__get_Left(m2)), MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n                m_mut = MapTreeNode$2__get_Right(m2);\n                continue MapTreeModule_foldOpt;\n            }\n            else {\n                return f(x, MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2));\n            }\n        }\n        else {\n            return x;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_fold(f, x, m) {\n    return MapTreeModule_foldOpt(f, x, m);\n}\n\nexport function MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x) {\n    const foldFromTo = (f_1_mut, m_1_mut, x_1_mut) => {\n        foldFromTo:\n        while (true) {\n            const f_1 = f_1_mut, m_1 = m_1_mut, x_1 = x_1_mut;\n            if (m_1 != null) {\n                const m2 = m_1;\n                if (m2 instanceof MapTreeNode$2) {\n                    const cLoKey = comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) | 0;\n                    const cKeyHi = comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) | 0;\n                    const x_2 = (cLoKey < 0) ? foldFromTo(f_1, MapTreeNode$2__get_Left(m2), x_1) : x_1;\n                    const x_3 = ((cLoKey <= 0) ? (cKeyHi <= 0) : false) ? f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_2) : x_2;\n                    if (cKeyHi < 0) {\n                        f_1_mut = f_1;\n                        m_1_mut = MapTreeNode$2__get_Right(m2);\n                        x_1_mut = x_3;\n                        continue foldFromTo;\n                    }\n                    else {\n                        return x_3;\n                    }\n                }\n                else if ((comparer.Compare(lo, MapTreeLeaf$2__get_Key(m2)) <= 0) ? (comparer.Compare(MapTreeLeaf$2__get_Key(m2), hi) <= 0) : false) {\n                    return f_1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2), x_1);\n                }\n                else {\n                    return x_1;\n                }\n            }\n            else {\n                return x_1;\n            }\n            break;\n        }\n    };\n    if (comparer.Compare(lo, hi) === 1) {\n        return x;\n    }\n    else {\n        return foldFromTo(f, m, x);\n    }\n}\n\nexport function MapTreeModule_foldSection(comparer, lo, hi, f, m, x) {\n    return MapTreeModule_foldSectionOpt(comparer, lo, hi, f, m, x);\n}\n\nexport function MapTreeModule_toList(m) {\n    const loop = (m_1_mut, acc_mut) => {\n        loop:\n        while (true) {\n            const m_1 = m_1_mut, acc = acc_mut;\n            if (m_1 != null) {\n                const m2 = m_1;\n                if (m2 instanceof MapTreeNode$2) {\n                    m_1_mut = MapTreeNode$2__get_Left(m2);\n                    acc_mut = (new List([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], loop(MapTreeNode$2__get_Right(m2), acc)));\n                    continue loop;\n                }\n                else {\n                    return new List([MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)], acc);\n                }\n            }\n            else {\n                return acc;\n            }\n            break;\n        }\n    };\n    return loop(m, new List());\n}\n\nexport function MapTreeModule_toArray(m) {\n    return Array.from(MapTreeModule_toList(m));\n}\n\nexport function MapTreeModule_ofList(comparer, l) {\n    return fold_1((acc, tupledArg) => MapTreeModule_add(comparer, tupledArg[0], tupledArg[1], acc), MapTreeModule_empty(), l);\n}\n\nexport function MapTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\n    MapTreeModule_mkFromEnumerator:\n    while (true) {\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const patternInput = e[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n            comparer_mut = comparer;\n            acc_mut = MapTreeModule_add(comparer, patternInput[0], patternInput[1], acc);\n            e_mut = e;\n            continue MapTreeModule_mkFromEnumerator;\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_ofArray(comparer, arr) {\n    let res = MapTreeModule_empty();\n    for (let idx = 0; idx <= (arr.length - 1); idx++) {\n        const forLoopVar = arr[idx];\n        res = MapTreeModule_add(comparer, forLoopVar[0], forLoopVar[1], res);\n    }\n    return res;\n}\n\nexport function MapTreeModule_ofSeq(comparer, c) {\n    if (isArrayLike(c)) {\n        return MapTreeModule_ofArray(comparer, c);\n    }\n    else if (c instanceof List) {\n        return MapTreeModule_ofList(comparer, c);\n    }\n    else {\n        const ie = getEnumerator(c);\n        try {\n            return MapTreeModule_mkFromEnumerator(comparer, MapTreeModule_empty(), ie);\n        }\n        finally {\n            ie.Dispose();\n        }\n    }\n}\n\nexport function MapTreeModule_copyToArray(m, arr, i) {\n    let j = i | 0;\n    MapTreeModule_iter((x, y) => {\n        arr[j] = [x, y];\n        j = (j + 1);\n    }, m);\n}\n\nexport class MapTreeModule_MapIterator$2 extends Record {\n    constructor(stack, started) {\n        super();\n        this.stack = stack;\n        this.started = started;\n    }\n}\n\nexport function MapTreeModule_MapIterator$2$reflection(gen0, gen1) {\n    return record_type(\"Map.MapTreeModule.MapIterator`2\", [gen0, gen1], MapTreeModule_MapIterator$2, () => [[\"stack\", list_type(option_type(MapTreeLeaf$2$reflection(gen0, gen1)))], [\"started\", bool_type]]);\n}\n\nexport function MapTreeModule_collapseLHS(stack_mut) {\n    MapTreeModule_collapseLHS:\n    while (true) {\n        const stack = stack_mut;\n        if (stack.tail != null) {\n            const rest = stack.tail;\n            const m = stack.head;\n            if (m != null) {\n                const m2 = m;\n                if (m2 instanceof MapTreeNode$2) {\n                    stack_mut = (new List(MapTreeNode$2__get_Left(m2), new List(MapTreeLeaf$2_$ctor_5BDDA1(MapTreeLeaf$2__get_Key(m2), MapTreeLeaf$2__get_Value(m2)), new List(MapTreeNode$2__get_Right(m2), rest))));\n                    continue MapTreeModule_collapseLHS;\n                }\n                else {\n                    return stack;\n                }\n            }\n            else {\n                stack_mut = rest;\n                continue MapTreeModule_collapseLHS;\n            }\n        }\n        else {\n            return new List();\n        }\n        break;\n    }\n}\n\nexport function MapTreeModule_mkIterator(m) {\n    return new MapTreeModule_MapIterator$2(MapTreeModule_collapseLHS(new List(m, new List())), false);\n}\n\nexport function MapTreeModule_notStarted() {\n    throw (new Error(\"enumeration not started\"));\n}\n\nexport function MapTreeModule_alreadyFinished() {\n    throw (new Error(\"enumeration already finished\"));\n}\n\nexport function MapTreeModule_current(i) {\n    if (i.started) {\n        const matchValue = i.stack;\n        if (matchValue.tail != null) {\n            if (matchValue.head != null) {\n                const m = matchValue.head;\n                if (m instanceof MapTreeNode$2) {\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\n                }\n                else {\n                    return [MapTreeLeaf$2__get_Key(m), MapTreeLeaf$2__get_Value(m)];\n                }\n            }\n            else {\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for current\"));\n            }\n        }\n        else {\n            return MapTreeModule_alreadyFinished();\n        }\n    }\n    else {\n        return MapTreeModule_notStarted();\n    }\n}\n\nexport function MapTreeModule_moveNext(i) {\n    if (i.started) {\n        const matchValue = i.stack;\n        if (matchValue.tail != null) {\n            if (matchValue.head != null) {\n                const m = matchValue.head;\n                if (m instanceof MapTreeNode$2) {\n                    throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\n                }\n                else {\n                    i.stack = MapTreeModule_collapseLHS(matchValue.tail);\n                    return !(i.stack.tail == null);\n                }\n            }\n            else {\n                throw (new Error(\"Please report error: Map iterator, unexpected stack for moveNext\"));\n            }\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        i.started = true;\n        return !(i.stack.tail == null);\n    }\n}\n\nexport function MapTreeModule_mkIEnumerator(m) {\n    let i = MapTreeModule_mkIterator(m);\n    return {\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n            return MapTreeModule_current(i);\n        },\n        [\"System.Collections.IEnumerator.get_Current\"]() {\n            return MapTreeModule_current(i);\n        },\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\n            return MapTreeModule_moveNext(i);\n        },\n        [\"System.Collections.IEnumerator.Reset\"]() {\n            i = MapTreeModule_mkIterator(m);\n        },\n        Dispose() {\n        },\n    };\n}\n\nexport function MapTreeModule_toSeq(s) {\n    return unfold((en_1) => {\n        if (en_1[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            return [en_1[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), en_1];\n        }\n        else {\n            return void 0;\n        }\n    }, MapTreeModule_mkIEnumerator(s));\n}\n\nexport class FSharpMap {\n    constructor(comparer, tree) {\n        this.comparer = comparer;\n        this.tree = tree;\n    }\n    GetHashCode() {\n        const this$ = this;\n        return FSharpMap__ComputeHashCode(this$) | 0;\n    }\n    Equals(that) {\n        const this$ = this;\n        if (that instanceof FSharpMap) {\n            const e1 = getEnumerator(this$);\n            try {\n                const e2 = getEnumerator(that);\n                try {\n                    const loop = () => {\n                        const m1 = e1[\"System.Collections.IEnumerator.MoveNext\"]();\n                        if (m1 === e2[\"System.Collections.IEnumerator.MoveNext\"]()) {\n                            if (!m1) {\n                                return true;\n                            }\n                            else {\n                                const e1c = e1[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                                const e2c = e2[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n                                if (equals(e1c[0], e2c[0]) ? equals(e1c[1], e2c[1]) : false) {\n                                    return loop();\n                                }\n                                else {\n                                    return false;\n                                }\n                            }\n                        }\n                        else {\n                            return false;\n                        }\n                    };\n                    return loop();\n                }\n                finally {\n                    e2.Dispose();\n                }\n            }\n            finally {\n                e1.Dispose();\n            }\n        }\n        else {\n            return false;\n        }\n    }\n    toString() {\n        const this$ = this;\n        return (\"map [\" + join(\"; \", map_2((kv) => format(\"({0}, {1})\", kv[0], kv[1]), this$))) + \"]\";\n    }\n    get [Symbol.toStringTag]() {\n        return \"FSharpMap\";\n    }\n    GetEnumerator() {\n        const __ = this;\n        return MapTreeModule_mkIEnumerator(__.tree);\n    }\n    [Symbol.iterator]() {\n        return toIterator(this.GetEnumerator());\n    }\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\n        const __ = this;\n        return MapTreeModule_mkIEnumerator(__.tree);\n    }\n    CompareTo(obj) {\n        const m = this;\n        if (obj instanceof FSharpMap) {\n            return compareWith((kvp1, kvp2) => {\n                const c = m.comparer.Compare(kvp1[0], kvp2[0]) | 0;\n                return ((c !== 0) ? c : compare(kvp1[1], kvp2[1])) | 0;\n            }, m, obj) | 0;\n        }\n        else {\n            throw (new Error(\"not comparable\\\\nParameter name: obj\"));\n        }\n    }\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\n        void x;\n        throw (new Error(\"Map cannot be mutated\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\n        throw (new Error(\"Map cannot be mutated\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\n        void x;\n        throw (new Error(\"Map cannot be mutated\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\n        const m = this;\n        return FSharpMap__ContainsKey(m, x[0]) ? equals(FSharpMap__get_Item(m, x[0]), x[1]) : false;\n    }\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\n        const m = this;\n        MapTreeModule_copyToArray(m.tree, arr, i);\n    }\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\n        return true;\n    }\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\n        const m = this;\n        return FSharpMap__get_Count(m) | 0;\n    }\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\n        const m = this;\n        return FSharpMap__get_Count(m) | 0;\n    }\n    get size() {\n        const m = this;\n        return FSharpMap__get_Count(m) | 0;\n    }\n    clear() {\n        throw (new Error(\"Map cannot be mutated\"));\n    }\n    delete(_arg1) {\n        throw (new Error(\"Map cannot be mutated\"));\n        return false;\n    }\n    entries() {\n        const m = this;\n        return map_2((p) => [p[0], p[1]], m);\n    }\n    get(k) {\n        const m = this;\n        return FSharpMap__get_Item(m, k);\n    }\n    has(k) {\n        const m = this;\n        return FSharpMap__ContainsKey(m, k);\n    }\n    keys() {\n        const m = this;\n        return map_2((p) => p[0], m);\n    }\n    set(k, v) {\n        const m = this;\n        throw (new Error(\"Map cannot be mutated\"));\n        return m;\n    }\n    values() {\n        const m = this;\n        return map_2((p) => p[1], m);\n    }\n    forEach(f, thisArg) {\n        const m = this;\n        iterate_1((p) => {\n            f(p[1], p[0], m);\n        }, m);\n    }\n}\n\nexport function FSharpMap$reflection(gen0, gen1) {\n    return class_type(\"Map.FSharpMap\", [gen0, gen1], FSharpMap);\n}\n\nexport function FSharpMap_$ctor(comparer, tree) {\n    return new FSharpMap(comparer, tree);\n}\n\n(() => {\n    FSharpMap.empty = FSharpMap_$ctor(LanguagePrimitives_FastGenericComparer(), MapTreeModule_empty());\n})();\n\nexport function FSharpMap_get_Empty() {\n    return FSharpMap.empty;\n}\n\nexport function FSharpMap_Create(ie) {\n    const comparer = LanguagePrimitives_FastGenericComparer();\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofSeq(comparer, ie));\n}\n\nexport function FSharpMap__get_Comparer(m) {\n    return m.comparer;\n}\n\nexport function FSharpMap__get_Tree(m) {\n    return m.tree;\n}\n\nexport function FSharpMap__Add(m, key, value) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_add(m.comparer, key, value, m.tree));\n}\n\nexport function FSharpMap__Change(m, key, f) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_change(m.comparer, key, f, m.tree));\n}\n\nexport function FSharpMap__get_IsEmpty(m) {\n    return m.tree == null;\n}\n\nexport function FSharpMap__get_Item(m, key) {\n    return MapTreeModule_find(m.comparer, key, m.tree);\n}\n\nexport function FSharpMap__TryPick(m, f) {\n    return MapTreeModule_tryPick(f, m.tree);\n}\n\nexport function FSharpMap__Exists(m, predicate) {\n    return MapTreeModule_exists(predicate, m.tree);\n}\n\nexport function FSharpMap__Filter(m, predicate) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_filter(m.comparer, predicate, m.tree));\n}\n\nexport function FSharpMap__ForAll(m, predicate) {\n    return MapTreeModule_forall(predicate, m.tree);\n}\n\nexport function FSharpMap__Fold(m, f, acc) {\n    return MapTreeModule_foldBack(f, m.tree, acc);\n}\n\nexport function FSharpMap__FoldSection(m, lo, hi, f, acc) {\n    return MapTreeModule_foldSection(m.comparer, lo, hi, f, m.tree, acc);\n}\n\nexport function FSharpMap__Iterate(m, f) {\n    MapTreeModule_iter(f, m.tree);\n}\n\nexport function FSharpMap__MapRange(m, f) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_map(f, m.tree));\n}\n\nexport function FSharpMap__Map(m, f) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_mapi(f, m.tree));\n}\n\nexport function FSharpMap__Partition(m, predicate) {\n    const patternInput = MapTreeModule_partition(m.comparer, predicate, m.tree);\n    return [FSharpMap_$ctor(m.comparer, patternInput[0]), FSharpMap_$ctor(m.comparer, patternInput[1])];\n}\n\nexport function FSharpMap__get_Count(m) {\n    return MapTreeModule_size(m.tree);\n}\n\nexport function FSharpMap__ContainsKey(m, key) {\n    return MapTreeModule_mem(m.comparer, key, m.tree);\n}\n\nexport function FSharpMap__Remove(m, key) {\n    return FSharpMap_$ctor(m.comparer, MapTreeModule_remove(m.comparer, key, m.tree));\n}\n\nexport function FSharpMap__TryGetValue(__, key, value) {\n    const matchValue = MapTreeModule_tryFind(__.comparer, key, __.tree);\n    if (matchValue == null) {\n        return false;\n    }\n    else {\n        const v = value_2(matchValue);\n        value.contents = v;\n        return true;\n    }\n}\n\nexport function FSharpMap__TryFind(m, key) {\n    return MapTreeModule_tryFind(m.comparer, key, m.tree);\n}\n\nexport function FSharpMap__ToList(m) {\n    return MapTreeModule_toList(m.tree);\n}\n\nexport function FSharpMap__ToArray(m) {\n    return MapTreeModule_toArray(m.tree);\n}\n\nexport function FSharpMap__ComputeHashCode(this$) {\n    const combineHash = (x, y) => (((x << 1) + y) + 631);\n    let res = 0;\n    const enumerator = getEnumerator(this$);\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const activePatternResult4293 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n            res = combineHash(res, structuralHash(activePatternResult4293[0]));\n            res = combineHash(res, structuralHash(activePatternResult4293[1]));\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n    return res | 0;\n}\n\nexport function isEmpty(table) {\n    return FSharpMap__get_IsEmpty(table);\n}\n\nexport function add(key, value, table) {\n    return FSharpMap__Add(table, key, value);\n}\n\nexport function change(key, f, table) {\n    return FSharpMap__Change(table, key, f);\n}\n\nexport function find(key, table) {\n    return FSharpMap__get_Item(table, key);\n}\n\nexport function tryFind(key, table) {\n    return FSharpMap__TryFind(table, key);\n}\n\nexport function remove(key, table) {\n    return FSharpMap__Remove(table, key);\n}\n\nexport function containsKey(key, table) {\n    return FSharpMap__ContainsKey(table, key);\n}\n\nexport function iterate(action, table) {\n    FSharpMap__Iterate(table, action);\n}\n\nexport function tryPick(chooser, table) {\n    return FSharpMap__TryPick(table, chooser);\n}\n\nexport function pick(chooser, table) {\n    const matchValue = tryPick(chooser, table);\n    if (matchValue != null) {\n        return value_2(matchValue);\n    }\n    else {\n        throw (new Error());\n    }\n}\n\nexport function exists(predicate, table) {\n    return FSharpMap__Exists(table, predicate);\n}\n\nexport function filter(predicate, table) {\n    return FSharpMap__Filter(table, predicate);\n}\n\nexport function partition(predicate, table) {\n    return FSharpMap__Partition(table, predicate);\n}\n\nexport function forAll(predicate, table) {\n    return FSharpMap__ForAll(table, predicate);\n}\n\nexport function map(mapping, table) {\n    return FSharpMap__Map(table, mapping);\n}\n\nexport function fold(folder, state, table) {\n    return MapTreeModule_fold(folder, state, FSharpMap__get_Tree(table));\n}\n\nexport function foldBack(folder, table, state) {\n    return MapTreeModule_foldBack(folder, FSharpMap__get_Tree(table), state);\n}\n\nexport function toSeq(table) {\n    return map_2((kvp) => [kvp[0], kvp[1]], table);\n}\n\nexport function findKey(predicate, table) {\n    return pick_1((kvp) => {\n        const k = kvp[0];\n        if (predicate(k, kvp[1])) {\n            return some(k);\n        }\n        else {\n            return void 0;\n        }\n    }, table);\n}\n\nexport function tryFindKey(predicate, table) {\n    return tryPick_1((kvp) => {\n        const k = kvp[0];\n        if (predicate(k, kvp[1])) {\n            return some(k);\n        }\n        else {\n            return void 0;\n        }\n    }, table);\n}\n\nexport function ofList(elements) {\n    return FSharpMap_Create(elements);\n}\n\nexport function ofSeq(elements) {\n    return FSharpMap_Create(elements);\n}\n\nexport function ofArray(elements) {\n    const comparer = LanguagePrimitives_FastGenericComparer();\n    return FSharpMap_$ctor(comparer, MapTreeModule_ofArray(comparer, elements));\n}\n\nexport function toList(table) {\n    return FSharpMap__ToList(table);\n}\n\nexport function toArray(table) {\n    return FSharpMap__ToArray(table);\n}\n\nexport function empty() {\n    return FSharpMap_get_Empty();\n}\n\nexport function createMutable(source, comparer) {\n    return Dictionary_$ctor_6623D9B3(source, comparer);\n}\n\nexport function groupBy(projection, xs, comparer) {\n    const dict = createMutable(empty_1(), comparer);\n    const enumerator = getEnumerator(xs);\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const v = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n            const key = projection(v);\n            if (dict.has(key)) {\n                void (dict.get(key).push(v));\n            }\n            else {\n                const value = dict.set(key, [v]);\n                void value;\n            }\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n    return map_2((tupledArg) => [tupledArg[0], tupledArg[1]], dict.entries());\n}\n\nexport function countBy(projection, xs, comparer) {\n    const dict = createMutable(empty_1(), comparer);\n    const enumerator = getEnumerator(xs);\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const key = projection(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\n            const value_1 = dict.has(key) ? dict.set(key, dict.get(key) + 1) : dict.set(key, 1);\n            void value_1;\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n    return dict.entries();\n}\n\nexport function count(table) {\n    return FSharpMap__get_Count(table);\n}\n\n","import { some, value } from \"../fable-library.3.1.4/Option.js\";\r\n\r\nexport function tuple(a, b) {\r\n    const matchValue = [a, b];\r\n    let pattern_matching_result, a_1, b_1;\r\n    if (matchValue[0] != null) {\r\n        if (matchValue[1] != null) {\r\n            pattern_matching_result = 0;\r\n            a_1 = value(matchValue[0]);\r\n            b_1 = value(matchValue[1]);\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return [a_1, b_1];\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport function ofFunc(f, arg) {\r\n    try {\r\n        return some(f(arg));\r\n    }\r\n    catch (matchValue) {\r\n        return void 0;\r\n    }\r\n}\r\n\r\n","import { FSharpRef, Record } from \"../fable-library.3.1.4/Types.js\";\r\nimport { record_type, class_type, list_type, string_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { ofArray, collect, map as map_1, singleton, cons, empty } from \"../fable-library.3.1.4/List.js\";\r\nimport { FSharpResult$2 } from \"../fable-library.3.1.4/Choice.js\";\r\nimport { tryParse } from \"../fable-library.3.1.4/Int32.js\";\r\nimport { empty as empty_1, ofSeq, tryFind } from \"../fable-library.3.1.4/Map.js\";\r\nimport { some, bind } from \"../fable-library.3.1.4/Option.js\";\r\nimport { equalsWith } from \"../fable-library.3.1.4/Array.js\";\r\nimport { comparePrimitives } from \"../fable-library.3.1.4/Util.js\";\r\nimport { ofFunc, tuple } from \"./prelude.fs.js\";\r\nimport { map as map_2, choose } from \"../fable-library.3.1.4/Seq.js\";\r\nimport { substring } from \"../fable-library.3.1.4/String.js\";\r\n\r\nexport class State$1 extends Record {\r\n    constructor(visited, unvisited, args, value) {\r\n        super();\r\n        this.visited = visited;\r\n        this.unvisited = unvisited;\r\n        this.args = args;\r\n        this.value = value;\r\n    }\r\n}\r\n\r\nexport function State$1$reflection(gen0) {\r\n    return record_type(\"Elmish.UrlParser.State`1\", [gen0], State$1, () => [[\"visited\", list_type(string_type)], [\"unvisited\", list_type(string_type)], [\"args\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, string_type])], [\"value\", gen0]]);\r\n}\r\n\r\nexport function StateModule_mkState(visited, unvisited, args, value) {\r\n    return new State$1(visited, unvisited, args, value);\r\n}\r\n\r\nexport function StateModule_map(f, _arg1) {\r\n    return new State$1(_arg1.visited, _arg1.unvisited, _arg1.args, f(_arg1.value));\r\n}\r\n\r\nexport function custom(tipe, stringToSomething) {\r\n    return (_arg1) => {\r\n        const unvisited = _arg1.unvisited;\r\n        if (unvisited.tail != null) {\r\n            const next = unvisited.head;\r\n            const matchValue = stringToSomething(next);\r\n            if (matchValue.tag === 1) {\r\n                return empty();\r\n            }\r\n            else {\r\n                return singleton(StateModule_mkState(cons(next, _arg1.visited), unvisited.tail, _arg1.args, _arg1.value(matchValue.fields[0])));\r\n            }\r\n        }\r\n        else {\r\n            return empty();\r\n        }\r\n    };\r\n}\r\n\r\nexport function str(state) {\r\n    return custom(\"string\", (arg0) => (new FSharpResult$2(0, arg0)))(state);\r\n}\r\n\r\nexport function i32(state) {\r\n    return custom(\"i32\", (arg) => {\r\n        let _arg1;\r\n        let outArg = 0;\r\n        _arg1 = [tryParse(arg, 511, false, 32, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return _arg1[0] ? (new FSharpResult$2(0, _arg1[1])) : (new FSharpResult$2(1, \"Can\\u0027t parse int\"));\r\n    })(state);\r\n}\r\n\r\nexport function s(str_1) {\r\n    return (_arg1) => {\r\n        const unvisited = _arg1.unvisited;\r\n        if (unvisited.tail != null) {\r\n            const next = unvisited.head;\r\n            if (next === str_1) {\r\n                return singleton(StateModule_mkState(cons(next, _arg1.visited), unvisited.tail, _arg1.args, _arg1.value));\r\n            }\r\n            else {\r\n                return empty();\r\n            }\r\n        }\r\n        else {\r\n            return empty();\r\n        }\r\n    };\r\n}\r\n\r\nexport function map(subValue, parse_1) {\r\n    return (_arg1) => map_1((arg10$0040) => StateModule_map(_arg1.value, arg10$0040), parse_1(new State$1(_arg1.visited, _arg1.unvisited, _arg1.args, subValue)));\r\n}\r\n\r\nexport function oneOf(parsers, state) {\r\n    return collect((parser) => parser(state), parsers);\r\n}\r\n\r\nexport function top(state) {\r\n    return singleton(state);\r\n}\r\n\r\nexport function customParam(key, func) {\r\n    return (_arg1) => {\r\n        const args = _arg1.args;\r\n        return singleton(StateModule_mkState(_arg1.visited, _arg1.unvisited, args, _arg1.value(func(tryFind(key, args)))));\r\n    };\r\n}\r\n\r\nexport function stringParam(name) {\r\n    return customParam(name, (x) => x);\r\n}\r\n\r\nexport const intParamHelp = (option) => bind((value) => {\r\n    let matchValue;\r\n    let outArg = 0;\r\n    matchValue = [tryParse(value, 511, false, 32, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return matchValue[1];\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}, option);\r\n\r\nexport function intParam(name) {\r\n    return customParam(name, intParamHelp);\r\n}\r\n\r\nexport function parseHelp(states_mut) {\r\n    parseHelp:\r\n    while (true) {\r\n        const states = states_mut;\r\n        if (states.tail != null) {\r\n            const state = states.head;\r\n            const matchValue = state.unvisited;\r\n            let pattern_matching_result;\r\n            if (matchValue.tail != null) {\r\n                if (matchValue.head === \"\") {\r\n                    if (matchValue.tail.tail == null) {\r\n                        pattern_matching_result = 1;\r\n                    }\r\n                    else {\r\n                        pattern_matching_result = 2;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result = 2;\r\n                }\r\n            }\r\n            else {\r\n                pattern_matching_result = 0;\r\n            }\r\n            switch (pattern_matching_result) {\r\n                case 0: {\r\n                    return some(state.value);\r\n                }\r\n                case 1: {\r\n                    return some(state.value);\r\n                }\r\n                case 2: {\r\n                    states_mut = states.tail;\r\n                    continue parseHelp;\r\n                }\r\n            }\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n        break;\r\n    }\r\n}\r\n\r\nexport function splitUrl(url) {\r\n    const matchValue = ofArray(url.split(\"/\"));\r\n    let pattern_matching_result, segments, segments_1;\r\n    if (matchValue.tail != null) {\r\n        if (matchValue.head === \"\") {\r\n            pattern_matching_result = 0;\r\n            segments = matchValue.tail;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n            segments_1 = matchValue;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n        segments_1 = matchValue;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return segments;\r\n        }\r\n        case 1: {\r\n            return segments_1;\r\n        }\r\n    }\r\n}\r\n\r\nexport function parse(parser, url, args) {\r\n    return parseHelp(parser(new State$1(empty(), splitUrl(url), args, (x) => x)));\r\n}\r\n\r\nexport function toKeyValuePair(segment) {\r\n    const matchValue = segment.split(\"=\");\r\n    if ((!equalsWith((x, y) => comparePrimitives(x, y), matchValue, null)) ? (matchValue.length === 2) : false) {\r\n        const value = matchValue[1];\r\n        return tuple(ofFunc(decodeURIComponent, matchValue[0]), ofFunc(decodeURIComponent, value));\r\n    }\r\n    else {\r\n        return void 0;\r\n    }\r\n}\r\n\r\nexport function parseParams(querystring) {\r\n    if (querystring.length > 1) {\r\n        return ofSeq(choose((x) => x, map_2((segment) => toKeyValuePair(segment), substring(querystring, 1).split(\"\\u0026\"))));\r\n    }\r\n    else {\r\n        return empty_1();\r\n    }\r\n}\r\n\r\nexport function parsePath(parser, location) {\r\n    return parse(parser, location.pathname, parseParams(location.search));\r\n}\r\n\r\nexport function parseHash(parser, location) {\r\n    let patternInput;\r\n    const hash = (location.hash.length > 1) ? substring(location.hash, 1) : \"\";\r\n    if (hash.indexOf(\"?\") >= 0) {\r\n        const h = substring(hash, 0, hash.indexOf(\"?\"));\r\n        patternInput = [h, substring(hash, h.length)];\r\n    }\r\n    else {\r\n        patternInput = [hash, \"?\"];\r\n    }\r\n    return parse(parser, patternInput[0], parseParams(patternInput[1]));\r\n}\r\n\r\n","import { Union, Record } from \"./.fable/fable-library.3.1.4/Types.js\";\r\nimport { union_type, option_type, class_type, record_type, list_type, int32_type, bool_type, string_type } from \"./.fable/fable-library.3.1.4/Reflection.js\";\r\n\r\nexport class Autor$0027 extends Record {\r\n    constructor(Name, Nachname, Vorname, Vortragender, FirmenIndex) {\r\n        super();\r\n        this.Name = Name;\r\n        this.Nachname = Nachname;\r\n        this.Vorname = Vorname;\r\n        this.Vortragender = Vortragender;\r\n        this.FirmenIndex = FirmenIndex;\r\n    }\r\n}\r\n\r\nexport function Autor$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Autor\\u0027\", [], Autor$0027, () => [[\"Name\", string_type], [\"Nachname\", string_type], [\"Vorname\", string_type], [\"Vortragender\", bool_type], [\"FirmenIndex\", list_type(int32_type)]]);\r\n}\r\n\r\nexport class Firma$0027 extends Record {\r\n    constructor(Name, Land) {\r\n        super();\r\n        this.Name = Name;\r\n        this.Land = Land;\r\n    }\r\n}\r\n\r\nexport function Firma$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Firma\\u0027\", [], Firma$0027, () => [[\"Name\", string_type], [\"Land\", string_type]]);\r\n}\r\n\r\nexport class Sitzungsleiter$0027 extends Record {\r\n    constructor(AnzeigeName, Vorname, Nachname) {\r\n        super();\r\n        this.AnzeigeName = AnzeigeName;\r\n        this.Vorname = Vorname;\r\n        this.Nachname = Nachname;\r\n    }\r\n}\r\n\r\nexport function Sitzungsleiter$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Sitzungsleiter\\u0027\", [], Sitzungsleiter$0027, () => [[\"AnzeigeName\", string_type], [\"Vorname\", string_type], [\"Nachname\", string_type]]);\r\n}\r\n\r\nexport class Raum$0027 extends Record {\r\n    constructor(Id, Raum) {\r\n        super();\r\n        this.Id = Id;\r\n        this.Raum = Raum;\r\n    }\r\n}\r\n\r\nexport function Raum$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Raum\\u0027\", [], Raum$0027, () => [[\"Id\", class_type(\"System.Guid\")], [\"Raum\", string_type]]);\r\n}\r\n\r\nexport class Beitrag$0027 extends Record {\r\n    constructor(Id, Uhrzeit, Zeiten, SessionNr, Dauer, Vortragsnummer, Kurzfassung, Titel, Autoren, Firmen, Abgesagt) {\r\n        super();\r\n        this.Id = Id;\r\n        this.Uhrzeit = Uhrzeit;\r\n        this.Zeiten = Zeiten;\r\n        this.SessionNr = SessionNr;\r\n        this.Dauer = (Dauer | 0);\r\n        this.Vortragsnummer = Vortragsnummer;\r\n        this.Kurzfassung = Kurzfassung;\r\n        this.Titel = Titel;\r\n        this.Autoren = Autoren;\r\n        this.Firmen = Firmen;\r\n        this.Abgesagt = Abgesagt;\r\n    }\r\n}\r\n\r\nexport function Beitrag$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Beitrag\\u0027\", [], Beitrag$0027, () => [[\"Id\", string_type], [\"Uhrzeit\", string_type], [\"Zeiten\", list_type(string_type)], [\"SessionNr\", option_type(string_type)], [\"Dauer\", int32_type], [\"Vortragsnummer\", string_type], [\"Kurzfassung\", string_type], [\"Titel\", string_type], [\"Autoren\", list_type(Autor$0027$reflection())], [\"Firmen\", list_type(Firma$0027$reflection())], [\"Abgesagt\", bool_type]]);\r\n}\r\n\r\nexport class Session$0027 extends Record {\r\n    constructor(Id, Bezeichnung, Beschreibung, K$00FCrzel, Vortragsk$00FCrzel, Startzeit, Startzeiten, Sitzungsleiter, AndererRaum) {\r\n        super();\r\n        this.Id = Id;\r\n        this.Bezeichnung = Bezeichnung;\r\n        this.Beschreibung = Beschreibung;\r\n        this[\"Kürzel\"] = K$00FCrzel;\r\n        this[\"Vortragskürzel\"] = Vortragsk$00FCrzel;\r\n        this.Startzeit = Startzeit;\r\n        this.Startzeiten = Startzeiten;\r\n        this.Sitzungsleiter = Sitzungsleiter;\r\n        this.AndererRaum = AndererRaum;\r\n    }\r\n}\r\n\r\nexport function Session$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Session\\u0027\", [], Session$0027, () => [[\"Id\", class_type(\"System.Guid\")], [\"Bezeichnung\", string_type], [\"Beschreibung\", string_type], [\"Kürzel\", option_type(string_type)], [\"Vortragskürzel\", string_type], [\"Startzeit\", string_type], [\"Startzeiten\", list_type(string_type)], [\"Sitzungsleiter\", list_type(Sitzungsleiter$0027$reflection())], [\"AndererRaum\", option_type(string_type)]]);\r\n}\r\n\r\nexport class Programm$0027 extends Record {\r\n    constructor(Startzeit, Startzeiten, K$00FCrzel, Beschreibung, Bezeichnung, AndererRaum) {\r\n        super();\r\n        this.Startzeit = Startzeit;\r\n        this.Startzeiten = Startzeiten;\r\n        this[\"Kürzel\"] = K$00FCrzel;\r\n        this.Beschreibung = Beschreibung;\r\n        this.Bezeichnung = Bezeichnung;\r\n        this.AndererRaum = AndererRaum;\r\n    }\r\n}\r\n\r\nexport function Programm$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Programm\\u0027\", [], Programm$0027, () => [[\"Startzeit\", string_type], [\"Startzeiten\", list_type(string_type)], [\"Kürzel\", option_type(string_type)], [\"Beschreibung\", string_type], [\"Bezeichnung\", string_type], [\"AndererRaum\", option_type(string_type)]]);\r\n}\r\n\r\nexport class Termin extends Record {\r\n    constructor(Id, SessionId, Name, Start, End, Description, Location, Url, WriteProtected) {\r\n        super();\r\n        this.Id = Id;\r\n        this.SessionId = SessionId;\r\n        this.Name = Name;\r\n        this.Start = Start;\r\n        this.End = End;\r\n        this.Description = Description;\r\n        this.Location = Location;\r\n        this.Url = Url;\r\n        this.WriteProtected = WriteProtected;\r\n    }\r\n}\r\n\r\nexport function Termin$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Termin\", [], Termin, () => [[\"Id\", string_type], [\"SessionId\", string_type], [\"Name\", string_type], [\"Start\", string_type], [\"End\", string_type], [\"Description\", string_type], [\"Location\", string_type], [\"Url\", string_type], [\"WriteProtected\", bool_type]]);\r\n}\r\n\r\nexport class Rahmenprogramm$0027 extends Record {\r\n    constructor(Zeit, Startdatum, Enddatum, Beschreibung, Bezeichnung, Raum) {\r\n        super();\r\n        this.Zeit = Zeit;\r\n        this.Startdatum = Startdatum;\r\n        this.Enddatum = Enddatum;\r\n        this.Beschreibung = Beschreibung;\r\n        this.Bezeichnung = Bezeichnung;\r\n        this.Raum = Raum;\r\n    }\r\n}\r\n\r\nexport function Rahmenprogramm$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Rahmenprogramm\\u0027\", [], Rahmenprogramm$0027, () => [[\"Zeit\", string_type], [\"Startdatum\", string_type], [\"Enddatum\", string_type], [\"Beschreibung\", string_type], [\"Bezeichnung\", string_type], [\"Raum\", string_type]]);\r\n}\r\n\r\nexport class Programmpunkt$0027 extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Programm\", \"Session\"];\r\n    }\r\n}\r\n\r\nexport function Programmpunkt$0027$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Domain.Programmpunkt\\u0027\", [], Programmpunkt$0027, () => [[[\"Item\", Programm$0027$reflection()]], [[\"Item\", Session$0027$reflection()]]]);\r\n}\r\n\r\nexport class Achse$0027 extends Record {\r\n    constructor(Startzeit, Datum, Pause, Programmpunkte) {\r\n        super();\r\n        this.Startzeit = Startzeit;\r\n        this.Datum = Datum;\r\n        this.Pause = Pause;\r\n        this.Programmpunkte = Programmpunkte;\r\n    }\r\n}\r\n\r\nexport function Achse$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Achse\\u0027\", [], Achse$0027, () => [[\"Startzeit\", string_type], [\"Datum\", string_type], [\"Pause\", option_type(string_type)], [\"Programmpunkte\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [class_type(\"System.Guid\"), Programmpunkt$0027$reflection()])]]);\r\n}\r\n\r\nexport class Tag$0027 extends Record {\r\n    constructor(Datum, Wochentag, R$00E4ume, Achsen) {\r\n        super();\r\n        this.Datum = Datum;\r\n        this.Wochentag = (Wochentag | 0);\r\n        this[\"Räume\"] = R$00E4ume;\r\n        this.Achsen = Achsen;\r\n    }\r\n}\r\n\r\nexport function Tag$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Tag\\u0027\", [], Tag$0027, () => [[\"Datum\", string_type], [\"Wochentag\", int32_type], [\"Räume\", list_type(Raum$0027$reflection())], [\"Achsen\", list_type(Achse$0027$reflection())]]);\r\n}\r\n\r\nexport class Klassifizierung$0027 extends Record {\r\n    constructor(Id, Bezeichnung) {\r\n        super();\r\n        this.Id = Id;\r\n        this.Bezeichnung = Bezeichnung;\r\n    }\r\n}\r\n\r\nexport function Klassifizierung$0027$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Klassifizierung\\u0027\", [], Klassifizierung$0027, () => [[\"Id\", class_type(\"System.Guid\")], [\"Bezeichnung\", string_type]]);\r\n}\r\n\r\nexport class ManuskriptArt extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Manuskript\", \"Folien\", \"Poster\"];\r\n    }\r\n}\r\n\r\nexport function ManuskriptArt$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Domain.ManuskriptArt\", [], ManuskriptArt, () => [[], [], []]);\r\n}\r\n\r\nexport class Manuskript extends Record {\r\n    constructor(Pnr, Url, Art) {\r\n        super();\r\n        this.Pnr = Pnr;\r\n        this.Url = Url;\r\n        this.Art = Art;\r\n    }\r\n}\r\n\r\nexport function Manuskript$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Domain.Manuskript\", [], Manuskript, () => [[\"Pnr\", string_type], [\"Url\", string_type], [\"Art\", ManuskriptArt$reflection()]]);\r\n}\r\n\r\n","import { Record, Union } from \"../client/.fable/fable-library.3.1.4/Types.js\";\r\nimport { tuple_type, list_type, class_type, record_type, option_type, string_type, int32_type, union_type, bool_type } from \"../client/.fable/fable-library.3.1.4/Reflection.js\";\r\nimport { Manuskript$reflection, Beitrag$0027$reflection, Rahmenprogramm$0027$reflection, Tag$0027$reflection, Termin$reflection } from \"../client/Domain.fs.js\";\r\n\r\nexport class ZeitenInOrtszeit extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"ZeitenInOrtszeit\"];\r\n    }\r\n}\r\n\r\nexport function ZeitenInOrtszeit$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Api.ZeitenInOrtszeit\", [], ZeitenInOrtszeit, () => [[[\"Item\", bool_type]]]);\r\n}\r\n\r\nexport class Config extends Record {\r\n    constructor(PortalId, TagungsId, Teilnehmer, ProfileUrl, Sprache, InOrtsZeitAnzeigen, EigenesProgramm) {\r\n        super();\r\n        this.PortalId = (PortalId | 0);\r\n        this.TagungsId = TagungsId;\r\n        this.Teilnehmer = Teilnehmer;\r\n        this.ProfileUrl = ProfileUrl;\r\n        this.Sprache = Sprache;\r\n        this.InOrtsZeitAnzeigen = InOrtsZeitAnzeigen;\r\n        this.EigenesProgramm = EigenesProgramm;\r\n    }\r\n}\r\n\r\nexport function Config$reflection() {\r\n    return record_type(\"TagungsProgramm.Shared.Api.Config\", [], Config, () => [[\"PortalId\", int32_type], [\"TagungsId\", string_type], [\"Teilnehmer\", option_type(string_type)], [\"ProfileUrl\", option_type(string_type)], [\"Sprache\", string_type], [\"InOrtsZeitAnzeigen\", bool_type], [\"EigenesProgramm\", bool_type]]);\r\n}\r\n\r\nexport class Url extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Url\"];\r\n    }\r\n}\r\n\r\nexport function Url$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Api.Url\", [], Url, () => [[[\"Item\", string_type]]]);\r\n}\r\n\r\nexport class Command extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Subscribe\", \"Unsubscribe\"];\r\n    }\r\n}\r\n\r\nexport function Command$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Api.Command\", [], Command, () => [[[\"Item\", Termin$reflection()]], [[\"Item\", Termin$reflection()]]]);\r\n}\r\n\r\nexport class Query extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Konferenz\", \"Poster\", \"TabSessions\", \"Beiträge\", \"Rahmenprogramm\", \"Manuskripte\", \"Termine\"];\r\n    }\r\n}\r\n\r\nexport function Query$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Api.Query\", [], Query, () => [[], [], [], [[\"Item1\", class_type(\"System.Guid\")], [\"Item2\", string_type]], [], [], []]);\r\n}\r\n\r\nexport class Result extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Konferenz\", \"Rahmenprogramm\", \"Beiträge\", \"Poster\", \"TabSessions\", \"Manuskripte\", \"Termine\"];\r\n    }\r\n}\r\n\r\nexport function Result$reflection() {\r\n    return union_type(\"TagungsProgramm.Shared.Api.Result\", [], Result, () => [[[\"Item1\", list_type(Tag$0027$reflection())], [\"Item2\", string_type], [\"Item3\", ZeitenInOrtszeit$reflection()]], [[\"Item\", list_type(Rahmenprogramm$0027$reflection())]], [[\"Item1\", class_type(\"System.Guid\")], [\"Item2\", list_type(Beitrag$0027$reflection())]], [[\"Item\", list_type(tuple_type(string_type, list_type(Beitrag$0027$reflection())))]], [[\"Item\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, list_type(tuple_type(string_type, list_type(Beitrag$0027$reflection())))])]], [[\"Item\", list_type(Manuskript$reflection())]], [[\"Item1\", list_type(Termin$reflection())], [\"Item2\", bool_type], [\"Item3\", Url$reflection()], [\"Item4\", bool_type]]]);\r\n}\r\n\r\n","import { Result_MapError, Result_Map, FSharpResult$2 } from \"../fable-library.3.1.4/Choice.js\";\r\nimport { class_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { getEnumerator } from \"../fable-library.3.1.4/Seq.js\";\r\n\r\nexport function tap(fn, a) {\r\n    return a.then(((x) => {\r\n        fn(x);\r\n        return x;\r\n    }));\r\n}\r\n\r\nexport function result(a) {\r\n    return a.then(((arg0) => (new FSharpResult$2(0, arg0)))).catch(((arg0_1) => (new FSharpResult$2(1, arg0_1))));\r\n}\r\n\r\nexport function mapResult(fn, a) {\r\n    return a.then(((result_1) => Result_Map(fn, result_1)));\r\n}\r\n\r\nexport function bindResult(fn, a) {\r\n    return a.then(((a_1) => {\r\n        if (a_1.tag === 1) {\r\n            return Promise.resolve((new FSharpResult$2(1, a_1.fields[0])));\r\n        }\r\n        else {\r\n            const pr = fn(a_1.fields[0]);\r\n            return pr.then(((arg0) => (new FSharpResult$2(0, arg0))));\r\n        }\r\n    }));\r\n}\r\n\r\nexport function mapResultError(fn, a) {\r\n    return a.then(((result_1) => Result_MapError(fn, result_1)));\r\n}\r\n\r\nexport class PromiseBuilder {\r\n    constructor() {\r\n    }\r\n}\r\n\r\nexport function PromiseBuilder$reflection() {\r\n    return class_type(\"Promise.PromiseBuilder\", void 0, PromiseBuilder);\r\n}\r\n\r\nexport function PromiseBuilder_$ctor() {\r\n    return new PromiseBuilder();\r\n}\r\n\r\nexport function PromiseBuilder__For_1565554B(_, seq, body) {\r\n    let p = Promise.resolve(undefined);\r\n    const enumerator = getEnumerator(seq);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const a = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            const pr = p;\r\n            p = (pr.then((() => body(a))));\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return p;\r\n}\r\n\r\nexport function PromiseBuilder__While_2044D34(this$, guard, p) {\r\n    if (guard()) {\r\n        return p.then((() => PromiseBuilder__While_2044D34(this$, guard, p)));\r\n    }\r\n    else {\r\n        return Promise.resolve(undefined);\r\n    }\r\n}\r\n\r\nexport function PromiseBuilder__TryFinally_7D49A2FD(_, p, compensation) {\r\n    return p.then(((x) => {\r\n        compensation();\r\n        return x;\r\n    })).catch(((er) => {\r\n        compensation();\r\n        throw er;\r\n    }));\r\n}\r\n\r\nexport function PromiseBuilder__Delay_62FBFDE1(_, generator) {\r\n    return {\r\n        then: (onSuccess, onError) => {\r\n            try {\r\n                return generator().then(onSuccess, onError);\r\n            }\r\n            catch (er) {\r\n                if (onError == null) {\r\n                    return Promise.reject(er);\r\n                }\r\n                else {\r\n                    try {\r\n                        const a = onError(er);\r\n                        return Promise.resolve(a);\r\n                    }\r\n                    catch (er_1) {\r\n                        return Promise.reject(er_1);\r\n                    }\r\n                }\r\n            }\r\n        },\r\n        catch: (onError_1) => {\r\n            try {\r\n                return generator().catch(onError_1);\r\n            }\r\n            catch (er_2) {\r\n                try {\r\n                    const a_1 = onError_1(er_2);\r\n                    return Promise.resolve(a_1);\r\n                }\r\n                catch (er_3) {\r\n                    return Promise.reject(er_3);\r\n                }\r\n            }\r\n        },\r\n    };\r\n}\r\n\r\nexport function PromiseBuilder__Run_212F1D4B(_, p) {\r\n    return p.then((x) => x);\r\n}\r\n\r\nexport function PromiseBuilder__Using_74F7E79D(this$, resource, binder) {\r\n    return PromiseBuilder__TryFinally_7D49A2FD(this$, binder(resource), () => {\r\n        let copyOfStruct = resource;\r\n        copyOfStruct.Dispose();\r\n    });\r\n}\r\n\r\n","import { Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { bool_type, class_type, union_type, obj_type, int32_type, string_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { int32ToString } from \"../fable-library.3.1.4/Util.js\";\r\nimport { keyValueList } from \"../fable-library.3.1.4/MapUtil.js\";\r\nimport { result } from \"../Fable.Promise.3.1.3/Promise.fs.js\";\r\nimport { singleton } from \"../fable-library.3.1.4/List.js\";\r\n\r\nexport class Types_HttpRequestHeaders extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Accept\", \"Accept-Charset\", \"Accept-Encoding\", \"Accept-Language\", \"Accept-Datetime\", \"Authorization\", \"Cache-Control\", \"Connection\", \"Cookie\", \"Content-Length\", \"Content-MD5\", \"Content-Type\", \"Date\", \"Expect\", \"Forwarded\", \"From\", \"Host\", \"If-Match\", \"If-Modified-Since\", \"If-None-Match\", \"If-Range\", \"If-Unmodified-Since\", \"Max-Forwards\", \"Origin\", \"Pragma\", \"Proxy-Authorization\", \"Range\", \"Referer\", \"SOAPAction\", \"TE\", \"User-Agent\", \"Upgrade\", \"Via\", \"Warning\", \"X-Requested-With\", \"DNT\", \"X-Forwarded-For\", \"X-Forwarded-Host\", \"X-Forwarded-Proto\", \"Front-End-Https\", \"X-Http-Method-Override\", \"X-ATT-DeviceId\", \"X-Wap-Profile\", \"Proxy-Connection\", \"X-UIDH\", \"X-Csrf-Token\", \"Custom\"];\r\n    }\r\n}\r\n\r\nexport function Types_HttpRequestHeaders$reflection() {\r\n    return union_type(\"Fetch.Types.HttpRequestHeaders\", [], Types_HttpRequestHeaders, () => [[[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"key\", string_type], [\"value\", obj_type]]]);\r\n}\r\n\r\nexport class Types_RequestProperties extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Method\", \"Headers\", \"Body\", \"Mode\", \"Credentials\", \"Cache\", \"Redirect\", \"Referrer\", \"ReferrerPolicy\", \"Integrity\", \"KeepAlive\", \"Signal\"];\r\n    }\r\n}\r\n\r\nexport function Types_RequestProperties$reflection() {\r\n    return union_type(\"Fetch.Types.RequestProperties\", [], Types_RequestProperties, () => [[[\"Item\", string_type]], [[\"Item\", class_type(\"Fetch.Types.IHttpRequestHeaders\")]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", class_type(\"Fetch.Types.AbortSignal\")]]]);\r\n}\r\n\r\nfunction errorString(response) {\r\n    return (((int32ToString(response.status) + \" \") + (response.statusText)) + \" for URL \") + (response.url);\r\n}\r\n\r\nexport function fetch$(url, init) {\r\n    const pr = fetch(url, keyValueList(init, 1));\r\n    return pr.then(((response) => {\r\n        if (response.ok) {\r\n            return response;\r\n        }\r\n        else {\r\n            const message = errorString(response);\r\n            throw (new Error(message));\r\n        }\r\n    }));\r\n}\r\n\r\nexport function fetchUnsafe(url, init) {\r\n    return fetch(url, keyValueList(init, 1));\r\n}\r\n\r\nexport function tryFetch(url, init) {\r\n    return result(fetch$(url, init));\r\n}\r\n\r\nexport function tryOptionsRequest(url) {\r\n    return result(fetch$(url, singleton(new Types_RequestProperties(0, \"OPTIONS\"))));\r\n}\r\n\r\n","import { List, Record } from \"../Types.js\";\nimport { record_type, array_type, int32_type } from \"../Reflection.js\";\nimport { op_LeftShift, op_BitwiseAnd, op_Addition, compare, op_Subtraction, op_Division, equals, fromInteger, op_Multiply, op_Modulus, toInt, fromBits } from \"../Long.js\";\nimport { copy, initialize, map, fill } from \"../Array.js\";\nimport { int32ToString } from \"../Util.js\";\nimport { isNullOrEmpty, join } from \"../String.js\";\n\nexport class BigNat extends Record {\n    constructor(bound, digits) {\n        super();\n        this.bound = (bound | 0);\n        this.digits = digits;\n    }\n}\n\nexport function BigNat$reflection() {\n    return record_type(\"BigInt.BigNat\", [], BigNat, () => [[\"bound\", int32_type], [\"digits\", array_type(int32_type)]]);\n}\n\nexport function BigNatModule_FFT_pow32(x_mut, n_mut) {\n    BigNatModule_FFT_pow32:\n    while (true) {\n        const x = x_mut, n = n_mut;\n        if (n === 0) {\n            return 1;\n        }\n        else if ((n % 2) === 0) {\n            x_mut = (x * x);\n            n_mut = (~(~(n / 2)));\n            continue BigNatModule_FFT_pow32;\n        }\n        else {\n            return (x * BigNatModule_FFT_pow32(x * x, ~(~(n / 2)))) | 0;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_FFT_leastBounding2Power(b) {\n    const findBounding2Power = (b_1_mut, tp_mut, i_mut) => {\n        findBounding2Power:\n        while (true) {\n            const b_1 = b_1_mut, tp = tp_mut, i = i_mut;\n            if (b_1 <= tp) {\n                return [tp, i];\n            }\n            else {\n                b_1_mut = b_1;\n                tp_mut = (tp * 2);\n                i_mut = (i + 1);\n                continue findBounding2Power;\n            }\n            break;\n        }\n    };\n    return findBounding2Power(b, 1, 0);\n}\n\nexport const BigNatModule_FFT_p = fromBits(2013265921, 0, false);\n\nconst BigNatModule_FFT_patternInput$004075 = [27, 15, 31, 440564289];\n\nexport const BigNatModule_FFT_w = BigNatModule_FFT_patternInput$004075[3];\n\nexport const BigNatModule_FFT_m = BigNatModule_FFT_patternInput$004075[1];\n\nexport const BigNatModule_FFT_k = BigNatModule_FFT_patternInput$004075[0];\n\nexport const BigNatModule_FFT_g = BigNatModule_FFT_patternInput$004075[2];\n\nexport const BigNatModule_FFT_primeP = BigNatModule_FFT_p;\n\nexport const BigNatModule_FFT_maxBitsInsideFp = 30;\n\nexport const BigNatModule_FFT_Fp_p = 2013265921;\n\nexport const BigNatModule_FFT_Fp_p64 = fromBits(2013265921, 0, true);\n\nexport function BigNatModule_FFT_Fp_toInt(x) {\n    return ~(~x);\n}\n\nexport function BigNatModule_FFT_Fp_ofInt32(x) {\n    return x >>> 0;\n}\n\nexport const BigNatModule_FFT_Fp_mzero = 0;\n\nexport const BigNatModule_FFT_Fp_mone = 1;\n\nexport const BigNatModule_FFT_Fp_mtwo = 2;\n\nexport function BigNatModule_FFT_Fp_mpow(x_mut, n_mut) {\n    BigNatModule_FFT_Fp_mpow:\n    while (true) {\n        const x = x_mut, n = n_mut;\n        if (n === 0) {\n            return BigNatModule_FFT_Fp_mone;\n        }\n        else if ((n % 2) === 0) {\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\n            n_mut = (~(~(n / 2)));\n            continue BigNatModule_FFT_Fp_mpow;\n        }\n        else {\n            const y_2 = BigNatModule_FFT_Fp_mpow(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, ~(~(n / 2)));\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_FFT_Fp_mpowL(x_mut, n_mut) {\n    BigNatModule_FFT_Fp_mpowL:\n    while (true) {\n        const x = x_mut, n = n_mut;\n        if (equals(n, fromBits(0, 0, false))) {\n            return BigNatModule_FFT_Fp_mone;\n        }\n        else if (equals(op_Modulus(n, fromBits(2, 0, false)), fromBits(0, 0, false))) {\n            x_mut = (toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\n            n_mut = op_Division(n, fromBits(2, 0, false));\n            continue BigNatModule_FFT_Fp_mpowL;\n        }\n        else {\n            const y_2 = BigNatModule_FFT_Fp_mpowL(toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(x, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0, op_Division(n, fromBits(2, 0, false)));\n            return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y_2, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_FFT_Fp_m2PowNthRoot(n) {\n    return BigNatModule_FFT_Fp_mpow(BigNatModule_FFT_w >>> 0, BigNatModule_FFT_pow32(2, BigNatModule_FFT_k - n));\n}\n\nexport function BigNatModule_FFT_Fp_minv(x) {\n    return BigNatModule_FFT_Fp_mpowL(x, op_Subtraction(BigNatModule_FFT_primeP, fromBits(2, 0, false)));\n}\n\nexport function BigNatModule_FFT_computeFFT(lambda, mu, n, w, u, res, offset) {\n    let x_1, x_3;\n    if (n === 1) {\n        res[offset] = u[mu];\n    }\n    else {\n        const halfN = (~(~(n / 2))) | 0;\n        const ww = toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(w, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\n        const offsetHalfN = (offset + halfN) | 0;\n        BigNatModule_FFT_computeFFT(lambda * 2, mu, halfN, ww, u, res, offset);\n        BigNatModule_FFT_computeFFT(lambda * 2, lambda + mu, halfN, ww, u, res, offsetHalfN);\n        let wj = BigNatModule_FFT_Fp_mone;\n        for (let j = 0; j <= (halfN - 1); j++) {\n            const even = res[offset + j];\n            const odd = res[offsetHalfN + j];\n            res[offset + j] = ((even + (x_1 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_1, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0)) % BigNatModule_FFT_Fp_p);\n            res[offsetHalfN + j] = (((even + BigNatModule_FFT_Fp_p) - (x_3 = wj, toInt(op_Modulus(op_Multiply(fromInteger(x_3, true, 6), fromInteger(odd, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0)) % BigNatModule_FFT_Fp_p);\n            const y_5 = wj;\n            wj = (toInt(op_Modulus(op_Multiply(fromInteger(w, true, 6), fromInteger(y_5, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0);\n        }\n    }\n}\n\nexport function BigNatModule_FFT_computFftInPlace(n, w, u) {\n    const res = fill(new Uint32Array(n), 0, n, BigNatModule_FFT_Fp_mzero);\n    BigNatModule_FFT_computeFFT(1, 0, n, w, u, res, 0);\n    return res;\n}\n\nexport function BigNatModule_FFT_computeInverseFftInPlace(n, w, uT) {\n    const bigKInv = BigNatModule_FFT_Fp_minv(n >>> 0);\n    return map((y) => (toInt(op_Modulus(op_Multiply(fromInteger(bigKInv, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0), BigNatModule_FFT_computFftInPlace(n, BigNatModule_FFT_Fp_minv(w), uT), Uint32Array);\n}\n\nexport const BigNatModule_FFT_maxTwoPower = 29;\n\nexport const BigNatModule_FFT_twoPowerTable = initialize(BigNatModule_FFT_maxTwoPower - 1, (i) => BigNatModule_FFT_pow32(2, i), Int32Array);\n\nexport function BigNatModule_FFT_computeFftPaddedPolynomialProduct(bigK, k, u, v) {\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(k);\n    const n = bigK | 0;\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u);\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v);\n    return BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\n        const x = uT[i];\n        const y = vT[i];\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\n    }, Uint32Array));\n}\n\nexport function BigNatModule_FFT_padTo(n, u) {\n    const uBound = u.length | 0;\n    return initialize(n, (i) => ((i < uBound) ? BigNatModule_FFT_Fp_ofInt32(u[i]) : BigNatModule_FFT_Fp_mzero), Uint32Array);\n}\n\nexport function BigNatModule_FFT_computeFftPolynomialProduct(degu, u, degv, v) {\n    const patternInput = BigNatModule_FFT_leastBounding2Power((degu + degv) + 1);\n    const bigK = patternInput[0] | 0;\n    const w = BigNatModule_FFT_Fp_m2PowNthRoot(patternInput[1]);\n    const u_1 = BigNatModule_FFT_padTo(bigK, u);\n    const v_1 = BigNatModule_FFT_padTo(bigK, v);\n    const n = bigK | 0;\n    const uT = BigNatModule_FFT_computFftInPlace(n, w, u_1);\n    const vT = BigNatModule_FFT_computFftInPlace(n, w, v_1);\n    return map((x_1) => BigNatModule_FFT_Fp_toInt(x_1), BigNatModule_FFT_computeInverseFftInPlace(n, w, initialize(n, (i) => {\n        const x = uT[i];\n        const y = vT[i];\n        return toInt(op_Modulus(op_Multiply(fromInteger(x, true, 6), fromInteger(y, true, 6)), BigNatModule_FFT_Fp_p64)) >>> 0;\n    }, Uint32Array)), Int32Array);\n}\n\nexport const BigNatModule_FFT_mzero = BigNatModule_FFT_Fp_mzero;\n\nexport const BigNatModule_FFT_mone = BigNatModule_FFT_Fp_mone;\n\nexport const BigNatModule_FFT_maxFp = ((BigNatModule_FFT_Fp_p + BigNatModule_FFT_Fp_p) - BigNatModule_FFT_mone) % BigNatModule_FFT_Fp_p;\n\nexport function BigNatModule_bound(n) {\n    return n.bound;\n}\n\nexport function BigNatModule_setBound(n, v) {\n    n.bound = v;\n}\n\nexport function BigNatModule_coeff(n, i) {\n    return n.digits[i];\n}\n\nexport function BigNatModule_coeff64(n, i) {\n    return fromInteger(BigNatModule_coeff(n, i), false, 2);\n}\n\nexport function BigNatModule_setCoeff(n, i, v) {\n    n.digits[i] = v;\n}\n\nexport function BigNatModule_pow64(x_mut, n_mut) {\n    BigNatModule_pow64:\n    while (true) {\n        const x = x_mut, n = n_mut;\n        if (n === 0) {\n            return fromBits(1, 0, false);\n        }\n        else if ((n % 2) === 0) {\n            x_mut = op_Multiply(x, x);\n            n_mut = (~(~(n / 2)));\n            continue BigNatModule_pow64;\n        }\n        else {\n            return op_Multiply(x, BigNatModule_pow64(op_Multiply(x, x), ~(~(n / 2))));\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_pow32(x_mut, n_mut) {\n    BigNatModule_pow32:\n    while (true) {\n        const x = x_mut, n = n_mut;\n        if (n === 0) {\n            return 1;\n        }\n        else if ((n % 2) === 0) {\n            x_mut = (x * x);\n            n_mut = (~(~(n / 2)));\n            continue BigNatModule_pow32;\n        }\n        else {\n            return (x * BigNatModule_pow32(x * x, ~(~(n / 2)))) | 0;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_hash(n) {\n    let res = 0;\n    for (let i = 0; i <= (n.bound - 1); i++) {\n        res = (n.digits[i] + (res << 3));\n    }\n    return res | 0;\n}\n\nexport function BigNatModule_maxInt(a, b) {\n    if (a < b) {\n        return b | 0;\n    }\n    else {\n        return a | 0;\n    }\n}\n\nexport function BigNatModule_minInt(a, b) {\n    if (a < b) {\n        return a | 0;\n    }\n    else {\n        return b | 0;\n    }\n}\n\nexport const BigNatModule_baseBits = 24;\n\nexport const BigNatModule_baseN = 16777216;\n\nexport const BigNatModule_baseMask = 16777215;\n\nexport const BigNatModule_baseNi64 = fromBits(16777216, 0, false);\n\nexport const BigNatModule_baseMaski64 = fromBits(16777215, 0, false);\n\nexport const BigNatModule_baseMaskU = fromBits(16777215, 0, true);\n\nexport const BigNatModule_baseMask32A = 16777215;\n\nexport const BigNatModule_baseMask32B = 255;\n\nexport const BigNatModule_baseShift32B = 24;\n\nexport const BigNatModule_baseMask64A = 16777215;\n\nexport const BigNatModule_baseMask64B = 16777215;\n\nexport const BigNatModule_baseMask64C = 65535;\n\nexport const BigNatModule_baseShift64B = 24;\n\nexport const BigNatModule_baseShift64C = 48;\n\nexport function BigNatModule_divbase(x) {\n    return ~(~((x >>> 0) >>> BigNatModule_baseBits));\n}\n\nexport function BigNatModule_modbase(x) {\n    return x & BigNatModule_baseMask;\n}\n\nexport function BigNatModule_createN(b) {\n    return new BigNat(b, new Int32Array(b));\n}\n\nexport function BigNatModule_copyN(x) {\n    return new BigNat(x.bound, copy(x.digits));\n}\n\nexport function BigNatModule_normN(n) {\n    const findLeastBound = (na_mut, i_mut) => {\n        findLeastBound:\n        while (true) {\n            const na = na_mut, i = i_mut;\n            if ((i === -1) ? true : (na[i] !== 0)) {\n                return (i + 1) | 0;\n            }\n            else {\n                na_mut = na;\n                i_mut = (i - 1);\n                continue findLeastBound;\n            }\n            break;\n        }\n    };\n    const bound = findLeastBound(n.digits, n.bound - 1) | 0;\n    n.bound = bound;\n    return n;\n}\n\nexport const BigNatModule_boundInt = 2;\n\nexport const BigNatModule_boundInt64 = 3;\n\nexport const BigNatModule_boundBase = 1;\n\nexport function BigNatModule_embed(x) {\n    const x_1 = ((x < 0) ? 0 : x) | 0;\n    if (x_1 < BigNatModule_baseN) {\n        const r = BigNatModule_createN(1);\n        r.digits[0] = x_1;\n        return BigNatModule_normN(r);\n    }\n    else {\n        const r_1 = BigNatModule_createN(BigNatModule_boundInt);\n        for (let i = 0; i <= (BigNatModule_boundInt - 1); i++) {\n            r_1.digits[i] = ((~(~(x_1 / BigNatModule_pow32(BigNatModule_baseN, i)))) % BigNatModule_baseN);\n        }\n        return BigNatModule_normN(r_1);\n    }\n}\n\nexport function BigNatModule_embed64(x) {\n    const x_1 = (compare(x, fromBits(0, 0, false)) < 0) ? fromBits(0, 0, false) : x;\n    const r = BigNatModule_createN(BigNatModule_boundInt64);\n    for (let i = 0; i <= (BigNatModule_boundInt64 - 1); i++) {\n        r.digits[i] = (~(~toInt(op_Modulus(op_Division(x_1, BigNatModule_pow64(BigNatModule_baseNi64, i)), BigNatModule_baseNi64))));\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_eval32(n) {\n    if (n.bound === 1) {\n        return n.digits[0] | 0;\n    }\n    else {\n        let acc = 0;\n        for (let i = n.bound - 1; i >= 0; i--) {\n            acc = (n.digits[i] + (BigNatModule_baseN * acc));\n        }\n        return acc | 0;\n    }\n}\n\nexport function BigNatModule_eval64(n) {\n    if (n.bound === 1) {\n        return fromInteger(n.digits[0], false, 2);\n    }\n    else {\n        let acc = fromBits(0, 0, false);\n        for (let i = n.bound - 1; i >= 0; i--) {\n            acc = op_Addition(fromInteger(n.digits[i], false, 2), op_Multiply(BigNatModule_baseNi64, acc));\n        }\n        return acc;\n    }\n}\n\nexport const BigNatModule_one = BigNatModule_embed(1);\n\nexport const BigNatModule_zero = BigNatModule_embed(0);\n\nexport function BigNatModule_restrictTo(d, n) {\n    return new BigNat(BigNatModule_minInt(d, n.bound), n.digits);\n}\n\nexport function BigNatModule_shiftUp(d, n) {\n    const m = BigNatModule_createN(n.bound + d);\n    for (let i = 0; i <= (n.bound - 1); i++) {\n        m.digits[i + d] = n.digits[i];\n    }\n    return m;\n}\n\nexport function BigNatModule_shiftDown(d, n) {\n    if ((n.bound - d) <= 0) {\n        return BigNatModule_zero;\n    }\n    else {\n        const m = BigNatModule_createN(n.bound - d);\n        for (let i = 0; i <= (m.bound - 1); i++) {\n            m.digits[i] = n.digits[i + d];\n        }\n        return m;\n    }\n}\n\nexport function BigNatModule_degree(n) {\n    return n.bound - 1;\n}\n\nexport function BigNatModule_addP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\n    let z, i_1, z_1, i_2;\n    BigNatModule_addP:\n    while (true) {\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\n        if (i < n) {\n            const x = (((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0)) + (z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0))) + c) | 0;\n            r.digits[i] = BigNatModule_modbase(x);\n            i_mut = (i + 1);\n            n_mut = n;\n            c_mut = BigNatModule_divbase(x);\n            p_mut = p;\n            q_mut = q;\n            r_mut = r;\n            continue BigNatModule_addP;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_add(p, q) {\n    const rbound = (1 + BigNatModule_maxInt(p.bound, q.bound)) | 0;\n    const r = BigNatModule_createN(rbound);\n    BigNatModule_addP(0, rbound, 0, p, q, r);\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_subP(i_mut, n_mut, c_mut, p_mut, q_mut, r_mut) {\n    let z, i_1, z_1, i_2;\n    BigNatModule_subP:\n    while (true) {\n        const i = i_mut, n = n_mut, c = c_mut, p = p_mut, q = q_mut, r = r_mut;\n        if (i < n) {\n            const x = (((z = p, (i_1 = (i | 0), (i_1 < z.bound) ? z.digits[i_1] : 0)) - (z_1 = q, (i_2 = (i | 0), (i_2 < z_1.bound) ? z_1.digits[i_2] : 0))) + c) | 0;\n            if (x > 0) {\n                r.digits[i] = BigNatModule_modbase(x);\n                i_mut = (i + 1);\n                n_mut = n;\n                c_mut = BigNatModule_divbase(x);\n                p_mut = p;\n                q_mut = q;\n                r_mut = r;\n                continue BigNatModule_subP;\n            }\n            else {\n                const x_1 = (x + BigNatModule_baseN) | 0;\n                r.digits[i] = BigNatModule_modbase(x_1);\n                i_mut = (i + 1);\n                n_mut = n;\n                c_mut = (BigNatModule_divbase(x_1) - 1);\n                p_mut = p;\n                q_mut = q;\n                r_mut = r;\n                continue BigNatModule_subP;\n            }\n        }\n        else {\n            return c !== 0;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_sub(p, q) {\n    const rbound = BigNatModule_maxInt(p.bound, q.bound) | 0;\n    const r = BigNatModule_createN(rbound);\n    if (BigNatModule_subP(0, rbound, 0, p, q, r)) {\n        return BigNatModule_embed(0);\n    }\n    else {\n        return BigNatModule_normN(r);\n    }\n}\n\nexport function BigNatModule_isZero(p) {\n    return p.bound === 0;\n}\n\nexport function BigNatModule_IsZero(p) {\n    return BigNatModule_isZero(p);\n}\n\nexport function BigNatModule_isOne(p) {\n    if (p.bound === 1) {\n        return p.digits[0] === 1;\n    }\n    else {\n        return false;\n    }\n}\n\nexport function BigNatModule_equal(p, q) {\n    if (p.bound === q.bound) {\n        const check = (pa_mut, qa_mut, i_mut) => {\n            check:\n            while (true) {\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\n                if (i === -1) {\n                    return true;\n                }\n                else if (pa[i] === qa[i]) {\n                    pa_mut = pa;\n                    qa_mut = qa;\n                    i_mut = (i - 1);\n                    continue check;\n                }\n                else {\n                    return false;\n                }\n                break;\n            }\n        };\n        return check(p.digits, q.digits, p.bound - 1);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function BigNatModule_shiftCompare(p, pn, q, qn) {\n    if ((p.bound + pn) < (q.bound + qn)) {\n        return -1;\n    }\n    else if ((p.bound + pn) > (q.bound + pn)) {\n        return 1;\n    }\n    else {\n        const check = (pa_mut, qa_mut, i_mut) => {\n            check:\n            while (true) {\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\n                if (i === -1) {\n                    return 0;\n                }\n                else {\n                    const pai = ((i < pn) ? 0 : pa[i - pn]) | 0;\n                    const qai = ((i < qn) ? 0 : qa[i - qn]) | 0;\n                    if (pai === qai) {\n                        pa_mut = pa;\n                        qa_mut = qa;\n                        i_mut = (i - 1);\n                        continue check;\n                    }\n                    else if (pai < qai) {\n                        return -1;\n                    }\n                    else {\n                        return 1;\n                    }\n                }\n                break;\n            }\n        };\n        return check(p.digits, q.digits, (p.bound + pn) - 1) | 0;\n    }\n}\n\nexport function BigNatModule_compare(p, q) {\n    if (p.bound < q.bound) {\n        return -1;\n    }\n    else if (p.bound > q.bound) {\n        return 1;\n    }\n    else {\n        const check = (pa_mut, qa_mut, i_mut) => {\n            check:\n            while (true) {\n                const pa = pa_mut, qa = qa_mut, i = i_mut;\n                if (i === -1) {\n                    return 0;\n                }\n                else if (pa[i] === qa[i]) {\n                    pa_mut = pa;\n                    qa_mut = qa;\n                    i_mut = (i - 1);\n                    continue check;\n                }\n                else if (pa[i] < qa[i]) {\n                    return -1;\n                }\n                else {\n                    return 1;\n                }\n                break;\n            }\n        };\n        return check(p.digits, q.digits, p.bound - 1) | 0;\n    }\n}\n\nexport function BigNatModule_lt(p, q) {\n    return BigNatModule_compare(p, q) === -1;\n}\n\nexport function BigNatModule_gt(p, q) {\n    return BigNatModule_compare(p, q) === 1;\n}\n\nexport function BigNatModule_lte(p, q) {\n    return BigNatModule_compare(p, q) !== 1;\n}\n\nexport function BigNatModule_gte(p, q) {\n    return BigNatModule_compare(p, q) !== -1;\n}\n\nexport function BigNatModule_min(a, b) {\n    if (BigNatModule_lt(a, b)) {\n        return a;\n    }\n    else {\n        return b;\n    }\n}\n\nexport function BigNatModule_max(a, b) {\n    if (BigNatModule_lt(a, b)) {\n        return b;\n    }\n    else {\n        return a;\n    }\n}\n\nexport function BigNatModule_contributeArr(a_mut, i_mut, c_mut) {\n    BigNatModule_contributeArr:\n    while (true) {\n        const a = a_mut, i = i_mut, c = c_mut;\n        const x = op_Addition(fromInteger(a[i], false, 2), c);\n        const c_1 = op_Division(x, BigNatModule_baseNi64);\n        const x_3 = (~(~toInt(op_BitwiseAnd(x, BigNatModule_baseMaski64)))) | 0;\n        a[i] = x_3;\n        if (compare(c_1, fromBits(0, 0, false)) > 0) {\n            a_mut = a;\n            i_mut = (i + 1);\n            c_mut = c_1;\n            continue BigNatModule_contributeArr;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_scale(k, p) {\n    const r = BigNatModule_createN(p.bound + BigNatModule_boundInt);\n    const k_1 = fromInteger(k, false, 2);\n    for (let i = 0; i <= (p.bound - 1); i++) {\n        BigNatModule_contributeArr(r.digits, i, op_Multiply(k_1, fromInteger(p.digits[i], false, 2)));\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_mulSchoolBookBothSmall(p, q) {\n    const r = BigNatModule_createN(2);\n    const rak = op_Multiply(fromInteger(p, false, 2), fromInteger(q, false, 2));\n    BigNatModule_setCoeff(r, 0, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\n    BigNatModule_setCoeff(r, 1, ~(~toInt(op_Division(rak, BigNatModule_baseNi64))));\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_mulSchoolBookCarry(r_mut, c_mut, k_mut) {\n    BigNatModule_mulSchoolBookCarry:\n    while (true) {\n        const r = r_mut, c = c_mut, k = k_mut;\n        if (compare(c, fromBits(0, 0, false)) > 0) {\n            const rak = op_Addition(BigNatModule_coeff64(r, k), c);\n            BigNatModule_setCoeff(r, k, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\n            r_mut = r;\n            c_mut = op_Division(rak, BigNatModule_baseNi64);\n            k_mut = (k + 1);\n            continue BigNatModule_mulSchoolBookCarry;\n        }\n        break;\n    }\n}\n\nexport function BigNatModule_mulSchoolBookOneSmall(p, q) {\n    const bp = BigNatModule_bound(p) | 0;\n    const r = BigNatModule_createN(bp + 1);\n    const q_1 = fromInteger(q, false, 2);\n    let c = fromBits(0, 0, false);\n    for (let i = 0; i <= (bp - 1); i++) {\n        const rak = op_Addition(op_Addition(c, BigNatModule_coeff64(r, i)), op_Multiply(BigNatModule_coeff64(p, i), q_1));\n        BigNatModule_setCoeff(r, i, ~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\n        c = op_Division(rak, BigNatModule_baseNi64);\n    }\n    BigNatModule_mulSchoolBookCarry(r, c, bp);\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_mulSchoolBookNeitherSmall(p, q) {\n    const r = BigNatModule_createN(p.bound + q.bound);\n    const ra = r.digits;\n    for (let i = 0; i <= (p.bound - 1); i++) {\n        const pai = fromInteger(p.digits[i], false, 2);\n        let c = fromBits(0, 0, false);\n        let k = i | 0;\n        for (let j = 0; j <= (q.bound - 1); j++) {\n            const qaj = fromInteger(q.digits[j], false, 2);\n            const rak = op_Addition(op_Addition(fromInteger(ra[k], false, 2), c), op_Multiply(pai, qaj));\n            ra[k] = (~(~toInt(op_BitwiseAnd(rak, BigNatModule_baseMaski64))));\n            c = op_Division(rak, BigNatModule_baseNi64);\n            k = (k + 1);\n        }\n        BigNatModule_mulSchoolBookCarry(r, c, k);\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_mulSchoolBook(p, q) {\n    const pSmall = BigNatModule_bound(p) === 1;\n    const qSmall = BigNatModule_bound(q) === 1;\n    if (pSmall ? qSmall : false) {\n        return BigNatModule_mulSchoolBookBothSmall(BigNatModule_coeff(p, 0), BigNatModule_coeff(q, 0));\n    }\n    else if (pSmall) {\n        return BigNatModule_mulSchoolBookOneSmall(q, BigNatModule_coeff(p, 0));\n    }\n    else if (qSmall) {\n        return BigNatModule_mulSchoolBookOneSmall(p, BigNatModule_coeff(q, 0));\n    }\n    else {\n        return BigNatModule_mulSchoolBookNeitherSmall(p, q);\n    }\n}\n\nexport class BigNatModule_encoding extends Record {\n    constructor(bigL, twoToBigL, k, bigK, bigN, split, splits) {\n        super();\n        this.bigL = (bigL | 0);\n        this.twoToBigL = (twoToBigL | 0);\n        this.k = (k | 0);\n        this.bigK = (bigK | 0);\n        this.bigN = (bigN | 0);\n        this.split = (split | 0);\n        this.splits = splits;\n    }\n}\n\nexport function BigNatModule_encoding$reflection() {\n    return record_type(\"BigInt.BigNatModule.encoding\", [], BigNatModule_encoding, () => [[\"bigL\", int32_type], [\"twoToBigL\", int32_type], [\"k\", int32_type], [\"bigK\", int32_type], [\"bigN\", int32_type], [\"split\", int32_type], [\"splits\", array_type(int32_type)]]);\n}\n\nexport function BigNatModule_mkEncoding(bigL, k, bigK, bigN) {\n    return new BigNatModule_encoding(bigL, BigNatModule_pow32(2, bigL), k, bigK, bigN, ~(~(BigNatModule_baseBits / bigL)), initialize(~(~(BigNatModule_baseBits / bigL)), (i) => BigNatModule_pow32(2, bigL * i), Int32Array));\n}\n\nexport const BigNatModule_table = [BigNatModule_mkEncoding(1, 28, 268435456, 268435456), BigNatModule_mkEncoding(2, 26, 67108864, 134217728), BigNatModule_mkEncoding(3, 24, 16777216, 50331648), BigNatModule_mkEncoding(4, 22, 4194304, 16777216), BigNatModule_mkEncoding(5, 20, 1048576, 5242880), BigNatModule_mkEncoding(6, 18, 262144, 1572864), BigNatModule_mkEncoding(7, 16, 65536, 458752), BigNatModule_mkEncoding(8, 14, 16384, 131072), BigNatModule_mkEncoding(9, 12, 4096, 36864), BigNatModule_mkEncoding(10, 10, 1024, 10240), BigNatModule_mkEncoding(11, 8, 256, 2816), BigNatModule_mkEncoding(12, 6, 64, 768), BigNatModule_mkEncoding(13, 4, 16, 208)];\n\nexport function BigNatModule_calculateTableTow(bigL) {\n    const k = (BigNatModule_FFT_maxBitsInsideFp - (2 * bigL)) | 0;\n    const bigK = BigNatModule_pow64(fromBits(2, 0, false), k);\n    return [bigL, k, bigK, op_Multiply(bigK, fromInteger(bigL, false, 2))];\n}\n\nexport function BigNatModule_encodingGivenResultBits(bitsRes) {\n    const selectFrom = (i_mut) => {\n        selectFrom:\n        while (true) {\n            const i = i_mut;\n            if (((i + 1) < BigNatModule_table.length) ? (bitsRes < BigNatModule_table[i + 1].bigN) : false) {\n                i_mut = (i + 1);\n                continue selectFrom;\n            }\n            else {\n                return BigNatModule_table[i];\n            }\n            break;\n        }\n    };\n    if (bitsRes >= BigNatModule_table[0].bigN) {\n        throw (new Error(\"Product is huge, around 268435456 bits, beyond quickmul\"));\n    }\n    else {\n        return selectFrom(0);\n    }\n}\n\nexport const BigNatModule_bitmask = initialize(BigNatModule_baseBits, (i) => (BigNatModule_pow32(2, i) - 1), Int32Array);\n\nexport const BigNatModule_twopowers = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow32(2, i), Int32Array);\n\nexport const BigNatModule_twopowersI64 = initialize(BigNatModule_baseBits, (i) => BigNatModule_pow64(fromBits(2, 0, false), i));\n\nexport function BigNatModule_wordBits(word) {\n    const hi = (k_mut) => {\n        hi:\n        while (true) {\n            const k = k_mut;\n            if (k === 0) {\n                return 0;\n            }\n            else if ((word & BigNatModule_twopowers[k - 1]) !== 0) {\n                return k | 0;\n            }\n            else {\n                k_mut = (k - 1);\n                continue hi;\n            }\n            break;\n        }\n    };\n    return hi(BigNatModule_baseBits) | 0;\n}\n\nexport function BigNatModule_bits(u) {\n    if (u.bound === 0) {\n        return 0;\n    }\n    else {\n        return ((BigNatModule_degree(u) * BigNatModule_baseBits) + BigNatModule_wordBits(u.digits[BigNatModule_degree(u)])) | 0;\n    }\n}\n\nexport function BigNatModule_extractBits(n, enc, bi) {\n    let z, i, z_1, i_1, z_2, i_2;\n    const biw = (~(~(bi / BigNatModule_baseBits))) | 0;\n    const bjw = (~(~(((bi + enc.bigL) - 1) / BigNatModule_baseBits))) | 0;\n    if (biw !== bjw) {\n        const xbit = (bi % BigNatModule_baseBits) | 0;\n        return ((((z = n, (i = (biw | 0), (i < z.bound) ? z.digits[i] : 0)) >> xbit) | ((z_1 = n, (i_1 = (bjw | 0), (i_1 < z_1.bound) ? z_1.digits[i_1] : 0)) << (BigNatModule_baseBits - xbit))) & BigNatModule_bitmask[enc.bigL]) | 0;\n    }\n    else {\n        return (((z_2 = n, (i_2 = (biw | 0), (i_2 < z_2.bound) ? z_2.digits[i_2] : 0)) >> (bi % BigNatModule_baseBits)) & BigNatModule_bitmask[enc.bigL]) | 0;\n    }\n}\n\nexport function BigNatModule_encodePoly(enc, n) {\n    const poly = fill(new Uint32Array(enc.bigK), 0, enc.bigK, BigNatModule_FFT_Fp_ofInt32(0));\n    const biMax = (n.bound * BigNatModule_baseBits) | 0;\n    const encoder = (i_mut, bi_mut) => {\n        encoder:\n        while (true) {\n            const i = i_mut, bi = bi_mut;\n            if ((i === enc.bigK) ? true : (bi > biMax)) {\n            }\n            else {\n                const pi = BigNatModule_extractBits(n, enc, bi) | 0;\n                poly[i] = BigNatModule_FFT_Fp_ofInt32(pi);\n                i_mut = (i + 1);\n                bi_mut = (bi + enc.bigL);\n                continue encoder;\n            }\n            break;\n        }\n    };\n    encoder(0, 0);\n    return poly;\n}\n\nexport function BigNatModule_decodeResultBits(enc, poly) {\n    let n = 0;\n    for (let i = 0; i <= (poly.length - 1); i++) {\n        if (poly[i] !== BigNatModule_FFT_mzero) {\n            n = i;\n        }\n    }\n    return (((BigNatModule_FFT_maxBitsInsideFp + (enc.bigL * n)) + 1) + 1) | 0;\n}\n\nexport function BigNatModule_decodePoly(enc, poly) {\n    const rbound = ((~(~(BigNatModule_decodeResultBits(enc, poly) / BigNatModule_baseBits))) + 1) | 0;\n    const r = BigNatModule_createN(rbound);\n    const evaluate = (i_mut, j_mut, d_mut) => {\n        evaluate:\n        while (true) {\n            const i = i_mut, j = j_mut, d = d_mut;\n            if (i === enc.bigK) {\n            }\n            else {\n                if (j >= rbound) {\n                }\n                else {\n                    BigNatModule_contributeArr(r.digits, j, op_Multiply(fromInteger(BigNatModule_FFT_Fp_toInt(poly[i]), false, 2), BigNatModule_twopowersI64[d]));\n                }\n                const d_1 = (d + enc.bigL) | 0;\n                const patternInput = (d_1 >= BigNatModule_baseBits) ? [j + 1, d_1 - BigNatModule_baseBits] : [j, d_1];\n                i_mut = (i + 1);\n                j_mut = patternInput[0];\n                d_mut = patternInput[1];\n                continue evaluate;\n            }\n            break;\n        }\n    };\n    evaluate(0, 0, 0);\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_quickMulUsingFft(u, v) {\n    const enc = BigNatModule_encodingGivenResultBits(BigNatModule_bits(u) + BigNatModule_bits(v));\n    return BigNatModule_normN(BigNatModule_decodePoly(enc, BigNatModule_FFT_computeFftPaddedPolynomialProduct(enc.bigK, enc.k, BigNatModule_encodePoly(enc, u), BigNatModule_encodePoly(enc, v))));\n}\n\nexport const BigNatModule_minDigitsKaratsuba = 16;\n\nexport function BigNatModule_recMulKaratsuba(mul, p, q) {\n    const bmax = BigNatModule_maxInt(p.bound, q.bound) | 0;\n    if (bmax > BigNatModule_minDigitsKaratsuba) {\n        const k = (~(~(bmax / 2))) | 0;\n        const a0 = BigNatModule_restrictTo(k, p);\n        const a1 = BigNatModule_shiftDown(k, p);\n        const b0 = BigNatModule_restrictTo(k, q);\n        const b1 = BigNatModule_shiftDown(k, q);\n        const q0 = mul(a0, b0);\n        const q1 = mul(BigNatModule_add(a0, a1), BigNatModule_add(b0, b1));\n        const q2 = mul(a1, b1);\n        return BigNatModule_add(q0, BigNatModule_shiftUp(k, BigNatModule_add(BigNatModule_sub(q1, BigNatModule_add(q0, q2)), BigNatModule_shiftUp(k, q2))));\n    }\n    else {\n        return BigNatModule_mulSchoolBook(p, q);\n    }\n}\n\nexport function BigNatModule_mulKaratsuba(x, y) {\n    return BigNatModule_recMulKaratsuba((x_1, y_1) => BigNatModule_mulKaratsuba(x_1, y_1), x, y);\n}\n\nexport const BigNatModule_productDigitsUpperSchoolBook = ~(~(64000 / BigNatModule_baseBits));\n\nexport const BigNatModule_singleDigitForceSchoolBook = ~(~(32000 / BigNatModule_baseBits));\n\nexport const BigNatModule_productDigitsUpperFft = ~(~(BigNatModule_table[0].bigN / BigNatModule_baseBits));\n\nexport function BigNatModule_mul(p, q) {\n    return BigNatModule_mulSchoolBook(p, q);\n}\n\nexport function BigNatModule_scaleSubInPlace(x, f, a, n) {\n    const patternInput = [x.digits, BigNatModule_degree(x)];\n    const x_1 = patternInput[0];\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\n    const ad = patternInput_1[1] | 0;\n    const a_1 = patternInput_1[0];\n    const f_1 = fromInteger(f, false, 2);\n    let j = 0;\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\n        if (j > patternInput[1]) {\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\n        }\n        let zLo = (~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)))) | 0;\n        let zHi = op_Division(z, BigNatModule_baseNi64);\n        if (zLo <= x_1[j + n]) {\n            x_1[j + n] = (x_1[j + n] - zLo);\n        }\n        else {\n            x_1[j + n] = (x_1[j + n] + (BigNatModule_baseN - zLo));\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\n        }\n        if (j < ad) {\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\n        }\n        else {\n            z = zHi;\n        }\n        j = (j + 1);\n    }\n    void BigNatModule_normN(x);\n}\n\nexport function BigNatModule_scaleSub(x, f, a, n) {\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\n    BigNatModule_scaleSubInPlace(freshx, f, a, n);\n    return BigNatModule_normN(freshx);\n}\n\nexport function BigNatModule_scaleAddInPlace(x, f, a, n) {\n    const patternInput = [x.digits, BigNatModule_degree(x)];\n    const x_1 = patternInput[0];\n    const patternInput_1 = [a.digits, BigNatModule_degree(a)];\n    const ad = patternInput_1[1] | 0;\n    const a_1 = patternInput_1[0];\n    const f_1 = fromInteger(f, false, 2);\n    let j = 0;\n    let z = op_Multiply(f_1, fromInteger(a_1[0], false, 2));\n    while ((compare(z, fromBits(0, 0, false)) > 0) ? true : (j < ad)) {\n        if (j > patternInput[1]) {\n            throw (new Error(\"scaleSubInPlace: pre-condition did not apply, result would be -ve\"));\n        }\n        let zLo = (~(~toInt(op_BitwiseAnd(z, BigNatModule_baseMaski64)))) | 0;\n        let zHi = op_Division(z, BigNatModule_baseNi64);\n        if (zLo < (BigNatModule_baseN - x_1[j + n])) {\n            x_1[j + n] = (x_1[j + n] + zLo);\n        }\n        else {\n            x_1[j + n] = (zLo - (BigNatModule_baseN - x_1[j + n]));\n            zHi = op_Addition(zHi, fromBits(1, 0, false));\n        }\n        if (j < ad) {\n            z = op_Addition(zHi, op_Multiply(f_1, fromInteger(a_1[j + 1], false, 2)));\n        }\n        else {\n            z = zHi;\n        }\n        j = (j + 1);\n    }\n    void BigNatModule_normN(x);\n}\n\nexport function BigNatModule_scaleAdd(x, f, a, n) {\n    const freshx = BigNatModule_add(x, BigNatModule_zero);\n    BigNatModule_scaleAddInPlace(freshx, f, a, n);\n    return BigNatModule_normN(freshx);\n}\n\nexport function BigNatModule_removeFactor(x, a, n) {\n    const patternInput = [BigNatModule_degree(a), BigNatModule_degree(x)];\n    const degx = patternInput[1] | 0;\n    const dega = patternInput[0] | 0;\n    if (degx < (dega + n)) {\n        return 0;\n    }\n    else {\n        const patternInput_1 = [a.digits, x.digits];\n        const xa = patternInput_1[1];\n        const aa = patternInput_1[0];\n        const f = ((dega === 0) ? ((degx === n) ? (~(~(xa[n] / aa[0]))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), fromInteger(aa[0], false, 2)))))) : ((degx === (dega + n)) ? (~(~(xa[degx] / (aa[dega] + 1)))) : (~(~toInt(op_Division(op_Addition(op_Multiply(fromInteger(xa[degx], false, 2), BigNatModule_baseNi64), fromInteger(xa[degx - 1], false, 2)), op_Addition(fromInteger(aa[dega], false, 2), fromBits(1, 0, false)))))))) | 0;\n        if (f === 0) {\n            if (BigNatModule_shiftCompare(a, n, x, 0) !== 1) {\n                return 1;\n            }\n            else {\n                return 0;\n            }\n        }\n        else {\n            return f | 0;\n        }\n    }\n}\n\nexport function BigNatModule_divmod(b, a) {\n    if (BigNatModule_isZero(a)) {\n        throw (new Error());\n    }\n    else if (BigNatModule_degree(b) < BigNatModule_degree(a)) {\n        return [BigNatModule_zero, b];\n    }\n    else {\n        const x = BigNatModule_copyN(b);\n        const d = BigNatModule_createN(((BigNatModule_degree(b) - BigNatModule_degree(a)) + 1) + 1);\n        let p = BigNatModule_degree(b) | 0;\n        const m = BigNatModule_degree(a) | 0;\n        let n = (p - m) | 0;\n        const Invariant = (tupledArg) => {\n        };\n        let finished = false;\n        while (!finished) {\n            Invariant([d, x, n, p]);\n            const f = BigNatModule_removeFactor(x, a, n) | 0;\n            if (f > 0) {\n                BigNatModule_scaleSubInPlace(x, f, a, n);\n                BigNatModule_scaleAddInPlace(d, f, BigNatModule_one, n);\n                Invariant([d, x, n, p]);\n            }\n            else {\n                finished = ((f === 0) ? (n === 0) : false);\n                if (!finished) {\n                    if (p === (m + n)) {\n                        Invariant([d, x, n - 1, p]);\n                        n = (n - 1);\n                    }\n                    else {\n                        Invariant([d, x, n - 1, p - 1]);\n                        n = (n - 1);\n                        p = (p - 1);\n                    }\n                }\n            }\n        }\n        return [BigNatModule_normN(d), BigNatModule_normN(x)];\n    }\n}\n\nexport function BigNatModule_div(b, a) {\n    return BigNatModule_divmod(b, a)[0];\n}\n\nexport function BigNatModule_rem(b, a) {\n    return BigNatModule_divmod(b, a)[1];\n}\n\nexport function BigNatModule_bitAnd(a, b) {\n    const r = BigNatModule_createN(BigNatModule_minInt(a.bound, b.bound));\n    for (let i = 0; i <= (r.bound - 1); i++) {\n        r.digits[i] = (a.digits[i] & b.digits[i]);\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_bitOr(a, b) {\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\n    for (let i = 0; i <= (a.bound - 1); i++) {\n        r.digits[i] = (r.digits[i] | a.digits[i]);\n    }\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\n        r.digits[i_1] = (r.digits[i_1] | b.digits[i_1]);\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_bitXor(a, b) {\n    const r = BigNatModule_createN(BigNatModule_maxInt(a.bound, b.bound));\n    for (let i = 0; i <= (a.bound - 1); i++) {\n        r.digits[i] = (r.digits[i] ^ a.digits[i]);\n    }\n    for (let i_1 = 0; i_1 <= (b.bound - 1); i_1++) {\n        r.digits[i_1] = (r.digits[i_1] ^ b.digits[i_1]);\n    }\n    return BigNatModule_normN(r);\n}\n\nexport function BigNatModule_hcf(a, b) {\n    const hcfloop = (a_1_mut, b_1_mut) => {\n        hcfloop:\n        while (true) {\n            const a_1 = a_1_mut, b_1 = b_1_mut;\n            if (BigNatModule_equal(BigNatModule_zero, a_1)) {\n                return b_1;\n            }\n            else {\n                a_1_mut = BigNatModule_divmod(b_1, a_1)[1];\n                b_1_mut = a_1;\n                continue hcfloop;\n            }\n            break;\n        }\n    };\n    if (BigNatModule_lt(a, b)) {\n        return hcfloop(a, b);\n    }\n    else {\n        return hcfloop(b, a);\n    }\n}\n\nexport const BigNatModule_two = BigNatModule_embed(2);\n\nexport function BigNatModule_powi(x, n) {\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\n        power:\n        while (true) {\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\n            if (n_1 === 0) {\n                return acc;\n            }\n            else if ((n_1 % 2) === 0) {\n                acc_mut = acc;\n                x_1_mut = BigNatModule_mul(x_1, x_1);\n                n_1_mut = (~(~(n_1 / 2)));\n                continue power;\n            }\n            else {\n                acc_mut = BigNatModule_mul(x_1, acc);\n                x_1_mut = BigNatModule_mul(x_1, x_1);\n                n_1_mut = (~(~(n_1 / 2)));\n                continue power;\n            }\n            break;\n        }\n    };\n    return power(BigNatModule_one, x, n);\n}\n\nexport function BigNatModule_pow(x, n) {\n    const power = (acc_mut, x_1_mut, n_1_mut) => {\n        power:\n        while (true) {\n            const acc = acc_mut, x_1 = x_1_mut, n_1 = n_1_mut;\n            if (BigNatModule_isZero(n_1)) {\n                return acc;\n            }\n            else {\n                const patternInput = BigNatModule_divmod(n_1, BigNatModule_two);\n                const ndiv2 = patternInput[0];\n                if (BigNatModule_isZero(patternInput[1])) {\n                    acc_mut = acc;\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\n                    n_1_mut = ndiv2;\n                    continue power;\n                }\n                else {\n                    acc_mut = BigNatModule_mul(x_1, acc);\n                    x_1_mut = BigNatModule_mul(x_1, x_1);\n                    n_1_mut = ndiv2;\n                    continue power;\n                }\n            }\n            break;\n        }\n    };\n    return power(BigNatModule_one, x, n);\n}\n\nexport function BigNatModule_toFloat(n) {\n    const evalFloat = (acc_mut, k_mut, i_mut) => {\n        evalFloat:\n        while (true) {\n            const acc = acc_mut, k = k_mut, i = i_mut;\n            if (i === n.bound) {\n                return acc;\n            }\n            else {\n                acc_mut = (acc + (k * n.digits[i]));\n                k_mut = (k * BigNatModule_baseN);\n                i_mut = (i + 1);\n                continue evalFloat;\n            }\n            break;\n        }\n    };\n    return evalFloat(0, 1, 0);\n}\n\nexport function BigNatModule_ofInt32(n) {\n    return BigNatModule_embed(n);\n}\n\nexport function BigNatModule_ofInt64(n) {\n    return BigNatModule_embed64(n);\n}\n\nexport function BigNatModule_toUInt32(n) {\n    const matchValue = n.bound | 0;\n    switch (matchValue) {\n        case 0: {\n            return 0;\n        }\n        case 1: {\n            const value = n.digits[0] | 0;\n            return value >>> 0;\n        }\n        case 2: {\n            const patternInput = [n.digits[0], n.digits[1]];\n            const xB = patternInput[1] | 0;\n            if (xB > BigNatModule_baseMask32B) {\n                throw (new Error());\n            }\n            return ((patternInput[0] & BigNatModule_baseMask32A) >>> 0) + ((((xB & BigNatModule_baseMask32B) >>> 0) << BigNatModule_baseShift32B) >>> 0);\n        }\n        default: {\n            throw (new Error());\n        }\n    }\n}\n\nexport function BigNatModule_toUInt64(n) {\n    const matchValue = n.bound | 0;\n    switch (matchValue) {\n        case 0: {\n            return fromBits(0, 0, true);\n        }\n        case 1: {\n            return fromInteger(n.digits[0], true, 2);\n        }\n        case 2: {\n            const patternInput = [n.digits[0], n.digits[1]];\n            return op_Addition(fromInteger(patternInput[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B));\n        }\n        case 3: {\n            const patternInput_1 = [n.digits[0], n.digits[1], n.digits[2]];\n            const xC = patternInput_1[2] | 0;\n            if (xC > BigNatModule_baseMask64C) {\n                throw (new Error());\n            }\n            return op_Addition(op_Addition(fromInteger(patternInput_1[0] & BigNatModule_baseMask64A, true, 2), op_LeftShift(fromInteger(patternInput_1[1] & BigNatModule_baseMask64B, true, 2), BigNatModule_baseShift64B)), op_LeftShift(fromInteger(xC & BigNatModule_baseMask64C, true, 2), BigNatModule_baseShift64C));\n        }\n        default: {\n            throw (new Error());\n        }\n    }\n}\n\nexport function BigNatModule_toString(n) {\n    const degn = BigNatModule_degree(n) | 0;\n    const route = (prior_mut, k_mut, ten2k_mut) => {\n        route:\n        while (true) {\n            const prior = prior_mut, k = k_mut, ten2k = ten2k_mut;\n            if (BigNatModule_degree(ten2k) > degn) {\n                return new List([k, ten2k], prior);\n            }\n            else {\n                prior_mut = (new List([k, ten2k], prior));\n                k_mut = (k + 1);\n                ten2k_mut = BigNatModule_mul(ten2k, ten2k);\n                continue route;\n            }\n            break;\n        }\n    };\n    const collect = (isLeading_mut, digits_mut, n_1_mut, _arg1_mut) => {\n        collect:\n        while (true) {\n            const isLeading = isLeading_mut, digits = digits_mut, n_1 = n_1_mut, _arg1 = _arg1_mut;\n            if (_arg1.tail != null) {\n                const prior_1 = _arg1.tail;\n                const patternInput = BigNatModule_divmod(n_1, _arg1.head[1]);\n                const nL = patternInput[1];\n                const nH = patternInput[0];\n                if (isLeading ? BigNatModule_isZero(nH) : false) {\n                    isLeading_mut = isLeading;\n                    digits_mut = digits;\n                    n_1_mut = nL;\n                    _arg1_mut = prior_1;\n                    continue collect;\n                }\n                else {\n                    isLeading_mut = isLeading;\n                    digits_mut = collect(false, digits, nL, prior_1);\n                    n_1_mut = nH;\n                    _arg1_mut = prior_1;\n                    continue collect;\n                }\n            }\n            else {\n                const n_2 = BigNatModule_eval32(n_1) | 0;\n                if (isLeading ? (n_2 === 0) : false) {\n                    return digits;\n                }\n                else {\n                    return new List(int32ToString(n_2), digits);\n                }\n            }\n            break;\n        }\n    };\n    const digits_4 = collect(true, new List(), n, route(new List(), 0, BigNatModule_embed(10)));\n    if (digits_4.tail == null) {\n        return \"0\";\n    }\n    else {\n        return join(\"\", Array.from(digits_4));\n    }\n}\n\nexport function BigNatModule_ofString(str) {\n    const len = str.length | 0;\n    if (isNullOrEmpty(str)) {\n        throw (new Error(\"empty string\\\\nParameter name: str\"));\n    }\n    const ten = BigNatModule_embed(10);\n    const build = (acc_mut, i_mut) => {\n        build:\n        while (true) {\n            const acc = acc_mut, i = i_mut;\n            if (i === len) {\n                return acc;\n            }\n            else {\n                const d = (str[i].charCodeAt(0) - \"0\".charCodeAt(0)) | 0;\n                if ((0 <= d) ? (d <= 9) : false) {\n                    acc_mut = BigNatModule_add(BigNatModule_mul(ten, acc), BigNatModule_embed(d));\n                    i_mut = (i + 1);\n                    continue build;\n                }\n                else {\n                    throw (new Error());\n                }\n            }\n            break;\n        }\n    };\n    return build(BigNatModule_embed(0), 0);\n}\n\nexport function BigNatModule_isSmall(n) {\n    return n.bound <= 1;\n}\n\nexport function BigNatModule_getSmall(n) {\n    const z = n;\n    const i = 0;\n    if (i < z.bound) {\n        return z.digits[i] | 0;\n    }\n    else {\n        return 0;\n    }\n}\n\nexport function BigNatModule_factorial(n) {\n    const productR = (a, b) => {\n        if (BigNatModule_equal(a, b)) {\n            return a;\n        }\n        else {\n            const m = BigNatModule_div(BigNatModule_add(a, b), BigNatModule_ofInt32(2));\n            return BigNatModule_mul(productR(a, m), productR(BigNatModule_add(m, BigNatModule_one), b));\n        }\n    };\n    return productR(BigNatModule_one, n);\n}\n\n","import { BigNatModule_factorial, BigNatModule_ofString, BigNatModule_toFloat, BigNatModule_toUInt64, BigNatModule_toUInt32, BigNatModule_pow, BigNatModule_two, BigNatModule_rem, BigNatModule_lte, BigNatModule_hcf, BigNatModule_bitXor, BigNatModule_bitOr, BigNatModule_bitAnd, BigNatModule_divmod, BigNatModule_mul, BigNatModule_isOne, BigNatModule_sub, BigNatModule_gte, BigNatModule_scale, BigNatModule_one, BigNatModule_add, BigNatModule_ofInt64, BigNatModule_hash, BigNatModule_gt, BigNatModule_lt, BigNatModule_equal, BigNatModule_getSmall, BigNatModule_isSmall, BigNatModule_ofInt32, BigNatModule_toString, BigNatModule_isZero } from \"./n.js\";\nimport { toString, Record } from \"../Types.js\";\nimport { class_type } from \"../Reflection.js\";\nimport { initialize } from \"../Array.js\";\nimport { op_Addition, op_Multiply, fromValue, equals, fromBits, compare, fromInteger, op_UnaryNegation } from \"../Long.js\";\nimport { op_UnaryNegation_Int32 } from \"../Int32.js\";\nimport Decimal from \"../Decimal.js\";\n\nexport class BigInteger extends Record {\n    constructor(signInt, v) {\n        super();\n        this.signInt = signInt;\n        this.v = v;\n    }\n    toString() {\n        const x = this;\n        const matchValue = BigInteger__get_SignInt(x) | 0;\n        switch (matchValue) {\n            case -1: {\n                return BigNatModule_isZero(BigInteger__get_V(x)) ? \"0\" : (\"-\" + BigNatModule_toString(BigInteger__get_V(x)));\n            }\n            case 0: {\n                return \"0\";\n            }\n            case 1: {\n                return BigNatModule_toString(BigInteger__get_V(x));\n            }\n            default: {\n                throw (new Error(\"signs should be +/- 1 or 0\"));\n            }\n        }\n    }\n    Equals(obj) {\n        const this$ = this;\n        return (obj instanceof BigInteger) ? BigInteger_op_Equality_56F059C0(this$, obj) : false;\n    }\n    GetHashCode() {\n        const x = this;\n        return BigInteger_hash_Z665282C2(x) | 0;\n    }\n    CompareTo(obj) {\n        const this$ = this;\n        if (obj instanceof BigInteger) {\n            return BigInteger_compare_56F059C0(this$, obj) | 0;\n        }\n        else {\n            throw (new Error(\"the objects are not comparable\\\\nParameter name: obj\"));\n        }\n    }\n}\n\nexport function BigInteger$reflection() {\n    return class_type(\"BigInt.BigInteger\", void 0, BigInteger, class_type(\"System.ValueType\"));\n}\n\nexport function BigInteger_$ctor_Z2BE94A1(signInt, v) {\n    return new BigInteger(signInt, v);\n}\n\n(() => {\n    BigInteger.smallLim = 4096;\n    BigInteger.smallPosTab = initialize(BigInteger.smallLim, (n) => BigNatModule_ofInt32(n));\n    BigInteger.one = BigInteger_$ctor_Z524259A4(1);\n    BigInteger.two = BigInteger_$ctor_Z524259A4(2);\n    BigInteger.zero = BigInteger_$ctor_Z524259A4(0);\n})();\n\nexport function BigInteger_nat_Z67CCE57D(n) {\n    if (BigNatModule_isSmall(n) ? (BigNatModule_getSmall(n) < BigInteger.smallLim) : false) {\n        return BigInteger.smallPosTab[BigNatModule_getSmall(n)];\n    }\n    else {\n        return n;\n    }\n}\n\nexport function BigInteger_create_Z2BE94A1(s, n) {\n    return BigInteger_$ctor_Z2BE94A1(s, BigInteger_nat_Z67CCE57D(n));\n}\n\nexport function BigInteger_posn_Z67CCE57D(n) {\n    return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(n));\n}\n\nexport function BigInteger_negn_Z67CCE57D(n) {\n    return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(n));\n}\n\nexport function BigInteger__get_Sign(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return 0;\n    }\n    else {\n        return x.signInt | 0;\n    }\n}\n\nexport function BigInteger__get_SignInt(x) {\n    return x.signInt;\n}\n\nexport function BigInteger__get_V(x) {\n    return x.v;\n}\n\nexport function BigInteger_op_Equality_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    let pattern_matching_result;\n    if (matchValue[0] === -1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 1;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 8;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 3;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 0) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 6;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 4;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 5;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 2;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 7;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else {\n        pattern_matching_result = 9;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 1: {\n            return BigNatModule_equal(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 2: {\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\n                return BigNatModule_isZero(BigInteger__get_V(y));\n            }\n            else {\n                return false;\n            }\n        }\n        case 3: {\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\n                return BigNatModule_isZero(BigInteger__get_V(y));\n            }\n            else {\n                return false;\n            }\n        }\n        case 4: {\n            return true;\n        }\n        case 5: {\n            return BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 6: {\n            return BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 7: {\n            return BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 8: {\n            return BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 9: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger_op_Inequality_56F059C0(x, y) {\n    return !BigInteger_op_Equality_56F059C0(x, y);\n}\n\nexport function BigInteger_op_LessThan_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    let pattern_matching_result;\n    if (matchValue[0] === -1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 1;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 8;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 3;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 0) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 6;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 4;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 5;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 2;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 7;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else {\n        pattern_matching_result = 9;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return BigNatModule_lt(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 1: {\n            return BigNatModule_lt(BigInteger__get_V(y), BigInteger__get_V(x));\n        }\n        case 2: {\n            return false;\n        }\n        case 3: {\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\n                return true;\n            }\n            else {\n                return !BigNatModule_isZero(BigInteger__get_V(y));\n            }\n        }\n        case 4: {\n            return false;\n        }\n        case 5: {\n            return !BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 6: {\n            return false;\n        }\n        case 7: {\n            return false;\n        }\n        case 8: {\n            return !BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 9: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger_op_GreaterThan_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    let pattern_matching_result;\n    if (matchValue[0] === -1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 1;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 8;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 3;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 0) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 6;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 4;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 5;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 2;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 7;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else {\n        pattern_matching_result = 9;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return BigNatModule_gt(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 1: {\n            return BigNatModule_gt(BigInteger__get_V(y), BigInteger__get_V(x));\n        }\n        case 2: {\n            if (!BigNatModule_isZero(BigInteger__get_V(x))) {\n                return true;\n            }\n            else {\n                return !BigNatModule_isZero(BigInteger__get_V(y));\n            }\n        }\n        case 3: {\n            return false;\n        }\n        case 4: {\n            return false;\n        }\n        case 5: {\n            return false;\n        }\n        case 6: {\n            return !BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 7: {\n            return !BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 8: {\n            return false;\n        }\n        case 9: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger_compare_56F059C0(n, nn) {\n    if (BigInteger_op_LessThan_56F059C0(n, nn)) {\n        return -1;\n    }\n    else if (BigInteger_op_Equality_56F059C0(n, nn)) {\n        return 0;\n    }\n    else {\n        return 1;\n    }\n}\n\nexport function BigInteger_hash_Z665282C2(z) {\n    if (BigInteger__get_SignInt(z) === 0) {\n        return 1;\n    }\n    else {\n        return (BigInteger__get_SignInt(z) + BigNatModule_hash(BigInteger__get_V(z))) | 0;\n    }\n}\n\nexport function BigInteger__get_StructuredDisplayString(x) {\n    return toString(x);\n}\n\nexport function BigInteger_$ctor_Z524259A4(n) {\n    if (n >= 0) {\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(n)));\n    }\n    else if (n === -2147483648) {\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(fromInteger(n, false, 2)))));\n    }\n    else {\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt32(op_UnaryNegation_Int32(n))));\n    }\n}\n\nexport function BigInteger_$ctor_Z524259C1(n) {\n    if (compare(n, fromBits(0, 0, false)) >= 0) {\n        return BigInteger_$ctor_Z2BE94A1(1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(n)));\n    }\n    else if (equals(n, fromBits(0, 2147483648, false))) {\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_add(BigNatModule_ofInt64(fromBits(4294967295, 2147483647, false)), BigNatModule_one)));\n    }\n    else {\n        return BigInteger_$ctor_Z2BE94A1(-1, BigInteger_nat_Z67CCE57D(BigNatModule_ofInt64(op_UnaryNegation(n))));\n    }\n}\n\nexport function BigInteger_get_One() {\n    return BigInteger.one;\n}\n\nexport function BigInteger_get_Two() {\n    return BigInteger.two;\n}\n\nexport function BigInteger_get_Zero() {\n    return BigInteger.zero;\n}\n\nexport function BigInteger_op_UnaryNegation_Z665282C2(z) {\n    const matchValue = BigInteger__get_SignInt(z) | 0;\n    if (matchValue === 0) {\n        return BigInteger_get_Zero();\n    }\n    else {\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(matchValue), BigInteger__get_V(z));\n    }\n}\n\nexport function BigInteger_Scale_Z320F31E(k, z) {\n    if (BigInteger__get_SignInt(z) === 0) {\n        return BigInteger_get_Zero();\n    }\n    else if (k < 0) {\n        return BigInteger_create_Z2BE94A1(op_UnaryNegation_Int32(BigInteger__get_SignInt(z)), BigNatModule_scale(op_UnaryNegation_Int32(k), BigInteger__get_V(z)));\n    }\n    else {\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(z), BigNatModule_scale(k, BigInteger__get_V(z)));\n    }\n}\n\nexport function BigInteger_subnn_6A57060(nx, ny) {\n    if (BigNatModule_gte(nx, ny)) {\n        return BigInteger_posn_Z67CCE57D(BigNatModule_sub(nx, ny));\n    }\n    else {\n        return BigInteger_negn_Z67CCE57D(BigNatModule_sub(ny, nx));\n    }\n}\n\nexport function BigInteger_addnn_6A57060(nx, ny) {\n    return BigInteger_posn_Z67CCE57D(BigNatModule_add(nx, ny));\n}\n\nexport function BigInteger__get_IsZero(x) {\n    if (BigInteger__get_SignInt(x) === 0) {\n        return true;\n    }\n    else {\n        return BigNatModule_isZero(BigInteger__get_V(x));\n    }\n}\n\nexport function BigInteger__get_IsOne(x) {\n    if (BigInteger__get_SignInt(x) === 1) {\n        return BigNatModule_isOne(BigInteger__get_V(x));\n    }\n    else {\n        return false;\n    }\n}\n\nexport function BigInteger_op_Addition_56F059C0(x, y) {\n    if (BigInteger__get_IsZero(y)) {\n        return x;\n    }\n    else if (BigInteger__get_IsZero(x)) {\n        return y;\n    }\n    else {\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n        let pattern_matching_result;\n        if (matchValue[0] === -1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 1;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 3;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 2;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 0;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else {\n            pattern_matching_result = 4;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\n            }\n            case 1: {\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\n            }\n            case 2: {\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\n            }\n            case 3: {\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\n            }\n            case 4: {\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\n            }\n        }\n    }\n}\n\nexport function BigInteger_op_Subtraction_56F059C0(x, y) {\n    if (BigInteger__get_IsZero(y)) {\n        return x;\n    }\n    else if (BigInteger__get_IsZero(x)) {\n        return BigInteger_op_UnaryNegation_Z665282C2(y);\n    }\n    else {\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n        let pattern_matching_result;\n        if (matchValue[0] === -1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 1;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 3;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 2;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 0;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else {\n            pattern_matching_result = 4;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return BigInteger_subnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\n            }\n            case 1: {\n                return BigInteger_subnn_6A57060(BigInteger__get_V(y), BigInteger__get_V(x));\n            }\n            case 2: {\n                return BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y));\n            }\n            case 3: {\n                return BigInteger_op_UnaryNegation_Z665282C2(BigInteger_addnn_6A57060(BigInteger__get_V(x), BigInteger__get_V(y)));\n            }\n            case 4: {\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\n            }\n        }\n    }\n}\n\nexport function BigInteger_op_Multiply_56F059C0(x, y) {\n    if (BigInteger__get_IsZero(x)) {\n        return x;\n    }\n    else if (BigInteger__get_IsZero(y)) {\n        return y;\n    }\n    else if (BigInteger__get_IsOne(x)) {\n        return y;\n    }\n    else if (BigInteger__get_IsOne(y)) {\n        return x;\n    }\n    else {\n        const m = BigNatModule_mul(BigInteger__get_V(x), BigInteger__get_V(y));\n        return BigInteger_create_Z2BE94A1(BigInteger__get_SignInt(x) * BigInteger__get_SignInt(y), m);\n    }\n}\n\nexport function BigInteger_DivRem_56F059C0(x, y) {\n    if (BigInteger__get_IsZero(y)) {\n        throw (new Error());\n    }\n    if (BigInteger__get_IsZero(x)) {\n        return [BigInteger_get_Zero(), BigInteger_get_Zero()];\n    }\n    else {\n        const patternInput = BigNatModule_divmod(BigInteger__get_V(x), BigInteger__get_V(y));\n        const r = patternInput[1];\n        const d = patternInput[0];\n        const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n        let pattern_matching_result;\n        if (matchValue[0] === -1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 1;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 3;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else if (matchValue[0] === 1) {\n            if (matchValue[1] === -1) {\n                pattern_matching_result = 2;\n            }\n            else if (matchValue[1] === 1) {\n                pattern_matching_result = 0;\n            }\n            else {\n                pattern_matching_result = 4;\n            }\n        }\n        else {\n            pattern_matching_result = 4;\n        }\n        switch (pattern_matching_result) {\n            case 0: {\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\n            }\n            case 1: {\n                return [BigInteger_posn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\n            }\n            case 2: {\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_posn_Z67CCE57D(r)];\n            }\n            case 3: {\n                return [BigInteger_negn_Z67CCE57D(d), BigInteger_negn_Z67CCE57D(r)];\n            }\n            case 4: {\n                throw (new Error(\"signs should be +/- 1\\\\nParameter name: x\"));\n            }\n        }\n    }\n}\n\nexport function BigInteger_op_Division_56F059C0(x, y) {\n    return BigInteger_DivRem_56F059C0(x, y)[0];\n}\n\nexport function BigInteger_op_Modulus_56F059C0(x, y) {\n    return BigInteger_DivRem_56F059C0(x, y)[1];\n}\n\nexport function BigInteger_op_RightShift_62E082A2(x, y) {\n    return BigInteger_op_Division_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\n}\n\nexport function BigInteger_op_LeftShift_62E082A2(x, y) {\n    return BigInteger_op_Multiply_56F059C0(x, BigInteger_Pow_62E082A2(BigInteger_get_Two(), y));\n}\n\nexport function BigInteger_op_BitwiseAnd_56F059C0(x, y) {\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitAnd(BigInteger__get_V(x), BigInteger__get_V(y)));\n}\n\nexport function BigInteger_op_BitwiseOr_56F059C0(x, y) {\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitOr(BigInteger__get_V(x), BigInteger__get_V(y)));\n}\n\nexport function BigInteger_op_ExclusiveOr_56F059C0(x, y) {\n    return BigInteger_posn_Z67CCE57D(BigNatModule_bitXor(BigInteger__get_V(x), BigInteger__get_V(y)));\n}\n\nexport function BigInteger_GreatestCommonDivisor_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    if (matchValue[0] === 0) {\n        if (matchValue[1] === 0) {\n            return BigInteger_get_Zero();\n        }\n        else {\n            return BigInteger_posn_Z67CCE57D(BigInteger__get_V(y));\n        }\n    }\n    else if (matchValue[1] === 0) {\n        return BigInteger_posn_Z67CCE57D(BigInteger__get_V(x));\n    }\n    else {\n        return BigInteger_posn_Z67CCE57D(BigNatModule_hcf(BigInteger__get_V(x), BigInteger__get_V(y)));\n    }\n}\n\nexport function BigInteger__get_IsNegative(x) {\n    if (BigInteger__get_SignInt(x) === -1) {\n        return !BigInteger__get_IsZero(x);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function BigInteger__get_IsPositive(x) {\n    if (BigInteger__get_SignInt(x) === 1) {\n        return !BigInteger__get_IsZero(x);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function BigInteger_Abs_Z665282C2(x) {\n    if (BigInteger__get_SignInt(x) === -1) {\n        return BigInteger_op_UnaryNegation_Z665282C2(x);\n    }\n    else {\n        return x;\n    }\n}\n\nexport function BigInteger_op_LessThanOrEqual_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    let pattern_matching_result;\n    if (matchValue[0] === -1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 1;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 6;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 3;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 0) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 8;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 4;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 7;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 2;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 5;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else {\n        pattern_matching_result = 9;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return BigNatModule_lte(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 1: {\n            return BigNatModule_lte(BigInteger__get_V(y), BigInteger__get_V(x));\n        }\n        case 2: {\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\n                return BigNatModule_isZero(BigInteger__get_V(y));\n            }\n            else {\n                return false;\n            }\n        }\n        case 3: {\n            return true;\n        }\n        case 4: {\n            return true;\n        }\n        case 5: {\n            return BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 6: {\n            return true;\n        }\n        case 7: {\n            return true;\n        }\n        case 8: {\n            return BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 9: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger_op_GreaterThanOrEqual_56F059C0(x, y) {\n    const matchValue = [BigInteger__get_SignInt(x), BigInteger__get_SignInt(y)];\n    let pattern_matching_result;\n    if (matchValue[0] === -1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 1;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 6;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 3;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 0) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 8;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 4;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 7;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else if (matchValue[0] === 1) {\n        if (matchValue[1] === -1) {\n            pattern_matching_result = 2;\n        }\n        else if (matchValue[1] === 0) {\n            pattern_matching_result = 5;\n        }\n        else if (matchValue[1] === 1) {\n            pattern_matching_result = 0;\n        }\n        else {\n            pattern_matching_result = 9;\n        }\n    }\n    else {\n        pattern_matching_result = 9;\n    }\n    switch (pattern_matching_result) {\n        case 0: {\n            return BigNatModule_gte(BigInteger__get_V(x), BigInteger__get_V(y));\n        }\n        case 1: {\n            return BigNatModule_gte(BigInteger__get_V(y), BigInteger__get_V(x));\n        }\n        case 2: {\n            return true;\n        }\n        case 3: {\n            if (BigNatModule_isZero(BigInteger__get_V(x))) {\n                return BigNatModule_isZero(BigInteger__get_V(y));\n            }\n            else {\n                return false;\n            }\n        }\n        case 4: {\n            return true;\n        }\n        case 5: {\n            return true;\n        }\n        case 6: {\n            return BigNatModule_isZero(BigInteger__get_V(x));\n        }\n        case 7: {\n            return BigNatModule_isZero(BigInteger__get_V(y));\n        }\n        case 8: {\n            return true;\n        }\n        case 9: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger_Pow_62E082A2(x, y) {\n    if (y < 0) {\n        throw (new Error(\"y\"));\n    }\n    const matchValue = [BigInteger__get_IsZero(x), y];\n    if (matchValue[0]) {\n        if (matchValue[1] === 0) {\n            return BigInteger_get_One();\n        }\n        else {\n            return BigInteger_get_Zero();\n        }\n    }\n    else {\n        const yval = BigInteger_$ctor_Z524259A4(y);\n        return BigInteger_create_Z2BE94A1(BigNatModule_isZero(BigNatModule_rem(BigInteger__get_V(yval), BigNatModule_two)) ? 1 : BigInteger__get_SignInt(x), BigNatModule_pow(BigInteger__get_V(x), BigInteger__get_V(yval)));\n    }\n}\n\nexport function BigInteger__get_ToInt32(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return 0;\n    }\n    else {\n        const u = BigNatModule_toUInt32(BigInteger__get_V(x));\n        if (u <= (2147483647 >>> 0)) {\n            return (BigInteger__get_SignInt(x) * (~(~u))) | 0;\n        }\n        else if ((BigInteger__get_SignInt(x) === -1) ? (u === ((2147483647 + 1) >>> 0)) : false) {\n            return -2147483648;\n        }\n        else {\n            throw (new Error());\n        }\n    }\n}\n\nexport function BigInteger__get_ToUInt32(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return 0;\n    }\n    else {\n        return BigNatModule_toUInt32(BigInteger__get_V(x));\n    }\n}\n\nexport function BigInteger__get_ToInt64(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return fromBits(0, 0, false);\n    }\n    else {\n        const u = BigNatModule_toUInt64(BigInteger__get_V(x));\n        if (compare(u, fromValue(fromBits(4294967295, 2147483647, false), true)) <= 0) {\n            return op_Multiply(fromInteger(BigInteger__get_SignInt(x), false, 2), fromValue(u, false));\n        }\n        else if ((BigInteger__get_SignInt(x) === -1) ? equals(u, fromValue(op_Addition(fromBits(4294967295, 2147483647, false), fromBits(1, 0, false)), true)) : false) {\n            return fromBits(0, 2147483648, false);\n        }\n        else {\n            throw (new Error());\n        }\n    }\n}\n\nexport function BigInteger__get_ToUInt64(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return fromBits(0, 0, true);\n    }\n    else {\n        return BigNatModule_toUInt64(BigInteger__get_V(x));\n    }\n}\n\nexport function BigInteger__get_ToDouble(x) {\n    const matchValue = BigInteger__get_SignInt(x) | 0;\n    switch (matchValue) {\n        case -1: {\n            return -BigNatModule_toFloat(BigInteger__get_V(x));\n        }\n        case 0: {\n            return 0;\n        }\n        case 1: {\n            return BigNatModule_toFloat(BigInteger__get_V(x));\n        }\n        default: {\n            throw (new Error(\"signs should be +/- 1 or 0\\\\nParameter name: x\"));\n        }\n    }\n}\n\nexport function BigInteger__get_ToSByte(x) {\n    return (BigInteger__get_ToInt32(x) + 0x80 & 0xFF) - 0x80;\n}\n\nexport function BigInteger__get_ToByte(x) {\n    return BigInteger__get_ToUInt32(x) & 0xFF;\n}\n\nexport function BigInteger__get_ToInt16(x) {\n    return (BigInteger__get_ToInt32(x) + 0x8000 & 0xFFFF) - 0x8000;\n}\n\nexport function BigInteger__get_ToUInt16(x) {\n    return BigInteger__get_ToUInt32(x) & 0xFFFF;\n}\n\nexport function BigInteger__get_ToSingle(x) {\n    return BigInteger__get_ToDouble(x);\n}\n\nexport function BigInteger__get_ToDecimal(x) {\n    return new Decimal(BigInteger__get_ToDouble(x));\n}\n\nexport function BigInteger_Parse_Z721C83C5(text) {\n    if (text == null) {\n        throw (new Error(\"text\"));\n    }\n    const text_1 = text.trim();\n    const len = text_1.length | 0;\n    if (len === 0) {\n        throw (new Error());\n    }\n    const matchValue = [text_1[0], len];\n    if (matchValue[0] === \"+\") {\n        if (matchValue[1] === 1) {\n            throw (new Error());\n        }\n        else {\n            return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\n        }\n    }\n    else if (matchValue[0] === \"-\") {\n        if (matchValue[1] === 1) {\n            throw (new Error());\n        }\n        else {\n            return BigInteger_negn_Z67CCE57D(BigNatModule_ofString(text_1.slice(1, (len - 1) + 1)));\n        }\n    }\n    else {\n        return BigInteger_posn_Z67CCE57D(BigNatModule_ofString(text_1));\n    }\n}\n\nexport function BigInteger__get_IsSmall(x) {\n    if (BigInteger__get_IsZero(x)) {\n        return true;\n    }\n    else {\n        return BigNatModule_isSmall(BigInteger__get_V(x));\n    }\n}\n\nexport function BigInteger_Factorial_Z665282C2(x) {\n    if (BigInteger__get_IsNegative(x)) {\n        throw (new Error(\"mustBeNonNegative\\\\nParameter name: x\"));\n    }\n    if (BigInteger__get_IsPositive(x)) {\n        return BigInteger_posn_Z67CCE57D(BigNatModule_factorial(BigInteger__get_V(x)));\n    }\n    else {\n        return BigInteger_get_One();\n    }\n}\n\nexport function BigInteger_op_UnaryPlus_Z665282C2(n1) {\n    return n1;\n}\n\nexport function BigInteger_FromInt64_Z524259C1(x) {\n    return BigInteger_$ctor_Z524259C1(x);\n}\n\nexport function BigInteger_FromInt32_Z524259A4(x) {\n    return BigInteger_$ctor_Z524259A4(x);\n}\n\n","import { BigInteger_op_Inequality_56F059C0, BigInteger_op_Equality_56F059C0, BigInteger_op_GreaterThanOrEqual_56F059C0, BigInteger_op_GreaterThan_56F059C0, BigInteger_op_LessThanOrEqual_56F059C0, BigInteger_op_LessThan_56F059C0, BigInteger_op_ExclusiveOr_56F059C0, BigInteger_op_BitwiseOr_56F059C0, BigInteger_op_BitwiseAnd_56F059C0, BigInteger_op_LeftShift_62E082A2, BigInteger_op_RightShift_62E082A2, BigInteger_op_UnaryPlus_Z665282C2, BigInteger_op_UnaryNegation_Z665282C2, BigInteger_op_Modulus_56F059C0, BigInteger_op_Division_56F059C0, BigInteger_op_Multiply_56F059C0, BigInteger_op_Subtraction_56F059C0, BigInteger_op_Addition_56F059C0, BigInteger__get_IsOne, BigInteger__get_IsZero, BigInteger__get_Sign, BigInteger__get_ToDecimal, BigInteger__get_ToDouble, BigInteger__get_ToSingle, BigInteger__get_ToUInt64, BigInteger__get_ToInt64, BigInteger__get_ToUInt32, BigInteger__get_ToInt32, BigInteger__get_ToUInt16, BigInteger__get_ToInt16, BigInteger__get_ToByte, BigInteger__get_ToSByte, BigInteger_$ctor_Z524259A4, BigInteger_$ctor_Z524259C1, BigInteger_get_Two, BigInteger_get_One, BigInteger_get_Zero, BigInteger_Abs_Z665282C2, BigInteger_Pow_62E082A2, BigInteger_GreatestCommonDivisor_56F059C0, BigInteger_DivRem_56F059C0, BigInteger_Parse_Z721C83C5, BigInteger } from \"./BigInt/z.js\";\nimport { fromInteger } from \"./Long.js\";\nimport { comparePrimitives, min, compare as compare_1, equals as equals_1, safeHash } from \"./Util.js\";\nimport { List, toString as toString_1 } from \"./Types.js\";\nimport { fold, head, skipWhile, ofSeq, find } from \"./List.js\";\nimport { unfold, delay, rangeNumber } from \"./Seq.js\";\nimport { fill, reverse } from \"./Array.js\";\n\nexport function isBigInt(x) {\n    return x instanceof BigInteger;\n}\n\nexport function tryParse(str, res) {\n    try {\n        res.contents = BigInteger_Parse_Z721C83C5(str);\n        return true;\n    }\n    catch (matchValue) {\n        return false;\n    }\n}\n\nexport function divRem(x, y, remainder) {\n    const patternInput = BigInteger_DivRem_56F059C0(x, y);\n    remainder.contents = patternInput[1];\n    return patternInput[0];\n}\n\nexport function parse(arg00) {\n    return BigInteger_Parse_Z721C83C5(arg00);\n}\n\nexport function greatestCommonDivisor(arg00, arg01) {\n    return BigInteger_GreatestCommonDivisor_56F059C0(arg00, arg01);\n}\n\nexport function pow(arg00, arg01) {\n    return BigInteger_Pow_62E082A2(arg00, arg01);\n}\n\nexport function abs(arg00) {\n    return BigInteger_Abs_Z665282C2(arg00);\n}\n\nexport const zero = BigInteger_get_Zero();\n\nexport const one = BigInteger_get_One();\n\nexport const two = BigInteger_get_Two();\n\nexport function fromString(s) {\n    return BigInteger_Parse_Z721C83C5(s);\n}\n\nexport function fromZero() {\n    return BigInteger_get_Zero();\n}\n\nexport function fromOne() {\n    return BigInteger_get_One();\n}\n\nexport function fromInt64(i) {\n    return BigInteger_$ctor_Z524259C1(i);\n}\n\nexport function fromInt32(i) {\n    if (i > 2147483647) {\n        return BigInteger_$ctor_Z524259C1(fromInteger(i, false, 6));\n    }\n    else {\n        return BigInteger_$ctor_Z524259A4(i);\n    }\n}\n\nexport function toSByte(x) {\n    return BigInteger__get_ToSByte(x);\n}\n\nexport function toByte(x) {\n    return BigInteger__get_ToByte(x);\n}\n\nexport function toInt16(x) {\n    return BigInteger__get_ToInt16(x);\n}\n\nexport function toUInt16(x) {\n    return BigInteger__get_ToUInt16(x);\n}\n\nexport function toInt32(x) {\n    return BigInteger__get_ToInt32(x);\n}\n\nexport function toUInt32(x) {\n    return BigInteger__get_ToUInt32(x);\n}\n\nexport function toInt64(x) {\n    return BigInteger__get_ToInt64(x);\n}\n\nexport function toUInt64(x) {\n    return BigInteger__get_ToUInt64(x);\n}\n\nexport function toSingle(x) {\n    return BigInteger__get_ToSingle(x);\n}\n\nexport function toDouble(x) {\n    return BigInteger__get_ToDouble(x);\n}\n\nexport function toDecimal(x) {\n    return BigInteger__get_ToDecimal(x);\n}\n\nexport function sign(x) {\n    return BigInteger__get_Sign(x);\n}\n\nexport function isZero(x) {\n    return BigInteger__get_IsZero(x);\n}\n\nexport function isOne(x) {\n    return BigInteger__get_IsOne(x);\n}\n\nexport function hash(x) {\n    return safeHash(x);\n}\n\nexport function compare(x, y) {\n    return x.CompareTo(y);\n}\n\nexport function equals(x, y) {\n    return equals_1(x, y);\n}\n\nexport function toString(x) {\n    return toString_1(x);\n}\n\nexport const get_Zero = BigInteger_get_Zero();\n\nexport const get_One = BigInteger_get_One();\n\nexport function op_Addition(arg00, arg01) {\n    return BigInteger_op_Addition_56F059C0(arg00, arg01);\n}\n\nexport function op_Subtraction(arg00, arg01) {\n    return BigInteger_op_Subtraction_56F059C0(arg00, arg01);\n}\n\nexport function op_Multiply(arg00, arg01) {\n    return BigInteger_op_Multiply_56F059C0(arg00, arg01);\n}\n\nexport function op_Division(arg00, arg01) {\n    return BigInteger_op_Division_56F059C0(arg00, arg01);\n}\n\nexport function op_Modulus(arg00, arg01) {\n    return BigInteger_op_Modulus_56F059C0(arg00, arg01);\n}\n\nexport function op_UnaryNegation(arg00) {\n    return BigInteger_op_UnaryNegation_Z665282C2(arg00);\n}\n\nexport function op_UnaryPlus(arg00) {\n    return BigInteger_op_UnaryPlus_Z665282C2(arg00);\n}\n\nexport function op_RightShift(arg00, arg01) {\n    return BigInteger_op_RightShift_62E082A2(arg00, arg01);\n}\n\nexport function op_LeftShift(arg00, arg01) {\n    return BigInteger_op_LeftShift_62E082A2(arg00, arg01);\n}\n\nexport function op_BitwiseAnd(arg00, arg01) {\n    return BigInteger_op_BitwiseAnd_56F059C0(arg00, arg01);\n}\n\nexport function op_BitwiseOr(arg00, arg01) {\n    return BigInteger_op_BitwiseOr_56F059C0(arg00, arg01);\n}\n\nexport function op_ExclusiveOr(arg00, arg01) {\n    return BigInteger_op_ExclusiveOr_56F059C0(arg00, arg01);\n}\n\nexport function op_LessThan(arg00, arg01) {\n    return BigInteger_op_LessThan_56F059C0(arg00, arg01);\n}\n\nexport function op_LessThanOrEqual(arg00, arg01) {\n    return BigInteger_op_LessThanOrEqual_56F059C0(arg00, arg01);\n}\n\nexport function op_GreaterThan(arg00, arg01) {\n    return BigInteger_op_GreaterThan_56F059C0(arg00, arg01);\n}\n\nexport function op_GreaterThanOrEqual(arg00, arg01) {\n    return BigInteger_op_GreaterThanOrEqual_56F059C0(arg00, arg01);\n}\n\nexport function op_Equality(arg00, arg01) {\n    return BigInteger_op_Equality_56F059C0(arg00, arg01);\n}\n\nexport function op_Inequality(arg00, arg01) {\n    return BigInteger_op_Inequality_56F059C0(arg00, arg01);\n}\n\nfunction flipTwosComplement(currByte, lowBitFound) {\n    const matchValue = [currByte, lowBitFound];\n    if (matchValue[1]) {\n        return [(currByte ^ 255) & 255, true];\n    }\n    else if (matchValue[0] === 0) {\n        return [0, false];\n    }\n    else {\n        return [(currByte ^ (254 << find((i) => ((currByte & (1 << i)) > 0), ofSeq(rangeNumber(0, 1, 7))))) & 255, true];\n    }\n}\n\nexport function toByteArray(value) {\n    if (equals_1(value, zero)) {\n        return new Uint8Array([0]);\n    }\n    else {\n        const isPositive = compare_1(value, zero) > 0;\n        const value_1 = isPositive ? value : BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value);\n        const mask32 = fromInt64(fromInteger(4294967295, false, 6));\n        const loop = (accumBytes_mut, consumeValue_mut, lowBitFound_mut) => {\n            let value_6, value_8, value_9, value_10;\n            loop:\n            while (true) {\n                const accumBytes = accumBytes_mut, consumeValue = consumeValue_mut, lowBitFound = lowBitFound_mut;\n                if (compare_1(consumeValue, zero) <= 0) {\n                    const accumBytes_1 = isPositive ? skipWhile((b) => (b === 0), accumBytes) : skipWhile((b_1) => (b_1 === 255), accumBytes);\n                    const isHighBitOne = (head(accumBytes_1) & 128) !== 0;\n                    return reverse(Uint8Array.from((isPositive ? isHighBitOne : false) ? (new List(0, accumBytes_1)) : (((!isPositive) ? (!isHighBitOne) : false) ? (new List(255, accumBytes_1)) : accumBytes_1)));\n                }\n                else {\n                    const currValue = toUInt32(BigInteger_op_BitwiseAnd_56F059C0(consumeValue, mask32));\n                    if (isPositive) {\n                        const b0 = currValue & 0xFF;\n                        let b1;\n                        const value_4 = currValue >>> 8;\n                        b1 = (value_4 & 0xFF);\n                        let b2;\n                        const value_5 = currValue >>> 16;\n                        b2 = (value_5 & 0xFF);\n                        accumBytes_mut = (new List((value_6 = (currValue >>> 24), value_6 & 0xFF), new List(b2, new List(b1, new List(b0, accumBytes)))));\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\n                        lowBitFound_mut = false;\n                        continue loop;\n                    }\n                    else {\n                        const patternInput = flipTwosComplement(currValue & 0xFF, lowBitFound);\n                        const patternInput_1 = flipTwosComplement((value_8 = (currValue >>> 8), value_8 & 0xFF), patternInput[1]);\n                        const patternInput_2 = flipTwosComplement((value_9 = (currValue >>> 16), value_9 & 0xFF), patternInput_1[1]);\n                        const patternInput_3 = flipTwosComplement((value_10 = (currValue >>> 24), value_10 & 0xFF), patternInput_2[1]);\n                        accumBytes_mut = (new List(patternInput_3[0], new List(patternInput_2[0], new List(patternInput_1[0], new List(patternInput[0], accumBytes)))));\n                        consumeValue_mut = BigInteger_op_RightShift_62E082A2(consumeValue, 32);\n                        lowBitFound_mut = patternInput_3[1];\n                        continue loop;\n                    }\n                }\n                break;\n            }\n        };\n        return loop(new List(), value_1, false);\n    }\n}\n\nexport function fromByteArray(bytes) {\n    if (bytes == null) {\n        throw (new Error(\"bytes\"));\n    }\n    if (bytes.length === 0) {\n        return zero;\n    }\n    else {\n        const isPositive = (bytes[bytes.length - 1] & 128) === 0;\n        const buffer = fill(new Uint8Array(4), 0, 4, 0);\n        const loop = (accumUInt32_mut, currIndex_mut, bytesRemaining_mut, lowBitFound_mut) => {\n            loop:\n            while (true) {\n                const accumUInt32 = accumUInt32_mut, currIndex = currIndex_mut, bytesRemaining = bytesRemaining_mut, lowBitFound = lowBitFound_mut;\n                if (bytesRemaining === 0) {\n                    const value_2 = fold((acc, value) => BigInteger_op_Addition_56F059C0(BigInteger_op_LeftShift_62E082A2(acc, 32), fromInt64(fromInteger(value, false, 6))), zero, accumUInt32);\n                    if (isPositive) {\n                        return value_2;\n                    }\n                    else {\n                        return BigInteger_op_Multiply_56F059C0(BigInteger_$ctor_Z524259A4(-1), value_2);\n                    }\n                }\n                else {\n                    const bytesToProcess = min((x, y) => comparePrimitives(x, y), bytesRemaining, 4) | 0;\n                    for (let i_1 = 0; i_1 <= (bytesToProcess - 1); i_1++) {\n                        buffer[i_1] = bytes[currIndex + i_1];\n                    }\n                    if (isPositive) {\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 0);\n                        accumUInt32_mut = (new List((((((buffer[0] | ((buffer[1] << 8) >>> 0)) >>> 0) | ((buffer[2] << 16) >>> 0)) >>> 0) | ((buffer[3] << 24) >>> 0)) >>> 0, accumUInt32));\n                        currIndex_mut = (currIndex + bytesToProcess);\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\n                        lowBitFound_mut = false;\n                        continue loop;\n                    }\n                    else {\n                        fill(buffer, bytesToProcess, 4 - bytesToProcess, 255);\n                        const patternInput = flipTwosComplement(buffer[0], lowBitFound);\n                        const patternInput_1 = flipTwosComplement(buffer[1], patternInput[1]);\n                        const patternInput_2 = flipTwosComplement(buffer[2], patternInput_1[1]);\n                        const patternInput_3 = flipTwosComplement(buffer[3], patternInput_2[1]);\n                        accumUInt32_mut = (new List((((((patternInput[0] | ((patternInput_1[0] << 8) >>> 0)) >>> 0) | ((patternInput_2[0] << 16) >>> 0)) >>> 0) | ((patternInput_3[0] << 24) >>> 0)) >>> 0, accumUInt32));\n                        currIndex_mut = (currIndex + bytesToProcess);\n                        bytesRemaining_mut = (bytesRemaining - bytesToProcess);\n                        lowBitFound_mut = patternInput_3[1];\n                        continue loop;\n                    }\n                }\n                break;\n            }\n        };\n        return loop(new List(), 0, bytes.length, false);\n    }\n}\n\nexport function makeRangeStepFunction(step, last) {\n    const stepComparedWithZero = compare_1(step, zero) | 0;\n    if (stepComparedWithZero === 0) {\n        throw (new Error(\"The step of a range cannot be zero\"));\n    }\n    const stepGreaterThanZero = stepComparedWithZero > 0;\n    return (x) => {\n        const comparedWithLast = compare_1(x, last) | 0;\n        return ((stepGreaterThanZero ? (comparedWithLast <= 0) : false) ? true : ((!stepGreaterThanZero) ? (comparedWithLast >= 0) : false)) ? [x, BigInteger_op_Addition_56F059C0(x, step)] : (void 0);\n    };\n}\n\nexport function range(first, step, last) {\n    const stepFn = makeRangeStepFunction(step, last);\n    return delay(() => unfold(stepFn, first));\n}\n\n","// tslint:disable:max-line-length\nimport { fromNumber, op_Division, op_Multiply, toNumber } from \"./Long.js\";\nimport { comparePrimitives, padLeftAndRightWithZeros, padWithZeros } from \"./Util.js\";\n// TimeSpan in runtime just becomes a number representing milliseconds\n/**\n * Calls:\n * - `Math.ceil` if the `value` is **negative**\n * - `Math.floor` if the `value` is **positive**\n * @param value Value to round\n */\nfunction signedRound(value) {\n    return value < 0 ? Math.ceil(value) : Math.floor(value);\n}\nexport function create(d = 0, h = 0, m = 0, s = 0, ms = 0) {\n    switch (arguments.length) {\n        case 1:\n            // ticks\n            return fromTicks(arguments[0]);\n        case 3:\n            // h,m,s\n            d = 0, h = arguments[0], m = arguments[1], s = arguments[2], ms = 0;\n            break;\n        default:\n            // d,h,m,s,ms\n            break;\n    }\n    return d * 86400000 + h * 3600000 + m * 60000 + s * 1000 + ms;\n}\nexport function fromTicks(ticks) {\n    return toNumber(op_Division(ticks, 10000));\n}\nexport function fromDays(d) {\n    return create(d, 0, 0, 0);\n}\nexport function fromHours(h) {\n    return create(h, 0, 0);\n}\nexport function fromMinutes(m) {\n    return create(0, m, 0);\n}\nexport function fromSeconds(s) {\n    return create(0, 0, s);\n}\nexport function days(ts) {\n    return signedRound(ts / 86400000);\n}\nexport function hours(ts) {\n    return signedRound(ts % 86400000 / 3600000);\n}\nexport function minutes(ts) {\n    return signedRound(ts % 3600000 / 60000);\n}\nexport function seconds(ts) {\n    return signedRound(ts % 60000 / 1000);\n}\nexport function milliseconds(ts) {\n    return signedRound(ts % 1000);\n}\nexport function ticks(ts) {\n    return op_Multiply(fromNumber(ts), 10000);\n}\nexport function totalDays(ts) {\n    return ts / 86400000;\n}\nexport function totalHours(ts) {\n    return ts / 3600000;\n}\nexport function totalMinutes(ts) {\n    return ts / 60000;\n}\nexport function totalSeconds(ts) {\n    return ts / 1000;\n}\nexport function negate(ts) {\n    return ts * -1;\n}\nexport function add(ts1, ts2) {\n    return ts1 + ts2;\n}\nexport function subtract(ts1, ts2) {\n    return ts1 - ts2;\n}\nexport const op_Addition = add;\nexport const op_Subtraction = subtract;\nexport const compare = comparePrimitives;\nexport const compareTo = comparePrimitives;\nexport function duration(x) {\n    return Math.abs(x);\n}\nexport function toString(ts, format = \"c\", _provider) {\n    if ([\"c\", \"g\", \"G\"].indexOf(format) === -1) {\n        throw new Error(\"Custom formats are not supported\");\n    }\n    const d = Math.abs(days(ts));\n    const h = Math.abs(hours(ts));\n    const m = Math.abs(minutes(ts));\n    const s = Math.abs(seconds(ts));\n    const ms = Math.abs(milliseconds(ts));\n    const sign = ts < 0 ? \"-\" : \"\";\n    return `${sign}${d === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"c\" ? d + \".\" : d + \":\"}${format === \"g\" ? h : padWithZeros(h, 2)}:${padWithZeros(m, 2)}:${padWithZeros(s, 2)}${ms === 0 && (format === \"c\" || format === \"g\") ? \"\" : format === \"g\" ? \".\" + padWithZeros(ms, 3) : \".\" + padLeftAndRightWithZeros(ms, 3, 7)}`;\n}\nexport function parse(str) {\n    const firstDot = str.search(\"\\\\.\");\n    const firstColon = str.search(\"\\\\:\");\n    if (firstDot === -1 && firstColon === -1) { // There is only a day ex: 4\n        const d = parseInt(str, 0);\n        if (isNaN(d)) {\n            throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n        }\n        else {\n            return create(d, 0, 0, 0, 0);\n        }\n    }\n    if (firstColon > 0) { // process time part\n        // WIP: (-?)(((\\d+)\\.)?([0-9]|0[0-9]|1[0-9]|2[0-3]):(\\d+)(:\\d+(\\.\\d{1,7})?)?|\\d+(?:(?!\\.)))\n        const r = /^(-?)((\\d+)\\.)?(?:0*)([0-9]|0[0-9]|1[0-9]|2[0-3]):(?:0*)([0-5][0-9]|[0-9])(:(?:0*)([0-5][0-9]|[0-9]))?\\.?(\\d+)?$/.exec(str);\n        if (r != null && r[4] != null && r[5] != null) {\n            let d = 0;\n            let ms = 0;\n            let s = 0;\n            const sign = r[1] != null && r[1] === \"-\" ? -1 : 1;\n            const h = +r[4];\n            const m = +r[5];\n            if (r[3] != null) {\n                d = +r[3];\n            }\n            if (r[7] != null) {\n                s = +r[7];\n            }\n            if (r[8] != null) {\n                // Depending on the number of decimals passed, we need to adapt the numbers\n                switch (r[8].length) {\n                    case 1:\n                        ms = +r[8] * 100;\n                        break;\n                    case 2:\n                        ms = +r[8] * 10;\n                        break;\n                    case 3:\n                        ms = +r[8];\n                        break;\n                    case 4:\n                        ms = +r[8] / 10;\n                        break;\n                    case 5:\n                        ms = +r[8] / 100;\n                        break;\n                    case 6:\n                        ms = +r[8] / 1000;\n                        break;\n                    case 7:\n                        ms = +r[8] / 10000;\n                        break;\n                    default:\n                        throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n                }\n            }\n            return sign * create(d, h, m, s, ms);\n        }\n    }\n    throw new Error(`String '${str}' was not recognized as a valid TimeSpan.`);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n","import { FSharpRef, Record, Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { record_type, class_type, tuple_type, lambda_type, union_type, list_type, obj_type, string_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { FSharpResult$2 } from \"../fable-library.3.1.4/Choice.js\";\r\nimport { addToDict, tryGetValue } from \"../fable-library.3.1.4/MapUtil.js\";\r\nimport { replace } from \"../fable-library.3.1.4/RegExp.js\";\r\n\r\nexport class ErrorReason extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"BadPrimitive\", \"BadPrimitiveExtra\", \"BadType\", \"BadField\", \"BadPath\", \"TooSmallArray\", \"FailMessage\", \"BadOneOf\"];\r\n    }\r\n}\r\n\r\nexport function ErrorReason$reflection() {\r\n    return union_type(\"Thoth.Json.ErrorReason\", [], ErrorReason, () => [[[\"Item1\", string_type], [\"Item2\", obj_type]], [[\"Item1\", string_type], [\"Item2\", obj_type], [\"Item3\", string_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]], [[\"Item1\", string_type], [\"Item2\", obj_type], [\"Item3\", string_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]], [[\"Item\", string_type]], [[\"Item\", list_type(string_type)]]]);\r\n}\r\n\r\nexport class CaseStrategy extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"PascalCase\", \"CamelCase\", \"SnakeCase\"];\r\n    }\r\n}\r\n\r\nexport function CaseStrategy$reflection() {\r\n    return union_type(\"Thoth.Json.CaseStrategy\", [], CaseStrategy, () => [[], [], []]);\r\n}\r\n\r\nexport class ExtraCoders extends Record {\r\n    constructor(Hash, Coders) {\r\n        super();\r\n        this.Hash = Hash;\r\n        this.Coders = Coders;\r\n    }\r\n}\r\n\r\nexport function ExtraCoders$reflection() {\r\n    return record_type(\"Thoth.Json.ExtraCoders\", [], ExtraCoders, () => [[\"Hash\", string_type], [\"Coders\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, tuple_type(lambda_type(obj_type, obj_type), lambda_type(string_type, lambda_type(obj_type, union_type(\"Microsoft.FSharp.Core.FSharpResult`2\", [obj_type, tuple_type(string_type, ErrorReason$reflection())], FSharpResult$2, () => [[[\"ResultValue\", obj_type]], [[\"ErrorValue\", tuple_type(string_type, ErrorReason$reflection())]]]))))])]]);\r\n}\r\n\r\nexport class Util_Cache$1 {\r\n    constructor() {\r\n        this.cache = (new Map([]));\r\n    }\r\n}\r\n\r\nexport function Util_Cache$1$reflection(gen0) {\r\n    return class_type(\"Thoth.Json.Util.Cache`1\", [gen0], Util_Cache$1);\r\n}\r\n\r\nexport function Util_Cache$1_$ctor() {\r\n    return new Util_Cache$1();\r\n}\r\n\r\nexport function Util_Cache$1__GetOrAdd_43981464(__, key, factory) {\r\n    let matchValue;\r\n    let outArg = null;\r\n    matchValue = [tryGetValue(__.cache, key, new FSharpRef(() => outArg, (v) => {\r\n        outArg = v;\r\n    })), outArg];\r\n    if (matchValue[0]) {\r\n        return matchValue[1];\r\n    }\r\n    else {\r\n        const x_1 = factory();\r\n        addToDict(__.cache, key, x_1);\r\n        return x_1;\r\n    }\r\n}\r\n\r\nexport const Util_CachedEncoders = Util_Cache$1_$ctor();\r\n\r\nexport const Util_CachedDecoders = Util_Cache$1_$ctor();\r\n\r\nexport function Util_Casing_lowerFirst(str) {\r\n    return str.slice(void 0, 0 + 1).toLowerCase() + str.slice(1, str.length);\r\n}\r\n\r\nexport function Util_Casing_convert(caseStrategy, fieldName) {\r\n    switch (caseStrategy.tag) {\r\n        case 2: {\r\n            return replace(Util_Casing_lowerFirst(fieldName), \"[A-Z]\", \"_$0\").toLowerCase();\r\n        }\r\n        case 0: {\r\n            return fieldName;\r\n        }\r\n        default: {\r\n            return Util_Casing_lowerFirst(fieldName);\r\n        }\r\n    }\r\n}\r\n\r\n","import { toString as toString_1 } from \"../fable-library.3.1.4/Decimal.js\";\r\nimport { mapIndexed, map as map_2, fold, getEnumerator } from \"../fable-library.3.1.4/Seq.js\";\r\nimport { empty, map as map_3, tryFind, add, toList } from \"../fable-library.3.1.4/Map.js\";\r\nimport { toString as toString_2 } from \"../fable-library.3.1.4/BigInt.js\";\r\nimport { toString as toString_3 } from \"../fable-library.3.1.4/Date.js\";\r\nimport { toString as toString_4 } from \"../fable-library.3.1.4/TimeSpan.js\";\r\nimport { Lazy, mapCurriedArgs, uncurry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { defaultArg, value as value_34, map, defaultArgWith, some } from \"../fable-library.3.1.4/Option.js\";\r\nimport { toString as toString_5, FSharpRef } from \"../fable-library.3.1.4/Types.js\";\r\nimport { class_type, getGenerics, getGenericTypeDefinition, getTupleFields, getTupleElements, isTuple, isGenericType, getEnumUnderlyingType, isEnum, getElementType, isArray, getUnionCaseFields, getUnionFields, isUnion, getRecordElements, getRecordField, name, isRecord, fullName } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { fill, map as map_1 } from \"../fable-library.3.1.4/Array.js\";\r\nimport { Util_CachedEncoders, Util_Cache$1__GetOrAdd_43981464, CaseStrategy, Util_Casing_convert } from \"./Types.fs.js\";\r\nimport { toFail, printf, toText } from \"../fable-library.3.1.4/String.js\";\r\n\r\nexport function guid(value) {\r\n    return value;\r\n}\r\n\r\nexport function decimal(value) {\r\n    return toString_1(value);\r\n}\r\n\r\nexport const nil = null;\r\n\r\nexport function object(values) {\r\n    const o = {};\r\n    const enumerator = getEnumerator(values);\r\n    try {\r\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\r\n            const forLoopVar = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\r\n            o[forLoopVar[0]] = forLoopVar[1];\r\n        }\r\n    }\r\n    finally {\r\n        enumerator.Dispose();\r\n    }\r\n    return o;\r\n}\r\n\r\nexport function list(values) {\r\n    return Array.from(values);\r\n}\r\n\r\nexport function seq(values) {\r\n    return Array.from(values);\r\n}\r\n\r\nexport function dict(values) {\r\n    return object(toList(values));\r\n}\r\n\r\nexport function bigint(value) {\r\n    return toString_2(value);\r\n}\r\n\r\nexport function datetimeOffset(value) {\r\n    return toString_3(value, \"O\", {});\r\n}\r\n\r\nexport function timespan(value) {\r\n    return toString_4(value);\r\n}\r\n\r\nexport function sbyte(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function byte(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function int16(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function uint16(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function int64(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function uint64(value) {\r\n    return String(value);\r\n}\r\n\r\nexport function unit() {\r\n    return null;\r\n}\r\n\r\nexport function tuple2(enc1, enc2, v1, v2) {\r\n    return [enc1(v1), enc2(v2)];\r\n}\r\n\r\nexport function tuple3(enc1, enc2, enc3, v1, v2, v3) {\r\n    return [enc1(v1), enc2(v2), enc3(v3)];\r\n}\r\n\r\nexport function tuple4(enc1, enc2, enc3, enc4, v1, v2, v3, v4) {\r\n    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4)];\r\n}\r\n\r\nexport function tuple5(enc1, enc2, enc3, enc4, enc5, v1, v2, v3, v4, v5) {\r\n    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5)];\r\n}\r\n\r\nexport function tuple6(enc1, enc2, enc3, enc4, enc5, enc6, v1, v2, v3, v4, v5, v6) {\r\n    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6)];\r\n}\r\n\r\nexport function tuple7(enc1, enc2, enc3, enc4, enc5, enc6, enc7, v1, v2, v3, v4, v5, v6, v7) {\r\n    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7)];\r\n}\r\n\r\nexport function tuple8(enc1, enc2, enc3, enc4, enc5, enc6, enc7, enc8, v1, v2, v3, v4, v5, v6, v7, v8) {\r\n    return [enc1(v1), enc2(v2), enc3(v3), enc4(v4), enc5(v5), enc6(v6), enc7(v7), enc8(v8)];\r\n}\r\n\r\nexport function Enum_byte(value) {\r\n    return byte(value);\r\n}\r\n\r\nexport function Enum_sbyte(value) {\r\n    return sbyte(value);\r\n}\r\n\r\nexport function Enum_int16(value) {\r\n    return int16(value);\r\n}\r\n\r\nexport function Enum_uint16(value) {\r\n    return uint16(value);\r\n}\r\n\r\nexport function Enum_int(value) {\r\n    return value;\r\n}\r\n\r\nexport function Enum_uint32(value) {\r\n    return value;\r\n}\r\n\r\nexport function datetime(value) {\r\n    return toString_3(value, \"O\", {});\r\n}\r\n\r\nexport function toString(space, value) {\r\n    return JSON.stringify(value, uncurry(2, null), some(space));\r\n}\r\n\r\nexport function option(encoder) {\r\n    return (arg) => defaultArgWith(map(encoder, arg), () => nil);\r\n}\r\n\r\nfunction autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t) {\r\n    const encoderRef = new FSharpRef(null);\r\n    const extra_1 = add(fullName(t), encoderRef, extra);\r\n    let encoder;\r\n    if (isRecord(t, true)) {\r\n        const setters = map_1((fi) => {\r\n            const targetKey = Util_Casing_convert(caseStrategy, name(fi));\r\n            const encode_1 = autoEncoder(extra_1, caseStrategy, skipNullField, fi[1]);\r\n            return (source) => ((target) => {\r\n                const value = getRecordField(source, fi);\r\n                if ((!skipNullField) ? true : (skipNullField ? (!(value == null)) : false)) {\r\n                    target[targetKey]=encode_1(value);\r\n                }\r\n                return target;\r\n            });\r\n        }, getRecordElements(t, true));\r\n        encoder = ((source_1) => fold(uncurry(2, mapCurriedArgs((target_1) => ((set$) => set$(source_1, target_1)), [0, [0, 2]])), {}, setters));\r\n    }\r\n    else if (isUnion(t, true)) {\r\n        encoder = ((value_1) => {\r\n            const patternInput = getUnionFields(value_1, t, true);\r\n            const info = patternInput[0];\r\n            const fields = patternInput[1];\r\n            const matchValue = fields.length | 0;\r\n            if (matchValue === 0) {\r\n                return name(info);\r\n            }\r\n            else {\r\n                const len = matchValue | 0;\r\n                const fieldTypes = getUnionCaseFields(info);\r\n                const target_2 = fill(new Array(len + 1), 0, len + 1, null);\r\n                target_2[0] = name(info);\r\n                for (let i = 1; i <= len; i++) {\r\n                    const encode_2 = autoEncoder(extra_1, caseStrategy, skipNullField, fieldTypes[i - 1][1]);\r\n                    target_2[i] = encode_2(fields[i - 1]);\r\n                }\r\n                return target_2;\r\n            }\r\n        });\r\n    }\r\n    else {\r\n        let message;\r\n        const arg10 = fullName(t);\r\n        message = toText(printf(\"Cannot generate auto encoder for %s. Please pass an extra encoder.\"))(arg10);\r\n        throw (new Error(message));\r\n    }\r\n    encoderRef.contents = encoder;\r\n    return encoder;\r\n}\r\n\r\nfunction autoEncoder(extra, caseStrategy, skipNullField, t) {\r\n    const fullname = fullName(t);\r\n    const matchValue = tryFind(fullname, extra);\r\n    if (matchValue == null) {\r\n        if (isArray(t)) {\r\n            const encoder = autoEncoder(extra, caseStrategy, skipNullField, getElementType(t));\r\n            return (value) => seq(map_2(encoder, value));\r\n        }\r\n        else if (isEnum(t)) {\r\n            const enumType = fullName(getEnumUnderlyingType(t));\r\n            if (enumType === \"System.SByte\") {\r\n                return (value_1) => sbyte(value_1);\r\n            }\r\n            else if (enumType === \"System.Byte\") {\r\n                return (value_2) => byte(value_2);\r\n            }\r\n            else if (enumType === \"System.Int16\") {\r\n                return (value_3) => int16(value_3);\r\n            }\r\n            else if (enumType === \"System.UInt16\") {\r\n                return (value_4) => uint16(value_4);\r\n            }\r\n            else if (enumType === \"System.Int32\") {\r\n                return (value_5) => value_5;\r\n            }\r\n            else if (enumType === \"System.UInt32\") {\r\n                return (value_7) => value_7;\r\n            }\r\n            else {\r\n                const arg10 = fullName(t);\r\n                const clo2 = toFail(printf(\"Cannot generate auto encoder for %s.\\nThoth.Json.Net only support the folluwing enum types:\\n- sbyte\\n- byte\\n- int16\\n- uint16\\n- int\\n- uint32\\nIf you can\\u0027t use one of these types, please pass an extra encoder.\\n                    \"))(arg10);\r\n                return (arg20) => clo2(arg20);\r\n            }\r\n        }\r\n        else if (isGenericType(t)) {\r\n            if (isTuple(t)) {\r\n                const encoders = map_1((t_2) => autoEncoder(extra, caseStrategy, skipNullField, t_2), getTupleElements(t));\r\n                return (value_9) => seq(mapIndexed((i, x) => encoders[i](x), getTupleFields(value_9)));\r\n            }\r\n            else {\r\n                const fullname_1 = fullName(getGenericTypeDefinition(t));\r\n                if (fullname_1 === \"Microsoft.FSharp.Core.FSharpOption`1[System.Object]\") {\r\n                    const encoder_2 = new Lazy(() => option(autoEncoder(extra, caseStrategy, skipNullField, getGenerics(t)[0])));\r\n                    return (value_10) => {\r\n                        if (value_10 == null) {\r\n                            return nil;\r\n                        }\r\n                        else {\r\n                            return encoder_2.Value(value_10);\r\n                        }\r\n                    };\r\n                }\r\n                else if ((fullname_1 === \"Microsoft.FSharp.Collections.FSharpList`1[System.Object]\") ? true : (fullname_1 === \"Microsoft.FSharp.Collections.FSharpSet`1[System.Object]\")) {\r\n                    const encoder_3 = autoEncoder(extra, caseStrategy, skipNullField, getGenerics(t)[0]);\r\n                    return (value_11) => seq(map_2(encoder_3, value_11));\r\n                }\r\n                else if (fullname_1 === \"Microsoft.FSharp.Collections.FSharpMap`2[System.Object,System.Object]\") {\r\n                    const keyType = getGenerics(t)[0];\r\n                    const valueEncoder = autoEncoder(extra, caseStrategy, skipNullField, getGenerics(t)[1]);\r\n                    if ((fullName(keyType) === \"System.String\") ? true : (fullName(keyType) === \"System.Guid\")) {\r\n                        return (value_12) => fold((target, _arg1) => {\r\n                            const activePatternResult3410 = _arg1;\r\n                            target[activePatternResult3410[0]]=valueEncoder(activePatternResult3410[1]);\r\n                            return target;\r\n                        }, {}, value_12);\r\n                    }\r\n                    else {\r\n                        let keyEncoder;\r\n                        const clo4 = autoEncoder(extra, caseStrategy, skipNullField, keyType);\r\n                        keyEncoder = ((arg40) => clo4(arg40));\r\n                        return (value_13) => seq(map_2((_arg2) => {\r\n                            const activePatternResult3414 = _arg2;\r\n                            return [keyEncoder(activePatternResult3414[0]), valueEncoder(activePatternResult3414[1])];\r\n                        }, value_13));\r\n                    }\r\n                }\r\n                else {\r\n                    return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);\r\n                }\r\n            }\r\n        }\r\n        else if (fullname === \"System.Boolean\") {\r\n            return (value_14) => value_14;\r\n        }\r\n        else if (fullname === \"Microsoft.FSharp.Core.Unit\") {\r\n            return unit;\r\n        }\r\n        else if (fullname === \"System.String\") {\r\n            return (value_16) => value_16;\r\n        }\r\n        else if (fullname === \"System.SByte\") {\r\n            return (value_18) => sbyte(value_18);\r\n        }\r\n        else if (fullname === \"System.Byte\") {\r\n            return (value_19) => byte(value_19);\r\n        }\r\n        else if (fullname === \"System.Int16\") {\r\n            return (value_20) => int16(value_20);\r\n        }\r\n        else if (fullname === \"System.UInt16\") {\r\n            return (value_21) => uint16(value_21);\r\n        }\r\n        else if (fullname === \"System.Int32\") {\r\n            return (value_22) => value_22;\r\n        }\r\n        else if (fullname === \"System.UInt32\") {\r\n            return (value_24) => value_24;\r\n        }\r\n        else if (fullname === \"System.Double\") {\r\n            return (value_26) => value_26;\r\n        }\r\n        else if (fullname === \"System.Single\") {\r\n            return (value_28) => value_28;\r\n        }\r\n        else if (fullname === \"System.DateTime\") {\r\n            return (value_30) => datetime(value_30);\r\n        }\r\n        else if (fullname === \"System.DateTimeOffset\") {\r\n            return (value_31) => datetimeOffset(value_31);\r\n        }\r\n        else if (fullname === \"System.TimeSpan\") {\r\n            return (value_32) => timespan(value_32);\r\n        }\r\n        else if (fullname === \"System.Guid\") {\r\n            return (value_33) => guid(value_33);\r\n        }\r\n        else if (fullname === \"System.Object\") {\r\n            return (x_1) => x_1;\r\n        }\r\n        else {\r\n            return autoEncodeRecordsAndUnions(extra, caseStrategy, skipNullField, t);\r\n        }\r\n    }\r\n    else {\r\n        const encoderRef = matchValue;\r\n        return (v) => encoderRef.contents(v);\r\n    }\r\n}\r\n\r\nfunction makeExtra(extra) {\r\n    if (extra != null) {\r\n        return map_3((_arg2, tupledArg) => (new FSharpRef(tupledArg[0])), extra.Coders);\r\n    }\r\n    else {\r\n        return empty();\r\n    }\r\n}\r\n\r\nexport class Auto {\r\n    constructor() {\r\n    }\r\n}\r\n\r\nexport function Auto$reflection() {\r\n    return class_type(\"Thoth.Json.Encode.Auto\", void 0, Auto);\r\n}\r\n\r\nexport function Auto_generateEncoderCached_Z127D9D79(caseStrategy, extra, skipNullField, resolver) {\r\n    let y_1, y;\r\n    const t = value_34(resolver).ResolveType();\r\n    const caseStrategy_1 = defaultArg(caseStrategy, new CaseStrategy(0));\r\n    const skipNullField_1 = defaultArg(skipNullField, true);\r\n    return Util_Cache$1__GetOrAdd_43981464(Util_CachedEncoders, (y_1 = (y = fullName(t), toString_5(caseStrategy_1) + y), defaultArg(map((e) => e.Hash, extra), \"\") + y_1), () => autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t));\r\n}\r\n\r\nexport function Auto_generateEncoder_Z127D9D79(caseStrategy, extra, skipNullField, resolver) {\r\n    const caseStrategy_1 = defaultArg(caseStrategy, new CaseStrategy(0));\r\n    const skipNullField_1 = defaultArg(skipNullField, true);\r\n    const t = value_34(resolver).ResolveType();\r\n    return autoEncoder(makeExtra(extra), caseStrategy_1, skipNullField_1, t);\r\n}\r\n\r\nexport function Auto_toString_5A41365E(space, value, caseStrategy, extra, skipNullField, resolver) {\r\n    return toString(space, Auto_generateEncoder_Z127D9D79(caseStrategy, extra, skipNullField, resolver)(value));\r\n}\r\n\r\nexport function encode(space, value) {\r\n    return toString(space, value);\r\n}\r\n\r\n","import { trim } from \"./String.js\";\n// RFC 4122 compliant. From https://stackoverflow.com/a/13653180/3922220\n// const guidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;\n// Relax GUID parsing, see #1637\nconst guidRegex = /^[\\(\\{]{0,2}[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}[\\)\\}]{0,2}$/;\nconst guidRegexNoHyphen = /^([0-9a-f]{8})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{4})([0-9a-f]{12})$/;\nconst guidRegexHex = /^\\{0x[0-9a-f]{8},(0x[0-9a-f]{4},){2}\\{(0x[0-9a-f]{2},){7}0x[0-9a-f]{2}\\}\\}$/;\nconst guidHexCaptures = /^([0-9a-f]{8})-(([0-9a-f]{4})-)(([0-9a-f]{4})-)([0-9a-f]{2})([0-9a-f]{2})-([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/;\nexport function toString(str, format, _provider) {\n    if (format && (format === null || format === void 0 ? void 0 : format.length) > 0) {\n        switch (format) {\n            case \"N\":\n                return str.replace(/-/g, '');\n            case \"D\":\n                return str;\n            case \"B\":\n                return \"{\" + str + \"}\";\n            case \"P\":\n                return \"(\" + str + \")\";\n            case \"X\":\n                return str.replace(guidHexCaptures, \"{0x$1,0x$3,0x$5,{0x$6,0x$7,0x$8,0x$9,0x$10,0x$11,0x$12,0x$13}}\");\n            default:\n                throw new Error(\"Unrecognized Guid print format\");\n        }\n    }\n    else {\n        return str;\n    }\n}\n/** Validates UUID as specified in RFC4122 (versions 1-5). */\nexport function parse(str) {\n    function hyphenateGuid(str) {\n        return str.replace(guidRegexNoHyphen, \"$1-$2-$3-$4-$5\");\n    }\n    const wsTrimAndLowered = str.trim().toLowerCase();\n    if (guidRegex.test(wsTrimAndLowered)) {\n        return trim(wsTrimAndLowered, \"{\", \"}\", \"(\", \")\");\n    }\n    else if (guidRegexNoHyphen.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered);\n    }\n    else if (guidRegexHex.test(wsTrimAndLowered)) {\n        return hyphenateGuid(wsTrimAndLowered.replace(/[\\{\\},]|0x/g, ''));\n    }\n    else {\n        throw new Error(\"Guid should contain 32 digits with 4 dashes: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\");\n    }\n}\nexport function tryParse(str, defValue) {\n    try {\n        defValue.contents = parse(str);\n        return true;\n    }\n    catch (_a) {\n        return false;\n    }\n}\n// From https://gist.github.com/LeverOne/1308368\nexport function newGuid() {\n    let b = \"\";\n    for (let a = 0; a++ < 36;) {\n        b += a * 51 & 52\n            ? (a ^ 15 ? 8 ^ Math.random() * (a ^ 20 ? 16 : 4) : 4).toString(16)\n            : \"-\";\n    }\n    return b;\n}\n// Maps for number <-> hex string conversion\nlet _convertMapsInitialized = false;\nlet _byteToHex;\nlet _hexToByte;\nfunction initConvertMaps() {\n    _byteToHex = new Array(256);\n    _hexToByte = {};\n    for (let i = 0; i < 256; i++) {\n        _byteToHex[i] = (i + 0x100).toString(16).substr(1);\n        _hexToByte[_byteToHex[i]] = i;\n    }\n    _convertMapsInitialized = true;\n}\n/** Parse a UUID into it's component bytes */\n// Adapted from https://github.com/zefferus/uuid-parse\nexport function guidToArray(s) {\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    let i = 0;\n    const buf = new Uint8Array(16);\n    s.toLowerCase().replace(/[0-9a-f]{2}/g, ((oct) => {\n        switch (i) {\n            // .NET saves first three byte groups with different endianness\n            // See https://stackoverflow.com/a/16722909/3922220\n            case 0:\n            case 1:\n            case 2:\n            case 3:\n                buf[3 - i++] = _hexToByte[oct];\n                break;\n            case 4:\n            case 5:\n                buf[9 - i++] = _hexToByte[oct];\n                break;\n            case 6:\n            case 7:\n                buf[13 - i++] = _hexToByte[oct];\n                break;\n            case 8:\n            case 9:\n            case 10:\n            case 11:\n            case 12:\n            case 13:\n            case 14:\n            case 15:\n                buf[i++] = _hexToByte[oct];\n                break;\n        }\n    }));\n    // Zero out remaining bytes if string was short\n    while (i < 16) {\n        buf[i++] = 0;\n    }\n    return buf;\n}\n/** Convert UUID byte array into a string */\nexport function arrayToGuid(buf) {\n    if (buf.length !== 16) {\n        throw new Error(\"Byte array for GUID must be exactly 16 bytes long\");\n    }\n    if (!_convertMapsInitialized) {\n        initConvertMaps();\n    }\n    const guid = _byteToHex[buf[3]] + _byteToHex[buf[2]] +\n        _byteToHex[buf[1]] + _byteToHex[buf[0]] + \"-\" +\n        _byteToHex[buf[5]] + _byteToHex[buf[4]] + \"-\" +\n        _byteToHex[buf[7]] + _byteToHex[buf[6]] + \"-\" +\n        _byteToHex[buf[8]] + _byteToHex[buf[9]] + \"-\" +\n        _byteToHex[buf[10]] + _byteToHex[buf[11]] +\n        _byteToHex[buf[12]] + _byteToHex[buf[13]] +\n        _byteToHex[buf[14]] + _byteToHex[buf[15]];\n    return guid;\n}\n","/**\n * DateTimeOffset functions.\n *\n * Note: DateOffset instances are always DateObjects in local\n * timezone (because JS dates are all kinds of messed up).\n * A local date returns UTC epoc when `.getTime()` is called.\n *\n * However, this means that in order to construct an UTC date\n * from a DateOffset with offset of +5 hours, you first need\n * to subtract those 5 hours, than add the \"local\" offset.\n * As said, all kinds of messed up.\n *\n * Basically; invariant: date.getTime() always return UTC time.\n */\nimport { create as createDate, dateOffsetToString, daysInMonth, offsetRegex, parseRaw } from \"./Date.js\";\nimport { fromValue, ticksToUnixEpochMilliseconds, unixEpochMillisecondsToTicks } from \"./Long.js\";\nimport { compareDates, padWithZeros } from \"./Util.js\";\nexport default function DateTimeOffset(value, offset) {\n    const d = new Date(value);\n    d.offset = offset != null ? offset : new Date().getTimezoneOffset() * -60000;\n    return d;\n}\nexport function fromDate(date, offset) {\n    const isUtc = date.kind === 1 /* UTC */;\n    const offset2 = isUtc ? 0 : date.getTimezoneOffset() * -60000;\n    if (offset != null && offset !== offset2) {\n        throw new Error(isUtc\n            ? \"The UTC Offset for Utc DateTime instances must be 0.\"\n            : \"The UTC Offset of the local dateTime parameter does not match the offset argument.\");\n    }\n    return DateTimeOffset(date.getTime(), offset2);\n}\nexport function fromTicks(ticks, offset) {\n    ticks = fromValue(ticks);\n    const epoc = ticksToUnixEpochMilliseconds(ticks) - offset;\n    return DateTimeOffset(epoc, offset);\n}\nexport function getUtcTicks(date) {\n    return unixEpochMillisecondsToTicks(date.getTime(), 0);\n}\nexport function minValue() {\n    // This is \"0001-01-01T00:00:00.000Z\", actual JS min value is -8640000000000000\n    return DateTimeOffset(-62135596800000, 0);\n}\nexport function maxValue() {\n    // This is \"9999-12-31T23:59:59.999Z\", actual JS max value is 8640000000000000\n    return DateTimeOffset(253402300799999, 0);\n}\nexport function parse(str) {\n    const date = parseRaw(str);\n    const offsetMatch = offsetRegex.exec(str);\n    const offset = offsetMatch == null\n        ? date.getTimezoneOffset() * -60000\n        : (offsetMatch[0] === \"Z\"\n            ? 0\n            : parseInt(offsetMatch[1], 10) * 3600000\n                + parseInt(offsetMatch[2], 10) * 60000);\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function tryParse(v, defValue) {\n    try {\n        defValue.contents = parse(v);\n        return true;\n    }\n    catch (_err) {\n        return false;\n    }\n}\nexport function create(year, month, day, h, m, s, ms, offset) {\n    if (offset == null) {\n        offset = ms;\n        ms = 0;\n    }\n    if (offset !== 0) {\n        if (offset % 60000 !== 0) {\n            throw new Error(\"Offset must be specified in whole minutes\");\n        }\n        if (~~(offset / 3600000) > 14) {\n            throw new Error(\"Offset must be within plus or minus 14 hour\");\n        }\n    }\n    let date;\n    if (offset === 0) {\n        date = new Date(Date.UTC(year, month - 1, day, h, m, s, ms));\n        if (year <= 99) {\n            date.setFullYear(year, month - 1, day);\n        }\n    }\n    else {\n        const str = padWithZeros(year, 4) + \"-\" +\n            padWithZeros(month, 2) + \"-\" +\n            padWithZeros(day, 2) + \"T\" +\n            padWithZeros(h, 2) + \":\" +\n            padWithZeros(m, 2) + \":\" +\n            padWithZeros(s, 2) + \".\" +\n            padWithZeros(ms, 3) +\n            dateOffsetToString(offset);\n        date = new Date(str);\n    }\n    const dateValue = date.getTime();\n    if (isNaN(dateValue)) {\n        throw new Error(\"The parameters describe an unrepresentable Date\");\n    }\n    return DateTimeOffset(dateValue, offset);\n}\nexport function now() {\n    const date = new Date();\n    const offset = date.getTimezoneOffset() * -60000;\n    return DateTimeOffset(date.getTime(), offset);\n}\nexport function utcNow() {\n    const date = now();\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toUniversalTime(date) {\n    return DateTimeOffset(date.getTime(), 0);\n}\nexport function toLocalTime(date) {\n    return DateTimeOffset(date.getTime(), date.getTimezoneOffset() * -60000);\n}\nexport function timeOfDay(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return d2.getUTCHours() * 3600000\n        + d2.getUTCMinutes() * 60000\n        + d2.getUTCSeconds() * 1000\n        + d2.getUTCMilliseconds();\n}\nexport function date(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    return createDate(d2.getUTCFullYear(), d2.getUTCMonth() + 1, d2.getUTCDate(), 0, 0, 0, 0);\n}\nexport function day(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDate();\n}\nexport function hour(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCHours();\n}\nexport function millisecond(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMilliseconds();\n}\nexport function minute(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMinutes();\n}\nexport function month(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCMonth() + 1;\n}\nexport function second(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCSeconds();\n}\nexport function year(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCFullYear();\n}\nexport function dayOfWeek(d) {\n    var _a;\n    return new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0)).getUTCDay();\n}\nexport function dayOfYear(d) {\n    var _a;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    const _year = d2.getUTCFullYear();\n    const _month = d2.getUTCMonth() + 1;\n    let _day = d2.getUTCDate();\n    for (let i = 1; i < _month; i++) {\n        _day += daysInMonth(_year, i);\n    }\n    return _day;\n}\nexport function add(d, ts) {\n    var _a;\n    return DateTimeOffset(d.getTime() + ts, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addDays(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 86400000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addHours(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 3600000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMinutes(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 60000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addSeconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v * 1000, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMilliseconds(d, v) {\n    var _a;\n    return DateTimeOffset(d.getTime() + v, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addYears(d, v) {\n    var _a;\n    const newMonth = d.getUTCMonth() + 1;\n    const newYear = d.getUTCFullYear() + v;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d.getUTCDate());\n    return create(newYear, newMonth, newDay, d.getUTCHours(), d.getUTCMinutes(), d.getUTCSeconds(), d.getUTCMilliseconds(), ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n}\nexport function addMonths(d, v) {\n    var _a, _b;\n    const d2 = new Date(d.getTime() + ((_a = d.offset) !== null && _a !== void 0 ? _a : 0));\n    let newMonth = d2.getUTCMonth() + 1 + v;\n    let newMonth_ = 0;\n    let yearOffset = 0;\n    if (newMonth > 12) {\n        newMonth_ = newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12);\n        newMonth = newMonth_;\n    }\n    else if (newMonth < 1) {\n        newMonth_ = 12 + newMonth % 12;\n        yearOffset = Math.floor(newMonth / 12) + (newMonth_ === 12 ? -1 : 0);\n        newMonth = newMonth_;\n    }\n    const newYear = d2.getUTCFullYear() + yearOffset;\n    const _daysInMonth = daysInMonth(newYear, newMonth);\n    const newDay = Math.min(_daysInMonth, d2.getUTCDate());\n    return create(newYear, newMonth, newDay, d2.getUTCHours(), d2.getUTCMinutes(), d2.getUTCSeconds(), d2.getUTCMilliseconds(), ((_b = d.offset) !== null && _b !== void 0 ? _b : 0));\n}\nexport function subtract(d, that) {\n    var _a;\n    return typeof that === \"number\"\n        ? DateTimeOffset(d.getTime() - that, ((_a = d.offset) !== null && _a !== void 0 ? _a : 0))\n        : d.getTime() - that.getTime();\n}\nexport function equals(d1, d2) {\n    return d1.getTime() === d2.getTime();\n}\nexport function equalsExact(d1, d2) {\n    return d1.getTime() === d2.getTime() && d1.offset === d2.offset;\n}\nexport function compare(d1, d2) {\n    return compareDates(d1, d2);\n}\nexport const compareTo = compare;\nexport function op_Addition(x, y) {\n    return add(x, y);\n}\nexport function op_Subtraction(x, y) {\n    return subtract(x, y);\n}\n","import { record_type, bool_type, list_type, option_type, class_type } from \"./Reflection.js\";\nimport { some, value as value_1 } from \"./Option.js\";\nimport { toString, List, Record } from \"./Types.js\";\nimport { singleton as singleton_1, collect, empty as empty_1, delay, fold as fold_2, reduce, iterate as iterate_1, toIterator, map as map_1, getEnumerator } from \"./Seq.js\";\nimport { fold as fold_1 } from \"./Array.js\";\nimport { join } from \"./String.js\";\nimport { structuralHash } from \"./Util.js\";\nimport { HashSet__Add_2B595, HashSet_$ctor_Z6150332D } from \"./MutableSet.js\";\n\nexport class SetTreeLeaf$1 {\n    constructor(k) {\n        this.k = k;\n    }\n}\n\nexport function SetTreeLeaf$1$reflection(gen0) {\n    return class_type(\"Set.SetTreeLeaf`1\", [gen0], SetTreeLeaf$1);\n}\n\nexport function SetTreeLeaf$1_$ctor_2B595(k) {\n    return new SetTreeLeaf$1(k);\n}\n\nexport function SetTreeLeaf$1__get_Key(_) {\n    return _.k;\n}\n\nexport class SetTreeNode$1 extends SetTreeLeaf$1 {\n    constructor(v, left, right, h) {\n        super(v);\n        this.left = left;\n        this.right = right;\n        this.h = h;\n    }\n}\n\nexport function SetTreeNode$1$reflection(gen0) {\n    return class_type(\"Set.SetTreeNode`1\", [gen0], SetTreeNode$1, SetTreeLeaf$1$reflection(gen0));\n}\n\nexport function SetTreeNode$1_$ctor_Z6E7BE5F7(v, left, right, h) {\n    return new SetTreeNode$1(v, left, right, h);\n}\n\nexport function SetTreeNode$1__get_Left(_) {\n    return _.left;\n}\n\nexport function SetTreeNode$1__get_Right(_) {\n    return _.right;\n}\n\nexport function SetTreeNode$1__get_Height(_) {\n    return _.h;\n}\n\nexport function SetTreeModule_empty() {\n    return void 0;\n}\n\nexport function SetTreeModule_countAux(t_mut, acc_mut) {\n    SetTreeModule_countAux:\n    while (true) {\n        const t = t_mut, acc = acc_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                t_mut = SetTreeNode$1__get_Left(t2);\n                acc_mut = SetTreeModule_countAux(SetTreeNode$1__get_Right(t2), acc + 1);\n                continue SetTreeModule_countAux;\n            }\n            else {\n                return (acc + 1) | 0;\n            }\n        }\n        else {\n            return acc | 0;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_count(s) {\n    return SetTreeModule_countAux(s, 0);\n}\n\nexport function SetTreeModule_mk(l, k, r) {\n    let hl;\n    const t = l;\n    if (t != null) {\n        const t2 = t;\n        hl = ((t2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2) : 1);\n    }\n    else {\n        hl = 0;\n    }\n    let hr;\n    const t_1 = r;\n    if (t_1 != null) {\n        const t2_1 = t_1;\n        hr = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\n    }\n    else {\n        hr = 0;\n    }\n    const m = ((hl < hr) ? hr : hl) | 0;\n    if (m === 0) {\n        return SetTreeLeaf$1_$ctor_2B595(k);\n    }\n    else {\n        return SetTreeNode$1_$ctor_Z6E7BE5F7(k, l, r, m + 1);\n    }\n}\n\nexport function SetTreeModule_rebalance(t1, v, t2) {\n    let t_2, t2_3, t_3, t2_4;\n    let t1h;\n    const t = t1;\n    if (t != null) {\n        const t2_1 = t;\n        t1h = ((t2_1 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_1) : 1);\n    }\n    else {\n        t1h = 0;\n    }\n    let t2h;\n    const t_1 = t2;\n    if (t_1 != null) {\n        const t2_2 = t_1;\n        t2h = ((t2_2 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_2) : 1);\n    }\n    else {\n        t2h = 0;\n    }\n    if (t2h > (t1h + 2)) {\n        const matchValue = value_1(t2);\n        if (matchValue instanceof SetTreeNode$1) {\n            if ((t_2 = SetTreeNode$1__get_Left(matchValue), (t_2 != null) ? (t2_3 = t_2, (t2_3 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_3) : 1) : 0) > (t1h + 1)) {\n                const matchValue_1 = value_1(SetTreeNode$1__get_Left(matchValue));\n                if (matchValue_1 instanceof SetTreeNode$1) {\n                    return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue_1)), SetTreeLeaf$1__get_Key(matchValue_1), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_1), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue)));\n                }\n                else {\n                    throw (new Error(\"internal error: Set.rebalance\"));\n                }\n            }\n            else {\n                return SetTreeModule_mk(SetTreeModule_mk(t1, v, SetTreeNode$1__get_Left(matchValue)), SetTreeLeaf$1__get_Key(matchValue), SetTreeNode$1__get_Right(matchValue));\n            }\n        }\n        else {\n            throw (new Error(\"internal error: Set.rebalance\"));\n        }\n    }\n    else if (t1h > (t2h + 2)) {\n        const matchValue_2 = value_1(t1);\n        if (matchValue_2 instanceof SetTreeNode$1) {\n            if ((t_3 = SetTreeNode$1__get_Right(matchValue_2), (t_3 != null) ? (t2_4 = t_3, (t2_4 instanceof SetTreeNode$1) ? SetTreeNode$1__get_Height(t2_4) : 1) : 0) > (t2h + 1)) {\n                const matchValue_3 = value_1(SetTreeNode$1__get_Right(matchValue_2));\n                if (matchValue_3 instanceof SetTreeNode$1) {\n                    return SetTreeModule_mk(SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeNode$1__get_Left(matchValue_3)), SetTreeLeaf$1__get_Key(matchValue_3), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_3), v, t2));\n                }\n                else {\n                    throw (new Error(\"internal error: Set.rebalance\"));\n                }\n            }\n            else {\n                return SetTreeModule_mk(SetTreeNode$1__get_Left(matchValue_2), SetTreeLeaf$1__get_Key(matchValue_2), SetTreeModule_mk(SetTreeNode$1__get_Right(matchValue_2), v, t2));\n            }\n        }\n        else {\n            throw (new Error(\"internal error: Set.rebalance\"));\n        }\n    }\n    else {\n        return SetTreeModule_mk(t1, v, t2);\n    }\n}\n\nexport function SetTreeModule_add(comparer, k, t) {\n    if (t != null) {\n        const t2 = t;\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\n        if (t2 instanceof SetTreeNode$1) {\n            if (c < 0) {\n                return SetTreeModule_rebalance(SetTreeModule_add(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\n            }\n            else if (c === 0) {\n                return t;\n            }\n            else {\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_add(comparer, k, SetTreeNode$1__get_Right(t2)));\n            }\n        }\n        else {\n            const c_1 = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\n            if (c_1 < 0) {\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, SetTreeModule_empty(), t, 2);\n            }\n            else if (c_1 === 0) {\n                return t;\n            }\n            else {\n                return SetTreeNode$1_$ctor_Z6E7BE5F7(k, t, SetTreeModule_empty(), 2);\n            }\n        }\n    }\n    else {\n        return SetTreeLeaf$1_$ctor_2B595(k);\n    }\n}\n\nexport function SetTreeModule_balance(comparer, t1, k, t2) {\n    if (t1 != null) {\n        const t1$0027 = t1;\n        if (t2 != null) {\n            const t2$0027 = t2;\n            if (t1$0027 instanceof SetTreeNode$1) {\n                if (t2$0027 instanceof SetTreeNode$1) {\n                    if ((SetTreeNode$1__get_Height(t1$0027) + 2) < SetTreeNode$1__get_Height(t2$0027)) {\n                        return SetTreeModule_rebalance(SetTreeModule_balance(comparer, t1, k, SetTreeNode$1__get_Left(t2$0027)), SetTreeLeaf$1__get_Key(t2$0027), SetTreeNode$1__get_Right(t2$0027));\n                    }\n                    else if ((SetTreeNode$1__get_Height(t2$0027) + 2) < SetTreeNode$1__get_Height(t1$0027)) {\n                        return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t1$0027), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_balance(comparer, SetTreeNode$1__get_Right(t1$0027), k, t2));\n                    }\n                    else {\n                        return SetTreeModule_mk(t1, k, t2);\n                    }\n                }\n                else {\n                    return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1));\n                }\n            }\n            else {\n                return SetTreeModule_add(comparer, k, SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2));\n            }\n        }\n        else {\n            return SetTreeModule_add(comparer, k, t1);\n        }\n    }\n    else {\n        return SetTreeModule_add(comparer, k, t2);\n    }\n}\n\nexport function SetTreeModule_split(comparer, pivot, t) {\n    if (t != null) {\n        const t2 = t;\n        if (t2 instanceof SetTreeNode$1) {\n            const c = comparer.Compare(pivot, SetTreeLeaf$1__get_Key(t2)) | 0;\n            if (c < 0) {\n                const patternInput = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Left(t2));\n                return [patternInput[0], patternInput[1], SetTreeModule_balance(comparer, patternInput[2], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\n            }\n            else if (c === 0) {\n                return [SetTreeNode$1__get_Left(t2), true, SetTreeNode$1__get_Right(t2)];\n            }\n            else {\n                const patternInput_1 = SetTreeModule_split(comparer, pivot, SetTreeNode$1__get_Right(t2));\n                return [SetTreeModule_balance(comparer, SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), patternInput_1[0]), patternInput_1[1], patternInput_1[2]];\n            }\n        }\n        else {\n            const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(t2), pivot) | 0;\n            if (c_1 < 0) {\n                return [t, false, SetTreeModule_empty()];\n            }\n            else if (c_1 === 0) {\n                return [SetTreeModule_empty(), true, SetTreeModule_empty()];\n            }\n            else {\n                return [SetTreeModule_empty(), false, t];\n            }\n        }\n    }\n    else {\n        return [SetTreeModule_empty(), false, SetTreeModule_empty()];\n    }\n}\n\nexport function SetTreeModule_spliceOutSuccessor(t) {\n    if (t != null) {\n        const t2 = t;\n        if (t2 instanceof SetTreeNode$1) {\n            if (SetTreeNode$1__get_Left(t2) == null) {\n                return [SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2)];\n            }\n            else {\n                const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Left(t2));\n                return [patternInput[0], SetTreeModule_mk(patternInput[1], SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2))];\n            }\n        }\n        else {\n            return [SetTreeLeaf$1__get_Key(t2), SetTreeModule_empty()];\n        }\n    }\n    else {\n        throw (new Error(\"internal error: Set.spliceOutSuccessor\"));\n    }\n}\n\nexport function SetTreeModule_remove(comparer, k, t) {\n    if (t != null) {\n        const t2 = t;\n        const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\n        if (t2 instanceof SetTreeNode$1) {\n            if (c < 0) {\n                return SetTreeModule_rebalance(SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2), SetTreeNode$1__get_Right(t2));\n            }\n            else if (c === 0) {\n                if (SetTreeNode$1__get_Left(t2) == null) {\n                    return SetTreeNode$1__get_Right(t2);\n                }\n                else if (SetTreeNode$1__get_Right(t2) == null) {\n                    return SetTreeNode$1__get_Left(t2);\n                }\n                else {\n                    const patternInput = SetTreeModule_spliceOutSuccessor(SetTreeNode$1__get_Right(t2));\n                    return SetTreeModule_mk(SetTreeNode$1__get_Left(t2), patternInput[0], patternInput[1]);\n                }\n            }\n            else {\n                return SetTreeModule_rebalance(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2), SetTreeModule_remove(comparer, k, SetTreeNode$1__get_Right(t2)));\n            }\n        }\n        else if (c === 0) {\n            return SetTreeModule_empty();\n        }\n        else {\n            return t;\n        }\n    }\n    else {\n        return t;\n    }\n}\n\nexport function SetTreeModule_mem(comparer_mut, k_mut, t_mut) {\n    SetTreeModule_mem:\n    while (true) {\n        const comparer = comparer_mut, k = k_mut, t = t_mut;\n        if (t != null) {\n            const t2 = t;\n            const c = comparer.Compare(k, SetTreeLeaf$1__get_Key(t2)) | 0;\n            if (t2 instanceof SetTreeNode$1) {\n                if (c < 0) {\n                    comparer_mut = comparer;\n                    k_mut = k;\n                    t_mut = SetTreeNode$1__get_Left(t2);\n                    continue SetTreeModule_mem;\n                }\n                else if (c === 0) {\n                    return true;\n                }\n                else {\n                    comparer_mut = comparer;\n                    k_mut = k;\n                    t_mut = SetTreeNode$1__get_Right(t2);\n                    continue SetTreeModule_mem;\n                }\n            }\n            else {\n                return c === 0;\n            }\n        }\n        else {\n            return false;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_iter(f_mut, t_mut) {\n    SetTreeModule_iter:\n    while (true) {\n        const f = f_mut, t = t_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                SetTreeModule_iter(f, SetTreeNode$1__get_Left(t2));\n                f(SetTreeLeaf$1__get_Key(t2));\n                f_mut = f;\n                t_mut = SetTreeNode$1__get_Right(t2);\n                continue SetTreeModule_iter;\n            }\n            else {\n                f(SetTreeLeaf$1__get_Key(t2));\n            }\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_foldBackOpt(f_mut, t_mut, x_mut) {\n    SetTreeModule_foldBackOpt:\n    while (true) {\n        const f = f_mut, t = t_mut, x = x_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                f_mut = f;\n                t_mut = SetTreeNode$1__get_Left(t2);\n                x_mut = f(SetTreeLeaf$1__get_Key(t2), SetTreeModule_foldBackOpt(f, SetTreeNode$1__get_Right(t2), x));\n                continue SetTreeModule_foldBackOpt;\n            }\n            else {\n                return f(SetTreeLeaf$1__get_Key(t2), x);\n            }\n        }\n        else {\n            return x;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_foldBack(f, m, x) {\n    return SetTreeModule_foldBackOpt(f, m, x);\n}\n\nexport function SetTreeModule_foldOpt(f_mut, x_mut, t_mut) {\n    SetTreeModule_foldOpt:\n    while (true) {\n        const f = f_mut, x = x_mut, t = t_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                f_mut = f;\n                x_mut = f(SetTreeModule_foldOpt(f, x, SetTreeNode$1__get_Left(t2)), SetTreeLeaf$1__get_Key(t2));\n                t_mut = SetTreeNode$1__get_Right(t2);\n                continue SetTreeModule_foldOpt;\n            }\n            else {\n                return f(x, SetTreeLeaf$1__get_Key(t2));\n            }\n        }\n        else {\n            return x;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_fold(f, x, m) {\n    return SetTreeModule_foldOpt(f, x, m);\n}\n\nexport function SetTreeModule_forall(f_mut, t_mut) {\n    SetTreeModule_forall:\n    while (true) {\n        const f = f_mut, t = t_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                if (f(SetTreeLeaf$1__get_Key(t2)) ? SetTreeModule_forall(f, SetTreeNode$1__get_Left(t2)) : false) {\n                    f_mut = f;\n                    t_mut = SetTreeNode$1__get_Right(t2);\n                    continue SetTreeModule_forall;\n                }\n                else {\n                    return false;\n                }\n            }\n            else {\n                return f(SetTreeLeaf$1__get_Key(t2));\n            }\n        }\n        else {\n            return true;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_exists(f_mut, t_mut) {\n    SetTreeModule_exists:\n    while (true) {\n        const f = f_mut, t = t_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                if (f(SetTreeLeaf$1__get_Key(t2)) ? true : SetTreeModule_exists(f, SetTreeNode$1__get_Left(t2))) {\n                    return true;\n                }\n                else {\n                    f_mut = f;\n                    t_mut = SetTreeNode$1__get_Right(t2);\n                    continue SetTreeModule_exists;\n                }\n            }\n            else {\n                return f(SetTreeLeaf$1__get_Key(t2));\n            }\n        }\n        else {\n            return false;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_subset(comparer, a, b) {\n    return SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a);\n}\n\nexport function SetTreeModule_properSubset(comparer, a, b) {\n    if (SetTreeModule_forall((x) => SetTreeModule_mem(comparer, x, b), a)) {\n        return SetTreeModule_exists((x_1) => (!SetTreeModule_mem(comparer, x_1, a)), b);\n    }\n    else {\n        return false;\n    }\n}\n\nexport function SetTreeModule_filterAux(comparer_mut, f_mut, t_mut, acc_mut) {\n    SetTreeModule_filterAux:\n    while (true) {\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc = acc_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                const acc_1 = f(SetTreeLeaf$1__get_Key(t2)) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc) : acc;\n                comparer_mut = comparer;\n                f_mut = f;\n                t_mut = SetTreeNode$1__get_Left(t2);\n                acc_mut = SetTreeModule_filterAux(comparer, f, SetTreeNode$1__get_Right(t2), acc_1);\n                continue SetTreeModule_filterAux;\n            }\n            else if (f(SetTreeLeaf$1__get_Key(t2))) {\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\n            }\n            else {\n                return acc;\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_filter(comparer, f, s) {\n    return SetTreeModule_filterAux(comparer, f, s, SetTreeModule_empty());\n}\n\nexport function SetTreeModule_diffAux(comparer_mut, t_mut, acc_mut) {\n    SetTreeModule_diffAux:\n    while (true) {\n        const comparer = comparer_mut, t = t_mut, acc = acc_mut;\n        if (acc == null) {\n            return acc;\n        }\n        else if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                comparer_mut = comparer;\n                t_mut = SetTreeNode$1__get_Left(t2);\n                acc_mut = SetTreeModule_diffAux(comparer, SetTreeNode$1__get_Right(t2), SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc));\n                continue SetTreeModule_diffAux;\n            }\n            else {\n                return SetTreeModule_remove(comparer, SetTreeLeaf$1__get_Key(t2), acc);\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_diff(comparer, a, b) {\n    return SetTreeModule_diffAux(comparer, b, a);\n}\n\nexport function SetTreeModule_union(comparer, t1, t2) {\n    if (t1 != null) {\n        const t1$0027 = t1;\n        if (t2 != null) {\n            const t2$0027 = t2;\n            if (t1$0027 instanceof SetTreeNode$1) {\n                if (t2$0027 instanceof SetTreeNode$1) {\n                    if (SetTreeNode$1__get_Height(t1$0027) > SetTreeNode$1__get_Height(t2$0027)) {\n                        const patternInput = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t1$0027), patternInput[0]), SetTreeLeaf$1__get_Key(t1$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t1$0027), patternInput[2]));\n                    }\n                    else {\n                        const patternInput_1 = SetTreeModule_split(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\n                        return SetTreeModule_balance(comparer, SetTreeModule_union(comparer, SetTreeNode$1__get_Left(t2$0027), patternInput_1[0]), SetTreeLeaf$1__get_Key(t2$0027), SetTreeModule_union(comparer, SetTreeNode$1__get_Right(t2$0027), patternInput_1[2]));\n                    }\n                }\n                else {\n                    return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2$0027), t1);\n                }\n            }\n            else {\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t1$0027), t2);\n            }\n        }\n        else {\n            return t1;\n        }\n    }\n    else {\n        return t2;\n    }\n}\n\nexport function SetTreeModule_intersectionAux(comparer_mut, b_mut, t_mut, acc_mut) {\n    SetTreeModule_intersectionAux:\n    while (true) {\n        const comparer = comparer_mut, b = b_mut, t = t_mut, acc = acc_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                const acc_1 = SetTreeModule_intersectionAux(comparer, b, SetTreeNode$1__get_Right(t2), acc);\n                const acc_2 = SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b) ? SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc_1) : acc_1;\n                comparer_mut = comparer;\n                b_mut = b;\n                t_mut = SetTreeNode$1__get_Left(t2);\n                acc_mut = acc_2;\n                continue SetTreeModule_intersectionAux;\n            }\n            else if (SetTreeModule_mem(comparer, SetTreeLeaf$1__get_Key(t2), b)) {\n                return SetTreeModule_add(comparer, SetTreeLeaf$1__get_Key(t2), acc);\n            }\n            else {\n                return acc;\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_intersection(comparer, a, b) {\n    return SetTreeModule_intersectionAux(comparer, b, a, SetTreeModule_empty());\n}\n\nexport function SetTreeModule_partition1(comparer, f, k, acc1, acc2) {\n    if (f(k)) {\n        return [SetTreeModule_add(comparer, k, acc1), acc2];\n    }\n    else {\n        return [acc1, SetTreeModule_add(comparer, k, acc2)];\n    }\n}\n\nexport function SetTreeModule_partitionAux(comparer_mut, f_mut, t_mut, acc_0_mut, acc_1_mut) {\n    SetTreeModule_partitionAux:\n    while (true) {\n        const comparer = comparer_mut, f = f_mut, t = t_mut, acc_0 = acc_0_mut, acc_1 = acc_1_mut;\n        const acc = [acc_0, acc_1];\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                const acc_2 = SetTreeModule_partitionAux(comparer, f, SetTreeNode$1__get_Right(t2), acc[0], acc[1]);\n                const acc_3 = SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc_2[0], acc_2[1]);\n                comparer_mut = comparer;\n                f_mut = f;\n                t_mut = SetTreeNode$1__get_Left(t2);\n                acc_0_mut = acc_3[0];\n                acc_1_mut = acc_3[1];\n                continue SetTreeModule_partitionAux;\n            }\n            else {\n                return SetTreeModule_partition1(comparer, f, SetTreeLeaf$1__get_Key(t2), acc[0], acc[1]);\n            }\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_partition(comparer, f, s) {\n    return SetTreeModule_partitionAux(comparer, f, s, SetTreeModule_empty(), SetTreeModule_empty());\n}\n\nexport function SetTreeModule_minimumElementAux(t_mut, n_mut) {\n    SetTreeModule_minimumElementAux:\n    while (true) {\n        const t = t_mut, n = n_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                t_mut = SetTreeNode$1__get_Left(t2);\n                n_mut = SetTreeLeaf$1__get_Key(t2);\n                continue SetTreeModule_minimumElementAux;\n            }\n            else {\n                return SetTreeLeaf$1__get_Key(t2);\n            }\n        }\n        else {\n            return n;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_minimumElementOpt(t) {\n    if (t != null) {\n        const t2 = t;\n        if (t2 instanceof SetTreeNode$1) {\n            return some(SetTreeModule_minimumElementAux(SetTreeNode$1__get_Left(t2), SetTreeLeaf$1__get_Key(t2)));\n        }\n        else {\n            return some(SetTreeLeaf$1__get_Key(t2));\n        }\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function SetTreeModule_maximumElementAux(t_mut, n_mut) {\n    SetTreeModule_maximumElementAux:\n    while (true) {\n        const t = t_mut, n = n_mut;\n        if (t != null) {\n            const t2 = t;\n            if (t2 instanceof SetTreeNode$1) {\n                t_mut = SetTreeNode$1__get_Right(t2);\n                n_mut = SetTreeLeaf$1__get_Key(t2);\n                continue SetTreeModule_maximumElementAux;\n            }\n            else {\n                return SetTreeLeaf$1__get_Key(t2);\n            }\n        }\n        else {\n            return n;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_maximumElementOpt(t) {\n    if (t != null) {\n        const t2 = t;\n        if (t2 instanceof SetTreeNode$1) {\n            return some(SetTreeModule_maximumElementAux(SetTreeNode$1__get_Right(t2), SetTreeLeaf$1__get_Key(t2)));\n        }\n        else {\n            return some(SetTreeLeaf$1__get_Key(t2));\n        }\n    }\n    else {\n        return void 0;\n    }\n}\n\nexport function SetTreeModule_minimumElement(s) {\n    const matchValue = SetTreeModule_minimumElementOpt(s);\n    if (matchValue == null) {\n        throw (new Error(\"Set contains no elements\"));\n    }\n    else {\n        return value_1(matchValue);\n    }\n}\n\nexport function SetTreeModule_maximumElement(s) {\n    const matchValue = SetTreeModule_maximumElementOpt(s);\n    if (matchValue == null) {\n        throw (new Error(\"Set contains no elements\"));\n    }\n    else {\n        return value_1(matchValue);\n    }\n}\n\nexport class SetTreeModule_SetIterator$1 extends Record {\n    constructor(stack, started) {\n        super();\n        this.stack = stack;\n        this.started = started;\n    }\n}\n\nexport function SetTreeModule_SetIterator$1$reflection(gen0) {\n    return record_type(\"Set.SetTreeModule.SetIterator`1\", [gen0], SetTreeModule_SetIterator$1, () => [[\"stack\", list_type(option_type(SetTreeLeaf$1$reflection(gen0)))], [\"started\", bool_type]]);\n}\n\nexport function SetTreeModule_collapseLHS(stack_mut) {\n    SetTreeModule_collapseLHS:\n    while (true) {\n        const stack = stack_mut;\n        if (stack.tail != null) {\n            const x = stack.head;\n            const rest = stack.tail;\n            if (x != null) {\n                const x2 = x;\n                if (x2 instanceof SetTreeNode$1) {\n                    stack_mut = (new List(SetTreeNode$1__get_Left(x2), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2)), new List(SetTreeNode$1__get_Right(x2), rest))));\n                    continue SetTreeModule_collapseLHS;\n                }\n                else {\n                    return stack;\n                }\n            }\n            else {\n                stack_mut = rest;\n                continue SetTreeModule_collapseLHS;\n            }\n        }\n        else {\n            return new List();\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_mkIterator(s) {\n    return new SetTreeModule_SetIterator$1(SetTreeModule_collapseLHS(new List(s, new List())), false);\n}\n\nexport function SetTreeModule_notStarted() {\n    throw (new Error(\"Enumeration not started\"));\n}\n\nexport function SetTreeModule_alreadyFinished() {\n    throw (new Error(\"Enumeration already started\"));\n}\n\nexport function SetTreeModule_current(i) {\n    if (i.started) {\n        const matchValue = i.stack;\n        if (matchValue.tail == null) {\n            return SetTreeModule_alreadyFinished();\n        }\n        else if (matchValue.head != null) {\n            const t = matchValue.head;\n            return SetTreeLeaf$1__get_Key(t);\n        }\n        else {\n            throw (new Error(\"Please report error: Set iterator, unexpected stack for current\"));\n        }\n    }\n    else {\n        return SetTreeModule_notStarted();\n    }\n}\n\nexport function SetTreeModule_moveNext(i) {\n    if (i.started) {\n        const matchValue = i.stack;\n        if (matchValue.tail != null) {\n            if (matchValue.head != null) {\n                const t = matchValue.head;\n                if (t instanceof SetTreeNode$1) {\n                    throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\n                }\n                else {\n                    i.stack = SetTreeModule_collapseLHS(matchValue.tail);\n                    return !(i.stack.tail == null);\n                }\n            }\n            else {\n                throw (new Error(\"Please report error: Set iterator, unexpected stack for moveNext\"));\n            }\n        }\n        else {\n            return false;\n        }\n    }\n    else {\n        i.started = true;\n        return !(i.stack.tail == null);\n    }\n}\n\nexport function SetTreeModule_mkIEnumerator(s) {\n    let i = SetTreeModule_mkIterator(s);\n    return {\n        [\"System.Collections.Generic.IEnumerator`1.get_Current\"]() {\n            return SetTreeModule_current(i);\n        },\n        [\"System.Collections.IEnumerator.get_Current\"]() {\n            return SetTreeModule_current(i);\n        },\n        [\"System.Collections.IEnumerator.MoveNext\"]() {\n            return SetTreeModule_moveNext(i);\n        },\n        [\"System.Collections.IEnumerator.Reset\"]() {\n            i = SetTreeModule_mkIterator(s);\n        },\n        Dispose() {\n        },\n    };\n}\n\nexport function SetTreeModule_compareStacks(comparer_mut, l1_mut, l2_mut) {\n    SetTreeModule_compareStacks:\n    while (true) {\n        const comparer = comparer_mut, l1 = l1_mut, l2 = l2_mut;\n        const matchValue = [l1, l2];\n        if (matchValue[0].tail != null) {\n            if (matchValue[1].tail != null) {\n                if (matchValue[1].head != null) {\n                    if (matchValue[0].head != null) {\n                        const x1_3 = matchValue[0].head;\n                        const x2_3 = matchValue[1].head;\n                        if (x1_3 instanceof SetTreeNode$1) {\n                            if (SetTreeNode$1__get_Left(x1_3) == null) {\n                                if (x2_3 instanceof SetTreeNode$1) {\n                                    if (SetTreeNode$1__get_Left(x2_3) == null) {\n                                        const c = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\n                                        if (c !== 0) {\n                                            return c | 0;\n                                        }\n                                        else {\n                                            comparer_mut = comparer;\n                                            l1_mut = (new List(SetTreeNode$1__get_Right(x1_3), matchValue[0].tail));\n                                            l2_mut = (new List(SetTreeNode$1__get_Right(x2_3), matchValue[1].tail));\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                    }\n                                    else {\n                                        const matchValue_3 = [l1, l2];\n                                        let pattern_matching_result, t1_6, x1_4, t2_6, x2_4;\n                                        if (matchValue_3[0].tail != null) {\n                                            if (matchValue_3[0].head != null) {\n                                                pattern_matching_result = 0;\n                                                t1_6 = matchValue_3[0].tail;\n                                                x1_4 = matchValue_3[0].head;\n                                            }\n                                            else if (matchValue_3[1].tail != null) {\n                                                if (matchValue_3[1].head != null) {\n                                                    pattern_matching_result = 1;\n                                                    t2_6 = matchValue_3[1].tail;\n                                                    x2_4 = matchValue_3[1].head;\n                                                }\n                                                else {\n                                                    pattern_matching_result = 2;\n                                                }\n                                            }\n                                            else {\n                                                pattern_matching_result = 2;\n                                            }\n                                        }\n                                        else if (matchValue_3[1].tail != null) {\n                                            if (matchValue_3[1].head != null) {\n                                                pattern_matching_result = 1;\n                                                t2_6 = matchValue_3[1].tail;\n                                                x2_4 = matchValue_3[1].head;\n                                            }\n                                            else {\n                                                pattern_matching_result = 2;\n                                            }\n                                        }\n                                        else {\n                                            pattern_matching_result = 2;\n                                        }\n                                        switch (pattern_matching_result) {\n                                            case 0: {\n                                                if (x1_4 instanceof SetTreeNode$1) {\n                                                    comparer_mut = comparer;\n                                                    l1_mut = (new List(SetTreeNode$1__get_Left(x1_4), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_4), 0), t1_6)));\n                                                    l2_mut = l2;\n                                                    continue SetTreeModule_compareStacks;\n                                                }\n                                                else {\n                                                    comparer_mut = comparer;\n                                                    l1_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_4)), t1_6)));\n                                                    l2_mut = l2;\n                                                    continue SetTreeModule_compareStacks;\n                                                }\n                                            }\n                                            case 1: {\n                                                if (x2_4 instanceof SetTreeNode$1) {\n                                                    comparer_mut = comparer;\n                                                    l1_mut = l1;\n                                                    l2_mut = (new List(SetTreeNode$1__get_Left(x2_4), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_4), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_4), 0), t2_6)));\n                                                    continue SetTreeModule_compareStacks;\n                                                }\n                                                else {\n                                                    comparer_mut = comparer;\n                                                    l1_mut = l1;\n                                                    l2_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_4)), t2_6)));\n                                                    continue SetTreeModule_compareStacks;\n                                                }\n                                            }\n                                            case 2: {\n                                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\n                                            }\n                                        }\n                                    }\n                                }\n                                else {\n                                    const c_1 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\n                                    if (c_1 !== 0) {\n                                        return c_1 | 0;\n                                    }\n                                    else {\n                                        comparer_mut = comparer;\n                                        l1_mut = (new List(SetTreeNode$1__get_Right(x1_3), matchValue[0].tail));\n                                        l2_mut = (new List(SetTreeModule_empty(), matchValue[1].tail));\n                                        continue SetTreeModule_compareStacks;\n                                    }\n                                }\n                            }\n                            else {\n                                const matchValue_4 = [l1, l2];\n                                let pattern_matching_result_1, t1_7, x1_5, t2_7, x2_5;\n                                if (matchValue_4[0].tail != null) {\n                                    if (matchValue_4[0].head != null) {\n                                        pattern_matching_result_1 = 0;\n                                        t1_7 = matchValue_4[0].tail;\n                                        x1_5 = matchValue_4[0].head;\n                                    }\n                                    else if (matchValue_4[1].tail != null) {\n                                        if (matchValue_4[1].head != null) {\n                                            pattern_matching_result_1 = 1;\n                                            t2_7 = matchValue_4[1].tail;\n                                            x2_5 = matchValue_4[1].head;\n                                        }\n                                        else {\n                                            pattern_matching_result_1 = 2;\n                                        }\n                                    }\n                                    else {\n                                        pattern_matching_result_1 = 2;\n                                    }\n                                }\n                                else if (matchValue_4[1].tail != null) {\n                                    if (matchValue_4[1].head != null) {\n                                        pattern_matching_result_1 = 1;\n                                        t2_7 = matchValue_4[1].tail;\n                                        x2_5 = matchValue_4[1].head;\n                                    }\n                                    else {\n                                        pattern_matching_result_1 = 2;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_1 = 2;\n                                }\n                                switch (pattern_matching_result_1) {\n                                    case 0: {\n                                        if (x1_5 instanceof SetTreeNode$1) {\n                                            comparer_mut = comparer;\n                                            l1_mut = (new List(SetTreeNode$1__get_Left(x1_5), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_5), 0), t1_7)));\n                                            l2_mut = l2;\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                        else {\n                                            comparer_mut = comparer;\n                                            l1_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_5)), t1_7)));\n                                            l2_mut = l2;\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                    }\n                                    case 1: {\n                                        if (x2_5 instanceof SetTreeNode$1) {\n                                            comparer_mut = comparer;\n                                            l1_mut = l1;\n                                            l2_mut = (new List(SetTreeNode$1__get_Left(x2_5), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_5), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_5), 0), t2_7)));\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                        else {\n                                            comparer_mut = comparer;\n                                            l1_mut = l1;\n                                            l2_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_5)), t2_7)));\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                    }\n                                    case 2: {\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\n                                    }\n                                }\n                            }\n                        }\n                        else if (x2_3 instanceof SetTreeNode$1) {\n                            if (SetTreeNode$1__get_Left(x2_3) == null) {\n                                const c_2 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\n                                if (c_2 !== 0) {\n                                    return c_2 | 0;\n                                }\n                                else {\n                                    comparer_mut = comparer;\n                                    l1_mut = (new List(SetTreeModule_empty(), matchValue[0].tail));\n                                    l2_mut = (new List(SetTreeNode$1__get_Right(x2_3), matchValue[1].tail));\n                                    continue SetTreeModule_compareStacks;\n                                }\n                            }\n                            else {\n                                const matchValue_5 = [l1, l2];\n                                let pattern_matching_result_2, t1_8, x1_6, t2_8, x2_6;\n                                if (matchValue_5[0].tail != null) {\n                                    if (matchValue_5[0].head != null) {\n                                        pattern_matching_result_2 = 0;\n                                        t1_8 = matchValue_5[0].tail;\n                                        x1_6 = matchValue_5[0].head;\n                                    }\n                                    else if (matchValue_5[1].tail != null) {\n                                        if (matchValue_5[1].head != null) {\n                                            pattern_matching_result_2 = 1;\n                                            t2_8 = matchValue_5[1].tail;\n                                            x2_6 = matchValue_5[1].head;\n                                        }\n                                        else {\n                                            pattern_matching_result_2 = 2;\n                                        }\n                                    }\n                                    else {\n                                        pattern_matching_result_2 = 2;\n                                    }\n                                }\n                                else if (matchValue_5[1].tail != null) {\n                                    if (matchValue_5[1].head != null) {\n                                        pattern_matching_result_2 = 1;\n                                        t2_8 = matchValue_5[1].tail;\n                                        x2_6 = matchValue_5[1].head;\n                                    }\n                                    else {\n                                        pattern_matching_result_2 = 2;\n                                    }\n                                }\n                                else {\n                                    pattern_matching_result_2 = 2;\n                                }\n                                switch (pattern_matching_result_2) {\n                                    case 0: {\n                                        if (x1_6 instanceof SetTreeNode$1) {\n                                            comparer_mut = comparer;\n                                            l1_mut = (new List(SetTreeNode$1__get_Left(x1_6), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_6), 0), t1_8)));\n                                            l2_mut = l2;\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                        else {\n                                            comparer_mut = comparer;\n                                            l1_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_6)), t1_8)));\n                                            l2_mut = l2;\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                    }\n                                    case 1: {\n                                        if (x2_6 instanceof SetTreeNode$1) {\n                                            comparer_mut = comparer;\n                                            l1_mut = l1;\n                                            l2_mut = (new List(SetTreeNode$1__get_Left(x2_6), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_6), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_6), 0), t2_8)));\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                        else {\n                                            comparer_mut = comparer;\n                                            l1_mut = l1;\n                                            l2_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_6)), t2_8)));\n                                            continue SetTreeModule_compareStacks;\n                                        }\n                                    }\n                                    case 2: {\n                                        throw (new Error(\"unexpected state in SetTree.compareStacks\"));\n                                    }\n                                }\n                            }\n                        }\n                        else {\n                            const c_3 = comparer.Compare(SetTreeLeaf$1__get_Key(x1_3), SetTreeLeaf$1__get_Key(x2_3)) | 0;\n                            if (c_3 !== 0) {\n                                return c_3 | 0;\n                            }\n                            else {\n                                comparer_mut = comparer;\n                                l1_mut = matchValue[0].tail;\n                                l2_mut = matchValue[1].tail;\n                                continue SetTreeModule_compareStacks;\n                            }\n                        }\n                    }\n                    else {\n                        const x2 = matchValue[1].head;\n                        const matchValue_1 = [l1, l2];\n                        let pattern_matching_result_3, t1_2, x1, t2_2, x2_1;\n                        if (matchValue_1[0].tail != null) {\n                            if (matchValue_1[0].head != null) {\n                                pattern_matching_result_3 = 0;\n                                t1_2 = matchValue_1[0].tail;\n                                x1 = matchValue_1[0].head;\n                            }\n                            else if (matchValue_1[1].tail != null) {\n                                if (matchValue_1[1].head != null) {\n                                    pattern_matching_result_3 = 1;\n                                    t2_2 = matchValue_1[1].tail;\n                                    x2_1 = matchValue_1[1].head;\n                                }\n                                else {\n                                    pattern_matching_result_3 = 2;\n                                }\n                            }\n                            else {\n                                pattern_matching_result_3 = 2;\n                            }\n                        }\n                        else if (matchValue_1[1].tail != null) {\n                            if (matchValue_1[1].head != null) {\n                                pattern_matching_result_3 = 1;\n                                t2_2 = matchValue_1[1].tail;\n                                x2_1 = matchValue_1[1].head;\n                            }\n                            else {\n                                pattern_matching_result_3 = 2;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_3 = 2;\n                        }\n                        switch (pattern_matching_result_3) {\n                            case 0: {\n                                if (x1 instanceof SetTreeNode$1) {\n                                    comparer_mut = comparer;\n                                    l1_mut = (new List(SetTreeNode$1__get_Left(x1), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1), 0), t1_2)));\n                                    l2_mut = l2;\n                                    continue SetTreeModule_compareStacks;\n                                }\n                                else {\n                                    comparer_mut = comparer;\n                                    l1_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1)), t1_2)));\n                                    l2_mut = l2;\n                                    continue SetTreeModule_compareStacks;\n                                }\n                            }\n                            case 1: {\n                                if (x2_1 instanceof SetTreeNode$1) {\n                                    comparer_mut = comparer;\n                                    l1_mut = l1;\n                                    l2_mut = (new List(SetTreeNode$1__get_Left(x2_1), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_1), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_1), 0), t2_2)));\n                                    continue SetTreeModule_compareStacks;\n                                }\n                                else {\n                                    comparer_mut = comparer;\n                                    l1_mut = l1;\n                                    l2_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_1)), t2_2)));\n                                    continue SetTreeModule_compareStacks;\n                                }\n                            }\n                            case 2: {\n                                throw (new Error(\"unexpected state in SetTree.compareStacks\"));\n                            }\n                        }\n                    }\n                }\n                else if (matchValue[0].head != null) {\n                    const x1_1 = matchValue[0].head;\n                    const matchValue_2 = [l1, l2];\n                    let pattern_matching_result_4, t1_4, x1_2, t2_4, x2_2;\n                    if (matchValue_2[0].tail != null) {\n                        if (matchValue_2[0].head != null) {\n                            pattern_matching_result_4 = 0;\n                            t1_4 = matchValue_2[0].tail;\n                            x1_2 = matchValue_2[0].head;\n                        }\n                        else if (matchValue_2[1].tail != null) {\n                            if (matchValue_2[1].head != null) {\n                                pattern_matching_result_4 = 1;\n                                t2_4 = matchValue_2[1].tail;\n                                x2_2 = matchValue_2[1].head;\n                            }\n                            else {\n                                pattern_matching_result_4 = 2;\n                            }\n                        }\n                        else {\n                            pattern_matching_result_4 = 2;\n                        }\n                    }\n                    else if (matchValue_2[1].tail != null) {\n                        if (matchValue_2[1].head != null) {\n                            pattern_matching_result_4 = 1;\n                            t2_4 = matchValue_2[1].tail;\n                            x2_2 = matchValue_2[1].head;\n                        }\n                        else {\n                            pattern_matching_result_4 = 2;\n                        }\n                    }\n                    else {\n                        pattern_matching_result_4 = 2;\n                    }\n                    switch (pattern_matching_result_4) {\n                        case 0: {\n                            if (x1_2 instanceof SetTreeNode$1) {\n                                comparer_mut = comparer;\n                                l1_mut = (new List(SetTreeNode$1__get_Left(x1_2), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x1_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x1_2), 0), t1_4)));\n                                l2_mut = l2;\n                                continue SetTreeModule_compareStacks;\n                            }\n                            else {\n                                comparer_mut = comparer;\n                                l1_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x1_2)), t1_4)));\n                                l2_mut = l2;\n                                continue SetTreeModule_compareStacks;\n                            }\n                        }\n                        case 1: {\n                            if (x2_2 instanceof SetTreeNode$1) {\n                                comparer_mut = comparer;\n                                l1_mut = l1;\n                                l2_mut = (new List(SetTreeNode$1__get_Left(x2_2), new List(SetTreeNode$1_$ctor_Z6E7BE5F7(SetTreeLeaf$1__get_Key(x2_2), SetTreeModule_empty(), SetTreeNode$1__get_Right(x2_2), 0), t2_4)));\n                                continue SetTreeModule_compareStacks;\n                            }\n                            else {\n                                comparer_mut = comparer;\n                                l1_mut = l1;\n                                l2_mut = (new List(SetTreeModule_empty(), new List(SetTreeLeaf$1_$ctor_2B595(SetTreeLeaf$1__get_Key(x2_2)), t2_4)));\n                                continue SetTreeModule_compareStacks;\n                            }\n                        }\n                        case 2: {\n                            throw (new Error(\"unexpected state in SetTree.compareStacks\"));\n                        }\n                    }\n                }\n                else {\n                    comparer_mut = comparer;\n                    l1_mut = matchValue[0].tail;\n                    l2_mut = matchValue[1].tail;\n                    continue SetTreeModule_compareStacks;\n                }\n            }\n            else {\n                return 1;\n            }\n        }\n        else if (matchValue[1].tail == null) {\n            return 0;\n        }\n        else {\n            return -1;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_compare(comparer, t1, t2) {\n    if (t1 == null) {\n        if (t2 == null) {\n            return 0;\n        }\n        else {\n            return -1;\n        }\n    }\n    else if (t2 == null) {\n        return 1;\n    }\n    else {\n        return SetTreeModule_compareStacks(comparer, new List(t1, new List()), new List(t2, new List())) | 0;\n    }\n}\n\nexport function SetTreeModule_choose(s) {\n    return SetTreeModule_minimumElement(s);\n}\n\nexport function SetTreeModule_toList(t) {\n    const loop = (t$0027_mut, acc_mut) => {\n        loop:\n        while (true) {\n            const t$0027 = t$0027_mut, acc = acc_mut;\n            if (t$0027 != null) {\n                const t2 = t$0027;\n                if (t2 instanceof SetTreeNode$1) {\n                    t$0027_mut = SetTreeNode$1__get_Left(t2);\n                    acc_mut = (new List(SetTreeLeaf$1__get_Key(t2), loop(SetTreeNode$1__get_Right(t2), acc)));\n                    continue loop;\n                }\n                else {\n                    return new List(SetTreeLeaf$1__get_Key(t2), acc);\n                }\n            }\n            else {\n                return acc;\n            }\n            break;\n        }\n    };\n    return loop(t, new List());\n}\n\nexport function SetTreeModule_copyToArray(s, arr, i) {\n    let j = i | 0;\n    SetTreeModule_iter((x) => {\n        arr[j] = x;\n        j = (j + 1);\n    }, s);\n}\n\nexport function SetTreeModule_toArray(s) {\n    const n = SetTreeModule_count(s) | 0;\n    const res = new Array(n);\n    SetTreeModule_copyToArray(s, res, 0);\n    return res;\n}\n\nexport function SetTreeModule_mkFromEnumerator(comparer_mut, acc_mut, e_mut) {\n    SetTreeModule_mkFromEnumerator:\n    while (true) {\n        const comparer = comparer_mut, acc = acc_mut, e = e_mut;\n        if (e[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            comparer_mut = comparer;\n            acc_mut = SetTreeModule_add(comparer, e[\"System.Collections.Generic.IEnumerator`1.get_Current\"](), acc);\n            e_mut = e;\n            continue SetTreeModule_mkFromEnumerator;\n        }\n        else {\n            return acc;\n        }\n        break;\n    }\n}\n\nexport function SetTreeModule_ofSeq(comparer, c) {\n    const ie = getEnumerator(c);\n    try {\n        return SetTreeModule_mkFromEnumerator(comparer, SetTreeModule_empty(), ie);\n    }\n    finally {\n        ie.Dispose();\n    }\n}\n\nexport function SetTreeModule_ofArray(comparer, l) {\n    return fold_1((acc, k) => SetTreeModule_add(comparer, k, acc), SetTreeModule_empty(), l);\n}\n\nexport class FSharpSet {\n    constructor(comparer, tree) {\n        this.comparer = comparer;\n        this.tree = tree;\n    }\n    GetHashCode() {\n        const this$ = this;\n        return FSharpSet__ComputeHashCode(this$) | 0;\n    }\n    Equals(that) {\n        const this$ = this;\n        return (that instanceof FSharpSet) ? (SetTreeModule_compare(FSharpSet__get_Comparer(this$), FSharpSet__get_Tree(this$), FSharpSet__get_Tree(that)) === 0) : false;\n    }\n    toString() {\n        const this$ = this;\n        return (\"set [\" + join(\"; \", map_1((x) => {\n            let copyOfStruct = x;\n            return toString(copyOfStruct);\n        }, this$))) + \"]\";\n    }\n    get [Symbol.toStringTag]() {\n        return \"FSharpSet\";\n    }\n    CompareTo(that) {\n        const s = this;\n        return SetTreeModule_compare(FSharpSet__get_Comparer(s), FSharpSet__get_Tree(s), FSharpSet__get_Tree(that)) | 0;\n    }\n    [\"System.Collections.Generic.ICollection`1.Add2B595\"](x) {\n        void x;\n        throw (new Error(\"ReadOnlyCollection\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Clear\"]() {\n        throw (new Error(\"ReadOnlyCollection\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Remove2B595\"](x) {\n        void x;\n        throw (new Error(\"ReadOnlyCollection\"));\n    }\n    [\"System.Collections.Generic.ICollection`1.Contains2B595\"](x) {\n        const s = this;\n        return SetTreeModule_mem(FSharpSet__get_Comparer(s), x, FSharpSet__get_Tree(s));\n    }\n    [\"System.Collections.Generic.ICollection`1.CopyToZ2E171D71\"](arr, i) {\n        const s = this;\n        SetTreeModule_copyToArray(FSharpSet__get_Tree(s), arr, i);\n    }\n    [\"System.Collections.Generic.ICollection`1.get_IsReadOnly\"]() {\n        return true;\n    }\n    [\"System.Collections.Generic.ICollection`1.get_Count\"]() {\n        const s = this;\n        return FSharpSet__get_Count(s) | 0;\n    }\n    [\"System.Collections.Generic.IReadOnlyCollection`1.get_Count\"]() {\n        const s = this;\n        return FSharpSet__get_Count(s) | 0;\n    }\n    GetEnumerator() {\n        const s = this;\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\n    }\n    [Symbol.iterator]() {\n        return toIterator(this.GetEnumerator());\n    }\n    [\"System.Collections.IEnumerable.GetEnumerator\"]() {\n        const s = this;\n        return SetTreeModule_mkIEnumerator(FSharpSet__get_Tree(s));\n    }\n    get size() {\n        const s = this;\n        return FSharpSet__get_Count(s) | 0;\n    }\n    add(k) {\n        const s = this;\n        throw (new Error(\"Set cannot be mutated\"));\n        return s;\n    }\n    clear() {\n        throw (new Error(\"Set cannot be mutated\"));\n    }\n    delete(k) {\n        throw (new Error(\"Set cannot be mutated\"));\n        return false;\n    }\n    has(k) {\n        const s = this;\n        return FSharpSet__Contains(s, k);\n    }\n    keys() {\n        const s = this;\n        return map_1((x) => x, s);\n    }\n    values() {\n        const s = this;\n        return map_1((x) => x, s);\n    }\n    entries() {\n        const s = this;\n        return map_1((v) => [v, v], s);\n    }\n    forEach(f, thisArg) {\n        const s = this;\n        iterate_1((x) => {\n            f(x, x, s);\n        }, s);\n    }\n}\n\nexport function FSharpSet$reflection(gen0) {\n    return class_type(\"Set.FSharpSet\", [gen0], FSharpSet);\n}\n\nexport function FSharpSet_$ctor(comparer, tree) {\n    return new FSharpSet(comparer, tree);\n}\n\nexport function FSharpSet__get_Comparer(set$) {\n    return set$.comparer;\n}\n\nexport function FSharpSet__get_Tree(set$) {\n    return set$.tree;\n}\n\nexport function FSharpSet_Empty(comparer) {\n    return FSharpSet_$ctor(comparer, SetTreeModule_empty());\n}\n\nexport function FSharpSet__Add(s, value) {\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_add(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\n}\n\nexport function FSharpSet__Remove(s, value) {\n    return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_remove(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s)));\n}\n\nexport function FSharpSet__get_Count(s) {\n    return SetTreeModule_count(FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet__Contains(s, value) {\n    return SetTreeModule_mem(FSharpSet__get_Comparer(s), value, FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet__Iterate(s, x) {\n    SetTreeModule_iter(x, FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet__Fold(s, f, z) {\n    const f_1 = f;\n    return SetTreeModule_fold((x, z_1) => f_1(z_1, x), z, FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet__get_IsEmpty(s) {\n    return FSharpSet__get_Tree(s) == null;\n}\n\nexport function FSharpSet__Partition(s, f) {\n    if (FSharpSet__get_Tree(s) == null) {\n        return [s, s];\n    }\n    else {\n        const patternInput = SetTreeModule_partition(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s));\n        return [FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[0]), FSharpSet_$ctor(FSharpSet__get_Comparer(s), patternInput[1])];\n    }\n}\n\nexport function FSharpSet__Filter(s, f) {\n    if (FSharpSet__get_Tree(s) == null) {\n        return s;\n    }\n    else {\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(s), SetTreeModule_filter(FSharpSet__get_Comparer(s), f, FSharpSet__get_Tree(s)));\n    }\n}\n\nexport function FSharpSet__Map(s, f, comparer) {\n    return FSharpSet_$ctor(comparer, SetTreeModule_fold((acc, k) => SetTreeModule_add(comparer, f(k), acc), SetTreeModule_empty(), FSharpSet__get_Tree(s)));\n}\n\nexport function FSharpSet__Exists(s, f) {\n    return SetTreeModule_exists(f, FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet__ForAll(s, f) {\n    return SetTreeModule_forall(f, FSharpSet__get_Tree(s));\n}\n\nexport function FSharpSet_op_Subtraction(set1, set2) {\n    if (FSharpSet__get_Tree(set1) == null) {\n        return set1;\n    }\n    else if (FSharpSet__get_Tree(set2) == null) {\n        return set1;\n    }\n    else {\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_diff(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\n    }\n}\n\nexport function FSharpSet_op_Addition(set1, set2) {\n    if (FSharpSet__get_Tree(set2) == null) {\n        return set1;\n    }\n    else if (FSharpSet__get_Tree(set1) == null) {\n        return set2;\n    }\n    else {\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(set1), SetTreeModule_union(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2)));\n    }\n}\n\nexport function FSharpSet_Intersection(a, b) {\n    if (FSharpSet__get_Tree(b) == null) {\n        return b;\n    }\n    else if (FSharpSet__get_Tree(a) == null) {\n        return a;\n    }\n    else {\n        return FSharpSet_$ctor(FSharpSet__get_Comparer(a), SetTreeModule_intersection(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)));\n    }\n}\n\nexport function FSharpSet_IntersectionMany(sets) {\n    return reduce((s1, s2) => FSharpSet_Intersection(s1, s2), sets);\n}\n\nexport function FSharpSet_Equality(a, b) {\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b)) === 0;\n}\n\nexport function FSharpSet_Compare(a, b) {\n    return SetTreeModule_compare(FSharpSet__get_Comparer(a), FSharpSet__get_Tree(a), FSharpSet__get_Tree(b));\n}\n\nexport function FSharpSet__get_Choose(x) {\n    return SetTreeModule_choose(FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__get_MinimumElement(x) {\n    return SetTreeModule_minimumElement(FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__get_MaximumElement(x) {\n    return SetTreeModule_maximumElement(FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__IsSubsetOf(x, otherSet) {\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\n}\n\nexport function FSharpSet__IsSupersetOf(x, otherSet) {\n    return SetTreeModule_subset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__IsProperSubsetOf(x, otherSet) {\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(x), FSharpSet__get_Tree(otherSet));\n}\n\nexport function FSharpSet__IsProperSupersetOf(x, otherSet) {\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(x), FSharpSet__get_Tree(otherSet), FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__ToList(x) {\n    return SetTreeModule_toList(FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__ToArray(x) {\n    return SetTreeModule_toArray(FSharpSet__get_Tree(x));\n}\n\nexport function FSharpSet__ComputeHashCode(this$) {\n    let res = 0;\n    const enumerator = getEnumerator(this$);\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const x_1 = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n            res = (((res << 1) + structuralHash(x_1)) + 631);\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n    return Math.abs(res) | 0;\n}\n\nexport function isEmpty(set$) {\n    return FSharpSet__get_IsEmpty(set$);\n}\n\nexport function contains(element, set$) {\n    return FSharpSet__Contains(set$, element);\n}\n\nexport function add(value, set$) {\n    return FSharpSet__Add(set$, value);\n}\n\nexport function singleton(value, comparer) {\n    return FSharpSet__Add(FSharpSet_Empty(comparer), value);\n}\n\nexport function remove(value, set$) {\n    return FSharpSet__Remove(set$, value);\n}\n\nexport function union(set1, set2) {\n    return FSharpSet_op_Addition(set1, set2);\n}\n\nexport function unionMany(sets, comparer) {\n    return fold_2((s1, s2) => FSharpSet_op_Addition(s1, s2), FSharpSet_Empty(comparer), sets);\n}\n\nexport function intersect(set1, set2) {\n    return FSharpSet_Intersection(set1, set2);\n}\n\nexport function intersectMany(sets) {\n    return FSharpSet_IntersectionMany(sets);\n}\n\nexport function iterate(action, set$) {\n    FSharpSet__Iterate(set$, action);\n}\n\nexport function empty(comparer) {\n    return FSharpSet_Empty(comparer);\n}\n\nexport function forAll(predicate, set$) {\n    return FSharpSet__ForAll(set$, predicate);\n}\n\nexport function exists(predicate, set$) {\n    return FSharpSet__Exists(set$, predicate);\n}\n\nexport function filter(predicate, set$) {\n    return FSharpSet__Filter(set$, predicate);\n}\n\nexport function partition(predicate, set$) {\n    return FSharpSet__Partition(set$, predicate);\n}\n\nexport function fold(folder, state, set$) {\n    return SetTreeModule_fold(folder, state, FSharpSet__get_Tree(set$));\n}\n\nexport function foldBack(folder, set$, state) {\n    return SetTreeModule_foldBack(folder, FSharpSet__get_Tree(set$), state);\n}\n\nexport function map(mapping, set$, comparer) {\n    return FSharpSet__Map(set$, mapping, comparer);\n}\n\nexport function count(set$) {\n    return FSharpSet__get_Count(set$);\n}\n\nexport function ofList(elements, comparer) {\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\n}\n\nexport function ofArray(array, comparer) {\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofArray(comparer, array));\n}\n\nexport function toList(set$) {\n    return FSharpSet__ToList(set$);\n}\n\nexport function toArray(set$) {\n    return FSharpSet__ToArray(set$);\n}\n\nexport function toSeq(set$) {\n    return map_1((x) => x, set$);\n}\n\nexport function ofSeq(elements, comparer) {\n    return FSharpSet_$ctor(comparer, SetTreeModule_ofSeq(comparer, elements));\n}\n\nexport function difference(set1, set2) {\n    return FSharpSet_op_Subtraction(set1, set2);\n}\n\nexport function isSubset(set1, set2) {\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\n}\n\nexport function isSuperset(set1, set2) {\n    return SetTreeModule_subset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\n}\n\nexport function isProperSubset(set1, set2) {\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set1), FSharpSet__get_Tree(set2));\n}\n\nexport function isProperSuperset(set1, set2) {\n    return SetTreeModule_properSubset(FSharpSet__get_Comparer(set1), FSharpSet__get_Tree(set2), FSharpSet__get_Tree(set1));\n}\n\nexport function minElement(set$) {\n    return FSharpSet__get_MinimumElement(set$);\n}\n\nexport function maxElement(set$) {\n    return FSharpSet__get_MaximumElement(set$);\n}\n\nexport function createMutable(source, comparer) {\n    return HashSet_$ctor_Z6150332D(source, comparer);\n}\n\nexport function distinct(xs, comparer) {\n    return delay(() => {\n        const set$ = HashSet_$ctor_Z6150332D(empty_1(), comparer);\n        return collect((x) => (HashSet__Add_2B595(set$, x) ? singleton_1(x) : empty_1()), xs);\n    });\n}\n\nexport function distinctBy(projection, xs, comparer) {\n    return delay(() => {\n        const set$ = HashSet_$ctor_Z6150332D(empty_1(), comparer);\n        return collect((x) => (HashSet__Add_2B595(set$, projection(x)) ? singleton_1(x) : empty_1()), xs);\n    });\n}\n\nexport function unionWith(s1, s2) {\n    return fold_2((acc, x) => acc.add(x), s1, s2);\n}\n\nexport function intersectWith(s1, s2, comparer) {\n    const s2_1 = ofSeq(s2, comparer);\n    const enumerator = getEnumerator(s1.keys());\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const x = enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]();\n            if (!FSharpSet__Contains(s2_1, x)) {\n                const value = s1.delete(x);\n                void value;\n            }\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n}\n\nexport function exceptWith(s1, s2) {\n    const enumerator = getEnumerator(s2);\n    try {\n        while (enumerator[\"System.Collections.IEnumerator.MoveNext\"]()) {\n            const value = s1.delete(enumerator[\"System.Collections.Generic.IEnumerator`1.get_Current\"]());\n            void value;\n        }\n    }\n    finally {\n        enumerator.Dispose();\n    }\n}\n\nexport function isSubsetOf(s1, s2, comparer) {\n    return isSubset(ofSeq(s1.values(), comparer), ofSeq(s2, comparer));\n}\n\nexport function isSupersetOf(s1, s2, comparer) {\n    return isSuperset(ofSeq(s1.values(), comparer), ofSeq(s2, comparer));\n}\n\nexport function isProperSubsetOf(s1, s2, comparer) {\n    return isProperSubset(ofSeq(s1.values(), comparer), ofSeq(s2, comparer));\n}\n\nexport function isProperSupersetOf(s1, s2, comparer) {\n    return isProperSuperset(ofSeq(s1.values(), comparer), ofSeq(s2, comparer));\n}\n\n","import { toFail, printf, toText, join } from \"../fable-library.3.1.4/String.js\";\r\nimport { Result_Map, FSharpResult$2 } from \"../fable-library.3.1.4/Choice.js\";\r\nimport { Util_CachedDecoders, Util_Cache$1__GetOrAdd_43981464, CaseStrategy, Util_Casing_convert, ErrorReason } from \"./Types.fs.js\";\r\nimport { tryParse as tryParse_2 } from \"../fable-library.3.1.4/Guid.js\";\r\nimport { toString as toString_12, FSharpRef } from \"../fable-library.3.1.4/Types.js\";\r\nimport { tryParse as tryParse_3 } from \"../fable-library.3.1.4/Int32.js\";\r\nimport { tryParse as tryParse_4, fromInt, fromNumber, toNumber, fromBits } from \"../fable-library.3.1.4/Long.js\";\r\nimport { parse, fromInt32 } from \"../fable-library.3.1.4/BigInt.js\";\r\nimport { tryParse as tryParse_5 } from \"../fable-library.3.1.4/Decimal.js\";\r\nimport Decimal from \"../fable-library.3.1.4/Decimal.js\";\r\nimport { toUniversalTime, tryParse as tryParse_6, minValue } from \"../fable-library.3.1.4/Date.js\";\r\nimport { tryParse as tryParse_7, minValue as minValue_1 } from \"../fable-library.3.1.4/DateOffset.js\";\r\nimport { tryParse as tryParse_8 } from \"../fable-library.3.1.4/TimeSpan.js\";\r\nimport { map as map_4, value as value_40, defaultArg, some } from \"../fable-library.3.1.4/Option.js\";\r\nimport { ofArray, map as map_1, length, singleton, append as append_1, ofSeq, empty, reverse, fold, tryLast, cons } from \"../fable-library.3.1.4/List.js\";\r\nimport { int16ToString, mapCurriedArgs, compare, int32ToString, uncurry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { map as map_2, tryFind, foldBack2, foldBack, fill, fold as fold_1 } from \"../fable-library.3.1.4/Array.js\";\r\nimport { contains, fold as fold_2, append, reverse as reverse_1 } from \"../fable-library.3.1.4/Seq.js\";\r\nimport { empty as empty_1, map as map_3, tryFind as tryFind_1, add, ofSeq as ofSeq_1, ofList } from \"../fable-library.3.1.4/Map.js\";\r\nimport { getGenerics, getGenericTypeDefinition, makeTuple, getTupleElements, isTuple, isGenericType, parseEnum, getEnumValues, getEnumUnderlyingType, isEnum, getElementType, isArray, isUnion, makeRecord, getRecordElements, isRecord, fullName, getUnionCaseFields, makeUnion as makeUnion_1, getUnionCases, name as name_3, class_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { ofSeq as ofSeq_2 } from \"../fable-library.3.1.4/Set.js\";\r\n\r\nexport function Helpers_isUndefined(o) {\r\n    return (typeof o) === \"undefined\";\r\n}\r\n\r\nfunction genericMsg(msg, value_1, newLine) {\r\n    try {\r\n        return (((\"Expecting \" + msg) + \" but instead got:\") + (newLine ? \"\\n\" : \" \")) + (JSON.stringify(value_1, null, 4) + '');\r\n    }\r\n    catch (matchValue) {\r\n        return ((\"Expecting \" + msg) + \" but decoder failed. Couldn\\u0027t report given value due to circular structure.\") + (newLine ? \"\\n\" : \" \");\r\n    }\r\n}\r\n\r\nfunction errorToString(path, error) {\r\n    const reason_1 = (error.tag === 2) ? genericMsg(error.fields[0], error.fields[1], true) : ((error.tag === 1) ? ((genericMsg(error.fields[0], error.fields[1], false) + \"\\nReason: \") + error.fields[2]) : ((error.tag === 3) ? genericMsg(error.fields[0], error.fields[1], true) : ((error.tag === 4) ? (genericMsg(error.fields[0], error.fields[1], true) + ((\"\\nNode `\" + error.fields[2]) + \"` is unkown.\")) : ((error.tag === 5) ? (((\"Expecting \" + error.fields[0]) + \".\\n\") + (JSON.stringify(error.fields[1], null, 4) + '')) : ((error.tag === 7) ? (\"The following errors were found:\\n\\n\" + join(\"\\n\\n\", error.fields[0])) : ((error.tag === 6) ? (\"The following `failure` occurred with the decoder: \" + error.fields[0]) : genericMsg(error.fields[0], error.fields[1], false)))))));\r\n    if (error.tag === 7) {\r\n        return reason_1;\r\n    }\r\n    else {\r\n        return ((\"Error at: `\" + path) + \"`\\n\") + reason_1;\r\n    }\r\n}\r\n\r\nexport function fromValue(path, decoder, value_1) {\r\n    const matchValue = decoder(path, value_1);\r\n    if (matchValue.tag === 1) {\r\n        const error = matchValue.fields[0];\r\n        return new FSharpResult$2(1, errorToString(error[0], error[1]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(0, matchValue.fields[0]);\r\n    }\r\n}\r\n\r\nexport function fromString(decoder, value_1) {\r\n    try {\r\n        return fromValue(\"$\", decoder, JSON.parse(value_1));\r\n    }\r\n    catch (matchValue) {\r\n        if (matchValue instanceof SyntaxError) {\r\n            return new FSharpResult$2(1, \"Given an invalid JSON: \" + matchValue.message);\r\n        }\r\n        else {\r\n            throw matchValue;\r\n        }\r\n    }\r\n}\r\n\r\nexport function unsafeFromString(decoder, value_1) {\r\n    const matchValue = fromString(decoder, value_1);\r\n    if (matchValue.tag === 1) {\r\n        throw (new Error(matchValue.fields[0]));\r\n    }\r\n    else {\r\n        return matchValue.fields[0];\r\n    }\r\n}\r\n\r\nexport function decodeValue(path, decoder) {\r\n    const decoder_1 = decoder;\r\n    return (value_1) => fromValue(path, decoder_1, value_1);\r\n}\r\n\r\nexport function decodeString(decoder) {\r\n    const decoder_1 = decoder;\r\n    return (value_1) => fromString(decoder_1, value_1);\r\n}\r\n\r\nexport function string(path, value_1) {\r\n    if ((typeof value_1) === \"string\") {\r\n        return new FSharpResult$2(0, value_1);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a string\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function guid(path, value_1) {\r\n    if ((typeof value_1) === \"string\") {\r\n        let matchValue;\r\n        let outArg = \"00000000-0000-0000-0000-000000000000\";\r\n        matchValue = [tryParse_2(value_1, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        if (matchValue[0]) {\r\n            return new FSharpResult$2(0, matchValue[1]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a guid\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a guid\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function unit(path, value_1) {\r\n    if (value_1 == null) {\r\n        return new FSharpResult$2(0, void 0);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"null\", value_1)]);\r\n    }\r\n}\r\n\r\nexport const sbyte = (path) => ((value_2) => {\r\n    const name_1 = \"a sbyte\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((-128 <= value_4) ? (value_4 <= 127) : false) ? (new FSharpResult$2(0, (value_4 + 0x80 & 0xFF) - 0x80)) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, false, 8, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const byte = (path) => ((value_2) => {\r\n    const name_1 = \"a byte\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((0 <= value_4) ? (value_4 <= 255) : false) ? (new FSharpResult$2(0, value_4 & 0xFF)) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, true, 8, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const int16 = (path) => ((value_2) => {\r\n    const name_1 = \"an int16\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((-32768 <= value_4) ? (value_4 <= 32767) : false) ? (new FSharpResult$2(0, (value_4 + 0x8000 & 0xFFFF) - 0x8000)) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, false, 16, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const uint16 = (path) => ((value_2) => {\r\n    const name_1 = \"an uint16\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((0 <= value_4) ? (value_4 <= 65535) : false) ? (new FSharpResult$2(0, value_4 & 0xFFFF)) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, true, 16, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const int = (path) => ((value_2) => {\r\n    const name_1 = \"an int\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((-2147483648 <= value_4) ? (value_4 <= 2147483647) : false) ? (new FSharpResult$2(0, ~(~value_4))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, false, 32, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const uint32 = (path) => ((value_2) => {\r\n    const name_1 = \"an uint32\";\r\n    const path_1 = path;\r\n    const value_3 = value_2;\r\n    if ((typeof value_3) === \"number\") {\r\n        const value_4 = value_3;\r\n        return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((0 <= value_4) ? (value_4 <= 4294967295) : false) ? (new FSharpResult$2(0, value_4 >>> 0)) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n    }\r\n    else if ((typeof value_3) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_3(value_3, 511, true, 32, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n    }\r\n});\r\n\r\nexport const int64 = (() => {\r\n    const min = fromBits(0, 2147483648, false);\r\n    const max = fromBits(4294967295, 2147483647, false);\r\n    return (path) => ((value_2) => {\r\n        const name_1 = \"an int64\";\r\n        const path_1 = path;\r\n        const value_3 = value_2;\r\n        if ((typeof value_3) === \"number\") {\r\n            const value_4 = value_3;\r\n            return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((toNumber(min) <= value_4) ? (value_4 <= toNumber(max)) : false) ? (new FSharpResult$2(0, fromNumber(value_4, false))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n        }\r\n        else if ((typeof value_3) === \"string\") {\r\n            let matchValue;\r\n            let outArg = fromInt(0);\r\n            matchValue = [tryParse_4(value_3, 511, false, 64, new FSharpRef(() => outArg, (v) => {\r\n                outArg = v;\r\n            })), outArg];\r\n            return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n        }\r\n    });\r\n})();\r\n\r\nexport const uint64 = (() => {\r\n    const min = fromBits(0, 0, true);\r\n    const max = fromBits(4294967295, 4294967295, true);\r\n    return (path) => ((value_2) => {\r\n        const name_1 = \"an uint64\";\r\n        const path_1 = path;\r\n        const value_3 = value_2;\r\n        if ((typeof value_3) === \"number\") {\r\n            const value_4 = value_3;\r\n            return (isFinite(value_4) && Math.floor(value_4) === value_4) ? (((toNumber(min) <= value_4) ? (value_4 <= toNumber(max)) : false) ? (new FSharpResult$2(0, fromNumber(value_4, true))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value was either too large or too small for \" + name_1)]))) : (new FSharpResult$2(1, [path_1, new ErrorReason(1, name_1, value_4, \"Value is not an integral value\")]));\r\n        }\r\n        else if ((typeof value_3) === \"string\") {\r\n            let matchValue;\r\n            let outArg = fromInt(0);\r\n            matchValue = [tryParse_4(value_3, 511, true, 64, new FSharpRef(() => outArg, (v) => {\r\n                outArg = v;\r\n            })), outArg];\r\n            return matchValue[0] ? (new FSharpResult$2(0, matchValue[1])) : (new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]));\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path_1, new ErrorReason(0, name_1, value_3)]);\r\n        }\r\n    });\r\n})();\r\n\r\nexport function bigint(path, value_1) {\r\n    if ((typeof value_1) === \"number\") {\r\n        return new FSharpResult$2(0, fromInt32(value_1));\r\n    }\r\n    else if ((typeof value_1) === \"string\") {\r\n        try {\r\n            return new FSharpResult$2(0, parse(value_1));\r\n        }\r\n        catch (matchValue) {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a bigint\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a bigint\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function bool(path, value_1) {\r\n    if ((typeof value_1) === \"boolean\") {\r\n        return new FSharpResult$2(0, value_1);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a boolean\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function float(path, value_1) {\r\n    if ((typeof value_1) === \"number\") {\r\n        return new FSharpResult$2(0, value_1);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a float\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function float32(path, value_1) {\r\n    if ((typeof value_1) === \"number\") {\r\n        return new FSharpResult$2(0, value_1);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a float32\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function decimal(path, value_1) {\r\n    if ((typeof value_1) === \"number\") {\r\n        return new FSharpResult$2(0, new Decimal(value_1));\r\n    }\r\n    else if ((typeof value_1) === \"string\") {\r\n        let matchValue;\r\n        let outArg = new Decimal(0);\r\n        matchValue = [tryParse_5(value_1, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        if (matchValue[0]) {\r\n            return new FSharpResult$2(0, matchValue[1]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a decimal\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a decimal\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function datetime(path, value_1) {\r\n    if ((typeof value_1) === \"string\") {\r\n        let matchValue;\r\n        let outArg = minValue();\r\n        matchValue = [tryParse_6(value_1, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        if (matchValue[0]) {\r\n            return new FSharpResult$2(0, toUniversalTime(matchValue[1]));\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a datetime\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a datetime\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function datetimeOffset(path, value_1) {\r\n    if ((typeof value_1) === \"string\") {\r\n        let matchValue;\r\n        let outArg = minValue_1();\r\n        matchValue = [tryParse_7(value_1, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        if (matchValue[0]) {\r\n            return new FSharpResult$2(0, matchValue[1]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a datetimeoffset\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a datetime\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function timespan(path, value_1) {\r\n    if ((typeof value_1) === \"string\") {\r\n        let matchValue;\r\n        let outArg = 0;\r\n        matchValue = [tryParse_8(value_1, new FSharpRef(() => outArg, (v) => {\r\n            outArg = v;\r\n        })), outArg];\r\n        if (matchValue[0]) {\r\n            return new FSharpResult$2(0, matchValue[1]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(0, \"a timespan\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a timespan\", value_1)]);\r\n    }\r\n}\r\n\r\nfunction decodeMaybeNull(path, decoder, value_1) {\r\n    const matchValue = decoder(path, value_1);\r\n    if (matchValue.tag === 1) {\r\n        if (value_1 == null) {\r\n            return new FSharpResult$2(0, void 0);\r\n        }\r\n        else if (matchValue.tag === 1) {\r\n            return new FSharpResult$2(1, matchValue.fields[0]);\r\n        }\r\n        else {\r\n            throw (new Error(\"The match cases were incomplete\"));\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(0, some(matchValue.fields[0]));\r\n    }\r\n}\r\n\r\nexport function optional(fieldName, decoder, path, value_1) {\r\n    if (value_1 === null ? false : (Object.getPrototypeOf(value_1 || false) === Object.prototype)) {\r\n        const fieldValue = value_1[fieldName];\r\n        if (Helpers_isUndefined(fieldValue)) {\r\n            return new FSharpResult$2(0, void 0);\r\n        }\r\n        else {\r\n            return decodeMaybeNull((path + \".\") + fieldName, decoder, fieldValue);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(2, \"an object\", value_1)]);\r\n    }\r\n}\r\n\r\nfunction badPathError(fieldNames, currentPath, value_1) {\r\n    return new FSharpResult$2(1, [defaultArg(currentPath, join(\".\", cons(\"$\", fieldNames))), new ErrorReason(4, (\"an object with path `\" + join(\".\", fieldNames)) + \"`\", value_1, defaultArg(tryLast(fieldNames), \"\"))]);\r\n}\r\n\r\nexport function optionalAt(fieldNames, decoder, firstPath, firstValue) {\r\n    const _arg1 = fold(uncurry(2, (tupledArg) => {\r\n        const curPath = tupledArg[0];\r\n        const curValue = tupledArg[1];\r\n        const res = tupledArg[2];\r\n        return (field_1) => ((res == null) ? ((curValue == null) ? [curPath, curValue, badPathError(fieldNames, curPath, firstValue)] : ((curValue === null ? false : (Object.getPrototypeOf(curValue || false) === Object.prototype)) ? [(curPath + \".\") + field_1, curValue[field_1], void 0] : [curPath, curValue, new FSharpResult$2(1, [curPath, new ErrorReason(2, \"an object\", curValue)])])) : [curPath, curValue, res]);\r\n    }), [firstPath, firstValue, void 0], fieldNames);\r\n    if (_arg1[2] == null) {\r\n        const lastValue = _arg1[1];\r\n        if (Helpers_isUndefined(lastValue)) {\r\n            return new FSharpResult$2(0, void 0);\r\n        }\r\n        else {\r\n            return decodeMaybeNull(_arg1[0], decoder, lastValue);\r\n        }\r\n    }\r\n    else {\r\n        return _arg1[2];\r\n    }\r\n}\r\n\r\nexport function field(fieldName, decoder, path, value_1) {\r\n    if (value_1 === null ? false : (Object.getPrototypeOf(value_1 || false) === Object.prototype)) {\r\n        const fieldValue = value_1[fieldName];\r\n        if (Helpers_isUndefined(fieldValue)) {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(3, (\"an object with a field named `\" + fieldName) + \"`\", value_1)]);\r\n        }\r\n        else {\r\n            return decoder((path + \".\") + fieldName, fieldValue);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(2, \"an object\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function at(fieldNames, decoder, firstPath, firstValue) {\r\n    const _arg1 = fold(uncurry(2, (tupledArg) => {\r\n        const curPath = tupledArg[0];\r\n        const curValue = tupledArg[1];\r\n        const res = tupledArg[2];\r\n        return (field_1) => {\r\n            if (res == null) {\r\n                if (curValue == null) {\r\n                    return [curPath, curValue, badPathError(fieldNames, curPath, firstValue)];\r\n                }\r\n                else if (curValue === null ? false : (Object.getPrototypeOf(curValue || false) === Object.prototype)) {\r\n                    const curValue_1 = curValue[field_1];\r\n                    return Helpers_isUndefined(curValue_1) ? [curPath, curValue_1, badPathError(fieldNames, void 0, firstValue)] : [(curPath + \".\") + field_1, curValue_1, void 0];\r\n                }\r\n                else {\r\n                    return [curPath, curValue, new FSharpResult$2(1, [curPath, new ErrorReason(2, \"an object\", curValue)])];\r\n                }\r\n            }\r\n            else {\r\n                return [curPath, curValue, res];\r\n            }\r\n        };\r\n    }), [firstPath, firstValue, void 0], fieldNames);\r\n    if (_arg1[2] == null) {\r\n        return decoder(_arg1[0], _arg1[1]);\r\n    }\r\n    else {\r\n        return _arg1[2];\r\n    }\r\n}\r\n\r\nexport function index(requestedIndex, decoder, path, value_1) {\r\n    let copyOfStruct;\r\n    const currentPath = ((path + \".[\") + int32ToString(requestedIndex)) + \"]\";\r\n    if (Array.isArray(value_1)) {\r\n        const vArray = value_1;\r\n        if (requestedIndex < vArray.length) {\r\n            return decoder(currentPath, vArray[requestedIndex]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, [currentPath, new ErrorReason(5, (((\"a longer array. Need index `\" + int32ToString(requestedIndex)) + \"` but there are only `\") + (copyOfStruct = (vArray.length | 0), int32ToString(copyOfStruct))) + \"` entries\", value_1)]);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [currentPath, new ErrorReason(0, \"an array\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function option(decoder, path, value_1) {\r\n    if (value_1 == null) {\r\n        return new FSharpResult$2(0, void 0);\r\n    }\r\n    else {\r\n        return Result_Map((arg0) => some(arg0), decoder(path, value_1));\r\n    }\r\n}\r\n\r\nexport function list(decoder, path, value_1) {\r\n    if (Array.isArray(value_1)) {\r\n        let i = -1;\r\n        return Result_Map((list_1) => reverse(list_1), fold_1((acc, value_2) => {\r\n            i = (i + 1);\r\n            if (acc.tag === 0) {\r\n                const matchValue = decoder(((path + \".[\") + int32ToString(i)) + \"]\", value_2);\r\n                if (matchValue.tag === 0) {\r\n                    return new FSharpResult$2(0, cons(matchValue.fields[0], acc.fields[0]));\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(1, matchValue.fields[0]);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }, new FSharpResult$2(0, empty()), value_1));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a list\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function seq(decoder, path, value_1) {\r\n    if (Array.isArray(value_1)) {\r\n        let i = -1;\r\n        return Result_Map((source) => reverse_1(source), fold_1((acc, value_2) => {\r\n            i = (i + 1);\r\n            if (acc.tag === 0) {\r\n                const matchValue = decoder(((path + \".[\") + int32ToString(i)) + \"]\", value_2);\r\n                if (matchValue.tag === 0) {\r\n                    return new FSharpResult$2(0, append([matchValue.fields[0]], acc.fields[0]));\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(1, matchValue.fields[0]);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }, new FSharpResult$2(0, []), value_1));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"a seq\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function array(decoder, path, value_1) {\r\n    if (Array.isArray(value_1)) {\r\n        let i = -1;\r\n        const tokens = value_1;\r\n        return fold_1((acc, value_2) => {\r\n            i = (i + 1);\r\n            if (acc.tag === 0) {\r\n                const acc_1 = acc.fields[0];\r\n                const matchValue = decoder(((path + \".[\") + int32ToString(i)) + \"]\", value_2);\r\n                if (matchValue.tag === 0) {\r\n                    acc_1[i] = matchValue.fields[0];\r\n                    return new FSharpResult$2(0, acc_1);\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(1, matchValue.fields[0]);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }, new FSharpResult$2(0, fill(new Array(tokens.length), 0, tokens.length, null)), tokens);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"an array\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function keys(path, value_1) {\r\n    if (value_1 === null ? false : (Object.getPrototypeOf(value_1 || false) === Object.prototype)) {\r\n        return new FSharpResult$2(0, ofSeq(Object.keys(value_1)));\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"an object\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function keyValuePairs(decoder, path, value_1) {\r\n    const matchValue = keys(path, value_1);\r\n    if (matchValue.tag === 1) {\r\n        return new FSharpResult$2(1, matchValue.fields[0]);\r\n    }\r\n    else {\r\n        return Result_Map((list_2) => reverse(list_2), fold((acc, prop) => {\r\n            if (acc.tag === 0) {\r\n                const matchValue_1 = decoder(path, value_1[prop]);\r\n                if (matchValue_1.tag === 0) {\r\n                    return new FSharpResult$2(0, cons([prop, matchValue_1.fields[0]], acc.fields[0]));\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(1, matchValue_1.fields[0]);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }, new FSharpResult$2(0, empty()), matchValue.fields[0]));\r\n    }\r\n}\r\n\r\nexport function oneOf(decoders, path, value_1) {\r\n    const runner = (decoders_1_mut, errors_mut) => {\r\n        runner:\r\n        while (true) {\r\n            const decoders_1 = decoders_1_mut, errors = errors_mut;\r\n            if (decoders_1.tail == null) {\r\n                return new FSharpResult$2(1, [path, new ErrorReason(7, errors)]);\r\n            }\r\n            else {\r\n                const matchValue = fromValue(path, uncurry(2, decoders_1.head), value_1);\r\n                if (matchValue.tag === 1) {\r\n                    decoders_1_mut = decoders_1.tail;\r\n                    errors_mut = append_1(errors, singleton(matchValue.fields[0]));\r\n                    continue runner;\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(0, matchValue.fields[0]);\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return runner(decoders, empty());\r\n}\r\n\r\nexport function nil(output, path, value_1) {\r\n    if (value_1 == null) {\r\n        return new FSharpResult$2(0, output);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"null\", value_1)]);\r\n    }\r\n}\r\n\r\nexport function value(_arg1, v) {\r\n    return new FSharpResult$2(0, v);\r\n}\r\n\r\nexport function succeed(output, _arg2, _arg1) {\r\n    return new FSharpResult$2(0, output);\r\n}\r\n\r\nexport function fail(msg, path, _arg1) {\r\n    return new FSharpResult$2(1, [path, new ErrorReason(6, msg)]);\r\n}\r\n\r\nexport function andThen(cb, decoder, path, value_1) {\r\n    const matchValue = decoder(path, value_1);\r\n    if (matchValue.tag === 0) {\r\n        return cb(matchValue.fields[0], path, value_1);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, matchValue.fields[0]);\r\n    }\r\n}\r\n\r\nexport function all(decoders, path, value_1) {\r\n    const runner = (decoders_1_mut, values_mut) => {\r\n        runner:\r\n        while (true) {\r\n            const decoders_1 = decoders_1_mut, values = values_mut;\r\n            if (decoders_1.tail == null) {\r\n                return new FSharpResult$2(0, values);\r\n            }\r\n            else {\r\n                const matchValue = decoders_1.head(path)(value_1);\r\n                if (matchValue.tag === 1) {\r\n                    return new FSharpResult$2(1, matchValue.fields[0]);\r\n                }\r\n                else {\r\n                    decoders_1_mut = decoders_1.tail;\r\n                    values_mut = append_1(values, singleton(matchValue.fields[0]));\r\n                    continue runner;\r\n                }\r\n            }\r\n            break;\r\n        }\r\n    };\r\n    return runner(decoders, empty());\r\n}\r\n\r\nexport function map(ctor, d1, path, value_1) {\r\n    const matchValue = d1(path, value_1);\r\n    if (matchValue.tag === 1) {\r\n        return new FSharpResult$2(1, matchValue.fields[0]);\r\n    }\r\n    else {\r\n        return new FSharpResult$2(0, ctor(matchValue.fields[0]));\r\n    }\r\n}\r\n\r\nexport function map2(ctor, d1, d2, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0]));\r\n        }\r\n    }\r\n}\r\n\r\nexport function map3(ctor, d1, d2, d3, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0]));\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function map4(ctor, d1, d2, d3, d4, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1), d4(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                const copyOfStruct_3 = matchValue[3];\r\n                if (copyOfStruct_3.tag === 1) {\r\n                    return new FSharpResult$2(1, copyOfStruct_3.fields[0]);\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0], copyOfStruct_3.fields[0]));\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function map5(ctor, d1, d2, d3, d4, d5, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1), d4(path, value_1), d5(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                const copyOfStruct_3 = matchValue[3];\r\n                if (copyOfStruct_3.tag === 1) {\r\n                    return new FSharpResult$2(1, copyOfStruct_3.fields[0]);\r\n                }\r\n                else {\r\n                    const copyOfStruct_4 = matchValue[4];\r\n                    if (copyOfStruct_4.tag === 1) {\r\n                        return new FSharpResult$2(1, copyOfStruct_4.fields[0]);\r\n                    }\r\n                    else {\r\n                        return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0], copyOfStruct_3.fields[0], copyOfStruct_4.fields[0]));\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function map6(ctor, d1, d2, d3, d4, d5, d6, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1), d4(path, value_1), d5(path, value_1), d6(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                const copyOfStruct_3 = matchValue[3];\r\n                if (copyOfStruct_3.tag === 1) {\r\n                    return new FSharpResult$2(1, copyOfStruct_3.fields[0]);\r\n                }\r\n                else {\r\n                    const copyOfStruct_4 = matchValue[4];\r\n                    if (copyOfStruct_4.tag === 1) {\r\n                        return new FSharpResult$2(1, copyOfStruct_4.fields[0]);\r\n                    }\r\n                    else {\r\n                        const copyOfStruct_5 = matchValue[5];\r\n                        if (copyOfStruct_5.tag === 1) {\r\n                            return new FSharpResult$2(1, copyOfStruct_5.fields[0]);\r\n                        }\r\n                        else {\r\n                            return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0], copyOfStruct_3.fields[0], copyOfStruct_4.fields[0], copyOfStruct_5.fields[0]));\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function map7(ctor, d1, d2, d3, d4, d5, d6, d7, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1), d4(path, value_1), d5(path, value_1), d6(path, value_1), d7(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                const copyOfStruct_3 = matchValue[3];\r\n                if (copyOfStruct_3.tag === 1) {\r\n                    return new FSharpResult$2(1, copyOfStruct_3.fields[0]);\r\n                }\r\n                else {\r\n                    const copyOfStruct_4 = matchValue[4];\r\n                    if (copyOfStruct_4.tag === 1) {\r\n                        return new FSharpResult$2(1, copyOfStruct_4.fields[0]);\r\n                    }\r\n                    else {\r\n                        const copyOfStruct_5 = matchValue[5];\r\n                        if (copyOfStruct_5.tag === 1) {\r\n                            return new FSharpResult$2(1, copyOfStruct_5.fields[0]);\r\n                        }\r\n                        else {\r\n                            const copyOfStruct_6 = matchValue[6];\r\n                            if (copyOfStruct_6.tag === 1) {\r\n                                return new FSharpResult$2(1, copyOfStruct_6.fields[0]);\r\n                            }\r\n                            else {\r\n                                return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0], copyOfStruct_3.fields[0], copyOfStruct_4.fields[0], copyOfStruct_5.fields[0], copyOfStruct_6.fields[0]));\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function map8(ctor, d1, d2, d3, d4, d5, d6, d7, d8, path, value_1) {\r\n    const matchValue = [d1(path, value_1), d2(path, value_1), d3(path, value_1), d4(path, value_1), d5(path, value_1), d6(path, value_1), d7(path, value_1), d8(path, value_1)];\r\n    const copyOfStruct = matchValue[0];\r\n    if (copyOfStruct.tag === 1) {\r\n        return new FSharpResult$2(1, copyOfStruct.fields[0]);\r\n    }\r\n    else {\r\n        const copyOfStruct_1 = matchValue[1];\r\n        if (copyOfStruct_1.tag === 1) {\r\n            return new FSharpResult$2(1, copyOfStruct_1.fields[0]);\r\n        }\r\n        else {\r\n            const copyOfStruct_2 = matchValue[2];\r\n            if (copyOfStruct_2.tag === 1) {\r\n                return new FSharpResult$2(1, copyOfStruct_2.fields[0]);\r\n            }\r\n            else {\r\n                const copyOfStruct_3 = matchValue[3];\r\n                if (copyOfStruct_3.tag === 1) {\r\n                    return new FSharpResult$2(1, copyOfStruct_3.fields[0]);\r\n                }\r\n                else {\r\n                    const copyOfStruct_4 = matchValue[4];\r\n                    if (copyOfStruct_4.tag === 1) {\r\n                        return new FSharpResult$2(1, copyOfStruct_4.fields[0]);\r\n                    }\r\n                    else {\r\n                        const copyOfStruct_5 = matchValue[5];\r\n                        if (copyOfStruct_5.tag === 1) {\r\n                            return new FSharpResult$2(1, copyOfStruct_5.fields[0]);\r\n                        }\r\n                        else {\r\n                            const copyOfStruct_6 = matchValue[6];\r\n                            if (copyOfStruct_6.tag === 1) {\r\n                                return new FSharpResult$2(1, copyOfStruct_6.fields[0]);\r\n                            }\r\n                            else {\r\n                                const copyOfStruct_7 = matchValue[7];\r\n                                if (copyOfStruct_7.tag === 1) {\r\n                                    return new FSharpResult$2(1, copyOfStruct_7.fields[0]);\r\n                                }\r\n                                else {\r\n                                    return new FSharpResult$2(0, ctor(copyOfStruct.fields[0], copyOfStruct_1.fields[0], copyOfStruct_2.fields[0], copyOfStruct_3.fields[0], copyOfStruct_4.fields[0], copyOfStruct_5.fields[0], copyOfStruct_6.fields[0], copyOfStruct_7.fields[0]));\r\n                                }\r\n                            }\r\n                        }\r\n                    }\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport function dict(decoder) {\r\n    let d1;\r\n    const decoder_1 = decoder;\r\n    d1 = ((path) => ((value_1) => keyValuePairs(decoder_1, path, value_1)));\r\n    return (path_1) => ((value_2) => map((elements) => ofList(elements), uncurry(2, d1), path_1, value_2));\r\n}\r\n\r\nfunction unwrapWith(errors, path, decoder, value_1) {\r\n    const matchValue = decoder(path, value_1);\r\n    if (matchValue.tag === 1) {\r\n        void (errors.push(matchValue.fields[0]));\r\n        return null;\r\n    }\r\n    else {\r\n        return matchValue.fields[0];\r\n    }\r\n}\r\n\r\nexport class Getters$1 {\r\n    constructor(path, v) {\r\n        this.errors = [];\r\n        const _this = this;\r\n        this.required = {\r\n            Field(fieldName, decoder) {\r\n                return unwrapWith(_this.errors, path, (path_1, value_1) => field(fieldName, decoder, path_1, value_1), v);\r\n            },\r\n            At(fieldNames, decoder_2) {\r\n                return unwrapWith(_this.errors, path, (firstPath, firstValue) => at(fieldNames, decoder_2, firstPath, firstValue), v);\r\n            },\r\n            Raw(decoder_4) {\r\n                return unwrapWith(_this.errors, path, decoder_4, v);\r\n            },\r\n        };\r\n        const _this_1 = this;\r\n        this.optional = {\r\n            Field(fieldName_1, decoder_5) {\r\n                return unwrapWith(_this_1.errors, path, (path_2, value_2) => optional(fieldName_1, decoder_5, path_2, value_2), v);\r\n            },\r\n            At(fieldNames_1, decoder_7) {\r\n                return unwrapWith(_this_1.errors, path, (firstPath_1, firstValue_1) => optionalAt(fieldNames_1, decoder_7, firstPath_1, firstValue_1), v);\r\n            },\r\n            Raw(decoder_9) {\r\n                const matchValue = decoder_9(path, v);\r\n                if (matchValue.tag === 1) {\r\n                    const reason = matchValue.fields[0][1];\r\n                    const error = matchValue.fields[0];\r\n                    let pattern_matching_result, v_2;\r\n                    switch (reason.tag) {\r\n                        case 1: {\r\n                            pattern_matching_result = 0;\r\n                            v_2 = reason.fields[1];\r\n                            break;\r\n                        }\r\n                        case 2: {\r\n                            pattern_matching_result = 0;\r\n                            v_2 = reason.fields[1];\r\n                            break;\r\n                        }\r\n                        case 3:\r\n                        case 4: {\r\n                            pattern_matching_result = 1;\r\n                            break;\r\n                        }\r\n                        case 5:\r\n                        case 6:\r\n                        case 7: {\r\n                            pattern_matching_result = 2;\r\n                            break;\r\n                        }\r\n                        default: {\r\n                            pattern_matching_result = 0;\r\n                            v_2 = reason.fields[1];\r\n                        }\r\n                    }\r\n                    switch (pattern_matching_result) {\r\n                        case 0: {\r\n                            if (v_2 == null) {\r\n                                return void 0;\r\n                            }\r\n                            else {\r\n                                void (_this_1.errors.push(error));\r\n                                return null;\r\n                            }\r\n                        }\r\n                        case 1: {\r\n                            return void 0;\r\n                        }\r\n                        case 2: {\r\n                            void (_this_1.errors.push(error));\r\n                            return null;\r\n                        }\r\n                    }\r\n                }\r\n                else {\r\n                    return some(matchValue.fields[0]);\r\n                }\r\n            },\r\n        };\r\n    }\r\n    get Required() {\r\n        const __ = this;\r\n        return __.required;\r\n    }\r\n    get Optional() {\r\n        const __ = this;\r\n        return __.optional;\r\n    }\r\n}\r\n\r\nexport function Getters$1$reflection(gen0) {\r\n    return class_type(\"Thoth.Json.Decode.Getters`1\", [gen0], Getters$1);\r\n}\r\n\r\nexport function Getters$1_$ctor_4A51B60E(path, v) {\r\n    return new Getters$1(path, v);\r\n}\r\n\r\nexport function Getters$1__get_Errors(__) {\r\n    return ofSeq(__.errors);\r\n}\r\n\r\nexport function object(builder, path, v) {\r\n    const getters = Getters$1_$ctor_4A51B60E(path, v);\r\n    const result = builder(getters);\r\n    const matchValue = Getters$1__get_Errors(getters);\r\n    if (matchValue.tail != null) {\r\n        const errors = matchValue;\r\n        if (length(errors) > 1) {\r\n            return new FSharpResult$2(1, [path, new ErrorReason(7, map_1((tupledArg) => errorToString(tupledArg[0], tupledArg[1]), errors))]);\r\n        }\r\n        else {\r\n            return new FSharpResult$2(1, matchValue.head);\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(0, result);\r\n    }\r\n}\r\n\r\nexport function tuple2(decoder1, decoder2) {\r\n    let decoder_3;\r\n    const decoder = decoder1;\r\n    decoder_3 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_3) => ((value_4) => andThen(uncurry(3, (v1) => {\r\n        let decoder_2;\r\n        const decoder_1 = decoder2;\r\n        decoder_2 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_2) => ((value_3) => andThen((v2, arg10$0040, arg20$0040) => succeed([v1, v2], arg10$0040, arg20$0040), uncurry(2, decoder_2), path_2, value_3));\r\n    }), uncurry(2, decoder_3), path_3, value_4));\r\n}\r\n\r\nexport function tuple3(decoder1, decoder2, decoder3) {\r\n    let decoder_5;\r\n    const decoder = decoder1;\r\n    decoder_5 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_5) => ((value_6) => andThen(uncurry(3, (v1) => {\r\n        let decoder_4;\r\n        const decoder_1 = decoder2;\r\n        decoder_4 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_4) => ((value_5) => andThen(uncurry(3, (v2) => {\r\n            let decoder_3;\r\n            const decoder_2 = decoder3;\r\n            decoder_3 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_3) => ((value_4) => andThen((v3, arg10$0040, arg20$0040) => succeed([v1, v2, v3], arg10$0040, arg20$0040), uncurry(2, decoder_3), path_3, value_4));\r\n        }), uncurry(2, decoder_4), path_4, value_5));\r\n    }), uncurry(2, decoder_5), path_5, value_6));\r\n}\r\n\r\nexport function tuple4(decoder1, decoder2, decoder3, decoder4) {\r\n    let decoder_7;\r\n    const decoder = decoder1;\r\n    decoder_7 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_7) => ((value_8) => andThen(uncurry(3, (v1) => {\r\n        let decoder_6;\r\n        const decoder_1 = decoder2;\r\n        decoder_6 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_6) => ((value_7) => andThen(uncurry(3, (v2) => {\r\n            let decoder_5;\r\n            const decoder_2 = decoder3;\r\n            decoder_5 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_5) => ((value_6) => andThen(uncurry(3, (v3) => {\r\n                let decoder_4;\r\n                const decoder_3 = decoder4;\r\n                decoder_4 = ((path_3) => ((value_4) => index(3, decoder_3, path_3, value_4)));\r\n                return (path_4) => ((value_5) => andThen((v4, arg10$0040, arg20$0040) => succeed([v1, v2, v3, v4], arg10$0040, arg20$0040), uncurry(2, decoder_4), path_4, value_5));\r\n            }), uncurry(2, decoder_5), path_5, value_6));\r\n        }), uncurry(2, decoder_6), path_6, value_7));\r\n    }), uncurry(2, decoder_7), path_7, value_8));\r\n}\r\n\r\nexport function tuple5(decoder1, decoder2, decoder3, decoder4, decoder5) {\r\n    let decoder_9;\r\n    const decoder = decoder1;\r\n    decoder_9 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_9) => ((value_10) => andThen(uncurry(3, (v1) => {\r\n        let decoder_8;\r\n        const decoder_1 = decoder2;\r\n        decoder_8 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_8) => ((value_9) => andThen(uncurry(3, (v2) => {\r\n            let decoder_7;\r\n            const decoder_2 = decoder3;\r\n            decoder_7 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_7) => ((value_8) => andThen(uncurry(3, (v3) => {\r\n                let decoder_6;\r\n                const decoder_3 = decoder4;\r\n                decoder_6 = ((path_3) => ((value_4) => index(3, decoder_3, path_3, value_4)));\r\n                return (path_6) => ((value_7) => andThen(uncurry(3, (v4) => {\r\n                    let decoder_5;\r\n                    const decoder_4 = decoder5;\r\n                    decoder_5 = ((path_4) => ((value_5) => index(4, decoder_4, path_4, value_5)));\r\n                    return (path_5) => ((value_6) => andThen((v5, arg10$0040, arg20$0040) => succeed([v1, v2, v3, v4, v5], arg10$0040, arg20$0040), uncurry(2, decoder_5), path_5, value_6));\r\n                }), uncurry(2, decoder_6), path_6, value_7));\r\n            }), uncurry(2, decoder_7), path_7, value_8));\r\n        }), uncurry(2, decoder_8), path_8, value_9));\r\n    }), uncurry(2, decoder_9), path_9, value_10));\r\n}\r\n\r\nexport function tuple6(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6) {\r\n    let decoder_11;\r\n    const decoder = decoder1;\r\n    decoder_11 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_11) => ((value_12) => andThen(uncurry(3, (v1) => {\r\n        let decoder_10;\r\n        const decoder_1 = decoder2;\r\n        decoder_10 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_10) => ((value_11) => andThen(uncurry(3, (v2) => {\r\n            let decoder_9;\r\n            const decoder_2 = decoder3;\r\n            decoder_9 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_9) => ((value_10) => andThen(uncurry(3, (v3) => {\r\n                let decoder_8;\r\n                const decoder_3 = decoder4;\r\n                decoder_8 = ((path_3) => ((value_4) => index(3, decoder_3, path_3, value_4)));\r\n                return (path_8) => ((value_9) => andThen(uncurry(3, (v4) => {\r\n                    let decoder_7;\r\n                    const decoder_4 = decoder5;\r\n                    decoder_7 = ((path_4) => ((value_5) => index(4, decoder_4, path_4, value_5)));\r\n                    return (path_7) => ((value_8) => andThen(uncurry(3, (v5) => {\r\n                        let decoder_6;\r\n                        const decoder_5 = decoder6;\r\n                        decoder_6 = ((path_5) => ((value_6) => index(5, decoder_5, path_5, value_6)));\r\n                        return (path_6) => ((value_7) => andThen((v6, arg10$0040, arg20$0040) => succeed([v1, v2, v3, v4, v5, v6], arg10$0040, arg20$0040), uncurry(2, decoder_6), path_6, value_7));\r\n                    }), uncurry(2, decoder_7), path_7, value_8));\r\n                }), uncurry(2, decoder_8), path_8, value_9));\r\n            }), uncurry(2, decoder_9), path_9, value_10));\r\n        }), uncurry(2, decoder_10), path_10, value_11));\r\n    }), uncurry(2, decoder_11), path_11, value_12));\r\n}\r\n\r\nexport function tuple7(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7) {\r\n    let decoder_13;\r\n    const decoder = decoder1;\r\n    decoder_13 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_13) => ((value_14) => andThen(uncurry(3, (v1) => {\r\n        let decoder_12;\r\n        const decoder_1 = decoder2;\r\n        decoder_12 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_12) => ((value_13) => andThen(uncurry(3, (v2) => {\r\n            let decoder_11;\r\n            const decoder_2 = decoder3;\r\n            decoder_11 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_11) => ((value_12) => andThen(uncurry(3, (v3) => {\r\n                let decoder_10;\r\n                const decoder_3 = decoder4;\r\n                decoder_10 = ((path_3) => ((value_4) => index(3, decoder_3, path_3, value_4)));\r\n                return (path_10) => ((value_11) => andThen(uncurry(3, (v4) => {\r\n                    let decoder_9;\r\n                    const decoder_4 = decoder5;\r\n                    decoder_9 = ((path_4) => ((value_5) => index(4, decoder_4, path_4, value_5)));\r\n                    return (path_9) => ((value_10) => andThen(uncurry(3, (v5) => {\r\n                        let decoder_8;\r\n                        const decoder_5 = decoder6;\r\n                        decoder_8 = ((path_5) => ((value_6) => index(5, decoder_5, path_5, value_6)));\r\n                        return (path_8) => ((value_9) => andThen(uncurry(3, (v6) => {\r\n                            let decoder_7;\r\n                            const decoder_6 = decoder7;\r\n                            decoder_7 = ((path_6) => ((value_7) => index(6, decoder_6, path_6, value_7)));\r\n                            return (path_7) => ((value_8) => andThen((v7, arg10$0040, arg20$0040) => succeed([v1, v2, v3, v4, v5, v6, v7], arg10$0040, arg20$0040), uncurry(2, decoder_7), path_7, value_8));\r\n                        }), uncurry(2, decoder_8), path_8, value_9));\r\n                    }), uncurry(2, decoder_9), path_9, value_10));\r\n                }), uncurry(2, decoder_10), path_10, value_11));\r\n            }), uncurry(2, decoder_11), path_11, value_12));\r\n        }), uncurry(2, decoder_12), path_12, value_13));\r\n    }), uncurry(2, decoder_13), path_13, value_14));\r\n}\r\n\r\nexport function tuple8(decoder1, decoder2, decoder3, decoder4, decoder5, decoder6, decoder7, decoder8) {\r\n    let decoder_15;\r\n    const decoder = decoder1;\r\n    decoder_15 = ((path) => ((value_1) => index(0, decoder, path, value_1)));\r\n    return (path_15) => ((value_16) => andThen(uncurry(3, (v1) => {\r\n        let decoder_14;\r\n        const decoder_1 = decoder2;\r\n        decoder_14 = ((path_1) => ((value_2) => index(1, decoder_1, path_1, value_2)));\r\n        return (path_14) => ((value_15) => andThen(uncurry(3, (v2) => {\r\n            let decoder_13;\r\n            const decoder_2 = decoder3;\r\n            decoder_13 = ((path_2) => ((value_3) => index(2, decoder_2, path_2, value_3)));\r\n            return (path_13) => ((value_14) => andThen(uncurry(3, (v3) => {\r\n                let decoder_12;\r\n                const decoder_3 = decoder4;\r\n                decoder_12 = ((path_3) => ((value_4) => index(3, decoder_3, path_3, value_4)));\r\n                return (path_12) => ((value_13) => andThen(uncurry(3, (v4) => {\r\n                    let decoder_11;\r\n                    const decoder_4 = decoder5;\r\n                    decoder_11 = ((path_4) => ((value_5) => index(4, decoder_4, path_4, value_5)));\r\n                    return (path_11) => ((value_12) => andThen(uncurry(3, (v5) => {\r\n                        let decoder_10;\r\n                        const decoder_5 = decoder6;\r\n                        decoder_10 = ((path_5) => ((value_6) => index(5, decoder_5, path_5, value_6)));\r\n                        return (path_10) => ((value_11) => andThen(uncurry(3, (v6) => {\r\n                            let decoder_9;\r\n                            const decoder_6 = decoder7;\r\n                            decoder_9 = ((path_6) => ((value_7) => index(6, decoder_6, path_6, value_7)));\r\n                            return (path_9) => ((value_10) => andThen(uncurry(3, (v7) => {\r\n                                let decoder_8;\r\n                                const decoder_7 = decoder8;\r\n                                decoder_8 = ((path_7) => ((value_8) => index(7, decoder_7, path_7, value_8)));\r\n                                return (path_8) => ((value_9) => andThen((v8, arg10$0040, arg20$0040) => succeed([v1, v2, v3, v4, v5, v6, v7, v8], arg10$0040, arg20$0040), uncurry(2, decoder_8), path_8, value_9));\r\n                            }), uncurry(2, decoder_9), path_9, value_10));\r\n                        }), uncurry(2, decoder_10), path_10, value_11));\r\n                    }), uncurry(2, decoder_11), path_11, value_12));\r\n                }), uncurry(2, decoder_12), path_12, value_13));\r\n            }), uncurry(2, decoder_13), path_13, value_14));\r\n        }), uncurry(2, decoder_14), path_14, value_15));\r\n    }), uncurry(2, decoder_15), path_15, value_16));\r\n}\r\n\r\nfunction toMap(xs) {\r\n    return ofSeq_1(xs);\r\n}\r\n\r\nfunction toSet(xs) {\r\n    return ofSeq_2(xs, {\r\n        Compare: (x, y) => compare(x, y),\r\n    });\r\n}\r\n\r\nfunction autoObject(decoderInfos, path, value_1) {\r\n    if (!(value_1 === null ? false : (Object.getPrototypeOf(value_1 || false) === Object.prototype))) {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"an object\", value_1)]);\r\n    }\r\n    else {\r\n        return foldBack(uncurry(2, (tupledArg) => {\r\n            const name = tupledArg[0];\r\n            return (acc) => ((acc.tag === 0) ? Result_Map((v) => cons(v, acc.fields[0]), tupledArg[1]((path + \".\") + name)(value_1[name])) : acc);\r\n        }), decoderInfos, new FSharpResult$2(0, empty()));\r\n    }\r\n}\r\n\r\nfunction autoObject2(keyDecoder, valueDecoder, path, value_1) {\r\n    if (!(value_1 === null ? false : (Object.getPrototypeOf(value_1 || false) === Object.prototype))) {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(0, \"an object\", value_1)]);\r\n    }\r\n    else {\r\n        return fold_2((acc, name) => {\r\n            if (acc.tag === 0) {\r\n                const matchValue = keyDecoder(path, name);\r\n                if (matchValue.tag === 0) {\r\n                    const _arg1 = valueDecoder((path + \".\") + name, value_1[name]);\r\n                    if (_arg1.tag === 0) {\r\n                        return new FSharpResult$2(0, cons([matchValue.fields[0], _arg1.fields[0]], acc.fields[0]));\r\n                    }\r\n                    else {\r\n                        return new FSharpResult$2(1, _arg1.fields[0]);\r\n                    }\r\n                }\r\n                else {\r\n                    return new FSharpResult$2(1, matchValue.fields[0]);\r\n                }\r\n            }\r\n            else {\r\n                return acc;\r\n            }\r\n        }, new FSharpResult$2(0, empty()), Object.keys(value_1));\r\n    }\r\n}\r\n\r\nfunction mixedArray(msg, decoders, path, values) {\r\n    let arg30, arg10;\r\n    if (decoders.length !== values.length) {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(6, (arg30 = (values.length | 0), (arg10 = (decoders.length | 0), toText(printf(\"Expected %i %s but got %i\"))(arg10)(msg)(arg30))))]);\r\n    }\r\n    else {\r\n        return foldBack2(uncurry(3, mapCurriedArgs((value_1) => ((decoder) => ((acc) => ((acc.tag === 0) ? Result_Map((v) => cons(v, acc.fields[0]), decoder(path, value_1)) : acc))), [0, [0, 2], 0])), values, decoders, new FSharpResult$2(0, empty()));\r\n    }\r\n}\r\n\r\nfunction makeUnion(extra, caseStrategy, t, name, path, values) {\r\n    const uci = tryFind((x) => (name_3(x) === name), getUnionCases(t, true));\r\n    if (uci != null) {\r\n        const uci_1 = uci;\r\n        if (values.length === 0) {\r\n            return new FSharpResult$2(0, makeUnion_1(uci_1, [], true));\r\n        }\r\n        else {\r\n            return Result_Map((values_1) => makeUnion_1(uci_1, Array.from(values_1), true), mixedArray(\"union fields\", map_2((fi) => autoDecoder(extra, caseStrategy, false, fi[1]), getUnionCaseFields(uci_1)), path, values));\r\n        }\r\n    }\r\n    else {\r\n        return new FSharpResult$2(1, [path, new ErrorReason(6, ((\"Cannot find case \" + name) + \" in \") + fullName(t))]);\r\n    }\r\n}\r\n\r\nfunction autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t) {\r\n    const decoderRef = new FSharpRef(null);\r\n    const extra_1 = add(fullName(t), decoderRef, extra);\r\n    let decoder;\r\n    if (isRecord(t, true)) {\r\n        const decoders = map_2((fi) => [Util_Casing_convert(caseStrategy, name_3(fi)), autoDecoder(extra_1, caseStrategy, false, fi[1])], getRecordElements(t, true));\r\n        decoder = ((path) => ((value_1) => Result_Map((xs) => makeRecord(t, Array.from(xs), true), autoObject(decoders, path, value_1))));\r\n    }\r\n    else if (isUnion(t, true)) {\r\n        decoder = ((path_1) => ((value_2) => {\r\n            if ((typeof value_2) === \"string\") {\r\n                return makeUnion(extra_1, caseStrategy, t, value_2, path_1, []);\r\n            }\r\n            else if (Array.isArray(value_2)) {\r\n                const values = value_2;\r\n                return makeUnion(extra_1, caseStrategy, t, values[0], path_1, values.slice(1, values.length));\r\n            }\r\n            else {\r\n                return new FSharpResult$2(1, [path_1, new ErrorReason(0, \"a string or array\", value_2)]);\r\n            }\r\n        }));\r\n    }\r\n    else if (isOptional) {\r\n        decoder = ((path_2) => ((value_3) => (new FSharpResult$2(1, [path_2, new ErrorReason(2, \"an extra coder for \" + fullName(t), value_3)]))));\r\n    }\r\n    else {\r\n        let message;\r\n        const arg10 = fullName(t);\r\n        message = toText(printf(\"Cannot generate auto decoder for %s. Please pass an extra decoder.\"))(arg10);\r\n        throw (new Error(message));\r\n    }\r\n    decoderRef.contents = decoder;\r\n    return decoder;\r\n}\r\n\r\nfunction autoDecoder(extra, caseStrategy, isOptional, t) {\r\n    let decoder_15;\r\n    const fullname = fullName(t);\r\n    const matchValue = tryFind_1(fullname, extra);\r\n    if (matchValue == null) {\r\n        if (isArray(t)) {\r\n            const decoder = autoDecoder(extra, caseStrategy, false, getElementType(t));\r\n            return (path_1) => ((value_2) => array(uncurry(2, decoder), path_1, value_2));\r\n        }\r\n        else if (isEnum(t)) {\r\n            const enumType = fullName(getEnumUnderlyingType(t));\r\n            if (enumType === \"System.SByte\") {\r\n                return (path_2) => ((value_4) => {\r\n                    const t_2 = t;\r\n                    const path_3 = path_2;\r\n                    const value_5 = value_4;\r\n                    const matchValue_1 = sbyte(path_3)(value_5);\r\n                    if (matchValue_1.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_1.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue = matchValue_1.fields[0] | 0;\r\n                        return contains(enumValue, getEnumValues(t_2)) ? (new FSharpResult$2(0, parseEnum(t_2, enumValue.toString()))) : (new FSharpResult$2(1, [path_3, new ErrorReason(1, fullName(t_2), value_5, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else if (enumType === \"System.Byte\") {\r\n                return (path_4) => ((value_7) => {\r\n                    const t_3 = t;\r\n                    const path_5 = path_4;\r\n                    const value_8 = value_7;\r\n                    const matchValue_2 = byte(path_5)(value_8);\r\n                    if (matchValue_2.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_2.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue_1 = matchValue_2.fields[0];\r\n                        return contains(enumValue_1, getEnumValues(t_3)) ? (new FSharpResult$2(0, parseEnum(t_3, enumValue_1.toString()))) : (new FSharpResult$2(1, [path_5, new ErrorReason(1, fullName(t_3), value_8, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else if (enumType === \"System.Int16\") {\r\n                return (path_6) => ((value_10) => {\r\n                    const t_4 = t;\r\n                    const path_7 = path_6;\r\n                    const value_11 = value_10;\r\n                    const matchValue_3 = int16(path_7)(value_11);\r\n                    if (matchValue_3.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_3.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue_2 = matchValue_3.fields[0] | 0;\r\n                        return contains(enumValue_2, getEnumValues(t_4)) ? (new FSharpResult$2(0, parseEnum(t_4, int16ToString(enumValue_2)))) : (new FSharpResult$2(1, [path_7, new ErrorReason(1, fullName(t_4), value_11, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else if (enumType === \"System.UInt16\") {\r\n                return (path_8) => ((value_13) => {\r\n                    const t_5 = t;\r\n                    const path_9 = path_8;\r\n                    const value_14 = value_13;\r\n                    const matchValue_4 = uint16(path_9)(value_14);\r\n                    if (matchValue_4.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_4.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue_3 = matchValue_4.fields[0];\r\n                        return contains(enumValue_3, getEnumValues(t_5)) ? (new FSharpResult$2(0, parseEnum(t_5, enumValue_3.toString()))) : (new FSharpResult$2(1, [path_9, new ErrorReason(1, fullName(t_5), value_14, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else if (enumType === \"System.Int32\") {\r\n                return (path_10) => ((value_16) => {\r\n                    const t_6 = t;\r\n                    const path_11 = path_10;\r\n                    const value_17 = value_16;\r\n                    const matchValue_5 = int(path_11)(value_17);\r\n                    if (matchValue_5.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_5.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue_4 = matchValue_5.fields[0] | 0;\r\n                        return contains(enumValue_4, getEnumValues(t_6)) ? (new FSharpResult$2(0, parseEnum(t_6, int32ToString(enumValue_4)))) : (new FSharpResult$2(1, [path_11, new ErrorReason(1, fullName(t_6), value_17, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else if (enumType === \"System.UInt32\") {\r\n                return (path_12) => ((value_19) => {\r\n                    const t_7 = t;\r\n                    const path_13 = path_12;\r\n                    const value_20 = value_19;\r\n                    const matchValue_6 = uint32(path_13)(value_20);\r\n                    if (matchValue_6.tag === 1) {\r\n                        return new FSharpResult$2(1, matchValue_6.fields[0]);\r\n                    }\r\n                    else {\r\n                        const enumValue_5 = matchValue_6.fields[0];\r\n                        return contains(enumValue_5, getEnumValues(t_7)) ? (new FSharpResult$2(0, parseEnum(t_7, enumValue_5.toString()))) : (new FSharpResult$2(1, [path_13, new ErrorReason(1, fullName(t_7), value_20, \"Unkown value provided for the enum\")]));\r\n                    }\r\n                });\r\n            }\r\n            else {\r\n                const arg10 = fullName(t);\r\n                const clo2 = toFail(printf(\"Cannot generate auto decoder for %s.\\nThoth.Json.Net only support the folluwing enum types:\\n- sbyte\\n- byte\\n- int16\\n- uint16\\n- int\\n- uint32\\nIf you can\\u0027t use one of these types, please pass an extra decoder.\\n                    \"))(arg10);\r\n                return (arg20) => {\r\n                    const clo3 = clo2(arg20);\r\n                    return (arg30) => clo3(arg30);\r\n                };\r\n            }\r\n        }\r\n        else if (isGenericType(t)) {\r\n            if (isTuple(t)) {\r\n                const decoders = map_2((t_8) => autoDecoder(extra, caseStrategy, false, t_8), getTupleElements(t));\r\n                return (path_14) => ((value_21) => (Array.isArray(value_21) ? Result_Map((xs) => makeTuple(Array.from(xs), t), mixedArray(\"tuple elements\", decoders, path_14, value_21)) : (new FSharpResult$2(1, [path_14, new ErrorReason(0, \"an array\", value_21)]))));\r\n            }\r\n            else {\r\n                const fullname_1 = fullName(getGenericTypeDefinition(t));\r\n                if (fullname_1 === \"Microsoft.FSharp.Core.FSharpOption`1[System.Object]\") {\r\n                    const decoder_13 = autoDecoder(extra, caseStrategy, true, getGenerics(t)[0]);\r\n                    return (path_15) => ((value_22) => option(uncurry(2, decoder_13), path_15, value_22));\r\n                }\r\n                else if (fullname_1 === \"Microsoft.FSharp.Collections.FSharpList`1[System.Object]\") {\r\n                    const decoder_14 = autoDecoder(extra, caseStrategy, false, getGenerics(t)[0]);\r\n                    return (path_16) => ((value_23) => list(uncurry(2, decoder_14), path_16, value_23));\r\n                }\r\n                else if (fullname_1 === \"Microsoft.FSharp.Collections.FSharpMap`2[System.Object,System.Object]\") {\r\n                    const keyDecoder = autoDecoder(extra, caseStrategy, false, getGenerics(t)[0]);\r\n                    const valueDecoder = autoDecoder(extra, caseStrategy, false, getGenerics(t)[1]);\r\n                    let d1;\r\n                    const decoders_1 = ofArray([(path_17) => ((value_24) => autoObject2(uncurry(2, keyDecoder), uncurry(2, valueDecoder), path_17, value_24)), (decoder_15 = tuple2(uncurry(2, keyDecoder), uncurry(2, valueDecoder)), (path_18) => ((value_25) => list(uncurry(2, decoder_15), path_18, value_25)))]);\r\n                    d1 = ((path_19) => ((value_26) => oneOf(decoders_1, path_19, value_26)));\r\n                    return (path_20) => ((value_28) => map((ar) => toMap(ar), uncurry(2, d1), path_20, value_28));\r\n                }\r\n                else if (fullname_1 === \"Microsoft.FSharp.Collections.FSharpSet`1[System.Object]\") {\r\n                    const decoder_16 = autoDecoder(extra, caseStrategy, false, getGenerics(t)[0]);\r\n                    return (path_21) => ((value_29) => {\r\n                        const matchValue_7 = array(uncurry(2, decoder_16), path_21, value_29);\r\n                        return (matchValue_7.tag === 0) ? (new FSharpResult$2(0, toSet(matchValue_7.fields[0]))) : (new FSharpResult$2(1, matchValue_7.fields[0]));\r\n                    });\r\n                }\r\n                else {\r\n                    return autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t);\r\n                }\r\n            }\r\n        }\r\n        else if (fullname === \"System.Boolean\") {\r\n            return (path_22) => ((value_31) => bool(path_22, value_31));\r\n        }\r\n        else if (fullname === \"Microsoft.FSharp.Core.Unit\") {\r\n            return (path_23) => ((value_32) => unit(path_23, value_32));\r\n        }\r\n        else if (fullname === \"System.String\") {\r\n            return (path_24) => ((value_33) => string(path_24, value_33));\r\n        }\r\n        else if (fullname === \"System.SByte\") {\r\n            return sbyte;\r\n        }\r\n        else if (fullname === \"System.Byte\") {\r\n            return byte;\r\n        }\r\n        else if (fullname === \"System.Int16\") {\r\n            return int16;\r\n        }\r\n        else if (fullname === \"System.UInt16\") {\r\n            return uint16;\r\n        }\r\n        else if (fullname === \"System.Int32\") {\r\n            return int;\r\n        }\r\n        else if (fullname === \"System.UInt32\") {\r\n            return uint32;\r\n        }\r\n        else if (fullname === \"System.Double\") {\r\n            return (path_25) => ((value_34) => float(path_25, value_34));\r\n        }\r\n        else if (fullname === \"System.Single\") {\r\n            return (path_26) => ((value_35) => float32(path_26, value_35));\r\n        }\r\n        else if (fullname === \"System.DateTime\") {\r\n            return (path_27) => ((value_36) => datetime(path_27, value_36));\r\n        }\r\n        else if (fullname === \"System.DateTimeOffset\") {\r\n            return (path_28) => ((value_37) => datetimeOffset(path_28, value_37));\r\n        }\r\n        else if (fullname === \"System.TimeSpan\") {\r\n            return (path_29) => ((value_38) => timespan(path_29, value_38));\r\n        }\r\n        else if (fullname === \"System.Guid\") {\r\n            return (path_30) => ((value_39) => guid(path_30, value_39));\r\n        }\r\n        else if (fullname === \"System.Object\") {\r\n            return (_arg1_6) => ((v) => (new FSharpResult$2(0, v)));\r\n        }\r\n        else {\r\n            return autoDecodeRecordsAndUnions(extra, caseStrategy, isOptional, t);\r\n        }\r\n    }\r\n    else {\r\n        const decoderRef = matchValue;\r\n        return (path) => ((value_1) => decoderRef.contents(path)(value_1));\r\n    }\r\n}\r\n\r\nfunction makeExtra(extra) {\r\n    if (extra != null) {\r\n        return map_3((_arg2, tupledArg) => (new FSharpRef(tupledArg[1])), extra.Coders);\r\n    }\r\n    else {\r\n        return empty_1();\r\n    }\r\n}\r\n\r\nexport class Auto {\r\n    constructor() {\r\n    }\r\n}\r\n\r\nexport function Auto$reflection() {\r\n    return class_type(\"Thoth.Json.Decode.Auto\", void 0, Auto);\r\n}\r\n\r\nexport function Auto_generateDecoderCached_7848D058(caseStrategy, extra, resolver) {\r\n    let y_1, y;\r\n    const t = value_40(resolver).ResolveType();\r\n    const caseStrategy_1 = defaultArg(caseStrategy, new CaseStrategy(0));\r\n    return Util_Cache$1__GetOrAdd_43981464(Util_CachedDecoders, (y_1 = (y = fullName(t), toString_12(caseStrategy_1) + y), defaultArg(map_4((e) => e.Hash, extra), \"\") + y_1), () => autoDecoder(makeExtra(extra), caseStrategy_1, false, t));\r\n}\r\n\r\nexport function Auto_generateDecoder_7848D058(caseStrategy, extra, resolver) {\r\n    const caseStrategy_1 = defaultArg(caseStrategy, new CaseStrategy(0));\r\n    const t = value_40(resolver).ResolveType();\r\n    return autoDecoder(makeExtra(extra), caseStrategy_1, false, t);\r\n}\r\n\r\nexport function Auto_fromString_Z5CB6BD(json, caseStrategy, extra, resolver) {\r\n    return fromString(uncurry(2, Auto_generateDecoder_7848D058(caseStrategy, extra, resolver)), json);\r\n}\r\n\r\nexport function Auto_unsafeFromString_Z5CB6BD(json, caseStrategy, extra, resolver) {\r\n    const matchValue = fromString(uncurry(2, Auto_generateDecoder_7848D058(caseStrategy, extra, resolver)), json);\r\n    if (matchValue.tag === 1) {\r\n        throw (new Error(matchValue.fields[0]));\r\n    }\r\n    else {\r\n        return matchValue.fields[0];\r\n    }\r\n}\r\n\r\n","import { Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { fullName, union_type, string_type, class_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { keyValueList } from \"../fable-library.3.1.4/MapUtil.js\";\r\nimport { Types_RequestProperties, Types_HttpRequestHeaders } from \"../Fable.Fetch.2.4.0/Fetch.fs.js\";\r\nimport { ofArray, empty, append, cons } from \"../fable-library.3.1.4/List.js\";\r\nimport { Auto_generateEncoderCached_Z127D9D79, toString } from \"../Thoth.Json.4.1.0/Encode.fs.js\";\r\nimport { value as value_2, map, defaultArg } from \"../fable-library.3.1.4/Option.js\";\r\nimport { FSharpResult$2 } from \"../fable-library.3.1.4/Choice.js\";\r\nimport { int32ToString, uncurry, curry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { fromString, Auto_generateDecoderCached_7848D058 } from \"../Thoth.Json.4.1.0/Decode.fs.js\";\r\nimport { PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B } from \"../Fable.Promise.3.1.3/Promise.fs.js\";\r\nimport { promise } from \"../Fable.Promise.3.1.3/PromiseImpl.fs.js\";\r\n\r\nexport class FetchError extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"PreparingRequestFailed\", \"DecodingFailed\", \"FetchFailed\", \"NetworkError\"];\r\n    }\r\n}\r\n\r\nexport function FetchError$reflection() {\r\n    return union_type(\"Thoth.Fetch.FetchError\", [], FetchError, () => [[[\"Item\", class_type(\"System.Exception\")]], [[\"Item\", string_type]], [[\"Item\", class_type(\"Fetch.Types.Response\")]], [[\"Item\", class_type(\"System.Exception\")]]]);\r\n}\r\n\r\nexport function Helper_fetch(url, init) {\r\n    return fetch(url, keyValueList(init, 1));\r\n}\r\n\r\nexport function Helper_withContentTypeJson(data, headers) {\r\n    if (data != null) {\r\n        return cons(new Types_HttpRequestHeaders(11, \"application/json\"), headers);\r\n    }\r\n    else {\r\n        return headers;\r\n    }\r\n}\r\n\r\nexport function Helper_encode(data, caseStrategy, extra, dataResolver) {\r\n    return toString(0, Auto_generateEncoderCached_Z127D9D79(caseStrategy, extra, void 0, dataResolver)(data));\r\n}\r\n\r\nexport function Helper_withBody(data, caseStrategy, extra, dataResolver, properties) {\r\n    return defaultArg(map((data_1) => cons(new Types_RequestProperties(2, Helper_encode(data_1, caseStrategy, extra, dataResolver)), properties), data), properties);\r\n}\r\n\r\nexport function Helper_withProperties(custom, properties) {\r\n    return defaultArg(map((list2) => append(properties, list2), custom), properties);\r\n}\r\n\r\nexport function Helper_eitherUnit(responseResolver, cont) {\r\n    if (fullName(responseResolver.ResolveType()) === \"Microsoft.FSharp.Core.Unit\") {\r\n        return new FSharpResult$2(0, void 0);\r\n    }\r\n    else {\r\n        return cont();\r\n    }\r\n}\r\n\r\nexport function Helper_resolve(response, caseStrategy, extra, decoder, responseResolver) {\r\n    const decoder_1 = defaultArg(curry(2, decoder), Auto_generateDecoderCached_7848D058(caseStrategy, extra, responseResolver));\r\n    let eitherUnitOr;\r\n    const responseResolver_1 = value_2(responseResolver);\r\n    eitherUnitOr = ((cont) => Helper_eitherUnit(responseResolver_1, cont));\r\n    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (((response.ok) ? PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (response.text().then(((_arg1) => (Promise.resolve(eitherUnitOr(() => {\r\n        const matchValue = fromString(uncurry(2, decoder_1), _arg1);\r\n        return (matchValue.tag === 1) ? (new FSharpResult$2(1, new FetchError(1, matchValue.fields[0]))) : (new FSharpResult$2(0, matchValue.fields[0]));\r\n    })))))))) : (Promise.resolve((new FSharpResult$2(1, new FetchError(2, response)))))).then(((_arg2) => (Promise.resolve(_arg2)))))));\r\n}\r\n\r\nexport function Helper_message(error) {\r\n    switch (error.tag) {\r\n        case 1: {\r\n            return \"[Thoth.Fetch] Error while decoding the response:\\n\\n\" + error.fields[0];\r\n        }\r\n        case 2: {\r\n            const response = error.fields[0];\r\n            return ((((\"[Thoth.Fetch] Request failed:\\n\\n\" + int32ToString(response.status)) + \" \") + (response.statusText)) + \" for URL \") + (response.url);\r\n        }\r\n        case 3: {\r\n            return \"[Thoth.Fetch] A network error occured:\\n\\n\" + error.fields[0].message;\r\n        }\r\n        default: {\r\n            return \"[Thoth.Fetch] Request preparation failed:\\n\\n\" + error.fields[0].message;\r\n        }\r\n    }\r\n}\r\n\r\nexport class Fetch {\r\n    constructor() {\r\n    }\r\n}\r\n\r\nexport function Fetch$reflection() {\r\n    return class_type(\"Thoth.Fetch.Fetch\", void 0, Fetch);\r\n}\r\n\r\nexport function Fetch_tryFetchAs_25B10BBE(url, decoder, data, httpMethod, properties, headers, caseStrategy, extra, responseResolver, dataResolver) {\r\n    let headers_2;\r\n    try {\r\n        const properties_3 = Helper_withProperties(properties, Helper_withBody(data, caseStrategy, extra, dataResolver, ofArray([new Types_RequestProperties(0, defaultArg(httpMethod, \"GET\")), (headers_2 = Helper_withContentTypeJson(data, defaultArg(headers, empty())), new Types_RequestProperties(1, keyValueList(headers_2, 0)))])));\r\n        const pr = PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (Helper_fetch(url, properties_3).then(((_arg1) => (Helper_resolve(_arg1, caseStrategy, extra, decoder, responseResolver)))))));\r\n        return pr.catch(((arg) => (new FSharpResult$2(1, new FetchError(3, arg)))));\r\n    }\r\n    catch (exn) {\r\n        return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (Promise.resolve((new FSharpResult$2(1, new FetchError(0, exn)))))));\r\n    }\r\n}\r\n\r\nexport function Fetch_fetchAs_25B10BBE(url, decoder, data, httpMethod, properties, headers, caseStrategy, extra, responseResolver, dataResolver) {\r\n    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (Fetch_tryFetchAs_25B10BBE(url, decoder, data, httpMethod, properties, headers, caseStrategy, extra, responseResolver, dataResolver).then(((_arg2) => {\r\n        const result = _arg2;\r\n        let response_1;\r\n        if (result.tag === 1) {\r\n            throw (new Error(Helper_message(result.fields[0])));\r\n        }\r\n        else {\r\n            response_1 = result.fields[0];\r\n        }\r\n        return Promise.resolve(response_1);\r\n    })))));\r\n}\r\n\r\nexport function Fetch_get_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_fetchAs_25B10BBE(url, decoder, data, void 0, properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryGet_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_tryFetchAs_25B10BBE(url, decoder, data, void 0, properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_post_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_fetchAs_25B10BBE(url, decoder, data, \"POST\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPost_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_tryFetchAs_25B10BBE(url, decoder, data, \"POST\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_put_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_fetchAs_25B10BBE(url, decoder, data, \"PUT\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPut_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_tryFetchAs_25B10BBE(url, decoder, data, \"PUT\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_patch_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_fetchAs_25B10BBE(url, decoder, data, \"PATCH\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPatch_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_tryFetchAs_25B10BBE(url, decoder, data, \"PATCH\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_delete_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_fetchAs_25B10BBE(url, decoder, data, \"DELETE\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryDelete_5760677E(url, data, properties, headers, caseStrategy, extra, decoder, responseResolver, dataResolver) {\r\n    return Fetch_tryFetchAs_25B10BBE(url, decoder, data, \"DELETE\", properties, headers, caseStrategy, extra, responseResolver, dataResolver);\r\n}\r\n\r\n","import { empty, singleton, append, ofArray } from \"../fable-library.3.1.4/List.js\";\r\nimport { Types_RequestProperties } from \"../Fable.Fetch.2.4.0/Fetch.fs.js\";\r\nimport { some, defaultArg } from \"../fable-library.3.1.4/Option.js\";\r\nimport { obj_type, class_type } from \"../fable-library.3.1.4/Reflection.js\";\r\nimport { Fetch_tryDelete_5760677E, Fetch_delete_5760677E, Fetch_tryPatch_5760677E, Fetch_patch_5760677E, Fetch_tryPut_5760677E, Fetch_put_5760677E, Fetch_tryPost_5760677E, Fetch_post_5760677E, Fetch_tryFetchAs_25B10BBE, Fetch_fetchAs_25B10BBE } from \"../Thoth.Fetch.2.0.0/Fetch.fs.js\";\r\nimport { uncurry } from \"../fable-library.3.1.4/Util.js\";\r\n\r\nexport function ServicesFramework_moduleHeaders(sf) {\r\n    return ofArray([[\"ModuleId\", sf.getModuleId()], [\"TabId\", sf.getTabId()], [\"RequestVerificationToken\", sf.getAntiForgeryValue()]]);\r\n}\r\n\r\nexport function ServicesFramework_setup$0027(isGet, moduleId, moduleName, url, props) {\r\n    const sf = window['$'].ServicesFramework(moduleId);\r\n    const serviceroot = sf.getServiceRoot(moduleName);\r\n    const props_1 = append(singleton(new Types_RequestProperties(4, \"same-origin\")), defaultArg(props, empty()));\r\n    const Url = serviceroot + url;\r\n    return {\r\n        Headers: ServicesFramework_moduleHeaders(sf),\r\n        Props: props_1,\r\n        Url: Url,\r\n    };\r\n}\r\n\r\nexport const ServicesFramework_setup = (moduleId) => ((moduleName) => ((url) => ((props) => ServicesFramework_setup$0027(false, moduleId, moduleName, url, props))));\r\n\r\nexport class Fetch {\r\n    constructor() {\r\n    }\r\n}\r\n\r\nexport function Fetch$reflection() {\r\n    return class_type(\"Dnn.Fable.Fetch\", void 0, Fetch);\r\n}\r\n\r\nexport function Fetch_fetchAs_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver) {\r\n    const sf = ServicesFramework_setup$0027(true, moduleId, moduleName, url, properties);\r\n    return Fetch_fetchAs_25B10BBE(sf.Url, uncurry(2, void 0), void 0, void 0, sf.Props, sf.Headers, caseStrategy, extra, responseResolver, {\r\n        ResolveType: () => obj_type,\r\n    });\r\n}\r\n\r\nexport function Fetch_tryFetchAs_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver) {\r\n    const sf = ServicesFramework_setup$0027(true, moduleId, moduleName, url, properties);\r\n    return Fetch_tryFetchAs_25B10BBE(sf.Url, uncurry(2, void 0), void 0, void 0, sf.Props, sf.Headers, caseStrategy, extra, responseResolver, {\r\n        ResolveType: () => obj_type,\r\n    });\r\n}\r\n\r\nexport function Fetch_get_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver) {\r\n    return Fetch_fetchAs_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver);\r\n}\r\n\r\nexport function Fetch_tryGet_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver) {\r\n    return Fetch_tryFetchAs_511FB67E(moduleId, moduleName, url, properties, caseStrategy, extra, responseResolver);\r\n}\r\n\r\nexport function Fetch_post_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_post_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPost_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_tryPost_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_put_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_put_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPut_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_tryPut_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_patch_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_patch_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryPatch_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_tryPatch_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_delete_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_delete_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\nexport function Fetch_tryDelete_3817AB3A(moduleId, moduleName, url, data, properties, caseStrategy, extra, responseResolver, dataResolver) {\r\n    const sf = ServicesFramework_setup(moduleId)(moduleName)(url)(properties);\r\n    return Fetch_tryDelete_5760677E(sf.Url, some(data), sf.Props, sf.Headers, caseStrategy, extra, uncurry(2, void 0), responseResolver, dataResolver);\r\n}\r\n\r\n","import { Union } from \"../.fable/fable-library.3.1.4/Types.js\";\r\nimport { Query$reflection, Command$reflection, Result$reflection } from \"../../Shared/Api.fs.js\";\r\nimport { unit_type, union_type, class_type } from \"../.fable/fable-library.3.1.4/Reflection.js\";\r\nimport { fableModule } from \"../Global.fs.js\";\r\nimport { Fetch_post_3817AB3A } from \"../.fable/Dnn.Fable.Fetch.2.0.0/fetch.fs.js\";\r\nimport { PromiseBuilder__Delay_62FBFDE1, PromiseBuilder__Run_212F1D4B } from \"../.fable/Fable.Promise.3.1.3/Promise.fs.js\";\r\nimport { promise } from \"../.fable/Fable.Promise.3.1.3/PromiseImpl.fs.js\";\r\nimport { Cmd_OfPromise_either } from \"../.fable/Fable.Elmish.3.1.0/cmd.fs.js\";\r\n\r\nexport class Msg extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Fetched\", \"FetchFailed\", \"Handled\"];\r\n    }\r\n}\r\n\r\nexport function Msg$reflection() {\r\n    return union_type(\"TagungsProgramm.Api.Msg\", [], Msg, () => [[[\"Item\", Result$reflection()]], [[\"Item\", class_type(\"System.Exception\")]], [[\"Item\", Command$reflection()]]]);\r\n}\r\n\r\nexport const moduleId = (() => {\r\n    const container = document.getElementById(fableModule.Platzhalter);\r\n    return container.dataset[\"moduleid\"];\r\n})();\r\n\r\nexport const moduleName = fableModule.ModuleName;\r\n\r\nfunction query$0027(query_1) {\r\n    return Fetch_post_3817AB3A(moduleId, moduleName, \"service/query\", query_1, void 0, void 0, void 0, {\r\n        ResolveType: Result$reflection,\r\n    }, {\r\n        ResolveType: Query$reflection,\r\n    });\r\n}\r\n\r\nfunction handle$0027(command) {\r\n    return PromiseBuilder__Run_212F1D4B(promise, PromiseBuilder__Delay_62FBFDE1(promise, () => (Fetch_post_3817AB3A(moduleId, moduleName, \"service/handle\", command, void 0, void 0, void 0, {\r\n        ResolveType: () => unit_type,\r\n    }, {\r\n        ResolveType: Command$reflection,\r\n    }).then((() => (Promise.resolve(command)))))));\r\n}\r\n\r\nexport function query(q) {\r\n    return Cmd_OfPromise_either((query_1) => query$0027(query_1), q, (arg0) => (new Msg(0, arg0)), (arg0_1) => (new Msg(1, arg0_1)));\r\n}\r\n\r\nexport function handle(c) {\r\n    return Cmd_OfPromise_either((command) => handle$0027(command), c, (arg0) => (new Msg(2, arg0)), (arg0_1) => (new Msg(1, arg0_1)));\r\n}\r\n\r\n","import { Record, Union } from \"../.fable/fable-library.3.1.4/Types.js\";\r\nimport { Termin$reflection, Rahmenprogramm$0027$reflection, Programm$0027$reflection, Session$0027$reflection, Raum$0027$reflection, Manuskript$reflection, Beitrag$0027$reflection, Tag$0027$reflection } from \"../Domain.fs.js\";\r\nimport { record_type, tuple_type, class_type, option_type, list_type, bool_type, union_type, string_type } from \"../.fable/fable-library.3.1.4/Reflection.js\";\r\nimport { exists } from \"../.fable/fable-library.3.1.4/List.js\";\r\nimport { Msg$reflection as Msg$reflection_1 } from \"./Api.fs.js\";\r\n\r\nexport class Tab extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Tag\", \"Posters\", \"TabSession\", \"Rahmenprogramm\", \"EigenesProgramm\"];\r\n    }\r\n}\r\n\r\nexport function Tab$reflection() {\r\n    return union_type(\"TagungsProgramm.Types.Tab\", [], Tab, () => [[[\"Item\", Tag$0027$reflection()]], [], [[\"Item\", string_type]], [], []]);\r\n}\r\n\r\nexport class Route extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Home\", \"Beitrag\", \"Rahmenprogramm\", \"RahmenprogrammPunkt\", \"Session\", \"Programm\"];\r\n    }\r\n}\r\n\r\nexport function Route$reflection() {\r\n    return union_type(\"TagungsProgramm.Types.Route\", [], Route, () => [[], [[\"Item\", string_type]], [], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]]]);\r\n}\r\n\r\nexport class Subscription extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Subscribed\", \"Unsubscribed\", \"PartialySubscribed\"];\r\n    }\r\n}\r\n\r\nexport function Subscription$reflection() {\r\n    return union_type(\"TagungsProgramm.Types.Subscription\", [], Subscription, () => [[], [], []]);\r\n}\r\n\r\nexport class Model extends Record {\r\n    constructor(IstAngemeldet, AnmeldungAnfordern, EigenesProgramm, ProfileUrl, Tage, Ausgew$00E4hlt, Sprache, ZeitenInOrtszeit, Route, Beitr$00E4ge, Manuskripte, Session, Programm, Beitrag, Poster, TabSessions, Rahmenprogramm, Termine, Thema, RahmenprogrammPunkt) {\r\n        super();\r\n        this.IstAngemeldet = IstAngemeldet;\r\n        this.AnmeldungAnfordern = AnmeldungAnfordern;\r\n        this.EigenesProgramm = EigenesProgramm;\r\n        this.ProfileUrl = ProfileUrl;\r\n        this.Tage = Tage;\r\n        this[\"Ausgewählt\"] = Ausgew$00E4hlt;\r\n        this.Sprache = Sprache;\r\n        this.ZeitenInOrtszeit = ZeitenInOrtszeit;\r\n        this.Route = Route;\r\n        this[\"Beiträge\"] = Beitr$00E4ge;\r\n        this.Manuskripte = Manuskripte;\r\n        this.Session = Session;\r\n        this.Programm = Programm;\r\n        this.Beitrag = Beitrag;\r\n        this.Poster = Poster;\r\n        this.TabSessions = TabSessions;\r\n        this.Rahmenprogramm = Rahmenprogramm;\r\n        this.Termine = Termine;\r\n        this.Thema = Thema;\r\n        this.RahmenprogrammPunkt = RahmenprogrammPunkt;\r\n    }\r\n}\r\n\r\nexport function Model$reflection() {\r\n    return record_type(\"TagungsProgramm.Types.Model\", [], Model, () => [[\"IstAngemeldet\", bool_type], [\"AnmeldungAnfordern\", bool_type], [\"EigenesProgramm\", bool_type], [\"ProfileUrl\", string_type], [\"Tage\", list_type(Tag$0027$reflection())], [\"Ausgewählt\", option_type(Tab$reflection())], [\"Sprache\", string_type], [\"ZeitenInOrtszeit\", bool_type], [\"Route\", option_type(Route$reflection())], [\"Beiträge\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [class_type(\"System.Guid\"), list_type(Beitrag$0027$reflection())])], [\"Manuskripte\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, Manuskript$reflection()])], [\"Session\", option_type(tuple_type(Raum$0027$reflection(), Session$0027$reflection()))], [\"Programm\", option_type(tuple_type(Raum$0027$reflection(), Programm$0027$reflection()))], [\"Beitrag\", option_type(Beitrag$0027$reflection())], [\"Poster\", list_type(tuple_type(string_type, list_type(Beitrag$0027$reflection())))], [\"TabSessions\", class_type(\"Microsoft.FSharp.Collections.FSharpMap`2\", [string_type, list_type(tuple_type(string_type, list_type(Beitrag$0027$reflection())))])], [\"Rahmenprogramm\", list_type(Rahmenprogramm$0027$reflection())], [\"Termine\", list_type(Termin$reflection())], [\"Thema\", option_type(tuple_type(string_type, list_type(Beitrag$0027$reflection())))], [\"RahmenprogrammPunkt\", option_type(Rahmenprogramm$0027$reflection())]]);\r\n}\r\n\r\nexport function Model__IstSubscribed_2297AD2E(__, nummer) {\r\n    let nummer_3, nummer_1;\r\n    const matchValue = [nummer, __.Termine];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] != null) {\r\n        if (nummer_1 = matchValue[0], exists((t_1) => (t_1.Id === nummer_1), matchValue[1])) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return new Subscription(0);\r\n        }\r\n        case 1: {\r\n            let pattern_matching_result_1;\r\n            if (matchValue[0] != null) {\r\n                if (nummer_3 = matchValue[0], exists((t_4) => (t_4.SessionId === nummer_3), matchValue[1])) {\r\n                    pattern_matching_result_1 = 0;\r\n                }\r\n                else {\r\n                    pattern_matching_result_1 = 1;\r\n                }\r\n            }\r\n            else {\r\n                pattern_matching_result_1 = 1;\r\n            }\r\n            switch (pattern_matching_result_1) {\r\n                case 0: {\r\n                    return new Subscription(2);\r\n                }\r\n                case 1: {\r\n                    return new Subscription(1);\r\n                }\r\n            }\r\n        }\r\n    }\r\n}\r\n\r\nexport class Msg extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"ApiMsg\", \"AnmeldungAnfordernSchliessen\", \"Wechseln\", \"ThemaZeigen\", \"ThemaSchliessen\", \"SessionZeigen\", \"SessionSchliessen\", \"ToggleSubscribtion\", \"ProgrammZeigen\", \"ProgrammSchliessen\", \"BeitragZeigen\", \"BeitragSchliessen\", \"RahmenprogrammZeigen\", \"RahmenprogrammSchliessen\", \"BeiträgeNachladen\"];\r\n    }\r\n}\r\n\r\nexport function Msg$reflection() {\r\n    return union_type(\"TagungsProgramm.Types.Msg\", [], Msg, () => [[[\"Item\", Msg$reflection_1()]], [], [[\"Item\", Tab$reflection()]], [[\"Item\", tuple_type(string_type, list_type(Beitrag$0027$reflection()))]], [], [[\"Item1\", Raum$0027$reflection()], [\"Item2\", Session$0027$reflection()]], [], [], [[\"Item1\", Raum$0027$reflection()], [\"Item2\", Programm$0027$reflection()]], [], [[\"Item\", Beitrag$0027$reflection()]], [], [[\"Item\", Rahmenprogramm$0027$reflection()]], [], [[\"Item\", Session$0027$reflection()]]]);\r\n}\r\n\r\n","import { map, defaultArg } from \"../.fable/fable-library.3.1.4/Option.js\";\r\nimport { Auto_unsafeFromString_Z5CB6BD } from \"../.fable/Thoth.Json.4.1.0/Decode.fs.js\";\r\nimport { Termin$reflection } from \"../Domain.fs.js\";\r\nimport { list_type } from \"../.fable/fable-library.3.1.4/Reflection.js\";\r\nimport { empty } from \"../.fable/fable-library.3.1.4/List.js\";\r\nimport { Auto_toString_5A41365E } from \"../.fable/Thoth.Json.4.1.0/Encode.fs.js\";\r\n\r\nconst storage = localStorage;\r\n\r\nexport function Termine_get() {\r\n    let _arg1;\r\n    return defaultArg(map((json) => Auto_unsafeFromString_Z5CB6BD(json, void 0, void 0, {\r\n        ResolveType: () => list_type(Termin$reflection()),\r\n    }), (_arg1 = storage.getItem(\"Schedule\"), (_arg1 === null) ? (void 0) : _arg1)), empty());\r\n}\r\n\r\nexport function Termine_set(v) {\r\n    storage.setItem(\"Schedule\", Auto_toString_5A41365E(0, v, void 0, void 0, void 0, {\r\n        ResolveType: () => list_type(Termin$reflection()),\r\n    }));\r\n}\r\n\r\n","import { oneOf, str, s as s_2, top, map } from \"../.fable/Fable.Elmish.Browser.3.0.4/parser.fs.js\";\r\nimport { Subscription, Model__IstSubscribed_2297AD2E, Model, Tab, Msg, Route as Route_4 } from \"./Types.fs.js\";\r\nimport { cons, filter, exists, empty, sumBy, tryHead, choose, map as map_2, distinct, append, tryFind, ofArray, collect } from \"../.fable/fable-library.3.1.4/List.js\";\r\nimport { isNullOrEmpty, toText, printf, toConsole, isNullOrWhiteSpace, replace } from \"../.fable/fable-library.3.1.4/String.js\";\r\nimport { defaultArg, map as map_1 } from \"../.fable/fable-library.3.1.4/Option.js\";\r\nimport { Cmd_map, Cmd_none, Cmd_batch, Cmd_OfFunc_result } from \"../.fable/Fable.Elmish.3.1.0/cmd.fs.js\";\r\nimport { add, containsKey, FSharpMap__TryFind, empty as empty_1, tryFind as tryFind_1, tryFindKey, FSharpMap__get_Item, ofSeq, toList } from \"../.fable/fable-library.3.1.4/Map.js\";\r\nimport { equals, compare, comparePrimitives, arrayHash, equalArrays } from \"../.fable/fable-library.3.1.4/Util.js\";\r\nimport { toString, parse, addMinutes as addMinutes_1 } from \"../.fable/fable-library.3.1.4/Date.js\";\r\nimport { Termin } from \"../Domain.fs.js\";\r\nimport { fableModule } from \"../Global.fs.js\";\r\nimport { Termine_set, Termine_get } from \"./Repository.fs.js\";\r\nimport { handle, query } from \"./Api.fs.js\";\r\nimport { Command, Query } from \"../../Shared/Api.fs.js\";\r\nimport { Navigation_modifyUrl } from \"../.fable/Fable.Elmish.Browser.3.0.4/navigation.fs.js\";\r\n\r\nexport const route = (() => {\r\n    let parseBefore, parseBefore_2, parseBefore_4;\r\n    const parsers = ofArray([map(new Route_4(0), (state) => top(state)), map(new Route_4(2), s_2(\"r\")), map((arg0) => (new Route_4(3, arg0)), (parseBefore = s_2(\"r\"), (state_2) => collect((state_1) => str(state_1), parseBefore(state_2)))), map((arg0_1) => (new Route_4(5, arg0_1)), (parseBefore_2 = s_2(\"p\"), (state_5) => collect((state_4) => str(state_4), parseBefore_2(state_5)))), map((arg0_2) => (new Route_4(4, arg0_2)), (parseBefore_4 = s_2(\"s\"), (state_8) => collect((state_7) => str(state_7), parseBefore_4(state_8)))), map((arg0_3) => (new Route_4(1, arg0_3)), (state_10) => str(state_10))]);\r\n    return (state_11) => oneOf(parsers, state_11);\r\n})();\r\n\r\nexport function beitragCmd(model, pnr) {\r\n    let list2;\r\n    const pnr_1 = replace(pnr, \"%20\", \" \").toUpperCase();\r\n    return map_1((arg) => Cmd_OfFunc_result(new Msg(10, arg)), tryFind((b_2) => (b_2.Vortragsnummer.toUpperCase() === pnr_1), (list2 = collect((tupledArg) => tupledArg[1], toList(model[\"Beiträge\"])), append(collect((tupledArg_1) => tupledArg_1[1], model.Poster), list2))));\r\n}\r\n\r\nexport function sessionCmd(model, kuerzel) {\r\n    const kuerzel_1 = replace(kuerzel, \"%20\", \" \");\r\n    const r$00E4ume = ofSeq(distinct(collect((x) => x, map_2((t) => map_2((r) => [r.Id, r], t[\"Räume\"]), model.Tage)), {\r\n        Equals: (x_1, y) => equalArrays(x_1, y),\r\n        GetHashCode: (x_1) => arrayHash(x_1),\r\n    }), {\r\n        Compare: (x_2, y_1) => comparePrimitives(x_2, y_1),\r\n    });\r\n    const sessions = ofSeq(choose((tupledArg) => {\r\n        const _arg1 = tupledArg[1];\r\n        if (_arg1.tag === 1) {\r\n            const s = _arg1.fields[0];\r\n            return [s, [FSharpMap__get_Item(r$00E4ume, tupledArg[0]), s]];\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, collect((x_4) => x_4, collect((x_3) => x_3, map_2((t_1) => map_2((a) => toList(a.Programmpunkte), t_1.Achsen), model.Tage)))), {\r\n        Compare: (x_5, y_2) => compare(x_5, y_2),\r\n    });\r\n    return map_1((session) => {\r\n        let tupledArg_1;\r\n        return Cmd_OfFunc_result((tupledArg_1 = FSharpMap__get_Item(sessions, session), new Msg(5, tupledArg_1[0], tupledArg_1[1])));\r\n    }, tryFindKey((s_1, _arg1_1) => {\r\n        if (defaultArg(map_1((k) => {\r\n            if (!isNullOrWhiteSpace(k)) {\r\n                return kuerzel_1.indexOf(k) >= 0;\r\n            }\r\n            else {\r\n                return false;\r\n            }\r\n        }, s_1[\"Kürzel\"]), false)) {\r\n            return true;\r\n        }\r\n        else if (!isNullOrWhiteSpace(s_1[\"Vortragskürzel\"])) {\r\n            return kuerzel_1.indexOf(s_1[\"Vortragskürzel\"]) >= 0;\r\n        }\r\n        else {\r\n            return false;\r\n        }\r\n    }, sessions));\r\n}\r\n\r\nexport function rahmenCmd(model, bezeichnung) {\r\n    const bezeichnung_1 = decodeURIComponent(bezeichnung);\r\n    return map_1((bez) => Cmd_batch(ofArray([Cmd_OfFunc_result(new Msg(2, new Tab(3))), Cmd_OfFunc_result(new Msg(12, bez))])), tryFind((p) => (p.Bezeichnung === bezeichnung_1), model.Rahmenprogramm));\r\n}\r\n\r\nexport function urlUpdate(route_1, model) {\r\n    toConsole(printf(\"urlUpdate %A\"))(route_1);\r\n    let pattern_matching_result, pnr, kuerzel, p;\r\n    if (route_1 != null) {\r\n        if (route_1.tag === 0) {\r\n            pattern_matching_result = 0;\r\n        }\r\n        else if (route_1.tag === 1) {\r\n            pattern_matching_result = 1;\r\n            pnr = route_1.fields[0];\r\n        }\r\n        else if (route_1.tag === 4) {\r\n            pattern_matching_result = 2;\r\n            kuerzel = route_1.fields[0];\r\n        }\r\n        else if (route_1.tag === 2) {\r\n            pattern_matching_result = 3;\r\n        }\r\n        else if (route_1.tag === 3) {\r\n            pattern_matching_result = 4;\r\n            p = route_1.fields[0];\r\n        }\r\n        else {\r\n            pattern_matching_result = 5;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 0;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, void 0, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n        }\r\n        case 1: {\r\n            const matchValue = beitragCmd(model, pnr);\r\n            if (matchValue == null) {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, route_1, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, void 0, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), matchValue];\r\n            }\r\n        }\r\n        case 2: {\r\n            const matchValue_1 = sessionCmd(model, kuerzel);\r\n            if (matchValue_1 == null) {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, route_1, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, void 0, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), matchValue_1];\r\n            }\r\n        }\r\n        case 3: {\r\n            return [model, Cmd_OfFunc_result(new Msg(2, new Tab(3)))];\r\n        }\r\n        case 4: {\r\n            const matchValue_2 = rahmenCmd(model, p);\r\n            if (matchValue_2 == null) {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, route_1, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, void 0, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), matchValue_2];\r\n            }\r\n        }\r\n        case 5: {\r\n            return [model, Cmd_none()];\r\n        }\r\n    }\r\n}\r\n\r\nexport function minusIfEmpty(s) {\r\n    if (isNullOrWhiteSpace(s)) {\r\n        return \"-\";\r\n    }\r\n    else {\r\n        return s;\r\n    }\r\n}\r\n\r\nexport function tohash(model) {\r\n    let matchValue, beitrag, session, clo1_1, program, clo1_2, r;\r\n    return \"#\" + (matchValue = [model.Session, model.Programm, model.Beitrag, model[\"Ausgewählt\"], model.RahmenprogrammPunkt], (matchValue[2] != null) ? (beitrag = matchValue[2], toText(printf(\"%s\"))(beitrag.Vortragsnummer)) : ((matchValue[0] != null) ? (session = matchValue[0][1], defaultArg(map_1((clo1_1 = toText(printf(\"s/%s\")), (arg10_1) => clo1_1(arg10_1)), session[\"Kürzel\"]), \"\")) : ((matchValue[1] != null) ? (program = matchValue[1][1], defaultArg(map_1((clo1_2 = toText(printf(\"p/%s\")), (arg10_2) => clo1_2(arg10_2)), program[\"Kürzel\"]), \"\")) : ((matchValue[4] != null) ? (r = matchValue[4], toText(printf(\"r/%s\"))(r.Bezeichnung)) : ((matchValue[3] != null) ? ((matchValue[3].tag === 3) ? \"r\" : \"\") : \"\")))));\r\n}\r\n\r\nexport function alsTermin(model) {\r\n    let beitrag, raum, session, raum_1, session_1, copyOfStruct;\r\n    let _arg1;\r\n    const matchValue = [model.Session, model.Programm, model.Beitrag, model[\"Ausgewählt\"], model.RahmenprogrammPunkt];\r\n    if (matchValue[0] != null) {\r\n        _arg1 = ((matchValue[2] != null) ? (beitrag = matchValue[2], (raum = matchValue[0][0], (session = matchValue[0][1], [beitrag.Vortragsnummer, beitrag.Titel, tryHead(beitrag.Zeiten), beitrag.Dauer, raum.Raum, session[\"Kürzel\"]]))) : (raum_1 = matchValue[0][0], (session_1 = matchValue[0][1], [session_1[\"Kürzel\"], session_1.Bezeichnung, tryHead(session_1.Startzeiten), defaultArg(map_1((list_2) => sumBy((b) => b.Dauer, list_2, {\r\n            GetZero: () => 0,\r\n            Add: (x, y) => (x + y),\r\n        }), tryFind_1(session_1.Id, model[\"Beiträge\"])), 60), defaultArg(session_1.AndererRaum, raum_1.Raum), void 0])));\r\n    }\r\n    else {\r\n        throw (new Error(\"Noch nicht implementiert\"));\r\n    }\r\n    let pattern_matching_result, dauer, id, raum_2, sessionId, titel, zeit;\r\n    if (_arg1[0] != null) {\r\n        if (_arg1[2] != null) {\r\n            pattern_matching_result = 0;\r\n            dauer = _arg1[3];\r\n            id = _arg1[0];\r\n            raum_2 = _arg1[4];\r\n            sessionId = _arg1[5];\r\n            titel = _arg1[1];\r\n            zeit = _arg1[2];\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            return new Termin(id, minusIfEmpty(defaultArg(sessionId, \"-\")), id, zeit, (copyOfStruct = addMinutes_1(parse(zeit), dauer), toString(copyOfStruct, \"yyyy-MM-ddTHH:mm:ss\")), titel, raum_2, window.location.href, false);\r\n        }\r\n        case 1: {\r\n            return void 0;\r\n        }\r\n    }\r\n}\r\n\r\nexport const userId = (() => {\r\n    const container = document.getElementById(fableModule.Platzhalter);\r\n    return container.dataset[\"user\"];\r\n})();\r\n\r\nexport function init(result) {\r\n    const patternInput = urlUpdate(result, new Model(!isNullOrEmpty(userId), false, false, \"\", empty(), void 0, \"\", false, void 0, empty_1(), empty_1(), void 0, void 0, void 0, empty(), empty_1(), empty(), Termine_get(), void 0, void 0));\r\n    return [patternInput[0], Cmd_batch(ofArray([patternInput[1], Cmd_map((arg0) => (new Msg(0, arg0)), query(new Query(0))), Cmd_map((arg0_1) => (new Msg(0, arg0_1)), query(new Query(1))), Cmd_map((arg0_2) => (new Msg(0, arg0_2)), query(new Query(2))), Cmd_map((arg0_3) => (new Msg(0, arg0_3)), query(new Query(4))), Cmd_map((arg0_4) => (new Msg(0, arg0_4)), query(new Query(5))), Cmd_map((arg0_5) => (new Msg(0, arg0_5)), query(new Query(6)))]))];\r\n}\r\n\r\nexport function tagMitprogramm(tag) {\r\n    return exists((achse) => exists((raum) => {\r\n        const p = FSharpMap__TryFind(achse.Programmpunkte, raum.Id);\r\n        let pattern_matching_result;\r\n        if (p != null) {\r\n            if (p.tag === 0) {\r\n                pattern_matching_result = 0;\r\n            }\r\n            else {\r\n                pattern_matching_result = 0;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n        switch (pattern_matching_result) {\r\n            case 0: {\r\n                return true;\r\n            }\r\n            case 1: {\r\n                return false;\r\n            }\r\n        }\r\n    }, tag[\"Räume\"]), tag.Achsen);\r\n}\r\n\r\nexport const tageMitprogramm = (list) => filter((tag) => tagMitprogramm(tag), list);\r\n\r\nexport function subscribe(id, termine) {\r\n    return cons(id, termine);\r\n}\r\n\r\nexport function unsubscribe(id, termine) {\r\n    return filter((t) => (t.Id !== id), termine);\r\n}\r\n\r\nexport function update(msg, model) {\r\n    let _arg3;\r\n    switch (msg.tag) {\r\n        case 6: {\r\n            const model_2 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, void 0, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_2, Navigation_modifyUrl(tohash(model_2))];\r\n        }\r\n        case 7: {\r\n            if (model.IstAngemeldet) {\r\n                const _arg1 = alsTermin(model);\r\n                if (_arg1 != null) {\r\n                    const t = _arg1;\r\n                    return [model, Cmd_map((arg0) => (new Msg(0, arg0)), handle(equals(Model__IstSubscribed_2297AD2E(model, t.Id), new Subscription(0)) ? (new Command(1, t)) : (new Command(0, t))))];\r\n                }\r\n                else {\r\n                    return [model, Cmd_none()];\r\n                }\r\n            }\r\n            else {\r\n                return [new Model(model.IstAngemeldet, true, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n        }\r\n        case 1: {\r\n            return [new Model(model.IstAngemeldet, false, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n        }\r\n        case 14: {\r\n            const session = msg.fields[0];\r\n            if (containsKey(session.Id, model[\"Beiträge\"])) {\r\n                return [model, Cmd_none()];\r\n            }\r\n            else {\r\n                return [model, Cmd_map((arg0_1) => (new Msg(0, arg0_1)), query(new Query(3, session.Id, session[\"Vortragskürzel\"])))];\r\n            }\r\n        }\r\n        case 0: {\r\n            const msg_2 = msg.fields[0];\r\n            if (msg_2.tag === 1) {\r\n                throw (new Error(msg_2.fields[0].message));\r\n            }\r\n            else if (msg_2.tag === 2) {\r\n                return [model, Cmd_map((arg0_2) => (new Msg(0, arg0_2)), query(new Query(6)))];\r\n            }\r\n            else if (msg_2.fields[0].tag === 2) {\r\n                const model_5 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, add(msg_2.fields[0].fields[0], msg_2.fields[0].fields[1], model[\"Beiträge\"]), model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n                const _arg5 = model_5.Route;\r\n                let pattern_matching_result, pnr_1;\r\n                if (_arg5 != null) {\r\n                    if (_arg5.tag === 1) {\r\n                        pattern_matching_result = 0;\r\n                        pnr_1 = _arg5.fields[0];\r\n                    }\r\n                    else {\r\n                        pattern_matching_result = 1;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result = 1;\r\n                }\r\n                switch (pattern_matching_result) {\r\n                    case 0: {\r\n                        return defaultArg(map_1((cmd_2) => [new Model(model_5.IstAngemeldet, model_5.AnmeldungAnfordern, model_5.EigenesProgramm, model_5.ProfileUrl, model_5.Tage, model_5[\"Ausgewählt\"], model_5.Sprache, model_5.ZeitenInOrtszeit, void 0, model_5[\"Beiträge\"], model_5.Manuskripte, model_5.Session, model_5.Programm, model_5.Beitrag, model_5.Poster, model_5.TabSessions, model_5.Rahmenprogramm, model_5.Termine, model_5.Thema, model_5.RahmenprogrammPunkt), cmd_2], beitragCmd(model_5, pnr_1)), [model_5, Cmd_none()]);\r\n                    }\r\n                    case 1: {\r\n                        return [model_5, Cmd_none()];\r\n                    }\r\n                }\r\n            }\r\n            else if (msg_2.fields[0].tag === 3) {\r\n                const model_6 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, msg_2.fields[0].fields[0], model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n                const _arg6 = model_6.Route;\r\n                let pattern_matching_result_1, pnr_2;\r\n                if (_arg6 != null) {\r\n                    if (_arg6.tag === 1) {\r\n                        pattern_matching_result_1 = 0;\r\n                        pnr_2 = _arg6.fields[0];\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_1 = 1;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result_1 = 1;\r\n                }\r\n                switch (pattern_matching_result_1) {\r\n                    case 0: {\r\n                        return defaultArg(map_1((cmd_3) => [new Model(model_6.IstAngemeldet, model_6.AnmeldungAnfordern, model_6.EigenesProgramm, model_6.ProfileUrl, model_6.Tage, model_6[\"Ausgewählt\"], model_6.Sprache, model_6.ZeitenInOrtszeit, void 0, model_6[\"Beiträge\"], model_6.Manuskripte, model_6.Session, model_6.Programm, model_6.Beitrag, model_6.Poster, model_6.TabSessions, model_6.Rahmenprogramm, model_6.Termine, model_6.Thema, model_6.RahmenprogrammPunkt), cmd_3], beitragCmd(model_6, pnr_2)), [model_6, Cmd_none()]);\r\n                    }\r\n                    case 1: {\r\n                        return [model_6, Cmd_none()];\r\n                    }\r\n                }\r\n            }\r\n            else if (msg_2.fields[0].tag === 4) {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, msg_2.fields[0].fields[0], model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else if (msg_2.fields[0].tag === 1) {\r\n                const model_8 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, msg_2.fields[0].fields[0], model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n                const _arg7 = model_8.Route;\r\n                let pattern_matching_result_2, p;\r\n                if (_arg7 != null) {\r\n                    if (_arg7.tag === 3) {\r\n                        pattern_matching_result_2 = 0;\r\n                        p = _arg7.fields[0];\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_2 = 1;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result_2 = 1;\r\n                }\r\n                switch (pattern_matching_result_2) {\r\n                    case 0: {\r\n                        return defaultArg(map_1((cmd_4) => [new Model(model_8.IstAngemeldet, model_8.AnmeldungAnfordern, model_8.EigenesProgramm, model_8.ProfileUrl, model_8.Tage, model_8[\"Ausgewählt\"], model_8.Sprache, model_8.ZeitenInOrtszeit, void 0, model_8[\"Beiträge\"], model_8.Manuskripte, model_8.Session, model_8.Programm, model_8.Beitrag, model_8.Poster, model_8.TabSessions, model_8.Rahmenprogramm, model_8.Termine, model_8.Thema, model_8.RahmenprogrammPunkt), cmd_4], rahmenCmd(model_8, p)), [model_8, Cmd_none()]);\r\n                    }\r\n                    case 1: {\r\n                        return [model_8, Cmd_none()];\r\n                    }\r\n                }\r\n            }\r\n            else if (msg_2.fields[0].tag === 5) {\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], ofSeq(map_2((m) => [m.Pnr, m], msg_2.fields[0].fields[0]), {\r\n                    Compare: (x, y) => comparePrimitives(x, y),\r\n                }), model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else if (msg_2.fields[0].tag === 6) {\r\n                if (msg_2.fields[0].fields[1]) {\r\n                    Termine_set(msg_2.fields[0].fields[0]);\r\n                }\r\n                return [new Model(model.IstAngemeldet, model.AnmeldungAnfordern, msg_2.fields[0].fields[3], msg_2.fields[0].fields[2].fields[0], model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, msg_2.fields[0].fields[1] ? msg_2.fields[0].fields[0] : model.Termine, model.Thema, model.RahmenprogrammPunkt), Cmd_none()];\r\n            }\r\n            else {\r\n                const tage_1 = tageMitprogramm(msg_2.fields[0].fields[0]);\r\n                const model_4 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, tage_1, (model[\"Ausgewählt\"] != null) ? model[\"Ausgewählt\"] : (_arg3 = tage_1, (_arg3.tail != null) ? (new Tab(0, _arg3.head)) : (void 0)), msg_2.fields[0].fields[1], msg_2.fields[0].fields[2].fields[0], model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n                const _arg4 = model_4.Route;\r\n                let pattern_matching_result_3, pnr, kuerzel;\r\n                if (_arg4 != null) {\r\n                    if (_arg4.tag === 1) {\r\n                        pattern_matching_result_3 = 0;\r\n                        pnr = _arg4.fields[0];\r\n                    }\r\n                    else if (_arg4.tag === 4) {\r\n                        pattern_matching_result_3 = 1;\r\n                        kuerzel = _arg4.fields[0];\r\n                    }\r\n                    else {\r\n                        pattern_matching_result_3 = 2;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result_3 = 2;\r\n                }\r\n                switch (pattern_matching_result_3) {\r\n                    case 0: {\r\n                        return [model_4, defaultArg(sessionCmd(model_4, pnr), Cmd_none())];\r\n                    }\r\n                    case 1: {\r\n                        return defaultArg(map_1((cmd_1) => [new Model(model_4.IstAngemeldet, model_4.AnmeldungAnfordern, model_4.EigenesProgramm, model_4.ProfileUrl, model_4.Tage, model_4[\"Ausgewählt\"], model_4.Sprache, model_4.ZeitenInOrtszeit, void 0, model_4[\"Beiträge\"], model_4.Manuskripte, model_4.Session, model_4.Programm, model_4.Beitrag, model_4.Poster, model_4.TabSessions, model_4.Rahmenprogramm, model_4.Termine, model_4.Thema, model_4.RahmenprogrammPunkt), cmd_1], sessionCmd(model_4, kuerzel)), [model_4, Cmd_none()]);\r\n                    }\r\n                    case 2: {\r\n                        return [model_4, Cmd_none()];\r\n                    }\r\n                }\r\n            }\r\n        }\r\n        case 8: {\r\n            const model_9 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, [msg.fields[0], msg.fields[1]], model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_9, Navigation_modifyUrl(tohash(model_9))];\r\n        }\r\n        case 9: {\r\n            const model_10 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, void 0, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_10, Navigation_modifyUrl(tohash(model_10))];\r\n        }\r\n        case 10: {\r\n            const model_11 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, msg.fields[0], model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_11, Navigation_modifyUrl(tohash(model_11))];\r\n        }\r\n        case 11: {\r\n            const model_12 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, void 0, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_12, Navigation_modifyUrl(tohash(model_12))];\r\n        }\r\n        case 2: {\r\n            const model_13 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, msg.fields[0], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_13, Navigation_modifyUrl(tohash(model_13))];\r\n        }\r\n        case 3: {\r\n            const model_14 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, msg.fields[0], model.RahmenprogrammPunkt);\r\n            return [model_14, Navigation_modifyUrl(tohash(model_14))];\r\n        }\r\n        case 4: {\r\n            const model_15 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, void 0, model.RahmenprogrammPunkt);\r\n            return [model_15, Navigation_modifyUrl(tohash(model_15))];\r\n        }\r\n        case 12: {\r\n            const model_16 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, msg.fields[0]);\r\n            return [model_16, Navigation_modifyUrl(tohash(model_16))];\r\n        }\r\n        case 13: {\r\n            const model_17 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, model.Session, model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, void 0);\r\n            return [model_17, Navigation_modifyUrl(tohash(model_17))];\r\n        }\r\n        default: {\r\n            const s = msg.fields[1];\r\n            const model_1 = new Model(model.IstAngemeldet, model.AnmeldungAnfordern, model.EigenesProgramm, model.ProfileUrl, model.Tage, model[\"Ausgewählt\"], model.Sprache, model.ZeitenInOrtszeit, model.Route, model[\"Beiträge\"], model.Manuskripte, [msg.fields[0], s], model.Programm, model.Beitrag, model.Poster, model.TabSessions, model.Rahmenprogramm, model.Termine, model.Thema, model.RahmenprogrammPunkt);\r\n            return [model_1, Cmd_batch(ofArray([Navigation_modifyUrl(tohash(model_1)), Cmd_OfFunc_result(new Msg(14, s))]))];\r\n        }\r\n    }\r\n}\r\n\r\n","import { toString, Record, Union } from \"../fable-library.3.1.4/Types.js\";\r\nimport { array_type, float64_type, int32_type, bool_type, obj_type, record_type, option_type, lambda_type, unit_type, class_type, union_type, string_type } from \"../fable-library.3.1.4/Reflection.js\";\r\n\r\nexport class FragmentProp extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Key\"];\r\n    }\r\n}\r\n\r\nexport function FragmentProp$reflection() {\r\n    return union_type(\"Fable.React.Props.FragmentProp\", [], FragmentProp, () => [[[\"Item\", string_type]]]);\r\n}\r\n\r\nexport class Prop extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"Key\", \"Ref\", \"ref\", \"ref\"];\r\n    }\r\n}\r\n\r\nexport function Prop$reflection() {\r\n    return union_type(\"Fable.React.Props.Prop\", [], Prop, () => [[[\"Item\", string_type]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Element\"), unit_type)]], [[\"Item\", class_type(\"Fable.React.IRefValue`1\", [option_type(class_type(\"Browser.Types.Element\"))])]], [[\"Item\", class_type(\"Fable.React.IRefValue`1\", [option_type(class_type(\"Browser.Types.Element\"))])]]]);\r\n}\r\n\r\nexport class DangerousHtml extends Record {\r\n    constructor(__html) {\r\n        super();\r\n        this.__html = __html;\r\n    }\r\n}\r\n\r\nexport function DangerousHtml$reflection() {\r\n    return record_type(\"Fable.React.Props.DangerousHtml\", [], DangerousHtml, () => [[\"__html\", string_type]]);\r\n}\r\n\r\nexport class DOMAttr extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"DangerouslySetInnerHTML\", \"OnCut\", \"OnPaste\", \"OnCompositionEnd\", \"OnCompositionStart\", \"OnCopy\", \"OnCompositionUpdate\", \"OnFocus\", \"OnBlur\", \"OnChange\", \"OnInput\", \"OnSubmit\", \"OnReset\", \"OnLoad\", \"OnError\", \"OnKeyDown\", \"OnKeyPress\", \"OnKeyUp\", \"OnAbort\", \"OnCanPlay\", \"OnCanPlayThrough\", \"OnDurationChange\", \"OnEmptied\", \"OnEncrypted\", \"OnEnded\", \"OnLoadedData\", \"OnLoadedMetadata\", \"OnLoadStart\", \"OnPause\", \"OnPlay\", \"OnPlaying\", \"OnProgress\", \"OnRateChange\", \"OnSeeked\", \"OnSeeking\", \"OnStalled\", \"OnSuspend\", \"OnTimeUpdate\", \"OnVolumeChange\", \"OnWaiting\", \"OnClick\", \"OnContextMenu\", \"OnDoubleClick\", \"OnDrag\", \"OnDragEnd\", \"OnDragEnter\", \"OnDragExit\", \"OnDragLeave\", \"OnDragOver\", \"OnDragStart\", \"OnDrop\", \"OnMouseDown\", \"OnMouseEnter\", \"OnMouseLeave\", \"OnMouseMove\", \"OnMouseOut\", \"OnMouseOver\", \"OnMouseUp\", \"OnSelect\", \"OnTouchCancel\", \"OnTouchEnd\", \"OnTouchMove\", \"OnTouchStart\", \"OnScroll\", \"OnWheel\", \"OnAnimationStart\", \"OnAnimationEnd\", \"OnAnimationIteration\", \"OnTransitionEnd\", \"Custom\"];\r\n    }\r\n}\r\n\r\nexport function DOMAttr$reflection() {\r\n    return union_type(\"Fable.React.Props.DOMAttr\", [], DOMAttr, () => [[[\"Item\", DangerousHtml$reflection()]], [[\"Item\", lambda_type(class_type(\"Browser.Types.ClipboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.ClipboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.CompositionEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.CompositionEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.ClipboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.CompositionEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.FocusEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.FocusEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.KeyboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.KeyboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.KeyboardEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.DragEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.MouseEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.Event\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.TouchEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.TouchEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.TouchEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.TouchEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.UIEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.WheelEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.AnimationEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.AnimationEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.AnimationEvent\"), unit_type)]], [[\"Item\", lambda_type(class_type(\"Browser.Types.TransitionEvent\"), unit_type)]], [[\"Item1\", string_type], [\"Item2\", obj_type]]]);\r\n}\r\n\r\nexport class SVGAttr extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"ClipPath\", \"Cx\", \"Cy\", \"D\", \"Dx\", \"Dy\", \"Fill\", \"FillOpacity\", \"FontFamily\", \"FontSize\", \"Fx\", \"Fy\", \"GradientTransform\", \"GradientUnits\", \"Height\", \"MarkerEnd\", \"MarkerMid\", \"MarkerStart\", \"Offset\", \"Opacity\", \"PatternContentUnits\", \"PatternUnits\", \"Points\", \"PreserveAspectRatio\", \"R\", \"Rx\", \"Ry\", \"SpreadMethod\", \"StopColor\", \"StopOpacity\", \"Stroke\", \"StrokeDasharray\", \"StrokeDashoffset\", \"StrokeLinecap\", \"StrokeMiterlimit\", \"StrokeOpacity\", \"StrokeWidth\", \"TextAnchor\", \"Transform\", \"Version\", \"ViewBox\", \"Width\", \"X1\", \"X2\", \"X\", \"XlinkActuate\", \"XlinkArcrole\", \"XlinkHref\", \"XlinkRole\", \"XlinkShow\", \"XlinkTitle\", \"XlinkType\", \"XmlBase\", \"XmlLang\", \"XmlSpace\", \"Y1\", \"Y2\", \"Y\", \"Custom\"];\r\n    }\r\n}\r\n\r\nexport function SVGAttr$reflection() {\r\n    return union_type(\"Fable.React.Props.SVGAttr\", [], SVGAttr, () => [[[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]]]);\r\n}\r\n\r\nexport class HTMLAttr extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"DefaultChecked\", \"DefaultValue\", \"Accept\", \"AcceptCharset\", \"AccessKey\", \"Action\", \"AllowFullScreen\", \"AllowTransparency\", \"Alt\", \"aria-atomic\", \"aria-busy\", \"aria-checked\", \"aria-colcount\", \"aria-colindex\", \"aria-colspan\", \"aria-controls\", \"aria-current\", \"aria-describedby\", \"aria-details\", \"aria-disabled\", \"aria-errormessage\", \"aria-expanded\", \"aria-flowto\", \"aria-haspopup\", \"aria-hidden\", \"aria-invalid\", \"aria-keyshortcuts\", \"aria-label\", \"aria-labelledby\", \"aria-level\", \"aria-live\", \"aria-modal\", \"aria-multiline\", \"aria-multiselectable\", \"aria-orientation\", \"aria-owns\", \"aria-placeholder\", \"aria-posinset\", \"aria-pressed\", \"aria-readonly\", \"aria-relevant\", \"aria-required\", \"aria-roledescription\", \"aria-rowcount\", \"aria-rowindex\", \"aria-rowspan\", \"aria-selected\", \"aria-setsize\", \"aria-sort\", \"aria-valuemax\", \"aria-valuemin\", \"aria-valuenow\", \"aria-valuetext\", \"Async\", \"AutoComplete\", \"AutoFocus\", \"AutoPlay\", \"Capture\", \"CellPadding\", \"CellSpacing\", \"CharSet\", \"Challenge\", \"Checked\", \"ClassID\", \"ClassName\", \"className\", \"Cols\", \"ColSpan\", \"Content\", \"ContentEditable\", \"ContextMenu\", \"Controls\", \"Coords\", \"CrossOrigin\", \"data-toggle\", \"DateTime\", \"Default\", \"Defer\", \"Dir\", \"Disabled\", \"Download\", \"Draggable\", \"EncType\", \"Form\", \"FormAction\", \"FormEncType\", \"FormMethod\", \"FormNoValidate\", \"FormTarget\", \"FrameBorder\", \"Headers\", \"Height\", \"Hidden\", \"High\", \"Href\", \"HrefLang\", \"HtmlFor\", \"HttpEquiv\", \"Icon\", \"Id\", \"InputMode\", \"Integrity\", \"Is\", \"KeyParams\", \"KeyType\", \"Kind\", \"Label\", \"Lang\", \"List\", \"Loop\", \"Low\", \"Manifest\", \"MarginHeight\", \"MarginWidth\", \"Max\", \"MaxLength\", \"Media\", \"MediaGroup\", \"Method\", \"Min\", \"MinLength\", \"Multiple\", \"Muted\", \"Name\", \"NoValidate\", \"Open\", \"Optimum\", \"Pattern\", \"Placeholder\", \"Poster\", \"Preload\", \"RadioGroup\", \"ReadOnly\", \"Rel\", \"Required\", \"Role\", \"Rows\", \"RowSpan\", \"Sandbox\", \"Scope\", \"Scoped\", \"Scrolling\", \"Seamless\", \"Selected\", \"Shape\", \"Size\", \"Sizes\", \"Span\", \"SpellCheck\", \"Src\", \"SrcDoc\", \"SrcLang\", \"SrcSet\", \"Start\", \"Step\", \"Summary\", \"TabIndex\", \"Target\", \"Title\", \"Type\", \"UseMap\", \"Value\", \"value\", \"Width\", \"Wmode\", \"Wrap\", \"About\", \"Datatype\", \"Inlist\", \"Prefix\", \"Property\", \"Resource\", \"Typeof\", \"Vocab\", \"AutoCapitalize\", \"AutoCorrect\", \"AutoSave\", \"ItemProp\", \"ItemScope\", \"ItemType\", \"ItemID\", \"ItemRef\", \"Results\", \"Security\", \"Unselectable\", \"Custom\"];\r\n    }\r\n}\r\n\r\nexport function HTMLAttr$reflection() {\r\n    return union_type(\"Fable.React.Props.HTMLAttr\", [], HTMLAttr, () => [[[\"Item\", bool_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", bool_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", float64_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", obj_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", bool_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", float64_type]], [[\"Item\", obj_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", float64_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", int32_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", array_type(string_type)]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", float64_type]], [[\"Item\", string_type]], [[\"Item\", bool_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]]]);\r\n}\r\n\r\nexport class CSSProp extends Union {\r\n    constructor(tag, ...fields) {\r\n        super();\r\n        this.tag = (tag | 0);\r\n        this.fields = fields;\r\n    }\r\n    cases() {\r\n        return [\"AlignContent\", \"AlignItems\", \"AlignSelf\", \"AlignmentAdjust\", \"AlignmentBaseline\", \"All\", \"Animation\", \"AnimationDelay\", \"AnimationDirection\", \"AnimationDuration\", \"AnimationFillMode\", \"AnimationIterationCount\", \"AnimationName\", \"AnimationPlayState\", \"AnimationTimingFunction\", \"Appearance\", \"BackfaceVisibility\", \"Background\", \"BackgroundAttachment\", \"BackgroundBlendMode\", \"BackgroundClip\", \"BackgroundColor\", \"BackgroundComposite\", \"BackgroundImage\", \"BackgroundOrigin\", \"BackgroundPosition\", \"BackgroundPositionX\", \"BackgroundPositionY\", \"BackgroundRepeat\", \"BackgroundSize\", \"BaselineShift\", \"Behavior\", \"BlockSize\", \"Border\", \"BorderBlockEnd\", \"BorderBlockEndColor\", \"BorderBlockEndStyle\", \"BorderBlockEndWidth\", \"BorderBlockStart\", \"BorderBlockStartColor\", \"BorderBlockStartStyle\", \"BorderBlockStartWidth\", \"BorderBottom\", \"BorderBottomColor\", \"BorderBottomLeftRadius\", \"BorderBottomRightRadius\", \"BorderBottomStyle\", \"BorderBottomWidth\", \"BorderCollapse\", \"BorderColor\", \"BorderCornerShape\", \"BorderImage\", \"BorderImageOutset\", \"BorderImageRepeat\", \"BorderImageSlice\", \"BorderImageSource\", \"BorderImageWidth\", \"BorderInlineEnd\", \"BorderInlineEndColor\", \"BorderInlineEndStyle\", \"BorderInlineEndWidth\", \"BorderInlineStart\", \"BorderInlineStartColor\", \"BorderInlineStartStyle\", \"BorderInlineStartWidth\", \"BorderLeft\", \"BorderLeftColor\", \"BorderLeftStyle\", \"BorderLeftWidth\", \"BorderRadius\", \"BorderRight\", \"BorderRightColor\", \"BorderRightStyle\", \"BorderRightWidth\", \"BorderSpacing\", \"BorderStyle\", \"BorderTop\", \"BorderTopColor\", \"BorderTopLeftRadius\", \"BorderTopRightRadius\", \"BorderTopStyle\", \"BorderTopWidth\", \"BorderWidth\", \"Bottom\", \"BoxAlign\", \"BoxDecorationBreak\", \"BoxDirection\", \"BoxFlex\", \"BoxFlexGroup\", \"BoxLineProgression\", \"BoxLines\", \"BoxOrdinalGroup\", \"BoxShadow\", \"BoxSizing\", \"BreakAfter\", \"BreakBefore\", \"BreakInside\", \"CaptionSide\", \"CaretColor\", \"Clear\", \"Clip\", \"ClipPath\", \"ClipRule\", \"Color\", \"ColorInterpolation\", \"ColorInterpolationFilters\", \"ColorProfile\", \"ColorRendering\", \"ColumnCount\", \"ColumnFill\", \"ColumnGap\", \"ColumnRule\", \"ColumnRuleColor\", \"ColumnRuleStyle\", \"ColumnRuleWidth\", \"ColumnSpan\", \"ColumnWidth\", \"Columns\", \"Content\", \"CounterIncrement\", \"CounterReset\", \"Cue\", \"CueAfter\", \"Cursor\", \"Direction\", \"Display\", \"DominantBaseline\", \"EmptyCells\", \"EnableBackground\", \"Fill\", \"FillOpacity\", \"FillRule\", \"Filter\", \"Flex\", \"FlexAlign\", \"FlexBasis\", \"FlexDirection\", \"FlexFlow\", \"FlexGrow\", \"FlexItemAlign\", \"FlexLinePack\", \"FlexOrder\", \"FlexShrink\", \"FlexWrap\", \"Float\", \"FloodColor\", \"FloodOpacity\", \"FlowFrom\", \"Font\", \"FontFamily\", \"FontFeatureSettings\", \"FontKerning\", \"FontLanguageOverride\", \"FontSize\", \"FontSizeAdjust\", \"FontStretch\", \"FontStyle\", \"FontSynthesis\", \"FontVariant\", \"FontVariantAlternates\", \"FontVariantCaps\", \"FontVariantEastAsian\", \"FontVariantLigatures\", \"FontVariantNumeric\", \"FontVariantPosition\", \"FontWeight\", \"GlyphOrientationHorizontal\", \"GlyphOrientationVertical\", \"Grid\", \"GridArea\", \"GridAutoColumns\", \"GridAutoFlow\", \"GridAutoRows\", \"GridColumn\", \"GridColumnEnd\", \"GridColumnGap\", \"GridColumnStart\", \"GridGap\", \"GridRow\", \"GridRowEnd\", \"GridRowGap\", \"GridRowPosition\", \"GridRowSpan\", \"GridRowStart\", \"GridTemplate\", \"GridTemplateAreas\", \"GridTemplateColumns\", \"GridTemplateRows\", \"HangingPunctuation\", \"Height\", \"HyphenateLimitChars\", \"HyphenateLimitLines\", \"HyphenateLimitZone\", \"Hyphens\", \"ImageOrientation\", \"ImageRendering\", \"ImageResolution\", \"ImeMode\", \"InlineSize\", \"Isolation\", \"JustifyContent\", \"JustifySelf\", \"Kerning\", \"LayoutGrid\", \"LayoutGridChar\", \"LayoutGridLine\", \"LayoutGridMode\", \"LayoutGridType\", \"Left\", \"LetterSpacing\", \"LightingColor\", \"LineBreak\", \"LineClamp\", \"LineHeight\", \"ListStyle\", \"ListStyleImage\", \"ListStylePosition\", \"ListStyleType\", \"Margin\", \"MarginBlockEnd\", \"MarginBlockStart\", \"MarginBottom\", \"MarginInlineEnd\", \"MarginInlineStart\", \"MarginLeft\", \"MarginRight\", \"MarginTop\", \"MarkerEnd\", \"MarkerMid\", \"MarkerStart\", \"MarqueeDirection\", \"MarqueeStyle\", \"Mask\", \"MaskBorder\", \"MaskBorderRepeat\", \"MaskBorderSlice\", \"MaskBorderSource\", \"MaskBorderWidth\", \"MaskClip\", \"MaskComposite\", \"MaskImage\", \"MaskMode\", \"MaskOrigin\", \"MaskPosition\", \"MaskRepeat\", \"MaskSize\", \"MaskType\", \"MaxFontSize\", \"MaxHeight\", \"MaxWidth\", \"MinBlockSize\", \"MinHeight\", \"MinInlineSize\", \"MinWidth\", \"MixBlendMode\", \"ObjectFit\", \"ObjectPosition\", \"OffsetBlockEnd\", \"OffsetBlockStart\", \"OffsetInlineEnd\", \"OffsetInlineStart\", \"Opacity\", \"Order\", \"Orphans\", \"Outline\", \"OutlineColor\", \"OutlineOffset\", \"OutlineStyle\", \"OutlineWidth\", \"OverflowStyle\", \"OverflowWrap\", \"OverflowX\", \"OverflowY\", \"Padding\", \"PaddingBlockEnd\", \"PaddingBlockStart\", \"PaddingBottom\", \"PaddingInlineEnd\", \"PaddingInlineStart\", \"PaddingLeft\", \"PaddingRight\", \"PaddingTop\", \"PageBreakAfter\", \"PageBreakBefore\", \"PageBreakInside\", \"Pause\", \"PauseAfter\", \"PauseBefore\", \"Perspective\", \"PerspectiveOrigin\", \"PointerEvents\", \"Position\", \"PunctuationTrim\", \"Quotes\", \"RegionFragment\", \"Resize\", \"RestAfter\", \"RestBefore\", \"Right\", \"RubyAlign\", \"RubyMerge\", \"RubyPosition\", \"ScrollBehavior\", \"ScrollSnapCoordinate\", \"ScrollSnapDestination\", \"ScrollSnapType\", \"ShapeImageThreshold\", \"ShapeInside\", \"ShapeMargin\", \"ShapeOutside\", \"ShapeRendering\", \"Speak\", \"SpeakAs\", \"StopColor\", \"StopOpacity\", \"Stroke\", \"StrokeDasharray\", \"StrokeDashoffset\", \"StrokeLinecap\", \"StrokeLinejoin\", \"StrokeMiterlimit\", \"StrokeOpacity\", \"StrokeWidth\", \"TabSize\", \"TableLayout\", \"TextAlign\", \"TextAlignLast\", \"TextAnchor\", \"TextCombineUpright\", \"TextDecoration\", \"TextDecorationColor\", \"TextDecorationLine\", \"TextDecorationLineThrough\", \"TextDecorationNone\", \"TextDecorationOverline\", \"TextDecorationSkip\", \"TextDecorationStyle\", \"TextDecorationUnderline\", \"TextEmphasis\", \"TextEmphasisColor\", \"TextEmphasisPosition\", \"TextEmphasisStyle\", \"TextHeight\", \"TextIndent\", \"TextJustify\", \"TextJustifyTrim\", \"TextKashidaSpace\", \"TextLineThrough\", \"TextLineThroughColor\", \"TextLineThroughMode\", \"TextLineThroughStyle\", \"TextLineThroughWidth\", \"TextOrientation\", \"TextOverflow\", \"TextOverline\", \"TextOverlineColor\", \"TextOverlineMode\", \"TextOverlineStyle\", \"TextOverlineWidth\", \"TextRendering\", \"TextScript\", \"TextShadow\", \"TextTransform\", \"TextUnderlinePosition\", \"TextUnderlineStyle\", \"Top\", \"TouchAction\", \"Transform\", \"TransformBox\", \"TransformOrigin\", \"TransformOriginZ\", \"TransformStyle\", \"Transition\", \"TransitionDelay\", \"TransitionDuration\", \"TransitionProperty\", \"TransitionTimingFunction\", \"UnicodeBidi\", \"UnicodeRange\", \"UserFocus\", \"UserInput\", \"UserSelect\", \"VerticalAlign\", \"Visibility\", \"VoiceBalance\", \"VoiceDuration\", \"VoiceFamily\", \"VoicePitch\", \"VoiceRange\", \"VoiceRate\", \"VoiceStress\", \"VoiceVolume\", \"WhiteSpace\", \"WhiteSpaceTreatment\", \"Widows\", \"Width\", \"WillChange\", \"WordBreak\", \"WordSpacing\", \"WordWrap\", \"WrapFlow\", \"WrapMargin\", \"WrapOption\", \"WritingMode\", \"ZIndex\", \"Zoom\", \"Custom\"];\r\n    }\r\n}\r\n\r\nexport function CSSProp$reflection() {\r\n    return union_type(\"Fable.React.Props.CSSProp\", [], CSSProp, () => [[[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", string_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item\", obj_type]], [[\"Item1\", string_type], [\"Item2\", obj_type]]]);\r\n}\r\n\r\nexport function stringEnum(case$) {\r\n    return toString(case$);\r\n}\r\n\r\nexport function CSSProp_Overflow_25F0CD75(overflow, overflowY) {\r\n    if (overflowY == null) {\r\n        return [\"overflow\", stringEnum(overflow)];\r\n    }\r\n    else {\r\n        const value = overflowY;\r\n        return [\"overflow\", (stringEnum(overflow) + \" \") + stringEnum(value)];\r\n    }\r\n}\r\n\r\n","import * as react from \"react\";\r\nimport { equals, uncurry } from \"../fable-library.3.1.4/Util.js\";\r\nimport { HTMLAttr } from \"./Fable.React.Props.fs.js\";\r\nimport { choose, fold } from \"../fable-library.3.1.4/Seq.js\";\r\nimport { isNullOrEmpty } from \"../fable-library.3.1.4/String.js\";\r\n\r\nexport function ReactElementTypeModule_memo(render) {\r\n    return react.memo(render, uncurry(2, null));\r\n}\r\n\r\nexport function ReactElementTypeModule_memoWith(areEqual, render) {\r\n    return react.memo(render, areEqual);\r\n}\r\n\r\nexport function Helpers_equalsButFunctions(x, y) {\r\n    if (x === y) {\r\n        return true;\r\n    }\r\n    else if ((typeof x === 'object' && !x[Symbol.iterator]) ? (!(y == null)) : false) {\r\n        const keys = Object.keys(x);\r\n        const length = keys.length | 0;\r\n        let i = 0;\r\n        let result = true;\r\n        while ((i < length) ? result : false) {\r\n            const key = keys[i];\r\n            i = (i + 1);\r\n            const xValue = x[key];\r\n            result = ((typeof xValue === 'function') ? true : equals(xValue, y[key]));\r\n        }\r\n        return result;\r\n    }\r\n    else {\r\n        return equals(x, y);\r\n    }\r\n}\r\n\r\nexport function Helpers_memoEqualsButFunctions(x, y) {\r\n    if (x === y) {\r\n        return true;\r\n    }\r\n    else if ((typeof x === 'object' && !x[Symbol.iterator]) ? (!(y == null)) : false) {\r\n        const keys = Object.keys(x);\r\n        const length = keys.length | 0;\r\n        let i = 0;\r\n        let result = true;\r\n        while ((i < length) ? result : false) {\r\n            const key = keys[i];\r\n            i = (i + 1);\r\n            const xValue = x[key];\r\n            result = ((typeof xValue === 'function') ? true : (xValue === y[key]));\r\n        }\r\n        return result;\r\n    }\r\n    else {\r\n        return false;\r\n    }\r\n}\r\n\r\nexport function Helpers_memoBuilder(name, render) {\r\n    render.displayName = name;\r\n    const memoType = ReactElementTypeModule_memo(render);\r\n    return (props) => react.createElement(memoType, props);\r\n}\r\n\r\nexport function Helpers_memoBuilderWith(name, areEqual, render) {\r\n    render.displayName = name;\r\n    const memoType = ReactElementTypeModule_memoWith(areEqual, render);\r\n    return (props) => react.createElement(memoType, props);\r\n}\r\n\r\nexport function Helpers_opt(o) {\r\n    const o_1 = o;\r\n    if (o_1 == null) {\r\n        return null;\r\n    }\r\n    else {\r\n        return o_1;\r\n    }\r\n}\r\n\r\nexport const Helpers_nothing = null;\r\n\r\nexport function Helpers_classBaseList(baseClass, classes) {\r\n    return new HTMLAttr(64, fold((state, name_1) => ((state + \" \") + name_1), baseClass, choose((tupledArg) => {\r\n        const name = tupledArg[0];\r\n        if (tupledArg[1] ? (!isNullOrEmpty(name)) : false) {\r\n            return name;\r\n        }\r\n        else {\r\n            return void 0;\r\n        }\r\n    }, classes)));\r\n}\r\n\r\nexport function Helpers_classList(classes) {\r\n    return Helpers_classBaseList(\"\", classes);\r\n}\r\n\r\n","import { Record } from \"../.fable/fable-library.3.1.4/Types.js\";\r\nimport { record_type, array_type, string_type } from \"../.fable/fable-library.3.1.4/Reflection.js\";\r\n\r\nexport class Resourcen extends Record {\r\n    constructor(Schliessen, BeginntUm, Sitzungsleitung, SitzungsleitungPlural, Raum, Posterbereich, Verschiedenes, Vortragender, WeitereInformationen, Tage, Rahmenprogramm, Pause, Ort, UhrZeitKurz, Poster, Locale, Und, TagKurz, AngabenInOrtszeit, EigenesProgramm, EigenesProgrammHilfe, EigenesProgrammAbrufen, EigenedProgrammSync, EigenedProgrammSync2, Login, LoginPlease1, LoginPlease2, Subscribe, Unsubscribe) {\r\n        super();\r\n        this.Schliessen = Schliessen;\r\n        this.BeginntUm = BeginntUm;\r\n        this.Sitzungsleitung = Sitzungsleitung;\r\n        this.SitzungsleitungPlural = SitzungsleitungPlural;\r\n        this.Raum = Raum;\r\n        this.Posterbereich = Posterbereich;\r\n        this.Verschiedenes = Verschiedenes;\r\n        this.Vortragender = Vortragender;\r\n        this.WeitereInformationen = WeitereInformationen;\r\n        this.Tage = Tage;\r\n        this.Rahmenprogramm = Rahmenprogramm;\r\n        this.Pause = Pause;\r\n        this.Ort = Ort;\r\n        this.UhrZeitKurz = UhrZeitKurz;\r\n        this.Poster = Poster;\r\n        this.Locale = Locale;\r\n        this.Und = Und;\r\n        this.TagKurz = TagKurz;\r\n        this.AngabenInOrtszeit = AngabenInOrtszeit;\r\n        this.EigenesProgramm = EigenesProgramm;\r\n        this.EigenesProgrammHilfe = EigenesProgrammHilfe;\r\n        this.EigenesProgrammAbrufen = EigenesProgrammAbrufen;\r\n        this.EigenedProgrammSync = EigenedProgrammSync;\r\n        this.EigenedProgrammSync2 = EigenedProgrammSync2;\r\n        this.Login = Login;\r\n        this.LoginPlease1 = LoginPlease1;\r\n        this.LoginPlease2 = LoginPlease2;\r\n        this.Subscribe = Subscribe;\r\n        this.Unsubscribe = Unsubscribe;\r\n    }\r\n}\r\n\r\nexport function Resourcen$reflection() {\r\n    return record_type(\"TagungsProgramm.Lokalisierung.Resourcen\", [], Resourcen, () => [[\"Schliessen\", string_type], [\"BeginntUm\", string_type], [\"Sitzungsleitung\", string_type], [\"SitzungsleitungPlural\", string_type], [\"Raum\", string_type], [\"Posterbereich\", string_type], [\"Verschiedenes\", string_type], [\"Vortragender\", string_type], [\"WeitereInformationen\", string_type], [\"Tage\", array_type(string_type)], [\"Rahmenprogramm\", string_type], [\"Pause\", string_type], [\"Ort\", string_type], [\"UhrZeitKurz\", string_type], [\"Poster\", string_type], [\"Locale\", string_type], [\"Und\", string_type], [\"TagKurz\", string_type], [\"AngabenInOrtszeit\", string_type], [\"EigenesProgramm\", string_type], [\"EigenesProgrammHilfe\", string_type], [\"EigenesProgrammAbrufen\", string_type], [\"EigenedProgrammSync\", string_type], [\"EigenedProgrammSync2\", string_type], [\"Login\", string_type], [\"LoginPlease1\", string_type], [\"LoginPlease2\", string_type], [\"Subscribe\", string_type], [\"Unsubscribe\", string_type]]);\r\n}\r\n\r\nexport const Deutsch = new Resourcen(\"Schließen\", \"Beginnt um\", \"Sitzungsleitung\", \"Sitzungsleitung\", \"Raum\", \"Posterbereich\", \"Verschiedenes\", \"Vortragender\", \"Weitere Informationen\", [\"Sonntag\", \"Montag\", \"Dienstag\", \"Mittwoch\", \"Donnerstag\", \"Freitag\", \"Samstag\"], \"Rahmenprogramm\", \"Pause\", \"Ort\", \" Uhr\", \"Poster\", \"de-DE\", \" und \", \"T\", \"Alle Zeitangaben in Ortszeit\", \"Eigener Zeitplan\", \"Sie können Programmpunkte wie Sessions und Beiträge zu Ihrem eigenen Zeitplan hinzufügen.\", \"Diesen Zeitplan auch auf anderen Geräten abrufen, indem Sie sich dort anmelden.\", \"Falls Sie schon einen Zeitplan auf einem anderen Gerät erstellt haben, synchronisiert sich dieser nach einem \", \" automatisch.\", \"Login\", \"Erstellung und Änderungen an Ihrem Zeitplan erfordern einen \", \" .\", \"Zum Zeitplan hinzufügen\", \"Vom Zeitplan entfernen\");\r\n\r\nexport const Englisch = new Resourcen(\"Close\", \"Starts at\", \"Chair:\", \"Chairs:\", \"Room:\", \"Poster area\", \"Various\", \"Presenting author\", \"More information\", [\"Sunday\", \"Monday\", \"Tuesday\", \"Wednesday\", \"Thursday\", \"Friday\", \"Saturday\"], \"Supporting programme\", \"Break\", \"Venue\", \"\", \"Posters\", \"en-EN\", \" and \", \"D\", \"All times in local time\", \"Personal Schedule\", \"You can add sessions and contributions to your personal schedule.\", \"Login on other devices to download your personal schedule.\", \"If you have already created a schedule on another device, it will be synchronized automatically after  \", \" .\", \"Login\", \"To create or update your personal schedule, please \", \".\", \"Subscribe\", \"Unsubscribe\");\r\n\r\n","import { currentTimeZone as currentTimeZone_1, toShortTimeString as toShortTimeString_1 } from \"./Date.js\";\r\nimport { empty as empty_1, append as append_1, tryHead, collect, sortBy, groupBy, singleton as singleton_1, head, cons, length, ofArray, ofSeq, mapIndexed, last, map } from \"../.fable/fable-library.3.1.4/List.js\";\r\nimport { compare, equals as equals_1, dayOfWeek, day, month, year, create, dayOfYear, parse } from \"../.fable/fable-library.3.1.4/Date.js\";\r\nimport { isNullOrWhiteSpace, join, printf, toText, replace } from \"../.fable/fable-library.3.1.4/String.js\";\r\nimport * as react from \"react\";\r\nimport { Helpers_nothing } from \"../.fable/Fable.React.8.0.1/Fable.React.Helpers.fs.js\";\r\nimport { Model__IstSubscribed_2297AD2E, Tab, Msg } from \"./Types.fs.js\";\r\nimport { dateHash, stringHash, comparePrimitives, equals, int32ToString } from \"../.fable/fable-library.3.1.4/Util.js\";\r\nimport { empty, singleton, append, delay } from \"../.fable/fable-library.3.1.4/Seq.js\";\r\nimport { map as map_1, defaultArg } from \"../.fable/fable-library.3.1.4/Option.js\";\r\nimport { FSharpMap__get_Item, toList, isEmpty, tryFind } from \"../.fable/fable-library.3.1.4/Map.js\";\r\nimport { DOMAttr, HTMLAttr, DangerousHtml } from \"../.fable/Fable.React.8.0.1/Fable.React.Props.fs.js\";\r\nimport { keyValueList } from \"../.fable/fable-library.3.1.4/MapUtil.js\";\r\nimport { fableModule } from \"../Global.fs.js\";\r\nimport { Deutsch, Englisch } from \"./Lokalisierung.fs.js\";\r\n\r\nexport const toShortTimeString = toShortTimeString_1;\r\n\r\nexport const currentTimeZone = currentTimeZone_1;\r\n\r\nexport function zeitAusgeben(zeiten, res, inOrtsZeit) {\r\n    return map((d) => {\r\n        let s_1, s;\r\n        const utc = parse(d + (inOrtsZeit ? \"Z\" : \"\"));\r\n        const local = parse(d);\r\n        const daydiff = (dayOfYear(utc) - dayOfYear(local)) | 0;\r\n        return replace((s_1 = (s = toShortTimeString(utc, res.Locale), (s.length === 7) ? (\"0\" + s) : s), (daydiff === 0) ? s_1 : ((daydiff < 0) ? toText(printf(\"%s %i%s\"))(s_1)(daydiff)(res.TagKurz) : toText(printf(\"%s +%iD\"))(s_1)(daydiff))), \" \", \" \");\r\n    }, zeiten);\r\n}\r\n\r\nexport function zeitAusgeben$0027(zeiten, res, inOrtsZeit) {\r\n    return react.createElement(react.Fragment, {}, ...map((e) => react.createElement(\"div\", {}, e), zeitAusgeben(zeiten, res, inOrtsZeit)));\r\n}\r\n\r\nexport function subscriptionStars(eigenesProgramm, subscribed) {\r\n    if (eigenesProgramm) {\r\n        return react.createElement(\"i\", {\r\n            className: \"fa \" + ((subscribed.tag === 2) ? \"fa-star-half-o\" : ((subscribed.tag === 1) ? \"fa-star-o\" : \"fa-star\")),\r\n        });\r\n    }\r\n    else {\r\n        return Helpers_nothing;\r\n    }\r\n}\r\n\r\nfunction Dialog_toggleSubscription(subscribed, res, dispatch) {\r\n    return react.createElement(\"button\", {\r\n        type: \"button\",\r\n        className: \"btn btn-warning btn-sm\",\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(7));\r\n        },\r\n    }, react.createElement(\"i\", {\r\n        className: \"fa \" + ((subscribed.tag === 2) ? \"fa-star\" : ((subscribed.tag === 1) ? \"fa-star\" : \"fa-star-o\")),\r\n    }), (subscribed.tag === 2) ? (\" \" + res.Subscribe) : ((subscribed.tag === 1) ? (\" \" + res.Subscribe) : (\" \" + res.Unsubscribe)));\r\n}\r\n\r\nfunction Dialog_toggleSubscriptionStars(subscribed, res, dispatch) {\r\n    return react.createElement(\"i\", {\r\n        className: \"fa fa-4x \" + ((subscribed.tag === 2) ? \"fa-star-half-o\" : ((subscribed.tag === 1) ? \"fa-star-o\" : \"fa-star\")),\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(7));\r\n        },\r\n    });\r\n}\r\n\r\nexport function Dialog_render$0027(res, abbrechen, header, footer, content) {\r\n    return react.createElement(\"div\", {\r\n        className: \"modal fade in\",\r\n        tabIndex: -1,\r\n        role: \"dialog\",\r\n        style: {\r\n            display: \"block\",\r\n            paddingRight: \"14px\",\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"modal-dialog modal-lg\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"modal-content\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"modal-header\",\r\n    }, react.createElement(\"button\", {\r\n        type: \"button\",\r\n        className: \"close\",\r\n        onClick: abbrechen,\r\n    }, \"×\"), header), react.createElement(\"div\", {\r\n        className: \"modal-body\",\r\n    }, ...content), react.createElement(\"div\", {\r\n        className: \"modal-footer\",\r\n    }, react.createElement(react.Fragment, {}, ...footer), react.createElement(\"button\", {\r\n        type: \"button\",\r\n        className: \"btn btn-info btn-sm\",\r\n        onClick: abbrechen,\r\n    }, res.Schliessen)))));\r\n}\r\n\r\nexport function Dialog_renderWithSubscription(res, abbrechen, header, content, eigenesProgramm, subscribed, dispatch) {\r\n    if (eigenesProgramm) {\r\n        return Dialog_render$0027(res, abbrechen, react.createElement(\"div\", {\r\n            className: \"row\",\r\n        }, react.createElement(\"div\", {\r\n            className: \"col-xs-10\",\r\n        }, header), react.createElement(\"div\", {\r\n            className: \"col-xs-2 text-center\",\r\n        }, Dialog_toggleSubscriptionStars(subscribed, res, dispatch))), [Dialog_toggleSubscription(subscribed, res, dispatch)], content);\r\n    }\r\n    else {\r\n        return Dialog_render$0027(res, abbrechen, header, [], content);\r\n    }\r\n}\r\n\r\nexport function Dialog_render(res, abbrechen, header, content) {\r\n    return Dialog_render$0027(res, abbrechen, header, [], content);\r\n}\r\n\r\nexport function AnmeldungAnfordern_render(res, url, dispatch) {\r\n    let arg20;\r\n    return Dialog_render(res, (_arg1) => {\r\n        dispatch(new Msg(1));\r\n    }, react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, \"Login required\"), [res.LoginPlease1, react.createElement(\"a\", {\r\n        className: \"btn btn-info \",\r\n        href: (arg20 = window.location.href, toText(printf(\"%s?returnUrl=%s\"))(url)(arg20)),\r\n    }, res.Login), res.LoginPlease2]);\r\n}\r\n\r\nexport function Beitrag_autoren(res, beitrag) {\r\n    const letzterAutor = last(beitrag.Autoren);\r\n    return map((autor) => react.createElement(react.Fragment, {}, react.createElement(\"span\", {\r\n        className: autor.Vortragender ? \"Vortragender\" : \"\",\r\n    }, autor.Name), react.createElement(\"sup\", {}, ...map((i) => int32ToString(i), autor.FirmenIndex)), (!equals(autor, letzterAutor)) ? \", \" : Helpers_nothing), beitrag.Autoren);\r\n}\r\n\r\nexport function Beitrag_firmen(beitrag) {\r\n    return mapIndexed((i, firma) => react.createElement(react.Fragment, {}, int32ToString(i + 1), \" \", firma.Name, (firma.Land === \"\") ? \"\" : (\", \" + firma.Land), react.createElement(\"br\", {})), beitrag.Firmen);\r\n}\r\n\r\nexport function Beitrag_head(res, beitrag, inOrtszeit) {\r\n    return react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-10\",\r\n    }, ...ofSeq(delay(() => append(singleton(react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"small\",\r\n    }, beitrag.Vortragsnummer))), delay(() => ((!(beitrag.Zeiten.tail == null)) ? singleton(react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-12 small\",\r\n    }, res.BeginntUm, \" \", join(res.Und, map((t) => (t + res.UhrZeitKurz), zeitAusgeben(beitrag.Zeiten, res, inOrtszeit)))))) : empty())))))));\r\n}\r\n\r\nexport function Beitrag_content(res, beitrag, manuskripte) {\r\n    return ofArray([react.createElement(\"h4\", {\r\n        style: {\r\n            marginTop: \"0\",\r\n        },\r\n    }, beitrag.Titel), react.createElement(\"p\", {}, ...Beitrag_autoren(res, beitrag)), react.createElement(\"p\", {}, ...Beitrag_firmen(beitrag)), react.createElement(\"div\", {\r\n        style: {\r\n            fontSize: \"large\",\r\n            fontFamily: \"\\u0027Droid Serif\\u0027, \\u0027Times New Roman\\u0027, Serif\",\r\n            whiteSpace: \"pre-wrap\",\r\n        },\r\n    }, beitrag.Kurzfassung), defaultArg(map_1((m) => react.createElement(\"div\", {\r\n        style: {\r\n            margin: \"1em 0 0 0\",\r\n        },\r\n    }, react.createElement(\"a\", {\r\n        target: \"_blank\",\r\n        href: \"/\" + m.Url,\r\n    }, react.createElement(\"i\", {\r\n        className: \"fa fa-file-pdf-o fa-2x\",\r\n    }), \" Download Paper\")), tryFind(beitrag.Vortragsnummer, manuskripte)), Helpers_nothing)]);\r\n}\r\n\r\nexport function Beitrag_render(beitrag, manuskripte, res, inOrtszeit, eigenesProgramm, istSubscribed, dispatch) {\r\n    return Dialog_renderWithSubscription(res, (_arg1) => {\r\n        dispatch(new Msg(11));\r\n    }, Beitrag_head(res, beitrag, inOrtszeit), Beitrag_content(res, beitrag, manuskripte), eigenesProgramm, istSubscribed, dispatch);\r\n}\r\n\r\nexport function Session_renderBeitrag(res, inOrtszeit, eigenesProgramm, testIfSubscribed, dispatch, beitrag) {\r\n    let patternInput;\r\n    const matchValue = [beitrag.SessionNr, beitrag.Uhrzeit];\r\n    patternInput = ((matchValue[0] == null) ? (isNullOrWhiteSpace(matchValue[1]) ? [beitrag.Vortragsnummer, \"\"] : [zeitAusgeben$0027(beitrag.Zeiten, res, inOrtszeit), beitrag.Vortragsnummer]) : [beitrag.Vortragsnummer + \" *\", matchValue[0]]);\r\n    const letzterAutor = last(beitrag.Autoren);\r\n    return react.createElement(\"div\", {\r\n        className: \"row calBeitrag\" + (beitrag.Abgesagt ? \" Abgesagt\" : \"\"),\r\n        onClick: (e) => {\r\n            if (beitrag.Abgesagt) {\r\n                e.preventDefault();\r\n            }\r\n            else {\r\n                dispatch(new Msg(10, beitrag));\r\n            }\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-sm-2\",\r\n    }, react.createElement(\"div\", {}, react.createElement(\"span\", {}, patternInput[0], subscriptionStars(eigenesProgramm, testIfSubscribed(beitrag.Vortragsnummer)))), react.createElement(\"p\", {\r\n        className: \"calRoom\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"calRoom\",\r\n    }, patternInput[1]))), react.createElement(\"div\", {\r\n        className: \"col-sm-10\",\r\n    }, react.createElement(\"h4\", {\r\n        style: {\r\n            marginTop: \"0\",\r\n        },\r\n    }, beitrag.Titel), react.createElement(\"p\", {}, ...Beitrag_autoren(res, beitrag)), react.createElement(\"p\", {}, react.createElement(\"small\", {}, ...Beitrag_firmen(beitrag)))));\r\n}\r\n\r\nexport function Session_renderHead(raum, session, res) {\r\n    let letzterLeiter;\r\n    const raum_1 = defaultArg(session.AndererRaum, raum.Raum);\r\n    return react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-10\",\r\n    }, react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, defaultArg(map_1((k) => react.createElement(\"span\", {\r\n        className: \"small\",\r\n    }, k), session[\"Kürzel\"]), Helpers_nothing), react.createElement(\"br\", {}), session.Bezeichnung), (session.Sitzungsleiter.tail == null) ? Helpers_nothing : react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-3 col-sm-2\",\r\n    }, react.createElement(\"small\", {}, (length(session.Sitzungsleiter) > 1) ? res.SitzungsleitungPlural : res.Sitzungsleitung)), react.createElement(\"div\", {\r\n        className: \"col-xs-9 col-sm-10 small\",\r\n    }, ...(letzterLeiter = last(session.Sitzungsleiter), map((leiter) => react.createElement(react.Fragment, {}, leiter.AnzeigeName, (!equals(leiter, letzterLeiter)) ? \", \" : Helpers_nothing), session.Sitzungsleiter)))), react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-3 col-sm-2 small\",\r\n    }, res.Raum), react.createElement(\"div\", {\r\n        className: \"col-xs-9 col-sm-10 small\",\r\n    }, raum_1))));\r\n}\r\n\r\nexport function Session_html(text) {\r\n    return react.createElement(\"div\", {\r\n        dangerouslySetInnerHTML: new DangerousHtml(text),\r\n    });\r\n}\r\n\r\nexport function Session_render(raum, session, beitr$00E4ge, res, inOrtszeit, eigenesProgramm, istSubscribed, testIfSubscribed, dispatch) {\r\n    return Dialog_renderWithSubscription(res, (_arg1) => {\r\n        dispatch(new Msg(6));\r\n    }, Session_renderHead(raum, session, res), cons(Session_html(session.Beschreibung), map((beitrag) => Session_renderBeitrag(res, inOrtszeit, eigenesProgramm, testIfSubscribed, dispatch, beitrag), beitr$00E4ge)), eigenesProgramm, istSubscribed, dispatch);\r\n}\r\n\r\nexport function Programm_renderHead(raum, programm, res) {\r\n    const raum_1 = defaultArg(programm.AndererRaum, raum.Raum);\r\n    return react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-10\",\r\n    }, react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, defaultArg(map_1((k) => react.createElement(\"span\", {\r\n        className: \"small\",\r\n    }, k), programm[\"Kürzel\"]), Helpers_nothing), react.createElement(\"br\", {}), programm.Bezeichnung), react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-3 small\",\r\n    }, res.Raum), react.createElement(\"div\", {\r\n        className: \"col-xs-9 small\",\r\n    }, raum_1))));\r\n}\r\n\r\nexport function Programm_render(raum, programm, res, dispatch) {\r\n    return Dialog_render(res, (_arg1) => {\r\n        dispatch(new Msg(9));\r\n    }, Programm_renderHead(raum, programm, res), [react.createElement(\"div\", {\r\n        dangerouslySetInnerHTML: new DangerousHtml(programm.Beschreibung),\r\n    })]);\r\n}\r\n\r\nexport function TagesProgramm_renderProgramm$0027(programm, res, inOrtszeit) {\r\n    return react.createElement(react.Fragment, {}, react.createElement(\"div\", {\r\n        className: \"clearfix\",\r\n    }), react.createElement(\"div\", {\r\n        className: \"row\",\r\n        style: {\r\n            marginBottom: \"5px\",\r\n            marginTop: \"16px\",\r\n        },\r\n    }, react.createElement(\"h5\", {}, zeitAusgeben$0027(programm.Startzeiten, res, inOrtszeit)), defaultArg(map_1((k) => react.createElement(\"div\", {\r\n        className: \"calNumber text-center\",\r\n    }, k), programm[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {\r\n        className: \" text-center \",\r\n    }, programm.Bezeichnung)));\r\n}\r\n\r\nexport function TagesProgramm_renderProgramm(raum, programm, res, inOrtszeit, dispatch) {\r\n    const hatBeschreibung = !isNullOrWhiteSpace(programm.Beschreibung);\r\n    return react.createElement(\"div\", keyValueList([new HTMLAttr(65, \"col-sm-10 col-sm-offset-1 col-md-8 col-md-offset-2 \"), hatBeschreibung ? (new DOMAttr(40, (_arg1) => {\r\n        dispatch(new Msg(8, raum, programm));\r\n    })) : (new DOMAttr(40, (value_1) => {\r\n        void value_1;\r\n    }))], 1), react.createElement(\"div\", {\r\n        className: hatBeschreibung ? \"calSession\" : \"calProgramm\",\r\n        style: {\r\n            padding: \"16px\",\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"row \",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-2\",\r\n    }, zeitAusgeben$0027(programm.Startzeiten, res, inOrtszeit)), react.createElement(\"div\", {\r\n        className: \"col-xs-10 \",\r\n    }, defaultArg(map_1((k) => react.createElement(\"div\", {\r\n        className: \"calNumber\",\r\n    }, k), programm[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {}, programm.Bezeichnung)))));\r\n}\r\n\r\nexport function TagesProgramm_renderSession(raum, session, res, inOrtszeit, istSubscribed, dispatch) {\r\n    return react.createElement(\"div\", {\r\n        className: \"col-sm-10 col-sm-offset-1 col-md-8 col-md-offset-2 \",\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(5, raum, session));\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"calSession\",\r\n        style: {\r\n            padding: \"16px\",\r\n        },\r\n    }, ...ofSeq(delay(() => {\r\n        let matchValue;\r\n        return append((matchValue = istSubscribed(session[\"Kürzel\"]), (matchValue.tag === 2) ? singleton(react.createElement(\"i\", {\r\n            className: \"fa fa-star-half-o pull-right\",\r\n        })) : ((matchValue.tag === 1) ? singleton(Helpers_nothing) : singleton(react.createElement(\"i\", {\r\n            className: \"fa fa-star pull-right\",\r\n        })))), delay(() => singleton(react.createElement(\"div\", {\r\n            className: \"row \",\r\n        }, react.createElement(\"div\", {\r\n            className: \"col-xs-2\",\r\n        }, zeitAusgeben$0027(session.Startzeiten, res, inOrtszeit)), react.createElement(\"div\", {\r\n            className: \"col-xs-10 \",\r\n        }, defaultArg(map_1((k) => react.createElement(\"div\", {\r\n            className: \"calNumber\",\r\n        }, k), session[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {}, session.Bezeichnung))))));\r\n    }))));\r\n}\r\n\r\nexport function TagesProgramm_renderPause(res, pause) {\r\n    const pause_1 = (pause === \"Pause\") ? res.Pause : pause;\r\n    return react.createElement(react.Fragment, {}, react.createElement(\"div\", {\r\n        className: \"clearfix\",\r\n    }), react.createElement(\"p\", {\r\n        className: \"text-center\",\r\n        style: {\r\n            margin: \"0\",\r\n        },\r\n    }, react.createElement(\"i\", {\r\n        style: {\r\n            fontSize: \"0.8em\",\r\n        },\r\n    }, pause_1)));\r\n}\r\n\r\nexport function TagesProgramm_render(res, inOrtszeit, istSubscribed, dispatch, tag) {\r\n    const raum = head(tag[\"Räume\"]);\r\n    return react.createElement(\"div\", {\r\n        className: \"container\",\r\n        id: \"calGrid\",\r\n    }, react.createElement(\"section\", {\r\n        id: \"programm\",\r\n    }, ...map((a) => {\r\n        const matchValue = [a.Pause, tryFind(raum.Id, a.Programmpunkte)];\r\n        if (matchValue[0] != null) {\r\n            const pause = matchValue[0];\r\n            return TagesProgramm_renderPause(res, pause);\r\n        }\r\n        else if (matchValue[1] != null) {\r\n            if (matchValue[1].tag === 1) {\r\n                const session = matchValue[1].fields[0];\r\n                return TagesProgramm_renderSession(raum, session, res, inOrtszeit, istSubscribed, dispatch);\r\n            }\r\n            else {\r\n                const punkt_1 = matchValue[1].fields[0];\r\n                return TagesProgramm_renderProgramm(raum, punkt_1, res, inOrtszeit, dispatch);\r\n            }\r\n        }\r\n        else {\r\n            return Helpers_nothing;\r\n        }\r\n    }, tag.Achsen)));\r\n}\r\n\r\nexport function TagMitR$00E4umen_renderProgramm(raum, programm, dispatch) {\r\n    const hatBeschreibung = !isNullOrWhiteSpace(programm.Beschreibung);\r\n    return react.createElement(\"div\", keyValueList([new HTMLAttr(65, \"col-md-3 \"), hatBeschreibung ? (new DOMAttr(40, (_arg1) => {\r\n        dispatch(new Msg(8, raum, programm));\r\n    })) : (new DOMAttr(40, (value_1) => {\r\n        void value_1;\r\n    }))], 1), (!hatBeschreibung) ? react.createElement(\"div\", {\r\n        className: \"calPunkt\",\r\n    }, defaultArg(map_1((k) => react.createElement(\"div\", {\r\n        className: \"calNumber\",\r\n    }, k), programm[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {\r\n        className: \"calName box equal-height\",\r\n        style: {\r\n            height: \"20px\",\r\n        },\r\n    }, programm.Bezeichnung), react.createElement(\"div\", {\r\n        className: \"calRoom\",\r\n    }, defaultArg(programm.AndererRaum, raum.Raum))) : react.createElement(\"div\", {\r\n        className: \"calSession\",\r\n    }, defaultArg(map_1((k_1) => react.createElement(\"div\", {\r\n        className: \"calNumber\",\r\n    }, k_1), programm[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {\r\n        className: \"calName box equal-height\",\r\n        style: {\r\n            height: \"20px\",\r\n        },\r\n    }, programm.Bezeichnung), react.createElement(\"div\", {\r\n        className: \"calRoom\",\r\n    }, defaultArg(programm.AndererRaum, raum.Raum))));\r\n}\r\n\r\nexport function TagMitR$00E4umen_renderSession(raum, session, istSubscribed, dispatch) {\r\n    return react.createElement(\"div\", {\r\n        className: \"col-md-3 \",\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(5, raum, session));\r\n        },\r\n    }, ...ofSeq(delay(() => {\r\n        let matchValue;\r\n        return append((matchValue = istSubscribed(session[\"Kürzel\"]), (matchValue.tag === 2) ? singleton(react.createElement(\"i\", {\r\n            className: \"fa fa-star-half-o pull-right\",\r\n        })) : ((matchValue.tag === 1) ? singleton(Helpers_nothing) : singleton(react.createElement(\"i\", {\r\n            className: \"fa fa-star pull-right\",\r\n        })))), delay(() => singleton(react.createElement(\"div\", {\r\n            className: \"calSession\",\r\n        }, defaultArg(map_1((k) => react.createElement(\"div\", {\r\n            className: \"calNumber\",\r\n        }, k), session[\"Kürzel\"]), Helpers_nothing), react.createElement(\"div\", {\r\n            className: \"calName box equal-height\",\r\n            style: {\r\n                height: \"20px\",\r\n            },\r\n        }, session.Bezeichnung), react.createElement(\"div\", {\r\n            className: \"calRoom\",\r\n        }, raum.Raum)))));\r\n    })));\r\n}\r\n\r\nexport function TagMitR$00E4umen_renderPunkt(istSubscribed, dispatch, raum, punkt) {\r\n    if (punkt != null) {\r\n        if (punkt.tag === 1) {\r\n            const session = punkt.fields[0];\r\n            return TagMitR$00E4umen_renderSession(raum, session, istSubscribed, dispatch);\r\n        }\r\n        else {\r\n            const punkt_1 = punkt.fields[0];\r\n            return TagMitR$00E4umen_renderProgramm(raum, punkt_1, dispatch);\r\n        }\r\n    }\r\n    else {\r\n        return react.createElement(\"div\", {\r\n            className: \"col-md-3 \",\r\n        });\r\n    }\r\n}\r\n\r\nexport function TagMitR$00E4umen_render(tag, res, istSubscribed, dispatch) {\r\n    return react.createElement(\"div\", {\r\n        id: \"calGrid\",\r\n        className: \"container\",\r\n        style: {\r\n            marginTop: \"16px\",\r\n        },\r\n    }, ...map((achse) => react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-1 zeit\",\r\n    }, react.createElement(\"span\", {}, achse.Startzeit)), react.createElement(\"div\", {\r\n        className: \"col-xs-11\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, defaultArg(map_1((p) => react.createElement(\"div\", {\r\n        className: \"pause col-xs-12\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"calNumber\",\r\n    }, (p === \"Pause\") ? res.Pause : p)), achse.Pause), Helpers_nothing), react.createElement(react.Fragment, {}, ...map((raum) => TagMitR$00E4umen_renderPunkt(istSubscribed, dispatch, raum, tryFind(raum.Id, achse.Programmpunkte)), tag[\"Räume\"]))))), tag.Achsen));\r\n}\r\n\r\nexport function Thema_renderBeitrag(res, dispatch, beitrag) {\r\n    const letzterAutor = last(beitrag.Autoren);\r\n    let patternInput;\r\n    const matchValue = [beitrag.SessionNr, beitrag.Uhrzeit];\r\n    patternInput = ((matchValue[0] == null) ? (isNullOrWhiteSpace(matchValue[1]) ? [beitrag.Vortragsnummer, \"\"] : [matchValue[1], beitrag.Vortragsnummer]) : [beitrag.Vortragsnummer + \" *\", matchValue[0]]);\r\n    return react.createElement(\"div\", {\r\n        className: \"row calBeitrag\",\r\n        onClick: (e) => {\r\n            dispatch(new Msg(10, beitrag));\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-sm-2\",\r\n    }, react.createElement(\"p\", {}, react.createElement(\"span\", {}, patternInput[0])), react.createElement(\"p\", {\r\n        className: \"calRoom\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"calRoom\",\r\n    }, patternInput[1]), react.createElement(\"i\", {\r\n        className: \"fa fa-star fa-lg\",\r\n        style: {\r\n            display: \"none\",\r\n        },\r\n    }))), react.createElement(\"div\", {\r\n        className: \"col-sm-10\",\r\n    }, react.createElement(\"h4\", {\r\n        style: {\r\n            marginTop: \"0\",\r\n        },\r\n    }, beitrag.Titel), react.createElement(\"p\", {}, ...Beitrag_autoren(res, beitrag)), react.createElement(\"p\", {}, react.createElement(\"small\", {}, ...Beitrag_firmen(beitrag)))));\r\n}\r\n\r\nexport function Thema_renderHead(thema, poster) {\r\n    let arg20, arg10;\r\n    return react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-10\",\r\n    }, react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"small\",\r\n    }, (arg20 = last(poster).Vortragsnummer, (arg10 = head(poster).Vortragsnummer, toText(printf(\"%s - %s\"))(arg10)(arg20)))), react.createElement(\"br\", {}), thema)));\r\n}\r\n\r\nexport function Thema_render(thema, beitr$00E4ge, res, dispatch) {\r\n    return Dialog_render(res, (_arg1) => {\r\n        dispatch(new Msg(4));\r\n    }, Thema_renderHead(thema, beitr$00E4ge), map((beitrag) => Thema_renderBeitrag(res, dispatch, beitrag), beitr$00E4ge));\r\n}\r\n\r\nexport function Posters_renderThema(thema, poster, res, dispatch) {\r\n    let arg20, arg10;\r\n    return react.createElement(\"div\", {\r\n        className: \"col-lg-3 col-md-4 col-sm-6\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"calSession\",\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(3, [thema, poster]));\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"calNumber\",\r\n    }, (arg20 = last(poster).Vortragsnummer, (arg10 = head(poster).Vortragsnummer, toText(printf(\"%s - %s\"))(arg10)(arg20)))), react.createElement(\"div\", {\r\n        className: \"cal-Name box equal-height\",\r\n    }, thema), react.createElement(\"div\", {\r\n        className: \"calRoom\",\r\n    }, res.Posterbereich)));\r\n}\r\n\r\nexport function Posters_render(poster, res, dispatch) {\r\n    let props, _arg1;\r\n    return react.createElement(\"div\", {\r\n        id: \"calGrid\",\r\n        className: \"container\",\r\n    }, (props = ofArray([new HTMLAttr(65, \"row\"), [\"style\", {\r\n        marginTop: \"16px\",\r\n    }]]), react.createElement(\"div\", keyValueList(props, 1), ...(_arg1 = poster, (_arg1.tail != null) ? ((_arg1.tail.tail == null) ? map((beitrag) => Thema_renderBeitrag(res, dispatch, beitrag), _arg1.head[1]) : map((tupledArg) => {\r\n        const thema = tupledArg[0];\r\n        return Posters_renderThema(isNullOrWhiteSpace(thema) ? res.Verschiedenes : thema, tupledArg[1], res, dispatch);\r\n    }, _arg1)) : map((tupledArg) => {\r\n        const thema = tupledArg[0];\r\n        return Posters_renderThema(isNullOrWhiteSpace(thema) ? res.Verschiedenes : thema, tupledArg[1], res, dispatch);\r\n    }, _arg1)))));\r\n}\r\n\r\nexport function RahmenprogrammPunkt_head(beitrag, res) {\r\n    return react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-10\",\r\n    }, react.createElement(\"h3\", {\r\n        className: \"modal-title\",\r\n    }, react.createElement(\"span\", {\r\n        className: \"small\",\r\n    }, beitrag.Bezeichnung)), react.createElement(\"div\", {\r\n        className: \"row\",\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-xs-12 small\",\r\n    }, res.BeginntUm, beitrag.Zeit), react.createElement(\"div\", {\r\n        className: \"col-xs-12 small\",\r\n    }, res.Ort, beitrag.Raum))));\r\n}\r\n\r\nexport function RahmenprogrammPunkt_content(beitrag) {\r\n    return singleton_1(react.createElement(\"div\", {\r\n        dangerouslySetInnerHTML: new DangerousHtml(beitrag.Beschreibung),\r\n    }));\r\n}\r\n\r\nexport function RahmenprogrammPunkt_render(beitrag, res, dispatch) {\r\n    return Dialog_render(res, (_arg1) => {\r\n        dispatch(new Msg(13));\r\n    }, RahmenprogrammPunkt_head(beitrag, res), RahmenprogrammPunkt_content(beitrag));\r\n}\r\n\r\nexport function EigenesProgramm_tagKopf(text) {\r\n    return react.createElement(\"div\", {\r\n        style: {\r\n            marginTop: \"30px\",\r\n        },\r\n    }, react.createElement(\"h4\", {\r\n        className: \"text-center\",\r\n    }, text), react.createElement(\"div\", {\r\n        className: \"separator\",\r\n    }));\r\n}\r\n\r\nexport function EigenesProgramm_userId() {\r\n    const container = document.getElementById(fableModule.Platzhalter);\r\n    return container.dataset[\"user\"];\r\n}\r\n\r\nexport function EigenesProgramm_render(termine, istAngemeldet, url, res, dispatch) {\r\n    return react.createElement(\"div\", {\r\n        className: \"container\",\r\n        style: {\r\n            marginTop: \"16px\",\r\n        },\r\n    }, react.createElement(react.Fragment, {}, ...map((tupledArg) => react.createElement(react.Fragment, {}, EigenesProgramm_tagKopf(tupledArg[0]), react.createElement(\"div\", {}, ...map((t_2) => {\r\n        const props_12 = ofArray([new HTMLAttr(65, \"row sc-element \"), [\"style\", {\r\n            padding: \"14px 0\",\r\n        }]]);\r\n        return react.createElement(\"div\", keyValueList(props_12, 1), react.createElement(\"div\", {\r\n            className: \"col-sm-1\",\r\n        }), react.createElement(\"div\", {\r\n            className: \"col-sm-3\",\r\n        }, head(zeitAusgeben(singleton_1(t_2.Start), res, false)), \"-\", head(zeitAusgeben(singleton_1(t_2.End), res, false)), \" \" + res.UhrZeitKurz, react.createElement(\"br\", {}), react.createElement(\"span\", {\r\n            className: \"small\",\r\n        }, t_2.Name)), react.createElement(\"div\", {\r\n            className: \"col-sm-8\",\r\n        }, react.createElement(\"h4\", {\r\n            style: {\r\n                marginTop: 0,\r\n                marginBottom: 4,\r\n            },\r\n        }, t_2.Description), t_2.Location));\r\n    }, tupledArg[1]))), groupBy((t_1) => {\r\n        const datum_1 = parse(t_1.Start);\r\n        let dow;\r\n        let copyOfStruct = create(year(datum_1), month(datum_1), day(datum_1));\r\n        dow = dayOfWeek(copyOfStruct);\r\n        const tag = res.Tage[dow];\r\n        const arg30 = month(datum_1) | 0;\r\n        const arg20 = day(datum_1) | 0;\r\n        return toText(printf(\"%s, %02i.%02i.\"))(tag)(arg20)(arg30);\r\n    }, sortBy((t) => t.Start, termine, {\r\n        Compare: (x, y) => comparePrimitives(x, y),\r\n    }), {\r\n        Equals: (x_1, y_1) => (x_1 === y_1),\r\n        GetHashCode: (x_1) => stringHash(x_1),\r\n    }))), react.createElement(\"div\", {\r\n        style: {\r\n            paddingTop: 24,\r\n        },\r\n    }, ...ofSeq(delay(() => append(singleton(res.EigenesProgrammHilfe), delay(() => append(singleton(react.createElement(\"br\", {})), delay(() => {\r\n        let arg20_1;\r\n        return append(istAngemeldet ? singleton(res.EigenesProgrammAbrufen) : singleton(react.createElement(react.Fragment, {}, res.EigenedProgrammSync, react.createElement(\"a\", {\r\n            className: \"btn btn-info \",\r\n            href: (arg20_1 = window.location.href, toText(printf(\"%s?returnUrl=%s\"))(url)(arg20_1)),\r\n        }, res.Login), res.EigenedProgrammSync2)), delay(() => {\r\n            let arg20_2, arg10_2;\r\n            return istAngemeldet ? singleton(react.createElement(\"p\", {\r\n                style: {\r\n                    marginTop: 12,\r\n                },\r\n            }, react.createElement(\"i\", {\r\n                className: \"fa fa-calendar\",\r\n            }), \" \", react.createElement(\"a\", {\r\n                href: (arg20_2 = EigenesProgramm_userId(), (arg10_2 = ((window.location.protocol === \"https:\") ? \"s\" : \"\"), toText(printf(\"webcal%s://tagung.dgzfp/desktopmodules/tagung/profile/calendar.aspx?tn=%s\"))(arg10_2)(arg20_2))),\r\n            }, \"Meine Termine \"), \" mit Kalender-App (z.B. Outlook) verbinden.\")) : empty();\r\n        }));\r\n    }))))))));\r\n}\r\n\r\nexport function Rahmenprogramm_tag(datum) {\r\n    const datum_1 = parse(datum);\r\n    return create(year(datum_1), month(datum_1), day(datum_1));\r\n}\r\n\r\nexport function Rahmenprogramm_tagCaption(res, datum) {\r\n    const wochentag = res.Tage[dayOfWeek(datum)];\r\n    const arg30 = month(datum) | 0;\r\n    const arg20 = day(datum) | 0;\r\n    return toText(printf(\"%s, %02i.%02i.\"))(wochentag)(arg20)(arg30);\r\n}\r\n\r\nexport function Rahmenprogramm_tagKopf(text) {\r\n    return react.createElement(\"div\", {\r\n        style: {\r\n            marginTop: \"30px\",\r\n        },\r\n    }, react.createElement(\"h4\", {\r\n        className: \"text-center\",\r\n    }, text), react.createElement(\"div\", {\r\n        className: \"separator\",\r\n    }));\r\n}\r\n\r\nexport function Rahmenprogramm_renderPunkt(res, dispatch, r) {\r\n    return react.createElement(\"div\", {\r\n        className: \"row sc-element \",\r\n        style: {\r\n            padding: \"14px 0\",\r\n        },\r\n    }, react.createElement(\"div\", {\r\n        className: \"col-sm-1\",\r\n    }), react.createElement(\"div\", {\r\n        className: \"col-sm-3\",\r\n    }, react.createElement(\"p\", {}, r.Zeit, res.UhrZeitKurz), react.createElement(\"p\", {\r\n        className: \"small\",\r\n    }, r.Raum)), react.createElement(\"div\", {\r\n        className: \"col-sm-8\",\r\n    }, react.createElement(\"h4\", {\r\n        style: {\r\n            marginTop: \"0px\",\r\n        },\r\n    }, r.Bezeichnung), isNullOrWhiteSpace(r.Beschreibung) ? Helpers_nothing : react.createElement(\"a\", {\r\n        className: \"btn btn-default btn-sm\",\r\n        onClick: (_arg1) => {\r\n            dispatch(new Msg(12, r));\r\n        },\r\n    }, res.WeitereInformationen)));\r\n}\r\n\r\nexport function Rahmenprogramm_render(rahmenprogramm, res, dispatch) {\r\n    const props_3 = ofArray([new HTMLAttr(99, \"calGrid\"), new HTMLAttr(65, \"container\"), [\"style\", {\r\n        marginTop: \"16px\",\r\n    }]]);\r\n    return react.createElement(\"div\", keyValueList(props_3, 1), ...collect((x_2) => x_2, map((tupledArg_1) => ofArray([Rahmenprogramm_tagKopf(Rahmenprogramm_tagCaption(res, tupledArg_1[0])), react.createElement(\"div\", {}, ...map((r_1) => Rahmenprogramm_renderPunkt(res, dispatch, r_1), tupledArg_1[1]))]), sortBy((tupledArg) => tupledArg[0], groupBy((r) => Rahmenprogramm_tag(r.Startdatum), rahmenprogramm, {\r\n        Equals: (x, y) => equals_1(x, y),\r\n        GetHashCode: (x) => dateHash(x),\r\n    }), {\r\n        Compare: (x_1, y_1) => compare(x_1, y_1),\r\n    }))));\r\n}\r\n\r\nexport function renderProgramm(model, res, dispatch) {\r\n    let tabs_3, tabs_2, tabs_1, tabs, t, matchValue, s_5, tag_14;\r\n    const mehrereTage = length(model.Tage) > 1;\r\n    const hatRahmenprogramm = !(model.Rahmenprogramm.tail == null);\r\n    const hatPoster = !(model.Poster.tail == null);\r\n    const tabs_4 = react.createElement(\"div\", {\r\n        className: \"container\",\r\n    }, react.createElement(\"ul\", {\r\n        className: \"nav nav-tabs\",\r\n    }, ...(tabs_3 = (tabs_2 = (tabs_1 = (tabs = map((tag_1) => {\r\n        let tag, wochentag;\r\n        return react.createElement(\"li\", {\r\n            role: \"presentation\",\r\n            className: equals(model[\"Ausgewählt\"], new Tab(0, tag_1)) ? \"active\" : \"\",\r\n        }, react.createElement(\"a\", {\r\n            href: \"#\",\r\n            onClick: (event) => {\r\n                dispatch(new Msg(2, new Tab(0, tag_1)));\r\n                event.preventDefault();\r\n                event.stopPropagation();\r\n            },\r\n        }, (tag = tag_1, (wochentag = res.Tage[tag.Wochentag], defaultArg(map_1((a) => {\r\n            const d_1 = parse(a.Datum);\r\n            const arg30 = month(d_1) | 0;\r\n            const arg20 = day(d_1) | 0;\r\n            return toText(printf(\"%s, %02i.%02i.\"))(wochentag)(arg20)(arg30);\r\n        }, tryHead(tag.Achsen)), wochentag)))));\r\n    }, model.Tage), isEmpty(model.TabSessions) ? tabs : append_1(tabs, map((tupledArg) => {\r\n        const k = tupledArg[0];\r\n        return react.createElement(\"li\", {\r\n            role: \"presentation\",\r\n            className: equals(model[\"Ausgewählt\"], new Tab(2, k)) ? \"active\" : \"\",\r\n        }, react.createElement(\"a\", {\r\n            href: \"#\",\r\n            onClick: (event_1) => {\r\n                dispatch(new Msg(2, new Tab(2, k)));\r\n                event_1.preventDefault();\r\n                event_1.stopPropagation();\r\n            },\r\n        }, k));\r\n    }, toList(model.TabSessions)))), (model.Poster.tail == null) ? tabs_1 : append_1(tabs_1, singleton_1(react.createElement(\"li\", {\r\n        role: \"presentation\",\r\n        className: equals(model[\"Ausgewählt\"], new Tab(1)) ? \"active\" : \"\",\r\n    }, react.createElement(\"a\", {\r\n        href: \"#\",\r\n        onClick: (event_2) => {\r\n            dispatch(new Msg(2, new Tab(1)));\r\n            event_2.preventDefault();\r\n            event_2.stopPropagation();\r\n        },\r\n    }, res.Poster))))), (model.Rahmenprogramm.tail == null) ? tabs_2 : append_1(tabs_2, singleton_1(react.createElement(\"li\", {\r\n        role: \"presentation\",\r\n        className: equals(model[\"Ausgewählt\"], new Tab(3)) ? \"active\" : \"\",\r\n    }, react.createElement(\"a\", {\r\n        href: \"#\",\r\n        onClick: (event_3) => {\r\n            dispatch(new Msg(2, new Tab(3)));\r\n            event_3.preventDefault();\r\n            event_3.stopPropagation();\r\n        },\r\n    }, res.Rahmenprogramm))))), model.EigenesProgramm ? append_1(tabs_3, singleton_1(react.createElement(\"li\", {\r\n        role: \"presentation\",\r\n        className: equals(model[\"Ausgewählt\"], new Tab(4)) ? \"active\" : \"\",\r\n    }, react.createElement(\"a\", {\r\n        href: \"#\",\r\n        onClick: (event_4) => {\r\n            dispatch(new Msg(2, new Tab(4)));\r\n            event_4.preventDefault();\r\n            event_4.stopPropagation();\r\n        },\r\n    }, res.EigenesProgramm)))) : tabs_3)));\r\n    const content = react.createElement(\"div\", {\r\n        ref: (_arg1_1) => {\r\n            equalHeight('#calGrid');;\r\n        },\r\n    }, (t = (matchValue = [model[\"Ausgewählt\"], model.Poster, model.Rahmenprogramm], (matchValue[0] != null) ? ((matchValue[0].tag === 1) ? Posters_render(matchValue[1], res, dispatch) : ((matchValue[0].tag === 2) ? (s_5 = matchValue[0].fields[0], Posters_render(FSharpMap__get_Item(model.TabSessions, s_5), res, dispatch)) : ((matchValue[0].tag === 3) ? Rahmenprogramm_render(matchValue[2], res, dispatch) : ((matchValue[0].tag === 4) ? EigenesProgramm_render(model.Termine, model.IstAngemeldet, model.ProfileUrl, res, dispatch) : (tag_14 = matchValue[0].fields[0], (length(tag_14[\"Räume\"]) === 1) ? TagesProgramm_render(res, model.ZeitenInOrtszeit, (arg00) => Model__IstSubscribed_2297AD2E(model, arg00), dispatch, tag_14) : TagMitR$00E4umen_render(tag_14, res, (arg00_1) => Model__IstSubscribed_2297AD2E(model, arg00_1), dispatch)))))) : Helpers_nothing), model.ZeitenInOrtszeit ? react.createElement(\"div\", {}, t, react.createElement(\"p\", {\r\n        className: \"text-center\",\r\n        style: {\r\n            marginTop: \"3em\",\r\n            fontSize: \"0.7em\",\r\n        },\r\n    }, ((res.AngabenInOrtszeit + \" (\") + currentTimeZone()) + \")\")) : t));\r\n    if ((mehrereTage ? true : hatRahmenprogramm) ? true : hatPoster) {\r\n        return ofArray([tabs_4, content]);\r\n    }\r\n    else {\r\n        return singleton_1(content);\r\n    }\r\n}\r\n\r\nexport function render(model, dispatch) {\r\n    let modalOffen;\r\n    const matchValue = [model.Session, model.Programm, model.Thema, model.Beitrag, model.RahmenprogrammPunkt];\r\n    let pattern_matching_result;\r\n    if (matchValue[0] == null) {\r\n        if (matchValue[1] == null) {\r\n            if (matchValue[2] == null) {\r\n                if (matchValue[3] == null) {\r\n                    if (matchValue[4] == null) {\r\n                        pattern_matching_result = 0;\r\n                    }\r\n                    else {\r\n                        pattern_matching_result = 1;\r\n                    }\r\n                }\r\n                else {\r\n                    pattern_matching_result = 1;\r\n                }\r\n            }\r\n            else {\r\n                pattern_matching_result = 1;\r\n            }\r\n        }\r\n        else {\r\n            pattern_matching_result = 1;\r\n        }\r\n    }\r\n    else {\r\n        pattern_matching_result = 1;\r\n    }\r\n    switch (pattern_matching_result) {\r\n        case 0: {\r\n            modalOffen = \"\";\r\n            break;\r\n        }\r\n        case 1: {\r\n            modalOffen = \"modal-open\";\r\n            break;\r\n        }\r\n    }\r\n    const res = (model.Sprache === \"Englisch\") ? Englisch : Deutsch;\r\n    const istSubscribed = (arg00) => Model__IstSubscribed_2297AD2E(model, arg00);\r\n    return react.createElement(\"div\", {\r\n        className: modalOffen,\r\n    }, ...ofSeq(delay(() => append(singleton(defaultArg(map_1((tupledArg) => {\r\n        const s = tupledArg[1];\r\n        return Session_render(tupledArg[0], s, defaultArg(tryFind(s.Id, model[\"Beiträge\"]), empty_1()), res, model.ZeitenInOrtszeit, model.EigenesProgramm, istSubscribed(s[\"Kürzel\"]), istSubscribed, dispatch);\r\n    }, model.Session), Helpers_nothing)), delay(() => append(singleton(defaultArg(map_1((tupledArg_1) => Programm_render(tupledArg_1[0], tupledArg_1[1], res, dispatch), model.Programm), Helpers_nothing)), delay(() => append(singleton(defaultArg(map_1((tupledArg_2) => Thema_render(tupledArg_2[0], tupledArg_2[1], res, dispatch), model.Thema), Helpers_nothing)), delay(() => append(singleton(defaultArg(map_1((b) => Beitrag_render(b, model.Manuskripte, res, model.ZeitenInOrtszeit, model.EigenesProgramm, istSubscribed(b.Vortragsnummer), dispatch), model.Beitrag), Helpers_nothing)), delay(() => append(singleton(defaultArg(map_1((p_1) => RahmenprogrammPunkt_render(p_1, res, dispatch), model.RahmenprogrammPunkt), Helpers_nothing)), delay(() => append(singleton(model.AnmeldungAnfordern ? AnmeldungAnfordern_render(res, model.ProfileUrl, dispatch) : Helpers_nothing), delay(() => renderProgramm(model, res, dispatch))))))))))))))));\r\n}\r\n\r\n","export function toShortTimeString(d, locale) {\r\n    return d.toLocaleTimeString(locale).replace(/:\\d\\d(?!:)/, \"\");\r\n}\r\n\r\nexport function currentTimeZone() {\r\n    return Intl.DateTimeFormat().resolvedOptions().timeZone;\r\n}","import { ProgramModule_mkProgram, ProgramModule_run } from \"./.fable/Fable.Elmish.3.1.0/program.fs.js\";\r\nimport { Program_withReactBatched } from \"./.fable/Fable.Elmish.React.3.0.1/react.fs.js\";\r\nimport { fableModule } from \"./Global.fs.js\";\r\nimport { ProgramModule_toNavigable } from \"./.fable/Fable.Elmish.Browser.3.0.4/navigation.fs.js\";\r\nimport { parseHash } from \"./.fable/Fable.Elmish.Browser.3.0.4/parser.fs.js\";\r\nimport { update, init, urlUpdate, route as route_1 } from \"./TagungsProgramm/State.fs.js\";\r\nimport { render } from \"./TagungsProgramm/View.fs.js\";\r\n\r\nProgramModule_run(Program_withReactBatched(fableModule.Platzhalter, ProgramModule_toNavigable((location) => parseHash(route_1, location), (route, model_2) => urlUpdate(route, model_2), ProgramModule_mkProgram((result) => init(result), (msg, model) => update(msg, model), (model_1, dispatch) => render(model_1, dispatch)))));\r\n\r\n"],"sourceRoot":""}