diff --git a/sources/Core/Text/Parser.uc b/sources/Core/Text/Parser.uc
new file mode 100644
index 0000000..0571b7b
--- /dev/null
+++ b/sources/Core/Text/Parser.uc
@@ -0,0 +1,1312 @@
+/**
+ * Implements a simple `Parser` with built-in functions to parse simple
+ * UnrealScript's types and support for saving / restoring parser states.
+ * Copyright 2020 Anton Tarasenko
+ *------------------------------------------------------------------------------
+ * This file is part of Acedia.
+ *
+ * Acedia is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Acedia is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Acedia. If not, see .
+ */
+class Parser extends AcediaObject
+ dependson(Text)
+ dependson(UnicodeData);
+
+var public int BYTE_MAX;
+var public int CODEPOINT_BACKSLASH;
+var public int CODEPOINT_USMALL;
+var public int CODEPOINT_ULARGE;
+
+// The sequence of Unicode code points that this `Parser` is supposed to parse.
+var private array content;
+// Incremented each time `Parser` is reinitialized with new `content`.
+// Can be used to make `Parser` object completely independent from
+// it's past, necessary since garbage collection is extra expensive in UE2
+// and we want to reuse created objects as much as possible.
+var private int version;
+
+// Describes current state of the `Parser`, instance of this struct
+// can be used to revert parser back to this state.
+struct ParserState
+{
+ // Record to which object (and of what version) this state belongs to.
+ // This information is used to make sure that we apply this state
+ // only to same `Parser` (of the same version) that it originated from.
+ var private AcediaObject ownerObject;
+ var private int ownerVersion;
+ // Has parser failed at some point?
+ var private bool failed;
+ // Points at the next symbol to be used next in parsing.
+ var private int pointer;
+};
+var private ParserState currentState;
+// For convenience `Parser` will store one internal state that designates
+// a state that's safe to revert to when some parsing attempt goes wrong.
+// @see `Confirm()`, `R()`
+var private ParserState confirmedState;
+
+// Describes rules for translating escaped sequences ("\r", "\n", "\t")
+// into appropriate code points.
+var private const array escapeCharactersMap;
+
+// Used to store a result of a `ParseSign()` function.
+enum ParsedSign
+{
+ SIGN_Missing,
+ SIGN_Plus,
+ SIGN_Minus
+};
+
+/**
+ * Initializes `Parser` with new data from a raw data
+ * (sequence of Unicode code points). Never fails.
+ *
+ * Any data from before this call is lost, any checkpoints are invalidated.
+ *
+ * @param source Sequence of Unicode code points that represents
+ * a string `Parser` will need to parse.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser InitializeRaw(array source)
+{
+ content = source;
+ version += 1;
+ currentState.ownerObject = self;
+ currentState.ownerVersion = version;
+ currentState.failed = false;
+ currentState.pointer = 0;
+ confirmedState = currentState;
+ return self;
+}
+
+/**
+ * Initializes `Parser` with new data from a `string`. Never fails.
+ *
+ * Any data from before this call is lost, any checkpoints are invalidated.
+ *
+ * @param source String `Parser` will need to parse.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser Initialize
+(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ InitializeRaw(_().text.StringToRaw(source, sourceType));
+ return self;
+}
+
+/**
+ * Initializes `Parser` with new data from a `Test`.
+ *
+ * Can fail if passed `none` as a parameter.
+ *
+ * Any data from before this call is lost, any checkpoints are invalidated.
+ *
+ * @param source `Text` object `Parser` will need to parse.
+ * If `none` is passed - parser won't be initialized.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser InitializeT(Text source)
+{
+ if (source == none) return self;
+ InitializeRaw(source.ToRaw());
+ return self;
+}
+
+/**
+ * Checks if `Parser` is in a failed state.
+ *
+ * Parser enters a failed state whenever any parsing call returns without
+ * completing it's job. `Parser` in a failed state will automatically fail
+ * any further parsing attempts until it gets reset via `R()` call.
+ *
+ * @return Returns 'false' if `Parser()` is in a failed state and
+ * `true` otherwise.
+ */
+public final function bool Ok()
+{
+ return (!currentState.failed);
+}
+
+/**
+ * Returns copy of the current state of this parser.
+ *
+ * As long as caller `Parser` was not reinitialized, returned `ParserState`
+ * structure can be used to revert this `Parser` to it's current condition
+ * by a `RestoreState()` call.
+ *
+ * @see `RestoreState()`
+ * @return Copy of the current state of the caller `Parser`.
+ */
+public final function ParserState GetCurrentState()
+{
+ return currentState;
+}
+
+/**
+ * Returns copy of (currently) last confirmed state of this parser.
+ *
+ * As long as caller `Parser` was not reinitialized, returned `ParserState`
+ * structure can be used to revert this `Parser` to it's current confirmed
+ * state by a `RestoreState()` call.
+ *
+ * @see `RestoreState()`, `Confirm()`, `R()`
+ * @return Copy of (currently) last confirmed state of this parser.
+ */
+public final function ParserState GetConfirmedState()
+{
+ return confirmedState;
+}
+
+/**
+ * Checks if given `stateToCheck` is valid for the caller `Parser`, i.e.:
+ * 1. It is a state generated by either `GetCurrentState()` or
+ * `GetConfirmedState()` calls on the caller `Parser`.
+ * 2. Caller `Parser` was not reinitialized since a call
+ * that generated given `stateToCheck`.
+ *
+ * @param stateToCheck `ParserState` to check for validity for
+ * caller `Parser`.
+ * @return `true` if given `stateToCheck` is valid and `false` otherwise.
+ */
+public final function bool IsStateValid(ParserState stateToCheck)
+{
+ if (stateToCheck.ownerObject != self) return false;
+ if (stateToCheck.ownerVersion != version) return false;
+ return true;
+}
+
+/**
+ * Checks if calling `RestoreState()` for passed state will return a `Parser`
+ * in an "Ok" state (not failed), i.e. state is valid and
+ * was generated when `Parser` was in a non-failed state.
+ *
+ * @param stateToCheck `ParserState` to check for corresponding to
+ * `Parser` being in a non-failed state.
+ * By definition must also be valid for the caller `Parser`.
+ * @return `true` if given `stateToCheck` is valid and `false` otherwise.
+ */
+public final function bool IsStateOk(ParserState stateToCheck)
+{
+ if (!IsStateValid(stateToCheck)) return false;
+ return (!stateToCheck.failed);
+}
+
+/**
+ * Resets parser to a state, given by `stateToRestore` argument
+ * (so a state `Parser` was in at the moment given `stateToRestore`
+ * was obtained).
+ *
+ * If given `stateToRestore` is from a different `Parser` or
+ * the owner `Parser` was reinitialized after passed state was obtained, -
+ * function will simply put caller `Parser` into a failed state.
+ * Note that caller `Parser` being put in a failed state after this call
+ * doesn't mean that described issues are actually present:
+ * `stateToRestore` can also describe a failed state of the `Parser`.
+ *
+ * @param stateToRestore `ParserState` that this method will attempt
+ * to set for the caller `Parser`.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser RestoreState(ParserState stateToRestore)
+{
+ if (!IsStateValid(stateToRestore))
+ {
+ currentState.failed = true;
+ return self;
+ }
+ currentState = stateToRestore;
+ return self;
+}
+
+ /**
+ * Remembers current state of `Parser` in an internal checkpoint variable,
+ * that can later be restored by an `R()` call.
+ *
+ * Can only save non-failed states and will only fail if caller `Parser` is
+ * in a failed state.
+ *
+ * `Confirm()` and `R()` are essentially convenience wrapper functions for
+ * `GetCurrentState()` and `RestoreState()` calls +
+ * state storage variable.
+ *
+ * @return `true` if current state is recorded in `Parser` as confirmed and
+ * `false` otherwise.
+ */
+public final function bool Confirm()
+{
+ if (!Ok()) return false;
+
+ confirmedState = currentState;
+ return true;
+}
+
+/**
+ * Resets `Parser` to a last state recorded as confirmed by a last successful
+ * `Confirm()` function call. If there weren't any such call -
+ * reverts `Parser` to it's state right after initialization.
+ *
+ * Always resets failed state of a `Parser`. Cannot fail.
+ *
+ * `Confirm()` and `R()` are essentially convenience wrapper functions for
+ * `GetCurrentState()` and `RestoreState()` calls + state storage variable.
+ *
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser R()
+{
+ currentState = confirmedState;
+ return self;
+}
+
+/**
+ * Shifts parsing pointer forward.
+ *
+ * Can only shift forward. To revert to a previous state in case of failure use
+ * combination of `GetCurrentState()` and `RestoreState()` functions.
+ *
+ * @param shift How much to shift parsing pointer?
+ * Values of zero and below are discarded and `1` is used instead
+ * (i.e. by default this method shifts pointer by `1` position).
+ * @return Returns the calling object, to allow for function chaining.
+ */
+protected final function Parser ShiftPointer(optional int shift)
+{
+ shift = Max(1, shift);
+ currentState.pointer = Min(currentState.pointer + shift, content.length);
+ return self;
+}
+
+/**
+ * Returns a code point from this `Parser`'s content, relative to next
+ * code point that caller `Parser` must handle.
+ *
+ * @param `shift` If `0` (default value) or negative value is passed -
+ * simply asks for the code point that caller `Parser` must handle.
+ * Otherwise shifts that index `shift` code points, i.e.
+ * `1` to return next code point or `2` to return code point after
+ * the next one.
+ * @return Returns code point at a given shift. If `shift` is too small/large
+ * and does not fit `Parser`'s contents, returns `-1`.
+ * `GetCodePoint()` with default (`0`) parameter can also return `-1` if
+ * contents of the caller `Parser` are empty or it has already consumed
+ * all input.
+ */
+protected final function Text.Character GetCharacter(optional int shift)
+{
+ local Text.Character invalidCharacter;
+ local int absoluteAddress;
+ absoluteAddress = currentState.pointer + Max(0, shift);
+ if (absoluteAddress < 0 || absoluteAddress >= content.length)
+ {
+ invalidCharacter.codePoint = -1;
+ return invalidCharacter;
+ }
+ return content[absoluteAddress];
+}
+
+/**
+ * Forces caller `Parser` to enter a failed state.
+ *
+ * @return Returns the calling object, to allow for a quick exit from
+ * a parsing function by `return Fail();`.
+ */
+protected final function Parser Fail()
+{
+ currentState.failed = true;
+ return self;
+}
+
+/**
+ * Returns amount of code points that have already been parsed,
+ * provided that caller `Parser` is in a correct state.
+ *
+ * @return Returns how many Unicode code points have already been parsed if
+ * caller `Parser` is in correct state;
+ * otherwise return value is undefined.
+ */
+public final function int GetParsedLength()
+{
+ return Max(0, currentState.pointer);
+}
+
+/**
+ * Returns amount of code points that have not yet been parsed,
+ * provided that caller `Parser` is in a correct state.
+ *
+ * @return Returns how many Unicode code points are still unparsed if
+ * caller `Parser` is in correct state;
+ * otherwise return value is undefined.
+ */
+public final function int GetRemainingLength()
+{
+ return Max(0, content.length - currentState.pointer);
+}
+
+/**
+ * Checks if caller `Parser` has already parsed all of it's content.
+ * Uninitialized `Parser` has no content and, therefore, parsed it all.
+ *
+ * Should return `true` iff `GetRemainingLength() == 0`.
+ *
+ * @return `true` if caller `Parser` has no more data to parse.
+ */
+public final function bool HasFinished()
+{
+ return (currentState.pointer >= content.length);
+}
+
+/**
+ * Returns still unparsed part of caller `Parser`'s source as an array of
+ * Unicode code points.
+ *
+ * @return Unparsed part of caller `Parser`'s source as an array of
+ * Unicode code points.
+ */
+public final function array GetRemainderRaw()
+{
+ local int i;
+ local array result;
+ for (i = 0; i < GetRemainingLength(); i += 1)
+ {
+ result[result.length] = GetCharacter(i);
+ }
+ return result;
+}
+
+/**
+ * Returns still unparsed part of caller `Parser`'s source as a `string`.
+ *
+ * @return Unparsed part of caller `Parser`'s source as a `string`.
+ */
+public final function string GetRemainder()
+{
+ local int i;
+ local array rawResult;
+ for (i = 0; i < GetRemainingLength(); i += 1)
+ {
+ rawResult[rawResult.length] = GetCharacter(i);
+ }
+ return _().text.RawToString(rawResult, STRING_Plain);
+}
+
+/**
+ * Returns still unparsed part of caller `Parser`'s source as `Text`.
+ *
+ * @return Unparsed part of caller `Parser`'s source as `Text`.
+ */
+public final function Text GetRemainderT()
+{
+ local int i;
+ local array rawResult;
+ for (i = 0; i < GetRemainingLength(); i += 1)
+ {
+ rawResult[rawResult.length] = GetCharacter(i);
+ }
+ return _().text.FromRaw(rawResult);
+}
+
+/**
+ * Matches any sequence of whitespace symbols, without returning it.
+ * Starts from where previous parsing function finished.
+ *
+ * Can never cause parser to enter failed state.
+ *
+ * What symbols exactly are considered whitespace refer to the description of
+ * `TextAPI.IsWhitespace()` function.
+ *
+ * @param whitespacesAmount Returns how many whitespace symbols
+ * were skipped. Any given value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser Skip(optional out int whitespacesAmount)
+{
+ local TextAPI api;
+ if (!Ok()) return self;
+
+ api = _().text;
+ whitespacesAmount = 0;
+ // Cycle will end once we either reach a non-whitespace symbol or
+ // there's not more code points to get
+ while (api.IsWhitespace(GetCharacter(whitespacesAmount)))
+ {
+ whitespacesAmount += 1;
+ }
+ ShiftPointer(whitespacesAmount);
+ return self;
+}
+
+/**
+ * Function that tries to match given data in `Parser`'s content,
+ * starting from where previous parsing function finished.
+ *
+ * Does nothing if caller `Parser` was in failed state.
+ *
+ * @param data Data that must be matched to the `Parser`'s
+ * contents, starting from where previous parsing function finished.
+ * @param caseInsensitive If `false` the matching will have to be exact,
+ * using `true` will make this method to ignore the case,
+ * where it's applicable.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MatchRaw
+(
+ array data,
+ optional bool caseInsensitive
+)
+{
+ local int i;
+ local TextAPI api;
+ if (!Ok()) return self;
+ if (data.length > GetRemainingLength()) return Fail();
+
+ api = _().text;
+ for (i = 0; i < data.length; i += 1)
+ {
+ if (!api.AreEqual(data[i], GetCharacter(i), caseInsensitive))
+ {
+ return Fail();
+ }
+ }
+ ShiftPointer(data.length);
+ return self;
+}
+
+/**
+ * Function that tries to match given `string`, starting from where
+ * previous parsing function finished.
+ *
+ * Does nothing if caller `Parser` was in failed state.
+ *
+ * @param word String that must be matched to the `Parser`'s
+ * contents, starting from where previous parsing function finished.
+ * @param caseInsensitive If `false` the matching will have to be exact,
+ * using `true` will make this method to ignore the case,
+ * where it's applicable.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser Match(string word, optional bool caseInsensitive)
+{
+ return MatchRaw(_().text.StringToRaw(word), caseInsensitive);
+}
+
+/**
+ * Function that tries to match given `Text`, starting from where
+ * previous parsing function finished.
+ *
+ * Does nothing if caller `Parser` was in failed state.
+ *
+ * @param word Text that must be matched to the `Parser`'s
+ * contents, starting from where previous parsing function finished.
+ * @param caseInsensitive If `false` the matching will have to be exact,
+ * using `true` will make this method to ignore the case,
+ * where it's applicable.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MatchT(Text word, optional bool caseInsensitive)
+{
+ if (!Ok()) return self;
+ if (word == none) return Fail();
+
+ return MatchRaw(word.ToRaw(), caseInsensitive);
+}
+
+/**
+ * Internal function for parsing unsigned integers in any base from 2 to 36.
+ *
+ * This parsing can fail, putting `Parser` into a failed state.
+ *
+ * @param result If parsing is successful, this value will contain
+ * parsed integer, otherwise value is undefined.
+ * Any passed value is discarded.
+ * @param base Base, in which integer in question is recorded.
+ * @param numberLength If this parameter is less or equal to zero,
+ * function will stop parsing the moment it can't recognize a character as
+ * belonging to a number in a given base.
+ * It will only fail if it couldn't parse a single character;
+ * If this parameter is set to be positive (`> 0`), function will
+ * attempt to use exactly `numberLength` character for parsing and will
+ * fail if they would not constitute a valid number.
+ * @param consumedCodePoints Amount of code point used (consumed) to parse
+ * this number; undefined, if parsing is unsuccessful.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MUnsignedInteger
+(
+ out int result,
+ optional int base,
+ optional int numberLength,
+ optional out int consumedCodePoints
+)
+{
+ local bool parsingFixedLength;
+ local int nextPosition;
+ numberLength = Max(0, numberLength);
+ parsingFixedLength = (numberLength != 0);
+ if (base == 0)
+ {
+ base = 10;
+ }
+ else if (base < 2 || base > 36)
+ {
+ return Fail();
+ }
+ result = 0;
+ consumedCodePoints = 0;
+ while (!HasFinished())
+ {
+ if (parsingFixedLength && consumedCodePoints >= numberLength) break;
+ nextPosition = _().text.CharacterToInt(GetCharacter(), base);
+ if (nextPosition < 0) break;
+
+ result = result * base + nextPosition;
+ consumedCodePoints += 1;
+ ShiftPointer();
+ }
+ if ( parsingFixedLength && consumedCodePoints != numberLength
+ || consumedCodePoints < 1)
+ {
+ return Fail();
+ }
+ return self;
+}
+
+/**
+ * Parses escaped sequence of the type that is usually used in
+ * string literals: backslash "\"", followed by any character
+ * (called escaped character later) or, in special cases, several characters.
+ * For most characters escaped sequence resolved into
+ * an escaped character's code point.
+ *
+ * Several escaped symbols:
+ * \n, \r, \t, \b, \f, \v
+ * are translated into a different code point corresponding to
+ * a control symbols, normally denoted by these sequences.
+ *
+ * A Unicode code point can also be directly entered with either of the two
+ * commands:
+ * \U0056
+ * \u56
+ * The difference is that `\U` allows you to enter two-byte code point, while
+ * `\u` only allows to define code points that fit into 1 byte,
+ * but is more compact.
+ *
+ * @param denotedCodePoint If parsing is successful, parameter will contain
+ * appropriate code point, denoted by a parsed escaped sequence;
+ * If parsing is unsuccessful, value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MEscapedSequence
+(
+ out Text.Character denotedCharacter
+)
+{
+ local int i;
+ if (!Ok()) return self;
+ // Need at least two characters to parse escaped sequence
+ if (GetRemainingLength() < 2) return Fail();
+ if (GetCharacter().codePoint != CODEPOINT_BACKSLASH) return Fail();
+
+ denotedCharacter = GetCharacter(1);
+ ShiftPointer(2);
+ // Escaped character denotes some special code point
+ for (i = 0; i < escapeCharactersMap.length; i += 1)
+ {
+ if (escapeCharactersMap[i].from == denotedCharacter.codePoint)
+ {
+ denotedCharacter.codePoint = escapeCharactersMap[i].to;
+ return self;
+ }
+ }
+ // Escaped character denotes declaration of arbitrary Unicode code point
+ if (denotedCharacter.codePoint == CODEPOINT_ULARGE)
+ {
+ MUnsignedInteger(denotedCharacter.codePoint, 16, 4);
+ }
+ else if (denotedCharacter.codePoint == CODEPOINT_USMALL)
+ {
+ MUnsignedInteger(denotedCharacter.codePoint, 16, 2);
+ }
+ return self;
+}
+
+/**
+ * Attempts to parse a string literal: a string enclosed in either of
+ * the following quotation marks: ", ', `.
+ * String literals can contain escaped sequences.
+ * String literals MUST end with closing quotation mark.
+ * @see `MEscapedSequence()`
+ *
+ * @param result If parsing is successful, this array will contain the
+ * contents of string literal with resolved escaped sequences;
+ * if parsing has failed, it's value is undefined.
+ * Any passed contents are simply discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MStringLiteralRaw(out array result)
+{
+ local TextAPI api;
+ local Text.Character nextCharacter;
+ local Text.Character usedQuotationMark;
+ local Text.Character escapedCharacter;
+ if (!Ok()) return self;
+ usedQuotationMark = GetCharacter();
+ if (!_().text.IsQuotationMark(usedQuotationMark)) return Fail();
+
+ ShiftPointer(); // Skip opening quotation mark
+ api = _().text;
+ result.length = 0;
+ while (!HasFinished())
+ {
+ nextCharacter = GetCharacter();
+ // Closing quote
+ if (api.AreEqual(nextCharacter, usedQuotationMark))
+ {
+ ShiftPointer();
+ return self;
+ }
+ // Escaped characters
+ if (api.IsCodePoint(nextCharacter, CODEPOINT_BACKSLASH))
+ {
+ if (!MEscapedSequence(escapedCharacter).Ok())
+ {
+ return Fail(); // Backslash MUST mean valid escape sequence
+ }
+ result[result.length] = escapedCharacter;
+ }
+ // Any other code point
+ else
+ {
+ result[result.length] = nextCharacter;
+ ShiftPointer();
+ }
+ }
+ // Content ended without a closing quote.
+ return Fail();
+}
+
+/**
+ * Attempts to parse a string literal: a string enclosed in either of
+ * the following quotation marks: ", ', `.
+ * String literals can contain escaped sequences.
+ * String literals MUST end with closing quotation mark.
+ * @see `MEscapedSequence()`
+ *
+ * @param result If parsing is successful, this `string` will contain the
+ * contents of string literal with resolved escaped sequences;
+ * if parsing has failed, it's value is undefined.
+ * Any passed contents are simply discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MStringLiteral(out string result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ if (MStringLiteralRaw(rawResult).Ok())
+ {
+ result = _().text.RawToString(rawResult, STRING_Plain);
+ }
+ return self;
+}
+
+/**
+ * Attempts to parse a string literal: a string enclosed in either of
+ * the following quotation marks: ", ', `.
+ * String literals can contain escaped sequences.
+ * String literals MUST end with closing quotation mark.
+ * @see `MEscapedSequence()`
+ *
+ * @param result If parsing is successful, this `Text` will contain the
+ * contents of string literal with resolved escaped sequences;
+ * if parsing has failed, it's value is undefined.
+ * Any passed contents are simply discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MStringLiteralT(out Text result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ if (MStringLiteralRaw(rawResult).Ok())
+ {
+ result = _().text.FromRaw(rawResult);
+ }
+ return self;
+}
+
+/**
+ * Matches everything until it finds one of the breaking symbols:
+ * 1. a specified code point (by default `0`);
+ * 2. (optionally) whitespace symbol (@see `TextAPI.IsWhitespace()`);
+ * 3. (optionally) quotation symbol (@see `TextAPI.IsQuotation()`).
+ * This method cannot fail.
+ *
+ * @param result Any content before one of the break symbols
+ * will be recorded into this array as a sequence of Unicode code points.
+ * @param codePointBreak Method will stop parsing upon encountering this
+ * code point (it will not be included in the `result`)
+ * @param whitespacesBreak `true` if you want to also treat any
+ * whitespace character as a break symbol
+ * (@see `TextAPI.IsWhitespace()` for what symbols are
+ * considered whitespaces)
+ * @param quotesBreak `true` if you want to also treat any
+ * quotation mark character as a break symbol
+ * (@see `TextAPI.IsQuotation()` for what symbols are
+ * considered quotation marks).
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MUntilRaw
+(
+ out array result,
+ optional Text.Character characterBreak,
+ optional bool whitespacesBreak,
+ optional bool quotesBreak
+)
+{
+ local Text.Character nextCharacter;
+ local TextAPI api;
+ if (!Ok()) return self;
+
+ api = _().text;
+ result.length = 0;
+ while (!HasFinished())
+ {
+ nextCharacter = GetCharacter();
+ if (api.AreEqual(nextCharacter, characterBreak)) break;
+ if (whitespacesBreak && api.IsWhitespace(nextCharacter)) break;
+ if (quotesBreak && api.IsQuotationMark(nextCharacter)) break;
+
+ result[result.length] = nextCharacter;
+ ShiftPointer();
+ }
+ return self;
+}
+
+/**
+ * Matches everything until it finds one of the breaking symbols:
+ * 1. a specified code point (by default `0`);
+ * 2. (optionally) whitespace symbol (@see `TextAPI.IsWhitespace()`);
+ * 3. (optionally) quotation symbol (@see `TextAPI.IsQuotation()`).
+ * This method cannot fail.
+ *
+ * @param result Any content before one of the break symbols
+ * will be recorded into this `string`.
+ * @param codePointBreak Method will stop parsing upon encountering this
+ * code point (it will not be included in the `result`)
+ * @param whitespacesBreak `true` if you want to also treat any
+ * whitespace character as a break symbol
+ * (@see `TextAPI.IsWhitespace()` for what symbols are
+ * considered whitespaces)
+ * @param quotesBreak `true` if you want to also treat any
+ * quotation mark character as a break symbol
+ * (@see `TextAPI.IsQuotation()` for what symbols are
+ * considered quotation marks).
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MUntil
+(
+ out string result,
+ optional Text.Character characterBreak,
+ optional bool whitespacesBreak,
+ optional bool quotesBreak
+)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MUntilRaw(rawResult, characterBreak, whitespacesBreak, quotesBreak);
+ result = _().text.RawToString(rawResult, STRING_Plain);
+ return self;
+}
+
+/**
+ * Matches everything until it finds one of the breaking symbols:
+ * 1. a specified code point (by default `0`);
+ * 2. (optionally) whitespace symbol (@see `TextAPI.IsWhitespace()`);
+ * 3. (optionally) quotation symbol (@see `TextAPI.IsQuotation()`).
+ * This method cannot fail.
+ *
+ * @param result Any content before one of the break symbols
+ * will be recorded into this `Text`.
+ * @param codePointBreak Method will stop parsing upon encountering this
+ * code point (it will not be included in the `result`)
+ * @param whitespacesBreak `true` if you want to also treat any
+ * whitespace character as a break symbol
+ * (@see `TextAPI.IsWhitespace()` for what symbols are
+ * considered whitespaces)
+ * @param quotesBreak `true` if you want to also treat any
+ * quotation mark character as a break symbol
+ * (@see `TextAPI.IsQuotation()` for what symbols are
+ * considered quotation marks).
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MUntilT
+(
+ out Text result,
+ optional Text.Character characterBreak,
+ optional bool whitespacesBreak,
+ optional bool quotesBreak
+)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MUntilRaw(rawResult, characterBreak, whitespacesBreak, quotesBreak);
+ result = _().text.FromRaw(rawResult);
+ return self;
+}
+
+/**
+ * Parses a string as either "simple" or "quoted".
+ * Not being able to read any symbols is not considered a failure.
+ *
+ * Reading empty string (either to lack of further data or
+ * instantly encountering a break symbol) is not considered a failure.
+ *
+ * Quoted string starts with quotation mark and ends either
+ * at the corresponding closing (un-escaped) mark
+ * or when `Parser`'s input has been fully consumed.
+ * If string started with a quotation mark, this method will act exactly
+ * like `MStringLiteralRaw()`.
+ *
+ * @param result If parsing is successful - string's contents will be
+ * recorded here; if parsing has failed - value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MStringRaw(out array result)
+{
+ if (!Ok()) return self;
+
+ if (_().text.IsQuotationMark(GetCharacter()))
+ {
+ MStringLiteralRaw(result);
+ }
+ else
+ {
+ MUntilRaw(result,, true, true);
+ }
+ return self;
+}
+
+/**
+ * Parses a string as either "simple" or "quoted".
+ * Not being able to read any symbols is not considered a failure.
+ *
+ * Reading empty string (either to lack of further data or
+ * instantly encountering a break symbol) is not considered a failure.
+ *
+ * Quoted string starts with quotation mark and ends either
+ * at the corresponding closing (un-escaped) mark
+ * or when `Parser`'s input has been fully consumed.
+ * If string started with a quotation mark, this method will act exactly
+ * like `MStringLiteral()`.
+ *
+ * @param result If parsing is successful - string's contents will be
+ * recorded here; if parsing has failed - value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MString(out string result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MStringRaw(rawResult);
+ result = _().text.RawToString(rawResult, STRING_Plain);
+ return self;
+}
+
+/**
+ * Parses a string as either "simple" or "quoted".
+ * Not being able to read any symbols is not considered a failure.
+ *
+ * Reading empty string (either to lack of further data or
+ * instantly encountering a break symbol) is not considered a failure.
+ *
+ * Quoted string starts with quotation mark and ends either
+ * at the corresponding closing (un-escaped) mark
+ * or when `Parser`'s input has been fully consumed.
+ * If string started with a quotation mark, this method will act exactly
+ * like `MStringLiteralT()`.
+ *
+ * @param result If parsing is successful - string's contents will be
+ * recorded here; if parsing has failed - value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MStringT(out Text result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MStringRaw(rawResult);
+ result = _().text.FromRaw(rawResult);
+ return self;
+}
+
+/**
+ * Matches a non-empty sequence of whitespace symbols.
+ *
+ * Cannot fail (not being able to read any input is not considered a failure).
+ *
+ * @param result If parsing was successful - whitespaces' Unicode code points
+ * will be recorded in this array, otherwise - undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MWhitespacesRaw(out array result)
+{
+ local Text.Character nextCharacter;
+ local TextAPI api;
+ if (!Ok()) return self;
+
+ api = _().text;
+ result.length = 0;
+ while (!HasFinished())
+ {
+ nextCharacter = GetCharacter();
+ if (!api.IsWhitespace(nextCharacter)) break;
+ result[result.length] = nextCharacter;
+ ShiftPointer();
+ }
+ return self;
+}
+
+/**
+ * Matches a non-empty sequence of whitespace symbols.
+ *
+ * Cannot fail (not being able to read any input is not considered a failure).
+ *
+ * @param result If parsing was successful - whitespaces will be
+ * recorded here, otherwise - undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MWhitespaces(out string result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MWhitespacesRaw(rawResult);
+ result = _().text.RawToString(rawResult, STRING_Plain);
+ return self;
+}
+
+/**
+ * Matches a non-empty sequence of whitespace symbols.
+ *
+ * Cannot fail (not being able to read any input is not considered a failure).
+ *
+ * @param result If parsing was successful - whitespaces will be
+ * recorded here, otherwise - undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MWhitespacesT(out Text result)
+{
+ local array rawResult;
+ if (!Ok()) return self;
+
+ MWhitespacesRaw(rawResult);
+ result = _().text.FromRaw(rawResult);
+ return self;
+}
+
+/**
+ * Parses next code point as itself.
+ *
+ * Can only fail if caller `Parser` has already exhausted all available data.
+ *
+ * @param result If parsing was successful - next Unicode code point,
+ * otherwise - value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MCharacter(out Text.Character result)
+{
+ if (!Ok()) return self;
+ if (HasFinished()) return Fail();
+
+ result = GetCharacter();
+ ShiftPointer();
+ return self;
+}
+
+/**
+ * Parses next code point as as byte.
+ * Can fail if caller `Parser` has already exhausted all available data or
+ * next Unicode code point cannot fit into the `byte` value range.
+ *
+ * @param result If parsing was successful - next Unicode code point as
+ * a byte, otherwise - value is undefined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MByte(out byte result)
+{
+ local Text.Character character;
+ if (!Ok()) return self;
+
+ if (!MCharacter(character).Ok())
+ {
+ return Fail();
+ }
+ if (character.codePoint < 0 || character.codePoint > BYTE_MAX)
+ {
+ return Fail();
+ }
+ result = character.codePoint;
+ return self;
+}
+
+/**
+ * Tries to parse a sign: either "+" or "-".
+ *
+ * @param result Value of `ParsedSign` will be recorded here,
+ * depending on what sign was encountered.
+ * `SIGN_Missing` value is only possible if we allow sign to be missing.
+ * @param allowMissingSign By default `false` means that parsing will fail
+ * if next character is neither "+" or "-";
+ * `true` means that parsing will not fail even if there is not sign, -
+ * method will then consume in input and will return `SIGN_Missing`
+ * as a result.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MSign
+(
+ out ParsedSign result,
+ optional bool allowMissingSign
+)
+{
+ local ParserState checkpoint;
+ if (!Ok()) return self;
+
+ // Read sign
+ checkpoint = GetCurrentState();
+ if (Match("-").Ok())
+ {
+ result = SIGN_Minus;
+ }
+ else if (RestoreState(checkpoint).Match("+").Ok())
+ {
+ result = SIGN_Plus;
+ }
+ else if (allowMissingSign)
+ {
+ result = SIGN_Missing;
+ RestoreState(checkpoint);
+ }
+ return self;
+}
+
+/**
+ * Tries to parse a number prefix that determines a base system for denoting
+ * integer numbers:
+ * 1. `0x` means hexadecimal;
+ * 2. `0b` means binary;
+ * 3. `0o` means octal;
+ * 4. otherwise we use decimal system.
+ *
+ * This parsing method cannot fail.
+ *
+ * Parser consumes appropriate prefix; nothing if decimal system is determined.
+ *
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MBase(out int base)
+{
+ local ParserState checkpoint;
+ if (!Ok()) return self;
+
+ checkpoint = GetCurrentState();
+ if (Match("0x").Ok())
+ {
+ base = 16;
+ }
+ else if (RestoreState(checkpoint).Match("0b").Ok())
+ {
+ base = 2;
+ }
+ else if (RestoreState(checkpoint).Match("0o").Ok())
+ {
+ base = 8;
+ }
+ else
+ {
+ RestoreState(checkpoint);
+ base = 10;
+ }
+ return self;
+}
+
+/**
+ * Parses signed integer either in a directly given base (`base`) or in an
+ * auto-determined one (based on prefix, @see `MBase()`).
+ *
+ * Integers are expected in form: (+/-)(0x/0b/0o).
+ * Examples: 78, 0o34, -2, 0b0101001, -0x78aC.
+ *
+ * @param result If parsing is successful - parsed value will be
+ * recorded here; if parsing fails - value is undetermined.
+ * Any passed value is discarded.
+ * @param base base in which function must attempt to parse a number;
+ * Default value (`0`) means function must auto-determine base,
+ * based on the prefix, otherwise must be between 2 and 36.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MInteger(out int result, optional int base)
+{
+ local ParsedSign integerSign;
+ if (!Ok()) return self;
+
+ MSign(integerSign, true);
+ if (base == 0)
+ {
+ MBase(base);
+ }
+ MUnsignedInteger(result, base);
+ if (integerSign == SIGN_Minus)
+ {
+ result *= -1;
+ }
+ return self;
+}
+
+// Internal function for parsing fractional part (including the dot ".")
+// of the text representation for floating point number (decimal system only).
+// Cannot fail, returns `0.0` if it couldn't parse anything.
+protected final function Parser MFractionalPart(out float result)
+{
+ local ParserState checkpoint;
+ local int fractionalInt;
+ local int digitsRead;
+ if (!Ok()) return self;
+
+ result = 0.0;
+ checkpoint = GetCurrentState();
+ if (!Match(".").Ok())
+ {
+ RestoreState(checkpoint);
+ return self;
+ }
+ checkpoint = GetCurrentState();
+ if (!MUnsignedInteger(fractionalInt,,, digitsRead).Ok())
+ {
+ fractionalInt = 0.0;
+ RestoreState(checkpoint);
+ return self;
+ }
+ result = float(fractionalInt) * (0.1 ** digitsRead);
+ return self;
+}
+
+// Internal function for parsing exponent part (including the symbol "e")
+// of the text representation for floating point number (decimal system only).
+// Can only fail if symbol "e" / "E" is present, but there is no valid
+// integer right after it (whitespace symbols in-between are forbidden).
+// Returns `0.0` if there was not exponent to parse.
+protected final function Parser MExponentPart(out int result)
+{
+ local ParserState checkpoint;
+ local ParsedSign exponendSign;
+ if (!Ok()) return self;
+
+ // Is there even an exponential part?
+ checkpoint = GetCurrentState();
+ if (!Match("e", true).Ok())
+ {
+ RestoreState(checkpoint);
+ return self;
+ }
+ // If yes - parse it:
+ result = 0.0;
+ MSign(exponendSign, true).MUnsignedInteger(result, 10);
+ if (exponendSign == SIGN_Minus)
+ {
+ result *= -1;
+ }
+ return self;
+}
+
+// Internal function for parsing optional suffix of the text representation
+// for floating point number ("f" or "F").
+// Cannot fail. Can only consume one Unicode code point,
+// when it is either "f" or "F".
+protected final function Parser MFloatSuffix()
+{
+ local ParserState checkpoint;
+ if (!Ok()) return self;
+
+ checkpoint = GetCurrentState();
+ if (!Match("f", true).Ok())
+ {
+ RestoreState(checkpoint);
+ }
+ return self;
+}
+
+/**
+ * Parses signed floating point number in JSON form + optional "f" / "F"
+ * suffix at the end.
+ *
+ * @param result If parsing is successful - parsed value will be
+ * recorded here; if parsing fails - value is undetermined.
+ * Any passed value is discarded.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Parser MNumber(out float result)
+{
+ local ParsedSign sign;
+ local int integerPart, exponentPart;
+ local float fractionalPart;
+ if (!Ok()) return self;
+
+ self.MSign(sign, true)
+ .MUnsignedInteger(integerPart, 10)
+ .MFractionalPart(fractionalPart)
+ .MExponentPart(exponentPart)
+ .MFloatSuffix();
+ if (!Ok())
+ {
+ return self;
+ }
+ result = float(integerPart) + fractionalPart;
+ result *= 10.0 ** exponentPart;
+ if (sign == SIGN_Minus)
+ {
+ result *= -1;
+ }
+ return self;
+}
+
+defaultproperties
+{
+ // Start with no initializations done
+ version = 0
+ BYTE_MAX = 255
+ CODEPOINT_BACKSLASH = 92 // \
+ CODEPOINT_USMALL = 117 // u
+ CODEPOINT_ULARGE = 85 // U
+ escapeCharactersMap(0)=(from=110,to=10) // \n
+ escapeCharactersMap(1)=(from=114,to=13) // \r
+ escapeCharactersMap(2)=(from=116,to=9) // \t
+ escapeCharactersMap(3)=(from=98,to=8) // \b
+ escapeCharactersMap(4)=(from=102,to=12) // \f
+ escapeCharactersMap(5)=(from=118,to=11) // \v
+}
\ No newline at end of file
diff --git a/sources/Core/Text/Tests/TEST_Parser.uc b/sources/Core/Text/Tests/TEST_Parser.uc
new file mode 100644
index 0000000..a6f0cab
Binary files /dev/null and b/sources/Core/Text/Tests/TEST_Parser.uc differ
diff --git a/sources/Core/Text/Tests/TEST_Text.uc b/sources/Core/Text/Tests/TEST_Text.uc
new file mode 100644
index 0000000..acb11cf
Binary files /dev/null and b/sources/Core/Text/Tests/TEST_Text.uc differ
diff --git a/sources/Core/Text/Tests/TEST_TextAPI.uc b/sources/Core/Text/Tests/TEST_TextAPI.uc
new file mode 100644
index 0000000..51aece9
Binary files /dev/null and b/sources/Core/Text/Tests/TEST_TextAPI.uc differ
diff --git a/sources/Core/Text/Text.uc b/sources/Core/Text/Text.uc
new file mode 100644
index 0000000..a8d6e27
--- /dev/null
+++ b/sources/Core/Text/Text.uc
@@ -0,0 +1,290 @@
+/**
+ * Text object, meant as Acedia's replacement for a `string` type,
+ * that is supposed to provide a better (although by no means full)
+ * Unicode support than what is available from built-in unrealscript functions.
+ * Main differences with `string` are:
+ * 1. Text is a reference type, that doesn't copy it's contents with each
+ * assignment.
+ * 2. It's functions such as `ToUpper()` work with larger sets of
+ * symbols than native functions such as `Caps()` that only work with
+ * ASCII Latin;
+ * 3. Can store a wider range of characters than `string`, although
+ * the only way to actually add them to `Text` is via directly
+ * inputting Unicode code points.
+ * 4. Since it's functionality implemented in unrealscript,
+ * Text is slower that a string;
+ * 5. Once created, Text object won't disappear until garbage collection
+ * is performed, even if it is not referenced anywhere.
+
+ * API that provides extended text handling with extended Cyrillic (Russian)
+ * support (native functions like `Caps` only work with Latin letters).
+ * Copyright 2020 Anton Tarasenko
+ *------------------------------------------------------------------------------
+ * This file is part of Acedia.
+ *
+ * Acedia is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Acedia is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Acedia. If not, see .
+ */
+class Text extends AcediaObject;
+
+// Used to store a result of a `ParseSign()` function.
+enum StringType
+{
+ STRING_Plain,
+ STRING_Colored,
+ STRING_Formatted
+};
+
+enum LetterCase
+{
+ LCASE_Lower,
+ LCASE_Upper
+};
+
+enum StringColorType
+{
+ STRCOLOR_Default,
+ STRCOLOR_Struct,
+ STRCOLOR_Alias
+};
+
+struct Character
+{
+ var int codePoint;
+ // `false` if relevant character has a particular color,
+ // `true` if it does not (use context-dependent default color).
+ var StringColorType colorType;
+ // Color of the relevant character if `isDefaultColor == false`.
+ var Color color;
+ var string colorAlias;
+};
+// We will store our string data in two different ways at once to make getters
+// faster at the cost of doing more work in functions that change the string.
+var private array contents;
+
+/**
+ * Sets new value of the `Text` object, that has called this method,
+ * to be equal to the given `Text`. Does not change given `Text`.
+ *
+ * @param source After this function caller `Text` will have exactly
+ * the same contents as given parameter.
+ * @return Returns the calling `Text` object, to allow for function chaining.
+ */
+public final function Text Copy(Text otherText)
+{
+ contents = otherText.contents;
+ return self;
+}
+
+/**
+ * Replaces data of caller `Text` object with data given by the array of
+ * Unicode code points, preserving the order of characters where it matters
+ * (some modifier code points are allowed arbitrary order in Unicode standard).
+ *
+ * `Text` isn't a simple wrapper around array of Unicode code points, so
+ * this function call should be assumed to be more expensive than
+ * a simple copy.
+ *
+ * @param source New contents of the `Text`.
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Text CopyRaw(array rawSource)
+{
+ contents = rawSource;
+ return self;
+}
+
+/**
+ * Copies contents of the given string into caller `Text`.
+ *
+ * `Text` isn't a simple wrapper around unrealscript's `string`, so
+ * this function call should be assumed to be more expensive than simple
+ * `string` copy.
+ *
+ * @param source New contents of the caller `Text`.
+ * @return Returns the calling `Text` object, to allow for function chaining.
+ */
+public final function Text CopyString(string source)
+{
+ CopyRaw(_().text.StringToRaw(source));
+ return self;
+}
+
+/**
+ * Returns data in the caller `Text` object in form of an array of
+ * Unicode code points, preserving the order of characters where it matters
+ * (some modifier code points are allowed arbitrary order in Unicode standard).
+ */
+public final function array ToRaw()
+{
+ return contents;
+}
+
+/**
+ * Returns the `string` representation of contents of the caller `Text`.
+ *
+ * Unreal Engine doesn't seem to store code points higher than 2^16 in
+ * `string`, so some data might be lost in the process.
+ * (To check if it concerns you, refer to the Unicode symbol table,
+ * but it is not a problem for most people).
+ */
+public final function string ToString(optional StringType resultType)
+{
+ return _().text.RawToString(contents, resultType);
+}
+
+/**
+ * Checks if the caller `Text` and a given `Text` have contain equal text
+ * content, according to Unicode standard. By default case-sensitive.
+ */
+public final function bool IsEqual
+(
+ Text otherText,
+ optional bool caseInsensitive
+)
+{
+ local int i;
+ local array otherContentsCopy;
+ local TextAPI api;
+ if (contents.length != otherText.contents.length) return false;
+
+ api = _().text;
+ // There's some evidence that UnrealEngine might copy the whole
+ // `otherText.contents` each time we access any element,
+ // so just copy it once.
+ otherContentsCopy = otherText.contents;
+ for (i = 0; i < contents.length; i += 1)
+ {
+ if (!api.AreEqual(contents[i], otherContentsCopy[i], caseInsensitive))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Checks if the caller `Text` contains the same text content as the given
+ * `string`. By default case-sensitive.
+ *
+ * If text contains Unicode code points that can't be stored in
+ * a given `string`, equality should be considered impossible.
+ */
+public final function bool IsEqualToString
+(
+ string source,
+ optional bool caseInsensitive,
+ optional StringType sourceType
+)
+{
+ local int i;
+ local array rawSource;
+ local TextAPI api;
+ api = _().text;
+ rawSource = api.StringToRaw(source, sourceType);
+ if (contents.length != rawSource.length) return false;
+
+ for (i = 0; i < contents.length; i += 1)
+ {
+ if (!api.AreEqual(contents[i], rawSource[i], caseInsensitive))
+ {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Returns `true` if the string has no characters, otherwise returns `false`.
+ */
+public final function bool IsEmpty()
+{
+ return (contents.length == 0);
+}
+
+/**
+ * Attempts to returns Unicode code point, stored in caller `Text` at the
+ * given `index`.
+ *
+ * Doesn't properly work if `Text` contains characters consisting of
+ * multiple code points.
+ *
+ * @return For a valid index (non-negative, not exceeding the length,
+ * given by `GetLength()` of the `Text`) returns Unicode code point,
+ * stored in caller `Text` at the given `index`; otherwise - returns `-1`.
+ */
+public final function Character GetCharacter(optional int index)
+{
+ if (index < 0) return _().text.GetInvalidCharacter();
+ if (index >= contents.length) return _().text.GetInvalidCharacter();
+
+ return contents[index];
+}
+
+/*
+ * Converts caller `Text` to lower case.
+ *
+ * Changes every symbol contained in caller `Text` to it's lower case folding
+ * (according to Unicode standard). Symbols without lower case folding
+ * (like "&" or "!") are left unchanged.
+ *
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Text ToLower()
+{
+ local int i;
+ local TextAPI api;
+ api = _().text;
+ for (i = 0; i < contents.length; i += 1)
+ {
+ contents[i] = api.ToLower(contents[i]);
+ }
+ return self;
+}
+
+/*
+ * Converts caller `Text` to upper case.
+ *
+ * Changes every symbol contained in caller `Text` to it's upper case folding
+ * (according to Unicode standard). Symbols without upper case folding
+ * (like "&" or "!") are left unchanged.
+ *
+ * @return Returns the calling object, to allow for function chaining.
+ */
+public final function Text ToUpper()
+{
+ local int i;
+ local TextAPI api;
+ api = _().text;
+ for (i = 0; i < contents.length; i += 1)
+ {
+ contents[i] = api.ToUpper(contents[i]);
+ }
+ return self;
+}
+
+public final function int GetHash() {
+ return _().text.GetHashRaw(contents);
+}
+
+/**
+ * Returns amount of symbols in the caller `Text`.
+ */
+public final function int GetLength()
+{
+ return contents.length;
+}
+
+defaultproperties
+{
+}
\ No newline at end of file
diff --git a/sources/Core/Text/TextAPI.uc b/sources/Core/Text/TextAPI.uc
new file mode 100644
index 0000000..009a138
--- /dev/null
+++ b/sources/Core/Text/TextAPI.uc
@@ -0,0 +1,1281 @@
+/**
+ * API that provides functions for working with text data, including
+ * standard `string` and Acedia's `Text` and raw string format
+ * `array`.
+ * Copyright 2020 Anton Tarasenko
+ *------------------------------------------------------------------------------
+ * This file is part of Acedia.
+ *
+ * Acedia is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Acedia is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Acedia. If not, see .
+ */
+class TextAPI extends Singleton
+ dependson(Text);
+
+// Escape code point is used to change output's color and is used in
+// Unreal Engine's `string`s.
+var private const int CODEPOINT_ESCAPE;
+// Opening and closing symbols for colored blocks in formatted strings.
+var private const int CODEPOINT_OPEN_FORMAT;
+var private const int CODEPOINT_CLOSE_FORMAT;
+// Symbol to escape any character in formatted strings,
+// including above mentioned opening and closing symbols.
+var private const int CODEPOINT_FORMAT_ESCAPE;
+
+// Every formatted string essentially consists of multiple differently
+// formatted (colored) parts. Such strings will be more convenient for us to
+// work with if we separate them from each other.
+// This structure represents one such block: maximum uninterrupted
+// substring, every character of which has identical formatting.
+// Do note that a single block does not define text formatting, -
+// it is defined by the whole sequence of blocks before it
+// (if `isOpening == false` you only know that you should change previous
+// formatting, but you do not know to what).
+struct FormattedBlock
+{
+ // Did this block start by opening or closing formatted part?
+ // Ignored for the very first block without any formatting.
+ var bool isOpening;
+ // Full text inside the block, without any formatting
+ var array contents;
+ // Formatting tag for this block
+ // (ignored for `isOpening == false`)
+ var string tag;
+ // Whitespace symbol that separates tag from the `contents`;
+ // For the purposes of reassembling a `string` broken into blocks.
+ var Text.Character delimiter;
+};
+
+private final function FormattedBlock CreateFormattedBlock(bool isOpening)
+{
+ local FormattedBlock newBlock;
+ newBlock.isOpening = isOpening;
+ return newBlock;
+}
+
+// Function that breaks formatted string into array of `FormattedBlock`s.
+// Returned array is guaranteed to always have at least one block.
+// First block in array always corresponds to part of the input string
+// (`source`) without any formatting defined, even if it's empty.
+// This is to avoid `FormattedBlock` having a third option besides two defined
+// by `isOpening` variable.
+private final function array DecomposeFormattedString(
+ string source)
+{
+ local Parser parser;
+ local Text.Character nextCharacter;
+ local FormattedBlock nextBlock;
+ local array result;
+ parser = ParseString(source, STRING_Plain);
+ while (!parser.HasFinished()) {
+ parser.MCharacter(nextCharacter);
+ // New formatted block by "{"
+ if (IsCodePoint(nextCharacter, CODEPOINT_OPEN_FORMAT))
+ {
+ result[result.length] = nextBlock;
+ nextBlock = CreateFormattedBlock(true);
+ parser.MUntil(nextBlock.tag,, true).MCharacter(nextBlock.delimiter);
+ if (!parser.Ok()) {
+ break;
+ }
+ continue;
+ }
+ // New formatted block by "}"
+ if (IsCodePoint(nextCharacter, CODEPOINT_CLOSE_FORMAT))
+ {
+ result[result.length] = nextBlock;
+ nextBlock = CreateFormattedBlock(false);
+ continue;
+ }
+ // Escaped sequence
+ if (IsCodePoint(nextCharacter, CODEPOINT_FORMAT_ESCAPE)) {
+ parser.MCharacter(nextCharacter);
+ }
+ if (!parser.Ok()) {
+ break;
+ }
+ nextBlock.contents[nextBlock.contents.length] = nextCharacter;
+ }
+ // Only put in empty block if there is nothing else.
+ if (nextBlock.contents.length > 0 || result.length == 0) {
+ result[result.length] = nextBlock;
+ }
+ _.memory.Free(parser);
+ return result;
+}
+
+/**
+ * Converts given `string` (`source`) of specified type `sourceType`
+ * into the "raw data", a sequence of individually colored symbols.
+ *
+ * @param source `string` that we want to break into a raw data.
+ * @param sourceType Type of the `string`, plain by default.
+ * @return Raw data, corresponding to the given `string` if it's
+ * treated according to `sourceType`.
+ */
+public final function array StringToRaw(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ if (sourceType == STRING_Plain) return StoR_Plain(source);
+ if (sourceType == STRING_Formatted) return StoR_Formatted(source);
+ return StoR_Colored(source);
+}
+
+// Subroutine for converting plain string into raw data
+private final function array StoR_Plain(string source)
+{
+ local int i;
+ local int sourceLength;
+ local Text.Character nextCharacter;
+ local array result;
+
+ // Decompose `source` into integer codes
+ sourceLength = Len(source);
+ for (i = 0; i < sourceLength; i += 1)
+ {
+ nextCharacter.codePoint = Asc(Mid(source, i, 1));
+ result[result.length] = nextCharacter;
+ }
+ return result;
+}
+
+// Subroutine for converting colored string into raw data
+private final function array StoR_Colored(string source)
+{
+ local int i;
+ local int sourceLength;
+ local array sourceAsIntegers;
+ local Text.Character nextCharacter;
+ local array result;
+
+ // Decompose `source` into integer codes
+ sourceLength = Len(source);
+ for (i = 0; i < sourceLength; i += 1)
+ {
+ sourceAsIntegers[sourceAsIntegers.length] = Asc(Mid(source, i, 1));
+ }
+ // Record string as array of `Character`s, parsing color tags
+ i = 0;
+ while (i < sourceLength)
+ {
+ if (sourceAsIntegers[i] == CODEPOINT_ESCAPE)
+ {
+ if (i + 3 >= sourceLength) break;
+ nextCharacter.colorType = STRCOLOR_Struct;
+ nextCharacter.color = _.color.RGB( sourceAsIntegers[i + 1],
+ sourceAsIntegers[i + 2],
+ sourceAsIntegers[i + 3]);
+ i += 4;
+ }
+ else
+ {
+ nextCharacter.codePoint = sourceAsIntegers[i];
+ result[result.length] = nextCharacter;
+ i += 1;
+ }
+ }
+ return result;
+}
+
+// Subroutine for converting formatted string into raw data
+private final function array StoR_Formatted(string source)
+{
+ local int i, j;
+ local Parser parser;
+ local Text.Character nextCharacter;
+ local array decomposedSource;
+ local array blockContentsCopy;
+ local array colorStack;
+ local array result;
+ parser = Parser(_.memory.Borrow(class'Parser'));
+ nextCharacter.colorType = STRCOLOR_Default;
+ decomposedSource = DecomposeFormattedString(source);
+ // First element of `decomposedSource` is special and has
+ // no color information, see `DecomposeFormattedString()` for details.
+ result = decomposedSource[0].contents;
+ for (i = 1; i < decomposedSource.length; i += 1)
+ {
+ if (decomposedSource[i].isOpening)
+ {
+ parser.Initialize(decomposedSource[i].tag);
+ nextCharacter = PushIntoColorStack(colorStack, parser);
+ }
+ else if (colorStack.length > 0) {
+ nextCharacter = PopColorStack(colorStack);
+ }
+ // This whole method is mostly to decide which formatting each symbol
+ // should have, so we only copy code points from block's `contents`.
+ blockContentsCopy = decomposedSource[i].contents;
+ for (j = 0; j < blockContentsCopy.length; j += 1)
+ {
+ nextCharacter.codePoint = blockContentsCopy[j].codePoint;
+ result[result.length] = nextCharacter;
+ }
+ }
+ _.memory.Free(parser);
+ return result;
+}
+
+// Following two functions are to maintain a "color stack" that will
+// remember unclosed colors (new colors are obtained from a parser) defined in
+// formatted string, on order.
+// It is necessary to deal with possible folded formatting definitions in
+// formatted strings.
+// For storing the color information we simply use `Text.Character`,
+// ignoring all information that is not related to colors.
+private final function Text.Character PushIntoColorStack(
+ out array stack,
+ Parser colorDefinitionParser)
+{
+ local Text.Character coloredCharacter;
+ if (colorDefinitionParser.Match("$").Ok()) {
+ coloredCharacter.colorType = STRCOLOR_Alias;
+ colorDefinitionParser.MUntil(coloredCharacter.colorAlias,, true);
+ }
+ else {
+ coloredCharacter.colorType = STRCOLOR_Struct;
+ }
+ colorDefinitionParser.R();
+ if (!_.color.ParseWith(colorDefinitionParser, coloredCharacter.color)) {
+ coloredCharacter.colorType = STRCOLOR_Default;
+ }
+ stack[stack.length] = coloredCharacter;
+ return coloredCharacter;
+}
+
+private final function Text.Character PopColorStack(
+ out array stack)
+{
+ local Text.Character coloredCharacter;
+ stack.length = Max(0, stack.length - 1);
+ if (stack.length > 0) {
+ coloredCharacter = stack[stack.length - 1];
+ }
+ else {
+ coloredCharacter.colorType = STRCOLOR_Default;
+ }
+ return coloredCharacter;
+}
+
+/**
+ * Converts given "raw data" (`source`) into a `string` of a specified type
+ * `sourceType`.
+ *
+ * @param source Raw data that we want to assemble into a `string`.
+ * @param sourceType Type of the `string` we want to assemble,
+ * plain by default.
+ * @return `string`, assembled from given "raw data" in `sourceType` format.
+ */
+public final function string RawToString(
+ array source,
+ optional Text.StringType sourceType,
+ optional Color defaultColor
+)
+{
+ if (sourceType == STRING_Plain) return RtoS_Plain(source);
+ if (sourceType == STRING_Formatted) return RtoS_Formatted(source);
+ return RtoS_Colored(source, defaultColor);
+}
+
+// Subroutine for converting raw data into plain `string`
+private final function string RtoS_Plain(array rawData)
+{
+ local int i;
+ local string result;
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ result $= Chr(rawData[i].codePoint);
+ }
+ return result;
+}
+
+// Subroutine for converting raw data into colored `string`
+private final function string RtoS_Colored
+(
+ array rawData,
+ Color defaultColor
+)
+{
+ local int i;
+ local Color currentColor;
+ local Color nextColor;
+ local string result;
+ defaultColor = _.color.FixColor(defaultColor);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ // Skip any escape codepoints to avoid unnecessary colorization
+ if (IsCodePoint(rawData[i], CODEPOINT_ESCAPE)) continue;
+ // Find `nextColor` that `rawData[i]` is supposed to have
+ if (rawData[i].colorType != STRCOLOR_Default)
+ {
+ nextColor = _.color.FixColor(rawData[i].color);
+ }
+ else
+ {
+ nextColor = defaultColor;
+ }
+ // Add color tag (either initially or when color changes)
+ if (i == 0 || !_.color.AreEqual(nextColor, currentColor))
+ {
+ currentColor = nextColor;
+ result $= Chr(CODEPOINT_ESCAPE);
+ result $= Chr(currentColor.r);
+ result $= Chr(currentColor.g);
+ result $= Chr(currentColor.b);
+ }
+ result $= Chr(rawData[i].codePoint);
+ }
+ return result;
+}
+
+// Subroutine for converting raw data into formatted `string`
+private final function string RtoS_Formatted(array rawData)
+{
+ local int i;
+ local bool isColorChange;
+ local Text.Character previousCharacter;
+ local string result;
+ previousCharacter.colorType = STRCOLOR_Default;
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ isColorChange = rawData[i].colorType != previousCharacter.colorType;
+ if (!isColorChange && rawData[i].colorType != STRCOLOR_Default)
+ {
+ isColorChange = !_.color.AreEqual( rawData[i].color,
+ previousCharacter.color);
+ }
+ if (isColorChange)
+ {
+ if (previousCharacter.colorType != STRCOLOR_Default) {
+ result $= "}";
+ }
+ if (rawData[i].colorType == STRCOLOR_Struct) {
+ result $= "{" $ _.color.ToString(rawData[i].color) $ " ";
+ }
+ if (rawData[i].colorType == STRCOLOR_Alias) {
+ result $= "{" $ "$" $ rawData[i].colorAlias $ " ";
+ }
+ }
+ if ( IsCodePoint(rawData[i], CODEPOINT_OPEN_FORMAT)
+ || IsCodePoint(rawData[i], CODEPOINT_CLOSE_FORMAT)) {
+ result $= "&";
+ }
+ result $= Chr(rawData[i].codePoint);
+ previousCharacter = rawData[i];
+ }
+ if (previousCharacter.colorType != STRCOLOR_Default) {
+ result $= "}";
+ }
+ return result;
+}
+
+/**
+ * Converts between three different types of `string`.
+ *
+ * @param input `string` to convers
+ * @param currentType Current type of the given `string`.
+ * @param newType Type to which given `string` must be converted to.
+ * @param defaultColor In case `input` is being converted into a
+ * `STRING_Colored` type, this color will be used for characters
+ * without one. Otherwise unused.
+ */
+public final function string ConvertString(
+ string input,
+ Text.StringType currentType,
+ Text.StringType newType,
+ optional Color defaultColor)
+{
+ local array rawData;
+ if (currentType == newType) return input;
+ rawData = StringToRaw(input, currentType);
+ return RawToString(rawData, newType, defaultColor);
+}
+
+/**
+ * Checks if given character is lower case.
+ *
+ * Result of this method describes whether character is
+ * precisely "lower case", instead of just "not being upper of title case".
+ * That is, this method will return `true` for characters that aren't
+ * considered either lowercase or uppercase (like "#", "@" or "&").
+ *
+ * @param character Character to test for lower case.
+ * @return `true` if given character is lower case.
+ */
+public final function bool IsLower(Text.Character character)
+{
+ // Small Latin letters
+ if (character.codePoint >= 97 && character.codePoint <= 122) {
+ return true;
+ }
+ // Small Cyrillic (Russian) letters
+ if (character.codePoint >= 1072 && character.codePoint <= 1103) {
+ return true;
+ }
+ // `ё`
+ if (character.codePoint == 1105) {
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Checks if given `string` is in lower case.
+ *
+ * This function returns `true` as long as it's equal to it's own
+ * `ToLowerString()` folding.
+ * This means that it can contain symbols that neither lower or upper case, or
+ * upper case symbols that don't have a lower case folding.
+ *
+ * To check whether a symbol is lower cased, use a combination of
+ * `GetCharacter()` and `IsLower()`.
+ *
+ * @param source `string` to check for being in lower case.
+ * @param sourceType Type of the `string` to check; default is plain string.
+ * @return `true` if `string` is equal to it's own lower folding,
+ * (per character given by `ToLower()` method).
+ */
+public final function bool IsLowerString
+(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ local int i;
+ local array rawData;
+ rawData = StringToRaw(source, sourceType);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ if (rawData[i] != ToLower(rawData[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Checks if given character is upper case.
+ *
+ * Result of this method describes whether character is
+ * precisely "upper case", instead of just "not being upper of title case".
+ * That is, this method will return `true` for characters that aren't
+ * considered either uppercase or uppercase (like "#", "@" or "&").
+ *
+ * @param character Character to test for upper case.
+ * @return `true` if given character is upper case.
+ */
+public final function bool IsUpper(Text.Character character)
+{
+ // Capital Latin letters
+ if (character.codePoint >= 65 && character.codePoint <= 90) {
+ return true;
+ }
+ // Capital Cyrillic (Russian) letters
+ if (character.codePoint >= 1040 && character.codePoint <= 1071) {
+ return true;
+ }
+ // `Ё`
+ if (character.codePoint == 1025) {
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Checks if given `string` is in upper case.
+ *
+ * This function returns `true` as long as it's equal to it's own
+ * `ToUpperString()` folding.
+ * This means that it can contain symbols that neither lower or upper case, or
+ * lower case symbols that don't have an upper case folding.
+ *
+ * To check whether a symbol is upper cased, use a combination of
+ * `GetCharacter()` and `IsUpper()`.
+ *
+ * @param source `string` to check for being in upper case.
+ * @param sourceType Type of the `string` to check; default is plain string.
+ * @return `true` if `string` is equal to it's own upper folding,
+ * (per character given by `ToUpper()` method).
+ */
+public final function bool IsUpperString
+(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ local int i;
+ local array rawData;
+ rawData = StringToRaw(source, sourceType);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ if (rawData[i] != ToUpper(rawData[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Checks if given character corresponds to a digit.
+ *
+ * @param codePoint Unicode code point to check for being a digit.
+ * @return `true` if given Unicode code point is a digit, `false` otherwise.
+ */
+public final function bool IsDigit(Text.Character character)
+{
+ if (character.codePoint >= 48 && character.codePoint <= 57) {
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Checks if given character is an ASCII character.
+ *
+ * @param character Character to check for being a digit.
+ * @return `true` if given character is a digit, `false` otherwise.
+ */
+public final function bool IsASCII(Text.Character character)
+{
+ if (character.codePoint >= 0 && character.codePoint <= 127) {
+ return true;
+ }
+ return false;
+}
+
+/**
+ * Checks if given `string` consists only from ASCII characters
+ * (ignoring characters in 4-byte color change sequences in colored strings).
+ *
+ * @param source `string` to test for being ASCII-only.
+ * @param sourceType Type of the passed `string`.
+ * @return `true` if passed `string` contains only ASCII characters.
+ */
+public final function bool IsASCIIString
+(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ local int i;
+ local array rawData;
+ rawData = StringToRaw(source, sourceType);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ if (!IsASCII(rawData[i])) {
+ return false;
+ }
+ }
+ return true;
+}
+
+/**
+ * Checks if given character represents some kind of white space
+ * symbol (like space ~ 0x0020, tab ~ 0x0009, etc.),
+ * according to either Unicode or a more classic space symbol definition,
+ * that includes:
+ * whitespace, tab, line feed, line tabulation, form feed, carriage return.
+ *
+ * @param character Character to check for being a whitespace.
+ * @return `true` if given character is a whitespace, `false` otherwise.
+ */
+public final function bool IsWhitespace(Text.Character character)
+{
+ switch (character.codePoint)
+ {
+ // Classic whitespaces
+ case 0x0020: // Whitespace
+ case 0x0009: // Tab
+ case 0x000A: // Line feed
+ case 0x000B: // Line tabulation
+ case 0x000C: // Form feed
+ case 0x000D: // Carriage return
+ // Unicode Characters in the 'Separator, Space' Category
+ case 0x00A0: // No-break space
+ case 0x1680: // Ogham space mark
+ case 0x2000: // En quad
+ case 0x2001: // Em quad
+ case 0x2002: // En space
+ case 0x2003: // Em space
+ case 0x2004: // Three-per-em space
+ case 0x2005: // Four-per-em space
+ case 0x2006: // Six-per-em space
+ case 0x2007: // Figure space
+ case 0x2008: // Punctuation space
+ case 0x2009: // Thin space
+ case 0x200A: // Hair space
+ case 0x202F: // Narrow no-break space
+ case 0x205F: // Medium mathematical space
+ case 0x3000: // Ideographic space
+ return true;
+ default:
+ return false;
+ }
+ return false;
+}
+
+/**
+ * Checks if passed character is one of the following quotation mark symbols:
+ * `"`, `'`, `\``.
+ *
+ * @param character Character to check for being a quotation mark.
+ * @return `true` if given Unicode code point denotes one of the recognized
+ * quote symbols, `false` otherwise.
+ */
+public final function bool IsQuotationMark(Text.Character character)
+{
+ if (character.codePoint == 0x0022) return true;
+ if (character.codePoint == 0x0027) return true;
+ if (character.codePoint == 0x0060) return true;
+ return false;
+}
+
+/**
+ * Converts given character into a number it represents in some base
+ * (from 2 to 36), i.e.:
+ * 1 -> 1
+ * 7 -> 7
+ * a -> 10
+ * e -> 14
+ * z -> 35
+ *
+ * @param character Character to convert into integer.
+ * Case does not matter, i.e. "a" and "A" will be treated the same.
+ * @param base Base to use for conversion.
+ * Valid values are from `2` to `36` (inclusive);
+ * If invalid value was specified (such as default `0`),
+ * the base of `36` is assumed, since that would allow for all possible
+ * characters to be converted.
+ * @return Positive integer value that is denoted by
+ * given character in given base;
+ * `-1` if given character does not represent anything in the given base.
+ */
+public final function int CharacterToInt
+(
+ Text.Character character,
+ optional int base
+)
+{
+ local int number;
+ if (base < 2 || base > 36) {
+ base = 36;
+ }
+ character = ToLower(character);
+ // digits
+ if (character.codePoint >= 0x0030 && character.codePoint <= 0x0039) {
+ number = character.codePoint - 0x0030;
+ }
+ // a-z
+ else if (character.codePoint >= 0x0061 && character.codePoint <= 0x007a) {
+ number = character.codePoint - 0x0061 + 10;
+ }
+ else {
+ return -1;
+ }
+ if (number >= base) {
+ return -1;
+ }
+ return number;
+}
+
+/**
+ * Checks if given `character` can be represented by a given `codePoint` in
+ * Unicode standard.
+ *
+ * @param character Character to check.
+ * @param codePoint Code point to check.
+ * @return `true` if given character can be represented by a given code point
+ * and `false` otherwise.
+ */
+public final function bool IsCodePoint(Text.Character character, int codePoint)
+{
+ return (character.codePoint == codePoint);
+}
+
+/**
+ * Returns a particular character from a given `string`, of a given type,
+ * with preserved color information.
+ *
+ * @param source String, from which to fetch the character.
+ * @param position Which, in order, character to fetch
+ * (starting counting from '0').
+ * By default returns first (`0`th) character.
+ * @param sourceType Type of the given `source` `string`.
+ * @return Character from a `source` at a given position `position`.
+ * If given position is out-of-bounds for a given `string`
+ * (it is either negative or at least the same as a total character count),
+ * - returns invalid character.
+ */
+public final function Text.Character GetCharacter
+(
+ string source,
+ optional int position,
+ optional Text.StringType sourceType
+)
+{
+ local Text.Character resultCharacter;
+ local array rawData;
+ if (position < 0) return GetInvalidCharacter();
+
+ // `STRING_Plain` is the only type where we do not need to do any parsing
+ // and get just fetch a character, so handle it separately.
+ if (sourceType == STRING_Plain)
+ {
+ if (position >= Len(source)) {
+ return GetInvalidCharacter();
+ }
+ resultCharacter.codePoint = Asc(Mid(source, position, 1));
+ return resultCharacter;
+ }
+ rawData = StringToRaw(source, sourceType);
+ if (position >= rawData.length) {
+ return GetInvalidCharacter();
+ }
+ return rawData[position];
+}
+
+/**
+ * Returns color of a given `Character` with set default color.
+ *
+ * `Character`s can have their color set to "default", meaning they would use
+ * whatever considered default color in the context.
+ *
+ * @param character `Character`, which color to return.
+ * @param defaultColor Color, considered default.
+ * @return Supposed color of a given `Character`, assuming default color is
+ * `defaultColor`.
+ */
+public final function Color GetCharacterColor(
+ Text.Character character,
+ Color defaultColor)
+{
+ if (character.colorType == STRCOLOR_Default) {
+ return defaultColor;
+ }
+ return character.color;
+}
+
+/**
+ * Returns character that is considered invalid.
+ *
+ * It is not unique, there can be different invalid characters.
+ *
+ * @return Invalid character instance.
+ */
+public final function Text.Character GetInvalidCharacter()
+{
+ local Text.Character result;
+ result.codePoint = -1;
+ return result;
+}
+
+/**
+ * Checks if given character is invalid.
+ *
+ * @param character Character to check.
+ * @return `true` if passed character is valid and `false` otherwise.
+ */
+public final function bool IsValidCharacter(Text.Character character)
+{
+ return (character.codePoint >= 0);
+}
+
+/**
+ * Checks if given characters are equal, with or without accounting
+ * for their case.
+ *
+ * @param codePoint1 Character to compare.
+ * @param codePoint2 Character to compare.
+ * @param caseInsensitive Optional parameter,
+ * if `false` we will require characters to be exactly the same,
+ * if `true` we will also consider characters equal if they
+ * only differ by case.
+ * @return `true` if given characters are considered equal,
+ * `false` otherwise.
+ */
+public final function bool AreEqual(
+ Text.Character character1,
+ Text.Character character2,
+ optional bool caseInsensitive
+)
+{
+ if (character1.codePoint == character2.codePoint) return true;
+ if (character1.codePoint < 0 && character2.codePoint < 0) return true;
+
+ if (caseInsensitive)
+ {
+ character1 = ToLower(character1);
+ character2 = ToLower(character2);
+ }
+ return (character1.codePoint == character2.codePoint);
+}
+
+/**
+ * Checks if given `string`s are equal to each other, with or without
+ * accounting for their case.
+ *
+ * @param string1 `string` to compare.
+ * @param string2 `string` to compare.
+ * @param caseInsensitive Optional parameter,
+ * if `false` we will require `string`s to be exactly the same,
+ * if `true` we will also consider `string`s equal if their corresponding
+ * characters only differ by case.
+ * @return `true` if given `string`s are considered equal, `false` otherwise.
+ */
+public final function bool AreEqualStrings(
+ string string1,
+ string string2,
+ optional bool caseInsensitive
+)
+{
+ local int i;
+ local array rawData1, rawData2;
+ rawData1 = StringToRaw(string1);
+ rawData2 = StringToRaw(string2);
+ if (rawData1.length != rawData2.length) return false;
+
+ for (i = 0; i < rawData1.length; i += 1)
+ {
+ if (!AreEqual(rawData1[i], rawData2[i], caseInsensitive)) return false;
+ }
+ return true;
+}
+
+/**
+ * Converts Unicode code point into it's lower case folding,
+ * as defined by Unicode standard.
+ *
+ * @param codePoint Code point to convert into lower case.
+ * @return Lower case folding of the given code point. If Unicode standard does
+ * not define any lower case folding (like "&" or "!") for given code point, -
+ * function returns given code point unchanged.
+ */
+public final function Text.Character ToLower(Text.Character character)
+{
+ local int newCodePoint;
+ newCodePoint =
+ class'UnicodeData'.static.ToLowerCodePoint(character.codePoint);
+ if (newCodePoint >= 0) {
+ character.codePoint = newCodePoint;
+ }
+ return character;
+}
+
+/**
+ * Converts Unicode code point into it's upper case version,
+ * as defined by Unicode standard.
+ *
+ * @param codePoint Code point to convert into upper case.
+ * @return Upper case version of the given code point. If Unicode standard does
+ * not define any upper case version (like "&" or "!") for given code point, -
+ * function returns given code point unchanged.
+ */
+public final function Text.Character ToUpper(Text.Character character)
+{
+ local int newCodePoint;
+ newCodePoint =
+ class'UnicodeData'.static.ToUpperCodePoint(character.codePoint);
+ if (newCodePoint >= 0) {
+ character.codePoint = newCodePoint;
+ }
+ return character;
+}
+
+/**
+ * Converts `string` to lower case.
+ *
+ * Changes every symbol in the `string` to their lower case folding.
+ * Characters without lower case folding (like "&" or "!") are left unchanged.
+ *
+ * @param source `string` that will be converted into a lower case.
+ * @return Lower case folding of a given `string`.
+ */
+public final function string ToLowerString(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ if (sourceType == STRING_Plain) {
+ return ConvertCaseForString_Plain(source, LCASE_Lower);
+ }
+ if (sourceType == STRING_Formatted) {
+ return ConvertCaseForString_Formatted(source, LCASE_Lower);
+ }
+ return ConvertCaseForString_Colored(source, LCASE_Lower);
+}
+
+/**
+ * Converts `string` to upper case.
+ *
+ * Changes every symbol in the `string` to their upper case folding.
+ * Characters without upper case folding (like "&" or "!") are left unchanged.
+ *
+ * @param source `string` that will be converted into an upper case.
+ * @return Upper case folding of a given `string`.
+ */
+public final function string ToUpperString(
+ string source,
+ optional Text.StringType sourceType
+)
+{
+ if (sourceType == STRING_Plain) {
+ return ConvertCaseForString_Plain(source, LCASE_Upper);
+ }
+ if (sourceType == STRING_Formatted) {
+ return ConvertCaseForString_Formatted(source, LCASE_Upper);
+ }
+ return ConvertCaseForString_Colored(source, LCASE_Upper);
+}
+
+private final function string ConvertCaseForString_Plain
+(
+ string source,
+ Text.LetterCase targetCase
+)
+{
+ local int i;
+ local array rawData;
+ rawData = StringToRaw(source, STRING_Plain);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ if (targetCase == LCASE_Lower) {
+ rawData[i] = ToLower(rawData[i]);
+ }
+ else {
+ rawData[i] = ToUpper(rawData[i]);
+ }
+ }
+ return RawToString(rawData, STRING_Plain);
+}
+
+private final function string ConvertCaseForString_Colored
+(
+ string source,
+ Text.LetterCase targetCase
+)
+{
+ local int i;
+ local string result;
+ local array rawData;
+ rawData = StringToRaw(source, STRING_Colored);
+ for (i = 0; i < rawData.length; i += 1)
+ {
+ if (targetCase == LCASE_Lower) {
+ rawData[i] = ToLower(rawData[i]);
+ }
+ else {
+ rawData[i] = ToUpper(rawData[i]);
+ }
+ }
+ result = RawToString(rawData, STRING_Colored);
+ if (rawData.length > 0 && rawData[0].colorType == STRCOLOR_Default) {
+ result = Mid(result, 4);
+ }
+ return result;
+}
+
+private final function string ConvertCaseForString_Formatted
+(
+ string source,
+ Text.LetterCase targetCase
+)
+{
+ // TODO: finish it later, no one needs it right now,
+ // no idea wtf I even bothered with these functions
+ return source;
+}
+
+/**
+ * Returns hash for a raw `string` data.
+ *
+ * Uses djb2 algorithm, somewhat adapted to make use of formatting
+ * (color) information. Hopefully it did not broke horribly.
+ *
+ * @param rawData Data to calculate hash of.
+ * @return Hash of the given data.
+ */
+public final function int GetHashRaw(array rawData) {
+ local int i;
+ local int colorInt;
+ local int hash;
+ hash = 5381;
+ for (i = 0; i < rawData.length; i += 1) {
+ // hash * 33 + rawData[i].codePoint
+ hash = ((hash << 5) + hash) + rawData[i].codePoint;
+ if (rawData[i].colorType != STRCOLOR_Default) {
+ colorInt = rawData[i].color.r
+ + rawData[i].color.g * 0x00ff
+ + rawData[i].color.b * 0xffff;
+ hash = ((hash << 5) + hash) + colorInt;
+ }
+ }
+ return hash;
+}
+
+/**
+ * Returns hash for a `string` data.
+ *
+ * Uses djb2 algorithm, somewhat adapted to make use of formatting
+ * (color) information. Hopefully it did not broke horribly.
+ *
+ * @param rawData `string` to calculate hash of.
+ * @param sourceType Type of the `string`, in case you want has to be more
+ * formatting-independent. Leaving default value (`STRING_Plain`) should be
+ * fine for almost any use case.
+ * @return Hash of the given data.
+ */
+public final function int GetHash(
+ string source,
+ optional Text.StringType sourceType) {
+ return GetHashRaw(StringToRaw(source, sourceType));
+}
+
+/**
+ * Creates a new, empty `Text`.
+ *
+ * This is a shortcut, same result cam be achieved by `new class'Text'`.
+ *
+ * @return Brand new, empty instance of `Text`.
+ */
+public final function Text Empty()
+{
+ local Text newText;
+ newText = new class'Text';
+ return newText;
+}
+
+/**
+ * Creates a `Text` that will contain a given `string`. Parameter made optional
+ * to enable easier way of creating empty `Text`.
+ *
+ * @param source `string` that will be copied into returned `Text`.
+ * @return New instance (not taken from the object pool) of `Text` that
+ * will contain passed `string`.
+ */
+public final function Text FromString(optional string source)
+{
+ local Text newText;
+ newText = new class'Text';
+ newText.CopyString(source);
+ return newText;
+}
+
+/**
+ * Creates a `Text` that will contain `string` with characters recorded in the
+ * given array. Parameter made optional to enable easier way of
+ * creating empty `Text`.
+ *
+ * @param rawData Sequence of characters that will be copied into
+ * returned `Text`.
+ * @return New instance (not taken from the object pool) of `Text` that
+ * will contain passed sequence of Unicode code points.
+ */
+public final function Text FromRaw(array rawData)
+{
+ local Text newText;
+ newText = new class'Text';
+ newText.CopyRaw(rawData);
+ return newText;
+}
+
+/**
+ * Method for creating a new, uninitialized parser object.
+ *
+ * Always creates a new parser. This method should be used when you plan to
+ * store created `Parser` and reuse later.
+ * To parse something once it's advised to use
+ * `Parse()`, `ParseString()` or `ParseRaw()` instead.
+ *
+ * It is a good practice to free created `Parser` once you don't need it.
+ *
+ * @see `Parser`
+ * @return Guaranteed to be new, uninitialized `Parser`.
+ */
+public final function Parser NewParser()
+{
+ return (new class'Parser');
+}
+
+/**
+ * Method for creating a new parser, initialized with contents of given `Text`.
+ *
+ * Always creates a new parser. This method should be used when you plan to
+ * store created `Parser` and reuse later.
+ * To parse something once it's advised to use `Parse()` instead.
+ *
+ * It is a good practice to free created `Parser` once you don't need it.
+ *
+ * @see `Parser`
+ * @param source Returned `Parser` will be setup to parse the contents of
+ * the passed `Text`.
+ * If `none` value is passed, - parser won't be initialized.
+ * @return Guaranteed to be new `Parser`,
+ * initialized with contents of `source`.
+ */
+public final function Parser NewParserFromText(Text source)
+{
+ local Parser parser;
+ parser = new class'Parser';
+ parser.InitializeT(source);
+ return parser;
+}
+
+/**
+ * Method for creating a new parser, initialized with a given `string`.
+ *
+ * Always creates a new parser. This method should be used when you plan to
+ * store created `Parser` and reuse later.
+ * To parse something once it's advised to use `ParseString()` instead.
+ *
+ * It is a good practice to free created `Parser` once you don't need it.
+ *
+ * @see `Parser`
+ * @param source Returned `Parser` will be setup to parse the `source`.
+ * @return Guaranteed to be new `Parser`, initialized with given `string`.
+ */
+public final function Parser NewParserFromString(string source)
+{
+ local Parser parser;
+ parser = new class'Parser';
+ parser.Initialize(source);
+ return parser;
+}
+
+/**
+ * Method for creating a new parser, initialized with a given sequence of
+ * characters.
+ *
+ * Always creates a new parser. This method should be used when you plan to
+ * store created `Parser` and reuse later.
+ * To parse something once it's advised to use `ParseRaw()` instead.
+ *
+ * It is a good practice to free created `Parser` once you don't need it.
+ *
+ * @see `Parser`
+ * @param source Returned `Parser` will be setup to parse passed
+ * characters sequence.
+ * @return Guaranteed to be new `Parser`, initialized with given
+ * characters sequence.
+ */
+public final function Parser NewParserFromRaw(array source)
+{
+ local Parser parser;
+ parser = new class'Parser';
+ parser.InitializeRaw(source);
+ return parser;
+}
+
+/**
+ * Returns "temporary" `Parser` that can be used for one-time parsing,
+ * initialized with a given sequence of characters.
+ * It will be automatically freed to be reused again after
+ * current tick ends.
+ *
+ * Returned `Parser` does not have to be a new object and
+ * it is possible that it is still referenced by some buggy or malicious code.
+ * To ensure that no problem arises:
+ * 1. Re-initialize returned `Parser` after executing any piece of
+ * code that you do not trust to misuse `Parser`s;
+ * 2. Do not use obtained reference after current tick ends or
+ * calling `FreeParser()` on it.
+ * For more details @see `Parser`.
+ *
+ * @param source Returned `Parser` will be setup to parse passed
+ * characters sequence.
+ * @return Temporary `Parser`, initialized with given
+ * characters sequence.
+ */
+public final function Parser ParseRaw(array source)
+{
+ local Parser parser;
+ parser = Parser(_.memory.Borrow(class'Parser'));
+ if (parser != none)
+ {
+ parser.InitializeRaw(source);
+ return parser;
+ }
+ return none;
+}
+
+/**
+ * Returns "temporary" `Parser` that can be used for one-time parsing,
+ * initialized with contents of given `Text`.
+ * It will be automatically freed to be reused again after
+ * current tick ends.
+ *
+ * Returned `Parser` does not have to be a new object and
+ * it is possible that it is still referenced by some buggy or malicious code.
+ * To ensure that no problem arises:
+ * 1. Re-initialize returned `Parser` after executing any piece of
+ * code that you do not trust to misuse `Parser`s;
+ * 2. Do not use obtained reference after current tick ends or
+ * calling `FreeParser()` on it.
+ * For more details @see `Parser`.
+ *
+ * @param source Returned `Parser` will be setup to parse the contents of
+ * the passed `Text`.
+ * @return Temporary `Parser`, initialized with contents of the given `Text`.
+ */
+public final function Parser Parse(Text source)
+{
+ local Parser parser;
+ if (source == none) return NewParser();
+
+ parser = Parser(_.memory.Borrow(class'Parser'));
+ if (parser != none)
+ {
+ parser.InitializeT(source);
+ return parser;
+ }
+ return none;
+}
+
+/**
+ * Returns "temporary" `Parser` that can be used for one-time parsing,
+ * initialized `string`.
+ * It will be automatically freed to be reused again after
+ * current tick ends.
+ *
+ * Returned `Parser` does not have to be a new object and
+ * it is possible that it is still referenced by some buggy or malicious code.
+ * To ensure that no problem arises:
+ * 1. Re-initialize returned `Parser` after executing any piece of
+ * code that you do not trust to misuse `Parser`s;
+ * 2. Do not use obtained reference after current tick ends or
+ * calling `FreeParser()` on it.
+ * For more details @see `Parser`.
+ *
+ * @param source Returned `Parser` will be setup to parse `source`.
+ * @return Temporary `Parser`, initialized with the given `string`.
+ */
+public final function Parser ParseString (
+ string source,
+optional Text.StringType sourceType) {
+ local Parser parser;
+ parser = Parser(_.memory.Borrow(class'Parser'));
+ if (parser != none) {
+ parser.Initialize(source, sourceType);
+ return parser;
+ }
+ return none;
+}
+
+defaultproperties
+{
+ CODEPOINT_ESCAPE = 27 // ANSI escape code
+ CODEPOINT_OPEN_FORMAT = 123 // '{'
+ CODEPOINT_CLOSE_FORMAT = 125 // '}'
+ CODEPOINT_FORMAT_ESCAPE = 38 // '&'
+}
\ No newline at end of file
diff --git a/sources/Core/Text/UnicodeData.uc b/sources/Core/Text/UnicodeData.uc
new file mode 100644
index 0000000..f405d5b
--- /dev/null
+++ b/sources/Core/Text/UnicodeData.uc
@@ -0,0 +1,4320 @@
+/**
+ * This file is part of Acedia.
+ *
+ * Acedia is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Acedia is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Acedia. If not, see .
+ */
+
+// !!! THIS FILE IS AUTOGENERATED AND SHOULD NOT BE MODIFIED !!!
+
+class UnicodeData extends AcediaObject
+ abstract;
+
+struct CodePointMapping
+{
+ var public int from;
+ var public int to;
+};
+
+var public const array to_lower;
+var public const array to_upper;
+var public const array to_title;
+
+public static function int ToLowerCodePoint(int codePoint)
+{
+ local int midPoint;
+ local int lowerIndex, higherIndex;
+ lowerIndex = 0;
+ higherIndex = default.to_lower.length - 1;
+ while (lowerIndex < higherIndex)
+ {
+ // Border case: lower and higher indices are right next to each other
+ if (lowerIndex + 1 >= higherIndex)
+ {
+ if (default.to_lower[lowerIndex].from == codePoint) {
+ return default.to_lower[lowerIndex].to;
+ }
+ if (default.to_lower[higherIndex].from == codePoint) {
+ return default.to_lower[higherIndex].to;
+ }
+ return -1;
+ }
+ // Choose half
+ midPoint = (lowerIndex + higherIndex) / 2;
+ if (default.to_lower[midPoint].from == codePoint) {
+ return default.to_lower[midPoint].to;
+ }
+ if (default.to_lower[midPoint].from < codePoint) {
+ lowerIndex = midPoint;
+ }
+ else {//if (default.to_lower[midPoint].from > codePoint)
+ higherIndex = midPoint;
+ }
+ }
+ return -1;
+}
+
+public static function int ToUpperCodePoint(int codePoint)
+{
+ local int midPoint;
+ local int lowerIndex, higherIndex;
+ lowerIndex = 0;
+ higherIndex = default.to_upper.length - 1;
+ while (lowerIndex < higherIndex)
+ {
+ // Border case: lower and higher indices are right next to each other
+ if (lowerIndex + 1 >= higherIndex)
+ {
+ if (default.to_upper[lowerIndex].from == codePoint) {
+ return default.to_upper[lowerIndex].to;
+ }
+ if (default.to_upper[higherIndex].from == codePoint) {
+ return default.to_upper[higherIndex].to;
+ }
+ return -1;
+ }
+ // Choose half
+ midPoint = (lowerIndex + higherIndex) / 2;
+ if (default.to_upper[midPoint].from == codePoint) {
+ return default.to_upper[midPoint].to;
+ }
+ if (default.to_upper[midPoint].from < codePoint) {
+ lowerIndex = midPoint;
+ }
+ else {//if (default.to_upper[midPoint].from > codePoint)
+ higherIndex = midPoint;
+ }
+ }
+ return -1;
+}
+
+defaultproperties
+{
+ to_lower(0)=(from=65,to=97)
+ to_lower(1)=(from=66,to=98)
+ to_lower(2)=(from=67,to=99)
+ to_lower(3)=(from=68,to=100)
+ to_lower(4)=(from=69,to=101)
+ to_lower(5)=(from=70,to=102)
+ to_lower(6)=(from=71,to=103)
+ to_lower(7)=(from=72,to=104)
+ to_lower(8)=(from=73,to=105)
+ to_lower(9)=(from=74,to=106)
+ to_lower(10)=(from=75,to=107)
+ to_lower(11)=(from=76,to=108)
+ to_lower(12)=(from=77,to=109)
+ to_lower(13)=(from=78,to=110)
+ to_lower(14)=(from=79,to=111)
+ to_lower(15)=(from=80,to=112)
+ to_lower(16)=(from=81,to=113)
+ to_lower(17)=(from=82,to=114)
+ to_lower(18)=(from=83,to=115)
+ to_lower(19)=(from=84,to=116)
+ to_lower(20)=(from=85,to=117)
+ to_lower(21)=(from=86,to=118)
+ to_lower(22)=(from=87,to=119)
+ to_lower(23)=(from=88,to=120)
+ to_lower(24)=(from=89,to=121)
+ to_lower(25)=(from=90,to=122)
+ to_lower(26)=(from=192,to=224)
+ to_lower(27)=(from=193,to=225)
+ to_lower(28)=(from=194,to=226)
+ to_lower(29)=(from=195,to=227)
+ to_lower(30)=(from=196,to=228)
+ to_lower(31)=(from=197,to=229)
+ to_lower(32)=(from=198,to=230)
+ to_lower(33)=(from=199,to=231)
+ to_lower(34)=(from=200,to=232)
+ to_lower(35)=(from=201,to=233)
+ to_lower(36)=(from=202,to=234)
+ to_lower(37)=(from=203,to=235)
+ to_lower(38)=(from=204,to=236)
+ to_lower(39)=(from=205,to=237)
+ to_lower(40)=(from=206,to=238)
+ to_lower(41)=(from=207,to=239)
+ to_lower(42)=(from=208,to=240)
+ to_lower(43)=(from=209,to=241)
+ to_lower(44)=(from=210,to=242)
+ to_lower(45)=(from=211,to=243)
+ to_lower(46)=(from=212,to=244)
+ to_lower(47)=(from=213,to=245)
+ to_lower(48)=(from=214,to=246)
+ to_lower(49)=(from=216,to=248)
+ to_lower(50)=(from=217,to=249)
+ to_lower(51)=(from=218,to=250)
+ to_lower(52)=(from=219,to=251)
+ to_lower(53)=(from=220,to=252)
+ to_lower(54)=(from=221,to=253)
+ to_lower(55)=(from=222,to=254)
+ to_lower(56)=(from=256,to=257)
+ to_lower(57)=(from=258,to=259)
+ to_lower(58)=(from=260,to=261)
+ to_lower(59)=(from=262,to=263)
+ to_lower(60)=(from=264,to=265)
+ to_lower(61)=(from=266,to=267)
+ to_lower(62)=(from=268,to=269)
+ to_lower(63)=(from=270,to=271)
+ to_lower(64)=(from=272,to=273)
+ to_lower(65)=(from=274,to=275)
+ to_lower(66)=(from=276,to=277)
+ to_lower(67)=(from=278,to=279)
+ to_lower(68)=(from=280,to=281)
+ to_lower(69)=(from=282,to=283)
+ to_lower(70)=(from=284,to=285)
+ to_lower(71)=(from=286,to=287)
+ to_lower(72)=(from=288,to=289)
+ to_lower(73)=(from=290,to=291)
+ to_lower(74)=(from=292,to=293)
+ to_lower(75)=(from=294,to=295)
+ to_lower(76)=(from=296,to=297)
+ to_lower(77)=(from=298,to=299)
+ to_lower(78)=(from=300,to=301)
+ to_lower(79)=(from=302,to=303)
+ to_lower(80)=(from=304,to=105)
+ to_lower(81)=(from=306,to=307)
+ to_lower(82)=(from=308,to=309)
+ to_lower(83)=(from=310,to=311)
+ to_lower(84)=(from=313,to=314)
+ to_lower(85)=(from=315,to=316)
+ to_lower(86)=(from=317,to=318)
+ to_lower(87)=(from=319,to=320)
+ to_lower(88)=(from=321,to=322)
+ to_lower(89)=(from=323,to=324)
+ to_lower(90)=(from=325,to=326)
+ to_lower(91)=(from=327,to=328)
+ to_lower(92)=(from=330,to=331)
+ to_lower(93)=(from=332,to=333)
+ to_lower(94)=(from=334,to=335)
+ to_lower(95)=(from=336,to=337)
+ to_lower(96)=(from=338,to=339)
+ to_lower(97)=(from=340,to=341)
+ to_lower(98)=(from=342,to=343)
+ to_lower(99)=(from=344,to=345)
+ to_lower(100)=(from=346,to=347)
+ to_lower(101)=(from=348,to=349)
+ to_lower(102)=(from=350,to=351)
+ to_lower(103)=(from=352,to=353)
+ to_lower(104)=(from=354,to=355)
+ to_lower(105)=(from=356,to=357)
+ to_lower(106)=(from=358,to=359)
+ to_lower(107)=(from=360,to=361)
+ to_lower(108)=(from=362,to=363)
+ to_lower(109)=(from=364,to=365)
+ to_lower(110)=(from=366,to=367)
+ to_lower(111)=(from=368,to=369)
+ to_lower(112)=(from=370,to=371)
+ to_lower(113)=(from=372,to=373)
+ to_lower(114)=(from=374,to=375)
+ to_lower(115)=(from=376,to=255)
+ to_lower(116)=(from=377,to=378)
+ to_lower(117)=(from=379,to=380)
+ to_lower(118)=(from=381,to=382)
+ to_lower(119)=(from=385,to=595)
+ to_lower(120)=(from=386,to=387)
+ to_lower(121)=(from=388,to=389)
+ to_lower(122)=(from=390,to=596)
+ to_lower(123)=(from=391,to=392)
+ to_lower(124)=(from=393,to=598)
+ to_lower(125)=(from=394,to=599)
+ to_lower(126)=(from=395,to=396)
+ to_lower(127)=(from=398,to=477)
+ to_lower(128)=(from=399,to=601)
+ to_lower(129)=(from=400,to=603)
+ to_lower(130)=(from=401,to=402)
+ to_lower(131)=(from=403,to=608)
+ to_lower(132)=(from=404,to=611)
+ to_lower(133)=(from=406,to=617)
+ to_lower(134)=(from=407,to=616)
+ to_lower(135)=(from=408,to=409)
+ to_lower(136)=(from=412,to=623)
+ to_lower(137)=(from=413,to=626)
+ to_lower(138)=(from=415,to=629)
+ to_lower(139)=(from=416,to=417)
+ to_lower(140)=(from=418,to=419)
+ to_lower(141)=(from=420,to=421)
+ to_lower(142)=(from=422,to=640)
+ to_lower(143)=(from=423,to=424)
+ to_lower(144)=(from=425,to=643)
+ to_lower(145)=(from=428,to=429)
+ to_lower(146)=(from=430,to=648)
+ to_lower(147)=(from=431,to=432)
+ to_lower(148)=(from=433,to=650)
+ to_lower(149)=(from=434,to=651)
+ to_lower(150)=(from=435,to=436)
+ to_lower(151)=(from=437,to=438)
+ to_lower(152)=(from=439,to=658)
+ to_lower(153)=(from=440,to=441)
+ to_lower(154)=(from=444,to=445)
+ to_lower(155)=(from=452,to=454)
+ to_lower(156)=(from=453,to=454)
+ to_lower(157)=(from=455,to=457)
+ to_lower(158)=(from=456,to=457)
+ to_lower(159)=(from=458,to=460)
+ to_lower(160)=(from=459,to=460)
+ to_lower(161)=(from=461,to=462)
+ to_lower(162)=(from=463,to=464)
+ to_lower(163)=(from=465,to=466)
+ to_lower(164)=(from=467,to=468)
+ to_lower(165)=(from=469,to=470)
+ to_lower(166)=(from=471,to=472)
+ to_lower(167)=(from=473,to=474)
+ to_lower(168)=(from=475,to=476)
+ to_lower(169)=(from=478,to=479)
+ to_lower(170)=(from=480,to=481)
+ to_lower(171)=(from=482,to=483)
+ to_lower(172)=(from=484,to=485)
+ to_lower(173)=(from=486,to=487)
+ to_lower(174)=(from=488,to=489)
+ to_lower(175)=(from=490,to=491)
+ to_lower(176)=(from=492,to=493)
+ to_lower(177)=(from=494,to=495)
+ to_lower(178)=(from=497,to=499)
+ to_lower(179)=(from=498,to=499)
+ to_lower(180)=(from=500,to=501)
+ to_lower(181)=(from=502,to=405)
+ to_lower(182)=(from=503,to=447)
+ to_lower(183)=(from=504,to=505)
+ to_lower(184)=(from=506,to=507)
+ to_lower(185)=(from=508,to=509)
+ to_lower(186)=(from=510,to=511)
+ to_lower(187)=(from=512,to=513)
+ to_lower(188)=(from=514,to=515)
+ to_lower(189)=(from=516,to=517)
+ to_lower(190)=(from=518,to=519)
+ to_lower(191)=(from=520,to=521)
+ to_lower(192)=(from=522,to=523)
+ to_lower(193)=(from=524,to=525)
+ to_lower(194)=(from=526,to=527)
+ to_lower(195)=(from=528,to=529)
+ to_lower(196)=(from=530,to=531)
+ to_lower(197)=(from=532,to=533)
+ to_lower(198)=(from=534,to=535)
+ to_lower(199)=(from=536,to=537)
+ to_lower(200)=(from=538,to=539)
+ to_lower(201)=(from=540,to=541)
+ to_lower(202)=(from=542,to=543)
+ to_lower(203)=(from=544,to=414)
+ to_lower(204)=(from=546,to=547)
+ to_lower(205)=(from=548,to=549)
+ to_lower(206)=(from=550,to=551)
+ to_lower(207)=(from=552,to=553)
+ to_lower(208)=(from=554,to=555)
+ to_lower(209)=(from=556,to=557)
+ to_lower(210)=(from=558,to=559)
+ to_lower(211)=(from=560,to=561)
+ to_lower(212)=(from=562,to=563)
+ to_lower(213)=(from=570,to=11365)
+ to_lower(214)=(from=571,to=572)
+ to_lower(215)=(from=573,to=410)
+ to_lower(216)=(from=574,to=11366)
+ to_lower(217)=(from=577,to=578)
+ to_lower(218)=(from=579,to=384)
+ to_lower(219)=(from=580,to=649)
+ to_lower(220)=(from=581,to=652)
+ to_lower(221)=(from=582,to=583)
+ to_lower(222)=(from=584,to=585)
+ to_lower(223)=(from=586,to=587)
+ to_lower(224)=(from=588,to=589)
+ to_lower(225)=(from=590,to=591)
+ to_lower(226)=(from=880,to=881)
+ to_lower(227)=(from=882,to=883)
+ to_lower(228)=(from=886,to=887)
+ to_lower(229)=(from=895,to=1011)
+ to_lower(230)=(from=902,to=940)
+ to_lower(231)=(from=904,to=941)
+ to_lower(232)=(from=905,to=942)
+ to_lower(233)=(from=906,to=943)
+ to_lower(234)=(from=908,to=972)
+ to_lower(235)=(from=910,to=973)
+ to_lower(236)=(from=911,to=974)
+ to_lower(237)=(from=913,to=945)
+ to_lower(238)=(from=914,to=946)
+ to_lower(239)=(from=915,to=947)
+ to_lower(240)=(from=916,to=948)
+ to_lower(241)=(from=917,to=949)
+ to_lower(242)=(from=918,to=950)
+ to_lower(243)=(from=919,to=951)
+ to_lower(244)=(from=920,to=952)
+ to_lower(245)=(from=921,to=953)
+ to_lower(246)=(from=922,to=954)
+ to_lower(247)=(from=923,to=955)
+ to_lower(248)=(from=924,to=956)
+ to_lower(249)=(from=925,to=957)
+ to_lower(250)=(from=926,to=958)
+ to_lower(251)=(from=927,to=959)
+ to_lower(252)=(from=928,to=960)
+ to_lower(253)=(from=929,to=961)
+ to_lower(254)=(from=931,to=963)
+ to_lower(255)=(from=932,to=964)
+ to_lower(256)=(from=933,to=965)
+ to_lower(257)=(from=934,to=966)
+ to_lower(258)=(from=935,to=967)
+ to_lower(259)=(from=936,to=968)
+ to_lower(260)=(from=937,to=969)
+ to_lower(261)=(from=938,to=970)
+ to_lower(262)=(from=939,to=971)
+ to_lower(263)=(from=975,to=983)
+ to_lower(264)=(from=984,to=985)
+ to_lower(265)=(from=986,to=987)
+ to_lower(266)=(from=988,to=989)
+ to_lower(267)=(from=990,to=991)
+ to_lower(268)=(from=992,to=993)
+ to_lower(269)=(from=994,to=995)
+ to_lower(270)=(from=996,to=997)
+ to_lower(271)=(from=998,to=999)
+ to_lower(272)=(from=1000,to=1001)
+ to_lower(273)=(from=1002,to=1003)
+ to_lower(274)=(from=1004,to=1005)
+ to_lower(275)=(from=1006,to=1007)
+ to_lower(276)=(from=1012,to=952)
+ to_lower(277)=(from=1015,to=1016)
+ to_lower(278)=(from=1017,to=1010)
+ to_lower(279)=(from=1018,to=1019)
+ to_lower(280)=(from=1021,to=891)
+ to_lower(281)=(from=1022,to=892)
+ to_lower(282)=(from=1023,to=893)
+ to_lower(283)=(from=1024,to=1104)
+ to_lower(284)=(from=1025,to=1105)
+ to_lower(285)=(from=1026,to=1106)
+ to_lower(286)=(from=1027,to=1107)
+ to_lower(287)=(from=1028,to=1108)
+ to_lower(288)=(from=1029,to=1109)
+ to_lower(289)=(from=1030,to=1110)
+ to_lower(290)=(from=1031,to=1111)
+ to_lower(291)=(from=1032,to=1112)
+ to_lower(292)=(from=1033,to=1113)
+ to_lower(293)=(from=1034,to=1114)
+ to_lower(294)=(from=1035,to=1115)
+ to_lower(295)=(from=1036,to=1116)
+ to_lower(296)=(from=1037,to=1117)
+ to_lower(297)=(from=1038,to=1118)
+ to_lower(298)=(from=1039,to=1119)
+ to_lower(299)=(from=1040,to=1072)
+ to_lower(300)=(from=1041,to=1073)
+ to_lower(301)=(from=1042,to=1074)
+ to_lower(302)=(from=1043,to=1075)
+ to_lower(303)=(from=1044,to=1076)
+ to_lower(304)=(from=1045,to=1077)
+ to_lower(305)=(from=1046,to=1078)
+ to_lower(306)=(from=1047,to=1079)
+ to_lower(307)=(from=1048,to=1080)
+ to_lower(308)=(from=1049,to=1081)
+ to_lower(309)=(from=1050,to=1082)
+ to_lower(310)=(from=1051,to=1083)
+ to_lower(311)=(from=1052,to=1084)
+ to_lower(312)=(from=1053,to=1085)
+ to_lower(313)=(from=1054,to=1086)
+ to_lower(314)=(from=1055,to=1087)
+ to_lower(315)=(from=1056,to=1088)
+ to_lower(316)=(from=1057,to=1089)
+ to_lower(317)=(from=1058,to=1090)
+ to_lower(318)=(from=1059,to=1091)
+ to_lower(319)=(from=1060,to=1092)
+ to_lower(320)=(from=1061,to=1093)
+ to_lower(321)=(from=1062,to=1094)
+ to_lower(322)=(from=1063,to=1095)
+ to_lower(323)=(from=1064,to=1096)
+ to_lower(324)=(from=1065,to=1097)
+ to_lower(325)=(from=1066,to=1098)
+ to_lower(326)=(from=1067,to=1099)
+ to_lower(327)=(from=1068,to=1100)
+ to_lower(328)=(from=1069,to=1101)
+ to_lower(329)=(from=1070,to=1102)
+ to_lower(330)=(from=1071,to=1103)
+ to_lower(331)=(from=1120,to=1121)
+ to_lower(332)=(from=1122,to=1123)
+ to_lower(333)=(from=1124,to=1125)
+ to_lower(334)=(from=1126,to=1127)
+ to_lower(335)=(from=1128,to=1129)
+ to_lower(336)=(from=1130,to=1131)
+ to_lower(337)=(from=1132,to=1133)
+ to_lower(338)=(from=1134,to=1135)
+ to_lower(339)=(from=1136,to=1137)
+ to_lower(340)=(from=1138,to=1139)
+ to_lower(341)=(from=1140,to=1141)
+ to_lower(342)=(from=1142,to=1143)
+ to_lower(343)=(from=1144,to=1145)
+ to_lower(344)=(from=1146,to=1147)
+ to_lower(345)=(from=1148,to=1149)
+ to_lower(346)=(from=1150,to=1151)
+ to_lower(347)=(from=1152,to=1153)
+ to_lower(348)=(from=1162,to=1163)
+ to_lower(349)=(from=1164,to=1165)
+ to_lower(350)=(from=1166,to=1167)
+ to_lower(351)=(from=1168,to=1169)
+ to_lower(352)=(from=1170,to=1171)
+ to_lower(353)=(from=1172,to=1173)
+ to_lower(354)=(from=1174,to=1175)
+ to_lower(355)=(from=1176,to=1177)
+ to_lower(356)=(from=1178,to=1179)
+ to_lower(357)=(from=1180,to=1181)
+ to_lower(358)=(from=1182,to=1183)
+ to_lower(359)=(from=1184,to=1185)
+ to_lower(360)=(from=1186,to=1187)
+ to_lower(361)=(from=1188,to=1189)
+ to_lower(362)=(from=1190,to=1191)
+ to_lower(363)=(from=1192,to=1193)
+ to_lower(364)=(from=1194,to=1195)
+ to_lower(365)=(from=1196,to=1197)
+ to_lower(366)=(from=1198,to=1199)
+ to_lower(367)=(from=1200,to=1201)
+ to_lower(368)=(from=1202,to=1203)
+ to_lower(369)=(from=1204,to=1205)
+ to_lower(370)=(from=1206,to=1207)
+ to_lower(371)=(from=1208,to=1209)
+ to_lower(372)=(from=1210,to=1211)
+ to_lower(373)=(from=1212,to=1213)
+ to_lower(374)=(from=1214,to=1215)
+ to_lower(375)=(from=1216,to=1231)
+ to_lower(376)=(from=1217,to=1218)
+ to_lower(377)=(from=1219,to=1220)
+ to_lower(378)=(from=1221,to=1222)
+ to_lower(379)=(from=1223,to=1224)
+ to_lower(380)=(from=1225,to=1226)
+ to_lower(381)=(from=1227,to=1228)
+ to_lower(382)=(from=1229,to=1230)
+ to_lower(383)=(from=1232,to=1233)
+ to_lower(384)=(from=1234,to=1235)
+ to_lower(385)=(from=1236,to=1237)
+ to_lower(386)=(from=1238,to=1239)
+ to_lower(387)=(from=1240,to=1241)
+ to_lower(388)=(from=1242,to=1243)
+ to_lower(389)=(from=1244,to=1245)
+ to_lower(390)=(from=1246,to=1247)
+ to_lower(391)=(from=1248,to=1249)
+ to_lower(392)=(from=1250,to=1251)
+ to_lower(393)=(from=1252,to=1253)
+ to_lower(394)=(from=1254,to=1255)
+ to_lower(395)=(from=1256,to=1257)
+ to_lower(396)=(from=1258,to=1259)
+ to_lower(397)=(from=1260,to=1261)
+ to_lower(398)=(from=1262,to=1263)
+ to_lower(399)=(from=1264,to=1265)
+ to_lower(400)=(from=1266,to=1267)
+ to_lower(401)=(from=1268,to=1269)
+ to_lower(402)=(from=1270,to=1271)
+ to_lower(403)=(from=1272,to=1273)
+ to_lower(404)=(from=1274,to=1275)
+ to_lower(405)=(from=1276,to=1277)
+ to_lower(406)=(from=1278,to=1279)
+ to_lower(407)=(from=1280,to=1281)
+ to_lower(408)=(from=1282,to=1283)
+ to_lower(409)=(from=1284,to=1285)
+ to_lower(410)=(from=1286,to=1287)
+ to_lower(411)=(from=1288,to=1289)
+ to_lower(412)=(from=1290,to=1291)
+ to_lower(413)=(from=1292,to=1293)
+ to_lower(414)=(from=1294,to=1295)
+ to_lower(415)=(from=1296,to=1297)
+ to_lower(416)=(from=1298,to=1299)
+ to_lower(417)=(from=1300,to=1301)
+ to_lower(418)=(from=1302,to=1303)
+ to_lower(419)=(from=1304,to=1305)
+ to_lower(420)=(from=1306,to=1307)
+ to_lower(421)=(from=1308,to=1309)
+ to_lower(422)=(from=1310,to=1311)
+ to_lower(423)=(from=1312,to=1313)
+ to_lower(424)=(from=1314,to=1315)
+ to_lower(425)=(from=1316,to=1317)
+ to_lower(426)=(from=1318,to=1319)
+ to_lower(427)=(from=1320,to=1321)
+ to_lower(428)=(from=1322,to=1323)
+ to_lower(429)=(from=1324,to=1325)
+ to_lower(430)=(from=1326,to=1327)
+ to_lower(431)=(from=1329,to=1377)
+ to_lower(432)=(from=1330,to=1378)
+ to_lower(433)=(from=1331,to=1379)
+ to_lower(434)=(from=1332,to=1380)
+ to_lower(435)=(from=1333,to=1381)
+ to_lower(436)=(from=1334,to=1382)
+ to_lower(437)=(from=1335,to=1383)
+ to_lower(438)=(from=1336,to=1384)
+ to_lower(439)=(from=1337,to=1385)
+ to_lower(440)=(from=1338,to=1386)
+ to_lower(441)=(from=1339,to=1387)
+ to_lower(442)=(from=1340,to=1388)
+ to_lower(443)=(from=1341,to=1389)
+ to_lower(444)=(from=1342,to=1390)
+ to_lower(445)=(from=1343,to=1391)
+ to_lower(446)=(from=1344,to=1392)
+ to_lower(447)=(from=1345,to=1393)
+ to_lower(448)=(from=1346,to=1394)
+ to_lower(449)=(from=1347,to=1395)
+ to_lower(450)=(from=1348,to=1396)
+ to_lower(451)=(from=1349,to=1397)
+ to_lower(452)=(from=1350,to=1398)
+ to_lower(453)=(from=1351,to=1399)
+ to_lower(454)=(from=1352,to=1400)
+ to_lower(455)=(from=1353,to=1401)
+ to_lower(456)=(from=1354,to=1402)
+ to_lower(457)=(from=1355,to=1403)
+ to_lower(458)=(from=1356,to=1404)
+ to_lower(459)=(from=1357,to=1405)
+ to_lower(460)=(from=1358,to=1406)
+ to_lower(461)=(from=1359,to=1407)
+ to_lower(462)=(from=1360,to=1408)
+ to_lower(463)=(from=1361,to=1409)
+ to_lower(464)=(from=1362,to=1410)
+ to_lower(465)=(from=1363,to=1411)
+ to_lower(466)=(from=1364,to=1412)
+ to_lower(467)=(from=1365,to=1413)
+ to_lower(468)=(from=1366,to=1414)
+ to_lower(469)=(from=4256,to=11520)
+ to_lower(470)=(from=4257,to=11521)
+ to_lower(471)=(from=4258,to=11522)
+ to_lower(472)=(from=4259,to=11523)
+ to_lower(473)=(from=4260,to=11524)
+ to_lower(474)=(from=4261,to=11525)
+ to_lower(475)=(from=4262,to=11526)
+ to_lower(476)=(from=4263,to=11527)
+ to_lower(477)=(from=4264,to=11528)
+ to_lower(478)=(from=4265,to=11529)
+ to_lower(479)=(from=4266,to=11530)
+ to_lower(480)=(from=4267,to=11531)
+ to_lower(481)=(from=4268,to=11532)
+ to_lower(482)=(from=4269,to=11533)
+ to_lower(483)=(from=4270,to=11534)
+ to_lower(484)=(from=4271,to=11535)
+ to_lower(485)=(from=4272,to=11536)
+ to_lower(486)=(from=4273,to=11537)
+ to_lower(487)=(from=4274,to=11538)
+ to_lower(488)=(from=4275,to=11539)
+ to_lower(489)=(from=4276,to=11540)
+ to_lower(490)=(from=4277,to=11541)
+ to_lower(491)=(from=4278,to=11542)
+ to_lower(492)=(from=4279,to=11543)
+ to_lower(493)=(from=4280,to=11544)
+ to_lower(494)=(from=4281,to=11545)
+ to_lower(495)=(from=4282,to=11546)
+ to_lower(496)=(from=4283,to=11547)
+ to_lower(497)=(from=4284,to=11548)
+ to_lower(498)=(from=4285,to=11549)
+ to_lower(499)=(from=4286,to=11550)
+ to_lower(500)=(from=4287,to=11551)
+ to_lower(501)=(from=4288,to=11552)
+ to_lower(502)=(from=4289,to=11553)
+ to_lower(503)=(from=4290,to=11554)
+ to_lower(504)=(from=4291,to=11555)
+ to_lower(505)=(from=4292,to=11556)
+ to_lower(506)=(from=4293,to=11557)
+ to_lower(507)=(from=4295,to=11559)
+ to_lower(508)=(from=4301,to=11565)
+ to_lower(509)=(from=5024,to=43888)
+ to_lower(510)=(from=5025,to=43889)
+ to_lower(511)=(from=5026,to=43890)
+ to_lower(512)=(from=5027,to=43891)
+ to_lower(513)=(from=5028,to=43892)
+ to_lower(514)=(from=5029,to=43893)
+ to_lower(515)=(from=5030,to=43894)
+ to_lower(516)=(from=5031,to=43895)
+ to_lower(517)=(from=5032,to=43896)
+ to_lower(518)=(from=5033,to=43897)
+ to_lower(519)=(from=5034,to=43898)
+ to_lower(520)=(from=5035,to=43899)
+ to_lower(521)=(from=5036,to=43900)
+ to_lower(522)=(from=5037,to=43901)
+ to_lower(523)=(from=5038,to=43902)
+ to_lower(524)=(from=5039,to=43903)
+ to_lower(525)=(from=5040,to=43904)
+ to_lower(526)=(from=5041,to=43905)
+ to_lower(527)=(from=5042,to=43906)
+ to_lower(528)=(from=5043,to=43907)
+ to_lower(529)=(from=5044,to=43908)
+ to_lower(530)=(from=5045,to=43909)
+ to_lower(531)=(from=5046,to=43910)
+ to_lower(532)=(from=5047,to=43911)
+ to_lower(533)=(from=5048,to=43912)
+ to_lower(534)=(from=5049,to=43913)
+ to_lower(535)=(from=5050,to=43914)
+ to_lower(536)=(from=5051,to=43915)
+ to_lower(537)=(from=5052,to=43916)
+ to_lower(538)=(from=5053,to=43917)
+ to_lower(539)=(from=5054,to=43918)
+ to_lower(540)=(from=5055,to=43919)
+ to_lower(541)=(from=5056,to=43920)
+ to_lower(542)=(from=5057,to=43921)
+ to_lower(543)=(from=5058,to=43922)
+ to_lower(544)=(from=5059,to=43923)
+ to_lower(545)=(from=5060,to=43924)
+ to_lower(546)=(from=5061,to=43925)
+ to_lower(547)=(from=5062,to=43926)
+ to_lower(548)=(from=5063,to=43927)
+ to_lower(549)=(from=5064,to=43928)
+ to_lower(550)=(from=5065,to=43929)
+ to_lower(551)=(from=5066,to=43930)
+ to_lower(552)=(from=5067,to=43931)
+ to_lower(553)=(from=5068,to=43932)
+ to_lower(554)=(from=5069,to=43933)
+ to_lower(555)=(from=5070,to=43934)
+ to_lower(556)=(from=5071,to=43935)
+ to_lower(557)=(from=5072,to=43936)
+ to_lower(558)=(from=5073,to=43937)
+ to_lower(559)=(from=5074,to=43938)
+ to_lower(560)=(from=5075,to=43939)
+ to_lower(561)=(from=5076,to=43940)
+ to_lower(562)=(from=5077,to=43941)
+ to_lower(563)=(from=5078,to=43942)
+ to_lower(564)=(from=5079,to=43943)
+ to_lower(565)=(from=5080,to=43944)
+ to_lower(566)=(from=5081,to=43945)
+ to_lower(567)=(from=5082,to=43946)
+ to_lower(568)=(from=5083,to=43947)
+ to_lower(569)=(from=5084,to=43948)
+ to_lower(570)=(from=5085,to=43949)
+ to_lower(571)=(from=5086,to=43950)
+ to_lower(572)=(from=5087,to=43951)
+ to_lower(573)=(from=5088,to=43952)
+ to_lower(574)=(from=5089,to=43953)
+ to_lower(575)=(from=5090,to=43954)
+ to_lower(576)=(from=5091,to=43955)
+ to_lower(577)=(from=5092,to=43956)
+ to_lower(578)=(from=5093,to=43957)
+ to_lower(579)=(from=5094,to=43958)
+ to_lower(580)=(from=5095,to=43959)
+ to_lower(581)=(from=5096,to=43960)
+ to_lower(582)=(from=5097,to=43961)
+ to_lower(583)=(from=5098,to=43962)
+ to_lower(584)=(from=5099,to=43963)
+ to_lower(585)=(from=5100,to=43964)
+ to_lower(586)=(from=5101,to=43965)
+ to_lower(587)=(from=5102,to=43966)
+ to_lower(588)=(from=5103,to=43967)
+ to_lower(589)=(from=5104,to=5112)
+ to_lower(590)=(from=5105,to=5113)
+ to_lower(591)=(from=5106,to=5114)
+ to_lower(592)=(from=5107,to=5115)
+ to_lower(593)=(from=5108,to=5116)
+ to_lower(594)=(from=5109,to=5117)
+ to_lower(595)=(from=7312,to=4304)
+ to_lower(596)=(from=7313,to=4305)
+ to_lower(597)=(from=7314,to=4306)
+ to_lower(598)=(from=7315,to=4307)
+ to_lower(599)=(from=7316,to=4308)
+ to_lower(600)=(from=7317,to=4309)
+ to_lower(601)=(from=7318,to=4310)
+ to_lower(602)=(from=7319,to=4311)
+ to_lower(603)=(from=7320,to=4312)
+ to_lower(604)=(from=7321,to=4313)
+ to_lower(605)=(from=7322,to=4314)
+ to_lower(606)=(from=7323,to=4315)
+ to_lower(607)=(from=7324,to=4316)
+ to_lower(608)=(from=7325,to=4317)
+ to_lower(609)=(from=7326,to=4318)
+ to_lower(610)=(from=7327,to=4319)
+ to_lower(611)=(from=7328,to=4320)
+ to_lower(612)=(from=7329,to=4321)
+ to_lower(613)=(from=7330,to=4322)
+ to_lower(614)=(from=7331,to=4323)
+ to_lower(615)=(from=7332,to=4324)
+ to_lower(616)=(from=7333,to=4325)
+ to_lower(617)=(from=7334,to=4326)
+ to_lower(618)=(from=7335,to=4327)
+ to_lower(619)=(from=7336,to=4328)
+ to_lower(620)=(from=7337,to=4329)
+ to_lower(621)=(from=7338,to=4330)
+ to_lower(622)=(from=7339,to=4331)
+ to_lower(623)=(from=7340,to=4332)
+ to_lower(624)=(from=7341,to=4333)
+ to_lower(625)=(from=7342,to=4334)
+ to_lower(626)=(from=7343,to=4335)
+ to_lower(627)=(from=7344,to=4336)
+ to_lower(628)=(from=7345,to=4337)
+ to_lower(629)=(from=7346,to=4338)
+ to_lower(630)=(from=7347,to=4339)
+ to_lower(631)=(from=7348,to=4340)
+ to_lower(632)=(from=7349,to=4341)
+ to_lower(633)=(from=7350,to=4342)
+ to_lower(634)=(from=7351,to=4343)
+ to_lower(635)=(from=7352,to=4344)
+ to_lower(636)=(from=7353,to=4345)
+ to_lower(637)=(from=7354,to=4346)
+ to_lower(638)=(from=7357,to=4349)
+ to_lower(639)=(from=7358,to=4350)
+ to_lower(640)=(from=7359,to=4351)
+ to_lower(641)=(from=7680,to=7681)
+ to_lower(642)=(from=7682,to=7683)
+ to_lower(643)=(from=7684,to=7685)
+ to_lower(644)=(from=7686,to=7687)
+ to_lower(645)=(from=7688,to=7689)
+ to_lower(646)=(from=7690,to=7691)
+ to_lower(647)=(from=7692,to=7693)
+ to_lower(648)=(from=7694,to=7695)
+ to_lower(649)=(from=7696,to=7697)
+ to_lower(650)=(from=7698,to=7699)
+ to_lower(651)=(from=7700,to=7701)
+ to_lower(652)=(from=7702,to=7703)
+ to_lower(653)=(from=7704,to=7705)
+ to_lower(654)=(from=7706,to=7707)
+ to_lower(655)=(from=7708,to=7709)
+ to_lower(656)=(from=7710,to=7711)
+ to_lower(657)=(from=7712,to=7713)
+ to_lower(658)=(from=7714,to=7715)
+ to_lower(659)=(from=7716,to=7717)
+ to_lower(660)=(from=7718,to=7719)
+ to_lower(661)=(from=7720,to=7721)
+ to_lower(662)=(from=7722,to=7723)
+ to_lower(663)=(from=7724,to=7725)
+ to_lower(664)=(from=7726,to=7727)
+ to_lower(665)=(from=7728,to=7729)
+ to_lower(666)=(from=7730,to=7731)
+ to_lower(667)=(from=7732,to=7733)
+ to_lower(668)=(from=7734,to=7735)
+ to_lower(669)=(from=7736,to=7737)
+ to_lower(670)=(from=7738,to=7739)
+ to_lower(671)=(from=7740,to=7741)
+ to_lower(672)=(from=7742,to=7743)
+ to_lower(673)=(from=7744,to=7745)
+ to_lower(674)=(from=7746,to=7747)
+ to_lower(675)=(from=7748,to=7749)
+ to_lower(676)=(from=7750,to=7751)
+ to_lower(677)=(from=7752,to=7753)
+ to_lower(678)=(from=7754,to=7755)
+ to_lower(679)=(from=7756,to=7757)
+ to_lower(680)=(from=7758,to=7759)
+ to_lower(681)=(from=7760,to=7761)
+ to_lower(682)=(from=7762,to=7763)
+ to_lower(683)=(from=7764,to=7765)
+ to_lower(684)=(from=7766,to=7767)
+ to_lower(685)=(from=7768,to=7769)
+ to_lower(686)=(from=7770,to=7771)
+ to_lower(687)=(from=7772,to=7773)
+ to_lower(688)=(from=7774,to=7775)
+ to_lower(689)=(from=7776,to=7777)
+ to_lower(690)=(from=7778,to=7779)
+ to_lower(691)=(from=7780,to=7781)
+ to_lower(692)=(from=7782,to=7783)
+ to_lower(693)=(from=7784,to=7785)
+ to_lower(694)=(from=7786,to=7787)
+ to_lower(695)=(from=7788,to=7789)
+ to_lower(696)=(from=7790,to=7791)
+ to_lower(697)=(from=7792,to=7793)
+ to_lower(698)=(from=7794,to=7795)
+ to_lower(699)=(from=7796,to=7797)
+ to_lower(700)=(from=7798,to=7799)
+ to_lower(701)=(from=7800,to=7801)
+ to_lower(702)=(from=7802,to=7803)
+ to_lower(703)=(from=7804,to=7805)
+ to_lower(704)=(from=7806,to=7807)
+ to_lower(705)=(from=7808,to=7809)
+ to_lower(706)=(from=7810,to=7811)
+ to_lower(707)=(from=7812,to=7813)
+ to_lower(708)=(from=7814,to=7815)
+ to_lower(709)=(from=7816,to=7817)
+ to_lower(710)=(from=7818,to=7819)
+ to_lower(711)=(from=7820,to=7821)
+ to_lower(712)=(from=7822,to=7823)
+ to_lower(713)=(from=7824,to=7825)
+ to_lower(714)=(from=7826,to=7827)
+ to_lower(715)=(from=7828,to=7829)
+ to_lower(716)=(from=7838,to=223)
+ to_lower(717)=(from=7840,to=7841)
+ to_lower(718)=(from=7842,to=7843)
+ to_lower(719)=(from=7844,to=7845)
+ to_lower(720)=(from=7846,to=7847)
+ to_lower(721)=(from=7848,to=7849)
+ to_lower(722)=(from=7850,to=7851)
+ to_lower(723)=(from=7852,to=7853)
+ to_lower(724)=(from=7854,to=7855)
+ to_lower(725)=(from=7856,to=7857)
+ to_lower(726)=(from=7858,to=7859)
+ to_lower(727)=(from=7860,to=7861)
+ to_lower(728)=(from=7862,to=7863)
+ to_lower(729)=(from=7864,to=7865)
+ to_lower(730)=(from=7866,to=7867)
+ to_lower(731)=(from=7868,to=7869)
+ to_lower(732)=(from=7870,to=7871)
+ to_lower(733)=(from=7872,to=7873)
+ to_lower(734)=(from=7874,to=7875)
+ to_lower(735)=(from=7876,to=7877)
+ to_lower(736)=(from=7878,to=7879)
+ to_lower(737)=(from=7880,to=7881)
+ to_lower(738)=(from=7882,to=7883)
+ to_lower(739)=(from=7884,to=7885)
+ to_lower(740)=(from=7886,to=7887)
+ to_lower(741)=(from=7888,to=7889)
+ to_lower(742)=(from=7890,to=7891)
+ to_lower(743)=(from=7892,to=7893)
+ to_lower(744)=(from=7894,to=7895)
+ to_lower(745)=(from=7896,to=7897)
+ to_lower(746)=(from=7898,to=7899)
+ to_lower(747)=(from=7900,to=7901)
+ to_lower(748)=(from=7902,to=7903)
+ to_lower(749)=(from=7904,to=7905)
+ to_lower(750)=(from=7906,to=7907)
+ to_lower(751)=(from=7908,to=7909)
+ to_lower(752)=(from=7910,to=7911)
+ to_lower(753)=(from=7912,to=7913)
+ to_lower(754)=(from=7914,to=7915)
+ to_lower(755)=(from=7916,to=7917)
+ to_lower(756)=(from=7918,to=7919)
+ to_lower(757)=(from=7920,to=7921)
+ to_lower(758)=(from=7922,to=7923)
+ to_lower(759)=(from=7924,to=7925)
+ to_lower(760)=(from=7926,to=7927)
+ to_lower(761)=(from=7928,to=7929)
+ to_lower(762)=(from=7930,to=7931)
+ to_lower(763)=(from=7932,to=7933)
+ to_lower(764)=(from=7934,to=7935)
+ to_lower(765)=(from=7944,to=7936)
+ to_lower(766)=(from=7945,to=7937)
+ to_lower(767)=(from=7946,to=7938)
+ to_lower(768)=(from=7947,to=7939)
+ to_lower(769)=(from=7948,to=7940)
+ to_lower(770)=(from=7949,to=7941)
+ to_lower(771)=(from=7950,to=7942)
+ to_lower(772)=(from=7951,to=7943)
+ to_lower(773)=(from=7960,to=7952)
+ to_lower(774)=(from=7961,to=7953)
+ to_lower(775)=(from=7962,to=7954)
+ to_lower(776)=(from=7963,to=7955)
+ to_lower(777)=(from=7964,to=7956)
+ to_lower(778)=(from=7965,to=7957)
+ to_lower(779)=(from=7976,to=7968)
+ to_lower(780)=(from=7977,to=7969)
+ to_lower(781)=(from=7978,to=7970)
+ to_lower(782)=(from=7979,to=7971)
+ to_lower(783)=(from=7980,to=7972)
+ to_lower(784)=(from=7981,to=7973)
+ to_lower(785)=(from=7982,to=7974)
+ to_lower(786)=(from=7983,to=7975)
+ to_lower(787)=(from=7992,to=7984)
+ to_lower(788)=(from=7993,to=7985)
+ to_lower(789)=(from=7994,to=7986)
+ to_lower(790)=(from=7995,to=7987)
+ to_lower(791)=(from=7996,to=7988)
+ to_lower(792)=(from=7997,to=7989)
+ to_lower(793)=(from=7998,to=7990)
+ to_lower(794)=(from=7999,to=7991)
+ to_lower(795)=(from=8008,to=8000)
+ to_lower(796)=(from=8009,to=8001)
+ to_lower(797)=(from=8010,to=8002)
+ to_lower(798)=(from=8011,to=8003)
+ to_lower(799)=(from=8012,to=8004)
+ to_lower(800)=(from=8013,to=8005)
+ to_lower(801)=(from=8025,to=8017)
+ to_lower(802)=(from=8027,to=8019)
+ to_lower(803)=(from=8029,to=8021)
+ to_lower(804)=(from=8031,to=8023)
+ to_lower(805)=(from=8040,to=8032)
+ to_lower(806)=(from=8041,to=8033)
+ to_lower(807)=(from=8042,to=8034)
+ to_lower(808)=(from=8043,to=8035)
+ to_lower(809)=(from=8044,to=8036)
+ to_lower(810)=(from=8045,to=8037)
+ to_lower(811)=(from=8046,to=8038)
+ to_lower(812)=(from=8047,to=8039)
+ to_lower(813)=(from=8072,to=8064)
+ to_lower(814)=(from=8073,to=8065)
+ to_lower(815)=(from=8074,to=8066)
+ to_lower(816)=(from=8075,to=8067)
+ to_lower(817)=(from=8076,to=8068)
+ to_lower(818)=(from=8077,to=8069)
+ to_lower(819)=(from=8078,to=8070)
+ to_lower(820)=(from=8079,to=8071)
+ to_lower(821)=(from=8088,to=8080)
+ to_lower(822)=(from=8089,to=8081)
+ to_lower(823)=(from=8090,to=8082)
+ to_lower(824)=(from=8091,to=8083)
+ to_lower(825)=(from=8092,to=8084)
+ to_lower(826)=(from=8093,to=8085)
+ to_lower(827)=(from=8094,to=8086)
+ to_lower(828)=(from=8095,to=8087)
+ to_lower(829)=(from=8104,to=8096)
+ to_lower(830)=(from=8105,to=8097)
+ to_lower(831)=(from=8106,to=8098)
+ to_lower(832)=(from=8107,to=8099)
+ to_lower(833)=(from=8108,to=8100)
+ to_lower(834)=(from=8109,to=8101)
+ to_lower(835)=(from=8110,to=8102)
+ to_lower(836)=(from=8111,to=8103)
+ to_lower(837)=(from=8120,to=8112)
+ to_lower(838)=(from=8121,to=8113)
+ to_lower(839)=(from=8122,to=8048)
+ to_lower(840)=(from=8123,to=8049)
+ to_lower(841)=(from=8124,to=8115)
+ to_lower(842)=(from=8136,to=8050)
+ to_lower(843)=(from=8137,to=8051)
+ to_lower(844)=(from=8138,to=8052)
+ to_lower(845)=(from=8139,to=8053)
+ to_lower(846)=(from=8140,to=8131)
+ to_lower(847)=(from=8152,to=8144)
+ to_lower(848)=(from=8153,to=8145)
+ to_lower(849)=(from=8154,to=8054)
+ to_lower(850)=(from=8155,to=8055)
+ to_lower(851)=(from=8168,to=8160)
+ to_lower(852)=(from=8169,to=8161)
+ to_lower(853)=(from=8170,to=8058)
+ to_lower(854)=(from=8171,to=8059)
+ to_lower(855)=(from=8172,to=8165)
+ to_lower(856)=(from=8184,to=8056)
+ to_lower(857)=(from=8185,to=8057)
+ to_lower(858)=(from=8186,to=8060)
+ to_lower(859)=(from=8187,to=8061)
+ to_lower(860)=(from=8188,to=8179)
+ to_lower(861)=(from=8486,to=969)
+ to_lower(862)=(from=8490,to=107)
+ to_lower(863)=(from=8491,to=229)
+ to_lower(864)=(from=8498,to=8526)
+ to_lower(865)=(from=8544,to=8560)
+ to_lower(866)=(from=8545,to=8561)
+ to_lower(867)=(from=8546,to=8562)
+ to_lower(868)=(from=8547,to=8563)
+ to_lower(869)=(from=8548,to=8564)
+ to_lower(870)=(from=8549,to=8565)
+ to_lower(871)=(from=8550,to=8566)
+ to_lower(872)=(from=8551,to=8567)
+ to_lower(873)=(from=8552,to=8568)
+ to_lower(874)=(from=8553,to=8569)
+ to_lower(875)=(from=8554,to=8570)
+ to_lower(876)=(from=8555,to=8571)
+ to_lower(877)=(from=8556,to=8572)
+ to_lower(878)=(from=8557,to=8573)
+ to_lower(879)=(from=8558,to=8574)
+ to_lower(880)=(from=8559,to=8575)
+ to_lower(881)=(from=8579,to=8580)
+ to_lower(882)=(from=9398,to=9424)
+ to_lower(883)=(from=9399,to=9425)
+ to_lower(884)=(from=9400,to=9426)
+ to_lower(885)=(from=9401,to=9427)
+ to_lower(886)=(from=9402,to=9428)
+ to_lower(887)=(from=9403,to=9429)
+ to_lower(888)=(from=9404,to=9430)
+ to_lower(889)=(from=9405,to=9431)
+ to_lower(890)=(from=9406,to=9432)
+ to_lower(891)=(from=9407,to=9433)
+ to_lower(892)=(from=9408,to=9434)
+ to_lower(893)=(from=9409,to=9435)
+ to_lower(894)=(from=9410,to=9436)
+ to_lower(895)=(from=9411,to=9437)
+ to_lower(896)=(from=9412,to=9438)
+ to_lower(897)=(from=9413,to=9439)
+ to_lower(898)=(from=9414,to=9440)
+ to_lower(899)=(from=9415,to=9441)
+ to_lower(900)=(from=9416,to=9442)
+ to_lower(901)=(from=9417,to=9443)
+ to_lower(902)=(from=9418,to=9444)
+ to_lower(903)=(from=9419,to=9445)
+ to_lower(904)=(from=9420,to=9446)
+ to_lower(905)=(from=9421,to=9447)
+ to_lower(906)=(from=9422,to=9448)
+ to_lower(907)=(from=9423,to=9449)
+ to_lower(908)=(from=11264,to=11312)
+ to_lower(909)=(from=11265,to=11313)
+ to_lower(910)=(from=11266,to=11314)
+ to_lower(911)=(from=11267,to=11315)
+ to_lower(912)=(from=11268,to=11316)
+ to_lower(913)=(from=11269,to=11317)
+ to_lower(914)=(from=11270,to=11318)
+ to_lower(915)=(from=11271,to=11319)
+ to_lower(916)=(from=11272,to=11320)
+ to_lower(917)=(from=11273,to=11321)
+ to_lower(918)=(from=11274,to=11322)
+ to_lower(919)=(from=11275,to=11323)
+ to_lower(920)=(from=11276,to=11324)
+ to_lower(921)=(from=11277,to=11325)
+ to_lower(922)=(from=11278,to=11326)
+ to_lower(923)=(from=11279,to=11327)
+ to_lower(924)=(from=11280,to=11328)
+ to_lower(925)=(from=11281,to=11329)
+ to_lower(926)=(from=11282,to=11330)
+ to_lower(927)=(from=11283,to=11331)
+ to_lower(928)=(from=11284,to=11332)
+ to_lower(929)=(from=11285,to=11333)
+ to_lower(930)=(from=11286,to=11334)
+ to_lower(931)=(from=11287,to=11335)
+ to_lower(932)=(from=11288,to=11336)
+ to_lower(933)=(from=11289,to=11337)
+ to_lower(934)=(from=11290,to=11338)
+ to_lower(935)=(from=11291,to=11339)
+ to_lower(936)=(from=11292,to=11340)
+ to_lower(937)=(from=11293,to=11341)
+ to_lower(938)=(from=11294,to=11342)
+ to_lower(939)=(from=11295,to=11343)
+ to_lower(940)=(from=11296,to=11344)
+ to_lower(941)=(from=11297,to=11345)
+ to_lower(942)=(from=11298,to=11346)
+ to_lower(943)=(from=11299,to=11347)
+ to_lower(944)=(from=11300,to=11348)
+ to_lower(945)=(from=11301,to=11349)
+ to_lower(946)=(from=11302,to=11350)
+ to_lower(947)=(from=11303,to=11351)
+ to_lower(948)=(from=11304,to=11352)
+ to_lower(949)=(from=11305,to=11353)
+ to_lower(950)=(from=11306,to=11354)
+ to_lower(951)=(from=11307,to=11355)
+ to_lower(952)=(from=11308,to=11356)
+ to_lower(953)=(from=11309,to=11357)
+ to_lower(954)=(from=11310,to=11358)
+ to_lower(955)=(from=11360,to=11361)
+ to_lower(956)=(from=11362,to=619)
+ to_lower(957)=(from=11363,to=7549)
+ to_lower(958)=(from=11364,to=637)
+ to_lower(959)=(from=11367,to=11368)
+ to_lower(960)=(from=11369,to=11370)
+ to_lower(961)=(from=11371,to=11372)
+ to_lower(962)=(from=11373,to=593)
+ to_lower(963)=(from=11374,to=625)
+ to_lower(964)=(from=11375,to=592)
+ to_lower(965)=(from=11376,to=594)
+ to_lower(966)=(from=11378,to=11379)
+ to_lower(967)=(from=11381,to=11382)
+ to_lower(968)=(from=11390,to=575)
+ to_lower(969)=(from=11391,to=576)
+ to_lower(970)=(from=11392,to=11393)
+ to_lower(971)=(from=11394,to=11395)
+ to_lower(972)=(from=11396,to=11397)
+ to_lower(973)=(from=11398,to=11399)
+ to_lower(974)=(from=11400,to=11401)
+ to_lower(975)=(from=11402,to=11403)
+ to_lower(976)=(from=11404,to=11405)
+ to_lower(977)=(from=11406,to=11407)
+ to_lower(978)=(from=11408,to=11409)
+ to_lower(979)=(from=11410,to=11411)
+ to_lower(980)=(from=11412,to=11413)
+ to_lower(981)=(from=11414,to=11415)
+ to_lower(982)=(from=11416,to=11417)
+ to_lower(983)=(from=11418,to=11419)
+ to_lower(984)=(from=11420,to=11421)
+ to_lower(985)=(from=11422,to=11423)
+ to_lower(986)=(from=11424,to=11425)
+ to_lower(987)=(from=11426,to=11427)
+ to_lower(988)=(from=11428,to=11429)
+ to_lower(989)=(from=11430,to=11431)
+ to_lower(990)=(from=11432,to=11433)
+ to_lower(991)=(from=11434,to=11435)
+ to_lower(992)=(from=11436,to=11437)
+ to_lower(993)=(from=11438,to=11439)
+ to_lower(994)=(from=11440,to=11441)
+ to_lower(995)=(from=11442,to=11443)
+ to_lower(996)=(from=11444,to=11445)
+ to_lower(997)=(from=11446,to=11447)
+ to_lower(998)=(from=11448,to=11449)
+ to_lower(999)=(from=11450,to=11451)
+ to_lower(1000)=(from=11452,to=11453)
+ to_lower(1001)=(from=11454,to=11455)
+ to_lower(1002)=(from=11456,to=11457)
+ to_lower(1003)=(from=11458,to=11459)
+ to_lower(1004)=(from=11460,to=11461)
+ to_lower(1005)=(from=11462,to=11463)
+ to_lower(1006)=(from=11464,to=11465)
+ to_lower(1007)=(from=11466,to=11467)
+ to_lower(1008)=(from=11468,to=11469)
+ to_lower(1009)=(from=11470,to=11471)
+ to_lower(1010)=(from=11472,to=11473)
+ to_lower(1011)=(from=11474,to=11475)
+ to_lower(1012)=(from=11476,to=11477)
+ to_lower(1013)=(from=11478,to=11479)
+ to_lower(1014)=(from=11480,to=11481)
+ to_lower(1015)=(from=11482,to=11483)
+ to_lower(1016)=(from=11484,to=11485)
+ to_lower(1017)=(from=11486,to=11487)
+ to_lower(1018)=(from=11488,to=11489)
+ to_lower(1019)=(from=11490,to=11491)
+ to_lower(1020)=(from=11499,to=11500)
+ to_lower(1021)=(from=11501,to=11502)
+ to_lower(1022)=(from=11506,to=11507)
+ to_lower(1023)=(from=42560,to=42561)
+ to_lower(1024)=(from=42562,to=42563)
+ to_lower(1025)=(from=42564,to=42565)
+ to_lower(1026)=(from=42566,to=42567)
+ to_lower(1027)=(from=42568,to=42569)
+ to_lower(1028)=(from=42570,to=42571)
+ to_lower(1029)=(from=42572,to=42573)
+ to_lower(1030)=(from=42574,to=42575)
+ to_lower(1031)=(from=42576,to=42577)
+ to_lower(1032)=(from=42578,to=42579)
+ to_lower(1033)=(from=42580,to=42581)
+ to_lower(1034)=(from=42582,to=42583)
+ to_lower(1035)=(from=42584,to=42585)
+ to_lower(1036)=(from=42586,to=42587)
+ to_lower(1037)=(from=42588,to=42589)
+ to_lower(1038)=(from=42590,to=42591)
+ to_lower(1039)=(from=42592,to=42593)
+ to_lower(1040)=(from=42594,to=42595)
+ to_lower(1041)=(from=42596,to=42597)
+ to_lower(1042)=(from=42598,to=42599)
+ to_lower(1043)=(from=42600,to=42601)
+ to_lower(1044)=(from=42602,to=42603)
+ to_lower(1045)=(from=42604,to=42605)
+ to_lower(1046)=(from=42624,to=42625)
+ to_lower(1047)=(from=42626,to=42627)
+ to_lower(1048)=(from=42628,to=42629)
+ to_lower(1049)=(from=42630,to=42631)
+ to_lower(1050)=(from=42632,to=42633)
+ to_lower(1051)=(from=42634,to=42635)
+ to_lower(1052)=(from=42636,to=42637)
+ to_lower(1053)=(from=42638,to=42639)
+ to_lower(1054)=(from=42640,to=42641)
+ to_lower(1055)=(from=42642,to=42643)
+ to_lower(1056)=(from=42644,to=42645)
+ to_lower(1057)=(from=42646,to=42647)
+ to_lower(1058)=(from=42648,to=42649)
+ to_lower(1059)=(from=42650,to=42651)
+ to_lower(1060)=(from=42786,to=42787)
+ to_lower(1061)=(from=42788,to=42789)
+ to_lower(1062)=(from=42790,to=42791)
+ to_lower(1063)=(from=42792,to=42793)
+ to_lower(1064)=(from=42794,to=42795)
+ to_lower(1065)=(from=42796,to=42797)
+ to_lower(1066)=(from=42798,to=42799)
+ to_lower(1067)=(from=42802,to=42803)
+ to_lower(1068)=(from=42804,to=42805)
+ to_lower(1069)=(from=42806,to=42807)
+ to_lower(1070)=(from=42808,to=42809)
+ to_lower(1071)=(from=42810,to=42811)
+ to_lower(1072)=(from=42812,to=42813)
+ to_lower(1073)=(from=42814,to=42815)
+ to_lower(1074)=(from=42816,to=42817)
+ to_lower(1075)=(from=42818,to=42819)
+ to_lower(1076)=(from=42820,to=42821)
+ to_lower(1077)=(from=42822,to=42823)
+ to_lower(1078)=(from=42824,to=42825)
+ to_lower(1079)=(from=42826,to=42827)
+ to_lower(1080)=(from=42828,to=42829)
+ to_lower(1081)=(from=42830,to=42831)
+ to_lower(1082)=(from=42832,to=42833)
+ to_lower(1083)=(from=42834,to=42835)
+ to_lower(1084)=(from=42836,to=42837)
+ to_lower(1085)=(from=42838,to=42839)
+ to_lower(1086)=(from=42840,to=42841)
+ to_lower(1087)=(from=42842,to=42843)
+ to_lower(1088)=(from=42844,to=42845)
+ to_lower(1089)=(from=42846,to=42847)
+ to_lower(1090)=(from=42848,to=42849)
+ to_lower(1091)=(from=42850,to=42851)
+ to_lower(1092)=(from=42852,to=42853)
+ to_lower(1093)=(from=42854,to=42855)
+ to_lower(1094)=(from=42856,to=42857)
+ to_lower(1095)=(from=42858,to=42859)
+ to_lower(1096)=(from=42860,to=42861)
+ to_lower(1097)=(from=42862,to=42863)
+ to_lower(1098)=(from=42873,to=42874)
+ to_lower(1099)=(from=42875,to=42876)
+ to_lower(1100)=(from=42877,to=7545)
+ to_lower(1101)=(from=42878,to=42879)
+ to_lower(1102)=(from=42880,to=42881)
+ to_lower(1103)=(from=42882,to=42883)
+ to_lower(1104)=(from=42884,to=42885)
+ to_lower(1105)=(from=42886,to=42887)
+ to_lower(1106)=(from=42891,to=42892)
+ to_lower(1107)=(from=42893,to=613)
+ to_lower(1108)=(from=42896,to=42897)
+ to_lower(1109)=(from=42898,to=42899)
+ to_lower(1110)=(from=42902,to=42903)
+ to_lower(1111)=(from=42904,to=42905)
+ to_lower(1112)=(from=42906,to=42907)
+ to_lower(1113)=(from=42908,to=42909)
+ to_lower(1114)=(from=42910,to=42911)
+ to_lower(1115)=(from=42912,to=42913)
+ to_lower(1116)=(from=42914,to=42915)
+ to_lower(1117)=(from=42916,to=42917)
+ to_lower(1118)=(from=42918,to=42919)
+ to_lower(1119)=(from=42920,to=42921)
+ to_lower(1120)=(from=42922,to=614)
+ to_lower(1121)=(from=42923,to=604)
+ to_lower(1122)=(from=42924,to=609)
+ to_lower(1123)=(from=42925,to=620)
+ to_lower(1124)=(from=42926,to=618)
+ to_lower(1125)=(from=42928,to=670)
+ to_lower(1126)=(from=42929,to=647)
+ to_lower(1127)=(from=42930,to=669)
+ to_lower(1128)=(from=42931,to=43859)
+ to_lower(1129)=(from=42932,to=42933)
+ to_lower(1130)=(from=42934,to=42935)
+ to_lower(1131)=(from=42936,to=42937)
+ to_lower(1132)=(from=42938,to=42939)
+ to_lower(1133)=(from=42940,to=42941)
+ to_lower(1134)=(from=42942,to=42943)
+ to_lower(1135)=(from=42946,to=42947)
+ to_lower(1136)=(from=42948,to=42900)
+ to_lower(1137)=(from=42949,to=642)
+ to_lower(1138)=(from=42950,to=7566)
+ to_lower(1139)=(from=42951,to=42952)
+ to_lower(1140)=(from=42953,to=42954)
+ to_lower(1141)=(from=42997,to=42998)
+ to_lower(1142)=(from=65313,to=65345)
+ to_lower(1143)=(from=65314,to=65346)
+ to_lower(1144)=(from=65315,to=65347)
+ to_lower(1145)=(from=65316,to=65348)
+ to_lower(1146)=(from=65317,to=65349)
+ to_lower(1147)=(from=65318,to=65350)
+ to_lower(1148)=(from=65319,to=65351)
+ to_lower(1149)=(from=65320,to=65352)
+ to_lower(1150)=(from=65321,to=65353)
+ to_lower(1151)=(from=65322,to=65354)
+ to_lower(1152)=(from=65323,to=65355)
+ to_lower(1153)=(from=65324,to=65356)
+ to_lower(1154)=(from=65325,to=65357)
+ to_lower(1155)=(from=65326,to=65358)
+ to_lower(1156)=(from=65327,to=65359)
+ to_lower(1157)=(from=65328,to=65360)
+ to_lower(1158)=(from=65329,to=65361)
+ to_lower(1159)=(from=65330,to=65362)
+ to_lower(1160)=(from=65331,to=65363)
+ to_lower(1161)=(from=65332,to=65364)
+ to_lower(1162)=(from=65333,to=65365)
+ to_lower(1163)=(from=65334,to=65366)
+ to_lower(1164)=(from=65335,to=65367)
+ to_lower(1165)=(from=65336,to=65368)
+ to_lower(1166)=(from=65337,to=65369)
+ to_lower(1167)=(from=65338,to=65370)
+ to_lower(1168)=(from=66560,to=66600)
+ to_lower(1169)=(from=66561,to=66601)
+ to_lower(1170)=(from=66562,to=66602)
+ to_lower(1171)=(from=66563,to=66603)
+ to_lower(1172)=(from=66564,to=66604)
+ to_lower(1173)=(from=66565,to=66605)
+ to_lower(1174)=(from=66566,to=66606)
+ to_lower(1175)=(from=66567,to=66607)
+ to_lower(1176)=(from=66568,to=66608)
+ to_lower(1177)=(from=66569,to=66609)
+ to_lower(1178)=(from=66570,to=66610)
+ to_lower(1179)=(from=66571,to=66611)
+ to_lower(1180)=(from=66572,to=66612)
+ to_lower(1181)=(from=66573,to=66613)
+ to_lower(1182)=(from=66574,to=66614)
+ to_lower(1183)=(from=66575,to=66615)
+ to_lower(1184)=(from=66576,to=66616)
+ to_lower(1185)=(from=66577,to=66617)
+ to_lower(1186)=(from=66578,to=66618)
+ to_lower(1187)=(from=66579,to=66619)
+ to_lower(1188)=(from=66580,to=66620)
+ to_lower(1189)=(from=66581,to=66621)
+ to_lower(1190)=(from=66582,to=66622)
+ to_lower(1191)=(from=66583,to=66623)
+ to_lower(1192)=(from=66584,to=66624)
+ to_lower(1193)=(from=66585,to=66625)
+ to_lower(1194)=(from=66586,to=66626)
+ to_lower(1195)=(from=66587,to=66627)
+ to_lower(1196)=(from=66588,to=66628)
+ to_lower(1197)=(from=66589,to=66629)
+ to_lower(1198)=(from=66590,to=66630)
+ to_lower(1199)=(from=66591,to=66631)
+ to_lower(1200)=(from=66592,to=66632)
+ to_lower(1201)=(from=66593,to=66633)
+ to_lower(1202)=(from=66594,to=66634)
+ to_lower(1203)=(from=66595,to=66635)
+ to_lower(1204)=(from=66596,to=66636)
+ to_lower(1205)=(from=66597,to=66637)
+ to_lower(1206)=(from=66598,to=66638)
+ to_lower(1207)=(from=66599,to=66639)
+ to_lower(1208)=(from=66736,to=66776)
+ to_lower(1209)=(from=66737,to=66777)
+ to_lower(1210)=(from=66738,to=66778)
+ to_lower(1211)=(from=66739,to=66779)
+ to_lower(1212)=(from=66740,to=66780)
+ to_lower(1213)=(from=66741,to=66781)
+ to_lower(1214)=(from=66742,to=66782)
+ to_lower(1215)=(from=66743,to=66783)
+ to_lower(1216)=(from=66744,to=66784)
+ to_lower(1217)=(from=66745,to=66785)
+ to_lower(1218)=(from=66746,to=66786)
+ to_lower(1219)=(from=66747,to=66787)
+ to_lower(1220)=(from=66748,to=66788)
+ to_lower(1221)=(from=66749,to=66789)
+ to_lower(1222)=(from=66750,to=66790)
+ to_lower(1223)=(from=66751,to=66791)
+ to_lower(1224)=(from=66752,to=66792)
+ to_lower(1225)=(from=66753,to=66793)
+ to_lower(1226)=(from=66754,to=66794)
+ to_lower(1227)=(from=66755,to=66795)
+ to_lower(1228)=(from=66756,to=66796)
+ to_lower(1229)=(from=66757,to=66797)
+ to_lower(1230)=(from=66758,to=66798)
+ to_lower(1231)=(from=66759,to=66799)
+ to_lower(1232)=(from=66760,to=66800)
+ to_lower(1233)=(from=66761,to=66801)
+ to_lower(1234)=(from=66762,to=66802)
+ to_lower(1235)=(from=66763,to=66803)
+ to_lower(1236)=(from=66764,to=66804)
+ to_lower(1237)=(from=66765,to=66805)
+ to_lower(1238)=(from=66766,to=66806)
+ to_lower(1239)=(from=66767,to=66807)
+ to_lower(1240)=(from=66768,to=66808)
+ to_lower(1241)=(from=66769,to=66809)
+ to_lower(1242)=(from=66770,to=66810)
+ to_lower(1243)=(from=66771,to=66811)
+ to_lower(1244)=(from=68736,to=68800)
+ to_lower(1245)=(from=68737,to=68801)
+ to_lower(1246)=(from=68738,to=68802)
+ to_lower(1247)=(from=68739,to=68803)
+ to_lower(1248)=(from=68740,to=68804)
+ to_lower(1249)=(from=68741,to=68805)
+ to_lower(1250)=(from=68742,to=68806)
+ to_lower(1251)=(from=68743,to=68807)
+ to_lower(1252)=(from=68744,to=68808)
+ to_lower(1253)=(from=68745,to=68809)
+ to_lower(1254)=(from=68746,to=68810)
+ to_lower(1255)=(from=68747,to=68811)
+ to_lower(1256)=(from=68748,to=68812)
+ to_lower(1257)=(from=68749,to=68813)
+ to_lower(1258)=(from=68750,to=68814)
+ to_lower(1259)=(from=68751,to=68815)
+ to_lower(1260)=(from=68752,to=68816)
+ to_lower(1261)=(from=68753,to=68817)
+ to_lower(1262)=(from=68754,to=68818)
+ to_lower(1263)=(from=68755,to=68819)
+ to_lower(1264)=(from=68756,to=68820)
+ to_lower(1265)=(from=68757,to=68821)
+ to_lower(1266)=(from=68758,to=68822)
+ to_lower(1267)=(from=68759,to=68823)
+ to_lower(1268)=(from=68760,to=68824)
+ to_lower(1269)=(from=68761,to=68825)
+ to_lower(1270)=(from=68762,to=68826)
+ to_lower(1271)=(from=68763,to=68827)
+ to_lower(1272)=(from=68764,to=68828)
+ to_lower(1273)=(from=68765,to=68829)
+ to_lower(1274)=(from=68766,to=68830)
+ to_lower(1275)=(from=68767,to=68831)
+ to_lower(1276)=(from=68768,to=68832)
+ to_lower(1277)=(from=68769,to=68833)
+ to_lower(1278)=(from=68770,to=68834)
+ to_lower(1279)=(from=68771,to=68835)
+ to_lower(1280)=(from=68772,to=68836)
+ to_lower(1281)=(from=68773,to=68837)
+ to_lower(1282)=(from=68774,to=68838)
+ to_lower(1283)=(from=68775,to=68839)
+ to_lower(1284)=(from=68776,to=68840)
+ to_lower(1285)=(from=68777,to=68841)
+ to_lower(1286)=(from=68778,to=68842)
+ to_lower(1287)=(from=68779,to=68843)
+ to_lower(1288)=(from=68780,to=68844)
+ to_lower(1289)=(from=68781,to=68845)
+ to_lower(1290)=(from=68782,to=68846)
+ to_lower(1291)=(from=68783,to=68847)
+ to_lower(1292)=(from=68784,to=68848)
+ to_lower(1293)=(from=68785,to=68849)
+ to_lower(1294)=(from=68786,to=68850)
+ to_lower(1295)=(from=71840,to=71872)
+ to_lower(1296)=(from=71841,to=71873)
+ to_lower(1297)=(from=71842,to=71874)
+ to_lower(1298)=(from=71843,to=71875)
+ to_lower(1299)=(from=71844,to=71876)
+ to_lower(1300)=(from=71845,to=71877)
+ to_lower(1301)=(from=71846,to=71878)
+ to_lower(1302)=(from=71847,to=71879)
+ to_lower(1303)=(from=71848,to=71880)
+ to_lower(1304)=(from=71849,to=71881)
+ to_lower(1305)=(from=71850,to=71882)
+ to_lower(1306)=(from=71851,to=71883)
+ to_lower(1307)=(from=71852,to=71884)
+ to_lower(1308)=(from=71853,to=71885)
+ to_lower(1309)=(from=71854,to=71886)
+ to_lower(1310)=(from=71855,to=71887)
+ to_lower(1311)=(from=71856,to=71888)
+ to_lower(1312)=(from=71857,to=71889)
+ to_lower(1313)=(from=71858,to=71890)
+ to_lower(1314)=(from=71859,to=71891)
+ to_lower(1315)=(from=71860,to=71892)
+ to_lower(1316)=(from=71861,to=71893)
+ to_lower(1317)=(from=71862,to=71894)
+ to_lower(1318)=(from=71863,to=71895)
+ to_lower(1319)=(from=71864,to=71896)
+ to_lower(1320)=(from=71865,to=71897)
+ to_lower(1321)=(from=71866,to=71898)
+ to_lower(1322)=(from=71867,to=71899)
+ to_lower(1323)=(from=71868,to=71900)
+ to_lower(1324)=(from=71869,to=71901)
+ to_lower(1325)=(from=71870,to=71902)
+ to_lower(1326)=(from=71871,to=71903)
+ to_lower(1327)=(from=93760,to=93792)
+ to_lower(1328)=(from=93761,to=93793)
+ to_lower(1329)=(from=93762,to=93794)
+ to_lower(1330)=(from=93763,to=93795)
+ to_lower(1331)=(from=93764,to=93796)
+ to_lower(1332)=(from=93765,to=93797)
+ to_lower(1333)=(from=93766,to=93798)
+ to_lower(1334)=(from=93767,to=93799)
+ to_lower(1335)=(from=93768,to=93800)
+ to_lower(1336)=(from=93769,to=93801)
+ to_lower(1337)=(from=93770,to=93802)
+ to_lower(1338)=(from=93771,to=93803)
+ to_lower(1339)=(from=93772,to=93804)
+ to_lower(1340)=(from=93773,to=93805)
+ to_lower(1341)=(from=93774,to=93806)
+ to_lower(1342)=(from=93775,to=93807)
+ to_lower(1343)=(from=93776,to=93808)
+ to_lower(1344)=(from=93777,to=93809)
+ to_lower(1345)=(from=93778,to=93810)
+ to_lower(1346)=(from=93779,to=93811)
+ to_lower(1347)=(from=93780,to=93812)
+ to_lower(1348)=(from=93781,to=93813)
+ to_lower(1349)=(from=93782,to=93814)
+ to_lower(1350)=(from=93783,to=93815)
+ to_lower(1351)=(from=93784,to=93816)
+ to_lower(1352)=(from=93785,to=93817)
+ to_lower(1353)=(from=93786,to=93818)
+ to_lower(1354)=(from=93787,to=93819)
+ to_lower(1355)=(from=93788,to=93820)
+ to_lower(1356)=(from=93789,to=93821)
+ to_lower(1357)=(from=93790,to=93822)
+ to_lower(1358)=(from=93791,to=93823)
+ to_lower(1359)=(from=125184,to=125218)
+ to_lower(1360)=(from=125185,to=125219)
+ to_lower(1361)=(from=125186,to=125220)
+ to_lower(1362)=(from=125187,to=125221)
+ to_lower(1363)=(from=125188,to=125222)
+ to_lower(1364)=(from=125189,to=125223)
+ to_lower(1365)=(from=125190,to=125224)
+ to_lower(1366)=(from=125191,to=125225)
+ to_lower(1367)=(from=125192,to=125226)
+ to_lower(1368)=(from=125193,to=125227)
+ to_lower(1369)=(from=125194,to=125228)
+ to_lower(1370)=(from=125195,to=125229)
+ to_lower(1371)=(from=125196,to=125230)
+ to_lower(1372)=(from=125197,to=125231)
+ to_lower(1373)=(from=125198,to=125232)
+ to_lower(1374)=(from=125199,to=125233)
+ to_lower(1375)=(from=125200,to=125234)
+ to_lower(1376)=(from=125201,to=125235)
+ to_lower(1377)=(from=125202,to=125236)
+ to_lower(1378)=(from=125203,to=125237)
+ to_lower(1379)=(from=125204,to=125238)
+ to_lower(1380)=(from=125205,to=125239)
+ to_lower(1381)=(from=125206,to=125240)
+ to_lower(1382)=(from=125207,to=125241)
+ to_lower(1383)=(from=125208,to=125242)
+ to_lower(1384)=(from=125209,to=125243)
+ to_lower(1385)=(from=125210,to=125244)
+ to_lower(1386)=(from=125211,to=125245)
+ to_lower(1387)=(from=125212,to=125246)
+ to_lower(1388)=(from=125213,to=125247)
+ to_lower(1389)=(from=125214,to=125248)
+ to_lower(1390)=(from=125215,to=125249)
+ to_lower(1391)=(from=125216,to=125250)
+ to_lower(1392)=(from=125217,to=125251)
+ to_upper(0)=(from=97,to=65)
+ to_upper(1)=(from=98,to=66)
+ to_upper(2)=(from=99,to=67)
+ to_upper(3)=(from=100,to=68)
+ to_upper(4)=(from=101,to=69)
+ to_upper(5)=(from=102,to=70)
+ to_upper(6)=(from=103,to=71)
+ to_upper(7)=(from=104,to=72)
+ to_upper(8)=(from=105,to=73)
+ to_upper(9)=(from=106,to=74)
+ to_upper(10)=(from=107,to=75)
+ to_upper(11)=(from=108,to=76)
+ to_upper(12)=(from=109,to=77)
+ to_upper(13)=(from=110,to=78)
+ to_upper(14)=(from=111,to=79)
+ to_upper(15)=(from=112,to=80)
+ to_upper(16)=(from=113,to=81)
+ to_upper(17)=(from=114,to=82)
+ to_upper(18)=(from=115,to=83)
+ to_upper(19)=(from=116,to=84)
+ to_upper(20)=(from=117,to=85)
+ to_upper(21)=(from=118,to=86)
+ to_upper(22)=(from=119,to=87)
+ to_upper(23)=(from=120,to=88)
+ to_upper(24)=(from=121,to=89)
+ to_upper(25)=(from=122,to=90)
+ to_upper(26)=(from=181,to=924)
+ to_upper(27)=(from=224,to=192)
+ to_upper(28)=(from=225,to=193)
+ to_upper(29)=(from=226,to=194)
+ to_upper(30)=(from=227,to=195)
+ to_upper(31)=(from=228,to=196)
+ to_upper(32)=(from=229,to=197)
+ to_upper(33)=(from=230,to=198)
+ to_upper(34)=(from=231,to=199)
+ to_upper(35)=(from=232,to=200)
+ to_upper(36)=(from=233,to=201)
+ to_upper(37)=(from=234,to=202)
+ to_upper(38)=(from=235,to=203)
+ to_upper(39)=(from=236,to=204)
+ to_upper(40)=(from=237,to=205)
+ to_upper(41)=(from=238,to=206)
+ to_upper(42)=(from=239,to=207)
+ to_upper(43)=(from=240,to=208)
+ to_upper(44)=(from=241,to=209)
+ to_upper(45)=(from=242,to=210)
+ to_upper(46)=(from=243,to=211)
+ to_upper(47)=(from=244,to=212)
+ to_upper(48)=(from=245,to=213)
+ to_upper(49)=(from=246,to=214)
+ to_upper(50)=(from=248,to=216)
+ to_upper(51)=(from=249,to=217)
+ to_upper(52)=(from=250,to=218)
+ to_upper(53)=(from=251,to=219)
+ to_upper(54)=(from=252,to=220)
+ to_upper(55)=(from=253,to=221)
+ to_upper(56)=(from=254,to=222)
+ to_upper(57)=(from=255,to=376)
+ to_upper(58)=(from=257,to=256)
+ to_upper(59)=(from=259,to=258)
+ to_upper(60)=(from=261,to=260)
+ to_upper(61)=(from=263,to=262)
+ to_upper(62)=(from=265,to=264)
+ to_upper(63)=(from=267,to=266)
+ to_upper(64)=(from=269,to=268)
+ to_upper(65)=(from=271,to=270)
+ to_upper(66)=(from=273,to=272)
+ to_upper(67)=(from=275,to=274)
+ to_upper(68)=(from=277,to=276)
+ to_upper(69)=(from=279,to=278)
+ to_upper(70)=(from=281,to=280)
+ to_upper(71)=(from=283,to=282)
+ to_upper(72)=(from=285,to=284)
+ to_upper(73)=(from=287,to=286)
+ to_upper(74)=(from=289,to=288)
+ to_upper(75)=(from=291,to=290)
+ to_upper(76)=(from=293,to=292)
+ to_upper(77)=(from=295,to=294)
+ to_upper(78)=(from=297,to=296)
+ to_upper(79)=(from=299,to=298)
+ to_upper(80)=(from=301,to=300)
+ to_upper(81)=(from=303,to=302)
+ to_upper(82)=(from=305,to=73)
+ to_upper(83)=(from=307,to=306)
+ to_upper(84)=(from=309,to=308)
+ to_upper(85)=(from=311,to=310)
+ to_upper(86)=(from=314,to=313)
+ to_upper(87)=(from=316,to=315)
+ to_upper(88)=(from=318,to=317)
+ to_upper(89)=(from=320,to=319)
+ to_upper(90)=(from=322,to=321)
+ to_upper(91)=(from=324,to=323)
+ to_upper(92)=(from=326,to=325)
+ to_upper(93)=(from=328,to=327)
+ to_upper(94)=(from=331,to=330)
+ to_upper(95)=(from=333,to=332)
+ to_upper(96)=(from=335,to=334)
+ to_upper(97)=(from=337,to=336)
+ to_upper(98)=(from=339,to=338)
+ to_upper(99)=(from=341,to=340)
+ to_upper(100)=(from=343,to=342)
+ to_upper(101)=(from=345,to=344)
+ to_upper(102)=(from=347,to=346)
+ to_upper(103)=(from=349,to=348)
+ to_upper(104)=(from=351,to=350)
+ to_upper(105)=(from=353,to=352)
+ to_upper(106)=(from=355,to=354)
+ to_upper(107)=(from=357,to=356)
+ to_upper(108)=(from=359,to=358)
+ to_upper(109)=(from=361,to=360)
+ to_upper(110)=(from=363,to=362)
+ to_upper(111)=(from=365,to=364)
+ to_upper(112)=(from=367,to=366)
+ to_upper(113)=(from=369,to=368)
+ to_upper(114)=(from=371,to=370)
+ to_upper(115)=(from=373,to=372)
+ to_upper(116)=(from=375,to=374)
+ to_upper(117)=(from=378,to=377)
+ to_upper(118)=(from=380,to=379)
+ to_upper(119)=(from=382,to=381)
+ to_upper(120)=(from=383,to=83)
+ to_upper(121)=(from=384,to=579)
+ to_upper(122)=(from=387,to=386)
+ to_upper(123)=(from=389,to=388)
+ to_upper(124)=(from=392,to=391)
+ to_upper(125)=(from=396,to=395)
+ to_upper(126)=(from=402,to=401)
+ to_upper(127)=(from=405,to=502)
+ to_upper(128)=(from=409,to=408)
+ to_upper(129)=(from=410,to=573)
+ to_upper(130)=(from=414,to=544)
+ to_upper(131)=(from=417,to=416)
+ to_upper(132)=(from=419,to=418)
+ to_upper(133)=(from=421,to=420)
+ to_upper(134)=(from=424,to=423)
+ to_upper(135)=(from=429,to=428)
+ to_upper(136)=(from=432,to=431)
+ to_upper(137)=(from=436,to=435)
+ to_upper(138)=(from=438,to=437)
+ to_upper(139)=(from=441,to=440)
+ to_upper(140)=(from=445,to=444)
+ to_upper(141)=(from=447,to=503)
+ to_upper(142)=(from=453,to=452)
+ to_upper(143)=(from=454,to=452)
+ to_upper(144)=(from=456,to=455)
+ to_upper(145)=(from=457,to=455)
+ to_upper(146)=(from=459,to=458)
+ to_upper(147)=(from=460,to=458)
+ to_upper(148)=(from=462,to=461)
+ to_upper(149)=(from=464,to=463)
+ to_upper(150)=(from=466,to=465)
+ to_upper(151)=(from=468,to=467)
+ to_upper(152)=(from=470,to=469)
+ to_upper(153)=(from=472,to=471)
+ to_upper(154)=(from=474,to=473)
+ to_upper(155)=(from=476,to=475)
+ to_upper(156)=(from=477,to=398)
+ to_upper(157)=(from=479,to=478)
+ to_upper(158)=(from=481,to=480)
+ to_upper(159)=(from=483,to=482)
+ to_upper(160)=(from=485,to=484)
+ to_upper(161)=(from=487,to=486)
+ to_upper(162)=(from=489,to=488)
+ to_upper(163)=(from=491,to=490)
+ to_upper(164)=(from=493,to=492)
+ to_upper(165)=(from=495,to=494)
+ to_upper(166)=(from=498,to=497)
+ to_upper(167)=(from=499,to=497)
+ to_upper(168)=(from=501,to=500)
+ to_upper(169)=(from=505,to=504)
+ to_upper(170)=(from=507,to=506)
+ to_upper(171)=(from=509,to=508)
+ to_upper(172)=(from=511,to=510)
+ to_upper(173)=(from=513,to=512)
+ to_upper(174)=(from=515,to=514)
+ to_upper(175)=(from=517,to=516)
+ to_upper(176)=(from=519,to=518)
+ to_upper(177)=(from=521,to=520)
+ to_upper(178)=(from=523,to=522)
+ to_upper(179)=(from=525,to=524)
+ to_upper(180)=(from=527,to=526)
+ to_upper(181)=(from=529,to=528)
+ to_upper(182)=(from=531,to=530)
+ to_upper(183)=(from=533,to=532)
+ to_upper(184)=(from=535,to=534)
+ to_upper(185)=(from=537,to=536)
+ to_upper(186)=(from=539,to=538)
+ to_upper(187)=(from=541,to=540)
+ to_upper(188)=(from=543,to=542)
+ to_upper(189)=(from=547,to=546)
+ to_upper(190)=(from=549,to=548)
+ to_upper(191)=(from=551,to=550)
+ to_upper(192)=(from=553,to=552)
+ to_upper(193)=(from=555,to=554)
+ to_upper(194)=(from=557,to=556)
+ to_upper(195)=(from=559,to=558)
+ to_upper(196)=(from=561,to=560)
+ to_upper(197)=(from=563,to=562)
+ to_upper(198)=(from=572,to=571)
+ to_upper(199)=(from=575,to=11390)
+ to_upper(200)=(from=576,to=11391)
+ to_upper(201)=(from=578,to=577)
+ to_upper(202)=(from=583,to=582)
+ to_upper(203)=(from=585,to=584)
+ to_upper(204)=(from=587,to=586)
+ to_upper(205)=(from=589,to=588)
+ to_upper(206)=(from=591,to=590)
+ to_upper(207)=(from=592,to=11375)
+ to_upper(208)=(from=593,to=11373)
+ to_upper(209)=(from=594,to=11376)
+ to_upper(210)=(from=595,to=385)
+ to_upper(211)=(from=596,to=390)
+ to_upper(212)=(from=598,to=393)
+ to_upper(213)=(from=599,to=394)
+ to_upper(214)=(from=601,to=399)
+ to_upper(215)=(from=603,to=400)
+ to_upper(216)=(from=604,to=42923)
+ to_upper(217)=(from=608,to=403)
+ to_upper(218)=(from=609,to=42924)
+ to_upper(219)=(from=611,to=404)
+ to_upper(220)=(from=613,to=42893)
+ to_upper(221)=(from=614,to=42922)
+ to_upper(222)=(from=616,to=407)
+ to_upper(223)=(from=617,to=406)
+ to_upper(224)=(from=618,to=42926)
+ to_upper(225)=(from=619,to=11362)
+ to_upper(226)=(from=620,to=42925)
+ to_upper(227)=(from=623,to=412)
+ to_upper(228)=(from=625,to=11374)
+ to_upper(229)=(from=626,to=413)
+ to_upper(230)=(from=629,to=415)
+ to_upper(231)=(from=637,to=11364)
+ to_upper(232)=(from=640,to=422)
+ to_upper(233)=(from=642,to=42949)
+ to_upper(234)=(from=643,to=425)
+ to_upper(235)=(from=647,to=42929)
+ to_upper(236)=(from=648,to=430)
+ to_upper(237)=(from=649,to=580)
+ to_upper(238)=(from=650,to=433)
+ to_upper(239)=(from=651,to=434)
+ to_upper(240)=(from=652,to=581)
+ to_upper(241)=(from=658,to=439)
+ to_upper(242)=(from=669,to=42930)
+ to_upper(243)=(from=670,to=42928)
+ to_upper(244)=(from=837,to=921)
+ to_upper(245)=(from=881,to=880)
+ to_upper(246)=(from=883,to=882)
+ to_upper(247)=(from=887,to=886)
+ to_upper(248)=(from=891,to=1021)
+ to_upper(249)=(from=892,to=1022)
+ to_upper(250)=(from=893,to=1023)
+ to_upper(251)=(from=940,to=902)
+ to_upper(252)=(from=941,to=904)
+ to_upper(253)=(from=942,to=905)
+ to_upper(254)=(from=943,to=906)
+ to_upper(255)=(from=945,to=913)
+ to_upper(256)=(from=946,to=914)
+ to_upper(257)=(from=947,to=915)
+ to_upper(258)=(from=948,to=916)
+ to_upper(259)=(from=949,to=917)
+ to_upper(260)=(from=950,to=918)
+ to_upper(261)=(from=951,to=919)
+ to_upper(262)=(from=952,to=920)
+ to_upper(263)=(from=953,to=921)
+ to_upper(264)=(from=954,to=922)
+ to_upper(265)=(from=955,to=923)
+ to_upper(266)=(from=956,to=924)
+ to_upper(267)=(from=957,to=925)
+ to_upper(268)=(from=958,to=926)
+ to_upper(269)=(from=959,to=927)
+ to_upper(270)=(from=960,to=928)
+ to_upper(271)=(from=961,to=929)
+ to_upper(272)=(from=962,to=931)
+ to_upper(273)=(from=963,to=931)
+ to_upper(274)=(from=964,to=932)
+ to_upper(275)=(from=965,to=933)
+ to_upper(276)=(from=966,to=934)
+ to_upper(277)=(from=967,to=935)
+ to_upper(278)=(from=968,to=936)
+ to_upper(279)=(from=969,to=937)
+ to_upper(280)=(from=970,to=938)
+ to_upper(281)=(from=971,to=939)
+ to_upper(282)=(from=972,to=908)
+ to_upper(283)=(from=973,to=910)
+ to_upper(284)=(from=974,to=911)
+ to_upper(285)=(from=976,to=914)
+ to_upper(286)=(from=977,to=920)
+ to_upper(287)=(from=981,to=934)
+ to_upper(288)=(from=982,to=928)
+ to_upper(289)=(from=983,to=975)
+ to_upper(290)=(from=985,to=984)
+ to_upper(291)=(from=987,to=986)
+ to_upper(292)=(from=989,to=988)
+ to_upper(293)=(from=991,to=990)
+ to_upper(294)=(from=993,to=992)
+ to_upper(295)=(from=995,to=994)
+ to_upper(296)=(from=997,to=996)
+ to_upper(297)=(from=999,to=998)
+ to_upper(298)=(from=1001,to=1000)
+ to_upper(299)=(from=1003,to=1002)
+ to_upper(300)=(from=1005,to=1004)
+ to_upper(301)=(from=1007,to=1006)
+ to_upper(302)=(from=1008,to=922)
+ to_upper(303)=(from=1009,to=929)
+ to_upper(304)=(from=1010,to=1017)
+ to_upper(305)=(from=1011,to=895)
+ to_upper(306)=(from=1013,to=917)
+ to_upper(307)=(from=1016,to=1015)
+ to_upper(308)=(from=1019,to=1018)
+ to_upper(309)=(from=1072,to=1040)
+ to_upper(310)=(from=1073,to=1041)
+ to_upper(311)=(from=1074,to=1042)
+ to_upper(312)=(from=1075,to=1043)
+ to_upper(313)=(from=1076,to=1044)
+ to_upper(314)=(from=1077,to=1045)
+ to_upper(315)=(from=1078,to=1046)
+ to_upper(316)=(from=1079,to=1047)
+ to_upper(317)=(from=1080,to=1048)
+ to_upper(318)=(from=1081,to=1049)
+ to_upper(319)=(from=1082,to=1050)
+ to_upper(320)=(from=1083,to=1051)
+ to_upper(321)=(from=1084,to=1052)
+ to_upper(322)=(from=1085,to=1053)
+ to_upper(323)=(from=1086,to=1054)
+ to_upper(324)=(from=1087,to=1055)
+ to_upper(325)=(from=1088,to=1056)
+ to_upper(326)=(from=1089,to=1057)
+ to_upper(327)=(from=1090,to=1058)
+ to_upper(328)=(from=1091,to=1059)
+ to_upper(329)=(from=1092,to=1060)
+ to_upper(330)=(from=1093,to=1061)
+ to_upper(331)=(from=1094,to=1062)
+ to_upper(332)=(from=1095,to=1063)
+ to_upper(333)=(from=1096,to=1064)
+ to_upper(334)=(from=1097,to=1065)
+ to_upper(335)=(from=1098,to=1066)
+ to_upper(336)=(from=1099,to=1067)
+ to_upper(337)=(from=1100,to=1068)
+ to_upper(338)=(from=1101,to=1069)
+ to_upper(339)=(from=1102,to=1070)
+ to_upper(340)=(from=1103,to=1071)
+ to_upper(341)=(from=1104,to=1024)
+ to_upper(342)=(from=1105,to=1025)
+ to_upper(343)=(from=1106,to=1026)
+ to_upper(344)=(from=1107,to=1027)
+ to_upper(345)=(from=1108,to=1028)
+ to_upper(346)=(from=1109,to=1029)
+ to_upper(347)=(from=1110,to=1030)
+ to_upper(348)=(from=1111,to=1031)
+ to_upper(349)=(from=1112,to=1032)
+ to_upper(350)=(from=1113,to=1033)
+ to_upper(351)=(from=1114,to=1034)
+ to_upper(352)=(from=1115,to=1035)
+ to_upper(353)=(from=1116,to=1036)
+ to_upper(354)=(from=1117,to=1037)
+ to_upper(355)=(from=1118,to=1038)
+ to_upper(356)=(from=1119,to=1039)
+ to_upper(357)=(from=1121,to=1120)
+ to_upper(358)=(from=1123,to=1122)
+ to_upper(359)=(from=1125,to=1124)
+ to_upper(360)=(from=1127,to=1126)
+ to_upper(361)=(from=1129,to=1128)
+ to_upper(362)=(from=1131,to=1130)
+ to_upper(363)=(from=1133,to=1132)
+ to_upper(364)=(from=1135,to=1134)
+ to_upper(365)=(from=1137,to=1136)
+ to_upper(366)=(from=1139,to=1138)
+ to_upper(367)=(from=1141,to=1140)
+ to_upper(368)=(from=1143,to=1142)
+ to_upper(369)=(from=1145,to=1144)
+ to_upper(370)=(from=1147,to=1146)
+ to_upper(371)=(from=1149,to=1148)
+ to_upper(372)=(from=1151,to=1150)
+ to_upper(373)=(from=1153,to=1152)
+ to_upper(374)=(from=1163,to=1162)
+ to_upper(375)=(from=1165,to=1164)
+ to_upper(376)=(from=1167,to=1166)
+ to_upper(377)=(from=1169,to=1168)
+ to_upper(378)=(from=1171,to=1170)
+ to_upper(379)=(from=1173,to=1172)
+ to_upper(380)=(from=1175,to=1174)
+ to_upper(381)=(from=1177,to=1176)
+ to_upper(382)=(from=1179,to=1178)
+ to_upper(383)=(from=1181,to=1180)
+ to_upper(384)=(from=1183,to=1182)
+ to_upper(385)=(from=1185,to=1184)
+ to_upper(386)=(from=1187,to=1186)
+ to_upper(387)=(from=1189,to=1188)
+ to_upper(388)=(from=1191,to=1190)
+ to_upper(389)=(from=1193,to=1192)
+ to_upper(390)=(from=1195,to=1194)
+ to_upper(391)=(from=1197,to=1196)
+ to_upper(392)=(from=1199,to=1198)
+ to_upper(393)=(from=1201,to=1200)
+ to_upper(394)=(from=1203,to=1202)
+ to_upper(395)=(from=1205,to=1204)
+ to_upper(396)=(from=1207,to=1206)
+ to_upper(397)=(from=1209,to=1208)
+ to_upper(398)=(from=1211,to=1210)
+ to_upper(399)=(from=1213,to=1212)
+ to_upper(400)=(from=1215,to=1214)
+ to_upper(401)=(from=1218,to=1217)
+ to_upper(402)=(from=1220,to=1219)
+ to_upper(403)=(from=1222,to=1221)
+ to_upper(404)=(from=1224,to=1223)
+ to_upper(405)=(from=1226,to=1225)
+ to_upper(406)=(from=1228,to=1227)
+ to_upper(407)=(from=1230,to=1229)
+ to_upper(408)=(from=1231,to=1216)
+ to_upper(409)=(from=1233,to=1232)
+ to_upper(410)=(from=1235,to=1234)
+ to_upper(411)=(from=1237,to=1236)
+ to_upper(412)=(from=1239,to=1238)
+ to_upper(413)=(from=1241,to=1240)
+ to_upper(414)=(from=1243,to=1242)
+ to_upper(415)=(from=1245,to=1244)
+ to_upper(416)=(from=1247,to=1246)
+ to_upper(417)=(from=1249,to=1248)
+ to_upper(418)=(from=1251,to=1250)
+ to_upper(419)=(from=1253,to=1252)
+ to_upper(420)=(from=1255,to=1254)
+ to_upper(421)=(from=1257,to=1256)
+ to_upper(422)=(from=1259,to=1258)
+ to_upper(423)=(from=1261,to=1260)
+ to_upper(424)=(from=1263,to=1262)
+ to_upper(425)=(from=1265,to=1264)
+ to_upper(426)=(from=1267,to=1266)
+ to_upper(427)=(from=1269,to=1268)
+ to_upper(428)=(from=1271,to=1270)
+ to_upper(429)=(from=1273,to=1272)
+ to_upper(430)=(from=1275,to=1274)
+ to_upper(431)=(from=1277,to=1276)
+ to_upper(432)=(from=1279,to=1278)
+ to_upper(433)=(from=1281,to=1280)
+ to_upper(434)=(from=1283,to=1282)
+ to_upper(435)=(from=1285,to=1284)
+ to_upper(436)=(from=1287,to=1286)
+ to_upper(437)=(from=1289,to=1288)
+ to_upper(438)=(from=1291,to=1290)
+ to_upper(439)=(from=1293,to=1292)
+ to_upper(440)=(from=1295,to=1294)
+ to_upper(441)=(from=1297,to=1296)
+ to_upper(442)=(from=1299,to=1298)
+ to_upper(443)=(from=1301,to=1300)
+ to_upper(444)=(from=1303,to=1302)
+ to_upper(445)=(from=1305,to=1304)
+ to_upper(446)=(from=1307,to=1306)
+ to_upper(447)=(from=1309,to=1308)
+ to_upper(448)=(from=1311,to=1310)
+ to_upper(449)=(from=1313,to=1312)
+ to_upper(450)=(from=1315,to=1314)
+ to_upper(451)=(from=1317,to=1316)
+ to_upper(452)=(from=1319,to=1318)
+ to_upper(453)=(from=1321,to=1320)
+ to_upper(454)=(from=1323,to=1322)
+ to_upper(455)=(from=1325,to=1324)
+ to_upper(456)=(from=1327,to=1326)
+ to_upper(457)=(from=1377,to=1329)
+ to_upper(458)=(from=1378,to=1330)
+ to_upper(459)=(from=1379,to=1331)
+ to_upper(460)=(from=1380,to=1332)
+ to_upper(461)=(from=1381,to=1333)
+ to_upper(462)=(from=1382,to=1334)
+ to_upper(463)=(from=1383,to=1335)
+ to_upper(464)=(from=1384,to=1336)
+ to_upper(465)=(from=1385,to=1337)
+ to_upper(466)=(from=1386,to=1338)
+ to_upper(467)=(from=1387,to=1339)
+ to_upper(468)=(from=1388,to=1340)
+ to_upper(469)=(from=1389,to=1341)
+ to_upper(470)=(from=1390,to=1342)
+ to_upper(471)=(from=1391,to=1343)
+ to_upper(472)=(from=1392,to=1344)
+ to_upper(473)=(from=1393,to=1345)
+ to_upper(474)=(from=1394,to=1346)
+ to_upper(475)=(from=1395,to=1347)
+ to_upper(476)=(from=1396,to=1348)
+ to_upper(477)=(from=1397,to=1349)
+ to_upper(478)=(from=1398,to=1350)
+ to_upper(479)=(from=1399,to=1351)
+ to_upper(480)=(from=1400,to=1352)
+ to_upper(481)=(from=1401,to=1353)
+ to_upper(482)=(from=1402,to=1354)
+ to_upper(483)=(from=1403,to=1355)
+ to_upper(484)=(from=1404,to=1356)
+ to_upper(485)=(from=1405,to=1357)
+ to_upper(486)=(from=1406,to=1358)
+ to_upper(487)=(from=1407,to=1359)
+ to_upper(488)=(from=1408,to=1360)
+ to_upper(489)=(from=1409,to=1361)
+ to_upper(490)=(from=1410,to=1362)
+ to_upper(491)=(from=1411,to=1363)
+ to_upper(492)=(from=1412,to=1364)
+ to_upper(493)=(from=1413,to=1365)
+ to_upper(494)=(from=1414,to=1366)
+ to_upper(495)=(from=4304,to=7312)
+ to_upper(496)=(from=4305,to=7313)
+ to_upper(497)=(from=4306,to=7314)
+ to_upper(498)=(from=4307,to=7315)
+ to_upper(499)=(from=4308,to=7316)
+ to_upper(500)=(from=4309,to=7317)
+ to_upper(501)=(from=4310,to=7318)
+ to_upper(502)=(from=4311,to=7319)
+ to_upper(503)=(from=4312,to=7320)
+ to_upper(504)=(from=4313,to=7321)
+ to_upper(505)=(from=4314,to=7322)
+ to_upper(506)=(from=4315,to=7323)
+ to_upper(507)=(from=4316,to=7324)
+ to_upper(508)=(from=4317,to=7325)
+ to_upper(509)=(from=4318,to=7326)
+ to_upper(510)=(from=4319,to=7327)
+ to_upper(511)=(from=4320,to=7328)
+ to_upper(512)=(from=4321,to=7329)
+ to_upper(513)=(from=4322,to=7330)
+ to_upper(514)=(from=4323,to=7331)
+ to_upper(515)=(from=4324,to=7332)
+ to_upper(516)=(from=4325,to=7333)
+ to_upper(517)=(from=4326,to=7334)
+ to_upper(518)=(from=4327,to=7335)
+ to_upper(519)=(from=4328,to=7336)
+ to_upper(520)=(from=4329,to=7337)
+ to_upper(521)=(from=4330,to=7338)
+ to_upper(522)=(from=4331,to=7339)
+ to_upper(523)=(from=4332,to=7340)
+ to_upper(524)=(from=4333,to=7341)
+ to_upper(525)=(from=4334,to=7342)
+ to_upper(526)=(from=4335,to=7343)
+ to_upper(527)=(from=4336,to=7344)
+ to_upper(528)=(from=4337,to=7345)
+ to_upper(529)=(from=4338,to=7346)
+ to_upper(530)=(from=4339,to=7347)
+ to_upper(531)=(from=4340,to=7348)
+ to_upper(532)=(from=4341,to=7349)
+ to_upper(533)=(from=4342,to=7350)
+ to_upper(534)=(from=4343,to=7351)
+ to_upper(535)=(from=4344,to=7352)
+ to_upper(536)=(from=4345,to=7353)
+ to_upper(537)=(from=4346,to=7354)
+ to_upper(538)=(from=4349,to=7357)
+ to_upper(539)=(from=4350,to=7358)
+ to_upper(540)=(from=4351,to=7359)
+ to_upper(541)=(from=5112,to=5104)
+ to_upper(542)=(from=5113,to=5105)
+ to_upper(543)=(from=5114,to=5106)
+ to_upper(544)=(from=5115,to=5107)
+ to_upper(545)=(from=5116,to=5108)
+ to_upper(546)=(from=5117,to=5109)
+ to_upper(547)=(from=7296,to=1042)
+ to_upper(548)=(from=7297,to=1044)
+ to_upper(549)=(from=7298,to=1054)
+ to_upper(550)=(from=7299,to=1057)
+ to_upper(551)=(from=7300,to=1058)
+ to_upper(552)=(from=7301,to=1058)
+ to_upper(553)=(from=7302,to=1066)
+ to_upper(554)=(from=7303,to=1122)
+ to_upper(555)=(from=7304,to=42570)
+ to_upper(556)=(from=7545,to=42877)
+ to_upper(557)=(from=7549,to=11363)
+ to_upper(558)=(from=7566,to=42950)
+ to_upper(559)=(from=7681,to=7680)
+ to_upper(560)=(from=7683,to=7682)
+ to_upper(561)=(from=7685,to=7684)
+ to_upper(562)=(from=7687,to=7686)
+ to_upper(563)=(from=7689,to=7688)
+ to_upper(564)=(from=7691,to=7690)
+ to_upper(565)=(from=7693,to=7692)
+ to_upper(566)=(from=7695,to=7694)
+ to_upper(567)=(from=7697,to=7696)
+ to_upper(568)=(from=7699,to=7698)
+ to_upper(569)=(from=7701,to=7700)
+ to_upper(570)=(from=7703,to=7702)
+ to_upper(571)=(from=7705,to=7704)
+ to_upper(572)=(from=7707,to=7706)
+ to_upper(573)=(from=7709,to=7708)
+ to_upper(574)=(from=7711,to=7710)
+ to_upper(575)=(from=7713,to=7712)
+ to_upper(576)=(from=7715,to=7714)
+ to_upper(577)=(from=7717,to=7716)
+ to_upper(578)=(from=7719,to=7718)
+ to_upper(579)=(from=7721,to=7720)
+ to_upper(580)=(from=7723,to=7722)
+ to_upper(581)=(from=7725,to=7724)
+ to_upper(582)=(from=7727,to=7726)
+ to_upper(583)=(from=7729,to=7728)
+ to_upper(584)=(from=7731,to=7730)
+ to_upper(585)=(from=7733,to=7732)
+ to_upper(586)=(from=7735,to=7734)
+ to_upper(587)=(from=7737,to=7736)
+ to_upper(588)=(from=7739,to=7738)
+ to_upper(589)=(from=7741,to=7740)
+ to_upper(590)=(from=7743,to=7742)
+ to_upper(591)=(from=7745,to=7744)
+ to_upper(592)=(from=7747,to=7746)
+ to_upper(593)=(from=7749,to=7748)
+ to_upper(594)=(from=7751,to=7750)
+ to_upper(595)=(from=7753,to=7752)
+ to_upper(596)=(from=7755,to=7754)
+ to_upper(597)=(from=7757,to=7756)
+ to_upper(598)=(from=7759,to=7758)
+ to_upper(599)=(from=7761,to=7760)
+ to_upper(600)=(from=7763,to=7762)
+ to_upper(601)=(from=7765,to=7764)
+ to_upper(602)=(from=7767,to=7766)
+ to_upper(603)=(from=7769,to=7768)
+ to_upper(604)=(from=7771,to=7770)
+ to_upper(605)=(from=7773,to=7772)
+ to_upper(606)=(from=7775,to=7774)
+ to_upper(607)=(from=7777,to=7776)
+ to_upper(608)=(from=7779,to=7778)
+ to_upper(609)=(from=7781,to=7780)
+ to_upper(610)=(from=7783,to=7782)
+ to_upper(611)=(from=7785,to=7784)
+ to_upper(612)=(from=7787,to=7786)
+ to_upper(613)=(from=7789,to=7788)
+ to_upper(614)=(from=7791,to=7790)
+ to_upper(615)=(from=7793,to=7792)
+ to_upper(616)=(from=7795,to=7794)
+ to_upper(617)=(from=7797,to=7796)
+ to_upper(618)=(from=7799,to=7798)
+ to_upper(619)=(from=7801,to=7800)
+ to_upper(620)=(from=7803,to=7802)
+ to_upper(621)=(from=7805,to=7804)
+ to_upper(622)=(from=7807,to=7806)
+ to_upper(623)=(from=7809,to=7808)
+ to_upper(624)=(from=7811,to=7810)
+ to_upper(625)=(from=7813,to=7812)
+ to_upper(626)=(from=7815,to=7814)
+ to_upper(627)=(from=7817,to=7816)
+ to_upper(628)=(from=7819,to=7818)
+ to_upper(629)=(from=7821,to=7820)
+ to_upper(630)=(from=7823,to=7822)
+ to_upper(631)=(from=7825,to=7824)
+ to_upper(632)=(from=7827,to=7826)
+ to_upper(633)=(from=7829,to=7828)
+ to_upper(634)=(from=7835,to=7776)
+ to_upper(635)=(from=7841,to=7840)
+ to_upper(636)=(from=7843,to=7842)
+ to_upper(637)=(from=7845,to=7844)
+ to_upper(638)=(from=7847,to=7846)
+ to_upper(639)=(from=7849,to=7848)
+ to_upper(640)=(from=7851,to=7850)
+ to_upper(641)=(from=7853,to=7852)
+ to_upper(642)=(from=7855,to=7854)
+ to_upper(643)=(from=7857,to=7856)
+ to_upper(644)=(from=7859,to=7858)
+ to_upper(645)=(from=7861,to=7860)
+ to_upper(646)=(from=7863,to=7862)
+ to_upper(647)=(from=7865,to=7864)
+ to_upper(648)=(from=7867,to=7866)
+ to_upper(649)=(from=7869,to=7868)
+ to_upper(650)=(from=7871,to=7870)
+ to_upper(651)=(from=7873,to=7872)
+ to_upper(652)=(from=7875,to=7874)
+ to_upper(653)=(from=7877,to=7876)
+ to_upper(654)=(from=7879,to=7878)
+ to_upper(655)=(from=7881,to=7880)
+ to_upper(656)=(from=7883,to=7882)
+ to_upper(657)=(from=7885,to=7884)
+ to_upper(658)=(from=7887,to=7886)
+ to_upper(659)=(from=7889,to=7888)
+ to_upper(660)=(from=7891,to=7890)
+ to_upper(661)=(from=7893,to=7892)
+ to_upper(662)=(from=7895,to=7894)
+ to_upper(663)=(from=7897,to=7896)
+ to_upper(664)=(from=7899,to=7898)
+ to_upper(665)=(from=7901,to=7900)
+ to_upper(666)=(from=7903,to=7902)
+ to_upper(667)=(from=7905,to=7904)
+ to_upper(668)=(from=7907,to=7906)
+ to_upper(669)=(from=7909,to=7908)
+ to_upper(670)=(from=7911,to=7910)
+ to_upper(671)=(from=7913,to=7912)
+ to_upper(672)=(from=7915,to=7914)
+ to_upper(673)=(from=7917,to=7916)
+ to_upper(674)=(from=7919,to=7918)
+ to_upper(675)=(from=7921,to=7920)
+ to_upper(676)=(from=7923,to=7922)
+ to_upper(677)=(from=7925,to=7924)
+ to_upper(678)=(from=7927,to=7926)
+ to_upper(679)=(from=7929,to=7928)
+ to_upper(680)=(from=7931,to=7930)
+ to_upper(681)=(from=7933,to=7932)
+ to_upper(682)=(from=7935,to=7934)
+ to_upper(683)=(from=7936,to=7944)
+ to_upper(684)=(from=7937,to=7945)
+ to_upper(685)=(from=7938,to=7946)
+ to_upper(686)=(from=7939,to=7947)
+ to_upper(687)=(from=7940,to=7948)
+ to_upper(688)=(from=7941,to=7949)
+ to_upper(689)=(from=7942,to=7950)
+ to_upper(690)=(from=7943,to=7951)
+ to_upper(691)=(from=7952,to=7960)
+ to_upper(692)=(from=7953,to=7961)
+ to_upper(693)=(from=7954,to=7962)
+ to_upper(694)=(from=7955,to=7963)
+ to_upper(695)=(from=7956,to=7964)
+ to_upper(696)=(from=7957,to=7965)
+ to_upper(697)=(from=7968,to=7976)
+ to_upper(698)=(from=7969,to=7977)
+ to_upper(699)=(from=7970,to=7978)
+ to_upper(700)=(from=7971,to=7979)
+ to_upper(701)=(from=7972,to=7980)
+ to_upper(702)=(from=7973,to=7981)
+ to_upper(703)=(from=7974,to=7982)
+ to_upper(704)=(from=7975,to=7983)
+ to_upper(705)=(from=7984,to=7992)
+ to_upper(706)=(from=7985,to=7993)
+ to_upper(707)=(from=7986,to=7994)
+ to_upper(708)=(from=7987,to=7995)
+ to_upper(709)=(from=7988,to=7996)
+ to_upper(710)=(from=7989,to=7997)
+ to_upper(711)=(from=7990,to=7998)
+ to_upper(712)=(from=7991,to=7999)
+ to_upper(713)=(from=8000,to=8008)
+ to_upper(714)=(from=8001,to=8009)
+ to_upper(715)=(from=8002,to=8010)
+ to_upper(716)=(from=8003,to=8011)
+ to_upper(717)=(from=8004,to=8012)
+ to_upper(718)=(from=8005,to=8013)
+ to_upper(719)=(from=8017,to=8025)
+ to_upper(720)=(from=8019,to=8027)
+ to_upper(721)=(from=8021,to=8029)
+ to_upper(722)=(from=8023,to=8031)
+ to_upper(723)=(from=8032,to=8040)
+ to_upper(724)=(from=8033,to=8041)
+ to_upper(725)=(from=8034,to=8042)
+ to_upper(726)=(from=8035,to=8043)
+ to_upper(727)=(from=8036,to=8044)
+ to_upper(728)=(from=8037,to=8045)
+ to_upper(729)=(from=8038,to=8046)
+ to_upper(730)=(from=8039,to=8047)
+ to_upper(731)=(from=8048,to=8122)
+ to_upper(732)=(from=8049,to=8123)
+ to_upper(733)=(from=8050,to=8136)
+ to_upper(734)=(from=8051,to=8137)
+ to_upper(735)=(from=8052,to=8138)
+ to_upper(736)=(from=8053,to=8139)
+ to_upper(737)=(from=8054,to=8154)
+ to_upper(738)=(from=8055,to=8155)
+ to_upper(739)=(from=8056,to=8184)
+ to_upper(740)=(from=8057,to=8185)
+ to_upper(741)=(from=8058,to=8170)
+ to_upper(742)=(from=8059,to=8171)
+ to_upper(743)=(from=8060,to=8186)
+ to_upper(744)=(from=8061,to=8187)
+ to_upper(745)=(from=8064,to=8072)
+ to_upper(746)=(from=8065,to=8073)
+ to_upper(747)=(from=8066,to=8074)
+ to_upper(748)=(from=8067,to=8075)
+ to_upper(749)=(from=8068,to=8076)
+ to_upper(750)=(from=8069,to=8077)
+ to_upper(751)=(from=8070,to=8078)
+ to_upper(752)=(from=8071,to=8079)
+ to_upper(753)=(from=8080,to=8088)
+ to_upper(754)=(from=8081,to=8089)
+ to_upper(755)=(from=8082,to=8090)
+ to_upper(756)=(from=8083,to=8091)
+ to_upper(757)=(from=8084,to=8092)
+ to_upper(758)=(from=8085,to=8093)
+ to_upper(759)=(from=8086,to=8094)
+ to_upper(760)=(from=8087,to=8095)
+ to_upper(761)=(from=8096,to=8104)
+ to_upper(762)=(from=8097,to=8105)
+ to_upper(763)=(from=8098,to=8106)
+ to_upper(764)=(from=8099,to=8107)
+ to_upper(765)=(from=8100,to=8108)
+ to_upper(766)=(from=8101,to=8109)
+ to_upper(767)=(from=8102,to=8110)
+ to_upper(768)=(from=8103,to=8111)
+ to_upper(769)=(from=8112,to=8120)
+ to_upper(770)=(from=8113,to=8121)
+ to_upper(771)=(from=8115,to=8124)
+ to_upper(772)=(from=8126,to=921)
+ to_upper(773)=(from=8131,to=8140)
+ to_upper(774)=(from=8144,to=8152)
+ to_upper(775)=(from=8145,to=8153)
+ to_upper(776)=(from=8160,to=8168)
+ to_upper(777)=(from=8161,to=8169)
+ to_upper(778)=(from=8165,to=8172)
+ to_upper(779)=(from=8179,to=8188)
+ to_upper(780)=(from=8526,to=8498)
+ to_upper(781)=(from=8560,to=8544)
+ to_upper(782)=(from=8561,to=8545)
+ to_upper(783)=(from=8562,to=8546)
+ to_upper(784)=(from=8563,to=8547)
+ to_upper(785)=(from=8564,to=8548)
+ to_upper(786)=(from=8565,to=8549)
+ to_upper(787)=(from=8566,to=8550)
+ to_upper(788)=(from=8567,to=8551)
+ to_upper(789)=(from=8568,to=8552)
+ to_upper(790)=(from=8569,to=8553)
+ to_upper(791)=(from=8570,to=8554)
+ to_upper(792)=(from=8571,to=8555)
+ to_upper(793)=(from=8572,to=8556)
+ to_upper(794)=(from=8573,to=8557)
+ to_upper(795)=(from=8574,to=8558)
+ to_upper(796)=(from=8575,to=8559)
+ to_upper(797)=(from=8580,to=8579)
+ to_upper(798)=(from=9424,to=9398)
+ to_upper(799)=(from=9425,to=9399)
+ to_upper(800)=(from=9426,to=9400)
+ to_upper(801)=(from=9427,to=9401)
+ to_upper(802)=(from=9428,to=9402)
+ to_upper(803)=(from=9429,to=9403)
+ to_upper(804)=(from=9430,to=9404)
+ to_upper(805)=(from=9431,to=9405)
+ to_upper(806)=(from=9432,to=9406)
+ to_upper(807)=(from=9433,to=9407)
+ to_upper(808)=(from=9434,to=9408)
+ to_upper(809)=(from=9435,to=9409)
+ to_upper(810)=(from=9436,to=9410)
+ to_upper(811)=(from=9437,to=9411)
+ to_upper(812)=(from=9438,to=9412)
+ to_upper(813)=(from=9439,to=9413)
+ to_upper(814)=(from=9440,to=9414)
+ to_upper(815)=(from=9441,to=9415)
+ to_upper(816)=(from=9442,to=9416)
+ to_upper(817)=(from=9443,to=9417)
+ to_upper(818)=(from=9444,to=9418)
+ to_upper(819)=(from=9445,to=9419)
+ to_upper(820)=(from=9446,to=9420)
+ to_upper(821)=(from=9447,to=9421)
+ to_upper(822)=(from=9448,to=9422)
+ to_upper(823)=(from=9449,to=9423)
+ to_upper(824)=(from=11312,to=11264)
+ to_upper(825)=(from=11313,to=11265)
+ to_upper(826)=(from=11314,to=11266)
+ to_upper(827)=(from=11315,to=11267)
+ to_upper(828)=(from=11316,to=11268)
+ to_upper(829)=(from=11317,to=11269)
+ to_upper(830)=(from=11318,to=11270)
+ to_upper(831)=(from=11319,to=11271)
+ to_upper(832)=(from=11320,to=11272)
+ to_upper(833)=(from=11321,to=11273)
+ to_upper(834)=(from=11322,to=11274)
+ to_upper(835)=(from=11323,to=11275)
+ to_upper(836)=(from=11324,to=11276)
+ to_upper(837)=(from=11325,to=11277)
+ to_upper(838)=(from=11326,to=11278)
+ to_upper(839)=(from=11327,to=11279)
+ to_upper(840)=(from=11328,to=11280)
+ to_upper(841)=(from=11329,to=11281)
+ to_upper(842)=(from=11330,to=11282)
+ to_upper(843)=(from=11331,to=11283)
+ to_upper(844)=(from=11332,to=11284)
+ to_upper(845)=(from=11333,to=11285)
+ to_upper(846)=(from=11334,to=11286)
+ to_upper(847)=(from=11335,to=11287)
+ to_upper(848)=(from=11336,to=11288)
+ to_upper(849)=(from=11337,to=11289)
+ to_upper(850)=(from=11338,to=11290)
+ to_upper(851)=(from=11339,to=11291)
+ to_upper(852)=(from=11340,to=11292)
+ to_upper(853)=(from=11341,to=11293)
+ to_upper(854)=(from=11342,to=11294)
+ to_upper(855)=(from=11343,to=11295)
+ to_upper(856)=(from=11344,to=11296)
+ to_upper(857)=(from=11345,to=11297)
+ to_upper(858)=(from=11346,to=11298)
+ to_upper(859)=(from=11347,to=11299)
+ to_upper(860)=(from=11348,to=11300)
+ to_upper(861)=(from=11349,to=11301)
+ to_upper(862)=(from=11350,to=11302)
+ to_upper(863)=(from=11351,to=11303)
+ to_upper(864)=(from=11352,to=11304)
+ to_upper(865)=(from=11353,to=11305)
+ to_upper(866)=(from=11354,to=11306)
+ to_upper(867)=(from=11355,to=11307)
+ to_upper(868)=(from=11356,to=11308)
+ to_upper(869)=(from=11357,to=11309)
+ to_upper(870)=(from=11358,to=11310)
+ to_upper(871)=(from=11361,to=11360)
+ to_upper(872)=(from=11365,to=570)
+ to_upper(873)=(from=11366,to=574)
+ to_upper(874)=(from=11368,to=11367)
+ to_upper(875)=(from=11370,to=11369)
+ to_upper(876)=(from=11372,to=11371)
+ to_upper(877)=(from=11379,to=11378)
+ to_upper(878)=(from=11382,to=11381)
+ to_upper(879)=(from=11393,to=11392)
+ to_upper(880)=(from=11395,to=11394)
+ to_upper(881)=(from=11397,to=11396)
+ to_upper(882)=(from=11399,to=11398)
+ to_upper(883)=(from=11401,to=11400)
+ to_upper(884)=(from=11403,to=11402)
+ to_upper(885)=(from=11405,to=11404)
+ to_upper(886)=(from=11407,to=11406)
+ to_upper(887)=(from=11409,to=11408)
+ to_upper(888)=(from=11411,to=11410)
+ to_upper(889)=(from=11413,to=11412)
+ to_upper(890)=(from=11415,to=11414)
+ to_upper(891)=(from=11417,to=11416)
+ to_upper(892)=(from=11419,to=11418)
+ to_upper(893)=(from=11421,to=11420)
+ to_upper(894)=(from=11423,to=11422)
+ to_upper(895)=(from=11425,to=11424)
+ to_upper(896)=(from=11427,to=11426)
+ to_upper(897)=(from=11429,to=11428)
+ to_upper(898)=(from=11431,to=11430)
+ to_upper(899)=(from=11433,to=11432)
+ to_upper(900)=(from=11435,to=11434)
+ to_upper(901)=(from=11437,to=11436)
+ to_upper(902)=(from=11439,to=11438)
+ to_upper(903)=(from=11441,to=11440)
+ to_upper(904)=(from=11443,to=11442)
+ to_upper(905)=(from=11445,to=11444)
+ to_upper(906)=(from=11447,to=11446)
+ to_upper(907)=(from=11449,to=11448)
+ to_upper(908)=(from=11451,to=11450)
+ to_upper(909)=(from=11453,to=11452)
+ to_upper(910)=(from=11455,to=11454)
+ to_upper(911)=(from=11457,to=11456)
+ to_upper(912)=(from=11459,to=11458)
+ to_upper(913)=(from=11461,to=11460)
+ to_upper(914)=(from=11463,to=11462)
+ to_upper(915)=(from=11465,to=11464)
+ to_upper(916)=(from=11467,to=11466)
+ to_upper(917)=(from=11469,to=11468)
+ to_upper(918)=(from=11471,to=11470)
+ to_upper(919)=(from=11473,to=11472)
+ to_upper(920)=(from=11475,to=11474)
+ to_upper(921)=(from=11477,to=11476)
+ to_upper(922)=(from=11479,to=11478)
+ to_upper(923)=(from=11481,to=11480)
+ to_upper(924)=(from=11483,to=11482)
+ to_upper(925)=(from=11485,to=11484)
+ to_upper(926)=(from=11487,to=11486)
+ to_upper(927)=(from=11489,to=11488)
+ to_upper(928)=(from=11491,to=11490)
+ to_upper(929)=(from=11500,to=11499)
+ to_upper(930)=(from=11502,to=11501)
+ to_upper(931)=(from=11507,to=11506)
+ to_upper(932)=(from=11520,to=4256)
+ to_upper(933)=(from=11521,to=4257)
+ to_upper(934)=(from=11522,to=4258)
+ to_upper(935)=(from=11523,to=4259)
+ to_upper(936)=(from=11524,to=4260)
+ to_upper(937)=(from=11525,to=4261)
+ to_upper(938)=(from=11526,to=4262)
+ to_upper(939)=(from=11527,to=4263)
+ to_upper(940)=(from=11528,to=4264)
+ to_upper(941)=(from=11529,to=4265)
+ to_upper(942)=(from=11530,to=4266)
+ to_upper(943)=(from=11531,to=4267)
+ to_upper(944)=(from=11532,to=4268)
+ to_upper(945)=(from=11533,to=4269)
+ to_upper(946)=(from=11534,to=4270)
+ to_upper(947)=(from=11535,to=4271)
+ to_upper(948)=(from=11536,to=4272)
+ to_upper(949)=(from=11537,to=4273)
+ to_upper(950)=(from=11538,to=4274)
+ to_upper(951)=(from=11539,to=4275)
+ to_upper(952)=(from=11540,to=4276)
+ to_upper(953)=(from=11541,to=4277)
+ to_upper(954)=(from=11542,to=4278)
+ to_upper(955)=(from=11543,to=4279)
+ to_upper(956)=(from=11544,to=4280)
+ to_upper(957)=(from=11545,to=4281)
+ to_upper(958)=(from=11546,to=4282)
+ to_upper(959)=(from=11547,to=4283)
+ to_upper(960)=(from=11548,to=4284)
+ to_upper(961)=(from=11549,to=4285)
+ to_upper(962)=(from=11550,to=4286)
+ to_upper(963)=(from=11551,to=4287)
+ to_upper(964)=(from=11552,to=4288)
+ to_upper(965)=(from=11553,to=4289)
+ to_upper(966)=(from=11554,to=4290)
+ to_upper(967)=(from=11555,to=4291)
+ to_upper(968)=(from=11556,to=4292)
+ to_upper(969)=(from=11557,to=4293)
+ to_upper(970)=(from=11559,to=4295)
+ to_upper(971)=(from=11565,to=4301)
+ to_upper(972)=(from=42561,to=42560)
+ to_upper(973)=(from=42563,to=42562)
+ to_upper(974)=(from=42565,to=42564)
+ to_upper(975)=(from=42567,to=42566)
+ to_upper(976)=(from=42569,to=42568)
+ to_upper(977)=(from=42571,to=42570)
+ to_upper(978)=(from=42573,to=42572)
+ to_upper(979)=(from=42575,to=42574)
+ to_upper(980)=(from=42577,to=42576)
+ to_upper(981)=(from=42579,to=42578)
+ to_upper(982)=(from=42581,to=42580)
+ to_upper(983)=(from=42583,to=42582)
+ to_upper(984)=(from=42585,to=42584)
+ to_upper(985)=(from=42587,to=42586)
+ to_upper(986)=(from=42589,to=42588)
+ to_upper(987)=(from=42591,to=42590)
+ to_upper(988)=(from=42593,to=42592)
+ to_upper(989)=(from=42595,to=42594)
+ to_upper(990)=(from=42597,to=42596)
+ to_upper(991)=(from=42599,to=42598)
+ to_upper(992)=(from=42601,to=42600)
+ to_upper(993)=(from=42603,to=42602)
+ to_upper(994)=(from=42605,to=42604)
+ to_upper(995)=(from=42625,to=42624)
+ to_upper(996)=(from=42627,to=42626)
+ to_upper(997)=(from=42629,to=42628)
+ to_upper(998)=(from=42631,to=42630)
+ to_upper(999)=(from=42633,to=42632)
+ to_upper(1000)=(from=42635,to=42634)
+ to_upper(1001)=(from=42637,to=42636)
+ to_upper(1002)=(from=42639,to=42638)
+ to_upper(1003)=(from=42641,to=42640)
+ to_upper(1004)=(from=42643,to=42642)
+ to_upper(1005)=(from=42645,to=42644)
+ to_upper(1006)=(from=42647,to=42646)
+ to_upper(1007)=(from=42649,to=42648)
+ to_upper(1008)=(from=42651,to=42650)
+ to_upper(1009)=(from=42787,to=42786)
+ to_upper(1010)=(from=42789,to=42788)
+ to_upper(1011)=(from=42791,to=42790)
+ to_upper(1012)=(from=42793,to=42792)
+ to_upper(1013)=(from=42795,to=42794)
+ to_upper(1014)=(from=42797,to=42796)
+ to_upper(1015)=(from=42799,to=42798)
+ to_upper(1016)=(from=42803,to=42802)
+ to_upper(1017)=(from=42805,to=42804)
+ to_upper(1018)=(from=42807,to=42806)
+ to_upper(1019)=(from=42809,to=42808)
+ to_upper(1020)=(from=42811,to=42810)
+ to_upper(1021)=(from=42813,to=42812)
+ to_upper(1022)=(from=42815,to=42814)
+ to_upper(1023)=(from=42817,to=42816)
+ to_upper(1024)=(from=42819,to=42818)
+ to_upper(1025)=(from=42821,to=42820)
+ to_upper(1026)=(from=42823,to=42822)
+ to_upper(1027)=(from=42825,to=42824)
+ to_upper(1028)=(from=42827,to=42826)
+ to_upper(1029)=(from=42829,to=42828)
+ to_upper(1030)=(from=42831,to=42830)
+ to_upper(1031)=(from=42833,to=42832)
+ to_upper(1032)=(from=42835,to=42834)
+ to_upper(1033)=(from=42837,to=42836)
+ to_upper(1034)=(from=42839,to=42838)
+ to_upper(1035)=(from=42841,to=42840)
+ to_upper(1036)=(from=42843,to=42842)
+ to_upper(1037)=(from=42845,to=42844)
+ to_upper(1038)=(from=42847,to=42846)
+ to_upper(1039)=(from=42849,to=42848)
+ to_upper(1040)=(from=42851,to=42850)
+ to_upper(1041)=(from=42853,to=42852)
+ to_upper(1042)=(from=42855,to=42854)
+ to_upper(1043)=(from=42857,to=42856)
+ to_upper(1044)=(from=42859,to=42858)
+ to_upper(1045)=(from=42861,to=42860)
+ to_upper(1046)=(from=42863,to=42862)
+ to_upper(1047)=(from=42874,to=42873)
+ to_upper(1048)=(from=42876,to=42875)
+ to_upper(1049)=(from=42879,to=42878)
+ to_upper(1050)=(from=42881,to=42880)
+ to_upper(1051)=(from=42883,to=42882)
+ to_upper(1052)=(from=42885,to=42884)
+ to_upper(1053)=(from=42887,to=42886)
+ to_upper(1054)=(from=42892,to=42891)
+ to_upper(1055)=(from=42897,to=42896)
+ to_upper(1056)=(from=42899,to=42898)
+ to_upper(1057)=(from=42900,to=42948)
+ to_upper(1058)=(from=42903,to=42902)
+ to_upper(1059)=(from=42905,to=42904)
+ to_upper(1060)=(from=42907,to=42906)
+ to_upper(1061)=(from=42909,to=42908)
+ to_upper(1062)=(from=42911,to=42910)
+ to_upper(1063)=(from=42913,to=42912)
+ to_upper(1064)=(from=42915,to=42914)
+ to_upper(1065)=(from=42917,to=42916)
+ to_upper(1066)=(from=42919,to=42918)
+ to_upper(1067)=(from=42921,to=42920)
+ to_upper(1068)=(from=42933,to=42932)
+ to_upper(1069)=(from=42935,to=42934)
+ to_upper(1070)=(from=42937,to=42936)
+ to_upper(1071)=(from=42939,to=42938)
+ to_upper(1072)=(from=42941,to=42940)
+ to_upper(1073)=(from=42943,to=42942)
+ to_upper(1074)=(from=42947,to=42946)
+ to_upper(1075)=(from=42952,to=42951)
+ to_upper(1076)=(from=42954,to=42953)
+ to_upper(1077)=(from=42998,to=42997)
+ to_upper(1078)=(from=43859,to=42931)
+ to_upper(1079)=(from=43888,to=5024)
+ to_upper(1080)=(from=43889,to=5025)
+ to_upper(1081)=(from=43890,to=5026)
+ to_upper(1082)=(from=43891,to=5027)
+ to_upper(1083)=(from=43892,to=5028)
+ to_upper(1084)=(from=43893,to=5029)
+ to_upper(1085)=(from=43894,to=5030)
+ to_upper(1086)=(from=43895,to=5031)
+ to_upper(1087)=(from=43896,to=5032)
+ to_upper(1088)=(from=43897,to=5033)
+ to_upper(1089)=(from=43898,to=5034)
+ to_upper(1090)=(from=43899,to=5035)
+ to_upper(1091)=(from=43900,to=5036)
+ to_upper(1092)=(from=43901,to=5037)
+ to_upper(1093)=(from=43902,to=5038)
+ to_upper(1094)=(from=43903,to=5039)
+ to_upper(1095)=(from=43904,to=5040)
+ to_upper(1096)=(from=43905,to=5041)
+ to_upper(1097)=(from=43906,to=5042)
+ to_upper(1098)=(from=43907,to=5043)
+ to_upper(1099)=(from=43908,to=5044)
+ to_upper(1100)=(from=43909,to=5045)
+ to_upper(1101)=(from=43910,to=5046)
+ to_upper(1102)=(from=43911,to=5047)
+ to_upper(1103)=(from=43912,to=5048)
+ to_upper(1104)=(from=43913,to=5049)
+ to_upper(1105)=(from=43914,to=5050)
+ to_upper(1106)=(from=43915,to=5051)
+ to_upper(1107)=(from=43916,to=5052)
+ to_upper(1108)=(from=43917,to=5053)
+ to_upper(1109)=(from=43918,to=5054)
+ to_upper(1110)=(from=43919,to=5055)
+ to_upper(1111)=(from=43920,to=5056)
+ to_upper(1112)=(from=43921,to=5057)
+ to_upper(1113)=(from=43922,to=5058)
+ to_upper(1114)=(from=43923,to=5059)
+ to_upper(1115)=(from=43924,to=5060)
+ to_upper(1116)=(from=43925,to=5061)
+ to_upper(1117)=(from=43926,to=5062)
+ to_upper(1118)=(from=43927,to=5063)
+ to_upper(1119)=(from=43928,to=5064)
+ to_upper(1120)=(from=43929,to=5065)
+ to_upper(1121)=(from=43930,to=5066)
+ to_upper(1122)=(from=43931,to=5067)
+ to_upper(1123)=(from=43932,to=5068)
+ to_upper(1124)=(from=43933,to=5069)
+ to_upper(1125)=(from=43934,to=5070)
+ to_upper(1126)=(from=43935,to=5071)
+ to_upper(1127)=(from=43936,to=5072)
+ to_upper(1128)=(from=43937,to=5073)
+ to_upper(1129)=(from=43938,to=5074)
+ to_upper(1130)=(from=43939,to=5075)
+ to_upper(1131)=(from=43940,to=5076)
+ to_upper(1132)=(from=43941,to=5077)
+ to_upper(1133)=(from=43942,to=5078)
+ to_upper(1134)=(from=43943,to=5079)
+ to_upper(1135)=(from=43944,to=5080)
+ to_upper(1136)=(from=43945,to=5081)
+ to_upper(1137)=(from=43946,to=5082)
+ to_upper(1138)=(from=43947,to=5083)
+ to_upper(1139)=(from=43948,to=5084)
+ to_upper(1140)=(from=43949,to=5085)
+ to_upper(1141)=(from=43950,to=5086)
+ to_upper(1142)=(from=43951,to=5087)
+ to_upper(1143)=(from=43952,to=5088)
+ to_upper(1144)=(from=43953,to=5089)
+ to_upper(1145)=(from=43954,to=5090)
+ to_upper(1146)=(from=43955,to=5091)
+ to_upper(1147)=(from=43956,to=5092)
+ to_upper(1148)=(from=43957,to=5093)
+ to_upper(1149)=(from=43958,to=5094)
+ to_upper(1150)=(from=43959,to=5095)
+ to_upper(1151)=(from=43960,to=5096)
+ to_upper(1152)=(from=43961,to=5097)
+ to_upper(1153)=(from=43962,to=5098)
+ to_upper(1154)=(from=43963,to=5099)
+ to_upper(1155)=(from=43964,to=5100)
+ to_upper(1156)=(from=43965,to=5101)
+ to_upper(1157)=(from=43966,to=5102)
+ to_upper(1158)=(from=43967,to=5103)
+ to_upper(1159)=(from=65345,to=65313)
+ to_upper(1160)=(from=65346,to=65314)
+ to_upper(1161)=(from=65347,to=65315)
+ to_upper(1162)=(from=65348,to=65316)
+ to_upper(1163)=(from=65349,to=65317)
+ to_upper(1164)=(from=65350,to=65318)
+ to_upper(1165)=(from=65351,to=65319)
+ to_upper(1166)=(from=65352,to=65320)
+ to_upper(1167)=(from=65353,to=65321)
+ to_upper(1168)=(from=65354,to=65322)
+ to_upper(1169)=(from=65355,to=65323)
+ to_upper(1170)=(from=65356,to=65324)
+ to_upper(1171)=(from=65357,to=65325)
+ to_upper(1172)=(from=65358,to=65326)
+ to_upper(1173)=(from=65359,to=65327)
+ to_upper(1174)=(from=65360,to=65328)
+ to_upper(1175)=(from=65361,to=65329)
+ to_upper(1176)=(from=65362,to=65330)
+ to_upper(1177)=(from=65363,to=65331)
+ to_upper(1178)=(from=65364,to=65332)
+ to_upper(1179)=(from=65365,to=65333)
+ to_upper(1180)=(from=65366,to=65334)
+ to_upper(1181)=(from=65367,to=65335)
+ to_upper(1182)=(from=65368,to=65336)
+ to_upper(1183)=(from=65369,to=65337)
+ to_upper(1184)=(from=65370,to=65338)
+ to_upper(1185)=(from=66600,to=66560)
+ to_upper(1186)=(from=66601,to=66561)
+ to_upper(1187)=(from=66602,to=66562)
+ to_upper(1188)=(from=66603,to=66563)
+ to_upper(1189)=(from=66604,to=66564)
+ to_upper(1190)=(from=66605,to=66565)
+ to_upper(1191)=(from=66606,to=66566)
+ to_upper(1192)=(from=66607,to=66567)
+ to_upper(1193)=(from=66608,to=66568)
+ to_upper(1194)=(from=66609,to=66569)
+ to_upper(1195)=(from=66610,to=66570)
+ to_upper(1196)=(from=66611,to=66571)
+ to_upper(1197)=(from=66612,to=66572)
+ to_upper(1198)=(from=66613,to=66573)
+ to_upper(1199)=(from=66614,to=66574)
+ to_upper(1200)=(from=66615,to=66575)
+ to_upper(1201)=(from=66616,to=66576)
+ to_upper(1202)=(from=66617,to=66577)
+ to_upper(1203)=(from=66618,to=66578)
+ to_upper(1204)=(from=66619,to=66579)
+ to_upper(1205)=(from=66620,to=66580)
+ to_upper(1206)=(from=66621,to=66581)
+ to_upper(1207)=(from=66622,to=66582)
+ to_upper(1208)=(from=66623,to=66583)
+ to_upper(1209)=(from=66624,to=66584)
+ to_upper(1210)=(from=66625,to=66585)
+ to_upper(1211)=(from=66626,to=66586)
+ to_upper(1212)=(from=66627,to=66587)
+ to_upper(1213)=(from=66628,to=66588)
+ to_upper(1214)=(from=66629,to=66589)
+ to_upper(1215)=(from=66630,to=66590)
+ to_upper(1216)=(from=66631,to=66591)
+ to_upper(1217)=(from=66632,to=66592)
+ to_upper(1218)=(from=66633,to=66593)
+ to_upper(1219)=(from=66634,to=66594)
+ to_upper(1220)=(from=66635,to=66595)
+ to_upper(1221)=(from=66636,to=66596)
+ to_upper(1222)=(from=66637,to=66597)
+ to_upper(1223)=(from=66638,to=66598)
+ to_upper(1224)=(from=66639,to=66599)
+ to_upper(1225)=(from=66776,to=66736)
+ to_upper(1226)=(from=66777,to=66737)
+ to_upper(1227)=(from=66778,to=66738)
+ to_upper(1228)=(from=66779,to=66739)
+ to_upper(1229)=(from=66780,to=66740)
+ to_upper(1230)=(from=66781,to=66741)
+ to_upper(1231)=(from=66782,to=66742)
+ to_upper(1232)=(from=66783,to=66743)
+ to_upper(1233)=(from=66784,to=66744)
+ to_upper(1234)=(from=66785,to=66745)
+ to_upper(1235)=(from=66786,to=66746)
+ to_upper(1236)=(from=66787,to=66747)
+ to_upper(1237)=(from=66788,to=66748)
+ to_upper(1238)=(from=66789,to=66749)
+ to_upper(1239)=(from=66790,to=66750)
+ to_upper(1240)=(from=66791,to=66751)
+ to_upper(1241)=(from=66792,to=66752)
+ to_upper(1242)=(from=66793,to=66753)
+ to_upper(1243)=(from=66794,to=66754)
+ to_upper(1244)=(from=66795,to=66755)
+ to_upper(1245)=(from=66796,to=66756)
+ to_upper(1246)=(from=66797,to=66757)
+ to_upper(1247)=(from=66798,to=66758)
+ to_upper(1248)=(from=66799,to=66759)
+ to_upper(1249)=(from=66800,to=66760)
+ to_upper(1250)=(from=66801,to=66761)
+ to_upper(1251)=(from=66802,to=66762)
+ to_upper(1252)=(from=66803,to=66763)
+ to_upper(1253)=(from=66804,to=66764)
+ to_upper(1254)=(from=66805,to=66765)
+ to_upper(1255)=(from=66806,to=66766)
+ to_upper(1256)=(from=66807,to=66767)
+ to_upper(1257)=(from=66808,to=66768)
+ to_upper(1258)=(from=66809,to=66769)
+ to_upper(1259)=(from=66810,to=66770)
+ to_upper(1260)=(from=66811,to=66771)
+ to_upper(1261)=(from=68800,to=68736)
+ to_upper(1262)=(from=68801,to=68737)
+ to_upper(1263)=(from=68802,to=68738)
+ to_upper(1264)=(from=68803,to=68739)
+ to_upper(1265)=(from=68804,to=68740)
+ to_upper(1266)=(from=68805,to=68741)
+ to_upper(1267)=(from=68806,to=68742)
+ to_upper(1268)=(from=68807,to=68743)
+ to_upper(1269)=(from=68808,to=68744)
+ to_upper(1270)=(from=68809,to=68745)
+ to_upper(1271)=(from=68810,to=68746)
+ to_upper(1272)=(from=68811,to=68747)
+ to_upper(1273)=(from=68812,to=68748)
+ to_upper(1274)=(from=68813,to=68749)
+ to_upper(1275)=(from=68814,to=68750)
+ to_upper(1276)=(from=68815,to=68751)
+ to_upper(1277)=(from=68816,to=68752)
+ to_upper(1278)=(from=68817,to=68753)
+ to_upper(1279)=(from=68818,to=68754)
+ to_upper(1280)=(from=68819,to=68755)
+ to_upper(1281)=(from=68820,to=68756)
+ to_upper(1282)=(from=68821,to=68757)
+ to_upper(1283)=(from=68822,to=68758)
+ to_upper(1284)=(from=68823,to=68759)
+ to_upper(1285)=(from=68824,to=68760)
+ to_upper(1286)=(from=68825,to=68761)
+ to_upper(1287)=(from=68826,to=68762)
+ to_upper(1288)=(from=68827,to=68763)
+ to_upper(1289)=(from=68828,to=68764)
+ to_upper(1290)=(from=68829,to=68765)
+ to_upper(1291)=(from=68830,to=68766)
+ to_upper(1292)=(from=68831,to=68767)
+ to_upper(1293)=(from=68832,to=68768)
+ to_upper(1294)=(from=68833,to=68769)
+ to_upper(1295)=(from=68834,to=68770)
+ to_upper(1296)=(from=68835,to=68771)
+ to_upper(1297)=(from=68836,to=68772)
+ to_upper(1298)=(from=68837,to=68773)
+ to_upper(1299)=(from=68838,to=68774)
+ to_upper(1300)=(from=68839,to=68775)
+ to_upper(1301)=(from=68840,to=68776)
+ to_upper(1302)=(from=68841,to=68777)
+ to_upper(1303)=(from=68842,to=68778)
+ to_upper(1304)=(from=68843,to=68779)
+ to_upper(1305)=(from=68844,to=68780)
+ to_upper(1306)=(from=68845,to=68781)
+ to_upper(1307)=(from=68846,to=68782)
+ to_upper(1308)=(from=68847,to=68783)
+ to_upper(1309)=(from=68848,to=68784)
+ to_upper(1310)=(from=68849,to=68785)
+ to_upper(1311)=(from=68850,to=68786)
+ to_upper(1312)=(from=71872,to=71840)
+ to_upper(1313)=(from=71873,to=71841)
+ to_upper(1314)=(from=71874,to=71842)
+ to_upper(1315)=(from=71875,to=71843)
+ to_upper(1316)=(from=71876,to=71844)
+ to_upper(1317)=(from=71877,to=71845)
+ to_upper(1318)=(from=71878,to=71846)
+ to_upper(1319)=(from=71879,to=71847)
+ to_upper(1320)=(from=71880,to=71848)
+ to_upper(1321)=(from=71881,to=71849)
+ to_upper(1322)=(from=71882,to=71850)
+ to_upper(1323)=(from=71883,to=71851)
+ to_upper(1324)=(from=71884,to=71852)
+ to_upper(1325)=(from=71885,to=71853)
+ to_upper(1326)=(from=71886,to=71854)
+ to_upper(1327)=(from=71887,to=71855)
+ to_upper(1328)=(from=71888,to=71856)
+ to_upper(1329)=(from=71889,to=71857)
+ to_upper(1330)=(from=71890,to=71858)
+ to_upper(1331)=(from=71891,to=71859)
+ to_upper(1332)=(from=71892,to=71860)
+ to_upper(1333)=(from=71893,to=71861)
+ to_upper(1334)=(from=71894,to=71862)
+ to_upper(1335)=(from=71895,to=71863)
+ to_upper(1336)=(from=71896,to=71864)
+ to_upper(1337)=(from=71897,to=71865)
+ to_upper(1338)=(from=71898,to=71866)
+ to_upper(1339)=(from=71899,to=71867)
+ to_upper(1340)=(from=71900,to=71868)
+ to_upper(1341)=(from=71901,to=71869)
+ to_upper(1342)=(from=71902,to=71870)
+ to_upper(1343)=(from=71903,to=71871)
+ to_upper(1344)=(from=93792,to=93760)
+ to_upper(1345)=(from=93793,to=93761)
+ to_upper(1346)=(from=93794,to=93762)
+ to_upper(1347)=(from=93795,to=93763)
+ to_upper(1348)=(from=93796,to=93764)
+ to_upper(1349)=(from=93797,to=93765)
+ to_upper(1350)=(from=93798,to=93766)
+ to_upper(1351)=(from=93799,to=93767)
+ to_upper(1352)=(from=93800,to=93768)
+ to_upper(1353)=(from=93801,to=93769)
+ to_upper(1354)=(from=93802,to=93770)
+ to_upper(1355)=(from=93803,to=93771)
+ to_upper(1356)=(from=93804,to=93772)
+ to_upper(1357)=(from=93805,to=93773)
+ to_upper(1358)=(from=93806,to=93774)
+ to_upper(1359)=(from=93807,to=93775)
+ to_upper(1360)=(from=93808,to=93776)
+ to_upper(1361)=(from=93809,to=93777)
+ to_upper(1362)=(from=93810,to=93778)
+ to_upper(1363)=(from=93811,to=93779)
+ to_upper(1364)=(from=93812,to=93780)
+ to_upper(1365)=(from=93813,to=93781)
+ to_upper(1366)=(from=93814,to=93782)
+ to_upper(1367)=(from=93815,to=93783)
+ to_upper(1368)=(from=93816,to=93784)
+ to_upper(1369)=(from=93817,to=93785)
+ to_upper(1370)=(from=93818,to=93786)
+ to_upper(1371)=(from=93819,to=93787)
+ to_upper(1372)=(from=93820,to=93788)
+ to_upper(1373)=(from=93821,to=93789)
+ to_upper(1374)=(from=93822,to=93790)
+ to_upper(1375)=(from=93823,to=93791)
+ to_upper(1376)=(from=125218,to=125184)
+ to_upper(1377)=(from=125219,to=125185)
+ to_upper(1378)=(from=125220,to=125186)
+ to_upper(1379)=(from=125221,to=125187)
+ to_upper(1380)=(from=125222,to=125188)
+ to_upper(1381)=(from=125223,to=125189)
+ to_upper(1382)=(from=125224,to=125190)
+ to_upper(1383)=(from=125225,to=125191)
+ to_upper(1384)=(from=125226,to=125192)
+ to_upper(1385)=(from=125227,to=125193)
+ to_upper(1386)=(from=125228,to=125194)
+ to_upper(1387)=(from=125229,to=125195)
+ to_upper(1388)=(from=125230,to=125196)
+ to_upper(1389)=(from=125231,to=125197)
+ to_upper(1390)=(from=125232,to=125198)
+ to_upper(1391)=(from=125233,to=125199)
+ to_upper(1392)=(from=125234,to=125200)
+ to_upper(1393)=(from=125235,to=125201)
+ to_upper(1394)=(from=125236,to=125202)
+ to_upper(1395)=(from=125237,to=125203)
+ to_upper(1396)=(from=125238,to=125204)
+ to_upper(1397)=(from=125239,to=125205)
+ to_upper(1398)=(from=125240,to=125206)
+ to_upper(1399)=(from=125241,to=125207)
+ to_upper(1400)=(from=125242,to=125208)
+ to_upper(1401)=(from=125243,to=125209)
+ to_upper(1402)=(from=125244,to=125210)
+ to_upper(1403)=(from=125245,to=125211)
+ to_upper(1404)=(from=125246,to=125212)
+ to_upper(1405)=(from=125247,to=125213)
+ to_upper(1406)=(from=125248,to=125214)
+ to_upper(1407)=(from=125249,to=125215)
+ to_upper(1408)=(from=125250,to=125216)
+ to_upper(1409)=(from=125251,to=125217)
+ to_title(0)=(from=97,to=65)
+ to_title(1)=(from=98,to=66)
+ to_title(2)=(from=99,to=67)
+ to_title(3)=(from=100,to=68)
+ to_title(4)=(from=101,to=69)
+ to_title(5)=(from=102,to=70)
+ to_title(6)=(from=103,to=71)
+ to_title(7)=(from=104,to=72)
+ to_title(8)=(from=105,to=73)
+ to_title(9)=(from=106,to=74)
+ to_title(10)=(from=107,to=75)
+ to_title(11)=(from=108,to=76)
+ to_title(12)=(from=109,to=77)
+ to_title(13)=(from=110,to=78)
+ to_title(14)=(from=111,to=79)
+ to_title(15)=(from=112,to=80)
+ to_title(16)=(from=113,to=81)
+ to_title(17)=(from=114,to=82)
+ to_title(18)=(from=115,to=83)
+ to_title(19)=(from=116,to=84)
+ to_title(20)=(from=117,to=85)
+ to_title(21)=(from=118,to=86)
+ to_title(22)=(from=119,to=87)
+ to_title(23)=(from=120,to=88)
+ to_title(24)=(from=121,to=89)
+ to_title(25)=(from=122,to=90)
+ to_title(26)=(from=181,to=924)
+ to_title(27)=(from=224,to=192)
+ to_title(28)=(from=225,to=193)
+ to_title(29)=(from=226,to=194)
+ to_title(30)=(from=227,to=195)
+ to_title(31)=(from=228,to=196)
+ to_title(32)=(from=229,to=197)
+ to_title(33)=(from=230,to=198)
+ to_title(34)=(from=231,to=199)
+ to_title(35)=(from=232,to=200)
+ to_title(36)=(from=233,to=201)
+ to_title(37)=(from=234,to=202)
+ to_title(38)=(from=235,to=203)
+ to_title(39)=(from=236,to=204)
+ to_title(40)=(from=237,to=205)
+ to_title(41)=(from=238,to=206)
+ to_title(42)=(from=239,to=207)
+ to_title(43)=(from=240,to=208)
+ to_title(44)=(from=241,to=209)
+ to_title(45)=(from=242,to=210)
+ to_title(46)=(from=243,to=211)
+ to_title(47)=(from=244,to=212)
+ to_title(48)=(from=245,to=213)
+ to_title(49)=(from=246,to=214)
+ to_title(50)=(from=248,to=216)
+ to_title(51)=(from=249,to=217)
+ to_title(52)=(from=250,to=218)
+ to_title(53)=(from=251,to=219)
+ to_title(54)=(from=252,to=220)
+ to_title(55)=(from=253,to=221)
+ to_title(56)=(from=254,to=222)
+ to_title(57)=(from=255,to=376)
+ to_title(58)=(from=257,to=256)
+ to_title(59)=(from=259,to=258)
+ to_title(60)=(from=261,to=260)
+ to_title(61)=(from=263,to=262)
+ to_title(62)=(from=265,to=264)
+ to_title(63)=(from=267,to=266)
+ to_title(64)=(from=269,to=268)
+ to_title(65)=(from=271,to=270)
+ to_title(66)=(from=273,to=272)
+ to_title(67)=(from=275,to=274)
+ to_title(68)=(from=277,to=276)
+ to_title(69)=(from=279,to=278)
+ to_title(70)=(from=281,to=280)
+ to_title(71)=(from=283,to=282)
+ to_title(72)=(from=285,to=284)
+ to_title(73)=(from=287,to=286)
+ to_title(74)=(from=289,to=288)
+ to_title(75)=(from=291,to=290)
+ to_title(76)=(from=293,to=292)
+ to_title(77)=(from=295,to=294)
+ to_title(78)=(from=297,to=296)
+ to_title(79)=(from=299,to=298)
+ to_title(80)=(from=301,to=300)
+ to_title(81)=(from=303,to=302)
+ to_title(82)=(from=305,to=73)
+ to_title(83)=(from=307,to=306)
+ to_title(84)=(from=309,to=308)
+ to_title(85)=(from=311,to=310)
+ to_title(86)=(from=314,to=313)
+ to_title(87)=(from=316,to=315)
+ to_title(88)=(from=318,to=317)
+ to_title(89)=(from=320,to=319)
+ to_title(90)=(from=322,to=321)
+ to_title(91)=(from=324,to=323)
+ to_title(92)=(from=326,to=325)
+ to_title(93)=(from=328,to=327)
+ to_title(94)=(from=331,to=330)
+ to_title(95)=(from=333,to=332)
+ to_title(96)=(from=335,to=334)
+ to_title(97)=(from=337,to=336)
+ to_title(98)=(from=339,to=338)
+ to_title(99)=(from=341,to=340)
+ to_title(100)=(from=343,to=342)
+ to_title(101)=(from=345,to=344)
+ to_title(102)=(from=347,to=346)
+ to_title(103)=(from=349,to=348)
+ to_title(104)=(from=351,to=350)
+ to_title(105)=(from=353,to=352)
+ to_title(106)=(from=355,to=354)
+ to_title(107)=(from=357,to=356)
+ to_title(108)=(from=359,to=358)
+ to_title(109)=(from=361,to=360)
+ to_title(110)=(from=363,to=362)
+ to_title(111)=(from=365,to=364)
+ to_title(112)=(from=367,to=366)
+ to_title(113)=(from=369,to=368)
+ to_title(114)=(from=371,to=370)
+ to_title(115)=(from=373,to=372)
+ to_title(116)=(from=375,to=374)
+ to_title(117)=(from=378,to=377)
+ to_title(118)=(from=380,to=379)
+ to_title(119)=(from=382,to=381)
+ to_title(120)=(from=383,to=83)
+ to_title(121)=(from=384,to=579)
+ to_title(122)=(from=387,to=386)
+ to_title(123)=(from=389,to=388)
+ to_title(124)=(from=392,to=391)
+ to_title(125)=(from=396,to=395)
+ to_title(126)=(from=402,to=401)
+ to_title(127)=(from=405,to=502)
+ to_title(128)=(from=409,to=408)
+ to_title(129)=(from=410,to=573)
+ to_title(130)=(from=414,to=544)
+ to_title(131)=(from=417,to=416)
+ to_title(132)=(from=419,to=418)
+ to_title(133)=(from=421,to=420)
+ to_title(134)=(from=424,to=423)
+ to_title(135)=(from=429,to=428)
+ to_title(136)=(from=432,to=431)
+ to_title(137)=(from=436,to=435)
+ to_title(138)=(from=438,to=437)
+ to_title(139)=(from=441,to=440)
+ to_title(140)=(from=445,to=444)
+ to_title(141)=(from=447,to=503)
+ to_title(142)=(from=452,to=453)
+ to_title(143)=(from=453,to=453)
+ to_title(144)=(from=454,to=453)
+ to_title(145)=(from=455,to=456)
+ to_title(146)=(from=456,to=456)
+ to_title(147)=(from=457,to=456)
+ to_title(148)=(from=458,to=459)
+ to_title(149)=(from=459,to=459)
+ to_title(150)=(from=460,to=459)
+ to_title(151)=(from=462,to=461)
+ to_title(152)=(from=464,to=463)
+ to_title(153)=(from=466,to=465)
+ to_title(154)=(from=468,to=467)
+ to_title(155)=(from=470,to=469)
+ to_title(156)=(from=472,to=471)
+ to_title(157)=(from=474,to=473)
+ to_title(158)=(from=476,to=475)
+ to_title(159)=(from=477,to=398)
+ to_title(160)=(from=479,to=478)
+ to_title(161)=(from=481,to=480)
+ to_title(162)=(from=483,to=482)
+ to_title(163)=(from=485,to=484)
+ to_title(164)=(from=487,to=486)
+ to_title(165)=(from=489,to=488)
+ to_title(166)=(from=491,to=490)
+ to_title(167)=(from=493,to=492)
+ to_title(168)=(from=495,to=494)
+ to_title(169)=(from=497,to=498)
+ to_title(170)=(from=498,to=498)
+ to_title(171)=(from=499,to=498)
+ to_title(172)=(from=501,to=500)
+ to_title(173)=(from=505,to=504)
+ to_title(174)=(from=507,to=506)
+ to_title(175)=(from=509,to=508)
+ to_title(176)=(from=511,to=510)
+ to_title(177)=(from=513,to=512)
+ to_title(178)=(from=515,to=514)
+ to_title(179)=(from=517,to=516)
+ to_title(180)=(from=519,to=518)
+ to_title(181)=(from=521,to=520)
+ to_title(182)=(from=523,to=522)
+ to_title(183)=(from=525,to=524)
+ to_title(184)=(from=527,to=526)
+ to_title(185)=(from=529,to=528)
+ to_title(186)=(from=531,to=530)
+ to_title(187)=(from=533,to=532)
+ to_title(188)=(from=535,to=534)
+ to_title(189)=(from=537,to=536)
+ to_title(190)=(from=539,to=538)
+ to_title(191)=(from=541,to=540)
+ to_title(192)=(from=543,to=542)
+ to_title(193)=(from=547,to=546)
+ to_title(194)=(from=549,to=548)
+ to_title(195)=(from=551,to=550)
+ to_title(196)=(from=553,to=552)
+ to_title(197)=(from=555,to=554)
+ to_title(198)=(from=557,to=556)
+ to_title(199)=(from=559,to=558)
+ to_title(200)=(from=561,to=560)
+ to_title(201)=(from=563,to=562)
+ to_title(202)=(from=572,to=571)
+ to_title(203)=(from=575,to=11390)
+ to_title(204)=(from=576,to=11391)
+ to_title(205)=(from=578,to=577)
+ to_title(206)=(from=583,to=582)
+ to_title(207)=(from=585,to=584)
+ to_title(208)=(from=587,to=586)
+ to_title(209)=(from=589,to=588)
+ to_title(210)=(from=591,to=590)
+ to_title(211)=(from=592,to=11375)
+ to_title(212)=(from=593,to=11373)
+ to_title(213)=(from=594,to=11376)
+ to_title(214)=(from=595,to=385)
+ to_title(215)=(from=596,to=390)
+ to_title(216)=(from=598,to=393)
+ to_title(217)=(from=599,to=394)
+ to_title(218)=(from=601,to=399)
+ to_title(219)=(from=603,to=400)
+ to_title(220)=(from=604,to=42923)
+ to_title(221)=(from=608,to=403)
+ to_title(222)=(from=609,to=42924)
+ to_title(223)=(from=611,to=404)
+ to_title(224)=(from=613,to=42893)
+ to_title(225)=(from=614,to=42922)
+ to_title(226)=(from=616,to=407)
+ to_title(227)=(from=617,to=406)
+ to_title(228)=(from=618,to=42926)
+ to_title(229)=(from=619,to=11362)
+ to_title(230)=(from=620,to=42925)
+ to_title(231)=(from=623,to=412)
+ to_title(232)=(from=625,to=11374)
+ to_title(233)=(from=626,to=413)
+ to_title(234)=(from=629,to=415)
+ to_title(235)=(from=637,to=11364)
+ to_title(236)=(from=640,to=422)
+ to_title(237)=(from=642,to=42949)
+ to_title(238)=(from=643,to=425)
+ to_title(239)=(from=647,to=42929)
+ to_title(240)=(from=648,to=430)
+ to_title(241)=(from=649,to=580)
+ to_title(242)=(from=650,to=433)
+ to_title(243)=(from=651,to=434)
+ to_title(244)=(from=652,to=581)
+ to_title(245)=(from=658,to=439)
+ to_title(246)=(from=669,to=42930)
+ to_title(247)=(from=670,to=42928)
+ to_title(248)=(from=837,to=921)
+ to_title(249)=(from=881,to=880)
+ to_title(250)=(from=883,to=882)
+ to_title(251)=(from=887,to=886)
+ to_title(252)=(from=891,to=1021)
+ to_title(253)=(from=892,to=1022)
+ to_title(254)=(from=893,to=1023)
+ to_title(255)=(from=940,to=902)
+ to_title(256)=(from=941,to=904)
+ to_title(257)=(from=942,to=905)
+ to_title(258)=(from=943,to=906)
+ to_title(259)=(from=945,to=913)
+ to_title(260)=(from=946,to=914)
+ to_title(261)=(from=947,to=915)
+ to_title(262)=(from=948,to=916)
+ to_title(263)=(from=949,to=917)
+ to_title(264)=(from=950,to=918)
+ to_title(265)=(from=951,to=919)
+ to_title(266)=(from=952,to=920)
+ to_title(267)=(from=953,to=921)
+ to_title(268)=(from=954,to=922)
+ to_title(269)=(from=955,to=923)
+ to_title(270)=(from=956,to=924)
+ to_title(271)=(from=957,to=925)
+ to_title(272)=(from=958,to=926)
+ to_title(273)=(from=959,to=927)
+ to_title(274)=(from=960,to=928)
+ to_title(275)=(from=961,to=929)
+ to_title(276)=(from=962,to=931)
+ to_title(277)=(from=963,to=931)
+ to_title(278)=(from=964,to=932)
+ to_title(279)=(from=965,to=933)
+ to_title(280)=(from=966,to=934)
+ to_title(281)=(from=967,to=935)
+ to_title(282)=(from=968,to=936)
+ to_title(283)=(from=969,to=937)
+ to_title(284)=(from=970,to=938)
+ to_title(285)=(from=971,to=939)
+ to_title(286)=(from=972,to=908)
+ to_title(287)=(from=973,to=910)
+ to_title(288)=(from=974,to=911)
+ to_title(289)=(from=976,to=914)
+ to_title(290)=(from=977,to=920)
+ to_title(291)=(from=981,to=934)
+ to_title(292)=(from=982,to=928)
+ to_title(293)=(from=983,to=975)
+ to_title(294)=(from=985,to=984)
+ to_title(295)=(from=987,to=986)
+ to_title(296)=(from=989,to=988)
+ to_title(297)=(from=991,to=990)
+ to_title(298)=(from=993,to=992)
+ to_title(299)=(from=995,to=994)
+ to_title(300)=(from=997,to=996)
+ to_title(301)=(from=999,to=998)
+ to_title(302)=(from=1001,to=1000)
+ to_title(303)=(from=1003,to=1002)
+ to_title(304)=(from=1005,to=1004)
+ to_title(305)=(from=1007,to=1006)
+ to_title(306)=(from=1008,to=922)
+ to_title(307)=(from=1009,to=929)
+ to_title(308)=(from=1010,to=1017)
+ to_title(309)=(from=1011,to=895)
+ to_title(310)=(from=1013,to=917)
+ to_title(311)=(from=1016,to=1015)
+ to_title(312)=(from=1019,to=1018)
+ to_title(313)=(from=1072,to=1040)
+ to_title(314)=(from=1073,to=1041)
+ to_title(315)=(from=1074,to=1042)
+ to_title(316)=(from=1075,to=1043)
+ to_title(317)=(from=1076,to=1044)
+ to_title(318)=(from=1077,to=1045)
+ to_title(319)=(from=1078,to=1046)
+ to_title(320)=(from=1079,to=1047)
+ to_title(321)=(from=1080,to=1048)
+ to_title(322)=(from=1081,to=1049)
+ to_title(323)=(from=1082,to=1050)
+ to_title(324)=(from=1083,to=1051)
+ to_title(325)=(from=1084,to=1052)
+ to_title(326)=(from=1085,to=1053)
+ to_title(327)=(from=1086,to=1054)
+ to_title(328)=(from=1087,to=1055)
+ to_title(329)=(from=1088,to=1056)
+ to_title(330)=(from=1089,to=1057)
+ to_title(331)=(from=1090,to=1058)
+ to_title(332)=(from=1091,to=1059)
+ to_title(333)=(from=1092,to=1060)
+ to_title(334)=(from=1093,to=1061)
+ to_title(335)=(from=1094,to=1062)
+ to_title(336)=(from=1095,to=1063)
+ to_title(337)=(from=1096,to=1064)
+ to_title(338)=(from=1097,to=1065)
+ to_title(339)=(from=1098,to=1066)
+ to_title(340)=(from=1099,to=1067)
+ to_title(341)=(from=1100,to=1068)
+ to_title(342)=(from=1101,to=1069)
+ to_title(343)=(from=1102,to=1070)
+ to_title(344)=(from=1103,to=1071)
+ to_title(345)=(from=1104,to=1024)
+ to_title(346)=(from=1105,to=1025)
+ to_title(347)=(from=1106,to=1026)
+ to_title(348)=(from=1107,to=1027)
+ to_title(349)=(from=1108,to=1028)
+ to_title(350)=(from=1109,to=1029)
+ to_title(351)=(from=1110,to=1030)
+ to_title(352)=(from=1111,to=1031)
+ to_title(353)=(from=1112,to=1032)
+ to_title(354)=(from=1113,to=1033)
+ to_title(355)=(from=1114,to=1034)
+ to_title(356)=(from=1115,to=1035)
+ to_title(357)=(from=1116,to=1036)
+ to_title(358)=(from=1117,to=1037)
+ to_title(359)=(from=1118,to=1038)
+ to_title(360)=(from=1119,to=1039)
+ to_title(361)=(from=1121,to=1120)
+ to_title(362)=(from=1123,to=1122)
+ to_title(363)=(from=1125,to=1124)
+ to_title(364)=(from=1127,to=1126)
+ to_title(365)=(from=1129,to=1128)
+ to_title(366)=(from=1131,to=1130)
+ to_title(367)=(from=1133,to=1132)
+ to_title(368)=(from=1135,to=1134)
+ to_title(369)=(from=1137,to=1136)
+ to_title(370)=(from=1139,to=1138)
+ to_title(371)=(from=1141,to=1140)
+ to_title(372)=(from=1143,to=1142)
+ to_title(373)=(from=1145,to=1144)
+ to_title(374)=(from=1147,to=1146)
+ to_title(375)=(from=1149,to=1148)
+ to_title(376)=(from=1151,to=1150)
+ to_title(377)=(from=1153,to=1152)
+ to_title(378)=(from=1163,to=1162)
+ to_title(379)=(from=1165,to=1164)
+ to_title(380)=(from=1167,to=1166)
+ to_title(381)=(from=1169,to=1168)
+ to_title(382)=(from=1171,to=1170)
+ to_title(383)=(from=1173,to=1172)
+ to_title(384)=(from=1175,to=1174)
+ to_title(385)=(from=1177,to=1176)
+ to_title(386)=(from=1179,to=1178)
+ to_title(387)=(from=1181,to=1180)
+ to_title(388)=(from=1183,to=1182)
+ to_title(389)=(from=1185,to=1184)
+ to_title(390)=(from=1187,to=1186)
+ to_title(391)=(from=1189,to=1188)
+ to_title(392)=(from=1191,to=1190)
+ to_title(393)=(from=1193,to=1192)
+ to_title(394)=(from=1195,to=1194)
+ to_title(395)=(from=1197,to=1196)
+ to_title(396)=(from=1199,to=1198)
+ to_title(397)=(from=1201,to=1200)
+ to_title(398)=(from=1203,to=1202)
+ to_title(399)=(from=1205,to=1204)
+ to_title(400)=(from=1207,to=1206)
+ to_title(401)=(from=1209,to=1208)
+ to_title(402)=(from=1211,to=1210)
+ to_title(403)=(from=1213,to=1212)
+ to_title(404)=(from=1215,to=1214)
+ to_title(405)=(from=1218,to=1217)
+ to_title(406)=(from=1220,to=1219)
+ to_title(407)=(from=1222,to=1221)
+ to_title(408)=(from=1224,to=1223)
+ to_title(409)=(from=1226,to=1225)
+ to_title(410)=(from=1228,to=1227)
+ to_title(411)=(from=1230,to=1229)
+ to_title(412)=(from=1231,to=1216)
+ to_title(413)=(from=1233,to=1232)
+ to_title(414)=(from=1235,to=1234)
+ to_title(415)=(from=1237,to=1236)
+ to_title(416)=(from=1239,to=1238)
+ to_title(417)=(from=1241,to=1240)
+ to_title(418)=(from=1243,to=1242)
+ to_title(419)=(from=1245,to=1244)
+ to_title(420)=(from=1247,to=1246)
+ to_title(421)=(from=1249,to=1248)
+ to_title(422)=(from=1251,to=1250)
+ to_title(423)=(from=1253,to=1252)
+ to_title(424)=(from=1255,to=1254)
+ to_title(425)=(from=1257,to=1256)
+ to_title(426)=(from=1259,to=1258)
+ to_title(427)=(from=1261,to=1260)
+ to_title(428)=(from=1263,to=1262)
+ to_title(429)=(from=1265,to=1264)
+ to_title(430)=(from=1267,to=1266)
+ to_title(431)=(from=1269,to=1268)
+ to_title(432)=(from=1271,to=1270)
+ to_title(433)=(from=1273,to=1272)
+ to_title(434)=(from=1275,to=1274)
+ to_title(435)=(from=1277,to=1276)
+ to_title(436)=(from=1279,to=1278)
+ to_title(437)=(from=1281,to=1280)
+ to_title(438)=(from=1283,to=1282)
+ to_title(439)=(from=1285,to=1284)
+ to_title(440)=(from=1287,to=1286)
+ to_title(441)=(from=1289,to=1288)
+ to_title(442)=(from=1291,to=1290)
+ to_title(443)=(from=1293,to=1292)
+ to_title(444)=(from=1295,to=1294)
+ to_title(445)=(from=1297,to=1296)
+ to_title(446)=(from=1299,to=1298)
+ to_title(447)=(from=1301,to=1300)
+ to_title(448)=(from=1303,to=1302)
+ to_title(449)=(from=1305,to=1304)
+ to_title(450)=(from=1307,to=1306)
+ to_title(451)=(from=1309,to=1308)
+ to_title(452)=(from=1311,to=1310)
+ to_title(453)=(from=1313,to=1312)
+ to_title(454)=(from=1315,to=1314)
+ to_title(455)=(from=1317,to=1316)
+ to_title(456)=(from=1319,to=1318)
+ to_title(457)=(from=1321,to=1320)
+ to_title(458)=(from=1323,to=1322)
+ to_title(459)=(from=1325,to=1324)
+ to_title(460)=(from=1327,to=1326)
+ to_title(461)=(from=1377,to=1329)
+ to_title(462)=(from=1378,to=1330)
+ to_title(463)=(from=1379,to=1331)
+ to_title(464)=(from=1380,to=1332)
+ to_title(465)=(from=1381,to=1333)
+ to_title(466)=(from=1382,to=1334)
+ to_title(467)=(from=1383,to=1335)
+ to_title(468)=(from=1384,to=1336)
+ to_title(469)=(from=1385,to=1337)
+ to_title(470)=(from=1386,to=1338)
+ to_title(471)=(from=1387,to=1339)
+ to_title(472)=(from=1388,to=1340)
+ to_title(473)=(from=1389,to=1341)
+ to_title(474)=(from=1390,to=1342)
+ to_title(475)=(from=1391,to=1343)
+ to_title(476)=(from=1392,to=1344)
+ to_title(477)=(from=1393,to=1345)
+ to_title(478)=(from=1394,to=1346)
+ to_title(479)=(from=1395,to=1347)
+ to_title(480)=(from=1396,to=1348)
+ to_title(481)=(from=1397,to=1349)
+ to_title(482)=(from=1398,to=1350)
+ to_title(483)=(from=1399,to=1351)
+ to_title(484)=(from=1400,to=1352)
+ to_title(485)=(from=1401,to=1353)
+ to_title(486)=(from=1402,to=1354)
+ to_title(487)=(from=1403,to=1355)
+ to_title(488)=(from=1404,to=1356)
+ to_title(489)=(from=1405,to=1357)
+ to_title(490)=(from=1406,to=1358)
+ to_title(491)=(from=1407,to=1359)
+ to_title(492)=(from=1408,to=1360)
+ to_title(493)=(from=1409,to=1361)
+ to_title(494)=(from=1410,to=1362)
+ to_title(495)=(from=1411,to=1363)
+ to_title(496)=(from=1412,to=1364)
+ to_title(497)=(from=1413,to=1365)
+ to_title(498)=(from=1414,to=1366)
+ to_title(499)=(from=4304,to=4304)
+ to_title(500)=(from=4305,to=4305)
+ to_title(501)=(from=4306,to=4306)
+ to_title(502)=(from=4307,to=4307)
+ to_title(503)=(from=4308,to=4308)
+ to_title(504)=(from=4309,to=4309)
+ to_title(505)=(from=4310,to=4310)
+ to_title(506)=(from=4311,to=4311)
+ to_title(507)=(from=4312,to=4312)
+ to_title(508)=(from=4313,to=4313)
+ to_title(509)=(from=4314,to=4314)
+ to_title(510)=(from=4315,to=4315)
+ to_title(511)=(from=4316,to=4316)
+ to_title(512)=(from=4317,to=4317)
+ to_title(513)=(from=4318,to=4318)
+ to_title(514)=(from=4319,to=4319)
+ to_title(515)=(from=4320,to=4320)
+ to_title(516)=(from=4321,to=4321)
+ to_title(517)=(from=4322,to=4322)
+ to_title(518)=(from=4323,to=4323)
+ to_title(519)=(from=4324,to=4324)
+ to_title(520)=(from=4325,to=4325)
+ to_title(521)=(from=4326,to=4326)
+ to_title(522)=(from=4327,to=4327)
+ to_title(523)=(from=4328,to=4328)
+ to_title(524)=(from=4329,to=4329)
+ to_title(525)=(from=4330,to=4330)
+ to_title(526)=(from=4331,to=4331)
+ to_title(527)=(from=4332,to=4332)
+ to_title(528)=(from=4333,to=4333)
+ to_title(529)=(from=4334,to=4334)
+ to_title(530)=(from=4335,to=4335)
+ to_title(531)=(from=4336,to=4336)
+ to_title(532)=(from=4337,to=4337)
+ to_title(533)=(from=4338,to=4338)
+ to_title(534)=(from=4339,to=4339)
+ to_title(535)=(from=4340,to=4340)
+ to_title(536)=(from=4341,to=4341)
+ to_title(537)=(from=4342,to=4342)
+ to_title(538)=(from=4343,to=4343)
+ to_title(539)=(from=4344,to=4344)
+ to_title(540)=(from=4345,to=4345)
+ to_title(541)=(from=4346,to=4346)
+ to_title(542)=(from=4349,to=4349)
+ to_title(543)=(from=4350,to=4350)
+ to_title(544)=(from=4351,to=4351)
+ to_title(545)=(from=5112,to=5104)
+ to_title(546)=(from=5113,to=5105)
+ to_title(547)=(from=5114,to=5106)
+ to_title(548)=(from=5115,to=5107)
+ to_title(549)=(from=5116,to=5108)
+ to_title(550)=(from=5117,to=5109)
+ to_title(551)=(from=7296,to=1042)
+ to_title(552)=(from=7297,to=1044)
+ to_title(553)=(from=7298,to=1054)
+ to_title(554)=(from=7299,to=1057)
+ to_title(555)=(from=7300,to=1058)
+ to_title(556)=(from=7301,to=1058)
+ to_title(557)=(from=7302,to=1066)
+ to_title(558)=(from=7303,to=1122)
+ to_title(559)=(from=7304,to=42570)
+ to_title(560)=(from=7545,to=42877)
+ to_title(561)=(from=7549,to=11363)
+ to_title(562)=(from=7566,to=42950)
+ to_title(563)=(from=7681,to=7680)
+ to_title(564)=(from=7683,to=7682)
+ to_title(565)=(from=7685,to=7684)
+ to_title(566)=(from=7687,to=7686)
+ to_title(567)=(from=7689,to=7688)
+ to_title(568)=(from=7691,to=7690)
+ to_title(569)=(from=7693,to=7692)
+ to_title(570)=(from=7695,to=7694)
+ to_title(571)=(from=7697,to=7696)
+ to_title(572)=(from=7699,to=7698)
+ to_title(573)=(from=7701,to=7700)
+ to_title(574)=(from=7703,to=7702)
+ to_title(575)=(from=7705,to=7704)
+ to_title(576)=(from=7707,to=7706)
+ to_title(577)=(from=7709,to=7708)
+ to_title(578)=(from=7711,to=7710)
+ to_title(579)=(from=7713,to=7712)
+ to_title(580)=(from=7715,to=7714)
+ to_title(581)=(from=7717,to=7716)
+ to_title(582)=(from=7719,to=7718)
+ to_title(583)=(from=7721,to=7720)
+ to_title(584)=(from=7723,to=7722)
+ to_title(585)=(from=7725,to=7724)
+ to_title(586)=(from=7727,to=7726)
+ to_title(587)=(from=7729,to=7728)
+ to_title(588)=(from=7731,to=7730)
+ to_title(589)=(from=7733,to=7732)
+ to_title(590)=(from=7735,to=7734)
+ to_title(591)=(from=7737,to=7736)
+ to_title(592)=(from=7739,to=7738)
+ to_title(593)=(from=7741,to=7740)
+ to_title(594)=(from=7743,to=7742)
+ to_title(595)=(from=7745,to=7744)
+ to_title(596)=(from=7747,to=7746)
+ to_title(597)=(from=7749,to=7748)
+ to_title(598)=(from=7751,to=7750)
+ to_title(599)=(from=7753,to=7752)
+ to_title(600)=(from=7755,to=7754)
+ to_title(601)=(from=7757,to=7756)
+ to_title(602)=(from=7759,to=7758)
+ to_title(603)=(from=7761,to=7760)
+ to_title(604)=(from=7763,to=7762)
+ to_title(605)=(from=7765,to=7764)
+ to_title(606)=(from=7767,to=7766)
+ to_title(607)=(from=7769,to=7768)
+ to_title(608)=(from=7771,to=7770)
+ to_title(609)=(from=7773,to=7772)
+ to_title(610)=(from=7775,to=7774)
+ to_title(611)=(from=7777,to=7776)
+ to_title(612)=(from=7779,to=7778)
+ to_title(613)=(from=7781,to=7780)
+ to_title(614)=(from=7783,to=7782)
+ to_title(615)=(from=7785,to=7784)
+ to_title(616)=(from=7787,to=7786)
+ to_title(617)=(from=7789,to=7788)
+ to_title(618)=(from=7791,to=7790)
+ to_title(619)=(from=7793,to=7792)
+ to_title(620)=(from=7795,to=7794)
+ to_title(621)=(from=7797,to=7796)
+ to_title(622)=(from=7799,to=7798)
+ to_title(623)=(from=7801,to=7800)
+ to_title(624)=(from=7803,to=7802)
+ to_title(625)=(from=7805,to=7804)
+ to_title(626)=(from=7807,to=7806)
+ to_title(627)=(from=7809,to=7808)
+ to_title(628)=(from=7811,to=7810)
+ to_title(629)=(from=7813,to=7812)
+ to_title(630)=(from=7815,to=7814)
+ to_title(631)=(from=7817,to=7816)
+ to_title(632)=(from=7819,to=7818)
+ to_title(633)=(from=7821,to=7820)
+ to_title(634)=(from=7823,to=7822)
+ to_title(635)=(from=7825,to=7824)
+ to_title(636)=(from=7827,to=7826)
+ to_title(637)=(from=7829,to=7828)
+ to_title(638)=(from=7835,to=7776)
+ to_title(639)=(from=7841,to=7840)
+ to_title(640)=(from=7843,to=7842)
+ to_title(641)=(from=7845,to=7844)
+ to_title(642)=(from=7847,to=7846)
+ to_title(643)=(from=7849,to=7848)
+ to_title(644)=(from=7851,to=7850)
+ to_title(645)=(from=7853,to=7852)
+ to_title(646)=(from=7855,to=7854)
+ to_title(647)=(from=7857,to=7856)
+ to_title(648)=(from=7859,to=7858)
+ to_title(649)=(from=7861,to=7860)
+ to_title(650)=(from=7863,to=7862)
+ to_title(651)=(from=7865,to=7864)
+ to_title(652)=(from=7867,to=7866)
+ to_title(653)=(from=7869,to=7868)
+ to_title(654)=(from=7871,to=7870)
+ to_title(655)=(from=7873,to=7872)
+ to_title(656)=(from=7875,to=7874)
+ to_title(657)=(from=7877,to=7876)
+ to_title(658)=(from=7879,to=7878)
+ to_title(659)=(from=7881,to=7880)
+ to_title(660)=(from=7883,to=7882)
+ to_title(661)=(from=7885,to=7884)
+ to_title(662)=(from=7887,to=7886)
+ to_title(663)=(from=7889,to=7888)
+ to_title(664)=(from=7891,to=7890)
+ to_title(665)=(from=7893,to=7892)
+ to_title(666)=(from=7895,to=7894)
+ to_title(667)=(from=7897,to=7896)
+ to_title(668)=(from=7899,to=7898)
+ to_title(669)=(from=7901,to=7900)
+ to_title(670)=(from=7903,to=7902)
+ to_title(671)=(from=7905,to=7904)
+ to_title(672)=(from=7907,to=7906)
+ to_title(673)=(from=7909,to=7908)
+ to_title(674)=(from=7911,to=7910)
+ to_title(675)=(from=7913,to=7912)
+ to_title(676)=(from=7915,to=7914)
+ to_title(677)=(from=7917,to=7916)
+ to_title(678)=(from=7919,to=7918)
+ to_title(679)=(from=7921,to=7920)
+ to_title(680)=(from=7923,to=7922)
+ to_title(681)=(from=7925,to=7924)
+ to_title(682)=(from=7927,to=7926)
+ to_title(683)=(from=7929,to=7928)
+ to_title(684)=(from=7931,to=7930)
+ to_title(685)=(from=7933,to=7932)
+ to_title(686)=(from=7935,to=7934)
+ to_title(687)=(from=7936,to=7944)
+ to_title(688)=(from=7937,to=7945)
+ to_title(689)=(from=7938,to=7946)
+ to_title(690)=(from=7939,to=7947)
+ to_title(691)=(from=7940,to=7948)
+ to_title(692)=(from=7941,to=7949)
+ to_title(693)=(from=7942,to=7950)
+ to_title(694)=(from=7943,to=7951)
+ to_title(695)=(from=7952,to=7960)
+ to_title(696)=(from=7953,to=7961)
+ to_title(697)=(from=7954,to=7962)
+ to_title(698)=(from=7955,to=7963)
+ to_title(699)=(from=7956,to=7964)
+ to_title(700)=(from=7957,to=7965)
+ to_title(701)=(from=7968,to=7976)
+ to_title(702)=(from=7969,to=7977)
+ to_title(703)=(from=7970,to=7978)
+ to_title(704)=(from=7971,to=7979)
+ to_title(705)=(from=7972,to=7980)
+ to_title(706)=(from=7973,to=7981)
+ to_title(707)=(from=7974,to=7982)
+ to_title(708)=(from=7975,to=7983)
+ to_title(709)=(from=7984,to=7992)
+ to_title(710)=(from=7985,to=7993)
+ to_title(711)=(from=7986,to=7994)
+ to_title(712)=(from=7987,to=7995)
+ to_title(713)=(from=7988,to=7996)
+ to_title(714)=(from=7989,to=7997)
+ to_title(715)=(from=7990,to=7998)
+ to_title(716)=(from=7991,to=7999)
+ to_title(717)=(from=8000,to=8008)
+ to_title(718)=(from=8001,to=8009)
+ to_title(719)=(from=8002,to=8010)
+ to_title(720)=(from=8003,to=8011)
+ to_title(721)=(from=8004,to=8012)
+ to_title(722)=(from=8005,to=8013)
+ to_title(723)=(from=8017,to=8025)
+ to_title(724)=(from=8019,to=8027)
+ to_title(725)=(from=8021,to=8029)
+ to_title(726)=(from=8023,to=8031)
+ to_title(727)=(from=8032,to=8040)
+ to_title(728)=(from=8033,to=8041)
+ to_title(729)=(from=8034,to=8042)
+ to_title(730)=(from=8035,to=8043)
+ to_title(731)=(from=8036,to=8044)
+ to_title(732)=(from=8037,to=8045)
+ to_title(733)=(from=8038,to=8046)
+ to_title(734)=(from=8039,to=8047)
+ to_title(735)=(from=8048,to=8122)
+ to_title(736)=(from=8049,to=8123)
+ to_title(737)=(from=8050,to=8136)
+ to_title(738)=(from=8051,to=8137)
+ to_title(739)=(from=8052,to=8138)
+ to_title(740)=(from=8053,to=8139)
+ to_title(741)=(from=8054,to=8154)
+ to_title(742)=(from=8055,to=8155)
+ to_title(743)=(from=8056,to=8184)
+ to_title(744)=(from=8057,to=8185)
+ to_title(745)=(from=8058,to=8170)
+ to_title(746)=(from=8059,to=8171)
+ to_title(747)=(from=8060,to=8186)
+ to_title(748)=(from=8061,to=8187)
+ to_title(749)=(from=8064,to=8072)
+ to_title(750)=(from=8065,to=8073)
+ to_title(751)=(from=8066,to=8074)
+ to_title(752)=(from=8067,to=8075)
+ to_title(753)=(from=8068,to=8076)
+ to_title(754)=(from=8069,to=8077)
+ to_title(755)=(from=8070,to=8078)
+ to_title(756)=(from=8071,to=8079)
+ to_title(757)=(from=8080,to=8088)
+ to_title(758)=(from=8081,to=8089)
+ to_title(759)=(from=8082,to=8090)
+ to_title(760)=(from=8083,to=8091)
+ to_title(761)=(from=8084,to=8092)
+ to_title(762)=(from=8085,to=8093)
+ to_title(763)=(from=8086,to=8094)
+ to_title(764)=(from=8087,to=8095)
+ to_title(765)=(from=8096,to=8104)
+ to_title(766)=(from=8097,to=8105)
+ to_title(767)=(from=8098,to=8106)
+ to_title(768)=(from=8099,to=8107)
+ to_title(769)=(from=8100,to=8108)
+ to_title(770)=(from=8101,to=8109)
+ to_title(771)=(from=8102,to=8110)
+ to_title(772)=(from=8103,to=8111)
+ to_title(773)=(from=8112,to=8120)
+ to_title(774)=(from=8113,to=8121)
+ to_title(775)=(from=8115,to=8124)
+ to_title(776)=(from=8126,to=921)
+ to_title(777)=(from=8131,to=8140)
+ to_title(778)=(from=8144,to=8152)
+ to_title(779)=(from=8145,to=8153)
+ to_title(780)=(from=8160,to=8168)
+ to_title(781)=(from=8161,to=8169)
+ to_title(782)=(from=8165,to=8172)
+ to_title(783)=(from=8179,to=8188)
+ to_title(784)=(from=8526,to=8498)
+ to_title(785)=(from=8560,to=8544)
+ to_title(786)=(from=8561,to=8545)
+ to_title(787)=(from=8562,to=8546)
+ to_title(788)=(from=8563,to=8547)
+ to_title(789)=(from=8564,to=8548)
+ to_title(790)=(from=8565,to=8549)
+ to_title(791)=(from=8566,to=8550)
+ to_title(792)=(from=8567,to=8551)
+ to_title(793)=(from=8568,to=8552)
+ to_title(794)=(from=8569,to=8553)
+ to_title(795)=(from=8570,to=8554)
+ to_title(796)=(from=8571,to=8555)
+ to_title(797)=(from=8572,to=8556)
+ to_title(798)=(from=8573,to=8557)
+ to_title(799)=(from=8574,to=8558)
+ to_title(800)=(from=8575,to=8559)
+ to_title(801)=(from=8580,to=8579)
+ to_title(802)=(from=9424,to=9398)
+ to_title(803)=(from=9425,to=9399)
+ to_title(804)=(from=9426,to=9400)
+ to_title(805)=(from=9427,to=9401)
+ to_title(806)=(from=9428,to=9402)
+ to_title(807)=(from=9429,to=9403)
+ to_title(808)=(from=9430,to=9404)
+ to_title(809)=(from=9431,to=9405)
+ to_title(810)=(from=9432,to=9406)
+ to_title(811)=(from=9433,to=9407)
+ to_title(812)=(from=9434,to=9408)
+ to_title(813)=(from=9435,to=9409)
+ to_title(814)=(from=9436,to=9410)
+ to_title(815)=(from=9437,to=9411)
+ to_title(816)=(from=9438,to=9412)
+ to_title(817)=(from=9439,to=9413)
+ to_title(818)=(from=9440,to=9414)
+ to_title(819)=(from=9441,to=9415)
+ to_title(820)=(from=9442,to=9416)
+ to_title(821)=(from=9443,to=9417)
+ to_title(822)=(from=9444,to=9418)
+ to_title(823)=(from=9445,to=9419)
+ to_title(824)=(from=9446,to=9420)
+ to_title(825)=(from=9447,to=9421)
+ to_title(826)=(from=9448,to=9422)
+ to_title(827)=(from=9449,to=9423)
+ to_title(828)=(from=11312,to=11264)
+ to_title(829)=(from=11313,to=11265)
+ to_title(830)=(from=11314,to=11266)
+ to_title(831)=(from=11315,to=11267)
+ to_title(832)=(from=11316,to=11268)
+ to_title(833)=(from=11317,to=11269)
+ to_title(834)=(from=11318,to=11270)
+ to_title(835)=(from=11319,to=11271)
+ to_title(836)=(from=11320,to=11272)
+ to_title(837)=(from=11321,to=11273)
+ to_title(838)=(from=11322,to=11274)
+ to_title(839)=(from=11323,to=11275)
+ to_title(840)=(from=11324,to=11276)
+ to_title(841)=(from=11325,to=11277)
+ to_title(842)=(from=11326,to=11278)
+ to_title(843)=(from=11327,to=11279)
+ to_title(844)=(from=11328,to=11280)
+ to_title(845)=(from=11329,to=11281)
+ to_title(846)=(from=11330,to=11282)
+ to_title(847)=(from=11331,to=11283)
+ to_title(848)=(from=11332,to=11284)
+ to_title(849)=(from=11333,to=11285)
+ to_title(850)=(from=11334,to=11286)
+ to_title(851)=(from=11335,to=11287)
+ to_title(852)=(from=11336,to=11288)
+ to_title(853)=(from=11337,to=11289)
+ to_title(854)=(from=11338,to=11290)
+ to_title(855)=(from=11339,to=11291)
+ to_title(856)=(from=11340,to=11292)
+ to_title(857)=(from=11341,to=11293)
+ to_title(858)=(from=11342,to=11294)
+ to_title(859)=(from=11343,to=11295)
+ to_title(860)=(from=11344,to=11296)
+ to_title(861)=(from=11345,to=11297)
+ to_title(862)=(from=11346,to=11298)
+ to_title(863)=(from=11347,to=11299)
+ to_title(864)=(from=11348,to=11300)
+ to_title(865)=(from=11349,to=11301)
+ to_title(866)=(from=11350,to=11302)
+ to_title(867)=(from=11351,to=11303)
+ to_title(868)=(from=11352,to=11304)
+ to_title(869)=(from=11353,to=11305)
+ to_title(870)=(from=11354,to=11306)
+ to_title(871)=(from=11355,to=11307)
+ to_title(872)=(from=11356,to=11308)
+ to_title(873)=(from=11357,to=11309)
+ to_title(874)=(from=11358,to=11310)
+ to_title(875)=(from=11361,to=11360)
+ to_title(876)=(from=11365,to=570)
+ to_title(877)=(from=11366,to=574)
+ to_title(878)=(from=11368,to=11367)
+ to_title(879)=(from=11370,to=11369)
+ to_title(880)=(from=11372,to=11371)
+ to_title(881)=(from=11379,to=11378)
+ to_title(882)=(from=11382,to=11381)
+ to_title(883)=(from=11393,to=11392)
+ to_title(884)=(from=11395,to=11394)
+ to_title(885)=(from=11397,to=11396)
+ to_title(886)=(from=11399,to=11398)
+ to_title(887)=(from=11401,to=11400)
+ to_title(888)=(from=11403,to=11402)
+ to_title(889)=(from=11405,to=11404)
+ to_title(890)=(from=11407,to=11406)
+ to_title(891)=(from=11409,to=11408)
+ to_title(892)=(from=11411,to=11410)
+ to_title(893)=(from=11413,to=11412)
+ to_title(894)=(from=11415,to=11414)
+ to_title(895)=(from=11417,to=11416)
+ to_title(896)=(from=11419,to=11418)
+ to_title(897)=(from=11421,to=11420)
+ to_title(898)=(from=11423,to=11422)
+ to_title(899)=(from=11425,to=11424)
+ to_title(900)=(from=11427,to=11426)
+ to_title(901)=(from=11429,to=11428)
+ to_title(902)=(from=11431,to=11430)
+ to_title(903)=(from=11433,to=11432)
+ to_title(904)=(from=11435,to=11434)
+ to_title(905)=(from=11437,to=11436)
+ to_title(906)=(from=11439,to=11438)
+ to_title(907)=(from=11441,to=11440)
+ to_title(908)=(from=11443,to=11442)
+ to_title(909)=(from=11445,to=11444)
+ to_title(910)=(from=11447,to=11446)
+ to_title(911)=(from=11449,to=11448)
+ to_title(912)=(from=11451,to=11450)
+ to_title(913)=(from=11453,to=11452)
+ to_title(914)=(from=11455,to=11454)
+ to_title(915)=(from=11457,to=11456)
+ to_title(916)=(from=11459,to=11458)
+ to_title(917)=(from=11461,to=11460)
+ to_title(918)=(from=11463,to=11462)
+ to_title(919)=(from=11465,to=11464)
+ to_title(920)=(from=11467,to=11466)
+ to_title(921)=(from=11469,to=11468)
+ to_title(922)=(from=11471,to=11470)
+ to_title(923)=(from=11473,to=11472)
+ to_title(924)=(from=11475,to=11474)
+ to_title(925)=(from=11477,to=11476)
+ to_title(926)=(from=11479,to=11478)
+ to_title(927)=(from=11481,to=11480)
+ to_title(928)=(from=11483,to=11482)
+ to_title(929)=(from=11485,to=11484)
+ to_title(930)=(from=11487,to=11486)
+ to_title(931)=(from=11489,to=11488)
+ to_title(932)=(from=11491,to=11490)
+ to_title(933)=(from=11500,to=11499)
+ to_title(934)=(from=11502,to=11501)
+ to_title(935)=(from=11507,to=11506)
+ to_title(936)=(from=11520,to=4256)
+ to_title(937)=(from=11521,to=4257)
+ to_title(938)=(from=11522,to=4258)
+ to_title(939)=(from=11523,to=4259)
+ to_title(940)=(from=11524,to=4260)
+ to_title(941)=(from=11525,to=4261)
+ to_title(942)=(from=11526,to=4262)
+ to_title(943)=(from=11527,to=4263)
+ to_title(944)=(from=11528,to=4264)
+ to_title(945)=(from=11529,to=4265)
+ to_title(946)=(from=11530,to=4266)
+ to_title(947)=(from=11531,to=4267)
+ to_title(948)=(from=11532,to=4268)
+ to_title(949)=(from=11533,to=4269)
+ to_title(950)=(from=11534,to=4270)
+ to_title(951)=(from=11535,to=4271)
+ to_title(952)=(from=11536,to=4272)
+ to_title(953)=(from=11537,to=4273)
+ to_title(954)=(from=11538,to=4274)
+ to_title(955)=(from=11539,to=4275)
+ to_title(956)=(from=11540,to=4276)
+ to_title(957)=(from=11541,to=4277)
+ to_title(958)=(from=11542,to=4278)
+ to_title(959)=(from=11543,to=4279)
+ to_title(960)=(from=11544,to=4280)
+ to_title(961)=(from=11545,to=4281)
+ to_title(962)=(from=11546,to=4282)
+ to_title(963)=(from=11547,to=4283)
+ to_title(964)=(from=11548,to=4284)
+ to_title(965)=(from=11549,to=4285)
+ to_title(966)=(from=11550,to=4286)
+ to_title(967)=(from=11551,to=4287)
+ to_title(968)=(from=11552,to=4288)
+ to_title(969)=(from=11553,to=4289)
+ to_title(970)=(from=11554,to=4290)
+ to_title(971)=(from=11555,to=4291)
+ to_title(972)=(from=11556,to=4292)
+ to_title(973)=(from=11557,to=4293)
+ to_title(974)=(from=11559,to=4295)
+ to_title(975)=(from=11565,to=4301)
+ to_title(976)=(from=42561,to=42560)
+ to_title(977)=(from=42563,to=42562)
+ to_title(978)=(from=42565,to=42564)
+ to_title(979)=(from=42567,to=42566)
+ to_title(980)=(from=42569,to=42568)
+ to_title(981)=(from=42571,to=42570)
+ to_title(982)=(from=42573,to=42572)
+ to_title(983)=(from=42575,to=42574)
+ to_title(984)=(from=42577,to=42576)
+ to_title(985)=(from=42579,to=42578)
+ to_title(986)=(from=42581,to=42580)
+ to_title(987)=(from=42583,to=42582)
+ to_title(988)=(from=42585,to=42584)
+ to_title(989)=(from=42587,to=42586)
+ to_title(990)=(from=42589,to=42588)
+ to_title(991)=(from=42591,to=42590)
+ to_title(992)=(from=42593,to=42592)
+ to_title(993)=(from=42595,to=42594)
+ to_title(994)=(from=42597,to=42596)
+ to_title(995)=(from=42599,to=42598)
+ to_title(996)=(from=42601,to=42600)
+ to_title(997)=(from=42603,to=42602)
+ to_title(998)=(from=42605,to=42604)
+ to_title(999)=(from=42625,to=42624)
+ to_title(1000)=(from=42627,to=42626)
+ to_title(1001)=(from=42629,to=42628)
+ to_title(1002)=(from=42631,to=42630)
+ to_title(1003)=(from=42633,to=42632)
+ to_title(1004)=(from=42635,to=42634)
+ to_title(1005)=(from=42637,to=42636)
+ to_title(1006)=(from=42639,to=42638)
+ to_title(1007)=(from=42641,to=42640)
+ to_title(1008)=(from=42643,to=42642)
+ to_title(1009)=(from=42645,to=42644)
+ to_title(1010)=(from=42647,to=42646)
+ to_title(1011)=(from=42649,to=42648)
+ to_title(1012)=(from=42651,to=42650)
+ to_title(1013)=(from=42787,to=42786)
+ to_title(1014)=(from=42789,to=42788)
+ to_title(1015)=(from=42791,to=42790)
+ to_title(1016)=(from=42793,to=42792)
+ to_title(1017)=(from=42795,to=42794)
+ to_title(1018)=(from=42797,to=42796)
+ to_title(1019)=(from=42799,to=42798)
+ to_title(1020)=(from=42803,to=42802)
+ to_title(1021)=(from=42805,to=42804)
+ to_title(1022)=(from=42807,to=42806)
+ to_title(1023)=(from=42809,to=42808)
+ to_title(1024)=(from=42811,to=42810)
+ to_title(1025)=(from=42813,to=42812)
+ to_title(1026)=(from=42815,to=42814)
+ to_title(1027)=(from=42817,to=42816)
+ to_title(1028)=(from=42819,to=42818)
+ to_title(1029)=(from=42821,to=42820)
+ to_title(1030)=(from=42823,to=42822)
+ to_title(1031)=(from=42825,to=42824)
+ to_title(1032)=(from=42827,to=42826)
+ to_title(1033)=(from=42829,to=42828)
+ to_title(1034)=(from=42831,to=42830)
+ to_title(1035)=(from=42833,to=42832)
+ to_title(1036)=(from=42835,to=42834)
+ to_title(1037)=(from=42837,to=42836)
+ to_title(1038)=(from=42839,to=42838)
+ to_title(1039)=(from=42841,to=42840)
+ to_title(1040)=(from=42843,to=42842)
+ to_title(1041)=(from=42845,to=42844)
+ to_title(1042)=(from=42847,to=42846)
+ to_title(1043)=(from=42849,to=42848)
+ to_title(1044)=(from=42851,to=42850)
+ to_title(1045)=(from=42853,to=42852)
+ to_title(1046)=(from=42855,to=42854)
+ to_title(1047)=(from=42857,to=42856)
+ to_title(1048)=(from=42859,to=42858)
+ to_title(1049)=(from=42861,to=42860)
+ to_title(1050)=(from=42863,to=42862)
+ to_title(1051)=(from=42874,to=42873)
+ to_title(1052)=(from=42876,to=42875)
+ to_title(1053)=(from=42879,to=42878)
+ to_title(1054)=(from=42881,to=42880)
+ to_title(1055)=(from=42883,to=42882)
+ to_title(1056)=(from=42885,to=42884)
+ to_title(1057)=(from=42887,to=42886)
+ to_title(1058)=(from=42892,to=42891)
+ to_title(1059)=(from=42897,to=42896)
+ to_title(1060)=(from=42899,to=42898)
+ to_title(1061)=(from=42900,to=42948)
+ to_title(1062)=(from=42903,to=42902)
+ to_title(1063)=(from=42905,to=42904)
+ to_title(1064)=(from=42907,to=42906)
+ to_title(1065)=(from=42909,to=42908)
+ to_title(1066)=(from=42911,to=42910)
+ to_title(1067)=(from=42913,to=42912)
+ to_title(1068)=(from=42915,to=42914)
+ to_title(1069)=(from=42917,to=42916)
+ to_title(1070)=(from=42919,to=42918)
+ to_title(1071)=(from=42921,to=42920)
+ to_title(1072)=(from=42933,to=42932)
+ to_title(1073)=(from=42935,to=42934)
+ to_title(1074)=(from=42937,to=42936)
+ to_title(1075)=(from=42939,to=42938)
+ to_title(1076)=(from=42941,to=42940)
+ to_title(1077)=(from=42943,to=42942)
+ to_title(1078)=(from=42947,to=42946)
+ to_title(1079)=(from=42952,to=42951)
+ to_title(1080)=(from=42954,to=42953)
+ to_title(1081)=(from=42998,to=42997)
+ to_title(1082)=(from=43859,to=42931)
+ to_title(1083)=(from=43888,to=5024)
+ to_title(1084)=(from=43889,to=5025)
+ to_title(1085)=(from=43890,to=5026)
+ to_title(1086)=(from=43891,to=5027)
+ to_title(1087)=(from=43892,to=5028)
+ to_title(1088)=(from=43893,to=5029)
+ to_title(1089)=(from=43894,to=5030)
+ to_title(1090)=(from=43895,to=5031)
+ to_title(1091)=(from=43896,to=5032)
+ to_title(1092)=(from=43897,to=5033)
+ to_title(1093)=(from=43898,to=5034)
+ to_title(1094)=(from=43899,to=5035)
+ to_title(1095)=(from=43900,to=5036)
+ to_title(1096)=(from=43901,to=5037)
+ to_title(1097)=(from=43902,to=5038)
+ to_title(1098)=(from=43903,to=5039)
+ to_title(1099)=(from=43904,to=5040)
+ to_title(1100)=(from=43905,to=5041)
+ to_title(1101)=(from=43906,to=5042)
+ to_title(1102)=(from=43907,to=5043)
+ to_title(1103)=(from=43908,to=5044)
+ to_title(1104)=(from=43909,to=5045)
+ to_title(1105)=(from=43910,to=5046)
+ to_title(1106)=(from=43911,to=5047)
+ to_title(1107)=(from=43912,to=5048)
+ to_title(1108)=(from=43913,to=5049)
+ to_title(1109)=(from=43914,to=5050)
+ to_title(1110)=(from=43915,to=5051)
+ to_title(1111)=(from=43916,to=5052)
+ to_title(1112)=(from=43917,to=5053)
+ to_title(1113)=(from=43918,to=5054)
+ to_title(1114)=(from=43919,to=5055)
+ to_title(1115)=(from=43920,to=5056)
+ to_title(1116)=(from=43921,to=5057)
+ to_title(1117)=(from=43922,to=5058)
+ to_title(1118)=(from=43923,to=5059)
+ to_title(1119)=(from=43924,to=5060)
+ to_title(1120)=(from=43925,to=5061)
+ to_title(1121)=(from=43926,to=5062)
+ to_title(1122)=(from=43927,to=5063)
+ to_title(1123)=(from=43928,to=5064)
+ to_title(1124)=(from=43929,to=5065)
+ to_title(1125)=(from=43930,to=5066)
+ to_title(1126)=(from=43931,to=5067)
+ to_title(1127)=(from=43932,to=5068)
+ to_title(1128)=(from=43933,to=5069)
+ to_title(1129)=(from=43934,to=5070)
+ to_title(1130)=(from=43935,to=5071)
+ to_title(1131)=(from=43936,to=5072)
+ to_title(1132)=(from=43937,to=5073)
+ to_title(1133)=(from=43938,to=5074)
+ to_title(1134)=(from=43939,to=5075)
+ to_title(1135)=(from=43940,to=5076)
+ to_title(1136)=(from=43941,to=5077)
+ to_title(1137)=(from=43942,to=5078)
+ to_title(1138)=(from=43943,to=5079)
+ to_title(1139)=(from=43944,to=5080)
+ to_title(1140)=(from=43945,to=5081)
+ to_title(1141)=(from=43946,to=5082)
+ to_title(1142)=(from=43947,to=5083)
+ to_title(1143)=(from=43948,to=5084)
+ to_title(1144)=(from=43949,to=5085)
+ to_title(1145)=(from=43950,to=5086)
+ to_title(1146)=(from=43951,to=5087)
+ to_title(1147)=(from=43952,to=5088)
+ to_title(1148)=(from=43953,to=5089)
+ to_title(1149)=(from=43954,to=5090)
+ to_title(1150)=(from=43955,to=5091)
+ to_title(1151)=(from=43956,to=5092)
+ to_title(1152)=(from=43957,to=5093)
+ to_title(1153)=(from=43958,to=5094)
+ to_title(1154)=(from=43959,to=5095)
+ to_title(1155)=(from=43960,to=5096)
+ to_title(1156)=(from=43961,to=5097)
+ to_title(1157)=(from=43962,to=5098)
+ to_title(1158)=(from=43963,to=5099)
+ to_title(1159)=(from=43964,to=5100)
+ to_title(1160)=(from=43965,to=5101)
+ to_title(1161)=(from=43966,to=5102)
+ to_title(1162)=(from=43967,to=5103)
+ to_title(1163)=(from=65345,to=65313)
+ to_title(1164)=(from=65346,to=65314)
+ to_title(1165)=(from=65347,to=65315)
+ to_title(1166)=(from=65348,to=65316)
+ to_title(1167)=(from=65349,to=65317)
+ to_title(1168)=(from=65350,to=65318)
+ to_title(1169)=(from=65351,to=65319)
+ to_title(1170)=(from=65352,to=65320)
+ to_title(1171)=(from=65353,to=65321)
+ to_title(1172)=(from=65354,to=65322)
+ to_title(1173)=(from=65355,to=65323)
+ to_title(1174)=(from=65356,to=65324)
+ to_title(1175)=(from=65357,to=65325)
+ to_title(1176)=(from=65358,to=65326)
+ to_title(1177)=(from=65359,to=65327)
+ to_title(1178)=(from=65360,to=65328)
+ to_title(1179)=(from=65361,to=65329)
+ to_title(1180)=(from=65362,to=65330)
+ to_title(1181)=(from=65363,to=65331)
+ to_title(1182)=(from=65364,to=65332)
+ to_title(1183)=(from=65365,to=65333)
+ to_title(1184)=(from=65366,to=65334)
+ to_title(1185)=(from=65367,to=65335)
+ to_title(1186)=(from=65368,to=65336)
+ to_title(1187)=(from=65369,to=65337)
+ to_title(1188)=(from=65370,to=65338)
+ to_title(1189)=(from=66600,to=66560)
+ to_title(1190)=(from=66601,to=66561)
+ to_title(1191)=(from=66602,to=66562)
+ to_title(1192)=(from=66603,to=66563)
+ to_title(1193)=(from=66604,to=66564)
+ to_title(1194)=(from=66605,to=66565)
+ to_title(1195)=(from=66606,to=66566)
+ to_title(1196)=(from=66607,to=66567)
+ to_title(1197)=(from=66608,to=66568)
+ to_title(1198)=(from=66609,to=66569)
+ to_title(1199)=(from=66610,to=66570)
+ to_title(1200)=(from=66611,to=66571)
+ to_title(1201)=(from=66612,to=66572)
+ to_title(1202)=(from=66613,to=66573)
+ to_title(1203)=(from=66614,to=66574)
+ to_title(1204)=(from=66615,to=66575)
+ to_title(1205)=(from=66616,to=66576)
+ to_title(1206)=(from=66617,to=66577)
+ to_title(1207)=(from=66618,to=66578)
+ to_title(1208)=(from=66619,to=66579)
+ to_title(1209)=(from=66620,to=66580)
+ to_title(1210)=(from=66621,to=66581)
+ to_title(1211)=(from=66622,to=66582)
+ to_title(1212)=(from=66623,to=66583)
+ to_title(1213)=(from=66624,to=66584)
+ to_title(1214)=(from=66625,to=66585)
+ to_title(1215)=(from=66626,to=66586)
+ to_title(1216)=(from=66627,to=66587)
+ to_title(1217)=(from=66628,to=66588)
+ to_title(1218)=(from=66629,to=66589)
+ to_title(1219)=(from=66630,to=66590)
+ to_title(1220)=(from=66631,to=66591)
+ to_title(1221)=(from=66632,to=66592)
+ to_title(1222)=(from=66633,to=66593)
+ to_title(1223)=(from=66634,to=66594)
+ to_title(1224)=(from=66635,to=66595)
+ to_title(1225)=(from=66636,to=66596)
+ to_title(1226)=(from=66637,to=66597)
+ to_title(1227)=(from=66638,to=66598)
+ to_title(1228)=(from=66639,to=66599)
+ to_title(1229)=(from=66776,to=66736)
+ to_title(1230)=(from=66777,to=66737)
+ to_title(1231)=(from=66778,to=66738)
+ to_title(1232)=(from=66779,to=66739)
+ to_title(1233)=(from=66780,to=66740)
+ to_title(1234)=(from=66781,to=66741)
+ to_title(1235)=(from=66782,to=66742)
+ to_title(1236)=(from=66783,to=66743)
+ to_title(1237)=(from=66784,to=66744)
+ to_title(1238)=(from=66785,to=66745)
+ to_title(1239)=(from=66786,to=66746)
+ to_title(1240)=(from=66787,to=66747)
+ to_title(1241)=(from=66788,to=66748)
+ to_title(1242)=(from=66789,to=66749)
+ to_title(1243)=(from=66790,to=66750)
+ to_title(1244)=(from=66791,to=66751)
+ to_title(1245)=(from=66792,to=66752)
+ to_title(1246)=(from=66793,to=66753)
+ to_title(1247)=(from=66794,to=66754)
+ to_title(1248)=(from=66795,to=66755)
+ to_title(1249)=(from=66796,to=66756)
+ to_title(1250)=(from=66797,to=66757)
+ to_title(1251)=(from=66798,to=66758)
+ to_title(1252)=(from=66799,to=66759)
+ to_title(1253)=(from=66800,to=66760)
+ to_title(1254)=(from=66801,to=66761)
+ to_title(1255)=(from=66802,to=66762)
+ to_title(1256)=(from=66803,to=66763)
+ to_title(1257)=(from=66804,to=66764)
+ to_title(1258)=(from=66805,to=66765)
+ to_title(1259)=(from=66806,to=66766)
+ to_title(1260)=(from=66807,to=66767)
+ to_title(1261)=(from=66808,to=66768)
+ to_title(1262)=(from=66809,to=66769)
+ to_title(1263)=(from=66810,to=66770)
+ to_title(1264)=(from=66811,to=66771)
+ to_title(1265)=(from=68800,to=68736)
+ to_title(1266)=(from=68801,to=68737)
+ to_title(1267)=(from=68802,to=68738)
+ to_title(1268)=(from=68803,to=68739)
+ to_title(1269)=(from=68804,to=68740)
+ to_title(1270)=(from=68805,to=68741)
+ to_title(1271)=(from=68806,to=68742)
+ to_title(1272)=(from=68807,to=68743)
+ to_title(1273)=(from=68808,to=68744)
+ to_title(1274)=(from=68809,to=68745)
+ to_title(1275)=(from=68810,to=68746)
+ to_title(1276)=(from=68811,to=68747)
+ to_title(1277)=(from=68812,to=68748)
+ to_title(1278)=(from=68813,to=68749)
+ to_title(1279)=(from=68814,to=68750)
+ to_title(1280)=(from=68815,to=68751)
+ to_title(1281)=(from=68816,to=68752)
+ to_title(1282)=(from=68817,to=68753)
+ to_title(1283)=(from=68818,to=68754)
+ to_title(1284)=(from=68819,to=68755)
+ to_title(1285)=(from=68820,to=68756)
+ to_title(1286)=(from=68821,to=68757)
+ to_title(1287)=(from=68822,to=68758)
+ to_title(1288)=(from=68823,to=68759)
+ to_title(1289)=(from=68824,to=68760)
+ to_title(1290)=(from=68825,to=68761)
+ to_title(1291)=(from=68826,to=68762)
+ to_title(1292)=(from=68827,to=68763)
+ to_title(1293)=(from=68828,to=68764)
+ to_title(1294)=(from=68829,to=68765)
+ to_title(1295)=(from=68830,to=68766)
+ to_title(1296)=(from=68831,to=68767)
+ to_title(1297)=(from=68832,to=68768)
+ to_title(1298)=(from=68833,to=68769)
+ to_title(1299)=(from=68834,to=68770)
+ to_title(1300)=(from=68835,to=68771)
+ to_title(1301)=(from=68836,to=68772)
+ to_title(1302)=(from=68837,to=68773)
+ to_title(1303)=(from=68838,to=68774)
+ to_title(1304)=(from=68839,to=68775)
+ to_title(1305)=(from=68840,to=68776)
+ to_title(1306)=(from=68841,to=68777)
+ to_title(1307)=(from=68842,to=68778)
+ to_title(1308)=(from=68843,to=68779)
+ to_title(1309)=(from=68844,to=68780)
+ to_title(1310)=(from=68845,to=68781)
+ to_title(1311)=(from=68846,to=68782)
+ to_title(1312)=(from=68847,to=68783)
+ to_title(1313)=(from=68848,to=68784)
+ to_title(1314)=(from=68849,to=68785)
+ to_title(1315)=(from=68850,to=68786)
+ to_title(1316)=(from=71872,to=71840)
+ to_title(1317)=(from=71873,to=71841)
+ to_title(1318)=(from=71874,to=71842)
+ to_title(1319)=(from=71875,to=71843)
+ to_title(1320)=(from=71876,to=71844)
+ to_title(1321)=(from=71877,to=71845)
+ to_title(1322)=(from=71878,to=71846)
+ to_title(1323)=(from=71879,to=71847)
+ to_title(1324)=(from=71880,to=71848)
+ to_title(1325)=(from=71881,to=71849)
+ to_title(1326)=(from=71882,to=71850)
+ to_title(1327)=(from=71883,to=71851)
+ to_title(1328)=(from=71884,to=71852)
+ to_title(1329)=(from=71885,to=71853)
+ to_title(1330)=(from=71886,to=71854)
+ to_title(1331)=(from=71887,to=71855)
+ to_title(1332)=(from=71888,to=71856)
+ to_title(1333)=(from=71889,to=71857)
+ to_title(1334)=(from=71890,to=71858)
+ to_title(1335)=(from=71891,to=71859)
+ to_title(1336)=(from=71892,to=71860)
+ to_title(1337)=(from=71893,to=71861)
+ to_title(1338)=(from=71894,to=71862)
+ to_title(1339)=(from=71895,to=71863)
+ to_title(1340)=(from=71896,to=71864)
+ to_title(1341)=(from=71897,to=71865)
+ to_title(1342)=(from=71898,to=71866)
+ to_title(1343)=(from=71899,to=71867)
+ to_title(1344)=(from=71900,to=71868)
+ to_title(1345)=(from=71901,to=71869)
+ to_title(1346)=(from=71902,to=71870)
+ to_title(1347)=(from=71903,to=71871)
+ to_title(1348)=(from=93792,to=93760)
+ to_title(1349)=(from=93793,to=93761)
+ to_title(1350)=(from=93794,to=93762)
+ to_title(1351)=(from=93795,to=93763)
+ to_title(1352)=(from=93796,to=93764)
+ to_title(1353)=(from=93797,to=93765)
+ to_title(1354)=(from=93798,to=93766)
+ to_title(1355)=(from=93799,to=93767)
+ to_title(1356)=(from=93800,to=93768)
+ to_title(1357)=(from=93801,to=93769)
+ to_title(1358)=(from=93802,to=93770)
+ to_title(1359)=(from=93803,to=93771)
+ to_title(1360)=(from=93804,to=93772)
+ to_title(1361)=(from=93805,to=93773)
+ to_title(1362)=(from=93806,to=93774)
+ to_title(1363)=(from=93807,to=93775)
+ to_title(1364)=(from=93808,to=93776)
+ to_title(1365)=(from=93809,to=93777)
+ to_title(1366)=(from=93810,to=93778)
+ to_title(1367)=(from=93811,to=93779)
+ to_title(1368)=(from=93812,to=93780)
+ to_title(1369)=(from=93813,to=93781)
+ to_title(1370)=(from=93814,to=93782)
+ to_title(1371)=(from=93815,to=93783)
+ to_title(1372)=(from=93816,to=93784)
+ to_title(1373)=(from=93817,to=93785)
+ to_title(1374)=(from=93818,to=93786)
+ to_title(1375)=(from=93819,to=93787)
+ to_title(1376)=(from=93820,to=93788)
+ to_title(1377)=(from=93821,to=93789)
+ to_title(1378)=(from=93822,to=93790)
+ to_title(1379)=(from=93823,to=93791)
+ to_title(1380)=(from=125218,to=125184)
+ to_title(1381)=(from=125219,to=125185)
+ to_title(1382)=(from=125220,to=125186)
+ to_title(1383)=(from=125221,to=125187)
+ to_title(1384)=(from=125222,to=125188)
+ to_title(1385)=(from=125223,to=125189)
+ to_title(1386)=(from=125224,to=125190)
+ to_title(1387)=(from=125225,to=125191)
+ to_title(1388)=(from=125226,to=125192)
+ to_title(1389)=(from=125227,to=125193)
+ to_title(1390)=(from=125228,to=125194)
+ to_title(1391)=(from=125229,to=125195)
+ to_title(1392)=(from=125230,to=125196)
+ to_title(1393)=(from=125231,to=125197)
+ to_title(1394)=(from=125232,to=125198)
+ to_title(1395)=(from=125233,to=125199)
+ to_title(1396)=(from=125234,to=125200)
+ to_title(1397)=(from=125235,to=125201)
+ to_title(1398)=(from=125236,to=125202)
+ to_title(1399)=(from=125237,to=125203)
+ to_title(1400)=(from=125238,to=125204)
+ to_title(1401)=(from=125239,to=125205)
+ to_title(1402)=(from=125240,to=125206)
+ to_title(1403)=(from=125241,to=125207)
+ to_title(1404)=(from=125242,to=125208)
+ to_title(1405)=(from=125243,to=125209)
+ to_title(1406)=(from=125244,to=125210)
+ to_title(1407)=(from=125245,to=125211)
+ to_title(1408)=(from=125246,to=125212)
+ to_title(1409)=(from=125247,to=125213)
+ to_title(1410)=(from=125248,to=125214)
+ to_title(1411)=(from=125249,to=125215)
+ to_title(1412)=(from=125250,to=125216)
+ to_title(1413)=(from=125251,to=125217)
+}
\ No newline at end of file