diff --git a/Import/GacUI.UnitTest.h b/Import/GacUI.UnitTest.h index 11d1e1c0..436b0549 100644 --- a/Import/GacUI.UnitTest.h +++ b/Import/GacUI.UnitTest.h @@ -1393,6 +1393,50 @@ IGuiRemoteProtocolMessages (Elements - Image) #undef ERROR_MESSAGE_PREFIX } +/*********************************************************************** +IGuiRemoteProtocolMessages (Elements - Document) +***********************************************************************/ + + void RequestRendererUpdateElement_DocumentParagraph(vint id, const remoteprotocol::ElementDesc_DocumentParagraph& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_GetCaret(vint id, const remoteprotocol::GetCaretRequest& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_GetCaretBounds(vint id, const remoteprotocol::GetCaretBoundsRequest& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_GetInlineObjectFromPoint(vint id, const Point& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_GetNearestCaretFromTextPos(vint id, const remoteprotocol::GetCaretBoundsRequest& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_IsValidCaret(vint id, const vint& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_OpenCaret(const remoteprotocol::OpenCaretRequest& arguments) override + { + CHECK_FAIL(L"Not implemented."); + } + + void RequestDocumentParagraph_CloseCaret() override + { + CHECK_FAIL(L"Not implemented."); + } + #undef REQUEST_RENDERER_UPDATE_ELEMENT #undef REQUEST_RENDERER_UPDATE_ELEMENT2 }; @@ -1697,7 +1741,15 @@ void GacUIUnitTest_StartFast_WithResourceAsText( const vl::presentation::unittest::UnitTestMainFunc& previousMainProxy ) { - protocol->GetEvents()->OnControllerConnect(); + { + vl::presentation::remoteprotocol::ControllerGlobalConfig globalConfig; +#if defined VCZH_WCHAR_UTF16 + globalConfig.documentCaretFromEncoding = vl::presentation::remoteprotocol::CharacterEncoding::UTF16; +#elif defined VCZH_WCHAR_UTF32 + globalConfig.documentCaretFromEncoding = vl::presentation::remoteprotocol::CharacterEncoding::UTF32; +#endif + protocol->GetEvents()->OnControllerConnect(globalConfig); + } auto theme = vl::Ptr(new TTheme); vl::presentation::theme::RegisterTheme(theme); { diff --git a/Import/GacUI.cpp b/Import/GacUI.cpp index 14325226..cb79e8d7 100644 --- a/Import/GacUI.cpp +++ b/Import/GacUI.cpp @@ -34968,8 +34968,9 @@ GuiRemoteController::INativeWindowService GuiRemoteController (events) ***********************************************************************/ - void GuiRemoteController::OnControllerConnect() + void GuiRemoteController::OnControllerConnect(const remoteprotocol::ControllerGlobalConfig& _globalConfig) { + remoteGlobalConfig = _globalConfig; UpdateGlobalShortcutKey(); vint idGetFontConfig = remoteMessages.RequestControllerGetFontConfig(); vint idGetScreenConfig = remoteMessages.RequestControllerGetScreenConfig(); @@ -35018,6 +35019,11 @@ GuiRemoteController , remoteWindow(this) , imageService(this) { +#if defined VCZH_WCHAR_UTF16 + remoteGlobalConfig.documentCaretFromEncoding = remoteprotocol::CharacterEncoding::UTF16; +#elif defined VCZH_WCHAR_UTF32 + remoteGlobalConfig.documentCaretFromEncoding = remoteprotocol::CharacterEncoding::UTF32; +#endif } GuiRemoteController::~GuiRemoteController() @@ -35039,6 +35045,11 @@ GuiRemoteController // there is no result from this request, assuming succeeded } + remoteprotocol::ControllerGlobalConfig GuiRemoteController::GetGlobalConfig() + { + return remoteGlobalConfig; + } + /*********************************************************************** GuiRemoteController (INativeController) ***********************************************************************/ @@ -35253,10 +35264,10 @@ GuiRemoteEvents (messages) GuiRemoteEvents (events) ***********************************************************************/ - void GuiRemoteEvents::OnControllerConnect() + void GuiRemoteEvents::OnControllerConnect(const remoteprotocol::ControllerGlobalConfig& arguments) { remote->remoteMessages.RequestControllerConnectionEstablished(); - remote->OnControllerConnect(); + remote->OnControllerConnect(arguments); bool disconnected = false; remote->remoteMessages.Submit(disconnected); // there is no result from this request, assuming succeeded @@ -35391,6 +35402,14 @@ GuiRemoteEvents (events) { for (auto l : remote->remoteWindow.listeners) l->Char(arguments); } + + void GuiRemoteEvents::OnDocumentParagraph_RenderInlineObjects(const Ptr>& arguments) + { + if (arguments) + { + remote->resourceManager->OnDocumentParagraph_RenderInlineObjects(*arguments.Obj()); + } + } } /*********************************************************************** @@ -35464,14 +35483,19 @@ GuiRemoteGraphicsRenderTarget remote->remoteMessages.RequestRendererDestroyed(ids); } - if (createdRenderers.Count() > 0) + if (createdRenderers.Count() > 0 || pendingParagraphCreations.Count() > 0) { auto ids = Ptr(new List); for (auto id : createdRenderers) { ids->Add({ id,renderers[id]->GetRendererType() }); } + for (auto&& creation : pendingParagraphCreations) + { + ids->Add(creation); + } createdRenderers.Clear(); + pendingParagraphCreations.Clear(); remote->remoteMessages.RequestRendererCreated(ids); } @@ -35753,10 +35777,57 @@ GuiRemoteGraphicsRenderTarget return clipperValidArea.Value(); } + GuiRemoteGraphicsParagraph* GuiRemoteGraphicsRenderTarget::GetParagraph(vint id) + { + vint index = paragraphs.Keys().IndexOf(id); + return index == -1 ? nullptr : paragraphs.Values()[index]; + } + + void GuiRemoteGraphicsRenderTarget::RegisterParagraph(GuiRemoteGraphicsParagraph* paragraph) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::elements::GuiRemoteGraphicsRenderTarget::RegisterParagraph(GuiRemoteGraphicsParagraph*)#" + auto paragraphId = paragraph->GetParagraphId(); + CHECK_ERROR(!paragraphs.Keys().Contains(paragraphId), ERROR_MESSAGE_PREFIX L"Duplicated paragraph id."); + paragraphs.Add(paragraphId, paragraph); + pendingParagraphCreations.Add({ paragraphId,remoteprotocol::RendererType::DocumentParagraph }); +#undef ERROR_MESSAGE_PREFIX + } + + void GuiRemoteGraphicsRenderTarget::UnregisterParagraph(vint id) + { + vint index = paragraphs.Keys().IndexOf(id); + if (index == -1) + { + return; + } + + paragraphs.Remove(id); + for (vint i = pendingParagraphCreations.Count() - 1; i >= 0; i--) + { + if (pendingParagraphCreations[i].id == id) + { + pendingParagraphCreations.RemoveAt(i); + return; + } + } + if (!destroyedRenderers.Contains(id)) + { + destroyedRenderers.Add(id); + } + } + /*********************************************************************** GuiRemoteGraphicsResourceManager ***********************************************************************/ + Ptr GuiRemoteGraphicsResourceManager::CreateParagraph(const WString& text, IGuiGraphicsRenderTarget* _renderTarget, IGuiGraphicsParagraphCallback* callback) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::elements::GuiRemoteGraphicsResourceManager::CreateParagraph(const WString&, IGuiGraphicsRenderTarget*, IGuiGraphicsParagraphCallback*)#" + CHECK_ERROR(&renderTarget == _renderTarget, ERROR_MESSAGE_PREFIX L"Unexpected render target object."); + return Ptr(new GuiRemoteGraphicsParagraph(text, remote, this, &renderTarget, callback)); +#undef ERROR_MESSAGE_PREFIX + } + GuiRemoteGraphicsResourceManager::GuiRemoteGraphicsResourceManager(GuiRemoteController* _remote, GuiHostedController* _hostedController) : remote(_remote) , renderTarget(_remote, _hostedController) @@ -35800,6 +35871,11 @@ GuiRemoteGraphicsResourceManager renderTarget.OnControllerDisconnect(); } + void GuiRemoteGraphicsResourceManager::OnDocumentParagraph_RenderInlineObjects(collections::List& arguments) + { + CHECK_FAIL(L"Not Implemented!"); + } + IGuiGraphicsRenderTarget* GuiRemoteGraphicsResourceManager::GetRenderTarget(INativeWindow* window) { CHECK_ERROR(window == &remote->remoteWindow, L"vl::presentation::elements::GuiRemoteGraphicsResourceManager::GetRenderTarget(INativeWindow*)#GuiHostedController should call this function with the native window."); @@ -35816,7 +35892,7 @@ GuiRemoteGraphicsResourceManager IGuiGraphicsLayoutProvider* GuiRemoteGraphicsResourceManager::GetLayoutProvider() { - CHECK_FAIL(L"Not Implemented!"); + return this; } Ptr GuiRemoteGraphicsResourceManager::CreateRawElement() @@ -36405,6 +36481,1120 @@ GuiPolygonElementRenderer } } +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS_DOCUMENT.CPP +***********************************************************************/ + +namespace vl::presentation::elements +{ + using namespace collections; + +/*********************************************************************** +Comparison +***********************************************************************/ + + bool AreEqual(const DocumentTextRunPropertyOverrides& a, const DocumentTextRunPropertyOverrides& b) + { + return a.textColor == b.textColor && + a.backgroundColor == b.backgroundColor && + a.fontFamily == b.fontFamily && + a.size == b.size && + a.textStyle == b.textStyle; + } + + bool AreEqual(const remoteprotocol::DocumentTextRunProperty& a, const remoteprotocol::DocumentTextRunProperty& b) + { + return a.textColor == b.textColor && + a.backgroundColor == b.backgroundColor && + a.fontProperties == b.fontProperties; + } + + bool AreEqual(const remoteprotocol::DocumentRunProperty& a, const remoteprotocol::DocumentRunProperty& b) + { + if (a.Index() != b.Index()) + return false; + + if (auto textA = a.TryGet()) + { + auto textB = b.Get(); + return AreEqual(*textA, textB); + } + else + { + auto inlineA = a.Get(); + auto inlineB = b.Get(); + return inlineA.size == inlineB.size && + inlineA.baseline == inlineB.baseline && + inlineA.breakCondition == inlineB.breakCondition && + inlineA.backgroundElementId == inlineB.backgroundElementId && + inlineA.callbackId == inlineB.callbackId; + } + } + +/*********************************************************************** +DiffRuns +***********************************************************************/ + + DocumentTextRunPropertyOverrides ApplyOverrides( + const DocumentTextRunPropertyOverrides& base, + const DocumentTextRunPropertyOverrides& overrides) + { + DocumentTextRunPropertyOverrides result; + result.textColor = overrides.textColor ? overrides.textColor : base.textColor; + result.backgroundColor = overrides.backgroundColor ? overrides.backgroundColor : base.backgroundColor; + result.fontFamily = overrides.fontFamily ? overrides.fontFamily : base.fontFamily; + result.size = overrides.size ? overrides.size : base.size; + result.textStyle = overrides.textStyle ? overrides.textStyle : base.textStyle; + return result; + } + + void AddTextRun( + DocumentTextRunPropertyMap& map, + CaretRange range, + const DocumentTextRunPropertyOverrides& propertyOverrides) + { + vint firstOverlap = -1; + + if (map.Count() > 0) + { + auto comparer = [&](const CaretRange& key, const CaretRange& searchRange) -> std::strong_ordering + { + if (key.caretEnd <= searchRange.caretBegin) + return std::strong_ordering::less; + else if (key.caretBegin >= searchRange.caretEnd) + return std::strong_ordering::greater; + else + return std::strong_ordering::equal; + }; + + vint index = -1; + firstOverlap = BinarySearchLambda(&map.Keys()[0], map.Keys().Count(), range, index, comparer); + + // Binary search may return any overlapping entry, scan backwards to find the first one + if (firstOverlap != -1) + { + while (firstOverlap > 0) + { + auto&& prevKey = map.Keys()[firstOverlap - 1]; + if (prevKey.caretEnd <= range.caretBegin || prevKey.caretBegin >= range.caretEnd) + break; + firstOverlap--; + } + } + } + + List> fragmentsToReinsert; + List keysToRemove; + List> overlappingOldRuns; + + if (firstOverlap != -1) + { + auto&& keys = map.Keys(); + for (vint i = firstOverlap; i < keys.Count(); i++) + { + auto&& key = keys[i]; + if (key.caretBegin >= range.caretEnd) + break; + + auto&& oldProperty = map[key]; + + // Record the overlapping portion + vint overlapBegin = key.caretBegin < range.caretBegin ? range.caretBegin : key.caretBegin; + vint overlapEnd = key.caretEnd > range.caretEnd ? range.caretEnd : key.caretEnd; + overlappingOldRuns.Add({CaretRange{overlapBegin, overlapEnd}, oldProperty}); + + if (key.caretBegin < range.caretBegin) + { + CaretRange beforeRange{ key.caretBegin, range.caretBegin }; + fragmentsToReinsert.Add({ beforeRange, oldProperty }); + } + + if (key.caretEnd > range.caretEnd) + { + CaretRange afterRange{ range.caretEnd, key.caretEnd }; + fragmentsToReinsert.Add({ afterRange, oldProperty }); + } + + keysToRemove.Add(key); + } + + for (auto&& key : keysToRemove) + { + map.Remove(key); + } + } + + for (auto&& fragment : fragmentsToReinsert) + { + map.Add(fragment.key, fragment.value); + } + + if (overlappingOldRuns.Count() > 0) + { + // The new range has overlaps with old runs - apply override semantics + vint currentPos = range.caretBegin; + + for (vint i = 0; i < overlappingOldRuns.Count(); i++) + { + auto&& [oldRange, oldProp] = overlappingOldRuns[i]; + + // Add any gap before this overlap with new properties as-is + if (currentPos < oldRange.caretBegin) + { + map.Add(CaretRange{currentPos, oldRange.caretBegin}, propertyOverrides); + } + + // Add the overlapping portion with merged properties + auto mergedProp = ApplyOverrides(oldProp, propertyOverrides); + map.Add(oldRange, mergedProp); + + currentPos = oldRange.caretEnd; + } + + // Add any remaining part after all overlaps with new properties as-is + if (currentPos < range.caretEnd) + { + map.Add(CaretRange{currentPos, range.caretEnd}, propertyOverrides); + } + } + else + { + // No overlaps - add the entire range with new properties + map.Add(range, propertyOverrides); + } + + // Find the first key within the original range for merging + vint newIndex = -1; + auto&& keys = map.Keys(); + for (vint i = 0; i < keys.Count(); i++) + { + if (keys[i].caretBegin >= range.caretBegin) + { + newIndex = i; + break; + } + } + + if (newIndex == -1) + return; + + while (newIndex > 0) + { + CaretRange leftKey = map.Keys()[newIndex - 1]; + CaretRange currentKey = map.Keys()[newIndex]; + + if (leftKey.caretEnd == currentKey.caretBegin && + AreEqual(map[leftKey], map[currentKey])) + { + CaretRange mergedRange{ leftKey.caretBegin, currentKey.caretEnd }; + auto mergedProperty = map[leftKey]; + + map.Remove(leftKey); + map.Remove(currentKey); + map.Add(mergedRange, mergedProperty); + + newIndex = map.Keys().IndexOf(mergedRange); + } + else + { + break; + } + } + + while (newIndex < map.Keys().Count() - 1) + { + CaretRange currentKey = map.Keys()[newIndex]; + CaretRange rightKey = map.Keys()[newIndex + 1]; + + if (currentKey.caretEnd == rightKey.caretBegin && + AreEqual(map[currentKey], map[rightKey])) + { + CaretRange mergedRange{ currentKey.caretBegin, rightKey.caretEnd }; + auto mergedProperty = map[currentKey]; + + map.Remove(currentKey); + map.Remove(rightKey); + map.Add(mergedRange, mergedProperty); + + newIndex = map.Keys().IndexOf(mergedRange); + } + else + { + break; + } + } + } + + bool AddInlineObjectRun( + DocumentInlineObjectRunPropertyMap& map, + CaretRange range, + const remoteprotocol::DocumentInlineObjectRunProperty& property) + { + if (map.Count() > 0) + { + auto comparer = [&](const CaretRange& key, const CaretRange& searchRange) -> std::strong_ordering + { + if (key.caretEnd <= searchRange.caretBegin) + return std::strong_ordering::less; + else if (key.caretBegin >= searchRange.caretEnd) + return std::strong_ordering::greater; + else + return std::strong_ordering::equal; + }; + + vint index = -1; + vint firstOverlap = BinarySearchLambda(&map.Keys()[0], map.Keys().Count(), range, index, comparer); + + if (firstOverlap != -1) + return false; + } + + map.Add(range, property); + return true; + } + + bool ResetInlineObjectRun( + DocumentInlineObjectRunPropertyMap& map, + CaretRange range) + { + return map.Remove(range); + } + + remoteprotocol::DocumentTextRunProperty ConvertToFullProperty(const DocumentTextRunPropertyOverrides& propertyOverrides) + { + remoteprotocol::DocumentTextRunProperty fullProp; + + // Required properties - validate non-null + CHECK_ERROR(propertyOverrides.fontFamily, L"fontFamily must be defined"); + CHECK_ERROR(propertyOverrides.size, L"size must be defined"); + + fullProp.fontProperties.fontFamily = propertyOverrides.fontFamily.Value(); + fullProp.fontProperties.size = propertyOverrides.size.Value(); + + // Optional properties - use defaults if null + fullProp.textColor = propertyOverrides.textColor ? + propertyOverrides.textColor.Value() : Color(0, 0, 0); + fullProp.backgroundColor = propertyOverrides.backgroundColor ? + propertyOverrides.backgroundColor.Value() : Color(0, 0, 0); + + auto style = propertyOverrides.textStyle ? + propertyOverrides.textStyle.Value() : (IGuiGraphicsParagraph::TextStyle)0; + + // Convert TextStyle enum flags to individual bool fields + fullProp.fontProperties.bold = (style & IGuiGraphicsParagraph::TextStyle::Bold) != (IGuiGraphicsParagraph::TextStyle)0; + fullProp.fontProperties.italic = (style & IGuiGraphicsParagraph::TextStyle::Italic) != (IGuiGraphicsParagraph::TextStyle)0; + fullProp.fontProperties.underline = (style & IGuiGraphicsParagraph::TextStyle::Underline) != (IGuiGraphicsParagraph::TextStyle)0; + fullProp.fontProperties.strikeline = (style & IGuiGraphicsParagraph::TextStyle::Strikeline) != (IGuiGraphicsParagraph::TextStyle)0; + + // Set default values for antialias properties + fullProp.fontProperties.antialias = true; + fullProp.fontProperties.verticalAntialias = true; + + return fullProp; + } + + void MergeRuns( + const DocumentTextRunPropertyMap& textRuns, + const DocumentInlineObjectRunPropertyMap& inlineObjectRuns, + DocumentRunPropertyMap& result) + { + result.Clear(); + + vint textIdx = 0; + vint inlineIdx = 0; + + auto&& textKeys = textRuns.Keys(); + auto&& inlineKeys = inlineObjectRuns.Keys(); + + CaretRange currentTextRange; + DocumentTextRunPropertyOverrides currentTextProperty; + bool hasCurrentText = false; + vint lastInlineEnd = -1; + + while (textIdx < textKeys.Count() || inlineIdx < inlineKeys.Count() || hasCurrentText) + { + if (!hasCurrentText && textIdx < textKeys.Count()) + { + currentTextRange = textKeys[textIdx]; + currentTextProperty = textRuns[currentTextRange]; + hasCurrentText = true; + textIdx++; + + // Trim text run if it overlaps with the last processed inline object + if (lastInlineEnd > currentTextRange.caretBegin) + { + if (lastInlineEnd >= currentTextRange.caretEnd) + { + // Text run is completely within the last inline object + hasCurrentText = false; + continue; + } + else + { + // Text run partially overlaps, trim the beginning + currentTextRange.caretBegin = lastInlineEnd; + } + } + } + + if (hasCurrentText && inlineIdx >= inlineKeys.Count()) + { + remoteprotocol::DocumentRunProperty runProp = ConvertToFullProperty(currentTextProperty); + result.Add(currentTextRange, runProp); + hasCurrentText = false; + continue; + } + + if (!hasCurrentText && inlineIdx < inlineKeys.Count()) + { + auto&& inlineKey = inlineKeys[inlineIdx]; + remoteprotocol::DocumentRunProperty runProp = inlineObjectRuns[inlineKey]; + result.Add(inlineKey, runProp); + lastInlineEnd = inlineKey.caretEnd; + inlineIdx++; + continue; + } + + if (hasCurrentText && inlineIdx < inlineKeys.Count()) + { + auto&& inlineKey = inlineKeys[inlineIdx]; + + if (currentTextRange.caretEnd <= inlineKey.caretBegin) + { + remoteprotocol::DocumentRunProperty runProp = ConvertToFullProperty(currentTextProperty); + result.Add(currentTextRange, runProp); + hasCurrentText = false; + } + else if (inlineKey.caretEnd <= currentTextRange.caretBegin) + { + remoteprotocol::DocumentRunProperty runProp = inlineObjectRuns[inlineKey]; + result.Add(inlineKey, runProp); + lastInlineEnd = inlineKey.caretEnd; + inlineIdx++; + } + else + { + if (currentTextRange.caretBegin < inlineKey.caretBegin) + { + CaretRange beforeRange{ currentTextRange.caretBegin, inlineKey.caretBegin }; + + remoteprotocol::DocumentRunProperty runProp = ConvertToFullProperty(currentTextProperty); + result.Add(beforeRange, runProp); + } + + remoteprotocol::DocumentRunProperty runProp = inlineObjectRuns[inlineKey]; + result.Add(inlineKey, runProp); + lastInlineEnd = inlineKey.caretEnd; + inlineIdx++; + + if (currentTextRange.caretEnd > inlineKey.caretEnd) + { + currentTextRange.caretBegin = inlineKey.caretEnd; + } + else + { + hasCurrentText = false; + } + } + } + } + } + + void DiffRuns( + const DocumentRunPropertyMap& oldRuns, + const DocumentRunPropertyMap& newRuns, + remoteprotocol::ElementDesc_DocumentParagraph& result) + { + result.runsDiff = Ptr(new List()); + result.createdInlineObjects = Ptr(new List()); + result.removedInlineObjects = Ptr(new List()); + + SortedList oldInlineCallbackIds; + SortedList newInlineCallbackIds; + + vint oldIdx = 0; + vint newIdx = 0; + + auto&& oldKeys = oldRuns.Keys(); + auto&& newKeys = newRuns.Keys(); + + while (oldIdx < oldKeys.Count() || newIdx < newKeys.Count()) + { + if (oldIdx >= oldKeys.Count()) + { + auto&& newKey = newKeys[newIdx]; + auto&& newValue = newRuns[newKey]; + + remoteprotocol::DocumentRun run; + run.caretBegin = newKey.caretBegin; + run.caretEnd = newKey.caretEnd; + run.props = newValue; + result.runsDiff->Add(run); + + if (auto inlineObj = newValue.TryGet()) + { + newInlineCallbackIds.Add(inlineObj->callbackId); + } + + newIdx++; + continue; + } + + if (newIdx >= newKeys.Count()) + { + auto&& oldKey = oldKeys[oldIdx]; + auto&& oldValue = oldRuns[oldKey]; + + if (auto inlineObj = oldValue.TryGet()) + { + oldInlineCallbackIds.Add(inlineObj->callbackId); + } + + oldIdx++; + continue; + } + + auto&& oldKey = oldKeys[oldIdx]; + auto&& newKey = newKeys[newIdx]; + + if (oldKey == newKey) + { + auto&& oldValue = oldRuns[oldKey]; + auto&& newValue = newRuns[newKey]; + + if (auto inlineObj = oldValue.TryGet()) + { + oldInlineCallbackIds.Add(inlineObj->callbackId); + } + if (auto inlineObj = newValue.TryGet()) + { + newInlineCallbackIds.Add(inlineObj->callbackId); + } + + if (!AreEqual(oldValue, newValue)) + { + remoteprotocol::DocumentRun run; + run.caretBegin = newKey.caretBegin; + run.caretEnd = newKey.caretEnd; + run.props = newValue; + result.runsDiff->Add(run); + } + + oldIdx++; + newIdx++; + } + else if (newKey < oldKey) + { + auto&& newValue = newRuns[newKey]; + + remoteprotocol::DocumentRun run; + run.caretBegin = newKey.caretBegin; + run.caretEnd = newKey.caretEnd; + run.props = newValue; + result.runsDiff->Add(run); + + if (auto inlineObj = newValue.TryGet()) + { + newInlineCallbackIds.Add(inlineObj->callbackId); + } + + newIdx++; + } + else + { + auto&& oldValue = oldRuns[oldKey]; + + if (auto inlineObj = oldValue.TryGet()) + { + oldInlineCallbackIds.Add(inlineObj->callbackId); + } + + oldIdx++; + } + } + +#define ERROR_MESSAGE_PREFIX L"vl::presentation::elements::DiffRuns(const DocumentRunPropertyMap&, const DocumentRunPropertyMap&, remoteprotocol::ElementDesc_DocumentParagraph&)#" + // Validate that all old run ranges are fully covered by new run ranges + for (vint oldI = 0; oldI < oldKeys.Count(); oldI++) + { + auto&& oldKey = oldKeys[oldI]; + vint coveredEnd = oldKey.caretBegin; + + // Find all new ranges that cover this old range + for (vint newI = 0; newI < newKeys.Count(); newI++) + { + auto&& newKey = newKeys[newI]; + + // Check if this new range overlaps with uncovered part of old range + if (newKey.caretBegin <= coveredEnd && newKey.caretEnd > coveredEnd) + { + coveredEnd = newKey.caretEnd > oldKey.caretEnd ? oldKey.caretEnd : newKey.caretEnd; + } + } + + CHECK_ERROR(coveredEnd >= oldKey.caretEnd, + ERROR_MESSAGE_PREFIX L"Old run range not fully covered by new runs"); + } +#undef ERROR_MESSAGE_PREFIX + + for (vint i = 0; i < newInlineCallbackIds.Count(); i++) + { + auto id = newInlineCallbackIds[i]; + if (!oldInlineCallbackIds.Contains(id)) + { + result.createdInlineObjects->Add(id); + } + } + + for (vint i = 0; i < oldInlineCallbackIds.Count(); i++) + { + auto id = oldInlineCallbackIds[i]; + if (!newInlineCallbackIds.Contains(id)) + { + result.removedInlineObjects->Add(id); + } + } + } + +/*********************************************************************** +GuiRemoteGraphicsParagraph +***********************************************************************/ + + GuiRemoteGraphicsParagraph::GuiRemoteGraphicsParagraph(const WString& _text, GuiRemoteController* _remote, GuiRemoteGraphicsResourceManager* _resourceManager, GuiRemoteGraphicsRenderTarget* _renderTarget, IGuiGraphicsParagraphCallback* _callback) + : text(_text) + , remote(_remote) + , resourceManager(_resourceManager) + , renderTarget(_renderTarget) + , callback(_callback) + { + if (renderTarget) + { + id = renderTarget->AllocateNewElementId(); + renderTarget->RegisterParagraph(this); + } + } + + GuiRemoteGraphicsParagraph::~GuiRemoteGraphicsParagraph() + { + if (renderTarget && id != -1) + { + renderTarget->UnregisterParagraph(id); + id = -1; + } + } + + vint GuiRemoteGraphicsParagraph::GetParagraphId() const + { + return id; + } + + bool GuiRemoteGraphicsParagraph::EnsureRemoteParagraphSynced() + { + if (!needUpdate) + { + return id != -1; + } + + if (id == -1 || !renderTarget) + { + return false; + } + + stagedRuns.Clear(); + MergeRuns(textRuns, inlineObjectRuns, stagedRuns); + + remoteprotocol::ElementDesc_DocumentParagraph desc; + if (committedRuns.Count() == 0) + { + desc.text = text; + } + + switch (paragraphAlignment) + { + case Alignment::Right: + desc.alignment = remoteprotocol::ElementHorizontalAlignment::Right; + break; + case Alignment::Center: + desc.alignment = remoteprotocol::ElementHorizontalAlignment::Center; + break; + default: + desc.alignment = remoteprotocol::ElementHorizontalAlignment::Left; + break; + } + + desc.wrapLine = wrapLine; + desc.maxWidth = maxWidth; + desc.id = id; + DiffRuns(committedRuns, stagedRuns, desc); + + auto& messages = renderTarget->GetRemoteMessages(); + vint requestId = messages.RequestRendererUpdateElement_DocumentParagraph(desc); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + return false; + } + + cachedSize = messages.RetrieveRendererUpdateElement_DocumentParagraph(requestId); + committedRuns = std::move(stagedRuns); + needUpdate = false; + return true; + } + + bool GuiRemoteGraphicsParagraph::TryBuildCaretRange(vint start, vint length, CaretRange& range) + { + if (length <= 0 || start < 0 || start + length > text.Length()) + { + return false; + } + range.caretBegin = NativeTextPosToRemoteTextPos(start); + range.caretEnd = NativeTextPosToRemoteTextPos(start + length); + return true; + } + + void GuiRemoteGraphicsParagraph::MarkParagraphDirty(bool invalidateSize) + { + needUpdate = true; + if (invalidateSize) + { + cachedSize = Size(0, 0); + } + } + + vint GuiRemoteGraphicsParagraph::NativeTextPosToRemoteTextPos(vint textPos) + { + return textPos; + } + + vint GuiRemoteGraphicsParagraph::RemoteTextPosToNativeTextPos(vint textPos) + { + return textPos; + } + + IGuiGraphicsLayoutProvider* GuiRemoteGraphicsParagraph::GetProvider() + { + return resourceManager; + } + + IGuiGraphicsRenderTarget* GuiRemoteGraphicsParagraph::GetRenderTarget() + { + return renderTarget; + } + + bool GuiRemoteGraphicsParagraph::GetWrapLine() + { + return wrapLine; + } + + void GuiRemoteGraphicsParagraph::SetWrapLine(bool value) + { + if (wrapLine != value) + { + wrapLine = value; + MarkParagraphDirty(true); + } + } + + vint GuiRemoteGraphicsParagraph::GetMaxWidth() + { + return maxWidth; + } + + void GuiRemoteGraphicsParagraph::SetMaxWidth(vint value) + { + if (maxWidth != value) + { + maxWidth = value; + MarkParagraphDirty(true); + } + } + + Alignment GuiRemoteGraphicsParagraph::GetParagraphAlignment() + { + return paragraphAlignment; + } + + void GuiRemoteGraphicsParagraph::SetParagraphAlignment(Alignment value) + { + if (paragraphAlignment != value) + { + paragraphAlignment = value; + MarkParagraphDirty(true); + } + } + + bool GuiRemoteGraphicsParagraph::SetFont(vint start, vint length, const WString& value) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + DocumentTextRunPropertyOverrides overrides; + overrides.fontFamily = value; + AddTextRun(textRuns, range, overrides); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::SetSize(vint start, vint length, vint value) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + DocumentTextRunPropertyOverrides overrides; + overrides.size = value; + AddTextRun(textRuns, range, overrides); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::SetStyle(vint start, vint length, TextStyle value) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + DocumentTextRunPropertyOverrides overrides; + overrides.textStyle = value; + AddTextRun(textRuns, range, overrides); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::SetColor(vint start, vint length, Color value) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + DocumentTextRunPropertyOverrides overrides; + overrides.textColor = value; + AddTextRun(textRuns, range, overrides); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::SetBackgroundColor(vint start, vint length, Color value) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + DocumentTextRunPropertyOverrides overrides; + overrides.backgroundColor = value; + AddTextRun(textRuns, range, overrides); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::SetInlineObject(vint start, vint length, const InlineObjectProperties& properties) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + + vint backgroundElementId = -1; + IGuiGraphicsRenderer* renderer = properties.backgroundImage ? properties.backgroundImage->GetRenderer() : nullptr; + if (renderer) + { + renderer->SetRenderTarget(renderTarget); + if (auto remoteRenderer = dynamic_cast(renderer)) + { + backgroundElementId = remoteRenderer->GetID(); + } + } + + remoteprotocol::DocumentInlineObjectRunProperty remoteProp; + remoteProp.size = properties.size; + remoteProp.baseline = properties.baseline; + remoteProp.breakCondition = properties.breakCondition; + remoteProp.backgroundElementId = backgroundElementId; + remoteProp.callbackId = properties.callbackId; + + if (!AddInlineObjectRun(inlineObjectRuns, range, remoteProp)) + { + return false; + } + + inlineObjectProperties.Remove(range); + inlineObjectProperties.Add(range, properties); + MarkParagraphDirty(true); + return true; + } + + bool GuiRemoteGraphicsParagraph::ResetInlineObject(vint start, vint length) + { + CaretRange range; + if (!TryBuildCaretRange(start, length, range)) return false; + if (!ResetInlineObjectRun(inlineObjectRuns, range)) return false; + + vint index = inlineObjectProperties.Keys().IndexOf(range); + if (index != -1) + { + auto stored = inlineObjectProperties.Values()[index]; + if (stored.backgroundImage) + { + if (auto renderer = stored.backgroundImage->GetRenderer()) + { + renderer->SetRenderTarget(nullptr); + } + } + inlineObjectProperties.Remove(range); + } + + MarkParagraphDirty(true); + return true; + } + + Size GuiRemoteGraphicsParagraph::GetSize() + { + if (!EnsureRemoteParagraphSynced()) + { + return cachedSize; + } + return cachedSize; + } + + bool GuiRemoteGraphicsParagraph::OpenCaret(vint caret, Color color, bool frontSide) + { + if (!EnsureRemoteParagraphSynced()) + { + return false; + } + + remoteprotocol::OpenCaretRequest request; + request.caret = NativeTextPosToRemoteTextPos(caret); + request.caretColor = color; + request.frontSide = frontSide; + + auto& messages = renderTarget->GetRemoteMessages(); + messages.RequestDocumentParagraph_OpenCaret(request); + bool disconnected = false; + messages.Submit(disconnected); + return !disconnected; + } + + bool GuiRemoteGraphicsParagraph::CloseCaret() + { + if (id == -1 || !renderTarget) + { + return false; + } + + auto& messages = renderTarget->GetRemoteMessages(); + messages.RequestDocumentParagraph_CloseCaret(); + bool disconnected = false; + messages.Submit(disconnected); + return !disconnected; + } + + void GuiRemoteGraphicsParagraph::Render(Rect bounds) + { + if (!renderTarget) + { + return; + } + + if (!EnsureRemoteParagraphSynced()) + { + return; + } + + remoteprotocol::ElementRendering rendering; + rendering.id = id; + rendering.bounds = bounds; + rendering.areaClippedByParent = renderTarget->GetClipperValidArea(); + + auto& messages = renderTarget->GetRemoteMessages(); + messages.RequestRendererRenderElement(rendering); + lastRenderedBatchId = renderTarget->renderingBatchId; + } + + vint GuiRemoteGraphicsParagraph::GetCaret(vint comparingCaret, CaretRelativePosition position, bool& preferFrontSide) + { + if (!EnsureRemoteParagraphSynced()) + { + preferFrontSide = false; + return comparingCaret; + } + + auto& messages = renderTarget->GetRemoteMessages(); + remoteprotocol::GetCaretRequest request; + request.caret = NativeTextPosToRemoteTextPos(comparingCaret); + request.relativePosition = position; + + vint requestId = messages.RequestDocumentParagraph_GetCaret(request); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + preferFrontSide = false; + return comparingCaret; + } + + auto response = messages.RetrieveDocumentParagraph_GetCaret(requestId); + preferFrontSide = response.preferFrontSide; + return RemoteTextPosToNativeTextPos(response.newCaret); + } + + Rect GuiRemoteGraphicsParagraph::GetCaretBounds(vint caret, bool frontSide) + { + if (!EnsureRemoteParagraphSynced()) + { + return {}; + } + + remoteprotocol::GetCaretBoundsRequest request; + request.caret = NativeTextPosToRemoteTextPos(caret); + request.frontSide = frontSide; + + auto& messages = renderTarget->GetRemoteMessages(); + vint requestId = messages.RequestDocumentParagraph_GetCaretBounds(request); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + return {}; + } + + return messages.RetrieveDocumentParagraph_GetCaretBounds(requestId); + } + + vint GuiRemoteGraphicsParagraph::GetCaretFromPoint(Point point) + { + if (!EnsureRemoteParagraphSynced()) + { + return 0; + } + + auto& messages = renderTarget->GetRemoteMessages(); + vint bestCaret = 0; + vint bestDistance = -1; + + for (vint caret = 0; caret <= text.Length(); caret++) + { + remoteprotocol::GetCaretBoundsRequest request; + request.caret = NativeTextPosToRemoteTextPos(caret); + request.frontSide = true; + + bool disconnected = false; + vint requestId = messages.RequestDocumentParagraph_GetCaretBounds(request); + messages.Submit(disconnected); + if (disconnected) + { + return bestCaret; + } + + Rect bounds = messages.RetrieveDocumentParagraph_GetCaretBounds(requestId); + if (bounds.x1 <= point.x && point.x < bounds.x2 && bounds.y1 <= point.y && point.y < bounds.y2) + { + return caret; + } + + vint horizontalDistance = 0; + if (point.x < bounds.x1) horizontalDistance = bounds.x1 - point.x; + else if (point.x > bounds.x2) horizontalDistance = point.x - bounds.x2; + + vint verticalDistance = 0; + if (point.y < bounds.y1) verticalDistance = bounds.y1 - point.y; + else if (point.y > bounds.y2) verticalDistance = point.y - bounds.y2; + + vint distance = horizontalDistance + verticalDistance; + if (bestDistance == -1 || distance < bestDistance) + { + bestDistance = distance; + bestCaret = caret; + } + } + + return bestCaret; + } + + Nullable GuiRemoteGraphicsParagraph::GetInlineObjectFromPoint(Point point, vint& start, vint& length) + { + start = 0; + length = 0; + + if (!EnsureRemoteParagraphSynced()) + { + return {}; + } + + auto& messages = renderTarget->GetRemoteMessages(); + vint requestId = messages.RequestDocumentParagraph_GetInlineObjectFromPoint(point); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + return {}; + } + + auto response = messages.RetrieveDocumentParagraph_GetInlineObjectFromPoint(requestId); + if (!response) + { + return {}; + } + + CaretRange range; + range.caretBegin = response.Value().caretBegin; + range.caretEnd = response.Value().caretEnd; + + vint index = inlineObjectProperties.Keys().IndexOf(range); + if (index == -1) + { + return {}; + } + + start = RemoteTextPosToNativeTextPos(range.caretBegin); + length = RemoteTextPosToNativeTextPos(range.caretEnd) - start; + return inlineObjectProperties.Values()[index]; + } + + vint GuiRemoteGraphicsParagraph::GetNearestCaretFromTextPos(vint textPos, bool frontSide) + { + if (!EnsureRemoteParagraphSynced()) + { + return textPos; + } + + remoteprotocol::GetCaretBoundsRequest request; + request.caret = NativeTextPosToRemoteTextPos(textPos); + request.frontSide = frontSide; + + auto& messages = renderTarget->GetRemoteMessages(); + vint requestId = messages.RequestDocumentParagraph_GetNearestCaretFromTextPos(request); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + return textPos; + } + + auto response = messages.RetrieveDocumentParagraph_GetNearestCaretFromTextPos(requestId); + return RemoteTextPosToNativeTextPos(response); + } + + bool GuiRemoteGraphicsParagraph::IsValidCaret(vint caret) + { + if (!EnsureRemoteParagraphSynced()) + { + return false; + } + + auto& messages = renderTarget->GetRemoteMessages(); + vint requestId = messages.RequestDocumentParagraph_IsValidCaret(NativeTextPosToRemoteTextPos(caret)); + bool disconnected = false; + messages.Submit(disconnected); + if (disconnected) + { + return false; + } + + return messages.RetrieveDocumentParagraph_IsValidCaret(requestId); + } + + bool GuiRemoteGraphicsParagraph::IsValidTextPos(vint textPos) + { + return 0 <= textPos && textPos <= text.Length(); + } +} + /*********************************************************************** .\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS_IMAGESERVICE.CPP ***********************************************************************/ @@ -37427,10 +38617,10 @@ GuiRemoteEventDomDiffConverter { } - void GuiRemoteEventDomDiffConverter::OnControllerConnect() + void GuiRemoteEventDomDiffConverter::OnControllerConnect(const remoteprotocol::ControllerGlobalConfig& arguments) { lastDom = {}; - TBase::OnControllerConnect(); + TBase::OnControllerConnect(arguments); } /*********************************************************************** @@ -39300,6 +40490,21 @@ Licensed under https ://github.com/vczh-libraries/License namespace vl::presentation::remoteprotocol { + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::CharacterEncoding>(const ::vl::presentation::remoteprotocol::CharacterEncoding & value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::CharacterEncoding>(const ::vl::presentation::remoteprotocol::CharacterEncoding&)#" + auto node = Ptr(new glr::json::JsonString); + switch (value) + { + case ::vl::presentation::remoteprotocol::CharacterEncoding::UTF8: node->content.value = WString::Unmanaged(L"UTF8"); break; + case ::vl::presentation::remoteprotocol::CharacterEncoding::UTF16: node->content.value = WString::Unmanaged(L"UTF16"); break; + case ::vl::presentation::remoteprotocol::CharacterEncoding::UTF32: node->content.value = WString::Unmanaged(L"UTF32"); break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); + } + return node; +#undef ERROR_MESSAGE_PREFIX + } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeWindowListener::HitTestResult>(const ::vl::presentation::INativeWindowListener::HitTestResult & value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::INativeWindowListener::HitTestResult>(const ::vl::presentation::INativeWindowListener::HitTestResult&)#" @@ -39491,6 +40696,41 @@ namespace vl::presentation::remoteprotocol #undef ERROR_MESSAGE_PREFIX } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition & value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition&)#" + auto node = Ptr(new glr::json::JsonString); + switch (value) + { + case ::vl::presentation::elements::IGuiGraphicsParagraph::StickToPreviousRun: node->content.value = WString::Unmanaged(L"StickToPreviousRun"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::StickToNextRun: node->content.value = WString::Unmanaged(L"StickToNextRun"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::Alone: node->content.value = WString::Unmanaged(L"Alone"); break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); + } + return node; +#undef ERROR_MESSAGE_PREFIX + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition & value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition&)#" + auto node = Ptr(new glr::json::JsonString); + switch (value) + { + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretFirst: node->content.value = WString::Unmanaged(L"CaretFirst"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLast: node->content.value = WString::Unmanaged(L"CaretLast"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLineFirst: node->content.value = WString::Unmanaged(L"CaretLineFirst"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLineLast: node->content.value = WString::Unmanaged(L"CaretLineLast"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveLeft: node->content.value = WString::Unmanaged(L"CaretMoveLeft"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveRight: node->content.value = WString::Unmanaged(L"CaretMoveRight"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveUp: node->content.value = WString::Unmanaged(L"CaretMoveUp"); break; + case ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveDown: node->content.value = WString::Unmanaged(L"CaretMoveDown"); break; + default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); + } + return node; +#undef ERROR_MESSAGE_PREFIX + } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RendererType>(const ::vl::presentation::remoteprotocol::RendererType & value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RendererType>(const ::vl::presentation::remoteprotocol::RendererType&)#" @@ -39508,8 +40748,7 @@ namespace vl::presentation::remoteprotocol case ::vl::presentation::remoteprotocol::RendererType::SolidLabel: node->content.value = WString::Unmanaged(L"SolidLabel"); break; case ::vl::presentation::remoteprotocol::RendererType::Polygon: node->content.value = WString::Unmanaged(L"Polygon"); break; case ::vl::presentation::remoteprotocol::RendererType::ImageFrame: node->content.value = WString::Unmanaged(L"ImageFrame"); break; - case ::vl::presentation::remoteprotocol::RendererType::UnsupportedColorizedText: node->content.value = WString::Unmanaged(L"UnsupportedColorizedText"); break; - case ::vl::presentation::remoteprotocol::RendererType::UnsupportedDocument: node->content.value = WString::Unmanaged(L"UnsupportedDocument"); break; + case ::vl::presentation::remoteprotocol::RendererType::DocumentParagraph: node->content.value = WString::Unmanaged(L"DocumentParagraph"); break; default: CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); } return node; @@ -39632,6 +40871,13 @@ namespace vl::presentation::remoteprotocol return node; } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ControllerGlobalConfig>(const ::vl::presentation::remoteprotocol::ControllerGlobalConfig & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"documentCaretFromEncoding", value.documentCaretFromEncoding); + return node; + } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::WindowSizingConfig>(const ::vl::presentation::remoteprotocol::WindowSizingConfig & value) { auto node = Ptr(new glr::json::JsonObject); @@ -39840,6 +41086,90 @@ namespace vl::presentation::remoteprotocol return node; } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentTextRunProperty>(const ::vl::presentation::remoteprotocol::DocumentTextRunProperty & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"textColor", value.textColor); + ConvertCustomTypeToJsonField(node, L"backgroundColor", value.backgroundColor); + ConvertCustomTypeToJsonField(node, L"fontProperties", value.fontProperties); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty>(const ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"size", value.size); + ConvertCustomTypeToJsonField(node, L"baseline", value.baseline); + ConvertCustomTypeToJsonField(node, L"breakCondition", value.breakCondition); + ConvertCustomTypeToJsonField(node, L"backgroundElementId", value.backgroundElementId); + ConvertCustomTypeToJsonField(node, L"callbackId", value.callbackId); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentRun>(const ::vl::presentation::remoteprotocol::DocumentRun & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"caretBegin", value.caretBegin); + ConvertCustomTypeToJsonField(node, L"caretEnd", value.caretEnd); + ConvertCustomTypeToJsonField(node, L"props", value.props); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph>(const ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"id", value.id); + ConvertCustomTypeToJsonField(node, L"text", value.text); + ConvertCustomTypeToJsonField(node, L"wrapLine", value.wrapLine); + ConvertCustomTypeToJsonField(node, L"maxWidth", value.maxWidth); + ConvertCustomTypeToJsonField(node, L"alignment", value.alignment); + ConvertCustomTypeToJsonField(node, L"runsDiff", value.runsDiff); + ConvertCustomTypeToJsonField(node, L"createdInlineObjects", value.createdInlineObjects); + ConvertCustomTypeToJsonField(node, L"removedInlineObjects", value.removedInlineObjects); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretRequest>(const ::vl::presentation::remoteprotocol::GetCaretRequest & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"caret", value.caret); + ConvertCustomTypeToJsonField(node, L"relativePosition", value.relativePosition); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretResponse>(const ::vl::presentation::remoteprotocol::GetCaretResponse & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"newCaret", value.newCaret); + ConvertCustomTypeToJsonField(node, L"preferFrontSide", value.preferFrontSide); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretBoundsRequest>(const ::vl::presentation::remoteprotocol::GetCaretBoundsRequest & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"caret", value.caret); + ConvertCustomTypeToJsonField(node, L"frontSide", value.frontSide); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::OpenCaretRequest>(const ::vl::presentation::remoteprotocol::OpenCaretRequest & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"caret", value.caret); + ConvertCustomTypeToJsonField(node, L"caretColor", value.caretColor); + ConvertCustomTypeToJsonField(node, L"frontSide", value.frontSide); + return node; + } + + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>(const ::vl::presentation::remoteprotocol::RenderInlineObjectRequest & value) + { + auto node = Ptr(new glr::json::JsonObject); + ConvertCustomTypeToJsonField(node, L"callbackId", value.callbackId); + ConvertCustomTypeToJsonField(node, L"location", value.location); + return node; + } + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RendererCreation>(const ::vl::presentation::remoteprotocol::RendererCreation & value) { auto node = Ptr(new glr::json::JsonObject); @@ -39959,6 +41289,18 @@ namespace vl::presentation::remoteprotocol return node; } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::CharacterEncoding>(vl::Ptr node, ::vl::presentation::remoteprotocol::CharacterEncoding& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::CharacterEncoding>(Ptr, ::vl::presentation::remoteprotocol::CharacterEncoding&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + if (jsonNode->content.value == L"UTF8") value = ::vl::presentation::remoteprotocol::CharacterEncoding::UTF8; else + if (jsonNode->content.value == L"UTF16") value = ::vl::presentation::remoteprotocol::CharacterEncoding::UTF16; else + if (jsonNode->content.value == L"UTF32") value = ::vl::presentation::remoteprotocol::CharacterEncoding::UTF32; else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); +#undef ERROR_MESSAGE_PREFIX + } + template<> void ConvertJsonToCustomType<::vl::presentation::INativeWindowListener::HitTestResult>(vl::Ptr node, ::vl::presentation::INativeWindowListener::HitTestResult& value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::INativeWindowListener::HitTestResult>(Ptr, ::vl::presentation::INativeWindowListener::HitTestResult&)#" @@ -40117,6 +41459,35 @@ namespace vl::presentation::remoteprotocol #undef ERROR_MESSAGE_PREFIX } + template<> void ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(vl::Ptr node, ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(Ptr, ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + if (jsonNode->content.value == L"StickToPreviousRun") value = ::vl::presentation::elements::IGuiGraphicsParagraph::StickToPreviousRun; else + if (jsonNode->content.value == L"StickToNextRun") value = ::vl::presentation::elements::IGuiGraphicsParagraph::StickToNextRun; else + if (jsonNode->content.value == L"Alone") value = ::vl::presentation::elements::IGuiGraphicsParagraph::Alone; else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(vl::Ptr node, ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(Ptr, ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + if (jsonNode->content.value == L"CaretFirst") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretFirst; else + if (jsonNode->content.value == L"CaretLast") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLast; else + if (jsonNode->content.value == L"CaretLineFirst") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLineFirst; else + if (jsonNode->content.value == L"CaretLineLast") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretLineLast; else + if (jsonNode->content.value == L"CaretMoveLeft") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveLeft; else + if (jsonNode->content.value == L"CaretMoveRight") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveRight; else + if (jsonNode->content.value == L"CaretMoveUp") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveUp; else + if (jsonNode->content.value == L"CaretMoveDown") value = ::vl::presentation::elements::IGuiGraphicsParagraph::CaretMoveDown; else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); +#undef ERROR_MESSAGE_PREFIX + } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererType>(vl::Ptr node, ::vl::presentation::remoteprotocol::RendererType& value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererType>(Ptr, ::vl::presentation::remoteprotocol::RendererType&)#" @@ -40133,8 +41504,7 @@ namespace vl::presentation::remoteprotocol if (jsonNode->content.value == L"SolidLabel") value = ::vl::presentation::remoteprotocol::RendererType::SolidLabel; else if (jsonNode->content.value == L"Polygon") value = ::vl::presentation::remoteprotocol::RendererType::Polygon; else if (jsonNode->content.value == L"ImageFrame") value = ::vl::presentation::remoteprotocol::RendererType::ImageFrame; else - if (jsonNode->content.value == L"UnsupportedColorizedText") value = ::vl::presentation::remoteprotocol::RendererType::UnsupportedColorizedText; else - if (jsonNode->content.value == L"UnsupportedDocument") value = ::vl::presentation::remoteprotocol::RendererType::UnsupportedDocument; else + if (jsonNode->content.value == L"DocumentParagraph") value = ::vl::presentation::remoteprotocol::RendererType::DocumentParagraph; else CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported enum value."); #undef ERROR_MESSAGE_PREFIX } @@ -40318,6 +41688,19 @@ namespace vl::presentation::remoteprotocol #undef ERROR_MESSAGE_PREFIX } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ControllerGlobalConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::ControllerGlobalConfig& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ControllerGlobalConfig>(Ptr, ::vl::presentation::remoteprotocol::ControllerGlobalConfig&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"documentCaretFromEncoding") ConvertJsonToCustomType(field->value, value.documentCaretFromEncoding); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::WindowSizingConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::WindowSizingConfig& value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::WindowSizingConfig>(Ptr, ::vl::presentation::remoteprotocol::WindowSizingConfig&)#" @@ -40646,6 +42029,144 @@ namespace vl::presentation::remoteprotocol #undef ERROR_MESSAGE_PREFIX } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentTextRunProperty>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentTextRunProperty& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentTextRunProperty>(Ptr, ::vl::presentation::remoteprotocol::DocumentTextRunProperty&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"textColor") ConvertJsonToCustomType(field->value, value.textColor); else + if (field->name.value == L"backgroundColor") ConvertJsonToCustomType(field->value, value.backgroundColor); else + if (field->name.value == L"fontProperties") ConvertJsonToCustomType(field->value, value.fontProperties); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty>(Ptr, ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"size") ConvertJsonToCustomType(field->value, value.size); else + if (field->name.value == L"baseline") ConvertJsonToCustomType(field->value, value.baseline); else + if (field->name.value == L"breakCondition") ConvertJsonToCustomType(field->value, value.breakCondition); else + if (field->name.value == L"backgroundElementId") ConvertJsonToCustomType(field->value, value.backgroundElementId); else + if (field->name.value == L"callbackId") ConvertJsonToCustomType(field->value, value.callbackId); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentRun>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentRun& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentRun>(Ptr, ::vl::presentation::remoteprotocol::DocumentRun&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"caretBegin") ConvertJsonToCustomType(field->value, value.caretBegin); else + if (field->name.value == L"caretEnd") ConvertJsonToCustomType(field->value, value.caretEnd); else + if (field->name.value == L"props") ConvertJsonToCustomType(field->value, value.props); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph>(Ptr, ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"id") ConvertJsonToCustomType(field->value, value.id); else + if (field->name.value == L"text") ConvertJsonToCustomType(field->value, value.text); else + if (field->name.value == L"wrapLine") ConvertJsonToCustomType(field->value, value.wrapLine); else + if (field->name.value == L"maxWidth") ConvertJsonToCustomType(field->value, value.maxWidth); else + if (field->name.value == L"alignment") ConvertJsonToCustomType(field->value, value.alignment); else + if (field->name.value == L"runsDiff") ConvertJsonToCustomType(field->value, value.runsDiff); else + if (field->name.value == L"createdInlineObjects") ConvertJsonToCustomType(field->value, value.createdInlineObjects); else + if (field->name.value == L"removedInlineObjects") ConvertJsonToCustomType(field->value, value.removedInlineObjects); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretRequest& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretRequest>(Ptr, ::vl::presentation::remoteprotocol::GetCaretRequest&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"caret") ConvertJsonToCustomType(field->value, value.caret); else + if (field->name.value == L"relativePosition") ConvertJsonToCustomType(field->value, value.relativePosition); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretResponse>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretResponse& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretResponse>(Ptr, ::vl::presentation::remoteprotocol::GetCaretResponse&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"newCaret") ConvertJsonToCustomType(field->value, value.newCaret); else + if (field->name.value == L"preferFrontSide") ConvertJsonToCustomType(field->value, value.preferFrontSide); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretBoundsRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretBoundsRequest& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretBoundsRequest>(Ptr, ::vl::presentation::remoteprotocol::GetCaretBoundsRequest&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"caret") ConvertJsonToCustomType(field->value, value.caret); else + if (field->name.value == L"frontSide") ConvertJsonToCustomType(field->value, value.frontSide); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::OpenCaretRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::OpenCaretRequest& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::OpenCaretRequest>(Ptr, ::vl::presentation::remoteprotocol::OpenCaretRequest&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"caret") ConvertJsonToCustomType(field->value, value.caret); else + if (field->name.value == L"caretColor") ConvertJsonToCustomType(field->value, value.caretColor); else + if (field->name.value == L"frontSide") ConvertJsonToCustomType(field->value, value.frontSide); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::RenderInlineObjectRequest& value) + { +#define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>(Ptr, ::vl::presentation::remoteprotocol::RenderInlineObjectRequest&)#" + auto jsonNode = node.Cast(); + CHECK_ERROR(jsonNode, ERROR_MESSAGE_PREFIX L"Json node does not match the expected type."); + for (auto field : jsonNode->fields) + { + if (field->name.value == L"callbackId") ConvertJsonToCustomType(field->value, value.callbackId); else + if (field->name.value == L"location") ConvertJsonToCustomType(field->value, value.location); else + CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unsupported struct member."); + } +#undef ERROR_MESSAGE_PREFIX + } + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererCreation>(vl::Ptr node, ::vl::presentation::remoteprotocol::RendererCreation& value) { #define ERROR_MESSAGE_PREFIX L"vl::presentation::remoteprotocol::ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererCreation>(Ptr, ::vl::presentation::remoteprotocol::RendererCreation&)#" @@ -40918,7 +42439,13 @@ namespace vl::presentation::remote_renderer void GuiRemoteRendererSingle::Opened() { - events->OnControllerConnect(); + vl::presentation::remoteprotocol::ControllerGlobalConfig globalConfig; +#if defined VCZH_WCHAR_UTF16 + globalConfig.documentCaretFromEncoding = vl::presentation::remoteprotocol::CharacterEncoding::UTF16; +#elif defined VCZH_WCHAR_UTF32 + globalConfig.documentCaretFromEncoding = vl::presentation::remoteprotocol::CharacterEncoding::UTF32; +#endif + events->OnControllerConnect(globalConfig); } void GuiRemoteRendererSingle::BeforeClosing(bool& cancel) @@ -41836,6 +43363,50 @@ namespace vl::presentation::remote_renderer #undef ERROR_MESSAGE_PREFIX } +/*********************************************************************** +* Rendering (Elements -- Document) +***********************************************************************/ + + void GuiRemoteRendererSingle::RequestRendererUpdateElement_DocumentParagraph(vint id, const remoteprotocol::ElementDesc_DocumentParagraph& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_GetCaret(vint id, const remoteprotocol::GetCaretRequest& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_GetCaretBounds(vint id, const remoteprotocol::GetCaretBoundsRequest& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_GetInlineObjectFromPoint(vint id, const Point& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_GetNearestCaretFromTextPos(vint id, const remoteprotocol::GetCaretBoundsRequest& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_IsValidCaret(vint id, const vint& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_OpenCaret(const remoteprotocol::OpenCaretRequest& arguments) + { + CHECK_FAIL(L"Not implemented."); + } + + void GuiRemoteRendererSingle::RequestDocumentParagraph_CloseCaret() + { + CHECK_FAIL(L"Not implemented."); + } + /*********************************************************************** * Rendering (Dom) ***********************************************************************/ diff --git a/Import/GacUI.h b/Import/GacUI.h index 62e02f03..59d801d9 100644 --- a/Import/GacUI.h +++ b/Import/GacUI.h @@ -20814,6 +20814,7 @@ namespace vl::presentation::remoteprotocol { struct FontConfig; struct ScreenConfig; + struct ControllerGlobalConfig; struct WindowSizingConfig; struct WindowShowing; struct IOMouseInfoWithButton; @@ -20830,6 +20831,15 @@ namespace vl::presentation::remoteprotocol struct ImageFrameMetadata; struct ImageMetadata; struct ElementDesc_ImageFrame; + struct DocumentTextRunProperty; + struct DocumentInlineObjectRunProperty; + struct DocumentRun; + struct ElementDesc_DocumentParagraph; + struct GetCaretRequest; + struct GetCaretResponse; + struct GetCaretBoundsRequest; + struct OpenCaretRequest; + struct RenderInlineObjectRequest; struct RendererCreation; struct ElementBeginRendering; struct ElementRendering; @@ -20857,6 +20867,7 @@ namespace vl::presentation::remoteprotocol template<> struct JsonNameHelper<::vl::presentation::FontProperties> { static constexpr const wchar_t* Name = L"FontProperties"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::FontConfig> { static constexpr const wchar_t* Name = L"FontConfig"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ScreenConfig> { static constexpr const wchar_t* Name = L"ScreenConfig"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ControllerGlobalConfig> { static constexpr const wchar_t* Name = L"ControllerGlobalConfig"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::WindowSizingConfig> { static constexpr const wchar_t* Name = L"WindowSizingConfig"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::WindowShowing> { static constexpr const wchar_t* Name = L"WindowShowing"; }; template<> struct JsonNameHelper<::vl::presentation::NativeWindowMouseInfo> { static constexpr const wchar_t* Name = L"IOMouseInfo"; }; @@ -20877,6 +20888,15 @@ namespace vl::presentation::remoteprotocol template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ImageFrameMetadata> { static constexpr const wchar_t* Name = L"ImageFrameMetadata"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ImageMetadata> { static constexpr const wchar_t* Name = L"ImageMetadata"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ElementDesc_ImageFrame> { static constexpr const wchar_t* Name = L"ElementDesc_ImageFrame"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::DocumentTextRunProperty> { static constexpr const wchar_t* Name = L"DocumentTextRunProperty"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty> { static constexpr const wchar_t* Name = L"DocumentInlineObjectRunProperty"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::DocumentRun> { static constexpr const wchar_t* Name = L"DocumentRun"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph> { static constexpr const wchar_t* Name = L"ElementDesc_DocumentParagraph"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::GetCaretRequest> { static constexpr const wchar_t* Name = L"GetCaretRequest"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::GetCaretResponse> { static constexpr const wchar_t* Name = L"GetCaretResponse"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::GetCaretBoundsRequest> { static constexpr const wchar_t* Name = L"GetCaretBoundsRequest"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::OpenCaretRequest> { static constexpr const wchar_t* Name = L"OpenCaretRequest"; }; + template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::RenderInlineObjectRequest> { static constexpr const wchar_t* Name = L"RenderInlineObjectRequest"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::RendererCreation> { static constexpr const wchar_t* Name = L"RendererCreation"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ElementBeginRendering> { static constexpr const wchar_t* Name = L"ElementBeginRendering"; }; template<> struct JsonNameHelper<::vl::presentation::remoteprotocol::ElementRendering> { static constexpr const wchar_t* Name = L"ElementRendering"; }; @@ -20893,6 +20913,13 @@ namespace vl::presentation::remoteprotocol } namespace vl::presentation::remoteprotocol { + enum class CharacterEncoding + { + UTF8, + UTF16, + UTF32, + }; + enum class IOMouseButton { Left, @@ -20933,8 +20960,7 @@ namespace vl::presentation::remoteprotocol SolidLabel, Polygon, ImageFrame, - UnsupportedColorizedText, - UnsupportedDocument, + DocumentParagraph, }; enum class RenderingDom_DiffType @@ -20944,6 +20970,11 @@ namespace vl::presentation::remoteprotocol Modified, }; + using DocumentRunProperty = ::vl::Variant< + ::vl::presentation::remoteprotocol::DocumentTextRunProperty, + ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty + >; + using UnitTest_ElementDescVariant = ::vl::Variant< ::vl::presentation::remoteprotocol::ElementDesc_SolidBorder, ::vl::presentation::remoteprotocol::ElementDesc_SinkBorder, @@ -20953,7 +20984,8 @@ namespace vl::presentation::remoteprotocol ::vl::presentation::remoteprotocol::ElementDesc_InnerShadow, ::vl::presentation::remoteprotocol::ElementDesc_Polygon, ::vl::presentation::remoteprotocol::ElementDesc_SolidLabel, - ::vl::presentation::remoteprotocol::ElementDesc_ImageFrame + ::vl::presentation::remoteprotocol::ElementDesc_ImageFrame, + ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph >; struct FontConfig @@ -20970,6 +21002,11 @@ namespace vl::presentation::remoteprotocol double scalingY; }; + struct ControllerGlobalConfig + { + ::vl::presentation::remoteprotocol::CharacterEncoding documentCaretFromEncoding; + }; + struct WindowSizingConfig { ::vl::presentation::NativeRect bounds; @@ -21099,6 +21136,72 @@ namespace vl::presentation::remoteprotocol ::vl::Nullable<::vl::presentation::remoteprotocol::ImageCreation> imageCreation; }; + struct DocumentTextRunProperty + { + ::vl::presentation::Color textColor; + ::vl::presentation::Color backgroundColor; + ::vl::presentation::FontProperties fontProperties; + }; + + struct DocumentInlineObjectRunProperty + { + ::vl::presentation::Size size; + ::vl::vint baseline; + ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition breakCondition; + ::vl::vint backgroundElementId; + ::vl::vint callbackId; + }; + + struct DocumentRun + { + ::vl::vint caretBegin; + ::vl::vint caretEnd; + ::vl::presentation::remoteprotocol::DocumentRunProperty props; + }; + + struct ElementDesc_DocumentParagraph + { + ::vl::vint id; + ::vl::Nullable<::vl::WString> text; + bool wrapLine; + ::vl::vint maxWidth; + ::vl::presentation::remoteprotocol::ElementHorizontalAlignment alignment; + ::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::DocumentRun>> runsDiff; + ::vl::Ptr<::vl::collections::List<::vl::vint>> createdInlineObjects; + ::vl::Ptr<::vl::collections::List<::vl::vint>> removedInlineObjects; + }; + + struct GetCaretRequest + { + ::vl::vint caret; + ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition relativePosition; + }; + + struct GetCaretResponse + { + ::vl::vint newCaret; + bool preferFrontSide; + }; + + struct GetCaretBoundsRequest + { + ::vl::vint caret; + bool frontSide; + }; + + struct OpenCaretRequest + { + ::vl::vint caret; + ::vl::presentation::Color caretColor; + bool frontSide; + }; + + struct RenderInlineObjectRequest + { + ::vl::vint callbackId; + ::vl::presentation::Rect location; + }; + struct RendererCreation { ::vl::vint id; @@ -21192,6 +21295,7 @@ namespace vl::presentation::remoteprotocol ::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::UnitTest_RenderingFrame>> frames; }; + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::CharacterEncoding>(const ::vl::presentation::remoteprotocol::CharacterEncoding & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeWindowListener::HitTestResult>(const ::vl::presentation::INativeWindowListener::HitTestResult & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeCursor::SystemCursorType>(const ::vl::presentation::INativeCursor::SystemCursorType & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeWindow::WindowSizeState>(const ::vl::presentation::INativeWindow::WindowSizeState & value); @@ -21203,6 +21307,8 @@ namespace vl::presentation::remoteprotocol template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementVerticalAlignment>(const ::vl::presentation::remoteprotocol::ElementVerticalAlignment & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementSolidLabelMeasuringRequest>(const ::vl::presentation::remoteprotocol::ElementSolidLabelMeasuringRequest & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::INativeImage::FormatType>(const ::vl::presentation::INativeImage::FormatType & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(const ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RendererType>(const ::vl::presentation::remoteprotocol::RendererType & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RenderingDom_DiffType>(const ::vl::presentation::remoteprotocol::RenderingDom_DiffType & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeCoordinate>(const ::vl::presentation::NativeCoordinate & value); @@ -21216,6 +21322,7 @@ namespace vl::presentation::remoteprotocol template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::FontProperties>(const ::vl::presentation::FontProperties & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::FontConfig>(const ::vl::presentation::remoteprotocol::FontConfig & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ScreenConfig>(const ::vl::presentation::remoteprotocol::ScreenConfig & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ControllerGlobalConfig>(const ::vl::presentation::remoteprotocol::ControllerGlobalConfig & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::WindowSizingConfig>(const ::vl::presentation::remoteprotocol::WindowSizingConfig & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::WindowShowing>(const ::vl::presentation::remoteprotocol::WindowShowing & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::NativeWindowMouseInfo>(const ::vl::presentation::NativeWindowMouseInfo & value); @@ -21236,6 +21343,15 @@ namespace vl::presentation::remoteprotocol template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ImageFrameMetadata>(const ::vl::presentation::remoteprotocol::ImageFrameMetadata & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ImageMetadata>(const ::vl::presentation::remoteprotocol::ImageMetadata & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementDesc_ImageFrame>(const ::vl::presentation::remoteprotocol::ElementDesc_ImageFrame & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentTextRunProperty>(const ::vl::presentation::remoteprotocol::DocumentTextRunProperty & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty>(const ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::DocumentRun>(const ::vl::presentation::remoteprotocol::DocumentRun & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph>(const ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretRequest>(const ::vl::presentation::remoteprotocol::GetCaretRequest & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretResponse>(const ::vl::presentation::remoteprotocol::GetCaretResponse & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::GetCaretBoundsRequest>(const ::vl::presentation::remoteprotocol::GetCaretBoundsRequest & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::OpenCaretRequest>(const ::vl::presentation::remoteprotocol::OpenCaretRequest & value); + template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>(const ::vl::presentation::remoteprotocol::RenderInlineObjectRequest & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::RendererCreation>(const ::vl::presentation::remoteprotocol::RendererCreation & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementBeginRendering>(const ::vl::presentation::remoteprotocol::ElementBeginRendering & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::ElementRendering>(const ::vl::presentation::remoteprotocol::ElementRendering & value); @@ -21250,6 +21366,7 @@ namespace vl::presentation::remoteprotocol template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::UnitTest_RenderingFrame>(const ::vl::presentation::remoteprotocol::UnitTest_RenderingFrame & value); template<> vl::Ptr ConvertCustomTypeToJson<::vl::presentation::remoteprotocol::UnitTest_RenderingTrace>(const ::vl::presentation::remoteprotocol::UnitTest_RenderingTrace & value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::CharacterEncoding>(vl::Ptr node, ::vl::presentation::remoteprotocol::CharacterEncoding& value); template<> void ConvertJsonToCustomType<::vl::presentation::INativeWindowListener::HitTestResult>(vl::Ptr node, ::vl::presentation::INativeWindowListener::HitTestResult& value); template<> void ConvertJsonToCustomType<::vl::presentation::INativeCursor::SystemCursorType>(vl::Ptr node, ::vl::presentation::INativeCursor::SystemCursorType& value); template<> void ConvertJsonToCustomType<::vl::presentation::INativeWindow::WindowSizeState>(vl::Ptr node, ::vl::presentation::INativeWindow::WindowSizeState& value); @@ -21261,6 +21378,8 @@ namespace vl::presentation::remoteprotocol template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementVerticalAlignment>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementVerticalAlignment& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementSolidLabelMeasuringRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementSolidLabelMeasuringRequest& value); template<> void ConvertJsonToCustomType<::vl::presentation::INativeImage::FormatType>(vl::Ptr node, ::vl::presentation::INativeImage::FormatType& value); + template<> void ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition>(vl::Ptr node, ::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition& value); + template<> void ConvertJsonToCustomType<::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition>(vl::Ptr node, ::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererType>(vl::Ptr node, ::vl::presentation::remoteprotocol::RendererType& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RenderingDom_DiffType>(vl::Ptr node, ::vl::presentation::remoteprotocol::RenderingDom_DiffType& value); template<> void ConvertJsonToCustomType<::vl::presentation::NativeCoordinate>(vl::Ptr node, ::vl::presentation::NativeCoordinate& value); @@ -21274,6 +21393,7 @@ namespace vl::presentation::remoteprotocol template<> void ConvertJsonToCustomType<::vl::presentation::FontProperties>(vl::Ptr node, ::vl::presentation::FontProperties& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::FontConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::FontConfig& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ScreenConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::ScreenConfig& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ControllerGlobalConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::ControllerGlobalConfig& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::WindowSizingConfig>(vl::Ptr node, ::vl::presentation::remoteprotocol::WindowSizingConfig& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::WindowShowing>(vl::Ptr node, ::vl::presentation::remoteprotocol::WindowShowing& value); template<> void ConvertJsonToCustomType<::vl::presentation::NativeWindowMouseInfo>(vl::Ptr node, ::vl::presentation::NativeWindowMouseInfo& value); @@ -21294,6 +21414,15 @@ namespace vl::presentation::remoteprotocol template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ImageFrameMetadata>(vl::Ptr node, ::vl::presentation::remoteprotocol::ImageFrameMetadata& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ImageMetadata>(vl::Ptr node, ::vl::presentation::remoteprotocol::ImageMetadata& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementDesc_ImageFrame>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementDesc_ImageFrame& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentTextRunProperty>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentTextRunProperty& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentInlineObjectRunProperty& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::DocumentRun>(vl::Ptr node, ::vl::presentation::remoteprotocol::DocumentRun& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretRequest& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretResponse>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretResponse& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::GetCaretBoundsRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::GetCaretBoundsRequest& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::OpenCaretRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::OpenCaretRequest& value); + template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>(vl::Ptr node, ::vl::presentation::remoteprotocol::RenderInlineObjectRequest& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::RendererCreation>(vl::Ptr node, ::vl::presentation::remoteprotocol::RendererCreation& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementBeginRendering>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementBeginRendering& value); template<> void ConvertJsonToCustomType<::vl::presentation::remoteprotocol::ElementRendering>(vl::Ptr node, ::vl::presentation::remoteprotocol::ElementRendering& value); @@ -21346,6 +21475,14 @@ namespace vl::presentation::remoteprotocol HANDLER(ImageCreated, ::vl::presentation::remoteprotocol::ImageCreation, ::vl::presentation::remoteprotocol::ImageMetadata, REQ, RES, NODROP)\ HANDLER(ImageDestroyed, ::vl::vint, void, REQ, NORES, NODROP)\ HANDLER(RendererUpdateElement_ImageFrame, ::vl::presentation::remoteprotocol::ElementDesc_ImageFrame, void, REQ, NORES, NODROP)\ + HANDLER(RendererUpdateElement_DocumentParagraph, ::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph, ::vl::presentation::Size, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_GetCaret, ::vl::presentation::remoteprotocol::GetCaretRequest, ::vl::presentation::remoteprotocol::GetCaretResponse, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_GetCaretBounds, ::vl::presentation::remoteprotocol::GetCaretBoundsRequest, ::vl::presentation::Rect, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_GetInlineObjectFromPoint, ::vl::presentation::Point, ::vl::Nullable<::vl::presentation::remoteprotocol::DocumentRun>, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_GetNearestCaretFromTextPos, ::vl::presentation::remoteprotocol::GetCaretBoundsRequest, ::vl::vint, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_IsValidCaret, ::vl::vint, bool, REQ, RES, NODROP)\ + HANDLER(DocumentParagraph_OpenCaret, ::vl::presentation::remoteprotocol::OpenCaretRequest, void, REQ, NORES, NODROP)\ + HANDLER(DocumentParagraph_CloseCaret, void, void, NOREQ, NORES, NODROP)\ HANDLER(RendererCreated, ::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::RendererCreation>>, void, REQ, NORES, NODROP)\ HANDLER(RendererDestroyed, ::vl::Ptr<::vl::collections::List<::vl::vint>>, void, REQ, NORES, NODROP)\ HANDLER(RendererBeginRendering, ::vl::presentation::remoteprotocol::ElementBeginRendering, void, REQ, NORES, NODROP)\ @@ -21357,7 +21494,7 @@ namespace vl::presentation::remoteprotocol HANDLER(RendererRenderDomDiff, ::vl::presentation::remoteprotocol::RenderingDom_DiffsInOrder, void, REQ, NORES, NODROP)\ #define GACUI_REMOTEPROTOCOL_EVENTS(HANDLER)\ - HANDLER(ControllerConnect, void, NOREQ, NODROP)\ + HANDLER(ControllerConnect, ::vl::presentation::remoteprotocol::ControllerGlobalConfig, REQ, NODROP)\ HANDLER(ControllerDisconnect, void, NOREQ, NODROP)\ HANDLER(ControllerRequestExit, void, NOREQ, NODROP)\ HANDLER(ControllerForceExit, void, NOREQ, NODROP)\ @@ -21376,6 +21513,7 @@ namespace vl::presentation::remoteprotocol HANDLER(IOKeyDown, ::vl::presentation::NativeWindowKeyInfo, REQ, NODROP)\ HANDLER(IOKeyUp, ::vl::presentation::NativeWindowKeyInfo, REQ, NODROP)\ HANDLER(IOChar, ::vl::presentation::NativeWindowCharInfo, REQ, NODROP)\ + HANDLER(DocumentParagraph_RenderInlineObjects, ::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>>, REQ, NODROP)\ #define GACUI_REMOTEPROTOCOL_MESSAGE_REQUEST_TYPES(HANDLER)\ HANDLER(::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::GlobalShortcutKey>>)\ @@ -21385,9 +21523,11 @@ namespace vl::presentation::remoteprotocol HANDLER(::vl::WString)\ HANDLER(::vl::presentation::NativeRect)\ HANDLER(::vl::presentation::NativeSize)\ + HANDLER(::vl::presentation::Point)\ HANDLER(::vl::presentation::VKEY)\ HANDLER(::vl::presentation::remoteprotocol::ElementBeginRendering)\ HANDLER(::vl::presentation::remoteprotocol::ElementBoundary)\ + HANDLER(::vl::presentation::remoteprotocol::ElementDesc_DocumentParagraph)\ HANDLER(::vl::presentation::remoteprotocol::ElementDesc_GradientBackground)\ HANDLER(::vl::presentation::remoteprotocol::ElementDesc_ImageFrame)\ HANDLER(::vl::presentation::remoteprotocol::ElementDesc_InnerShadow)\ @@ -21398,24 +21538,34 @@ namespace vl::presentation::remoteprotocol HANDLER(::vl::presentation::remoteprotocol::ElementDesc_SolidBorder)\ HANDLER(::vl::presentation::remoteprotocol::ElementDesc_SolidLabel)\ HANDLER(::vl::presentation::remoteprotocol::ElementRendering)\ + HANDLER(::vl::presentation::remoteprotocol::GetCaretBoundsRequest)\ + HANDLER(::vl::presentation::remoteprotocol::GetCaretRequest)\ HANDLER(::vl::presentation::remoteprotocol::ImageCreation)\ + HANDLER(::vl::presentation::remoteprotocol::OpenCaretRequest)\ HANDLER(::vl::presentation::remoteprotocol::RenderingDom_DiffsInOrder)\ HANDLER(::vl::presentation::remoteprotocol::WindowShowing)\ HANDLER(::vl::vint)\ HANDLER(bool)\ #define GACUI_REMOTEPROTOCOL_MESSAGE_RESPONSE_TYPES(HANDLER)\ + HANDLER(::vl::Nullable<::vl::presentation::remoteprotocol::DocumentRun>)\ + HANDLER(::vl::presentation::Rect)\ + HANDLER(::vl::presentation::Size)\ HANDLER(::vl::presentation::remoteprotocol::ElementMeasurings)\ HANDLER(::vl::presentation::remoteprotocol::FontConfig)\ + HANDLER(::vl::presentation::remoteprotocol::GetCaretResponse)\ HANDLER(::vl::presentation::remoteprotocol::ImageMetadata)\ HANDLER(::vl::presentation::remoteprotocol::ScreenConfig)\ HANDLER(::vl::presentation::remoteprotocol::WindowSizingConfig)\ + HANDLER(::vl::vint)\ HANDLER(bool)\ #define GACUI_REMOTEPROTOCOL_EVENT_REQUEST_TYPES(HANDLER)\ + HANDLER(::vl::Ptr<::vl::collections::List<::vl::presentation::remoteprotocol::RenderInlineObjectRequest>>)\ HANDLER(::vl::presentation::NativeWindowCharInfo)\ HANDLER(::vl::presentation::NativeWindowKeyInfo)\ HANDLER(::vl::presentation::NativeWindowMouseInfo)\ + HANDLER(::vl::presentation::remoteprotocol::ControllerGlobalConfig)\ HANDLER(::vl::presentation::remoteprotocol::IOMouseInfoWithButton)\ HANDLER(::vl::presentation::remoteprotocol::ScreenConfig)\ HANDLER(::vl::presentation::remoteprotocol::WindowSizingConfig)\ @@ -21427,6 +21577,160 @@ namespace vl::presentation::remoteprotocol #endif +/*********************************************************************** +.\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS_DOCUMENT.H +***********************************************************************/ +/*********************************************************************** +Vczh Library++ 3.0 +Developer: Zihan Chen(vczh) +GacUI::Remote Window + +Interfaces: + GuiRemoteController + +***********************************************************************/ + +#ifndef VCZH_PRESENTATION_GUIREMOTEGRAPHICS_DOCUMENT +#define VCZH_PRESENTATION_GUIREMOTEGRAPHICS_DOCUMENT + + +namespace vl::presentation +{ + class GuiRemoteController; +} + +namespace vl::presentation::elements +{ +/*********************************************************************** +DiffRuns +***********************************************************************/ + + struct CaretRange + { + vint caretBegin = 0; + vint caretEnd = 0; + + auto operator<=>(const CaretRange&) const = default; + }; + + struct DocumentTextRunPropertyOverrides + { + Nullable textColor; + Nullable backgroundColor; + Nullable fontFamily; + Nullable size; + Nullable textStyle; + }; + + using DocumentTextRunPropertyMap = collections::Dictionary; + using DocumentInlineObjectRunPropertyMap = collections::Dictionary; + using DocumentRunPropertyMap = collections::Dictionary; + + extern void AddTextRun( + DocumentTextRunPropertyMap& map, + CaretRange range, + const DocumentTextRunPropertyOverrides& propertyOverrides); + + extern bool AddInlineObjectRun( + DocumentInlineObjectRunPropertyMap& map, + CaretRange range, + const remoteprotocol::DocumentInlineObjectRunProperty& property); + + extern bool ResetInlineObjectRun( + DocumentInlineObjectRunPropertyMap& map, + CaretRange range); + + extern void MergeRuns( + const DocumentTextRunPropertyMap& textRuns, + const DocumentInlineObjectRunPropertyMap& inlineObjectRuns, + DocumentRunPropertyMap& result); + + extern void DiffRuns( + const DocumentRunPropertyMap& oldRuns, + const DocumentRunPropertyMap& newRuns, + remoteprotocol::ElementDesc_DocumentParagraph& result); + +/*********************************************************************** +GuiRemoteGraphicsParagraph +***********************************************************************/ + + class GuiRemoteGraphicsResourceManager; + class GuiRemoteGraphicsRenderTarget; + + class GuiRemoteGraphicsParagraph : public Object, public IGuiGraphicsParagraph + { + protected: + WString text; + GuiRemoteController* remote = nullptr; + GuiRemoteGraphicsResourceManager* resourceManager = nullptr; + GuiRemoteGraphicsRenderTarget* renderTarget = nullptr; + IGuiGraphicsParagraphCallback* callback = nullptr; + + DocumentTextRunPropertyMap textRuns; + DocumentInlineObjectRunPropertyMap inlineObjectRuns; + DocumentRunPropertyMap stagedRuns; + DocumentRunPropertyMap committedRuns; + collections::Dictionary inlineObjectProperties; + bool wrapLine = false; + vint maxWidth = -1; + Alignment paragraphAlignment = Alignment::Left; + Size cachedSize = Size(0, 0); + bool needUpdate = true; + vint id = -1; + vuint64_t lastRenderedBatchId = 0; + + public: + GuiRemoteGraphicsParagraph(const WString& _text, GuiRemoteController* _remote, GuiRemoteGraphicsResourceManager* _resourceManager, GuiRemoteGraphicsRenderTarget* _renderTarget, IGuiGraphicsParagraphCallback* _callback); + ~GuiRemoteGraphicsParagraph(); + + vint GetParagraphId() const; + + protected: + vint NativeTextPosToRemoteTextPos(vint textPos); + vint RemoteTextPosToNativeTextPos(vint textPos); + bool TryBuildCaretRange(vint start, vint length, CaretRange& range); + bool EnsureRemoteParagraphSynced(); + void MarkParagraphDirty(bool invalidateSize); + + public: + // ============================================================= + // IGuiGraphicsParagraph + // ============================================================= + + IGuiGraphicsLayoutProvider* GetProvider() override; + IGuiGraphicsRenderTarget* GetRenderTarget() override; + bool GetWrapLine() override; + void SetWrapLine(bool value) override; + vint GetMaxWidth() override; + void SetMaxWidth(vint value) override; + Alignment GetParagraphAlignment() override; + void SetParagraphAlignment(Alignment value) override; + + bool SetFont(vint start, vint length, const WString& value) override; + bool SetSize(vint start, vint length, vint value) override; + bool SetStyle(vint start, vint length, TextStyle value) override; + bool SetColor(vint start, vint length, Color value) override; + bool SetBackgroundColor(vint start, vint length, Color value) override; + bool SetInlineObject(vint start, vint length, const InlineObjectProperties& properties) override; + bool ResetInlineObject(vint start, vint length) override; + + Size GetSize() override; + bool OpenCaret(vint caret, Color color, bool frontSide) override; + bool CloseCaret() override; + void Render(Rect bounds) override; + + vint GetCaret(vint comparingCaret, CaretRelativePosition position, bool& preferFrontSide) override; + Rect GetCaretBounds(vint caret, bool frontSide) override; + vint GetCaretFromPoint(Point point) override; + Nullable GetInlineObjectFromPoint(Point point, vint& start, vint& length) override; + vint GetNearestCaretFromTextPos(vint textPos, bool frontSide) override; + bool IsValidCaret(vint caret) override; + bool IsValidTextPos(vint textPos) override; + }; +} + +#endif + /*********************************************************************** .\PLATFORMPROVIDERS\REMOTE\GUIREMOTEGRAPHICS_IMAGESERVICE.H ***********************************************************************/ @@ -21579,6 +21883,7 @@ namespace vl::presentation namespace elements { + class GuiRemoteGraphicsParagraph; /*********************************************************************** GuiRemoteGraphicsRenderTarget @@ -21592,19 +21897,21 @@ GuiRemoteGraphicsRenderTarget using HitTestResult = INativeWindowListener::HitTestResult; using SystemCursorType = INativeCursor::SystemCursorType; protected: - GuiRemoteController* remote; - GuiHostedController* hostedController; - NativeSize canvasSize; - vint usedFrameIds = 0; - vint usedElementIds = 0; - vint usedCompositionIds = 0; - RendererMap renderers; - collections::SortedList createdRenderers; - collections::SortedList destroyedRenderers; - RendererSet renderersAskingForCache; - Nullable clipperValidArea; - collections::List hitTestResults; - collections::List cursors; + GuiRemoteController* remote; + GuiHostedController* hostedController; + NativeSize canvasSize; + vint usedFrameIds = 0; + vint usedElementIds = 0; + vint usedCompositionIds = 0; + RendererMap renderers; + collections::SortedList createdRenderers; + collections::SortedList destroyedRenderers; + RendererSet renderersAskingForCache; + Nullable clipperValidArea; + collections::List hitTestResults; + collections::List cursors; + collections::Dictionary paragraphs; + collections::List pendingParagraphCreations; HitTestResult GetHitTestResultFromGenerator(reflection::DescriptableObject* generator); Nullable GetCursorFromGenerator(reflection::DescriptableObject* generator); @@ -21633,19 +21940,32 @@ GuiRemoteGraphicsRenderTarget void RegisterRenderer(elements_remoteprotocol::IGuiRemoteProtocolElementRender* renderer); void UnregisterRenderer(elements_remoteprotocol::IGuiRemoteProtocolElementRender* renderer); Rect GetClipperValidArea(); + GuiRemoteGraphicsParagraph* GetParagraph(vint id); + void RegisterParagraph(GuiRemoteGraphicsParagraph* paragraph); + void UnregisterParagraph(vint id); }; /*********************************************************************** GuiRemoteGraphicsResourceManager ***********************************************************************/ - class GuiRemoteGraphicsResourceManager : public GuiGraphicsResourceManager + class GuiRemoteGraphicsResourceManager + : public GuiGraphicsResourceManager + , public IGuiGraphicsLayoutProvider { protected: GuiRemoteController* remote; GuiRemoteGraphicsRenderTarget renderTarget; GuiHostedController* hostedController; + protected: + + // ============================================================= + // IGuiGraphicsLayoutProvider + // ============================================================= + + Ptr CreateParagraph(const WString& text, IGuiGraphicsRenderTarget* _renderTarget, IGuiGraphicsParagraphCallback* callback) override; + public: GuiRemoteGraphicsResourceManager(GuiRemoteController* _remote, GuiHostedController* _hostedController); ~GuiRemoteGraphicsResourceManager(); @@ -21655,6 +21975,7 @@ GuiRemoteGraphicsResourceManager void OnControllerConnect(); void OnControllerDisconnect(); + void OnDocumentParagraph_RenderInlineObjects(collections::List& arguments); // ============================================================= // IGuiGraphicsResourceManager @@ -23558,7 +23879,7 @@ GuiRemoteEventDomDiffConverter GuiRemoteEventDomDiffConverter(); ~GuiRemoteEventDomDiffConverter(); - void OnControllerConnect() override; + void OnControllerConnect(const remoteprotocol::ControllerGlobalConfig& arguments) override; }; /*********************************************************************** @@ -28528,6 +28849,7 @@ GuiRemoteController bool connectionForcedToStop = false; bool connectionStopped = false; + remoteprotocol::ControllerGlobalConfig remoteGlobalConfig; remoteprotocol::FontConfig remoteFontConfig; remoteprotocol::ScreenConfig remoteScreenConfig; @@ -28606,7 +28928,7 @@ GuiRemoteController // Events // ============================================================= - void OnControllerConnect(); + void OnControllerConnect(const remoteprotocol::ControllerGlobalConfig& _globalConfig); void OnControllerDisconnect(); void OnControllerRequestExit(); void OnControllerForceExit(); @@ -28616,8 +28938,9 @@ GuiRemoteController GuiRemoteController(IGuiRemoteProtocol* _remoteProtocol); ~GuiRemoteController(); - void Initialize(); - void Finalize(); + void Initialize(); + void Finalize(); + remoteprotocol::ControllerGlobalConfig GetGlobalConfig(); // ============================================================= // INativeController diff --git a/Import/GacUICompiler.cpp b/Import/GacUICompiler.cpp index 64ad744c..ac29ab91 100644 --- a/Import/GacUICompiler.cpp +++ b/Import/GacUICompiler.cpp @@ -10193,24 +10193,23 @@ namespace vl::presentation::instancequery { void GuiInstanceQueryParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 3046; // 28794 bytes before compressing + static const vl::vint dataLength = 2815; // 27722 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 230; - static const vl::vint dataSolidRows = 11; - static const vl::vint dataRows = 12; + static const vl::vint dataRemain = 255; + static const vl::vint dataSolidRows = 10; + static const vl::vint dataRows = 11; static const char* compressed[] = { - "\x7A\x70\x00\x00\xDE\x0B\x00\x00\x0D\x00\x01\x82\x80\x07\x03\x82\x81\x82\x06\x89\x82\x88\x0A\x87\x06\x84\x0C\x0A\x9D\x0A\x86\x1A\x87\x16\x84\x77\x02\x09\xBF\x7B\x8C\x8B\x8E\x84\x00\x1D\x9D\x9F\x81\x9C\x8B\x90\x93\x7F\x1F\x9F\x81\x0A\x8B\x91\x85\x96\x83\x27\xA8\x8A\x91\x96\x94\x91\x9B\x90\x37\xA2\xB3\x87\x99\x9D\x93\x9C\x9B\x3F\xB8\x81\xBA\x9A\x8C\x9F\xA0\x9F\x45\xC0\x89\xA2\xAB\xA4\xA0\x98\xA3\x4D\xC8\x8F\xAA\xA3\xAC\xA5\xAA\xA7\x03\xB4\x87\xBE\x8B\xAA\x99\xA8\xAE\x09\x99\xAE\x9D\xAD\x98\xB3\xAA\xA9\x59\xD0\xA7\xA6\xB9\xB4\xA9\xB6\xAB\x6F\xD8\x82\x9A\xAF\xAE\xAF\xB4\xBB\x71\xE8\x82\x83\x0C\x94\xB2\xBF\xBA\x65\xF8\xB3\xAA\xB3\x84\x01\xBE\xC0\x7F\xF7\x81\xCB\xC9\xC1\xBC\xB7\xC1\x6E\x90\xF0\xB2\xC2\xB9\x81\x03\xC3\x8A\x8D\xD4\xDA\xB1\x84\xB9\xCC\xC4\xA0\x9F\xE2\xCE\xC2\xC5\xCC\xC3\xCD\x8F\xA6\xD1\xCA\xD3\xC9\x82\x02\xCC\xA4\x8C\xE1\xD1\xDA\xCC\xD5\xCA\x90\xA7\xB6\xDC\xD8\xDB\xD4\xDD\xD6\xDF\xB7\x9E\xC3\x88\x86\x87\x94\xDB\xD9\xA8\xA5\xC0\xFB\xD2\xE3\x84\xD9\xE4\xB2\xA3\xD0\xF5\xDB\xE1\xD5\xEA\xE5\xCD\xBA\xD6\xF9", + "\x4A\x6C\x00\x00\xF7\x0A\x00\x00\x0D\x00\x01\x82\x80\x07\x03\x82\x81\x82\x06\x89\x82\x88\x0A\x87\x06\x84\x0C\x0A\x9D\x0A\x86\x1A\x87\x16\x84\x77\x02\x09\xBF\x7B\x8C\x8B\x8E\x84\x00\x1D\x9D\x9F\x81\x9C\x8B\x90\x93\x7F\x1F\x9F\x81\x0A\x8B\x91\x85\x96\x83\x27\xA8\x8A\x91\x96\x94\x91\x9B\x90\x37\xA2\xB3\x87\x99\x9D\x93\x9C\x9B\x3F\xB8\x81\xBA\x9A\x8C\x9F\xA0\x9F\x45\xC0\x89\xA2\xAB\xA4\xA0\x98\xA3\x4D\xC8\x8F\xAA\xA3\xAC\xA5\xAA\xA7\x03\xB4\x87\xBE\x8B\xAA\x99\xA8\xAE\x09\x99\xAE\x9D\xAD\x98\xB3\xAA\xA9\x59\xD0\xA7\xA6\xB9\xB4\xA9\xB6\xAB\x6F\xD8\x82\x9A\xAF\xAE\xAF\xB4\xBB\x71\xE8\x82\x83\x0C\x94\xB2\xBF\xBA\x65\xF8\xB3\xAA\xB3\x84\x01\xBE\xC0\x7F\xF7\x81\xCB\xC9\xC1\xBC\xB7\xC1\x6E\x90\xF0\xB2\xC2\xB9\x81\x03\xC3\x8A\x8D\xD4\xDA\xB1\x84\xB9\xCC\xC4\xA0\x9F\xE2\xCE\xC2\xC5\xCC\xC3\xCD\x8F\xA6\xD1\xCA\xD3\xC9\x82\x02\xCC\xA4\x8C\xE1\xD1\xDA\xCC\xD5\xCA\x90\xA7\xB6\xDC\xD8\xDB\xD4\xDD\xD6\xDF\xB7\x9E\xC3\x88\x86\x87\x94\xDB\xD9\xA8\xA5\xC0\xFB\xD2\xE3\x84\xD9\xE4\xB2\xA3\xD0\xF5\xDB\xE1\xD5\xEA\xE5\xCD\xBA\xD6\xF9", "\xE0\x01\x07\xE6\xED\xD8\xB9\xD7\xF1\xE7\xE2\xE8\xF0\xF2\xD3\xC8\xE7\xF4\xEC\xED\xF6\xF0\xF7\xBD\xDC\xCA\x1F\xE0\x03\x04\xFA\xF8\xBF\xF8\xC1\xE2\xFC\x07\xFB\xF7\xFF\xF1\x40\x89\x7E\x80\xFB\x41\x86\x83\x80\x07\x85\x88\x83\x82\x0A\x8D\x8C\x72\x78\x00\x63\x5A\x7B\x78\xEC\x44\x8F\x81\x82\x17\x8C\x89\x86\x83\xDB\x56\x8D\x84\x86\x1F\x9A\x81\x8B\x6D\x0E\x3E\x70\x89\x78\x27\xA8\x7B\x7B\x84\x0E\x52\x86\x78\x85\x13\xBA\x7B\x87\x8C\x23\xB4\x88\x8A\x88\x37\x9C\x89\x8F\x6E\x10\x26\x88\x8F\x47\x11\x3E\x8A\x8E\x8A\x30\xAF\x82\x8D\x8D\x48\xBB\x89\x90\x91\x47\x8A\x9E\x90\x93\xE2\x52\x04\x7F\x04\x42\xB6\x80\x95\x8A\x15\x98\x91\x8E\x87\xCA\x54\x04\x7D\x05\x55\x8B\x9A\x42\x05\x61\x8F\x99\x97\x8F\x67\x83\x99\x9A\x95\x6B\xA2\x9B\x96\x96\x46\x9C\x97\x94\x9A\x09\x57\x05\x9B\x9C\x6A\xAF\x94\x9D\x9C\x70\xA5\x7E\x9D\x7A\x7C\xBB\x9F\x9F\x8A\x81\xB9\x96\x40\x44\x2E\x83\xA5\x92\xA2\x4D\xB8\x9C\x9B\x84\x19\x34\x7A\x07\x9D\xD4\x5B\x04\xA6\x9E\x86\x8C\xA2\x9C\x75\x1C\x17\xA5\xA3\xA3\x9F\xAE\x91\xAA\x99\x98\xA0\xAA\xA5\x9F\x80\x8A\xA2\x45\xA2", "\x02\x5E\x0E\xA7\xA9\x82\xA9\xA2\x43\x07\xAF\xB2\xA4\xA3\x40\x20\x35\xA7\xAE\xAD\x8B\xBC\xAD\xA1\x9B\xA4\xA3\xAE\xA2\xA8\xB0\x99\xA2\x41\x08\xF4\x62\x0A\xAD\xAF\xBB\x8D\xBC\xB0\x00\x23\x0B\xBF\xAD\xA9\xD6\x64\x04\x7D\x09\xD2\xA2\x74\x44\xAB\xCE\x93\xB2\xB0\xB0\xC3\x81\xB5\xB2\xA9\xBE\x9B\xA4\xB6\xB8\xE5\xA8\xAD\xB6\xB9\x06\x67\x04\x7C\x0A\xD9\xBD\x69\x09\xBC\xB1\xAB\xBA\xBB\xB3\xDC\x6A\x04\x7F\x0A\xF4\x86\xB6\xBD\xBD\xF8\xAC\xB3\xB8\xB1\xBC\xAC\x04\x7D\x0B\xFD\xA4\xBF\xBE\xBF\x01\xF7\xBE\xB7\xC0\xE8\x8E\xBE\x08\x7D\x16\x5C\xBD\xC3\x6F\x30\x09\xC4\xC3\xC2\x0A\xD7\xCC\xC3\xC3\xE9\x80\xC0\xC8\xC7\x1B\xDE\xCD\xC7\xC8\xCF\xB1\x04\x7E\x0C\x1A\xCA\x73\x0D\xCB\xE1\xB1\xC0\xBA\x42\x34\x34\x75\x0E\x42\x62\x5F\xB7\xBA\xCC\x3B\xF3\xCD\xCF\xCF\x2F\xB7\x04\x7C\x0E\x30\xCA\x49\x0D\xD1\x40\xD0\xCC\xCE\x41\x3A\x34\x7B\x0C\xCE\x3E\xFA\xC2\xD6\xD2\x51\xD4\xD9\xD1\xC8\x1F\xE2\x7D\x0C\xD2\x53\xD8\xD7\xCA\xC0\x5E\xE5\xC8\xCB\xD8\xE2\x7E\x0C\xD6\xD5\x5D\xC1\x4F\x0C\x7D\x40\x10\xD7\xD4\xC9\x11\xE6\xC2\xD8\xD8\x70\xCB\xDA\xA2\x10\xF4", - "\x43\x17\xDA\x40\x44\x3B\xD5\xDD\xD5\x61\xF1\xD4\xDA\xC3\x74\xF2\xD2\xE1\xE1\x83\xE2\xC2\x79\x11\xF4\x46\x1E\xDC\x00\x47\x0F\xE9\xE1\xD6\xF7\x88\x14\x7D\x12\x6E\xE9\xD6\xE2\xDD\x81\xDC\xEF\xDF\xDB\xCF\x8B\x14\x7C\x13\x8F\xCD\x12\xE4\xE2\xA8\xF7\xBE\x10\x7D\x4F\x19\xE8\xDB\xEB\x9D\xC0\xEF\xE6\xE6\x93\xDF\xD4\xE3\xED\x00\xD1\x17\xE8\xEE\x94\xCA\xEC\xEE\xED\xBE\xFF\x62\x17\xEE\x00\xD3\x14\x7C\x15\xAE\xF1\xE0\xE9\xED\x73\xFF\xED\xF1\xF0\xB7\x56\x14\x7F\x15\x8F\xD8\x14\xF1\xEF\xD8\xC0\xF9\xF7\xF3\xDB\xC7\xEE\xF2\xF7\xD0\xFB\x69\x17\xF5\xDA\xE5\xFC\xF6\xF9\xE0\xCC\xCE\x02\x71\x01\x79\xC3\x40\xFB\x70\xF1\x4E\x75\x42\xAF\x75\x5E\xFA\x40\xF0\xD7\x79\xFD\xFE\xF2\xCA\x44\x70\x69\x97\x35\x2D\x93\x7D\x79\x21\x00\xB7\x2B\x7F\x5D\x33\x7E\x41\x7F\x79\x38\x03\xA4\x31\x26\xF9\x61\x32\x02\xC3\x3D\x2A\x07\x89\x3B\x80\x27\x33\x82\x40\x16\x80\x3D\x08\x89\x86\x7F\x15\x9D\x29\x4C\x7C\x22\x81\x93\x37\x79\x20\xFC\x7C\x48\x01\x86\x25\x7F\xBB\x24\x87\x2E\x31\x27\x84\x00\x29\x84\x25\x17\x8F\x87\x24\x86\x25\x84\x49\x08\x85\x2E\x0D\x81\x26", - "\x86\x0D\x82\x86\x0A\x99\x89\x79\x0E\xA9\x25\x87\x0A\x20\x88\x78\x1C\x87\x3B\x18\xAD\x63\x85\x03\x2D\x84\x69\x32\x84\x87\x90\x0A\x8D\x89\x27\x37\x89\x4C\x23\x82\x88\x92\x0C\x8B\x8B\x59\x9D\x8A\x15\xE2\x8D\x22\x2D\xA0\x8B\x8C\x3A\x88\x8C\x0C\xE1\x89\x8D\x32\xA4\x8C\x23\x66\x87\x8C\x1C\xEF\x8B\x23\x38\xB2\x8F\x1F\x76\x92\x8D\x1E\xE7\x8B\x8E\x30\xBD\x8B\x8B\x7F\x90\x83\x11\xF7\x2E\x86\x00\x39\x87\x2E\x5F\x97\x8D\x1D\xF4\x8F\x1E\x2A\x80\x58\x8A\x02\x32\x89\x72\x01\x96\x85\x32\x54\x93\x87\x65\x45\x93\x21\x80\x8C\x91\x4B\xA1\x26\x91\xE7\x50\x92\x6B\x5D\x2E\x93\x8E\x20\x96\x85\x9D\x89\x95\x1B\xF3\x8B\x95\x45\xAD\x90\x8F\xAA\x8B\x8D\x0D\xB1\x97\x87\x59\xAF\x91\x91\x8A\x98\x97\x1D\x8C\x80\x3C\x27\x83\x91\x39\x0C\x2F\x95\x21\xD5\x8D\x22\x5D\xB2\x8E\x98\x67\x9C\x94\x16\xA4\x22\x87\xC0\x01\x9A\x96\x21\x23\x98\x29\xB4\x97\x82\x36\x90\x9E\x8D\xAF\x85\x94\x2B\xD7\x9B\x9B\x5A\xAA\x8E\x9B\xD8\x9C\x9A\x2B\xE2\x90\x97\x6C\x94\x9D\x97\xD6\x80\x9D\x37\xD5\x98\x92\x8B\x62\x95\x3B\x21\x8F\x94\x0F\x84\x9A\x21\x42\xB1\x20\x99\x60\x8A", - "\x9A\x22\x9B\x22\x87\x3F\x8F\x9A\x9D\x1B\x25\x93\x3F\xC9\x33\x9E\xD2\x05\x96\x9E\x27\x38\x9F\x16\xFA\x9B\x9F\x7E\x9D\x2B\xA0\xE8\x84\x26\x40\xD3\x96\x9D\x8A\xA4\x9A\x9B\xE3\x80\xA1\x39\xE4\x9E\x82\x24\x89\x20\xA1\x5E\x8C\x91\x47\xF4\x9F\xA3\x78\xA4\x9C\xA1\x8A\x8E\xA1\x5D\x10\xAB\x99\x68\x8A\x24\xA5\x82\x9F\x94\x78\x07\xA6\xA4\x8D\xA8\xA7\x8E\x2A\xB7\x2C\x4C\xFB\x93\xA3\xBA\x0A\xA7\x9E\x8C\x97\xA6\x1C\xB9\xA4\x35\x9D\x8A\x95\xA7\x88\x81\xA8\x23\xC4\xA0\x98\x46\x88\xAC\x34\x18\xBB\xA2\x46\xD1\xA4\xAB\x73\xAD\xA1\x9C\x53\xB6\xAB\x3E\xD2\xAC\x9D\x6F\x9D\xA8\xAB\x5F\xAB\x9D\x44\xDE\xA3\xAC\xB0\xA5\xAA\xAC\x57\xA8\xAF\x56\xD5\xA6\xA3\xAC\xB2\x9D\x88\xD7\x34\xA6\x4F\xA2\xA0\xAF\x77\xA0\xA1\x24\x3F\xA7\x26\x50\xE7\x8C\xA8\xF0\x06\xAF\x8E\x4F\xA4\xA1\x5D\xC4\x85\xA5\xB9\xAF\x93\xAF\x60\x9D\xAF\x75\x7F\xA2\x8F\xC0\xA0\x3C\xAD\x17\xBA\xAB\x3E\x90\xBE\xAD\xC8\xAD\xA9\xAC\x1B\x39\x7F\x1F\xF2\xA9\xA9\xB7\x89\x23\xB3\xF5\x95\xA4\x66\xFF\x18\xB1\x2D\x8A\xB1\x26\x8C\xA7\x8E\x63\xFA\x79\x89\x0F\x85\xB5\xB3\x27\xAB\xA9\x6B\xAB", - "\xAE\xA9\x97\xA2\xB7\xAC\x1B\x39\xAC\x49\x25\xBE\x96\x83\x3E\x9D\xB6\x09\x29\xB5\x6E\xCA\xAF\x95\xD3\xA7\x22\xB8\x5B\x8B\xB4\x17\x97\xB8\xB6\xAE\x8D\xBC\xB2\xA3\xB0\xBB\x73\x92\xBA\x90\xE9\xA9\xA9\xA3\xD1\xB4\xBB\x1D\xD1\xAB\x93\xD1\xBA\xB1\x24\xDD\xAD\xB9\x78\xD7\xBF\x1F\xF1\x9B\xAE\xBC\xFB\x88\xBE\x22\xEA\xB7\x8E\xF6\x8D\xB2\xA6\x33\xAA\x23\x7C\x1E\xA6\x21\xF9\xA4\xA5\xBE\xAE\xB8\xBD\x5D\x5C\x00\xBF\x94\x05\xA2\x20\x8A\xA3\xBC\x13\x92\x9D\x7D\xD9\x86\x22\xC0\x0A\x24\xC0\x00\x01\xCA\x21\x01\xE0\x80\xBE\xCA\x9F\x22\x32\xAC\xAF\x22\x0A\xF6\xB4\x7E\x09\xD9\xC3\x6B\x83\x2C\xB3\x81\x0E\xC5\x80\x1A\xC6\x23\x87\xFA\xBC\x84\xF9\xA1\xC3\x20\xF6\xB1\x8A\x42\x76\x38\xC3\x84\x2C\xC5\xC4\x2E\xC7\xC6\x40\x08\xCD\xC5\x03\xCD\xC2\xC6\x01\x34\xC4\x8C\x86\x2D\x3E\x10\xF5\xC3\x20\x3D\xC2\xC4\x8E\x80\x01\xC8\x0F\xC3\xC9\x42\x42\xDF\xC6\x40\x48\xC6\xC8\x25\xC1\x24\xC9\x1B\x83\xCB\x15\xBA\xCA\xC5\xCF\x8A\x24\xCA\x91\x86\xC1\x61\x37\xCE\xC8\x00\x25\x40\xBE\x29\xC3\x93\x1F\xFD\xB0\x00\x28\xC7\x8F\x8A\x02\x10\x7D\xFE\x0A\xC2\x4A\xF8", - "\x97\x8B\x00\x6A\xDC\xCA\x41\x2A\x6E\xCC\xEA\x23\xBB\x62\x75\xC9\x20\x01\x71\xC6\xCB\x84\x18\x59\xCF\x22\xDC\xCE\x41\x32\x8D\x52\x40\xD1\x8A\xD0\xEF\x6A\x22\x97\x06\xD7\x20\x44\xF8\x7B\x4C\xFD\xB7\x88\x02\x0E\xD5\xC1\x84\x16\x54\xCC\x1F\xB4\xD0\x00\x57\x89\x56\x4C\xF5\xBA\xD3\x57\x8A\x5A\xA7\x83\x2B\x00\x4D\xE3\xBB\x5E\xA3\xC2\x20\x03\x26\xDA\x20\x7E\x69\xD7\xC9\x9A\xDA\x09\x7F\x8A\xAF\xD5\x47\xD6\x62\x86\xDC\x3F\x20\xAE\xE2\x3F\x23\x2B\x84\x9D\x63\xA7\x8A\x53\x47\x63\xB3\xCC\xEA\x06\xBD\x37\x9E\x6F\x5B\x94\xD4\x34\x48\x65\xBB\xD5\x37\xE3\xBF\xD6\x75\x1F\x25\x91\x62\xD3\x44\x89\xD2\xCA\x3B\x47\x45\xCB\x2E\xD9\x40\x03\xC4\xC2\xDE\xD8\x77\x0A\xC5\xB4\x32\xDC\x3D\x45\x83\xD4\x3A\x32\xD9\xD4\xCD\x20\x7D\xCA\x73\x2C\xB4\xD5\x7F\x8B\xD9\xDD\x84\x24\x49\x2C\xFD\xB9\x7C\x4B\xCF\xDF\x37\x8F\x08\x55\xDE\x2F\x5F\xBD\x40\x2C\xAF\xC5\x70\xC9\x23\x52\xEE\x85\x71\x98\x81\x27\xAF\xDB\x1F\x27\xD2\x36\xC0\x75\xC1\xAA\xDC\xD8\xEA\x34\x50\xDF\x13\x53\xE1\x40\x5F\xCF\x45\x64\xDC\x3C\xDB\x1B\xF5\xE3\xF2\x10\x41\xB5\x09\x5F\x20\x59", - "\xEF\xD0\x75\xC8\xBE\xCD\xE2\x85\x16\x5E\x62\x7F\xC0\xE3\x40\x41\xD2\x20\x8E\xF3\xE2\xE4\xED\x4B\x5A\xAF\x8D\x2A\x20\x3B\x66\xE2\x21\xF0\x49\xE3\xBD\x68\xD3\x20\x30\x7F\xE1\x21\xA8\xC5\x3A\xB7\xC4\xE2\x20\x2A\x47\xEE\x20\xFA\x42\xE8\xC0\x6E\xD6\x21\x1E\x4F\xEB\x20\xAE\xCA\xE8\xE8\x6D\xC6\x20\xAA\xC6\xE4\x76\xE2\x2E\xEA\x41\x3E\xED\xE5\x84\x06\x64\xE5\x8A\x58\xC9\x40\x62\xE5\xE8\x9C\xC3\x24\xCE\x49\xCF\x45\x21\xCC\x8C\xED\xA6\xEE\xEA\x20\x36\x12\xCE\xA2\x36\xE1\xCB\x84\x34\xDB\x20\x56\xE5\xEE\x41\x4F\x69\xE4\xE5\x46\x26\xE8\x71\xFF\xEB\x40\x66\x68\xE2\x83\x2D\x6D\xF1\x03\x35\xED\xA5\x87\xF3\xB0\x64\xCA\x20\x6F\x90\xFC\x54\xE2\xB7\xE9\x21\xCD\xC2\x22\xE3\xCF\x5F\x21\xDF\x52\xE7\x36\xB2\xC9\xD6\xDE\x0A\x21\xF2\xE2\x82\x2C\x71\xC2\xF3\x73\x20\xA6\xFD\xEE\xE0\x83\x26\x73\xCC\xC1\x22\x09\x70\xBF\xDC\xE7\xE3\xE5\xF3\x7E\xCA\x24\x74\xB6\xEF\x58\xC2\xB2\xE2\x21\xD8\xC1\x20\xF4\xB9\xCA\x23\xEA\x24\xFB\x37\x42\xDA\xEF\x50\x3D\xF7\xED\x40\x2D\x71\xF8\xEE\x2B\x57\xF9\x03\x3A\xF6\x40\x1E\xFE\x59\x8F\x3A\x75\xFA\xE2\x2E\x56", - "\xC5\x5A\xFB\xEC\xE9\xC0\x06\x78\xE0\xFD\x37\xC5\xD8\xF2\x21\xE1\xF0\xF6\xFC\x55\x0B\x59\xA7\xEC\xF1\x20\xF7\xDB\xFE\xFC\xD2\x6C\xFA\x75\x28\xE4\xFE\x00\x36\xFD\xFC\x57\x72\x10\xD4\x3A\x7F\xCA\x12\x6A\xFD\x70\x71\x03\x11\x29\x01\x81\x10\xD6\x34\x80\x44\x28\x80\xED\x76\x7E\xE3\x3A\x67\x0A\x1D\x05\xCB\x2E\x7C\x09\x86\x7E\x5E\x0F\x38\x18\x81\x81\x0B\x80\x00\x5F\x07\x65\x0A\x13\x06\xCB\x27\x7D\xEF\x7F\x81\x64\x0A\x65\xBC\x21\x2D\xC1\x76\x82\xF7\x7F\x81\x67\x0A\x82\xCE\x21\x73\xBB\x73\x10\x2E\x80\x80\xB3\x72\x10\x6A\x02\x83\xCF\x2E\x2E\xC1\x7B\x7E\x27\x89\x83\x01\x1D\x06\xBD\x77\x1B\x49\x75\x83\xB3\x2A\x10\xDC\x71\x7A\x0A\x1F\x06\x45\x8B\x1B\x59\x78\x84\x01\x10\x84\x76\x7F\x81\x71\x0F\x84\xD6\x18\x30\xC1\x73\x7F\x03\x12\x7E\x42\x80\x00\x73\x0C\x83\x28\x3C\x85\x02\x1C\x82\x5F\x86\x07\x43\x6C\x07\xF2\x7E\x72\xE6\x7D\x07\x43\x63\x08\xCB\x2C\x7F\x41\x8B\x7A\x01\x14\x08\x58\x8A\x1C\x15\x34\x7C\x01\x12\x87\x2F\x8F\x85\x86\x07\x87\x1F\x10\x77\x52\x80\x00\x7C\x88\x83\x74\x80\x00\x88\x00\x88\x0A\x1F\x32\xC1\x76\x80\x5D\x86", - "\x7E\x8A\x02\x86\x85\x3E\x88\x65\x86\x7E\x8D\x03\x64\x93\x0B\x2C\x94\x81\x10\x2F\x7F\x85\x94\x03\x64\x9A\x0B\x2C\x66\x83\x10\x54\x8D\x7D\xE2\x62\x1E\x9D\x83\x10\x85\x8C\x84\x23\x7D\x1B\x34\x8D\x2A\xE6\x7B\x09\x8F\x3F\x8A\x01\x13\x8A\xBC\x2F\x11\x9C\x02\x82\x09\x10\x0A\xCB\x24\x8B\x00\x09\x8A\xB7\x8A\x10\xA1\x0A\x8B\x06\x15\x0A\xCB\x2B\x2D\xBC\x7F\x81\xA6\x04\x8C\x8A\x27\x33\xAE\x70\x00\xC8\x8D\x76\x1F\x8A\x0A\xCC\x8C\x2B\x44\x3F\x8C\xD1\x85\x85\x5F\x8E\x0A\xD5\x8E\x2C\x84\x7E\x5B\x40\x71\x7D\x1F\x82\x0B\x92\x8D\x1B\x8C\x70\x8E\x09\x11\x74\x94\x7F\x81\xB5\x05\x8E\xBF\x11\x04\x3C\x8A\x8E\x91\x76\x7E\xB8\x0E\x8E\xB7\x13\x7A\xE8\x86\x10\x47\x82\x10\x3E\x8F\x85\xBB\x06\x8F\x1D\x3B\x8F\x01\x17\x76\x5F\x8E\x0B\x43\x64\x0C\xCB\x22\x90\x00\x0A\x85\x5F\x85\x0C\x43\x6B\x0C\xCB\x21\x75\xC9\x8F\x85\xCC\x00\x90\xD6\x11\x39\xCF\x82\x91\xD2\x8F\x85\xCF\x06\x91\xCA\x18\x7B\x19\x9A\x10\x92\x7C\x8A\x06\x12\x0D\x1E\x9F\x11\xA6\x3F\x8C\x51\x8C\x8F\xE6\x75\x0D\x27\x94\x1D\x2B\x93\x90\xE6\x78\x0D\x43\x6E\x0D\xCB\x21\x93\x0B\x96\x7E", - "\xDF\x03\x64\xE5\x0B\x2C\x04\x93\x10\xF2\x81\x8C\xAD\x8F\x1B\x0C\x93\x10\x1A\x92\x94\x60\x7D\x1B\x78\x69\x73\x1F\x86\x0E\x8F\x3B\x94\x03\x1F\x93\x48\x93\x10\xE7\x0D\x8D\x00\x0B\x0E\xCB\x20\x95\x02\x15\x94\x53\x92\x10\xEC\x06\x95\xF0\x0B\x2C\x79\x83\x87\x5D\x91\x10\xF1\x0A\x77\xBC\x20\x05\x56\x93\x96\x7D\x87\x88\xF6\x08\x96\xCE\x28\x3C\x14\x89\x10\x6C\x96\x88\x65\x90\x00\xFB\x00\x97\xCF\x2D\x80\x11\x73\x67\x0A\x19\x31\x1F\x83\x43\xE9\x70\x30\x2C\x30\x5F\xB9\x6B\x45\xB5\x69\x98\xF0\x53\x52\xFD\x7E\x5F\x2A\x14\x16\xD9\x6F\x0F\x8C\x97\x7A\x8D\x92\x70\x28\x44\x1F\x82\x96\x31\x0B\x64\x16\xFC\x6F\x49\x70\x5B\x99\xC1\x70\x9A\x7A\x83\x79\x32\x5D\x4C\xBA\x68\x99\x34\x7D\x6D\x80\x11\x48\x3B\x7C\x83\x11\x47\x45\x29\x1E\x5E\x25\x12\x9B\x1C\x13\x5E\xCD\x46\x9B\xC3\x68\x99\xD1\x69\x9B\xA1\x9B\x9B\x56\x99\x12\xB4\x6F\x53\xD8\x6F\x11\xC3\x9A\x97\xCD\x4C\x44\xC7\x98\x99\xC8\x94\x9C\x64\x6A\x60\x34\x1E\x9C\x31\x1A\x60\x98\x60", + "\x43\x17\xDA\x40\x44\x3B\xD5\xDD\xD5\x61\xF1\xD4\xDA\xC3\x74\xF2\xD2\xE1\xE1\x83\xE2\xC2\x79\x11\xF4\x46\x1E\xDC\x00\x47\x0F\xE9\xE1\xD6\xF7\x88\x14\x7D\x12\x6E\xE9\xD6\xE2\xDD\x81\xDC\xEF\xDF\xDB\xCF\x8B\x14\x7C\x13\x8F\xCD\x12\xE4\xE2\xA8\xF7\xBE\x10\x7D\x4F\x19\xE8\xDB\xEB\x9D\xC0\xEF\xE6\xE6\x93\xDF\xD4\xE3\xED\x00\xD1\x17\xE8\xEE\x94\xCA\xEC\xEE\xED\xBE\xFF\x62\x17\xEE\x00\xD3\x14\x7C\x15\xAE\xF1\xE0\xE9\xED\x73\xFF\xED\xF1\xF0\xB7\x56\x14\x7F\x15\x8F\xD8\x14\xF1\xEF\xD8\xC0\xF9\xF7\xF3\xDB\xC7\xEE\xF2\xF7\xD0\xFB\x69\x17\xF5\xDA\xE5\xFC\xF6\xF9\xE0\xCC\xCB\x02\x71\x01\x79\xC4\x68\xCA\xEE\xC9\x78\xC8\xFB\x01\x74\xF0\x00\x5F\x09\x46\x66\xC5\x4C\x97\x49\x4D\xFE\x41\xF1\x76\x32\x42\x44\x33\x20\xFC\x46\x24\x80\xF2\x7C\x4A\xFD\x01\x31\x80\x00\x36\x7E\x7E\x06\x85\x31\x99\x7F\x73\x20\x0A\x82\x25\x81\x16\x81\x20\x02\x81\x21\x83\x83\x1D\x29\x26\x0B\x8A\x21\x07\x81\x2A\x7F\xE2\x1D\x29\x83\x00\x0F\x35\x4A\x06\x28\x84\x14\x98\x83\x80\x22\x90\x85\x5D\x4D\x41\x85\xBA\x0D\x85\x86\x06\x23\x84\x00\x25\x83\x20\xFB\x7C\x7A", + "\x21\x2A\x8B\x86\x40\x2D\x89\x78\x01\x89\x23\x83\xF7\x72\x87\x5D\x31\x2D\x81\x98\x30\x7F\x83\x85\x6D\x8A\x13\xF7\x5F\x80\xFA\x28\x82\x87\xF6\x68\x8B\x14\xA7\x48\x86\xD2\x0D\x84\x81\xF4\x3F\x20\x0F\xC3\x85\x88\x07\x8A\x27\x8A\x0A\x23\x8E\x06\xD0\x84\x24\x29\x9B\x8D\x63\x6E\x8F\x8D\xDC\x71\x8F\x8C\x22\x74\x8B\x8B\x76\x8C\x8C\xC0\x5A\x82\x8F\x24\x4D\x87\x8E\x53\x99\x8F\x0C\xD1\x8A\x8E\x86\x5D\x8F\x82\x67\x89\x8D\x19\xFC\x8D\x8E\x40\x8E\x8A\x90\x4B\x84\x93\x20\xD4\x84\x3F\x17\xB9\x7B\x91\x85\x9C\x22\x23\xCF\x83\x92\x80\x5B\x92\x92\x91\x97\x5F\x27\xA2\x99\x93\x92\x63\x96\x93\xA5\x93\x8D\x2A\xC4\x4A\x8D\x94\x3F\x86\x62\x1F\x28\x86\x4A\x4A\x8F\x7D\x93\x2D\x91\x30\x28\x87\x92\x11\xC2\x85\x7E\x5A\x89\x85\x8D\xA9\x9A\x84\x77\x0C\x92\x8E\x62\xAF\x8F\x94\x1D\x22\x9A\x78\x48\x90\x8F\x55\x94\x3C\x99\xA6\x8E\x9B\x84\x50\x9A\x95\x4E\x86\x94\x3E\x3A\x8D\x96\x32\xA4\x28\x84\x86\x3C\x93\x97\x03\x33\x3D\x58\x09\x99\x20\xEF\x09\x22\x87\xC6\x9B\x89\x15\xE7\x9A\x90\x76\xB5\x2D\x9B\xDF\x80\x9E\x40\x62\x90\x80\x72\x86\x26\x9C\x39\x9E", + "\x94\x78\x4C\x81\x98\xEA\x2B\x99\x9F\x97\x8E\x9F\x5D\x70\x91\x9E\x14\xB4\x9B\x20\x96\x97\x9D\x0C\xC7\x89\x94\x6A\x9B\x9F\x37\xD4\x90\x91\x2D\xA4\x96\x9B\x8E\x7A\x91\x89\x01\xA0\xA3\x40\x8A\x2E\x9B\x6F\x86\xA5\x8C\x28\x98\x9D\x01\xFA\x97\x3A\x10\xB1\x98\xA3\x06\x3A\x9B\x09\x9C\xA7\xA5\x8F\xA3\x9E\x7F\x0A\x22\xA7\x5E\x24\xAD\x8F\x8D\x0E\xA6\x9F\x27\xB9\x9B\x42\x9B\xA9\x21\x8E\xBC\x96\xA5\xF5\x90\xA5\x39\xBB\xA3\x39\x86\xBD\x9B\x42\x81\x37\xA2\x49\x8C\xA5\xA3\x8D\x29\x9B\x8A\x37\xB3\x43\x53\xCE\x81\xAB\x17\x51\xA7\x99\xD2\x96\xA9\x56\x8A\x57\xAB\x69\x9B\xAC\x57\x5D\xAF\x46\xFD\x0D\x8A\xA6\x81\xA4\x34\xA0\x1E\xAA\x23\x41\x88\x92\xA8\x85\xA6\xAE\x83\x4D\xBF\x1F\x58\xC4\xA2\x20\x95\xAF\x9C\xA5\x05\xAA\xAC\x48\xB1\xA4\xAF\x35\xB1\xAD\xAA\x8A\x53\xAF\x5B\xA4\x8D\xAF\xEB\x28\xAF\xA7\x7A\xAF\xA4\x0B\xFC\xA3\xB0\x82\x06\xA9\xAE\x0F\xB7\x35\x58\xDC\xAF\xAA\x67\x53\xB4\x57\x10\x85\xB2\x5D\xBC\xA6\x20\x9F\x82\x88\xA8\x08\xB6\x9F\x40\x32\xAC\x82\x9A\xB5\xA1\xB3\x8D\xBB\xB3\x59\xF8\xA9\xAD\x84\x2B\xAD\x7D\xA2\xA2\x20\x69\xA8", + "\xA5\xA9\xBF\x87\xAA\xAC\x85\xA5\xAE\x46\xAB\xBD\xA7\x96\x89\xB1\xA8\x8B\xA3\xA9\x63\xD3\xAC\x9E\xC8\x94\x39\xA9\x27\xAB\xAB\x01\xA9\x94\xB9\x93\x00\xB4\x57\xCD\xA0\x9A\x71\xDE\xA1\xAE\x89\xBF\x90\x95\xD5\xB4\x39\x74\xA1\x24\x9B\xEE\x8F\xB1\x94\xDC\xB7\xB4\x69\x28\xB7\x2E\xB2\x9D\x2E\xBC\x36\x85\xB1\x71\x86\x2C\x0B\x93\xB3\x96\x62\xE8\xA9\xA5\x6C\xAE\x35\x8C\xDD\x95\x80\x88\xF5\xAD\x9D\x70\x86\x21\x89\xDA\x9F\x98\x89\x1F\x28\x8A\x67\xAB\x83\xC1\x94\x05\xC5\xBF\x02\x28\xC0\x7D\xC2\xBE\xAD\x06\xF7\xB9\x21\x0A\xC0\x00\x0A\x91\xC3\xC3\xDF\x83\x21\xC2\xAF\xA9\x86\x85\x89\xCA\x20\xFB\x10\xC5\xC3\xF8\xA9\x22\x87\xFC\xBA\xBF\x07\xE4\xC1\xA3\x26\xD7\xC1\x89\xE4\x8F\xC3\x84\x3D\x3D\xAD\x2A\xCE\xC7\x7C\x9A\xC2\xC6\x18\xDC\xC1\x21\x11\x5B\xBD\x8C\x86\x29\xC7\x14\xF7\xC4\xC7\x33\xD1\xC2\x7D\xAC\xC7\xC5\xDD\xB5\xA9\xC8\x9A\xA8\xC9\x3C\xA5\x41\x9F\x0C\xDC\x38\x8B\xF4\x77\xA1\x8F\xBC\x51\xB3\xDD\x11\xC2\x4A\x13\x55\xCA\x75\x28\x8A\x65\x2C\xF8\x61\xCA\x2B\xC1\x23\xC4\x5E\xC7\x9C\x30\xCD\xB0\x5B\x64\xC9\xA6\x99\xC0\xB3\x21\x4E", + "\x69\xCD\x82\x6B\xDD\x86\x42\x5E\x4F\xCC\xCC\xA3\x4C\x3A\x5A\xCA\x39\x03\x96\x58\xA8\x20\xB1\xCB\xA6\x09\x39\x55\x9F\xC7\x8F\xCF\xD2\x89\x22\x59\x83\xDD\xB1\xA1\xBB\x8A\x21\x79\x49\xD3\xB4\x8B\xCD\x94\xBF\x0F\xD3\x9F\x45\xDA\x0E\xB7\xA0\x7F\x22\x23\xEE\xBB\xD2\xAC\x8A\xB4\xB2\xFB\x65\x71\x2B\xA8\x8C\x3B\xF8\xB0\x71\x20\xB3\xBE\x86\x78\x43\xC3\x77\x70\x8B\x5D\x95\xAA\xD7\x5F\x88\xBE\xCE\x59\x5C\xB2\x70\x00\x3D\x4D\xC7\x8B\x15\xC0\x74\x32\x61\xD5\x37\x11\xD3\xA8\x91\x76\x4F\xD7\xDF\x08\x89\xD6\x00\x68\x51\x91\x8A\x55\xC0\x52\xC5\x76\x55\x9F\xC2\x8A\xFD\x05\xCD\xD3\x09\x42\xD4\xCD\x02\x3F\x9F\x40\x05\xC3\xD6\xE5\x46\x20\xD1\xD8\xCE\x59\x86\xB3\xB8\x64\x6B\x4D\xB4\x3B\xDD\xC1\x23\x8B\x9A\x7E\x5D\x62\xF7\x31\xDD\x00\x0C\xCA\xE6\x70\x5E\xDD\xDD\x2B\xDB\x20\xF2\xC7\xD4\x00\x0E\xD6\x85\x09\x53\xC8\xD5\xB7\xDA\x5C\x8A\xBC\x59\xDE\x22\xFA\xDB\xCC\xE1\xC0\x03\x0D\x8A\x25\xE0\xD8\xA0\x71\x63\xD1\xC6\xD1\xBF\x86\x2D\x44\x83\x04\xDA\x73\x2C\x71\xE3\xB3\x15\xE3\x20\x30\x60\x75\x66\x1A\xFC\x38\xC7\x82\x24\x4A\xD0\x76\x05\x8C", + "\xDC\x21\x49\x42\x39\xDA\x72\xA2\x75\xDE\x3A\x58\xC6\x22\xCA\x9A\x77\x69\x97\xCA\x3D\xE4\x16\xF7\xD5\xD3\x1A\xE3\xD4\x85\x38\xE5\xE3\xB7\xDC\x05\x19\xB3\xB8\x85\x9F\xE4\xE7\xD6\x66\x7A\xE1\xC3\x92\xC3\xCE\x85\x2C\xE2\xDF\x6D\x67\xDE\x78\x1E\xEA\xC6\x6F\xC3\x22\x6F\x1A\xE6\xEA\xC3\x86\x24\xEB\xD0\xA0\x74\x71\x1A\xFD\xE8\x5B\xDC\xE0\xC4\xD0\x51\x72\xE3\x17\xF2\xCD\x42\x3E\xD6\x21\xA7\xD6\xEA\x20\x98\x72\xE9\x6F\x69\xE6\xE1\xB7\xC1\x24\x74\x1A\xEA\xDA\xD7\xB9\xE1\xE5\xC2\x6B\x72\xE3\x93\x48\xED\xD9\x9A\x70\x0B\x32\xAE\xCB\xE2\x03\x3A\xEE\x40\x74\xED\xD4\x81\x03\x7A\xE3\xAB\x48\xF2\x40\x0A\xF1\x20\xB1\xCD\xF1\x20\xC8\x7A\xE0\xB4\x92\xF1\x20\xCA\xC0\x02\xEB\x9B\x6A\x22\xF4\x1A\xE4\x56\x8B\x41\xF4\xEF\x9A\x76\x7A\xC6\xD7\xDA\xEC\x83\x27\xF0\xE8\xA0\x77\xD2\xC6\xC8\x56\xF4\x9F\xF7\xD5\xBD\x1A\xE0\xDD\xEB\x83\x2C\xCE\x83\x11\x50\x74\x5E\x01\xCF\xB3\x3D\xF3\x21\xD7\xF6\xE8\x00\x62\x01\xC7\x8B\x07\xF3\x21\xDF\xDA\x70\x0D\xCB\x4C\xFA\x40\x46\xF7\xF2\x00\x29\x0A\xBD\xE2\x31\xF3\x40\x0C\xF1\xF5\x84\x2C\x0D\x8C\xD1\x50\xF2", + "\x42\x16\xFD\xFA\x83\x2E\x0D\x8C\x68\xC9\xE2\xF6\xC7\xE0\x74\x38\x25\x8D\xDD\x09\xE5\xF4\xEA\xFA\xD2\x0F\x32\xBC\xDB\xEF\x03\x32\xFC\xEC\x9A\x74\x0F\x32\x93\xD1\xFE\xB6\x70\x3A\x76\x05\x46\x08\x3B\x7A\x0A\x1B\x79\xFA\x68\x07\xCA\x7A\x28\xAC\x72\x10\xE1\x7A\x39\x7E\x0C\x5A\x0C\x8A\x10\xE6\x6A\x39\x86\x02\x81\xBC\x24\x7B\xF3\x77\x7C\x8E\x05\x46\x15\x39\x70\x1A\x8B\x7F\xFA\x60\x09\x65\x4D\x65\x20\x81\x80\x9A\x32\x09\x65\x4F\x32\xB9\x77\x80\xB7\x64\x09\x0B\x8C\x2B\xBA\x7E\x80\xB7\x6A\x09\x18\x8E\x2C\x33\x81\x10\x15\x8A\x6F\xA2\x07\x83\xCF\x2F\x80\xF9\x77\x6B\xAA\x0B\x2C\x3B\x87\x2C\xB7\x6B\x0A\xCB\x29\x7E\x03\x18\x80\xC7\x7C\x0A\x49\x8A\x10\x40\x87\x7C\xAD\x08\x7D\xBD\x1A\x84\x02\x15\x84\xD5\x70\x0B\x54\x8F\x1B\xDB\x2B\x81\xD5\x73\x0B\x65\x47\x33\x8D\x5D\x85\x22\x87\x7C\xB5\x05\x46\x2E\x76\x64\x01\x14\x86\xEC\x7A\x39\xB7\x05\x46\x4F\x3D\x58\xF4\x6E\x85\xE5\x73\x10\xB9\x05\x46\x49\x7A\x86\x00\x03\x87\x65\x85\x7D\xBB\x05\x46\x41\x05\x58\x7C\x8D\x86\xFA\x6D\x0B\x65\x4D\x37\x8D\x57\x7F\x02\x10\x7F\xFA\x6F\x0B\x31\x8E", + "\x2C\x8A\x81\x10\x06\x30\x3A\xC5\x0E\x83\xDC\x11\x89\x00\x05\x80\x9A\x3D\x0C\x96\x82\x1E\x02\x74\x87\x28\x35\x0D\x65\x47\x76\x7A\x8F\x89\x7D\x85\x87\x02\x17\x0D\x65\x4A\x04\x85\x56\x8A\x84\x87\x7C\xD9\x05\x46\xA6\x3D\x58\xFF\x73\x10\x8C\x87\x7C\xDB\x0F\x88\xCF\x25\x8B\x02\x13\x89\x9A\x31\x0E\x9D\x8D\x1B\xBC\x81\x10\x9A\x8A\x6F\xE9\x01\x8C\xBF\x1E\x8B\x03\x13\x88\xD5\x71\x0F\xCB\x25\x8C\x02\x1E\x8A\xD5\x72\x0F\xCB\x28\x70\xB6\x87\x6B\xF3\x05\x8D\x0A\x1A\x8C\xC7\x74\x0F\x5B\x87\x1B\xD6\x82\x10\xD0\x85\x7D\xF7\x0F\x8D\xBB\x1F\x81\xDB\x77\x6B\xFA\x05\x46\x85\x73\x70\x01\x18\x8E\x02\x14\x7E\x28\x3C\x0F\x65\x49\x79\xF2\x59\x10\xF0\x81\x10\xA0\x78\x32\xFE\x05\x46\xAA\x77\x8F\x06\x16\x82\x03\x10\x71\x9A\x36\x46\x9C\x7F\x2C\x19\x7E\x5E\x1A\x1A\x90\x0C\x9D\x90\x0B\x4E\x43\x0F\x9F\x5E\xB0\x4B\x40\x5F\x4D\x44\x15\x9A\x69\x18\x95\x46\x0A\x79\x91\x8D\x54\x5B\x73\x1A\x43\x1E\x90\x68\xEE\x84\x58\x1A\x17\x4B\x26\x92\x46\x28\x92\x7C\x8C\x63\x63\x4C\x7A\x11\xB2\x4F\x92\xB1\x41\x93\x2C\x92\x4B\x11\x64\x63\x30\x15\x93\x1F\x10", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -10242,25 +10241,25 @@ namespace vl::presentation::instancequery L"[7][QPrimaryFragment]< NAME [ \".\" NAME @ ] >", L"[8][QPrimaryAttributed] BEGIN ", L"[9][QPrimaryAttributed] END [ENDING]", - L"[10][QPrimaryAttributed]<< !QPrimaryFragment @ >>", - L"[11][QPrimaryAttributed]<< \"@\" @ [ NAME ] \":\" !QPrimaryFragment >>", - L"[12][QPrimaryAttributed]<< \"@\" [ NAME @ ] \":\" !QPrimaryFragment >>", - L"[13][QPrimaryAttributed]<< \"@\" [ NAME ] \":\" !QPrimaryFragment @ >>", - L"[14][QPrimaryAttributed]<< \"@\" [ NAME ] \":\" @ !QPrimaryFragment >>", + L"[10][QPrimaryAttributed]", + L"[11][QPrimaryAttributed]", + L"[12][QPrimaryAttributed]", + L"[13][QPrimaryAttributed]", + L"[14][QPrimaryAttributed]", L"[15][QPrimary] BEGIN ", L"[16][QPrimary] END [ENDING]", - L"[17][QPrimary]<< \"(\" !QueryRoot \")\" @ >>", - L"[18][QPrimary]<< \"(\" !QueryRoot @ \")\" >>", - L"[19][QPrimary]<< \"(\" @ !QueryRoot \")\" >>", - L"[20][QPrimary]<< \"/\" !QPrimaryAttributed @ >>", - L"[21][QPrimary]<< \"/\" @ !QPrimaryAttributed >>", - L"[22][QPrimary]<< \"//\" !QPrimaryAttributed @ >>", - L"[23][QPrimary]<< \"//\" @ !QPrimaryAttributed >>", + L"[17][QPrimary]", + L"[18][QPrimary]", + L"[19][QPrimary]", + L"[20][QPrimary]", + L"[21][QPrimary]", + L"[22][QPrimary]", + L"[23][QPrimary]", L"[24][Query0] BEGIN ", L"[25][Query0] END [ENDING]", L"[26][Query0]< Query0 @ QPrimary >", L"[27][Query0]< Query0 QPrimary @ >", - L"[28][Query0]<< !QPrimary @ >>", + L"[28][Query0]", L"[29][Query1] BEGIN ", L"[30][Query1] END [ENDING]", L"[31][Query1]< Query1 \"*\" @ Query0 >", @@ -10269,7 +10268,7 @@ namespace vl::presentation::instancequery L"[34][Query1]< Query1 \"^\" Query0 @ >", L"[35][Query1]< Query1 @ \"*\" Query0 >", L"[36][Query1]< Query1 @ \"^\" Query0 >", - L"[37][Query1]<< !Query0 @ >>", + L"[37][Query1]", L"[38][Query2] BEGIN ", L"[39][Query2] END [ENDING]", L"[40][Query2]< Query2 \"+\" @ Query1 >", @@ -10278,10 +10277,10 @@ namespace vl::presentation::instancequery L"[43][Query2]< Query2 \"-\" Query1 @ >", L"[44][Query2]< Query2 @ \"+\" Query1 >", L"[45][Query2]< Query2 @ \"-\" Query1 >", - L"[46][Query2]<< !Query1 @ >>", + L"[46][Query2]", L"[47][QueryRoot] BEGIN ", L"[48][QueryRoot] END [ENDING]", - L"[49][QueryRoot]<< !Query2 @ >>", + L"[49][QueryRoot]", }; return results[index]; } diff --git a/Import/Metadata/RemoteProtocol.json b/Import/Metadata/RemoteProtocol.json index 5c6a2fb8..a9c47be6 100644 --- a/Import/Metadata/RemoteProtocol.json +++ b/Import/Metadata/RemoteProtocol.json @@ -386,11 +386,44 @@ "name": "ControllerConnectionStopped", "request": null, "response": null + }, { + "$ast": "EnumDecl", + "attributes": [], + "name": "CharacterEncoding", + "members": [{ + "$ast": "EnumMember", + "name": "UTF8" + }, { + "$ast": "EnumMember", + "name": "UTF16" + }, { + "$ast": "EnumMember", + "name": "UTF32" + }] + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "ControllerGlobalConfig", + "members": [{ + "$ast": "StructMember", + "name": "documentCaretFromEncoding", + "type": { + "$ast": "ReferenceType", + "name": "CharacterEncoding" + } + }], + "type": "Struct" }, { "$ast": "EventDecl", "attributes": [], "name": "ControllerConnect", - "request": null + "request": { + "$ast": "EventRequest", + "type": { + "$ast": "ReferenceType", + "name": "ControllerGlobalConfig" + } + } }, { "$ast": "EventDecl", "attributes": [], @@ -2091,6 +2124,495 @@ } }, "response": null + }, { + "$ast": "EnumDecl", + "attributes": [{ + "$ast": "Attribute", + "cppType": "::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition", + "name": "@Cpp" + }, { + "$ast": "Attribute", + "cppType": "::vl::presentation::elements::IGuiGraphicsParagraph", + "name": "@CppNamespace" + }], + "name": "BreakCondition", + "members": [{ + "$ast": "EnumMember", + "name": "StickToPreviousRun" + }, { + "$ast": "EnumMember", + "name": "StickToNextRun" + }, { + "$ast": "EnumMember", + "name": "Alone" + }] + }, { + "$ast": "EnumDecl", + "attributes": [{ + "$ast": "Attribute", + "cppType": "::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition", + "name": "@Cpp" + }, { + "$ast": "Attribute", + "cppType": "::vl::presentation::elements::IGuiGraphicsParagraph", + "name": "@CppNamespace" + }], + "name": "CaretRelativePosition", + "members": [{ + "$ast": "EnumMember", + "name": "CaretFirst" + }, { + "$ast": "EnumMember", + "name": "CaretLast" + }, { + "$ast": "EnumMember", + "name": "CaretLineFirst" + }, { + "$ast": "EnumMember", + "name": "CaretLineLast" + }, { + "$ast": "EnumMember", + "name": "CaretMoveLeft" + }, { + "$ast": "EnumMember", + "name": "CaretMoveRight" + }, { + "$ast": "EnumMember", + "name": "CaretMoveUp" + }, { + "$ast": "EnumMember", + "name": "CaretMoveDown" + }] + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "DocumentTextRunProperty", + "members": [{ + "$ast": "StructMember", + "name": "textColor", + "type": { + "$ast": "PrimitiveType", + "type": "Color" + } + }, { + "$ast": "StructMember", + "name": "backgroundColor", + "type": { + "$ast": "PrimitiveType", + "type": "Color" + } + }, { + "$ast": "StructMember", + "name": "fontProperties", + "type": { + "$ast": "ReferenceType", + "name": "FontProperties" + } + }], + "type": "Struct" + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "DocumentInlineObjectRunProperty", + "members": [{ + "$ast": "StructMember", + "name": "size", + "type": { + "$ast": "ReferenceType", + "name": "Size" + } + }, { + "$ast": "StructMember", + "name": "baseline", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "breakCondition", + "type": { + "$ast": "ReferenceType", + "name": "BreakCondition" + } + }, { + "$ast": "StructMember", + "name": "backgroundElementId", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "callbackId", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }], + "type": "Struct" + }, { + "$ast": "UnionDecl", + "attributes": [], + "name": "DocumentRunProperty", + "members": [{ + "$ast": "UnionMember", + "name": "DocumentTextRunProperty" + }, { + "$ast": "UnionMember", + "name": "DocumentInlineObjectRunProperty" + }] + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "DocumentRun", + "members": [{ + "$ast": "StructMember", + "name": "caretBegin", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "caretEnd", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "props", + "type": { + "$ast": "ReferenceType", + "name": "DocumentRunProperty" + } + }], + "type": "Struct" + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "ElementDesc_DocumentParagraph", + "members": [{ + "$ast": "StructMember", + "name": "id", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "text", + "type": { + "$ast": "OptionalType", + "element": { + "$ast": "PrimitiveType", + "type": "String" + } + } + }, { + "$ast": "StructMember", + "name": "wrapLine", + "type": { + "$ast": "PrimitiveType", + "type": "Boolean" + } + }, { + "$ast": "StructMember", + "name": "maxWidth", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "alignment", + "type": { + "$ast": "ReferenceType", + "name": "ElementHorizontalAlignment" + } + }, { + "$ast": "StructMember", + "name": "runsDiff", + "type": { + "$ast": "ArrayType", + "element": { + "$ast": "ReferenceType", + "name": "DocumentRun" + } + } + }, { + "$ast": "StructMember", + "name": "createdInlineObjects", + "type": { + "$ast": "ArrayType", + "element": { + "$ast": "PrimitiveType", + "type": "Integer" + } + } + }, { + "$ast": "StructMember", + "name": "removedInlineObjects", + "type": { + "$ast": "ArrayType", + "element": { + "$ast": "PrimitiveType", + "type": "Integer" + } + } + }], + "type": "Struct" + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "RendererUpdateElement_DocumentParagraph", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "ElementDesc_DocumentParagraph" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "ReferenceType", + "name": "Size" + } + } + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "GetCaretRequest", + "members": [{ + "$ast": "StructMember", + "name": "caret", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "relativePosition", + "type": { + "$ast": "ReferenceType", + "name": "CaretRelativePosition" + } + }], + "type": "Struct" + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "GetCaretResponse", + "members": [{ + "$ast": "StructMember", + "name": "newCaret", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "preferFrontSide", + "type": { + "$ast": "PrimitiveType", + "type": "Boolean" + } + }], + "type": "Struct" + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "GetCaretBoundsRequest", + "members": [{ + "$ast": "StructMember", + "name": "caret", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "frontSide", + "type": { + "$ast": "PrimitiveType", + "type": "Boolean" + } + }], + "type": "Struct" + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "OpenCaretRequest", + "members": [{ + "$ast": "StructMember", + "name": "caret", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "caretColor", + "type": { + "$ast": "PrimitiveType", + "type": "Color" + } + }, { + "$ast": "StructMember", + "name": "frontSide", + "type": { + "$ast": "PrimitiveType", + "type": "Boolean" + } + }], + "type": "Struct" + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_GetCaret", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "GetCaretRequest" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "ReferenceType", + "name": "GetCaretResponse" + } + } + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_GetCaretBounds", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "GetCaretBoundsRequest" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "ReferenceType", + "name": "Rect" + } + } + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_GetInlineObjectFromPoint", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "Point" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "OptionalType", + "element": { + "$ast": "ReferenceType", + "name": "DocumentRun" + } + } + } + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_GetNearestCaretFromTextPos", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "GetCaretBoundsRequest" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + } + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_IsValidCaret", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, + "response": { + "$ast": "MessageResponse", + "type": { + "$ast": "PrimitiveType", + "type": "Boolean" + } + } + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_OpenCaret", + "request": { + "$ast": "MessageRequest", + "type": { + "$ast": "ReferenceType", + "name": "OpenCaretRequest" + } + }, + "response": null + }, { + "$ast": "MessageDecl", + "attributes": [], + "name": "DocumentParagraph_CloseCaret", + "request": null, + "response": null + }, { + "$ast": "StructDecl", + "attributes": [], + "name": "RenderInlineObjectRequest", + "members": [{ + "$ast": "StructMember", + "name": "callbackId", + "type": { + "$ast": "PrimitiveType", + "type": "Integer" + } + }, { + "$ast": "StructMember", + "name": "location", + "type": { + "$ast": "ReferenceType", + "name": "Rect" + } + }], + "type": "Struct" + }, { + "$ast": "EventDecl", + "attributes": [], + "name": "DocumentParagraph_RenderInlineObjects", + "request": { + "$ast": "EventRequest", + "type": { + "$ast": "ArrayType", + "element": { + "$ast": "ReferenceType", + "name": "RenderInlineObjectRequest" + } + } + } }, { "$ast": "EnumDecl", "attributes": [], @@ -2130,10 +2652,7 @@ "name": "ImageFrame" }, { "$ast": "EnumMember", - "name": "UnsupportedColorizedText" - }, { - "$ast": "EnumMember", - "name": "UnsupportedDocument" + "name": "DocumentParagraph" }] }, { "$ast": "StructDecl", @@ -2614,6 +3133,9 @@ }, { "$ast": "UnionMember", "name": "ElementDesc_ImageFrame" + }, { + "$ast": "UnionMember", + "name": "ElementDesc_DocumentParagraph" }] }, { "$ast": "StructDecl", diff --git a/Import/Metadata/RemoteProtocol/Protocol_Controller.txt b/Import/Metadata/RemoteProtocol/Protocol_Controller.txt index 348ab73d..ddd097ba 100644 --- a/Import/Metadata/RemoteProtocol/Protocol_Controller.txt +++ b/Import/Metadata/RemoteProtocol/Protocol_Controller.txt @@ -99,7 +99,19 @@ message ControllerGetScreenConfig message ControllerConnectionEstablished {} message ControllerConnectionStopped {} -event ControllerConnect {} +enum CharacterEncoding +{ + UTF8, + UTF16, + UTF32, +} + +struct ControllerGlobalConfig +{ + var documentCaretFromEncoding : CharacterEncoding; +} + +event ControllerConnect { request: ControllerGlobalConfig; } event ControllerDisconnect {} event ControllerRequestExit {} event ControllerForceExit {} diff --git a/Import/Metadata/RemoteProtocol/Protocol_Renderer.txt b/Import/Metadata/RemoteProtocol/Protocol_Renderer.txt index 051c14f9..fe4fb458 100644 --- a/Import/Metadata/RemoteProtocol/Protocol_Renderer.txt +++ b/Import/Metadata/RemoteProtocol/Protocol_Renderer.txt @@ -11,8 +11,7 @@ enum RendererType SolidLabel, Polygon, ImageFrame, - UnsupportedColorizedText, - UnsupportedDocument, + DocumentParagraph, } struct RendererCreation diff --git a/Import/Metadata/RemoteProtocol/Protocol_Renderer_Document.txt b/Import/Metadata/RemoteProtocol/Protocol_Renderer_Document.txt new file mode 100644 index 00000000..28f81fcf --- /dev/null +++ b/Import/Metadata/RemoteProtocol/Protocol_Renderer_Document.txt @@ -0,0 +1,106 @@ +[@Cpp(::vl::presentation::elements::IGuiGraphicsParagraph::BreakCondition)] +[@CppNamespace(::vl::presentation::elements::IGuiGraphicsParagraph)] +enum BreakCondition +{ + StickToPreviousRun, + StickToNextRun, + Alone, +} + +[@Cpp(::vl::presentation::elements::IGuiGraphicsParagraph::CaretRelativePosition)] +[@CppNamespace(::vl::presentation::elements::IGuiGraphicsParagraph)] +enum CaretRelativePosition +{ + CaretFirst, + CaretLast, + CaretLineFirst, + CaretLineLast, + CaretMoveLeft, + CaretMoveRight, + CaretMoveUp, + CaretMoveDown, +} + +struct DocumentTextRunProperty +{ + var textColor : color; + var backgroundColor : color; + var fontProperties : FontProperties; +} + +struct DocumentInlineObjectRunProperty +{ + var size : Size; + var baseline : int; + var breakCondition : BreakCondition; + var backgroundElementId : int; + var callbackId : int; +} + +union DocumentRunProperty +{ + DocumentTextRunProperty, + DocumentInlineObjectRunProperty, +} + +struct DocumentRun +{ + var caretBegin : int; + var caretEnd : int; + var props : DocumentRunProperty; +} + +struct ElementDesc_DocumentParagraph +{ + var id : int; + var text : string?; + var wrapLine : bool; + var maxWidth : int; + var alignment : ElementHorizontalAlignment; + var runsDiff : DocumentRun[]; + var createdInlineObjects : int[]; + var removedInlineObjects : int[]; +} + +message RendererUpdateElement_DocumentParagraph { request: ElementDesc_DocumentParagraph; response: Size; } + +struct GetCaretRequest +{ + var caret : int; + var relativePosition : CaretRelativePosition; +} + +struct GetCaretResponse +{ + var newCaret : int; + var preferFrontSide : bool; +} + +struct GetCaretBoundsRequest +{ + var caret : int; + var frontSide : bool; +} + +struct OpenCaretRequest +{ + var caret : int; + var caretColor : color; + var frontSide : bool; +} + +message DocumentParagraph_GetCaret { request: GetCaretRequest; response: GetCaretResponse; } +message DocumentParagraph_GetCaretBounds { request: GetCaretBoundsRequest; response: Rect; } +message DocumentParagraph_GetInlineObjectFromPoint { request: Point; response: DocumentRun?; } +message DocumentParagraph_GetNearestCaretFromTextPos { request: GetCaretBoundsRequest; response: int; } +message DocumentParagraph_IsValidCaret { request: int; response: bool; } +message DocumentParagraph_OpenCaret { request: OpenCaretRequest; } +message DocumentParagraph_CloseCaret {} + +struct RenderInlineObjectRequest +{ + var callbackId : int; + var location : Rect; +} + +event DocumentParagraph_RenderInlineObjects { request: RenderInlineObjectRequest[]; } \ No newline at end of file diff --git a/Import/Metadata/RemoteProtocol/Protocol_UnitTest.txt b/Import/Metadata/RemoteProtocol/Protocol_UnitTest.txt index 73dddf84..e46da983 100644 --- a/Import/Metadata/RemoteProtocol/Protocol_UnitTest.txt +++ b/Import/Metadata/RemoteProtocol/Protocol_UnitTest.txt @@ -9,6 +9,7 @@ union UnitTest_ElementDescVariant ElementDesc_Polygon, ElementDesc_SolidLabel, ElementDesc_ImageFrame, + ElementDesc_DocumentParagraph, } struct UnitTest_RenderingFrame diff --git a/Import/Metadata/RemoteProtocol/Protocols.txt b/Import/Metadata/RemoteProtocol/Protocols.txt index b846776c..9b73ee43 100644 --- a/Import/Metadata/RemoteProtocol/Protocols.txt +++ b/Import/Metadata/RemoteProtocol/Protocols.txt @@ -3,6 +3,7 @@ Protocol_MainWindow Protocol_IO Protocol_Renderer_BasicElements Protocol_Renderer_ImageFrame +Protocol_Renderer_Document Protocol_Renderer Protocol_SyncDom Protocol_UnitTest \ No newline at end of file diff --git a/Import/VlppGlrParser.cpp b/Import/VlppGlrParser.cpp index e2addf88..316d5aa0 100644 --- a/Import/VlppGlrParser.cpp +++ b/Import/VlppGlrParser.cpp @@ -275,88 +275,38 @@ AstInsReceiverBase } } - void AstInsReceiverBase::SetField(ParsingAstBase* object, vint32_t field, const ObjectOrToken& value, bool weakAssignment) + void AstInsReceiverBase::SetField(ParsingAstBase* object, vint32_t field, const SlotValue& value, bool weakAssignment) { - if (value.object) - { - if (weakAssignment) + value.Apply(Overloading( + [&](const TokenSlot& tokenSlot) { - throw AstInsException( - L"Weak assignment only available for field of enum type", - AstInsErrorType::FieldWeakAssignmentOnNonEnum, - field + if (weakAssignment) + { + throw AstInsException( + L"Weak assignment only available for field of enum type", + AstInsErrorType::FieldWeakAssignmentOnNonEnum, + field ); - } - SetField(object, field, value.object); - } - else if (value.enumItem != -1) - { - SetField(object, field, value.enumItem, weakAssignment); - } - else - { - if (weakAssignment) + } + SetField(object, field, tokenSlot.token, tokenSlot.index); + }, + [&](const EnumItemSlot& enumItemSlot) { - throw AstInsException( - L"Weak assignment only available for field of enum type", - AstInsErrorType::FieldWeakAssignmentOnNonEnum, - field + SetField(object, field, enumItemSlot.value, weakAssignment); + }, + [&](const Ptr< ParsingAstBase>& objectSlot) + { + if (weakAssignment) + { + throw AstInsException( + L"Weak assignment only available for field of enum type", + AstInsErrorType::FieldWeakAssignmentOnNonEnum, + field ); + } + SetField(object, field, objectSlot); } - SetField(object, field, value.token, value.tokenIndex); - } - } - - AstInsReceiverBase::CreatedObject& AstInsReceiverBase::PushCreated(CreatedObject&& createdObject) - { - if (created.Count() == 0) - { - created.Add(std::move(createdObject)); - } - else - { - auto& top = created[created.Count() - 1]; - if ( - !top.object && - top.pushedCount == createdObject.pushedCount && - top.delayedToken.reading == createdObject.delayedToken.reading && - top.delayedFieldAssignments.Count() == 0 - ) - { - top.object = createdObject.object; - top.extraEmptyDfaBelow++; - } - else - { - created.Add(std::move(createdObject)); - } - } - return created[created.Count() - 1]; - } - - const AstInsReceiverBase::CreatedObject& AstInsReceiverBase::TopCreated() - { - return created[created.Count() - 1]; - } - - void AstInsReceiverBase::PopCreated() - { - auto& top = created[created.Count() - 1]; - if (top.extraEmptyDfaBelow == 0) - { - created.RemoveAt(created.Count() - 1); - } - else if (top.object) - { - top.object = nullptr; - top.delayedFieldAssignments.Clear(); - top.extraEmptyDfaBelow--; - } - } - - void AstInsReceiverBase::DelayAssign(FieldAssignment&& fa) - { - created[created.Count() - 1].delayedFieldAssignments.Add(std::move(fa)); + )); } void AstInsReceiverBase::Execute(AstIns instruction, const regex::RegexToken& token, vint32_t tokenIndex) @@ -364,306 +314,254 @@ AstInsReceiverBase EnsureContinuable(); try { - if (created.Count() == 0 && instruction.type != AstInsType::BeginObject) - { - switch (instruction.type) - { - case AstInsType::BeginObject: - case AstInsType::DelayFieldAssignment: - case AstInsType::ResolveAmbiguity: - case AstInsType::AccumulatedDfa: - case AstInsType::LriStore: - case AstInsType::LriFetch: - break; - default: - throw AstInsException( - L"There is no created object.", - AstInsErrorType::NoRootObject - ); - } - } - - vint expectedLeavings = 0; - if (created.Count() > 0) - { - expectedLeavings = TopCreated().pushedCount; - } - switch (instruction.type) { case AstInsType::Token: - { - pushed.Add(ObjectOrToken{ token,tokenIndex }); - } - break; case AstInsType::EnumItem: + case AstInsType::StackSlot: { - pushed.Add(ObjectOrToken{ instruction.param }); - } - break; - case AstInsType::BeginObject: - { - auto value = CreateAstNode(instruction.param); - value->codeRange = { &token,&token }; - PushCreated(CreatedObject{ value,pushed.Count() }); - } - break; - case AstInsType::DelayFieldAssignment: - { - PushCreated(CreatedObject{ nullptr,pushed.Count(),token }); - } - break; - case AstInsType::ReopenObject: - { - auto& createdObject = created[created.Count() - 1]; - if (createdObject.object) + if (stackFrames.Count() == 0) { throw AstInsException( - L"DelayFieldAssignment is not submitted before ReopenObject.", - AstInsErrorType::MissingDfaBeforeReopen - ); - } - if (pushed.Count() < expectedLeavings + 1) - { - throw AstInsException( - L"There is no pushed value to reopen.", - AstInsErrorType::MissingValueToReopen - ); - } - if (pushed.Count() > expectedLeavings + 1) - { - throw AstInsException( - L"The value to reopen is not the only unassigned value.", - AstInsErrorType::TooManyUnassignedValues - ); + L"There is no stack frame to store slot values.", + AstInsErrorType::NoStackFrame + ); } + auto&& frame = stackFrames[stackFrames.Count() - 1]; - auto value = pushed[pushed.Count() - 1]; - if (value.object) + SlotValue slotValue; + switch (instruction.type) { - pushed.RemoveAt(pushed.Count() - 1); - createdObject.object = value.object; - createdObject.object->codeRange.start = ParsingTextPos::Start(&createdObject.delayedToken); - - for (auto&& dfa : createdObject.delayedFieldAssignments) + case AstInsType::Token: + slotValue = SlotValue(TokenSlot{ token,tokenIndex }); + break; + case AstInsType::EnumItem: + slotValue = SlotValue(EnumItemSlot{ instruction.param }); + break; + case AstInsType::StackSlot: { - SetField(createdObject.object.Obj(), dfa.field, dfa.value, dfa.weakAssignment); + if (creatingObjects.Count() == 0) + { + throw AstInsException( + L"There is no creating object to store in a stack slot.", + AstInsErrorType::NoCreatingObjectForStackSlot + ); + } + auto astNode = creatingObjects[creatingObjects.Count() - 1].object; + creatingObjects.RemoveAt(creatingObjects.Count() - 1); + slotValue = SlotValue(astNode); + + if (frame.codeRangeStart > astNode->codeRange.start) + { + frame.codeRangeStart = astNode->codeRange.start; + } } - createdObject.delayedFieldAssignments.Clear(); + break; + default:; + } + + auto keyIndex = frame.slots.Keys().IndexOf(instruction.count); + if (keyIndex == -1) + { + SlotStorage storage; + storage.value = slotValue; + frame.slots.Add(instruction.count, storage); } else { - throw AstInsException( - L"The pushed value to reopen is not an object.", - AstInsErrorType::ReopenedValueIsNotObject - ); + auto&& storage = const_cast(frame.slots.Values()[keyIndex]); + if (!storage.additionalValues) + { + storage.additionalValues = Ptr(new List); + } + storage.additionalValues->Add(slotValue); } } break; - case AstInsType::EndObject: + case AstInsType::StackBegin: { - Ptr objectToPush; - { - auto& createdObject = TopCreated(); - if (!createdObject.object) - { - throw AstInsException( - L"There is no created objects after DelayFieldAssignment.", - AstInsErrorType::NoRootObjectAfterDfa - ); - } - if (pushed.Count() > createdObject.pushedCount) - { - throw AstInsException( - L"There are still values to assign to fields before finishing an object.", - AstInsErrorType::LeavingUnassignedValues - ); - } - - objectToPush = createdObject.object; - PopCreated(); - } - - objectToPush->codeRange.end = ParsingTextPos::End(&token); - pushed.Add(ObjectOrToken{ objectToPush }); + stackFrames.Add({ {},ParsingTextPos::Start(&token) }); } break; - case AstInsType::DiscardValue: + case AstInsType::CreateObject: { - auto& createdObject = TopCreated(); - if (pushed.Count() <= createdObject.pushedCount) + if (stackFrames.Count() == 0) { throw AstInsException( - L"There is no pushed value to discard.", - AstInsErrorType::MissingValueToDiscard - ); + L"There is no stack frame to store slot values.", + AstInsErrorType::NoStackFrame + ); } - pushed.RemoveAt(pushed.Count() - 1); - } - break; - case AstInsType::LriStore: - { - { - vint pushedCount = 0; - if (created.Count() > 0) - { - auto& createdObject = TopCreated(); - pushedCount = createdObject.pushedCount; - } + auto&& frame = stackFrames[stackFrames.Count() - 1]; - if (pushed.Count() <= pushedCount) - { - throw AstInsException( - L"There is no pushed value to run LriStore.", - AstInsErrorType::MissingValueToLriStore - ); - } + auto astNode = CreateAstNode(instruction.param); + astNode->codeRange = { &token,&token }; + if (astNode->codeRange.start > frame.codeRangeStart) + { + astNode->codeRange.start = frame.codeRangeStart; } - auto value = pushed[pushed.Count() - 1]; - if (value.object) - { - if (lriStoredObject) - { - throw AstInsException( - L"LriFetch is not executed before the next LriStore.", - AstInsErrorType::LriStoredValueNotCleared - ); - } - else - { - lriStoredObject = value.object; - pushed.RemoveAt(pushed.Count() - 1); - } - } - else - { - throw AstInsException( - L"The value to run LriStore is not an object.", - AstInsErrorType::LriStoredValueIsNotObject - ); - } - } - break; - case AstInsType::LriFetch: - { - if (lriStoredObject) - { - pushed.Add(ObjectOrToken{ lriStoredObject }); - lriStoredObject = nullptr; - } - else - { - throw AstInsException( - L"LriStore is not executed before the next LriFetch.", - AstInsErrorType::LriStoredValueNotExists - ); - } + CreatingObject info; + info.object = astNode; + info.type = instruction.param; + creatingObjects.Add(info); } break; case AstInsType::Field: case AstInsType::FieldIfUnassigned: { - auto& createdObject = TopCreated(); - if (pushed.Count() <= createdObject.pushedCount) + if (creatingObjects.Count() == 0) { throw AstInsException( - L"There is no pushed value to be assigned to a field.", - AstInsErrorType::MissingFieldValue - ); + L"There is no creating object to assign fields.", + AstInsErrorType::NoCreatingObjectForField, + instruction.param + ); } - auto value = pushed[pushed.Count() - 1]; - pushed.RemoveAt(pushed.Count() - 1); + if (stackFrames.Count() == 0) + { + throw AstInsException( + L"There is no stack frame to provide values for field assignment.", + AstInsErrorType::NoStackFrame + ); + } + auto&& frame = stackFrames[stackFrames.Count() - 1]; - bool weakAssignment = instruction.type == AstInsType::FieldIfUnassigned; - if (createdObject.object) + auto slotKeyIndex = frame.slots.Keys().IndexOf(instruction.count); + if (slotKeyIndex == -1) { - SetField(createdObject.object.Obj(), instruction.param, value, weakAssignment); + break; } - else + + auto storage = frame.slots.Values()[slotKeyIndex]; + auto object = creatingObjects[creatingObjects.Count() - 1].object.Obj(); + + const bool weakAssignment = instruction.type == AstInsType::FieldIfUnassigned; + auto assignValue = [&](const SlotValue& slotValue) { - DelayAssign({ value,instruction.param,weakAssignment }); + SetField(object, instruction.param, slotValue, weakAssignment); + }; + + SetField(object, instruction.param, storage.value, weakAssignment); + if (storage.additionalValues) + { + for (auto&& additionalValue : *storage.additionalValues.Obj()) + { + SetField(object, instruction.param, additionalValue, weakAssignment); + } } } break; + case AstInsType::StackEnd: + { + if (stackFrames.Count() == 0) + { + throw AstInsException( + L"There is no stack frame to end.", + AstInsErrorType::NoStackFrameForStackEnd + ); + } + if (creatingObjects.Count() == 0) + { + throw AstInsException( + L"There is no creating object when ending the current stack frame.", + AstInsErrorType::NoCreatingObjectForStackEnd + ); + } + + auto&& frame = stackFrames[stackFrames.Count() - 1]; + auto astNode = creatingObjects[creatingObjects.Count() - 1].object.Obj(); + + if (astNode->codeRange.start > frame.codeRangeStart) + { + astNode->codeRange.start = frame.codeRangeStart; + } + + auto codeRangeEnd = ParsingTextPos::End(&token); + if (astNode->codeRange.end < codeRangeEnd) + { + astNode->codeRange.end = codeRangeEnd; + } + + stackFrames.RemoveAt(stackFrames.Count() - 1); + } + break; case AstInsType::ResolveAmbiguity: { - if (instruction.count <= 0 || pushed.Count() < expectedLeavings + instruction.count) + if (stackFrames.Count() == 0) + { + throw AstInsException( + L"There is no stack frame to resolve ambiguity.", + AstInsErrorType::NoStackFrame + ); + } + auto&& frame = stackFrames[stackFrames.Count() - 1]; + + auto slotKeyIndex = frame.slots.Keys().IndexOf(ResolveAmbiguitySlotIndex); + if (slotKeyIndex == -1) { throw AstInsException( L"There are not enough candidates to create an ambiguity node.", AstInsErrorType::MissingAmbiguityCandidate - ); + ); } - for (vint i = 0; i < instruction.count; i++) + auto storage = frame.slots.Values()[slotKeyIndex]; + vint candidateCount = 1; + if (storage.additionalValues) { - if (!pushed[pushed.Count() - i - 1].object) - { - throw AstInsException( - L"Tokens or enum items cannot be ambiguity candidates.", - AstInsErrorType::AmbiguityCandidateIsNotObject + candidateCount += storage.additionalValues->Count(); + } + if (candidateCount < 2) + { + throw AstInsException( + L"There are not enough candidates to create an ambiguity node.", + AstInsErrorType::MissingAmbiguityCandidate + ); + } + + Array> candidates(candidateCount); + auto readCandidate = [&](const SlotValue& slotValue, vint index) + { + slotValue.Apply(Overloading( + [&](const TokenSlot&) + { + throw AstInsException( + L"Tokens cannot be ambiguity candidates.", + AstInsErrorType::AmbiguityCandidateIsNotObject ); + }, + [&](const EnumItemSlot&) + { + throw AstInsException( + L"Enum items cannot be ambiguity candidates.", + AstInsErrorType::AmbiguityCandidateIsNotObject + ); + }, + [&](const Ptr& objectSlot) + { + candidates[index] = objectSlot; + } + )); + }; + + readCandidate(storage.value, 0); + if (storage.additionalValues) + { + for (vint i = 0; i < storage.additionalValues->Count(); i++) + { + readCandidate(storage.additionalValues->Get(i), i + 1); } } - Array> candidates(instruction.count); - for (vint i = 0; i < instruction.count; i++) - { - auto value = pushed[pushed.Count() - 1]; - pushed.RemoveAt(pushed.Count() - 1); - candidates[i] = value.object; - } - - pushed.Add(ObjectOrToken{ ResolveAmbiguity(instruction.param, candidates) }); + auto resolved = ResolveAmbiguity(instruction.param, candidates); + CreatingObject info; + info.object = resolved; + info.type = instruction.param; + creatingObjects.Add(info); } break; - case AstInsType::AccumulatedDfa: - { - auto&& createdObject = PushCreated(CreatedObject{ nullptr,pushed.Count(),token }); - createdObject.extraEmptyDfaBelow += instruction.count - 1; - } - break; - case AstInsType::AccumulatedEoRo: - { - while (instruction.count > 0) - { - auto& createdObject = created[created.Count() - 1]; - if (!createdObject.object) - { - throw AstInsException( - L"There is no created objects after DelayFieldAssignment.", - AstInsErrorType::NoRootObjectAfterDfa - ); - } - if (pushed.Count() > createdObject.pushedCount) - { - throw AstInsException( - L"There are still values to assign to fields before finishing an object.", - AstInsErrorType::LeavingUnassignedValues - ); - } - - if (createdObject.extraEmptyDfaBelow >= instruction.count) - { - createdObject.object->codeRange.start = ParsingTextPos::Start(&createdObject.delayedToken); - createdObject.object->codeRange.end = ParsingTextPos::End(&token); - createdObject.extraEmptyDfaBelow -= instruction.count; - instruction.count = 0; - } - else - { - instruction.count -= createdObject.extraEmptyDfaBelow + 1; - createdObject.extraEmptyDfaBelow = 0; - Execute({ AstInsType::EndObject }, token, tokenIndex); - Execute({ AstInsType::ReopenObject }, token, tokenIndex); - } - } - } - break; - default: - CHECK_FAIL(L"vl::glr::AstInsReceiverBase::Execute(AstIns, const regex::RegexToken&)#Unknown Instruction."); } } catch (const AstInsException&) @@ -678,7 +576,7 @@ AstInsReceiverBase EnsureContinuable(); try { - if (created.Count() > 0 || pushed.Count() > 1) + if (stackFrames.Count() > 0 || creatingObjects.Count() != 1) { throw AstInsException( L"No more instruction but the root object has not been completed yet.", @@ -686,15 +584,8 @@ AstInsReceiverBase ); } - auto object = pushed[0].object; - if (!object) - { - throw AstInsException( - L"No more instruction but the root object has not been completed yet.", - AstInsErrorType::InstructionNotComplete - ); - } - pushed.Clear(); + auto object = creatingObjects[0].object; + creatingObjects.RemoveAt(0); finished = true; return object; } @@ -884,6 +775,7 @@ Reflection } } + /*********************************************************************** .\ASTPRINT.CPP ***********************************************************************/ @@ -1088,6 +980,16 @@ namespace vl SERIALIZE(count) END_SERIALIZATION + BEGIN_SERIALIZATION(CompetitionArray) + SERIALIZE(start) + SERIALIZE(count) + END_SERIALIZATION + + BEGIN_SERIALIZATION(CompetitionDesc) + SERIALIZE(competitionId) + SERIALIZE(highPriority) + END_SERIALIZATION + BEGIN_SERIALIZATION(ReturnIndexArray) SERIALIZE(start) SERIALIZE(count) @@ -1101,7 +1003,7 @@ namespace vl BEGIN_SERIALIZATION(ReturnDesc) SERIALIZE(consumedRule) SERIALIZE(returnState) - SERIALIZE(priority) + SERIALIZE(competitions) SERIALIZE(ruleType) SERIALIZE(insAfterInput) END_SERIALIZATION @@ -1110,15 +1012,13 @@ namespace vl SERIALIZE(fromState) SERIALIZE(toState) SERIALIZE(condition) - SERIALIZE(priority) - SERIALIZE(insBeforeInput) + SERIALIZE(competitions) SERIALIZE(insAfterInput) SERIALIZE(returnIndices) END_SERIALIZATION BEGIN_SERIALIZATION(StateDesc) SERIALIZE(rule) - SERIALIZE(clause) SERIALIZE(endingState) END_SERIALIZATION @@ -1129,6 +1029,7 @@ namespace vl SERIALIZE(transitions) SERIALIZE(astInstructions) SERIALIZE(returnIndices) + SERIALIZE(competitions) SERIALIZE(returns) SERIALIZE(edges) SERIALIZE(states) @@ -2330,20 +2231,19 @@ namespace vl::glr::json { void JsonParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 1933; // 17265 bytes before compressing + static const vl::vint dataLength = 1790; // 16729 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 141; - static const vl::vint dataSolidRows = 7; - static const vl::vint dataRows = 8; + static const vl::vint dataRemain = 254; + static const vl::vint dataSolidRows = 6; + static const vl::vint dataRows = 7; static const char* compressed[] = { - "\x71\x43\x00\x00\x85\x07\x00\x00\x0C\x00\x01\x82\x80\x06\x03\x82\x81\x82\x06\x89\x82\x87\x0A\x80\x81\x84\x09\x0A\x98\x0A\x9D\x0A\x86\x65\x01\x84\xFF\x19\x9A\x99\x8A\x80\x03\x8D\x8D\x1D\x9D\x97\x89\x83\x96\x81\x93\x81\x02\x0A\xA7\x82\x8F\x8A\x8D\x8F\x96\x1C\x8A\xB0\x9F\x7F\x90\x99\x9B\x96\x37\x9F\x9D\x83\x0A\x92\x84\x03\x9E\x18\xB6\xB2\x82\xA1\xA0\x9F\xA0\xA3\x45\xBA\x87\xAA\xA9\xA0\x93\xA4\xA7\x4D\xAE\x8F\xB2\xA1\xA9\x99\xAA\x9A\x53\xD6\x86\x93\x99\x98\xAA\x83\x02\x40\xDB\x84\xA2\xB8\xA4\xB0\xA6\xB3\x5E\x83\x9C\xB9\xA8\xAF\xA9\xAE\xAA\x68\xF0\xAA\xA3\xB3\xBD\xB1\xBB\xB3\x77\xE9\x87\x81\xB9\xBA\xB8\x96\xBA\x7F\xF6\x81\xD8\xB3\xC2\xBD\x81\xB5\x6E\xEC\xAF\xBA\xAD\xBC\xC5\xC2\xBF\x87\x80\xD1\xC2\xC1\x84\x84\x92\xC5\x98\x89\xDA\xD1\xBE\xC3\xC8\xC2\xCF\x86\x9E\x92\xC2\xD4\xCC\xD3\xCE\xD3\xA1\x88\xDC\xCD\xB6\x80\x04\xBF\xC7\x9D\xA8\xD0\xD2\xD1\xDA\xD5\xC6\xD6\xB7\x8B\xF8\xD0\xDB\xD8\xD3\xD8\xDB\xBC\xBA\xC2\xEA\x89\x07\xD6\xDF\xDA\xA3\xC0\xC7\xFD\xD4\xDC\xE6\xE5\xE6\xC3\x9B\xF9\xD9\xCB\xD1\xE9\xEA\xEA\xD3\xD2\xC1\xF8", + "\x59\x41\x00\x00\xF6\x06\x00\x00\x0C\x00\x01\x82\x80\x06\x03\x82\x81\x82\x06\x89\x82\x87\x0A\x80\x81\x84\x09\x0A\x98\x0A\x9D\x0A\x86\x65\x01\x84\xFF\x19\x9A\x99\x8A\x80\x03\x8D\x8D\x1D\x9D\x97\x89\x83\x96\x81\x93\x81\x02\x0A\xA7\x82\x8F\x8A\x8D\x8F\x96\x1C\x8A\xB0\x9F\x7F\x90\x99\x9B\x96\x37\x9F\x9D\x83\x0A\x92\x84\x03\x9E\x18\xB6\xB2\x82\xA1\xA0\x9F\xA0\xA3\x45\xBA\x87\xAA\xA9\xA0\x93\xA4\xA7\x4D\xAE\x8F\xB2\xA1\xA9\x99\xAA\x9A\x53\xD6\x86\x93\x99\x98\xAA\x83\x02\x40\xDB\x84\xA2\xB8\xA4\xB0\xA6\xB3\x5E\x83\x9C\xB9\xA8\xAF\xA9\xAE\xAA\x68\xF0\xAA\xA3\xB3\xBD\xB1\xBB\xB3\x77\xE9\x87\x81\xB9\xBA\xB8\x96\xBA\x7F\xF6\x81\xD8\xB3\xC2\xBD\x81\xB5\x6E\xEC\xAF\xBA\xAD\xBC\xC5\xC2\xBF\x87\x80\xD1\xC2\xC1\x84\x84\x92\xC5\x98\x89\xDA\xD1\xBE\xC3\xC8\xC2\xCF\x86\x9E\x92\xC2\xD4\xCC\xD3\xCE\xD3\xA1\x88\xDC\xCD\xB6\x80\x04\xBF\xC7\x9D\xA8\xD0\xD2\xD1\xDA\xD5\xC6\xD6\xB7\x8B\xF8\xD0\xDB\xD8\xD3\xD8\xDB\xBC\xBA\xC2\xEA\x89\x07\xD6\xDF\xDA\xA3\xC0\xC7\xFD\xD4\xDC\xE6\xE5\xE6\xC3\x9B\xF9\xD9\xCB\xD1\xE9\xEA\xEA\xD3\xD2\xC1\xF8", "\xEB\xEA\xEF\xE4\xEB\xD9\xD7\xC9\x8A\x06\xE0\xE8\xEF\xEF\xE7\xE6\xDE\xEA\xF2\xF5\xF5\xF1\xF7\xDD\xEE\xF1\xF0\xF8\xF3\xF7\x05\xF2\x0E\xA6\x8A\x8D\x05\xF6\x05\xF3\xE7\x0F\x3F\x79\x73\x80\xA5\x50\x05\x79\x04\x02\xA5\x60\x47\x65\xEB\x4F\x7E\x80\x81\xA7\x4F\x85\x6A\x84\x11\x90\x89\x6A\x85\xBF\x58\x88\x73\x84\x1A\x8E\x7D\x84\x78\xF3\x61\x81\x43\x04\x09\x95\x8C\x87\x89\x26\xA9\x87\x84\x8A\xA1\x54\x05\x8B\x8A\x2A\x99\x8C\x8A\x8C\x31\x9B\x85\x8E\x87\x33\xB6\x80\x8F\x8E\x34\xBC\x8A\x8D\x8F\x40\xBF\x82\x90\x8E\x37\xA0\x85\x7E\x7C\x47\xB4\x70\x01\x05\x2F\x81\x94\x92\x8F\x4F\xB3\x66\x05\x93\x43\x86\x9C\x7A\x92\x14\x90\x96\x95\x96\x4E\x96\x97\x04\x95\xCC\x52\x4C\x80\x92\x57\xA2\x85\x99\x92\x66\x9C\x95\x95\x7A\x6A\x91\x9B\x99\x83\x1F\xAC\x93\x69\x06\x60\x96\x9A\x05\x9D\x72\xB9\x8E\x9B\x9E\x5B\xB1\x90\x9D\x69\x1B\x38\x9F\x9D\x91\x79\x84\xA3\xA2\x96\x85\x88\xA7\xA1\x97\x89\x8C\xAB\xA3\x9B\x06\x5C\x05\x78\x45\x63\x83\x4E\x05\x79\x1F\x02\xA6\x40\x08\xE5\x61\x0A\xA6\x92\x22\x25\x73\x0B\xA7\x69\xA3\x64\x09\x79\x25\x25\x76\x09\x79", - "\x27\x24\xA1\x40\x0A\xAE\xA7\x92\xAD\x0A\xE5\x6A\x01\xAF\x0A\xB1\xAD\x9D\x9E\x9E\xBB\x86\xA4\x9A\xAE\x8D\x90\xA8\x96\x9F\xBF\x84\xB3\x40\x0B\xE5\x6D\x09\xAE\xB1\xA5\xBC\xAA\x42\x0B\xE5\x6F\x05\x78\x0C\xE5\x71\x01\xAE\x0C\xCB\x8E\xB9\x43\x0C\xE5\x74\x09\xB6\xAF\xC3\x9A\xB5\xB2\xB8\xE1\xA0\xBD\xB2\xB9\x01\x75\x0F\xB6\xA2\xE3\xA8\xB2\xAC\xB0\x8F\xBC\x99\x7A\x0D\xEB\x8E\xAD\xB8\xBB\xE5\xB8\xB7\xBA\xBE\x68\x81\x47\x0D\xBD\xC2\xBB\xB6\xBD\xBE\x03\xC2\xC1\xC1\xBF\xEF\x8C\xB8\xC3\x73\x38\x31\xA9\x0C\xC0\xF2\xB1\xBD\xAC\xBF\x09\xE4\xB6\xC1\xC4\xF7\x85\xCB\xC2\xC2\x00\x3A\x00\xC7\xC4\x1A\xD5\xCE\xB8\xBC\x19\xC7\xC0\x03\x0E\x1F\xC1\xB8\xC4\xC1\x26\xE4\xCC\xCB\xCA\x02\x7D\x1A\x41\x4A\x95\xBC\x64\xCE\x7E\x57\x77\xC3\x43\x4A\xCB\x7A\xC2\x40\x4F\xF1\xB3\x45\x71\x42\x3E\xFD\xCA\x40\x42\x25\xF3\x4F\x3F\xD0\x06\x48\xD7\x6C\xCF\x00\x10\xD2\xD0\x98\x60\x57\x53\x4C\xD4\x45\xCD\x7C\xD3\xCE\x6C\x55\xDB\x6B\xD5\x21\x57\x5B\xD6\x40\x52\xF0\x4E\xD7\x6D\x33\x67\xDC\x6D\xDA\x6C\x73\x49\xD6\xDA\x1B\xCA\xDF\x47\xD8\x01\x7F\x47\x54\xD0\x5F", - "\xF0\x49\xD5\xD9\x2D\x78\xD8\xDA\xDE\x60\xBE\xDB\xD8\xE0\x35\xCB\x72\xE3\x72\x6E\xFE\x4C\x5B\xE1\xCD\x49\xE1\xDB\x6D\x8C\xF2\xDD\x49\xD6\x91\xDD\x83\xD4\xD1\x8B\xED\xD4\xE1\xD3\x2A\xD7\xEC\xE7\x55\x70\xCD\xEB\xE7\x40\x76\xEB\x6F\xD9\xE7\x30\x74\xD0\x01\xE9\xB7\x67\xE1\xD1\xEA\x8A\xE0\xEA\xE7\xE4\x8F\xD0\xE3\xEF\x47\x7B\xD9\xE6\xD7\xE8\x64\xFA\xE9\xDC\xED\x85\xCD\x75\xE6\xE4\x1A\x59\xDC\xE8\x6F\xC3\xC4\xFF\x3D\xD6\xBA\x49\xF4\xF0\xE5\xA8\xED\x4A\xE9\xD6\x33\x4E\xF2\xE5\xD6\x4E\xD7\xCE\xE7\x40\xD9\xC6\xE7\xEF\x46\xB9\xF7\xDF\xF5\xF1\x81\xE3\xF9\x45\xF8\xAB\x56\xF2\xDE\xF1\xBE\xFF\xD0\xF1\xED\xC2\xE6\xFB\xF2\x42\xEA\xFB\x9B\xF6\x40\xD4\xF0\x45\xFE\xE3\x9F\xC9\xD7\xFD\x40\xDD\x6D\x39\xE8\x4A\x7A\x23\xFD\x7C\x71\x20\x7C\x7F\x22\x01\xEF\x7C\x6A\xF1\x7B\x74\x81\xBD\x6E\x83\xEF\x38\x71\x77\xF4\x72\x7C\x79\xED\x63\x70\x04\x81\x25\x7E\xDD\x3F\x78\x00\xF9\x7D\x6F\x05\xC7\x61\x7B\xB9\x64\x87\x2A\xC7\x68\x72\xD9\x72\x79\x84\xD1\x6D\x23\x80\x04\x9F\x1D\x0B\xB1\x8F\x1E\x18\x84\x83\x81\x14\x89\x23\x0C\xFA\x73\x84\xF8\x4D\x3B", - "\x87\x04\x96\x86\xF2\x40\x8A\x78\x21\x84\x7A\x75\x46\x9A\x22\xEA\x75\x7B\x88\xB6\x2A\x72\x37\x4F\x8C\x2E\xBA\x3E\x80\x6A\x91\x3E\x81\x6A\x57\x98\x81\x42\x0C\x76\x8A\x2A\x95\x83\x20\xA1\x61\x80\xD4\x62\x87\x84\x9C\x7D\x78\x25\x65\x83\x20\xE3\x64\x89\x20\x36\x86\x26\x32\x66\x83\x20\x1C\x8D\x8F\x8D\xF2\x33\x88\x7F\x0A\x37\x8C\x07\xF9\x86\x8F\xF2\x10\x6F\x8F\x33\x74\x7E\x1F\x8A\x2E\x35\x84\x2A\x74\x3C\x3A\x8A\x20\x22\xD7\x89\x20\x3C\x25\x3D\x23\x81\x5E\x85\x07\x81\x99\x20\x49\x52\x91\x3D\x8C\x77\x4F\x25\xEB\x30\x6A\x04\x4C\x91\x21\x79\x03\x91\x42\x1E\x9F\x93\x81\x3A\x0D\x3C\x2D\x9F\x49\x29\x83\x2B\x0E\x54\x8A\x22\x95\xAB\x81\x20\x1F\x65\x39\x6A\x4E\x5B\x94\x4C\x8C\x79\x53\x2D\xCA\x4C\x07\x2B\x84\x89\x34\x8C\x89\x80\xC5\x1D\x21\x85\xD3\x1D\x89\x8E\x17\x6C\x93\x24\xBE\x88\x7D\x97\x4C\x91\x89\xB1\x3B\x26\x2B\x98\x7B\x3D\x8E\x01\x87\x39\xD6\x9D\x8C\x35\xE4\x4D\x98\x33\x5D\x25\x89\x12\x62\x91\xF0\x58\x9D\x20\x71\x89\x6D\x23\x2D\x82\x9B\x6C\x1D\x21\x41\x2D\xAA\x65\x23\xA1\x6A\x9D\x34\x8A\x2B\x40\x64\xB1\x6F\x34\x6E\x8A", - "\x49\x47\x24\x43\x9C\x8E\x7A\x88\x00\xF7\x35\x9A\x42\x2E\x41\x78\x26\x5B\x9A\x49\xAA\x7F\x97\x3A\xAF\x94\x92\x32\x44\x9C\x38\x0D\xBA\x9E\x42\x74\x47\xA0\x33\x59\x69\x6B\xE0\x8E\xA2\x42\x11\x96\x21\x62\xA1\x35\x85\x18\xAA\x22\x7F\x02\xA9\x20\x4A\x5D\xA1\x3D\x01\x81\xA5\x42\x04\xAA\xA3\x84\x3A\x97\xA4\xEB\x25\x90\x4C\x86\x28\x89\xF4\x1D\x26\x53\x15\xA1\x23\xA8\x39\xA0\x01\x45\xA8\x8E\x90\x69\x9E\x9A\x42\x29\x5C\xA7\x56\x7C\xA1\x3F\x3F\xA6\x22\x4F\x82\x22\xA6\x89\x89\x24\x56\xFD\x96\x61\x40\x01\xA4\xA6\x9B\xAF\x99\x3D\x48\xA2\x23\x48\xAD\xA6\x20\x5B\x51\xAE\x5D\x5B\xA3\x22\x81\x24\xA7\x9D\xF4\x21\xAA\x20\x54\xAE\xAA\x41\x38\x51\x78\x64\x7C\xA7\xAC\x08\x8A\x21\x3B\x86\x29\xAC\xA1\x89\x20\x5A\xC1\x72\x58\x4F\xF3\xA4\x8E\xB1\xBB\x3E\xAA\x09\x36\x5B\x57\x94\x64\x94\xBF\xA4\xAE\x99\xE9\x25\xB2\x40\x7C\xA6\xAF\xB2\xAB\x3D\x9E\x03\x2C\xA6\x5A\x83\x28\x5B\xC1\xA1\x62\xB2\x02\x2A\xA3\x3C\xDB\x51\xA2\x33\x63\xAB\xA6\x91\xBD\xB0\xC2\x1D\x23\x8A\xD0\xA6\x48\xB2\x78\x8B\xA6\x39\x93\xB2\x21\x7F\x7C\xA7\x39\x98\xA1\x21\xD6\x31", - "\xB0\x00\xB8\xB2\x55\x23\x0F\x6F\xB7\x68\x53\x4C\xA6\xDA\xB4\xB4\x9C\x09\x28\x66\x6E\xA5\x32\x4C\xD3\x81\x24\xB6\xBC\xBC\xA8\x62\xEB\x34\xB6\x68\x8C\x3D\x23\x3D\x02\xB4\x00\x3F\x02\xBA\x4D\x86\xB8\x00\xB4\xB7\x9B\x68\x1D\x21\x08\xE9\x83\x0A\xBA\x96\x97\xBA\x41\x86\x2A\xB3\xE7\x8A\x25\x08\xD2\xAF\x3B\xA5\x3C\xA3\xBD\xA4\xAC\xB1\x20\x47\x09\xBF\x68\x36\x92\xBD\xD5\x8D\xB3\x20\x49\x12\xBD\x69\x21\x5C\xBC\x91\x80\xB6\x20\x4B\x1A\xBF\x69\x27\x5D\xBE\xD5\x87\xB2\x20\x4D\x02\xC1\x68\x2B\x55\xC1\xAF\x3F\xBB\x20\x4F\x12\xB9\x14\x52\xB0\x57\x06\xDC\x7F\xC1\x02\x33\x0A\x74\xD5\x02\xBA\xAF\x97\xB9\xB9\x03\x3C\x9E\x72\x82\x27\x0B\x94\x49\x20\x96\x03\x20\xC7\x7D\xC9\x99\x3C\x14\xC2\x25\xBD\x2B\xD7\x9C\xC5\x45\xB4\x74\x0C\xC1\x20\x0B\x0A\xD3\x36\x5B\xF6\x90\x00\x1A\xE9\xB3\xC4\x01\x3A\x09\x8E\xB1\x3A\x59\xE0\x7E\xC3\x8F\x07\xC1\x20\x17\x43\xCC\x38\xBC\xBC\xC7\xC8\xB5\xB6\xC4\x00\x5E\x0C\xC9\x8E\x3A\xAF\xC9\x03\xB2\xC8\x18\x55\xCA\x20\x6A\x46\xCA\x21\xCE\xAC\x92\x18\x52\xB4\x0C\xE9\x82\xB0\xCB\x6D\x92\xCA\x19\x52\xB8\x0C\xE9", - "\x95\xB4\xC7\xD6\xA3\x20\x45\xC0\xC0\x00\x35\x1C\xCB\x3D\x1C\xB2\xCE\x94\xEC\x07\xCE\x32\x61\xBA\xCF\x49\xC0\x02\x1B\x7D\xCA\x48\x93\x83\x26\xB6\xC0\xA6\x20\x1C\x04\xD2\x20\x6E\x41\x7E\xD0\x02\x3F\xB7\x76\x8A\x22\x0E\x46\xC1\x26\x5B\xC1\x6F\xA6\xA5\x52\xC4\x0E\x4B\xF2\x54\xBE\x9B\xC1\xD2\x1D\x1E\xDF\x38\x9C\xB0\x78\x9B\x4A\x72\x9A\x2F\x8C\x9A\x8B\xE0\x65\x92\x9E\x34\x30\xD7\x3F\x55\x87\x98\xF8\x74\xD5\xCA\x1E\xA0\x7C\xAB\xBB\xD9\x8A\x65\x8A\x33\x7F\x5C\x8A\xD7\x2E\xB5\x71\xD9\x2F\x81\x3D\xBC\x32\x92\xBB\xEA\x0C\x99\x9C\x78\x8A\x36\xB9\x35\x8F\x91\xE8\x1F\x90", + "\x27\x24\xA1\x40\x0A\xAE\xA7\x92\xAD\x0A\xE5\x6A\x01\xAF\x0A\xB1\xAD\x9D\x9E\x9E\xBB\x86\xA4\x9A\xAE\x8D\x90\xA8\x96\x9F\xBF\x84\xB3\x40\x0B\xE5\x6D\x09\xAE\xB1\xA5\xBC\xAA\x42\x0B\xE5\x6F\x05\x78\x0C\xE5\x71\x01\xAE\x0C\xCB\x8E\xB9\x43\x0C\xE5\x74\x09\xB6\xAF\xC3\x9A\xB5\xB2\xB8\xE1\xA0\xBD\xB2\xB9\x01\x75\x0F\xB6\xA2\xE3\xA8\xB2\xAC\xB0\x8F\xBC\x99\x7A\x0D\xEB\x8E\xAD\xB8\xBB\xE5\xB8\xB7\xBA\xBE\x68\x81\x47\x0D\xBD\xC2\xBB\xB6\xBD\xBE\x03\xC2\xC1\xC1\xBF\xEF\x8C\xB8\xC3\x73\x38\x31\xA9\x0C\xC0\xF2\xB1\xBD\xAC\xBF\x09\xE4\xB6\xC1\xC4\xF7\x85\xCB\xC2\xC2\x00\x3A\x00\xC7\xC4\x1A\xD5\xCE\xB8\xBC\x19\xC7\xC0\x03\x0E\x1F\xC1\xB8\xC4\xC1\x26\xE4\xCC\xCB\xCA\x02\x42\x2A\x41\x4A\x57\x6E\xC2\x40\xCD\xAB\x76\xC1\x40\xCE\xB7\x7A\xC0\x00\xCF\xBC\x7E\xC0\xD3\x72\x3E\xEB\x41\x42\xD1\x00\x08\xDF\x4D\xA5\xBC\x60\x5C\xD3\xD1\x0A\x56\x69\xCC\x4C\x48\xC3\xD9\xD2\x4F\x60\x8E\xDA\x7F\xD3\x00\x12\xDD\xCC\xD5\x21\x5C\xDB\xD3\xD6\xAB\x5A\xD3\x40\xD2\x48\xDE\xD1\xD0\x4C\x63\xC3\x4C\x4F\x55\x66\xF7\xC1\xDA\x41\x6A\xC4\xDC\xDA\x42\x08", + "\x65\xD8\xDF\xDC\x03\x75\xDD\x73\x4C\x56\xF3\x42\xD0\x5B\x83\xF5\xCC\xC5\xE0\x82\xD6\xCB\xCC\xE1\x87\xCC\xEA\xE3\xCF\x8E\xEE\xB8\xE1\xE2\x14\xED\xD2\x41\xDC\xCB\x58\xE0\x02\xE5\x61\xDA\xEA\xE6\xD5\x7E\xD4\xE7\x8D\xD5\x91\xD4\xCA\x6F\xDB\x06\x53\xE2\xE8\xCC\x8B\xC6\xEF\xE0\xE7\x9B\xEC\x5A\xE4\xEA\x67\xD1\xD5\xEA\x93\xB4\xF3\xD0\xE3\xCC\xB7\xE6\xCA\xEA\xE8\x56\xBF\xE4\xE5\xF0\xBD\xEC\xE0\xE6\xEB\x92\xC5\xF6\x97\xE9\xBC\xC8\xF4\xC6\xF0\x89\xC4\xFE\xF1\xC8\xD0\xC2\xE2\xF7\xD4\x8F\xD5\xF5\xE0\xF6\xC9\xD3\xFE\xEE\xF2\xE9\x70\xEA\x6E\xE6\x22\x76\xEE\xF7\x9E\xB9\xE1\xDB\xED\x42\xDA\xCD\xE7\xFB\xF5\x5F\xD9\xF0\xFB\x7A\xED\xF2\xFF\xF9\x7A\xF5\xEE\xB1\xEB\xEA\x19\x7B\xFC\xFE\xFF\xAB\x79\x7F\xF3\x73\x74\x4C\x00\xA2\x76\x80\x94\x69\x7D\x73\x56\x62\x80\x8D\x0D\x81\x23\x0F\x9F\x1E\x02\xB3\x28\x69\x09\xA0\x69\x21\x16\x8D\x25\x05\xEC\x24\x75\xF3\x51\x82\x5D\x7C\x70\x69\x08\xD7\x63\x84\xA4\x5D\x26\x6A\x3B\x23\x84\x09\xA1\x8A\x68\x85\x1A\x71\x6F\xB5\x69\x20\x0C\x82\x28\x69\x19\xA2\x86\x20\x36\x87\x78\x0E\x8A\x2A\x81\x1C\xB5\x85", + "\x3C\x7E\x69\x6C\x10\xC3\x8C\x7C\xF3\x46\x22\x81\x41\x86\x89\x0C\xE4\x6B\x89\x26\xB2\x68\x83\xE5\x28\x6A\x6B\x09\x25\x39\x11\xA4\x39\x21\xB0\x77\x88\x99\x1D\x28\x0F\xF2\x1D\x21\x50\xEB\x2A\x81\x1E\x65\x36\x6A\x49\x61\x8A\x21\x7A\x05\x3E\x02\xF7\x47\x8D\x84\x3B\x09\x8A\x0A\x28\x43\x7A\x1D\x2C\x0E\x38\x89\x22\x8E\x5B\x8A\x21\x1F\x65\x30\x77\x2F\x73\x8A\x21\x7E\x1C\x8E\x42\x7E\x89\x8F\x84\x3F\x0C\x8C\x0A\x3C\x51\x1B\x86\x20\x10\x35\x8A\x21\x53\x8B\x83\x21\x20\x65\x3C\x06\x15\xB0\x76\x67\x27\x89\x3D\x26\x92\x6D\x79\xD4\x5A\x94\x87\x2A\x7D\x20\xEC\x55\x7A\x84\x00\x1A\x76\x67\x39\x84\x96\x0A\xB9\x8E\x67\x29\x9E\x94\x7E\x29\x63\x3C\xD6\x11\x94\x87\x50\x8A\x26\x3F\x58\x81\x7D\x2C\x86\x2B\x40\x83\x17\x93\x34\x9A\x68\x6A\xCF\x53\x40\x8B\xF5\x3E\x86\x96\x09\x34\x4D\x31\x85\x8A\x21\xFB\x1C\x91\x21\x66\x8F\x94\x99\x55\x8E\x96\x64\x86\x27\x52\x45\x83\x86\xD5\x54\x98\x24\x6B\x83\x22\x91\xD2\x9D\x99\x36\x86\x2C\x9A\x81\x19\x86\x5D\xA1\x43\x9F\x40\x23\x94\x39\x5B\x9E\x9A\x20\xA7\x4A\x9F\x5E\x72\x91\x21\x72\x81\x26\x45\xCF\x86", + "\x23\xAA\x74\x90\x00\x57\xA2\x9C\x9C\x2E\x8F\x9F\xAB\x1D\x93\x20\x2D\xBF\x9B\x20\xF6\x84\x22\x40\x80\x06\x56\x7E\xB9\x3F\xA0\x02\x26\xA2\x40\x7E\x97\x63\x8E\x08\x59\x97\xF6\x2D\x9D\x3E\x83\x24\x5A\xAE\x4F\x3F\xA1\x02\x38\x95\xC9\x4C\x36\x5A\x7E\x8F\x3A\xA4\x03\x26\x43\x46\x82\x2C\x5A\x8F\xA3\x30\xA5\x02\x2E\x9B\x48\x9D\x2E\x5A\x7E\xB0\xA7\x86\x03\x21\x41\x42\x32\xAF\x65\x8E\x34\x5C\x9F\x3A\xAC\x8A\x40\x2A\xA6\x20\xFE\x2B\xA1\x20\x0D\x6B\x9A\x92\x78\x89\xA5\x85\xA8\x66\xA5\xA5\x2C\xAA\x40\x41\xAD\xA6\x85\x15\x90\xAA\xA7\x3D\x97\x40\x78\x93\xA6\x85\x3D\x04\xA0\x66\x5C\xAB\x3A\x8B\xAF\x06\xB0\x81\x24\xA8\x10\xB7\x9E\x59\xA2\x61\x35\x20\x2B\xAA\xAB\x4F\x86\x22\x58\xE6\x9B\xA1\x21\x2B\xAB\xAE\xAD\x72\xAE\x3B\xC7\xA0\x01\x22\x2B\xAC\x98\xE1\x82\x20\x5E\x80\x03\xB0\x9F\x47\x0B\xAD\x62\x41\xB2\x5A\x89\x20\xB1\xAA\x89\x21\x09\xB1\x43\xB3\x29\x9C\x6A\x09\xB5\xAC\x8A\xB1\x84\xBB\x6C\x5F\xCC\x0B\xAD\x68\xA9\xAB\x49\xB3\x9D\xA9\x42\x4E\x0B\xAC\x6C\x98\xB4\x49\x26\xBC\x60\x14\x6B\xA0\x9D\xCF\xA8\xB7\x88\x0B\xB2\x0B\x5A\xE9", + "\x97\xB5\xBD\xA2\xB6\x20\x54\x0B\xAD\x3C\xB5\xB9\x21\xC2\x9C\x66\x0A\x6B\xBB\x9C\x6F\xDF\x2B\xA0\x2C\x2B\xA8\x56\xFC\x8F\xB7\x40\x2C\x9C\x62\x2D\x2B\xAD\xA1\x98\xAD\xB2\x40\x24\x4C\xAE\x2E\x20\x93\x3D\x84\x83\x22\x74\x9B\x65\x35\x2F\x31\x51\xBB\x02\x2A\xB9\x45\x8A\x20\x0D\x58\x49\xB3\xAC\x7C\xA1\x0F\x5A\x97\xA2\xA9\x80\x27\xB9\xAE\x8E\xA6\x23\x18\x6B\xAA\x58\xAE\x6F\xB9\x20\xE7\x94\x61\x19\x6B\xA0\x5A\xFB\xB6\xB1\xBE\x03\x27\x0F\x5A\xD2\x5E\xBF\xDE\x8B\xA1\x0D\x6B\xBD\xA1\x7B\x80\x07\xBE\x53\x8B\xA3\x0D\x6B\xA5\xA7\x82\x8D\xCC\xB9\xC7\x6D\x0B\xAD\xD8\x5C\x6B\x65\x83\x2A\x99\xDB\x83\x27\x0D\xB1\x40\x8E\x41\x1D\xC0\xC0\x81\x30\x09\x56\x9E\xA2\x20\x89\xE3\xB9\x21\x38\x31\x54\x52\x06\x37\xA4\x5B\xB3\x32\x0F\xB5\xAD\xA3\xC1\x30\xDB\xAB\x42\xF4\x0B\xAD\x9A\x8B\xC0\x92\xD7\x8B\xA2\x1D\x31\x5D\xB4\x81\x26\xB5\xC4\x01\x37\x0D\xAC\x1E\x55\x94\x99\x0D\xCF\xC9\x61\x66\x86\x30\xD2\xC5\x7D\xB5\xBA\x82\x2D\x28\x99\xCB\x26\xCA\xAE\x6C\x99\x0A\x80\x00\x5F\xC1\xCE\x28\xE3\xC8\x22\xF1\x66\xCD\x23\xE4\x67\x95\x9A\xA5\x90", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -2390,13 +2290,13 @@ namespace vl::glr::json L"[23][JArray]< \"[\" { JValue @ ; \",\" } \"]\" >", L"[24][JValue] BEGIN ", L"[25][JValue] END [ENDING]", - L"[26][JValue]<< !JArray @ >>", - L"[27][JValue]<< !JLiteral @ >>", - L"[28][JValue]<< !JObject @ >>", + L"[26][JValue]", + L"[27][JValue]", + L"[28][JValue]", L"[29][JRoot] BEGIN ", L"[30][JRoot] END [ENDING]", - L"[31][JRoot]<< !JArray @ >>", - L"[32][JRoot]<< !JObject @ >>", + L"[31][JRoot]", + L"[32][JRoot]", }; return results[index]; } @@ -2718,15 +2618,14 @@ Initialize traceExecs.Clear(); insExecs.Resize(0); - insExec_Objects.Clear(); + insExec_Stacks.Clear(); insExec_InsRefLinks.Clear(); - insExec_ObjRefLinks.Clear(); - insExec_ObjectStacks.Clear(); - insExec_CreateStacks.Clear(); + insExec_StackRefLinks.Clear(); + insExec_StackArrayRefLinks.Clear(); firstBranchTrace = nullref; firstMergeTrace = nullref; - firstObject = nullref; + firstStack = nullref; firstStep = nullref; traceAmbiguities.Clear(); traceAmbiguityLinks.Clear(); @@ -2735,6 +2634,7 @@ Initialize initialTrace = AllocateTrace(); initialTrace->state = startState; concurrentCount = 1; + concurrentCountBeforeError.Reset(); concurrentTraces->Add(initialTrace); } @@ -2800,6 +2700,12 @@ Input concurrentTraces->Set(traceIndex, nullptr); } + if (concurrentCount == 0) + { + bool ambiguityInvolved = false; + concurrentCountBeforeError = traceCount; + FillSuccessorsAfterEndOfInput(ambiguityInvolved); + } return concurrentCount > 0; } @@ -2812,41 +2718,51 @@ FillSuccessorsAfterEndOfInput ambiguityInvolved = false; List visiting; - // create a merge trace for multiple surviving traces - if (concurrentCount > 1) + if (concurrentCountBeforeError) { - auto newTrace = GetTrace(traces.Allocate()); - for (vint32_t traceIndex = 0; traceIndex < concurrentCount; traceIndex++) + for (vint i = 0; i < concurrentCountBeforeError.Value(); i++) { - auto trace = concurrentTraces->Get(traceIndex); - auto first = trace; - auto last = trace; - - if (trace->state == -1) - { - // a surviving trace could also be a merge trace - // in this case we move predecessors to the new trace - first = GetTrace(trace->predecessors.first); - last = GetTrace(trace->predecessors.last); - } - - if (newTrace->predecessors.first == nullref) - { - newTrace->predecessors.first = first; - newTrace->predecessors.last = last; - } - else - { - GetTrace(newTrace->predecessors.last)->predecessors.siblingNext = first; - first->predecessors.siblingPrev = newTrace->predecessors.last; - newTrace->predecessors.last = last; - } + visiting.Add(backupTraces->Get(i)); } - BeginSwap(); - AddTrace(newTrace); - EndSwap(); } - visiting.Add(concurrentTraces->Get(0)); + else + { + // create a merge trace for multiple surviving traces + if (concurrentCount > 1) + { + auto newTrace = GetTrace(traces.Allocate()); + for (vint32_t traceIndex = 0; traceIndex < concurrentCount; traceIndex++) + { + auto trace = concurrentTraces->Get(traceIndex); + auto first = trace; + auto last = trace; + + if (trace->state == -1) + { + // a surviving trace could also be a merge trace + // in this case we move predecessors to the new trace + first = GetTrace(trace->predecessors.first); + last = GetTrace(trace->predecessors.last); + } + + if (newTrace->predecessors.first == nullref) + { + newTrace->predecessors.first = first; + newTrace->predecessors.last = last; + } + else + { + GetTrace(newTrace->predecessors.last)->predecessors.siblingNext = first; + first->predecessors.siblingPrev = newTrace->predecessors.last; + newTrace->predecessors.last = last; + } + } + BeginSwap(); + AddTrace(newTrace); + EndSwap(); + } + visiting.Add(concurrentTraces->Get(0)); + } // fill successors based on predecessors bool initialTraceVisited = false; @@ -2929,7 +2845,12 @@ EndOfInput } EndSwap(); - if (concurrentCount == 0) return false; + if (concurrentCount == 0) + { + concurrentCountBeforeError = traceCount; + FillSuccessorsAfterEndOfInput(ambiguityInvolved); + return false; + } FillSuccessorsAfterEndOfInput(ambiguityInvolved); if (!ambiguityInvolved) @@ -2945,7 +2866,7 @@ EndOfInput step->et_i.startTrace = initialTrace->allocatedIndex; step->et_i.startIns = 0; step->et_i.endTrace = lastTrace->allocatedIndex; - step->et_i.endIns = insList.c3 - 1; + step->et_i.endIns = insList.countAll - 1; } return initialTrace; } @@ -3272,11 +3193,10 @@ AttendCompetition Ref& newCarriedCompetitions, Ref returnStack, vint32_t ruleId, - vint32_t clauseId, - bool forHighPriority + CompetitionDesc comp ) { - // a competition is defined by its rule, clause and the owner trace + // a competition is defined by its rule, competition id and the owner trace // but we don't need to compare the trace // since only transitions starting from that trace will search competitions in that trace // we only create a new Competition object if it has not been created for the trace yet @@ -3286,7 +3206,7 @@ AttendCompetition while (cid != nullref) { auto cpt = GetCompetition(cid); - if (cpt->ruleId == ruleId && cpt->clauseId == clauseId) + if (cpt->ruleId == ruleId && cpt->competitionId == comp.competitionId) { competition = cpt; break; @@ -3304,7 +3224,7 @@ AttendCompetition competition->currentTokenIndex = trace->currentTokenIndex; competition->ruleId = ruleId; - competition->clauseId = clauseId; + competition->competitionId = comp.competitionId; competition->nextActiveCompetition = activeCompetitions; activeCompetitions = competition; @@ -3319,7 +3239,7 @@ AttendCompetition auto ac = AllocateAttendingCompetitions(); ac->competition = competition; - ac->forHighPriority = forHighPriority; + ac->forHighPriority = comp.highPriority; ac->returnStack = returnStack; ac->nextActiveAC = newAttendingCompetitions; @@ -3359,18 +3279,19 @@ AttendCompetitionIfNecessary auto returnIndex = executable.returnIndices[edgeDesc.returnIndices.start + returnRef]; auto&& returnDesc = executable.returns[returnIndex]; - if (returnDesc.priority != EdgePriority::NoCompetition) + for (vint compRef = 0; compRef < returnDesc.competitions.count; compRef++) { + auto&& comp = executable.competitions[returnDesc.competitions.start + compRef]; // attend a competition from a ReturnDesc edge - // find out the rule id and the clause id for this competition + // find out the rule id and the competition id for this competition // a ReturnDesc is a compact transition which consumes a rule // so it does not points to the ending state // therefore we just need the toState of this ReturnDesc for reference - auto&& stateForClause = executable.states[returnDesc.returnState]; - vint32_t competitionRule = stateForClause.rule; - vint32_t competitionClause = stateForClause.clause; - CHECK_ERROR(competitionRule != -1 && competitionClause != -1, ERROR_MESSAGE_PREFIX L"Illegal rule or clause id."); - AttendCompetition(trace, newAttendingCompetitions, newCarriedCompetitions, newReturnStack, competitionRule, competitionClause, returnDesc.priority == EdgePriority::HighPriority); + auto&& returnState = executable.states[returnDesc.returnState]; + vint32_t competitionRule = returnState.rule; + CHECK_ERROR(competitionRule != -1, ERROR_MESSAGE_PREFIX L"Illegal rule id."); + CHECK_ERROR(comp.competitionId != -1, ERROR_MESSAGE_PREFIX L"Illegal competition id."); + AttendCompetition(trace, newAttendingCompetitions, newCarriedCompetitions, newReturnStack, competitionRule, comp); } // push this ReturnDesc to the ReturnStack @@ -3383,21 +3304,20 @@ AttendCompetitionIfNecessary edgeFromState = executable.ruleStartStates[returnDesc.consumedRule]; } - if (edgeDesc.priority != EdgePriority::NoCompetition) + for (vint compRef = 0; compRef < edgeDesc.competitions.count; compRef++) { - // attend a competition from a EdgeDesc edge - // find out the rule id and the clause id for this competition + auto&& comp = executable.competitions[edgeDesc.competitions.start + compRef]; + // attend a competition from a ReturnDesc edge + // find out the rule id and the competition id for this competition + // a ReturnDesc is a compact transition which consumes a rule + // so it does not points to the ending state + // therefore we just need the toState of this ReturnDesc for reference auto&& fromState = executable.states[edgeFromState]; auto&& toState = executable.states[edgeDesc.toState]; - vint32_t competitionRule = toState.rule; - vint32_t competitionClause = toState.clause; - if (toState.endingState) - { - competitionRule = fromState.rule; - competitionClause = fromState.clause; - } - CHECK_ERROR(competitionRule != -1 && competitionClause != -1, ERROR_MESSAGE_PREFIX L"Illegal rule or clause id."); - AttendCompetition(trace, newAttendingCompetitions, newCarriedCompetitions, newReturnStack, competitionRule, competitionClause, edgeDesc.priority == EdgePriority::HighPriority); + vint32_t competitionRule = toState.endingState ? fromState.rule : toState.rule; + CHECK_ERROR(competitionRule != -1, ERROR_MESSAGE_PREFIX L"Illegal rule id."); + CHECK_ERROR(comp.competitionId != -1, ERROR_MESSAGE_PREFIX L"Illegal competition id."); + AttendCompetition(trace, newAttendingCompetitions, newCarriedCompetitions, newReturnStack, competitionRule, comp); } #undef ERROR_MESSAGE_PREFIX } @@ -3416,8 +3336,8 @@ CheckAttendingCompetitionsOnEndingEdge while (acId != nullref) { // when executing an EndingInput transition, we announce high priority win a competition if - // 1) such EndingInput transitions ends the clause, and the state of the trace holding competition belongs to the same clause - // we ensure this by comparing rule id, clause id in Competition + // 1) such EndingInput transitions ends the rule, and the state of the trace holding competition belongs to the same rule + // we ensure this by comparing rule id in Competition // and compare ReturnStack object (not content) in AttendingCompetitions // the reason returnStack is not in Competition is that // different transitions always create new ReturnStack objects @@ -3427,9 +3347,9 @@ CheckAttendingCompetitionsOnEndingEdge if (ac->returnStack == returnStack) { auto cpt = GetCompetition(ac->competition); - // ensure that this EndingInput edge and the competition belong to the same clause + // ensure that this EndingInput edge and the competition belong to the same rule auto&& stateDesc = executable.states[edgeDesc.fromState]; - if (cpt->ruleId == stateDesc.rule && cpt->clauseId == stateDesc.clause) + if (cpt->ruleId == stateDesc.rule) { // check if it is a high bet if (ac->forHighPriority && cpt->status == CompetitionStatus::Holding) @@ -3605,6 +3525,7 @@ GetCurrentSuccessorInReturnStack ReturnStackSuccessors* TraceManager::GetCurrentSuccessorInReturnStack(Ref base, vint32_t currentTokenIndex) { +#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::GetCurrentSuccessorInReturnStack(vint32_t, vint32_t)#" auto& cache = base == nullref ? initialReturnStackCache : GetReturnStack(base)->cache; if (cache.successors.tokenIndex == currentTokenIndex) { @@ -3615,11 +3536,12 @@ GetCurrentSuccessorInReturnStack return &cache.lastSuccessors; } - CHECK_ERROR(currentTokenIndex > cache.successors.tokenIndex, L"vl::glr::automaton::TraceManager::GetCurrentSuccessorInReturnStack(vint32_t, vint32_t)#ReturnStackSuccessors::tokenIndex corrupted."); + CHECK_ERROR(currentTokenIndex > cache.successors.tokenIndex, ERROR_MESSAGE_PREFIX L"ReturnStackSuccessors::tokenIndex corrupted."); cache.lastSuccessors = cache.successors; cache.successors = {}; cache.successors.tokenIndex = currentTokenIndex; return &cache.successors; +#undef ERROR_MESSAGE_PREFIX } /*********************************************************************** @@ -3710,6 +3632,34 @@ TraceManager::IsQualifiedTokenForEdgeArray return false; } +/*********************************************************************** +TraceManager::TestLeftrecEdgeQualification +***********************************************************************/ + + void TraceManager::TestLeftrecEdgeQualification(EdgeDesc& edgeDesc, regex::RegexToken* lookAhead, bool& acceptLookAhead, bool& acceptEndingInput) + { + if (lookAhead) + { + vint32_t lookAheadTransitionIndex = executable.GetTransitionIndex(edgeDesc.toState, Executable::TokenBegin + (vint32_t)lookAhead->token); + auto& lookAheadEdgeArray = executable.transitions[lookAheadTransitionIndex]; + + // mark this EndingInput if any LeftrecInput + lookAhead transition exists + if (IsQualifiedTokenForEdgeArray(lookAhead, lookAheadEdgeArray)) + { + acceptLookAhead = true; + } + } + + { + vint32_t endingInputTransitionIndex = executable.GetTransitionIndex(edgeDesc.toState, Executable::EndingInput); + auto& endingInputEdgeArray = executable.transitions[endingInputTransitionIndex]; + if (endingInputEdgeArray.count > 0) + { + acceptEndingInput = true; + } + } + } + /*********************************************************************** TraceManager::WalkAlongSingleEdge ***********************************************************************/ @@ -3802,25 +3752,31 @@ TraceManager::WalkAlongEpsilonEdges EdgeArray& edgeArray ) { - // if there is no more token - // then it is not possible for more left recursions - if (!lookAhead) return; - for (vint32_t edgeRef = 0; edgeRef < edgeArray.count; edgeRef++) { vint32_t byEdge = edgeArray.start + edgeRef; auto& edgeDesc = executable.edges[byEdge]; // see if the target state could consume that token - vint32_t lookAheadTransitionIndex = executable.GetTransitionIndex(edgeDesc.toState, Executable::TokenBegin + (vint32_t)lookAhead->token); - auto& lookAheadEdgeArray = executable.transitions[lookAheadTransitionIndex]; - if (!IsQualifiedTokenForEdgeArray(lookAhead, lookAheadEdgeArray)) continue; + bool acceptLookAhead = false; + bool acceptEndingInput = false; + TestLeftrecEdgeQualification(edgeDesc, lookAhead, acceptLookAhead, acceptEndingInput); - // proceed only if it can - WalkAlongSingleEdge(currentTokenIndex, Executable::LeftrecInput, trace, byEdge, edgeDesc); + if (acceptLookAhead || acceptEndingInput) + { + // proceed only if it can + auto nextTrace = WalkAlongSingleEdge(currentTokenIndex, Executable::LeftrecInput, trace, byEdge, edgeDesc); - // A LeftrecInput transition points to a non ending state in another clause - // so there is no need to find other epsilon transitions after LeftrecInput + if (acceptEndingInput && nextTrace) + { + // A LeftrecInput will be generated because of + // A real left-recursive rule + // Merging prefix inside a rule + // Merging prefix crossed-reference + // The last two cases could connect LeftrecInput transitions to an ending state + WalkAlongEpsilonEdges(currentTokenIndex, lookAhead, nextTrace); + } + } } } @@ -3836,64 +3792,21 @@ TraceManager::WalkAlongEpsilonEdges // so we count how many EndingInput transition we could walk along first vint32_t endingCount = -1; - - if (!lookAhead) { // if there is no more tokens // then we have to go all the way to the end anyway - vint32_t currentState = trace.stateTrace->state; - auto currentReturnStack = trace.stateTrace->returnStack; - - while (currentState != -1) - { - vint32_t transitionIndex = executable.GetTransitionIndex(currentState, Executable::EndingInput); - auto&& edgeArray = executable.transitions[transitionIndex]; - - // at most one EndingInput transition could exist from any state - CHECK_ERROR(edgeArray.count < 2, L"vl::glr::automaton::TraceManager::WalkAlongEpsilonEdges(vint32_t, vint32_t, Trace*)#Too many EndingInput transitions."); - - if (edgeArray.count == 0) - { - // if there is no more EndingInput to go - // and the current state is not an ending state - // then we just give up - - auto&& stateDesc = executable.states[currentState]; - if (stateDesc.endingState) - { - currentState = -1; - } - else - { - return; - } - } - else if (currentReturnStack == nullref) - { - vint32_t byEdge = edgeArray.start; - auto& edgeDesc = executable.edges[byEdge]; - currentState = edgeDesc.toState; - } - else - { - auto rs = GetReturnStack(currentReturnStack); - currentReturnStack = rs->previous; - currentState = executable.returns[rs->returnIndex].returnState; - } - } - } - else - { // otherwise we see how many EndingInput transition we need to walk along vint32_t currentCount = 0; vint32_t currentState = trace.stateTrace->state; auto currentReturnStack = trace.stateTrace->returnStack; +#define MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL endingCount = currentCount + while (currentState != -1) { currentCount++; - // try LeftrecInput + lookAhead + // try LeftrecInput + (lookAhead or EndingInput) { vint32_t transitionIndex = executable.GetTransitionIndex(currentState, Executable::LeftrecInput); auto&& edgeArray = executable.transitions[transitionIndex]; @@ -3901,19 +3814,22 @@ TraceManager::WalkAlongEpsilonEdges { vint32_t byEdge = edgeArray.start + edgeRef; auto& edgeDesc = executable.edges[byEdge]; - vint32_t lookAheadTransitionIndex = executable.GetTransitionIndex(edgeDesc.toState, Executable::TokenBegin + (vint32_t)lookAhead->token); - auto& lookAheadEdgeArray = executable.transitions[lookAheadTransitionIndex]; - // mark this EndingInput if any LeftrecInput + lookAhead transition exists - if (IsQualifiedTokenForEdgeArray(lookAhead, lookAheadEdgeArray)) + bool acceptLookAhead = false; + bool acceptEndingInput = false; + TestLeftrecEdgeQualification(edgeDesc, lookAhead, acceptLookAhead, acceptEndingInput); + + // mark this EndingInput if any LeftrecInput + (lookAhead or EndingInput) transition exists + if (acceptLookAhead || acceptEndingInput) { - endingCount = currentCount; + MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL; goto TRY_ENDING_INPUT; } } } // try lookAhead + if (lookAhead) { vint32_t transitionIndex = executable.GetTransitionIndex(currentState, Executable::TokenBegin + (vint32_t)lookAhead->token); auto&& edgeArray = executable.transitions[transitionIndex]; @@ -3921,7 +3837,7 @@ TraceManager::WalkAlongEpsilonEdges // mark this EndingInput if lookAhead transition exists if (IsQualifiedTokenForEdgeArray(lookAhead, edgeArray)) { - endingCount = currentCount; + MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL; } } @@ -3931,27 +3847,59 @@ TraceManager::WalkAlongEpsilonEdges vint32_t transitionIndex = executable.GetTransitionIndex(currentState, Executable::EndingInput); auto&& edgeArray = executable.transitions[transitionIndex]; - // at most one EndingInput transition could exist from any state - CHECK_ERROR(edgeArray.count < 2, L"vl::glr::automaton::TraceManager::WalkAlongEpsilonEdges(vint32_t, vint32_t, Trace*)#Too many EndingInput transitions."); - - if (edgeArray.count == 0 || currentReturnStack == nullref) + if (edgeArray.count > 1) { - // currentReturnStack == -1 means this is the last possible EndingInput - // no need to test forward - // because if the current EndingInput is doable - // it would have already been marked - currentState = -1; + // if there are multiple EndingInput transitions + // assume they would all succeed, and do recursive calls later + MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL; + break; } - else + else if (edgeArray.count == 1 && currentReturnStack != nullref) { auto rs = GetReturnStack(currentReturnStack); currentReturnStack = rs->previous; currentState = executable.returns[rs->returnIndex].returnState; } + else if (lookAhead) + { + // lookAhead && (edgeArray.count == 0 || currentReturnStack == nullref) + // if edgeArray.count == 0 + // no further EndingInput transition could be walked + // if currentReturnStack == nullref + // it means this is the last possible EndingInput + // no need to test forward + // because if the current EndingInput is doable + // it would have already been marked + break; + } + else if (edgeArray.count == 0) + { + // !lookAhead && edgeArray.count == 0 + // if there is no more EndingInput to go + // and the current state is not an ending state + // then we just give up + // it is possible that a LeftrecInput transition is available + + auto&& stateDesc = executable.states[currentState]; + if (stateDesc.endingState) + { + MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL; + } + break; + } + else + { + // !lookAhead && edgeArray.count == 1 && currentReturnStack == nullref + vint32_t byEdge = edgeArray.start; + auto& edgeDesc = executable.edges[byEdge]; + currentState = edgeDesc.toState; + } } } } +#undef MARK_AT_LEAST_EXECUTE_TO_THIS_LEVEL + for (vint32_t i = 0; trace && (i < endingCount || endingCount == -1); i++) { { @@ -3972,9 +3920,33 @@ TraceManager::WalkAlongEpsilonEdges } else { - vint32_t byEdge = edgeArray.start; - auto& edgeDesc = executable.edges[byEdge]; - trace = WalkAlongSingleEdge(currentTokenIndex, Executable::EndingInput, trace, byEdge, edgeDesc); + for (vint32_t edgeRef = 0; edgeRef < edgeArray.count; edgeRef++) + { + vint32_t byEdge = edgeArray.start + edgeRef; + auto& edgeDesc = executable.edges[byEdge]; + auto nextTrace = WalkAlongSingleEdge(currentTokenIndex, Executable::EndingInput, trace, byEdge, edgeDesc); + + if (edgeArray.count > 1) + { + // if the current trace has multiple EndingInput + // we don't know if the current trace will survive or not + // a following recursive call is necessary + if (nextTrace) + { + WalkAlongEpsilonEdges(currentTokenIndex, lookAhead, nextTrace); + } + } + else + { + trace = nextTrace; + } + } + + if (edgeArray.count > 1) + { + // when this for-loop ends, the outer for-loop also ends + trace = { nullptr,nullptr }; + } // EndingInput could be followed by EndingInput or LeftrecInput } @@ -4000,7 +3972,7 @@ TraceManager::WalkAlongTokenEdges for (vint32_t edgeRef = 0; edgeRef < edgeArray.count; edgeRef++) { vint32_t byEdge = edgeArray.start + edgeRef; - auto& edgeDesc = executable.edges[edgeArray.start + edgeRef]; + auto& edgeDesc = executable.edges[byEdge]; if (IsQualifiedTokenForCondition(token, edgeDesc.condition)) { if (auto newTrace = WalkAlongSingleEdge(currentTokenIndex, input, trace, byEdge, edgeDesc)) @@ -4020,58 +3992,12 @@ TraceManager::WalkAlongTokenEdges .\TRACEMANAGER\TMPTR.CPP ***********************************************************************/ -#if defined VCZH_MSVC && defined _DEBUG -#define VCZH_DO_DEBUG_CHECK -#endif - namespace vl { namespace glr { namespace automaton { -/*********************************************************************** -DebugCheckTraceExecData -***********************************************************************/ - -#ifdef VCZH_DO_DEBUG_CHECK - void TraceManager::DebugCheckTraceExecData() - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::DebugCheckTraceExecData()#" - IterateSurvivedTraces( - [this](Trace* trace, Trace* predecessor, vint32_t visitCount, vint32_t predecessorCount) - { - if (predecessorCount <= 1) - { - auto traceExec = GetTraceExec(trace->traceExecRef); - for (vint32_t insRef = 0; insRef < traceExec->insExecRefs.count; insRef++) - { - auto&& ins = ReadInstruction(insRef, traceExec->insLists); - auto insExec = GetInsExec(traceExec->insExecRefs.start + insRef); - - // ensure BO/DFA are closed - switch (ins.type) - { - case AstInsType::BeginObject: - case AstInsType::DelayFieldAssignment: - CHECK_ERROR(insExec->eoInsRefs != nullref, ERROR_MESSAGE_PREFIX L"Internal error: BO/BOLA/DFA not closed."); - break; - } - - // ensure DFA are associated with objects closed - switch (ins.type) - { - case AstInsType::DelayFieldAssignment: - CHECK_ERROR(insExec->objRefs != nullref, ERROR_MESSAGE_PREFIX L"Internal error: DFA not associated."); - break; - } - } - } - } - ); -#undef ERROR_MESSAGE_PREFIX - } -#endif /*********************************************************************** PrepareTraceRoute @@ -4085,18 +4011,12 @@ PrepareTraceRoute AllocateExecutionData(); BuildAmbiguityStructures(); PartialExecuteTraces(); -#ifdef VCZH_DO_DEBUG_CHECK - DebugCheckTraceExecData(); -#endif + SummarizeInstructionRange(); } } } } -#if defined VCZH_MSVC && defined _DEBUG -#undef VCZH_DO_DEBUG_CHECK -#endif - /*********************************************************************** .\TRACEMANAGER\TMPTR_ALLOCATEEXECUTIONDATA.CPP ***********************************************************************/ @@ -4113,7 +4033,7 @@ AllocateExecutionData void TraceManager::AllocateExecutionData() { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::AllocateExecutionData()#" +#define TRACE_MAMAGER_PHRASE L"PrepareTraceRoute/AllocateExecutionData" vint32_t insExecCount = 0; auto nextBranchTrace = &firstBranchTrace; auto nextMergeTrace = &firstMergeTrace; @@ -4122,17 +4042,20 @@ AllocateExecutionData // ensure traceExecRef reflects the partial order of the execution order of traces if (predecessorCount > 1 && visitCount != predecessorCount) return; - CHECK_ERROR(trace->traceExecRef == nullref, ERROR_MESSAGE_PREFIX L"Internal error: IterateSurvivedTraces unexpectedly revisit a trace."); + if (trace->traceExecRef != nullref) + { + throw TraceException(*this, trace, nullptr, TRACE_MAMAGER_PHRASE, L"IterateSurvivedTraces unexpectedly revisit a trace."); + } trace->traceExecRef = traceExecs.Allocate(); auto traceExec = GetTraceExec(trace->traceExecRef); traceExec->traceId = trace; ReadInstructionList(trace, traceExec->insLists); - if (traceExec->insLists.c3 > 0) + if (traceExec->insLists.countAll > 0) { traceExec->insExecRefs.start = insExecCount; - traceExec->insExecRefs.count = traceExec->insLists.c3; - insExecCount += traceExec->insLists.c3; + traceExec->insExecRefs.count = traceExec->insLists.countAll; + insExecCount += traceExec->insLists.countAll; } // fill branch trace linked list @@ -4150,7 +4073,7 @@ AllocateExecutionData } }); insExecs.Resize(insExecCount); -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } } } @@ -4201,7 +4124,7 @@ BuildAmbiguityStructures void TraceManager::BuildAmbiguityStructures() { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::BuildAmbiguityStructures()#" +#define TRACE_MAMAGER_PHRASE L"PrepareTraceRoute/BuildAmbiguityStructures" IterateSurvivedTraces( [this](Trace* trace, Trace* predecessor, vint32_t visitCount, vint32_t predecessorCount) { @@ -4226,7 +4149,10 @@ BuildAmbiguityStructures } else { - CHECK_ERROR(predecessor->state != -1, ERROR_MESSAGE_PREFIX L"Predecessor trace of a merge trace cannot be a merge trace."); + if (predecessor->state == -1) + { + throw TraceException(*this, trace, predecessor, TRACE_MAMAGER_PHRASE, L"Predecessor trace of a merge trace cannot be a merge trace."); + } if (visitCount == 1) { @@ -4258,13 +4184,16 @@ BuildAmbiguityStructures } currentTrace = StepForward(currentTrace); } - CHECK_ERROR(currentTrace != nullptr, ERROR_MESSAGE_PREFIX L"Cannot determine commonForwardBranch of a merge trace."); + if (currentTrace == nullptr) + { + throw TraceException(*this, currentTrace, nullptr, TRACE_MAMAGER_PHRASE, L"Cannot determine commonForwardBranch of a merge trace."); + } traceExec->branchData.commonForwardBranch = currentTrace; } } } ); -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } #undef NEW_MERGE_STACK_MAGIC_COUNTER @@ -4310,299 +4239,12 @@ PartialExecuteTraces } } ); - - CalculateObjectFirstInstruction(); - CalculateObjectLastInstruction(); #undef ERROR_MESSAGE_PREFIX } } } } -/*********************************************************************** -.\TRACEMANAGER\TMPTR_PARTIALEXECUTETRACES_CALCULATEOBJECTFIRSTINSTRUCTION.CPP -***********************************************************************/ - -#if defined VCZH_MSVC && defined _DEBUG -#define VCZH_DO_DEBUG_CHECK -#endif - -namespace vl -{ - namespace glr - { - namespace automaton - { - using namespace collections; - -#define NEW_MERGE_STACK_MAGIC_COUNTER (void)(MergeStack_MagicCounter++) - -/*********************************************************************** -CalculateObjectFirstInstruction -***********************************************************************/ - - bool TraceManager::UpdateTopTrace(InsRef& topInsRef, InsRef newInsRef) - { - if ( - topInsRef.trace == nullref || - topInsRef.trace > newInsRef.trace || - (topInsRef.trace == newInsRef.trace && topInsRef.ins > newInsRef.ins) - ) - { - topInsRef = newInsRef; - return true; - } - else - { - return false; - } - } - - void TraceManager::InjectFirstInstruction(InsRef insRef, Ref injectTargets, vuint64_t magicInjection) - { - auto objLinkRef = injectTargets; - while (objLinkRef != nullref) - { - auto objLink = GetInsExec_ObjRefLink(objLinkRef); - objLinkRef = objLink->previous; - auto ieObject = GetInsExec_Object(objLink->id); - - if (ieObject->mergeCounter == magicInjection) continue; - ieObject->mergeCounter = magicInjection; - - // there will be only one top create instruction per object - // even when object relationship is partial ordered - // TODO: prove it - if (UpdateTopTrace(ieObject->topInsRef, insRef)) - { - InjectFirstInstruction(insRef, ieObject->assignedToObjectIds, magicInjection); - } - } - } - - void TraceManager::CalculateObjectFirstInstruction() - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::CalculateObjectFirstInstruction()#" - // check all individual objects - { - auto objRef = firstObject; - while (objRef != nullref) - { - auto ieObject = GetInsExec_Object(objRef); - objRef = ieObject->previous; - - // set the top local trace to its create trace - UpdateTopTrace(ieObject->topLocalInsRef, ieObject->createInsRef); - - // check all DFA instructions - auto insRefLinkId = ieObject->dfaInsRefs; - while (insRefLinkId != nullref) - { - auto insRefLink = GetInsExec_InsRefLink(insRefLinkId); - insRefLinkId = insRefLink->previous; - - // there will be only one top local create instruction per object - // even when object relationship is partial ordered - // TODO: prove it - UpdateTopTrace(ieObject->topLocalInsRef, insRefLink->insRef); - } - - // set the top trace to its top local trace - UpdateTopTrace(ieObject->topInsRef, ieObject->topLocalInsRef); - } - } - - // check all assigned to targets - { - auto objRef = firstObject; - while (objRef != nullref) - { - auto ieObject = GetInsExec_Object(objRef); - objRef = ieObject->previous; - - NEW_MERGE_STACK_MAGIC_COUNTER; - auto magicInjection = MergeStack_MagicCounter; - ieObject->mergeCounter = magicInjection; - InjectFirstInstruction(ieObject->topInsRef, ieObject->assignedToObjectIds, magicInjection); - -#ifdef VCZH_DO_DEBUG_CHECK - { - auto createTrace = GetTrace(ieObject->topInsRef.trace); - auto traceExec = GetTraceExec(createTrace->traceExecRef); - auto&& ins = ReadInstruction(ieObject->topInsRef.ins, traceExec->insLists); - CHECK_ERROR(ins.type == AstInsType::BeginObject || ins.type == AstInsType::DelayFieldAssignment, ERROR_MESSAGE_PREFIX L"The found instruction is not a BeginObject or DelayFieldAssignment instruction."); - } -#endif - } - } -#undef ERROR_MESSAGE_PREFIX - } - -#undef NEW_MERGE_STACK_MAGIC_COUNTER - } - } -} - -/*********************************************************************** -.\TRACEMANAGER\TMPTR_PARTIALEXECUTETRACES_CALCULATEOBJECTLASTINSTRUCTION.CPP -***********************************************************************/ - -#if defined VCZH_MSVC && defined _DEBUG -#define VCZH_DO_DEBUG_CHECK -#endif - -namespace vl -{ - namespace glr - { - namespace automaton - { - using namespace collections; - -#define NEW_MERGE_STACK_MAGIC_COUNTER (void)(MergeStack_MagicCounter++) - -/*********************************************************************** -CalculateObjectLastInstruction -***********************************************************************/ - - bool TraceManager::IsInTheSameBranch(Trace* forward, Trace* targetForwardAtFront) - { - while (true) - { - // if two forwards are the same - if (forward == targetForwardAtFront) - { - // then they are in the same branch - return true; - } - else if (forward->traceExecRef > targetForwardAtFront->traceExecRef) - { - // otherwise - auto forwardExec = GetTraceExec(forward->traceExecRef); - if (forwardExec->branchData.commonForwardBranch != nullref) - { - // if commonForwardBranch exists, this is a merge trace - auto commonForward = GetTrace(forwardExec->branchData.commonForwardBranch); - if (commonForward->traceExecRef < targetForwardAtFront->traceExecRef) - { - // is the merge trace is in front of the targetForwardAtFront - // check each branch - auto predecessorId = forward->predecessors.first; - while (predecessorId != nullref) - { - auto predecessor = GetTrace(predecessorId); - predecessorId = predecessor->predecessors.siblingNext; - - auto predecessorExec = GetTraceExec(predecessor->traceExecRef); - if (IsInTheSameBranch(GetTrace(predecessorExec->branchData.forwardTrace), targetForwardAtFront)) - { - return true; - } - } - - // targetForwardAtFront could be among them, but could not be in front of them - return false; - } - } - - // if commonForwardBranch doesn't contribute, look forward again - auto nextForward = GetTrace(forwardExec->branchData.forwardTrace); - if (nextForward == forward) - { - if (forward->predecessors.first == nullptr) - { - break; - } - else - { - forward = GetTrace(GetTraceExec(GetTrace(forward->predecessors.first)->traceExecRef)->branchData.forwardTrace); - } - } - else - { - forward = nextForward; - } - } - else - { - break; - } - } - return false; - } - - void TraceManager::CalculateObjectLastInstruction() - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::CalculateObjectLastInstruction()#" - // check all individual objects - { - auto objRef = firstObject; - while (objRef != nullref) - { - auto ieObject = GetInsExec_Object(objRef); - objRef = ieObject->previous; - - // all EndObject ending a BO/DFA are considered - // there is no "bottom EndObject" - // each EndObject should be in different branches - auto topLocalTrace = GetTrace(ieObject->topLocalInsRef.trace); - auto topLocalTraceExec = GetTraceExec(topLocalTrace->traceExecRef); - auto insExec = GetInsExec(topLocalTraceExec->insExecRefs.start + ieObject->topLocalInsRef.ins); - auto insRefLinkId = insExec->eoInsRefs; - - // get the branch where BO stays - auto createTrace = GetTrace(ieObject->createInsRef.trace); - auto createTraceExec = GetTraceExec(createTrace->traceExecRef); - auto createTraceForward = GetTrace(createTraceExec->branchData.forwardTrace); - - NEW_MERGE_STACK_MAGIC_COUNTER; - auto magicInsRef = MergeStack_MagicCounter; - - while (insRefLinkId != nullref) - { - auto insRefLink = GetInsExec_InsRefLink(insRefLinkId); - insRefLinkId = insRefLink->previous; - - auto bottomInsRef = insRefLink->insRef; - auto bottomTrace = GetTrace(bottomInsRef.trace); - auto bottomTraceExec = GetTraceExec(bottomTrace->traceExecRef); - auto bottomInsExec = GetInsExec(bottomTraceExec->insExecRefs.start + bottomInsRef.ins); - if (bottomInsExec->mergeCounter != magicInsRef) - { - bottomInsExec->mergeCounter = magicInsRef; - - // filter out any result that does not happen after ieObject->createTrace - // topLocalTrace could be a DFA created object, and multiple objects could share the same DFA object - // in some cases its eoInsRefs could pointing to EndObject of completely unrelated objects - // TODO: make it accurate - - if (IsInTheSameBranch(GetTrace(bottomTraceExec->branchData.forwardTrace), createTraceForward)) - { - PushInsRefLink(ieObject->bottomInsRefs, bottomInsRef); - } - } - -#ifdef VCZH_DO_DEBUG_CHECK - { - auto eoTrace = GetTrace(bottomInsRef.trace); - auto traceExec = GetTraceExec(eoTrace->traceExecRef); - auto&& ins = ReadInstruction(bottomInsRef.ins, traceExec->insLists); - CHECK_ERROR(ins.type == AstInsType::EndObject, ERROR_MESSAGE_PREFIX L"The found instruction is not a EndObject instruction."); - } -#endif - } - - CHECK_ERROR(ieObject->bottomInsRefs != nullref, ERROR_MESSAGE_PREFIX L"Cannot found bottom instructions for an object."); - } - } -#undef ERROR_MESSAGE_PREFIX - } - -#undef NEW_MERGE_STACK_MAGIC_COUNTER - } - } -} - /*********************************************************************** .\TRACEMANAGER\TMPTR_PARTIALEXECUTETRACES_ENSUREINSEXECCONTEXTCOMPATIBLE.CPP ***********************************************************************/ @@ -4619,43 +4261,48 @@ EnsureInsExecContextCompatible void TraceManager::EnsureInsExecContextCompatible(Trace* baselineTrace, Trace* commingTrace) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::EnsureInsExecContextCompatible(Trace*, Trace*)#" +#define TRACE_MAMAGER_PHRASE L"PrepareTraceRoute/EnsureInsExecContextCompatible" auto&& contextComming = GetTraceExec(baselineTrace->traceExecRef)->context; auto&& contextBaseline = GetTraceExec(commingTrace->traceExecRef)->context; - auto error = []() - { - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Execution results of traces to merge are different."); - }; - - // check if the two lriStored be both empty or non-empty - if ((contextBaseline.lriStoredObjects == nullref) != (contextComming.lriStoredObjects == nullref)) error(); // check if the two objectStack have the same depth - if ((contextBaseline.objectStack == nullref) != (contextComming.objectStack == nullref)) error(); + if ((contextBaseline.objectStack == nullref) != (contextComming.objectStack == nullref)) + { + throw TraceException(*this, baselineTrace, commingTrace, TRACE_MAMAGER_PHRASE, L"Execution results of traces to merge do not have the same depth of objectStack."); + } if (contextBaseline.objectStack != nullref) { - auto stackBaseline = GetInsExec_ObjectStack(contextBaseline.objectStack); - auto stackComming = GetInsExec_ObjectStack(contextComming.objectStack); - if (stackBaseline->pushedCount != stackComming->pushedCount) error(); + auto objectStackBaseline = GetInsExec_StackArrayRefLink(contextBaseline.objectStack); + auto objectStackComming = GetInsExec_StackArrayRefLink(contextComming.objectStack); + if (objectStackBaseline->currentDepth != objectStackComming->currentDepth) + { + throw TraceException(*this, baselineTrace, commingTrace, TRACE_MAMAGER_PHRASE, L"Execution results of traces to merge do not have the same depth of objectStack."); + } } // check if the two createStack have the same depth // check each corresponding createStack have the same stackBase - auto stack1 = contextBaseline.createStack; - auto stack2 = contextComming.createStack; - while (stack1 != stack2) + auto stackBaseline = contextBaseline.createStack; + auto stackComming = contextComming.createStack; + while (stackBaseline != stackComming) { - if (stack1 == nullref || stack2 == nullref) error(); + if (stackBaseline == nullref || stackComming == nullref) + { + throw TraceException(*this, baselineTrace, commingTrace, TRACE_MAMAGER_PHRASE, L"Execution results of traces to merge do not have the same depth of createStack."); + } - auto stackObj1 = GetInsExec_CreateStack(stack1); - auto stackObj2 = GetInsExec_CreateStack(stack2); + auto stackObjBaseline = GetInsExec_StackArrayRefLink(stackBaseline); + auto stackObjComming = GetInsExec_StackArrayRefLink(stackComming); - if (stackObj1->stackBase != stackObj2->stackBase) error(); + if (stackObjBaseline->objectStackDepthForCreateStack != stackObjComming->objectStackDepthForCreateStack) + { + throw TraceException(*this, baselineTrace, commingTrace, TRACE_MAMAGER_PHRASE, L"Execution results of traces to merge do not have the same depth of objectStack between one slice of both createStack."); + } - stack1 = stackObj1->previous; - stack2 = stackObj2->previous; + stackBaseline = stackObjBaseline->previous; + stackComming = stackObjComming->previous; } -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } } } @@ -4679,44 +4326,10 @@ namespace vl MergeInsExecContext ***********************************************************************/ - void TraceManager::PushInsRefLinkWithCounter(Ref& link, Ref comming) + template (InsExec_Context::* stack), typename TMerge> + Ref TraceManager::MergeStack(Trace* mergeTrace, TMerge&& merge) { - auto magicPush = MergeStack_MagicCounter; - while (comming != nullref) - { - auto commingStack = GetInsExec_InsRefLink(comming); - comming = commingStack->previous; - - auto insTrace = GetTrace(commingStack->insRef.trace); - auto insTraceExec = GetTraceExec(insTrace->traceExecRef); - auto insExec = GetInsExec(insTraceExec->insExecRefs.start + commingStack->insRef.ins); - if (insExec->mergeCounter == magicPush) continue; - - insExec->mergeCounter = magicPush; - PushInsRefLink(link, commingStack->insRef); - } - } - - void TraceManager::PushObjRefLinkWithCounter(Ref& link, Ref comming) - { - auto magicPush = MergeStack_MagicCounter; - while (comming != nullref) - { - auto commingStack = GetInsExec_ObjRefLink(comming); - comming = commingStack->previous; - - auto ieObject = GetInsExec_Object(commingStack->id); - if (ieObject->mergeCounter == magicPush) continue; - - ieObject->mergeCounter = magicPush; - PushObjRefLink(link, ieObject); - } - } - - template), Ref (InsExec_Context::* stack), typename TMerge> - Ref TraceManager::MergeStack(Trace* mergeTrace, AllocateOnly& allocator, TMerge&& merge) - { - Array stacks(mergeTrace->predecessorCount); + Array stacks(mergeTrace->predecessorCount); // fill the first level of stacks objects { @@ -4728,13 +4341,13 @@ MergeInsExecContext auto traceExec = GetTraceExec(predecessor->traceExecRef); auto stackId = traceExec->context.*stack; - stacks[index++] = stackId == nullref ? nullptr : (this->*get)(stackId); + stacks[index++] = stackId == nullref ? nullptr : GetInsExec_StackArrayRefLink(stackId); predecessorId = predecessor->predecessors.siblingNext; } } - Ref stackTop; - Ref* pStackPrevious = &stackTop; + Ref stackTop; + auto pStackPrevious = &stackTop; while (stacks[0]) { // check if all stack objects are the same @@ -4757,7 +4370,7 @@ MergeInsExecContext } // otherwise, create a new stack object to merge all - auto newStack = (this->*get)(allocator.Allocate()); + auto newStack = GetInsExec_StackArrayRefLink(insExec_StackArrayRefLinks.Allocate()); *pStackPrevious = newStack; pStackPrevious = &(newStack->previous); @@ -4774,7 +4387,16 @@ MergeInsExecContext merge(newStack, stacks[index]); // do not visit the same object repeatly - PushObjRefLinkWithCounter(newStack->objectIds, stacks[index]->objectIds); + auto currentLinkRef = stacks[index]->ids; + while (currentLinkRef != nullref) + { + auto currentLink = GetInsExec_StackRefLink(currentLinkRef); + currentLinkRef = currentLink->previous; + auto currentStack = GetInsExec_Stack(currentLink->id); + if (currentStack->mergeCounter == magicPush) continue; + currentStack->mergeCounter = magicPush; + PushStackRefLink(newStack->ids, currentStack); + } } } @@ -4782,7 +4404,7 @@ MergeInsExecContext for (vint index = 0; index < stacks.Count(); index++) { auto stackId = stacks[index]->previous; - stacks[index] = stackId == nullref ? nullptr : (this->*get)(stackId); + stacks[index] = stackId == nullref ? nullptr : GetInsExec_StackArrayRefLink(stackId); } } return stackTop; @@ -4794,30 +4416,22 @@ MergeInsExecContext auto traceExec = GetTraceExec(mergeTrace->traceExecRef); traceExec->context.objectStack = MergeStack< - InsExec_ObjectStack, - &TraceManager::GetInsExec_ObjectStack, &InsExec_Context::objectStack >( mergeTrace, - insExec_ObjectStacks, - [this](InsExec_ObjectStack* newStack, InsExec_ObjectStack* commingStack) + [this](InsExec_StackArrayRefLink* newStack, InsExec_StackArrayRefLink* commingStack) { - // all commingStack->pushedCount are ensured to be the same - newStack->pushedCount = commingStack->pushedCount; + newStack->currentDepth = commingStack->currentDepth; }); traceExec->context.createStack = MergeStack< - InsExec_CreateStack, - &TraceManager::GetInsExec_CreateStack, &InsExec_Context::createStack >( mergeTrace, - insExec_CreateStacks, - [this](InsExec_CreateStack* newStack, InsExec_CreateStack* commingStack) + [this](InsExec_StackArrayRefLink* newStack, InsExec_StackArrayRefLink* commingStack) { - // all commingStack->stackBase are ensured to be the same - newStack->stackBase = commingStack->stackBase; - PushInsRefLinkWithCounter(newStack->createInsRefs, commingStack->createInsRefs); + newStack->currentDepth = commingStack->currentDepth; + newStack->objectStackDepthForCreateStack = commingStack->objectStackDepthForCreateStack; }); NEW_MERGE_STACK_MAGIC_COUNTER; @@ -4827,9 +4441,6 @@ MergeInsExecContext auto predecessor = GetTrace(predecessorId); predecessorId = predecessor->predecessors.siblingNext; auto predecessorTraceExec = GetTraceExec(predecessor->traceExecRef); - - // do not visit the same object repeatly - PushObjRefLinkWithCounter(traceExec->context.lriStoredObjects, predecessorTraceExec->context.lriStoredObjects); } } @@ -4854,36 +4465,12 @@ namespace vl PartialExecuteOrdinaryTrace ***********************************************************************/ - InsExec_Object* TraceManager::NewObject() + InsExec_Stack* TraceManager::NewStack() { - auto ieObject = GetInsExec_Object(insExec_Objects.Allocate()); - ieObject->previous = firstObject; - firstObject = ieObject; - return ieObject; - } - - vint32_t TraceManager::GetStackBase(InsExec_Context& context) - { - if (context.createStack == nullref) - { - return 0; - } - else - { - return GetInsExec_CreateStack(context.createStack)->stackBase; - } - } - - vint32_t TraceManager::GetStackTop(InsExec_Context& context) - { - if (context.objectStack == nullref) - { - return 0; - } - else - { - return GetInsExec_ObjectStack(context.objectStack)->pushedCount; - } + auto ieStack = GetInsExec_Stack(insExec_Stacks.Allocate()); + ieStack->previous = firstStack; + firstStack = ieStack; + return ieStack; } void TraceManager::PushInsRefLink(Ref& link, InsRef insRef) @@ -4894,134 +4481,89 @@ PartialExecuteOrdinaryTrace link = newLink; } - void TraceManager::PushObjRefLink(Ref& link, Ref id) + void TraceManager::PushStackRefLink(Ref& link, Ref id) { - auto newLink = GetInsExec_ObjRefLink(insExec_ObjRefLinks.Allocate()); + auto newLink = GetInsExec_StackRefLink(insExec_StackRefLinks.Allocate()); newLink->previous = link; newLink->id = id; link = newLink; } + void TraceManager::PushStackArrayRefLink(Ref& arrayLink, Ref id) + { + Ref link; + PushStackRefLink(link, id); + PushStackArrayRefLink(arrayLink, link); + } + + void TraceManager::PushStackArrayRefLink(Ref& arrayLink, Ref link) + { + auto newArrayLink = GetInsExec_StackArrayRefLink(insExec_StackArrayRefLinks.Allocate()); + newArrayLink->previous = arrayLink; + newArrayLink->ids = link; + + if (arrayLink == nullref) + { + newArrayLink->currentDepth = 0; + } + else + { + newArrayLink->currentDepth = GetInsExec_StackArrayRefLink(arrayLink)->currentDepth + 1; + } + arrayLink = newArrayLink; + } + Ref TraceManager::JoinInsRefLink(Ref first, Ref second) { if (first == nullref) return second; if (second == nullref) return first; - Ref newStack; + Ref newInsRef; while (first != nullref) { - auto stack = GetInsExec_InsRefLink(first); - first = stack->previous; - PushInsRefLink(newStack, stack->insRef); + auto insRef = GetInsExec_InsRefLink(first); + first = insRef->previous; + PushInsRefLink(newInsRef, insRef->insRef); } while (second != nullref) { - auto stack = GetInsExec_InsRefLink(second); - second = stack->previous; - PushInsRefLink(newStack, stack->insRef); + auto insRef = GetInsExec_InsRefLink(second); + second = insRef->previous; + PushInsRefLink(newInsRef, insRef->insRef); } - return newStack; + return newInsRef; } - Ref TraceManager::JoinObjRefLink(Ref first, Ref second) + Ref TraceManager::JoinStackRefLink(Ref first, Ref second) { if (first == nullref) return second; if (second == nullref) return first; - Ref newStack; + Ref newStack; while (first != nullref) { - auto stack = GetInsExec_ObjRefLink(first); + auto stack = GetInsExec_StackRefLink(first); first = stack->previous; - PushObjRefLink(newStack, stack->id); + PushStackRefLink(newStack, stack->id); } while (second != nullref) { - auto stack = GetInsExec_ObjRefLink(second); + auto stack = GetInsExec_StackRefLink(second); second = stack->previous; - PushObjRefLink(newStack, stack->id); + PushStackRefLink(newStack, stack->id); } return newStack; } - void TraceManager::PushAssignedToObjectIdsSingleWithMagic(Ref fieldObjectIds, Ref assignedToTarget) - { - NEW_MERGE_STACK_MAGIC_COUNTER; - auto magicFieldObject = MergeStack_MagicCounter; - - auto linkRef = fieldObjectIds; - while (linkRef != nullref) - { - auto link = GetInsExec_ObjRefLink(linkRef); - linkRef = link->previous; - - if (link->id.handle == InsExec_Object::TokenOrEnumItemObjectId) - { - continue; - } - auto ieFieldObject = GetInsExec_Object(link->id); - if (ieFieldObject->mergeCounter == magicFieldObject) continue; - ieFieldObject->mergeCounter = magicFieldObject; - PushObjRefLink(ieFieldObject->assignedToObjectIds, assignedToTarget); - } - } - - void TraceManager::PushAssignedToObjectIdsMultipleWithMagic(Ref fieldObjectIds, Ref assignedToTarget) - { - NEW_MERGE_STACK_MAGIC_COUNTER; - auto magicElement = MergeStack_MagicCounter; - - auto linkRef = assignedToTarget; - while (linkRef != nullref) - { - auto link = GetInsExec_ObjRefLink(linkRef); - linkRef = link->previous; - - auto ieAssignedToObject = GetInsExec_Object(link->id); - if (ieAssignedToObject->mergeCounter == magicElement) return; - ieAssignedToObject->mergeCounter = magicElement; - - PushAssignedToObjectIdsSingleWithMagic(fieldObjectIds, link->id); - } - } - - InsExec_ObjectStack* TraceManager::PushObjectStackSingle(InsExec_Context& context, Ref objectId) - { - auto ie = GetInsExec_ObjectStack(insExec_ObjectStacks.Allocate()); - ie->previous = context.objectStack; - PushObjRefLink(ie->objectIds, objectId); - ie->pushedCount = GetStackTop(context) + 1; - context.objectStack = ie; - return ie; - } - - InsExec_ObjectStack* TraceManager::PushObjectStackMultiple(InsExec_Context& context, Ref linkId) - { - auto ie = GetInsExec_ObjectStack(insExec_ObjectStacks.Allocate()); - ie->previous = context.objectStack; - ie->objectIds = JoinObjRefLink(ie->objectIds, linkId); - ie->pushedCount = GetStackTop(context) + 1; - context.objectStack = ie; - return ie; - } - - InsExec_CreateStack* TraceManager::PushCreateStack(InsExec_Context& context) - { - auto ie = GetInsExec_CreateStack(insExec_CreateStacks.Allocate()); - ie->previous = context.createStack; - context.createStack = ie; - return ie; - } - void TraceManager::PartialExecuteOrdinaryTrace(Trace* trace) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::PartialExecuteOrdinaryTrace(Trace*)#" +#define TRACE_MAMAGER_PHRASE L"PrepareTraceRoute/PartialExecuteOrdinaryTrace" InsExec_Context context; if (trace->predecessors.first != nullref) { @@ -5030,8 +4572,21 @@ PartialExecuteOrdinaryTrace context = traceExec->context; } + auto ForEachStack = [this](Ref targetStack, auto&& callback) + { + auto topStackArray = GetInsExec_StackArrayRefLink(targetStack); + auto topStackLinkRef = topStackArray->ids; + while (topStackLinkRef != nullref) + { + auto topStackLink = GetInsExec_StackRefLink(topStackLinkRef); + topStackLinkRef = topStackLink->previous; + auto topStack = GetInsExec_Stack(topStackLink->id); + callback(topStack); + } + }; + auto traceExec = GetTraceExec(trace->traceExecRef); - for (vint32_t insRef = 0; insRef < traceExec->insLists.c3; insRef++) + for (vint32_t insRef = 0; insRef < traceExec->insLists.countAll; insRef++) { auto&& ins = ReadInstruction(insRef, traceExec->insLists); auto insExec = GetInsExec(traceExec->insExecRefs.start + insRef); @@ -5039,196 +4594,343 @@ PartialExecuteOrdinaryTrace switch (ins.type) { - case AstInsType::BeginObject: + case AstInsType::CreateObject: { - // new object - auto ieObject = NewObject(); - ieObject->createInsRef = { trace,insRef }; - - // new create stack - auto ieCSTop = PushCreateStack(context); - PushInsRefLink(ieCSTop->createInsRefs, ieObject->createInsRef); - ieCSTop->stackBase = GetStackTop(context); - PushObjRefLink(ieCSTop->objectIds, ieObject); - - // InsExec::createdObjectId - insExec->createdObjectId = ieObject; - } - break; - case AstInsType::DelayFieldAssignment: - { - // new create stack - auto ieCSTop = PushCreateStack(context); - PushInsRefLink(ieCSTop->createInsRefs, { trace, insRef }); - ieCSTop->stackBase = GetStackTop(context); - } - break; - case AstInsType::ReopenObject: - { - CHECK_ERROR(GetStackTop(context) - GetStackBase(context) >= 1, ERROR_MESSAGE_PREFIX L"Pushed values not enough."); - CHECK_ERROR(context.createStack != nullref, ERROR_MESSAGE_PREFIX L"There is no created object."); - - // pop an object - auto ieOSTop = GetInsExec_ObjectStack(context.objectStack); - context.objectStack = ieOSTop->previous; - - auto ieCSTop = GetInsExec_CreateStack(context.createStack); - - // InsExec_Object::assignedToObjectIds - PushAssignedToObjectIdsMultipleWithMagic(ieCSTop->reverseAssignedToObjectIds, ieCSTop->objectIds); - - // reopen an object - // ReopenObject in different branches could write to the same InsExec_CreateStack - // this happens when ambiguity happens in the !Rule syntax - // but the same InsExec_CreateStack means the clause of !Rule does not have ambiguity - // so ambiguity should also be resolved here - // and such ReopenObject will be the last instruction in a trace - // this means it is impossible to continue with InsExec_CreateStack polluted by sibling traces - // therefore adding multiple objects to the same InsExec_CreateStack in multiple branches is fine - // the successor trace will be a merge trace taking all of the information - NEW_MERGE_STACK_MAGIC_COUNTER; + if (context.createStack == nullref) { - auto magicReopen = MergeStack_MagicCounter; - { - auto ref = ieCSTop->objectIds; - while (ref != nullref) - { - auto link = GetInsExec_ObjRefLink(ref); - auto ieObject = GetInsExec_Object(link->id); - ieObject->mergeCounter = magicReopen; - ref = link->previous; - } - } - { - auto ref = ieOSTop->objectIds; - while (ref != nullref) - { - auto link = GetInsExec_ObjRefLink(ref); - auto ieObject = GetInsExec_Object(link->id); - if (ieObject->mergeCounter != magicReopen) - { - ieObject->mergeCounter = magicReopen; - PushObjRefLink(ieCSTop->objectIds, link->id); - } - ref = link->previous; - } - } + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[CreateObject] context.createStack is empty."); } - - auto insRefLinkId = ieCSTop->createInsRefs; - while(insRefLinkId != nullref) + ForEachStack(context.createStack, [=](InsExec_Stack* topStack) { - auto insRefLink = GetInsExec_InsRefLink(insRefLinkId); - insRefLinkId = insRefLink->previous; + PushInsRefLink(topStack->createObjectInsRefs, { trace, insRef }); + PushStackRefLink(insExec->operatingStacks, topStack); + }); + } + break; + case AstInsType::StackBegin: + { + auto newTopStack = NewStack(); + PushStackArrayRefLink(context.createStack, newTopStack); + newTopStack->beginInsRef = { trace, insRef }; + PushStackRefLink(insExec->operatingStacks, newTopStack); - // check if the top create stack is from DFA - auto traceCSTop = GetTrace(insRefLink->insRef.trace); - auto traceExecCSTop = GetTraceExec(traceCSTop->traceExecRef); - CHECK_ERROR(ReadInstruction(insRefLink->insRef.ins, traceExecCSTop->insLists).type == AstInsType::DelayFieldAssignment, ERROR_MESSAGE_PREFIX L"DelayFieldAssignment is not submitted before ReopenObject."); - - auto insExecDfa = GetInsExec(traceExecCSTop->insExecRefs.start + insRefLink->insRef.ins); - auto ref = ieOSTop->objectIds; - while (ref != nullref) - { - auto link = GetInsExec_ObjRefLink(ref); - auto ieObject = GetInsExec_Object(link->id); - // InsExec_Object::dfaInsRefs - PushInsRefLink(ieObject->dfaInsRefs, insRefLink->insRef); - // InsExec::objRefs - PushObjRefLink(insExecDfa->objRefs, ieObject); - ref = link->previous; - } + auto newStackTop = GetInsExec_StackArrayRefLink(context.createStack); + if (context.objectStack == nullref) + { + newStackTop->objectStackDepthForCreateStack = 0; + } + else + { + newStackTop->objectStackDepthForCreateStack = GetInsExec_StackArrayRefLink(context.objectStack)->currentDepth; } } break; - case AstInsType::EndObject: + case AstInsType::StackEnd: { - CHECK_ERROR(context.createStack != nullref, ERROR_MESSAGE_PREFIX L"There is no created object."); - - // pop a create stack - auto ieCSTop = GetInsExec_CreateStack(context.createStack); - context.createStack = ieCSTop->previous; - - // push an object - CHECK_ERROR(ieCSTop->objectIds != nullref, ERROR_MESSAGE_PREFIX L"An object has not been associated to the create stack yet."); - PushObjectStackMultiple(context, ieCSTop->objectIds); - - // InsExec::objRefs - insExec->objRefs = ieCSTop->objectIds; - - // InsExec::eoInsRefs - auto insRefLinkId = ieCSTop->createInsRefs; - while (insRefLinkId != nullref) + if (context.createStack == nullref) { - auto insRefLink = GetInsExec_InsRefLink(insRefLinkId); - insRefLinkId = insRefLink->previous; - - auto traceCSTop = GetTrace(insRefLink->insRef.trace); - auto traceExecCSTop = GetTraceExec(traceCSTop->traceExecRef); - auto insExecCreate = GetInsExec(traceExecCSTop->insExecRefs.start + insRefLink->insRef.ins); - PushInsRefLink(insExecCreate->eoInsRefs, { trace, insRef }); + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[StackEnd] context.createStack is empty."); } - } - break; - case AstInsType::DiscardValue: - case AstInsType::Field: - case AstInsType::FieldIfUnassigned: - { - CHECK_ERROR(GetStackTop(context) - GetStackBase(context) >= 1, ERROR_MESSAGE_PREFIX L"Pushed values not enough."); - - auto ieObjTop = GetInsExec_ObjectStack(context.objectStack); - context.objectStack = ieObjTop->previous; - - // InsExec_Object::assignedToObjectIds - if (context.createStack != nullref) + bool endWithCreate = false; + bool endWithReuse = false; + ForEachStack(context.createStack, [&](InsExec_Stack* topStack) { - auto ieCSTop = GetInsExec_CreateStack(context.createStack); - if (ieCSTop->objectIds == nullref) + bool executedCreateObject = false; + if (topStack->createObjectInsRefs != nullref) { - ieCSTop->reverseAssignedToObjectIds = JoinObjRefLink(ieCSTop->reverseAssignedToObjectIds, ieObjTop->objectIds); + auto lastCreateObjectInsRefLink = GetInsExec_InsRefLink(topStack->createObjectInsRefs); + executedCreateObject = lastCreateObjectInsRefLink->insRef.trace == trace; + } + + if(executedCreateObject) + { + endWithCreate = true; + PushInsRefLink(topStack->endWithCreateInsRefs, { trace, insRef }); } else { - PushAssignedToObjectIdsMultipleWithMagic(ieObjTop->objectIds, ieCSTop->objectIds); + endWithReuse = true; + PushInsRefLink(topStack->endWithReuseInsRefs, { trace, insRef }); } - } - } - break; - case AstInsType::LriStore: - { - CHECK_ERROR(GetStackTop(context) - GetStackBase(context) >= 1, ERROR_MESSAGE_PREFIX L"Pushed values not enough."); - CHECK_ERROR(context.lriStoredObjects == nullref, ERROR_MESSAGE_PREFIX L"LriFetch is not executed before the next LriStore."); - auto ieObjTop = GetInsExec_ObjectStack(context.objectStack); - context.objectStack = ieObjTop->previous; - context.lriStoredObjects = ieObjTop->objectIds; + PushStackRefLink(insExec->operatingStacks, topStack); + }); + + if (endWithCreate == endWithReuse) + { + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[StackEnd] Connected CreateObject and StackEnd should always be in the same trace."); + } + + if (endWithReuse) + { + if (context.objectStack == nullref) + { + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[StackEnd] context.objectStack is empty."); + } + auto topObjects = GetInsExec_StackArrayRefLink(context.objectStack); + context.objectStack = topObjects->previous; + ForEachStack(context.createStack, [&](InsExec_Stack* topStack) + { + topStack->useFromStacks = JoinStackRefLink(topStack->useFromStacks, topObjects->ids); + }); + } + + auto topStacks = GetInsExec_StackArrayRefLink(context.createStack); + context.createStack = topStacks->previous; + PushStackArrayRefLink(context.objectStack, topStacks->ids); } break; - case AstInsType::LriFetch: + case AstInsType::StackSlot: { - CHECK_ERROR(context.lriStoredObjects != nullref, ERROR_MESSAGE_PREFIX L"LriStore is not executed before the next LriFetch."); - PushObjectStackMultiple(context, context.lriStoredObjects); - context.lriStoredObjects = nullref; + if (context.createStack == nullref) + { + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[StackSlot] context.createStack is empty."); + } + if (context.objectStack == nullref) + { + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[StackSlot] context.objectStack is empty."); + } + auto topObjects = GetInsExec_StackArrayRefLink(context.objectStack); + context.objectStack = topObjects->previous; + ForEachStack(context.createStack, [&](InsExec_Stack* topStack) + { + topStack->fieldStacks = JoinStackRefLink(topStack->fieldStacks, topObjects->ids); + }); } break; + case AstInsType::Field: + case AstInsType::FieldIfUnassigned: case AstInsType::Token: case AstInsType::EnumItem: - { - PushObjectStackSingle(context, Ref(InsExec_Object::TokenOrEnumItemObjectId)); - } break; case AstInsType::ResolveAmbiguity: - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"ResolveAmbiguity should not appear in traces."); - case AstInsType::AccumulatedDfa: - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"AccumulatedDfa should not appear in traces."); - case AstInsType::AccumulatedEoRo: - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"AccumulatedEoRo should not appear in traces."); + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"[ResolveAmbiguity] should not appear in traces."); default:; - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Unrecognizabled instruction."); + throw TraceException(*this, { trace, insRef }, TRACE_MAMAGER_PHRASE, L"Unrecognizabled instruction."); } } traceExec->context = context; -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE + } + +#undef NEW_MERGE_STACK_MAGIC_COUNTER + } + } +} + +/*********************************************************************** +.\TRACEMANAGER\TMPTR_PARTIALEXECUTETRACES_SUMMARIZEINSTRUCTIONRANGE.CPP +***********************************************************************/ + +namespace vl +{ + namespace glr + { + namespace automaton + { + using namespace collections; + +#define NEW_MERGE_STACK_MAGIC_COUNTER (void)(MergeStack_MagicCounter++) + +/*********************************************************************** +IterateStackWithDependency +***********************************************************************/ + + template + void TraceManager::IterateStackWithDependency(Ref(InsExec_Stack::* dependencies), TCallback&& callback) + { + NEW_MERGE_STACK_MAGIC_COUNTER; + auto stackMagicCounter = MergeStack_MagicCounter; + + // traverse through all stacks + auto currentStackRef = firstStack; + while (currentStackRef != nullref) + { + auto currentStack = GetInsExec_Stack(currentStackRef); + currentStackRef = currentStack->previous; + if (currentStack->mergeCounter == stackMagicCounter) continue; + currentStack->mergeCounter = stackMagicCounter; + + List indirectStacks; + indirectStacks.Add(currentStack); + + // list all untouched dependencies in order, skipped processed ones + for (vint i = 0; i < indirectStacks.Count(); i++) + { + auto stack = indirectStacks[i]; + auto currentInsRefLink = stack->*dependencies; + while (currentInsRefLink != nullref) + { + auto insRefLink = GetInsExec_StackRefLink(currentInsRefLink); + currentInsRefLink = insRefLink->previous; + + auto useFromStack = GetInsExec_Stack(insRefLink->id); + if (useFromStack->mergeCounter == stackMagicCounter) continue; + useFromStack->mergeCounter = stackMagicCounter; + indirectStacks.Add(useFromStack); + } + } + + // process all listed stacks + for (vint i = indirectStacks.Count() - 1; i >= 0; i--) + { + auto stack = indirectStacks[i]; + callback(stack); + } + } + } + +/*********************************************************************** +SummarizeEarilestLocalInsRefs +***********************************************************************/ + + void TraceManager::SummarizeEarilestLocalInsRefs() + { + IterateStackWithDependency(&InsExec_Stack::useFromStacks, [this](InsExec_Stack* stack) + { + SortedList insRefs; + auto currentStackRefLink = stack->useFromStacks; + while (currentStackRefLink != nullref) + { + auto stackRefLink = GetInsExec_StackRefLink(currentStackRefLink); + currentStackRefLink = stackRefLink->previous; + + auto useFromStack = GetInsExec_Stack(stackRefLink->id); + UpdateTopTrace(stack->summarizing.earliestLocalInsRef, useFromStack->summarizing.earliestLocalInsRef); + CollectInsRefs(insRefs, useFromStack->summarizing.indirectCreateObjectInsRefs); + } + UpdateTopTrace(stack->summarizing.earliestLocalInsRef, stack->beginInsRef); + CollectInsRefs(insRefs, stack->createObjectInsRefs); + + for (auto insRef : insRefs) + { + PushInsRefLink(stack->summarizing.indirectCreateObjectInsRefs, insRef); + } + }); + } + +/*********************************************************************** +SummarizeEarilestStackInsRefs +***********************************************************************/ + + void TraceManager::SummarizeEarilestStackInsRefs() + { + { + auto currentStackRef = firstStack; + while (currentStackRef != nullref) + { + auto currentStack = GetInsExec_Stack(currentStackRef); + currentStackRef = currentStack->previous; + + currentStack->allDependentStacks = JoinStackRefLink(currentStack->fieldStacks, currentStack->useFromStacks); + } + } + IterateStackWithDependency(&InsExec_Stack::allDependentStacks, [this](InsExec_Stack* stack) + { + auto currentStackRefLink = stack->allDependentStacks; + while (currentStackRefLink != nullref) + { + auto stackRefLink = GetInsExec_StackRefLink(currentStackRefLink); + currentStackRefLink = stackRefLink->previous; + + auto fieldStack = GetInsExec_Stack(stackRefLink->id); + UpdateTopTrace(stack->summarizing.earliestStackInsRef, fieldStack->summarizing.earliestStackInsRef); + } + UpdateTopTrace(stack->summarizing.earliestStackInsRef, stack->summarizing.earliestLocalInsRef); + }); + } + +/*********************************************************************** +SummarizeEarilestInsRefs +***********************************************************************/ + + void TraceManager::SummarizeEarilestInsRefs() + { + List indirectStacks; + + // traverse through all stacks + auto currentStackRef = firstStack; + while (currentStackRef != nullref) + { + auto currentStack = GetInsExec_Stack(currentStackRef); + currentStackRef = currentStack->previous; + + indirectStacks.Clear(); + indirectStacks.Add(currentStack); + + // traverse through all useFromStacks recursively + for (vint i = 0; i < indirectStacks.Count(); i++) + { + auto stack = indirectStacks[i]; + // if earliestInsRef could be refreshed, propogate it into useFromStacks + if (!UpdateTopTrace(stack->summarizing.earliestInsRef, currentStack->summarizing.earliestStackInsRef)) + { + continue; + } + + if (stack == currentStack) + { + stack->summarizing.bottomInsRefs = JoinInsRefLink(stack->endWithCreateInsRefs, stack->endWithReuseInsRefs); + } + else + { + stack->summarizing.bottomInsRefs = currentStack->summarizing.bottomInsRefs; + } + + auto currentInsRefLink = stack->useFromStacks; + while (currentInsRefLink != nullref) + { + auto insRefLink = GetInsExec_StackRefLink(currentInsRefLink); + currentInsRefLink = insRefLink->previous; + + auto useFromStack = GetInsExec_Stack(insRefLink->id); + indirectStacks.Add(useFromStack); + } + } + } + } + +/*********************************************************************** +SummarizeInstructionRange +***********************************************************************/ + + bool TraceManager::UpdateTopTrace(InsRef& topInsRef, InsRef newInsRef) + { + if ( + topInsRef.trace == nullref || + topInsRef.trace > newInsRef.trace || + (topInsRef.trace == newInsRef.trace && topInsRef.ins > newInsRef.ins) + ) + { + topInsRef = newInsRef; + return true; + } + else + { + return false; + } + } + + void TraceManager::CollectInsRefs(collections::SortedList& insRefs, Ref link) + { + auto currentInsRefLink = link; + while (currentInsRefLink != nullref) + { + auto insRefLink = GetInsExec_InsRefLink(currentInsRefLink); + currentInsRefLink = insRefLink->previous; + + if (!insRefs.Contains(insRefLink->insRef)) + { + insRefs.Add(insRefLink->insRef); + } + } + } + + void TraceManager::SummarizeInstructionRange() + { + SummarizeEarilestLocalInsRefs(); + SummarizeEarilestStackInsRefs(); + SummarizeEarilestInsRefs(); } #undef NEW_MERGE_STACK_MAGIC_COUNTER @@ -5277,602 +4979,842 @@ namespace vl { namespace automaton { -/*********************************************************************** -MarkNewLeafStep -***********************************************************************/ - - void TraceManager::MarkNewLeafStep(ExecutionStep* step, ExecutionStep*& firstLeaf, ExecutionStep*& currentLeaf) - { - if (!firstLeaf) - { - firstLeaf = step; - } - - if (currentLeaf) - { - currentLeaf->next = step; - } - currentLeaf = step; - } -/*********************************************************************** -AppendStepLink -***********************************************************************/ - - void TraceManager::AppendStepLink(ExecutionStep* first, ExecutionStep* last, bool leafNode, DEFINE_EXECUTION_STEP_CONTEXT) - { - if (!root) - { - root = first; - } - - first->parent = currentStep; - currentStep = last; - - if (leafNode) - { - MarkNewLeafStep(last, firstLeaf, currentLeaf); - } - } + using namespace collections; +#define TRACE_MAMAGER_PHRASE L"ResolveAmbiguity/BuildExecutionOrder" /*********************************************************************** -AppendStepsBeforeAmbiguity +ExecutionStep Operations ***********************************************************************/ - void TraceManager::AppendStepsBeforeAmbiguity(Trace* startTrace, vint32_t startIns, TraceAmbiguity* ta, DEFINE_EXECUTION_STEP_CONTEXT) + void TraceManager::AppendStepsAfterList(ExecutionStepLinkedList steps, ExecutionStepLinkedList& current) { - // append a step from current position to the beginning of TraceAmbiguity - auto taFirst = GetTrace(ta->firstTrace); - auto taFirstExec = GetTraceExec(taFirst->traceExecRef); - if ( taFirst->traceExecRef > startTrace->traceExecRef || - (taFirst->traceExecRef == startTrace->traceExecRef && ta->prefix > startIns)) + if (!steps.first) { - if (ta->prefix > taFirstExec->insLists.c3) - { - // if the first ambiguous instruction is in successors of the branch trace - // execution from the current position to the end of the prefix - if (startTrace != taFirst || startIns < taFirstExec->insLists.c3) - { - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = startTrace->allocatedIndex; - step->et_i.startIns = startIns; - step->et_i.endTrace = taFirst->allocatedIndex; - step->et_i.endIns = taFirstExec->insLists.c3 - 1; - AppendStepLink(step, step, false, PASS_EXECUTION_STEP_CONTEXT); - } - if (ta->prefix > taFirstExec->insLists.c3) - { - auto prefixTrace = GetTrace(taFirst->successors.first); - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = prefixTrace->allocatedIndex; - step->et_i.startIns = 0; - step->et_i.endTrace = prefixTrace->allocatedIndex; - step->et_i.endIns = ta->prefix - taFirstExec->insLists.c3 - 1; - AppendStepLink(step, step, false, PASS_EXECUTION_STEP_CONTEXT); - } - } - else - { - // execute instructions before the first ambiguous instruction - if (startTrace != taFirst || startIns < ta->prefix) - { - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = startTrace->allocatedIndex; - step->et_i.startIns = startIns; - step->et_i.endTrace = taFirst->allocatedIndex; - step->et_i.endIns = ta->prefix - 1; - AppendStepLink(step, step, false, PASS_EXECUTION_STEP_CONTEXT); - } - } + return; } - } - -/*********************************************************************** -AppendStepsAfterAmbiguity -***********************************************************************/ - - void TraceManager::AppendStepsAfterAmbiguity(Trace*& startTrace, vint32_t& startIns, TraceAmbiguity* ta, DEFINE_EXECUTION_STEP_CONTEXT) - { - auto taLast = GetTrace(ta->lastTrace); - auto taLastExec = GetTraceExec(taLast->traceExecRef); - if (ta->postfix > taLastExec->insLists.c3) + if (!current.first) { - // if the last ambiguous instruction is in predecessors of the merge trace - // execute the postfix - auto postfixTrace = GetTrace(taLast->predecessors.first); - auto postfixTraceExec = GetTraceExec(postfixTrace->traceExecRef); - { - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = postfixTrace->allocatedIndex; - step->et_i.startIns = postfixTraceExec->insLists.c3 - (ta->postfix - taLastExec->insLists.c3); - step->et_i.endTrace = postfixTrace->allocatedIndex; - step->et_i.endIns = postfixTraceExec->insLists.c3 - 1; - AppendStepLink(step, step, false, PASS_EXECUTION_STEP_CONTEXT); - } - - // set the corrent position to the beginning of taList - startTrace = taLast; - startIns = 0; + current = steps; } else { - // otherwise set the current position to the instruction after the last ambiguous instruction - startTrace = taLast; - startIns = GetTraceExec(startTrace->traceExecRef)->insLists.c3 - ta->postfix; + steps.first->parent = current.last; + current.last = steps.last; } } -/*********************************************************************** -AppendStepsForAmbiguity -***********************************************************************/ - - void TraceManager::AppendStepsForAmbiguity(TraceAmbiguity* ta, bool checkCoveredMark, DEFINE_EXECUTION_STEP_CONTEXT) + void TraceManager::AppendLeafToTree(ExecutionStep* leaf, ExecutionStepTree& tree) { - ExecutionStep* taStepFirst = nullptr; - ExecutionStep* taStepLast = nullptr; - BuildAmbiguousStepLink(ta, checkCoveredMark, taStepFirst, taStepLast); - AppendStepLink(taStepFirst, taStepLast, false, PASS_EXECUTION_STEP_CONTEXT); - } - -/*********************************************************************** -AppendStepsBeforeBranch -***********************************************************************/ - - void TraceManager::AppendStepsBeforeBranch(Trace* startTrace, vint32_t startIns, Trace* branchTrace, TraceExec* branchTraceExec, DEFINE_EXECUTION_STEP_CONTEXT) - { - if (startTrace->traceExecRef < branchTrace->traceExecRef || - (startTrace->traceExecRef == branchTrace->traceExecRef && startIns < branchTraceExec->insLists.c3)) + if (!tree.firstLeaf) { - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = startTrace->allocatedIndex; - step->et_i.startIns = startIns; - step->et_i.endTrace = branchTrace->allocatedIndex; - step->et_i.endIns = branchTraceExec->insLists.c3 - 1; - AppendStepLink(step, step, false, PASS_EXECUTION_STEP_CONTEXT); + tree.firstLeaf = leaf; + tree.lastLeaf = leaf; + } + else + { + tree.lastLeaf->leafNext = leaf; + tree.lastLeaf = leaf; } } -/*********************************************************************** -BuildStepTree -***********************************************************************/ - - void TraceManager::BuildStepTree(Trace* startTrace, vint32_t startIns, Trace* endTrace, vint32_t endIns, ExecutionStep*& root, ExecutionStep*& firstLeaf, ExecutionStep* currentStep, ExecutionStep*& currentLeaf) + ExecutionStepLinkedList TraceManager::ConvertStepTreeToList(ExecutionStepTree tree) { - // find the next critical trace record which is or after startTrace - auto critical = GetTrace(GetTraceExec(startTrace->traceExecRef)->branchData.forwardTrace); + ExecutionStepLinkedList result; - // traverse critical until we hit endTrace - while (true) + // initialize visitCount and copyCount { - // skip if critical is before startTrace - if (critical && critical->traceExecRef < startTrace->traceExecRef) + Ref currentLeafRef = tree.firstLeaf; + while (currentLeafRef != nullref) { - goto NEXT_CRITICAL; + auto currentLeaf = GetExecutionStep(currentLeafRef); + currentLeafRef = currentLeaf->leafNext; + + Ref currentStepRef = currentLeaf; + while (currentStepRef != nullref) + { + auto currentStep = GetExecutionStep(currentStepRef); + currentStepRef = currentStep->parent; + + currentStep->visitCount = 0; + currentStep->copyCount = 0; + } + } + } + { + Ref currentLeafRef = tree.firstLeaf; + while (currentLeafRef != nullref) + { + auto currentLeaf = GetExecutionStep(currentLeafRef); + currentLeafRef = currentLeaf->leafNext; + + Ref currentStepRef = currentLeaf; + while (currentStepRef != nullref) + { + auto currentStep = GetExecutionStep(currentStepRef); + currentStepRef = currentStep->parent; + + currentStep->copyCount++; + } + } + } + + // traverse through each leaf + // make a list from root to leaf + // join them + { + Ref currentLeafRef = tree.firstLeaf; + while (currentLeafRef != nullref) + { + auto currentLeaf = GetExecutionStep(currentLeafRef); + currentLeafRef = currentLeaf->leafNext; + + ExecutionStepLinkedList leafList{ currentLeaf,currentLeaf }; + auto walkingStep = currentLeaf; + while (walkingStep->parent != nullref) + { + walkingStep = GetExecutionStep(walkingStep->parent); + + if (walkingStep->visitCount++ == walkingStep->copyCount) + { + leafList.first = walkingStep; + } + else + { + auto stepCopy = GetExecutionStep(executionSteps.Allocate()); + static_assert(sizeof(stepCopy->et_i) >= sizeof(stepCopy->et_ra)); + stepCopy->type = walkingStep->type; + stepCopy->et_i = walkingStep->et_i; + leafList.first->parent = stepCopy; + leafList.first = stepCopy; + } + } + AppendStepsAfterList(leafList, result); + } + } + + // clean leafPrev and leafNext + { + Ref currentLeafRef = tree.firstLeaf; + while (currentLeafRef != nullref) + { + auto currentLeaf = GetExecutionStep(currentLeafRef); + currentLeafRef = currentLeaf->leafNext; + + currentLeaf->leafNext = nullref; + } + } + + return result; + } + +/*********************************************************************** +CreateResolveAmbiguityStep +***********************************************************************/ + + ExecutionStep* TraceManager::CreateResolveAmbiguityStep(TraceAmbiguity* ta) + { + auto taFirst = GetTrace(ta->firstTrace); + auto taLast = GetTrace(ta->lastTrace); + auto step = GetExecutionStep(executionSteps.Allocate()); + step->type = ExecutionType::RA_End; + step->et_ra.type = -1; + step->et_ra.trace = taLast->allocatedIndex; + { + if (typeCallback == nullptr) + { + throw TraceException(*this, TRACE_MAMAGER_PHRASE, L"Missing ITypeCallback to resolve the type from multiple objects."); + } + auto currentStackLinkRef = ta->bottomCreateObjectStacks; + while (currentStackLinkRef != nullref) + { + auto currentStackLink = GetInsExec_StackRefLink(currentStackLinkRef); + currentStackLinkRef = currentStackLink->previous; + auto ieObject = GetInsExec_Stack(currentStackLink->id); + + // find all CreateObject instructions in that stack + if (ieObject->summarizing.indirectCreateObjectInsRefs == nullref) + { + throw TraceException(*this, ieObject, TRACE_MAMAGER_PHRASE, L"indirectCreateObjectInsRefs should not be null."); + } + auto coInsRefLink = ieObject->summarizing.indirectCreateObjectInsRefs; + while (coInsRefLink != nullref) + { + auto coInsRef = GetInsExec_InsRefLink(coInsRefLink); + coInsRefLink = coInsRef->previous; + + auto coTrace = GetTrace(coInsRef->insRef.trace); + auto coTraceExec = GetTraceExec(coTrace->traceExecRef); + auto&& coIns = ReadInstruction(coInsRef->insRef.ins, coTraceExec->insLists); + if (coIns.type != AstInsType::CreateObject || coIns.param == -1) + { + throw TraceException(*this, ieObject, TRACE_MAMAGER_PHRASE, L"indirectCreateObjectInsRefs points to an unexpected instruction."); + } + + if (step->et_ra.type == -1) + { + step->et_ra.type = coIns.param; + } + else if (step->et_ra.type != coIns.param) + { + vint32_t baseClass = typeCallback->FindCommonBaseClass(step->et_ra.type, coIns.param); + if (baseClass == -1) + { + throw UnableToResolveAmbiguityException( + WString::Unmanaged(L"Unable to resolve ambiguity type from ") + + typeCallback->GetClassName(step->et_ra.type) + + WString::Unmanaged(L" and ") + + typeCallback->GetClassName(coIns.param) + + WString::Unmanaged(L"."), + step->et_ra.type, + coIns.param, + EnsureTraceWithValidStates(taFirst)->currentTokenIndex, + EnsureTraceWithValidStates(taLast)->currentTokenIndex + ); + } + step->et_ra.type = baseClass; + } + } + } + } + return step; + } + +/*********************************************************************** +CollectNestedAmbiguities +***********************************************************************/ + + Ptr TraceManager::CollectNestedAmbiguities(TraceAmbiguity* ta) + { + auto taFirst = GetTrace(ta->firstTrace); + auto taBranch = GetTrace(ta->branchTrace); + + Ptr nestedTas; + { + auto criticalTrace = taFirst; + while (criticalTrace && criticalTrace->traceExecRef <= taBranch->traceExecRef) + { + auto criticalTraceExec = GetTraceExec(criticalTrace->traceExecRef); + if (criticalTraceExec->ambiguityBegins != nullref) + { + auto taLink = GetTraceAmbiguityLink(criticalTraceExec->ambiguityBegins); + auto nestedTa = GetTraceAmbiguity(taLink->ambiguity); + if (nestedTa != ta) + { + auto nestedTaLast = GetTrace(nestedTa->lastTrace); + if (nestedTaLast->traceExecRef > taBranch->traceExecRef) + { + if (!nestedTas) nestedTas = Ptr(new NestedAmbiguityInfo); + nestedTas->nestedAmbiguities.Add(nestedTa); + } + else + { + criticalTrace = GetTrace(nestedTa->mergeTrace); + continue; + } + } + } + + auto criticalRef = criticalTraceExec->nextAmbiguityCriticalTrace; + criticalTrace = criticalRef == nullref ? nullptr : GetTrace(criticalRef); + } + } + + if (nestedTas) + { + nestedTas->branchTraces.Add(GetTrace(ta->branchTrace), ta); + for (auto nestedTa : nestedTas->nestedAmbiguities) + { + auto branchTrace = GetTrace(nestedTa->branchTrace); + nestedTas->branchTraces.Add(branchTrace, nestedTa); } - // if critical is empty - // or critical is after endTrace - // or critical is endTrace and the first ambiguous instruction is not before endIns - - if (critical) + for (auto nestedTa : nestedTas->nestedAmbiguities) { - if (critical->traceExecRef < endTrace->traceExecRef) + auto currentTraceRef = nestedTa->branchTrace; + while (currentTraceRef != nullref) { - goto CONTINUE_SEARCHING; - } - if (critical == endTrace) - { - auto criticalExec = GetTraceExec(critical->traceExecRef); - if (criticalExec->ambiguityBegins != nullref) + auto currentTrace = GetTrace(currentTraceRef); + if (currentTrace->traceExecRef < taFirst->traceExecRef) { - auto taLinkRef = criticalExec->ambiguityBegins; - while (taLinkRef != nullref) - { - auto taLink = GetTraceAmbiguityLink(taLinkRef); - taLinkRef = taLink->previous; + break; + } - auto ta = GetTraceAmbiguity(taLink->ambiguity); - if (ta->prefix < endIns) + if (currentTrace->successors.siblingNext != currentTrace->successors.siblingPrev) + { + auto predecessor = GetTrace(currentTrace->predecessors.first); + if (nestedTas->branchTraces.Keys().Contains(predecessor)) + { + nestedTas->branchSelections.Add(nestedTa, currentTrace); + } + } + + auto currentTraceExec = GetTraceExec(currentTrace->traceExecRef); + if (currentTraceExec->branchData.forwardTrace == currentTrace) + { + currentTraceRef = currentTrace->predecessors.first; + } + else + { + currentTraceRef = currentTraceExec->branchData.forwardTrace; + } + } + } + } + + return nestedTas; + } + +/*********************************************************************** +BuildStepLeafsForAmbiguityBranch +***********************************************************************/ + + void TraceManager::BuildStepLeafsForAmbiguityBranch( + TraceAmbiguity* ta, + ExecutionStep* lastSharedStep, + Trace* ambiguityBranchStartTrace, + vint32_t* ambiguityBranchStartIns, + ExecutionStepTree& ambiguityStepTree) + { + auto taFirst = GetTrace(ta->firstTrace); + auto taLast = GetTrace(ta->lastTrace); + auto taMerge = GetTrace(ta->mergeTrace); + auto taFirstExec = GetTraceExec(taFirst->traceExecRef); + auto taLastExec = GetTraceExec(taLast->traceExecRef); + auto taMergeExec = GetTraceExec(taMerge->traceExecRef); + vint32_t prefixExtra = ta->prefix - taFirstExec->insLists.countAll; + vint32_t postfixExtra = ta->postfix - taLastExec->insLists.countAll; + + ExecutionStepLinkedList branchList; + // Execute the branch + { + Trace* rawBranchTrace = nullptr; + auto steps = BuildStepListUntilFirstRawBranchTrace( + ambiguityBranchStartTrace, + ambiguityBranchStartIns ? *ambiguityBranchStartIns : (prefixExtra <= 0 ? 0 : prefixExtra), + taMerge, + (taMergeExec->insLists.countAll - 1 - (postfixExtra <= 0 ? 0 : postfixExtra)), + nullptr, + &rawBranchTrace + ); + + if (rawBranchTrace) + { + if (steps.first) + { + steps.first->parent = lastSharedStep; + } + + auto successorId = rawBranchTrace->successors.first; + while (successorId != nullref) + { + auto successor = GetTrace(successorId); + successorId = successor->successors.siblingNext; + BuildStepLeafsForAmbiguityBranch(ta, (steps.first ? steps.last : lastSharedStep), successor, nullptr, ambiguityStepTree); + } + return; + } + AppendStepsAfterList(steps, branchList); + } + + // Execute from taMerge to taLast + if (postfixExtra < 0) + { + auto steps = BuildStepList( + taMerge, + 0, + taLast, + -postfixExtra - 1, + nullptr + ); + AppendStepsAfterList(steps, branchList); + } + + // Append RA_BRANCH + { + auto step = GetExecutionStep(executionSteps.Allocate()); + step->type = ExecutionType::RA_Branch; + step->et_ra.trace = taLast->allocatedIndex; + step->et_ra.type = -1; + AppendStepsAfterList({ step,step }, branchList); + } + + branchList.first->parent = lastSharedStep; + AppendLeafToTree(branchList.last, ambiguityStepTree); + } + +/*********************************************************************** +BuildStepLeafsForNestedAmbiguityBranch +***********************************************************************/ + + void TraceManager::BuildStepLeafsForNestedAmbiguityBranch( + TraceAmbiguity* ta, + ExecutionStep* lastSharedStep, + BSLA_Guidance* guidance, + ExecutionStepTree& ambiguityStepTree) + { + ExecutionStepLinkedList stepsBeforeBranch; + auto nta = guidance->nestedTas->nestedAmbiguities[guidance->nextAmbiguityIndex]; + + auto taFirst = GetTrace(ta->firstTrace); + auto ntaFirst = GetTrace(nta->firstTrace); + + // Execute from taFirst until the nested TraceAmbiguity + { + auto ntaFirst = GetTrace(nta->firstTrace); + auto steps = BuildStepList( + taFirst, + ta->prefix, + ntaFirst, + -1, + nullptr + ); + AppendStepsAfterList(steps, stepsBeforeBranch); + } + + // Execute the nested TraceAmbiguity + Trace* currentTrace = ntaFirst; + vint32_t currentIns = 0; + { + auto steps = BuildStepListThroughAmbiguity( + currentTrace, + currentIns, + nta, + guidance + ); + AppendStepsAfterList(steps, stepsBeforeBranch); + } + + + // Execute the rest + stepsBeforeBranch.first->parent = lastSharedStep; + lastSharedStep = stepsBeforeBranch.last; + BuildStepLeafsForAmbiguityBranch( + ta, + lastSharedStep, + currentTrace, + ¤tIns, + ambiguityStepTree + ); + } + +/*********************************************************************** +BuildStepListForAmbiguity +***********************************************************************/ + + ExecutionStepLinkedList TraceManager::BuildStepListForAmbiguity( + TraceAmbiguity* ta, + BSLA_Guidance* guidance) + { + BSLA_Guidance DoNotUse_BSLA_Guidance; + BSL_Guidance DoNotUse_BSL_Guidance; + + ExecutionStepLinkedList result; + auto taFirst = GetTrace(ta->firstTrace); + auto taBranch = GetTrace(ta->branchTrace); + auto taFirstExec = GetTraceExec(taFirst->traceExecRef); + auto taBranchExec = GetTraceExec(taBranch->traceExecRef); + vint32_t prefixExtra = ta->prefix - taFirstExec->insLists.countAll; + + // Find the first nested TraceAmbiguity between taFirst and taBranch + bool currentAmbiguityIsNested = guidance != nullptr; + if (!guidance && (DoNotUse_BSLA_Guidance.nestedTas = CollectNestedAmbiguities(ta))) + { + guidance = &DoNotUse_BSLA_Guidance; + } + + if (currentAmbiguityIsNested) + { + guidance->nextAmbiguityIndex++; + } + bool nestedAmbiguityAvailable = guidance && guidance->nextAmbiguityIndex < guidance->nestedTas->nestedAmbiguities.Count(); + + // Append RA_BEGIN + { + auto step = GetExecutionStep(executionSteps.Allocate()); + step->type = ExecutionType::RA_Begin; + step->et_ra.trace = taFirst->allocatedIndex; + step->et_ra.type = -1; + AppendStepsAfterList({ step,step }, result); + } + + { + ExecutionStepTree branchSteps; + // If there is a nested TraceAmbiguity, Execute it first + if (nestedAmbiguityAvailable) + { + BuildStepLeafsForNestedAmbiguityBranch(ta, nullptr, guidance, branchSteps); + } + + ExecutionStepLinkedList sharedSteps; + // Execute from taFirst to taBranch + if (prefixExtra < 0) + { + if (guidance) + { + DoNotUse_BSL_Guidance = { + (currentAmbiguityIsNested ? &guidance->nestedTas->branchSelections[ta] : nullptr), + &guidance->nestedTas->nestedAmbiguities, + }; + } + sharedSteps = BuildStepList( + taFirst, + ta->prefix, + taBranch, + taBranchExec->insLists.countAll - 1, + (guidance ? &DoNotUse_BSL_Guidance : nullptr) + ); + } + + // Nested TraceAmbiguity is not implemented, so all successors of taBranch are needed + auto successorId = taBranch->successors.first; + while (successorId != nullref) + { + auto successor = GetTrace(successorId); + successorId = successor->successors.siblingNext; + + if (guidance) + { + // Skip visited branches + for (vint i = guidance->nextAmbiguityIndex; i < guidance->nestedTas->nestedAmbiguities.Count(); i++) + { + auto nta = guidance->nestedTas->nestedAmbiguities[i]; + for (auto selection : guidance->nestedTas->branchSelections[nta]) + { + if (selection == successor) { - goto CONTINUE_SEARCHING; + goto SKIP_CURRENT_SUCCESSOR; } } } } + BuildStepLeafsForAmbiguityBranch(ta, sharedSteps.last, successor, nullptr, branchSteps); + SKIP_CURRENT_SUCCESSOR:; } - // it means we have reached the end - break; + AppendStepsAfterList(ConvertStepTreeToList(branchSteps), result); + } - CONTINUE_SEARCHING: + if (currentAmbiguityIsNested) + { + guidance->nextAmbiguityIndex--; + } - // there is three kinds of critical node: - // ambiguous trace (could also be a branch tree) - // branch trace - // predecessor of merge trace + // Append RA_END + { + auto step = CreateResolveAmbiguityStep(ta); + AppendStepsAfterList({ step,step }, result); + } + return result; + } + +/*********************************************************************** +BuildStepListThroughAmbiguity +***********************************************************************/ + + ExecutionStepLinkedList TraceManager::BuildStepListThroughAmbiguity( + Trace*& currentTrace, + vint32_t& currentIns, + TraceAmbiguity* ta, + BSLA_Guidance* guidance + ) + { + ExecutionStepLinkedList result; + + auto taFirst = GetTrace(ta->firstTrace); + auto taLast = GetTrace(ta->lastTrace); + auto taFirstExec = GetTraceExec(taFirst->traceExecRef); + auto taLastExec = GetTraceExec(taLast->traceExecRef); + vint32_t prefixExtra = ta->prefix - taFirstExec->insLists.countAll; + vint32_t postfixExtra = ta->postfix - taLastExec->insLists.countAll; + + if (currentTrace->traceExecRef < taFirst->traceExecRef || currentIns < ta->prefix) + { + auto step = GetExecutionStep(executionSteps.Allocate()); + step->et_i.startTrace = currentTrace->allocatedIndex; + step->et_i.startIns = currentIns; + if (ta->prefix == 0) { - auto criticalExec = GetTraceExec(critical->traceExecRef); - if (criticalExec->ambiguityBegins != nullref) + if (taFirst->predecessors.first != taFirst->predecessors.last) { - // check if the only one TraceAmbiguity covers all successors - bool singleCompleteAmbiguity = true; - { - auto firstSuccessor = GetTrace(critical->successors.first); - auto successorId = firstSuccessor->successors.siblingNext; - auto covered = GetTraceExec(firstSuccessor->traceExecRef)->ambiguityCoveredInForward; - while (successorId != nullref) - { - auto successor = GetTrace(successorId); - successorId = successor->successors.siblingNext; + throw TraceException(*this, ta, nullptr, TRACE_MAMAGER_PHRASE, L"The prefix of the TraceAmbiguity is 0, but its firstTrace is a merge trace."); + } + auto taFirstPrev = GetTrace(taFirst->predecessors.first); + auto taFirstPrevExec = GetTraceExec(taFirstPrev->traceExecRef); + step->et_i.endTrace = taFirstPrev->allocatedIndex; + step->et_i.endIns = taFirstPrevExec->insLists.countAll - 1; + } + else if (prefixExtra <= 0) + { + step->et_i.endTrace = taFirst->allocatedIndex; + step->et_i.endIns = ta->prefix - 1; + } + else + { + step->et_i.endTrace = taFirst->allocatedIndex; + step->et_i.endIns = taFirstExec->insLists.countAll - 1; + } + AppendStepsAfterList({ step, step }, result); + } - if (covered != GetTraceExec(successor->traceExecRef)->ambiguityCoveredInForward) + if (prefixExtra > 0) + { + // at the moment taFirst should be taBranch + // TraceAmbiguity begins at each successors of taBranch, instead of before taBranch + auto taFirstSuccessor = GetTrace(taFirst->successors.first); + auto step = GetExecutionStep(executionSteps.Allocate()); + step->et_i.startTrace = taFirstSuccessor->allocatedIndex; + step->et_i.startIns = 0; + step->et_i.endTrace = taFirstSuccessor->allocatedIndex; + step->et_i.endIns = prefixExtra - 1; + AppendStepsAfterList({ step, step }, result); + } + + // Execute the next TraceAmbiguity + auto taSteps = BuildStepListForAmbiguity(ta, guidance); + AppendStepsAfterList(taSteps, result); + + // Step (currentTrace, currentIns) forward to right after TraceAmbiguity + if (postfixExtra > 0) + { + // at the moment taLast should be taMerge + // TraceAmbiguity ends at each predecessor of taMerge, instead of after taMerge + auto taLastPredecessor = GetTrace(taLast->predecessors.first); + auto taLastPredecessorExec = GetTraceExec(taLastPredecessor->traceExecRef); + auto step = GetExecutionStep(executionSteps.Allocate()); + step->et_i.startTrace = taLastPredecessor->allocatedIndex; + step->et_i.startIns = taLastPredecessorExec->insLists.countAll - postfixExtra; + step->et_i.endTrace = taLastPredecessor->allocatedIndex; + step->et_i.endIns = taLastPredecessorExec->insLists.countAll - 1; + AppendStepsAfterList({ step, step }, result); + } + + if (ta->postfix == 0) + { + if (taLast->successors.first == nullref) + { + currentTrace = nullptr; + } + else if (taLast->successors.first != taLast->successors.last) + { + throw TraceException(*this, ta, nullptr, TRACE_MAMAGER_PHRASE, L"The postfix of the TraceAmbiguity is 0, but its lastTrace is a branch trace."); + } + else + { + currentTrace = GetTrace(taLast->successors.first); + currentIns = 0; + } + } + else + { + currentTrace = taLast; + currentIns = -(postfixExtra <= 0 ? postfixExtra : 0); + } + + return result; + } + +/*********************************************************************** +BuildStepList +***********************************************************************/ + + ExecutionStepLinkedList TraceManager::BuildStepListUntilFirstRawBranchTrace( + Trace* startTrace, + vint32_t startIns, + Trace* endTrace, + vint32_t endIns, + BSL_Guidance* guidance, + Trace** rawBranchTrace) + { + ExecutionStepLinkedList result; + Trace* currentTrace = startTrace; + vint32_t currentIns = startIns; + + while (currentTrace) + { + auto currentTraceExec = GetTraceExec(currentTrace->traceExecRef); + + // Find the next critical trace + Trace* criticalTrace = nullptr; + if (currentTraceExec->nextAmbiguityCriticalTrace != nullref) + { + criticalTrace = currentTrace; + } + else + { + criticalTrace = GetTrace(currentTraceExec->branchData.forwardTrace); + } + + while (criticalTrace && criticalTrace->traceExecRef <= currentTrace->traceExecRef) + { + auto nextRef = GetTraceExec(criticalTrace->traceExecRef)->nextAmbiguityCriticalTrace; + if (nextRef == nullref) + { + if (criticalTrace->successors.first != criticalTrace->successors.last) + { + // When there is no more next critical trace before a branch trace + auto criticalTraceExec = GetTraceExec(criticalTrace->traceExecRef); + if (criticalTraceExec->ambiguityBegins != nullref) + { + // If it is associated with a TraceAmbiguity, it is a critical trace we are looking for + break; + } + throw TraceException(*this, currentTrace, nullptr, TRACE_MAMAGER_PHRASE, L"Failed to find a TraceAmbiguity between this trace and the next branch trace."); + } + else + { + // When there is no more next critical trace, we are about to reach the end + // Ignore the current critical trace, stop searching, just run through the end + goto NO_CRITICAL_TRACE; + } + } + + // When it runs past (endTrace, endIns) + // Ignore the current critical trace, stop searching, just run through the end + criticalTrace = nextRef == nullref ? nullptr : GetTrace(nextRef); + if (criticalTrace->traceExecRef >= endTrace->traceExecRef) + { + goto NO_CRITICAL_TRACE; + } + else if (endIns < 0 && criticalTrace->successors.first == endTrace) + { + goto NO_CRITICAL_TRACE; + } + } + + // If the current critical trace is associated with a TraceAmbiguity + // and the TraceAmbiguity is what configured to skip + // treat it as an ordinary trace + auto criticalTraceExec = GetTraceExec(criticalTrace->traceExecRef); + bool ignoreCriticalAmgiguity = false; + if (guidance && guidance->ambiguitiesToSkip && criticalTraceExec->ambiguityBegins != nullref) + { + auto ta = GetTraceAmbiguity(GetTraceAmbiguityLink(criticalTraceExec->ambiguityBegins)->ambiguity); + for (auto nestedTa : *guidance->ambiguitiesToSkip) + { + if (nestedTa == ta) + { + ignoreCriticalAmgiguity = true; + break; + } + } + } + + if (ignoreCriticalAmgiguity || criticalTraceExec->ambiguityBegins == nullref) + { + // If the current critical trace is a branch trace + // and there is a specified successor to execute + // treat it as an ordinary trace + // otherwise, exit properly + Trace* specifieidBranchSelection = nullptr; + if (criticalTrace->successors.first != criticalTrace->successors.last) + { + if (guidance && guidance->branchSelections) + { + for (auto selection : *guidance->branchSelections) + { + if (criticalTrace == selection->predecessors.first) { - singleCompleteAmbiguity = false; + specifieidBranchSelection = selection; break; } } } - if (singleCompleteAmbiguity) + if (!specifieidBranchSelection) { - // if yes, it means the TraceAmbiguity will cover all successors - // run the ambiguity in place, no need for recursion - auto taLink = GetTraceAmbiguityLink(criticalExec->ambiguityBegins); - auto ta = GetTraceAmbiguity(taLink->ambiguity); - - // append steps for ambiguity and fix the current position - AppendStepsBeforeAmbiguity(startTrace, startIns, ta, PASS_EXECUTION_STEP_CONTEXT); - AppendStepsForAmbiguity(ta, false, PASS_EXECUTION_STEP_CONTEXT); - AppendStepsAfterAmbiguity(startTrace, startIns, ta, PASS_EXECUTION_STEP_CONTEXT); - - // fix critical - critical = GetTrace(GetTraceExec(startTrace->traceExecRef)->branchData.forwardTrace); - continue; - } - else - { - // there could be one or more TraceAmbiguity - // there could also be successors that are not covered by any TraceAmbiguity - auto taLinkRef = criticalExec->ambiguityBegins; - while (taLinkRef != nullref) + if (rawBranchTrace) { - auto taLink = GetTraceAmbiguityLink(taLinkRef); - taLinkRef = taLink->previous; - auto ta = GetTraceAmbiguity(taLink->ambiguity); - - auto branchStartTrace = startTrace; - auto branchStartIns = startIns; - auto branchStep = currentStep; - -#define PASS_BRANCH_STEP_CONTEXT root, firstLeaf, branchStep, currentLeaf - AppendStepsBeforeAmbiguity(branchStartTrace, branchStartIns, ta, PASS_BRANCH_STEP_CONTEXT); - AppendStepsForAmbiguity(ta, true, PASS_BRANCH_STEP_CONTEXT); - AppendStepsAfterAmbiguity(branchStartTrace, branchStartIns, ta, PASS_BRANCH_STEP_CONTEXT); - BuildStepTree(branchStartTrace, branchStartIns, endTrace, endIns, PASS_BRANCH_STEP_CONTEXT); -#undef PASS_BRANCH_STEP_CONTEXT + *rawBranchTrace = criticalTrace; + endTrace = criticalTrace; + endIns = GetTraceExec(endTrace->traceExecRef)->insLists.countAll - 1; + goto NO_CRITICAL_TRACE; } - - // treat the remaining successors as from a branch trace - AppendStepsBeforeBranch(startTrace, startIns, critical, criticalExec, PASS_EXECUTION_STEP_CONTEXT); - - auto successorId = critical->successors.first; - while (successorId != nullref) + else { - auto successor = GetTrace(successorId); - successorId = successor->successors.siblingNext; - if (GetTraceExec(successor->traceExecRef)->ambiguityCoveredInForward == nullref) - { - BuildStepTree(successor, 0, endTrace, endIns, PASS_EXECUTION_STEP_CONTEXT); - } + throw TraceException(*this, currentTrace, criticalTrace, TRACE_MAMAGER_PHRASE, L"The next critical trace after the current trace is not associated with a TraceAmbiguity."); } - return; } } - else if (critical->successors.first != critical->successors.last) + + // A critical trace could be a predecessor of a merge trace + // Execute until here and continue + auto step = GetExecutionStep(executionSteps.Allocate()); + step->et_i.startTrace = currentTrace->allocatedIndex; + step->et_i.startIns = currentIns; + step->et_i.endTrace = criticalTrace->allocatedIndex; + step->et_i.endIns = criticalTraceExec->insLists.countAll - 1; + AppendStepsAfterList({ step, step }, result); + + if(specifieidBranchSelection) { - // if critical is a branch tree - - // append a step current position to the end of critical - AppendStepsBeforeBranch(startTrace, startIns, critical, criticalExec, PASS_EXECUTION_STEP_CONTEXT); - - // recursively process all successors - auto successorId = critical->successors.first; - while (successorId != nullref) - { - auto successor = GetTrace(successorId); - successorId = successor->successors.siblingNext; - BuildStepTree(successor, 0, endTrace, endIns, PASS_EXECUTION_STEP_CONTEXT); - } - return; + currentTrace = specifieidBranchSelection; } - else if (critical->predecessors.siblingPrev != critical->predecessors.siblingNext) + else if (criticalTrace->successors.first == nullref) { - // if critical is a predecessor of a merge tree - // see if it could be an end - if (critical->successors.first == endTrace && endIns < 0) - { - // fix endTrace and endIns - endTrace = critical; - endIns = criticalExec->insLists.c3 + endIns; - break; - } - else - { - // otherwise, fix critical - critical = GetTrace(GetTraceExec(GetTrace(critical->successors.first)->traceExecRef)->branchData.forwardTrace); - continue; - } + currentTrace = nullptr; } else { - // this happens when the forward trace is not critical + currentTrace = GetTrace(criticalTrace->successors.first); + currentIns = 0; } + continue; } - NEXT_CRITICAL: - auto criticalRef = GetTraceExec(critical->traceExecRef)->nextAmbiguityCriticalTrace; - critical = criticalRef == nullref ? nullptr : GetTrace(criticalRef); + // Execute from (currentTrace, currentIns) until the next TraceAmbiguity + auto ta = GetTraceAmbiguity(GetTraceAmbiguityLink(criticalTraceExec->ambiguityBegins)->ambiguity); + auto steps = BuildStepListThroughAmbiguity(currentTrace, currentIns, ta, nullptr); + AppendStepsAfterList(steps, result); + } + NO_CRITICAL_TRACE: + + if (endIns < 0 && endIns != GetTraceExec(endTrace->traceExecRef)->insLists.countAll - 1) + { + // The real endTrace is a predecessor of endTrace, but we need to find out which + auto realEndTrace = currentTrace; + while (realEndTrace->successors.first != endTrace) + { + realEndTrace = GetTrace(realEndTrace->successors.first); + } + + auto realEndTraceExec = GetTraceExec(realEndTrace->traceExecRef); + endTrace = realEndTrace; + endIns = realEndTraceExec->insLists.countAll + endIns; } - if ( startTrace->traceExecRef < endTrace->traceExecRef || - (startTrace->traceExecRef == endTrace->traceExecRef && startIns <= endIns)) + if (currentTrace) { - auto step = GetExecutionStep(executionSteps.Allocate()); - step->et_i.startTrace = startTrace->allocatedIndex; - step->et_i.startIns = startIns; - step->et_i.endTrace = endTrace->allocatedIndex; - step->et_i.endIns = endIns; - AppendStepLink(step, step, true, PASS_EXECUTION_STEP_CONTEXT); - } - else - { - MarkNewLeafStep(currentStep, firstLeaf, currentLeaf); + if ( + currentTrace->traceExecRef < endTrace->traceExecRef || + (currentTrace->traceExecRef == endTrace->traceExecRef && currentIns <= endIns) + ) + { + // Execute from (currentTrace, currentIns) to (endTrace, endIns) + auto step = GetExecutionStep(executionSteps.Allocate()); + step->et_i.startTrace = currentTrace->allocatedIndex; + step->et_i.startIns = currentIns; + step->et_i.endTrace = endTrace->allocatedIndex; + step->et_i.endIns = endIns; + AppendStepsAfterList({ step, step }, result); + } + else + { + throw TraceException(*this, currentTrace, endTrace, TRACE_MAMAGER_PHRASE, L"BuildStepList corrupted with a currentTrace after startIns."); + } } + + return result; } -/*********************************************************************** -ConvertStepTreeToLink -***********************************************************************/ - - void TraceManager::ConvertStepTreeToLink(ExecutionStep* root, ExecutionStep* firstLeaf, ExecutionStep*& first, ExecutionStep*& last) + ExecutionStepLinkedList TraceManager::BuildStepList( + Trace* startTrace, + vint32_t startIns, + Trace* endTrace, + vint32_t endIns, + BSL_Guidance* guidance) { - // calculate copyCount - Ref currentLeafRef = firstLeaf; - while (currentLeafRef != nullref) - { - auto currentRef = currentLeafRef; - while (currentRef != nullref) - { - auto current = GetExecutionStep(currentRef); - current->copyCount++; - currentRef = current->parent; - } - - currentLeafRef = GetExecutionStep(currentLeafRef)->next; - } - - // for each leaf, build a step link from root to the leaf - // concat all link, fill first and last - currentLeafRef = firstLeaf; - while (currentLeafRef != nullref) - { - // disconnect currentLeaf to the next leaf - auto currentLeaf = GetExecutionStep(currentLeafRef); - auto nextLeafRef = currentLeaf->next; - currentLeaf->next = nullref; - - // fix next from root to currentLeaf - auto current = currentLeaf; - while (current->parent != nullref) - { - auto parent = GetExecutionStep(current->parent); - parent->next = current; - current = parent; - } - - // make a step link from root to currentLeaf - ExecutionStep* linkFirst = nullptr; - ExecutionStep* linkLast = nullptr; - - Ref currentRef = root; - while (currentRef != nullref) - { - // increase visitCount - auto current = GetExecutionStep(currentRef); - current->visitCount++; - - if (current->visitCount == current->copyCount) - { - // if visitCount == copyCount - // it means current will not be copied in the next round - // sublink from current to currentLeaf copy be used directly - if (!linkFirst) - { - linkFirst = current; - } - if (linkLast) - { - linkLast->next = current; - } - linkLast = currentLeaf; - break; - } - else - { - // otherwise, copy current - static_assert(sizeof(ExecutionStep::ETI) >= sizeof(ExecutionStep::ETRA)); - auto step = GetExecutionStep(executionSteps.Allocate()); - step->type = current->type; - step->et_i = current->et_i; - - if (!linkFirst) - { - linkFirst = step; - } - if (linkLast) - { - linkLast->next = step; - } - linkLast = step; - currentRef = current->next; - } - } - - if (!first) - { - first = linkFirst; - } - if (last) - { - last->next = linkFirst; - } - last = linkLast; - - currentLeafRef = nextLeafRef; - } - } - -/*********************************************************************** -BuildAmbiguousStepLink -***********************************************************************/ - - void TraceManager::BuildAmbiguousStepLink(TraceAmbiguity* ta, bool checkCoveredMark, ExecutionStep*& first, ExecutionStep*& last) - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::BuildAmbiguousStepLink()#" - auto taFirst = GetTrace(ta->firstTrace); - auto taFirstExec = GetTraceExec(taFirst->traceExecRef); - auto taLast = GetTrace(ta->lastTrace); - auto taLastExec = GetTraceExec(taLast->traceExecRef); - - ExecutionStep* root = GetExecutionStep(executionSteps.Allocate()); - root->type = ExecutionType::Empty; - - ExecutionStep* firstLeaf = nullptr; - ExecutionStep* currentLeaf = nullptr; - - if (ta->prefix < taFirstExec->insLists.c3) - { - // if the first ambiguous instruction is in taFirst - - // traverse all successors - auto successorId = taFirst->successors.first; - while (successorId != nullref) - { - auto successor = GetTrace(successorId); - successorId = successor->successors.siblingNext; - if (checkCoveredMark && GetTraceExec(successor->traceExecRef)->ambiguityCoveredInForward != ta) - { - continue; - } - - // append a step to execute from the first ambiguous instruction - auto first = GetExecutionStep(executionSteps.Allocate()); - first->parent = root; - first->et_i.startTrace = taFirst->allocatedIndex; - first->et_i.startIns = ta->prefix; - first->et_i.endTrace = taFirst->allocatedIndex; - first->et_i.endIns = taFirstExec->insLists.c3 - 1; - - // run from successor to the end - BuildStepTree( - successor, 0, - taLast, taLastExec->insLists.c3 - ta->postfix - 1, - root, firstLeaf, first, currentLeaf - ); - } - } - else - { - // if the first ambiguous instruction is in successor traces - - // traverse all successors - auto successorId = taFirst->successors.first; - while (successorId != nullref) - { - auto successor = GetTrace(successorId); - successorId = successor->successors.siblingNext; - if (checkCoveredMark && GetTraceExec(successor->traceExecRef)->ambiguityCoveredInForward != ta) - { - continue; - } - - // run from the first ambiguous instruction to the last - BuildStepTree( - successor, ta->prefix - taFirstExec->insLists.c3, - taLast, taLastExec->insLists.c3 - ta->postfix - 1, - root, firstLeaf, root, currentLeaf - ); - } - } - - // create the ResolveAmbiguity step - auto stepRA = GetExecutionStep(executionSteps.Allocate()); - stepRA->type = ExecutionType::ResolveAmbiguity; - stepRA->et_ra.count = 0; - stepRA->et_ra.type = -1; - stepRA->et_ra.trace = taLast->allocatedIndex; - { - Ref currentLeafRef = firstLeaf; - while (currentLeafRef != nullref) - { - stepRA->et_ra.count++; - currentLeafRef = GetExecutionStep(currentLeafRef)->next; - } - } - { - CHECK_ERROR(typeCallback != nullptr, ERROR_MESSAGE_PREFIX L"Missing ITypeCallback to resolve the type from multiple objects."); - auto linkRef = ta->bottomObjectIds; - while (linkRef != nullref) - { - auto link = GetInsExec_ObjRefLink(linkRef); - linkRef = link->previous; - - auto ieObject = GetInsExec_Object(link->id); - auto ieTrace = GetTrace(ieObject->createInsRef.trace); - auto ieTraceExec = GetTraceExec(ieTrace->traceExecRef); - - auto&& ins = ReadInstruction(ieObject->createInsRef.ins, ieTraceExec->insLists); - if (stepRA->et_ra.type == -1) - { - stepRA->et_ra.type = ins.param; - } - else if (stepRA->et_ra.type != ins.param) - { - vint32_t baseClass = typeCallback->FindCommonBaseClass(stepRA->et_ra.type, ins.param); - if (baseClass == -1) - { - throw UnableToResolveAmbiguityException( - WString::Unmanaged(L"Unable to resolve ambiguity from ") + - typeCallback->GetClassName(stepRA->et_ra.type) + - WString::Unmanaged(L" and ") + - typeCallback->GetClassName(ins.param) + - WString::Unmanaged(L"."), - stepRA->et_ra.type, - ins.param, - EnsureTraceWithValidStates(taFirst)->currentTokenIndex, - EnsureTraceWithValidStates(taLast)->currentTokenIndex - ); - } - stepRA->et_ra.type = baseClass; - } - } - } - - // append the ResolveAmbiguity step to the step tree - ConvertStepTreeToLink(root, firstLeaf, first, last); - - auto current = first; - while (current != last) - { - auto next = GetExecutionStep(current->next); - current->next = nullref; - next->parent = current; - current = next; - } - - stepRA->parent = last; - last = stepRA; -#undef ERROR_MESSAGE_PREFIX + return BuildStepListUntilFirstRawBranchTrace(startTrace, startIns, endTrace, endIns, guidance, nullptr); } /*********************************************************************** @@ -5881,30 +5823,25 @@ BuildExecutionOrder void TraceManager::BuildExecutionOrder() { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::BuildExecutionOrder()#" // get the instruction range auto startTrace = initialTrace; vint32_t startIns = 0; auto endTrace = concurrentTraces->Get(0); - vint32_t endIns = GetTraceExec(endTrace->traceExecRef)->insLists.c3 - 1; + vint32_t endIns = GetTraceExec(endTrace->traceExecRef)->insLists.countAll - 1; - // build step tree - ExecutionStep* root = nullptr; - ExecutionStep* firstLeaf = nullptr; - ExecutionStep* currentLeaf = nullptr; - BuildStepTree(startTrace, startIns, endTrace, endIns, root, firstLeaf, nullptr, currentLeaf); - - // BuildAmbiguousStepLink should have merged a tree to a link - CHECK_ERROR(firstLeaf != nullptr, ERROR_MESSAGE_PREFIX L"Ambiguity is not fully identified."); - CHECK_ERROR(firstLeaf->next == nullref, ERROR_MESSAGE_PREFIX L"Ambiguity is not fully identified."); - - // fill firstStep - ExecutionStep* first = nullptr; - ExecutionStep* last = nullptr; - ConvertStepTreeToLink(root, firstLeaf, first, last); - firstStep = first; -#undef ERROR_MESSAGE_PREFIX + auto steps = BuildStepList(startTrace, startIns, endTrace, endIns, nullptr); + { + auto current = steps.last; + while (current != steps.first) + { + auto parent = GetExecutionStep(current->parent); + parent->next = current; + current = parent; + } + } + firstStep = steps.first; } +#undef TRACE_MAMAGER_PHRASE } } } @@ -5916,10 +5853,6 @@ BuildExecutionOrder .\TRACEMANAGER\TMRA_CHECKMERGETRACES.CPP ***********************************************************************/ -#if defined VCZH_MSVC && defined _DEBUG -#define VCZH_DO_DEBUG_CHECK -#endif - namespace vl { namespace glr @@ -5931,20 +5864,20 @@ namespace vl #define NEW_MERGE_STACK_MAGIC_COUNTER (void)(MergeStack_MagicCounter++) /*********************************************************************** -CheckMergeTrace +CheckAmbiguityResolution ***********************************************************************/ template - bool TraceManager::EnumerateObjects(Ref objRefLinkStartSet, bool withCounter, TCallback&& callback) + bool TraceManager::EnumerateObjects(Ref stackRefLinkStartSet, bool withCounter, TCallback&& callback) { // check every object in the link auto magicIterating = MergeStack_MagicCounter; - auto linkId = objRefLinkStartSet; + auto linkId = stackRefLinkStartSet; while (linkId != nullref) { - auto objRefLink = GetInsExec_ObjRefLink(linkId); - linkId = objRefLink->previous; - auto ieObject = GetInsExec_Object(objRefLink->id); + auto stackRefLink = GetInsExec_StackRefLink(linkId); + linkId = stackRefLink->previous; + auto ieObject = GetInsExec_Stack(stackRefLink->id); if (withCounter) { @@ -5960,21 +5893,22 @@ CheckMergeTrace } template - bool TraceManager::EnumerateBottomInstructions(InsExec_Object* ieObject, TCallback&& callback) + bool TraceManager::EnumerateBottomInstructions(InsExec_Stack* ieObject, TCallback&& callback) { - auto insRefLinkId = ieObject->bottomInsRefs; + auto insRefLinkId = ieObject->summarizing.bottomInsRefs; while (insRefLinkId != nullref) { auto insRefLink = GetInsExec_InsRefLink(insRefLinkId); insRefLinkId = insRefLink->previous; if (!callback(GetTrace(insRefLink->insRef.trace), insRefLink->insRef.ins)) return false; } + return true; } bool TraceManager::ComparePrefix(TraceExec* baselineTraceExec, TraceExec* commingTraceExec, vint32_t prefix) { - if (commingTraceExec->insLists.c3 < prefix) return false; + if (commingTraceExec->insLists.countAll < prefix) return false; for (vint32_t i = 0; i < prefix; i++) { auto&& insBaseline = ReadInstruction(i, baselineTraceExec->insLists); @@ -5987,11 +5921,11 @@ CheckMergeTrace bool TraceManager::ComparePostfix(TraceExec* baselineTraceExec, TraceExec* commingTraceExec, vint32_t postfix) { - if (commingTraceExec->insLists.c3 < postfix) return false; + if (commingTraceExec->insLists.countAll < postfix) return false; for (vint32_t i = 0; i < postfix; i++) { - auto&& insBaseline = ReadInstruction(baselineTraceExec->insLists.c3 - i - 1, baselineTraceExec->insLists); - auto&& insComming = ReadInstruction(baselineTraceExec->insLists.c3 - i - 1, baselineTraceExec->insLists); + auto&& insBaseline = ReadInstruction(baselineTraceExec->insLists.countAll - i - 1, baselineTraceExec->insLists); + auto&& insComming = ReadInstruction(baselineTraceExec->insLists.countAll - i - 1, baselineTraceExec->insLists); if (insBaseline != insComming) return false; } @@ -5999,18 +5933,17 @@ CheckMergeTrace } template - bool TraceManager::CheckAmbiguityResolution(TraceAmbiguity* ta, collections::List>& visitingIds, TCallback&& callback) + bool TraceManager::CheckAmbiguityResolution(TraceAmbiguity* ta, collections::List>& visitingIds, collections::List* failureReasons, TCallback&& callback) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::CheckAmbiguityResolution(TraceAmbiguity&, List&, TCallback&&)#" // following conditions need to be satisfies if multiple objects could be the result of ambiguity // - // BO/DFA that create objects must be + // StackBegin that create objects must be // the same instruction in the same trace // in different trace // these traces share the same predecessor // prefix in these traces are the same // - // EO that ed objects must be + // StackEnd that end objects must be // the same instruction in the same trace // in different trace // these traces share the same successor @@ -6021,38 +5954,92 @@ CheckMergeTrace Trace* last = nullptr; TraceExec* firstTraceExec = nullptr; TraceExec* lastTraceExec = nullptr; - bool foundBeginSame = false; - bool foundBeginPrefix = false; + + vint firstTraceCount = 0; + vint firstSameTraceCount = 0; + vint firstSamePredecessorCount = 0; + bool foundEndSame = false; bool foundEndPostfix = false; bool succeeded = false; // iterate all top objects - succeeded = callback([&](Ref objRefLink) + if (failureReasons) { - return EnumerateObjects(objRefLink, false, [&](InsExec_Object* ieObject) + failureReasons->Add(L"[InsExec_Stack->summarizing.earliestInsRef]"); + } + succeeded = callback([&](Ref objRefLink) + { + return EnumerateObjects(objRefLink, false, [&](InsExec_Stack* ieObject) { - auto createTrace = GetTrace(ieObject->topInsRef.trace); + auto createTrace = GetTrace(ieObject->summarizing.earliestInsRef.trace); + if (failureReasons) + { + failureReasons->Add(L" Verifying object " + + itow(ieObject->allocatedIndex) + + L", its earliestInsRef is " + + itow(ieObject->summarizing.earliestInsRef.trace.handle) + L"@" + itow(ieObject->summarizing.earliestInsRef.ins) + + L"."); + } if (!first) { first = createTrace; firstTraceExec = GetTraceExec(first->traceExecRef); ta->firstTrace = createTrace; - ta->prefix = ieObject->topInsRef.ins; - } - else if (first == createTrace) - { - // check if two instruction is the same - if (ta->prefix != ieObject->topInsRef.ins) return false; - foundBeginSame = true; + ta->prefix = ieObject->summarizing.earliestInsRef.ins; + if (failureReasons) + { + failureReasons->Add(L" This is the first object in the list."); + } } else { - // check if two instruction shares the same prefix - if (first->predecessors.first != createTrace->predecessors.first) return false; - auto createTraceExec = GetTraceExec(createTrace->traceExecRef); - if (!ComparePrefix(firstTraceExec, createTraceExec, ta->prefix)) return false; - foundBeginPrefix = true; + firstTraceCount++; + + if (first == createTrace) + { + // check if two instruction is the same + if (ta->prefix != ieObject->summarizing.earliestInsRef.ins) + { + if (failureReasons) + { + failureReasons->Add(L" It has a different prefix, stopped."); + } + return false; + } + firstSameTraceCount++; + } + + if (first->predecessors.first == createTrace->predecessors.first) + { + // check if two instruction shares the same prefix + if (first->predecessors.first != createTrace->predecessors.first) + { + } + auto createTraceExec = GetTraceExec(createTrace->traceExecRef); + if (!ComparePrefix(firstTraceExec, createTraceExec, ta->prefix)) + { + if (failureReasons) + { + failureReasons->Add(L" They has a different postfix, stopped"); + } + return false; + } + firstSamePredecessorCount++; + } + + if (first != createTrace && first->predecessors.first != createTrace->predecessors.first) + { + if (failureReasons) + { + failureReasons->Add(L" The predecessor of the trace where the earliestInsRef of the first object is " + + itow(first->predecessors.first.handle) + + L", meanwhile the one for the current object is " + + itow(createTrace->predecessors.first.handle) + + L", they are different, stopped."); + } + return false; + } } return true; @@ -6062,25 +6049,41 @@ CheckMergeTrace // iterate all bottom instructions { - // bottomInsRefs need to be filtered again + if (failureReasons) + { + failureReasons->Add(L"[InsExec_Stack->endWithCreateInsRefs/endWithReuseInsRefs]"); + } + // endWith(Create|Reuse)InsRefs need to be filtered again // because the object from the first branch could be a field in the object from the second branch - // in this case, that object could have multiple incompatible bottomInsRefs + // in this case, that object could have multiple incompatible endWith(Create|Reuse)InsRefs // so we try eoTrace and the unique and existing eoTrace->successors.first // see which wins Group postfixesAtSelf, postfixesAtSuccessor; NEW_MERGE_STACK_MAGIC_COUNTER; - callback([&](Ref objRefLink) + callback([&](Ref objRefLink) { - return EnumerateObjects(objRefLink, true, [&](InsExec_Object* ieObject) + return EnumerateObjects(objRefLink, true, [&](InsExec_Stack* ieObject) { - PushObjRefLink(ta->bottomObjectIds, ieObject); + if (failureReasons) + { + failureReasons->Add(L" Verifying object " + + itow(ieObject->allocatedIndex) + + L" which has StackEnd instructions:"); + } + PushStackRefLink(ta->bottomCreateObjectStacks, ieObject); // check if EO satisfies the condition return EnumerateBottomInstructions(ieObject, [&](Trace* eoTrace, vint32_t eoIns) { + if (failureReasons) + { + failureReasons->Add(L" " + + itow(eoTrace->allocatedIndex) + L"@" + itow(eoIns) + + L"."); + } auto eoTraceExec = GetTraceExec(eoTrace->traceExecRef); - InsRef insRef{ eoTrace,eoTraceExec->insLists.c3 - eoIns - 1 }; + InsRef insRef{ eoTrace,eoTraceExec->insLists.countAll - eoIns - 1 }; postfixesAtSelf.Add(eoTrace, insRef); Trace* successorTrace = nullptr; @@ -6094,6 +6097,33 @@ CheckMergeTrace }); }); + if (failureReasons) + { + failureReasons->Add(L" [postfixesAtSelf]"); + for (vint i = 0; i < postfixesAtSelf.Count(); i++) + { + auto key = postfixesAtSelf.Keys()[i]; + WString message = L" " + itow(key ? key->allocatedIndex : -1) + L" ->"; + for (auto&& value : postfixesAtSelf.GetByIndex(i)) + { + message += L" " + itow(value.trace.handle) + L"@-" + itow(value.ins); + } + failureReasons->Add(message); + } + + failureReasons->Add(L" [postfixesAtSuccessor]"); + for (vint i = 0; i < postfixesAtSuccessor.Count(); i++) + { + auto key = postfixesAtSuccessor.Keys()[i]; + WString message = L" " + itow(key ? key->allocatedIndex : -1) + L" ->"; + for (auto&& value : postfixesAtSuccessor.GetByIndex(i)) + { + message += L" " + itow(value.trace.handle) + L"@-" + itow(value.ins); + } + failureReasons->Add(message); + } + } + // find the most possible answer from postfixesAtSelf and postfixesAtSuccessor // bottom bottomInsRefs are splitted into multiple group // find the unique one that has the maximum capacity @@ -6163,8 +6193,20 @@ CheckMergeTrace foundEndPostfix = true; } + if (failureReasons) + { + failureReasons->Add(L" [unique possible largest group]"); + failureReasons->Add(L" postfixesAtSelf -> " + itow(uniqueAtSelf)); + failureReasons->Add(L" postfixesAtSuccessor -> " + itow(uniqueAtSuccessor)); + failureReasons->Add(L" lastPostfix -> " + itow(lastPostfix.trace.handle) + L"@" + itow(lastPostfix.ins)); + } + if (lastPostfix.trace == nullref) { + if (failureReasons) + { + failureReasons->Add(L" lastPostfix has an empty trace, stopped."); + } succeeded = false; } else @@ -6178,19 +6220,37 @@ CheckMergeTrace } if (!succeeded) return false; + if (failureReasons) + { + failureReasons->Add(L"[TraceAmbiguity]"); + } + // ensure the statistics result is compatible - if (first && !foundBeginSame && !foundBeginPrefix) foundBeginSame = true; if (last && !foundEndSame && !foundEndPostfix) foundEndSame = true; - if (foundBeginSame == foundBeginPrefix) return false; - if (foundEndSame == foundEndPostfix) return false; + if (firstTraceCount != firstSameTraceCount && firstTraceCount != firstSamePredecessorCount) + { + if (failureReasons) + { + failureReasons->Add(L"Some StackBegin instructions share the same trace while some share the same predecessor, stopped."); + } + return false; + } + if (foundEndSame == foundEndPostfix) + { + if (failureReasons) + { + failureReasons->Add(L"Some StackEnd instructions share the same trace while some share the same successor, stopped."); + } + return false; + } // fix prefix if necessary - if (foundBeginPrefix) + if (firstTraceCount != firstSameTraceCount) { auto first = GetTrace(GetTrace(ta->firstTrace)->predecessors.first); auto traceExec = GetTraceExec(first->traceExecRef); ta->firstTrace = first; - ta->prefix += traceExec->insLists.c3; + ta->prefix += traceExec->insLists.countAll; } // fix postfix if necessary @@ -6206,11 +6266,26 @@ CheckMergeTrace // ensure firstTrace and lastTrace are in the same branch auto firstForward = GetTrace(GetTraceExec(GetTrace(ta->firstTrace)->traceExecRef)->branchData.forwardTrace); auto lastForward = GetTrace(GetTraceExec(GetTrace(ta->lastTrace)->traceExecRef)->branchData.forwardTrace); + + if (failureReasons) + { + failureReasons->Add(L"firstTrace: " + itow(ta->firstTrace.handle)); + failureReasons->Add(L"prefix: " + itow(ta->prefix)); + failureReasons->Add(L"lastTrace: " + itow(ta->lastTrace.handle)); + failureReasons->Add(L"postfix: " + itow(ta->postfix)); + failureReasons->Add(L"firstForward: " + itow(firstForward->allocatedIndex)); + failureReasons->Add(L"lastForward (currentForward): " + itow(lastForward->allocatedIndex)); + } + auto currentForward = lastForward; while (true) { if (currentForward->traceExecRef < firstForward->traceExecRef) { + if (failureReasons) + { + failureReasons->Add(L"currentForward is before firstForward, stopped."); + } return false; } if (currentForward == firstForward) @@ -6229,30 +6304,61 @@ CheckMergeTrace if (currentForward != nextForward) { currentForward = nextForward; + if (failureReasons) + { + failureReasons->Add(L"currentForward steps forward to: " + + itow(currentForward->allocatedIndex) + + L"."); + } } else if (currentForward->predecessorCount > 0) { currentForward = GetTrace(GetTraceExec(GetTrace(currentForward->predecessors.first)->traceExecRef)->branchData.forwardTrace); + if (failureReasons) + { + failureReasons->Add(L"currentForward steps forward passing a branch to: " + + itow(currentForward->allocatedIndex) + + L"."); + } } else { + if (failureReasons) + { + failureReasons->Add(L"currentForward reaches the beginning of the trace, stopped."); + } break; } } + return false; -#undef ERROR_MESSAGE_PREFIX } - bool TraceManager::CheckMergeTrace(TraceAmbiguity* ta, Trace* trace, TraceExec* traceExec, collections::List>& visitingIds) +/*********************************************************************** +CheckSingleMergeTrace +***********************************************************************/ + + bool TraceManager::CheckSingleMergeTrace(TraceAmbiguity* ta, Trace* trace, TraceExec* traceExec, collections::List>& visitingIds, collections::List* failureReasons) { - // when a merge trace is the surviving trace + if (failureReasons) + { + failureReasons->Add(L"Trying to merge trace " + + itow(trace->allocatedIndex) + + L"."); + } + + // when a merge trace is the last trace // objects in the top object stack are the result of ambiguity if (trace->successorCount == 0) { - auto ieOSTop = GetInsExec_ObjectStack(traceExec->context.objectStack); - return CheckAmbiguityResolution(ta, visitingIds, [=](auto&& callback) + if (failureReasons) { - return callback(ieOSTop->objectIds); + failureReasons->Add(L"This is the last trace, compare all concurrent objects in the objectStack top."); + } + auto ieOSTop = GetInsExec_StackArrayRefLink(traceExec->context.objectStack); + return CheckAmbiguityResolution(ta, visitingIds, failureReasons, [=](auto&& callback) + { + return callback(ieOSTop->ids); }); } @@ -6267,28 +6373,44 @@ CheckMergeTrace { // [CONDITION] - // the first predecessor must has a EndObject instruction - // count the number of instructions after EndObject + // the first predecessor must has a StackEnd instruction + // count the number of instructions after StackEnd // these instructions are the postfix vint32_t postfix = -1; auto firstTrace = GetTrace(trace->predecessors.first); auto firstTraceExec = GetTraceExec(firstTrace->traceExecRef); - for (vint32_t i = firstTraceExec->insLists.c3 - 1; i >= 0; i--) + for (vint32_t i = firstTraceExec->insLists.countAll - 1; i >= 0; i--) { auto&& ins = ReadInstruction(i, firstTraceExec->insLists); - if (ins.type == AstInsType::EndObject) + if (ins.type == AstInsType::StackEnd) { - postfix = firstTraceExec->insLists.c3 - i - 1; + postfix = firstTraceExec->insLists.countAll - i - 1; break; } } if (postfix == -1) { + if (failureReasons) + { + failureReasons->Add(L"The first predecessor " + + itow(firstTrace->allocatedIndex) + + L" has no StackEnd."); + } + goto CHECK_OBJECTS_IN_TOP_CREATE_STACK; } + if (failureReasons) + { + failureReasons->Add(L"The first predecessor " + + itow(firstTrace->allocatedIndex) + + L" has StackEnd, its postfix is " + + itow(postfix) + + L"."); + } + // [CONDITION] - // all predecessor must have a EndObject instruction + // all predecessor must have a StackEnd instruction // posftix of all predecessors must be the same { auto predecessorId = trace->predecessors.last; @@ -6298,27 +6420,41 @@ CheckMergeTrace predecessorId = predecessor->predecessors.siblingPrev; if (!ComparePostfix(firstTraceExec, GetTraceExec(predecessor->traceExecRef), postfix + 1)) { + if (failureReasons) + { + failureReasons->Add(L"Another predecessor " + + itow(predecessor->allocatedIndex) + + L" has no StackEnd or has a different postfix."); + } goto CHECK_OBJECTS_IN_TOP_CREATE_STACK; } } } - // check if all EndObject ended objects are the result of ambiguity + // check if all StackEnd ended objects are the result of ambiguity if (postfix == 0) { - // if EndObject is the last instruction of predecessors + // if StackEnd is the last instruction of predecessors // then their objRefs has been written to the top object stack - auto ieOSTop = GetInsExec_ObjectStack(traceExec->context.objectStack); - auto succeeded = CheckAmbiguityResolution(ta, visitingIds, [=](auto&& callback) + if (failureReasons) { - return callback(ieOSTop->objectIds); + failureReasons->Add(L"The postfix is 0, compare all concurrent objects in the objectStack top."); + } + auto ieOSTop = GetInsExec_StackArrayRefLink(traceExec->context.objectStack); + auto succeeded = CheckAmbiguityResolution(ta, visitingIds, failureReasons, [=](auto&& callback) + { + return callback(ieOSTop->ids); }); if (succeeded) return true; } else { - // otherwise find all objRefs of EndObject - auto succeeded = CheckAmbiguityResolution(ta, visitingIds, [=, this, &visitingIds](auto&& callback) + // otherwise find all objRefs of StackEnd + if (failureReasons) + { + failureReasons->Add(L"The postfix > 0, compare all concurrent objects in all StackEnd instructions."); + } + auto succeeded = CheckAmbiguityResolution(ta, visitingIds, failureReasons, [=, this, &visitingIds](auto&& callback) { auto predecessorId = trace->predecessors.first; while (predecessorId != nullref) @@ -6327,10 +6463,16 @@ CheckMergeTrace predecessorId = predecessor->predecessors.siblingNext; // search for the object it ends + if (failureReasons) + { + failureReasons->Add(L"Verifying predecessor " + + itow(predecessor->allocatedIndex) + + L"."); + } auto predecessorTraceExec = GetTraceExec(predecessor->traceExecRef); - auto indexEO = predecessorTraceExec->insLists.c3 - postfix - 1; + auto indexEO = predecessorTraceExec->insLists.countAll - postfix - 1; auto insExecEO = GetInsExec(predecessorTraceExec->insExecRefs.start + indexEO); - if (!callback(insExecEO->objRefs)) return false; + if (!callback(insExecEO->operatingStacks)) return false; } return true; }); @@ -6338,10 +6480,14 @@ CheckMergeTrace } } CHECK_OBJECTS_IN_TOP_CREATE_STACK: - auto ieCSTop = GetInsExec_CreateStack(traceExec->context.createStack); - return CheckAmbiguityResolution(ta, visitingIds, [=](auto&& callback) + if (failureReasons) { - return callback(ieCSTop->objectIds); + failureReasons->Add(L"All condition dissatisfied, compare all concurrent objects in the createStack top."); + } + auto ieCSTop = GetInsExec_StackArrayRefLink(traceExec->context.createStack); + return CheckAmbiguityResolution(ta, visitingIds, failureReasons, [=](auto&& callback) + { + return callback(ieCSTop->ids); }); } @@ -6374,7 +6520,7 @@ CheckTraceAmbiguity void TraceManager::CheckTraceAmbiguity(TraceAmbiguity* ta) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::CheckTraceAmbiguity(TraceAmbiguity*)#" +#define TRACE_MAMAGER_PHRASE L"ResolveAmbiguity/CheckMergeTraces/CheckTraceAmbiguity" auto teFirst = GetTraceExec(GetTrace(ta->firstTrace)->traceExecRef); if (teFirst->ambiguityBegins == nullref) @@ -6404,10 +6550,10 @@ CheckTraceAmbiguity // if there is a TraceAmbiguity to override // ensure they are equivalent auto ta2 = GetTraceAmbiguity(taLinkToOverride->ambiguity); -#ifdef VCZH_DO_DEBUG_CHECK - CHECK_ERROR(ta2->prefix == ta->prefix, ERROR_MESSAGE_PREFIX L"Incompatible TraceAmbiguity has been assigned at the same place."); - CHECK_ERROR(ta2->postfix == ta->postfix, ERROR_MESSAGE_PREFIX L"Incompatible TraceAmbiguity has been assigned at the same place."); -#endif + if (ta2->prefix != ta->prefix || ta2->postfix != ta->postfix) + { + throw TraceException(*this, ta, ta2, TRACE_MAMAGER_PHRASE, L"Incompatible TraceAmbiguity has been assigned at the same place"); + } // override ambiguityBegins taLinkToOverride->ambiguity = ta; @@ -6422,54 +6568,23 @@ CheckTraceAmbiguity taLink->previous = teFirst->ambiguityBegins; teFirst->ambiguityBegins = taLink; } -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } -/*********************************************************************** -DebugCheckTraceAmbiguityInSameTrace -***********************************************************************/ - -#ifdef VCZH_DO_DEBUG_CHECK - void TraceManager::DebugCheckTraceAmbiguitiesInSameTrace(Trace* trace, TraceExec* traceExec) - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::DebugCheckTraceAmbiguityInSameTrace(Trace*, TraceExec*)#" - - // if there are multiple ambiguityBegins - // first ambiguity instructions must all be in successors - vint faiInBranch = 0; - vint faiInSuccessor = 0; - auto taLinkRef = traceExec->ambiguityBegins; - while (taLinkRef != nullref) - { - auto taLink = GetTraceAmbiguityLink(taLinkRef); - taLinkRef = taLink->previous; - - auto ta = GetTraceAmbiguity(taLink->ambiguity); - if (ta->prefix >= traceExec->insLists.c3) - { - faiInSuccessor++; - } - else - { - faiInBranch++; - } - } - CHECK_ERROR((faiInBranch == 1 && faiInSuccessor == 0) || faiInBranch == 0, ERROR_MESSAGE_PREFIX L"Incompatible TraceAmbiguity has been assigned at the same place."); -#undef ERROR_MESSAGE_PREFIX - } -#endif - /*********************************************************************** CategorizeTraceAmbiguities ***********************************************************************/ void TraceManager::MarkAmbiguityCoveredForward(Trace* currentTrace, TraceAmbiguity* ta, Trace* firstTrace, TraceExec* firstTraceExec) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::MarkAmbiguityCoveredForward(Trace*, TraceAmbiguity*, Trace*, TraceExec*)#" +#define TRACE_MAMAGER_PHRASE L"ResolveAmbiguity/CheckMergeTraces/MarkAmbiguityCoveredForward" while (true) { auto forward = GetTrace(GetTraceExec(currentTrace->traceExecRef)->branchData.forwardTrace); - CHECK_ERROR(forward->traceExecRef > firstTraceExec, ERROR_MESSAGE_PREFIX L"Unexpected ambiguity resolving structure found."); + if (forward->traceExecRef <= firstTraceExec) + { + throw TraceException(*this, forward, nullptr, TRACE_MAMAGER_PHRASE, L"Unexpected ambiguity resolving structure found."); + } auto forwardExec = GetTraceExec(forward->traceExecRef); if (forward->predecessors.first != forward->predecessors.last) @@ -6490,19 +6605,16 @@ CategorizeTraceAmbiguities return; } } - else if (forward->predecessors.first == firstTrace) - { - auto forwardExec = GetTraceExec(forward->traceExecRef); - CHECK_ERROR(forwardExec->ambiguityCoveredInForward == nullref || forwardExec->ambiguityCoveredInForward == ta, L"Unexpected ambiguity resolving structure found."); - forwardExec->ambiguityCoveredInForward = ta; - return; - } - else + else if (forward->predecessors.first != firstTrace) { currentTrace = GetTrace(forward->predecessors.first); } + else + { + return; + } } -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } void TraceManager::CategorizeTraceAmbiguities(Trace* trace, TraceExec* traceExec) @@ -6515,7 +6627,7 @@ CategorizeTraceAmbiguities taLinkRef = taLink->previous; auto ta = GetTraceAmbiguity(taLink->ambiguity); - if (ta->prefix >= traceExec->insLists.c3) + if (ta->prefix >= traceExec->insLists.countAll) { // mark ambiguityCoveredInForward MarkAmbiguityCoveredForward(GetTrace(ta->lastTrace), ta, trace, traceExec); @@ -6529,7 +6641,7 @@ CheckMergeTraces void TraceManager::CheckMergeTraces() { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::CheckMergeTraces()#" +#define TRACE_MAMAGER_PHRASE L"ResolveAmbiguity/CheckMergeTraces" // mark all branch trace critical { auto traceId = firstBranchTrace; @@ -6557,7 +6669,7 @@ CheckMergeTraces } // iterating TraceMergeExec - List> visitingIds; + List> visitingIds; auto traceId = firstMergeTrace; while (traceId != nullref) { @@ -6566,10 +6678,96 @@ CheckMergeTraces traceId = traceExec->nextMergeTrace; auto ta = GetTraceAmbiguity(traceAmbiguities.Allocate()); - bool succeeded = CheckMergeTrace(ta, trace, traceExec, visitingIds); - CHECK_ERROR(succeeded, ERROR_MESSAGE_PREFIX L"Failed to find ambiguous objects in a merge trace."); + bool succeeded = CheckSingleMergeTrace(ta, trace, traceExec, visitingIds, nullptr); + if (!succeeded) + { + List failureReasons; + CheckSingleMergeTrace(ta, trace, traceExec, visitingIds, &failureReasons); + + throw TraceException(*this, trace, nullptr, TRACE_MAMAGER_PHRASE, stream::GenerateToStream([&](stream::TextWriter& writer) + { + writer.WriteLine(L"Failed to find ambiguous objects in a merge trace."); + writer.WriteLine(L"[Details]"); + for (auto&& reason : failureReasons) + { + writer.WriteLine(reason); + } + })); + } traceExec->ambiguityDetected = ta; + // record branch and merge trace + ta->mergeTrace = trace; + { + auto currentBranchTrace = trace; + auto predecessorRef = trace->predecessors.first; + while (predecessorRef != nullref) + { + // when traces look like this + // the first predecessor locates B while the correct one should be A + // so all predecessors need to test + // + // A + // | + // +-+-+ + // | | + // B C + // | | + // +-+ | + // | | | + // D E F + // | | | + // +-+-+ + // | + // G + + auto predecessor = GetTrace(predecessorRef); + predecessorRef = predecessor->predecessors.siblingNext; + + Trace* branchTrace = nullptr; + auto predecessorForward = GetTrace(GetTraceExec(predecessor->traceExecRef)->branchData.forwardTrace); + if (predecessorForward->predecessors.first == predecessorForward->predecessors.last) + { + branchTrace = predecessorForward; + } + else + { + branchTrace = GetTrace(GetTraceExec(predecessorForward->traceExecRef)->branchData.commonForwardBranch); + } + + // when traces look like this + // some branchTrace may be the root, ignores + // + // A + // | + // +-+-+ + // | | | + // B C D + // | | | + // +-+ | + // | | + // E F + // | | + // +---+ + // | + // G + + if (branchTrace->predecessors.first != nullref) + { + branchTrace = GetTrace(branchTrace->predecessors.first); + if (currentBranchTrace->traceExecRef > branchTrace->traceExecRef) + { + currentBranchTrace = branchTrace; + } + } + } + ta->branchTrace = currentBranchTrace; + } + if (ta->firstTrace == ta->mergeTrace) + { + throw TraceException(*this, trace, nullptr, TRACE_MAMAGER_PHRASE, L"Failed to find TraceAmbiguity::branchTrace."); + } + // check if existing TraceAmbiguity in firstTrace are compatible CheckTraceAmbiguity(ta); } @@ -6585,14 +6783,11 @@ CheckMergeTraces if (traceExec->ambiguityBegins != nullref) { -#ifdef VCZH_DO_DEBUG_CHECK - DebugCheckTraceAmbiguitiesInSameTrace(trace, traceExec); -#endif CategorizeTraceAmbiguities(trace, traceExec); } } } -#undef ERROR_MESSAGE_PREFIX +#undef TRACE_MAMAGER_PHRASE } #undef NEW_MERGE_STACK_MAGIC_COUNTER @@ -6600,10 +6795,6 @@ CheckMergeTraces } } -#if defined VCZH_MSVC && defined _DEBUG -#undef VCZH_DO_DEBUG_CHECK -#endif - /*********************************************************************** .\TRACEMANAGER\TRACEMANAGER.CPP ***********************************************************************/ @@ -6731,11 +6922,10 @@ TraceManager , competitions(blockSize) , attendingCompetitions(blockSize) , traceExecs(blockSize) - , insExec_Objects(blockSize) + , insExec_Stacks(blockSize) , insExec_InsRefLinks(blockSize) - , insExec_ObjRefLinks(blockSize) - , insExec_ObjectStacks(blockSize) - , insExec_CreateStacks(blockSize) + , insExec_StackRefLinks(blockSize) + , insExec_StackArrayRefLinks(blockSize) , traceAmbiguities(blockSize) , traceAmbiguityLinks(blockSize) , executionSteps(blockSize) @@ -6786,10 +6976,10 @@ TraceManager { return &insExecs[index]; } - - InsExec_Object* TraceManager::GetInsExec_Object(Ref index) + + InsExec_Stack* TraceManager::GetInsExec_Stack(Ref index) { - return insExec_Objects.Get(index); + return insExec_Stacks.Get(index); } InsExec_InsRefLink* TraceManager::GetInsExec_InsRefLink(Ref index) @@ -6797,19 +6987,14 @@ TraceManager return insExec_InsRefLinks.Get(index); } - InsExec_ObjRefLink* TraceManager::GetInsExec_ObjRefLink(Ref index) + InsExec_StackRefLink* TraceManager::GetInsExec_StackRefLink(Ref index) { - return insExec_ObjRefLinks.Get(index); + return insExec_StackRefLinks.Get(index); } - InsExec_ObjectStack* TraceManager::GetInsExec_ObjectStack(Ref index) + InsExec_StackArrayRefLink* TraceManager::GetInsExec_StackArrayRefLink(Ref index) { - return insExec_ObjectStacks.Get(index); - } - - InsExec_CreateStack* TraceManager::GetInsExec_CreateStack(Ref index) - { - return insExec_CreateStacks.Get(index); + return insExec_StackArrayRefLinks.Get(index); } TraceExec* TraceManager::GetTraceExec(Ref index) @@ -6861,18 +7046,15 @@ ReadInstructionList void TraceManager::ReadInstructionList(Trace* trace, TraceInsLists& insLists) { // this function collects the following instructions in order: - // 1) byEdge.insBeforeInput // 2) byEdge.insAfterInput // 3) executedReturnStack.returnIndex.insAfterInput in order if (trace->byEdge != -1) { auto& edgeDesc = executable.edges[trace->byEdge]; - insLists.edgeInsBeforeInput = edgeDesc.insBeforeInput; insLists.edgeInsAfterInput = edgeDesc.insAfterInput; } else { - insLists.edgeInsBeforeInput = {}; insLists.edgeInsAfterInput = {}; } if (trace->executedReturnStack != nullref) @@ -6886,9 +7068,8 @@ ReadInstructionList insLists.returnInsAfterInput = {}; } - insLists.c1 = (vint32_t)(insLists.edgeInsBeforeInput.count); - insLists.c2 = (vint32_t)(insLists.c1 + insLists.edgeInsAfterInput.count); - insLists.c3 = (vint32_t)(insLists.c2 + insLists.returnInsAfterInput.count); + insLists.countAfterInput = (vint32_t)(insLists.edgeInsAfterInput.count); + insLists.countAll = (vint32_t)(insLists.countAfterInput + insLists.returnInsAfterInput.count); } /*********************************************************************** @@ -6901,20 +7082,16 @@ ReadInstruction // the index is the instruction in a virtual instruction array // defined by all InstructionArray in TraceInsLists combined together #define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::ReadInstruction(vint, TraceInsLists&)#" - CHECK_ERROR(0 <= instruction && instruction < insLists.c3, ERROR_MESSAGE_PREFIX L"Instruction index out of range."); + CHECK_ERROR(0 <= instruction && instruction < insLists.countAll, ERROR_MESSAGE_PREFIX L"Instruction index out of range."); vint32_t insRef = -1; - if (instruction < insLists.c1) + if (instruction < insLists.countAfterInput) { - insRef = insLists.edgeInsBeforeInput.start + instruction; + insRef = insLists.edgeInsAfterInput.start + instruction; } - else if (instruction < insLists.c2) + else if (instruction < insLists.countAll) { - insRef = insLists.edgeInsAfterInput.start + (instruction - insLists.c1); - } - else if (instruction < insLists.c3) - { - insRef = insLists.returnInsAfterInput.start + (instruction - insLists.c2); + insRef = insLists.returnInsAfterInput.start + (instruction - insLists.countAfterInput); } else { @@ -6942,217 +7119,70 @@ namespace vl TraceManager::ExecuteTrace ***********************************************************************/ - struct TraceManagerSubmitter +#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::ExecuteTrace(Trace*, IAstInsReceiver&, List&)#" + + class AstInsOptimizer : public Object, public virtual IAstInsReceiver { - // LriFetch + LriStore - bool lriFetch = false; + protected: + IAstInsReceiver& receiver; - // AccumulatedDfa - vint32_t adfaCount = 0; - vint32_t adfaIndex = -1; - regex::RegexToken* adfaToken = nullptr; + bool cachedStackBegin = false; + const regex::RegexToken* cachedStackBeginToken = nullptr; + vint32_t cachedStackBeginTokenIndex = -1; - // AccumulatedEoRo - vint32_t aeoroCount = 0; - vint32_t aeoroIndex = -1; - regex::RegexToken* aeoroToken = nullptr; - - // Caching EndObject / LriFetch - AstIns cachedIns; - vint32_t cachedIndex = -1; - regex::RegexToken* cachedToken = nullptr; - - IAstInsReceiver* receiver = nullptr; - - void Submit(AstIns& ins, regex::RegexToken& token, vint32_t tokenIndex) + public: + AstInsOptimizer(IAstInsReceiver& _receiver) + :receiver(_receiver) { -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManagerSubmitter::Submit(AstIns&, RegexToken&, vint32_t)#" - // LriFetch+LriStore disappear - // multiple DelayFieldAssignment of the same token are compressed to single AccumulatedDfa - // multiple EndObject+ReopenObject of the same token are compressed to single AccumulatedEoRo - - // cache availability conditions - // lriFetch == true && cachedToken != nullptr - // one LriFetch instruction is cached - // cachedIns is the cached instruction - // { cachedToken,cachedIndex } is the token with this instruction - // lriFetch == false && cachedToken != nullptr - // one EndObject instruction is cached - // cachedIns is the cached instruction - // { cachedToken,cachedIndex } is the token with this instruction - // aeoroToken != nullptr - // aeoroCount EndObject+ReopenObject instruction pairs is cached - // { aeoroToken,aeoroIndex } is the token with this instruction - // adfaToken != nullptr - // aeoroCount DelayFieldAssignment instructions is cached - // { adfaToken,adfaIndex } is the token with this instruction - - bool cacheLf = lriFetch == true && cachedToken != nullptr; - bool cacheEo = lriFetch == false && cachedToken != nullptr; - bool cacheEoRo = aeoroToken != nullptr; - bool cacheDfa = adfaToken != nullptr; - bool cacheAvailable = cacheLf || cacheEo || cacheEoRo || cacheDfa; - CHECK_ERROR( - (!cacheLf && !cacheEo && !cacheEoRo && !cacheDfa) || - ( cacheLf && !cacheEo && !cacheEoRo && !cacheDfa) || - (!cacheLf && cacheEo && !cacheEoRo && !cacheDfa) || - (!cacheLf && !cacheEo && cacheEoRo && !cacheDfa) || - (!cacheLf && cacheEo && cacheEoRo && !cacheDfa) || - (!cacheLf && !cacheEo && !cacheEoRo && cacheDfa), - ERROR_MESSAGE_PREFIX L"Internal error: instruction cache corrupted." - ); - - // clear cache if it is unrelated to the current instruction - if (cacheAvailable) - { - bool cacheRelated = false; - - switch (ins.type) - { - case AstInsType::LriStore: - if (cacheLf) cacheRelated = true; - break; - case AstInsType::DelayFieldAssignment: - if (cacheDfa && adfaToken == &token) cacheRelated = true; - break; - case AstInsType::EndObject: - if ((cacheEoRo && aeoroToken == &token) && !cacheEo) cacheRelated = true; - break; - case AstInsType::ReopenObject: - if ((cacheEo && cachedToken == &token) && (!cacheEoRo || aeoroToken == &token)) cacheRelated = true; - break; - default:; - } - - if (!cacheRelated) - { - ExecuteSubmitted(); - cacheAvailable = false; - } - } - - if (cacheAvailable) - { - // execute instructions with cache - switch (ins.type) - { - case AstInsType::LriStore: - { - lriFetch = false; - cachedToken = nullptr; - } - break; - case AstInsType::DelayFieldAssignment: - { - adfaCount++; - } - break; - case AstInsType::EndObject: - { - cachedIns = ins; - cachedIndex = tokenIndex; - cachedToken = &token; - } - break; - case AstInsType::ReopenObject: - { - if (cacheEoRo) - { - aeoroCount++; - } - else - { - aeoroCount = 1; - aeoroIndex = tokenIndex; - aeoroToken = &token; - } - cachedToken = nullptr; - } - break; - default: - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Internal error: unrelated cache should have been cleared."); - } - } - else - { - // execute instructions without cache - switch (ins.type) - { - case AstInsType::LriFetch: - { - lriFetch = true; - cachedIns = ins; - cachedIndex = tokenIndex; - cachedToken = &token; - } - break; - case AstInsType::DelayFieldAssignment: - { - adfaCount = 1; - adfaIndex = tokenIndex; - adfaToken = &token; - } - break; - case AstInsType::EndObject: - { - cachedIns = ins; - cachedIndex = tokenIndex; - cachedToken = &token; - } - break; - default: - receiver->Execute(ins, token, tokenIndex); - } - } -#undef ERROR_MESSAGE_PREFIX } - void ExecuteSubmitted() + void Execute(AstIns instruction, const regex::RegexToken& token, vint32_t tokenIndex) override { - if (adfaToken) + if (cachedStackBegin) { - if (adfaCount == 1) + if (instruction.type == AstInsType::StackEnd) { - AstIns ins = { AstInsType::DelayFieldAssignment }; - receiver->Execute(ins, *adfaToken, adfaIndex); + cachedStackBegin = false; + return; } - else - { - AstIns ins = { AstInsType::AccumulatedDfa,-1,adfaCount }; - receiver->Execute(ins, *adfaToken, adfaIndex); - } - adfaCount = 0; - adfaToken = nullptr; + + receiver.Execute({ AstInsType::StackBegin }, *cachedStackBeginToken, cachedStackBeginTokenIndex); + cachedStackBegin = false; } - if (aeoroToken) + + if (instruction.type == AstInsType::StackBegin) { - AstIns ins = { AstInsType::AccumulatedEoRo,-1,aeoroCount }; - receiver->Execute(ins, *aeoroToken, aeoroIndex); - aeoroCount = 0; - aeoroToken = nullptr; + cachedStackBegin = true; + cachedStackBeginToken = &token; + cachedStackBeginTokenIndex = tokenIndex; + return; } - if (cachedToken) + + receiver.Execute(instruction, token, tokenIndex); + } + + Ptr Finished() override + { + if (cachedStackBegin) { - receiver->Execute(cachedIns, *cachedToken, cachedIndex); - cachedToken = nullptr; - lriFetch = false; + receiver.Execute({ AstInsType::StackBegin }, *cachedStackBeginToken, cachedStackBeginTokenIndex); + cachedStackBegin = false; } + return receiver.Finished(); } }; -#define ERROR_MESSAGE_PREFIX L"vl::glr::automaton::TraceManager::ExecuteTrace(Trace*, IAstInsReceiver&, List&)#" - - void TraceManager::ExecuteSingleTrace(TraceManagerSubmitter& submitter, Trace* trace, vint32_t firstIns, vint32_t lastIns, TraceInsLists& insLists, collections::List& tokens) + void TraceManager::ExecuteSingleTrace(IAstInsReceiver& receiver, Trace* trace, vint32_t firstIns, vint32_t lastIns, TraceInsLists& insLists, collections::List& tokens) { for (vint32_t i = firstIns; i <= lastIns; i++) { auto& ins = ReadInstruction(i, insLists); auto& token = tokens[trace->currentTokenIndex]; - submitter.Submit(ins, token, trace->currentTokenIndex); + receiver.Execute(ins, token, trace->currentTokenIndex); } } - void TraceManager::ExecuteSingleStep(TraceManagerSubmitter& submitter, ExecutionStep* step, collections::List& tokens) + void TraceManager::ExecuteSingleStep(IAstInsReceiver& receiver, ExecutionStep* step, collections::List& tokens) { TraceInsLists temp; @@ -7193,11 +7223,11 @@ TraceManager::ExecuteTrace } else { - lastIns = insLists->c3 - 1; + lastIns = insLists->countAll - 1; } // execute instructions - ExecuteSingleTrace(submitter, trace, firstIns, lastIns, *insLists, tokens); + ExecuteSingleTrace(receiver, trace, firstIns, lastIns, *insLists, tokens); // find the next trace if (step->et_i.endTrace == trace->allocatedIndex) @@ -7219,16 +7249,40 @@ TraceManager::ExecuteTrace } } break; - case ExecutionType::ResolveAmbiguity: + default: { - AstIns ins = { AstInsType::ResolveAmbiguity,step->et_ra.type,step->et_ra.count }; auto raTrace = GetTrace(Ref(step->et_ra.trace)); raTrace = EnsureTraceWithValidStates(raTrace); auto raToken = raTrace->currentTokenIndex; - submitter.Submit(ins, tokens[raToken], raToken); + + switch (step->type) + { + case ExecutionType::RA_Begin: + { + if (raToken == -1) raToken = 0; + AstIns ins = { AstInsType::StackBegin }; + receiver.Execute(ins, tokens[raToken], raToken); + } + break; + case ExecutionType::RA_Branch: + { + AstIns ins = { AstInsType::StackSlot,-1,ResolveAmbiguitySlotIndex }; + receiver.Execute(ins, tokens[raToken], raToken); + } + break; + case ExecutionType::RA_End: + { + AstIns ins = { AstInsType::ResolveAmbiguity,step->et_ra.type,0 }; + receiver.Execute(ins, tokens[raToken], raToken); + } + { + AstIns ins = { AstInsType::StackEnd }; + receiver.Execute(ins, tokens[raToken], raToken); + } + break; + default:; + } } - break; - default:; } } @@ -7236,23 +7290,20 @@ TraceManager::ExecuteTrace { CHECK_ERROR(state == TraceManagerState::ResolvedAmbiguity, ERROR_MESSAGE_PREFIX L"Wrong timing to call this function."); - TraceManagerSubmitter submitter; - submitter.receiver = &receiver; - // execute from the first step + AstInsOptimizer optimizedReceiver(receiver); auto step = GetInitialExecutionStep(); CHECK_ERROR(step != nullptr, L"Internal error: execution steps not built!"); while (step) { // execute step - ExecuteSingleStep(submitter, step, tokens); + ExecuteSingleStep(optimizedReceiver, step, tokens); // find the next step step = step->next == nullref ? nullptr : GetExecutionStep(step->next); } - submitter.ExecuteSubmitted(); - return receiver.Finished(); + return optimizedReceiver.Finished(); } #undef ERROR_MESSAGE_PREFIX } @@ -8630,22 +8681,21 @@ namespace vl::glr::xml { void XmlParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 2539; // 23493 bytes before compressing + static const vl::vint dataLength = 2277; // 22621 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 235; - static const vl::vint dataSolidRows = 9; - static const vl::vint dataRows = 10; + static const vl::vint dataRemain = 229; + static const vl::vint dataSolidRows = 8; + static const vl::vint dataRows = 9; static const char* compressed[] = { - "\xC5\x5B\x00\x00\xE3\x09\x00\x00\x0D\x00\x01\x82\x80\x08\x03\x82\x81\x82\x06\x89\x82\x85\x0A\x83\x06\x84\x07\x0A\x91\x0A\x9C\x0A\x82\x12\x84\x14\x0A\xA3\x42\x09\x8F\x7D\x8E\x8F\x8E\x0A\x80\x1F\x9F\x81\x93\x92\x8F\x92\x26\xFF\x68\x86\x9B\x93\x91\x96\x92\x0A\xA9\xAA\x91\x99\x91\x91\x91\x00\x34\xAC\xB9\x8E\x9B\x98\x98\x8F\x9A\x3D\xA7\x81\xA0\x93\xA3\x9B\x9E\x9D\x47\xBC\x89\xBE\x96\x82\x9B\x96\xA1\x4B\xD0\x8D\xA0\xA1\xAC\xA1\xAA\xA3\x53\xC8\x99\xAA\xAB\xAC\xA7\x80\xA7\x45\xCF\x96\xBD\xA2\xAF\xAC\xAA\xB2\x63\xE6\x9A\xAA\xBC\xAC\xB6\xAE\x81\x60\xD7\xB7\x8A\x88\x9A\xB9\xB1\xBB\x76\x89\x9B\x89\x85\xB8\xB4\xAC\xB7\x65\xF0\xA7\xA0\xC9\xB2\xC3\xB4\xC3\x6D\x88\xEF\xA1\x81\xBE\xBE\xB1\xBF\x8A\x81\xCC\xC3\xC1\xCD\xC3\xC9\xC3\x97\x89\xD9\xCB\xC2\x94\xCB\xCC\xC9\x9D\x98\xE1\xDA\xC3\xD4\xCD\xC7\x81\x03\x74\xB8\xAE\xCB\xD4\xC0\xC9\xCF\x96\xA5\xE0\xC7\xD5\xCF\xD6\xD9\xD8\xB4\xB0\xF6\xD9\xD7\xDB\xDE\xCE\x00\x04\x2A\xC9\x8C\x8C\xBA\x86\x02\xE1\xAC\xF9\x86\x87\x08\xE6\xD7\xC7\xE7\xAD\xB5\xD0\xEA\xEE\xE1\xEA\xDD\xE9\xC9\xD9\xD5\xF4", + "\x5D\x58\x00\x00\xDD\x08\x00\x00\x0D\x00\x01\x82\x80\x08\x03\x82\x81\x82\x06\x89\x82\x85\x0A\x83\x06\x84\x07\x0A\x91\x0A\x9C\x0A\x82\x12\x84\x14\x0A\xA3\x42\x09\x8F\x7D\x8E\x8F\x8E\x0A\x80\x1F\x9F\x81\x93\x92\x8F\x92\x26\xFF\x68\x86\x9B\x93\x91\x96\x92\x0A\xA9\xAA\x91\x99\x91\x91\x91\x00\x34\xAC\xB9\x8E\x9B\x98\x98\x8F\x9A\x3D\xA7\x81\xA0\x93\xA3\x9B\x9E\x9D\x47\xBC\x89\xBE\x96\x82\x9B\x96\xA1\x4B\xD0\x8D\xA0\xA1\xAC\xA1\xAA\xA3\x53\xC8\x99\xAA\xAB\xAC\xA7\x80\xA7\x45\xCF\x96\xBD\xA2\xAF\xAC\xAA\xB2\x63\xE6\x9A\xAA\xBC\xAC\xB6\xAE\x81\x60\xD7\xB7\x8A\x88\x9A\xB9\xB1\xBB\x76\x89\x9B\x89\x85\xB8\xB4\xAC\xB7\x65\xF0\xA7\xA0\xC9\xB2\xC3\xB4\xC3\x6D\x88\xEF\xA1\x81\xBE\xBE\xB1\xBF\x8A\x81\xCC\xC3\xC1\xCD\xC3\xC9\xC3\x97\x89\xD9\xCB\xC2\x94\xCB\xCC\xC9\x9D\x98\xE1\xDA\xC3\xD4\xCD\xC7\x81\x03\x74\xB8\xAE\xCB\xD4\xC0\xC9\xCF\x96\xA5\xE0\xC7\xD5\xCF\xD6\xD9\xD8\xB4\xB0\xF6\xD9\xD7\xDB\xDE\xCE\x00\x04\x2A\xC9\x8C\x8C\xBA\x86\x02\xE1\xAC\xF9\x86\x87\x08\xE6\xD7\xC7\xE7\xAD\xB5\xD0\xEA\xEE\xE1\xEA\xDD\xE9\xC9\xD9\xD5\xF4", "\xE2\xEA\x84\x84\x83\x7D\xDB\xDA\xFD\xEC\xEF\xEA\xEB\xDE\xD8\xE2\xEA\xE4\xF3\xF6\xF1\xF2\x00\x09\x4D\xEC\xEB\xFE\xF5\xF4\xF5\xF3\xBC\xF9\xFF\xDA\xF2\xD4\xFC\xD2\xDE\x0A\x32\x75\x7C\x7D\xF7\x6F\x7E\x7E\x69\xFB\x49\x8D\x7E\x82\xFF\x4C\x88\x82\x68\x0E\x45\x76\x82\x83\xB3\x54\x88\x6E\x85\xBE\x4B\x8A\x85\x83\x1B\x8F\x8C\x87\x87\x1E\xA1\x85\x85\x87\x23\xA0\x85\x8A\x88\x17\xA4\x89\x88\x69\x0C\x02\x85\x82\x7D\x07\xA7\x82\x8F\x8A\x28\x99\x86\x88\x8D\x33\xB6\x85\x8D\x7A\xF3\x7D\x81\x40\x40\x12\xB0\x88\x84\x8F\x03\xBE\x8F\x88\x81\x31\xB8\x8A\x92\x8E\x39\x84\x97\x92\x91\x49\x8C\x9B\x92\x93\x51\x8E\x90\x45\x90\x48\x83\x98\x7E\x96\x13\xAA\x82\x97\x97\x54\x9C\x92\x92\x97\x4E\x8F\x0E\x89\x95\x5B\xA4\x99\x9B\x8D\x60\xAB\x9B\x8E\x9B\x4D\xB0\x93\x96\x9C\xB6\x50\x07\x9A\x98\x59\xAA\x9D\x94\x9B\x61\xBA\x93\x98\x9F\x74\xBD\x90\xA3\x9E\x6F\x84\xA1\x9E\xA1\x73\x88\xAD\x9B\x7B\x12\x58\x90\x94\x9E\x8F\xBE\x99\x9F\xA0\xF6\x52\x07\x9E\x68\x13\x17\xA4\x68\x05\x9A\x85\xAF\x9E\xA7\x93\xA0\xA1\xA4\x69\x15\x1D\xA0\x6A\x05\xA6\xB1\x67\x05\xAA", "\x8B\x9F\xA7\xA2\x41\x18\x2C\xA2\xA2\xA8\x45\xB5\xAF\x92\xAD\x68\x8A\xA3\xAF\xAB\xA1\xBC\xA2\x41\x06\xB2\x8A\x4A\x05\xB0\x09\x5B\x0E\x88\x45\x8E\x81\x4D\x06\x8B\x1E\x2E\x8F\x06\x8B\x20\x04\xBE\xA9\xA2\xF6\x61\x02\xB7\x40\x16\x49\xB7\xAC\x00\x23\x2E\x84\x0A\x8B\x25\x2E\x86\x0A\x8B\x27\x2E\x88\x46\xB6\xB9\x93\xBD\xA9\xAF\xD4\xAC\xB6\x6D\x0A\xD7\xA3\xA4\xAF\xB6\x2A\x31\xB8\xAC\xA4\xF7\x92\xA2\xBE\xAF\xF9\x94\xAE\xBB\xAE\xED\xBB\xB1\xC1\x40\x2B\x36\xBB\xB5\xBA\xFF\x81\xAA\xC2\xAE\xE7\x6C\x06\xC1\x0B\x2E\xAE\x0E\x8B\x0B\x2E\xB0\x0E\x89\x0C\x2E\xB2\x06\xC0\xC2\x02\xEB\xBD\xC4\xC0\x1E\xFD\xB3\xBC\xC7\x01\x73\x0B\xC4\xBE\x07\xE8\xC4\xC9\xCA\xFA\xA2\xCC\xBC\x00\x34\x27\xCD\xC8\xCB\xFE\x9F\xCB\xC2\xBA\x20\xE1\x45\x0E\xCC\x35\xEE\xC3\xC0\xCD\x23\xEA\xC2\xD2\x68\x36\x3C\xC1\xD3\xCC\x2B\xC9\xD3\xD1\xCF\x40\xEF\xC7\x0E\xD1\x2F\xCA\xD8\xD3\xD2\x47\xCC\xD2\xD6\xD5\x54\xD1\xD9\xD7\xCF\x57\xD5\xDE\xD6\xD6\x53\xE2\x68\x0C\xD4\x5C\xDB\xD1\xCB\xB6\x39\x24\xD7\xDB\xCA\x3A\x2A\xD9\xCF\xCD\x09\xC9\x4B\x0E\xDB\x70\xC6\x9C\x0C\xDD\x0C", - "\xEF\x7D\x0C\xDE\x38\xF5\xDE\xCF\xDA\x66\xEF\xD9\xDE\x41\x3E\x3C\xD4\x83\x0F\x86\xF6\xC9\x40\x10\x89\xFF\xD2\xE1\xDF\x83\xF1\xD0\xE7\xE4\x92\xD5\xE2\x41\x10\x8D\xDB\xB2\x11\xE6\x2B\xC3\x1C\xE7\x6F\x44\x1F\xE1\xD8\xD6\xA3\xDF\xD5\xD9\xE9\x2F\xC5\x12\xE8\x69\x46\x2B\xE3\xBF\x11\xAE\xE0\x6D\x2A\x42\x7B\x76\x4E\xBA\x4C\xF1\x76\xE7\xED\x4A\xB9\xE0\x75\x50\x71\x7E\x72\x45\xEF\x40\xCC\x4A\xA8\xEE\x42\x2D\x97\x53\xF2\x40\xC5\xEA\xB7\xF1\x42\xC9\xFE\x5B\xF1\x40\xCD\xFB\xE6\x49\xEF\x03\x51\xFE\x6B\xF4\x00\x15\xFD\xC7\xF3\x06\x5A\xF5\x6C\xF0\xAE\x72\x44\xF9\x6D\xE6\xC5\x59\xFB\x55\xC2\xEA\xD0\xFB\x40\xDC\xEB\xF1\xF1\x4A\xDC\xF1\xF8\x87\xFB\x02\x69\x67\x57\xF9\xBA\x6D\xF9\x41\x70\xC6\x7C\x76\x77\x45\x2C\x7A\x90\x78\x7E\x76\xFE\x7A\x77\xDF\x07\x86\x26\xF9\x65\x79\x25\xFA\x73\x7E\x49\x5C\x70\x80\xBF\x11\x87\x81\x13\x8A\x22\xF7\x0B\x82\x80\xE8\x45\x2F\x82\xE8\x74\x7E\x06\xF4\x4C\x80\xF1\x7A\x30\x84\xFD\x62\x85\x42\x1B\x8D\x68\x99\x1D\x20\x7B\x02\x26\x85\x6F\x28\x8D\x37\x04\xB0\x7C\x84\x1D\x86\x20\x0D\xB2\x2B\x86\x17\x99\x80", - "\x5D\xF7\x79\x87\x0D\xD7\x2D\x86\x1F\x9F\x24\x7B\x2C\x91\x49\x09\x9F\x8A\x7C\x15\x86\x25\x82\xAE\x25\x8A\x11\x9D\x28\x88\x1C\x97\x78\x79\x4C\x8C\x7E\x13\xC4\x76\x8B\x91\x30\x81\x20\x32\x9C\x85\x13\xBF\x8B\x39\x2E\x9F\x27\x8B\x00\x01\x8C\x04\xE3\x83\x25\xFA\x66\x8E\x23\x68\x92\x8B\x47\x72\x86\x88\xEE\x61\x3F\x7B\x42\x82\x22\xFD\x26\x24\x8E\x1F\x95\x89\x80\x57\x9E\x80\x20\xDE\x83\x85\xFD\x6C\x8B\x8E\x87\x9E\x20\x05\xD9\x82\x83\x36\x85\x96\x79\x79\x80\x8C\x23\x98\x8E\x91\x15\xAF\x8F\x85\x58\x84\x89\x22\xD4\x8F\x90\xEB\x44\x92\x90\x16\x9B\x93\x3F\x6E\x83\x91\x33\x8A\x25\x8F\xFF\x08\x96\x0D\x82\x27\x8E\x0E\x81\x96\x20\x7B\x83\x26\x2A\xDB\x8C\x79\x4B\xBF\x18\x8D\x6A\x86\x24\x14\xA1\x86\x24\xFE\x75\x81\x25\xBB\x89\x85\x2F\xA2\x91\x99\x5F\x83\x9A\x8B\xBA\x82\x96\x2F\xD3\x87\x88\x85\x0B\x99\x88\xAF\x83\x21\x84\x52\x7A\x80\x3C\x91\x9A\x77\xAB\x88\x80\x34\x9F\x95\x9A\x07\xBC\x95\x92\x3A\x84\x82\x33\xE2\x99\x20\x54\x8B\x92\x79\xA7\x84\x9C\x2C\xB6\x91\x8E\x75\x83\x27\x99\x64\x83\x21\x31\xD9\x90\x01\x58\xB5\x44\x81\xA8\x90", - "\x9C\x33\xDC\x7A\x9F\x66\xBF\x7E\x9D\x7A\x8C\x9D\x3A\xD7\x28\x8D\xE3\x04\xA6\x38\x45\x28\x8C\x1A\x8C\x8B\xA1\x48\x80\x01\x40\x07\xA9\x20\x44\xFE\x28\x8D\x79\x8E\xA5\x9F\x70\x8A\x22\x45\xD7\x91\x21\x8D\x9C\x9F\x9D\x09\xBA\xA1\x48\xFF\x91\xA2\x83\x18\xA0\x93\x24\xBE\x2E\xC5\x55\x90\x01\x56\xB5\x9B\xA0\xEB\x89\xA7\x10\xCF\x84\x76\x91\xBA\x2B\x9C\x37\xA9\x22\x41\xB1\xA4\xA6\x4B\xA5\x9D\x93\x02\x25\x98\x0B\xC2\xA6\xA7\x32\x83\x38\xA8\x01\x3B\xA4\x17\xB2\xA9\x7F\xA2\xB2\x9E\xA9\x0B\x28\xA0\x53\x81\x2F\x3B\x81\x28\x8B\xA2\xD2\x99\x92\x41\x40\x46\x21\x2B\x46\x26\x4C\x09\x36\x4D\x42\x0D\x56\x20\x4B\x49\x21\x53\x2C\xA5\x54\x4B\xA1\x2E\x12\x17\x61\x22\xAD\x6B\xA9\x23\x27\x2E\x4E\x97\x58\x71\xA9\x21\xA0\x0E\x45\x31\xD6\x5C\xA4\x54\xB3\x29\x21\xCD\x5D\xAF\x79\x34\x81\x5A\xC1\xAF\x3C\x7B\xCF\x46\xB2\x7D\x75\xA7\xAF\x84\x21\x16\xAD\x0A\x23\x5D\x63\x83\x22\x14\xC8\x89\x22\xB2\x93\xA1\x23\x28\x2E\x4A\xA8\x81\x35\x59\xB3\x01\x24\x16\x5E\x8A\x25\x60\xD0\x80\x05\x14\x2E\x54\x86\xC3\x26\xB6\x14\xCE\x8A\x27\xB3\xA0\xA7\x17\x68\x89", - "\x25\xB4\xD0\xA8\x11\xB5\x0A\x2B\xB4\x68\xA9\x1E\xB5\x84\x30\xB1\xB3\xAA\x13\xB6\x41\x35\xB9\xB3\x55\x38\xB1\x21\xBA\xB9\xB0\x2B\x2E\x48\x09\xB5\x9E\xA4\x33\x71\xAE\xA6\x4B\xF6\x90\x34\xEE\x7E\xAB\xAD\xBC\x34\x84\x75\xB1\x34\x86\x97\xBC\x31\x24\xBE\x9E\xB8\xCA\x45\x9B\xBA\xDB\x0F\x74\x40\xBE\x89\x8B\x6F\x21\x2D\xB3\x80\x2E\xA4\x85\xE5\xA0\xBE\x42\x0D\xA2\x35\x90\x28\x8E\xA5\x58\xA1\xA3\x7B\x3E\x95\xAA\x23\x61\x22\x86\x2E\xBC\xAB\x4C\xE8\xBA\x21\xFC\xB6\x51\x24\x60\xBE\x75\x58\xB5\xAF\x3C\x16\xAD\xBB\x5B\x21\x26\xAE\x82\x94\x77\x20\xA9\xB6\x39\x24\x68\xB3\xC2\xE5\x01\x25\xA1\xF3\x21\x24\x53\x40\x93\x66\x81\x80\x0F\xC1\xEF\x8A\x20\xAE\x03\x22\xBF\xCC\x53\x93\x20\x01\xFE\xBA\x21\xA8\x5A\x5B\xAA\x39\xA6\x3E\x17\xD2\x97\x3D\x21\x20\x59\x88\xCC\x6E\xAB\x81\x22\xAF\xC2\xC2\x4E\x46\xB1\x34\xC4\x41\x1F\xC3\x21\xC1\x04\x41\x27\xB2\x3B\xC3\x5E\xB2\x83\x21\xC3\x49\xCA\x21\x60\x9A\xCA\x70\x83\x10\xCA\x20\x20\xC0\xCB\x7B\x09\xBC\xA6\x02\x59\xCB\x20\x31\xDA\xC8\x85\xB6\x5F\xCA\x81\x33\xC2\xCC\x1B\xDB\x59\x99\x9D\xAE\xC2\x85", - "\x3C\xAC\xCA\x01\x39\x59\x97\xBA\x7E\xA4\x14\xC2\x21\xCC\x51\xD1\x72\x91\x76\xC1\x21\x33\xF9\xCB\xCC\xDB\x5C\xCC\x70\x6D\xC9\x21\x6F\x5A\x59\x5C\x44\xCC\x96\x8B\x78\xC2\x20\x09\xFF\xCB\x20\xE5\x4C\xCB\xCB\x7E\xCF\x56\x42\xC0\xD4\x37\x94\xC1\x23\x95\x87\xC7\x22\x06\xF6\x3C\x94\x06\x39\xD1\xF7\x16\xD3\x21\xDF\xBA\xBE\x20\xC9\xA7\xD7\x53\x89\xDD\xCF\xF9\xA4\xD2\x20\x12\x6C\xD4\x00\x2B\xA3\xCF\xA4\x9E\xD3\x20\xA2\xDD\xBC\xA7\x89\x2A\x62\x59\xF1\x62\xD6\xBA\xCF\xA5\x42\x22\xD6\xC9\x17\xC9\x25\x68\xB2\xC3\x6E\xAC\xA3\xCC\x7A\x51\xF6\xC0\xC2\x0A\x2D\x6E\xAC\xF7\x62\xD6\x19\x8D\xDD\xC0\xAF\xC1\x21\xE1\x32\xDC\x70\x59\xFD\xC2\xD5\x02\x36\xAE\x41\x3A\xC8\xCD\x2A\xC4\x42\xDC\x4F\xD9\xD8\x00\x1B\x72\xD6\xDE\x05\xD9\x20\xDC\x68\xDD\x2D\xB8\xCA\x21\xD0\x72\xD5\x75\xB2\xCE\xD0\xB8\x81\x22\xDE\x0E\xEA\xDD\xB9\xB2\xCA\x0B\xAD\xD8\xC3\xE0\x7E\xC3\x84\xDE\x09\x2C\x09\xC1\x80\x0E\x09\x85\xCC\xD0\xDE\x0A\x3D\xDC\x00\x6F\xD0\xDB\x84\x10\x0B\xE1\x52\x0B\xE2\xC4\xF1\xDA\x21\x67\xE6\xC1\x21\x54\x0B\xE2\x15\x0B\xE3\x58\x59\xD2\xE3\xC4", - "\x1F\xE6\x20\x16\x0B\xEA\x0B\x85\xC8\x5D\xD6\x00\x04\xDF\x40\x43\xC5\xDC\x5B\x5C\x0B\xE1\xBC\x25\xE5\x59\xEA\xDE\x0B\xCC\x74\xE3\x20\x3A\xEF\xD2\xB9\xC6\x4F\xE5\x74\xC8\xE6\x20\x5F\x18\xE7\x6F\x53\xC9\xC5\x89\x08\xAD\xE2\x06\x21\x0F\xC2\xE3\x0B\xE0\x2E\xCD\xE9\x21\x45\xE2\x20\x7D\xA4\x31\x25\x32\x0B\xE7\x0C\x0B\xE5\xB0\x9C\x80\x09\xEA\xAA\xAA\xD9\x0D\x0B\xEB\x0F\xC2\xEF\xC7\xEA\x83\x25\xEB\xE2\xEA\xCD\x0F\xC2\xEF\x0B\xE0\x39\xED\xEB\x20\x6F\xFE\xE3\x7A\x8A\x21\x0F\x85\xF3\x0B\xE1\xDD\x5A\x5B\xDB\xA8\xEB\xEF\x84\x35\x0B\xE1\x77\x0B\xE2\xA1\xE3\xEC\xE8\x81\x0B\xCD\xE6\x00\x19\x0E\xD2\xB3\x66\xEA\xC7\xEA\xDB\x0F\x93\xEC\x6A\xD8\x83\x2F\xF0\xA1\xC1\x25\x0F\x99\xF3\x5C\xDB\x96\xF7\xE9\x81\x3F\x09\xF4\x2F\x76\xEE\x40\x0B\xFE\xF2\x00\x01\x11\x73\xAC\xE2\x20\xA2\x90\xFC\x36\x41\x28\xF1\x36\xB3\xF0\xD2\xBA\xDD\x60\x35\xDC\xC1\xAA\xDD\x84\x0E\x45\x21\x0B\xEE\xF6\xF7\x91\xB2\x21\x91\xD4\xF5\xE0\x47\xF3\xAA\xA8\xC3\x27\x10\x2E\x48\x13\xC2\x98\xB7\xEE\x81\x09\xFB\x20\x81\xF0\xF2\x22\x19\x77\x5C\x83\x31\xF3\xD7\x06\x2B\x13", - "\xED\xB6\x37\xFA\x45\xC9\x25\xFB\x46\xF0\xF1\x23\x63\xF1\x24\xF4\xE6\xFE\x20\xEE\xE1\x20\xC5\xA9\xE3\x21\x47\x0B\xE1\x12\x0B\xF0\x5E\xB6\x26\xD1\x21\xEF\xCE\xFA\x20\x93\x06\x30\xFC\x7D\x52\xAF\x5A\x10\x9B\x6F\x7F\x01\x14\x09\x06\x34\x5C\xEF\x75\x6A\x0A\x13\x7F\x85\x76\x10\x95\x0E\x22\x96\x0B\x70\xA9\x66\x7C\xB4\x5A\x10\xFA\x70\x79\x98\x09\x39\x17\x80\x00\xFE\x74\x7F\x02\x19\x09\x0F\x3E\x22\x1F\x87\x80\x22\x81\x10\x9A\x06\x30\xB1\x63\x76\x1F\x80\x81\xF5\x5A\x10\x9B\x0E\x22\x9C\x0B\x70\x14\x3A\x2D\x10\x3C\x52\xDF\x5E\x42\xA6\x5D\x83\x92\x60\x12\x2A\x66\x12\xD2\x5F\x57\x30\x74\x80\x6B\x5E\x52\x34\x42\x6C\x8E\x15\x5E\xA3\x41\x57\x7E\x5A\x4A\x49\x81\x12\xCF\x57\x12\x53\x8E\x11\xC5\x46\x13\x57\x82\x85\x71\x59\x85\x50\x5A\x3B\x5C\x8D\x7C\x58\x8B\x85\x71\x57\x52\x2A\x14\x86\xFF\x0E\x4B\x36\x18\x86\xF2\x5B\x56\x6A\x86\x61\xCE\x15\x62\x32\x1F\x60\x36\x12\x87\xEC\x51\x57\x74\x8F\x74\x4E\x1A\x5E\x29\x1C\x42\x36\x1C\x87\x21\x1E\x87\x6B\x50", + "\xEF\x7D\x0C\xDE\x38\xF5\xDE\xCF\xDA\x66\xEF\xD9\xDE\x41\x3E\x3C\xD4\x83\x0F\x86\xF6\xC9\x40\x10\x89\xFF\xD2\xE1\xDF\x83\xF1\xD0\xE7\xE4\x92\xD5\xE2\x41\x10\x8D\xDB\xB2\x11\xE6\x2B\xC3\x1C\xE7\x6F\x44\x1F\xE1\xD8\xD6\xA3\xDF\xD5\xD9\xE9\x2F\xC5\x12\xE8\x69\x46\x2B\xE3\xBF\x11\xAE\xE0\x69\x2A\x42\x7B\x7E\x5B\xCB\x63\xB5\xC3\x41\x72\x4D\x7E\x44\x7C\xEF\xEF\xBE\xC3\x41\x7A\x40\xB9\xC2\x4C\x73\x55\x51\x83\xF1\x41\xF1\xBA\x6B\xCC\xF1\x6F\xCE\xC5\x51\xF4\xF2\x28\xFB\xEB\x71\x51\xC1\xC2\x4D\x8B\xEF\xC6\xD2\xF9\x4A\xF5\x03\x47\xFD\xEE\x42\xDB\xDC\xF0\x02\xF8\xAE\x72\x40\xF9\xF7\x57\x59\xF1\x41\xF9\xDC\xE8\xF5\x6E\xFA\x0A\x72\xFA\x6E\xFB\x00\x30\xFF\xEE\xFD\xD0\xE9\x4F\xF2\x4C\x2B\x6B\x7D\x40\x4A\x7D\x36\xFC\x4F\x79\x24\xFC\x60\x82\xFF\x5E\x73\x66\x01\x80\x07\x7F\x29\x38\x7D\x6A\x66\x77\x7C\x06\xA3\x20\x82\x0A\x93\x5F\x63\x04\x8F\x31\x09\xA6\x7C\x7E\x7A\x36\x82\x06\xC5\x2E\x82\xEE\x60\x86\x20\x18\x99\x83\xCF\x0E\x8E\x80\x99\x38\x7F\x3B\xC2\x6A\x20\xFE\x47\x31\x85\xE1\x0A\x21\x3E\x36\x99\x87\xF5\x09\x2C\x7F\x04\xAA\x81", + "\x47\x34\x88\x86\x08\xAF\x69\x84\x15\x8E\x4D\x88\x19\x87\x8B\x10\xBF\x68\x88\x05\x8A\x8C\x7A\x33\x6D\x88\x00\xCE\x4F\x31\x20\x83\x22\x8A\xD3\x76\x74\xCA\x58\x8B\x8B\x25\xA7\x6C\x8B\x51\x9E\x8B\x13\xDA\x83\x67\xC7\x3C\x7C\x85\xD8\x7E\x3A\x8B\x33\x84\x76\x19\xB7\x86\x8D\x3A\x81\x7D\xFD\x73\x80\x8A\x36\x70\x84\x78\x62\x87\x3C\x18\xCC\x6B\x8F\x79\x7D\x8C\x88\x79\x8F\x3F\x1F\xCC\x81\x90\xFB\x3E\x87\x87\xFF\x07\x93\x0F\x8A\x9A\x84\x46\x99\x83\x90\x67\x7B\x80\x05\xBD\x35\x84\x3C\xB5\x8B\x84\x57\x35\x93\xF2\x05\x94\x40\x07\xB8\x7E\x85\x0D\x2B\x8E\x42\x01\x45\x87\x1D\xA4\x8F\x82\x9C\x86\x48\x24\xE3\x89\x7D\x2E\x97\x90\x90\xAF\x84\x91\x2C\xE7\x6E\x80\x4D\x85\x82\x21\x0E\x81\x24\xFE\x0E\x84\x80\xFC\x46\x84\x8E\xA7\x9F\x23\x2A\xFA\x89\x94\x5B\x43\x9F\x3D\xB6\x92\x27\xF3\x49\x9B\x81\x84\x0C\x9E\x24\xBF\x93\x94\x24\xD3\x9E\x8B\x67\xA3\x22\x82\x45\x2B\x99\x36\xED\x83\x96\x6B\x9C\x30\x92\xDE\x9E\x23\xF3\x60\x95\x28\x02\xA1\x99\x36\xE7\x9F\x1E\x36\xD7\x26\x9D\xF3\x29\x9B\x9D\x7E\x24\x82\xC5\x14\x84\x80\x78\x97\x88\x97\xDC\x86", + "\x22\x03\xCF\x7B\x9E\x38\x82\x89\x21\x56\x96\x92\x3E\xC0\x98\x34\x82\x82\x26\x81\x67\x86\xA1\x40\x08\xAE\x9E\x39\x80\xA2\xA1\xC0\x2A\x22\x2D\xE8\x89\x20\x4F\x86\x38\x9F\x09\x37\x8D\x40\x38\x86\x20\x52\x86\x21\x42\x06\x3A\x7F\x8F\x0F\x2A\x20\x33\x49\x26\x4E\x09\x2D\x52\x41\x16\x54\x83\x4C\x54\x85\x54\xEF\x21\x27\x24\x2E\x41\x24\x98\xB6\x39\x24\x94\x02\x95\x42\x31\x51\xA6\x85\x15\x16\x45\x0E\x96\x58\x32\x8A\x26\x12\x17\x44\x85\x59\x43\xA9\x23\x25\x2E\x46\x97\x68\x49\xAE\x20\x98\x0E\x47\xF3\x4F\x5F\xA9\x81\x19\x12\xA7\xB0\x47\x3D\x48\x1A\x14\xA6\x85\x23\x5D\xA7\x09\x3B\x11\x57\x89\x2F\xAB\x9B\x8A\x24\x13\x2E\x41\xA1\x40\x75\x50\xAC\x83\x1D\x11\x9F\xBA\x6A\x21\xC1\x6D\xA3\x21\x4F\x30\xAA\x20\xB6\x8E\x60\x5D\x82\x21\x15\xBB\x81\x22\xAD\x00\x0C\xAE\x59\x89\x23\x14\xA0\xB2\xAA\xAB\x0A\x24\x14\x53\x8A\x2A\xAF\xC1\x86\x25\x14\x69\xAA\x22\x60\x84\x41\x24\x53\x06\xB1\x21\x73\xAE\xB3\x40\x27\x1B\xB1\x84\x0D\xB4\xB2\x0A\x28\x16\x8B\x48\x03\x93\x16\xA8\x61\x24\x52\x88\xB6\x44\xFE\x6F\x80\x83\x76\x94\x80\x2B\x73\xA3\x79\x7D", + "\x91\x72\xF6\x60\x3F\x3C\xF8\x6E\x93\xCF\x1A\xAD\xB5\xF7\x38\x7C\xA3\x96\x61\x22\x47\xF7\x9E\xB6\x35\xB5\xB7\x7D\x7E\xBB\x58\xFE\x43\xBA\x70\x83\x17\x4F\x9F\x86\x97\xA3\x71\x80\x08\xA4\x83\x29\x99\x24\xBC\xA0\xB3\xCA\x2E\xA6\xBB\xF3\x00\xBA\x20\xDA\xA8\x64\xAA\x4E\x97\x3C\xE6\xBF\xAC\xB5\xC0\x44\xBF\x7B\x20\xA3\x20\x20\x54\x72\x20\xC8\x50\xB8\x81\x6E\xB3\x20\x91\x8D\x69\x36\x48\xBD\xBB\x7B\x4F\xB3\x21\xEA\x81\xB8\x00\x42\xB2\xBE\x91\x7E\xB2\x20\x93\xAF\xB9\x20\xDD\x4A\xBE\x7D\x2A\xA3\x20\xEE\xBF\xBD\xAC\xC4\xB6\x3E\x83\x82\x2C\x53\xE9\xA7\x5F\xB6\xEF\x35\xC2\x41\x63\xB7\xC0\x00\x30\x58\x5D\xBF\x3A\xC3\x40\x2B\x53\xBB\xC9\x82\x20\xB6\x21\xD8\xA1\x87\x99\xB1\xC2\xEE\x44\x86\xA6\x03\x3C\xC3\x7F\x90\x60\xC4\xD1\x30\xC2\x20\x24\xDD\xC2\xC4\x35\xC4\x54\x15\xFF\xBC\x62\xA5\x91\x86\xB6\x32\xC2\x20\x96\x9D\xC0\x63\x0F\xAF\x3D\x8E\x83\x29\xBD\x0E\xCF\x6C\xC7\x9C\x2B\xCA\x40\x13\xCE\x70\x85\x23\x69\xC8\x02\xAD\xC4\x8E\x90\xAC\x6D\xE4\xB4\xB6\x20\x52\xDB\xA0\x6B\xF7\x68\xCB\xF3\xA5\xC8\x00\x61\xC4\x20\x6B\x85\x77\xCC\xDE", + "\x8F\x79\xCD\x04\xD5\xCB\xE2\x49\xB6\xBD\xDE\xA0\xCA\x21\xF4\xAD\xBB\x40\x1B\x77\xCC\xFB\xAF\xCB\x94\xAC\xA1\x77\x99\xFC\xB9\xCA\x81\x3C\xA6\x20\x4D\xDF\xBD\xEB\x50\xC0\x35\x43\xCD\xC4\xB5\xB0\x67\xCD\x9C\xF6\xC3\x20\x47\xF6\xB7\xBF\x49\x09\xBA\x91\xDA\xC1\x20\x4B\xE2\xCB\xBA\x4B\x09\xBA\x88\x85\xDD\xD2\xE3\x9D\xC5\x09\xC9\xA4\xCB\x26\xBB\xAA\x21\x49\xEB\x67\x09\xC9\xBE\xD0\xA5\x86\xD8\xCE\xD6\x91\x09\xB9\xC3\x47\xCE\xAC\xF5\xCB\x65\x29\x09\xB9\xBE\x9C\xC0\x01\xA2\x82\x26\x59\xE9\x95\x0E\x60\xB9\xCB\xA4\x6B\xD6\x02\xBA\xFB\x05\xDE\x20\xC9\xDF\xBC\x17\x06\x60\xD9\x29\xEC\xB5\x0B\xC9\xB9\xBE\x90\x86\x25\xDB\x80\x3A\xB7\x6C\x5F\x09\xB8\x55\x98\xCC\xDB\x37\x93\xB9\x0C\xC9\xAE\xA8\xB9\x83\x2D\xDA\x35\xD3\xBB\x0C\xC9\xA1\xC3\xB6\xEC\xDD\xD4\xD6\xA5\x09\xB9\xD9\x4B\xDC\x7C\xB5\xD3\xBB\x33\x09\xB9\xC1\xFA\xC1\x21\xBB\xBC\xD8\x65\x34\x09\xBF\x5B\xDA\x5A\xDA\x40\x4B\x53\xBB\x35\x06\x63\xDC\x03\x2C\xE1\x87\xEC\x06\x60\x75\xD1\xE4\xB5\x6D\x06\x62\xBC\x8B\xEC\xB4\x37\x06\x61\xDF\x03\x28\xE1\x87\xEF\x09\xB8\xDE\x22\xE3\x20", + "\xE1\x53\xB9\x1C\x06\x69\xE4\x83\x25\x5B\xBA\x72\x0C\xE6\x8F\xFA\xC2\x21\x39\x09\xBD\xE5\xF3\xC2\x20\x84\x82\x2F\xE5\x0E\xF5\x0E\x60\x3B\xEB\xA0\x6B\xF6\x09\xB9\xA0\xC0\x04\x80\x3D\xE3\x20\xC0\xFF\xB8\x0F\x99\xF6\x57\xC2\x21\xEC\xB4\x1F\x49\xB9\xE9\x13\xD7\x22\x21\x54\xD7\xBE\x6D\x7E\x09\xB8\xA8\xD6\xE9\x21\x5E\xE1\x22\xAB\xA8\x60\x11\xE4\x9F\xC1\xE0\x81\xAA\x23\xC9\xB4\xE1\x20\x41\x09\xBE\xC4\x03\x92\xB0\xD6\xAC\xB4\x11\xE4\xAC\xC7\xEB\x06\x30\xEC\x75\xAC\xB6\x11\xE4\x9F\xB0\xEF\x03\x37\xED\x40\x67\xEF\xBE\x44\x0D\xA6\x48\x7F\xE1\x23\xDA\xF2\xC6\x21\x46\x09\xBC\xC6\x68\xE9\xF0\x00\x59\xEB\x65\x47\x09\xBB\xC7\x91\xF5\xDF\x74\x91\x19\xB8\x20\xE8\xE8\xF2\x93\x9C\x21\xE8\xBF\x7C\x82\xD8\xA5\xF3\x2E\x34\xA7\x83\xFF\x07\x86\x96\x00\x09\x9D\xF5\xB9\x8D\x85\xEC\xA1\x23\xF6\xA7\xC2\xEE\xF6\x11\xB8\xF4\xFE\x00\x0F\x93\xDD\xFE\xF2\x97\x21\x20\xB0\x00\x5A\xB2\xF9\xE2\xC1\xF8\x81\xC8\xFC\x20\xFF\x15\x80\xA2\x9B\x00", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -8698,10 +8748,10 @@ namespace vl::glr::xml L"[27][XElement]< \"<\" NAME { XAttribute } ( \"/>\" | \">\" { XSubNode } \"\" ) >", L"[28][XSubNode] BEGIN ", L"[29][XSubNode] END [ENDING]", - L"[30][XSubNode]<< ( !XText @ | !XCData | !XComment | !XElement ) >>", - L"[31][XSubNode]<< ( !XText | !XCData @ | !XComment | !XElement ) >>", - L"[32][XSubNode]<< ( !XText | !XCData | !XComment @ | !XElement ) >>", - L"[33][XSubNode]<< ( !XText | !XCData | !XComment | !XElement @ ) >>", + L"[30][XSubNode]", + L"[31][XSubNode]", + L"[32][XSubNode]", + L"[33][XSubNode]", L"[34][XInstruction] BEGIN ", L"[35][XInstruction] END [ENDING]", L"[36][XInstruction]< \"\" >", diff --git a/Import/VlppGlrParser.h b/Import/VlppGlrParser.h index c53f0da6..5f86a6e1 100644 --- a/Import/VlppGlrParser.h +++ b/Import/VlppGlrParser.h @@ -279,23 +279,19 @@ AST (Visitor) Instructions ***********************************************************************/ + constexpr vint32_t ResolveAmbiguitySlotIndex = -2; + enum class AstInsType { - Token, // Token() : Push the current token as a value. - EnumItem, // EnumItem(Value) : Push an enum item. - BeginObject, // BeginObject(Type) : Begin creating an AST node. - DelayFieldAssignment, // DelayFieldAssignment() : An object will be created later by ReopenObject, delay future field assignments to this object before ReopenObject. - ReopenObject, // ReopenObject() : Move the last pushed object back to creating status. - EndObject, // EndObject() : Finish creating an AST node, all objects pushed after BeginObject are supposed to be its fields. - DiscardValue, // DiscardValue() : Remove a pushed value. - LriStore, // LriStore() : Take the top object away and store to a register temporarily. - LriFetch, // LriFetch() : Clear the register and put it back as a top object. - Field, // Field(Field) : Associate a field name with the top object. - FieldIfUnassigned, // FieldIfUnassigned(Field) : Like Field(Field) but only take effect if such field has never been assigned. - ResolveAmbiguity, // ResolveAmbiguity(Type, Count) : Combine several top objects to one using an ambiguity node. Type is the type of each top object. - - AccumulatedDfa, // AccumulatedDfa(Count) : Multiple DelayFieldAssignment - AccumulatedEoRo, // AccumulatedEoRo(Count) : Multiple EndObject + ReopenObject + Token, // Token(Count) : Put the current token in the Count-th slot. + EnumItem, // EnumItem(Value, Count) : Put an enum item in the Count-th slot. + StackBegin, // StackBegin() : Begin a new stack frame. + StackSlot, // StackSlot(Count) : Assign the just created object to the Count-th slot. Reset the creating object. + CreateObject, // CreateObject(Type) : Create an AST node, it becomes the creating object. Error if the previous creating object has not been reset. + Field, // Field(Field, Count) : Associate a field name of the creating object with the value in the Count-th slot. Ignored if the Count-th slot is empty. + FieldIfUnassigned, // FieldIfUnassigned(Field, Count) : Like Field(Field) but only take effect if such field has never been assigned. + StackEnd, // StackEnd() : End the current stack frame. Leave the creating object as is. + ResolveAmbiguity, // ResolveAmbiguity(Type) : Combine several values in the specified slot to one using an ambiguity node. Type is the type of each value. }; struct AstIns @@ -324,28 +320,22 @@ Instructions UnknownType, // UnknownType(Type) : The type id does not exist. UnknownField, // UnknownField(Field) : The field id does not exist. UnsupportedAbstractType, // UnsupportedAbstractType(Type) : Unable to create abstract class. - UnsupportedAmbiguityType, // UnsupportedAmbiguityType(Type) : The type is not configured to allow ambiguity. - UnexpectedAmbiguousCandidate, // UnexpectedAmbiguousCandidate(Type) : The type of the ambiguous candidate is not compatible to the required type. FieldNotExistsInType, // FieldNotExistsInType(Field) : The type doesn't have such field. FieldReassigned, // FieldReassigned(Field) : An object is assigned to a field but this field has already been assigned. FieldWeakAssignmentOnNonEnum, // FieldWeakAssignmentOnNonEnum(Field) : Weak assignment only available for field of enum type. ObjectTypeMismatchedToField, // ObjectTypeMismatchedToField(Field) : Unable to assign an object to a field because the type does not match. - NoRootObject, // NoRootObject() : There is no created objects. - NoRootObjectAfterDfa, // NoRootObjectAfterDfa() : There is no created objects after DelayFieldAssignment. - TooManyUnassignedValues, // LeavingUnassignedValues() : The value to reopen is not the only unassigned value. - MissingDfaBeforeReopen, // MissingDfaBeforeReopen() : DelayFieldAssignment is not submitted before ReopenObject. - MissingValueToReopen, // MissingValueToReopen() : There is no pushed value to reopen. - ReopenedValueIsNotObject, // ReopenedValueIsNotObject() : The pushed value to reopen is not an object. - MissingValueToDiscard, // MissingValueToDiscard() : There is no pushed value to discard. - MissingValueToLriStore, // MissingValueToLriStore() : There is no pushed value to run LriStore. - LriStoredValueIsNotObject, // LriStoredValueIsNotObject() : The value to run LriStore is not an object. - LriStoredValueNotCleared, // LriStoredValueNotCleared() : LriFetch is not executed before the next LriStore. - LriStoredValueNotExists, // LriStoredValueNotExists() : LriStore is not executed before the next LriFetch. - LeavingUnassignedValues, // LeavingUnassignedValues() : There are still values to assign to fields before finishing an object. - MissingFieldValue, // MissingFieldValue() : There is no pushed value to be assigned to a field. - MissingAmbiguityCandidate, // MissingAmbiguityCandidate() : There are not enough candidates to create an ambiguity node. + UnsupportedAmbiguityType, // UnsupportedAmbiguityType(Type) : The type is not configured to allow ambiguity. + UnexpectedAmbiguousCandidate, // UnexpectedAmbiguousCandidate(Type) : The type of the ambiguous candidate is not compatible to the required type. + MissingAmbiguityCandidate, // MissingAmbiguityCandidate() : There are less than two candidates to create an ambiguity node. AmbiguityCandidateIsNotObject, // AmbiguityCandidateIsNotObject() : Tokens or enum items cannot be ambiguity candidates. + + NoStackFrame, // NoStackFrame() : Stack operations are executed while no stack frame exists. + NoStackFrameForStackEnd, // NoStackFrameForStackEnd() : StackEnd when no stack frame exists. + NoCreatingObjectForField, // NoCreatingObjectForField() : Field when no creating object. + NoCreatingObjectForStackSlot, // NoCreatingObjectForStackSlot() : StackSlot when no creating object. + NoCreatingObjectForStackEnd, // NoCreatingObjectForStackEnd() : StackEnd when no creating object. + InstructionNotComplete, // InstructionNotComplete() : No more instruction but the root object has not been completed yet. Corrupted, // Corrupted() : An exception has been thrown therefore this receiver cannot be used anymore. Finished, // Finished() : The finished instruction has been executed therefore this receiver cannot be used anymore. @@ -379,61 +369,54 @@ IAstInsReceiver class AstInsReceiverBase : public Object, public virtual IAstInsReceiver { private: - struct ObjectOrToken + struct TokenSlot + { + regex::RegexToken token; + vint32_t index = -1; + + auto operator<=>(const TokenSlot&) const = default; + }; + + struct EnumItemSlot + { + vint32_t value = -1; + + auto operator<=>(const EnumItemSlot&) const = default; + }; + + using SlotValue = Variant>; + + struct SlotStorage + { + SlotValue value; + Ptr> additionalValues; + + auto operator<=>(const SlotStorage&) const = default; + }; + using SlotMap = collections::Dictionary; + + struct StackFrame + { + SlotMap slots; + ParsingTextPos codeRangeStart; + }; + using StackFrameList = collections::List; + + struct CreatingObject { Ptr object; - vint32_t enumItem = -1; - regex::RegexToken token = {}; - vint32_t tokenIndex = -1; - - explicit ObjectOrToken(Ptr _object) : object(_object) {} - explicit ObjectOrToken(vint32_t _enumItem) : enumItem(_enumItem) {} - explicit ObjectOrToken(const regex::RegexToken& _token, vint32_t _tokenIndex) : token(_token), tokenIndex(_tokenIndex) {} + vint32_t type = -1; }; + using CreatingObjectList = collections::List; - struct FieldAssignment - { - ObjectOrToken value; - vint32_t field = -1; - bool weakAssignment = false; - }; - - struct CreatedObject - { - Ptr object; - vint pushedCount; - - regex::RegexToken delayedToken; - collections::List delayedFieldAssignments; - vint extraEmptyDfaBelow = 0; - - CreatedObject(Ptr _object, vint _pushedCount) - : object(_object) - , pushedCount(_pushedCount) - { - } - - CreatedObject(Ptr _object, vint _pushedCount, const regex::RegexToken& _delayedToken) - : object(_object) - , pushedCount(_pushedCount) - , delayedToken(_delayedToken) - { - } - }; - - collections::List created; - collections::List pushed; - Ptr lriStoredObject; + CreatingObjectList creatingObjects; + StackFrameList stackFrames; bool finished = false; bool corrupted = false; void EnsureContinuable(); - void SetField(ParsingAstBase* object, vint32_t field, const ObjectOrToken& value, bool weakAssignment); + void SetField(ParsingAstBase* object, vint32_t field, const SlotValue& value, bool weakAssignment); - CreatedObject& PushCreated(CreatedObject&& createdObject); - const CreatedObject& TopCreated(); - void PopCreated(); - void DelayAssign(FieldAssignment&& fa); protected: virtual Ptr CreateAstNode(vint32_t type) = 0; virtual void SetField(ParsingAstBase* object, vint32_t field, Ptr value) = 0; @@ -639,6 +622,7 @@ Reflection #endif + /*********************************************************************** .\ASTPRINT.H ***********************************************************************/ @@ -788,6 +772,12 @@ Executable vint32_t count = 0; }; + struct CompetitionArray + { + vint32_t start = -1; + vint32_t count = 0; + }; + struct ReturnIndexArray { vint32_t start = -1; @@ -800,11 +790,10 @@ Executable vint32_t count = 0; }; - enum class EdgePriority + struct CompetitionDesc { - NoCompetition, - HighPriority, - LowPriority, + vint32_t competitionId = -1; + bool highPriority = false; }; enum class ReturnRuleType @@ -819,7 +808,7 @@ Executable { vint32_t consumedRule = -1; vint32_t returnState = -1; - EdgePriority priority = EdgePriority::NoCompetition; + CompetitionArray competitions; ReturnRuleType ruleType = ReturnRuleType::Field; InstructionArray insAfterInput; }; @@ -829,8 +818,7 @@ Executable vint32_t fromState = -1; vint32_t toState = -1; StringLiteral condition; - EdgePriority priority = EdgePriority::NoCompetition; - InstructionArray insBeforeInput; + CompetitionArray competitions; InstructionArray insAfterInput; ReturnIndexArray returnIndices; }; @@ -838,7 +826,6 @@ Executable struct StateDesc { vint32_t rule = -1; - vint32_t clause = -1; bool endingState = false; }; @@ -855,6 +842,7 @@ Executable collections::Array transitions; // transitions[state * (TokenBegin + tokenCount) + input] = edges from state with specified input. collections::Array astInstructions; // referenced by EdgeDesc::insBeforeInput and EdgeDesc::insAfterInput collections::Array returnIndices; // referenced by ReturnIndexArray + collections::Array competitions; // referenced by EdgeArray collections::Array returns; // referenced by Executable::returnIndices collections::Array edges; // referenced by EdgeArray collections::Array states; // referenced by returnState/fromState/toState @@ -1802,9 +1790,8 @@ AllocateOnly explicit Ref(vint32_t _handle) :handle(_handle) {} __forceinline bool operator==(NullRef) const { return handle == -1; } - - __forceinline std::strong_ordering operator<=>(const Ref& ref) const { return handle <=> ref.handle; } __forceinline bool operator==(const Ref& ref) const { return handle == ref.handle; } + __forceinline std::strong_ordering operator<=>(const Ref& ref) const = default; __forceinline Ref& operator=(const Ref& ref) { handle = ref.handle; return *this; } __forceinline Ref& operator=(T* obj) { handle = obj == nullptr ? -1 : obj->allocatedIndex; return *this; } @@ -1876,7 +1863,6 @@ AllocateOnly struct ReturnStack; struct Trace; struct TraceExec; - struct InsExec_Object; /*********************************************************************** TraceManager (Data Structures) @@ -1927,7 +1913,7 @@ TraceManager (Data Structures) vint32_t currentTokenIndex = -1; // currentTokenIndex from the trace that creates this competition vint32_t ruleId = -1; // the rule id of state, when an edge starts this competition - vint32_t clauseId = -1; // the clause id of the state, when an edge starts this competition + vint32_t competitionId = -1; // the unique competition id in a rule, when an edge starts this competition // an state must be picked up and ensure that, the syntax creating the priority and the state belong to the same clause vint32_t highCounter = 0; // temporary counter for all existing high bets @@ -1953,6 +1939,21 @@ TraceManager (Data Structures) /*********************************************************************** TraceManager (Data Structures -- Input/EndOfInput) + +For a trace like: + A + / \ +B C + \ / + D + +A.successors.(first .. last) = {B,C} +B.successors.siblingNext = C +C.successors.siblingPrev = B +(B, C).successors.(first .. last) = {D} + +predecessors are for reverse relationships. +Such data structure makes many-to-many relationships impossible to represent. ***********************************************************************/ struct TraceCollection @@ -1970,7 +1971,7 @@ TraceManager (Data Structures -- Input/EndOfInput) Ref attendingCompetitions; // a linked list containing all AttendingCompetitions that this trace is attending // predecessors could share and modify the same linked list // if a competition is over, node could be removed from the linked list - // one competition only creates two AttendingCompetitions, traces with the same bet share the object + // one competition only creates two AttendingCompetitions, traces with the same bet sharing the object Ref carriedCompetitions; // all attended competitions regardless of the status of the competition }; @@ -2002,13 +2003,17 @@ TraceManager (Data Structures -- Input/EndOfInput) }; /*********************************************************************** -TraceManager (Data Structures -- PrepareTraceRoute/ResolveAmbiguity) +TraceManager (Data Structures -- PrepareTraceRoute) ***********************************************************************/ + struct InsExec_Stack; + struct InsRef { Ref trace; vint32_t ins = -1; + + __forceinline std::strong_ordering operator<=>(const InsRef& ref) const = default; }; struct InsExec_InsRefLink : Allocatable @@ -2017,116 +2022,142 @@ TraceManager (Data Structures -- PrepareTraceRoute/ResolveAmbiguity) InsRef insRef; }; - struct InsExec_ObjRefLink : Allocatable + struct InsExec_StackRefLink : Allocatable { - Ref previous; - Ref id; + Ref previous; + Ref id; }; - struct InsExec_Object : Allocatable, WithMagicCounter + struct InsExec_StackArrayRefLink : Allocatable, WithMagicCounter { - static const vint32_t TokenOrEnumItemObjectId = -2; + Ref previous; + Ref ids; - // previous allocated object - Ref previous; + // The current depth of the link. The first one is 0. + vint currentDepth = -1; - // fieldObjectIds are object fields of this object - Ref fieldObjectIds; + // Available when the link is in InsExec_Context::createStack + // It records the InsExec_Context::objectStack depth when the link is created. + vint objectStackDepthForCreateStack = -1; + }; - // assignedToObjectIds are objects who has at least one field that is this object - Ref assignedToObjectIds; + struct InsExec_StackSummarizing + { + // The earliest StackBegin instructions including in useFromStacks + InsRef earliestLocalInsRef; - // instruction that creates this object - InsRef createInsRef; + // The earliest StackBegin instructions including in useFromStacks and fieldStacks + InsRef earliestStackInsRef; - // DelayFieldAssignment instructions that associates to the current object - Ref dfaInsRefs; + // earliestStackInsRef but propogated back into useFromStacks + InsRef earliestInsRef; - // first instruction that creates this object - InsRef topLocalInsRef; - - // first instruction that creates this object or its fields - InsRef topInsRef; - - // last instructions that closes this object + // StackEnd instructions mapping earliestInsRef. + // Such StackBegin and StackEnd may not belong to the same stack. + // But belong to the out-most stack. Ref bottomInsRefs; + + // All CreateObject instructions including in useFromStacks + Ref indirectCreateObjectInsRefs; }; - struct InsExec_ObjectStack : Allocatable, WithMagicCounter + struct InsExec_Stack : Allocatable, WithMagicCounter { - Ref previous; - Ref objectIds; - vint32_t pushedCount = -1; // number for InsExec_CreateStack::stackBase - }; + // previous allocated object + Ref previous; - struct InsExec_CreateStack : Allocatable, WithMagicCounter - { - Ref previous; - vint32_t stackBase = -1; // the number of objects in the object stack that is frozen + // owner-field relationships + Ref fieldStacks; - // All InsExec_InsRefLink that create the current InsExec_CreateStack - Ref createInsRefs; + // useFrom-useBy relationships + Ref useFromStacks; - // InsExec_ObjRefLink assigned by BO/BOLA/RO - Ref objectIds; + // fieldStacks and useFromStacks + Ref allDependentStacks; - // objectIds will be added to reverseAssignedToObjectIds::assignedToObjectIds when ReopenObject happens - // it happens when a field is assigned to a DFA created object, the objectIds are unknown yet - Ref reverseAssignedToObjectIds; + // Key instructions in this stack + InsRef beginInsRef; + Ref createObjectInsRefs; + Ref endWithCreateInsRefs; + Ref endWithReuseInsRefs; + + InsExec_StackSummarizing summarizing; }; struct InsExec_Context { - Ref objectStack; // InsExec_ObjectStack after executing instructions - Ref createStack; // InsExec_CreateStack after executing instructions - Ref lriStoredObjects; // LriStore stored InsExec_ObjRefLink after executing instructions + Ref objectStack; // Stack of created objects + Ref createStack; // Stack of opening objects }; struct InsExec : WithMagicCounter { - // BO: - // the created object - Ref createdObjectId; + // Stack operated by StackBegin/StackEnd/CreateObject + Ref operatingStacks; - // DFA: - // all associated objects - // EO: - // all ended objects - Ref objRefs; - - // InsExec_InsRefLink - // BO/DFA: - // EndingObject instructions that close objects or create stack created by the current instruction - Ref eoInsRefs; - - // context before executing the current instruction + // Context before executing this instruction InsExec_Context contextBeforeExecution; }; +/*********************************************************************** +TraceManager (Data Structures -- ResolveAmbiguity) + +A branch begins from: + The initial trace + Successors of a branch trace (a trace with multiple successors) + A merge trace (a trace with multiple predecessors) +branchData.forwardTrace points to the nearest beginning of a trace. + +Here a demos of which traces are beginnings: + A* + | + B + / \ +C* D* +| | +E F + \ / + G*(cfb->B) + | + H + +For any merge trace, its branchData.commonForwardBranch points to the latest forwardTrace that all comming branches share. +It does not necessary equal to branchData.forwardTrace of all predecessors as their values might be different. + +All branch traces can be found beginning from TraceManager::firstBranchTrace following nextBranchTrace. +All merge traces can be found beginning from TraceManager::firstMergeTrace following nextMergeTrace. +Traversing through branchData.forwardTrace and branchData.commonForwardBranch will skip all branches going forward. +***********************************************************************/ + + // TraceAmbiguity describes where an ambiguity resolving begins and ends struct TraceAmbiguity : Allocatable { - // all objects to merge - Ref bottomObjectIds; + // all objects to merge, they all have valid createObjectInsRef + Ref bottomCreateObjectStacks; // if multiple TraceAmbiguity are assigned to the same place // it records the one it overrides Ref overridedAmbiguity; // the trace where ambiguity resolution begins - // prefix is the number of instructions before BO/DFA + // prefix is the number of instructions before SB // if prefix + 1 is larger than instructions in firstTrace - // then BO/DFA is in all successors + // then StackBegin is in all successors // these instructions create topObjectIds Ref firstTrace; vint32_t prefix = -1; // the trace when ambiguity resolution ends - // postfix is the number of instructions after EO + // postfix is the number of instructions after SE // if lastTrace is a merge trace - // then EO is in all predecessors + // then StackEnd is in all predecessors // these instructions end bottomObjectIds Ref lastTrace; vint32_t postfix = -1; + + // The merge trace that creates this TraceAmbiguity, and its associated branch trace + Ref branchTrace; + Ref mergeTrace; }; struct TraceAmbiguityLink : Allocatable @@ -2137,12 +2168,10 @@ TraceManager (Data Structures -- PrepareTraceRoute/ResolveAmbiguity) struct TraceInsLists { - InstructionArray edgeInsBeforeInput; InstructionArray edgeInsAfterInput; InstructionArray returnInsAfterInput; - vint32_t c1; - vint32_t c2; - vint32_t c3; + vint32_t countAfterInput; + vint32_t countAll; }; struct TraceBranchData : WithMagicCounter @@ -2158,24 +2187,25 @@ TraceManager (Data Structures -- PrepareTraceRoute/ResolveAmbiguity) Ref commonForwardBranch; }; + // TraceExec stores all ambiguity awared data for a trace struct TraceExec : Allocatable { Ref traceId; TraceInsLists insLists; // instruction list of this trace InstructionArray insExecRefs; // allocated InsExec for instructions - InsExec_Context context; - TraceBranchData branchData; + InsExec_Context context; // context after executing all instructions + TraceBranchData branchData; // branch shapes - // linked list of branch traces + // linked list of branch traces, in a global depth-first order, from TraceManager::firstBranchTrace Ref nextBranchTrace; - // linked list of merge traces + // linked list of merge traces, in a global depth-first order, from TraceManager::firstMergeTrace Ref nextMergeTrace; - // linked list of ambiguity critical trace (order by trace id ascending) - // the linked list begins from a trace whose forwardTrace is itself - // record all traces that is + // linked list of ambiguity critical trace + // it is stored in a trace whose forwardTrace is itself + // record all traces with the same forwardTrace value, order by trace id ascending // a branch trace // a predecessor of a merge trace // a trace pointed by TraceAmbiguity::firstTrace @@ -2183,32 +2213,32 @@ TraceManager (Data Structures -- PrepareTraceRoute/ResolveAmbiguity) // TraceAmbiguity associated to the trace // it could be associated to - // firstTrace (order by prefix ascending) - // lastTrace (order by postfix ascending) + // TraceAmbiguity::firstTrace (order by prefix ascending) + // TraceAmbiguity::lastTrace (order by postfix ascending) // the merge trace that create this TraceAmbiguity // ambiguityBegins will contain multiple TraceAmbiguity when // multiple ambiguity begins in different group of successors // there is also a possibility when all ambiguities don't cover all successors - Ref ambiguityDetected; - Ref ambiguityBegins; - // when this trace is a successor of a branch trace - // and such branch trace has non-empty ambiguityBegins - // ambiguityCoveredInForward points to the ambiguity which begins in the current trace - Ref ambiguityCoveredInForward; + Ref ambiguityDetected; // The TraceAmbiguity whose lastTrace is this trace + // Referring to the last StackEnd of all predecessors + // Or the opening object at the end of the trace + + Ref ambiguityBegins; // All TraceAmbiguity whose firstTrace is this trace + // All TraceAmbiguity in this list are grouped by lastTrace (using TraceAmbiguity::overridedAmbiguity) + // To traverse all of them, begins from each TraceAmbiguity in this list, and go through TraceAmbiguity::overridedAmbiguity }; /*********************************************************************** TraceManager (Data Structures -- BuildExecutionOrder) ***********************************************************************/ - struct ExecutionStep; - enum class ExecutionType { - Empty, Instruction, - ResolveAmbiguity, + RA_Begin, + RA_Branch, + RA_End, }; struct ExecutionStep : Allocatable @@ -2223,31 +2253,35 @@ TraceManager (Data Structures -- BuildExecutionOrder) struct ETRA { - vint32_t count; vint32_t type; vint32_t trace; }; ExecutionType type = ExecutionType::Instruction; - // for steps that ready to execute - // "next" means the next step to execute - // for steps that returns from BuildStepTree - // "next" in a leaf step points to the next leaf step - Ref next; - - // for steps that returns from BuildStepTree - // "next" is the parent step in the tree - Ref parent; - - vint32_t copyCount = 0; - vint32_t visitCount = 0; - union { ETI et_i; ETRA et_ra; }; + + // list (parent, next) + // tree (parent, leafPrev, leafNext) + Ref next, parent, leafNext; + vint32_t visitCount = 0; + vint32_t copyCount = 0; + }; + + struct ExecutionStepLinkedList + { + ExecutionStep* first = nullptr; + ExecutionStep* last = nullptr; + }; + + struct ExecutionStepTree + { + ExecutionStep* firstLeaf = nullptr; + ExecutionStep* lastLeaf = nullptr; }; /*********************************************************************** @@ -2274,8 +2308,6 @@ TraceManager } }; - struct TraceManagerSubmitter; - class TraceManager : public Object, public virtual IExecutor { protected: @@ -2310,7 +2342,7 @@ TraceManager void TryMergeSurvivingTraces(); // Competition - void AttendCompetition(Trace* trace, Ref& newAttendingCompetitions, Ref& newCarriedCompetitions, Ref returnStack, vint32_t ruleId, vint32_t clauseId, bool forHighPriority); + void AttendCompetition(Trace* trace, Ref& newAttendingCompetitions, Ref& newCarriedCompetitions, Ref returnStack, vint32_t ruleId, CompetitionDesc comp); void AttendCompetitionIfNecessary(Trace* trace, vint32_t currentTokenIndex, EdgeDesc& edgeDesc, Ref& newAttendingCompetitions, Ref& newCarriedCompetitions, Ref& newReturnStack); void CheckAttendingCompetitionsOnEndingEdge(Trace* trace, EdgeDesc& edgeDesc, Ref acId, Ref returnStack); bool CheckBackupTracesBeforeSwapping(vint32_t currentTokenIndex); @@ -2322,6 +2354,7 @@ TraceManager // Walk bool IsQualifiedTokenForCondition(regex::RegexToken* token, StringLiteral condition); bool IsQualifiedTokenForEdgeArray(regex::RegexToken* token, EdgeArray& edgeArray); + void TestLeftrecEdgeQualification(EdgeDesc& edgeDesc, regex::RegexToken* lookAhead, bool& acceptLookAhead, bool& acceptEndingInput); WalkingTrace WalkAlongSingleEdge(vint32_t currentTokenIndex, vint32_t input, WalkingTrace trace, vint32_t byEdge, EdgeDesc& edgeDesc); void WalkAlongLeftrecEdges(vint32_t currentTokenIndex, regex::RegexToken* lookAhead, WalkingTrace trace, EdgeArray& edgeArray); void WalkAlongEpsilonEdges(vint32_t currentTokenIndex, regex::RegexToken* lookAhead, WalkingTrace trace); @@ -2336,6 +2369,8 @@ TraceManager template void IterateSurvivedTraces(TCallback&& callback); + + public: void ReadInstructionList(Trace* trace, TraceInsLists& insLists); AstIns& ReadInstruction(vint32_t instruction, TraceInsLists& insLists); @@ -2343,66 +2378,54 @@ TraceManager // PrepareTraceRoute AllocateOnly traceExecs; collections::Array insExecs; - AllocateOnly insExec_Objects; + AllocateOnly insExec_Stacks; AllocateOnly insExec_InsRefLinks; - AllocateOnly insExec_ObjRefLinks; - AllocateOnly insExec_ObjectStacks; - AllocateOnly insExec_CreateStacks; + AllocateOnly insExec_StackRefLinks; + AllocateOnly insExec_StackArrayRefLinks; // phase: AllocateExecutionData void AllocateExecutionData(); + // phase: BuildAmbiguityStructures + Trace* StepForward(Trace* trace); + void BuildAmbiguityStructures(); + // phase: PartialExecuteTraces - PartialExecuteOrdinaryTrace - InsExec_Object* NewObject(); - vint32_t GetStackBase(InsExec_Context& context); - vint32_t GetStackTop(InsExec_Context& context); + InsExec_Stack* NewStack(); void PushInsRefLink(Ref& link, InsRef insRef); - void PushObjRefLink(Ref& link, Ref id); + void PushStackRefLink(Ref& link, Ref id); + void PushStackArrayRefLink(Ref& arrayLink, Ref id); + void PushStackArrayRefLink(Ref& arrayLink, Ref link); Ref JoinInsRefLink(Ref first, Ref second); - Ref JoinObjRefLink(Ref first, Ref second); - void PushAssignedToObjectIdsSingleWithMagic(Ref fieldObjectIds, Ref assignedToTarget); - void PushAssignedToObjectIdsMultipleWithMagic(Ref fieldObjectIds, Ref assignedToTargets); - InsExec_ObjectStack* PushObjectStackSingle(InsExec_Context& context, Ref objectId); - InsExec_ObjectStack* PushObjectStackMultiple(InsExec_Context& context, Ref linkId); - InsExec_CreateStack* PushCreateStack(InsExec_Context& context); + Ref JoinStackRefLink(Ref first, Ref second); void PartialExecuteOrdinaryTrace(Trace* trace); // phase: PartialExecuteTraces - EnsureInsExecContextCompatible void EnsureInsExecContextCompatible(Trace* baselineTrace, Trace* commingTrace); // phase: PartialExecuteTraces - MergeInsExecContext - void PushInsRefLinkWithCounter(Ref& link, Ref comming); - void PushObjRefLinkWithCounter(Ref& link, Ref comming); - template), Ref (InsExec_Context::*stack), typename TMerge> - Ref MergeStack(Trace* mergeTrace, AllocateOnly& allocator, TMerge&& merge); + template (InsExec_Context::*stack), typename TMerge> + Ref MergeStack(Trace* mergeTrace, TMerge&& merge); void MergeInsExecContext(Trace* mergeTrace); - // phase: PartialExecuteTraces - CalculateObjectFirstInstruction - bool UpdateTopTrace(InsRef& topInsRef, InsRef newInsRef); - void InjectFirstInstruction(InsRef insRef, Ref injectTargets, vuint64_t magicInjection); - void CalculateObjectFirstInstruction(); - - // phase: PartialExecuteTraces - CalculateObjectLastInstruction - bool IsInTheSameBranch(Trace* forward, Trace* targetForwardAtFront); - void CalculateObjectLastInstruction(); - // phase: PartialExecuteTraces void PartialExecuteTraces(); - // phase: BuildAmbiguityStructures - Trace* StepForward(Trace* trace); - void BuildAmbiguityStructures(); - -#if defined VCZH_MSVC && defined _DEBUG - // phase: DebugCheckTraceExecData - void DebugCheckTraceExecData(); -#endif + // phase: SummarizeInstructionRange + template + void IterateStackWithDependency(Ref(InsExec_Stack::* dependencies), TCallback&& callback); + bool UpdateTopTrace(InsRef& topInsRef, InsRef newInsRef); + void CollectInsRefs(collections::SortedList& insRefs, Ref link); + void SummarizeEarilestLocalInsRefs(); + void SummarizeEarilestStackInsRefs(); + void SummarizeEarilestInsRefs(); + void SummarizeInstructionRange(); protected: // ResolveAmbiguity Ref firstBranchTrace; Ref firstMergeTrace; - Ref firstObject; + Ref firstStack; Ref firstStep; AllocateOnly traceAmbiguities; AllocateOnly traceAmbiguityLinks; @@ -2410,41 +2433,90 @@ TraceManager // phase: CheckMergeTraces template - bool EnumerateObjects(Ref objRefLinkStartSet, bool withCounter, TCallback&& callback); + bool EnumerateObjects(Ref stackRefLinkStartSet, bool withCounter, TCallback&& callback); template - bool EnumerateBottomInstructions(InsExec_Object* ieObject, TCallback&& callback); + bool EnumerateBottomInstructions(InsExec_Stack* ieObject, TCallback&& callback); bool ComparePrefix(TraceExec* baselineTraceExec, TraceExec* commingTraceExec, vint32_t prefix); bool ComparePostfix(TraceExec* baselineTraceExec, TraceExec* commingTraceExec, vint32_t postfix); template - bool CheckAmbiguityResolution(TraceAmbiguity* ta, collections::List>& visitingIds, TCallback&& callback); - bool CheckMergeTrace(TraceAmbiguity* ta, Trace* trace, TraceExec* traceExec, collections::List>& visitingIds); + bool CheckAmbiguityResolution(TraceAmbiguity* ta, collections::List>& visitingIds, collections::List* failureReasons, TCallback&& callback); + bool CheckSingleMergeTrace(TraceAmbiguity* ta, Trace* trace, TraceExec* traceExec, collections::List>& visitingIds, collections::List* failureReasons); void LinkAmbiguityCriticalTrace(Ref traceId); void CheckTraceAmbiguity(TraceAmbiguity* ta); -#if defined VCZH_MSVC && defined _DEBUG - void DebugCheckTraceAmbiguitiesInSameTrace(Trace* trace, TraceExec* traceExec); -#endif void MarkAmbiguityCoveredForward(Trace* currentTrace, TraceAmbiguity* ta, Trace* firstTrace, TraceExec* firstTraceExec); void CategorizeTraceAmbiguities(Trace* trace, TraceExec* traceExec); void CheckMergeTraces(); // phase: BuildExecutionOrder -#define DEFINE_EXECUTION_STEP_CONTEXT ExecutionStep*& root, ExecutionStep*& firstLeaf, ExecutionStep*& currentStep, ExecutionStep*& currentLeaf - void MarkNewLeafStep(ExecutionStep* step, ExecutionStep*& firstLeaf, ExecutionStep*& currentLeaf); - void AppendStepLink(ExecutionStep* first, ExecutionStep* last, bool leapNode, DEFINE_EXECUTION_STEP_CONTEXT); - void AppendStepsBeforeAmbiguity(Trace* startTrace, vint32_t startIns, TraceAmbiguity* ta, DEFINE_EXECUTION_STEP_CONTEXT); - void AppendStepsAfterAmbiguity(Trace*& startTrace, vint32_t& startIns, TraceAmbiguity* ta, DEFINE_EXECUTION_STEP_CONTEXT); - void AppendStepsForAmbiguity(TraceAmbiguity* ta, bool checkCoveredMark, DEFINE_EXECUTION_STEP_CONTEXT); - void AppendStepsBeforeBranch(Trace* startTrace, vint32_t startIns, Trace* branchTrace, TraceExec* branchTraceExec, DEFINE_EXECUTION_STEP_CONTEXT); - void BuildStepTree(Trace* startTrace, vint32_t startIns, Trace* endTrace, vint32_t endIns, ExecutionStep*& root, ExecutionStep*& firstLeaf, ExecutionStep* currentStep, ExecutionStep*& currentLeaf); - void ConvertStepTreeToLink(ExecutionStep* root, ExecutionStep* firstLeaf, ExecutionStep*& first, ExecutionStep*& last); - void BuildAmbiguousStepLink(TraceAmbiguity* ta, bool checkCoveredMark, ExecutionStep*& first, ExecutionStep*& last); + + + struct NestedAmbiguityInfo + { + collections::List nestedAmbiguities; // all nested ambiguities in order from outer to inner + collections::Dictionary branchTraces; // branchTrace to TraceAmbiguities + collections::Group branchSelections; // critial successors of each TraceAmbiguities' branchTrace from inner to outer + }; + + struct BSL_Guidance + { + const collections::List* branchSelections = nullptr; + const collections::List* ambiguitiesToSkip = nullptr; + + }; + + struct BSLA_Guidance + { + Ptr nestedTas; + vint nextAmbiguityIndex = 0; + }; + + void AppendStepsAfterList(ExecutionStepLinkedList steps, ExecutionStepLinkedList& current); + void AppendLeafToTree(ExecutionStep* leaf, ExecutionStepTree& tree); + ExecutionStepLinkedList ConvertStepTreeToList(ExecutionStepTree tree); + + ExecutionStep* CreateResolveAmbiguityStep(TraceAmbiguity* ta); + Ptr CollectNestedAmbiguities(TraceAmbiguity* ta); + + void BuildStepLeafsForAmbiguityBranch( + TraceAmbiguity* ta, + ExecutionStep* lastSharedStep, + Trace* ambiguityBranchStartTrace, + vint32_t* ambiguityBranchStartIns, + ExecutionStepTree& ambiguityStepTree); + void BuildStepLeafsForNestedAmbiguityBranch( + TraceAmbiguity* ta, + ExecutionStep* lastSharedStep, + BSLA_Guidance* guidance, + ExecutionStepTree& ambiguityStepTree); + ExecutionStepLinkedList BuildStepListForAmbiguity( + TraceAmbiguity* ta, + BSLA_Guidance* guidance); + ExecutionStepLinkedList BuildStepListThroughAmbiguity( + Trace*& currentTrace, + vint32_t& currentIns, + TraceAmbiguity* ta, + BSLA_Guidance* guidance + ); + ExecutionStepLinkedList BuildStepListUntilFirstRawBranchTrace( + Trace* startTrace, + vint32_t startIns, + Trace* endTrace, + vint32_t endIns, + BSL_Guidance* guidance, + Trace** rawBranchTrace); + ExecutionStepLinkedList BuildStepList( + Trace* startTrace, + vint32_t startIns, + Trace* endTrace, + vint32_t endIns, + BSL_Guidance* guidance); void BuildExecutionOrder(); -#undef DEFINE_EXECUTION_STEP_CONTEXT public: TraceManager(Executable& _executable, const ITypeCallback* _typeCallback, vint blockSize); vint32_t concurrentCount = 0; + Nullable concurrentCountBeforeError; collections::List* concurrentTraces = nullptr; collections::List* backupTraces = nullptr; @@ -2458,11 +2530,10 @@ TraceManager AttendingCompetitions* AllocateAttendingCompetitions(); InsExec* GetInsExec(vint32_t index); - InsExec_Object* GetInsExec_Object(Ref index); + InsExec_Stack* GetInsExec_Stack(Ref index); InsExec_InsRefLink* GetInsExec_InsRefLink(Ref index); - InsExec_ObjRefLink* GetInsExec_ObjRefLink(Ref index); - InsExec_ObjectStack* GetInsExec_ObjectStack(Ref index); - InsExec_CreateStack* GetInsExec_CreateStack(Ref index); + InsExec_StackRefLink* GetInsExec_StackRefLink(Ref index); + InsExec_StackArrayRefLink* GetInsExec_StackArrayRefLink(Ref index); TraceExec* GetTraceExec(Ref index); TraceAmbiguity* GetTraceAmbiguity(Ref index); TraceAmbiguityLink* GetTraceAmbiguityLink(Ref index); @@ -2479,11 +2550,85 @@ TraceManager void ResolveAmbiguity() override; protected: - void ExecuteSingleTrace(TraceManagerSubmitter& submitter, Trace* trace, vint32_t firstIns, vint32_t lastIns, TraceInsLists& insLists, collections::List& tokens); - void ExecuteSingleStep(TraceManagerSubmitter& submitter, ExecutionStep* step, collections::List& tokens); + void ExecuteSingleTrace(IAstInsReceiver& receiver, Trace* trace, vint32_t firstIns, vint32_t lastIns, TraceInsLists& insLists, collections::List& tokens); + void ExecuteSingleStep(IAstInsReceiver& receiver, ExecutionStep* step, collections::List& tokens); public: Ptr ExecuteTrace(IAstInsReceiver& receiver, collections::List& tokens) override; }; + + class TraceException : public Exception + { + public: + TraceException(TraceManager& tm, InsRef insRef, const wchar_t* phrase, const wchar_t* message) + : Exception( + WString::Unmanaged(L"[") + + WString::Unmanaged(phrase) + + WString::Unmanaged(L"] at ") + + itow(insRef.trace.handle) + WString::Unmanaged(L"@") + itow(insRef.ins) + + WString::Unmanaged(L" : ") + + WString::Unmanaged(message) + ) + { + } + + TraceException(TraceManager& tm, Trace* trace1, Trace* trace2, const wchar_t* phrase, const WString& message) + : Exception( + WString::Unmanaged(L"[") + + WString::Unmanaged(phrase) + + WString::Unmanaged(L"] at trace ") + + itow(trace1->allocatedIndex) + + (trace2 == nullptr ? WString::Empty : WString::Unmanaged(L" and ") + itow(trace2->allocatedIndex)) + + WString::Unmanaged(L" : ") + + message + ) + { + } + + TraceException(TraceManager& tm, Trace* trace1, Trace* trace2, const wchar_t* phrase, const wchar_t* message) + : TraceException(tm, trace1, trace2, phrase, WString::Unmanaged(message)) + { + } + + TraceException(TraceManager& tm, TraceAmbiguity* ta1, TraceAmbiguity* ta2, const wchar_t* phrase, const wchar_t* message) + : Exception( + WString::Unmanaged(L"[") + + WString::Unmanaged(phrase) + + WString::Unmanaged(L"] at trace ambiguity ") + + itow(ta1->firstTrace.handle) + WString::Unmanaged(L"@") + itow(ta1->prefix) + WString::Unmanaged(L"..") + + itow(ta1->lastTrace.handle) + WString::Unmanaged(L"@-") + itow(ta1->postfix) + + (ta2 == nullptr ? WString::Empty : + WString::Unmanaged(L" and ") + + itow(ta2->firstTrace.handle) + WString::Unmanaged(L"@") + itow(ta2->prefix) + WString::Unmanaged(L"..") + + itow(ta2->lastTrace.handle) + WString::Unmanaged(L"@-") + itow(ta2->postfix) + ) + + WString::Unmanaged(L" : ") + + WString::Unmanaged(message) + ) + { + } + + TraceException(TraceManager& tm, InsExec_Stack* stack, const wchar_t* phrase, const wchar_t* message) + : Exception( + WString::Unmanaged(L"[") + + WString::Unmanaged(phrase) + + WString::Unmanaged(L"] at trace ") + + itow(stack->allocatedIndex) + + WString::Unmanaged(L" : ") + + WString::Unmanaged(message) + ) + { + } + + TraceException(TraceManager& tm, const wchar_t* phrase, const wchar_t* message) + : Exception( + WString::Unmanaged(L"[") + + WString::Unmanaged(phrase) + + WString::Unmanaged(L"] : ") + + WString::Unmanaged(message) + ) + { + } + }; } } } diff --git a/Import/VlppGlrParserCompiler.cpp b/Import/VlppGlrParserCompiler.cpp index 7204dfcb..61acb134 100644 --- a/Import/VlppGlrParserCompiler.cpp +++ b/Import/VlppGlrParserCompiler.cpp @@ -95,7 +95,7 @@ WriteAstHeaderFile writer.WriteLine(L"#pragma once"); } writer.WriteLine(L""); - for (auto include : group->Owner()->Global().includes) + for (auto include : group->Owner()->Global().astIncludes) { if (include.Length() > 0 && include[0] == L'<') { @@ -3130,41 +3130,6 @@ CreateParserGenRuleAst _ReuseClause->CreateProp(L"syntax")->SetPropType(AstPropType::Type, L"Syntax"); _ReuseClause->CreateProp(L"assignments")->SetPropType(AstPropType::Array, L"Assignment"); - /////////////////////////////////////////////////////////////////////////////////// - // Left Recursion Clauses - /////////////////////////////////////////////////////////////////////////////////// - - auto _Lrp = _ast->CreateClass(L"LeftRecursionPlaceholder"); - _Lrp->CreateProp(L"flag")->SetPropType(AstPropType::Token); - - auto _LrpClause = _ast->CreateClass(L"LeftRecursionPlaceholderClause"); - _LrpClause->SetBaseClass(L"Clause"); - _LrpClause->CreateProp(L"flags")->SetPropType(AstPropType::Array, L"LeftRecursionPlaceholder"); - - auto LriConfig = _ast->CreateEnum(L"LeftRecursionConfiguration"); - LriConfig->CreateItem(L"Single"); - LriConfig->CreateItem(L"Multiple"); - - auto LriContinuationType = _ast->CreateEnum(L"LeftRecursionInjectContinuationType"); - LriContinuationType->CreateItem(L"Optional"); - LriContinuationType->CreateItem(L"Required"); - - auto _LriContinuation = _ast->CreateClass(L"LeftRecursionInjectContinuation"); - auto _LriClause = _ast->CreateClass(L"LeftRecursionInjectClause"); - - _LriContinuation->CreateProp(L"flags")->SetPropType(AstPropType::Array, L"LeftRecursionPlaceholder"); - _LriContinuation->CreateProp(L"configuration")->SetPropType(AstPropType::Type, L"LeftRecursionConfiguration"); - _LriContinuation->CreateProp(L"type")->SetPropType(AstPropType::Type, L"LeftRecursionInjectContinuationType"); - _LriContinuation->CreateProp(L"injectionTargets")->SetPropType(AstPropType::Array, L"LeftRecursionInjectClause"); - - _LriClause->SetBaseClass(L"Clause"); - _LriClause->CreateProp(L"rule")->SetPropType(AstPropType::Type, L"RefSyntax"); - _LriClause->CreateProp(L"continuation")->SetPropType(AstPropType::Type, L"LeftRecursionInjectContinuation"); - - auto _PmClause = _ast->CreateClass(L"PrefixMergeClause"); - _PmClause->SetBaseClass(L"Clause"); - _PmClause->CreateProp(L"rule")->SetPropType(AstPropType::Type, L"RefSyntax"); - /////////////////////////////////////////////////////////////////////////////////// // Rule /////////////////////////////////////////////////////////////////////////////////// @@ -3283,7 +3248,7 @@ WriteLexerHeaderFile writer.WriteLine(L"#pragma once"); } writer.WriteLine(L""); - for (auto include : manager.Global().includes) + for (auto include : manager.Global().astIncludes) { if (include.Length() > 0 && include[0] == L'<') { @@ -3644,10 +3609,6 @@ CreateParserGenAst manager.CreateToken(L"POSITIVE", L"/+"); manager.CreateToken(L"NEGATIVE", L"-"); - manager.CreateToken(L"LS_PH", L"left_recursion_placeholder"); - manager.CreateToken(L"LS_I", L"left_recursion_inject"); - manager.CreateToken(L"LS_IM", L"left_recursion_inject_multiple"); - manager.CreateToken(L"LS_PM", L"prefix_merge"); manager.CreateToken(L"ID", L"[a-zA-Z_][a-zA-Z0-9_]*"); manager.CreateToken(L"STRING", L"(\"[^\"]*\")+"); manager.CreateToken(L"CONDITIONAL_LITERAL", L"(\'[^\']*\')+"); @@ -3967,10 +3928,8 @@ namespace vl extern void CalculateFirstSet(VisitorContext& context, Ptr syntaxFile); extern void ValidateTypes(VisitorContext& context, Ptr syntaxFile); extern void ValidateStructure(VisitorContext& context, Ptr syntaxFile); - extern void ValidatePrefixMerge(VisitorContext& context, Ptr syntaxFile); extern Ptr RewriteSyntax_Switch(VisitorContext& context, VisitorSwitchContext& sContext, SyntaxSymbolManager& syntaxManager, Ptr syntaxFile); - extern Ptr RewriteSyntax_PrefixMerge(VisitorContext& context, SyntaxSymbolManager& syntaxManager, Ptr syntaxFile); extern void CompileSyntax(VisitorContext& context, Ptr output, Ptr syntaxFile); /*********************************************************************** @@ -3982,14 +3941,6 @@ CompileSyntax return syntaxFile->switches.Count() > 0; } - bool NeedRewritten_PrefixMerge(Ptr syntaxFile) - { - return !From(syntaxFile->rules) - .SelectMany([](auto rule) { return From(rule->clauses); }) - .FindType() - .IsEmpty(); - } - void CreateSyntaxSymbols(LexerSymbolManager& lexerManager, SyntaxSymbolManager& syntaxManager, vint fileIndex, Ptr syntaxFile) { for (auto rule : syntaxFile->rules) @@ -4012,20 +3963,6 @@ CompileSyntax rule->codeRange ); } - - for (auto clause : rule->clauses) - { - if (auto lrpClause = clause.Cast()) - { - for (auto flag : lrpClause->flags) - { - if (!syntaxManager.lrpFlags.Contains(flag->flag.value)) - { - syntaxManager.lrpFlags.Add(flag->flag.value); - } - } - } - } } } @@ -4046,7 +3983,7 @@ CompileSyntax return true; } - bool VerifySyntax_UntilPrefixMerge(VisitorContext& context, Ptr syntaxFile) + bool VerifySyntax_UntilCompile(VisitorContext& context, Ptr syntaxFile) { CalculateFirstSet(context, syntaxFile); if (context.syntaxManager.Global().Errors().Count() > 0) return false; @@ -4057,9 +3994,6 @@ CompileSyntax ValidateStructure(context, syntaxFile); if (context.syntaxManager.Global().Errors().Count() > 0) return false; - ValidatePrefixMerge(context, syntaxFile); - if (context.syntaxManager.Global().Errors().Count() > 0) return false; - return true; } @@ -4087,22 +4021,11 @@ CompileSyntax if (context.syntaxManager.Global().Errors().Count() > 0) goto FINISHED_COMPILING; } - if (NeedRewritten_PrefixMerge(syntaxFile)) { VisitorContext context(astManager, lexerManager, syntaxManager); VisitorSwitchContext sContext; if (!VerifySyntax_UntilSwitch(context, sContext, syntaxFile)) goto FINISHED_COMPILING; - if (!VerifySyntax_UntilPrefixMerge(context, syntaxFile)) goto FINISHED_COMPILING; - - syntaxFile = RewriteSyntax_PrefixMerge(context, syntaxManager, syntaxFile); - if (context.syntaxManager.Global().Errors().Count() > 0) goto FINISHED_COMPILING; - } - - { - VisitorContext context(astManager, lexerManager, syntaxManager); - VisitorSwitchContext sContext; - if (!VerifySyntax_UntilSwitch(context, sContext, syntaxFile)) goto FINISHED_COMPILING; - if (!VerifySyntax_UntilPrefixMerge(context, syntaxFile)) goto FINISHED_COMPILING; + if (!VerifySyntax_UntilCompile(context, syntaxFile)) goto FINISHED_COMPILING; CompileSyntax(context, output, syntaxFile); } FINISHED_COMPILING: @@ -4156,29 +4079,6 @@ DirectFirstSetVisitor return context.syntaxManager.Rules().Values()[index]; } - void AddStartLiteral(const ParsingToken& literal) - { - context.ruleBeginsWithLiteral.Add(ruleSymbol, literal); - context.clauseBeginsWithLiteral.Add(currentClause, literal); - } - - void AddStartTokenOrRule(const ParsingToken& literal) - { - if (auto startRule = TryGetRuleSymbol(literal.value)) - { - context.directStartRules.Add(ruleSymbol, { startRule,currentClause }); - context.clauseToStartRules.Add(currentClause, startRule); - if (ruleSymbol == startRule && !context.leftRecursiveClauses.Contains(ruleSymbol, currentClause)) - { - context.leftRecursiveClauses.Add(ruleSymbol, currentClause); - } - } - else - { - AddStartLiteral(literal); - } - } - public: DirectFirstSetVisitor( VisitorContext& _context, @@ -4202,20 +4102,11 @@ DirectFirstSetVisitor void Visit(GlrRefSyntax* node) override { - if (node->refType == GlrRefType::Id) - { - AddStartTokenOrRule(node->literal); - } - else - { - AddStartLiteral(node->literal); - } couldBeEmpty = false; } void Visit(GlrUseSyntax* node) override { - AddStartTokenOrRule(node->name); couldBeEmpty = false; } @@ -4278,31 +4169,8 @@ DirectFirstSetVisitor auto nodeSyntax = node->syntax.Obj(); auto pushSyntax = dynamic_cast(nodeSyntax); if (pushSyntax) nodeSyntax = pushSyntax->syntax.Obj(); - - if (auto useSyntax = dynamic_cast(nodeSyntax)) - { - if (auto startRule = TryGetRuleSymbol(useSyntax->name.value)) - { - context.directSimpleUseRules.Add(ruleSymbol, { startRule,currentClause }); - context.simpleUseClauseToReferencedRules.Add(currentClause, startRule); - } - } } } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - node->rule->Accept(this); - } - - void Visit(GlrPrefixMergeClause* node) override - { - node->rule->Accept(this); - } }; /*********************************************************************** @@ -4322,74 +4190,6 @@ CalculateFirstSet } } - void CalculateFirstSet_RuleClosure(const RulePathDependencies& direct, RulePathDependencies& indirect, PathToLastRuleMap& pathToLastRules) - { - for (auto [rule, index] : indexed(direct.Keys())) - { - auto&& startRules = direct.GetByIndex(index); - for (auto [startRule, clause] : startRules) - { - indirect.Add(rule, { startRule,clause }); - pathToLastRules.Add({ rule,startRule }, { rule,clause }); - } - } - - while (true) - { - vint offset = 0; - // TODO: (enumerable) foreach:alterable - for (auto [rule, index] : indexed(indirect.Keys())) - { - auto&& startRules1 = indirect.GetByIndex(index); - for (auto [startRule1, clause1] : startRules1) - { - if (rule == startRule1) continue; - vint index2 = direct.Keys().IndexOf(startRule1); - if (index2 != -1) - { - auto&& startRules2 = direct.GetByIndex(index2); - for (auto [startRule2, clause2] : startRules2) - { - if (rule == startRule2 || startRule1 == startRule2) continue; - if (!pathToLastRules.Contains({ rule,startRule2 }, { startRule1,clause2 })) - { - offset++; - if (!indirect.Contains(rule, { startRule2,clause2 })) - { - indirect.Add(rule, { startRule2,clause2 }); - } - pathToLastRules.Add({ rule,startRule2 }, { startRule1,clause2 }); - } - } - } - } - } - - if (offset == 0) - { - break; - } - } - } - - void CalculateFirstSet_IndirectStartRules(VisitorContext& context) - { - CalculateFirstSet_RuleClosure( - context.directStartRules, - context.indirectStartRules, - context.indirectStartPathToLastRules - ); - } - - void CalculateFirstSet_IndirectSimpleUseRules(VisitorContext& context) - { - CalculateFirstSet_RuleClosure( - context.directSimpleUseRules, - context.indirectSimpleUseRules, - context.indirectSimpleUsePathToLastRules - ); - } - template void CalculateFirstSet_MoveFromDirectClauses( SortedList& clauses, @@ -4413,35 +4213,9 @@ CalculateFirstSet } } - void CalculateFirstSet_IndirectLrpPmClauses(VisitorContext& context) - { - for (auto [rule, index] : indexed(context.indirectStartRules.Keys())) - { - SortedList lriClauses; - SortedList lrpClauses; - SortedList pmClauses; - - CalculateFirstSet_MoveFromDirectClauses(lriClauses, context.indirectLriClauses, context.directLriClauses, rule, rule); - CalculateFirstSet_MoveFromDirectClauses(lrpClauses, context.indirectLrpClauses, context.directLrpClauses, rule, rule); - CalculateFirstSet_MoveFromDirectClauses(pmClauses, context.indirectPmClauses, context.directPmClauses, rule, rule); - - auto&& startRules = context.indirectStartRules.GetByIndex(index); - - for (auto startRule : startRules) - { - CalculateFirstSet_MoveFromDirectClauses(lriClauses, context.indirectLriClauses, context.directLriClauses, rule, startRule.ruleSymbol); - CalculateFirstSet_MoveFromDirectClauses(lrpClauses, context.indirectLrpClauses, context.directLrpClauses, rule, startRule.ruleSymbol); - CalculateFirstSet_MoveFromDirectClauses(pmClauses, context.indirectPmClauses, context.directPmClauses, rule, startRule.ruleSymbol); - } - } - } - void CalculateFirstSet(VisitorContext& context, Ptr syntaxFile) { CalculateFirstSet_DirectStartRules(context, syntaxFile); - CalculateFirstSet_IndirectStartRules(context); - CalculateFirstSet_IndirectSimpleUseRules(context); - CalculateFirstSet_IndirectLrpPmClauses(context); } } } @@ -4792,6 +4566,19 @@ CompileSyntaxVisitor node->Accept(this); return result; } + + StatePair BuildAssignments(StatePair pair, List>& assignments) + { + for (auto node : assignments) + { + auto propSymbol = FindPropSymbol(clauseType, node->field.value); + auto enumSymbol = dynamic_cast(propSymbol->propSymbol); + auto enumItem = (vint32_t)enumSymbol->ItemOrder().IndexOf(node->value.value); + auto field = output->fieldIds[propSymbol]; + pair = automatonBuilder.BuildAssignment(pair, enumItem, field, (node->type == GlrAssignmentType::Weak)); + } + return pair; + } public: CompileSyntaxVisitor( VisitorContext& _context, @@ -4844,7 +4631,17 @@ CompileSyntaxVisitor auto rule = context.syntaxManager.Rules().Values()[index]; if (rule->isPartial) { - result = automatonBuilder.BuildPartialRuleSyntax(rule); + auto astRule = context.astRules[rule]; + List> elements; + for (auto clause : astRule->clauses) + { + auto partialClause = clause.Cast(); + elements.Add([this, partialClause]() + { + return BuildAssignments(Build(partialClause->syntax), partialClause->assignments); + }); + } + result = automatonBuilder.BuildAlternativeSyntax(elements); } else if (field == -1) { @@ -4946,19 +4743,6 @@ CompileSyntaxVisitor // GlrClause::IVisitor //////////////////////////////////////////////////////////////////////// - StatePair BuildAssignments(StatePair pair, List>& assignments) - { - for (auto node : assignments) - { - auto propSymbol = FindPropSymbol(clauseType, node->field.value); - auto enumSymbol = dynamic_cast(propSymbol->propSymbol); - auto enumItem = (vint32_t)enumSymbol->ItemOrder().IndexOf(node->value.value); - auto field = output->fieldIds[propSymbol]; - pair = automatonBuilder.BuildAssignment(pair, enumItem, field, (node->type == GlrAssignmentType::Weak)); - } - return pair; - } - void Visit(GlrCreateClause* node) override { clauseType = context.clauseTypes[node]; @@ -4973,13 +4757,7 @@ CompileSyntaxVisitor void Visit(GlrPartialClause* node) override { - clauseType = context.clauseTypes[node]; - result = automatonBuilder.BuildClause([this, node]() - { - return automatonBuilder.BuildPartialClause( - [this, node]() { return BuildAssignments(Build(node->syntax), node->assignments); } - ); - }); + // Content of partial clauses are embedded in the caller side } void Visit(GlrReuseClause* node) override @@ -4992,101 +4770,6 @@ CompileSyntaxVisitor ); }); } - - WString FlagIndexToName(vint32_t flag) - { - return context.syntaxManager.lrpFlags[flag]; - } - - void CollectFlagsInOrder(SortedList& flags, List>& placeholders) - { - CopyFrom( - flags, - From(placeholders) - .Select([this](Ptr flag) - { - return (vint32_t)context.syntaxManager.lrpFlags.IndexOf(flag->flag.value); - }) - .Distinct() - ); - } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - SortedList flags; - CollectFlagsInOrder(flags, node->flags); - - result = automatonBuilder.BuildClause([this, &flags]() - { - return automatonBuilder.BuildLrpClause( - flags, - { this,&CompileSyntaxVisitor::FlagIndexToName } - ); - }); - } - - using StateBuilder = Func; - - StateBuilder CompileLriTarget(SortedList& flags, GlrLeftRecursionInjectClause* lriTarget) - { - StateBuilder useOrLriSyntax; - auto rule = context.syntaxManager.Rules()[lriTarget->rule->literal.value]; - if (flags.Count() == 0) - { - useOrLriSyntax = [this, rule]() { return automatonBuilder.BuildUseSyntax(rule); }; - } - else - { - useOrLriSyntax = [this, rule, &flags]() { - return automatonBuilder.BuildLriSyntax( - flags, - rule, - { this,&CompileSyntaxVisitor::FlagIndexToName } - ); - }; - } - - if (!lriTarget->continuation) - { - return useOrLriSyntax; - } - else - { - auto cont = lriTarget->continuation; - return [this, useOrLriSyntax, cont]() - { - bool optional = cont->type == GlrLeftRecursionInjectContinuationType::Optional; - - SortedList flags; - CollectFlagsInOrder(flags, cont->flags); - - List targetRules; - for (auto lriTarget : cont->injectionTargets) - { - targetRules.Add(CompileLriTarget(flags, lriTarget.Obj())); - } - - return automatonBuilder.BuildLriClauseSyntax( - useOrLriSyntax, - optional, - std::move(targetRules)); - }; - } - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - result = automatonBuilder.BuildClause([this, node]() - { - SortedList flags; - return automatonBuilder.BuildReuseClause(CompileLriTarget(flags, node)); - }); - } - - void Visit(GlrPrefixMergeClause* node) override - { - CHECK_FAIL(L"GlrPrefixMergeClause should have been removed after RewriteSyntax_PrefixMerge()!"); - } }; /*********************************************************************** @@ -5200,7 +4883,6 @@ ResolveNameVisitor void ResolveClause(Ptr clause) { - context.clauseToRules.Add(clause.Obj(), ruleSymbol); clause->Accept(this); } @@ -5479,7 +5161,6 @@ ResolveNameVisitor { if (auto classSymbol = GetRuleClass(node->type)) { - context.ruleKnownTypes.Add(ruleSymbol, classSymbol); context.clauseTypes.Add(node, classSymbol); } node->syntax->Accept(this); @@ -5489,7 +5170,6 @@ ResolveNameVisitor { if (auto classSymbol = GetRuleClass(node->type)) { - context.ruleKnownTypes.Add(ruleSymbol, classSymbol); context.clauseTypes.Add(node, classSymbol); } node->syntax->Accept(this); @@ -5500,46 +5180,6 @@ ResolveNameVisitor reuseClause = node; node->syntax->Accept(this); } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - for (auto flag : node->flags) - { - auto name = flag->flag.value; - if (!ruleSymbol->lrFlags.Contains(name)) - { - ruleSymbol->lrFlags.Add(name); - } - } - context.directLrpClauses.Add(ruleSymbol, node); - } - - void VisitLriClause(GlrLeftRecursionInjectClause* node) - { - VisitReuseSyntax( - node->rule->literal, - (!node->continuation || node->continuation->type == GlrLeftRecursionInjectContinuationType::Optional) - ); - if (node->continuation) - { - for (auto lriTarget : node->continuation->injectionTargets) - { - VisitLriClause(lriTarget.Obj()); - } - } - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - VisitLriClause(node); - context.directLriClauses.Add(ruleSymbol, node); - } - - void Visit(GlrPrefixMergeClause* node) override - { - VisitReuseSyntax(node->rule->literal, true); - context.directPmClauses.Add(ruleSymbol, node); - } }; /*********************************************************************** @@ -5637,1467 +5277,6 @@ ResolveName } } } - - if (context.directPmClauses.Count() > 0) - { - for (auto rule : syntaxFile->rules) - { - if (!IsLegalNameBeforeWithPrefixMerge(rule->name.value)) - { - context.syntaxManager.AddError( - ParserErrorType::SyntaxInvolvesPrefixMergeWithIllegalRuleName, - rule->name.codeRange, - rule->name.value - ); - } - - for (auto lrp : From(rule->clauses).FindType()) - { - for (auto p : lrp->flags) - { - if (!IsLegalNameBeforeWithPrefixMerge(p->flag.value)) - { - context.syntaxManager.AddError( - ParserErrorType::SyntaxInvolvesPrefixMergeWithIllegalPlaceholderName, - p->flag.codeRange, - rule->name.value, - p->flag.value - ); - } - } - } - } - } - } - } - } -} - -/*********************************************************************** -.\PARSERGEN\COMPILESYNTAX_REWRITESYNTAX_PREFIXMERGE.CPP -***********************************************************************/ - -namespace vl -{ - namespace glr - { - namespace parsergen - { - using namespace collections; - using namespace compile_syntax; - - extern void CalculateFirstSet_IndirectStartRules(VisitorContext& context); - extern void CalculateFirstSet_IndirectSimpleUseRules(VisitorContext& context); - - namespace rewritesyntax_prefixmerge - { - struct RewritingPrefixConflict - { - // all clauses are simple use clauses, RuleSymbol* in values are the rule referenced by keys - SortedList unaffectedClauses; // clauses that are not affected by prefix extraction - SortedList prefixClauses; // simple use clauses that are prefix themselves - Group conflictedClauses; // c1 -> c2 if c1's prefix is prefix clause c2 - }; - - struct PrefixRuleWithClause - { - RuleSymbol* ruleSymbol = nullptr; - GlrClause* clause = nullptr; - - bool operator==(PrefixRuleWithClause& p) const - { - return ruleSymbol == p.ruleSymbol && clause == p.clause; - } - }; - - struct RewritingContext - { - List pmRules; // all rules that need to be rewritten - Dictionary skippedRules; // skipped RuleSymbol -> GlrRule - SortedList protectedSkippedClause; // a simple use clause that belongs to one of the skipped rules - Dictionary originRules; // rewritten RuleSymbol -> GlrRule ends with _LRI_Original, which is the same GlrRule object before rewritten - Dictionary lriRules; // rewritten RuleSymbol -> GlrRule containing left_recursion_inject clauses - Dictionary fixedAstRules; // RuleSymbol -> GlrRule relationship after rewritten - - Group extractPrefixClauses; // RuleSymbol -> {rule to be extracted, clause begins with rule} - Dictionary, GlrRule*> extractedPrefixRules; // {rewritten RuleSymbol, prefix RuleSymbol} -> GlrRule ends with _LRI_Prefix - Dictionary> extractedConflicts; // rewritten RuleSymbol -> all needed information if prefix extraction affects how it generates left_recursion_inject clauses - }; - - Ptr GetConflict(const RewritingContext& rContext, RuleSymbol* ruleSymbol) - { - vint indexConflict = rContext.extractedConflicts.Keys().IndexOf(ruleSymbol); - if (indexConflict == -1) - { - return nullptr; - } - else - { - return rContext.extractedConflicts.Values()[indexConflict]; - } - } - - Ptr EnsureGetConflict(RewritingContext& rContext, RuleSymbol* ruleSymbol) - { - auto conflict = GetConflict(rContext, ruleSymbol); - if (!conflict) - { - conflict = Ptr(new RewritingPrefixConflict); - rContext.extractedConflicts.Add(ruleSymbol, conflict); - } - return conflict; - } - -/*********************************************************************** -FillMissingPrefixMergeClauses -***********************************************************************/ - - void RemoveDirectReferences(RulePathDependencies& references, RuleSymbol* ruleSymbol, GlrClause* clause) - { - vint index = references.Keys().IndexOf(ruleSymbol); - if (index != -1) - { - auto&& values = const_cast&>(references.GetByIndex(index)); - // TODO: (enumerable) foreach:indexed(alterable(reversed)) - for (vint i = values.Count() - 1; i >= 0; i--) - { - if (values[i].clause == clause) - { - values.RemoveAt(i); - } - } - - if (values.Count() == 0) - { - references.Remove(ruleSymbol); - } - } - } - - void FillMissingPrefixMergeClauses(VisitorContext& vContext, SyntaxSymbolManager& syntaxManager, Ptr rewritten) - { - // find position of thses clauses in rules - for (auto clauseRaw : vContext.clauseToConvertedToPrefixMerge) - { - auto ruleSymbol = vContext.clauseToRules[clauseRaw]; - auto ruleRaw = vContext.astRules[ruleSymbol]; - vint ruleIndex = rewritten->rules.IndexOf(ruleRaw); - vint clauseIndex = ruleRaw->clauses.IndexOf(clauseRaw); - auto clause = ruleRaw->clauses[clauseIndex]; - - // create new rule and replace the clause with prefix_merge - auto newRule = Ptr(new GlrRule); - rewritten->rules.Insert(ruleIndex, newRule); - newRule->codeRange = clauseRaw->codeRange; - newRule->name = ruleRaw->name; - newRule->name.value += L"_LRI_Isolated_" + itow(clauseIndex); - newRule->clauses.Add(clause); - - auto newPM = Ptr(new GlrPrefixMergeClause); - newPM->codeRange = clauseRaw->codeRange; - ruleRaw->clauses[clauseIndex] = newPM; - { - auto startRule = Ptr(new GlrRefSyntax); - newPM->rule = startRule; - - startRule->refType = GlrRefType::Id; - startRule->literal.value = newRule->name.value; - } - - // remove direct references - RemoveDirectReferences(vContext.directStartRules, ruleSymbol, clause.Obj()); - RemoveDirectReferences(vContext.directSimpleUseRules, ruleSymbol, clause.Obj()); - - // fix rule and clause symbols - auto newRuleSymbol = syntaxManager.CreateRule( - newRule->name.value, - ruleSymbol->fileIndex, - true, - ruleSymbol->isParser, - ruleRaw->name.codeRange - ); - newRuleSymbol->isPartial = ruleSymbol->isPartial; - newRuleSymbol->ruleType = vContext.clauseTypes[clause.Obj()]; - vContext.astRules.Add(newRuleSymbol, newRule.Obj()); - vContext.clauseTypes.Add(newPM.Obj(), newRuleSymbol->ruleType); - vContext.clauseToRules.Set(clause.Obj(), newRuleSymbol); - vContext.clauseToRules.Add(newPM.Obj(), ruleSymbol); - vContext.clauseToStartRules.Add(newPM.Obj(), newRuleSymbol); - - // fix directPmClauses - // indirectPmClauses - // directStartRules - vContext.directPmClauses.Add(ruleSymbol, newPM.Obj()); - vContext.indirectPmClauses.Add(ruleSymbol, newPM.Obj()); - vContext.directStartRules.Add(ruleSymbol, { newRuleSymbol,newPM.Obj() }); - for (auto key : syntaxManager.Rules().Values()) - { - if (vContext.indirectStartPathToLastRules.Contains({ key,ruleSymbol })) - { - vContext.indirectPmClauses.Add(key, newPM.Obj()); - } - } - } - - // fix indirectStartRules - // indirectSimpleUseRules - // indirectStartPathToLastRules - // indirectSimpleUsePathToLastRules - vContext.indirectStartRules.Clear(); - vContext.indirectSimpleUseRules.Clear(); - vContext.indirectStartPathToLastRules.Clear(); - vContext.indirectSimpleUsePathToLastRules.Clear(); - CalculateFirstSet_IndirectStartRules(vContext); - CalculateFirstSet_IndirectSimpleUseRules(vContext); - } - -/*********************************************************************** -CollectSkippedTargets -***********************************************************************/ - - void CollectSkippedTargets(const VisitorContext& vContext, RewritingContext& rContext, Ptr rewritten) - { - // when a rule - // is not a prefix of a rewritten rule - // has no direct prefix_merge clause - // has only one clause which starts with prefix_merge clause - // skip rewriting it - // if the only clause of a skipped rule is a simple use clause referencing a rule to be rewritten - // the name it referenced should not be changed in RenamePrefix - - List lastRemovedCandidates; - Dictionary candidateProtectedClauses; - - for (auto rule : rewritten->rules) - { - auto ruleSymbol = vContext.syntaxManager.Rules()[rule->name.value]; - if (vContext.indirectPmClauses.Keys().Contains(ruleSymbol)) - { - if (!vContext.directPmClauses.Keys().Contains(ruleSymbol)) - { - GlrClause* uniqueQualifiedClause = nullptr; - for (auto clause : rule->clauses) - { - vint index = vContext.clauseToStartRules.Keys().IndexOf(clause.Obj()); - if (index == -1) continue; - - auto&& startRules = vContext.clauseToStartRules.GetByIndex(index); - for (auto startRule : startRules) - { - if (vContext.indirectPmClauses.Keys().Contains(startRule)) - { - if (!uniqueQualifiedClause) - { - uniqueQualifiedClause = clause.Obj(); - break; - } - else - { - goto DO_NOT_SKIP; - } - break; - } - } - } - - if (uniqueQualifiedClause) - { - rContext.skippedRules.Add(ruleSymbol, rule.Obj()); - if (vContext.simpleUseClauseToReferencedRules.Keys().Contains(uniqueQualifiedClause)) - { - candidateProtectedClauses.Add(ruleSymbol, uniqueQualifiedClause); - } - } - continue; - DO_NOT_SKIP: - lastRemovedCandidates.Add(ruleSymbol); - } - } - } - - while (lastRemovedCandidates.Count() > 0) - { - List newRemovedCandidates; - for (auto ruleSymbol : lastRemovedCandidates) - { - vint indexStart = vContext.directStartRules.Keys().IndexOf(ruleSymbol); - if (indexStart != -1) - { - for (auto startRuleSymbol : vContext.directStartRules.GetByIndex(indexStart)) - { - if (rContext.skippedRules.Keys().Contains(startRuleSymbol.ruleSymbol)) - { - rContext.skippedRules.Remove(startRuleSymbol.ruleSymbol); - newRemovedCandidates.Add(startRuleSymbol.ruleSymbol); - } - } - } - } - CopyFrom(lastRemovedCandidates, newRemovedCandidates); - } - - for (auto [ruleSymbol, rule] : rContext.skippedRules) - { - vint index = candidateProtectedClauses.Keys().IndexOf(ruleSymbol); - if (index != -1) - { - rContext.protectedSkippedClause.Add(candidateProtectedClauses.Values()[index]); - } - } - } - -/*********************************************************************** -CollectRewritingTargets -***********************************************************************/ - - void CollectRewritingTargets(const VisitorContext& vContext, RewritingContext& rContext, Ptr rewritten) - { - for (auto rule : rewritten->rules) - { - auto ruleSymbol = vContext.syntaxManager.Rules()[rule->name.value]; - if (vContext.indirectPmClauses.Keys().Contains(ruleSymbol)) - { - if (rContext.skippedRules.Keys().Contains(ruleSymbol)) - { - continue; - } - rContext.pmRules.Add(ruleSymbol); - - vint indexStart = vContext.directStartRules.Keys().IndexOf(ruleSymbol); - vint indexSimpleUse = vContext.directSimpleUseRules.Keys().IndexOf(ruleSymbol); - - if (indexStart != -1 && indexSimpleUse != -1) - { - // all clauses should be simple use to enable prefix detection - if (vContext.directSimpleUseRules.GetByIndex(indexSimpleUse).Count() != rule->clauses.Count()) continue; - Ptr conflict; - - for (auto [startRule, startClause] : vContext.directStartRules.GetByIndex(indexStart)) - { - // prefix_merge clauses and left recursive clauses are not involved in prefix detection/extraction - if (dynamic_cast(startClause)) continue; - if (vContext.leftRecursiveClauses.Contains(ruleSymbol, startClause)) continue; - - // find all clause pair "!X" and "Y ...", see if X is a prefix of Y - for (auto [simpleUseRule, simpleUseClause] : vContext.directSimpleUseRules.GetByIndex(indexSimpleUse)) - { - // ignore if X is Y - if (startRule == simpleUseRule) continue; - - // ignore if X is not a prefix of Y - vint indexExtract = vContext.indirectStartPathToLastRules.Keys().IndexOf({ startRule,simpleUseRule }); - if (indexExtract == -1) continue; - - // ignore if Y ::= X directly or indirectly - for (auto [extractRule, extractClause] : vContext.indirectStartPathToLastRules.GetByIndex(indexExtract)) - { - // ignore if Y ::= X directly or indirectly - if (vContext.directSimpleUseRules.Contains(extractRule, { simpleUseRule,extractClause })) continue; - - // prefix extraction needed - if (!rContext.extractPrefixClauses.Contains(extractRule, { simpleUseRule,extractClause })) - { - rContext.extractPrefixClauses.Add(extractRule, { simpleUseRule,extractClause }); - } - - // fill conflict information for ruleSymbol - if (!conflict) - { - conflict = EnsureGetConflict(rContext, ruleSymbol); - } - - if (!conflict->prefixClauses.Contains(simpleUseClause)) - { - conflict->prefixClauses.Add(simpleUseClause); - } - if (!conflict->conflictedClauses.Contains(startClause, simpleUseClause)) - { - conflict->conflictedClauses.Add(startClause, simpleUseClause); - } - } - } - } - - if (conflict) - { - for (auto clause : rule->clauses) - { - if (!conflict->prefixClauses.Contains(clause.Obj()) && !conflict->conflictedClauses.Contains(clause.Obj())) - { - conflict->unaffectedClauses.Add(clause.Obj()); - } - } - } - } - } - } - } - -/*********************************************************************** -CreateRewrittenRules -***********************************************************************/ - - void CreateRewrittenRules(const VisitorContext& vContext, RewritingContext& rContext, Ptr rewritten) - { - for (auto ruleSymbol : rContext.pmRules) - { - auto originRule = vContext.astRules[ruleSymbol]; - rContext.originRules.Add(ruleSymbol, originRule); - - auto lri = Ptr(new GlrRule); - rewritten->rules.Add(lri); - rContext.lriRules.Add(ruleSymbol, lri.Obj()); - - lri->codeRange = originRule->codeRange; - lri->attPublic = originRule->attPublic; - lri->attParser = originRule->attParser; - lri->codeRange = originRule->name.codeRange; - lri->name = originRule->name; - - originRule->attPublic = {}; - originRule->attParser = {}; - originRule->name.value += L"_LRI_Original"; - } - - // TODO: (enumerable) foreach - for (auto [ruleSymbol, index] : indexed(rContext.extractPrefixClauses.Keys())) - { - auto originRule = vContext.astRules[ruleSymbol]; - auto&& prefixClauses = rContext.extractPrefixClauses.GetByIndex(index); - for (auto [prefixRuleSymbol, prefixClause] : From(prefixClauses) - .OrderByKey([](auto&& p) {return p.ruleSymbol->Name(); })) - { - if (!rContext.extractedPrefixRules.Keys().Contains({ ruleSymbol,prefixRuleSymbol })) - { - auto ep = Ptr(new GlrRule); - rewritten->rules.Insert(rewritten->rules.IndexOf(originRule), ep); - rContext.extractedPrefixRules.Add({ ruleSymbol,prefixRuleSymbol }, ep.Obj()); - - ep->codeRange = originRule->codeRange; - ep->name.codeRange = originRule->name.codeRange; - ep->name.value = ruleSymbol->Name() + L"_" + prefixRuleSymbol->Name() + L"_LRI_Prefix"; - } - } - } - } - -/*********************************************************************** -FixRuleTypes -***********************************************************************/ - - void FixRuleTypes(const VisitorContext& vContext, RewritingContext& rContext, SyntaxSymbolManager& syntaxManager) - { - CopyFrom(rContext.fixedAstRules, vContext.astRules); - for (auto ruleSymbol : rContext.pmRules) - { - auto originRule = rContext.originRules[ruleSymbol]; - auto lriRule = rContext.lriRules[ruleSymbol]; - auto originSymbol = syntaxManager.CreateRule( - originRule->name.value, - ruleSymbol->fileIndex, - ruleSymbol->isPublic, - ruleSymbol->isParser, - originRule->codeRange - ); - - originSymbol->isPartial = ruleSymbol->isPartial; - originSymbol->ruleType = ruleSymbol->ruleType; - rContext.fixedAstRules.Set(originSymbol, originRule); - rContext.fixedAstRules.Set(ruleSymbol, lriRule); - } - - for (auto [pair, epRule] : rContext.extractedPrefixRules) - { - auto originRule = rContext.originRules[pair.key]; - auto epRuleSymbol = syntaxManager.CreateRule( - epRule->name.value, - pair.key->fileIndex, - false, - false, - originRule->codeRange - ); - epRuleSymbol->ruleType = pair.value->ruleType; - rContext.fixedAstRules.Add(epRuleSymbol, epRule); - } - - for (auto [ruleSymbol, rule] : rContext.fixedAstRules) - { - if (!rule->type) - { - rule->type.value = ruleSymbol->ruleType->Name(); - } - } - - for (auto ruleSymbol : syntaxManager.Rules().Values()) - { - ruleSymbol->assignedNonArrayField = false; - ruleSymbol->lrFlags.Clear(); - } - } - -/*********************************************************************** -RewriteExtractedPrefixRules -***********************************************************************/ - - void RewriteExtractedPrefixRules(const VisitorContext& vContext, RewritingContext& rContext, SyntaxSymbolManager& syntaxManager) - { - for (auto [pair, epRule] : rContext.extractedPrefixRules) - { - { - auto lrpClause = Ptr(new GlrLeftRecursionPlaceholderClause); - lrpClause->codeRange = epRule->codeRange; - epRule->clauses.Add(lrpClause); - - auto lrp = Ptr(new GlrLeftRecursionPlaceholder); - lrpClause->flags.Add(lrp); - lrp->flag.value = L"LRIP_" + pair.key->Name() + L"_" + pair.value->Name(); - syntaxManager.lrpFlags.Add(lrp->flag.value); - } - { - auto reuseClause = Ptr(new GlrReuseClause); - reuseClause->codeRange = epRule->codeRange; - epRule->clauses.Add(reuseClause); - - auto useSyntax = Ptr(new GlrUseSyntax); - reuseClause->syntax = useSyntax; - useSyntax->name.value = rContext.originRules[pair.value]->name.value; - } - } - } - -/*********************************************************************** -RewriteRules (Common) -***********************************************************************/ - - using PMClauseRecord = GenericRuleClausePath; - - struct PMInjectRecord - { - RuleSymbol* pmRule = nullptr; - RuleSymbol* injectIntoRule = nullptr; - }; - - void RewriteRules_AddPmClause( - const VisitorContext& vContext, - RuleSymbol* ruleSymbol, - GlrPrefixMergeClause* pmClause, - Group& pmClauses - ) - { - auto pmRule = vContext.clauseToRules[pmClause]; - if (ruleSymbol == pmRule) - { - if (!pmClauses.Contains(pmClause->rule->literal.value, { ruleSymbol,pmClause })) - { - pmClauses.Add(pmClause->rule->literal.value, { ruleSymbol,pmClause }); - } - } - else - { - for (auto [indirectStartRule, indirectClause] : vContext.indirectStartPathToLastRules[{ ruleSymbol, pmRule }]) - { - if (!pmClauses.Contains(pmClause->rule->literal.value, { ruleSymbol,pmClause })) - { - pmClauses.Add(pmClause->rule->literal.value, { ruleSymbol,pmClause }); - } - } - } - } - - Ptr RewriteRules_CollectUnaffectedIndirectPmClauses( - const VisitorContext& vContext, - const RewritingContext& rContext, - RuleSymbol* initiatedRuleSymbol, - RuleSymbol* ruleSymbol, - SortedList& visited, - Group& pmClauses - ) - { - auto conflict = initiatedRuleSymbol == ruleSymbol ? GetConflict(rContext, ruleSymbol) : nullptr; - if (!visited.Contains(ruleSymbol)) - { - visited.Add(ruleSymbol); - - if (conflict) - { - for (auto [simpleUseRule, simpleUseClause] : vContext.directSimpleUseRules[ruleSymbol]) - { - if (conflict->unaffectedClauses.Contains(simpleUseClause)) - { - RewriteRules_CollectUnaffectedIndirectPmClauses(vContext, rContext, initiatedRuleSymbol, simpleUseRule, visited, pmClauses); - } - else - { - vint indexConflicted = conflict->conflictedClauses.Keys().IndexOf(simpleUseClause); - if (indexConflicted == -1) continue; - - auto&& prefixClauses = conflict->conflictedClauses.GetByIndex(indexConflicted); - for (auto pmClause : - From(vContext.indirectPmClauses[ruleSymbol]).Except( - From(prefixClauses) - .SelectMany([&](GlrClause* prefixClause) - { - return From(vContext.indirectPmClauses[vContext.simpleUseClauseToReferencedRules[prefixClause]]); - }) - )) - { - RewriteRules_AddPmClause(vContext, simpleUseRule, pmClause, pmClauses); - } - } - } - } - else - { - for (auto pmClause : vContext.indirectPmClauses[ruleSymbol]) - { - RewriteRules_AddPmClause(vContext, ruleSymbol, pmClause, pmClauses); - } - } - } - return conflict; - } - - void RewriteRules_CheckPath( - const VisitorContext& vContext, - RuleSymbol* startSymbol, - RuleSymbol* endSymbol, - bool& hasSimpleUseTransition, - bool& hasNonSimpleUseTransition - ) - { - // check the path from startSymbol to endSymbol - // hasSimpleUseTransition and hasNonSimpleUseTransition must be false before non-recursive calling from outside - // if a transition is found - // either of one will be set to true - // meaning such transition is counted - - bool isEndSymbolLeftRecursive = vContext.leftRecursiveClauses.Keys().Contains(endSymbol); - if (isEndSymbolLeftRecursive) - { - // if endSymbol is left recursive - // then we find a non-simple-use transition from startSymbol to endSymbol - hasNonSimpleUseTransition = true; - } - - if (startSymbol == endSymbol) - { - // if startSymbol is endSymbol - // then we find a simple-use transition - // which does not actually transit - hasSimpleUseTransition = true; - } - else - { - // otherwise we look through all possible path from startSymbol to endSymbol - vint index = vContext.indirectStartPathToLastRules.Keys().IndexOf({ startSymbol,endSymbol }); - if (index != -1) - { - for (auto [lastRuleSymbol, clause] : vContext.indirectStartPathToLastRules.GetByIndex(index)) - { - if (vContext.simpleUseClauseToReferencedRules.Keys().Contains(clause)) - { - // if we find a simple-use clause - // we check how all transitions look like from startSymbol to lastRuleSymbol - RewriteRules_CheckPath(vContext, startSymbol, lastRuleSymbol, hasSimpleUseTransition, hasNonSimpleUseTransition); - } - else - { - // if we find a non-simple-use clause - // then we find a non-simple-use transition from startSymbol to endSymbol - hasNonSimpleUseTransition = true; - } - } - } - } - } - - void RewriteRules_CollectFlags( - const VisitorContext& vContext, - RuleSymbol* ruleSymbol, - const List& pmClauses, - Dictionary& flags, - bool& generateOptionalLri - ) - { - for (auto [injectIntoRule, pmClause] : pmClauses) - { - auto pmRule = vContext.clauseToRules[pmClause]; - bool hasSimpleUseTransition = false; - bool hasNonSimpleUseTransition = false; - RewriteRules_CheckPath(vContext, ruleSymbol, pmRule, hasSimpleUseTransition, hasNonSimpleUseTransition); - - if (hasSimpleUseTransition) - { - generateOptionalLri = true; - } - - if (hasNonSimpleUseTransition) - { - flags.Add(L"LRI_" + pmRule->Name(), { pmRule,injectIntoRule }); - } - } - } - - bool RewriteRules_HasMultiplePaths( - const VisitorContext& vContext, - RuleSymbol* fromRule, - RuleSymbol* toRule, - Dictionary, vint>& pathCounter - ) - { - Pair key = { fromRule, toRule }; - vint index = pathCounter.Keys().IndexOf(key); - if (index != -1) return pathCounter.Values()[index]; - - RuleSymbol* currentRule = toRule; - bool hasMultiplePaths = false; - - while (currentRule != fromRule) - { - index = vContext.indirectStartPathToLastRules.Keys().IndexOf({ fromRule,currentRule }); - if (index == -1) goto FINISHED; - - auto&& lastRules = vContext.indirectStartPathToLastRules.GetByIndex(index); - if (lastRules.Count() > 1) { - hasMultiplePaths = true; - goto FINISHED; - } - currentRule = lastRules[0].ruleSymbol; - } - - FINISHED: - pathCounter.Add(key, hasMultiplePaths); - return hasMultiplePaths; - } - -/*********************************************************************** -RewriteRules (AST Creation) -***********************************************************************/ - - Ptr CreateLriClause( - const WString& ruleName - ) - { - auto lriClause = Ptr(new GlrLeftRecursionInjectClause); - - auto lriStartRule = Ptr(new GlrRefSyntax); - lriClause->rule = lriStartRule; - lriStartRule->refType = GlrRefType::Id; - lriStartRule->literal.value = ruleName; - - return lriClause; - } - - Ptr CreateLriContinuation( - const VisitorContext& vContext, - const RewritingContext& rContext, - RuleSymbol* ruleSymbol, - const PMInjectRecord& pmInjectRecord, - const WString& flag, - Dictionary, vint>& pathCounter, - bool generateOptionalLri - ) - { - auto lriCont = Ptr(new GlrLeftRecursionInjectContinuation); - - if (RewriteRules_HasMultiplePaths(vContext, ruleSymbol, pmInjectRecord.pmRule, pathCounter)) - { - lriCont->configuration = GlrLeftRecursionConfiguration::Multiple; - } - else - { - lriCont->configuration = GlrLeftRecursionConfiguration::Single; - } - - if (generateOptionalLri) - { - lriCont->type = GlrLeftRecursionInjectContinuationType::Optional; - } - else - { - lriCont->type = GlrLeftRecursionInjectContinuationType::Required; - } - - auto lriContFlag = Ptr(new GlrLeftRecursionPlaceholder); - lriCont->flags.Add(lriContFlag); - lriContFlag->flag.value = flag; - - vint injectIntoOriginIndex = rContext.originRules.Keys().IndexOf(pmInjectRecord.injectIntoRule); - auto lriContTargetName = injectIntoOriginIndex == -1 - ? pmInjectRecord.injectIntoRule->Name() - : rContext.originRules.Values()[injectIntoOriginIndex]->name.value - ; - auto lriContTarget = CreateLriClause(lriContTargetName); - lriCont->injectionTargets.Add(lriContTarget); - - return lriCont; - } - -/*********************************************************************** -RewriteRules (Unaffected) -***********************************************************************/ - - void RewriteRules_GenerateUnaffectedLRIClauses( - const VisitorContext& vContext, - const RewritingContext& rContext, - RuleSymbol* ruleSymbol, - GlrRule* lriRule, - Dictionary, vint>& pathCounter, - Group& pmClauses, - SortedList& knownOptionalStartRules - ) - { - // TODO: (enumerable) foreach on group - for (auto [pmName, pmIndex] : indexed(pmClauses.Keys())) - { - // if originRule is not left recursive - // do not generate lriClause for the flag created for originRule, because there is no continuation - // if a pmName does generate some lriClause - // it becomes GLRICT::Optional - // otherwise - // it becomse GLRICT::Required - // generate useSyntax instead of lriClause - - Dictionary flags; - bool generateOptionalLri = false; - RewriteRules_CollectFlags( - vContext, - ruleSymbol, - pmClauses.GetByIndex(pmIndex), - flags, - generateOptionalLri - ); - - if (generateOptionalLri && flags.Count() == 0) - { - auto reuseClause = Ptr(new GlrReuseClause); - reuseClause->codeRange = lriRule->codeRange; - lriRule->clauses.Add(reuseClause); - - auto useSyntax = Ptr(new GlrUseSyntax); - reuseClause->syntax = useSyntax; - useSyntax->name.value = pmName; - } - - for (auto [flag, pmInjectRecord] : flags) - { - auto lriClause = CreateLriClause(pmName); - lriRule->clauses.Add(lriClause); - - auto lriCont = CreateLriContinuation( - vContext, - rContext, - ruleSymbol, - pmInjectRecord, - flag, - pathCounter, - generateOptionalLri - ); - lriClause->continuation = lriCont; - - if (generateOptionalLri) - { - generateOptionalLri = false; - knownOptionalStartRules.Add(pmName); - } - } - } - } - -/*********************************************************************** -RewriteRules (Affected) -***********************************************************************/ - - void RewriteRules_GenerateAffectedLRIClausesSubgroup( - const VisitorContext& vContext, - const RewritingContext& rContext, - RuleSymbol* conflictedRuleSymbol, - RuleSymbol* prefixRuleSymbol, - SortedList& lripFlags, - GlrRule* lriRule, - Dictionary, vint>& pathCounter, - SortedList& knownOptionalStartRules - ) - { - Group pmClauses; - { - SortedList visited; - auto conflict = RewriteRules_CollectUnaffectedIndirectPmClauses( - vContext, - rContext, - prefixRuleSymbol, - prefixRuleSymbol, - visited, - pmClauses - ); - - if (conflict) - { - vContext.syntaxManager.AddError( - ParserErrorType::PrefixExtractionAffectedRuleReferencedAnother, - rContext.originRules[vContext.syntaxManager.Rules()[lriRule->name.value]]->codeRange, - lriRule->name.value, - conflictedRuleSymbol->Name(), - prefixRuleSymbol->Name() - ); - return; - } - } - - // TODO: (enumerable) foreach on group - for (auto [pmName, pmIndex] : indexed(pmClauses.Keys())) - { - // if originRule is not left recursive - // left_recursion_inject directly into conflictedRuleSymbol - // if a pmName does generate some lriClause - // it becomes GLRICT::Optional - // otherwise - // it becomse GLRICT::Required - // generate useSyntax instead of lriClause - - auto&& pmClauseRecords = pmClauses.GetByIndex(pmIndex); - - Dictionary flags; - bool omittedSelf = false; - bool generateOptionalLri = false; - RewriteRules_CollectFlags( - vContext, - prefixRuleSymbol, - pmClauseRecords, - flags, - generateOptionalLri - ); - - if (generateOptionalLri) - { - // TODO: add test case for omittedSelf == true - for (auto lripFlag : lripFlags) - { - auto lriClause = CreateLriClause(pmName); - lriRule->clauses.Add(lriClause); - - auto lriCont = CreateLriContinuation( - vContext, - rContext, - conflictedRuleSymbol, - { prefixRuleSymbol,conflictedRuleSymbol }, - lripFlag, - pathCounter, - false - ); - lriClause->continuation = lriCont; - } - } - - if (knownOptionalStartRules.Contains(pmName)) - { - generateOptionalLri = false; - } - - for (auto [flag, pmInjectRecord] : flags) - { - { - // Since there is no switches in pmClauses - // So there is no switches in pmInjectRecord as well - // because flags comes from pmClauses, collected by RewriteRules_CollectFlags above - auto lriClause = CreateLriClause(pmName); - lriRule->clauses.Add(lriClause); - - auto lriCont = CreateLriContinuation( - vContext, - rContext, - prefixRuleSymbol, - { pmInjectRecord.pmRule,prefixRuleSymbol }, - flag, - pathCounter, - generateOptionalLri - ); - lriClause->continuation = lriCont; - - for (auto lripFlag : lripFlags) - { - auto lriCont2 = CreateLriContinuation( - vContext, - rContext, - conflictedRuleSymbol, - { prefixRuleSymbol,conflictedRuleSymbol }, - lripFlag, - pathCounter, - true - ); - - auto branchStart = lriCont->injectionTargets[0]; - if (branchStart->continuation) - { - // TODO: add test case - auto newBranchStart = CreateLriClause(branchStart->rule->literal.value); - newBranchStart->continuation = lriCont2; - lriCont->injectionTargets.Add(newBranchStart); - } - else - { - branchStart->continuation = lriCont2; - } - } - - if (generateOptionalLri) - { - generateOptionalLri = false; - } - } - } - } - } - - void RewriteRules_GenerateAffectedLRIClauses( - const VisitorContext& vContext, - const RewritingContext& rContext, - RuleSymbol* ruleSymbol, - GlrRule* lriRule, - Ptr conflict, - Dictionary, vint>& pathCounter, - SortedList& knownOptionalStartRules - ) - { - // TODO: (enumerable) foreach on group - for (auto [conflictedClause, conflictedIndex] : indexed(conflict->conflictedClauses.Keys())) - { - auto conflictedRuleSymbol = vContext.simpleUseClauseToReferencedRules[conflictedClause]; - auto&& prefixClauses = conflict->conflictedClauses.GetByIndex(conflictedIndex); - for (auto prefixClause : prefixClauses) - { - auto prefixRuleSymbol = vContext.simpleUseClauseToReferencedRules[prefixClause]; - SortedList lripFlags; - for (auto extracted : vContext.indirectStartPathToLastRules[{conflictedRuleSymbol, prefixRuleSymbol}]) - { - lripFlags.Add(L"LRIP_" + extracted.ruleSymbol->Name() + L"_" + prefixRuleSymbol->Name()); - } - RewriteRules_GenerateAffectedLRIClausesSubgroup( - vContext, - rContext, - conflictedRuleSymbol, - prefixRuleSymbol, - lripFlags, - lriRule, - pathCounter, - knownOptionalStartRules - ); - } - } - } - -/*********************************************************************** -RewriteRules -***********************************************************************/ - - bool CompareLri(Ptr c1, Ptr c2); - - bool CompareLriTargest(List>& targets1, List>& targets2) - { - if (targets1.Count() != targets2.Count()) return false; - for (auto [target, i] : indexed(targets1)) - { - if (!CompareLri(targets1[i], targets2[i])) return false; - } - return true; - } - - bool CompareLri(Ptr c1, Ptr c2) - { - if (c1->rule->literal.value != c2->rule->literal.value) return false; - if ((c1->continuation == nullptr) != (c2->continuation == nullptr)) return false; - if (!c1->continuation) return true; - - auto cont1 = c1->continuation; - auto cont2 = c2->continuation; - if (cont1->flags.Count() != cont2->flags.Count()) return false; - // TODO: (enumerable) foreach:indexed, flag not used, considering Linq:Zip, Any - for (auto [flag, i] : indexed(cont1->flags)) - { - if (cont1->flags[i]->flag.value != cont2->flags[i]->flag.value) return false; - } - - return CompareLriTargest(cont1->injectionTargets, cont2->injectionTargets); - } - - void OptimizeLri(List>& lriClauses) - { - for (auto lriClause : lriClauses) - { - if (lriClause->continuation) - { - OptimizeLri(lriClause->continuation->injectionTargets); - } - } - - List> results, candidates; - for (auto [prefixRuleName, subLriClauses] : From(lriClauses) - .GroupBy([](auto lriClause) {return lriClause->rule->literal.value; }) - ) - { - CopyFrom(candidates, From(subLriClauses).Reverse()); - while (candidates.Count() > 0) - { - auto candidate = candidates[candidates.Count() - 1]; - candidates.RemoveAt(candidates.Count() - 1); - // TODO: (enumerable) foreach:indexed(alterable(reversed)) - for (vint i = candidates.Count() - 1; i >= 0; i--) - { - auto compare = candidates[i]; - if (CompareLriTargest(candidate->continuation->injectionTargets, compare->continuation->injectionTargets)) - { - List> flags; - CopyFrom( - flags, - From(candidate->continuation->flags) - .Concat(compare->continuation->flags) - ); - CopyFrom( - candidate->continuation->flags, - From(flags) - .GroupBy([](auto flag) { return flag->flag.value; }) - .Select([](auto pair) { return pair.value.First(); }) - ); - - if (compare->continuation->configuration == GlrLeftRecursionConfiguration::Multiple) - { - candidate->continuation->configuration = GlrLeftRecursionConfiguration::Multiple; - } - - if(compare->continuation->type==GlrLeftRecursionInjectContinuationType::Optional) - { - candidate->continuation->type = GlrLeftRecursionInjectContinuationType::Optional; - } - - candidates.RemoveAt(i); - } - } - results.Add(candidate); - } - } - - CopyFrom(lriClauses, results); - } - - void RewriteRules(const VisitorContext& vContext, const RewritingContext& rContext, SyntaxSymbolManager& syntaxManager) - { - Dictionary, vint> pathCounter; - for (auto [ruleSymbol, originRule] : rContext.originRules) - { - auto lriRule = rContext.lriRules[ruleSymbol]; - Ptr conflict; - Group pmClauses; - { - SortedList visited; - conflict = RewriteRules_CollectUnaffectedIndirectPmClauses( - vContext, - rContext, - ruleSymbol, - ruleSymbol, - visited, - pmClauses - ); - } - - SortedList knownOptionalStartRules; - RewriteRules_GenerateUnaffectedLRIClauses( - vContext, - rContext, - ruleSymbol, - lriRule, - pathCounter, - pmClauses, - knownOptionalStartRules - ); - - if (conflict) - { - RewriteRules_GenerateAffectedLRIClauses( - vContext, - rContext, - ruleSymbol, - lriRule, - conflict, - pathCounter, - knownOptionalStartRules - ); - } - - List> otherClauses; - List> lriClauses; - for (auto clause : lriRule->clauses) - { - if (auto lriClause = clause.Cast()) - { - lriClauses.Add(lriClause); - } - else - { - otherClauses.Add(clause); - } - } - - if (lriClauses.Count() > 0) - { - OptimizeLri(lriClauses); - CopyFrom( - lriRule->clauses, - From(otherClauses) - .Concat( - From(lriClauses).Select([](auto clause)->Ptr {return clause; }) - ) - ); - } - } - } - -/*********************************************************************** -FixPrefixMergeClauses -***********************************************************************/ - - void FixPrefixMergeClauses(const VisitorContext& vContext, const RewritingContext& rContext, SyntaxSymbolManager& syntaxManager) - { - for (auto ruleSymbol : vContext.directPmClauses.Keys()) - { - auto originRule = rContext.originRules[ruleSymbol]; - - auto lrpClause = Ptr(new GlrLeftRecursionPlaceholderClause); - lrpClause->codeRange = originRule->codeRange; - originRule->clauses.Insert(0, lrpClause); - - auto lrp = Ptr(new GlrLeftRecursionPlaceholder); - lrp->flag.value = L"LRI_" + ruleSymbol->Name(); - lrpClause->flags.Add(lrp); - syntaxManager.lrpFlags.Add(lrp->flag.value); - - for (vint i = 0; i < originRule->clauses.Count(); i++) - { - if (auto pmClause = originRule->clauses[i].Cast()) - { - if (ruleSymbol->isPartial) - { - auto partialClause = Ptr(new GlrPartialClause); - originRule->codeRange = originRule->codeRange; - originRule->clauses[i] = partialClause; - - partialClause->type.value = ruleSymbol->ruleType->Name(); - - auto refSyntax = Ptr(new GlrRefSyntax); - refSyntax->refType = GlrRefType::Id; - refSyntax->literal.value = pmClause->rule->literal.value; - partialClause->syntax = refSyntax; - } - else - { - auto reuseClause = Ptr(new GlrReuseClause); - originRule->codeRange = originRule->codeRange; - originRule->clauses[i] = reuseClause; - - auto useSyntax = Ptr(new GlrUseSyntax); - useSyntax->name.value = pmClause->rule->literal.value; - reuseClause->syntax = useSyntax; - } - } - } - } - } - -/*********************************************************************** -RenamePrefix -***********************************************************************/ - - class RenamePrefixVisitor - : public Object - , protected virtual GlrSyntax::IVisitor - , protected virtual GlrClause::IVisitor - { - protected: - const RewritingContext& rContext; - RuleSymbol* ruleSymbol; - const SyntaxSymbolManager& syntaxManager; - - public: - RenamePrefixVisitor( - const RewritingContext& _rContext, - RuleSymbol* _ruleSymbol, - const SyntaxSymbolManager& _syntaxManager - ) - : rContext(_rContext) - , ruleSymbol(_ruleSymbol) - , syntaxManager(_syntaxManager) - { - } - - void FixClause(Ptr clause) - { - clause->Accept(this); - } - - protected: - - void FixStartRule(ParsingToken& ruleName) - { - auto startRuleSymbol = syntaxManager.Rules()[ruleName.value]; - vint index = rContext.extractedPrefixRules.Keys().IndexOf({ ruleSymbol,startRuleSymbol }); - if (index != -1) - { - auto epRule = rContext.extractedPrefixRules.Values()[index]; - ruleName.value = epRule->name.value; - return; - } - - index = rContext.originRules.Keys().IndexOf(startRuleSymbol); - if (index != -1) - { - auto originRule = rContext.originRules.Values()[index]; - ruleName.value = originRule->name.value; - } - } - - //////////////////////////////////////////////////////////////////////// - // GlrSyntax::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrRefSyntax* node) override - { - if (node->refType == GlrRefType::Id) - { - vint index = syntaxManager.Rules().Keys().IndexOf(node->literal.value); - if (index != -1) - { - FixStartRule(node->literal); - } - } - } - - void Visit(GlrUseSyntax* node) override - { - FixStartRule(node->name); - } - - void Visit(GlrLoopSyntax* node) override - { - } - - void Visit(GlrOptionalSyntax* node) override - { - } - - void Visit(GlrSequenceSyntax* node) override - { - node->first->Accept(this); - } - - void Visit(GlrAlternativeSyntax* node) override - { - } - - void Visit(GlrPushConditionSyntax* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrTestConditionSyntax* node) override - { - } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrCreateClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrPartialClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrReuseClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - } - - void Visit(GlrPrefixMergeClause* node) override - { - } - }; - - void RenamePrefix(RewritingContext& rContext, const SyntaxSymbolManager& syntaxManager) - { - for (auto [ruleSymbol, originRule] : From(rContext.originRules).Concat(rContext.skippedRules)) - { - RenamePrefixVisitor visitor(rContext, ruleSymbol, syntaxManager); - for (auto clause : originRule->clauses) - { - if (rContext.protectedSkippedClause.Contains(clause.Obj())) - { - continue; - } - - // !(a; b) should be moved from rule X_LRI_Original to left_recursion_inject clauses in rule X - if (auto reuseClause = clause.Cast()) - { - if (auto pushSyntax = reuseClause->syntax.Cast()) - { - reuseClause->syntax = pushSyntax->syntax; - } - } - visitor.FixClause(clause); - } - } - } - } - -/*********************************************************************** -RewriteSyntax -***********************************************************************/ - - Ptr RewriteSyntax_PrefixMerge(VisitorContext& context, SyntaxSymbolManager& syntaxManager, Ptr syntaxFile) - { - using namespace rewritesyntax_prefixmerge; - - // merge files to single syntax file - auto rewritten = Ptr(new GlrSyntaxFile); - CopyFrom(rewritten->rules, syntaxFile->rules); - - // find clauses that need to be converted to prefix_merge and fix VisitorContext - FillMissingPrefixMergeClauses(context, syntaxManager, rewritten); - - // find rules that need to be rewritten using left_recursion_inject - RewritingContext rewritingContext; - CollectSkippedTargets(context, rewritingContext, rewritten); - CollectRewritingTargets(context, rewritingContext, rewritten); - - // create rewritten rules, rename origin rules - CreateRewrittenRules(context, rewritingContext, rewritten); - - // fix rule types (fix syntaxManager.rules, clear RuleSymbol fields) - FixRuleTypes(context, rewritingContext, syntaxManager); - - // create clauses in rewritten X_Y_LRI_Prefix rules - RewriteExtractedPrefixRules(context, rewritingContext, syntaxManager); - - // create left_recursion_inject clauses in rewritten rules - RewriteRules(context, rewritingContext, syntaxManager); - - // convert prefix_merge to left_recursion_placeholder and reuse clauses (fix syntaxManager.lrpFlags) - FixPrefixMergeClauses(context, rewritingContext, syntaxManager); - - // rename rule references in origin rules - RenamePrefix(rewritingContext, syntaxManager); - - return rewritten; } } } @@ -7843,21 +6022,6 @@ DeductAndVerifyClauseVisitor Verify(node->syntax); } - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - result = true; - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - result = true; - } - - void Visit(GlrPrefixMergeClause* node) override - { - result = true; - } - public: bool result = false; @@ -8180,550 +6344,6 @@ RewriteSyntax } } -/*********************************************************************** -.\PARSERGEN\COMPILESYNTAX_VALIDATEPREFIXMERGE.CPP -***********************************************************************/ - -namespace vl -{ - namespace glr - { - namespace parsergen - { - using namespace collections; - using namespace compile_syntax; - -/*********************************************************************** -ValidateDirectPrefixMergeRuleVisitor -***********************************************************************/ - - class ValidateDirectPrefixMergeRuleVisitor - : public Object - , protected virtual GlrSyntax::IVisitor - , protected virtual GlrClause::IVisitor - { - protected: - VisitorContext& context; - RuleSymbol* ruleSymbol; - - public: - ValidateDirectPrefixMergeRuleVisitor( - VisitorContext& _context, - RuleSymbol* _ruleSymbol - ) - : context(_context) - , ruleSymbol(_ruleSymbol) - { - } - - void ValidateClause(Ptr clause) - { - clause->Accept(this); - } - - protected: - - void NotBeginWithARule(ParsingAstBase* node) - { - // TODO: Should accept and generate !prefix_merge equivalent effect for this clause automatically - context.syntaxManager.AddError( - ParserErrorType::RuleMixedPrefixMergeWithClauseNotSyntacticallyBeginWithARule, - node->codeRange, - ruleSymbol->Name() - ); - } - - void VerifyStartRule(ParsingAstBase* node, RuleSymbol* startRule) - { - if (ruleSymbol != startRule && !context.indirectPmClauses.Keys().Contains(startRule)) - { - // TODO: Should accept and generate !prefix_merge equivalent effect for this clause automatically - // When this is not a left-recursive clause - context.syntaxManager.AddError( - ParserErrorType::RuleMixedPrefixMergeWithClauseNotBeginWithIndirectPrefixMerge, - node->codeRange, - ruleSymbol->Name(), - startRule->Name() - ); - } - } - - //////////////////////////////////////////////////////////////////////// - // GlrSyntax::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrRefSyntax* node) override - { - if (node->refType != GlrRefType::Id) - { - NotBeginWithARule(node); - } - else - { - vint index = context.syntaxManager.Rules().Keys().IndexOf(node->literal.value); - if (index == -1) - { - NotBeginWithARule(node); - } - else - { - VerifyStartRule(node, context.syntaxManager.Rules().Values()[index]); - } - } - } - - void Visit(GlrUseSyntax* node) override - { - VerifyStartRule(node, context.syntaxManager.Rules()[node->name.value]); - } - - void Visit(GlrLoopSyntax* node) override - { - NotBeginWithARule(node); - } - - void Visit(GlrOptionalSyntax* node) override - { - NotBeginWithARule(node); - } - - void Visit(GlrSequenceSyntax* node) override - { - node->first->Accept(this); - } - - void Visit(GlrAlternativeSyntax* node) override - { - NotBeginWithARule(node); - } - - void Visit(GlrPushConditionSyntax* node) override - { - CHECK_FAIL(L"GlrPushConditionSyntax should have been removed after RewriteSyntax_Switch()!"); - } - - void Visit(GlrTestConditionSyntax* node) override - { - CHECK_FAIL(L"GlrTestConditionSyntax should have been removed after RewriteSyntax_Switch()!"); - } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrCreateClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrPartialClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrReuseClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - NotBeginWithARule(node); - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - NotBeginWithARule(node); - } - - void Visit(GlrPrefixMergeClause* node) override - { - } - }; - -/*********************************************************************** -ValidateDeducingPrefixMergeRuleVisitor -***********************************************************************/ - - class ValidateDeducingPrefixMergeRuleVisitor - : public Object - , protected virtual GlrSyntax::IVisitor - , protected virtual GlrClause::IVisitor - { - protected: - using NonSimpleUseDeduction = Pair; - - VisitorContext& context; - RuleSymbol* ruleSymbol; - - Ptr> result; - bool couldBeEmpty = false; - - public: - ValidateDeducingPrefixMergeRuleVisitor( - VisitorContext& _context, - RuleSymbol* _ruleSymbol - ) - : context(_context) - , ruleSymbol(_ruleSymbol) - { - } - - void ValidateClause(Ptr clause) - { - clause->Accept(this); - } - - protected: - - void TryAppendResult(const ParsingToken& name, RuleSymbol* refRuleSymbol) - { - if (context.directPmClauses.Keys().Contains(refRuleSymbol)) - { - if (!result) result = Ptr(new List); - result->Add({ &name,refRuleSymbol }); - } - } - - void VisitRuleRef(const ParsingToken& name) - { - vint index = context.syntaxManager.Rules().Keys().IndexOf(name.value); - if (index == -1) return; - - auto refRuleSymbol = context.syntaxManager.Rules().Values()[index]; - TryAppendResult(name, refRuleSymbol); - - index = context.indirectSimpleUseRules.Keys().IndexOf(refRuleSymbol); - if (index == -1) return; - - for (auto [simpleUseSymbol, _] : context.indirectSimpleUseRules.GetByIndex(index)) - { - TryAppendResult(name, simpleUseSymbol); - } - } - - void VisitPotentialEmptySyntax() - { - // a clause is not allowed to produce an empty sequence - // since this syntax could produce an empty sequence - // therefore there should be other non-parallel part of syntax in this clause that produces a non-empty sequence - // it doesn't need to check the error here - result = nullptr; - couldBeEmpty = true; - } - - //////////////////////////////////////////////////////////////////////// - // GlrSyntax::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrRefSyntax* node) override - { - result = nullptr; - couldBeEmpty = false; - - if (node->refType != GlrRefType::Id) return; - VisitRuleRef(node->literal); - } - - void Visit(GlrUseSyntax* node) override - { - result = nullptr; - couldBeEmpty = false; - - VisitRuleRef(node->name); - } - - void Visit(GlrLoopSyntax* node) override - { - VisitPotentialEmptySyntax(); - } - - void Visit(GlrOptionalSyntax* node) override - { - VisitPotentialEmptySyntax(); - } - - void Visit(GlrSequenceSyntax* node) override - { - node->first->Accept(this); - auto firstResult = result; - bool firstEmpty = couldBeEmpty; - - node->second->Accept(this); - auto secondResult = result; - auto secondEmpty = couldBeEmpty; - - couldBeEmpty = firstEmpty && secondEmpty; - - if (!firstEmpty && !secondEmpty) - { - result = nullptr; - } - else if (!firstEmpty) - { - result = firstResult; - } - else if (!secondEmpty) - { - result = secondResult; - } - else - { - result = nullptr; - } - } - - void Visit(GlrAlternativeSyntax* node) override - { - node->first->Accept(this); - auto firstResult = result; - bool firstEmpty = couldBeEmpty; - - node->second->Accept(this); - auto secondResult = result; - auto secondEmpty = couldBeEmpty; - - couldBeEmpty = firstEmpty || secondEmpty; - if (couldBeEmpty) - { - VisitPotentialEmptySyntax(); - } - else - { - if (firstResult && secondResult) - { - CopyFrom(*firstResult.Obj(), *secondResult.Obj(), true); - result = firstResult; - } - else if (firstResult) - { - result = firstResult; - } - else if (secondResult) - { - result = secondResult; - } - else - { - result = nullptr; - } - } - } - - void Visit(GlrPushConditionSyntax* node) override - { - CHECK_FAIL(L"GlrPushConditionSyntax should have been removed after RewriteSyntax_Switch()!"); - } - - void Visit(GlrTestConditionSyntax* node) override - { - CHECK_FAIL(L"GlrTestConditionSyntax should have been removed after RewriteSyntax_Switch()!"); - } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrCreateClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrPartialClause* node) override - { - node->syntax->Accept(this); - } - - void Visit(GlrReuseClause* node) override - { - if (!dynamic_cast(node->syntax.Obj())) - { - node->syntax->Accept(this); - } - } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - if (!node->continuation || node->continuation->type == GlrLeftRecursionInjectContinuationType::Optional) - { - VisitRuleRef(node->rule->literal); - } - } - - void Visit(GlrPrefixMergeClause* node) override - { - } - }; - -/*********************************************************************** -ValidatePrefixMerge -***********************************************************************/ - - void ValidatePrefixMerge(VisitorContext& context, Ptr syntaxFile) - { - for (auto rule : syntaxFile->rules) - { - auto ruleSymbol = context.syntaxManager.Rules()[rule->name.value]; - - if (context.directPmClauses.Keys().Contains(ruleSymbol)) - { - ValidateDirectPrefixMergeRuleVisitor visitor(context, ruleSymbol); - for (auto clause : rule->clauses) - { - visitor.ValidateClause(clause); - } - } - - { - ValidateDeducingPrefixMergeRuleVisitor visitor(context, ruleSymbol); - for (auto clause : rule->clauses) - { - visitor.ValidateClause(clause); - } - } - - vint indexPm = context.indirectPmClauses.Keys().IndexOf(ruleSymbol); - vint indexLrp = context.indirectLrpClauses.Keys().IndexOf(ruleSymbol); - vint indexLri = context.indirectLriClauses.Keys().IndexOf(ruleSymbol); - - if (indexPm != -1) - { - auto rulePm = context.clauseToRules[context.indirectPmClauses.GetByIndex(indexPm)[0]]; - if (indexLrp != -1) - { - auto ruleLrp = context.clauseToRules[context.indirectLrpClauses.GetByIndex(indexLrp)[0]]; - context.syntaxManager.AddError( - ParserErrorType::RuleIndirectlyBeginsWithPrefixMergeMixedLeftRecursionMarkers, - rule->name.codeRange, - ruleSymbol->Name(), - rulePm->Name(), - ruleLrp->Name() - ); - } - if (indexLri != -1) - { - auto ruleLri = context.clauseToRules[context.indirectLriClauses.GetByIndex(indexLri)[0]]; - context.syntaxManager.AddError( - ParserErrorType::RuleIndirectlyBeginsWithPrefixMergeMixedLeftRecursionMarkers, - rule->name.codeRange, - ruleSymbol->Name(), - rulePm->Name(), - ruleLri->Name() - ); - } - if (ruleSymbol->isPartial) - { - context.syntaxManager.AddError( - ParserErrorType::PartialRuleIndirectlyBeginsWithPrefixMerge, - rule->name.codeRange, - ruleSymbol->Name(), - rulePm->Name() - ); - } - - if (!context.directPmClauses.Keys().Contains(ruleSymbol)) - { - for (auto clause : rule->clauses) - { - ParsingToken firstDirectLiteral; - RuleSymbol* firstIndirectNonPmRule = nullptr; - GlrPrefixMergeClause* firstIndirectlyPmClause = nullptr; - - // test if this clause directly begins with and literal - vint index = context.clauseBeginsWithLiteral.Keys().IndexOf(clause.Obj()); - if (index != -1) - { - firstDirectLiteral = context.clauseBeginsWithLiteral.GetByIndex(index)[0]; - } - - // find all direct start rules from this clause - index = context.clauseToStartRules.Keys().IndexOf(clause.Obj()); - if (index != -1) - { - List visiting; - SortedList visited; - CopyFrom(visiting, context.clauseToStartRules.GetByIndex(index)); - - // TODO: (enumerable) visiting/visited - for (vint i = 0; i < visiting.Count(); i++) - { - auto visitingRule = visiting[i]; - if (visited.Contains(visitingRule)) continue; - visited.Add(visitingRule); - - // test if the visiting rule begins with prefix_merge - index = context.indirectPmClauses.Keys().IndexOf(visitingRule); - if (index != -1) - { - if (!firstIndirectlyPmClause) - { - firstIndirectlyPmClause = context.indirectPmClauses.GetByIndex(index)[0]; - } - } - else - { - // if the visiting rule itself partial begins with prefix_merge - // then an errors should be generated for this rule - // here we assume it never happens in order to reduce the number of errors - if (!firstIndirectNonPmRule) - { - firstIndirectNonPmRule = visitingRule; - } - } - if ((firstDirectLiteral || firstIndirectNonPmRule) && firstIndirectlyPmClause) break; - } - } - - if (firstDirectLiteral && firstIndirectlyPmClause) - { - context.syntaxManager.AddError( - ParserErrorType::ClausePartiallyIndirectlyBeginsWithPrefixMergeAndLiteral, - clause->codeRange, - ruleSymbol->Name(), - context.clauseToRules[firstIndirectlyPmClause]->Name(), - firstDirectLiteral.value - ); - } - else if (firstIndirectNonPmRule && firstIndirectlyPmClause) - { - context.syntaxManager.AddError( - ParserErrorType::ClausePartiallyIndirectlyBeginsWithPrefixMergeAndRule, - clause->codeRange, - ruleSymbol->Name(), - context.clauseToRules[firstIndirectlyPmClause]->Name(), - firstIndirectNonPmRule->Name() - ); - } - else if (!context.leftRecursiveClauses.Contains(ruleSymbol, clause.Obj())) - { - // safe to add the clause since errors have been detected in ClausePartiallyIndirectlyBeginsWithPrefixMerge - vint index = context.clauseToStartRules.Keys().IndexOf(clause.Obj()); - if (index != -1) - { - for (auto ruleSymbol : context.clauseToStartRules.GetByIndex(index)) - { - if (context.indirectPmClauses.Keys().IndexOf(ruleSymbol) != -1) - { - goto SKIP_ADDING; - } - } - } - context.clauseToConvertedToPrefixMerge.Add(clause.Obj()); - SKIP_ADDING:; - } - } - } - } - } - } - } - } -} - /*********************************************************************** .\PARSERGEN\COMPILESYNTAX_VALIDATESTRUCTURE.CPP ***********************************************************************/ @@ -8750,7 +6370,6 @@ ValidateStructureCountingVisitor VisitorContext& context; RuleSymbol* ruleSymbol; GlrClause* clause = nullptr; - GlrLeftRecursionPlaceholderClause* lrpClause = nullptr; vint optionalCounter = 0; vint loopCounter = 0; @@ -9037,30 +6656,6 @@ ValidateStructureCountingVisitor node->syntax->Accept(this); CheckAfterClause(node, true); } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - if (!lrpClause) - { - lrpClause = node; - } - else - { - context.syntaxManager.AddError( - ParserErrorType::TooManyLeftRecursionPlaceholderClauses, - node->codeRange, - ruleSymbol->Name() - ); - } - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - } - - void Visit(GlrPrefixMergeClause* node) override - { - } }; /*********************************************************************** @@ -9118,6 +6713,19 @@ ValidateStructureRelationshipVisitor { AddFieldCounter(node->field.value, 1); } + + if (ruleSymbol->isPartial && node->refType == GlrRefType::Id) + { + vint ruleIndex = context.syntaxManager.Rules().Keys().IndexOf(node->literal.value); + if (ruleIndex != -1) + { + auto refRuleSymbol = context.syntaxManager.Rules().Values()[ruleIndex]; + if (refRuleSymbol->isPartial && !context.partialRuleDependencies.Contains(ruleSymbol, refRuleSymbol)) + { + context.partialRuleDependencies.Add(ruleSymbol, refRuleSymbol); + } + } + } } void Visit(GlrUseSyntax* node) override @@ -9256,18 +6864,6 @@ ValidateStructureRelationshipVisitor node->syntax->Accept(this); CheckAfterClause(node); } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - } - - void Visit(GlrPrefixMergeClause* node) override - { - } }; /*********************************************************************** @@ -9287,6 +6883,45 @@ ValidateStructure visitor2.ValidateClause(clause); } } + + PartialOrderingProcessor pop; + List partialRules; + CopyFrom(partialRules, + From(context.syntaxManager.Rules().Values()) + .Where([&](RuleSymbol* rule) { return rule->isPartial; }) + ); + pop.InitWithGroup(partialRules, context.partialRuleDependencies); + pop.Sort(); + + for (vint i = 0; i < context.partialRuleDependencies.Count(); i++) + { + auto partialRule = context.partialRuleDependencies.Keys()[i]; + if (context.partialRuleDependencies.GetByIndex(i).Contains(partialRule)) + { + context.syntaxManager.AddError( + ParserErrorType::PartialRuleIsRecursive, + context.astRules[partialRule]->codeRange, + partialRule->Name() + ); + } + } + + for (auto&& component : pop.components) + { + if (component.nodeCount > 1) + { + for (auto partialRule : From(FromPointer(component.firstNode, component.firstNode + component.nodeCount)) + .Select([&](vint index) { return partialRules[index]; }) + .OrderByKey([](auto partialRule) { return partialRule->Name(); })) + { + context.syntaxManager.AddError( + ParserErrorType::PartialRuleIsRecursive, + context.astRules[partialRule]->codeRange, + partialRule->Name() + ); + } + } + } } } } @@ -9584,26 +7219,6 @@ VerifySwitchesAndConditionsVisitor } } } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Traverse(GlrPrefixMergeClause* node) override - { - auto pmRuleSymbol = context.syntaxManager.Rules()[node->rule->literal.value]; - vint index = sContext.ruleAffectedSwitches.Keys().IndexOf(pmRuleSymbol); - if(index != -1) - { - context.syntaxManager.AddError( - ParserErrorType::PrefixMergeAffectedBySwitches, - node->codeRange, - ruleSymbol->Name(), - pmRuleSymbol->Name(), - sContext.ruleAffectedSwitches.GetByIndex(index)[0] - ); - } - } }; /*********************************************************************** @@ -9928,240 +7543,6 @@ ValidateTypesVisitor Visit(assignment.Obj()); } } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - } - - void Visit(GlrPrefixMergeClause* node) override - { - auto prefixRule = context.syntaxManager.Rules()[node->rule->literal.value]; - if (prefixRule->isPartial) - { - context.syntaxManager.AddError( - ParserErrorType::PartialRuleInPrefixMerge, - node->rule->codeRange, - ruleSymbol->Name(), - node->rule->literal.value - ); - } - } - }; - -/*********************************************************************** -LriVerifyTypesVisitor -***********************************************************************/ - - class LriVerifyTypesVisitor - : public empty_visitor::ClauseVisitor - { - protected: - VisitorContext& context; - RuleSymbol* ruleSymbol; - - public: - LriVerifyTypesVisitor( - VisitorContext& _context, - RuleSymbol* _ruleSymbol - ) - : context(_context) - , ruleSymbol(_ruleSymbol) - { - } - - void ValidateClause(Ptr clause) - { - clause->Accept(this); - } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void Visit(GlrLeftRecursionInjectClause* node) override - { - auto prefixRule = context.syntaxManager.Rules()[node->rule->literal.value]; - if (prefixRule->isPartial) - { - context.syntaxManager.AddError( - ParserErrorType::PartialRuleInLeftRecursionInject, - node->rule->codeRange, - ruleSymbol->Name(), - node->rule->literal.value - ); - } - - for (auto lriTarget : node->continuation->injectionTargets) - { - auto target = lriTarget->rule; - for (auto lriFlag : node->continuation->flags) - { - List lrpClauses; - { - vint index = context.indirectLrpClauses.Keys().IndexOf(context.syntaxManager.Rules()[target->literal.value]); - if (index != -1) - { - CopyFrom( - lrpClauses, - From(context.indirectLrpClauses.GetByIndex(index)) - .Where([lriFlag](auto&& lrp) - { - return !From(lrp->flags) - .Where([lriFlag](auto&& flag) { return flag->flag.value == lriFlag->flag.value; }) - .IsEmpty(); - })); - } - } - - if (lrpClauses.Count() == 0) - { - context.syntaxManager.AddError( - ParserErrorType::LeftRecursionPlaceholderNotFoundInRule, - target->codeRange, - ruleSymbol->Name(), - lriFlag->flag.value, - target->literal.value - ); - } - else if (lrpClauses.Count() > 1 && node->continuation->configuration == GlrLeftRecursionConfiguration::Single) - { - context.syntaxManager.AddError( - ParserErrorType::LeftRecursionPlaceholderNotUnique, - target->codeRange, - ruleSymbol->Name(), - lriFlag->flag.value, - target->literal.value - ); - } - - for (auto lrpClause : lrpClauses) - { - auto lrpClauseRule = context.clauseToRules[lrpClause]; - if (!ConvertibleTo(prefixRule->ruleType, lrpClauseRule->ruleType)) - { - context.syntaxManager.AddError( - ParserErrorType::LeftRecursionPlaceholderTypeMismatched, - target->codeRange, - ruleSymbol->Name(), - lriFlag->flag.value, - target->literal.value, - lrpClauseRule->Name() - ); - } - } - } - - if (lriTarget->continuation) - { - Visit(lriTarget.Obj()); - } - } - } - }; - -/*********************************************************************** -LriPrefixTestingVisitor -***********************************************************************/ - - class LriPrefixTestingVisitor - : public empty_visitor::ClauseVisitor - { - protected: - VisitorContext& context; - RuleSymbol* ruleSymbol; - Group lriEndings; - - public: - LriPrefixTestingVisitor( - VisitorContext& _context, - RuleSymbol* _ruleSymbol - ) - : context(_context) - , ruleSymbol(_ruleSymbol) - { - } - - void ValidateClause(Ptr clause) - { - clause->Accept(this); - } - - //////////////////////////////////////////////////////////////////////// - // GlrClause::IVisitor - //////////////////////////////////////////////////////////////////////// - - void SearchLriEndings(List& visiting, GlrLeftRecursionInjectClause* node) - { - visiting.Add(node); - if (!node->continuation || node->continuation->type == GlrLeftRecursionInjectContinuationType::Optional) - { - for (auto lri : visiting) - { - if (!lriEndings.Contains(lri, node->rule->literal.value)) - { - lriEndings.Add(lri, node->rule->literal.value); - } - } - } - - if (node->continuation) - { - for (auto target : node->continuation->injectionTargets) - { - SearchLriEndings(visiting, target.Obj()); - } - } - visiting.RemoveAt(visiting.Count() - 1); - } - - void VerifyPrefix(GlrLeftRecursionInjectClause* node) - { - if (node->continuation) - { - for (auto t1 : node->continuation->injectionTargets) - { - auto k1 = context.syntaxManager.Rules()[t1->rule->literal.value]; - vint i1 = lriEndings.Keys().IndexOf(t1.Obj()); - if (i1 == -1) continue; - for (auto t2 : node->continuation->injectionTargets) - { - auto k2 = context.syntaxManager.Rules()[t2->rule->literal.value]; - vint i2 = lriEndings.Keys().IndexOf(t2.Obj()); - if (i2 == -1) continue; - - if (t1 != t2 && context.indirectStartPathToLastRules.Keys().Contains({ k2, k1 })) - { - auto&& e1 = lriEndings.GetByIndex(i1); - auto&& e2 = lriEndings.GetByIndex(i2); - if (!From(e1).Intersect(e2).IsEmpty()) - { - context.syntaxManager.AddError( - ParserErrorType::LeftRecursionInjectTargetIsPrefixOfAnotherSameEnding, - node->codeRange, - ruleSymbol->Name(), - node->continuation->flags[0]->flag.value, - k1->Name(), - k2->Name() - ); - } - } - } - } - } - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - { - List visiting; - SearchLriEndings(visiting, node); - } - VerifyPrefix(node); - } }; /*********************************************************************** @@ -10177,14 +7558,6 @@ ValidateTypes for (auto clause : rule->clauses) { vtVisitor.ValidateClause(clause); - { - LriVerifyTypesVisitor lvtVisitor(context, ruleSymbol); - lvtVisitor.ValidateClause(clause); - } - { - LriPrefixTestingVisitor lptVisitor(context, ruleSymbol); - lptVisitor.ValidateClause(clause); - } } } } @@ -10378,7 +7751,8 @@ Utility void InitializeParserSymbolManager(ParserSymbolManager& manager) { manager.name = L"ParserGen"; - Fill(manager.includes, L"../AstBase.h", L"../SyntaxBase.h"); + Fill(manager.astIncludes, L"../AstBase.h"); + Fill(manager.syntaxIncludes, L"../SyntaxBase.h"); Fill(manager.cppNss, L"vl", L"glr", L"parsergen"); manager.headerGuard = L"VCZH_PARSER2_PARSERGEN"; } @@ -10476,21 +7850,6 @@ Visitor Pattern Implementation { visitor->Visit(this); } - - void GlrLeftRecursionPlaceholderClause::Accept(GlrClause::IVisitor* visitor) - { - visitor->Visit(this); - } - - void GlrLeftRecursionInjectClause::Accept(GlrClause::IVisitor* visitor) - { - visitor->Visit(this); - } - - void GlrPrefixMergeClause::Accept(GlrClause::IVisitor* visitor) - { - visitor->Visit(this); - } } namespace vl::reflection::description { @@ -10524,13 +7883,6 @@ namespace vl::reflection::description IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrCreateClause, glr::parsergen::GlrCreateClause) IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrPartialClause, glr::parsergen::GlrPartialClause) IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrReuseClause, glr::parsergen::GlrReuseClause) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionPlaceholder, glr::parsergen::GlrLeftRecursionPlaceholder) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause, glr::parsergen::GlrLeftRecursionPlaceholderClause) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionConfiguration, glr::parsergen::GlrLeftRecursionConfiguration) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType, glr::parsergen::GlrLeftRecursionInjectContinuationType) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionInjectContinuation, glr::parsergen::GlrLeftRecursionInjectContinuation) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrLeftRecursionInjectClause, glr::parsergen::GlrLeftRecursionInjectClause) - IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrPrefixMergeClause, glr::parsergen::GlrPrefixMergeClause) IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrRule, glr::parsergen::GlrRule) IMPL_TYPE_INFO_RENAME(vl::glr::parsergen::GlrSyntaxFile, glr::parsergen::GlrSyntaxFile) @@ -10739,62 +8091,6 @@ namespace vl::reflection::description CLASS_MEMBER_FIELD(assignments) END_CLASS_MEMBER(vl::glr::parsergen::GlrReuseClause) - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionPlaceholder) - CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) - - CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) - - CLASS_MEMBER_FIELD(flag) - END_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionPlaceholder) - - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause) - CLASS_MEMBER_BASE(vl::glr::parsergen::GlrClause) - - CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) - - CLASS_MEMBER_FIELD(flags) - END_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause) - - BEGIN_ENUM_ITEM(vl::glr::parsergen::GlrLeftRecursionConfiguration) - ENUM_ITEM_NAMESPACE(vl::glr::parsergen::GlrLeftRecursionConfiguration) - ENUM_NAMESPACE_ITEM(Single) - ENUM_NAMESPACE_ITEM(Multiple) - END_ENUM_ITEM(vl::glr::parsergen::GlrLeftRecursionConfiguration) - - BEGIN_ENUM_ITEM(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType) - ENUM_ITEM_NAMESPACE(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType) - ENUM_NAMESPACE_ITEM(Optional) - ENUM_NAMESPACE_ITEM(Required) - END_ENUM_ITEM(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType) - - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionInjectContinuation) - CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) - - CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) - - CLASS_MEMBER_FIELD(flags) - CLASS_MEMBER_FIELD(configuration) - CLASS_MEMBER_FIELD(type) - CLASS_MEMBER_FIELD(injectionTargets) - END_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionInjectContinuation) - - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionInjectClause) - CLASS_MEMBER_BASE(vl::glr::parsergen::GlrClause) - - CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) - - CLASS_MEMBER_FIELD(rule) - CLASS_MEMBER_FIELD(continuation) - END_CLASS_MEMBER(vl::glr::parsergen::GlrLeftRecursionInjectClause) - - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrPrefixMergeClause) - CLASS_MEMBER_BASE(vl::glr::parsergen::GlrClause) - - CLASS_MEMBER_CONSTRUCTOR(vl::Ptr(), NO_PARAMETER) - - CLASS_MEMBER_FIELD(rule) - END_CLASS_MEMBER(vl::glr::parsergen::GlrPrefixMergeClause) - BEGIN_CLASS_MEMBER(vl::glr::parsergen::GlrRule) CLASS_MEMBER_BASE(vl::glr::ParsingAstBase) @@ -10838,9 +8134,6 @@ namespace vl::reflection::description CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrCreateClause* node)) CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrPartialClause* node)) CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrReuseClause* node)) - CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause* node)) - CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrLeftRecursionInjectClause* node)) - CLASS_MEMBER_METHOD_OVERLOAD(Visit, {L"node"}, void(vl::glr::parsergen::GlrClause::IVisitor::*)(vl::glr::parsergen::GlrPrefixMergeClause* node)) END_INTERFACE_MEMBER(vl::glr::parsergen::GlrClause) #endif @@ -10879,13 +8172,6 @@ namespace vl::reflection::description ADD_TYPE_INFO(vl::glr::parsergen::GlrCreateClause) ADD_TYPE_INFO(vl::glr::parsergen::GlrPartialClause) ADD_TYPE_INFO(vl::glr::parsergen::GlrReuseClause) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionPlaceholder) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionConfiguration) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectContinuation) - ADD_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectClause) - ADD_TYPE_INFO(vl::glr::parsergen::GlrPrefixMergeClause) ADD_TYPE_INFO(vl::glr::parsergen::GlrRule) ADD_TYPE_INFO(vl::glr::parsergen::GlrSyntaxFile) } @@ -11000,70 +8286,6 @@ MakeCreateClause return *this; } -/*********************************************************************** -MakeLeftRecursionInjectClause -***********************************************************************/ - - MakeLeftRecursionInjectClause& MakeLeftRecursionInjectClause::continuation(const vl::Ptr& value) - { - node->continuation = value; - return *this; - } - - MakeLeftRecursionInjectClause& MakeLeftRecursionInjectClause::rule(const vl::Ptr& value) - { - node->rule = value; - return *this; - } - -/*********************************************************************** -MakeLeftRecursionInjectContinuation -***********************************************************************/ - - MakeLeftRecursionInjectContinuation& MakeLeftRecursionInjectContinuation::configuration(GlrLeftRecursionConfiguration value) - { - node->configuration = value; - return *this; - } - - MakeLeftRecursionInjectContinuation& MakeLeftRecursionInjectContinuation::flags(const vl::Ptr& value) - { - node->flags.Add(value); - return *this; - } - - MakeLeftRecursionInjectContinuation& MakeLeftRecursionInjectContinuation::injectionTargets(const vl::Ptr& value) - { - node->injectionTargets.Add(value); - return *this; - } - - MakeLeftRecursionInjectContinuation& MakeLeftRecursionInjectContinuation::type(GlrLeftRecursionInjectContinuationType value) - { - node->type = value; - return *this; - } - -/*********************************************************************** -MakeLeftRecursionPlaceholder -***********************************************************************/ - - MakeLeftRecursionPlaceholder& MakeLeftRecursionPlaceholder::flag(const vl::WString& value) - { - node->flag.value = value; - return *this; - } - -/*********************************************************************** -MakeLeftRecursionPlaceholderClause -***********************************************************************/ - - MakeLeftRecursionPlaceholderClause& MakeLeftRecursionPlaceholderClause::flags(const vl::Ptr& value) - { - node->flags.Add(value); - return *this; - } - /*********************************************************************** MakeLoopSyntax ***********************************************************************/ @@ -11144,16 +8366,6 @@ MakePartialClause return *this; } -/*********************************************************************** -MakePrefixMergeClause -***********************************************************************/ - - MakePrefixMergeClause& MakePrefixMergeClause::rule(const vl::Ptr& value) - { - node->rule = value; - return *this; - } - /*********************************************************************** MakePushConditionSyntax ***********************************************************************/ @@ -11390,41 +8602,6 @@ namespace vl::glr::parsergen::copy_visitor to->type = from->type; } - void RuleAstVisitor::CopyFields(GlrLeftRecursionInjectClause* from, GlrLeftRecursionInjectClause* to) - { - CopyFields(static_cast(from), static_cast(to)); - to->continuation = CopyNode(from->continuation.Obj()); - to->rule = CopyNode(from->rule.Obj()); - } - - void RuleAstVisitor::CopyFields(GlrLeftRecursionInjectContinuation* from, GlrLeftRecursionInjectContinuation* to) - { - to->configuration = from->configuration; - for (auto&& listItem : from->flags) - { - to->flags.Add(CopyNode(listItem.Obj())); - } - for (auto&& listItem : from->injectionTargets) - { - to->injectionTargets.Add(CopyNode(listItem.Obj())); - } - to->type = from->type; - } - - void RuleAstVisitor::CopyFields(GlrLeftRecursionPlaceholder* from, GlrLeftRecursionPlaceholder* to) - { - to->flag = from->flag; - } - - void RuleAstVisitor::CopyFields(GlrLeftRecursionPlaceholderClause* from, GlrLeftRecursionPlaceholderClause* to) - { - CopyFields(static_cast(from), static_cast(to)); - for (auto&& listItem : from->flags) - { - to->flags.Add(CopyNode(listItem.Obj())); - } - } - void RuleAstVisitor::CopyFields(GlrLoopSyntax* from, GlrLoopSyntax* to) { CopyFields(static_cast(from), static_cast(to)); @@ -11463,12 +8640,6 @@ namespace vl::glr::parsergen::copy_visitor to->type = from->type; } - void RuleAstVisitor::CopyFields(GlrPrefixMergeClause* from, GlrPrefixMergeClause* to) - { - CopyFields(static_cast(from), static_cast(to)); - to->rule = CopyNode(from->rule.Obj()); - } - void RuleAstVisitor::CopyFields(GlrPushConditionSyntax* from, GlrPushConditionSyntax* to) { CopyFields(static_cast(from), static_cast(to)); @@ -11586,20 +8757,6 @@ namespace vl::glr::parsergen::copy_visitor this->result = newNode; } - void RuleAstVisitor::Visit(GlrLeftRecursionPlaceholder* node) - { - auto newNode = vl::Ptr(new GlrLeftRecursionPlaceholder); - CopyFields(node, newNode.Obj()); - this->result = newNode; - } - - void RuleAstVisitor::Visit(GlrLeftRecursionInjectContinuation* node) - { - auto newNode = vl::Ptr(new GlrLeftRecursionInjectContinuation); - CopyFields(node, newNode.Obj()); - this->result = newNode; - } - void RuleAstVisitor::Visit(GlrRule* node) { auto newNode = vl::Ptr(new GlrRule); @@ -11719,27 +8876,6 @@ namespace vl::glr::parsergen::copy_visitor this->result = newNode; } - void RuleAstVisitor::Visit(GlrLeftRecursionPlaceholderClause* node) - { - auto newNode = vl::Ptr(new GlrLeftRecursionPlaceholderClause); - CopyFields(node, newNode.Obj()); - this->result = newNode; - } - - void RuleAstVisitor::Visit(GlrLeftRecursionInjectClause* node) - { - auto newNode = vl::Ptr(new GlrLeftRecursionInjectClause); - CopyFields(node, newNode.Obj()); - this->result = newNode; - } - - void RuleAstVisitor::Visit(GlrPrefixMergeClause* node) - { - auto newNode = vl::Ptr(new GlrPrefixMergeClause); - CopyFields(node, newNode.Obj()); - this->result = newNode; - } - vl::Ptr RuleAstVisitor::CopyNode(GlrCondition* node) { if (!node) return nullptr; @@ -11788,22 +8924,6 @@ namespace vl::glr::parsergen::copy_visitor return this->result.Cast(); } - vl::Ptr RuleAstVisitor::CopyNode(GlrLeftRecursionPlaceholder* node) - { - if (!node) return nullptr; - Visit(node); - this->result->codeRange = node->codeRange; - return this->result.Cast(); - } - - vl::Ptr RuleAstVisitor::CopyNode(GlrLeftRecursionInjectContinuation* node) - { - if (!node) return nullptr; - Visit(node); - this->result->codeRange = node->codeRange; - return this->result.Cast(); - } - vl::Ptr RuleAstVisitor::CopyNode(GlrRule* node) { if (!node) return nullptr; @@ -11838,18 +8958,6 @@ namespace vl::glr::parsergen::copy_visitor return CopyNode(static_cast(node)).Cast(); } - vl::Ptr RuleAstVisitor::CopyNode(GlrLeftRecursionInjectClause* node) - { - if (!node) return nullptr; - return CopyNode(static_cast(node)).Cast(); - } - - vl::Ptr RuleAstVisitor::CopyNode(GlrLeftRecursionPlaceholderClause* node) - { - if (!node) return nullptr; - return CopyNode(static_cast(node)).Cast(); - } - vl::Ptr RuleAstVisitor::CopyNode(GlrLoopSyntax* node) { if (!node) return nullptr; @@ -11880,12 +8988,6 @@ namespace vl::glr::parsergen::copy_visitor return CopyNode(static_cast(node)).Cast(); } - vl::Ptr RuleAstVisitor::CopyNode(GlrPrefixMergeClause* node) - { - if (!node) return nullptr; - return CopyNode(static_cast(node)).Cast(); - } - vl::Ptr RuleAstVisitor::CopyNode(GlrPushConditionSyntax* node) { if (!node) return nullptr; @@ -12021,18 +9123,6 @@ ClauseVisitor void ClauseVisitor::Visit(GlrReuseClause* node) { } - - void ClauseVisitor::Visit(GlrLeftRecursionPlaceholderClause* node) - { - } - - void ClauseVisitor::Visit(GlrLeftRecursionInjectClause* node) - { - } - - void ClauseVisitor::Visit(GlrPrefixMergeClause* node) - { - } } @@ -12113,83 +9203,6 @@ namespace vl::glr::parsergen::json_visitor WriteToken(node->type); EndField(); } - void RuleAstVisitor::PrintFields(GlrLeftRecursionInjectClause* node) - { - BeginField(vl::WString::Unmanaged(L"continuation")); - Print(node->continuation.Obj()); - EndField(); - BeginField(vl::WString::Unmanaged(L"rule")); - Print(node->rule.Obj()); - EndField(); - } - void RuleAstVisitor::PrintFields(GlrLeftRecursionInjectContinuation* node) - { - BeginField(vl::WString::Unmanaged(L"configuration")); - switch (node->configuration) - { - case vl::glr::parsergen::GlrLeftRecursionConfiguration::Multiple: - WriteString(vl::WString::Unmanaged(L"Multiple")); - break; - case vl::glr::parsergen::GlrLeftRecursionConfiguration::Single: - WriteString(vl::WString::Unmanaged(L"Single")); - break; - default: - WriteNull(); - } - EndField(); - BeginField(vl::WString::Unmanaged(L"flags")); - BeginArray(); - for (auto&& listItem : node->flags) - { - BeginArrayItem(); - Print(listItem.Obj()); - EndArrayItem(); - } - EndArray(); - EndField(); - BeginField(vl::WString::Unmanaged(L"injectionTargets")); - BeginArray(); - for (auto&& listItem : node->injectionTargets) - { - BeginArrayItem(); - Print(listItem.Obj()); - EndArrayItem(); - } - EndArray(); - EndField(); - BeginField(vl::WString::Unmanaged(L"type")); - switch (node->type) - { - case vl::glr::parsergen::GlrLeftRecursionInjectContinuationType::Optional: - WriteString(vl::WString::Unmanaged(L"Optional")); - break; - case vl::glr::parsergen::GlrLeftRecursionInjectContinuationType::Required: - WriteString(vl::WString::Unmanaged(L"Required")); - break; - default: - WriteNull(); - } - EndField(); - } - void RuleAstVisitor::PrintFields(GlrLeftRecursionPlaceholder* node) - { - BeginField(vl::WString::Unmanaged(L"flag")); - WriteToken(node->flag); - EndField(); - } - void RuleAstVisitor::PrintFields(GlrLeftRecursionPlaceholderClause* node) - { - BeginField(vl::WString::Unmanaged(L"flags")); - BeginArray(); - for (auto&& listItem : node->flags) - { - BeginArrayItem(); - Print(listItem.Obj()); - EndArrayItem(); - } - EndArray(); - EndField(); - } void RuleAstVisitor::PrintFields(GlrLoopSyntax* node) { BeginField(vl::WString::Unmanaged(L"delimiter")); @@ -12255,12 +9268,6 @@ namespace vl::glr::parsergen::json_visitor WriteToken(node->type); EndField(); } - void RuleAstVisitor::PrintFields(GlrPrefixMergeClause* node) - { - BeginField(vl::WString::Unmanaged(L"rule")); - Print(node->rule.Obj()); - EndField(); - } void RuleAstVisitor::PrintFields(GlrPushConditionSyntax* node) { BeginField(vl::WString::Unmanaged(L"switches")); @@ -12642,48 +9649,6 @@ namespace vl::glr::parsergen::json_visitor EndObject(); } - void RuleAstVisitor::Visit(GlrLeftRecursionPlaceholderClause* node) - { - if (!node) - { - WriteNull(); - return; - } - BeginObject(); - WriteType(vl::WString::Unmanaged(L"LeftRecursionPlaceholderClause"), node); - PrintFields(static_cast(node)); - PrintFields(static_cast(node)); - EndObject(); - } - - void RuleAstVisitor::Visit(GlrLeftRecursionInjectClause* node) - { - if (!node) - { - WriteNull(); - return; - } - BeginObject(); - WriteType(vl::WString::Unmanaged(L"LeftRecursionInjectClause"), node); - PrintFields(static_cast(node)); - PrintFields(static_cast(node)); - EndObject(); - } - - void RuleAstVisitor::Visit(GlrPrefixMergeClause* node) - { - if (!node) - { - WriteNull(); - return; - } - BeginObject(); - WriteType(vl::WString::Unmanaged(L"PrefixMergeClause"), node); - PrintFields(static_cast(node)); - PrintFields(static_cast(node)); - EndObject(); - } - RuleAstVisitor::RuleAstVisitor(vl::stream::StreamWriter& _writer) : vl::glr::JsonVisitorBase(_writer) { @@ -12758,32 +9723,6 @@ namespace vl::glr::parsergen::json_visitor EndObject(); } - void RuleAstVisitor::Print(GlrLeftRecursionPlaceholder* node) - { - if (!node) - { - WriteNull(); - return; - } - BeginObject(); - WriteType(vl::WString::Unmanaged(L"LeftRecursionPlaceholder"), node); - PrintFields(static_cast(node)); - EndObject(); - } - - void RuleAstVisitor::Print(GlrLeftRecursionInjectContinuation* node) - { - if (!node) - { - WriteNull(); - return; - } - BeginObject(); - WriteType(vl::WString::Unmanaged(L"LeftRecursionInjectContinuation"), node); - PrintFields(static_cast(node)); - EndObject(); - } - void RuleAstVisitor::Print(GlrRule* node) { if (!node) @@ -12833,16 +9772,11 @@ namespace vl::glr::parsergen::traverse_visitor void RuleAstVisitor::Traverse(GlrClause* node) {} void RuleAstVisitor::Traverse(GlrCondition* node) {} void RuleAstVisitor::Traverse(GlrCreateClause* node) {} - void RuleAstVisitor::Traverse(GlrLeftRecursionInjectClause* node) {} - void RuleAstVisitor::Traverse(GlrLeftRecursionInjectContinuation* node) {} - void RuleAstVisitor::Traverse(GlrLeftRecursionPlaceholder* node) {} - void RuleAstVisitor::Traverse(GlrLeftRecursionPlaceholderClause* node) {} void RuleAstVisitor::Traverse(GlrLoopSyntax* node) {} void RuleAstVisitor::Traverse(GlrNotCondition* node) {} void RuleAstVisitor::Traverse(GlrOptionalSyntax* node) {} void RuleAstVisitor::Traverse(GlrOrCondition* node) {} void RuleAstVisitor::Traverse(GlrPartialClause* node) {} - void RuleAstVisitor::Traverse(GlrPrefixMergeClause* node) {} void RuleAstVisitor::Traverse(GlrPushConditionSyntax* node) {} void RuleAstVisitor::Traverse(GlrRefCondition* node) {} void RuleAstVisitor::Traverse(GlrRefSyntax* node) {} @@ -12863,16 +9797,11 @@ namespace vl::glr::parsergen::traverse_visitor void RuleAstVisitor::Finishing(GlrClause* node) {} void RuleAstVisitor::Finishing(GlrCondition* node) {} void RuleAstVisitor::Finishing(GlrCreateClause* node) {} - void RuleAstVisitor::Finishing(GlrLeftRecursionInjectClause* node) {} - void RuleAstVisitor::Finishing(GlrLeftRecursionInjectContinuation* node) {} - void RuleAstVisitor::Finishing(GlrLeftRecursionPlaceholder* node) {} - void RuleAstVisitor::Finishing(GlrLeftRecursionPlaceholderClause* node) {} void RuleAstVisitor::Finishing(GlrLoopSyntax* node) {} void RuleAstVisitor::Finishing(GlrNotCondition* node) {} void RuleAstVisitor::Finishing(GlrOptionalSyntax* node) {} void RuleAstVisitor::Finishing(GlrOrCondition* node) {} void RuleAstVisitor::Finishing(GlrPartialClause* node) {} - void RuleAstVisitor::Finishing(GlrPrefixMergeClause* node) {} void RuleAstVisitor::Finishing(GlrPushConditionSyntax* node) {} void RuleAstVisitor::Finishing(GlrRefCondition* node) {} void RuleAstVisitor::Finishing(GlrRefSyntax* node) {} @@ -13093,46 +10022,6 @@ namespace vl::glr::parsergen::traverse_visitor Finishing(static_cast(node)); } - void RuleAstVisitor::Visit(GlrLeftRecursionPlaceholderClause* node) - { - if (!node) return; - Traverse(static_cast(node)); - Traverse(static_cast(node)); - Traverse(static_cast(node)); - for (auto&& listItem : node->flags) - { - InspectInto(listItem.Obj()); - } - Finishing(static_cast(node)); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - } - - void RuleAstVisitor::Visit(GlrLeftRecursionInjectClause* node) - { - if (!node) return; - Traverse(static_cast(node)); - Traverse(static_cast(node)); - Traverse(static_cast(node)); - InspectInto(node->continuation.Obj()); - InspectInto(node->rule.Obj()); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - } - - void RuleAstVisitor::Visit(GlrPrefixMergeClause* node) - { - if (!node) return; - Traverse(static_cast(node)); - Traverse(static_cast(node)); - Traverse(static_cast(node)); - InspectInto(node->rule.Obj()); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - } - void RuleAstVisitor::InspectInto(GlrCondition* node) { if (!node) return; @@ -13183,33 +10072,6 @@ namespace vl::glr::parsergen::traverse_visitor Finishing(static_cast(node)); } - void RuleAstVisitor::InspectInto(GlrLeftRecursionPlaceholder* node) - { - if (!node) return; - Traverse(static_cast(node)); - Traverse(static_cast(node)); - Traverse(node->flag); - Finishing(static_cast(node)); - Finishing(static_cast(node)); - } - - void RuleAstVisitor::InspectInto(GlrLeftRecursionInjectContinuation* node) - { - if (!node) return; - Traverse(static_cast(node)); - Traverse(static_cast(node)); - for (auto&& listItem : node->flags) - { - InspectInto(listItem.Obj()); - } - for (auto&& listItem : node->injectionTargets) - { - InspectInto(listItem.Obj()); - } - Finishing(static_cast(node)); - Finishing(static_cast(node)); - } - void RuleAstVisitor::InspectInto(GlrRule* node) { if (!node) return; @@ -13261,71 +10123,52 @@ namespace vl::glr::parsergen { void ParserGenRuleParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 14903; // 207517 bytes before compressing + static const vl::vint dataLength = 10130; // 132882 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 55; - static const vl::vint dataSolidRows = 58; - static const vl::vint dataRows = 59; + static const vl::vint dataRemain = 146; + static const vl::vint dataSolidRows = 39; + static const vl::vint dataRows = 40; static const char* compressed[] = { - "\x9D\x2A\x03\x00\x2F\x3A\x00\x00\x27\x00\x01\x82\x80\x08\x0B\x82\x81\x82\x06\x89\x82\x88\x0A\x86\x06\x84\x0A\x0A\x97\x0A\x9C\x0A\x82\x12\x84\x80\x09\xAD\x0A\x92\x1A\x81\x2A\x84\x2B\x0A\xDC\x0A\x9F\x2A\x83\x32\x84\x34\x0A\x8C\x4A\x8F\x4A\x82\x4A\x84\x4B\x0A\xA1\x4A\x87\x5A\x86\x56\x84\x5C\x0A\xC5\x1E\x09\x8F\x7D\x9E\x9F\x9E\x0A\x80\x3F\x9F\x91\xA3\xA2\x9F\xA2\x46\xFF\x48\xA6\xAB\xA3\xA1\xA6\xA2\x0A\xC9\x8A\xB1\xA9\xA7\xA7\xA2\xAA\x4C\xD8\x8E\xA1\xAA\x81\x02\xAC\xA8\x3C\xD5\x9F\xB7\xA1\xB1\xAD\xB3\xAD\x67\xE0\x86\x92\xA6\xA8\xA3\xB0\xB7\x69\xE4\xAB\xA2\xB1\xB8\xBB\xB8\xB3\x77\xE8\x86\x9E\xA9\x84\xBD\xBC\xB5\x03\xEC\xAF\xB3\xA5\xBC\xC3\xBE\xB9\x81\xF4\x87\xD6\xB9\xC0\xBF\x80\x01\x5D\x83\xED\xA6\xCD\xC2\xBD\xCA\xC0\x02\x82\xC5\xD3\xCC\xCA\xCA\xCF\xCD\x9F\x8B\xD4\xD9\xCA\xC7\xC8\xC4\xD2\x8E\xA8\xD6\xCA\xD8\xC9\x82\xCC\xD1\x9D\xA0\xF2\xD0\xD1\xD6\xD0\xC6\xD6\xA7\xAE\xE5\xD8\xD7\xDA\xDD\xD4\xDF\xAB\xC0\xED\xC2\xAB\xDA\xE1\xDC\xE2\xBF\xC8\xC1\xEA\xE3\xE7\xD6\xDB\xD1\xC6\xBD\xCC\xE7\xEE\xE4\xDC\xE9\xE9\xD2\xD5\xD1\xF7", - "\xEA\xE8\xEC\xEF\xE2\xDE\xB1\xF4\xD3\xDF\xE2\xF1\xF3\xDA\x02\x83\x11\xC4\xF6\xEE\xF1\xF6\xF4\xDB\xEE\xF1\xF0\xF1\xF4\xF9\xEF\xFB\xE0\x84\x2B\xE3\xFC\xFF\xF0\xF7\xF9\xFF\x75\x71\x81\x01\xFB\x7E\x7D\x7F\x7B\x01\x86\x05\x80\x82\x07\x80\x8D\x82\x80\x0F\xB8\x79\x72\x84\xCB\x54\x8D\x70\x78\x16\x94\x78\x87\x86\x13\x9C\x85\x86\x87\x17\x9D\x82\x8B\x87\x23\xA1\x84\x8B\x89\x26\xA9\x8A\x85\x89\x2B\xA8\x8D\x8A\x8A\xD9\x60\x87\x73\x01\x0B\x8E\x86\x83\x8D\x0C\xB8\x86\x8D\x8E\x3C\xBB\x8E\x8C\x84\x3A\x80\x9D\x8E\x90\x3F\x99\x81\x8C\x8B\x47\xAE\x89\x90\x8C\xDF\x48\x9D\x92\x92\x4F\x8C\x92\x7C\x91\x54\x86\x91\x97\x8B\x58\x8B\x99\x97\x75\x0C\x7D\x56\x7E\x8C\x5A\xA1\x97\x96\x98\x53\x96\x95\x98\x98\x63\xA9\x97\x9A\x93\x6B\x90\x9D\x9A\x94\x5F\xAC\x91\x9E\x9B\x73\xB0\x91\x82\x99\x75\x9B\x9F\x9A\x9E\x79\xA4\x9D\x9E\x9A\x7F\xBB\x9E\x9D\x42\x09\x35\x85\x94\x9A\x82\x80\xA7\x9C\xA2\x81\x8D\xAB\xA2\x9C\x8F\xB4\x91\xA6\x9D\x11\x8C\xA3\xA4\x9F\x97\x83\xA5\xA4\xA4\x9B\x92\xAD\xA7\x70\x0A\x06\xA8\x9D\xA6\x8A\x9F\xA8\xA6\xA9\x9A\x81\x93\xAA\x41", - "\x0B\x22\xA6\xA4\xAA\xA5\xAA\xAF\xAB\x40\x0C\x2E\xAC\xA6\xAC\xB7\x83\x9B\xA8\xAE\x9E\xBC\xA4\xA6\xAF\xC7\x4D\x06\xAD\xAF\xBA\xB3\xA5\xB1\xAE\x45\x86\xB9\xB0\xB2\x00\x0E\x4E\x94\xA9\x89\x91\xBE\xA2\x41\x0F\x03\xBF\xAF\xB1\xC4\x8B\xB9\xB7\xA1\xCC\xBB\xA8\xB7\xB5\xDA\xA0\xBC\xB7\xB6\xDE\xA1\xB7\xA8\xB0\xA9\x9F\xB7\xBA\xBA\xE9\xA6\xBD\xBB\xB8\xE2\xA5\xB0\xBF\xBA\xEE\xB1\xAC\xBA\xBD\xF5\x92\xB9\x40\x04\xD6\xB4\xB3\xBF\xBB\xF2\x81\xCA\xB3\xBF\xF8\x80\x01\x05\xBF\x00\xC3\xC2\xC0\xB3\x12\x08\xC5\xC2\xBC\x13\x06\xA0\x47\xB3\xB0\xBA\xB5\xC7\xB4\xE8\x8F\xCA\xC3\xC6\xDD\x9C\xC4\xBA\xC7\xF1\xA0\xCE\xBF\xC2\x1F\xDD\xC6\xC9\xC9\x28\xE1\xC7\xCA\xCA\x29\xE3\xC2\xC9\xC2\x2B\xFE\xB5\x06\xC3\x16\xD9\xC5\xCF\xBD\x37\xF9\xB8\xC4\xCE\x3B\xFF\x86\x06\xA1\x12\x54\xC6\xCD\xCF\x04\xF9\xC5\xD0\xD1\x24\xEC\xCA\xD2\xCB\x31\xF0\xCD\xCA\xD3\x4B\xD0\xDC\xD3\xD3\x1A\xCD\xD5\xD4\xD5\x46\xC9\xDE\xBC\x42\x7B\x48\xDF\xCB\xD5\x51\xE0\xD3\xD6\xB8\x19\x34\xCE\xD6\xD5\x46\xDA\x06\xD8\xB4\x67\xD8\xDD\xD9\xD8\x59\xDF\xD1\xDC\xDA\x6F\xE3\xD6\xDE\xD4\x78", - "\xE2\xD9\xDF\xDC\x6E\xEC\xDE\xDF\xC5\x7F\xC3\xD1\xE0\xCF\x09\x5B\x0B\xD8\xE0\x88\xC2\xE9\xE0\xE1\x8B\xFF\x84\x46\xD0\x8C\xCA\xE2\xE5\xE4\x02\x5D\x07\xE3\xE4\x3F\xBB\x40\xE5\x40\x1F\x17\xE4\xE6\xCE\x83\xE0\xED\xE3\xD1\xA1\xE4\xE3\xEA\xD6\x7B\xF5\xD9\xE9\xE9\xA8\xFA\xDE\xE8\xDF\x70\xEA\xEF\xEA\xEC\xB0\xF7\xD3\xED\xE9\x20\x1E\xE2\xE8\xE6\xA6\xFC\xED\xE9\xED\xAB\xE3\xE1\x0A\xA1\x16\x5B\xED\xEF\xE7\xC7\xFB\xE8\xF3\xEF\xB4\xCD\xFC\xEA\xDC\xCE\xE7\xE0\xF7\xF3\x74\xD4\xFD\xDE\xF4\xD5\xD8\xFB\xB7\x08\xBA\xC9\xFE\xF4\xF3\xD6\xF1\xE1\x80\x09\xDD\xE0\xFA\xF6\xB8\x25\x25\xF3\xF7\xF9\xB6\xC0\xF7\xEC\xFB\xC1\xFE\xEB\xFA\xFC\xD9\xF4\xF7\xF6\xFD\xE2\xF0\xFF\xF9\x90\x26\x2A\xF5\xFF\xF2\xF3\x60\x83\xFF\x4A\x74\x81\xEF\x41\x85\x80\xE6\x78\x7D\xFB\x51\x7A\x81\xF8\x42\x87\x7E\x0F\x99\x7D\x03\xFB\x71\x83\x05\xA1\x7E\x82\x0F\x58\x21\xD7\x17\x8E\x80\x04\xA0\x38\x05\xFE\x70\x82\x07\x83\x86\x80\x12\x89\x85\x82\x1D\x85\x86\x08\xAA\x82\x82\x14\x94\x83\x84\x2B\x87\x84\x0C\xAD\x83\x86\x0C\x93\x86\x7D\x38\x8C\x82\x0B\xB9\x8C\x83\x17\xAC\x87", - "\x38\x29\x01\x84\x0D\x80\x0A\x04\x21\xB6\x83\x87\x3A\x95\x85\x0A\xB2\x8F\x87\x25\x87\x85\x89\x3E\x8C\x8A\x14\xCF\x8B\x04\x23\x8E\x8E\x84\x4F\x93\x88\x16\xDB\x81\x87\x2C\x9E\x8C\x8B\x43\x9A\x89\x17\xE0\x87\x89\x02\xAC\x06\x8A\x51\x9F\x8B\x18\xEB\x81\x8C\x35\xAD\x8C\x8C\x57\x8C\x8D\x19\xD0\x8C\x86\xFD\x75\x8F\x86\x49\x94\x8D\x1E\xE2\x8F\x8C\x39\xB1\x8D\x8F\x80\x93\x8C\x1F\x82\x9E\x8C\x42\xB0\x8E\x87\x1A\x26\x7A\xBC\x2E\x08\x8D\x3B\x88\x89\x21\x2F\x0D\x93\x1E\x85\x9F\x8E\x43\xBE\x89\x8D\x87\x8E\x92\x12\x85\x60\x06\x49\xBD\x82\x93\x00\x11\x06\x27\xA3\x7C\x22\x45\x94\x90\x93\x97\x80\x97\x20\x95\x9C\x94\x54\x81\x95\x95\xAA\x87\x95\x2C\x99\x93\x92\x5A\x9F\x95\x96\x2B\x93\x05\xF7\x34\x03\x94\x3C\xB7\x97\x97\x76\x98\x97\x2B\xAE\x96\x93\x61\x81\x2D\x06\xBD\x8F\x91\x30\xC0\x9E\x97\x65\x8E\x9D\x99\xD0\x8A\x99\x34\x9B\x93\x97\x54\x82\x9D\x98\xD8\x90\x97\x35\xDA\x9C\x98\x69\x9E\x9C\x9A\xDB\x85\x62\x0D\x5D\x77\x07\xEE\x78\x05\x7B\x39\x06\x52\x0E\x49\x90\x9D\xD2\x7B\x04\x9D\x00\x1C\x06\xA1\x3D\x00\x9E\x79\x7E\x06\x50\x3F\x06", - "\x50\x10\x70\x91\x09\x7A\xB2\x91\x9C\xD5\x86\x98\x40\x83\xAD\x9B\x76\x8F\x9F\x9B\x7A\x85\xA1\x42\x87\xA6\xA1\x69\x80\x02\x08\xFE\x96\x94\x43\x8B\xAE\xA1\x55\x84\x9C\x9B\x13\xB6\xA1\x40\xFE\x53\x09\x88\x96\x9A\xA1\x1A\xB4\x3C\x11\x1E\xA2\xA1\xD2\x45\x0C\xA4\xD9\x97\xA2\x4A\x9B\xA8\xA3\x8A\xBF\x98\xA4\x2F\xB9\xA1\x4C\xAE\xAC\x58\x23\x28\xA5\xA5\x08\xA1\xA4\x4C\x92\xA4\xA7\x8F\xB2\xA4\xA7\x39\xAF\x8B\x11\x37\xAB\xA4\x82\xBF\xA6\xA7\x3D\xA5\xA7\x51\xCA\xA9\xA9\x94\xAC\xA5\xA8\x3B\xA8\xAA\x40\x48\x0D\x7B\x24\x1D\x7A\x09\xDD\x6B\x0A\xA1\x4C\x04\xA9\x29\x4D\x08\x9E\x4E\x10\x9F\x13\x06\x50\x0B\xAE\xB4\x3E\x23\xC6\x72\x0A\xA1\x53\x06\xAD\xA8\x8C\xA9\xA8\x40\xAD\xA0\x5C\xDB\x54\x0B\xB6\x8B\xAE\xA9\x46\xAD\xA8\x4E\xF2\xAC\xAE\x8A\xB3\xAF\xAD\x7D\xBA\xA7\x5D\xFB\xAE\x7B\x2A\x06\x50\x24\xC6\x77\x0A\x5D\xFA\xA0\xAB\xC1\x8D\xB4\xB1\x4F\xB1\xB1\x5E\xFF\xA8\xAE\x85\x98\x0B\xB1\x94\xA4\xB2\x60\x90\xB3\xB3\xC0\xB3\xA1\xB3\x8F\xA0\xB5\x50\x59\x08\xB2\xCF\xB1\xAE\xAF\xA6\xB2\xA9\x6A\x80\xB8\xB5\xD6\x9B\xB0\xA1\x5A\x05\xB6\x6B\x9F", - "\xBB\xB5\xCA\x8E\xB2\xB2\x6E\xB6\xB4\x67\xB9\xBA\xB2\xDA\xB3\xB4\x59\x5B\x1D\x7A\x48\x26\x99\x39\x2E\x1D\x7E\x0B\x86\x44\x24\x71\xAA\xBD\xB4\x30\x30\x99\x0C\x86\x42\x0E\x6C\xDD\x36\x24\xE3\x64\x0E\x50\x65\x13\xBA\x6F\xAF\xB5\xB7\xDE\xA7\xB4\xBB\xBF\xAC\xB8\x78\xE3\xBB\xBB\xF2\x9F\xBE\xBC\xE2\xA8\xBC\x6B\xE4\xB7\xBC\x66\x66\x0A\xBB\xC9\x27\x0C\x7C\xE9\xBD\xBC\xFA\xB6\xBB\xBD\xEA\xBA\xB6\x68\x9D\xB1\xBC\xFC\xB5\xBE\xBF\xF7\xBA\xBD\x01\xA8\x2B\xB8\x71\x69\x0B\xBE\x00\xC3\x3A\x1A\x08\xC2\xC1\xFE\x8D\xC4\xBD\x01\xDE\xB9\x84\xD7\x3B\x0C\x06\xD2\xC3\x38\x6C\x16\xC1\x68\xDD\xBB\xC2\xEF\x6D\x0D\x7B\x6E\x1D\x7B\x1B\x5D\x70\x0E\x43\x71\x0A\xC3\xA0\x92\x0C\x3C\xF3\x06\x50\x3A\x28\xC2\x21\x75\x06\x52\x1D\x06\x57\x0E\x78\xB8\x0F\xC5\xBC\xBD\xC0\x84\x89\xCF\xC1\xFC\x97\xC5\xC7\xFF\xA0\xCB\x84\xB8\xBF\x41\x3C\x38\xC7\xB6\xFC\xBB\xC6\x90\xBC\xCF\xC7\x26\xFA\xC6\xC7\x4F\xC1\xCA\x74\x7A\x0D\x7B\x3D\x07\xCB\xB7\x48\xD9\xC4\x91\xD8\xCC\xCA\xE4\x7C\x0F\xCA\xFB\xBA\xC9\x92\xD0\xCB\xCB\x21\x7D\x08\xCC\x1C\xC5\xCD\x9A\xE3\xC2\xCB\x28", - "\xC3\xCC\xCD\x6F\xC2\xCE\x9C\xD9\xC6\x20\x3F\x28\xCE\xC1\x4E\xCA\xCC\x9E\xEE\xC3\x89\x3F\x37\xCA\xC9\x79\xD0\xCC\x93\xFC\xCB\xC9\x42\xC1\xD3\xCE\x5D\xCB\xCD\xE9\x00\x1F\xCE\x32\xC2\xD7\x38\x81\x0D\xD3\x69\x82\x12\xD3\x38\xF4\xC9\xD1\x00\x03\x11\xA5\x83\xD0\x94\x42\x1B\xD6\xD0\x84\xC7\xD3\xA5\xE1\xCF\x41\x42\x1F\xD2\xD4\x98\xDD\x3A\x21\x27\xDD\xC3\x43\x2C\xD2\xCF\x80\xDD\xC0\x22\x2F\xDF\xD1\x14\x89\x14\xD6\x88\xC4\xD5\x90\x0A\x18\xD7\x51\xCA\xD6\xD7\x7B\xD0\xD6\xA3\xB9\xDF\xD7\x54\xC3\xD8\xD8\xDD\x2B\x11\xF7\x2A\x25\xC1\xE3\x0D\x15\x7B\x8E\x06\x50\x4B\x4D\xD8\xD4\xE4\x50\x10\x9E\x91\x06\x52\x4B\x54\xDD\xC3\x49\x06\x54\x12\x86\x55\x11\xAF\xC6\xDD\xCC\x61\xC9\x38\x26\xDC\xC6\xDF\x72\x17\x13\xDC\x5D\xEE\xDD\xD8\xEF\xC1\xD9\x1E\x98\x1D\x7B\x4C\x1D\x7A\x13\xDD\x7B\x12\xA1\x1C\x1D\xDD\x02\x9D\x10\x9E\x9E\x06\x53\x27\x77\xC0\x14\x43\x72\x26\x78\xA2\x1D\xDE\xBC\xC4\xDB\xE1\xD1\x63\x12\xE1\xB1\xCA\xDC\xA7\xFC\xB4\x14\x88\xC7\xDC\xDC\x96\xD8\xE3\xC4\x8C\xE1\xE3\x3C\xA5\x16\xE2\xE5\xD5\xD5\xA8\xA3\xE2\xE2\x50\xE5\xE4\xB0", - "\xA6\x00\xE5\xC6\xF1\xDD\xE2\x85\xB4\x21\xDD\x22\xE7\xE4\xC9\xB1\xE4\xE6\x8E\xD7\xE4\xE5\x37\xF0\xDE\xCE\xDE\x78\x15\x3B\xE9\x12\xE5\x1B\xE8\xD9\xCE\x8D\xEA\xE2\x93\xF5\xE3\xA2\xAA\x00\xEA\xD1\xB6\xE1\xE4\xA6\xEB\xE3\xE7\x2D\xE2\xE9\xD3\xD2\xEB\x85\x55\x0A\xED\xDA\x50\xE3\xE9\xD4\xC5\xE8\xEA\xA2\xC8\x7C\x15\xDD\x6D\x15\xF7\x36\x20\xE7\x84\x2F\x16\x50\xB0\x17\xE9\xC1\x31\x10\x9E\x59\x06\x53\x16\x77\xD4\x16\xA1\x35\x16\x50\x5B\x2A\xEA\xE6\xA0\x97\x15\xF7\x38\x25\xEC\x83\x39\x15\x7B\xBA\x06\x53\x2E\x77\xE4\x3E\x5E\x30\x9D\x17\x86\x5E\x17\x9D\xBF\x16\x50\x60\x06\x51\x18\x84\xEE\xE9\xD0\xDC\xE3\xE6\xC9\xCB\xEC\xEA\x93\xF8\xE7\xD4\x98\xD2\x19\xEE\x43\x1D\x7B\xC4\x1D\x79\x31\x06\x56\x19\xC8\xCF\x47\x18\xF0\x88\x1A\xA1\x49\x17\xCE\x65\x06\x53\x19\x86\x4C\x18\x3C\xCD\x16\x50\x67\x26\xF4\xF2\x78\xE7\xE8\xEE\xBA\xFA\xF2\xE6\x8F\x1E\x50\xD0\x17\xF5\xEF\x99\xF9\xEB\xCD\xC3\xFF\xF2\xBB\xF6\xF1\xD7\xE0\xB1\x1B\xEE\x52\x1D\x7B\xD3\x1D\x78\x35\x06\x55\x1A\xE1\xFF\x46\x1A\xF0\x97\x1A\xA1\x58\x17\xCF\x6C\x06\x52\x1B\x86\x5B\x1A", - "\xF5\xDE\xE5\xF9\xA7\xE4\xFF\xFC\x5B\xE7\xFB\xF2\xDA\xEC\xFD\xD3\x9C\x1D\x7B\xDD\x1D\x7A\x37\x5D\x7F\x1A\x43\x60\x1B\xFC\xDD\x21\x1C\x3C\xE2\x16\x51\x71\x37\xCC\x1C\x86\x25\x0E\x86\x26\x0E\xF0\x47\x0E\x86\x28\x0E\xF8\x7D\x7E\xE6\x79\x7E\xE5\x74\x7C\xE8\x7A\x80\x0E\x8C\x80\x0F\x86\x7C\x0D\x83\x47\xE9\x09\x80\x14\x8D\x5A\xEA\x06\x28\xEB\x08\x81\x0B\x80\x81\xC8\x7A\x7E\x95\x78\x79\x21\x85\x81\xEB\x74\x42\xEC\x0D\x3D\xED\x0D\x3D\xEE\x0D\x3D\xEF\x06\x28\xF0\x0E\x81\xC3\x11\x0F\xF0\x42\x0F\x86\x23\x0F\x77\x64\x0F\x86\x25\x0F\x86\x26\x0F\x32\x85\x82\x13\x8F\x81\x19\x82\x81\x44\x80\x82\x29\x47\x0F\x3F\x87\x82\x42\x8B\x84\x11\x86\x84\x23\x89\x7C\x24\x8A\x84\x4D\x83\x84\x4E\x86\x34\xF8\x06\x28\xF9\x09\x84\x4F\x82\x82\xB9\x7A\x7C\x5B\x86\x82\x5F\x81\x84\x53\x8C\x5C\xFA\x0A\x85\x5D\x81\x85\x61\x85\x84\x54\x8B\x86\xCC\x5B\x0F\x66\x8C\x7B\x60\x87\x86\x50\x83\x87\x5C\x80\x87\x62\x80\x84\x6A\x8C\x84\x78\x85\x85\xFC\x5C\x0F\x6F\x8E\x85\x72\x85\x87\x80\x86\x87\x79\x83\x86\x86\x8B\x87\x6C\x87\x88\x52\x88\x88\xCB\x1D\x0F\x86\x2E", - "\x0F\x7F\x88\x86\x81\x81\x87\x84\x8C\x87\x83\x87\x89\xC8\x67\x67\x00\x0E\x17\x02\x1C\x89\x82\x82\x89\x95\x89\x88\x8C\x8A\x88\x69\x86\x89\xA0\x88\x89\x41\x21\x00\x9E\x80\x00\xEA\x11\x20\x04\x0B\x8A\xAD\x8F\x20\x07\x00\x8B\xF4\x1A\x00\xB4\x89\x10\x0D\x07\x8B\xA7\x83\x3A\x10\x0B\x8A\x04\x25\x3A\x15\x0A\x8B\x03\x18\x01\xC2\x82\x10\x1B\x0B\x8A\xAB\x8D\x5A\x1C\x05\x8C\x9C\x3C\x8C\x00\x02\x02\xCE\x85\x88\xA3\x83\x8D\x8B\x85\x8D\xA5\x82\x8A\xD6\x83\x89\x77\x89\x8D\xA1\x8A\x87\xDC\x88\x8A\xC8\x35\x02\xC8\x8C\x5F\x26\x03\x8E\xE0\x84\x89\xE7\x8B\x8D\xD7\x8E\x8D\xEB\x84\x8A\xDA\x82\x8D\x29\x47\x02\xE6\x8B\x8B\x74\x88\x8E\xF4\x8F\x89\xF5\x8A\x8E\x7A\x68\x02\xF3\x89\x8F\xF0\x8D\x8E\xD4\x80\x90\xDF\x87\x8F\xF6\x8E\x8F\xA6\x86\x90\xD8\x87\x1D\x29\x0D\x8F\xF8\x8D\x90\x05\x9E\x90\xFA\x8D\x8D\xEE\x86\x87\x2A\x0C\x90\x0F\x97\x91\x11\x9A\x50\x2B\x06\x91\x19\x94\x90\x1D\x9E\x50\x2C\x0C\x91\x2D\x0C\x91\xFF\x81\x14\x2E\x04\x92\x07\x90\x91\x25\x92\x91\x01\x9F\x8E\x29\x98\x91\x2B\x99\x8E\x31\x9E\x91\x33\x98\x69\x2F\x08\x92\x09\x9E\x92", - "\x39\x9A\x10\x30\x08\x93\xEC\x86\x34\x31\x0E\x93\x13\x92\x93\x2F\x9F\x91\x2A\x95\x94\x35\x97\x94\x3B\x9C\x70\x32\x02\x94\x2D\x9C\x92\x03\x93\x10\x33\x0E\x94\x51\x98\x3C\x34\x04\x95\x02\x99\x95\x3A\x9B\x2D\x35\x08\x95\x5B\x93\x94\x34\x98\x94\x62\x9B\x94\x61\x94\x96\x08\x9B\x1C\x36\x0E\x95\x50\x9A\x95\x6B\x9F\x95\x4F\x94\x94\x66\x9A\x94\x3F\x9D\x96\x74\x91\x20\x37\x0A\x96\x0A\x58\x03\x78\x95\x96\x73\x9A\x50\x39\x0B\x97\x67\x90\x96\x81\x9F\x96\x7C\x92\x98\x72\x92\x2E\x3A\x00\x98\x87\x94\x98\x83\x92\x1D\x3B\x0A\x98\x30\x93\x96\x7D\x95\x98\x8C\x9B\x98\x55\x91\x10\x3C\x00\x99\xAD\x5D\x03\x9A\x99\x94\x91\x91\x97\x9F\x93\x99\x8D\x9C\x96\x70\x92\x9A\x96\x97\x1D\x3E\x0D\x99\x4F\x4F\x03\xAA\x90\x9A\x46\x91\x9A\x86\x90\x9B\xC7\x10\x04\xAD\x96\x9A\xB2\x97\x99\xAF\x99\x9B\x9E\x9A\x9B\x92\x91\x9B\xBC\x9E\x9A\x4C\x41\x04\xB5\x93\x44\x42\x03\x9C\x95\x97\x9B\x3E\x43\x04\xC6\x98\x9B\xBB\x9D\x9C\xBD\x97\x9C\xBF\x96\x7E\x44\x0B\x9C\xA4\x94\x99\xB8\x95\x04\xD4\x9E\x96\xCC\x9F\x9C\xDB\x90\x9C\xDC\x9E\x43\x46\x09\x9D\x44\x37\x04\xE2", - "\x95\x9A\xBE\x9E\x9C\xDE\x99\x9E\xB6\x91\x9D\xE7\x9F\x9D\x46\x38\x04\xE5\x93\x3A\x49\x01\x9F\xA3\x9A\x9D\xD5\x95\x9F\x79\x4A\x04\xF4\x97\x9A\xF6\x9D\x9F\x75\x96\x9D\xF7\x98\x50\x4B\x0B\x9F\xC8\x9E\x9F\xE6\x90\x9D\x12\x8C\x04\x04\xAC\x9E\x08\xA3\x30\x4D\x0B\xA0\xE8\x9B\x9E\x11\xAD\x9E\xEA\x94\xA1\x2B\x4E\x04\x10\xAE\x9E\xFF\x9E\x50\x4F\x09\xA1\x15\xAD\xA0\x1F\xAD\x9D\x12\xAA\xA1\x01\x20\x05\x1E\xAB\x2D\x51\x07\xA2\x16\xAB\xA2\x20\xA3\xA2\x21\xA1\xA0\x05\xAB\xA1\xFC\x94\x1F\x52\x0A\xA2\xFE\x23\x05\x36\xA2\xA2\x2C\xAA\xA3\x2D\xAB\xA3\x30\xAC\xA0\x3C\xAD\x75\x54\x09\xA3\x3F\xA3\xA1\x3D\xA7\xA4\x41\xA5\xA4\x24\xA6\x10\x55\x04\xA4\x06\xA0\xA0\x4F\xA8\x9F\x07\xA9\xA4\x51\xA3\xA3\x53\xAA\xA4\x2F\xA5\xA5\x3F\x26\x05\x4E\xA2\xA3\x31\xA7\xA5\x5A\xA0\xA4\x58\xAE\xA2\xCB\x17\x05\x5D\xA0\xA6\x5E\xA2\xA6\x61\xA6\xA4\x54\xA9\xA6\x6C\xA3\xA6\x3E\xAB\xA6\x03\x38\x05\x1C\x99\x05\x67\xA0\xA5\x6E\xAB\xA4\x52\xA8\xA7\x68\xAD\xA7\x0F\x2A\x05\x77\xAB\xA7\x82\xA6\xA5\x7C\xA5\xA8\x83\xAF\x23\x5B\x01\xA8\x84\xA7\xA8\x6A\xA9\xA7\x59\xAE", - "\xA8\x64\xA1\xA7\x90\xA2\xA9\x7E\xA1\x24\x5C\x0C\x91\x5D\x0A\xA8\x5F\xA6\xA8\x8B\xAD\xA9\x9B\xAC\xA8\x6F\xA2\xA7\x8F\xA5\xA9\x9E\xAD\xA8\xA4\xA1\x10\x5E\x0A\xA9\xA6\xAC\xA9\x05\x4F\x05\xAA\xA2\x81\x60\x0F\xAA\x7A\xA5\xAA\xA1\xA3\xA9\x48\xA0\xA7\xB7\xA1\xA6\x61\x02\xAB\xA3\xAC\xAA\x54\x22\x06\xBC\xA6\x7E\x63\x01\xAC\x94\xAE\xAB\xB5\xA7\xAA\x54\x24\x06\xC4\xA9\xAB\xB6\xAD\xA6\x09\x15\x06\xCB\xA2\x1D\x66\x01\xAD\xB8\xAE\xAC\xC6\xAF\x44\x67\x04\xAD\xA2\xA1\xA9\xCC\xAA\x50\x68\x0A\xAD\xCD\xA5\xAD\xE2\xA1\x14\x69\x00\xAE\x09\x1A\x06\xE6\xA7\xAD\xBD\xA0\xAA\x03\x3B\x06\xE9\xAC\xAE\xEB\xA4\xAB\x4F\x4C\x06\xEF\xA2\xAF\xF1\xAF\xA9\xF6\xAC\xAD\xD6\xA3\x10\x6D\x05\xAF\xF8\xAF\xAF\xDE\x3E\x06\x1C\x9F\x06\xFE\xAB\xAA\xF0\xAA\xAF\xE3\xA1\xAE\xDB\xA5\xAC\x07\xBC\xB0\xF9\xAE\xB0\x18\x90\x07\x1C\x91\x07\x05\xB2\x2F\x72\x05\xB1\xB3\xA0\xB0\xC7\xAA\xAE\x08\xBB\xB0\xDD\xAE\x91\x73\x08\xB1\xF7\xA6\xB0\x0F\xBE\x2F\x74\x02\xB2\x1D\xBA\xB0\x2A\xB8\xAC\x1B\xBD\xB0\x1F\xB1\x24\x75\x08\xB2\x10\xB4\xB2\x00\xB6\x07\x32\xBF\xB2\x25\xBB\xAF", - "\x39\xB9\xB0\x2C\xB9\xB1\x34\xBF\xB3\x2D\xBB\xB3\xDA\x87\x07\x37\xBA\xB3\x1A\xB0\x1E\x78\x05\xB4\x3C\xBC\xB1\xC3\x19\x07\x1C\x9A\x07\x4A\xB3\x25\x7B\x01\xB5\x2B\xBC\xB4\x38\xB7\xB4\x23\xB1\xB4\x58\xBB\x2D\x7C\x04\xB5\x3D\xB9\xB5\x3E\xB2\x2F\x7D\x0E\xB5\x56\xB6\xB4\x40\xB1\xB6\x68\xB9\x81\x7E\x0C\x91\x7F\x04\xB6\x2E\xB6\xB6\x5A\xBF\xB3\x80\x0E\xB6\x42\xB5\xB5\x6F\xBB\xB4\x77\xBE\xB1\x84\x51\x08\x74\xBB\xB5\x33\xB1\xB7\xBB\x92\x08\x7D\xB7\xB6\x60\xB5\xB8\x29\xBF\xB5\xDB\x23\x08\x83\xB0\xB8\x69\xB7\xB8\x0F\x24\x08\x1C\x95\x08\x1C\x96\x08\x8B\xBD\xB8\x7F\xB6\xB9\x57\xB4\xB8\x8E\xB9\x8F\x87\x05\xB9\x86\xB7\xB9\x9F\xBE\x2F\x88\x0C\x91\x89\x0E\xB9\x9B\xB5\xB7\x88\xB2\x2E\x8A\x01\x8D\xE0\x1D\x08\xAC\xB9\x1C\x90\x0F\xBA\xCB\x13\x09\xCE\x86\x09\xB2\xB3\xB3\x99\x0E\x8B\x44\x3E\x09\xCE\x81\x0A\xCE\x84\x0A\xAA\xA5\x0A\xCE\x88\x0A\xCE\x8B\x0A\xB7\xB9\xB9\x8C\xB1\xBA\x5D\x7E\x0A\x1C\x9F\x0A\xA6\xB0\xBA\x2B\x40\x0B\xCF\xB8\xBC\x98\xB0\xB7\xD5\xB8\xB7\x08\x51\x0B\x1C\x92\x0B\xAA\xA3\x0B\xD3\xB6\xBD\xCA\xB8\xBD\x3F\x24\x0B\xDF", - "\xB2\xBE\x9A\xB0\xBD\xE8\xB4\xBD\xE1\xB3\x25\xB5\x0C\x91\xB6\x05\xBE\x7A\xB6\xBE\xC9\xB6\x7E\xB7\x05\xB0\xB8\x0B\xA0\xB9\x0C\x91\xBA\x00\xBF\x76\xB8\xBA\x65\xB1\x86\xBB\x05\xB0\xBC\x0B\xA0\xBD\x0C\x91\xBE\x0C\xBF\xA9\xBA\xBE\xA7\xB8\x91\xBF\x05\xB0\x04\x0F\x8B\x03\x11\x8B\xCF\x12\x15\x90\x1B\x2F\x83\x15\xC1\x06\x1F\x33\xA4\x22\x15\x85\x29\x10\x20\x45\x18\x12\xC6\x1D\x14\xCA\x10\xFC\x25\x18\x18\xC3\x10\x1A\xC0\x2B\x1C\xCA\x10\x1F\xC2\x1A\x10\xC3\xC1\x49\x1F\xC2\x22\xC1\xC3\x83\x12\x15\x21\xCB\x1D\x36\xC5\xC3\x49\x17\xC3\xDE\x19\xC3\x85\x1E\xC3\xA2\x10\xC4\x30\xC6\x14\x3C\xC2\x15\x23\xC6\xC1\x20\xCA\xC3\x44\xCA\xC4\x43\x15\xC4\x46\xC6\x14\x27\xC2\x10\x29\xC9\x31\x2B\xCE\xC1\x83\x1E\xC4\x4F\xCF\x13\x58\xC9\xC5\x3D\x1B\xC5\x5C\xC1\xC5\x01\x15\xC2\xA2\x1E\xC5\x59\xC0\xC6\x00\x03\xC5\xF7\x25\xC5\x06\x1D\xC2\xCF\x14\xC6\x4F\xC6\xC6\x62\xCF\x1C\x66\xC8\xC6\xF5\x2A\xC6\x03\x1C\xC6\xD6\x12\xC3\x38\xC4\xC3\x3F\xC9\x14\x34\x2D\xC7\x50\xCE\x30\x5D\x21\xC4\x49\x1D\xC1\x06\x16\xC6\x52\x1A\xC7\x3D\xCC\xC7\x84\xC6\x14\x7F\xCD", - "\xC8\x43\x16\xC6\xC9\x82\x15\x83\xC3\xC4\x43\x16\xC8\x8F\x17\xC5\x4C\xCA\xC5\x9B\xCE\x13\x6E\xC6\xC4\x9F\xC2\xC4\x33\xC1\xC8\x48\xC3\xC6\x9D\xCD\xC5\xA7\xCF\x0F\x73\xCF\x27\x76\xC2\x10\x78\xCB\x1D\xA1\xCB\xC3\xA9\xC1\xCB\xA4\xC6\x10\x71\xC6\x1D\xB4\xC1\xC9\x0A\x14\xC7\x04\x3D\xCA\x01\x1F\xCA\xDE\x1A\xC8\x5C\xCF\x13\xC2\xC3\xCC\x3D\x1F\xC8\x96\xCF\x13\x66\xCD\x30\x85\x15\xC9\xA3\xC7\xC9\x0A\x19\x3B\x85\x15\xCC\xC6\xC4\xCD\xC3\xC8\xCC\xCF\xCA\xCC\x0A\x1C\xCC\xA2\x1E\xCC\x7B\xC6\x14\x98\xC2\x10\xD2\xC6\xCA\x80\xCD\xC4\xB3\xC7\xCE\xE5\xCC\xC9\xE9\xCE\xC9\xE8\xC0\xC9\xDA\xC5\xCA\x6D\xCD\xCE\xC9\xCC\xCE\xEB\xCD\x13\xAB\xCB\xC1\x85\xCC\xC2\x83\x1A\x1F\xF5\xCF\x0F\xD6\xCF\xC5\x0A\x16\x38\x26\xC1\xD0\xAC\xC9\xCF\x09\x18\x4C\xF8\xC0\xCE\x0A\x18\xD0\xA2\x19\x8C\x93\x11\xCE\x01\x13\x4E\xD3\xC9\xCA\xC9\x83\xC9\x06\xD6\x10\x12\xDE\xC2\xA9\xC6\xC6\x02\xD2\x1A\x1C\xD5\xD0\x0A\xD7\xD0\x17\xC4\xD0\x03\xD5\x38\x20\xD0\xCD\x22\xD9\xC4\xFD\xC9\xCB\xEA\xCE\xCE\xF4\xCE\xD2\xA8\xCB\xD2\xF2\xC9\xCD\x3E\x16\xC6\x07\x3A\xD2\x30\xDF\x0F", - "\x2C\xDF\xD2\xF3\xC6\xCF\x0A\x15\x2D\x38\xDD\xD3\x3A\xD3\xD3\xDF\xCA\xCB\x09\x13\x33\x41\xD4\xD3\x31\xD9\xD3\x3B\xDE\xD3\x09\x1D\x39\x49\xD5\xD4\x2D\xD2\xD4\x4D\xDA\xCA\x0A\x13\x3C\x51\xDB\xC8\x4B\xC2\xD3\xFD\xC6\xD3\x9A\xCC\xD5\x4C\xDB\xD1\x0A\x17\xD3\xE4\xC1\xD6\x60\xD2\xD4\x66\xC1\x34\x2A\xC7\xD1\x03\x15\x44\x59\xD6\xCC\x4B\xD4\xD5\x62\xD9\x10\x6A\xD4\xC5\x6C\xD2\x10\x6E\xD5\xD6\x72\xD7\xD6\x4A\xD6\xD5\x74\xD7\xD2\x3F\x10\xD1\x44\x43\xD2\x09\x1A\x39\x7A\xDD\xD7\x55\xD9\xD8\x73\xD6\x10\x86\xD1\xCF\x7C\xD2\xD5\x3C\xDD\xD7\x70\xC4\xD8\x8C\xDF\xD5\x66\xD7\xD9\x68\xDB\xCB\x80\xDE\x13\x82\xD0\xCC\x89\xC9\xCA\xFF\xC9\xC5\x8A\xDF\xD8\x5A\xD6\xD4\x06\x14\xD6\x8E\xD9\xD3\x66\xC0\xD4\x87\xD0\xD9\x4E\xD6\x10\x48\xDD\xDA\xA5\xDF\xCE\x06\x10\xD5\xB2\xD0\xD7\x7E\xD6\x10\x58\xD7\xDB\x70\xDE\xD5\x6F\xDD\xDB\x63\xD6\xD9\x99\xDF\xD7\x09\xD8\xD2\x06\x19\xD7\xA9\xD3\xDC\x06\x15\xD7\x69\xC7\xD7\x01\x18\xDC\xB8\xCB\xD8\x03\x1C\xDC\x75\xCE\xDC\x83\xD5\xDC\x81\xDA\x10\xD0\xD5\xDD\x21\xD7\xDC\x9B\xDD\x13\x82\xDB\xDD\xDE\x19\x8C\x88", - "\xC6\xDD\x55\x45\x18\x0E\xD3\x18\x82\xD7\xDE\x0D\xDE\x30\xEB\xD2\xDC\x92\xD1\xDC\x25\xD4\x2D\x94\xD3\x10\xB1\xD2\xC7\x0A\x16\xDB\xF8\xD9\x10\xBB\xDB\xDF\xA7\xD5\xDF\x02\x18\xDA\xD6\x19\xD6\xDF\xDF\x0F\xE1\xD0\xE0\x01\x14\xDD\xBD\xC6\xDD\xE2\xD7\xC4\xCB\xD5\xE0\x07\xE8\xDD\x9C\xDA\x10\xF7\x43\xD1\x5D\xD4\xD2\x1E\xD8\xE1\x76\xDD\xDD\x03\x1C\xD0\xFE\xD3\x10\x1D\xDF\xE1\xC6\x80\xE1\x0B\xD0\xDF\xAE\xD3\xD4\xA4\xD8\xDB\xA3\xD8\xD9\x88\xD2\xDD\x01\xE6\xE2\xB3\xD1\xD9\x27\xE5\xD5\xAB\xD0\xE3\x2A\xE4\xD4\x31\xEF\xDA\xF6\xD6\xE3\x70\xDB\xE2\xCA\xD3\x10\xFA\xD1\xDD\x29\xED\xE3\x2E\xE1\x10\xFD\xD2\xE4\x2C\xE3\xE3\x45\xE6\x30\x3C\xE6\xCC\x3E\xE1\xDF\x09\x12\xE0\xB0\xC8\xE3\x37\xE7\xE1\xC4\xDB\xD6\x1C\xE8\xD7\x4D\xE3\xCC\x4F\xE7\xE2\x04\xE2\xE1\xE0\xDA\xDD\x5B\xEC\xC5\x5D\xE9\xE3\xB9\xD3\xDD\x24\xE9\x10\x0D\xEC\xC8\x42\xD5\xD1\xEA\xDA\x10\x8D\xD9\xC7\x14\xDA\x10\xE5\xD9\xE5\x01\x11\xE7\xDB\x11\xDA\x6F\xC0\xE7\x63\xE2\xDA\x54\xE4\xE4\x56\xE5\xD9\xBF\xDE\xE4\x7F\xE6\xCC\x93\xD3\xDF\x03\x18\xE7\xDE\x15\xE6\x55\xEA\xDA\x9A\xD0", - "\xE6\x06\xEA\xCF\x88\xE2\x10\x8A\xE2\xCA\x4A\xE3\xE4\x84\xE1\xE8\x89\xED\xE7\x4F\xCC\xE8\xC0\xD0\xCF\x03\xEC\xE7\x83\xEC\xE5\x85\xE3\xCC\xF7\xC8\xE5\xC6\xD7\xC7\x83\x1A\xE7\xA0\xC5\xEA\x64\xEE\xEA\x7E\xE8\xE9\xA4\xEA\xE9\x2F\xE3\xEA\xAF\xE2\xEB\x00\xD9\x10\xAC\xD9\xDC\x2D\xE8\xEB\x65\xCA\x10\xF7\xD8\xE4\x7B\xD9\xE4\x66\xE6\xC6\x41\xE3\xE5\xBE\xED\xE9\x4B\xE7\xE4\xC8\xE4\xEC\x8D\xEF\xE3\xB5\xEC\xDB\x99\xEE\xEC\x9F\xEF\xDF\xB6\xE1\xEB\xD4\xE6\xE8\x11\x19\xE6\xDE\xD7\xED\xCA\xE9\xEC\x46\xCF\xE5\xA8\xE9\xDD\x6A\xEC\xE9\xAD\xE0\xEE\x0E\xE8\xE6\x90\xE1\xE1\xD2\xE3\xEB\xD9\xEE\xEE\xC3\xE1\xEF\xBD\xEE\xE8\x51\xE6\xEE\x96\xE6\xE6\x34\xEF\xD3\xF6\xE2\xCB\xE8\xE9\x14\x66\xC1\xEC\xCD\xE2\xEF\x97\xE4\xEF\xB5\xDB\xEF\x5B\xDF\xEE\xB9\xEA\xDB\x06\xF6\xCE\xFD\xE5\xCB\x03\x12\xE5\x8B\xE0\xEB\xDF\xE4\xF0\x0F\xFB\xF0\x53\xD3\xEF\xD0\xE9\xE0\xDC\xED\xD6\x16\xF2\xE3\xF8\xEB\xE4\x0A\xE6\x25\xBE\xC7\xDD\xED\xE7\xEB\x08\xFF\xEB\x57\xEB\xE1\xA9\xEA\xE5\x16\xE9\xD3\xE9\xD5\x18\x82\xD5\xE9\x6C\xED\xD7\xAC\xE2\xF2\xD6\xD1\x44\x2D\xF2\xD4", - "\x35\xFC\xEF\x27\xF3\xF1\x02\xFF\xF1\x0D\xFC\xF0\x14\xF1\xED\xBC\xE3\xF0\x3F\xF8\xDB\x35\xEE\xED\xE7\xED\xF3\xE1\xE0\xEC\x1D\xF1\xD7\x18\xF0\xE5\x05\xFA\xF4\xF7\xEF\xEC\x52\xF3\x10\xCC\xE1\xF1\x41\xF7\xF1\x5E\xE2\xDF\x25\xF8\xED\x47\xF5\xED\x15\xF4\xF5\x3C\xF1\xF6\xDA\xE9\xF2\xCD\xD6\xE7\x24\xF5\xF4\x40\xFC\xF4\xE9\xE2\x10\x21\xF8\x26\x23\xFB\xE6\x07\xF6\xF6\xF0\xE7\xF5\x70\xFB\xF1\x2C\xFF\xF5\x3E\xF1\xF5\x5D\xF5\xEF\x64\xFE\xF0\x02\x1B\xEB\xC2\xE8\xF7\x01\x10\xF0\x5A\xF3\xF4\x9C\x3F\xF4\x67\xE2\x10\x59\xF5\xF5\x62\xF4\xF4\x85\xFF\xF7\xD6\xEC\xF7\x4D\xF8\xF6\xDC\xDB\xF2\xCF\xDC\xF8\xE2\xEA\xF2\xE4\xED\xED\x96\xFF\xF6\x1A\xFB\xEE\x62\xE1\xF8\xA6\xD3\xF6\x19\xEA\xEB\x08\xE0\x00\x88\xF2\xFA\x00\x07\xEC\xDE\x16\xC6\x8F\xFE\xEF\x5E\xF2\xE2\x01\x10\xF1\xAE\xF1\xF7\x4E\x23\xF7\xAB\xFA\xFB\x50\x2C\xFB\x93\xE3\xFA\xE3\xE3\xE1\xE5\xE9\xF3\x34\xF9\xCA\xD8\xC4\xF9\x03\x1A\x36\xCD\xC9\xCA\x82\xDA\x4B\xC6\xF7\xE2\x3B\xFE\xC8\x4B\xEC\xFC\xDD\xCE\xFC\x0A\x10\xFD\xA1\xF5\xF6\x7E\xFD\xF6\x76\xF9\xF0\xA8\xFC\xF6\x56\xFA\xFC\x83", - "\xFC\xF8\xF9\xE7\xD4\xE6\xFB\xE4\xB0\xF0\xF9\xD3\xE9\xF1\x00\x03\xFB\x75\xFD\xFD\x48\xF5\xFB\x93\xFE\xFD\x86\xFC\xE4\xA6\xFC\xF5\xC5\xEB\xED\xA4\xF5\xFC\xDB\xF1\xFF\xE4\x7A\xF8\x5E\x7C\xE2\x70\xFA\x62\x7C\xA0\x6A\x7C\x00\x06\xF7\x4C\x12\xE0\x7F\xFF\x42\x7B\xF7\x68\x79\x95\x7E\x00\xA7\x7A\xFA\x69\xFF\x35\x6A\xD3\x75\x80\x3A\x72\x20\x2B\x7E\xEE\x71\x00\xEF\x7C\xE7\x74\x7F\x01\x7F\xFE\x78\x7C\x0E\x8B\xFF\x18\x7F\x82\x6A\x7B\x74\x7E\x01\xB7\x7E\x05\x8B\x25\x0C\x82\x04\x86\x75\xFC\x7B\xF8\x61\x72\xFF\x7F\x1C\x53\x7F\x50\x16\x81\x3F\x09\xF9\x65\x80\xAE\x0F\x1C\x5E\x66\x99\x62\x6C\x93\x08\x07\xBE\x08\x21\x87\xCC\x4B\x73\x64\x1E\x81\xB8\x68\x08\xA9\x7F\xAD\x7E\xF1\x63\x7E\xFD\x66\x7A\x22\x83\x09\xAE\x7A\xDA\x7A\xFA\x18\x80\x8A\x73\x82\x82\x7F\xF0\x52\x83\x07\x8B\xE7\x4F\x6B\x16\x92\x7F\x91\x7E\xC8\x5F\x82\x28\x8D\x01\xA3\x80\x00\x8F\x82\x68\x83\xFE\x40\x7D\x06\x8A\xFF\x4E\x82\x1A\x8F\x70\xFD\x7D\x00\xB5\x7E\x37\x87\x00\xEE\x7C\x0B\x82\x13\x2E\x83\x0E\xB5\x82\x30\x83\x01\xEA\x76\x0C\x91\x74\x34\x86\x3A\x3C\x67\x9C\x64", - "\x04\xFF\x07\xCB\x62\x0D\x82\x6C\xD5\x6E\x72\x98\x7A\x10\x2C\x76\x19\x75\x73\xBF\x7E\xBA\x43\x85\x01\x83\x03\x86\x0A\x82\x11\x7E\x3B\x83\x20\x11\x18\x2B\x8E\xE9\x6D\x7F\xFD\x68\x82\x24\x84\x0E\x9E\x84\x32\x89\x09\x87\x0B\x18\x89\x83\x7B\x85\x03\x9B\x84\x36\x8D\x04\xA9\x85\x29\x97\x7D\xAB\x78\x14\xA7\x82\x51\x87\xF7\x65\x83\xEA\x7C\x1A\x2F\x86\xE4\x5C\x83\xCB\x71\x01\xA1\x75\x42\x0B\x85\xB9\x80\xEC\x7C\x82\x18\x85\x05\xA9\x7E\x41\x12\x85\x2A\x84\x14\xB4\x84\xF0\x75\xFE\x41\x7C\x41\x07\x85\xCB\x80\x02\x83\x08\xC2\x7B\x1D\x66\x60\x30\x9A\x83\xA3\x80\x15\xBD\x82\x81\x0D\xFA\x54\x83\x31\x90\x86\xAE\x87\x0D\xBB\x70\x67\x88\x0B\xD8\x85\x2D\x9A\x86\xC4\x80\xB6\x6B\x7D\x6B\x81\x02\xCA\x85\x38\x81\x83\xAF\x79\x16\xA0\x87\x6C\x82\x0E\x9A\x83\x2D\x93\x87\xE7\x85\x1E\x8B\x7C\x72\x88\x0F\xBA\x87\xFD\x70\x7F\xA7\x7A\x20\x2C\x87\xC4\x7B\x0B\xEC\x7D\x3A\x98\x7A\xF2\x84\x13\x92\x78\x5E\x88\x10\xCE\x87\xC4\x06\x86\x03\x0D\x55\x0E\x87\x81\x86\x10\xFE\x86\x3B\x9B\x86\xB0\x86\x19\x88\x87\x36\x8F\x0E\xF4\x84\x3C\x86\x83\x01\x89\x20", - "\x25\x87\x76\x88\x0E\x96\x8B\x2B\x98\x7F\x10\x8A\x20\xBD\x86\x61\x86\x0B\x9A\x8B\x4A\x9D\x7B\x2D\x89\x25\xA2\x89\x97\x8B\xF4\x6E\x7C\x48\x94\x6D\x03\x0E\x59\x32\x88\x00\x04\x11\xA1\x85\x47\x99\x87\xF0\x87\x0E\xA9\x13\x3C\x85\x0D\x8A\x0B\x46\x8D\x85\x1E\x89\x29\x87\x89\xBC\x71\x07\x9C\x78\x3F\x8A\x88\x4C\x81\x03\x82\x81\xB4\x7A\xF9\x6B\x7A\x2F\x86\x08\x3D\x8B\x16\xBF\x88\x93\x8A\x0F\x89\x82\xDE\x7B\x7C\x2E\x88\x2A\x98\x83\x90\x8E\x15\xCD\x8B\xDE\x76\x7D\xCF\x82\x2C\x85\x88\x6F\x8E\x07\x94\x84\x20\x92\x83\x45\x8F\x17\xB4\x89\x8A\x82\x0D\xCC\x8B\x1F\x8C\x77\x68\x8F\x28\x90\x7B\x8B\x80\x14\x98\x89\x59\x97\x8B\xA5\x7B\x27\xA3\x88\x82\x83\x0C\xDC\x89\x50\x9F\x8A\x56\x89\x2E\xB0\x82\xC0\x81\x08\xF9\x70\xC8\x68\x8C\x29\x80\x27\x82\x09\x5A\x1E\x0C\x94\x8F\x4E\x96\x8C\x35\x83\xC9\x42\x16\xB3\x81\x10\x65\x1A\x33\x9B\x8C\x8C\x8E\x20\x1E\x8C\x8D\x6D\xCF\x13\x0F\xC8\x64\x1F\x98\x85\x2B\x90\x85\x05\x82\x09\xAB\x7F\x6A\x8D\x81\xAD\x89\x35\xB0\x6A\xD3\x86\xDD\x37\x66\x63\x94\x75\x01\x0F\x35\xB8\x83\xD8\x8B\x13\xBA\x8F\x50\x9C", - "\x8D\x99\x8D\x9F\x45\x85\x47\x88\x18\x93\x87\x55\x99\x64\x9C\x88\x00\x06\x8F\xDB\x88\x00\xA0\x8E\x5B\x82\x6C\xA3\x89\x38\x88\x80\xA1\x84\x1B\xA8\x83\x60\x07\x84\xCF\x0F\xBD\x72\x8C\x63\x68\x1D\xD6\x0E\x60\x7D\x86\x46\x0B\x11\x88\x85\x0B\x8B\x13\xCE\x8C\x55\x9F\x7C\x03\x09\x3A\x87\x8E\x81\x06\x1E\x99\x7C\x7A\x82\x08\xEA\x8A\x31\x91\x89\xD5\x72\x11\xBB\x88\x75\x98\x7E\x8D\x89\xF6\x4A\x09\xFA\x88\x16\xFC\x8F\x7A\x93\x8A\xEE\x8C\x00\x8E\x8B\xCB\x8B\xFA\x18\x8F\x7F\x80\x00\x06\x93\x3B\x1D\x8F\xED\x02\xD8\x03\x8F\x67\x7D\x67\xE2\x89\x3B\x8A\x08\x07\x93\xF3\x1D\x82\x7F\x92\x8F\x02\x0F\x42\xBA\x8E\x13\x86\xF3\x56\x8E\x33\x97\x8F\xFD\x60\x2F\x87\x91\x04\x9B\x21\x86\x08\x89\x8E\x7D\x27\x95\x42\xBF\x81\x87\x0B\xEA\x4B\x71\x7C\x87\x81\x55\x89\x92\x0E\x87\x17\x9D\x21\xD5\x88\x23\x33\x91\x88\x8A\x94\x09\x8F\x1B\x91\x1A\x83\x0A\x8E\x9D\x91\x02\x0F\x47\x8F\x8F\x8D\x0B\x0E\xF3\x8A\x4F\x8A\x8A\xCC\x81\x20\x3A\x8B\x2B\x8B\x16\xDA\x88\x92\x95\x8B\x33\x8A\x2D\x85\x8C\x96\x87\x12\xD9\x89\x32\x85\x89\x54\x95\x2B\xB7\x88\x0B\x89\x10", - "\x4B\x91\x27\x9D\x8B\x4B\x89\x23\x82\x8C\x23\x9E\x24\xE1\x90\x4A\x88\x8B\x56\x94\x23\x8F\x92\x98\x87\x12\xD4\x85\x89\x83\x08\x5E\x93\x21\xB4\x8B\x2E\x84\x01\xE3\x92\x94\x9C\x8B\x49\x90\x00\x2E\x92\xD7\x79\x26\xC8\x88\x98\x86\x8C\x7E\x88\x3C\xA4\x8B\x38\x91\x15\xCC\x93\xFD\x62\x94\x92\x89\x4A\xAC\x85\xBD\x88\x25\xF4\x93\x38\x9B\x89\x7D\x94\x51\x91\x86\x36\x9D\x15\x9B\x81\x16\x80\x00\x84\x93\x2C\xAA\x92\x33\x96\x29\xE4\x88\x85\x85\x93\x80\x97\x4F\x90\x93\x78\x8F\x14\x8B\x96\xA1\x98\x93\xA3\x90\x20\x89\x94\x4C\x94\x26\xD7\x91\x57\x8A\x95\x5C\x90\x2B\xAD\x95\x4D\x99\x27\xB0\x96\x54\x80\x00\x0F\x8D\x3F\x85\x93\x3B\x9D\x28\x8C\x8A\xE4\x78\x90\x4A\x93\x56\xBE\x93\x3C\x9B\x25\xB7\x97\xA7\x8E\x95\x5B\x89\x4B\x9F\x89\x5D\x96\x2A\xDF\x90\xB1\x89\x88\xCD\x92\x4E\xAC\x8B\x5F\x9F\x26\xA6\x84\xAF\x93\x94\xBE\x92\x4C\xA8\x8A\x9D\x88\x26\xC2\x96\xA4\x87\x8C\xC9\x89\x32\xB1\x94\x38\x9E\x2D\xA7\x97\x49\x80\x91\x39\x6A\x44\x80\x97\xB4\x81\x2D\x85\x95\xE7\x67\x8F\x02\x97\x2C\x87\x91\x48\x96\x2E\xD8\x97\x9C\x99\x96\x7F\x8B\x48\xB9", - "\x8E\xD7\x79\x29\xCD\x90\xB2\x9E\x8B\xE8\x92\xA8\x6A\x97\x6A\x9A\x28\xC1\x84\xA5\x89\x96\x8E\x96\x2E\xBA\x96\xB8\x84\x30\xBC\x89\xB9\x87\x7F\x8B\x8B\x61\x83\x91\xBC\x8F\x30\x8F\x8D\xB8\x97\x87\xD7\x90\x61\xB8\x97\x80\x9D\xD7\x03\x9B\x83\x88\x80\x96\x18\x47\x89\x8E\x19\x9B\x13\xA1\x9B\x4E\x94\x91\x72\x7E\xBA\x7C\x90\xB4\x86\x32\xAC\x9B\xEA\x68\x99\xBB\x7E\xBA\x42\x93\x03\x90\x33\x91\x86\xDA\x64\x99\x68\x8D\x66\xAC\x8C\xB5\x7B\x32\xB4\x99\x8E\x8D\x91\xB8\x88\x00\x3A\x98\xD8\x87\x33\xAF\x98\x62\x9D\x99\xEB\x93\x68\xBB\x8C\xB5\x73\x33\xCC\x8E\xFB\x6A\x9A\xBF\x8D\x68\xA2\x98\x20\x91\x10\x48\x99\xC3\x90\x9A\xD5\x8D\x2A\x8D\x9A\xEF\x02\xD8\x2D\x9A\x20\x89\x65\xCB\x8E\xCC\x61\x9B\x24\x8A\x10\x1F\x66\x60\x76\x95\x6F\x8B\x20\x27\x26\x46\x89\x10\x6B\x9B\x78\x9E\x82\x85\x0B\x6C\xB0\x6A\xB9\x96\xCC\x02\x6D\x3A\x2C\x9B\x06\x0B\x9D\x38\x9B\x81\x0D\x3F\x7B\x9A\x40\x1D\x9B\x6F\x9E\x20\x1A\x20\x09\x99\x10\x6F\x26\xDF\x81\x08\x86\x99\x70\x83\x09\xC7\x1A\x38\xA3\x71\xDC\x98\x8F\x06\x0C\x97\x07\x9D\x4D\x4F\xE6\x09\x08\xF7\x13\x9C", - "\x7B\x96\xBA\x49\x25\xC6\x91\x10\x69\x1F\xE4\x99\x95\xDE\x8A\x21\x34\x96\xC1\x66\xFD\x04\x9E\x41\x05\x9D\xA1\x99\x21\x05\x1E\xCE\x9F\x8C\x15\x9E\x41\x1C\x96\xA9\x9F\x75\xAE\x9D\x81\x07\x46\x13\x9D\xED\x8C\x9D\xBC\x63\xE4\x79\x9C\xEB\x62\x14\x82\x6D\xEF\x8C\x91\x93\x9B\x74\xBC\x49\xD9\x92\x10\x65\x27\xE4\x86\x9E\xAC\x98\x79\xA6\x9D\x81\x0A\x3C\xD6\x0E\x18\x1C\x61\x3C\x81\x7A\x81\x08\xF2\x65\x36\x8A\x09\xD8\x94\x9E\x09\x0C\x87\x57\x9E\x3A\x75\x3D\x89\x09\xD8\x9F\x9E\xD6\x9D\x11\xA2\x9F\x84\x0A\xC8\x5A\x9D\xF7\x86\x08\x61\x9E\x7C\x89\x09\x4B\x88\x3E\x8A\x08\xFB\x83\x08\x61\x9F\x7D\x82\x09\xB0\x96\xC6\x6A\x9F\x21\x67\x9F\xF0\x9C\x7B\x99\x9F\xF0\x99\x10\x3A\x82\x0E\x9E\x81\x3E\x82\xB0\x61\x15\x84\x0A\x21\xA4\x92\x00\xBB\x8F\x0A\x0C\x44\xAD\x8E\x00\x07\x40\x84\xA1\x02\xAA\x08\x0D\xA4\x55\x0F\xA0\x42\x1A\x10\x03\xA2\x04\xA9\x08\x06\xA5\x82\x88\xA0\x0C\xA0\x41\x9A\xA2\x03\xBC\xA0\x14\xA1\x21\x16\xA1\xF9\x80\x42\x86\x09\x04\xA4\xA1\x26\x95\x21\x1D\xA0\x11\xAB\x41\xA9\xA1\x42\x10\x9D\x01\x0F\x84\x99\x91\x09\xA2\x3B\xC5", - "\x84\x72\x86\x08\xF6\x9B\x1A\xBA\x9E\x1C\xAC\x3F\xF5\x93\x0D\xB1\x60\x3D\xA3\x20\x36\x8C\x04\x94\xC2\x34\xA3\x40\x0B\xA0\x43\xA4\x44\x89\xA3\x22\xA5\x42\xC2\xA2\x11\xA2\x08\x4B\xA0\xD4\x41\x08\x25\xAF\x44\x81\x08\x0C\xA0\x00\x51\xA5\x86\xB6\x65\x2A\xAD\x2C\x0A\x0B\x02\xB7\xA2\x60\xA0\x04\xA7\x92\x81\x0C\xCD\x03\x09\x19\xAA\x89\x2C\xA7\x83\xAE\xA0\x59\x99\x46\x97\xA3\x1A\xA7\xA2\xA2\x9E\x83\xAE\xA2\x5A\x11\x47\xED\xA0\x0A\xB4\xA3\x72\x8E\x8E\xB3\xA1\x26\xA8\x46\x86\x0B\x08\xBB\xA3\x6F\xA5\x8F\x83\x09\x3F\xA1\x10\x05\xA1\x1D\xBE\xA3\x2D\xA0\x8F\xAC\xA2\x44\xAA\x46\x8A\xA5\x4E\x87\xA4\x83\xA1\x91\x93\x8C\x15\xA9\x47\x8C\xA7\x1C\xB3\xA4\x2F\xA0\x78\xAA\x87\x84\x0C\xCB\x6E\x91\xFD\x81\xA2\x52\x62\xDF\x49\x09\x4F\xAE\x3D\x8F\x76\x0F\xA2\x08\xA4\xA5\x7D\xA6\x80\x4F\xA8\x3F\xF3\x9D\x0C\x9A\xA1\xA3\xA5\x95\x81\x09\xB0\x9A\xE0\x2C\xA7\xFE\x85\xA5\x09\x0B\x30\x84\xA4\x00\x06\x48\xB9\xA6\x1C\xB7\xA3\x98\xA6\x20\x0B\xA0\x5D\xA2\x49\xD3\xA3\x84\x9F\xA5\x80\xA6\x91\x96\x96\x4B\xA0\x4C\xC6\xA6\x2F\xBA\xA3\x85\xA4\x8B\x84\xA7", - "\x46\xA1\x4C\xC3\x44\x32\xB1\xA6\x7C\xA5\x60\x82\x09\x5D\xAD\x4B\xDA\xA2\x35\xB0\xA6\xBC\xA4\x8B\x97\xA3\x69\xA7\x49\xCE\xA6\x37\xB0\x8F\xD7\xA1\x9C\x99\xA6\xA1\x99\x4E\xDD\xA4\x1C\xA9\x08\x2F\x94\x9B\x9C\xA3\x78\xA5\x4C\xC4\xA0\x3C\xAD\xA7\xF3\xA0\x9F\xAB\xA6\x7A\xA4\x4D\xE6\xA5\x7A\x9A\xA7\x81\xA5\x33\x80\xA8\x65\xA6\x45\x8A\x08\x3F\xA5\xA7\xF6\xA7\x9C\x82\xA8\x70\xAE\x4E\x82\x0B\x15\xA8\x9D\x01\x0A\x9E\xAB\xA6\x88\xA0\x00\x12\xA9\x40\xA0\x00\x0B\xA4\xA2\x96\xA8\x82\xA0\x00\x1A\xA9\x3D\xA4\x91\x1E\xAD\x9F\x89\xA9\xE5\x73\x50\xD5\xA6\x40\x01\xA9\x08\xA8\xA4\xA5\xA8\x7F\xA7\x52\xAB\xAB\x48\xAE\xA8\x0A\x08\xA5\x8D\xA7\x97\xA5\x50\x89\x0A\x4C\xA9\xA6\x26\xAD\xA6\x97\xA8\x05\xAC\x45\xA4\x92\x4F\xBD\xA9\xE2\xA1\xA8\xAB\xA7\x2B\xA1\xE2\x0E\x9E\x30\xBA\x70\x46\xA8\xC4\x48\xAB\x80\x05\x54\xCC\xAB\x52\xBD\xA2\x26\x69\x93\x91\xAA\x85\xAA\x4E\x97\xA9\x43\xA1\x08\x0B\xA7\xAA\x95\xAA\x8E\xAA\x55\xDD\xA8\x17\xBE\xAA\x43\xAF\xA3\x94\xA5\x94\xA3\x56\x8B\x9C\x17\xAC\x9C\x1C\xAB\x81\xA8\xAB\x9C\xA0\x00\x6B\xA8\x4B\xA1\x08\x6E", - "\xAC\xA6\xAD\xAB\xB3\xA4\x57\xEB\xA5\x5C\xA4\x91\x57\xA7\xAE\xA5\xAA\x81\x0A\x57\xD2\xA8\x33\xB8\xA9\x6F\xAD\xA2\xA2\xAA\x5C\x4E\x52\xA4\x93\x46\xAC\xAB\x87\xA9\xB0\x89\xAC\xB9\xAB\x58\x86\xAF\x60\xBF\xAB\xD8\xA7\xA2\x97\xA3\xC6\xAB\x57\x91\xAB\x63\xAF\xA4\x09\x0E\x6B\x81\x08\xCD\xA0\x00\x0A\x74\x65\xB0\x9B\x90\xAB\xAB\xAC\xAB\x71\x61\x49\xA2\xA8\x89\x9E\xAC\x97\xAC\x3D\xB9\x6F\xC2\xAE\x45\xD1\x64\x6B\xA4\xAC\x85\x6F\xB5\x93\x7B\xD0\xAA\x55\xA4\xAF\x36\xA9\xAD\x77\x72\xB6\x80\x72\xDD\xA2\xCE\x3C\xAD\x6E\xAC\xA8\x5C\xA0\xF6\x5F\xAC\x83\x06\x5B\x96\xAE\x69\xAE\xAD\xC0\xAB\x9D\xA8\xAD\xE3\xA0\x5A\xA5\xAC\x59\xB1\xAD\xC9\xAF\xA2\x82\xAE\xDC\xA0\x00\x45\xAE\x60\xAC\xAE\x82\x74\xB6\x81\xAE\xDF\xA5\x5D\xDC\xAF\x72\xAF\xAE\x54\xAB\xBA\x98\xAE\xCC\xA4\x5C\xDC\xAF\x15\xBF\xAE\x33\xA8\xAF\xAB\xAD\xE8\xAC\x51\xD7\xA2\x75\xA3\xAE\xE4\xAB\xD3\x6C\xAE\xB6\xA7\x45\xE2\xAC\x78\xB1\xAF\xBD\xAB\xBE\x81\xAD\x2B\xA9\xF5\x2B\x9F\x40\x17\x9C\x06\x08\xC0\x83\x08\xD4\x86\x10\x1E\x9D\x80\xAA\x08\x04\xB3\x20\x06\xB0\xBE\x97\x11\x12\x76", - "\x41\x18\x79\x0C\x9C\xBD\x74\x9C\x85\x0B\x39\x8A\xB2\x42\x0B\xB0\x02\x0E\x6A\xB8\x98\x81\x0D\x49\x09\x09\x87\xA6\x08\x5B\x9D\x94\x06\x08\x11\xBE\x23\x88\xB3\x85\xA6\xB1\x09\x08\xC3\x81\x08\xED\x76\x61\x89\x08\x8B\xA2\x08\x2A\xB1\x94\x0A\x08\xC9\x96\x10\x1E\x72\x40\x16\xB1\x01\x09\xC1\xB0\xB1\x12\x79\x10\x3A\xB1\xE7\x8A\x08\x19\x6A\xBE\x9A\xAF\x75\xA1\x64\xF6\x86\x7E\xB2\xAB\x45\xB1\x20\x2F\xAE\xEA\xA9\x64\x9D\xAC\x77\xAB\xA0\x4D\xB6\xBE\xA9\xAF\xD6\xA9\x10\x4D\xB3\x92\xA3\xAF\xAA\xAD\xCA\xA2\x75\x21\xB7\x51\xD1\xB0\x77\xB6\xB2\x5F\xB3\xCB\x8E\xAF\x29\xBA\x65\xCD\xAF\x6D\xB8\xB2\x11\x68\xB9\x9C\xB2\x8E\xAD\x64\xE8\xAC\x60\xA8\xB2\xEB\xAB\xCD\xAC\xAA\x30\xB7\x64\xA4\x90\x9D\xB2\xB3\x81\xAE\xCB\xB5\xB2\x20\xB2\x66\xE7\xB3\x7D\xA2\x08\x4D\xB1\xD0\xBD\xB2\xE3\xAF\x67\xE9\xB2\x99\xA4\xB4\x64\xB0\xA3\x6A\xB3\x31\xBF\x66\xF6\xB3\xA0\xB7\xAE\x85\xB0\x00\x3A\xB2\x3C\xB0\x67\x89\x0B\x95\xB1\xB4\x82\xB0\xBA\x94\xB4\xF5\xA5\x66\xB3\xAC\xA3\xB1\xAC\xED\xAC\xCF\x96\xB4\xF3\xA2\x6A\xD9\xAF\xA7\xA2\xAD\xFB\xAD\xD4\xBB\xAD\x3D", - "\xBE\x57\x83\x0B\x9D\xA7\xB5\x5A\xAF\x8A\xAD\xB2\x52\xBD\x69\xAB\xB7\xA6\xB5\xAC\x92\xB3\xD1\xBE\xB3\x44\xB8\x5F\x81\x09\xF3\x9E\xB5\x0A\x0E\x6D\x8C\x9E\x85\x07\x37\x86\x09\xB1\xA3\x08\xC7\xB2\x20\x3A\x9B\xBC\x9A\x10\x4B\xB7\x40\x09\x9C\xCF\xB2\x21\x10\xB6\x81\x02\x4F\x52\x9D\x40\x10\x9E\xD6\xB1\x20\x14\x07\xE5\x89\x8C\x3C\x62\xFC\x9C\x81\x3C\x65\x1A\x1C\xB7\x1D\xA8\xC2\x59\xB4\x2B\x54\x0F\xC9\x43\x20\x81\x0A\x1E\x66\x0D\x63\xB5\xB6\xAB\xA0\xEB\xB2\x21\x17\x06\x77\xB6\x6D\x9A\x92\xB9\xA0\x00\xD8\x04\xDE\x83\x09\x64\x40\xF1\x77\xB5\x36\x1A\xB7\xAE\xA4\xBF\x77\xB6\x85\x0A\x0D\x00\xBB\x2C\xB7\x6A\x03\xB9\x21\x1B\x06\x83\xB2\x57\x80\x9D\xC2\xA1\x08\xDC\x04\xE1\x9A\x90\xE4\x29\x6D\x9F\x65\x50\x1B\xA5\xC1\x2D\xE2\x8A\x09\x6E\x0C\x70\x82\x6E\x61\x3A\xB8\x09\x0E\x1B\x0C\xB9\x6F\xB0\x00\x58\x29\xB6\xB6\x68\xC9\x0E\x07\x9A\x2B\x93\xB4\x1F\x3C\x63\xED\x8F\xB8\x00\x07\x1B\x0C\xB9\x5D\xA0\x61\xB0\xB8\x38\x0C\xB8\x61\x9B\xDA\x89\xB9\x70\x08\x73\xD2\xB4\xCC\xA2\x08\xE2\x04\xE1\xA4\x90\x67\xBF\x70\xE3\x07\xC8\xAA\x08\xF4\x24", - "\xE5\x89\x10\x85\x09\x4F\x4A\xBA\x2C\x4A\x08\xFD\x27\xE7\x80\x00\x72\x0C\x70\xBA\x81\x47\x32\xBA\xE5\x02\xE8\x8A\x08\x9B\x22\x75\xE6\x06\xD6\xA9\x08\x54\x2A\xEA\xA7\x07\xAF\xB6\x10\x63\x28\xC8\xA6\x08\xE8\x05\xE3\x8A\x09\xBA\x22\x75\xE9\x07\xCC\xAA\x08\xA4\x2A\xEA\xAA\x06\x86\xBB\x40\xEF\x2E\xD3\xA1\x12\x24\x96\xD4\x12\xBB\x75\x04\x76\x83\x0B\xAA\x32\xBA\xEC\x05\xEF\x82\x08\x57\x32\x75\xED\x04\xC3\xB0\x78\x19\x32\xEA\xAE\x07\xC3\xBA\x10\x25\x32\xD4\xAF\x07\x0C\xB8\x74\x81\x09\x13\x32\x75\xF0\x04\xC3\xA3\x88\x29\x3F\xEE\x83\x13\x33\xA1\x10\x05\x3A\xE6\xBF\x11\x43\xA4\xC5\x12\xBB\x78\x0C\x70\xC3\xA1\x8C\x32\xBA\xF2\x04\xE1\x97\xA3\x33\x32\x75\xF3\x06\xEA\xAA\x08\xAC\xBF\xE7\xB4\x07\xD7\xB9\x10\x1E\x36\xD4\xB5\x07\xB4\xBE\x20\x36\xBD\x9F\xB6\x0F\x39\xBF\x40\x0A\x36\x52\xBF\x1E\x3E\xBC\x81\x00\x7C\xBF\xB8\x3E\x05\xBD\x0A\x0E\xDE\x12\xBB\x7C\x08\x7C\x89\x0A\xBE\x32\xBA\xFA\x04\xE1\x88\x7D\x7F\x32\x75\xFB\x04\xE3\xA9\x08\x62\x3A\xEA\x9D\x0E\xC4\x73\x70\x52\xB8\x3F\x17\xBC\x0A\x0F\xE3\x1F\xBC\x2A\x10\xF1\x49\x3A\xD4", - "\xBD\x07\x91\xBA\x21\x20\x3A\xA9\xBE\x0F\x0C\xBA\x9B\x96\x3B\xDA\xBC\xE1\xBC\x65\xC1\x32\x75\x80\x02\x1E\x69\x46\x8A\x61\xF0\x23\xBF\xEE\x03\x7F\xF5\xBD\x00\x17\xBF\xA6\xA3\x20\x06\x3C\xA9\xB2\x00\x00\xC0\x27\xAA\x08\x03\xC7\xE7\x83\x00\x03\xC6\x10\x40\x07\x82\x9A\x81\xDD\x0F\xDE\xA8\xB9\x6D\x11\x14\x3E\x8E\x04\xD0\x27\x41\x0C\x6E\x8B\x0F\x0A\xC6\x28\x3C\x62\x05\xC4\xB7\x02\x08\x02\xE0\x0F\xA0\x0A\xC8\x13\xC3\x70\x01\x0A\xD8\x9F\x7E\x81\x11\xA0\x04\x72\xA6\xC3\x71\x11\x90\xA8\xA0\x94\xBF\x11\xA0\x0A\x03\xC9\x46\x0F\x84\x8E\xC6\x1C\x87\x6E\xC0\xE9\x07\x71\xF0\x27\xF6\x8B\xC1\xF5\xA3\x07\xC5\x19\x12\xC4\x1F\x41\x08\x89\x82\xC2\x53\x14\xE4\xAC\x75\x7B\xBC\x44\x7E\x9D\x11\xD4\xB2\xAA\xA7\x41\x39\xA1\x10\xC0\x82\xB3\xC2\x18\xBA\xC0\xC3\x0A\x07\xA1\x9A\x2D\xCF\x84\xE8\x7C\x2E\xA2\x8D\x55\xC0\xD5\x8A\x8E\xA3\x8A\x10\x22\xC1\x72\x01\x0A\x4D\xA8\x00\x1F\xC0\x1B\xAD\x89\x64\xC1\x2C\xA0\xC2\x99\xA9\x0C\xDD\x0F\x21\xA6\x83\xB2\xC0\x95\x01\x0A\xB0\x7A\xF6\x61\xC2\x88\x79\x8C\x3B\xA6\x19\xDB\xC0\x0A\x0A\xC0\xAD\xC3\x00\x1C", - "\x79\x94\x9C\x38\xAB\xC3\xD6\xB6\xC7\x86\xC5\x07\x13\x10\xFD\xC2\x1D\xD1\xC0\x27\xB6\x78\x0E\xB9\x18\xC9\x10\x12\xBF\x22\xD3\xA9\x82\x68\x12\xD6\x63\xBE\x31\x24\x5A\xAA\x26\xCF\xB0\x76\xC5\xC2\x83\xC5\x07\x1E\x58\xF0\xC3\x44\x2B\xA0\x99\xC3\x04\xCA\x08\xAB\x98\x84\xF4\x0F\x02\xA9\x91\x67\xC2\x21\x1B\xB1\x83\xBE\x62\xDD\x1F\x15\xBF\xC3\x27\xC3\xC6\xB2\xA4\x2A\x18\xF8\x66\x63\x15\xA8\xC4\xD2\x9F\xD7\xA7\xB7\x00\x1A\xE0\x3E\xC7\x23\xCA\xC5\x09\x0C\xE8\x97\xB6\xA4\xB1\x86\xAF\x93\xA1\x66\x08\xB8\xC7\x38\x01\x0B\xA6\xBA\x82\x8F\x11\x1A\xCF\xC6\x3F\xA3\x48\x01\x0B\xA8\xB5\x8D\xC1\x10\x67\xB8\xC6\x01\xBF\x41\x01\x0B\xAB\xBD\x8D\x82\x0B\x49\x2F\xC3\x9E\xB4\x12\xFD\x85\x80\x09\x39\xB1\xC5\x42\x03\x2A\x9C\xC3\x48\x10\x79\x42\xCF\x89\x83\x09\xD8\xB1\xC2\x03\x0C\xAB\x31\xC7\x80\x05\x88\xC3\xA1\x3D\xC8\x28\x03\x8D\x1D\xC0\xC5\x84\x0F\x55\x7B\xC4\x95\x03\x88\xF4\xC0\x19\xC6\x09\xB0\x2F\x85\x83\x0A\x5A\x26\xC8\x96\xC1\x1A\xFC\xC0\x85\x0C\x56\x0D\xCB\x90\x19\x7A\x3C\x66\x12\xC0\xC7\xE8\x9A\x58\x16\xCB\x8F\x0A\xC4\x19\xCF\x18", - "\xEE\xC6\x83\x09\x71\xF8\xC6\x40\x0A\x2E\xE5\xC1\x20\x03\x9D\xF4\x01\x80\xDC\x85\x17\xC6\x08\xD0\x28\x1D\xFC\x1C\x05\x78\x35\xE6\xB5\x75\x3B\x20\xA3\x1A\xC1\x69\xC3\x7F\xC1\x10\x57\x2E\xF1\x19\x2E\x32\xCB\x48\x2F\x90\x8A\xAC\x93\xD4\x12\x7C\x21\xCA\x3F\x14\xA2\x87\x97\x5C\xC9\x10\x07\x33\x2D\xA3\x1D\x69\xC3\x29\xD2\xC6\x85\x09\x78\xBC\xA1\xE9\x11\xAB\x32\x7B\x24\xCE\x28\x45\x76\x5D\xC5\xC8\x13\x2A\x74\x35\xC9\xDB\xA3\x30\x83\xC2\xDE\x49\x46\xA2\x7B\xC9\x0A\xCB\x20\x0E\xBC\x9C\xC3\x10\x14\xBD\x4A\xC0\x00\x12\xB3\x14\xF6\xB5\x7F\xA6\x8A\x83\x0A\xE8\xAC\xCB\x43\x17\xE5\xB2\xCA\x23\xB6\x10\x68\xCA\x56\xC2\x08\x2E\x36\x78\x27\xBD\xB7\xC2\x8A\xD3\x9E\xAE\xBB\xAC\x2F\xCE\xA1\x19\x7B\x4E\x9C\x94\x93\x29\xD6\x7D\xCA\x69\xC8\xA1\x3E\xAE\x81\x0A\x88\xDE\xCB\x13\x2A\xC4\x65\x2D\x2E\xC2\x09\x1A\x3E\x91\xD4\x12\xD5\x81\x9B\x8A\xC5\x32\xD1\xCD\x80\x06\x65\x1D\xCD\x77\x04\xB1\x02\x0A\x91\x4A\xC5\x73\xC2\x8E\x8A\x0A\x9F\x26\xCD\xE0\x0A\x18\xE0\xCC\x55\xBA\x8D\x8A\x0A\xA6\x30\xCD\xC9\x0A\xE7\xA3\xC3\x1E\xBA\x10\x7B\x26\x66\xC1", - "\x08\x84\xBE\x24\xFF\x10\x6A\xC9\x3F\xBC\xCD\x42\x14\xB1\x41\x11\x28\x05\xBF\xE2\xCF\x20\x64\xC4\x73\xC3\xB0\x0A\x0D\xDA\xAD\xCD\x84\x03\x6D\x42\xCC\x95\x10\xC7\xD6\xCA\x11\xD5\x71\xE9\xC6\x10\x5E\x34\x6E\xCB\x0E\x2B\xB9\x3B\xC3\x9F\xDF\xC0\x00\x6C\x35\x67\xCF\xBE\x6F\xCE\xEC\x86\x08\xD5\xCA\x10\x5B\x99\x51\xD4\xBE\xD6\xCF\xE0\x2F\xCA\xB6\xBB\x9E\xA8\xB2\x41\x13\xC5\x77\xC2\x21\x0F\x39\xCE\xCF\x72\x6F\xC9\xDC\xB5\xCF\x29\xB1\x10\xC9\xCC\x84\x23\x89\xBF\xB0\x79\xCC\x22\x2B\xC9\x20\x12\xC9\xEB\x01\x14\x3F\x38\xF9\x94\x0F\x14\xBE\x3A\xC9\xD0\x35\xC3\xA0\x81\x08\xD9\x20\xD0\x0F\x12\xBA\x1D\xCD\x09\xD8\x85\xD3\xC9\x42\x10\x3B\x0F\xD1\x21\x3C\x3B\xB7\xC6\x77\xD6\xCD\xCD\xAE\x65\x15\xD0\x00\x3A\xBE\xBC\xC5\x40\x62\x6E\x67\x63\xCD\x00\x04\xFE\xAC\xD0\xEF\x11\x97\x81\x09\x66\xDC\xCE\x02\xC2\x0E\xE0\x0F\x05\x38\x94\xF0\xCA\x7D\xC9\xCE\x0A\x0A\xF1\x3D\xD1\xEE\x05\x95\xC0\xA1\x42\x15\xD1\x00\x04\x35\xC0\xD3\x84\x0E\x78\x43\xD0\x78\x03\xCB\x6F\xC8\x49\xCD\xB3\xA2\xCD\x79\x4E\xD1\x72\x0E\xCB\xD9\xC1\x20\x08\xD2\xDF\xC8\xA3", - "\x82\x09\xE8\x36\xD2\xCB\x0F\x2E\xD9\xD2\x1F\xDB\x2F\xB0\xD0\x13\x28\xD2\xC8\xCD\x36\xC9\x09\xD2\x30\xA6\xC3\x0F\x60\xC3\xD3\x48\xD2\x3A\xCB\xD2\x83\x0A\x7A\x6D\xD3\x71\x1C\xCC\x51\xD4\xC2\x69\xD0\xD7\x36\xA7\xD2\x0E\x91\x3D\xD1\x48\xD7\xC3\xB3\xD3\x81\x02\x7B\x3D\xD2\xED\x3D\xD1\xA5\xCE\x2A\xC6\x08\x24\xDE\x9E\xB0\xD1\xF0\x3D\xD1\xCF\x3D\x47\xF6\x33\xA7\xC3\x10\x48\xD0\x7E\xC5\xCA\xD3\x3D\x47\xD8\x3F\x1E\xD1\x69\x14\xD6\x40\x1A\xCB\x5A\xD1\x45\xCC\x23\xC2\xC0\x00\x02\xD6\x9A\xCF\x10\xDC\x3D\x4F\xD7\x0E\x52\xDD\xA8\xFF\xCB\x8F\x00\x3F\xAA\xD1\x28\x24\xD5\x4B\xD6\xA6\xE0\x0F\xFB\x31\xD5\xB2\xC3\x15\xE9\xD1\xF9\x38\xAB\x81\x12\xA9\xD5\x9A\x29\xD7\xFE\x3D\xD5\x07\x1B\x35\xD6\x99\x51\xDC\x3F\xC3\xD1\x48\x28\xCC\x1B\xD9\xA2\x80\x42\x41\xC7\xCD\x3F\xD7\x54\xC3\x08\x01\x46\x90\xBB\xBF\xBE\xA4\x92\x09\x0A\x49\xD2\xD6\x81\x04\x80\x4F\xD4\x78\x0B\xD6\xB9\xB4\x3C\xC6\x40\x6F\xD9\x1C\x60\xD4\x97\xC3\xD4\x02\x08\x01\x64\xD7\xE5\x00\xAE\xE9\xD2\x15\xC9\x08\x17\x43\x5D\xC3\x0E\x70\xD2\xA7\xDB\xD5\x40\x1B\x40\xF2\xD7\x38\x20", - "\xD7\xED\xC8\xAE\x81\x09\x07\x59\xD7\xD2\x08\x5C\xFF\xD5\xFC\xC9\x10\x29\x42\xF1\x0B\x41\x3D\xD2\xEF\xB3\xD0\x70\xDD\xAA\x83\xCA\x41\x0F\x41\xC6\x19\x06\x7D\xD1\xBF\xBB\xB0\xB9\xD4\x79\xD6\x41\xC6\x18\x07\x7D\xD1\xE0\xC7\xAD\xC7\xCC\x8F\xBD\xD2\x3F\x14\x07\x49\xD7\x1B\xB9\xFD\x29\xD0\x12\x40\xD8\xD7\x0D\xC9\x82\xB6\x7B\xDD\x5A\x4D\xB1\x58\xD6\xB6\x57\x46\x20\xF3\x34\xE3\x1D\x64\xFE\xCA\xC3\xC3\x08\x59\x46\x78\x25\x43\x1E\xD7\x6B\x46\x1E\x30\xCF\xD9\xD2\x9E\x0F\x46\xC8\x5E\x3E\xB3\xCF\xA9\x51\xCE\x44\xC6\x18\x12\x7D\xD1\xE5\xCB\x97\x81\x0B\xCA\xCC\xD6\xE4\xCF\x12\xF4\xC5\x07\x1C\x6C\x56\xCF\xD3\xC0\x00\xA2\xCE\x55\xCA\x8F\x55\x4D\xA1\xD2\x0F\xB5\x21\xD1\x06\x0F\x6A\xDA\xD7\x77\xD7\x0C\xDC\xD8\x7D\x02\x37\x9D\xCF\x6A\xD3\xD2\x18\xDC\x00\x66\xD9\x80\x0A\xBE\x56\xDD\x37\xE9\xD1\x5E\x4F\x9D\xC3\x0C\x7C\xCF\xCE\x02\x0F\x6A\xEE\xD6\x82\xD6\x10\x14\x02\xDB\xCF\x10\xF2\xC8\x6F\xCE\xDB\xE8\xC9\xA2\xC4\x45\xDD\xC7\x0E\xE2\xB9\x6E\xC9\x08\x7E\xDC\xB2\xCB\x47\xE1\xD2\x0E\x0E\xD2\x71\xC6\x09\x81\xD5\x94\xA0\x03\xDF\xC3\xB0", - "\xAB\x46\x8C\x59\xBE\x0C\xDA\x36\xED\xCD\x8A\xC5\x47\x9D\xCD\x22\x7D\xD0\xB7\x30\xB6\x9D\xDC\x24\x29\xD1\x21\x4D\x33\xFD\x49\x1E\xDA\x77\x25\xDE\x40\x09\xB6\x2B\xB1\x45\xCD\x4A\x94\xD1\x14\x4A\xC4\x00\x10\xDD\x7C\xDE\xA1\x3A\xCC\x61\xC6\x99\xA4\x22\x6E\xD7\xDA\xBD\xDB\x85\x35\xD7\x1C\xB2\xAA\x83\x19\x02\xDD\xD8\x06\x09\xE9\x86\x09\x17\xB4\xB6\xD2\x4B\xF1\x4F\x17\x8C\xDC\x78\xC7\xD1\x81\x18\x78\x46\x1C\x71\xC2\x08\xCC\xD9\x77\xC0\xB5\xE7\xD5\x30\x67\xD4\x15\xC4\xCF\x7F\x4E\x75\xFF\x10\x21\xDC\xB9\x82\x0A\xF7\xD9\x8D\x29\xD1\x35\x62\xDE\x2A\x1F\x79\x6B\xDF\xF9\xDB\xCD\x20\xD8\x00\x0A\x4F\xF5\xD0\x9F\x3D\xD1\x9D\xC5\xDF\x01\x0C\x1B\xC3\x09\x91\x23\xBD\xA4\x22\xFE\xC2\x08\x10\x2D\x7F\xEB\x21\x00\xE0\x8D\xA9\xD2\x7E\x4B\xDF\xDD\x0C\xF6\x2B\xDE\x02\xE3\xA6\xC5\xC9\x87\x48\xE0\xE0\x09\x52\xF8\xDF\x87\x22\x92\xB7\xDA\x40\x03\x52\xEB\xDE\x4E\x7D\xD0\xED\x3B\xBE\xCE\xCE\x40\x1C\xDF\xF1\xDC\x89\x1E\xE1\x80\x0C\xC0\xAC\xD8\x13\x20\xE1\x52\x49\x45\xC9\x54\xDA\xD9\x13\x0A\x0B\x8D\xDD\xD7\x00\x07\x52\x4F\xDD\xEB\x07\xAB\xD6", - "\xCF\xD8\xD8\xDA\x29\xD1\x56\x73\xE1\xA0\x02\xAC\x93\xE3\x0D\xF7\xE1\x45\xCA\x59\x7B\xE0\x85\x04\xAD\xB6\xE0\x6D\xCD\xDE\x02\x0F\x5B\x43\xE2\x78\xD6\x87\xB7\xE3\xFB\xC5\xCA\xF4\x53\x89\xC6\x08\x84\xD6\xC4\x9E\xD8\x79\xD2\x58\x52\xE3\x20\x34\x41\xCE\xC7\xC3\xC3\xDE\xF6\xC1\x08\x27\x59\x8B\xC2\x08\x91\xD5\xC5\x86\x09\xF4\xDF\xE2\x00\x01\x69\x62\xE3\x80\x09\xB3\xE5\xE3\x40\x14\xDC\x30\xD5\x6B\x5D\xCD\xB9\x5D\xA3\xC8\xDA\x0F\xFE\xDC\xE4\xCA\x70\x5D\xCC\xCA\x5D\xA3\x82\x02\xEE\x59\xD6\x16\xD9\x7E\xE3\x5D\xCE\xCC\x08\x19\xDD\x19\xDF\xE3\x06\x0C\xEB\x86\x08\xAB\x22\xC0\xC3\x22\x22\xE3\x08\xD8\xC8\x86\xCC\x23\x48\xE2\x10\x2F\xE0\xCB\xCE\x04\x97\xDB\x48\x2D\xDB\xCE\xC4\xC9\xD2\xDD\xFC\xD2\x04\x99\xE0\xF4\x88\xE4\x48\xED\xC2\xE4\xCE\xED\x4B\xE3\xAC\x79\x94\xC0\x01\x4E\xE1\xAE\xF1\xDE\x26\x0A\xE5\xDD\x09\x03\x2A\xE4\x56\xEF\xC4\xB0\xD0\xEF\x48\xE5\x1D\x03\x96\xFA\xC4\xF2\xC2\x0A\x30\xE4\x78\x01\x01\xBA\xE1\x21\x1E\xE3\xA2\xC6\x0A\x3E\xE5\x72\x02\x47\x9C\xE2\x4F\xE4\xCE\x55\x06\xCC\xCB\x0F\x42\x49\xE6\x1E\xB1\x45\xCC\x5F", - "\xCE\xCC\xBD\x3D\xD3\x48\x4B\xDF\xAC\xE5\x61\xCD\xCD\x81\x04\xBE\x1D\xCF\xFD\x5D\xD1\xB3\xDB\x82\xEC\xE4\x5A\xDA\xB5\xFB\x5D\x67\xC7\x60\x3D\xD7\x2E\x74\xDE\x85\x0C\xC8\xA1\xE3\x13\x2D\xE7\x29\xE4\x3C\xCE\xC0\x16\xE9\x10\x26\xBB\xF2\xC9\xD1\xC1\x04\x7B\xD3\x13\xF0\xC1\xCF\xF1\xDC\x31\x0B\x50\xFC\xE2\x20\x3A\xC6\x77\xE4\x42\x03\xEB\x40\x05\xC8\x04\xEB\x39\x05\x06\x43\xE1\x20\x08\xE9\x3F\xF0\xE1\xC7\x03\x41\x4C\xC9\x7B\xE4\x9E\xC8\x07\x82\x4A\xCF\x03\x0B\xA2\xD2\xE5\x27\x26\xC9\xD0\xD9\xFC\xC9\x06\xCD\xE3\x38\x19\x4D\xCE\xCD\xD1\xB8\xE0\x79\xCD\x06\x21\xEB\x36\x63\xE5\x4A\xE5\xCA\xF1\xDD\x34\x09\xE9\xD2\x08\x3B\x64\xE9\x23\xE8\xC6\xD5\x04\x4C\xF7\x0E\xF3\x4B\xA6\xC9\x09\x5A\xEA\xB5\xD9\x07\x4D\xE1\x0A\x0F\x52\xA7\xD1\x9D\x14\xDD\x0D\x3F\xE9\x47\x0A\xE5\x25\xEB\x98\xF0\xD1\x70\x06\xD4\x89\x09\x93\x42\xEA\x03\x0F\x8C\xC5\xCB\x72\x0D\xD4\x86\x0A\x06\xF6\xCE\x25\xE8\x8E\xDA\xDB\x74\x0A\xCA\xED\x04\x43\xE6\x08\x99\x53\x7D\xE5\xE8\x6D\xEE\xA1\x8F\xDA\x2A\xF3\x07\x5F\xEB\x20\x00\x56\xB1\xE1\xC8\xB0\xE1\x3D\x0A\xE5\xF9", - "\x01\xAD\xC2\x09\x6C\x5B\xBE\xE8\x2A\x41\x05\xE9\x45\xCB\x1F\x32\xEB\x1F\x11\xC5\xB3\xD2\x5D\xF0\xCE\xE4\xCD\x1F\x3B\xEA\x2A\x1D\xAF\x3D\xD3\x5F\xE6\xC7\xA2\xD3\xB0\xDD\x0E\x82\x56\x3C\x07\xEE\xA1\xB1\xDF\x01\x00\x8C\x5B\xC9\x80\x08\xC5\xFE\xEA\xDC\xC4\xCF\x03\x02\xB2\xF4\x0E\x8A\x5D\xD8\xBB\xE5\xFC\xC5\x00\x9A\xE9\x40\x17\x59\xCE\xE2\xCC\xA9\xD3\x01\x01\xED\x0F\x11\x64\x64\xEC\x33\xE9\xA2\x89\x00\x6A\xE1\x12\x61\xE6\xB2\xD1\xE6\xF2\xCB\x00\x2F\xEC\x7B\x96\xED\x01\x09\x66\x46\xEC\x3C\xE1\xBF\x8F\x00\x6E\xE6\x18\xBF\xEC\x68\x7B\xED\xD3\xD4\x9E\x93\x03\x6F\xF5\x00\xBF\xEE\x69\x7D\xD1\x8A\xC7\xD7\xA9\xD3\x05\x00\x63\xAD\xC1\x21\x13\x5A\xE3\x1C\xDC\x80\xED\xFC\xD8\x00\xD0\xEC\x3E\x32\xE3\xB7\xC5\xDD\x88\xEC\x79\xD9\x00\xD9\xE9\x40\x2B\x5A\xEA\xE4\xD3\xC5\xCA\x06\x01\xEF\x0F\x15\x6D\x64\xEF\x9D\xE9\xA2\x9B\x00\x7A\xE1\x12\x74\xE3\x46\xDD\xEF\x80\x0B\xB7\xC5\xC8\x07\x0F\xEF\x43\x14\x6F\x6B\xEE\x83\x0A\xD4\xDA\xD9\x07\x18\xEF\x3F\x12\x8F\xF2\xEE\x65\xE1\xBF\x9E\x00\x80\xF4\x12\x8A\x5B\xBF\xEF\xE3\x14\xDF\x01\x07\xF0", - "\x08\x1F\xED\x90\x5B\xB9\xFC\xEC\x18\xE2\x02\x07\xF3\x08\x1F\xED\x7C\xE4\xBB\xED\xEA\x96\xD5\x02\x07\xF2\x09\x1F\xED\x83\xE3\x3E\xCA\x09\x87\xC1\xBF\xA8\x03\x81\xF2\x17\xF4\xCB\x20\x33\xEE\x34\xE9\x02\x60\x61\xD8\x8D\x01\x27\xF0\x3C\x1F\xB8\x83\x04\xE2\xB0\xE2\x0B\x11\xF1\xCC\x13\xC6\xEA\xF1\x14\xDF\x02\x2E\xF1\xF6\x78\xF1\xCB\x08\xB1\x0D\xEE\xF2\xC4\x03\x60\x62\xC5\xAA\x08\xAB\x5D\x47\xC2\xF2\xEB\xE0\xC3\xB7\x02\x91\xF4\x0F\x85\xE6\x53\xC1\x09\x25\xFE\xDD\xF1\xDE\x0E\x0F\xF2\x01\x17\x11\x03\xEC\x2A\xFF\xD8\xB0\xE1\x0F\x18\xF2\x0F\x11\x12\x1B\xF3\xCB\xE1\xBF\xC0\x00\x98\xE1\x12\xB4\x5A\xC9\xDE\xEC\x18\xE3\x04\x67\xF3\x90\x15\x04\x63\xF5\xB4\xE4\xCE\x23\x0E\xE6\xBF\x13\x25\x11\xF3\xAC\xEC\x3C\xC9\x03\x3A\xF4\x25\x39\x5E\x9A\xF3\xED\xF1\xDC\x09\x3C\xF3\x27\x0F\xDB\x9B\x06\x33\x5C\xF2\x32\xB4\x3C\xD1\x02\x3E\xF4\x05\x3F\xEF\x2D\xEA\xD4\x03\x08\xD1\xE4\xE6\x0B\xE3\xE5\xFC\xF1\x16\x1F\xED\xBE\x5A\xCA\xC0\x01\xCB\x29\x10\x78\xE8\x8C\xDB\x02\xBF\xED\x3B\x00\x5F\x1E\xDC\xE9\x86\x09\xD6\xD4\xF4\x00\x05\x0B\x21\xF4\xF0", - "\x05\xCC\x9A\xF5\xA9\xE3\x08\x40\xE0\x46\xDF\x03\x55\xF9\x1C\x29\x07\x60\xEF\xF5\x80\xB1\x45\xE1\x02\x5A\xFB\x1C\x46\x5C\xA9\xE4\xF3\x30\xE3\x0C\x3C\xF5\xE1\x0D\x0A\x37\xF7\x9A\xEC\xD9\x65\x03\xD8\xC7\x0E\xE7\x5F\xEB\xF2\xF1\xFC\xC7\x03\xCA\xF2\x3A\x1A\x5F\x66\xF9\xE7\xF1\xDD\x1A\x11\xF6\xD7\x0E\x7B\x54\xF7\x05\xF4\x9E\xEB\x03\x6F\xED\x03\xBF\xED\x7D\x6E\xF5\x09\xFC\xB2\xEF\x03\x6F\xF1\x03\xBF\xEF\x9B\xD0\xF4\x81\x08\xEB\x81\x0B\xA4\xFB\xE6\x02\x0B\x0E\x3F\xED\x3A\x0F\xDB\x81\x62\xA6\xFF\xCF\x03\x0D\x23\xF1\xDF\x3B\x00\xE4\xE2\x14\xBE\xE2\x08\xB1\x2C\x3C\xF8\x02\x1F\xF9\x10\x7C\x01\xBF\xE7\x0E\x01\xFE\x20\x2D\xF6\x34\xEC\x44\x25\xC9\xBE\xE9\xD1\x7D\x07\xE0\xEF\x16\x87\xF0\xF0\xA9\xD2\x1F\x04\xF8\x06\x0A\x10\x12\xF9\xEB\x03\x5C\x43\xF1\xFC\xC3\x04\x18\xF9\x48\x28\xE7\x75\xF1\x10\x1D\xF8\x93\xEC\xD9\x87\x01\xE4\xC3\x13\x7C\xED\x99\xA6\xF9\x95\xF0\xE1\x8B\x02\xE5\xFF\x11\x85\xEA\xE9\xAE\xF9\x97\xEC\xD9\x8F\x02\xE6\xD4\x12\x8B\xE5\xF3\xC0\xF4\xCB\xD3\x04\x3A\xFD\x3B\x0B\x06\x67\x46\xF3\x80\x01\x7D\xF0\xD1\x97\x01", - "\xE8\xE0\x0E\x67\x04\xF4\x84\xDC\x79\xDB\x04\x4A\xF9\x39\x2F\xE9\x9E\xFB\xB8\xA9\xD3\x27\x11\xFA\xCB\x0C\x1A\x0D\xFA\x40\xF0\xC3\xA3\x06\xCE\xE7\x05\xBF\xEF\x1A\x2A\xE5\xA2\xF4\xD6\x93\xC9\x42\x09\x05\x3A\xFD\x15\x3F\xED\x6D\x03\xF6\x9B\xF0\x12\xE1\x08\xAF\x02\xE7\xF3\x05\xDF\xEF\x0D\x2A\xE5\x84\xC3\x08\xC6\x2C\x3C\xF5\x04\x6C\xF3\x25\x28\xCB\x40\x11\xC9\x09\xEB\x88\x3E\xFA\x81\x0A\xA1\x81\xFF\x1C\x20\xFC\x03\x0E\xB9\x24\xCF\x5B\x0C\xF7\xF4\x0D\xE1\xE9\xFC\x29\xD1\x17\x0D\xFD\x00\x17\x93\x83\x08\x50\xD1\xDF\xBB\x07\xC0\xFC\x05\xC9\xF6\x10\x17\xFF\xDF\xE5\xDE\xCC\x13\x1C\x1C\x48\xCF\xF4\xF8\xA0\xFF\xB6\x04\x07\x1C\x4D\x44\xC3\x09\xA3\xC6\xF8\xD2\x0E\x2F\x1C\xFC\xAB\xFA\x21\x3E\xC9\xF8\xD0\x0C\x1B\xFB\x94\x04\x30\x1E\xF8\x86\xC1\x06\x30\x6B\x84\xC4\xE2\x2A\xF8\xFD\x03\x0E\xD3\xDA\xDA\x63\x0C\xFB\xF4\x0C\x57\xFD\xCC\xC0\xFC\xA5\xE4\xCF\x65\x05\xFC\x81\x12\x57\xE8\xFE\xD1\xD7\xED\xC0\x00\x68\x0D\xFC\x8F\x11\x3C\x0B\xE9\x01\x09\xF9\xDE\xE4\x18\xE5\x0D\x55\xFD\x90\x16\x07\xD8\xF8\x00\x1A\xFE\x93\xE1\xBF\xDA\x06\xF7", - "\xE3\x12\x7A\xEB\x7D\xE3\xFF\x58\xFA\xB5\xDF\x07\xF9\xF3\xC1\x3A\xFB\xFD\xCD\xD7\xF7\xF4\x25\x04\x01\xFC\xED\xE9\x30\xE1\x1D\x34\xFF\xEE\x08\x00\x77\xFD\xAD\xAC\xD9\xEE\x03\xFE\x70\x1E\x0C\x00\xFE\x7E\xA2\x54\x9E\x73\x03\x02\x81\x72\x00\x01\x05\x80\xAE\x59\x8A\x68\x0F\x09\x80\xCB\x04\x05\x0C\x00\xA6\x6F\x29\x69\x3F\x00\x01\x83\x07\xD8\x74\xF4\x7C\xDE\x64\x67\x02\x03\x0D\x3D\xFB\x49\x04\xF7\x76\x06\x86\x10\x3C\x74\xA8\x7B\x01\x0E\x01\xB4\x07\x0F\x7A\x08\x83\x10\x07\x7D\x5A\x6C\x03\x07\x02\xA3\x0F\x13\x80\x7D\x79\xA2\x51\x00\x2F\x83\x83\x06\xE2\x6A\x80\x02\x04\x0B\x88\xEA\x56\x00\x35\x81\x90\x0C\x02\x31\x80\x00\x01\x88\x14\x9E\x5B\x00\x37\x31\x74\x7F\x20\x23\x7F\x50\x68\x0C\x7C\x01\x05\x81\x44\x0F\xF8\x7D\xDF\x68\x7A\x1D\x01\x0F\x83\x24\x30\x00\x40\x83\x13\x80\xEF\x41\x04\x22\x02\x14\x8F\x23\x05\x79\x38\x80\x66\x29\xA2\x67\x00\x5A\x80\x95\x08\x03\x00\x81\x52\x74\x8C\x6C\x02\x21\x81\xDD\x04\x0F\x04\x06\xA9\x68\x31\x00\x1A\x80\x1E\x26\x79\x5D\x80\x00\x05\x06\x9A\x6D\x36\x02\x1B\x89\x1C\x04\x01\x40\x80\x9E\x60\xC3", - "\x7B\x00\x4C\x81\xE9\x03\xFE\x5A\x75\xA8\x78\x0F\x01\x06\x81\x01\x37\x32\x19\x38\x04\x34\x7F\x7F\x81\x8A\x63\x04\x21\x81\x48\x01\x21\x8A\x10\x0D\x01\x88\x83\x78\x61\xBF\x4A\x01\x61\x83\x13\x0E\x08\x89\x04\x52\x01\x24\x89\x10\x25\x7D\x0C\x69\x47\x01\x06\x96\x01\x97\x82\x41\x07\x05\x1A\x82\x20\x59\x8A\x68\x05\x21\x81\x5D\x01\x28\x83\x10\x1C\x01\xA4\x81\x89\x54\x9E\x5F\x01\x61\x80\x19\x0A\x0A\x82\x04\xBB\x7A\xFA\x7E\xF6\x68\x71\x66\x01\x18\x8B\x06\x33\x82\x01\x06\x19\x0D\x0A\x82\x04\xEF\x79\x59\x7C\xAF\x21\x81\x72\x00\x2F\x80\x00\x1E\x7B\xB6\x80\x71\x71\xBF\x74\x01\x61\x81\x1E\x06\x0C\xB0\x01\xF4\x7C\x8F\x66\x10\x19\x1B\xE4\x67\x1E\x0D\x07\x86\x04\x7C\x02\x31\x84\xEF\x46\x0F\x15\x19\x53\x66\xF1\x57\x83\xBC\x0D\x91\x62\x10\x1D\x83\xAD\x7E\x0F\x1F\x61\x27\x2B\xA6\x7F\x10\x12\x04\x86\x04\xE7\x81\x39\x86\x34\x09\x81\x02\x04\x35\x81\xBF\x7F\x01\xE0\x82\x40\x00\x08\x06\x83\x76\x03\x81\x7B\x96\x43\x04\xFB\x65\xFC\x62\x08\x35\x83\x3F\x08\xBF\x76\x3C\x3B\x83\x02\x04\xB8\x14\x9E\x43\x02\x00\x84\x95\x03\xF0\x5A\x7A\x04\x85", - "\x40\x08\xB6\x71\x6F\x84\x01\x42\x8D\x1D\x3B\x01\x7C\x78\x96\x62\x10\x0E\x65\xF1\x6D\x21\x02\x11\x83\x0C\x2A\x19\x42\x01\x6D\x24\x67\x86\x01\x42\x87\x08\x06\x83\x17\x7E\xF1\x02\xA6\x42\x04\x33\x19\x23\x73\x47\x27\x84\x60\x71\x3A\x83\x47\x01\x66\x06\x07\x47\x81\xBF\x49\x02\x09\x86\x22\x06\x0C\xBF\x01\x07\x7B\x9B\x68\x12\xAE\x84\x29\x12\x4E\x8D\x12\xAA\x84\x29\x11\x4A\x86\x10\x18\x84\x30\x70\x23\x0B\x11\x8C\x0B\x7A\x82\x40\x0D\x11\xAE\x83\x44\x0F\x8D\x19\x10\x3F\x69\x4C\x85\x42\x0D\x08\x06\x83\xDD\x04\x54\x83\x10\x04\x85\x38\x7F\x51\x8B\x2D\x16\x85\x02\x04\x95\x10\x14\xBE\x10\x5E\x84\x36\x8C\x13\xA0\x85\x0A\x04\xE9\x72\xFD\x50\x02\x09\x85\x24\x06\x0C\x80\x02\x07\x79\xA2\x66\xF9\x69\x68\x93\x01\x42\x84\x09\x06\x83\x81\x03\x81\x7F\x65\x1E\x83\xA6\x72\x56\x82\x2E\x31\x5E\x03\x07\x5D\x81\x15\xA3\x0E\x7C\x86\x40\x0E\x16\xA6\x70\x4F\x13\xA4\x66\x10\x0E\x85\x7F\x84\xEF\x0F\x9A\x46\x04\x8C\x1B\x57\x81\x14\x17\x02\x54\x84\x78\x0D\x18\x83\x85\x29\x69\x26\x0A\x17\xBE\x0B\x93\x87\x40\x0D\xA9\x49\x86\xC8\x0F\x66\x83\x10\x37", - "\x66\x9C\x85\x01\x1E\x19\x82\x04\x66\x84\x1A\x7A\x09\x09\x84\x9B\x02\x31\x8A\xF1\x46\x0F\x94\x1B\xB3\x29\xA2\x5D\x02\x09\x86\x27\x06\x0C\xA0\x7C\xC6\x0C\x68\x87\x15\xA9\x68\xA0\x03\x65\x8F\x2E\x16\x6B\x02\x06\x6D\x84\x18\xA4\x10\xBC\x85\x40\x0D\x1A\xA1\x86\xDE\x0E\xC2\x63\x10\x06\x86\x1B\x74\x09\x14\xB1\x43\x04\x8B\x85\x72\x8B\x42\x1C\x6C\x17\x85\x8A\x61\x0A\x3A\x86\x05\x0C\x74\x81\x10\x33\x6C\xC4\x86\xBC\x08\x1D\x83\x04\x44\x6D\x76\x83\x30\x1B\x87\xA4\x85\x8A\x62\x0A\x09\x84\xA3\x02\x31\x84\x08\x07\x78\x3D\x6D\xE7\x79\xA2\x65\x02\x09\x86\x29\x06\x0C\x85\x02\x07\x79\x77\x87\x1B\xA4\x67\xA8\x00\x75\x83\x25\x0C\x6D\x01\x06\x7C\x8F\x1B\xAB\x10\xF8\x84\x00\x09\x1E\x8E\x87\x43\x11\xD5\x63\x10\x32\x84\x30\x71\x2A\x09\x10\xAA\x02\x91\x85\x72\x04\x20\x82\x04\xCF\x18\x79\x6C\x0A\x36\x87\xF4\x05\x75\x63\x10\x32\x83\x30\x71\x2B\x09\x10\xAE\x02\x09\x8B\x72\x04\x21\x82\x04\x5F\x6D\xFC\x60\x0B\x37\x30\x47\x79\x80\x0B\x6D\x06\x04\x06\x86\x77\x8C\x2C\x23\x88\x03\x07\x43\x80\x20\xB3\x11\x25\x8B\x40\x0E\x9D\x71\x6F\xB3\x01\x86", - "\x82\x2E\x2A\x88\x02\x07\x8B\x80\xC3\x75\x02\x32\x8A\xBF\x08\x6E\x24\x88\x63\x87\x94\x06\x08\x07\x78\x3B\x89\x8A\x8D\x23\xB4\x07\x29\x7E\xF1\x04\x6F\x1E\x84\x29\x6B\x2D\x09\x10\xB8\x02\xC6\x80\x22\x07\xE0\x70\x6D\x03\x04\xBF\x1E\x18\x84\x0D\x50\x8A\x40\x08\x6F\x13\x89\xA5\x0F\x95\x81\x13\xA9\x68\xBA\x01\x42\x8B\x0B\x06\x83\x89\x03\x81\x78\x9E\x51\x89\x43\x89\xE9\x03\x26\x96\x89\x65\x8B\xE8\x02\x25\x86\x04\x91\x6C\x0C\x7D\x0B\x10\x88\x09\x06\x22\x07\xE0\x6B\x89\x13\x89\x8A\x6E\x0B\x06\x83\xC0\x02\x31\x81\xF3\x7D\x68\x77\x6E\x40\x06\x9E\x66\x88\xDB\x09\x9F\x81\x10\x01\x1C\x58\x8B\xE8\x04\x28\xAC\x89\x29\x6A\x30\x00\x27\x86\x04\x8D\x03\x81\x77\x28\xB5\x89\xE4\x67\x30\x06\x0C\x85\x03\xC6\x82\x23\x0F\xDB\x5D\x5F\x06\x07\x9F\x8B\x22\xA9\x10\x98\x8B\x40\x0F\x28\xBB\x87\x43\x12\xE7\x56\x10\x07\x89\x80\x8A\xB8\x01\xB8\x42\x04\xFD\x80\x44\x7B\x28\x81\x09\xA7\x89\x40\x0D\x22\xAC\x6C\xC8\x03\xAA\x8C\x21\x98\x7A\x0A\x04\x8D\x82\xFD\x49\x03\xB2\x89\x40\x02\x09\x3F\x76\xA9\x89\x41\x89\x26\x81\x09\x94\x00\xAF\x85\x2B\xBF\x8A", - "\x43\x0A\x25\x0F\xDB\x55\x1C\x09\x05\xC2\x14\x9E\x4A\x03\x20\x88\xD1\x09\xB8\x43\x04\xC8\x89\xA9\x8E\x2F\x19\x5E\x06\x06\xB2\x81\xBF\x4D\x03\xCD\x89\xE9\x0D\x9F\x43\x04\x6D\x88\xCB\x60\x0D\x39\x8A\x54\x0B\xB6\x81\x0F\xA9\x68\xD1\x02\x31\x83\x0D\x06\x83\x98\x03\x81\x7D\x2D\x81\x04\x1B\x8A\xF4\x75\x0D\x09\x84\xD6\x02\x31\x89\x09\x07\x78\xE6\x5E\x41\x0D\x2B\x92\x7F\xD8\x00\xB8\x8A\x09\x34\x8B\x0A\x07\xAB\x82\xFD\x59\x03\xE0\x88\xD4\x7A\xE9\x75\x8B\x42\x88\x79\x6A\x0D\x20\x8B\x9E\x00\x9F\x76\x75\x09\x04\x3D\x1C\x79\x6B\x0D\x20\x8B\xDD\x07\xFA\x56\x10\x0B\x8C\xD2\x8B\xBB\x0B\xB9\x43\x04\x0D\x8D\xFC\x6C\x0D\x39\x88\xEF\x0B\x85\x63\x10\x29\x1D\xE4\x66\x37\x09\x10\x9F\x03\x1C\x8F\x75\x0E\x31\x82\x04\x6C\x1C\x79\x61\x0E\x09\x84\xE2\x01\xC9\x81\x14\x27\x8C\x01\x04\xE9\x61\xBF\x64\x03\x09\x85\x39\x0E\x32\x8A\x04\x20\x8E\x41\x09\x32\x84\x87\xE7\x03\xCD\x89\x10\x39\x8C\x03\x06\xCC\x8B\x29\x97\x07\xE9\x02\xCF\x8A\x33\x8A\x04\x42\x8C\xA8\x87\x1C\x2B\x03\x46\x8D\xD0\x8A\x10\x20\x68\x15\x8D\xC1\x09\x34\x81\x04\xAD\x6D\xD4\x83", - "\x25\x13\x8D\x00\x00\xDD\x15\x28\xBC\x0E\x50\x8C\x37\x74\x2C\x81\x04\xED\x01\xD3\x82\x10\x32\x1D\x09\x05\xD5\x83\x34\x86\x0D\x64\x8E\x41\x0A\x35\x96\x8D\xF4\x07\xDA\x81\xFC\x69\x68\xEF\x02\x1D\x8B\x1C\x21\x02\xF4\x7E\xDB\x8A\xFC\x71\x6F\xF4\x02\xDC\x83\x1C\x26\x02\x75\x8E\x0B\x79\xA2\x79\x03\x7A\x8F\x71\x0B\x0A\x3D\x8D\xC6\x65\xFC\x6E\x0F\x01\x8E\xD2\x04\x2C\x00\xC6\x24\x5C\x76\x8F\xF6\x7C\xB2\x43\x00\xCB\x47\x07\x86\x10\x36\x02\x8B\x8E\x42\x0D\x38\xA4\x7F\x30\x70\x02\x01\x39\x85\x1E\x95\x8D\x42\x07\x39\xAC\x7F\xA8\x79\x03\x0B\x39\x81\x08\xC2\x00\xE1\x86\x10\x20\x8E\x57\x80\x00\x02\x01\x23\x8E\xA7\x1E\xE9\x80\xEB\x4E\x77\xAC\x8D\x90\x0C\x0C\x2E\x8E\xB9\x78\x79\x6C\x01\x31\x8E\x43\x09\x34\x04\x3B\xB7\x7C\xD2\x7D\x08\x08\x3B\x97\x1F\xBB\x8D\x2B\x70\xC3\x66\x00\xBF\x8C\x95\x0B\x0D\x01\x8F\x24\x81\xEA\x8B\x02\x05\x8F\xDD\x04\x38\x08\x3C\xA9\x68\x30\x00\xF3\x80\x1E\x25\x03\xCF\x8C\x79\x65\x03\x12\x8F\xC9\x06\x3A\x01\x3C\xBA\x80\xA9\x8E\x0E\x08\x3D\x8B\x07\xEF\x03\xF6\x89\xA2\x7F\x00\xDF\x8F\x70\x04\x0F\x22\x8F\xE4", - "\x64\x11\x05\x3E\x87\x07\xF9\x01\xF0\x8B\x0E\xB0\x70\x49\x00\xC3\x5D\x1D\x3E\x03\x07\x7B\xE5\x80\x0F\x92\x7F\x4A\x02\xFC\x88\x21\x35\x8F\x4E\x7D\xFC\x6B\x04\x2B\x8F\x3C\x61\x18\x87\x39\x96\x81\xC2\x81\x25\x70\x40\x97\x07\x05\x02\x00\x9D\x3F\xB0\x70\x55\x03\x01\x97\x71\x4A\x90\x55\x7C\x79\x6A\x05\x0E\x90\x3F\x34\x04\x95\xED\x70\x70\x5F\x00\x05\x95\x89\x56\x90\x51\x75\x8A\x64\x06\x1A\x90\xA2\x44\x07\x9B\x99\x69\x68\x69\x02\xFE\x89\x1C\x1E\x00\x09\x87\xE5\x80\x08\xA9\x8E\x6A\x01\xF1\x8F\x06\x0B\x47\xC6\x3B\x0D\x3C\x38\x92\x82\x30\x71\x1C\x05\x3C\xB6\x01\x30\x93\x85\x52\x43\x96\x8E\x34\x90\xCB\x68\x07\x05\x8F\x7D\x01\x0E\x97\xA4\x7B\x90\x9E\x8C\xB9\x72\xFD\x7F\x01\xC5\x8C\x21\x02\x44\xA0\x58\x44\x92\xDA\x86\x44\xA8\x71\x86\x01\xF1\x8B\x08\x0B\x91\xCC\x4D\x13\x93\x10\x17\x8E\x9C\x83\xBD\x5D\x08\x05\x8F\x92\x00\x15\x92\x10\x3D\x00\x56\x92\x40\x07\x39\x81\x83\x66\x7C\x89\x85\x3C\x99\x02\x5E\x91\x40\x0B\x08\xAB\x4F\x3C\x92\x32\x80\xC3\x5B\x02\xC5\x8C\x28\x09\x46\x80\x00\x49\x01\x18\x91\x10\x23\x91\xE2\x85\xF1\x87\x0A", - "\x33\x91\x96\x80\x1B\x99\x10\x30\x5F\x06\x06\xD9\x8A\x34\xA9\x10\x80\x93\x15\x9F\x35\x9E\x0F\x82\x90\xDC\x79\xA2\x69\x02\x26\x93\xB6\x03\xA2\x5F\x8C\x29\x6A\x2A\x03\x47\xAC\x02\x73\x91\x15\x0B\x24\x8A\x04\x3B\x8C\x0C\x7E\x0A\x33\x91\xB0\x03\x1C\x90\x0A\x86\x0F\x8F\x90\xA5\x39\xA2\x72\x02\x8D\x93\x70\x07\x05\x17\x92\x09\x04\xD6\x85\x94\x73\x02\x73\x91\x2D\x03\x47\xA7\x82\xC6\x0F\x8A\x60\x49\x8B\x7E\x0C\x5C\x2E\x03\x47\x99\x01\x09\x86\x2C\x98\x32\x9C\x89\x0C\x5F\x2E\x03\x47\x9A\x01\xB9\x90\xD2\x89\xA2\x7D\x02\x0C\x5E\x2F\x03\x47\x9B\x01\x5E\x8A\x42\x0F\x77\x32\x73\xA5\x92\xBF\x02\xA3\x73\x92\xF1\x6D\x30\x0C\x70\x42\x03\x73\x90\x17\x09\x4C\x89\x04\x99\x90\xCB\x64\x0C\x0C\x5C\xC5\x03\x1C\x99\x0A\x86\x0F\xCF\x92\x40\x0A\x4A\xB0\x68\xC7\x00\xC3\x58\x0C\x33\x91\x5E\x01\x42\x87\xBC\x42\x04\xCB\x91\xFC\x6A\x0C\x0D\x93\xEF\x0B\x3A\x91\x10\x00\x8D\x2C\x6F\x32\x0C\x70\x4C\x03\x73\x90\x2C\x86\x3C\x32\x93\x00\x01\x36\x92\xFD\x4E\x03\x0C\x5F\x33\x03\x47\xA0\x01\xEA\x92\x30\x94\x9E\x51\x03\x0C\x5E\x34\x03\x47\xA1\x01\x09\x85", - "\xF5\x66\x6D\x51\x60\x46\x30\x07\x66\x6E\x66\x31\xF5\x5D\xD3\x6C\x03\x4B\x48\x86\x64\xCD\x02\x84\x46\x42\x86\x0A\xD4\x69\x51\x86\x0F\x0E\x34\x46\x94\xA1\x5B\x06\xBE\x45\xE3\x3F\x51\xAF\x65\x0E\x36\x24\x32\x51\xA7\x5D\xE5\x05\x28\x38\x6D\x55\x70\x44\x05\xD7\x6D\x13\x3F\x60\x9D\x66\x43\x31\x36\x5C\x05\x4B\x61\xCD\x3A\xC8\x38\x94\xF7\x5B\x4E\x94\x82\x77\x5B\x24\x5C\x5B\x01\x54\x92\x05\x24\x5C\x57\x05\x54\xAC\x60\xF7\x5B\x82\x60\x00\x0B\x68\xFF\x02\x0E\x4C\x15\x0E\x95\x34\x61\x52\x97\x6F\x4B\x49\xAC\x4B\x0F\x37\x83\x41\x05\x3E\x40\x57\x0E\x03\x4E\x34\xA9\x60\x53\x0D\x55\xAA\x3D\x5C\x95\x47\x92\xD8\x05\x95\x63\x95\x50\x05\x56\xAB\x50\x96\x42\x59\x9E\x3E\x6A\x95\x7E\x91\x08\x54\xF2\x71\x50\xBB\x60\x03\x56\x87\x72\x95\x9D\x64\x5D\x95\xC0\x68\x95\x03\x06\x53\x92\xD8\x3A\x95\x65\x60\x5B\x97\x57\xAE\x95\x63\x6A\x5D\x91\x58\x82\x36\x14\x94\x61\x9E\x57\x83\x96\xE3\x4C\x60\x92\x3D\x4A\x41\x78\x97\x62\x9E\x86\x4A\x96\xC1\x49\x63\x91\x59\xA0\x53\x6C\x07\x2E\x56\xC4\x3B\x52\x0E\x34\x66\x9D\x83\x66\x5B\x1A\x48\x5B\x0D\x59\x92", - "\x05\x1A\x4A\x43\x31\x5A\x81\x05\xA3\x95\x3D\x5C\x15\x30\x62\x4E\x04\x6A\x93\x14\x24\x48\x5C\x07\x02\x5C\x16\x2E\x96\x52\x04\xBC\x51\x14\x0B\x50\x0E\x37\x15\x5C\x16\x36\x96\x52\x07\x15\x5C\x15\x3A\x96\x41\x04\x6F\x92\x4A\x70\x06\x02\x67\x50\x0E\x26\x7B\x94\xC3\x95\x50\x05\x5C\xBF\x96\x03\x04\x71\x99\x58\xA7\x52\x53\x6C\x73\x90\xBF\x4E\x97\x37\x96\x9B\x40\x3D\x52\x97\xC6\x95\x5C\x94\x5D\x88\x97\x2C\x64\x76\x9B\x8C\x5A\x97\x1E\x94\x3B\x6D\x51\xAE\x49\x0E\x34\x78\x95\x5D\x86\x0F\x7A\x4B\x77\x96\x5E\xA6\x5B\x6E\x48\x57\x09\x5E\xA3\x97\xD9\x5B\x7A\x9C\x5D\xAA\x97\xE7\x95\x7B\x91\x86\x65\x97\x3D\x68\x7D\x9F\x96\x76\x97\x81\x96\x2D\x52\x45\x61\x07\xFE\x62\x54\x03\x44\x5C\x05\xC5\x4A\x52\x01\x60\xBF\x03\xFD\x59\x50\x09\x90\x4C\x05\x07\x9A\x51\x05\x88\x5C\x05\x85\x62\x43\x34\x2F\x4E\x4C\x3F\x32\xBA\x51\x14\x12\x98\x90\x52\xF4\x44\x61\x95\x52\xD6\x5B\x85\x9B\x48\x59\x98\xF7\x5A\x86\x93\x10\x16\x62\x6C\x04\x88\x92\x15\x16\x62\x0E\x34\x89\x91\x14\x26\x98\x9A\x52\xB5\x58\x28\x47\x05\x2B\x9A\x4F\x08\xF8\x0E\x34\x2F\x99\x50", - "\x01\x63\xA4\x47\xC8\x6F\x26\x59\x6D\x7B\x4E\x4C\x04\x8E\x96\x14\x3C\x32\x5C\x04\x8F\x91\x14\x3E\x98\x2D\x65\xF4\x40\x64\x87\x60\xE6\x5B\x90\x99\xC1\x37\x5B\xD4\x46\x50\x4F\x0F\x0A\x38\x5C\x04\x93\x91\x14\x0E\x99\xE6\x58", + "\x12\x07\x02\x00\x8A\x27\x00\x00\x23\x00\x01\x82\x80\x0E\x03\x82\x81\x82\x06\x89\x82\x88\x0A\x80\x86\x82\x0A\x0A\x97\x0A\x9C\x0A\x82\x12\x85\x24\x0A\xCE\x0A\x94\x2A\x87\x2A\x85\x2E\x0A\xF0\x0A\x9A\x3A\x82\x66\x09\x84\xFF\x29\xAA\x89\x9A\x80\x03\x95\x95\x2D\xAF\xAA\x91\x92\x9F\x7C\x9A\x99\x37\xAF\xB9\x90\x9A\x85\x9A\x9B\x9E\x35\xBB\xB3\x80\xA8\x9C\xA2\x9D\x96\x0A\x81\x06\xBC\x98\x91\xA3\xA5\xA1\x4D\xC5\x91\xA7\xA3\xAC\xA6\x82\x9F\x42\xAC\x8F\xBA\xA5\xA8\xAB\xAA\xA7\x5D\xDC\x9F\xB2\xA3\xB4\xAA\x82\xA5\x09\xE8\xA5\xB6\xA3\x80\xAF\xAD\x9F\x61\xF0\x86\x82\x09\xA7\xB5\xAC\xB9\x6D\xE0\xAB\xBE\xA9\xBC\xB1\xBE\xB3\x7F\xEC\x82\x8E\xB1\xBF\xBA\xC2\xBB\x88\x85\xC9\xDB\xB2\xB1\xC0\xBF\xC1\x7A\x8E\xCD\xD0\xCE\xBC\xC8\xC0\xCB\x82\x81\x84\xCC\xC8\xB8\xCF\xC6\xCD\x91\x9E\xD3\xC0\xD5\xCC\xD3\xCA\xD3\x99\xAE\xA1\xC8\xDF\xCA\xD5\xD2\xD7\xA7\xB0\xE9\xDB\xC2\xCD\xCC\xD7\xD1\xB2\xAD\xF4\xC2\xD6\xD9\xDC\xDD\xDD\xB7\xBD\xC0\xFE\xD2\xE3\xD4\xE3\xC3\x8A\xC9\xDC\xC8\xE6\x83\x01\xBA\xE5\xB5\xCC\xD1\xEB\xC3\xE8\xE8\xDE\xE9\xD7\xD4\xD9\xF6", + "\xE1\xE5\x94\x03\xE7\xCB\xDA\xDD\xE2\xF0\x05\x00\xF1\xEA\xE1\xDC\xC7\xEA\x86\x07\xF3\xED\xF4\xF0\xE8\xF2\xEF\xF3\xFB\xF2\xF5\xE1\xF8\xC6\xF9\xEF\xDB\xF9\xD9\xFF\xD9\xFA\x41\x8C\x7E\x80\xFE\x44\x80\x83\x80\x08\x85\x89\x83\x81\x0A\x8D\x8C\x83\x83\xBA\x46\x77\x02\x7B\xF6\x71\x74\x7F\x85\x15\xB5\x7B\x7B\x7D\x06\x91\x8B\x82\x87\x0E\xA0\x80\x87\x6F\x1D\xA4\x8F\x86\x89\x21\xA8\x83\x89\x71\x27\xAC\x89\x8A\x8B\x2B\x98\x79\x84\x86\x1B\x96\x83\x8D\x40\x0C\x69\x54\x7B\x7F\x22\xBD\x8A\x8A\x8F\x30\x80\x92\x8D\x8D\x1A\xBC\x8F\x8F\x91\x41\x88\x93\x92\x91\x49\x8D\x9B\x91\x89\x4E\xBB\x80\x97\x93\x2D\x94\x9F\x8A\x95\x31\x92\x95\x96\x96\x57\x9C\x99\x96\x7A\x09\x14\x84\x90\x8D\x4C\x98\x92\x92\x97\x67\x9C\x8B\x96\x9A\x5D\xAC\x9F\x96\x8D\x63\xB7\x81\x9F\x9C\x65\xA8\x9A\x92\x9D\x51\xAE\x99\x9A\x41\x0A\x22\x95\x9E\x9E\x77\x80\xA9\x9C\x9C\x7F\x84\xA3\x96\x42\x0B\x3E\x97\xA2\xA0\x2D\x4C\x0A\xA3\x9A\x86\x90\xA5\x93\xA2\x91\xAD\x95\xA7\x9B\x93\xAF\x6D\x03\xA3\x96\x99\xAD\xA4\x99\x94\x9E\xA8\xA4\xA8\x92\x87\x4C\xA7\xA8\x72\x83\x7F\x03\xA9", + "\x7B\xA2\xAD\xA8\xA9\x9F\xA9\xA1\xA8\xAC\xA8\xB4\x93\xAE\xAC\xA5\xB8\xA1\xAE\xAD\xB9\xBC\xAB\xAD\xA1\xAE\x81\xA7\xA7\xAB\xBA\xB5\xA0\xB0\xAD\xC4\xBE\xA6\xB3\xAD\xCA\x89\xB0\x04\xAB\xC2\x81\xB3\xA2\xB4\x66\x91\xB8\xB2\xB5\x72\x91\x00\xB7\xB4\xD7\xBD\x67\x4A\x8E\x8C\xB8\x9D\x4B\x04\x62\x90\x40\xBB\xB0\xD8\x8D\xB9\xBB\xB1\xC5\x89\xBC\xBA\xBA\xDC\xAD\xBB\xB8\xB3\xEF\xB5\xB4\xBF\xBD\xBD\xB6\xB9\xBC\xBE\xBF\xBC\xBB\xB3\xBE\x00\xFD\xB1\xC3\xBF\xBB\x95\x0B\xB5\xB5\xF1\xB0\xB8\xC3\xC2\xE2\x8D\xC1\xB9\x42\x16\x22\x92\x47\xB9\xD4\x8E\xC8\xB9\xC2\xFA\x82\xCA\xC4\xC1\x1C\xEE\xBE\xBE\xC7\x03\xE0\xCB\xC6\xC8\x1D\xF3\xB1\xCA\xC9\x23\xE8\xC5\xC9\xC2\x18\x07\xC6\xC5\xC5\x0F\xD7\xCC\xC1\xCC\x1A\x99\x0E\xC8\xCD\x34\x9A\x07\xCE\xCC\x2F\xDD\xB3\xCC\xCF\x38\xF2\xB8\xC7\xC7\x2A\xE4\xC6\xD1\xD1\x48\xC3\xD7\xCA\xD2\x29\xCC\xDB\xCB\xCF\x30\xC0\xD2\xD5\xD4\x54\xC2\x4B\x07\xCE\x55\xC2\xD0\xD6\xCF\x3D\xDA\xD4\x78\x45\x14\xDC\xD1\xD0\x00\x1D\x18\xD2\xD8\x9C\x1E\x22\x9F\x06\xD9\x5E\xE3\xD9\xC7\xD3\x5D\xCA\xC1\xDF\xDB\x47\xCE\xD5\xDF\xD6\x6D", + "\xD3\xD7\xD9\xD6\x72\xEE\xD4\xD2\xDD\x49\xF8\xDD\xDE\xDE\x79\xFC\xD0\x08\xDB\x83\xFC\xD4\xDD\xE0\x73\xFF\xDD\x49\x08\x62\x96\x41\xD9\xE1\x7B\xD5\xE4\xE7\xE5\x89\xD6\xE9\xE4\xE6\x8B\xC0\xEE\xE6\xE0\x9D\xE0\xEE\xE1\xE3\x4B\xE2\xE5\xE9\xDC\x00\x53\xEB\xE7\xEA\xA1\xE4\xED\xD2\xE0\x24\x08\xED\xE9\x42\x25\x32\xE3\xEA\xDF\xA7\xF8\xEF\xEA\xEB\x70\xFA\xED\xEC\xE1\xAC\xF7\xE0\xF3\xEC\xC3\xC2\xF3\x42\x09\xB6\xF9\xE5\xF2\xF2\x8A\xC6\xFA\xE4\xF1\xCD\xCC\xFF\xF2\xF3\x9C\xD4\xF1\xF2\xF4\xD5\xD8\xF7\xF7\xEE\xBE\xF7\xDC\xEE\xF7\xDD\xE9\xB7\x09\xF2\xDC\xC6\x48\x08\xF9\xBF\xD1\xF5\xFA\xFA\xE9\xD3\xFA\xF4\xF4\xEE\xEB\xF1\xFD\xFB\xD9\xF2\xF5\xFC\xFD\xDB\xF8\xF0\xFF\xFD\xE0\xCB\xF6\xFD\xFE\xFD\x6C\x7D\x00\xF3\x7D\x35\x14\x28\x7B\x80\x01\x2A\x07\x01\x8C\x71\x7D\xCF\x5F\x7C\x81\xFE\x7A\x7E\xF5\x7B\x70\x80\x08\x82\x86\x82\x34\x4B\x07\x02\x8E\x8D\x80\xD3\x7F\x7C\x82\x20\x93\x82\x08\xEF\x73\x85\x0F\xA5\x82\x82\x24\x89\x87\xFF\x2C\x0B\x82\x0F\xA8\x86\x84\x2A\x89\x35\x0B\x2D\x81\x6E\x17\x34\x85\x83\x0F\x9C\x81\x04\x88\x85\x82\x1D\x97\x86", + "\x87\x04\x98\x80\xFF\x42\x8D\x86\x17\xAD\x37\x05\x37\x9B\x84\x11\xA1\x81\x86\x1E\x8C\x88\x86\x50\x8F\x86\x14\xCE\x8C\x58\x18\x09\x8F\x87\x46\x8B\x8B\x09\xD4\x8D\x88\x2D\x9D\x88\x88\x43\x80\x8D\x11\xB9\x89\x8A\x31\x8F\x89\x35\x31\x08\x72\x0C\x08\x73\x06\xC4\x74\x02\x4C\x35\x17\x8A\xE6\x36\x02\x8F\x80\x37\x05\x8E\x00\x18\x06\x98\x39\x02\x4C\x1D\x22\x4B\x07\x62\x5C\x04\x1E\xE7\x8C\x8B\x28\x85\x93\x8A\x5E\x86\x91\xBA\x3D\x03\x91\x2D\x89\x90\x91\x66\x8E\x91\x24\xDF\x83\x48\x1F\x08\x77\x07\x88\x60\x08\xE2\x41\x02\x4C\x21\x0D\x94\x92\xE4\x23\x08\x1E\xC4\x02\x4D\x22\x22\x4E\x08\x62\x47\x0A\x98\x48\x0F\x92\x45\x93\x96\x95\x65\x91\x94\x19\xB3\x98\x87\x5A\x8A\x8F\x95\x90\x92\x96\x2D\xD8\x84\x97\x5B\xBA\x96\x97\xBD\x9C\x97\x2E\x9A\x78\x22\xD5\x44\x90\x37\x4A\x0D\x95\x2E\xC1\x91\x88\x5C\x87\x97\x99\x8F\x90\x9A\x33\xD1\x94\x9B\x69\x96\x9F\x97\xC2\x80\x9B\x30\xE1\x88\x9A\x81\x0B\x08\x8F\x4C\x0A\x99\xB2\x4D\x02\x9D\x6A\x9D\x9C\x9B\xCC\x88\x9F\x36\xE3\x8B\x9D\x63\xBD\x32\x23\xC6\x92\x91\x4B\x4F\x05\x9D\x6B\xA9\x9C\x9D\xDA\x90", + "\x4C\x14\x08\x71\x0A\xC4\x52\x08\x71\x53\x02\x4C\x47\x71\x90\x95\x75\x95\x08\x8F\x56\x02\x4E\x47\x2A\x78\x0A\x31\x59\x0A\x4C\x5A\x18\x8F\x16\x75\x97\x9C\x7C\x99\x9F\xA2\xCD\x95\xA2\x3B\x9A\xA2\x9F\x7B\x9B\xA6\xA3\x1D\xAB\x9C\x17\x14\xA0\xA5\x82\xB9\x98\xA3\xEA\x87\xA5\x46\xA5\xA0\x96\x96\x8B\x9D\x9D\xD6\x60\x24\x41\xB1\x3E\x0A\x92\xB0\xA6\xA4\x28\xB6\xA3\x4A\xB7\xAB\x57\x2F\x08\x70\x0C\x88\x61\x0C\xE2\x62\x02\x4D\x31\x36\xA2\xA5\x72\x44\x0C\x1E\xE5\x02\x4C\x33\x22\x4F\x0C\x62\x48\x0E\x98\x69\x08\x8E\x35\x07\xA9\xA7\x1F\xBC\xA7\x4B\xC8\xAA\xA7\x94\x98\xA9\xA4\x5C\xB9\xA9\x58\xE0\xAF\xAB\xD7\x2B\x0F\xAA\x3B\xA3\xAC\x4E\xE9\xA5\xAD\x96\x9A\xAA\x9A\x1C\xBD\x54\x1B\x68\xAE\xAA\xB6\xB6\xAD\xAE\x78\xBD\xAA\x5E\xE2\xAD\xAC\xFC\x6D\x08\x71\x6E\x08\x73\x1B\x08\x72\x24\xD5\x71\x0C\xAE\x7B\xA6\x3A\x1C\x78\x83\x0E\x31\x74\x0A\x4C\x75\x02\x4E\x1D\x62\x47\x0E\x3C\xB8\x08\xB1\x7C\xB7\xAD\x62\xEB\xA9\xAF\xCC\x9D\xB4\xAC\x9A\xBE\xB3\x66\xEE\xAA\xAD\xFF\x79\x08\xB3\xA0\xBF\xB0\x67\xA3\xBB\xAB\xBE\xB0\xAE\xA5\xAF\xA9\x20\x49\x33", + "\xAD\xB5\xD0\xA9\xB4\xB5\xB1\xA5\xB5\x6D\xAA\xB4\xB4\xBE\x7B\x08\xB5\xAB\xA2\xB4\x05\xFC\x00\xB9\xD8\x3D\x0D\xB8\xBB\xB8\xB6\x39\xF7\x9E\x0E\xE4\xB9\xB6\xB5\xE9\x5F\x0E\x73\xCB\xBF\xAC\xEA\xBA\xB7\xB9\x34\x40\x13\x74\xF6\x95\xBA\xEE\x86\x21\x10\xDB\xAD\x26\x20\x61\xB0\xB6\xEB\x90\xBA\x8C\x83\x04\xBD\x77\xF1\xA1\x36\x42\x2A\xBF\xBA\x44\x85\x13\x7B\xE7\xBC\xBD\xE4\x82\xBF\xB6\xF7\xA1\xB8\x7E\xFB\xBA\xBF\xFE\xB1\x36\x10\x88\x67\x10\xE2\x08\x18\x71\x44\x22\x4A\x11\xF3\xBA\xB3\x22\x78\x8C\x10\x31\x4D\x12\x4C\x8E\x02\x4F\x23\x62\x40\x12\x3C\x91\x11\xC1\xBC\xB6\xBC\x7F\xBD\xB6\xB6\xFF\x9A\xC6\xC3\xD8\xB9\xC1\x88\xCA\xB2\x8C\x49\x18\xC4\xC4\xF5\xA3\xC5\x7E\x9C\xC2\xC4\xF3\x9A\xB3\x12\x88\x74\x10\xE2\x15\x18\x70\x4B\x22\x4F\x12\x27\xD4\x80\x26\x78\x89\x12\x31\x5A\x12\x4C\x9B\x02\x4C\x27\x62\x4D\x13\x1C\xDB\xC7\xC3\x2C\xDA\xAE\x27\x46\xCD\x57\x4F\x0C\xC9\xC9\x2B\xC8\xCA\x94\xA3\xC0\x14\xC4\x61\x10\x71\xA2\x08\x73\x28\x62\x44\x15\x27\xF8\x7D\x14\x78\x86\x16\x98\x27\x12\x4C\x54\x22\x49\x15\x62\x4A\x16\x97\xAA\xC7\xC8\x36", + "\xDA\x7B\x15\x6B\xCE\xC5\x8B\xDE\xB4\xBE\x85\x2C\x11\xCE\x74\xDD\xC0\x94\xED\xC2\xCE\x14\xE5\xB9\xCF\x98\x6D\x14\x9E\xA9\xCD\xCF\x28\xEE\xCB\x57\xAE\x03\xD3\x9F\x84\xDD\x37\x57\x0A\xD3\xBD\x8B\xD1\xD0\xA4\xEA\x30\x17\x47\xF0\xB8\xD0\x7E\xD3\xD3\xA5\x8C\xDC\xD2\x49\xDB\xD6\xD3\x1A\x51\x17\x89\xB2\x16\xD3\x3A\xDA\xD6\xD4\x9F\xC7\xD6\x9E\xD3\xCD\xCF\x59\x25\xD3\xD5\x87\xCC\xD4\xA6\xEF\x54\x17\x57\xF3\xCD\xD3\x09\x35\x16\xAD\x99\xD9\xD5\x5E\xE8\xD7\xD7\xB0\xC5\xD0\x9F\xB3\xD3\xD8\x5C\xC6\x26\x16\xBB\xC6\xD2\xB0\xA0\xCB\xD9\x3D\xCC\xDC\xD8\xBD\x57\x14\xE2\x38\x18\x71\x5C\x08\x72\x17\x62\x5B\x15\xB2\xCC\x5C\x16\x3C\xBD\x12\x4C\xBE\x02\x4F\x2F\x62\x40\x18\x31\x41\x1B\xDB\xCF\xC6\xDB\x40\x42\x18\x71\x61\x08\x74\x18\x88\x65\x1A\x98\x46\x18\xDD\x5D\x47\x18\x8F\xC8\x02\x4D\x32\x62\x4A\x18\x31\x4B\x1A\x4C\xCC\x15\xDE\xAC\xEA\xD1\xD8\x68\xCE\xDF\xE0\x03\xE0\xD5\xC1\x84\xE7\xD6\xF2\x0D\x18\x71\xCE\x08\x73\x33\x08\x70\x1A\x31\x51\x1A\xE0\xC9\x52\x18\x1E\xD3\x12\x4C\x6A\x22\x4D\x1A\x62\x56\x1A\x98\x57\x18\x8E\x6C\x22\x49\x1B", + "\x18\xED\xD9\xC2\xAA\xDD\xE0\x96\xFC\xD0\xD8\x72\x5A\x1A\x98\x5B\x19\xE4\x83\xEB\xE6\xD7\x0B\xEA\xE1\xCB\xB8\xEB\xE6\x98\xEF\xE4\x46\xDC\x08\x71\x37\x08\x7E\x1A\xC4\x5F\x1A\x4C\xE0\x15\xE7\x90\x61\x18\x8E\x71\x22\x4B\x1C\x62\x44\x1E\x98\x65\x12\x4C\x73\x0A\xEA\xE7\x3F\xFD\xE5\xCE\xAE\xEA\xD8\x9B\xF1\xD7\xEB\x2A\xE0\xED\x6F\x67\x18\x70\x74\x08\x71\x1D\x88\x6A\x1E\x98\x6B\x17\xEA\xF5\x2C\x18\x8F\xED\x02\x4E\x3B\x62\x4F\x1C\x31\x70\x1A\x4C\xF1\x18\x8E\x3C\x62\x43\x1F\xB6\xFC\xE1\xEB\x80\xFD\xE8\xC3\x81\xF5\xD8\xAC\xC2\xF6\xF0\x85\xFC\xEA\xF5\x74\x1E\xEE\x9F\xF5\x1A\x4C\xF6\x0D\xF3\xD6\xFF\xE7\xF0\xC5\xE9\xD8\xF1\x97\xF6\xF0\xC2\xC9\x57\x1E\xC4\x78\x18\x71\xF9\x08\x72\x3E\x62\x4B\x1E\xC9\xF2\x4C\x1F\x78\x9D\x1E\x98\x7E\x1E\x4E\x31\x40\x02\x2D\x02\x30\xF5\xEC\xB2\xFF\xF4\xCC\xDB\xF1\xEC\xB8\xFE\xE9\xEE\x83\xF5\xF2\xCA\xC6\x3A\x00\xB4\xF4\xF4\xE1\x99\xFE\xF6\xE2\xFE\xE5\xF7\xC7\xE9\xF1\xF1\xB7\xFA\xF7\xE6\xFC\xF2\xF9\xC9\xFD\x57\x00\x41\xF6\xF7\x9B\xD1\xFC\xF9\xCF\xE6\xFB\xE4\xD7\xF6\xFB\xED\xDE\xFA\xEB\xE0\xE3\xF8", + "\xF6\xD5\xF3\xC4\x02\x14\xFE\xE5\x05\x07\xFF\xF2\xDD\xF1\xFC\xE4\xDF\xFA\xFC\xEC\xF0\xFE\xD8\xD9\xF3\xFC\xCD\xF1\xFE\xFD\xED\xE6\x3A\x01\x6A\xFC\xFB\xF9\xE4\xFB\xF7\xFF\x7E\x7C\x01\x8D\x12\x07\x0C\x7F\x0B\x16\x80\xF9\x7A\x7D\x09\x85\x7F\x70\x29\x00\x08\x83\x27\x0A\x0F\x80\xC3\x1B\x00\x12\x86\x1C\x0C\x0F\x80\x0D\x05\x81\x0A\x8B\x3A\x0E\x0A\x81\xBB\x2F\x00\x0F\x80\x01\x0F\x81\x01\x0F\x82\x01\x0F\x83\x01\x1E\x87\x7F\xD0\x7F\x7E\xF8\x72\x7F\x00\x86\x7F\xFE\x70\x83\x2F\x8B\x7E\x31\x84\x83\x33\x8D\x7F\x44\x44\x01\x29\x83\x62\x15\x0B\x83\x37\x8C\x82\x2B\x82\x27\x16\x0E\x83\x02\x82\x83\x45\x86\x83\x47\x88\x83\x49\x80\x84\xAF\x17\x01\x44\x84\x7F\x2A\x8B\x5A\x18\x0F\x84\x03\x85\x85\x46\x80\x85\x35\x8A\x84\x58\x89\x2E\x19\x04\x85\xEB\x4A\x01\x5E\x88\x84\x5B\x8B\x84\x0B\x81\x85\x0C\x8A\x85\x56\x82\x86\x69\x8E\x73\x1B\x01\x86\x39\x5C\x01\x6E\x8C\x84\x67\x8F\x7E\x1D\x01\x87\x65\x89\x85\x72\x89\x1A\x1E\x06\x87\x2E\x84\x86\x7D\x83\x86\x80\x8B\x86\x79\x8C\x43\x1F\x0C\x87\x2D\x87\x88\xD6\x30\x02\x86\x81\x84\x7F\x82\x88\x77\x8F", + "\x83\x8F\x8E\x87\xEF\x21\x02\x8B\x8A\x3D\x22\x05\x89\x73\x81\x89\x81\x87\x85\x8E\x8D\x88\x9C\x8F\x89\x6A\x80\x8A\x7C\x33\x02\x98\x88\x3F\x24\x05\x8A\x78\x8A\x89\x9D\x88\x88\x1B\x8D\x82\x25\x08\x8A\x90\x8E\x89\x5C\x56\x02\xB0\x82\x89\x8C\x8C\x8A\x99\x82\x8B\x68\x82\x8A\x02\x17\x02\xB5\x82\x38\x28\x0F\x8B\xAB\x87\x8B\xC4\x8D\x8A\xC5\x89\x8B\xB8\x86\x86\xCA\x89\x8A\x73\x29\x02\xC2\x83\x36\x2A\x0F\x8C\xA1\x83\x8D\xBB\x84\x8D\x9A\x5B\x02\xD2\x85\x8D\xDA\x83\x88\x7D\x6C\x02\xD9\x8A\x39\x2D\x0F\x8D\xAA\x83\x36\x2E\x02\x8E\x7A\x5F\x02\xE6\x89\x8C\xCC\x8A\x8E\xB1\x83\x1C\x30\x0F\x80\x31\x09\x8E\xC7\x8B\x8C\xED\x83\x8F\xCC\x82\x03\xF2\x86\x8C\xFA\x88\x8C\xF6\x85\x8F\xFB\x84\x8F\xB6\x8A\x3D\x33\x09\x8F\xFC\x8F\x8F\xEB\x8D\x8F\x7E\x84\x03\x04\x90\x90\x9B\x86\x8D\xE3\x8E\x90\xBA\x8A\x59\x35\x0B\x90\x07\x96\x90\xFE\x85\x90\xB9\x86\x03\x0F\x87\x03\x0F\x88\x03\x14\x97\x91\x0C\x93\x8C\x16\x91\x90\x18\x91\x92\x2E\x79\x03\x1F\x94\x92\x26\x90\x91\xEC\x8E\x87\x3A\x0F\x80\x3B\x09\x92\x0D\x9B\x8D\x0F\x94\x93\x00\x0C\x03\x7C\x8D\x03", + "\x7C\x8E\x03\x7C\x8F\x03\x0F\x80\x04\x32\x98\x75\x41\x06\x8E\x42\x0F\x80\x43\x0F\x80\x44\x0F\x80\x45\x0F\x80\x46\x01\x94\xBC\x85\x93\xDC\x8A\x92\x23\x67\x04\x0F\x88\x04\x4E\x9C\x92\xD6\x39\x04\x57\x96\x93\x2D\x93\x93\x51\x9E\x95\x50\x91\x96\x00\x0A\x04\x0F\x8B\x04\x5B\x92\x10\x4C\x07\x96\x62\x9D\x95\x22\x99\x64\x4D\x0A\x96\x11\x9B\x96\x08\x90\x96\x71\x95\x97\x6C\x9F\x94\x76\x93\x97\x6D\x99\x5C\x4E\x06\x8E\x4F\x00\x97\xC3\x10\x05\x80\x9A\x97\x78\x97\x97\x58\x93\x92\x2D\x11\x05\x83\x9F\x1A\x52\x0B\x98\x49\x63\x05\x0F\x84\x05\x8E\x9B\x92\x5C\x94\x98\x87\x9B\x2B\x55\x03\x99\xAD\x16\x05\xE6\x87\x05\x0F\x88\x05\x9A\x90\x92\x15\x95\x92\xA3\x99\x5C\x59\x01\x9A\xBD\x1A\x05\xE6\x8B\x05\x0F\x8C\x05\xA8\x94\x97\x86\x95\x99\x88\x94\x1E\x5D\x0F\x9A\x7B\x95\x9A\xB8\x92\x9A\xE9\x2E\x05\x7C\x8F\x05\xB6\x95\x98\xD6\x3C\x01\xCE\x13\x17\x6F\x1F\x2E\x74\x11\x17\xC6\x95\x9C\xCC\x27\x9C\x9C\x19\x9C\xC8\x9B\x9C\xCA\x9D\x2B\xDF\x19\x10\x8E\x21\x17\xE6\x19\x10\x06\x3A\x3A\x13\x2F\x9C\x32\x13\x9D\x06\x1A\x2D\xD6\x9A\x10\x6B\x38\x14\x06", + "\x1B\x9D\xCD\x95\x13\xE6\x95\x1B\x4C\x2C\x9C\x03\x1C\x9E\xBC\x1E\x9C\xE7\x9D\x2B\xEE\x91\x1C\xF0\x9A\x9E\xD0\x9C\x9D\xBB\x23\x9F\xC4\x15\x9F\xEF\x97\x9F\xF1\x99\x9F\xD1\x9B\x2B\xDE\x93\x10\xC2\x7E\x13\xD7\x94\x9C\xE4\x93\x10\x07\xA3\x10\xC3\x98\xA0\xE5\x91\xA0\x2B\x13\xA0\xB1\x7F\x16\x0B\xA2\x10\xFA\x9D\x12\x15\xA1\x10\x0D\xAD\x9E\x0A\x19\x9E\xFD\x92\x13\xFA\x9E\x13\x3E\x1B\xA1\x34\x27\x17\xC2\x7E\xA1\xF4\x98\x9E\x10\xAA\x12\x21\xA2\xA2\x32\x14\xA2\x72\x2D\xA2\x2E\xA5\x2B\x32\xA3\xA3\xE9\x25\xA3\x36\xA3\x24\x38\xA3\xA3\x3A\xAB\xA2\x37\xAE\xA3\x09\x32\xA1\x01\x1E\x10\xB5\x19\xA1\x00\x0D\x32\x09\xA2\x10\x46\xA6\x33\x09\x1A\x9F\x28\xAB\x9F\x35\x12\xA4\x04\x14\xA1\x0A\x18\xA4\x49\xA5\x1E\x0A\x1C\xA4\x0E\xA3\x10\x4F\xA6\xA3\x2B\x1B\xA3\x2E\xA0\xA3\x73\x26\xA2\x1D\xA0\xA4\x5D\xAE\xA5\x29\x10\xA6\x22\xA2\xA6\xC3\x1A\xA6\xFC\x99\xA2\xF2\x90\xA4\x43\x27\xA6\x68\xAE\xA6\xFE\x96\x9F\xBD\x24\xA6\xAA\x3D\x12\xFA\x92\xA5\x11\x31\x9E\x09\x1C\x42\xAA\x36\xA4\x33\x4D\xA4\x65\xA8\x9F\x2B\x12\x7C\x8A\xAA\x10\x7E\xA4\xA5\x81\xA7", + "\xA5\x01\x14\xA8\x62\x24\xA7\x5E\xA6\xA7\x71\xA8\xA8\xC9\x26\xA9\x02\xA9\xA5\x8E\xA6\x10\x56\x40\xA9\x46\xA9\x46\x86\xA9\x10\x94\xA6\xA3\x52\xAA\xA5\x45\xAA\x10\x9F\xA7\xA5\xA1\xAA\x10\x4E\xA0\xA4\x9A\xA4\xA3\x72\xA4\x1E\xB1\xA9\xA9\xB3\xAA\x1E\xB5\xA9\x2E\x77\x12\xA6\xB9\xA9\x30\xBD\xAD\xA3\x98\xAF\xA3\xC1\xAE\xAB\xB7\xAC\x19\xFA\x9F\xAB\x6F\x12\xA5\x7A\xAB\xA5\x1F\xA0\xA0\xC3\xA0\xAC\xFF\x92\xAB\xCF\xA4\xAB\xC5\xAA\x21\xC8\xA8\xAB\xD5\xA4\x23\xD7\xA0\x27\xDB\xA6\xAD\xD9\xA1\x1C\xC7\xAF\xAD\xC4\x1A\xAC\x6F\x12\x7C\x52\xA0\x36\x9C\x16\xA4\x71\x4A\x9D\xE2\xA3\xA2\xAE\xAD\xAE\xBF\x70\xAF\xAF\x1D\xAD\xDA\xA2\xAF\xB1\x14\xAF\x31\xA6\xAF\xA9\x18\xAF\x73\x2C\xAF\x6D\xAA\xAF\xAD\x1E\xAF\xF1\xA3\xAD\xD8\xA4\xB0\xDC\xA0\xB0\xB8\x12\xB0\x20\xAF\xAE\x06\xB5\x1B\x52\xA2\xA5\xCF\x20\xA8\x06\x15\x36\x83\xAA\x10\x69\x39\x10\x52\xA5\xAA\x3C\xAD\xA9\x49\xAE\x13\x17\xAF\x16\xBC\xA8\xB0\xBD\x1A\xB0\xF7\xA2\xB2\x7C\xA6\xB2\x0C\xB1\xAD\xB6\xAD\xB0\xF5\xAC\xB2\xF9\xAE\xB2\xFD\xA8\xB2\xA3\xAA\xB2\x48\x21\xAE\x30\xBE\x13\x52\xAB\xA8", + "\x18\xBC\xA8\x0A\x1B\x29\x12\xB3\x10\x13\x3C\xAC\x91\xAA\x10\x7F\xA6\x10\x19\xB2\xB2\x62\xAB\xAC\x1C\xA7\xB3\x03\xB4\xB3\xC4\xAC\xB4\xF3\xA2\xB3\x42\xB0\xA5\x97\xAE\xB4\xD0\xA8\xA7\xCE\xA6\xB5\xD4\xA0\xB5\x25\xBC\xB5\x5F\xA9\xB2\x58\xBB\x22\x39\xB0\xB6\x02\x1F\xB0\x3D\xBC\xB1\x02\x11\xB4\x4B\xB6\x10\x46\xA5\xB4\x03\x17\xB4\x5E\xBA\x12\x49\xB5\xAE\x64\xB0\xA7\x59\xB1\xB6\x2B\xBA\xB5\xEA\x17\x17\xE4\xA1\x17\x36\xBA\xB7\x07\xB1\xB7\x09\xB2\xB5\x1D\xB1\xA5\x90\xA4\x1C\x7D\xAA\x10\x3A\x3F\xB3\x02\x1B\x46\x15\xB9\x10\x8E\xBD\x1C\x87\xAE\xB4\x24\xBB\xAF\x84\xB6\xA1\x97\xB1\x10\x95\xB1\xB0\x99\xB0\x00\x9B\xB3\xB8\x82\xB3\xB2\x9D\xBF\xB9\xA2\xB1\xBA\x7F\xB8\xB7\x48\x23\xB6\x90\xA2\xA6\x52\xAE\xB3\xE9\xA1\x11\x62\x2D\xB6\x0A\x12\xA6\x1A\xBE\xA2\x77\x17\xBA\xCD\xA2\xAD\x80\xBE\xAD\xA1\xB7\xB2\xBD\xB5\xB7\x54\xB7\xB7\xB9\xB9\xB7\xA8\xBF\xB4\xBB\xBD\xB2\xC7\xBF\xB2\xC9\xB8\xB8\xC0\xB8\xA6\xA9\xB7\xB8\x38\xB0\xBD\x35\x18\xBB\x76\xBA\xBB\xC5\xB7\xB5\xC3\xB2\xAC\xCB\xBF\xAF\xBF\xB3\xB3\xD7\xBB\xB5\xDB\xBD\xB4\xDF\xB5\xB0\xE1", + "\xB1\xB5\xA6\xBD\xBC\xCE\xBC\xB7\xD2\xBD\x9D\x3C\xB9\x10\x89\x2C\xB8\x01\x16\x2E\x67\x1A\x10\x46\xA4\x2E\x09\x14\xBB\x40\xA2\x7C\x2D\x16\xAE\x0A\x1F\x2D\xAF\xB9\x10\x90\x30\xAA\x15\x11\xBB\x0A\x11\xC0\x53\xB6\xA4\x92\x32\xB9\x09\x16\xA4\x06\xCF\xB6\xF4\xB3\xC0\x0B\xCF\xC0\x09\x17\x38\xA4\xA3\xB9\xC5\xBA\xBF\xAE\x7F\x16\xED\x1A\x3A\xC2\x7C\xBA\xFD\xB8\xB6\x01\x1D\xC0\x09\xA8\xC0\x04\xC0\xC0\xC0\xB4\xC2\xF7\xB2\xC1\x06\x12\xC2\x01\x12\xA5\x28\xCC\xB6\x2A\xC3\x10\x14\xCF\xA0\x15\xC3\xAC\x3A\xBA\xC0\x57\xAE\x13\x1B\xC9\xC3\x2A\xAB\xB3\x09\x1E\xBF\xA9\xA6\xC2\x02\xC9\x10\x09\xC4\xA0\x31\xC2\x10\x2C\xCE\xB9\x47\xC1\x10\x45\xC2\x10\x62\xAC\xC0\xED\xB0\xC3\x44\xCB\xC4\x58\xA3\xC1\x16\xC2\x10\xB5\xB2\xA2\xC2\x7A\x9F\x46\xA2\xA5\x40\xCC\x1B\x50\xC3\xC4\x06\x1D\xC4\x01\x12\x7C\x61\xC7\xC0\x10\xC8\xC3\x0A\xA5\xC0\x51\xCB\xC6\x53\xC1\xC1\x70\xC6\x10\x33\xCC\xA5\x57\xC5\xBD\x2A\x1B\xC5\x54\xC7\x17\x3B\xC4\xC7\xE7\xBE\xBD\xD9\xB6\xBC\xE3\xB1\xB8\xE5\xBD\xB5\x83\xC6\xB9\xDD\xB3\xB5\xCE\xB0\xC8\x7F\xC8\xBD\x76\xCA\xBD\x81\xCC", + "\xBB\x85\xCC\xA2\xE8\xB8\xA6\xEA\xBE\xC7\x8D\xCA\xC8\x97\xCC\xC8\xC1\xB6\xBD\x8B\xC0\xBE\x8F\xC8\xBC\x9F\xCA\xBC\xA1\xC1\xB3\x87\xCB\xB6\xA3\xCC\xBD\x91\xC9\xA6\x93\xCE\xA5\x95\xC8\xC8\xE9\xBE\xC9\x9D\xC4\xBE\xA7\xC2\xBE\xB1\xC2\xC8\xB3\xC6\xBE\xA9\xC5\xBA\xB9\xCE\xBB\xBB\xCB\xCA\x39\xA0\xCB\x99\xCF\x16\xD4\xBB\xC9\x40\x26\xB6\xD8\x90\xC2\x00\x0A\x40\x62\xC3\x10\x1A\x4C\xAE\xC3\xA2\xA5\xD9\x9F\xBF\x06\x1A\xCC\xAC\xAA\x10\xCD\xC3\xBF\x35\xC4\xB9\x40\xAC\xA6\x12\x26\xA6\xB0\xAB\xCD\xC0\xC4\xCC\x8E\xC5\xCB\x90\xC7\xCB\x84\xC6\xCE\x86\xCD\xCB\x96\xC2\xCE\x98\xCC\xCE\x9A\xC9\xC8\xEF\xCF\xCA\xB2\xC4\xCE\xBC\x13\xCC\xF0\xC9\xAC\xBE\xCB\xB1\xF3\xC1\xCC\xFB\xCE\xCE\xE1\xC7\xCF\xFD\xC0\xD0\xB6\xC4\xCF\xA2\xC4\xD0\xA4\xCA\xCE\xAE\xC4\xC9\xFF\xC2\xCF\xC6\xA9\xCF\xB6\xB8\xCF\x3E\xCC\xC3\x32\x16\xA4\x87\xB5\xC5\xD8\xC3\xB5\x59\xC1\xBD\x90\xA6\xA0\x15\xD4\xC5\x78\xC9\xCD\xC5\xBD\xAB\xDC\xCF\x1A\x4A\xB8\xC5\xDE\xC3\xAC\x22\xDB\xD0\x0A\xD1\xD0\x0C\xD5\xCE\x06\xD8\xCA\xE8\xCC\xB9\xA5\xC8\xB9\x33\xDA\xB9\xA3\xB7\xD3\x35\xDA\xC4", + "\x7D\xC9\xD0\xAC\xC0\xD1\x34\xCA\xCD\x39\xD8\xC1\xEB\xC7\x17\x5D\xCE\xD0\xFF\x05\xD4\xCB\xCA\xA4\x27\xC4\xC5\x2E\xCC\x1E\x54\xC9\xD1\x35\x17\xC3\x0E\xCB\xD1\x35\x14\xD1\x74\xB4\xD5\x2F\xA6\xD4\x6F\xAE\xCF\x2C\xDB\xD2\x03\xDC\xCF\x5F\xDC\xD5\x61\xD2\xD0\x2E\xD0\xD6\x65\xD2\xD6\x67\xD4\xD6\xA0\xCF\xD2\xD3\xBA\xD5\x50\x2D\xB7\x9C\x1E\xC1\x09\x1B\x2A\xF0\xB0\x00\x57\x39\xD4\x01\x18\xAE\x0C\xA4\xC5\x8B\xB2\xC5\x3F\xD1\xD3\x29\x10\xD7\xB5\x1F\xA4\xA4\xBC\xCB\x80\xDD\x1B\x52\xA4\xD7\xD2\xC3\x10\x77\xD5\xCD\x09\x1A\xD7\x4E\xCC\xD7\x4F\xD2\xB2\x4F\xAA\xC7\x6D\xCB\x10\xC8\xCA\xD8\x49\xA6\xA4\x11\xB8\xC6\x09\x14\xA4\x65\xB5\xC7\x68\xDC\x1B\x73\xB1\x17\x7B\xC4\xD3\x08\xD6\xCA\x6C\xDF\x1A\x52\xA9\x23\x8B\xD2\x10\x9A\xD3\xC2\x0A\x1D\xD9\xAA\xD3\xB4\x9F\xD7\xD9\x01\x10\xD5\x2D\x27\xDA\xE4\x9C\xD1\x58\xDF\x12\x52\xA5\xD8\x6E\xD2\x9D\x0A\x16\xBF\xAF\xD1\x10\xB1\x38\xD7\x00\x09\x3A\x18\xD2\xB2\x82\xD4\xDA\xEB\xBF\x12\x1F\xBE\xB7\xB8\xD0\x00\xC6\xD1\xC4\x06\x19\xDC\x8E\xD6\x10\xCC\xD5\xDB\x00\x0A\xDB\x2F\x22\xD4\x9C\x1F\xD1\xA9", + "\xD8\xDA\x87\xD4\xDE\x87\xD3\xDD\xE3\xD1\xDD\x5F\xBF\xDB\xED\xD2\xD1\x2F\x15\xDA\x9C\x15\xD9\xC8\xCD\xCA\x85\xB2\x13\xF4\xD5\xD7\xC2\xDB\xCE\x6A\xD5\xD0\x66\xDB\xD6\xFF\xDE\xDF\xA3\xD2\xE0\xFD\xD7\xD0\x87\xD6\xD8\xAB\xD7\xCE\x09\xE9\xCE\xE9\xD3\xDC\x2F\x2F\xDC\xC1\x19\xDF\xC7\xD0\x00\x52\xA2\xBF\xD8\xD7\x3C\x87\xB6\xA4\xB5\x3F\xB8\xE6\x3B\xD4\x09\x16\x40\x11\xDE\xC6\x06\x13\x3E\x09\x1C\xDB\xDF\xDF\xCD\x39\xD4\xBA\xE8\xDB\xE0\x32\xD9\xCB\xEA\xD5\x1B\x21\xB9\xE2\x38\xD5\xDE\x36\xD2\xE3\x36\xE9\xCB\x2B\xE1\xE0\xCC\xB1\xE2\x02\x16\xA5\x17\xE2\x10\x48\x4C\xE1\x03\x16\x43\x3C\xE6\xDB\x06\x14\xE4\x7E\xDC\xC7\x40\xD4\xE3\x3A\xD8\xE3\x0E\xEB\x22\x89\xB9\x10\x3E\xE0\xC6\x0A\x11\xE4\x17\xD2\xE2\x43\xE5\xDD\x46\xA8\xE4\x58\xE6\xD2\x28\xD3\xE3\xE7\xDF\xE4\x40\x2F\xE2\xF5\xCC\xDE\x72\xB3\xBB\x57\xDC\xD3\x36\xAD\xAB\x29\xD4\xDD\x29\xCE\xE6\x6A\xE3\xA3\x23\xD1\x1B\x73\xEF\xDE\xDE\xD9\xC8\x75\xE7\xC7\x68\xE1\x17\x1D\xCE\xD3\x77\xEE\xBC\x6D\xED\xD0\x6F\xE2\xE8\x6A\xCC\x1B\x7D\xE1\x17\x62\xA9\xE7\x29\x17\xE8\xEB\xD3\xE8\x30\xEB", + "\xE7\x8D\xE5\xE8\xE0\xA2\xE6\x29\x1A\xE8\xBD\x16\xE9\x46\xA8\xE9\x90\xEE\xB0\x9B\xEC\x1B\x52\xA6\xE9\xFA\x90\xEA\x9D\xE1\x1C\x26\xE1\xE8\x9C\xEE\xE8\x86\xE3\xEA\xC4\x1C\xE8\xA7\xE2\xE9\xC4\x19\xE9\xC8\xCE\x07\x64\xED\xD1\x39\xE0\x00\x72\xD7\xE5\xE6\xD1\xD9\x45\xE5\x7B\xEB\xC7\xEB\x53\xD6\xB4\x5A\xE4\xC5\xB0\xEB\xEB\xBE\xEA\xEB\xC0\xE5\xE2\xD5\xD6\xE2\x52\xAA\xEC\xC0\xB5\xEC\x35\xEE\xEA\xC1\xDA\xEA\x70\xB3\xB5\xCE\xE7\xE2\xBD\xE5\xDD\x84\xD2\xED\x0A\x1E\xDA\x03\x11\x26\x09\x1C\xED\x02\x1E\xED\x06\x10\xEE\x01\x12\xEE\x03\x14\xEE\x00\x06\xEE\x98\xD9\x10\xEA\xE8\x23\x0A\x1D\xEE\x00\x08\xEE\xF0\xE2\xEF\xDB\xEF\xEE\xF5\xEC\xEE\xF7\xE6\x10\xF0\xED\x27\x09\x1C\xEF\x06\x1F\xBE\xFF\xEA\x10\xD5\x96\x10\xAE\xB3\x10\xA0\xD5\xEE\x02\xF7\xB6\xB7\xD8\xEF\xD4\x9A\xF0\x06\x17\xF0\xE9\xE9\xF0\x09\x15\xF0\xA6\x2C\xF0\x06\x13\xF0\x03\x14\xF1\x43\xA6\xEF\x0D\xF3\xF1\x0D\x1C\xF1\x17\xFE\xF0\x06\xF0\xF2\x03\x18\xF1\x02\x1A\xF1\x53\xA6\xF1\x25\xF2\xF2\x15\xFA\xEF\x12\xF4\xF0\x1F\xFA\xF2\x02\x16\xF2\x01\x18\xF2\x10\xF0\xEF\xB1\xD5\xF3", + "\x31\xFE\xF2\x73\xDC\xF2\x1B\xF2\xF3\x01\x19\xF3\x00\x06\xF3\x24\xF0\xDB\x3E\xF9\xF2\x3C\xF6\x10\x42\xF4\xF4\x40\xF0\x00\x4B\xFB\xF3\xDD\xEA\x10\x4F\xFB\xF0\x49\xF3\x10\x53\xFF\xF0\x45\xF1\xF4\x47\xF7\xF3\x52\xFB\xF5\x59\xFE\xF4\x5E\xFD\xF4\xB4\xD7\xF2\x50\xF1\xEE\xB3\xD1\xF6\x55\xF2\x10\x63\xFA\xF3\x54\xF1\xF5\x09\x1B\xF6\x43\xF5\xF6\x08\xFF\xF6\x68\xFE\xF6\x06\x10\xF7\x4C\xF9\xF6\x01\x18\xF7\x72\xF1\xF1\x74\xFE\xF1\x6D\xF6\xF6\x7F\xF0\xF3\x81\xF3\xF7\x77\xF5\xF7\x82\xF7\xF8\x80\xF8\xF5\x4D\xF0\x9E\x7F\xD9\xEB\x1A\xA5\xDD\x8E\xFA\xE4\xDE\xD5\xED\x93\xFE\xE5\xD4\xE5\xDD\x5F\xC9\xDB\xCD\xEA\xF9\xA2\xD1\xEA\x9E\xF0\xD2\x90\xF6\xEB\xD5\xD7\xDD\x64\xF5\xF8\x7E\xF6\x10\xA6\xFC\xF6\x8C\xFA\xF7\xD6\xD8\xF8\x86\xF3\x10\xAB\xF1\xF7\xA8\xF0\xEF\xB3\xF9\xF7\x76\xF2\xFB\xB0\xF9\xFA\xBA\xFB\xF8\x23\xFD\xF4\xB7\xFD\xF7\xB6\xFB\xFB\xC3\xFE\xFB\x2D\xF9\xFB\x02\x11\xFC\xB5\xFA\x10\x16\xE7\xFA\xAD\xF8\xFC\xF1\xB4\xFC\xCC\xF2\xFD\x09\x1D\xFC\xAC\xFF\xFB\xAE\xF6\xFD\xB4\xFF\xFC\x89\xF3\x10\xDA\xF8\xFB\xDD\xF2\x10\xDF\xF2\xFC\xD3", + "\xF6\xFC\x3F\xF9\xFD\xD4\xFF\x10\xE9\xFE\xFD\xEB\xF2\x10\xD1\xC9\xF1\xE4\xF7\xCC\xE6\xF8\xF4\xD0\xF0\x00\xEF\xFE\xFC\xD8\xF5\xFF\xF7\xF7\xFD\xC7\xF1\xFE\x01\x1B\xFF\xDB\x79\xFF\x7E\x7E\xFB\x7D\xFE\x7F\x7D\x01\x84\x80\xF3\x7C\xEB\x72\x7E\xC2\x7C\xFD\x31\x7E\xFB\x67\x80\x00\x80\xFC\x4E\x81\x80\x0E\xB6\x78\x7D\xFF\x73\x80\x00\x05\x02\xBC\x7F\xF3\x75\xFF\x1A\x81\x00\x97\x80\xBC\x7A\x20\x1E\x80\x09\x81\x02\x94\x83\x01\x83\x81\xF1\x7E\x20\x28\x81\xE5\x70\x31\x27\x82\x0B\x89\x80\x5F\x7B\x05\x8D\x81\x12\x84\x03\xF0\x76\x0D\x9F\x7A\x37\x85\xE9\x79\x80\xD7\x7A\xB6\x69\x58\xEC\x49\x08\x3D\x81\x20\x01\x82\x00\x03\x04\xC5\x83\x0F\x86\x08\x46\x84\x05\xB3\x80\x78\x7A\x00\xCB\x81\x0A\x82\x80\x18\x85\x09\x90\x82\x1A\x82\x05\xA0\x80\x13\x9F\x7A\x53\x70\x03\x99\x82\x1A\x8B\x05\xF0\x75\x17\x95\x52\x58\x81\x0C\x8D\x7B\x2F\x82\xE5\x62\x82\xEB\x64\x83\x0C\x83\x0A\xB0\x76\x12\x8B\x06\xCF\x82\x05\x9C\x80\x03\x84\x0D\x87\x80\x39\x80\x03\xCD\x78\x1D\x89\x83\x56\x87\x00\xA8\x55\x37\x84\xFF\x03\x83\x1E\x9B\x80\x7D\x80\x03\xBF\x83\x0F\x80", + "\x07\x82\x86\x1E\x87\x84\x75\x86\xF5\x43\x85\x3B\x83\x10\x0B\x86\x1B\x81\x08\x8E\x82\x09\x8D\x84\x44\x88\x07\x85\x84\x0D\x9D\x6B\x8C\x6B\x22\x0A\x08\x8A\x56\x10\x17\x5A\x41\x03\x4F\x72\x64\x53\x49\x85\xFA\x73\xC7\x02\x09\x24\x8E\x82\x56\x61\x21\x27\x84\x35\x8A\x10\x25\x84\x24\x87\x80\xAE\x80\x00\x2B\x85\x3C\x89\x0A\x86\x0B\x2C\x96\x84\xF0\x71\x16\xB7\x85\x40\x84\x03\xBA\x84\x2C\x82\x85\x95\x84\x17\xB9\x84\x60\x80\xFF\x12\x86\x40\x1E\x85\xA3\x83\x00\x89\x63\x65\x89\xC6\x03\x08\x19\x6B\x6E\x0A\x0D\xBB\x42\x08\xED\x63\x10\x54\x87\x34\x8A\x08\x1B\x76\x20\x19\x87\x81\x0B\x0D\x82\x08\xF2\x09\x08\xDF\x86\x20\x21\x87\x24\x54\xE2\x57\x52\xA5\x75\x68\xF4\x03\x3E\x6C\x74\x81\x06\xE2\x43\x0F\x39\x80\x5E\x1E\x86\x1D\x8A\x09\x7A\x0A\x0E\xE2\x13\xEC\x72\x87\x09\x0E\x1E\x35\x86\x48\x58\xF2\x78\x86\x41\x17\x07\xFB\x87\x4A\x40\x78\x0D\x1D\x12\x78\x05\x40\x86\x62\x09\x0F\xF2\x72\x13\x96\x09\x0F\x07\x8A\xB1\x63\x08\x49\x63\x38\x2D\x08\x7D\x03\x9F\x2F\x55\x42\x1E\x84\x04\x8A\x21\x3C\x06\x87\x81\x10\x26\x70\x39\x2A\x0F\x62\x55\x1F", + "\x1C\x88\x0A\x76\xCD\x64\x0D\x4B\x1E\x07\x23\x8A\x4A\x57\x67\x8C\x88\x12\x23\x88\xBC\x74\x66\x2C\x88\xD5\x7C\x75\x71\x7A\x10\x09\x28\x48\x89\x0A\x30\x57\x44\x4A\x09\x80\x27\x13\xCD\x51\x4E\x9F\x7A\x5C\x75\x44\x73\x5D\x9F\x8D\xF4\x11\x5D\x4C\x8F\x5B\x44\x89\xC9\x42\x09\x75\x50\x27\x18\x51\x52\x9D\x72\x76\x26\x24\xAC\x0F\xA7\x83\x00\x80\x27\xDE\x5D\x50\x54\x88\x03\x8C\x25\xAB\x8F\xED\x59\x88\x0D\x98\x24\x5C\x8A\xDF\x5E\x8A\x78\x7A\x4A\x3D\x88\x9C\x06\x71\xE1\x21\x2C\x83\x08\x05\x0E\x15\xCF\x51\x3F\x2A\x8B\x02\x0B\x01\x23\x8A\x85\x03\x58\x70\x89\x40\x0C\x00\x30\x52\x3F\x7E\x77\x81\x0A\x54\x76\x88\x41\x1E\x8A\x7B\x8A\x20\x3D\x8B\xA6\x82\xF5\x00\x8E\x42\x14\x2A\x7E\x88\x02\x06\x8D\x84\x08\x18\x84\x8D\x42\x8B\x8C\x06\x0F\xAF\x3E\x8A\x09\x00\x19\x83\x0A\x64\x8E\x8C\xAA\x7E\x2B\x83\x88\x81\x07\x59\x7E\x88\x05\x1E\x8A\x34\x78\x00\x12\x2E\xBF\x85\x01\x79\x89\x75\x60\x2F\x7E\x8F\x02\x1E\x8A\x29\x58\x1A\x98\x8F\x40\x18\x00\xA0\x8A\x21\x23\x8C\xD7\x86\x0A\xB1\x8D\x42\x1A\x2E\x7E\x8A\x03\x36\x8C\x83\x08\x1B\xB4\x8D\x40\x1B", + "\x00\x5E\x88\x0C\x22\x6E\xCC\x7C\x37\x08\x73\x42\x86\x6A\x9A\x62\x4D\x55\x68\x29\x5F\x2E\x51\x75\x3F\x79\x62\x43\x15\xD4\x47\x5D\x5A\x7A\x1C\xE4\x0C\xBA\x7A\x4F\x52\x6B\xF4\x4C\x8E\x66\x11\x18\xCF\x76\x77\x6B\x87\x65\x61\x6E\x21\x8D\x77\x8B\xEB\x05\x50\xB3\x02\x7A\xE4\x8A\x29\xA1\x8F\xB1\x1B\xF9\x33\x8A\x86\x06\x71\x46\x57\x5D\x33\x7C\xF3\x8F\x1A\x4F\x50\x74\x84\x0F\xDA\x78\xF4\x7B\x75\x6C\x73\x36\x1E\x82\x45\x87\x76\x8F\x7D\x85\x71\x1B\x2D\x8A\x9F\x1B\x8E\x80\x9F\x76\xA2\x6F\x5D\x18\x85\xD1\x72\xF4\x42\x3F\x75\x91\x1B\x90\x6E\x3B\xAA\x7A\x31\x18\xEE\x5B\x8D\xAF\x18\x88\xA3\x7A\x21\xAE\x8E\x81\x0D\x1D\xD6\x74\xF0\x11\x85\xFA\x4D\x3D\x82\x3F\x0E\x95\x1D\xEA\x0F\x33\x9A\x4F\xF3\x8A\x21\x1D\x90\x0B\x9B\x2B\x56\x86\x84\x91\x7E\xAA\x1E\x40\xB4\x81\x77\x13\x0E\xA1\x6E\x7A\x12\x91\xA1\x8F\x5D\x30\x88\x76\x84\x1E\x21\x8D\x87\x8F\x17\xAB\x50\x21\xB0\x12\x94\x70\xEF\x6F\x16\xA8\x58\x75\x72\x10\xE5\x79\x90\x66\x16\x14\x8F\x88\x8D\x10\x78\xF7\x8A\x3D\x0C\x8A\xEF\x60\x00\xFA\x4C\xC4\x65\x91\x70\x17\x8E\x2B\x67\x21\x86\x25", + "\xD5\x6F\xBB\x1C\x23\xEB\x63\x10\xBA\x4E\xB8\x71\x25\xF0\x12\x55\x93\x5A\x8D\x6E\xBB\x70\x7A\x2C\x9A\x21\x5B\x8B\xD4\x5C\x84\x6A\x96\x4B\x8C\x16\xB0\x83\xB5\x20\x86\x77\x7A\x90\x42\x7F\x5D\x1C\x25\x5D\x73\x1C\x1A\x91\x7B\x8F\x17\xA6\x20\xD9\x6A\x0F\xF6\x80\xF7\x6F\x17\x37\x34\x2D\xAD\x0B\xF6\x79\x92\x66\x19\x16\xC8\x93\x9C\x13\x7D\x7F\x94\x59\x1F\x88\x57\x73\x1C\x5A\x7D\x99\x9A\x10\xFB\x23\x9D\x49\x62\x31\x59\x1F\xF1\x1B\x3F\x2B\x67\x2E\x94\xF4\x55\x7E\x39\x9D\x2B\x03\x2B\xD4\x45\x87\x7B\x6D\x05\x8B\x80\xBE\x16\x13\x8E\x97\x70\x03\x82\x83\x87\x5D\x0B\x29\x38\x78\x1B\x43\x81\x9A\x9A\x1C\x0F\x2C\xBF\x46\x0F\x41\x8B\x20\x98\x1F\x44\x28\x94\xB8\x0D\x57\x87\x53\xB8\x13\x52\x71\x62\x86\x17\x95\x01\x0B\x0B\xAF\x16\xA1\x26\x2C\xB4\x11\x84\x9E\x90\x7C\x1E\xA9\x2B\x67\x1D\x97\x20\x86\x0B\xB3\x8C\x93\x34\x12\xAA\x2B\x67\xA0\x85\x2D\x83\x0B\xB3\x8C\x91\xB5\x16\xAA\x2B\x67\x26\x9D\x2D\x82\x08\x86\x81\x08\x70\x92\x73\x33\x2A\x3E\x96\x1C\x76\x92\x40\x09\x97\x98\x1D\xB0\x00\x90\x0D\x11\x0B\xAC\x27\xD8\x0F\x2C\xEB\x64\x8E\x2B", + "\x67\x58\x80\x26\xC0\x1F\x64\x2B\x67\x7A\x23\x5F\x8A\x08\x41\x23\x36\x1D\x8F\xD4\x5E\x23\x02\x98\x1C\xB1\x1B\xD9\x23\xB5\x04\x9B\xD4\x51\x85\x6F\x23\x6C\x04\x2F\x75\x66\x49\x09\x9B\x27\x91\x1B\xCD\x28\x58\xBD\x0D\x58\x81\x2A\xEF\x17\x6C\x9E\x6E\x9A\x26\x62\x83\x08\x2B\x7C\x37\x2D\x8E\x77\x7E\x24\x22\x9A\x20\x2D\x23\xB1\x19\x5E\x6B\x64\x29\x29\x99\x01\x0B\x4F\x80\x1E\xF9\x2B\xCE\x28\x24\xCC\x80\x00\x28\x98\x78\x02\x31\x75\x66\x2F\x8F\x9A\x42\x01\x94\xC0\x1E\xC0\x2B\x67\x64\x2A\x29\xAD\x85\xDC\x0B\x30\x1A\x9D\x25\x0F\x87\x9E\x9C\x37\x0D\x32\xAE\x8F\x0D\xCF\x85\x5F\xBC\x1B\x08\x3F\x34\xB1\x0F\x33\x8E\x98\x7C\x1D\xC2\x15\x9B\xD4\x0F\x0C\xB5\x90\xE6\x06\x31\x5B\x9D\x35\x0F\x87\x88\x90\x3C\x32\x31\xD8\x98\x0D\xCF\x85\x63\x8C\x16\x1B\x37\x36\xBD\x0F\x33\x84\x99\x9A\x1B\xC7\x2D\x9A\xA5\x9A\x10\x2B\x98\xF0\x1F\x31\x73\x9D\x19\x82\x08\x99\x9C\x37\x43\x31\xDE\x8F\x63\x06\x09\x67\xBC\x1B\x25\x3F\x37\xE3\x63\xCF\x91\x1B\x55\x35\x70\x95\x86\x6C\x81\x37\x59\x31\xD2\x8C\x9C\x09\x0A\x1A\x98\x1D\x2D\x32\x13\xF3\x12\xD7\x80\x00", + "\xE7\x1B\x6C\x22\x33\xC7\x9A\x30\xAA\x85\xDC\x04\x33\xEB\x65\x51\x82\x92\x0C\x79\x10\x48\x97\xEA\x08\x33\xEB\x63\x52\xA3\x9D\x5E\x44\x0C\x9A\x1C\x9C\x2B\x67\xF0\x26\x51\xA8\x94\xAB\x11\x37\x02\x37\x3A\x74\x27\xAA\x19\x73\x86\x08\xA6\x9A\x39\x0E\x37\x3A\x79\x94\xF3\x92\x20\x3A\x9D\x81\x02\x35\x9A\x1E\xA8\x2B\x67\xA6\x97\xD7\x43\x09\xE1\x92\x10\x58\x9A\xE6\x0E\x35\xEB\x65\xA1\x3B\x74\xE6\x91\x10\x17\x9F\xBB\x1A\x35\xEB\x65\x58\x81\x9F\x80\x04\x3D\x80\x00\xD9\x9C\x1B\xD2\x33\x9D\x40\x2B\xE9\x9A\x10\x6A\x99\xAF\x16\x36\xEB\x63\x30\x8A\x9E\xE1\x95\xE5\x71\x1A\xB6\x2B\x67\xDA\x93\x7B\x98\x9D\xBA\x91\x37\x5F\x37\x3A\x6B\x97\xF2\x9D\x7B\xBC\x9A\xCD\x13\x6E\x6B\x66\xBC\x8B\x9F\xDC\x9A\x21\x02\x9C\xCD\x17\x6E\x6B\x64\xBE\x99\x9F\x87\x9B\x6C\x2E\x37\x75\x66\x30\x80\xA0\x00\x00\x71\xDC\x69\x6E\x32\x36\x76\x9F\x1A\x54\x97\x03\xB1\x1B\xFB\x34\x73\x86\x09\x95\x8C\x3A\xE3\x19\xBF\x3A\xA0\xCC\x62\x21\x1D\x9F\x77\x1F\x6F\x20\xA2\x40\x02\x54\xBB\x99\x6E\x01\x39\x75\x63\x31\xF2\x9C\x0A\xA4\x9E\x71\x19\xE2\x2B\x67\xDE\x8E\x40\xAF", + "\xA1\xF3\x91\x1B\x15\x3B\x9D\x6E\x2F\x5D\x76\x43\xD5\x9D\xDC\x1A\x38\xEB\x64\xC0\x3C\xA0\x85\x0F\x3D\x9A\x1E\xC7\x2B\x67\x4E\x9E\x85\xA5\x9F\xB8\x12\x72\x6B\x66\xD6\x8A\xA2\x09\x08\x6E\x98\x1C\x93\x3B\xCE\x66\x98\x14\xA6\x08\x76\x9C\x6F\x32\x39\x75\x62\x37\xD7\xA3\x40\x1B\x9F\x98\x19\xE8\x2B\x66\xBF\x9E\x45\x82\x0B\x00\xB8\x1C\x45\x3B\x9D\x49\x9D\x32\xA1\x10\x40\x98\xDF\x09\x3A\xEB\x65\xCB\x3B\x75\x42\x51\x41\xE3\x1A\xD3\x2D\x96\x72\x14\x5B\x80\x00\x3A\xAC\x37\x64\x3A\x09\xA1\x08\x52\xA0\x00\x3D\xA1\xD5\x16\x76\x7F\xA0\x00\x01\x92\x02\x0C\x77\x98\x1C\xB4\x3B\xCE\x66\x33\xAE\x68\xA4\x01\x0D\x78\x98\x1C\xB6\x3B\xCE\x77\x33\x23\xA3\x98\x71\x19\xEE\x2B\x67\x4A\x37\x49\x9D\x9C\xF0\x15\x3B\xEB\x65\xD6\x1D\xA4\x83\x05\x44\x98\x1D\xDE\x2B\x67\xD4\x33\x94\x8B\x9D\xB1\x1D\x77\x6B\x65\xB7\x2A\xA5\x40\x71\x6E\x0F\x3D\x75\x65\x6E\x30\xA5\x40\x19\xA2\x9A\x1D\xF3\x2B\x66\x78\x36\x4B\x80\x00\x18\xAB\x1D\xA1\x3B\x9D\x79\x37\x5E\xA7\x46\xAB\x1D\xE9\x2B\x67\x2B\xA2\x7E\x90\xA4\x00\x0E\x46\x9A\x1E\xEA\x2B\x67\x39\xA2\x7E\x87\x93", + "\x81\x02\x39\xAC\x1C\x15\x63\x0E\xE4\x90\x00\x13\xA6\xCD\x16\x7E\x06\xA4\x2E\xA1\x08\xCB\xA7\x5D\x29\x3E\x43\xA5\x4A\xD0\x96\xE6\x1B\x3F\xEB\x67\x88\xAA\x8E\xEF\x98\x1C\xD6\x8C\xED\x3A\x4F\x28\x38\x8F\xAC\xA6\x0A\xAB\x2B\x11\x43\x3A\x69\xA3\xEB\xA3\x4A\x82\x09\x80\x90\x3C\x17\x42\x21\xBA\xA7\x01\x0A\x5F\x80\x1F\x0C\x46\x48\x82\xA8\xE5\x7A\x1C\x1D\x43\x9D\x50\x3A\x79\xA6\x50\xA3\x7F\xBB\x02\x41\xEB\x65\x90\xAB\xA7\x86\xA5\x2E\x98\x1E\x09\x4B\x67\x9A\xA3\x9D\x9A\x92\x83\x0C\x4F\xFC\x1A\x0E\x46\xA4\x1B\xAB\x20\x14\xA9\xD5\x1D\x83\x06\xA5\x47\xA2\x08\xD5\xA7\x5D\x03\x42\x7A\xA9\x1A\x12\xA4\x00\x0A\xA4\xAB\x18\x0C\x6B\x67\xBD\x3B\xEB\x2E\xAA\x4B\xAF\x17\x70\x43\x9D\x51\x3D\x9A\xA8\x49\xE3\x1B\x1E\x4B\x67\xA3\x3C\xA7\x9E\xA4\xC3\x1F\x4E\x8A\x08\xEB\x22\xAA\xA4\xA1\x6E\x17\x45\x75\x60\x7C\x48\xAB\x2A\xA0\x1E\xA7\x43\x9D\x68\xA6\xF9\x9E\x52\x81\xA4\x8D\x85\xAA\xFD\x74\xF6\x12\x52\x97\xAF\x4D\xAB\x1D\x30\x4B\x67\x09\xAC\xAA\x8A\x09\x5F\xAA\x23\xD8\xAA\x41\x17\xA8\x62\xA9\x21\x05\xA7\x77\x1E\x8D\x6B\x67\x4A\xA9\xAB\x06", + "\x0D\x99\x98\x1D\x72\x4B\xCE\x32\xAA\xFC\x88\x98\x75\xA0\x78\x2F\x46\x79\xA3\x1C\x67\x93\x40\x18\xAB\x7C\x1B\x22\x46\xA4\xE7\x91\x10\x30\xAB\xBB\x1A\x48\xEB\x67\xA7\xB2\x9E\xC2\xA0\x00\x37\xA8\xB3\x1E\x48\xEB\x63\xA9\x8B\xAD\x9E\xA0\x3C\x2F\x4B\x3A\x74\x45\xBB\x74\xB1\x96\x9E\x66\x18\x93\x53\x96\x56\xB4\xAC\x03\x0D\x9C\xAF\x16\x9E\x4B\x2D\x9F\xAD\x42\x0C\xAC\xE6\x9B\x57\x00\x4B\x71\x96\x5A\x86\x08\x63\xB6\xAA\xCC\x15\x28\x79\x97\xD6\xA3\x10\x0C\xAD\x57\xAF\x17\x49\x4B\x9D\x56\xAD\xC9\xA9\x10\x64\xA8\xB3\x0D\x4A\x14\x9C\xB6\xB7\xA0\xB5\xA1\x37\x56\x4B\x3A\x72\xAD\xBC\xA9\xAE\xB1\x1A\xB2\x45\x33\xC2\xAD\x40\x0E\x93\x03\x09\x64\x80\x1F\xB4\x46\x48\xD0\xAE\x40\x15\x98\xC0\x1F\x2D\x46\xA4\xEC\xA3\x10\x06\xAC\xB3\x1D\x4B\x43\x9E\xB9\x80\x00\xEE\xA2\x10\x0E\xAD\xAF\x02\x4C\xB0\x9A\xBC\xA4\xAF\x80\x0C\x58\xEF\x15\x63\x4B\x67\xEF\xAA\x7E\xAB\xAE\x00\x0B\x59\xA5\x96\x59\xA3\x08\x9C\x4B\xD7\x73\xAE\xD1\xAC\x2C\x79\xAF\xD4\x4A\x4D\xFA\xAB\x89\xA3\x1A\xD0\x4B\xCE\x3C\x4D\x80\xB1\xA2\x71\x18\xC0\x93\x5A\x31\x0A\x5E\xF4\x9F", + "\xD8\x0E\x4D\xEB\x66\x0C\x0D\xB1\xDE\xA1\x37\x06\xB3\xD4\x4A\x03\x13\xB1\x70\xB1\x1A\xE1\x8B\xCE\x6E\x01\x86\xA3\x08\x72\xAB\x75\x0C\xB1\x75\x62\x07\x62\xAC\x9D\x91\xAE\x71\x1C\x0C\x3C\x42\xE9\xA4\x4D\xF1\x19\x19\x02\xAF\xC3\x0F\x97\xA9\xA8\x66\x19\x06\x34\x3F\x8F\x86\x0E\xBF\xA2\x94\x23\x1B\x39\x07\x5F\xB4\x11\x31\xB3\xB1\xBD\x15\x0E\x36\xB0\xF2\x05\x4C\xBA\xB0\xF0\x1F\x03\x3D\xB2\x4E\x06\xB3\x81\x0F\x32\xC0\x1D\x20\x1C\x43\x4D\xB5\xC5\xA3\x1A\x41\x04\x7B\x45\x92\x71\x01\xB1\x40\xB3\x57\x0B\x05\x21\xBA\x1E\x21\xB3\x92\xBA\x1C\x95\x01\xC9\xB3\x12\x9B\x99\x57\xFC\x1B\x25\x1C\x43\x65\x8E\x20\x24\xB2\xBE\x18\x09\x7C\x40\x4C\xBE\xAE\xBD\x11\x13\x22\xB2\x3B\x02\x5E\xB0\xAA\x79\xBB\x15\x9B\x02\xCC\xBA\x03\x3A\xB0\x5A\x9A\x1D\x27\x02\xB3\x7E\x04\xCF\x83\xAA\xCD\x1F\x09\x62\xB0\x95\xBB\x75\x30\xAC\xBF\xBD\x15\x50\x02\x66\x86\x06\xA0\xB9\x6E\x71\x1B\x14\x22\xB2\x45\x0F\x68\xA3\x99\xDC\x05\x05\x62\xB6\x11\x15\xB4\x95\x9F\x39\xE2\xB2\x24\x1B\xB4\x31\x99\x6E\x29\x04\x31\xB6\x09\x20\xB4\xCE\x91\x1B\xAB\x02\xCC\x9A\x04\x53", + "\xB1\x62\xEF\x15\x2B\x02\xB3\x9E\x02\xBC\x85\x27\x14\xA3\x36\x2F\x06\x98\xA2\x05\x0F\x43\xD6\xB0\xA1\xB1\x11\x0B\x62\xB2\xA4\xAA\x1D\xBA\xB3\xB8\x80\x1F\x59\x02\x66\xA4\x05\xAE\xAA\x08\xF5\xAB\x57\x35\x04\x31\xB8\x69\xC0\xB4\x11\xB1\x1B\xB7\x02\xCC\xA6\x05\x63\xB9\x10\x29\xAD\xAD\x19\x05\x62\xB7\x14\x14\xB6\x83\x00\x5B\xBD\x17\x2E\x02\xB3\xA8\x03\xDB\x83\x09\xDB\xAC\x2C\x3D\x06\x98\xA3\xB5\xCE\xB4\xC2\xA3\x1B\x5F\x02\x66\xAA\x06\xB8\xA6\xA3\x71\x19\x18\x22\xB3\x54\xB9\x6E\xCA\xAE\x02\xA2\xB3\xAC\x05\x2C\x4A\x08\x38\xBB\x2B\x45\x06\x98\xAF\xB5\xAA\x1F\x50\x86\x09\x3B\xB5\x2B\x47\x06\x98\xAE\x05\xFA\xB7\xB4\x98\xA0\x31\xB6\x6B\x81\xB8\xB2\xB1\x1B\xCB\x02\xCC\xB0\x05\x84\xB9\x54\xE3\x19\x33\x02\xB3\xBD\xB6\xE1\x95\xB7\xB8\x1F\x0C\x62\xB2\x2C\x14\xB8\x96\xB3\x6C\x11\x06\x31\xB4\x6C\x9A\xB8\x16\xB1\x1B\xD3\x02\xCC\xB4\x04\x90\xBB\x37\xF1\x19\x35\x02\xB3\xCB\xB6\xE4\x83\x09\xB5\xAC\x2C\x57\x06\x98\xB6\x05\x2C\xBD\x8D\xB1\x1B\x6C\x02\x66\xD1\xB6\xEA\x02\x9D\x02\x0C\x68\x80\x1F\x6D\x00\x63\xC6\x0C\xD0\xA1\x08\x02\xBC", + "\x6F\x1F\x06\xDA\x3D\x0E\xC6\x0E\xEA\x81\xBA\x71\x1D\x1C\x3C\x43\xA7\xB8\x74\xF1\x1A\x39\x14\x3D\xE9\x8B\x20\x31\x9D\xEE\xA1\x37\x69\x06\x98\xB8\x05\x62\xB3\xEB\xA5\xAF\xB8\x1B\x0E\x62\xB2\x2E\x01\xBB\x7D\xB0\x73\x2D\x06\x31\xBC\x0B\x68\xBB\xA0\xB8\x1C\xEF\x02\xCC\xBE\x04\xB7\xB5\x71\xC0\x1D\x3C\x02\xB3\xC0\x04\xEE\x8F\xAA\xBE\x13\x0F\x62\xB2\x30\x1A\xBB\xB1\xA3\x6C\x35\x06\x31\xB4\x0C\x00\xBF\x2D\xB1\x1B\xF7\x02\xCC\x86\x06\xC3\xBE\x4B\xF1\x19\x3E\x02\xB3\xC8\x04\xF1\xB4\xB9\x5E\x1B\x0F\x62\xB2\x32\x0C\xBC\xAD\xB4\x59\x3D\x06\x31\xBC\x0C\x62\xB0\xF0\x9C\xBA\x6E\x1A\xCC\x8E\x06\xCF\xBA\x10\x04\xB9\xB2\x01\x00\x15\x8A\x21\x10\x06\xD2\xBA\x70\xE3\x1B\x00\x09\xBD\x09\x0A\x1A\x2C\xBC\x71\x81\x37\x05\x00\xEC\xA6\x08\xD4\x03\xF6\xA1\xAD\xB8\x17\x00\x37\xBF\x40\x16\x06\xBA\xBF\x1A\xA3\x1B\x04\x0E\x7B\x82\x08\x36\x01\xBE\x80\xA1\x6E\x0B\x01\xE2\xB1\x10\x5A\x04\xF2\xA0\x00\xE4\xB5\x57\x0D\x00\xE6\xB0\x00\x5C\x07\xF3\xBE\xAD\xBD\x17\x01\x14\xBE\x6F\x0F\x7C\x93\xBF\xAE\x11\x00\xD4\xB8\x1C\x0F\xBF\xCC\xBD\x2B\x13\x00\xF5", + "\xA2\x07\x62\xB7\x2D\x86\x08\xDC\x90\x3C\x15\x03\x7C\x40\x97\xAD\x0A\xFD\x83\x09\x4F\x90\x3C\x19\x03\x7C\x4D\xBA\x8C\x4A\x21\x1F\xBC\xCD\x1F\x01\x23\x8B\x70\x1C\x89\xEB\xB9\x6E\x20\x00\xFF\xB6\x1C\x00\xC3\xFC\xB1\x1B\x21\x03\x3E\x59\xBA\x81\x09\x3C\x89\xA5\xDC\x04\x01\xD4\xBC\x1C\x18\xBB\x8D\x05\x7A\xF1\x1A\x09\x14\xBE\xE7\x03\x02\xC9\x09\x06\xCC\x5E\xF1\x18\x0A\x14\xBE\xEA\x02\x03\xC6\x08\x0E\xC4\x5F\xF1\x1A\x0A\x14\xBE\x6B\xBD\x72\xA4\xC0\x45\xBB\x2B\x2C\x00\xF5\xB0\x07\x22\xC3\x20\x24\xC0\x6B\xB9\x2C\x2E\x00\xF5\xBD\xBB\x2A\xC5\x7D\xA3\x1A\x18\x04\x7D\xF6\x05\x0C\xCC\xC0\x0E\xB0\x78\x32\x00\xEA\xBF\x78\xB9\xC2\xBA\xA0\x1E\x34\x04\xFA\xBC\x07\x1F\xC1\x10\x24\xC2\xF7\xB5\x15\x36\x04\xFA\xBF\x06\x26\xC0\x00\x24\xC0\xF9\xBB\x15\x38\x04\xFA\x82\x00\x05\xC5\x13\x8A\x0B\x41\x23\x1B\x3A\x04\x00\xEF\x0D\x59\x93\x10\x5A\x9C\xDF\x1B\x01\x52\xC6\x38\x39\x94\x83\x01\x51\x63\x19\x0F\x09\xC3\xAF\x0D\x0D\xC6\x08\xE9\x90\x3C\x3F\x03\xFD\xA4\x0F\xBF\x94\x0D\xF1\x1B\x22\x00\x87\xB1\x0E\x19\xC2\x08\x6B\xC4\x6F\x07\x02\x31\xCE", + "\x87\x8A\x09\x1E\xDC\x1B\x48\x04\x10\xE9\x0C\x99\x24\x6B\xC0\x1D\x12\x14\xBE\xB6\xBB\xD7\x4C\xC5\x5D\xB0\x3C\x4B\x00\xF5\xA4\xBE\x92\xC1\xED\xAB\x1D\x26\x04\x7D\xD3\xBD\x26\xCF\xBB\xAB\x1F\x09\x14\xBE\xF0\xBF\x89\xF5\xB8\xDF\x11\x02\xD4\xBE\xFD\xA5\xC5\xBD\xBA\x39\x53\x00\xF5\xB6\xBF\xAB\xC1\xF0\x80\x1F\x2A\x04\x7D\x9D\x03\xFB\xBF\x08\x41\xC4\x6F\x17\x02\xEA\xB9\x80\xB1\xC5\xA8\xA3\x1B\x59\x04\xFA\xA5\x01\x5B\xC9\x10\x13\xC4\xBC\xA3\x1B\x5B\x04\xFA\xA9\x00\x62\xC6\x10\x46\xC6\xCE\xA3\x1B\x5D\x04\xFA\xAD\x00\x66\xC3\x10\x3E\x29\x42\x03\x9F\xC0\x1F\x0B\x0A\xC5\xD6\x08\x8D\x83\x09\x4D\x23\x1B\x60\x03\x3E\x71\x8E\xE3\x0D\x8D\x82\x08\xB3\x80\x1E\x65\x03\x1B\xF8\x0D\x73\xC3\x10\x46\x2B\xD8\x06\x03\xEA\xC5\x37\x2C\xC6\x81\x0F\x87\x98\x1F\x19\x14\xBE\x31\x03\x24\x84\x2B\x84\x05\x8F\xAB\x1D\x1A\x14\xBE\x43\xC2\x75\x2E\xC6\x83\x0F\x8D\xC0\x1F\x1A\x02\xC7\xE4\x0A\x7D\x82\x09\x81\xCC\x37\x70\x01\x3C\xCD\x09\x0A\xC9\x20\x3B\xC6\xE0\x11\x07\x0F\xCA\x42\x0C\x2A\x09\x0D\x20\xFC\x1A\x39\x08\x90\xEA\x0C\x46\xC6\x08\xD2\x90\x78", + "\x37\x02\x8B\xC9\x10\x21\xCB\x40\x11\x9F\x7C\x18\x0F\x24\xC8\x90\xCA\x10\x7D\xC7\xBB\x19\x03\xD4\xBB\x06\x23\x88\xA8\x2C\x8F\xF1\x1B\x1E\x14\xBE\x49\xC2\x75\x28\xC8\x81\x0A\x91\x9A\x1D\x1F\x1D\xC8\x70\x15\x31\xA7\xC9\xB8\x12\x08\x2B\xCB\x40\x02\xCA\x02\x0C\x26\xC0\x1F\x41\x06\x94\x82\x0A\xB8\x86\x08\xF8\x9C\x6F\x04\x05\xA6\xC1\x10\x4F\xC9\x19\xD1\x1B\x85\x04\xFA\xB5\x01\x91\x87\x56\x35\xCB\xD8\x07\x04\xD4\xB9\x0A\xEA\x1D\xA8\xCC\x93\xF1\x19\x22\x14\xC6\x34\x17\x32\x83\x08\xB2\xC8\x39\x0D\x04\x55\xC0\x00\x6A\xCA\x20\x1D\xCA\xE0\x1E\x08\x6F\xC9\x60\x29\x08\xD6\xC0\x78\x0F\x04\xBB\xC7\x91\xF1\x18\x24\x0F\xCB\x75\x8C\x20\xF1\x1B\x48\x08\x96\xF2\x11\x60\xC3\x08\x77\xC8\x78\x15\x04\xC0\xCA\x10\x56\xCA\xE6\x16\x04\x6F\xCF\x7F\x82\x09\xC5\x23\x36\x17\x05\x1F\xC9\x0D\x92\xC9\x20\x0D\x2D\xB1\x19\x09\x17\xCD\x6B\x19\xCC\x00\x07\x80\xBC\x1B\x4D\x0E\x99\xB8\x0C\x65\xC6\x08\x9B\xC8\x78\x1D\x05\xB7\xC7\x9A\x83\x0A\x68\xDA\x1C\x9E\x07\x2D\xE9\xCC\xD7\xC1\x37\x1F\x07\x5B\xCF\xCD\x01\x09\xB2\x23\x1A\x50\x07\x9B\x8A\x0B\x69\x23", + "\x1B\xA1\x05\x37\xC9\x09\xCA\x23\x36\x22\x07\x5B\xDA\xCD\x06\x0F\x5F\x80\x1F\x51\x0F\x96\xCA\xCF\x40\x1F\xCD\xC0\x1C\x14\x0D\xCE\x85\x04\x9C\xC0\x1D\x29\x0F\xCB\xD5\xC8\xF4\x80\x1E\x53\x04\x7D\xB7\x00\x50\xC3\x08\xD9\xCB\xEC\xA3\x1A\x54\x04\x7D\xBC\x03\x77\xC2\x08\xE1\xCD\x03\xE3\x1A\x55\x04\x7D\xC1\x03\x79\xC1\x08\xE9\xCD\x04\xE3\x1A\x56\x04\x7D\xC6\x03\x7B\xC0\x00\xF1\xCC\x05\xF5\x14\x57\x04\x7D\x96\xC6\x3C\xB1\xCF\x34\xC1\x5D\x30\x04\xEA\xB0\x05\x77\xCD\x7C\xDD\xB6\xBB\x12\x16\x14\xBE\x5A\xCF\x9F\xB9\xC6\xE6\x14\x05\xD4\xBA\x0B\x06\xD1\xB1\xA1\x37\x36\x04\xF5\xBA\xC6\x0D\xD4\xB8\xA3\x1A\x5C\x04\x7D\xE4\x03\x84\xC9\x08\x57\xC5\x56\x3A\x04\xEA\xBF\x8F\xF2\xA5\x03\xA2\x08\xD0\xCC\x6F\x3C\x05\xB7\xC7\xA2\xF0\xCD\xFD\x8F\xCB\x29\xD2\x20\x07\x2D\xB1\x1E\x0B\x73\x4F\xA5\x82\x08\x0C\x9B\x20\x2D\xCC\xCD\x15\x0C\x54\xBE\x1B\x03\x89\x39\xD2\x20\x33\xCC\xCD\x17\x0C\x54\xBF\x1B\x00\xD2\x0A\x0D\x85\xBC\x1B\x64\x05\x9A\xBD\x0D\x90\xC1\x08\xB8\xCB\x75\x0B\x06\xEA\xBE\x90\xAA\x1E\x92\xC2\x08\x19\x98\x78\x0D\x07\xB7\xC7\xA5", + "\xAF\x87\xD8\x0E\x06\xD4\xBD\x22\xD6\xD2\x85\x06\x3A\xEF\x14\x34\x14\xBE\x1C\xCA\x75\x07\x2E\xCF\x93\x36\x52\x04\xF5\xB3\x03\x23\x8B\x4D\xC6\x09\x32\xDC\x2C\x54\x04\xF5\xB4\x03\x23\x89\x4B\xFA\xD0\x26\xA4\x7D\xF5\x01\x9E\xCA\x08\x43\xD3\x8A\x94\xBE\x3B\x0F\xA7\x89\x09\x94\xCF\x17\xDA\x04\xFA\xA3\xC8\xD5\x1F\x31\x82\x0B\x6F\x23\x1B\xDC\x07\x3E\xC3\x0F\x46\xD1\x10\x3B\xD0\xE6\x01\x07\xD4\xBA\x25\xCC\xD4\x40\xD1\x37\x63\x04\xF5\xB0\xC9\x9B\xD6\x50\xD1\xBA\xEA\xBA\x07\x23\x88\x0D\xAE\xD4\x71\x1F\x1C\x12\xD4\xE3\x07\xAA\x95\xD5\xDC\x0C\x07\xD4\xBF\x26\xEA\x1D\x56\xD0\x00\x01\xD7\xEA\x0E\x07\xD4\xBC\x0F\x26\xD4\x85\x07\xA8\xCC\x14\x3C\x14\xBE\x3F\xCA\x75\x26\x98\x81\x02\xA7\xFC\x1A\x3C\x0F\xCB\xC3\xD1\x20\x3A\xD2\xCD\x13\x0F\x6F\xCB\x78\x3D\x68\x28\x08\x5A\xD2\xD6\x5A\x7B\xBF\x3D\x0A\xFE\x57\xD6\xD5\xD0\x78\x4D\x73\xB6\x07\xA1\x5D\xD6\x71\x91\x7C\xAA\x77\x1F\x09\x5A\x65\x5C\x1C\xE4\xD6\x77\x18\x50\xE8\xD0\x25\x14\x69\x75\xD9\xAE\x82\x96\xBB\xCD\x0B\x26\x70\x00\x31\xD7\x79\xDD\x12\x74\xD6\x53\x77\xD7\xEF\xD3\x20\x36", + "\xD7\x7C\xDC\x23\xF8\xD6\x41\x1B\xD7\xFF\xD5\x5E\xC2\xD8\x7F\xDA\xAF\x83\xD8\xBF\xDD\x88\x06\xD9\x60\xC4\xD9\x7E\xD7\xB0\xF2\xD5\xC2\xC5\xD8\x0B\xD8\x61\xD1\xD8\x87\xD3\xB1\x95\x6D\x97\x56\xD8\x04\x45\x25\x28\x77\x78\x7D\x13\x1B\xDA\xC7\xDA\xD8\x2D\x08\xDE\x73\x90\x91\xDD\x21\x80\x03\x8F\x85\xD9\x28\xDD\x25\x25\xD8\x19\x90\x00\x32\x93\x3F\x0C\xD9\x30\xDD\x25\x31\xD8\x44\x12\xB3\xB5\xD8\xCD\xD7\xD9\xEE\x5E\x66\xF9\xD8\x9C\xD1\xF0\x3C\xDB\x40\x0C\xD9\xA1\x88\x00\x39\x91\xA0\xD4\xB4\x8D\x16\xD1\xCF\x79\x21\x78\x69\xC5\x87\xF9\x7F\x0F\x28\x78\x21\x80\x84\x4F\xD9\x6A\xCE\xDB\x96\x00", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -13338,23 +10181,13 @@ namespace vl::glr::parsergen L"Cond2", L"Cond", L"SwitchItem", - L"Switches", - L"OptionalBody", L"TestBranch", - L"Token", L"Syntax0", L"Syntax1", L"Syntax2", L"Syntax", - L"AssignmentOp", L"Assignment", L"Clause", - L"Placeholder", - L"RuleName", - L"LriConfig", - L"LriContinuationBody", - L"LriContinuation", - L"LriTarget", L"Rule", L"File", }; @@ -13369,190 +10202,131 @@ namespace vl::glr::parsergen L"[2][Cond0]< \"!\" @ Cond0 >", L"[3][Cond0]< \"!\" Cond0 @ >", L"[4][Cond0]< ID @ >", - L"[5][Cond0]<< \"(\" !Cond \")\" @ >>", - L"[6][Cond0]<< \"(\" !Cond @ \")\" >>", - L"[7][Cond0]<< \"(\" @ !Cond \")\" >>", + L"[5][Cond0]", + L"[6][Cond0]", + L"[7][Cond0]", L"[8][Cond1] BEGIN ", L"[9][Cond1] END [ENDING]", L"[10][Cond1]< Cond1 \"&&\" @ Cond0 >", L"[11][Cond1]< Cond1 \"&&\" Cond0 @ >", L"[12][Cond1]< Cond1 @ \"&&\" Cond0 >", - L"[13][Cond1]<< !Cond0 @ >>", + L"[13][Cond1]", L"[14][Cond2] BEGIN ", L"[15][Cond2] END [ENDING]", L"[16][Cond2]< Cond2 \"||\" @ Cond1 >", L"[17][Cond2]< Cond2 \"||\" Cond1 @ >", L"[18][Cond2]< Cond2 @ \"||\" Cond1 >", - L"[19][Cond2]<< !Cond1 @ >>", + L"[19][Cond2]", L"[20][Cond] BEGIN ", L"[21][Cond] END [ENDING]", - L"[22][Cond]<< !Cond2 @ >>", + L"[22][Cond]", L"[23][SwitchItem] BEGIN ", L"[24][SwitchItem] END [ENDING]", L"[25][SwitchItem]< \"!\" @ ID >", L"[26][SwitchItem]< \"!\" ID @ >", L"[27][SwitchItem]< ID @ >", - L"[28][Switches] BEGIN ", - L"[29][Switches] END [ENDING]", - L"[30][Switches]\"switch\" @ { SwitchItem ; \",\" } \";\"", - L"[31][Switches]\"switch\" { SwitchItem ; \",\" @ } \";\"", - L"[32][Switches]\"switch\" { SwitchItem ; \",\" } \";\" @", - L"[33][Switches]\"switch\" { SwitchItem @ ; \",\" } \";\"", - L"[34][OptionalBody] BEGIN ", - L"[35][OptionalBody] END [ENDING]", - L"[36][OptionalBody]\"[\" @ Syntax \"]\"", - L"[37][OptionalBody]\"[\" Syntax \"]\" @", - L"[38][OptionalBody]\"[\" Syntax @ \"]\"", - L"[39][TestBranch] BEGIN ", - L"[40][TestBranch] END [ENDING]", - L"[41][TestBranch]< Cond \":\" ( Syntax1 @ | \";\" ) >", - L"[42][TestBranch]< Cond \":\" ( Syntax1 | \";\" @ ) >", - L"[43][TestBranch]< Cond \":\" @ ( Syntax1 | \";\" ) >", - L"[44][TestBranch]< Cond @ \":\" ( Syntax1 | \";\" ) >", - L"[45][Token] BEGIN ", - L"[46][Token] END [ENDING]", - L"[47][Token]CONDITIONAL_LITERAL @", - L"[48][Token]ID @", - L"[49][Token]STRING @", - L"[50][Syntax0] BEGIN ", - L"[51][Syntax0] END [ENDING]", - L"[52][Syntax0]< \"!\" @ ID >", - L"[53][Syntax0]< \"!\" ID @ >", - L"[54][Syntax0]< \"!(\" @ { SwitchItem ; \",\" } \";\" Syntax \")\" >", - L"[55][Syntax0]< \"!(\" { SwitchItem ; \",\" @ } \";\" Syntax \")\" >", - L"[56][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" @ Syntax \")\" >", - L"[57][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" Syntax \")\" @ >", - L"[58][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" Syntax @ \")\" >", - L"[59][Syntax0]< \"!(\" { SwitchItem @ ; \",\" } \";\" Syntax \")\" >", - L"[60][Syntax0]< \"+\" @ OptionalBody >", - L"[61][Syntax0]< \"+\" OptionalBody @ >", - L"[62][Syntax0]< \"-\" @ OptionalBody >", - L"[63][Syntax0]< \"-\" OptionalBody @ >", - L"[64][Syntax0]< \"?(\" @ TestBranch { \"|\" TestBranch } \")\" >", - L"[65][Syntax0]< \"?(\" TestBranch @ { \"|\" TestBranch } \")\" >", - L"[66][Syntax0]< \"?(\" TestBranch { \"|\" @ TestBranch } \")\" >", - L"[67][Syntax0]< \"?(\" TestBranch { \"|\" TestBranch @ } \")\" >", - L"[68][Syntax0]< \"?(\" TestBranch { \"|\" TestBranch } \")\" @ >", - L"[69][Syntax0]< \"{\" @ Syntax [ \";\" Syntax ] \"}\" >", - L"[70][Syntax0]< \"{\" Syntax @ [ \";\" Syntax ] \"}\" >", - L"[71][Syntax0]< \"{\" Syntax [ \";\" @ Syntax ] \"}\" >", - L"[72][Syntax0]< \"{\" Syntax [ \";\" Syntax @ ] \"}\" >", - L"[73][Syntax0]< \"{\" Syntax [ \";\" Syntax ] \"}\" @ >", - L"[74][Syntax0]< OptionalBody @ >", - L"[75][Syntax0]< Token @ [ \":\" ID ] >", - L"[76][Syntax0]< Token [ \":\" @ ID ] >", - L"[77][Syntax0]< Token [ \":\" ID @ ] >", - L"[78][Syntax0]<< \"(\" !Syntax \")\" @ >>", - L"[79][Syntax0]<< \"(\" !Syntax @ \")\" >>", - L"[80][Syntax0]<< \"(\" @ !Syntax \")\" >>", - L"[81][Syntax1] BEGIN ", - L"[82][Syntax1] END [ENDING]", - L"[83][Syntax1]< Syntax1 @ Syntax0 >", - L"[84][Syntax1]< Syntax1 Syntax0 @ >", - L"[85][Syntax1]<< !Syntax0 @ >>", - L"[86][Syntax2] BEGIN ", - L"[87][Syntax2] END [ENDING]", - L"[88][Syntax2]< Syntax2 \"|\" @ Syntax1 >", - L"[89][Syntax2]< Syntax2 \"|\" Syntax1 @ >", - L"[90][Syntax2]< Syntax2 @ \"|\" Syntax1 >", - L"[91][Syntax2]<< !Syntax1 @ >>", - L"[92][Syntax] BEGIN ", - L"[93][Syntax] END [ENDING]", - L"[94][Syntax]<< !Syntax2 @ >>", - L"[95][AssignmentOp] BEGIN ", - L"[96][AssignmentOp] END [ENDING]", - L"[97][AssignmentOp]\"=\" @", - L"[98][AssignmentOp]\"?=\" @", - L"[99][Assignment] BEGIN ", - L"[100][Assignment] END [ENDING]", - L"[101][Assignment]< ID @ AssignmentOp ID >", - L"[102][Assignment]< ID AssignmentOp @ ID >", - L"[103][Assignment]< ID AssignmentOp ID @ >", - L"[104][Clause] BEGIN ", - L"[105][Clause] END [ENDING]", - L"[106][Clause]< \"!\" \"prefix_merge\" \"(\" @ RuleName \")\" >", - L"[107][Clause]< \"!\" \"prefix_merge\" \"(\" RuleName \")\" @ >", - L"[108][Clause]< \"!\" \"prefix_merge\" \"(\" RuleName @ \")\" >", - L"[109][Clause]< \"!\" \"prefix_merge\" @ \"(\" RuleName \")\" >", - L"[110][Clause]< \"!\" @ \"prefix_merge\" \"(\" RuleName \")\" >", - L"[111][Clause]< \"!\" @ RuleName LriContinuation >", - L"[112][Clause]< \"!\" RuleName @ LriContinuation >", - L"[113][Clause]< \"!\" RuleName LriContinuation @ >", - L"[114][Clause]< \"left_recursion_placeholder\" \"(\" @ Placeholder { \",\" Placeholder } \")\" >", - L"[115][Clause]< \"left_recursion_placeholder\" \"(\" Placeholder @ { \",\" Placeholder } \")\" >", - L"[116][Clause]< \"left_recursion_placeholder\" \"(\" Placeholder { \",\" @ Placeholder } \")\" >", - L"[117][Clause]< \"left_recursion_placeholder\" \"(\" Placeholder { \",\" Placeholder @ } \")\" >", - L"[118][Clause]< \"left_recursion_placeholder\" \"(\" Placeholder { \",\" Placeholder } \")\" @ >", - L"[119][Clause]< \"left_recursion_placeholder\" @ \"(\" Placeholder { \",\" Placeholder } \")\" >", - L"[120][Clause]< Syntax \"as\" \"partial\" @ ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[121][Clause]< Syntax \"as\" \"partial\" ID @ [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[122][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", - L"[123][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", - L"[124][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", - L"[125][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", - L"[126][Clause]< Syntax \"as\" @ \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[127][Clause]< Syntax \"as\" @ ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[128][Clause]< Syntax \"as\" ID @ [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[129][Clause]< Syntax \"as\" ID [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", - L"[130][Clause]< Syntax \"as\" ID [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", - L"[131][Clause]< Syntax \"as\" ID [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", - L"[132][Clause]< Syntax \"as\" ID [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", - L"[133][Clause]< Syntax @ \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[134][Clause]< Syntax @ \"as\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[135][Clause]< Syntax @ [ \"{\" { Assignment ; \",\" } \"}\" ] >", - L"[136][Clause]< Syntax [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", - L"[137][Clause]< Syntax [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", - L"[138][Clause]< Syntax [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", - L"[139][Clause]< Syntax [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", - L"[140][Placeholder] BEGIN ", - L"[141][Placeholder] END [ENDING]", - L"[142][Placeholder]< ID @ >", - L"[143][RuleName] BEGIN ", - L"[144][RuleName] END [ENDING]", - L"[145][RuleName]< ID @ >", - L"[146][LriConfig] BEGIN ", - L"[147][LriConfig] END [ENDING]", - L"[148][LriConfig]\"left_recursion_inject\" @", - L"[149][LriConfig]\"left_recursion_inject_multiple\" @", - L"[150][LriContinuationBody] BEGIN ", - L"[151][LriContinuationBody] END [ENDING]", - L"[152][LriContinuationBody]LriConfig \"(\" @ Placeholder { \",\" Placeholder } \")\" LriTarget { \"|\" LriTarget }", - L"[153][LriContinuationBody]LriConfig \"(\" Placeholder @ { \",\" Placeholder } \")\" LriTarget { \"|\" LriTarget }", - L"[154][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" @ Placeholder } \")\" LriTarget { \"|\" LriTarget }", - L"[155][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" Placeholder @ } \")\" LriTarget { \"|\" LriTarget }", - L"[156][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" Placeholder } \")\" @ LriTarget { \"|\" LriTarget }", - L"[157][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" Placeholder } \")\" LriTarget @ { \"|\" LriTarget }", - L"[158][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" Placeholder } \")\" LriTarget { \"|\" @ LriTarget }", - L"[159][LriContinuationBody]LriConfig \"(\" Placeholder { \",\" Placeholder } \")\" LriTarget { \"|\" LriTarget @ }", - L"[160][LriContinuationBody]LriConfig @ \"(\" Placeholder { \",\" Placeholder } \")\" LriTarget { \"|\" LriTarget }", - L"[161][LriContinuation] BEGIN ", - L"[162][LriContinuation] END [ENDING]", - L"[163][LriContinuation]< \"[\" @ LriContinuationBody \"]\" >", - L"[164][LriContinuation]< \"[\" LriContinuationBody \"]\" @ >", - L"[165][LriContinuation]< \"[\" LriContinuationBody @ \"]\" >", - L"[166][LriContinuation]< LriContinuationBody @ >", - L"[167][LriTarget] BEGIN ", - L"[168][LriTarget] END [ENDING]", - L"[169][LriTarget]< \"(\" @ RuleName LriContinuation \")\" >", - L"[170][LriTarget]< \"(\" RuleName @ LriContinuation \")\" >", - L"[171][LriTarget]< \"(\" RuleName LriContinuation \")\" @ >", - L"[172][LriTarget]< \"(\" RuleName LriContinuation @ \")\" >", - L"[173][LriTarget]< RuleName @ >", - L"[174][Rule] BEGIN ", - L"[175][Rule] END [ENDING]", - L"[176][Rule]< [ \"@public\" @ ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause } \";\" >", - L"[177][Rule]< [ \"@public\" ] [ \"@parser\" @ ] ID [ \":\" ID ] { \"::=\" Clause } \";\" >", - L"[178][Rule]< [ \"@public\" ] [ \"@parser\" ] ID @ [ \":\" ID ] { \"::=\" Clause } \";\" >", - L"[179][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" @ ID ] { \"::=\" Clause } \";\" >", - L"[180][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID @ ] { \"::=\" Clause } \";\" >", - L"[181][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" @ Clause } \";\" >", - L"[182][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause @ } \";\" >", - L"[183][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause } \";\" @ >", - L"[184][File] BEGIN ", - L"[185][File] END [ENDING]", - L"[186][File]< [ Switches @ ] Rule { Rule } >", - L"[187][File]< [ Switches ] Rule @ { Rule } >", - L"[188][File]< [ Switches ] Rule { Rule @ } >", + L"[28][TestBranch] BEGIN ", + L"[29][TestBranch] END [ENDING]", + L"[30][TestBranch]< Cond \":\" ( Syntax1 @ | \";\" ) >", + L"[31][TestBranch]< Cond \":\" ( Syntax1 | \";\" @ ) >", + L"[32][TestBranch]< Cond \":\" @ ( Syntax1 | \";\" ) >", + L"[33][TestBranch]< Cond @ \":\" ( Syntax1 | \";\" ) >", + L"[34][Syntax0] BEGIN ", + L"[35][Syntax0] END [ENDING]", + L"[36][Syntax0]< \"!\" @ ID >", + L"[37][Syntax0]< \"!\" ID @ >", + L"[38][Syntax0]< \"!(\" @ { SwitchItem ; \",\" } \";\" Syntax \")\" >", + L"[39][Syntax0]< \"!(\" { SwitchItem ; \",\" @ } \";\" Syntax \")\" >", + L"[40][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" @ Syntax \")\" >", + L"[41][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" Syntax \")\" @ >", + L"[42][Syntax0]< \"!(\" { SwitchItem ; \",\" } \";\" Syntax @ \")\" >", + L"[43][Syntax0]< \"!(\" { SwitchItem @ ; \",\" } \";\" Syntax \")\" >", + L"[44][Syntax0]< \"+\" \"[\" @ Syntax \"]\" >", + L"[45][Syntax0]< \"+\" \"[\" Syntax \"]\" @ >", + L"[46][Syntax0]< \"+\" \"[\" Syntax @ \"]\" >", + L"[47][Syntax0]< \"+\" @ \"[\" Syntax \"]\" >", + L"[48][Syntax0]< \"-\" \"[\" @ Syntax \"]\" >", + L"[49][Syntax0]< \"-\" \"[\" Syntax \"]\" @ >", + L"[50][Syntax0]< \"-\" \"[\" Syntax @ \"]\" >", + L"[51][Syntax0]< \"-\" @ \"[\" Syntax \"]\" >", + L"[52][Syntax0]< \"?(\" @ TestBranch { \"|\" TestBranch } \")\" >", + L"[53][Syntax0]< \"?(\" TestBranch @ { \"|\" TestBranch } \")\" >", + L"[54][Syntax0]< \"?(\" TestBranch { \"|\" @ TestBranch } \")\" >", + L"[55][Syntax0]< \"?(\" TestBranch { \"|\" TestBranch @ } \")\" >", + L"[56][Syntax0]< \"?(\" TestBranch { \"|\" TestBranch } \")\" @ >", + L"[57][Syntax0]< \"[\" @ Syntax \"]\" >", + L"[58][Syntax0]< \"[\" Syntax \"]\" @ >", + L"[59][Syntax0]< \"[\" Syntax @ \"]\" >", + L"[60][Syntax0]< \"{\" @ Syntax [ \";\" Syntax ] \"}\" >", + L"[61][Syntax0]< \"{\" Syntax @ [ \";\" Syntax ] \"}\" >", + L"[62][Syntax0]< \"{\" Syntax [ \";\" @ Syntax ] \"}\" >", + L"[63][Syntax0]< \"{\" Syntax [ \";\" Syntax @ ] \"}\" >", + L"[64][Syntax0]< \"{\" Syntax [ \";\" Syntax ] \"}\" @ >", + L"[65][Syntax0]< ( ID @ | STRING | CONDITIONAL_LITERAL ) [ \":\" ID ] >", + L"[66][Syntax0]< ( ID | STRING @ | CONDITIONAL_LITERAL ) [ \":\" ID ] >", + L"[67][Syntax0]< ( ID | STRING | CONDITIONAL_LITERAL ) [ \":\" @ ID ] >", + L"[68][Syntax0]< ( ID | STRING | CONDITIONAL_LITERAL ) [ \":\" ID @ ] >", + L"[69][Syntax0]< ( ID | STRING | CONDITIONAL_LITERAL @ ) [ \":\" ID ] >", + L"[70][Syntax0]", + L"[71][Syntax0]", + L"[72][Syntax0]", + L"[73][Syntax1] BEGIN ", + L"[74][Syntax1] END [ENDING]", + L"[75][Syntax1]< Syntax1 @ Syntax0 >", + L"[76][Syntax1]< Syntax1 Syntax0 @ >", + L"[77][Syntax1]", + L"[78][Syntax2] BEGIN ", + L"[79][Syntax2] END [ENDING]", + L"[80][Syntax2]< Syntax2 \"|\" @ Syntax1 >", + L"[81][Syntax2]< Syntax2 \"|\" Syntax1 @ >", + L"[82][Syntax2]< Syntax2 @ \"|\" Syntax1 >", + L"[83][Syntax2]", + L"[84][Syntax] BEGIN ", + L"[85][Syntax] END [ENDING]", + L"[86][Syntax]", + L"[87][Assignment] BEGIN ", + L"[88][Assignment] END [ENDING]", + L"[89][Assignment]< ID ( \"=\" @ | \"?=\" ) ID >", + L"[90][Assignment]< ID ( \"=\" | \"?=\" ) ID @ >", + L"[91][Assignment]< ID ( \"=\" | \"?=\" @ ) ID >", + L"[92][Assignment]< ID @ ( \"=\" | \"?=\" ) ID >", + L"[93][Clause] BEGIN ", + L"[94][Clause] END [ENDING]", + L"[95][Clause]< Syntax \"as\" \"partial\" @ ID [ \"{\" { Assignment ; \",\" } \"}\" ] >", + L"[96][Clause]< Syntax \"as\" \"partial\" ID @ [ \"{\" { Assignment ; \",\" } \"}\" ] >", + L"[97][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", + L"[98][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", + L"[99][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", + L"[100][Clause]< Syntax \"as\" \"partial\" ID [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", + L"[101][Clause]< Syntax \"as\" ID @ [ \"{\" { Assignment ; \",\" } \"}\" ] >", + L"[102][Clause]< Syntax \"as\" ID [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", + L"[103][Clause]< Syntax \"as\" ID [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", + L"[104][Clause]< Syntax \"as\" ID [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", + L"[105][Clause]< Syntax \"as\" ID [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", + L"[106][Clause]< Syntax [ \"{\" @ { Assignment ; \",\" } \"}\" ] >", + L"[107][Clause]< Syntax [ \"{\" { Assignment ; \",\" @ } \"}\" ] >", + L"[108][Clause]< Syntax [ \"{\" { Assignment ; \",\" } \"}\" @ ] >", + L"[109][Clause]< Syntax [ \"{\" { Assignment @ ; \",\" } \"}\" ] >", + L"[110][Clause]{{< Syntax \"as\" @ \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] > ; < Syntax \"as\" @ ID [ \"{\" { Assignment ; \",\" } \"}\" ] >}}", + L"[111][Clause]{{< Syntax @ \"as\" \"partial\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] > ; < Syntax @ \"as\" ID [ \"{\" { Assignment ; \",\" } \"}\" ] > ; < Syntax @ [ \"{\" { Assignment ; \",\" } \"}\" ] >}}", + L"[112][Rule] BEGIN ", + L"[113][Rule] END [ENDING]", + L"[114][Rule]< [ \"@public\" @ ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause } \";\" >", + L"[115][Rule]< [ \"@public\" ] [ \"@parser\" @ ] ID [ \":\" ID ] { \"::=\" Clause } \";\" >", + L"[116][Rule]< [ \"@public\" ] [ \"@parser\" ] ID @ [ \":\" ID ] { \"::=\" Clause } \";\" >", + L"[117][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" @ ID ] { \"::=\" Clause } \";\" >", + L"[118][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID @ ] { \"::=\" Clause } \";\" >", + L"[119][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" @ Clause } \";\" >", + L"[120][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause @ } \";\" >", + L"[121][Rule]< [ \"@public\" ] [ \"@parser\" ] ID [ \":\" ID ] { \"::=\" Clause } \";\" @ >", + L"[122][File] BEGIN ", + L"[123][File] END [ENDING]", + L"[124][File]< [ \"switch\" @ { SwitchItem ; \",\" } \";\" ] Rule { Rule } >", + L"[125][File]< [ \"switch\" { SwitchItem ; \",\" @ } \";\" ] Rule { Rule } >", + L"[126][File]< [ \"switch\" { SwitchItem ; \",\" } \";\" @ ] Rule { Rule } >", + L"[127][File]< [ \"switch\" { SwitchItem ; \",\" } \";\" ] Rule @ { Rule } >", + L"[128][File]< [ \"switch\" { SwitchItem ; \",\" } \";\" ] Rule { Rule @ } >", + L"[129][File]< [ \"switch\" { SwitchItem @ ; \",\" } \";\" ] Rule { Rule } >", }; return results[index]; } @@ -14330,24 +11104,22 @@ namespace vl::glr::parsergen { void ParserGenTypeParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 2930; // 42808 bytes before compressing + static const vl::vint dataLength = 2480; // 34610 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 114; - static const vl::vint dataSolidRows = 11; - static const vl::vint dataRows = 12; + static const vl::vint dataRemain = 176; + static const vl::vint dataSolidRows = 9; + static const vl::vint dataRows = 10; static const char* compressed[] = { - "\x38\xA7\x00\x00\x6A\x0B\x00\x00\x27\x00\x01\x82\x80\x08\x03\x82\x81\x82\x06\x89\x82\x84\x0A\x84\x06\x85\x09\x0A\x9A\x0A\x82\x1A\x80\x16\x84\x16\x0A\xB0\x47\x09\x8F\x7D\x8E\x8F\x8E\x0A\x80\x1F\x9F\x81\x93\x92\x8F\x92\x26\xFF\x68\x86\x9B\x93\x91\x96\x92\x0A\xA9\xAA\x91\x99\x97\x97\x92\x9A\x2C\xB8\xAE\x9A\x90\x9C\x8D\x9A\x9E\x37\xBE\xB9\x82\xAB\x9C\xA1\x9E\x83\x32\xB6\xA0\x80\xAB\xA6\xA1\xA0\xA4\x3F\xCE\x8D\xB0\xA3\xA4\xA9\xA2\xAB\x47\x83\x89\xAC\xA3\x9A\xA9\xAE\xAC\x4F\xDA\x91\xA0\xB3\xAA\xB1\xAA\xB3\x57\xE8\x99\xA1\x92\x81\x00\xAE\xA5\x5F\xEA\xA1\xA2\x8B\xAE\xAC\xB9\xBB\x6F\xF9\xB6\xBA\xB4\xB1\xB8\xBB\xB1\x72\xE5\xBF\xA7\xB3\xC1\xB5\xC3\xB5\x01\xF5\xBD\xB8\xBB\xBD\xC7\xC4\xBE\x81\xFE\x89\xC0\xC7\xC3\xBB\xC8\xC2\x97\x86\xD9\xC8\xC2\x94\xCB\xCC\xCB\x9D\x98\xE1\xDA\xC3\xD4\xCE\xC5\xC8\x8C\x8F\xCE\xC8\xD0\xCD\xCA\xC1\xCF\xAF\xA5\xE0\xCE\xB9\x84\xDA\xD5\xDB\xAC\xAB\xEE\xD2\xC2\xD9\xDB\xD3\xDD\xA9\xB9\xF8\xC0\xED\xD0\xD8\xDF\xDF\xC6\xC1\xC4\xFA\xD9\xE5\xE1\xDF\xE3\x9E\xCF\xCA\xED\xEC\xE2\xEA\xE6\xE4\xD6\xD5\xD8\xFB", - "\xE1\xEC\xEE\xD0\xEF\xA4\xE0\xE6\xDD\xE4\xF7\xED\xF3\xF0\xE7\xE3\xE6\xEB\xF8\xF4\xF6\xF5\xF6\xF0\xEF\xF2\xE0\xD2\xF4\xF9\xF4\xD0\x02\x0A\xB6\xC2\xEC\xFB\xE7\xE0\xEA\xFF\x59\x71\x81\x7D\xBE\x77\x75\x82\x7B\xF6\x48\x87\x81\x7C\x09\x8C\x8B\x80\x67\x03\x3A\x77\x75\x74\x0C\x75\x63\x86\x82\xD0\x58\x83\x76\x80\xFD\x40\x8D\x84\x87\xFE\x5F\x84\x81\x86\x0E\xA4\x83\x7F\x83\x0D\xA7\x86\x89\x8A\x2C\xA8\x8E\x8B\x8A\x2F\x9B\x83\x8A\x8C\x06\xB0\x86\x8C\x8D\x1A\x97\x85\x88\x8E\x3B\xBA\x8A\x88\x8F\x3F\xBE\x8D\x8B\x8D\x42\xB1\x85\x90\x91\xDA\x75\x80\x93\x90\x4B\x86\x99\x91\x8E\x4F\xBD\x81\x95\x90\xD5\x45\x02\x87\x94\x4C\x87\x9D\x90\x92\x03\x8A\x9A\x97\x97\x58\x8E\x9D\x94\x94\x63\x92\x95\x98\x95\x67\x99\x91\x98\x97\x22\x9E\x9B\x9B\x96\x70\xA0\x99\x9A\x98\x6D\xA4\x95\x9E\x99\x77\xA8\x99\x9E\x9A\x73\xAC\x91\x8B\x9F\x1E\x80\xA0\x89\xA0\x84\x83\xA0\x02\x01\x57\xBD\x91\x9F\x9B\x72\xBB\x94\x9E\xA0\x33\x8D\xA0\xA6\x9B\x8A\x8A\x4B\x46\x85\x8C\x99\xA5\xA6\xA6\x8E\xBE\x95\xA1\xA4\x9C\x93\xA2\x68\x42\x06\x7B\x72\xA8\x9E\xA7\xBA\x99\xA8\x9F", - "\x9D\x8B\xAB\xA7\xAB\xAD\x92\xA1\x41\x02\x89\xB1\xA1\xAB\xA7\x94\xB6\xA0\xAF\xAA\x8F\xB8\xA6\x9E\xA0\x0A\x35\xAC\xAE\xA7\x86\x8B\x02\xB2\xAF\xA8\x88\xBA\xAA\xB2\xAC\x83\xBE\xAA\xAE\xD0\x8E\xB2\xAE\xA1\xA0\xBB\xAC\xB1\xAF\xD4\xB9\xA2\xB7\xAD\xD9\xBF\xA7\xB4\xB1\xD5\x91\xBF\xB7\xB3\xDB\x96\xBD\xB4\x69\x0E\x58\xA6\xB9\xB8\xE5\xA2\xB7\xBB\xB2\xEF\x8D\xB3\xBB\xB4\xEC\xB3\xBC\xB5\xBD\xF1\x98\xB8\xBC\xBE\x0D\x07\xB9\xBC\xB8\xDA\xB6\xBB\xB9\xC0\xFF\xA4\xB2\xC2\xBB\xFB\x84\xC9\xC2\x68\x0E\x0A\x49\x7F\xBD\x0A\xD1\xCE\xB5\xC1\xF4\x92\xC9\xB0\xC5\x10\xD3\xCB\xC3\xC5\x1B\xF0\xBD\xC6\xBC\x18\xC3\xCA\xC6\xC5\x1E\xD1\x70\x06\xBF\x1F\xFA\xB4\xC8\xC8\x29\xC0\xC3\xCB\xCB\x1C\xEB\xCA\xC8\xCC\x25\xF4\xCC\xCA\xCC\x2E\xF1\xC6\xCC\xB6\x11\x28\xC8\xCE\xC1\x21\xC8\xCF\xCD\xC5\x3B\xF9\xC5\xCE\xCE\x48\xC7\xDA\xD3\xCD\x45\xC0\xDD\xCA\xD3\x43\xD9\xC9\xD0\xD3\x53\xF3\xC7\xC6\x04\x3E\xCD\xD4\xD1\xD5\x46\xD4\xDB\xD2\xD5\x5F\xDD\xD0\xDA\xD7\x20\xD0\x4A\xBA\xD0\x5A\xD2\xD1\xD8\xD4\x69\xE2\xCC\xD4\xDB\x6F\xDB\xDB\xDA\xDC\x64\xE3\xD6\xDE\xD8\x78", - "\xF0\xD3\xDE\xDA\x75\xC4\xB4\x05\xD6\x71\xFC\xD7\xDE\xDE\x7D\xC4\xE3\xE0\xDD\x87\xC2\xE9\xDC\xE2\x8B\xC9\x45\x04\xE0\x7B\xEE\xD1\xE4\xDA\x81\xD2\xE5\xE0\xE3\x86\xCD\xE6\xE5\xE2\x9B\xDA\xE4\xE7\xE4\xED\xA1\xE7\xC2\xE8\x41\xE4\xEF\xD0\xE6\xA8\xCA\xE9\xE7\xEA\xA9\xDD\xEC\xEA\xEA\xAD\xDF\xE7\xE4\xEC\xB4\xEE\xE1\xEE\xE9\x51\xE6\xB6\x04\xE4\xB3\xF6\xE5\xEE\xEC\xD8\x97\x0C\xEC\xE7\xC0\xDE\xE8\xED\xDB\xC5\xEF\xEE\xEF\xF2\x1F\x98\x0E\xC3\xED\x85\x92\x47\xDB\xF1\x95\xC9\xF0\xF5\xE9\xA3\xD9\xF8\xF7\xF6\xA7\xFF\xE4\xF4\xE8\xDA\xDD\xFC\xF3\xF7\xBD\xD6\xFE\xF5\xF8\xB9\xE6\xF3\xFA\xF6\x1B\x03\xF6\xF0\xFA\xC8\xE4\xF4\xF2\xFC\xEF\xDC\xF9\xF8\xFD\xCA\xEA\xFA\xFC\xFE\xCE\x5C\x0E\xF9\xFE\xFC\x67\x7E\xFD\x71\x70\x7F\xEA\x41\x83\x7D\x03\x86\x81\x01\xE0\x79\x80\x06\xA2\x7B\x7F\x0B\x85\x7E\xA0\x1D\x0F\x7F\xEB\x4F\x87\x80\x10\x8D\x82\x04\x91\x83\x7E\x0E\xB5\x7F\x82\x1E\x80\x81\x08\x96\x87\x7F\x11\x82\x80\x84\x1A\x9D\x82\xA1\x1E\x05\x83\x13\x84\x67\x03\x2D\x88\x80\x0A\xB3\x85\x85\x14\x9F\x85\x86\x34\x84\x82\x0D\xA2\x8B\x86\x12\xBA\x81", - "\x87\x0A\x9D\x84\xB7\x20\x01\x87\x0C\x80\x8E\x81\x38\x89\x8B\x0F\xD1\x31\x05\x22\x98\x87\x89\x26\x92\x86\x12\xC1\x87\x89\x0D\x82\x88\x81\x14\x33\x79\x14\xC6\x85\x87\x11\x0E\x8B\x8B\x50\x97\x88\x17\xCB\x84\x8C\x2A\x93\x88\x89\x13\x64\x07\x17\xE2\x81\x8C\x7C\x65\x03\x8D\x55\x8A\x85\x1C\xB7\x85\x8C\x34\xA6\x8A\x34\x26\x10\x8F\x19\xD6\x83\x8E\x1E\xBD\x8E\x87\x77\x81\x92\x1D\x83\x9C\x8F\x3D\xAA\x80\x20\x5A\x80\x02\x45\x09\x98\x3B\x14\x3A\x8D\x8E\x85\x90\x92\x1C\x86\x94\x8E\x41\x91\x96\x92\x93\x92\x91\x25\x84\x99\x92\x4C\x9B\x97\x92\x9C\x9F\x91\x27\xA1\x9E\x8E\x4A\xA5\x92\x87\x2A\x0F\x90\x69\x2B\x0A\x94\x52\x80\x96\x95\x2E\x9A\x93\x29\x9E\x93\x96\x58\x92\x8A\x96\x17\x2D\x94\x28\xBB\x93\x94\x5E\xA2\x97\x97\xB5\x9E\x95\x30\xBD\x94\x98\x60\xAF\x92\x98\xC7\x85\x9B\x30\xC6\x91\x96\x5A\x97\x7D\x05\xBA\x8A\x86\x0B\x51\x9C\x99\x5B\x8E\x9D\x99\xB6\x83\x8F\x35\xD6\x99\x9B\x36\xA6\x93\x5A\x2F\x1E\x5C\x0C\x4F\x75\x3A\x19\x3E\x5B\x06\xD4\x8B\x9A\x3A\xC9\x95\x9A\x6D\x9D\x98\x8C\xF0\x8C\x8D\x3C\xFF\x88\x9A\x64\xB5\x9A\x99\xEC\x8B", - "\x9F\x3D\xED\x9E\x9A\x1D\xB4\x01\x9D\xF9\x81\xA3\x3E\xFA\x9C\x9A\x7B\x85\xA0\x9F\x03\xA2\xA2\x41\x35\x00\xA1\x84\x8E\xA7\xA0\xFC\x93\x9F\x37\x8F\xAE\x9C\x83\x95\xA0\xA1\x06\x36\x06\xBF\x37\x04\x9D\x00\x79\x06\x5F\x3A\x0D\xA0\x44\x84\xA7\xA3\x88\xB2\x9F\xA4\xF4\x83\xA6\x42\xA5\xA4\xA5\x7E\x9B\x9C\xA5\x2B\xAE\xA7\x3B\xA8\xA3\xA2\x04\xBB\x03\x8D\x3C\x1E\x5D\x0F\x1D\xAF\x43\x1F\x3E\x58\x08\x22\xB0\xA4\x45\xB2\xA6\xA2\xA2\x98\xA2\xA8\x2A\xBC\x59\x10\x6B\x82\x08\x7F\x43\x0C\xA7\x82\x45\x0A\xBF\x46\x01\xA8\xA3\xA6\xA1\xA5\x48\xB9\xAA\x55\xAD\xA2\xA3\x89\x47\x10\xAA\x01\x21\x5B\x9A\x32\x24\x57\x84\x18\x6E\x2B\x56\x5E\x2A\x4C\x0F\x66\x21\xB2\xBD\x4C\xAC\x0A\x39\xA6\x57\x6C\xA3\x20\xB7\x9D\x50\xAE\x09\x3B\xA7\x5C\x8A\x22\xAD\xB7\xA9\x26\xAE\x02\x27\xAD\x5F\x74\xA2\x21\xBE\xB7\xAF\xAF\x0A\x22\xB1\x64\x69\xAD\x2F\x11\x78\xAE\x20\xFD\x43\xAC\x62\x89\x21\xB3\xBE\x26\x54\x2D\xCF\x20\xB1\x40\x69\x56\xB2\xB0\x99\xB5\x21\x5C\x37\xB0\x00\x22\xBF\xB1\x81\x1C\xB1\x32\x84\xA1\x20\x63\x87\xB6\x24\xCD\x80\x06\x58\x92\xAD\xB6\x42\x15", - "\xBC\xB5\x91\x2E\xB4\xB6\xBB\x2B\xB7\x6E\x0E\xB3\xB2\x83\x3A\xAE\xAF\xB2\xA9\x22\x6B\xEB\xAA\x20\xDD\x86\x39\xB5\x00\x06\xBB\x73\x48\xB5\x42\xE0\xB6\xB2\x21\xA4\x48\xB6\x42\x4D\xB5\xB7\x8F\x2E\xB2\xAE\x83\xB3\xBB\x91\x25\xB7\x21\xED\xBD\xB3\x20\xBF\xAB\xB0\x57\x32\x21\x42\xB5\xA9\x24\xB9\xDE\xA1\xBA\x41\x51\xBB\x37\xF2\x8D\xB7\xBC\x0A\x23\xB9\x8D\x5C\xB1\x20\xEC\x91\x36\xBD\x91\x24\xB9\x42\x54\xB3\x58\xFA\x80\x06\xBE\xED\xA3\xBC\x7C\xFB\xBC\x2A\xFC\xBB\xB3\xC0\x6D\xBC\x28\x7F\xC6\x32\x26\xE5\xB2\x22\x26\x0B\xCF\x39\x83\x82\xC6\x24\xE4\x86\xC6\x38\x17\xD2\xC0\x82\x83\x21\xC2\xDE\xAA\xBB\x20\xEC\xA7\xBA\x42\x19\xC4\xBC\x0A\xE3\x20\xB9\xF2\xB8\x42\x7F\x80\xC2\xC5\x84\x24\xC1\x25\x2F\xCF\xC3\x89\xDA\xB1\xB7\xE7\x89\x24\xC5\xCB\xA3\xC5\x81\xA6\xCF\x22\xF4\xBB\xAE\xC5\x3B\xC6\xBD\x85\xF1\xBC\x2A\x07\xF2\xC3\x24\x31\xC7\xC9\x47\x3E\xCE\xB8\xEB\x90\xB9\xC8\xEF\xA3\xCA\x70\xE9\xB6\xC6\x83\x38\xC5\xC4\x42\xD3\xC4\x81\xB5\xCE\xC9\x1B\xD0\xC9\xBF\x1B\xCB\x23\x97\x87\xC2\xCB\x04\xE8\xAC\xC7\x1E\x29\xCA\x92\xCC\xC5\xBA\x8F", - "\x2E\xB1\xC4\xCF\x2A\xCF\x91\xA8\xC4\xCB\x2E\xD6\xCB\xCC\x0C\xC1\xCD\x40\x1D\xC3\xBF\xEF\x82\x27\xCA\x30\xC8\xCF\x92\xB4\xCD\x2E\x39\xF2\xC4\xCE\x5E\x2E\xB5\xCF\x09\xDA\x21\x45\xFD\x2E\xB5\x86\xBB\x34\xA4\xDC\x2E\xB5\x4B\x4F\xD6\x52\x94\xD8\xD2\x57\x2C\x98\xB3\x81\x22\xB0\xB9\xA0\xDA\xC7\x96\x86\x2A\xB8\x44\x49\x26\xD2\x03\x26\xD6\x41\x2A\xD3\x20\x54\xDD\xB9\x21\xAC\xCF\xD6\x41\x2E\xD1\x20\x38\xF1\xD5\xD6\x0A\x37\xD4\x41\x1A\xD6\xCD\x55\xC4\xCF\xD4\xBF\xDE\xD7\x94\xB0\xD1\xD9\x56\xFC\xA9\xD7\xC7\xC0\xD9\x42\x11\xD1\x20\x5D\xCC\xDF\x50\xC9\xD3\xD6\x42\x30\xBD\xD3\x59\x55\xDD\xD3\x80\x1E\x5D\x48\x2E\xB7\xDA\x81\x01\x16\x5F\xC8\xAE\x79\xB7\xA4\xB1\x3B\x0C\xC4\x8D\xDB\x21\x22\x12\xBF\x66\xD8\xDD\x90\x03\x16\x5F\x11\xC8\x93\xB5\xE4\xD2\x34\xE5\x9C\xD7\xDA\x86\xDC\x36\x68\xA9\x9D\xDB\x7C\xE1\x22\xD7\xD3\x8D\xDD\x42\x04\x1E\x5E\x5D\xE1\x9A\xE0\x06\x25\x11\xC1\x8A\x27\xE0\x84\xC2\x26\x10\xFE\x47\x08\xBA\xFE\xDE\xE0\x4F\xE0\xDE\x39\xC8\xB4\xDC\x69\x21\x29\xC2\x8D\xF0\x59\xC3\xC8\xB8\x38\x0F\x91\xCA\xD6\x91\xC4\xD6\xE2", - "\x09\x2A\xB9\xC8\x94\x4C\xD7\x0F\x61\x24\xD6\xA3\xB3\x5A\xAE\xB0\xE6\xE4\x01\xB0\xE4\xDA\x2E\xEE\x38\x9C\xAB\xE3\x55\x68\xF9\xE2\x80\x70\xD4\xE1\xB7\xCF\xD2\xB4\x9C\xC2\x20\xB9\x21\x22\xB7\xA4\xD5\x3C\x86\xD7\x82\xEF\xDA\xB8\xA1\x22\x68\x8D\x69\x21\x8C\xFE\x5F\xD9\x46\xC2\x35\x48\x27\x6C\x90\x82\x46\xE8\xD7\x4C\xF7\x7B\x69\x82\x24\xEB\x00\x7C\x83\xEC\x01\x2E\xD3\xCF\x81\x4A\xED\xA3\xCE\x38\xED\x00\x0A\xB2\xA0\x1B\x46\x6C\x83\x3C\xE4\x34\x65\xE3\x21\xD4\x86\x51\x25\xC7\x55\xEB\x5A\x0F\x13\xB6\x73\x21\x22\x79\xBF\xDC\x5C\xEB\x06\x21\xF1\xD8\x82\x8D\xED\x80\x3B\xED\xE6\x06\x39\x02\x67\xF8\x52\xEF\x80\x08\xF3\xED\x19\x95\xEF\x40\x7E\xE6\xEC\x85\x2D\x7D\xEB\x13\x7C\xF3\x40\x12\xFB\xF1\x00\x7E\x7E\xF0\x01\x5B\x75\x42\x79\xE3\xEF\x69\x56\xE9\x21\xAA\xE6\x21\xE3\xFC\xEE\x38\x16\xA8\xF3\x20\x1D\xEA\x21\xEC\x83\x25\xF2\xDA\xD5\x3F\xDC\x76\xE7\xE5\x5B\x0A\x25\xF0\x83\x3F\x6D\xF4\x03\x39\x89\xA9\x53\x52\xDC\x83\x05\xF8\xF3\x61\x84\xF6\x41\x3B\xFD\xF4\x01\x92\x7E\x20\xA7\xFD\xF1\x75\x5E\x87\xF6\x41\x59\xFB\x20\x30\x88\xF9", - "\x18\xDF\xF2\x20\x0A\xA2\xF9\x9E\xE6\xE6\x22\xED\xDA\xF1\x41\x37\x9D\xFD\x50\xEB\xE0\xFF\xE0\xD7\x71\xFC\x83\x22\xF5\xFA\x06\x32\xDC\xCA\x81\x4A\xB8\xD1\xB5\xFB\x20\x4D\x47\x7E\x27\x50\x7C\x9B\x73\x7F\x09\x1B\x48\xCB\x75\x1D\xBA\x62\x5A\x04\x82\x10\x01\x8C\x7E\x19\x4F\x80\x03\x1F\x79\x10\x81\x46\xCA\x73\x10\xEE\x75\x81\x01\x1E\x48\x89\x4C\x6F\xC1\x75\x1D\x17\x82\x10\x6A\x42\x80\x18\x19\x48\xD0\x4F\x7E\x86\x21\x82\x01\x19\x47\x02\x8D\x70\xFB\x7E\x2E\x23\x86\x10\x19\x80\x7D\x85\x23\x4E\x28\x88\x1D\x31\x83\x10\x2C\x8A\x81\x27\x53\x83\x02\x1B\x83\x34\x87\x52\x40\x82\x10\xE4\x75\x28\x1B\x26\x4E\x28\x80\x73\xA2\x5A\x7F\x02\x1C\x7D\x3C\x8F\x4F\xA0\x77\x31\x08\x88\x81\x06\x8B\x50\x9E\x5C\x51\x28\x80\x67\xA2\x53\x85\x02\x15\x72\xD1\x11\x12\x1F\x58\x82\x37\x58\x82\xAE\x5B\x85\x0A\x19\x83\xF8\x70\x5E\x9E\x5E\x53\x28\x84\x74\x15\x1A\x10\x43\x86\x84\x0A\x1B\x54\x37\x81\x1D\x5F\x71\x73\x07\x8D\x72\x69\x82\x10\x4F\x55\x87\xA2\x10\x77\xFB\x6A\x10\x1C\x8C\x83\x52\x5E\x87\x17\x37\x6F\x03\x13\x88\x41\x82\x71\x86\x80\x2F\x25\x82", - "\x83\x55\x83\x10\x49\x02\x6A\x06\x1C\x04\x9E\x5B\x77\xC8\x5F\x88\xA9\x61\x89\x02\x1E\x04\x94\x83\x10\x51\x0E\x59\x8A\x7F\x81\x06\x1A\x89\x22\x8C\x89\x01\x13\x05\x9F\x82\x10\x56\x0E\x59\xB3\x79\x89\x70\x88\x8A\x00\x08\x05\xAB\x85\x28\x9A\x7E\x76\x09\x16\x8A\x01\x14\x73\x5F\x8A\x10\x5B\x05\x8B\x86\x27\x7F\x01\x18\x5C\x01\x76\x10\x27\x8C\x83\x5E\x05\x55\x01\x15\x8C\x54\x82\x80\x5F\x0E\x59\x61\x0E\x59\xCF\x78\x8B\x06\x1C\x8C\x5D\x82\x8B\x63\x0E\x59\x65\x0E\x59\xD2\x73\x10\xC4\x87\x86\xB2\x87\x06\x9E\x59\x06\x9E\x54\x81\xDE\x8A\x10\xD6\x8B\x82\xB2\x8B\x06\x93\x71\x1D\xE9\x77\x8E\x09\x19\x8E\x00\x0C\x8B\x5A\x7A\x10\x6D\x0D\x8E\xA2\x1F\x7F\xD4\x83\x10\x2E\x82\x10\xC7\x81\x84\x6F\x0A\x8C\x00\x0D\x8F\x01\x1E\x83\x72\x89\x10\x70\x0E\x59\x72\x0E\x59\x12\x8B\x8F\x02\x14\x90\xD0\x62\x80\x74\x0E\x59\x76\x0E\x59\x4E\x80\x8F\x06\x10\x91\x68\x87\x90\x06\x18\x07\x9E\x5A\x07\x9E\x56\x90\x00\x08\x5C\x10\x91\x87\xBE\x76\x10\x7C\x08\x8F\xA4\x1C\x84\xC3\x8C\x70\x7A\x8C\x91\x03\x1E\x07\x2A\x9C\x19\x8A\x8E\x90\x01\x16\x83\xD7\x62\x72", - "\x0F\x65\x71\xE3\x6F\x16\x1E\x7F\x11\xA2\x5C\x16\x41\x99\x74\xED\x63\x94\xDA\x64\x94\xE8\x67\x77\x24\x1A\x94\x3D\x6D\x6E\xA1\x6E\x59\x48\x7F\x7A\x28\x88\x74\xFE\x69\x6F\xFF\x09\x61\x6C\x18\x95\x1C\x7D\x6E\x5A\x90\x8C\x6C\x1C\x67\x2C\x10\x96\x26\x11\x61\x5F\x9D\x6E\x64\x91\x12\x67\x92\x7C\x9D\x69\x96\x29\x7F\x16\x59\x76\x12\xCA\x5C\x16\x71\x91\x12\x73\x95\x5C\xED\x6E\x85\x2C\x18\x97\x26\x1A\x6B\x6C\x1C\x97\x2F\x7F\x16\xF4\x86\x12\x30\x7C\x16\x83\x9D\x6E", + "\x32\x87\x00\x00\xA8\x09\x00\x00\x23\x00\x01\x82\x80\x06\x03\x82\x81\x82\x06\x89\x82\x84\x0A\x84\x06\x85\x0B\x0A\xA2\x0A\x86\x1A\x82\x08\x85\x81\xFF\x19\x9A\x99\x8A\x80\x03\x8D\x8D\x1D\x9F\x9A\x81\x92\x97\x7C\x92\x91\x27\x9F\xA9\x80\x9A\x85\x92\x93\x96\x25\xAB\xA3\x90\x98\x94\x9A\x94\x9B\x2C\x89\xAE\x92\x9C\x88\x9F\x98\x9D\x31\xBE\xBD\x80\xA5\x9C\xA3\x9A\xA3\x39\x86\xBB\x82\xAF\x90\xA7\x9E\xA5\x41\xCE\x83\xB0\xA5\xA4\xAB\xA2\xAB\x49\x98\x91\xB8\xAF\xA2\xAD\xAB\x8E\x03\x81\x0C\xBC\x9D\xA4\xAF\xA8\xAF\x57\xE8\x99\xA2\x8B\xA2\xA9\xB2\xB5\x5D\xEC\x9B\xB0\xB7\xB2\xBB\xAE\xBB\x69\xF8\xAB\xA1\x8D\xB6\xB3\xB6\xBD\x71\xFC\xB3\xA0\xC5\xBA\xC3\xBA\xC3\x79\x88\xFB\xBE\x83\xC2\xC5\xC0\xC6\x87\x90\xC9\xD2\xCB\xC5\xBC\xBB\xBF\x8E\x85\xD4\xCF\xC6\xCC\xC0\xCD\xCD\x9A\x9D\xD9\xDF\xC2\xD0\xD0\xD3\xC6\xA6\xE4\xAA\xCA\x82\xB1\x85\xD6\xBF\xAB\xEE\xB1\xD0\xD3\xB5\xDA\xD8\xDB\xB4\xB7\xFA\xD9\xDC\xDF\xCB\xD8\xDF\xB8\xC0\xFB\xC2\xED\xDE\xCF\xDE\xE3\xC1\xC8\xC3\xEA\xE5\xE3\xD3\xE2\xE7\xC9\xD0\xCB\xF2\xED\xE1\xD5\xE8\xEB\xD3\xD8\xD5\xE5", + "\xDC\xE8\xD5\xEF\xC8\xDF\x93\xE1\xF5\xCE\xED\xF0\xF0\xF3\x93\x82\x2C\xD7\xE3\xF4\xCC\xF4\xF2\xE7\xF1\xE2\xEF\xFE\xF2\xF8\xF9\xF9\xF6\xF5\xF8\xF3\xC3\x03\xF5\xED\xD2\x0C\x6E\x6C\x78\x7D\xA1\x44\x87\x69\x7E\x05\x88\x87\x83\x7E\xF7\x4D\x8A\x7E\x83\x09\x8C\x8F\x83\x84\x11\x90\x8B\x82\x85\xCF\x5A\x74\x73\x86\xCC\x5C\x84\x76\x87\x1A\x9D\x82\x8B\x87\x23\xA1\x84\x8B\x89\x26\xA9\x8D\x79\x85\x14\x97\x8D\x89\x86\x2B\xAE\x8C\x8B\x8C\x32\xB5\x80\x8E\x81\x37\x8A\x89\x8E\x84\x34\xBB\x88\x87\x80\x3A\x80\x93\x65\x01\xFE\x5B\x78\x8E\x90\x3F\xBF\x77\x92\x92\x41\x8C\x9C\x8E\x8D\x48\xAF\x81\x95\x8F\x53\x90\x9E\x91\x92\x46\x8D\x99\x97\x93\x3E\x92\x97\x96\x97\x5B\x98\x90\x89\x8C\x5D\x94\x9F\x96\x99\x61\xA0\x93\x9B\x92\x69\xA8\x90\x8B\x45\x61\x55\x95\x9A\x95\x6D\xB4\x9B\x9A\x96\x77\x9C\x92\x9F\x9E\x67\xB6\x92\x43\x01\x45\xB9\x92\x99\x89\x64\xBC\x95\x9F\x9C\x88\x8A\x48\x01\xA0\x84\xAC\x92\xA2\x9A\x8D\xB8\x91\xA6\x9E\x7D\x89\xA5\xA6\xA1\x20\x89\x0C\xA0\x8A\x85\x97\xAE\xA7\xA1\x98\x93\xA3\xA1\x40\x0A\x1B\xAA\x8A\xA3\x25\x8B\x06\xA9\xA7", + "\xA0\x9F\xAF\xA2\x9B\xA2\x90\xAC\xA4\xAA\xB3\x92\xA5\xAC\xA5\xAD\xB9\xAF\xAA\x9F\xB7\xA3\xA7\xAA\xAD\xBF\xB8\xAB\xAE\xA5\xBA\xB1\xA0\xAD\xAF\xB2\x81\xBE\xAE\x43\x02\xAE\xA6\xB0\xAF\xCA\x89\xBC\xAB\xB0\xA1\x88\xB7\xB1\xB4\xD7\x93\xBF\xB0\xB1\x20\x8D\x0B\xA8\xAD\xD8\x90\xBA\xB6\xB5\xE2\xA0\xB3\xB9\xB8\xDC\x9B\xB5\xB4\xBA\xEB\xA7\xBE\xBA\xB9\xF0\x80\xBF\xBA\xBC\xF1\x82\xBA\xBA\xB3\xE4\xA9\xB9\xBD\xBB\xF5\xBE\xA3\xBE\xBD\xFB\xB8\xBC\xBA\xC0\xFF\xBE\xBD\xBE\xB4\x07\xD9\xB9\xC1\xB9\xF4\x8D\xC0\xC3\xC0\xC5\x81\x4E\x03\xB7\x0E\xC6\xC5\xC4\xC2\x17\xCA\xC9\xC4\xC3\x0F\xC5\xC8\xC5\xC7\x0B\xD9\x8F\x00\xC5\x20\xDB\xCA\xBC\xC4\xD4\x84\xC1\xC8\xBF\x26\xEC\xC5\xCB\xCB\x16\xF0\xCF\xC5\xCC\x8B\x50\x04\xC8\xCD\x33\xF9\xCA\xC6\xCC\xD7\x91\x07\xCE\xCE\x1C\xF8\xCB\xCE\xD0\x41\xC0\xD7\xCA\xC7\x43\xC6\xDE\xC8\xD1\x47\xEB\xCA\xC9\xCB\x4F\xFC\xC5\xD1\xD2\x54\xD3\xD6\xD5\xD3\x50\xD5\x72\x07\xCF\x55\xD8\xD2\xD6\xD7\x4C\xCB\xDA\xD1\xD4\x61\xE4\xD9\xB3\x04\x5C\xD7\xD2\xD9\xD7\x6B\xEA\xD6\xD8\xDB\x6F\xEE\xD1\xC4\xCA\xF7\xB3\xD8\xD0\xB4\x14", + "\x29\xD0\xDB\xD8\x76\xCE\xDD\xDD\xD6\x29\xFF\xDF\xD5\xDB\x7B\xF0\xD6\x41\x05\x7A\xC4\xEA\xE1\xDC\x85\xF2\xD1\xE3\xE3\x75\xE0\x86\x06\x42\xEA\x4C\xEB\xE2\xE0\x65\xD8\xEC\xDC\xE4\x01\xDA\xE6\xE0\xE7\x00\x18\x09\xE2\xE5\xA4\xDE\xEE\xE1\xE4\x25\x99\x06\xAA\x06\xA3\xC6\x4B\x05\xEB\xA0\xF7\xDD\xE3\xEC\x97\xF1\xEE\xDE\xED\x80\xE8\xED\xE4\xEE\x83\xE5\xEC\xED\xE6\xBF\xDB\xEA\xEC\xDD\xBB\xC3\xF2\xED\xED\xC6\xF7\xE9\xF0\xB0\x1C\x30\xE5\x89\x07\xCE\xC5\xF2\xF4\xF1\xD4\xC7\xFE\xEF\xF2\xBD\xE6\xE4\xEF\xF5\xD3\xD6\xF3\xDE\x07\xD1\xD5\xFA\xF1\xF7\xE3\xE2\xF9\xEC\xF9\xE7\xE6\xF9\xF5\xF0\x9F\xD8\xF0\xF2\xFB\xC2\xE8\xFB\xF8\xFC\xED\xF2\xFF\xFA\xFD\xF1\xD4\xFF\x05\xF8\xDE\xEC\xF7\xE8\xFE\xF5\x6A\x7F\xFD\x29\x40\x04\xFE\x65\x7F\x5C\x21\x06\x81\xFA\x7D\x74\x7F\xFF\x42\x81\x7F\x0C\x80\x82\x03\x91\x8F\x81\x00\x94\x87\x82\x07\x85\x7E\x44\x4D\x5A\x7A\xE4\x52\x83\x7B\x1D\x9C\x78\xF5\x00\x2C\x82\xFF\x60\x86\x84\x1E\x95\x83\x04\x99\x8B\x80\x16\x93\x34\x04\x0A\x93\x7F\x07\xEB\x55\x05\x18\x83\x80\x83\x2D\x99\x86\x0C\xAA\x87\x85\x06\x99\x44", + "\x22\x25\x9E\x85\x0A\x94\x87\x04\x1B\x90\x86\x85\x37\x88\x8B\x11\xE9\x78\x04\x23\x96\x82\x89\x4F\x9A\x85\x12\xD2\x8B\x89\x1D\xB8\x86\x8A\x50\x8B\x85\x64\x29\x06\x54\x15\x14\x77\x3A\x2C\x06\x55\x0B\x4E\x8A\x8A\x2C\x94\x89\x8A\x66\x89\x8F\x14\xEA\x85\x8B\x35\xAE\x8D\x8D\x70\x88\x8F\x1B\xF2\x81\x8F\x32\xB3\x8E\x8E\x75\x87\x66\x0B\x64\x8D\x87\x19\xA2\x87\x8A\x77\x9D\x8C\x0F\xC3\x89\x8A\x41\xA7\x5F\x05\x7C\x84\x93\x19\xF8\x84\x8F\x46\x8C\x97\x91\x86\x85\x92\x22\xEC\x8A\x32\x18\x26\x51\x06\x5F\x99\x3B\x0C\x26\x54\x07\x44\xBF\x8A\x92\x9F\x8B\x91\x24\xA2\x93\x93\x40\xA5\x91\x8F\xA7\x8E\x93\x28\x94\x90\x93\x54\xAD\x91\x94\x3B\x95\x05\xF8\x36\x06\x55\x1B\x19\x95\x3A\x39\x06\x56\x0E\x1E\x91\x85\x5E\xA8\x80\x96\xA6\x80\x98\x2A\xC2\x97\x5B\x1D\x21\x7C\x07\xA6\x5D\x07\x2D\xA0\x4F\x06\x53\x40\x0C\x97\xBF\x9E\x96\x10\xC4\x9F\x94\x69\xBE\x8E\x9A\x83\x89\x22\x21\x4B\x9E\x33\x73\x41\x46\x20\xA5\x4E\x2C\x91\x09\x2B\x6A\xB0\x06\x20\x50\x6E\x31\x47\x6B\x03\x25\x72\xBF\x27\x5D\x9D\x97\x2A\x9E\x39\xFE\x2B\x9D\x79\xAE\x20\x9E\xF6\x85", + "\x27\x38\x86\x28\x9F\xD1\x27\x5C\x2C\xFB\x8C\x9C\x53\x5E\x9A\x20\x4D\x62\x9A\x21\x9B\x93\x9E\x40\x01\xA2\x21\x4E\x89\x25\x9F\x00\x0C\xA1\x40\x3E\x69\x21\x6F\x83\x20\x9D\xEE\x86\x41\x7F\x0F\xA3\xA0\x70\x64\x2D\x9E\x01\x20\xA4\x58\x16\xA9\x9E\x91\x2A\x51\x88\x21\xAA\x20\x9C\x25\xAF\x23\x93\x86\x24\xA4\x01\x32\xA2\x69\x32\xAE\xA5\x38\x49\x22\xA6\xCC\x4F\xA6\x42\x32\xAE\x5B\x9B\xBB\xA5\x21\x2A\xBF\xA5\x42\x3D\xA7\x9C\xA1\x86\x21\xA7\x03\x21\x9D\x51\xE9\x95\x24\x91\x90\xA2\xA9\x0A\xAE\x25\x4D\xAC\xAB\x22\x83\x8A\xA6\x34\x8B\x57\xAA\x69\x1B\xA7\xAA\x97\x32\xA4\x2C\x18\xB1\xA9\x49\x10\xA0\xA2\x97\x32\x9C\xA3\x4C\xA0\x59\x59\xE6\xAA\x40\x88\x9F\xA2\xAB\xA6\x2E\xAC\x53\x72\xAE\x2C\xAE\xA2\xAA\x24\x2B\xA6\x9E\x4B\x30\xA0\x2C\xAF\xB0\xAE\x25\x79\xA0\x03\x5A\xEC\xAE\x56\xB2\x19\xAC\x9F\x1D\xA0\x5A\x61\x8A\x2C\xAE\xBE\xBE\xA9\x21\x09\xB7\xAA\x4C\x87\xB6\xA6\x83\x32\xA6\xA1\x06\x36\xAF\x42\x85\xA6\xA9\x81\x32\xA0\xAA\x7F\x4A\x21\x58\xDD\x93\xAD\xC4\x8F\x4E\xA9\xA6\xBE\x57\x60\x84\xB7\x5B\xD5\xAC\xB4\x2C\x64\xA9\xB5\x8B\x22", + "\xA3\xB4\x7F\xA5\x25\xB6\xA6\x37\x9E\x6C\xB4\x48\xB5\xB4\x8F\x66\xB5\x84\xB9\x40\x70\xEC\xA0\xB6\x6E\xB6\xB2\x41\x22\xBC\xAE\x66\xA3\x32\xA6\xDC\x9D\x25\xB9\xA6\x58\xB4\x6B\x9B\x23\xB8\xB3\xAF\xA8\xAD\x19\xAA\xAF\x6E\xD0\x55\xBB\x18\x71\xB6\xB7\x16\x49\xBA\x42\x4B\xB3\xA6\xD1\xB0\xA8\xBA\x28\xA0\x02\x74\xD3\xB9\x23\xEE\x86\x45\xB7\xD9\xBF\xB7\x76\xC2\xB3\xBF\xB9\x86\xB9\xB7\xEF\xA3\xBC\x53\x4A\xBB\xBE\xFD\xAE\x28\xB7\xE4\xAE\x24\x6E\xEE\xB2\x24\x02\xDF\x26\xC0\x1B\x21\xC0\x6A\x0A\xC2\x24\x91\x8C\xC7\x23\x22\xA5\x8A\x56\xF0\xB3\x20\xF2\xBC\xAA\xA6\x8D\xBD\xB3\x41\x0C\xB1\xA8\x9F\x89\x21\xB0\x7C\xA0\xC5\x87\x96\xB6\xBD\x8A\xA5\xC4\xC4\x09\x38\xB4\x5F\xAA\xC7\xC4\xCF\x8A\x54\xC3\x09\x34\xB3\x66\xB1\xC0\xC6\x83\x32\xC1\x20\x7C\xB7\xC5\x44\xF0\xA6\xAA\x85\xBD\xC5\x44\x1D\x3C\x0E\xA9\x1D\x2F\xC6\x14\x5D\x25\x0F\xA6\x50\xA1\x01\xD9\x3D\x22\x3F\x09\xCA\x21\x4B\xD5\x39\x47\x7F\x06\x54\xF2\xB5\x81\x3B\xE4\xA0\x12\xA9\x22\xA0\x86\x2C\xCA\x21\x10\xA6\x5C\xAD\x13\xCC\xCA\x20\x41\x37\xBC\xAF\x5C\x84\xCD\x42\x04\x11\xCC\x85", + "\x29\xCA\xCA\x0A\x25\x12\xA9\x41\x00\xAF\x07\xC5\xB7\xBE\xA5\x30\xA2\x48\xEF\x9E\xBF\xEA\x24\xBD\xBA\x19\x52\xA7\x9E\xA8\x31\xC5\x75\x41\xB0\xD0\x35\xD7\xA3\xBA\x3A\xC8\xD1\x0F\xED\xC3\x78\xA0\xA9\xA5\x76\x38\xB3\xAB\xE9\x55\xD0\x00\x83\xD1\x32\x8E\x91\xD4\x7A\xA4\x82\x21\xD3\x93\x3A\xC6\x9D\xC9\x54\xA8\x81\x93\xC4\xB3\x09\x3C\xD3\xB9\x23\x69\xBD\xD2\x05\xC8\x00\xA3\xD7\x5A\xCD\x58\xB5\xB3\x5A\xC2\x24\xD3\x32\xA7\x5D\x39\xA8\xC5\x3B\x4B\xFA\xC7\x5C\x10\x2D\xD4\x6A\x1E\xD2\x63\x75\x62\x74\xD6\x25\x53\x61\x42\x13\x72\x60\xD6\x42\xD9\x32\xAC\xC6\x20\x45\xF3\x6F\x74\x64\xE8\x43\xD6\xD2\xCB\x5C\xF4\x56\xD9\x45\x69\xC3\x25\xD4\xC3\x7B\x7C\x8D\xD9\x3B\xD7\x81\x1E\xDB\x78\x12\xC8\xB1\x76\x68\x64\x9D\x75\x6F\xCE\xD6\x28\x59\x6D\x42\x6C\xD3\x6E\x2F\x8F\xDB\x32\x88\x69\x21\xB4\xA0\x7B\x05\xF0\x79\xDE\x20\xD8\xC0\x75\x18\xF7\xDB\x31\x7F\xC3\x22\xDE\x73\x63\x8C\xC1\x8F\x3C\xD9\xC3\x6B\x5B\x8F\x0B\xFA\x31\xB0\x86\x2E\xD9\xB9\x48\x94\xDB\xA5\x33\xE3\x40\x2A\x72\x60\x4C\x98\xE0\x35\x1A\xE2\x21\xB5\xF3\x61\xB2\x53\xD5\x3C\xE3", + "\x14\xEB\x5E\x2C\x91\xEF\x32\x94\xC3\x23\xE4\xA0\x74\x94\xCB\x9D\x25\xE3\x97\xEB\x5E\x96\x33\xEA\x20\xCC\x82\x2D\x78\x81\x78\x01\x7C\x3D\xE6\x22\xB8\xF3\x69\x97\x9C\xC9\x21\xE8\x03\x3B\xDB\xDC\x3B\x96\xE8\x83\x0A\xEB\x20\xE0\x62\x62\x31\xCD\xE0\xEA\x85\x03\xE8\x74\xC8\x94\xEA\x40\x57\xE2\x20\x65\xF3\x6A\x99\xDC\xDA\xCE\xD5\x8A\x29\x80\x81\x4D\x9A\xEB\x01\x31\xCB\x40\x5E\xE0\x75\x67\x9C\xDC\xBC\x22\xAA\xEE\x40\x65\xE3\x6E\x21\x21\x7C\xEE\x03\x27\xDB\xDC\x43\x0F\xD0\x14\x5B\x81\xE5\x02\x6A\x0B\x99\xA6\x5F\xEF\x81\x01\xB7\x5C\x4C\x17\xBE\xA0\x91\x2A\x20\x97\xC3\x7E\x09\xF7\xA1\xB2\x48\x85\xF2\xE5\x75\x50\x0F\xBE\xB8\xB3\xF1\xDF\xD4\x72\x0B\xFB\xBA\xC4\xCB\x0A\x24\x87\xDC\x54\x01\x7D\x2B\xC6\x22\xF4\xA0\x75\x09\xF8\x40\x80\xF1\xB9\x56\x0F\xBE\xAF\xD0\xA0\xEB\x86\xFB\x5C\x2C\x37\xBF\xD2\xB2\xED\xF3\xBA\x5A\x07\xBE\x70\xC1\x21\xF7\x09\x3B\xE7\xF4\x5C\x07\xBF\x7D\xC2\x20\xF8\x4B\xB3\x6E\x17\x77\xB7\xDD\xDF\xCA\x23\xCC\x06\x29\xDC\xE8\x60\x09\xD1\x12\x50\xFB\x20\x35\xE3\x78\x19\x77\xB4\xDE\x93\xC3\x27\xFA\x1B\xC2\x62", + "\x19\x77\xB6\xE1\xE3\xCF\xFA\xF7\x02\x68\x0F\x7D\xA1\xEE\xF9\x84\x20\xF9\x20\xC2\xF4\x7A\x1A\x77\xBE\xF1\xF6\xC6\x27\xFD\xEA\xAB\x5C\x1B\x77\xB1\xFE\x88\xAF\xDA\x20\xD2\x73\x3C\x6E\x05\x7D\x28\x2F\x7F\x01\x19\x7D\xD3\x32\x07\xF7\x5F\x74\xE6\x79\x10\x06\x84\x10\xEB\x24\x07\xF7\x5C\x75\xF6\x73\x10\x0F\x85\x7F\xD4\x36\x07\xF7\x58\x77\x0D\x86\x10\x0F\x81\x7F\xE7\x28\x07\xF7\x58\x7A\x1D\x86\x81\x9B\x77\x2E\x7A\x07\x5F\xA6\x7E\x7D\x02\x16\x6F\x70\x5D\x12\x2F\x82\x69\xAD\x62\x52\x98\x6D\x11\x34\x87\x83\x36\x8D\x11\x6E\x55\x56\x3B\x8A\x83\x3E\x87\x5F\x82\x5F\x83\xDC\x61\x84\x7D\x69\x59\x2D\x14\x5E\xB0\x6D\x11\x48\x8B\x84\x4A\x8D\x84\x45\x85\x61\x1D\x1C\x57\x00\x0E\x58\x52\x82\x85\x5F\x59\x6B\x57\x8F\x82", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -14357,9 +11129,7 @@ namespace vl::glr::parsergen static const wchar_t* results[] = { L"EnumItem", L"Enum", - L"ClassPropType", L"classProp", - L"ClassBody", L"Class", L"Type", L"File", @@ -14382,42 +11152,36 @@ namespace vl::glr::parsergen L"[9][Enum]< [ \"@public\" ] \"enum\" ID \"{\" { EnumItem @ } \"}\" >", L"[10][Enum]< [ \"@public\" ] \"enum\" ID \"{\" { EnumItem } \"}\" @ >", L"[11][Enum]< [ \"@public\" ] \"enum\" ID @ \"{\" { EnumItem } \"}\" >", - L"[12][ClassPropType] BEGIN ", - L"[13][ClassPropType] END [ENDING]", - L"[14][ClassPropType]\"token\" @", - L"[15][ClassPropType]ID \"[\" \"]\" @", - L"[16][ClassPropType]ID \"[\" @ \"]\"", - L"[17][ClassPropType]ID @", - L"[18][ClassPropType]ID @ \"[\" \"]\"", - L"[19][classProp] BEGIN ", - L"[20][classProp] END [ENDING]", - L"[21][classProp]< \"var\" @ ID \":\" ClassPropType \";\" >", - L"[22][classProp]< \"var\" ID \":\" @ ClassPropType \";\" >", - L"[23][classProp]< \"var\" ID \":\" ClassPropType \";\" @ >", - L"[24][classProp]< \"var\" ID \":\" ClassPropType @ \";\" >", - L"[25][classProp]< \"var\" ID @ \":\" ClassPropType \";\" >", - L"[26][ClassBody] BEGIN ", - L"[27][ClassBody] END [ENDING]", - L"[28][ClassBody]ID @ [ \":\" ID ] \"{\" { classProp } \"}\"", - L"[29][ClassBody]ID [ \":\" @ ID ] \"{\" { classProp } \"}\"", - L"[30][ClassBody]ID [ \":\" ID @ ] \"{\" { classProp } \"}\"", - L"[31][ClassBody]ID [ \":\" ID ] \"{\" @ { classProp } \"}\"", - L"[32][ClassBody]ID [ \":\" ID ] \"{\" { classProp @ } \"}\"", - L"[33][ClassBody]ID [ \":\" ID ] \"{\" { classProp } \"}\" @", - L"[34][Class] BEGIN ", - L"[35][Class] END [ENDING]", - L"[36][Class]< [ \"@public\" @ ] [ \"@ambiguous\" ] \"class\" ClassBody >", - L"[37][Class]< [ \"@public\" ] [ \"@ambiguous\" @ ] \"class\" ClassBody >", - L"[38][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" @ ClassBody >", - L"[39][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ClassBody @ >", - L"[40][Type] BEGIN ", - L"[41][Type] END [ENDING]", - L"[42][Type]<< ( !Enum @ | !Class ) >>", - L"[43][Type]<< ( !Enum | !Class @ ) >>", - L"[44][File] BEGIN ", - L"[45][File] END [ENDING]", - L"[46][File]< Type @ { Type } >", - L"[47][File]< Type { Type @ } >", + L"[12][classProp] BEGIN ", + L"[13][classProp] END [ENDING]", + L"[14][classProp]< \"var\" @ ID \":\" ( \"token\" | ID | ID \"[\" \"]\" ) \";\" >", + L"[15][classProp]< \"var\" ID \":\" ( \"token\" @ | ID | ID \"[\" \"]\" ) \";\" >", + L"[16][classProp]< \"var\" ID \":\" ( \"token\" | ID @ | ID \"[\" \"]\" ) \";\" >", + L"[17][classProp]< \"var\" ID \":\" ( \"token\" | ID | ID \"[\" \"]\" ) \";\" @ >", + L"[18][classProp]< \"var\" ID \":\" ( \"token\" | ID | ID \"[\" \"]\" @ ) \";\" >", + L"[19][classProp]< \"var\" ID \":\" ( \"token\" | ID | ID \"[\" @ \"]\" ) \";\" >", + L"[20][classProp]< \"var\" ID \":\" ( \"token\" | ID | ID @ \"[\" \"]\" ) \";\" >", + L"[21][classProp]< \"var\" ID \":\" @ ( \"token\" | ID | ID \"[\" \"]\" ) \";\" >", + L"[22][classProp]< \"var\" ID @ \":\" ( \"token\" | ID | ID \"[\" \"]\" ) \";\" >", + L"[23][Class] BEGIN ", + L"[24][Class] END [ENDING]", + L"[25][Class]< [ \"@public\" @ ] [ \"@ambiguous\" ] \"class\" ID [ \":\" ID ] \"{\" { classProp } \"}\" >", + L"[26][Class]< [ \"@public\" ] [ \"@ambiguous\" @ ] \"class\" ID [ \":\" ID ] \"{\" { classProp } \"}\" >", + L"[27][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" @ ID [ \":\" ID ] \"{\" { classProp } \"}\" >", + L"[28][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID @ [ \":\" ID ] \"{\" { classProp } \"}\" >", + L"[29][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID [ \":\" @ ID ] \"{\" { classProp } \"}\" >", + L"[30][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID [ \":\" ID @ ] \"{\" { classProp } \"}\" >", + L"[31][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID [ \":\" ID ] \"{\" @ { classProp } \"}\" >", + L"[32][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID [ \":\" ID ] \"{\" { classProp @ } \"}\" >", + L"[33][Class]< [ \"@public\" ] [ \"@ambiguous\" ] \"class\" ID [ \":\" ID ] \"{\" { classProp } \"}\" @ >", + L"[34][Type] BEGIN ", + L"[35][Type] END [ENDING]", + L"[36][Type]", + L"[37][Type]", + L"[38][File] BEGIN ", + L"[39][File] END [ENDING]", + L"[40][File]< Type @ { Type } >", + L"[41][File]< Type { Type @ } >", }; return results[index]; } @@ -14489,14 +11253,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::Ptr(new vl::glr::parsergen::GlrEnum); case ParserGenClasses::EnumItem: return vl::Ptr(new vl::glr::parsergen::GlrEnumItem); - case ParserGenClasses::LeftRecursionInjectClause: - return vl::Ptr(new vl::glr::parsergen::GlrLeftRecursionInjectClause); - case ParserGenClasses::LeftRecursionInjectContinuation: - return vl::Ptr(new vl::glr::parsergen::GlrLeftRecursionInjectContinuation); - case ParserGenClasses::LeftRecursionPlaceholder: - return vl::Ptr(new vl::glr::parsergen::GlrLeftRecursionPlaceholder); - case ParserGenClasses::LeftRecursionPlaceholderClause: - return vl::Ptr(new vl::glr::parsergen::GlrLeftRecursionPlaceholderClause); case ParserGenClasses::LoopSyntax: return vl::Ptr(new vl::glr::parsergen::GlrLoopSyntax); case ParserGenClasses::NotCondition: @@ -14507,8 +11263,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::Ptr(new vl::glr::parsergen::GlrOrCondition); case ParserGenClasses::PartialClause: return vl::Ptr(new vl::glr::parsergen::GlrPartialClause); - case ParserGenClasses::PrefixMergeClause: - return vl::Ptr(new vl::glr::parsergen::GlrPrefixMergeClause); case ParserGenClasses::PushConditionSyntax: return vl::Ptr(new vl::glr::parsergen::GlrPushConditionSyntax); case ParserGenClasses::RefCondition: @@ -14559,16 +11313,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrCreateClause::syntax, object, field, value, cppFieldName); case ParserGenFields::Enum_items: return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrEnum::items, object, field, value, cppFieldName); - case ParserGenFields::LeftRecursionInjectClause_continuation: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLeftRecursionInjectClause::continuation, object, field, value, cppFieldName); - case ParserGenFields::LeftRecursionInjectClause_rule: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLeftRecursionInjectClause::rule, object, field, value, cppFieldName); - case ParserGenFields::LeftRecursionInjectContinuation_flags: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLeftRecursionInjectContinuation::flags, object, field, value, cppFieldName); - case ParserGenFields::LeftRecursionInjectContinuation_injectionTargets: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLeftRecursionInjectContinuation::injectionTargets, object, field, value, cppFieldName); - case ParserGenFields::LeftRecursionPlaceholderClause_flags: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLeftRecursionPlaceholderClause::flags, object, field, value, cppFieldName); case ParserGenFields::LoopSyntax_delimiter: return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrLoopSyntax::delimiter, object, field, value, cppFieldName); case ParserGenFields::LoopSyntax_syntax: @@ -14585,8 +11329,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrPartialClause::assignments, object, field, value, cppFieldName); case ParserGenFields::PartialClause_syntax: return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrPartialClause::syntax, object, field, value, cppFieldName); - case ParserGenFields::PrefixMergeClause_rule: - return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrPrefixMergeClause::rule, object, field, value, cppFieldName); case ParserGenFields::PushConditionSyntax_switches: return vl::glr::AssemblerSetObjectField(&vl::glr::parsergen::GlrPushConditionSyntax::switches, object, field, value, cppFieldName); case ParserGenFields::PushConditionSyntax_syntax: @@ -14637,8 +11379,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::glr::AssemblerSetTokenField(&vl::glr::parsergen::GlrCreateClause::type, object, field, token, tokenIndex, cppFieldName); case ParserGenFields::EnumItem_name: return vl::glr::AssemblerSetTokenField(&vl::glr::parsergen::GlrEnumItem::name, object, field, token, tokenIndex, cppFieldName); - case ParserGenFields::LeftRecursionPlaceholder_flag: - return vl::glr::AssemblerSetTokenField(&vl::glr::parsergen::GlrLeftRecursionPlaceholder::flag, object, field, token, tokenIndex, cppFieldName); case ParserGenFields::PartialClause_type: return vl::glr::AssemblerSetTokenField(&vl::glr::parsergen::GlrPartialClause::type, object, field, token, tokenIndex, cppFieldName); case ParserGenFields::RefCondition_name: @@ -14677,10 +11417,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase return vl::glr::AssemblerSetEnumField(&vl::glr::parsergen::GlrAssignment::type, object, field, enumItem, weakAssignment, cppFieldName); case ParserGenFields::ClassProp_propType: return vl::glr::AssemblerSetEnumField(&vl::glr::parsergen::GlrClassProp::propType, object, field, enumItem, weakAssignment, cppFieldName); - case ParserGenFields::LeftRecursionInjectContinuation_configuration: - return vl::glr::AssemblerSetEnumField(&vl::glr::parsergen::GlrLeftRecursionInjectContinuation::configuration, object, field, enumItem, weakAssignment, cppFieldName); - case ParserGenFields::LeftRecursionInjectContinuation_type: - return vl::glr::AssemblerSetEnumField(&vl::glr::parsergen::GlrLeftRecursionInjectContinuation::type, object, field, enumItem, weakAssignment, cppFieldName); case ParserGenFields::OptionalSyntax_priority: return vl::glr::AssemblerSetEnumField(&vl::glr::parsergen::GlrOptionalSyntax::priority, object, field, enumItem, weakAssignment, cppFieldName); case ParserGenFields::RefSyntax_refType: @@ -14706,16 +11442,11 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"CreateClause", L"Enum", L"EnumItem", - L"LeftRecursionInjectClause", - L"LeftRecursionInjectContinuation", - L"LeftRecursionPlaceholder", - L"LeftRecursionPlaceholderClause", L"LoopSyntax", L"NotCondition", L"OptionalSyntax", L"OrCondition", L"PartialClause", - L"PrefixMergeClause", L"PushConditionSyntax", L"RefCondition", L"RefSyntax", @@ -14731,7 +11462,7 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"UseSyntax", }; vl::vint index = (vl::vint)type; - return 0 <= index && index < 34 ? results[index] : nullptr; + return 0 <= index && index < 29 ? results[index] : nullptr; } const wchar_t* ParserGenCppTypeName(ParserGenClasses type) @@ -14748,16 +11479,11 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"vl::glr::parsergen::GlrCreateClause", L"vl::glr::parsergen::GlrEnum", L"vl::glr::parsergen::GlrEnumItem", - L"vl::glr::parsergen::GlrLeftRecursionInjectClause", - L"vl::glr::parsergen::GlrLeftRecursionInjectContinuation", - L"vl::glr::parsergen::GlrLeftRecursionPlaceholder", - L"vl::glr::parsergen::GlrLeftRecursionPlaceholderClause", L"vl::glr::parsergen::GlrLoopSyntax", L"vl::glr::parsergen::GlrNotCondition", L"vl::glr::parsergen::GlrOptionalSyntax", L"vl::glr::parsergen::GlrOrCondition", L"vl::glr::parsergen::GlrPartialClause", - L"vl::glr::parsergen::GlrPrefixMergeClause", L"vl::glr::parsergen::GlrPushConditionSyntax", L"vl::glr::parsergen::GlrRefCondition", L"vl::glr::parsergen::GlrRefSyntax", @@ -14773,7 +11499,7 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"vl::glr::parsergen::GlrUseSyntax", }; vl::vint index = (vl::vint)type; - return 0 <= index && index < 34 ? results[index] : nullptr; + return 0 <= index && index < 29 ? results[index] : nullptr; } const wchar_t* ParserGenFieldName(ParserGenFields field) @@ -14798,14 +11524,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"CreateClause::type", L"Enum::items", L"EnumItem::name", - L"LeftRecursionInjectClause::continuation", - L"LeftRecursionInjectClause::rule", - L"LeftRecursionInjectContinuation::configuration", - L"LeftRecursionInjectContinuation::flags", - L"LeftRecursionInjectContinuation::injectionTargets", - L"LeftRecursionInjectContinuation::type", - L"LeftRecursionPlaceholder::flag", - L"LeftRecursionPlaceholderClause::flags", L"LoopSyntax::delimiter", L"LoopSyntax::syntax", L"NotCondition::condition", @@ -14816,7 +11534,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"PartialClause::assignments", L"PartialClause::syntax", L"PartialClause::type", - L"PrefixMergeClause::rule", L"PushConditionSyntax::switches", L"PushConditionSyntax::syntax", L"RefCondition::name", @@ -14844,7 +11561,7 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"UseSyntax::name", }; vl::vint index = (vl::vint)field; - return 0 <= index && index < 63 ? results[index] : nullptr; + return 0 <= index && index < 54 ? results[index] : nullptr; } const wchar_t* ParserGenCppFieldName(ParserGenFields field) @@ -14869,14 +11586,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"vl::glr::parsergen::GlrCreateClause::type", L"vl::glr::parsergen::GlrEnum::items", L"vl::glr::parsergen::GlrEnumItem::name", - L"vl::glr::parsergen::GlrLeftRecursionInjectClause::continuation", - L"vl::glr::parsergen::GlrLeftRecursionInjectClause::rule", - L"vl::glr::parsergen::GlrLeftRecursionInjectContinuation::configuration", - L"vl::glr::parsergen::GlrLeftRecursionInjectContinuation::flags", - L"vl::glr::parsergen::GlrLeftRecursionInjectContinuation::injectionTargets", - L"vl::glr::parsergen::GlrLeftRecursionInjectContinuation::type", - L"vl::glr::parsergen::GlrLeftRecursionPlaceholder::flag", - L"vl::glr::parsergen::GlrLeftRecursionPlaceholderClause::flags", L"vl::glr::parsergen::GlrLoopSyntax::delimiter", L"vl::glr::parsergen::GlrLoopSyntax::syntax", L"vl::glr::parsergen::GlrNotCondition::condition", @@ -14887,7 +11596,6 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"vl::glr::parsergen::GlrPartialClause::assignments", L"vl::glr::parsergen::GlrPartialClause::syntax", L"vl::glr::parsergen::GlrPartialClause::type", - L"vl::glr::parsergen::GlrPrefixMergeClause::rule", L"vl::glr::parsergen::GlrPushConditionSyntax::switches", L"vl::glr::parsergen::GlrPushConditionSyntax::syntax", L"vl::glr::parsergen::GlrRefCondition::name", @@ -14915,7 +11623,7 @@ ParserGenAstInsReceiver : public vl::glr::AstInsReceiverBase L"vl::glr::parsergen::GlrUseSyntax::name", }; vl::vint index = (vl::vint)field; - return 0 <= index && index < 63 ? results[index] : nullptr; + return 0 <= index && index < 54 ? results[index] : nullptr; } vl::Ptr ParserGenAstInsReceiver::ResolveAmbiguity(vl::vint32_t type, vl::collections::Array>& candidates) @@ -14983,10 +11691,6 @@ namespace vl::glr::parsergen L"WEAK_ASSIGN", L"POSITIVE", L"NEGATIVE", - L"LS_PH", - L"LS_I", - L"LS_IM", - L"LS_PM", L"ID", L"STRING", L"CONDITIONAL_LITERAL", @@ -15030,10 +11734,6 @@ namespace vl::glr::parsergen L"?=", L"+", L"-", - L"left_recursion_placeholder", - L"left_recursion_inject", - L"left_recursion_inject_multiple", - L"prefix_merge", nullptr, nullptr, nullptr, @@ -15077,10 +11777,6 @@ namespace vl::glr::parsergen L"/?=", L"/+", L"-", - L"left_recursion_placeholder", - L"left_recursion_inject", - L"left_recursion_inject_multiple", - L"prefix_merge", L"[a-zA-Z_][a-zA-Z0-9_]*", L"(\"[^\"]*\")+", L"(\'[^\']*\')+", @@ -15093,22 +11789,20 @@ namespace vl::glr::parsergen void ParserGenLexerData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 2348; // 39623 bytes before compressing + static const vl::vint dataLength = 1801; // 25496 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 44; - static const vl::vint dataSolidRows = 9; - static const vl::vint dataRows = 10; + static const vl::vint dataRemain = 9; + static const vl::vint dataSolidRows = 7; + static const vl::vint dataRows = 8; static const char* compressed[] = { - "\xC7\x9A\x00\x00\x24\x09\x00\x00\x94\x00\x01\x81\x21\x84\x81\x80\x20\x82\x01\x04\x88\x04\x89\x04\x84\x82\x05\x0F\x84\x8B\x04\x8C\x04\x81\x06\x8B\x04\x8E\x04\x9F\x04\x80\x11\x8E\x82\x21\x20\x84\x82\x13\x94\x83\x10\x82\x25\x04\xA6\x0A\x94\x87\x11\x96\x82\x28\x30\x84\x89\x13\x9C\x82\x14\x9B\x04\xAB\x39\x84\x8C\x14\x9C\x83\x16\x3F\x84\xAE\x02\xA4\x87\x15\xA2\x82\x30\x04\xB9\x04\x8A\x1C\xA4\x83\x1D\x4F\x84\xBC\x12\xA4\x85\x1D\xAA\x82\x3E\x58\x84\x9F\x1B\xAC\x83\x82\x83\x04\x83\x81\x9A\x24\x83\x2D\xB2\x82\x5C\x68\x84\x9D\x2B\xB4\x82\x2E\xB7\x04\xDF\x31\xA4\x80\x34\xB8\x83\x30\x77\x84\xA2\x3A\xB4\x83\x31\xBE\x82\x64\x00\xC4\x85\x33\xC4\x82\x32\xC3\x04\xE7\x09\xC4\x88\x34\xC4\x83\x34\x8F\x84\xAA\x32\xC4\x83\x35\xCA\x82\x6C\x18\xC4\x8D\x3B\xCC\x82\x36\xCF\x04\xEF\x21\xC4\x80\x3C\xD0\x83\x38\xA7\x84\xB2\x2A\xD4\x83\x39\xD6\x82\x74\x30\xC4\x95\x33\xDC\x82\x3A\xDB\x04\xF7\x39\xC4\x88\x3C\xDC\x83\x3C\x04\xFA\x04\x9B\x33\xE4\x80\x3E\xE3\x04\xFD\x09\xE4\x8E\x3C\x83\x7F\x7F\x10\x00\x0F\xEF\xED\x0C\x81\xEB\x80\xD3\xFF\x57\xF2", - "\xE3\xEB\xEF\x06\x82\x1B\x4E\xD3\xF1\x04\x84\x0E\x87\x80\x10\xD8\xD3\xF7\x04\x83\x08\x82\x0C\xE2\xCF\xDE\x11\xFF\x7C\x08\x83\x0A\xF4\x96\x34\xF1\xE1\x81\x85\x80\x0D\x12\x74\x75\x46\x7A\xCF\x40\x84\x83\x3F\x07\x04\x46\x80\x00\x02\x0A\x84\x43\x00\x0E\xBF\x71\x84\x00\x0B\x95\x84\x41\x06\x13\x96\x81\x43\x42\x12\x9D\x80\x01\x01\x04\x46\x03\x84\x01\x19\x93\x87\x45\x40\x12\x19\x44\x7D\x76\x2C\xAD\x8E\x8B\x8B\x30\xB1\x82\x8F\x8C\x34\xB5\x86\x8F\x8D\x35\x9C\x47\x80\x8E\x3C\xB8\x8E\x47\x8E\x3D\x81\x92\x93\x90\x44\x85\x9F\x70\x49\x40\x83\x98\x90\x77\x35\x8B\x99\x77\x92\x50\xA5\x41\x41\x94\x53\x92\x90\x00\x95\x57\xA2\x45\x97\x96\x59\x9C\x98\x97\x97\x56\xA0\x99\x92\x91\x64\xA5\x96\x8E\x93\x65\xA8\x9D\x90\x7D\x62\x9D\x9E\x99\x9B\x70\x96\x97\x4A\x97\x61\xB5\x94\x9F\x9D\x6E\xA6\x9A\x9F\x9E\x34\xAA\x96\x92\x9F\x33\xBE\x94\x0A\x9D\x6F\x84\xA1\x9C\x9E\x87\x85\xA8\xA2\xA1\x2B\xBC\x9E\xA2\xA3\x80\x84\x91\xA5\x8C\x7E\x89\xA6\xA4\xA3\x8B\x99\xAA\xA3\xA6\x29\x78\x9F\xA3\xA7\x8F\x93\xA2\x92\xA8\x2F\x95\xA8\xA7\xA6\x97\x9A\xAB\x4A\xA6", - "\xA9\x9B\xA0\xAB\xAB\x7A\xA4\xAD\x8E\xAC\x2D\xA6\xAC\xAB\xA9\xAD\xAD\xAE\x4B\xAD\x9E\xB0\xAE\xAD\x91\xB4\xB8\x81\xB3\x93\xF4\x71\x4C\xAC\xAA\xB8\x89\xBC\x94\x4D\xC7\xAD\x9F\xAF\xB3\xD0\x91\xB2\xB7\xB4\xD4\x95\xB6\xB7\xB5\xD8\x99\xBA\xB7\xB6\xDC\x9D\xBE\xB7\xB7\xE0\xA1\xB2\xBB\xB8\xE4\xA5\xB6\xBB\xB9\xE8\xA9\xBA\xBB\xBA\x44\xB7\x43\x98\xBB\xF0\xB1\xBE\xAE\x4E\xEF\xA0\xAD\x4D\xBD\xF2\xB9\xB4\xB4\x50\xF8\xBA\xBE\xBF\xBF\x00\xC1\xCC\xBB\x50\xFD\x82\xC6\xC3\xC1\x08\xC3\x96\x51\xC1\x09\xCD\xCE\xC3\xC3\x10\xD1\xC2\xC7\xC4\x14\xD5\xC6\xC7\xC5\x18\xD9\xC4\x9B\xB0\x67\x8D\xA4\xA4\x9B\xA7\x89\x5D\xB2\xB2\xC8\xA3\xCA\xA6\xC6\xD3\x5C\xCB\x98\xC3\x47\xA0\xC6\xC9\xC9\x30\xF9\xA4\xCA\xB3\x3D\xB1\x04\x42\xCD\x01\x78\xC0\x02\xCE\x3C\xF7\xCE\xCD\x40\x32\x3F\xCB\xCE\xD0\x3D\xF9\xC4\xD3\xD1\x46\xC9\xD3\xD2\xD2\x45\xCB\xDE\xD1\xD3\x50\xC8\xDF\xD2\xD4\x51\xCC\xD4\xD7\xD5\x56\xD9\xD3\xD6\xD6\x55\xDB\xDE\xD5\x76\x33\x04\x41\xD9\x40\x63\xC0\x05\xDB\xD9\x62\xE9\xD4\xDA\xDA\x66\xC4\x44\x0C\xDB\x68\xEB\xD2\xDD\xDB\x73\xF1\xD4\xDF\xDD\x76", - "\xF9\xD0\xDF\xDE\x75\xFC\xD8\xDE\xDF\x7A\xFD\xD2\xE3\xDF\x83\xC1\xE4\xE3\xE1\x86\xC6\xEF\x89\x0D\x04\x4C\xE7\x82\xE3\x4C\xBF\x30\xE4\xCA\x94\xD5\xE2\x8E\x0D\x1E\xD6\xEA\xE7\xE6\xDE\xB7\x09\xE4\xE7\x19\xCB\x5C\xC8\xB9\x38\x1F\xE0\xE9\xCB\xA3\xC1\xA6\xE9\xAD\xF4\x4D\x5F\xCA\xCC\xAF\xF3\xC4\xA1\xE5\x2A\xFD\x9B\xE8\x8B\xB6\xB1\xC2\xED\xEC\xBC\xF0\xC4\xEF\xED\x37\xB5\xE9\xEC\xEC\xBA\xFD\xED\x98\x54\xC7\xBF\xE9\xEA\x8C\xC2\xEE\xC5\xF3\xF3\xC4\xD8\x93\x56\xF1\xC0\xD0\xC5\xEE\xEA\xA3\xC3\xFB\xEE\x9B\x56\x54\xFE\xF6\xAB\x94\xD7\xFC\xF1\xF5\xA8\xD1\xE1\xF7\xA9\x59\x5F\xF7\xFB\xF2\x08\xE2\xFF\xC5\xF6\xCE\xEB\xF0\xF7\xF6\xF2\xCA\xF1\xE4\xB0\xE4\xFF\x3A\xF6\xFA\xF4\xD6\x9C\x57\xF7\xF6\x66\x4D\xF3\x07\x49\x51\xAF\x33\x7C\x7F\x00\x87\x76\x02\x8B\x8C\x81\x06\x8E\x87\x81\x10\x91\x82\x04\x93\x84\x82\x80\x62\x2F\x7E\x15\x94\x82\xFB\x30\x43\x80\xF3\x64\x62\x08\xFD\x68\x83\x01\x98\x85\x47\xAE\x66\x82\x68\x41\x7C\x68\xD6\x5E\x67\x84\x15\xAE\x84\x85\x2B\x8D\x84\x0C\xAF\x82\x87\x1A\xB1\x87\x86\x34\x99\x7D\x90\x43\x0A\x87\x0C\x91\x61", - "\x71\x80\x61\x8B\xDC\x6F\x65\x70\x21\x88\x76\x88\x40\x85\x8A\x12\xC7\x8B\x89\x24\x8C\x8F\x89\x4E\x91\x88\x12\xEC\x67\x5A\x22\x3D\x86\x87\x01\x70\x73\xE4\x53\x3B\x8B\xE7\x1D\x88\x8B\x0B\x85\x08\x41\x62\x87\x40\x32\x91\x76\x8C\x68\x83\x8E\x1A\x81\x29\x8C\x36\xAB\x88\x00\x6D\x90\x8F\x1B\xF1\x84\x8F\x39\xB6\x8E\x8D\x78\x92\x8D\x1E\xF5\x8B\x8F\x3B\xBA\x8F\x8F\x7C\x80\x92\x1F\x81\x94\x91\x41\x86\x95\x8F\x88\x84\x84\x18\xBD\x46\x09\x2B\x8B\x91\x82\x47\x0E\x93\x23\x93\x9A\x5A\x24\x12\x92\x81\x1B\x85\x55\xFE\x7B\x73\x84\xF9\x49\x51\x09\x21\x8A\x91\xC5\x19\x9E\x45\x0E\x84\x5A\x84\x6D\x4A\x09\x28\xC4\x71\x81\x34\x5B\x91\x7E\xAB\x91\x94\x2A\x97\x91\x60\x52\xAC\x70\x7E\x04\x92\x95\x27\xDB\x7B\x09\xED\x6D\x93\x63\xAF\x99\x96\xA6\x4C\x0A\x96\x4F\xBE\x91\x7C\xB4\x98\x75\x30\x9E\x83\x97\x66\x80\x05\x09\xC7\x88\x66\x2D\xCA\x98\x96\x66\x8F\x7E\x09\xC5\x99\x9B\xC9\x14\x9C\x9B\xD3\x53\x9F\x94\xA2\x85\x94\x2C\xCE\x96\x99\x80\x0F\x09\x9A\x38\x50\x08\x41\x6A\x91\x20\x76\x80\x06\x9D\xF0\x8B\x9E\x3C\x81\x21\x0B\x79\xAF\x9E\x9E\xF1\x8D", - "\x9C\x3E\xFB\x9A\x9F\x7E\xB7\x9E\x9F\xF9\x9F\x9E\x40\x81\xA4\xA0\x7E\x83\xA6\xA0\x05\xA0\xA0\x42\x8B\xAA\xA1\x86\x87\xA6\xA1\x09\xAF\xA2\x44\xD9\x32\x0A\x82\x15\xA1\x20\x17\xA0\x01\x46\x9B\xA6\xA3\x8E\x98\xA6\xA3\x1A\xA4\x23\x14\x20\xAC\xA3\x8F\xA6\xA1\xA4\x27\xA5\xA4\x4A\xAB\xAA\xA5\x96\xA4\xA7\xA5\x29\xB0\xA4\x4B\xB2\xAE\xA5\x98\xB6\xA3\xA6\x37\xB5\xA4\x4E\xBB\xAA\xA6\x9D\x99\x39\x8E\x3F\xB4\x3D\x21\x89\x93\xA8\x41\x84\xAF\x90\x46\xA9\xA9\x51\xCB\xA8\xA8\xA6\x87\xAF\xA9\x4A\xAD\xAA\x54\xD0\xAD\x9B\x6B\x54\x09\x99\x55\xB2\x81\x15\x58\xA9\xAB\xAA\x96\x0C\xAB\xD2\x80\xAE\xFE\x4B\x90\x9D\x72\xBB\x92\x53\x57\x01\x97\x2F\xFF\x44\xAD\x94\x5A\x9F\xAC\x70\xA9\x53\x5A\xF8\x75\x9B\xB2\x84\x20\x0B\x6F\xA6\xAC\x2B\xC8\x9C\x7C\x0E\xAD\xAD\x7C\x7A\xA7\x55\x16\x79\xA3\x76\xBE\xA1\x9C\x47\xA6\x8E\xAF\xF7\x64\x24\x9C\xB5\x86\xB2\x80\x7F\xA3\xAF\xF7\x66\x2D\xB1\xDE\x73\xAA\x52\xF9\x69\x2E\x30\xF1\xA4\xB0\x11\x81\x49\xA2\xA0\xB6\x9D\x3D\x90\xAC\xA0\x89\xA1\xB4\xB4\xA8\xA6\xB5\x69\xA7\xBA\xB5\xD4\xAC\xB7\xB5\xAB\xB1\xB6\x6B\xE2", - "\xAF\x44\x1E\xBD\xAD\xAB\xF9\x5D\xA4\x4D\xBB\xB7\xA5\x91\xB9\xA4\xB7\x3C\xA0\xBA\x6E\xBF\xB4\xB9\xE0\x85\xBB\xB8\xC6\xA9\xB8\x72\xCB\xB2\xB8\x90\x95\x8C\xB6\xB8\xB1\xB8\xC2\x6C\x27\xB6\xE9\x8C\x87\x2D\xD5\xB6\xB9\xC2\x72\x29\xBA\xED\xA3\x52\xAC\x89\xA0\xB1\x67\x9C\xB9\x81\xB0\x9D\xB8\x9C\xC1\x63\x9F\x08\xF5\x25\xB2\xF2\x87\xB2\x62\xDF\x8A\xB3\x7B\xE8\xB2\xBF\xC0\xAD\xBD\x55\x97\xAA\x49\x64\xF8\x27\xBF\xF1\xB2\xAF\xB1\xAE\x95\xAD\x7D\xFE\xB4\xC0\x2E\x7B\x2C\x4B\xF9\xBF\xBA\x80\xE2\xBD\xBF\x63\x7E\x2D\xBC\xDE\xB5\x71\x60\x67\xB1\xC2\x21\x44\x34\xC2\x15\xD9\xC2\x8C\x07\x38\xC2\xCB\x71\xBD\x7C\xE9\xBB\xB2\x7D\xEE\xB6\xAD\x04\xC1\x49\xBC\x92\xA4\xC4\xA1\x0A\x3D\xC0\xF0\x66\xBB\xBE\x1D\x63\x75\x63\x22\xC5\xC0\x15\xEF\x66\xC4\xB3\x51\xB1\xA2\x10\x3D\xC5\x11\xDA\xC6\x5F\x93\x3D\xC3\x8F\xC3\xC4\xC9\x22\xE1\x5F\xC3\x29\xC1\xC6\x35\xA3\xCC\xC8\x74\x99\x60\xC9\x28\xCD\xC8\x9E\x16\x3D\xC6\xE8\xB0\x58\xCA\x3A\xD6\x49\x66\x55\xCD\xBC\x23\xD7\x64\x33\x42\xD6\x78\x78\xD9\xCA\x53\xCF\x1C\xCE\xC6\x30\xCF\x60\x96\x8B\xC9\xC4\x29", - "\xE8\xCB\x49\xA2\x29\x7A\x97\x8D\x65\x35\x30\xD7\x63\xCD\x69\xC9\xCB\x80\xE7\xCD\x4C\xD4\x10\xC7\xC9\x63\xCC\xCE\x9B\xF2\x7B\x35\x3F\xF3\xCF\xD0\x47\xC1\xD1\x9E\x9C\x99\x50\xD7\x3C\xCE\xC9\x18\x78\xCE\x92\xF6\xAF\xD0\x4D\x71\x36\xB2\x00\xC0\x9A\xA0\xA7\x54\x37\x4A\xEE\xB8\xC7\x88\xA4\xCE\x7B\xB7\x3E\xD2\x9A\x6F\xC0\xB2\x9B\xC5\xD5\x8D\xA0\xD2\x58\x51\xC3\xD4\x50\xBA\x3D\xC9\xA6\xEC\xA9\xD5\x37\xE7\x55\x37\x2D\xCC\xD7\xA4\xB6\x40\x38\x1A\xEA\xD6\x99\xBA\xD1\xC7\xA2\xEA\xB4\x78\xE2\x3D\x72\x38\xC0\xD3\xD4\x5D\xC3\xDE\xD6\x5B\xC1\x27\x38\x9E\xC1\xDB\xCA\x4C\xDB\xC9\x1A\xCB\x4A\x39\xB9\xCA\xD8\x66\xEC\xCD\x39\x5F\xCE\xD9\x4F\xDA\xDA\xBD\xAD\xE6\xAF\x0E\x6B\xE4\x62\xDA\xB6\x63\xDC\x41\x00\x16\xDD\x6C\xE7\xD1\xC0\xD4\xD4\xD3\xA6\x01\x1D\xDD\x6F\xE8\xD8\x7B\xF1\xDB\xCF\xA6\x02\x15\xDE\x1F\xE1\xDA\xC1\xF9\xCC\xC0\x00\x03\x1D\xDF\x55\xFF\xDF\xC4\xAE\xDB\x78\x21\x05\xE7\xC7\x83\xF9\xC2\xDD\xDE\xCD\x4D\x21\x10\xD7\xCE\x45\xFB\xD2\xE0\xAF\xDC\x4A\x21\x06\xEF\xDC\x4D\xF9\xCF\x10\xC4\xCC\xE3\xB7\xC8\xC2\x5E\x49\xC2\xDA\xDE", - "\x23\xC8\x12\xC8\xA4\xE1\x5E\x93\xD3\xD8\xE5\xE3\xA9\x12\xC8\xF7\xD3\x7C\x88\xEE\x4A\x11\x2B\xEF\xAC\xCD\xEF\x71\xE1\x36\xF9\xE7\x65\x8B\x07\xDE\xC3\xA1\xD6\xE6\x2C\x4C\x17\xE7\x9F\xC3\xE9\xAB\xC5\xEF\xAD\x46\x08\xEB\xE7\x7E\xAC\xEA\xB7\x8E\x1A\x96\xA8\xDA\x92\xEA\x23\xE1\x97\x23\x14\xE6\x62\x97\xE9\xDD\xDA\x11\xFA\xE6\xD2\x97\xEF\xEA\x98\xEF\x60\x12\x48\xE6\xD6\xC6\x5E\xE8\xDE\xB3\xD9\xE8\x4F\x91\x03\xBE\xD5\xE2\x98\xEA\xB3\x92\x17\xE9\x63\xE7\xE6\xDE\x98\xE6\x4B\x49\x29\xEE\xB1\x1D\xF4\xD5\xCF\x99\xEF\xED\xE7\x41\x4C\x1F\xFF\x1C\x1F\x09\x7E\x1F\x0F\x3A\x0A\xF6\x1F\x8A\x1F\x03\x3B\x5B\x19\x3B\x07\x00\x25\x20\x01\x3B\x56\x7B\xE9\x30\x01\x89\x01\x23\x40\x00\x07\x44\x00\x1A\x21\x21\xEF\x01\x20\x43\x99\xEF\x25\x40\x70\x31\x20\xFB\x01\x20\x3F\x01\x3A\x3E\x87\x66\x31\x21\xED\x18\x4A\xF3\x9A\xFD\x50\x00\x38\xFA\xF4\xB8\x9C\x43\x53\xFC\x20\x00\x79\x01\x21\x3C\x14\x6D\x3D\xF7\x4B\x5A\xF3\x9C\x3B\xF4\x21\x41\x41\x22\xF7\xAB\x4C\xF9\xEA\xD3\xFB\x52\x10\x47\x5C\x3D\x5C\x5C\xF5\x40\x51\xFA\xFA\xE9\xEE\x4C\x44\x2F\x6A\xF9", - "\xEF\xCE\xFE\xFB\xEE\xD0\x44\x4B\x09\x5A\x51\xF7\x9A\xF2\x44\xF5\xC8\x24\x20\x0D\x41\x21\x43\x78\x4A\xF3\xDB\xC4\x55\x20\x89\x41\x25\xD8\x81\x2A\x46\x34\xF3\x3F\x58\x3F\x20\x00", + "\x98\x63\x00\x00\x01\x07\x00\x00\x60\x00\x01\x80\x21\x84\x81\x83\x1E\x82\x01\x04\x88\x04\x89\x04\x84\x82\x05\x0F\x84\x8B\x04\x8C\x04\x81\x06\x8B\x04\x8E\x04\x9F\x04\x80\x11\x8E\x82\x21\x20\x84\x82\x13\x94\x83\x10\x82\x25\x04\xA6\x0A\x94\x87\x11\x96\x82\x28\x30\x84\x89\x13\x9C\x82\x14\x9B\x04\xAB\x39\x84\x8C\x14\x9C\x83\x16\x3F\x84\xAE\x02\xA4\x87\x15\xA2\x82\x30\x04\xB9\x04\x8A\x1C\xA4\x83\x1D\x4F\x84\xBC\x12\xA4\x85\x1D\xAA\x82\x3E\x58\x84\x87\x86\x84\x83\x80\x81\x04\xC1\x04\x9A\x24\x83\x2D\xB2\x82\x5C\x68\x84\x9D\x2B\xB4\x82\x2E\xB7\x04\xDF\x31\xA4\x80\x81\x81\xBA\x00\x61\x04\xB9\xA1\x82\x34\x81\xBF\x80\x63\x04\x81\xC1\x84\x34\x81\xC3\x80\x65\x04\x89\xC1\x86\x34\x81\xC7\x80\x67\x04\x91\xC1\x88\x34\x81\xCB\x80\x69\x04\x99\xC1\x8A\x34\x81\xCF\x80\x6B\x04\xA1\xC1\x8C\x34\x81\xD3\x80\x6D\x04\xA9\xC1\x8E\x34\x81\xD7\x80\x6F\x04\xB1\xC1\x80\x3C\x81\xDB\x80\x71\x04\xB9\xC1\x82\x3C\x81\xDF\x80\x73\x04\x81\xE1\x84\x3C\x81\xE3\x80\x75\x04\x89\xE1\x86\x3C\x81\xE7\x80\x77\x04\x91\xE1\x88\x3C\x82\x3C\x82\x7B\x58\xC4\x9C", + "\x3B\xEC\x81\x3E\xEF\x04\xFE\x04\x9F\x7F\x78\x08\x00\xF2\xE4\x9C\x04\x8A\xF1\x80\xF7\x7E\xF6\xE7\xE8\xF0\xEF\x04\x82\x0F\xF0\xF4\x11\x04\x9B\x0E\x81\x80\x89\xF6\xF4\x17\x04\x43\x04\x41\x18\x37\x74\x79\x07\x06\xBF\x34\x04\x41\x15\x09\x86\x05\x82\xE6\x41\x49\x41\x40\x19\x12\x49\x81\x45\xFF\x64\x75\x85\x86\xFF\x07\x04\x43\x86\x00\x02\x0F\x84\x41\x03\x23\x84\x86\x89\x00\x20\x8A\x88\x8A\x2B\xA7\x81\x43\x42\x2E\xA9\x84\x41\x01\x04\x46\x08\x88\x01\x2C\x98\x41\x42\x04\x19\x49\x8E\x7B\x8F\x40\x81\x92\x93\x90\x44\x85\x96\x93\x91\x48\x89\x9A\x90\x92\x1E\x3E\x8B\x93\x93\x4A\x9C\x4C\x84\x94\x54\x95\x96\x97\x95\x57\xA1\x43\x95\x96\x4E\x84\x9A\x95\x7C\xE4\x5F\x92\x9A\x48\x01\x63\x95\x98\x99\x00\x26\x99\x9B\x47\x67\xAD\x9B\x9A\x9B\x6A\xB1\x98\x9A\x9A\x58\xB5\x96\x9D\x9D\x5F\xB7\x9F\x3D\x9E\x49\xBC\x91\x9B\x9C\x80\xB0\x91\xA3\x9B\x84\xAA\x94\x4A\xA0\x88\x85\xA3\xA0\x9D\x7A\x8D\xAE\xA2\x91\x7E\xB8\x9D\x97\x90\x91\xA7\x49\xA2\x9C\x97\x8B\xAA\xA5\xA6\x9C\x8A\xAE\x9B\xA3\xA0\xA1\xAE\x79\xA4\x58\xA4\xA5\x91\xA4\x98\x9E\xAA\xA9\xAA", + "\xAC\x9B\xAB\xAB\xA0\x24\x28\x92\xAB\xAC\x8F\xA6\xA6\x96\xAD\x94\x89\x8D\xA9\xA7\xBB\xAF\xA1\x41\x4A\xBC\xAE\xAC\xA0\xAD\xC4\x92\xAB\x97\xAD\x93\x82\x98\xAA\xB0\xCC\x81\xBE\xB0\xA1\x2B\x4F\xB8\xAD\xB1\xD4\xBD\x99\xB0\x94\xD3\x81\x91\xA6\x4B\xD2\x8D\xBE\xAF\xB7\xBD\xBD\xA5\xB7\xB8\xE4\xA5\xB6\xBB\xB9\xE8\xA9\xBA\xBB\xBA\xEC\xAD\xBE\xBB\xBB\xF0\xB1\xB2\xBF\xBC\xF4\xB5\xB6\xBF\xBD\xF8\xB9\xBA\xBF\xBE\xFC\xBD\xBE\xBD\xB1\x31\x47\xBF\xBF\xC0\x04\xF3\xA4\x4E\xC0\xB4\xB7\x48\xC1\xC1\x0C\xE4\xBA\x4F\xC2\x0D\xD1\xC2\xC7\xC4\x14\xF8\xBD\x4C\xC4\x15\xD9\xCA\xC7\xC6\x50\x80\x58\xC4\xC7\x20\xE1\xC2\xCB\xC8\x24\xE5\xC6\xCB\xC9\x28\xE9\xCA\xCB\xCA\x2C\xDA\xB7\xB7\x93\xD9\x80\x9B\xB1\xB7\x34\xE0\xBE\xB5\xB8\x2F\xC3\x93\x51\x40\x3B\xC0\x0D\xCF\xCF\x44\x7C\xC1\xD0\x00\x46\x42\xD6\xD2\xCF\x43\xC0\xD7\xD2\xD2\x48\xCB\xD9\xD3\xD3\x4E\xD1\xDD\xD3\xD4\x4C\xD5\xD0\xD4\xD5\x57\xD6\xD2\xD6\xD6\x58\xDB\xD9\xD7\xD7\x52\xEE\x79\x51\x40\x63\xC0\x05\xDB\xD9\x48\x69\xD4\xDA\xDA\x66\xEC\xD1\x0C\xDB\x68\xEB\xD2\xDD\xDB\x73\xF1\xD4\xDF\xDD\x76", + "\xF9\xD0\xDF\xDE\x75\xFC\xD8\xDE\xDF\x7A\xFD\xD2\xE3\xDF\x83\xC1\xE4\xE3\xE1\x86\xF6\xD2\x92\x0C\x04\x4C\xEC\x86\xE3\x60\xBF\x30\xE5\xCB\x94\xD5\xE4\x93\x0C\x39\xD6\xEA\xE7\xE6\xEB\xB4\x09\xE4\xE7\x24\xF6\x0F\xE4\xBE\x35\x23\xED\xC9\xCC\x4B\xA8\xE3\xA9\x82\x37\x37\xCE\xE9\xCD\x38\xDD\xA6\xE6\xEA\xD6\x9F\xC8\x7B\xCC\x36\xF0\xEF\xE9\xEE\xBC\xF3\xE6\xE8\xA4\xA6\xF8\xE1\xEC\xEF\xC3\xC3\xF8\x0E\xAB\xBE\xF6\xE8\x90\xED\x7F\x9C\x85\xF3\xEE\xCF\xC1\x4B\x52\xEE\xCA\xE1\xCC\xF3\x91\xD7\xC2\xF0\xF6\x53\xD4\xC4\xFE\xB5\xF2\x91\xE5\xA1\xF2\xAE\xDB\xDD\xA0\x55\xF7\xD1\xC4\xA0\xFA\x9E\xD9\xE4\xF8\xF9\xF9\xDE\xF5\xCB\xFB\x9D\xED\xCE\xF0\xFD\xFA\xBD\x93\x5D\xF4\xE8\xFC\xFD\xFE\xFF\xFF\x00\x81\x82\x00\x83\x84\x81\x02\x86\x83\x63\x56\x35\x7B\x01\xD8\x4C\x6B\x06\x83\x6D\x68\x5D\x71\x82\x03\xDE\x64\x82\x09\xA0\x6E\x82\x15\x93\x80\x06\x9B\x8A\x83\x0E\x97\x86\x83\x47\x74\x55\x56\x0A\x8B\x80\x91\x49\x70\x70\x28\x93\x6F\xDB\x05\x79\x84\xC4\x6D\x87\x84\x2C\x91\x86\x0B\xB2\x80\x87\x19\xB6\x85\x86\x38\x8F\x87\xEF\x0F\x5C\x2B\xF0\x65\x85", + "\x64\x90\x73\x70\x7A\x42\x84\x3C\x22\xBF\x85\x7F\x5F\x20\x01\x12\xEE\x3B\x88\xF4\x09\x8F\x89\x5E\x31\x88\x58\x53\x8A\x88\x29\x95\x8C\x8A\x50\x98\x8A\x15\xD9\x87\x8B\x2E\x9C\x8F\x8B\x5B\x81\x8E\x16\xE3\x8E\x8A\x31\xA5\x8C\x8C\x60\x88\x8E\x19\xE9\x87\x8D\x36\x9C\x8F\x88\x7A\x42\x2C\x09\xF0\x84\x80\x21\x3B\x84\x8E\x78\x8F\x5F\x10\x77\x8C\x7F\xEB\x40\x7D\x7A\xDA\x6F\x7E\x20\xAA\x54\x09\xDD\x73\x7E\x4E\xF5\x71\x70\xFE\x3B\x75\x09\xFB\x5F\x7D\x72\x7E\x87\x57\xF8\x76\x73\x91\x45\x95\x92\x56\x90\x9C\x8E\xB2\x13\x9A\x90\x47\x97\x95\x53\x46\x0F\x90\xE5\x11\x9E\x4A\x4E\xAB\x75\x53\x47\x1E\x91\xFC\x2B\x93\x59\xD3\x5A\x96\x65\x80\x8E\x7C\x2B\xAA\x93\x78\x24\x22\x91\x8F\xB8\x98\x49\x12\x04\x2B\x97\x80\x3D\x90\x00\xBF\x81\x98\x2F\xC3\x91\x20\x25\x04\x98\x98\xC7\x82\x9A\x2F\xC9\x9C\x99\x65\x8E\x98\x99\xCF\x8A\x98\x34\xD3\x92\x9B\x6A\x8D\x9C\x9A\xD7\x96\x99\x34\xD9\x9C\x9B\x6D\x9E\x98\x9B\xDF\x9A\x98\x38\xD3\x9E\x3D\x25\x04\x26\x9C\x01\x28\x9C\x00\x6A\x9C\x9D\x73\xAE\x99\x9D\xEF\x8B\x9C\x41\x4C\x01\x9F\x76\xB0\x9F\x9E\xF2\x98", + "\x9E\x3D\xF9\x9C\x9F\x7D\xBE\x9D\x9E\x00\xBA\x9D\x40\xFD\x93\xA1\x7F\x82\xA7\xA0\x04\xA8\xA2\x41\x89\xAC\xA1\x85\xBB\x9C\x89\x56\x90\xA0\x87\x6C\x84\xA3\x35\x96\xA2\x8D\x18\xAE\x8F\x45\x9A\xA9\xA3\x8A\x9D\xA3\xA3\x1E\xBC\xA2\x48\xA1\xAF\x8D\x5C\xAB\x5D\x09\xAF\x86\xA6\x01\xCE\x09\xA4\x95\xAE\xA7\x09\x2D\xAC\x64\x29\xB9\x51\x96\x4A\xB3\x97\x93\xDF\x50\x0A\x21\x99\x93\x8E\x9A\xBE\x85\x94\x36\xB6\x93\x4D\xC3\xA2\x5C\x9E\xBF\xA5\x4A\x89\x87\x94\xA1\x51\x04\x97\xA6\xB2\x7E\xA8\xEC\x66\x97\xED\x4E\xAC\x76\x29\x14\xAD\x95\x32\xB1\xA7\x54\xB5\xAD\x93\x41\x93\x0F\xAA\xF0\x74\x4A\x38\xE3\xA7\x98\x63\xA1\x9D\x9B\xE3\x84\xAF\x59\xEB\xA9\xAC\xB4\xAA\xAD\xAD\x6C\xAF\xAE\x5C\xEE\xA4\xAE\xB6\xA2\x82\xAB\x2E\xBB\x5E\x43\x85\xAC\xAE\x7C\xB4\x9A\xA1\x7D\xAD\xA1\x60\xFB\xA0\xB1\xC2\x82\xB6\xB0\x84\xA7\xB2\x62\x89\xBC\xB1\xC1\xB8\xAD\x4A\x3D\x99\xAE\x64\x82\x84\x0B\xC7\x93\xB6\x72\x55\x16\xB3\x65\x8D\x66\x0A\xCD\x9B\xB7\x8F\x47\xB4\x49\x52\xDB\xA4\xA8\xB0\x83\x97\x90\xC6\x41\xB4\x2C\xDD\xA3\xA9\x2B\x26\xB5\xB4\x3D\xB9\x63\x4C\x9B", + "\x9C\xAA\xA5\x82\xAF\xB6\x54\xA8\xB6\xF8\x35\xB8\x3C\x2C\x2F\xB0\xB7\xFB\x7F\xB0\xE8\x59\x0E\xB2\xE1\x87\x4C\x2C\xB1\xA6\xBA\x72\xCA\x46\x2D\xE4\x9B\x73\xB6\xAB\xAA\x49\x20\xB0\xB4\xBA\xE0\xAA\xB6\x64\xD0\xB2\x66\x54\xCD\x75\xBB\x41\x69\x28\xA7\x45\xAB\xB9\xC4\x6C\x2E\xB8\xF1\xA6\xBF\xBC\xE8\xB5\x5D\x76\xBF\x43\xB4\xEE\x96\xBF\xBD\x61\xA9\xBF\xCA\x6F\x25\xBC\xF9\x91\x62\x2E\xF5\xB6\xBC\x2E\xFC\x1F\x1E\x7E\x13\x07\x1F\x9F\x0E\x13\x0F\x71\x15\x03\x47\x1D\x17\x2E\x05\x36\x50\x00\x4D\x41\x20\x06\xCB\xC4\x20\x0E\xD1\xC0\x84\x91\x21\x21\x89\x01\x20\x43\x00\x17\x21\x40\x1A\x21\x20\xFA\x31\x42\xC1\x0A\xC5\x41\x40\x0B\x41\x21\x06\x41\x27\x41\x01\x36\x3D\x40\x70\x38\x41\x06\xE6\x27\xC5\x6E\x40\xC4\x8C\x8F\xCE\xC5\x1A\xF4\xC7\xC6\x0E\xD0\x47\x8D\x91\x40\x01\xFC\x01\x23\x3F\x3B\x42\x43\x8C\x8A\xC2\x4A\x00\x0A\xC6\x23\x6E\x47\x52\x91\xC3\xC3\xC2\x1B\xF4\x46\xC6\x12\xC1\x21\x80\x01\x22\xC7\x80\x0A\xCD\xCA\x4B\xD6\xC4\x8E\x50\xCD\xC9\x2C\xC0\x05\xC8\x47\xCC\xC8\x95\xA4\x4D\xCA\x0F\x76\xC0\xCB\x0A\xD6\x47\x99\x88\x24\x20\x11", + "\x41\x25\x21\x63\xD1\xCD\x41\x00\x00", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -15377,81 +12071,6 @@ namespace vl::glr::parsergen VisitSyntax(node->syntax.Obj()); Visit(node->assignments); } - - void Visit(GlrLeftRecursionPlaceholderClause* node) override - { - writer.WriteString(L"left_recursion_placeholder("); - for (auto [flag, index] : indexed(node->flags)) - { - if (index != 0) writer.WriteString(L", "); - writer.WriteString(flag->flag.value); - } - writer.WriteChar(L')'); - } - - void VisitLriCont(GlrLeftRecursionInjectContinuation* node) - { - if (node->type == GlrLeftRecursionInjectContinuationType::Optional) - { - writer.WriteChar(L'['); - } - - writer.WriteString(L"left_recursion_inject"); - if (node->configuration == GlrLeftRecursionConfiguration::Multiple) - { - writer.WriteString(L"_multiple"); - } - - writer.WriteChar(L'('); - for (auto [lriFlag, index] : indexed(node->flags)) - { - if (index != 0) writer.WriteString(L", "); - writer.WriteString(lriFlag->flag.value); - } - writer.WriteString(L") "); - - for (auto [target, index] : indexed(node->injectionTargets)) - { - if (index != 0) writer.WriteString(L" | "); - VisitLriTarget(target.Obj()); - } - - if (node->type == GlrLeftRecursionInjectContinuationType::Optional) - { - writer.WriteChar(L']'); - } - } - - void VisitLriTarget(GlrLeftRecursionInjectClause* node) - { - if (node->continuation) - { - writer.WriteChar(L'('); - writer.WriteString(node->rule->literal.value); - writer.WriteChar(L' '); - VisitLriCont(node->continuation.Obj()); - writer.WriteChar(L')'); - } - else - { - writer.WriteString(node->rule->literal.value); - } - } - - void Visit(GlrLeftRecursionInjectClause* node) override - { - writer.WriteChar(L'!'); - writer.WriteString(node->rule->literal.value); - writer.WriteChar(L' '); - VisitLriCont(node->continuation.Obj()); - } - - void Visit(GlrPrefixMergeClause* node) override - { - writer.WriteString(L"!prefix_merge("); - writer.WriteString(node->rule->literal.value); - writer.WriteString(L")"); - } }; } @@ -15784,8 +12403,19 @@ WriteSyntaxHeaderFile writer.WriteLine(L"#pragma once"); } writer.WriteLine(L""); + for (auto include : manager.Global().syntaxIncludes) + { + if (include.Length() > 0 && include[0] == L'<') + { + writer.WriteLine(L"#include " + include); + } + else + { + writer.WriteLine(L"#include \"" + include + L"\""); + } + } writer.WriteLine(L"#include \"" + output->assemblyH + L"\""); - writer.WriteLine(L"#include \"" + output->lexerH +L"\""); + writer.WriteLine(L"#include \"" + output->lexerH + L"\""); writer.WriteLine(L""); WString prefix = WriteNssBegin(manager.Global().cppNss, writer); @@ -16011,10 +12641,9 @@ namespace vl StateSymbol ***********************************************************************/ - StateSymbol::StateSymbol(RuleSymbol* _rule, vint32_t _clauseId) + StateSymbol::StateSymbol(RuleSymbol* _rule) : ownerManager(_rule->Owner()) , rule(_rule) - , clauseId(_clauseId) { } @@ -16032,18 +12661,7 @@ StateSymbol result = e1->input.token <=> e2->input.token; if (result == 0) { - if (e1->input.condition && e2->input.condition) - { - result = e1->input.condition.Value() <=> e2->input.condition.Value(); - } - else if (e1->input.condition) - { - result = std::strong_ordering::greater; - } - else if (e2->input.condition) - { - result = std::strong_ordering::less; - } + result = e1->input.condition <=> e2->input.condition; } break; case EdgeInputType::Rule: @@ -16052,9 +12670,30 @@ StateSymbol default:; } } - - if (result != 0) return result; - return orderedStates.IndexOf(e1->To()) <=> orderedStates.IndexOf(e2->To()); + if (result == 0) + { + result = orderedStates.IndexOf(e1->To()) <=> orderedStates.IndexOf(e2->To()); + } + if (result == 0) + { + result = CompareEnumerable(e1->competitions, e2->competitions); + } + if (result == 0) + { + result = CompareEnumerable(e1->insAfterInput, e2->insAfterInput); + } + if (result == 0) + { + result = e1->returnEdges.Count() <=> e2->returnEdges.Count(); + } + if (result == 0) + { + result = CompareEnumerable( + From(e1->returnEdges).Select([&](EdgeSymbol* e) { return orderedStates.IndexOf(e->To()); }), + From(e2->returnEdges).Select([&](EdgeSymbol* e) { return orderedStates.IndexOf(e->To()); }) + ); + } + return result; })); } @@ -16113,10 +12752,10 @@ SyntaxSymbolManager rules.Remove(name); } - StateSymbol* SyntaxSymbolManager::CreateState(RuleSymbol* rule, vint32_t clauseId) + StateSymbol* SyntaxSymbolManager::CreateState(RuleSymbol* rule) { CHECK_ERROR(phase == SyntaxPhase::EpsilonNFA, L"vl::gre::parsergen::SyntaxSymbolManager::CreateState(RuleSymbol*)#Cannot change the automaton after calling BuildCompactSyntax()."); - auto symbol = Ptr(new StateSymbol(rule, clauseId)); + auto symbol = Ptr(new StateSymbol(rule)); states.Add(symbol); return symbol.Obj(); } @@ -16181,6 +12820,7 @@ SyntaxSymbolManager for (auto ruleName : rules.order) { auto ruleSymbol = rules.map[ruleName]; + if (ruleSymbol->isPartial) continue; auto orderedStates = From(groupedStates[ruleSymbol]) .OrderByKey([](StateSymbol* s) { @@ -16239,10 +12879,12 @@ AutomatonBuilder (Syntax) edge->input.type = EdgeInputType::Token; edge->input.token = tokenId; edge->input.condition = condition; + + vint count = usedFieldIds++; + edge->insAfterInput.Add({ AstInsType::Token,-1,count }); if (field != -1) { - edge->insAfterInput.Add({ AstInsType::Token }); - edge->insAfterInput.Add({ AstInsType::Field,field }); + fieldIns.Add({ AstInsType::Field,field,count }); } } @@ -16265,22 +12907,23 @@ AutomatonBuilder (Syntax) edge->input.rule = rule; edge->input.ruleType = ruleType; + vint count = usedFieldIds++; switch (ruleType) { case automaton::ReturnRuleType::Field: CHECK_ERROR(field != -1, ERROR_MESSAGE_PREFIX L"Field must set for ReturnRuleType::Field."); - edge->insAfterInput.Add({ AstInsType::Field,field }); + edge->insAfterInput.Add({ AstInsType::StackSlot,-1,count }); + fieldIns.Add({ AstInsType::Field,field,count }); break; case automaton::ReturnRuleType::Partial: CHECK_ERROR(field == -1, ERROR_MESSAGE_PREFIX L"Field must not set for ReturnRuleType::Partial."); break; case automaton::ReturnRuleType::Discard: CHECK_ERROR(field == -1, ERROR_MESSAGE_PREFIX L"Field must not set for ReturnRuleType::Discard."); - edge->insAfterInput.Add({ AstInsType::DiscardValue }); + edge->insAfterInput.Add({ AstInsType::StackSlot,-1,count }); break; case automaton::ReturnRuleType::Reuse: CHECK_ERROR(field == -1, ERROR_MESSAGE_PREFIX L"Field must not set for ReturnRuleType::Reuse."); - edge->insAfterInput.Add({ AstInsType::ReopenObject }); break; } } @@ -16304,11 +12947,6 @@ AutomatonBuilder (Syntax) return BuildRuleSyntaxInternal(rule, field, automaton::ReturnRuleType::Field); } - AutomatonBuilder::StatePair AutomatonBuilder::BuildPartialRuleSyntax(RuleSymbol* rule) - { - return BuildRuleSyntaxInternal(rule, -1, automaton::ReturnRuleType::Partial); - } - AutomatonBuilder::StatePair AutomatonBuilder::BuildDiscardRuleSyntax(RuleSymbol* rule) { return BuildRuleSyntaxInternal(rule, -1, automaton::ReturnRuleType::Discard); @@ -16400,13 +13038,11 @@ AutomatonBuilder (Syntax) CreateEdge(bodyPair.end, pair.end); auto skipEdge = CreateEdge(pair.begin, pair.end); - if (preferTake) + if (preferTake || preferSkip) { - takeEdge->important = true; - } - if (preferSkip) - { - skipEdge->important = true; + vint32_t id = ++ruleSymbol->Owner()->usedCompetitionIds; + takeEdge->competitions.Add({ id,preferTake }); + skipEdge->competitions.Add({ id,preferSkip }); } endPoses.Add(pair.end, clauseDisplayText.Length()); @@ -16466,7 +13102,8 @@ AutomatonBuilder (Clause) AutomatonBuilder::StatePair AutomatonBuilder::BuildClause(const StateBuilder& compileSyntax) { - ruleSymbol->NewClause(); + usedFieldIds = 0; + fieldIns.Clear(); clauseDisplayText = L""; startPoses.Clear(); endPoses.Clear(); @@ -16493,8 +13130,9 @@ AutomatonBuilder (Clause) { auto withState = CreateState(); auto edge = CreateEdge(pair.end, withState); - edge->insBeforeInput.Add({ AstInsType::EnumItem,enumItem }); - edge->insBeforeInput.Add({ (weakAssignment ? AstInsType::FieldIfUnassigned : AstInsType::Field),field}); + vint count = usedFieldIds++; + edge->insAfterInput.Add({ AstInsType::EnumItem,enumItem,count }); + fieldIns.Add({ (weakAssignment ? AstInsType::FieldIfUnassigned : AstInsType::Field),field,count}); endPoses.Add(withState, clauseDisplayText.Length()); return { pair.begin,withState }; } @@ -16511,21 +13149,18 @@ AutomatonBuilder (Clause) clauseDisplayText += L" >"; { auto edge = CreateEdge(pair.begin, bodyPair.begin); - edge->insBeforeInput.Add({ AstInsType::BeginObject,classId }); + edge->insAfterInput.Add({ AstInsType::StackBegin }); } { auto edge = CreateEdge(bodyPair.end, pair.end); - edge->insBeforeInput.Add({ AstInsType::EndObject }); + edge->insAfterInput.Add({ AstInsType::CreateObject,classId }); + CopyFrom(edge->insAfterInput, fieldIns, true); + edge->insAfterInput.Add({ AstInsType::StackEnd }); } endPoses.Add(pair.end, clauseDisplayText.Length()); return pair; } - AutomatonBuilder::StatePair AutomatonBuilder::BuildPartialClause(const StateBuilder& compileSyntax) - { - return compileSyntax(); - } - AutomatonBuilder::StatePair AutomatonBuilder::BuildReuseClause(const StateBuilder& compileSyntax) { StatePair pair; @@ -16533,119 +13168,21 @@ AutomatonBuilder (Clause) pair.end = CreateState(); startPoses.Add(pair.begin, clauseDisplayText.Length()); - clauseDisplayText += L"<< "; + clauseDisplayText += L">"; + clauseDisplayText += L" !>"; { auto edge = CreateEdge(pair.begin, bodyPair.begin); - edge->insBeforeInput.Add({ AstInsType::DelayFieldAssignment }); + edge->insAfterInput.Add({ AstInsType::StackBegin }); } { auto edge = CreateEdge(bodyPair.end, pair.end); - edge->insBeforeInput.Add({ AstInsType::EndObject }); + CopyFrom(edge->insAfterInput, fieldIns, true); + edge->insAfterInput.Add({ AstInsType::StackEnd }); } endPoses.Add(pair.end, clauseDisplayText.Length()); return pair; } - - AutomatonBuilder::StatePair AutomatonBuilder::BuildLrpClause(collections::SortedList& flags, const Func& flagName) - { - /* - * S --+--(lrp:(a,b))--+--> E - */ - - StatePair pair; - pair.begin = CreateState(); - pair.end = CreateState(); - startPoses.Add(pair.begin, clauseDisplayText.Length()); - - { - auto edge = CreateEdge(pair.begin, pair.end); - edge->input.type = EdgeInputType::LrPlaceholder; - CopyFrom(edge->input.flags, flags); - } - - clauseDisplayText += L"lrp:("; - // TODO: (enumerable) Linq:Aggregate - for (vint i = 0; i < flags.Count(); i++) - { - if (i > 0) clauseDisplayText += L","; - clauseDisplayText += flagName(flags[i]); - } - clauseDisplayText += L")"; - endPoses.Add(pair.end, clauseDisplayText.Length()); - return pair; - } - - AutomatonBuilder::StatePair AutomatonBuilder::BuildLriSyntax(collections::SortedList& flags, RuleSymbol* rule, const Func& flagName) - { - StatePair pair; - pair.begin = CreateState(); - pair.end = CreateState(); - startPoses.Add(pair.begin, clauseDisplayText.Length()); - - { - auto edge = CreateEdge(pair.begin, pair.end); - edge->input.type = EdgeInputType::LrInject; - CopyFrom(edge->input.flags, flags); - edge->input.rule = rule; - edge->input.ruleType = automaton::ReturnRuleType::Reuse; - edge->insAfterInput.Add({ AstInsType::ReopenObject }); - } - - clauseDisplayText += L"lri:("; - // TODO: (enumerable) Linq:Aggregate - for (vint i = 0; i < flags.Count(); i++) - { - if (i > 0) clauseDisplayText += L","; - clauseDisplayText += flagName(flags[i]); - } - clauseDisplayText += L")->" + rule->Name(); - endPoses.Add(pair.end, clauseDisplayText.Length()); - return pair; - } - - AutomatonBuilder::StatePair AutomatonBuilder::BuildLriSkip() - { - StatePair pair; - pair.begin = CreateState(); - pair.end = CreateState(); - startPoses.Add(pair.begin, clauseDisplayText.Length()); - - { - auto edge = CreateEdge(pair.begin, pair.end); - edge->input.type = EdgeInputType::Epsilon; - } - - clauseDisplayText += L"lri:"; - endPoses.Add(pair.end, clauseDisplayText.Length()); - return pair; - } - - AutomatonBuilder::StatePair AutomatonBuilder::BuildLriClauseSyntax(StateBuilder useOrLriSyntax, bool optional, collections::List&& continuations) - { - /* - * +--(lri:c:ReopenObject)--+ - * | | - * +--(lri:a:ReopenObject)--+--(lri:d:ReopenObject)--+--+ - * | | | | - * | +------------------------+ | {<-- if optional} - * | V - * S --(rule:ReopenObject)--+--(lri:b:ReopenObject)------------------------------+--> E - * | ^ - * +----------------------------------------------------+ {<-- if optional} - */ - - if (optional) - { - continuations.Add([this]() { return BuildLriSkip(); }); - } - - List seqs; - seqs.Add(useOrLriSyntax); - seqs.Add([this, &continuations]() { return BuildAlternativeSyntax(continuations); }); - return BuildSequenceSyntax(seqs); - } } } } @@ -16706,12 +13243,12 @@ SyntaxSymbolManager::BuildAutomaton { auto&& stateDesc = executable.states[index]; stateDesc.rule = (vint32_t)rulesInOrder.IndexOf(state->Rule()); - stateDesc.clause = state->ClauseId(); stateDesc.endingState = state->endingState; } List edgesInOrder; List returnEdgesInOrder; + List competitionsInOrder; List returnIndicesInOrder; List astInsInOrder; @@ -16787,25 +13324,20 @@ SyntaxSymbolManager::BuildAutomaton stringLiteralIndex += length; } - switch (edge->importancy) + // edgeDesc.competitions + edgeDesc.competitions.start = (vint32_t)competitionsInOrder.Count(); + for (auto competition : edge->competitions) { - case EdgeImportancy::HighPriority: - edgeDesc.priority = automaton::EdgePriority::HighPriority; - break; - case EdgeImportancy::LowPriority: - edgeDesc.priority = automaton::EdgePriority::LowPriority; - break; - default:; + competitionsInOrder.Add({ competition.competitionId, competition.highPriority }); } + edgeDesc.competitions.count = (vint32_t)competitionsInOrder.Count() - edgeDesc.competitions.start; - edgeDesc.insBeforeInput.start = (vint32_t)astInsInOrder.Count(); - CopyFrom(astInsInOrder, edge->insBeforeInput, true); - edgeDesc.insBeforeInput.count = (vint32_t)astInsInOrder.Count() - edgeDesc.insBeforeInput.start; - + // edgeDesc.insAfterInput edgeDesc.insAfterInput.start = (vint32_t)astInsInOrder.Count(); CopyFrom(astInsInOrder, edge->insAfterInput, true); edgeDesc.insAfterInput.count = (vint32_t)astInsInOrder.Count() - edgeDesc.insAfterInput.start; + // edgeDesc.returnIndices edgeDesc.returnIndices.start = (vint32_t)returnIndicesInOrder.Count(); for (auto returnEdge : edge->returnEdges) { @@ -16818,7 +13350,7 @@ SyntaxSymbolManager::BuildAutomaton } edgeDesc.returnIndices.count = (vint32_t)returnIndicesInOrder.Count() - edgeDesc.returnIndices.start; - if (edgeDesc.insBeforeInput.count == 0) edgeDesc.insBeforeInput.start = -1; + if (edgeDesc.competitions.count == 0) edgeDesc.competitions.start = -1; if (edgeDesc.insAfterInput.count == 0) edgeDesc.insAfterInput.start = -1; if (edgeDesc.returnIndices.count == 0) edgeDesc.returnIndices.start = -1; } @@ -16830,24 +13362,28 @@ SyntaxSymbolManager::BuildAutomaton auto&& returnDesc = executable.returns[edgeIndex]; returnDesc.consumedRule = (vint32_t)rulesInOrder.IndexOf(edge->input.rule); returnDesc.returnState = (vint32_t)statesInOrder.IndexOf(edge->To()); - switch (edge->importancy) - { - case EdgeImportancy::HighPriority: - returnDesc.priority = automaton::EdgePriority::HighPriority; - break; - case EdgeImportancy::LowPriority: - returnDesc.priority = automaton::EdgePriority::LowPriority; - break; - default:; - } - returnDesc.ruleType = edge->input.ruleType; + + // returnDesc.competitions + returnDesc.competitions.start = (vint32_t)competitionsInOrder.Count(); + for (auto competition : edge->competitions) + { + competitionsInOrder.Add({ competition.competitionId, competition.highPriority }); + } + returnDesc.competitions.count = (vint32_t)competitionsInOrder.Count() - returnDesc.competitions.start; + + // returnDesc.insAfterInput returnDesc.insAfterInput.start = (vint32_t)astInsInOrder.Count(); CopyFrom(astInsInOrder, edge->insAfterInput, true); returnDesc.insAfterInput.count = (vint32_t)astInsInOrder.Count() - returnDesc.insAfterInput.start; + + if (returnDesc.competitions.count == 0) returnDesc.competitions.start = -1; if (returnDesc.insAfterInput.count == 0) returnDesc.insAfterInput.start = -1; } + // executable.competitions + CopyFrom(executable.competitions, competitionsInOrder); + // executable.returnIndices CopyFrom(executable.returnIndices, returnIndicesInOrder); @@ -16892,33 +13428,16 @@ CreateParserGenRuleSyntax auto _cond2 = createRule(L"Cond2"); auto _cond = createRule(L"Cond"); auto _switchItem = createRule(L"SwitchItem"); - auto _switches = createRule(L"Switches"); - auto _optionalBody = createRule(L"OptionalBody"); auto _testBranch = createRule(L"TestBranch"); - auto _token = createRule(L"Token"); auto _syntax0 = createRule(L"Syntax0"); auto _syntax1 = createRule(L"Syntax1"); auto _syntax2 = createRule(L"Syntax2"); auto _syntax = createRule(L"Syntax"); - auto _assignmentOp = createRule(L"AssignmentOp"); auto _assignment = createRule(L"Assignment"); auto _clause = createRule(L"Clause"); - auto _placeholder = createRule(L"Placeholder"); - auto _ruleName = createRule(L"RuleName"); - auto _lriConfig = createRule(L"LriConfig"); - auto _lriContinuationBody = createRule(L"LriContinuationBody"); - auto _lriContinuation = createRule(L"LriContinuation"); - auto _lriTarget = createRule(L"LriTarget"); auto _rule = createRule(L"Rule"); auto _file = createRule(L"File"); - _switches->isPartial = true; - _optionalBody->isPartial = true; - _token->isPartial = true; - _assignmentOp->isPartial = true; - _lriConfig->isPartial = true; - _lriContinuationBody->isPartial = true; - _file->isParser = true; _file->ruleType = dynamic_cast(ast.Symbols()[L"SyntaxFile"][0]); @@ -16965,26 +13484,25 @@ CreateParserGenRuleSyntax Clause{ _switchItem } = create(tok(T::USE) + tok(T::ID, F::SwitchItem_name), C::SwitchItem).with(F::SwitchItem_value, GlrSwitchValue::False); // "switch" {SwitchItem:switches ; ","} ";" as partial File - Clause{ _switches } = partial(tok(T::SWITCH) + loop(rule(_switchItem, F::SyntaxFile_switches), tok(T::COMMA)) + tok(T::SEMICOLON)); + auto _switches = tok(T::SWITCH) + loop(rule(_switchItem, F::SyntaxFile_switches), tok(T::COMMA)) + tok(T::SEMICOLON); /////////////////////////////////////////////////////////////////////////////////// // Syntax (primitive) /////////////////////////////////////////////////////////////////////////////////// // "[" Syntax:syntax "]" as partial OptionalSyntax - Clause{ _optionalBody } = partial(tok(T::OPEN_SQUARE) + rule(_syntax, F::OptionalSyntax_syntax) + tok(T::CLOSE_SQUARE)); + auto _optionalBody = tok(T::OPEN_SQUARE) + rule(_syntax, F::OptionalSyntax_syntax) + tok(T::CLOSE_SQUARE); // ID:literal as partial RefSyntax {refType = Id} - Clause{ _token } = partial(tok(T::ID, F::RefSyntax_literal)).with(F::RefSyntax_refType, GlrRefType::Id); - // STRING:literal as partial RefSyntax {refType = Literal} - Clause{ _token } = partial(tok(T::STRING, F::RefSyntax_literal)).with(F::RefSyntax_refType, GlrRefType::Literal); - // CONDITIONAL_LITERAL:literal as partial RefSyntax {refType = ConditionalLiteral} - Clause{ _token } = partial(tok(T::CONDITIONAL_LITERAL, F::RefSyntax_literal)).with(F::RefSyntax_refType, GlrRefType::ConditionalLiteral); + auto _token_Id = tok(T::ID, F::RefSyntax_literal) && with(F::RefSyntax_refType, GlrRefType::Id); + auto _token_Literal = tok(T::STRING, F::RefSyntax_literal) && with(F::RefSyntax_refType, GlrRefType::Literal); + auto _token_ConditionalLiteral = tok(T::CONDITIONAL_LITERAL, F::RefSyntax_literal) && with(F::RefSyntax_refType, GlrRefType::ConditionalLiteral); + auto _token = _token_Id | _token_Literal | _token_ConditionalLiteral; // Token [":" ID:field] as RefSyntax - Clause{ _syntax0 } = create(prule(_token) + opt(tok(T::COLON) + tok(T::ID, F::RefSyntax_field)), C::RefSyntax); + Clause{ _syntax0 } = create(_token + opt(tok(T::COLON) + tok(T::ID, F::RefSyntax_field)), C::RefSyntax); // "!" ID:name as UseSyntax Clause{ _syntax0 } = create(tok(T::USE) + tok(T::ID, F::UseSyntax_name), C::UseSyntax); @@ -16993,13 +13511,13 @@ CreateParserGenRuleSyntax Clause{ _syntax0 } = create(tok(T::OPEN_CURLY) + rule(_syntax, F::LoopSyntax_syntax) + opt(tok(T::SEMICOLON) + rule(_syntax, F::LoopSyntax_delimiter)) + tok(T::CLOSE_CURLY), C::LoopSyntax); // "+" OptionalBody as OptionalSyntax {priority = PreferTake} - Clause{ _syntax0 } = create(tok(T::POSITIVE) + prule(_optionalBody), C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::PreferTake); + Clause{ _syntax0 } = create(tok(T::POSITIVE) + _optionalBody, C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::PreferTake); // "-" OptionalBody as OptionalSyntax {priority = PreferSkip} - Clause{ _syntax0 } = create(tok(T::NEGATIVE) + prule(_optionalBody), C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::PreferSkip); + Clause{ _syntax0 } = create(tok(T::NEGATIVE) + _optionalBody, C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::PreferSkip); // OptionalBody as OptionalSyntax {priority = Equal} - Clause{ _syntax0 } = create(prule(_optionalBody), C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::Equal); + Clause{ _syntax0 } = create(_optionalBody, C::OptionalSyntax).with(F::OptionalSyntax_priority, GlrOptionalPriority::Equal); /////////////////////////////////////////////////////////////////////////////////// // Syntax (conditional) @@ -17041,13 +13559,13 @@ CreateParserGenRuleSyntax /////////////////////////////////////////////////////////////////////////////////// // "=" as partial Assignment {type = Strong} - Clause{ _assignmentOp } = partial(tok(T::ASSIGN)).with(F::Assignment_type, GlrAssignmentType::Strong); - // "?=" as partial Assignment {type = Weak} - Clause{ _assignmentOp } = partial(tok(T::WEAK_ASSIGN)).with(F::Assignment_type, GlrAssignmentType::Weak); + auto _assignmentOp_Strong = tok(T::ASSIGN) && with(F::Assignment_type, GlrAssignmentType::Strong); + auto _assignmentOp_Weak = tok(T::WEAK_ASSIGN) && with(F::Assignment_type, GlrAssignmentType::Weak); + auto _assignmentOp = _assignmentOp_Strong | _assignmentOp_Weak; // ID:field AssignmentOp STRING:value as Assignment - Clause{ _assignment } = create(tok(T::ID, F::Assignment_field) + prule(_assignmentOp) + tok(T::ID, F::Assignment_value), C::Assignment); + Clause{ _assignment } = create(tok(T::ID, F::Assignment_field) + _assignmentOp + tok(T::ID, F::Assignment_value), C::Assignment); // Syntax:syntax "as" ID:type ["{" {Assignment:assignments ; ","} "}"] as CreateClause Clause{ _clause } = create(rule(_syntax, F::CreateClause_syntax) + tok(T::AS) + tok(T::ID, F::CreateClause_type) + opt(tok(T::OPEN_CURLY) + loop(rule(_assignment, F::CreateClause_assignments), tok(T::COMMA)) + tok(T::CLOSE_CURLY)), C::CreateClause); @@ -17058,58 +13576,6 @@ CreateParserGenRuleSyntax // Syntax:syntax ["{" {Assignment:assignments ; ","} "}"] as ReuseClause Clause{ _clause } = create(rule(_syntax, F::ReuseClause_syntax) + opt(tok(T::OPEN_CURLY) + loop(rule(_assignment, F::ReuseClause_assignments), tok(T::COMMA)) + tok(T::CLOSE_CURLY)), C::ReuseClause); - /////////////////////////////////////////////////////////////////////////////////// - // Clause (left recursive) - /////////////////////////////////////////////////////////////////////////////////// - - // ID:flag as LeftRecursionPlaceholder - Clause{ _placeholder } = create(tok(T::ID, F::LeftRecursionPlaceholder_flag), C::LeftRecursionPlaceholder); - - // ID:literal as RefSyntax {refType = ID} - Clause{ _ruleName } = create(tok(T::ID, F::RefSyntax_literal), C::RefSyntax).with(F::RefSyntax_refType, GlrRefType::Id); - - // "left_recursion_placeholder" "(" RuleName:flags {"," ruleName:flags} ")" as LeftRecursionPlaceholderClause - Clause{ _clause } = create( - tok(T::LS_PH) + tok(T::OPEN_ROUND) - + rule(_placeholder, F::LeftRecursionPlaceholderClause_flags) - + loop(tok(T::COMMA) + rule(_placeholder, F::LeftRecursionPlaceholderClause_flags)) - + tok(T::CLOSE_ROUND), - C::LeftRecursionPlaceholderClause); - - // "left_recursion_inject" as partial LeftRecursionInjectContinuation {configuration = Single} - Clause{ _lriConfig } = partial(tok(T::LS_I)).with(F::LeftRecursionInjectContinuation_configuration, GlrLeftRecursionConfiguration::Single); - - // "left_recursion_inject_multiple" as partial LeftRecursionInjectContinuation {configuration = Multiple} - Clause{ _lriConfig } = partial(tok(T::LS_IM)).with(F::LeftRecursionInjectContinuation_configuration, GlrLeftRecursionConfiguration::Multiple); - - // LriConfig "(" Placeholder:flag {"," Placeholder:flag} ")" LriTarget:injectionTargets {"|" LriTarget:injectionTargets} as partial LeftRecursionInjectContinuation - Clause{ _lriContinuationBody } = partial( - prule(_lriConfig) + tok(T::OPEN_ROUND) - + rule(_placeholder, F::LeftRecursionInjectContinuation_flags) - + loop(tok(T::COMMA) + rule(_placeholder, F::LeftRecursionInjectContinuation_flags)) - + tok(T::CLOSE_ROUND) - + rule(_lriTarget, F::LeftRecursionInjectContinuation_injectionTargets) - + loop(tok(T::ALTERNATIVE) + rule(_lriTarget, F::LeftRecursionInjectContinuation_injectionTargets)) - ); - - // LriContinuationBody as LeftRecursionInjectionContinuation {type = Required} - Clause{ _lriContinuation } = create(prule(_lriContinuationBody), C::LeftRecursionInjectContinuation).with(F::LeftRecursionInjectContinuation_type, GlrLeftRecursionInjectContinuationType::Required); - - // "[" LriContinuationBody as LeftRecursionInjectionContinuation "]" {type = Optional} - Clause{ _lriContinuation } = create(tok(T::OPEN_SQUARE) + prule(_lriContinuationBody) + tok(T::CLOSE_SQUARE), C::LeftRecursionInjectContinuation).with(F::LeftRecursionInjectContinuation_type, GlrLeftRecursionInjectContinuationType::Optional); - - // RuleName:rule as LeftRecursionInjectClause - Clause{ _lriTarget } = create(rule(_ruleName, F::LeftRecursionInjectClause_rule), C::LeftRecursionInjectClause); - - // "(" RuleName:rule LriContinuation:continuation ")" as LeftRecursionInjectClause - Clause{ _lriTarget } = create(tok(T::OPEN_ROUND) + rule(_ruleName, F::LeftRecursionInjectClause_rule) + rule(_lriContinuation, F::LeftRecursionInjectClause_continuation) + tok(T::CLOSE_ROUND), C::LeftRecursionInjectClause); - - // "!" RuleName:rule LriContinuation:continuation as LeftRecursionInjectClause - Clause{ _clause } = create(tok(T::USE) + rule(_ruleName, F::LeftRecursionInjectClause_rule) + rule(_lriContinuation, F::LeftRecursionInjectClause_continuation), C::LeftRecursionInjectClause); - - // "!" "prefix_merge" "(" RuleName:rule ")" as PrefixMergeClause - Clause{ _clause } = create(tok(T::USE) + tok(T::LS_PM) + tok(T::OPEN_ROUND) + rule(_ruleName, F::PrefixMergeClause_rule) + tok(T::CLOSE_ROUND), C::PrefixMergeClause); - /////////////////////////////////////////////////////////////////////////////////// // File /////////////////////////////////////////////////////////////////////////////////// @@ -17118,7 +13584,7 @@ CreateParserGenRuleSyntax Clause{ _rule } = create(opt(tok(T::ATT_PUBLIC, F::Rule_attPublic)) + opt(tok(T::ATT_PARSER, F::Rule_attParser)) + tok(T::ID, F::Rule_name) + opt(tok(T::COLON) + tok(T::ID, F::Rule_type)) + loop(tok(T::INFER) + rule(_clause, F::Rule_clauses)) + tok(T::SEMICOLON), C::Rule); // [Switches] Rule:rules {Rule:rules} as SyntaxFile - Clause{ _file } = create(opt(prule(_switches)) + rule(_rule, F::SyntaxFile_rules) + loop(rule(_rule, F::SyntaxFile_rules)), C::SyntaxFile); + Clause{ _file } = create(opt(_switches) + rule(_rule, F::SyntaxFile_rules) + loop(rule(_rule, F::SyntaxFile_rules)), C::SyntaxFile); } } } @@ -17155,16 +13621,11 @@ CreateParserGenTypeSyntax auto _enumItem = createRule(L"EnumItem"); auto _enum = createRule(L"Enum"); - auto _classPropType = createRule(L"ClassPropType"); auto _classProp = createRule(L"classProp"); - auto _classBody = createRule(L"ClassBody"); auto _class = createRule(L"Class"); auto _type = createRule(L"Type"); auto _file = createRule(L"File"); - _classPropType->isPartial = true; - _classBody->isPartial = true; - _file->isParser = true; _file->ruleType = dynamic_cast(ast.Symbols()[L"AstFile"][0]); @@ -17179,22 +13640,21 @@ CreateParserGenTypeSyntax Clause{ _enum } = create(opt(tok(T::ATT_PUBLIC, F::Type_attPublic)) + tok(T::ENUM) + tok(T::ID, F::Type_name) + tok(T::OPEN_CURLY) + loop(rule(_enumItem, F::Enum_items)) + tok(T::CLOSE_CURLY), C::Enum); // "token" as partial ClassProp {propType = "Token"} - Clause{ _classPropType } = partial(tok(T::TOKEN)).with(F::ClassProp_propType, GlrPropType::Token); - // ID:propTypeName as partial ClassProp {propType = "Type"} - Clause{ _classPropType } = partial(tok(T::ID, F::ClassProp_propTypeName)).with(F::ClassProp_propType, GlrPropType::Type); - // ID:propTypeName "[" "]" as partial ClassProp {propType = "Array"} - Clause{ _classPropType } = partial(tok(T::ID, F::ClassProp_propTypeName) + tok(T::OPEN_SQUARE) + tok(T::CLOSE_SQUARE)).with(F::ClassProp_propType, GlrPropType::Array); + auto _classPropType_Token = tok(T::TOKEN) && with(F::ClassProp_propType, GlrPropType::Token); + auto _classPropType_Type = (tok(T::ID, F::ClassProp_propTypeName)) && with(F::ClassProp_propType, GlrPropType::Type); + auto _classPropType_Array = (tok(T::ID, F::ClassProp_propTypeName) + tok(T::OPEN_SQUARE) + tok(T::CLOSE_SQUARE)) && with(F::ClassProp_propType, GlrPropType::Array); + auto _classPropType = _classPropType_Token | _classPropType_Type | _classPropType_Array; // "var" ID:name ":" ClassPropType ";" as ClassProp - Clause{ _classProp } = create(tok(T::VAR) + tok(T::ID, F::ClassProp_name) + tok(T::COLON) + prule(_classPropType) + tok(T::SEMICOLON), C::ClassProp); + Clause{ _classProp } = create(tok(T::VAR) + tok(T::ID, F::ClassProp_name) + tok(T::COLON) + _classPropType + tok(T::SEMICOLON), C::ClassProp); // ID:name [":" ID:baseClass] "{" {ClassProp} "}" as partial Class - Clause{ _classBody } = partial(tok(T::ID, F::Type_name) + opt(tok(T::COLON) + tok(T::ID, F::Class_baseClass)) + tok(T::OPEN_CURLY) + loop(rule(_classProp, F::Class_props)) + tok(T::CLOSE_CURLY)); + auto _classBody = (tok(T::ID, F::Type_name) + opt(tok(T::COLON) + tok(T::ID, F::Class_baseClass)) + tok(T::OPEN_CURLY) + loop(rule(_classProp, F::Class_props)) + tok(T::CLOSE_CURLY)); // ["@public"] ["@ambiguous"] "class" ClassBody {ambiguity = Yes} - Clause{ _class } = create(opt(tok(T::ATT_PUBLIC, F::Type_attPublic)) + opt(tok(T::ATT_AMBIGUOUS, F::Class_attAmbiguous)) + tok(T::CLASS) + prule(_classBody), C::Class); + Clause{ _class } = create(opt(tok(T::ATT_PUBLIC, F::Type_attPublic)) + opt(tok(T::ATT_AMBIGUOUS, F::Class_attAmbiguous)) + tok(T::CLASS) + _classBody, C::Class); // !Class | !Enum Clause{ _type } = use(_enum) | use(_class); @@ -17253,73 +13713,145 @@ namespace vl using namespace collections; /*********************************************************************** -StateSymbolSet +SyntaxSymbolManager::MergeEdgesWithSameInput ***********************************************************************/ - struct StateSymbolSet + void SyntaxSymbolManager::ApplyIncrementalChange(const IncrementalChange& ic, StateList& newStates, EdgeList& newEdges) { - private: - static const SortedList EmptyStates; - - Ptr> states; - - public: - StateSymbolSet() = default; - StateSymbolSet(const StateSymbolSet&) = delete; - StateSymbolSet& operator=(const StateSymbolSet&) = delete; - - StateSymbolSet(StateSymbolSet&& set) + if (ic.createdStates.Count() + ic.createdEdges.Count() > 0) { - states = set.states; - set.states = nullptr; - } - - StateSymbolSet& operator=(StateSymbolSet&& set) - { - states = set.states; - set.states = nullptr; - return *this; - } - - StateSymbolSet Copy() const - { - StateSymbolSet set; - set.states = states; - return set; - } - - bool Add(StateSymbol* state) - { - if (states) + for (vint i = newEdges.Count() - 1; i >= 0; i--) { - if (states->Contains(state)) return false; - states->Add(state); - return true; + auto edge = newEdges[i]; + if (ic.reuseOps == !ic.opEdges.Contains(edge.Obj())) + { + if (edge->fromState) edge->fromState->outEdges.Remove(edge.Obj()); + if (edge->toState) edge->toState->inEdges.Remove(edge.Obj()); + newEdges.RemoveAt(i); + } } - else + + for (vint i = newStates.Count() - 1; i >= 0; i--) { - states = Ptr(new SortedList); - states->Add(state); - return true; + auto state = newStates[i]; + if (ic.reuseOps == !ic.opStates.Contains(state.Obj())) + { + newStates.RemoveAt(i); + } + } + + CopyFrom(newStates, ic.createdStates, true); + CopyFrom(newEdges, ic.createdEdges, true); + } + } + +/*********************************************************************** +SyntaxSymbolManager::BuildCompactNFAInternal +***********************************************************************/ + + void SyntaxSymbolManager::BuildCompactNFAInternal() + { + Array, Ptr>> newStatesAndEdges(rules.map.Count()); + for (vint i = 0; i < newStatesAndEdges.Count(); i++) + { + newStatesAndEdges[i] = { Ptr(new StateList),Ptr(new EdgeList) }; + } + + for (auto [ruleSymbol, i] : indexed(rules.map.Values())) + { + auto&& newStates = *newStatesAndEdges[i].key.Obj(); + auto&& newEdges = *newStatesAndEdges[i].value.Obj(); + // remove all epsilon edges, potentially duplicating input edges + auto [startState, endState] = EliminateEpsilonEdges(ruleSymbol, newStates, newEdges); + ruleSymbol->startStates.Clear(); + ruleSymbol->startStates.Add(startState); + + // there will be only one start state per rule after EliminateEpsilonEdges + // detect and resolve direct left recursion + EliminateLeftRecursion(ruleSymbol, startState, endState, newStates, newEdges); + + // merge as many input edges as possible to reduce wasted traces during parsing + // they consume same token or rule from the same state + // performance will be bad if duplicated parsing actually happen + // could save 20x wasted traces for Workflow parser + MergeEdgesWithSameInput(ruleSymbol, startState, newStates, newEdges); + MergeEdgesWithSameRuleUsingLeftrec(ruleSymbol, ruleSymbol->startStates[0], newStates, newEdges); + } + + // further merging but introduces minimum cross-reference rule input to states in other rule + // this should only be done after performing local merging inside each rule + // detect and ban indirect left recursion + auto pmCache = CreatePrefixMergeCache(); + if (!pmCache) return; + PrefixMergeCrossReference_Solve(pmCache.Obj(), prefixMergeSolutions); + + // apply each solution + // unnecessary edges will be removed later as they could be still needed + // prefix-merge created Rule becomes PrefixMergeRule and later changed back to Rule + Array ics(prefixMergeSolutions.Count()); + for (auto [key, index] : indexed(prefixMergeSolutions.Keys())) + { + auto [ruleSymbol, currentState] = key; + auto solution = prefixMergeSolutions[key]; + auto&& ic = ics[index]; + ic.reuseOps = false; + PrefixMergeCrossReference_Apply(pmCache.Obj(), ruleSymbol, currentState, solution, ic); + } + + // recycle unused states and edges + for (auto [key, index] : indexed(prefixMergeSolutions.Keys())) + { + auto [ruleSymbol, currentState] = key; + vint i = rules.map.Keys().IndexOf(ruleSymbol->Name()); + auto&& newStates = *newStatesAndEdges[i].key.Obj(); + auto&& newEdges = *newStatesAndEdges[i].value.Obj(); + auto&& ic = ics[index]; + ApplyIncrementalChange(ic, newStates, newEdges); + + auto solution = prefixMergeSolutions[key]; + for (auto application : solution->applications) + { + for (auto edge : application->edgesToMerge) + { + edge->input.type = EdgeInputType::PrefixMergeDiscardedRule; + } + } + + for (auto edge : currentState->OutEdges()) + { + if (edge->input.type == EdgeInputType::PrefixMergeRule) + { + edge->input.type = EdgeInputType::Rule; + } } } - const SortedList& States() const + // secure life cycle of states and edges + states.Clear(); + edges.Clear(); + for (vint i = 0; i < newStatesAndEdges.Count(); i++) { - return states ? *states.Obj() : EmptyStates; + auto&& newStates = *newStatesAndEdges[i].key.Obj(); + auto&& newEdges = *newStatesAndEdges[i].value.Obj(); + CopyFrom(states, newStates, true); + CopyFrom(edges, newEdges, true); } + } + } + } +} - std::strong_ordering operator<=>(const StateSymbolSet& set) const - { - if (!states && !set.states) return std::strong_ordering::equal; - if (!states) return std::strong_ordering::less; - if (!set.states) return std::strong_ordering::greater; - return CompareEnumerable(*states.Obj(), *set.states.Obj()); - } +/*********************************************************************** +.\SYNTAX\SYNTAXSYMBOL_NFACOMPACT_ELIMINATEEPSILONEDGES.CPP +***********************************************************************/ - bool operator==(const StateSymbolSet& set) const { return (*this <=> set) == 0; } - }; - const SortedList StateSymbolSet::EmptyStates; +namespace vl +{ + namespace glr + { + namespace parsergen + { + using namespace collections; /*********************************************************************** CompactSyntaxBuilder @@ -17361,8 +13893,6 @@ CompactSyntaxBuilder { case EdgeInputType::Token: case EdgeInputType::Rule: - case EdgeInputType::LrPlaceholder: - case EdgeInputType::LrInject: { // a new edge is created, accumulating multiple epsilon edges, ending with such edge auto targetNewState = CreateCompactState(edge->To()); @@ -17373,12 +13903,10 @@ CompactSyntaxBuilder auto newEdge = Ptr(new EdgeSymbol(newState, targetNewState)); newEdges.Add(newEdge); newEdge->input = edge->input; - newEdge->important |= edge->important; for (auto accumulatedEdge : accumulatedEdges) { - CopyFrom(newEdge->insBeforeInput, accumulatedEdge->insBeforeInput, true); CopyFrom(newEdge->insAfterInput, accumulatedEdge->insAfterInput, true); - newEdge->important |= accumulatedEdge->important; + CopyFrom(newEdge->competitions, accumulatedEdge->competitions, true); } } break; @@ -17386,7 +13914,12 @@ CompactSyntaxBuilder BuildEpsilonEliminatedEdgesInternal(edge->To(), newState, endState, visited, accumulatedEdges); break; case EdgeInputType::Ending: - // Ending is ignored because it doesn't exist in epsilon-NFA + // These edges are not involved + case EdgeInputType::LeftRec: + case EdgeInputType::PrefixMergeDiscardedRule: + case EdgeInputType::PrefixMergeRule: + case EdgeInputType::CrossReferencedToken: + // These edges do not exist in epsilon-NFA break; default: CHECK_FAIL(L"Unhandled!"); @@ -17405,20 +13938,16 @@ CompactSyntaxBuilder newEdge->input.type = EdgeInputType::Ending; for (auto accumulatedEdge : accumulatedEdges) { - CopyFrom(newEdge->insBeforeInput, accumulatedEdge->insBeforeInput, true); CopyFrom(newEdge->insAfterInput, accumulatedEdge->insAfterInput, true); - newEdge->important |= accumulatedEdge->important; + CopyFrom(newEdge->competitions, accumulatedEdge->competitions, true); } for (auto endingEdge : newState->OutEdges()) { if (endingEdge != newEdge && endingEdge->input.type == EdgeInputType::Ending) { - if ( - CompareEnumerable(endingEdge->insBeforeInput, newEdge->insBeforeInput) == 0 && - CompareEnumerable(endingEdge->insAfterInput, newEdge->insAfterInput) == 0) + if (CompareEnumerable(endingEdge->insAfterInput, newEdge->insAfterInput) == 0) { - CHECK_ERROR(newEdge->important == endingEdge->important, L"It is not possible to have two equal ending edges with different priority."); newState->outEdges.Remove(newEdge.Obj()); endState->inEdges.Remove(newEdge.Obj()); goto DISCARD_ENDING_EDGE; @@ -17447,7 +13976,7 @@ CompactSyntaxBuilder } else { - auto newState = Ptr(new StateSymbol(rule, state->ClauseId())); + auto newState = Ptr(new StateSymbol(rule)); newState->label = state->label; newStates.Add(newState); oldToNew.Add(state, newState.Obj()); @@ -17466,39 +13995,93 @@ CompactSyntaxBuilder } }; +/*********************************************************************** +SyntaxSymbolManager::EliminateEpsilonEdges +***********************************************************************/ + + SyntaxSymbolManager::StartEndStatePair SyntaxSymbolManager::EliminateEpsilonEdges(RuleSymbol* rule, StateList& newStates, EdgeList& newEdges) + { + /* + * For any transition that goes through some epsilon edge and ends with a non-epsilon edge + * we copy all instructions from epsilon edges and the non-epsilon edge in order + * and create a new edge directly pointing to the toState of the non-epsilon edge + * + * [BEFORE] + * +-(x)-> B + * | + * A -(e1)-+-(e2)-> C -+-(y)-> E + * | | + * +-(e3)-> D -+ + * + * [AFTER] + * +-(e1,x)-> B + * | + * A -+-(e1,e2,y)-> E + * | ^ + * +-(e1,e3,y)---+ + */ + + // epsilon-NFAs are per clause + // now we need to create a start state and an ending state + // to connect all epsilon-NFAs of its clauses together + auto psuedoState = Ptr(new StateSymbol(rule)); + newStates.Add(psuedoState); + for (auto startState : rule->startStates) + { + newEdges.Add(Ptr(new EdgeSymbol(psuedoState.Obj(), startState))); + } + + CompactSyntaxBuilder builder(rule, newStates, newEdges); + auto compactStartState = builder.CreateCompactState(psuedoState.Obj()); + compactStartState->label = L" BEGIN "; + + auto compactEndState = Ptr(new StateSymbol(rule)); + compactEndState->label = L" END "; + compactEndState->endingState = true; + newStates.Add(compactEndState); + + List visited; + visited.Add(compactStartState); + + // all epsilon-NFAs of its clauses become one connected epsilon-NFA of this rule + // we can build the compact-NFA out of this epsilon-NFA starting from the start state + // TODO: (enumerable) foreach:alterable + for (vint i = 0; i < visited.Count(); i++) + { + auto current = visited[i]; + builder.BuildEpsilonEliminatedEdges(current, compactEndState.Obj(), visited); + } + + return { compactStartState,compactEndState.Obj()}; + } + } + } +} + +/*********************************************************************** +.\SYNTAX\SYNTAXSYMBOL_NFACOMPACT_ELIMINATELEFTRECURSION.CPP +***********************************************************************/ + +namespace vl +{ + namespace glr + { + namespace parsergen + { + using namespace collections; + /*********************************************************************** SyntaxSymbolManager::BuildLeftRecEdge ***********************************************************************/ void SyntaxSymbolManager::BuildLeftRecEdge(EdgeSymbol* newEdge, EdgeSymbol* endingEdge, EdgeSymbol* lrecPrefixEdge) { - newEdge->important |= endingEdge->important; - newEdge->important |= lrecPrefixEdge->important; + CopyFrom(newEdge->competitions, endingEdge->competitions, true); + CopyFrom(newEdge->competitions, lrecPrefixEdge->competitions, true); newEdge->input.type = EdgeInputType::LeftRec; - CopyFrom(newEdge->insBeforeInput, endingEdge->insBeforeInput, true); CopyFrom(newEdge->insAfterInput, endingEdge->insAfterInput, true); - CopyFrom(newEdge->insBeforeInput, lrecPrefixEdge->insBeforeInput, true); CopyFrom(newEdge->insAfterInput, lrecPrefixEdge->insAfterInput, true); - - // TODO: (enumerable) foreach:indexed(alterable(reversed)) - for (vint i = newEdge->insBeforeInput.Count() - 1; i >= 0; i--) - { - if (newEdge->insBeforeInput[i].type == AstInsType::BeginObject) - { - newEdge->insBeforeInput.Insert(i, { AstInsType::LriStore }); - newEdge->insBeforeInput.Insert(i + 2, { AstInsType::LriFetch }); - } - } - // TODO: (enumerable) foreach:indexed(alterable(reversed)) - for (vint i = newEdge->insAfterInput.Count() - 1; i >= 0; i--) - { - if (newEdge->insAfterInput[i].type == AstInsType::BeginObject) - { - newEdge->insBeforeInput.Insert(i, { AstInsType::LriStore }); - newEdge->insBeforeInput.Insert(i + 2, { AstInsType::LriFetch }); - } - } } /*********************************************************************** @@ -17556,289 +14139,1677 @@ SyntaxSymbolManager::EliminateLeftRecursion newEdges.Remove(lrecEdge); } } + } + } +} /*********************************************************************** -SyntaxSymbolManager::EliminateSingleRulePrefix +.\SYNTAX\SYNTAXSYMBOL_NFACOMPACT_MERGEEDGESWITHSAMEINPUT.CPP ***********************************************************************/ - void SyntaxSymbolManager::EliminateSingleRulePrefix(RuleSymbol* rule, StateSymbol* startState, StateSymbol* endState, StateList& newStates, EdgeList& newEdges) +namespace vl +{ + namespace glr + { + namespace parsergen + { + using namespace collections; + +/*********************************************************************** +SymbolSet +***********************************************************************/ + + template + struct SymbolSetListType; + + template + struct SymbolSetListType + { + using Type = List; + }; + + template + struct SymbolSetListType + { + using Type = SortedList; + }; + + template + using SymbolSetListType_t = typename SymbolSetListType::Type;; + + template + struct SymbolSet + { + public: + using ListType = SymbolSetListType_t; + using ListPtr = Ptr; + + private: + static const ListType EmptySymbols; + ListPtr symbols; + + public: + SymbolSet() = default; + SymbolSet(const SymbolSet&) = delete; + SymbolSet& operator=(const SymbolSet&) = delete; + + SymbolSet(SymbolSet&& set) + { + symbols = set.symbols; + set.symbols = nullptr; + } + + SymbolSet& operator=(SymbolSet&& set) + { + symbols = set.symbols; + set.symbols = nullptr; + return *this; + } + + SymbolSet(TSymbol _symbol) + { + Add(_symbol); + } + + SymbolSet(const IEnumerable& _symbols) + { + symbols = Ptr(new ListType); + CopyFrom(*symbols.Obj(), _symbols); + } + + bool Add(TSymbol _symbol) + { + if (!symbols) + { + symbols = Ptr(new ListType); + } + if (symbols->Contains(_symbol)) return false; + symbols->Add(_symbol); + return true; + } + + const ListType& Symbols() const + { + return symbols ? *symbols.Obj() : EmptySymbols; + } + + ListPtr SymbolsPtr() const + { + return symbols; + } + + std::strong_ordering operator<=>(const SymbolSet& set) const + { + if (!symbols && !set.symbols) return std::strong_ordering::equal; + if (!symbols) return std::strong_ordering::less; + if (!set.symbols) return std::strong_ordering::greater; + return CompareEnumerable(*symbols.Obj(), *set.symbols.Obj()); + } + + bool operator==(const SymbolSet& set) const + { + return (*this <=> set) == 0; + } + }; + + template + const SymbolSetListType_t SymbolSet::EmptySymbols; + + struct LabeledState + { + WString label; + vint index; + StateSymbol* state = nullptr; + + auto operator<=>(const LabeledState& ls) const = default; + bool operator==(const LabeledState&) const = default; + }; + + using StateSymbolSet = SymbolSet; + using InsSymbolSet = SymbolSet; + using CompetitionSymbolSet = SymbolSet; + +/*********************************************************************** +SyntaxSymbolManager::MergeEdgesWithSameInput +***********************************************************************/ + + void SyntaxSymbolManager::MergeEdgesWithSameInput(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges) { /* - * Move the single rule prefix from the rule begin state - * if there is any single rule clause consist of the same rule - * + * Two edges can be merged if: + * They are both Token or Rule + * They have the same input, insAfterInput and competitions + * returnEdges of an edge is empty at this moment so it is ignored + * + * If a state has multiple outgoing edges that can be merged + * the target states will be merged into one + * all outgoing edges from target states will be recreated from the merged state + * mergable edges will be replaced by a new edge + * * [BEFORE] - * +-(x)-> A --------(ending)-+ - * | | - * S -+-(x)-> ... -> B -(ending)-+-> E - * | | - * +-(x)-> ... -> C -(ending)-+ - * + * +-(r)-> U -(b)-> X + * | + * A -+-(r)-> V -(b)-> Y + * | + * +-(r)-> W -(c)-> Z + * * [AFTER] - * +-(leftrec)-> ... -> B -(ending)---+ - * | v - * S-(x)-> A -+-----------------------(ending)-> E - * | ^ - * +-(leftrec)-> ... -> C -(ending)---+ + * + * +-(b)-> XY + * | + * A -+-(r)-> UVW -+-(c)-> Z */ - Group prefixEdges; - List continuationEdges, eliminatedEdges; + Dictionary> statesToMerged; + Dictionary mergedToStates; - // identify prefix edge and continuation edge - // prefix edges are clauses (x) - // continuation edges are all qualified clauses with prefix (x) except prefix edges - for (auto edge : startState->OutEdges()) + List workingStates; + IncrementalChange ic; + + // Start from the start state { - if (edge->input.type != EdgeInputType::Rule) continue; - if (edge->input.rule == rule) continue; - auto state = edge->To(); - if (state->InEdges().Count() > 1) continue; + ic.opStates.Add(startState); + workingStates.Add(startState); + } - if (state->OutEdges().Count() == 1 && state->OutEdges()[0]->input.type == EdgeInputType::Ending) + auto ReuseState = [&](StateSymbol* state) + { + if (!ic.opStates.Contains(state)) { - prefixEdges.Add(edge->input.rule, edge); + ic.opStates.Add(state); + workingStates.Add(state); + } + }; + + auto ReuseEdge = [&](EdgeSymbol* edge) + { + ReuseState(edge->To()); + if (!ic.opEdges.Contains(edge)) + { + ic.opEdges.Add(edge); + } + }; + + auto ApplyEdgeToMergedState = [&](EdgeSymbol* edge, StateSymbol* mergedState) + { + ReuseState(edge->To()); + auto newEdge = Ptr(new EdgeSymbol(mergedState, edge->To())); + ic.createdEdges.Add(newEdge); + newEdge->input = edge->input; + CopyFrom(newEdge->competitions, edge->competitions); + CopyFrom(newEdge->insAfterInput, edge->insAfterInput); + }; + + for (vint i = 0; i < workingStates.Count(); i++) + { + auto currentState = workingStates[i]; + vint currentMergedToStateIndex = mergedToStates.Keys().IndexOf(currentState); + + Group, EdgeSymbol*> groupedEdges; + if (currentMergedToStateIndex == -1) + { + // if the current state is an original state + for (auto edge : currentState->OutEdges()) + { + if (edge->input.type == EdgeInputType::Token || edge->input.type == EdgeInputType::Rule) + { + // only group Token or Rule edges + groupedEdges.Add( + { + edge->input, + InsSymbolSet{edge->insAfterInput}, + CompetitionSymbolSet(edge->competitions) + }, edge); + } + else + { + // reuse others + ReuseEdge(edge); + } + } } else { - continuationEdges.Add(edge); - } - } - - // TODO: (enumerable) foreach on group - for (auto [ruleSymbol, prefixIndex] : indexed(prefixEdges.Keys())) - { - auto&& prefixEdgesOfRule = prefixEdges.GetByIndex(prefixIndex); - CHECK_ERROR(prefixEdgesOfRule.Count() == 1, L"Multiple prefix edges under the same rule is not supported yet."); - - // TODO: - // prefixEdge means the clause could consume only one rule - // multiple prefixEdge could be - // the rule has multiple such clauses - // there is one clause but it looks like "([a] | [b]) c" - // where both [a] and [b] create an epsilon edge to c - // and after removing epsilon edges they become both edge consuming c - // in this case we need to create a prefix edges to replace all others - // it also means unresolvable ambiguity - // maybe a better solution is to define it as a kind of invalid syntax - } - - // for all prefixEdge and continuationEdge under the same rule - // if their insBeforeInput are different - // move prefixEdge's insBeforeInput to insAfterInput with help from LriStore and LriFetch - SortedList compatibleInsBeforeInputPrefixRules; - // TODO: (enumerable) foreach on group - for (auto [ruleSymbol, prefixIndex] : indexed(prefixEdges.Keys())) - { - // see if all prefixEdges are compatible - auto&& prefixEdgesOfRule = prefixEdges.GetByIndex(prefixIndex); - auto prefixEdge = prefixEdgesOfRule[0]; - for (auto otherPrefixEdge : From(prefixEdgesOfRule).Skip(1)) - { - if (CompareEnumerable(prefixEdge->insBeforeInput, otherPrefixEdge->insBeforeInput) != 0) + // if the current state is a merged state, search all of its original states + for (auto targetState : *mergedToStates.Values()[currentMergedToStateIndex].Obj()) { - goto INCOMPATIBLE; - } - } - - // see if all continuationEdges are compatible - for (auto continuationEdge : continuationEdges) - { - if (continuationEdge->input.rule == prefixEdge->input.rule) - { - if (CompareEnumerable(prefixEdge->insBeforeInput, continuationEdge->insBeforeInput) != 0) + for (auto edge : targetState.state->OutEdges()) { - goto INCOMPATIBLE; + if (edge->input.type == EdgeInputType::Token || edge->input.type == EdgeInputType::Rule) + { + // only group Token or Rule edges + groupedEdges.Add( + { + edge->input, + InsSymbolSet{edge->insAfterInput}, + CompetitionSymbolSet(edge->competitions) + }, edge); + } + else + { + // duplicate others to start from the merged state + ApplyEdgeToMergedState(edge, currentState); + } } } } - compatibleInsBeforeInputPrefixRules.Add(ruleSymbol); - INCOMPATIBLE:; - } - - // for all prefixEdge that fails the above test - // combine insBeforeInput with insAfterInput with the help from LriStore and LriFetch - // properly move instructions from prefixEdge to endingEdge - // TODO: (enumerable) foreach on group - for (auto [ruleSymbol, prefixIndex] : indexed(prefixEdges.Keys())) - { - bool compatible = compatibleInsBeforeInputPrefixRules.Contains(ruleSymbol); - for (auto prefixEdge : prefixEdges.GetByIndex(prefixIndex)) + // see if multiple edges could be grouped together + for (vint groupedIndex = 0; groupedIndex < groupedEdges.Count(); groupedIndex++) { - List ins; - if (!compatible && prefixEdge->insBeforeInput.Count() > 0) + auto&& groupedKey = groupedEdges.Keys()[groupedIndex]; + auto&& groupedValues = groupedEdges.GetByIndex(groupedIndex); + + if (groupedValues.Count() == 1) { - ins.Add({ AstInsType::LriStore }); - CopyFrom(ins, prefixEdge->insBeforeInput, true); - ins.Add({ AstInsType::LriFetch }); - prefixEdge->insBeforeInput.Clear(); + // if a group only has one edge, reuse the target state + if (currentMergedToStateIndex == -1) + { + ReuseEdge(groupedValues[0]); + } + else + { + ApplyEdgeToMergedState(groupedValues[0], currentState); + } } - CopyFrom(ins, prefixEdge->insAfterInput, true); - prefixEdge->insAfterInput.Clear(); - - auto endingEdge = prefixEdge->To()->OutEdges()[0]; - CopyFrom(ins, endingEdge->insBeforeInput, true); - CopyFrom(endingEdge->insBeforeInput, ins); - } - } - - // for all qualified continuationEdge - // create a new edge to run continuationEdge's instruction properly after prefixEdge - // remove continuationEdge - for (auto continuationEdge : continuationEdges) - { - vint prefixIndex = prefixEdges.Keys().IndexOf(continuationEdge->input.rule); - if (prefixIndex == -1) continue; - - bool compatible = compatibleInsBeforeInputPrefixRules.Contains(continuationEdge->input.rule); - bool eliminated = false; - for (auto prefixEdge : prefixEdges.GetByIndex(prefixIndex)) - { - // important and insSwitch happen before shifting into the rule - if (continuationEdge->important != prefixEdge->important) continue; - - eliminated = true; - auto state = prefixEdge->To(); - auto newEdge = Ptr(new EdgeSymbol(state, continuationEdge->To())); - newEdges.Add(newEdge); - - newEdge->input.type = EdgeInputType::LeftRec; - newEdge->important = continuationEdge->important; - if (compatible) + else { - CopyFrom(newEdge->insAfterInput, continuationEdge->insAfterInput); - } - else if (continuationEdge->insBeforeInput.Count() > 0) - { - // for incompatible continuationEdge - // combine insBeforeInput with insAfterInput with the help from LriStore and LriFetch - newEdge->insAfterInput.Add({ AstInsType::LriStore }); - CopyFrom(newEdge->insAfterInput, continuationEdge->insBeforeInput, true); - newEdge->insAfterInput.Add({ AstInsType::LriFetch }); - CopyFrom(newEdge->insAfterInput, continuationEdge->insAfterInput, true); + // if a group has multiple edges, merge all target states into one + Ptr mergedState; + { + StateSymbolSet targetSet; + for (auto edge : groupedValues) + { + targetSet.Add({ edge->To()->label,newStates.IndexOf(edge->To()),edge->To() }); + } + + vint index = statesToMerged.Keys().IndexOf(targetSet); + if (index != -1) + { + // if the merged state already exists, reuse it + mergedState = statesToMerged.Values()[index]; + } + else + { + // otherwise, create a new merged state + // its label is the combination of all originals + mergedState = Ptr(new StateSymbol(startState->Rule())); + ic.createdStates.Add(mergedState); + workingStates.Add(mergedState.Obj()); + + mergedState->label = stream::GenerateToStream([&](stream::TextWriter& writer) + { + writer.WriteString(L"{{"); + for (auto [state, index] : indexed(targetSet.Symbols())) + { + if (index > 0) writer.WriteString(L" ; "); + writer.WriteString(state.label); + } + writer.WriteString(L"}}"); + }); + + mergedToStates.Add(mergedState.Obj(), targetSet.SymbolsPtr()); + statesToMerged.Add(std::move(targetSet), mergedState); + } + } + + auto newEdge = Ptr(new EdgeSymbol(currentState, mergedState.Obj())); + ic.createdEdges.Add(newEdge); + + newEdge->input = groupedKey.get<0>(); + CopyFrom(newEdge->insAfterInput, groupedKey.get<1>().Symbols()); + CopyFrom(newEdge->competitions, groupedKey.get<2>().Symbols()); } } - - if (eliminated) - { - eliminatedEdges.Add(continuationEdge); - } } - for (auto eliminatedEdge : eliminatedEdges) - { - vint prefixIndex = prefixEdges.Keys().IndexOf(eliminatedEdge->input.rule); - if (prefixIndex == -1) continue; - eliminatedEdge->From()->outEdges.Remove(eliminatedEdge); - eliminatedEdge->To()->inEdges.Remove(eliminatedEdge); - newEdges.Remove(eliminatedEdge); - } + ApplyIncrementalChange(ic, newStates, newEdges); } + } + } +} /*********************************************************************** -SyntaxSymbolManager::EliminateEpsilonEdges +.\SYNTAX\SYNTAXSYMBOL_NFACOMPACT_MERGEEDGESWITHSAMERULEUSINGLEFTREC.CPP ***********************************************************************/ - StateSymbol* SyntaxSymbolManager::EliminateEpsilonEdges(RuleSymbol* rule, StateList& newStates, EdgeList& newEdges) +namespace vl +{ + namespace glr + { + namespace parsergen + { + using namespace collections; + +/*********************************************************************** +SyntaxSymbolManager::MergeEdgesWithSameRuleUsingLeftrec +***********************************************************************/ + + void SyntaxSymbolManager::MergeEdgesWithSameRuleUsingLeftrec(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges) { /* - * For any transition that goes through some epsilon edge and ends with a non-epsilon edge - * we copy all instructions from epsilon edges and the non-epsilon edge in order - * and create a new edge directly pointing to the toState of the non-epsilon edge - * + * Two edges can be merged if: + * They consume the same Rule, but they have different insAfterInput and competitions + * We only check rules because MergeEdgesWithSameInput already take care of those + * + * If a state has multiple outgoing edges that can be merged + * An edge with no insAfterInput and competitions will be inserted before these edges + * These edges will be converted to LeftRec + * * [BEFORE] - * +-(x)-> B - * | - * A -(e1)-+-(e2)-> C -+-(y)-> E - * | | - * +-(e3)-> D -+ - * - * [AFTER] - * +-(e1,x)-> B + * +-(r)-> U -(ending)-> X * | - * A -+-(e1,e2,y)-> E - * | ^ - * +-(e1,e3,y)---+ + * A -+-(r)-> V -(b)-> Y + * | + * +-(r)-> W -+-(c)-> Z1 + * | + * +-(ending)-> Z2 + * + * [AFTER] + * + * +-(ending)-> X + * | + * A -(r)-> B -+-(leftrec)-> V -(b)-> Y + * | + * +-(leftrec)-> W -(c)-> Z1 + * | + * +-(ending)-> Z2 */ - // epsilon-NFAs are per clause - // now we need to create a start state and an ending state - // to connect all epsilon-NFAs of its clauses together - auto psuedoState = CreateState(rule, -1); - for (auto startState : rule->startStates) + IncrementalChange ic; + CopyFrom(ic.opStates, From(newStates).Select([](auto p) {return p.Obj(); })); + CopyFrom(ic.opEdges, From(newEdges).Select([](auto p) {return p.Obj(); })); + + SortedList visitedStates; + List workingStates; + workingStates.Add(startState); + + // travel through all states + for (vint i = 0; i < workingStates.Count(); i++) { - CreateEdge(psuedoState, startState); + // group outgoing Rule edges by rules, ignore others + auto currentState = workingStates[i]; + Group groupedEdges; + for (auto edge : currentState->OutEdges()) + { + if (edge->input.type != EdgeInputType::Rule) continue; + groupedEdges.Add(edge->input.rule, edge); + } + + for (vint j = 0; j < groupedEdges.Count(); j++) + { + // only process cases when multiple edges consume the same rule + // their insAfterInput or competitions are different + // otherwise they should have been merged in MergeEdgesWithSameInput + auto&& edges = groupedEdges.GetByIndex(j); + if (edges.Count() > 1) + { + // newState labeling [pm-lr] is made + auto newState = Ptr(new StateSymbol(rule)); + ic.createdStates.Add(newState); + newState->label = currentState->label + L"[pm-lr]"; + + // currentState goes to newState by an Rule edge with empty insAfterInput and competitions + auto newEdge = Ptr(new EdgeSymbol(currentState, newState.Obj())); + ic.createdEdges.Add(newEdge); + newEdge->input = edges[0]->input; + + // edit all original Rule edges + for (auto originalRuleEdge : edges) + { + // disconnect originalRuleEdge from currentState + originalRuleEdge->fromState->outEdges.Remove(originalRuleEdge); + originalRuleEdge->fromState = nullptr; + + vint epsilonCount = 0; + vint inputCount = 0; + + auto targetState = originalRuleEdge->toState; + for (auto targetEdge : targetState->outEdges) + { + if (targetEdge->input.type == EdgeInputType::Ending || targetEdge->input.type == EdgeInputType::LeftRec) + { + epsilonCount++; + } + else + { + inputCount++; + } + } + + if (epsilonCount == 0) + { + // if all edges following originalRuleEdge are input edges + // reconnect it from newState and turn it into LeftRec + originalRuleEdge->fromState = newState.Obj(); + originalRuleEdge->fromState->outEdges.Add(originalRuleEdge); + originalRuleEdge->input = { EdgeInputType::LeftRec }; + } + else + { + // otherwise complex editing involves + Ptr newTargetState; + for (auto targetEdge : targetState->OutEdges()) + { + if (targetEdge->input.type == EdgeInputType::Ending || targetEdge->input.type == EdgeInputType::LeftRec) + { + // for any epsilon edge following originalRuleEdge + // we don't want two epsilon edge as it would make the NFA non-compact + // a new edge will be made to merge originalRuleEdge and this following epsilon edge + auto newTargetEdge = Ptr(new EdgeSymbol(newState.Obj(), targetEdge->toState)); + ic.createdEdges.Add(newTargetEdge); + + newTargetEdge->input = targetEdge->input; + CopyFrom(newTargetEdge->competitions, originalRuleEdge->competitions, true); + CopyFrom(newTargetEdge->competitions, targetEdge->competitions, true); + CopyFrom(newTargetEdge->insAfterInput, originalRuleEdge->insAfterInput, true); + CopyFrom(newTargetEdge->insAfterInput, targetEdge->insAfterInput, true); + } + else + { + // for any input edge following originalRuleEdge + // as we can't change targetState which originalRuleEdge points to + // because there might be other edges connecting to targetState + // we will duplicate targetState to a [pm-dup] + // and make originalRuleEdge connect to it from newState as a LeftRec + if (!newTargetState) + { + newTargetState = Ptr(new StateSymbol(rule)); + ic.createdStates.Add(newTargetState); + newTargetState->label = targetState->label + L"[pm-dup]"; + + originalRuleEdge->fromState = newState.Obj(); + originalRuleEdge->fromState->outEdges.Add(originalRuleEdge); + originalRuleEdge->toState->inEdges.Remove(originalRuleEdge); + originalRuleEdge->toState = newTargetState.Obj(); + originalRuleEdge->toState->inEdges.Add(originalRuleEdge); + originalRuleEdge->input = { EdgeInputType::LeftRec }; + } + + // and copy the input rule + auto newTargetEdge = Ptr(new EdgeSymbol(newTargetState.Obj(), targetEdge->toState)); + ic.createdEdges.Add(newTargetEdge); + + newTargetEdge->input = targetEdge->input; + CopyFrom(newTargetEdge->competitions, targetEdge->competitions, true); + CopyFrom(newTargetEdge->insAfterInput, targetEdge->insAfterInput, true); + } + } + } + + if (originalRuleEdge->fromState == nullptr) + { + // if originalRuleEdge is not reused, remove it + originalRuleEdge->toState->inEdges.Remove(originalRuleEdge); + ic.opEdges.Remove(originalRuleEdge); + } + + if (targetState->inEdges.Count() == 0) + { + // after removing originalRuleEdge + // if no other state points to targetState + // remove it + // if a [pm-dup] is made, we won't reusing and just let that happen + ic.opStates.Remove(targetState); + for (auto targetEdge : targetState->OutEdges()) + { + targetEdge->toState->inEdges.Remove(targetEdge); + ic.opEdges.Remove(targetEdge); + } + } + } + } + } + + for (auto edge : currentState->OutEdges()) + { + if (!visitedStates.Contains(edge->To())) + { + visitedStates.Add(edge->To()); + workingStates.Add(edge->To()); + } + } } - CompactSyntaxBuilder builder(rule, newStates, newEdges); - auto compactStartState = builder.CreateCompactState(psuedoState); - compactStartState->label = L" BEGIN "; - - auto compactEndState = Ptr(new StateSymbol(rule, -1)); - compactEndState->label = L" END "; - compactEndState->endingState = true; - newStates.Add(compactEndState); - - List visited; - visited.Add(compactStartState); - - // all epsilon-NFAs of its clauses become one connected epsilon-NFA of this rule - // we can build the compact-NFA out of this epsilon-NFA starting from the start state - // TODO: (enumerable) foreach:alterable - for (vint i = 0; i < visited.Count(); i++) - { - auto current = visited[i]; - builder.BuildEpsilonEliminatedEdges(current, compactEndState.Obj(), visited); - } - - // optimize - EliminateLeftRecursion(rule, compactStartState, compactEndState.Obj(), newStates, newEdges); - EliminateSingleRulePrefix(rule, compactStartState, compactEndState.Obj(), newStates, newEdges); - - return compactStartState; + ApplyIncrementalChange(ic, newStates, newEdges); } + } + } +} /*********************************************************************** -SyntaxSymbolManager::BuildCompactNFAInternal +.\SYNTAX\SYNTAXSYMBOL_NFACOMPACT_PREFIXMERGECROSSREFERENCE.CPP ***********************************************************************/ - void SyntaxSymbolManager::BuildCompactNFAInternal() - { - StateList newStates; - EdgeList newEdges; - for (auto ruleSymbol : rules.map.Values()) - { - auto startState = EliminateEpsilonEdges(ruleSymbol, newStates, newEdges); - ruleSymbol->startStates.Clear(); - ruleSymbol->startStates.Add(startState); - } - CopyFrom(states, newStates); - CopyFrom(edges, newEdges); +namespace vl +{ + namespace glr + { + namespace parsergen + { + using namespace collections; - // only when a state has any important out edge - // its out edges are marked accordingly - for (auto state : states) +/*********************************************************************** +BitSet +***********************************************************************/ + + struct BitSet + { + public: + static const BitSet Zero; + + private: + vint wordCount = 0; + vuint64_t* words = nullptr; + + static bool AllZero(vuint64_t* words, vint wordCount) { - bool competition = false; - for (auto edge : state->OutEdges()) + for (vint i = 0; i < wordCount; i++) { - if (edge->important) + if (words[i] != 0) return false; + } + return true; + } + public: + BitSet& operator=(const BitSet& bs) noexcept + { + if (this != &bs) + { + wordCount = bs.wordCount; + if (words) { - competition = true; + delete[] words; + words = nullptr; + } + if (bs.words) + { + words = new vuint64_t[wordCount]; + memcpy(words, bs.words, sizeof(vuint64_t) * wordCount); + } + } + return *this; + } + + BitSet& operator=(BitSet&& bs) noexcept + { + if (this != &bs) + { + wordCount = bs.wordCount; + if (words) + { + delete[] words; + } + words = bs.words; + bs.wordCount = 0; + bs.words = nullptr; + } + return *this; + } + + BitSet() = default; + BitSet(const BitSet& bs) noexcept { *this = bs; } + BitSet(BitSet&& bs) noexcept { *this = std::move(bs); } + ~BitSet() { if (words) delete[] words; } + + auto operator<=>(const BitSet& bs) const + { + if (this == &bs) return std::strong_ordering::equal; + vint minWordCount = wordCount < bs.wordCount ? wordCount : bs.wordCount; + if (minWordCount > 0) + { + auto result = memcmp(words, bs.words, sizeof(vuint64_t) * minWordCount) <=> 0; + if (result != 0) return result; + } + + auto result = wordCount <=> bs.wordCount; + if (result < 0) + { + return AllZero(bs.words + minWordCount, bs.wordCount - minWordCount) ? std::strong_ordering::equal : std::strong_ordering::less; + } + else if (result > 0) + { + return AllZero(words + minWordCount, wordCount - minWordCount) ? std::strong_ordering::equal : std::strong_ordering::greater; + } + else + { + return result; + } + } + bool operator==(const BitSet& bs) const + { + return (*this <=> bs) == 0; + } + + bool operator[](vint index) const + { + vint wordIndex = index / 64; + vint bitIndex = index % 64; + if (wordIndex >= wordCount) + { + return false; + } + return (words[wordIndex] & (vuint64_t(1) << bitIndex)) != 0; + } + + void Set(vint index) + { + vint wordIndex = index / 64; + vint bitIndex = index % 64; + if (wordIndex >= wordCount) + { + vint oldWordCount = wordCount; + wordCount = wordIndex + 1; + vuint64_t* newWords = new vuint64_t[wordCount]; + memset(newWords, 0, sizeof(vuint64_t) * wordCount); + if (words) + { + memcpy(newWords, words, sizeof(vuint64_t) * oldWordCount); + delete[] words; + } + words = newWords; + } + words[wordIndex] |= (vuint64_t(1) << bitIndex); + } + + operator bool() const + { + return !AllZero(words, wordCount); + } + + BitSet operator|(const BitSet& bs) const + { + if (this == &bs) return *this; + BitSet result; + vint maxWordCount = wordCount > bs.wordCount ? wordCount : bs.wordCount; + if (maxWordCount > 0) + { + result.wordCount = maxWordCount; + result.words = new vuint64_t[maxWordCount]; + for (vint i = 0; i < maxWordCount; i++) + { + vuint64_t w1 = i < wordCount ? words[i] : 0; + vuint64_t w2 = i < bs.wordCount ? bs.words[i] : 0; + result.words[i] = w1 | w2; + } + } + return result; + } + + BitSet& operator|=(const BitSet& bs) + { + if (this == &bs) return *this; + *this = *this | bs; + return *this; + } + + BitSet operator&(const BitSet& bs) const + { + if (this == &bs) return *this; + BitSet result; + vint minWordCount = wordCount < bs.wordCount ? wordCount : bs.wordCount; + if (minWordCount > 0) + { + result.wordCount = minWordCount; + result.words = new vuint64_t[minWordCount]; + for (vint i = 0; i < minWordCount; i++) + { + result.words[i] = words[i] & bs.words[i]; + } + } + return result; + } + + BitSet& operator&=(const BitSet& bs) + { + if (this == &bs) return *this; + *this = *this & bs; + return *this; + } + + BitSet& operator-=(const BitSet& bs) + { + if (this == &bs) + { + *this = Zero; + } + else + { + vint minWordCount = wordCount < bs.wordCount ? wordCount : bs.wordCount; + for (vint i = 0; i < minWordCount; i++) + { + words[i] &= ~bs.words[i]; + } + } + return *this; + } + }; + + const BitSet BitSet::Zero; + +/*********************************************************************** +SyntaxSymbolManager::CreatePrefixMerge +***********************************************************************/ + + struct PrefixMergeCache + { + // prepared by CreatePrefixMergeCache + Array rules; + Array rulesByDeps; // if a begins with b, a is before b + Array directStartSetTokens, startSetTokens; + Array directStartSetRules, startSetRules, reverseStartSetRules; + }; + + Ptr SyntaxSymbolManager::CreatePrefixMergeCache() + { + auto cache = Ptr(new PrefixMergeCache); + CopyFrom(cache->rules, rules.map.Values()); + const vint ruleCount = cache->rules.Count(); + + cache->rulesByDeps.Resize(ruleCount); + cache->directStartSetTokens.Resize(ruleCount); + cache->startSetTokens.Resize(ruleCount); + cache->directStartSetRules.Resize(ruleCount); + cache->startSetRules.Resize(ruleCount); + cache->reverseStartSetRules.Resize(ruleCount); + for (auto [ruleSymbol, index] : indexed(cache->rules)) + { + ruleSymbol->pmRuleIndex = index; + } + + PartialOrderingProcessor pop; + { + Group deps; + for (auto ruleSymbol : cache->rules) + { + auto startState = ruleSymbol->startStates[0]; + BitSet directTokens, directRules; + for (auto edge : startState->OutEdges()) + { + switch (edge->input.type) + { + case EdgeInputType::Token: + directTokens.Set(edge->input.token); + break; + case EdgeInputType::Rule: + directRules.Set(edge->input.rule->pmRuleIndex); + deps.Add(ruleSymbol, edge->input.rule); + break; + default:; + } + } + cache->directStartSetTokens[ruleSymbol->pmRuleIndex] = directTokens; + cache->directStartSetRules[ruleSymbol->pmRuleIndex] = directRules; + } + pop.InitWithGroup(cache->rules, deps); + pop.Sort(); + } + + for (auto component : pop.components) + { + if (component.nodeCount > 1) + { + AddError( + ParserErrorType::RuleIsIndirectlyLeftRecursive, + {}, + From(Range(0, component.nodeCount)) + .Select([&](vint index) { return cache->rules[component.firstNode[index]]->Name(); }) + .OrderBySelf() + .Aggregate([](auto&& a, auto&& b) { return a + L", " + b; }) + ); + } + } + if (global.Errors().Count() > 0) return nullptr; + + for (auto [component, index] : indexed(pop.components)) + { + auto ruleSymbol = cache->rules[*component.firstNode]; + auto startSetTokens = cache->directStartSetTokens[ruleSymbol->pmRuleIndex]; + auto startSetRules = cache->directStartSetRules[ruleSymbol->pmRuleIndex]; + cache->rulesByDeps[ruleCount - 1 - index] = ruleSymbol; + + auto startState = ruleSymbol->startStates[0]; + for (auto edge : startState->OutEdges()) + { + if (edge->input.type != EdgeInputType::Rule) continue; + startSetTokens |= cache->startSetTokens[edge->input.rule->pmRuleIndex]; + startSetRules |= cache->startSetRules[edge->input.rule->pmRuleIndex]; + } + cache->startSetTokens[ruleSymbol->pmRuleIndex] = startSetTokens; + cache->startSetRules[ruleSymbol->pmRuleIndex] = startSetRules; + } + + for (vint i = 0; i < ruleCount; i++) + { + for (vint j = 0; j < ruleCount; j++) + { + if (cache->startSetRules[i][j]) + { + cache->reverseStartSetRules[j].Set(i); + } + } + } + + return cache; + } + +//#if defined VCZH_MSVC && defined _DEBUG +//#define LOG_DECISION_MAKING +//#define LOG console::Console::Write +//#define LOGL console::Console::WriteLine +//#endif + +/*********************************************************************** +SyntaxSymbolManager::PrefixMergeCrossReference_SolveInState +***********************************************************************/ + + void SyntaxSymbolManager::PrefixMergeCrossReference_SolveInState( + PrefixMergeCache * cache, + RuleSymbol * rule, + StateSymbol * currentState, + Ptr application) + { + /* + * To find out the minimum start set of rules to inject + * + * Stores startSetRules[edge->input.rule] to startSetEdges + * Try each rule in cache->rulesByDeps + * If startSetRules[rule] satisfies both conditions on each edge to merge + * startSetEdges[edge] & startSetRules[rule] == startSetRules[rule] + * startSetEdges[edge] & startSetRules[rule] == BitSet::Zero + * Then this rule is one in the minimum start set, update startSetEdges by: + * extract startSetRules[rule] + * extract any parent rule where startSetRules[parent rule] has rule + * Repeat until the test results in all BitSet::Zero (or when all startSetEdges are BitSet::Zero) + * + * We can see indirectStartSetRules as the relationship in a partial ordered graph starting from a rule + * When a rule is picked up as a prefix rule + * it removes the rule and all its descendants from the graph + * and we will have to break all node that depends on this prefix rule into multiple prefix rules + * so those parents will never be prefix rules + * after parent nodes are removed, the graph breaks into multiple sub graphs, maybe disconnected + * The goal is to pick up all smaller graphs that: + * they are big enough + * their leaf nodes do no intersect with each other + * leaf nodes of the current graph is covered by them + */ + +#define ERROR_MESSAGE_PREFIX L"vl::glr::parsergen::SyntaxSymbolManager::PrefixMergeCrossReference_SolveInState(PrefixMergeCache*, RuleSymbol*, StateSymbol*, Array&, List&, PrefixMergeSolutionMap&)#" + +#ifdef LOG_DECISION_MAKING + LOG(L" [GROUPED] :"); + for (auto [edge, index] : indexed(application->edgesToMerge)) + { + LOG(L" " + edge->input.rule->Name()); + } + LOGL(L""); +#endif + // prepare startSetEdges to be startSetRules of each edge's input rule + Array startSetEdges(application->edgesToMerge.Count()); + for (auto [edge, index] : indexed(application->edgesToMerge)) + { + startSetEdges[index] = cache->startSetRules[edge->input.rule->pmRuleIndex]; + startSetEdges[index].Set(edge->input.rule->pmRuleIndex); + } + + // at this moment, application->prefixRules are part of the solution that has already been picked u + if (application->prefixRules.Count() > 0) + { + for (auto prefixRule : application->prefixRules) + { + // take away all rules that depends or reversed depends on the prefix rule + auto startSetRule = cache->startSetRules[prefixRule->pmRuleIndex]; + startSetRule.Set(prefixRule->pmRuleIndex); + auto reverseStartSetRule = cache->reverseStartSetRules[prefixRule->pmRuleIndex]; + auto startSetToExtract = startSetRule | reverseStartSetRule; + + for (vint edgeIndex = 0; edgeIndex < application->edgesToMerge.Count(); edgeIndex++) + { + startSetEdges[edgeIndex] -= startSetToExtract; + } + } +#ifdef LOG_DECISION_MAKING + LOGL(L" [APPLIED REUSED]"); + for (auto [edge, index] : indexed(application->edgesToMerge)) + { + LOG(L" " + edge->input.rule->Name() + L" :"); + auto&& startSetEdge = startSetEdges[index]; + for (auto rule : cache->rulesByDeps) + { + if (startSetEdge[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); + } +#endif + // if startSetEdges become all empty, no more prefix rule will be found + bool allZero = true; + for (vint edgeIndex = 0; edgeIndex < application->edgesToMerge.Count(); edgeIndex++) + { + if (startSetEdges[edgeIndex] != BitSet::Zero) + { + allZero = false; break; } } + if (allZero) return; + } - if (competition) + { + FOUND_ONE_SOLUTION: +#ifdef LOG_DECISION_MAKING + LOGL(L" [ITERATION]"); + for (auto [edge, index] : indexed(application->edgesToMerge)) { - for (auto edge : state->OutEdges()) + LOG(L" " + edge->input.rule->Name() + L" :"); + auto&& startSetEdge = startSetEdges[index]; + for (auto rule : cache->rulesByDeps) { - edge->importancy = edge->important ? EdgeImportancy::HighPriority : EdgeImportancy::LowPriority; + if (startSetEdge[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); + } +#endif + + bool matchedOthers = false; + + // try each rule in dependency order + for (auto prefixRule : cache->rulesByDeps) + { + vint containedCount = 0; + vint exclusiveCount = 0; + vint otherCount = 0; + auto startSetRule = cache->startSetRules[prefixRule->pmRuleIndex]; + startSetRule.Set(prefixRule->pmRuleIndex); + + // compare the start set of this rule to remaining start set subset of each edge + // count each situation + for (vint edgeIndex = 0; edgeIndex < application->edgesToMerge.Count(); edgeIndex++) + { + auto& startSetEdge = startSetEdges[edgeIndex]; + auto matchResult = startSetEdge & startSetRule; + if (matchResult == startSetRule) + { + // startSetEdge contains startSetRule + containedCount++; + } + else if (matchResult == BitSet::Zero) + { + // startSetEdge does no intercept with startSetRule + exclusiveCount++; + } + else + { + // others + otherCount++; + break; + } + } + if (otherCount > 0) matchedOthers = true; + + // if some startSetEdge contains start set of the candidate rule + // and others are empty intersection + // we found a prefix rule + if (containedCount > 0 && otherCount == 0) + { + // take away all rules that depends or reversed depends on the prefix rule + auto reverseStartSetRule = cache->reverseStartSetRules[prefixRule->pmRuleIndex]; + auto startSetToExtract = startSetRule | reverseStartSetRule; + + for (vint edgeIndex = 0; edgeIndex < application->edgesToMerge.Count(); edgeIndex++) + { + startSetEdges[edgeIndex] -= startSetToExtract; + } + + application->prefixRules.Add(prefixRule); +#ifdef LOG_DECISION_MAKING + LOG(L" [FOUND " + prefixRule->Name() + L"] :"); + for (auto rule : cache->rulesByDeps) + { + if (startSetRule[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); +#endif + goto FOUND_ONE_SOLUTION; + } + } + + CHECK_ERROR(!matchedOthers, ERROR_MESSAGE_PREFIX L"Internal error: Unable to find a proper prefix merge solution."); + } + +#undef ERROR_MESSAGE_PREFIX + } + +/*********************************************************************** +SyntaxSymbolManager::PrefixMergeCrossReference_Solve +***********************************************************************/ + + void SyntaxSymbolManager::PrefixMergeCrossReference_Solve( + PrefixMergeCache* cache, + bool forStartState, + RuleSymbol* rule, + StateSymbol* startState, + PrefixMergeSolutionMap& prefixMergeSolutions) + { + auto logCache = [&]() + { +#ifdef LOG_DECISION_MAKING + if (prefixMergeSolutions.Count() == 0) + { + LOGL(L"[CACHE]"); + LOGL(L" [RULES]"); + for (auto rule : cache->rulesByDeps) + { + LOG(L" " + rule->Name() + L" :"); + auto&& startSetRule = cache->directStartSetRules[rule->pmRuleIndex]; + for (auto rule : cache->rulesByDeps) + { + if (startSetRule[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); + } + LOGL(L" [START SET]"); + for (auto rule : cache->rulesByDeps) + { + LOG(L" " + rule->Name() + L" :"); + auto&& startSetRule = cache->startSetRules[rule->pmRuleIndex]; + for (auto rule : cache->rulesByDeps) + { + if (startSetRule[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); + } + LOGL(L" [REVERSED]"); + for (auto rule : cache->rulesByDeps) + { + LOG(L" " + rule->Name() + L" :"); + auto&& startSetRule = cache->reverseStartSetRules[rule->pmRuleIndex]; + for (auto rule : cache->rulesByDeps) + { + if (startSetRule[rule->pmRuleIndex]) LOG(L" " + rule->Name()); + } + LOGL(L""); + } + LOGL(L""); + } +#endif + }; + + /* + * If forStartState is true, only process the start state, otherwise process all reachable states except the start state + * forStartState == true will be applied all rules in start set dependency order first + * therefore whenever we see a rule input edge, its (rule, startState) should already have a solution + * + * When making a solution, if any Rule input edge already have a solution, reuse it + * Find edges whose start set have intersection, process each group + * Merge all solutions into one + * + * There are multiple applications in a solution + * Each application records what prefix rules will be injected into what edges + * For group that has only one edge, there will be no application + * + * For any start state, a solution will be created when there are groups with multiple edges, or any edge whose input rule has a solution on its start state + * For any other state, a solution will be created only when there are groups with multiple edges + */ + +#define ERROR_MESSAGE_PREFIX L"vl::glr::parsergen::SyntaxSymbolManager::PrefixMergeCrossReference_Solve(PrefixMergeCache*, RuleSymbol*, StateSymbol*, PrefixMergeSolutionMap&)#" + SortedList visitedStates; + List workingStates; + workingStates.Add(startState); + + // Traverse all states + for (vint i = 0; i < workingStates.Count(); i++) + { + auto currentState = workingStates[i]; + + if (forStartState == (currentState == startState)) + { + Group biDeps; + + // Group all edges that have intersection in start set + for (vint j = 0; j < currentState->OutEdges().Count() - 1; j++) + { + auto edge1 = currentState->OutEdges()[j]; + if (edge1->input.type != EdgeInputType::Rule) continue; + auto tokens1 = cache->startSetTokens[edge1->input.rule->pmRuleIndex]; + auto rules1 = cache->startSetRules[edge1->input.rule->pmRuleIndex]; + rules1.Set(edge1->input.rule->pmRuleIndex); + + for (vint k = j + 1; k < currentState->OutEdges().Count(); k++) + { + auto edge2 = currentState->OutEdges()[k]; + if (edge2->input.type != EdgeInputType::Rule) continue; + auto tokens2 = cache->startSetTokens[edge2->input.rule->pmRuleIndex]; + auto rules2 = cache->startSetRules[edge2->input.rule->pmRuleIndex]; + rules2.Set(edge2->input.rule->pmRuleIndex); + + CHECK_ERROR(edge1->input.rule != edge2->input.rule, ERROR_MESSAGE_PREFIX L"Internal error: Two edges from the same state should not consume the same rule, this should have been eliminated by MergeEdgesWithSameRuleUsingLeftrec."); + if (!(tokens1 & tokens2)) continue; + if (!(rules1 & rules2)) continue; + + biDeps.Add(edge1, edge2); + biDeps.Add(edge2, edge1); + } + } + + PartialOrderingProcessor pop; + pop.InitWithGroup(currentState->OutEdges(), biDeps); + pop.Sort(); + + // Find if a solution needs to be created for the current state + bool hasSolution = false; + for (auto component : pop.components) + { + if (component.nodeCount > 1) + { + // if there is a group with multiple edges, yes + hasSolution = true; + break; + } + else if (currentState == startState) + { + // if the input rule has a solution on its start state, and the current state is the start state, yes + auto edge = currentState->OutEdges()[*component.firstNode]; + if (edge->input.type == EdgeInputType::Rule) + { + auto prefixRule = edge->input.rule; + if (prefixMergeSolutions.Keys().Contains({ prefixRule, prefixRule->startStates[0] })) + { + hasSolution = true; + break; + } + } + } + } + + // skip the current state if no solution is needed + // edges are grouped by start set intersections + // so whenever a rule input has a solution on its start state or not + // the rule or its solution will never conflict with other groups + // since the solution will be a subset of union of all start sets for the group + if (hasSolution) + { + logCache(); +#ifdef LOG_DECISION_MAKING + LOGL(L"[PMCR] " + rule->Name() + L" @ " + currentState->label); +#endif + // Check all groups with single edge + auto solution = Ptr(new PrefixMergeSolutionValue); + for (auto component : pop.components) + { + if (component.nodeCount == 1) + { + auto edge = currentState->OutEdges()[*component.firstNode]; + if (edge->input.type == EdgeInputType::Rule) + { + auto prefixRule = edge->input.rule; + vint solutionIndex = prefixMergeSolutions.Keys().IndexOf({ prefixRule, prefixRule->startStates[0] }); + if (solutionIndex == -1) + { +#ifdef LOG_DECISION_MAKING + LOGL(L" [SINGLE] " + prefixRule->Name()); +#endif + // if the input rule has no solution on its start state + // but the current state needs a solution + // then the input rule is a prefix + solution->prefixRules.Add(prefixRule); + } + else + { +#ifdef LOG_DECISION_MAKING + LOGL(L" [SINGLE USED] " + prefixRule->Name()); +#endif + // otherwise, copy all prefix rules + CopyFrom(solution->prefixRules, prefixMergeSolutions.Values()[solutionIndex]->prefixRules, true); + } + } + } + } + + // Check all groups with multiple edges, applications will be created on these groups + for (auto component : pop.components) + { + if (component.nodeCount > 1) + { + // collect all existing solutions for each edge + auto application = Ptr(new PrefixMergeSolutionApplication); + application->edgesToMerge.Resize(component.nodeCount); + for (vint j = 0; j < component.nodeCount; j++) + { + application->edgesToMerge[j] = currentState->OutEdges()[component.firstNode[j]]; + } + for (auto edge : application->edgesToMerge) + { + auto prefixRule = edge->input.rule; + vint solutionIndex = prefixMergeSolutions.Keys().IndexOf({ prefixRule, prefixRule->startStates[0] }); + if (solutionIndex != -1) + { +#ifdef LOG_DECISION_MAKING + LOGL(L" [SINGLE USED] " + prefixRule->Name()); +#endif + // copy all prefix rules, ensure no duplication + for (auto prefixRule : prefixMergeSolutions.Values()[solutionIndex]->prefixRules) + { + if (!application->prefixRules.Contains(prefixRule)) + { + application->prefixRules.Add(prefixRule); + } + } + } + } + + // solve for the current group + PrefixMergeCrossReference_SolveInState(cache, rule, currentState, application); + + // copy all prefix rules, ensure no duplication + solution->applications.Add(application); + for (auto prefixRule : application->prefixRules) + { + if (!solution->prefixRules.Contains(prefixRule)) + { + solution->prefixRules.Add(prefixRule); + } + } + } + } + prefixMergeSolutions.Add({ rule, currentState }, solution); + +#ifdef LOG_DECISION_MAKING + LOG(L" [MATCHED] :"); + for (auto rule : solution->prefixRules) + { + LOG(L" " + rule->Name()); + } + LOGL(L""); + LOGL(L""); +#endif + } + } + + // continue if required + if (!forStartState) + { + for (auto edge : currentState->OutEdges()) + { + if (!visitedStates.Contains(edge->To())) + { + visitedStates.Add(edge->To()); + workingStates.Add(edge->To()); + } } } } +#undef ERROR_MESSAGE_PREFIX } + + void SyntaxSymbolManager::PrefixMergeCrossReference_Solve(PrefixMergeCache* cache, PrefixMergeSolutionMap& prefixMergeSolutions) + { + for (auto rule : From(cache->rulesByDeps).Reverse()) + { + PrefixMergeCrossReference_Solve(cache, true, rule, rule->startStates[0], prefixMergeSolutions); + } + for (auto rule : From(cache->rulesByDeps).Reverse()) + { + PrefixMergeCrossReference_Solve(cache, false, rule, rule->startStates[0], prefixMergeSolutions); + } + } + +/*********************************************************************** +SyntaxSymbolManager::PrefixMergeCrossReference_AccumulatedEdges +***********************************************************************/ + + struct PrefixMergeApplicationItems + { + using EdgeList = List; + using EdgeListPtr = Ptr; + using RuleToEdgesMap = Group; + using TokenToEdgesMap = Group>, EdgeListPtr>; + + BitSet coveredRules; + RuleToEdgesMap ruleToEdges; + TokenToEdgesMap tokenToEdges; + }; + + EdgeSymbol* SyntaxSymbolManager::PrefixMergeCrossReference_AccumulatedEdges(StateSymbol* fromState, const WString& pmLabel, const collections::List& accumulatedEdgesList, IncrementalChange& ic) + { + auto IsSingleReuseEdge = [](EdgeSymbol* edge) + { + if (edge->input.type != EdgeInputType::Rule) return false; + if (edge->input.ruleType != automaton::ReturnRuleType::Reuse) return false; + if (edge->competitions.Count() != 0) return false; + + vint edgeIns = edge->insAfterInput.Count(); + if (edgeIns >= 2) return false; + if (edgeIns == 1 && edge->insAfterInput[0].type != AstInsType::StackBegin) return false; + + auto targetState = edge->To(); + List endingEdges; + CopyFrom(endingEdges, From(targetState->OutEdges()).Where([](EdgeSymbol* e) + { + return e->input.type == EdgeInputType::Ending; + })); + if (endingEdges.Count() != 1) return false; + + auto endingEdge = endingEdges[0]; + if (endingEdge->input.type != EdgeInputType::Ending) return false; + + if (edgeIns == 0) + { + if (endingEdge->insAfterInput.Count() != 2) return false; + if (endingEdge->insAfterInput[0].type != AstInsType::StackBegin) return false; + if (endingEdge->insAfterInput[1].type != AstInsType::StackEnd) return false; + } + else + { + if (endingEdge->insAfterInput.Count() != 1) return false; + if (endingEdge->insAfterInput[0].type != AstInsType::StackEnd) return false; + } + return true; + }; + + Array accumulatedSizes(accumulatedEdgesList.Count()); + for (auto [edges, index] : indexed(accumulatedEdgesList)) + { + auto&& edgeList = *edges.Obj(); + accumulatedSizes[index] = 0; + for (vint i = edgeList.Count(); i > 0; i--) + { + auto edge = edgeList[i - 1]; + if (!IsSingleReuseEdge(edge)) + { + accumulatedSizes[index] = i; + break; + } + } + } + + // newState labeling [pm-cr] is made if there are multiple choices + auto newState = Ptr(new StateSymbol(fromState->Rule())); + ic.createdStates.Add(newState); + newState->label = fromState->label + pmLabel; + + // newEdge to connect fromState to newState + auto newEdge = Ptr(new EdgeSymbol(fromState, newState.Obj())); + ic.createdEdges.Add(newEdge); + + SortedList contStateLabels; + Group, EdgeSymbol*> createdContEdges; + for (auto [edges, index] : indexed(accumulatedEdgesList)) + { +#ifdef LOG_DECISION_MAKING + LOG(L" "); + for (auto [edge, edgeIndex] : indexed(*edges.Obj())) + { + if (edgeIndex > 0) LOG(L" -> "); + if (edgeIndex == accumulatedSizes[index]) + { + LOG(L"| "); + } + if (edge->input.type == EdgeInputType::Rule) + { + LOG(edge->input.rule->Name()); + } + else + { + LOG(L"[TOKEN] " + (edge->input.condition ? edge->input.condition.Value() : itow(edge->input.token))); + } + } + LOGL(L""); +#endif + auto&& edgeList = *edges.Obj(); + vint accSize = accumulatedSizes[index]; + for (vint i = edgeList.Count(); i >= accSize && i > 0; i--) + { + auto lastEdge = edgeList[i - 1]; + + Ptr contState; + auto lastState = lastEdge->To(); + for (auto contEdge : lastState->OutEdges()) + { + if (contEdge->input.type == EdgeInputType::PrefixMergeDiscardedRule) + { + continue; + } + + if (contEdge->input.type == EdgeInputType::LeftRec) + { + if (contEdge->returnEdges.Count() == 0); + else continue; + } + + if (contEdge->input.type == EdgeInputType::Ending) + { + if (accSize == 0 && i == 1); + else if (i == accSize); + else continue; + } + + auto AddNewContEdge = [&](StateSymbol* contFromState, bool useLastEdgeContent, bool useReturnEdges) + { + auto newContEdge = Ptr(new EdgeSymbol(contFromState, contEdge->To())); + + newContEdge->input = contEdge->input; + if (useLastEdgeContent) + { + CopyFrom(newContEdge->competitions, lastEdge->competitions, true); + CopyFrom(newContEdge->insAfterInput, lastEdge->insAfterInput, true); + } + CopyFrom(newContEdge->competitions, contEdge->competitions, true); + CopyFrom(newContEdge->insAfterInput, contEdge->insAfterInput, true); + + if (useReturnEdges) + { + for (vint j = 0; j < i - 1; j++) + { + newContEdge->returnEdges.Add(edgeList[j]); + } + } + + auto key = Pair(newContEdge->From(), newContEdge->To()); + vint index = createdContEdges.Keys().IndexOf(key); + if (index != -1) + { + for (auto created : createdContEdges.GetByIndex(index)) + { + if (created->input != newContEdge->input) continue; + if (CompareEnumerable(created->competitions, newContEdge->competitions) != 0) continue; + if (CompareEnumerable(created->insAfterInput, newContEdge->insAfterInput) != 0) continue; + if (CompareEnumerable(created->returnEdges, newContEdge->returnEdges) != 0) continue; + + newContEdge->From()->outEdges.Remove(newContEdge.Obj()); + newContEdge->To()->inEdges.Remove(newContEdge.Obj()); + return; + } + } + + createdContEdges.Add(key, newContEdge.Obj()); + ic.createdEdges.Add(newContEdge); + }; + + if (i == 1 && contEdge->input.type != EdgeInputType::Rule) + { + AddNewContEdge(newState.Obj(), true, false); + continue; + } + + if (contEdge->input.type == EdgeInputType::LeftRec) + { + AddNewContEdge(newState.Obj(), true, true); + continue; + } + + if (!contState) + { + auto label = fromState->label + pmLabel; + for (vint j = 0; j < i; j++) + { + auto&& input = edgeList[j]->input; + if (input.type == EdgeInputType::Rule) + { + label += L" " + input.rule->Name(); + } + else + { + label += L" [TOKEN] " + (input.condition ? input.condition.Value() : itow(input.token)); + } + } + if (contStateLabels.Contains(label)) continue; + contStateLabels.Add(label); + + contState = Ptr(new StateSymbol(fromState->Rule())); + ic.createdStates.Add(contState); + contState->label = label; + + auto lrEdge = Ptr(new EdgeSymbol(newState.Obj(), contState.Obj())); + ic.createdEdges.Add(lrEdge); + + lrEdge->input.type = EdgeInputType::LeftRec; + CopyFrom(lrEdge->competitions, lastEdge->competitions, true); + for (vint j = 0; j < i - 1; j++) + { + lrEdge->returnEdges.Add(edgeList[j]); + } + CopyFrom(lrEdge->insAfterInput, lastEdge->insAfterInput, true); + } + + { + AddNewContEdge(contState.Obj(), false, false); + } + } + } + } + + return newEdge.Obj(); + } + +/*********************************************************************** +SyntaxSymbolManager::PrefixMergeCrossReference_Apply +***********************************************************************/ + + void SyntaxSymbolManager::PrefixMergeCrossReference_Apply(PrefixMergeCache* cache, collections::List& accumulatedEdges, PrefixMergeApplicationItems& pmai) + { + auto lastEdge = accumulatedEdges[accumulatedEdges.Count() - 1]; + auto lastRule = lastEdge->input.rule; + + if (pmai.coveredRules[lastRule->pmRuleIndex]) + { + auto edges = Ptr(new List); + CopyFrom(*edges.Obj(), accumulatedEdges); + pmai.ruleToEdges.Add(lastRule, edges); + } + else + { + for (auto edge : lastRule->startStates[0]->OutEdges()) + { + switch (edge->input.type) + { + case EdgeInputType::Rule: + // RuleIsIndirectlyLeftRecursive has been checked so there will be no deadloop + accumulatedEdges.Add(edge); + PrefixMergeCrossReference_Apply(cache, accumulatedEdges, pmai); + accumulatedEdges.RemoveAt(accumulatedEdges.Count() - 1); + break; + case EdgeInputType::Token: + { + auto edges = Ptr(new List); + CopyFrom(*edges.Obj(), accumulatedEdges); + edges->Add(edge); + pmai.tokenToEdges.Add({ edge->input.token, edge->input.condition }, edges); + } + break; + default:; + } + } + } + + } + + void SyntaxSymbolManager::PrefixMergeCrossReference_Apply(PrefixMergeCache* cache, RuleSymbol* rule, StateSymbol* currentState, Ptr solution, IncrementalChange& ic) + { + /* + * For any state A whose prefix calls look like: + * A -> r1 -> ... rn -> (u1, v1, ...) + * A -> s1 -> ... sn -> (u1, v1, ...) + * The same (u1, v1, ...) will be merged. + * Especially when A indirectly reuses (u1, v1, ...), this approach removes duplicated ambiguous results. + * by not doing this, it produces two duplicated A -> (different paths) -> (u1, v1, ...) + * and parsing efforts are wasted if (u1, v1, ...) costs a large number of transitions + * + * Because a prefix will be produced and then passed into its parent rule like this: + * {CreateObject(u1)} ... {StackSlot(0), CreateObject(r1)} {StackSlot(0), CreateObject(A)} + * we can parse (u1, v1, ...) first, and then patch multiple EndingInput transitions directly into (rn, sn) + * such EndingInput transition will have non-empty returnEdges + * + * (u1, v1, ...) are not required to be reuse clauses which only contain one rule + * as even if they are, they may be followed by LeftRec transitions, it doesn't make the work simpler, but even more checking + * recursive cross-reference merges will not be implemented at the moment + * treat it as a special case which only merge prefixes in the size of one rule + * + * PrefixMergeCrossReference_Solve worked out how many transitions need to be reworked + * e.g. (a start set graph, assuming left nodes are selected prefix rules) + * +-> r2 .. + * | +-> r4 .. + * A -> r1 -+-> r3 -+-> r5 .. + * | + * +-> r6.. + * when r4 merges, (r2, r5, r6) will need similar edges to start from A: + * A -+- r4 (injects into r3) + * +- r5 (injects into r3) + * +- r2 (injects into r1) + * +- r6 (injects into r1) + */ + + for (auto application : solution->applications) + { + PrefixMergeApplicationItems pmai; + for (auto prefixRule : application->prefixRules) + { + pmai.coveredRules.Set(prefixRule->pmRuleIndex); + } + + List accumulatedEdges; + for (auto edge : application->edgesToMerge) + { + accumulatedEdges.Add(edge); + PrefixMergeCrossReference_Apply(cache, accumulatedEdges, pmai); + accumulatedEdges.RemoveAt(accumulatedEdges.Count() - 1); + } + +#ifdef LOG_DECISION_MAKING + LOGL(L"[PMAI] " + rule->Name() + L" @ " + currentState->label); +#endif + for (vint i = 0; i < pmai.ruleToEdges.Count(); i++) + { + auto pmRule = pmai.ruleToEdges.Keys()[i]; +#ifdef LOG_DECISION_MAKING + LOGL(L" [RULE] " + pmRule->Name() + L" :"); +#endif + auto&& accumulatedEdgesList = pmai.ruleToEdges.GetByIndex(i); + auto newEdge = PrefixMergeCrossReference_AccumulatedEdges(currentState, (L"[pm-cr-rule: " + pmRule->Name() + L"]"), accumulatedEdgesList, ic); + newEdge->input.type = EdgeInputType::PrefixMergeRule; + newEdge->input.rule = pmRule; + } + for (vint i = 0; i < pmai.tokenToEdges.Count(); i++) + { + auto [pmToken, condition] = pmai.tokenToEdges.Keys()[i]; +#ifdef LOG_DECISION_MAKING + LOGL(L" [TOKEN] " + (condition ? condition.Value() : itow(pmToken))); +#endif + auto&& accumulatedEdgesList = pmai.tokenToEdges.GetByIndex(i); + auto newEdge = PrefixMergeCrossReference_AccumulatedEdges(currentState, (L"[pm-cr-token: " + (condition ? condition.Value() : itow(pmToken)) + L"]"), accumulatedEdgesList, ic); + newEdge->input.type = EdgeInputType::Token; + newEdge->input.token = pmToken; + newEdge->input.condition = condition; + } +#ifdef LOG_DECISION_MAKING + LOGL(L""); +#endif + } + } + +#ifdef LOG_DECISION_MAKING +#undef LOG_DECISION_MAKING +#undef LOG +#undef LOGL +#endif } } } @@ -17872,48 +15843,40 @@ SyntaxSymbolManager::FixCrossReferencedRuleEdge switch (edge->input.type) { case EdgeInputType::Token: - case EdgeInputType::LrPlaceholder: - // multiple Rule edges followed by one Token or LrPlaceholder edge create a cross-referenced edge - if (edge->returnEdges.Count() == 0) { + // Cannot call CreateEdge here because it is checked as a public API + // But during NFA building we should still change the automaton auto newEdge = Ptr(new EdgeSymbol(startState, edge->To())); edges.Add(newEdge); + // Either prefix-merged or cross-referenced Token transition may have non-empty returnEdges + // There is no way to tell if a token is cross-referenced, which should be ignored during accumulation + // So we use CrossReferencedToken here and later renamed everything back to Token newEdge->input = edge->input; - newEdge->importancy = edge->importancy; + newEdge->input.type = EdgeInputType::CrossReferencedToken; + CopyFrom(newEdge->competitions, edge->competitions, true); for (auto acc : accumulatedEdges) { - CopyFrom(newEdge->insBeforeInput, acc->insBeforeInput, true); + CopyFrom(newEdge->returnEdges, acc->returnEdges, true); newEdge->returnEdges.Add(acc); } - CopyFrom(newEdge->insBeforeInput, edge->insBeforeInput, true); CopyFrom(newEdge->insAfterInput, edge->insAfterInput, true); } break; case EdgeInputType::Rule: - if (accumulatedEdges.Contains(edge)) - { - AddError( - ParserErrorType::RuleIsIndirectlyLeftRecursive, - {}, - edge->input.rule->Name() - ); - } - else - { - accumulatedEdges.Add(edge); - FixCrossReferencedRuleEdge(startState, orderedEdges, accumulatedEdges); - accumulatedEdges.RemoveAt(accumulatedEdges.Count() - 1); - } + // RuleIsIndirectlyLeftRecursive has been checked so there will be no deadloop + accumulatedEdges.Add(edge); + FixCrossReferencedRuleEdge(startState, orderedEdges, accumulatedEdges); + accumulatedEdges.RemoveAt(accumulatedEdges.Count() - 1); break; case EdgeInputType::Epsilon: - case EdgeInputType::Ending: case EdgeInputType::LeftRec: - // Epsilon edges do not exist in compact-NFA - // Ending and LeftRec edges are not involved - break; - case EdgeInputType::LrInject: - CHECK_FAIL(L"LrInject is impossible from a start state"); + case EdgeInputType::PrefixMergeDiscardedRule: + // These edges are not involved + case EdgeInputType::Ending: + case EdgeInputType::PrefixMergeRule: + case EdgeInputType::CrossReferencedToken: + // These edges do not exist in compact-NFA break; default: CHECK_FAIL(L"Unhandled!"); @@ -17921,400 +15884,6 @@ SyntaxSymbolManager::FixCrossReferencedRuleEdge } } -/*********************************************************************** -SyntaxSymbolManager::FixLeftRecursionInjectEdge -***********************************************************************/ - - void SyntaxSymbolManager::FixLeftRecursionInjectEdge(StateSymbol* startState, EdgeSymbol* injectEdge) - { -#define ERROR_MESSAGE_PREFIX L"vl::glr::parsergen::SyntaxSymbolManager::FixLeftRecursionInjectEdge(StateSymbol*, EdgeSymbol*)#" - // search for all qualified placeholder edge starts from inject targets - List placeholderEdges; - for (auto outEdge : startState->OutEdges()) - { - if (outEdge->input.type == EdgeInputType::LrPlaceholder) - { - if (!From(outEdge->input.flags).Intersect(injectEdge->input.flags).IsEmpty()) - { - placeholderEdges.Add(outEdge); - } - } - } - - // calculate all return edges and ending states for each placeholder edge - // return edges: - // injectEdge - // return edge begins from inject target - // ... - // return edge begins from most inner rule that contains placeholder - // ending states: - // to state of return edge begins from inject target - // ... - // to state of return edge begins from most inner rule that contains placeholder - // to state from placeholder edge - Array> endingStatesArray(placeholderEdges.Count()); - Array> returnEdgesArray(placeholderEdges.Count()); - for(auto [placeholderEdge, index] : indexed(placeholderEdges)) - { - auto& endingStates = endingStatesArray[index]; - auto& returnEdges = returnEdgesArray[index]; - - // check if placeholderEdge does nothing more than using rules - if (placeholderEdge->insAfterInput.Count() > 0) - { - // EdgeInputType::LrPlaceholder is created from a left_recursion_placeholder clause - // This is ensured by the semantic - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Internal error: EdgeInputType::LrPlaceholder edge should have empty insAfterInput."); - } - - for (vint i = 0; i <= placeholderEdge->returnEdges.Count(); i++) - { - auto returnEdge = - i == 0 - ? injectEdge - : placeholderEdge->returnEdges[i - 1] - ; - auto endingState = - i == placeholderEdge->returnEdges.Count() - ? placeholderEdge->To() - : placeholderEdge->returnEdges[i]->To() - ; - - for (auto outEdge : endingState->OutEdges()) - { - if (outEdge->input.type == EdgeInputType::Ending && outEdge->insAfterInput.Count() > 0) - { - // EdgeInputType::Ending is created from accumulating multiple EdgeInputType::Epsilon edges leading to an ending state - // EdgeInputType::Epsilon always have empty insAfterInput - CHECK_FAIL(ERROR_MESSAGE_PREFIX L"Internal error: EdgeInputType::Ending edge should have empty insAfterInput."); - } - } - - returnEdges.Add(returnEdge); - endingStates.Add(endingState); - } - } - - // calculate all acceptable Token input from inject edge - // key: - // token - // the number of return edges carried into this edge, at least 1 - // value: - // index of placeholder edge - // the LeftRec edge before the Token edge (optional) - // the Token edge that consume this input - using InputKey = Pair; - using InputValue = Tuple; - Group acceptableInputs; - - // calculate all acceptable Ending input from inject edge - // value: - // index of placeholder edge - // the additional Ending edge - using EndingInputValue = Pair; - List acceptableEndingInputs; - - for(auto [placeholderEdge, index] : indexed(placeholderEdges)) - { - auto& endingStates = endingStatesArray[index]; - auto& returnEdges = returnEdgesArray[index]; - - // TODO: (enumerable) foreach:indexed(reversed) - for (vint i = returnEdges.Count() - 1; i >= 0; i--) - { - auto endingState = endingStates[i]; - auto returnEdge = returnEdges[i]; - EdgeSymbol* endingEdge = nullptr; - - for (auto outEdge : endingState->OutEdges()) - { - switch (outEdge->input.type) - { - case EdgeInputType::Ending: - endingEdge = outEdge; - if (returnEdge == injectEdge) - { - // all possible Ending input are comsumed - // an ending edge should be created if - // the injection edge cannot be skipped - // the injection edge to state has Ending input - // an optional injection can be skipped - // a non-optional injection can be skipped by surrounding syntax - - auto endingEdgeAfterInject = From(injectEdge->To()->OutEdges()) - .Where([](auto edge) { return edge->input.type == EdgeInputType::Ending; }) - .First(nullptr); - if (endingEdgeAfterInject) - { - // find if there is a state in the same rule that looks like: - // +-------------------(ending)---------------------+ - // | | - // S -+ +->E - // | | - // +-{-(leftrec)-> X} -(lri:ThisEdge)-> T -(ending)-+ - // or - // +-(same rule)-> Y -----------------(ending)------------------+ - // | | - // S -+ +->E - // | | - // +-(same rule)-{-(leftrec)-> X} -(lri:ThisEdge)-> T -(ending)-+ - - List visiting; - SortedList visited; - visiting.Add(injectEdge->From()); - - // TODO: (enumerable) visiting/visited - for (vint i = 0; i < visiting.Count(); i++) - { - auto visitingState = visiting[i]; - if (visited.Contains(visitingState)) continue; - visited.Add(visitingState); - - for (auto siblingEdge : visitingState->OutEdges()) - { - if (siblingEdge->input.type == EdgeInputType::Ending) - { - goto SKIP_SEARCHING; - } - } - - for (auto commingEdge : visitingState->InEdges()) - { - if (commingEdge->From()->Rule() != injectEdge->From()->Rule()) continue; - - switch (commingEdge->input.type) - { - case EdgeInputType::LeftRec: - visiting.Add(commingEdge->From()); - break; - case EdgeInputType::Rule: - { - auto expectedReturnRule = commingEdge->input.rule; - for (auto siblingCommingEdge : commingEdge->From()->OutEdges()) - { - if (siblingCommingEdge == commingEdge) continue; - if (siblingCommingEdge->input.type != EdgeInputType::Rule) continue; - if (siblingCommingEdge->input.rule != expectedReturnRule) continue; - - if (!From(siblingCommingEdge->To()->OutEdges()) - .Where([](auto edge) { return edge->input.type == EdgeInputType::Ending; }) - .IsEmpty()) - { - goto SKIP_SEARCHING; - } - } - } - break; - default:; - } - } - } - - { - // if there is no such state - // an Ending edge is needed - acceptableEndingInputs.Add({ index,endingEdgeAfterInject }); - } - SKIP_SEARCHING:; - } - } - break; - // find if there is any LeftRec from this state - case EdgeInputType::LeftRec: - { - // compact everything on top of this LeftRec and create an Input - for (auto tokenEdge : outEdge->To()->OutEdges()) - { - if (tokenEdge->input.type == EdgeInputType::Token) - { - acceptableInputs.Add({ tokenEdge->input.token,i + 1 }, { index,outEdge,tokenEdge }); - } - } - } - break; - // find if there is any Token from this state - case EdgeInputType::Token: - acceptableInputs.Add({ outEdge->input.token,i + 1 }, { index,nullptr,outEdge }); - break; - default:; - } - } - - if (!endingEdge) - { - // stop searching if there is no Ending input - // since there will be no more {Ending} Token edge to compact - break; - } - } - } - - auto prepareLriEdgeInstructions = [&](vint placeholderIndex, vint returnEdgeCount, List& instructionPrefix) - { - auto placeholderEdge = placeholderEdges[placeholderIndex]; - auto& endingStates = endingStatesArray[placeholderIndex]; - auto& returnEdges = returnEdgesArray[placeholderIndex]; - - // search for all possible "LrPlaceholder {Ending} LeftRec Token" transitions - // for each transition, compact edges and put injectEdge properly in returnEdges - // here insBeforeInput has been ensured to be: - // EndObject - // LriStore - // DelayFieldAssignment - // placeholderEdge->insBeforeInput - // LriFetch - // loop {endingEdge->insBeforeInput returnEdge->insAfterInput} - // --LeftRec--> ... - - // EndObject is for the ReopenObject in the use rule transition before - // DelayFieldAssignment is for the ReopenObject in injectEdge->insAfterInput - // injectEdge is the last returnEdge - - // there is no instruction in injectEdge->insBeforeInput - instructionPrefix.Add({ AstInsType::EndObject }); - instructionPrefix.Add({ AstInsType::LriStore }); - instructionPrefix.Add({ AstInsType::DelayFieldAssignment }); - CopyFrom(instructionPrefix, placeholderEdge->insBeforeInput, true); - instructionPrefix.Add({ AstInsType::LriFetch }); - - // TODO: (enumerable) foreach:reversed - for (vint i = returnEdges.Count() - 1; i >= returnEdgeCount; i--) - { - auto endingState = endingStates[i]; - auto returnEdge = returnEdges[i]; - auto endingEdge = From(endingState->OutEdges()) - .Where([](auto edge) { return edge->input.type == EdgeInputType::Ending; }) - .First(); - - CopyFrom(instructionPrefix, endingEdge->insBeforeInput, true); - CopyFrom(instructionPrefix, returnEdge->insAfterInput, true); - } - }; - - for (auto [placeholderIndex, endingEdgeAfterInject] : acceptableEndingInputs) - { - auto newEdge = Ptr(new EdgeSymbol(injectEdge->From(), endingEdgeAfterInject->To())); - edges.Add(newEdge); - newEdge->input = endingEdgeAfterInject->input; - newEdge->importancy = endingEdgeAfterInject->importancy; - - prepareLriEdgeInstructions(placeholderIndex, 0, newEdge->insBeforeInput); - CopyFrom(newEdge->insBeforeInput, endingEdgeAfterInject->insBeforeInput, true); - CopyFrom(newEdge->insBeforeInput, endingEdgeAfterInject->insAfterInput, true); - } - - // TODO: (enumerable) foreach on group - for (auto [input, inputIndex] : indexed(acceptableInputs.Keys())) - { - auto [inputToken, returnEdgeCount] = input; - auto&& placeholderRecords = acceptableInputs.GetByIndex(inputIndex); - - // group inputs by lrEdge, tokenEdge, carried return edges - // if there are multiple inputs from the same key - // it means such input creates an ambiguity - // - // it usually happens in clauses like Prefix lri(flags) Target - // where multiple valid flags found in Target at the same time - // - // if we could indentify some inputs here where excluded return edges are all reuse edges - // then we can only create edges for one of them - - struct Entry - { - EdgeSymbol* lrEdge; - EdgeSymbol* tokenEdge; - List* returnEdges; - vint returnEdgeCount; - - std::strong_ordering operator<=>(const Entry& entry)const - { - std::strong_ordering - result = lrEdge <=> entry.lrEdge; if (result != 0) return result; - result = tokenEdge <=> entry.tokenEdge; if (result != 0) return result; - return CompareEnumerable( - From(*returnEdges).Take(returnEdgeCount), - From(*entry.returnEdges).Take(returnEdgeCount) - ); - } - - bool operator==(const Entry& entry) const { return (*this <=> entry) == 0; } - }; - Group simpleUseRecords; - - // search for placeholder edges where their excluded return edges are all reuse edges - // TODO: (enumerable) foreach on group - for (vint recordIndex = 0; recordIndex < placeholderRecords.Count(); recordIndex++) - { - auto [placeholderIndex, lrEdge, tokenEdge] = placeholderRecords[recordIndex]; - Entry entry{ lrEdge,tokenEdge,&returnEdgesArray[placeholderIndex],returnEdgeCount }; - if(From(*entry.returnEdges) - .Skip(returnEdgeCount) - .All([](EdgeSymbol* edge) {return edge->input.ruleType == automaton::ReturnRuleType::Reuse; }) - ) - { - simpleUseRecords.Add(entry, recordIndex); - } - } - - // for each group, if there are more than one placeholder edges - // mark them as deleted except the first one - SortedList recordsToRemove; - // TODO: (enumerable) foreach on group - for (vint recordGroup = 0; recordGroup < simpleUseRecords.Count(); recordGroup++) - { - auto&& records = simpleUseRecords.GetByIndex(recordGroup); - if (records.Count() > 1) - { - CopyFrom(recordsToRemove, From(records).Skip(1)); - } - } - - // delete them in Group - // this way is not recommended but the group is going to be discarded very soon - // TODO: (enumerable) foreach:reversed - for (vint i = recordsToRemove.Count() - 1; i >= 0; i--) - { - const_cast&>(placeholderRecords).RemoveAt(recordsToRemove[i]); - } - - // convert reminaings - for (auto [placeholderIndex, lrEdge, tokenEdge] : placeholderRecords) - { - auto newEdge = Ptr(new EdgeSymbol(injectEdge->From(), tokenEdge->To())); - edges.Add(newEdge); - newEdge->input = tokenEdge->input; - newEdge->importancy = tokenEdge->importancy; - - CopyFrom(newEdge->returnEdges, From(returnEdgesArray[placeholderIndex]).Take(returnEdgeCount), true); - CopyFrom(newEdge->returnEdges, tokenEdge->returnEdges, true); - prepareLriEdgeInstructions(placeholderIndex, returnEdgeCount, newEdge->insBeforeInput); - if (lrEdge) - { - // newEdge consumes a token - // lrEdge->insAfterInput happens before consuming this token - // so it should be copied to newEdge->insBeforeInput - CopyFrom(newEdge->insBeforeInput, lrEdge->insBeforeInput, true); - CopyFrom(newEdge->insBeforeInput, lrEdge->insAfterInput, true); - } - CopyFrom(newEdge->insBeforeInput, tokenEdge->insBeforeInput, true); - CopyFrom(newEdge->insAfterInput, tokenEdge->insAfterInput, true); - } - } - - // report an error if nothing is created - if (acceptableInputs.Count() == 0 && acceptableEndingInputs.Count() == 0) - { - AddError( - ParserErrorType::LeftRecursionInjectHasNoContinuation, - {}, - injectEdge->fromState->Rule()->Name(), - lrpFlags[injectEdge->input.flags[0]], - startState->Rule()->Name() - ); - } -#undef ERROR_MESSAGE_PREFIX - } - /*********************************************************************** SyntaxSymbolManager::BuildCrossReferencedNFAInternal ***********************************************************************/ @@ -18356,19 +15925,13 @@ SyntaxSymbolManager::BuildCrossReferencedNFAInternal } } - // convert LrInject to Token for (auto state : states) { - vint index = orderedEdges.Keys().IndexOf(state); - if (index != -1) + for (auto edge : state->OutEdges()) { - for (auto edge : orderedEdges.GetByIndex(index)) + if (edge->input.type == EdgeInputType::CrossReferencedToken) { - if (edge->input.type == EdgeInputType::LrInject) - { - auto startState = edge->input.rule->startStates[0]; - FixLeftRecursionInjectEdge(startState, edge); - } + edge->input.type = EdgeInputType::Token; } } } diff --git a/Import/VlppGlrParserCompiler.h b/Import/VlppGlrParserCompiler.h index 26ade4d6..f1562c4a 100644 --- a/Import/VlppGlrParserCompiler.h +++ b/Import/VlppGlrParserCompiler.h @@ -103,8 +103,7 @@ ParserSymbolManager ERROR_ITEM(TokenFragmentNotExists, fragmentName)\ /* SyntaxSymbolManager */\ ERROR_ITEM(DuplicatedRule, ruleName)\ - ERROR_ITEM(RuleIsIndirectlyLeftRecursive, ruleName) /* Indirect left recursion must be resolved before */\ - ERROR_ITEM(LeftRecursionInjectHasNoContinuation, ruleName, placeholder, targetRuleName)\ + ERROR_ITEM(RuleIsIndirectlyLeftRecursive, ruleNames) /* Indirect left recursion must be resolved before */\ /* SyntaxAst(ResolveName) */\ ERROR_ITEM(RuleNameConflictedWithToken, ruleName)\ ERROR_ITEM(TypeNotUniqueInRule, ruleName, name)\ @@ -121,8 +120,6 @@ ParserSymbolManager ERROR_ITEM(UnusedSwitch, switchName)\ ERROR_ITEM(SwitchNotExists, ruleName, switchName)\ ERROR_ITEM(SyntaxInvolvesSwitchWithIllegalRuleName, ruleName) /* A syntax uses switch should not use rule name that has _SWITCH/SWITCH_ */\ - ERROR_ITEM(SyntaxInvolvesPrefixMergeWithIllegalRuleName, ruleName) /* A syntax uses prefix_merge should not use rule name that has _LRI/_LRIP/LRI_/LRIP_ */\ - ERROR_ITEM(SyntaxInvolvesPrefixMergeWithIllegalPlaceholderName, ruleName, placeholderName) /* A syntax uses prefix_merge should not use placeholder name that has _LRI/_LRIP/LRI_/LRIP_ */\ /* SyntaxAst(CalculateTypes) */\ ERROR_ITEM(RuleMixedPartialClauseWithOtherClause, ruleName)\ ERROR_ITEM(RuleWithDifferentPartialTypes, ruleName, ruleType, newType)\ @@ -133,7 +130,6 @@ ParserSymbolManager ERROR_ITEM(ReuseClauseContainsNoUseRule, ruleName) /* A reuse clause contains no use rule therefore the type cannot be determined */\ /* SyntaxAst(ValidateSwitchesAndConditions, condition) */\ ERROR_ITEM(PushedSwitchIsNotTested, ruleName, switchName)\ - ERROR_ITEM(PrefixMergeAffectedBySwitches, ruleName, prefixMergeRule, switchName)\ ERROR_ITEM(SwitchUnaffectedRuleNotExist)\ /* SyntaxAst(RewriteSyntax_Switch, condition) */\ ERROR_ITEM(SwitchUnaffectedRuleExpandedToNoClause, ruleName)\ @@ -147,12 +143,6 @@ ParserSymbolManager ERROR_ITEM(UseRuleInNonReuseClause, ruleName, useRuleName) /* A use rule should only appear in reuse clause */\ ERROR_ITEM(PartialRuleUsedOnField, ruleName, clauseType, partialRuleName, fieldName) /* A partial rule does not create object, it cannot be assigned to a field */\ ERROR_ITEM(ClauseTypeMismatchedToPartialRule, ruleName, clauseType, partialRuleName, partialRuleType) /* A clause uses a partial rule of an incompatible type */\ - ERROR_ITEM(LeftRecursionPlaceholderNotFoundInRule, ruleName, placeholder, targetRuleName) /* left_recursion_inject injects to a rule which doesn't accept the specified placeholder */\ - ERROR_ITEM(LeftRecursionPlaceholderNotUnique, ruleName, placeholder, targetRuleName) /* left_recursion_inject injects to a rule which has multiple places accepting the specified placeholder */\ - ERROR_ITEM(LeftRecursionInjectTargetIsPrefixOfAnotherSameEnding, ruleName, placeholder, targetPrefixName, targetRuleName) /* left_recursion_inject injects into two targets, A is a prefix of B, and both injection could end with the same target C, C could be B */\ - ERROR_ITEM(LeftRecursionPlaceholderTypeMismatched, ruleName, placeholder, targetRuleName, placeholderRuleName)\ - ERROR_ITEM(PartialRuleInLeftRecursionInject, ruleName, partialRuleName)\ - ERROR_ITEM(PartialRuleInPrefixMerge, ruleName, partialRuleName)\ /* SyntaxAst(ValidateStructure, counting) */\ ERROR_ITEM(ClauseNotCreateObject, ruleName) /* A reuse clause does not contain use rule in some potential sequences */\ ERROR_ITEM(UseRuleUsedInOptionalBody, ruleName, useRuleName)\ @@ -165,19 +155,10 @@ ParserSymbolManager ERROR_ITEM(OptionalBodyCouldExpandToEmptySequence, ruleName)\ ERROR_ITEM(NegativeOptionalEndsAClause, ruleName) /* Negative optional syntax cannot ends a clause */\ ERROR_ITEM(MultiplePrioritySyntaxInAClause, ruleName)\ - ERROR_ITEM(TooManyLeftRecursionPlaceholderClauses, ruleName)\ /* SyntaxAst(ValidateStructure, relationship) */\ ERROR_ITEM(FieldAssignedMoreThanOnce, ruleName, clauseType, fieldName)\ - /* SyntaxAst(ValidatePrefixMerge, prefix_merge) */\ - ERROR_ITEM(RuleMixedPrefixMergeWithClauseNotSyntacticallyBeginWithARule, ruleName) /* If a rule has prefix_merge clause, than all other clause must syntactically begins with a rule */\ - ERROR_ITEM(RuleMixedPrefixMergeWithClauseNotBeginWithIndirectPrefixMerge, ruleName, startRule) /* If a rule has prefix_merge clause, than all other clause must directly or indirectly starts with prefix_merge */\ - ERROR_ITEM(RuleIndirectlyBeginsWithPrefixMergeMixedLeftRecursionMarkers, ruleName, prefixMergeRule, leftRecursionMarkerRule)\ - ERROR_ITEM(PartialRuleIndirectlyBeginsWithPrefixMerge, ruleName, prefixMergeRule)\ - ERROR_ITEM(ClausePartiallyIndirectlyBeginsWithPrefixMergeAndLiteral, ruleName, prefixMergeRule, literal)\ - ERROR_ITEM(ClausePartiallyIndirectlyBeginsWithPrefixMergeAndRule, ruleName, prefixMergeRule, literal)\ - /* SyntaxAst(RewriteSyntax_PrefixMerge, prefix_merge) */\ - ERROR_ITEM(PrefixExtractionAffectedRuleReferencedAnother, ruleName, conflictedRule, prefixRule) /* During left_recursion_inject clause generation, if prefix extracted affected the process, all !prefixRule clauses where prefixRule is the prefix of conflictedRule in any !conflictedRule clauses, prefixRule should not be affected */\ - + ERROR_ITEM(PartialRuleIsRecursive, ruleName)\ + enum class ParserErrorType { #define ParserErrorType_EnumItem(NAME, ...) NAME, @@ -219,7 +200,8 @@ ParserSymbolManager ErrorList errors; public: WString name; - StringItems includes; + StringItems astIncludes; + StringItems syntaxIncludes; StringItems cppNss; WString headerGuard; @@ -773,16 +755,11 @@ namespace vl::glr::parsergen class GlrClause; class GlrCondition; class GlrCreateClause; - class GlrLeftRecursionInjectClause; - class GlrLeftRecursionInjectContinuation; - class GlrLeftRecursionPlaceholder; - class GlrLeftRecursionPlaceholderClause; class GlrLoopSyntax; class GlrNotCondition; class GlrOptionalSyntax; class GlrOrCondition; class GlrPartialClause; - class GlrPrefixMergeClause; class GlrPushConditionSyntax; class GlrRefCondition; class GlrRefSyntax; @@ -826,20 +803,6 @@ namespace vl::glr::parsergen Weak = 1, }; - enum class GlrLeftRecursionConfiguration - { - UNDEFINED_ENUM_ITEM_VALUE = -1, - Single = 0, - Multiple = 1, - }; - - enum class GlrLeftRecursionInjectContinuationType - { - UNDEFINED_ENUM_ITEM_VALUE = -1, - Optional = 0, - Required = 1, - }; - class GlrCondition abstract : public vl::glr::ParsingAstBase, vl::reflection::Description { public: @@ -1004,9 +967,6 @@ namespace vl::glr::parsergen virtual void Visit(GlrCreateClause* node) = 0; virtual void Visit(GlrPartialClause* node) = 0; virtual void Visit(GlrReuseClause* node) = 0; - virtual void Visit(GlrLeftRecursionPlaceholderClause* node) = 0; - virtual void Visit(GlrLeftRecursionInjectClause* node) = 0; - virtual void Visit(GlrPrefixMergeClause* node) = 0; }; virtual void Accept(GlrClause::IVisitor* visitor) = 0; @@ -1050,46 +1010,6 @@ namespace vl::glr::parsergen void Accept(GlrClause::IVisitor* visitor) override; }; - class GlrLeftRecursionPlaceholder : public vl::glr::ParsingAstBase, vl::reflection::Description - { - public: - vl::glr::ParsingToken flag; - }; - - class GlrLeftRecursionPlaceholderClause : public GlrClause, vl::reflection::Description - { - public: - vl::collections::List> flags; - - void Accept(GlrClause::IVisitor* visitor) override; - }; - - class GlrLeftRecursionInjectContinuation : public vl::glr::ParsingAstBase, vl::reflection::Description - { - public: - vl::collections::List> flags; - GlrLeftRecursionConfiguration configuration = GlrLeftRecursionConfiguration::UNDEFINED_ENUM_ITEM_VALUE; - GlrLeftRecursionInjectContinuationType type = GlrLeftRecursionInjectContinuationType::UNDEFINED_ENUM_ITEM_VALUE; - vl::collections::List> injectionTargets; - }; - - class GlrLeftRecursionInjectClause : public GlrClause, vl::reflection::Description - { - public: - vl::Ptr rule; - vl::Ptr continuation; - - void Accept(GlrClause::IVisitor* visitor) override; - }; - - class GlrPrefixMergeClause : public GlrClause, vl::reflection::Description - { - public: - vl::Ptr rule; - - void Accept(GlrClause::IVisitor* visitor) override; - }; - class GlrRule : public vl::glr::ParsingAstBase, vl::reflection::Description { public: @@ -1138,13 +1058,6 @@ namespace vl::reflection::description DECL_TYPE_INFO(vl::glr::parsergen::GlrCreateClause) DECL_TYPE_INFO(vl::glr::parsergen::GlrPartialClause) DECL_TYPE_INFO(vl::glr::parsergen::GlrReuseClause) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionPlaceholder) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionConfiguration) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectContinuationType) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectContinuation) - DECL_TYPE_INFO(vl::glr::parsergen::GlrLeftRecursionInjectClause) - DECL_TYPE_INFO(vl::glr::parsergen::GlrPrefixMergeClause) DECL_TYPE_INFO(vl::glr::parsergen::GlrRule) DECL_TYPE_INFO(vl::glr::parsergen::GlrSyntaxFile) @@ -1232,21 +1145,6 @@ namespace vl::reflection::description INVOKE_INTERFACE_PROXY(Visit, node); } - void Visit(vl::glr::parsergen::GlrLeftRecursionPlaceholderClause* node) override - { - INVOKE_INTERFACE_PROXY(Visit, node); - } - - void Visit(vl::glr::parsergen::GlrLeftRecursionInjectClause* node) override - { - INVOKE_INTERFACE_PROXY(Visit, node); - } - - void Visit(vl::glr::parsergen::GlrPrefixMergeClause* node) override - { - INVOKE_INTERFACE_PROXY(Visit, node); - } - END_INTERFACE_PROXY(vl::glr::parsergen::GlrClause::IVisitor) #endif @@ -1302,34 +1200,6 @@ namespace vl::glr::parsergen::builder MakeCreateClause& type(const vl::WString& value); }; - class MakeLeftRecursionInjectClause : public vl::glr::ParsingAstBuilder - { - public: - MakeLeftRecursionInjectClause& continuation(const vl::Ptr& value); - MakeLeftRecursionInjectClause& rule(const vl::Ptr& value); - }; - - class MakeLeftRecursionInjectContinuation : public vl::glr::ParsingAstBuilder - { - public: - MakeLeftRecursionInjectContinuation& configuration(GlrLeftRecursionConfiguration value); - MakeLeftRecursionInjectContinuation& flags(const vl::Ptr& value); - MakeLeftRecursionInjectContinuation& injectionTargets(const vl::Ptr& value); - MakeLeftRecursionInjectContinuation& type(GlrLeftRecursionInjectContinuationType value); - }; - - class MakeLeftRecursionPlaceholder : public vl::glr::ParsingAstBuilder - { - public: - MakeLeftRecursionPlaceholder& flag(const vl::WString& value); - }; - - class MakeLeftRecursionPlaceholderClause : public vl::glr::ParsingAstBuilder - { - public: - MakeLeftRecursionPlaceholderClause& flags(const vl::Ptr& value); - }; - class MakeLoopSyntax : public vl::glr::ParsingAstBuilder { public: @@ -1365,12 +1235,6 @@ namespace vl::glr::parsergen::builder MakePartialClause& type(const vl::WString& value); }; - class MakePrefixMergeClause : public vl::glr::ParsingAstBuilder - { - public: - MakePrefixMergeClause& rule(const vl::Ptr& value); - }; - class MakePushConditionSyntax : public vl::glr::ParsingAstBuilder { public: @@ -1481,16 +1345,11 @@ namespace vl::glr::parsergen::copy_visitor void CopyFields(GlrClause* from, GlrClause* to); void CopyFields(GlrCondition* from, GlrCondition* to); void CopyFields(GlrCreateClause* from, GlrCreateClause* to); - void CopyFields(GlrLeftRecursionInjectClause* from, GlrLeftRecursionInjectClause* to); - void CopyFields(GlrLeftRecursionInjectContinuation* from, GlrLeftRecursionInjectContinuation* to); - void CopyFields(GlrLeftRecursionPlaceholder* from, GlrLeftRecursionPlaceholder* to); - void CopyFields(GlrLeftRecursionPlaceholderClause* from, GlrLeftRecursionPlaceholderClause* to); void CopyFields(GlrLoopSyntax* from, GlrLoopSyntax* to); void CopyFields(GlrNotCondition* from, GlrNotCondition* to); void CopyFields(GlrOptionalSyntax* from, GlrOptionalSyntax* to); void CopyFields(GlrOrCondition* from, GlrOrCondition* to); void CopyFields(GlrPartialClause* from, GlrPartialClause* to); - void CopyFields(GlrPrefixMergeClause* from, GlrPrefixMergeClause* to); void CopyFields(GlrPushConditionSyntax* from, GlrPushConditionSyntax* to); void CopyFields(GlrRefCondition* from, GlrRefCondition* to); void CopyFields(GlrRefSyntax* from, GlrRefSyntax* to); @@ -1508,8 +1367,6 @@ namespace vl::glr::parsergen::copy_visitor virtual void Visit(GlrSwitchItem* node); virtual void Visit(GlrTestConditionBranch* node); virtual void Visit(GlrAssignment* node); - virtual void Visit(GlrLeftRecursionPlaceholder* node); - virtual void Visit(GlrLeftRecursionInjectContinuation* node); virtual void Visit(GlrRule* node); virtual void Visit(GlrSyntaxFile* node); @@ -1530,9 +1387,6 @@ namespace vl::glr::parsergen::copy_visitor void Visit(GlrCreateClause* node) override; void Visit(GlrPartialClause* node) override; void Visit(GlrReuseClause* node) override; - void Visit(GlrLeftRecursionPlaceholderClause* node) override; - void Visit(GlrLeftRecursionInjectClause* node) override; - void Visit(GlrPrefixMergeClause* node) override; public: virtual vl::Ptr CopyNode(GlrCondition* node); @@ -1541,22 +1395,17 @@ namespace vl::glr::parsergen::copy_visitor virtual vl::Ptr CopyNode(GlrSwitchItem* node); virtual vl::Ptr CopyNode(GlrTestConditionBranch* node); virtual vl::Ptr CopyNode(GlrAssignment* node); - virtual vl::Ptr CopyNode(GlrLeftRecursionPlaceholder* node); - virtual vl::Ptr CopyNode(GlrLeftRecursionInjectContinuation* node); virtual vl::Ptr CopyNode(GlrRule* node); virtual vl::Ptr CopyNode(GlrSyntaxFile* node); vl::Ptr CopyNode(GlrAlternativeSyntax* node); vl::Ptr CopyNode(GlrAndCondition* node); vl::Ptr CopyNode(GlrCreateClause* node); - vl::Ptr CopyNode(GlrLeftRecursionInjectClause* node); - vl::Ptr CopyNode(GlrLeftRecursionPlaceholderClause* node); vl::Ptr CopyNode(GlrLoopSyntax* node); vl::Ptr CopyNode(GlrNotCondition* node); vl::Ptr CopyNode(GlrOptionalSyntax* node); vl::Ptr CopyNode(GlrOrCondition* node); vl::Ptr CopyNode(GlrPartialClause* node); - vl::Ptr CopyNode(GlrPrefixMergeClause* node); vl::Ptr CopyNode(GlrPushConditionSyntax* node); vl::Ptr CopyNode(GlrRefCondition* node); vl::Ptr CopyNode(GlrRefSyntax* node); @@ -1626,9 +1475,6 @@ namespace vl::glr::parsergen::empty_visitor void Visit(GlrCreateClause* node) override; void Visit(GlrPartialClause* node) override; void Visit(GlrReuseClause* node) override; - void Visit(GlrLeftRecursionPlaceholderClause* node) override; - void Visit(GlrLeftRecursionInjectClause* node) override; - void Visit(GlrPrefixMergeClause* node) override; }; } @@ -1663,16 +1509,11 @@ namespace vl::glr::parsergen::json_visitor virtual void PrintFields(GlrClause* node); virtual void PrintFields(GlrCondition* node); virtual void PrintFields(GlrCreateClause* node); - virtual void PrintFields(GlrLeftRecursionInjectClause* node); - virtual void PrintFields(GlrLeftRecursionInjectContinuation* node); - virtual void PrintFields(GlrLeftRecursionPlaceholder* node); - virtual void PrintFields(GlrLeftRecursionPlaceholderClause* node); virtual void PrintFields(GlrLoopSyntax* node); virtual void PrintFields(GlrNotCondition* node); virtual void PrintFields(GlrOptionalSyntax* node); virtual void PrintFields(GlrOrCondition* node); virtual void PrintFields(GlrPartialClause* node); - virtual void PrintFields(GlrPrefixMergeClause* node); virtual void PrintFields(GlrPushConditionSyntax* node); virtual void PrintFields(GlrRefCondition* node); virtual void PrintFields(GlrRefSyntax* node); @@ -1704,9 +1545,6 @@ namespace vl::glr::parsergen::json_visitor void Visit(GlrCreateClause* node) override; void Visit(GlrPartialClause* node) override; void Visit(GlrReuseClause* node) override; - void Visit(GlrLeftRecursionPlaceholderClause* node) override; - void Visit(GlrLeftRecursionInjectClause* node) override; - void Visit(GlrPrefixMergeClause* node) override; public: RuleAstVisitor(vl::stream::StreamWriter& _writer); @@ -1717,8 +1555,6 @@ namespace vl::glr::parsergen::json_visitor void Print(GlrSwitchItem* node); void Print(GlrTestConditionBranch* node); void Print(GlrAssignment* node); - void Print(GlrLeftRecursionPlaceholder* node); - void Print(GlrLeftRecursionInjectContinuation* node); void Print(GlrRule* node); void Print(GlrSyntaxFile* node); }; @@ -1756,16 +1592,11 @@ namespace vl::glr::parsergen::traverse_visitor virtual void Traverse(GlrClause* node); virtual void Traverse(GlrCondition* node); virtual void Traverse(GlrCreateClause* node); - virtual void Traverse(GlrLeftRecursionInjectClause* node); - virtual void Traverse(GlrLeftRecursionInjectContinuation* node); - virtual void Traverse(GlrLeftRecursionPlaceholder* node); - virtual void Traverse(GlrLeftRecursionPlaceholderClause* node); virtual void Traverse(GlrLoopSyntax* node); virtual void Traverse(GlrNotCondition* node); virtual void Traverse(GlrOptionalSyntax* node); virtual void Traverse(GlrOrCondition* node); virtual void Traverse(GlrPartialClause* node); - virtual void Traverse(GlrPrefixMergeClause* node); virtual void Traverse(GlrPushConditionSyntax* node); virtual void Traverse(GlrRefCondition* node); virtual void Traverse(GlrRefSyntax* node); @@ -1787,16 +1618,11 @@ namespace vl::glr::parsergen::traverse_visitor virtual void Finishing(GlrClause* node); virtual void Finishing(GlrCondition* node); virtual void Finishing(GlrCreateClause* node); - virtual void Finishing(GlrLeftRecursionInjectClause* node); - virtual void Finishing(GlrLeftRecursionInjectContinuation* node); - virtual void Finishing(GlrLeftRecursionPlaceholder* node); - virtual void Finishing(GlrLeftRecursionPlaceholderClause* node); virtual void Finishing(GlrLoopSyntax* node); virtual void Finishing(GlrNotCondition* node); virtual void Finishing(GlrOptionalSyntax* node); virtual void Finishing(GlrOrCondition* node); virtual void Finishing(GlrPartialClause* node); - virtual void Finishing(GlrPrefixMergeClause* node); virtual void Finishing(GlrPushConditionSyntax* node); virtual void Finishing(GlrRefCondition* node); virtual void Finishing(GlrRefSyntax* node); @@ -1828,9 +1654,6 @@ namespace vl::glr::parsergen::traverse_visitor void Visit(GlrCreateClause* node) override; void Visit(GlrPartialClause* node) override; void Visit(GlrReuseClause* node) override; - void Visit(GlrLeftRecursionPlaceholderClause* node) override; - void Visit(GlrLeftRecursionInjectClause* node) override; - void Visit(GlrPrefixMergeClause* node) override; public: void InspectInto(GlrCondition* node); @@ -1839,8 +1662,6 @@ namespace vl::glr::parsergen::traverse_visitor void InspectInto(GlrSwitchItem* node); void InspectInto(GlrTestConditionBranch* node); void InspectInto(GlrAssignment* node); - void InspectInto(GlrLeftRecursionPlaceholder* node); - void InspectInto(GlrLeftRecursionInjectContinuation* node); void InspectInto(GlrRule* node); void InspectInto(GlrSyntaxFile* node); }; @@ -2230,29 +2051,24 @@ namespace vl::glr::parsergen CreateClause = 8, Enum = 9, EnumItem = 10, - LeftRecursionInjectClause = 11, - LeftRecursionInjectContinuation = 12, - LeftRecursionPlaceholder = 13, - LeftRecursionPlaceholderClause = 14, - LoopSyntax = 15, - NotCondition = 16, - OptionalSyntax = 17, - OrCondition = 18, - PartialClause = 19, - PrefixMergeClause = 20, - PushConditionSyntax = 21, - RefCondition = 22, - RefSyntax = 23, - ReuseClause = 24, - Rule = 25, - SequenceSyntax = 26, - SwitchItem = 27, - Syntax = 28, - SyntaxFile = 29, - TestConditionBranch = 30, - TestConditionSyntax = 31, - Type = 32, - UseSyntax = 33, + LoopSyntax = 11, + NotCondition = 12, + OptionalSyntax = 13, + OrCondition = 14, + PartialClause = 15, + PushConditionSyntax = 16, + RefCondition = 17, + RefSyntax = 18, + ReuseClause = 19, + Rule = 20, + SequenceSyntax = 21, + SwitchItem = 22, + Syntax = 23, + SyntaxFile = 24, + TestConditionBranch = 25, + TestConditionSyntax = 26, + Type = 27, + UseSyntax = 28, }; enum class ParserGenFields : vl::vint32_t @@ -2276,50 +2092,41 @@ namespace vl::glr::parsergen CreateClause_type = 16, Enum_items = 17, EnumItem_name = 18, - LeftRecursionInjectClause_continuation = 19, - LeftRecursionInjectClause_rule = 20, - LeftRecursionInjectContinuation_configuration = 21, - LeftRecursionInjectContinuation_flags = 22, - LeftRecursionInjectContinuation_injectionTargets = 23, - LeftRecursionInjectContinuation_type = 24, - LeftRecursionPlaceholder_flag = 25, - LeftRecursionPlaceholderClause_flags = 26, - LoopSyntax_delimiter = 27, - LoopSyntax_syntax = 28, - NotCondition_condition = 29, - OptionalSyntax_priority = 30, - OptionalSyntax_syntax = 31, - OrCondition_first = 32, - OrCondition_second = 33, - PartialClause_assignments = 34, - PartialClause_syntax = 35, - PartialClause_type = 36, - PrefixMergeClause_rule = 37, - PushConditionSyntax_switches = 38, - PushConditionSyntax_syntax = 39, - RefCondition_name = 40, - RefSyntax_field = 41, - RefSyntax_literal = 42, - RefSyntax_refType = 43, - ReuseClause_assignments = 44, - ReuseClause_syntax = 45, - Rule_attParser = 46, - Rule_attPublic = 47, - Rule_clauses = 48, - Rule_name = 49, - Rule_type = 50, - SequenceSyntax_first = 51, - SequenceSyntax_second = 52, - SwitchItem_name = 53, - SwitchItem_value = 54, - SyntaxFile_rules = 55, - SyntaxFile_switches = 56, - TestConditionBranch_condition = 57, - TestConditionBranch_syntax = 58, - TestConditionSyntax_branches = 59, - Type_attPublic = 60, - Type_name = 61, - UseSyntax_name = 62, + LoopSyntax_delimiter = 19, + LoopSyntax_syntax = 20, + NotCondition_condition = 21, + OptionalSyntax_priority = 22, + OptionalSyntax_syntax = 23, + OrCondition_first = 24, + OrCondition_second = 25, + PartialClause_assignments = 26, + PartialClause_syntax = 27, + PartialClause_type = 28, + PushConditionSyntax_switches = 29, + PushConditionSyntax_syntax = 30, + RefCondition_name = 31, + RefSyntax_field = 32, + RefSyntax_literal = 33, + RefSyntax_refType = 34, + ReuseClause_assignments = 35, + ReuseClause_syntax = 36, + Rule_attParser = 37, + Rule_attPublic = 38, + Rule_clauses = 39, + Rule_name = 40, + Rule_type = 41, + SequenceSyntax_first = 42, + SequenceSyntax_second = 43, + SwitchItem_name = 44, + SwitchItem_value = 45, + SyntaxFile_rules = 46, + SyntaxFile_switches = 47, + TestConditionBranch_condition = 48, + TestConditionBranch_syntax = 49, + TestConditionSyntax_branches = 50, + Type_attPublic = 51, + Type_name = 52, + UseSyntax_name = 53, }; extern const wchar_t* ParserGenTypeName(ParserGenClasses type); @@ -2386,18 +2193,14 @@ namespace vl::glr::parsergen WEAK_ASSIGN = 27, POSITIVE = 28, NEGATIVE = 29, - LS_PH = 30, - LS_I = 31, - LS_IM = 32, - LS_PM = 33, - ID = 34, - STRING = 35, - CONDITIONAL_LITERAL = 36, - SPACE = 37, - COMMENT = 38, + ID = 30, + STRING = 31, + CONDITIONAL_LITERAL = 32, + SPACE = 33, + COMMENT = 34, }; - constexpr vl::vint ParserGenTokenCount = 39; + constexpr vl::vint ParserGenTokenCount = 35; extern bool ParserGenTokenDeleter(vl::vint token); extern const wchar_t* ParserGenTokenId(ParserGenTokens token); extern const wchar_t* ParserGenTokenDisplayText(ParserGenTokens token); @@ -2428,25 +2231,15 @@ namespace vl::glr::parsergen Cond2 = 14, Cond = 20, SwitchItem = 23, - Switches = 28, - OptionalBody = 34, - TestBranch = 39, - Token = 45, - Syntax0 = 50, - Syntax1 = 81, - Syntax2 = 86, - Syntax = 92, - AssignmentOp = 95, - Assignment = 99, - Clause = 104, - Placeholder = 140, - RuleName = 143, - LriConfig = 146, - LriContinuationBody = 150, - LriContinuation = 161, - LriTarget = 167, - Rule = 174, - File = 184, + TestBranch = 28, + Syntax0 = 34, + Syntax1 = 73, + Syntax2 = 78, + Syntax = 84, + Assignment = 87, + Clause = 93, + Rule = 112, + File = 122, }; const wchar_t* RuleParserRuleName(vl::vint index); @@ -2488,12 +2281,10 @@ namespace vl::glr::parsergen { EnumItem = 0, Enum = 4, - ClassPropType = 12, - classProp = 19, - ClassBody = 26, - Class = 34, - Type = 40, - File = 44, + classProp = 12, + Class = 23, + Type = 34, + File = 38, }; const wchar_t* TypeParserRuleName(vl::vint index); @@ -2583,18 +2374,16 @@ StateSymbol protected: SyntaxSymbolManager* ownerManager; RuleSymbol* rule; - vint32_t clauseId; EdgeList inEdges; EdgeList outEdges; - StateSymbol(RuleSymbol* _rule, vint32_t _clauseId); + StateSymbol(RuleSymbol* _rule); public: WString label; bool endingState = false; SyntaxSymbolManager* Owner() { return ownerManager; } RuleSymbol* Rule() { return rule; } - vint32_t ClauseId() { return clauseId; } const EdgeList& InEdges() { return inEdges; } const EdgeList& OutEdges() { return outEdges; } @@ -2607,43 +2396,38 @@ EdgeSymbol enum class EdgeInputType { - Epsilon, // No input is needed to execute this edge. - Ending, // An epsilon edge that reduces the current rule. - LeftRec, // An epsilon edge that reduces the current rule, which is the first input of one of its left recursive clause. - Token, // An token is read to execute this edge. - Rule, // A rule is reduced to execute this edge. - LrPlaceholder, // A left recursion placeholder is consumed to execute this edge. EdgeInput::token is the index of SyntaxSymbolManager::lrpFlags. - LrInject, // A left recursion injection. + Epsilon, // No input is needed to execute this edge. + PrefixMergeRule, // Rule transition that created from accumulated transitions, it is a temporarily mark and will be converted back to Rule, during prefix-merge process + PrefixMergeDiscardedRule, // Rule transition that leads accmuulated transitions, converted to PrefixMergeDiscardedRule during prefix-merge process + CrossReferencedToken, // Token transition that created from accumulated transitions, it is a temporarily mark and will be converted back to Token, during cross-reference process + + Ending, // An epsilon edge that reduces the current rule. + LeftRec, // An epsilon edge that reduces the current rule, which is the first input of one of its left recursive clause. + Token, // An token is read to execute this edge. + Rule, // A rule is reduced to execute this edge. }; struct EdgeInput { EdgeInputType type = EdgeInputType::Epsilon; - vint32_t token = -1; // useful when type == Token - Nullable condition; // useful when type == Token - collections::SortedList flags; // usefule when type == LrPlaceholder or LrInject + // Token + vint32_t token = -1; + Nullable condition; - automaton::ReturnRuleType ruleType = automaton::ReturnRuleType::Field; // useful when type == Rule or LrInject - RuleSymbol* rule = nullptr; // useful when type == Rule or LrInject + // Rule + automaton::ReturnRuleType ruleType = automaton::ReturnRuleType::Field; + RuleSymbol* rule = nullptr; - EdgeInput& operator=(EdgeInput& input) - { - type = input.type; - token = input.token; - condition = input.condition; - CopyFrom(flags, input.flags); - ruleType = input.ruleType; - rule = input.rule; - return *this; - } + auto operator<=>(const EdgeInput&) const = default; }; - enum class EdgeImportancy + struct EdgeCompetition { - NoCompetition, - HighPriority, - LowPriority, + vint32_t competitionId = -1; + bool highPriority = false; + + auto operator<=>(const EdgeCompetition&) const = default; }; class EdgeSymbol : public Object @@ -2653,6 +2437,7 @@ EdgeSymbol using InsList = collections::List; using EdgeList = collections::List; + using CompetitionList = collections::List; protected: SyntaxSymbolManager* ownerManager; StateSymbol* fromState; @@ -2661,11 +2446,9 @@ EdgeSymbol EdgeSymbol(StateSymbol* _from, StateSymbol* _to); public: EdgeInput input; // Input of this edge. - bool important = false; // true and false are the only two priorites of edges. - EdgeImportancy importancy = EdgeImportancy::NoCompetition; // important -> HighPriority, !important with important sibling -> LowPriority. + CompetitionList competitions; // Competitions this edge involves in. // (filled by BuildCompactNFA) // If any important edge forms a cross referenced NFA edge, it becomes important too. - InsList insBeforeInput; // Instructions to execute before pushing the value from a token or a reduced rule. InsList insAfterInput; // Instructions to execute after pushing the value from a token or a reduced rule. EdgeList returnEdges; // Edges of rule reduction. // InsBeforeInput will be copied to a cross-referenced edge. @@ -2685,11 +2468,10 @@ RuleSymbol friend class SyntaxSymbolManager; using StateList = collections::List; - using NameList = collections::SortedList; protected: SyntaxSymbolManager* ownerManager; WString name; - vint32_t currentClauseId = -1; + vint pmRuleIndex = -1; RuleSymbol(SyntaxSymbolManager* _ownerManager, const WString& _name, vint _fileIndex); public: @@ -2700,12 +2482,9 @@ RuleSymbol bool isPartial = false; bool assignedNonArrayField = false; AstClassSymbol* ruleType = nullptr; - NameList lrFlags; SyntaxSymbolManager* Owner() { return ownerManager; } const WString& Name() { return name; } - void NewClause() { currentClauseId++; } - vint32_t CurrentClauseId() { return currentClauseId; } }; /*********************************************************************** @@ -2714,64 +2493,154 @@ SyntaxSymbolManager enum class SyntaxPhase { - EpsilonNFA, // An automaton that has edges of Epsilon, Token, Rule. + EpsilonNFA, // An automaton that has edges of: + // Epsilon + // Token + // Rule + // Ending - CompactNFA, // Epsilon edges are eliminated by compressing multiple edges into one. + CompactNFA, // An automaton that has edges of + // Token + // Rule + // Ending + // LeftRec + // with ignored but still existing edges + // PrefixMergeDiscardedRule + // Epsilon edges are eliminated by compressing multiple edges into one. // Epsilon edges to the ending state will be compressed to an Ending edge. // The first edge of Rule in left-recursive clauses becomes a LeftRec edge, with its fromState changed to the ending state. // fromState and toState of non-LeftRec edges belong to the same clause. + // PrefixMergeRule transitions will be built from several Rule transitions. + // Such Rule transitions will be disconnected but still stored, and PrefixMergeRule will be renamed to Rule. - CrossReferencedNFA, // Edges of Rule are compressed to an edge that pointing towards states in other clauses. + CrossReferencedNFA, // An automaton that has edges of + // Token + // Ending + // LeftRec + // with ignored but still existing edges + // Rule + // PrefixMergeDiscardedRule + // Edges of Rule are compressed to an edge that pointing towards states in other clauses. // Multiple edges of rule are stored in returnEdges in the order of execution. // insBeforeInput of an edge contains insBeforeInput from its returnEdges. // returnEdges of an edge will be pushed to a stack when it is executed. // Executing an Ending edge pops a returnEdges and execute its insAfterInput only. // automaton::Executable is exactly the same to CrossReferencedNFA, stored a more cache friendly way. + // Rule transitions will be kept, but it is not logged, and also ignored during building automaton. }; + struct PrefixMergeCache; + + struct PrefixMergeSolutionApplication + { + collections::Array edgesToMerge; + collections::SortedList prefixRules; + }; + using PrefixMergeSolutionApplicationList = collections::List>; + + struct PrefixMergeSolutionValue + { + collections::SortedList prefixRules; + PrefixMergeSolutionApplicationList applications; + }; + using PrefixMergeSolutionKey = Tuple; + using PrefixMergeSolutionMap = collections::Dictionary>; + + struct PrefixMergeApplicationItems; + class SyntaxSymbolManager : public Object { using StateList = collections::List>; using EdgeList = collections::List>; - using LrpFlagList = collections::SortedList; + using StartEndStatePair = collections::Pair; protected: - MappedOwning rules; - StateList states; - EdgeList edges; - ParserSymbolManager& global; - SyntaxPhase phase = SyntaxPhase::EpsilonNFA; + MappedOwning rules; + StateList states; + EdgeList edges; + ParserSymbolManager& global; + SyntaxPhase phase = SyntaxPhase::EpsilonNFA; - void BuildLeftRecEdge(EdgeSymbol* newEdge, EdgeSymbol* endingEdge, EdgeSymbol* lrecPrefixEdge); - void EliminateLeftRecursion(RuleSymbol* rule, StateSymbol* startState, StateSymbol* endState, StateList& newStates, EdgeList& newEdges); - void EliminateSingleRulePrefix(RuleSymbol* rule, StateSymbol* startState, StateSymbol* endState, StateList& newStates, EdgeList& newEdges); - StateSymbol* EliminateEpsilonEdges(RuleSymbol* rule, StateList& newStates, EdgeList& newEdges); + protected: + struct IncrementalChange + { + StateList createdStates; + EdgeList createdEdges; + bool reuseOps = true; // In ApplyIncrementalChange, true means to keep opStates and opEdges, false means to remove + collections::SortedList opStates; + collections::SortedList opEdges; + }; + + static StartEndStatePair EliminateEpsilonEdges(RuleSymbol* rule, StateList& newStates, EdgeList& newEdges); + static void BuildLeftRecEdge(EdgeSymbol* newEdge, EdgeSymbol* endingEdge, EdgeSymbol* lrecPrefixEdge); + static void EliminateLeftRecursion(RuleSymbol* rule, StateSymbol* startState, StateSymbol* endState, StateList& newStates, EdgeList& newEdges); + static void MergeEdgesWithSameInput(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges); + static void MergeEdgesWithSameRuleUsingLeftrec(RuleSymbol* rule, StateSymbol* startState, StateList& newStates, EdgeList& newEdges); + + Ptr CreatePrefixMergeCache(); + static void PrefixMergeCrossReference_SolveInState( + PrefixMergeCache* cache, + RuleSymbol* rule, + StateSymbol* currentState, + Ptr application); + static void PrefixMergeCrossReference_Solve( + PrefixMergeCache* cache, + bool forStartState, + RuleSymbol* rule, + StateSymbol* startState, + PrefixMergeSolutionMap& prefixMergeSolutions); + static void PrefixMergeCrossReference_Solve(PrefixMergeCache* cache, PrefixMergeSolutionMap& prefixMergeSolutions); + + static EdgeSymbol* PrefixMergeCrossReference_AccumulatedEdges( + StateSymbol* fromState, + const WString& pmLabel, + const collections::List>>& accumulatedEdgesList, + IncrementalChange& ic); + static void PrefixMergeCrossReference_Apply( + PrefixMergeCache* cache, + collections::List& accumulatedEdges, + PrefixMergeApplicationItems& pmai); + static void PrefixMergeCrossReference_Apply( + PrefixMergeCache* cache, + RuleSymbol* rule, + StateSymbol* currentState, + Ptr solution, + IncrementalChange& ic); + + static void ApplyIncrementalChange(const IncrementalChange& ic, StateList& newStates, EdgeList& newEdges); void BuildCompactNFAInternal(); - void FixCrossReferencedRuleEdge(StateSymbol* startState, collections::Group& orderedEdges, collections::List& accumulatedEdges); - void FixLeftRecursionInjectEdge(StateSymbol* startState, EdgeSymbol* injectEdge); + protected: + + void FixCrossReferencedRuleEdge( + StateSymbol* startState, + collections::Group& orderedEdges, + collections::List& accumulatedEdges); void BuildCrossReferencedNFAInternal(); + public: SyntaxSymbolManager(ParserSymbolManager& _global); - WString name; - LrpFlagList lrpFlags; + WString name; + vint32_t usedCompetitionIds = 0; + PrefixMergeSolutionMap prefixMergeSolutions; - RuleSymbol* CreateRule(const WString& name, vint fileIndex, bool isPublic, bool isParser, ParsingTextRange codeRange = {}); - void RemoveRule(const WString& name); + RuleSymbol* CreateRule(const WString& name, vint fileIndex, bool isPublic, bool isParser, ParsingTextRange codeRange = {}); + void RemoveRule(const WString& name); - StateSymbol* CreateState(RuleSymbol* rule, vint32_t clauseId); - EdgeSymbol* CreateEdge(StateSymbol* from, StateSymbol* to); + StateSymbol* CreateState(RuleSymbol* rule); + EdgeSymbol* CreateEdge(StateSymbol* from, StateSymbol* to); - void BuildCompactNFA(); - void BuildCrossReferencedNFA(); - void BuildAutomaton(vint tokenCount, automaton::Executable& executable, automaton::Metadata& metadata); - void GetStatesInStableOrder(collections::List& order); - WString GetStateGlobalLabel(StateSymbol* state, vint index); + void BuildCompactNFA(); + void BuildCrossReferencedNFA(); + void BuildAutomaton(vint tokenCount, automaton::Executable& executable, automaton::Metadata& metadata); + void GetStatesInStableOrder(collections::List& order); + WString GetStateGlobalLabel(StateSymbol* state, vint index); - const ParserSymbolManager& Global() const { return global; } - const auto& Rules() const { return rules.map; } - const auto& RuleOrder() { return rules.order; } - SyntaxPhase Phase() { return phase; } + const ParserSymbolManager& Global() const { return global; } + const auto& Rules() const { return rules.map; } + const auto& RuleOrder() { return rules.order; } + SyntaxPhase Phase() { return phase; } template void AddError(ParserErrorType type, ParsingTextRange codeRange, TArgs&&... args) const @@ -2780,8 +2649,8 @@ SyntaxSymbolManager } }; - extern void CreateParserGenTypeSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager); - extern void CreateParserGenRuleSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager); + extern void CreateParserGenTypeSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager); + extern void CreateParserGenRuleSyntax(AstSymbolManager& ast, SyntaxSymbolManager& manager); } } } @@ -2832,21 +2701,9 @@ namespace vl using GlrRuleMap = collections::Dictionary; using LiteralTokenMap = collections::Dictionary; using RuleDependencies = collections::Group; - using RuleKnownTypes = collections::Group; using ClauseReuseDependencies = collections::Group; using ClauseTypeMap = collections::Dictionary; - using LeftRecursiveClauseMap = collections::Group; - using LeftRecursionInjectClauseMap = collections::Group; - using LeftRecursionPlaceholderClauseMap = collections::Group; - using PrefixMergeClauseMap = collections::Group; - using ClauseToRuleMap = collections::Dictionary; - using ClauseToRuleGroup = collections::Group; - using RuleToLiteralMap = collections::Group; - using ClauseToLiteralMap = collections::Group; - using RulePathDependencies = collections::Group; - using PathToLastRuleMap = collections::Group; - using ClauseList = collections::List; struct VisitorContext @@ -2860,34 +2717,12 @@ namespace vl GlrRuleMap astRules; // RuleSymbol -> GlrRule LiteralTokenMap literalTokens; RuleDependencies ruleReuseDependencies; // RuleSymbol -> !rule in that rule - RuleKnownTypes ruleKnownTypes; // RuleSymbol -> explicitly declared object type in clauses ClauseReuseDependencies clauseReuseDependencies; // GlrReuseClause -> !rule in that clause ClauseTypeMap clauseTypes; // GlrClause -> type - ClauseToRuleMap clauseToRules; // GlrClause -> RuleSymbol that contain this clause Ptr cachedLexer; - LeftRecursiveClauseMap leftRecursiveClauses; // RuleSymbol -> all clauses begins with that rule - LeftRecursionInjectClauseMap directLriClauses, indirectLriClauses; // RuleSymbol -> contained left_recursion_injection clauses - // RuleSymbol -> reachable left_recursion_injection clauses - LeftRecursionPlaceholderClauseMap directLrpClauses, indirectLrpClauses; // RuleSymbol -> contained left_recursion_placeholder clauses - // RuleSymbol -> reachable left_recursion_placeholder clauses - PrefixMergeClauseMap directPmClauses, indirectPmClauses; // RuleSymbol -> contained prefix_merge clauses - // RuleSymbol -> reachable prefix_merge clauses - - ClauseToRuleMap simpleUseClauseToReferencedRules; // GlrClause -> RuleSymbol when this clause is !RuleSymbol - ClauseToRuleGroup clauseToStartRules; // GlrClause -> RuleSymbol when this clause begins with RuleSymbol - RuleToLiteralMap ruleBeginsWithLiteral; // RuleSymbol that begins with any literal - ClauseToLiteralMap clauseBeginsWithLiteral; // GlrClause that begins with any literal - - RulePathDependencies directStartRules, indirectStartRules; // RuleSymbol -> {rule, clause begins with the rule} - // RuleSymbol -> {rule, reachable clause begins with the rule} - RulePathDependencies directSimpleUseRules, indirectSimpleUseRules; // RuleSymbol -> {rule, clause that is !rule} - // RuleSymbol -> {rule, reachable clause that is !rule} - PathToLastRuleMap indirectStartPathToLastRules; // {r1, r3} -> {r2, clause}, where r1 --(indirect)--> r2 --(direct)--> {r3, clause begins with r3 contained in r2} - PathToLastRuleMap indirectSimpleUsePathToLastRules; // {r1, r3} -> {r2, clause}, where r1 (indirect)::= !r2 (direct)::= {r3, clause that is !r3 contained in r2} - // ValidateStructure - ClauseList clauseToConvertedToPrefixMerge; // GlrClause when it should be converted to a prefix_merge clause + RuleDependencies partialRuleDependencies; // RuleSymbol -> direct referenced partial rule in that partial rule VisitorContext( const AstSymbolManager& _astManager, @@ -3007,6 +2842,8 @@ AutomatonBuilder using AssignmentBuilder = Func; protected: + vint usedFieldIds = 0; + collections::List fieldIns; RuleSymbol* ruleSymbol; WString clauseDisplayText; @@ -3015,7 +2852,7 @@ AutomatonBuilder StateSymbol* CreateState() { - return ruleSymbol->Owner()->CreateState(ruleSymbol, ruleSymbol->CurrentClauseId()); + return ruleSymbol->Owner()->CreateState(ruleSymbol); } EdgeSymbol* CreateEdge(StateSymbol* from, StateSymbol* to) @@ -3029,7 +2866,6 @@ AutomatonBuilder StatePair BuildTokenSyntax(vint32_t tokenId, const WString& displayText, Nullable condition, vint32_t field); StatePair BuildFieldRuleSyntax(RuleSymbol* rule, vint32_t field); - StatePair BuildPartialRuleSyntax(RuleSymbol* rule); StatePair BuildDiscardRuleSyntax(RuleSymbol* rule); StatePair BuildUseSyntax(RuleSymbol* rule); StatePair BuildLoopSyntax(const StateBuilder& loopBody, const StateBuilder& loopDelimiter, bool hasDelimiter); @@ -3040,13 +2876,7 @@ AutomatonBuilder StatePair BuildClause(const StateBuilder& compileSyntax); StatePair BuildAssignment(StatePair pair, vint32_t enumItem, vint32_t field, bool weakAssignment); StatePair BuildCreateClause(vint32_t classId, const StateBuilder& compileSyntax); - StatePair BuildPartialClause(const StateBuilder& compileSyntax); StatePair BuildReuseClause(const StateBuilder& compileSyntax); - - StatePair BuildLrpClause(collections::SortedList& flags, const Func& flagName); - StatePair BuildLriSyntax(collections::SortedList& flags, RuleSymbol* rule, const Func& flagName); - StatePair BuildLriSkip(); - StatePair BuildLriClauseSyntax(StateBuilder useOrLriSyntax, bool optional, collections::List&& continuations); }; namespace syntax_writer @@ -3065,7 +2895,6 @@ Clause struct Rule { - static const vint Partial = -2; static const vint Discard = -1; RuleSymbol* rule; @@ -3110,6 +2939,12 @@ Clause U second; }; + struct WithConfig + { + vint32_t field; + vint32_t enumItem; + }; + template struct With { @@ -3131,18 +2966,6 @@ Clause } }; - template - struct Partial - { - T body; - - template - Partial> with(F field, E enumItem) - { - return { { body,(vint32_t)field,(vint32_t)enumItem } }; - } - }; - template struct Reuse { @@ -3192,9 +3015,6 @@ Verification template struct IsClause_> { static constexpr bool Value = IsClause_::Value; }; - template - struct IsClause_> { static constexpr bool Value = IsClause_::Value; }; - template struct IsClause_> { static constexpr bool Value = IsClause_::Value; }; @@ -3223,12 +3043,6 @@ Operators return { r,Rule::Discard }; } - inline Rule prule(RuleSymbol* r) - { - CHECK_ERROR(r->isPartial, L"vl::glr::parsergen::syntax_writer::prule(RuleSymbol*)#Rule should be a partial rule."); - return { r,Rule::Partial }; - } - template inline Rule rule(RuleSymbol* r, F field) { @@ -3272,18 +3086,24 @@ Operators return { c1,c2 }; } + template + inline WithConfig with(F field, E enumItem) + { + return { (vint32_t)field,(vint32_t)enumItem }; + } + + template + inline std::enable_if_t, With> operator&&(const C1& c1, const WithConfig& with) + { + return { c1,with.field,with.enumItem }; + } + template inline std::enable_if_t, Create> create(const C& clause, T type) { return { clause,(vint32_t)type }; } - template - inline std::enable_if_t, Partial> partial(const C& clause) - { - return { clause }; - } - template inline std::enable_if_t, Reuse> reuse(const C& clause) { @@ -3307,13 +3127,12 @@ Builder StatePair Build(const Rule& clause) { - switch (clause.field) + if (clause.field == Rule::Discard) { - case Rule::Partial: - return builder.BuildPartialRuleSyntax(clause.rule); - case Rule::Discard: return builder.BuildDiscardRuleSyntax(clause.rule); - default: + } + else + { return builder.BuildFieldRuleSyntax(clause.rule, clause.field); } } @@ -3410,14 +3229,6 @@ Builder ); } - template - StatePair Build(const Partial& clause) - { - return builder.BuildPartialClause( - [this, &clause]() { return Build(clause.body); } - ); - } - template StatePair Build(const Reuse& clause) { @@ -3443,13 +3254,6 @@ Builder return *this; } - template - Clause& operator=(const Partial& clause) - { - Assign(clause); - return *this; - } - template Clause& operator=(const Reuse& clause) { diff --git a/Import/VlppWorkflowCompiler.cpp b/Import/VlppWorkflowCompiler.cpp index a86c61c0..895c88b9 100644 --- a/Import/VlppWorkflowCompiler.cpp +++ b/Import/VlppWorkflowCompiler.cpp @@ -40440,736 +40440,603 @@ namespace vl::workflow { void WorkflowParserData(vl::stream::IStream& outputStream) { - static const vl::vint dataLength = 185138; // 3433199 bytes before compressing + static const vl::vint dataLength = 151080; // 2617385 bytes before compressing static const vl::vint dataBlock = 256; - static const vl::vint dataRemain = 50; - static const vl::vint dataSolidRows = 723; - static const vl::vint dataRows = 724; + static const vl::vint dataRemain = 40; + static const vl::vint dataSolidRows = 590; + static const vl::vint dataRows = 591; static const char* compressed[] = { - "\x00\x00\x10\x00\x2F\x5D\x00\x00\x73\x00\x01\x82\x80\x08\x23\x82\x81\x82\x06\x89\x82\x92\x1A\x87\x1A\x84\x1E\x0A\xD1\x0A\x95\x2A\x81\x2E\x84\x2F\x0A\xE7\x4A\x96\x7A\x84\x7E\x84\x04\x01\x09\x97\x01\x96\x80\x10\x93\x81\x35\x27\x82\x9B\x1A\x91\x81\x21\x96\x00\x47\x30\x8D\x20\x9D\x28\x99\x2D\x30\xDE\x30\x84\x30\x9C\x34\x98\x38\x30\xFE\x30\x83\x40\x9E\x48\x98\x51\x30\xA7\x70\x9E\x50\x99\x60\x98\x66\x30\xE0\x70\x88\x02\x01\x85\x09\xAA\x06\x9B\x18\xA3\x82\x13\xAE\x81\x15\x5E\x81\xB2\x01\xB0\x00\x1C\xB2\x1F\x64\xC2\x24\xAC\x24\xB3\x28\xB2\x2D\x64\xE3\x24\xAC\x34\xB1\x3C\xB3\x3E\x64\x85\x64\xAA\x44\xB5\x48\xB3\x4C\x64\xA2\x64\xAE\x54\xB1\x58\xB2\x5C\x64\xC1\x64\xB0\x64\xB7\x68\xB2\x6F\x64\xEF\x64\xB6\x74\xB7\x7C\xB3\x04\x03\x09\x98\x19\xC6\x84\x0C\xCF\x81\x20\x1F\xC2\x84\x12\xD1\x83\x15\xD2\x00\x31\x28\xC3\x18\x3D\x97\x7F\xD7\xB0\xAF\xCA\x80\x01\xD9\xDB\xD9\xDA\xB0\xB7\xF8\xDF\x7A\xD8\xDD\xDF\xDA\xBF\xB6\xCA\x9B\xDC\xDB\xE3\xDD\xE0\xB9\xC6\xFE\xCA\xE0\xE4\xE6\xE1\x84\xC4\xC8\xF2\xCE\xE9\xE0\xEB\xE2\xEA\xD3\xD6\xCB\xF3", - "\xD9\x80\x98\xDB\xEB\xDA\xCD\xE1\xEF\xE6\x81\xE8\xED\xE2\xE3\xD5\xE5\xE0\xFB\xF3\xEE\x82\xEF\xDE\xE6\xE9\xF9\xE6\x84\xB0\x00\xEF\xA8\xF7\xCA\x84\x0A\x86\xED\x03\xFE\x0A\x46\x00\x81\x42\x07\x03\x86\x40\x02\x06\x83\x49\x01\x82\x02\x4A\x0C\x81\x40\x0B\x0F\x80\x00\x03\x12\xB2\x7D\x7A\x78\x17\xA4\x73\x42\x85\x1B\xAC\x7D\x86\x7B\x1F\x98\x81\x8A\x86\x02\x5C\x85\x8A\x87\x27\xA0\x89\x8A\x88\x2B\xA4\x81\x42\x89\x2F\xA8\x81\x8E\x8A\x33\xAC\x85\x8E\x8B\x00\x0D\x05\x86\x8C\xDF\x74\x8D\x8E\x8D\x00\x0E\x0B\x8E\x8F\x30\xBF\x88\x8D\x91\x48\xBC\x89\x90\x91\x4A\x8D\x9C\x93\x93\x40\x8B\x91\x96\x93\x53\x90\x97\x90\x95\x57\x96\x9A\x7B\x88\x5B\xAD\x8D\x97\x8D\x5F\x86\x91\x9A\x94\x59\x95\x96\x99\x99\x68\xA3\x98\x96\x9A\x5A\xB4\x7C\x96\x9B\x5E\xB0\x90\x9A\x9C\x62\xB4\x94\x99\x98\x0F\x03\x97\x98\x9B\x7B\xB6\x9B\x9A\x9F\x6D\xA8\x79\x84\x9F\x69\x80\xAD\x9E\xA0\x6F\x88\xA1\x9E\xA2\x73\x8C\xA5\x9E\xA3\x77\x86\xA5\xA0\xA4\x7F\x94\xA1\xA2\x74\x96\x87\xA8\xA7\xA6\xE7\x5C\xA3\x7D\xA6\x93\x9E\xA3\xA2\xA4\x84\xA5\xA4\xAB\xA9\xA0\xA6\xA9\xA8\xAA", - "\xA2\x89\xAD\xAB\xA2\xAF\x8D\xA1\xAF\xA3\xB3\x91\xAB\xAB\xAD\xB5\x95\xA9\xAF\xA5\x9D\xBD\xAF\xA7\xAE\x9A\xBE\xA3\xA8\xAE\xC2\xAE\xA5\xB0\xAC\xC7\xB2\xA9\xB0\xAD\xCB\xB6\xA0\xB1\xA8\xCD\xBA\xA1\xB4\xAF\xBF\x93\xB1\xB1\xB5\xD8\x83\xBF\xB2\xAA\xDB\xAC\xA6\xB4\xB4\xD9\x86\xB1\xB8\xB2\xE3\x8A\xB5\xB8\xB3\xE7\x8E\xBF\xB4\xB7\xEB\x9E\xB9\xBA\xB4\xEF\x94\xBA\xB5\xBB\xC4\xB1\xB7\xB7\xBC\xF6\xA0\xB8\xBF\xBE\xE2\xBC\xB4\xBA\xBF\xE6\x80\xC8\xBA\xC0\xEA\xB9\xBC\xBA\xC1\xEE\x84\xC0\xBE\xC2\xF2\xBD\xBE\xC3\xBF\x0F\xC1\xC1\xC7\xC0\x13\xC5\xCC\xC3\xBD\x15\xCB\xC9\xC5\xC3\x10\xDD\xC2\xC6\xC7\x14\xE0\xC6\xC7\xC6\x18\xE2\xCA\xC6\xC9\x1C\xDF\xCA\xC9\xC8\x2B\xE3\xC8\xC9\xC9\x2D\xE7\xC1\xCD\xCA\x2C\xF5\xCE\xCB\xCC\x30\xF6\xC2\xCE\xCE\x34\xC5\x90\x06\x9E\xFA\xA4\xC1\xD3\xCB\x38\x91\x02\x86\x04\x01\xB4\xBD\xB5\xBD\x17\xC3\xD8\xCE\xD3\x3C\xF9\xC7\xCD\xD4\x50\xD3\xD6\xD7\xCE\x57\xFD\xC8\xD7\xD6\x5A\xDD\xD2\xD4\xD7\x5F\xDE\xD5\xD4\xD8\x63\xE2\xD7\xC1\xD3\x67\xC2\xD9\xD8\xD1\x6B\xCF\xDD\xD8\xD5\x6F\xD9\xD1\xDB\xDC\x65\xF4\xD1\xDC\xD9\x77", - "\xE6\xD9\xC2\xDA\x7B\xEC\xDD\xDE\xDB\x7F\xF0\xD1\xE2\xDC\x75\xC5\xE9\xDE\xDD\x83\xFC\x88\x06\x84\x19\x09\xD8\xC0\xD3\x7C\xD0\xEE\xDE\xE4\x80\xD4\xE2\xE2\xE5\x84\xC7\xE6\xE1\xE2\x7A\xD8\xE8\xDC\xE7\x88\xDE\xED\xE7\xD2\xA4\xCA\xD6\xEB\xE3\xA5\xE8\xE7\xE8\xDA\xA0\xDB\xE2\xE9\xE8\xA9\xEC\xEF\xEA\xEB\xB1\xD1\xE5\xEF\xE4\xB7\xD5\xE9\xEF\xE5\xBB\xD9\xED\xEA\xE6\xC0\xFF\xE2\xF3\xEC\xC1\xC4\xF3\xF1\xEF\x3B\xDF\x02\x84\x08\x8E\xF2\xE8\xF3\xE8\xAB\xF6\xE1\xF4\xEE\xD3\xFA\xE5\xF4\xEF\xD7\xFE\xE6\xF3\xF6\xCF\xF0\xE9\xF7\xE7\xDC\xDF\xF0\xF6\xEA\xE4\xCE\xF2\xFA\xF7\xE5\xD2\xF9\xF8\xF5\xEB\xD6\xFD\xF8\xF6\xEF\xDA\xFD\xF4\xED\xE7\xF4\xF1\xFC\xF8\xF3\xC5\xF9\xFF\xF1\xF5\xFA\xFD\xFC\xFF\xF7\x63\x7E\xF9\x01\x88\x7D\x01\x86\x82\x7D\x06\x26\x04\xD0\x7E\x74\x80\xFB\x46\x27\x04\x0B\x81\x70\x0A\x12\x49\x04\x09\x6A\x02\x42\x2B\x12\x40\x0B\x12\x4D\x04\x09\x6E\x02\x42\x2F\x12\x40\x0C\x12\x41\x06\x09\x4C\x25\x3B\xFF\x61\x7D\x03\x8C\x87\x80\xF6\x6D\x86\x7D\x06\x33\x05\x04\xAA\x86\x20\x1A\x33\x83\x7F\x34\x88\x82\x0E\xAE\x8B\x86\x18\xBD\x80", - "\x7E\x2F\x80\x8B\x0F\xF2\x79\x84\x1C\x86\x8D\x88\x48\x89\x21\x0D\x37\x89\x89\x20\x84\x8B\x85\x00\x8E\x88\xFE\x4D\x83\x89\x9D\x76\x04\x89\x50\x96\x72\x43\x28\x8F\x7C\x1C\x18\x8A\x60\x39\x12\x42\x0E\x12\x4B\x06\x09\x50\x24\x8B\x06\x3D\x06\x84\x3E\x02\x43\x1F\x12\x40\x08\x12\x41\x0A\x84\x42\x02\x43\x21\x1F\x8D\x8A\x02\x98\x8D\x01\xFA\x8E\x81\x1F\x84\x0F\x8E\x3C\x82\x21\x11\x00\x9E\x87\x40\x85\x97\x90\x42\x86\x91\x22\x88\x9F\x88\x29\xB9\x8A\x91\x8D\x9C\x8C\x0B\x92\x91\x8A\x4A\x96\x76\x08\x84\x8B\x92\x26\x91\x90\x93\x29\x99\x8F\x88\x9F\x94\x89\x27\x8F\x98\x91\x23\x19\x94\x93\x8C\x9E\x92\x23\xFB\x83\x94\x56\xA9\x94\x94\x9B\x8A\x96\x25\xA0\x9B\x95\x3E\xAD\x96\x96\xAF\x8E\x95\x2C\xB0\x98\x95\x5D\xBA\x95\x97\xC0\x92\x97\x2D\x93\x93\x99\x4A\x85\x99\x87\xC7\x93\x54\x42\x6F\x3A\x21\x24\x0D\x7B\x96\xA2\x99\x94\x2E\xBE\x93\x9B\x60\xBC\x92\x98\xD2\x84\x99\x36\xC6\x9B\x9A\x64\x9D\x9C\x96\xD0\x81\x96\x38\xB5\x9A\x9A\x6A\xA5\x9E\x9A\xBF\x98\x9A\x39\xDC\x9B\x9C\x6F\xAD\x98\x9C\xC9\x91\x9B\x3B\xF2\x98\x9D\x6A\xAA\x9D\x9E\xE7\x97", - "\x9E\x3E\xD7\x9C\x9F\x74\xBD\x9E\x9E\x3E\x4F\x0B\x29\xFB\x9E\x9F\x82\x80\xA6\xA0\xF9\x9F\x9D\x42\x88\xAC\x9C\x7C\x8D\xA4\xA0\x07\xB1\xA3\x42\x92\xAF\xA0\x85\x95\xA4\xA1\xEE\x8E\xA1\x46\x90\xA3\xA3\x8E\x97\xA4\xA2\x1B\xBE\x44\x14\x12\x42\x23\x84\x02\x43\x9C\xE1\x84\x9F\x47\x9E\xA1\xA4\x8C\xB0\x9F\x9B\xF4\x9C\xA3\x4A\xB3\xAD\xA4\x90\xAF\xA3\x9E\x28\xB1\x9D\x4E\xB0\xAB\xA6\x9C\xAA\xA5\xA6\x2C\xB7\xA6\x46\xC2\xA2\xA6\xA0\xB4\xA4\xA8\x16\xA6\xAA\x52\xB7\xA7\x0A\x09\x58\x0F\x99\x3A\xBF\xA4\x52\xAE\xA1\xA7\xA4\x93\xAE\xA6\x55\xB4\xA9\x4F\xC3\xA9\xAA\xAC\x9B\xAD\xA8\x57\xA1\xA9\x57\xE2\xAF\xAA\xAB\xA3\xAF\xA8\x67\xAB\xA9\x5A\xE1\xA8\xAD\xB2\x9A\xAA\xAA\x6B\xB1\xAE\x5B\xDE\xA0\xAF\xB9\xAF\x68\x23\x68\x89\xA6\x5E\x8A\x9F\x0A\x09\x60\x09\x93\x61\x12\x42\x18\x12\x43\x0C\x09\x64\x0A\x42\x65\x12\x42\x19\x12\x47\x0C\x09\x68\x0A\x42\x69\x12\x42\x1A\x12\x4B\x0D\x81\xA6\xAE\xAE\x6D\xB5\xAE\x66\x83\x2C\x0C\xCB\xB9\x65\x0D\x9E\xB4\xAF\x5E\xBC\xAB\xB3\xA8\xA3\xB6\xA7\xA7\xBC\xA8\x66\xEA\xAB\xB5\x9B\xAE\x09\xB4\x64\xA5\xB4\x69\xA9", - "\xB0\xAC\xB9\xB2\xB5\x66\x6F\x10\xB5\x66\xA7\xB0\x0E\xDD\x8E\x51\x0E\x12\x52\x0E\x84\x00\x29\xAE\x81\x34\x0A\x42\x75\x12\x42\x1D\x12\x47\x0E\x09\x78\x0A\x42\x79\x12\x42\x1E\x12\x4B\x0E\xDF\xAC\xAC\xB5\xB7\xAA\xB5\x10\xFC\x06\xBB\x65\x7D\x0D\xBB\xAD\xB6\xB4\x6D\x97\xB9\xBB\xDA\xA1\xBF\xBC\xE5\xA4\xBF\x78\xB9\x6E\x0E\xF0\xA9\xBF\xAD\xEB\xA2\xB6\x69\xF3\xB3\xB6\x90\x7F\x0E\xBD\xF1\xA5\x9C\x20\x78\xB2\x21\x40\x12\x42\x10\x12\x43\x12\x84\x04\x12\x43\x42\x12\x46\x10\x12\x47\x12\x84\x08\x12\x43\x44\x12\x42\x11\x12\x4B\x10\x7F\xF5\xB4\xC2\xD4\xB4\xBE\xC2\x2B\x6C\x13\x84\xB5\x6D\x11\x0D\xDA\xB9\xBF\xBB\xB7\xC3\x87\xA2\xC6\xBD\xF7\xB2\xBD\xC2\x23\xD5\xC2\x23\x1E\xC5\xC5\x89\x4F\x12\x42\x90\x10\xA8\x8A\xAD\xC4\xC4\xF5\xB5\xC0\xBE\x37\xC7\xC4\x86\xBB\xC9\xC4\x1E\xF4\xC3\xC6\x36\xC0\xC8\x8E\xC2\xCA\xC7\x1E\xC6\xCF\xC7\x3E\xC1\xC9\x92\xC3\xCB\xC9\x22\xC8\xCF\xC8\x4A\xD0\xC8\x93\xD2\xCE\xC9\x28\xC8\xCE\x12\x2C\xD6\xCA\x96\xD3\xCF\xC9\x2E\xDB\xCD\xCA\x5C\xDF\xC9\x6C\xA0\xC8\xBA\x32\xD7\xBF\xCC\xE2\xB9\xC7\x98\xEA\xC1\xC4\x22", - "\xEB\xCE\xCD\x6D\xCD\xCB\x9B\xF2\xC1\xCE\x2A\xF3\xCD\x97\x97\x19\xC8\x93\x98\x1A\xCE\x30\xFE\xCF\xCE\x5E\xC1\xCE\xA0\xFF\xC5\xCF\x40\xC4\xD5\xCC\x6C\xC8\xD0\x9C\x8A\xD4\xCE\x46\xF6\xCD\xD0\x62\xD0\xD3\xA0\x80\xD1\xD2\x47\xC6\xD4\xD2\x93\xD1\xCD\x26\x7D\xC8\xD3\x43\xE8\xC8\xBD\x66\xC9\xCF\xA2\x9F\xD6\xC5\x4E\xE6\xD2\xD2\x9E\xC2\xD5\xA3\xA4\xD1\xD4\x50\xC9\xD4\xD5\xAF\xCB\x5A\x26\x12\x4B\x12\x19\xEB\xD2\xD5\x8F\xD6\xD1\xA5\xB0\xD3\xD4\x5C\xD7\xD0\xD5\xA7\xDA\xD5\xA6\xC2\xD9\xD4\x57\xFD\xD6\xD8\xB7\xC8\xD9\xAE\xBC\xD9\xD9\x52\xC0\xDF\xD9\xC4\xC1\xDB\x6C\x21\x12\x42\x51\x36\xD3\xD9\xBE\xDB\xD5\xB6\xC3\xDC\xD8\x6C\xCA\xDF\xD7\xD1\xD0\xD9\xB7\xE0\xD3\xDC\x6D\xDF\xDE\xDC\xCE\xC1\xDE\xBA\xE5\xDC\xDB\x6D\xC5\xD9\xDD\xEC\xD8\x44\x2A\x12\x49\x15\x6B\xE4\xDE\xDD\xD2\xD8\xDE\xB8\xFA\xDB\xDC\x7E\xF1\xD9\xDF\xE7\xCD\xDD\xC0\xEF\xDD\xD4\x78\xFE\xDF\xE0\x03\xE0\xE2\xC1\x89\xEB\xDE\x86\xFD\xDE\xE1\xFF\xCD\xE3\xC2\xB7\xBF\x14\x4E\xD2\xE3\x62\xB0\x1B\xC1\x2C\x12\x42\x16\x09\x73\x12\x42\xB4\x12\x41\x2D\x12\x46\x16\x09\x77\x12\x42", - "\xB8\x12\x41\x2E\x12\x4A\x16\x09\x7B\x16\xE2\x0F\xF3\xE1\xC1\xA7\xBC\x16\x98\xF3\x35\x17\x36\xE8\xE2\xCC\xB1\xD0\xE2\x9D\xF3\xE4\xE7\x3B\xE7\xD9\x10\xBE\x19\xE6\x64\xFF\x12\x42\xC0\x16\xDC\xBA\xBF\xE2\xE8\xA6\xCD\xDE\xE9\xDE\xC1\xEB\xD3\xC0\xE0\xEB\x7B\xFD\xE7\xEA\x52\xF1\xE9\xD5\xCB\xE4\xEB\xAE\xCD\xEE\xEB\x53\xFF\xEA\xD8\xE1\xE4\xEC\xAD\xE0\xEE\xEC\x63\xE8\xEE\x26\xC6\x15\xE9\xAC\xD6\xEE\xED\x5C\xE9\xEF\xDB\xDB\xE2\xE0\xB8\xF5\xEC\xEE\x04\xE7\xEF\xDC\xFA\xE1\xEF\xB2\xFB\xEA\xEE\x7D\xEA\xEE\xE0\xFF\xEE\xEE\x58\x87\x1D\xED\x78\xEA\xE1\xE2\x97\xEC\xEF\xBB\xCD\xF1\xEF\x80\xEE\xF1\xE4\x90\xF5\xF0\xC9\xD5\xF4\xF2\x83\xE1\xF0\xE1\xD3\x68\x18\x09\x49\x1A\xE9\x96\xF9\xF1\xE8\x9B\xF4\xF4\xCD\xE6\xF3\xF4\xA7\xF8\xF1\xE9\xA8\xFC\xF4\xD5\xE9\xF2\xF1\x8F\xF0\xF7\xE4\xB2\xF7\xF2\xDA\xE2\xF3\x9A\xCF\x12\x40\x34\x20\xFE\xF5\xD6\xF6\xF3\xF5\xBD\xE1\xFB\xEF\xAF\xFC\xF1\xD9\xC5\xFD\xF6\xC7\xF7\xF7\xF0\xBE\xF9\xF8\xE0\xCB\xFA\xF8\xCD\xE4\xF9\xCC\xBF\x86\x1A\x09\x57\x1C\xF7\xCF\xF9\xF9\xF4\xCC\xF3\xFB\xD8\xDB\xF8\xFA\xDD\xE6\xF9", - "\xF8\xC8\xF3\xFC\xE5\xDF\xFA\xFB\xE5\xEE\xFB\xF9\xEB\xF9\xFC\xE9\xD1\xE6\x9D\xDD\x12\x42\x37\x58\xFC\xFD\xF7\xF6\xFE\xE7\xDE\xED\xFC\xF7\xF7\xF8\xEB\xC5\xFA\xF8\xFC\xFC\x76\x77\x00\x88\x7F\xE2\x71\x80\xFE\x76\x80\xF9\x78\x80\x63\x74\x0E\x12\x25\x0E\xF4\x7F\x7F\xE8\x7A\x80\xE4\x72\x81\xE6\x70\x81\xF5\x74\x80\x13\x88\x81\x15\x84\x81\xEA\x76\x81\x1E\x8C\x81\xEE\x7A\x81\x1D\x80\x82\xFB\x72\x82\x21\x8D\x7F\x09\x86\x82\x25\x88\x82\x05\x8A\x82\x03\x8C\x82\x19\x80\x83\x1B\x8E\x82\x11\x84\x83\x17\x82\x83\x23\x8A\x10\xEB\x08\x78\x60\x7C\x0E\x12\x2D\x0E\x0F\x84\x82\x2F\x82\x80\x35\x88\x83\x27\x84\x84\x37\x88\x84\x1F\x86\x83\x4B\x86\x84\x2B\x8A\x84\x42\x85\x84\x50\x8C\x84\x51\x89\x84\x3F\x43\x0F\x12\x24\x0F\x41\x84\x85\x5C\x8E\x84\x43\x87\x80\x5D\x83\x85\x5E\x82\x85\x60\x83\x86\x56\x89\x82\x66\x8D\x84\x62\x8B\x86\x65\x8C\x86\x68\x8E\x86\x2D\x89\x86\x55\x83\x7E\xFA\x0C\x83\x88\x4B\x0F\x1B\x6E\x11\xC5\x58\x48\xFD\x02\x21\xFE\x05\x21\x12\x2A\x1F\xCC\x4D\x1D\x30\x1E\x1D\x02\x05\x88\x0A\x13\x00\x88\x89\x10\x04\x0B\x88\x06\x15", - "\x00\x8E\x83\x10\x06\x01\x89\x02\x17\x00\x94\x81\x87\x70\x81\x83\xB7\x50\x12\x7B\x8B\x63\x09\x07\x89\x9A\x8D\x86\xA2\x8F\x86\xA3\x88\x89\xA5\x81\x8A\x60\x7A\x00\xA0\x83\x83\x72\x81\x86\xA7\x8C\x8A\xB7\x5B\x00\xAB\x89\x83\xAD\x85\x8B\x99\x80\x8B\xAF\x84\x8B\xB7\x8A\x8B\xB9\x87\x84\xBD\x8F\x84\xBF\x8F\x85\xA4\x8A\x48\x0C\x00\x8A\x0D\x00\x13\x27\x5B\x8B\xBE\x83\x8C\xA6\x8C\x8C\xA8\x8D\x8C\xD0\x8F\x8C\xD2\x88\x8B\xCE\x84\x8D\xD1\x86\x8D\xD3\x8C\x8B\xD5\x8A\x8D\xD7\x8C\x8D\x3B\x63\x01\xA0\x84\x01\xC8\x8E\x8A\xDB\x8B\x8C\xDD\x86\x8E\xD9\x88\x8E\xD8\x8B\x8E\xDE\x8C\x8E\xEA\x8D\x8E\xF0\x8F\x8E\xF2\x80\x8C\xE5\x84\x8F\xD1\x8A\x01\xA0\x8B\x01\xE3\x86\x8B\xC1\x84\x86\xF5\x82\x8C\xE7\x86\x8F\xE9\x82\x90\xEE\x84\x90\xF1\x86\x90\xF3\x80\x90\x03\x9A\x90\x05\x9C\x90\x07\x9E\x90\x09\x9E\x8F\x01\x9A\x63\x21\x03\x8B\x11\x97\x86\x13\x92\x91\x0B\x9A\x91\x0D\x9C\x91\x0F\x9E\x91\x17\x9A\x86\xFD\x88\x91\x1B\x94\x92\x53\x32\x02\x16\x98\x90\x2A\x90\x91\x2B\x90\x92\x2D\x96\x92\x1F\x90\x93\x21\x93\x87\x34\x94\x8E\x19\x92\x93\x2F\x92\x92", - "\xFF\x8E\x92\x2C\x9D\x93\xB4\x73\x02\x29\x9E\x93\x38\x92\x94\x3A\x97\x93\x45\x95\x92\x47\x9D\x91\x43\x9C\x93\x4C\x9B\x94\x4E\x99\x94\x31\x90\x95\x33\x96\x93\x9A\x44\x02\x41\x9D\x94\x52\x99\x93\x35\x9C\x8F\x3B\x9F\x94\x5B\x9A\x8C\x5A\x94\x95\x4A\x99\x95\x44\x9F\x95\x23\x94\x96\x58\x96\x96\x5D\x9E\x28\x25\x07\x95\x5E\x92\x96\x51\x9A\x96\x46\x92\x97\x48\x94\x97\x63\x96\x97\x71\x90\x97\x53\x9C\x95\xD1\x86\x02\x6E\x98\x96\x6F\x9C\x97\x75\x9A\x97\x61\x92\x98\x77\x94\x98\x65\x98\x98\x69\x9A\x98\x81\x90\x96\x89\x96\x98\x79\x90\x99\x7B\x9E\x98\x8B\x99\x10\x27\x0F\x97\x78\x93\x99\x67\x99\x99\x85\x94\x99\x8D\x9B\x99\x8C\x90\x98\xA2\x9C\x99\x8F\x9E\x99\x96\x38\x02\xA0\x89\x02\xFB\x86\x9A\xA4\x95\x99\xAC\x91\x9A\xAD\x9F\x99\x6B\x91\x9B\xA3\x90\x9B\xB6\x92\x99\x9D\x90\x9A\xB8\x95\x9A\xBA\x9F\x9A\xBB\x9E\x9A\xBD\x97\x5A\x2F\x08\x99\xB7\x9E\x9B\xC6\x91\x9C\xB3\x95\x9C\xC8\x93\x97\xCA\x99\x9C\xBF\x92\x9B\xCC\x9F\x9C\xB5\x92\x9D\x37\x50\x03\xC4\x94\x9D\x0A\x11\x03\xD7\x92\x30\x32\x00\x8A\x33\x00\x8A\x34\x00\x8A\x29\x1D\x89\x36", - "\x00\x8A\x37\x00\x8A\x38\x00\x8A\x39\x00\x8A\x3A\x00\x8A\x2C\x1D\x89\x3C\x0B\x9D\xCB\x93\x98\x30\x8D\x03\xF2\x9A\x48\x3E\x07\x9F\xD1\x97\x9C\xCE\x9C\x9F\xFB\x93\x9F\x87\x99\x10\x3F\x0A\x9F\xF4\x97\x5B\x40\x00\x8A\x2F\x1D\x89\x01\xAE\x9F\x35\x32\x04\x04\xAD\x4B\x43\x04\xA0\x44\x04\xA0\x45\x0F\xA0\x91\x9C\xA0\x3D\x66\x04\xA0\x82\x13\x9D\x88\x04\xA0\x89\x04\xA0\x8A\x04\xA0\x8B\x04\x04\xAC\x04\xA0\x84\x13\x09\x19\x1F\xBD\x40\x05\x30\x16\x1F\x52\x0D\xA2\x0A\x14\x05\xA0\x86\x13\x9D\x86\x05\x16\xAE\x23\x57\x00\x8A\x58\x07\xA3\xB9\x9D\x9F\x00\xA8\x64\x59\x00\xA3\x09\x18\x13\x09\x16\x1F\x0B\xA7\x5A\x5D\x0C\xA3\x50\x3A\x13\x9D\x8F\x05\xA0\x80\x06\xA0\x81\x06\xA0\x82\x06\xA0\x83\x06\xA0\x8C\x13\x0A\xA7\xA1\x3F\xAA\x99\x3E\xAD\xA5\xFF\x9E\xA5\x05\xAB\xA5\x3D\xAF\xA5\x64\xA1\xA6\x60\xA7\xA4\x67\xAA\xA5\x69\xA8\x8E\x65\x0A\xA4\xC0\x9B\xA6\x96\x76\x06\x6E\xA0\x9D\x66\xA5\xA6\x68\xA6\xA7\x6A\xA8\xA7\x5C\xAA\xA7\x63\xA5\xA7\x7E\xA7\xA7\x7F\xA9\xA7\x35\x37\x06\xA0\x88\x06\x73\xA3\x9D\x0C\xA9\x06\x87\xAB\x3B\x6A\x04\xA0\x6B\x04", - "\xA0\x3E\x19\xA5\x7B\xA1\xA8\x7D\x7D\x06\xA0\x8E\x06\xA0\x8F\x06\xA0\x80\x14\x9D\x81\x07\xA0\x82\x07\x04\xA3\x07\xA0\x84\x07\x30\x1A\xA2\xEA\x47\x07\x42\xA6\x10\x79\x09\xAA\x03\x1B\x07\xA0\x8C\x07\xA0\x8D\x07\x8B\xAA\x10\x42\x1D\x89\x7F\x03\xAB\xD8\x99\xAB\x18\xAB\x33\x80\x0C\xAA\x02\x12\x08\xBE\xAC\xA7\x3A\x64\x08\xB8\xA2\x30\x85\x00\x8A\x86\x00\x8A\x87\x00\x8A\x88\x00\x8A\x89\x00\x8A\x8A\x00\x8A\x8B\x05\xAC\x03\x1C\x08\xD4\xA0\xA7\xBC\x98\xAD\x6F\xA2\xAC\xDB\xA4\xA9\x7D\xA0\xA8\xE0\xA2\xA8\xE1\xA3\xA9\xE3\xAF\xAD\xE2\xA7\xAE\xE4\xA8\xAE\xE6\xA9\xAE\xEC\xAB\xAE\xEE\xA9\xAD\xDC\xA4\xA7\xE5\xA0\xAF\xDE\xA4\xAF\xF3\xA4\x7B\x8D\x07\xAD\xF1\xA8\xA8\x62\xA6\xAF\xEA\xAE\xAF\xED\xA0\xB0\xEF\xAD\xAD\xF7\xA2\xAF\xFF\xA4\xB0\x07\xB6\xB0\x01\xB8\xB0\x3E\x2E\x08\xA0\x8F\x08\xFA\xA5\xAF\x1A\x90\x09\x11\xB3\x35\x91\x04\xA0\x92\x04\xA0\x93\x05\xB1\x09\xBC\xAF\x8A\x44\x09\xA0\x85\x09\xA0\x86\x14\x9D\x87\x09\xA0\x88\x09\xA0\x89\x09\x04\xAA\x09\xA0\x8B\x09\xA5\xA2\x4F\x9E\x01\xAC\x00\x00\x0A\x32\xB8\x14\x9D\x83\x0A\xA0\x84\x0A", - "\x11\xB5\x0A\xA0\x86\x0A\x1C\xBB\xB0\x0A\xB3\xB0\x74\x2A\x14\x45\xAA\x10\xA9\x02\xB3\x05\xBE\x4E\xAB\x0F\xB3\x40\x2C\x0A\xA0\x8D\x0A\xA0\x8E\x0A\xA0\x8F\x0A\xA0\x80\x0B\xA0\x81\x0B\xA0\x82\x0B\x11\xB3\x0B\x4C\xB2\xB0\x5E\xBC\xB0\x42\xBE\xB1\xFB\xA4\x9B\x64\xBD\x9C\x63\xB6\xB6\x12\xB1\xB4\x5F\xBA\xB6\x60\xBB\xB6\x62\xB2\x8D\xB4\x0D\xB5\x6D\xB3\xB7\x6C\xB5\xB7\x6F\xB9\xB4\x65\xBA\xAB\xFD\xA4\xB7\x77\xBD\xB1\x79\xBB\xAB\x40\xBD\xB7\x81\xBF\xB7\x7B\xB6\xB7\x84\xBE\x8C\xB5\x02\xB7\xC7\x76\x0B\x8A\xB2\xB8\x61\xB7\xB8\x67\xBA\xB7\x8A\x47\x0B\x8D\xB3\x1B\xB8\x05\xB9\xD7\x39\x0B\x98\xB2\xB9\x91\xB0\xB8\x8F\xB8\xB6\x78\xB0\xBA\x7E\xB2\xBA\x83\xB4\xBA\x9F\xBC\xB9\x69\xBE\xB8\x6E\xB0\xB9\xA9\xBC\xBA\xA1\xB8\xBA\xAF\xBE\xB9\xAB\xB6\xBA\xB3\xB0\xBB\xA3\xB6\xBB\xA5\xB2\x98\xBA\x0B\xB9\x52\x7B\x0B\xBC\xB5\xB8\xAA\xBC\xB7\xAE\xB7\xBB\xB2\xB2\xBC\xB4\xB6\xBC\xB8\xB7\xBA\xC5\xB6\xB8\xC7\xBC\xBC\xC9\xB5\xBB\xCB\xB7\x94\xBC\x0F\xBB\xDA\xAE\xBC\xD1\xB3\xBC\xB9\xB7\xBD\xCD\xB1\xBC\xD6\xB0\xBC\xD8\xBA\xBC\xDE\xBB\xBD\xDF\xB4\xAF\xBD", - "\x04\xA0\x4C\x12\xA9\xE0\xB5\xBD\xDC\xBB\xBE\xE3\xB8\xBC\xDA\xBF\xBC\xEE\xB1\xBE\xF0\xBD\xBD\xEA\xBD\xBE\xF4\xBD\xB9\xF2\xBF\xBE\xFA\xB9\xBF\xFC\xB5\xBF\xE2\xBF\xBF\xF3\xBC\xBE\x68\xBF\x0B\xD4\xB8\xBF\xFE\xB1\xC0\xF6\xBE\x28\xC0\x05\xC0\xAD\xB0\xC0\xFB\xB7\xC0\x0F\xC6\xC0\x12\xCD\xC0\x08\xCE\xC0\xFD\xB3\xC1\x4E\x18\xBE\xD0\xB7\xC1\x14\xC1\xC1\x1D\xCC\xC1\xB1\xB0\xC2\xC4\xB2\xC2\xD9\xB4\xC2\xE9\xB3\xC1\x21\xC0\xC1\x26\xCB\xC1\x2A\xCE\x8C\xC2\x0C\xC0\x29\xC8\xC2\x23\xCD\xC2\x32\xC5\xC2\x34\xCF\xC1\x37\xC1\xC3\x38\xC5\xA6\xC3\x00\x8A\xC4\x00\xC3\x33\xC5\x61\xC5\x00\xC4\x3E\x26\x0C\x04\xA7\x0C\x04\xA8\x0C\x44\xC7\xC2\x3B\xC0\x00\xC9\x00\x8A\xCA\x00\x8A\xCB\x00\x8A\x50\x1D\x89\xCD\x00\x8A\xCE\x04\xA0\xCF\x00\x8A\xD0\x0F\xB2\x3D\x53\x0D\x32\xB5\x0D\x32\xB7\x0D\xA0\x88\x0D\xA0\x89\x0D\x11\xBA\x0D\xA0\x8B\x0D\x4B\xCC\xC2\x35\xC2\x90\xDC\x02\xB3\xDE\x08\xB4\x41\xCA\x49\x52\x1A\xC1\xE5\x41\x0E\xA0\x82\x0E\xA0\x83\x0E\xA0\x84\x0E\xA0\x85\x0E\xA0\x86\x0E\xA0\x87\x0E\x11\xB8\x0E\x6D\xC1\xBF\x39\xC5\xC7\x3A\xCD\xC8\x8C\xCF", - "\xC8\x36\xCF\xC6\x6E\xCD\xC4\x8E\xC1\xC9\x94\xC0\xC9\x4C\xC5\xC9\x99\xCB\x33\xE9\x09\xC8\xF7\xB7\xC9\x96\xCA\xC9\x93\xC2\xCA\x8A\xC2\xC9\xA5\xC0\xCA\x9B\xC1\xCA\x98\xC3\xCA\xEA\x4A\x0E\x9E\xC2\xC0\x15\xC1\xCB\x1E\xC4\xCA\x9F\xC4\xCB\xB0\xC3\xCB\xAB\xC7\xCA\xB6\xC9\xC0\xB3\x2B\x0E\xAF\xCC\x6C\xEC\x01\xB1\xED\x00\x8A\xEE\x00\x8A\xEF\x00\x8A\xF0\x00\x8A\xF1\x00\x8A\xF2\x00\x8A\xF3\x00\x8A\xF4\x00\x8A\xF5\x00\x8A\xF6\x00\x8A\xF7\x0F\xCB\x16\xC0\xA6\xF8\x0C\xC0\xF9\x08\xCD\xB2\xCB\xC2\xBA\xC9\xCB\xB5\xCC\x23\xFA\x0E\xCD\x0C\xAB\x0F\xA0\x8C\x0F\xE6\xC0\xCE\xEC\x4D\x0F\xEB\xC2\x10\xFE\x0F\xA0\x04\xA0\x00\x64\x11\x1F\xE2\xC7\xCB\x3F\x41\x00\xF5\xCA\x10\x02\x0B\xCF\x29\xAE\xCF\x06\x14\x00\x00\xD3\x10\x05\x03\xD0\x02\x16\x00\x06\xDB\x32\x07\x09\xD0\x00\x04\x15\x29\xA2\x4F\x0B\x04\x16\xF6\x1D\x00\x12\xDA\x10\x0F\x0C\xD0\x10\x0C\xD0\x57\x18\xC7\x81\x32\x01\x0C\xD3\x01\x0C\xDB\xCB\xD9\xC3\xC1\x14\x05\xD1\x09\x16\x01\x26\xD8\xCB\xB0\x48\x01\x21\xDA\x4E\x19\x0C\xD0\x1A\x0C\xD0\x5A\x1D\x89\x1C\x0C\xD0\x1D\x0C\xD0\x1E\x0C\xD0", - "\x1F\x0D\xD2\x34\x30\x02\x3C\xD9\xCA\x40\xDC\xCA\xAA\xC3\xD4\x41\xD1\xCE\x44\xD2\xD4\x45\xD3\xCE\x47\xD6\xD4\x49\xD8\xCF\x8B\xCB\xD4\x4A\xD9\x33\x21\x0F\xD3\x48\xD5\xD5\x4C\xD6\xD5\x51\xD8\xD5\x4E\xD6\xCA\x59\xD7\xD5\x5E\xDD\xD5\x60\xDB\xD5\xA8\xCA\xD5\xBC\xC3\xD2\x63\xDF\xD5\x62\xD2\xD2\x82\x9D\x15\x1C\xD9\xD6\xF7\xC5\xD6\xDF\xCF\xD4\x4D\xD3\x2B\x23\x04\xD5\x68\xD0\xD7\x2A\xD3\xD7\x66\xDA\xD6\x79\xD4\xD6\x7B\xDF\xD6\x18\x84\x02\x76\xD1\xD6\x78\xDC\xCE\x6E\xD0\xD5\x87\xDA\xD7\x71\xDC\xD5\x89\xDE\xD7\x8B\xD7\xD6\x84\xDF\xD7\x88\xD5\xD8\x8A\x45\x02\x83\xDE\x4E\x26\x07\xD9\x94\xDC\xD8\x9B\xD0\xD9\x8D\xD7\xD7\x92\xDA\xD8\x7D\xD0\xDA\x8F\xDC\xD7\x86\xDD\xD9\xA6\xD2\xD7\x8E\xD3\xDA\x91\xD5\xDA\x80\xDE\xDA\x93\xD1\xDA\xF4\xA7\x02\x9A\xD2\xDB\xA4\xDC\xDA\x9F\xDD\xDA\xB8\xD8\xDA\xAF\xDB\xDB\xB6\xDA\xDB\xA7\xDF\xDB\x62\xD8\x02\xB5\xD0\xDB\xA2\xD1\xDC\xC6\xDB\xDA\xC8\xDE\xDB\xC9\xD7\xDB\xCB\xDF\xDC\xAA\xDE\xDC\xD1\xD0\xDC\xD3\xD9\xDB\x96\x39\x02\xC5\xD1\x44\x2A\x09\xDD\xD0\xDC\xD9\xC2\xDC\xDB\xB1\xDD\xDC\xD4\xDE\xDD\xE2", - "\xD6\xDD\xE0\xD7\xDC\xD5\xD7\xDE\xCA\xD9\xDE\xDF\xDD\xDE\xE5\xDA\xDE\xD2\xD4\xDE\xCC\xD3\xDF\x13\x30\x16\x6D\xD0\xDF\xE3\xDE\xD9\xF8\xD6\xDE\xEE\xD4\xDF\xEC\xDF\xDE\xFD\xDD\xDD\xFA\xD1\xE0\xCE\x8C\x02\xDC\xDF\xDF\xFE\xD2\xDF\x02\xE9\xDA\x0A\xE8\xE0\x0B\xED\xDB\x0F\xE1\xDE\x09\xE3\xE0\x00\xE5\xE1\x13\xEC\xE0\x14\xE7\xE1\x48\x6D\x02\x07\xE3\x76\x2E\x0D\xE1\x19\xE1\xE1\xE8\xDD\xE0\x24\xE1\xE2\x0E\xE7\xE2\x25\xE8\xE1\x2A\xE0\xE1\x28\xE6\xE2\x29\xEC\xE2\x2F\xE2\xE1\x22\xEB\xDE\x31\xEC\x64\x2F\x00\xE2\x2B\xE2\xE3\x2D\xE9\xE3\x23\xEE\xE2\x3E\xEC\xE3\x34\xEF\xE3\x30\xE2\xE4\x3A\xE5\x61\x30\x08\xE3\x43\xE0\xE4\xF1\xD4\xE4\x3D\xEA\xE4\xF9\xDE\xE4\xFC\xD6\xE1\x33\xEB\xE4\x50\xEB\xDF\x56\xE4\xE0\x35\xE1\xE4\x3A\xC1\x03\x48\xE5\xE4\x4C\xEA\xE5\x49\xE1\xE6\x5E\xE5\xE5\x58\xEF\xE5\x61\x23\x16\xF7\xD2\x4F\x33\x00\xE2\x34\x00\xE2\x35\x0D\xE5\x4D\xE3\xE4\x36\x0C\xD0\x37\x0C\xD0\x66\x1D\x89\x39\x0C\xD0\x3A\x00\xE2\x3B\x0C\xD0\x3C\x04\x16\xA6\xAA\x64\x3F\x09\xD2\x03\x11\x04\x0C\xDA\x16\x9D\x83\x04\x70\xE8\x23\x44\x0C\xD0\x45\x0B", - "\xE8\x54\xE2\xE6\x96\x76\x04\x84\xE7\x10\x95\xE9\xE5\x6F\x3A\x04\x90\xE1\x38\x4B\x0C\xD0\x6C\x1D\x89\x4D\x0C\xD0\x4E\x0C\xD0\x4F\x0C\xD0\x50\x0C\xD0\x51\x0B\xE9\x51\xEA\xE1\x63\xE2\xE9\x60\xED\xEA\xB0\xE1\xE7\xB1\xEF\xEA\xB2\xE5\xEB\xB4\xE7\xEB\x91\xE3\xEB\xB9\xE6\xEB\xBB\xE8\xEB\x4F\xEE\xEA\xBD\xE1\xEC\xBF\xE0\x4B\x52\x0A\xEA\x12\x8E\x16\x9D\x84\x05\x64\x12\x24\x52\xEB\xE3\xC0\xE3\xEC\xBC\xE0\xED\xBE\xEB\xEA\x53\xE2\xED\xC2\xE4\xED\xCE\xEA\x64\x62\x0C\xD0\x72\x19\xE6\xCD\xE3\x76\x64\x06\xEC\xD7\x35\x06\x20\xE6\x06\x20\xE7\x06\xE2\xEF\xED\x4D\xC8\x06\x0C\xD9\x06\x0C\xDA\x06\x0C\xDB\x06\x0C\xD4\x17\x9D\x8D\x06\x20\xEE\x06\x0C\xDF\x06\x80\xE2\x4F\x72\x07\xE9\x00\x04\x07\xFE\xE6\x07\x0C\xD7\x07\x0C\xD8\x07\xE9\xEA\xAA\x0C\xDA\x07\x07\xF5\xED\xD8\xE1\x8D\x7B\x0E\xEF\x78\x15\xB4\xEA\xE5\x24\x7F\x0B\xF0\x20\x30\x08\x0C\xD1\x08\x0C\xD2\x08\x0C\xD3\x08\x0C\xD4\x08\x0C\xDA\x17\x9D\x86\x08\x16\xF1\x10\x87\x0C\xD0\x88\x0B\xEC\x65\xE4\xE6\x13\xFF\xEC\x0D\xF6\xE6\xD6\xE1\xF3\x2F\xFC\xF2\xAC\xE1\xED\x33\xFE\xF2\x57\xE8\x6C", - "\x96\x05\xF2\x30\xF7\xF3\xBA\xE2\xF3\x39\xF5\xF3\xD3\xE1\xF4\x0C\xF4\xF4\x8A\x47\x09\x0C\xD8\x09\x3C\xF4\xF3\x3F\x40\x18\xDE\xE7\x5B\x9A\x00\xE2\x9B\x00\xE2\x9C\x0B\xF4\x38\xF4\x95\x9D\x0C\xD0\x9E\x0C\xD0\x9F\x0C\xD0\xA0\x0C\xD0\xA1\x0C\xD0\x82\x1F\xF4\x03\x13\x0A\x0C\xD4\x0A\xFB\xED\x53\xA7\x0E\xEF\xA9\x0E\xEF\xAB\x0C\xD0\xAC\x0C\xD0\xAD\x0C\xF3\x84\x1D\x89\xAF\x06\xF5\x3F\xFE\xF3\x4C\x60\x0B\xFE\xE2\x0B\xFE\xEC\xF4\x02\x14\x0B\x78\xF0\x24\xB5\x0C\xD0\xB6\x0C\xD0\xB7\x0C\xD0\x88\x1D\x89\xB9\x0C\xD0\xBA\x0C\xD0\xBB\x03\xF8\xD3\x4C\x0B\x0C\xDD\x0B\x92\xF7\xED\xBB\x3E\x0B\x97\xF1\x38\xBF\x00\xE2\xC0\x00\xE2\x8A\x14\xF6\xD9\xED\xE3\xC2\x0C\xD0\xC3\x0C\xD0\xC4\x0C\xD0\xC5\x0C\xD0\xC6\x0C\xD0\xC7\x00\xE2\xC8\x0C\xD0\xC9\x09\xF6\xB7\x5C\x0C\xFE\xEE\x0C\xFE\xEC\x18\x9D\x81\x0D\x0C\xD2\x0D\x3C\xF3\x0D\x0C\xD4\x0D\x9B\xFA\xF7\x43\xF2\x4F\xD5\x0E\xEF\x8E\x12\xF1\x42\xFF\x36\xD9\x03\xFC\xB3\x1A\x0D\x0C\xDB\x0D\x0C\xDC\x0D\x0C\xDD\x0D\x0C\xD0\x19\x9D\x8F\x0D\x0C\xD0\x0E\x3C\xF1\x0E\x0C\xD2\x0E\x2A\xFD\xF2\x79\xF6\xF4\x98", - "\xE0\xF4\x2B\xF7\xF5\xE2\xF6\xF3\xE4\xFD\xF3\xEB\xF0\xF8\xE5\xF4\xFC\x1A\x90\x0F\xCE\xF7\xFE\xE3\xF4\xFF\xEA\xF6\xFF\xC5\xF9\xFE\xF9\xFB\xFC\xE6\xFA\xFF\xE5\x41\x0F\xF3\x7E\xFF\x7D\x7E\xFE\x70\xFF\x03\x81\xD1\x78\x7F\x98\x78\x01\x86\x81\xD1\x7B\xFF\x02\x72\x3C\x01\x80\x04\x85\xFD\x68\x7F\x08\x8A\x00\x85\x82\x05\x92\x80\xF5\x78\xD9\x33\x06\x86\x64\x0F\x10\x83\x01\x8F\x1F\xF5\x06\x03\xA0\x18\xCA\x02\xFA\x01\x0B\x3D\x00\x71\xF8\x02\x04\xAF\x7E\xBA\x49\x0F\x0C\x6A\x3E\x0C\x68\xFB\x04\xA1\x7C\x06\x86\x6D\x0F\x0C\x6A\x3F\x18\x71\x0C\x68\x00\x28\x0D\x40\x7A\x4B\x03\x00\x6A\x16\x0F\x05\x07\x07\x8A\x09\x03\x08\x1A\x5E\x0C\x02\x05\x82\x0A\x08\x33\x25\x81\x9A\x1A\x00\x48\x81\x42\x0B\x00\x4E\x84\x02\x82\x81\xA3\x4C\x00\x42\x81\x42\x0E\x00\x56\x82\x0A\x82\x18\x08\x01\x05\xA7\x2D\x04\x1D\x82\x02\x0A\x02\x20\x83\x80\x03\x01\x63\x80\x00\x14\x00\x66\x85\x02\x26\x82\x0B\x06\x06\x97\x02\x19\x8A\x3B\x9B\x0D\x13\x59\x01\x37\x83\x01\xCE\x3A\x06\x14\x83\x4A\x33\x03\x38\x82\x20\x1E\x19\x4B\x81\x07\x1B\x83\x0D\x85\xC5\x5E\x00\x33\x8F", - "\x01\x66\x81\x68\x1D\x44\x21\x06\x0C\xA2\x00\x33\x83\x02\x00\x85\x98\x04\x0D\x9D\x45\x04\x3B\x80\x79\x28\x02\x59\x83\x40\x0A\x01\x96\x82\x20\x2C\x00\x33\x8D\x02\x66\x82\x0B\x0E\x84\x81\x1F\x05\x26\x82\x18\x00\x0A\x97\x81\x05\x8C\x36\xAA\x0A\xF9\x43\x09\x19\x09\x09\xAB\x83\xB2\x15\x01\xA5\x83\x77\x36\x00\x33\x87\x03\x66\x80\x0E\x06\x83\x39\x06\x0C\xBA\x00\x33\x8B\x03\x66\x80\x0F\x11\x85\xCB\x15\x07\x26\x82\x1F\x08\x1A\x4C\x76\x16\x9F\x80\xC7\x84\x01\x89\x81\x29\x88\x01\xF7\x7C\x33\x87\x85\xD0\x87\x19\x92\x87\x64\x8E\x0A\xEF\x1C\x13\x00\x86\xD3\x80\x19\x9A\x86\x65\x8B\x00\xD5\x84\x35\x8C\x7F\xD1\x87\x1B\xAE\x7E\x3F\x5D\x04\x58\x86\x38\x95\x83\xDC\x86\x14\x99\x87\x74\x8D\x0C\x81\x86\x37\x9B\x86\xEF\x84\x1D\xA1\x87\x81\x0E\x04\x66\x84\x3C\x80\x87\xEB\x81\x1E\xBA\x86\x7C\x87\x0E\x99\x81\x3F\x8C\x32\x4F\x06\x0C\x90\x03\x62\x83\x0F\xF2\x85\x3E\x9C\x87\xF7\x83\x1C\x8A\x88\x74\x8B\x0F\x8B\x8A\x3F\x89\x88\x0C\x88\x21\x86\x89\x7F\x8E\x0E\x92\x89\x43\x91\x88\x0E\x8E\x19\x94\x88\xDA\x3E\x05\x76\x87\x44\x90\x88\x0F\x8A\x20", - "\x1F\x02\x8F\x87\x11\xA1\x89\x49\x80\x12\x60\x04\x24\x96\x89\x95\x89\x11\x95\x89\x4B\x8B\x86\x1B\x8D\x1B\xAC\x88\x8C\x84\x13\xA6\x8B\x4C\x96\x89\x2F\x8A\x26\xB9\x89\xA3\x41\x06\x2A\x8B\x4E\x8D\x87\xA7\x62\x0C\x3E\x89\x9A\x8A\x11\xF7\x87\x18\x03\x8A\x38\x8C\x28\xAE\x88\xA5\x80\x13\xA0\x8A\x40\x44\x03\x66\x85\x0C\x08\x8B\xA2\x87\x61\x66\x03\x54\x93\x26\x67\x02\x25\xA8\x02\x95\x89\x06\x57\x89\x53\x97\x61\x6A\x06\x0C\xAB\x02\x33\x8C\x06\x66\x81\x1B\x06\x83\x6E\x06\x0C\xAF\x02\x95\x80\x07\x66\x81\x1C\x13\x84\x3D\x2C\x0E\x2D\x84\x00\x06\x07\x73\x88\x1E\x06\x83\x79\x06\x0C\xBA\x02\xAF\x84\x27\x7B\x02\x19\x9C\x03\x7C\x8A\x1D\xB1\x88\x46\x3D\x07\x73\x8B\x1F\x13\x8B\xE3\x81\x10\x01\x8D\x59\x12\x08\x66\x83\x20\x06\x83\x84\x06\x0C\x85\x04\x33\x86\x08\x66\x83\x21\x06\x83\x88\x03\x31\x8A\x09\x44\x06\x06\x8A\x04\x41\x87\x88\x3F\x8D\x20\xA7\x89\xA5\x89\x14\xA5\x8C\x55\x83\x8D\x5F\x88\x35\xBA\x88\xA6\x8B\x1A\xE8\x44\x26\x1A\x8C\xA0\x8C\x35\x82\x8C\xA7\x84\x1A\xA7\x8F\x4D\x96\x8D\xA1\x89\x36\xA6\x8C\x1D\x39\x09\x30\x8F\x60\x80", - "\x8A\xAD\x88\x37\xB2\x8C\xE0\x83\x1B\x9F\x8A\x71\x8A\x8D\x2F\x7A\x13\x3E\x8D\xF9\x4B\x09\x4B\x8E\x40\x1C\x04\x66\x85\x13\x26\x82\x4F\x06\x06\x9F\x06\x19\x80\x05\x66\x81\x14\x26\x82\x51\x06\x06\xA3\x06\x19\x84\x05\x66\x85\x14\x26\x82\x53\x0E\x1C\xC8\x8C\x5D\x47\x05\xE5\x8D\x66\x28\x05\xF4\x89\x1B\xBF\x8E\x68\x97\x8D\x50\x19\x15\x2C\x8F\xE1\x8F\x1E\xBD\x26\x2A\x13\x8F\xE8\x43\x15\x29\x8E\x56\x06\x06\xAD\x06\x19\x8E\x05\x66\x87\x15\x26\x82\x58\x06\x06\xB1\x06\x19\x92\x05\x66\x83\x16\x26\x82\x5A\x06\x06\xB5\x06\x19\x96\x05\xF8\x8A\x38\xA8\x47\x5B\x01\x21\xB8\x10\x2E\x15\x90\xA9\x88\x3E\x99\x91\xF6\x8F\x43\x39\x04\x86\x9F\x64\xBA\x06\x0C\xBB\x05\x0F\x95\x1C\x88\x24\x2F\x04\x91\xB3\x15\x17\x2A\x88\x5F\x0A\x12\xBF\x06\x19\x80\x06\x28\x95\x3E\x88\x33\x60\x06\x06\xC2\x06\x19\x83\x06\x66\x84\x18\x26\x83\x62\x06\x06\xC6\x06\x4A\x87\x06\x66\x80\x19\x30\x8B\xDB\x2B\x0C\x73\x89\x33\x13\x8B\xCF\x06\x0C\x90\x06\x33\x81\x0D\x69\x8E\x34\x06\x83\xD3\x01\x46\xBA\x8C\x09\x90\x24\x54\x07\x5C\x96\x06\x88\x89\x22\x98\x06\x29\x96\x10", - "\x59\x06\x19\x9A\x06\x66\x83\x1B\x26\x82\x6E\x06\x06\xDD\x06\x19\x9E\x06\x66\x87\x1B\x1C\x93\x1F\x20\x0E\x66\x81\x38\x0B\x93\xC7\x8A\x93\x22\x06\x38\x9B\x32\x63\x06\x4A\x84\x07\x2A\x8D\x1C\x34\x92\x0D\x94\x92\x66\x06\x19\x87\x07\x66\x80\x1D\x26\x83\x74\x06\x06\xEA\x06\x19\x8B\x07\x2A\x8C\x1D\x26\x83\x76\x03\x24\xA7\x2C\x3C\x13\x8B\xF2\x03\x2E\xB4\x06\x33\x85\x0F\x66\x82\x3D\x09\x8F\xF7\x06\x0C\xB8\x07\x3D\x9C\x21\xF1\x91\x91\x19\x07\x73\x8B\x1F\x19\x92\x9B\x8D\x0F\x7B\x92\x3F\x0F\x83\x66\x80\x00\x3C\x0F\x41\x4F\x1E\x2B\x97\x40\x06\x44\xAE\x92\x20\x38\x0F\x58\x91\x10\x5E\x0C\x01\x14\x95\x82\x41\x88\x05\x00\x5C\x9E\x1D\x06\x00\xAE\x86\x86\xB4\x8B\x43\xB4\x8F\x29\x95\x1B\xC5\x96\xB0\x9B\x8D\xC7\x94\x4A\x86\x97\xE0\x8B\x2C\xEF\x58\x05\x1C\x95\x54\x4D\x02\x10\x96\x62\x99\x2C\xCD\x94\x71\x97\x96\x32\x90\x59\x8C\x97\x6A\x9C\x2D\xDB\x94\x3B\x36\x00\xD3\x91\x88\x17\x01\x70\x9F\x43\x18\x00\xAE\x86\x52\xC3\x96\x3D\x89\x08\x0D\x07\x2E\xAA\x34\x07\x0D\x97\x8F\x6E\x03\x24\x97\x0B\x3F\x01\x73\x96\x79\x97\x1E\x20\x06\x5E\x80", - "\x01\x10\x0A\x2F\xA2\x02\xBE\x83\x01\xFA\x94\x04\x30\x97\x04\x2A\x2F\xA7\x00\xAE\x98\x95\x00\x03\x05\x38\x94\x1E\x88\x23\x2E\x02\xBE\x83\x87\x2F\x07\x61\xA9\x97\x60\x9E\x2D\xEF\x58\x0C\x12\x98\x34\x19\x06\x18\x99\x9C\x12\x03\x03\x98\xC5\x85\x91\x9A\x24\x06\x1E\x98\xB0\x36\x03\x23\x99\x89\x78\x01\x1B\x9B\x9A\x39\x01\x94\x9D\x2D\x96\x1E\x0E\x1A\x97\x3B\x02\x5F\xBC\x00\x7D\x9D\x03\x7A\x96\x0F\x06\x99\x00\x00\x08\x3A\x97\x20\x07\x30\x8A\x09\x11\x0B\x98\xCB\x10\x09\x2C\x98\x99\x89\x04\x43\x98\xC8\x8A\x02\xFA\x93\x09\x3F\x95\x6C\x9A\x2C\xAD\x98\xB6\x94\x96\x15\x9F\x69\xAA\x97\xA9\x9F\x31\xD2\x99\xD5\x8C\x9A\xD6\x95\x22\x06\x9A\xAB\x9E\x29\x93\x99\xD7\x9A\x96\x20\x9D\x53\xB7\x96\xA8\x91\x36\xDE\x98\x22\x3A\x02\x5B\x98\x6B\x8E\x9A\xB5\x91\x35\xEC\x99\xD9\x80\x9B\x5C\x9D\x4C\x5B\x02\x7D\x9C\x05\x4B\x98\xD9\x91\x9B\x7C\x97\x6D\x8D\x9B\xB6\x97\x37\xEE\x98\xDE\x82\x9B\x79\x9F\x6F\xA6\x9A\xB2\x3A\x06\x69\x9B\xFB\x0B\x03\x86\x9C\x6A\x9F\x9B\xBD\x9A\x37\xD9\x99\xDF\x8F\x9C\x8A\x9D\xC4\x6C\x02\x7D\x9D\x06\x09\x9F\xD5\x9D\x29", - "\x6E\x06\x72\x97\x31\x37\x0A\x39\x81\x08\x1C\x1D\x9C\x00\x01\x0E\x20\x9C\xC0\x98\x8D\x72\x02\xBE\x93\x03\xFA\x94\x0E\x3A\x97\x3A\x0A\x2F\xF6\x02\xBE\x97\x03\xA0\x98\x0F\x3A\x97\x3C\x00\x34\xBD\x28\x1F\x18\x99\x7E\x00\x67\x80\x04\x7D\x91\x08\x7A\x96\x20\x03\x9D\x3C\x13\x10\x3A\x96\x42\x00\x3C\xF0\x9A\xDF\x8B\x16\x85\x00\x67\x87\x04\x9C\x93\x0E\x89\x05\xF1\x99\x19\x8A\x02\x5F\x8B\x04\x7D\x9C\x08\x7A\x95\x23\x1A\x97\x8E\x02\x5F\x8F\x04\x7D\x90\x09\x4F\x9E\x8E\x31\x04\xFA\x92\x12\x1E\x9F\xB5\x9F\x3E\x13\x07\xF8\x8C\x27\x94\x00\x74\x95\x04\xD0\x96\x09\x67\x9D\xE3\x9D\x56\x97\x02\x5F\x98\x04\x7D\x99\x09\x7A\x96\x26\x1A\x97\x9B\x02\x5F\x9C\x04\xD0\x9D\x09\x7A\x96\x27\x15\x9D\xB7\x29\x14\x38\x99\x51\x08\x33\xA5\x06\xBE\x86\x05\xFA\x97\x14\x2E\x9F\xD9\x08\x0A\x7A\x95\x2A\x0B\xA0\xC7\x98\x72\x83\x08\x55\x08\x33\xAC\x04\xF3\x91\x88\xAE\x00\x82\xA7\x17\x57\x0A\x2F\xB0\x06\xBE\x91\x05\xFA\x92\x16\x3A\x97\x59\x0A\x2F\xB4\x06\xBE\x95\x05\x1A\xA1\x72\x81\x9C\x0C\x46\x0B\x29\xA3\xC4\x17\x05\x2E\xA3\x71\x8E\x9C\x15\xA4\x3A\x83", - "\x9D\x0D\xA6\x9E\x12\xA2\x20\x38\x04\x7D\x99\x0B\x76\x98\x0D\xB6\xA1\x40\xA0\x87\xBF\xA0\x21\xA7\x39\xC3\xA0\xE3\x82\x9C\x44\xA2\x86\xA4\x9E\x81\x17\x0C\x31\xA3\xD8\x86\xA2\x33\xA5\x88\x92\xA2\x25\xAC\x37\xD0\xA3\x12\xA3\x08\xC8\x02\x5F\x89\x06\x1F\xA3\x45\xCF\xA1\x17\xAB\xA1\x39\xA6\x8B\x94\xA3\xF7\x95\x45\xDF\xA3\x0D\xBA\x25\xD7\x02\x5F\x98\x06\x2E\xA3\x46\xC8\xA3\x11\xB1\xA0\x56\xA5\x8C\xAD\xA2\x38\xA6\x46\xC1\xA3\x1B\xAF\x1F\xE6\x02\x5F\xA7\x06\x27\xA0\x46\xC1\x20\x3A\x1C\xA3\x53\x19\x1D\x20\x9C\x75\x00\x3A\xEB\x04\x20\xB6\xA3\x94\x3C\x1D\x3A\x97\x76\x0A\x2F\xEE\x06\xBE\x8F\x07\xFA\x90\x1E\x3A\x97\x78\x00\x3A\xF2\x06\xBE\x93\x07\x00\xA7\xB4\x36\x06\x9C\x98\x0F\x38\x9A\x3E\x1A\x97\xFB\x02\x5F\xBC\x06\x3E\xAD\x0F\x7A\x96\x3F\x07\xA4\x49\xA2\x8C\xAD\x18\x9C\x91\x00\x7F\x0D\x7D\x0F\x8F\x03\x06\x95\xAF\x94\x79\x24\x00\x32\xA6\xAC\x8A\x08\x05\x06\x96\xB5\x95\x00\x1A\x4B\xB9\x97\x40\x07\x00\xBD\xA6\x08\x81\xA7\x24\x83\x4C\x89\x0A\x02\x05\xA6\x41\x23\x01\x08\xA7\x81\x0C\x00\x3D\xA4\xB0\x93\xA3\x61\xA5\x8F\xB5\xA3", - "\x54\xA2\x4D\xD0\xA5\x1C\xA4\xA3\xD8\xA6\x8D\x91\xA2\x6B\xAF\x45\x9A\x03\x32\xBC\xA6\xE0\xA2\x95\x95\xA6\x71\xA7\x46\xDB\xA4\x39\xA8\xA4\x57\xA1\x9C\xB5\x19\x0D\x0F\x4D\xE7\xA4\x35\xA5\xA7\xE9\xA6\x9D\xB7\xA3\x6B\xAA\x4D\xF1\xA7\x38\xB5\x19\x1C\x05\x9D\xBE\x71\x0E\x0A\x4F\xD3\x1A\x07\x1A\xA7\x1F\x02\x9F\xA0\x00\x7D\xA1\x02\x7A\xA6\x08\x1A\xA7\x23\x02\x9F\xA4\x00\x7D\xA5\x02\x7A\xA6\x09\x1A\xA7\x27\x02\x9F\xA8\x01\x7E\xA8\x4E\xF4\x51\x0A\x14\xA8\xB0\x22\x05\x18\xA9\x79\xA3\x4D\x9C\xAA\x3A\xB3\x1A\x2B\x03\xA3\xB4\x56\x16\x0A\x4F\xAD\x02\x33\xB4\xA3\x1F\xAD\xA2\x99\xA6\x94\xA2\x4F\xE6\xA7\x3D\xB0\xA7\x72\xA5\xA5\xB6\xA6\x98\xA3\x7E\x3B\x02\x48\xB3\xA9\x2A\xAD\x9E\xB1\xA9\x97\xA9\x53\xAC\xA8\x4F\xAF\xA7\x3D\xA8\x06\x7C\x01\x9B\xAB\x53\xB4\xAA\x4E\xAB\xA9\xD1\xA6\xA8\xBE\xA8\xA5\xA7\x2E\x3D\x02\x3E\xBE\x01\x44\xA8\xA9\xB7\x2D\x1F\x01\x55\xB7\x28\x10\x15\xAA\x0A\x09\x08\x3A\xA6\x21\x0A\x4F\xC3\x00\x56\xA9\xAA\xDE\x44\x08\x3A\xA7\x22\x0A\x4F\xC6\x02\x3E\xA7\x02\xFA\xA0\x09\x3A\xA7\x24\x0F\x55\x86\x0A\x12\x1A\xA7\x4B", - "\x05\x97\x8C\x99\x72\x2E\x04\x3D\xA6\x7D\x10\x02\x76\xAA\x21\x12\x02\x7D\xA3\x05\x7A\xA4\x15\x0D\xAB\x13\x1D\x0A\x3A\xA6\x2B\x00\x58\xA9\xA8\x50\xB4\x19\x57\x01\xAF\x89\x09\x2C\x0A\x58\xAA\xA3\x16\x05\xAC\x88\x24\x0B\x3A\xA7\x2E\x0A\x4F\xDE\x02\x3E\xBF\x02\xFA\xA0\x0C\x3A\xA7\x30\x0A\x4F\xE2\x00\x64\xA4\x3B\x63\x02\x9F\xA4\x03\xCF\xAC\x54\x82\x19\x19\x04\xAD\xEA\x26\x0C\x1F\xAD\x33\x0A\x4F\xE8\x02\x3E\xA9\x03\xA8\xAF\xB0\x82\x48\x35\x0A\x4F\xEB\x02\x3E\xAC\x03\xFA\xA5\x0D\x3A\xA6\x37\x0A\x4F\xEF\x03\x67\xB0\x03\xFA\xA1\x0E\x32\xAA\x79\x24\x07\x0D\xAF\x40\x16\x03\xC6\xAA\x20\x38\x02\x7D\xA9\x07\x7A\xA6\x1E\x11\xAD\x40\x13\x0F\x3A\xA6\x3E\x00\x5D\xAE\xA9\x69\xA3\x08\x7D\x01\xB9\x81\x09\x3F\x0A\x5D\xF7\xA5\x20\x15\xAE\x6F\x1A\x10\x3A\xA7\x41\x0A\x4F\x84\x06\x3E\xA5\x04\xFA\xA6\x10\x3A\xA7\x43\x0A\x4F\x88\x04\x78\xB1\x33\x89\x02\x9F\x8A\x05\xF7\xA2\x55\xBF\x23\x22\x14\xAF\xBB\x1C\x11\x1F\xAD\x46\x0F\x59\x8E\x04\x7E\xAB\xAA\x84\x3F\x11\x3A\xA6\x48\x0A\x4F\x91\x06\x3E\xB2\x04\xFA\xA3\x12\x3A\xA6\x4A\x0F\x59\x95\x06", - "\x3E\xB6\x04\xC3\xAD\xA7\x19\x05\xEE\xAB\x09\x5D\xAD\x27\x1A\xA7\x9E\x02\x9F\x9F\x05\xFF\xA9\x10\x20\x06\x3E\xA1\x05\x1C\xB4\x9E\xBE\xA8\x51\x0D\x5D\xA4\x05\x77\xA3\x87\xA6\x01\xC4\x93\x19\x53\x0A\x4F\xA8\x06\x3E\xA9\x05\xFA\xA2\x15\x3A\xA7\x55\x0A\x4F\xAC\x06\x3E\xAD\x05\x2A\xB6\xB0\x9E\xA9\x80\x0E\x0A\x27\xB1\x50\xA2\xB1\x60\xAA\xB6\x96\xAF\x1F\xBD\x51\xC3\xB0\x3A\x50\x05\xFA\xA1\x16\x27\xA9\x20\xBB\x63\xBF\xA9\x93\xB7\xAE\x3A\xB6\xC8\x8F\xB2\x22\xB1\x65\xB8\xAA\x90\xB6\xA7\xBF\x01\xC7\xB2\xA9\xA2\xA4\x65\xDB\xB1\x7D\xB5\xB2\x5C\xB7\xCA\xB1\x32\x60\x0A\x4F\xC1\x06\x96\xAE\xB2\x50\x1A\x18\x1F\xAD\x61\x0E\x63\xB4\x19\x31\x1F\xAC\xC6\x02\x9F\x87\x06\x7D\xA8\x0C\x67\xB0\x94\xA3\x3B\xC9\x02\x9F\x8A\x06\x7D\xAB\x0C\x7A\xA4\x33\x1A\xA7\xCD\x02\x9F\x8E\x07\xCF\xAF\x0C\x7A\xA4\x34\x11\xB0\xB7\x2B\x1A\x1D\xAF\x6A\x0D\x5D\xD7\x06\x3E\xB8\x06\xFA\xA1\x1B\x27\xB2\x6D\x0A\x4F\xDB\x06\x9D\xBD\xB2\xF7\xA4\x1B\x1D\xAE\x6F\x0D\x66\xB6\x8C\x38\x17\xB4\x3E\x11\x1C\x3A\xA6\x71\x0A\x4F\xE3\x06\x3E\xA4\x07\xFA\xA5\x1C\x3A\xA6\x73", - "\x0A\x4F\xE7\x07\x99\xA8\x07\xFA\xA1\x1D\x0B\xB2\x20\xB4\x6B\xC5\xB2\x95\xB3\xB2\x62\xB7\xCB\x9E\xB3\xA3\xAC\x6B\xD4\x4B\x3D\x1A\xA7\xF8\x03\xD6\xB6\xB5\x30\xB8\x6B\xC5\xB6\x94\xA7\xB6\xB7\xB0\xD9\x84\xB6\x65\xB7\x94\x06\x01\x32\x57\xA5\x04\x17\xD9\x81\x09\x67\xAB\x6B\x80\xB1\xAE\xBD\xB5\x4C\xB4\xD9\x98\xB7\x5A\xB0\x66\xBA\xB4\xD9\x35\x00\xD2\xB6\x97\x82\x08\x0B\x01\x6E\xD4\xB4\x9A\xA9\xB6\xE8\xB3\xD9\xA9\xB6\x6F\xB7\x67\xE7\xB6\xBA\xAF\xB7\x47\x4C\x04\x21\xB6\xEF\x05\x02\x65\xB6\xB5\xA6\xB6\xEB\xB3\xDB\x83\xB6\x76\xB8\x69\xED\xB6\xBF\xBD\xB7\x48\x33\x06\x33\xB6\x85\x04\x03\x03\xB9\xB6\xA5\x27\x35\x06\xE0\x92\x3A\x1B\x0A\x70\x93\x1B\x0D\x0D\xB8\x20\x18\x07\x10\xB9\x80\x09\x03\x13\xBA\xBB\xAF\x5B\x3A\x06\xE2\xBB\x00\x8B\xBC\x03\x16\xB9\x0F\x16\xB8\x3E\x06\xE2\xBF\x00\x8B\xB5\x24\x40\x02\xC5\xA1\x02\xE1\xB3\xAE\xAC\x26\x22\x01\x6E\xF6\x0E\x11\x0D\xB9\x0A\x08\x09\x16\xB9\x24\x06\x71\xCA\x00\xC9\xBB\x19\x4B\x06\xE2\x8C\x03\x9B\xB7\x6D\xF7\xB4\x8E\x0D\x02\x30\xB9\x21\x0F\x03\xA0\xBA\x42\xD1\x00\xCF\xBA\x25\x52\x06", - "\xE2\x93\x02\x8B\xB4\x05\x16\xB9\x15\x16\xB8\x56\x06\xE2\x97\x02\x8B\xB8\x05\x47\xBA\xB6\xBE\xB9\x61\x11\x0B\x16\xBA\x8D\x4A\x05\x5B\xB8\xBC\xBA\xB7\xDD\xB0\xEC\x95\xB7\x83\xBF\x75\xBE\xAB\x16\x16\xB8\x5C\x06\xEB\xBC\xB6\x58\x2D\x05\x6A\xBB\x4D\x3E\x02\x6E\xBA\x21\x1F\x03\xB8\xB9\x10\x60\x00\xDD\xBC\xB6\x65\x51\x0C\x16\xB8\x31\x06\x71\xE3\x02\xC5\xA4\x03\x16\xBD\x0C\x16\xB8\x33\x07\x77\x83\x0B\x19\x16\xB8\x68\x01\xE5\xB2\x27\x35\x04\x74\x83\x09\x1B\x0D\xBC\x02\x0F\x0D\x16\xB8\x38\x06\x71\xF1\x01\xE1\xA0\x19\x72\x06\xE2\xB3\x03\xCB\xB3\x76\xF8\xB9\xCD\x14\x03\x90\xB9\x20\x36\x03\xD0\xB7\x4F\xF8\x00\xE7\xBA\x24\x79\x06\xE2\xBA\x02\x8B\xBB\x07\x16\xB8\x1F\x16\xB8\x7D\x06\xE2\xBE\x02\x8B\xBF\x07\x27\xBF\xBF\xB4\xA6\x80\x06\xF6\x84\x3D\x40\x0A\x7B\xBD\xB8\xD9\xAB\xBB\xF8\xB5\xEC\xBF\xBC\xB1\xBE\xA7\x02\x06\xC5\xA3\x04\xF6\xB3\xF8\x98\xBA\xE1\xBE\x79\xB7\xBD\xF0\xA0\xBE\x57\xBA\xF9\x92\xBF\x20\x21\x09\x16\xBA\x24\x1D\xBD\xCF\xBB\x56\x13\x04\xEC\xB3\x4D\x14\x07\xE9\xB5\x04\xA7\xBE\x12\x1C\xBF\x7C\xB8\x81\x17\x06\xC5", - "\xB8\x04\x16\xB9\x13\x16\xB8\x4D\x06\x71\x9B\x06\xC5\xBC\x04\xA7\xBD\x13\x16\xB8\x4F\x0A\x78\xBD\x29\x28\x04\xBD\xA3\x04\xF4\xA5\x04\x8B\xB6\x0A\x16\xBB\x29\x03\xBF\x74\x10\x15\x16\xB9\x54\x00\x80\xD0\xBC\xF9\xA9\x08\xAA\x04\xF4\xAC\x04\xD2\xB3\x0E\xAE\x05\x01\xD3\x15\xAF\x06\xE2\xB0\x04\x8B\xB1\x0B\x16\xBA\x2C\x16\xB8\xB3\x06\xE2\xB4\x04\x8B\xB5\x0B\x0F\xC3\xF2\xA6\xC0\x74\x56\x16\x1E\xC1\xE9\xBB\x6F\xF8\x9B\x2D\x03\xC1\xCD\xB8\xE0\xBE\xBD\x14\xC8\x8E\x38\x06\xC5\xB9\x05\x28\xC5\x04\xCB\x16\x5D\x01\x83\x8A\x27\x2E\x07\xBD\xBC\x07\xF4\xBD\x05\x1A\xCD\x79\xA7\x46\x2F\x16\xB8\xBF\x06\xE2\x80\x06\x8B\xB1\x0C\x16\xBA\x30\x16\xB8\xC3\x07\xF4\x84\x06\x8B\xB5\x0C\x75\xBF\x6D\x28\x06\xA4\xBA\x19\x24\xBC\x66\x06\x71\xCD\x06\xC5\xAE\x06\x3C\xC0\x00\x0F\x06\x8B\xB0\x0D\x59\xC2\xF3\xB5\x88\xD1\x04\xF4\x93\x06\x06\xC1\x11\xD5\x06\x17\xDC\x11\xD6\x06\xE2\x97\x06\x8B\xB8\x0D\x16\xB9\x36\x16\xB8\xDA\x06\xE2\x9B\x06\x8B\xBC\x0D\x67\xC3\x0A\xDF\xA2\xDD\x06\x0E\xCC\x32\x6F\x0A\x87\xD1\xBC\x0B\xD9\xBE\x1F\xC4\xF8\x9F\xC3\x03\xCC", - "\xA0\x5F\x06\xC5\xA0\x07\x7D\xC4\x10\xC3\x09\x70\x09\x88\x81\x1E\x38\x07\xBD\xE3\x07\xF4\xA4\x07\x46\xC0\x82\xE3\x3D\x39\x16\xB8\xE6\x06\xE2\xA7\x06\x8B\xB8\x0E\x16\xB9\x3A\x16\xB8\xEA\x07\xF4\xAB\x06\x8B\xBC\x0E\x4E\xC3\x69\x2F\x07\xA4\xB9\x1E\x24\xBD\x79\x06\x71\xF4\x06\xC5\xB5\x07\x59\xC6\x1E\x16\xB9\x7B\x04\x89\x82\xC5\x44\x98\x07\xA4\xBA\x1F\x24\xC2\x9B\x8C\x0F\x35\xC6\x42\x1D\x07\x16\xBE\x1F\x24\xB8\x8B\xB0\x00\x05\x10\xAB\x8F\x95\xC6\xC3\x96\x85\x53\x64\xC0\x6D\x86\x0B\x00\x0C\xC6\xBB\xA4\x04\xE1\xBB\x65\x14\x00\x50\xC6\xB8\xA5\x53\x05\x06\x1A\xF6\x67\x3B\xC3\x8D\xD2\xC5\x0F\xDD\xC6\x7F\xC6\x0F\xDC\x60\x03\x0A\x8D\xC3\x82\x35\xC6\xB7\x83\xC4\xF9\xB2\xC0\x6F\xC7\x71\xB6\xC4\x37\xDF\xC6\xF0\xC5\x1D\xC1\xC5\x79\xCC\x8E\xE9\xC5\x25\xCE\xC7\x80\xC5\x1E\xEA\xC0\x5D\x25\x01\x65\xC7\x41\x96\x00\xFE\xC6\x20\x17\x01\x80\xCB\x8E\xB7\x2C\x06\x04\xC8\x60\x39\x03\x08\xC9\x95\x1A\x01\x0B\xCB\x3A\xAE\xC8\xF6\xC2\x02\x5C\x00\x87\xCD\x01\x0E\xCA\x07\x0E\xC8\x1F\x06\x21\xE0\x00\x87\xC1\x02\x10\xC8\x8F\x02\x01\x0E\xCB\x04", - "\x16\xC6\x95\xB8\xD9\x56\xC6\x7D\x08\x01\x26\xCA\x21\x2A\x00\x87\xCB\x02\x0E\xC8\x0B\x1E\xC8\x34\x1D\x05\x0E\xC8\x17\x00\x93\xF9\xC5\x38\xC1\x13\x2F\x01\x25\xC9\x09\x18\x0A\x93\xAA\xA3\x0C\x15\xC9\xD3\x24\x06\x0E\xC9\x1A\x0E\x90\xB6\x02\x43\xD7\x01\x0E\xC8\x07\x0E\xC9\x1C\x0E\x90\xBA\x00\x50\xCA\xC4\xE0\xC2\xC0\x7B\x01\xA7\xCA\x8E\xD1\xCA\x55\xCB\x19\x3C\x04\x2A\xF7\xC6\x7A\xC7\x93\xD5\xCB\x04\x7D\x01\x0E\xCE\x07\x1A\xCA\x7C\xC0\x35\x3F\x03\x58\xD2\x27\x40\x07\x2C\xC9\x09\x20\x0A\x96\x86\x0A\x10\x0D\xCB\x05\xCB\x3E\x43\x02\x87\xC4\x04\x0E\xC9\x11\x0E\xC8\x46\x06\x21\xC7\x02\x87\xC8\x04\x70\xCA\x40\x09\x02\x0E\xCA\x09\x23\xC8\x79\x2D\x04\x3D\xCB\x40\x0F\x02\x86\xCA\x20\x11\x02\x87\xC2\x05\x0E\xCB\x14\x1E\xCB\x2B\x1C\x0A\x0E\xC9\x2A\x00\x99\xF2\xC4\x3B\xD6\x02\x89\xC9\x20\x18\x03\xCC\xC7\x4F\xDA\x01\x65\xD3\x1A\x5B\x06\x21\xDC\x02\x87\xCD\x05\x0E\xCA\x17\x0E\xC8\x5F\x06\x21\xE0\x02\x87\xC1\x06\x1F\xCF\x3E\xCE\xA9\x62\x06\x35\xFD\x3B\x31\x02\x9B\xB6\xC9\x5C\xD7\xCA\x96\xCD\x2B\xDB\xCA\x7D\xCE\xE5\x64\x02\x43\xC5", - "\x03\xB5\xCA\x1C\xE0\x18\x33\x01\x9C\xE5\x27\x19\x15\xCC\x68\x05\x32\xE9\x03\xE2\xCE\x95\xD2\x46\x1A\x0E\xC8\x6B\x06\x21\xEC\x02\x87\xCD\x06\x0E\xCA\x1B\x0E\xC8\x6F\x05\x32\xF0\x02\x87\xC1\x07\x03\xCD\x5C\x9C\xCC\x76\x04\x33\xF8\x02\x87\xC9\x07\x0E\xCA\x1E\x0C\xCE\x8E\x13\x0F\x0E\xC8\x3E\x08\x9E\xE4\xCA\x3D\xBD\x03\x9C\xCF\x0F\x1C\xCD\xC4\x8D\x9E\xCB\x16\x20\x0E\xC8\x83\x06\x21\xC4\x04\x87\xC5\x08\x0E\xCA\x21\x0E\xC8\x87\x06\x21\xC8\x05\xFA\xCC\x9B\xB6\x8D\x22\x04\xD0\x52\x3A\x11\x08\xD1\xDB\xC1\x8F\x91\xC8\x57\xCC\xD0\xB9\xC8\x42\xEA\x3B\x45\x0E\x90\x8C\x07\x39\xCF\xD0\xB8\xCE\x41\xC5\xD0\xE1\xCD\xA0\xAF\xCC\x54\xDD\xD0\xEF\xC1\x42\xD9\xD0\x75\x2A\x09\x0B\xD3\x88\xC1\xD1\x1A\xD2\x37\xEE\xCF\xE6\xC9\xA2\x92\xD2\x87\xD4\x53\x9B\x06\x44\xE0\xD0\xDB\xC7\xA2\xB4\xD3\x8C\xDC\xD0\x22\xD7\x46\xDF\xD1\x1C\xDC\xA3\xAD\xD2\x33\x5C\x04\x32\xD5\x47\xEF\xD1\xDD\xCA\xA2\x98\xD2\x8E\xCC\xD1\x43\xD3\x45\xC4\xD3\xD3\x2D\x09\x41\xD2\x8F\xC7\xD2\x4B\xD5\x46\xF8\xD1\x27\xD2\xA4\xA8\xD1\x92\xD4\x4A\x9E\x06\x49\xD7\xD3\x0D\xDB\xA3", - "\xD4\xD2\x97\xDB\xD2\x45\xD4\x4B\xC8\xD2\x2B\xD4\xA6\xB6\xD0\x8F\xDF\x04\x5A\xD5\xEF\x20\x04\x87\xC1\x0A\x17\xD2\x98\xD1\xD2\x50\xD2\x49\xF2\xD2\x23\xD5\xA5\xE6\xD3\x97\xC5\xD3\x53\xD0\x4C\xEE\xD0\x3C\xDD\xA5\xFA\xD2\x94\xDD\xD3\x96\x67\x15\x29\xD2\xCB\x30\x0B\x0E\xC9\x2C\x0E\xD3\x61\xD1\x51\xFB\xD2\x3B\xDE\xA7\xF1\xD0\x9D\xD7\xD3\x8C\xD6\xCB\x7F\x04\x87\xC0\x0C\x03\xD4\x8E\xC1\x06\x96\xD7\x6D\x02\x07\xCA\xC3\x0C\x15\xCC\x31\x19\xD4\x63\xD4\xC9\x05\x06\x87\xC6\x0C\x0E\xCB\x31\x0E\xC8\xC8\x06\x21\xC9\x06\x87\xCA\x0C\x15\xCF\x32\x0E\xC8\xCC\x06\x3B\xF7\x2D\x67\x0C\x99\xD1\x04\x67\xD3\x06\x0E\xCC\x1A\x0E\xC9\x6A\x01\xA4\xD6\x06\x43\xD7\x06\xA0\xD0\x4E\xF7\xA6\x6C\x0C\x99\xDA\x07\x7C\xD1\x88\xDC\x01\x58\xF3\x0D\x6E\x0E\x90\xDE\x06\x43\xDF\x06\x0E\xC8\x1C\x0E\xC9\x70\x0E\x90\xE2\x06\x43\xC3\x07\x41\xD4\x1C\x0E\xC9\x72\x08\xA8\x8B\xD5\x9E\xDC\xD3\xA1\xD7\x5B\xD1\xD5\x71\xD2\xAE\xE5\xD4\xA0\xC4\xD7\x4B\x73\x1E\x0A\xD7\x47\xDD\xA8\xF5\xD2\xB9\xC1\xD7\xE7\xD7\x5D\xCC\x34\x7A\x0E\x90\xF5\x05\xB7\xDF\xD3\xF0\xD1\x5F\xC2", - "\xD6\x48\xD2\xAF\xF3\xD3\x9B\xDE\xD7\x2A\xA3\x00\x08\x11\x63\xC8\xAF\xFB\xD5\xBB\xDC\xD7\xF1\xD1\x61\xFA\xD6\x80\xDE\xAD\x8A\xDB\xCB\x64\x00\x03\xDA\x19\xD3\x71\x02\x01\xB1\xCD\xC7\x0F\x26\x00\x15\xD9\x1A\xC6\x09\x03\x09\xB1\xD7\xC5\x43\x7D\xD8\xDE\x09\x01\x20\xD8\x85\x0A\x00\x23\xDB\x13\x86\xD9\x06\x0C\x01\x28\xD9\x81\x0D\x00\x2B\xDA\x40\x0E\x00\x2E\xD9\x20\x0F\x01\x98\xD0\x00\x10\x00\xCD\xC8\xD8\xC7\x39\x02\x37\xD8\x75\x22\x01\x3B\xD8\xB8\xC6\xD8\x3F\xDC\x75\x53\x00\x9F\xDD\xA7\x14\x00\xCD\xD5\x00\x1D\xD8\x1D\xC7\xD9\xA5\xD1\xB4\xEC\xD5\xD3\xDF\xD7\x4E\xD8\x5D\xCB\xD9\x65\x13\x02\x34\xD8\x09\x09\xDA\x51\xDD\x5F\xD9\xDA\x87\xDC\xB0\x85\xD9\xD7\xCE\xD4\x50\xD9\x6C\xCA\xD4\xAF\xDB\xB5\xEC\x26\x0C\x04\xDA\x5A\xDA\x6C\xCD\xD9\xA9\xDA\xB6\xE4\xD8\x3B\xD3\x01\x68\xDF\x94\x74\x01\xB8\xD1\x38\x35\x00\xCD\xD6\x01\x34\xDF\x06\x34\xD8\x1C\x04\xB3\xB9\x00\xCD\xDA\x01\x34\xDB\x07\x34\xD8\x1E\x04\xB3\xBD\x00\xCD\xDE\x01\x34\xDF\x07\x34\xDA\xA0\xD2\x90\x40\x03\xE2\xDB\x1D\x41\x07\x71\xE5\xDA\xC6\xD9\xB6\x8C\x52\x10\x12\xDC", - "\x82\x4B\x08\x34\xD8\x22\x08\xB5\xED\xD8\xD8\xC3\xDB\x9F\xDB\x6D\xD4\xDC\xAE\xD3\xB9\xDF\xDA\x34\x52\x02\x34\xDB\x0A\x1D\xDC\xD0\xDE\xAE\xA4\xDE\xE7\xCD\xDD\x6C\xDC\x75\xF8\xD9\xD1\xD1\xBB\xA2\xDE\xE9\xD3\xDD\xB3\x11\x0C\x18\xDC\xD9\xDC\xB4\xD2\xD8\xED\xDF\xDD\xB7\xDD\x77\xD5\xDC\xDB\xD2\x4F\x62\x03\xEE\xC4\xDE\xAF\xD8\x77\xE5\xDD\xE5\xD9\xBC\xC2\xDE\xEB\xCC\xDD\x63\x07\x78\xEE\xDA\xDE\xDF\xB4\xD4\xDE\xEF\xC1\xDE\x21\xD4\x0C\x12\xDF\x09\x65\x06\x5B\xDD\xCD\x06\x03\x34\xDF\x0C\x34\xD8\x34\x04\xB3\xE9\x00\xCD\xCA\x03\x34\xDB\x0D\x34\xD8\x36\x04\xB3\xED\x00\xCD\xCE\x03\x34\xDF\x0D\x34\xD8\x38\x0E\xBD\xCA\xDD\x4F\x31\x03\xF5\xDB\x67\x32\x03\xFC\xD5\xBD\xC8\xDE\xF5\xCA\x48\x73\x04\x7F\xC2\x48\x3A\x04\xB3\xF5\x03\xEA\xDE\xDF\x08\xE3\x7A\xC9\xE1\xD0\xDA\xC0\x8D\xE0\x03\xEF\xE0\xB0\xD8\x78\xD7\x1F\x41\x02\xC0\xF4\x54\x21\x15\xE0\x61\x15\x10\x34\xD8\x43\x04\xB3\x87\x04\xCD\xC8\x04\x34\xD9\x11\x34\xD8\x45\x04\xB3\x8B\x04\xCD\xCC\x04\x34\xDD\x11\x34\xD8\x47\x04\xB3\x8F\x04\x06\xF5\xDD\x60\x38\x12\x2F\xE0\xCB\x11\x09\x33", - "\xE0\xF6\xD7\xDE\xCC\xDA\xEA\x12\x04\x1B\xE8\x81\x13\x04\xCD\xD4\x04\x07\xE6\x81\xD1\xE1\x1B\xE3\xBC\xC2\xE2\xFD\xDF\xDF\xCF\xDB\x81\xC3\xE3\x1C\xE3\x9F\x22\x04\x0F\xED\xDE\xFD\xDE\x88\xCE\xDE\x18\xE0\xC1\xC7\xE2\x12\xE0\x54\xA3\x07\x89\xC8\xE2\x2A\xEB\xC4\xD0\xE0\x0E\xFE\xE2\x45\xE5\x8A\xED\xD6\x52\x0A\xC5\xD7\xE3\x14\xF2\xE0\x60\xE1\x89\xD2\xE3\x28\xE2\xC6\xEC\xE0\x00\x05\x05\x65\xE3\x8D\xDF\xE3\x2D\xE8\xC6\xF4\xE0\x11\xEA\xE3\x6D\xE6\x36\xA6\x05\x38\xE9\xC7\xE1\xE1\x17\xF6\xE3\x4C\xE2\x8E\xFE\xE2\x2B\xE2\xC8\xB4\x3F\x29\x1C\xE3\x7F\xE6\x8C\xEE\xE2\x42\xED\xC7\xF8\xE1\x22\xE5\xE4\x5C\xE4\x91\xCF\xE5\x12\x78\x0A\x08\xE6\x24\xF7\xE4\x67\xE7\x8E\xD1\xE5\x4C\xE1\xC8\x8D\xE7\x27\x69\x05\x96\xE4\x93\xE9\xE3\x4D\xEB\xC8\xA2\xE4\x20\xE3\xE5\x75\xE7\x1E\xAA\x05\x50\xE5\xCA\xAD\xE7\x1C\xEA\xE4\xAF\xE0\x92\xE9\xE4\x59\xE6\xBA\xAB\x04\x2B\xF1\xE5\x9E\xE3\x96\xF9\xE4\x4D\xEA\xCB\x93\xE6\x2F\xF2\xE4\xAC\x07\x96\xC3\xE4\x53\xE0\xCB\xC3\xE6\x2B\xE6\xE6\xB8\xE7\x97\xC3\x9D\x56\x02\xCC\x8E\xE4\x26\xE7\xE6\xCE\xE4\x98\xF4\xE5", - "\x4E\xEA\xCC\x93\x56\x2B\x0D\xE6\xA4\xE1\x99\xCF\xE6\x6D\xE2\xCD\xBB\xE4\x35\xED\xB7\xAF\x00\x9B\xEE\x26\x58\x02\xCE\xBC\xE6\x39\xFF\xE6\xDD\xE7\x9E\xB1\x04\x9A\xD2\x0B\x65\xE6\x4F\xB3\x05\xEE\xE7\x5C\x34\x04\xEF\xD5\x0B\x5E\xDE\x2D\x11\xE7\xA7\xE1\x88\x37\x04\x9A\xD8\x0B\x34\xD9\x2E\x14\xD9\xBA\x04\x66\xFB\x04\x9A\xDC\x0B\x5E\xDD\x2F\x14\xD9\xBE\x05\x63\xE4\xC9\xDD\x11\x0C\x1D\xDA\x7D\x03\x06\x0E\xEA\x21\x05\x06\x9A\xD6\x0C\x34\xDB\x31\x08\xE4\xC8\x04\x66\xC9\x06\x7C\xE5\xCC\xCB\x72\x32\x11\xE8\x09\x0C\x19\x20\xE8\x15\xAE\x0C\x1C\xEA\x40\x0F\x06\x34\xD8\x1A\x34\xD9\x68\x04\xB3\xD2\x04\xCD\xD3\x06\x34\xDC\x1A\x34\xD9\x6A\x08\xC8\xD6\x04\xCD\xD7\x06\x41\xE6\x9B\xE8\xE5\x73\xEB\xD3\xE8\xE4\x34\xF9\xE6\xC8\xE1\xC8\x65\x06\x9A\xD6\x0E\x39\xE9\x35\xFC\xE6\x3F\xED\x97\xDB\xE7\xA0\xE1\xCD\xC9\xE8\xDE\x94\x07\x34\xDD\x1E\x06\xEB\xA5\xED\xD4\xC8\xEA\x55\xEC\xEA\x40\xED\xAA\xD8\xEA\x90\x93\x00\x0B\x10\xC1\xC1\x08\x04\x06\xAB\xC3\x08\xA5\xDE\xD4\xBE\xEB\x55\xFA\xEA\x68\xE9\xAB\xEA\xEA\xA5\xE9\xCE\xD4\xEB\x4E\xB2\x00\x62", - "\xEE\x62\xD3\xE7\x9E\xE4\xD7\xF9\xE5\x47\xEB\xEB\x78\x9B\x02\x31\xEA\x8D\xD3\x10\x14\x03\x5E\xFE\xD8\x92\xE5\x02\x3F\xEB\x6D\xCC\x64\x16\x03\x60\xEB\x16\x17\x07\xB0\xE7\x16\x0C\x0A\xD8\xF6\xEA\x33\x59\x00\x8D\xEB\x20\x1A\x01\xC8\xE2\x10\x1B\x00\x65\xE1\x08\x1C\x07\xB2\xC0\x01\x0E\x0A\xD9\x9E\x02\x66\xE5\x12\x1F\x02\xB3\xE0\x01\xBF\xEB\xD0\xD7\x1F\x08\x1F\xEB\xF6\x0D\x04\x28\xEC\x85\x07\x02\x1A\xEC\x0A\x1A\xEC\x29\x07\xB3\xFB\x18\x15\x0A\xD9\xAB\x02\x6C\xE5\xEB\x07\x8C\x05\x2B\xED\x84\x0E\x02\x3B\xEE\x0A\xB0\x01\xB7\xEA\x97\x31\x00\xCD\xE2\x03\x1A\xEF\x0C\x1A\xEC\x34\x02\xB3\xF5\x00\xCD\xE6\x03\x1A\xEF\x0D\x01\xEE\x94\x38\x07\x1A\xED\x1C\x00\xDD\xE9\xEA\xA3\x1A\x01\xD5\xE9\xCE\x3B\x01\xEC\xEE\x28\x3C\x00\x77\xF3\x0D\x3D\x07\xBB\xE6\xEA\x1D\x3E\x03\x1A\xEF\x0F\x1A\xEC\x40\x02\xB3\xC1\x02\xCD\xE2\x04\x1A\xEF\x10\x02\xEF\x09\x0C\x08\x1A\xED\x22\x04\xDA\xF2\x24\x12\x1E\xED\x03\x0A\x09\x38\xEE\x81\x0C\x04\x1A\xED\x13\x1A\xEC\x4E\x00\xBE\xC2\x19\x27\x0A\xD9\xD0\x02\x80\xF7\xEB\xDE\xB1\x0A\x3B\xEF\x80\x03\x05\x0B\xF3", - "\x3D\xB5\x02\x07\xF2\x91\x16\x02\xCD\xE7\x05\x1A\xEC\x16\x1A\xEC\x59\x02\xB3\xDA\x02\xCD\xEB\x05\x1A\xEC\x17\x11\xF0\x3A\xEE\xB1\xE1\xF0\x04\xFC\xD3\xA2\xF3\x51\xFB\xEA\x25\xF6\xE9\x1D\x02\xCD\xEE\x05\x20\xF3\x89\xE1\x13\x5F\x06\xC5\xFD\x24\x30\x0E\xE2\xE1\x02\x8B\xE2\x03\x32\xF5\xAD\xEA\x27\x31\x0A\xD9\xE4\x02\x66\xE5\x03\x9A\xEE\x0C\x1A\xED\x33\x0A\xD9\xE8\x02\x8B\xE9\x03\x9A\xEA\x0D\x35\xEF\x9E\x2D\x06\x0E\xF3\x1B\x0E\xF0\x71\x02\xB3\xF2\x02\xCD\xE3\x07\x39\xF2\x8F\x14\x03\x9A\xED\x0E\x16\xF3\xB3\xE2\x13\xF6\x02\x83\xF8\x03\x0E\xF3\x1C\xBA\x03\x2D\xF0\x35\x7B\x02\x66\xFC\x03\x9A\xED\x0F\x1A\xEC\x3F\x0A\xD9\xFF\x02\x66\xE0\x04\x9A\xE9\x10\x24\xF3\x30\x12\x08\x73\xF0\x5E\xE3\xEF\xD6\xE9\xC5\xF3\xEA\x13\xFE\xD6\xEC\xE8\x35\xA3\x04\x9A\xEC\x10\x36\xF3\x5E\xE5\x08\x03\xF7\xEE\x06\x04\x2E\xF7\x10\x2E\xF0\x44\x06\xE8\xF8\xF0\x3B\x29\x04\x9A\xEA\x11\x1A\xED\x45\x0A\xD9\x8C\x06\x66\xED\x04\x9A\xEE\x11\x2E\xF1\x47\x0A\xD9\x90\x07\x92\xF7\x2D\x93\x06\xC1\xD5\x04\x07\xF7\x09\x1A\xEC\x26\x1A\xEC\x99\x05\xD1\xC9\x08\x4D", - "\x0A\xD9\x9B\x06\xAA\xFC\xF3\x43\x74\x13\x0E\xF0\x4F\x01\xE6\x91\x88\x28\x0F\xF5\x13\x19\x14\x1A\xEC\x51\x0A\xD9\xA3\x06\x66\xE4\x05\x9A\xED\x14\x1A\xEC\x53\x0A\xD9\xA7\x04\xAE\xE2\x08\xA8\x07\xD8\xE3\xF1\x3D\xF4\xE2\x8E\xF6\x9F\xFC\xF2\xCF\xF0\xC5\xF4\xD3\x54\x0A\xD9\xAA\x06\xB2\xFE\xE5\xAB\x07\xDA\xD3\x1A\x56\x0E\xE2\xAD\x06\x8B\xEE\x05\xDA\xF2\xC7\xF4\x19\x57\x0A\xD9\xB0\x06\x66\xF1\x05\x9A\xEA\x16\x1A\xED\x59\x0A\xD9\xB4\x06\x8B\xF5\x05\x9A\xEE\x16\x1F\xF5\xD3\x29\x0B\x0E\xF3\x2E\x0E\xF0\xBD\x02\xB3\xFE\x04\xCD\xEF\x0B\x57\xF4\x30\x1A\xEC\xC1\x01\xDC\xF8\xED\x09\x72\x0C\x0E\xF0\x31\x15\xF5\x36\x8E\x18\x02\xF8\x20\x17\x0C\x1A\xEC\x32\x1A\xEC\xC9\x02\xB3\xCA\x06\xCD\xEB\x0C\x1A\xEC\x33\x1A\xEC\xCD\x07\xDA\xCE\x07\x85\xF2\xED\xF5\xE9\xB3\xFE\xF8\xCC\xF1\xE4\xCB\xF7\x91\xFE\xCB\xCF\x04\xC7\xF9\xF3\xCE\xF2\xCF\xE4\xF9\x3E\xFA\xF2\xAF\xF3\x9D\xE0\xF9\x65\x50\x1A\x27\xF8\x92\x41\x0D\x57\xF6\x34\x1A\xEC\xD3\x02\xB3\xD4\x06\xCD\xE5\x0D\x1A\xEE\x35\x1A\xEC\xD7\x02\xB3\xD8\x06\xCD\xE9\x0D\x1A\xEE\x36\x1A\xEC\xDB\x02", - "\xB3\xDC\x07\x99\xF1\xED\xE5\x25\x37\x0C\xFA\xB3\x0E\x1B\x10\xFB\x94\xF4\xF5\xAF\xDF\x37\x13\xFA\xA8\x58\x1C\x1A\xED\x70\x08\xF5\x9E\xBE\x38\x1D\xFA\x13\x1B\x1C\x2E\xF0\x72\x0E\xE2\xE5\x04\xD8\xE2\xF9\x9A\x26\x1C\x1A\xED\x73\x0A\xD9\xE8\x06\x66\xE9\x07\x9A\xEA\x1D\x1A\xED\x75\x0E\xE2\xEC\x06\x66\xED\x07\xF3\xF7\xC2\x30\x06\x07\xF2\x0F\x0E\xF0\x3D\x1A\xEC\xF5\x02\xB3\xF6\x07\x6B\xF7\x0F\x1A\xEC\x3E\x07\xFB\x2B\xFD\x8E\x79\x06\x07\xFB\x0F\x08\xFA\x6D\x9D\x07\x88\xF8\x00\x3E\x07\xCF\xEA\xD9\x80\x02\x83\x1F\xEA\xF7\x0F\xF2\xD2\xD9\x81\x02\x00\x1A\xFE\x5C\xE1\x08\x03\x06\xF3\xFC\xEA\x81\x04\x00\x22\xFC\x60\xFB\x19\x05\x06\xF4\xC4\xED\x8E\xF0\xEB\x83\xFB\xC7\xED\xFD\xD0\xF5\xE5\xEC\xF9\xF7\x86\x00\x2A\xFF\x10\x96\xFD\x30\xFD\xA1\x78\xFC\xA9\x39\x00\x3B\xFF\xC4\x0A\x00\xBE\xF8\x64\x0B\x01\xE0\xF9\xF8\xFD\x38\x03\x04\xFE\x39\x10\xF9\xCE\x00\xE4\xFF\x00\x48\xFC\x04\x08\xFE\x11\x00\xF9\xC5\x12\x09\x08\xFC\x93\x02\xE9\xE5\xED\xEF\x1E\x02\x26\xFC\xFB\x08\x01\x5B\xFE\x42\x1A\x00\xC8\xFB\x03\x08\xFE\x0E\x02\xFD\xBB\x19\x07", - "\x08\xFE\x1E\x05\xFC\xEE\xFC\x75\xAF\x01\x5E\xFD\x42\x01\x01\xEE\xFA\x85\xA3\x00\xF5\xFA\x4B\x24\x00\xF2\xE5\x01\xC8\xFE\x04\x08\xFF\x13\x08\xFC\xA8\x00\xF2\xE9\x01\xC8\x7E\x0A\x04\xFF\x50\x0D\x2B\x03\x00\x88\xF2\x79\x7E\xB3\x7C\x02\x82\xEE\x71\x7E\x55\x7C\xEC\x7A\x63\x2C\x00\x06\x83\xCB\x7E\x00\x87\x80\x13\x82\x04\x8F\xFA\x57\x80\x68\x7D\xBB\x5D\x02\x08\x7F\x2E\x01\x04\x8D\xF4\x74\x09\x2F\x02\x07\x85\x9D\x22\x80\xD9\x24\x09\x89\x10\x32\x00\x26\x81\x05\x8C\x68\x33\x00\xC8\x7C\x0D\x08\xFC\x75\x00\xC8\x7E\x0D\x08\xFC\x77\x00\xC8\x7C\x0E\x09\x02\x83\x04\x39\x00\xF2\x7A\x03\x17\x7F\xF2\x11\x0F\x01\xFF\x43\x04\x3F\x03\x0F\x82\x10\x01\x01\xC8\x7E\x10\x08\xFC\x43\x01\x37\x80\xC8\x04\x04\x08\x7F\x45\x01\x12\x85\xFC\x76\x46\x46\x02\x10\x81\x10\x08\x01\x52\x83\x3D\x5A\x04\x0E\x81\x9A\x13\x12\x08\xFC\x4C\x01\xC8\x7D\x13\x08\xFC\x4E\x01\xC8\x7F\x13\x08\xFC\x50\x01\xC8\x7D\x14\x08\x05\x89\x80\x2A\x82\xEC\x7B\x00\xAC\x7E\x18\x83\x13\x8C\x06\xB8\x66\x52\x00\xF2\x73\x05\x27\x81\xED\x68\x15\x04\x07\xB0\x12\x55\x00\x16\x86\x05", - "\x18\x81\x57\x03\x1D\x8C\x00\xBD\x14\x58\x00\xF2\x79\x05\x08\x7F\x5A\x00\xF2\x7B\x05\x08\x7F\x5C\x00\xF2\x7D\x05\x18\x81\x5E\x00\xF2\x7F\x05\x3C\x80\x3D\x16\x18\x05\x05\xA4\x01\x55\x82\x19\x08\xFC\x67\x01\xC8\x7C\x1A\x0E\x07\xB8\x08\x69\x00\xF2\x7A\x06\x1B\x82\x14\x83\x3D\x4B\x06\x15\x81\x6D\x01\x15\x83\x0E\x6F\x01\xA0\x81\xE0\x00\x07\x08\x7F\x71\x00\xF2\x72\x07\x08\x7F\x73\x00\xF2\x74\x07\x08\x7F\x75\x00\xF2\x76\x07\x29\x82\x8E\x0B\x1D\x08\xFC\x78\x01\xB8\x82\x1A\x8B\xFE\x6E\x81\xA1\x81\x06\x8B\x06\x81\x83\xC0\x80\x9D\x29\x07\x3D\x82\x0D\x81\x1B\x8E\xF2\x5F\x80\xCC\x82\x2F\x8F\x07\xA9\x81\x18\x22\x1E\x08\xFC\x7B\x01\xC8\x82\x02\x8F\x0B\x8B\x83\xCE\x83\x1B\x85\x0C\x8D\x83\xC9\x83\x0D\x3C\x07\x08\x7F\x7D\x01\x35\x8C\xBA\x7E\x01\xE2\x83\x0F\x1F\x07\x18\x81\x80\x00\x16\x81\x08\x25\x83\xC2\x80\x2C\x12\x08\x08\x7F\x83\x00\xF2\x74\x08\x08\x7F\x85\x00\xF2\x76\x08\x08\x7F\x87\x00\x16\x88\x08\x08\x7F\x89\x00\x24\x87\x5B\x0C\x02\x55\x82\x23\x05\x05\x90\x02\xC8\x7D\x24\x08\xFC\x52\x02\xEC\x81\x40\x03\x09\x08\x7F\x94\x01", - "\x42\x88\x0D\xA5\x39\x95\x01\x15\x87\x09\x26\x82\x11\x45\x26\x0E\x10\x85\x09\x9A\x00\xF2\x7B\x09\x08\x7F\x9C\x00\xF2\x7D\x09\x08\x7F\x9E\x00\xF2\x7F\x09\x08\x7F\xA0\x03\x45\x83\x0C\x96\x80\xED\x83\x33\x8A\x0C\xA8\x81\x2B\x87\x49\x80\x32\x61\x02\xC8\x7E\x28\x06\x12\xA1\x68\xA3\x03\x4C\x89\x33\x24\x02\x58\x81\x29\x08\x05\xA6\x02\x36\x86\x36\x8A\x49\x27\x02\xC8\x7C\x2A\x08\xFC\x69\x02\xC8\x7E\x2A\x08\xFC\x6B\x02\xC8\x7C\x2B\x08\x05\xAD\x02\xC8\x7E\x2B\x0E\x0F\xA7\x16\xB1\x01\x15\x83\x0B\x15\x81\xB5\x00\xF2\x76\x0B\x08\x7F\xB7\x02\x43\x88\x0B\x08\x7F\xB9\x01\x4F\x84\x0C\xBE\x38\xBA\x01\x15\x8C\x0B\x14\x84\x36\x46\x2F\x0E\x15\xB4\x09\xBF\x00\xF2\x70\x0C\x08\x7F\xC1\x00\xF2\x72\x0C\x08\x7F\xC3\x00\xF2\x74\x0C\x08\x7F\xC5\x02\x43\x86\x0C\x08\x7F\xC7\x03\x53\x89\x12\xBE\x84\x2C\x87\x5E\x8F\x15\xBD\x85\xDB\x81\x36\x8D\xAD\x0A\x03\xC8\x7F\x32\x07\x16\x82\x6B\xCC\x03\x61\x83\x2B\x0D\x03\x58\x82\x33\x08\x05\x8F\x03\x8A\x85\x37\x8B\x32\x10\x03\xC8\x7D\x34\x08\xFC\x52\x03\xC8\x7F\x34\x08\xFC\x54\x03\xC8\x7D\x35\x08\x05\x96", - "\x03\xC8\x7F\x35\x0A\x17\x95\x18\xDA\x01\x15\x8C\x0D\x15\x81\xDE\x00\xF2\x7F\x0D\x08\x7F\xE0\x02\x43\x81\x0E\x08\x7F\xE2\x01\x64\x86\x0D\xBD\x29\xE3\x01\x15\x85\x0E\x24\x85\xB6\x47\x39\x02\x1B\x86\x04\xE8\x00\xF2\x79\x0E\x08\x7F\xEA\x00\xF2\x7B\x0E\x08\x7F\xEC\x00\xF2\x7D\x0E\x08\x7F\xEE\x02\x43\x8F\x0E\x08\x7F\xF0\x03\x68\x8F\x10\xB3\x86\x7C\x86\x4B\x82\x18\xA8\x84\x81\x86\x64\x8D\xC4\x33\x03\xC8\x7C\x3D\x0B\x1B\x90\x68\xF5\x03\x76\x83\x02\x58\x81\xF7\x00\x16\x88\x0F\x1E\x87\xD5\x87\xB9\x09\x0F\x08\x7F\xFA\x00\xF2\x7B\x0F\x08\x7F\xFC\x00\xF2\x7D\x0F\x08\x7F\xFE\x03\x19\x88\xFC\x40\x00\x11\x0A\x33\x62\x4F\x03\x00\xF5\x84\xE7\x78\x4B\x79\x87\x02\x06\x7D\x07\x00\x3C\x87\xA3\x7D\x40\x08\x00\x00\x88\x1E\x6D\x02\x04\x20\xAB\x7E\x6F\x0E\x02\x07\x20\x8A\x04\x0B\x03\x82\x80\x1D\x99\x48\x0C\x00\x81\x86\x1F\x0E\x00\x12\x8B\x7B\x40\x01\x0E\x88\xB7\x15\x04\x08\x21\x83\x04\x12\x03\x86\x82\x10\x13\x00\x1E\x89\x40\x04\x01\x21\x88\x00\x01\x05\x04\x22\x96\x00\x24\x8B\x05\x04\x22\x93\x0D\x18\x00\x89\x89\x01\x04\x88\xD8\x7C\x34", - "\x8F\x20\x94\x87\xCF\x86\x8C\x86\x23\xAD\x84\xD7\x80\xE0\x4C\x01\x2B\x88\xD2\x86\x75\x80\x18\xB5\x88\x38\x8A\x4A\x8E\x17\xB4\x88\xBD\x11\x07\x0C\x23\xB9\x88\x3D\x8B\x8C\x8C\x0D\x8A\x89\xD3\x87\x92\x87\x23\xA0\x1D\x1E\x03\x91\x82\x24\xA5\x87\x4F\x88\x95\x81\x24\x91\x87\x48\x8A\x1B\x7F\x01\x24\x88\x20\x00\x8C\x8E\x23\x89\x89\x55\x88\x90\x83\x24\x8E\x89\x57\x8B\x5F\x85\xC7\x23\x00\x24\x88\x09\x02\x25\xBE\x84\x25\x03\x9A\x83\x67\x26\x00\x6E\x88\x9D\x07\x02\x31\x89\x8E\x08\x0A\x04\x27\x8D\x89\x37\x15\x0A\x04\x22\xAA\x00\x24\x8B\x0A\x04\x22\xAC\x00\x24\x89\x0B\x04\x22\xAE\x00\x77\x8A\x42\x0F\x02\x24\x88\x30\x02\x97\x8D\x53\x33\x00\x15\x8A\x12\x1D\x28\x86\x04\x37\x00\x89\x88\x03\x24\x88\x39\x01\xA1\x87\x2E\x3A\x00\x24\x8B\x0E\x06\x29\xA1\x89\x18\x38\x0F\x0F\x28\x83\x04\x3E\x03\xA7\x8A\x4E\x40\x01\x9B\x8B\x0F\x11\x04\x24\x88\x42\x00\x89\x83\x04\x24\x88\x44\x00\x89\x85\x04\x24\x88\x46\x00\x89\x87\x04\x25\x8A\x63\x88\x9E\x8F\x25\x99\x89\x53\x8A\x98\x86\x25\xB5\x8A\xEF\x44\x12\x04\x22\x89\x01\xB4\x88\xC9\x7A\x04\x01\x8B", - "\x3B\x1B\x12\x04\x2C\x8C\x01\xC4\x89\x13\x04\x2C\xBF\x88\x53\x0E\x13\x04\x22\x8F\x01\x24\x88\x14\x04\x22\x91\x01\x24\x8A\x14\x04\x22\x93\x01\xC4\x88\x15\x04\x22\x95\x01\x8A\x8B\x6D\x18\x05\x22\x8A\x01\x06\x16\x00\x2E\x80\x00\x5C\x00\x89\x8D\x05\x24\x88\x5E\x03\xB2\x8C\x23\x1F\x01\x24\x88\x18\x0A\x2E\xB8\x8A\x41\x39\x18\x03\x2E\xA3\x01\xE3\x8B\x38\x45\x06\x2F\x8B\x39\x0E\x19\x04\x22\xA7\x01\x24\x88\x1A\x04\x22\xA9\x01\x24\x8A\x1A\x04\x22\xAB\x01\x24\x88\x1B\x08\x2F\xB8\x08\x6D\x00\x89\x8E\x06\x04\x88\x08\x4C\xB3\x80\x26\xA5\x89\x44\x8B\xC3\x8C\x2B\x8C\x89\xB7\x8A\x2E\x12\x07\x24\x88\x73\x03\xC1\x8E\xC8\x74\x01\x1A\x8C\x3B\x15\x07\x04\x8B\x76\x00\xB1\x87\x07\x1D\x8C\x64\x8B\x85\x18\x07\x24\x88\x79\x00\x89\x8A\x07\x24\x88\x7B\x00\x89\x8C\x07\x24\x88\x7D\x00\xB1\x8E\x07\x24\x88\x7F\x01\xB7\x87\x5A\x02\x02\xE3\x88\x21\x03\x2E\x86\x02\x24\x8B\x21\x04\x22\x88\x02\x24\x8F\x6C\x09\x08\x24\x88\x8A\x01\xD0\x85\x31\x93\x32\x8B\x03\xB8\x8D\x08\x35\x8B\x11\x47\x23\x06\x34\xA7\x0B\x90\x00\x89\x81\x09\x24\x88\x92\x00\x89\x83", - "\x09\x24\x88\x94\x00\x89\x85\x09\x24\x88\x96\x03\xD3\x86\x10\x17\x02\x24\x88\x26\x0C\x30\x87\x8D\x66\x88\xBC\x85\x36\xB9\x8A\x0E\x8E\xD9\x81\x31\xBD\x1D\x9C\x00\x89\x8D\x09\x1E\x8D\x4A\x72\x27\x00\x37\x8A\x12\x9F\x00\xB1\x80\x0A\x04\x8B\xA1\x03\xDC\x8B\x2B\x88\x12\xA2\x00\x89\x83\x0A\x24\x88\xA4\x00\x89\x85\x0A\x24\x88\xA6\x00\x89\x87\x0A\x04\x8B\xA8\x00\x89\x89\x0A\x36\x8C\x17\x18\x2B\x03\x2E\xAE\x02\xE3\x88\x2C\x04\x22\xB1\x02\x24\x8A\x2C\x0A\x37\x80\x00\xB3\x00\x89\x84\x0B\x17\x8E\x69\x8D\x9F\x25\x0B\x23\x8B\xB7\x00\xD3\x86\x13\x79\x02\x9C\x8C\x8F\x0A\x0B\x24\x88\xBB\x00\x89\x8C\x0B\x24\x88\xBD\x00\x89\x8E\x0B\x24\x88\xBF\x00\x89\x80\x0C\x17\x8E\xC1\x00\x89\x82\x0C\x23\x8D\x14\x8D\xEE\x8C\x29\x92\x8C\x7B\x8E\xAE\x8E\x3B\x9D\x8E\x3A\x1A\x31\x04\x22\x87\x03\xA5\x8D\x88\x68\x0C\x05\x8F\x39\x0D\x32\x04\x2C\x8A\x03\xC4\x8B\x32\x08\x3C\x98\x89\x39\x0C\x33\x04\x22\x8D\x03\x24\x8A\x33\x04\x22\x8F\x03\x24\x88\x34\x04\x22\x91\x03\xC4\x8A\x34\x04\x22\x93\x03\x8C\x8D\x85\x16\x0D\x23\x8B\xD8\x03\xB8\x8A\x0D\x24\x88\xDB", - "\x00\x89\x8C\x0D\x17\x8E\xDD\x00\x89\x8E\x0D\x0F\x8F\x67\x8F\x24\x3F\x0D\x23\x8B\xE1\x02\xE8\x86\x1B\x63\x03\xF0\x8C\x9D\x04\x0E\x24\x88\xE5\x00\x89\x86\x0E\x24\x88\xE7\x00\x89\x88\x0E\x24\x88\xE9\x00\x89\x8A\x0E\x17\x8E\xEB\x00\x89\x8C\x0E\x38\x8E\xBB\x8E\xDA\x85\x32\xBD\x8E\xC0\x8D\xFC\x82\x41\xAB\x8D\xB6\x44\x3C\x09\x3F\x8F\x90\xBF\x8C\xEF\x89\x41\x8E\x90\xB6\x8A\xEE\x8F\x45\x71\x03\x17\x91\x07\x9D\x40\xA8\x8D\x1A\x91\x04\x94\x41\x90\x8F\x3E\x86\x3C\x01\x42\xA4\x8D\x27\x93\x04\x98\x41\xA6\x90\x2F\x91\x09\x92\x43\xB0\x12\xF3\x03\x0A\x9E\x41\x93\x8C\x23\x90\x0A\x9E\x42\xA2\x90\x10\x8F\xF8\x14\x0F\x24\x88\xF5\x00\x03\x9D\x43\xBC\x90\x38\x93\x10\x9C\x42\xB1\x90\x1C\x93\x11\x9C\x6C\x39\x03\x24\x8A\x3E\x06\x43\x9E\x5E\xFB\x03\x13\x93\x31\x3C\x03\xC4\x89\x3F\x04\x2C\xBE\x03\x52\x91\x11\x92\x32\x24\x88\x13\x09\x27\x21\x00\x14\x08\x98\x7E\x00\x00\x46\x9B\x7E\x02\x07\x00\x03\x46\x9F\x7E\xAA\x4B\x19\x91\x20\xB5\x0C\x05\x02\x1A\x9E\xB1\x46\x00\x6E\x91\x8C\x8F\x43\x09\x00\x6E\x92\x7D\x0B\x00\x35\x91\x0A\x05\x03\x0E\x46", - "\x9E\x07\x0E\x03\x1E\x96\xD1\x3E\x91\xEF\x0C\x04\x00\x48\x86\x04\x11\x03\x20\x96\x44\x87\x44\x12\x00\x1E\x99\x10\x14\x00\x8A\x92\x0A\x56\x01\x06\x92\x17\x1B\x05\x00\x49\x81\x04\x18\x03\x24\x90\x00\x19\x00\x96\x92\x06\x06\x49\x9B\x00\x96\x90\x07\x06\x49\x9D\x00\x96\x90\x0C\x94\x44\x90\x90\x33\x90\x09\x99\x44\xB7\x90\xA4\x91\xDF\x1E\x01\x16\x92\x1F\x01\x28\x99\xCE\x60\x00\xAE\x92\x92\x11\x02\x31\x92\x40\x0A\x08\x04\x4B\xB8\x08\x23\x03\x2D\x9B\x43\xB2\x13\x24\x02\x25\x95\x02\x16\x92\x26\x02\x25\x97\x02\x16\x92\x28\x02\x25\x99\x02\x3A\x92\x74\x0A\x0A\x06\x49\xAB\x00\x71\x92\x3C\x1E\x02\x0D\x92\x03\x04\x0C\x00\x4D\x8B\x04\x96\x93\x0C\x06\x49\xB4\x00\xC8\x92\xE5\x05\x03\x16\x92\x36\x01\x36\x93\x4A\xAB\x44\x37\x03\x34\x94\x71\x62\x93\xF7\x53\x0E\x0E\x4D\x97\x0F\x3C\x02\x25\x9D\x03\x16\x92\x3E\x02\x25\x9F\x03\x16\x92\x40\x02\x25\x91\x04\x16\x92\x42\x03\x39\x97\x2E\x03\x01\x96\x90\x11\x04\x4E\xA2\x92\x4A\x91\x3F\x98\x4A\x9B\x90\xA6\x91\x40\x9A\x43\x81\x0E\x46\x02\x25\x97\x04\x36\x93\x26\x78\x12\x08\x50\xA7\x16\x49\x03", - "\x42\x92\x10\x0A\x01\x0E\x95\x40\x0B\x04\x11\x94\x00\x96\x8E\x1C\x04\x16\x92\x4D\x02\x25\x9E\x04\x16\x92\x4F\x02\x25\x90\x05\x16\x92\x51\x00\x45\x92\x05\x16\x92\x53\x01\x33\x9D\x53\x16\x01\xE4\x90\x16\x04\x4E\x9A\x01\x96\x93\x16\x06\x49\x9C\x01\x14\x95\x91\x0D\x05\x16\x92\x5E\x01\x4C\x95\x4A\x93\x32\x5F\x00\x39\x91\x06\x3B\x93\x11\x47\x18\x06\x53\xB4\x0C\x64\x02\x25\x95\x06\x16\x92\x66\x02\x25\x97\x06\x16\x92\x68\x02\x25\x99\x06\x16\x92\x6A\x03\x4F\x90\x24\x2B\x01\x96\x90\x1B\x0C\x53\xA7\x92\x39\x93\x2E\x9F\x4F\xBC\x93\x57\x97\x4D\x96\x55\x95\x95\x2D\x91\x7E\x3E\x06\x0E\x95\x03\x94\x12\x92\x50\x9B\x95\x87\x90\x57\x92\x56\xA1\x95\xBB\x0F\x1B\x00\x56\xA4\x95\x5A\x91\x2A\x93\x56\x9D\x95\x8E\x08\x1C\x06\x49\xB1\x01\x53\x97\x5B\x97\x56\xAC\x95\x6E\x94\x5A\x9E\x4F\xA6\x95\xDF\x93\xD4\x03\x07\x16\x92\x74\x03\x5A\x9C\xC5\x75\x01\x82\x96\x3B\x16\x07\x14\x94\x77\x00\x45\x98\x07\x05\x96\x7D\x97\xCE\x09\x07\x16\x92\x7A\x02\x25\x9B\x07\x16\x92\x7C\x02\x25\x9D\x07\x16\x92\x7E\x00\x45\x9F\x07\x16\x92\x80\x02\x49\x97\x5B\x03", - "\x02\xE4\x91\x21\x04\x4E\x87\x02\x96\x90\x22\x06\x49\x89\x02\x8C\x96\x42\x0A\x08\x16\x92\x8B\x01\x6A\x99\x55\x93\x2A\x8C\x00\x39\x9E\x08\x35\x95\x15\x44\x24\x0E\x5A\x82\x0C\x91\x02\x25\x92\x09\x16\x92\x93\x02\x25\x94\x09\x16\x92\x95\x02\x25\x96\x09\x16\x92\x97\x03\x6D\x95\x56\x87\x97\x6D\x95\x45\x98\x57\x8A\x97\x70\x95\x63\x96\xC9\x18\x02\x96\x91\x26\x06\x5C\x82\x71\x9A\x03\x74\x98\x48\x1B\x02\x14\x94\x27\x04\x51\x9D\x02\xD6\x94\x73\x9E\x4E\x1E\x02\x96\x93\x27\x06\x49\xA0\x02\x96\x91\x28\x06\x49\xA2\x02\x96\x93\x28\x04\x51\xA4\x02\x96\x91\x29\x0E\x59\xA7\x16\xA8\x00\x39\x9A\x0A\x24\x93\xAC\x02\x25\x9D\x0A\x16\x92\xAE\x01\x77\x9F\x0A\x16\x92\xB0\x01\x77\x98\x55\x8C\x28\xB1\x00\x39\x93\x0B\x34\x96\x19\x49\x2D\x0E\x5F\xBC\x08\xB6\x02\x25\x97\x0B\x16\x92\xB8\x02\x25\x99\x0B\x16\x92\xBA\x02\x25\x9B\x0B\x16\x92\xBC\x01\x77\x9D\x0B\x16\x92\xBE\x02\x1B\x91\x6E\x5E\x97\xCE\x96\x5D\x9D\x61\xBA\x95\xAF\x96\x87\x9B\x57\x93\x0C\xC4\x02\x25\x95\x0C\x07\x98\x21\x6A\x31\x08\x62\xB9\x0C\xC7\x00\x45\x98\x0C\x14\x94\xC9\x03\x8A", - "\x90\x62\x82\x0C\xCA\x02\x25\x9B\x0C\x16\x92\xCC\x02\x25\x9D\x0C\x16\x92\xCE\x02\x25\x9F\x0C\x14\x94\xD0\x02\x25\x91\x0D\x2F\x97\x17\x18\x35\x04\x4E\x96\x03\xE4\x90\x36\x06\x49\x99\x03\x96\x92\x36\x0D\x5D\x9B\x03\x96\x90\x37\x02\x63\x8B\x97\x80\x29\x37\x04\x4E\x9F\x03\x04\x9A\x4C\x41\x0E\x13\x99\x74\x0A\x38\x06\x49\xA3\x03\x96\x90\x39\x06\x49\xA5\x03\x96\x92\x39\x06\x49\xA7\x03\x96\x90\x3A\x0D\x5D\xA9\x03\x96\x92\x3A\x0A\x61\xA3\x98\xC9\x97\x7F\x98\x5C\xB9\x95\x54\x9A\x56\x9D\x5C\x8A\x04\xF0\x02\x25\x91\x0F\x1C\x99\xC2\x6A\x3C\x0C\x67\xB3\x0A\xF3\x00\x45\x94\x0F\x14\x94\xF5\x03\x9F\x90\x67\x81\x04\xF6\x02\x25\x97\x0F\x16\x92\xF8\x02\x25\x99\x0F\x16\x92\xFA\x02\x25\x9B\x0F\x14\x94\xFC\x02\x25\x9D\x0F\x04\x99\x15\x19\x8E\x0A\x0A\x7D\x87\x3A\x0B\x2B\x5C\x88\x1D\x9A\x64\x91\x40\x05\x00\x20\x9A\x68\x92\x01\x04\x6A\xAB\x91\x53\x0F\x01\x07\x6A\x9E\x6C\x08\x03\xAA\x98\x20\xB7\x99\xEA\x39\x02\x0B\x6A\xB6\x91\xB3\x9B\x7B\x4D\x00\x2E\x9A\xF2\x12\x03\x08\x6B\x89\x04\x0F\x03\xAE\x96\x10\x10\x00\xBE\x9B\x40\x01\x01\x01\x9B", - "\x61\x40\xB1\x94\x06\x46\x9B\x67\x40\xB2\x93\x35\x15\x00\xC8\x9A\x05\x0B\x6A\x9B\x98\x72\x99\x9C\x96\x67\xB7\x95\xB0\x98\x5F\x97\x68\x9C\x98\x0A\x04\x07\x08\x6C\x9D\x00\xCA\x99\x3A\x7E\x01\x1D\x9B\x4A\x1B\x07\x00\x6E\x80\x09\x20\x03\xB8\x98\x23\x21\x00\xE6\x99\x9D\x90\x4B\x22\x00\xC8\x9B\x08\x08\x6C\xA4\x00\xC8\x99\x09\x08\x6C\xA6\x00\xC8\x9B\x09\x09\x6E\xB4\x09\x28\x00\xB2\x99\x02\x2B\x9A\x72\x92\x22\x1C\x02\x35\x9A\xBC\x74\xC0\x96\x10\x30\x00\xC8\x99\x0C\x08\x6C\xB2\x00\xF7\x9A\xE5\x03\x03\x08\x9B\x34\x01\xC2\x9F\x61\x8B\x39\x35\x02\xC0\x93\x10\x37\x00\x12\x9E\x3A\x59\x03\x0E\x9C\xD7\x0E\x0E\x08\x6C\xBB\x00\xC8\x98\x0F\x08\x6C\xBD\x00\xC8\x9A\x0F\x08\x6C\xBF\x00\xC8\x98\x10\x08\x71\xA7\x0B\x41\x00\xB2\x92\x04\x0F\x9B\xD7\x99\xB4\x94\x67\x95\x9B\x73\x98\xB6\x91\x62\xB3\x98\x03\x04\x12\x08\x6C\x89\x01\x27\x9E\x89\x7A\x04\x39\x9C\xA7\x17\x12\x0C\x73\xBC\x77\x3F\x9D\x40\x0D\x04\x01\x9D\x32\x9F\x6D\x1E\x04\x08\x9B\x4F\x00\xB2\x90\x05\x08\x9B\x51\x00\xB2\x92\x05\x08\x9B\x53\x00\xD1\x94\x05\x08\x9B\x55\x00\xBF\x92", - "\x4F\x18\x01\x15\x9D\xB8\x89\x75\xA4\x8B\xC8\x99\x17\x08\x6C\x9E\x01\x44\x9D\x91\x0F\x05\x08\x9B\x60\x01\xD8\x93\x6D\xAC\x2E\x61\x03\xD6\x93\x06\x1B\x9D\xF6\x8A\xD9\x94\x33\x26\x01\xC8\x9B\x19\x08\x6C\xA8\x01\xC8\x99\x1A\x08\x6C\xAA\x01\xC8\x9B\x1A\x08\x6C\xAC\x01\x6E\x9C\x90\x0D\x06\x08\x9B\x6E\x00\xCB\x93\x73\xAA\x9B\x22\x9B\xE0\x90\x73\x92\x9B\x54\x95\xCC\x94\x07\x08\x9B\x75\x01\xDF\x9E\xC7\x76\x01\x8E\x9D\x39\x17\x07\x04\x9D\x78\x00\xD1\x99\x07\x11\x9E\x87\x9C\x22\x1A\x07\x08\x9B\x7B\x00\xB2\x9C\x07\x08\x9B\x7D\x00\xB2\x9E\x07\x08\x9B\x7F\x00\xD1\x90\x08\x08\x9B\x81\x02\xD5\x9D\x53\x04\x02\x5B\x9E\x21\x0B\x75\x88\x02\xC8\x99\x22\x08\x6C\x8A\x02\x98\x9E\xA3\x0B\x08\x08\x9B\x8C\x01\xED\x9F\x70\x9F\x32\x8D\x03\xD6\x9F\x08\x2C\x9D\x11\x45\x24\x0A\x7B\x8B\x0B\x92\x00\xB2\x93\x09\x08\x9B\x94\x00\xB2\x95\x09\x08\x9B\x96\x00\xB2\x97\x09\x08\x9B\x98\x03\xF0\x99\x10\x19\x02\xC8\x9A\x26\x02\x78\x96\x9B\x86\x9C\xB5\x9A\x7D\xBB\x9E\xDB\x9D\xCB\x97\x76\xBE\x54\xA0\x02\xF4\x98\x7D\xA3\x9F\x31\x9E\xCB\x95\x74\xA5\x9F\xDF", - "\x9C\xEA\x21\x0A\x22\x9F\xE8\x9D\xE2\x98\x78\x85\x9E\xE4\x9F\xFB\x94\x73\xAA\x53\xA2\x00\xFB\x92\x7F\x84\x9E\xF3\x9F\xCB\x9D\x7D\x99\x9F\xDC\x9F\x37\x93\x0A\x36\x9F\xFA\x9D\xFF\x9E\x7D\xAE\x9F\x01\xA3\x00\xA0\x7F\x82\x38\xA4\x00\x00\xA7\x7E\xB7\x9F\x99\x9F\x02\xA5\x80\xBC\x9F\x06\xA1\x90\x35\x0A\x0A\xA0\xE6\x9D\x05\xA9\x7E\xB1\x9F\x0F\xA0\x06\xA7\x4F\x66\x02\xC8\x9B\x29\x07\x7D\xAD\x9F\x07\xA0\x03\xAB\x7F\x9A\xA0\x16\xA0\x01\xAE\x80\x80\x00\xAD\x00\xB2\x9E\x0A\x14\xA0\x98\x5B\x2B\x0C\x82\xB4\x0C\xB0\x00\xD1\x91\x0B\x04\x9D\xB2\x03\x0B\xA1\x82\xAB\x0C\xB3\x00\xB2\x94\x0B\x08\x9B\xB5\x00\xB2\x96\x0B\x08\x9B\xB7\x00\xB2\x98\x0B\x04\x9D\xB9\x00\xB2\x9A\x0B\x2A\x9E\xB7\x15\x2F\x0B\x75\xBF\x02\x5B\x9D\x30\x08\x6C\x82\x03\xC8\x9B\x30\x0A\x80\x84\x03\xC8\x99\x31\x06\x83\xB9\x9F\x4D\x32\x31\x0B\x75\x88\x03\xC0\x9E\x4D\x4A\x0C\x17\xA1\x61\x0B\x32\x08\x6C\x8C\x03\xC8\x99\x33\x08\x6C\x8E\x03\xC8\x9B\x33\x08\x6C\x90\x03\xC8\x99\x34\x00\x86\x8D\xA0\x25\xA3\x0D\xA7\x82\xB1\xA1\x58\xA0\x1D\xAE\xC8\x52\x03\xC8\x9B\x34\x0F\x86", - "\x82\x6B\xD4\x03\x1E\xA3\x2B\x15\x03\x44\x9E\x35\x04\x74\x97\x03\x7E\xA3\xB5\x98\x0D\x08\x9B\xD9\x00\xB2\x9A\x0D\x08\x9B\xDB\x00\xB2\x9C\x0D\x08\x9B\xDD\x00\xD1\x9E\x0D\x08\x9B\xDF\x00\x12\xA7\x5A\x22\x03\x5B\x9C\x39\x0B\x75\xA6\x03\xC8\x9B\x39\x08\x6C\xA8\x03\x0A\xA1\x3A\x08\x6C\xAA\x03\x85\xA0\x04\xA0\x83\x2B\x03\x5B\x9D\x3B\x0D\x85\xB6\x46\xEF\x01\x29\xA6\x10\x30\x03\xC8\x99\x3C\x08\x6C\xB2\x03\xC8\x9B\x3C\x08\x6C\xB4\x03\xC8\x99\x3D\x08\x6C\xB6\x03\x0A\xA3\x3D\x08\x6C\xB8\x03\xAE\xA0\x08\xA5\x87\x97\xA0\xC2\xA0\xFE\x96\x8C\xB0\xA1\xC4\xA2\x08\xA2\x80\x82\x26\xF9\x01\x30\xAA\x8C\x91\xA0\xC7\xA3\x08\xA7\x0F\x7A\x03\xC8\x9B\x3E\x0E\x8C\x99\xA0\xC5\xA0\x32\xA6\x82\xB6\xA1\xDA\xA2\x1C\xA3\x0E\x7C\x03\xC8\x99\x3F\x07\x8D\xBC\x68\xFE\x03\x38\xA8\x24\x04\x9D\x41\x0B\x12\x41\x00\x14\x5B\xAF\x9A\x34\xA7\x61\x02\x00\xEC\xA1\x22\x21\x8F\x8C\x22\xF3\xA3\x23\x25\x8F\x92\x22\xF7\xA1\x25\x29\x8F\xAB\x0C\x08\x03\x3E\xA0\x00\x09\x00\xD4\x59\xBF\x98\x48\x0C\x00\xD4\x5B\x84\x85\x90\x8A\x04\x10\x02\x3F\xA1\x01\x3E\xA3\x12\x02", - "\x3F\xA3\x35\x13\x00\xFE\xA0\x05\x0E\x90\x89\xA3\x25\x39\x05\x07\x90\xA2\x04\x17\xA6\x0A\x59\x01\x13\xA4\xB0\x12\x06\x0E\x8F\x9B\x00\xFE\xA0\x07\x0E\x8F\x9D\x00\xFE\xA2\x07\x0E\x8F\x9F\x00\xFE\xA0\x08\x0C\x91\x9E\xA3\x14\xA7\x1C\xAD\x92\x9C\xA3\xEE\xA0\x36\xAF\x8C\xAF\x7F\xFE\xA2\x08\x0B\x92\xBE\x84\x23\x03\x4D\xA3\x67\x24\x00\x3A\xA4\x9D\x05\x02\x3D\xA4\x8E\x0A\x09\x00\x94\x8B\xA3\x41\x13\x09\x0E\x8F\xA8\x00\xFE\xA1\x0A\x0E\x8F\xAA\x00\xFE\xA3\x0A\x0E\x8F\xAC\x00\x43\xA6\x42\x0D\x02\x3E\xA3\x2E\x01\x40\xA2\x4F\x31\x00\x19\xA7\x2A\x49\x95\x82\x04\x35\x02\x3F\xA6\x03\x3E\xA3\x37\x01\x54\xA7\x2E\x38\x00\xFE\xA1\x0E\x02\x96\xA4\xA0\x75\x32\x0E\x0B\x95\x81\x04\x3C\x03\x5A\xA7\x4F\x7E\x00\x67\xA7\x0F\x1F\x03\x3E\xA3\x40\x02\x3F\xA1\x04\x3E\xA3\x42\x02\x3F\xA3\x04\x3E\xA3\x44\x02\x3F\xA5\x04\x31\xA5\x20\x0E\x11\x0E\x8F\x87\x01\x80\xA6\x4C\xA6\x98\xAE\xA4\xDB\xA3\x4B\xAA\x98\x89\xA6\x8C\xA4\x4B\xAD\x98\x93\x32\x48\x01\x61\xA8\x98\x8E\xA6\x94\xA7\x30\xA4\x4D\x49\x01\xFE\xA2\x12\x02\x99\xB0\xA4\x44\xA5\x36\xA1\x93\x93", - "\xA6\x96\xA5\x65\xAB\xA3\x4B\x01\xFE\xA0\x13\x0B\x99\xAD\x6B\x4D\x03\x69\xA0\x4B\x0E\x01\x92\xA7\x13\x02\x99\x90\x01\xAA\xA6\x68\xA1\x38\x11\x01\xFE\xA2\x14\x0E\x8F\x93\x01\xFE\xA0\x15\x0E\x8F\x95\x01\xFE\xA2\x15\x02\x99\x97\x01\xFE\xA0\x16\x06\x95\xBD\x14\x5B\x02\x5B\xAD\x05\x2E\xA5\x5F\x02\x3F\xA0\x06\x3E\xA3\x61\x01\x6C\xA8\x23\x22\x01\xFE\xA3\x18\x0E\x9C\x91\xA3\xAC\x2C\x19\x0E\x96\xA6\x01\x6E\xA7\x38\x48\x06\x13\xA7\x81\x0D\x1A\x0E\x8F\xAA\x01\xFE\xA3\x1A\x0E\x8F\xAC\x01\xFE\xA1\x1B\x0E\x8F\xAE\x01\xFE\xA3\x1B\x0C\x9D\x9F\xA6\x9C\xA4\x34\xAD\x8D\xA1\xA6\xF0\xA4\x75\xA4\xCD\x70\x01\xFE\xA1\x1C\x0B\x9E\xA6\x6E\x72\x03\x7D\xA7\x3D\x33\x01\x92\xA4\x1D\x02\x99\xB5\x01\xFA\xA6\x29\xA6\x10\x36\x01\xFE\xA3\x1D\x0E\x8F\xB8\x01\xFE\xA1\x1E\x0E\x8F\xBA\x01\xFE\xA3\x1E\x02\x99\xBC\x01\xFE\xA1\x1F\x03\x9C\xB7\x16\x80\x02\x5B\xA2\x08\x2E\xA5\x84\x02\x3F\xA5\x08\x3E\xA3\x86\x01\x80\xA6\x10\x07\x02\xFE\xA0\x22\x0E\xA1\x9E\xA6\xAC\x2D\x22\x0E\x96\x8B\x02\xD9\xA5\x44\x4D\x08\x23\xA8\x20\x0E\x23\x0E\x8F\x8F\x02\xFE\xA0\x24", - "\x0E\x8F\x91\x02\xFE\xA2\x24\x0E\x8F\x93\x02\xFE\xA0\x25\x0C\xA2\x81\x04\x95\x02\x3F\xA6\x09\x3B\xA8\xA0\xA6\x7C\xA2\xA0\xA4\xA8\xEE\xA4\x7B\xAB\x98\xB2\xA6\x46\xAB\x63\xA0\x3F\x40\xA9\xED\xA7\x90\xA3\x93\xA8\xA5\x7D\x1C\x26\x0E\x8F\x99\x02\x4C\xAB\x91\xA1\x9F\xAF\xA7\x42\xA8\x94\xA8\xA4\x9D\xA6\x2D\x3A\x26\x0E\x8F\x9B\x02\x55\xA9\x88\x6C\x09\x21\xA9\x39\x0D\x27\x02\x99\x9E\x02\x92\xA7\x27\x04\xA6\x97\xA9\x8E\x08\x28\x0E\x8F\xA1\x02\xFE\xA2\x28\x0E\x8F\xA3\x02\xFE\xA0\x29\x0E\x8F\xA5\x02\x92\xA6\x29\x0E\x8F\xA7\x02\x13\xAB\x69\x1A\x0A\x2E\xA5\xAC\x02\x5B\xAE\x0A\x3E\xA3\xAF\x02\x3F\xA0\x0B\x00\xA9\xB1\x02\x3F\xA2\x0B\x2B\xA9\x59\xAB\x7C\x23\x0B\x2E\xA5\xB5\x01\x8A\xA6\x13\x77\x02\x8C\xA8\x9D\x08\x0B\x3E\xA3\xB9\x02\x3F\xAA\x0B\x3E\xA3\xBB\x02\x3F\xAC\x0B\x3E\xA3\xBD\x02\x3F\xAE\x0B\x15\xAA\x49\xAB\x96\xA5\xA4\x9C\xA9\x87\xA5\x93\xAA\xA5\xAE\x54\xBF\x02\x3F\xA0\x0C\x24\xAA\xC4\x5D\x30\x00\xAB\x8B\x0B\xC2\x02\x64\xA3\x0C\x12\xA6\xC4\x03\xAC\xAF\x4F\x85\x03\xFE\xA2\x31\x0E\x8F\x87\x03\xFE\xA0\x32\x0E\x8F\x89\x03", - "\xFE\xA2\x32\x02\x99\x8B\x03\xFE\xA0\x33\x0D\xA7\x97\x18\xCF\x02\x5B\xA1\x0D\x2E\xA5\xD3\x02\x3F\xA4\x0D\x3E\xA3\xD5\x00\x90\xA6\x0D\x3E\xA3\xD7\x02\xAE\xAB\xAA\x9A\x24\xD8\x02\x5B\xAA\x0D\x12\xAA\xB6\x44\x37\x0A\xAD\x83\x04\xDD\x02\x3F\xAE\x0D\x3E\xA3\xDF\x02\x3F\xA0\x0E\x3E\xA3\xE1\x02\x3F\xA2\x0E\x3E\xA3\xE3\x00\x90\xA4\x0E\x3E\xA3\xE5\x03\xB8\xAF\xA4\x84\xA9\x4E\xA9\xAA\xA6\xA5\x8D\xAA\xF7\xA9\xBF\xA5\xA6\x26\x03\xF6\xAA\xBE\xAA\xA4\x98\xA9\x04\xAD\xA9\xAC\xA6\x92\x20\xE7\x02\x3F\xA8\x0E\x01\xAC\x41\xA9\xC1\xA8\xAA\x8D\xAC\x06\xAC\xBF\xA2\xB0\xB6\x46\xE9\x02\x3F\xAA\x0E\x0C\xAC\x80\x4F\x3A\x08\xB1\xBC\x08\xEC\x02\x64\xAD\x0E\x12\xA6\xEE\x03\xC6\xA6\x82\xAF\x03\xFE\xA0\x3C\x0E\x8F\xB1\x03\xFE\xA2\x3C\x0E\x8F\xB3\x03\xFE\xA0\x3D\x02\x99\xB5\x03\xFE\xA2\x3D\x0B\xAC\x95\x18\xF9\x02\x5B\xAB\x0F\x2E\xA5\xFD\x02\x3F\xAE\x0F\x0E\xA4\x40\xA8\x00\x09\x27\x18\x7E\x01\x03\xCF\xA1\x6A\x90\xAC\xEB\x3E\x00\x02\xB4\xBD\x87\xFB\x07\xD1\xA1\x10\x28\x4B\x36\x46\x01\x0A\xB4\xA7\x7E\xB0\x13\x01\x0F\xB4\x86\x41\x53\xAD\x12\x45", - "\xB5\x86\x53\x57\xAE\x41\x0B\x00\x19\xAD\xCC\x50\xD7\xA2\x10\x0D\x00\x5E\xAF\xC4\xA7\xB0\xA7\xAA\x64\xAD\xBE\xA4\xB4\xA5\xAD\xAC\x6E\x03\x01\xB6\xBE\xAC\x6B\xAE\x24\x70\x01\x2D\xAD\x48\x19\x04\x00\xB7\xBE\x08\x12\x03\xDC\xA0\x24\x13\x00\x76\xAF\xD8\xAF\x3E\x14\x00\x6B\xAD\x05\x0B\xB6\x96\x00\x6B\xAF\x05\x0B\xB6\x98\x00\x6B\xAD\x06\x09\xB7\xA1\x09\x1A\x03\xDA\xAB\x01\x0F\xAD\x02\xA6\x26\x1E\x01\x0F\xAD\xF6\x04\x08\x00\xB9\x8A\x04\x22\x03\xDA\xA3\x02\x2B\xAD\x24\x03\xE1\xA1\x38\x25\x00\x6B\xAE\x09\x0A\xB9\x91\xAC\xF9\x37\x09\x03\xB9\x89\x04\x29\x03\xE8\xAA\x42\x6B\x00\x9F\xAF\xEE\x0C\x02\x2B\xAD\x2D\x03\xDA\xAE\x02\x2B\xAD\x2F\x03\xDA\xA0\x03\x2B\xAD\x31\x03\xDA\xA2\x03\x29\xAE\xAA\x1B\x0C\x0B\xB6\xB4\x00\xB8\xAF\xEB\x65\x03\x3D\xAE\xB7\x16\x0D\x00\xBC\x93\x9C\xC3\xAE\x40\x08\x03\x05\xAF\x62\xAF\xDB\x09\x03\x2B\xAD\x3A\x03\xDA\xAB\x03\x2B\xAD\x3C\x03\xDA\xAD\x03\x2B\xAD\x3E\x00\xF2\xA0\x00\x3F\x00\x6B\xAC\x10\x0C\xB8\xB2\x13\x43\x02\xE9\xA3\x10\x05\x01\xDE\xAE\x40\x07\x04\x2B\xAD\x48\x03\xDA\xA9\x04\x16\xAF\x45", - "\x0A\x12\x0B\xB6\x8B\x01\xE8\xAF\xBE\xA4\xA7\x0C\x01\xE1\xAD\x40\x0E\x04\x31\xAF\xF7\x50\x14\x0D\xBE\xB4\x0C\x51\x03\xDA\xA2\x05\x2B\xAD\x53\x03\xDA\xA4\x05\x2B\xAD\x55\x03\xDA\xA6\x05\x2B\xAD\x57\x03\xFD\xA0\x24\x18\x01\x06\xB2\xDE\xAB\xAD\x8E\xAC\x68\xAC\xBE\xAB\xC0\xA0\xAE\x10\xB0\xF1\x59\x05\x09\xB0\x12\xAF\xD9\xA6\xB6\xAA\xAA\x0E\xB1\x06\xBE\xAF\xA4\x1D\x5A\x00\x05\xBC\xC0\x97\xB0\xEE\xAD\x04\xBD\xC0\x9B\xB0\xA0\x67\xDA\xAC\x05\x1E\xB0\x22\xB0\x08\xB3\xB0\xA9\xB0\x0F\xB3\xC3\xA8\xC1\xA0\x29\x5D\x03\xDA\xAE\x05\x28\xB0\xA6\x6F\x17\x04\xC3\x97\x0F\x60\x02\xF5\xA1\x06\x16\xAF\x62\x03\x0D\xB6\xB6\xA3\x01\x6B\xAC\x19\x0B\xB6\xA5\x01\x6B\xAE\x19\x0B\xB6\xA7\x01\x6B\xAC\x1A\x06\xBD\xA9\x01\x6B\xAE\x1A\x0B\xBD\x8C\x79\xF4\xAF\x1B\x04\xBF\xB1\x01\x6B\xAE\x1C\x0B\xB6\xB3\x01\x3E\xB2\x41\x04\x07\x2B\xAD\x75\x01\x16\xBA\xC1\x93\x30\x76\x00\xFD\xA8\x07\x34\xAF\x62\x7A\x17\xB0\x32\x3B\x01\x6B\xAC\x1F\x0B\xB6\xBD\x01\x6B\xAE\x1F\x0B\xB6\xBF\x01\x6B\xAC\x20\x0B\xB6\x81\x02\x66\xB1\xF2\xAF\xC1\xAD\xB0\x23\xB2\x1D\xBC\xC2", - "\x9F\xB1\x3C\x6A\x20\x0B\xB6\x83\x02\x75\xB2\x2F\x74\x08\x01\xB2\x53\x0D\x21\x06\xBD\x86\x02\xD6\xAF\x21\x04\xC8\xAD\xA4\x88\x03\xDA\xA9\x08\x2B\xAD\x8A\x03\xDA\xAB\x08\x2B\xAD\x8C\x03\xDA\xAD\x08\x16\xAF\x8E\x03\xDA\xAF\x08\x0F\xB1\xB7\x16\x24\x04\xBF\x94\x02\xF4\xAE\x25\x0B\xB6\x97\x02\x6B\xAC\x26\x01\xC8\x99\x02\x6B\xAE\x26\x0B\xC8\xAB\xB0\x74\x27\x26\x04\xBF\x9D\x02\x64\xB1\x44\x4F\x09\x2B\xB2\x40\x08\x28\x0B\xB6\xA1\x02\x6B\xAE\x28\x0B\xB6\xA3\x02\x6B\xAC\x29\x0B\xB6\xA5\x02\x6B\xAE\x29\x01\xC8\xA7\x02\xB4\xB2\x02\xBC\xC7\xAF\xB0\x7A\xB2\x0B\xB1\xC2\x8A\xB3\xAC\xB2\x3C\x18\x0A\x05\xB3\x15\xB0\x32\xB6\xC1\xB8\xB1\x2A\xB2\xA9\xAF\x3E\x29\x02\x6B\xAE\x2A\x00\xCD\xB7\xB1\xC7\xB3\x32\xB9\xC7\x93\xB3\xDD\xB1\x33\xB2\x98\x2B\x02\x6B\xAC\x2B\x0B\xCD\x82\x6B\xAD\x03\x39\xB3\x2B\x2E\x02\xD6\xAF\x2B\x06\xBD\xB0\x02\xEA\xB3\xB5\x91\x0B\x2B\xAD\xB2\x03\xDA\xA3\x0B\x2B\xAD\xB4\x03\xDA\xA5\x0B\x2B\xAD\xB6\x02\xF5\xA7\x0B\x2B\xAD\xB8\x00\x27\xB7\x5A\x3B\x02\xF4\xAD\x2F\x04\xBF\xBF\x02\x6B\xAC\x30\x0B\xB6\x81\x03\x81\xB2", - "\x30\x0B\xB6\x83\x03\xF1\xB1\x35\xB4\x79\x04\x03\xF4\xAE\x31\x01\xCB\xB6\x44\xC8\x01\x44\xB6\x10\x09\x03\x6B\xAE\x32\x0B\xB6\x8B\x03\x6B\xAC\x33\x0B\xB6\x8D\x03\x6B\xAE\x33\x0B\xB6\x8F\x03\x1A\xB5\x38\xB6\xCD\x94\xB3\x2C\xB6\x4A\xB6\xCC\xA4\xB0\x82\x28\x34\x09\xD2\xB0\xB4\xE2\xB1\x4B\xB4\xD3\xAB\xB4\x2E\xB5\x34\xBE\xCD\x92\xB4\x3A\xB5\x4D\xB9\xD3\x81\x0E\xD1\x03\x4C\xB9\xCC\x9F\xB3\xD2\xB1\x51\xBB\xD3\xB6\xB4\x43\xB4\x4F\xBC\xCD\xAD\x38\xD2\x03\xDA\xA3\x0D\x02\xB5\x3C\x68\x35\x00\xD5\x85\x09\xD5\x02\xF5\xA6\x0D\x16\xAF\xD7\x03\x54\xBA\x41\x98\x03\x6B\xAD\x36\x0B\xB6\x9A\x03\x6B\xAF\x36\x0B\xB6\x9C\x03\x6B\xAD\x37\x06\xBD\x9E\x03\x6B\xAF\x37\x02\xD0\x97\x18\xE2\x00\xFD\xA4\x0E\x34\xAF\xE6\x03\xDA\xA7\x0E\x2B\xAD\xE8\x01\x20\xB9\x0E\x2B\xAD\xEA\x02\x56\xBE\xD3\x8E\x23\xEB\x00\xFD\xAD\x0E\x17\xB4\xAC\xA0\x54\xB0\x0F\x2B\xAD\xF1\x03\xDA\xA2\x0F\x2B\xAD\xF3\x03\xDA\xA4\x0F\x2B\xAD\xF5\x03\xDA\xA6\x0F\x3A\xB5\x38\xB5\x9C\x47\x0F\x10\xB6\x2F\xB5\x52\xB8\xD4\xA0\xB3\x37\xB5\x90\x38\x0F\x14\xB6\x3D\xB5\x64\xB6\xD9\xBF", - "\xB4\x7B\xB1\x66\xBD\xD9\x95\xB6\x4D\x31\x3E\x0C\xD9\x8B\xB5\x9F\xB6\x68\xB8\xDA\x98\xB6\xA9\xB5\x6B\xBB\x12\x7A\x03\xA7\xB5\x68\xBE\xDA\x86\xB5\x7B\xB7\x6C\xB7\xD4\xA0\xB6\xCC\xB2\x67\xBC\xDA\xBB\xB6\xB4\xB6\x1C\xAB\x0F\x2B\xAD\xFC\x01\x6C\xB8\x37\x7D\x03\xC2\xB6\x42\x0E\x0F\x28\xAF\xF4\xAD\x00\x0F\x33\x21\x91\xCB\xB7\xD0\xAD\xDB\xB8\x08\x03\x01\x73\xB8\x46\x84\x00\xD2\xB7\x1A\x95\x00\x15\xB7\x6F\x90\x76\xBE\x1D\x07\x00\xDA\xB7\x47\x0D\xDD\xA7\x0B\x09\x03\x77\xB6\x10\x0A\x00\xD8\xB5\xE3\xA3\x35\x0D\x00\xD8\xB6\x7D\x0F\x00\x29\xB7\x0A\x05\x04\x02\xDE\x9C\x88\xEF\xB7\x87\x81\xDF\x88\x12\x14\x03\x7C\xB5\x22\xB6\xB7\x16\x02\x7D\xB7\x01\x2C\xB7\x09\x05\x06\x06\xDF\x9A\x00\xF6\xB7\x06\x06\xDF\x9C\x00\xF6\xB5\x07\x06\xDF\x9E\x00\xF6\xB4\x68\x79\xE0\xBB\x0C\x20\x02\x7D\xB1\x02\x0B\xB8\x3E\x0A\x08\x00\xE1\x8C\x31\x23\x00\x7F\xB6\x10\x25\x00\x16\xBB\x7C\x27\x02\x18\xB7\xBD\x50\x00\x0C\x02\x36\xB7\x2D\x03\x84\xBD\x30\x76\xB7\x2F\x02\x88\xB1\x26\x30\x00\xF6\xB5\x0C\x06\xDF\xB2\x00\x19\xBA\x40\x04\x03\x36\xB7\x35\x02\x7D", - "\xB6\x03\x36\xB7\x37\x02\x7D\xB8\x03\x26\xB8\xC7\x1D\x0E\x06\xDF\xBA\x00\x38\xB8\x06\x9B\x03\x3D\xB8\x37\x14\x0F\x00\xE4\x8A\x04\x3D\x01\x8B\xB1\x10\x3F\x00\xF6\xB4\x10\x03\xE4\x8A\xB5\x8E\x09\x10\x06\xDF\x82\x01\xF6\xB7\x10\x06\xDF\x84\x01\xF6\xB5\x11\x06\xDF\x86\x01\x4B\xBA\x41\x07\x04\x36\xB7\x48\x01\x79\xB2\x4F\x0B\x01\x46\xB8\x00\x0D\x04\x21\xB9\x4F\x02\x7D\xB0\x05\x36\xB7\x51\x01\x96\xB3\x31\x12\x01\xF6\xB7\x14\x06\xDF\x94\x01\xF6\xB5\x15\x01\xE6\x97\x01\xF6\xB4\x16\x06\xDF\x99\x01\xF6\xB6\x16\x06\xDF\x9B\x01\xF6\xB4\x17\x0A\xE6\x82\x04\x5D\x03\x9F\xBB\x32\x1E\x01\xF6\xB7\x17\x02\xE8\x80\x00\x60\x03\xA1\xB0\xA8\x21\x01\x61\xBB\x18\x01\xE6\x98\x23\x65\x00\x87\xBA\x10\x2A\x01\xF6\xB7\x1A\x07\xE8\xAC\x01\xF6\xB5\x1B\x07\xE8\xAE\x01\xF6\xB7\x1B\x06\xDF\xB0\x01\x61\xBA\x1C\x06\xDF\xB3\x01\xF6\xB4\x1D\x06\xDF\xB5\x01\xF6\xB6\x1D\x0A\xE8\xB7\xB6\xB8\x67\x1D\x0B\xEA\xB5\xB6\xBC\xB4\xAB\xB6\xDB\xB0\xBA\x3A\x30\x1E\x0F\xEA\xBA\xB6\xCF\xB7\x68\xBA\xEB\xAB\xB6\xB9\xB8\xAF\xB2\xEB\x92\x23\x79\x03\xAD\xB4\xDA\xBD\xBA", - "\xB2\xB5\xAC\xB4\xEB\xBF\xBA\xD2\xB2\x1E\x02\xEC\xBB\xBA\xC5\xB8\xB1\xB9\xDB\x83\xBB\xC8\xB9\xB4\xB8\x8E\x3B\x01\xCB\xBA\xAF\xB7\xEC\xA6\xA0\x7C\x01\xB5\xBD\xEC\x92\xBB\xB8\xB8\xB7\xB0\xED\x97\xBB\xDD\xB8\xB8\xBF\xED\x8D\x59\x7D\x02\xB6\xBF\xEC\x8C\xBB\xE7\xBA\xB5\xB1\xEE\xAB\xBB\xE3\xBB\x34\x1E\x07\x26\xBB\x44\xB6\xB7\xB8\xEE\xB1\xBB\xE2\xBB\xBC\xBC\xE4\xA9\xBB\xDB\xB9\xBD\xBA\xEE\x95\x44\x7F\x00\xBC\xB7\xEF\xB4\xBB\xEC\xBA\xBD\xB7\xD9\x8E\xBB\x00\xBD\xBB\xB2\xF0\x9F\x51\x80\x02\x7D\xB1\x08\x3E\xBB\xAC\x6E\x20\x0C\xF0\xBF\x10\x83\x03\xA1\xB4\x08\x07\xBA\x85\x03\xC3\xBA\xDA\x8E\x0A\x86\x02\x7D\xB7\x08\x36\xB7\x88\x02\x7D\xB9\x08\x36\xB7\x8A\x02\x7D\xBB\x08\x07\xBA\x8C\x02\x7D\xBD\x08\x1E\xB9\x3D\x14\x24\x01\xE6\x92\x02\x61\xB8\x25\x06\xDF\x95\x02\xF6\xB6\x25\x06\xF1\x81\x04\x97\x02\x7D\xB8\x09\x07\xBA\x99\x03\xCC\xB6\xEC\x96\x1E\x9A\x01\x98\xBC\x09\x0F\xBA\x11\x46\x27\x0A\xF3\x85\x09\x9F\x02\x7D\xB0\x0A\x36\xB7\xA1\x02\x7D\xB2\x0A\x36\xB7\xA3\x02\x7D\xB4\x0A\x36\xB7\xA5\x03\xD0\xB2\xEF\xBB\xBB\x07\xBF\xC5\xB8", - "\xEF\x97\xBD\x3E\x56\x29\x02\xF5\xBA\xBB\x62\x37\x29\x0B\xF5\x82\x24\xA8\x02\xCE\xB9\x0A\x36\xB7\xAA\x02\x7D\xBB\x0A\x36\xB7\xAC\x02\x7D\xBD\x0A\x36\xB7\xAE\x02\x7D\xBF\x0A\x36\xB7\xB0\x02\x7D\xB1\x0B\x36\xB7\xB2\x02\x7D\xB3\x0B\x1F\xBD\xA4\xB4\x2D\x08\xF7\xA1\x09\xB5\x03\xDE\xB4\xF5\xBF\xBD\x20\x4E\x2D\x0E\xF7\xA2\x35\xB7\x02\x7D\xB8\x0B\x03\xBE\xC4\x5D\x2E\x08\xF8\xB3\x60\x87\xBB\x2E\x07\xE8\xBC\x02\x8B\xBF\x3F\x9D\x0B\x36\xB7\xBE\x02\x7D\xBF\x0B\x36\xB7\xC0\x02\x7D\xB1\x0C\x36\xB7\xC2\x03\xA1\xB3\x0C\x36\xB7\xC4\x00\xCA\xB7\x5B\x07\x03\x61\xB9\x32\x01\xE6\x8B\x03\xF6\xB4\x33\x06\xDF\x8D\x03\x3A\xBE\x33\x06\xDF\x8F\x03\x91\xBF\xC0\xB4\x78\x10\x03\x61\xBA\x34\x00\xF4\xB6\x44\xD4\x01\xEC\xB3\x10\x15\x03\xF6\xB6\x35\x06\xDF\x97\x03\xF6\xB4\x36\x06\xDF\x99\x03\xF6\xB6\x36\x06\xDF\x9B\x03\xBA\xBE\xD5\xB5\xE6\x1C\x03\xC9\xBF\xAC\xB1\xF0\x80\xBE\x58\xBF\xBF\xB2\xFD\xA1\x89\xDD\x01\xF3\xBB\xF3\x86\xBC\x34\x8A\x37\x06\xFD\x84\xBC\xD3\xBF\x69\x1F\x0D\x1B\xBF\x53\xBD\xBE\xBF\xFC\xA2\xBF\xD8\xBC\xF9\xB5\xC1\xA0\x03\xE0", - "\xBC\xD7\xB1\xFD\xB2\xBE\xEA\xBC\x55\x21\x0E\x29\xBF\xE3\xBF\xFA\xB8\xDB\x85\xBC\x61\x0A\x38\x00\xFF\xA5\xBF\xF2\xBE\xF2\xBD\xFD\xBA\xBF\xEC\xBD\xCE\x03\x0E\x37\xBF\x55\xBE\xF3\xB8\xFF\xB4\xBF\xD0\xBC\x01\xC6\xFE\x81\x0E\xE4\x00\x00\xC5\x00\xFB\xBF\x02\xC1\x00\xC7\xFD\x8E\xC0\xDC\xBE\xD4\x15\x0E\x0A\xC0\x07\xC1\x05\xC9\xFF\x8D\xC0\x0B\xC1\xFF\xB3\x00\xCC\xC0\x7E\x2A\x39\x07\xFB\xB1\xBF\x06\xC3\x05\xCF\x00\xD9\xC0\xF3\xBC\x07\xC1\x01\xE5\xC0\x1A\xC3\x72\x98\x0E\x14\xC0\x22\xC3\x09\xCC\xFF\xA8\xC0\x30\xC3\x0B\xC9\x5C\xA9\x03\x2C\xC1\x08\xC6\x03\xE6\xC0\xE1\xBD\x0B\xC9\x03\xF7\xC0\x29\xC0\x09\xC2\x03\xD8\xC0\x2F\x3E\x3A\x05\x03\xF8\xC0\xED\xBC\x11\xC0\x02\xC6\xC1\x1B\xC1\x26\x2B\x0E\x16\xBF\xEC\x03\x10\xCD\x03\xD6\xC0\x3C\xC1\x0C\xC0\x04\xFA\xC0\x45\xC3\x13\xC4\x05\xC7\xC1\x56\xC1\x14\xCF\x03\xE3\xC0\x50\xC2\xBA\x3D\x0E\x0E\xC1\x52\xC0\x17\xC7\x05\xD3\x32\xEE\x03\x07\xC9\x04\xE1\xC1\x2E\xC3\x61\xA0\x0F\x36\xB7\xF1\x00\x18\xCA\x4E\x72\x03\x6E\xC1\x40\x03\x0F\x07\xBA\xF4\x03\xA1\xB5\x0F\x31\xC1\x27\xA2\x3D\x06\xDF", - "\xB7\x03\xF6\xB4\x3E\x06\xDF\xB9\x03\xF6\xB6\x3E\x06\xDF\xBB\x03\x87\xB8\x3F\x06\xDF\xBD\x03\xA2\xBF\x69\x10\x00\x06\x0D\x9E\x99\x7D\x0C\x08\xFA\x87\x8C\x23\x23\xC8\x46\x85\x00\x92\xC3\x1A\x96\x00\x15\xC2\x50\xAD\xCE\x07\x00\x18\xC2\x46\x40\x27\xCA\x05\xD3\x30\x09\x00\x26\xC6\x47\xA2\xC2\xB6\x9A\x27\xCD\x53\x0E\x00\xA6\xC2\x41\x0F\x00\x29\xC2\x03\x04\x04\x0C\x0A\xC2\x04\x11\x03\x2B\xC1\x10\x12\x00\xB2\xC0\x00\x03\x01\x35\xC2\x14\x01\x2D\xC9\x06\xF7\x53\x15\x02\x2E\xCB\x03\xC8\xC1\x10\xC3\x2F\xC9\x05\xFD\x14\x16\x02\x2F\xC5\x05\xE8\xC1\xC2\xC0\x32\xC7\x0C\xDB\xC1\xBB\xC1\x33\xC3\xE4\x17\x00\xC6\xC0\x16\xCA\x0C\xD2\xC3\xCC\xC1\x32\xC5\x0D\xE6\xA0\x18\x01\x34\xC7\x06\xD7\xC3\xD4\xC3\x14\xCF\x09\xCD\x31\x19\x01\x2D\xCA\x01\x1A\xC3\x5F\x87\x06\x04\x0E\xF1\x19\x1C\x03\x39\xCE\x28\x1D\x00\xEA\xC3\x6C\x0E\x01\x2D\xC3\xDF\xC3\x07\x05\x0B\xE0\x00\xB5\xC1\x08\x05\x0B\xE2\x00\xB5\xC3\x08\x05\x0B\xE4\x00\xF0\xC1\x42\x05\x02\x35\xC2\x26\x00\x26\xC6\xDE\xBB\x0C\x29\x00\x29\xC9\x10\x2B\x00\x06\xC6\x41\x0D\x02\x35\xC2\x2E\x01", - "\x2D\xCF\x02\x3D\xC3\x02\x0C\x0C\x05\x0B\xF1\x00\x10\xC7\x34\xC4\xAF\x32\x00\x09\xC7\x40\x04\x03\x19\xC4\xEA\x52\x0D\x05\x11\xCA\x12\x37\x01\x2D\xC8\x03\x35\xC2\x39\x01\x2D\xCA\x03\x35\xC2\x3B\x01\x2D\xCC\x03\x35\xC2\x3D\x03\x47\xCE\x0D\xD1\x53\x3E\x02\x4B\xC2\x06\xDF\xC3\xE6\x9F\x0F\x05\x0B\xC0\x01\x32\xC6\x33\xCB\x0C\xEF\xC4\x9E\x5D\x10\x09\x13\xD6\xC3\x3C\xC5\xCC\x92\x04\x35\xC2\x43\x03\x4F\xCB\x13\xF3\xC4\xC0\xC1\x73\x64\x04\x06\xC5\xDD\xC0\x52\xC3\x0C\xCF\xC5\x16\xC5\x30\xC0\xEB\x85\x01\x4C\xC7\x36\xC1\x14\xDC\xC3\x56\xC6\x53\xC7\x8A\x06\x01\x55\xC6\x54\xCD\x14\xFA\xC4\x5F\xC4\x50\xCA\x15\xD8\xC5\x15\xB3\x11\x0D\x15\xFE\xC0\x57\xC5\x5A\xC3\x16\xEA\xC5\x60\xC5\x56\xC3\x35\x08\x01\x67\xC5\x17\xC0\x15\xE4\xC5\x68\xC7\x5A\xC6\x17\xED\xC5\x61\x09\x12\x01\x17\xE3\xC1\x5E\xC6\x5B\xC2\x16\xF8\xC5\x75\xC7\x38\x4A\x04\x3B\xC5\x34\xC7\x5F\xC6\x18\xC7\xC5\x80\xC6\x5C\xC1\x15\xC1\xC6\xBF\xBB\x12\x04\x18\xC9\xC5\xC5\xB8\x13\x02\x13\xCD\x01\x8F\xC7\x5C\xCC\x16\xC7\xC6\x61\xC4\x62\xC8\x19\xFE\xC5\xAB\xA5\x65\xCB\x18\xCA", - "\xC6\x74\xC4\x68\xC7\x19\xDA\xC6\xD7\x83\x13\x0E\x19\xE1\xC6\x7C\xC4\x63\xC4\x1A\xD9\xC6\xAC\xC4\x67\xCD\x14\xD0\x01\xA7\xC4\x22\x11\x05\x31\xC6\x77\xC7\x66\xCD\x17\xF7\xC6\xAA\xC5\x6B\xC8\x1B\xE2\xC6\xB5\xC7\x6A\xCE\x1A\xEE\x54\x52\x00\x6D\xC9\x18\xE9\xC6\xBC\xC7\x70\xC5\x18\xFE\xC6\xDD\x2B\x14\x02\x1C\xD1\x44\x54\x01\x2D\xC5\x05\x0B\xC7\x21\x6A\x15\x02\x13\xD7\x01\xB4\xC4\x16\x02\x13\xD9\x01\x32\xC6\x16\x00\x1D\xFA\xB6\x5B\x01\x2D\xCC\x05\x35\xC2\x5D\x01\x2D\xCE\x05\x35\xC2\x5F\x01\x2D\xC0\x06\x32\xC4\x61\x01\x2D\xC2\x06\x02\xC4\xF2\x11\x19\x0C\x11\xC1\x04\x67\x03\x7B\xC0\x00\x29\x01\xB5\xC2\x1A\x05\x0B\xEB\x01\xB4\xC4\x1B\x05\x0B\xED\x01\xDB\xC7\x6F\xC4\x7B\x2E\x01\xF2\xC4\x1C\x02\x1F\xE3\x43\x72\x01\x7F\xC1\x26\x33\x01\xB5\xC0\x1D\x05\x0B\xF5\x01\xB5\xC2\x1D\x05\x0B\xF7\x01\xB5\xC0\x1E\x05\x0B\xF9\x01\x06\xC8\x3B\x1A\x07\x35\xC2\x7B\x01\x85\xC2\xAC\x7C\x01\x1A\xCB\xAC\x0D\x07\x32\xC4\x7E\x02\x4C\xCF\x07\x1D\xC8\xD7\x98\x20\x05\x0B\xC1\x02\xB5\xC2\x20\x05\x0B\xC3\x02\xB5\xC0\x21\x05\x0B\xC5\x02\x32\xC6\x21", - "\x05\x0B\xC7\x02\xEC\xC5\x4F\x1A\x08\x32\xC7\x8C\x02\x7C\xCE\x08\x35\xC2\x8F\x01\x2D\xC0\x09\x34\xC6\x91\x01\x2D\xC2\x09\x24\xC8\x90\xC7\x4D\x13\x09\x32\xC7\x95\x03\x80\xC1\x11\x57\x02\x44\xCA\x41\x08\x09\x35\xC2\x99\x01\x2D\xCA\x09\x35\xC2\x9B\x01\x2D\xCC\x09\x35\xC2\x9D\x01\x2D\xCE\x09\x34\xC6\x9F\x01\x93\xCF\x19\xC4\xC7\x60\xCB\x71\xCA\x1B\xF9\xC6\xFE\xC5\x03\xA0\x0A\x35\xC2\xA1\x02\x97\xC8\x1A\xE2\xC9\x65\xC9\x71\xC6\x1B\xE4\xC9\x73\x1A\x28\x0A\x26\xE3\xC6\x63\xCA\x9B\xC8\x1C\xF0\xC9\x78\xCA\x9D\xC5\x27\xE1\xC9\x45\xC8\x9B\xCB\x5C\xA3\x02\xB5\xC0\x29\x03\x27\xFD\xC6\x7B\xCA\x9F\xC9\x27\xFC\xC9\x96\xC4\xA1\xCD\x26\xC4\x5F\xA5\x03\xA0\xC6\x1C\xFD\xC9\x90\xC9\xA2\xCF\x23\xA6\x02\x8E\xCB\x9B\xCA\x27\xCB\xCA\x86\xCB\xA5\xCB\x1B\xC8\xCA\x5F\xCA\x42\x07\x0A\x15\xCA\x77\xCA\xA6\xC7\x28\xD9\xCA\x9C\xCB\x9A\xC1\x29\xDD\xCA\xA7\xCA\xA9\xC6\xE2\x68\x02\x98\xC1\x87\xBF\x28\xD2\xCA\x96\xC9\xA9\xC4\x27\xD8\xCA\xA9\xC9\x89\x3D\x0A\x20\xCA\x85\xC9\xAD\xCA\x28\xDB\xCA\xA4\xC9\xAF\xC8\xBA\x2E\x02\xB8\xC8\xAD\xC0\x2B\xE1\xCA", - "\xB2\xCB\xAE\xC3\x2A\xEA\x3B\xAF\x01\xB0\xCC\x2B\xFA\xCA\xAF\xC8\xAA\xC3\x2C\xF9\xCA\xCF\xCA\xB0\xC3\x10\x30\x02\xCA\xCB\xB1\xC1\x2D\xCB\xCB\xD7\xCA\xB5\xCE\x2C\xDB\xCB\xAA\xC8\xB7\xC1\x10\x31\x02\xD5\xCA\xA8\xC2\x2E\xC5\xCB\xBB\xC2\x2C\x01\x2E\xE4\xCB\xB1\xCA\xAF\xC9\x2D\xE3\xCB\xDF\xB3\x2C\x07\x2E\xEA\xCB\xDE\xCA\xB1\xCC\x2E\xCC\xCB\xEA\x10\x2D\x0F\x2E\xF4\xCB\xC4\xC8\xBC\xCD\x2D\xFB\xCB\xB3\xC8\xB6\xC1\x2F\xC5\x09\xB5\x03\xBD\xCB\x2E\xE8\xCB\xF9\xC8\xBE\xC6\xA6\x76\x02\x02\xCF\xBF\xC9\x2E\xC6\xCC\xD2\xC8\xBF\xC2\x2F\xC4\xCC\xD0\xCB\x40\x07\x0B\x09\xCC\x0E\xCD\xB3\xC5\x31\xCB\xCC\x03\xCE\xBE\xC3\x76\x38\x02\x14\xCD\xBF\xCA\x2D\xD7\xCC\x05\xCD\xC6\xCC\x30\xFE\xCB\x20\xCD\x32\x79\x0B\x1D\xCC\x0F\xCE\xC6\xC9\x32\xE3\xCC\x1F\xCE\xC7\xCF\xB6\x3A\x02\x28\xCE\xC5\xCE\x32\xD0\xCC\x0D\xCF\xCC\xCA\x32\xC0\x2A\xBB\x01\xCC\xC8\x31\xCA\xCC\x21\xCC\xCF\xC1\x31\xE5\xCC\x3A\x18\x2F\x0A\x33\xFD\xCC\x40\xCC\xC9\xC7\x98\xBD\x02\x43\xCF\xCF\xC6\x33\xEC\xCC\xF3\xCA\xC8\xCE\x34\xCE\x1D\xBE\x01\xD2\xC5\x33\xEB\xCC\x4F\xCD\xD1\xCD", - "\x32\xD4\xCD\x1C\x33\x2F\x02\x35\xC6\xCD\x58\xCE\xD5\xCD\x34\xFE\xCC\x53\xCC\xA0\x20\x0C\x1B\xCD\x57\xCE\xCC\xCD\x35\xCB\xCD\x55\xCC\xDA\xCE\x74\x01\x03\x64\xCF\xD7\xCE\x35\xF4\xCC\x5C\xCE\xD9\xC2\x37\xFB\xCC\x6F\xCF\xCD\xC4\x37\xE2\x53\xC2\x01\xDB\xC0\x37\xE5\xCD\x77\xCF\xD9\xCE\x37\xF3\xCD\x21\x6B\x30\x0A\x37\xF6\xCD\x44\xCE\xDA\xC5\x37\xCC\xCD\x7B\xCE\xDB\xC6\x38\xCB\xCE\x7F\xCD\x44\x44\x0C\x03\xCE\x88\xCC\xE1\xCA\x34\xCD\xCE\x85\xCC\xE5\xC3\x39\xC0\xCE\x97\xCD\xDF\xC8\x39\xE1\xCD\x9A\xCD\xE7\xC0\x4B\x05\x03\x90\xCD\xDA\xCE\x3B\x86\x03\xA1\xCC\xD8\xC1\x37\xDE\xCE\x99\xCC\xCD\x07\x0C\x25\xCE\x87\xCC\x83\x28\x0C\x2C\xCE\x2B\x0D\x32\x00\x3B\xD6\xCE\x9C\xCD\xE5\xCB\x39\xE7\xCE\xB6\xCC\xEA\xC5\x3B\xE9\xCE\xBC\xCD\x45\x4A\x0C\x33\xCE\xB7\xCF\xF1\x1B\x0C\x00\xCF\x3C\x08\x33\x04\x3C\xF9\xCE\xC8\xCD\xEF\xC8\x3B\xCA\xCF\x57\xCD\x33\x07\x3C\xCC\xCF\x8A\xCC\xED\xCB\x3C\xFE\x84\xCE\x03\xF3\xCB\x3B\xD7\xCF\xD3\xCD\xF6\xCC\x37\xC9\xCF\xD8\xCF\xF1\x1F\x0C\x16\xCF\xDA\xCD\xF4\xC1\x3C\xE2\xCF\xBA\xCD\xF8\xCD\xD9\x10\x03\xE0", - "\xCF\xF6\xC0\x3D\xC9\xCE\xEC\xCE\xE4\xCD\x3D\xE4\xCF\xDC\xCE\xF9\xCE\x3E\xE1\x09\xD1\x01\xAB\xCA\x10\x16\x03\xB5\xC3\x35\x09\x3E\xF0\xCF\xEB\xCF\xFC\xCA\x3E\xEF\xCF\xED\xCD\xE4\xC2\x40\xE2\xCE\xE3\xCD\x00\xD4\x40\xED\x6B\xD8\x03\xFE\xCC\x6C\x19\x03\xB5\xC2\x36\x0A\x40\xE6\x35\xDB\x00\xCA\xCC\x0D\x32\xC4\xDD\x02\x4C\xCE\x0D\x35\xC2\xDF\x03\x03\xD1\x4D\x60\x03\xB5\xC1\x38\x05\x0B\xE2\x03\xB5\xC3\x38\x05\x0B\xE4\x03\xB5\xC1\x39\x02\x13\xE6\x03\xB5\xC3\x39\x05\x23\xF7\x16\xEA\x02\x7C\xCC\x0E\x32\xC7\xEE\x01\x2D\xCF\x0E\x35\xC2\xF0\x00\x6D\xC1\x0F\x35\xC2\xF2\x02\x06\xD2\x3A\xF3\x03\xF2\xC5\x3D\x0A\x24\xF6\x44\xF7\x03\xA0\xC8\x0F\x35\xC2\xF9\x01\x2D\xCA\x0F\x35\xC2\xFB\x01\x2D\xCC\x0F\x35\xC2\xFD\x01\x2D\xCE\x0F\x00\xCF\xB5\xC0\x00\x08\x34\x18\x7E\x92\x71\x00\x03\x45\xCE\xB7\x48\x1A\x00\x07\x45\xE8\x91\x45\x0B\x00\x0B\x45\xE8\x9A\x3C\x08\x01\x0F\x45\xD9\xC2\x53\xCD\x01\x03\x46\xFD\x4A\x67\xD3\x10\x49\x46\xC9\x04\x08\x03\x1A\xD6\x10\x09\x00\x6E\xD3\x40\x0A\x00\x31\xD1\xC2\x7C\x1D\xD1\x10\x0C\x00\x63\xD3\x40\xC4\x33", - "\x0F\x00\x63\xD2\x7D\x01\x01\x3D\xD1\x0A\x07\x04\x06\x47\xE7\x41\x83\xD1\x05\x03\x48\xD3\x0D\x16\x03\x20\xD7\x01\x07\xD2\xE5\xCF\xF1\x18\x01\x00\xD2\xEB\x48\x24\xDA\x42\x5C\x00\x8C\xD0\x2C\x1D\x01\x03\xD2\x1E\x03\x20\xDF\x01\x03\xD2\x20\x03\x20\xD1\x02\x03\xD2\x22\x03\x20\xD3\x02\x15\xD2\x39\x0C\x09\x04\x4A\xC0\xD0\xFE\xCC\xFF\xC8\x4A\xC3\xD0\xA6\xCF\xFF\xCB\xE4\x25\x00\xA7\xD2\xFC\xCC\x4A\xED\xCE\xAD\xD2\x2A\xD2\x4B\xDE\x30\x26\x01\x2C\xD4\x92\x27\x00\xBA\xD2\x2D\xDE\x4A\xFF\xD2\xBE\xD1\x30\xD6\x40\xF3\x27\x28\x01\x2F\xD3\x4C\xF4\xD2\xC8\xD0\xE3\xC5\x40\xE9\xD2\xC7\xD2\x32\xDD\x48\xC2\xD3\x3E\x55\x0A\x06\x4C\xE5\x39\x2A\x03\x20\xDB\x02\x13\xD3\xAF\x6C\x0B\x08\x4D\xF7\x16\x2D\x03\x36\xD3\x10\x2E\x00\xDE\xD2\x40\x0F\x02\x03\xD2\x30\x01\x38\xDE\xDA\xB1\x00\x83\xD2\x0C\x03\x48\xF3\x00\x83\xD0\x0D\x03\x48\xF5\x00\x83\xD2\x0D\x06\x4E\xC0\x00\x37\x03\x20\xD8\x03\x39\xD1\xF2\x13\x0E\x02\x49\xC3\x04\x3D\x03\x3E\xD2\x10\x3F\x00\x83\xD0\x10\x03\x48\xC1\x01\xF3\xD1\x91\x02\x04\x03\xD2\x43\x01\x41\xDF\x4C\xF7\x14\x44\x02", - "\x3F\xD1\x10\x06\x01\x0E\xD7\x3D\x58\x04\x0A\xD4\x34\x0D\x12\x03\x48\xCA\x01\x83\xD3\x12\x03\x48\xCC\x01\x83\xD1\x13\x03\x48\xCE\x01\x83\xD3\x13\x04\x51\xCC\x19\x50\x03\x20\xD1\x05\x23\xD4\x7E\x72\x14\x08\x52\xE5\x13\x53\x03\x3C\xD4\x05\x33\xD3\x55\x03\x4A\xD5\x17\xD6\x01\x83\xD3\x15\x03\x48\xD8\x01\x83\xD1\x16\x03\x48\xDA\x01\x83\xD3\x16\x03\x4F\xDC\x01\x83\xD1\x17\x08\x4F\xFD\x14\x60\x01\x44\xD2\x06\x11\xD4\x64\x03\x20\xD5\x06\x03\xD2\x66\x02\x4C\xDE\x28\x27\x01\x83\xD0\x1A\x0E\x54\xCD\xD3\x64\x1D\x1A\x01\x51\xEB\x01\x11\xD7\x38\x4D\x06\x13\xD5\xCB\x0A\x1B\x03\x48\xEF\x01\x83\xD0\x1C\x03\x48\xF1\x01\x83\xD2\x1C\x03\x48\xF3\x01\x83\xD0\x1D\x0C\x55\xC9\x04\x75\x03\x5A\xD7\x40\xF1\xCF\xC0\xD0\x55\xDB\x4C\xF3\xD2\xCE\xD1\xDF\x16\x07\x2E\xD5\xB5\xD2\x5C\xDB\x50\xCC\xD3\x7C\xD4\x5D\xDA\x49\x37\x01\x78\xD4\xD8\x18\x07\x01\xD6\x75\xD5\xFF\xCE\x57\xF3\xD5\x6F\xD6\x61\xDA\xAA\x04\xD6\xD2\xCD\x5C\xDD\x57\xC9\xD6\xAB\xD0\x64\xD5\x4E\x3A\x01\x8C\xD4\x62\xD9\x57\xEF\x47\x7B\x01\x65\xDB\x57\xC7\xD6\x9B\xD6\xD4\x1C\x07\x1A", - "\xD6\x70\xD4\x34\xD1\x4D\x7D\x01\xA0\xD6\x62\xD1\x2F\xFE\x01\xA5\xD5\x64\xD7\x59\xDC\xD6\xA1\xD6\x5E\xDD\x5A\xCF\xD6\xF7\x43\x1F\x09\x5A\xF7\xD2\xAB\xD6\x64\xDE\x58\xDC\xC0\x80\x03\x20\xD1\x08\x33\xD6\xCD\x66\x20\x0C\x5B\xD6\x0E\x83\x03\x3C\xD4\x08\x19\xD5\x3C\x0A\x21\x0F\x5B\xCF\xAC\x87\x03\x20\xD8\x08\x03\xD2\x89\x03\x20\xDA\x08\x03\xD2\x8B\x03\x20\xDC\x08\x33\xD3\x8D\x03\x20\xDE\x08\x03\xD5\xB7\x15\x24\x01\x51\xD3\x02\x11\xD5\x25\x03\x48\xD6\x02\x83\xD3\x25\x0C\x58\xD8\x02\x83\xD1\x26\x03\x48\xDA\x02\x83\xD3\x26\x01\x51\xDD\x02\x83\xD2\x27\x03\x48\xDF\x02\x83\xD0\x28\x03\x48\xE1\x02\x83\xD2\x28\x03\x4F\xE3\x02\x8C\xD4\x29\x03\x48\xE5\x02\xF3\xD2\x29\x07\x5C\xD8\x20\xA7\x01\x44\xD9\x0A\x04\xD7\xF9\x47\x18\xDD\xE1\xB0\x02\x83\xD1\x2C\x03\x4F\xF2\x02\x83\xD3\x2C\x03\x4F\xF4\x02\x83\xD1\x2D\x03\x48\xF6\x02\x83\xD3\x2D\x03\x48\xF8\x02\x83\xD1\x2E\x03\x48\xFA\x02\x83\xD3\x2E\x0F\x5F\xEC\xD6\xA6\xD5\x32\xDD\x58\xE2\xD6\xB6\xD6\xF4\x2F\x61\xE5\xD8\xAE\xD5\x88\xD5\x58\xEA\xD6\x22\xDA\x65\xD7\x61\x3D\x02\x27\xD9\x6D", - "\xD2\x63\xED\xD8\x9D\xD7\x8C\xD1\x10\x3E\x02\x31\xD8\x8D\xDF\x5A\xE0\xD8\x2C\xDB\x8A\xD4\x5B\xFA\xD8\x4C\x1B\x2F\x09\x63\xFE\xD8\xB7\xD4\x8A\xD0\x5B\xC0\xD9\x50\x0C\x30\x03\x48\xC1\x03\x43\xD8\x8F\x62\x0C\x0D\xD9\x45\x0B\x30\x03\x4F\xC4\x03\xF3\xD1\x31\x00\x65\xDA\x90\xC6\x03\x20\xD7\x0C\x03\xD2\xC8\x03\x20\xD9\x0C\x03\xD2\xCA\x03\x20\xDB\x0C\x33\xD3\xCC\x03\x20\xDD\x0C\x18\xD7\xA7\x14\x34\x01\x51\xD2\x03\x11\xD4\x35\x03\x48\xD5\x03\x83\xD2\x35\x0C\x58\xD7\x03\x83\xD0\x36\x07\x65\xFB\xD8\x41\x11\x36\x01\x51\xDB\x03\x04\xDA\x6D\x4D\x0D\x0D\xD9\xDE\x03\x20\xDF\x0D\x03\xD2\xE0\x03\x20\xD1\x0E\x03\xD2\xE2\x03\x20\xD3\x0E\x03\xD2\xE4\x00\x63\xD5\x0E\x37\xD9\x2A\xDB\x88\xD9\x62\xFD\xD8\x92\xDB\x91\xD4\x64\xE3\x1F\xE6\x00\xA4\xD4\x69\xEE\xD8\x97\xDB\xA4\xDF\x63\xDD\xDA\x96\xD9\xA5\xDC\x63\xDF\xDA\xBE\x73\x39\x0A\x69\xF3\x19\xE8\x03\xA9\xD5\x64\xF6\xD8\xA2\xDA\x91\xD3\x6A\xEB\xDA\x48\xDB\x9C\x19\x0E\x2A\xDA\x24\xD8\xAB\xDC\x69\xED\xDA\xB6\xDB\xCE\x0A\x0E\x03\xD2\xEB\x00\xAD\xD8\x37\x6C\x03\xF3\xD1\x3B\x0C\x58\xEE\x03", - "\xF3\xD3\x3B\x03\x4F\xF0\x03\xBE\xDA\x75\x81\x0F\x03\xD2\xF2\x03\x20\xD3\x0F\x03\xD2\xF4\x03\x20\xD5\x0F\x03\xD2\xF6\x03\x3C\xD7\x0F\x03\xD2\xF8\x00\x9A\xD7\x61\x3B\x03\x11\xD5\x3F\x09\x55\xC3\xD2\xB6\xC2\x17\x93\x01\x0B\x41\x45\x0A\x00\x03\x6E\xD8\x7E\x03\x03\xB9\xD8\x45\xF8\xD9\xA7\x20\x01\x0A\x6E\xC8\xAD\x26\x17\xBB\xDB\xB4\xAF\x47\x08\x02\xBC\xD4\x46\xE5\x13\x09\x02\xBD\xDE\x1D\x0A\x00\xFA\xD8\x83\x8D\x6F\xC9\x04\x0C\x03\xBF\xD6\x10\x0D\x00\x02\xDF\x58\x75\x70\xC2\x04\x0F\x03\xC1\xD0\x6A\xC8\x1B\x10\x02\xC2\xD8\x6B\xF1\xDA\xB0\xDB\xC2\xDE\x6A\xC1\x11\x11\x02\xC3\xD7\x6B\xD7\xDC\x35\xD8\xC4\xD5\x6B\xDA\xDC\x37\x16\x04\x0E\x70\xD3\x00\x16\xDD\x3A\x74\x01\x21\xDC\x3E\x09\x05\x04\x72\xF9\x0C\x16\x03\xC9\xD8\x23\x17\x00\x2A\xDD\x98\x08\x01\x2D\xDC\x57\xCD\x06\x0E\x70\xDA\x00\x0E\xDF\x06\x0E\x70\xDC\x00\x0E\xDD\x07\x0E\x70\xDE\x00\x30\xDE\xA3\x0F\x01\x0E\xDC\x20\x02\xBD\xDA\x47\xF9\x0C\x23\x02\xBD\xD9\xDA\x46\xDD\xAC\x76\xC3\xD8\x02\x0E\xDC\x29\x01\xCF\xD3\x2B\x2A\x00\x0E\xDF\x0A\x0E\x74\xE1\xDA\x3D\x18\x0B\x08", - "\x74\xFC\x76\x57\xDF\x6F\x73\x75\xEF\x0F\x31\x02\xC3\xD2\x03\x0E\xDC\x33\x02\xC3\xD4\x03\x0E\xDC\x35\x02\xC3\xD6\x03\x0E\xDC\x37\x03\xD6\xD3\x71\xE7\x16\x38\x02\xDA\xD9\x6B\xEC\xDB\x1C\xDC\xD5\xDD\x37\xF9\x00\x6E\xDD\xDC\xDF\x6A\xDB\xDC\x12\xDF\xDB\xD1\x69\xD8\xDC\x96\x32\x0E\x05\x77\xF9\xDD\x76\xDF\xDA\xD1\x78\xCA\x83\x3B\x03\xDF\xDF\x70\xC0\xDE\x88\xDF\xE1\xDE\xE3\x3C\x00\x0E\xDD\x0F\x06\x78\xFC\xDD\x7B\xDD\xC6\xD9\x78\xD0\xDE\x9B\xDA\xE4\xDA\x49\x3E\x00\x8F\xDE\xE5\xDD\x6E\x7F\x00\x99\xDC\xDC\xD3\x79\xDA\xDE\xA0\xDC\x35\x50\x04\x1D\xDE\x91\xDE\xE7\xDA\x78\xD4\xDE\xDD\x29\x10\x04\x7A\xD5\xDE\xA6\xDF\x2E\xC2\x04\x2B\xDE\xA4\xD8\xEA\xD1\x71\xE7\xDE\xED\x6B\x10\x00\x7B\xF3\xDE\xB2\xDC\xDE\xD4\x7B\xED\xDE\xA1\xDD\xE9\xD6\x1B\x44\x01\xB7\xDE\xEE\xD9\x7B\xDE\xDA\xB8\xDD\xEF\xD9\x15\xC5\x01\xC1\xDC\xF1\xD2\x7C\xC6\xDF\xB1\xDD\xBB\x66\x04\x0E\xDC\x47\x01\xF2\xD4\xA7\x48\x01\xD2\xDF\xFB\x09\x04\x06\xDE\x4A\x02\xE1\xDB\x04\x15\xDF\x97\xB4\x13\x0E\x70\xCD\x01\x0E\xDE\x13\x0E\x70\xCF\x01\x0E\xDC\x14\x0E\x70\xD1\x01\x86", - "\xDE\x14\x0E\x70\xD3\x01\x42\xDE\x3C\x16\x05\x19\xDD\x03\x04\x16\x00\x7F\xC2\x04\x5A\x02\xC3\xDB\x05\x0E\xDC\x5C\x00\xF7\xD3\x10\x1D\x01\x0E\xDE\x17\x0A\x7F\xC3\xDE\x17\x1B\x17\x03\x7F\xC1\x04\x61\x03\x00\xE7\x4F\x63\x01\xFF\xDF\xCA\x04\x06\x0E\xDC\x65\x02\xC3\xD6\x06\x0E\xDC\x67\x02\xC3\xD8\x06\x0E\xDC\x69\x02\xC3\xDA\x06\x09\xE0\xBB\xDC\x13\x3B\x06\x18\xE0\xC3\xDE\xDC\xDC\x7B\xDF\xE0\xB6\x44\x1B\x0C\x81\xCC\xDF\xC5\xDC\x08\xEC\x7A\xFE\xDE\x27\xE1\x0A\xEB\xE4\x2D\x01\x23\xE2\x09\xED\x7C\xEE\xE0\x25\xE0\x0A\xEC\x35\xEE\x01\x2D\xE2\x0C\xE1\x83\xEA\xE0\x37\xE1\x86\x4F\x06\x35\xE0\x38\xE3\xF2\xD0\x83\xFE\xE0\x36\xE0\x10\xED\x83\xF3\x0A\x70\x00\x0F\xEF\x82\xC1\xE1\xCA\xDD\x12\xEF\xCD\xB1\x01\x46\xE1\x0E\xEE\x84\xC2\xE1\x47\xE3\x10\xEA\x32\xF2\x01\x4D\xE0\x14\xEF\x84\xCA\xE1\x77\xDC\x16\xE9\x28\xF3\x01\x55\xE2\x16\xEA\x77\xD2\xE1\x59\xE2\x07\xED\x14\xF4\x01\x5D\xE2\x18\xE0\x86\xC2\xDE\x9F\xDF\x0F\xE2\x02\xF5\x01\x65\xE1\x18\xEE\x86\xE8\xE1\x19\xE3\x19\xE1\x06\xF6\x01\x6D\xE0\x1C\xED\x81\xEF\xE1\x5F\xE1\x14\xEA\x87", - "\xD7\xE1\x66\xE3\x1E\xE6\x85\xFA\xDE\x77\x01\x1D\xE9\x87\xFC\xE1\x78\xE0\x00\xE9\x86\xC8\xE1\x7D\xE0\x21\xE6\x87\xE4\xE0\x7F\xE2\x17\xE7\xC3\x38\x01\x82\xE2\x21\xE7\x82\xB9\x01\x0E\xDE\x1E\x01\x89\xC7\xE2\x72\xE2\x24\xE2\xCD\xBB\x01\x97\xE1\x1C\xE5\xC1\xBC\x01\x9D\xE3\x1D\xEB\x88\xEA\xE1\xD7\x99\x1F\x01\x8A\xC8\x19\x7E\x03\x29\xE4\x8A\xC5\xE2\x98\xE2\x1F\xEE\x88\xED\xE2\x75\xC7\x1F\x0A\x8A\xC8\xE2\xAC\xE2\x27\xEA\x88\xC3\xE2\xD1\xCC\x20\x03\x8B\xD3\x13\x81\x03\x2E\xEE\x8A\xC9\xE2\x8D\xE0\x30\xEF\x8A\xE7\xA0\x82\x02\x2F\xE7\x8B\xDA\xE2\x8C\xE3\x30\xE2\x8A\xF8\xE2\xCA\xE1\x32\xE2\x8C\xE5\x39\x83\x02\x31\xE1\x8C\xF5\xE2\xCB\xE0\x32\xEB\x8A\xE3\xE2\xB4\xE3\x65\xB4\x08\x12\xE3\xCD\xE3\x35\xEC\x8C\xCF\xE3\xD4\xE2\x06\x95\x08\x0E\xDC\x86\x00\x37\xE0\x8E\xD8\xE3\x99\xE3\x61\xA7\x08\x26\xE3\xE1\xE2\x1B\x78\x08\x2C\xE3\xE8\xE3\x2F\xED\x8E\xF2\xA1\x89\x00\x3C\xEF\x8D\xC7\x44\x8A\x02\x3D\xE6\x8D\xD9\xE3\xF7\xE1\x3C\xE9\xDF\x0B\x02\xFA\xE0\x2C\xE3\x8D\xFE\xE3\x03\xE5\x3F\xE6\x90\xE2\xD8\x8C\x01\x40\xEA\x49\x0D\x02\x0A\xE5", - "\x35\xE2\x90\xDD\xE3\xFC\xE3\x3E\xE8\xA3\x4E\x02\x0D\xE6\x33\xE3\x8F\xE9\xE3\xB6\xE1\x41\xE2\x91\xF2\xE3\x04\xE6\x04\x2F\x08\x15\xE4\xDE\xE2\x33\x20\x09\x20\xE4\x11\xE7\x43\xE7\x8E\xC7\xE4\x26\xE7\xFB\x01\x09\x24\xE4\x18\xE6\x43\xE9\x91\xD0\xE4\x2D\xE6\x45\xED\x91\xEA\xCC\x92\x00\x4B\xEC\x91\xE8\xE4\x2F\xE5\x99\x33\x09\x1D\xE2\x94\x02\x4D\xE7\x8C\xEE\xB6\x95\x02\x4F\xEA\x91\xE9\xE4\x33\xE4\xEA\x26\x09\x1D\xE2\x97\x02\x50\xED\xD9\x18\x02\x4A\xE7\x49\xEB\x91\xFF\xE4\x39\xE7\x45\xE7\x93\xCF\xE5\x8E\x09\x26\x0D\x94\xD2\xE5\x50\xE6\x4B\xEA\x76\x1A\x02\x9D\xE3\x26\x07\x95\xC5\xE5\x61\x88\x27\x0F\x95\xF8\xE4\x5A\xE6\x4C\xE4\x96\xE6\xE5\xC9\x95\x27\x03\x96\xD4\xE5\x30\xE7\x54\xE4\x94\xE7\xE5\x21\xE7\x5B\xEC\x96\xCE\xE5\x72\xE5\x5D\xE1\x95\xE0\xE5\x70\xE5\x49\xEC\xA3\x5E\x02\x6B\xE6\x5D\xE5\x96\xF1\xE5\x77\xE5\x5E\xE8\xA3\x5F\x02\x7D\xE6\x26\x10\x0A\x05\xE6\x7F\xE4\x90\x01\x0A\x08\xE6\x68\xE6\x5F\xED\x98\xC1\xE6\xCE\x22\x28\x0E\x70\xE3\x02\x8C\xE6\x97\x34\x0A\x0A\xE4\xA5\x02\xE1\xD6\x0A\x06\xDE\xA7\x01\x65\xE9\xCC\x68", - "\x02\x0E\xDD\x2A\x0E\x70\xEA\x02\x0E\xDF\x2A\x0E\x70\xEC\x02\x0E\xDD\x2B\x06\x78\xEE\x02\x0E\xDF\x2B\x0D\x7E\xFD\x14\xB2\x02\x01\xE4\x0B\x06\xE0\xB6\x02\xC3\xD7\x0B\x0E\xDC\xB8\x00\x06\xE9\x0B\x0E\xDC\xBA\x02\x67\xE4\x69\xFB\x02\x06\xE1\x2F\x06\x80\xE3\x43\xBF\x01\x27\xE0\x0C\x0E\xDC\xC1\x02\xC3\xD2\x0C\x0E\xDC\xC3\x02\xC3\xD4\x0C\x0E\xDC\xC5\x02\xC3\xD6\x0C\x18\xE0\xC7\x02\x6F\xEE\x96\xD0\xE6\x8E\xE4\x60\xE9\x98\xF1\xE4\x80\xE4\x32\x06\x9D\xD9\xE5\x8F\xE7\x76\xE7\x9D\xF7\xDA\xC9\x03\x77\xE3\x94\xD8\xE7\xE8\xE6\x78\xE0\x9E\xDA\xE7\xE1\xE5\x7B\xEC\x9E\xFD\x1D\xCA\x02\x79\xED\x96\xEB\xE7\x7A\xE6\x7A\xE7\x9E\xF6\xE7\xF3\xE7\x7D\xEE\x9E\xF5\xE7\xFB\xE7\xD4\xCB\x0C\x32\xE7\x74\xE6\x8F\x3C\x0C\x18\xE0\xCD\x00\x06\xEE\x0C\x03\xE7\x8F\xE4\x34\x08\xA0\xCA\x19\xD2\x03\x82\xEC\xC4\x14\x03\x9D\xE1\x35\x00\xA0\xC2\x26\xD6\x02\xC3\xD7\x0D\x0E\xDC\xD8\x02\xC3\xD9\x0D\x0E\xDC\xDA\x02\x01\xEC\x0D\x0E\xDC\xDD\x02\xBD\xD8\x30\x61\x03\xAF\xE6\xC0\x04\x0E\x13\xE8\x12\xC0\x8A\xE2\x98\xFB\x68\xE6\x00\x06\xE7\x0E\x18\xE0\xE8\x02\x83", - "\xEC\x9D\xC0\x09\xEA\x02\x8C\xE3\x67\x2C\x03\x36\xEB\x27\x3E\x0E\x1D\xE2\xEF\x02\x8A\xE0\xA6\x30\x03\x0E\xDD\x3C\x0E\x70\xF2\x03\x0E\xDF\x3C\x0E\x70\xF4\x03\x06\xE2\x3D\x0E\x70\xF7\x03\x22\xEA\x42\x0B\x0F\x25\xE8\x13\x0C\x00\x00\x10\x00\xB6\x81\x00\x00\xFE\x13\x00\x02\x83\x81\x03\x82\x83\x7F\x08\x89\x88\x86\x87\x82\x85\x84\x86\x03\x8E\x8F\x90\x80\x02\x8B\x84\x8A\x16\xFF\x54\x95\x86\x8B\x8D\x8C\x8F\x1D\x98\xA1\x90\x8F\x88\x8D\x80\x86\x05\xA4\xA3\x8C\x85\x92\x96\x88\x90\x2F\xA2\xB1\x8E\x9E\x80\x99\x9A\x99\x37\xB4\x8A\x96\x9B\x9B\x8C\x0A\x88\x29\xAC\xAB\x8D\x83\x9A\xA1\xA2\xA2\x39\xC6\x89\xA8\xAD\x9A\x9F\x88\xA7\x17\xD0\x9A\x98\x9D\xA2\xA5\xAA\xA6\x4F\xD6\x99\xB8\xA1\xAA\xAD\xAE\xAE\x53\xD2\xBC\x9B\xA1\x8B\xA1\xB3\xA3\x67\xCB\xA9\xB7\xAB\xB4\xB2\x81\x96\x5E\xE1\xB1\xA3\xBF\xAD\xB5\xBB\xB7\x66\xF8\xA8\xBA\xBA\xB4\xBC\xB6\xBF\x6E\x9C\xBB\xA2\xCD\xBC\xC3\xBE\xC3\x81\xF0\xA0\xB4\xB2\xBB\xC4\xAB\xC4\x79\x88\xF7\xB2\xCD\xC6\xB9\xCA\xC0\x93\x8A\xD6\xCC\xCC\xCF\xC5\xCD\xC8\x9A\x98\xD7\xD4\xCD\xCA\xB2\xCF\xD1\xA1\xA4\xE7", - "\xC5\xD3\xBB\xD6\xD6\xD3\xB0\xAD\xF1\xCE\xC3\xDB\xCF\xD6\xD9\xB8\xB4\xF9\xD6\xD5\xDA\xD0\xD6\xDD\xC0\xBC\xFB\xDE\xD7\xD9\xE0\xE3\xDE\xAA\xC8\xE9\xCB\xE0\xD5\xE7\xC0\xE6\xCF\xCE\xC5\xD0\xE3\xEA\xEB\xC2\xEA\xD7\xD6\xD0\xD1\xEC\xED\xE9\xEF\xEC\xDF\xDB\xDE\xE3\xF0\xF4\xF2\xF1\xF2\xE8\xE7\xEA\xFF\xC1\xF4\xF6\xF2\xF7\xE9\xF0\xEB\xE8\xDA\xEA\xFA\xFA\xFA\xED\xF8\xC5\xC1\x0F\x98\x95\xE2\xE1\xC6\x49\x73\x72\x80\x01\x98\x73\x7F\x6F\x00\x89\x87\x73\x80\x06\xB7\x78\x83\x82\x05\xB5\x7A\x7D\x7C\x13\x87\x8F\x7C\x84\x0A\x84\x89\x85\x83\x15\x8E\x87\x86\x86\x18\xA1\x80\x8B\x88\x1C\x8F\x84\x8A\x84\x26\xA5\x8F\x86\x8A\xCA\x68\x8B\x8A\x8B\x2D\xB9\x79\x88\x8C\x0C\xB4\x81\x86\x8C\x2F\xB8\x81\x8F\x7B\x1D\xBD\x83\x8E\x8E\x35\x80\x97\x8C\x8F\x3F\x84\x99\x8E\x91\x3B\x94\x85\x92\x92\x47\x8C\x99\x92\x85\x4F\x9E\x81\x96\x8F\x4D\x90\x91\x90\x92\x03\x82\x0D\x7E\x41\x41\x43\x9E\x93\x95\x5F\x9E\x96\x96\x98\x52\xA0\x93\x9B\x86\x36\xA8\x92\x92\x9A\x58\xA4\x94\x97\x94\x4B\xA7\x92\x88\x8B\x66\xA5\x9E\x99\x9C\x76\xAC\x91\x9A\x9E\x72\xA7\x8B\x9B\x9C", - "\x69\x80\xAF\x9E\x9F\x6D\xBC\x99\x9E\xA0\x85\x88\xAB\x9E\xA2\x7D\xB4\x97\x9F\x87\x03\x1B\x94\x41\x95\x87\x84\xAB\xA2\xA5\x8D\x81\xA8\xA5\xA5\x8E\x86\xAF\x99\x9D\x9F\x8F\xA0\x9C\xA5\xA1\x9E\xA8\x9D\xA9\x8C\x9C\xAA\xA5\xA7\xA9\xA8\xAB\xA6\xAB\xAC\xAF\xA7\xAB\xAC\xA4\xB4\xA3\xAB\xAD\xA0\xB6\xA9\xAD\xAD\xBC\xB8\xA2\xAB\xAE\xBE\xA6\xAD\xAC\xB0\xC4\xBF\xA6\xB2\xB0\xC1\xAD\xAA\xAF\xB1\xCA\x83\xBC\xB2\xAC\xCE\x88\xB5\xB2\xB4\xCF\xB1\xA6\xB7\xAA\xD8\x83\xA7\xB6\xB6\xD9\x89\xA0\xB5\xB2\xDF\x93\xBD\xB0\xB8\xDB\x85\x64\x02\xA4\x02\x5D\x94\xB7\xBA\xE3\xA2\xB1\xB9\xB5\xDD\x97\xA5\xBA\xBC\xF1\x99\xAC\xB7\xBD\xDE\xB3\xB6\xBD\xBE\xF5\xAA\xA8\xBC\xBD\xFF\xBB\xB0\xC0\xBF\x01\xFE\xB4\xC3\xC1\x03\xC9\xC2\xC3\xC2\x06\xCA\xCD\xC0\xC3\xAE\x85\x08\xB8\x00\xEA\xAD\xB0\xBD\xC1\xB0\xBD\xB9\xC4\xC6\xCB\xAC\xBF\xBA\xC7\xFA\x93\x66\x03\xC4\x15\xDF\xC6\xC4\xC8\x9A\x87\x04\xC9\xB4\x02\x48\x0B\xC8\x44\x09\x2F\xCC\x42\x02\x32\xC6\x4B\x01\xCD\x03\x4C\x08\xCE\x40\x0D\x3B\xC0\x02\x03\x3E\xCF\x0E\xCC\x04\x3E\xD1\x0E\xCE\x04\x3E\xE1\xCB\xC4\xC2\x10", - "\xDD\xC7\xCB\xD3\x26\xE3\x83\x05\xD2\x1A\xFE\x44\xD4\xC7\x2C\xD1\xDA\xD2\xD3\x5A\xD5\xD9\xD7\xD6\x5F\xDE\xD4\xBA\xD8\xEE\xA0\xD3\xD8\xD6\xE0\x95\x07\xD4\xD3\x0F\xED\xD3\x6A\x05\x6B\xCE\xCB\xD2\xDC\x5C\xE6\xD5\xD8\xD9\x17\xEC\xD3\xDD\xD3\x61\xE8\xD7\xDE\xDF\x79\xF4\xDD\xDE\xDE\x75\xF8\xD8\xC8\xE0\x87\xC4\xE3\xE2\xE0\x67\xCA\xED\xE0\xE3\x7F\xCE\xE1\xE4\xE4\x81\xFC\xDF\xE2\xE5\x93\xD8\xE5\xE6\xDB\x85\xC8\xE0\xD6\xDD\x9B\xFB\xDC\xE7\xE2\x9A\xC9\xE4\xE6\xE9\x81\x57\x01\xDD\xE9\x9F\xC6\xED\xEA\xE7\x5D\xF0\xE0\xE8\xEA\xA3\xD7\xE5\xED\xE6\xB7\xE1\xED\xE6\xE4\xBA\xE4\xE9\xEC\xED\xA2\xC1\xFB\xEF\xE9\xAF\xFC\xE0\xF3\xF0\xAC\xF1\xE6\xF1\xF1\xC4\xCA\xFD\xF3\xEC\xCC\xC9\xF0\xF6\xF3\xD2\xEE\xE4\xF7\xEF\xD1\xD8\xF7\xF7\x68\x18\x2B\xEA\xF7\xF4\xE0\xD6\xF1\xFA\xEC\xE2\xE5\xF4\xFB\xF9\xCB\xDB\xF8\xF3\xF7\xE6\xE9\xF3\xFA\xFB\xED\xCF\xF1\xFD\xF5\xE8\xF2\xF5\xFC\xFD\xF0\xF7\xFC\xFA\xFE\xC2\xFE\xED\xFE\xED\xFF\x78\x75\x00\xBD\x70\x81\xF5\x43\x87\x78\xFE\x66\x82\x02\x89\x8C\x81\x02\x8D\x82\x80\x0B\x8E\x82\x04\x90\x8F\x80\x02\x94\x83", - "\x82\x16\x99\x80\x02\x98\x8B\x83\x0B\x9E\x82\x83\xD9\x67\x81\x08\x91\x8F\x83\x0E\xA0\x82\x7D\x15\x86\x86\x0A\xA3\x89\x84\x16\x90\x21\x03\x3E\x7A\x02\xF7\x22\x88\x84\x0E\xAE\x85\x84\x37\x87\x87\xFB\x76\x79\x7F\x1E\xBC\x87\x87\xF8\x60\x8B\xFE\x3E\x81\x89\x22\x83\x8A\x88\x34\x9B\x86\x11\xC9\x86\x7B\x0D\x33\x84\x84\x3A\x93\x7F\x11\xCB\x80\x8B\x15\xB5\x80\x87\x57\x91\x8B\xA0\x1C\x0F\x89\x16\x99\x8E\x8A\x4A\x93\x8A\x18\xCC\x8C\x7F\x2A\xB9\x80\x8C\x52\x84\x8C\x11\xE3\x86\x8D\x2F\xA7\x8F\x8D\x6E\x91\x8D\x18\xEA\x88\x88\xAE\x5D\x05\x8B\x36\x91\x8E\x07\x78\x88\x8B\x39\xAD\x8E\x8F\x5E\x80\x91\x1E\x82\x9D\x8F\x34\xBF\x8E\x90\x81\x88\x93\x20\x8A\x95\x91\x32\x89\x96\x91\x8B\x90\x91\x23\xEB\x84\x8E\x2A\x8F\x94\x92\x87\x92\x92\x16\x98\x97\x93\x3A\x9D\x96\x92\x91\x9C\x91\x28\x97\x5F\x02\x3E\x9B\x97\x52\x20\x06\x94\x1A\x9A\x9B\x94\x51\x93\x96\x93\xA3\x80\x97\x2B\xB2\x97\x94\x5A\xAD\x90\x96\xB3\x8C\x8F\x27\xBA\x91\x96\x5E\xB9\x95\x92\xBE\x95\x95\x30\xB7\x96\x96\x38\x84\x92\x98\xC0\x89\x9A\x89\x21\x0A\x94\x63\x8C\x90\x99\x99\x8E", - "\x94\x34\xBB\x9A\x98\x6A\x91\x98\x97\xD3\x9D\x95\x35\xDA\x97\x9B\x62\xB2\x8F\x99\xC4\x83\x98\x1C\xA2\x0E\x67\x11\x0D\x9F\x9B\xAC\x8E\x99\x3A\xE8\x92\x9B\x70\x9B\x9F\x97\xDD\x82\x9C\x3B\xD8\x9E\x9D\x78\xAF\x99\x9B\xF0\x96\x9A\x3E\xDC\x9B\x9F\x7C\xBC\x9F\x9F\xFE\x81\xA0\x3E\x83\xA5\x9F\x7E\x84\xA0\x8E\x24\x07\x9F\x31\x85\xA0\xA1\x83\xB3\x9E\x9B\x0B\xAA\x9D\x3B\x92\xA4\x9E\x8A\x90\xA0\x9C\x16\xB2\x9D\x44\x8F\xAA\xA2\x8C\x9C\xA7\x9E\x0C\xA2\xA1\x48\x8E\xAB\xA3\x92\x9E\xA6\xA4\x83\x45\x06\x42\xA7\xAC\xA5\x75\xA8\xA3\xA2\x1F\xB6\x9E\x4C\x86\xA3\xA5\x9A\x99\xA0\xA4\x37\xB3\xA5\x43\xB6\xA1\xA6\x9A\xB9\xA6\xA7\x3D\xBB\xA7\x4F\xC2\xA1\xA8\x91\x83\xAE\xA8\x45\xA4\xA5\x4B\xB0\xAF\xA5\x8A\x89\xAB\x20\x26\x0B\xA6\x4B\xCB\xAE\xA9\xA6\x97\xA3\xAA\x58\xAC\xA8\x55\xD7\xAA\xAB\xAC\x95\xAB\xAB\x1D\xBE\xA8\x57\xDF\xA2\xAD\xB0\x9D\xAF\xAC\x64\xA8\xAF\x58\xEB\xA6\xAD\xB4\xAE\xAC\xAD\x38\xAF\xAB\x51\xCA\xA5\xAD\xB8\x96\xAD\xAD\x70\xBA\xA4\x52\xF7\xA6\xAE\xB0\xBD\xAD\xAE\x7A\xB4\xAE\x5A\xF8\xA4\xB1\xBF\x83\xB6\xB0\x6F\xA5\xB1\x60\x9E", - "\x67\x04\x9F\x68\x02\xAA\x87\xAB\xB3\x5C\xBC\xAC\xAE\xC9\xB2\xAF\xB2\x95\xA0\xA9\x66\xC4\xAB\xB3\xBD\xBE\xAE\xB2\x9D\xAF\x59\x0A\x10\xB9\xB0\xC4\xB9\xAA\xB3\x9F\xA8\xB4\x60\xAA\xB5\x30\x15\x24\xB7\xB4\x9C\xA9\xB5\x6C\xAB\xB3\xB7\xC8\xAC\xB5\xB4\xA0\xB2\xB6\x67\xB4\xBB\xB6\xDB\xB5\xB0\xB7\x14\x2B\x07\x6B\x8A\xB7\xB6\xD8\xBD\xB0\xB8\xE0\x4C\x07\x70\xA6\xBA\x7B\x16\x0B\xBB\x23\x2E\x1E\x67\x0B\x3E\x60\x06\x9F\x71\x06\x67\x32\x1E\x67\x0C\x3E\x64\x06\x9F\x75\x06\x67\x36\x1E\x67\x0D\x3E\x68\x07\xE7\x85\xBC\xB8\xBF\xA9\x79\x0E\x66\xB8\x38\x1D\x2C\xBF\xB8\xC6\xA2\xB0\x72\xF0\xB8\xBC\xFA\x8C\xBF\xBE\x5C\x7B\x07\x7B\xF2\xB1\x30\x1E\x3B\xBC\xB2\xBA\xBC\xBD\x7D\x82\xC8\xBF\xF3\x85\xC1\xBD\x03\xC0\xC0\x6F\x84\xC9\xB7\x05\xCA\xC6\xB7\xF6\xAD\xC0\x84\x8C\xC6\xC0\x09\xF3\xBE\xA1\x3D\x1F\xBF\x64\x9B\xC8\xB3\x00\xCF\xC7\xC2\x1F\xD1\xBD\x88\x89\xCC\xC3\xD0\xA3\xC7\xC0\x11\xD5\xC2\x8A\x88\xC8\xC4\x0A\xEC\xC6\xC2\x22\xC5\xC6\x87\xB2\xCE\xC0\x1A\xD3\xC6\x8A\x3E\x1A\xC1\xD4\x3F\x0A\xC6\x13\xF6\xC0\xC4\x3F\xD1\xC5\x87\xB5\xC3\xC9\x1B", - "\xC1\xCC\xC4\x45\xC0\xC9\x92\xC2\xCE\xC7\x25\xD3\x30\x08\x3E\x61\x09\x8F\xB3\xCE\xC9\x16\xE7\xC0\xC6\xDA\x62\x0B\x94\xC4\xCD\xC9\x2E\xD4\xCE\xCB\x5C\xDF\xCA\x98\xE1\xC4\xCC\x23\xD5\xC8\xCB\x56\xC7\xC9\x9A\xE7\xCB\xC5\x14\xEF\xC5\xCD\x2E\xCE\xCC\x16\xC3\x0B\xCA\x98\x84\x0D\xCE\x4A\xC0\xCE\x99\xFA\xC9\xCF\x31\xFB\xCE\xCF\x7D\xC5\xCD\xA0\xFF\xC2\xD0\x26\xC0\xD6\xD0\x85\xC8\xC8\x9F\x88\xD4\xD1\x46\xC3\xD7\xD1\x8C\xD0\xD2\xA2\x87\xD8\xC9\x22\x38\xC9\xD2\x98\xD3\xD1\xA2\xEB\xCB\xA2\x23\x3E\x67\x08\x97\xDA\xD2\xA3\x99\xDC\xD2\x4A\xE5\xD3\xD3\x68\xC9\xD4\x9C\xD7\xCB\xD4\x35\xEA\xD7\xCD\xB0\xD2\xCD\x9C\xB3\xDC\xD5\x58\xF4\xD6\xD5\xAD\xCC\xCE\xAD\xB5\xDE\x5C\x24\x21\xD7\xD4\xA3\xC2\xD6\xA4\xC0\xD3\xD9\x57\xF2\xD4\xD7\xB7\xDA\xD7\xB1\xB8\xDB\xD6\x66\xCB\xDA\xD9\xC9\xCB\xD2\xB0\xA4\xD6\xD9\x67\x49\x0F\xD7\xD5\xC8\xDA\xB6\xCE\xD1\xDA\x53\xD9\xDC\xDB\xDB\xD0\xD9\xB8\xD2\xD4\xD8\x6A\xF9\xD4\xDC\xDF\xC2\xDC\xB8\xEB\xDA\xDD\x76\xE8\xDF\xDC\xDE\xD0\xDC\xAA\xF2\xD1\xD9\x72\xD3\xDF\xDE\xF6\xCE\x56\x12\x58\xD4\xDF\x62\xFD\xDE\xDC", - "\xCD\xCE\xDD\xBC\x81\xEF\xDC\xA2\x8B\x0C\xDF\x04\xE3\xE3\xB3\x85\xEB\xE0\x85\xDD\xDB\xDE\x09\xF0\xE1\xC3\x92\xEF\xE1\x7A\xE9\xDC\xE1\x15\xFE\xDD\xC4\x96\xEF\xDE\x7C\xD7\xE6\xE1\xE3\xC0\xE4\xBB\x98\xE1\xE4\x8A\xE5\xE1\x7D\x4C\x08\xE3\xC4\x9C\xEB\xE2\x8D\xEB\xE6\xE5\x19\xE0\xE3\xCB\xB2\xE1\xE6\x8F\xDD\xE1\xDF\x1F\xE6\xE7\xC8\xA2\xE2\xE0\x9D\xF1\x8D\x09\x13\x62\x03\xCD\xB9\xEC\xE5\x99\xF6\xE1\x8F\x4F\x01\xE8\x45\x51\x0A\xE9\x96\xF4\xE7\xE4\x30\xF0\xEB\xD3\xBB\xEE\xE6\x92\xD4\xED\xE8\x35\xF8\xE7\xD0\xDB\xEE\xE9\xA3\xC6\xEA\xEB\x5D\xE0\xEF\xD7\xC4\xE1\xEB\xAB\xE5\xED\xE7\x58\xF2\xEA\xD7\xD9\xE4\xED\xA9\xE8\xEF\xEC\x56\xEF\xEE\xDB\xF1\xE4\xEE\x9E\xF5\xED\xEA\x76\xF1\x33\x14\x2A\xEC\xEC\xAE\xE3\xEE\xEF\x7D\xE0\x5C\x15\x7C\xEA\xEC\xB1\xC1\xF7\xEF\x61\xED\xEF\xDA\x85\xFA\xF0\xC3\xCC\xF0\xF0\x8F\xE9\xF0\xE4\xE6\xE3\xEF\xBC\xF8\xE8\x76\x55\x04\xF0\xE5\x8B\xFB\xF2\xC7\xDD\xF5\xF1\xA0\xF3\xF2\xDC\x9C\xF3\xF4\xCF\xE5\xF1\xF4\x01\xF6\x0A\xE6\xA7\xF2\xF5\xBB\xE9\xEF\xF3\xAD\xF6\xF3\xEB\xAC\xF2\xF3\xDA\xC8\xF7\xF6\x87\xF9\xF5", - "\xE4\xB8\xFB\xF7\x64\xD7\x0B\xF5\xAE\xF0\xEE\xEC\xC2\xF7\xF3\xD9\xC1\xFD\xF2\xC5\xE4\xFA\xF1\xC3\xF8\xF9\xE5\xC9\xFD\xF9\xCA\xF1\xF8\xF4\xD3\xF4\xF5\xE3\xD5\xFC\xF9\xD7\xEF\xF9\xF6\xCE\xFC\xFA\xE9\xD5\x50\x0B\xC0\xF8\xFA\xE9\xD6\xF3\xFC\xF1\xE8\xF4\xF7\xB0\xF6\xF6\xEE\xE9\xF8\xFC\xDA\xED\xFC\xFC\xE7\xEB\xFE\xFB\xF2\xF0\xFF\xD8\xDA\xFD\xFC\xF7\xF1\xFD\xEF\xFB\xFC\xFC\xFA\xE6\xFE\xFE\xDD\x74\x7D\xF8\x71\x80\xDB\x7E\x7D\x03\x86\x80\xFA\x7D\x7F\xFC\x73\x7F\x0B\x89\x05\xE1\x79\x7F\x00\x88\x80\x14\x1A\x05\xAB\x7B\x05\x0F\x84\x80\x07\x82\x80\x09\x8C\x80\x0A\x8D\x81\x1C\x8F\x81\xF5\x7A\x7E\x0B\x81\x82\xEF\x7F\x7F\x22\x8E\x81\x71\x7C\x05\x17\x8A\x64\x5D\x0A\x63\x5E\x0E\x33\x5F\x0E\x33\x60\x0E\x33\x61\x0E\x33\x62\x0E\x33\x63\x0E\x33\x64\x0E\x33\x65\x0E\x33\x66\x0E\x33\x67\x0E\x33\x68\x0B\x82\x1A\x81\x81\x7D\x29\x06\xAB\x7A\x06\x44\x85\x80\x45\x87\x82\x20\x86\x82\x25\x80\x3B\x6B\x0B\x84\x19\x8C\x84\x56\x8E\x2A\x6C\x04\x85\x1B\x84\x82\xFE\x70\x81\x4E\x8C\x85\x23\x80\x85\x5D\x88\x81\x5B\x82\x86\x61\x8E\x85\x51\x8E\x2D\x6D", - "\x0E\x33\x6E\x0A\x85\x46\x82\x4F\x6F\x0E\x86\x10\x10\x07\xE7\x41\x07\xE7\x42\x07\x72\x89\x86\x12\x88\x1C\x73\x0E\x33\x74\x0E\x33\x75\x0E\x33\x76\x0E\x33\x77\x0E\x33\x78\x07\x4E\x79\x0E\x33\x7A\x03\x31\x03\x0E\x45\x7D\x0D\x74\x0C\x1F\x07\x90\x86\x10\x81\x0E\x33\x82\x0E\x33\x83\x0A\x63\x84\x0E\x33\x85\x09\x87\x63\x8B\x87\x7A\x81\x18\x86\x03\x89\x03\x18\x08\xA4\x88\x82\x1E\x5A\x08\xAB\x7B\x08\x3E\x3C\x08\x3E\x3D\x08\x3E\x3E\x08\x3E\x3F\x08\x3E\x30\x09\x3E\x31\x09\x3A\x62\x09\x9E\x87\x86\x64\x8F\x86\x55\x8F\x8B\x65\x88\x86\x9F\x8D\x84\xA1\x87\x85\xC1\x8D\x8B\x5F\x86\x86\xA8\x82\x8C\xBC\x80\x8A\xC3\x82\x4F\x93\x0B\x8B\xCB\x88\x8C\xC5\x80\x8C\xBE\x87\x8C\xCE\x8D\x8C\xC4\x8F\x8C\xD6\x89\x8C\xCC\x83\x8D\xD9\x80\x8E\xDB\x8A\x8D\xC6\x87\x8D\xE6\x8E\x8D\xD4\x8C\x8D\xD8\x83\x8E\xE2\x88\x64\x94\x02\x8D\x4F\x8F\x8D\xF1\x89\x8E\xE4\x8D\x8D\xD5\x8B\x8E\xE5\x88\x8E\xE1\x83\x8F\xFB\x80\x86\xED\x86\x8F\xEA\x87\x8E\xF7\x82\x90\x01\x9A\x8F\xEC\x8C\x8F\x07\x9E\x8F\x08\x99\x8F\x03\x96\x90\x0C\x95\x90\x0D\x91\x91\x10\x93\x91\x0B\x85", - "\x09\xF0\x8A\x90\x18\x9A\x8C\x23\x26\x09\x17\x9E\x51\x97\x0E\x33\x98\x07\x4E\x99\x0E\x33\x9A\x0E\x33\x9B\x0E\x33\x9C\x0E\x33\x9D\x0E\x33\x9E\x0E\x33\x9F\x0E\x33\xA0\x0E\x33\xA1\x0E\x33\xA2\x0E\x33\xA3\x0D\x91\xF2\x8A\x90\xA4\x0B\x7A\xA5\x08\x93\xF4\x8F\x8F\xF8\x80\x90\xF5\x8B\x81\xA6\x0E\x93\xFD\x8A\x91\x19\x93\x18\xA7\x06\x94\xDE\x48\x0A\x3A\x69\x0A\x3E\x3A\x0A\x3E\x3B\x0A\x3E\x3C\x0A\x3E\x3D\x0A\x3E\x3E\x0A\x3E\x3F\x0A\x3E\x30\x0B\x3E\x31\x0B\x3E\x32\x0B\x3E\x33\x0B\x4C\x9F\x90\x43\x94\x11\xB4\x0B\x7A\xB5\x05\x96\x42\x90\x94\x04\x97\x96\x0E\x96\x7A\xB6\x0C\x96\x5C\x37\x0B\x74\x9F\x96\x6E\x91\x97\x41\x9B\x97\x78\x9B\x90\x6D\x9E\x97\x7C\x9A\x97\x7D\x99\x94\x3F\x90\x98\x83\x98\x94\x88\x92\x8F\xB8\x07\x97\x82\x9D\x98\x12\x90\x97\x8F\x99\x97\x91\x96\x98\x8E\x94\x91\x92\x96\x99\x94\x93\x99\x84\x9B\x8F\xB9\x0C\x98\x03\x2A\x0B\x9E\x98\x99\x9B\x99\x90\x89\x95\x98\xA3\x96\x96\x97\x90\x99\xA2\x95\x9A\x47\x99\x93\xAC\x94\x9A\x44\x6B\x0B\xA1\x9A\x9A\xB4\x99\x9A\xB6\x99\x99\xAB\x9E\x9A\xBA\x96\x9A\xAF\x98\x9A\xB8\x95\x9B", - "\xBF\x97\x9B\xA7\x9F\x97\xC3\x91\x98\x9A\x9D\x9B\xC4\x98\x9C\xC6\x97\x42\xBC\x03\x9B\xC2\x9A\x9C\x87\x9B\x9B\xAD\x9C\x9B\xD2\x90\x9B\xD4\x97\x9D\xD3\x99\x9D\xD6\x9A\x9D\xBE\x95\x9C\xD1\x98\x9D\xDB\x91\x9E\xDD\x90\x9D\x95\x90\x9C\xDE\x95\x9E\xCF\x95\x9D\xE3\x9A\x9E\xC9\x9C\x9E\xCB\x96\x9E\x1E\x5D\x0B\xCE\x91\x9C\xF4\x9A\x90\xBE\x03\x9F\xD3\x3F\x0B\x3A\x60\x0C\x3E\x31\x0C\x3E\x32\x0C\x3E\x33\x0C\x3E\x34\x0C\x3E\x35\x0C\x3E\x36\x0C\x3E\x37\x0C\x3E\x38\x0C\x3E\x39\x0C\x3E\x3A\x0C\xF8\x94\x9E\xCF\x6B\x0C\xAB\x7C\x0C\x11\xAE\x9E\xDF\x9C\x9D\xED\x90\x9E\xDA\x3D\x0C\x17\xAC\xA1\x1B\xAA\xA1\xEF\x99\x9E\x20\xA3\xA2\xF5\x92\xA1\xB9\x95\xA2\x19\xA2\x9E\x21\xAC\xA2\x26\x2E\x0C\x1F\xA2\xA2\x2B\xAE\x9B\xCF\x07\x4E\xD0\x00\x8F\xD1\x01\xA3\x2E\xA3\xA3\x2D\xAB\x9E\x2A\xA8\x9E\x27\xA8\xA1\x40\xA7\x9E\xC7\x92\xA4\x45\xAF\xA3\x47\xA2\xA3\x43\xA8\xA2\xF0\x96\xA4\x29\xAA\xA4\x49\xAB\xA3\x4B\xA2\x8F\xD2\x0A\xA3\x3E\xA0\xA5\x98\x93\x0D\x56\xA3\x1A\xD4\x0B\xA5\x26\xA4\xA4\x4F\xA2\xA5\x51\xA7\xA5\x62\xA1\xA6\x64\xA7\xA6\x3D\xA9\xA6\x5F", - "\xAC\xA4\x24\xA8\xA5\x4D\xA8\xA4\x66\xAA\xA6\x3C\xAB\xA6\x4E\xAF\xA6\x6E\xAE\x81\xD5\x0E\xA5\x73\xAB\xA7\x53\xA6\x66\xD6\x0A\xA7\x7D\xA7\xA7\x41\xA0\xA7\x76\xA5\xA6\x85\xA8\xA6\x74\xA4\xA8\x6D\xA1\x18\xD7\x00\xA8\x63\xA2\xA7\x81\xA6\xA8\x8B\xA8\xA8\x7C\xAF\xA8\x89\xA2\xA8\x60\xA7\xA8\x90\xA6\xA9\x95\xA1\xA7\x97\xAE\x76\xD8\x0E\xA8\x9E\xAD\xA9\x9A\xAF\xA9\x94\xA1\xA9\xA7\xAC\xA9\xA8\xAB\xA9\xA3\xAB\xAA\xA6\xA1\x57\xD9\x02\xAA\xA5\xA4\xAA\x93\xAC\xAA\xB3\xAE\xAA\xB4\xA3\xA8\x98\xAC\xA6\xBA\xA2\xA9\xBD\xA9\xAA\xAD\xAA\xAA\xC2\xA1\xAC\xC4\xA7\xAB\xC3\xA6\xAC\xC5\xA0\x35\xDA\x02\xAB\xB5\xAF\xAA\xCE\xA9\xAB\x99\xAD\xAC\xD0\xAC\xAB\xD1\xAF\xAB\xB6\xA2\xAD\xB8\xA9\xAD\xC7\xA8\xAD\xDB\xA6\xAD\xCF\xAA\xAD\xCF\x2B\x0D\xCC\xAE\xAD\xD3\xA5\xA7\xDC\xA9\xAC\xE4\xA0\xAE\xC8\xAB\xAE\xE7\xAC\x53\xDC\x03\xAE\xD5\xA1\xAF\xD4\xA3\xAF\xE6\xA9\xAE\xDD\xA2\xAF\xF5\xA8\xAF\x8A\xA6\xAF\xE8\xAA\xAF\xBB\xA9\xAF\x91\x1D\x0D\xF0\xAA\x29\xDE\x0A\x63\xDF\x0E\x33\xE0\x0E\x33\xE1\x0E\x33\xE2\x0E\x33\xE3\x0E\x33\xE4\x0E\x33\xE5\x0E\x33\xE6\x0E", - "\x33\xE7\x0E\x33\xE8\x0E\x33\xE9\x03\xB0\x00\xBB\x4E\xEA\x0B\x7A\xEB\x0C\xB1\xFB\xAE\xAF\xBE\xA4\xB2\xA4\x7C\x0E\x22\xBF\xAF\x23\xB4\xAF\x2B\xBD\xB1\x2D\xBF\xB2\x2A\xB1\xB3\x25\xBC\xB2\x32\xB0\xAC\xEC\xAC\xAF\x19\x2D\x0E\x3E\x3E\x0E\x29\xBE\xAB\xEF\x00\x8F\xF0\x07\x4E\xF1\x07\x4E\xF2\x0E\x33\xF3\x0D\xB3\x36\xB0\x47\xF4\x0E\x33\xF5\x0E\x33\xF6\x0E\x33\xF7\x0E\x33\xF8\x0E\x33\xF9\x07\x4E\xFA\x0E\x33\xFB\x0C\x88\x5E\x4E\x0F\xA7\x82\x10\x15\x00\x11\x42\x70\xB6\x5F\xBE\x1F\x10\x13\x00\x63\xBC\x25\x14\x14\x00\x67\xB3\x29\xE0\x25\x00\x6B\xB9\x2E\x14\x16\x00\x6F\xB4\x31\xE5\xA0\xB3\xBE\xA7\x00\x73\xB1\xB6\x0C\x19\x00\x79\xB5\xB7\x97\x2B\x00\x73\xB5\x32\xD3\x3C\x00\x81\xB4\x11\x0D\x05\xB8\x10\x1E\x00\x88\xBC\x10\x0F\x0B\xB8\x06\x10\x01\x8E\xB3\x10\x11\x01\xB9\x02\x12\x01\x94\xB8\xB3\xED\xA9\xB9\x00\x03\x01\x97\xB1\x77\x14\x0D\xB9\x34\xB3\xB3\x2E\xB5\xB3\xD7\xA8\xB9\xA6\xB6\xB2\xA5\xB8\xBA\xDF\xA3\x20\x15\x07\xB9\x16\x00\xBA\xA3\xBE\x76\x17\x00\xBB\x30\x58\x01\xB4\xB7\x18\x19\x07\xBB\x81\x1A\x01\xBA\xB9\xB4\xA7\xBA\x29", - "\x1B\x07\xB9\x1C\x07\xB9\x1D\x07\xB9\x1E\x07\xB9\x1F\x07\xB9\x20\x0D\xBB\xA3\x11\x02\x97\xB2\x02\x73\xBD\x88\x79\x45\x02\x7D\xB0\x11\x27\x05\xBD\x0C\x19\x02\x97\xBA\x02\x97\xBB\x02\xCC\xB6\x22\x2C\x07\xB9\x2D\x0F\xBD\x7E\xB2\xBA\x85\x9E\x02\xD8\xB6\x10\x30\x09\xBE\x37\xB1\x2B\x32\x04\xBE\xE0\x23\x03\x97\xB4\x03\x97\xB5\x03\x97\xB6\x03\x97\xB7\x03\x97\xB8\x03\x97\xB9\x03\xF0\xB7\xAF\xA1\xBE\x9B\x3A\x0F\xBF\xC9\x6B\x03\x04\xCD\xBE\x01\xC9\xBA\x09\xCB\xBA\xFD\xAB\xC0\xE5\xBE\xBB\xAA\xBE\x45\x3C\x07\xC0\x9A\xB1\xC1\xEA\xA5\xC1\x0E\xC7\xC1\xBF\xB1\xBB\x10\xC9\xC1\x00\xCC\xC1\x0A\xC0\xC2\x0C\xC8\xC0\x22\xC9\x35\x3D\x04\xC1\x1B\xC6\xB7\x1D\xC5\xC2\x1A\xC6\xC1\x1F\xCA\xC2\x21\xC0\xC3\x23\xC8\xC1\x2C\xCF\xC2\xA4\xB3\xC3\x29\xC7\x18\x3E\x0C\xBE\x34\xC2\xC3\x0F\xC1\xC3\x37\xCF\xC3\x38\xCE\xC2\x0D\xC5\xC3\x45\xCE\xC3\x2D\xCE\xC1\x47\xC1\xC4\x49\xC6\xC4\x24\xC8\xC4\xDD\xA0\x04\x28\xC4\xC4\x4F\xCC\xC4\x36\xC6\xBE\x56\xCB\xC4\x58\xCB\xC5\x2B\xC0\xC5\x5A\xCD\xC5\xFB\x81\x04\x53\xCA\xC4\x55\xCC\xC5\x40\xC6\xC6\x43\xC4\xC6\x3D", - "\xC9\xC5\x65\xC0\xC6\x68\xC2\xC4\x70\xC8\x1C\x42\x03\xC6\x4E\xCB\xC6\x6F\xCD\xC4\x5E\xCD\xC6\x67\xCE\xC6\x7C\xCB\xC7\x7E\xC9\xC6\x75\xC9\xC3\x77\xC7\xC5\x7D\xC0\xC8\x79\xCC\x6E\x43\x0C\xC3\x82\xC5\xC8\x71\xC4\xC8\x7F\xCD\xC8\x5F\xCF\xC8\x78\xCC\xC6\x76\xCC\xC8\x93\xC3\xC8\x91\xC6\xC8\x94\xCB\xC8\x92\xCE\xC8\x9A\xC8\xC9\x7A\xCF\xC9\x93\x15\x04\x97\xB6\x04\x74\xC7\xC8\x9C\xC2\xCA\x9D\xC9\xC9\x90\xC1\xCA\xAD\xCE\x81\x47\x07\xCA\x9B\xC4\xC5\x95\xCB\xCA\x19\x28\x04\xB2\xC0\xCA\xB5\xCA\xCA\xBC\xCF\xCA\xA9\xCE\xCB\xB4\xCD\x6E\x49\x09\xCB\x96\xCE\xC9\xB9\xAA\x04\xC4\xC1\x57\x4B\x09\xCC\xBD\xC7\xC9\xC5\xCC\xCA\xCE\xC6\xCB\xBB\xC0\xCC\x6A\xCF\xCB\xD1\xCD\xCC\x03\x2C\x04\xCC\xC0\x54\x4D\x08\xC2\x4E\x0B\xCD\x10\x1F\x04\x97\xB0\x05\x97\xB1\x05\x97\xB2\x05\x97\xB3\x05\x97\xB4\x05\x97\xB5\x05\x97\xB6\x05\x97\xB7\x05\x97\xB8\x05\x97\xB9\x05\xE0\xC6\xCC\x40\xAA\x05\xF7\xC1\x20\x5B\x0B\xCF\xAE\xC7\xCD\xD4\xC1\xC8\x29\x8E\xCF\xD3\xC0\xD0\x4E\x8D\x05\x04\xDF\x81\x5E\x09\xD0\x5F\x07\xB9\x60\x07\xB9\x61\x07\xB9\x62\x07\xB9\x63\x07", - "\xB9\x64\x07\xB9\x65\x07\xB9\x66\x07\xB9\x67\x07\xB9\x68\x07\xB9\x69\x09\xD0\xC1\xCA\x90\x6A\x02\xD2\x91\x1B\x06\x26\xD2\xD0\xD5\xC3\xD2\x2B\xDC\x73\x6C\x09\xD2\x66\x6D\x06\x30\xD3\xCB\x2D\xDA\xD2\x36\xD8\xCA\x2C\xD7\xD3\x34\xDA\xD3\xBA\xC6\xCD\xF8\xCF\xD3\xD0\xC0\xD4\x19\x2E\x06\x33\xD1\x18\x6F\x05\xD4\xCF\xCF\xCF\x42\xD5\xD0\x4B\xDE\xD3\x41\xDF\xD4\x4A\xD0\xD5\x4C\xD2\xD5\x51\x30\x07\x48\xD1\x57\x71\x07\xD5\xD8\xC4\xD5\x39\xD8\xD3\x35\xDE\xD5\x3C\xD9\xD4\x53\xD1\xD5\x64\xD3\xD6\x1C\x62\x07\x5A\xD1\xD0\x60\xDB\xD6\x3B\xDC\xD6\x3D\xDD\xD5\x6D\xD1\xD7\x6F\xDF\xD5\x72\xD2\xD6\x4E\xD5\xD6\x77\xD6\xD6\xED\x63\x07\x69\xD6\xD0\x4D\xD0\xD7\x73\xD1\xD6\xD2\xC9\xD7\x84\xD0\xD8\x76\xD6\xD8\x83\xD8\xD8\x5B\xD8\xD7\x8A\xDA\xD6\x75\xD9\xD8\x74\xD1\x18\x74\x0D\xD7\x7F\xD1\xD9\x87\xD6\xD9\x90\xD2\xD8\x8B\xDA\xD7\x8D\xD4\x54\x75\x04\xD9\x5C\xD8\xD9\x9B\xD5\xD8\xA2\xDE\xD8\x81\xDE\xD6\x97\xDA\xD9\xA6\xD9\xDA\xA8\xD9\xD9\x30\x56\x07\xA0\xDE\x31\x77\x01\xDB\x9C\xD5\xDA\x7E\xD1\xDA\xAA\xD7\xDB\x8C\xD6\xDB\x95\xD9\xDB\xBD\xDD\xDA", - "\xA3\xDD\xD9\xBF\xDF\xD8\xC1\xDC\xDB\xB8\xD0\xDC\xAB\xDE\xDA\xC4\xD2\x7A\x78\x04\xDB\x71\x49\x07\x28\xCA\x07\x09\xDB\x07\x97\xBC\x07\x97\xBD\x07\x97\xBE\x07\x97\xBF\x07\x97\xB0\x08\x97\xB1\x08\x97\xB2\x08\x97\xB3\x08\x97\xB4\x08\x97\xB5\x08\xCE\xD2\xDC\xC9\x66\x08\xCE\xD7\x08\xE9\xD6\xDC\xBB\xDE\xDB\xC7\xDD\x3C\x88\x0F\xDE\xF2\xD1\xDF\x30\x59\x08\xF6\xD6\x66\x8A\x09\xD0\x8B\x07\xB9\x8C\x07\xB9\x8D\x07\xB9\x8E\x07\xB9\x8F\x07\xB9\x90\x07\xB9\x91\x07\xB9\x92\x07\xB9\x93\x07\xB9\x94\x07\xB9\x95\x0B\xDF\xCB\xD1\x70\x96\x0E\xDC\x97\x04\xE1\xA7\xD5\xE1\xC3\xDB\xE1\xDE\x48\x09\x1A\xEC\xDA\x1C\xE3\xDF\xC9\x39\x09\x09\xDA\x09\x09\xDB\x09\x8A\xCA\xDE\xF8\xD7\x29\x9D\x0B\xE2\x1E\x5F\x09\x30\xE5\xAF\xA1\x0E\xDC\xA2\x01\xE2\x83\xD3\x0A\x97\xB4\x0A\x97\xB5\x0A\x97\xB6\x0A\x97\xB7\x0A\x8A\xC9\x0A\x97\xBA\x0A\x73\xB4\x00\x14\x1E\x0A\xD1\xBF\x21\xB1\x09\xD0\xB2\x08\xE3\x6D\x43\x0B\x50\xE9\xDC\xC5\xD7\xDF\x1C\x64\x0B\x09\xD5\x0B\x09\xD6\x0B\x33\xE8\xDC\xBA\xD0\x35\xB8\x0D\xE5\x4E\x5A\x0B\x62\xEE\xAB\xBC\x0E\xDC\xBD\x03\xE5\x1A", - "\xCE\x0B\x97\xBF\x0B\x97\xB0\x0C\x97\xB1\x0C\x97\xB2\x0C\x8A\xC4\x0C\x97\xB5\x0C\x47\xE4\x11\xC9\x0B\xE4\xC8\x1C\x0C\x09\xDD\x0C\x6A\xE8\x45\xCE\x01\xE8\x24\xE2\xE2\x1E\xE4\x7A\xCF\x04\xE8\x2D\xE7\xE8\xCA\xDC\xE8\x55\xEE\xE5\x1D\xE6\xE8\x92\xEE\x2A\xD0\x0A\xE8\xB5\xD6\xE5\xA4\xD8\xE9\x2C\xE7\xE9\x90\xE5\xE8\x8D\xE3\xE9\x8F\xE3\xE2\x8B\xE0\xEA\x1F\x21\x0D\xCE\xD2\x0D\x96\xE9\xE9\x9D\xE3\xEA\x9F\xED\xEA\xA1\xEE\xE8\x54\xE1\xEB\x5F\xEA\xEA\xA2\xEC\x6E\xD3\x05\xE6\xA4\xE3\xEB\x9B\xE4\xEB\xB0\xE4\x54\xD5\x09\xEA\xBB\xE1\xEC\xF0\xDC\xE9\xB5\xEC\xEB\xB9\xE1\xE9\xAE\xE2\xEB\xC8\xEF\xEA\xC7\xEE\xE9\xCC\xE9\xEC\xBA\xE3\xEC\xC6\xE0\xED\xCB\xEA\xEC\xCE\xE6\xED\xAC\xE3\xDA\xD6\x00\xEC\xD2\xE2\xEC\xB0\x37\x0D\xDC\xE3\x18\xD8\x01\xEE\xAB\xE4\xEC\xBD\xE5\xED\xD1\xEA\xE9\xDD\xEB\xEE\xF5\xA9\x0D\xE4\xE5\xEC\xDE\xE5\xEE\xD3\xEF\xEC\xF4\xE8\xED\xE6\xED\xEC\xD9\xE6\xEF\xF3\xEA\xEF\xF1\xE0\xEF\xEC\xE2\xEF\xFD\xE7\xEE\xD7\xE9\xEE\x00\xF6\x3D\xDA\x0F\xEE\x02\xF9\xEF\x04\xFE\xEF\xEA\xED\xF0\x05\xFE\xF0\x0C\xFF\xF0\x12\xFD\x3C\xDB\x08", - "\xF0\xF8\xE7\xEF\x71\x5C\x0D\x16\xF3\x1A\xDD\x0B\xF1\xF5\xEB\xF0\x09\xF8\xF1\x1F\xF8\xEE\x24\xF3\xF0\xED\x7E\x0D\x1E\xFC\xEF\xFF\xE1\xF1\x2C\xF1\xF2\xFB\xE0\xF2\x17\xFF\xF2\x25\xFA\xF0\x93\x9F\x0D\x29\xF0\xF3\xD4\xE6\xF2\x3A\xF4\xF3\x3B\xF2\xF2\x2A\xF0\xF1\x2E\xF1\xF0\x31\xFA\x90\xE0\x07\xF3\x0C\x11\x0E\x46\xFD\xF3\x32\xFA\xF4\x42\xF9\xF3\x3C\xFF\xF4\x3E\xF1\x70\xE2\x09\xF4\x50\xFB\xF4\x55\xFD\xF4\x23\xFC\xF4\x2B\xF1\xF4\x5B\xF3\xF4\x5D\xFE\xF4\x51\xF3\xF3\x61\xFA\xF5\x40\xFE\xF5\x65\xF0\xF6\x56\xFA\xD7\xE3\x04\xF5\x63\xF7\xF5\x5F\xF9\xF5\x6E\xF7\xF6\x70\xFD\xF6\x74\xF9\xF6\x76\xFA\x90\xE4\x0C\xF6\x77\xFF\xF6\x3F\xF3\xF1\x5C\xF2\xF7\x7D\xFD\xF2\x66\xFE\xF7\x83\xF2\xF8\x68\xF1\xCC\xE5\x0A\xF7\x58\xF1\xF8\x7F\xF4\xF8\x87\xFC\xF7\x38\xF6\x22\xE6\x0A\xF8\x90\xF2\xF6\x7B\xF0\xF8\x91\xFC\xF8\x85\xFD\xF8\x86\xF3\xF7\x97\xFE\xF8\x9E\xFB\xF8\x44\x57\x0E\x94\xF8\xF9\x96\xF2\xFA\xA7\xF5\xF9\x64\xF2\xEF\xE8\x05\xFA\xA0\xFA\xF9\x8F\xF6\xFA\xAB\xFD\xF9\xB0\xF1\xFA\xAA\xF1\xF7\xA8\xC9\x0E\xA9\xEA\x0E\xAE\xF4\xFB\x99\xFF\xFB", - "\xA9\xF2\xFB\xB8\xFE\xFB\xC1\xFF\xFA\xC0\xF3\xFB\x9C\xFD\xD3\xEB\x0D\xFB\xC9\xFB\xF9\xCE\xF1\xFB\xC6\xF5\xFC\xC4\xF8\xFC\xCF\xF6\xFB\x83\x2C\x0E\xCC\xF5\xFD\xB5\xFB\xFD\xC7\xF3\xFC\xCD\xF0\xFD\xD3\xFE\xFD\xDA\xFD\xFD\x75\xFD\x0E\xD9\xF0\xFE\xDF\xF6\xFD\xD1\xF4\xFD\xE8\xF3\xFE\x0C\x1E\x0E\xE7\xFA\xFE\xE1\xF5\xF7\xA8\xFC\xFE\xF2\xF9\xFE\xDC\xF2\xFD\xF8\xF4\xFE\x9F\xF3\xFF\xFD\xF1\x18\xEF\x01\xFE\x79\x7E\xFB\x73\x00\xE2\x7D\xFB\x67\x80\x38\x60\x1E\x02\x80\xFE\x75\xFF\x06\x83\xFD\x6E\x7F\x04\x84\x01\xB7\x7C\xFA\x73\x01\x97\x2D\x3C\x0B\x80\x96\x7A\x1E\x18\x80\xF9\x33\x0F\x1B\x82\x03\x85\x80\x14\x82\xF8\x61\x81\xF5\x7F\x01\x92\x82\x08\x9F\x7F\x10\x85\x04\xBA\x7F\x14\x83\x02\xFE\x7D\x03\x8D\x81\x6E\x3C\x1E\x1E\x81\xBA\x75\x0F\x33\x83\x07\x56\x07\x36\x87\x05\xA8\x80\x04\x80\x02\xBB\x83\x03\x9C\x81\x26\x81\x7D\x37\x07\x1C\x85\x01\xBA\x82\x11\x85\x82\x48\x87\x04\x87\x82\x25\x89\x04\xA4\x80\x0C\x84\x3D\xF8\x04\x08\x8C\x83\x29\x8E\x04\xBE\x81\x0F\x8B\x82\x55\x80\x0B\xAE\x81\x26\x8B\x05\xD4\x81\x17\x99\x82\x5C\x83\xFF\x4F", - "\x37\x7C\x07\xB9\x7A\x06\x14\x80\x83\x5E\x82\x0C\x91\x81\x15\x80\x04\xEC\x83\x0F\x8F\x83\x57\x81\x0C\xAC\x80\x2B\x81\x04\xDF\x82\x1D\x8A\x83\x2A\x83\x0D\xBA\x83\x3C\x8C\x07\x9A\x5F\x3E\x07\x83\x77\x83\x0E\x81\x66\x7E\x00\x08\xF8\x83\x13\x8D\x83\x7B\x87\x10\xB0\x82\x20\x5D\x0F\x05\x86\x20\x92\x83\xA6\x3E\x1F\x22\x68\x47\x88\x08\xFD\x80\x1D\x8E\x83\x71\x81\x0D\xA4\x3C\x00\x06\x01\x40\x09\x26\x88\x83\xA0\x87\x30\x01\x01\x4E\x84\xB6\x6E\x16\x00\x04\x85\x68\x5D\x0E\x86\x85\x4B\x89\x08\xAC\x86\x25\x9A\x82\x7D\x13\x00\x28\x84\xB6\x53\x99\x04\x03\x2C\x90\x5B\xAA\x87\x11\x9A\x85\x4A\x8A\x08\x9F\x85\x20\x9C\x85\xAE\x85\x17\xB9\x84\x60\x80\x0B\x93\x0D\x01\x17\x85\x74\x5B\x18\x8B\x84\x4C\x8A\x0C\xBE\x87\x2A\x85\x86\xC4\x80\x12\x8B\x87\x56\x80\x0D\xD3\x87\x2B\x92\x86\xCE\x82\x17\xA8\x64\x03\x08\x0C\x82\x5C\x36\x8D\x86\xE0\x80\x8B\x07\x01\x6E\x89\x0D\xD1\x87\x2E\x96\x86\xC2\x84\x19\xAA\x86\x83\x08\x00\x64\x85\x38\x94\x86\xDF\x83\x6F\x6E\x86\x77\x1A\x00\x48\x86\xDE\x50\x87\xE7\x85\x1C\xA8\x87\x60\x8C\x0F\xBB\x74\x03\x16\x87", - "\xFA\x81\x20\xBC\x7E\x07\x03\x0F\xCF\x17\x03\x00\x88\xEF\x87\x1A\xB9\x87\x84\x89\x0E\xF8\x85\x15\x91\x00\x08\x8B\x1D\x8A\x89\x50\x81\x18\x13\x01\x41\x9E\x18\x14\x07\x22\x8D\x89\x89\x8F\x0B\xFB\x85\x35\x82\x88\x4D\x6D\x02\x1A\x88\xFA\x46\x01\x23\x8B\x47\x8C\x88\xFD\x81\x1E\x8E\x89\x8E\x80\x12\xAB\x8B\x33\x8A\x89\x1C\x8F\x25\x84\x33\x0B\x06\x12\xB0\x8B\x46\x97\x89\x29\x8B\x21\x92\x88\x9C\x87\x12\xBB\x89\x4E\x85\x4C\x18\x05\x26\xBA\x88\x97\x8A\x0D\xAC\x88\x4A\x9D\x89\x54\x69\x03\x02\x8A\x8A\x85\x14\xB2\x88\x53\x86\x87\x4F\x8E\x23\xB6\x89\x9F\x86\x14\xBE\x88\x52\x91\x89\xBE\x4A\x03\x0B\x8B\xAA\x84\x14\xD0\x88\x57\x98\x8A\x5E\x8E\xE5\x5B\x01\xAD\x8E\x14\xDF\x88\x1C\x3C\x00\x64\x8E\x77\x5D\x01\xB4\x8E\x2A\x1E\x03\x48\x9F\x00\x23\x88\x04\x23\x89\x10\x03\x12\xA2\x03\x48\x83\x01\x23\x8C\x04\x23\x89\x12\x03\x12\xA6\x03\x48\x87\x01\x23\x88\x05\x2C\x8A\xA9\x8E\x73\x29\x03\x60\x99\x1A\x2A\x07\x30\x87\x8B\xA9\x87\x15\x9A\x5F\x0A\x0A\x8C\xED\x3C\x05\x10\x8D\xAE\x84\x18\xD1\x89\x4B\x80\x8B\x95\x8E\x2C\x94\x8B\xB2\x8C\x19\xCD", - "\x89\xCC\x6D\x01\x93\x88\x33\x97\x8C\x9E\x8C\x18\xA5\x8F\x50\x82\x8D\x8B\x8F\x34\x9A\x5C\x17\x01\x1A\xA4\x8E\x6A\x9B\x8C\x9E\x89\x2C\xB1\x8D\xCC\x8D\x19\xB2\x8E\x6D\x94\x8D\xB3\x8B\x34\xB0\x8D\xDB\x8A\x1B\xA9\x0F\x0B\x0D\x8D\xBB\x88\x37\xBC\x8D\xD4\x86\x19\xC4\x8E\x66\x8D\x8C\xC1\x8D\x37\xA6\x8D\xE2\x86\x15\xCB\x8F\x71\x8E\x8E\xB5\x8A\x38\x92\x8E\xE5\x8F\x1A\x9B\x28\x0C\x00\x8E\xC8\x89\x3B\x95\x67\x18\x08\x1D\x91\x0E\x0C\x1D\x8E\xD5\x88\x3A\xB9\x8C\xE3\x81\x1D\xD4\x8F\xEC\x33\x01\xE0\x8C\x39\x94\x8C\x5F\x64\x03\x69\x8F\x61\x15\x01\xEE\x8D\x3C\xA4\x8F\xF1\x8D\x1C\xE1\x8E\x7D\x85\x4C\x36\x01\x3E\xA4\x3D\x1B\x0A\x1F\xC3\x8D\x7D\x8A\x8F\xA8\x8F\x3F\x8F\x8F\xFB\x83\x20\x80\x92\x6B\x86\x90\xC9\x88\x22\x38\x01\xFE\x83\x1D\xF3\x8E\x7F\x8B\x8F\x0E\x95\x41\x82\x90\xF9\x83\x21\xF6\x69\x0E\x08\x86\x48\x71\x42\xA6\x8F\x02\x9C\x21\x94\x90\x84\x95\x90\x0F\x91\x40\x9F\x91\x11\x92\x22\xA5\x93\x81\x9D\x90\xF4\x8C\x44\xAC\x37\x1E\x0C\x20\x9B\x92\x87\x86\x91\x09\x90\x44\x92\x90\x15\x91\x23\xB4\x92\x76\x84\x90\x3D\x6E\x07\x2D\x90", - "\x0D\x9C\x23\xB2\x92\x8B\x89\x91\x30\x97\x46\x88\x90\x21\x98\x22\xA1\x93\x89\x9E\x55\x3F\x03\x47\xBE\x91\x1E\x96\x23\xE2\x8E\x91\x95\x91\x41\x96\x49\x9B\x08\x20\x0A\x24\xCD\x90\x8E\x80\x92\x47\x90\x4B\xA6\x5D\x20\x05\x25\xD1\x93\x95\x8F\x92\x44\x97\x45\x99\x92\x30\x92\x25\xBF\x90\x99\x9F\x92\x6D\x22\x08\x1D\x93\x31\x93\x23\xDE\x93\x90\x85\x93\x4C\x96\x4D\x85\x93\x36\x9A\xD7\x43\x03\x9A\x90\x92\x6C\x96\x4C\xB4\x92\x3C\x9C\x27\xE1\x91\xA5\x04\x02\x77\x96\x4F\xA7\x93\x37\x98\x26\xFA\x92\xA1\x91\x93\x79\x90\x51\xBD\x92\x38\x9F\x6C\x45\x01\xA0\x8C\x94\x56\x94\x50\x92\x95\x39\x97\x28\xCB\x92\xA5\x91\x94\x94\x92\x51\x82\x94\xAE\x16\x04\x0F\x95\xA1\x9A\x94\x90\x90\x46\x87\x02\x4F\x93\x29\xE2\x93\xA2\x9F\x94\x97\x92\x4E\xA6\x95\x4D\x95\x29\x98\x97\xAA\x81\x95\xB7\x48\x09\x24\x95\x4C\x99\x2A\x89\x95\xAD\x87\x95\xA5\x92\x4B\xAC\x94\x50\x9B\x4E\x49\x03\xAC\x8F\x95\xA8\x96\x55\xBA\x94\x58\x98\x2B\xB4\x96\xB0\x83\x94\x9B\x62\x09\x3F\x95\x61\x91\x2C\xAA\x94\xB3\x99\x95\xC8\x90\x58\xA8\x65\x25\x0B\x2C\xD1\x97\xB3\x86\x96\xCE", - "\x96\x5A\x9A\x97\x3D\x9B\x2B\xB7\x95\xB7\x87\x96\xDC\x94\x58\x9F\x96\x8F\x1C\x04\x40\x8D\x13\x03\x89\x4E\x05\x5A\xA1\x97\x66\x96\x2B\xE0\x95\xAB\x99\x96\xEB\x90\x5A\xB1\x96\x6C\x98\x13\xCF\x02\xBA\x8F\x97\xED\x90\x5E\xB8\x97\x62\x92\x2D\xF4\x94\xBF\x97\x96\xFD\x91\x60\x80\x99\x81\x9B\x2D\xFB\x97\xB8\x9C\x30\x50\x07\x5E\xBC\x95\x2A\x81\x05\x0A\x9A\xB7\x82\x97\x10\x9C\x5D\xBF\x97\x82\x9B\x30\xFE\x94\x72\x92\x02\x0E\x9E\x5D\x95\x98\x81\x94\x31\x8F\x9A\xC4\x87\x98\x13\x9B\x5E\x9C\x98\x91\x94\x30\xA4\x99\xC7\x9A\x98\x1E\x9E\x5B\x13\x03\x8C\x9A\x2F\x9B\x99\xC9\x86\x98\x11\x9A\x5E\xB0\x99\x8F\x92\xED\x54\x00\x70\x95\x02\x23\x8E\x0A\x2C\x99\x7C\x9C\x33\xA1\x9B\xCC\x92\x99\x2E\x9F\x64\xAD\x99\x94\x96\x31\xB1\x99\xD1\x94\x99\x48\x98\x68\x84\x9B\x91\x9F\x33\xC7\x98\x4C\x37\x02\x3B\x9E\x67\xBC\x7E\x2C\x01\x35\xCD\x31\x16\x17\x93\x5A\x03\x24\x9B\x03\x91\x8C\x05\x23\x89\x17\x03\x89\x5E\x03\x24\x9F\x03\x91\x80\x06\x23\x89\x18\x03\x89\x62\x03\x24\xA3\x03\x91\x84\x06\x55\x9A\xD1\x9D\x13\x65\x01\x6A\xA6\x02\xB7\x99\x34\xCE\x9A", - "\xDD\x9D\x13\x67\x04\x6E\x8A\x9A\xCC\x48\x06\x7A\x9B\xD9\x29\x03\x18\x95\x69\x8C\x9B\xA0\x96\x32\x85\x9E\xE0\x8F\x99\xE0\x15\x0D\x23\x88\x37\x0E\x37\xAB\x87\x1B\x0D\x9C\x93\x08\x0E\x00\x8F\x38\x00\x1C\xF2\x00\xE4\x82\x9A\x50\x1B\x0E\x23\x88\x3A\x03\x12\xF5\x03\x48\x96\x03\x23\x8F\x0E\x23\x88\x3C\x00\x1C\xF9\x03\x48\x9A\x03\xC8\x82\x7A\x58\x23\x3E\x01\x11\x86\x0B\x1F\x0D\x9D\x03\x09\x10\x23\x88\x41\x03\x12\x83\x07\x9D\x84\x04\x23\x8D\x10\x17\x9C\xC3\x90\xA4\x06\x04\xEC\x82\x08\x88\x07\x77\xB6\x7A\x45\x01\x35\x8B\x07\x48\x8C\x04\x23\x8D\x11\x23\x88\x47\x03\x12\x8F\x07\x48\x90\x04\x23\x89\x12\x3B\x9D\xC3\x90\x0C\x92\x05\xE0\x84\x9C\xD4\x9C\x77\x8B\x9A\xC4\x9B\x3D\x98\x9C\x00\x16\x04\xD3\x98\x7B\xA2\x9F\xEE\x9A\x3D\xA8\x9A\xF9\x83\x9A\xE7\x9D\x67\xA0\x99\xE9\x17\x09\x61\x9C\xF9\x99\x9E\xF0\x9B\x7C\xA9\x9E\xA9\x9F\x3E\xF2\x9C\xFA\x97\x9F\xEA\x9F\x6D\x9C\x9F\xF9\x9B\x3E\x9A\x14\x26\x0E\x9F\xFC\x9A\x7F\x9E\x9F\xFE\x95\x37\x83\x9D\xFD\x87\xA0\x01\xA5\x80\xBB\x9E\xFC\x94\x3F\x89\xA3\xDE\x8C\xA0\x04\xA5\x0A\x99\x04\x00", - "\xA0\x41\xD5\x66\x26\x14\xA0\x1C\x33\x13\x37\x92\x4E\x03\x12\x9D\x07\x48\x9E\x04\x23\x8F\x13\x23\x88\x50\x03\x12\xA1\x07\x48\x82\x05\x23\x8B\x14\x23\x88\x52\x03\x12\xA5\x07\x48\x86\x05\x18\xA5\x81\x99\x11\x53\x01\x35\xA8\x05\x0C\xB1\xA0\x77\x9B\x81\xA2\x11\x54\x07\x43\x82\xA0\x0E\x6A\x05\x3D\xA3\x9D\x2B\x05\x3B\x9C\x0A\x23\x89\x2B\x03\x89\xAE\x03\x24\xAF\x05\x91\x80\x0B\x23\x89\x2C\x03\x89\xB2\x03\x24\xB3\x05\x91\x84\x0B\x23\x89\x2D\x03\x89\xB6\x01\x88\x8F\xA0\x11\x17\x0B\x51\x98\x2E\x1A\xA2\x39\xA3\x80\xBE\xA0\x8A\x09\x0B\x60\xA1\xF2\x1A\x05\x66\xA2\x87\xB2\xA1\xFC\x9A\x40\xE2\xA1\x1B\xA5\x9F\x15\xA7\x8D\xB1\x9F\x01\x1B\x0B\x69\xA2\x1B\xBB\xA2\x6B\xA1\x8F\xB8\xA0\x03\xAE\x40\xFE\x94\x2F\x16\xA3\x70\xA4\x8D\xB8\xA3\x3D\xAA\x46\x84\xA7\x1D\xA1\xA3\x1B\x45\x17\x00\xA5\x39\xAD\x47\xFC\xA1\x1C\xA3\xA4\x63\xA6\x7E\x82\xA4\x44\xA4\x11\x3E\x07\x22\xB2\xA4\x7A\xA1\x92\x88\xA1\x47\xA4\x49\x98\xA6\x21\xA1\xA4\x97\x2F\x17\x02\x9F\x4F\xAD\x97\x41\x07\x28\xBE\x28\xC3\x07\x94\xB5\x57\x62\x01\x35\xC6\x07\x25\xB3\x4C\xC7\x03", - "\x24\x88\x07\x91\x89\x0C\x23\x8A\x32\x03\x89\xCB\x02\x78\x8D\x07\x91\x8E\x0C\x57\x9C\x43\x12\x06\xA9\x9F\x43\x15\x07\x57\xA9\x6C\x56\x04\x31\xBC\xA4\x8E\xA3\x92\x89\xA7\x4C\xA2\x47\x9E\xA6\x26\xAD\xA4\xF2\x27\x1A\x07\xA6\x65\xA5\x48\xCF\xA4\x32\xB5\xA6\xCD\xA3\x93\x94\xA7\xBF\x48\x0D\x53\xA4\x33\xB0\xA4\xD9\xA0\x9A\x87\xA5\x65\xA4\x4A\xCE\xA4\x91\x39\x06\xDE\xA5\x9C\x9A\xA7\x6F\xAD\x49\xEB\xA6\x3A\xA2\xA7\xA0\xA3\x7A\x1A\x07\x74\xA6\x4D\xDB\xA5\x3C\xB5\xA7\xEC\xA4\x9C\xB8\xA7\x77\xA6\x45\x5B\x04\x3D\xA1\xA7\xD7\xA3\x9C\x98\xA6\x70\xA4\x50\xED\xA4\x3C\xA0\x2A\xDC\x07\x9F\x85\xA8\x7D\xA0\x50\xF6\xA4\x23\xA1\xA8\xF7\xA5\xA1\xB1\x23\x6E\x0A\x50\x86\xA8\x44\xAF\xA8\x0E\xAE\x9C\x8B\xA9\x81\xA6\x51\xF0\x22\x37\x15\xA8\x0C\xAB\xA3\x82\xA9\x91\xA1\x51\xA2\xA9\x49\xBD\xA8\x97\x2F\x1B\x20\xA8\x8E\xA1\x52\xA8\xA8\x3F\xB9\xA8\xEE\xA3\x9F\xB2\xA8\xD8\x10\x0E\x2B\xA8\x49\xB8\xA8\xF9\xA4\xA5\xBA\xA9\x9B\xAA\x51\xAE\xAA\xF5\x01\x07\x36\xAF\xA4\xAD\xA9\xA1\xAB\x53\xC2\xA9\x51\xB8\xA9\x2F\xA9\x6A\x22\x07\xA0\xA8\x54\xB3\xAA\x49", - "\xAD\xAA\x12\xA9\xA9\x92\xAB\xA9\x83\x0E\x4C\xA9\x4F\xA4\xAA\x3C\xA9\xA6\x91\xAA\xA7\xAE\x53\xDB\xAA\x57\xAF\xAA\x79\x24\x1C\x37\x93\x72\x0A\x4A\xE0\xAB\x64\x47\x07\x65\xAE\xA9\x29\x07\xB4\xAE\xAB\x6B\x05\xD4\x8C\x07\x56\xAD\xFD\x2D\x07\x91\x8E\x0E\x23\x8B\x3B\x03\x89\xF0\x03\x24\xB1\x06\xE1\x93\x0F\x23\x88\x3D\x1E\xA5\x06\x08\x1F\x01\xA6\xE4\x0B\x0F\x71\xAA\x43\x3C\x07\x86\xAF\xA2\x97\xAB\xA3\xAB\x58\xD9\xAB\x41\xAD\xAC\x46\xAE\xB1\x8A\xAC\xAD\xA5\x18\x7D\x07\x9D\x9E\x07\x6C\xAC\xB1\x93\x4C\x00\x07\x01\x60\x58\x50\x22\x00\x9D\xAC\x21\x37\x87\x9B\x54\x00\x21\xAD\x2A\x98\x22\x05\x06\xB4\xB4\x84\x1A\x96\x00\x2A\xAC\x2E\x8C\x08\x07\x06\xB5\x89\x86\x86\x08\x00\x32\xAD\xC9\x09\x00\xB6\xAC\x22\x0A\x00\xD9\xA3\x5A\x82\x08\x03\x19\xAD\x10\x0D\x01\x32\xAD\x0C\x9C\x10\x11\x02\x6C\xAA\x9D\x01\x14\x02\x00\xAE\xCB\x75\x01\x4B\xAE\xD2\x76\x00\xCE\xAB\xB2\x8F\xAC\xCA\xAD\x55\xE6\xAB\x74\xB7\xAE\xD2\xAD\xEA\x57\x01\xE8\xA0\x53\xD8\xAD\x77\xB9\xAE\xDF\xA9\xBC\xB9\xA8\xB4\x78\x01\x5C\xAF\x78\xB1\xAC\xE8\xA8\xAA\x96\xAE\xF0\xA7", - "\x5E\xEA\xAE\x66\x99\x00\xE6\xAB\xAA\x9F\xAB\xEA\xA4\x5F\xD8\xA9\x7A\xB0\xAC\xEE\xAE\x9B\x1A\x01\xF8\xAC\x55\xF6\xAD\x7E\xBA\xAC\xDE\xAD\xBD\xB8\xAF\x01\xBD\xD4\x1B\x00\x7F\xB3\xAF\xFE\xAC\xC0\x81\xB0\xF9\xAB\x5E\xE2\xAD\xDC\x3C\x00\x07\xB5\xC1\x82\xB0\xEA\xA9\x60\x94\xB0\x80\xAC\xAF\x0C\xB0\xA5\x9D\x01\x08\xBE\x54\x1E\x00\x87\xB5\xB0\x0B\xB5\xBF\x97\xB0\x07\xB2\x62\x92\xAE\x07\x5F\x00\x1F\xB6\x37\x60\x01\x14\xB1\x57\x21\x00\x8B\xB7\xAF\x16\xB6\xC4\x93\xB1\x10\xB8\x60\xA3\xB1\xBB\x22\x01\x2F\xB7\xBF\xB2\xB1\x0C\xB0\x62\x98\xB1\x89\xB0\xB1\x01\x13\x04\x39\xB0\x05\xBE\x63\xB5\xB3\x8E\xBF\xB1\x3A\xB0\xC8\x85\xB2\x09\xBC\x63\x93\x0C\x09\x03\xB2\x31\xB2\xC9\xA4\xB0\x23\xB2\x65\xB3\xB3\x92\xAE\x2A\x25\x00\xCA\xB4\xB1\x2A\x86\x02\x5A\xB3\x40\x07\x01\x5E\xB3\xCA\x8C\xB2\x24\xB4\x64\xE2\xB1\x7D\xB6\xB1\xB1\x10\x05\x21\xB2\x2B\xB6\x66\xBD\xB1\x9B\xA8\xB3\x64\xB1\xCA\xB9\x35\x14\x0B\x66\xCD\xB0\x30\x8A\x01\x6B\xB3\x05\x35\xB3\x38\xBB\x65\xE7\xB3\x91\xB4\xB2\x49\xB5\x2F\x6C\x01\x3D\xB0\x68\xE5\xB0\x9B\xA7\xB4\x76\xB5\xCA", - "\x89\xB5\x40\xB6\x68\x8B\xB5\xA3\xBC\xB3\x57\xB6\xCD\x88\xB4\x5E\x5D\x02\x04\xB7\x98\xA5\xB4\x72\xB7\xD1\x98\xB5\x3E\xB2\x69\x8E\xB5\xB7\x4E\x01\x96\xB6\xCF\xA0\xA5\x17\x01\x6A\x81\x0C\x0C\x1C\xAD\x8C\xB5\xFD\x32\x00\x54\xB4\x54\x34\x00\xAB\xBD\x56\x36\x05\xD4\x95\x15\x1B\x02\x6B\xC0\x84\x0E\x06\xAF\x39\x06\xBC\xBA\x00\xF3\xAB\x03\x66\xAC\x0F\x0F\xB5\x06\x0E\x07\x26\xAF\x1F\x03\x5C\x94\x0B\x10\x07\xAE\x14\x0E\x08\x26\xAF\x23\x05\x6B\xB8\x60\x12\x0D\xB6\xB9\x51\x09\x10\xB6\x4D\xB8\x47\xCA\x03\xB4\xAC\x08\x4B\x00\xD8\x91\xB4\xDF\x4D\x04\x5A\xB4\x87\x2F\x02\xDE\xB6\x74\x51\x03\x6B\xB1\x20\x52\x00\xB9\xB5\x7A\x53\x06\xBC\x94\x02\xF3\xA5\x05\x66\xAE\x15\x06\xAF\x57\x01\xDC\x99\x02\xF3\xAA\x05\x45\xB4\x44\x1E\x02\xC8\xB0\x22\x21\x02\xF3\xA2\x06\x67\xB6\xE6\x43\x03\xFE\xB6\x74\x64\x03\x80\xBE\x69\xB4\x91\x19\x01\xB8\x66\x01\xDC\x85\xB9\x05\x48\x06\x0A\xBA\x47\x2A\x03\x0E\xBD\x5E\x6C\x02\x82\xB1\x19\x6D\x00\xC5\xB8\x74\x6E\x06\xBC\xAF\x02\xF3\xA0\x07\x66\xAD\x1C\x06\xAF\x72\x01\xDC\xB4\x02\xF3\xA5\x07\x76\xB4\x43\x19", - "\x03\xF9\xB3\x40\x3C\x03\x8B\xBB\xAF\x7D\x00\xCB\xA2\xB5\x38\xAE\x0F\x2F\xB9\x4E\xB0\x69\xEF\xB3\x9F\xB7\xB4\x38\xB8\xE6\x94\xB6\x9D\xB9\x69\xBD\xB8\xA7\xB0\xB3\x44\x37\x0F\x26\xAE\x40\x03\x73\xC0\xB9\xCE\xB4\xB9\x9B\xB3\xDB\xB7\xB8\x9E\xBF\x73\xCB\xB8\xD2\xA7\xBA\x46\xBC\xE9\x8A\xBA\x45\xB5\x73\x87\xB5\x20\x05\xBA\x6B\x32\x10\x18\xBA\xAA\xB9\x74\xB6\xB8\xD7\xB0\xBA\x4E\xB9\xEA\x8F\xBA\xA9\xBE\x75\xA9\xB5\xD3\xBF\xBA\x64\xBB\xD2\xB2\x47\x41\x0B\x75\xC0\x28\x21\x0D\xBB\x3B\xBB\xEC\xB2\xBA\xB1\xB4\x77\xE1\xBA\xDD\xB5\xB2\x0E\x05\x14\x1E\xAD\x7B\xB7\x1A\x48\xAE\x65\x19\x08\xBD\xA8\x00\x03\x03\xD3\x01\x78\x83\xBE\x54\x05\xBC\x84\xBE\xD8\x89\xBC\x88\x06\x78\xF1\x08\xE2\xA7\xBC\x8A\xB8\xF2\x8C\xBD\xC5\xBC\x10\x0D\xBC\x58\x0F\xBC\x8E\xBC\x22\x31\x00\xCA\xB6\x10\x28\x00\xE7\xA3\x08\x3F\x07\xF3\x82\x09\x24\x04\x2A\x19\x09\x02\x14\x08\x8B\x05\xF4\x96\x09\xD3\xB0\x11\x2D\x07\x69\x05\x00\xA7\x09\x23\x30\xBC\xA9\x09\x11\x07\x01\xEC\xB6\x08\x81\xBF\x08\x27\x0C\x04\x07\x7B\x92\x08\xEB\xAC\x08\x89\x07\xF5\xBD\xBC\x87\x06\x7B", - "\xB4\xBC\xEE\xB4\x08\x0B\x03\xF7\x83\xBE\x85\x0F\x7B\x86\x09\x06\x02\xBE\xC6\xBA\x22\x05\xBF\xB8\x00\x78\x94\x0A\x0F\x0A\xBE\xD1\xBE\x21\x0D\xBF\x81\x06\x07\x50\xBC\xF5\xB6\x08\xD3\xB8\x2C\x15\xBE\x88\x0B\x79\xD2\x08\xEF\xB9\xBE\xCC\xBC\x22\x22\x02\xEF\xB2\x7E\xE0\xBF\xF2\xA9\x08\x81\xBC\x09\x18\xBF\xEF\xBE\x7B\x94\x08\x24\x0C\xBF\x7F\xBE\xFD\xA8\xBE\xF8\xB4\x11\x1D\x03\xFC\xAD\xBF\xF5\xB8\x22\x3A\x01\xD3\x07\x5B\xA7\x0F\xF6\xA2\x08\x7F\x00\xFF\xA2\x0D\x8C\x05\x80\xD2\x0B\x01\xC0\x00\x09\xC2\x2A\x33\xBC\xFA\xB4\x7C\xEF\xBC\x42\x19\xBD\xFF\xB9\xFF\x81\xC0\xE0\xB4\x80\x94\x0B\x03\xC6\xBD\x14\x09\x02\xF1\x0B\x09\xC0\x80\x95\xC3\xFE\xB7\xC0\xC8\xB9\x03\xCB\xC1\xD5\xB4\x11\x4F\xBE\x54\x0D\xC0\x71\x0F\x01\xE2\xC0\xB0\x04\x82\x9A\xC2\x09\xD4\xC0\x0A\x09\xF0\x97\xBE\xF3\xB6\x81\xFF\x07\x03\xDD\xBE\x2F\xC6\x03\xC6\xC1\x10\xCA\x80\x94\x0D\xED\xBD\xC1\x81\xBD\xFC\xB1\x0B\xF3\xB8\x83\x89\x0B\x03\xCB\xBF\x41\xC0\x66\x03\xC2\x88\x03\x83\x96\x0D\x0D\xCB\xC1\xD2\xB8\x09\xD4\x08\xF9\xBC\x83\xA7\xC2\x0F\xD6\xBF\x1D\xC2\x0A\xCE", - "\xC0\x22\xC2\x81\xBD\xC1\xF8\xB6\xC1\x39\xC5\xFF\xAA\xC0\x23\xCC\x82\x82\xC1\x18\xD4\xAD\x53\xC1\x12\x45\xC3\x8C\x0C\x80\x94\x08\x13\xC0\x0B\x32\xC3\x0E\xF4\xC3\x2C\xCE\x85\x98\xC1\x17\xCD\xC2\x08\x0F\x01\xC1\xBF\x28\xC0\x87\xE3\xC0\x15\xDA\xC3\x7B\xC2\x21\x27\xC2\x2C\xCE\x10\x01\xBD\xF2\xBF\xC3\x25\xC1\xFD\xAF\x21\x37\xCC\x0E\xF1\xC2\xEB\x88\xC4\x89\xC0\x21\x0B\xC4\x36\xC2\x11\x3A\xC3\x1A\xD9\xC4\x92\xC4\x21\x00\xC3\xB8\x05\x32\x77\xC2\x65\x19\xC3\x65\xC6\x0B\xDB\xC4\x50\xCC\x7F\xE4\xBF\x27\xCC\xC5\x5F\xC0\x22\x10\xC2\x52\xC6\x87\x96\xC7\x40\x15\xC2\xA2\x0F\x0A\xDC\xC5\x1B\xC1\x89\xAD\xC4\x43\x1C\xC2\x4B\xC5\x07\xCF\xC1\xFB\xB4\x88\x95\xC6\x21\xD2\xC3\xA9\xC0\x10\xFF\x07\x55\xC0\x8B\x81\xBE\xFF\xB0\xC4\x68\xC6\x09\xD4\x09\x01\xC2\x79\x8C\x0A\x17\x1D\xBB\x5A\xC3\xF2\x95\xC6\x83\x06\x79\x96\x0C\xE6\xB7\xBC\x91\xB9\xF3\x9A\xC6\x71\xC5\x79\xA2\xBE\xE0\xA6\xC7\xDD\xC2\x34\x1F\xC6\x6F\xC1\x8E\xE0\xC6\x2B\xDB\xC6\x03\x0E\xF3\xB0\xC6\x81\x01\x7A\xF3\xC4\x00\x04\xBD\x53\x10\x04\xD0\x09\xD4\xB6\x8F\xD7\xC6\x54\x1E\xBB", - "\x8C\xC1\x0D\xE3\xC6\x77\xC5\x8E\xF6\xC5\x3A\xD4\x0C\xEB\xC2\x1D\xED\xC6\x76\xC3\x90\x8C\xC9\x41\xC4\xC7\xDC\xC0\x1D\xD2\xC8\x7B\xCA\x84\x84\xC9\xE7\xA6\xC7\xF5\xC0\x22\xC3\x08\x7C\xC0\x2A\x7A\xC4\x43\x1C\xC7\xB4\xC3\x23\x07\xC6\x83\x03\x06\x18\xC5\x26\xC5\x19\x8C\x0F\x01\xE5\xC9\x64\xCD\x8B\x9A\xC5\x36\xCC\x08\xBA\xB8\x1A\xC1\xC8\x69\xC0\x11\x03\xC5\x48\xC2\xC9\x78\xC4\x22\x2B\xC9\x11\xC6\x86\xAF\xCA\xCD\x0F\xC5\xAC\xC7\x01\xEE\xC1\x9B\xC8\x93\xA2\x0E\x4A\xC6\xC9\x89\xC4\x19\xEC\xC4\x4F\xC2\x93\xBB\xC5\x28\xC6\x08\xA3\xC0\x2C\x28\xC8\x5B\xC2\x10\x3B\xC8\x0D\xDD\xC9\x7D\xC2\xF3\x80\xCA\x50\xCF\x84\x94\xC5\x51\xDE\xC8\x24\xC8\x29\xFB\xC2\xA5\xC0\x8A\xF1\xBF\x56\xD9\xC4\xC3\xC6\x2B\xF8\xC8\xB0\xC3\x10\x56\xCA\x15\xD8\xCA\xCA\xC6\x19\xE7\xCB\x44\xCF\x80\xD4\xC4\x51\xC3\x08\x06\x04\x2A\xD0\xC0\xB1\xC4\x87\xA5\x19\x5E\xC3\xC9\xB7\xC4\x2F\xC7\xC3\xAC\xC0\x11\x31\xC9\x30\xDE\xC2\x82\xC2\x2D\xC0\x01\xBF\xC1\x83\xE4\xC0\x4F\xCA\xC5\x3E\xCB\x20\x0F\xC5\xC3\xCA\x8C\xC2\xCA\x62\xCC\xCC\x39\xCF\x10\xEC\xC9\x68\xCE\x92\x84", - "\xCC\x43\x1B\xC1\x94\xCD\x25\xF1\xC4\x51\xC7\x99\xFA\xC8\x2E\xD4\x0C\xBA\xC0\x16\xCB\xC7\xC8\xC2\x10\x15\xCA\x65\x06\xC5\x33\xC9\x10\xEA\xBF\xD2\xC0\x98\x88\xC2\x60\xDA\xBF\x71\xCB\x0B\xF3\xCB\x3D\xC9\x96\xC5\xC4\x5E\xC6\xCD\xB7\xCC\x0F\xF9\xCC\x88\x0F\x8C\xA1\xCC\x67\xC3\xCD\x06\x0E\x2E\xD2\xCA\x8A\x09\x9A\xED\xC0\x32\xCF\xCC\xCA\xC5\x64\x0D\xCF\x0D\xC7\x89\x9B\xCD\x6C\xCB\xCD\x9E\xCE\x20\x06\xCC\xB0\x00\x9B\xCE\xC8\x4D\xDC\xC0\xBE\xCA\x20\x13\xCE\xED\xBE\x98\xD7\xC8\x64\xD9\xCE\x92\xCB\x37\xF4\xC2\xCB\xC1\x9E\x80\x03\x78\xCF\xCA\x81\xCE\x3A\xDE\xCF\xCE\xC3\x9C\x9F\xCE\x7A\xCC\xCB\x02\x09\x2A\xD6\x0C\xE9\xC0\x9C\xF2\xCE\x6A\xC4\xCB\x99\xC1\x09\xF7\xCE\xE7\xC6\x10\x33\xC7\x72\xD0\x08\xEF\xCF\x3B\xD5\xCE\xE8\xC2\x9A\x80\xD1\x22\xC6\xCB\x4D\xCA\x35\xFD\xCD\xBB\xC2\x9E\xFD\xCC\x83\xC7\xCE\x0E\xD3\x0F\xF2\xCB\x08\xD0\x8B\xF5\xCA\x39\xDE\xC7\x71\x08\x20\xF3\xCF\x7F\x09\x90\x88\xCB\x42\xCA\xC8\x0D\xC8\x45\xCF\xC8\x8B\xC3\x10\x07\xCB\xF8\xAB\xD1\x0E\xC9\x22\xC6\xC9\x89\xCA\x91\x82\x0A\x8B\xC7\xBE\xEF\xC5\x46\xC0\x00", - "\x79\xCA\xA3\x99\xC8\x8B\xC3\xBD\xAA\xBC\x3A\xC3\x08\x90\xCF\xA3\x80\x00\x88\xC0\x0B\x22\xD2\x35\xE5\xD1\x17\xD2\xA3\xBA\xD3\x8D\xDD\xC4\x27\xD6\x44\xE9\xD0\x29\xD0\xA3\xAA\xD1\x93\xC5\xD2\x4F\xD5\x11\xD1\xD2\x26\xDD\xA2\xE6\xC6\x6B\xD6\xD2\xF1\xC0\x23\xE6\xC6\x8E\xCE\x26\x78\xCC\x00\x04\xD2\x31\xD3\x20\x07\xD2\xCB\x09\xA4\xCD\xC7\x96\xD8\xD1\x55\xD4\x4A\xD7\xD3\x34\xD6\xA3\xB4\xD0\x96\xD6\xD3\x74\xD7\x1C\xF3\xD1\x3D\xDA\xA3\xDF\xD2\x9C\xC1\xD3\xF6\xC6\x47\xF9\xD2\x32\xDE\x29\x66\xD0\x9A\xD9\xC5\x3D\xC1\x41\xE3\xCA\xD6\xC0\x00\x5B\xCF\x6B\xC2\xC6\x14\x0E\x26\xE6\xCE\x65\xC9\xA1\xF4\xC2\x23\xC3\xD0\x42\xD2\x20\x03\xCB\x49\xDD\xA0\x8C\xD4\x68\xDC\xCE\x90\xD0\x22\x3A\xCE\x44\xD7\x9E\xF5\xCE\x41\x1E\xD3\x19\x0D\x3B\xD2\xD1\xD9\xCE\x9F\xB0\xC5\xA5\xDC\xD2\x02\x08\x18\xE0\xD4\xC4\xC0\x86\xAD\xD4\x2B\xCF\xD5\x70\xD6\x20\x05\xCF\x59\xD5\x99\xD3\xC6\x62\xCD\xD3\x99\xD3\x2F\xF6\xD4\x50\xC5\x32\x40\xD4\x79\xDA\xCC\x17\xD7\x3A\xF8\xD4\x28\xD5\x98\x98\xD7\xB1\xC0\xCF\x14\xD0\x00\x06\xD6\xF8\xC6\x9B\xC3\xD5\x26\xCB\xD6\x5A", - "\xD0\x22\x13\xCC\x5E\xD2\x9A\xEC\xCD\xB4\xD3\xD6\x0A\xD1\x3E\xC9\xD7\x11\xD8\xAD\x82\xCA\x7D\xDC\xD0\x41\xCC\x22\x23\xD4\xCA\x05\xAC\x96\xD0\xA7\xD8\xD0\x8C\xD0\x55\xD6\x08\x55\xDD\xA1\xAC\xD7\xB7\xCE\xD7\x6F\xCD\x54\xE2\xCC\x08\xD6\x9C\xD7\xCF\x84\xC7\xD0\x0C\x08\x5C\xF2\xCC\x64\xDF\xAE\xCA\xD4\xA3\xDB\xD5\x8F\xD4\x56\xEE\xC3\xF6\xC1\x78\xE6\xD3\x69\xD2\xBD\x3D\xC5\x64\x0D\xD8\x02\xD2\xAE\x85\xD8\xB9\xCC\xD4\x8E\xD2\x34\x34\xD7\x74\xD5\x93\x8A\xCF\xC4\xC1\xD6\x0F\xDE\x22\x0A\xD4\x3A\xC5\xAE\xBE\xC7\x4F\xC8\xD7\x5C\xCD\x05\xDE\xD8\x7C\xD4\xAA\x94\xD6\xA7\xCE\xD6\xD4\xD0\x00\x2B\xD7\x3A\xCB\x77\x8D\xCC\xC1\xD9\xD7\x2E\xD8\x3D\xED\xCC\x98\xD1\xAE\x82\x0A\x81\xDB\xCF\x14\x0F\x63\xCF\xD7\x05\xD6\xB1\xFF\xCC\xA3\xD2\xD5\x09\xDD\x57\xD0\x08\x62\xC1\xAD\xC2\xD9\xCC\xC1\xD9\x12\x0B\x64\xC3\xCC\x53\xD3\x10\x08\xDA\xC6\xC1\xD5\x0C\x0A\x39\xC0\xDA\x4F\x85\x9B\xC2\xD7\xB8\xCA\xCD\x25\x1E\x1B\xA0\xD9\xE0\xCC\x8B\xC7\xCE\x1F\xDD\xD7\x23\xD1\x31\xED\xCE\xB1\xD3\xB4\x95\xD8\xCE\xDD\xD4\x3A\xD8\x00\x1B\xD7\xA4\xDD\xAD\xAA\xDB", - "\xDA\xCC\xD9\xA8\xC8\x2E\xFB\xD6\xEB\xBC\xB3\x83\xD8\x69\xD7\xDB\x5D\xD8\x6A\xCE\x08\xA9\xD8\x9B\xFB\xD9\x8E\xDC\xD6\xC7\xCD\x2B\xC0\xDC\x9B\xDF\x9C\xC5\xDA\xAB\xC7\xDA\x7D\xD8\x39\xC3\x08\xA6\xD0\xB0\xA7\xAD\x66\xCD\xDC\x6F\xD8\x5E\xF1\xDA\xAB\xD4\x19\x1B\xD9\xCA\xCB\xD8\x3A\xD3\x4D\xE2\x0C\x81\xD6\xA9\xEF\xD0\xB3\xD1\xD3\xB0\xD2\x4F\xCE\xD2\x3C\xD0\xA6\xF5\xD0\x9F\xD7\xD3\xAF\xD9\x4F\xD9\xD2\x73\xD7\xAA\xE6\xC4\x8F\xC5\xD2\x82\xD5\x75\xF7\xC7\x20\xDD\xB6\x82\x0B\xA1\xD9\xDB\x5E\xC4\x70\xC2\xCE\xC3\xD0\x93\x91\xDE\xDA\xDF\xDA\x8F\xD9\x6E\xF3\xDB\xAB\xDA\xB0\x8C\x0B\xA6\xD9\xDC\x06\xD9\x6E\xDF\xD4\xBA\xD9\xB8\xEA\xD4\xD9\xCA\xC4\xF1\xD6\x78\xF6\xD6\xC7\xD7\xAB\x90\xDC\xCA\xC8\xCB\xB5\xD0\x79\xDD\xDF\xCD\xDA\xBD\xA0\xDD\xE5\xC3\x08\x95\xD0\x15\xE2\xDE\x62\xD4\x11\x69\xDD\x79\xD0\xDE\x17\xD9\x6E\xD9\xD9\xCE\xD8\xB5\x86\x0A\xA4\xDB\xDA\xB0\xA8\x6F\xD0\xD8\x7D\xD6\xB6\xA9\xC3\xF7\xD4\xCB\x76\xD9\x5A\xEE\xDF\x9B\xDD\xB2\xF0\xD8\xD5\xC2\x08\xD3\xDC\x79\xCA\xDB\xBF\xD2\xC0\xFA\xDE\xC8\xDA\xDB\xFD\xDF\x70\xD4\xDE\x7F", - "\xDB\xBD\xF8\xDE\x41\x03\xE0\x98\xDD\x80\xDA\xDD\x03\xE0\x00\x48\xDA\x02\xF5\xDB\x4B\xDA\x31\xD8\xE0\xA2\xD0\xBF\xC6\xD8\xF9\xDF\xDF\xBC\xCE\x57\xED\xCE\xE2\xA7\xB9\xA4\xE2\x06\xF7\xCE\x25\x1C\x85\xE7\xC5\xF7\xDF\xC2\xF1\xDC\x07\xF3\xDF\xA9\xD5\x7E\xC3\x09\xFB\xD2\x1A\x31\xE2\x03\xF1\xDA\x10\xE7\x3A\xD7\xD4\x14\xEB\x9E\x81\xE3\xF9\xC2\x08\x32\xE6\x28\xF4\xE0\xE0\xD9\xB3\x9C\xE1\x02\xF4\xDF\xCD\xD8\x2A\xCA\xCD\x24\xE4\x19\x6A\xDC\xF7\xC0\xC5\x25\xD8\x05\xD2\xE1\x0F\xE5\xBD\xB2\xC7\x14\xFF\xE1\x83\xD9\x88\xE3\xD0\x7E\xD8\xB8\x94\xE1\x08\xEB\xE1\x60\xE2\x21\x02\xDF\xB2\xD2\xC4\xEA\xC0\x11\xE6\xD3\x5A\xDD\x87\xC5\xCB\x16\xEE\xB6\xB5\xE0\xD8\xD3\xE3\x33\xE4\x80\xCC\xE2\x03\xE4\xBC\xDA\xCD\xF9\xD0\xD6\x47\xE2\x24\xCE\xD9\xEB\xD9\x10\x59\xE0\x89\xDE\xDF\x68\xDB\x55\xD3\xC5\xF6\xC9\x92\xCB\xE3\xFE\xCD\xE2\x7D\xE3\x20\x0F\xE3\x1C\xE1\xC5\xDC\xBE\x62\xCD\xE4\x7A\xE7\x91\xFC\xE3\x08\xEC\x10\x72\xD6\x44\x1E\xDC\xE0\xDE\x8B\xCC\xE5\x34\xE9\x10\x6B\xE0\xF6\xD1\xDB\x1E\xE0\x8A\xCB\xE0\x83\x04\xB9\x96\xE3\x57\xD4\xD8\xD5\xD3", - "\x7D\xD7\xD7\x83\xDF\xC7\xC9\xCC\x21\xE8\x08\xA6\xE5\x90\xD8\xD9\x5A\xEB\xC3\xB7\xE4\x76\xDC\xE0\xCB\xDA\x95\xE0\xE0\xE7\xDE\xCB\x86\xE4\x53\xC9\xE4\xF5\xD2\x54\xC5\xE7\xEC\xDF\xC6\xB0\xE4\x00\x1F\xD9\x76\xE1\x79\xDC\xE1\x54\xE4\xC9\xAB\xE7\xE4\xCB\xE6\x27\xE0\x99\xDC\xD9\xAC\xDE\xCB\xB9\xE4\x7D\xD1\xE4\x02\x08\x87\xF3\xD6\x1D\xE2\x10\x3C\xE3\x1E\xFB\xE0\xE0\xE2\x6E\xFC\xE4\x4D\xD8\xCD\xCE\xE3\x3A\xF2\xD9\xED\xE1\x9D\xDE\xE4\x87\x00\xCA\x80\xE2\x28\xF2\xE5\x49\xCE\x7B\xDA\xE7\xCF\xDC\x10\x2D\xE5\x34\xE3\xDF\x1C\xE4\x73\xD5\xE7\x61\xE6\xCB\xF9\xC6\x33\xF8\x00\xDD\xE2\x8C\xCA\xD2\x8A\x02\xCE\x9F\xE4\x39\xE0\x00\xE6\xE2\x93\xE8\xE6\x4E\xE7\xB2\xFB\xE5\x28\xE4\xE6\xD6\xD1\x9F\xD2\xDF\x77\xE3\xB3\x8F\xE0\xFF\xCD\xE3\x5B\xE2\x98\xDD\xE2\x86\x00\xCD\xE7\xE5\xF4\xD3\xE6\xEF\xE6\x9F\xE6\xE8\x1B\xE9\xCE\x82\xEB\x38\xF5\xE4\x02\x09\x8E\xEB\xE8\xD5\xCE\xCD\xBF\xE5\x3A\xED\xE8\xF4\xE7\xA1\xD1\xE8\x8F\xE0\xC9\x94\xE9\x7A\xCD\xE6\xC1\xD7\x79\xFF\xE6\x2C\xEF\xB2\xC0\xE9\xEF\xD0\xE7\x19\xEB\x51\xF1\xDB\x79\xEA\x10\x75\xE5\x0A", - "\xF7\xE7\x57\xE3\x96\xE8\xE5\x94\xE1\xCF\xBE\xEA\x40\x0E\xE9\x0E\xE8\xA6\xC0\x00\x99\xE9\xBA\xA2\xDC\x65\x04\xDD\xA9\xDB\x76\xE6\xD9\x2E\xD1\xBB\xBA\xDE\x58\xFA\xE2\xA8\xD9\x57\xE4\xEB\xD5\xD5\xD6\xFF\xD2\xEB\xCC\xEB\x7D\xD6\x76\xE2\xD2\x7B\xC4\xA8\xAD\x16\xA1\xCA\xCC\x6C\xD9\x66\xEE\xCB\xA1\xE7\x92\x94\x09\x5E\xFD\xD9\x00\x03\xAF\xF3\xE8\x69\xE7\xD3\xEF\xE7\x4E\xF2\x08\x61\xDA\x2F\xC2\xEC\x89\xE7\xD2\xE9\xE5\x30\xE3\xE8\x23\xEE\xF9\xB8\xEA\xC5\xE5\xD5\xA0\xEB\xB9\xD6\xE8\xF6\xE4\x81\xC1\xE5\xBF\xEE\xB7\xE1\xC9\x52\xE4\xD9\xCC\xE0\xB3\xCF\xEA\x92\xE3\xD9\xDD\xDB\x62\xFC\xE9\x9B\xE6\xB2\xC6\x08\x6A\xEF\xD2\xD6\xE6\x40\x0A\xE9\x34\xDD\x14\xB4\xE3\xAA\xC5\xD9\xE3\xE2\x1B\xE2\xED\x45\xE6\x7C\xE5\xE0\x58\xC5\xD3\xC6\xE4\x43\xE6\xEC\xB5\xEB\xA1\xDA\xD7\x77\xE2\xD4\x83\xEC\x40\xE9\xE7\x93\xE5\xB5\xC4\xE8\x4B\xEF\xD9\xD3\xDA\x3C\xEF\xE7\x25\xEC\xB1\xEC\xE8\xAB\xED\xC1\xD4\xE9\x73\xE5\xDC\xD4\xE8\xAB\xF9\xE8\xAD\xEC\xD5\xA8\xEF\x71\xDD\xED\xBB\xE6\xA8\xF1\xD9\xC3\xE1\xC6\x9F\xEA\x6D\xE3\xEE\xE2\xE8\xB0\xC5\xEE\xE9\xE6", - "\xC2\xEE\xE5\x7A\xFD\xEC\xCC\xE8\x9F\xCA\xEA\x0E\xEC\xD4\x89\x0A\x53\xF9\xED\xA4\xEF\xBA\xC3\xDE\xEA\xEC\xDA\xD9\xEA\x6B\xE0\x00\xB0\xEE\xBB\xCD\xED\xEC\xEF\xCE\xDD\xEC\x10\xE1\xDE\x0A\xEE\x4D\xCD\xD7\xF7\xE2\xB9\xE5\xE5\x70\xEA\xF0\x0C\x0F\xB1\xCA\xEF\xC8\xE3\x10\x6B\xEE\x80\xF3\xEE\xAA\xEA\x92\xDC\xE9\x07\xFB\x94\xDA\xC8\x83\xEA\xDC\xF2\xE8\xB4\xD3\xEB\x0F\xF1\xBE\xD1\xEA\x46\xE1\xE8\x05\xF7\x43\xD8\xC7\xB8\xD7\xD6\x87\xE7\x94\xC1\xEB\xAC\xDE\xAD\xEA\xDC\xD8\xD0\xD7\xB4\xF2\x8D\xF2\xDD\x5E\xD2\xAE\xC1\xD5\x31\xDC\xBB\xB1\xDB\xEF\xC9\xDD\x11\x03\xC5\xCA\xC6\xB0\xE6\x11\x44\xF2\x44\x06\xF2\x0E\x08\xC9\xCA\x08\x25\xF9\x10\x4C\xF0\x42\x0E\xF2\xFF\x00\xCA\xD0\xF3\xC0\xB5\x06\x66\xC5\x90\xFF\xC7\x3D\xC2\xCA\xD9\xF3\x2D\xFE\x85\xDA\xF1\x97\xFC\xF2\x43\xF4\x51\xD5\xF2\x7B\xC7\xE5\xA1\xD0\x98\xE2\xCD\x5E\xF1\xCC\xDF\xF3\x35\xFA\xE6\xED\xF0\x9A\xE7\xF3\xD4\xED\x0B\x16\xF2\x21\xFF\xE6\xEC\xF1\x9D\xEE\xF3\xC7\xC9\xCD\xF7\xF3\x3D\xF9\xE7\xF0\xF1\x86\xE2\x08\x41\x03\xCE\xD8\xF2\x3B\xFD\xE7\x84\xF7\x75\xDA\xF3\x85\xF0\xCF", - "\xC7\xF4\x3F\xF3\xA2\xD3\xF0\x45\x07\x09\x3A\xD5\xCC\xC8\xD2\x46\xFA\x9A\x88\xF7\xA2\xE6\xF4\x8D\xF4\xD2\xF0\xC4\x4B\xF9\xE9\x98\xF6\x70\xE5\xAE\x74\xF1\xD1\xFC\xF3\x4B\xFA\xE8\x9D\xF5\xA9\xF5\xF4\x9A\xF4\x15\xCE\xF4\x88\x03\xE6\x91\xF5\xA8\xE4\xF5\xA3\xF6\xD4\xF1\xF4\x54\xFE\xE9\x9B\xF5\xAA\xE0\xC5\x9C\xF7\xD3\xEA\x5E\x41\xF6\xE6\xB5\xF6\xAA\xF7\xF5\x99\xC1\xD7\xF6\xF4\x5F\xF8\xEB\xC0\xF5\x22\xCB\xF5\x0C\x0C\x0B\x3C\xF5\x49\xF4\xEC\xC1\xF6\xB1\xFB\xC3\xC2\xF7\xD7\xCD\xF7\x63\xFF\xEC\xF4\xC0\xB2\xFB\xF5\x64\xF7\xD5\xF2\xF4\x51\xFC\xED\xB0\xF5\xB7\xFB\xF6\xDE\xF1\xDC\xE0\xF7\x71\xFA\xEB\x83\x08\x0C\x0B\xF6\x6C\xD5\xDA\xD9\x09\x68\xF5\xEC\xD3\xF4\xB4\xEA\xF7\x45\xF0\xDE\xC7\xF2\x46\xDE\x02\x68\xF7\xE8\xD2\xF7\x49\xF0\xDF\xCB\xF2\x7D\xFD\xE4\xFC\xF7\x93\xFE\xF7\x51\xF4\x51\xC6\x02\x7B\xFF\xD5\x80\xF8\xBB\xEE\xF6\xEE\xF6\xDA\xC6\xF9\x85\xF9\xF0\xA9\xDF\x0C\x04\xF8\xEB\xF4\xE1\xE7\xF5\x61\xF3\xF1\xD2\xF5\xC5\xED\xF7\x17\xF8\xE1\xDC\xE1\x1D\x00\xF1\xF1\xF5\xC3\xFE\xF8\x19\xFC\xDA\xDF\xF9\x79\xF3\xF2\xF9\xF5\xC9\xFB", - "\xF7\x71\xDD\x07\x1D\xF8\x92\xF1\xF2\xEF\xF7\xC9\xFD\xF7\x2F\xFF\xDF\xF1\xF9\x80\xF3\xF3\x81\xBF\x07\x0B\xF9\x26\xFD\xE5\xCA\xF9\x99\xF7\xF0\xA2\xFA\xCE\xF1\xF8\x35\xFC\x22\x21\x02\x9C\xF8\xF2\xBF\xF8\xC8\xF3\xF5\x14\xF8\xE9\xD6\xF8\xA5\xF8\xF1\xCC\xFA\xC6\xE9\xE7\x27\x06\x1C\xE6\x00\xA2\xF0\xF3\xC6\xF8\xCB\xEE\xFA\x3E\xF8\xEB\xEE\xF8\xAB\xF9\xF3\xDA\xFB\xCE\xFC\xE0\x51\xFE\x1E\xD3\xFB\x6C\xF3\xE8\xDC\xF9\xD1\xFE\xFA\x40\xFE\xEC\xD5\xFA\xB4\xF7\xF4\xDF\xF4\xAD\xFC\xE0\xA7\xEF\x74\xC6\x08\x49\xF9\xEE\xBC\xFA\xC4\xEC\xFB\x57\xFE\xED\xC9\xFA\xBD\xFB\xF4\xD4\xED\x74\xEA\xEB\x02\x0C\xEE\xF7\xF6\xBB\xF4\xF8\xEA\xFA\xCC\xE6\xFC\x34\xF8\xF1\xFD\xF8\x0D\xDC\x9C\xD4\xFB\xE1\xF8\xFB\x5D\xFC\xEF\xCD\xFA\xC9\xFF\xF4\x94\xFD\xD6\xF6\xFC\x5B\xF9\x9D\xCC\x0D\xC0\xB2\xF8\x85\xF9\xE1\xF0\xFC\x67\xF8\xF3\xDF\xFA\xD0\xFB\xF6\xA2\xFD\xDA\xE9\xE7\x16\xF2\xEE\xD2\x5C\x6D\xFF\xF6\xA4\xFF\xE3\xE6\xFD\x6D\xFA\xDC\xED\xFC\xD8\xF9\xF7\xB2\xFC\x84\xE6\x08\x61\xFA\x47\xE3\xFA\x57\xF5\xF6\xAE\xFD\xE2\xFE\xFD\x8B\xFB\xF4\xF4\xFD\xC8\xF6\xFB", - "\xFD\xFB\x9F\xE0\x00\xB9\xFD\x48\xFB\xFD\x22\xDD\xF9\xA7\xFF\xF0\xE1\xFD\xC5\xFB\xF2\xD1\xFF\xCA\xF3\xFD\x97\xFD\xF5\xF9\xFC\xD4\xE9\xF9\xF9\xD3\xE5\xF9\xA7\xCD\xFD\xEC\xE4\xF7\x7B\xFF\xFA\xC2\xFE\xF1\xFE\xFC\xE4\xFF\xF7\xF3\xFD\xE6\xFA\xF5\xC2\x08\xED\xFA\xBB\xDC\xFE\xEE\xDE\xFE\xB5\xF8\xFC\xC6\xFE\xF9\xF2\xFD\xF4\xFC\xF5\xF6\xFF\xD6\xF8\xFF\xD8\xFF\xF4\xF9\xAD\x8C\x08\x0F\x0E\xFC\xBF\x7F\xF3\x75\xFA\x7C\x7F\xD0\x7E\xFE\x73\xFE\x46\x80\xE5\x7C\x02\x87\xFE\x61\x7F\xE7\x74\x43\x0D\x00\x00\x80\xC1\x7D\x02\x88\xFE\x4A\x80\xF1\x7F\x04\x86\x01\x8C\x80\x17\x83\xFC\x75\xEE\x42\x04\x48\x01\x8F\x70\xD8\x4A\x02\x10\x83\xDD\x72\x00\xAF\x7E\x04\x83\x00\x84\x01\x84\x7F\x27\x81\x01\x8B\x01\x80\x00\x42\x02\x07\x80\xDF\x42\x04\x7E\x01\x08\x8F\xF9\x63\x80\x01\x81\x09\x84\x02\xA9\x80\x26\x81\x06\x85\xFF\x6B\x80\x22\x02\x0B\x8D\xE0\x40\x00\xB9\x6E\x8C\x70\xFF\x68\x80\x3A\x83\xFD\x75\x04\xB9\x7F\x47\x83\xFE\x78\x03\xB7\x80\x49\x83\x01\x8B\x02\xAD\x00\x3E\x83\x03\x6B\x05\x32\x80\x8A\x7E\x08\x86\x03\xB5\x80\x4B\x80\x16\x8D\x04\x92", - "\x80\xB7\x7F\x40\x07\x05\x11\x81\x14\x06\x28\x04\x05\x80\x7F\x56\x81\x16\x81\x01\x8B\x80\x1A\x80\x06\x8A\x06\x9D\x78\x10\x04\x09\x00\x06\x90\x04\x44\x02\x2F\x77\x06\x95\x80\x6B\x83\x0E\x85\x07\x86\x81\x77\x80\x12\x89\x07\x8C\x7E\xAC\x78\xEB\x7B\x07\x8E\x81\x7F\x80\x17\x89\x06\x83\x82\x76\x80\x21\x88\x07\xAC\x81\x0C\x05\xAB\x7C\xEC\x55\x81\x33\x83\x15\x83\x07\x84\x81\x81\x80\x1A\x85\x96\x54\x04\x72\x79\xEF\x74\x03\x8F\x82\x2A\x81\x24\x84\x07\x86\x82\x7A\x80\x27\x8A\x04\xAB\x80\x81\x7A\x25\x8E\x08\xA5\x81\x5B\x82\x24\x87\x08\x85\x82\xA8\x83\x29\x81\xA0\x4F\x7A\x7E\x82\x27\x80\x08\xAE\x82\x82\x81\x2A\x8D\x09\xB2\x82\x9F\x82\x26\x80\x09\xB0\x82\xA6\x83\x2C\x8A\x0A\xBA\x82\xBC\x81\x2D\x88\x0B\x9B\x82\xB4\x83\x2B\x83\x09\xBD\x81\xA2\x82\x19\x84\x0A\xB6\x82\x99\x83\x2F\x87\x0B\x81\x83\xB1\x83\x2A\x80\x11\x27\x7B\xC5\x81\x29\x80\x0C\xBB\x82\xBE\x80\x33\x89\x0B\x95\x83\xD4\x82\x30\x89\x0D\xA9\x6E\xCA\x79\x34\x88\x0C\xB9\x80\xDF\x80\x13\x81\x0E\x9A\x81\xE3\x80\x26\x80\x0E\x88\x82\xD8\x79\xAF\x7C\x08\xAB\x83\x64\x81\x23", - "\x86\x0C\xB1\x6D\xD0\x82\x3A\x8D\x0E\xAC\x83\x97\x83\x31\x8A\x0C\x89\x83\xC3\x80\x43\x05\xEF\x5E\x83\xF7\x83\x39\x86\x0D\x93\x83\xBD\x82\x36\x81\x10\x8D\x83\x03\x87\x35\x85\xBA\x50\x04\x03\x7C\x3F\x8F\x0F\x8B\x83\xDB\x82\x41\x84\x10\x98\x83\x05\x84\x40\x80\x11\x93\x84\x02\x84\x1F\x8C\x10\x0F\x7C\x0A\x85\x43\x82\x11\x95\x84\x1C\x87\x43\x8D\x11\x8E\x84\x20\x87\x46\x8E\x11\xA9\x6E\x1C\x7D\x46\x81\x11\x8C\x84\x27\x84\x3E\x8A\x11\xA8\x84\x14\x87\x48\x81\x12\xAC\x84\x07\x84\x43\x0A\xF2\x66\x84\x2D\x87\x4B\x8A\x12\xA9\x84\xFE\x83\x4A\x87\x13\xB5\x84\x22\x84\xE0\x70\x00\x37\x7C\x34\x87\x47\x8D\x13\x83\x85\x30\x86\x4B\x84\x14\xBB\x84\x42\x85\x51\x8E\x13\x83\x7D\x41\x86\x51\x8A\x14\x87\x85\x39\x84\x4E\x82\x0E\xBD\x83\x53\x87\x42\x88\x14\xA9\x6E\xEC\x7E\x8C\x7E\xFE\x5E\x7E\xF4\x83\x28\x8E\x0E\x92\x83\x4F\x85\x58\x87\x15\xBE\x84\x59\x85\xEA\x6B\x15\x8E\x85\x63\x84\x54\x85\x15\xBA\x84\x51\x84\x4F\x82\x16\xAD\x85\x49\x85\x5A\x8D\xFF\x5E\x76\xF2\x81\x3D\x8F\x15\xA5\x83\xF6\x82\x55\x80\x17\xA9\x6E\x7F\x7E\x5A\x84\x0E\x94\x85", - "\x7F\x86\x5E\x8B\x16\x92\x85\x81\x84\x5B\x83\x18\xAE\x85\x72\x84\xED\x63\x10\x23\x6C\xE6\x83\x61\x81\x17\xBB\x85\x36\x84\x64\x8E\x17\x8D\x86\x85\x87\x83\x68\xC7\x43\x7E\x5D\x87\x3B\x89\x19\xA0\x85\x89\x86\x64\x8F\x16\xA8\x75\x92\x75\x53\x81\x19\x8E\x86\x68\x86\x67\x8D\x19\xA4\x86\xA3\x85\x65\x88\x18\xA6\x86\x63\x77\xFA\x72\xF5\x6D\x82\x82\x86\x6A\x8F\x18\xA8\x86\x93\x85\x5E\x86\x18\xB2\x86\x58\x87\x6B\x82\x1A\xB5\x86\x77\x84\x60\x84\x19\xBF\x86\x8C\x69\x59\x8E\x13\xA7\x85\xA9\x84\x70\x8D\x1B\xB1\x86\xC6\x84\xE2\x71\x78\x42\x87\xEA\x7C\x00\x04\x1C\xBC\x86\x9B\x84\x5E\x87\x1C\xB7\x86\xC9\x85\x3A\x7F\xFF\x7B\x86\x9F\x84\x6E\x85\x1C\xB6\x86\x84\x85\x75\x84\x03\x81\x5E\x0F\x80\x76\x87\x1A\x9A\x87\xD0\x87\x3C\x86\x1E\xB6\x85\x1C\x71\x07\x86\xD0\x41\x6B\x20\x82\x78\x8C\x1A\xB4\x86\xD9\x86\x77\x8E\x15\x91\x87\xE8\x83\x40\x0D\x02\xAB\x87\x47\x75\x0C\x8E\x1E\xB0\x87\xE3\x86\x7C\x8A\x19\xA7\x87\x57\x81\xE0\x5D\x03\xB8\x87\x31\x6D\x10\x85\x1A\xBC\x87\xEF\x84\x79\x81\x1F\x9C\x87\xAB\x84\x82\x8E\x20\xAE\x78\x0C\x04\x14\x84", - "\x20\x80\x76\x53\x83\x7E\x8A\x20\xBD\x87\x0C\x8B\x6C\x87\x21\x89\x88\x94\x85\xE0\x5F\x05\x93\x88\x2F\x80\x00\x02\x06\x96\x88\xFE\x84\x67\x8C\x21\x99\x88\x07\x8B\x86\x8F\x20\x81\x5E\x6E\x80\x88\x8F\x03\xB1\x81\xFA\x77\x5C\x83\x10\x2F\x00\x6F\x82\x35\x60\x1B\x94\x87\x28\x8B\x76\x83\x1D\x84\x86\x54\x7B\x8D\x8D\x1D\xB9\x88\xE5\x84\x7A\x8E\xFB\x7D\x88\x24\x88\x90\x8B\x20\xBB\x88\x0D\x8A\x8A\x8A\x24\x81\x5E\x95\x81\x5D\x83\x1F\x80\x88\xFF\x86\x90\x82\x25\x87\x7F\xA1\x82\x93\x81\x25\x8F\x89\x53\x8B\x95\x8A\x25\xAB\x80\x90\x7B\x22\x80\x25\xA6\x88\x0F\x89\x89\x82\x1D\xB4\x87\xC8\x86\x91\x88\x21\x88\x89\x1A\x8B\xB5\x73\x10\x0A\x82\x75\x7C\x99\x88\x23\xA8\x89\x29\x8A\x98\x85\x1F\x82\x04\xF1\x82\x97\x89\x25\xA0\x89\x4A\x8A\x9C\x85\x26\x81\x7D\x10\x05\x37\x86\x25\xB8\x89\x7A\x8B\x9B\x8E\x26\xBF\x88\xF0\x82\x8F\x89\x24\x81\x8A\x84\x8B\xA0\x87\x28\x8C\x6A\x75\x89\x9B\x8F\x25\xA3\x89\x8F\x8A\x6F\x86\x26\xAD\x86\x00\x03\x3E\x8F\x27\x90\x8A\x77\x88\xA6\x88\x25\x9B\x8A\x0D\x82\x41\x09\x10\x97\x8A\x92\x88\x9C\x8A\x23\x8A\x8A\x69", - "\x88\xC0\x71\x78\x58\x84\xA0\x8B\x9E\x84\x2A\xB1\x89\x93\x89\x98\x8C\xA8\x65\x84\xA9\x8A\xA0\x81\x29\xAA\x8A\xB3\x8A\xAC\x84\xDD\x73\x84\xB1\x89\xA2\x85\x2B\xBA\x8A\x99\x88\x60\x86\xF3\x46\x8A\xA5\x8A\xA8\x81\x24\x9C\x8A\x78\x89\xE0\x5C\x14\xB9\x8A\x8B\x8A\xB0\x87\x24\xAB\x8A\xA3\x88\xD4\x7A\x1B\x88\x8B\xC1\x88\xB3\x83\x2C\x9B\x89\x9A\x89\xA7\x8F\x65\x4F\x8B\x76\x88\xB1\x85\x2D\x80\x8A\xAD\x89\x9E\x8C\xA8\x71\x7D\xCB\x8B\xAE\x89\x2C\x92\x8B\xE1\x8B\x77\x85\xC1\x58\x86\xE2\x89\xB4\x89\x2E\xAC\x8A\xCA\x8B\x78\x81\x78\x4C\x86\xDD\x88\xA2\x83\x2E\xAB\x8B\xA9\x85\xE0\x5C\x18\x32\x8B\xEA\x89\xAF\x84\x2B\xBA\x8B\xCE\x80\x46\x70\x2D\xAC\x8B\xE4\x8B\x99\x81\x30\xA7\x88\x71\x6C\x73\x82\x23\x82\x04\xCF\x85\xB9\x8A\x2D\xA1\x8A\x03\x8E\xAB\x8C\x27\x8C\x04\x06\x8E\x62\x88\x30\x80\x8B\x00\x8C\xBD\x83\x2D\x9C\x8B\xED\x88\xA5\x81\x31\x94\x8A\x09\x8E\xC0\x86\x31\x8A\x8C\xD4\x88\xC3\x83\x24\x94\x04\x1B\x8C\x68\x80\x55\x14\x8C\xCD\x88\xBF\x8C\x2B\x8B\x8C\xFB\x89\x80\x84\x11\x17\x87\xFF\x89\xCA\x8C\x32\xB6\x8A\x33\x8F\xCA\x89\x05", - "\xA0\x87\x28\x8F\xC5\x8B\x2D\xBB\x8C\x22\x8E\xCA\x86\x11\x86\x04\xEA\x85\x47\x6E\xCC\x6D\x87\x31\x8E\xCE\x8D\x33\xB5\x8C\xF3\x8A\xCF\x81\x13\x86\x04\xF7\x86\xD0\x81\xAC\x7A\x87\x45\x8C\xC8\x88\x31\x8D\x8C\xDE\x89\xC6\x86\x32\x82\x04\x03\x8A\xD3\x87\xD4\x46\x88\x32\x8D\xC8\x8D\x32\x9E\x8D\x34\x8F\xCD\x84\x11\x12\x88\x5A\x8D\xCC\x65\x21\x91\x8D\x1E\x8E\xD2\x85\x31\xAA\x8D\x5D\x8F\x0A\x8F\x21\xA5\x8D\x80\x77\x88\x88\x36\x84\x8C\x54\x8C\xBE\x8B\x36\x88\x8D\x4B\x8F\x40\x0D\x22\xB0\x8D\x21\x88\x8C\x81\xE2\x4E\x7C\xE6\x63\xC8\x61\x78\x70\x8C\x45\x69\x78\x8A\xA3\x7B\x8D\x65\x6A\x33\x7E\x37\x89\x8E\xC1\x6A\x07\x0E\xCB\x41\x5E\x98\x65\xA1\x6E\xCC\x72\x01\xE6\x61\xE4\x8C\xD7\x76\x8C\x53\x8F\xC7\x89\x36\xB8\x8D\xA9\x6C\x9B\x88\x2E\xAC\x8D\x46\x8F\xD7\x89\x39\xA6\x8B\xC4\x83\xDC\x8E\x30\xB5\x8D\xF1\x89\xB7\x8C\x24\xB9\x8C\x52\x8C\xCF\x82\x3A\xAE\x8E\x61\x8C\x28\x8C\x3A\x9B\x8E\x60\x8C\xE6\x80\x3B\xB6\x8E\x73\x8B\xE6\x23\x3B\xB4\x8D\x9A\x8C\xEF\x80\x3A\xAD\x8E\x47\x8D\xED\x89\x34\x9C\x8E\x6D\x8F\x38\x84\x24\xA6\x8E\x55\x8C", - "\xEA\x86\x35\x89\x8F\x23\x8F\x33\x8B\x3B\xA7\x8E\xBD\x8C\xF4\x8F\x3B\xB4\x8E\x2B\x82\x9F\x89\x2D\x82\x8F\xF9\x88\xF1\x81\x3A\xB1\x8E\x5D\x80\x9D\x8F\x3C\x8C\x8F\xD3\x8E\xEF\x8A\x3D\x80\x8F\xF9\x81\x3A\x87\x3D\xA3\x8E\xE3\x8C\xF5\x87\x3B\x83\x8F\xD6\x8A\x40\x06\x29\xA7\x8F\xEB\x8D\xF6\x88\x3D\xB7\x8D\xF3\x8E\x4F\x8F\x29\xB0\x8F\xC1\x8C\xFA\x85\x3F\x9B\x8F\xB8\x8D\x6C\x87\x2A\x9F\x8F\x76\x8D\xF1\x89\x3F\xB1\x8F\x29\x89\xE0\x50\x2B\xB8\x8F\xAF\x8F\x00\x9A\x40\x89\x90\x0C\x91\xBF\x86\x10\x38\x8A\x08\x90\xF7\x8B\x40\x92\x90\x0D\x90\x8F\x84\x11\x00\x85\xC8\x8D\x00\x9C\x3F\xAC\x8F\xFA\x8F\x0A\x87\x2C\x91\x90\xFD\x8C\x05\x92\x42\xA1\x90\x24\x93\xCF\x87\x2D\xA2\x7D\x00\x91\xEA\x8B\x3C\x9A\x90\xD9\x87\x72\x88\x2D\x8E\x8A\xE1\x8E\xF4\x89\x3E\xA2\x8F\xFB\x8F\xC1\x81\xD8\x69\x90\x2B\x92\x0A\x9A\x3C\x9C\x70\x7D\x84\xF9\x83\x42\x9C\x90\x04\x92\x00\x95\x41\xA6\x90\x15\x69\x91\x89\x43\x87\x91\x3B\x92\xE6\x78\x43\x89\x91\x31\x90\xF8\x83\x43\x97\x8D\x00\x01\xEA\x7E\x43\xA5\x90\xF2\x8D\x07\x91\x44\xBE\x85\x2E\x90\x0A\x96\x44\x8C", - "\x91\x4F\x92\x13\x95\x43\x92\x8C\xC8\x7F\x0B\x9F\x39\x9D\x91\x2C\x92\xFA\x83\x41\x96\x90\xD6\x2E\x18\x9C\x15\x91\x8F\x5E\x92\x15\x97\x46\x80\x91\xB9\x8D\xC9\x80\x21\x86\x04\x1D\x8C\x0D\x9E\x46\x83\x91\x55\x93\x15\x93\x45\x84\x91\x00\x00\xE1\x80\x43\xA4\x91\x3A\x90\x1B\x95\x46\x94\x8A\x86\x8C\x08\x90\x47\xB8\x91\xF4\x8F\x1D\x9F\x43\xB9\x8D\x1C\x81\x8D\x86\x10\x04\x8D\x86\x91\x1E\x9F\x46\x92\x92\x88\x92\x10\x9E\x40\xB6\x87\x8E\x93\x40\x00\x35\x91\x92\x89\x92\x1E\x96\x46\x95\x92\x1B\x90\x23\x90\x00\x19\x8D\x8C\x8F\xD6\x8B\x44\x82\x92\x81\x91\x13\x9A\x26\x82\x04\x64\x8D\x29\x96\x36\xA7\x92\xAA\x91\x2A\x90\x48\xB1\x6D\x6F\x8E\x2B\x91\x37\xB0\x92\xB3\x90\x17\x9F\x45\xB6\x91\xDD\x8C\x00\x08\x38\x92\x8E\xC1\x6B\xE2\x8B\xDB\x79\x8E\x5E\x75\x01\x96\xBA\x76\x90\x2D\x7B\x92\x6E\x13\x89\x93\xC7\x90\x18\x9C\x4C\xAF\x78\xCB\x91\x8C\x70\xE3\x54\x64\x3A\x79\x8F\x6C\xE3\x6E\x88\x0F\x63\x8F\x76\x49\x94\x91\x9D\x93\x24\x9D\x4D\xA5\x8F\x6B\x88\x2E\x9B\x4B\xB2\x90\xE3\x91\x1B\x9D\x4B\x9E\x8E\x6B\x91\x2C\x98\x44\xA8\x92\x0F\x8E\x41", - "\x0D\x24\x9C\x92\xDB\x93\x21\x9B\x48\x9F\x93\xF3\x92\x4F\x85\x25\xB0\x93\xA1\x90\x3D\x9C\x4D\xB1\x93\x94\x93\x25\x92\x10\x1D\x89\x7F\x91\x39\x93\x48\xA4\x93\x8A\x93\x3E\x99\x4F\xBC\x93\xFA\x92\x3C\x96\x50\xB6\x90\xE8\x91\x42\x9D\x4F\x8B\x94\x9F\x91\x3D\x98\x45\x94\x04\x8D\x8B\x18\x92\x50\xB2\x92\x17\x95\x3B\x93\x10\x16\x8F\x01\x95\x41\x9A\x50\x9F\x94\x0F\x94\x48\x99\xBA\x55\x94\xE9\x91\x2E\x9C\x4E\xBA\x92\xC5\x88\x45\x92\x4E\x9E\x94\x21\x95\x4B\x9E\x50\x86\x93\x10\x07\xFB\x8D\x51\x9E\x92\xBC\x92\x37\x98\x50\xB7\x94\xCD\x87\xFD\x83\x53\xB6\x94\x07\x95\x4F\x9B\x47\xAE\x94\xF5\x88\x45\x08\x2A\xB8\x93\x3F\x97\x4B\x98\x53\x85\x95\x47\x94\x18\x97\x40\xBB\x94\xA0\x90\x52\x9E\x53\x91\x94\x10\x94\xA5\x80\x41\x8C\x95\x12\x96\x53\x96\x55\x90\x95\x49\x8B\xAF\x8B\x45\xA7\x94\x5C\x95\x13\x96\x2C\xAB\x94\x34\x94\x41\x91\x56\xA6\x93\xBE\x88\xC9\x8A\x46\x86\x95\x4F\x95\x4D\x9D\x54\x98\x95\x1A\x89\x16\x9A\xFB\x60\x95\x3C\x97\x55\x9A\x56\x95\x95\xEE\x8A\x4E\x60\x57\xAB\x95\x73\x95\x54\x92\x56\xA5\x95\x50\x74\x55\x9A\x57\xA4\x95", - "\x78\x97\x5E\x91\x58\x8B\x89\x8D\x7F\x56\x9A\x4E\xA8\x94\x63\x97\x2A\x92\xC8\x49\x95\x79\x96\x48\x9C\x58\x82\x96\xB7\x85\xE0\x52\x45\xAC\x95\x68\x96\x5C\x90\x59\xBF\x95\x8A\x96\x1C\x91\x78\x75\x91\x97\x96\x63\x99\x56\x9D\x96\x40\x97\x44\x99\x46\x9A\x91\x19\x90\x46\x9C\x52\x95\x96\x94\x94\x59\x87\x56\x8F\x96\x80\x94\x5D\x9D\x58\xA1\x96\x2D\x92\x59\x94\x5A\x84\x95\xA9\x97\x67\x9D\x5A\x98\x96\xAA\x8F\xCB\x87\x57\xAE\x96\xA0\x94\x6A\x9F\x5A\xBE\x96\x50\x91\x21\x9E\x57\x9E\x96\x96\x97\x6D\x94\x5C\xB5\x96\x36\x91\xD0\x86\x4B\xA1\x88\x90\x93\x70\x90\x5B\x88\x97\xD0\x97\x6F\x9C\x5A\x81\x5E\x4D\x8F\x72\x9F\x03\x9B\x92\xCE\x94\x70\x96\x5C\x8F\x97\xD2\x96\x6D\x92\x20\x99\x92\xF4\x63\x6E\x98\x5B\xAB\x93\x87\x95\x3A\x7D\x4A\x80\x93\x47\x77\xD9\x84\x5B\x9D\x97\xC5\x97\x40\x9B\x5D\xB0\x94\x0C\x05\x2D\x98\x5E\xB1\x6C\x72\x8F\x7A\x9D\x5B\xAC\x96\xEE\x95\x7E\x9C\xA8\x7F\x92\x76\x76\xE2\x89\xD0\x5E\x61\x89\x75\xD7\x66\x08\x17\x72\x7A\x67\x80\x9B\xB8\x73\x76\x00\x00\x22\x04\x60\x9D\x6D\x0A\x9B\x28\x7D\xB5\x4F\x02\xA5\x74\xE3\x66", - "\x10\x10\x98\xF6\x63\x3B\x99\xA7\x77\x93\x79\x68\x40\x96\x51\xAB\x80\x24\x94\x37\x86\x8E\x5D\x98\x3E\x84\x88\x9D\x1C\xB2\x94\xBA\x6E\x4E\x9B\x61\xBD\x92\x43\x95\x9E\x6B\x54\xBA\x6E\x53\x96\xEE\x6A\x59\x94\x04\x9C\x97\x1C\x97\x42\xAF\x95\xF6\x60\xB8\x80\x46\xBD\x90\x75\x94\x82\x66\x8E\x5B\x7E\x46\x71\x9E\x6F\x62\x90\x04\x31\x9A\x5B\x9A\xFC\x66\x63\x3F\x98\x43\x01\x64\xB2\x96\x34\x98\xF2\x83\x38\x9F\x8F\x38\x8E\x3D\x6A\x5C\xB3\x97\x1F\x82\x39\x65\x5D\x90\x99\x21\x88\x76\x9A\xBB\x64\x92\x54\x9B\x0F\x8C\x35\x8D\x87\xE7\x95\x7F\x91\xAC\x6A\x97\x79\x6A\x7C\x9E\x65\x87\x75\xF5\x95\x76\x9E\x13\xBC\x97\xAF\x0A\x99\x62\x4C\xA3\x99\x31\x6C\x2B\x0F\x5F\xBD\x74\xC7\x7F\x7D\x77\xDF\x66\x69\x1A\x9A\x71\x74\xD4\x71\x6D\x40\x03\x3B\x7C\x07\x1C\x78\xE0\x92\x40\x09\x67\xA4\x78\x10\x07\x9E\x91\x23\xA7\x72\x1C\x72\x0C\x0F\xCE\x4D\x94\x17\x79\x7B\x79\xCE\x4A\x00\xEF\x72\x6C\x56\x67\x92\x75\x1C\x70\x15\x70\xD9\x66\x71\x0C\x04\x03\x0C\x67\xBE\x93\x3F\x87\x3B\x7E\x47\x97\x8E\xF3\x75\x3A\x7F\x41\x93\x70\x69\x6C\x45\x02\x0B\x17\x9A\x96", - "\x84\x44\x04\x06\x2F\x73\xB7\x00\xA9\x9C\x47\xA7\x9A\x80\x98\x43\x09\x6A\x83\x9A\xBA\x71\xDC\x6C\x6A\xB8\x76\x66\x6B\xAB\x9F\x37\x98\x77\xC7\x7F\xAC\x95\xC6\x61\x9A\x10\x06\xAD\x96\xE2\x5D\x9A\xD4\x74\x0B\x0F\xCE\x59\x01\xAA\x9A\x28\x9B\x04\x2F\x73\x8E\x02\x78\x97\x5C\xAC\x97\xD1\x97\x7D\x9D\x1C\x88\x9A\xB6\x96\x7E\x94\x5E\xAE\x8C\xA5\x8E\x7D\x9F\x5E\xB8\x97\xA6\x97\x58\x9B\x3A\x86\x96\x26\x95\x79\x9E\x6D\x94\x89\xCA\x98\x77\x9E\x6C\xAD\x97\xB9\x94\x44\x05\x67\x9A\x97\xD2\x98\x62\x91\x57\x8D\x9B\xD7\x99\xB4\x99\x6D\xBC\x95\x89\x81\xB8\x98\x6E\xAF\x9B\x83\x96\x62\x92\x62\xA4\x9B\xD3\x99\x46\x94\x35\x81\x5E\x1C\x97\x89\x9B\x6E\x8C\x9B\x00\x9F\xB8\x9C\x6E\x81\x5E\xF7\x98\xBB\x99\x6E\x9D\x95\x5D\x90\xC1\x92\x6F\x98\x9B\xF9\x9B\x69\x91\x54\xB1\x94\x0B\x9E\xBB\x9D\x70\x89\x96\x02\x7D\xC4\x98\x6F\xAA\x9B\xF5\x9A\xA9\x82\x54\x96\x9C\x06\x9C\xBD\x9C\x5B\x84\x96\x10\x07\x8A\x95\x52\xBA\x9B\x08\x9C\xC9\x94\x3A\xB2\x84\x1C\x9D\xC0\x9D\x6E\x97\x9C\xCD\x8C\x43\x08\x41\x96\x9B\x07\x9F\xB7\x95\x4E\x9F\x95\xDC\x9A\xC9\x9D\x6D", - "\xB7\x9C\xED\x8D\x18\x93\x5B\xA6\x99\x12\x9C\xC6\x9F\x71\x9D\x88\x48\x9B\x90\x95\x73\x8E\x9C\x3D\x9D\xC9\x99\x52\x90\x04\x36\x9A\xCA\x91\x73\xB8\x9C\x44\x9E\x0D\x98\x63\x8A\x9D\x1E\x9F\x78\x9E\x73\xA5\x9A\x0C\x04\xBC\x83\x71\xBF\x9B\x02\x9C\xD4\x91\xB7\x77\x8B\x51\x9F\xB2\x99\x75\x9F\x9D\x20\x9E\xBF\x80\x73\x9D\x9D\xE2\x9B\xCA\x93\x70\x81\x9D\xDB\x7D\xCA\x90\x76\x8B\x9D\x36\x9D\xCE\x95\x64\xB4\x91\x6A\x9E\xD9\x9A\x75\x93\x9D\x59\x94\xDA\x9D\xFE\x71\x9D\x6C\x9D\xD3\x9D\x71\x85\x8C\xAB\x95\xD1\x92\x73\xBA\x9D\x73\x9D\xCB\x96\x10\x1B\x9A\x23\x9C\xE0\x9B\x76\xA4\x9D\xF3\x99\xDC\x62\x5C\xBE\x9B\x19\x9F\xD5\x9D\x78\x8A\x87\x14\x07\x93\x9C\x66\x91\x99\x43\x9C\xC5\x9E\x78\xBF\x9C\x8C\x6B\x94\x93\x79\x95\x99\x78\x9C\xE2\x9C\x70\xBB\x9B\x14\x04\x96\x9B\x79\x9A\x99\x9D\x9F\xE5\x92\x75\xAC\x91\x81\x5D\x97\x99\x66\x8E\x73\x60\x98\xE3\x98\x79\xA6\x9E\x5E\x9E\xDC\x90\x45\xA2\x99\xAB\x9D\xB0\x65\x66\xAE\x9E\xA7\x9F\xDF\x96\x79\xA0\x9E\x6D\x80\x78\x90\x00\x2B\x99\x8F\x99\x22\x60\xDE\x71\x6D\x72\x9B\x43\x77\x6E\x89\x9A\x84\x74", - "\x75\x7F\x67\xB4\x9A\xCE\x72\xA0\x97\x6B\xBB\x77\xC7\x7F\xF2\x9B\x6B\x8A\x72\x0C\x06\xF3\x9F\x6B\xA2\x78\x85\x9B\xA1\x95\x6C\xA9\x6E\x8C\x99\xAB\x96\x10\x0E\x9A\xEC\x75\xF2\x97\xFC\x52\x9A\x13\x78\xA5\x96\x10\x16\x9A\xB0\x9B\x37\x74\xDD\x6F\x9C\xA0\x98\xF5\x93\x78\x9B\x9F\x4B\x87\x3B\x73\x6A\xA9\x9F\x36\x74\x75\x7A\x6B\xAD\x9F\xC9\x72\xAB\x90\x7F\x8D\x87\xF7\x9C\x17\x76\x7E\x83\x04\xBE\x9B\x30\x97\x67\x9C\x70\xFD\x9E\x48\x7F\x7F\x82\x04\x01\xA0\xA7\x98\x7D\xA9\x73\x05\xA3\xA4\x9C\x6B\xBA\x9F\xF4\x9E\x6F\x70\x11\x02\x9B\xDE\x9F\x40\x04\x6C\x91\xA0\x8C\x6B\xB1\x95\x81\x82\x04\xC9\x99\xE5\x98\x75\xB2\x9E\x20\xA0\xD0\x95\x6D\xBC\x9C\x2C\x9E\xEE\x9F\x81\x8A\x96\xD0\x99\x09\xAC\x74\xBB\x9E\xA8\x9C\x25\x85\x7A\xB4\x9D\x65\x9E\x7B\x91\x78\x58\x98\xB8\x9D\xEC\x99\x77\xAC\xA0\x27\x9E\x41\x07\x7C\xBE\x9D\x2B\xA3\x09\xAE\x79\xBC\xA0\x6D\x9E\xE1\x90\x82\x87\x8F\x63\x9C\xEC\x91\x83\xBF\xA0\x36\x91\xC1\x91\x78\xA6\xA0\x8F\x9D\x0B\xAD\x27\xAF\xA0\x46\x9C\x0E\xA9\x70\xAA\x94\x1E\xA1\x13\xAC\x84\xAF\x9E\x1C\x72\x12\xA7\x78\x86", - "\xA1\x89\x9C\xEF\x9A\x0F\x90\xA1\x57\xA1\xEE\x93\x85\x88\x84\x60\xA1\x0F\xA6\x85\xA6\xA1\x98\x99\x8A\x95\x83\x87\xA1\x5C\xA3\xE7\x92\x78\x83\x04\x22\x9D\x17\xA1\x85\xBE\xA0\xCB\x8D\xE0\x5D\x62\x85\x9E\x52\xA1\x10\xA9\x87\xAB\x80\xEC\x9F\x1A\xA2\x87\xA1\xA1\x36\xA0\xA3\x6F\x69\xBE\xA1\x6E\xA0\x20\xAC\x86\x90\x9E\xA3\x95\x92\x95\x84\xB0\xA0\x7F\xA0\x1A\xA4\x75\xB8\x7E\x7D\x9E\x0A\xAA\x87\xB4\xA1\x5E\xA0\x5D\x8B\x88\xB3\xA1\x67\xA3\x24\xAD\x67\x8F\x73\x65\xA2\x26\xA8\x85\x98\xA2\x98\x9A\xD5\x9C\x88\x85\xA2\x8E\xA1\xDD\x97\x19\x8D\xA2\x9E\xA2\x18\xA3\x73\xBD\x98\x84\xA0\x10\xA2\x84\xB7\xA0\xF0\x98\x24\xAB\x73\xAD\xA2\x92\xA3\x2B\xA8\x84\xB9\x98\x10\x8D\x24\xAB\x77\xA3\xA2\xAE\xA2\xB6\x96\x77\x9A\x85\x9D\xA2\x2D\xAD\x86\x9E\x97\xBF\xA2\x59\x81\x8C\xBB\xA1\xC8\xA0\x25\xA6\x1D\x87\xA3\xCA\xA2\x21\xA8\x8A\xAB\x80\x8B\x9C\x1E\xAD\x8C\xA5\xA2\x87\xA3\x1B\xAD\x48\x98\x93\x14\x05\x73\x94\x8B\xBB\xA2\xA0\xA2\x2A\xA7\x74\x8C\x04\x9A\x9D\xED\x99\x1F\x8C\xA3\x99\xA2\x30\xA5\x89\x83\x04\xA2\x9E\x38\xA5\x20\xA4\xA3\x9F\xA2\x33", - "\xA3\x5D\xA3\x8D\xBE\x9D\xEB\x92\x8D\xA5\xA3\xC9\xA0\x3D\xA1\x8B\x9E\x81\xBE\x9F\xED\x93\x8F\xAD\xA3\xD4\xA3\x33\xAE\x8B\xBD\x9E\xD8\xA0\x1C\x8C\x8E\x9E\xA3\xF5\xA1\x64\x94\x11\x29\xA0\xDC\xA2\x3B\xAD\x8B\xB7\xA3\x02\x04\x42\xAB\x84\xBD\xA3\xA4\xA3\x2A\xA0\x11\x16\x98\xDB\xA3\x43\xA9\x8A\x81\xA2\x1A\x94\xA0\x73\x90\x98\xA4\xBC\xA1\x71\x91\x78\x7B\xA0\xB5\xA1\x41\xA4\x90\x93\xA3\x17\xA5\x35\xAA\x90\xB1\x96\x23\xA1\x45\xAB\x85\x9D\xA4\x09\xA4\xB5\x9C\x10\x1A\xA1\x21\xA3\x2D\xA6\x91\x82\xA1\xFC\x9B\x46\xA6\x92\x90\xA4\xC4\xA2\xF3\x85\x85\xBC\xA3\x25\xA6\x3F\xA9\x3B\xB0\xA4\xB0\xA2\x3D\xA2\x94\x86\xA4\x10\x9F\x4E\xA3\x92\x83\xA5\x47\xA4\xA6\x96\x62\xBB\xA3\x49\xA5\x53\xAC\x91\x8E\xA1\x17\x86\x4D\xAE\x93\x88\xA5\xB1\x9E\x01\x92\x95\x91\xA4\xE6\xA0\x54\xAF\x40\x97\xA5\x0B\xA4\x55\xAD\x56\x97\x90\x5C\xA5\x48\xA4\x92\x9F\xA3\x06\x07\x20\xAC\x94\x8F\xA5\x27\xA5\x4B\xA2\x36\x89\xA2\x42\x9D\x69\x93\x8C\xA2\xA5\x5E\xA5\x6E\x83\x8B\xA7\xA5\x37\xA5\x4F\xA8\x95\x86\x8F\x76\x96\x51\xA8\x96\xB8\xA4\x70\xA4\xA6\x9F\x74\xAB\xA4", - "\xDD\xA3\x5E\xA6\x97\x8D\x87\xA2\xA1\x60\xA5\x97\x99\xA5\x39\xA3\x2B\x7D\x95\xBC\xA4\x88\xA7\x18\xA2\x76\xA4\xA0\x6A\xA5\x63\xA3\x98\xA8\xA4\xB9\xA3\x5C\xA3\x95\x8C\xA6\x22\xA5\x55\xA5\x8C\x83\x87\x61\xA5\x64\xA9\x99\xA5\x9D\x42\x99\xDA\x9A\x97\x87\xA6\x9F\xA7\x65\xAF\x88\xB3\x98\x6D\xA7\x25\xA9\x96\xB3\xA4\xA5\xA7\xC3\x9E\xFF\x5D\xA6\xAC\xA7\x58\xAD\x9A\x8D\x87\xD1\xA2\x69\xA2\x98\x92\xA6\x34\xA5\xE4\x9E\x7B\x9A\xA3\x74\xA6\x6D\xA4\x9A\xB2\xA6\x0C\xA4\x0B\x8E\x7B\x96\x99\xBD\xA7\x5D\xA0\x9C\xB1\xA5\xAE\xA6\x41\x09\x8E\x9C\x08\x66\x6B\x96\x9D\x97\x8E\xA5\xBF\xA7\x60\x99\x7A\xB1\xA3\xB0\xA4\x60\xAB\x9A\xA0\x9D\x1E\x89\x3E\xA5\x9D\xB1\xA4\x6F\xA6\x67\xA9\x3B\xA8\x99\xCC\xA6\x7F\x94\x7F\x83\x9F\x1C\x71\xF1\x9A\xD5\x60\xA4\x6A\x71\x82\x79\x3B\x92\x9F\xF8\x9F\x36\x76\x10\x16\x9F\x02\xA0\xA4\x99\xCE\x6C\xA7\xFE\x9F\x03\xAF\x9E\xBB\x9F\x36\x92\xA1\x9B\x81\x80\x00\x0E\xA4\x2E\x7A\x9E\x9B\xA2\xDD\x9C\xF3\x91\xAC\x60\x9F\xC8\x9F\x71\x74\xDD\x64\x9F\xFE\x77\x72\x7E\x5B\x78\xA7\x60\x91\x1F\xA6\x80\xB6\xA7\x03\x04\xE1\x91", - "\x7E\x86\xA8\xC7\x7E\x59\xAE\x80\xAE\x9F\x03\x07\xFC\x9F\x7C\xAC\x71\x39\x9D\x03\xA5\x7E\x90\xA8\x08\xA0\x83\xA4\x29\x9E\xA8\x09\xA8\x85\x71\xA2\x98\xA0\xB2\x98\xAA\x92\xA2\x90\x91\x24\xAB\x76\x7F\xDF\x49\xA0\xC1\x9C\xB0\x97\xFC\x54\xA0\x02\xAB\x51\x77\x81\x9B\xA8\x84\x99\x3A\x7A\x81\xB5\xA8\x31\x6D\x07\xAE\x96\xAC\xA4\xB1\xA6\x74\xA7\x90\x9B\xA7\x41\xA4\x66\xA9\x3B\xBD\xA7\xDC\xA4\x90\xA6\x9D\x8E\xA6\xEE\x90\x91\xA2\x93\x8B\xA9\x6B\xA4\x43\x04\x83\x85\xA7\x8B\xA4\x74\xAE\x9B\xB0\x97\x3A\xA2\x93\xAD\x9D\x81\xA9\x46\xA8\x72\xA5\xA5\xB7\xA6\xE7\x92\x96\xAA\xA4\x89\xA9\xD6\xA0\x00\x00\x94\x8F\xA9\x64\xAB\x75\xA1\x76\x86\x04\xFD\x98\x95\xAF\x9C\xA0\xA9\xC7\xA4\x51\xAF\x92\xA2\xA9\x86\xA7\x95\xA9\x9C\xA6\x7B\x74\xAA\x9A\xA5\xA4\xA7\xA6\xEE\x8D\x9E\xAC\x97\x9E\xA7\xFE\x8D\xB2\x5E\xA7\x93\xA6\x80\xAB\xC7\x9F\x3F\xA3\xA6\x76\xAB\x97\xA1\x9D\x98\x9A\x71\xA2\x71\xAE\xA5\xAF\xA9\xA0\xA4\x45\x07\x87\x89\xAA\x90\xA8\xA5\xA8\x8B\x86\x04\x0E\xAA\xA5\xAC\xA5\x96\xA9\x77\xAA\x40\x06\xA1\x8E\xAA\x5D\xA9\xA8\xAF\x57\xA1\xA6\x77", - "\x9C\xA2\xA0\xAA\x9C\xAA\x8A\xAA\x5C\xAA\x88\x90\xA6\x9B\xA8\x9C\xAF\xA8\x97\xAA\x6D\x67\xA0\xA8\x9B\xB3\xA6\x94\xA5\x81\x62\xAB\xB4\xAA\x85\xAB\xA8\xA5\x58\xBF\xA8\x75\xAB\xA9\xAE\xAA\x98\x9A\x5C\x9F\x96\xA0\xA5\xB3\xAA\xC1\xA7\x64\x9D\xAA\x8B\xAA\xA8\xAA\x47\xAB\x99\x8D\x87\x31\x9B\x9E\xAF\xAB\x89\xAB\xB0\xAA\x6B\x86\x99\xBE\xAA\xC8\xAB\xB3\xAA\x99\xAC\xA5\xA2\xA4\xAF\xAA\xA7\xA8\xA9\x22\xA1\x65\xAB\xAA\xAA\xA4\x69\xAB\x9F\xA7\xAC\x9A\x97\x4B\x9A\xA9\xA9\xAA\x94\xAB\x9A\xAB\x8A\x86\xB8\x37\xAA\x71\xA8\xB4\xA9\x20\x81\x5E\x92\x9E\x3A\xA4\x79\x9A\xAB\xE2\xAB\xB0\xA8\xAB\x94\x8A\xE1\xA1\x78\xAF\x34\xAC\xAB\xAF\xAB\xB8\xAD\xA9\xA3\x92\xBE\x9E\x73\xA9\xAB\x96\xAB\xD5\xA9\xA4\xA0\x11\x2A\x9E\xFA\xA9\x7A\x9C\xAF\xA2\xAA\x04\xAC\x96\xA8\x8F\x81\xA4\x0C\x06\x3E\xA9\xAE\xA1\xAB\x84\xAA\xBF\xAD\x1C\xA0\xA7\x12\x0A\x9A\x9B\xB0\xAE\xAB\xF6\xAB\x91\xAB\xB1\x8D\xAC\xE8\xAA\x4F\x88\xA4\x8E\xAB\x05\xAF\xC4\xAA\x58\x94\xA4\x6E\xAB\xC0\xA5\xB2\xA1\xAC\xA2\x96\x94\xAF\xB1\xAB\xAC\xE7\xA9\xCB\xA9\xA5\xA6\xAB\x95\xA8\xCB\xA5\xB3", - "\xB1\xAC\x37\xAD\xCE\xA7\x76\xA9\xA4\x29\xAE\xC5\xAA\xB3\xBE\xAC\xD1\xAA\x99\xAF\xB2\xA6\xAC\x68\xA9\x4D\xA4\xB3\xAA\xAC\x44\xAD\x1D\xA4\x85\xB4\xAB\x15\xAD\xC7\xAD\xAF\x90\x91\x67\xAA\xB0\xA4\xB1\x84\xAB\x81\xA9\x51\xAC\xB4\x94\xAD\x0C\xAC\xCC\xA6\x43\x8B\xA5\x49\xAF\x98\xA4\xB2\x8E\xAC\x02\x06\x1A\xAD\xB3\x8E\xAD\x59\xAD\xD7\xA9\xCE\x4D\xAA\x38\xAC\xD2\xA6\xB3\xBB\xAC\x28\x9F\xD1\xA0\xB4\xAF\xAD\xD8\xA4\x58\xAE\xB6\xA4\xAD\x1C\xAF\x10\xA2\xF4\x43\xAD\x6B\xAC\xDC\xAB\xA6\xA8\xA6\xD9\xAA\x6A\xA5\xAF\x93\xAD\xF7\xA8\x14\x9F\x76\xA7\x8C\x73\xAC\xE0\xAD\xAE\xA0\xAC\xCD\x85\xD2\x94\xB7\x88\xAE\x3F\xAD\xDC\xAD\x57\xA0\xAB\x5F\xAD\xDE\xAB\xB8\x9F\xA5\x3A\x99\xE1\xA1\xB9\xA9\xAD\x2A\x9E\xBD\x88\xB7\x98\xAE\x93\xAC\xD8\xA1\x45\x9B\xAE\x8D\xAE\xE1\xA5\xB5\x9E\xAB\xA9\xA4\xAB\xAD\xB9\x92\xAE\xA2\xAE\x9C\xA2\x8B\x9F\xAB\x63\xAD\xEA\xA5\xB7\x97\xAE\x36\x93\xE0\xA3\x31\x96\xAE\xDC\xA9\xED\xAC\x77\x93\xAB\x9C\xAE\xEB\xAC\xB8\xAA\xAD\xCD\x86\x84\xA8\xBA\xB0\xAE\xBC\xAE\xB2\xA1\x5C\x60\xAE\xC1\xAD\xF1\xAF\xAE\xBA\xA6\x10\xAF", - "\x23\x94\xBC\xBA\xAD\xC0\xAC\xBE\xA3\x9C\x8B\xAF\xA7\xAD\xEE\xAA\x58\x8B\xA7\x19\xAE\x33\x72\xB0\x8C\xAF\xB6\xAF\x98\xA3\x9D\x89\xAF\x03\x06\x3C\xA6\xB6\x9B\xAB\x52\xAD\x76\xAC\xBD\x82\x04\x12\xAF\xEF\xA9\xBD\xBD\xAA\x32\xAE\xDE\x8E\x7B\x80\x9F\x13\xA8\x28\x64\x9E\xA9\x73\xE6\xA7\x7F\x78\x9E\xA5\x72\xFF\xA4\xA6\x94\x9F\x8F\xA8\x18\xAA\x40\x00\x9F\x8A\xA0\xCE\x76\xF2\x9A\x67\xAB\xA8\x32\x9A\x40\x0A\x9F\xBC\xA8\x80\x74\x92\xAF\xBE\x94\x77\x01\xAB\xF4\x99\x7F\x9F\x9F\x00\xB1\xE0\x58\xA0\xAE\xA8\x0A\xA8\x00\x08\x7E\xB8\xA8\xB1\x98\x07\x79\xA9\x9F\xA8\xF9\xAD\x1F\x9D\xC0\xB7\xAD\xFB\xA6\x86\xA7\x7D\xBD\xAF\xB9\x9A\x8A\xA8\xA2\x84\xA0\x22\xB0\x05\xBA\x7E\xA1\xB0\xFB\xA4\x8C\xAD\xBE\xB2\xA7\xF6\x9D\x09\xBF\xC1\xB8\x9A\x39\x9C\x8D\xAA\xC0\xAE\xA7\x16\xA3\x06\xB0\x11\x3B\xA8\x33\xB0\x3F\x76\x10\x3E\xA8\x81\x72\xD3\x60\xD8\x60\x01\xBE\x72\xC4\x6A\x97\x40\xB1\x23\xB0\xFC\xAF\xCE\x73\xAF\x08\x06\x10\xBD\xB5\x44\xB1\x26\xB1\xFD\x91\x7D\xBF\xAF\x0C\x6F\x10\xB6\xC3\x8C\x04\xF7\xAF\x85\xAB\xC0\x83\x04\xFB\xAC\xBB\x61\xB4\x52", - "\xB1\x45\xB0\x75\x73\xC0\xB9\xB0\x17\x76\x41\x08\xA4\x8A\xB1\x12\x9B\x40\x0C\xC4\xAF\xB0\xD0\x9D\xCE\x99\xC0\xAD\xA7\x3A\xB3\x40\x04\xA0\x88\x76\x5B\xB3\x12\xB3\xC5\x86\x04\x0F\xB1\x53\x7F\xD0\x53\xB0\x3D\xB0\x17\xBD\xC4\x92\xA0\x2E\x9E\xA6\x9B\xB2\x72\xB1\x5D\xB1\x85\xA2\x7F\xBF\xB1\x65\xB2\x40\x07\xC6\xB1\xA7\x27\x78\x03\xAE\xC2\xAE\x72\x02\x06\x0F\xB1\x22\x87\xB2\xFC\xAC\x0C\xBB\x02\xAD\xA8\x76\xB2\x56\x7A\xC2\x96\x04\x64\xB0\x82\x90\xC9\xB1\xA8\x0B\xA1\x0B\xB9\xC2\x84\xB2\x9A\xB3\x1C\xB3\x10\x14\xB2\xF6\x77\x43\x77\xC9\xB0\xB1\x35\x6D\x28\xB1\xC8\xB1\xB0\xC3\x98\x28\xB9\xC7\x4C\x04\x9B\xB3\x0A\xB9\xC8\x94\x77\x38\xB0\x1B\xB1\xC6\x83\x04\x3C\xB1\x9E\x64\x23\xA3\xAF\x46\x6A\x39\x6B\xCB\xBC\x8D\x3F\x81\x31\x96\xBE\x92\xAD\x32\xA3\x90\xA4\xBB\x84\xB3\x45\xAE\x31\xB7\xB5\x81\xAE\xBA\xAE\xD6\xA0\x46\xA8\xAC\xDF\xAF\xDF\xAD\xBC\x90\x91\x53\xA9\x34\xBD\xB4\x8D\xB3\x9E\xAC\x12\xB8\xCD\x83\xB3\x5E\xAF\xF9\xA0\xBE\x9A\xAF\xCA\xB2\xDF\xA7\xCD\x93\xB3\x76\xAE\x4E\xAB\xCC\x87\xAE\xCE\xB2\xDE\xA6\xB4\xA7\xB3\x4F\xAF\x36", - "\xB9\xBB\x8A\x9C\xC7\xB1\x37\xB8\xCC\x85\x8A\xF1\xB0\xFA\xA1\xBA\x9D\xAB\x06\x04\x89\x9D\xBA\xA4\xB3\xFC\xB2\xC6\x94\x86\xB5\xB3\xDF\xB2\x3D\xBC\xB6\x86\x04\x62\xAE\x35\xB8\xB5\xAF\xAE\xAF\x88\xF4\xAE\xCE\xB7\xB3\x8C\x6B\xA4\xAC\xCD\x82\xB4\xEA\xB2\xDC\xAC\xCE\xA5\xAD\x0F\xB5\x62\xAE\xA9\x8A\xB4\xFD\xB2\xD2\xA8\xAD\xA5\xAA\x13\xB4\x42\xB3\xCF\x88\xA2\xA4\xAD\xDF\xA6\xBA\x8B\xB4\xC6\xAD\xF4\xA5\xAB\xB1\xAA\x00\xB6\x34\xBE\xCD\x87\x7F\x7F\xA4\x49\xB8\xBD\x9F\xB4\x65\xA9\x61\xA1\xD0\xB3\xB4\x4C\xAA\x62\xAC\xD0\xB0\xB4\x6A\xAA\x64\x98\xD1\xAB\xB4\x12\xA5\x48\xBC\xD1\xA2\xB3\x07\xB7\xEE\xA1\xD1\x9B\xB4\xC0\xA1\x4A\xB3\xCE\xBC\xB4\x2B\x82\xEC\xAE\x1C\xBB\xB4\x38\xB5\x4D\xB2\xAD\xAC\xAE\x06\xB4\x33\xB9\xD1\x9C\x70\xBE\xAE\xF4\xA8\xD4\x92\xB5\x8C\x69\x6D\xA5\xD1\xAA\xB4\xE1\xAC\xF2\xA0\xCC\x8F\x60\xBC\xA5\x54\xB8\xCE\xA2\xB5\x9B\xA1\xBE\xA5\xBD\xBB\xAB\x46\xB5\x50\xB9\xCE\x8E\xAE\x0C\x04\xF5\xA9\x1F\x0D\xA7\x4C\xB6\x3C\xB7\x8E\xAC\x92\xD4\xA5\x5A\xB8\xD5\x8D\xB5\x39\x9C\xED\x99\xB0\xB4\x97\x71\xB4\x44\xB6\xD2\x81\xAD", - "\x18\xAF\x5B\xB2\x9E\x8D\xB1\x07\xB1\x9C\x97\xC4\xA2\xB2\x7E\x98\x14\xBB\xC7\x8C\x6A\x55\xB0\x06\xB7\xC5\xBA\xAF\x88\xB4\x00\x0F\xC5\xB6\xB2\x99\x76\x18\xB1\xD9\xAB\xB1\xF5\xA5\x06\xBF\xC6\xA5\x77\x70\x99\xCE\x95\xC7\xA5\xB2\x5A\x74\x1E\xB8\xC8\xB2\xA8\x39\x9F\x05\xB5\xA2\x87\xA0\x1A\xB3\x2A\xBE\x41\x83\xB2\xAA\xB5\x2F\x94\xCA\x88\x04\x73\x9A\x33\x77\xCA\x9C\xB6\xA9\x75\x87\xAB\xC8\x91\xB2\x69\xB3\x24\xB7\xDB\x9C\xB2\x20\xB2\x6D\xBF\xC9\xAD\xB6\xB9\x8E\x0C\xB4\xD9\xA3\x76\x06\x07\x8D\xA8\xC6\x9C\xA8\x2B\x81\x2D\xB9\xD9\x8F\xB6\x00\x01\x2E\xBA\xBB\x42\xB3\xE9\xAF\x5B\x77\xE3\x66\x75\xD2\x91\x34\x9D\xD6\x53\x93\x35\x78\x8E\x77\xDD\xBE\x84\xF5\x74\x14\x97\xBB\x79\x69\xD7\xAC\x14\x95\xD7\x72\xAB\x21\x8A\x36\x9D\x1C\x90\xB7\x27\xB6\x74\xBA\xDD\x99\xB7\xD4\xB7\x76\xBD\x1C\x8F\x93\x69\x77\x7B\xB5\xDD\xB2\xB7\xD4\x92\x3D\x6F\xDD\xBA\x6E\xE1\xB5\x00\xBB\xBB\x7C\xB2\xE6\xB7\x4D\xB2\xD7\x9A\xA5\xE1\x92\x5D\xB3\xD6\x9B\xB5\x39\x9F\xC8\xA7\xD5\x83\xB8\xEF\xB2\x0B\xA2\xE0\xAD\xB3\x53\xB5\x3A\x75\xCD\x84\xB8\x6A\xB4\x59\xB8", - "\x69\x9A\xB3\x0D\xB8\x4D\xB7\xD4\xB8\xB5\x11\xBB\x3B\xAC\xB3\x92\xB8\x1E\xB4\x38\xB6\xCE\x80\xB5\x77\xB7\x7F\xB6\xD1\x80\x00\x6D\xA8\x87\xB2\xD4\xBF\xB5\xC7\xAF\x87\xB3\xD2\x95\xB8\x5C\xB4\x48\xB6\x3E\xAB\xB8\x07\xB8\x83\xBE\xCF\x9F\xA1\x0B\xB8\x45\xB6\xD5\x99\xA4\x00\x00\xD7\xA0\xE1\xA1\xB8\x7E\xB7\xDE\xA1\xB6\xBD\xB5\x16\xB9\x6E\xA1\x72\x80\xB9\x2D\xB8\x80\xB2\x10\x0E\xB4\x37\xBA\x88\xBE\xD4\x99\x9A\x35\xB9\x87\xBD\xE3\xB4\x9C\x1D\xB7\x89\xBE\xD2\xA8\xB8\x82\xAE\x2E\xAF\xD2\x8A\xB9\xD7\xB0\xA9\xA5\xD4\x91\xB9\x6B\xB7\x94\xBE\xE5\x81\x5E\x8A\xAE\x97\xBC\xE2\x99\xB9\xE7\x8B\x3E\xB1\xE3\xB6\xB8\xA1\xAF\xBB\x84\xE4\x97\xB8\x73\xB7\x62\x99\xE4\xBD\xB8\xE4\xB2\x4E\xBD\xE4\x92\xB9\x63\xB9\x52\xB6\xE5\x94\xB9\x62\xBB\x99\xBC\xA7\xBA\x9C\x50\xB7\x8E\xB8\xE0\xBE\xB7\xCE\x88\xEE\xA0\xE8\x81\xB9\xCC\xB2\x96\xB6\x8C\xB3\xB9\x5D\xB9\x9D\xB8\x97\x90\x04\x55\xB7\xA0\xB5\xE4\x84\xBA\xB9\x8E\x56\xBF\xE6\x90\xBA\xED\xB0\xBC\xAB\x9B\xAB\xB9\x19\xB9\x82\xB0\x11\x26\xB5\x82\xB4\x5A\xBC\xE5\xA6\xB8\x89\xBB\x8C\xBA\x9C\x81\xAC\x98", - "\xB8\x8F\xBE\x55\xB0\xA3\xBC\xB2\xF7\xAE\xE7\xB2\xB8\x5D\xB4\x44\x0A\xD7\xA7\xB5\x64\x99\xA9\xBF\xE7\xA5\xB4\x3E\xBA\x2F\x9B\xBE\xB2\xBA\xAC\xBA\x8B\xB1\xE0\x9F\xBA\xAB\xB8\x9A\xB1\xB4\x86\xB8\x18\xBA\xA9\xBB\xE4\x90\xB3\xBD\xBA\x93\xB9\xD3\x94\x04\x0F\xBB\xA4\xBF\xE8\xBF\xAD\x1F\xA4\xAE\xBE\xEB\x97\xB9\x70\xBA\x9E\xB7\xAD\xB1\x9B\x88\xB8\xA8\xB6\xED\xA1\x98\xCE\xBA\xB1\xBB\xE4\xA5\xB8\xC5\xB8\x9D\xB9\xCC\xAA\xB8\x90\xAE\xB4\xB1\xEA\xB8\xB8\x51\xAC\x96\xB9\xE9\xA9\xB9\x14\x06\x3E\xB7\xED\x8A\xBB\x64\xBB\x3F\xBC\xEB\xAC\xBB\xE7\xB8\xAD\xB7\xA8\xAF\xBB\x8E\xB8\x9B\xB5\xA6\xA8\xAD\xF5\xB9\xBC\xB0\xED\xB7\x8A\xD9\xBA\xB7\xB8\xE3\xA6\xB6\xF9\xBA\xB0\xBD\xD3\xA5\xA5\xFD\xBB\xB8\xBD\xE6\x8A\xB5\xCD\xAA\xB8\xBB\xEE\x82\xAF\x3E\xB7\x96\xB0\xE2\xB3\xBA\xFB\xBB\x92\xB1\xE6\x8A\xBA\x10\xBC\x9E\xB1\x78\x6D\xB4\x14\xBD\xAE\xBF\xE4\xBB\xAA\x0F\xBE\xC6\xB4\xE9\xAA\xAE\x36\xB4\xAD\xB9\xF1\x8F\xBB\x50\x92\xB1\xA8\xE7\xA3\xBC\x75\xAE\xA1\xBC\x99\x95\xBB\xDD\xBA\xC1\xB1\xE8\xBD\xB9\xF0\xBA\xC0\xBA\xEF\x95\xB9\x82\xBA\xC8\xBA\xF0", - "\xA8\xAE\x2A\xBC\xB3\xA5\xF0\x8B\xBC\xF2\xBA\x6E\x9C\xF2\xB1\xBC\x15\xBD\x39\xBE\x00\xBB\xBC\x2D\xBC\xB9\xAE\xD5\x96\x97\x60\xB4\xD1\xB0\xF4\x82\xA9\x9B\xBB\xF3\xAF\xF3\x81\xBC\x41\xBF\xF4\xA4\xEA\x8F\xBD\x36\xBD\xB0\xB9\x3B\x88\xAC\xB0\xBB\x2B\x94\xF5\x91\xBC\xF6\xB8\x75\x7F\xEA\x9D\xBA\xB1\xBB\xD6\xB7\xF2\xB7\xBC\xD1\xB6\xAD\xBC\xCB\xAC\xAF\x05\xAA\xFB\xA5\xBF\xBB\xB9\xF1\xAD\x04\xBA\xCD\x85\xB6\x39\x9D\x63\xB7\xDA\xA0\xA8\x00\x01\x16\xB2\xCB\xA4\xB6\x2B\x82\xDC\xB0\xC1\xA6\xA8\x75\xBD\x64\xB3\xD9\x8B\xB7\x34\xB1\x43\xA7\xD9\x8D\x9A\x91\xB7\x67\xB0\xDB\xB7\xB1\x91\xB4\xC0\xB5\xC9\xBF\x77\x8D\xB9\x7A\xA6\xDE\x6B\xB6\x1D\xB1\x64\xBF\xDA\xBF\x03\xB1\xB5\xB0\x63\xDB\x8E\xBE\x9D\xB6\x6E\xBF\xDB\x8B\xB6\x29\xAB\xE6\xB7\xDC\xB9\xA8\x9E\xB0\x01\xB1\x22\x97\xBE\xF4\xAF\xE3\xBD\x4B\x82\xB7\x80\xBD\x1B\xB2\x10\x06\xB7\xA3\xB5\x27\xB7\xFC\x4A\xB7\xF8\xAC\x73\xBE\xDC\xAD\xAE\x81\x5C\x67\x72\xF4\xA7\x9F\x71\x9D\xE0\x52\xDA\xA1\xBB\x71\x6E\x04\x09\xFB\x94\x04\xBE\xBD\xE1\xAB\x59\xBF\xBE\x40\x98\xF1\xBC\x10\x26\x01\xC6\xBE", - "\x41\x08\xD0\x42\xBF\x14\x07\xEE\xB6\xE6\xB1\x6D\x1A\x01\xF2\xB3\x10\x11\xBF\xCC\xBC\x44\x08\x05\x12\xBF\x02\x04\xDA\xB9\x93\xA2\x56\xD8\xBC\x00\x0E\x38\x95\xBF\x46\x99\xF7\xB9\xF0\xB8\xB8\x56\x01\xF7\xBE\xC8\xB7\xBE\x84\xAC\xBD\xB0\x46\xA3\xBF\xBA\xB9\x23\xBD\xFD\x86\x78\x0C\xBE\x41\x0F\x81\x7F\xAB\xB6\xBC\x3E\xB9\x33\x1D\xBF\xCE\xBE\xD1\xB0\x11\x01\xBF\xEA\xBC\xA5\x8C\xFF\x9D\xBC\x98\x98\xFB\xB5\xA6\x82\xC0\x23\xB8\xF2\xB0\xFE\x8A\xBF\xF8\xBD\xF7\xB4\xFD\xBD\xBF\x50\x93\x02\xC0\x00\xFB\xB9\xD7\xBF\x01\xC3\x10\x1A\xBF\xF1\xBF\x40\x07\xFE\xB6\xBF\x02\x07\xF7\xBC\x00\xFA\xB7\x04\xC2\x4B\xA0\x77\x92\xC0\x02\x05\xF9\xB0\x02\xC0\x00\x17\xC2\xA8\xB9\xFE\x8F\xC0\x7C\x91\x07\xC1\xA5\x86\x04\x25\xC0\x8E\xB0\xFF\x83\xB4\x03\x07\xFC\xB7\xE0\x4A\x63\x70\xBF\x0A\x8D\xF6\xBC\xBD\x6F\xBF\xDA\xBC\x47\xBA\xBD\x8B\xBD\x04\xB6\xF7\xA9\xBD\x2C\xB3\x13\xBB\x9F\xBF\xC0\x33\xC1\x6D\xBB\x02\xBF\xBD\xB1\xBD\xE0\xBC\x9F\x83\xBE\xFB\xA7\x66\xB8\xF9\x86\xC1\xBD\x92\xE1\xB4\xF9\x88\xBE\xC0\xB7\x26\xAA\xF8\xA0\xB6\x8C\xBD\x64\xBF\xA9\xB3", - "\xBD\x19\xB2\x07\xBD\xFA\xBD\xB6\x9A\xBE\xE8\xBF\x03\xA4\xBE\xFE\xA6\xE9\xB9\x3B\x93\xBE\x95\xBF\x51\x74\x06\xFF\x03\x35\xC2\x6B\xBB\xDB\xB7\xBD\xAE\xBE\x6F\xB2\x06\xCF\x60\x6B\xC1\x1B\xC1\xDC\xAD\xB2\x55\xC0\xA6\x90\xFB\x96\xB1\x4A\xC3\xEC\xB1\xDB\x73\x71\x66\x69\x2C\xB0\x04\xC9\x62\x53\x64\x20\xBC\xF9\xA5\xA7\x87\xB6\x83\x95\xC8\x80\x00\x82\xC1\x11\xC3\xD1\x42\xC1\x73\xC0\x45\x04\x04\xCE\x04\x85\xC3\x22\xCD\x08\xF4\xB6\x8F\xC1\xDC\xBA\xD8\x81\x72\x98\x70\x2C\xBE\xF7\x9A\x9F\x8A\xC2\x2A\xB7\x08\xCB\x9A\x84\xBD\x28\xCF\xCA\x86\x04\x97\xC3\x13\xC9\x09\xEB\x80\x52\xC1\x1A\xC1\xB3\x79\xBF\x98\xB3\x65\x85\xC5\x54\x04\xA9\xC1\xE9\xB9\xF9\xBD\x92\x57\xC3\xE1\xBA\xD5\x4D\xBE\x09\x05\x25\xC2\x0A\xDF\xBE\x15\xB2\xA7\x9C\xDA\x91\x6B\x9D\xC0\x2A\xC2\xF9\xAF\xC1\xB1\xC3\x29\xAE\xCC\x75\xC2\x65\xC3\x2D\xC7\x06\xC8\xC3\xA8\xB0\x1E\x71\x08\xC7\xC3\x9E\xBC\x23\xBE\xE6\x87\x75\xCC\xC0\x1B\xCA\x03\xE2\x92\x68\xC2\x29\xBB\x60\x96\xC2\x91\xB4\xEA\xB9\x04\xEA\xBE\x00\x00\xEB\xB2\xC7\x4A\xC3\xC1\x69\x36\xC6\x07\xDB\xA2\x7B\xC2\x63", - "\xBD\x07\xCA\xBD\x50\xBF\xE8\xA6\xD9\xA2\xBD\x79\xB9\xAB\xB4\xED\x9B\xC0\x28\xBE\xBF\xBC\xC1\x44\xBB\x4B\xBC\xC9\xB5\x0F\xDC\x70\xC9\xB9\x3C\xCE\x0F\xF1\xB9\xAC\x80\x3D\xC9\x0F\xEE\xBC\x1F\xBE\xB6\xB3\xF0\xBB\xBA\x28\xC0\x42\xCB\xEC\xAB\xC0\x78\xAA\x41\xC4\xF6\xA8\xBB\x4F\xA2\x44\xC6\xF5\x95\xBA\x4B\xAD\x43\xCC\xF3\x9C\xBD\x64\xA5\x44\xC8\x0F\xD3\xC4\x55\xBC\x07\x7A\xEE\x85\xBD\x24\xC6\xA6\xBC\x10\x3A\xB8\xFD\xC2\x42\xC3\xF3\xB5\xBA\x05\xB5\x49\xC2\x10\xE9\xBC\x14\x04\xBE\xB1\x12\xD1\xBB\xF6\xC3\x56\xA6\x11\xE6\xBB\xFF\xA1\x1F\xB7\x13\xF4\xC4\x6D\xBB\x16\xCF\x12\xFA\xC3\x1B\xBC\x51\xB7\xE8\x9F\xC4\x17\xC7\x40\xC1\x1C\xB7\xB9\xFF\xC0\x4F\xC1\x14\xCC\x04\x13\xBC\x48\xCC\x11\xF9\xC4\xB6\xAB\x4E\xC9\x10\xC0\xC5\xD4\x76\x4C\xBF\x10\xEB\xC4\xC5\xB0\x3A\xCF\x13\xCE\xC4\xED\xBB\x63\xAC\xFB\xB8\xC4\x51\xBE\x09\xCF\xD4\xA5\xAE\x5F\xC6\x52\xC3\x15\xD4\xAE\x0D\xBF\x50\xCA\x11\xEE\xC4\x33\xC7\x88\xB8\xF0\xB0\xC3\x6D\xC7\x92\xBF\x16\xD2\xC5\x57\xC6\xCC\xBD\x4B\xBC\xC2\x63\xBD\x51\xCA\x12\xFD\x92\x92\xBB\x56\xCB\x11\xD6\xBC", - "\x47\xBD\x96\x99\xF4\xB4\xC5\x5D\xBC\xB3\xB4\x11\x1C\xBA\x3C\x0A\x99\x64\x9C\xBF\xC5\x49\xC7\xB1\xB0\x11\x2E\xB5\x89\xC6\xF5\xA0\x17\xCF\xC5\x1F\xA3\xF6\xAF\xD5\x94\x04\xAA\xB9\x4A\xC4\x15\xC6\xC6\xAE\xBA\x76\xA4\x18\xD8\xC5\x4E\xC4\x14\x91\xD8\x91\xC6\xC1\x93\x64\xC9\x17\xED\xBF\x4B\xC3\x67\xC6\x17\xD5\xC6\xE1\xB0\x8C\xBA\x17\xDB\xC6\x10\xC6\x40\x0C\x0F\xFE\xC5\x6C\xC7\x50\xBE\xB2\xAA\xC6\x61\xC5\x4D\xC3\x10\x14\xB8\xA1\xC5\x63\xC5\x17\xF9\xC6\x60\xC6\x3C\xCC\x10\xEE\xC6\xC1\xC6\x51\xC4\xEE\xA6\xC6\xBE\xC7\x42\xC2\x10\x1C\xBB\x9A\xC4\x57\xCB\x12\xF0\xB3\x44\xC5\x71\xCB\x17\xFF\xA4\xC8\xC7\x41\xCE\xB9\xA3\xC4\xCD\xC4\x63\xC9\x15\xE7\xC4\xD5\xC5\x6F\xC8\x01\xC0\x00\x2D\xC5\x76\xC5\x1B\xC0\xC6\x43\xB8\x6E\xCE\xF1\x9C\xC6\x6D\xAD\x74\xC6\x16\xE8\xC7\x98\xA9\x77\xCF\x1A\xE2\x92\x3E\xC5\x5C\xC5\x18\xDD\xC5\xAB\xAC\x59\xCF\xFC\x92\xC7\xB0\xC5\x47\xC3\x16\xE2\xB4\x65\xC7\x59\xCA\x1D\xDF\x8B\xEE\xC4\x7E\xC8\x16\xD1\xC5\xEA\xC6\x7F\xC3\x1E\xF5\xBA\x56\xC7\x7C\xC0\x1A\xDA\xB4\xD2\xC3\x81\xC6\x1D\xDA\xB8\x5E\xC7\x7D\xCB", - "\x1E\xCA\xC8\x8B\xB9\x5A\xCB\xF2\x85\xC8\xBF\xC7\x79\xCE\x76\x88\xC5\x0F\xCA\x78\xCB\xFD\xB5\xC7\xFC\xC6\x84\xC6\x20\xDE\xC8\xE9\xB4\x9F\xB6\x1F\xFF\xC7\xEF\xC7\xC4\xA5\xAE\x98\xC8\x14\xC8\x70\xC5\xA6\xBD\xC5\xF2\xC7\x82\xCE\xE1\x8C\x04\xF1\xAB\x5E\xB3\xAF\xAB\xC5\x24\xC9\x8C\xC5\x21\xCC\x8D\x4E\xBC\x8B\xC2\x23\xD3\xC8\x3C\x83\xD4\xBE\x23\xEB\xC6\x1A\xCB\x13\x85\xD7\x83\xC9\x2E\xCB\x88\xC6\x43\x9F\xBD\xA4\xC5\xD8\xB8\x24\xC5\xC9\x44\xC8\xC8\xB2\x10\x23\xC6\x14\x0A\xC6\xA3\x9E\x9B\xC3\xA9\x6F\x0D\xC8\xDA\xB9\xC0\x66\xC3\x26\xAC\x03\xD8\xC1\x3E\xC1\x64\xBF\x25\xFA\xC2\xFF\x77\x24\xCA\x0A\xC3\x78\xC7\x7C\x12\xCC\x07\xE4\xC3\x06\xB0\x96\xCE\x13\x98\xB6\xE3\xC3\x2D\xB2\x10\x0E\xC1\xB6\xC0\x14\xC9\x3B\xAD\xC2\x54\xC3\x28\xCB\x7E\xBE\xB1\x79\xC3\x9E\xB1\x1F\xE0\xC9\x7C\xBE\x17\xC8\xDB\x88\xB7\x6E\xC1\x35\xC3\x28\xE0\xBE\x28\xB1\x24\xCD\x6B\x94\xC3\x8A\xC8\x04\xAA\x27\xC9\xCA\x60\xB1\x65\xB0\x80\xA1\xC3\x78\xC3\xA3\xC9\x73\xAD\xC3\x5C\xC2\xEC\xBF\x66\xB6\xC9\x9B\xA2\x96\xC4\xF7\x9C\xC9\xCE\xC2\x97\xCB\x09\xDF\xC1\x92", - "\xB1\x2F\x93\x26\xD3\xC1\x5A\x76\x99\xC5\x27\xEB\xC2\xBD\x92\x9A\xCE\x0E\xEC\xC9\x4C\xC1\xA3\xCC\xC0\xBD\xC9\x7C\x90\x9E\xC1\xDA\x89\xBE\x7C\xCA\xA5\xC0\xF9\xB2\xCA\x19\xA8\xA3\xC1\x29\xC4\xB7\x93\xC8\xAD\xCC\x0D\xD0\xC3\x98\xC0\x9A\xC2\x07\xFF\xCA\xF8\x76\x41\x05\x07\xEE\xC9\xFC\x9C\xB1\xC7\x26\xD8\x78\xAC\xB3\x7E\xA6\x0E\xFC\xB6\xA5\xC9\xEE\x88\x29\xFB\xBD\xA8\xB6\x1F\xC9\x0C\xF2\x76\xA7\xC2\x19\xB1\xC4\xBE\x75\x7A\xB0\x30\xC7\xC2\xB9\x9C\x9E\xC9\x06\xBA\xCD\x81\x98\xE0\xC2\xB0\xC9\xBA\x67\xCA\xAE\xC0\x60\x7A\x2A\xC9\xB1\xE0\xCA\x21\xC2\x2E\xCE\xB1\x9A\xC3\x10\xC1\x61\xBF\xC2\xA4\xC9\x6E\xBD\x2A\xE0\xC2\xD1\x6A\xED\xBF\x80\x6A\xC3\xCC\xCA\x0D\x90\x27\xEB\xC9\x72\xC8\x67\x57\x2F\xDD\xCB\x86\xB1\xE1\xBF\xCE\x70\xC2\xD1\xC2\xE5\x68\x30\xCC\xC2\xB8\xCB\x7E\xA8\x17\xFF\x03\xE8\xC8\xBE\xC7\x28\xC1\xC3\xD4\x77\x9F\xC4\x26\xD1\xB0\x82\xCA\x16\xBC\xB5\x69\xCB\xBA\xC9\xA1\xCC\x2B\xE7\xA8\xFD\xC9\xB8\xC9\x2F\xC4\xCA\xCF\xC2\xA1\xCE\x31\xDC\xCB\x4A\x70\x44\x00\x30\xDD\xC9\x98\x99\x37\xC6\xC9\x87\xCC\x2D\xCE\x27\xCA\x2E", - "\xFE\x84\x32\xCF\x8B\xA4\x33\xF3\xC2\x2E\xCC\xA5\xC2\x2D\xFB\xCC\xD3\xC3\xCD\xCD\x1C\x97\xCB\x3D\xC0\xDF\xBA\x2D\xF9\xC8\x94\xC4\xD3\xB7\x0F\xF8\xC8\xB4\xC4\xD2\xC0\x45\x80\xBB\x02\xC8\x8A\xC8\x1A\xF3\xC6\x3A\xC9\x92\xCC\x1E\xC3\x04\x01\xC5\xD5\xC0\x25\xC1\xBD\xCD\xBA\x79\xC6\x1C\xD1\xCD\x0E\xCA\x77\xC2\xE6\x41\xC8\x40\xCB\x8E\xCE\x11\xCC\xCD\x5A\xCF\xD7\xC5\xA6\x8C\xC7\x4D\xCD\xDB\xCD\xF3\xA0\xBB\x22\xC9\x86\xCA\x36\xE3\xB8\xE5\xB9\xD9\xC6\x35\xCA\xC7\x95\x88\xD9\xCA\x24\xC1\xAD\x28\xC6\xDB\xC9\x34\xF3\xCD\xC7\x7D\x78\xCE\x37\xE7\xC6\x4B\xC6\x41\x02\x13\xFF\xCD\xD3\xC4\x46\xC0\x11\x08\xB9\x83\xCD\x72\xC2\xE4\xBA\xC4\x4F\xC8\xE0\xC4\x1F\xC3\x04\x1A\xCE\xE3\xC1\x25\xF0\xC4\x42\xC7\x85\xC8\x36\xC8\xCE\xF9\xC6\xD9\xCB\x1F\xFF\xB4\xC4\xC6\xDD\xCB\x35\xC2\xC7\xB4\x76\xD7\xC9\x38\xFE\xC3\x17\xBE\xDE\xC2\x37\xFA\xAA\x95\xAD\xE4\xC7\x3A\xEF\xCE\x7C\x91\xB0\xA0\x36\xCE\xCD\xE8\xBC\x3B\x76\x3A\xDD\xCE\x5C\xCF\xB2\xA6\x43\xAA\xC0\x3F\xCB\xDE\xC9\xB9\xBA\xCE\xEB\xBE\xEA\xCD\x22\xE4\xCE\x26\xC9\x88\xC2\x35\xE2\xCE\x86\xA8", - "\xF0\xCC\x31\x82\xCF\xBD\xCF\x92\xB3\x31\xDD\xC8\x8D\xCF\x76\xC6\x10\x30\xC8\x9C\xCE\x73\xC5\xE8\x81\xC6\xA3\x9F\x60\xCE\x3A\xF8\xCE\xA3\xCC\xA6\x98\x18\xD5\xC9\xCE\x73\x62\xC1\x36\xE9\xC8\x10\xCB\xA8\xBC\xCB\xB9\xB7\xD0\xCD\xDA\xCC\x3A\xD1\x88\x47\xCB\xE6\xC4\x38\xFE\xCE\xEA\xA9\x67\xCC\xCB\xA5\xAF\xB4\xCD\xFA\xC6\x1B\xC6\x04\x54\xCB\x7C\x06\x25\xC4\xB6\x01\xCC\x18\x95\x2E\xCC\xB7\xA0\xC8\xA7\xC6\xBF\xA3\xCA\x17\xCF\xB8\xC9\xF7\x84\xD0\xD4\xCA\xBE\xC9\x3B\xAE\xCA\x99\xCA\x12\xCD\x26\xF0\xCC\x7B\xBB\xC0\xCF\x2A\xC5\xCC\x74\xC9\x33\xC2\x40\xFB\xB9\xB6\xCB\x7F\x7C\x30\xC5\xCB\xD0\xC8\x1F\xA9\x2B\xF3\xCB\x7C\xB0\xC1\xB1\xF9\x82\xCD\x36\x91\xCE\xC1\xC1\x8B\xCB\x10\xD3\xAA\x9E\x2C\xEB\xCA\xC6\xC9\x18\xC8\x2C\xF5\x9A\xBE\xCB\x70\xB9\x2C\xC1\xCB\x21\xCF\x1D\xCF\x33\xE4\xD0\x60\x90\xD1\xC0\x28\xD9\xCB\x2A\x7A\x85\x8A\x4C\xB4\xB7\xEC\xB6\x8C\x70\xDF\xB3\x69\xED\xB5\x10\xD8\xDD\x93\xB7\x42\xD1\x8E\x76\xDF\xB3\x75\x3A\x6B\x78\xB6\x23\xE5\xB7\x9B\xC8\xAB\xC9\x3B\xBF\xCF\x4A\xC1\x00\xD2\x45\xE2\xCA\xF6\xC8\x0E\xD4\x29\xAC", - "\xCB\x0F\x77\xBB\xCA\x0D\xE9\xD0\xA2\x90\x03\xD8\x2D\xF4\xBD\x0F\xD1\xA8\xC8\x69\x92\xD0\x0D\xD0\x39\xC5\x41\xDF\xD1\x66\xD0\x06\xDB\x30\xD1\xCC\x23\xCD\x6A\xB5\x43\xDB\xA2\x95\xCD\xBB\xC1\x22\x9D\xCC\x70\xC0\x18\xC2\x32\xEF\xD0\xB2\xB5\x0C\xD9\xFA\x85\xCC\x28\xD1\x1B\xDA\x42\xEA\xCC\x79\xD1\xB5\xCB\x89\xA6\xD0\x7C\xBD\x20\xD7\x41\xFC\x91\xE2\xC0\xC1\xC2\x29\xEB\xBE\x91\xB6\x0E\xDB\x31\xC6\xCD\x63\x80\xFC\xC6\x39\xC1\xA7\x48\xA8\xE7\x7C\x3C\xD7\xCE\x7C\x91\x26\xD4\x11\x03\x81\xEA\xCC\xF7\xC8\x3A\xCA\xB8\xBC\x7F\xF6\xC6\x3D\xF7\xCD\xB2\x8C\xD9\x76\x4A\xC7\xCF\x8E\xC4\x43\x0A\xCD\x9A\xD2\xB7\xCF\x29\xDD\x3D\xFB\xB9\xA0\xD1\xF5\xCC\x4A\xDE\xC0\xC3\xC7\xFB\x7B\x49\xE8\xD2\x9E\xCE\xD0\xAA\x4A\xEE\xCF\x97\xD3\x2C\xD6\x8A\x89\x7B\x95\xD3\xEA\xC2\x4A\xEB\xCF\x2F\xBA\x2E\xD1\x4B\xF7\xD2\x78\xCC\x4C\xA0\x4B\xEB\xD2\xE3\xCF\x8C\xC9\xCF\x85\xD3\xC3\xCE\xE4\xCF\x38\xDE\x8A\xD4\xD1\xF3\xC5\x4D\xD8\xCE\x51\xA7\x2F\xD1\x3A\xD6\xD2\xF6\xCC\x14\x97\x38\xD0\x91\xB5\xD3\xFB\xC6\x4C\xDD\xB9\x76\xA1\x36\xDC\x49\xF2\xD2\x52\xC8\x93", - "\xB5\x4A\xC0\xD3\xE1\xD3\x97\xBC\xC1\xAF\xD3\xDF\xD3\x39\xDC\x4C\xF6\xB9\x35\xBC\xA5\x85\x4E\xC1\xD3\xD6\xD3\xF5\xC9\x39\xFA\xBC\xDE\xD1\x7F\xC6\x4F\xD1\xD3\xE9\x71\x98\xBF\x4C\xF0\xD3\x62\xCE\x6E\xCE\xB3\x6A\xD3\xBC\xD1\x43\xDA\x38\xD5\x9D\x0C\xD6\x30\xDC\x4E\xC8\xD3\x21\xBE\x3E\xDB\x4B\xD2\xD4\x9E\xAE\xC9\xBA\xDF\xBB\xD3\xF1\xD1\x47\xD7\x14\xF9\xD3\xE4\xD3\x45\xDD\x4F\xC1\xA7\x73\xC4\x3D\xD2\x50\xDB\xD3\xC7\xD3\x30\xD0\x22\xE0\xCE\xCA\xD0\x34\xD5\x3F\xDF\xBB\x16\xC8\x40\xD6\x52\xF1\xCD\x28\xD7\x44\xD3\xED\xAF\x9F\x01\xD4\x4D\xDA\x4D\xFB\xD4\x50\xC7\x40\x04\x3D\xE1\xD4\xCB\xD0\x41\xD7\xEA\x90\x04\x35\xC9\xD6\xB7\x23\xDD\x7F\x22\xD4\xEC\xC3\x20\xD8\x92\xBC\xB2\xF8\xCD\x1C\x9C\xD4\x09\xD7\xEC\xC5\x22\xD0\xC6\xE0\xCD\xB0\x69\xDF\x87\xD4\xF5\xD1\x4D\xD7\x4F\xFD\x92\x58\xBC\xD8\xBA\xF5\xB3\xD4\x5B\xD6\x43\xD9\x3C\xF2\xCF\x97\xC4\x44\x04\x3F\xF6\x90\x50\xD4\xF9\xCF\x52\xCC\xC8\xF8\xCF\xAD\xB9\x53\xE1\xD5\x18\xD7\xBF\xAE\x49\xD0\x04\x69\xD6\x54\xD1\x4A\xCB\xD5\x82\xBF\x5B\xD2\x54\xC3\xD4\x1F\xCB\x40\x04\x35\xD6\xD4", - "\x41\xD7\x5A\xDD\xE6\x99\xCD\x80\xD6\x4B\xD1\x3D\xF0\xD4\x33\xAC\x58\xDB\x57\xDA\xD5\x38\xBF\x27\xD9\x54\xE9\xD4\xA2\x93\x5C\xD0\xEA\x41\xD6\x87\xD4\x5B\xD7\x36\xC8\xD5\x94\xD7\x5D\xDA\x22\xD4\x04\x6C\xCC\x18\x95\x57\xC8\xCF\x4A\xD6\xFE\xB3\xA7\xBA\xD5\x82\xD4\x68\xD7\x53\xD7\xD6\x2D\xD4\x42\xDA\x56\xCD\xCE\x81\x5C\x76\xC8\x56\xCF\xD6\x36\xD4\x5E\xD9\xE3\x91\xD4\x23\xD5\x5C\xD6\x12\xC4\xB4\xB4\xD5\x68\xDB\x58\xFA\xC7\x00\x03\x38\xDB\x51\xF0\xD6\x70\xD4\xA6\x9C\x38\xDE\xD6\xC0\xD7\x81\xCA\x55\x8A\xD6\xA5\xD4\x38\xD2\x88\xB9\xD6\x90\xD5\x70\xD8\x46\xB1\xD4\xBB\xCC\x73\xD1\x5B\xCE\xD7\x2A\xD4\xDF\xAC\x52\xC2\x81\xC5\xD5\x72\xD7\xFC\x46\xD4\x8E\xD5\x66\xD6\x4B\xCD\xD6\x8F\xAC\x76\xDE\x5D\xE6\xD3\x8C\xD4\x61\xA2\x5D\xD4\xD7\xD3\xD7\xBF\xAC\x63\xB4\xD5\xD9\xD5\x65\xDC\xC1\x5A\xD4\x58\xD7\x49\xDC\x53\xE2\xD5\xCF\xD7\x4A\xDE\xF0\x98\xD6\x86\xD6\x66\xD6\x5C\xCA\xCF\x50\x93\x91\x9C\x5E\xE3\xD7\xFC\xD0\x37\xD6\x5F\xEA\xC5\xF8\xD6\x6A\xD6\x57\xDF\xD7\xCD\x85\x49\xDC\xFC\x6D\xD7\xFA\xD5\x5F\xD2\x10\x13\xCC\xF1\xD6\x4E\xDB", - "\x4E\xE8\xD7\x9E\xAF\x4F\xDF\x5B\xC0\xD8\x1E\xD4\x8E\xB5\x54\xDE\xD5\x47\xD5\x6A\xD9\x55\xF3\xD7\xB6\xD5\x89\xCF\x3D\xFA\xCF\xE1\xCF\x79\xDB\x5B\xD3\xD8\xFF\xA8\x55\xD4\x62\xD6\xD5\x26\xDA\x76\xD5\x5E\xE5\xC8\x5D\xD5\x93\xCF\x55\xCB\xD8\x18\xD9\x54\xD5\xA6\x8C\xC9\x55\xD6\x93\xC4\x63\xF9\xD7\x08\xDA\x7B\xD9\xCE\x79\xCF\xF7\x07\xFE\xCB\x63\xC6\xD8\xA6\xD4\x3A\xDD\x1A\xDE\xD8\xF2\xD4\x8A\xD4\x3B\xC4\xA1\x05\xDB\x87\xDA\x64\xFE\xD8\x71\x79\x8B\xD0\x65\xFC\xD5\x25\xC8\x61\xD0\x54\xFC\xD8\xE4\xD4\x88\xD3\xE1\x92\xD9\x0D\xDB\x94\xD8\x37\xDF\xD6\xCA\xD7\x6A\xD0\x46\x92\xD6\x73\x7C\x83\xDD\x63\xC1\xAD\xCE\xD1\x77\xD8\x65\xC1\xD8\xCD\xD6\x4F\x8D\x59\xC5\xD6\x44\xD9\x98\xD2\x4D\xE8\xD6\xE2\xD7\x9A\xD9\x61\xED\xB9\x69\xDB\x7F\xD6\x67\xF6\xD8\x43\xD4\x8D\xB8\x5C\xDE\xD9\x5A\xD8\x45\xD2\x10\x3D\xCD\xC4\xD5\x8D\xD2\x66\xF7\xCF\x03\x06\xE0\xC5\x68\xFB\xD9\x87\xD8\x79\xCC\x10\x3E\xD6\x11\xD8\x85\xD7\x62\xC1\xA7\xC3\xD4\x9C\xDE\x64\xF4\xD7\x6D\xD9\x73\x89\x0B\xD7\xD8\x8C\xDB\x81\xDC\xD6\xA2\xD0\x7F\xD9\x97\xD2\x6A\xC8\xDA\x9F", - "\xCF\x7D\xD8\x64\xD2\xD8\x98\xD9\x7A\xD5\xF6\x8A\xD8\x4D\xD9\x92\xD9\x6A\xD2\xDA\x89\xAC\x97\xD7\x66\xF3\xDA\x9F\xDB\x40\x0D\xD2\x91\xDA\x93\xD9\x88\xDF\x36\xD0\xD4\xA4\xD4\xA0\xDF\x64\xF0\xC0\x6B\x66\x4F\x80\x66\xD4\xD9\xA3\xD9\xAD\xD6\x3B\xE1\xDA\xB4\xD8\x9B\xD6\x64\xFF\xD3\xD1\xD5\xAF\xD5\x6C\xCA\xDB\x9B\xD4\xB3\xD1\x3C\xCE\xDB\xC9\xDB\x9D\xD5\xA6\xAC\xDA\xA7\xD8\xAC\xDE\x6B\xE4\xD4\x48\xC4\xAE\xDE\x62\xC1\xDA\x52\xBB\x8A\xC3\x64\xD7\xDA\xBA\xD9\xB5\xD2\x16\xC0\x00\x16\xDA\xB7\xDB\x6D\xE5\xDB\xC6\xD8\x00\x0B\x61\xF2\xD8\x1D\xD9\x9D\xD1\x67\xC4\xDB\xC9\xD8\x75\x9D\x23\xE3\xDB\xAE\xD8\xBB\xD0\x6D\xE9\xD8\x42\xC8\xBE\xD8\x6A\xFA\xDB\xF1\xD2\x65\xC8\xF4\x98\xC6\xB2\xD9\x96\xDF\x6B\xFF\xCE\x64\xD7\xC0\xD6\x56\xC5\xDC\xFB\xDB\xB7\xDD\x53\xD3\xC9\x6E\xD4\xFF\xC0\x46\xD9\xC9\x89\xC3\x1C\xD3\x40\xD9\xD1\x16\xDF\x9E\xBC\x45\xE9\xCA\x9F\xC3\x7E\xA5\x46\xCB\xD2\xA2\x90\x1A\xD3\x46\xDA\xB6\x0A\xCF\x7E\xAB\x41\xCF\xCB\x8A\x9B\x9E\xC2\x31\xDA\xC1\xC3\xC0\x08\xDC\xA8\x48\xD2\xA8\xB6\x22\xD7\x45\xF1\xCC\x2B\xD2\x05\xD3\x73", - "\xFB\xB9\x30\xDC\xDD\xB2\x73\xED\xD0\x7B\xD2\x0C\xD0\x43\xDA\xD1\x50\x91\x23\xD3\x41\xCF\xD2\xE5\xC1\x24\xD8\x6C\x8C\xDC\xD6\xD9\x2B\xD3\x0F\xC8\xDB\x06\xDF\xAB\xD5\x3E\xF9\xD2\xF2\xD8\xB9\xD5\x5B\xD3\xDD\xF5\xD6\x5F\xD8\x74\xFC\xD9\xF4\xD8\x35\xB7\x75\xCD\xDA\x0D\xDD\x89\xCF\x4A\xEA\xD9\xF3\xDB\x8B\xDF\x6C\xCA\x96\xC3\xDA\xD8\xD6\x6E\xF1\x6D\x64\xDB\xEA\x76\x68\xDE\xDA\xB5\xCE\x2F\xDC\x74\xDD\xDD\x63\xDD\xB9\x94\x4C\xD4\xDB\x4D\xDC\xC0\xD2\x77\xC9\xD3\x51\xDD\xBE\xD4\x75\xD9\xDA\x25\xC9\x9E\xD3\x59\xDD\xDA\x45\xD9\xB4\xDE\x67\xFE\xDB\xDA\xD9\xDC\xD8\xE3\x84\xDA\x96\xDA\xDE\xDA\x5B\xCE\xDC\xC1\xA6\xA2\xD9\x78\xFF\xDB\x7B\xDE\xAA\xD5\x22\xD0\xDA\x60\xDE\xD4\xDB\x78\xEB\xDB\xC2\xD7\xD6\xDC\x76\xC4\xC4\x10\x07\xA6\xDA\x6E\xC6\xDE\x9B\xDF\x72\xD4\x77\xF0\xDD\x67\xDF\xC1\xBD\x6D\xD5\xDE\x8A\xDC\xDF\xD0\x7A\xEF\xBC\x27\xCA\xB0\xD6\x66\xF5\xDD\xED\xD0\x77\xDA\x67\xE1\xDD\xE0\xDA\xE4\xD7\x63\x9A\xDE\x81\xDD\xAE\xDD\x4E\xC2\x8E\xA8\xDC\xE4\xD7\x79\xEB\xDE\xD4\x77\x7A\xDF\x77\xF4\xDE\x07\xDC\xEC\xDB\xE7\xB0\xD7\xBD\xDD", - "\xE1\xD5\x7A\xD7\xDB\xA7\xDF\xEC\xD6\x79\xEA\xDE\xCB\xDD\xF6\x7D\x7C\xC3\xDF\xCF\xDE\xED\xD1\x7D\xC7\x7F\xD8\xD9\xDE\xDE\x7B\xD0\xDF\xC6\xDD\x75\xD5\x6A\xC4\xD8\xD9\xDA\xEE\xDF\x7B\xE4\xDA\x72\xD0\xE1\xD2\x7E\xDC\xDF\xF2\xD3\xF0\xA3\x7A\xC9\xDD\x59\xDD\xAD\xBF\x6E\xF9\xD8\x31\x6D\x58\xBE\x7A\xEB\xDD\xB9\xDE\x83\xD2\x9C\x8D\xD5\xB8\xDE\x9C\xD5\x7F\xF6\x90\x2A\xD9\x90\xD2\x19\xEB\xDF\x58\xDE\xD9\xD1\x3F\xEC\xCF\xA9\xB9\xFE\xDD\x7E\xC1\xDC\x14\x04\x8E\xDB\x62\xFA\xD8\xAD\xDB\xF6\xD6\x7D\xDD\xDF\x06\xAC\x43\x00\x64\xFD\x08\x42\xDB\xC9\xC8\x72\xE2\x9F\xE4\xC9\xC5\xDE\x72\xF8\x99\x08\xD1\x21\xDA\x40\xD8\xD1\x71\xD2\x17\xDB\x0E\xD8\x9A\x62\xD1\xD1\xC8\xDA\x9F\xDC\x37\xDC\x1F\x92\x72\xE6\xE0\x74\xBF\x1A\xD3\x82\xEE\xD1\x26\xDC\x1C\xDC\x47\xC1\x6B\x13\xCF\x0B\xEC\x47\xB5\xD1\x0F\x74\x1E\xD3\x08\xF8\xBD\x3D\xDF\x1F\xD4\x74\xFB\xDC\x1D\xD1\x0F\xE1\x27\xFF\xE0\x7E\xD3\x10\xE0\x2C\xE4\xCC\x1B\xE0\x09\xB4\x48\xFB\xE0\x71\xC3\x0A\x82\x74\xE9\xD1\x05\xCF\xB4\xCE\x81\xE8\xCC\xEC\xC3\xD1\xD7\x25\xD3\xDC\x3E\x84\x15\xD4\x0E\xD6", - "\xD1\x3C\xDF\x7A\xAD\x81\xCC\xE1\x7A\xD2\x17\xE8\x71\xC9\xE1\xE9\x71\x09\xEB\x43\xE4\xD1\xB1\xCB\x0C\xE7\xD4\x6E\xE0\xFD\xCC\xA5\x89\x41\xD1\xB0\x27\xDC\x0B\xD1\x84\xF9\x8E\x9B\xDA\x1D\xDF\x03\xB5\xE0\x6D\xE0\x14\x98\x83\xDA\x75\x3A\xE2\x23\xCD\x85\xC7\xD2\x35\xDC\x1B\xD0\x72\xE9\x6E\x39\xDD\x06\xB0\x84\xE9\xDC\x90\xCA\xCF\xDD\x47\xC0\xDD\xFA\xB5\x21\xEC\xDC\x87\xE2\x18\xE2\x13\xE5\x29\xE4\xE1\xB4\xB2\x15\xE2\x71\xC2\xD2\xA2\x92\x16\xE5\x30\xDC\xE1\x73\xE0\x08\xEA\x86\xF1\x6C\x22\xE1\x1E\xEA\xDF\x9B\xDC\x65\xC9\xC7\xD1\x47\xE8\xE0\x7F\xE3\x19\xD5\x0A\xD9\xDC\xB5\xCB\x1B\xDC\x88\xC7\xD7\x9F\xE0\x60\x78\x87\xD8\xE1\xCD\x87\x1E\xEF\xDF\x7D\xE1\x1C\xD0\x22\xE7\x2C\xCA\xE2\x96\xBD\x11\xEE\x48\xC7\xE1\x00\x00\x24\xE4\xA1\xBB\xE2\x3E\xE0\x30\xE2\x8C\xC3\xA0\x8A\xB3\x12\xEE\x87\xDD\xE2\x98\x9B\x13\xE3\x72\xCC\xB7\x52\xE0\x18\xE6\x48\xFA\xC1\x96\xE3\xBC\xC6\x83\xD9\xE2\x1A\xE2\x05\xE8\x31\xD0\xC2\xB1\xE1\x88\x81\x8A\xF4\xE2\x36\x90\x29\xE1\x26\xEF\xE2\x14\x06\x19\xE3\x49\xE7\xE0\x69\xE0\x2F\xEB\x86\xE5\xDC\x71\xD1\x1C", - "\xE6\x73\xE9\xE2\x7B\xB9\x1D\xEF\xD0\x73\xE2\x98\xE1\xEA\x66\x8B\xDC\xCC\xBE\xE3\xD0\xD6\x8C\xF9\xE3\x50\xE0\x11\xE4\x8E\xE6\x9A\x81\xE3\x35\xE4\x88\xC1\xE4\xA2\xE1\xE0\x5E\x8C\xEC\xE0\x19\xB1\x34\xEB\x8C\xFA\xE2\xC9\xB5\x35\xEA\x8D\xEF\xE3\xCC\xE0\xDB\xB9\x8D\xC5\xD0\xF4\xCB\x01\xD3\x86\xCF\xE4\x15\xE6\xA9\xCF\x85\xCB\xE4\x91\xE3\xBE\xCE\x71\xE9\xE3\xC5\xE3\x0C\xD3\x27\xEC\xE3\xDD\xE3\x0F\x8E\x8E\xC2\xE2\x29\xE2\x28\x92\x8F\xFB\xC2\x2C\xDF\x08\xDC\x8A\xC3\xCB\xCA\xE1\x2E\xED\x91\xE9\xCC\x71\xD3\x31\xE1\x04\xC4\xE3\x46\xE2\x48\xE1\x8C\xFC\xE3\xCF\xE2\x12\xC6\x93\xF3\xB2\x33\xAB\x24\xE8\x91\xE1\xD0\x03\x06\x24\xD8\x2A\xFF\x77\x47\xCC\xE6\xD3\x7E\xC3\xE0\x4B\xDC\xF1\xDE\x74\xF7\xD6\x50\xDE\xF2\xD0\x81\xE2\xD6\x4D\xA8\xFD\xDA\x7F\xE3\xB8\x56\xD8\xE9\xD3\x95\xE0\xD7\xAE\xD3\xEB\xDA\x95\xDF\xE5\xEC\xDC\xDE\xC0\x35\xFB\xDF\xC0\xDC\x2E\xDE\x3D\x96\xE5\x07\xE3\xB9\xDF\x66\xDB\xE5\x8C\xDE\xD2\xC8\x77\xD2\xE5\x60\xE7\xB9\xD5\x37\xD7\xE5\x69\xE5\xDC\x6E\x5A\xE5\xE5\x02\xE1\xDB\xD8\x78\xEC\xE5\x4A\xE5\xB8\xDB\x71\xA8\xE5", - "\x79\xE7\x77\xCE\x5B\xE1\xE5\xB5\xDE\xE7\xA5\x69\xFC\xE5\x78\xE4\x6F\xDB\x69\xC4\xE6\xC5\xDE\x7E\xB5\x39\xCC\xE6\x4F\xE5\x89\xC9\x7D\xF0\xE5\x90\xE7\x26\xA3\x99\xE7\xDF\x0F\xE1\xDB\xDD\x14\xDC\xDD\x95\xE6\x5F\xAE\x95\xDD\xE6\x7B\xB9\x82\xC5\x98\xD8\xE6\x9E\xAE\xEC\xC4\x96\xD7\xDF\xB1\xC7\xE7\xA0\x98\xE3\xE6\xF6\xDF\x65\xED\x96\xD1\xDE\x54\xE6\x75\xD6\x6A\xCE\xE0\x94\xE4\x62\xD2\x9B\xE0\xDF\xB4\xE4\x69\xEB\x5F\xD2\xDB\xCB\xCF\x6A\xED\x98\xD2\xCF\x11\xAB\x67\xE1\x80\xD0\xA3\xC2\xE4\xD7\xD6\xE9\xBC\xB2\xF2\xDF\x6B\xEB\x94\xED\xDD\x23\xDA\xFF\xDE\xE9\x8E\xE5\x76\xDE\x42\xD0\xB0\xA7\xCF\xC5\xE4\xDB\xD2\x70\xC2\xC6\x04\xDE\x6F\xE1\x99\xC0\xDB\x00\x02\x02\xEE\x9C\xCC\xE0\xA9\xDD\x66\xE0\x9A\xFC\x91\x13\xE0\x63\x05\x81\xE1\xE7\xB5\xE6\x65\xD9\x57\xC0\xDE\x74\xE5\x6A\xE3\x96\xED\xE7\xAC\xE5\x89\xCF\x57\xC8\xE6\xA8\xE7\x35\xD8\x35\xD5\xE7\xA7\xE4\x14\x9C\x1B\xDC\xE6\xC3\xE7\x6F\xED\x9F\xD8\xD2\xF8\xE6\x25\xD0\x1D\xD0\xE7\xB0\xE7\x6E\xE3\x77\xEC\xE7\x75\xE4\x9E\xD1\xA0\xED\xDF\x03\xE9\xF5\xD9\x9E\xF3\xD9\x7D\xAA\x76\xE1", - "\x9D\xE8\xC6\x7B\xE5\x5C\xEC\x9F\xEA\xE7\xE0\xC7\x82\xE9\x97\xD6\xA5\x12\xE9\x81\xE6\x7F\xC7\xE6\x16\xE9\xE8\xD1\xB7\x4B\xE6\xFF\xE6\xBE\xD0\xE5\x84\xE8\xCB\xE4\xE7\xD0\x5D\xD3\xDB\x08\xE9\x60\xE7\x77\xF7\xE6\x9A\xCE\x83\xEA\x9B\xCB\xD9\x79\xA5\x8B\xE1\x9F\xFB\xDA\x04\xC8\x8A\xE8\x7E\xC8\xE0\xAD\xCE\x8E\xE2\x9E\xF6\xE6\xC1\xDA\x72\xEB\xA3\xE7\xDB\x1A\xD7\x78\xEF\xA3\xF7\xAE\x30\xBD\x5F\xE7\xA4\xE8\xC6\xAE\xE6\x92\xEF\xA0\xEC\xDE\xC6\xCF\x8C\xEE\xA4\xFF\xAB\x4D\xE9\x62\xEE\x9F\xD8\xE8\xCF\xCD\x89\xEE\xA1\xD5\xC0\x3C\x0E\x86\xE7\xA3\xD4\x8A\xEF\xDF\x02\xE1\x7F\xDE\xE9\x8D\xE6\xBD\xD8\x7F\xDD\xE8\x29\xEB\xB9\xDD\x7F\xD4\xE0\xFF\xDE\x8D\xE7\xA5\xED\xB9\x31\xD8\xFC\xD4\x21\xA4\xE9\xDB\xE4\xA5\x8E\x9D\xEC\xE9\xB6\x9C\x9D\xE3\xA1\xFF\xD8\x11\xDE\x35\xE5\x90\xF5\x62\xFB\xA4\x27\xEC\x90\xDA\xE4\x17\xE4\x45\xE4\x94\xC9\xB6\x85\xE9\x02\xD4\x85\xE4\xE0\xFC\xC8\x25\xE7\xFC\x6B\xE0\x67\xE0\xC9\xDF\x8F\xCC\x04\x6F\xE0\xDF\xB7\x92\xC2\xE4\x3E\x87\x4A\xE9\x05\xD3\xEA\xA0\xD9\x49\xEF\x80\x78\xE2\x17\xE3\x30\xEE\x42\xEA\xE3\x31", - "\x6F\x4F\xEC\x83\xF4\xE4\x9E\xE8\x45\x06\xAA\xCD\xE1\x42\xE3\x2F\xEA\x93\xEB\xEA\x61\xE0\x20\xE1\x93\xE1\xEA\xC8\xE1\xB0\x92\x94\xC6\xEA\x19\xA2\x43\xE8\x9E\xD2\xE9\x38\xE9\x54\xEC\xAB\xF5\xE7\x61\xA8\x9A\xE3\xA4\xF8\xB8\xF3\xE5\x88\xE9\x9F\xED\xDD\x59\xE6\x91\xE0\x97\xDD\xCD\x6E\xE9\x9D\xE4\x9F\xCF\xEB\xC6\xEB\x88\xBF\x9E\xC9\xE8\xC7\xEA\xBD\x9A\xA7\xDB\xE9\x60\x93\x5A\xE1\xAD\xD4\xEB\x74\xCF\xB5\xEB\x9C\xCD\xE8\xBB\xEA\x90\xE9\x99\xED\xD6\xDE\xE8\xFA\xD1\x78\x55\xE8\xCA\xEB\xAF\xEC\x94\xC9\xDA\xE5\xEB\xB8\xE1\x13\xED\xEB\x8C\xC5\x3A\xD2\xAC\xCB\xE9\xE9\x70\x89\xE7\xA1\xD6\xE7\xF3\xD2\x8F\xEF\xA4\xFD\xD9\x03\xD9\x8C\xE1\xAE\xD3\xE9\x34\xE8\x6F\xED\x5F\xF0\xEB\x06\xEA\x25\xA2\xA3\xE2\xEB\xF1\xE9\x99\xBB\xAF\xDC\xEB\x66\xE6\x7B\x64\xB0\xC1\xEC\x0D\xC8\xC2\xEA\xAE\xF5\xBA\x45\xEA\x96\xE9\xA6\xC8\xE9\xAD\xDE\xC4\xEA\xB1\xD2\xE6\x1C\xCA\xC5\xE3\xAC\xE0\x7D\x1D\xEF\xBD\xE5\xAD\xDF\xD4\x49\xEA\x95\xEE\xAC\xE9\xDF\xAF\xA7\xBC\xEB\xB0\xE9\xE6\x16\xD9\xBA\xEB\xB1\xE0\x91\x61\xEB\x77\xE3\xA6\xEA\xEC\x13\xEE\x62\x9D\x9C", - "\xF8\xE9\xE3\xA0\xCD\xEF\xB2\xE9\xB8\x6D\xB5\xBF\xD7\xB0\xC0\xEC\xAC\xD4\xAA\xB5\x56\xCC\x04\x99\xC4\xD0\xE6\xB2\xC4\xCF\x77\xEA\x79\xEE\xCC\x67\xD5\x47\xEC\xB6\xE4\x7E\xE5\xE7\x0F\x74\x05\xCD\xB4\xD7\xEC\x1C\x73\xB4\xEE\xA2\xC6\xE7\x47\xD9\x6E\xEB\xB3\xD0\xEB\xDB\x99\xB3\xEB\xA7\xFC\xEB\xF7\xE6\xCE\xE6\xB4\xFC\xEC\x89\xD6\xBE\xE5\xB3\xDE\xEC\xF4\xEA\xD2\xDE\xAB\xDB\xED\xDB\xE9\x6A\xE3\x97\xCC\xEC\x57\xEC\x07\x7A\xAD\xEE\xEC\x63\xEC\xD4\xAF\xB0\xC1\xED\x70\xCF\xCA\xEF\xA5\xEB\xEB\x11\xEA\xD7\xEE\xB4\xCE\xDA\xD8\xD2\xD8\xE3\xB5\xE7\xD6\x3F\xBA\xE0\xE0\xAC\xC1\xA7\x83\xE4\xDA\xEB\xAC\xD2\xAA\x77\xED\xAF\xE2\x10\x36\xEB\x22\xE8\xBE\xEA\x6F\x4D\xEE\xF5\xD8\x7F\xDC\x01\xD4\xEE\x5C\xEE\xE5\xE3\xFC\x86\xEE\xD0\xEB\x77\xCB\x99\xD1\xEE\x23\xED\xDC\x68\xF1\x8A\xEE\x67\xED\xDC\x62\x9A\xEF\xE9\xA1\xEC\x07\x76\x9A\xF0\xE7\xA8\xEC\x75\x75\xB1\xE2\xEC\xAC\xED\x1C\x91\xB2\xE0\xEE\xB1\xEE\x65\xE3\xBB\xE9\xEE\xB8\xEE\xF4\xD0\x52\xED\xED\x7B\xED\xDB\xD5\xA5\xC7\xEE\x5F\xEE\xF3\xC8\xB9\xFC\xEE\x7C\xC7\xF0\xEA\xA2\xC0\x8D\x97\xB8", - "\xE7\xE4\xBC\xC1\xA7\x37\xEE\xD2\xEF\x9C\xFF\xEC\x83\xEE\xBB\xEF\x18\xFE\xEC\xFF\xE9\xF4\xE9\xB0\xC7\xAC\xED\xCC\xF4\xE0\xBC\xFF\xED\xFA\xB5\xD2\xEF\xD0\x4C\xED\xDB\xEC\xD5\xE6\xE4\xA6\xBD\x43\xEE\x41\x02\xB5\xE1\xEF\x1F\xED\x3A\x76\xB5\xFD\xEE\x3C\xEB\xD2\xCA\xBD\xDD\xEE\xBD\xC5\xD7\xE6\xB6\xEC\xED\xC0\xE6\x46\xAA\xBC\xF4\xED\x60\x93\x7E\xE4\xBB\xF0\xED\xEC\xEC\xE9\xE5\xF6\xAB\xEF\xAD\xEC\xFF\xED\x4B\xAF\xED\x71\xED\xEE\xE7\xFC\x73\xED\xFE\xED\xDD\xEA\xDF\x84\xF0\xFD\xEC\xEC\xE7\xFC\x4C\xF0\x01\xF1\x01\xF4\xDD\x77\xE5\xE8\xED\xDA\xED\xB0\xE8\xEB\x09\xF2\xF5\xEF\xAF\x8E\xDE\xF0\xEE\x03\xF9\x9A\xC9\xEE\x1E\xF1\x03\xFC\xC1\x60\xE8\xF8\xED\xE5\xED\x79\xC6\xEF\x2F\xEB\x45\xB7\xBF\xD9\xF0\x1A\x8F\xED\xE5\xBB\xDC\xEF\x99\x96\x0B\xF2\xC0\xE7\xEC\x8A\x97\xE7\xE6\xC0\xD2\xF0\x2C\xB4\x0A\xF8\xB5\xFD\xE8\xEF\xEF\xF2\xE6\xA2\xF2\xC2\x7A\xED\x04\xFB\x02\xAF\xEE\xFB\xEC\x0E\xFB\x21\xFB\xEE\x25\xF1\x07\xF0\xB2\xC8\xF1\x2C\xF2\x12\xF0\xA5\xD7\xD7\x41\xF0\x0D\xF4\xB2\xD9\xEC\x0A\xF1\x12\xF5\xEB\x99\xE9\x21\xF2\x10\xFD\x4B\xED", - "\xEC\x4D\xF2\x0F\xF8\x69\xB1\xEC\x38\xEF\xCC\xEE\xB7\xE2\xEF\x60\xEE\x40\x0D\xBC\xCF\x74\x4E\xD5\x15\xFD\xC5\xDF\x97\xD4\xE7\x0A\xF9\xC5\xD7\xBD\xD9\xED\xF5\xE5\xC1\xD7\xEF\xF1\x96\x67\xC3\xC6\xE9\xEF\x6A\xEC\xC4\xD7\xF6\x9F\xC3\x08\x9B\x1E\x0F\x2D\xDA\xC5\x31\x6E\x1F\xFC\xA9\xC3\x04\x9A\xE0\xD1\xD7\x2E\xC0\xF1\xCE\x72\x20\xFF\x92\xEB\xCB\x1B\xE4\x25\xC8\xC8\xC1\x6B\x8A\xF2\xA3\xE5\x2F\xE1\xE0\x7C\xF3\xC3\xC1\xC9\xC3\xE5\x8C\x6A\x39\xE7\x94\xD1\xB0\x63\xB3\x23\xF7\xD4\x57\xF2\xB8\xE9\xDC\x60\xA9\xE7\xE3\x2D\xE1\x25\xF5\x33\xC6\x04\xA0\xF2\xA2\xE8\x28\xDE\xB6\xAE\xE0\x31\xCA\x97\x69\xF2\x53\xE3\x2A\xFE\x41\xEB\xDC\xA6\xC3\x29\xF3\x10\x30\xF2\xD2\xE3\x07\xE8\x69\xB7\xE3\x81\xCA\x29\xFC\x33\xCC\x04\xB8\xF0\x47\xE2\xAA\xED\xEA\xFA\xE3\xAB\xEE\xCB\xE6\x69\xC1\xF2\x4C\xE3\xCC\xE8\xEA\xA4\xE8\x60\x7B\x06\xFE\xC2\x96\xF0\x4F\xE8\x90\xCF\xE2\xC7\xF1\x22\xF2\xCD\xD1\xEA\xD4\xF1\x2D\xFF\xCB\xE8\xF2\x3E\xCD\x1C\xDA\x90\xCE\xF2\x80\xF0\x60\x79\xCC\xF4\xEA\x37\xE5\x43\xEB\x9F\x89\xE5\x72\xE9\x88\x8A\x07\x3A\xF0\x6D\xB8\x00", - "\xF2\xC5\xFB\xF0\xEE\xEE\x1C\xFE\xC4\xC2\xE8\xA4\xD3\xFC\xEA\xC6\xD8\xE8\xC9\xE9\x17\xFD\xBE\xE5\xED\x3D\xF2\x15\xFE\xCF\xFA\xF3\xE7\xDA\x3B\xF1\xBC\xC6\xF1\x1C\x98\x3B\xF5\x38\xDB\x94\x06\xF5\x1E\xFE\x76\xF6\xF3\x1A\xF0\x54\xE7\x96\xF7\xF1\x16\xF0\xDE\xC4\xC1\xF3\xF3\x33\xF0\xF1\xC8\xC1\xEF\xF1\x03\xF4\x6F\xDC\xC1\xDE\xF1\x64\xF1\xC3\xE0\xC2\xC5\xF1\x22\xF1\x3A\x74\xC2\xC0\xF4\xD2\xE4\xE4\xE7\xC3\xFD\xEE\x27\xE9\x3F\xF4\xD2\xE6\xDE\x4C\xF0\x46\xF0\xC3\xD3\xF1\x51\xE8\xFD\xEB\xC6\xF5\xE8\x0C\xF7\x1C\xFC\x95\xF9\xE8\x2A\xF6\x4B\xFF\xAD\xDC\xBC\x39\xF4\x48\xFE\x4F\xD1\xEC\xF7\xF2\x4F\xF9\x3B\x84\xF1\x27\xF6\x16\xF2\xBB\xED\xF4\x42\xF5\x46\xFD\x4B\xBF\xEE\x14\xF4\x41\xFD\x4B\xCC\xF5\x1C\xF4\x1E\xFD\xB0\xD0\xF5\xFF\xF2\x4E\xFC\x47\x98\xF1\x49\xF7\x4B\xF8\xE3\x9C\xF1\x56\xF5\x44\xFB\x02\xA0\xF1\xCE\xEF\x51\x79\x9C\xC1\xF5\x45\xF5\xEE\x87\xC6\xDA\x75\x69\xF1\x43\xF4\xD6\xD4\x77\x6B\xE9\x58\xFB\x8E\xAE\xF1\x59\xF7\x9E\xB1\xA7\xE2\xE9\x73\xE8\x5C\xF5\xD6\xDB\xA2\xDE\xEE\x56\x70\xBE\xCD\xF5\x21\xF5\x19\xF4\xBE\xCA\xDC", - "\x0C\x07\xF9\xEC\xD7\xC6\xF5\x9B\xA2\x40\xFA\xD5\xD2\xEE\xF1\xF2\xD6\xEB\xD6\xD7\xCD\xB2\xC5\x42\xFC\xD8\xC0\x00\xF9\xF1\x57\xFB\xB8\xE6\x9B\x8E\xF6\x53\xFF\xCE\xC8\xF6\x4D\xE5\x4F\xF7\xD7\xE3\xD2\x79\xED\xE9\xE1\xD7\xFC\x91\x08\xF2\x64\xF3\xB1\xE0\xEB\x8A\xF6\x5A\xFF\x6C\xE4\xF6\x51\xF2\x52\xF9\x3B\x93\xF4\x51\xF6\x57\xFD\x4B\xD7\xF4\x9F\xF6\x6B\xFD\x78\xD5\xF6\xCF\xC7\xBB\xE6\xD7\xEF\xF0\x7B\xBB\x48\xF2\xDA\xD0\xEC\xED\xC7\x6D\xFC\xA0\xF9\xEB\x9A\xF4\x6E\xFE\x97\xC2\xEC\x97\xEE\x6F\xF6\xD9\xF6\xEE\x48\xF7\x66\xFD\xD1\xF9\x9C\x36\xF2\x70\xF2\xDB\xDB\xA2\xA3\xEF\x6E\xFB\xD8\xF9\x9C\xA7\xEF\x65\xFA\xDC\xF1\xCE\xB4\xF7\x4F\xF1\x1A\x90\xF4\xA9\xF5\x3B\xD4\xD5\xEB\xF4\xC7\xE9\xCE\xBD\x6C\xDC\xF7\x9E\xF4\xF3\xD9\xDC\xCE\xF7\x93\xF7\x8A\xED\x9B\xE4\xF7\x32\xF4\x96\xE9\xDD\xE7\xEC\x4D\x98\x7B\xF3\xDD\xFC\xD6\x60\xF7\x43\x73\xD6\xE6\xF6\x36\xF5\xD9\xB7\xD6\xFF\x77\x69\xF5\x7E\xF3\xDF\xFD\x92\x6D\xF7\x43\x78\x3E\xE0\xF7\xF4\xF0\xF6\xE5\x80\xC6\xF7\x7D\xF7\xF1\x79\xD7\xFF\x77\x7B\xF5\x6B\xFD\xDD\xD5\xDD\x7A\xF1\xF9\xE3", - "\x01\xEF\xF7\x6E\xE7\xDA\xEF\xDF\xF0\xF7\x59\xEF\x83\xF2\xD5\xF9\x9C\xC5\xE9\x55\xF8\xD9\xE1\xED\xF2\xF4\x7E\xFD\x6E\xFA\xEF\xD7\xF7\x73\xF7\xD8\xE5\xF8\x9E\xAE\x61\xFB\xDC\xC9\xF8\x39\x9C\x04\xF6\xDD\xE8\xF7\x6E\xD8\x85\xFC\xD9\xE3\xD6\x21\xFA\x7F\xFC\x9D\xEE\xF8\xAA\xF5\x8E\xF8\x69\xAC\xF6\x1E\xF9\x78\xF2\xA8\x88\xF8\x84\xF5\x3B\xDB\xD1\xFD\xF8\x05\xFB\xA3\xD2\xE3\xC2\xD8\x03\x06\x6E\xF1\xDB\xF4\xF1\xBD\xF5\x8D\xF3\xD8\xC1\xA7\x8F\xE4\x81\xFF\xDB\xC4\xF7\x9B\xEE\x93\xFE\xE0\xCF\xDD\xDF\xDE\xBF\xE5\xDA\xF6\xF8\x26\xF0\x53\xC7\xE4\xC3\xF7\xF9\x76\x95\xF4\xE4\xCD\xEC\xD5\xF6\x8E\xFB\xE2\xFD\x92\xAB\xED\x45\xF7\xE2\xEE\xEE\x5F\xFB\xB2\xDA\xDE\xC3\xEC\x40\xFB\x8B\xF8\x7D\xF2\xF0\xC7\xF7\x9A\xF3\xE7\xE7\xF7\x6A\xFB\x99\xF7\xD4\xE5\xEC\x5C\xFB\x93\xF5\xE1\xCF\xD8\x6D\xF8\x93\xFE\x53\xC1\xFA\x37\xF7\x40\x05\xDF\xDA\x75\xF7\xF5\x9F\xF7\xE5\xFA\xF7\xF7\xD9\x70\xF9\xE7\xE0\xF9\xE6\xCE\x84\xF1\x5E\xB1\xF9\x66\xF8\x1F\x93\xD7\xF2\xEC\x75\xF6\x98\xF2\xE5\xF9\xB5\x76\xF1\x4D\xFE\xE7\xDC\xEF\x2C\x89\x9F\xE6\x0D\xFE\xCB\x14", - "\x07\x38\xF2\x87\xF7\x71\x1F\xCD\x1F\xF1\xD9\x85\xF2\xC0\xE3\x21\xF9\xEA\xD1\xF3\x83\xF0\xA2\xE4\xC9\xC7\x98\xB0\xFB\x22\xFE\x13\xA2\xE3\x7C\xBE\x17\xD5\x31\xF5\xFA\x92\xF3\x11\xCD\xA8\xE3\xFA\xAF\xF0\x48\xE9\x93\xE6\x69\x6B\xD3\xAE\xF6\xCB\xC2\x04\xA6\xF8\x44\xE3\xA8\xF7\xC9\xAD\xF3\x66\x71\xEC\xF1\xFA\xEE\xD1\xAA\xEC\xE8\x80\xCD\xD6\xF0\xB4\xFC\xCB\xE8\xB6\xA0\xE9\x2F\xC1\x2F\xCB\xC2\xC9\xF8\x4A\xE0\x8F\xC3\xD2\x35\xE4\xB5\xF0\xC9\xD7\xF3\xA4\xF2\x21\xE2\xEE\xDF\xF2\xE4\xFB\x26\xF9\x48\xE7\xFB\x81\xF1\xBA\xF6\x87\xF4\xC1\xEC\xFA\x38\xFD\xCD\xD2\xFB\x0C\x07\x37\xFA\x10\x06\xFB\xDB\xF3\x2D\xF6\x74\xE7\xF3\xBE\x9F\xE4\xB5\xD3\x58\xEA\xCD\x84\xAB\xFA\x93\xC2\xEA\x33\xE6\x27\xED\xCC\xDE\xE3\x62\xC9\x23\xF4\xCE\xC0\xE5\x39\x9E\x26\xFF\xEE\xD9\xF8\xB9\xF3\xA2\xE1\x41\xEB\xE2\xBD\xF9\x14\xCD\xEC\xD8\xF2\x23\xEB\x07\xD8\xF1\xDC\x70\xD7\xF8\xDD\xB9\xED\xCA\xFB\x05\xFC\xCD\xD3\xAB\xE7\xFA\x21\xFC\xCE\xD4\x90\xE0\xE3\x60\x92\x23\xEE\x93\xEE\xFB\xDE\xC0\xB4\xF7\x90\xD8\xF3\x4A\xC2\xBD\xF4\xF2\xCB\xF3\x55\xE0\xBF\xFC\xCB", - "\x88\x43\xAA\xF3\xCC\xF5\xAB\xC6\xB6\x81\xE9\xC2\xF9\xA8\xF1\xF2\xDB\xE3\x24\xF4\xEF\xF7\xA7\xD0\xFA\xC3\xFF\xD0\x68\xE2\x11\xE6\x0A\xE4\xF1\xDB\xFC\xE9\x71\xA5\xE8\xDA\x97\xEA\x7F\xEB\x09\xF4\xCB\xF6\xFA\xB5\xE1\xCB\xDC\xF4\xE1\xBE\x43\xFC\x0D\xD5\xF1\xCC\xF3\x21\xE7\xCF\xD4\xF5\xE5\xD0\x27\xFD\x3D\xE8\x33\xE1\xFD\x83\xE2\x4F\x8F\xF2\xE5\xFB\xD0\xE3\xBE\xF1\x47\xE8\xF3\x8A\xFB\x3E\xF6\xE1\xE2\xF8\x8B\xF8\x43\x94\xE8\xCE\xF4\x00\x01\x87\xFB\xE9\xE8\xF4\xC8\xBB\xDC\xF4\x11\xDD\xE5\x94\xFA\x9D\xF5\xE7\xFA\xF9\xC4\xCE\x8A\xFB\xE1\xEC\xF8\x05\xF5\xDF\xF0\xF8\xD8\x9A\xA1\xF7\x92\xF3\xDA\xD9\xC4\x8E\xFB\xDF\xF0\xE9\xF4\xD9\x1A\xFA\x89\xFB\xE7\xBC\xF8\x77\xFD\x99\xEF\xE3\xDA\xFA\xD2\xF4\x77\xE3\xE4\xD5\xFE\x18\xF9\x79\xC8\xF9\xCA\xFE\x65\xBE\x92\xF8\xE2\xC5\xEC\x03\x06\x49\xF0\xE3\xFC\xF6\x94\xCE\xDE\xFE\xB8\xC5\xCF\x50\xF1\x79\xF7\xFA\xF1\xAE\x74\xF8\xE1\xF1\xE4\xFB\xB9\xCD\xF7\xA3\xF2\xF9\xFC\x91\xD1\xF4\xE8\xF7\xE1\xDB\xA2\x65\xFA\xDF\xF2\xFB\xF9\x8E\x69\xFA\xE3\xF7\xFB\xE2\x92\x44\xF7\xEB\xF0\xF7\xE2\xF7\x2C\xEA", - "\xA7\xF1\xF7\xEB\xFE\xDF\xF5\xE6\xFA\xE8\xC8\xFF\xEB\xF6\xF2\xF3\xE6\xE9\xE6\xCD\xFE\xEE\xF0\xF7\xCA\x96\x58\xF7\xE8\xFD\xDE\xDC\x70\x5C\xF6\xF5\xFF\xFC\xD8\xCF\xE4\xB7\x0F\x89\xE8\xDF\xFA\x87\xFC\x84\xF7\x7F\xD2\xFA\x00\x01\x7F\xF4\xFE\xC3\xFE\xBD\xD1\x80\xFA\xD5\x43\xF8\xCE\xFF\xFA\xF2\x4A\x97\xFA\x61\xF1\xA6\xF2\xFD\xDC\xFE\x48\xED\xA7\xFD\xF8\xFF\xFE\x3F\xF0\x40\xA8\xFE\xC2\xF6\x14\x67\x6D\x7C\x82\x4E\xC2\x65\xD3\x38\xF7\x66\x69\x04\x80\x51\x7F\x42\x31\x1C\x6E\xD5\x7C\x32\x79\xF7\x5D\xE9\x50\x7D\xB8\x7C\xD4\x5A\xAE\x7A\x00\x8F\x30\x68\x00\xA8\xFC\x5B\x68\x0A\x7E\x6D\x7F\xAB\x7F\xD8\x78\x6E\x66\xC5\x59\xFD\x6B\x73\xCE\x7D\xAE\x36\x05\x82\xEC\x7D\x1C\x43\xE5\x6A\xFB\x28\x5B\xC5\x7C\x0A\x80\x07\x83\x04\x85\xF6\x6D\x0E\x4E\xFD\x74\x5E\x27\x72\x03\x82\x33\x3C\x05\x89\x92\x69\xDD\x1A\xEA\x11\x58\x13\x66\x19\x81\xB0\x34\x06\x8F\xED\x70\x8F\x56\xFD\x67\x61\x0D\x81\x03\x80\xCB\x7B\x66\x64\xEB\x6B\x01\x83\x01\xBA\x66\x45\x80\x07\x81\x07\x80\xDA\x7A\xF2\x64\x87\x4F\xF3\x2A\x80\x4A\x80\x1E\x81\xD2\x78\x26\x71\xEE\x69", - "\x02\x82\x01\xAE\x7E\xB7\x75\x95\x66\xC3\x66\x08\x80\xED\x66\xCA\x4F\xFC\x10\x02\x6C\x7E\x78\x67\x06\x82\x09\x80\xA2\x65\x00\x90\x01\xE6\x34\x65\x81\x04\x82\x31\x33\x01\x81\xEF\x61\x11\x69\x01\x97\x80\x50\x49\x08\x80\xDD\x5B\x02\x83\x06\x88\x03\xBE\xFC\x33\x7D\x25\x67\xAE\x37\x1B\x84\x04\x89\x9F\x5F\xF5\x40\x01\xDB\x80\x64\x80\x61\x7E\xAB\x74\xD8\x7D\x06\x9F\x01\x7B\x01\xAD\x80\x36\x49\x17\x81\x06\x59\x06\x87\x06\x8E\xE6\x07\x02\xB5\x80\x99\x74\x8D\x7F\x1F\x83\xB5\x2F\x30\x6F\x04\xBD\x00\xF6\x71\x3F\x80\x2D\x80\x25\x84\x03\x86\x09\x93\x02\x83\xE4\x23\x7E\x62\x81\x20\x82\x23\x87\x08\x87\x42\x65\x04\x8F\x60\x1D\x81\xCB\x7C\x59\x75\x15\x81\x0F\x8B\x08\x68\x05\xA5\xFC\x60\x7D\x1F\x81\x9D\x72\x15\x83\x14\x88\x05\x97\xA1\x6C\x02\x88\x4C\xAE\x80\x9A\x7C\x35\x76\xE6\x71\xBA\x2C\x32\x4D\x93\x14\x45\x43\x69\xB5\x38\x12\x6F\x88\x6B\xDE\x43\x06\x96\xB7\x46\x68\xC7\x81\x22\x35\x77\x5A\xBF\x57\xDF\x52\xF1\x17\xD5\x14\x02\x4E\x68\xA3\x68\x14\x6B\x16\x81\xAC\x33\x05\x3F\xF1\x22\x81\xD5\x81\x55\x7F\x44\x72\x13\x8F\x5A\x28\x30", - "\x56\x03\x90\x80\x19\x81\x50\x80\x20\x86\x4C\x3F\x0D\x9F\xFA\x60\x91\x72\x80\x19\x58\x3A\x80\x36\x87\xA8\x35\x0E\x9B\xFA\x5B\xA2\x46\x7E\x5A\x3B\x4E\x79\x1D\x86\x99\x3D\x0E\x97\xFA\x4F\xEA\x4B\x7E\x93\x81\x6E\x83\xC3\x65\x1E\x81\xCA\x71\x34\x57\xFC\x79\x81\xB3\x2A\x6F\x82\x0C\x77\xE0\x77\x87\x66\x05\x94\x04\x7C\x81\x39\x7E\x03\x69\x2F\x4D\xE3\x7D\x05\x66\x08\x90\x04\x08\x82\x40\x7E\x85\x80\xD7\x7B\xD8\x7B\x88\x77\x05\xBB\x03\xA4\x81\xEB\x7C\x6A\x80\x3B\x80\x23\x81\x73\x6E\x08\x8C\x04\x10\x82\x11\x7E\x59\x78\x31\x7D\x1F\x7B\x8F\x7A\x08\xB1\x6C\x20\x82\xC2\x79\x9D\x7D\xB4\x66\x9B\x7E\x11\x86\x08\x28\x04\xCA\x79\x2A\x82\x73\x7B\xDA\x7F\x57\x3A\x97\x38\x05\x17\x03\x86\x02\xA4\x37\x07\x32\x4D\x80\xDA\x72\xF0\x74\x33\x74\x04\xDD\x36\x3B\x82\x73\x80\x06\x87\xE7\x7B\x2D\x78\x09\xB5\x04\xF7\x80\xB1\x80\x75\x82\x51\x80\x28\x8E\x01\x84\x08\x8F\x60\x72\x81\x01\x37\xA3\x80\xB4\x7E\x04\x8F\x05\x8C\x08\x29\x00\xE5\x16\x52\x82\xA1\x80\x14\x4A\x11\x8C\xDC\x4C\x04\x98\x05\xCC\x82\xD0\x7D\x1B\x80\xDF\x59\x07\x84\x11\x19\x09\x94", - "\x04\x41\x82\xEE\x81\x5D\x79\x26\x87\x0F\x63\x10\x06\x0B\x90\x04\x68\x82\xF6\x80\x9C\x73\x20\x85\x22\x81\xC8\x2E\x0B\x8C\x04\x70\x82\xFD\x81\x64\x73\x2A\x85\x2E\x89\x15\x89\x0B\xA6\xFC\x20\x81\x01\x81\xAF\x83\x22\x60\x2F\x89\x10\x99\xC8\x53\x04\xF3\x82\xBD\x71\xF6\x32\x5D\x86\x20\x04\x18\x91\x08\x86\x06\x9B\x51\x67\x7F\x13\x80\xDD\x5A\xE6\x72\x0E\x8D\x0B\xBD\x05\xF1\x82\x32\x83\x58\x81\x18\x82\xBF\x58\xDE\x41\x5A\x41\x03\xEA\x5B\x45\x68\x63\x80\x10\x6A\x34\x88\x4C\x53\x6F\x65\x06\xEE\x5B\x36\x49\x65\x81\xE0\x2D\x19\x89\xBA\x2F\x06\x90\x04\x51\x81\x1C\x6D\x69\x82\x45\x84\x03\x8D\x18\x81\x09\x9A\x00\xEB\x81\x31\x37\xDA\x81\x4A\x85\x9C\x7D\x4B\x5D\x09\x8E\x73\x0C\x80\xE3\x80\x67\x3A\x6E\x80\x26\x8C\x1B\x82\xC3\x78\x01\xA1\x80\x83\x82\xA4\x82\x53\x82\x12\x6D\x12\x83\x08\x03\x07\x8B\x7E\xA7\x75\x77\x82\x1F\x84\x1B\x81\x10\x8F\x98\x4F\x07\xBA\x7E\xC5\x82\x00\x54\x3E\x84\x3A\x84\xEA\x6F\x0B\xA4\xE4\x4B\x83\x10\x02\xAF\x80\x6E\x80\xB0\x37\x1D\x80\xF9\x7A\x02\xF1\x71\x92\x80\xEE\x83\x65\x81\x2F\x89\x31\x6B\x0B\x85\x05", - "\x9B\x81\x4A\x81\xF2\x82\xB7\x7E\x13\x83\xF6\x60\x0C\xBA\x00\xC7\x3A\xF2\x82\x80\x7C\xD8\x7E\x3E\x8D\x08\x81\xD6\x39\x07\xEA\x80\xA3\x59\x40\x73\x7D\x81\x37\x8C\x11\x9A\xB9\x4D\x07\x82\x02\xFF\x82\x38\x82\x7E\x59\x32\x85\x15\x85\x6E\x47\x08\x80\x00\x09\x84\x3E\x81\x0E\x6A\x57\x74\x1D\x87\x7F\x7A\x04\xB7\x82\x16\x61\xF5\x81\x61\x87\x50\x70\x00\x1E\x0D\x81\x6B\x40\x83\x19\x84\xB0\x82\x56\x83\x14\x71\x0E\x81\x0C\x9C\xBF\x22\x84\x7E\x83\x1D\x61\x89\x81\x93\x56\x1D\x8D\x0A\x9D\xFD\x4E\x39\x50\x82\x16\x62\x86\x86\x31\x8C\x21\x94\x0A\x8F\x74\x57\x82\x27\x85\xE4\x80\xB4\x7C\x2B\x8A\x04\x62\x0F\xB2\x08\xA8\x84\x98\x82\x5C\x61\x7A\x84\x2D\x8E\xFE\x40\x12\xAC\x07\x82\x59\x2E\x73\x3C\x5A\x91\x83\x43\x8F\x72\x62\x10\xB1\xB1\x3A\x84\x23\x85\xC0\x2D\x13\x80\x90\x6E\xCA\x54\x0D\x85\x08\xE6\x7D\x51\x59\x25\x84\x8D\x85\x49\x8C\x1F\x89\x65\x6D\x08\xB5\x81\x2C\x83\x2C\x84\x94\x81\x45\x86\x6C\x54\x10\x9D\x75\x3E\x81\xD0\x49\xD1\x81\x31\x83\x4D\x81\x1A\x8C\x13\x89\xD1\x28\x83\xCE\x48\xD3\x80\x18\x4A\x35\x84\x11\x0C\x0D\xBE\x84\x2E", - "\x83\x0C\x02\xD8\x80\xBC\x6A\x36\x8C\x09\x73\x11\xB6\x06\x95\x83\x41\x74\xFC\x82\x36\x85\xE7\x7A\xCD\x66\xD3\x11\x08\x88\x81\xE7\x81\x15\x86\x27\x7C\x40\x80\x0E\x84\x0A\x8D\xCC\x15\x6A\x21\x45\x43\x84\x24\x85\x39\x40\x0F\x9F\xEF\x31\x08\x90\x85\x3F\x40\x49\x87\x25\x87\x4D\x6B\x1D\x84\x12\x97\xC3\x0C\x85\x51\x85\xB4\x17\x3F\x84\x3A\x85\x0C\x6E\x0E\x83\x04\xAF\x84\x34\x71\x6A\x7A\x7F\x85\x25\x71\x47\x7F\xF8\x66\x08\x80\x61\xC2\x83\x2B\x85\x36\x7E\x95\x7A\x25\x9F\x13\x8F\x06\xA2\x7E\x7B\x82\x6B\x61\xA9\x80\x41\x82\x2B\x8B\xF9\x45\x0A\xB1\x85\x4C\x80\x27\x85\x38\x79\x52\x83\xEF\x60\x0F\xB5\xFB\x2A\x85\x82\x85\x2E\x82\x99\x86\x27\x4D\x19\x84\xDB\x42\x03\xEE\x84\xC4\x81\x36\x86\xB4\x87\x4D\x88\x0C\x8A\x13\x93\x0B\xD1\x85\x32\x3C\x3A\x84\x44\x06\x4E\x8D\x1C\x58\x13\x86\x04\x7A\x84\xE9\x79\x1F\x41\x7F\x58\x3A\x84\x87\x3A\x0F\xBE\xCF\x5B\x81\x5B\x84\x0E\x72\xA3\x84\x38\x8C\xF0\x76\xC8\x47\x07\xC1\x84\x0B\x69\xE9\x81\xBA\x84\x83\x36\x23\x9A\xEA\x2C\xE1\x0A\x84\x0E\x59\x51\x87\xBC\x85\x5E\x73\x24\x96\x15\x9C\x08\x8C\x82", - "\xCC\x5A\x57\x86\xB9\x83\x44\x54\xF6\x73\x14\xBB\x07\xB9\x85\x47\x84\xB9\x81\x31\x7E\xEB\x74\x26\x9F\x04\x88\x0C\xCC\x84\x71\x36\x06\x87\x43\x3C\x32\x83\x1F\x89\x05\xBB\x02\xB3\x82\x86\x7E\x73\x74\xC4\x7B\xFB\x7E\xE3\x7B\x70\x6E\xFE\x36\x7F\xA9\x36\xBB\x7D\xFC\x7B\xF9\x74\x29\x51\xEC\x5E\xFF\x72\x7F\xA9\x36\x12\x7E\xF1\x7D\xED\x78\xFF\x60\xF5\x5B\x0C\xBB\x7F\xBE\x7F\x01\x7A\xEA\x7C\xFC\x69\xF8\x7A\xFE\x4A\xF0\x28\x7B\x1F\x86\xE1\x7F\x48\x4B\x66\x80\xB8\x63\x08\x14\xFE\x23\x86\x6E\x7F\x41\x6C\xCF\x87\x2B\x73\xEF\x57\xFF\x40\x0D\xE7\x6D\x1F\x7A\x9B\x87\xF1\x7C\x71\x79\x31\x92\xDE\x50\xCE\x46\x86\x27\x87\x5A\x5D\x94\x7F\x68\x80\xCF\x7D\xD7\x72\xD4\x50\x86\x4A\x86\x84\x6F\x9B\x7D\xB8\x7F\xF9\x79\x1A\xBC\xED\x37\x48\x4D\x87\xF4\x78\x4E\x7A\x9E\x74\x32\x88\x19\xBE\x84\x3D\x7F\xE5\x7E\xF6\x7C\xF0\x7B\x68\x85\xBF\x6A\xCD\x5D\x0D\xAB\x86\x5F\x87\xEA\x7E\xD7\x85\x6C\x8A\xDF\x52\x1B\xB0\x0D\xF4\x86\xD0\x7E\x38\x7F\xDB\x80\x64\x84\xA5\x71\xFD\x73\xFE\x6A\x86\xC4\x67\xEC\x7F\xDD\x86\x8A\x71\xDF\x78\x1A\x83\x0E\xE7\x6D\x87", - "\x7D\xFF\x3B\xF8\x7C\x6E\x84\x38\x87\x8C\x4D\xFA\x64\x86\xD3\x7E\xFB\x70\xD6\x44\x7A\x7B\xE5\x66\x1B\xA8\xFE\x74\x5A\x07\x7D\xBD\x86\xCE\x87\x5F\x5B\xE0\x71\x60\x4D\xF8\x11\x87\x7F\x86\x51\x48\xD4\x72\xAB\x30\x00\x9F\xF7\x40\x08\xAD\x06\xE8\x84\x7F\x84\x63\x5D\x44\x83\x30\x91\x03\xAC\x0E\xA7\x87\x92\x5A\x79\x86\xEA\x82\x94\x7D\x29\x93\x1D\xBE\x03\xB1\x70\x61\x83\x7E\x87\x6E\x85\x5D\x8B\x10\x8E\x0F\xBB\x0E\xD1\x83\xB8\x85\x58\x80\xAC\x73\x1A\x7F\x17\x8F\x18\xBB\x0B\xD8\x7E\xC6\x84\x65\x65\xAF\x86\x09\x85\x2C\x88\x15\xB6\xA8\x6A\x7E\x9A\x83\x28\x6B\xA6\x81\xE0\x79\x3A\x9F\x1D\xAC\xEA\x46\x83\x49\x82\xE5\x82\xF3\x80\x14\x7E\x22\x94\x08\x81\x6B\x48\x7E\x16\x87\x89\x7D\x13\x67\x3B\x8B\x3D\x80\xEC\x10\xFD\x78\x85\x12\x5B\x58\x80\x3D\x70\x51\x84\x29\x40\x18\x8A\xC1\x02\x86\xB0\x87\x29\x86\x3F\x71\x54\x80\x90\x60\x0C\xAD\x0E\x8D\x71\x05\x87\xE9\x87\xC1\x82\x78\x8D\x3C\x9E\x1E\x8F\x0F\xCA\x85\xBC\x80\x3F\x74\xFA\x80\x22\x0E\x21\x87\xEA\x04\xFC\x67\x83\x2A\x85\x75\x84\xB9\x81\x56\x77\x71\x6F\x17\x89\x0C\xBE\x7D\x1F\x73", - "\xA9\x81\xED\x86\x7A\x8C\x40\x90\xC1\x6D\xE3\x27\x85\xFE\x87\x98\x37\xFA\x86\x60\x80\x46\x4E\x1F\xA4\xC3\x70\x87\x03\x88\x86\x02\xFC\x85\x24\x84\x3F\x82\x21\xB9\x0F\xF4\x83\xCD\x64\xFB\x85\xFC\x87\x84\x81\x3E\x8C\xA4\x59\x01\xC7\x87\xAF\x5F\x65\x84\x05\x8E\x76\x86\xC4\x44\x14\xA5\x10\x86\x02\xE8\x80\xE6\x5B\x37\x72\x42\x83\x14\x8E\x20\x90\x0C\xD9\x4F\x11\x89\x1B\x8B\x40\x05\x5E\x8F\xDF\x37\x17\xBC\x10\xDB\x82\xFA\x84\x1A\x8A\xCA\x69\x8E\x6B\x41\x9A\x1F\x9D\x10\xBE\x87\xEC\x84\xE0\x85\xF1\x84\x7F\x81\x2C\x8A\x21\xA1\x10\x86\x02\x23\x88\x63\x79\x15\x8E\x78\x8A\x44\x81\xCA\x76\x02\x8D\x86\x3E\x42\x2F\x83\x43\x3B\x33\x80\x3A\x99\x9D\x5E\x0C\x9C\x86\x45\x7D\xCC\x78\xE4\x85\x65\x82\x68\x75\xFB\x6C\x0D\xA9\x78\x90\x7B\x37\x88\x86\x72\x65\x8C\x37\x88\x23\xB5\x11\xB7\x86\x2F\x87\xEB\x7F\x4C\x7D\xB3\x76\x47\x9B\x1C\x8D\x87\x35\x86\x87\x87\xAA\x84\xE4\x79\x67\x8C\xFF\x78\x34\x78\xF8\x31\x86\x72\x7D\x9C\x4F\xCF\x81\x6A\x81\x34\x93\xAD\x61\x0D\x84\x89\x28\x4C\x39\x89\x9B\x59\x69\x81\x48\x9F\xF0\x47\xB9\x12\x89\x65\x54\xD3", - "\x7F\x1D\x8F\xB4\x70\xDC\x6B\x23\x94\x0D\xAC\x7A\x7C\x7C\xCB\x84\xCC\x83\xCF\x56\x37\x9B\x24\x9F\xFF\x48\x4E\x98\x88\xBF\x79\xEE\x7B\x6E\x8D\x38\x9C\xE1\x5E\x12\x8C\x89\x70\x89\xE0\x7D\x21\x89\x6D\x84\xFC\x69\x25\xB2\xC5\x7E\x86\x89\x89\x59\x88\x1F\x4D\x94\x8E\x47\x98\x23\x94\xF9\x30\x4C\xB6\x88\xBC\x64\x2F\x8A\x97\x83\xFC\x7E\x5C\x42\x0E\xA6\x89\xA2\x89\xA0\x55\xF7\x7C\x95\x81\xBF\x60\xFF\x4F\xD1\x62\x7F\xC1\x88\xC9\x87\xF9\x78\xB0\x76\x10\x0A\xFF\x4C\x0E\xFB\x88\x3D\x77\x36\x7A\xE6\x84\x98\x8E\xB9\x54\xFF\x6E\xF5\x76\x7F\xFB\x7F\xD0\x86\xE0\x6E\x20\x0D\x39\x9C\x7B\x5F\x0E\xEC\x88\x80\x86\x4C\x4F\xE8\x87\xBF\x30\x00\x8C\xB2\x7A\x6E\x02\x7F\xA2\x48\x91\x84\x40\x60\x4D\x8C\xF7\x7B\x80\x6E\x13\xB4\x5F\x8C\x7E\x70\x57\x3A\x5E\xDA\x48\x33\x85\x7B\x47\x12\x93\x7F\xF4\x89\xC0\x76\x3D\x8F\x2F\x7A\x64\x56\xED\x45\x14\x8B\x67\xE6\x30\xCF\x6D\x27\x88\x9F\x8F\x4B\x85\x7E\x7E\xD0\x1A\x77\xC0\x89\x87\x88\x2A\x8A\xA2\x81\xE6\x60\xA6\x6A\xB9\x14\x8A\xB0\x85\xB2\x5D\xF1\x7F\xCE\x71\x4A\x95\x75\x43\x13\xCB\x7A\xB8\x88\xE4\x79", - "\x47\x8F\x3B\x67\x4C\x8C\xD9\x41\x14\x86\x7D\xC9\x77\x83\x88\x38\x57\x71\x8C\x50\x99\x26\xA8\xFF\x70\x7F\x1C\x38\x6F\x8B\x43\x3D\x68\x71\xB4\x45\x27\xA8\xB6\x67\x89\x38\x5D\x75\x89\x04\x5D\x9D\x89\x47\x94\x14\x70\x13\xA1\x86\x27\x8A\xFB\x76\x4A\x8C\x9F\x74\x36\x97\x27\x9E\xAE\x7F\x89\xA0\x7B\xA0\x8B\x42\x7B\xA4\x5D\x4F\x85\x91\x4B\x12\xE9\x39\xB0\x7B\x32\x57\xE6\x79\x6E\x34\x49\x87\xFE\x20\xE8\x30\x71\x79\x35\xA9\x87\x12\x7B\xA4\x80\xD3\x6D\xFD\x65\xBD\x35\x7F\x39\x4F\x55\x8B\x88\x58\x6D\x88\xDD\x78\x28\x95\x78\x4A\x8A\x1F\x8B\x3D\x7C\x15\x79\x68\x59\x56\x82\x29\xAB\x15\xDA\x86\x38\x6B\x81\x8A\xFA\x6B\xA8\x88\x52\x88\xCE\x4A\x15\xFB\x7B\x11\x58\x6B\x8A\xD4\x5A\x9B\x8C\x4F\x82\xDA\x54\x13\xDD\x57\x4A\x8A\x9B\x88\xDD\x58\xA7\x88\x1A\x7A\x29\xBC\xBD\x00\x80\xD0\x78\x0E\x82\x2E\x07\x71\x4D\x53\x8F\x9A\x4A\x15\xF2\x89\x0E\x5C\xA5\x88\x1D\x8E\x3D\x7A\x54\x88\x2A\xA2\x92\x00\x89\x0F\x79\xCA\x8A\x52\x8F\xA9\x84\xDD\x31\x2A\xA3\xB8\x53\x8A\x1B\x3E\xA5\x8B\x55\x89\x7D\x89\x55\x88\x2B\xA1\x14\x98\x4D\x6D\x8A\x4C\x4C\x58", - "\x8B\x05\x42\x56\x84\xF3\x4A\x15\xB2\x89\xBD\x49\x8D\x8B\x11\x7C\xAB\x88\xB1\x71\xE9\x5C\xEC\x78\x7C\xB3\x8B\xB7\x89\xBB\x6D\xA4\x8C\x5B\x6B\x26\x94\x77\x09\x87\x11\x59\xC5\x86\xCD\x74\xA5\x8E\xB9\x4E\xFF\x7F\x77\x30\x8A\xE6\x4B\x38\x79\x4B\x8C\x9C\x8A\xFF\x65\x2A\x94\x04\x06\x8B\xA8\x5A\xC4\x89\x7F\x87\xA8\x3B\x58\x94\x3F\x46\x15\xA2\x56\x8F\x8A\xA5\x8A\xC9\x81\x9D\x33\x59\x9C\xAD\x7F\x14\xD8\x5D\x66\x8B\xE5\x62\x66\x89\xBC\x8B\x54\x9A\x27\xA9\xBB\x4A\x8A\x9E\x8B\x86\x74\x68\x8F\x6C\x52\x5A\x89\x28\xA6\x63\x5A\x8A\x4F\x79\xD9\x72\xE7\x51\xB5\x84\xFB\x6A\x2A\xAD\x16\xA9\x73\x64\x8A\x51\x48\x6C\x8B\xA8\x76\x5A\x98\x2D\xB8\xD3\x34\x8B\x5B\x8A\xDD\x8A\x47\x8F\xB4\x86\xFE\x7C\x2D\x9B\xF1\x4A\x8A\xC0\x8A\xBE\x5E\x70\x89\xF3\x44\x5C\x9C\xB7\x7C\x15\xCC\x8A\x7E\x8A\xEC\x70\x44\x04\xA6\x8E\x2C\x82\x08\x02\x16\x99\x58\x84\x8B\x32\x54\x74\x8C\xEE\x52\x5D\x83\x16\x86\x02\x8C\x8B\x7C\x2E\xF2\x8B\x67\x83\xC6\x30\x2D\x89\x06\xA5\x18\xD6\x85\xD4\x84\xD2\x81\x9C\x80\x4E\x84\x29\x5A\x16\x8C\x04\x5C\x85\x36\x48\x6F\x87\x46\x36", - "\xF7\x43\x2E\x9E\x29\xA6\x63\x5F\x8B\xCD\x42\xC8\x88\x75\x3B\xBB\x84\xDD\x3D\x2E\xBD\xD2\x38\x8C\x49\x50\xA5\x88\x66\x8D\xC5\x73\x5E\x94\x2B\xBD\xED\x7D\x8A\xEE\x5C\x8B\x88\x41\x88\xC9\x86\xE4\x64\x2F\xA3\x16\xD2\x7E\x3A\x34\xF8\x8A\xEE\x70\xC0\x81\x5F\x98\xCD\x5E\xAE\x2B\x8B\xBD\x49\xFB\x88\x6F\x69\xBF\x89\xBA\x3B\x2F\x9B\xA2\x32\x8B\xFF\x8A\x01\x8D\x0C\x7E\xBF\x80\x52\x84\x33\xAA\x15\xB6\x8B\xDC\x72\x03\x8D\x70\x56\xB7\x87\xFC\x29\x30\xA8\xB6\x0B\x8C\x71\x36\xBC\x88\xDF\x5A\xAF\x8C\xA8\x26\x2E\x91\xB0\x48\x8B\xD4\x3A\x99\x8A\x56\x3C\xC2\x8F\x35\x97\x30\x8C\xB7\x19\x8C\x23\x5D\x0D\x8D\x06\x5D\xC3\x80\xD4\x67\x09\xA0\x18\x89\x7B\x9D\x47\xEC\x88\x79\x8C\xC7\x87\xFC\x3E\x31\x80\xE8\x64\x8B\x96\x8A\x0F\x4C\xA4\x8D\xC8\x8C\x64\x93\xA6\x64\x17\xE9\x8B\xA9\x73\xF5\x88\x75\x3D\xAA\x89\x73\x4F\x32\x8F\x0D\xA5\x8B\xE4\x8A\xFA\x8B\x2E\x8C\xC0\x8C\x47\x58\x32\xB9\x8E\x5A\x8C\xBD\x68\x2E\x8E\x4F\x46\xCB\x88\x69\x40\x33\xA5\x19\xD4\x8C\x53\x8C\x31\x8D\x57\x8A\xBE\x8D\x37\x86\x33\x81\x0E\xDD\x5F\x6C\x8D\x9C\x4E\x9B\x8C\xEE", - "\x50\x67\x9C\xE0\x32\x19\xA8\x5B\x74\x8D\xB8\x36\x9D\x8C\xEF\x58\x67\x87\xFE\x3A\x19\xFF\x3B\x7C\x8D\x5A\x5E\x9F\x8A\x09\x60\x68\x8D\xD8\x42\x1A\xCC\x5B\x84\x8D\x1F\x87\x22\x65\xBA\x8D\xC4\x52\x82\x4E\x06\xA8\x50\x4A\x8A\x20\x8D\xD0\x52\xC7\x8D\xB0\x6C\x34\xA9\xE6\x0E\x8D\x0F\x6A\x35\x89\xE5\x83\x81\x7D\xFD\x43\x32\xBC\xD6\x11\x8D\xFF\x54\x74\x8D\xD9\x5C\xB3\x87\xC1\x7B\x4E\x45\x0D\xBD\x78\x1C\x74\xB9\x89\x7A\x65\xD2\x85\xFA\x6A\x2A\x92\x19\xD3\x7A\xA4\x8C\xD9\x6A\xA8\x8A\xB6\x66\x6A\x84\x9E\x68\x1A\xAC\x63\xAE\x89\x71\x8E\xE6\x53\x04\x6E\x6A\x9C\xB6\x76\x1A\xDE\x7B\xF9\x8D\xF9\x89\xC2\x8D\xD6\x80\x6B\x82\xDE\x74\xC3\x05\x87\xF0\x8C\x67\x8A\x34\x80\x9A\x83\x02\x7F\x35\xB4\xBD\x41\x8D\xA8\x63\x61\x8C\x6A\x5D\xD8\x89\x9A\x67\x36\x91\xB0\x49\x8D\xDF\x63\x65\x8C\x39\x65\xD9\x88\x37\x6F\x36\x8A\xC1\x3C\x8A\x67\x88\xB9\x7C\x79\x8C\xDB\x89\x73\x5E\x36\x9C\x89\x5D\x5F\xDA\x8C\x4A\x46\xBA\x8E\x86\x46\x6E\x92\x19\x93\x1A\xE4\x8B\xEC\x8D\x9C\x4C\xA6\x8A\xA3\x7A\x54\x9C\x34\xAB\x80\x1E\x8D\x4D\x7D\x22\x37\xBD\x89\xB7\x88", - "\x66\x95\x30\xAC\xFE\x34\x8D\x5F\x8A\xFB\x89\xF7\x5A\xD5\x8D\x1C\x4C\x35\x87\xDF\x7D\x8B\x0D\x8E\xA2\x8E\x57\x8F\xB6\x81\x75\x81\x33\x85\x1D\xBB\x8B\xB8\x8C\x04\x8D\x4A\x8C\xDE\x86\xC6\x6D\x30\xA5\xBD\x1A\x8E\x74\x5E\x8E\x8E\x91\x61\x73\x8C\x75\x9D\xCE\x4D\x17\x82\x8E\xCF\x8A\x51\x7C\x40\x83\x64\x3F\x80\x32\x02\xA8\xFA\x3C\x6D\x8B\x60\xB7\x8F\x2B\x82\x94\x4C\x23\x84\x87\x67\x0F\xB4\x60\xB0\x87\xBA\x8D\xC1\x67\x24\x7F\x1D\x71\x39\x9F\x0D\xFE\x8E\x6D\x6E\x96\x8E\x34\x8E\xE5\x8F\x70\x7A\x1D\x4F\x12\xCF\x4D\xEE\x8D\x7C\x8B\xB8\x8A\xB1\x45\x73\x80\x38\xB4\xF8\x4A\x7F\x4D\x8B\xD5\x7D\xCE\x8A\x9A\x8B\x73\x9A\xEE\x6C\xEB\x0F\x8E\x06\x8A\xC8\x8C\xD3\x82\xDE\x81\x74\x91\x38\x93\xEE\x18\x8F\x0D\x8B\xF0\x5C\xE8\x8B\x6B\x85\xE5\x7A\x3C\x93\x14\xEB\x6C\xA9\x66\x00\x6F\x45\x88\xF5\x8B\x28\x84\xBF\x45\x1C\xFF\x7C\x47\x8E\x2B\x8D\xA1\x79\xCB\x77\x35\x81\x27\xA7\x19\xD3\x8E\xCC\x7F\x85\x8C\xDD\x7A\xCD\x81\x6E\x83\xF4\x63\x1E\xC8\x77\x76\x8B\xDF\x8C\x53\x68\xFD\x78\x71\x83\xDF\x60\x1D\x99\x58\x62\x8F\xC2\x8E\xC7\x8C\xEF\x50\x72", - "\x90\x23\xA2\x1C\x85\x66\x24\x8F\xDA\x7A\xFF\x7F\xAF\x89\xFD\x59\x36\x96\x1F\xA3\x60\x82\x8F\x5E\x68\xE1\x89\x38\x50\x6E\x93\xF1\x62\x1B\xB1\x73\x0F\x7A\x25\x8D\x45\x64\xF3\x83\x48\x96\xBF\x73\x1C\xC1\x56\x93\x8F\xD7\x79\xE2\x88\x22\x0A\x69\x9E\xE8\x5D\xBF\x22\x7F\x4B\x89\xB2\x8F\xD0\x8C\xB7\x6B\x6F\x8A\x38\x87\x1C\xE6\x7F\xFD\x8D\x76\x6B\xBF\x88\xF6\x8C\x74\x85\x91\x4E\x1D\xDE\x6F\x6E\x86\xF1\x8C\xE9\x89\xA2\x84\x7E\x94\x3D\xA3\xF7\x02\x90\x56\x87\x03\x92\xE7\x8B\x00\x9E\x50\x8C\x3D\x93\xFB\x42\x8F\x0F\x81\x02\x92\xBB\x6B\xEB\x8B\x80\x9C\x91\x67\xE9\x12\x90\xC7\x8E\xE6\x59\xF2\x89\x38\x5B\x7C\x88\x6D\x4D\x1F\xB8\x5C\xCF\x8E\xA2\x6D\xF4\x8D\xF0\x86\x72\x84\x87\x51\x1B\xC3\x88\x7A\x32\xB9\x8C\x2B\x35\x64\x06\x02\x8D\x3B\xA4\x0F\x99\x88\xE6\x86\xC5\x31\x0B\x93\x5D\x5B\x23\x89\x22\x8F\x0A\x82\x02\x33\x91\xB9\x88\x18\x8E\x05\x86\x83\x85\x91\x40\x1E\xD7\x8B\xF6\x6F\xEC\x8D\x70\x53\xFB\x84\x3C\x7D\x3E\x88\xF9\x20\x80\x15\x91\xF2\x8C\x97\x74\xC4\x5D\xFD\x47\x3F\x86\x1D\xCE\x90\x5F\x87\xF4\x8D\x70\x55\xF2\x8E\x78\x98", - "\xAD\x63\xC0\x3E\x8E\xBD\x68\xF8\x8F\xF1\x3A\x93\x89\x73\x53\x3F\x8F\xF5\x3A\x8F\x54\x8E\x59\x8C\x8E\x59\xFF\x86\xFE\x7B\x3F\xA3\xD5\x70\x8E\x08\x90\x4C\x87\x77\x67\xF5\x88\x70\x97\x3F\x80\x20\xF5\x8F\x0C\x8E\x31\x90\x93\x70\x0C\x99\x66\x8B\x3F\x83\xBD\x23\x60\xBB\x8D\x0C\x59\xAF\x8D\x4C\x56\x71\x99\x60\x45\x1F\xA3\x5C\x19\x90\x25\x63\x06\x94\x78\x6D\x81\x94\x7B\x5F\x20\xA8\x63\x21\x90\x60\x73\x08\x95\x0A\x9A\xBE\x5B\xE3\x6D\x67\x77\x3B\x2E\x90\xFA\x4D\x29\x31\x05\x9F\x82\x88\x0C\x87\x75\x3E\x84\x84\x78\x4A\x91\x0D\x90\x77\x81\xAD\x30\x44\xB4\x20\xC2\x88\x48\x39\x1E\x93\xAF\x5F\xFA\x82\x81\x82\x42\x84\xCF\x44\x90\xED\x68\x23\x93\xE3\x78\x09\x9E\x5C\x9C\x23\x8B\x21\x8D\x8F\xC4\x66\x28\x91\xAD\x5A\x16\x9A\x58\x52\x42\x96\xF4\x76\x90\x56\x90\x09\x90\x16\x94\xD2\x6A\x54\x9C\x42\xBB\xCA\x69\x90\x06\x91\xE4\x7D\x12\x91\x18\x91\xFD\x63\x46\xA0\x0D\x92\x90\x66\x91\x36\x89\xFF\x89\x68\x5F\x7F\x92\xAD\x6C\x21\xE6\x7F\x70\x91\x55\x6C\x1D\x96\xE8\x81\x8D\x81\x43\x97\x1D\xA8\x76\x71\x8A\xD3\x8F\x1D\x92\x02\x99\x87\x8C\x6E", - "\x7B\x21\xA3\x5C\x7D\x90\xE6\x5B\x1F\x95\x61\x71\x88\x84\x87\x43\x22\xED\x69\x85\x91\x0C\x5B\x21\x97\xC6\x67\x76\x83\x27\x8D\x22\xFF\x7F\x8A\x32\x19\x63\x51\x3A\x05\x9C\xBE\x22\xC3\x31\x1D\x95\x91\x0B\x86\x67\x38\x26\x92\x20\x02\x8F\x91\xD9\x34\x23\xD9\x83\x98\x4C\xBD\x8C\xD1\x6B\x1F\x90\x00\x1D\x47\x80\x76\x7F\x91\xBC\x86\x66\x7C\x27\x92\x80\x87\x44\x9A\x6F\x42\x24\xC0\x71\x77\x8E\xF6\x84\x12\x8B\x21\x90\x2F\x9B\x44\x4F\x24\xBA\x72\x7C\x8E\x38\x88\xE0\x8D\xEF\x8A\xD0\x52\xDF\x76\x1E\xA7\x91\x1D\x93\x82\x63\x36\x8E\xF2\x8C\x8A\x8B\x3C\xB2\xE5\x21\x92\xE3\x8E\xC3\x85\x66\x8A\xF5\x8A\x78\x82\xF4\x47\x19\x9F\x92\xED\x68\x2A\x91\xFF\x7D\x9B\x66\xE5\x71\x37\xAA\x24\x9D\x8D\xB8\x91\x7A\x8C\x04\x90\x00\x0E\x85\x86\x23\x8C\x20\xA2\x8F\x35\x92\x88\x89\x03\x97\x26\x9B\x02\x44\x43\xAB\x22\x9C\x51\xCA\x77\xD5\x8C\x51\x90\xCD\x78\x92\x91\x90\x6E\x24\xB1\x8F\x5A\x7D\xA7\x91\x35\x91\xF7\x8E\x86\x8E\xF3\x49\x20\xC2\x91\xAF\x89\xF1\x74\xEF\x8E\x65\x8A\x83\x90\x49\xA6\xFF\x5D\x91\x4A\x61\x6F\x93\x63\x79\x1C\x9A\x04\x63\x47\x93", - "\xCE\x13\x87\x0F\x8D\xAC\x93\x88\x59\x1D\x9C\xDC\x4B\x47\x8A\xF4\x09\x91\x3A\x73\x45\x93\x4C\x95\xAD\x6E\x88\x92\x40\x9B\x24\xE3\x66\x3B\x92\x53\x93\x19\x96\x20\x08\x8A\x8D\x23\xAA\x22\xC5\x89\xD8\x8B\x9D\x90\x2D\x92\x2D\x79\x93\x81\x3F\x9E\x25\xFC\x48\x83\x92\x1C\x5E\x2D\x93\x2F\x93\x10\x12\x49\x9E\x1F\x97\x8F\x0E\x91\x26\x8D\x64\x96\x26\x62\x81\x9E\x45\xBD\xD2\x3D\x92\xB0\x8F\xA9\x90\x5C\x88\x46\x75\x7B\x8A\x4B\x9B\xD7\x05\x93\x48\x93\xA0\x91\xC0\x8E\x1D\x91\x28\x8B\xFD\x4F\x23\x84\x77\x50\x93\xCE\x92\x49\x95\xB6\x88\x7B\x84\xBF\x5A\x26\xED\x6D\xAF\x92\x6C\x91\x70\x74\x25\x9D\x95\x9E\x4C\xBA\x1A\x94\x90\xB6\x93\x15\x40\x59\x94\x1C\x66\x96\x92\x26\xA5\x23\x85\x66\xE7\x91\x36\x88\x5B\x92\x09\x6E\x96\x8B\x72\x70\x25\xE6\x34\x72\x93\xC7\x91\x84\x7C\xFA\x8F\x7B\x55\x12\x91\x01\x98\x84\x45\x85\x7B\x93\x26\x97\x82\x82\x26\x83\x00\xB8\x23\xA4\x82\x18\x92\xE7\x93\x15\x80\x14\x90\x00\x17\x48\xA6\x69\x04\x92\x16\x85\x4F\x93\x0E\x91\x11\x82\x8A\x9B\x4C\xA5\x24\xE0\x8F\xA9\x63\xC9\x92\xD5\x6B\x27\x9D\x97\x88\x4D\xBF\x25", - "\xE2\x86\x6F\x7E\xF2\x6D\x62\x90\x35\x60\x8B\x8C\x4C\x86\x26\xB9\x93\x36\x8E\xF5\x93\x4B\x90\x3F\x99\x3B\x4E\x4C\x87\x21\x99\x74\x3B\x93\x5D\x90\xEC\x8A\x0B\x99\x9A\x76\x4C\x90\xF9\x20\x93\xB1\x93\xEF\x61\x82\x97\xDC\x66\x94\x91\xC0\x63\x0D\xAB\x93\xA8\x63\x65\x92\x79\x97\x53\x8E\x7A\x88\x50\x93\x23\xB0\x93\x17\x94\xDF\x75\x86\x92\x41\x9B\xA1\x90\x23\x9B\x25\xFF\x93\xB9\x8C\x69\x88\x58\x94\x1C\x62\x96\x98\x9B\x7B\x26\x85\x66\xBD\x93\xC2\x8F\x6F\x94\xE8\x61\x9C\x88\x4D\x83\x27\xE4\x61\xC5\x92\xBC\x67\x71\x93\x69\x7D\x94\x94\x4B\xB0\x23\xED\x33\x96\x47\xE7\x92\x24\x91\x6E\x1A\x89\x9C\x4E\x9E\x27\xFA\x91\xB4\x32\xE9\x92\x8F\x95\x3C\x90\x28\x8B\xCC\x3D\x28\xE3\x93\x60\x49\x1F\x95\xB0\x34\x20\x99\xA3\x9B\x4E\x88\x29\xEE\x70\x44\x95\xB6\x6F\x5D\x90\xED\x60\x9A\x9A\x4B\xAD\x11\xED\x93\x0E\x95\xDD\x62\x57\x70\x08\x9B\xF7\x6F\xCB\x73\x1E\xCC\x90\x82\x92\xD0\x93\x7C\x95\x4C\x5B\x98\x8D\x23\xBE\x27\xC7\x92\xED\x8E\xBC\x66\x80\x96\x3E\x90\x00\x04\x50\x8A\xE6\x5D\x5F\x98\x92\x36\x97\x82\x90\xC7\x53\xA7\x88\x8D\x4D\x28\xE8", - "\x93\xC9\x91\xA3\x92\x84\x95\xDD\x6D\x8C\x88\x4F\xA7\x26\xD9\x94\xC4\x90\xBD\x86\x36\x97\x2A\x95\x8C\x9C\x4F\xAE\x15\xD7\x91\x6D\x87\x3A\x96\x56\x95\x46\x9E\x7B\x9A\x4F\x93\x20\xC1\x8F\x8E\x95\x13\x94\xD1\x69\x45\x9C\x88\x88\x4B\xAF\x14\xA0\x93\x2F\x95\x82\x65\x8C\x92\x9A\x83\xA3\x99\xD3\x74\x26\x92\x70\x6A\x8E\xEA\x83\x08\x3D\x51\x93\x2F\x65\x19\x23\x2A\x91\x90\x4F\x95\x89\x90\x75\x95\x81\x32\x02\x97\x4E\xBD\xE4\x76\x8E\x22\x39\x23\x95\x45\x91\x20\x91\xA5\x86\x55\xB2\x2A\x8F\x88\x16\x7E\x8A\x91\x2B\x90\xD1\x88\xE5\x69\x4F\x83\x2A\xEB\x93\x8E\x94\x2C\x94\x7A\x97\x3D\x9B\xF8\x69\x39\xAB\xFE\x63\x94\x23\x5D\xFA\x91\x1B\x88\x59\x9D\xB0\x6C\x56\xA9\xE6\x65\x94\xA8\x93\x33\x96\x55\x90\x32\x9F\xAB\x82\x08\x2B\x29\xED\x88\x6E\x95\x5E\x6A\x81\x94\x78\x61\xA7\x8D\x23\x8A\x2A\xEE\x62\x1D\x95\x31\x90\x68\x91\x4F\x93\xAD\x85\x22\x4E\x2A\xFD\x94\xBD\x95\x3F\x94\x7A\x97\x5B\x98\x6F\x95\x4A\xAB\x2B\xE1\x95\x73\x90\x77\x97\x97\x97\x43\x97\x94\x81\x51\x85\x1E\xA3\x94\x05\x67\x12\x96\x34\x8A\x52\x90\x8C\x74\x54\xB0\x1E\xAB\x94", - "\xC0\x71\x16\x94\xA0\x90\x00\x09\xA9\x84\xBA\x5B\x2A\x85\x8F\x9D\x94\xF0\x70\x84\x92\xC3\x81\xAA\x9E\x14\x8B\x06\xA4\x95\x18\x73\x76\x35\xAB\x93\x3A\x91\x0B\x84\x48\x8F\x2C\xA8\x95\xB3\x94\x0B\x89\xC5\x97\x27\x82\xA4\x89\x55\x8E\x24\xB5\x95\x65\x83\x5B\x97\x0F\x8D\xE9\x71\xA5\x86\x1D\x97\x11\x83\x02\x4A\x95\x4B\x92\xAB\x93\x9A\x7D\x23\x8B\x59\xB0\xFC\x30\x95\x14\x97\xE4\x87\xFD\x5F\x53\x9F\x7D\x84\xFD\x67\x27\xC5\x95\x0C\x02\x2B\x96\xC6\x80\x22\x02\xAC\x96\x59\x86\x1E\xA3\x92\xB9\x89\x60\x74\xD0\x93\x13\x5E\xAC\x92\x3E\x87\xE8\x4B\x92\xC1\x53\xA2\x94\x49\x95\xBC\x8B\xB0\x9E\xEB\x50\x2B\xCE\x86\x02\x8A\xA4\x94\xEC\x89\x4D\x98\xF7\x7E\xFC\x52\x2D\xED\x69\xD9\x94\x9F\x91\xE7\x8E\x50\x9D\x4E\x7D\x56\xBB\x2C\xBF\x92\x1F\x61\xA1\x94\x6A\x88\x5E\x97\xD0\x65\x9D\x62\x2D\xFB\x5C\xE4\x94\xF8\x92\xB9\x97\x6A\x96\xFE\x68\x57\x97\x0E\x81\x90\x87\x93\x81\x94\xBB\x97\x2C\x99\x9A\x8A\x40\x9C\x2D\xDE\x95\x64\x96\x85\x7B\xDC\x95\x6A\x99\xB2\x67\x5B\x80\x20\xF6\x95\x9D\x7E\x1A\x64\x6E\x95\x69\x9B\xE4\x5C\x57\xBA\xE4\x7E\x95\x5C", - "\x92\x97\x88\x73\x92\x60\x9F\x94\x85\x58\x80\xE3\x07\x96\x81\x96\xE6\x8B\xFC\x63\x4B\x99\x76\x95\x4B\x95\x2B\xBE\x95\x71\x97\x44\x8C\xCD\x90\x58\x9C\xB6\x9C\x23\x7D\x2C\xF4\x7E\xC4\x95\x3E\x8A\x77\x8C\x51\x97\x9F\x84\x5C\xA9\xE6\x4A\x95\x47\x92\xA5\x95\xA5\x94\x69\x9F\x94\x8F\x5A\xA4\x26\x8E\x89\x7E\x96\x51\x48\xD5\x93\x69\x97\xAD\x87\x4A\x99\x2D\xB0\x8F\xDB\x94\x36\x96\xD7\x95\x5C\x95\xB7\x98\x4A\xA6\x2E\xF4\x8F\x79\x96\x89\x5C\xE9\x91\x34\x9D\xB9\x92\xAD\x7B\x29\xB2\x93\xA5\x93\x2E\x7F\x76\x7D\x78\x9A\xAA\x52\x43\xA5\x2D\xBD\x97\x85\x95\xDF\x97\x17\x92\x5E\x94\xF7\x7B\x5B\x8B\x2D\xF4\x95\x50\x96\x88\x97\xDD\x90\x00\x98\xAF\x84\xBA\x7A\x2B\xCB\x96\x86\x96\xC5\x63\xF0\x90\x60\x9A\x93\x6C\x5C\x9F\x29\x8E\x97\x3A\x72\xC8\x95\xEF\x8E\xC2\x8D\x8E\x98\x59\xB6\x28\xCC\x93\x27\x90\x81\x02\x84\x3B\x07\x80\x9D\x8A\xE7\x13\x2C\xC3\x94\xBA\x94\xEA\x83\xFC\x93\x1E\x9E\xB2\x88\xFB\x6D\x2C\xBB\x92\x53\x94\xD4\x61\x00\x9B\x7C\x7A\xB3\x9C\x5D\x9F\x2E\xDD\x94\x5A\x95\xC3\x8F\x12\x93\x80\x9E\xD7\x6A\x5D\xB0\x1E\xA8\x97\xBC\x96", - "\x07\x98\x9B\x92\x82\x9D\x46\x8E\x5D\x9F\x29\xD2\x95\x4F\x93\xD9\x96\xD6\x90\x0E\x53\xBC\x97\x5D\xAC\x29\xB9\x97\x6D\x89\xDD\x97\xEB\x96\x7A\x9B\xBA\x84\x61\xB0\x1E\xF7\x94\x5F\x95\xB4\x96\xCF\x97\x78\x9D\x36\x8E\x5B\x88\x30\xC7\x6D\xCC\x96\xD5\x48\xF5\x97\x85\x90\xBD\x82\x54\x99\x2E\xF1\x90\x88\x94\x20\x75\x0D\x9C\x6B\x81\xC3\x85\x7B\x58\x2F\xCF\x92\x80\x97\xF5\x97\xA3\x90\xFD\x7F\xBD\x9B\x60\x9D\x1D\x97\x90\x3D\x98\xFE\x6C\xE5\x85\x71\x9A\x5C\x8F\x4A\x89\x2C\xFC\x5A\x49\x93\xCA\x97\x8D\x91\x5A\x37\x92\x71\x44\x8D\xB1\x25\x06\x55\x98\xF1\x91\xC6\x95\x15\x79\xBF\x9E\x14\x99\x31\xB5\x93\x23\x97\x03\x55\xC9\x91\x51\x39\x77\x83\x63\xA7\x2C\xA1\x91\x5D\x98\xF7\x95\x7C\x91\x99\x86\x63\x8A\x60\x8F\xB3\x14\x97\x3C\x96\x38\x99\x3D\x89\x89\x9A\x47\x98\xD0\x4C\x30\xD3\x7C\x8F\x8F\x1B\x98\xDD\x78\x82\x9A\xB6\x8C\x5D\x90\x12\xD4\x63\x6E\x98\x4A\x46\x05\x9C\x6D\x77\xAE\x63\xDE\x6F\x1B\xDB\x97\xBC\x97\xDA\x94\x60\x95\x39\x4E\xC1\x9B\xE9\x50\x19\xF4\x98\x46\x8E\x11\x9A\x1A\x99\x50\x9C\xC3\x9A\x63\xB4\x30\xA6\x98\x89\x96\x83", - "\x74\x22\x9F\x75\x9A\xC2\x82\x5D\xBD\x92\x2C\x98\xCD\x88\x0F\x8D\x2B\x8E\x29\x9F\xC7\x87\x54\xAD\x26\xEC\x98\x71\x87\xE0\x97\x86\x72\x28\x90\x94\x90\x64\x98\x28\xB3\x98\x75\x98\xAA\x5A\x21\x9A\x8B\x9B\xC9\x9F\x52\x9D\x2F\xC0\x71\x45\x99\x4A\x7E\x28\x49\x7C\x95\x62\x61\x64\x90\x91\x64\x97\x70\x5A\x5F\x9A\x7E\x58\x7D\x96\xA6\x2A\x5F\x88\x12\xF8\x7A\xED\x96\x4F\x99\x70\x55\x04\x95\x30\x60\x00\x87\xEF\x6B\x98\x44\x87\xC6\x88\xDE\x85\x9E\x76\xC9\x9C\xCE\x47\x30\x9C\x89\x94\x7A\x61\x9B\x33\x9F\x66\x94\xC8\x8D\x49\x93\x32\xE0\x94\xB1\x97\x9D\x85\x14\x9E\x15\x9B\x34\x96\x5A\x6E\x32\xB5\x5D\x18\x99\x6F\x9A\x06\x9B\x2E\x9C\xC1\x83\x67\xB3\x1B\xD5\x99\x46\x8E\x10\x9B\x51\x92\x92\x9F\xB6\x98\x64\xBF\x27\xF6\x99\x47\x92\x14\x9B\xDB\x95\x93\x9E\x4B\x88\x43\xB0\x33\xFC\x94\xC8\x62\x39\x5D\x38\x9A\x86\x95\x75\x96\xFC\x61\x1E\xE1\x96\xE7\x99\x31\x8D\x41\x99\x72\x9C\x99\x96\x5B\x92\x2F\xC6\x98\xE5\x6F\x7F\x98\xF2\x93\x09\x83\xD0\x8D\x0E\x77\x32\xBA\x72\xB9\x99\x4C\x9B\xF0\x8C\x39\x98\xB8\x8E\x64\x8A\x2E\x92\x8C\x0C\x02\xF3\x97", - "\xDB\x94\x98\x9C\x7A\x41\x68\x89\xE0\x49\x99\xA3\x88\xF2\x71\xC3\x97\x3D\x85\xB9\x02\x59\x8E\x06\xA5\x06\xFF\x5F\x0A\x81\xFF\x92\x32\x8B\x08\x8A\xCC\x31\x34\xDC\x80\xF8\x97\x55\x95\x20\x3F\xA6\x9A\xA3\x99\x69\x9B\x2C\xED\x33\x3C\x9A\x27\x97\x16\x9C\xEE\x80\xB2\x9B\x7F\x6E\x34\xDD\x88\xAC\x79\x34\x9B\x0D\x90\x00\x01\xD4\x93\x01\xB3\x34\x8D\x84\x33\x96\xD1\x90\xAF\x97\x6D\x97\xC7\x94\x5B\x85\x30\xCF\x92\xD7\x98\xE5\x95\x02\x9D\xA2\x9D\xCF\x95\x59\x9D\x33\xE4\x99\xA7\x89\xA3\x96\x44\x9F\x3B\x64\xC1\x89\x5D\xA6\x34\xE6\x99\x63\x9B\x73\x6D\x3A\x9F\xAB\x94\x93\x89\x68\x89\xB4\x6E\x99\x94\x93\x73\x98\x56\x8D\x96\x95\xF6\x54\x67\xB8\xED\x60\x96\x27\x61\xB4\x98\x9D\x92\x95\x96\xB4\x9A\x64\x8F\x34\xB0\x8F\xFC\x99\x72\x9A\x3F\x9C\xAE\x9B\x84\x8E\x61\x98\x33\xA4\x99\x6C\x9A\x42\x96\x0D\x9C\xB0\x9C\x9D\x78\x67\xBC\x2E\x8E\x9B\x23\x98\xBE\x9A\x41\x9D\x6F\x9E\xD6\x9B\xEA\x67\x35\x82\x97\x90\x95\xCA\x9A\xAF\x8E\xEB\x8D\xD5\x88\x47\x4B\x31\xDF\x99\x24\x9B\x2F\x4F\x65\x9A\x72\x98\xFE\x69\x4E\xB4\x12\xA9\x37\xCC\x98\xA2\x6D\xFC", - "\x94\xA2\x96\x9D\x9B\x51\xA0\x31\xC2\x9A\xB8\x94\x85\x92\x4E\x9E\x1A\x66\x61\x76\x62\x9E\x2C\xF9\x85\x4A\x9A\x70\x7B\x36\x95\xB5\x9E\xD3\x92\x59\x8B\xA8\x6D\x33\xB5\x9A\x5A\x99\x18\x9B\xFC\x45\xD4\x9B\x6D\xB2\x34\xB1\x96\xE5\x87\x10\x44\x41\x91\xB8\x9F\xDA\x88\x6A\xAC\xC2\x51\x94\xDB\x98\xCC\x94\x63\x9E\xE8\x85\xD5\x9D\x6B\x9C\x2E\xFA\x9A\xA8\x63\xAC\x99\xE6\x71\x9B\x9C\xD5\x82\x6C\x9E\x35\x9D\x9B\xA5\x97\x3E\x98\x1F\x9E\x67\x95\xD6\x91\x60\xA3\x36\xBE\x86\xE7\x9A\xA1\x86\x30\x9F\x90\x9F\xD7\x8C\x53\x8A\x32\xCF\x92\x8D\x99\xA3\x92\x3C\x9C\x77\x96\xD7\x87\x6C\x8A\x36\x95\x99\xD3\x9B\x57\x9B\x42\x9C\x9D\x96\xB6\x9A\x6C\xA9\x73\x01\x9B\x61\x9A\x83\x00\x28\x9A\x3A\x76\xD8\x9A\x6A\xB0\x30\xD8\x9B\xE6\x7B\xFD\x9A\x46\x9C\x92\x95\x7A\x88\x70\xA0\x2B\xB0\x99\x06\x9D\x1D\x99\x83\x99\xBF\x93\xD1\x9F\x61\x9F\x33\xC1\x98\x0B\x9D\x21\x98\x73\x91\xA3\x9E\xD1\x96\x40\x84\x1F\xE9\x9B\xD3\x73\x4B\x94\x5C\x9B\x20\x01\xDA\x8A\x58\x63\x38\xEC\x97\x93\x97\xF5\x9A\x14\x98\x7E\x94\x11\x00\x00\x00\x10\x00\xB7\x47\x01\x00\xFF\x00\x81", - "\x80\x81\x00\x05\x82\x82\x00\x0F\x07\x86\x82\x82\x81\x06\x85\x82\x0D\x0F\x80\x0C\x81\x85\x02\x88\x8A\x18\x81\x84\x8F\x89\x87\x85\x8C\x87\x0F\x91\x9E\x98\x86\x8B\x91\x8C\x8A\x07\x17\xA7\x94\x82\x02\x88\x02\x95\x14\x88\x30\x8B\x91\x80\x92\x84\x06\x33\x82\x9B\x8A\x8D\x8A\x87\x8E\x89\x22\xBE\xA4\x99\x94\x99\x96\x92\x9A\x00\xAD\x8F\x8F\x97\xA2\x82\x99\xA6\x34\xB6\x87\x98\x90\xAB\x82\x89\x9E\x07\xBF\xA1\x84\xA0\x85\x92\xA0\xA4\x00\xC6\x9F\xA0\xBA\xA2\x84\xA7\xB1\x4E\xDC\xA7\x92\xA6\x84\xA8\xB4\x8D\x57\xEA\xAC\xB0\x8A\xB6\xAD\xAC\xB0\x61\xEA\x99\x85\xB7\x87\xB3\xBB\x98\x7A\x98\xB3\xA0\x0E\xB7\xBC\x87\x9D\x07\xD8\x8B\x82\xC0\xA5\xB9\xC0\x94\x8F\x8C\xBC\xA6\x8E\xBB\xC4\xC1\xAA\x6B\x92\x85\xD6\xC7\xC1\xB8\xCD\xC1\x41\x86\xC2\x96\xBC\xC8\xA6\xB0\xD1\x34\x93\xC5\x95\xC5\x81\x8F\xA7\xB7\x2B\x83\xDB\xCD\xD8\x8B\x01\xC8\x81\xB6\x98\xD9\x99\xD0\xDF\x90\xDE\xD4\x2B\xAA\xC0\x05\x3A\xB7\xDD\xD2\x9A\xC6\xB4\xF8\xA9\xE3\x88\xBF\x7E\xE6\xCE\xFF\x42\xE4\xE8\xC8\xEA\xE6\xEB\xCB\xB7\xC1\x98\xE0\xB4\xEC\xA4\xE1\x5D\x45\xDA\xE0\x8E\xE8", - "\xE7\xF1\xE7\xE7\xE5\xC1\xF2\x81\x22\xF2\xDD\xDA\xE9\xF1\xEF\xF4\x8A\xF7\x92\xE1\x09\xEE\xBD\xFB\xD2\xFA\xF8\xFB\xF8\x86\xF5\x7B\x7F\x7C\x6E\xFC\x40\x7E\x6D\x81\xC7\x6B\x7F\x40\x75\xBD\x41\x8E\x7D\x7F\xF4\x48\x8A\x71\x77\xE7\x42\x70\x0D\x7E\x06\x82\x80\x84\x80\x12\x8D\x79\x77\x80\x01\x42\x7C\x14\x86\x09\x87\x80\x88\x79\x1D\x91\x7E\x80\x4B\x12\x57\x85\x75\x8A\xD7\x70\x8F\x87\x86\x02\x56\x84\x8B\x84\x48\x6B\x8C\x87\x89\xE8\x7C\x8A\x8D\x8D\x12\x6E\x07\x8E\x87\x14\xBE\x82\x8D\x91\x34\xA1\x82\x46\x11\x43\xAA\x87\x91\x8E\x4F\xA6\x7C\x8E\x70\x33\x0D\x91\x8E\x91\x58\x89\x98\x8B\x94\x12\x7B\x06\x97\x8C\x19\x8F\x81\x99\x84\x59\xA3\x92\x66\x44\x3D\x1F\x98\x92\x99\x04\xA5\x95\x8B\x5E\x12\x5F\x0A\x98\x94\x6E\xB8\x82\x96\x96\xD2\x52\x41\x1B\x9C\x77\xAC\x9B\x75\x94\x2B\x7F\x8A\x93\x43\x27\x2A\x52\x72\x09\x7C\x81\xA0\xA2\x89\x78\x82\xA9\x52\x44\x85\x98\x67\xA1\xA2\x8C\xBE\x9B\x95\xA3\x8B\xB0\x9F\x43\x18\x94\x9A\x86\xA5\x8F\x98\xB5\x94\x93\x77\x12\x62\x1D\xA6\x98\x6F\xA8\xA6\x9E\xA2\xA2\x8E\x9C\x97\x43\xA4\x6B\xA0\xAB\xA7\x8E", - "\xB3\xA9\xA8\x99\xA1\xB8\x92\x72\x44\xA3\xBF\x9D\xAB\x95\xB9\xB4\xA5\x86\x44\x19\x27\xA8\xAE\xB0\xBF\xA0\x97\xAF\x99\x84\x86\xA2\x44\xA2\x2F\x89\xBB\x9B\xB2\x6D\x81\xB4\xB7\xA0\x0A\x51\xAD\x6F\xA4\xD1\x96\xB2\xAE\xA7\xD7\x97\xA8\xB2\xAE\x90\x8E\xBF\x40\xB4\x0D\x99\xAA\xA9\xAF\xAC\x9E\xBC\xBA\x7D\xE5\x92\xAF\xB2\xB1\x3B\xAE\xBE\xAA\xBD\xC0\x9F\xA2\x70\x0F\xF4\x95\xB3\xBB\xBF\xE1\xB6\xAF\xB7\xBA\xD1\x42\x71\x69\x89\xB5\x89\xCA\xBB\xB1\x01\xC2\x78\x12\x5A\xBC\x91\x73\x62\x22\xFD\xBE\xA8\xBE\xB2\x03\xCC\xC9\xC4\xB3\x0A\x42\x10\xC7\x79\x83\x7E\x15\xC6\xB8\x01\xCA\xC2\xB4\xA9\x0F\x62\x0F\xC4\x8F\x83\x7F\x03\xCA\xC0\xEF\xA0\xBB\xC6\xBF\x25\xC3\xBF\x41\x0B\x2B\xF8\x93\x63\x16\x2F\xE6\xC7\xC7\xB4\x33\xD8\xB7\x43\x15\x39\xDF\xA3\x62\x28\x3D\xCB\xC5\xBC\xC0\x41\xE4\xCD\xD1\x9E\x0F\x64\x05\xD1\xC0\x83\x44\x1A\x58\x62\x06\x51\x02\x5D\x63\x98\x71\xA1\xCC\x46\x58\xC5\x4A\xD7\x67\x5C\xFD\x6E\xD5\x74\xA7\x4D\xCE\x4A\x5A\xAF\x46\xDA\x67\xD5\x12\x63\xDD\x6C\x68\x8E\x7C\x89\xDB\xD3\xC2\x6C\x6F\xB9\xDB\x54\xEF\xD8\x65\xD8\x00\x32", - "\xD6\x80\xDD\x5D\xE7\x77\xDF\xD7\x2C\x8B\x5C\xD8\xC8\x7E\xFD\x60\xE2\xE0\x25\x84\xE6\xDA\xE1\x36\xE6\x5B\xE0\xCB\x8D\xC6\x8F\xE3\xD6\x5B\x45\xE6\xDD\xE5\x7D\x57\xEA\xCD\xE6\x25\x9B\xE4\xD9\xE7\x93\xDF\xEF\xAA\xE5\x98\x7C\xDF\xD2\x6C\x49\xE7\xCD\x9E\xDA\x0B\xB1\xEF\xCC\x9D\xE4\xB5\xED\xB4\xD3\x88\xCB\xD5\xCE\xEC\x0A\x8A\x41\x7B\xEE\xBF\xF7\xE3\xEF\xD3\xB5\x82\x7D\x78\xF1\xC8\xCA\xD4\xCD\xF3\xAB\xC7\x48\x7C\xF3\xBD\xCF\xF5\xF6\xC5\xBC\xF7\xB9\xF5\xBE\xC5\xDB\xF8\xC7\xF5\x8F\xBA\xE9\xB8\xF0\x95\x9D\xF6\xF8\xDE\x2D\xB6\xEE\xF4\xD0\xE0\xF0\xC5\xC2\x44\x23\x94\xFA\xF7\xF9\xED\xFE\xCA\xBD\xFA\xF2\xDC\xF0\xF6\xF1\xED\xB7\xFF\x42\x8B\xE3\x7C\x7D\xF9\x7B\x7B\x7C\x94\x4A\x22\x48\xF9\x7F\x7B\xFC\x04\x84\x7F\xF7\x4F\x24\x49\x09\x8C\x7F\x02\xF5\x7E\x78\xEC\x74\x72\x21\x55\x51\x80\xEE\x05\x87\x78\x0A\x91\x7E\x20\x5E\x5A\x81\x07\x93\x84\x84\xFD\x6D\x7A\x38\x69\x42\x85\xFF\x0D\x86\x84\x07\x8A\x22\x4E\x2A\x83\x82\x07\x82\x8A\x52\x85\x3B\x49\x86\x32\x73\x84\x07\xAB\x88\x7D\x66\x72\x5F\x5C\xEA\x6C\x86\x02\xAD\x8E\x38\xE1\x1A\x5E", - "\x40\xDC\x41\x83\x0E\xB2\x85\x85\x21\xB8\x2A\x38\x9C\x58\x84\xC1\x44\x8E\x88\x09\x85\x8D\x54\x41\x8C\x82\x16\xBA\x82\x88\xB2\x12\x27\x6C\x53\x95\x8B\x06\xDD\x83\x8D\x1E\xBC\x52\x89\x64\x83\x84\x15\xD6\x8F\x88\x62\x59\x8C\x8B\x5B\x8D\x8A\x17\xBE\x8B\x5B\x79\x52\x8A\x63\x70\x99\x8E\x1C\x86\x87\x21\x23\xA5\x41\x89\x06\x56\x7D\x1A\xBC\x8A\x8F\x2B\xB4\x88\x89\x76\x88\x8D\x1C\xEB\x85\x8D\x42\xAD\x8F\x90\x7F\x89\x91\x20\x95\x8E\x68\x47\xAC\x8F\x92\x7C\x86\x20\xBF\x77\x8E\x77\x45\xA2\x8A\x8D\x9F\x81\x7B\x41\x07\x62\x56\x41\x9E\x90\x93\xA0\x93\x8E\x42\x0F\x68\x33\x88\x4E\x3B\x62\x6F\x9B\x8D\x2A\x8D\x9E\x85\x83\x1E\x65\x95\x8C\x6F\x22\xC8\x1C\x96\x7A\x59\x84\x96\x97\xF0\x49\x67\xD4\x2F\x72\x22\x97\x7C\x96\x82\xA7\x94\x94\x23\xA9\x32\x22\x9C\x78\x90\x73\x0F\x3C\x67\x31\x95\x90\x99\x1C\x95\x98\x23\xC2\x24\x6B\x33\xA3\x7F\x20\xA4\x53\x9E\x7D\xCB\x9F\x95\x38\xCC\x86\x90\x85\x12\x6B\x9B\x6E\x6F\x22\xD5\x7F\x62\x22\x07\x1C\x72\x21\xA4\x8F\x5C\x18\xF8\x20\x70\x77\xA7\x70\x9E\x75\x78\x4F\xE1\x35\x94\x32\xD1\x69\x9F\x26\x70\x6F", - "\x22\x3D\xF3\x65\x6C\x03\x73\x98\x2C\xFB\x85\x9D\xE8\x2D\x79\x96\x80\xAC\x9A\xA0\xEF\x83\x95\x3E\x9F\x59\xA1\x47\xAC\x75\x37\xAE\x6D\x7C\xEC\x0F\xAA\x21\x81\x83\x75\xA0\x25\x47\xA2\x69\x20\x7D\x9E\x86\x90\x9E\xA1\x8E\x6D\x9D\x44\x86\x21\x9F\x8C\x22\xA5\x28\x24\xAB\x36\x3F\xFD\x6F\x21\xD9\x2F\x5D\x9E\x2B\xB4\x2E\xE7\x7A\x91\xA6\x00\x3A\x6E\x35\x0D\xB3\x29\x2C\xE3\x96\x9A\x85\x86\x24\x41\x93\x84\x7D\x51\xA1\x91\x98\x85\x08\xA8\x61\x94\x80\x9C\x53\xCB\xAA\x95\x83\x03\x7A\x91\x96\x8A\x9B\x54\xE1\x85\xAA\x83\x0B\x78\xAB\xD7\x98\x8D\x58\x9D\x97\x84\x89\x13\x78\xAC\x44\xBC\xAA\x56\xA8\x92\x9D\xAD\xA2\xA9\xAD\x6F\xB6\xA3\x41\x4F\xA5\x95\xA8\xA6\x91\xAB\xCC\x9F\x7F\x50\xEE\xA4\xAD\xB1\x80\x4F\x21\xF1\x68\xAC\x5F\xBD\x90\xAF\xBE\x86\xAD\x20\x00\x89\xA8\x0D\xEA\xA3\x97\xC6\xA2\x96\x20\x89\xB0\xAA\x52\x8C\xBD\xAC\xB6\x8D\xAF\x20\x08\x82\xB2\x65\xD4\xAB\xAD\xCE\xB9\xAA\x21\x10\x9A\xB2\x67\x95\xB3\xB4\x72\x83\xB2\x68\x06\x39\x82\x68\x8E\xB6\xB5\xCD\x94\xB7\xB2\x20\x9B\xAE\x6B\xF1\xA3\xB6\x8E\x47\x21\x85\xAB\xA4\xB4\x6B\x9C", - "\xBF\xB3\x83\x30\x81\xB7\xAD\xA5\xB4\x6F\x8F\xB5\x21\x1B\x80\xBB\xB8\xC1\xBB\xB7\x6B\xB5\x8D\x8E\x73\x4A\x20\x5D\x8A\xAB\x88\x72\xD3\xBB\xB8\x6C\xB1\x5D\x8E\x40\x9F\x9B\x5D\xFE\xA8\x99\xB2\x9B\x52\xB6\xC2\xB5\xB8\x6D\x99\x95\x20\x53\x5A\xBE\xAE\xE8\xBF\x81\x41\x2F\xA4\x9B\xC2\x84\xB7\xB4\xED\xB2\xAF\x19\xF5\xA3\xB3\xF1\x8A\xBE\xBE\xC4\xA0\x01\xB1\x67\xB5\xBE\xC3\xB0\xB8\x6A\xD9\x4E\xBB\x41\x50\xB2\xB3\xC5\xB8\xB9\xB9\xBA\xB9\xBE\x1F\xB2\x50\x91\x02\xD2\xBA\xBC\xFE\xB5\xB7\x5F\x81\xCF\x87\xE7\xA0\xBF\xBE\x11\xC1\xBD\xE2\x14\xC8\xBA\x0B\xFC\xBE\xC0\x19\xD8\xC3\x7B\xDD\xA5\x21\x4D\x87\xB8\xC2\x23\xDA\xC1\x88\x89\xC0\xB6\x9D\xA7\xC7\xC0\xD4\xB0\xC4\x8A\xA8\xB5\x20\x56\xBD\x36\x95\x78\x30\x97\x87\x8F\xC2\xC7\x1E\xF6\xB6\x20\xB7\x97\xC5\x50\x86\x2B\x97\x17\xEB\xC0\xC1\x48\xD1\xC7\x8F\x85\x2A\x64\x74\xB4\xA2\x21\xC6\x86\xC9\x8A\xA2\xCD\xBA\xEE\xA1\x7A\x21\xCE\x82\xCB\x49\x87\x22\x9A\x29\xD5\xCE\xBD\x5F\xDF\xBD\x36\xC3\x9A\xA2\x89\x1E\x9E\xCB\xF1\xB2\xC1\x98\xEA\xC9\xCC\xF2\x80\x07\x9C\x5A\xDC\x9A\x42\x6B\x99\xA5\x87", - "\x10\x01\xA7\x00\x0D\xA7\x50\x3C\x40\x71\x3B\xF7\x9A\xA2\x3B\xB4\xA1\x4F\xBF\xA8\x23\x8C\x92\x64\x74\xB2\x5D\xCC\x9E\xFA\xC4\x22\xF6\xA7\x25\xA2\x24\xDE\xA7\x4C\xC4\x95\xA7\x80\x8A\x26\xCF\x04\xA8\x76\x41\x94\x7A\xBC\x49\xE6\xA2\xCE\x42\xBC\xA3\x41\x18\xDF\xA2\x4D\xE1\xA4\xD3\xB9\x77\xA2\x81\x06\xDF\x94\x44\xF7\xA2\x22\xA4\xD1\x70\x48\xB2\x5E\xD1\x8C\x10\xD6\xCD\x84\xD7\x30\xA8\xED\x26\xD3\x51\xCB\xD3\xA2\x01\x77\xD5\x6F\xA5\xA8\xA3\x21\xC5\x26\xA6\x2E\xA7\x3D\xAD\x98\x22\xD9\xFC\xB9\xD4\x21\xAC\xD9\xC6\xAB\xC9\xDA\x75\x54\xCB\xA5\xD8\x5B\xDC\xD5\xA0\xC1\xD3\xD1\x49\xE5\xCD\xD2\xDB\xCF\x69\xB3\xAD\xCE\xD2\x6C\xFB\xD7\xD8\xC0\xC2\xDD\xB7\x9F\xDF\x9F\x50\xE9\x74\xA7\x9D\xCF\xD9\x5A\x59\xD8\xDD\x1D\xC3\x91\xC9\x33\xCD\xCF\xB0\x85\x24\xAF\x77\x5B\xB8\xCC\xFA\xCC\xC6\x92\x93\xC3\xAF\x0B\xC2\xE1\xDF\x52\xAC\xCD\xC2\xEE\xC7\xAB\xE8\xB7\xDB\xE0\x6B\xCA\xC7\x94\x87\xEB\xC3\x83\x1F\xAE\xE1\xC9\x94\xC9\xC0\xF8\xDE\xC7\x89\xE4\xDF\xAC\x18\xF8\xAC\xC5\xC7\xC0\xE3\x8D\xE5\xE3\xE1\x1A\xE8\xE7\xC8\x9E\xE7\xE5\xE4\x52\x25\xDF", - "\x2D\xE9\xBC\x88\xAC\xE8\xE0\x1B\x76\xD9\xE3\x2B\xF1\xE1\xCA\xAE\xE0\xB0\x83\xDC\xE4\xE4\x08\xFF\xDE\x7C\x88\xBE\xE7\x98\xFD\xBC\xE6\x1D\xF4\xC4\x00\x11\xB4\xBF\x99\xFA\xE1\xE7\x26\xE1\xE9\x4F\x99\xB1\xE4\x2B\xEA\xE7\xE7\x48\xE0\xE9\xD2\xD7\xC7\x21\xD0\x95\xE8\xE0\x57\xE6\xEA\xD3\xD1\xEB\xEA\x00\xC7\x22\xB5\x5F\xFF\xBE\xD0\x8A\xEB\xEC\x37\xE1\x80\xCD\x61\xF2\xEB\xD1\xCF\xE8\xEA\xA5\xF8\xB1\xED\x6C\xF2\xE4\x8F\xCB\xC0\x01\xDF\xB8\xEA\xE2\x74\xE2\xEF\xDE\x84\xE6\x20\xE3\xBF\xEB\xE7\x7A\xEF\xE1\xCD\xD7\xB8\x91\xEC\xB0\xED\xED\x88\xF3\xEC\xD9\xFC\xEB\xC1\x77\x4D\xC5\xE9\x83\xE1\xF2\xDC\xE3\xE1\xEF\x8A\xC6\x21\x8A\x8F\xE9\xF0\xCE\xF5\xE3\xF2\xC2\xE5\xBD\xE8\x9B\xF9\xF1\xE9\x9A\xF5\xEC\xE1\x0E\xD0\xF2\x50\xFD\xF2\xD6\xB3\xF9\xEA\xD3\xE7\x8A\xF0\x8A\xE5\xEC\xEC\xA4\xF6\xEC\x83\x3B\xB9\xF4\x92\xF2\xF5\xED\xAC\xF4\xF6\xA5\xD5\xF4\xB9\x06\x24\xC0\xE6\xB9\xF5\xF9\xD5\xCE\xFA\xF8\xC4\xF6\xF7\xF1\xD6\xBE\xF1\xC3\xF1\xF3\xF7\xB8\xE3\xF4\xF2\x85\x23\xFA\xCF\xC5\x22\xF9\xFE\xC2\xF6\xC8\xBC\xF8\xFA\xEA\xDC\xC5\xF1\x1E\xC0\xF8", - "\xE7\xE5\xFA\xF7\xA8\xBB\x58\xF5\xED\xE1\xF8\xFB\xCD\xFD\xF6\x17\xD6\xFC\xFC\xE2\xF6\xE8\xCF\xAB\x94\xCD\x43\xCF\x24\x62\x37\x73\x7E\xD9\x72\x80\x8B\x7F\x10\x41\x66\x20\x38\x60\x16\x21\x30\x7F\xF4\x73\x7F\xC3\x7F\x7C\xC2\x1D\x64\x71\x6D\x6E\x06\x11\x65\xF7\x73\x80\xFA\x79\x7F\x87\x50\x00\x59\x68\x80\xC6\x60\x00\x5D\x67\x81\xA9\x7C\x7C\x0F\x80\x7D\x10\x82\x11\xDA\x43\x81\x4F\x67\x10\x67\x62\x82\xF1\x7B\x7E\x1A\x82\x66\x12\x10\x67\x1E\x84\x6F\x00\x04\x67\x2E\x8D\x80\x31\x81\x69\x30\x73\x82\xDA\x7E\x83\xDE\x5E\x54\x0C\x85\x82\x0E\x81\x7D\x4A\x7D\x70\x0E\x64\x82\x46\x8F\x7C\x45\x8C\x75\x5E\x53\x84\x4B\x86\x82\x52\x8B\x7F\xD2\x30\x85\x4C\x8B\x83\x80\x77\x85\xF2\x7E\x7E\x2F\x76\x85\x53\x88\x85\xFB\x6B\x74\x5E\x8D\x84\x5F\x8D\x69\x81\x59\x83\x44\x80\x86\xB1\x76\x73\xEA\x7A\x7A\x65\x8C\x79\x6C\x88\x86\x51\x84\x86\x64\x82\x1C\x54\x79\x84\x3F\x8F\x82\x6E\x84\x85\x06\x1E\x75\x78\x84\x80\x7A\x8A\x84\x5A\x86\x6D\xA9\x53\x86\x6A\x8C\x7B\xC2\x1F\x76\x72\x83\x88\x7B\x8C\x85\x0F\x17\x77\x7F\x89\x81\x5B\x8D\x69\x7E\x71\x89\x60", - "\x74\x87\x3D\x56\x78\x96\x8A\x76\x87\x87\x72\x46\x42\x60\xC9\x76\x88\x93\x80\x87\x8C\x71\x49\xD5\x7B\x89\x79\x73\x8A\x6E\x80\x45\xA2\x80\x83\xC1\x72\x1C\xE6\x5D\x86\x82\x8F\x86\x8D\x8D\x69\xAF\x7D\x89\x40\x86\x75\xBB\x2D\x8A\xB5\x84\x8A\x0F\x1F\x7B\x8B\x84\x8B\xB3\x85\x87\xA5\x8C\x60\x92\x48\x8A\x59\x82\x8C\x79\x84\x7F\x9F\x85\x61\x03\x6C\x8B\xC3\x8E\x88\xE7\x76\x8A\xE9\x71\x8C\x98\x8A\x8A\x17\x4D\x5C\xCE\x81\x8A\x01\x82\x89\xAE\x8E\x8B\x0A\x16\x62\xD6\x88\x8B\x81\x8B\x8C\xB6\x7C\x68\x3A\x88\x8D\xE6\x81\x85\x0E\x3D\x7F\xAD\x6F\x7F\xD0\x8B\x8E\x8C\x89\x8D\x40\x6E\x8E\xD2\x6A\x4B\xF1\x80\x88\xE9\x84\x88\x4C\x66\x8F\x0A\x85\x4C\xF9\x8E\x8D\xAB\x8D\x4C\xFE\x88\x14\x3B\x31\x90\x97\x82\x8D\x43\x35\x90\x51\x16\x66\x08\x9C\x89\xEA\x81\x84\x07\x14\x83\x25\x29\x80\x06\x92\x11\x38\x85\x3A\x66\x5F\x6B\xE1\x6D\x3E\x80\x30\x72\xB2\x66\x6A\xB4\x68\x6A\xFE\x3A\x6A\x25\x21\x6D\xFF\x80\x6E\xEF\x6F\x29\xCB\x60\x19\xF1\x6E\x6D\xFE\x78\x52\xE3\x81\x91\x02\x93\x8B\xD3\x1F\x90\xA9\x8F\x8D\x25\x95\x70\xDD\x89\x90\x34\x9E\x93\xFC\x80", - "\x00\x48\x8B\x7C\xF2\x8A\x8C\xFA\x89\x86\xAF\x8C\x1E\x38\x99\x8C\xD7\x80\x8E\x55\x8D\x93\x10\x9A\x93\xD1\x8F\x93\x51\x9D\x8B\x56\x94\x8F\xFC\x6B\x94\x91\x72\x95\x45\x91\x87\xC8\x8B\x95\x57\x95\x94\xC4\x8D\x73\x50\x99\x93\x61\x97\x94\xEC\x88\x3F\xB2\x82\x96\xE4\x8B\x8F\x3B\x90\x59\x5A\x97\x7D\x6D\x95\x82\x76\x81\x97\xF8\x74\x95\x0A\x72\x1C\x7E\x84\x94\x68\x93\x8F\x6C\x98\x97\xC9\x84\x25\x76\x98\x81\x40\x93\x90\x0F\x1A\x88\x5F\x92\x97\x80\x90\x96\x36\x98\x26\x83\x99\x8B\x85\x98\x95\x7D\x7F\x98\xE5\x8D\x97\x52\x82\x1C\x9A\x8C\x97\x35\x9F\x97\x5C\x96\x99\xCD\x8D\x61\xCF\x85\x96\x4C\x93\x97\x73\x8D\x53\xDD\x7C\x77\xE0\x74\x98\x55\x93\x95\x9D\x9C\x4F\x05\x10\x7A\x33\x9D\x9A\x91\x9C\x99\x6F\x97\x7A\xA2\x9C\x98\xB4\x9C\x9A\x86\x9A\x10\xB7\x8B\x98\x8A\x92\x9B\x32\x83\x5F\xB1\x97\x96\x9B\x96\x99\x7C\x85\x10\xC0\x89\x98\x77\x90\x9C\x66\x9D\x98\x90\x46\x8C\xA7\x8A\x99\xB3\x96\x9C\xA4\x97\x82\xCF\x96\x79\xC7\x82\x9D\xAB\x99\x9B\xDC\x9E\x99\xC5\x88\x9D\xD1\x91\x7E\xBE\x9B\x9C\xC4\x90\x76\x9F\x98\x7E\xA1\x9B\x96\xD4\x93\x9E", - "\xAA\x99\x97\x12\x12\x8E\xCA\x9D\x9E\xA3\x9C\x9E\x90\x93\x74\x79\x64\x99\x6E\x9A\x9B\xCE\x9C\x7F\x4E\x64\x69\x0A\x10\x80\xEA\x95\x9C\x02\xA3\x9D\xAE\x90\x00\x07\x85\x91\x1F\x85\x64\xC3\x9A\x9F\xDD\x93\xA0\xF6\x92\x81\x35\x87\x6E\x00\x06\x81\xF1\x95\x9F\xCD\x9D\xA0\xE6\x94\x90\xFD\x9F\x6D\x0A\x11\x82\x15\xA5\x99\x0E\xA7\xA1\xDE\x9F\x10\x29\x81\xA1\x14\x85\x10\x2D\x8F\xA1\xF9\x98\xA1\xDB\x9B\x9E\x41\x94\x91\xB2\x26\x91\x0D\x9A\x4E\xF8\x98\x94\x4E\x97\x54\x35\xA5\x9A\x49\x92\x3E\x0B\xAC\xA2\x22\xAA\x8B\x12\x13\x94\xE2\x9C\x9C\xF3\x94\xA4\x61\x87\x71\x2A\xA6\xA3\xE5\x9D\xA2\x05\xA0\x92\xDA\x9F\xA3\x04\xA1\xA5\x4C\xA2\xA5\x50\xA1\x9C\x42\x87\x9B\xBF\x9B\xA4\xEE\x9A\x57\x58\xA4\x9E\x0C\xA3\xA2\x0A\x17\x86\x49\xAA\xA3\x46\xA9\xA5\x92\x9C\x74\x43\xAA\xA5\x45\xAA\xA6\x61\x88\xA6\xF2\x98\x9B\x2E\xAB\x9B\x98\x59\xA3\x7E\x91\xA7\x92\x9B\x97\x69\xAF\xA5\x21\xAB\xA6\xFB\x97\x76\x74\xA6\x94\x7B\xA1\x86\x88\x9F\xA4\x7C\xAE\xA3\x85\xA2\x91\x06\x10\x89\x84\xA0\xA7\x81\xAB\x86\x71\x2F\xA7\x4D\x95\x9B\x00\x09\x99\x79\xA6\xA8\x8C", - "\xA4\xA5\x6E\x67\x9A\xB6\x79\x9A\x16\xA7\xA8\x8D\xA8\x88\xDF\x9B\x7D\x00\x0C\xA9\x20\xA8\xA9\x97\xA6\xA5\x07\x10\x9B\x63\xA5\xA7\x9F\xAF\xA6\xF9\x51\x8B\x3D\xA6\xA7\x96\xA6\xA6\x66\x47\x10\xBD\x95\xA6\x5E\xA3\xAB\xE4\x62\xA3\xAC\xA6\xAA\xB4\xA0\xA6\x07\x19\x9C\x8B\xAF\xAB\xAD\xAD\xA9\x61\x8A\xA9\x4A\x74\xAA\x2B\xA2\xAB\xCC\xA0\xA4\xD7\x92\xAA\xCA\xAA\xA4\x7A\xAE\xAB\xA0\xAF\xAC\xE6\x79\x9E\xB1\xA5\xAC\xA5\xA8\xAA\x06\x18\xAC\x4E\x8F\x7D\x90\xA5\x9D\x80\xAB\x81\xF0\x93\xAC\xB9\xAD\xAC\xD4\xAE\x89\xB3\x65\xA9\xE8\xA3\xA5\xEE\xA1\x69\x36\x66\xA2\x2B\x86\x10\x00\xA9\xAD\xE9\xA6\xAC\x8E\xA6\x80\x0C\x91\x1B\x12\x1A\xA0\xAB\xA3\xAE\xEF\xAE\xA9\x1B\x80\xA1\x08\xA6\x83\x14\xA6\xAE\xAE\xA7\xAE\xDA\xAC\x77\x1D\x85\xB0\x12\xAE\xA1\x08\xB8\xAF\x0A\xB7\xAF\xDE\x70\x00\x25\xAE\xB0\x27\xA0\x00\x29\xA1\xB1\xDB\xA5\xA5\x1E\xB1\x98\x33\x8B\xAF\x99\x14\xA3\xA2\x66\x10\x14\x0C\x91\x2B\x91\x30\x80\x37\xB2\x7F\x6C\x52\xE9\x6D\x3E\xE3\x62\xAA\xF2\x61\x10\x28\x97\x91\x2A\x9B\x69\x3C\x2D\x92\x0C\x11\xB3\xD7\xA4\x6C\xAB\x6F\x81\xC8\x62", - "\xB1\x09\xB3\xB4\x42\xBD\xB3\x59\x9D\xA5\x44\xBD\xB1\x02\xB6\x9F\x3D\x8A\xB4\xA7\xAF\xB1\x4F\xB0\xB2\x0F\x12\xA4\x49\xBB\xAC\x0B\xB2\xAD\x5D\x9A\x94\x48\xB5\xB4\x4E\xB4\xAC\x19\xAF\x10\x4E\xAC\xAE\x57\xB4\xA6\x6C\xAE\xB5\x01\xB1\xB5\x68\xB6\xB6\x5B\xA7\xA5\x01\xA4\xB1\x56\xBE\xB6\x74\x9A\x96\xF6\xA7\xB6\x6A\xBB\xB4\x6B\xB7\x10\x62\xAC\xB1\x6F\xB4\xB7\x13\xBC\xB7\xA2\xAE\xA6\x5C\xBB\xB7\x50\xB5\xB7\x29\x7E\x95\x7A\xB8\xB5\xED\xA3\xB8\x7D\xB1\x69\x77\x87\xB8\x64\xB3\xAD\x7E\xB1\xB8\xB6\x78\xA7\x55\xB8\xB8\x63\xBD\xAB\x91\xB5\xB1\x68\x7F\xAF\x91\xA0\xB9\x8A\xBA\xAE\x87\x91\xAE\xF4\x9D\xB5\xD5\xAA\x10\x8A\xA2\xB6\x70\xBF\xB8\xBA\xA0\xBA\x2F\x42\xBA\xB8\xA5\xB9\x4A\x74\xA9\xB0\xB8\xB9\x9F\xB2\xB9\x69\x96\xAD\x15\xB1\xAD\xAA\xB9\xB8\x76\xBD\xBB\x85\xB1\xAA\x46\xB3\xAA\xAE\xB5\xB6\x8B\xB2\xB5\x0A\x1A\xAA\x8E\xB4\xBB\xBE\xB4\xB8\xCC\xB4\x6E\xB0\xAC\xB9\xE2\xAD\xB9\xAB\xB5\x80\xBC\x93\xBC\x9E\xBB\xBC\xA5\xB2\x9C\xA8\xB9\xB9\x82\xB8\xBD\xB3\xB5\x7F\xFA\x56\xBD\xD3\xB4\xBA\xAC\xBA\x8D\xA0\x9C\x8D\x6D\xBC\xBD\x96\xB9\xBA", - "\xD6\x93\x8D\xD0\x95\x8D\xD0\xB3\xBA\xDD\xB9\xB6\xD9\xBD\xAD\xA0\x80\xAE\x5B\xB4\xBE\xB6\xBA\xBC\xBF\xB8\xBB\xA8\x92\xBE\xBC\xB4\xBF\xDF\xBF\x7E\xF9\xB3\xBF\xCD\xBF\xBD\x63\x98\x4F\x05\xCB\xBE\xEA\xBB\xBB\xCE\xAC\x9F\x2A\x8E\x9F\x07\x15\xAF\xF1\xBF\xBA\xFB\xB0\xB0\x77\xB5\x8F\x1B\xA1\x93\x07\x1E\xAF\xC9\xB8\xC1\xDE\xB7\xC1\x09\xC7\x10\x04\xB1\xA3\x1F\x87\xB0\xDB\xB5\xBB\xFA\xBB\xC2\x06\xC4\x6E\x0D\xB6\xC2\x36\x80\xB1\x29\xC1\xC2\x2C\xCC\xC0\x2A\xCC\x77\x17\xB0\xC3\x12\xAB\xB1\x33\xC2\xC0\x22\xC1\xBD\x0A\x96\x10\x30\xAF\x2E\xBC\xA3\xB2\x73\x60\xC0\x97\xB7\x99\x5D\x8B\xC0\x0E\xCC\xBE\x4A\xCC\xA3\x15\xC4\xBC\x08\xC1\xC4\x05\x14\xB5\x3F\xC2\xBF\x36\xC6\xBC\x16\x78\xC4\x4E\xC3\xC2\x06\x11\xB6\x53\xC8\xC5\x4D\xCD\xC0\xFC\xB7\xC0\x57\xC1\x94\x4D\xBD\xC2\x61\xC6\xC1\xAD\x72\xB7\x51\xC7\xBD\x3E\xC5\xC3\x4A\x79\xB7\x3D\xC6\xC6\x72\xC5\xC6\xF5\xB4\x74\x4C\xC8\xC7\x6B\xC2\xA7\x70\x9B\xC7\x20\xC1\xC7\x6A\xC1\xBC\x8D\xB5\xC7\xC5\xB2\xC8\x59\xCD\xBF\xA0\x5C\xC5\x64\xC1\xC8\xF9\xA8\x41\x8C\xC7\xC3\x89\xC9\x5F\x83\xA6\xC8\x7D", - "\xC0\xC7\x76\xCC\x77\xA7\xB7\xC9\xE3\xB3\xC8\x15\xB5\x89\x1F\xC2\xBD\x01\xCF\xC8\x07\x12\xBB\x67\xC2\xC5\xA7\xC2\x99\xDE\xA0\xBE\xBA\xBC\xC7\xA9\xCD\xC9\x71\xBE\xBF\x9B\xA1\xC9\x34\xCE\xC9\x7C\x78\xBC\x96\xCF\xCA\xA3\xC7\xC8\xAF\xA4\xCB\x88\xC3\xC6\x19\xCB\x5E\xBE\xC9\xC9\x93\xCB\xAB\xC3\xCC\xCB\xC8\xC2\xAA\xC2\xA9\xCB\x77\xCE\xC8\xC9\xC4\xBD\xE6\xB8\x9E\xE8\xB3\xB7\x92\xC0\xCC\xB5\xC2\x7D\xF7\xB2\xBC\x80\xC2\xCA\x49\xC7\x9C\x00\x0B\xCA\x97\x7C\xCC\xB6\xC5\xCC\x9C\xC8\xA8\xDC\x79\xCD\xAD\xCE\xCC\xE5\xCD\xCD\x54\xC0\x00\xE5\xA2\xCE\xE4\xCA\xCB\xEC\xCD\x69\xE8\x81\xCF\xCD\xCC\xCD\x5F\xB0\xC1\xF2\xA2\xC1\xF4\xA7\xCC\xEB\xC9\xCF\xB6\x42\xB2\x5A\x1A\x10\x1E\xC0\xCF\xD6\xCF\xCB\xAE\xCD\xC6\xC2\x4B\xC1\xEF\x80\x65\xFE\xC2\xCF\x00\xD6\x10\x2F\xC4\xC4\x1F\x82\xC3\xFF\xCD\xC8\xF8\xC6\x9F\x39\xC4\xD1\x36\x8C\xC3\x17\xD5\xCD\x09\xD3\xCE\x4A\x73\xC4\x19\x15\xC4\x03\xD7\x10\x19\x99\x68\x12\x15\x01\x28\xB8\xB3\x78\x20\x38\x2C\xDD\xB2\xF6\x77\x6A\xD5\x62\xA9\x33\xB0\x10\x35\xB3\xA3\x32\x94\xD3\x78\x2A\xB3\x02\x1C\xB3\x15\xB7", - "\xD3\xFF\x09\xD3\xFC\xA7\xB3\x6F\xC0\xCB\x07\xD4\xCC\xB7\xBC\xB6\xD4\xC7\xCD\x49\xDF\xCC\x0A\xDC\xD4\x47\xDB\xCB\x1F\xDE\xD4\xED\xB6\x55\x0F\xD7\xCF\x40\xCD\x69\x48\xA1\xCA\x5B\xDC\xC6\x22\xD7\xD5\x5F\xC9\xD5\x61\xDA\xCE\x10\xD8\xD1\x5F\xD8\xCA\x51\xDC\x93\xE9\xB0\xD2\x66\xDA\xD5\x3B\xAA\x10\x80\xB0\xD7\x60\xD6\xCF\x65\xDE\xCD\x74\xC5\xD5\x08\xDF\xD6\x77\xDD\x53\x73\xDD\xD7\x62\xC1\xD2\x76\xD1\xCB\x72\xD4\xD6\x83\xDF\xD4\x03\xC1\x24\x86\xD8\xD8\x67\xD1\xCC\x00\x04\xB9\x8D\xD6\xD5\x7C\xD7\xD8\x82\xDA\x74\x9B\xBE\xD5\x81\xD3\xD9\x8C\xDD\xCC\x89\x8B\xD8\x95\xDF\xD9\x9A\xDF\xAD\x00\x0B\xC9\x91\xDB\xD7\x19\xDE\xD8\xA0\xC6\xD0\xA0\xD7\xDA\x92\xDE\xCD\xA6\xC4\xD7\x6A\xD0\xD8\x75\xD6\x7C\xE8\xCE\xD9\xA1\xD7\xDB\x5E\xC7\xCE\xDB\x88\xBF\x6D\xDD\xDA\x69\xD8\xC9\xE4\x68\xCB\x7A\xDA\xD4\xAB\xD2\xAE\xB0\x86\xDB\xAC\xD6\xDA\xED\xC7\xAB\xB1\xD4\xD9\xB8\xD6\xDC\xDA\xB3\xD5\xF3\xC3\xDB\xC5\xDD\x69\xCB\xC3\xDC\x50\xD2\xDB\xCD\xD4\xDB\xBB\xDA\xCD\xBD\xDA\xDC\x99\xD9\xDC\x0A\x65\xDB\xDB\xCF\xDB\x48\xD0\xDA\xE7\x94\x8D\xD8\xA2\xDD", - "\x5D\xC6\xDE\x54\xD1\xBC\xE0\xC9\x9D\xAA\xDF\xDC\xE1\xDE\xDE\x0F\xC7\x10\xEF\xC8\xDD\xFA\xD5\xDA\xC4\xD0\xBE\xF5\xCB\xD9\xDA\xD0\xDC\xFB\xD5\xB1\xF1\xA8\xB1\xF3\xA5\x10\x14\xC8\xD9\xD4\xD4\xDF\x0B\xEE\xCD\x07\xAA\xC3\x19\xB5\xD0\x03\xE1\xE0\xE7\xD7\xDB\x11\x82\xD0\x8C\x1F\x10\x28\xC3\xE1\xCE\xD2\xDE\xD9\xD6\x7B\x13\xD5\xD2\x15\xD8\xDC\xF6\xDE\xC4\x63\x6C\xD0\xF7\x8A\x10\x1E\xDC\xDF\x1F\xE0\xE0\x1D\xED\xCE\x24\xD8\x11\x26\xD9\xE1\x47\xC5\xDE\xF5\xD9\xD9\x37\x96\xE3\x0D\xE0\xDD\x50\xCA\xE0\xDB\xD5\xDD\x0B\xE0\x1E\x24\xE7\xE3\x37\xA5\x10\x5D\xD3\xDF\x1E\xEC\xE1\x2E\xEA\x74\x60\xCC\xE2\x4A\xE0\xE4\x3F\xEC\xE0\x51\xE9\xDB\xC3\x13\xE4\x3B\xE1\xD7\x07\x1F\xD7\x2F\xE4\xE4\x53\xED\x53\x79\xDE\xE4\x60\xE0\xDB\x67\xA6\xE5\x5D\xE8\xE5\x7F\xCF\xDD\xFD\xD9\xE4\x17\xC5\x97\x3A\xE5\xE6\x57\xE1\x94\x90\xD2\xE6\x15\xEA\xE6\x9C\xD2\x11\x97\xD8\xE4\x25\xE8\xD6\x66\xE5\x10\x95\xCF\xE4\x52\xE2\xE0\xD0\xC9\xA8\x64\xE0\xE8\x6B\xD6\x10\xA9\xDE\xE7\x74\xE5\xD6\x98\x93\xE8\x73\xED\xCE\xF1\xD1\x9E\x88\xE9\xE7\x6E\xD9\xDE\xEF\xBB\xDE\x3E", - "\xE4\xE8\x14\xEF\xDE\x15\xB2\xDC\x61\xE9\xE9\xD3\xD2\xA9\xCF\xB7\xE9\x8D\xEC\xE5\x98\xE6\x7B\xCC\xD5\xEA\x4B\xE0\xE5\x7D\xA2\x9C\x91\xE4\xEA\x15\xE2\x1C\xD7\xDD\xE9\x5B\xEF\xE6\x92\xAF\xE8\xF0\xB2\xEA\x9A\xEE\xE9\x26\xE0\xBC\xB9\xBC\xE8\xB9\xEE\xDC\x94\xE0\x9E\xB7\xE8\xE7\xAE\xEF\xEB\xA9\xE0\xBE\xB6\xE6\xE9\xC4\xE4\xEB\xA8\xEA\xEA\xB5\xAA\x49\xBE\xEF\xE9\xCD\xEE\xDF\xD1\xED\xDE\x7B\xE0\x00\x05\xE0\xE1\x07\xE0\x00\x09\xEB\xEC\x6E\xEF\xED\xAB\xE5\x10\x0F\xEC\xD1\x12\xA2\xE1\xB2\xE7\xEC\x89\xE4\xD8\x24\xC8\xE1\x14\x1D\x32\xD5\xEA\xE7\x45\xEC\x81\xEC\xEC\x10\x07\x9D\xE6\xD3\xE9\xEE\x4B\xDB\x90\x28\xE9\x92\x2A\xEF\xEE\x6E\xD8\xEF\xA2\xD1\xE3\x14\x13\xE3\xED\xE8\x91\xBD\x6E\xB3\x21\x9A\xC0\x29\xBF\x34\x80\x32\xD4\x92\x3E\xD2\x82\x6F\x92\xEC\x6B\xED\x41\xBD\x68\xCA\x64\x92\x92\x92\xD4\x44\xD6\xC4\xEE\x6D\xD4\xE0\xDC\xEC\x59\xBD\xE3\xDE\xE7\xEF\x92\xEA\xC5\x38\xA6\xEF\xA3\xE0\xF2\xC0\xA6\x10\x56\xC2\xE7\xC6\xEE\xEC\x2F\xF0\xBE\x47\xED\xEA\x2A\xF2\xED\xCF\xE5\x10\x4D\xEE\xF2\x36\xF1\xF3\x00\xFF\xE7\x29\xF0\xEE\x37\xF5", - "\xE5\x28\xFC\xF3\x25\xFA\xC8\x59\xEE\xEF\xBE\xD8\xE3\xF0\x38\xF4\x1F\xF1\xE5\x86\xB3\xF2\x3F\xF4\xF2\x4A\xFC\xA5\x68\xED\xE2\x30\xFB\xF3\x05\xA5\xC8\x34\xF0\xF4\x44\xFD\x69\x71\xEA\xEB\xF0\xEC\xF5\x49\xC2\x98\x43\xF8\xF5\xD6\xE1\xEF\x7D\xE7\xEE\x57\xF7\xF6\x7E\xC5\x10\xA4\xDA\xF3\x6C\xF2\xF5\x41\x97\xE8\x6A\xFE\xF3\x5D\xF1\x94\xAF\xD0\xF6\xFF\xE5\xF4\xA4\xC6\xBF\xDD\xD9\xCE\x3D\xF1\xF8\x7C\xF4\x6E\xC9\xE3\xCD\xEC\xD1\xF6\x72\xFE\xF4\x12\x1C\xE9\x70\xF8\xF8\x51\xF1\xF2\x0A\x11\xEA\x50\xF7\xF7\x62\xF1\xF7\x41\xF7\xEA\x8F\xF4\xF9\x89\xF2\x99\x45\xC2\xF8\xC5\xE6\xF6\xF6\x91\xEB\x8D\xFB\xF7\x9F\xF1\xD1\xBA\xD7\xBE\xBC\xDE\xF1\x69\xE3\xF8\x89\xD2\xCB\xC9\xAC\xF4\xAB\xF3\xF5\xEE\xB2\xEC\xCA\xEB\xF5\x9B\xF9\xF9\x05\xA5\xF8\xA9\xF7\xF8\xA4\xF5\xF3\x96\xF6\xCE\xEE\xC0\xFB\x56\xF6\xF7\xF7\xDE\xB2\x65\xFF\xFB\xA0\xFE\xD8\xD9\xE4\xEE\x19\xBD\xED\xB6\xF8\xFB\xC8\xFB\x81\xE3\xE2\xE2\x36\x86\xEE\xA3\xF9\xF4\xBE\xFC\xAD\xFD\x8B\xEF\x36\xBE\xD0\xC7\xFE\xF8\x9A\xF0\xF9\x07\x11\xE2\x32\xE3\xE2\xDF\xFD\xFB\x95\xFA\xFD\x16\xB3\xEF", - "\x0D\x1E\x90\xE7\xF8\xFD\xE9\xF3\xE9\x21\xBC\xFD\x3A\xD8\xD2\xC2\xFF\xFC\xC0\xF9\xC6\xB3\xE1\xFF\xF0\xF2\x99\xFA\xF8\xEE\xAC\x7D\xEE\x5E\x67\x96\x7A\xF7\x7D\x7C\xF4\x6A\x7F\x33\x7A\x00\x81\x81\xEB\x71\x86\x39\x79\x01\x8D\x7A\xB7\x79\xFC\x52\x81\xE4\x72\xD9\x39\x71\xD5\x78\x7F\x14\x86\xE8\x67\x72\xD5\x73\xFC\x1E\x7D\x90\x6B\x7A\xEF\x78\x02\x87\x80\xC7\x6A\xE5\x00\x81\xE9\x60\x7F\xC5\x7A\x8F\x57\x80\x05\x87\x02\x8E\x6E\xD6\x6C\x81\xD9\x78\xFD\x77\x53\xFB\x70\x03\x8A\x7F\x43\x17\x73\x18\x81\xFA\x68\x81\x0D\x49\xF6\x0C\x81\xEC\x71\x81\x26\x7E\xED\x74\x80\x1F\x89\xC7\x13\x4D\x08\x9F\x81\xFC\x79\x0C\x79\x7B\xFD\x71\x01\x99\x81\xDF\x67\x7D\xD2\x63\xF7\x78\x74\x27\x8D\x01\xBC\x73\xEC\x70\x56\x43\x87\x01\xBD\x6E\x56\x47\x04\xD5\x81\x0B\x81\x82\x00\x02\xF2\x79\x81\x1D\x84\x06\x8E\x6C\xE6\x73\x80\x3A\x82\x06\x81\x7B\xCE\x7B\x00\xDA\x82\x17\x81\x4A\xA2\x7E\x0D\xA3\x82\x35\x80\xFC\x3A\x7E\x77\x7C\x80\x73\x86\x00\xAB\x78\x28\x8A\xDE\x06\x7F\x14\x89\x83\x7A\x83\xEC\x7C\x75\xFF\x5D\x05\xF9\x82\x08\x95\x83\xE4\x6B\x05\x84\x82", - "\x43\x8B\x05\xEF\x4D\x16\x8C\x82\x23\x86\xCD\x3F\x6F\xB5\x75\x06\x81\x86\xE9\x78\x76\xEC\x7D\x26\x12\x08\xE7\x75\x03\xCD\x80\x20\x81\x43\xD3\x7D\xFC\x55\x7F\x47\x86\x02\x9F\x83\x42\x71\x60\x1C\x57\x20\x1B\x71\x4E\x81\x09\x87\x85\x81\x44\x7F\x03\x7E\xFC\x4A\x84\x39\x8C\x0A\xFB\x83\xFA\x74\x7F\x45\x6D\xDF\x45\x85\x5A\x84\x05\xE5\x5E\x10\x79\x84\x00\x0D\x6A\x24\x84\x4A\x8E\xD8\x7F\x7C\x31\x96\x84\x95\x81\x0C\x46\x86\xE2\x7F\x09\xC8\x81\xB8\x62\x4A\xC3\x84\x19\x8D\x64\xE5\x11\x0D\x9E\x81\xDB\x60\x00\x0E\x80\x12\xA8\x83\x64\x8E\x0C\xAD\x85\x37\x91\x79\x16\x80\x0F\xBC\x85\x66\x85\x04\xA5\x83\x31\x8E\x85\xE4\x86\x17\x85\x09\x2F\x7B\x08\xE3\x84\x37\x84\x37\xE6\x82\x1A\xB4\x83\x5E\x81\xE8\x2A\x82\x38\x8D\x87\xF8\x82\xD1\x4A\x6D\x5D\x89\x0F\xDA\x85\x0A\x8F\x6C\xD5\x85\x0D\x80\x76\x3B\x71\x10\xDF\x82\x06\x9C\x73\x05\x88\x08\x87\x89\xD1\x69\x10\xC9\x81\x7E\x34\x7B\xFD\x85\x14\x8E\x88\x72\x3B\x04\x92\x8A\x27\x8F\x87\xEA\x87\x9B\x49\x85\x7B\x84\x0B\x91\x88\x7A\x63\x84\xB3\x64\x1F\x9D\x89\x91\x8A\xEE\x1F\x3D\x43\x97\x88\x8E", - "\x6A\x0C\xAE\x87\x79\x89\x0E\xF5\x84\x00\x07\x83\xF4\x86\x23\xB2\x86\x37\x3C\x06\x86\x8B\x37\x91\x89\x7C\x39\x0E\xBE\x87\x96\x82\x13\xDE\x66\x1D\x80\x7C\x02\x8E\x22\x9E\x86\xC2\x7B\x11\xBC\x7C\x32\x8C\x89\xD3\x80\x24\xAF\x7C\x91\x8B\x13\x98\x8A\x4B\x9F\x89\x27\x8B\x28\xAD\x7D\x70\x41\x15\xDB\x86\xFC\x62\x49\x93\x78\x27\x8D\x8B\xAB\x8A\xCF\x06\x70\x3F\x68\x70\x55\x8A\x2B\xB9\x76\x0D\x68\x0A\x9C\x60\x91\x21\x8B\x3C\x8C\x19\x52\x09\x12\x6C\xFC\x5B\x77\x2A\x9D\x89\x41\x8F\x1C\xB9\x2E\x58\x8C\x10\x04\x78\xBD\x72\x08\x16\x6B\x25\x87\x8B\xBD\x81\x86\x1B\x68\xF5\x7B\x61\x68\x8E\x29\xB5\x73\xA8\x10\x0C\xFF\x06\x30\x9D\x48\x68\x19\xAA\x1B\x79\x8C\x02\xD4\x54\x34\xBC\x21\x4A\x2A\x00\x26\x4D\x69\x83\x01\x05\x01\x8C\x52\x9C\x41\x96\x8C\x2F\xB9\x2F\x65\x86\x0D\xA8\x8A\x66\x84\x37\x04\x83\x2B\x9F\x8C\x46\x84\x6E\x09\x80\x5C\x96\x89\x6F\x82\x52\x59\x86\xA1\x86\x15\xA3\x8E\x5E\x88\x87\x82\x8A\x2D\xA2\x78\xD2\x84\x1B\xEB\x72\x1B\x7F\x83\xB1\x8A\x34\xBB\x6A\x11\x19\x19\xB0\x8C\x09\x9D\x8D\x37\x8F\x12\xB1\x87\xCE\x82\x15\xF5\x78", - "\x9B\x73\x85\xBA\x89\x38\x89\x8B\x07\x20\x1C\xA9\x8F\xB4\x64\x7B\xC8\x8C\x35\xA2\x8B\x8F\x81\xBA\x4C\x8A\x74\x89\x8B\x25\x8A\x08\x96\x8E\xB9\x8E\x1C\xC1\x78\x44\x84\x89\xD7\x89\x37\xB1\x5D\xE6\x85\x1B\x95\x58\x54\x9B\x8E\x33\x8E\x37\xA0\x83\xF3\x81\x1D\xDC\x8D\x79\x92\x8D\xC7\x5C\x3C\xAF\x8D\x5E\x68\x1E\xC4\x8D\x6B\x8B\x88\x30\x88\x3B\xA1\x8F\xCB\x84\x13\xF2\x8F\x69\x90\x83\xFE\x88\x3C\xA2\x6A\x3E\x85\xE9\x7E\x81\x56\x9A\x8F\xEE\x8E\x36\xAE\x7C\xD1\x60\x14\xA8\x8F\x7B\x83\x88\x0B\x94\x95\x41\x91\xE4\x85\x04\xEC\x8C\x47\x94\x90\x0F\x97\xD8\x44\x61\xF6\x89\x1E\xCA\x8C\x7F\x81\x43\x93\x85\x43\x9D\x8F\xFB\x8F\x04\x98\x84\x2E\x9C\x78\xFD\x65\x3E\xB1\x8A\x11\x92\xAA\x21\x85\x2C\x83\x85\x2A\x96\x41\x86\x8F\xB5\x85\x18\xEE\x75\x8C\x8A\x88\x1E\x96\xCD\x34\x8A\x81\x06\x17\xED\x7D\x34\x33\x90\xFB\x88\x0C\xBE\x8A\x51\x80\x18\xB7\x93\x44\x99\x90\x01\x7D\x46\x86\x78\x23\x9E\x19\xBB\x8F\x12\x7C\x90\xF6\x8B\x3A\xA0\x5E\xCE\x8B\x22\xD1\x93\xAE\x73\x5A\x40\x91\x41\x85\x74\x23\x79\x25\xAC\x92\x4B\x8B\x8D\x5A\x92\x40\x9E\x93\xFF", - "\x87\x24\xF3\x8C\xB9\x34\x92\x32\x94\x4C\x8F\x8F\xDB\x87\x20\xE2\x8D\x98\x90\x90\x61\x55\x4B\x96\x92\xFB\x43\x1C\xD5\x92\x9D\x97\x76\x75\x91\x4D\xA2\x93\x9E\x77\x1C\x97\x91\x90\x8A\x8F\x4E\x94\x39\x8C\x93\xE2\x8A\x26\xC1\x78\x0E\x86\x93\x48\x96\xC2\x5D\x12\x39\x9B\x22\xA8\x20\xA3\x92\x7D\xBE\x2F\x51\xA6\x84\x1B\x22\x29\xE5\x92\x79\x85\x8A\xB8\x8F\x43\xB9\x91\x40\x97\x05\xC1\x5D\x83\x98\x91\x23\x92\x4A\x9C\x82\x28\x97\x27\xA0\x96\xA8\x4A\x89\x85\x94\x44\xA1\x95\x4B\x89\x1F\xEE\x93\x98\x82\x93\xBB\x43\x50\xAA\x94\x3F\x70\xEB\x15\x95\x93\x83\x6F\x7F\x7E\x56\x84\x94\xCA\x38\x29\xED\x92\xA6\x8B\x95\xCB\x8D\x53\xBD\x74\x59\x92\x25\xFC\x92\x52\x8C\x90\xBA\x93\x56\xAE\x89\xFC\x68\x28\xCD\x96\x4C\x86\x18\xC9\x92\x54\x92\x09\xE5\x7F\x17\xCD\x7D\xB4\x88\x90\xE0\x5E\x45\xB5\x8B\x04\x57\x2D\xAE\x97\x85\x67\x91\x27\x6D\x02\x5D\x97\x5F\x92\xAA\x3B\x91\x40\x1D\x91\x9A\x87\x47\x84\x96\x6C\x96\x2C\xA4\x52\x92\x9D\x26\xE3\x96\x35\x9B\x93\x37\x3F\x2E\xB5\x71\x9D\x31\x6E\xE1\x93\xA6\x63\x49\x9A\x63\x8B\x0B\x8C\x46\x0D\x8C\x7B\x37", - "\x31\xB6\x68\xC9\x89\xE2\x1D\x7A\x51\x80\x94\x9B\x95\x11\xB3\x8C\x67\x9B\x27\xD6\x80\x5B\x7E\x93\x6F\x97\x4F\x89\x98\xD0\x81\x2F\x88\x99\x11\x86\x8D\x0D\x9A\x4F\x98\x91\x2F\x95\x31\x93\x99\xA2\x93\x93\xE4\x96\x25\xA8\x92\x53\x9C\x30\x9B\x99\xC5\x59\x93\x24\x99\x55\x92\x96\xB2\x44\x2A\x9A\x9A\xC4\x83\x7E\x4F\x7F\x63\xA5\x94\x1B\x85\xD8\x6B\x96\xAB\x80\x99\x6E\x37\x05\xAA\x98\x76\x9D\x28\xCB\x11\xC7\x80\x96\x5C\x8E\x4F\x76\x99\x90\x9B\x33\xF6\x4D\x0F\x99\x98\x29\x98\x69\x92\x55\xB7\x7A\x34\xB7\x94\xD0\x8E\x33\xDF\x8E\x64\x8D\x9B\x5D\x96\x7B\x15\x89\xC4\x97\x9A\xAF\x90\x4E\x91\x67\x3E\x82\x05\xBE\x96\xBC\x93\x9A\xE0\x87\x58\x92\x91\xA1\x9F\x35\xD2\x99\x76\x80\x00\x8C\x78\x6C\x85\x97\x9E\x9F\x10\x28\x96\xDA\x9C\x99\x2E\x9B\x40\xAF\x89\x9F\x99\x28\xB1\x95\xCB\x89\x9A\x66\x9A\x43\xAE\x22\xB2\x96\x31\xF5\x9A\xD8\x81\x67\x32\x99\x6E\x99\x9A\xEE\x68\xFA\x77\x83\xC1\x9E\x98\x25\x9A\x6F\x91\x90\xC0\x99\x38\xD8\x98\xCE\x87\x56\xBD\x91\x70\xB8\x9B\x97\x99\x11\xCC\x95\xD1\x84\x9A\x6F\x9A\xFD\x61\x91\xC7\x98\x38\x97\x9E\x9B", - "\x34\x96\x44\x96\x5A\xBC\x9B\xCE\x99\x39\x91\x36\xB6\x9C\x91\xDC\x93\x74\x8F\x9B\xBE\x9E\x12\xEC\x89\xB5\x8E\x8B\x74\x9D\x71\xA0\x5E\x73\x90\x10\x68\x95\x30\x98\x8B\xB1\x9E\x73\xBD\x8B\x7A\x9C\x82\x39\x9D\xE9\x80\x83\x02\x7B\x5B\xB6\x41\x94\x6F\x2E\x00\x9A\xC5\x7D\x34\x5A\x06\x77\xB9\x9A\xD1\x63\x32\x96\x97\xEF\x9C\x94\x0F\x9F\x70\xAB\x9C\xD2\x9B\x3C\xE0\x5D\x68\x94\x9C\xB2\x9C\x73\xA5\x8C\xE5\x98\x3D\xF3\x94\x98\x83\x9C\x8E\x9B\x66\x8E\x9A\xC9\x9E\x3C\xB6\x3D\xF3\x83\x9F\xD9\x9E\x61\x9B\x80\xE9\x94\x3E\xE8\x9F\xBC\x8C\x87\xCF\x9C\x7A\x9D\x9E\xF8\x87\xF4\x2A\x9D\xFB\x8F\x75\x6C\x97\x7E\x8A\x97\x67\x9B\x0F\xF7\x99\xF9\x93\x9F\x5A\x9D\x0F\x5C\x9F\xF0\x97\xED\x07\x96\xEE\x92\x9F\x04\xA1\x28\x47\x9B\xEA\x9A\x3D\xFE\x9B\x23\x43\xA0\xE0\x98\x7C\x51\x9A\x00\xA4\x41\x89\xA2\xA4\x56\x9A\x11\xA5\x81\xB2\x9D\x60\x78\x05\xF6\x9D\xFA\x90\x94\x7E\x7D\x70\x9F\x95\xFF\x96\x41\xEE\x9F\x2D\x70\xA0\x1A\xA5\x62\x6E\x9A\x06\xA2\x3E\xD4\x9B\x58\x82\x66\x1E\xA7\x80\x93\x9E\x63\x61\x43\xF1\x9F\x0C\xAA\x66\x28\xA4\x6D\x82\x96\x42\x8E", - "\x3F\xA6\xA0\x0B\xB7\x76\x16\x94\x7D\x9F\xA1\xC9\x92\x37\xC1\xA1\xA6\x85\x9B\x15\xA1\x82\x9C\xA0\x4F\x99\x43\x82\x9E\x37\x76\x9C\x36\xA2\x7F\xAB\x98\x85\x70\x31\x99\xA1\x0B\xB6\x85\xA0\x9F\x45\x92\x50\x4E\x82\x43\xD2\xA3\x95\x9D\x18\xBC\x9F\x2C\xB5\xA1\x1F\xA4\x44\xE0\x5E\xEB\x81\x9D\xB0\x9B\x8C\x89\xA3\x14\xAC\xB0\x61\xA1\x41\x19\x8B\x5D\xA3\x88\xB4\x98\x7D\x75\x16\x93\x8E\x41\x0B\x71\x71\xA1\x8F\x91\xA3\xE0\x51\x3C\xA8\x9F\xF0\x99\x66\x06\x07\x65\x45\x51\x40\xAD\xDD\x21\x01\x13\xB3\x94\xD1\x9D\x40\x85\x08\x43\xAA\x46\xA5\xA0\xFE\x8B\x98\x15\x5C\x91\xBD\xA0\x17\xAE\x48\xB6\x87\xF5\x82\x6D\x92\xA5\x8A\xAC\xA2\x32\xA7\x0D\x98\x9A\xED\x39\xA4\x42\xA2\x8F\x9C\xA5\x67\x8F\x3D\xDE\x64\x21\xA5\x9C\xA0\xA7\x88\xAC\x9C\x51\xA9\x44\xC2\x0D\x2A\xBE\x9A\xAB\xA3\x8F\xB3\x97\x65\x8E\x4A\x87\xA4\x09\xA0\x5F\xF1\x85\x96\x8D\xA4\x2B\xA2\x38\xBC\x8D\x21\xB6\xA5\x3E\xA2\xE9\x39\xA4\x89\x0F\x4A\xDE\xA3\xCD\x8A\x9F\xF6\x84\x6B\x80\x01\x62\xA2\x47\xC1\xA4\xD6\x9D\x93\xCA\xA4\x99\xAC\xA5\x4A\xA3\x45\xDD\x39\x36\x72\xA6\xB2\xA1\x9B", - "\xA3\xA4\x43\x97\x4D\xC0\xA4\x25\xA0\x5F\x0B\xA2\xE9\x18\xA7\x6D\xAB\x3F\xDA\xA6\xDD\x3D\xA6\xBB\xA3\x93\x8A\x9D\xD6\x5F\x4B\xE9\xA7\x15\xBF\x87\x18\xA2\x97\x93\xA5\x72\xA4\x4E\xFF\x86\x11\xB4\x7D\x06\x0B\x9C\xAB\xA3\x77\xA8\x2D\xCB\xA3\xB0\x88\xA5\xDE\xA4\x9E\x8A\x3B\xB4\x9F\x49\x81\xA9\x35\xA6\x08\x2B\xA2\x9C\x86\xA8\xB8\x91\x94\x0E\x36\x3C\xBA\xA4\xFC\xA7\x98\x9D\x35\x22\x6F\x50\xA1\xA6\x39\xB4\xA6\x97\x82\x27\x8A\x3B\x14\x0F\x32\x42\x0E\x47\x2A\xA6\x67\x01\x9B\x66\x03\x6C\x63\x6E\x42\x0C\xCB\x45\x9C\x4A\x01\x9B\x57\x01\x6C\x65\x04\x1D\xAA\x44\x0B\x01\x2E\xAA\x5D\x85\x9D\x36\x01\x53\x8A\x0B\x08\x19\x66\x5F\x00\x9D\xB3\xA7\xB5\x9E\x44\xA6\x4D\xE4\x81\x5E\xFA\xA0\xA3\x92\xA9\x32\xAE\x4F\xBC\xA1\x14\x8B\xA6\x0B\xAE\x5B\xBF\x9A\xF9\x62\xAA\x41\xA8\x2F\xA5\xA3\xEA\xA2\xB4\x77\xA7\xA9\x87\x10\x54\x02\x17\x42\x0E\x56\xA8\x90\x58\xAB\xAB\xA2\x11\x59\xA8\x87\x9B\xAA\xDF\x22\x38\x0F\x03\x9A\xA7\x10\x63\xA9\x3B\xBB\xA9\x0C\xAF\x96\x94\x72\x28\xA7\x36\x8A\x0F\x07\x7E\xA8\x6E\xA0\x00\x20\x00\x9D\xA0\x51\xBD\xAA\x5D\xB1", - "\x77\x21\x95\xA2\xAA\xA4\x04\xAF\x54\xF3\xA2\x41\x19\xA2\xC2\x9B\x8B\xB1\xAB\x58\x3A\x48\xC8\xAA\x3B\xB7\xAB\x7E\xAA\xDC\x71\xAA\xEB\x7C\x77\x4E\xA9\x54\xBD\xAB\xCE\xA6\x8C\xB1\xAB\xB7\x8D\x58\xC9\xA8\xE6\x80\x71\x71\xA8\x8E\x95\xAD\xC3\xA0\x55\xC8\xA7\x2D\x95\xA3\x05\x9F\x8E\xB4\xAA\x8B\xA5\x4F\xE9\xAB\x9A\x84\x8C\xE0\x94\xC6\x76\x7F\xB3\xA5\x57\x9D\xAD\x2F\xAF\x92\x47\xAE\xB1\x91\xA9\xCB\xAB\x4E\x89\xA4\x3E\xAB\xA4\x96\xA8\x89\xA2\x6D\x4B\xA0\xBE\x32\xAC\x62\xB1\xAC\xED\x92\x21\x1E\xA4\x85\xAC\x59\xEA\xAA\x67\xA5\xA5\x3D\x2F\x94\xB1\xAD\xDC\xA1\x4B\xE7\x9A\x6F\xAE\xAD\xD0\xAF\x1A\xB4\xA4\x62\xAC\x5C\xFC\xA9\xCC\x80\xAA\xD5\xAF\x86\x81\x5E\xF8\x95\x50\xC5\xAC\x70\xBE\xAC\xC3\xA7\x21\x0F\xAE\xE3\xAF\x5B\x8F\xA5\xCD\x80\xA8\xDE\xAF\x9B\x81\xAF\x39\x5C\x5A\xA4\xAF\x3E\xA5\xAF\xB6\x87\xEB\x5D\xAE\xB4\xA3\x54\xE4\xAD\xBC\x66\xA0\x9B\xAC\xBE\xB4\xAC\xA1\xAE\xD8\x61\xA4\x26\xB9\xAE\xB4\x96\x31\x6D\xAF\xBD\xAA\x5D\xD3\xA7\x13\x6C\xA7\xE8\xAA\xBF\xBA\xAC\xC8\xA1\xF4\x71\xA4\x75\xA9\xAF\x02\xAF\x99\x8B\xAA\x48\x78\x5D", - "\x90\xB0\x4F\xA8\xA4\x21\xA7\xA8\xA9\x66\xBD\xA0\x4B\xFC\xAB\x63\xB4\x72\x04\xAC\xB8\x8A\xB1\xE6\xAF\x5E\xF1\x75\x42\xBF\xAF\x16\xB6\xB4\x9F\xA6\xD7\x33\x5A\x84\xB2\x31\xBB\xAF\x07\xB2\x7B\x4D\xAA\x00\xB3\x23\xBF\x45\x36\x7C\xA8\x61\xAA\xA5\x1D\x6F\x90\xAD\xDD\x23\xA9\x77\x65\xA9\x12\x0F\xA4\x87\xAB\x94\xAD\xDD\x2B\xA9\x77\x6D\xA9\x39\xB7\x21\x30\xA9\x24\xBD\xA1\x59\x64\x4D\xAC\xB2\x07\x0F\xA6\x9D\x6F\x9C\xA3\x60\x9D\xB1\x81\xB7\xA8\x8A\x93\x71\x8C\xAB\x0A\xB3\x62\x9E\xB3\x6C\xB9\x54\x3F\xA9\x92\xB4\xB0\xFE\x9A\x65\x94\xB2\x98\xA9\xB1\xF5\xAF\xB4\xBB\xA1\x90\x8F\x55\xDD\xA8\x57\xAF\x08\x5E\xAD\x8A\xA0\xAB\x36\xB0\x67\xEF\xB2\x42\x11\xB3\xFF\x52\xAC\xA4\xAA\x83\x06\x56\x89\xB1\x6B\xB6\xAF\x80\xB7\x19\xAC\xAB\x17\xA8\x10\x7B\xB1\x41\x1F\xA8\xDA\x77\x2B\xB2\xAB\x16\xB6\x65\xAF\xB3\x82\xB4\x72\x79\xAF\xC1\x9D\xB3\x2B\xB5\x5A\xEA\x7C\x60\xBE\xA3\x82\xA9\xB5\x85\x78\x3B\x3C\x68\x8E\xB4\x89\xB2\xB0\xFA\x52\xD3\xB7\x8A\x7C\x45\x65\x9E\xB6\x97\xA0\xA1\xDB\x78\xB4\xBC\x76\x55\x8D\x69\xCD\xA6\x7A\xBE\xAC\xB4\x9F\x1F\x36", - "\x9C\xC3\x88\x3B\xA5\xB6\xAB\xB1\xB0\x4A\xA0\x05\x71\xAA\x3C\xA9\x5F\xFF\xB3\x77\xB0\xAF\xFF\x85\x8F\xA7\x97\x0F\x44\x3C\x8E\x8F\x35\x8A\xAE\x79\xB7\xA5\xAA\x0A\xE3\x9C\x10\x3E\x69\x40\x0C\xB6\xA3\x0D\xA7\x0B\xB3\x49\xB6\x6A\xB0\x98\x6C\xAE\xAF\xFC\xAF\xD1\xBD\x29\xF3\x9F\x6A\xC0\xB7\x17\xB8\x6A\x68\xB0\xC6\xAB\xAF\x27\x41\x6E\xDA\xB4\xAA\xB8\x86\x63\xB0\xCB\x9F\xB1\x2F\xBB\x10\xDC\xB4\xAE\xAB\xB7\xE7\xB0\x65\x81\xB5\x6E\xB8\x61\xEB\x85\xBA\xB5\x9E\xD7\xAE\xC0\xB0\xB7\x7A\xB2\x86\x65\xB7\xA7\xB9\xB5\x0F\x0A\x67\xAA\xB6\x76\xBA\x30\x8B\x66\xBF\xA7\xB5\x44\xAC\x20\x87\xB8\x4A\xBD\x4A\x8B\x97\xC2\xB5\xB6\x19\x8C\x69\x95\xB4\x71\xBE\x59\x93\xA1\xB6\xBF\xB7\xE3\xB5\xB8\x37\xB7\x86\xB5\x66\xC3\x74\xC4\xB7\xB5\xF6\xA1\xCC\x83\xB8\x6F\xB1\x2C\xA9\x57\xC6\xA0\xB5\x91\x7F\xE4\x8C\xB0\xE0\x7D\x2A\x94\xB8\xC9\xA1\x9A\xAC\x70\xE4\xAA\xB1\xB0\x96\x63\x8F\xBA\xCC\xAA\x7F\x53\xAF\xE6\xAE\xB8\x7E\xB9\x73\xFA\xB4\xC1\xB6\xB6\x1D\xBD\xF6\x7A\xB8\x73\xBC\x73\xA2\xBB\xC4\xA4\xBA\xF3\xB0\xF8\x43\xB5\x8B\xB8\x70\xC9\xB9\x81\x5B\x9C", - "\x3F\xBF\xE3\xB3\x97\x4B\xB3\x6C\xB6\x40\x17\xA3\xB9\xD1\xAA\xCD\x81\x68\x51\xBE\x23\x84\x6A\xCA\xB9\xB8\x00\x07\x8C\x9A\xA3\x8C\x54\x59\xC7\xB8\xC6\xBA\xA1\xE3\x79\xB3\x9F\xBA\xCF\xA3\x24\xE3\xBB\xB6\x7C\xB5\x66\xBD\xE9\xBF\xB5\x17\x51\x57\xC5\xB4\x1A\xAA\xB4\x56\x01\x9B\x5E\x02\x43\xB0\x00\x43\x01\x36\x7E\xBB\xDD\x68\xF0\x85\x9C\xC1\xB7\x54\x84\xBE\x32\xA6\xBC\x85\xA8\xF1\xB7\xAD\xBE\xBF\x77\x8D\xBD\x77\x71\x01\xD9\x60\x05\x19\x67\xB2\xBA\x74\x49\x01\x5C\xAB\x04\x6B\xBF\xDA\x6E\xB7\x0B\xBE\x74\x97\x87\xE6\xB3\xB9\x9C\xBA\xEB\xAC\x79\xCC\xBC\x6F\xC3\xAC\xD3\xAC\xB8\xA7\xBA\x54\x48\xAF\x97\xB8\x74\xF3\xB9\xE7\xA9\xB3\xE2\x7F\xE4\x54\xB7\xA1\xBF\x6F\xF9\xB4\xD6\xAF\xBD\x30\xBE\xDE\xB6\xB8\x9F\xB8\x27\xA4\xBD\x62\xBD\xB7\xB3\xBC\xF7\x89\xB9\x80\xBE\x7B\xA2\xBD\x41\x12\xAF\x25\xB0\xF7\xAD\xBC\x6E\xAB\x7B\xB7\xBF\x33\x9E\xAF\x2B\xB9\xF4\xAB\xB0\x01\xB1\x7C\xCE\xBE\x79\xB1\x94\xCD\xB9\xEE\x85\x82\x0C\xAB\x6F\xCA\xBC\xF4\x99\xB0\xCA\xA3\x84\xAE\xBD\xF1\xB7\x7D\xE0\xBD\x61\xA2\xBF\xF4\xB6\xFB\x85\xB8\x93\xB9\x7D\xC9", - "\xBE\xF1\xA1\x83\xC5\xBB\xFA\xB0\x15\xF8\xB4\x73\xF8\x94\xED\xB2\xBB\xE5\xB8\x39\x74\xBE\x41\x81\x74\x86\x92\xD4\xB6\xBE\xB6\x85\xE7\x80\xC0\xE9\xB5\x7F\xDB\x9B\xF9\xBB\xBF\xDF\xB6\xFC\x8B\xBC\xF4\xBF\x6E\xD1\xB9\x8D\xB4\x8A\xED\xB9\xF5\x8F\xC0\x40\x35\x7D\xDA\xBE\x03\xBD\x8A\x89\xB1\x15\xA9\x91\x0A\xCE\x7E\xE9\xBE\x64\x47\x9D\x55\xBD\xDC\x48\xC1\x92\xB6\x10\x62\xB9\x60\xA4\xBB\x23\xC1\xF7\xB2\x76\xAE\xB9\x2E\xCD\xB1\x04\xD1\xBE\x09\xC5\x20\x2D\xBB\x13\xCF\x76\xA9\xC3\x82\xA2\x0E\xC2\xB5\x76\x84\xB6\x40\xAC\x77\xC8\xB7\x5B\xAA\xB6\x88\x8E\x39\x0E\xB6\xAB\x0F\x10\x00\x1D\xBE\x80\x00\xA6\xBF\x1F\x00\x1D\x22\x63\x18\x49\xC2\x70\x1A\xAC\xB6\x3A\xCA\xAA\xB5\xEE\x7B\x75\x9C\xC2\x04\xC4\xB3\x52\x6E\xC5\xB7\xBE\xD4\xB3\x25\xB6\xC3\xF7\xB5\x62\x5E\xC3\xFD\xA4\xB6\x2B\xC0\x83\xB0\xBC\xF0\x6B\xBD\x59\xBE\x03\xEA\xC3\x06\xCC\x7A\xED\xB5\x18\xC0\xBA\xE7\xAE\xD7\xAB\xC2\x02\xC5\xA0\x5C\xAD\x07\xCC\xC3\xC3\xB9\x0E\xD8\xB7\x32\xCB\x73\xD7\x86\xBC\xA4\xBF\x78\xC7\xF7\x82\xB8\x0B\xCB\x85\xD4\xAA\x00\xAF\xC1\xDD\xBF\xFD\xB8\xAE", - "\x42\xC2\x7C\xBF\xBC\xF4\xA9\xC4\x73\xC1\x06\xCC\x88\x44\xCE\x80\x9F\x67\x1B\xD9\x88\xDC\xBD\x12\xC3\xC1\x4B\x82\x80\x8C\xC7\x26\xC4\xC1\x04\x93\x01\xD7\xC4\x05\x91\x1F\x94\xC5\x1B\xC5\x91\x27\xB4\x0F\xCB\xBF\x40\xC2\x99\x2D\xBB\x2A\xD4\xC3\x92\xC5\x26\xA9\xC2\x56\xC9\x7F\xE1\x5E\x29\xD3\xC5\x21\xB9\x57\xB7\xC4\xF5\xB5\x21\xC6\xBB\x1D\xD0\xC5\x4A\xAD\xFF\x9D\x9B\xFF\xBE\x89\x81\xA1\x28\xDD\xA0\x64\xC0\x12\xF4\xC4\xA5\xB3\x8A\xD8\xC0\x05\xD2\xC3\xCB\xC0\x18\xF0\x57\xB8\xA7\x75\xC5\xC7\x2F\xDD\xA7\x12\x08\x04\xFA\xC0\x18\x99\x8C\x9A\xC4\xBE\xB4\x91\x2C\xC7\x76\x9A\x71\x66\xCA\x0F\xB7\x1A\xDA\xBB\xC5\x80\xC7\x1F\xB3\xC0\x4C\xB9\xB1\x70\xBB\x35\xC6\xC3\xD2\xC6\xCD\x39\xC0\x59\xBB\x83\xDD\x6E\x0F\xD2\x27\xDE\xC7\x1D\xEA\xC1\xCF\xB0\x8F\xA0\xBE\xE7\xA4\xC7\xC6\xC0\x1A\xA8\xC7\x48\xC8\x00\x80\xC9\x6D\xA3\x6B\x03\xC9\x1A\xFE\xC7\x7E\xCC\x90\x98\x8D\x42\xD1\xC7\x0B\x8F\x0F\xC4\xC9\x3E\xCF\x7E\xF6\xC3\x15\xDF\xC4\x2A\xC2\x22\xCA\xC9\x86\xC5\x01\xF9\x9D\x21\xDF\xC8\xF3\x93\x10\xFA\xC7\x57\xC8\x8D\x82\x95\x37\xC7\xC5\x5C", - "\xC6\x9B\x4B\xC5\x91\xC7\x76\xAF\xAD\x75\x87\xC9\xB8\xC5\x24\xE6\x5C\x83\xC2\x37\x96\xBA\x2A\xCD\xC9\xFC\xB1\x13\xE8\xC8\x62\xC4\x68\x9D\xC4\x4B\xD8\xBF\xB8\xB5\xA8\xAC\xB2\x68\xC0\x91\xC0\xC9\x81\x41\xB1\x17\xCE\x1A\xE8\xB9\x83\x09\x8A\xCA\xC5\x51\xDC\xC2\x2C\xB7\x21\xCB\xC8\xC7\x62\x8B\xBC\xC4\x4F\xD2\x9B\x1A\xA9\x29\xFF\xC8\xA8\xC3\x61\x9E\xB8\x48\xD8\xC8\xEB\x8E\x17\xDA\xCB\xB1\xC0\x70\xEB\xB3\x52\x90\xC9\x56\xCB\x02\xCA\xC0\x64\xC4\x94\xD3\xC8\x49\xCA\x7F\x4B\xBF\x26\xC6\xCA\xB7\xC0\x22\xB4\xC9\x96\xB8\xC0\x6D\x8A\xD1\x95\xC7\xAD\xC7\x95\xF7\xC9\x15\xDB\x67\x1A\xC5\x20\x0C\xAC\xA5\xC2\x97\xDC\xCB\x29\x80\xCC\x66\x8D\x20\x14\xBC\xB2\xCE\x94\x92\xC5\xAC\xB3\xB5\xF5\x70\x2D\xE9\xC6\x99\xC4\x47\x88\xCE\x1D\xA8\x51\x76\xC8\xEC\xB3\xC6\xC8\xCB\x24\x85\x9D\xF2\x9D\x6E\x9F\xCD\x70\xB7\xC6\x63\xB2\x99\x08\xB7\xE2\xAE\xAB\x8B\xBE\x34\xEF\x9C\x45\xB3\x57\xC1\xC0\x5E\x03\xC2\xE0\x5B\x34\xF7\xBB\xC0\xC6\x58\xD3\xC1\xFD\x66\x08\xAD\xCA\x32\xD3\xC9\x8E\xC0\x49\xE0\xC8\x4E\xD2\xAE\x99\xCD\x9D\x7C\xAD\xC6\xCC\x91\xDF\xC0", - "\x12\xC1\xCE\xD7\x70\x0D\xE9\xCB\x46\xC3\x99\xC5\xCF\x5C\xCC\x5A\xC8\xC9\xDE\x5A\xC9\xA7\xCD\x97\xF8\x69\x74\xDE\xC3\xD7\xCF\x19\x93\xCE\xBA\xCF\x9C\xAA\xC2\x48\xCC\xCC\xF9\xC4\x3A\x86\xB8\xDD\xCB\x91\x94\xC8\xF3\xA4\xCF\xD4\xCA\x2D\xC8\x88\xA9\xCE\x9C\xC5\x82\xC4\xBC\xCB\x5F\xCF\x6C\xB6\xC8\xE2\xC6\x9E\xB6\x86\x4E\xD1\xC9\xED\xCE\x10\xC7\xC6\x26\xAC\x9E\xF5\xCD\x2E\xC2\xA1\xD9\xC9\xF6\xAF\x4D\x00\xD6\x0B\xCD\xC9\x78\xC5\xCC\x01\xB3\xFE\xBD\xCF\xB7\xC4\x95\x84\xD3\x3F\x99\xCA\x08\xD1\x3E\xC7\xC9\xFD\xCF\x4F\xED\xC9\x7E\xDB\xA0\x5D\xCA\xE8\x8C\xCF\xDD\xC6\x9C\xBE\xC8\x78\xDB\xC9\xA4\xC6\x00\xE2\xC5\x05\xDF\x9B\xEF\xBD\x5C\xD4\xCF\x0C\xD7\x06\xEB\x57\xEA\xC7\xA0\xDE\x64\xD5\xBB\xC6\x99\xB0\x3D\xDC\xCE\xC3\xC0\x46\xE1\xC4\xAD\xA4\xB5\x32\xD7\x42\xCE\xC7\x12\xC3\x59\x8E\xD3\x25\x8F\xCC\xB2\x86\x42\xFE\xCF\x19\xD2\xAA\x6B\xC5\x08\xCD\xC7\x3E\xD0\x14\xF4\x96\x1B\xD7\x18\xB9\xD3\x90\xCA\xD2\xFC\xC7\x49\xD2\xD2\x30\x81\xA5\xA9\xD1\x89\xD5\xC5\xC3\xCD\x45\xDA\xD2\xAE\x69\xA4\x8E\x6E\x72\xCD\xCE\x53\xD7\x4A\xE5\xCE\x2B", - "\xD5\x22\xD5\xD2\x98\xC9\xCF\x83\x8A\x0F\xDA\xC3\x0D\xD3\xA6\xE1\x42\x45\xD1\xD0\x6C\xD4\xFF\xAA\xD3\x46\xB2\xA1\xE4\xCA\xED\xA4\xCC\x28\xD6\x38\xDF\xCE\x38\xDE\x9B\xE2\xC3\xF1\xBD\xD2\xBC\xC8\x92\x64\xD1\xEE\xC0\x06\x8F\xC7\x96\xD8\xCF\x8E\x6F\x3D\xDF\xD0\x44\xD0\x06\xF3\xCF\xA1\xCB\xCE\x7C\x3F\x3E\xD0\xD4\x3C\xDE\xE8\x62\xC8\x9F\xD4\xD4\xE7\xB6\x43\xD7\xD4\xF8\xCB\xA3\x83\xD3\xA0\xC9\xC9\xED\x66\x40\xE0\xD1\x38\xD2\x89\xAE\xC7\x99\xC4\xD2\x21\xD1\xE6\xA4\xD4\x1D\xD5\x8E\x8A\x08\x84\xD9\xD3\x84\xD5\x43\xD6\xD4\x58\xD0\xAA\x99\xD7\xAC\xCF\xD4\x60\xD1\x2C\xFA\xC4\x27\xD4\xA6\xB4\xD2\x88\xCC\xCB\x7B\xC4\x56\xFD\xCB\x0D\x92\xA4\xBD\xD7\xB0\xCB\xD1\x75\xD3\x53\xE2\xCF\x83\x0F\xA2\xF4\xC6\xD5\xA0\xD4\x0B\x8A\x1B\xCE\xD6\x11\xCF\xA9\xC7\xD7\x61\xDE\x8A\xB4\xCB\x31\xCA\xD7\x6D\xD0\x76\xC0\xD1\x0C\x70\xD6\x25\x96\x48\xF0\xD0\x24\xD5\xAD\xC9\xD6\x37\x7B\xCC\xF5\xC3\xE1\x40\x7E\xC2\xA9\x97\xB4\xCE\x14\xC7\xAA\xEC\xD2\x54\x72\xCD\xE3\x91\x94\x73\xD4\xDF\x38\xB3\x85\xA8\x5F\xCB\xBC\x7D\xD2\xAA\x7C\xD5\xF0\x5E\xD7\x14\x08", - "\x70\x35\x0F\xC1\x00\x0A\x02\xA6\x73\x00\x1C\x46\xC2\xB5\x86\x09\x82\xDE\x9A\xE0\x08\xE0\x02\x0E\x47\xC4\x61\xEA\xD7\xE8\x0B\x84\xF8\x32\xC4\xD0\x78\x2A\x5B\x6D\x32\x68\x00\x07\xB1\xBC\x6A\xA4\x52\x02\x71\xAB\x13\x06\xD8\xFB\x43\x05\x71\xA9\x27\x19\x66\x20\xDC\x49\xD2\x08\x91\xDD\xDD\x29\xDA\x6D\xD9\x85\x07\x0C\x65\xE2\xCD\x91\xDE\xD8\x00\xD8\xFD\x86\x08\x36\xDF\x6C\xB9\xD8\x42\xBB\xB3\xF2\x99\xCF\xC0\x5F\x7D\xB7\xA8\x81\xDA\x6C\xD9\x98\x80\x03\x25\x00\xD7\x67\x90\x69\xE2\x54\x33\xD1\xAB\xCD\xD8\x1C\xC0\xB7\xBC\xD7\x54\xC1\xC6\xE1\xAA\xB4\x9C\x99\xB9\xCB\xD5\x61\xD6\x69\xC9\xD1\x2C\xC4\xA7\xD8\xDA\xB1\xC1\x5E\xDB\xCC\x55\xD8\xD5\x78\x7F\xA6\xC2\xD6\xB9\xDE\x6B\x55\xDB\x5E\xA1\xDB\xAC\xD5\xAB\xFC\xB7\x9E\xC6\xDB\x5E\xDB\x21\x88\xBF\x45\xD3\xA9\x9C\xBA\xA0\xD1\xDA\x5A\xDA\x3D\xC0\x00\x43\xD3\xAA\xFD\xD2\x7B\xC9\xDB\x7C\x3E\x51\xFD\xDB\xB1\xD7\x41\x80\xDF\xD9\x9A\xD4\x70\xDE\x6F\xD9\x88\xC4\xD8\xAB\x9C\xD1\x89\x88\xCA\xDC\xD5\x71\xC5\xD0\xC3\xD3\xA1\xF3\x9B\xD5\xCA\xDC\xC1\x5D\x2A\xF9\xD4\xA9\xDA\x82\xAF\xD6\xE4", - "\xC8\xD3\x37\xDC\x42\xC6\xAB\x60\xDF\xB9\x94\xCF\x5A\xDC\xCF\x78\xDD\x6D\xF7\xA4\xA1\xC7\x96\xC5\xD4\xE7\xDF\xDA\x97\x93\x57\xEE\xDD\xBC\xD1\xB7\xF9\x2F\x89\xC5\xDD\x62\xDD\x72\xD0\xBB\xC1\xDC\xA9\xAD\xD4\xB3\xD4\xC6\x94\xDA\x6E\x92\xD6\xCE\xC8\xA3\xB3\xDE\xEA\xDB\xDC\xF9\x2E\x04\xEC\xC7\x34\xA9\xBA\xAC\xD3\xB5\x7E\xD6\x0F\x59\x78\xF1\xB0\x83\x02\xAE\xD3\xD4\xB9\xCD\xDE\x67\xDF\xDC\xA8\xD7\x3F\xA7\xB9\x84\xCD\x38\x84\xDD\xBC\xDB\x29\xF2\xBC\xE3\xDE\xBC\xFC\xB5\x96\xC1\xDF\x91\xDF\xDA\x49\xC3\xC4\xD4\xB8\xA4\xA6\xF4\xCC\xDF\xBD\xDF\x1B\xFD\xCD\xF6\xDE\xB8\xCF\xDB\xFA\x8B\xD3\x98\xDE\xC0\xBE\xA4\xEC\xD5\xBB\xF6\xDD\x32\xB8\xDF\xF4\xDD\x4D\xF9\x2F\xB5\xD0\xBB\xF9\xDD\xE8\xC0\x00\x6F\xD8\x77\xEC\xDB\x8C\x83\xB7\xE9\xDC\xA3\xD5\xBD\x0A\xBC\x7F\xC6\xE1\x80\xCC\xB7\x8F\xE0\xED\xDE\xDD\x82\x75\x7B\xF1\xDE\xA5\x32\xB8\x96\xE3\xF1\xC2\xD0\x93\x57\x7D\xFE\xA8\xD9\xD0\xBE\x9E\xE3\x05\xDF\xD5\xA8\xDC\x7C\xD9\xDE\x7E\xB0\xB9\xF0\xDC\xDD\xCF\x86\xA2\xD6\x84\xEB\xE1\x6B\x86\xAA\x97\xE1\x00\xFF\x87\x9A\xDD\x7E\xE5\xDE\x49\x5E", - "\xB9\xE8\xDE\x0B\xF3\xDE\xA2\xDB\x28\xE5\xE1\xBA\xD6\xA7\x99\xD2\xFF\xB3\xE1\xC8\xDD\x17\xE4\xE0\x00\xEB\xC1\xAF\xE1\xD0\x6C\xDC\x3E\xE2\x81\xE0\x83\xDB\xD1\xC5\xD5\xE0\x5E\xA2\xE1\x9D\x35\x59\xC4\xDF\xFF\x48\xC5\xC1\x4B\xF0\xC9\x9D\x12\xE7\x86\xD2\xC4\xE5\xD7\xA4\xCC\xDE\x0A\xFD\xDF\x5B\xD9\xED\xAA\xD8\x99\xA7\xC6\x93\xE2\xDD\xD5\xCC\x44\xDF\x32\xDA\x59\x2E\xE7\x0D\xDB\xDE\x84\x56\xBB\x01\xD9\xBA\x72\x15\xC1\x08\x09\x34\xD8\x52\x1B\xE2\x07\x0F\x68\xDA\xE1\x22\xE3\xBF\xCD\xE2\x03\xE0\xCE\x83\xE7\x90\xD2\x4D\xF3\xD2\xC3\xE8\xE2\x4B\x8B\xDF\x52\xE7\x75\xCB\x89\x2F\xDA\xC3\xC8\xE1\x25\xEE\xE4\x69\xD6\xB6\xBB\xE1\x24\xE9\x11\x84\xE2\x24\xF6\xE1\x95\xDD\x6C\xD1\xE4\x50\xE2\x37\x9E\xE4\x29\xEA\xE4\x20\xE6\x94\xDF\xE0\x01\xEE\xBF\x88\xE0\x1D\xF3\x81\x89\xE7\x87\xEA\xC9\x57\xE1\xF4\x15\xE0\x11\xE8\xE5\xB6\x82\x51\xF8\xE4\xD0\xD2\x9F\xD2\xDF\xA2\x71\xE5\x07\xD4\x75\xC8\x96\x60\xE8\xBE\xC2\xE7\xD8\x81\xE3\x86\xE0\xEC\xAD\xE1\x51\xEB\xCA\xFF\x85\x0C\xF7\xE5\xB2\xE3\xB9\x74\xE4\xE0\x79\xC3\xAC\xE7\x26\xE1\x7A\x3D\xE5\x91", - "\xEE\xE3\x22\xA7\xAB\xD6\xE0\x34\xE3\xE1\x00\xD4\x98\xDA\xE6\x6C\x6B\xC4\xDD\xDB\x36\xFB\xD6\xC6\xE4\x71\x98\xE5\x73\xEB\x56\xD3\xE7\x3F\x9B\xDD\xE3\xE1\x99\xED\x66\x2D\xEF\x81\x7B\xCA\x13\xF6\xE6\xA9\xD2\xB1\xAB\xE2\xAF\xB2\xCE\xB7\xE7\xB7\x8F\xD9\x28\x92\x31\xEE\xE7\x0D\x40\xBD\x99\x58\x14\xD2\xE7\xDE\xE7\x19\x95\xDE\x40\xE2\x5A\xFD\xE4\x27\xEE\x89\x76\xE1\x63\x78\xE2\x76\xE1\xCC\xD7\xB4\x13\xF7\xE7\x07\xAF\x68\x48\xE6\x8C\xE2\x89\x8C\xE7\x37\xE9\xE8\x41\x78\x92\xE0\xE8\x7C\xEE\x3D\x83\xE9\xEE\xDC\xE8\x50\xD6\xA4\xD1\x34\x55\xE7\xCD\xA4\xE8\xDF\x22\xE5\x23\xEC\x97\xC4\xB4\x96\xE6\xC9\xAE\xEA\xED\x34\xE9\xEB\xE2\x8C\xF6\x4F\x04\xE1\xD3\xA8\xD7\xBC\x8D\xE0\xD1\xE5\xA7\xEA\x7F\x95\xC8\xD2\x8B\xE1\x3E\xFB\xDB\x2A\xEE\xCD\x3A\xE5\xA0\xE1\xCF\xA2\x6D\x07\xFF\xE8\x4D\xE8\x7C\x52\xD5\x87\xE9\xD3\xBD\xC9\x37\xF1\xEA\x4C\xED\xD6\x57\xEA\xA8\xEC\xD5\x92\x4F\x32\xE2\xEA\x46\xEB\x5E\x8F\xE6\xAA\xE4\xD1\xD7\x75\x0D\xED\xE6\x3E\xE8\x83\xF3\x2F\x96\xE2\xD3\xD8\xC9\x52\xF0\x9C\xE5\xE4\xAD\xE9\xEB\xC3\xDB\xD5\xE4\xEA\x4E\xEE", - "\x6C\x50\xE0\xAB\xCC\xE6\x51\x59\xD7\xDD\xEB\x25\xEA\xEB\xC1\x7E\xA1\xFF\xEB\xB3\x90\xCF\xFE\xEA\x4D\xE4\xB4\xF4\xE7\x59\xC2\xED\xC3\xE2\xDA\x5F\xE0\x37\xCD\xE3\x77\xEA\x45\xD7\xD7\x0C\xC5\xB4\xDA\xD5\x56\xF6\xEB\x84\xB5\xA0\xDB\x77\x83\xE5\xD4\x85\xE1\x40\xCB\xE8\x1F\x46\x1D\xDD\xED\x4F\xEE\xAB\xBF\x87\x3E\xEB\xAD\xF7\x97\x20\x09\xD9\x4D\xBA\x10\x7D\xE1\xC3\xCE\x33\x25\xDD\xBB\x71\xED\x89\xDB\x81\x63\xAC\x66\xE3\xED\x9B\x8D\xD5\x95\xEA\xDC\xE9\xB4\xB6\xB7\x6E\xFB\xE5\x97\x84\xB7\x9C\xB0\xB9\xE7\xD2\xC0\xE3\x71\xDE\xED\x65\xEA\xAF\xDD\x34\x4A\xE0\xFC\x76\xD7\x7C\xB0\xEC\x08\xE9\xAA\xC3\xEF\x9A\xED\xD6\xDD\xC0\x72\xF1\xEC\xA4\xEA\x3F\xC0\xBF\xE5\xAB\xD8\xD5\xEF\xFE\xDC\xEE\x1B\xE8\xB8\xCA\xD3\xF0\xAA\x10\x36\xEF\x60\xF1\xEE\xD8\xCF\xBA\xE8\xEF\xDB\xEE\x97\x86\x0B\x9E\xD3\xEE\xBF\xEF\xB2\xC1\x7B\x06\xE0\xDF\xC9\xEE\x61\xFF\x87\x44\xED\xB7\xAF\xEA\x4A\x6A\xDB\xF6\xEC\x7B\xFE\x66\xBA\xE5\xBE\xD8\xEF\x53\xEE\xCD\x36\xCA\x80\xEB\xEF\xE7\xEA\x6E\x8E\xB0\xF1\xAB\xDF\xC4\x89\x5C\xFC\xB2\xD0\xEC\xB7\xE9\xE3\xD3\xD5\xA1", - "\xD1\xA5\x83\xE2\x55\x90\xDF\xC0\xD2\xF0\xEA\xEB\x81\x29\xC6\x86\xE2\xEF\x61\xE8\x56\x9F\x23\xFE\xE3\xE0\xE8\xEA\x92\xD4\xA8\x92\xB1\xC2\xE0\xF0\xC9\xEE\xAA\xB7\xB0\xDF\xAA\xCD\xC1\x5C\xC7\x85\x9C\x1F\xB5\x38\xC0\xB3\x43\x02\xB2\xCA\xA4\xC8\x85\x9C\x23\xB5\x38\xC8\xB0\xDC\x22\x0E\xD3\xB1\x18\x4F\xC2\x27\xBC\x77\xEF\xD6\x32\xB4\xB2\x7E\xB3\x88\xFF\xEE\xB4\xB4\xE1\xA3\xDD\x61\xA6\xEF\x8C\xEB\xC5\xCB\x88\x4D\xDF\xE1\xF2\xED\x94\xFE\x89\x96\xD5\xCA\xFB\xEB\x64\xD9\xCE\xDB\xB1\x26\xF8\xD9\x76\xB5\xAA\xA1\xF2\x30\xFA\x55\xEE\xB1\x99\xF5\xB3\x50\xB4\xCF\xBC\xBB\xA1\xDF\xE4\x97\xF3\xB2\x9C\xBB\xA8\xC9\x23\xB0\xF0\xB7\xBC\x9A\xA4\xF0\x82\xF7\xF2\x9E\xA9\xD2\x8C\xF1\xEE\xE3\xD7\xCA\x39\x62\xF1\xD1\xE0\xEA\xC5\xD6\xF2\x39\xDF\x97\xF1\xE1\x68\xA2\xCC\x76\xF3\xC3\xF1\xEF\x9E\x24\xC6\xE3\xD6\x19\xF6\xF0\x7C\xF5\xB8\xC2\x0E\xCD\xEA\x68\x9C\xEE\x7E\xF1\xF4\x21\xF6\xF6\x20\xED\x8E\x69\xE8\xD2\xF0\x81\xFE\xAC\x11\xEB\xDB\x53\xE9\x68\xB9\xB3\x5B\xF3\x6F\xFF\xDE\x17\xEE\xD3\xE5\xEC\x8D\xE2\xE8\xA6\xF4\x60\xFE\xE8\x4B\xF0\xAC\xEE", - "\x32\x91\xEA\xDC\xB5\xF6\x6A\x8E\xF3\x8B\xF2\xD6\xCA\x86\x5C\xFC\x77\x38\xEA\x7F\xE9\xF0\xE0\x58\xA6\xF6\xF5\x58\xF1\x94\x3E\xF5\x89\xF6\xD6\x73\xD4\xB8\xD9\xF4\x42\xBC\xD3\xC3\xF4\xB0\xFE\x66\x40\xEE\xD5\xC7\xF6\x97\x89\xDF\x83\xF5\x9F\xF2\x9B\xB6\xE4\xD8\xF7\xEF\x0D\x4B\xD4\xD2\xF6\x21\xE2\x0E\x4F\xEA\xDB\xEC\xEF\x5F\xE1\xDE\xD6\xF4\xCE\xB5\xEB\xCF\xF6\xDB\xD2\xAA\x74\xF8\xE7\xBA\xF5\x7E\x3F\xEA\xCE\xF5\xDD\xC1\x4B\xB1\xE9\xEE\xEE\xF5\x11\x87\xEB\xCA\xF6\xB3\xCA\x3B\x6A\xE5\xDD\xE6\xF5\xA4\x39\xE6\xDB\xF5\xB8\xD8\xF3\x07\xF9\xEB\xF1\xF5\xEE\x6C\xF7\xFD\xF2\xDD\xC8\x76\x84\xF7\xED\xAA\xF7\xE2\xCC\xF8\x02\xFA\xE1\xCF\xA2\x5E\xF4\xD8\x94\xFA\x9F\xE0\xDE\x98\xF2\xDF\xCD\xED\xC5\xA6\xF1\xA2\x6D\xA3\xF6\xDE\x8F\xF1\xD5\xFE\xF6\x16\xFA\xC6\x80\xEB\x11\xD6\xF4\x23\xF9\xBB\xEE\x89\x4D\xF5\x24\xE5\xF6\xC4\xF0\x71\x75\xBE\x8F\xF4\x08\x86\xE5\x10\x50\x02\xCC\xFF\xF4\xF6\xF3\x69\xFE\xE4\x8B\xE6\xCE\xD3\xF6\xFE\xC1\x52\x1D\xFA\xE6\x41\xFB\xFB\x01\xF4\xA9\xF8\xCE\xE8\x63\x43\xFE\x23\xC5\xF9\x80\xF1\x69\x42\xF4\xD3\xFA\xF8", - "\xC6\xEE\xD8\xF7\xF3\x84\xFD\x69\x52\xFA\xA2\xE7\xE7\xD0\xA2\xE4\xEF\xF9\x73\xB1\xED\xB9\xF8\x87\xF6\x4F\xD5\xF3\xEB\xD2\xEE\x87\xBE\xF2\xDE\xFB\xBC\x9D\xF6\x66\xF8\xCB\xA0\xF7\x9D\xFF\x10\x53\xE9\xBD\xE6\xF8\x1B\x45\xAF\xE2\xF7\xB7\xFA\xD5\x84\xFB\xAF\xF2\xF7\x92\x50\xDE\xCF\xFA\x95\xF2\xD6\xC5\xF9\x4F\x38\xF7\x5F\xFB\xD9\xE2\x6C\x7E\xFD\xF0\xC6\xF8\xB9\x20\xF8\x73\xF8\xEF\xEA\x64\x88\xF2\xF8\x8E\xFB\x53\x8C\xFC\x50\xFE\xF0\xFC\xEA\xC8\xFC\xF7\xF7\xFB\xC1\xF6\xFB\x3E\xFE\xF2\xD7\x84\x2A\xE0\xF7\x91\xFB\xB5\x65\xEC\x89\xFC\xEA\xC1\x4B\x3F\xF2\x3A\xE5\xF9\xE7\xEE\x6C\x8E\xEC\x5A\xE6\xFD\xBD\xF5\x22\x9F\xF8\xCD\xF3\x50\x49\xFE\x1C\xE7\xEC\x83\x08\xF2\xE2\xFA\x3F\xFA\xB5\xB3\xF8\x33\xD9\xF9\xCA\xF7\x36\xA1\xF6\xA2\xA3\xF5\x15\x0E\xF6\xE3\xF6\x9E\xF9\xEF\xBC\xFE\xD2\x2C\xDA\x26\xF5\xF1\xD4\x72\x58\xF4\xF7\xA1\xFF\x06\x54\xF5\xAC\xF9\xF9\xE0\x82\xE6\xE2\xFA\xD1\xFD\xF1\xE7\xFA\x92\x50\xF9\xD7\xFE\xE9\xFD\xA6\x31\xFD\x9C\x9B\xFD\xA7\xE7\x4E\xD3\xFB\xC2\xFD\xCE\x56\xFA\xE3\xE7\xF5\xFD\x9D\xD5\xE9\xFB\x80\xCD\xF5\xA7", - "\xFD\xE4\xED\x67\x61\xFB\xFD\xE3\xFE\xA3\x9E\xFD\xB7\x2C\xDB\xE8\xB0\xEA\xFE\xFD\xCB\x88\xB7\xFA\xF8\xCD\xFF\x13\xF4\xFC\xD8\x7E\xF3\x76\x9F\x32\x7D\xFE\x7D\xFF\x70\xFC\x3A\x7D\x02\x82\xF2\x7D\x53\x34\x7B\x06\x81\xF5\x7F\x0C\x40\x7E\x4B\x7F\xF0\x7A\xC7\x5B\x7F\xC8\x79\xB0\x25\xFF\x4D\x79\x42\x72\xD6\x72\xFF\x62\x6F\x41\x71\xEB\x6A\xE4\x45\x80\x19\x76\x46\x48\xF9\x73\x7F\x0A\x80\x10\x50\x00\x9C\x7F\x01\x81\x2D\x6C\xF9\x56\x7F\x81\x7E\x24\x47\x01\xB5\x18\x18\x7F\xEA\x79\x00\xA0\x41\xA9\x7D\x84\x3F\x02\xA1\x5D\x3D\x68\xF8\x78\x02\xAE\x30\xE7\x62\x0C\x80\x02\x97\x42\x2C\x7F\xF5\x69\xFF\x6C\x80\x9D\x6B\x92\x66\xF2\x4A\x6C\x05\x04\xF0\x7D\x15\x09\x57\x37\x7F\x49\x0F\xFA\x70\x02\x3C\x63\x6B\x71\x86\x0E\x77\xC1\x7F\x06\x87\xFE\x7C\x1D\xDA\x7D\x0B\x80\xC1\x45\x72\x57\x7D\xE6\x77\x36\x4C\x7F\x0D\x80\xF9\x7C\xA5\x7A\x80\x27\x70\x42\x6E\x03\xA1\x81\x9E\x7E\xFE\x7E\xA7\x42\x3D\x67\x82\x03\x89\xCA\x77\x80\x4E\x7F\x0C\x86\xFC\x65\x72\x37\x82\xF9\x72\xF9\x58\x68\xC4\x5C\x19\x88\x07\xA3\x67\x43\x82\x1C\x86\x5D\x51\x70\x7D\x83", - "\x0F\x8A\xA4\x59\x7B\x82\x81\x09\x81\x94\x28\x7D\x6A\x83\x0E\x82\xAA\x21\x7B\x85\x80\xD4\x74\xEE\x41\x82\x68\x82\x0A\x64\x00\x91\x82\xEF\x7D\xA7\x13\x09\xAE\x81\x94\x81\x18\x28\x00\x8D\x82\x73\x82\x71\x7C\x00\x98\x82\xA0\x80\xAB\x47\x03\x84\x7E\x69\x80\x11\x89\x13\x77\x80\x97\x82\x18\x89\x08\x93\x7E\x23\x81\x17\x84\x02\xBA\x6A\xE1\x71\x1B\x8A\x0A\x97\x43\xA9\x81\x29\x8E\x07\x85\x41\x2B\x83\x2D\x84\x01\x81\x2F\xA0\x7C\x27\x89\x02\x80\x3F\xA4\x7F\xB6\x36\xCF\x57\x81\x5E\x80\xA1\x55\x03\x9B\x3B\x83\x67\x2B\x8D\x09\x94\x39\xAE\x7F\x09\x37\x03\x94\x7A\xB4\x65\xED\x76\x05\xBF\x70\x27\x3B\x11\x8C\xDA\x7D\x4E\x7A\x80\xFA\x78\x5A\x56\x83\xA3\x5A\xBD\x47\x54\x54\x81\x4B\x81\xA9\x76\x83\x3E\x02\x4D\x80\x63\x47\xF1\x3C\x08\xD0\x59\x15\x88\x27\x29\x83\xE1\x83\x3A\x87\x0E\xAE\x83\xE2\x81\x50\x2E\x04\x31\x55\x95\x01\x36\x35\x02\x19\x33\xAB\x74\xDF\x17\x0F\xB9\x7E\x00\x45\x77\x3B\x0F\x85\x4E\xF9\x82\xED\x1F\x0F\x96\x66\x87\x79\x3F\x84\xDB\x76\x27\x4D\x02\x3D\x88\x0F\x8A\x84\xFC\x80\x7D\x72\x11\x03\x84\xCA\x51\x40\x8A\x74\x10", - "\x84\x94\x76\x1C\x7E\x10\x8F\x04\xE0\x83\x3F\x00\x9B\x6F\x7E\x92\x01\x36\x36\xF3\x5D\x37\xF3\x81\x77\x39\x10\xA0\x84\xD9\x33\x48\x87\x10\x91\x1A\x21\x85\xE1\x46\x12\x87\x55\x12\x86\xA3\x7A\x68\x50\x6C\xB3\x65\xD1\x65\x1F\x30\x66\x77\x83\xCF\x7C\x05\x84\x83\xCA\x81\x6E\x79\x0D\xAA\x7D\x40\x7F\x4E\x8E\xBD\x5A\x2D\xB2\x82\x2D\x80\xC2\x54\x7F\xB3\x82\x2E\x8A\x05\xBF\x82\x05\x29\x16\x81\x01\x80\x7B\xE2\x7E\x2B\x8E\x14\x86\x77\x71\x82\x2F\x8A\x08\xAE\x44\x76\x82\xF0\x72\x7F\x49\x7B\x47\x87\x54\x81\x92\x77\x80\xED\x7E\x29\x85\x0C\xB2\x4D\xF1\x7F\x2A\x8C\xE5\x64\x7D\x90\x81\x28\x8A\xA4\x48\x82\x5E\x87\xB7\x7F\xA8\x3E\x84\x6F\x71\xE1\x18\x0A\xA7\x80\xBB\x82\x4D\x86\x96\x43\x73\x41\x86\x21\x87\x0D\x5B\x82\x99\x80\x52\x8D\xE1\x7E\x7D\xB6\x23\x28\x87\x03\x88\x7E\x52\x85\x05\x88\x01\x9E\x80\x1A\x82\x58\x85\x04\xB5\x82\x76\x86\x51\x81\xBB\x71\x82\x65\x85\x51\x85\x8B\x48\x86\x95\x82\x61\x87\xC0\x79\x82\x81\x85\x56\x82\xAA\x3D\x82\x79\x86\x56\x87\xC0\x41\x83\x7A\x67\x0D\x87\x0C\x8A\x5A\xC9\x83\x53\x85\x13\xBC\x1D\xCD\x82\xC1", - "\x2F\x0C\xBD\x80\x8D\x86\x50\x85\x80\x54\x6F\xBB\x58\x5F\x84\x77\x7C\x83\x4A\x82\x46\x8D\x53\x3A\x00\x71\x55\xAC\x5E\xCD\x2D\x84\xED\x75\xBD\x14\x67\x7B\x34\xA9\x7A\x70\x02\x01\x23\x79\x05\x07\x6F\x87\xE6\x5E\x65\x5F\x7B\x30\x67\xD4\x74\x78\x72\x5A\x44\x08\x01\x00\x87\x84\x04\x73\x8A\x01\x0E\x87\xCC\x84\x16\x0C\x1C\xB1\x86\x54\x38\x4C\x85\x1C\x80\x00\x1E\x00\x73\x8C\x80\x7F\x43\xDB\x87\x25\x49\x77\x43\x87\x07\x06\x75\x80\xD8\x5D\x87\xEA\x3C\x79\x8E\xD8\x22\x87\x01\x64\x6D\x80\x1E\x86\x04\x83\x05\x46\x48\x1B\x94\x39\x15\x3C\x60\x71\x1F\x81\x64\xC2\x87\x6E\x87\x10\x35\x87\xC9\x86\x99\x53\x1E\x8C\x87\xC8\x87\x1E\x62\x1C\x0B\x87\xEB\x86\x6E\x89\x1F\x8A\x04\xCF\x85\x80\x80\x00\x05\x88\xF6\x86\x41\x02\x1D\x86\x88\xD4\x85\x3B\x38\x1E\x95\x6E\xD9\x86\x81\x86\x1E\xA0\x41\x13\x8B\x42\x4F\x1D\x89\x88\x05\x07\x83\x8B\xAC\x47\x71\xD7\x85\x85\x85\x22\x5A\x88\xB9\x84\x00\x0A\x1E\x98\x88\x00\x01\x7B\x81\x30\x52\x2A\x14\x87\xE2\x58\x1B\x82\x07\x29\x8B\x6A\x64\x9B\x57\x84\x0A\x04\x6E\x8F\xFA\x70\x88\x07\x07\xDE\x59\xE6\x45\x04", - "\x8A\x5E\xA8\x29\x23\x81\x2F\x3B\x89\xC5\x2D\x23\xBC\x1D\x3F\x8A\xED\x11\x24\x8A\x1D\x43\x8A\x68\x35\x24\xA0\x2F\x47\x8A\x70\x09\x24\x92\x04\x90\x5D\x77\x32\x79\x5D\x37\xDA\x6A\x70\x06\x79\x7C\x83\x98\x5E\x14\x89\x5F\x2D\x88\xC1\x2F\x8A\x8F\x10\xB1\x55\x34\x8A\x41\x08\x25\x95\x2C\x5A\x8B\x43\x0F\x25\xB4\x60\x8A\x59\x57\x82\x99\x19\x84\xDE\x31\xBC\x61\x13\xB2\x71\x46\x7B\x0F\x6C\x69\x58\x06\xEC\x82\x6C\x88\x0E\xAF\x83\x28\x8B\x42\x8E\x0F\x9C\x89\x0C\x84\x40\x89\x27\x84\x84\xAB\x5B\x21\x65\x38\x76\x88\x3F\x7A\x44\x0B\x24\x8F\x04\x83\x8A\x42\x05\x28\x87\x04\x87\x8A\x41\x09\x28\xB8\x88\x8E\x5F\xE0\x5D\x28\x85\x5E\xD9\x31\x93\x85\x38\x4F\x89\x85\x4D\x94\x82\x11\x13\x89\xDC\x81\xD7\x57\x10\x15\x89\x81\x88\x46\x8C\x77\x6A\x89\x74\x7A\xBB\x6F\x29\x87\x3C\x19\x88\x9E\x1A\xE3\x5A\x0E\x12\x04\x6E\x83\x18\x27\x8A\x1A\x27\x04\x88\x04\x80\x00\xAC\x8B\x01\x6D\x0A\x87\x73\x1A\x59\x96\x7E\xE5\x64\x89\xB4\x65\xAC\x55\xB1\x5B\x6C\xCD\x68\x6C\x68\xB0\x78\x19\xBD\x89\x4F\x1D\x1F\x95\x84\x05\x85\xAC\x52\x1C\x00\x8A\x42\x7A\xA0\x8F", - "\x28\x87\x5E\xCB\x89\xE2\x5D\x2C\x8B\x5E\x8B\x88\xE3\x51\x78\x4F\x8B\xA2\x2A\xA4\x87\x54\x54\x8A\x47\x56\xA5\x8F\x10\x18\x8A\x7C\x88\x15\x66\x10\x1C\x8A\xA9\x85\x62\x80\xC2\x4A\x85\x9A\x7F\xD4\x6A\xC9\x56\x86\x63\x84\x96\x4C\x16\x84\x72\x54\x6F\xBA\x88\xCE\x5B\x24\xEE\x8B\x68\x8F\x15\xAF\x8B\x37\x86\xBC\x89\x13\xB0\x43\x70\x81\x1D\x8A\x2F\xB1\x8B\x4C\x79\x41\x0D\xEC\x69\x85\x4F\x86\x5E\x2E\x1A\x92\x2A\x61\x84\xC0\x88\x13\xA2\x36\x84\x81\x66\x82\x18\x9A\x47\x75\x85\x64\x82\xA9\x0C\x82\x0A\x8F\x1E\x85\xCA\x2F\x85\xB3\x8A\xBD\x81\x30\x86\x71\xC6\x87\x52\x81\x31\x9B\x3A\x37\x83\x27\x8E\x18\x9B\x8C\x07\x70\x04\x85\x2E\x8D\x7E\x76\x4D\xB8\x8E\x30\xAF\x5F\x80\x84\xC8\x83\x2F\x9D\x79\xFA\x87\xBC\x86\x31\x8B\x7C\x15\x8E\x55\x81\xE5\x6C\x8C\xC4\x87\xC8\x87\x32\xBF\x7F\x31\x8F\x34\x8A\xF0\x44\x6B\x1F\x82\xCA\x8A\x16\x98\x45\x71\x84\xD6\x73\x2D\x71\x80\x26\x8F\x32\x8E\x59\x5F\x86\xB4\x65\x68\x87\x30\x8B\x8D\xDE\x31\x69\x82\xA1\x16\x76\x32\x8E\x77\x7A\xA1\x19\x8A\x2D\x60\x97\x17\x03\x81\x81\x35\x60\xBF\x85\xCC\x73\x3F\x54", - "\x8E\x38\x6E\x0D\x9E\x6C\x92\x25\x84\x8D\x35\xB7\x68\x58\x1A\xDE\x5C\x77\x51\x8B\x68\x8C\xB5\x8C\x23\xAA\x8D\x3E\x88\xDB\x80\x24\xAE\x8D\xB6\x1E\xB5\x8A\x4C\x58\x8B\xCA\x52\xB6\x8A\x10\x1C\x8B\x86\x79\x9F\x85\x10\x20\x8B\xCA\x50\xB2\x89\x6C\x44\x8A\x70\x8C\x91\x81\x38\x86\x89\x83\x8C\x92\x85\x38\x8A\x89\x87\x8C\x93\x81\x79\x53\x5E\xD9\x30\xDE\x84\x2C\xBA\x8D\x00\x00\xDF\x8B\x2F\x41\x25\xB1\x87\xEB\x76\x2C\x92\x04\x7E\x8E\x9B\x86\x28\x89\x8E\x80\x8F\xB4\x8E\x39\x8E\x8A\x9F\x8C\xA4\x81\x3A\x8C\x8B\x8F\x5F\xE2\x80\x25\x8D\x8E\x97\x5D\x5C\x50\x08\x31\x55\x81\x01\x5C\x53\x08\x25\x83\xC1\x2F\x85\x8F\x0D\xB0\x8E\x15\x2D\x7D\x07\x2C\x99\x33\xF5\x06\x37\x36\x3B\x8A\x8B\xDD\x37\xEE\x8D\x39\x85\x4E\xBE\x8F\xE6\x8D\x3B\x9C\x8E\x0A\x05\xF0\x88\x28\xB8\x8E\xC4\x8F\x41\x06\x3C\x8A\x8A\xC8\x8F\xE8\x85\x58\x4B\x8F\x8C\x8B\xF0\x8E\x3C\x8B\x5E\xD0\x8C\x00\x02\x37\x8F\x8F\xA6\x8C\xF0\x8C\x38\x92\x8F\x85\x4E\xE3\x8D\xAE\x45\x6D\x92\x8D\xCF\x77\x2F\x93\x78\xAC\x79\xCF\x86\x16\xBB\x63\x37\x80\x18\x87\x3E\xB7\x8C\xC0\x3C\xF4\x7A\x18", - "\x82\x8D\x60\x2F\xC0\x8F\x3E\xAB\x8C\xC4\x7C\xBA\x8A\x0D\x98\x85\x1A\x8F\xFA\x8E\xA6\x7B\x8B\x0D\x8E\xD1\x8D\x7B\x5A\x8D\x79\x60\x7B\x5D\x3F\xBA\x85\xEA\x3E\x99\x85\x19\xB9\x8F\x1B\x21\xC1\x83\x3F\xA3\x8F\xC1\x2D\xC2\x8A\x3F\x84\x90\x91\x18\x5A\x8B\x40\xAC\x8B\xD8\x5F\x00\x9A\x19\xA7\x4D\xFC\x7F\x03\x97\x41\x96\x75\x39\x8E\x64\x84\x3F\x82\x63\x86\x4D\x61\x86\x30\x8A\x73\x1D\x8E\xFC\x87\xF9\x3E\x85\x00\x93\xEA\x6B\x37\x56\x90\x41\x8C\x39\x7C\x18\xA6\x8F\x1F\x8D\x08\x80\x19\xBE\x8F\x1E\x90\xE1\x45\x2B\xA9\x90\x91\x54\xCD\x8A\xA1\x76\x8C\x34\x93\x35\x44\x19\xBE\x8C\xA2\x85\x4F\x18\x19\x9A\x90\x0B\x8E\x89\x43\x36\xBA\x18\x2C\x92\xFD\x8C\x77\x08\x8D\x45\x6E\xD2\x8F\x32\x94\x83\xE0\x63\x11\x90\x90\x38\x90\x57\x85\xC9\x7D\x2D\xB7\x66\x6F\x53\xD5\x8D\x1A\x94\x91\x33\x8C\xD7\x87\x45\xB0\x6C\x06\x05\x83\x8A\x33\xAE\x64\x5C\x6D\x0B\x9F\x33\xA5\x91\x4A\x93\x07\x92\x3C\x37\x80\xEE\x8F\x01\x90\x3F\x8A\x04\x44\x86\x6A\x84\x44\xA9\x91\x0C\x91\xC5\x24\x2E\xAE\x8C\x15\x74\xD5\x35\x34\x90\x90\x81\x68\xDE\x2C\x3F\xBB\x91\x1B\x90", - "\x07\x8B\xDD\x70\x90\x72\x92\xE9\x6E\x2F\x9C\x85\x26\x90\xF0\x3A\x40\xAE\x91\x6A\x93\x41\x0E\x40\xB1\x90\x90\x92\x7D\x22\x41\x8C\x92\x67\x91\x05\x90\x48\xA6\x91\xA2\x35\x06\x91\x49\xA2\x8B\x88\x41\x07\x93\x42\xB9\x91\x73\x84\xAD\x84\x48\x9C\x92\x21\x80\x5E\x83\x47\xB7\x8F\x4C\x65\x22\x95\xA0\x22\x8C\x78\x93\xD6\x8E\x2A\x88\x90\x85\x91\xE8\x34\x31\xAF\x90\x22\x93\x04\x95\x96\x68\x70\x15\x79\x2D\x94\x49\x82\x92\x33\x90\x1F\x9D\x43\x8B\x7E\x9E\x92\x2D\x9F\x32\xBC\x8C\xBA\x90\x10\x94\x2F\x94\x51\xA3\x90\xFB\x81\x02\x9C\x86\xB4\x67\x30\x8F\x44\xA0\x92\x85\x7B\xE3\x8E\x2D\x88\x7A\x5C\x91\x08\x8E\x34\xA8\x60\xD5\x92\x21\x9B\x82\x52\x91\x6C\x71\x32\x9F\x4B\x95\x91\xAC\x84\x3F\x82\xDA\x4C\x8D\x51\x8F\x06\x2E\xFB\x74\x66\xB1\x86\xAF\x82\x11\x20\x88\x83\x04\x8E\x59\xDA\x46\x04\xAA\x8A\x44\x0E\x4E\x87\x55\xF8\x86\x32\x55\x4F\x85\x56\x63\x8A\xED\x11\x26\x8A\x04\xF9\x91\x19\x75\x26\xBB\x89\x11\x84\x40\x92\x4D\x98\x91\x06\x87\xEC\x8C\x3D\x87\x55\x99\x8F\xE2\x59\x11\x82\x07\xB9\x8D\x4F\x15\x3D\x91\x8B\x0F\x95\xF3\x80\x3A\x9A", - "\x8F\xD3\x8E\xA8\x21\x51\x87\x94\xA4\x8C\x45\x93\x51\x87\x55\x17\x96\x46\x92\x3A\x9E\x94\x19\x94\x47\x91\x29\x92\x94\xD7\x88\x49\x95\x37\xA6\x94\x85\x56\xF7\x8E\x22\xA0\x8F\x28\x97\xE2\x59\x50\x96\x94\x7C\x5D\x47\x92\x52\x95\x94\xC1\x2E\x4C\x9A\x4C\x76\x94\xD8\x8C\x4D\x95\x3B\x89\x8F\x06\x04\x4E\x94\x3D\xBC\x94\x05\x06\x4F\x90\x53\xBA\x94\x7C\x1D\xF5\x87\x3D\xBF\x94\x4E\x89\x4B\x92\xAA\x36\x8D\xCA\x8C\xEA\x84\x25\xB4\x8E\x7C\x1F\x42\x9A\x1C\x91\x81\x27\x86\x9B\x1F\x52\xAE\x44\x69\x8C\x51\x92\x24\x80\x95\xD2\x8B\x46\x91\x52\x9F\x95\xCE\x89\xE9\x89\x54\xA7\x8E\xDD\x36\x4A\x9B\x26\x85\x84\xE1\x8E\xA8\x27\x55\xB3\x4B\x59\x96\x57\x91\x56\xAE\x95\xD0\x88\x57\x9D\x56\x9F\x94\x47\x57\x51\x92\xAA\x34\x8D\x85\x54\x53\x96\x10\x26\x95\xA1\x88\x4B\x97\x23\x80\x00\xEF\x85\x3B\x33\x1F\x95\x6E\x83\x97\x86\x81\x1C\x8C\x87\xF7\x92\xF8\x84\x17\x83\x88\x3B\x91\x40\x63\x2C\x8A\x96\xE0\x2C\x80\x84\x22\x85\x96\x21\x88\x82\x8C\x58\x86\x04\x96\x96\x7F\x82\x11\x0B\x88\x24\x8A\x18\x91\xEF\x20\x88\x54\x3A\xD8\x87\x59\x99\x8C\xFB\x86\x81", - "\x82\x3B\x9A\x96\x0F\x04\x68\x9D\xCE\x1E\x88\x45\x40\x6B\x99\x11\x6A\x96\xD7\x3B\x88\x87\x54\x5F\x84\x24\x8A\x89\x83\x2F\x41\x96\xD7\x38\x65\x90\x1F\x88\x96\xBC\x96\x84\x8A\x1D\xBC\x87\xCC\x86\x64\x93\x5A\x8D\x87\x06\x89\x66\x9D\x1B\x92\x04\xC6\x94\x64\x92\x1C\x1C\x96\xC3\x96\x67\x97\x0D\x70\x96\xF1\x3A\x68\x98\x5A\xB5\x8C\x01\x66\x6B\x9E\x12\x67\x96\xC7\x95\x6A\x9F\x5B\xBE\x96\x06\x88\x74\x97\x0D\x72\x96\xCA\x50\x6D\x93\x5C\xB6\x96\x7C\x1C\x65\x92\x1C\x26\x97\xD3\x1B\x59\x90\x39\xBA\x8A\x7A\x73\xBB\x03\x18\x1D\x00\xA4\x8B\xED\x1F\x2A\x9B\x00\x50\x97\xF2\x6A\x68\x50\x83\x45\x6C\x7B\x95\x84\x78\x19\xF0\x95\xC9\x25\x2A\x9B\x6C\xF4\x96\x95\x87\x12\x3F\x8A\x1B\x6D\x7F\x9F\x4E\x85\x04\xF1\x93\x43\x01\x60\x95\x95\x61\x20\x07\x01\x57\x79\x00\xF5\x96\xD2\x1B\x60\xAC\x84\xD9\x33\x84\x99\x37\x93\x93\x00\x03\x0D\x06\x27\x9C\x93\x0A\x06\x86\x9C\x0F\xB8\x00\xF1\x94\x13\x62\x11\x36\x00\x11\x9A\x68\x36\x61\x85\x56\xFB\x93\x41\x07\x62\x9F\x8F\x72\x72\x87\x9A\x27\xBC\x83\x2E\x9B\x51\x5E\x60\xBC\x83\x10\x99\x77\x33\x63\x9C\x98", - "\x07\x05\x8D\x97\x60\x80\x96\x78\x18\x89\x92\x60\xA2\x2A\xC9\x94\x90\x95\x1B\x95\x98\x1B\x9B\x51\x5B\x62\xAB\x94\x2D\x98\x91\x9D\xDD\x29\x98\x06\x07\x91\x9A\x5E\x98\x98\x31\x9A\x32\x5E\x64\xA0\x89\x4A\x98\x8E\x96\x10\x11\x99\x2A\x37\x2B\x9D\x0D\x82\x4D\x0C\x9B\x4A\x06\x39\x95\x99\x14\x99\x77\x33\x65\xB8\x8A\x45\x6C\x96\x9B\x78\x63\x99\xFA\x90\x98\x91\x50\xA2\x99\x71\x56\x99\x92\xAA\x28\x99\xFE\x90\x6D\x6E\x66\x81\x2F\x70\x9A\x68\x3C\x64\x85\x04\x75\x98\xF8\x27\x67\x80\x00\x79\x9B\xEB\x73\x67\x95\x2C\x7D\x9B\x07\x2F\x67\xBC\x1D\x79\x9A\x70\x0B\x67\x81\x9A\x36\x23\xA0\x9A\x13\x29\x8A\x78\x19\x7E\x70\x9B\x42\x07\x59\x01\x91\x9A\x4C\x51\x9A\xFC\x81\x29\x02\x69\x83\x94\x60\x91\x41\x06\x69\x9D\x37\x6B\x97\x01\x73\x57\xA0\x95\x71\x96\x56\x92\x38\xA2\x9A\x84\x8C\xA9\x96\x38\xA2\x95\x93\x8B\xF6\x8D\x3D\xA9\x8E\x3F\x99\xF0\x2C\x5C\x97\x98\x04\x97\xE5\x8F\x10\x14\x9A\x2F\x99\xE1\x44\x6B\x9F\x91\x01\x74\x00\x0B\x69\xB6\x9A\x97\x9B\xE2\x57\x6B\xB0\x9A\x99\x9A\xAE\x95\x62\x8A\x61\xED\x97\x11\x6E\x68\x04\x98\x99\x1A\x42\x09", - "\x11\xBB\x8A\xC9\x9A\xAD\x21\x62\xB8\x19\xCB\x98\xA3\x9B\xB1\x47\x9B\xD2\x99\xB3\x96\x10\x11\x9B\xFB\x97\xB4\x9F\x6C\x9B\x6C\xD8\x99\x8C\x88\x67\x1B\x3C\x0F\x6F\xB7\x9B\x6D\x96\x9B\x05\x07\xC6\x32\x1C\x20\x88\xE7\x99\x36\x30\x22\x9F\x99\x9C\x9B\xD9\x82\x57\xAF\x9B\xA6\x98\xE2\x81\x6F\xBC\x8E\x70\x95\xB5\x89\x3D\x99\x8B\x4E\x96\x95\x9B\x37\xB7\x7F\xE7\x88\x2C\x94\x32\xB5\x8F\xFE\x9A\x32\x9B\x81\x2A\x8F\x9B\x92\xC0\x96\x9F\x2D\x91\xC6\x90\x14\x91\x3F\x99\x93\xB1\x90\x29\x9D\xF0\x68\x7A\x90\x97\x33\x91\x6F\x79\x8B\x0C\x9C\x8C\x5D\x14\xA4\x93\x56\x83\xC5\x92\x71\xA3\x7D\x79\x81\x12\x91\x70\xA1\x21\x06\x91\xC2\x9B\x33\x80\x82\xDE\x92\x2F\x9F\x07\xAF\x64\x97\x90\x1D\x92\x37\x53\x92\x22\x9C\x19\x96\x49\xA5\x9C\x81\x93\x2D\x9E\x16\x95\x9C\x24\x7F\x60\x8B\x58\xB0\x9C\x98\x91\x88\x8D\x4B\xB1\x9C\xC3\x93\xE2\x35\x42\xB4\x9C\x9D\x81\x54\x6E\x71\xBC\x90\xF9\x14\x29\x8E\x70\x8D\x9C\x6E\x19\xCA\x87\x4A\xAF\x91\xB8\x92\x93\x71\x71\xA5\x93\x4A\x6B\xCE\x99\x73\x8F\x56\x3A\x90\x87\x84\x74\xBC\x9C\xE0\x73\x0D\x93\x74\xAD\x92\xF1", - "\x3B\x0F\x9B\x74\x9C\x9D\x92\x2B\x10\x95\x70\x9F\x93\xC0\x80\xD1\x88\x73\xAA\x9C\x21\x88\x13\x92\xC7\x4E\x91\x50\x9F\xBF\x93\xD9\x6C\x98\x05\x84\xD4\x83\x46\x9C\x9C\x65\x8C\x3F\x82\x0D\xB5\x90\x17\x8E\xBB\x42\x4E\xAA\x92\xE6\x91\xCC\x7D\x6A\x95\x2C\xE4\x96\x7D\x99\x2B\xA6\x8D\x7F\x97\xA7\x9F\x56\xB4\x95\xA0\x9A\x8E\x80\x6F\xB5\x9B\x6B\x8C\xAA\x95\x52\xA4\x95\xAB\x9B\x53\x9D\x6E\x85\x9E\x8B\x9C\xE2\x97\x78\x89\x9E\x8D\x9C\xE3\x9D\x36\xB3\x9B\x0F\x06\x5D\x91\xBC\x38\x95\x8B\x5E\x5E\x95\x10\x3C\x95\x64\x9A\x1C\x79\x56\xA7\x88\xCF\x42\x6E\x9D\x53\x2A\x9E\x9D\x19\x62\x99\x11\x6E\x9E\x2E\x46\x75\x99\x4B\xB3\x37\xC2\x07\x63\x99\x11\x42\x97\x7F\x8C\x6F\x84\x7B\x88\x97\x7C\x5D\x90\x9E\x12\x6F\x9A\x9A\x8C\x6A\x79\x2C\x9A\x97\x7F\x96\x74\x91\x7C\x96\x9D\x67\x4E\xEC\x9C\x77\x18\x97\xBB\x9C\xF1\x9D\x29\x94\x97\x84\x5A\xF2\x96\x7B\x1E\x97\x92\x24\x78\x97\x7C\x85\x04\x81\x9F\xB3\x54\x27\x81\x0C\x71\x88\x6C\x6D\x7D\xA7\x07\xDF\x9F\x9C\x81\x0F\x9F\x0A\xE1\x9C\x3C\x8D\xD3\x20\x9F\xDB\x9F\xD3\x05\x7E\xA4\x9F\xE9\x9D\xFB\x0B\x7E", - "\x9C\x9F\xED\x9D\x74\x0F\x7E\xA0\x70\xB8\x95\xBC\x3C\x7A\xB6\x9F\xBD\x94\x89\x80\x7B\x9D\x88\xDB\x94\x89\x86\x7B\x87\x75\xB8\x9D\x76\x9A\x7B\x9A\x77\xBE\x9F\x75\x85\x80\x80\x76\xC0\x9E\x72\x9D\x99\x43\x97\xD4\x9C\x08\x76\x7C\x8A\xA0\x2D\x8D\xE5\x62\x7D\x84\x5A\xCC\x9E\x76\x7D\x80\xB6\x42\x13\xA2\xDC\x49\x81\x86\x77\x17\xA3\x3F\x46\x7D\x90\xA0\x0A\x05\xF6\x96\x67\xBC\x5D\xF7\x9E\xA4\x25\x82\x92\x26\xFB\x9F\x01\x79\x82\x89\x9F\x7C\x5F\x06\xA5\x7B\xBC\x5D\x01\xA1\xF3\x93\x80\xAE\x44\x07\xA3\xD9\x45\x83\x84\x5A\x09\xA1\x46\x4E\x5C\x92\x26\x1D\xA3\x06\x2F\x80\x99\x44\x2E\xA3\xAD\x87\x36\x55\xA0\x2E\x45\x0F\xA6\x9F\x01\xA1\x11\xA2\xDC\x46\x84\x91\x1A\x1F\xA1\x46\x42\x82\xB2\x89\x41\x26\x8E\x97\x54\x4A\x9A\x71\x99\xD1\x6F\x64\x5D\x99\x27\x07\xA3\x93\x62\x99\x33\x52\xA2\x32\x5E\x63\x85\x4E\x54\xA2\x4B\x84\x9B\x57\xA1\x18\x6D\xD0\x3D\x85\x85\x56\x61\xA0\xC8\x7A\x68\x64\xA1\x60\x8E\x19\xA9\xCD\x29\xA1\xAF\x7C\x1B\xA5\x58\x60\x98\xDD\x37\x17\xA7\x54\x67\xA1\x8B\x5E\x1D\xAA\x4C\x70\xA1\x1F\x22\x1C\xA9\x87\x9C\xA1\xD9\x32", - "\x1E\xA8\x86\xB1\x55\x7E\xA0\x69\x6F\x34\x2F\x7E\x6A\x00\xDF\x55\x7F\x97\x43\x27\xA0\x08\x7D\x88\xB6\x42\x2B\xA1\xE5\x61\x89\x86\x96\x21\x90\x08\xAD\x58\x95\x6E\xFF\x9F\x75\x81\x83\x9A\x77\x8F\xA3\x3F\x47\x83\x94\xA2\x9F\xA1\x88\x89\x83\x87\x75\x3B\xA0\x08\x7B\x84\xA0\x41\x3F\xA3\x51\x7B\x81\x9E\x33\xAB\xA1\x4F\x14\x84\x97\x87\xA7\xA3\x42\x4D\x8A\x9D\x1A\xB3\xA1\x50\x28\x6E\x92\x04\x74\xA0\x89\x8D\x84\x87\x75\x4F\xA3\x6D\x8C\x1C\x9D\xA2\x97\x40\x30\xAA\xFE\x13\xA2\x21\x88\x31\xA4\xE5\x35\xA2\x92\x28\x32\xA2\x99\x19\xA2\x80\x77\x26\xA7\xD4\x42\xA3\x8E\x35\x28\xA4\xE5\x12\xA3\xED\x33\x28\xA7\x1D\xA5\xA2\xB6\x41\x2C\xA5\x22\x69\xA2\xFC\x9C\x77\x94\x22\xAF\xA2\x80\x76\x36\xAD\x5A\xBD\x9F\x0C\xA1\x36\x39\x8B\x83\x97\xBB\xA3\x75\x8D\x8B\xBD\x14\x8B\xA1\xEA\x9F\x8B\xB9\x9F\xC3\x96\x31\xAB\x5A\xA4\xA3\xD3\x97\x41\x0C\x8C\x81\x64\xCE\xA3\x75\x80\x8D\xA0\x41\xD4\xA3\xB5\x3D\x8F\xB1\x3B\xD6\xA0\x60\x78\x8D\xBF\x43\xE2\xA1\x46\x4C\x8D\xA5\x96\x24\x8A\x32\xA1\xF4\x20\xA3\x01\x65\x41\xA1\x7B\xB4\xA3\x02\xA1\x78\x8C\x1C\xA9", - "\xA3\x80\x77\x13\xA2\x1C\x34\x00\xD9\x30\x46\xAC\x0F\x89\xA2\xFE\x96\x7C\x97\x0D\x86\x04\x69\x03\xB0\x98\x88\xB1\x97\x09\x9A\x42\x01\x92\xBF\x9D\x5B\x98\x42\x58\x67\x18\x50\x83\x05\x4A\x85\x6A\x0A\x04\x2E\xA5\xC2\x35\x56\x78\x19\x77\x03\x4A\xAB\x6C\x5F\x20\xFD\x90\x40\x01\x27\xBB\xA4\xE8\x9E\xF8\x96\x7E\xAC\x9F\x3E\xA4\x50\xAF\x93\x9B\x3B\x2B\x86\x4C\xA8\x7C\x95\x8D\x06\x04\x92\x7F\x92\x87\x04\x73\x00\x9E\x1D\x94\x9B\x6C\x71\x7B\xAB\x82\xE3\x4B\xA5\x06\x07\x3D\xA8\x94\x85\x04\x7D\x00\x9E\x12\x62\x99\x9B\xE4\x9B\x20\x9B\xC7\x4A\x8E\x1B\x6C\x6F\x53\x18\x22\xA5\x20\x41\x57\xA1\x07\x38\x19\x75\x00\x9E\x10\x07\x2A\xA5\x78\x18\x1D\x08\x67\x2C\x00\x37\xA6\x0D\x2E\x96\x9B\x6C\x85\x00\x9E\x17\x08\x38\x19\xB5\x00\x9E\x16\x0B\x38\x19\x41\x7A\x51\xA5\x10\x3D\xA5\x5F\xA6\x92\x5C\x97\xB8\x19\xC4\xA3\x60\x05\x98\x92\x04\x79\x00\x9E\x18\x07\x0A\xA6\x78\x19\x62\xAB\xB1\x4B\xA6\x8F\xA4\x9E\x13\xE7\x69\xA4\x05\x04\x2D\x08\x67\x39\x02\x97\xA4\x9E\x11\x9A\x54\xA5\x05\x05\x23\x01\x97\x92\x28\xBB\x00\x9E\x11\x9A\x9B\x6C\x71\x67\x60", - "\x06\x99\x9B\x6C\xB2\x02\x68\xA2\x99\xAB\xA6\x1B\x6F\x64\xAA\x29\x86\x04\xAE\xA7\x55\xA0\x00\x31\xA6\x5E\x8F\x41\x04\x9B\xA4\x8D\xB6\xA4\x6B\xAD\x95\xB7\xA6\x83\x04\x6F\xAA\x63\x7B\xA6\xBA\xA4\x67\xA3\x9B\x81\xA7\x7E\xA7\x70\xAD\x9A\x84\xA7\x81\xA5\x47\x18\x9C\xAE\x97\x12\x07\x6C\x72\x9C\xAE\x6C\xC2\xA6\x6F\xAF\x10\x27\x02\x78\x18\x2A\x08\x67\x10\x0E\xC9\xA7\x41\x0E\x03\x1F\xA6\x19\x2C\x76\xAC\x9C\xA8\x79\x5D\xA5\x40\xAF\x9A\x85\x04\x3F\x6F\x60\x05\xBD\x43\x06\x55\x00\x9E\x10\x04\x38\x19\x47\x8B\x60\x0B\x0A\x38\x19\xA9\x00\x7C\xA8\x67\x2A\x02\x78\x1B\xC7\x73\x18\x36\x64\xF7\xA4\x9E\x13\x8F\x43\x06\xFB\xA6\x44\x0C\x09\x38\x19\xFF\xA7\xC6\x6E\x09\x38\x19\x96\x00\x81\xA6\xA0\x9B\x6C\x05\xAB\xC6\x6F\x09\x38\x19\x0B\xAB\xC6\x6B\xA7\x43\x06\x84\x00\x9E\x1C\x08\x38\x19\xB1\x00\x9E\x1E\x0A\x38\x19\xAF\x00\x9E\x14\x0C\x38\x19\xC5\x00\x9E\x14\x09\x38\x19\x3E\x7A\x70\xAF\xA1\x9B\x6C\x91\x00\x9E\x15\xA2\x9B\x6C\x93\x00\x9E\x19\x09\x38\x19\x9A\x02\x8A\xAC\xA2\xAE\xA8\x1B\x6D\x8B\xAB\xB1\x4E\x3C\x12\x07\x1B\x08\x67\x36\xA8", - "\x1B\x6D\x88\xA5\x9C\x87\x01\x78\x18\xE9\x93\x9E\x80\x00\x3E\xAA\x6C\xA1\xA4\xB5\xA6\x7B\x94\x9E\x1B\x04\x38\x19\x4C\x00\x9E\x1D\x0B\x38\x19\xBC\x00\x9E\x10\x7D\x43\x06\x4F\xAA\x44\x02\x08\x38\x19\xA1\x00\x9E\x1B\x00\x38\x19\x0A\x00\x96\xA8\x67\x2B\x32\x83\x04\x97\xA2\x11\x11\x46\x1B\x6C\xE8\x97\x84\x60\xA9\x5D\xA6\x98\xAF\x2A\xA4\xA9\xC2\xA7\x0B\x08\x67\x21\xA2\x83\x04\x9B\xA2\x11\x37\x98\xC2\xA4\x9C\xA5\x9C\xB2\xA9\xD9\xA6\x41\x04\xA7\x9F\xA7\x0A\x06\x46\xAD\x95\xBA\xA9\xC2\xA4\x9F\xA5\x9C\xBE\xA9\x75\xA9\x41\x05\x03\x38\x19\x83\xAB\xC6\x62\x03\x38\x19\x87\xAA\xA1\xA8\xA8\x8B\xAA\x8A\xA9\xA3\xAD\x95\x89\xAA\x8F\xA8\x9E\x14\x0A\x12\xAA\x78\x1A\x29\x08\x67\x23\x02\x97\xA8\x9E\x1F\x84\x83\x06\xE3\x1B\x60\x08\xE3\x41\xAA\x00\x01\x4C\x3D\x95\xB0\xA5\x70\x8B\x07\x2C\x06\x38\x19\xA7\xAB\xC6\x69\xAA\x9D\xA5\x6E\x00\x9E\x1D\xAA\x9B\x6C\x68\x00\x9E\x1B\x06\x38\x19\xB1\xAB\xC6\x63\xAB\xB0\xAA\x6A\x04\x3E\x01\xA0\xAD\x97\xBC\xA9\xAF\xAE\xAB\xBF\xAA\xC0\xA9\xB0\xAC\x95\xAA\x76\xD5\x98\xB1\xA3\xAC\xB0\x93\xC5\xA8\xB2\xA7", - "\xAC\x88\x98\xC9\xA8\xB3\xAB\xAC\xBC\x98\xCF\xA9\xB8\x9E\x7C\x92\xA4\xD3\xAA\x41\x09\x6E\x95\xAB\xFF\x96\x42\x07\xAD\x9A\xAB\xEB\x91\xB7\xA8\xAD\x80\x00\xDB\xA9\x53\x9F\x10\x0C\x07\xE4\xAA\x44\x05\xAE\xA3\xAB\xE6\xA9\xBA\xA8\xAE\xAB\xAB\xC5\x8E\xBA\xAD\xAE\xAC\xAB\xE2\xAA\x49\x22\x53\x0A\x0E\xF4\xAA\xBC\xA5\x6E\x17\x1B\xF8\xA8\xC2\x33\xAF\xB6\xAB\x7A\x0D\xBF\xAA\xB1\x76\xAB\x5E\x0D\xC0\xA3\xE2\x4A\x68\xD5\x2C\xC1\xAE\x6C\x86\xAC\x06\x06\xC0\xA8\xB0\xB0\x50\x05\xAD\xC3\xA7\xB0\x8A\x9B\x12\x07\x3D\x62\xB1\x91\xAC\x14\xAE\xA7\x86\xB1\x90\xAC\x17\xAF\x41\x03\xB1\x99\xAC\xD7\x99\xC5\xA8\xB1\x8A\x04\x87\x0D\xC8\xA2\x11\x22\xAC\x0F\x04\xC9\xA0\xB2\xA3\xAC\x28\xAD\xC9\xA9\xB2\xA7\xAC\x2A\xAD\xCB\xAC\xB2\x8A\x04\x19\x17\x60\x09\xA5\x8F\x04\x57\xAA\x51\x3A\x2F\x46\xA7\x3C\x04\xAC\x11\x37\x12\x04\x89\x95\xD8\x2F\xA9\x80\x00\x31\xAE\x44\x03\xB3\x8A\x04\x35\xAE\xEE\x91\x4F\x26\x66\xA8\x64\xBB\x6E\x9D\xBD\xAC\x41\x5A\x44\x01\xB4\x8F\x04\x43\xAF\x41\x05\xB4\x86\x4C\x37\xAC\xD2\xAA\xB3\x8F\x04\x4B\xAC\xBC\x8A\x10\x3F\xAC\xA2", - "\xAB\x41\x0F\xB4\x8A\x04\x51\xAE\x41\x03\xB5\x9A\x1B\xC8\x93\xA1\x5E\x19\x17\x1A\x3B\xAF\x43\x0C\xB4\xB7\x78\x2B\x36\xD3\xA2\x11\x32\xAC\x12\x07\xD8\xA2\x20\x86\x3F\xCA\xA4\x47\x07\xB5\x8A\x04\x59\xAF\xC2\x9B\xB5\xAD\xAD\x0F\x07\xD7\xA7\x10\x21\xAD\x05\x06\xDC\xA4\x5C\xA5\xAD\x38\xAD\x62\x07\xB7\x87\x04\x79\xAC\x1C\x9D\xB4\x8F\x04\x5D\xAE\x41\x0E\xB7\x86\x04\x80\xAC\x00\x02\xB8\xB6\x14\x47\xAF\xD9\xAE\x6B\x18\xAD\x3C\xAE\xD6\xA7\x10\x3F\xAC\x8F\xAD\x41\x01\xB9\x93\xAE\xEB\x2A\xD5\xAF\x26\xB8\xAD\x99\xAE\xDE\xAB\xB9\xBC\xAD\x30\xAF\xDB\xA2\xB4\xB1\xAD\xAE\x19\xE5\xA6\xB7\xA3\xAE\x88\xAD\xE9\xAA\xB8\xAC\xAD\x8C\xAE\xDB\xAF\x10\x30\xAD\x34\xAD\xEB\xAF\x9B\x86\xAE\xB0\xAD\xD6\x02\xBB\x8F\x25\x7B\xAD\xED\xAD\xB7\xAA\xAE\x50\xAC\xEB\xA6\xB3\xB7\x27\x10\x17\xEB\xA8\xB6\x98\xAE\x6A\xAE\xE6\xA6\xB2\x28\xAE\x5E\xAC\xF1\xA0\xB6\x86\xAF\x46\xAF\xEE\xA6\x10\x09\xAD\x69\xAE\x42\x0B\xB6\x81\xAF\x0A\x05\xE3\xA5\x6E\x92\xAF\x7F\xAC\xF5\xA4\xB5\x88\xAF\x75\xAD\xCE\xAD\xBB\xA2\x0D\xBF\xAE\x19\x87\xBA\x82\xAF\xA9\xAF\xED\xAB\xBA", - "\xB9\xAE\xC7\xAE\xEB\xA6\xBE\x8B\xAF\xA4\xAD\xF3\xA6\xBA\x8F\xAF\xEC\xAF\x41\x06\x01\x36\xAE\x21\xA3\xFB\xA4\xB4\xBA\xAE\xC9\xAF\xFC\xA7\xB9\xB5\xAF\xDA\xAE\xF3\xA5\x10\x1C\xAD\xFC\xAF\x41\x08\xBB\xBF\xAF\xF1\xAE\xF5\xA5\x10\x18\xAF\xCC\xAD\x01\xB7\xBF\x87\xB0\xD0\xAE\xE3\xA0\xBE\x90\xAE\xE2\xAC\xD9\xAF\x8C\x70\xA6\x96\xAE\x41\x0A\xB4\xA9\xAF\x38\x3F\xE2\xAD\xBE\xBD\xAF\xC5\xAC\xFC\xA5\xBD\x81\xB0\xBC\xAC\xFD\xA1\xBB\xB6\xAF\xB3\xAC\xF7\xA1\xBD\xAE\xAF\x25\xB0\x03\xB7\xC2\xA5\xAF\x29\xB3\x00\xBB\xC2\x92\xB0\x2D\xB3\xFA\xAD\xBD\x92\x04\x3C\x7B\x41\x01\x83\x9D\xAE\x00\x03\xE7\xA0\xC0\xB4\xB0\xD7\xAF\xE1\xAE\xBB\xAC\xB0\xC0\xAE\x0E\xB7\x10\x1E\xAF\x00\x01\x0F\xBE\x7B\x09\xB0\xEC\x86\xFF\xA2\xB5\x83\xB1\xB9\xA6\xF2\xA6\xC3\x87\xB1\x38\xB1\x12\xB8\xBF\xBB\xB0\xC3\xAC\x0C\xB3\xBD\xA6\xB0\xE3\xAE\xFC\xA5\xC3\x9E\xB0\xD9\xAF\x7D\x86\xC0\x80\x00\x08\xB1\x17\xB4\xC2\x9F\xB1\x32\xB1\x18\xBE\xC0\x85\x5A\xE7\xAD\xE0\x00\xC2\xA8\x5B\xB4\xAC\x17\xBA\x10\x3B\xAF\x6A\xB2\x02\xB2\xC5\xA2\xAD\x54\xB0\x07\xB6\xC5\xA4\xB1\x11\xB2", - "\x19\xB3\xC1\xA8\xB1\x15\xB3\xF7\xAE\xC5\xA1\xAF\x60\xB2\x06\xB4\xB7\x95\xB1\x02\xB0\x20\xB4\xC0\x82\xB2\x39\xB3\x16\xBB\xC4\x90\xB1\xD8\x9F\x1E\xB1\xB8\xBD\xB1\x66\xAF\x1F\xB5\x10\x1F\xB0\x48\xB2\xFA\xA2\xC9\x86\x04\x4C\xB2\x13\xB5\x10\x3F\xB0\x17\xB2\xE7\xA9\xC1\xB3\xAD\x55\xAD\x07\xBB\xC9\xA5\xB1\x06\x07\xF6\xAA\xC4\xA0\xB2\x3C\xB3\x0A\x9F\xC2\xAB\xB1\x88\xB1\x1B\xBA\xC8\xA9\xB2\x9A\xB0\x00\x0C\xC9\x99\xB1\x9E\xB0\x05\xB9\xBF\x86\x04\xA2\xB0\x00\x04\xCA\x87\xB2\x18\xB1\x22\xB8\xCA\xA4\xAF\x8C\xB3\x18\xBB\xCA\x81\xB2\xAD\xB3\x19\xB9\xC6\x8A\x04\xC1\xB3\x32\x30\xC4\x82\xB1\x0D\xB0\x0A\xB5\xC4\xB1\xB1\x89\xAE\x16\xBE\xCB\xB6\xB1\xFA\xAC\x25\xB5\x22\x96\xB2\x92\xAC\x26\xB5\xB8\x97\xB3\x2A\xB0\x16\xB0\xC9\x9A\xB3\x84\xB3\x2F\xB5\x10\x38\xB1\x23\xB2\x1E\xB1\xC3\x93\xB1\xD5\xB0\x11\xBF\xC0\x86\xB1\xE8\xAD\x27\xB1\xC2\xB5\xB1\x93\xB1\x1E\xB1\xC5\xAF\xB3\x7C\xB1\x3C\xB9\xCC\xA4\xB3\x57\xB1\x3D\xBC\xCB\xB7\xB3\x2E\xB0\x2C\xBA\xCF\x95\xB2\xFC\xB3\x25\xBE\xCF\xBE\xB1\x8D\xB3\x32\xBF\xC8\x8D\xB3\x83\xB3\x33\xB3\xCB\xAE", - "\xB3\x6C\xB0\x3C\xB3\xC3\xBF\xB3\xF3\xB0\x36\xB3\xC7\xBE\xAC\x85\xB0\xD0\xA5\xCA\x81\xB1\xA7\xB3\xE0\xAB\xC1\x99\xB2\x0D\xB6\x2E\xBC\xCA\x87\x96\x11\xB5\x47\xB3\xCD\xA1\xB4\x94\xAF\x1B\xB0\xC1\x8F\xB4\x28\xB5\x24\xBB\xCD\xB9\xB3\x77\xB0\xEF\x94\xCC\xA6\xB2\xC6\xB2\x48\xBB\xC8\x8C\xB4\xCA\xB2\x49\xBC\xCC\xB1\xB4\xE8\xB3\xCF\xA9\x5C\x8B\xB0\x16\xB6\x1B\xB6\xCD\x99\xB4\xE5\xB2\x40\xB7\xCE\xBD\xB2\xE9\xB0\x81\x8F\xD1\x94\xB3\x17\xB4\x4F\xB0\xD0\x8E\xB2\x37\xB3\x52\xB4\xD0\xAF\xB2\x05\x04\x13\xB3\xD4\xA0\xB3\xA0\xAC\x56\x42\xBA\x89\xB5\x72\xB2\x3D\xB4\xC7\x85\xB4\x59\xB6\x4D\xB4\xCB\x85\xB3\xB6\xB3\x31\xB2\xC6\x93\xB5\x0E\xB5\x55\xB0\xD1\xB2\xB4\x4D\xB4\x4D\xB7\x10\x1B\xB5\x09\xB5\x38\xBB\xD0\xA4\xB4\x3D\xB7\x2E\xB6\xD5\xA3\xB5\x58\xB5\xA8\xA6\xD6\x94\xB4\xB5\xB1\x51\xB7\xCB\x88\xB3\x52\xB4\x52\xB1\xD0\xA1\xB5\x03\xB4\x5F\xBF\xC9\x85\x04\x74\xB5\x45\xBD\xCF\x91\xB5\x78\xB4\x5B\xBE\xD3\xB0\xB4\x00\x02\x2B\xBB\xD8\xBE\xB5\x0F\x05\x63\xB1\xD8\x8F\xB6\x46\xB6\x3C\xB0\xC7\xA0\xB5\xD9\xB0\x53\xB2\xD1\x98\x96\x4F\xB4\x4B", - "\xB1\xBA\xAA\xB2\x93\xB6\x5B\xB0\xD4\xA2\xB6\x1D\xB6\x66\xB8\xD6\x82\xB6\x6A\xB6\x4B\xB4\xCF\x88\xB6\x7B\xB4\x47\xBA\xCE\x87\x88\xA5\xB5\x4E\xBD\xD2\x87\xB5\x9F\xB7\x61\xB1\xDA\x97\xB5\x97\xB6\x56\xB9\xDB\xA9\xB5\x3A\xB4\x2E\xB5\xD2\xBA\xB5\x6F\xB5\x50\xBD\xDA\x83\xB7\xB0\xB5\x71\xB4\xD8\x91\xB6\x86\xB4\x55\xB6\xCE\x89\xB7\xAC\xB7\x6D\xBC\xCE\xB3\xB5\xCC\xB4\x67\xB3\xD8\xAB\xB5\xD1\xB5\x5B\xB3\xDD\xAB\xB6\xC0\xB7\x4C\xB6\xD0\x8E\xB5\x37\xB4\x48\xBA\xDB\xA7\xB6\xB9\xB0\x72\xB0\xDE\x8A\xB6\xE2\xB5\x59\xB9\xD9\x99\xB7\x0A\xB4\x64\xB3\xCE\x9D\xB7\xA9\xB7\x77\xB5\xD9\x8E\xB3\x7F\xB7\x3E\xBE\xD8\xB1\xB7\x9D\xB4\x46\xBD\xDB\x92\xB7\x4A\xB4\x75\xB1\xDE\xB1\xB5\xA4\xB5\x79\xB0\xD5\xBD\xB7\x85\xB7\x7F\xBE\xDD\x81\xB8\xEB\xB6\x6D\xBC\xCD\x80\xB3\x53\x97\x7B\xB6\xE0\xA6\xB6\x5E\xB4\x6A\xBA\xDE\xB7\xB7\x29\xB7\x6D\xB1\xCD\xB9\xB7\x08\xB7\x7E\xB6\xD7\xB2\xB7\x5F\xB6\x6F\xBB\xD1\xA2\xB0\x72\xB5\x81\xB7\xD6\xB8\xB4\xC4\xB7\x6E\xBE\xD9\xAF\xB4\xAA\xB4\x86\xB0\xD7\xA3\xB6\x8C\xB4\x7C\xBF\xE1\x88\xB8\xD0\xB6\x82\xB5\xDF\x8C\xB8", - "\x2E\xBA\x72\xB6\xDD\x9C\xB8\xDF\xB1\x5D\xBD\xD5\x84\xAE\x21\xB8\x80\xB4\xDB\x82\xB8\xEC\xB4\x81\xBE\xDE\xA4\xB7\x27\xBA\x79\xB9\xE2\xA8\xB7\xC7\xB7\x49\xB9\xE3\x95\xB7\x0F\xB9\x8C\xB3\xE1\xA7\xB7\x15\xB9\x7A\xBE\xE4\x96\xB6\xED\xB4\x66\xB0\xCD\x91\xB8\x48\xB8\x60\xBF\xDA\x9A\xB7\xB1\xB4\x6F\xBC\xE2\xB6\xB7\x58\xBA\x91\xBA\xE5\x87\x04\x1B\xBA\x84\xB9\xE4\x87\xB8\xDB\xB6\x6C\xBA\xD1\xA2\xB5\x0E\xB9\x89\xB5\x10\x01\xB3\x31\xA2\x6B\xB8\xE2\x8D\xB7\x2A\xBA\x7F\xB3\xE6\xB8\xB8\x65\xB8\x8C\xBD\xC4\xB2\xB2\x26\xBA\x97\xB7\xE7\xA0\xB9\xCE\xB4\x77\xB6\xE3\x97\xB8\x7D\xB9\x47\xB7\xDD\x81\xBA\xFA\xB7\x66\xBC\xDF\xAD\xB9\x62\xBB\x6C\xBF\xDB\x85\xB9\x7E\xBB\xA2\xB2\xE5\xAB\xB9\x14\xB8\x90\xB6\xE1\x97\xB9\xF8\xB7\x6D\xB6\xE7\x8A\xB9\x78\xB8\x93\xB9\xD7\x9C\xBA\x19\xB9\x94\xB8\xDB\x93\xB9\x4B\xB9\x95\xBD\xE4\xBF\xB4\x4F\xBB\x80\xBE\xE7\x9F\xBA\x6C\xB9\x98\xBB\xE2\x92\xBA\x23\xB8\x3E\xB3\xDE\x98\xB7\xA8\xB9\xA8\xBA\xEA\xA3\xBA\xAC\xB9\xA2\xBE\xE9\xB2\xB8\x3F\xBB\x48\xB3\xDF\x87\xBA\xA4\xBB\x8B\xBA\xE8\x92\x04\x2B\x98\x51\xB4", - "\xE8\xB9\xB9\x09\xBB\x9E\xB3\xE4\x8D\xB8\x24\xB9\x93\x90\xEC\xA2\xB3\x41\xBB\x82\xBF\xEC\xAD\xBA\x94\xB8\xB2\xB3\xED\xB7\xB5\xC3\xBA\xB3\xB3\xE9\xB1\xB9\xB7\xBA\xB4\xB9\xEB\x8B\xBB\xA2\xBA\x64\xB8\xE8\x9D\xBA\xA6\xB9\xB2\xBC\xD5\x94\xBB\x9B\xB9\xAF\xB8\xEE\xB2\xB9\x7C\x9B\xB6\xB0\xE2\xAD\xBB\x94\xB6\xAF\xB9\xEE\xB2\xBB\x34\xB9\xB7\xB4\xEB\xB0\xB9\xD1\xB8\x9E\x98\xEF\x90\xBA\xB3\xBB\x9B\xB9\xD8\xA0\xBB\x47\xBA\x8A\x9F\xEF\xB2\xBA\x7A\xBB\xBE\xB3\xF0\xBD\xBB\x67\xBA\xB8\xB8\xE9\x94\xB9\x9A\xBA\x95\xBE\xEE\xA5\xBA\xF0\xBA\xBA\xBE\xE3\xAC\xBB\x12\xBD\xBD\xBF\xEE\xA1\xBB\xFE\xBB\xB8\xBF\xE8\x88\xBC\xCD\xBA\xC2\xB5\xDB\x8C\xBC\x4C\xB2\xC5\xBE\xE1\x81\xBB\x3B\xB5\x8D\xBE\xED\xB5\xBA\x64\xB5\xC3\xBD\xF1\x8F\xBC\xA9\xB9\xC4\xBB\xEA\x9A\xBC\x14\xBC\xC7\xB0\x00\x16\xBA\xF1\xBA\xC7\xB3\xE3\x80\xBC\x09\xBE\xC0\xB3\xF2\xB6\xBA\x05\xBE\xC3\xB2\xE8\xA0\xBA\xE4\xBB\xAE\xB6\xEE\x85\xBB\x3A\xBB\xBD\xBA\xF3\xA8\xBC\xC6\xB4\xAF\xB4\xF3\x86\xBB\x0A\x9B\xC1\xB5\xE8\xAE\xB9\xA0\xB4\xCB\xBD\xD7\xA6\xBC\x8E\xBB\xCE\xB0\xF2\xAA\xBC\x22", - "\xBC\x91\xB4\xF0\xAE\xBC\x7F\xBB\x43\x01\x83\x98\xBD\x5F\xBB\xC7\xB3\xF5\x91\xBA\x3E\xBE\xD7\xB4\xF2\xB1\xB2\x35\x5E\x42\x04\xF6\x83\xBA\x66\xBC\xB3\xBC\xF5\xA9\xBD\xD0\xB8\xD0\xB0\xF6\xAF\xBD\x44\xBD\xDC\xB5\xEE\xB4\xB7\xE7\xB9\xCD\xB1\xF4\xAF\xBC\x43\xBD\xAC\xB7\xF6\x81\xBC\x55\xBC\xBF\xB6\xF7\x8C\xB1\x38\xBC\xDE\xB2\xF8\xB2\xBD\xFA\xB8\xDD\xB8\xED\x9F\xBD\x25\xBE\xD4\xBC\xF8\x95\xBB\x37\xBB\xB5\xB6\xEF\x95\xBC\x92\xBF\xDE\xB4\xEC\x93\xBC\x50\xBE\xA9\xB4\xE7\x9A\xBB\x4B\xBC\xC6\xB3\xF3\xAD\xB8\x97\xBE\xCD\xB9\xE6\xAE\xBD\x99\xBE\xD1\xBC\xF7\x88\xBD\x50\xB8\xBC\xBF\xF9\x91\xBD\xA1\xBC\xB7\xB4\xF9\xBD\xBD\x9D\xBE\xEB\xB0\xE8\x80\xBE\x8D\xB9\xD9\xBA\xF5\x83\xBE\x3D\xBD\xE1\xBB\xF0\x87\xBE\x12\x05\xE2\xB9\xFA\xB2\xBC\x4E\xBC\xE9\xBB\xF1\xBF\xBD\x37\xBC\xE8\xB0\xF3\xBA\xBA\xC4\xBF\xD1\xBC\xF9\x89\xBD\x98\xBD\xEC\xB3\xEF\x99\xBC\xC6\xBE\xDF\xB7\xF7\x83\xBF\xC2\xBB\xEC\xBC\xFA\xAE\xBA\x1D\xB6\xE2\xB9\xE9\x99\xBF\xF4\xB9\xF5\xB5\xFB\xB6\xBC\xDE\xBC\xC4\xB0\xFE\x94\xBF\x64\xBB\xF1\xB7\xFD\x92\xBF\xF9\xBA\xF6\xBF\xFC", - "\xAD\xBE\x36\xBC\xCE\xB7\xA7\x86\x98\x07\x07\x03\xAA\xEC\xBA\xBD\xAA\xBF\xE6\xBF\xF4\x90\xBF\x06\x06\xFD\xBB\xEE\xB2\xBE\xE1\xBD\xFA\xB6\xFD\xBE\xBF\x17\xBC\x00\xC8\xFE\xBC\xB9\xEA\xBC\x13\xB4\x00\xE7\xBC\xA2\xBD\xF1\xB2\x00\xE3\xBF\xC8\xBF\x02\xC9\xF5\x8C\xBD\xCF\xB5\xE3\xBE\xFB\xBF\xBC\x2D\xBE\x02\xC8\xFD\xA9\xBC\x16\xC2\x88\xB6\xF8\x99\xC0\x12\x06\x04\xCA\xFB\x94\xC0\x86\xBB\xCA\xBF\x01\xFD\xB5\x22\xC0\xDC\xBB\xFB\x93\xBE\x01\xC0\x02\xC6\xFD\x9A\xC0\xEC\xBC\xCF\xB1\xF2\x8E\xBE\xA5\xBD\x04\xCB\x01\xCD\xBD\xCE\xBF\xFE\xB0\xFF\xB6\xC0\x31\xC3\xD6\xBD\x01\xC2\xB9\xDF\xBB\xDA\xBF\x10\x29\xC0\x79\xBF\x0A\xCA\xF9\xA6\xC0\xBF\xBC\x08\xC3\x04\xF7\xC0\x15\xC2\xFB\xBA\x03\xDC\xBF\xB7\xB4\x11\xCB\xF8\x87\xC1\x5D\xBD\xDD\xBA\x04\xF5\xB4\x4B\xC1\x0F\xCC\xFB\xB3\xC0\x17\xC2\xDA\xB0\xFC\x99\xC1\xCB\xBD\xD1\xBD\xFC\xAB\xBE\xEF\xBC\x14\xC6\xEA\x92\xC1\xDF\xBC\x07\xCE\x04\xE2\xBF\xFC\xBD\x41\x08\x06\xE6\xBF\x6A\xC1\x0B\xC6\xF9\xAA\xBF\x6F\xC1\xCC\xB7\xFE\xA3\xBE\x0F\xC1\x1B\xC0\xF6\xAF\xBE\x0A\x05\x1D\xCC\xFC\xB7\xC1\x0E\xC2", - "\x0B\xC0\x01\xFB\xC1\xB7\xBC\x76\x8C\x04\xE5\xC0\x55\xC3\xE3\xB2\x04\xFD\xC1\x87\xC0\xD5\xBE\x01\xC9\xC1\x7D\xB4\x0C\xC1\x06\xF8\xBF\x63\xC2\xFE\xBC\x06\xFB\xC0\x60\xBC\xCE\xBE\x07\xE2\xC1\x80\xC1\x0E\xC7\x09\xE6\xC1\xF0\xBB\x26\xC4\x09\xDD\xC2\x64\xC3\x13\xC9\xED\x91\xC1\x8D\xC0\xDA\xBD\x05\xD6\xC1\x91\xC0\xDB\xBA\x10\x31\xA0\xA2\xC2\x11\xC9\xFF\x88\xC1\x18\xC1\x2B\xCF\x10\x27\xBE\xF5\xBD\x2A\xC4\xF8\x8F\xC2\xB5\xC1\x70\xBE\x0A\xFE\xB0\x21\xC2\x2E\xCD\xFB\xBC\xC2\x5E\xC3\x15\xC8\xE6\x85\xC2\xB1\xC0\x09\xCE\x08\xC0\xC1\x56\xBE\x2F\xCF\x10\x1A\xC2\xC2\xC0\x17\xC4\x0C\xEC\xC2\xCE\xC0\x16\xCC\x08\xDA\xC1\x2C\xC3\x01\xC3\x07\xEF\xC0\xC1\xC0\x36\xC4\x05\xF4\xC0\x09\xC1\x37\xC3\x09\xF2\xC2\x95\xC0\x2D\xC5\x0C\xF6\xC2\xD7\xC3\x38\xCA\x0C\xEA\xC2\xD3\xC2\x22\xCF\x05\xE9\xC3\x81\xBD\x1A\xC8\x03\xE5\xC2\x9F\xC3\x29\xC7\x06\xD1\xC3\x73\xBF\x2A\xCE\x0E\xC6\xC3\x06\x04\xCE\xB9\xDA\x3F\xC3\x6B\x84\xFE\x76\xE8\x01\xC4\x2F\x9D\x41\x00\x10\xCF\x04\x07\xC6\x40\xC6\x10\xC4\xC4\x03\xC7\x43\x09\x9B\x71\xC3\x70\xC3\x3C\xC6\x09\xF9", - "\xC1\x98\xC3\x43\xC9\xFB\xAA\xC0\xEB\xC3\x2E\xCC\x0C\xE7\xC0\x97\xB6\x45\xCD\xE1\x93\xC0\x0D\xC2\x27\xC4\x11\xE0\xC2\x36\xBE\x47\xCD\xE3\x8C\xC0\x06\xC0\x1E\xC2\x08\xFA\xC1\x4C\xB2\x49\xC7\xFF\xA4\xC3\xA4\xC3\x44\xCB\x12\xD8\xC2\x2D\xC4\x3E\xCF\x03\xD6\xBB\x41\xC3\x3B\xC7\x10\x2E\xC4\xFF\xBF\xF4\xBA\x12\xDB\xC3\x83\xC0\x4F\xC5\x00\xFE\xC4\x81\xC0\x50\xCC\x12\xD2\x04\x42\xC4\x4A\xC4\x14\xE2\xC4\x33\xC4\x49\xC8\xFC\x89\xC5\x20\xC5\x4A\xC5\x14\xF9\xC4\xFC\xC1\x41\x00\x15\xE3\xC0\x21\xC4\x3D\xC3\x12\xF6\xC3\xF0\xBB\x55\xC8\x11\xD9\xC5\x32\xC6\x51\xC4\x13\xC8\xC5\x36\xC7\x1A\xCB\x15\xD0\xBE\x64\xC6\x37\xC3\x0B\xC9\xC2\x35\xC1\x26\xC9\x16\xEA\xC3\x60\xC6\x39\xC4\x0D\xD9\xB9\x35\xC6\x5A\xC5\x0E\xEC\xC5\xE1\xC2\x43\xC5\x16\xF2\xC1\x54\xC5\x5F\xBE\x15\xC5\xC1\x19\xC7\x30\xCB\x11\xD0\xC2\x1D\xC7\x5E\xCA\x0D\xFD\xC5\xD5\xC3\x31\xC2\xF6\xAF\xC5\x10\xC6\x1D\xC1\x07\xC7\xC6\xCD\xC0\x5D\xCF\x0B\xCF\xB1\x7A\xC6\x5D\xC1\x13\xF2\xC5\xFB\xC0\x3A\xCB\x13\xC6\xC6\x3F\xC4\x62\xC2\x19\xD5\xC6\x70\xC6\x54\xCC\x14\xE2\xC5\x4E\xC6\x5B", - "\xC0\x1A\xCD\xC6\x7F\xC3\x63\xCD\x19\xD1\xC6\x66\xB9\x5D\xC1\x1A\xCB\xC5\x5A\xC5\x53\xCC\x15\xE5\xC4\x9C\xC7\x54\xCC\x1A\xFE\xB9\x7C\xC3\x66\xC6\x19\xEA\xC6\xB6\xC4\x47\xCF\x19\xDB\xB9\x6D\xBE\x6E\xCF\x1A\xED\xBF\x7C\xC7\x6D\xCD\xD1\xB9\xC6\xB8\x65\x6D\xC3\x1A\xDE\xC6\xAD\xC7\x64\xCA\x7F\x67\xC6\x17\xC4\x60\xC1\x17\xF8\xC5\xDC\xC3\x33\xCC\x18\xD1\xC7\x53\xC3\x5A\xC0\x0E\xD5\xC7\xD6\xC2\x70\xC8\x1A\xDC\xC2\xBC\xC7\x72\xC6\x1C\xF7\xB6\x7F\xC5\x76\xC7\x17\xDB\xC7\x83\xC2\x6B\xCF\x1D\xE3\xC2\xE1\xC5\x6C\xC4\x1A\xF3\xC6\x4F\xC6\x72\xCE\x1E\xCC\xC7\x7E\xB9\x79\xC2\x0F\xCD\xC1\xC5\xC6\x6F\xCD\x1C\xD0\xC7\x1F\xC4\x56\xC2\x1A\xF3\xC7\xE3\xC6\xA9\xB8\xF3\xB8\xBC\xC8\xC7\x9C\xB5\x08\xC4\xC8\x5C\xBA\x62\xCD\xE2\x77\xC2\x09\xC8\x84\xB1\x1C\xFD\xC3\xC1\xBD\x84\xCB\xE7\x43\xC7\x32\xC1\x3E\xCD\x0E\xED\xC5\xAF\x53\x4B\xC1\x18\xD2\xC3\x83\xC5\x2F\xC9\xE5\x99\xC8\x3D\xC4\x71\xC0\x19\xFA\xC7\x7E\xB8\x88\xC3\x14\xE2\xC8\xAB\xC4\x89\xCD\xD1\xA6\xC8\x4A\xC4\x8A\xCD\x1B\xC4\xC6\xBF\xC7\x41\x0C\x22\xD1\xC5\xB0\xC5\x58\xC4\x1F\xEB\xC8", - "\xF2\xC6\x8D\xC1\x20\xF2\xC8\x39\xC8\x66\xCD\x16\xCC\xB1\x33\xCA\x7F\xC5\x23\xFE\xC8\x79\xC5\x79\x7D\x23\xD4\xC7\xE9\xC5\x8A\x78\x1D\xF7\xC7\x88\xC0\x7A\xC7\x14\xD3\xC8\xEB\xC4\x4C\xCD\x1E\xFA\xC8\x2A\xCB\x6D\xB1\x24\xDF\xC5\xFF\xC4\x95\xC0\x23\xFB\xC7\x46\xCB\x6E\xC2\x11\xC4\xC9\xDC\xC5\x37\xB0\x25\xCB\xC9\x11\xC4\x7E\xC3\x22\xDB\xC9\x25\xCB\x91\xCE\x24\xE3\xC5\x63\xC9\x7F\xC8\x25\xC3\xC9\x48\xCA\x1E\xC7\x25\xD2\xC7\x59\xC8\x98\xC3\x08\xF3\xC9\xE6\xC7\x65\xC1\x27\xEC\xC9\xC0\xC7\x2B\xCA\x24\xEE\xC9\x74\xC8\x9C\xCB\x26\xE5\xC6\xA1\xB1\x21\xC8\x27\xCC\xC9\xCB\xC0\x4E\xCB\x23\xF6\xBC\x87\xC9\x99\xCD\x24\xFA\xC3\x3F\xCB\x9F\xC7\x12\xF4\xC8\x2E\xCA\x78\xC5\x25\xC2\xC8\x92\xCA\x86\xC3\x1D\xC3\xCA\xF0\xC4\xD8\xBD\x28\xCE\xC6\x5F\xCB\x9E\xC4\x28\xD9\xCA\x21\xC9\x85\xC7\x13\xD5\xBE\x37\xCA\x86\xBD\x20\xF8\x56\x5E\xCA\x99\xC9\x22\xE8\xC9\xC7\xC6\xA1\xCA\x26\xD0\xCA\x45\xCA\x82\xC0\x0C\xED\xC9\x93\xCA\x90\xC5\x29\xC0\xC8\x97\xCA\xED\xBF\x20\xEC\xCA\x14\xCA\x0F\xC6\x16\xF2\xC6\x68\xC6\x75\xC8\x2B\xDA\xCA\x75\xCA\xA8\xCD", - "\x29\xC8\xBE\xA4\xCB\x89\xC6\x2A\xC3\xCB\xEF\xC5\xB1\xCD\x25\xC1\xCB\x5B\xC2\x85\xCD\x21\xE7\xC3\x89\xC5\x3E\x53\x2B\xD7\xC8\xB5\xCA\xB6\xCD\x2A\xCF\xCA\xDC\xC9\x98\xCE\x2D\xD4\xCB\xD9\xC3\xAB\xCE\x21\xDC\xC9\x3C\xCB\xB7\xC9\x28\xE8\xCA\x8B\xC8\xF2\xB8\xF3\xAC\x45\xC8\xCA\xA0\xC4\x2B\xD6\xBF\xF0\xC9\xA9\xC2\x2C\xF9\xC7\xB0\xCB\xDB\x91\x2F\xFB\xCA\x5A\xCB\xB9\xCE\xE7\xB5\xCB\xCE\xCB\xBD\xC7\x26\xFE\xCB\x1D\xB4\xC0\xCD\x22\xCF\xCB\xF8\xC8\xC1\xC7\xDB\x86\xCC\x94\xC8\xC2\xC3\x30\xD8\xCB\x31\xC8\x8F\x6A\x2E\xEC\xC3\xD7\xCB\x5C\xC6\xE6\x8C\xCC\xBA\xCA\xC3\xC6\x2E\xD0\xCC\xE8\xCA\xC4\xC4\x2E\xDF\xC3\xF3\xC9\x92\xCA\x2F\xF6\xCB\xD5\xCB\xA9\xC4\xFB\x8F\xC9\x0A\x04\xC6\xCF\x26\xFC\xCB\x76\xC8\xCA\xCB\xEE\x13\xCC\x1A\xC6\xA2\xCD\x2B\xF6\xBC\x2A\xCD\xA0\xCC\x32\xCA\xCB\xD2\xCB\xCB\xCF\x31\xDA\xC7\x21\xCE\xCB\xC0\x21\xE3\xCC\x01\xCD\xC9\xC0\x2D\xE9\xCA\xA6\xB9\xCD\xC9\x27\xD3\xC9\x2D\xCC\x9F\xCA\x33\xD1\xC9\x1B\xCA\xB5\xC2\x33\xF9\xCB\x29\xCF\xB6\xC5\x31\xD9\xC6\x97\xB6\xD1\xC8\x28\xD4\xCC\x4F\xCE\xC2\xCE\xF9\xAB\xCA\x38", - "\x80\xCC\xC2\x18\xD9\xCD\x1C\xCC\x6E\xC5\x08\xD6\xCD\x8E\xCB\xBA\xC7\x32\xCA\xCD\x1E\xCC\xD3\xCB\x29\xFD\xCC\x68\xCD\xAA\x5A\x36\xC9\xCB\x9C\xC9\xCE\xCF\x33\xD1\xCD\x5E\xCC\x87\xC0\x36\xD6\xCC\xFF\xCA\xD4\xC7\x37\xD4\xCD\x11\xCE\xDB\xC4\x26\xE0\xCA\xAE\xCB\x8B\xCA\x35\xFE\xCA\x7E\xC8\xD0\xC7\x30\xC2\xCC\x1B\xCC\xDE\xC1\x2B\xFF\xCA\x5D\xCF\xCE\xC7\x1E\xEC\xCD\xA3\xC8\x83\xCB\x18\xC6\xCE\x0D\xCC\xE2\xC2\x38\xE1\xCD\x8B\xCF\x82\xC4\x37\xCE\xCE\x7A\xC9\xDC\xCB\x08\xE2\xC9\x9B\xCF\xDB\xC2\x2F\xE1\xCB\x22\xCD\x77\xC9\x36\xFF\xCD\xA9\xC5\xA8\xCE\x39\xFA\xC4\xA7\xCC\xA0\xC7\x34\xEA\xCE\x90\xCF\xB2\xC1\x45\xA2\xCE\x37\xCF\xEA\xC5\x15\xCD\xCE\xB4\xCE\xC6\xC7\x39\xCA\xCE\x0B\xCE\xDE\xCC\x2E\xF3\xCC\xC8\xBC\xD9\xC0\x38\xE0\xCB\x53\xCD\xA4\xC6\x2C\xF6\x54\xBE\xCF\xD9\xC5\x1A\xED\x89\xB9\xCB\xCA\xCA\x3B\xD6\xCA\x50\xCD\x94\x59\x3C\xDB\xBF\xB2\xCF\x43\x0C\x3C\xFB\xCB\xCF\xCC\xAF\xC1\x3D\xF6\xBC\xD7\xCC\xC9\xC5\x2E\xFB\xCE\x7C\xCD\xC7\xC5\x10\x1D\xCF\x41\xCF\xF7\xC0\x3D\xC3\xCE\xDC\xCF\xF4\xC5\x06\xDD\xCA\xE4\xCF\xE1\xC2\x34", - "\xC9\xCC\x98\xCF\x6D\xBD\x3E\xD5\xCE\xEF\xCF\xC3\xCC\x3B\xE6\xBA\xF3\xCD\xC6\xC6\x39\xE7\xCF\xF1\xCC\xFE\xCA\x3E\xE6\xC2\x72\xCF\xF8\xCF\x3F\xF5\xC3\x01\xD0\x00\x09\x3F\xCE\xCF\xFB\xCE\xF6\xC8\x3E\xC8\xBF\x07\xD2\xCD\xC9\x3D\xFD\xCB\xFD\xCC\xBC\xB8\xF3\x8D\xD0\xAF\xCD\xE0\xCC\x3F\xF7\xCF\xF0\xB8\x05\xD7\x35\xF1\xCC\xBF\xCF\xF6\xCC\x40\xC3\xD0\x67\xC4\xC3\xBA\x41\xE5\xCD\x58\xCD\x07\xDB\x40\xC6\xD0\x20\xD0\xB1\xCF\x39\xCE\xC8\x85\xCC\xF2\xC5\x37\xCE\xCD\x26\xD1\x04\xD6\xFA\x85\xC2\x23\xD3\xF0\xC6\x36\xD4\xCF\x05\xD1\x0D\xD9\x3A\xD6\xD0\x0A\xD2\x0C\xDF\x41\xEF\xD0\x26\xCC\x0E\xDB\x42\xEB\xB3\x12\x06\x0E\xD0\x1E\xF0\xCE\xA4\xCE\xCF\xC2\x40\xC0\xD1\x43\xCD\xBB\xC0\xF6\x86\xD1\xEC\xC4\x12\xD5\x3C\xDD\xCB\x06\xCB\xE4\xCE\x42\xDC\xCE\x48\xCC\xCE\xC3\x44\xE1\xBD\x9A\xCE\xF4\xCC\x44\xF0\xCF\x18\xD3\x0C\xD6\x45\xDE\xD1\x58\xD2\x14\xDB\x37\xC6\xCF\x7D\xCA\x05\x86\x3D\xE9\xD0\xD1\xCB\x16\xD3\x41\xEC\xD1\x44\xCE\x04\xD5\x44\xF0\xD1\x4E\xD0\x13\xB0\x45\xD2\xC9\x66\xD1\x0C\xD1\x46\xFF\xD0\x65\xD0\x0F\xD0\x41\xFB\xD1\x4F\xD0", - "\x1D\xD0\x3C\xC1\xD2\x5F\xD2\xFD\xC1\x3E\xFE\xB9\x77\xD1\xD3\xC1\x44\xEB\xCF\x05\xD0\xCE\xB3\xC4\x18\xCF\x09\xD3\x1F\xD7\x48\xDE\x91\xA8\xCF\x11\xDE\x47\xC9\xCD\xA5\xC7\x23\xDE\x3D\xE0\xCC\x49\xD1\xDB\xC6\x04\xB9\xCE\x91\xD0\x26\xD5\x3D\xE6\x13\x82\xD2\x07\xD0\xF6\x9A\xD2\xE5\xCC\x27\xD3\x45\xE2\xCB\x05\x04\x2A\xDE\x3E\xE6\xCF\x3D\xD0\x20\xDE\x4A\xF4\xCF\xB0\xD2\x24\xD8\x46\xD3\x24\xA5\xD3\x09\xDC\xC4\xB3\xD2\xFA\xCD\xFD\xC9\x38\xD3\xD2\xB7\xB4\x2F\xD8\x40\xFE\xD2\xE0\xCF\x2D\xD6\xDA\x7D\xD1\xC4\xCF\x19\xD4\x45\xDF\xD2\x95\xD1\x14\xD7\x49\xDA\xD1\xAC\xCD\x2B\xD9\x4B\xFE\xD0\xA6\xC4\x29\xD5\x48\xFF\xD2\xC6\xD2\x34\xD7\x4D\xC5\xD3\xCB\xD2\x30\xDE\x40\xE1\xD2\xD0\xD1\xCB\xBE\x4D\xD5\xD0\xC9\xD2\x1E\xD0\x4C\xD6\xD3\xC8\xD3\x0D\xDC\x48\xDB\xD1\x05\xC8\x33\xDE\x3A\xDB\xD0\x5F\xCE\x39\xD9\x4D\xDC\xD1\x6A\xD0\x3A\xD0\x4A\xC4\xD3\x17\xD3\x39\xD0\xEF\xA3\xD3\xF0\xD2\xDD\xC2\x4F\xDD\xD3\xD3\xD0\x20\xDC\x2C\xDB\x83\xF7\xD1\x2D\xD2\x4A\xC5\xD0\xFC\xD0\x09\xDC\x41\xCA\xCF\xA3\xD0\x2E\xDB\x4D\xF9\xD3\xF3\xD1\x3B\xD9\x50\xF6", - "\xD0\x25\xD0\x43\xD5\x40\xF8\xC2\xC7\xD1\x41\xDA\x4A\xCA\xD3\xAC\xD0\x3D\xD6\x10\x31\xA0\x13\xD7\x0E\xD5\x4E\xD6\xD4\xEC\xD1\x21\xC1\x52\xD6\xD2\x23\xD6\x10\xD1\x4D\xC9\xBF\x04\xD5\x33\xD8\x47\xCF\xD3\xB6\xCE\x66\xC3\x37\xCE\xD4\xE9\xD1\x45\xDA\x52\xF7\xCE\x27\xD6\x33\xD9\x52\xEB\xD3\x2B\xD5\x4E\xDF\x52\xFB\xD4\x00\xD3\x16\xDE\x53\xCA\xD2\x4D\xD3\x20\xDB\x4B\xC1\xD4\xFA\xD2\xCD\xB3\x54\xEB\xCD\x9D\xD1\xE4\xC6\x3A\xC5\x04\x29\x88\x24\xD8\x4F\xF1\xD2\x49\xD4\x54\xD8\x54\xED\xC5\x51\xD7\x26\xDC\x33\xCD\xD5\x0D\xD6\x97\x87\x55\xCB\xD3\x59\xD5\x2A\xDB\x55\xEB\xD2\xA5\xCF\x41\x01\x56\xEF\xD2\x1B\xD7\x3F\xDD\x51\xE7\xD5\xB4\xD1\x5A\xD4\x52\xF6\xBD\x6C\xD5\x2F\xD6\x50\xE1\xD3\x32\xD6\x55\xDF\x50\xD4\xD5\xF3\xD1\x5C\xD3\x4C\xF3\xD5\x31\xD5\xB6\xC6\x57\xF5\xD4\x0B\xD7\x4D\xD5\x57\xC0\x00\x7A\xD7\x37\xD3\x55\xF6\xD2\x60\xD7\x57\xDB\x56\xCA\xD6\x65\xD7\x4C\xDE\x55\xF7\xD5\x88\xD7\x62\xD0\x59\xC7\xD4\x5B\xD1\x61\xD4\x4E\xEA\xD3\x41\xD4\x5C\xDC\x58\xFA\xC1\x96\xD5\x3F\xD0\x43\xEF\xD5\xB7\xCD\x3B\xDD\x59\xCA\xD4\xF1\xD0\x68", - "\xD3\x58\xD8\xD4\x7F\xD6\x46\xD3\x56\xDC\xD4\x8D\xD5\x6A\xDE\x52\xC4\xD5\x60\xD1\x55\xD0\xF6\xA3\xD6\x14\xD5\x60\xDC\x53\xF7\xCE\x38\xBC\x6D\xD2\x52\xD8\xD6\x04\xD1\x65\xDB\x59\xDE\xD2\xBA\xD4\x4A\xDC\x5B\xE1\xD0\x2B\xD6\x68\xDF\x5B\xCE\xD5\xB6\xC8\x65\xCC\x4F\x87\xD7\x5D\xD5\x15\xDD\x42\xE6\xD5\xCC\xD7\x45\xD5\x08\xC1\xD7\x3A\xD7\x70\xDA\x42\xEB\xD4\xB9\xD5\x74\xDE\x46\xDB\x89\x93\xD4\x5D\xDE\x57\xC4\xD6\xDA\xD7\x4A\xD4\x5D\xFF\xD4\xD6\xD5\x1B\xD2\x5E\xE1\xD7\xB7\xCF\x78\xD0\x5B\xC6\xD2\x79\xD4\x7A\xD3\x58\xF8\xBC\xE0\x1D\xE5\x10\x7A\x92\xD5\x7C\xD5\xEC\xCF\xF5\xB3\xD7\x5A\xD7\xE3\xCC\x55\xF7\xD7\xEE\xD7\x77\xD8\x5F\xE2\xD5\xFA\xD4\x59\xDA\x44\xC0\x00\xFF\xD4\x5A\xDB\x5A\xEA\xD5\xAD\xD4\x81\xDD\x5F\xFD\xCD\x0A\xD9\x77\xDD\x57\xD9\xB9\x05\xD9\x5B\xD7\x60\xE6\xD6\xFE\xD7\x82\xD2\x3E\xCD\xD8\x80\xD5\x69\xD2\x58\xD5\xD8\x0E\xDA\x7D\xDB\x45\xD1\xD8\x72\xD6\x5B\xDB\x61\xCC\xD8\x20\xDB\x5E\xD2\x62\xF7\xD6\x83\xD5\x89\xD6\x58\xF5\xD7\xFB\xD7\x76\xDF\x10\x2A\xD8\x97\xD6\x4D\xD8\x62\xDC\xD8\x19\xDA\x3F\xD4\x61\xE4\xD8", - "\x16\xDB\xCF\xA0\x63\xDE\xD6\x8B\xD1\x66\xDD\xF2\xBB\xD8\xA4\xD6\x8D\xD3\x62\xD7\xD8\xED\xD0\x90\xD5\x5B\xDA\xD8\x33\xD8\x83\xD8\x5A\xD8\xD8\xAA\xD5\x80\xDC\x5A\xC3\xD8\x46\xDB\x6E\xD2\x63\xFE\xD8\x29\xD9\x8E\xD7\xEC\xAF\xD8\x56\xDB\x6D\xB1\x65\xC2\xD7\x53\xD9\x6F\xDB\x52\xDB\xD9\xD5\xD5\x97\xD4\x5C\xE1\xD6\x5C\xCC\x98\xD4\x5E\xE2\xD9\xD7\xD4\x99\xDC\x38\xE6\xD9\xEB\xD4\x36\xDB\x4C\xC5\xD9\x59\xDB\xD6\xCB\x66\xF1\xD9\x72\xD0\x96\xDD\x61\xED\xD8\xD8\xD6\x44\x0C\x66\xCC\xD5\x02\xDA\x27\xDB\x67\xF0\xCD\x1E\xDB\x97\xD4\x67\xF6\xBC\x7F\xDB\xE8\xCD\x67\xC8\xD7\x06\x05\xA1\xD5\x3B\xC1\xDA\xB7\xCE\xA2\xDF\x40\xD4\xD6\x79\xDB\x43\x03\x4F\x86\x04\x93\xD9\x41\x05\x69\xC0\x00\x97\xD9\xA6\xD2\x4F\x9B\xDA\x92\xD8\xA7\xDA\x10\x1A\xDA\x9D\xD9\xA8\xDF\x69\xDE\xDA\x07\x04\x9A\xA6\x10\x26\xDA\x05\x04\xAA\xD0\x00\x2A\xDA\xAC\xDB\x97\xAE\x6A\xCF\x04\xAD\xD8\xAC\xDF\x6A\xCA\x04\xB1\xD8\xAD\xD3\x6B\xC7\x04\x80\xA5\xF3\xCB\x62\xE7\xD8\x54\xDB\x65\xB9\x6B\xF4\xD7\xBC\xDA\x97\xDD\xF2\xBF\xDA\xF9\xD5\xE7\xCC\x68\xC3\xD6\xC4\xD8\x80\xD6", - "\x6C\xF8\xD9\xB7\xCD\xB2\xD6\x60\xCE\xD9\x08\xDB\x80\xDE\x6C\xD2\xD8\xD0\xDB\x8D\xD7\x61\xD3\xDB\x21\xDB\x84\xD3\x64\xFF\xAC\xD8\xDA\x89\xDA\x6D\xC9\xD9\xD7\xDB\xA0\xD8\xFC\x9D\xDB\xBB\xDB\xB7\xDD\x6B\xCC\xD8\xE4\xD9\x8C\xD6\x5B\xE7\xDB\xE1\xDB\x9D\xD7\x68\xCD\xD7\x00\x01\xBA\xDC\x63\xC5\xD5\xA6\xD0\x13\xB2\x6F\xC1\xD9\x9F\xD7\xB6\xD7\x65\xCA\x04\xF7\xDB\x91\xD2\x64\xE0\xDB\x7E\xB9\xBF\xD2\x65\xEB\xDB\xC2\xD8\xB2\xD2\x6E\xF1\xDB\x07\xDE\xC0\xDC\x65\xC4\xDC\x63\xDB\x69\xDC\x35\xCA\xDC\x61\xD8\xC3\xD9\x66\xCE\xDC\x8C\xCC\xC4\xD7\x66\xD2\xDC\xE6\xD5\xB3\xD7\x70\xF6\xDB\x1B\xDE\x84\xCC\x6F\xDD\xDC\x82\xA6\xBB\xDF\x64\xDE\xD2\x16\xDD\x9B\xDC\x4D\xDD\xD4\xED\xD1\xC9\xDC\x67\xE3\xDC\x88\xDA\x73\xD5\x4F\xF8\xDA\x20\xDD\x1A\xDF\x51\xC0\x61\x35\xD9\xBE\xD0\x70\xD9\xCE\x2F\xDE\x41\x0A\x72\xC0\xDA\xCC\xDB\x7B\xD4\x73\xCD\xD9\xCB\xDB\xBB\xDD\x48\xFF\xDC\xAF\xD7\xCA\xD1\x6D\xE4\xDC\x31\xDC\xCC\xD2\x72\xC7\xDD\x2D\xDC\xC2\xDB\x74\xD6\xDB\x01\xDD\xD2\xDA\x73\xD2\xDD\x44\xD3\x43\x04\xAA\xB5\xDC\x3D\xD9\xC1\xD7\xD9\x97\xDD\x40", - "\xDD\x16\xDF\x60\xE6\xB9\x5C\xDD\xD1\xDC\x73\xC2\xDD\x5B\xD1\xD8\xDF\x4E\xF8\xDB\x59\xDD\xC3\xDF\x5D\xE6\xDD\xBA\xDA\xBA\xD8\x64\xEC\xDB\x7E\xB8\xDB\xD0\x6C\xE6\xDB\x5A\xDC\x83\xD2\x77\xC5\xDB\x5E\xDF\xB1\xDB\x75\xD4\xDD\x00\x03\xDD\xDA\x6C\xF9\xDD\x3D\xDF\xDA\xDC\x77\xFE\xDD\xCF\xD9\xD0\xDC\x72\xF0\xDB\x84\xDC\xB5\xD6\x78\xCC\xDD\x88\xDF\xE0\xDC\x77\xF8\xBC\x89\xDD\xB6\xD5\x6D\xFA\xDB\xB7\xB5\xE4\xDE\x6D\xD3\xDE\x37\xDD\xE5\xD7\x70\xD6\xDE\xE5\xD8\xE6\xD0\x77\xD2\x04\x9C\xDE\xDB\xDF\x6F\xDF\xDE\xAA\xCB\x18\xD6\x10\x21\xDE\xF3\xD9\x6C\xD1\x51\xC5\xC2\xA8\xDC\xDA\xD4\x6F\xFA\xD2\xA0\xDE\xE3\xDF\x74\xD4\xDE\x98\xCA\xD5\xD2\x7B\xD8\xDD\xAF\xDC\x35\xDC\xC4\xAD\xDE\xFE\xDA\xCD\xD4\x7A\xF2\xD9\xCF\xD7\xE9\xDC\x77\xCB\xD9\xBC\xDF\xC0\xDF\x76\xF5\xDD\x44\xD8\xD7\xC5\x7C\xCB\xDC\xC7\xDE\xDA\xDA\x64\xEC\xDE\x8F\xDD\xEC\xD3\x7B\xD9\xDE\xB5\xDE\x42\x0B\x7C\xD1\xDC\xCD\xDF\xC4\xD2\x78\xD3\xDF\xBF\xDC\xBC\xB7\x7D\xD7\xDC\xD9\xDD\xC6\xD3\x58\xDF\xDF\x26\xDC\x44\xDB\x4C\xE4\xDF\x46\xDC\xD4\xDD\xD1\xA8\xDF\x63\xDF\xE1\xD3\x74", - "\xF2\x7E\x07\x13\xD4\x87\x10\x2A\xA9\x7A\x92\x44\x32\x11\x34\xDF\x73\x6B\x44\x38\x7F\xC7\x04\x47\x94\xA4\xA6\x45\x86\x04\xFB\xDE\x41\x0D\x7F\xF2\xDF\x00\xE0\xC9\x93\xCA\x84\xE0\x05\x05\x00\xE5\x10\x37\x39\xCB\x32\xFE\xD2\x11\x00\xAA\xDB\x93\xFC\xD2\x11\x05\xAA\x75\x9E\x42\x0A\x80\xDE\xA5\x11\xE1\x01\xEF\x10\x02\xA2\x19\xE1\x02\xEB\x85\xB0\xDF\x12\xE3\x43\x06\x66\x8E\xE0\x0F\x07\x39\xA6\x7F\xCF\x04\x17\xE0\x1E\xAF\x81\xA4\xE0\x0A\x05\x25\x3C\x82\xDC\x99\xB7\xC9\x05\xE1\x82\xF7\x6D\x39\xDD\x41\x0F\x82\xD0\x3B\x20\xE2\x06\xEA\x10\x2A\xE0\x08\xE0\x00\x07\x81\xF7\x39\x31\xA3\x0D\xEB\x80\xC5\xC2\x42\xE0\x00\x0C\x83\xF9\xE0\x1E\xE3\x03\x58\x84\xFE\xE0\x12\x07\x76\xA3\x8E\x5D\x9C\xAC\x58\x0A\xEC\x26\x68\x30\x17\xE0\x9A\x24\x85\xE0\xA5\x0A\x06\xFF\xD2\x2E\x52\xE1\x9D\x9E\x44\x0A\x85\xC2\x74\x5C\xE0\x0D\xE3\x73\xCF\xE1\x16\xE2\x01\xE6\x8B\x5E\x3F\x65\xE3\x43\x00\x81\xD7\xE1\x0F\x04\x05\xE1\x85\xE9\xE1\x73\x68\x1B\xEA\x10\x1C\xE0\x72\xE3\x41\x04\x87\xF7\xDF\x12\x06\x99\x95\x87\xC6\x04\x26\xE0\x18\xE0\x87\xF9\x98\x12\x07", - "\x07\xAB\x87\xEB\x67\x68\xE3\x0C\xE0\x83\xE3\xE1\x85\xE2\x0E\xE7\x88\xCF\xC7\x89\xE1\x12\xE0\x81\x4D\xE2\x4C\xE3\x43\x07\x84\xD0\xE2\x3F\xE0\xD7\xC3\x88\xC0\x00\x0C\xE3\x14\x9F\x87\xC6\x04\x93\xE3\x1B\xE6\x88\xD9\x70\x94\xE1\x13\xE2\x11\x2B\xA7\x0F\x04\x29\xED\x2E\xB8\xDE\xAA\xDE\xFA\xB7\xE4\x33\xDD\x9E\xDC\xF2\xDF\xB3\xAB\xE2\x78\xDD\x1E\xDA\x7E\xF7\xB6\xB0\xE3\xDF\xD2\x8B\xF4\xDE\xF0\xB9\x2D\xE5\x78\xC0\xDE\x64\xDF\x4A\xDA\x8B\xCA\xDE\xBC\xE2\xFB\xDB\x45\xFF\xE2\x92\xDF\xE2\xD3\x8B\xE7\xE2\x5D\xDF\x2D\xE4\x7D\xF9\xE2\x7C\xDC\x31\xE7\x79\xC6\xE3\xB8\xE2\xCD\xBE\x8C\xDD\xDE\xD0\xE3\x32\xE2\x8D\xCD\xE3\xD8\xE0\xF7\xDE\x8A\xFB\xDB\x5B\x32\x36\xEE\x7C\xD7\xD8\xD3\xE2\xE8\xDE\x7B\xDB\xE3\xB4\xE3\xC1\xD1\x8E\xE9\xDE\xEC\xD6\x2A\xE3\x7C\xDC\xCD\xE7\xE2\xEB\xD9\x8A\xE8\xDC\x85\xC1\x3B\xED\x7B\xE9\xDD\xDA\xDC\x83\xD2\x8F\xC6\xDF\xA3\xDC\x39\xE6\xEA\xB7\xE3\xCC\xDD\x3E\xEF\x8D\xD5\xBA\x40\x85\x32\xE0\x53\xFA\xDD\xF6\xE1\x36\xE8\x8A\xE9\xE3\xF0\xE2\xE9\xDC\x25\x5E\xE3\xF5\xE1\xF2\xDC\x38\xFC\xE3\xD8\xDE\x3F\xED\x90\xE2", - "\xCD\x0A\xE7\x71\x77\x90\xEE\xD9\x09\xE5\x17\xD3\x86\x42\xE4\x40\xD6\x3E\xE5\x67\xC8\xE3\x62\xDE\xA1\xD2\x8C\xD1\xDA\x20\xE7\xD9\xD3\x8F\xF9\xDE\x02\xD5\x40\xE1\x92\xCB\xDA\x81\xDD\x41\xEC\x90\xE2\xDF\xDF\xD4\x44\xE0\x7E\xD2\xE4\x30\xE6\x4B\xE7\x91\xE7\xDC\x09\xDA\x4C\xE5\x7E\xF8\xD5\xCB\xD0\xCE\xB3\xEE\x2C\xE2\xD5\xE1\xF7\xD4\x16\x5C\xE4\xE5\xD5\x1C\xD3\x94\xEB\xE4\x8F\xDA\x77\xDC\x60\xFF\xE4\xB1\xE3\x40\xED\x92\xD7\xD8\x4C\xE6\x2D\xEE\x94\xFD\xE2\xB7\xCD\x54\xEB\x8B\xCA\xE3\x42\xE4\xF2\xB6\x95\xC0\xE3\x58\xE6\x47\xE7\x94\xE6\xE4\xF8\xE3\x38\xEF\x8F\xDD\xB4\x5B\xE5\x31\xE1\x8C\xCC\xDE\x05\xD1\x59\xEF\x8C\xE7\xE5\xC7\xE0\xBC\xBA\x96\xD4\xE3\x6C\xE5\x34\xEA\x95\xFC\xDD\x6F\xE6\x38\xE4\x8F\xF5\xE4\x50\xE5\xF4\xD1\x6A\x77\xE4\xE6\xDD\x47\xD5\x97\xE8\xE3\x18\xE5\x82\xDF\x97\xEE\xE3\x08\xE7\x20\xC3\x98\xE7\xE4\xEF\xE2\x61\xEB\x8E\xD5\xE4\x87\xE5\x58\xE7\x97\xC6\xE5\xC8\xBF\x92\xDD\x98\xFD\xE3\x62\xE7\x44\xE4\x96\xF4\xE5\x7A\xE5\x8D\x6C\x97\xFC\xE4\x7E\xE4\x66\xEF\x92\xD0\xE6\x84\xC0\x63\xEB\x98\xDA\xE4\xFA\x73\x66", - "\xE1\x59\xC9\xD8\xED\xD3\x64\xE1\x91\xD5\xE6\x78\xE4\x45\xE4\x9A\xC6\x28\x99\xE5\x34\x9D\x76\xC0\xE6\x38\xE7\x80\xDE\x93\xDE\xE6\xA6\xE4\xA4\xD5\x95\xF8\xE6\x44\xE4\x9A\xDD\x9A\xD7\xE6\x9F\xE5\x1D\xD9\x8D\x71\xE6\xCC\x8F\xEF\x82\x7C\x88\xE5\xE0\xD3\xD7\xDF\xB3\x84\x4F\x40\xE5\x5C\xE6\x8D\xC9\x81\x7C\xDC\x73\xED\x94\xDD\xE4\x63\xE7\x6D\xB2\x9D\xD2\xE5\xD4\xE6\x65\xE6\x9D\xD1\xE7\x07\xDF\x75\xE7\x95\xD3\xE5\x23\xE7\xED\xCE\x9D\xDC\xE5\xE0\xE4\x5A\xEB\x45\xE3\xE7\x66\xE5\x57\xE5\x9D\xE6\xBA\xE8\xE7\x5A\xEA\x9E\xDA\xE7\xEC\xE4\x77\xE1\x9C\xC6\xD5\x0B\xA0\x72\xE7\x58\xFA\xE6\x3E\xDC\xC9\x29\x9B\xCA\xE5\x17\xD9\x7B\xE0\x97\xEF\xE7\xBF\xE7\x76\xE3\x9F\xE6\xD2\xFE\xE6\x5D\xE8\x92\xF2\xD6\x05\xE8\x6D\xED\x97\xE8\xE6\x5C\xCD\x82\xE4\x98\xC1\xE6\x03\xDB\x92\xDE\xA0\xC8\xE6\x85\xE7\x80\xD3\xA1\xCE\xE6\x07\xEB\x3C\xD7\xA1\xD4\xE6\x8F\xE6\x70\xE7\x3C\xC7\xE7\x60\xE4\x87\xE9\xA1\xCB\xD3\x1B\xEB\x6A\xED\xA1\xF4\xE7\xFA\xE5\x6F\xE8\x71\xE0\xE6\x85\xC9\x45\xE5\xA2\xF3\xE4\xAC\xE4\x8B\xEE\x1C\xE7\xE1\x20\xEB\x6C\xEF\xA0\xF5\xE6", - "\x9E\xD1\x3B\xDF\xA2\xFB\xE4\xA7\xE5\x84\xE5\x08\xFB\xE8\xE9\xDE\x5C\xE5\x4D\xF5\xE8\xCD\xE4\x80\xE2\xA3\xDF\xE8\x61\x92\x7C\xEB\x9F\xCA\xE7\x1D\xB4\x90\xED\x7E\xE6\xE7\x2B\xD6\x93\xE2\x92\xD0\xE9\xE2\xE6\x92\xEA\xA2\xE1\xDF\x47\xEB\x53\xD0\x00\x3A\xA8\x05\x04\x97\xEB\xA5\xD2\x04\x5E\xE9\x98\xE0\xA6\xE3\xE9\x0F\x06\x98\xE5\xA6\xE4\xE9\x0A\x06\x99\xE9\xA6\xE8\xE9\xD6\x53\x41\xB6\xA3\xD4\xE8\x10\xE8\x26\xC8\xA7\x2B\xB4\x37\xEB\x82\xEA\x07\xF3\xE9\x7C\xDC\x9E\xE3\xA0\xF0\xDE\x26\x67\x44\xB6\x9F\xEC\xD8\x54\xE7\x60\xDA\xA7\xCB\xE9\x04\xE7\x85\xD3\xA8\xD7\xE9\x34\xE4\x68\xE7\xA8\xFF\xE9\xC1\xDB\x7A\xE0\xEF\x8B\xEA\x21\xEA\x89\xE3\xA2\xDD\xD4\x90\xEB\x9B\xE8\xA1\xC9\xE6\x03\xD9\xA5\xE5\xA4\xE5\xE7\x6D\xE6\xCD\xBA\xA9\xD3\xE7\x45\xE6\x87\xEC\x07\x96\xB0\x7B\xEA\xEE\xDE\x33\x6E\xE9\x9B\xE9\x76\xE1\xA0\xD5\xDF\x6D\xE9\x3B\xBC\xA8\xF4\xDD\x8E\xEA\xA7\xEE\xCD\xA9\xEA\xA1\xE8\x8A\xE3\xAA\xC6\xB2\x84\xEB\x53\xEF\xB3\x9F\xEA\xD8\xE5\xAD\xE6\x4A\xFC\xEA\xDF\xE6\xAA\xE9\xA5\xC9\xD7\x07\xE1\x9F\xE4\xAA\xF9\xEA\x81\xEB\x77\xDB", - "\x64\xC0\xEB\xE4\xE6\xB0\xE2\xAA\xED\xEA\x7E\xE9\xA4\xE0\xA3\xE7\xE8\xF5\xDB\xA9\xEE\xAA\xD2\xEB\x3C\xE8\x7E\xEF\x5D\xF8\xBC\xCC\xE9\x7A\xEC\xA9\xC2\xE9\x4C\xB1\xB7\xEE\x9E\xDF\xEB\xCF\xE4\xD8\xB2\xAE\xFF\xE7\xE4\xE9\x56\xE1\x9A\xC1\xDF\x7F\x68\xAA\xE0\xAA\xFE\xE6\xC3\xE8\x0B\xD5\x83\xC5\x94\xC7\xE8\xA2\xE1\xA3\xCF\xEB\xF2\xE8\x22\xE0\xAD\xF5\xEB\xAF\xE9\x2B\xE1\xAB\xD1\xE6\x85\xC3\xB9\xE6\xA0\xD8\xEA\x9E\xD0\xB7\xE3\xAB\xEF\xEB\x2B\xE8\xBE\xE5\x75\xF7\xEA\x1E\xB5\xA9\xE9\x92\xC6\xEB\xB8\xEA\xBD\xE4\xAD\xFC\xE9\x0C\xEC\x9D\xE0\xA7\xF8\xE8\x4D\xDE\xC0\xEA\xA0\xDC\xE6\x09\xDA\xC6\xE5\xA7\xDC\xEC\x99\xEB\xC1\xED\xAB\xF0\xEB\x0A\xEC\x4B\xDA\x10\x3C\xA8\xEE\xEB\xC8\xE9\xB0\xC3\xD2\x28\xEF\xB5\xE6\xA9\xE2\xE8\x04\xED\x69\xCD\xB2\xD1\xEB\x2F\xEE\xA4\xE1\xB3\xF0\xDB\x33\xEC\xBF\xE8\xAD\xC1\xE9\xE5\xE8\x13\xB9\xB3\xD1\xEC\xFD\xE9\x50\xEE\x95\xC8\xBF\x3F\xED\xC3\xE8\xAC\xE1\xE7\x83\xD5\xD1\xE6\xB1\xD7\xEA\x15\xE8\x26\xCA\xB4\xFC\xDD\x4F\xEE\xC3\xE2\x5B\xFE\xEC\x22\xED\xB0\xEE\xAB\xD4\xEC\x07\x05\xD4\xE7\xB4\xD4\xE9\x49", - "\xED\xD5\xED\xAC\xD7\xED\xA6\xEB\x43\x0A\xB5\xD2\xEC\x93\xE9\x82\xD3\xB6\xC1\xED\xCE\xE6\xBA\xE3\x50\xE7\xEC\x5E\xEE\xB7\xEE\xAC\xF6\xEA\x59\xED\xDB\xE3\xAE\xEF\xED\xD5\xEA\xD8\xE2\xB7\xE8\xEB\x74\xEF\x09\xD7\xB6\xFB\xEC\x4F\xE9\xA7\xE5\x10\x3B\xED\x35\xEF\xB4\xE5\xB6\xFE\xE8\x15\xE4\xE0\xE4\xAB\xE4\xEC\x70\xED\xBE\xEC\x88\xF1\xED\x29\xEE\xD5\xE8\xB8\xF5\xED\x6C\xED\xE3\xEF\xB5\xCF\xEE\x58\xEE\x41\x06\xB8\xC8\xEC\x58\xE9\xC9\xE8\xF3\x97\xEE\x2A\xED\xE6\xE9\xB8\xFF\xED\x77\xEF\xC0\xED\xB4\xCD\xDD\x9C\xEE\xE3\xEB\xB2\xD0\xEE\xC4\xEA\x30\xB2\x11\x25\xEE\x93\xEF\xE9\xE5\xB9\xEE\xDC\xCA\xD4\xE3\xEE\xB2\xC7\xEE\xAE\xED\xD8\xE2\x73\xC5\xEB\x91\xEF\xEC\xE8\xB9\xC9\xEA\x25\xEF\x92\xDC\xBA\xEE\xED\x60\xEF\xC3\xEA\xA5\xFF\xEE\x73\xED\xF0\xE3\xB5\xDE\xDC\xB2\xEC\xCD\xE4\xBB\xDE\xEE\xA8\xEE\xE5\xE1\xBA\xDB\xEC\x3D\xEA\x27\xD4\xBC\xF8\xED\xC6\xEF\x3C\xD3\xBD\xE2\xEE\x71\xE8\xE9\xEF\xBC\xDF\xEC\xD1\xEE\xF6\xE2\xB9\xC0\xEF\x94\xEE\xED\xE0\x3A\xFF\x6E\xDF\xED\xF1\xE1\xBE\xC0\xD2\xCB\x3F\xD2\xE0\xB3\xE3\xEE\x9D\xC9\xFA\xEC\x77", - "\xEE\xEF\x52\xEF\x3C\xD0\xBF\xDB\xED\x7E\xEC\xD8\xB3\xBF\xE4\xED\x37\xED\x01\xD7\xBF\xE8\xED\x46\xEA\x13\xDB\xBF\xFC\xED\x53\xE9\xFD\xEC\xC4\xBF\xEF\x81\xED\xB6\xEC\x9F\xFE\xB9\x04\xF3\xF2\xEC\xBB\xDF\xEE\x46\x92\xF2\xEB\xBB\xF7\xEB\x0C\xF1\x02\xFF\xC0\xD3\xEC\xE2\xEF\x5F\x5B\xBD\xD7\xEC\x76\xEA\x27\xD2\xC1\xDD\xEE\x0B\xF1\xF3\xEB\xB0\xE4\xEF\xBA\xEC\x07\xF0\xC1\xDE\xF0\x0D\xF2\xCE\xE5\xC0\xFC\xEC\x6A\xEF\xD0\x85\xBE\xD4\xEF\xE7\xEE\x6C\xDB\xC1\xE6\xEE\xCC\xEF\x09\xDF\xC2\xED\xEE\x31\xF1\x05\xF0\xBB\xF8\xEE\x20\xF2\x03\xF2\xC2\xD4\xF0\xC2\xED\xEA\xEB\xCC\x33\xF0\xE0\xED\xED\xED\xC3\xD6\xF0\x2B\xF0\xF6\xE8\xB1\xF0\xDB\x40\xF2\xF9\xE2\xC4\xC7\xEF\x48\xE8\x0C\x85\xC4\xD0\xEF\xDA\xE8\x83\xD9\xC4\xEC\xF0\x4B\xF2\xFC\xE7\xC1\xCC\xED\xD9\xEC\xBC\xDD\x4E\xD3\xF1\x46\xF1\x06\xFD\x74\xCB\xD9\x5C\xF0\x14\xF7\xC0\xF8\xDC\xFA\xE8\x11\xF1\xC2\xF0\xF0\x1D\xF3\xEB\xEE\x51\xCB\xEE\x66\xF2\x0E\xF8\xC6\xE3\xF0\x6A\xF0\xCE\xB1\xC6\xDC\xEF\x51\xF3\x85\xD2\xC7\xD7\xF1\xEB\xED\x16\xFA\xBF\xF8\xF1\x36\xEC\xFB\xEB\xC7\xCF\xF1\x74\xF3", - "\x18\xF7\xDB\xB3\xF1\x18\xF0\xC8\xEA\xC1\xFC\xF1\x82\xED\xFE\xEB\x45\xC4\xF2\x58\xF3\x11\xFF\x7E\xF7\x8D\x88\xF2\x01\xFC\xA4\xDB\x8B\x91\xF0\x0A\xF3\xB4\xC0\xA9\x95\xF1\xDF\xE0\xAE\xD7\x8A\x99\xF1\x00\xFB\xC9\xD4\xF2\x80\xF1\x21\xFD\xBD\xF0\xDB\xDE\x8E\xFA\xED\xC7\xFA\xF1\x5B\xD1\x29\xF7\x70\xEA\xF2\xF1\xEF\x32\xDC\xCA\xF4\xEF\x9F\xF0\x24\xF1\xCA\xCD\xF2\x5E\xF0\x29\xFD\xC9\xEC\xE4\xC9\xE8\x83\xDF\xCA\xF8\xEF\x7E\xF1\x2A\xF7\xCB\xC9\xE5\x93\xF2\xA9\xBB\xCB\xFC\xEF\xE9\xEB\x25\xFB\xB6\xC7\x04\xC3\xF0\x00\xF8\xCB\xC8\xED\xDF\xD5\x32\xF7\xC2\xDA\xF2\x3D\xEC\x27\xF3\xCB\xF9\xF1\x8E\xF0\xC3\xBE\xCC\xCA\xF0\x70\xF0\x35\xD7\xCD\xD3\xF0\x83\xED\x8E\xEC\x35\xDB\xF3\x3B\xF1\x37\xFF\xC5\xC5\xC2\xE0\xF3\x1B\xFC\xC3\xCC\xF1\xB2\xF3\x19\xF4\xC3\xE9\xF1\x36\xF0\x26\xF3\xCD\xE7\xF2\xD5\xF0\x49\xE8\xCC\xFF\xF2\xC9\xE5\xA1\xEE\xE7\xA5\xF3\xEB\xF1\x36\xF3\xC4\xE3\x9E\xF4\xF3\x7D\xE2\xC8\xC0\xDF\x31\xE3\x3C\xFF\xCE\xC9\xF2\xBD\xF1\x71\xD4\xCE\xFD\xF3\x80\xE8\x33\xFF\x7C\xD5\xE4\xF8\xF1\x10\xF5\xC3\xFB\xF3\x6B\xF0\x8D\xE5\xA4\x83", - "\xF4\x92\xF2\x3D\xFC\x8D\xD3\xF4\xEA\xF2\x43\xFC\xCE\xD0\xF4\x38\xBD\x43\xFA\xC4\xCF\xF4\xE8\xF2\x40\xF9\xD1\xDF\xF4\x1B\xF5\x48\xF8\xD1\xEE\xF1\xF9\xF3\x39\xF3\x4F\xDE\xF4\x54\xF0\x48\xFB\xD2\xC8\xF4\x8D\xE8\x7C\xE0\xEF\xAC\xF4\x5D\xF2\x21\xFD\x74\xF8\xBC\xB1\x8B\x33\xFE\xC9\xE5\xEB\x39\xF4\x36\xFA\xD2\xEA\xBF\x3D\xF4\x37\xFA\xC8\xEB\xD4\x41\xF5\x38\xF3\xD4\xF7\xCE\x45\xF6\x39\xF2\xCE\xF0\xDB\x49\xF5\x4A\xFB\xD4\xC5\xD0\x4D\xF6\x46\xFA\xCF\xF2\xD6\x51\xF4\x49\xF3\xD5\xF3\xD3\x55\xF5\x4B\xF5\xD2\xD8\xF5\x7C\xDD\x56\xF5\xD3\xE3\xF2\x50\xF5\x57\xF2\xD6\xED\xF2\x1D\xD4\x4E\xF3\xD6\xF0\xF2\xD1\xF3\x43\x0E\xD5\xE2\xF1\xC1\xF3\x41\x0B\xD6\xC1\xF2\x6D\xF6\x41\x0F\xD6\xE2\xF2\x75\xF2\x6B\xE1\xD0\xF2\xF5\xA3\xE7\xBC\xE3\xD7\xF4\xF2\x36\xF4\x53\xF7\xD6\xFC\xF2\xA8\xF2\x3C\xF8\xD7\xE4\xF5\x09\xDB\x5E\xF4\xCD\xF5\xF2\x61\xF4\x61\xF4\xB8\xEC\xEB\xB0\x89\x5E\xF1\xBB\xC3\xF6\x68\xF5\x0A\xF2\x39\xCC\xF6\x86\xF4\x3C\xF8\xD8\xE5\xD4\x8C\xCD\x65\xF4\xD0\xC1\xF6\xB8\xD6\x44\x0A\xD9\xD5\xF4\xBA\xEB\x45\xF5\x10\x1F\xF6\x96\xF3\xBF", - "\xE0\xF6\xA4\xF6\xD0\xF2\x64\xFA\x10\x28\xF6\x3B\xF6\x6A\xFE\xD6\xFF\xF5\xC4\xF1\xDE\xED\xCE\xEC\xF6\xCB\xF0\xD7\xEB\xAD\xD2\x04\x47\xAA\x62\xF8\x09\xF9\xF6\x91\xF7\x25\xFC\xDB\xC0\xF6\xF1\xF3\xED\xCF\xDB\xF1\xF6\xD5\xEF\x32\xD3\xDC\xCA\xF3\xC0\xF2\x45\xF7\xDB\x87\xF7\x3A\xF5\x6D\xF2\xC0\xF8\xF6\x07\xDC\x73\xFE\xD3\xCF\xF5\x5B\xD2\x74\xF2\xD4\xC5\xF4\xC2\xF4\xDF\xD6\xDD\xC6\xF5\xD8\xF7\x60\xDB\xDD\xCA\xF5\x47\xF6\x77\xFA\xDD\xC4\xE7\x05\x07\x77\xFE\xD4\xE1\xF7\xDF\xD6\x79\xF2\xD5\xFF\xF4\x1D\xD6\x7A\xF6\xD5\xEC\xF7\x83\xC2\x7B\xFA\xD5\xD7\xF5\xEA\xBE\x7C\xFF\xD5\xF5\xF5\x64\xF0\x0E\xF6\x10\x36\xF7\x6C\xF6\x72\xF0\xD0\xCF\xF6\xE5\xF7\x78\xFA\xDB\xCD\xDD\xFC\xF4\x5C\xFE\xDF\xDF\xE4\x07\x05\x81\xF4\xD7\xFF\xF3\xF0\xBA\x82\xFC\xD7\xE0\xF5\xD5\xF6\x63\xFA\xDF\xC1\xF8\x03\xFA\x16\xF5\x08\xCE\xF8\x87\xF5\x5F\xF2\x5D\xD5\xE4\x18\xFA\x65\xFA\xE1\xD8\xF6\xAF\xE5\x87\xFB\xD9\xC1\xF7\xF9\xE6\x42\x02\xE2\xE0\xF6\xB9\xF2\x1D\xF0\xDD\xD5\xF8\x05\xD3\x89\xF5\xDA\xF2\xF4\x36\xBE\x8B\xF9\xDA\xC6\xF3\x2B\xF9\x6F\xF6\xDA\xCC\xB1", - "\x32\xF9\x6B\xF4\xE3\xCF\x04\x39\xFA\x73\xF1\xCB\xE3\xEF\x06\x05\x92\xAC\xE2\xCC\xBC\x42\xFA\x8D\xF0\xE3\xC5\x04\x45\xF8\x70\xF7\xD9\xEB\xD4\x49\xF8\x71\xFD\xC2\xF3\xD3\x4D\xF8\x72\xF5\xCF\xE1\xF6\xB7\xB5\x94\xFD\xDC\xC9\xF7\x54\xFA\xA9\xB6\xE5\xD3\xF7\xE8\xF5\x96\xBB\xE5\xD7\xF7\x9C\xF7\x60\xDF\xE5\xDC\xF7\x61\xFB\x77\xD3\xE6\xE0\xF7\xDD\xF6\x99\xFC\x77\xE7\xF9\xE7\xF5\x9A\xFC\x60\xEC\xF9\xEB\xF4\x75\xFC\xE4\xE4\xF7\x00\x00\x9C\xFF\xDE\xF2\xF9\xB7\xCE\x9D\xF3\xDF\xF0\xF7\x03\xDA\x9E\xF7\xDF\xCC\xF8\x41\xFB\xC1\xDE\xE7\xFD\xF7\x59\xF8\xE1\xC7\xD7\xC8\xF9\x12\xFA\x44\xF8\xE8\xC3\xF9\x73\xF8\xA3\xF9\xE7\xF4\xF9\x83\xFA\x81\xF5\xE8\xF6\xBC\x91\xFB\x82\xF1\xD7\xC8\xBF\x95\xFB\x83\xF8\xDF\xE5\xDE\x8C\xF5\xA6\xF9\xE1\xD0\xF8\x06\xF4\xE3\xCE\xE9\xDE\xF8\xA0\xFA\x9A\xDD\xE9\xC9\xFA\xCB\x33\xA8\xF3\xE2\xCB\xF9\x9D\xF7\x43\x0A\xEA\xE8\xF8\x0A\xF6\x8A\xFE\xEA\xEB\xF9\xB4\xFA\xA3\xF2\xE6\xF5\xFA\x46\xFB\xAA\xE0\xEF\xAF\xFA\x2F\xFA\xAE\xF1\xFF\x92\x04\x45\xA6\x94\xFE\xCF\xD7\xFA\x00\x01\xB0\xF7\xE5\xD3\xF9\x29\xFB\xCF\xA6", - "\xEC\xDC\xF9\x6E\xFB\x85\xDB\xEC\xE0\xF9\x24\xFB\x77\xDF\xEC\xE4\xF9\xD1\xF8\x83\xD3\xED\xE8\xF9\x65\xFA\xB5\xF7\x70\xD7\xFB\x6D\xF9\xB6\xFE\xEC\xFC\xDD\xDC\xF9\x9C\xFD\xE5\xDF\xFB\xB6\xFA\xB4\xF0\xEE\xE7\xFB\xE5\xF8\x83\xD8\xF3\xA1\xFB\x77\xFB\xB8\xFE\xE7\xAC\xFB\x7B\xF8\x9E\xF3\x58\xF0\xFB\x7F\xF8\xB1\xF4\xEF\xC4\xFA\xC9\xF8\xB0\xF9\xE8\xF1\xA0\xF7\xFA\xA4\xF9\xEF\xDC\xFA\xF3\xE9\xBF\xF6\xE9\xC7\xF8\x36\xBE\xC0\xFA\xE9\xC0\xFA\xC8\xBE\xC1\xFF\xE9\xDB\xFA\xAC\xEA\x41\x0A\xF0\xE4\xFA\x0C\xFC\xBC\xBF\xF0\xEB\xFA\x1F\xFB\x4A\xD3\xF1\xF0\xFA\xB6\xF7\x42\xFC\xD8\xD7\xFC\xBD\xF9\xBC\xE7\xC3\xCA\xFA\xC5\xFB\xBE\xFA\xEF\xE9\xFB\x0E\xE7\x6B\xEC\xF1\xF3\xF8\x37\xF8\xF2\xEE\xF0\xF4\xF9\x27\xFE\x8E\xF9\xF2\xCF\x04\x2D\xFE\x8F\xF9\xD6\xCA\x04\x31\xFC\x96\xFF\xEF\xE6\xBA\x35\xFC\xB2\xF1\xEB\xEF\xFB\xE8\xF9\xAE\xFE\xF1\xE6\xEC\x07\x05\x4C\xA2\xEC\xC9\xF4\x19\xFE\x99\xB2\xF4\xC7\xFB\xC3\xF8\xC1\xF5\x10\x07\xFD\xCC\xFA\xB7\xFE\xE7\x8C\xFD\xD0\xF8\xAB\xF3\x58\xD0\xFD\xD4\xFA\xD4\xFF\x5D\xD4\xFD\xD8\xF9\xB5\xF7\x61\xD8\xFD\xDD", - "\xFA\xD6\xFF\xB3\x9C\xFD\xE2\xF9\xB3\xFF\xF4\xFC\xDD\x60\xFD\xBB\xF2\xF6\xDD\xB4\x65\xFD\xBC\xFE\xEE\xE8\xFD\x64\xFD\xDB\xF4\xF2\xC0\xE4\x0F\x05\xDA\xF5\xEF\xCA\xFD\x60\xBE\xDC\xF8\xEF\xFB\xFC\x6C\xFF\xDB\xF2\x11\x36\xFD\xFE\xF8\xDE\xF1\xF7\xE2\xFC\x7F\xFE\xDE\xF0\xF0\xC0\xF8\x00\x00\xDF\xF3\xF0\xD3\xFA\xC8\xBE\xE1\xF7\xF0\xC4\xFB\x4C\xB2\xE2\xFB\xF0\xC8\xFC\x43\xEA\x41\x0E\xF8\xD0\xFC\x90\xFD\xE3\xFE\xF6\xFE\xFC\xBD\xEC\xD7\xC3\xF9\xD4\xFC\xA5\xF8\xC5\xDF\x9A\xDB\xFE\x18\xFF\x73\xF3\xD9\xC7\xFA\x85\xFC\xAA\xFB\xF7\xF4\xF9\xA0\xFD\xC7\xFA\xB9\xE7\xFE\x82\xFE\xA9\xB9\xFA\xE8\xFC\x47\xF9\xDD\xF7\xF9\xCA\xF9\x15\xFF\xED\xCF\xFA\xEE\xFC\xB1\xFE\xE5\xFD\xFA\xC8\xF8\x6A\x7B\xEE\xFD\xFB\xD8\xFE\x83\xD0\x9B\x78\xF4\xC4\xFD\xA2\xFE\x42\x02\xFC\xCD\xFD\x5E\xFD\x47\xB7\xFC\xD1\xFD\xB5\xFF\x60\xDB\xFC\xD5\xFD\xCD\xFF\x77\xDF\xFC\xD9\xFD\x56\xFD\x96\xB3\xFD\xDD\xFD\xD5\xFF\x85\xD7\xFD\xE1\xFD\x4E\xFE\xF2\xFC\x77\xDB\xFF\x66\xFD\xF7\xF7\xDB\xA0\xFF\x6A\xFF\xD9\xF3\xFE\xDF\xFF\x74\xF8\xF9\xF3\xF7\xC8\xFE\x60\xBE\xFA\xF7\xF7", - "\xC5\xFD\x7E\xBA\xFB\xFD\xF7\xF0\xFF\x12\x06\xFC\xF7\xF8\xF7\xFC\x33\xA6\xEF\xF0\xB0\xD5\xE4\xF6\xFF\xE2\xF4\xF7\xED\xE8\xAF\x73\xFE\x7F\xE3\x7C\xF1\x75\xFF\x68\xFF\x7A\xFF\x11\x7F\x05\x02\x01\x80\xE5\x7C\x00\x8F\x10\x0A\x00\x9C\xFE\x11\x7E\x36\x5E\x07\x81\xE8\x7F\xC7\x7A\xB8\x6A\xDD\x4D\x00\xA6\x7F\x17\x81\x03\x80\x00\x84\xF4\x72\x01\x8A\xFD\x4C\xF0\x4B\x6C\x1D\x80\xD8\x7E\xAF\x7E\x5D\x65\x00\x9A\x00\xAA\xFC\x09\x80\x06\x80\xE0\x7C\x09\x79\x04\x88\xFB\x63\x01\xAD\xFF\x29\x80\xB4\x7F\xCE\x7E\xF4\x7C\xCE\x72\x5E\x4E\xF2\x55\xF1\x6A\x5F\x35\x81\xA1\x7D\x4C\x7E\x05\x89\x03\x83\xFE\x7B\x00\xBF\x7E\x3D\x80\xE4\x7D\xF6\x7E\xCF\x51\x04\x8C\xFE\x72\x00\x8C\x6C\x45\x80\xE8\x7F\x11\x87\xC2\x69\x04\x94\xFE\x51\xFF\x59\x5C\x4D\x80\xEC\x7F\x13\x84\x09\x8C\x77\x71\x02\x9C\xFF\x49\x7F\xB7\x5A\x2B\x81\xF8\x78\x0B\x86\xEA\x5A\x02\xA5\xFF\x62\x7F\x5D\x81\x2A\x80\x0D\x82\x0C\x86\x02\x8F\x08\x1E\x01\xEB\x7F\xF8\x7E\x83\x03\x19\x87\xFD\x75\xBF\x6B\x03\xB3\xFF\x45\x7F\xA9\x77\x18\x52\x1B\x87\xFE\x7E\xF7\x7F\xEF\x6C\xF1\x35\x3E\x64", - "\x80\x15\x82\x1A\x7B\x0E\x8E\xFF\x6C\xFF\x47\xF3\x6A\x80\x79\x81\x18\x80\x04\x80\xF9\x5C\x07\x83\x00\xBF\xFF\x33\x74\x72\x80\x0C\x82\x42\x05\x10\x8B\x00\x87\x04\xA3\xFE\x65\x78\x78\x81\x32\x83\xED\x70\xE4\x7C\x08\x8F\x00\x95\xFE\x27\x80\x00\x01\x4A\x83\x04\x83\xE6\x70\xE4\x71\x04\xBA\x01\xED\x79\x9A\x80\x0F\x80\x09\x79\x14\x82\x02\x80\x02\x81\x02\xB6\x80\x2E\x7B\x65\x68\x29\x85\x05\x8F\xF3\x78\x79\x55\x46\x07\x80\xAF\x81\x4F\x80\x20\x69\x16\x82\x08\x97\x04\x8F\x04\x34\x81\xA8\x81\xAD\x7B\x32\x68\x17\x8A\x03\x90\xD5\x79\xFE\x12\x02\xBC\x80\x1F\x82\x2F\x86\x05\x8C\xC4\x41\x06\x82\x01\xD3\x80\x3F\x56\x63\x82\x11\x83\x10\x80\xF6\x4A\x06\x8A\x01\xCC\x81\xC5\x80\xBE\x6E\x33\x86\x09\x8B\x04\x9E\x73\x53\x03\xD2\x80\xD5\x81\x8E\x5B\x35\x87\x0A\x83\x04\x9A\x06\xB4\xF9\x5B\x81\x5B\x81\x6E\x83\x6D\x58\x1C\x8F\x05\x9C\x02\xB0\xBB\x64\x81\x68\x81\x3A\x80\x65\x27\xE0\x68\x0E\x8C\x03\x94\x00\x9F\x7E\x31\x51\x76\x83\x1B\x87\x1D\x81\xD1\x6B\x66\x32\x03\xF4\x80\xF4\x7F\x71\x82\x34\x87\x1B\x8B\x0F\x92\x04\xAB\x03\xFE\x81\x15\x81", - "\x78\x82\x22\x87\x1F\x82\x0B\x86\xE9\x70\x03\xC0\x81\x03\x82\x83\x03\x3D\x85\x0F\x89\x06\x84\x01\xB7\x02\xFC\x81\x00\x83\x82\x03\x42\x86\x10\x8E\x07\x88\x08\x91\x04\x80\x00\x13\x83\x46\x81\x45\x87\x21\x87\x11\x99\x08\x96\x02\x8C\x80\x5A\x74\xE8\x51\x2E\x84\xBE\x76\xFD\x42\x09\xBD\x02\xFE\x75\xB1\x7E\x93\x82\x30\x80\x25\x84\x0C\x92\x08\x2A\x04\xC7\x81\xD9\x81\xDB\x5B\x4B\x83\x19\x86\x0B\x8A\x08\x33\x04\xCF\x81\x35\x83\x83\x03\x4D\x84\x1A\x8C\x0C\x9B\x09\x98\x03\xD0\x81\x2E\x82\xBE\x6E\x4F\x84\x1B\x88\x0C\x9D\x68\x43\x05\xE1\x81\x45\x82\x99\x82\x50\x83\x29\x87\x11\x98\x79\x47\x05\xE5\x81\xE2\x80\x53\x5F\x53\x81\x1D\x89\x0F\x92\x0A\x87\xDC\x53\x82\xEE\x81\x72\x74\x56\x83\x1E\x8C\x09\x81\x08\x81\x05\x97\x82\x4B\x6D\xAD\x80\x3E\x80\x0E\x86\x10\x02\x0B\x8C\x04\xEA\x81\x36\x5E\xB3\x80\x45\x85\x21\x88\x00\x80\x00\x2A\x05\x9A\x82\x6C\x82\x26\x5B\x5B\x87\x23\x8E\x08\x96\x09\x80\xFE\x76\x82\x60\x83\x42\x63\x5C\x83\x13\x8E\xDA\x7E\x0A\x8F\x04\x7B\x82\xA2\x80\x35\x79\x58\x84\xCE\x70\x18\x85\x05\xAB\xFE\x7F\x82\x4C\x83\x82", - "\x83\x3C\x6D\x30\x8C\x0A\x85\xD9\x4C\x06\xB2\x7E\x7D\x83\x82\x03\x63\x86\xE6\x78\x16\x88\x7E\x53\x06\xBA\x7E\x55\x82\xDE\x7D\x41\x06\x39\x56\x10\x1C\x0C\x9B\x06\xCD\x53\xA0\x83\x87\x02\x67\x80\x00\x03\x1A\x85\x0D\xA1\x06\x8A\x02\xA6\x82\xD1\x83\x69\x87\x20\x09\x1A\x97\xB3\x26\x79\x2E\x83\xE0\x52\x31\x3D\x6C\x84\xCC\x30\x1B\x95\x0D\xB2\x06\xB6\x83\xB4\x83\xDB\x82\x6E\x81\x37\x8C\x1B\x85\x08\x29\xA7\x0F\x02\xBF\x82\x85\x01\x70\x87\x20\x03\x1C\x86\x08\x05\x07\xBE\x83\x12\x03\xE3\x80\x00\x02\x39\x8C\x1C\x89\x0E\x8E\x07\xC0\x83\xCF\x82\xE1\x81\x74\x87\x20\x0C\x7C\x55\x0E\x92\x04\x56\x83\x0F\x02\xEC\x82\x42\x02\x3B\x84\x1D\x97\x0E\x9E\x07\xD9\x83\xDF\x83\xED\x81\x78\x80\x8E\x32\x83\x3B\x2C\x47\xDC\x09\x50\x30\x82\x66\x80\x7A\x84\x26\x80\x12\x87\x08\x2B\x07\xB8\x82\xED\x82\x05\x44\xDF\x6F\x3D\x8C\x13\x99\x09\xB2\x07\x87\x80\xF4\x83\x9F\x82\x7D\x85\x20\x09\x1F\x84\x0A\xB1\x04\xA6\x5D\xFD\x82\xA4\x83\x7F\x80\xDE\x51\x20\x90\x0A\x89\x05\x80\x84\xF3\x83\x04\x85\x53\x86\x3C\x87\x11\x85\x10\x94\x05\xE4\x82\xFC\x83\xF3\x82", - "\x84\x81\x2F\x85\x91\x6E\x10\x99\x05\x91\x83\xF5\x80\x06\x86\x62\x83\x99\x66\x21\x9C\x0A\x98\x08\x9D\x84\x63\x82\x7A\x80\xCE\x58\x44\x87\x16\x99\x0C\xB6\xBC\x24\x84\x6B\x83\xCA\x80\xD8\x58\x45\x80\x17\x8A\x11\x9B\x00\x90\x81\x00\x00\x16\x84\x5D\x83\x23\x83\x09\x8B\x66\x32\x08\xFC\x82\x3B\x7D\x49\x81\x0C\x57\x46\x81\x18\x8D\xE7\x4B\xD9\x3C\x84\x86\x82\x06\x7B\x88\x84\xCE\x70\x24\x8D\x0C\x8C\xF0\x45\x84\x90\x83\x1C\x86\x7B\x82\x41\x8B\x21\x9D\xA8\x48\x09\x94\x83\x26\x84\xE4\x5F\x93\x80\x33\x80\x21\x80\xFA\x46\x04\x3F\x4D\x27\x82\xA1\x76\x69\x78\x4B\x8B\x12\x9A\x12\xB1\xFE\x5C\x84\xE9\x83\xFD\x80\x00\x00\x4C\x8C\x1E\x95\x0B\x87\x04\x64\x84\xF0\x82\x33\x87\x95\x84\xEF\x68\x26\x95\x0F\x84\xFB\x6D\x84\xFA\x83\xF8\x81\x41\x00\x4E\x8E\x1F\x80\x0A\xB3\x9A\x6C\x84\x78\x85\x8B\x80\x9D\x82\x40\x86\x27\x8A\x08\x3B\x09\x86\x84\x03\x85\x5F\x7F\x9D\x82\x4F\x89\x27\x8D\x12\x83\xC2\x7F\x84\x0F\x84\x21\x74\xA2\x87\x42\x8A\x24\x9E\x0B\xBE\x09\x89\x82\x73\x85\x42\x85\x2D\x82\x4E\x83\x26\x94\xF3\x4B\x0A\x9E\x84\x8D\x85\x48\x84\xA1", - "\x84\x42\x8C\xD8\x77\x14\xA1\x08\xDD\x82\x1F\x7F\x65\x1A\xA7\x85\x44\x85\x25\x8D\xA7\x63\x0A\xA9\x84\x51\x85\x75\x77\xBC\x77\x54\x8D\x22\x89\x15\xBF\x01\x9A\x85\x86\x84\xDB\x72\x44\x04\x55\x83\x23\x91\x0B\xB3\x0A\x92\x85\x23\x82\x3E\x7E\x27\x6C\x56\x88\x23\x8F\xF9\x4F\x0A\x9B\x85\xB1\x85\x82\x75\x47\x5C\x89\x54\x2C\x83\x16\x86\x0B\xB7\x5B\xC5\x85\x26\x78\xD8\x59\x59\x8A\x23\x99\xEF\x60\xFC\x4C\x85\x9A\x83\x65\x86\xB3\x81\x06\x5F\x22\x97\x03\xAA\x0A\xB0\x84\xD5\x85\x67\x84\x26\x87\x55\x82\x2D\x88\x16\x87\x0B\xDA\x74\x9B\x52\x83\x01\xB8\x85\x20\x03\x2E\x80\x7B\x65\x0B\xCC\x58\xE7\x84\x89\x01\xBA\x87\x21\x05\x2E\x8B\x17\x8A\x04\x6E\x85\x07\x02\x78\x86\xB8\x85\xA3\x52\x2F\x84\x17\xB4\x0B\xA2\x7B\x00\x01\x7A\x85\xBE\x87\x5E\x8C\x2E\x8A\x17\x93\x0B\xFE\x85\x83\x7E\x6B\x86\xBE\x83\x60\x88\x2F\x84\x18\xB7\xB6\x7A\x85\xED\x68\x84\x85\x21\x62\x61\x85\x91\x6C\x18\xAF\xE6\x7A\x85\x38\x5E\x88\x84\xC0\x86\xD4\x56\x30\x94\x18\xBC\x0B\x96\x86\x3B\x5D\x6E\x49\x16\x4A\x63\x80\xF6\x52\x61\x0C\xB1\x1E\x86\xB5\x2C\x53\x5E\x0C\x18", - "\x64\x8C\x31\x9F\x18\x9D\xB4\x24\x86\x2E\x30\x91\x87\xC9\x80\x5F\x88\x32\x96\x1A\x77\xB6\x23\x86\x21\x86\x43\x7C\x8C\x85\x65\x85\x01\x8B\x66\x34\x0C\x9B\x86\x2A\x87\x8C\x85\xCA\x80\xDE\x57\x33\x80\x41\x3F\x0B\xA5\x86\x33\x74\x9B\x87\xCF\x83\x67\x82\x46\x6F\xCD\x7D\x0C\xB8\x5E\x47\x87\x98\x86\xCD\x5D\x67\x8C\x34\x8B\x19\xAF\x0C\xF8\x85\x74\x19\xA8\x85\x47\x5C\x8E\x1C\xC4\x54\x1A\xA5\xA5\x70\x5D\x52\x87\xDB\x5A\xD5\x84\x65\x28\x35\x93\x1A\x9E\x0D\xDA\x86\x50\x87\xAF\x86\xA9\x59\x6B\x8F\xFD\x36\x03\x96\x00\xE5\x86\x32\x86\x6B\x87\xD6\x80\x6D\x86\xF3\x4B\x1B\x9D\x02\x80\x00\x6E\x86\x83\x01\xDC\x82\xF7\x26\x36\x91\x41\x73\x0D\x99\x84\x5C\x87\xA2\x84\xE9\x7F\x6E\x8B\x64\x77\x1B\xB8\xBC\x7E\x86\x57\x87\xB6\x86\xD8\x85\x6B\x80\x36\x85\x1C\x8D\xFC\x60\x30\xEA\x45\x35\x49\xE2\x80\x6A\x3C\x38\x83\xBD\x0B\x0E\x8E\x87\x8A\x87\xC8\x85\xE3\x80\x71\x82\x39\x90\x1C\x93\x0E\x80\x00\x09\x4B\xCC\x85\x47\x59\xA1\x4C\xC4\x5C\x1C\x98\x8E\x1B\x87\x9F\x87\xDB\x5A\xE7\x87\x21\x03\x3A\x8A\x08\x25\x0E\xB5\x44\xA0\x86\xD1\x84\xBE\x87\x74", - "\x86\x10\x0C\x1D\x85\x04\x1A\x87\xA4\x87\xA1\x84\xEA\x81\x60\x80\xF2\x6E\x1D\x98\x0E\xA9\x87\x87\x87\xDB\x86\xEA\x83\x77\x85\x37\x81\x1D\xA6\x0D\xCB\x19\xB6\x87\x76\x69\xF0\x85\x10\x66\x3B\x98\x79\x45\x0F\xBE\x87\xF0\x5C\xDB\x86\xF2\x80\x77\x89\x3C\x98\x17\x8A\xA5\x49\x52\x12\x03\xE7\x84\xF2\x5A\x7A\x80\xF6\x54\x1E\x8C\xB1\x56\x87\xD1\x87\xEC\x87\x6D\x58\x7B\x8F\x10\x1C\x1E\x8A\x04\x5E\x87\x07\x02\xF0\x84\xF4\x83\x7B\x8E\x3C\x9D\x68\x62\x0F\x85\x02\xD4\x87\xF4\x86\xEC\x83\x7C\x8F\x3B\x9A\x1E\xA6\xBA\x67\x87\x00\x00\xF8\x84\xCE\x58\x7E\x84\x3F\x8B\x1F\xA8\x0F\xCE\x85\xCB\x18\xF8\x85\x3B\x6A\x7F\x85\x08\x72\x1F\xAE\x0F\xD1\x85\xF5\x86\xF2\x86\x00\x8F\x7D\x86\x3E\x98\x17\xBF\xAC\x07\x88\x1D\x5A\x3F\x5E\x02\x89\x81\x8B\x45\x6B\x20\xB7\xB6\x0E\x88\xA6\x5C\x08\x89\xB4\x82\x82\x86\xF3\x48\x20\xA1\xFA\x0C\x7B\x76\x7A\xC2\x7C\x05\x88\xF9\x50\xF7\x77\x9D\x5B\x10\xD7\x85\x13\x7D\x92\x7F\xBC\x71\x83\x81\x42\x84\x21\xA0\xFC\x1D\x88\x25\x7D\xC1\x6B\x07\x8C\x89\x5B\x42\x8E\xB1\x4A\x04\x60\x00\x12\x02\x18\x8B\x43\x02\x86\x86", - "\xEA\x54\x21\xB0\xBB\x36\x88\x36\x5E\x1C\x88\xF2\x5A\x87\x80\x00\x1C\x21\x8C\xB1\x3E\x88\x31\x89\x8E\x58\x10\x8B\x86\x82\x44\x85\x22\xBA\x0C\x87\x02\x43\x89\x17\x8A\x11\x8A\x89\x84\x44\x94\x1D\xB1\xA0\x49\x88\x3E\x79\x20\x8B\x6D\x58\x8A\x86\x10\x14\x22\x9F\xF0\x55\x88\x4B\x89\x1B\x8A\xFD\x85\x87\x88\x3F\x92\x22\xBD\x0E\xCD\x88\xED\x86\x30\x89\xB4\x86\x8A\x86\x25\x85\x08\x24\x11\xE7\x88\x59\x89\x1C\x89\x1A\x8E\x21\x83\x08\x7F\x7A\x45\xD0\x6F\x88\x5B\x68\x38\x8A\xDD\x5A\x8E\x87\x3B\x74\x23\x83\xD6\x76\x88\xDF\x6B\x47\x7B\x80\x68\x8F\x89\xE5\x4E\x23\xA0\xF8\x24\x7F\x1B\x7D\xD7\x70\x1F\x8F\xC2\x6A\x47\x9E\xA4\x43\x12\xA6\x88\x31\x51\x40\x8B\xBC\x72\x91\x80\x23\x8C\x24\x96\x0B\x85\x89\x37\x7B\x65\x6B\x21\x8D\xA3\x53\x49\x97\x6D\x50\x12\xA1\x38\x76\x5E\x4A\x17\xCF\x52\x93\x8D\xD1\x5C\x24\xB7\xB6\x1E\x89\xA6\x5C\x50\x88\xBC\x5A\x94\x83\x73\x57\x9D\x64\x12\xC8\x5F\xA7\x88\xB0\x5D\x2A\x8C\x89\x5B\x4A\x9A\x13\x1B\xD1\x2D\x89\xCA\x84\x58\x88\xA5\x23\xA5\x69\x4A\x95\x25\xBF\x11\xB0\x84\xB2\x89\x28\x89\xDB\x3F\x95\x8C\x4B", - "\x82\xEC\x5A\x5C\x34\x89\xBD\x88\x53\x7C\xE9\x79\x97\x85\x33\x8E\x25\x97\x10\xC3\x89\xB7\x88\x6B\x84\x31\x8F\x8A\x8F\x4B\x8D\xF5\x73\x12\xA6\x89\xC1\x89\xC1\x6B\x32\x88\x93\x80\x4D\x9E\x25\xB0\x5F\x76\x5E\x92\x1F\x9F\x55\x36\x8D\xA3\x5B\x4D\x97\x6D\x5D\x13\xA6\x5D\xDF\x88\x78\x5D\x38\x8A\x25\x5B\x52\x63\x27\x88\xBF\x66\x89\x60\x5E\x74\x88\x13\x5A\x9D\x88\x45\x05\x27\xAE\x10\xA9\x49\xEE\x89\x78\x89\xCB\x58\x9D\x8C\x4E\x8F\x04\xA1\x10\xF5\x89\x35\x85\x76\x8B\xED\x60\x9F\x80\x4F\x8E\x26\xBD\x13\x83\x6B\xFC\x88\x72\x8A\x30\x88\x46\x81\x50\x81\x15\xBA\x13\x9E\x7F\xA4\x7F\x82\x88\xDE\x81\xE5\x26\x4D\x8A\x28\xB8\xBC\x0A\x8A\x10\x8B\x2D\x69\x44\x8A\x9E\x89\x42\x86\x89\x36\xBD\x38\x19\x3F\x56\x8C\x89\x47\x5A\xA3\x87\xDB\x5C\x28\xA6\xBA\x1E\x8A\xF0\x5C\x90\x8A\x45\x8F\x76\x62\x52\x88\x7E\x65\x14\xE0\x5E\x27\x8A\x26\x59\x4A\x8E\xE7\x4B\x52\x6B\x29\x8A\x0B\xAE\x8A\xA5\x30\x92\x88\xC3\x5F\xA4\x80\x53\x91\x03\xAC\x14\x83\x8A\xD6\x85\x9A\x8B\x48\x8B\xB0\x6A\x53\x8C\x26\xA8\x4D\x5B\x68\x3D\x8B\x9F\x8B\x31\x88\x46\x81\x54\x8B", - "\xB2\x45\x15\xDC\x66\x47\x8A\xC6\x65\x50\x88\xE7\x5B\x54\x97\x29\xBC\x14\xC0\x8A\x50\x8B\x96\x89\x54\x8E\x9F\x84\x4D\x6D\x8B\x73\xD3\x57\x8A\xCB\x68\xAC\x8A\xF5\x5A\xAB\x89\x60\x7C\x2A\x83\xD8\x5E\x8A\x9E\x69\x79\x68\xCE\x58\xAC\x8D\x74\x76\x2A\xAA\xBF\x2B\x6F\x15\x72\xB4\x8B\x6B\x74\xAC\x80\x6F\x62\x2B\xA5\xEC\x6C\x8A\x8E\x89\xB3\x86\x60\x85\x10\x6A\x56\x84\xFD\x75\x15\x84\x7F\x6E\x8A\x21\x87\x5B\x89\xAB\x8C\x57\x9D\xA8\x70\x15\xEF\x89\x06\x02\x32\x02\xFA\x5A\xB0\x86\xFD\x44\x2C\x89\xD8\x06\x8B\x03\x6C\xC4\x8A\x27\x6A\xB1\x8D\x74\x6C\x2C\x9D\xCA\x0E\x8B\x05\x68\xC8\x8B\x16\x6A\xB2\x8B\x52\x74\x2C\xB7\xCE\x16\x8B\x83\x6A\xCC\x8B\x77\x6A\xB3\x8A\xEE\x72\x08\x1C\x16\x97\x6C\x9F\x8A\x3F\x5D\x68\x8E\xB3\x83\x58\x8F\xB3\x5C\xCD\x23\x8B\xB4\x87\x65\x18\x6A\x8E\xD4\x5B\x5A\x90\x77\x6D\x16\x82\x85\x0A\x03\xD7\x88\xF2\x5A\xB6\x80\xF6\x54\x2D\x99\x0B\xB1\x50\xB6\x8B\xA0\x84\x69\x89\x23\x74\xFA\x79\x2D\xB6\x13\xA0\x7E\xBE\x8A\x2D\x75\x70\x8F\x6D\x83\x5C\x81\x2C\x8B\xD3\x45\x8B\x05\x02\xE4\x88\x00\x02\xB9\x8A\x5C\x98\x79", - "\x7D\x1B\x5F\x5E\xCF\x8A\x86\x5D\x74\x8B\xA5\x63\x5D\x97\x9D\x55\x17\x83\x6B\xD7\x8B\xEF\x69\x76\x89\xCB\x5B\x5D\x97\xB0\x5D\x17\xFE\x5C\xDF\x8B\x8E\x59\x78\x8F\xB6\x53\x5E\x86\x75\x65\x17\xF0\x5D\xE7\x8A\xD8\x8A\x6D\x2D\x80\x69\x5E\x88\x7E\x6D\x17\xEC\x40\x7A\x61\xF7\x8B\x6D\x8C\xE7\x31\x57\x8B\x66\x32\x17\xF4\x8B\x5B\x69\xFB\x8A\xB2\x82\xBF\x8C\xB5\x2C\x2F\xA6\x16\x95\x72\xFC\x8A\x5D\x89\x7F\x89\x99\x82\x57\x83\xDF\x1E\xF3\x0C\x67\x01\x8C\xC7\x69\xF9\x41\x92\x82\xF2\x1E\x2F\x9D\xD4\x09\x8C\x0B\x8C\x78\x6C\x84\x88\xBE\x82\x2C\x8F\x08\x0F\x96\x5F\x5E\x17\x8C\x86\x5D\x86\x8B\xA5\x6B\x61\x97\x9D\x5D\x18\x83\x6B\x1F\x8D\xEF\x69\x88\x89\xCB\x53\x62\x97\xB0\x65\x18\xFE\x5C\x27\x8D\x8E\x59\x8A\x8F\xB6\x5B\x62\x86\x75\x6D\x18\xF0\x5D\x2F\x8C\xF5\x89\x55\x53\x99\x61\x63\x88\x7E\x75\x18\x80\x00\x37\x8D\x1B\x8F\x7C\x8E\xC2\x8F\x5F\x8F\xCD\x7A\x18\x92\x02\x3F\x8C\x1E\x8D\x59\x78\xC8\x84\x63\x85\x32\xBC\x16\xB0\x84\x41\x8D\x7C\x8A\x90\x8C\x41\x75\x91\x69\x32\x82\x18\xF6\x51\x3D\x72\x22\x8F\x90\x8B\xC9\x83\x60\x6E\x32\xB3", - "\x18\x9D\x6A\x56\x8D\x82\x01\x96\x88\xC7\x81\x65\x8F\x08\x13\xA5\x18\x61\x5F\x8D\xD2\x61\x98\x88\xDE\x63\x66\x85\xA0\x65\x19\xDB\x68\x67\x8D\x95\x69\x9A\x8D\xE5\x5B\x66\x83\xAC\x6D\x19\xDF\x6B\x6F\x8C\x06\x6D\x9C\x8F\xC2\x63\x67\x9E\x73\x75\x19\x9D\x5A\x77\x8D\x23\x8A\x41\x01\xCF\x86\xEA\x5C\x33\xB0\xBB\x7E\x8C\x7B\x8C\xF5\x5C\xA0\x8B\xFF\x7C\xD8\x63\x34\xA0\x10\xA0\x7E\x86\x8C\x26\x59\xA2\x8A\x22\x0B\x68\x8A\x16\x8D\x1A\x8A\x02\x8F\x8D\x83\x01\xA4\x8E\x51\x82\x69\x9D\x31\xB3\xEB\x13\x8D\x07\x82\x2F\x8E\xA5\x8C\xF0\x78\x69\x85\x23\x80\x00\x1D\x8D\x38\x5F\x4E\x8E\xA8\x8B\x99\x63\x6A\x9D\xA8\x60\x1A\xC2\x74\xA0\x73\x9F\x7E\xAA\x8D\x64\x7B\x6A\x83\xA4\x6D\x1A\xA4\x78\xAF\x8C\x35\x79\xAC\x8D\x9D\x7D\x0A\x94\x07\xB3\x1A\x80\x69\xA9\x8D\xCC\x7D\x45\x77\xE7\x7B\x64\x77\x35\x86\x04\xAD\x82\xCA\x84\x5F\x8F\x3C\x6C\xD7\x8C\x35\x64\x36\x8C\xCE\x46\x8D\x8C\x7A\x64\x8F\xBC\x75\xD6\x80\x2A\x9E\x34\x82\x1B\xCB\x69\xCF\x8D\x8E\x69\xB4\x89\xC1\x68\xF3\x55\x55\x66\xD2\x56\x8D\x27\x68\x6C\x8D\x3B\x7A\xDB\x80\xD1\x7C\x36\xBF\x1A", - "\xDE\x8D\xF3\x68\x70\x8E\xFA\x5A\xDC\x8D\x51\x64\x37\x89\xD8\x66\x8D\x03\x6C\x74\x8E\x27\x6A\xDD\x8D\x74\x6C\x37\xB0\xDB\x6E\x8D\x97\x88\x78\x8F\x16\x6A\xDE\x8B\x52\x74\x37\xAD\xBC\x76\x8D\x7D\x5A\x7C\x8E\xB2\x74\x6B\x6A\x6F\x9A\xF8\x73\xEB\x7D\x8D\x17\x6C\x80\x8E\x9F\x5A\xE0\x88\x2F\x84\x38\xB7\xB6\x06\x8E\xA6\x5C\x84\x8D\xDA\x85\xC0\x85\x10\x0A\x38\xBA\x0D\x84\x7F\x0E\x8E\x42\x8C\xE9\x79\xE2\x87\x68\x8B\x66\x14\x1C\xDC\x85\x17\x8E\x4C\x81\xC6\x8F\x21\x0B\x71\x8A\x08\x1D\x1C\x87\x02\x1F\x8E\x83\x01\xC8\x8D\xE1\x87\x18\x86\x49\x4E\xD1\x27\x52\xA6\x68\x94\x8E\x1A\x7A\xE5\x8D\xCE\x6C\x39\x90\xF4\x2E\x8E\xBF\x8C\x98\x8D\x5B\x62\xE6\x8B\x4C\x74\x39\x9D\xD4\x36\x8E\x09\x6C\x9C\x8F\x80\x6A\xE7\x8E\x49\x7C\x39\x8D\xDD\x3E\x8E\xF0\x6C\x9C\x5C\xD0\x8D\x80\x63\x74\x9B\xA2\x45\x1D\xF6\x5E\x47\x8F\x96\x5D\xD2\x88\xA1\x80\x23\x8B\x3A\xBB\x1B\x8C\x67\x4E\x8E\x06\x6D\xD4\x8F\xC2\x63\x75\x88\x21\xA0\xA4\x25\x76\x55\x8F\x8E\x59\xD6\x8E\x89\x82\x11\x1B\x3A\xA1\x11\xA6\x8E\x1F\x80\xAE\x66\xD7\x8B\xE1\x8B\xCC\x03\x3B\xB2\x18\x85", - "\x02\x66\x8E\x36\x8B\x41\x01\xED\x80\xF6\x4C\x3B\x8C\xB1\x6E\x8E\x5D\x8E\xAC\x8E\xDC\x8A\xAF\x84\xEC\x75\xDF\x55\x09\xF7\x8E\xF4\x80\xBC\x8D\xB9\x72\xEF\x88\x21\x9C\x3B\x99\x0A\xAE\x85\x62\x85\x2A\x84\xCE\x5E\xEF\x8E\x2B\x8C\xFF\x76\x1D\xF4\x81\xED\x69\x52\x85\x21\x64\xF0\x8F\x0B\x94\x14\x83\x1E\xF9\x8E\x90\x8F\x66\x8D\xE2\x88\xF1\x8B\x78\x94\x3C\x95\xE4\x0A\x8F\x8C\x66\xC1\x8E\x98\x87\xF1\x8D\x6C\x8C\x3C\x80\x1B\xEA\x84\x2E\x85\xCD\x8E\x44\x04\x23\x5A\xAE\x64\x3D\x97\xF2\x26\x8F\x85\x8E\x83\x00\xEA\x8D\xF1\x8A\x10\x0B\x3D\x9F\x1E\x87\x02\xAE\x8F\x9F\x7D\xEC\x8E\x89\x63\x7B\x8C\xE0\x75\x1E\xA4\x78\xB7\x8E\x35\x79\xEE\x8D\x9D\x7B\x7B\x90\xE8\x7D\x1E\xBF\x8D\xBF\x8F\xBC\x89\xEB\x8C\x1E\x81\x7C\x8B\xA6\x45\x1F\xD6\x5F\xC7\x8F\x41\x61\xF2\x8B\xB1\x74\xFA\x6B\x3E\x87\x18\xAF\x73\xCE\x8F\xA6\x6D\xF4\x88\xDE\x63\x7D\x97\x24\x95\x1F\xDB\x68\xD7\x8F\x95\x69\xF6\x88\xA7\x8C\x70\x80\x00\x1B\x1F\xCC\x8E\xD6\x85\xEF\x8F\xD3\x8C\xB1\x72\x7E\x9E\x37\x84\xFE\x65\x8F\xB2\x7D\xE1\x8D\xB3\x88\xE7\x58\x7E\x9E\x73\x6D\x1F\x9D\x5A", - "\xEF\x8F\xDB\x59\xFC\x8E\xD4\x53\x7F\x90\x77\x75\x1F\xE7\x8E\x00\x01\x5B\x56\xBA\x72\xFF\x87\xC9\x7C\x3F\xA9\x1E\x85\x02\xFE\x8E\xD6\x8F\x41\x01\x00\x9F\x7A\x86\x08\x04\x20\xBF\x7E\x07\x90\x27\x69\x02\x94\x81\x7B\x80\x84\xE1\x4D\x20\xEA\x78\x0F\x91\x76\x79\x04\x90\xA2\x73\x81\x9F\x35\x95\x20\xC2\x8F\x03\x90\x7A\x83\x05\x93\x99\x6B\x81\x96\x7E\x5D\x20\x83\x61\x1F\x90\xE6\x8C\x8C\x81\x04\x9F\x7C\x93\xD7\x64\x20\xCD\x6E\x27\x90\x78\x6D\x0A\x97\x92\x8B\x82\x9B\xA2\x6D\x20\xAB\x6A\x2F\x90\xEE\x8D\x0C\x51\x06\x90\x7E\x80\xF9\x74\x20\xE3\x8F\xA4\x7F\x1B\x92\xF9\x8E\x5A\x8A\x83\x89\x3F\x99\x20\xEB\x8F\x12\x03\x1E\x92\x9F\x5A\x08\x9D\xD1\x44\x42\xB7\xB6\x46\x90\xA6\x5C\x24\x90\xBC\x5A\x09\x98\x7F\x8B\x55\x57\xF2\x4E\x90\xA6\x7A\x28\x92\x00\x96\x20\x02\x85\x85\x40\x85\x04\x55\x90\x3F\x7E\x2C\x91\xC9\x72\x0B\x93\x48\x7C\x42\xA4\xF0\x5E\x90\x6A\x78\x30\x91\x3B\x7A\x0C\x90\xD1\x64\x43\xBF\x1A\xE6\x90\xF3\x68\x34\x91\x97\x8A\x21\x0A\x86\x9D\xA8\x6D\x21\x89\x6C\x6F\x90\x3D\x61\x1C\x90\x13\x63\x87\x83\xE7\x55\xE4\x75\x90\x16", - "\x7C\xC6\x64\x1E\x95\x80\x6B\x87\x9B\xA2\x7D\x21\xD6\x89\x7F\x91\xDB\x65\x20\x93\xB0\x63\x88\x98\x41\xB0\x08\x85\x91\x3B\x90\x90\x7C\x22\x92\x84\x87\x88\x96\x3C\xAF\xE6\x0B\x91\x56\x8F\x2B\x92\x88\x82\x22\x00\x89\x9D\x68\x55\x22\xB7\x5B\x97\x90\x53\x5D\x26\x90\xDE\x5B\x89\x96\x79\x5D\x22\xEA\x8E\x06\x02\x3F\x50\x68\x72\x14\x9E\x44\x64\x45\x8C\xF0\x26\x91\x24\x78\x54\x92\x1A\x7A\x15\x9D\xCE\x6C\x45\x80\xD2\x2E\x91\xBF\x8C\x58\x93\x3C\x6A\x16\x9B\x4C\x74\x45\x9D\xD4\x36\x91\x09\x6C\x5C\x93\x80\x6A\x17\x95\x61\x8A\x08\x3C\x22\xCD\x6E\xBF\x90\x78\x6D\x30\x97\xEB\x53\x8C\x8C\x78\x45\x23\xC3\x8A\x21\x89\x63\x90\xF7\x8B\x99\x1A\x8C\x83\xAC\x4D\x23\xDF\x6B\xCF\x91\xCE\x8B\x43\x01\x1A\x97\x61\x74\x46\xBE\xB9\x56\x91\x5B\x88\x6C\x91\x6A\x8A\x22\x0A\x8D\x9F\x22\xBE\x22\x8E\x91\xF3\x75\x6E\x91\xB4\x82\x1C\x98\x7F\x84\x47\x88\xBF\x66\x91\x60\x5E\x74\x90\x13\x5A\x1D\x9C\x8D\x94\x07\xAC\x23\xCA\x85\xAF\x54\x75\x75\x3C\x97\x92\x73\x8F\x9F\x3F\x80\x00\x75\x91\x53\x91\x82\x00\x3E\x96\x0A\x97\x8F\x94\x07\xBB\x23\xA0\x73\xFF\x91", - "\x92\x75\x40\x94\x81\x73\x90\x84\xE1\x45\x24\xEA\x78\x07\x93\x76\x79\x42\x90\xA2\x7B\x90\x9F\x35\xB8\xBC\x0D\x92\xF3\x68\x88\x93\x32\x6A\x22\x96\xFD\x54\x48\x83\xC2\x16\x92\x22\x91\x10\x88\x46\x95\x04\x94\xF8\x7B\x48\x8D\xDD\x1E\x92\xF0\x6C\x90\x93\x25\x8A\x24\x9B\x45\x64\x49\xAB\xD4\x26\x92\x32\x90\x89\x00\x4A\x95\x06\x9B\xCC\x0B\x49\x86\x22\x9A\x92\xE0\x91\x8E\x93\x24\x97\x21\x0E\x92\x92\x46\x8A\x04\x35\x92\x17\x6C\x9C\x92\x9F\x5A\x27\x9D\xD1\x5C\x49\xB7\xB6\x3E\x92\xA6\x5C\xA0\x91\xB4\x80\x47\x5A\xAE\x64\x4A\x97\xF2\x46\x92\xF6\x90\xA4\x91\x3E\x90\x00\x0A\x94\x9C\x47\x8D\x25\xBF\x7E\x4F\x92\x27\x69\x54\x94\x81\x73\x95\x84\xE1\x55\x25\xEA\x78\x57\x93\x76\x79\x56\x90\xA2\x7B\x95\x9F\x35\x9D\x25\x98\x90\x06\x03\xAF\x93\x32\x6A\x2C\x9D\x51\x64\x4B\x83\xC2\x66\x92\x7A\x60\xB4\x90\x47\x91\x84\x8A\x96\x96\x43\xAF\xE6\x6D\x92\xF0\x6C\xB8\x91\x01\x6A\x2E\x90\x58\x85\x08\x34\x25\xAB\x6A\x77\x93\xDB\x65\x5E\x95\x06\x91\x83\x5B\x4B\xAF\x24\xA0\x7E\x7E\x93\x44\x91\x5F\x91\x26\x96\x2D\x81\x4C\xBE\x20\xE1\x92\x33\x92\x85", - "\x02\x61\x96\xCF\x5B\x98\x9D\x68\x4D\x26\xB7\x5B\x8F\x92\x53\x5D\x64\x90\xDE\x53\x99\x98\x3F\x8C\x03\x97\x93\x62\x85\x3E\x86\x39\x86\xE6\x5A\x99\x91\x0A\x9B\x26\xC8\x5F\x9D\x93\x03\x84\xBC\x59\x34\x91\x28\x80\x4D\x99\x26\xA2\x8F\xE6\x7E\x53\x5C\x69\x90\x33\x94\xEC\x64\x4D\xAD\xD3\x2E\x93\x85\x61\xD5\x93\x69\x96\xF1\x8B\xF6\x77\x6D\x72\x26\x94\x85\xAF\x92\x31\x87\x92\x68\x36\x95\x91\x7C\x4D\xAF\xE6\x24\x93\x38\x5E\xE0\x91\x6D\x92\x35\x93\x9B\x80\x3D\xA5\x26\xE0\x5E\xB7\x92\xE3\x90\xCE\x5B\x2D\x54\xEC\x6C\x4E\xB4\xFD\x4E\x93\x34\x85\x83\x00\x74\x96\x56\x8F\x10\x13\x4E\xA1\x1E\xD5\x93\x62\x84\xEB\x91\xAA\x82\x3B\x95\x25\x9C\x4E\xB4\x03\xDE\x93\xCD\x8C\xF0\x90\x86\x82\x3C\x9F\x77\x84\x4F\xB6\x23\xE6\x93\x4B\x93\xE5\x91\x76\x93\x3D\x9D\x9C\x90\xFC\x68\x27\xFC\x91\xED\x69\xF7\x92\xB2\x8C\xF0\x72\x9F\x85\xD9\x75\x27\x8C\x78\xF7\x92\x12\x7A\x7A\x94\x52\x89\x9F\x8A\xE3\x7D\x27\xBE\x84\x5C\x67\xFF\x90\x44\x7B\xC9\x62\xA0\x9F\x35\xB1\x27\xBA\x93\x85\x61\x02\x94\x58\x95\x20\x0A\xA0\x8B\x43\x92\x27\xEC\x93\xC6\x93\x06\x95", - "\x47\x6A\x42\x99\x60\x74\x50\x83\xD8\x16\x94\xBD\x91\x54\x82\xF5\x5A\xDE\x77\xD9\x5C\x50\x8C\xD8\x1E\x94\x17\x6C\x10\x96\x9F\x5A\x44\x9D\xD1\x44\x51\x8F\xF9\x4B\x69\x26\x94\x53\x5D\x8A\x90\xDE\x5B\xA2\x96\x79\x6D\x28\xC8\x5F\x2F\x94\xB0\x5D\x8C\x94\x5B\x83\xA3\x85\xEE\x5D\xD4\x31\x94\x38\x95\xE1\x93\xC2\x89\x06\x55\xA3\x9F\x2D\x8B\x33\x3D\x94\x37\x81\x1B\x96\x8E\x90\xFF\x80\xA4\x9A\x50\x89\xD8\x45\x94\x94\x8C\x5D\x83\x91\x8E\x5A\x88\xA4\x99\x34\x81\x29\xCC\x8C\xAF\x73\x26\x96\xA7\x8A\x4A\x98\xF3\x52\x52\x96\x29\xC3\x94\x30\x94\x2C\x96\x8C\x92\x4B\x9C\xC4\x54\x52\x92\x04\x67\x52\xA9\x93\x83\x00\x98\x90\x0C\x82\xA6\x9C\x52\x9F\x29\xE6\x94\x0F\x03\x31\x97\x67\x90\xEC\x5A\xA6\x9E\x4C\xB6\xBC\x6D\x94\xA2\x92\x83\x00\x9C\x97\x38\x9C\xC4\x53\x53\xA4\x26\xF6\x94\x62\x84\x3C\x94\xA5\x82\x4F\x96\x9C\x9C\x53\x91\x27\xF2\x94\x68\x94\x2D\x76\x9F\x94\x3A\x9A\x10\x03\x54\x97\x27\x85\x95\x5A\x94\x43\x95\xAA\x82\x51\x98\x79\x8C\xEC\x4C\x2A\x84\x93\x20\x7F\x47\x95\xB3\x8A\x52\x98\x21\x94\x54\xBF\x1D\xB8\x5E\x96\x94\x7B\x91\xA6", - "\x93\x29\x9B\xA9\x90\x4F\x9C\xCD\x1D\x95\xF3\x92\x6B\x84\xA8\x92\xD7\x8E\xA8\x81\x54\x8F\x19\x80\x95\x61\x94\xFC\x8F\xA8\x94\xEE\x88\xA8\x89\x55\x88\xBF\x2B\x95\x24\x78\x58\x96\x1A\x7A\x56\x9D\xCE\x74\x55\x90\xF4\x36\x95\x0E\x93\x1F\x82\x13\x6A\xB6\x70\x48\x7C\x55\xBF\x1A\xBE\x95\xF3\x68\x60\x97\x32\x6A\x58\x9D\x51\x64\x56\x83\xC2\x46\x95\x03\x6C\x64\x96\x27\x6A\x59\x9D\x74\x6C\x56\xB0\xDB\x4E\x95\x05\x68\x68\x97\x16\x6A\x5A\x96\x4D\x94\x56\xB7\xCE\x56\x95\x83\x6A\x6C\x97\x65\x5A\x5B\x99\xE5\x5C\x56\x8C\x22\xA1\x88\xDE\x94\x13\x8B\x32\x19\x5C\x9D\xD1\x44\x57\xB7\xB6\x66\x95\xB9\x86\x74\x94\xBC\x5A\x5D\x96\xF3\x4C\x57\x92\x1C\xB0\x84\xEE\x95\x8A\x8E\xAE\x91\xEC\x85\x91\x71\x57\x99\x0B\xE3\x95\x36\x94\x6A\x8F\xBC\x92\x3F\x9B\xAF\x8A\xE3\x76\x2B\xFD\x95\xED\x79\x7F\x97\x30\x87\xE7\x72\xB0\x9A\xD2\x72\x01\x79\x95\x7A\x61\x83\x97\x89\x96\xFA\x5A\xB0\x8F\x52\x83\xD8\x0D\x96\x46\x95\x87\x94\xC2\x96\x93\x60\xB1\x8A\x52\x89\xD8\x15\x96\x24\x83\x41\x60\xC6\x92\x57\x8D\x74\x7B\x58\x92\x29\x9E\x96\xA6\x94\x83\x00\xC8\x96", - "\x55\x90\xF6\x43\x59\xA4\x29\xB6\x5E\x26\x97\x35\x94\x13\x59\x65\x9E\xA6\x80\x45\x85\x04\x2C\x96\x71\x94\xE4\x5C\xCC\x94\x4E\x92\x11\x13\x59\x8C\x03\xB6\x96\x90\x7E\x9C\x94\x6E\x94\x6B\x6A\xB3\x86\x4E\x8B\xD9\x3D\x96\x7F\x95\x97\x97\xC4\x95\x63\x93\xB4\x81\x3A\xB5\x2C\xC5\x96\x05\x68\xA0\x94\xA1\x97\x20\x0A\xB4\x87\x54\xB6\x14\x8F\x02\x4D\x96\xC0\x8E\x8F\x97\x68\x9B\xB0\x90\x52\xA4\xFE\x51\x96\x8D\x95\x79\x74\xD6\x91\x31\x9C\xB4\x88\x5A\xB5\x25\x80\x00\x5B\x97\x66\x8D\xD8\x90\x43\x83\xB6\x9F\x3B\xA5\x2D\xF6\x91\x67\x97\xA5\x91\xDA\x94\x1F\x98\xF3\x44\xFE\x42\xE9\x6E\x96\xE5\x74\xB8\x94\x86\x82\x6E\x9F\x77\x94\x5B\xB6\x23\xF6\x96\x4B\x92\xBC\x96\x0B\x82\x6F\x9F\xF3\x7C\x5B\xA5\xEC\x7E\x96\x0C\x78\xC0\x94\x09\x7A\x70\x9A\xC6\x64\x5C\xAD\xF3\x06\x97\x1C\x7B\x1E\x84\x44\x78\x71\x9F\x6B\x8C\x5C\xAD\xC5\x0E\x97\xEA\x5E\xC8\x97\x92\x95\xFB\x82\xB9\x96\x5A\x84\xFE\x15\x97\x03\x6C\xCC\x96\x27\x6A\x73\x9C\x60\x86\x12\x83\x2E\x80\x96\x8B\x96\xD0\x96\x81\x94\x6B\x6C\xB9\x99\x43\xAF\xE6\x25\x97\x71\x8B\x18\x50\xEA\x94\xC0", - "\x8B\xCC\x0B\x5D\x96\x13\xAE\x97\x54\x8A\x2A\x84\x3D\x80\x76\x93\x58\x74\x5D\x9F\xD7\x36\x97\x0C\x6C\xDC\x97\x85\x6A\x77\x91\x89\x80\x00\x0F\xA5\x2C\x82\xA0\x73\xDF\x96\x97\x86\x05\x82\xBC\x89\xDB\x7F\x1D\xC5\x97\xFD\x76\x06\x78\xF2\x95\x98\x76\x8F\x8B\x5E\x85\x2C\xCC\x52\xA2\x97\xB6\x62\xF3\x96\x6B\x9B\x52\x73\x5E\x95\x2D\x83\x6C\xD6\x96\x87\x96\x27\x69\x7B\x91\xB1\x9B\x5E\x91\x2F\xCB\x69\xDC\x96\x8B\x94\xF6\x97\x7B\x93\x65\x8A\x08\x21\x2F\x99\x96\xE3\x97\x81\x95\xC9\x77\x7C\x9C\xB1\x9D\x94\x6C\x2F\xB1\x94\xEF\x97\x90\x96\x93\x90\x7A\x9A\xBE\x94\x57\xAF\xE6\x71\x97\x24\x96\x26\x58\xFE\x97\x64\x98\xFC\x5B\x5F\xAA\x2C\x98\x81\xFE\x97\x96\x94\xD8\x59\x80\x91\xB3\x83\x60\xA4\x2F\x96\x97\x21\x88\x02\x98\xCD\x93\x6A\x9F\x10\x0A\x60\xBE\x26\xA4\x7F\x0E\x98\x04\x94\xE3\x61\x82\x94\x9B\x8D\x60\x87\x30\xB2\x85\x16\x99\xFA\x94\x09\x7C\x82\x96\x9C\x9C\x60\x81\x2D\xBE\x97\x17\x98\xEF\x96\x06\x9A\x8D\x7E\xC1\x8B\x5A\x8A\x18\xB5\x85\x2A\x85\x5E\x85\xEC\x7A\x85\x9C\x8F\x8C\x61\xBF\xFC\x2E\x98\x25\x76\x18\x98\x03\x7A\x86\x96", - "\x4A\x74\x61\xAA\xF1\x36\x98\xED\x78\x1C\x98\x44\x7A\x87\x9F\x6B\x9C\x61\xB3\xD3\x3E\x98\xCB\x68\x20\x99\xF9\x94\x54\x84\x0F\x82\x62\x89\xD8\x46\x98\x7A\x60\x24\x98\x26\x62\x89\x9E\x96\x84\xFD\x4C\x31\xA6\x97\xF3\x75\x27\x99\x01\x6A\x8A\x9B\x45\x74\x62\x96\x13\xD6\x98\xB7\x66\x2C\x9B\x60\x6A\x8B\x9F\x97\x91\x41\x5C\x31\x89\x91\xCB\x19\x2F\x9B\xB7\x95\xFB\x82\xC6\x82\x57\x8C\x0A\xF6\x91\x38\x5F\x32\x98\xBE\x82\x8D\x97\xDB\x4C\x63\xA6\xBA\x6E\x98\xF0\x5C\x38\x9A\xCD\x5A\x8E\x98\xFC\x54\x63\xAD\x05\xF3\x52\x9F\x84\x75\x74\x1E\x9C\x88\x95\xAE\x7B\x63\xA8\x0A\xD5\x84\x7E\x99\x56\x84\x20\x9F\x8C\x9B\x94\x81\x64\xA8\x30\xD2\x96\x0A\x02\x43\x9A\x1D\x9A\x91\x9A\xB8\x9F\x35\x8C\x32\xC1\x84\x24\x79\x47\x9A\xE7\x92\x8D\x72\xC9\x89\x12\xB6\x23\x95\x99\x50\x85\x41\x98\xA6\x87\x92\x94\xC8\x8C\x5B\x92\x04\x18\x99\xB2\x97\x66\x8C\x28\x99\xE9\x7F\xC1\x83\x65\xBC\x2E\x9F\x99\x9D\x98\xD0\x72\x29\x99\x84\x9D\xC4\x90\x11\xAB\x32\xA3\x98\x00\x94\xC6\x67\x2B\x98\x78\x95\xB2\x73\x65\x83\x2F\xBF\x7E\xB6\x98\xE3\x94\x1A\x98\x95\x9B\xC9", - "\x85\x64\xA9\x32\xB5\x99\xBF\x98\xFB\x94\xE9\x79\x97\x99\xBC\x84\xE1\x4B\xD9\x44\x99\xCC\x97\xA5\x91\x3B\x68\x99\x9F\xBC\x85\x26\x8F\x04\x4C\x99\xD4\x97\xD8\x94\x00\x00\x9A\x97\xBD\x99\x50\x86\x04\x54\x99\xDA\x97\xA6\x6C\x36\x9D\x7B\x9A\xCD\x81\x66\x91\x32\xDE\x99\x94\x98\x70\x99\x3B\x7B\x9B\x92\xBE\x96\x66\x85\x04\x69\x52\xBD\x98\x17\x80\x3A\x99\x8F\x97\xC9\x6B\x67\xBC\x31\x98\x84\xEE\x99\x3F\x98\x3D\x81\x9E\x92\xC8\x93\x67\xA2\x33\x90\x7A\xF4\x99\x43\x99\xFD\x71\x9F\x96\xC7\x8C\x62\x7C\x33\x8D\x99\xF3\x69\x7F\x98\x24\x9A\x8D\x72\xD0\x93\x64\xAD\xF3\x05\x9A\x96\x99\xA5\x90\x42\x99\x93\x96\xCF\x89\x67\x8C\x1B\x8A\x02\x0B\x9B\x50\x98\x3C\x9F\x9E\x9F\x6B\x91\x68\xA4\x32\xEC\x82\x16\x9B\x53\x9B\x43\x01\xA3\x9C\xCA\x90\x62\xB0\x08\x9C\x9A\xB0\x99\x01\x95\x21\x60\xA4\x94\xCB\x8C\xE0\x64\x34\xB7\x99\x25\x77\x93\x9A\x2E\x99\x3D\x92\x11\x0A\x69\x85\x33\x84\x9A\x14\x9B\x80\x99\x4C\x9B\xD3\x81\x42\x8E\x69\x89\x33\x9E\x95\x8C\x66\x9B\x99\x33\x9B\x7E\x96\x10\x1A\x69\x91\x33\xAC\x92\x2D\x9B\x99\x9B\x10\x9D\xA7\x92\xD4\x9A", - "\x57\x9B\x34\xC5\x9A\x03\x6C\x9F\x99\x35\x9D\xE9\x6A\xD4\x99\x66\xB0\xDB\x4D\x9A\xDC\x99\xA7\x98\x52\x9E\x93\x60\xD5\x85\x67\x9D\x2E\xF1\x84\x74\x7F\x44\x85\xB9\x72\xAB\x98\x21\x9C\x6A\xBF\x1D\xDE\x9A\xF6\x90\xB0\x9B\x52\x92\xAC\x9E\x02\x84\x6B\xBF\xFC\x66\x9A\x25\x76\xB4\x98\x03\x7A\xAD\x94\xC2\x6C\x6B\xAA\xF1\x6E\x9A\xED\x78\xB8\x99\xE2\x91\x4D\x8F\xC1\x92\x6B\xBF\x1A\xF6\x9A\x6D\x62\xBC\x9A\xFA\x5A\xAF\x93\xB9\x91\x41\x7C\x35\x88\x98\x20\x7F\xBF\x9B\x80\x6A\xB0\x9E\x49\x64\x6C\x97\x35\xF5\x84\x62\x84\xC3\x98\xBC\x6A\xB1\x99\xBA\x85\x13\x9F\x30\xCB\x6C\x8C\x9A\x02\x8E\x5F\x9B\xAA\x9D\xCA\x96\x16\x91\x36\xD6\x89\x97\x9A\x69\x99\x66\x9B\xB0\x6B\xD9\x9F\xAE\x5D\x36\x8C\x6C\x9F\x9B\x0B\x6D\x68\x9E\xCF\x53\xDA\x98\x17\xB6\x01\x0E\x9B\x6C\x83\xD3\x98\x5D\x99\xB5\x98\xDA\x8E\x5A\x86\x04\x2A\x9B\x6E\x84\xE3\x90\x6C\x98\xAB\x9F\xC1\x93\x6D\x88\x36\x94\x85\xB6\x9A\x3E\x84\xE4\x79\xB7\x90\x28\x84\x4D\xBC\x36\xA5\x9B\xB7\x5B\xDF\x98\x65\x98\xDE\x62\xDC\x8E\x68\xA5\xEC\x45\x9B\xEC\x98\x7B\x90\x72\x9F\x9D\x9F\x77\x8B\x6E", - "\xB2\x33\xC0\x90\x0F\x02\xE7\x99\x3D\x9D\xD9\x82\xDD\x9A\x67\xB4\x03\xD5\x9B\x76\x98\xEC\x98\x40\x9A\xFD\x5A\xDD\x83\x68\xB1\x32\x8C\x7B\xDD\x9A\x83\x9A\x48\x9C\x71\x61\xDE\x89\x68\xBC\x23\xE5\x9B\x0C\x9A\xEA\x99\x6B\x98\x91\x9F\x36\x88\x6F\x92\x34\xCD\x9B\xEB\x9B\x2A\x86\x7B\x9F\xA2\x9E\xDA\x9C\x69\x85\x04\x73\x9B\x1A\x9B\xAF\x8F\x41\x00\xBF\x9D\xD1\x8D\x6C\x91\x37\xF1\x9B\x90\x95\x65\x18\x7F\x99\xA4\x99\xAB\x9F\x6F\xAB\x36\xF5\x9B\x9E\x8D\x01\x9D\x49\x9C\x84\x7A\xE0\x88\x69\x8C\xF0\x0D\x9C\x2B\x9B\xF3\x98\x80\x9A\xBD\x97\xE0\x8C\x6F\xAF\x36\x93\x9C\x18\x84\x9C\x5D\x98\x84\xD8\x7B\xE1\x94\xFB\x5D\x38\x9F\x98\x1F\x9C\x13\x99\x96\x81\xC2\x9F\xF3\x61\x71\x88\x38\xA6\x9C\xA9\x84\x14\x9D\x95\x82\xC5\x94\x0F\x8C\x71\x8D\x1B\xAE\x9C\x18\x84\x18\x9F\xDF\x8A\xC6\x96\x8F\x94\x71\xAC\x34\x97\x82\x36\x9C\x7E\x91\x8E\x98\x34\x7B\xE3\x8E\xA2\x7D\x38\xC2\x99\x30\x85\x1F\x9E\x31\x9D\x10\x62\xE4\x8A\xE3\x45\x39\xED\x79\x47\x9D\xB9\x99\xB0\x85\xE9\x69\xE4\x9F\x35\x8D\x39\xF7\x8A\x21\x89\x27\x9C\x4D\x98\xE4\x72\xE5\x9D\x6B\x90", - "\x0A\xDD\x84\x24\x9D\x92\x8F\xA4\x82\x39\x9C\x77\x75\x72\x89\xD8\x5E\x9C\x03\x6C\x30\x9E\x27\x6A\xCC\x9C\xE4\x98\x70\x97\x2A\x92\x02\x35\x53\x03\x81\x9A\x9B\xC9\x9D\x29\x6B\x73\x9B\x39\x9F\x98\x6E\x9D\x5C\x86\x94\x91\xCE\x93\xE2\x8F\x69\xAD\xF3\x74\x9C\x58\x9C\x3B\x9C\x44\x78\xCF\x94\xE6\x8D\x73\xBC\xDD\x7C\x9C\x66\x9C\x7B\x90\xA0\x9D\xC2\x95\x25\x83\x74\xB1\x36\xF0\x9C\x7F\x9D\x44\x9F\x82\x87\x21\x06\xE8\x94\x6D\xA2\x38\x80\x00\x8D\x9D\xDB\x9A\x71\x91\xD2\x9A\xDB\x84\xF6\x54\x3A\xBD\x9B\x90\x7F\x4B\x9C\x70\x9E\x1B\x97\x10\x1A\x74\x83\x37\xF5\x8B\x68\x9C\x45\x9C\x9B\x9D\x80\x6E\xE9\x86\x6E\xAC\x2A\x9D\x9D\xA2\x9D\x37\x9F\xA3\x9D\xD4\x99\xDC\x8A\x66\x9C\xCD\x2C\x9D\xCC\x9A\x7B\x93\x92\x68\xD6\x9F\xDC\x98\x10\xAD\xD3\x34\x9D\xD3\x9A\x5B\x9D\x21\x60\xD7\x96\xDD\x90\x6E\x8A\x04\x3C\x9D\xFD\x98\x4C\x80\xB0\x9B\xBB\x9D\x51\x63\x76\x9E\x37\xFB\x9C\xA9\x9C\x39\x9E\xFC\x90\xD2\x99\xEC\x95\x73\xB7\x34\x8F\x9A\x07\x02\xC8\x52\x42\x06\x31\x5A\x10\x1A\x03\x07\xDC\x54\x9D\x07\x02\x6B\x9F\x01\x80\xDB\x96\x10\x1A\x76\xA3\x3A", - "\xDB\x68\xDC\x9D\x82\x02\xB7\x9A\xD5\x98\xE0\x81\x77\x80\x00\x63\x9D\xCA\x9D\xFC\x94\x62\x52\x22\x0B\x07\x0B\x77\x8F\x04\x68\x9D\xCE\x9D\x9D\x98\x00\x06\xDC\x90\xEF\x99\x73\x8F\x3B\xCE\x68\xF4\x9C\xBE\x6D\xBE\x9F\x22\x8B\xEF\x9F\x76\xAB\xD4\x7D\x9D\xE4\x9C\x0B\x9D\x41\x00\xE0\x99\xEE\x9C\x5F\xA0\xBD\x04\x9E\xF1\x9D\x9F\x9B\x77\x68\xE1\x96\xEF\x92\x77\xB8\xBC\x0C\x9E\x7D\x9D\x02\x68\xC4\x99\xD0\x9B\x94\x93\x78\x84\x3A\xC2\x74\x16\x9F\x43\x9C\x5B\x81\xE3\x9E\xE8\x88\x70\xAD\xD3\x1C\x9E\x92\x9D\xC7\x99\x21\x60\xE4\x95\xE9\x86\x4E\xA4\x3C\x98\x9D\x94\x85\x93\x9F\xA6\x99\x5A\x8A\xF2\x9F\x74\xA0\x3B\x92\x02\xF5\x9D\x88\x9F\xCB\x9F\x21\x06\xEE\x9C\x03\x2E\x3B\x8A\x02\x59\x52\x9A\x9F\xCD\x9F\x20\x06\xEE\x9D\x79\xBB\x3C\xE2\x28\xD3\x9C\x89\x03\x1F\x07\xE7\x93\xF0\x82\x7A\x84\x3D\xF3\x9D\x30\x9F\xBB\x80\xCF\x99\xE9\x9C\x29\x93\xD7\x6D\x3C\xA6\x9D\x43\x9D\x8A\x73\xD3\x9D\xD5\x98\xD3\x8F\xCD\x66\x3B\xAB\x47\x0F\x03\xD6\x46\xCE\x9F\x21\x08\xF5\x8A\x08\x1A\x3D\xC1\x9E\x5C\x9E\x89\x03\xD7\x9B\xE9\x91\xF6\x99\x7A\x87\x3D\xDD", - "\x9E\x07\x03\xB1\x9E\x41\x07\xEA\x97\xF6\x87\x7A\xB1\x3C\x94\x9E\x9E\x99\xAD\x9E\x42\x06\xE6\x92\xF7\x87\x08\x34\x3D\xE0\x9E\xD5\x9C\x3A\x7F\xD4\x99\xD6\x95\xF1\x8C\x7A\xBE\x3B\xB7\x67\x7B\x9F\x5A\x9F\xDF\x89\xF0\x99\xEB\x83\x7C\xBE\x3D\x81\x9E\x55\x84\xC2\x9D\xAF\x99\xC3\x92\xA5\x47\x7C\x85\x3C\xEB\x94\x53\x55\x77\x9F\xC1\x69\xF2\x99\xF7\x97\x08\x94\x3E\xD9\x9D\x7C\x6F\xCB\x9D\xB7\x99\xF3\x9C\xEE\x8D\x7C\x92\x3E\x96\x9F\x8E\x9F\x84\x9F\x52\x9D\x53\x6A\xF9\x82\x77\x9C\x3E\x9F\x9F\x7F\x9F\xC1\x69\xE9\x9F\xDC\x97\xFA\x95\x7C\xA9\x3E\xDF\x6B\xAB\x9F\xB7\x9F\xC5\x9D\xD9\x81\xFB\x8D\x7D\x98\x3E\x8B\x9D\x0A\x03\xDA\x9C\xE8\x98\xF5\x98\xF8\x94\x07\xBA\x3E\xAF\x9F\x59\x5D\xDF\x9D\xEF\x9D\x5C\x72\xFC\x8F\x7C\x82\x30\xBB\x8C\xB9\x9F\xD0\x9D\xC3\x9A\xE1\x90\xC6\x9E\x7C\xAE\x3E\xC3\x9F\x18\x85\xE2\x9E\xE8\x9E\xA9\x95\x40\x72\x7E\x8B\x3F\xA3\x9F\x97\x88\xEB\x9E\xCC\x9B\xA5\x6A\xFD\x90\x7B\xBF\xFC\x2B\x9F\xAB\x9F\xBB\x9F\x41\x03\xF5\x99\xF3\x89\x7E\x8F\x04\x60\x9F\xCE\x9F\xF1\x9D\xFA\x98\xE8\x9A\xFE\x8F\x08\x03\x3D\xE7\x9F", - "\xEB\x9F\x82\x03\xFB\x9E\xFC\x94\xFF\x97\x7D\x80\x3F\xE3\x98\x31\x51\xEE\x9F\xEC\x9A\xD7\x9C\x38\x7A\x7F\x9A\x3C\x9E\x9E\x5C\x66\xFF\x9D\xC7\x9A\xE0\x9B\x50\x8D\x7F\x8A\x04\x68\x9E\x06\x02\xB5\x9D\x41\x03\xF5\x98\x00\xA5\x08\x0A\x40\x80\x00\x0C\xA0\xB1\x9D\xFC\x98\x00\x0D\x00\xA0\x00\x0F\x40\x91\xA0\x66\x9E\xF8\x9D\xD9\x9D\xFE\x96\x10\x15\x80\x82\x40\xA1\x9E\x8F\x9C\x9C\x5D\xF8\x9B\x02\xA2\xFE\x86\x08\x1F\x40\xA5\x9E\x1F\x98\x11\xA2\xF2\x9B\xFB\x97\x3B\x67\x81\xA8\x3C\xC6\x93\x2E\xA1\x95\x9E\xCD\x59\x06\xAE\xF2\x9C\x7E\xAB\x40\xDE\x9F\x25\x76\x1A\xA0\xD4\x99\x8E\x72\x11\x0F\x1D\x4F\x04\x11\x54\x0F\x03\xBA\x53\x01\x82\x08\xA7\xFF\x9F\x59\x44\x41\xD0\x9F\x7F\x8F\x23\xA2\xF1\x9D\x80\x9C\xC4\x4A\x82\x93\x3F\xD1\x9A\x05\x68\x27\xA3\xF5\x9C\xFA\x9B\x45\x72\x82\xAC\x40\xFD\x5A\x56\xA0\x1C\xA0\x03\x79\x0B\xAB\xFF\x89\x82\xBC\xDD\x5C\xA0\xFF\x9E\x02\xA0\x18\xA3\x00\xA5\x25\x83\x83\xA0\x40\x88\x9C\x66\xA0\x14\xA1\x08\xA2\x22\x09\x06\xAF\x81\x9F\x30\xED\xA0\x32\xA0\xE4\x5C\x1C\xA5\x06\xAD\xF2\x53\x83\xBB\x40\xD4\x69\x76", - "\xA0\xAA\x9D\xA8\x95\xFB\x89\x07\xBC\x7B\x95\x3D\xF3\x75\x7D\xA0\xC1\x9E\x3D\x91\x10\xA5\xF8\x83\x84\xB4\xF9\x04\xA1\x8B\x9E\x2F\xA3\x45\x80\x11\xA1\xEC\x9F\x2D\xB1\xA0\x0C\xA1\xC4\x9C\xC0\x9B\x32\x18\x12\xA7\xEC\x83\x5D\x95\xE4\x14\xA1\xE2\x9A\x4B\xA3\x6B\x70\x13\xA6\xDE\x90\x76\x86\x04\x1C\xA1\xE9\x9A\xC6\x9D\x10\xA7\x0B\xA4\x0A\xAB\x84\xA5\x42\xC5\xA0\x1D\x5A\x50\xA3\x7B\x9B\x97\x9F\x10\x06\x04\x12\x04\x2E\xA1\xAD\xA1\x57\xA2\x2C\xA1\x16\xA4\x0B\xAA\x08\x30\x42\xB6\xA1\xB3\xA0\x5C\xA1\x2D\xA7\x20\x07\x0B\xBC\x85\xB9\x42\xBE\xA1\x0F\x03\xBB\x53\x01\x82\x18\xA8\x0A\xA1\x86\xBC\xDD\x44\xA1\x48\xA0\x7B\x90\x32\xA3\x09\xAB\xC0\x8A\x08\x0B\x43\xCF\xA0\x56\x9A\x78\x6F\x33\xA3\x0A\xA0\x05\xAC\x78\x53\x43\xD7\xA0\xDF\x6B\x6B\xA2\x16\xA4\x84\x7A\x0D\xBD\x82\x8A\x43\xC7\xA1\xE0\xA1\x8B\x81\x37\xA1\x0C\xAA\x79\x86\x86\xA2\x43\xE1\xA1\xC5\xA0\x67\xA3\xC1\x6B\x1C\xA4\x06\xB0\x54\xB1\xA0\x6C\xA1\x67\xA0\x02\xA3\x92\x68\x1E\xAA\x06\xA8\x70\xB4\x43\xEE\xA0\x8F\x9D\x7B\xA1\x1C\xA5\x2D\x8A\x0F\xB4\x83\x83\xD6\x7D\xA1\x77\xA0", - "\x88\x78\x40\xA2\x0F\xA4\xAA\x84\xFD\x43\x44\xFE\xA0\x7B\xA1\x65\x1B\x41\xA2\x10\xAE\xEA\x95\xC8\x4B\x44\x85\xA1\x0D\xA3\xD7\x73\x43\xA1\x11\xAC\x0A\xAA\x87\xB8\x3E\x87\x02\x13\xA3\x46\xA2\x45\xA1\x1D\xA0\xEF\x59\x88\x91\x42\x83\x6C\x1E\xA3\x4A\xA3\x3C\x69\x24\xA9\x09\xA3\x89\xB4\xF9\x08\x01\x12\x03\x44\x01\x0F\xA1\x25\xA2\x11\x00\x82\x9C\x71\x70\x11\x0F\x03\xF0\x44\x36\xA1\xCB\x52\x13\xBB\x86\xA7\xD0\x35\xA2\xDE\xA1\xA5\x90\x4E\xA4\x1C\xA4\x0F\x9B\x89\xAD\x43\xCD\x8D\x3E\xA3\x78\xA1\x95\x81\x28\xA5\x0F\xA9\x15\x84\x45\xF8\xA1\x08\x9D\xA3\xA3\x3E\xA4\x89\x5A\x14\xBE\x87\x9F\xD7\x4D\xA2\x01\xA3\x5F\x8C\x54\xA4\x20\xAC\xC0\x73\x8A\x88\x44\xA5\x76\x56\xA2\x86\xA1\xDC\x9A\x21\x09\x15\xB0\x88\xBC\x23\xDD\xA2\x14\xA2\x9D\xA3\xC1\x68\x2C\xA6\xC7\x84\x8B\x9F\x44\xEB\x92\xDD\x8E\xB3\xA2\x48\xA3\xCA\x9B\xCC\x0A\x8B\xA5\x44\xCB\x69\x6E\xA3\x4E\xA0\x56\xA4\xCE\x71\x17\xA1\x85\xBF\x1D\xF5\xA2\xAB\xA0\xB1\xA1\xD3\x98\x46\x88\x17\xB4\x6F\xB2\x43\x85\x61\x7D\xA3\xFC\x9B\x8E\x92\x22\x01\x18\xBD\x6F\xAC\x2E\x84\xA3\x74\xA3\xC4", - "\xA3\x45\x85\x30\xA4\xE0\x93\xA7\x4C\x46\x8B\x9C\x6A\x79\xC7\xA2\x83\x9C\x84\x72\x19\xB9\x72\x95\x45\xF4\x7C\x13\x55\x87\x02\x67\x57\x00\x8B\x19\xBC\x88\x86\x04\x1D\xA3\xC9\xA1\xA5\x90\x68\xA4\x19\xA4\x9A\x83\x8D\x90\x43\xE8\x97\x9E\x68\xD3\xA0\x35\xA1\x1A\xA5\x40\x6A\x8D\xB3\x44\xE6\x5C\xAE\xA2\x9B\xA1\x3B\x79\x36\xA9\x13\xBC\x47\xB4\x46\xBC\xA2\xCD\x8D\xDB\xA3\x4F\xA0\x43\x8A\x1B\xA2\x8A\xB4\x03\xBD\xA3\x45\xA3\x2A\x84\x70\xA0\x29\xA4\x00\xB8\x79\x43\x47\xCB\xA2\x12\x03\xE3\xA2\x53\xA4\xC1\x6A\x1C\xB1\x8A\xAD\xC5\x4D\xA3\x54\xA2\x53\x68\x74\xA7\x2A\xA0\xE4\x81\x21\x93\x47\xDA\xA2\x09\xA3\xE4\xA0\xDF\x6F\x3A\xAE\x15\xBF\xF9\x5C\x47\xE1\xA2\x5B\xA3\x83\x03\x77\xA2\x23\xA2\x1E\xBB\x8E\x8A\x3D\x9F\xA3\x57\x9D\xF1\xA3\x59\xA5\xB2\x9D\x7D\x8A\x8F\xAB\x45\x93\x97\xCB\x18\xF7\xA3\x5B\xA3\xA8\x9D\x99\x54\xF3\x72\x47\xF2\xA2\x0C\x79\xFB\xA2\x5D\xA6\x1E\x9A\x1F\xB9\x8B\xB6\x46\xE6\xA3\x17\x83\xFE\xA2\x5F\xA5\x1C\xAA\x10\x0E\x04\x12\x04\x0F\x01\x12\x02\x48\x02\x44\x07\x44\x5A\x10\x1D\x08\x47\x00\x8E\xA4\x9E\xA3\x82\x00", - "\x84\xA1\x34\xAC\x8F\x93\x90\xA4\x46\xE2\x84\x16\xA5\xD3\xA1\xFB\x95\x80\x69\x21\xAB\x8D\xA8\x46\xCD\x6E\x1D\xA5\xD7\xA3\xCF\x51\x44\xA2\x1B\xB0\xE8\x64\x48\xB5\xA3\x3F\x7F\x13\xA4\x6E\xA0\x43\x8A\x22\xBB\x8D\xBF\x1D\xAD\xA4\xBE\xA3\x66\x8C\x8C\xA1\x38\xA4\x0F\x93\x91\x84\x47\x84\xA4\x07\x02\x1B\xA4\x72\xA7\x21\x0A\x23\xAB\x8E\x97\xD8\x3D\xA4\xCE\xA2\xF5\x5C\x90\xA1\x3A\xA7\x42\x63\x92\x94\x47\xD1\x9E\x8C\x7A\x23\xA4\x76\xA5\x20\xA4\xF8\x6A\x92\x9D\x47\xA5\x76\x4E\xA4\xF0\xA1\x8A\xA4\xCE\x71\x25\xA4\x8F\x86\x04\x55\xA4\xEB\xA2\x78\x6C\x96\xA7\x3D\xA0\xD8\x91\x41\x5B\x49\xF3\xA3\x92\xA0\x89\x03\x97\xA0\x3F\xA8\x24\xA4\xFD\x63\x49\xFB\xA3\x11\xA3\x79\x77\x99\xA6\x3F\xAE\x09\xB2\x90\x94\x49\xFC\x6E\x6B\xA5\x01\xA5\x8D\xA0\x4E\xA4\x27\xB7\x08\xB1\x49\x82\xA3\xF8\x8F\x14\x57\x01\x82\x4F\xA1\x21\xA0\x00\x3C\x49\x94\xA4\x3F\x7F\x3F\xA7\x85\xA4\x52\x82\x28\xBA\x90\x92\x29\x85\xA5\x1E\xA5\x0D\xA7\x16\x68\x51\xA2\x22\xB2\x08\x0C\x4A\xA5\xA4\xBF\x8D\x47\xA4\x8A\xA5\x64\x72\x29\xAB\x91\xBF\x1D\x95\xA5\x2E\xA4\x7B\x90\xA6", - "\xA1\x46\xA8\x21\x9B\x94\xB4\x48\xCD\x8D\x9E\xA5\x1B\xA4\xD7\x96\x20\x01\x2A\xBB\x91\x8A\x04\x25\xA5\x3E\xA4\x3F\x5C\xAA\xA1\x48\xA6\xFD\x4B\x95\x84\x49\xD4\x69\xAE\xA5\x23\xA7\x5C\x8D\x22\x71\x2B\xAB\x92\x95\x47\xA0\x7E\xB5\xA5\x27\xA4\x03\x79\x57\xA2\x25\xB4\x94\xB4\xF9\x3C\xA5\x56\xA5\x82\x00\xB0\xA1\x4B\xA5\x40\x63\x96\x9C\x49\x99\x92\xDD\x8E\x63\xA4\x98\xA0\x59\xAB\xCC\x0A\x96\xA4\x49\xB3\xA5\x8C\x7A\x67\xA4\x9A\xA7\x0F\xA4\xF8\x72\x96\xAC\x49\xDA\x9C\xA4\xA5\x5F\xA4\xDF\x6E\x5A\xA2\x27\xA0\x95\x9B\x4B\xDF\xA5\x17\x82\x6E\xA4\x9E\xA6\x65\x90\x00\x03\x51\x4A\x04\x75\x41\x0F\x03\x04\x56\x42\x02\x90\x3D\xDA\x32\x80\x99\x40\xDE\x9E\xEE\xA4\x78\xA7\x43\x03\x45\x57\x00\x94\x97\xBD\x49\xF6\xA5\x80\xA5\x92\x74\xBE\xA3\x50\xA6\x9C\x9B\x97\x86\x4A\xCB\x9D\xFE\xA5\x44\xA6\x94\x91\x60\xAD\x28\xB3\x97\xBC\xDD\x04\xA6\x90\xA5\x79\x68\xC2\xA3\x52\xAC\xC0\x6B\x98\x96\x4A\xF6\x91\x0E\xA7\x4C\xA7\x52\x91\x62\xAC\x29\xBF\x3B\x94\x4C\x9F\xA5\xA2\xA0\x85\x03\xC5\xA2\x54\xAD\x6C\x9B\x98\xA6\x4A\x87\x02\x1E\xA7\x54\xA6\x44\x01", - "\x64\xAC\x2A\xA3\x84\x64\x4C\xAF\xA5\xE3\x9A\xC6\x7B\xC9\xA2\x56\xAF\xDD\x93\xD7\x6B\x4C\xB6\xA5\x24\x79\x97\xA6\xAE\xA1\x66\xA4\xE7\x72\x99\xBD\x4A\x8D\xA6\x07\xA7\xF3\xA1\x41\x06\x66\xA1\x2C\xA5\x80\x86\x04\x3C\xA6\xC4\xA4\xC9\x9B\xC8\xA7\xCA\x90\x34\xA7\x96\xA6\x33\x80\x00\x45\xA7\x65\xA7\xD1\xA1\x69\xAF\x2C\xAD\xE7\x4C\x4D\xD3\xA5\x3F\x7F\xA7\xA7\xB5\xA0\x67\xA7\x11\x92\x9A\x9D\x4B\x98\x84\x56\xA7\x71\xA5\x5B\x82\x46\x5D\x27\xBC\x9A\xB9\x4B\x83\x69\x5E\xA6\x7E\xA7\x07\x99\x6C\xAF\x2F\xAA\x77\x8F\x04\x64\xA6\x02\xA7\x65\x9C\xDA\xA5\x60\xA6\xEA\x4B\x9B\x89\x4C\xEA\x5F\x6E\xA6\x86\xA4\x09\x79\x6E\xAF\x30\xAB\x4A\xB4\x4D\x92\xA6\xFC\x91\xBB\xA5\xC5\xA6\x1E\x9A\x37\xB8\x98\xBF\x1D\xFD\xA6\x1C\xA6\x0C\x84\xE0\xA7\x63\xA7\xC2\x83\x9C\xA2\x4C\xB7\x5B\x86\xA7\x92\xA7\x80\x69\x71\xA8\x32\xB2\xAD\x4C\x4E\xAC\xA6\x80\x69\xC7\xA4\xCC\xA0\x5A\xA4\xFA\x72\x9C\xB3\x4C\x94\xA7\x84\x7E\xCB\xA7\xCD\xA3\x6E\xAC\x77\x7A\x9C\xBD\x4C\xB8\x5E\x9E\xA7\xA0\xA7\x4A\x69\x74\xA6\x34\xAD\xBA\x64\x4E\xCA\xA6\xEC\xA3\x18\x53\xE9\xA5\x69", - "\xA9\x32\xB3\xD7\x6B\x4E\xD0\xA6\x4C\xA5\x10\x8B\xEB\xA3\x6A\xA5\x26\xB9\x9C\xB4\xF9\x33\xA7\x57\xA7\x33\x9F\xD9\xA5\x73\xAC\x3B\xB7\x08\xB8\x4E\xDA\xA6\x4C\x59\xDF\xA6\x61\xA3\x74\xA4\xE7\x72\xD9\x1F\x4D\xA6\x69\xC6\xA6\xB1\xA4\x5B\x81\x79\xA5\x36\xA6\x78\x8C\xB1\x4C\xA7\x69\xA6\xB3\xA6\x42\x00\x7A\xAC\x36\xB0\x77\x54\x4F\xEF\xA6\x1D\x6B\xEB\xA6\xDC\xA7\x84\x6A\x3D\xB5\x9B\xBC\x23\xDD\xA7\x78\xA7\x9F\x7C\xF8\xA3\x6F\xAB\x94\x83\x9F\xBE\x4D\xF6\x91\xE6\xA7\xC0\xA7\xDF\x89\x7D\xA4\x38\xA5\x08\x2C\x4F\x87\xA7\xB9\x87\xF7\xA6\xE2\xA6\x93\x62\x3F\xAD\x9C\xB3\xD3\x75\xA7\x90\xA6\xD9\x68\xFE\xA3\x72\xA4\x4D\x7B\x9F\x97\x4E\xAD\xA6\x30\x84\xFF\xA7\xE6\xA0\x73\xA6\x2D\x82\xA0\xBD\x4C\x86\xA8\xA2\xA7\xDB\x64\x02\xAD\x74\xA6\xB4\x8F\x08\x0B\x50\xA8\xA7\xF0\x6D\x07\xA8\xEB\xA7\xD7\x82\x41\xB0\x9D\xB7\x4A\xB1\x50\x15\xA8\xDA\xA4\x01\xA8\xE4\x79\x41\xB9\x9D\xB2\x3A\xDC\x66\x1D\xA8\xE0\xA6\x6E\x8E\x81\xA5\x3C\xA5\xA1\x97\x04\xA1\xA8\xC3\xA6\x05\xA8\xDF\x68\x85\xAD\x18\xAB\xA6\x6C\x50\x90\xA3\xED\x79\x17\xAB\x64\xA4\x07\xAF", - "\x10\x1B\x55\x47\x4F\xA7\x68\x36\xA8\xE5\xA6\x8A\x81\x87\xAD\x3C\xBF\x5F\xB5\x50\xFC\x6E\x3C\xA9\xE8\xA6\xF3\xA6\x3F\x50\x44\xA7\xB8\x41\x51\xD5\xA7\x36\x5F\x23\xA8\xF6\xA1\xC1\x6A\x44\xBB\x9E\xAD\xF3\x4D\xA8\xDE\xA7\x9F\x7C\x14\xA9\x7C\xA5\xB2\x73\xA2\xA4\x4F\xFC\x91\x56\xA9\xF3\xA7\x8D\x9A\x21\x09\x45\xAA\x9F\xB6\x23\xDD\xA8\xED\xA6\x00\x00\x18\xA8\x7E\xA7\x10\x03\xA3\xB3\x4F\xA5\x63\x66\xA8\xFB\xA7\x94\x99\x06\x59\x46\xB9\x9F\x90\x39\xA0\x7E\x6D\xA8\xFE\xA4\x44\x79\x8E\xAF\x3F\xB3\xA3\xB4\xF9\x74\xA8\x03\xA9\x27\xA9\x11\xAB\x2F\xA1\x42\x98\xA3\xBD\x4C\xCB\x6C\x7E\xA9\x04\xA8\x5F\x94\x88\xAC\x47\xB0\xA3\xB7\x51\x87\xA9\x17\x83\x40\xA8\x03\xAD\x80\x6A\x48\xB0\xA0\x8C\x52\xFB\xA8\x7D\xA4\x26\x59\x23\xAB\x82\xAB\xA0\x80\x00\x27\x6C\x0F\x02\x03\x54\xDE\x9E\x0E\xA9\x55\x82\xFB\x91\xA2\x8E\xD1\x1D\xA9\x54\xA8\x06\x78\x28\xAF\x8A\xAF\xF3\x63\xA5\x9A\x51\xFC\x91\xED\x9C\x4D\xA9\x0F\xAF\xF8\x97\x03\xAE\xA2\x80\xD2\x26\xA9\x5E\xA9\xA5\x90\x2C\xA9\x8C\xA3\x4B\xA4\xA3\xB6\xBC\x35\xA9\x67\xA8\x78\x6C\x2E\xAA\x8D\xAD\x51", - "\x7B\xA5\xAE\x51\xCB\x69\xBE\xA8\x39\xA9\x81\x9F\xF9\x9B\x49\xB5\x12\x81\x53\xF5\xA8\xBF\x8D\x63\xA9\x1E\xAF\x95\xA7\x70\x6A\xA6\xBF\x51\xDC\x66\xCE\xA8\x41\xAB\x5F\x93\x99\x11\x4D\xAB\xA4\x9B\xD1\x55\xA9\x8E\xA9\x6B\xA8\x9D\x78\x9B\xA4\x49\xA0\xA6\xBC\xDD\x25\xA0\x58\x53\x7E\x16\xD1\x9E\xFD\x9D\x4A\xBE\xA4\x97\x50\xE5\xA9\xA1\xA9\xDA\xA6\xB5\x84\x9B\xA6\x41\xAA\xA7\x9D\x1F\xEC\xA9\x1A\xA8\x00\xAA\xB5\x85\x02\xAF\x00\xB4\xA7\x92\x04\x76\xA9\x1B\xA1\xB4\x9F\x3D\xA9\x5E\xA7\x10\x15\x80\x95\x40\xF0\xA9\x1E\xA9\x2D\xAA\xDD\x9A\x22\x00\x4E\xAC\x7D\x97\x44\x9B\x9F\x17\x82\x80\xAA\x08\xAA\x95\xA2\x44\xBE\xA1\x84\x53\xAB\xA9\x4C\xA0\x74\xA8\x29\xAD\x64\x7A\x50\xA9\xA1\x95\x14\x85\x02\x0D\x55\x3E\xA5\x46\xAF\x86\xA4\x4D\x7B\xA8\x85\x53\xF4\x81\x1E\xAA\x88\xA9\x33\xA7\x20\x01\x52\xAD\xA8\xAC\x52\x8F\x02\x25\xAA\x24\xA8\xF2\x59\xA5\xAB\x44\xBA\x83\x6C\x54\xAE\xA9\xBF\x8D\x97\xAA\x39\xAC\x84\x72\x53\xA9\xA7\xAA\xF1\x35\xAA\x13\xAA\x06\x78\x4E\xAF\x94\xAF\xF3\x7B\xA9\xB1\x52\xFC\x91\x3E\xAB\x30\xA8\xCE\x59\xA8\xA6\x4B\xAB", - "\xA9\xBC\xDD\x44\xAA\xB9\xA9\xAF\x5C\x52\xAC\x97\xA3\x08\x6B\xAA\xBF\x52\xD6\x9C\x28\xAB\x2B\x9E\x53\xAA\x98\xA3\x4F\x73\xAA\x88\x53\xD5\xAA\x74\x7C\xAB\xAB\x32\xA9\xA6\xA7\x54\xBA\x99\x80\x00\x5A\xAA\xCF\xA8\xC6\x64\x58\xAA\x9A\xA2\x98\x92\x08\x23\x55\xD6\xA9\xC8\x90\x90\x7F\x59\xA9\x9B\xA6\x4D\x8B\xAB\x9D\x53\xF4\xA3\x5F\xAB\xAE\xAB\x45\x86\xAD\xAD\x4E\xB7\xA9\xB2\x55\x91\xA9\x66\xAA\x3A\x7D\xC7\x32\xA4\xAC\x0C\x9B\xAB\xA6\x54\x85\x98\x7E\xAA\x95\xA8\xD8\x59\xB0\xAD\x52\xBE\xA4\x44\x56\xB0\xAA\xF3\x69\xC3\xAB\x4C\xAA\x8D\x7A\x58\xB6\xA9\x94\xD3\x0D\xAB\x39\xAA\x12\x78\x64\xAC\xA7\xA5\xB2\x73\xAC\xBF\x54\xBF\x7E\x96\xAB\x30\xA9\x66\xAD\xA8\xA3\x58\xBC\xBB\x5B\x56\xC9\xAA\x5F\x97\xCF\xA8\x53\xAB\xC0\x62\x5A\xAF\xAA\x89\xD8\x25\xAB\x54\xAA\xF5\x5C\x6A\xAF\xAA\xAA\x5A\xBE\xAA\xAB\x56\xDB\xAA\x6F\xA9\x65\x1B\x6B\xAD\x67\xA3\x5B\xA4\xAB\x97\xD8\x35\xAB\x68\xAA\x69\x98\x6E\xAC\xAD\xA7\x3B\x7B\xAD\xAF\x55\xA7\xAB\xAE\xAB\x2B\x9E\x6F\xAD\xAE\xA2\x4F\xBD\x3E\x83\x57\xF1\xA9\xAD\xA6\xC2\x7F\x71\xA9\xA0\xA1\x1E\xAB\xD8", - "\x3A\x55\x9E\xAB\xD0\xAB\x8B\x83\x72\xAB\xA1\xAA\x10\x13\xAE\x96\x54\xDF\x6B\xD6\xAB\x16\xA8\x5C\xAD\x4A\x57\x00\x9C\xAE\xBD\x49\xDE\xAB\x1C\xAA\x88\x78\x78\xAF\xA3\xAD\x6C\x83\xAF\xBC\x55\xE2\x84\xE6\xAB\xBF\xAB\x48\xAE\x20\x09\x5E\xA2\xAC\xAD\x57\x85\xAB\x4D\x6F\xF7\xA8\x62\xAB\x99\x62\x5F\xAB\xAC\xAD\xF3\x75\xAB\x8E\xAA\xF1\xA8\xDF\x68\xBF\xA1\x59\xAA\xE3\x7C\x57\x94\xAB\xA7\x9C\xF6\xAB\x7E\xAB\xC0\xAD\x5D\xA7\xB8\x7F\x57\x97\xAB\xB1\xA7\xEE\x8F\x81\xA9\x8C\xAB\x64\x6B\xB0\x9C\x56\xCC\x58\x0E\xAC\xD0\xAB\x4A\x69\xC2\xA3\x5A\xA7\x9A\x94\x58\xA6\xAB\x03\x6D\x0B\xAD\x6A\xAD\xA3\x6A\x61\xAC\xAD\x90\x55\x8A\x02\x1D\xAC\xD8\xA8\x5B\xA2\x22\x01\x62\xA1\xAB\x8C\xF6\x25\xAC\xB6\xAA\x33\x9B\x43\x00\xC5\xA9\x5B\xB7\xA8\x80\x00\x2C\xAC\xBC\xAA\x17\xAC\x8C\xAF\xB7\xA9\x61\xA4\xB0\xB8\x55\xAB\xAC\x36\xAD\xF0\xAB\xAF\x8B\xC6\xA4\x5C\xAA\x72\x98\x83\x0A\x02\x98\x55\x87\x03\xA4\x57\x21\x0B\x6B\x5A\xB1\xAD\xC5\x45\xAC\xE4\xAA\x75\x74\x92\xAF\xBC\xA4\x29\x8B\xB2\xAA\x57\xA4\x93\x4E\xAC\xC1\xA8\x13\x59\xCA\xA0\x5F\xB0\xB7\x54", - "\x59\xF3\xAB\xD6\x5F\x2B\xAE\x7D\xA8\xA2\x7A\x65\xB9\xAF\xBF\x1A\xDD\xAC\xFD\xAB\x76\x78\x98\xA8\xC0\xA4\xC2\x63\xB3\x88\x58\x8C\x78\x66\xAD\x30\xA9\x9A\xAF\xC1\xA8\x09\x8B\xB3\x92\x58\xB7\x67\x6E\xAD\x0A\xAD\xD3\x69\xCE\xA8\x61\xB8\x84\x74\x59\x9B\xAC\x83\x61\x3B\xAE\x87\xAD\x4B\xA2\x11\x1A\xB3\xA2\x58\xF0\xA3\x7D\xAC\xBE\x6E\x9F\xAD\x67\xA3\x68\xA9\xB1\xB8\x0B\x85\xAD\x2D\xAD\xEF\x68\xA2\xA9\xC6\xAA\x68\xBE\xAA\x8B\x5A\xB4\xAC\x68\xA3\x65\x1B\xA3\xAD\xC7\xAA\x09\xA4\xFD\x53\x5A\xC8\xAB\x95\xAC\xC2\x7F\xA5\xAC\xB9\xAD\x26\xA2\x36\x47\x54\x9A\x4D\x82\xAD\x50\xAF\x45\x83\xD3\xA4\x5D\xA7\x08\x24\x5A\xD7\xAB\x0C\x6D\x53\xAE\x76\xAE\xA8\x9A\x10\x16\x54\x53\xA7\x12\x02\xD6\x53\x57\xAF\x43\x01\x3E\x5F\x10\x11\xB5\x8A\x04\x34\xAD\x0A\x02\xFA\x51\xAD\xAA\x22\x0A\x6B\xAA\x08\x2F\xA7\x3B\xAD\x0F\x03\x5F\xAE\x42\x04\x15\x02\x11\x0D\x05\x12\x04\x17\x54\x0F\x03\x0C\x57\x43\x00\x0A\x4F\x10\x15\x50\x4F\x04\x29\x53\x0F\x03\x59\x03\xC1\x6A\xDA\xA7\x00\x94\xB6\xB7\x58\x8A\x02\xD6\xAC\x23\xAF\x32\x69\xDB\xA9\x64\xBF\x3B\x9C\x5B", - "\xCC\xAC\xC6\x93\x6F\xAF\x93\xA8\xF2\x72\x6E\xB2\xB2\x92\x04\x65\xAD\x55\xAD\x02\x68\xBA\xA8\xCB\xA9\x60\x6B\xB7\x9B\x59\xBF\x8D\xEE\xAC\x2F\xAF\x3C\x69\xDE\xA1\x66\xB0\xE8\x74\x5B\xE4\xAC\x34\xA8\x6C\xAC\xDF\x6F\xDE\xA7\x66\xA4\xE1\x7C\x5B\xFB\xA1\xFF\xAC\xCE\xA9\xC0\xAF\xCD\xA3\x48\xB1\xB6\x97\x39\x83\xAE\x72\xAC\x78\x6C\xC2\xAD\xCE\xAD\x74\x6B\xB8\xB8\x59\x98\x98\xFA\xAD\x8B\x82\xC3\xAB\xCF\xA3\x60\x73\xB8\xBF\x59\xFC\xAC\x06\xAF\x42\xAB\x32\x1E\xE2\xA6\x62\xA4\xFD\x5C\x5C\x86\xAD\xDB\x91\x8C\xAF\xB5\xAF\x6D\x8F\x71\xA9\xB4\xB6\x24\x87\x02\x25\xAE\x46\xAC\x83\x69\xE5\xA0\x69\xAD\xB8\xBB\x5B\xAF\xAE\x12\xAE\x3A\x7F\x69\x51\xFE\x6F\x10\x13\xB9\x9F\xE2\x7F\x37\x00\x00\x9B\xAE\x22\x77\x7E\x39\x73\xB8\xC3\x5D\xE1\x0F\x02\x5F\x71\x9E\xAD\x18\x74\xFF\x6E\x85\x72\x08\x3A\x5C\x8E\x71\x8B\x71\xEE\x8F\xD1\xA9\x12\x72\x86\x76\x16\x8B\x5D\x97\x70\x10\x71\xA7\xAF\x04\x76\xE8\xAE\x73\xB3\xD3\x12\x5D\x9B\x70\x54\xAF\xA1\xAE\x41\x04\x03\x77\x75\xBD\x30\x59\x5D\x9B\x71\x05\x03\x3E\x72\xD0\xA8\xEC\xA6\x84\x61\xC4\x5F\x5D\xB7", - "\xAE\x48\x3B\x9A\xAD\xD5\xA9\xE9\xA1\x83\x5D\xBA\x89\x5D\xCB\x19\x6E\xAE\x1C\x72\x42\x01\xEE\xA5\x10\x1D\xC4\x46\x04\x74\xAE\x98\x70\xAE\x64\xDE\xA9\x13\x7A\x76\xBA\xBA\xB5\x5D\xE6\xAE\x7D\xAE\xB2\xAF\xE9\x10\xEF\xAE\x84\x6A\x08\x39\xA5\x50\x70\x06\x03\xC3\xAC\xD9\xA8\x4D\x1A\x78\xA8\xBB\x8C\x5E\xEB\xAE\x02\x71\xA2\xAF\x43\x05\xF1\xAB\x73\xA5\x08\x03\xE0\x13\xAF\x90\xAF\x21\x71\x45\x74\xF2\xA8\x74\xA5\x44\x0C\xCE\x1C\xAF\x4C\xAF\x83\x00\x04\x70\xF4\xA7\x81\x6E\xC3\x49\x5E\x99\xAF\x18\x70\xD2\xAF\x07\x76\xF0\xA8\x7A\xBC\xC0\x6A\x5E\xA2\x70\x12\x03\xD7\xAE\x42\x02\xEC\xA2\x7B\xA0\xC4\x4F\x04\x1F\x50\xB5\xAF\xD8\x08\xE6\xAE\xEF\xA9\x77\xBB\xBC\xA8\x5E\xFC\xAE\xAC\xAE\xDE\xAF\x3B\x19\xF7\xAF\x77\xB7\xBD\xB1\x5E\xBF\xAF\x5C\x66\xE2\xAD\xEF\xAF\x35\x7A\x7C\xB6\xBB\x85\x04\x4A\xAF\xA7\x16\xE5\xAD\xE1\xAF\x20\x06\x6B\xA7\x08\x3B\xA5\x0F\x02\xB7\x00\x89\x01\xF6\xA8\xFB\xAA\x7D\xBD\xBE\x9C\x5F\xDF\xAF\x0A\x03\xED\xAD\xF8\xAE\xFB\xA3\x7E\xA0\xBF\x87\x04\x62\xAF\xE7\xAE\xF2\xAD\xFA\xAF\x21\x08\x0B\x10\xB5\x92\x04\x6D\xAF", - "\x0F\x02\xCC\x50\xB0\xAA\x21\x02\x7F\xAA\x08\x3A\x02\x12\x02\xA3\x52\x85\x01\xFE\xAF\x20\x0D\xA4\x53\xBF\xBC\x5F\x92\x02\x4B\x54\xFF\xAE\x41\x01\x00\xBA\x10\x04\x07\x4F\x04\x06\xB0\x05\xB0\x89\x00\x02\xB7\x20\x0B\x80\xA6\x08\x0D\x60\x85\x02\x0F\xB0\x00\x01\x04\xB3\x02\xBA\x80\xB5\xC0\x87\x60\x96\xB0\x09\xB1\x0B\xB3\x43\x07\x17\x02\x11\x17\xBF\x9B\x60\xF8\xAF\x12\x02\x0E\xB3\x43\x03\xFF\xA0\x23\x8B\x66\x31\xA0\x26\xB0\x85\x60\x60\x02\x44\x01\x18\x02\x11\x02\x06\x2D\x60\xAF\xB0\x0F\x02\x17\xB1\x0C\xB0\x06\xBA\x10\x12\xC1\xB5\x60\xB4\xB0\x07\x02\x1B\xB1\x0E\xB0\x07\xB6\x10\x1A\xC1\xBD\x60\xBC\xB0\x05\x02\x1F\xB1\x41\x03\x18\x07\x70\x64\xC2\x87\x00\xC6\xB0\x23\xAE\x83\x00\x12\xB2\xDB\xAD\x51\x6B\xC2\x9D\x5B\xF6\x91\x4E\xB0\x70\xAF\x07\x99\x0A\xB3\x6E\xA4\xF6\x54\x61\xE6\xAD\x0F\x03\x2B\xB1\xBA\xAB\x8B\x6A\x85\xAC\xB7\x83\xD8\x5D\xB0\xEF\xAD\x79\x68\x18\xB2\xDE\xAB\x4C\x63\xC3\xB5\x5B\xBF\x8D\x66\xB0\x7C\xAD\x3B\x78\xE7\x59\x86\xBD\xB7\xAA\xF1\x6D\xB0\x61\xA8\x38\xB0\x67\xAA\x0E\xB4\x70\xB7\x6C\x74\x61\x89\xAE\xFE", - "\x9A\x85\x03\x1D\xB4\xE1\xAE\xD1\x96\x16\xBB\x61\x8F\xAE\x9E\x69\x3F\xB0\xC5\xA9\x10\xB4\xE7\x62\xC4\x97\x5C\xDF\xB0\x7C\x6E\x43\xB1\xC7\xA8\x46\x8A\x88\xA0\xB9\xBA\x37\xCA\xB0\x5E\xAB\x46\xB2\xC9\xAB\x8C\x9B\xCC\x12\xC4\xAA\x5C\x87\x93\x43\xB1\x42\xB1\x22\xB3\x13\xB7\x11\x96\xC4\xAD\x5C\xF0\x6D\x9E\xB0\x4A\xAE\x18\xB4\xCE\x7B\xA1\x4F\x08\x25\x62\x8A\x02\xA7\xB1\x83\x01\x2A\xB6\x20\x0B\x8A\xA5\x08\x2D\x62\x80\x00\xAF\xB1\x58\xB2\x44\x02\x16\xB6\x8A\xB3\xC5\xB6\x62\xB5\xB1\xB8\xB0\x85\x01\x87\x57\x21\x0B\x8B\xBA\xC5\x92\x04\x3D\xB1\x07\x02\x60\xB2\x41\x02\x18\xB5\x10\x04\xC6\x80\x00\x46\xB1\xC8\xB1\x5F\xB2\x32\xB4\x17\xBB\x8C\xBE\xC5\x8C\x63\x8F\x02\xC6\x00\x89\x01\x34\xB0\x1A\xB2\x8D\xB5\xC6\x94\x63\xD7\xB1\x0A\x03\x69\xB1\x36\xB6\x1A\xBB\x8D\xB8\xC6\x87\x04\x5A\xB1\xDF\xB0\x6E\xB1\x38\xB7\x21\x07\x0C\x12\x08\x08\x03\x66\xB1\xE8\xB1\x87\x03\x39\xB2\x1D\xB9\x8E\xAA\x08\x2B\x63\xEE\xB1\xED\xB1\x83\x03\x3B\xB2\x1E\xB1\x8F\xA6\x08\x33\x63\xF6\xB1\xF5\xB1\x82\x03\x3D\xB5\x20\x09\x0C\x07\xB8\x7D\x63\x87\x80\xFF\xB1", - "\x24\xB0\x3F\xB4\xEF\x61\x90\xAC\xC2\x89\xD8\x05\xB2\x4F\xB1\xA5\x90\x42\xB2\x0A\xBC\x16\x8B\xC8\x95\x61\xC6\x93\x0E\xB2\x2C\xB2\x42\x01\x22\xBB\x85\xAB\xA9\x54\x64\xDE\xB0\x9E\x69\x8B\xB1\x18\xB3\x99\x6A\x91\xA4\xC3\x9D\xD4\x1D\xB2\x67\xB1\x4A\xA8\x48\xB2\x0D\xB0\xD1\x63\xC9\xAE\x61\xED\x79\x26\xB3\x7D\xA1\x4A\xB4\xB3\xAB\x92\xB5\xC3\xA5\x55\x8F\x02\x2D\xB2\x3C\xB3\x61\xA0\x26\xB4\x90\xB5\xC9\x9F\x5A\x80\x00\x31\xB2\x3E\xB1\x01\x69\x27\xB0\x88\xAD\xBA\x7C\x64\x83\xB1\xA9\xA6\x89\x03\x4F\xB7\x10\xB1\x69\xA2\xCA\x9E\x55\xC3\xB2\x8B\xB0\x6B\x84\x52\xB6\x11\xB1\x2D\x8B\xCA\x93\x62\xBD\x97\x4E\xB3\x4B\xB2\x9F\x59\x2A\xBF\x89\xBB\xC9\xB6\x64\x82\xB2\x38\xB3\xAB\xB2\x41\xB0\xE2\xA7\x10\x0A\x06\x07\xDC\x5E\xB2\x07\x80\xB0\xB0\x56\xB2\x2C\xBB\x95\xBE\xA4\x64\x65\x89\xB2\xFC\x91\xB3\xB0\x43\xB0\xC1\x9A\x96\xAF\xC8\xAC\xFF\x6D\xB2\x12\xB3\xAE\xB0\xDF\x68\x2E\xB5\x91\xB7\x9D\x74\x65\x98\xB2\x4D\x6F\xBB\xB3\x46\xB5\xA3\x6A\x97\xBE\xC8\x89\xD8\x7D\xB2\x21\xB2\x07\x96\x41\x00\x30\xB4\x92\xBF\x35\x84\x66\xA7\xB2\x10\x7B\xC3", - "\xB3\x3E\xA2\x31\xBC\x59\xAC\xCC\xAE\x64\xF8\x9F\x12\x02\xC7\xB2\x4C\xB1\xAD\xAB\xCC\x12\xCC\xBA\x64\xDB\x68\x96\xB3\x9E\xB0\xBC\x69\x33\xB0\x94\xAD\xA0\x8A\x04\x1C\xB3\x44\xB3\xBC\xB3\x5C\xB6\xAB\xA0\x9A\xA9\xCA\xA0\xFC\x25\xB3\x4C\xB3\x87\x8D\x08\x88\x35\xBF\x94\xBD\x22\x8F\x04\x2C\xB3\x52\xB2\x7C\x84\x6C\xB5\x2A\xBF\xB5\x93\xCD\xA2\x62\xCB\x69\xB6\xB2\x4C\xAF\x3C\x69\x37\xBC\x69\xA5\xD9\x7C\x66\xA5\xAD\x83\xB3\xD1\xB3\x4D\xB1\xE8\xA1\x74\xAB\x06\x2E\x5F\x8F\x02\xC6\xB3\x87\x00\x33\x07\x38\xBA\x10\x0B\xCE\x8F\x04\x4D\x01\x12\x02\x67\x01\x3E\xB0\x00\x0F\x0C\x11\xCE\x93\x67\xD2\xB3\xEC\xB1\x87\x00\x76\xB0\x1E\xBA\x9D\xB7\xCE\x9E\x67\xD9\xB3\x0A\x03\xED\xB0\x3D\xB5\x3B\xB0\x9E\xA7\x08\x22\x67\xF8\xB1\xE4\xB2\xEE\xB1\x78\xB7\x3B\xBA\x9E\xA6\xCF\xAC\x67\xE3\xB3\xEB\xB3\xF2\xB2\x41\x00\x1A\x03\x9D\xB4\xCF\xB2\x67\x85\x02\xF6\xB3\xF6\xB3\x7C\xB5\x3E\xBC\x9F\xB7\xCF\x80\x00\x79\xB3\xF0\xB3\x83\x00\x80\xB0\x3D\xBA\x10\x03\xD0\xBA\x63\x92\x02\x06\xB4\x00\x03\x3E\xB7\x3F\xBD\x9F\xBA\xCF\xB8\x67\x8D\xB4\x01\xB5\xFD\xB2", - "\x7F\xB1\x41\xBB\xA0\xB1\x06\x12\x04\x52\x01\x12\x03\x69\x01\x86\xB3\x43\xBF\x10\x1A\xD0\x9D\x68\x9C\xB4\x0A\x02\x0F\xB5\x88\xB0\x44\xB7\x10\x02\xD1\xA5\x68\xA4\xB4\x06\x02\x13\xB5\x8A\xB0\x45\xB5\x10\x0A\xD1\x85\x04\x54\x01\x12\x02\x18\xB7\x43\x02\x46\xBA\x10\x14\xD1\x87\x04\x36\xB4\x06\x02\x1C\xB7\x8B\xB1\x46\xBC\xA3\xB3\xD1\xBD\x68\xB5\xB4\x3F\xB5\x1B\xB5\x90\xB1\x47\xB2\x11\x15\x06\x29\x7F\x06\x02\x46\xB4\xDE\xAC\x9A\x11\x49\xBB\x78\xA5\xD2\xA8\x5E\x97\xAF\x0A\x02\x26\xB4\xDA\xA8\x4A\xB7\x10\x12\xD2\x95\x5E\xCB\xAF\xA4\x7E\x2B\xB5\xE7\xAA\xF3\xAF\x9A\x7A\xD2\xA1\x5E\x86\x02\x10\x70\x2F\xB5\xE9\xAE\x49\xBA\xA4\xA4\xD3\xA4\x5D\x9C\x70\x62\xB5\xD5\xAD\x95\xB0\xF5\xA6\x66\x49\xD3\xA5\xE0\x66\xB4\x68\xAE\xE7\xAC\x00\x06\x4D\xBD\x82\x70\xD3\x97\x69\xC0\x70\x76\xB5\x2D\xB4\x96\xB4\xF0\x74\xA7\xB8\x6F\x39\x69\xDF\xB4\xC5\xAE\x85\x03\x07\x55\x4F\xBE\x79\xAC\xEC\x44\x6A\xDC\xB4\xF3\x75\x43\xB5\xD9\xAE\xF8\xAF\x10\x0A\xD4\xA7\x2E\x56\x01\x7F\xB5\x0B\x73\xF4\xAE\x20\x07\x0D\x07\xD2\x85\x04\x15\xB5\x65\xB5\x87\x00\xA6", - "\xB5\x49\xBA\xA9\xAF\xD2\x92\x5E\x8A\x02\x9B\xB5\x29\xB7\xA7\xB7\x20\x01\xAA\xB7\xD3\x9C\xCD\x25\xB5\x7A\xB4\xE0\xAC\xA9\xB0\xF5\xA0\x81\x68\xD5\x80\x6A\x80\x00\xA6\xAF\x4B\xB4\xEA\xA8\x4D\x1E\xAA\xB7\xC0\x5C\xE0\x35\xB5\x6A\xB4\x4A\xB4\x9B\xB2\x22\x08\xAB\xAF\xD3\x9D\x6A\xBC\xAF\x72\xB5\x5E\xB5\x9D\xB7\x57\xB4\x76\xB8\xD3\x84\x6B\xE8\xAE\xAA\xB4\x5D\xB6\xF0\xAC\x57\xB8\x7A\xA1\xD6\x88\x5F\x95\x72\xC2\xB5\xB7\xAC\xB3\xB0\x58\xB0\x78\xA0\xD5\xA8\x5E\xA7\x17\xD8\x01\x69\xB4\xD9\xAB\x52\xB5\x10\x19\x06\x12\x04\x5E\xB5\x0F\x02\x6D\x02\x44\x02\x5C\xBF\x10\x1B\x06\x12\x04\x66\xB5\x0F\x02\x6E\x02\x44\x05\x1B\x02\x11\x1E\x06\x12\x04\x5F\x01\x12\x02\x70\x02\x44\x01\x1C\x02\x11\x02\x07\x12\x04\x6A\xB5\x0F\x02\x7B\xB7\x43\x03\x1C\x07\xAF\xB2\x08\x3C\x6B\x8F\x02\xE4\x01\x7E\xB4\xC0\xB2\x22\x05\x0E\x02\xD8\x8A\x04\x05\xB6\x0F\x02\x73\x02\xC1\xB7\x20\x07\x0E\x0D\xD7\x92\x04\x0A\xB6\x0F\x03\x86\xB7\x43\x00\x1D\x0B\xB0\xA6\x08\x29\x03\x0E\xB6\x13\xB6\x89\x03\xC5\xB7\x21\x0A\x0E\x18\xD8\x8A\x04\x1D\xB6\x0F\x03\x75\x02\x44\x04", - "\x1D\x02\x11\x0D\x07\x25\x6C\xA7\xB6\x0F\x02\x93\xB5\xCA\xB0\x65\xBA\x10\x0A\xD9\xAD\x6C\xAC\xB6\x07\x02\x97\xB5\xCC\xB0\x66\xB6\x10\x12\xD9\xB5\x6C\xB4\xB6\x05\x02\x9B\xB5\x41\x06\x1D\x02\x11\x02\xD9\x8F\x04\x3C\xB6\x0F\x03\x77\x01\xCF\xB2\x22\x02\xB4\xAC\xD4\x82\x6A\xD5\xB5\x07\x02\x78\x02\x44\x02\x69\xBF\x10\x0C\xDA\x8A\x04\x4E\xB6\x49\xB7\xA5\xB6\xD4\xB5\x69\xB3\xB5\xAF\xDA\x95\x6D\xD1\xB6\x54\xB7\xAC\xB6\xD5\xB2\x6B\xB7\x10\x11\x07\x12\x04\x5E\xB6\x0F\x02\xB0\xB6\x42\x02\x6C\xB7\x10\x12\x07\x07\xDC\x66\xB6\x07\x80\xB4\xB4\x56\xB2\x6D\xB5\x96\xAD\xBA\x6C\x6D\xE8\xB2\x3F\x7F\xB7\xB7\x5A\xB4\x00\xA2\xB7\xAE\xCB\xAC\x05\xF5\xB6\x71\xB2\x83\x00\xDE\xB5\x2E\xB3\x58\x7B\xDB\xB8\x65\xF0\x6D\x7E\xB7\xBD\xB1\x82\x69\x70\xBE\x97\xA3\xB0\x44\x6E\x81\xB3\x1D\x6B\xC3\xB5\x61\xB5\x92\xAA\xB8\xA8\xCC\xBF\x1A\x8D\xB7\x61\xA8\xC8\xB4\x67\xAA\x72\xBF\x98\xBF\x59\x54\x6E\x93\xB3\x29\x93\x87\x03\xE5\xB7\x32\xB4\x99\xB2\x08\x1B\x6E\x9A\xB3\x05\x69\xCF\xB5\x67\xB1\x74\xB4\xE7\x62\xDD\xA1\x66\x80\xB7\x7C\x6E\xD3\xB6\x69\xB1\x06", - "\x5A\xBA\xA9\xCD\xAF\x2B\xD6\x85\xAD\xB7\xD6\xB0\xD7\x8A\x73\xB7\xE5\x91\xDD\xB1\x66\xFA\x8C\x05\x02\xDB\xB4\x6D\xB6\x9A\x8A\xBB\xB7\xCD\x89\x6E\xA9\xB7\xC0\xB7\x8B\x81\xEF\xB2\x37\xBB\x4C\x63\xDE\xBD\x66\x81\xAC\x05\x03\x79\x02\x44\x02\x79\xBF\x10\x0C\xDE\x8A\x04\x4E\xB7\x07\x02\x7A\x02\x44\x02\x7A\xBF\x10\x14\xDE\x8A\x04\x56\xB7\xD1\xB7\xE9\xB6\xF6\xB5\x7A\xBB\xBD\xB7\xDE\x9D\x6F\xD9\xB7\xDC\xB7\xF0\xB6\xF7\xB2\x7C\xB7\x10\x15\x07\x12\x04\x66\xB7\x0F\x02\xF4\xB6\x42\x02\x7D\xB5\xBE\xA7\xDF\xAE\x6F\xE9\xB7\xEF\xB7\xF5\xB5\xFC\xB5\x7D\xB0\xBF\xB5\xDF\xB2\x6F\xF6\xB7\xF5\x27\x39\x34\x95\xB1\xF2\xA0\x74\xA6\xC3\x71\xA0\x49\xB5\x05\x02\x08\x71\xAC\xB0\x03\x7C\x81\x7C\xC0\x66\x99\x62\xAE\x72\xB5\x4A\x1A\xB1\xB5\xE9\xA0\xF2\x6F\x67\x32\x69\x8B\xB8\xD2\xB4\x49\x70\xD2\xB0\x14\x7A\x9D\x56\xD4\xAF\x6A\xE8\x14\x55\x70\x4F\xB5\xFF\xB4\xF7\xAB\xBF\xA9\xD5\x9C\xCD\x15\x71\x8C\x66\xA8\xAC\xEA\xAB\x80\xB9\xC1\xBC\xBD\x9C\xE0\x36\xB5\xBB\xB4\xDE\xAE\xD8\xA9\x05\x73\xC1\xBA\xD3\x95\x32\x20\xB8\x8C\x7A\x18\xBB\xBC\x77\x02\x7F", - "\xCE\x0C\xE1\x86\x6D\xC8\xB5\x1F\xB8\x33\x73\x32\x1E\x86\xB7\xB4\xBC\xBD\xA7\x2E\x12\xB5\x12\x02\x7B\x02\x44\x07\x1E\x0C\x26\x24\xE2\xB5\xDF\x05\x02\x46\xB8\x85\x01\x07\xB8\x00\x09\xC4\xA4\xBA\x9B\x70\x8A\x02\x4D\xB9\x42\xB4\xE9\x79\x8A\xB8\xA8\xA4\xFC\x54\x71\x80\x00\x10\x71\x2B\xBB\x00\xBF\x8A\xB8\xA6\x17\xE2\x9C\xE0\x5E\xB8\x43\xB9\x3C\x71\x18\xBE\x57\xB0\xC5\xB2\x08\x32\x69\xD7\xB8\x95\x19\x2B\xB8\x04\xBE\x20\x0A\xC6\xA5\x84\x57\x71\xEF\x19\x57\xB9\x33\xBA\xFF\xB3\x8C\xBC\xC0\xAB\x66\x31\x71\xAD\xB8\x4C\xB8\xEA\x2F\x41\x07\x8A\xBC\xAD\xA0\x00\x38\x03\x12\x02\x7F\xB9\x87\x01\x3E\x02\x22\x03\xC8\xAF\x08\x3A\x03\x12\x02\x87\xB9\x87\x03\x3E\x00\x90\xB2\x11\x0B\xE4\x8F\x04\x01\xB9\x0A\x02\x7E\x00\x23\xBF\x21\x02\xC9\xAF\xE4\x92\x04\x7D\x01\x16\xB8\x4C\xB9\xA6\xB2\x21\x0A\xC9\xBC\xD4\x9C\x72\x9A\xB8\x59\x71\x4B\xB8\x28\xBF\x20\x01\x74\xBD\xE4\xB8\x70\x95\x72\xA6\xB8\x53\xB4\xE3\x61\x95\xBA\xA7\xB0\xC0\x6C\x72\xAF\xB5\x03\xB9\x57\xB9\x09\xBF\x93\xB6\xC2\xA2\xE5\xB5\x72\x8F\x02\xB2\xB8\x31\xB8\x2E\xB8\xF5\xA2\x76", - "\xB9\xE5\x92\x70\xB7\xB8\x06\x02\x5F\xBB\xB0\xB4\x96\xB5\xAC\xBC\x9A\x42\x73\x91\xB8\xC4\xB8\xB4\xAF\x3B\x1F\x98\xBC\x89\x78\xE3\x8C\x73\xD5\xB8\x21\x89\x67\xBB\x9E\xB6\x5A\x82\xCD\xB2\xD3\xBE\x03\x36\xB9\x82\xAE\x6C\xB8\xDA\xAD\x8F\xBA\x86\x5A\x7A\x33\x6A\x97\x02\xDF\xB8\x8F\x03\x28\xBE\x20\x01\x74\xAA\x43\x57\xE0\x4B\xB8\xE6\xB9\x39\xBA\x38\xBC\xF7\xA0\xC0\xB3\x08\x2C\x6A\xE0\xB9\xBC\xAF\x01\xB9\x3A\xBF\x88\xBE\xCE\xB7\xE5\xBE\x04\x2D\xAF\xF0\xB8\xB2\xAE\x9B\x4C\x97\xB9\xCF\xB1\xD3\xB8\x71\xF3\xB9\xC3\xB9\xAC\x03\xB3\xB4\xB1\x70\xD0\xA8\xE6\x82\x74\xCB\xB5\xEB\xB8\xB2\xAE\x9C\xB5\xA0\xB2\xC5\xB0\x11\x8C\x74\xD0\xB9\x20\x7F\x87\xBB\xA2\xB5\x87\xBB\xAC\x52\xE8\x9B\x32\x28\xAF\x7D\xB9\x00\x01\xD8\x05\x90\x1A\xD1\xBB\xE4\xAA\x76\x61\x06\xB3\xB9\x8F\xB8\x07\xBB\x54\xB0\x4F\x40\xE9\x98\xE1\x24\xB9\xA9\x44\x93\xBB\x0D\x24\x6B\x6D\xD1\xA5\xE6\x8C\xCE\x2D\xBA\x68\xAE\x08\x70\x4C\xBF\x4A\xB3\xC0\xB3\xE9\xBA\x69\xE8\x14\x36\xBB\x57\xB4\x07\x71\xA7\xB8\xC2\xA5\xC2\x2A\x74\xDE\xAE\x3E\xBA\x15\xB9\x4A\xBC\x5A\xB0\xCC\xA8", - "\x30\x7F\x74\x8E\x49\x43\xBA\x97\xB8\x63\x7C\xA7\xBA\xC3\xA9\xEA\x8A\x73\xCE\xBA\x57\xB4\x39\xB4\x53\xBB\xA5\xB5\x91\x73\xEA\xB5\x71\xD0\xBA\x7A\xB4\xA9\xBB\x51\xBC\x82\xB5\xD2\xBC\xBD\xBD\x71\x82\x00\x61\x07\x01\x01\xD8\x04\x00\x0C\x6C\x5A\x7D\x7C\xAA\x36\x00\x43\xAC\x63\x55\x74\x19\xA3\x0C\xAB\x57\x01\x29\x75\xCA\x55\xD1\x1B\xC4\x48\xAF\x50\x07\x0F\xD6\xAE\x56\x71\x75\xC2\x55\x46\x71\xBA\xB8\xB4\x51\xBA\x1C\xAE\x3C\x55\x7A\x00\x7A\xBA\x65\xBA\x46\x5E\xAF\x53\x07\x00\xD8\xAD\x2F\x43\x31\x3C\x55\x3C\x01\xC2\xBA\x1E\x38\x4D\x1C\x2B\x0C\x0E\x3D\x00\x0A\xBB\x2D\x5E\x08\x70\xAF\x56\x07\x00\xD9\xA8\x67\x5D\x01\x01\xBB\x00\x01\xFA\x00\xAF\x01\xB1\x4A\x05\x18\xEC\x9A\x76\xCE\x5C\x54\x00\xCF\xB8\x99\x0C\x5D\x3C\x04\x02\xED\x9A\x38\x15\xBB\x92\x5A\x23\x02\x69\xBA\x21\x00\x04\x08\xED\xB5\xB8\x40\x00\xAB\xBA\x8B\x0E\x6B\xBD\x02\x6A\x03\x11\xED\x80\x19\x33\xBB\x36\x0A\x1A\x02\x6D\xB8\x47\x43\xDB\xA2\x5C\x5F\x00\x3B\xBB\x37\x11\xD9\xB9\xE4\x56\x02\x00\xDC\xA5\x02\x33\x76\x9C\x55\xC0\xBA\x23\x03\x6C\xB9\xA3\x0E\xC8\xB1\x6E", - "\x0C\x07\x47\x00\xB3\xBB\xC3\x04\xFB\xB2\x38\x1F\xD9\xB0\x57\x46\x04\x7F\xB5\xCE\xBB\x69\x27\x6C\xBC\xED\x6A\xAF\xA1\x56\x49\x01\x33\xBB\xB9\x6D\x2A\x01\xC9\x46\xAE\xB0\x98\x39\xB5\x56\x01\x63\xBB\x7B\xBA\xC0\x33\xCF\x54\x03\x7C\xAB\x4A\x02\x33\x76\xBF\x56\x1F\x50\x5E\x57\x12\x03\xB6\xB8\xF3\x44\x9E\x3C\xAA\x4C\x00\xF4\xBB\xFA\x72\xAF\x55\x09\x0F\xDE\xAA\xE1\x41\xAB\x4E\x00\xB3\xBA\x5E\x06\xF0\x7C\x57\x5F\x04\x1D\xEF\xB0\xFC\x78\xBA\x50\x00\x03\xBD\x6C\x88\xAF\xB1\x05\x0A\xF0\xAB\x1D\xF8\xBA\x52\x00\x07\xBE\xC8\x88\xAF\xB3\x05\x12\xF0\xB6\x25\xF8\xBA\x54\x00\x0B\xBD\x3F\x92\x58\x55\x05\x13\xED\x82\x07\x4B\x97\xBC\x54\x2B\x02\x87\xB9\xA8\x92\xAC\x57\x02\x1A\x78\xD2\x9D\xC0\x54\x2C\x01\x80\xBB\x25\xA2\xAC\x59\x02\x2B\x78\xBF\xA0\x78\xBA\x2D\x02\x86\xBB\xFE\x90\xAC\x5B\x02\x33\x78\xF8\xBA\x5C\x01\xD9\xBB\xB8\x1F\x01\xAC\xAB\x5D\x02\x33\x76\xA9\x44\x1A\x00\xE6\x01\x7B\x4E\x0B\x03\xDB\xA7\x72\x1B\x00\x42\xBC\xD6\xBA\xF4\x87\x6C\xBC\x03\x7D\x00\x08\xF2\xAF\xAB\x28\x21\x77\x1C\x07\x02\x93\xB9\x5E\x50\x98\x21\xBA\x94", - "\x02\x68\xBB\x32\x44\xE9\x6E\xF6\x53\xCA\xBD\x53\x44\x33\x13\x34\x17\x00\x5C\xBD\xA0\x48\x99\x08\x02\x7F\x00\x01\xF3\x99\x76\xE4\x0C\x1F\x50\x08\x02\x99\xBD\xBA\xBF\x88\x7A\x5F\x6B\x79\xE4\x0C\x17\x70\x0A\x03\x9B\xBB\x43\x18\xC2\x0B\x00\x33\x79\xA8\x21\x7D\xB8\x7C\x00\x96\xBC\xCC\x05\xC8\x11\x00\x37\x79\x80\x33\x68\x15\x0A\x03\x9F\xB8\x5B\x30\x7E\x13\x00\x03\x7A\x99\x30\xA6\x71\xA9\x03\xA1\xBD\x5D\x3B\xE3\xB8\xEB\xA0\x01\x33\xBB\x7A\x07\x69\xA0\xAF\x01\xCB\xB6\xF7\x41\x1F\x7C\xAA\x61\x00\x1A\xBC\x95\xA2\xB0\x52\x0C\x03\xDB\xBE\x1A\x1D\x3B\x13\xBD\x64\x0D\x9F\x56\x82\xA2\x58\x53\x06\x0F\xF1\x8A\x04\x66\xA5\xC0\x54\x32\x03\x6C\xB8\x70\x01\x44\xBC\x55\x65\x01\x2B\xBD\x12\x02\x76\xA4\xB0\x56\x0C\x00\xEB\xA6\x98\x82\xAB\x67\x00\xB5\xBD\x75\xA4\x5E\xB8\x0D\x0A\xE1\xA1\xB2\x81\xAB\x69\x00\x1A\xBC\x27\xAC\xAF\x52\x0D\x0A\xE1\xB5\xBE\xBF\xAA\x6B\x00\x1A\xBD\x5E\xAC\xB0\x54\x0D\x0A\xE1\xA4\xB6\x82\xAB\x6D\x00\x1A\xBC\x66\xAD\xB0\x56\x0D\x0A\xE1\xB0\xB6\x81\xAB\x6F\x00\x1A\xBD\xA5\xAC\xAF\x50\x0E\x0A\xE1\xAC\xC1\x82\xAB", - "\x71\x00\xA6\xBD\x60\xB0\x5E\xBA\x0E\x01\xEE\xA6\x08\x0E\x64\xBC\x55\x73\x01\x72\xBD\x41\x05\x3A\xB2\xAC\x54\x03\x2A\x7B\x80\x00\x16\xB4\x61\x55\x1D\x03\xB6\xB7\x8F\x32\xD7\xBA\x71\x14\xBD\x2D\x5E\x7A\xB6\xB0\x56\x0E\x0A\xE1\xA8\xD8\x99\x77\x8C\x9D\xCB\xBA\x89\x00\xC8\xB1\x58\x58\x07\x01\xF8\x8F\x04\x24\xB6\xC2\x55\x3C\x02\xC1\xBA\x21\x00\xB4\xA1\x56\x7A\x01\x6F\xBD\x64\xB7\x5F\x57\x1E\x03\xE1\xB5\xB6\xB8\xEB\xBC\x01\x14\xBE\x06\x02\xEC\xB7\xAF\x55\x0F\x08\xF1\xA5\x08\x05\x72\xC1\x55\x7E\x01\xE3\xB9\x3F\xBF\x57\x5F\x07\x02\xF9\x81\x75\xC1\x55\x80\x00\x93\xBD\xF1\x40\xB3\xBC\x2B\x01\x04\x02\x77\xF1\x56\x2C\xBE\x29\x57\xCB\xB9\x24\x01\xF3\xAF\x08\x03\x02\x33\xBE\x3C\x03\x9A\xBE\x42\x04\x10\x08\xF3\xA8\x5C\x7A\x7C\x87\x02\x85\x01\xDE\xB8\x72\x4F\xE7\xB6\x10\x06\x04\x02\x7D\x8F\x02\x1C\x00\xA2\xBD\x41\x07\x10\x08\xDB\xA5\xA2\x4A\x7D\x80\x00\x88\x01\xA6\xBE\x98\x47\xE9\xB9\x08\x12\xFA\x99\x0B\x4F\xBE\x8A\x00\xAB\xBF\x41\x01\x05\x0F\xF4\xAB\x04\x1A\x7D\xBA\x6E\x4F\xBE\x46\x03\xD7\xBE\x06\x7F\xF4\xAD\x04\x33\x76\xF1", - "\x09\x38\x01\xA7\xBE\x23\x03\xB6\xB6\x9A\x3E\x01\x0F\x7D\x8F\x01\xB3\xBA\xD4\x30\x11\x07\xE9\xB0\x09\x13\xED\xAC\x6B\x4A\x00\x4F\xBF\x48\x03\x6C\xB9\xB1\x42\x05\x0F\xFA\x92\x02\x7B\xBE\xC0\x81\xA7\xBF\x24\x03\xB6\xB1\xB6\x18\x02\x0F\x7D\x94\x01\x1A\xBD\x31\x03\xD3\xBD\x12\x09\xDF\xAD\x9B\x0F\x7D\x96\x01\xB3\xBB\x57\x2B\x19\x07\xE9\xB7\x09\x1A\xF0\x81\x00\x68\xBB\xBC\x04\x4C\x01\xE3\xBD\x78\x48\xDE\xAC\xF3\x86\xBC\x4B\x02\x9D\xBE\x2F\xBF\x3A\x48\xF3\xB4\x66\x11\x41\x45\x00\x21\xBF\x1B\x15\xE4\x4B\x01\x00\xF5\xB8\x0A\x26\x89\x46\x00\x2C\xBF\x80\x32\xFA\x5E\x41\x07\x1B\x00\xDC\xB9\x04\x11\x7E\x8C\x8D\x4F\xBE\x4D\x03\xE6\xBF\x20\x0E\x06\x00\xEE\xAE\x88\x7D\x92\xBE\xBF\xD9\x33\xCF\x52\x0F\x0F\xF4\xBB\x04\x2F\x7B\xFB\x00\x4F\xBE\x4E\x02\x86\xBC\xF8\xB2\xAC\x5D\x04\x3B\x7E\xEB\x9E\x4F\xBE\x4F\x03\x6C\xB9\x98\x58\x07\x0F\xFA\x9F\x02\x33\xBB\x0A\xA2\xCC\xB8\xBE\xBD\xAF\x5A\x08\x0F\xFA\xA0\x02\x4F\xBF\x05\x03\x44\x03\xD3\xB9\x14\x0A\xE1\xB4\x04\x0F\x7D\xA2\x01\xB3\xBA\x26\x5A\x23\x07\xE9\xB3\x0A\x09\xFF\x92\x04\x6B\xBF", - "\xC2\x54\x52\x00\xF8\xB8\x00\x00\x09\x0F\xFA\xA5\x02\x73\xBF\x99\x01\xA7\xBE\x29\x02\xC3\xB0\x0A\x0F\xFA\xA7\x02\x7C\xBF\x4F\xBE\x54\x03\xFC\xBD\x14\x0F\xF4\xA9\x05\x03\x80\xCF\xBE\xAA\x01\xD9\xBB\x03\x55\x18\x0F\xF4\xAB\x05\x0A\x80\x92\x02\xC7\x01\xA7\xBC\x2B\x03\xFE\xB9\x0C\x0F\xFA\xAD\x02\x1A\xBC\xD3\x01\xA7\xBE\x2B\x00\x03\xCF\xF4\xAF\x05\x1A\x78\xDA\x01\x4F\xBE\x58\x03\x07\xC7\xE9\xB1\x0B\x13\xED\xA9\x36\x5D\x01\x4F\xBE\x59\x02\x09\xC3\x5D\xBF\xF4\xB3\x05\x1A\x78\xE8\x01\x4F\xBE\x5A\x02\x86\xBD\x1D\x0F\xF4\xB5\x05\x1A\x78\xF0\x01\x4F\xBE\x5B\x03\xFC\xBB\x1E\x0F\xF4\xB7\x05\x33\x7F\xF6\x01\x4F\xBE\x5C\x03\xFC\xB8\x1F\x0F\xF4\xB9\x05\x1A\x78\xFE\x01\x4F\xBE\x5D\x03\xFC\xBD\x1F\x0F\xF4\xBB\x05\x33\x76\x95\x0F\x0F\x00\xD2\xBF\x43\x04\x17\x0F\xE3\xAF\xC0\x52\x81\x8A\x02\xBD\x01\x27\xC3\x55\x07\x0A\xCC\x80\xBA\x02\xE2\xBD\x5C\xC0\x06\x03\x5F\x02\x17\xC7\x15\x60\x06\xC5\x08\x00\x03\x73\xBF\x17\x01\x32\xC0\x00\x01\x18\x03\xDB\xAC\x8B\x1E\x00\x6A\xC0\xC2\x01\xD9\xB8\xF3\x60\x04\x0A\x06\xC3\x06\x2D\x81\xA1\x60\x6A", - "\xC0\x62\x02\x1C\xC0\x29\x6A\x06\xC5\x06\x37\x81\xC3\x60\x6A\xC0\x63\x03\x1E\xC6\x21\x6A\x06\xC7\x06\x1A\x78\xA9\x00\x6A\xC0\x64\x02\x8E\xBF\xFE\x6A\x06\xC9\x06\x0B\x82\xA8\x70\x6A\xC0\x65\x01\x15\xC2\x0D\x7A\x06\xCB\x06\x2F\x7B\xB6\x00\x6A\xC0\x66\x03\x18\xC7\xB6\x0A\x06\xCD\x06\x1B\x82\x89\x15\x6A\xC0\x67\x03\xFC\xB8\x08\x00\xFB\xB8\xD6\x37\xA9\x41\x00\xA5\xC1\x0C\x31\xE5\x0B\x09\x0A\x06\xCF\x06\x1F\x82\xE5\x7B\x6A\xC0\x68\x03\xBB\xB9\x09\x0A\x06\xD1\x06\x33\x76\x97\x6D\x47\x00\x35\xC2\x34\x03\xB6\xBA\x6A\x79\x02\x3B\x79\x9B\x14\xAA\x6C\x2C\x03\x2F\xC0\x15\x2C\x2B\x1F\x02\x2A\x81\xD3\x01\x1A\xBC\x31\x02\x1A\xC4\x1A\x0F\xEE\xAA\x03\x2A\x81\xD5\x01\xCD\xC0\x35\xC2\x35\x07\xDD\xB7\x07\x0A\x03\xD7\x03\x73\xBF\x7C\x00\x35\xC0\x36\x07\xDD\xB4\x08\x0A\x03\xD9\x03\x1A\xBC\x80\x00\x35\xC2\x36\x02\xC3\xB2\x08\x0A\x03\xDB\x03\x2F\xC1\x7E\xA4\x35\xC0\x37\x00\x1D\xC3\x09\x0A\x03\xDD\x03\x73\xBF\x91\x00\x35\xC2\x37\x03\xB6\xB7\x54\x52\x04\x2A\x81\xDF\x01\xF0\xC0\x35\xC0\x38\x04\x1E\xC2\x26\xAA\x03\xE1\x03\x79\xC1\xC2\x54", - "\x71\x03\xFC\xB8\x13\x0A\x06\xC3\x07\x2F\x7B\xA1\x01\x6A\xC0\x72\x03\x41\xC2\x0D\xC5\x0E\x0F\x04\xCA\x04\x1E\x01\x6A\xC0\x73\x03\x6C\xBB\x88\x1F\x09\x0A\x03\xE7\x03\x0E\xC2\x07\x02\x88\xC2\xB0\x50\x1D\x03\x11\xC6\xAB\xAA\x81\xE9\x01\xB3\xBB\x01\xBA\x29\x03\x18\xC0\x98\x23\xE0\xAA\x02\x24\xC2\xD8\x35\x01\xB9\x2B\x00\x25\xC9\x81\x29\x11\x73\x02\x6A\xC0\xEA\x01\x49\xC0\xB6\xAA\x0D\xCB\x0E\x12\x09\xC7\x04\x3A\x01\x6A\xC0\x76\x02\x4D\xC6\x20\x08\x13\xC2\x56\x6D\x03\x33\xBB\x66\x4C\x5E\x02\x1A\xC6\x1D\x00\x14\xCA\xC0\xAA\x81\xEF\x01\xB3\xBA\xB1\xAD\x31\x02\x0D\xC0\x0F\x09\x0A\xD2\x63\xEA\xC0\xF1\x00\xA7\xC0\x34\xB2\x0D\xC2\x0F\x12\x0A\xCA\x04\x4B\x01\x6A\xC1\x79\x02\x55\xC7\x20\x0C\x0C\x0A\x03\xF4\x03\x33\xBB\x78\x51\x66\x02\x1A\xC5\x1E\x0B\x15\xC6\x08\x1D\x85\xC2\x55\xF6\x00\xB0\xC2\x44\x02\x2C\xC2\xAC\x57\x07\x2A\x85\xCF\xB3\x6A\xC0\x7C\x03\x4E\xC5\x20\x02\x0D\x0A\x03\xF9\x03\x73\xC2\x00\x01\xBA\xC2\xB0\x52\x1F\x0F\xEE\xB5\x06\x2A\x81\xFB\x01\xB3\xBB\x4A\x1B\x36\x02\x0D\xCC\x0F\x01\x0C\xE7\x6B\xEA\xC0\xFD\x01\x77", - "\xBE\x3E\x02\x0D\xCE\x0F\x13\xED\xA7\x2E\x7D\x01\x2C\xC3\x76\x37\xCF\x54\x1F\x0A\x06\xDF\x07\x0E\x86\x97\xB9\x91\xC2\x17\x44\xAF\x07\x00\x06\xE6\xA7\x23\x0B\x59\xAC\xBE\x06\x01\xCE\xC1\xAA\x47\x33\xCC\x5D\x64\x10\x62\x86\xA9\x4B\xA4\xC3\x87\x02\x91\xBB\xD1\xB3\x00\x09\x0D\xC2\x8F\x29\x66\xA7\xC2\xB3\x02\x6B\xC7\x78\x46\x3D\x71\x0D\xF6\x2A\x33\xC3\xC5\x72\x9B\x2A\x6D\xC7\xDA\x48\x1B\xD0\xCE\x44\x0A\x3B\xC3\x05\x03\x03\x01\x6F\xC7\x06\x12\x4F\x40\x0E\xC0\xAD\x43\xC3\xE3\x1D\x17\x02\x71\xC1\x01\x03\x1C\xDE\xD2\x6E\x00\x46\xC3\x0A\x00\xE4\xC3\xFD\x6E\x38\xCB\x00\x0D\x0E\xC1\x09\x46\xC3\x0C\x00\xE9\xC0\x0A\x76\x38\xCD\x00\x03\x0E\xF8\x29\x34\x00\x66\xBD\xED\xBE\x9F\x46\x0E\x71\x1E\xC4\x33\x05\x02\x41\x59\xDE\x54\x62\xC1\x7B\x4A\x3C\xC9\x81\x3C\x15\x1E\x9E\x21\x45\xA0\xBD\x67\x54\x92\x48\x3E\xC2\x11\x12\xFD\xAD\x87\xE9\xC3\x6A\xBA\x5C\x4C\xAF\x50\xE7\x5A\x19\xCE\x57\x79\x87\xC0\x4D\x6A\x51\x33\x08\x13\x5D\x3F\xC5\xAF\x5F\x0F\xD8\x9A\x01\xC4\xBC\x05\x9F\x54\x81\xC6\x61\x50\xD7\xBA\x0F\xED\x97\x77\x54\x0B\xC4\x8D\x55", - "\xB3\x50\xEE\x48\x2B\x5C\x15\x14\x96\x3C\x55\x87\x06\xF6\xC1\xBB\x34\x57\x02\xB8\x51\x10\xE6\xF0\x1A\xC4\x1E\xC4\xDC\x5F\x7D\xC5\xBC\x50\x22\xD3\xCD\x3C\x0A\x0E\x0D\xBC\x55\xC8\x55\x89\xC4\x3E\xC5\x20\xD8\xD6\x1C\x88\x93\xC4\xF3\xC3\x0A\xC6\xC7\x50\x30\x36\x21\xD0\x11\xCF\x99\x71\x4C\xBC\x05\xEF\x24\xAF\x51\x9E\x0B\x22\xD2\x11\xFF\x16\xA1\xC4\xC3\x5D\x1E\xC6\xE0\x4C\x57\x07\x90\x43\x12\xE8\xB6\x0A\x0D\xDF\x54\x17\x44\x43\x4C\xCC\x05\xC4\x1B\xEC\xB8\x87\xD8\x35\xCC\x02\x0D\xC5\x82\xC6\x46\xCD\x57\x53\xCD\x0C\x07\x17\x6D\x40\xC4\x26\x5A\xDE\x03\x99\x1A\x21\xCC\x0E\x2A\xDA\x40\xC4\xC9\x4A\xBD\x07\x03\x55\x4B\xC4\x74\x63\x11\xCA\xC4\x77\x55\x06\x02\xE6\x64\x99\xC6\xF6\x6B\xA1\x1C\x15\x03\x31\x7A\x06\xA0\x4F\x35\xC6\x0C\x76\x45\xC4\x6A\x7A\x57\x5D\xE0\x69\xBB\x50\xC4\x0B\xB8\x90\xC5\x90\x1A\x37\x01\xBA\x9A\x88\xFA\x06\x52\xC4\x33\x72\xE7\xB8\x5B\x3A\x37\x18\x12\xE6\x88\xB9\xB5\x05\x03\x7B\x33\x3B\x1F\x4F\xC7\x6B\x74\x13\xCA\xE1\x1F\x56\xB4\xC2\x6F\x4F\x86\x12\x6F\x09\x6B\x60\x12\xC4\x4F\x77\x31\x39\x7A\x46\xC4\x9B", - "\xC2\x3D\xCC\xE3\x73\x11\xCA\x04\xD4\xC4\xB8\x44\xBD\x04\x34\x44\x57\x0A\x12\x97\xC7\x09\xA0\x1A\xC5\x34\xAE\x4E\xC7\xAF\x80\x52\xCC\x3E\x86\x10\xED\x6B\x5E\x06\x81\xC4\x31\x89\x97\xBF\x44\x27\x22\xD5\x13\xE6\x89\xEC\x2F\xAC\xC4\xB4\x8C\xA8\xC2\xF0\x4E\x35\x1F\x12\xC7\x8A\x8F\x02\xAE\x8F\x7B\x32\x76\x92\x43\xCE\x35\x15\x14\xFF\x8A\xAD\x95\xB9\xC4\x66\x9E\x7C\xC3\x36\x3E\x35\x0C\xBB\x40\x89\xA8\xBC\x1D\x57\xE2\x35\x83\xC0\x5B\x3E\x35\x03\x15\xE3\x53\xC9\xC5\x52\xA0\x62\xC6\x9E\xC7\x58\xC0\x0C\xA9\x16\xD9\x46\x92\xC5\xA8\x21\x7B\x33\xBA\x4D\xBD\x4A\x1A\xB1\x15\xE0\x8B\x92\xC4\x3F\xAE\x55\xC7\x41\x06\x40\xAB\x2C\xC1\x15\x48\x9B\x68\xC5\x0A\x02\xFB\xC3\x86\xC7\x40\xAB\x2B\xD1\x33\x46\x9A\x1E\xC5\x3E\x8A\x20\xC7\xA8\xBF\x5C\xC9\x27\xCF\x56\x77\x63\x03\xC4\xDC\xC4\x83\x00\x83\xA6\x55\xCE\x22\x40\x14\xF8\x8B\xE6\x5C\x40\xC5\x0E\xA6\xB6\xC6\x5F\xCF\xA6\x4C\x12\xCE\x4A\xF5\xC5\x62\x51\x7B\x30\xE0\x07\x1E\x37\x21\xCD\x2F\x68\x7A\xD3\xC5\x19\x31\x0C\xC7\xC1\xC5\x43\xC1\x30\xC5\x08\x28\x4B\xFC\xC5\x19\x31\x8C\x0B\xC4\xC2", - "\xF9\x54\x23\xD2\x08\x2A\x4B\x84\xC6\xB3\x33\xC1\x03\xC8\xC3\x61\x53\x2F\xCF\x08\x32\x7A\x98\xC6\xED\x34\x15\xC7\xC1\xC2\xA8\x1C\xAB\x4E\xED\x20\x8C\xED\x35\x82\x57\x95\xC5\xB2\xC0\x48\xC1\x30\xBA\x10\xF6\x14\x3A\xC6\xE8\x58\x20\xC4\xDA\xA2\x43\xCC\x23\xC7\x18\xC1\xB3\x40\xC4\xD0\xA6\x0D\xC6\x69\x30\x68\xCD\xFF\x4E\x18\xFF\x50\xCF\x55\x97\xA8\x6E\x55\x2E\x58\x70\x07\x38\x03\x17\xFA\x71\x25\xAA\x1A\xC4\x76\x34\xD5\xC7\xA3\x50\x24\xD1\x11\xC2\x9E\x2E\x44\x87\x07\xF7\xC2\x8F\xC5\xBA\xA0\x31\xC1\x10\xDE\xA7\x5B\xC6\x0F\x02\x79\xC4\x90\xC1\xBD\xAA\x21\xC9\x2C\x68\x8D\xDA\x74\x40\xC4\x1E\x1A\x86\xC1\x6C\x1F\x36\xD0\x77\x40\x89\xBE\xBD\x28\xC7\x50\x47\xCF\x55\x6E\xC7\xD9\x40\x12\xFA\x75\xF8\xC4\x19\x30\x26\x58\xDF\xC5\x20\x00\x21\xDD\x18\xDE\x5A\xB7\xC6\x2E\x44\x9C\x5F\xE0\xC6\xB9\x50\x24\xCE\xB5\x88\x8E\xB3\x33\xC1\x59\xC5\xC4\xC7\xC4\x45\xCA\x10\x14\x4E\x6D\x8B\xB8\x45\x31\x51\xC5\xC4\xA2\x49\xBA\x16\xEC\xA4\xEF\x98\x6B\x5C\xC4\x2B\x57\x87\x55\xC9\xC3\xD6\xA5\x36\xDC\x15\x09\x97\x0B\xC7\x34\xC7\xF6\x4A\xB2\xB8\x66", - "\xCE\x22\x4B\x31\x4B\x8E\x99\x42\xBC\x54\x61\xAD\xDE\xC0\x57\x47\xA7\x4B\x1C\xFA\x88\xED\x4B\xCE\xBD\xC7\xC5\xA8\x42\x5E\xCB\x38\xC7\x1A\xC6\x8E\xC6\xAD\x97\xC6\xC1\x4F\x98\xC1\x74\xCD\x34\xCD\x13\xC7\x5B\x93\xC4\xCA\xAC\xA9\xC7\x99\xC0\x70\x00\xC4\x5D\x1A\xF7\x88\xE2\x50\x2E\x44\x95\xC6\xD3\xC2\x21\x0E\x6C\xAF\xF2\x8E\x88\xE5\x5B\x86\xC4\xCA\xC7\x41\x03\xE9\xA7\x8F\x3E\xC0\xBA\x8E\xB8\x45\x83\x02\x5F\xC6\xF6\xC6\x20\x04\x82\xA9\x14\xEB\x60\xA5\xC7\x1F\x5A\x63\xC7\xF8\xC1\x08\xB7\x30\xCB\xD0\x9A\x88\x83\x03\xCE\xC4\xC3\xC6\x43\xB7\x1E\x3C\xEE\xBF\x1E\xC2\x9E\x03\x03\xD6\xC5\x87\x01\x82\xB7\x1E\x30\xA9\xA1\x1E\xF1\x99\x03\x03\x7B\x34\x5E\x56\xAB\xB7\x1E\x3C\xAE\xBE\x1F\xE2\xA1\x11\x57\xE3\x0C\x5E\x56\xD7\xC5\x0A\x53\x9B\x39\x19\xD3\x8F\x87\x02\xEE\xB5\x24\xBC\x85\xC2\xF0\x42\xB8\x59\x1E\xE3\x8D\x87\x02\xFA\xBD\x64\xC6\xC4\xB6\x7E\xC1\x67\x42\x5C\x62\x8F\x97\xC8\x06\x02\x8A\xB4\xC7\x53\x67\xB8\x3E\xD9\x69\x6A\x8F\xA0\xC8\x05\x03\xA2\xB5\xB2\xC3\xBA\xBE\x39\xD9\xC0\x02\xAE\x71\xC7\xEB\xC6\x00\x02\x10\xBB\x84\xC0", - "\x00\x15\xE4\x9C\x90\xE2\x50\x82\x57\xFC\xC5\x32\xB9\x5A\xCB\xF2\xA6\x20\xC1\x88\x82\x57\x01\xC9\xF6\x48\x59\xBC\x86\xCA\x00\x01\x1B\x3E\x8C\xA5\xC8\xD1\x1B\x05\x01\x58\xBA\x64\x15\x23\xC2\xB5\x63\x8E\x9D\x0A\x61\x07\x7B\x30\x05\x06\x88\xC4\x66\x16\x29\x1F\x90\xC6\xC4\x8C\x57\x28\xC8\xB2\x5C\x8A\xCB\xA1\x16\x29\x27\x90\xD8\xC8\x0A\x03\xA4\xBC\x0D\xCA\x04\x0C\x45\xC8\x85\x36\x14\x30\xC8\x28\xC8\x03\x6A\x16\xCA\xD2\x65\x46\xC0\xCC\x36\x14\x3A\xC8\xA5\x6D\x35\xCA\x5C\x1D\x8D\xC8\xAD\x36\x29\x01\x91\xFA\x38\x31\x00\x39\xCB\x41\x07\x06\x04\x47\xD9\xC0\x31\x13\x56\xC6\xD1\x1B\xB4\xBE\x0F\xCC\x57\x06\x12\x60\x1C\x31\x13\x62\xC6\x60\xC9\x1C\x4D\x1F\xCD\x5D\x3F\x4A\x26\x24\xCE\xB9\x4E\xC7\x55\xC5\x48\xC8\xAE\x41\x9E\x0A\x36\xC6\x1C\xF5\x76\x83\xC9\xB3\x66\x98\xC5\x3C\x0C\x3F\xC6\x38\xDB\x01\x0B\x92\xAE\x44\x6A\xC5\x75\x14\xC0\xC1\x86\xCC\x03\x1F\x24\xF3\x66\x43\x18\x8E\xC8\xBB\x5C\x90\xC5\x07\x06\x4A\xC1\x15\x69\x88\x29\xC9\x61\xC9\x07\xCA\x41\x06\xED\xB8\x49\xC1\x4F\x30\x92\xE3\x57\x40\xC5\x1F\x01\x2B\xC8\x57\x45\x79", - "\x17\x25\xC4\xBA\x40\xC4\xB0\xBB\x5A\xCA\x42\x01\x4E\xCB\xAE\x1B\x1C\xDA\x2F\x41\x00\xBB\xC8\xC1\x4F\xA5\x6E\x97\xCC\xB0\x4F\x22\xF6\x12\x49\xC9\x71\x4C\x55\x6C\x33\xC8\x4D\xC7\x2B\xCA\x14\x50\x93\xE2\x50\xB9\x6D\x69\xC8\xEC\xC5\xBD\x43\xF7\xA2\x26\xC7\x04\x6C\x6E\xD3\xC9\xDB\xC6\x1E\x3D\x08\x07\x4D\xC1\x10\xD3\x34\x53\xC9\xBE\xC7\x18\xCA\x6A\xBE\x9B\xCE\xDE\x33\x10\xF1\x13\x45\xC4\x38\xC5\xD5\x77\x22\xC8\x09\x01\x36\x02\x0E\x17\xE0\x38\x0A\x49\xC4\xC3\xC4\xDE\xBC\x9D\xC8\x73\xB8\x27\xCA\x71\xB2\xC9\xE5\x7B\x72\xCA\x7B\xC3\x42\xC6\x9A\x35\x24\xF1\x90\xA5\xBB\xFC\xC8\x00\x02\x9F\xC7\x8D\x5C\x49\xD1\x21\xCD\x01\x02\xCA\x66\x70\x7F\xCA\xDD\xC6\x70\xCE\x04\x10\x28\xEA\xE1\x04\xCA\x0C\x5E\x20\xC7\x13\x06\xA2\xCA\x10\x15\xE9\xAF\xB1\x05\xC7\x31\xC8\x28\x00\x47\xCE\x0E\x78\x51\xC7\x5E\x40\x89\xD1\x00\x23\xCB\x2B\x4D\x49\xCC\xB8\x50\x24\xDD\xFB\x89\x94\xE2\xAE\x12\xCA\xA1\x5E\xA3\xC0\x35\x89\x52\xC1\xD4\xAE\x8A\xA6\x33\x28\xC5\xF6\x49\x68\xB9\xA1\xCF\x81\x51\x29\xFB\xAB\x4E\xC9\xC6\x83\x9A\xC9\xDA\xAF\x66\xC6\x9A\x3B", - "\x26\xFA\x71\x56\x00\x42\xCB\x45\xC7\x1B\x5A\x9C\xC1\xDD\x17\x02\x02\x95\xA7\x17\x3E\xCB\x88\x78\x90\xC6\xF0\xB9\x50\xD9\xE8\xAF\xB1\x70\xC9\x62\x50\x5E\x05\x16\x03\x91\xCD\xD9\xBF\x56\x68\x30\x00\x07\xA8\x32\x40\xCA\xF6\x14\x0B\x02\x54\xC9\xF4\xB0\x8C\xA8\x33\x88\xC9\x78\xCB\xD4\x12\xA8\xC7\xE4\x00\x2B\xF5\x87\x80\xCA\x98\x86\xA1\xCB\xB8\x1E\xAD\xCA\x2C\x80\x12\xDF\x01\x42\xCA\x8A\x2E\xBA\xCA\xA9\x58\x48\xC0\x06\x02\x2A\xC4\x4F\x7A\xCA\x7D\x5A\x20\xC5\x18\x02\xA8\xCE\xA5\x60\x2C\xF6\xA9\x70\xCA\x62\x00\xA1\xC8\x9E\x16\xB0\xC7\xCC\x40\x12\xCA\x7E\x89\xCA\x45\x76\xC6\xCB\xEE\x58\x48\xC4\x06\x02\x2A\xCB\x3F\x12\xCB\xC6\xC8\xE1\x11\x19\x02\xA8\xCE\x3D\x52\x2C\xF9\x94\xFA\x38\x66\x00\xA1\xC9\xA6\xC0\xB5\x59\x3A\xDA\xE3\x13\x7E\x89\xCA\xCC\x7A\xC9\xCA\x51\xC9\xBA\x18\x06\x02\x2A\xD6\xF9\x12\xCB\x4C\xCA\xED\x15\x1A\x02\xA8\xC6\xEC\x72\x2C\xE9\x93\xE9\xC8\x6A\x00\xA1\xCB\xD1\x7A\xB2\xC8\x55\xC8\x10\xC1\x21\x8B\xC9\x6C\x01\x7A\xC9\x09\x87\x66\xCA\x35\xD0\x2B\xFD\x7E\x89\xCA\x2E\x44\x76\x36\x05\xC9\x91\xC1\x96\x83\xEB", - "\x92\x04\x73\x00\x42\xCA\x76\x37\x15\xCA\xAD\xC9\xC8\x8E\x2E\xCF\x04\x55\xBF\x09\xCA\x76\x37\x17\xCC\xBA\xCC\xF3\x96\x2E\xF8\x3C\xD1\xCB\x5A\xBC\xA0\xCA\x60\x36\xBB\xC3\xFE\x80\x2F\xCB\xE1\x40\xC4\x83\x00\xF2\xCA\x41\x07\x10\x06\x5E\xC9\x15\xE2\x97\xD0\xBE\xEA\xCB\x82\x00\x23\x02\xA8\xCE\x9D\x51\x4A\x71\x90\x8B\xC8\xD0\xC7\xD9\x31\x62\x4F\x36\x5A\x40\xCF\x1E\xC1\x88\xAE\x44\x89\x4A\xEF\x50\x24\xCD\xF4\x42\x49\xC2\x3C\x61\x2D\x21\x24\xFD\xCB\x02\xCC\x03\xCA\x6F\xC8\x44\xDA\x5E\x0D\x02\x4B\xC8\xB4\xC4\x86\x5F\x72\xCC\xBB\xC6\x10\x15\xFF\xB4\x90\x96\x01\x42\xCB\x9F\x57\x74\xC9\xAB\xC1\xEB\xBA\x23\xC6\x04\x1D\x01\x19\xCD\x32\xC5\xCB\xC7\x21\xCE\x61\xC5\x08\x24\x02\x21\xCC\x9B\xC5\xF7\xC8\x01\xC4\x86\xCB\x0A\x08\x31\xF3\x89\xD5\xC9\x05\x02\x56\x01\x89\xC8\x00\x02\x0B\x0E\x31\xC2\x90\x6F\xCB\xB3\x01\x19\xCD\x2E\x02\xA8\xC2\x38\xD0\x2B\xFA\x02\x10\xCC\x00\x3A\x5E\x04\x13\x5B\xC2\xCC\x61\xCF\x08\x3D\x02\x33\xCC\xC3\x00\x1E\xCD\xA3\xC0\xC6\xC0\x8B\xB3\x31\xCA\x03\x4A\xCC\x21\x6E\x75\xC6\x41\x03\x19\x03\x63\xD1\x06\x10", - "\x99\xD6\x6F\x70\xCA\x69\x03\x8C\xC8\x1B\x07\x65\xDF\xBF\x4C\x99\xD9\x01\x33\xCC\xDA\xBD\x42\xCC\x89\x57\x47\xD1\x6E\x20\x03\x33\xCC\xE6\x00\xA1\xCA\xE2\xC0\xAE\xC7\x0E\x00\x32\xD7\x8F\xDA\x74\x44\xCC\xDF\xC8\xC7\xB3\xC6\xC8\x03\xC9\x28\xF8\xBC\x1B\xCC\x72\xCD\xB1\xB7\x8C\xCF\x1E\x0A\x66\xC2\x31\xC0\x89\xC4\xC0\x34\xC8\x24\xC2\x9D\xC9\xBC\xC3\x53\xD9\x0A\x33\x98\xA7\xBF\x83\xCD\xF3\xCA\xE1\xC7\xF5\xB4\x43\xCC\x00\x2A\x06\x1A\xC4\x38\x5F\x32\xCE\xF6\x15\x01\x0A\x1A\x17\xC7\x13\x00\x0F\xCD\x64\x0D\x60\x5A\x58\xCA\x38\x14\x01\x18\x34\xDB\x28\x3D\x80\x80\x07\x60\x59\x5A\xCD\xC8\xCD\xBD\x5E\x34\xE8\x42\x41\x81\xA1\xCD\xB7\xCA\xF1\xC7\x19\x66\x6A\xC0\xCC\x2A\x04\xA9\xCD\x75\xCA\xC3\xC5\x1A\xC1\xA1\xC3\x1A\x90\x35\xFB\x95\x86\xC7\x18\x01\x56\xCC\xB6\x32\x5F\x36\x6B\xC1\x2C\xC6\x8E\x99\x00\xBA\xCD\x0C\x32\x72\x85\xD7\xC7\x58\xCB\x35\xC4\x88\x41\xCD\xED\x34\xE6\x4C\xB1\xCD\xB1\xC6\x38\xDB\x00\x08\x9B\xAE\x44\x1B\x1B\x65\xCF\x64\xCE\x70\xCC\x01\x0F\x36\xF3\x66\x27\xC5\x33\x75\xCC\xCB\x7C\x0D\x03\x06\x6D\xC1\x15\x5C\x09", - "\xD2\xCD\x9F\xCB\xE8\x1B\x1B\xC1\xA1\xC5\x2E\x92\x36\xE5\x96\xD1\x1B\x1F\x01\x6E\xCC\xAE\x42\x86\x12\x6D\xCB\x2D\xDA\x2F\x74\xC0\x09\xCA\x3A\x1A\xB4\xC9\xB6\xC2\x9C\x01\x01\x2A\x9B\x82\x4F\x42\x14\x69\xCF\x6D\xCC\xB9\xCC\x64\x17\x37\xF1\x99\x09\x4A\xD2\xCD\xDE\xC8\xAF\x53\x04\x08\x6C\xC4\x01\x2A\x06\x42\x03\xD4\x86\xC0\x05\xE6\xC0\xAE\xC6\x02\x1E\x37\xF9\x97\xA1\x45\x31\x51\x38\xCC\xAF\x57\x04\x0A\x1A\x14\x14\xCE\x9C\x81\xC4\x31\x50\x3C\xCC\xAF\x54\x05\x05\x71\xCD\x11\x17\x9C\xBC\x05\x31\x51\xED\xC8\xA9\xCC\xFF\x6D\x71\xCD\xC3\x5F\x9C\xCA\x6F\x70\xCA\x4C\xC1\x8B\xC5\x20\x0A\x03\x07\x39\xD5\xE4\x70\xC8\x20\x09\x92\xCC\x94\x0E\xE5\xCC\xD8\x72\x34\xC2\x27\x24\xC1\x2B\xCF\x1B\x10\xCD\xCB\x5E\x79\x8F\x49\x23\xF8\x97\xFF\xCB\xB3\x33\xE4\x48\x84\x31\xC1\xC4\x60\xC5\x3A\xC2\x9E\x2E\xC7\x70\xCB\x22\x02\x6A\x03\x50\xC9\x81\x2B\x31\x52\x9C\xED\x4B\x48\x01\x4A\xCF\xDE\x7B\xE7\xC2\x53\xC9\xB5\x70\x95\xCF\x00\x52\xCE\xE0\x80\xD5\xCA\x44\xCE\x74\x72\x32\xC5\x04\x67\xBB\x34\xC8\x2E\x03\xD6\xC9\xE7\x58\x65\xC6\x36\xD6\x15\x59", - "\xCE\xC7\x17\xB1\xCF\x8A\x48\xE6\xC9\x5C\x88\x3B\xF0\x1E\xEA\xCE\xDB\xC5\x18\xCB\x1A\x06\xED\xC2\xA7\x83\x3B\xF5\x8E\xF0\xCA\x72\x01\xA5\xCC\x13\xCD\x61\xCE\x44\xC5\x34\xFD\x34\xF4\xCE\x05\x03\x3D\x02\xDD\xCB\xC9\xC3\x62\xD6\x7B\x80\x9E\x90\xA0\x83\xCF\x28\xCF\x7B\xCB\x10\x07\x78\xC9\x04\x09\x9E\xE5\xCE\x5E\xCE\x6E\x1F\xE1\xC8\x12\x0F\x78\xDE\x32\xC5\x9E\x82\xC6\x87\xCF\x4B\x01\xE5\xCD\x9D\xC6\x76\xC6\x08\x04\x84\xB4\xC8\x1A\xC3\x1B\xC9\x80\xC4\x77\xC0\x57\xD5\x08\xD2\x90\xBF\xCE\xBC\x04\x79\xC7\xD3\xCA\x8F\x32\x0A\x07\x3C\xE8\x02\x63\xCE\xF2\xC4\x8D\xCD\x7B\x49\x15\x07\x78\xCF\x05\x30\x9E\xFE\xCC\x86\xC6\x58\x03\xE1\xCE\x16\x07\x7B\xC9\x31\xFE\x9D\x85\x02\xB7\x01\xC3\xCD\x2F\x05\xF7\xCF\x62\xD7\x3C\xD0\x60\x87\xCF\xC4\x00\xE2\xCF\x8D\xCF\xF7\xC7\x8C\xA7\x3C\xD8\x85\x89\xCA\xC3\xC7\xCE\xCD\x41\x07\x2C\xC2\x7A\xCD\x12\xE2\xC3\x5B\xBE\x70\xCA\xB6\xC2\xBD\x51\x1A\x03\x76\xCF\x40\x72\x9E\xFA\x38\x7A\xC2\x7B\x56\x35\x05\xFB\xC8\x7B\xD1\x21\xD7\x03\x32\xCE\x07\x03\xC1\xC0\xF4\xCC\xD0\xCC\x64\xDC\x06\x28\x9F\x86\x02", - "\xE0\x00\xF2\xCE\xA2\xC9\x86\xC1\x0E\x0F\x3F\xC5\x04\x65\x01\xF2\xCE\xF7\xC8\xF3\xCE\x1C\x06\x7F\xC0\x00\x2A\x03\x63\xCE\xA9\x1A\x73\xC7\x41\x03\x1D\x03\x76\xCE\x11\x69\x36\x2B\xCF\xD1\x1A\x76\x01\xFF\xC8\x1E\x00\x80\xC4\x3C\xC0\x89\xF1\x01\xFD\xCF\x7A\x01\x03\xD2\xF1\xCC\x7C\xD6\x07\x3D\x9F\x8B\xC3\x09\xCB\xD4\x18\x1A\xCC\xDF\xC0\x00\x1B\x07\x3D\x9F\xF5\x0F\x1A\xC5\xD4\x18\xDB\xCA\xCC\xBC\xAF\x49\x0E\x21\xA0\xF1\xCE\x69\xC9\x02\x01\x72\x02\x6F\x09\x00\x06\x41\xE4\x19\x26\x62\x4E\x2A\xA2\xCE\xE0\x4A\x01\x09\x1C\x1B\x34\xC0\xCB\x33\xC7\x1C\xD0\x06\x02\x0B\xD1\xC2\xC8\x2B\x68\x40\xD3\x9A\xAB\xD0\x71\x07\x1D\xD0\x2A\x27\x95\x2F\x7D\xD1\xEB\x80\xA1\xCF\x61\x42\xD0\xC0\x33\x2B\x2A\xE4\xC9\x67\xC8\x73\x47\xA1\xEE\x5E\x49\xD0\x6C\x37\x2B\x2B\x03\xD4\x61\xC4\x1C\xCF\xA1\xBB\x62\x51\xD1\x0C\x33\x2B\x2B\x04\xD1\x02\x17\x42\xDE\x89\x59\xD0\x8C\xC8\x14\xD0\x07\xD6\x04\x0E\x85\xC9\xB5\x60\xA1\xAE\x44\x6C\x22\x01\xD2\xCE\x6F\x0C\xDE\x5F\xDC\x15\x2C\x45\x3E\xD0\xC2\x12\x16\x01\x19\xD3\xE9\x0C\x86\xC1\x15\x6C\x45\x45\xD0\xDA", - "\x17\x18\x03\x1C\xD5\x06\x05\x87\xD8\x15\x6C\x45\x4C\xD0\x67\xBB\x39\xD2\x0E\x05\x0F\xD2\x78\x4C\x8B\x14\xA1\xA3\xCE\x20\x09\x39\xD3\x0F\x04\x10\xD1\x67\x4C\x8B\x23\xA0\xC0\x00\x73\xD0\x22\x00\x23\xD2\x0C\x5C\x16\x36\x39\xF3\x17\x45\x00\x73\xD1\x24\x03\x24\xD1\x40\xCC\x3C\x76\x41\xE7\x11\x4A\x00\x9B\xD0\x5E\x04\x0F\x88\x70\x0C\x3C\x79\x49\x4D\xA1\x80\xC4\xD6\xCF\x35\x69\xBA\xC7\xBD\xCB\x04\x01\x45\xC6\x13\xB7\xC6\xCC\x66\x83\xC9\x1A\xCC\x09\x0E\x8A\xCD\x9B\x13\x88\xCC\x67\x0D\xCB\x34\xC9\x13\x05\x16\xD1\x53\x8E\x15\xCC\xCF\x23\xC9\x69\xC8\x27\x00\x2F\xD7\x20\x0E\x58\x84\x45\xD9\x94\x86\xC7\x4F\x01\x61\xD2\x81\x8D\x85\xC8\x42\x68\xFA\xB0\x95\xD0\x00\xCA\xD0\x2D\x8F\x2D\xD1\xBD\x41\x43\xD1\x02\x11\xA3\x9F\x8D\xD3\xD1\x9C\x59\x4B\xCF\x1A\xDE\x6D\x86\x46\xF0\xBE\x11\xCF\x53\x01\x6B\xD0\xCC\x8E\x1B\xDC\x20\xCC\x32\xD4\x01\x57\xD1\xAE\x8E\x72\xD1\xBE\x54\xC9\xC5\x05\x17\x46\xC4\x20\xEA\xD1\x3C\xC9\xF7\xCA\x15\x07\x1A\xD5\x85\x90\x47\xC3\xB8\x40\xC4\x57\x01\x6B\xD2\x1F\x56\x1E\xD2\x55\xC6\x1C\xD8\x01\x57\xD1\xFB\x90", - "\x7E\xD2\xC0\xCD\xBD\x49\x05\x00\x43\xDA\x01\x35\xD0\x35\x55\x09\xC7\x10\x1E\x14\xD2\x83\xCB\x30\xC6\x9D\xF1\x4C\xAF\xC8\xB8\xC8\x17\x01\x39\x0C\x74\xCD\xD7\x29\x88\x70\xD0\xF3\x0B\x2F\x01\x72\x07\x1E\x35\x06\x17\x46\xE9\x88\x78\xD0\xC2\x12\x33\x03\x46\xD4\x12\x9E\x91\xC5\x3F\xE9\x91\xED\x00\x23\xD3\x06\x99\x49\xD6\xF7\xCC\x64\xD4\x03\x29\xA4\xD5\x9D\x2B\xD3\xE2\xCC\x90\xC3\x0F\x0F\x92\xC9\x7B\xB1\xA4\xCB\xCF\x4C\xCC\x41\x01\x4D\xD6\x20\x08\x08\x17\x46\xE0\x1F\x6A\xD0\xE1\xBF\x6B\xD2\x8B\x40\xFC\x08\x91\xC7\x23\x0A\x02\x73\xD0\x8E\x00\x9F\xD2\x03\xD6\x70\xCF\x08\x13\x43\xD3\x02\x4A\xD2\x14\xD0\x26\xCC\x25\x03\x0E\xD8\x09\x10\x4A\xD0\x9E\xEF\xCB\x99\x01\x39\xD1\x27\x06\x2A\xD6\x79\xC0\x12\xDE\x02\x73\xD0\xA2\x00\xAE\xD0\xE7\xC9\xF2\xC3\x0A\x13\x43\xE7\x02\x57\xD1\xBD\xC8\xB8\xC8\x2A\x02\x28\xD3\x9B\x35\x3C\x05\xA5\xBC\x05\xA9\x01\x39\xD1\x2B\x00\x2D\xDB\x94\xD1\x21\xEE\x02\x73\xD0\xB2\x00\xBA\xD1\x54\xD6\xF8\xC0\x00\x13\x05\x33\xA1\xB7\x01\x7A\xD3\xAB\xD0\xF3\xC8\x17\x03\x87\xDC\x05\x01\xA6\xDD\xD2\x86\xC7\x5E", - "\x03\x1C\xD1\x18\x07\x98\xC3\x4B\xEF\x97\xC2\x01\x73\xD0\x63\x03\x35\xD0\xF4\x4B\xCA\x0D\x48\xCF\x9C\x8F\xD2\x62\x51\x4B\x6E\x4D\x36\x32\xD0\x74\xCA\x30\xE2\xA1\x2A\x6D\x26\x63\x01\xCF\xD7\xC5\x0D\xD2\x62\xD7\x26\x6A\x6A\x18\xD3\x9D\xD2\x5C\x44\xDB\x6C\x79\x62\x9A\xCE\x48\xE3\xA6\xA1\x45\x13\x1B\x74\x18\x67\xD1\x15\xD8\x0A\x25\x64\x26\xA9\x77\xCB\xA4\xD3\x0D\x17\x3D\xC8\xAE\xC7\x0C\x0C\x4B\xE1\x8A\x17\x70\x6F\xD2\x73\xB3\x1C\xD4\x19\x07\x8D\xD7\xC0\x60\xA4\xF3\x0B\xCD\x01\x39\xD1\x34\x05\x38\xD6\x92\xDC\x40\xD2\x03\x73\xD0\xD6\x00\xE6\xD0\x4B\xD4\x2F\xD7\x0D\x13\x43\xDB\x03\x52\xD3\x32\xD2\xC3\xC4\x37\x03\x0E\xD0\x0E\x18\x4E\xF8\xA4\xFC\xD2\xE1\x01\x39\xD1\x39\x07\x1A\xD8\xC1\xB0\x2B\xE8\x9E\xE4\x0C\x47\x4A\x4F\xD0\xAF\x06\x1C\x07\x8D\xC3\x16\xE7\x74\xFC\xB7\x91\xCF\x73\x03\x35\xD3\x4E\x90\x38\x07\x2A\x72\xA2\x9C\xD0\xE8\x01\x6B\xD3\xC6\x95\x3E\xD8\x09\x80\x12\xE9\x03\x57\xD1\xCB\x96\xFE\xD3\x6D\x58\x48\xCA\x0E\x17\x46\xC6\x32\x82\xD4\x2D\x5E\x20\xC7\x3A\x07\x1A\xD9\xCF\x88\x50\xC7\x04\x20\xCA\x69\xC8\x76\x03", - "\x35\xD4\xB7\x9E\xA0\xC3\x6C\x40\x89\xED\x01\xD7\xD0\x3C\x9D\x85\xD6\xEC\x50\x24\xCE\x07\x17\xA3\xD0\xC5\xCC\xD1\xA3\x4A\xB6\xCF\x8C\x0F\x0E\x17\x46\xE6\x3B\x9B\xD4\x96\x37\xC8\xCC\x3C\x07\x1A\xD5\xEF\x88\x51\xE7\x9B\xDA\x17\xF1\x01\x6B\xD1\x2A\xAF\x66\xC7\x54\x4E\x37\xC2\x27\x72\x01\xD7\xD1\x82\xA8\x8A\xD4\xDE\xC3\x5F\x13\x07\x17\xA3\xE5\x9F\xAE\xC5\xA3\x4B\xBE\xCD\x0A\xD0\x00\x14\x07\x17\xA3\x85\x1A\x28\xD5\x81\xD2\x1E\x3D\x1E\x00\x86\xD6\x07\x08\xA4\xE4\xA9\xCF\x55\xA0\xAF\xC6\xB1\xF2\xC8\x0F\x09\x0E\x15\x8C\xF9\xA9\x1C\x61\xA0\xAE\xCF\xB1\xF2\xC4\x00\x0C\x0D\x17\xA9\x8A\x02\xAA\xA3\x78\x09\xD0\xAC\x87\x80\x24\xD0\x00\x2C\x06\x08\xCC\x12\x02\xB4\xA6\x69\x31\xE8\xA9\x8A\x3C\x55\x5D\x00\x67\xD4\x64\x0D\xCE\xC7\xB0\x59\xE8\xA7\x32\xCC\x3E\xEA\x00\x70\xD4\x1B\x15\xEB\xAE\x67\x59\xE8\xA0\xB1\xB1\x3C\xF7\x00\x78\xD4\xA8\x21\x57\xB3\x9A\xD3\x79\xB0\x57\xC4\x02\x1E\xA9\xE4\x0C\x18\xB4\xAC\x21\xD0\xAA\x0A\xA0\x24\xD0\x02\x00\xAA\x80\x33\xF0\xB4\xDE\x59\xD0\xAF\x5B\xCF\x5E\xDD\x02\x0F\xAA\xD8\x35\x3A\xB7\x39\xD6\x76", - "\xA2\xFA\xCE\x7D\x97\x54\xD9\x60\x4D\xBB\xFE\x5B\xA0\xAF\x9C\x90\x48\xC7\x07\x1E\x54\xED\x6B\x09\x00\x61\x07\x41\xD4\xD4\x90\xAE\xC4\x08\x06\x55\xEE\x88\x17\x00\xA9\xD4\x92\xB9\x41\x05\x17\xAC\x7C\xD1\x04\x2E\xAA\xB3\x33\x25\x01\x58\xD7\x13\xBF\xB5\x7C\xA9\xDE\x04\x2C\x06\x7C\xCB\x76\x1D\xB0\x04\x6A\x31\xE8\xA5\xEF\x80\x12\xEC\x02\x37\xD5\xA1\x44\x21\x02\xAE\xD1\x94\xBF\x10\x13\x51\xEF\x97\xB9\x01\xC8\xD4\x5C\x46\x48\xCA\x52\xD4\xB4\xB0\x2B\xC6\x03\x07\xD5\x1B\x14\x2F\x01\xD8\x02\x4C\xD7\xB5\xAC\x3E\xD2\x03\x58\xD5\xA8\x21\x35\x03\xB6\xD2\x56\xD5\xF8\x6A\x0D\x00\x89\xDE\x01\xBF\xD4\x32\x0C\x76\xC8\xAC\x51\x74\xAE\x02\x26\xAB\x86\xC7\xEC\x01\x74\xD7\x86\x10\x11\x01\x36\x0C\xD7\x01\x5D\x9F\xC6\xEF\xCA\x7D\x01\xB4\xD2\xF0\x48\x09\x0B\x56\xE8\x74\x8F\x02\x03\xC6\xE6\xCF\x01\x01\x56\x08\xA6\xCF\x08\x26\x02\x7E\xD5\xE4\xB8\x69\x79\xE4\xCC\x02\x01\x2B\x00\x56\xF5\x5C\xC2\xD5\xE4\xD4\xD7\x8C\x90\xC2\x04\x04\xB0\xC4\x33\x09\x99\xD4\xD5\xD8\x92\x4E\xD7\x0B\x05\x62\xDB\xA1\x16\x32\xD8\xAC\xB6\x82\xEF\xD4\x52\xC9\xC3\xD4", - "\xCC\x02\x66\xCC\x57\xEE\x04\xA1\xD6\x69\xC8\x25\x03\xC8\xD3\x43\x1F\x0E\x15\x57\xE4\xAB\xD0\x00\x28\xD6\x0E\xD0\x16\x03\x65\xD5\x16\x2E\x59\xFB\xAA\xEA\x80\x31\xD6\x22\xD6\x19\x04\x66\xD0\x98\x31\x02\xF1\xB1\x41\xAE\x49\x30\x5E\x54\x1D\x04\x67\xD8\xAD\x29\x37\xF9\xB2\x41\xAE\x66\xCB\x9C\xD0\xD1\xD1\x03\x3E\x02\x0A\x0D\x03\xAB\xF9\xAA\x9C\xD4\x48\x00\xC7\xD2\x21\x0D\x09\x11\x15\x28\x10\x2A\x03\xAA\xD4\xB2\xC4\xA7\xD7\x13\x03\xB5\xC7\x08\x2C\x02\x56\xD6\xB8\x7A\xAC\xD4\xB9\xD1\x6A\xCF\x5E\xCE\x05\x1D\xAD\xE4\xC7\x60\xD7\x59\x4E\xD8\xD7\x66\xD5\x10\x19\xA4\x91\x9E\xBD\x01\x67\xD7\x82\x02\x32\x01\x6D\xD0\x69\x8B\x5B\xCC\xAB\xA0\xAC\x70\xCA\x66\x01\xDC\xD0\x00\x09\x0D\x14\x5B\xC7\x04\x75\x00\x76\xD7\x7F\xD7\x22\x80\xAE\xCB\x0D\x0B\x5A\xC0\x00\x69\x01\x7E\xD6\x83\x00\xE3\xC9\x97\x50\x81\x79\xEF\x3C\xAA\x6B\x01\xB1\x04\x21\xC5\x9C\x4A\x80\xB6\x9E\xD9\x4D\xE8\x42\x03\xB8\x53\xD5\xF7\xC8\x3B\x01\x56\x03\x39\xD8\x15\x76\x83\xD8\x22\x03\xB9\x2D\xD7\x7B\xCF\x1E\x0C\xB9\xC4\x33\x26\x9E\x84\x57\x03\xB8\x32\xD6\xE1\xC2\x00", - "\x0E\x83\x3F\x52\xDE\xAD\x81\xD7\x06\x03\x01\xB9\x9B\xD5\xBD\x4E\x00\x0D\x5D\xE4\x19\x3D\xC2\x9E\x5B\x01\xB9\x9D\xD4\xC9\xCA\x01\x16\x5D\xDB\x28\x48\x01\xB0\xD6\x41\x57\xC3\xB4\xE1\xCE\xBB\xC8\x85\x23\x9F\xBC\x5B\x03\xB8\xE8\xB4\xF3\xCA\x06\x0E\x83\x3D\x5C\xC2\x9E\x64\x01\xAA\x03\x78\x0B\x00\xBC\x51\xD6\x38\xDD\x01\x05\xAF\x80\x33\x10\xD0\xE4\xD6\x44\x04\x52\xDC\x7C\xC9\x02\x17\xAF\xC4\x36\xC1\xD6\x58\xB7\xA6\xD1\xF2\xC5\x05\x1F\x5E\xFE\x91\xC9\x03\xA6\x33\x01\xBB\xA8\xD6\x70\xC1\x06\x06\x5F\xED\x6B\x47\xBC\xDA\xD7\x55\xD4\xA7\xD5\x0D\x0E\xBE\xCE\x11\x69\x00\x68\xD7\x53\xAF\x5D\xA0\xF3\xC9\x0F\x05\xBF\xD3\xCD\x37\x00\x78\xD7\x6D\x70\xCF\x78\x5C\xCD\x10\x0E\x83\x25\x58\xE9\xE9\x49\x03\xA8\x33\x01\xB9\xB1\xD6\x70\xC2\x09\x1D\x5F\xE1\x8A\x67\xD1\xF1\xD6\x85\x02\xB3\xD4\xF9\xCE\x09\x0E\x60\xF8\x8A\x62\x00\x00\xD9\x8E\xC9\xB5\xD4\x53\xDA\x0A\x0D\x5E\xE4\x19\x70\x00\xC9\x02\xE9\xD5\xB7\xD4\xC9\xC5\x0B\x1E\x60\xDB\x28\x7D\x00\x21\xD9\xFC\xD4\x4C\x51\x67\xD8\x88\xC6\x03\xC5\xB0\xE4\x0C\x47\xD3\x38\x5B\x00\xBE\x5D\xDC", - "\xA9\xCD\x06\x2F\xB0\x9B\x14\x9A\x01\xE4\x00\xBB\x33\x80\xB8\xAF\xCC\x3E\xDA\x03\x16\xD8\x82\x4E\x55\x01\x06\xDF\x20\x03\xC0\xA1\x58\xCC\x99\xE6\x01\x40\xD9\x38\x4C\x61\xD1\x82\xD2\xD2\x6F\x2F\xF2\x03\x37\xD8\xA8\x20\xC9\xD1\x2E\x5B\x80\xB2\xB1\xC6\x1C\xFF\x03\x49\xD8\x62\x51\x6A\x03\x10\xD9\x76\xD2\x11\x1A\x4E\x80\x89\x8B\x00\x77\x06\xD7\xD7\x75\xBB\x8B\xD2\xBC\xDF\x0B\xAC\xB0\xA7\xD1\x73\x5D\xBB\x06\x01\xDD\x6B\xBA\xC3\xCA\x61\xFA\x04\xE7\xD8\xBC\x54\x12\x02\x1A\xDC\xCC\x01\x00\x0C\x0D\x3B\xB0\x92\x02\x30\xD6\x4E\xD5\x0C\x03\x8E\xDB\xA1\x11\x00\x36\xB1\xEE\xD8\x38\xD6\x4E\xD6\x0F\x04\x8F\xD3\x84\xDF\x63\xC1\xB0\xAA\xC3\x70\xCB\x25\x00\x21\xD8\x30\x31\x03\x0C\x0D\x09\xB0\xA3\x71\x70\xCA\x2C\x03\x22\xD8\x5B\x30\x04\x0E\x64\xC0\xB2\x98\xAA\x70\xCB\x32\x01\x18\xDF\x4B\x97\x37\x02\xAB\x32\xAB\x9A\xD8\x0F\x02\xBF\xA8\x90\xC3\x0E\x0B\xC9\xCE\x7F\x9D\xB2\xC1\x14\x9F\xD8\x22\xDA\x44\x04\x6C\xDC\x7C\xC1\x04\x25\xB2\xE0\xD4\xA7\xD9\x87\x03\x1A\x01\x95\xDC\xC5\xD8\xA4\xB0\x95\x8F\x01\xAF\xD9\x98\x35\x2C\xDB\xDA\x94\xCB", - "\xC5\x63\xF8\xAD\x9C\xD5\x9D\x01\x5C\xDA\x41\x01\x15\x0B\xCB\xD8\x88\xBD\xB2\xE2\xD7\x66\x80\xB8\xCB\x2A\x03\x92\xD5\x10\x18\x05\x05\xB3\x86\x02\x95\x00\x4B\xD8\xD6\xAC\xAA\xB1\x79\xDA\x05\x37\x0D\x12\xD7\x62\x50\x33\x4C\xF4\x2C\x57\x5B\x0B\x17\x66\xD2\x04\x3C\x01\xCF\xD9\x0C\x30\x1E\x51\x73\xDC\x7C\xDE\x05\x37\x0D\x4E\xD7\x71\x4C\x52\x02\xA9\xD0\x0F\x52\xBA\xCC\x3E\xC9\x03\x67\xD9\x64\x0D\x58\x03\x3A\xDE\x8B\x8F\x5E\xD4\x06\x02\xB3\x99\x30\xBE\x01\x63\xD8\x1E\x53\x76\xDA\xC7\x20\x07\x37\xB3\xED\x35\xCC\x00\x7D\xDA\xC9\xC0\xAE\xCC\x0E\x1F\x67\xEE\x88\x5A\x01\x02\xDB\x84\xB4\x5C\xC8\x1F\x06\xD0\xD3\xCD\x28\x03\x09\xDA\xCF\xB6\xB8\xC8\x01\x06\x75\x08\xCE\xC2\x43\x76\x03\x73\xD9\xA3\xA0\x4E\xD7\x03\x06\x75\x02\xC6\xC1\x2A\x46\xAE\xF8\x50\xDC\xD6\x26\xCF\x06\x04\xA3\xD4\x66\x11\x00\x1F\xB4\xE3\xD7\xEF\xCB\x13\x00\x49\xDB\x43\x1F\x01\x07\x69\xE9\x29\xF0\xCA\x33\x01\x95\xD8\x2A\x25\x05\x0E\xD2\xCA\x08\x1B\x2C\xB9\xC9\x32\xDA\xC0\x33\x0E\x05\xA6\xDD\x2D\xCC\x45\xF9\xB4\xD8\x35\x49\x00\x9E\xD8\x64\x7F\xBD\xC7\x05\x0E", - "\x1D\x2B\xB1\xD4\x37\xB1\x04\xD4\x30\x1E\x53\x81\xD1\x43\xC4\x03\x3F\xB4\x99\x30\x3B\xD6\xDE\x58\x1E\x53\x82\xDC\x64\xD0\x03\x0F\xB5\xED\x35\x43\xD6\xA9\xDB\x06\xD9\xF2\xCC\x07\x14\x68\xE4\x19\x02\x01\x7B\xD6\x3C\x50\xD4\xB4\xF9\xC7\x08\x1E\x6A\xDB\x28\x0F\x01\x61\xDB\xA9\xCC\xA7\xD2\x12\x06\xD4\xC4\x33\x1C\x02\x31\x05\xEC\x34\x3C\x50\x0D\xD9\xF2\xCF\x09\x0D\x6B\xDB\x28\x5F\xD6\x71\x58\x3C\x51\x0F\xDC\xC9\xCC\x0A\x17\x6A\xEE\x88\x3C\x01\x42\xDB\x82\x02\x11\xDC\x2F\xD8\x0B\x1E\x6B\xF3\x66\x73\xD6\x5A\xDA\x50\x79\xE4\xCC\x18\x06\xD7\xC8\x85\x18\x03\x49\xDA\x66\xB9\xD1\x8C\x5C\xC9\x1A\x06\xD8\xC1\x15\x67\x03\x01\xDB\x00\x00\x2F\xDA\xE1\xC5\x1B\x05\xD9\xD8\x15\x75\x03\x18\xDB\x52\x00\x38\xD9\x7B\x49\x1D\x0D\xD8\xC0\xCC\x03\x00\x3E\x30\x71\xDB\x93\xD4\xA7\xD6\x1E\x05\xDA\xD8\xD6\x13\x00\x28\xDB\x91\xDA\x33\x82\x68\xDA\x8F\x33\x00\x13\x0B\x07\xB5\xE3\x67\xB0\xDB\x5F\xBB\x22\x83\xB6\xDC\xD7\xB6\x6D\xE4\x19\x33\x00\xB9\xDB\x1D\x72\x4A\x74\xC9\xCD\x01\x1E\x6D\xDB\x28\x43\x00\x3E\x30\xA5\xD8\x24\xDC\x53\xDA\x02\x06\x6E", - "\xE8\x42\x52\x00\xC9\xDB\xD8\xDA\x42\x05\xA4\xA0\x24\xD7\x01\x33\x05\x36\x0A\x43\x01\xB9\x00\x66\x16\x07\x36\x9A\x38\x43\x62\xB2\x86\xC7\x45\x01\xEB\xD8\x30\x82\xBB\xD5\xA3\x5C\x6E\xD2\xB7\x87\x02\xAC\xD8\x26\xCF\x14\x02\xBC\xDD\x3D\x84\x6F\xCF\x04\x7D\x00\xE6\xDA\xDD\xD9\x46\xC0\xAE\xC1\x06\x0C\x6F\xFE\x22\xEE\xDB\x5C\xA3\xF8\xDA\x70\xD8\xC7\xAC\xA9\xCF\x03\x36\xB7\x87\x02\x7B\x00\xFC\xD8\xC8\xA2\xBF\xD6\x7B\xA3\x5C\xDC\xAA\xFD\x00\xCE\xDB\x09\x1A\x80\xDE\x20\x07\x0A\x11\x6E\xC5\x75\x80\x00\x62\xAE\x20\xC4\x23\x03\x2E\x08\xCD\xC1\x10\xD5\x32\x78\x50\xAD\xD3\xCB\xD3\x6B\xD0\x57\x4F\xCE\x19\xE9\x40\x89\x8D\x01\x14\xDD\xBD\xCF\x43\x07\x9D\x13\xA4\x48\x63\xC0\x00\x0E\x01\x21\xDC\x1E\xD1\x9B\xBB\x23\x7C\x7C\xCF\x04\x29\xB8\xC1\xCC\x8E\x21\x52\x70\x5C\xC8\x12\x0F\xE2\xCF\x33\xFE\x69\xC9\xD9\x9C\xD5\x48\x01\x8D\xDF\x4A\xAB\xE0\xD9\xC0\x3D\x71\xDA\x35\xB3\xD2\x89\x00\x25\x05\xC7\xDD\xAE\x28\x61\x3A\x72\x3C\x55\x96\x01\x1D\xDF\x81\xC4\x57\x09\xB4\xC0\x00\x1C\x73\xD6\xD8\x96\xD6\xC0\x33\x91\x19\xB4\xCC\xA9\xD7\x04\x0A", - "\xB9\xED\x35\xB6\x00\x1F\x30\xE0\x07\xC8\x18\x34\x54\x4D\xF6\xB8\xDF\x72\x5F\x74\x4E\xD6\x8B\x40\x13\x04\xE4\xCE\x11\x4A\x5E\x54\xDC\x91\xCE\x4D\x03\x95\xDE\x45\x47\x0B\x1A\x72\xFA\x77\x93\x31\x91\xCF\x4D\x03\x9A\xD9\xCA\xD6\x10\x1E\xD2\x47\x89\x41\xDC\x2A\xDD\x7D\x75\x41\x04\x9C\xDC\x64\xDC\x04\x33\x05\x15\xDA\x01\xC4\x5C\x00\x14\xDA\xCF\xD0\x00\x0D\x67\xCC\x99\xA7\x01\x7F\xDC\x32\x0D\x31\x03\xD0\xD3\x1E\xD8\x22\x9C\xAA\xB2\x01\xFF\xDA\x6C\x36\x34\x04\xC0\xDD\xE8\xD6\x4D\x11\x9E\xBE\x01\x91\xDD\x0C\x30\x38\x04\xD2\xDD\xAE\x6A\x08\x3B\xAE\xFC\xD2\xCA\x01\x4C\xDD\xBB\x36\x1D\x0C\xE9\xD4\xD7\x45\x04\x7D\xD4\xEF\xCA\x6B\x02\xA8\xDE\x45\x4C\x0F\x05\x75\xF8\x29\x4A\xD7\x4C\xCC\x71\x01\xA2\xDB\x43\x1A\x00\x0C\x66\xE6\xBA\x80\x00\xD4\xD7\x18\xC9\x3B\x03\xD5\xD0\x39\xD7\x1B\x26\x66\x78\x14\x21\xDA\xBE\xD1\x3E\x04\xD7\xDE\x4A\xDE\x75\xD6\xEB\x65\xA3\x9C\xD5\x02\x00\xE0\x55\xA3\xD8\x89\x66\x76\xD0\xEC\x00\x00\xEB\xD7\x18\xC9\x04\x03\xD9\xD4\x66\x01\x02\x0E\xBB\x8C\x76\x37\xDA\xC3\xC5\x07\x04\xDA\xDB\xA1\x0F\x02\x17\xBB", - "\x84\xDD\xB4\xD4\x26\xCD\x0A\x04\xDB\xD8\x0A\x3D\x02\x1F\xBB\x95\xDD\x8D\x7A\x4E\xD5\x0D\x00\x70\x57\xDB\xD9\x3F\xB7\x0D\x28\x33\x78\x14\xA6\xD9\x1A\xCA\x08\x04\xEE\xC0\xCC\x3A\x01\x67\xDD\x9D\xDC\x00\xDC\x5C\xCE\x09\x05\xEF\xD8\xD6\x08\x02\x78\xDD\xB7\xDC\x15\xCB\x7B\xCA\x0B\x00\xB8\x40\x74\xFC\x0A\x16\x01\xB6\xDC\x3C\x17\x58\xDC\xC9\xC5\x06\x05\x78\xE4\x19\x23\x01\x09\xDE\xB5\xD9\xE4\xC8\x0E\x0C\xEE\xC4\x33\x30\x02\x77\x06\xEC\x34\x3C\x17\x5C\xDF\xBD\xCD\x07\x15\x78\xDB\x28\x40\x01\x18\xDF\x63\xDC\x34\xD8\xAE\xCA\x08\x1D\x77\xD9\x60\x50\x01\x00\xDE\x3C\x17\x60\xD8\x48\xC6\x09\x06\x79\xED\x6B\x5E\x01\x29\xDE\x85\xD7\x7B\xCA\x14\x0E\xF1\xC8\x85\x05\xB4\xB9\x59\x78\x15\x2A\xD9\x0C\xCF\x15\x0E\xF2\xCE\x11\x7B\x03\x31\xDE\x19\xD7\xC8\xCF\x2E\x05\xE7\xD9\x32\xCE\x1D\x3F\xBA\xAA\xDB\x91\xCF\x63\x01\xCD\xD8\x30\x37\x01\x0E\x1D\x19\xBC\xC8\xDE\xF5\xD9\xA5\xDC\xB6\x32\xA5\xD1\xC7\x58\x53\x39\xB1\x91\xCF\xE1\x00\xA9\xDD\x06\x37\x06\x0E\xF4\xC2\x79\xF5\x7C\x3C\xDB\xDA\x16\x77\x02\xD6\xDD\x5D\x37\x04\x1D\x7A\xCF\xBB\xC1", - "\xD6\xED\x4B\x7D\x03\xD8\xD8\xDA\xCE\x3A\x10\x77\xCB\xB7\x91\xCF\x08\x00\xB9\x55\xBB\xDE\x0C\x0D\xF6\xDE\x7A\xF1\x55\x9C\xD5\x15\x00\xB9\x56\x4D\x09\x04\x02\xB7\x42\x0E\x35\x01\x46\xDE\x76\xDF\xEF\xD9\x0C\xCB\x04\x0A\xF7\xD7\xBF\x7D\xBD\xBD\xA0\x80\xDF\x67\xDD\x7A\xDC\x2F\xD1\x03\x05\x7C\xCF\x22\x07\xDF\x00\xD7\xC4\xDC\xC3\x76\x6D\xDF\x5E\xDF\x01\x0E\xBE\xA6\x7C\x90\xDF\xE9\xDA\xE4\xDC\xD0\xD9\x5E\xA0\x12\xCD\x01\x17\xDF\x67\x85\xCC\xDF\x41\x05\x15\x0B\xF9\xC8\x77\xFD\x00\xC0\xC4\x5B\x00\xB9\xDE\x44\x00\x0D\x02\xFA\xC4\x1F\xF5\xBD\xF6\x76\x8F\xC5\xF7\xCA\x1A\x02\x6E\x55\xE1\xDC\x15\x0B\x3F\x45\x76\x19\xDD\xD4\xD3\x86\xDA\xF0\x4E\x3D\x4D\xE0\x38\xB9\xB0\xDC\x6A\x7B\x27\xC4\x93\xCB\x0D\x04\xFB\xC4\x33\x0A\x03\x2E\x07\x80\x07\x9C\x7B\xA8\xCE\xC4\xDC\x06\x05\x7E\xDB\x28\x4B\x01\xC8\xDE\x01\xD9\xDA\xC0\xAE\xCD\x06\x0E\x7E\xE8\x42\x4C\x01\xD1\xDF\xE0\xDD\xAC\xC9\x86\xCE\x06\x16\x7E\xC0\x66\x4D\x01\xD9\xDF\xD5\x79\x47\x58\x48\xCF\x06\x1E\x7E\xD8\x6B\x4E\x01\xE1\xDE\x5E\xD5\x82\xD6\x70\xC0\x07\x06\x7F\xD9\x60\x4F\x01", - "\xE9\xDF\xA1\xD9\xB1\xC9\xF2\xC1\x07\x0E\x7F\xED\x6B\x50\x01\xF1\xDF\xD1\x78\x35\xD1\x8D\xC2\x07\x16\x7F\xEE\x88\x14\xDB\xCF\x55\x9C\x7A\xC1\xDD\xBD\x43\x07\x1E\x7F\xF3\x66\x52\x01\xF9\xDF\x74\xDC\xEA\x5C\x53\xD4\x07\x06\x80\xE1\x8A\x53\x01\x09\xE1\x9C\x79\xB8\xCA\x7B\x15\x07\x0E\x80\xF8\x8A\x54\x01\x11\xE1\x7F\x57\x7B\xCE\x0E\x06\x01\xE2\x3C\x55\x03\x19\xE0\x34\xC8\x52\xD5\x07\xE1\xCE\x46\x0D\x00\x81\xF0\xB5\x4F\xC5\x23\xE0\x31\x53\x35\x06\x04\xE9\xBA\x60\x12\xF9\x01\x29\xE0\x01\xC4\x6C\x00\x0B\xE5\x78\xC1\x79\xDA\x03\x36\xBF\xFB\x00\xAD\xDF\x6E\xB5\x02\xE4\xB9\x7C\xE7\xDC\x4B\xFD\x01\x72\x56\x03\xE1\x70\xB5\x6B\xDC\xC2\x7A\x10\x06\x74\xFC\xA5\x88\x01\x40\xE0\x32\x0F\x39\x03\x08\xE0\x00\x0C\xEE\x6A\xAE\xB1\xC8\x93\x00\xD0\xDC\xB6\x34\x1E\x05\xFA\xC4\x82\xFF\x13\xCC\xCF\x9F\x00\x29\xE1\x06\x32\x00\x03\x17\x06\xCD\x0C\xF7\x1F\xDD\x40\xC5\x55\x02\x16\xE5\x5D\x30\x01\x1D\x82\xF5\xF8\x07\x02\xA8\xDC\xE6\xCF\x2D\x03\x0C\xEE\x22\x5E\x00\x26\xC1\x9D\xC5\xCD\xB6\xB8\xCB\x30\x01\x09\xEB\xA1\x0C\x01\x09\xB8\xFB\x7B\x6C", - "\xA0\xB8\xCA\x33\x04\x0D\xE3\x9B\x39\x01\x2F\xC1\xA6\x7C\xDB\xD6\xB8\xCA\x36\x04\x0F\xE1\x2A\x47\x02\x3F\xC1\x89\x7C\x28\xDB\xFD\xCC\x21\xE0\x57\x45\x05\x07\x84\xF8\xC1\xAF\xDA\x9C\xD4\x79\x03\x22\xE2\xF0\x43\x06\x0E\x84\xD6\xC1\xA2\x96\x70\xCA\x7F\x03\x24\xE1\xCE\x41\x07\x16\x84\xCD\xC1\xBF\xA1\xCC\xCE\x05\x03\x6C\x04\xD9\xDF\x07\x1E\x84\xCC\xF7\x1E\xDC\x86\xC6\x0B\x03\x6C\x05\xDD\xD0\xE2\xD9\x65\x4C\xF7\x72\xDD\x1C\xD1\x11\x03\x28\xE6\xAD\xD6\x0A\xFD\x7C\x9A\xAC\xB3\xE1\x1B\x14\x55\x01\x2D\xE1\x68\xB0\x57\xDB\x01\x33\x06\x41\xE0\x0A\x02\x5C\x03\x1D\xE7\x12\xE5\x10\x0B\x78\xFC\xA5\xC6\x00\xBF\xE0\x45\xDF\x30\xE7\x13\xE1\xF7\x60\x7B\xC2\x27\x51\x00\xAB\xE0\x44\xD7\x5C\x04\x5D\x3C\xDC\x7B\x78\xCC\x9F\xDE\x00\xD1\xE1\x0D\x16\xAC\xD9\x8E\x5C\xDC\x7B\x6B\xFC\xA5\xEB\x00\xB8\xE0\x54\x22\x3C\x03\x17\xEA\x10\x0B\x79\xC6\x8E\xF7\x00\xE1\xE0\x1A\xC4\xE0\x56\x0B\xE2\xF3\xCC\x3E\xC3\x02\x59\xE1\xA8\x20\x07\x00\xE0\x50\x35\x3C\xDC\x7A\x79\xE9\x91\x90\x01\xE9\xE0\x6C\x37\xB6\xDC\xB7\x5C\xDC\x7A\x6C\xF1\x90\x9C\x01\xF9\xE1", - "\x0C\x33\x0A\x03\x1D\xE7\x06\xE5\x0B\x8E\xC3\xF3\x0B\xA8\x00\x78\xE0\x60\x31\x07\x00\xB8\x54\x86\xD0\xBD\xCC\xCF\xB5\x00\x85\xE0\x50\xDD\x21\xE5\x10\xFF\x7A\xDC\xAA\xC2\x01\x12\xE3\x0C\x31\x16\x04\x22\xE0\x07\xFB\x6D\xDC\xAA\xCF\x01\x19\xE3\x76\x35\x1A\x04\x23\xE0\x08\xE8\x64\xDC\xAA\xDC\x01\x21\xE2\x17\x45\x1E\x03\x1E\xE5\x11\xE0\x00\x0D\xB9\xFE\xD3\x29\xE3\xD9\x30\x22\x04\x25\xED\x11\xE4\xA9\xB0\x95\xF6\x01\x01\xE2\x70\x54\x29\x0A\x38\x07\x09\x04\x88\xF5\xC4\xCE\xAB\x9C\xD4\x02\x00\x29\x0E\xA6\x00\x01\x1B\x89\xFD\x59\xBE\xE2\x25\xE2\xAA\xD4\x5C\xCA\x02\x03\x14\xE1\x81\x46\xC5\xD1\xAD\x48\xE2\x44\xE2\x2D\xDC\x53\xD0\x02\x0D\x8A\xD6\xDD\x4F\xE2\x0A\x03\x60\x01\x54\xE7\x11\xEF\xCB\xD1\x3C\xEE\x00\x56\xE2\x82\xB4\xAC\xE3\x41\x07\x19\x0B\x15\xE4\x86\xD9\x02\xF0\xCA\x3C\x00\x52\x09\x3C\x09\x09\x02\x16\xE6\x08\x1D\x03\x34\xE2\x0A\x02\x2B\x7F\x91\xDD\xBD\x4B\x04\x04\x25\x35\xBE\xA3\x7E\x71\xE3\xCA\xD6\x67\xD2\xF7\xD1\x67\x47\xFA\x4C\xF7\x39\xDF\x5E\xDC\x6C\x36\xF0\x7F\xE8\x70\x18\xE2\x71\xC6\xB8\xB3\x32\x9C\xD4\x26", - "\x02\x5D\xE6\x30\xE4\x10\x9B\x0D\x8C\x99\xE7\xD3\x1B\x15\x60\x83\x68\x85\x30\xE9\xE7\xDD\x0C\x9F\x05\x91\xCF\x4D\x01\xB6\xE3\x92\xDF\x35\x8A\x13\x97\x3A\xDA\xC6\x93\xC8\x71\x4C\xE5\x82\x78\x54\x48\xD0\x19\xE8\x85\x0A\x07\xD8\x46\x6B\x3A\x3A\xDD\x06\x33\xA3\x1C\x90\x44\x52\xD1\x01\x1F\xE3\xA5\xE3\x25\x84\x78\x84\x53\xD3\x05\x10\x8D\xEA\xC6\x95\x85\x8F\x87\xC7\xE3\x6D\xE6\x45\x4C\x25\x96\xF4\x3F\xBE\xDF\xDC\x38\x87\x78\x84\x5C\xCD\x0A\x06\x1B\xFB\x8B\xFC\x0A\x74\x18\xE5\x84\x7C\xD1\x71\xE0\x35\xDC\x2B\x02\x52\x2F\x69\x3F\xE3\xA8\xD0\xE4\x86\xA3\xD9\xF2\xC9\x05\x0B\x8C\xD5\xC6\xAF\x87\x07\x8A\xE6\xCE\x16\x06\x3A\xE0\xFC\xC6\x1D\x83\xB4\x9C\xD5\x5B\x00\xEE\xE0\x70\xE2\x77\x8A\x10\x09\x83\xCC\x99\xDC\x00\xE2\xE3\xE8\xE1\xEC\x81\xA3\xD1\x79\xDD\x02\x29\xC7\x9B\xE3\xEB\xE2\x85\x01\xB0\xD8\x48\xCE\x05\x0F\x8F\xE0\xC6\xE2\x50\x09\x4A\xD5\xA2\x5D\xCE\x3E\xE1\x1B\xED\x1D\xA7\x29\x9C\xD5\x60\x00\xFE\xE3\x6D\xE1\xA1\x49\xED\xD1\x21\xE1\x01\x02\xE4\xC6\xE2\xE9\xE3\xAC\xD0\xB1\xC8\x20\xEC\x8E\xCA\xC8\x8A\xE0\xEF\xCB\x31\x03", - "\x72\xE2\xF0\x4C\x0E\x00\x5C\x40\x0E\x09\x4A\xB0\xE0\x22\xD5\x19\x05\x41\xEB\xFB\xDF\x37\xF6\xC2\x91\xCF\x66\x00\x0E\xE6\x6B\xD6\x43\xED\x0C\xFC\x54\xE7\x01\x13\xE4\x71\x4D\x76\x00\xE0\x57\x76\x45\x22\xF1\x3C\xE9\x01\x28\xE4\x62\x51\x77\x03\x8A\xE7\x41\xEE\x0D\xE0\x12\xEB\x01\x22\xE4\x1A\xDC\x12\xE5\x39\xE0\xAE\xCC\x06\x18\x91\xFC\xC5\xF8\xE3\xED\xE0\x26\xCD\x1B\x00\x46\xE1\x20\xD1\x07\x16\xC8\x8F\xE4\xF6\xE0\x0E\xD3\x1B\x06\x47\xE1\x18\xF8\x8E\xC1\xBD\xEF\xCB\x70\x00\x26\xE4\x99\x09\xA1\x41\xDA\xDC\x54\xF1\x01\x44\xE4\xBC\x04\x79\x03\x8C\xE1\x3E\xEF\xC6\xDC\x54\xF3\x01\x58\xE4\xD3\xB7\x2D\xE6\x77\xE2\xB6\xDC\xA9\xD5\x03\x20\xC9\x8F\x02\xF6\x00\x31\xE7\xEC\x86\x23\xE1\x79\xD7\x03\x27\xC9\x8A\x02\xF8\x00\x35\xE6\x7F\xE6\x24\xE1\x79\xD9\x03\x2F\xC9\x87\x02\xFA\x01\x23\xE4\x97\xE6\x20\x0F\x12\xE6\x1C\xFB\x01\x77\xE4\x06\x02\xB5\xDF\xB3\x51\xA1\x44\xDD\xC6\x1C\xFD\x01\x76\xE3\x7E\x00\x40\xE6\x93\xE2\x6B\xD1\x79\xC0\x04\x36\xC7\x81\x01\x8A\xE4\xF2\xE0\x7A\xD8\xAE\xC3\x08\x16\x8F\xC4\x02\x11\xE5\x09\x4A\xCA\xDC\xF3", - "\xCE\x10\x06\x1F\xE7\x04\x18\xCA\xA4\xAC\x70\xCB\x44\x02\x7D\xE2\x11\x0F\x29\xF8\x71\xD1\x9E\x8C\x01\x9F\xE2\x47\x03\x67\xE4\x1F\x0A\x27\xEC\x22\x8F\x13\xEF\xCB\x2E\x44\x48\x01\xA4\xE4\x52\x14\x3D\x89\x18\xD2\xC9\x9B\x14\x94\x15\x44\xD5\xE4\xCB\x12\x04\x4A\x1A\x1B\x17\x02\x37\xE5\xAF\xE5\x15\xB4\xA7\xD0\x13\x0D\x2B\xFE\x4F\x40\xCB\x93\x46\x3E\xB4\x60\xD9\xB1\xE3\xC5\xA7\x2C\xE5\x25\xAB\x69\x9C\xD5\xA2\x01\x65\xE5\xAB\xAD\x59\xED\x4C\x87\x08\x3D\x8F\x91\xCF\xA7\x00\x69\xE7\x41\x03\x15\x04\x2D\xF4\x26\xAB\x6A\x9C\xD5\xAC\x00\x6D\xE6\x41\x00\x16\x0D\x2D\xF4\x54\x19\x6B\x9C\xD5\xB1\x00\x71\xE7\xF3\xAD\x5C\xEF\xAD\xB0\x2B\xF6\x02\x6A\xE5\x00\x00\x5D\x00\xBB\xE1\x5C\xB0\x57\xDB\x05\x30\xCB\xBF\x01\xF3\xE4\x85\x00\xBA\xB1\xF2\xC0\x0C\x10\x97\xC4\x03\x79\xE5\x07\x02\x7C\xB5\xE4\xCD\x18\x00\x2F\xE9\x06\x00\xCC\xEE\xE2\x70\xCA\x65\x00\xBC\xE6\x19\x07\x30\xE5\x08\x11\x90\x91\xCF\xCF\x00\x78\xE7\x34\x05\x61\xE0\x00\x11\x54\xD1\x9E\xD4\x01\xF0\xE4\x6C\x01\xB7\xE2\xF2\x1D\x03\xE0\x12\xD9\x03\x24\x09\xC0\xE1\x83\x01\x3F\x03", - "\xEC\xD2\xF9\x06\x82\xC0\x89\xE4\x01\x20\xE6\x32\x0E\x02\x02\xF5\xD6\x8B\xD2\x15\xCC\x99\xEF\x01\x60\xE2\xA6\xDE\xDC\x56\x34\x32\xF9\x1C\x67\xD1\x37\x7B\x01\x31\xE6\x6C\x35\x09\x03\x66\xE9\x1D\xE5\x08\x20\xC1\x86\xC7\x07\x00\x44\x2C\xB3\xDB\x06\x0C\x33\xED\x99\xE5\xC7\xF0\xCA\x13\x00\xA1\xE5\xB5\xDD\x68\xEC\x50\x91\x68\xDC\xAA\x9F\x00\x88\x2D\x90\xE4\x9F\x2C\x65\xED\x34\xE0\xFA\xB0\x95\xAA\x00\x4A\xE7\x0D\x14\x17\x04\x69\xE7\x05\xF2\x2F\xE9\x9C\xD9\xE6\xA8\x21\xD9\xDC\x6F\x5A\xF2\x1A\x1F\xE6\x1C\xC2\x01\x60\xE6\x80\x32\x3C\x00\xD7\xE2\xA0\x85\xA6\x9C\x54\xCE\x01\x68\xE6\xD8\x34\x43\x03\xDA\xE6\xD2\xDD\xB5\x9C\x54\xDA\x01\x70\xE6\x19\x30\x4A\x03\xDC\xE7\x9A\x8A\x0B\xA0\x91\xF8\xCD\xED\x35\xA2\x01\xBD\xE6\xE4\x18\x15\xE1\x43\xD2\x03\x08\x5A\x6D\xDD\xB0\x00\xB9\x54\x6A\x32\xF2\x19\x21\xED\x61\xC0\x00\x7F\x00\x7F\xE6\x17\x47\x2F\x02\x70\xEF\x21\xEF\x2F\xCB\x02\x11\xE7\xB3\x33\x66\x00\xE5\xE4\x17\xE5\xE5\xD1\x9A\xE4\x19\x5B\x01\x54\xE7\xAE\xE4\x00\x06\x18\xE1\x37\xDE\x9C\xDB\x28\x68\x01\xA1\xE6\xB6\xE6\xE4\x7F\x20", - "\xE7\x46\x0D\x05\x07\xCE\xE4\x0C\xF5\x00\xB9\x54\xBB\x32\xF2\x16\x0D\xEC\x32\xFA\x02\x2F\xE7\x1B\x15\x02\x03\x6C\x03\x76\xE2\x11\x15\x91\xC6\x8E\xC7\x01\x98\xE7\x50\x45\x05\x03\x36\x04\x33\xEB\x90\xB0\x95\xD3\x01\xC1\xE6\x5C\x46\x2C\xE3\x6C\xE1\x24\xFC\x4B\xDF\x03\x38\xE7\xA8\x21\x18\x03\x6C\x03\x71\xE2\xD9\xDC\x54\xEC\x03\x49\xE7\x82\x4E\x20\x00\xF1\xE5\x67\xE9\xD9\xCB\x68\xD8\xCF\xFD\xE2\xDB\xE6\xA3\xE5\x97\xE4\x4B\xDE\x56\x2D\x77\xDC\x01\x3B\xE7\xDC\xE7\x2A\xE5\xE4\xC9\x02\x05\x3E\xE4\x33\x2C\x01\x68\xE7\xE2\xE7\x40\xD9\xE4\xCE\x03\x0D\x3E\xFB\x50\x3C\x01\x70\xE7\x55\xE6\xF9\xE7\x7B\xCB\x05\x05\x3F\xE8\x85\x0C\x02\x78\xE7\xA2\xE6\xB4\xDE\x1E\x38\x07\x0D\x3F\xE0\xCC\x00\xC4\xB9\x59\x92\x1F\x3E\xE5\x0C\xCD\x08\x05\x40\xF8\xD6\x2B\x02\x53\xE7\xDC\xE7\x42\xE5\x0C\xCA\x0A\x0E\x56\x36\x29\x1E\x01\x6E\x2A\xC2\x02\x5D\x01\xF8\xE1\x7F\xE5\x10\x02\x7C\xE9\x91\xE0\x00\x15\xE8\x4A\x90\x06\xEE\x1C\xBB\x41\xE2\x9D\xCB\xBE\xC0\xC4\x6E\x01\x10\xEB\xBB\x9B\x84\xEF\x10\x16\x06\x25\xD0\xAA\xE7\x6D\xD6\xB8\xC8\x1F\x02\x85\xEA", - "\x10\x08\x04\x2C\xD0\x8A\x02\xE4\x01\x17\xE8\xDD\xE2\xC0\xAC\xA9\xCA\x04\x34\xD0\x87\x02\x96\x01\x1B\xE9\xD9\xB2\x87\xEC\x37\xE7\x08\x27\xBE\x86\xC7\x98\x01\x06\xEA\xA6\x4A\x88\xE3\xD2\x48\xCD\x38\x32\x35\xE5\x86\xC7\x53\x02\x5B\x2F\x2E\xEF\x5D\x0F\x08\x3A\xCA\xEF\xCB\xA8\x00\xB7\x2A\xDE\x04\x15\x03\x45\xE4\x33\x38\x32\x2E\xB4\x7C\xD3\x56\x02\x16\xEA\x22\x01\x0B\x1D\xA2\xDB\x28\x38\x19\x3A\xB4\xBE\xD2\x2C\x03\x8C\xEF\x10\x16\x05\x26\xD1\xA8\x21\xB8\x18\x2F\xB4\x90\xC7\x16\x0C\x46\xFA\xBF\xAF\xD1\x80\x33\xB8\x19\x6B\xE7\x7B\xCC\x17\x05\x47\xE7\x08\x00\x03\x77\xE8\xD8\x34\x5C\x1A\xAB\xB0\x48\xC1\x0C\x1D\xA3\xC3\x63\x80\xE9\x19\x30\x5C\x1B\xB9\xE1\xF2\xC6\x0C\x06\xA4\xF2\xAD\x88\xE9\xED\x34\x5C\x18\xB8\xB1\xF2\xCB\x0C\x0E\xA4\xD4\x67\x90\xE9\x2E\x44\x5C\x18\xB9\xB1\xF2\xC0\x0D\x16\xA4\xD4\x03\x18\xE9\xB3\x32\x5C\x1B\xBE\xE7\xBD\xC5\x0D\x16\xA4\xD9\x03\x20\xE9\xA1\x44\x5C\x1A\xC0\xE7\xBD\xCA\x0D\x16\xA4\xDE\x03\x28\xE9\xB8\x44\x5C\x19\x01\xC9\xF2\xCF\x0D\x16\xA4\xE3\x03\x30\xE9\x94\xE0\x8F\xB7\x7B\xCC\x1C\x06\x49", - "\xE8\x07\x38\xD2\xF1\x4C\xB8\x18\x8B\xE7\x7B\xC9\x1D\x06\x49\xED\x07\x3F\xD2\xE2\x50\x8E\x8A\xC8\x34\x74\xE0\x3E\xEC\xB5\x3D\x98\xC6\x8E\xEE\x01\x6E\x2A\xA9\xE7\x03\x5A\x2D\xEC\xF3\x26\x99\xC6\x8E\xF9\x01\xD1\xE8\x32\x0C\x07\x04\x9A\xE2\xF2\x0F\x82\xE9\x91\x84\x00\x84\x2A\x66\xDD\x0A\x04\x94\x06\x9A\x3D\x37\x36\xCC\xDA\x17\x10\x01\x70\xE8\x99\x0F\x06\x04\x4E\xFC\xF9\x3F\xCC\xB1\xC8\x1C\x00\x75\xEB\x86\x15\x08\x0D\x4E\xE2\x79\x26\xC7\xFC\xD2\x28\x00\x79\xE8\x2A\x25\x36\xEC\xDB\x5D\x37\x30\xBA\xFC\xD2\x34\x00\xC2\x2A\x34\xEB\x52\x1C\x4D\xFC\xDA\x39\xBA\xE9\xC8\x3F\x00\x7D\xE8\x60\x36\x0D\x05\x4F\xFC\xDA\x33\xC7\x86\xC7\x4B\x00\x85\xE8\xB6\x34\x0F\x0D\x50\xF6\xAD\x25\xCD\xB1\xC8\x57\x00\x89\xE9\x06\x34\x54\xED\x4F\xFF\x8F\xD1\x9E\xE3\x00\x1A\xEB\x76\x34\xB1\xE5\xA3\xE2\xBF\xD1\x3C\xEF\x01\x21\xEA\x2E\x44\x53\x01\x45\xEB\x19\xD0\x00\x01\x77\xFC\xA5\xFB\x00\x28\xEB\xD9\x30\x2D\x03\xA5\xE1\x61\x84\x9C\xE9\x91\x87\x01\x84\x2B\x76\xDE\x30\x04\x94\x08\x9A\x3D\x37\x0D\xCE\xA6\xDC\x94\x01\x98\xE9\xA8\x41\x1A\x04\x53\xF4", - "\x30\x81\x9E\xF0\xCA\xA0\x00\xA1\xE8\xAE\x47\x1B\x05\x54\xFD\x37\x02\xBC\xCC\xCF\xAC\x00\x81\xE8\x99\x0D\x1D\x05\x50\xF6\xAD\x24\xCE\x86\xC7\xB7\x00\xA9\xEB\x86\x12\x1F\x05\x55\xEC\xA9\xF5\xCE\xFC\xD2\xC2\x01\x9C\xE8\x99\x09\x68\xE1\xC7\x5D\x37\x1F\xD5\xC0\xC4\xCF\x00\xB1\xEB\x86\x17\x02\x08\x68\x2C\xD7\x3D\x1B\x3E\xE7\x31\xC8\x6E\x02\x52\xEA\xF0\x47\x02\x08\xB4\x25\xD3\xC6\xE7\x9C\xD4\x74\x03\x5C\xE9\xCE\x45\x03\x16\xAB\xFC\x7C\x25\xDC\xBC\x54\x7A\x02\x5A\xE8\x15\x23\x04\x08\xB4\x3D\xD4\xD5\xE7\x91\xCF\x00\x00\x76\x54\xD9\xD2\x05\x1E\xAB\xE2\x3C\x7E\xE1\x69\xC9\x06\x03\x62\xEC\xCC\x00\x06\x0E\xAC\xDC\x6D\x6A\xE7\xEF\xCB\x0C\x00\x76\x55\xDD\xDE\x06\x0D\xAB\xFC\x7C\x18\xEB\xCC\xCE\x13\x03\x66\xEC\xCC\x0E\x07\x1E\xAC\xE2\x3C\x57\xDE\xEF\xCB\x19\x03\x68\xEB\x43\x1E\x08\x06\xAD\xDC\x6D\x28\xEB\xCC\xCE\x20\x03\x6A\xE8\x15\x2E\x09\x0E\xAD\xF6\x56\x02\xE8\xD1\x1B\x26\x03\x6C\xE8\x30\x3E\x0A\x06\xAC\xFC\x7C\x0A\xE8\x69\xC8\x2D\x03\x6E\xE8\x5B\x3D\x0B\x1E\xAD\xE2\x3C\x12\xE8\x69\xC9\x33\x03\x64\xED\x81\x98\x9D\x42\x0E", - "\x0C\x03\x16\xEB\xB6\x2A\x0F\xE8\x07\xD5\x0E\x0B\x5C\xFE\x7A\x8D\xD7\xE3\xB5\xD0\xEA\x96\xEB\x09\xEE\x70\xC3\x08\x15\xAE\xC7\x04\x0F\x01\xD7\xEB\x89\xB5\x76\xE9\xC2\x8A\x29\xEC\x32\xD1\x02\x5E\xEB\x1F\xCD\xF0\xEA\x42\x06\x1E\x03\x5E\xE6\xAA\xEF\x58\xA5\xCF\xE8\xEB\x82\x03\x2A\x02\xBD\xED\x17\x0E\xAB\x37\xD5\xA6\xE5\xEF\xCB\x56\x03\x70\xED\x20\x0A\x0B\x14\xAF\xED\xB2\x6E\x2A\xA8\x33\xC7\x4A\x33\xE9\x86\xCC\x0B\x18\x4E\x43\xD4\xA1\x00\x4A\xE8\x2E\x8D\xC8\xB4\x37\xD6\x60\xFC\xF3\x89\xD8\x8F\x4B\xDE\xE8\xE7\xD1\x7C\xED\x5D\x3B\x03\x16\xAF\xD2\x19\x9C\xE8\x7C\xD2\x6F\x03\x84\xEE\x45\x49\x04\x16\xB0\xD4\x19\x86\x02\xEF\xE9\x34\xCA\x3A\x03\xC3\xE3\x9B\x37\x02\x1E\xD8\x8A\x02\x8F\x4B\x7B\xE8\x90\xC6\x1E\x04\x62\xE1\x15\x65\x01\x27\xEC\x50\x8D\x38\xE0\xA7\xD2\x00\x07\x4F\x43\xA8\xF3\x01\x0F\xEC\x79\xE0\x4E\xD5\x03\x07\x9E\x4C\xEC\xC0\x04\x30\xD8\xD7\x8C\xF2\xE2\xB8\xC9\x06\x04\xC7\xE4\x66\x0E\x04\x3F\xD8\xD2\xD1\x9A\xA2\xB8\xC9\x09\x04\xC8\xEB\xA1\x1C\x04\x07\xD9\x8A\xEC\xC8\xC5\xF7\xC9\x0C\x04\xC9\xE8\x0A\x2A\x05\x0F", - "\xD9\x8F\x4B\x05\xE5\x34\xC9\x0F\x04\xCA\xE0\x98\x38\x05\x17\xD9\xA0\xE1\x4C\xCD\x24\x00\x97\xE8\x5B\x3D\x48\xFC\x6D\x4F\x96\x36\xEA\x1C\xD1\x2A\x03\x3D\x4D\xDD\xDF\x49\xF9\x65\x4F\x96\x3F\xEA\xBC\x54\x31\x03\x98\xE9\x03\x37\x4B\xE6\xB3\xD5\xCE\xCC\xCF\x6E\x01\x39\xED\xBB\x31\x1E\x0F\x65\xFC\x9C\xF5\xC0\xB5\xEC\xFD\x0E\x1C\xEC\xD7\xB4\xF9\xC5\x08\x00\xB4\xDD\x91\x83\xEB\x31\xED\x15\xD9\xD4\xD3\xCD\xE4\x66\x19\x00\x04\x56\x6C\x35\x8F\x4B\xB3\xEA\xE1\xC5\x13\x0C\x68\xFB\x50\x29\x00\x0F\xED\x17\xED\x83\x00\x5C\xE9\x8D\xCA\x0A\x1A\xB3\xEE\x88\x39\x00\x84\x2A\xD3\x33\x63\x4E\x1C\xE1\x43\xD6\x05\x1E\xDA\xB3\x33\x47\x01\x50\xED\xA6\xEF\xA4\x7C\x7C\xC2\x06\x15\xDA\xA6\xE3\x84\x2B\x00\xEC\x62\xEF\xBD\xCF\x0C\x07\xB5\xE1\x8A\x64\x00\xAA\xED\x0F\xEC\x83\x94\x70\xD6\x6B\xF8\x15\x72\x01\x39\xED\x28\xED\x87\xE0\x93\xCF\x1C\x0F\x6A\xE0\xCC\x00\x02\x18\xED\xBA\xEC\xB7\x80\xEB\xE4\x57\x04\x0F\x05\xB6\xD8\x6B\x10\x01\xC8\xED\x60\xEC\x99\xE1\xB1\xEE\xA4\x0D\x77\xC9\xD5\xF1\x58\x8F\x4A\xD8\xE8\x93\xCE\x01\x05\x6D\xF6\x78\xD1\xDB", - "\x89\xED\xDD\x71\xC8\xCF\x06\x05\xDB\xEF\xF1\xD1\xB5\xEB\xDA\x85\x02\xC0\xEA\x0E\xD0\x0A\x04\xDC\xE8\x0A\x29\xAB\xEE\xD9\xD0\xD6\x91\xCF\x1A\x02\x93\x16\xA6\x01\x04\x0E\x52\x02\x07\x5E\x01\xC0\xEC\x70\xEC\x50\xE1\xF2\xC3\x04\x13\xB7\xF5\xFF\x76\xED\x23\xB7\x7C\xEC\x90\xEB\x52\xEC\xA9\xD1\x02\x3E\xDB\xD3\x16\x00\xEE\x43\xBA\xC0\xE8\xC9\xEF\x10\xD0\x2B\xDF\x01\x07\xEE\x0A\x03\x35\x01\xC2\xE8\x66\x58\x9D\x42\xB5\xE0\xCA\xF3\xD7\x10\xEE\x9E\x9F\xC4\xEA\x7F\x55\x71\xE7\xB7\xE7\xC5\x9C\xD5\x7B\x00\x76\xEF\x41\x00\x11\x0B\x71\xE2\x62\x18\xA7\x28\x33\x63\x8C\x28\xE9\x0C\xCA\x11\x0E\xA4\x14\xA2\xD0\x1A\x97\xB4\x70\xCB\x45\x02\x93\x12\x6F\x0F\x08\x0D\xB9\xE4\x19\x63\x8C\x60\xE8\x7D\xC7\xCC\xEA\xC8\xD6\x73\xFB\x50\x23\x19\xE9\xE8\x40\xC5\x4A\x03\xCE\xEB\x5E\xAD\x73\xE8\x85\x23\x19\xF2\xE8\x86\xC6\x4D\x03\xD0\xEF\x21\xC5\x74\xE0\xCC\x23\x19\xFA\xE8\x58\xE1\xA5\xEF\x41\x03\x14\x0D\x74\xF8\xD6\x23\x19\x83\xE9\x86\xC6\x52\x02\xD4\xEE\x20\x08\x0A\x15\xBA\xD9\x60\x63\x8C\x8B\xE9\xF7\xC9\x2A\x03\xEB\xE5\x10\x0D\x05\x1E\xDD\xED", - "\x35\x63\x8D\x49\xE9\xD9\xD4\xEC\xE4\x63\xC7\xBB\xEE\x88\x63\x8C\x9B\xE8\x1C\xCC\xDB\xEF\x16\x0E\x76\xF3\xCD\x23\x19\xA3\xE9\x83\xD2\xB6\xEC\x2F\x05\xEE\xE1\x2A\x43\x33\xAB\xD2\xCC\xCF\xBD\x00\xB6\xED\x30\x04\xEF\xE8\x2B\x43\x33\xB3\xD2\x8F\xD3\x6C\xEE\x63\x00\xE1\xEA\xF0\x43\x66\x8F\x98\xEF\x97\xC7\x01\x6C\xEF\x65\x03\xE2\xE9\xCE\x43\x66\x82\xA6\xCC\x9F\xCC\x01\x6C\xEE\x68\x03\xE4\xEA\x0C\x5E\x6D\x83\x33\x94\xC6\xDD\xE3\x0F\xBD\x64\xEF\xE7\xEB\x3C\xEE\x7A\x8B\x86\x0B\xD3\xF7\xE3\x01\xC4\x02\x93\x80\xE9\x8D\xC1\x0D\x0E\x52\x03\xD4\xAA\xEB\x58\x22\x02\x92\x35\xE9\xAE\xEE\x7A\xE4\x33\x32\xD6\xB1\xEF\xF4\xD8\xE6\xCF\x39\x01\xE3\xE8\xAD\x3A\xAD\xFC\xB6\x04\x90\xE7\xE8\xE1\x13\x3C\x04\xF7\xE9\x81\x3B\x02\x1D\xDC\xB2\xD9\xDF\xE3\xC8\xCF\x3F\x04\xF8\xE2\x12\xE7\xBE\xD1\xDC\xC3\xD7\x9C\xD5\x05\x03\xA7\x54\xD9\xD7\x07\x0E\xBE\xFF\x20\xCE\xE6\x91\xCF\x0B\x03\xA7\x53\xA0\xE5\x08\x1B\xAF\xF9\x1F\xB9\xEC\x91\xCE\x11\x03\xF4\xEC\xCC\x02\x09\x16\xBE\xC6\x20\x81\xE1\x9C\xD4\x17\x03\xF8\xEB\x43\x10\x0A\x06\xBF\xC0\x20\x89\xE1", - "\x4C\xCC\x1D\x03\xFA\xE8\x15\x2E\x0A\x0E\xBF\xDF\xDF\x90\xE1\x91\xCE\x23\x03\xFC\xE8\x30\x35\x60\xFF\xBD\xD4\x2D\x91\xCF\x52\x01\xFD\xEC\xB6\x32\x19\x06\x7F\xE4\x40\xAE\xD4\xF4\xE3\x02\xF1\x0C\x30\x36\x05\x00\xF2\xFD\xD1\x3C\xEA\x01\x1F\x55\xED\xDC\x73\x03\xC9\xE9\x08\x9A\xFC\x84\x55\xC9\xE0\xED\x35\xF5\x00\x06\xF1\xB3\xD4\x52\xE7\x81\xEE\x11\x43\x00\x77\x49\xA6\x32\x02\x93\x53\xEC\xC9\xCF\x08\x1B\xBE\xE5\xB4\xCE\xED\xEF\xEF\x41\xEC\x93\xCA\x13\x06\x82\xFB\x50\x1E\x00\x28\xF0\xF7\xEE\x45\xED\xE4\xCD\x14\x00\x81\xE4\x33\x2B\x00\x77\x49\xEC\x34\x02\x92\xA4\xE9\x86\xC2\x0B\x15\xC1\xDB\x28\x3B\x00\x38\xF0\x0A\xF3\x43\x03\xD3\xEC\x81\xDF\x05\x1D\xE0\xB3\x33\x4B\x00\x10\xF2\x10\xF3\x47\xEC\xA9\xCB\x06\x07\xE1\xDE\xCD\x4A\xF0\xE4\xEE\x62\xDF\xBD\xC7\x0D\x1E\xC1\xC6\xDD\xF7\x49\xA8\x32\x02\x91\x92\xE4\x48\xD4\x0E\x0F\xC2\xF8\x8A\x76\x00\x51\xF1\xE7\xEF\x93\xE4\xF9\xC0\x0F\x1E\xC2\xC2\x9E\x04\x01\x61\xF1\xEB\xEF\xF8\xE7\xBD\xCC\x0F\x16\xC2\xC0\x66\x12\x01\x41\xF0\x29\xF0\xC8\xD4\x53\xD9\x00\x1E\x5E\x6D\xBB\xA2\x01\x71", - "\xF0\x31\xF0\x9B\xE7\xBD\xC6\x01\x16\xC3\xE4\x19\x32\x01\x79\xF0\x35\xF2\xFE\xE4\xF9\xC3\x02\x1E\xC3\xDB\x28\x2E\xED\x71\x58\x02\x90\x6E\xEA\x7B\x10\x03\x06\xC4\xE8\x42\x52\x01\x58\xF1\x25\xF3\x41\x01\xDD\xE4\xA4\xDD\x01\x0E\xE2\x80\x33\xE1\x01\x48\xF2\x1C\xF6\x26\xEC\xA9\xCA\x02\x1E\xAF\x36\x0A\x56\x00\xEF\x56\x70\x00\x1E\x09\x86\xE7\xBF\xE1\xB2\x91\xD9\x9F\xF0\xCF\x8A\x28\xF2\x22\x0E\x0F\x05\xC5\xE9\xE0\xCA\xE2\x9C\xD4\x33\x01\x2A\xF0\x6A\x9B\x8A\xF5\x29\x0E\x29\x21\xF0\x12\x03\xF2\xE8\x5F\xD4\x0E\x03\x8B\xE7\x80\xB5\xE2\x84\x44\xB7\xF0\x49\xF0\x0F\xE9\xF2\xC2\x08\x1D\xC5\xEB\x8B\xBF\xF1\x07\x03\x75\xEE\xFF\xE8\xBF\xEC\x7C\xD0\x04\x17\xE2\x9F\xCC\xC8\xF1\xAD\xAE\x93\x10\x35\x35\x85\x8B\xBD\xDC\xA0\x9F\x01\xDE\x57\x81\xE9\x11\x02\xE4\xE4\x85\x83\xDA\x9C\xB0\xD9\xF1\x64\x0C\x29\x00\x37\xF2\x12\x9E\x32\xFC\x4B\xF5\x02\x46\xF1\xD8\x35\x87\xEC\x6F\x5D\x0A\x91\x7C\xF3\x2F\x01\x03\x68\xF1\x19\x31\x36\x01\x30\xF7\x21\x05\x85\x81\xB1\xDC\xA0\xCD\x01\xF0\xF1\x76\x35\xC8\xEB\x1D\xF0\x7D\xF1\x3C\xD9\x03\x79\xF1\x2E\x45", - "\x44\x03\x3C\xF4\x0D\x94\xA8\xDC\x54\xE5\x03\x60\xF1\x1B\x15\x4B\x03\x38\xF0\x00\x05\x85\x87\xA8\xDC\xA0\xF0\x01\x00\xF3\xD9\x32\xD6\xEC\x1F\xFF\x10\x0F\xA8\xF1\x90\xFC\x01\x11\xF3\x50\x46\x2C\x03\x20\xF7\x10\x15\x42\x97\xD4\xE9\xC8\x08\x00\x4B\x5C\xB3\xD8\x18\x0C\x91\xFD\xC6\xF8\xDF\xEF\xCB\x14\x00\x91\xF0\x99\x0E\x19\x05\x92\xE4\xC7\xF6\xB4\xF0\xCA\x20\x00\x95\xF3\x86\x14\x1B\x0D\x92\xEC\xC8\xE0\xD9\xFC\xD2\x2C\x00\x99\xF0\x2A\x22\x1D\x05\x93\xF5\x42\xA8\xD9\xC4\xD4\x38\x00\x4B\x5D\xBB\xD8\x1F\x03\x8D\xF4\x44\x95\xE0\xE0\xDB\x3A\xF2\xC0\x33\x01\x07\x53\x56\x9A\x35\x42\x94\xB5\xFC\xD2\x51\x01\xA4\xF0\xB6\x35\x02\x0C\x94\xE6\xCA\xFE\xD9\x95\xD5\x96\x5D\x81\xEB\x08\x06\x0D\xF6\x92\xFB\xDA\x91\x9E\xE8\x00\x59\xF2\x32\x0C\x0C\x04\x2B\xFE\x92\xE1\xFA\x4B\xDB\xCF\xCB\x42\xF2\x32\x0D\x0F\x07\x53\x5C\xAE\x35\x42\xBB\xE0\xE9\xC8\x80\x01\xB4\xF3\x86\x15\x09\x0C\x96\xF6\xCA\xE7\x4B\xF0\xCA\x8D\x00\xA9\xF1\x06\x35\x0B\x05\x95\xF4\xC7\xF8\xD5\x91\xCF\x99\x00\xBD\xF1\xBB\x33\x0D\x0D\x97\xE4\xC8\xD3\xE1\xCC\xCF\xA5\x00\xB9", - "\xF0\x2A\x21\x0F\x0F\xA9\x54\xC6\xF3\xDA\xCC\xCF\xB2\x00\xC1\xF2\x8B\x40\x11\x05\x98\xFD\xC8\xDD\xB1\xF0\xCA\xBE\x00\xC9\xF3\x6C\x36\x12\x05\x99\xFD\xCA\xEB\xE1\xCC\xCF\xCA\x00\xC5\xF0\x60\x34\x14\x05\x97\xFE\xCB\xE6\xB1\x9C\xD5\xD7\x00\xD1\xF0\xB6\x34\x16\x05\x9A\xE6\xCC\xFB\xE1\xCC\xCF\xE4\x00\xD5\xF1\x06\x34\x18\x0D\x9A\xF6\xCC\xD3\xDB\xEF\xCB\xF1\x00\xD9\xF1\xBB\x34\x1A\x05\x9B\xFE\xCC\xEC\xB8\xCC\xCC\xFE\x00\xDD\xF2\x8B\x45\x0B\xF9\xCB\x55\x42\x94\xE2\x8E\xE7\x0B\x00\x51\x59\xBB\xDB\x1E\x0D\x98\xF6\xCB\xDC\xE2\x91\xCF\x18\x00\x51\x5A\x4D\x0C\x04\x02\xCA\x47\x37\x5E\xAF\x4D\xF2\x12\x02\xE9\xE8\x91\xD6\x04\x02\x9D\xFE\xC2\x55\xE7\xB0\x0D\xD7\xF2\xE7\xF3\x87\xC8\xAE\xC4\x03\x1D\xCE\xE5\xE2\x5F\xF3\x43\x61\xF0\xF2\x69\xF5\xE1\xEC\xA9\xC2\x02\x26\xE7\xB0\x52\xE8\xF2\xEB\x6E\x7A\xF6\x35\xF7\x10\x1D\x7C\xC6\x8E\xD0\x00\xEF\xF2\xBC\x15\x7C\xF7\x20\x0A\x03\x13\xCF\xF6\xE6\x87\xE3\xEF\xCA\x2F\x02\x72\xF1\x08\x9B\x9F\xFF\xAB\x1E\xAF\x28\x33\x7E\x50\x95\xEF\x49\xD2\x94\x5E\x72\xE7\x08\x3E\xA1\x57\xE8\x78\xEC\x51\x5A", - "\xDE\x02\x0E\x0C\xA0\xE4\x33\x3E\xA1\x39\xEE\x86\xC7\x39\x02\x84\xF0\xCD\x95\xA1\xFB\x50\x3E\xA1\x40\xEE\x86\xC6\x3C\x03\x86\xF7\x21\x0C\x07\x1D\xD0\xE8\x42\x7E\x50\x48\xEF\x18\xC9\x1F\x03\x44\xFE\xF5\x86\xD1\xC0\x66\x7E\x50\x50\xEF\x9C\xD0\x8B\xF4\x17\xAE\xA2\xF8\xD6\x3E\xA1\x58\xEE\x31\xC9\x43\x03\x8C\xF7\x5B\x45\xA3\xF1\xC7\xD2\x04\x61\xEE\xCC\xCE\x46\x03\x8E\xF5\x20\x00\x09\x1D\xD1\xED\x6B\x7E\x50\x6A\xEF\x5A\xD7\x90\xF0\x00\x05\x09\x06\xD2\xEE\x88\x7E\x50\x71\xEE\xE6\xCE\x25\x03\x49\xFA\x09\x0E\xD2\xF3\x66\x7E\x50\x78\xEE\x26\xCF\x26\x03\x49\xFF\x09\x16\xD2\xE1\x8A\x7E\x50\x7F\xEE\x26\xCC\x28\x03\x49\xF4\x0A\x1E\xD2\xF8\x8A\x7E\x50\x87\xEE\xC4\xF3\x92\xF1\x15\x06\xA6\xE2\x3C\x7E\xA1\x0E\xEF\xCC\xCE\x55\x03\x92\xF6\x15\x0D\xA6\xF1\x33\x7E\xA1\x16\xEF\x4C\xCD\x57\x03\x92\xF3\x16\x05\xA7\xE2\x43\x7B\x23\x85\x51\x50\xDD\x04\xE7\x86\x15\x29\x95\x85\x83\xBD\xEA\xC7\x8A\x02\xDA\x92\x02\x92\xA1\xF4\x99\xED\x36\xFF\x1E\xB0\x95\xB4\x01\xA2\x59\x8A\xD2\x8B\x43\x4E\x90\xA1\xEC\x32\xF7\x02\x22\x59\xF7\x31\x5E\x01\x9F", - "\xF1\x40\xC3\xA7\x98\xD0\xF1\x90\xBE\x01\x98\xF5\x59\xB3\xA6\xF4\x57\x03\xA7\x80\xD1\xF1\x90\xC5\x01\xA1\xF4\xE4\xB3\xA8\xF6\xA3\xEF\x2C\xF1\x3C\xCC\x03\x29\xF5\x0A\x02\x69\x03\xAA\xF7\x24\xF6\x10\x11\xD1\xFC\xA5\xD3\x01\xB0\xF5\x83\x01\x36\x03\x56\xF1\x65\xEA\xD6\x91\x9E\xDA\x01\xB9\xF4\xF8\xCC\xAF\xF5\x51\xF7\x10\x00\xD2\xCC\x99\xE1\x01\xC1\xF5\x82\x03\x39\x03\x58\xF8\xAA\x8A\x08\x09\xE9\xCC\xCC\xE8\x01\x64\xF4\x00\x06\x1D\x0C\xAC\xE5\x08\x33\x29\xD1\xF4\x2F\xE6\x69\xF5\x3D\x05\x5A\xF0\xED\xC7\xD7\xB7\xC4\xD2\xF5\xFC\x00\x6E\xF7\x9C\x91\x4C\xFC\x97\xDD\x07\x12\xEB\x83\x00\x01\x50\x0D\xC7\x9C\x91\x4D\xFC\x64\xC4\x00\x01\xA0\x77\x31\x0A\x01\x74\xF4\x99\x0B\x4E\x90\xA7\xEC\x32\xCB\x00\x6F\xF5\x71\x06\x79\xF7\x86\x13\x4E\x98\xA7\xFC\x4B\xD2\x00\x78\xF5\x62\x5E\x7D\xF4\x2A\x23\x63\x9B\xCD\xCD\x2F\x59\x00\x02\xF6\x73\x5B\x00\x51\x36\x0E\x7B\x50\x38\x0B\x5E\x86\x32\x8B\xF5\xA8\xEE\x5E\x07\xF2\x96\xDC\x90\xB1\xFD\x8F\xC5\x04\x06\x99\x05\xF6\x3D\x38\x07\x00\x61\xF6\x10\x1D\x00\x0A\xEC\x9B\x4B\x0C\xF6\x12\xBD\x22\x9A", - "\x2F\xEE\x20\xFB\x50\x39\x33\x94\xF6\x81\xF5\x92\xF4\x2A\x24\xB7\x96\x8D\xE4\x52\xDF\x00\x01\x50\x03\xEB\x2C\x03\x33\xF7\xBE\x9E\x8D\xF1\x3C\xEA\x00\x30\xF6\x64\x0C\x59\xF0\x56\x24\xB7\x91\x61\xE4\x52\xF5\x00\x01\x50\xCC\xDD\x39\x02\x7F\xF7\xC2\x91\x3F\xEC\x32\xC1\x01\x40\xF6\x64\x0D\x40\x03\xD0\xF4\x66\xF9\x2E\xB0\x2B\xCD\x01\x48\xF6\x67\xDB\xA5\xF4\x00\x04\xB7\x9A\x62\xE6\x1C\xD9\x01\x50\xF6\xA8\x21\x4E\x02\xD4\xF4\xB7\x9F\x4F\xE0\x12\xE5\x01\x38\xF6\x1B\x15\x55\x03\xCC\xF3\x6A\xF0\x7E\xF0\x92\xD8\xED\xDD\xEC\x5B\xF6\xF4\xEC\x57\xDF\x6C\xF4\x66\xE9\xDB\xC9\xD9\x9C\xD5\x88\x00\xB6\xF5\x06\x34\x1A\x0E\xB6\xFD\xD5\xD2\xA5\xF2\xF6\xED\x34\x71\x01\xDD\xF5\x6E\xE1\x79\xC0\x05\x38\xED\xAE\x44\x10\xF2\xDE\x58\x6F\x9F\x00\xF6\x38\xCC\x05\x3F\xED\xB3\x33\xFE\x01\xBD\xF6\xFC\xDC\xC9\xC8\x0B\x01\x40\x6D\xBB\x8C\x00\x96\x5C\xD4\x30\x6F\x98\xCE\xED\x5E\x45\x06\x07\xEE\xA1\x45\x1B\x00\x4B\x5E\x69\x34\xB7\x9F\x94\xE0\x12\xD1\x03\x17\xF7\xB8\x45\x14\x02\xE6\xF2\x22\x0C\xDB\x83\xC1\xFC\xA5\xDD\x01\x60\xF6\x54\x23\x0D\x02\x37", - "\xFC\xDB\x97\xAA\xF1\x90\xE8\x01\xA9\xF6\xC0\x30\x11\x04\x75\xF2\xF1\xCF\x2F\xF3\x03\x0E\xF7\x64\x0D\xA8\xF1\x1C\x5C\xB7\x9F\x96\xFC\x40\xCA\xFA\x6D\xDD\x61\x00\x4B\x5C\xBB\x34\xB7\x94\x84\xE4\x52\xCD\x00\x42\x15\xCC\xDD\x38\x03\xE8\xF6\xC0\x9C\x84\xF1\x3C\xD9\x00\x48\xF7\x64\x0D\x3F\x03\xF2\xF2\x21\x0C\xDB\x80\xAC\xED\x97\x25\x00\xC2\x14\x56\xE1\xE4\xF4\x74\xFF\x98\xEC\x32\xF2\x00\x50\xF7\x4D\xED\xE9\xF7\x7E\x9F\x32\xF2\xC8\xC0\xDF\xD5\xD9\xE2\xF7\x44\xF7\x39\xF1\xE4\xCA\x09\x09\xBD\xE4\x33\x38\x02\x42\xF7\xDC\xF7\xD3\xF1\xE4\xCF\x0A\x0D\xBE\xFF\x5D\xF0\xEF\xCC\xF7\x46\xE9\xB3\xF3\x43\x04\x0C\x05\xBF\xEE\x6C\xF7\xEF\xD4\xF7\x78\xD8\xFD\xF5\xA1\x95\x7F\xF0\x98\x28\x07\x3F\xEF\xE3\xF7\x74\xE5\xF7\xCA\x1F\x04\x80\xF8\xAD\x38\x07\x1B\xEF\xF8\xF7\x7C\xE5\x98\xEC\x03\xF9\x63\xC2\xCA\x52\xDC\xF0\xDB\xEF\xCB\x98\x00\xF3\xF7\x41\x04\x14\x02\xAC\x02\x0E\x16\x00\x22\x59\x9B\xF7\xEC\xF0\x5C\xCE\x14\x0A\xC1\xE6\x08\x32\x02\x1D\xF8\x33\x10\x10\xF9\xFC\xF0\x16\xF1\x79\xD4\x05\x25\xF0\xE6\xC0\x28\xF8\xA0\xAE\x0A\xF8\x82\xF1", - "\x43\xF7\x88\xEF\xF0\x80\x00\xCE\x01\x18\xF8\x6B\xBB\x86\xF0\xC0\xFC\x6F\xDC\xD2\xB7\xF8\xDC\x00\x1D\xF9\xD0\x7C\x87\xF8\xC0\xE0\xD0\xCC\x9F\xDE\x01\x13\xF9\x42\xDE\x10\xFA\x6E\x85\xC1\xE1\x75\x9D\x0F\xF0\xCA\xED\x00\x61\x15\x83\xF6\x20\x08\xE7\x95\xD4\xFC\xA5\xEE\x01\xC2\x14\xBD\x06\x3C\x02\x8A\xF4\x66\x18\x73\x9E\xEA\xE9\xC8\xF3\x01\x2C\xFB\x10\xBC\x8B\xFB\xA1\x18\x73\xA6\xEA\xE9\xC8\xF8\x00\x31\xF8\x25\xBC\x8C\xF8\x0A\x38\x73\xA9\xE8\xE9\xC8\xFD\x00\x35\xF9\x8C\x46\xB8\x4A\x21\xD8\x73\xB6\xEA\xC0\xC4\x02\x00\xE3\x4A\xDE\x06\x00\x04\xC7\xFD\xE2\xDA\x6B\xEF\xCB\x07\x00\x3D\xF9\xDC\x55\x8F\xF5\xC6\xFF\xD1\xF0\x95\x8C\x00\x82\xF8\x3B\x0C\x21\xFD\x8D\xFD\x2E\xFC\x54\xD1\x00\x09\xF9\xDD\x57\x45\xF8\x60\x30\xCF\x98\xAD\xFC\x4B\xD6\x00\x10\xF9\x73\x5A\x49\xF8\xB6\x30\xCF\x99\xA5\xFC\x4B\xDB\x00\x18\xF9\x86\x1C\x4D\xF9\x06\x30\xCF\x94\xAE\xE0\x12\xE0\x00\x20\xF9\xAD\x68\x51\xF9\xBB\x30\xCF\x9C\xAE\xFC\x4B\xE5\x00\x28\xF9\x98\x6C\x55\xFA\x8B\x40\xCF\x95\xAF\xFC\x4B\xEA\x00\x30\xF9\x2E\x00\x59\xFB\x6C\x30\xCF\x9D\xAF", - "\xE0\x12\xEF\x00\x30\xF9\x33\x00\x5D\xF9\xA8\x40\x44\xDA\x2C\xCA\xBE\xFB\xC6\xB3\x33\xE6\x9C\xDE\x99\xC5\xF7\x36\xE5\xEF\x8A\x4F\xCF\xE0\x42\xF9\xB8\x45\x35\x02\x91\xF5\xDE\x9B\xFC\xDC\x55\x75\x00\x50\xF9\x82\x4E\x36\x03\x34\xFA\xD5\xC1\x79\xD6\x01\x18\xF3\xF6\xF4\xDB\xF9\xED\xDD\x1A\xCF\x06\x0F\xCD\xFE\xD3\xE1\xF3\xB7\xCD\x31\xC8\x1C\x01\x39\xF9\x40\xCF\x06\x07\xE7\xFE\x9A\xB1\xC8\x39\x01\x75\xF8\xAF\x00\x0E\x0E\xCE\xF3\x7F\xEF\x97\xBA\x00\xF2\xF9\x2F\x95\x3D\xFC\xD9\xC1\x43\xDB\x01\x39\xF3\xD0\x96\xFB\xF9\x69\xCC\x29\xCF\x9F\xF6\xBE\x81\xE8\xE3\xA8\xBC\x05\x3D\x00\x82\xFB\x41\x04\x0E\x01\xD0\xF3\x80\xC2\x27\x3E\x00\x0A\xFB\x9E\x99\x40\xFF\x45\xD2\x9C\x1F\x01\x11\xF4\xF7\x9B\x01\xFA\x1B\xD7\x7C\x08\x08\x07\xD1\xF0\x74\x81\xF4\xBC\xD4\x67\x09\x20\x01\x47\xFA\x44\xFF\xAC\x55\x77\x83\xA9\x8E\xE7\x42\x01\x8E\xF9\x1E\x01\xA0\xFA\xA4\xD1\x6E\x03\x01\x2A\xF9\x44\x00\xE3\x4A\x70\x02\x0F\x06\xA4\xEF\xCA\xCE\xF3\x8F\x08\x1D\xFB\x3D\x01\x4D\xFF\x3D\xDC\x64\xC7\x02\x1D\xF4\xA5\xF4\xCF\x55\xA7\xF3\x7D\xD4\x48\xD8\x04\x1D", - "\xE8\xEB\xE8\xC1\xFA\xFD\xD2\xC3\xC5\x12\x05\xA3\xFE\x07\x1B\xE9\xC3\xA8\xFA\xC9\x1D\xFB\x3F\x02\x53\xFB\xFD\xD1\x43\xCB\x02\x1D\xF4\x80\x01\x53\xFB\x07\xD4\x5C\xCC\x09\x0D\xD1\xE1\x04\x19\xF5\x96\xD4\x86\xC7\x26\x01\x47\xFA\x10\x0F\xD5\xFC\x50\xD4\x94\x9D\xFA\x83\x01\xB2\xF8\xD9\xCF\xBD\xCF\x04\x1D\xE8\xC4\x02\x6A\xFA\x0E\xFB\xF9\x08\x14\x05\xA3\xF7\x1E\xC8\xEA\xF9\x9C\xA7\xCA\x1D\xFA\x43\x02\x5A\xFA\xA3\xF7\x46\x12\x02\x1D\xF4\xBA\xF4\x76\xFB\x13\xE2\xE1\xC3\x0A\x0D\xD1\xE8\x04\x2A\xF5\xA7\xFA\x26\xDC\x2A\x01\x47\xF9\x11\x0A\xD6\xED\xE9\xDA\x2F\x55\x00\xAA\xF8\x2B\x02\x4C\xFB\x13\x26\xA4\xE5\xA8\xAD\xEC\x8E\xE7\x58\x00\xE3\x4B\x40\xEB\x11\x03\xA0\xE4\xD1\xF5\xEC\x91\xE4\x9A\xFA\x32\x0C\x26\x05\xB3\xF3\xF7\x99\xBD\xCC\x99\xEE\x00\xC6\x4A\x66\xDD\x29\x04\x88\xF6\x10\x05\xA8\xAD\xE3\xE7\x08\x7A\x01\xD4\xF8\x99\x0C\x4F\xFC\xDB\x45\xA8\xB6\xE3\xC4\xD4\x86\x00\xD9\xFB\x86\x11\x18\x0C\xDA\xE5\x08\x05\x54\xD5\xF6\x31\xC8\x49\x02\x6E\xFD\xDD\xED\xDB\xE0\x00\x05\x54\xCA\x46\xA7\xEE\x8B\xF6\x71\xFD\x20\xF1\x79\xDE\x04", - "\x21\xF6\x9B\x14\xDD\x00\xD2\xFB\x40\xAC\x3D\xE2\x76\xE3\xEE\xC0\x66\x6A\x01\xC5\xFB\x82\xAA\x45\xF1\x8D\xC5\x0B\x16\xEE\xCD\xF0\xD9\xFB\xF0\xEE\xBE\xD1\x30\x06\xBB\xF9\x81\x26\x00\x01\xA0\x26\x33\x05\xAB\x68\xDD\x1A\xCD\x19\x04\xDE\xF2\x0C\xE7\xF7\x84\xAA\xFF\xEF\xF7\xC9\x36\x05\xBD\xF8\x86\xCF\xEF\xDE\xF6\xFA\xD7\x4C\xCD\x72\x00\x7D\xFB\x36\x30\x03\x16\xEF\xE5\xF6\xDA\xDF\x91\xCF\x78\x02\x71\x4D\xDD\xDE\x03\x01\x40\x68\x66\x05\xAA\x94\xF6\x3D\x3A\x3F\x03\xBF\xF1\x2A\x4F\xDA\xF5\xF6\xF7\xEC\x4C\xCC\x05\x03\x89\x4C\xD9\xDB\x05\x1E\xEF\xD3\xF7\x8A\x02\xA6\xF6\x20\xC6\x05\x07\xC4\x43\x50\xE9\x03\x38\xEE\xF7\xFB\x5E\xF3\xF7\xC9\x08\x04\xC3\xF4\x66\x16\x03\x1F\xF8\xFF\xFB\x32\xF1\xF7\xC8\x0B\x07\xC4\x4D\xEE\xC3\x04\x01\xA0\x6C\x35\x05\xAB\xDE\xF4\x91\xD1\x07\x0C\xE2\xE4\x33\x13\x02\x2F\xFC\xF0\xFB\x21\xF0\x5C\xCE\x08\x03\xE1\xEF\x78\xD6\xF8\xAD\xFB\x7F\xF3\xF7\xCA\x14\x05\xC7\xFB\xA1\x11\x05\x3F\xF8\xBE\xFB\xCD\xE6\xFA\xE1\x8D\xFB\x43\x1F\x0B\x06\xF0\xF9\xF8\xEA\x8F\x91\xCF\x35\x00\x91\xF8\x15\x2E\x0C\x07\xF2\xCB", - "\xF7\xE3\xF0\x4C\xCD\x3B\x03\x94\xF8\x30\x3C\x0D\x16\xF2\xC5\x54\xA0\xEB\x4C\xCD\x41\x03\x92\xFB\x27\xF8\xE3\xE0\xF1\xDF\xE6\xCC\xCC\x90\x01\x31\xFC\x60\x32\x1F\x05\xE6\xE8\xF1\xF9\xEF\xC0\xD9\x6A\xFC\x6C\x36\x02\x02\x58\x10\xE3\xE1\xE0\xDC\xB0\xF1\xFC\x19\x30\x0D\x00\x9D\xFF\xC9\xF1\x6E\xEF\x2F\xF7\x02\x78\xFC\xED\x34\x15\x02\xB0\x17\xC0\xFF\xF6\xCF\x2F\xC4\x03\x00\xFD\x9F\xED\x41\xFC\x9F\xFE\x20\x08\x5C\xFC\x40\xD1\x03\x5B\xFC\x6E\xE3\x13\x4E\xC3\x02\x58\x18\xDE\xE2\xE1\xDC\xAA\xDF\x01\x90\xFD\x82\x03\x3A\x02\xD2\xF7\x1D\x94\xF4\xCB\xFA\x85\x02\xDB\xEA\x5D\xDD\xA6\xF8\x00\x09\x0F\x1C\xF4\xFB\xEF\x9E\xFD\x66\xFC\x83\x02\x2E\xF0\x48\xCB\x0F\x03\xF5\xC7\x00\x74\x54\xC2\x02\x39\x00\xAA\xFE\xCD\xF3\x8C\xEF\x2F\xC9\x00\x74\x54\x36\x0B\x0A\x00\xAC\xFF\x9E\xA3\xEB\xF7\xF0\xC6\xD1\xF0\xCA\x17\x00\x3A\x55\x3C\x0C\x04\x0B\xEB\xEF\x08\x0E\x02\x0A\xFD\xEF\xDA\x8D\xB4\xC3\xCC\x4E\x53\x50\xFD\x04\x09\xF1\xC0\xD4\x06\x03\xD9\xED\x1A\xC9\x06\x0C\xEC\xE4\x33\x2A\x02\x4F\xFD\xA6\xFA\xBE\xD0\x0F\x00\xD7\xF4\x66\x17\x05\x3D\xFA", - "\x86\x02\xD0\xFD\x1D\xE8\x93\xC8\x09\x0C\xED\xFB\x50\x05\x03\x5F\xFD\xE1\xA9\xA6\xF4\xA7\xD4\x0A\x05\xEE\xE8\x85\x13\x03\x68\xFD\x00\x01\x70\xFC\x00\x00\xB8\xFF\x41\xED\xF7\xD8\xE2\xF0\xFD\xF2\xFD\xAE\xF6\xE1\xC4\x0D\x05\xED\xEC\x59\xD8\xFB\xD4\xFB\xCC\xCF\x3B\x02\xBD\xF8\x5B\x3C\x0F\x18\xF7\xEA\xED\x8B\xCF\x03\xFF\x0C\x32\x02\x06\xB8\x46\x9A\x32\xF7\xDF\xE4\x9C\xD0\x8F\x01\x84\xFD\xBB\x30\x03\x0C\xF0\xF2\x08\x32\xFB\xEA\xFB\x1C\xD1\x4D\x02\xC4\xFB\x28\xD5\xF1\xE9\xF6\xE5\xD4\xEF\xCB\xA7\x01\x8D\xFF\x6C\x34\x06\x0D\xF1\xF8\x79\xB7\xE4\xC0\xC4\xB3\x00\x91\xFD\xB2\xD5\xE4\xF7\x10\x12\xF7\xFF\xE4\x8E\xE7\xBF\x00\x61\xFC\x99\x0B\xAE\xF9\xCB\x52\xF7\xC9\xF8\xD1\x1B\xCC\x00\x95\xFC\xAE\x47\x0B\x0C\xF2\xE0\xF7\xD0\xF8\xFC\xD2\xD8\x00\x9D\xFE\x9B\xF5\xE7\xF9\xEE\xF8\xF0\xF0\x95\xE4\x01\xFD\xFC\x54\x23\x1E\x03\xC0\xF6\xF1\xE3\x61\xFC\xA5\xEF\x01\x49\xFE\xC0\x30\x22\x04\xE9\xFE\xF1\xE9\xF1\xCC\x9F\xFA\x01\x32\xFF\x0D\x15\x25\x06\xB8\x4C\xAE\x32\xF7\xF2\xF8\x8E\xE7\x07\x00\xFB\xC1\xBB\xDD\x14\x0C\xF5\xED\xFA\xFA\xF8\x9C", - "\xD5\x14\x00\xFB\xC0\xB3\xDD\xBB\xFC\xDB\x52\xF7\xE4\xDA\xE9\xC8\x20\x00\xB5\xFE\xC5\xD4\xE8\xF1\xEF\xE9\xF2\xC6\x8E\xAC\x00\x62\xFE\x32\x0D\x34\x06\xB8\x48\x9A\x32\xF7\xDB\xE1\x8E\xE7\x39\x00\xB9\xFF\x86\x10\x1C\x04\xF7\xF2\xF7\xD0\xD6\x9C\xD0\x45\x00\xC1\xFC\x2A\x26\x1D\x05\xF8\xE2\xB6\xD0\xE5\xF9\xFE\x1B\x14\x7E\x01\xD9\xFD\xEA\xF7\xE6\xFC\x4B\xDE\x01\x10\xFF\x66\xC9\x13\x4D\xD7\xFE\xCE\xF1\xE5\xF8\xFC\xC0\x66\x1C\x00\x9A\xFE\xB3\xFF\x6B\xF4\xC9\xC8\x07\x1E\xFC\xD8\x6B\x2B\xFC\x71\x58\x79\xFF\x22\xF2\x38\x15\x08\x06\xFD\xD9\x60\x3C\x00\x27\x4D\xBE\xFD\xA1\xFC\xF9\xC2\x09\x0E\xFD\xED\x6B\x4B\x00\xB1\xFE\xD1\xFF\x73\xF7\xBD\xCF\x09\x0A\xFC\xDB\xCB\xF6\xC3\xC2\x02\x2D\x03\x89\x4D\xE1\xF6\xE9\xF1\x3C\xED\x02\x3E\xFF\x06\x03\x5C\x00\xF0\xFB\xF5\xD3\xFC\xFA\xFD\xE3\xE7\x9C\xD5\xBB\x00\xE4\xFD\x41\x07\x18\x0B\xFC\xF1\x6E\x8D\xFF\x94\xFF\xAA\xFC\xB8\xC9\x32\x02\xFA\xF3\xA7\xB5\xFE\xFB\x7C\xD7\xFF\x26\xFE\x1F\xF8\x15\xF4\xFB\xF3\x0E\x1E\xFE\xF9\x48\xE0\xFF\x2D\xFE\x3C\xD8\x5C\xCD\x1C\x06\xFB\xF2\x07\x26\xFF\x8B\x36", - "\xB9\xFE\x69\xC7\xFD\x84\x53\xD4\x0F\x16\x0F\xD3\xF1\xD4\x49\xB1\xF4\xB8\xC9\x3D\x06\x3E\xCA\x37\x19\x07\x36\xFF\xA4\xEB\x2C\x5A\x7C\x69\xFA\x00\xFC\x7F\xAC\x78\xFF\x7F\x1B\x0A\x05\x0D\x67\x7C\x1C\x68\xFF\x00\x04\x80\xE3\x2A\xC6\x27\x1A\x62\x05\x0D\x6F\x7C\x1C\x68\x04\x00\xC6\x27\x7A\x03\x08\x00\x0E\x80\x00\x80\x2D\x74\x70\x65\x09\x00\x14\x80\x40\x01\x17\x80\x07\x80\x7F\x7C\xCC\x67\x0E\x00\x1C\x80\x6A\x2B\x1E\x80\xA8\x10\x05\x0D\xC6\x7A\x7C\x69\x13\x00\x23\x80\xD0\x2C\x25\x80\x80\x19\x05\x0D\xCF\x7A\x7C\x69\x18\x00\x2B\x80\x0F\x6A\x2D\x80\xD8\x1A\x05\x0D\x95\x7C\x40\x62\x1D\x00\x33\x80\xF9\x14\x35\x80\x19\x18\x05\x0D\x9D\x7C\x13\x6B\x3B\x80\xDF\x07\x3D\x80\xED\x1A\x05\x0D\xA5\x7C\x86\x63\x27\x00\x42\x80\xF1\x36\x44\x80\x2E\x22\x05\x0D\xAD\x7C\x40\x62\x2C\x00\x4A\x80\x30\x00\x4C\x80\xB3\x19\x05\x0D\xB5\x7C\x40\x62\x31\x00\x4A\x80\x35\x00\x54\x80\xA1\x22\x05\x0D\xBD\x7C\x86\x63\x36\x00\x4A\x80\x3A\x00\x5C\x80\xB8\x22\x34\x5E\x3E\x7F\x62\x6E\xC7\x7C\xA1\x22\x66\x80\xF8\x7F\xB0\x72\x69\x80\xB8\x22\x1E\x50\x24\x7B", - "\x1D\x72\x39\x72\x62\x28\x15\x50\x06\x67\x9C\x6A\x3B\x00\xC6\x27\x9E\x68\xAF\x00\xA6\x7E\x07\x50\x12\x01\xA7\x00\x02\x7C\xB7\x05\xC6\x27\x15\x69\xB1\x00\x27\x26\xCC\x01\x15\x50\xAF\x67\x9C\x6A\x40\x00\x82\x80\x64\x06\xB4\x00\x85\x80\xFB\x54\x0F\x01\x88\x00\x80\x80\x8A\x22\x8B\x80\x1B\x0A\x7F\x7E\x39\x67\x15\x50\x8E\x67\x9C\x6A\x46\x00\x94\x80\xA8\x10\xBB\x00\x27\x26\x7A\x03\x15\x50\x5F\x7F\x26\x6E\x49\x00\x9C\x80\x80\x19\xBF\x00\x9F\x80\x8F\x80\x56\x7F\x4C\x66\x4C\x00\xA5\x80\xD8\x1A\xC3\x00\xA8\x80\x58\x6A\xEB\x10\x92\x80\x09\x40\xAD\x80\x19\x18\xC7\x00\x8E\x80\xB1\x80\x46\x1B\xB3\x80\x6E\x41\xB5\x80\xED\x1A\xCA\x00\xB8\x80\x7D\x80\x42\x56\xBB\x80\x55\x00\xBD\x80\x2E\x22\xCD\x00\xC0\x80\xFD\x54\x12\x01\xC3\x00\xBB\x80\x58\x00\xC5\x80\xB3\x19\xD0\x00\xC8\x80\x1D\x50\x42\x59\xBB\x80\x5B\x00\xCE\x80\x0F\x70\xD1\x80\x05\x01\x15\x50\xD9\x00\xBB\x80\x5E\x00\xD6\x80\xB8\x22\xD6\x00\xD8\x80\x14\x50\x2A\x49\xBB\x80\x61\x00\xDE\x80\x82\x27\xD9\x00\xE1\x80\x15\x50\xF3\x00\xBB\x80\x64\x00\xE6\x80\x71\x26\xDC\x00\xB0\x80", - "\xC1\x80\x4E\x05\xBB\x80\x67\x00\xEE\x80\x62\x28\xE0\x00\xE9\x80\x8E\x7F\x40\x62\x6A\x00\xF6\x80\x01\x62\xE3\x00\xF1\x80\xC9\x80\xF2\x7B\xEF\x65\x6D\x00\xFD\x80\xBC\x02\xE7\x00\x00\x81\xD2\x80\xCD\x6A\xBB\x80\x70\x00\x05\x81\x3D\x5B\xF9\x80\xE9\x5B\xBB\x80\x73\x00\x0D\x81\x3F\x5B\x08\x81\xD9\x80\x9C\x7F\x1B\x70\x13\x81\x0A\x01\xF2\x00\x15\x81\xE2\x80\xB7\x79\xFB\x6B\x19\x81\x07\x01\xF6\x00\x1C\x81\x15\x50\xF2\x00\xBB\x80\x7C\x00\x20\x81\x06\x01\xFA\x00\x23\x81\xCD\x04\xBB\x80\x7F\x00\x28\x81\x05\x01\xFE\x00\x0F\x81\x31\x22\xC9\x01\x40\x62\x82\x00\x2F\x81\x80\x25\x74\x2A\xCC\x01\x17\x50\x71\x80\x23\x72\x73\x80\x01\x62\x0F\x50\x76\x80\x91\x67\x85\x00\x79\x80\x64\x06\x04\x00\xC5\x7E\xF2\x52\x95\x63\xBB\x80\x87\x00\x37\x81\x06\x00\x39\x81\xFC\x54\x5C\x77\xBB\x80\x8A\x00\x37\x81\xB7\x7E\x12\x64\x0F\x50\x91\x80\x9C\x6A\x8D\x00\x37\x81\x0C\x00\x74\x2A\x7A\x03\x0F\x50\x99\x80\x91\x67\x90\x00\x37\x81\x10\x00\x5C\x81\x4F\x81\x4B\x3F\xBB\x80\x93\x00\x37\x81\x14\x00\x64\x81\xEF\x52\x66\x79\x9C\x6A\x96\x00\x37\x81\x18\x00", - "\x6B\x81\x48\x81\x78\x0B\xBB\x80\x99\x00\x37\x81\x1C\x00\x4E\x81\x6C\x81\x06\x01\x9A\x67\x9C\x6A\x9C\x00\x37\x81\x1F\x00\x79\x81\x73\x81\x06\x01\xA4\x00\xBB\x80\x9F\x00\x37\x81\x22\x00\x81\x81\xFA\x54\x59\x58\xBB\x80\xA2\x00\x37\x81\x25\x00\x89\x81\x09\x50\xD3\x80\x9C\x6A\xA5\x00\x37\x81\x28\x00\x90\x81\x0E\x50\xDF\x5A\xBB\x80\xA8\x00\x37\x81\x2B\x00\x97\x81\x16\x50\xE3\x80\x9C\x6A\xAB\x00\x37\x81\x2E\x00\x9E\x81\x0F\x50\xEB\x80\x9C\x6A\xAE\x00\x37\x81\xD4\x7E\x39\x67\x0F\x50\x65\x00\xBB\x80\xB1\x00\x37\x81\x35\x00\xA5\x81\xFA\x80\x86\x63\xB4\x00\x37\x81\x38\x00\x72\x81\x8A\x81\xEA\x7B\x7E\x7E\x37\x81\xDB\x7E\xAC\x81\xEC\x4E\xBB\x80\xBA\x00\x37\x81\x40\x00\xB3\x81\x10\x81\x9C\x6A\xBD\x00\x37\x81\x43\x00\xB9\x81\x91\x81\x1E\x81\x4C\x66\xC0\x00\x37\x81\x47\x00\xCB\x81\x98\x81\xCD\x81\x7C\x69\xC3\x00\x37\x81\x4B\x00\xD2\x81\x9F\x81\x9A\x5B\xBB\x80\xC6\x00\x37\x81\x4F\x00\xD9\x81\x0F\x50\x2D\x00\xBB\x80\xC9\x00\x37\x81\x53\x00\xC5\x81\x33\x81\x9C\x6A\xCC\x00\x37\x81\x56\x00\x9E\x81\xAB\x4F\x0A\x7A\x1C\x68\xCF\x00", - "\x64\x80\x72\x80\x01\x62\xAB\x4F\x56\x7C\x40\x62\xD0\x00\x4A\x80\xD4\x00\xF2\x81\x71\x26\xAB\x4F\x5F\x7C\x1C\x68\xD5\x00\x4A\x80\xD9\x00\xFB\x81\x62\x28\xAB\x4F\x09\x80\x44\x6A\xDA\x00\x4A\x80\xDE\x00\x03\x82\xF4\x81\x7F\x5A\x40\x62\xDF\x00\x4A\x80\xE3\x00\x0B\x82\xBC\x02\xAB\x4F\x77\x7C\x86\x63\xE4\x00\x4A\x80\xE8\x00\x12\x82\x13\x50\x38\x7A\x69\x64\xE9\x00\x4A\x80\xED\x00\x1A\x82\x1A\x50\x0A\x01\x28\x80\x1D\x6A\x4A\x80\xF2\x00\x21\x82\x1C\x50\xDD\x5A\x70\x65\xF3\x00\x4A\x80\xF7\x00\x28\x82\x06\x50\x07\x01\x38\x80\x86\x63\xF8\x00\x4A\x80\xFC\x00\x2F\x82\x26\x50\xDE\x7A\x9C\x6A\xFD\x00\x4A\x80\x01\x00\xA0\x0C\x1A\x62\xAB\x4F\x47\x80\x31\x64\x02\x00\xA0\x0C\x7B\x7C\x3E\x82\x5F\x6D\xEB\x5A\x70\x65\x07\x00\x44\x82\x71\x2B\x46\x82\x1B\x0A\xAB\x4F\x57\x80\x86\x63\x0C\x00\x4B\x82\x76\x06\x4D\x82\xA8\x10\xAB\x4F\x5F\x80\xD2\x6E\x53\x82\xDD\x2B\x55\x82\x80\x19\x3E\x50\xB4\x7E\xBA\x71\x82\x7A\xA8\x10\x2E\x51\x01\x81\xC6\x7C\x61\x82\x80\x19\x52\x50\xEF\x81\x44\x6A\x16\x00\xA0\x0C\x92\x7A\xB3\x19\x52\x50\xF6\x81\xBF\x66", - "\xA0\x0C\xF7\x18\x1F\x00\x5C\x82\xD8\x1A\x52\x50\xFE\x81\x44\x6A\x20\x00\x72\x82\xCF\x02\x75\x82\x19\x18\x52\x50\x06\x82\x8E\x73\x27\x00\x7B\x82\x37\x03\x7D\x82\xED\x1A\x52\x50\x11\x80\x44\x6A\x2E\x00\x83\x82\x79\x2A\x85\x82\x2E\x22\x52\x50\x15\x82\x31\x64\x35\x00\x8B\x82\x8E\x24\x8D\x82\x6E\x82\x20\x80\x4C\x66\x3C\x00\x93\x82\x40\x06\x95\x82\xA1\x22\x52\x50\x24\x82\x86\x63\x43\x00\x9A\x82\xA3\x27\x9C\x82\xB8\x22\x52\x50\x30\x80\x40\x62\x4A\x00\xA2\x82\x99\x40\xA4\x82\x82\x27\x52\x50\x32\x82\xD5\x68\xAA\x82\x57\x00\xAC\x82\x71\x26\x52\x50\x40\x80\xFE\x68\xAA\x82\x5E\x00\xB3\x82\x62\x28\x52\x50\x41\x82\x69\x64\x5F\x00\xAA\x82\x65\x00\xBA\x82\x01\x62\x52\x50\x4F\x80\x86\x63\x66\x00\xAA\x82\x6C\x00\xC2\x82\xBC\x02\x52\x50\x50\x82\x31\x64\x6D\x00\xAA\x82\x73\x00\xCA\x82\x65\x7B\xB3\x5F\x70\x65\x74\x00\xAA\x82\x7A\x00\xD2\x82\xF8\x7D\x00\x00\x3F\x1B\xC9\x7D\xB3\x19\x59\x00\x74\x2A\x80\x03\x2E\x75\x93\x71\x29\x7B\xF3\x81\xBC\x02\x5A\x00\xE0\x82\x12\x01\xD3\x50\x97\x7D\x26\x6E\x7B\x00\xA0\x0C\x03\x75\x5B\x00\x59\x7F", - "\x1B\x51\x03\x68\x70\x65\x86\x00\xEE\x82\x64\x06\x68\x00\xF1\x82\x18\x51\xD9\x7E\x40\x62\x91\x00\xA0\x0C\xCC\x6E\x75\x00\x74\x2A\xA6\x19\xD3\x50\xAF\x7D\xBC\x02\x9D\x00\xFE\x82\x64\x06\x83\x00\x01\x83\xE9\x82\xC9\x77\x62\x77\x07\x83\x1B\x0A\x91\x00\x0A\x83\xE6\x50\x47\x73\x9C\x6A\xB5\x00\x0E\x83\xA8\x10\x9F\x00\x11\x83\xF2\x82\x06\x01\xFA\x7E\x31\x64\xC1\x00\xF6\x82\x1B\x0A\xAD\x00\xF9\x82\xEB\x65\xD3\x82\x4C\x66\xCC\x00\x16\x83\x80\x19\xBA\x00\x19\x83\xFA\x82\x15\x79\x70\x65\xD8\x00\x27\x83\xD8\x1A\xC8\x00\x2A\x83\x23\x83\x6F\x7B\x91\x67\xE4\x00\x2F\x83\x19\x18\xD6\x00\x32\x83\x4B\x5F\xAC\x7A\x64\x78\x37\x83\xED\x1A\x48\x7F\xBC\x2D\xD3\x50\x59\x76\x1C\x68\xFC\x00\x3E\x83\x2E\x22\xF2\x00\x3A\x83\x00\x00\xD3\x50\x84\x7B\x31\x64\x08\x00\x1E\x31\xCC\x6E\x00\x00\xF6\x61\x02\x83\x0D\x78\x28\x79\x1E\x31\xED\x6E\x0E\x00\xF6\x61\xA8\x19\xD3\x50\x37\x7F\xDA\x0B\x21\x00\x4F\x83\x64\x06\x1D\x00\x52\x83\x0B\x83\x1B\x78\x9C\x6A\x2D\x00\x5F\x83\x1B\x0A\x2B\x00\x62\x83\x12\x83\x07\x01\x19\x7E\x86\x63\x39\x00\x1E\x31\x03\x75", - "\x81\x7F\x58\x11\xD3\x50\xAE\x7B\x69\x64\x44\x00\x70\x83\x64\x06\x46\x00\xB6\x7F\xD3\x50\xA2\x80\x04\x5E\x56\x83\x64\x06\x53\x00\xF6\x61\xEC\x1A\x7C\x83\xBB\x80\x5C\x00\x7F\x83\x67\x74\x82\x83\x63\x83\x77\x79\x9C\x6A\x69\x00\x67\x83\xA8\x10\x73\x00\x6A\x83\x1A\x83\x82\x6D\x70\x65\x75\x00\x8E\x83\x80\x19\x81\x00\x91\x83\x2B\x83\xE9\x3C\xEF\x65\x81\x00\x87\x83\xA8\x10\x8F\x00\x59\x83\x8A\x83\xB0\x47\x70\x65\x8E\x00\x96\x83\xD8\x1A\x9E\x00\x99\x83\x33\x83\x88\x7A\x70\x65\x9A\x00\xA6\x83\x19\x18\xAC\x00\xA9\x83\x3B\x83\x02\x81\xCC\x67\xA6\x00\x9E\x83\x28\x83\x89\x83\x6B\x83\x06\x71\x9C\x6A\xB3\x00\xB6\x83\x03\x78\xB8\x83\x92\x83\x99\x40\xBB\x80\xC0\x00\xBD\x83\x19\x18\xDA\x00\xBF\x83\x9A\x83\x6F\x7E\x91\x67\xCD\x00\xC4\x83\xED\x1A\xEA\x00\xC7\x83\xAA\x83\x7D\x7E\x3E\x6C\xCC\x83\x2E\x22\x03\x80\xB9\x2C\xD3\x50\xC7\x79\x26\x6E\xE7\x00\xD3\x83\x29\x63\xC6\x27\x5A\x83\x17\x7C\xCC\x67\xF4\x00\xAE\x83\x37\x68\xD9\x2A\x3E\x2C\xC6\x27\x53\x83\xA7\x78\x33\x76\xA9\x14\x36\x05\x0E\x00\xA9\x14\x87\x02\xE6\x83\xA2\x83\xCF\x7F", - "\x91\x67\x10\x00\xEA\x83\x6F\x2A\xED\x83\x0F\x38\xEF\x83\xB9\x83\x35\x7C\xF3\x73\xF4\x83\xB0\x36\xF6\x83\x06\x08\xF8\x83\xC0\x83\xF6\x79\x31\x64\x2C\x00\xFC\x83\xB3\x57\xFE\x83\x8B\x40\x00\x84\xC8\x83\x80\x40\x9C\x6A\x3A\x00\xA9\x14\xF1\x04\x47\x00\x07\x84\x35\x22\xDD\x83\x12\x01\x28\x51\x0F\x01\xEB\x82\xBC\x2A\x49\x00\xA9\x14\x03\x75\x04\x81\x58\x11\x15\x84\x45\x70\x70\x65\x54\x00\x1A\x84\x64\x06\x7A\x00\xC6\x27\xF1\x04\x1E\x84\x48\x44\x0E\x77\x05\x84\x80\x19\x4B\x81\xBC\x2D\x27\x84\x30\x74\xDF\x70\x2A\x84\xD8\x1A\x95\x00\x09\x84\x3C\x69\x0C\x83\x01\x7F\x31\x84\x19\x18\xA3\x00\x34\x84\x05\x01\x2E\x84\xA7\x6E\x94\x72\x38\x84\xED\x1A\xB0\x81\x2D\x84\xCC\x7D\xEF\x65\x8F\x00\x22\x84\x4C\x7E\x25\x84\x14\x84\x24\x83\x7C\x69\x9A\x00\x40\x84\x2E\x22\xEA\x81\x43\x84\x2C\x83\x9C\x6A\xA6\x00\x4E\x84\xB3\x19\x08\x82\x51\x84\x60\x6A\x70\x65\xB2\x00\x55\x84\xA1\x22\x19\x82\x58\x84\xC4\x7A\xE5\x6C\x5C\x84\xB8\x22\xF6\x00\x3B\x84\x50\x5F\xF1\x7D\xA0\x79\x62\x84\x82\x27\x04\x00\xA0\x0C\xA6\x19\x3D\x84\x2D\x75\x70\x65\xD6\x00", - "\x69\x84\x71\x26\x12\x00\x6C\x84\x4A\x84\x00\x7E\xEF\x65\xE2\x00\x0E\x84\x2F\x68\xA0\x0C\xA8\x19\x6E\x84\x5C\x83\xC2\x09\xEF\x00\x72\x84\x62\x28\x2F\x00\x75\x84\x90\x80\x3F\x7F\xAC\x7E\x82\x84\x01\x62\x3D\x00\x85\x84\x35\x74\x5B\x6D\x80\x7C\x25\x0C\x03\x75\x4B\x00\xA0\x0C\x26\x84\x4E\x7F\x40\x62\x12\x00\x90\x84\x64\x06\x58\x00\x93\x84\x76\x84\xAA\x80\x7C\x69\x1D\x00\x25\x0C\xED\x6E\xC1\x82\x71\x2C\x6E\x84\x7D\x83\xED\x25\x2A\x00\xA0\x84\x64\x06\x75\x00\xA0\x0C\xEC\x1A\x6E\x84\xC5\x7B\x8E\x73\x37\x00\x25\x0C\xCC\x6E\x85\x00\x8C\x84\x23\x77\x41\x7E\xCC\x67\x43\x00\xB1\x84\x36\x7E\xB4\x84\x35\x84\x87\x79\x4C\x66\x4F\x00\xA8\x84\x1B\x0A\xA1\x00\x7C\x84\x9C\x84\xA3\x83\x9C\x6A\x5C\x00\xB9\x84\x1B\x0A\xB0\x00\xBB\x84\x3C\x84\xE4\x7B\x5F\x79\xC8\x84\xA8\x10\xBE\x00\xCB\x84\x66\x84\xB3\x83\x2D\x69\xC0\x84\xD7\x6F\xAB\x84\xC4\x84\xBA\x83\x91\x67\x81\x00\xD6\x84\x5C\x7E\xD8\x84\x86\x84\xD4\x81\x40\x62\x8E\x00\xDD\x84\xD8\x1A\xEC\x00\xDF\x84\x8D\x84\xE1\x84\x86\x63\x9B\x00\xE4\x84\x19\x18\x45\x83\xA3\x84\xC3\x6D\x7C\x69", - "\xA8\x00\xEC\x84\xED\x1A\x0C\x00\x1E\x31\x7D\x84\xB3\x7F\x24\x6C\xF3\x84\xAD\x63\xF6\x84\xD9\x84\x98\x6C\x17\x71\xCF\x84\xE6\x59\x25\x0C\xC2\x01\x2A\x00\x1E\x31\x6D\x84\xC5\x7F\xEF\x65\xD0\x00\x00\x85\x06\x01\xDC\x00\x02\x85\xB8\x28\x05\x85\xFD\x84\x96\x54\x70\x65\xDE\x00\x0A\x85\x05\x01\xEA\x00\x0D\x85\x0F\x04\x0F\x85\xE0\x84\xEC\x79\x91\x67\xEC\x00\x14\x85\x7E\x5C\x17\x85\x77\x16\x19\x85\xE8\x84\x5D\x71\xF9\x6A\x1E\x85\x06\x00\x6D\x22\xB0\x08\x22\x85\xB5\x84\xCC\x78\x4C\x66\x08\x00\x6D\x22\xF1\x04\x15\x00\x28\x85\x5D\x6C\xFC\x84\x0F\x01\x9A\x5E\x0A\x01\xA3\x71\x8E\x73\xCA\x7D\x7F\x00\x1E\x31\x80\x03\x36\x85\xE4\x41\x7C\x69\xCA\x7D\x80\x00\x3C\x85\x9B\x10\xFF\x43\xCC\x67\x17\x00\x6D\x22\xF7\x7F\xDC\x0E\x30\x77\x9C\x6A\x18\x00\x6D\x22\x7A\x03\x1C\x00\x48\x85\x30\x6C\x01\x80\x39\x80\x4E\x85\xC4\x14\x51\x85\x1B\x0A\xDD\x0E\x80\x82\x26\x6E\x22\x00\x55\x85\xE7\x02\x57\x85\xA8\x10\xDD\x0E\x88\x82\x81\x82\x5D\x85\xFC\x36\x5F\x85\x80\x19\xDD\x0E\x90\x82\x69\x64\x2C\x00\x64\x85\x59\x0E\x66\x85\xD8\x1A\xDD\x0E\x1C\x82", - "\x1C\x68\x31\x00\x6C\x85\xB1\x6B\x6E\x85\x1B\x75\x86\x7C\x9C\x6A\x36\x00\x74\x85\x2C\x67\x76\x85\xED\x1A\xDD\x0E\xA7\x82\x9D\x64\x7B\x85\x13\x0A\x7D\x85\x2E\x22\xDD\x0E\xAF\x82\x69\x64\x40\x00\x82\x85\x44\x00\x84\x85\xB3\x19\xDD\x0E\xB6\x82\x0B\x74\x82\x85\x49\x00\x8C\x85\xA1\x22\xDD\x0E\xBD\x82\x1C\x68\x4A\x00\x82\x85\x4E\x00\x93\x85\xB8\x22\xDD\x0E\xC5\x82\x31\x64\x4F\x00\x82\x85\x53\x00\x9B\x85\x82\x27\xDD\x0E\xCD\x82\x69\x64\x54\x00\x82\x85\x58\x00\xA3\x85\x71\x26\xDD\x0E\x58\x82\x69\x64\x59\x00\x82\x85\x5D\x00\xAB\x85\x62\x28\xE1\x23\x6E\x84\xCB\x7C\x66\x82\x06\x01\xC1\x6E\x69\x82\x8E\x73\x5E\x00\xB3\x85\x3F\x72\x01\x62\xC1\x6E\x70\x82\x31\x64\x5F\x00\x82\x85\x63\x00\xBE\x85\xBC\x02\xC1\x6E\x78\x82\x8E\x73\x64\x00\x82\x85\x68\x00\xC7\x85\x07\x7F\x44\x5A\x8C\x83\x82\x85\x6D\x00\xCF\x85\x52\x84\x51\x5A\xC6\x65\x82\x85\x72\x00\xD5\x85\x41\x76\x19\x80\x5E\x72\x82\x85\x77\x00\xDB\x85\x07\x01\xC1\x6E\x71\x85\x44\x6A\x78\x00\x82\x85\x7C\x00\xE1\x85\xB9\x85\x78\x85\x91\x67\x7D\x00\x82\x85\x81\x00\xE9\x85\x5E\x73", - "\x0F\x01\x80\x85\x31\x64\x82\x00\x82\x85\x86\x00\xF0\x85\x00\x00\xC1\x6E\x87\x85\x1C\x68\x87\x00\x82\x85\x8B\x00\xF8\x85\xC1\x6E\x8F\x85\x69\x64\x8C\x00\x82\x85\x90\x00\x00\x86\x15\x5B\xE6\x75\x82\x85\x95\x00\x07\x86\x0F\x01\x9E\x85\x69\x64\x96\x00\x82\x85\x9A\x00\x0C\x86\x0A\x01\xA6\x85\x19\x7F\x82\x85\x9F\x00\x13\x86\x07\x01\xAE\x85\x1C\x68\xA0\x00\x82\x85\xA4\x00\xF8\x85\xAA\x51\xBB\x85\x26\x6E\xA5\x00\x6D\x22\x6D\x82\xA1\x22\xAA\x51\xC2\x85\x69\x64\xA8\x00\x6D\x22\xF7\x18\xAE\x00\x20\x86\x53\x85\x86\x63\xAF\x00\x2C\x86\xB1\x57\x2F\x86\xC9\x72\x91\x67\xB6\x00\x33\x86\x53\x60\x35\x86\xD7\x85\xC7\x81\x39\x86\x7A\x58\x3B\x86\xD6\x72\x70\x65\xC4\x00\x3E\x86\x5D\x59\x40\x86\xBE\x7A\xEF\x65\xCB\x00\x44\x86\x06\x01\xD1\x00\x46\x86\x05\x01\x9F\x82\x31\x64\xD2\x00\x4A\x86\x4E\x86\x4D\x86\x7C\x6B\x70\x65\xD9\x00\x52\x86\x15\x73\x54\x86\xFB\x85\x44\x6A\xE0\x00\x58\x86\xE6\x00\x54\x86\x02\x86\x1C\x68\xE7\x00\x58\x86\xED\x00\x54\x86\x96\x85\x44\x6A\xEE\x00\x58\x86\xF4\x00\x54\x86\x0E\x86\x1C\x68\xF5\x00\x58\x86\xFB\x00", - "\x54\x86\x15\x86\x44\x6A\xFC\x00\x58\x86\x02\x00\x30\x0A\x1A\x62\xAA\x51\x1B\x86\x44\x6A\x03\x00\x30\x0A\xF7\x18\x09\x00\x78\x86\x45\x76\xCA\x7E\x9C\x6A\x0A\x00\x30\x0A\x03\x75\x9D\x83\x58\x11\xEC\x62\x1F\x84\x78\x6F\x86\x86\x45\x76\xCC\x83\x8A\x86\x28\x84\x54\x71\x30\x0A\xCC\x6E\x9B\x00\x2A\x85\x06\x01\x90\x86\x2F\x84\x50\x80\x93\x86\x64\x06\xA9\x00\x96\x86\x05\x01\x98\x86\x3E\x73\x70\x65\x38\x00\x9B\x86\x95\x80\x9E\x86\x27\x6E\xFD\x78\xEF\x65\x44\x00\xA4\x86\xA8\x10\xC5\x00\xA6\x86\xA0\x86\x00\x00\x1C\x83\x69\x64\x50\x00\x8D\x86\x1B\x0A\xD3\x00\x8F\x86\x4B\x84\xA8\x6F\xAB\x86\x80\x19\xE0\x00\xAE\x86\xD0\x85\x4C\x66\x67\x00\xBA\x86\xD8\x1A\xEE\x00\xBD\x86\x34\x83\xEF\x65\x73\x00\xC1\x86\xED\x84\xC4\x86\x76\x7B\x7C\x69\x7F\x00\xC8\x86\x31\x63\xA9\x14\xA6\x19\xAF\x86\x43\x83\x44\x6A\x8B\x00\xCE\x86\xBF\x5F\xD0\x86\xEF\x5F\x27\x7F\x86\x63\x97\x00\xD6\x86\xB3\x19\x26\x00\xD8\x86\xC6\x7E\x54\x83\xCC\x67\xA3\x00\x30\x0A\xED\x6E\x34\x00\xA9\x14\xA8\x19\xAF\x86\x7F\x84\xF3\x05\xB0\x00\xDD\x86\xA1\x22\x43\x00\xE0\x86", - "\x05\x52\x87\x84\x86\x63\xBC\x00\xEE\x86\xB8\x22\x51\x00\xF1\x86\xEB\x62\x8E\x84\xCC\x67\xC8\x00\xB4\x86\xA8\x10\x5F\x00\x7A\x84\xE1\x86\x2A\x78\xB7\x7A\xFE\x86\x80\x19\x6C\x00\x01\x87\xF2\x86\x2D\x72\xEF\x65\xDE\x00\xE5\x86\x64\x06\x79\x00\xA9\x14\xEC\x1A\xAF\x86\xA5\x84\x7A\x1C\xEB\x00\x0D\x87\x1B\x0A\x89\x00\x10\x87\xD9\x86\x67\x7F\x54\x6A\xF6\x86\x82\x27\x99\x00\xF9\x86\x97\x86\xB6\x84\xED\x7A\x14\x21\xCC\x6E\xA7\x00\x20\x87\x9F\x86\x76\x7F\x31\x64\x10\x00\x14\x21\xED\x6E\xB5\x00\xE8\x86\x1A\x87\x50\x7E\xEF\x65\x1D\x00\x24\x87\x64\x06\xC4\x00\x27\x87\xA7\x86\x58\x7E\x7C\x69\x29\x00\x34\x87\x1B\x0A\xD2\x00\x37\x87\xAF\x86\x60\x7E\x7C\x69\x35\x00\x2C\x87\x64\x06\xE0\x00\x19\x87\x02\x87\xBB\x81\xCC\x67\x42\x00\x44\x87\x1B\x0A\xF0\x00\x47\x87\x09\x87\xA3\x7F\x7C\x69\x4F\x00\x4C\x87\xC4\x60\x25\x0C\x11\x87\x17\x81\xCC\x67\x5C\x00\x54\x87\x80\x19\x10\x00\x56\x87\x30\x87\xD1\x83\x4C\x66\x69\x00\x5B\x87\xD8\x1A\x20\x00\x25\x0C\xE9\x86\xF8\x84\x7C\x69\x76\x00\x63\x87\x19\x18\x2F\x00\x66\x87\x5F\x87\x8C\x7E\x94\x72", - "\x3C\x87\x0A\x01\x8F\x00\x14\x21\xC2\x01\x3E\x00\x25\x0C\xD1\x86\x07\x85\xB5\x6A\x72\x87\xE8\x6D\x75\x87\x12\x01\x4C\x00\x78\x87\x6F\x87\xA0\x7E\xA5\x67\x7C\x87\x06\x01\xAB\x00\x7E\x87\xEC\x42\x81\x87\x48\x87\xF3\x6D\x9C\x6A\xAD\x00\x85\x87\x05\x01\xB9\x00\x88\x87\x1E\x47\x8A\x87\x50\x87\xF5\x79\xF5\x72\x8F\x87\x00\x00\xC7\x00\x92\x87\xFB\x4D\x94\x87\xFA\x86\x2C\x85\x7C\x69\xC9\x00\x6B\x87\x00\x00\xD6\x00\x9B\x87\x06\x01\x84\x00\x6E\x87\x0F\x01\x08\x52\x4F\x7C\x9C\x6A\xD8\x00\x14\x21\x49\x85\xAA\x87\xF9\x7F\x9C\x6A\xD9\x00\x14\x21\x7A\x03\xDD\x00\xAE\x87\x64\x06\xB0\x87\x27\x5A\x9C\x6A\xDE\x00\xB4\x87\xF5\x5A\xB7\x87\x67\x6D\x43\x5A\x4C\x66\xE3\x00\xBD\x87\x11\x5B\xBF\x87\x9F\x83\x0D\x82\x86\x63\xE8\x00\xC4\x87\x0A\x01\xEC\x00\xC6\x87\x80\x19\xB9\x87\xB5\x7A\x50\x7C\xCB\x87\x5D\x5B\xCE\x87\xD8\x1A\xD0\x87\xB2\x5A\x91\x70\xD3\x87\x06\x01\xF6\x00\xD5\x87\x19\x18\xD7\x87\x00\x00\x4F\x86\x69\x64\xF7\x00\xDA\x87\x05\x01\xFB\x00\xDD\x87\xED\x1A\xDF\x87\xF3\x85\x69\x64\xFC\x00\xE4\x87\x52\x10\x1A\x62\xDF\x87\x5B\x86", - "\x8E\x73\x01\x00\xCA\x07\x7A\x03\x05\x00\xCA\x07\xEF\x87\x39\x82\x91\x67\x06\x00\xF4\x87\x42\x2B\xF7\x87\xB8\x87\x08\x86\x7C\x69\x0B\x00\xFC\x87\x1C\x01\xFE\x87\xC0\x87\x0D\x86\x70\x65\x10\x00\x03\x88\x5B\x2B\x05\x88\xC7\x87\x0F\x01\x73\x86\x8E\x73\x15\x00\x0A\x88\xC1\x0A\x0C\x88\xCF\x87\xEF\x5A\x70\x65\x1A\x00\x12\x88\xFD\x2F\x14\x88\xCF\x76\xF4\x62\x68\x80\xB8\x85\x19\x18\x83\x6D\xAF\x86\xB7\x85\x2A\x7B\x39\x52\xC2\x6F\x7C\x69\x1F\x00\x1B\x88\x19\x18\x93\x00\x25\x0C\x80\x03\x1D\x52\xD5\x7C\xED\x25\x20\x00\x29\x88\xED\x1A\x94\x00\x2C\x88\x62\x52\xDC\x7C\x22\x7E\x32\x88\x2E\x22\x95\x00\x35\x88\x3C\x52\x49\x7D\x31\x64\x22\x00\x39\x88\x9B\x79\x3C\x88\x0D\x52\xE3\x6F\x86\x63\x23\x00\x41\x88\xA1\x22\x97\x00\x43\x88\x25\x88\xAA\x64\x86\x63\x24\x00\x48\x88\xB8\x22\x98\x00\x4B\x88\x57\x52\x7C\x67\x91\x67\x25\x00\x50\x88\x1E\x87\x53\x88\x6E\x52\x26\x65\x86\x63\x26\x00\x58\x88\x71\x26\x9A\x00\x5A\x88\x00\x00\x1D\x52\x03\x75\xBC\x02\x27\x00\x5F\x88\x62\x28\xEB\x84\xCF\x2A\x1D\x52\x07\x7D\x7A\x36\x68\x88\x01\x62\x9C\x00", - "\x62\x88\x1D\x52\x71\x7D\x67\x04\x29\x00\x6F\x88\x05\x83\x72\x88\x1A\x70\x76\x6A\x77\x88\xB9\x78\x79\x88\x21\x70\x86\x63\x2B\x00\x7C\x88\x28\x55\x7E\x88\x82\x7D\x03\x84\x82\x88\xD5\x55\x84\x88\x2D\x70\x86\x63\x2D\x00\x87\x88\xF5\x79\x89\x88\x34\x70\xEF\x65\x2E\x00\x32\x88\x2F\x00\xCA\x07\xC2\x01\xA2\x00\x62\x88\x88\x52\x22\x86\xBC\x2A\x31\x00\x8D\x88\xD8\x1A\x88\x52\x29\x86\x1C\x68\x32\x00\x19\x88\x05\x01\x36\x00\x9D\x88\xC2\x52\x30\x86\x31\x64\x37\x00\xA3\x88\x7B\x1B\xA6\x88\x7E\x52\xC1\x87\xDA\x7E\xAB\x88\x40\x00\xAD\x88\x88\x52\x62\x85\x26\x6E\x41\x00\xAB\x88\x45\x00\xB3\x88\x12\x01\x69\x85\x1C\x68\x46\x00\xAB\x88\x4A\x00\xBA\x88\xC7\x5A\xCC\x67\x4B\x00\xAB\x88\x4F\x00\xC1\x88\x23\x82\xCF\x68\xAB\x88\x54\x00\xC7\x88\xBA\x7A\xC3\x71\xAB\x88\x59\x00\xCC\x88\x06\x01\xF1\x87\x26\x6E\x5A\x00\xAB\x88\x5E\x00\xD1\x88\x05\x01\x61\x86\x44\x6A\x5F\x00\xAB\x88\x63\x00\xD8\x88\x00\x00\x67\x86\xCB\x85\xAB\x88\x68\x00\xDF\x88\x6D\x86\x44\x6A\x69\x00\xAB\x88\x6D\x00\xDF\x88\x0F\x88\x26\x6E\x6E\x00\xAB\x88\x72\x00\xDF\x88", - "\x7B\x86\x8E\x73\x73\x00\xAB\x88\x77\x00\xAD\x88\x17\x63\xA7\x88\x1E\x88\x24\x88\x32\x84\x36\x88\xFA\x88\xE5\x82\x64\x06\x9F\x6E\x17\x84\xED\x25\x78\x00\xCA\x07\xCC\x6E\xA3\x00\x9D\x87\x20\x76\x9F\x7D\xCC\x67\x84\x00\x05\x89\xF1\x6C\x08\x89\xA1\x86\xE5\x78\xFA\x62\xCA\x07\xED\x6E\xBF\x00\xA8\x87\x9E\x6E\xDC\x73\x40\x62\x9D\x00\x13\x89\x2B\x79\x16\x89\x40\x74\x36\x84\x4C\x66\xAA\x00\x1B\x89\xD0\x7D\x1D\x89\x09\x89\xBB\x53\xFE\x88\x3D\x81\xBF\x85\x07\x6F\xA8\x86\x6A\x70\x22\x89\x36\x6F\x24\x89\x10\x89\xD8\x77\x86\x7E\x0D\x89\x1B\x0A\xFB\x00\x0F\x89\x00\x00\x9F\x6E\x0E\x79\x44\x6A\xD0\x00\x2D\x89\x80\x19\x09\x00\x6D\x22\xA8\x19\x9F\x6E\xDB\x7D\x1C\x68\xDD\x00\x3C\x89\xD8\x1A\x4D\x85\xB9\x2C\x9F\x6E\x0F\x7F\x44\x6A\xEA\x00\x45\x89\xAA\x60\x3F\x89\x1F\x89\xDD\x7A\x9C\x6A\xF7\x00\x4D\x89\xED\x1A\x7A\x85\x48\x89\x67\x84\xED\x7A\x0B\x06\xED\x6E\x45\x00\x4F\x89\xEA\x7E\x7D\x73\xEF\x65\x11\x00\x5A\x89\x64\x06\xA8\x85\x57\x89\x77\x84\xCC\x67\x1E\x00\x0B\x06\x0E\x6B\xC7\x0B\x6D\x22\xEC\x1A\x9F\x6E\xEB\x86\x67\x04\x2C\x00", - "\x62\x89\x1B\x0A\x73\x00\x5D\x89\x17\x89\x64\x83\x91\x67\x39\x00\x72\x89\x56\x82\x75\x89\x1E\x89\x57\x79\xCC\x67\x46\x00\x0B\x06\xCC\x6E\x91\x00\x6D\x22\xA6\x19\x9F\x6E\x75\x83\x1C\x68\x52\x00\x81\x89\xA6\x6B\x84\x89\x50\x89\x13\x87\xD1\x0D\x5E\x00\x69\x89\x64\x06\xAD\x00\x6D\x22\xDE\x29\x9F\x6E\x8E\x89\xDA\x0B\x6C\x00\x91\x89\x1B\x0A\xBE\x00\x94\x89\x50\x89\xAE\x84\x26\x6E\x7A\x00\x7A\x89\x80\x19\xCF\x00\x7C\x89\x25\x89\xCD\x7B\xEF\x65\x87\x00\xA2\x89\xD8\x1A\xDE\x00\xA5\x89\x30\x89\x4D\x6C\xCC\x67\x94\x00\x9A\x89\xA8\x10\x65\x86\x71\x2C\x9F\x6E\x7F\x7F\x26\x6E\xA2\x00\xAA\x89\x19\x18\xFD\x00\xAD\x89\x37\x89\xCD\x84\xEF\x65\xAF\x00\xBA\x89\xF4\x84\x30\x0A\x40\x89\xB4\x81\x04\x76\xB2\x89\x80\x19\x1B\x00\x30\x0A\x95\x89\xC6\x89\x69\x64\xCA\x00\xC8\x89\xA7\x7F\xCB\x89\x50\x89\xDA\x76\x40\x7F\xD0\x89\x19\x18\x3D\x00\xD2\x89\x5E\x89\xC9\x83\xEF\x65\xE6\x00\xD6\x89\xED\x1A\x4E\x00\xD9\x89\x76\x89\x25\x39\x7C\x69\xF4\x00\xDE\x89\x2E\x22\x5F\x00\x30\x0A\x6D\x89\x68\x87\x78\x7C\x78\x25\x6A\x89\x07\x01\x6F\x00\xE9\x89", - "\x50\x89\x8D\x7E\x44\x6A\x10\x00\x78\x25\x94\x64\x78\x25\xC2\x01\xCD\x86\x65\x89\x8C\x72\xEF\x65\x1F\x00\xF6\x89\xA0\x37\xF8\x89\xEF\x5F\xC4\x89\x50\x89\xA1\x7E\x69\x64\x2E\x00\xFF\x89\x87\x09\x01\x8A\x0F\x01\x9D\x00\x03\x8A\xDA\x89\xD9\x7F\x9C\x6A\x3D\x00\x08\x8A\xAB\x3D\x0A\x8A\xC3\x56\x0D\x8A\xE2\x89\x96\x87\x89\x71\x12\x8A\x67\x42\x14\x8A\x07\x01\xBB\x00\x16\x8A\x7D\x89\x46\x7C\x4C\x66\x5B\x00\xED\x89\x5D\x47\x1C\x8A\x83\x59\xF1\x89\x2E\x63\x83\x86\x51\x7E\x78\x25\xCC\x6E\xDA\x00\x30\x0A\xA6\x19\x2F\x63\x9A\x7E\x70\x65\x77\x00\x2C\x8A\x64\x06\xE8\x00\x2F\x8A\xB1\x5E\xFB\x82\xDC\x75\x1A\x8A\xD8\x1A\xF6\x00\x1F\x8A\x7B\x81\x18\x89\x86\x63\x90\x00\x3C\x8A\x19\x18\x05\x00\x14\x21\xA8\x19\x31\x8A\xBE\x89\xC0\x6C\x44\x8A\x92\x61\x47\x8A\x39\x8A\x26\x89\x65\x82\xFB\x88\x19\x18\x49\x8A\xF4\x7E\x1C\x68\xAA\x00\x4C\x8A\xA0\x64\x4E\x8A\x29\x8A\x32\x76\x91\x67\xB7\x00\x35\x8A\x1B\x0A\x32\x00\x14\x21\x30\x8A\xB8\x86\x86\x63\xC3\x00\x58\x8A\xB3\x19\x40\x00\x5A\x8A\xBA\x5E\xD6\x85\x08\x85\x67\x8A\xA1\x22\x53\x87\xB9\x2C", - "\x49\x8A\x4A\x89\x8E\x73\xDD\x00\x6E\x8A\xB8\x22\x5E\x00\x6A\x8A\x81\x1C\x3C\x83\x4C\x66\xEA\x00\x76\x8A\x6E\x7A\x79\x8A\x40\x8A\x1F\x7F\xCC\x67\xF7\x00\x7E\x8A\x71\x26\x7C\x00\x80\x8A\x05\x01\x49\x8A\x4C\x83\xDF\x74\x95\x36\xED\x6E\x8B\x00\x88\x8A\x46\x1B\xE2\x86\x4C\x66\x11\x00\x95\x36\xEE\x89\x06\x01\x9A\x00\x14\x21\xEC\x1A\x49\x8A\x6F\x89\xBC\x02\x1F\x00\x8D\x8A\xD6\x7E\x90\x8A\x49\x8A\x9D\x7B\x77\x7F\x9F\x8A\x1B\x0A\x91\x87\x71\x8A\xFB\x86\x4C\x66\x39\x00\x95\x36\xCC\x6E\xC8\x00\x62\x8A\x4F\x8A\x21\x7E\xCC\x67\x45\x00\xAC\x8A\x64\x06\xA4\x87\xBC\x2D\x49\x8A\x97\x89\xCF\x70\x95\x8A\x64\x06\xE4\x00\x14\x21\xDE\x29\xB8\x8A\xBB\x80\x5F\x00\xBB\x8A\x1B\x0A\xF5\x00\xBE\x8A\xB0\x8A\x9A\x76\xD4\x6F\xA5\x8A\xE1\x62\xCA\x07\x48\x8A\x22\x87\x7C\x69\x7A\x00\xCA\x8A\x80\x19\x11\x88\xA8\x8A\xBD\x84\x7C\x69\x87\x00\xC3\x8A\xA8\x10\x4F\x88\x71\x2C\x49\x8A\xB7\x89\xBC\x2A\x95\x00\xD1\x8A\xD8\x1A\x34\x00\xCC\x8A\xC7\x8A\x06\x01\x87\x7F\x44\x6A\xA2\x00\xE0\x8A\x19\x18\x43\x00\xE3\x8A\x5B\x8A\x49\x87\x79\x7A\xD8\x8A\xAE\x66", - "\xCA\x07\xBF\x8A\xCD\x89\x1C\x68\xBD\x00\xF0\x8A\x81\x74\xF2\x8A\xE4\x8A\x16\x71\x94\x74\xF7\x8A\x19\x18\x74\x00\xF9\x8A\xED\x8A\xDB\x89\xCC\x67\xD9\x00\xFD\x8A\x86\x82\x00\x8B\x6B\x8A\xE3\x89\x40\x62\xE7\x00\x05\x8B\x2E\x22\x96\x00\xCA\x07\x9A\x8A\xEB\x89\x86\x63\xF5\x00\x0C\x8B\xB3\x19\xA6\x00\x0F\x8B\xFA\x8A\x77\x6F\x91\x67\x03\x00\xA8\x36\xF1\x04\x10\x00\xA8\x36\xC2\x01\xB6\x00\xEC\x8A\x08\x8B\x07\x01\xDA\x79\x8E\x73\x12\x00\x1C\x8B\x71\x02\x1F\x8B\xBF\x58\x22\x8B\x7A\x8A\x0B\x8A\x70\x65\x21\x00\x28\x8B\x01\x17\x2A\x8B\x33\x5A\x2C\x8B\x81\x8A\x1B\x85\xEF\x65\x30\x00\x31\x8B\xA6\x0B\x33\x8B\x0A\x01\xE3\x00\x35\x8B\x89\x8A\x17\x77\x91\x67\x3F\x00\x3A\x8B\x07\x01\x4C\x00\x3C\x8B\x65\x5B\x3F\x8B\x91\x8A\x9F\x87\x40\x62\x4E\x00\xA8\x36\xA6\x19\x5C\x00\x47\x8B\xF0\x24\x0B\x06\xEC\x1A\x36\x63\x07\x01\x02\x89\x7A\x1C\x5E\x00\xA8\x36\xCC\x6E\x61\x89\xBC\x2D\x55\x8B\xD1\x7E\x70\x65\x6A\x00\x5A\x8B\x64\x06\x1F\x00\xDE\x89\x5E\x8B\x66\x44\x70\x65\x76\x00\x44\x8B\xD8\x1A\x2D\x00\x0B\x06\xA8\x19\x66\x8B\x45\x74\xEE\x70", - "\x6A\x8B\xAF\x7F\x6D\x8B\x12\x01\x6F\x8B\xB7\x7D\x8E\x73\x90\x00\x72\x8B\xB7\x7F\x74\x8B\x0F\x01\x6F\x8B\x55\x8A\x44\x6A\x9D\x00\x7A\x8B\x2E\x22\x5A\x00\x7C\x8B\xED\x52\x5C\x8A\xEF\x65\xAA\x00\x62\x8B\x1B\x0A\x69\x00\x65\x8B\x64\x8A\xA5\x76\x82\x8B\xBB\x7C\x85\x8B\x07\x01\x6F\x8B\x42\x89\x44\x6A\xC3\x00\x90\x8B\xA1\x22\x86\x00\x92\x8B\x9E\x67\xE1\x7D\xF7\x81\x98\x8B\xB8\x22\x95\x00\x9B\x8B\x05\x01\x6F\x8B\x18\x7F\x44\x6A\xDD\x00\x9F\x8B\x82\x27\xA4\x00\xA2\x8B\x00\x00\x6F\x8B\xD3\x86\x8E\x73\xEA\x00\xA8\x8B\x71\x26\xB3\x00\xAB\x8B\x6F\x8B\x8B\x8A\x1C\x68\xF7\x00\xB1\x8B\x62\x28\xC2\x00\xB4\x8B\x92\x8A\x7C\x69\x04\x00\x80\x29\x96\x8A\x05\x01\xD1\x00\x53\x8B\x75\x8B\x47\x79\x31\x64\x12\x00\x80\x29\xED\x6E\xE1\x00\xBC\x8B\x77\x89\xFD\x89\xC9\x8B\x64\x06\xF0\x00\xCC\x8B\x46\x7F\x9C\x6A\x2C\x00\x80\x29\xCC\x6E\xFF\x00\x8D\x8B\x03\x87\x40\x62\x38\x00\xD6\x8B\x64\x06\x0D\x00\x24\x8A\x7D\x8B\xB5\x7B\xCC\x67\x44\x00\xC0\x8B\x64\x06\x1B\x00\x78\x25\xDE\x29\x6F\x8B\xB9\x8A\xF3\x05\x52\x00\xE5\x8B\x75\x70\xE8\x8B\xC5\x8B", - "\x1B\x87\xEF\x65\x60\x00\xCF\x8B\x1B\x0A\x11\x8A\xB9\x2C\x6F\x8B\x6F\x7F\x1C\x68\x6D\x00\xF5\x8B\xA8\x10\x4C\x00\x78\x25\x6E\x8B\x29\x87\x69\x64\x7A\x00\xEE\x8B\xA8\x10\x23\x8A\x71\x2C\x6F\x8B\xDD\x8A\xED\x25\x88\x00\xFD\x8B\x80\x19\x6B\x00\x00\x8C\xF1\x8B\xAB\x83\x9C\x6A\x95\x00\x0D\x8C\xD8\x1A\x7A\x00\x10\x8C\xE1\x8B\xD4\x84\x7C\x69\xA2\x00\x05\x8C\x80\x19\x89\x00\xF0\x8B\x19\x8C\xEE\x8A\x7C\x69\xB0\x00\x1D\x8C\xD8\x1A\x9A\x00\x20\x8C\x86\x8B\x51\x87\x40\x62\xBE\x00\x25\x8C\x19\x18\xAB\x00\x28\x8C\x93\x8B\x58\x87\x25\x83\x2D\x8C\xED\x1A\xBC\x00\x30\x8C\x9C\x8B\x09\x7C\x3E\x6C\x34\x8C\xC6\x80\x78\x25\x54\x8B\x11\x8B\xAF\x7B\x3B\x8C\xB3\x19\x75\x8A\x08\x8C\xDF\x83\x4C\x66\xF6\x00\x15\x8C\x41\x25\x66\x37\xC2\x01\xED\x00\x18\x8C\x29\x8C\x24\x8B\x70\x65\x05\x00\x66\x37\xF1\x04\x12\x00\x4A\x8C\x12\x01\xFC\x00\x4D\x8C\x31\x8C\x2E\x8B\x68\x7F\x52\x8C\xC4\x14\x55\x8C\x34\x2B\x95\x36\x01\x8C\x53\x71\x91\x67\x23\x00\x5C\x8C\xFF\x03\x5E\x8C\x04\x22\x60\x8C\x11\x8C\x18\x8A\x91\x67\x32\x00\x65\x8C\x50\x06\x67\x8C\x5B\x5F", - "\x69\x8C\x21\x8C\xBF\x7E\x9C\x6A\x41\x00\x66\x37\xA6\x19\x4F\x00\x70\x8C\x7C\x38\x95\x36\xEC\x1A\x01\x53\x6F\x8B\x23\x88\xFF\x88\xB6\x5E\xD3\x53\x3C\x81\x3E\x81\x4D\x72\x00\x00\x68\x53\x9A\x88\xED\x25\x51\x00\x66\x37\x49\x85\x68\x53\xA0\x88\x44\x6A\x52\x00\x66\x37\x7A\x03\x56\x00\x8C\x8C\x64\x06\x68\x53\xCA\x85\x26\x6E\x57\x00\x92\x8C\x78\x11\x95\x8C\x38\x6C\xAF\x88\x40\x62\x5C\x00\x9B\x8C\x33\x44\x9D\x8C\xA8\x10\x68\x53\xB5\x88\x97\x5E\xA2\x8C\x4E\x05\xA4\x8C\x80\x19\x68\x53\xBC\x88\x3A\x6B\xA9\x8C\xB0\x47\xAB\x8C\x26\x8C\x97\x82\xDF\x70\xB0\x8C\x61\x49\xB2\x8C\x19\x18\x68\x53\xE1\x87\x1C\x68\x70\x00\xB6\x8C\x17\x7B\xB8\x8C\xED\x1A\x68\x53\xEA\x87\xD3\x75\xBE\x8C\xF3\x4E\xC0\x8C\x2E\x22\x68\x53\xD3\x88\xBC\x2A\x7A\x00\xC5\x8C\x7E\x00\xC7\x8C\xB3\x19\x68\x53\xDA\x88\x8E\x73\x7F\x00\xC5\x8C\x83\x00\xCF\x8C\xA1\x22\x68\x53\xE1\x88\x26\x6E\x84\x00\xC5\x8C\x88\x00\xD7\x8C\xB8\x22\x68\x53\xE6\x88\x8E\x73\x89\x00\xC5\x8C\x8D\x00\xDF\x8C\x82\x27\x68\x53\xEC\x88\xBC\x2A\x8E\x00\xC5\x8C\x92\x00\xE7\x8C\x60\x88\x16\x88", - "\x9C\x6A\x93\x00\xC5\x8C\x97\x00\xEF\x8C\x69\x88\x69\x6A\x84\x8C\x29\x89\x6E\x6D\x2A\x8A\x18\x7C\x66\x37\xCC\x6E\x48\x00\x05\x8B\x41\x54\xD2\x7E\x1C\x68\xA4\x00\xFE\x8C\x64\x06\x56\x00\x01\x8D\x3A\x8A\x31\x64\xB0\x00\x6E\x8C\x80\x19\x64\x00\x72\x8C\x5C\x54\x6A\x8C\xCC\x67\xCA\x7D\x2E\x22\x41\x54\xD0\x53\x80\x8C\x28\x89\xBC\x02\x41\x54\x04\x83\x00\x58\x0D\x8D\xD8\x1A\x73\x00\x10\x8D\x65\x54\x50\x89\x40\x62\xCA\x00\x1E\x8D\x19\x18\x82\x00\x21\x8D\x06\x01\x41\x54\x68\x53\x18\x8D\x85\x8C\x84\x54\x13\x83\x91\x67\xD7\x00\x26\x8D\xED\x1A\x91\x00\x29\x8D\x05\x01\x41\x54\xB1\x86\x1C\x68\xE4\x00\x06\x8D\xEC\x77\x09\x8D\x00\x7F\x4C\x66\xF0\x00\x33\x8D\x2E\x22\xAE\x00\x36\x8D\x62\x54\xBE\x86\xE5\x7A\x42\x8D\xB3\x19\xF6\x8A\xB9\x2C\x41\x54\x73\x8A\x26\x6E\x0A\x00\x2F\x0C\xED\x6E\xCC\x00\x45\x8D\x41\x54\xA5\x8B\x8E\x73\x17\x00\x51\x8D\x9F\x73\x54\x8D\x58\x89\x7C\x69\x24\x00\x59\x8D\x1B\x0A\xEA\x00\x5B\x8D\xDA\x82\x58\x80\x5F\x8D\xA8\x10\xF9\x00\x62\x8D\xE2\x6F\x82\x6C\x2F\x0C\xC1\x8B\x40\x2B\xA8\x36\xEC\x1A\x41\x54\x9C\x8A", - "\x7F\x87\x65\x8D\x80\x19\x18\x00\xA8\x36\xA8\x19\x41\x54\xA3\x8A\x31\x64\x59\x00\x73\x8D\x53\x6F\x76\x8D\x2F\x8D\x6C\x83\x70\x65\x66\x00\x2F\x0C\xCC\x6E\x36\x00\x4E\x8B\x7F\x8D\x06\x01\x87\x89\x44\x6A\x72\x00\x83\x8D\x64\x06\x44\x00\x86\x8D\x4F\x63\x9D\x84\x40\x62\x7E\x00\x6B\x8D\xE1\x78\xA8\x36\xDE\x29\x41\x54\xEB\x8B\x67\x04\x8C\x00\x94\x8D\x67\x74\x96\x8D\x87\x8D\x1E\x63\xAC\x83\x7C\x8D\xFE\x8A\x7E\x8D\x90\x8D\x07\x01\xFA\x8B\x44\x6A\xA7\x00\xA2\x8D\xED\x1A\x83\x00\xA4\x8D\x11\x8D\xD5\x8A\x40\x62\xB4\x00\x9C\x8D\xA8\x10\x92\x00\x6E\x8D\x9F\x8D\xDE\x47\x70\x65\xC2\x00\xAA\x8D\x2E\x22\xA2\x00\xAD\x8D\x22\x8D\x39\x87\x68\x75\xBA\x8D\xB3\x19\xB1\x00\xBD\x8D\x2A\x8D\xF4\x8A\x44\x6A\xDC\x00\xB2\x8D\x80\x19\xC0\x00\x9E\x8D\xA5\x8D\xDA\x84\xEF\x65\xEA\x00\xC9\x8D\xD8\x1A\xD1\x00\xCC\x8D\xAE\x8D\x2A\x8C\x33\x82\xD1\x8D\x19\x18\xE2\x00\xD4\x8D\xBE\x8D\xD6\x8D\x31\x64\x06\x00\x8D\x0B\x6C\x8D\xF3\x00\xDB\x8D\xC5\x8D\x39\x8C\x4C\x66\x14\x00\xE0\x8D\x45\x81\x80\x29\x6F\x8D\x3F\x8C\x69\x64\x22\x00\xE8\x8D\x1B\x0A\x14\x00", - "\xEA\x8D\xB6\x8D\xF3\x89\x8E\x73\x30\x00\x8D\x0B\xF1\x04\x3D\x00\x8D\x0B\x38\x18\x80\x29\x77\x8D\x7A\x87\x4C\x66\x3F\x00\xF7\x8D\x7F\x87\xFA\x8D\x76\x0E\xFC\x8D\xB6\x8D\x05\x8A\x1C\x68\x4E\x00\x01\x8E\xD1\x04\x03\x8E\x06\x08\x05\x8E\xCD\x8D\xFA\x83\x95\x6A\x0A\x8E\xAD\x47\x0C\x8E\x0A\x01\x51\x00\x0E\x8E\xD5\x8D\x6B\x8C\xEF\x65\x6C\x00\x12\x8E\x3C\x4F\x14\x8E\x48\x44\x17\x8E\xDC\x8D\x74\x8C\x91\x67\x7B\x00\xEF\x8D\x0A\x01\x89\x00\x1E\x8E\x61\x49\xF2\x8D\x5A\x8C\x8E\x7A\x9C\x6A\x8B\x00\x8D\x0B\x49\x85\x8B\x6F\x8F\x8C\x8E\x73\x8C\x00\x8D\x0B\x7A\x03\x90\x00\x2F\x8E\x64\x06\x8B\x6F\x98\x8C\xBC\x2A\x91\x00\x35\x8E\xBD\x73\x38\x8E\x1B\x0A\x8B\x6F\x5A\x85\x48\x6E\x3E\x8E\x67\x53\x40\x8E\x59\x7B\xC8\x87\x31\x64\x9B\x00\x45\x8E\xD3\x6D\x47\x8E\x80\x19\x8B\x6F\xAE\x8C\x8E\x73\xA0\x00\x4C\x8E\x1B\x7C\x4E\x8E\xD8\x1A\x8B\x6F\xE4\x85\x8E\x73\xA5\x00\x54\x8E\xC3\x6C\x56\x8E\x19\x18\x8B\x6F\xBB\x8C\x44\x6A\xAA\x00\x5C\x8E\x05\x01\xAE\x00\x5E\x8E\xED\x1A\x8B\x6F\xC3\x8C\x44\x6A\xAF\x00\x64\x8E\x7D\x69\x67\x8E\x2E\x22\x8B\x6F", - "\xCA\x8C\xED\x25\xB4\x00\x6D\x8E\xB8\x00\x6F\x8E\xB3\x19\x8B\x6F\xD2\x8C\x26\x6E\xB9\x00\x6D\x8E\xBD\x00\x77\x8E\xA1\x22\x8B\x6F\xDA\x8C\xBC\x2A\xBE\x00\x6D\x8E\xC2\x00\x7F\x8E\xB8\x22\x8B\x6F\xE2\x8C\x26\x6E\xC3\x00\x6D\x8E\xC7\x00\x87\x8E\x82\x27\x8B\x6F\xEA\x8C\xED\x25\xC8\x00\x6D\x8E\xCC\x00\x8F\x8E\x71\x26\x8B\x6F\xF2\x88\x26\x6E\xCD\x00\x6D\x8E\xD1\x00\x97\x8E\x62\x28\xBA\x78\x89\x8C\xE0\x67\x9F\x8E\xFA\x8C\x62\x8C\x07\x01\x32\x8E\x26\x6E\xD3\x00\x6D\x8E\xD7\x00\xA4\x8E\xBC\x02\xBA\x78\x3B\x8E\xED\x25\xD8\x00\x6D\x8E\xDC\x00\xAD\x8E\xB9\x78\x9F\x8C\x9B\x6D\x6D\x8E\xE1\x00\xB5\x8E\xA6\x8E\x48\x5A\x70\x65\xE2\x00\x6D\x8E\xE6\x00\xBB\x8E\x37\x8B\xD1\x87\x9C\x6A\xE7\x00\x6D\x8E\xEB\x00\xC2\x8E\x8C\x87\xD6\x5A\xD6\x73\x6D\x8E\xF0\x00\xC9\x8E\x0F\x8A\xC8\x88\x9C\x6A\xF1\x00\x6D\x8E\xF5\x00\xCF\x8E\x10\x8E\x06\x01\x6A\x8E\x8E\x73\xF6\x00\x6D\x8E\xFA\x00\xD6\x8E\x00\x00\xBA\x78\x72\x8E\x7A\x1C\xFB\x00\x6D\x8E\xFF\x00\xDE\x8E\xBA\x78\x7A\x8E\xBD\x2A\x0A\x38\xFD\x2A\x0A\x38\x1A\x62\xBA\x78\x82\x8E\xED\x25\x05\x00", - "\xEA\x8E\x6F\x2B\xEC\x8E\x64\x06\xBA\x78\x8A\x8E\x29\x62\xF2\x8E\x02\x05\xF4\x8E\x1B\x0A\xBA\x78\x92\x8E\x7A\x1C\x0F\x00\xF9\x8E\x70\x24\xFB\x8E\xB4\x75\xF1\x8C\x0B\x6B\x01\x8F\x3E\x2C\x03\x8F\x80\x19\x25\x55\xA2\x8E\xD1\x0D\x19\x00\x09\x8F\x87\x7A\xBB\x7F\x06\x01\xA8\x8E\xBC\x2A\x1A\x00\x07\x8F\xFD\x2F\x0F\x8F\x19\x18\x25\x55\xB0\x8E\x7A\x1C\x1F\x00\x16\x8F\xE3\x33\x18\x8F\xED\x1A\x25\x55\x43\x8E\x86\x5D\x1E\x8F\x04\x36\x20\x8F\x2E\x22\x25\x55\xA7\x8C\xED\x25\x29\x00\x25\x8F\x2D\x00\x27\x8F\xB3\x19\x25\x55\x51\x8E\x26\x6E\x2E\x00\x25\x8F\x32\x00\x2F\x8F\xA1\x22\x25\x55\x59\x8E\x26\x6E\x33\x00\x25\x8F\x37\x00\x37\x8F\xB8\x22\x25\x55\x61\x8E\x8E\x73\x38\x00\x25\x8F\x3C\x00\x3F\x8F\x82\x27\x25\x55\xD9\x8E\x26\x6E\x3D\x00\x25\x8F\x41\x00\x47\x8F\x71\x26\x25\x55\xE1\x8E\xD1\x0D\x42\x00\x25\x8F\x46\x00\x4F\x8F\x62\x28\x25\x55\xE8\x8E\xED\x25\x47\x00\x25\x8F\x4B\x00\x57\x8F\x01\x62\x25\x55\xEF\x8E\x7A\x1C\x4C\x00\x25\x8F\x50\x00\x5F\x8F\xBC\x02\x25\x55\xF7\x8E\x8A\x8C\x25\x8F\x55\x00\x67\x8F\x45\x8C\x00\x00\xFE\x8E", - "\xD1\x0D\x56\x00\x25\x8F\x5A\x00\x6E\x8F\x51\x55\x0F\x01\x9A\x8E\xBC\x2A\x5B\x00\x25\x8F\x5F\x00\x76\x8F\xFC\x89\xAD\x62\xCC\x67\x60\x00\x7E\x8F\x80\x19\x7E\x55\x13\x8F\xED\x25\x61\x00\x25\x8F\x65\x00\x83\x8F\xFB\x76\xBA\x87\x20\x72\x25\x8F\x6A\x00\x8B\x8F\x1D\x74\xB7\x8E\x72\x67\x25\x8F\x6F\x00\x91\x8F\x1C\x1B\x49\x8E\x69\x64\x70\x00\x25\x8F\x74\x00\x97\x8F\x7E\x55\x32\x8F\xBC\x2A\x75\x00\x25\x8F\x79\x00\x9E\x8F\xB4\x8C\x40\x62\x7A\x00\x25\x8F\x7E\x00\xA5\x8F\x0F\x01\x42\x8F\x26\x6E\x7F\x00\x25\x8F\x83\x00\xAB\x8F\xCE\x7A\xAC\x6A\x25\x8F\x88\x00\xB2\x8F\x31\x82\xA1\x72\x25\x8F\x8D\x00\xB7\x8F\x06\x01\x5A\x8F\x7A\x1C\x8E\x00\x25\x8F\x92\x00\xBC\x8F\x05\x01\x62\x8F\xD1\x0D\x93\x00\x25\x8F\x97\x00\xC3\x8F\x00\x00\x6A\x8F\x7A\x1C\x98\x00\x25\x8F\x9C\x00\xCA\x8F\x71\x8F\xDA\x0B\x9D\x00\x25\x8F\xA1\x00\xCA\x8F\x79\x8F\xED\x25\xA2\x00\x25\x8F\xA6\x00\x97\x8F\xE9\x55\x0C\x8F\xDA\x0B\xA7\x00\x97\x8F\x2E\x22\xE9\x55\x86\x8F\x7A\x1C\xA8\x00\x25\x8F\xAC\x00\xDD\x8F\xA8\x88\x69\x64\xAD\x00\x25\x8F\xB1\x00\xEA\x8F\x36\x86", - "\xEF\x65\xB2\x00\x25\x8F\xB6\x00\xF0\x8F\x3C\x86\x5D\x8A\x25\x8F\xBB\x00\xF6\x8F\x41\x86\x9C\x6A\xBC\x00\x25\x8F\xC0\x00\xFB\x8F\x47\x86\xCC\x67\xC1\x00\x25\x8F\xC5\x00\x01\x90\x4E\x86\xD6\x6A\x25\x8F\xCA\x00\x07\x90\x55\x86\x4D\x78\x25\x8F\xCF\x00\x0C\x90\x52\x8F\xDA\x0B\xD0\x00\x25\x8F\xD4\x00\x0C\x90\xBE\x8F\xD1\x0D\xD5\x00\x25\x8F\xD9\x00\x0C\x90\xC5\x8F\xDA\x0B\xDA\x00\x25\x8F\xDE\x00\x0C\x90\xCC\x8F\xD1\x0D\xDF\x00\x25\x8F\xE3\x00\x0C\x90\xD2\x8F\xC2\x09\xE4\x00\x25\x8F\xE8\x00\x0C\x90\xD8\x8F\x7A\x1C\xE9\x00\x25\x8F\xED\x00\x97\x8F\x3C\x0C\x57\x8B\xD1\x0D\xEE\x00\x0A\x38\x03\x75\x7F\x00\x48\x8C\x73\x1C\x0B\x76\x9C\x6A\xF9\x00\x3A\x90\x64\x06\x8C\x00\x3D\x90\x3C\x0C\x3D\x7B\x8E\x73\x04\x00\x4C\x07\xCC\x6E\x99\x00\x34\x8C\x3C\x0C\x1C\x8D\x76\x06\x4A\x90\x64\x06\xA7\x00\x4D\x90\x23\x8D\xD4\x66\x51\x90\x1B\x0A\xB5\x00\x54\x90\x0A\x6D\x9C\x6A\x28\x00\x57\x90\xA8\x10\xC3\x00\x5A\x90\xAD\x56\xF9\x8C\x86\x8C\xBB\x8D\x44\x84\xCC\x67\x34\x00\x4C\x07\x03\x75\xD1\x00\x45\x90\x8E\x8B\x08\x75\x5E\x90\x80\x19\xDE\x00", - "\x61\x90\xE2\x85\x89\x6C\x6F\x90\xE5\x84\x72\x90\xE8\x51\x9C\x6A\x57\x00\x75\x90\x19\x18\xFA\x00\x77\x90\xD6\x7A\x70\x65\x63\x00\x7B\x90\xED\x1A\x08\x00\x77\x8C\xEE\x0F\x2F\x79\xFD\x6D\x82\x90\x89\x63\x85\x90\xF0\x12\x63\x8D\x7E\x72\x89\x90\xA7\x64\x8B\x90\xBA\x10\x69\x8D\x91\x67\x87\x00\x4C\x07\xED\x6E\x6D\x8C\xB9\x2C\x3C\x0C\x71\x8D\x0F\x01\x94\x00\x8F\x90\xA1\x22\x76\x8C\xBC\x2D\x3C\x0C\x79\x8D\x69\x64\xA0\x00\x9E\x90\xB8\x22\x79\x8C\xA1\x90\xA9\x8A\x7C\x69\xAC\x00\x69\x90\x64\x06\x5D\x00\x33\x8D\x3C\x0C\x89\x8D\x8E\x73\xB7\x00\xAD\x90\x1B\x0A\x6A\x00\xB0\x90\xE2\x8B\x4C\x66\xC2\x00\x96\x90\x5D\x7C\x66\x37\xEC\x1A\x3C\x0C\x99\x8D\xBC\x02\xCF\x00\xBC\x90\x1B\x0A\x87\x00\xBE\x90\x86\x90\xC8\x8A\x27\x71\xA6\x90\x82\x27\xF5\x8C\xA9\x90\x00\x6B\x70\x65\xE8\x00\xCB\x90\x71\x26\xA5\x00\x91\x90\x3F\x56\xAF\x89\x4C\x66\xF4\x00\xC4\x90\xA8\x10\xB3\x00\x66\x37\xA8\x19\x3C\x0C\x0A\x8C\xF7\x5E\xD7\x23\xCC\x6E\xC2\x00\xD5\x90\x0D\x1D\x12\x8C\x91\x67\x0D\x00\xE2\x90\x64\x06\xD0\x00\xE5\x90\xBA\x1F\x22\x8C\x40\x62\x19\x00", - "\xD7\x23\xED\x6E\xDE\x00\xC7\x90\x8C\x90\xEF\x90\x5D\x88\xF2\x90\x64\x06\xEE\x00\xF5\x90\x92\x90\x02\x8B\x4C\x66\x33\x00\xF9\x90\x1B\x0A\xFE\x00\xFC\x90\xD6\x90\x83\x78\x4C\x66\x40\x00\x01\x91\xF1\x70\x2F\x0C\xBF\x90\xF0\x84\x9E\x6F\x09\x91\x80\x19\x1E\x00\x2F\x0C\xDE\x90\xEC\x8D\x1C\x68\x5A\x00\x0F\x91\x6B\x8B\x12\x91\xC8\x90\x70\x87\x26\x72\xEA\x90\x0D\x4C\xD7\x23\xFB\x02\xD8\x8D\x3E\x90\x7F\x8F\x4C\x66\x75\x00\x1D\x91\x5E\x4F\x1F\x91\x9E\x3D\x21\x91\x3C\x0C\x07\x8E\x44\x6A\x83\x00\x26\x91\xDF\x75\x28\x91\x0F\x01\x58\x00\x2A\x91\xB6\x8E\x39\x6E\x2F\x91\x1F\x66\x31\x91\x28\x76\x34\x91\xE2\x7F\x58\x70\x37\x91\xF2\x75\x39\x91\x0B\x7D\x3B\x91\x21\x8A\x61\x74\x17\x91\xFC\x75\x40\x91\x26\x50\x19\x91\x0F\x01\x78\x63\x83\x81\x63\x90\x8C\x71\x06\x01\x4B\x91\x05\x01\x8E\x63\x6D\x80\x1F\x88\xED\x1A\x7F\x63\x37\x90\xDA\x0B\xBC\x00\xD7\x23\x03\x75\x91\x00\xAA\x8D\x7F\x63\x03\x8D\x44\x6A\xC7\x00\x5A\x91\xF5\x8E\x5D\x91\x0A\x8D\x69\x64\xD2\x00\x3E\x91\xED\x1A\xAB\x00\x21\x91\x7F\x63\x4F\x90\x14\x86\x68\x91\x2E\x22\xB9\x00", - "\x6B\x91\x55\x90\x31\x64\xEA\x00\x6F\x91\xB3\x19\xC7\x00\x72\x91\x5B\x90\x91\x67\xF6\x00\x76\x91\xA1\x22\xD5\x00\x79\x91\x31\x89\xCC\x67\x02\x00\x5F\x38\x03\x75\xE3\x00\x64\x91\x3F\x8D\x7C\x69\x0D\x00\x5F\x38\xCC\x6E\xF0\x00\x80\x91\x73\x90\x9C\x6A\x19\x00\x8B\x91\x64\x06\xFE\x00\x8E\x91\x78\x90\x56\x88\x92\x91\x5D\x64\x25\x8E\x1B\x7C\x7B\x8A\x8C\x6F\x98\x91\xA8\x10\x1A\x00\x9A\x91\x4C\x91\x82\x8A\x4C\x66\x3D\x00\x9E\x91\x80\x19\x28\x00\xA1\x91\x26\x66\xDA\x86\x31\x64\x49\x00\xA6\x91\xD8\x1A\x36\x00\xA9\x91\x00\x00\x7F\x63\x2F\x7F\x26\x6E\x55\x00\x5F\x38\xED\x6E\x44\x00\x8D\x0B\xA8\x19\x7F\x63\x9B\x90\x91\x0F\xAE\x91\x19\x18\x53\x00\xB1\x91\x7F\x63\xA3\x90\x1C\x68\x6E\x00\xBF\x91\xED\x1A\x61\x00\xC2\x91\xAA\x90\xA7\x8F\x84\x91\x64\x06\x6F\x00\x1C\x8E\xA2\x91\xB1\x8A\x4C\x66\x85\x00\xCD\x91\xF6\x73\xD0\x91\xAA\x91\x0A\x87\xCD\x78\xB7\x91\x64\x06\x27\x8E\x71\x2C\x7F\x63\xC1\x90\xAB\x6C\xDB\x91\x1B\x0A\x99\x00\x8D\x0B\xEC\x1A\x7F\x63\x9F\x89\xBC\x2A\xAA\x00\xC7\x91\x2E\x22\xA9\x00\xCA\x91\xCF\x90\x9C\x6A\xB6\x00", - "\xEB\x91\xB3\x19\xB7\x00\xEE\x91\x9B\x83\xAD\x76\xE2\x91\xAC\x86\xBA\x91\x12\x01\x7F\x63\xE0\x90\xD1\x0D\xCF\x00\xF2\x91\xA1\x22\xD4\x00\xF5\x91\x0F\x4A\x9C\x6A\xDB\x00\x00\x92\xB8\x22\xBF\x8E\xBC\x2D\x7F\x63\x41\x87\x0A\x8B\xF8\x91\x80\x19\xCE\x8E\xDE\x91\xC6\x8D\x8E\x73\xF4\x00\x0E\x92\x2E\x62\x0A\x38\xE6\x91\x32\x8C\x7C\x69\x01\x00\x97\x0D\xED\x6E\x10\x00\x17\x92\xFB\x91\x19\x92\x40\x62\x0E\x00\x1C\x92\x2F\x68\x1F\x92\x42\x56\x0D\x91\xCD\x66\x24\x92\x1B\x0A\x30\x00\x0A\x38\xBB\x91\x14\x91\x44\x6A\x28\x00\x2A\x92\xA8\x10\x3F\x00\x2D\x92\x20\x92\x77\x8F\xF1\x76\x97\x0D\xF4\x76\x97\x0D\xC2\x01\x4E\x00\x0A\x38\xA6\x19\x7F\x63\x25\x8B\x26\x6E\x43\x00\x39\x92\xF5\x3F\x3B\x92\xF0\x03\x3E\x92\x36\x92\x2C\x7C\xEF\x65\x51\x00\x44\x92\x53\x0B\x46\x92\xC0\x62\x48\x92\x27\x92\xBC\x8E\x4C\x66\x5F\x00\x4D\x92\x11\x77\x4F\x92\x0A\x01\x78\x00\x51\x92\x0A\x01\x7F\x63\x02\x84\x27\x69\x56\x92\x3C\x4F\x58\x92\xBC\x50\x5B\x92\x9B\x91\x4B\x8B\x7E\x72\x32\x92\x23\x77\x62\x92\x06\x01\x94\x00\x35\x92\x44\x56\x49\x92\x53\x91\x52\x8A", - "\xED\x1A\x4E\x56\x52\x91\x13\x8D\x6E\x80\x82\x27\x74\x92\xF3\x7F\x91\x67\x8A\x00\x97\x0D\x49\x85\x78\x92\x79\x61\x31\x77\x97\x0D\x34\x77\x7C\x92\x64\x06\x7E\x92\x1B\x8F\xD1\x0D\x90\x00\x81\x92\x42\x6E\x83\x92\x1B\x0A\x7E\x92\x23\x8F\x7A\x1C\x95\x00\x89\x92\xF3\x52\x8B\x92\xA8\x10\x7E\x92\x2A\x8F\x7A\x1C\x9A\x00\x91\x92\x0F\x61\x93\x92\x80\x19\x7E\x92\xA0\x8F\xED\x25\x9F\x00\x99\x92\x53\x77\x9B\x92\xD8\x1A\x7E\x92\x3A\x8F\xBC\x2A\xA4\x00\xA1\x92\x5C\x77\xA3\x92\x19\x18\x7E\x92\xAD\x8F\xBC\x2A\xA9\x00\xA9\x92\x65\x77\xAB\x92\xED\x1A\x7E\x92\x4A\x8F\xBC\x2A\xAE\x00\xB1\x92\x34\x66\xB3\x92\x29\x75\xE3\x5A\x70\x65\xB3\x00\xB9\x92\xB7\x00\xBB\x92\x15\x8B\xF9\x87\xEF\x65\xB8\x00\xB9\x92\xBC\x00\xC2\x92\xA1\x22\x7E\x92\x1E\x90\xC2\x09\xBD\x00\xB9\x92\xC1\x00\xC9\x92\xB8\x22\x7E\x92\x24\x90\xDA\x0B\xC2\x00\xB9\x92\xC6\x00\xD1\x92\x77\x92\xBA\x74\xCC\x67\xC7\x00\xB9\x92\xCB\x00\xD9\x92\x71\x26\x7E\x92\x30\x90\x38\x7F\xB9\x92\xD0\x00\xE0\x92\x62\x28\x96\x63\x0A\x01\x57\x91\xC2\x09\xD1\x00\x97\x0D\x03\x75\xA3\x00\x0A\x38", - "\xF1\x04\xE9\x92\xF3\x82\x27\x71\xEE\x92\x16\x6F\xF1\x92\x7E\x80\x65\x91\x62\x86\x60\x92\xC4\x75\x64\x92\x0C\x6E\x41\x8A\x31\x64\xF3\x00\xFC\x92\x19\x18\xCB\x00\xFE\x92\x05\x01\xF3\x92\xA6\x89\xB0\x72\x03\x93\xED\x1A\x1C\x90\xBC\x2D\x08\x93\x3E\x84\xD1\x77\x80\x2A\xCC\x6E\xE7\x00\x06\x93\x00\x00\x0F\x93\xB0\x86\xC0\x7E\x80\x2A\x03\x75\xF5\x00\xF8\x92\xB2\x56\x0A\x01\x39\x89\x8E\x73\x22\x00\x12\x93\x64\x06\x02\x00\x4C\x07\xA6\x19\x17\x93\x95\x8B\x8E\x73\x2E\x00\x23\x93\x1B\x0A\x10\x00\x26\x93\xF9\x92\xC5\x86\xCC\x67\x3A\x00\x2C\x93\xA8\x10\x1E\x00\x2F\x93\x1E\x93\x60\x84\x4C\x66\x46\x00\x34\x93\x80\x19\x2C\x00\x37\x93\x95\x63\x5C\x8D\x2D\x65\x3C\x93\xD8\x1A\x3A\x00\x3F\x93\x07\x01\x17\x93\xB6\x8B\x44\x6A\x5E\x00\x43\x93\x19\x18\x48\x00\x46\x93\xFF\x92\x66\x89\x4C\x66\x6A\x00\x80\x2A\xED\x6E\x56\x00\x4C\x07\xA8\x19\x17\x93\xBD\x91\x9D\x4E\x4C\x93\xED\x1A\x65\x00\x4F\x93\x07\x93\xF3\x86\x31\x64\x83\x00\x5C\x93\x2E\x22\x73\x00\x5F\x93\x16\x93\xCB\x91\x4C\x69\x1A\x93\x49\x7B\xDA\x90\x47\x93\x95\x84\x49\x77\x6B\x93", - "\xAC\x75\x6D\x93\x50\x93\x91\x8D\x86\x63\xA5\x00\x54\x93\x64\x06\x9B\x00\x4C\x07\xEC\x1A\x17\x93\xE0\x91\xCF\x56\x78\x93\x61\x7B\x7B\x93\x30\x93\x8B\x83\x91\x67\xBF\x00\x64\x93\xB3\x19\xBB\x00\x67\x93\x17\x93\xA7\x8D\x8E\x73\xCB\x00\x87\x93\xA1\x22\xC9\x00\x8A\x93\x02\x8C\x1C\x68\xD7\x00\x80\x93\xA8\x10\xD7\x00\x57\x93\x83\x93\xC5\x84\x35\x83\x8F\x93\xB8\x22\xE6\x00\x92\x93\xBF\x8D\x86\x63\xF0\x00\x9D\x93\x82\x27\xD9\x90\x0E\x93\x12\x92\x26\x6E\xFC\x00\x96\x93\x80\x19\x02\x00\xD7\x23\x7C\x93\xA8\x93\xBC\x2A\x09\x00\xB1\x5A\xED\x6E\x12\x00\xAE\x93\x9A\x93\x06\x91\x96\x7C\xB3\x93\x64\x06\x22\x00\xB6\x93\x38\x93\xB8\x93\x40\x62\x23\x00\xBA\x93\x60\x8A\xBD\x93\x40\x93\xE5\x8D\x7C\x69\x30\x00\xC2\x93\xA8\x10\x42\x00\xD7\x23\x58\x93\x2F\x92\x8E\x73\x3D\x00\xC9\x93\x80\x19\x51\x00\xCC\x93\xB7\x93\xFE\x84\xEB\x7B\xB1\x5A\xA0\x78\xB1\x5A\xC2\x01\x60\x00\xD7\x23\x27\x93\xFE\x8D\x7C\x69\x58\x00\xD8\x93\x9E\x45\xDA\x93\x2A\x49\xDD\x93\xD5\x93\x11\x85\xB1\x78\xE2\x93\x50\x4B\xE4\x93\x24\x7A\xE6\x93\xBE\x93\xD7\x8E\x2D\x69", - "\xEA\x93\x07\x50\xEC\x93\xFF\x09\xEE\x93\xC5\x93\x24\x85\xCC\x67\x82\x00\xF2\x93\xEB\x62\xF4\x93\x93\x8B\xF6\x93\x6E\x93\x66\x92\x31\x64\x90\x00\xD1\x93\x1F\x66\xFD\x93\x06\x01\xA6\x00\xD4\x93\x02\x58\x65\x77\x4D\x91\xD7\x71\x00\x00\x72\x6A\xB8\x56\x70\x92\x81\x8C\xA8\x10\x10\x94\x16\x5B\xA5\x67\xB1\x5A\x03\x75\xB5\x00\x45\x91\x00\x00\x14\x94\x32\x8A\x1C\x6C\x17\x94\x64\x06\xC2\x00\x1A\x94\x1C\x94\x5C\x44\x14\x83\xFB\x93\xD8\x1A\xCF\x00\xFF\x93\xC3\x6C\x00\x93\x69\x64\xC1\x00\x26\x94\x19\x18\xDD\x00\x29\x94\x05\x01\x23\x94\x77\x8B\x9B\x8E\x2E\x94\xED\x1A\xEB\x00\x31\x94\x1B\x94\x2B\x89\x5F\x66\x36\x94\x2E\x22\xF9\x00\x39\x94\x23\x94\x39\x8D\x44\x6A\xE5\x00\x1F\x94\x1B\x0A\x07\x00\x15\x92\x32\x94\x6D\x90\x0F\x79\x3D\x94\xC2\x5F\x5F\x38\xA6\x19\x23\x94\x29\x93\xA9\x93\x4C\x94\x76\x68\x4E\x94\x12\x01\x23\x94\x4E\x8D\xBC\x2A\x08\x00\x82\x28\xCC\x6E\x30\x00\x55\x94\xA4\x63\xB4\x7A\xE6\x8D\x5B\x94\x64\x06\x3E\x00\x5E\x94\xB7\x56\x41\x93\x86\x63\x20\x00\x62\x94\x1B\x0A\x4C\x00\x65\x94\x07\x01\x23\x94\x49\x93\x8E\x73", - "\x2C\x00\x6A\x94\xA8\x10\x5A\x00\x6D\x94\x2A\x94\x51\x93\x7C\x69\x38\x00\x82\x28\xED\x6E\x68\x00\x5F\x38\xA8\x19\x23\x94\x5A\x93\x75\x6E\x73\x94\x93\x7C\x76\x94\x49\x94\xCD\x8B\xCC\x67\x51\x00\x83\x94\x76\x82\x85\x94\x3A\x94\x7E\x89\x4C\x66\x5D\x00\x82\x28\x03\x75\x93\x00\x48\x94\x8D\x94\xD2\x91\x7C\x69\x68\x00\x91\x94\x64\x06\xA0\x00\x94\x94\x23\x94\x7E\x93\xE6\x4B\x7B\x94\x92\x89\x5F\x38\xEC\x1A\x9D\x94\xBB\x80\x80\x00\xA0\x94\x1B\x0A\xBD\x00\xA2\x94\x56\x94\xBD\x73\x78\x79\x8A\x94\x19\x18\xCD\x00\x8C\x94\x23\x94\x8C\x93\x26\x6E\x99\x00\xAE\x94\xED\x1A\x06\x92\xBC\x2D\x23\x94\xD6\x7B\x7A\x1C\xA5\x00\xA7\x94\xA8\x10\xE9\x00\x7E\x94\xAB\x94\xC0\x62\x5A\x84\xB6\x94\x2E\x22\xF8\x00\xB1\x94\xBF\x89\xE5\x6C\xC5\x94\xB3\x19\x06\x00\x97\x0D\x4F\x94\xB0\x93\xED\x25\xCA\x00\xBE\x94\xEA\x5D\x97\x0D\xA3\x94\xD0\x94\x7A\x1C\xD7\x00\xD3\x94\xD8\x1A\x24\x00\xD5\x94\xC2\x94\xDD\x8D\x69\x64\xE4\x00\xDA\x94\x19\x18\x34\x00\xDD\x94\x5F\x94\xDF\x94\x1C\x68\xF1\x00\xE2\x94\xED\x1A\x44\x00\xE5\x94\x66\x94\xC6\x93\x40\x62\xFE\x00", - "\xEA\x94\x2E\x22\x54\x00\x97\x0D\x7F\x94\xCE\x93\x26\x6E\x0B\x00\x58\x26\xED\x6E\x63\x00\xF5\x94\xDE\x94\x11\x8F\x4C\x66\x18\x00\x58\x26\xD3\x79\x58\x26\xB1\x7E\xCE\x94\xFE\x94\x8C\x8F\xA1\x75\x02\x95\x5E\x38\x04\x95\xF7\x54\x06\x95\xE6\x94\x04\x77\x91\x67\x34\x00\x0A\x95\xA5\x38\x0C\x95\xC6\x7E\x0E\x95\xEE\x94\xC3\x8E\x4C\x66\x42\x00\x13\x95\x30\x29\x15\x95\x5C\x54\x17\x95\x6E\x94\x41\x8B\xEF\x65\x50\x00\x1C\x95\x78\x0B\x1E\x95\x07\x01\xAA\x00\x20\x95\x77\x94\x43\x91\xF4\x71\xFA\x94\x41\x48\x27\x95\x06\x01\xC6\x92\xB9\x2C\xAB\x63\xF2\x75\x0C\x94\xA0\x77\x06\x01\x34\x95\x00\x00\xC0\x63\x51\x8A\x12\x94\x80\x19\xB2\x63\x15\x94\xF3\x6B\x58\x26\x03\x75\xDD\x92\x58\x11\x3F\x95\x1D\x94\x91\x67\x78\x00\x42\x95\x64\x06\xD4\x00\x68\x92\x86\x87\xFA\x92\x2D\x91\x25\x95\xD8\x1A\xE1\x00\x2A\x95\x35\x95\x45\x7B\x7C\x69\x8F\x00\x51\x95\x19\x18\xEF\x00\x54\x95\x00\x00\x46\x95\x4A\x8A\x71\x6E\x59\x95\xED\x1A\xFD\x00\x5C\x95\x5E\x95\x7F\x8B\x8E\x73\xA7\x00\x61\x95\x2E\x22\x0B\x00\x80\x2A\xA6\x19\x5E\x95\x42\x94\x8E\x73\xB3\x00", - "\x4A\x95\x1B\x0A\x19\x00\xAB\x93\x4E\x95\x88\x91\x2B\x8C\x69\x95\xDE\x86\x6C\x95\x12\x01\x5E\x95\x51\x94\xBC\x2A\xCA\x00\x79\x95\xA1\x22\x34\x00\x7B\x95\xC1\x56\x9D\x8B\x86\x63\xD6\x00\x81\x95\xB8\x22\x42\x00\x84\x95\xBE\x56\x9C\x91\x40\x62\xE2\x00\x89\x95\x82\x27\x50\x00\x8C\x95\xDB\x72\x67\x94\x31\x64\xEE\x00\x91\x95\xFF\x66\x94\x95\x76\x95\x5F\x89\x57\x7F\x99\x95\x62\x28\x6C\x00\x9B\x95\x55\x95\x93\x90\xEF\x65\x06\x00\x7D\x38\xED\x6E\x7A\x00\x80\x2A\xA8\x19\x5E\x95\x81\x94\x38\x0F\x7D\x38\xCC\x6E\x89\x00\xA2\x95\x5D\x95\x61\x93\x69\x64\x1F\x00\xAF\x95\x64\x06\x97\x00\xB2\x95\x5E\x95\x6D\x83\x31\x64\x2B\x00\x7D\x38\x03\x75\x77\x93\x45\x95\x6F\x93\x31\x64\x36\x00\xBF\x95\x7F\x78\x75\x95\xA3\x95\x6D\x81\x91\x67\x41\x00\xA7\x95\x64\x06\x86\x93\x71\x2C\x5E\x95\x9E\x94\x41\x3F\xCD\x95\x1B\x0A\xCF\x00\x80\x2A\xEC\x1A\x5E\x95\xE8\x91\xED\x25\x5B\x00\xB7\x95\x1B\x0A\xDF\x00\xBA\x95\xCE\x8A\x40\x62\x67\x00\xDD\x95\xB3\x89\xE0\x95\xAF\x8D\x19\x7A\xD4\x95\xA8\x10\xFB\x00\xAA\x95\x7C\x95\xDD\x7B\x7C\x69\x80\x00\xE4\x95", - "\x80\x19\x0A\x00\xB1\x5A\x6D\x95\xC9\x94\x4C\x66\x8C\x00\xF1\x95\x46\x89\xF4\x95\xED\x95\x1A\x8C\x40\x62\x98\x00\xE9\x95\x80\x19\x26\x00\xB1\x5A\xD8\x95\xD7\x94\xD1\x0D\xA5\x00\x00\x96\xAF\x91\x03\x96\xFC\x95\xE7\x94\x44\x6A\xB2\x00\x08\x96\x19\x18\x46\x00\x0A\x96\x85\x95\xE9\x84\x31\x64\xBF\x00\x0F\x96\xC9\x66\x12\x96\x8D\x95\xEF\x94\x86\x63\xCC\x00\x17\x96\x2E\x22\x66\x00\xB1\x5A\xAB\x95\xF7\x94\xBC\x2A\xD9\x00\x1E\x96\xB3\x19\x75\x00\x21\x96\x0B\x96\xFF\x94\x7C\x69\xE6\x00\xF9\x95\xB9\x5B\x7D\x38\xC2\x01\x84\x00\xFB\x95\x13\x96\x23\x91\xE4\x89\x2E\x96\x36\x65\xE4\x83\x57\x52\x33\x96\x1A\x96\x4A\x92\x82\x91\x67\x28\xEB\x83\x67\x28\xC2\x01\xA0\x00\x3B\x96\x95\x95\x53\x92\x7C\x69\x10\x00\x3F\x96\x6F\x2A\x41\x96\xC7\x56\x44\x96\x9C\x95\x19\x8E\x67\x89\x49\x96\xB0\x36\x4B\x96\x53\x60\x4D\x96\xC9\x95\x0B\x84\x91\x67\x2C\x00\x67\x28\xF1\x04\x39\x00\x53\x96\x9F\x59\x29\x96\x0F\x01\xB9\x63\x45\x96\x3C\x95\x19\x8D\x64\x06\x61\x96\x06\x01\x3B\x95\x11\x94\x64\x96\x20\x83\x45\x85\x4C\x66\x3B\x00\x67\x28\x26\x86\xB8\x22", - "\x68\x96\x12\x8F\x70\x65\x3E\x00\x67\x28\xF7\x18\x44\x00\x67\x28\x1A\x62\x72\x96\x2D\x5A\x49\x67\x76\x96\xB8\x3D\x79\x96\x92\x89\x93\x8F\xB3\x68\x7E\x96\x7F\x41\x80\x96\x6B\x96\x8D\x5A\x70\x65\x53\x00\x84\x96\x7E\x42\x86\x96\xA8\x10\x7B\x96\xA3\x87\x70\x65\x5A\x00\x8B\x96\x48\x44\x8D\x96\x80\x19\x8F\x96\xA6\x92\x87\x8F\x93\x96\x7B\x46\x95\x96\xD8\x1A\x8F\x96\xAE\x92\xED\x25\x68\x00\x9A\x96\xFA\x48\x9C\x96\x19\x18\x8F\x96\xB6\x92\xED\x25\x6F\x00\xA2\x96\x00\x00\x75\x00\xA4\x96\xED\x1A\x8F\x96\x12\x90\xC2\x09\x76\x00\xAA\x96\x7C\x00\xAD\x96\x2E\x22\x8F\x96\x18\x90\xDA\x0B\x7D\x00\xAA\x96\x83\x00\xB5\x96\xB3\x19\x8F\x96\xCC\x92\xF3\x05\x84\x00\xAA\x96\x8A\x00\xBD\x96\xA1\x22\x8F\x96\xD4\x92\xC2\x09\x8B\x00\xAA\x96\x91\x00\xC5\x96\x71\x96\xDB\x92\x4C\x66\x92\x00\xAA\x96\x98\x00\xCD\x96\x82\x27\x8F\x96\xE3\x92\xDA\x0B\x99\x00\xAA\x96\x9F\x00\xD4\x96\x71\x26\xC8\x56\x0A\x01\x7A\x6A\x69\x96\x62\x28\xA0\x00\x5D\x96\x80\x19\xC9\x63\x56\x8B\x70\x65\xA2\x00\x67\x28\x03\x75\xD9\x00\x04\x94\x05\x01\xE6\x96\x5F\x8B\x8D\x87", - "\xEA\x96\x64\x06\xE6\x00\xED\x96\x00\x00\xEF\x96\x67\x8B\x9C\x6A\xB8\x00\x51\x96\xA8\x10\xF3\x00\x55\x96\xF6\x96\x2B\x94\x1C\x68\xC4\x00\xFB\x96\x80\x19\x01\x00\x82\x28\xA6\x19\xF7\x96\x5F\x95\x08\x85\x03\x97\xD8\x1A\x0F\x00\x06\x97\x12\x01\x08\x97\x66\x95\x26\x6E\xDC\x00\x0B\x97\x19\x18\x1D\x00\x0E\x97\xC9\x56\x66\x90\xD0\x7A\xF2\x96\x68\x83\xEA\x94\x08\x97\x20\x93\x26\x6E\xF3\x00\x14\x97\xED\x1A\x7A\x94\xBC\x2D\x08\x97\x7E\x95\xC5\x26\x22\x97\x2E\x22\x46\x00\x17\x97\x0A\x01\x08\x97\x58\x94\xED\x25\x0B\x00\xD6\x27\xCC\x6E\x54\x00\x2C\x97\x07\x01\x08\x97\x56\x8D\x26\x6E\x17\x00\x32\x97\x64\x06\x62\x00\x35\x97\x06\x01\x08\x97\xAE\x8B\x26\x6E\x23\x00\x3B\x97\x1B\x0A\x70\x00\x3E\x97\xEE\x96\xAB\x91\x69\x64\x2F\x00\x44\x97\x26\x80\x47\x97\xFF\x96\x78\x94\x40\x62\x3B\x00\xD6\x27\xED\x6E\x8C\x00\x82\x28\xA8\x19\x08\x97\xAD\x95\xD8\x0E\x4C\x97\x80\x19\x9B\x00\x4E\x97\x08\x97\xC4\x91\x44\x6A\x54\x00\x5B\x97\xD8\x1A\xA9\x00\x5E\x97\x69\x93\x31\x64\x60\x00\xD6\x27\x03\x75\xB7\x00\x1D\x97\xC3\x95\x69\x64\x6B\x00\x6A\x97", - "\x35\x87\x6D\x97\xD9\x91\x4C\x66\x76\x00\x53\x97\x7A\x7F\x82\x28\xEC\x1A\x08\x97\xD2\x95\x8A\x6B\x77\x97\x1B\x0A\xE1\x00\x79\x97\x0F\x97\xAC\x94\x51\x6B\x63\x97\x19\x18\xE9\x94\x25\x97\xE1\x95\x86\x63\x9C\x00\x85\x97\xDF\x23\x66\x97\xE7\x95\x31\x64\xA8\x00\x7E\x97\xA8\x10\x0D\x00\x58\x26\x57\x97\xEE\x95\x40\x62\xB5\x00\x8C\x97\x2E\x22\x1C\x00\x58\x26\x07\x97\xF6\x95\xE2\x7D\x9A\x97\xB3\x19\x2A\x00\x9D\x97\x82\x97\xFD\x95\x86\x63\xCD\x00\x92\x97\x80\x19\x38\x00\x58\x26\x7A\x97\x05\x96\x1F\x90\xA9\x97\xD8\x1A\x48\x00\xAC\x97\xA5\x97\x0C\x96\x8E\x73\xE7\x00\xB0\x97\x19\x18\x58\x00\xB3\x97\x18\x97\x14\x96\x69\x64\xF4\x00\xB8\x97\xED\x1A\x68\x00\xBB\x97\x2D\x97\x28\x92\x31\x64\x01\x00\x83\x0A\xED\x6E\x49\x95\xB9\x2C\x08\x97\xD8\x83\xBC\x2A\x0E\x00\xC8\x97\x64\x06\x87\x00\x95\x97\xB4\x97\x2B\x96\x40\x62\x1B\x00\x83\x0A\x36\x05\x27\x00\x83\x0A\xC2\x01\x96\x00\xA4\x97\xBC\x97\x35\x96\x40\x62\x29\x00\xD8\x97\x13\x38\xDB\x97\xFB\x91\xDE\x97\xC4\x97\x2B\x8E\xEF\x65\x37\x00\xE3\x97\x84\x22\xE5\x97\xCF\x56\xE7\x97\x36\x97", - "\x35\x91\x91\x67\x45\x00\xEC\x97\x15\x8E\xEE\x97\x0A\x01\xC0\x00\xF0\x97\x3F\x97\x22\x95\xCC\x67\x53\x00\xF5\x97\xE1\x43\xF7\x97\xE6\x59\xFA\x97\x48\x97\x01\x94\x69\x64\x61\x00\xD0\x97\x34\x49\x01\x98\x0B\x85\xD3\x97\xCB\x56\xC7\x57\x27\x89\x2E\x8D\xC9\x84\x64\x74\x36\x95\xE3\x71\xD5\x63\xE7\x96\x9C\x6A\x70\x00\x83\x0A\x03\x75\xEB\x00\x2E\x95\xCD\x56\x0A\x89\x4C\x66\x7B\x00\x19\x98\x64\x06\xF8\x00\x1C\x98\xD4\x63\x4F\x95\x8E\x73\x86\x00\xFF\x97\xD4\x62\x7D\x38\xA6\x19\x15\x98\x99\x86\x0C\x6C\x29\x98\x19\x18\x13\x00\x2B\x98\x12\x98\x0E\x8A\x4C\x66\x9E\x00\x30\x98\x8C\x64\x33\x98\x1D\x98\x7A\x91\x88\x8B\x38\x98\x2E\x22\x2F\x00\x3A\x98\x25\x98\x87\x8B\xCC\x67\xB6\x00\x21\x98\xF6\x8B\x17\x96\x2D\x98\x05\x01\x1F\x97\xBC\x2A\xC1\x00\x3E\x98\xB3\x19\x4A\x00\x41\x98\x07\x01\x49\x98\xF9\x85\xD9\x67\x4E\x98\xA1\x22\x58\x00\x51\x98\x06\x01\x53\x98\x2F\x97\x7A\x1C\xD9\x00\x56\x98\xB8\x22\x66\x00\x59\x98\x05\x01\x53\x98\x38\x97\xBC\x2A\xE5\x00\x5F\x98\x82\x27\x74\x00\x62\x98\x00\x00\x53\x98\x41\x97\xBC\x2A\xF1\x00\x68\x98", - "\xFC\x81\x6B\x98\x53\x98\x70\x94\x26\x6E\xFD\x00\x71\x98\x62\x28\x90\x00\x73\x98\xBD\x8B\x40\x62\x09\x00\xE5\x0A\xED\x6E\x9E\x00\x7D\x38\xA8\x19\x53\x98\x59\x97\x16\x00\xE5\x0A\xCC\x6E\xAD\x00\x7B\x98\x87\x94\x4C\x66\x22\x00\x87\x98\x64\x06\xBB\x00\x8A\x98\xD3\x8B\x5E\x71\xE5\x0A\x03\x75\xC9\x00\x48\x98\x6E\x97\x1C\x68\x39\x00\x94\x98\xB5\x8A\x97\x98\x74\x97\x7C\x69\x44\x00\x7F\x98\x64\x06\xE3\x00\x7D\x38\xEC\x1A\x53\x98\x7C\x97\x12\x41\xA1\x98\x1B\x0A\xF3\x00\xA4\x98\x34\x98\x84\x93\x01\x7A\x8E\x98\x1B\x0A\x03\x00\x67\x28\x2C\x98\x89\x97\x31\x64\x6A\x00\xB0\x98\xA8\x10\x11\x00\xB3\x98\xAD\x98\xD7\x90\x69\x87\xA9\x98\xA8\x10\x1F\x00\x67\x28\x83\x98\x97\x97\xDC\x75\xB8\x98\x80\x19\x2E\x00\xBB\x98\x3B\x98\xE7\x90\x45\x84\xC6\x98\xD8\x1A\x3C\x00\xC9\x98\x42\x98\xF7\x90\x4A\x8E\xBF\x98\x80\x19\x4A\x00\x67\x28\xA5\x98\xAE\x97\xC2\x09\xA8\x00\xD4\x98\xD8\x1A\x92\x96\x71\x2C\x53\x98\xD4\x89\x98\x97\xDC\x98\x19\x18\x6A\x00\xD7\x98\xBC\x98\xBF\x93\x86\x63\xC2\x00\xE3\x98\xED\x1A\x7A\x00\xE6\x98\xCA\x98\x60\x87\x7C\x69", - "\xCF\x00\xEB\x98\x85\x85\xC2\x98\xE7\x98\xE8\x76\x70\x65\xDC\x00\xF3\x98\xB3\x19\xD9\x96\xB9\x2C\x53\x98\xF4\x8D\x26\x6E\xE9\x00\xCD\x98\x05\x01\xF5\x00\xE5\x0A\xC2\x01\xA8\x00\xD0\x98\x52\x98\xDF\x93\x40\x62\xF7\x00\x02\x99\x99\x5D\x8A\x0A\x20\x8B\x08\x99\x5A\x98\xAB\x6C\x50\x8C\x8A\x0A\x36\x05\x11\x00\x0F\x99\xB3\x58\x11\x99\x63\x98\xF2\x97\xEF\x65\x13\x00\x15\x99\x71\x02\x18\x99\x56\x74\x1A\x99\x6C\x98\xFC\x97\x4C\x66\x21\x00\x1F\x99\x37\x03\x21\x99\x0A\x01\xE0\x00\x23\x99\xE0\x98\x70\x65\x2F\x00\x8A\x0A\xF1\x04\x3C\x00\x2A\x99\x07\x01\xEE\x00\xF5\x98\xCF\x56\xE7\x56\x13\x98\x10\x8F\x26\x7C\x0E\x98\x63\x96\x10\x98\xDB\x90\xFC\x8C\xCC\x67\x3E\x00\x8A\x0A\x03\x75\xFD\x00\x5A\x96\x39\x99\x3F\x90\x91\x67\x49\x00\x44\x99\x2A\x73\xC0\x97\xE2\x56\x47\x90\x89\x7D\x28\x99\xA8\x10\x3A\x97\xBC\x2D\xE2\x56\x6D\x91\x48\x44\x52\x99\x80\x19\x25\x00\xD6\x27\xA6\x19\xE2\x56\x34\x94\xBC\x2A\x6C\x00\x59\x99\xD8\x1A\x33\x00\x5C\x99\x48\x99\x30\x8D\xEF\x65\x78\x00\x62\x99\x19\x18\x41\x00\x65\x99\x22\x57\x07\x01\x6F\x95\xDB\x8C", - "\x4C\x99\xDD\x6E\x4E\x99\x4A\x94\x44\x6A\x8F\x00\x6A\x99\xED\x1A\x5C\x00\x6D\x99\x11\x57\xDC\x85\x71\x6E\x78\x99\x2E\x22\x6A\x00\x7B\x99\x28\x57\x86\x95\x31\x64\xA7\x00\x7F\x99\xB3\x19\x78\x00\x82\x99\x06\x01\xE2\x56\x65\x98\xED\x25\xB3\x00\x87\x99\x99\x8B\x8A\x99\x05\x01\xE2\x56\x6E\x98\xED\x25\xBF\x00\x90\x99\xB8\x22\x94\x00\x92\x99\x7D\x69\x49\x97\x1C\x68\xCB\x00\x98\x99\x82\x27\xA2\x00\x9B\x99\xE2\x56\xB4\x91\x02\x64\x31\x99\x16\x6F\xD6\x27\xA8\x19\xE2\x56\x59\x97\xE4\x00\xA0\x99\x71\x26\xBF\x00\xA3\x99\xB4\x95\x0F\x79\xAE\x99\x62\x28\xA8\x97\x55\x99\x67\x97\xEB\x87\x72\x99\xA8\x10\xDB\x00\x74\x99\xDA\x8B\x40\x73\xDC\x5A\x03\x75\xE8\x00\xBD\x99\x75\x93\xC7\x8B\xDC\x5A\xED\x6E\xF5\x00\xD6\x27\xEC\x1A\xE2\x56\xA7\x98\x7D\x07\xC6\x99\x64\x06\x05\x00\x83\x0A\xCA\x99\x83\x97\x58\x96\xDC\x5A\xCC\x6E\x15\x00\x83\x0A\x5D\x99\xB5\x98\x69\x64\x38\x00\xD5\x99\x64\x06\x23\x00\xD8\x99\x66\x99\xBD\x98\x96\x62\xCE\x99\x1B\x0A\x31\x00\x83\x0A\xAA\x99\xC4\x98\xD5\x68\xDD\x99\x1B\x0A\x40\x00\xE0\x99\x6E\x99\xE5\x8A\x70\x65", - "\x5D\x00\xEB\x99\xA8\x10\x4E\x00\xEE\x99\x7C\x99\x95\x7F\x40\x62\x69\x00\xE4\x99\xA8\x10\x5C\x00\xD1\x99\xE1\x99\xCE\x8D\xCC\x67\x76\x00\xFB\x99\x06\x87\xFE\x99\xEF\x99\xFB\x8A\x8B\x67\x03\x9A\x13\x75\x05\x9A\xF7\x99\xE8\x98\x02\x94\x09\x9A\x19\x18\x8C\x00\x0B\x9A\x83\x99\x1B\x96\x31\x64\x9D\x00\x0F\x9A\xED\x1A\x9C\x00\xE7\x99\xFF\x99\xF7\x98\x1C\x6C\x17\x9A\x2E\x22\xAB\x00\x1A\x9A\x06\x9A\x19\x8B\x7E\x7E\xF3\x99\x07\x01\xC3\x00\xDC\x5A\x19\x74\xF6\x99\x13\x9A\xE0\x97\x86\x63\xC5\x00\x25\x9A\x4B\x86\x28\x9A\xE6\x58\x2A\x9A\x8B\x99\x13\x99\x9C\x6A\xD3\x00\x2F\x9A\x05\x01\xDF\x00\x31\x9A\x2D\x74\x33\x9A\x93\x99\x1C\x99\xCC\x67\xE1\x00\x38\x9A\x00\x00\xED\x00\x3B\x9A\x38\x74\x3D\x9A\x9C\x99\x3C\x91\x2F\x73\x42\x9A\xFB\x00\x45\x9A\x65\x5B\x47\x9A\xE2\x56\x47\x74\x31\x64\xFD\x00\x17\x9A\x0A\x00\x07\x0B\xBB\x02\xE5\x0A\xA8\x19\x4B\x57\xE2\x56\x2D\x8D\xA5\x8E\x73\x57\x3D\x99\xE1\x96\x5D\x9A\x80\x19\xA0\x57\xDF\x8F\xC2\x09\x0C\x00\x07\x0B\x70\x96\x82\x27\xA0\x57\xE5\x8F\xD1\x0D\x0F\x00\x07\x0B\xFF\x62\x07\x0B\x1A\x62", - "\xA0\x57\x86\x92\xDA\x0B\x16\x00\x6E\x9A\x6F\x2A\x70\x9A\x64\x06\xA0\x57\x8E\x92\xD1\x0D\x1D\x00\x76\x9A\xD6\x33\x78\x9A\x58\x90\x99\x8F\x1C\x68\x24\x00\x7E\x9A\xB4\x36\x80\x9A\xA8\x10\xA0\x57\x9E\x92\x7A\x1C\x2B\x00\x85\x9A\xFC\x37\x87\x9A\x62\x9A\xA6\x8F\x86\x63\x32\x00\x8D\x9A\x7C\x38\x8F\x9A\xD8\x1A\xA0\x57\x9F\x96\x7A\x1C\x39\x00\x94\x9A\x8A\x19\x96\x9A\x19\x18\xA0\x57\xA7\x96\x7A\x1C\x40\x00\x9C\x9A\x8F\x0D\x9E\x9A\xED\x1A\xA0\x57\xB0\x96\xF3\x05\x47\x00\xA4\x9A\x4D\x00\xA6\x9A\x2E\x22\xA0\x57\xB8\x96\xC2\x09\x4E\x00\xA4\x9A\x54\x00\xAE\x9A\xB3\x19\xA0\x57\xC0\x96\x67\x04\x55\x00\xA4\x9A\x5B\x00\xB6\x9A\xA1\x22\xA0\x57\xC8\x96\xF3\x05\x5C\x00\xA4\x9A\x62\x00\xBE\x9A\xB8\x22\xA0\x57\x2A\x90\xF3\x05\x63\x00\xA4\x9A\x69\x00\xC6\x9A\x69\x9A\x05\x8F\xB2\x6F\xA4\x9A\x70\x00\xCE\x9A\x71\x26\xE0\x96\xFB\x97\x0F\x98\x61\x9A\xD8\x1A\xE8\x57\x74\x93\x60\x9A\x64\x90\xB3\x19\xF0\x57\x0A\x01\xDE\x96\xDD\x9A\x4E\x91\x90\x87\xEA\x57\x75\x92\x54\x91\x2E\x22\xDE\x63\x07\x01\xE0\x9A\xE3\x9A\x0D\x94\xE5\x63\x00\x00\xFD\x57", - "\x3E\x99\x9C\x7A\x56\x9A\x64\x06\xF1\x9A\xE1\x43\x70\x65\x73\x00\xD4\x9A\x3F\x99\xFF\x57\x56\x74\xD5\x82\x07\x0B\x7A\x03\x78\x00\xFA\x9A\x01\x62\xF6\x9A\xC2\x72\x75\x72\xFF\x9A\x16\x7F\x02\x9B\xBC\x02\x04\x9B\x3B\x5A\x9C\x6A\x7E\x00\x07\x9B\xE7\x4F\x09\x9B\xDF\x6C\x82\x9A\x2D\x91\x0F\x9B\xCE\x50\x11\x9B\x53\x60\xBB\x88\x70\x65\x88\x00\x15\x9B\xE2\x85\x17\x9B\x0A\x01\x0B\x9B\x00\x00\x98\x96\x7A\x1C\x8D\x00\x1C\x9B\x02\x63\x1E\x9B\xFC\x9A\xD1\x8E\x91\x67\x92\x00\x25\x9B\x3E\x73\x27\x9B\x06\x01\x20\x9B\xA1\x9A\xD1\x0D\x97\x00\x2C\x9B\x00\x00\x9B\x00\x2E\x9B\x05\x01\x20\x9B\xA9\x9A\x67\x04\x9C\x00\x34\x9B\xA0\x00\x37\x9B\xF0\x9A\xC4\x92\xCC\x67\xA1\x00\x34\x9B\xA5\x00\x3F\x9B\x20\x9B\xB9\x9A\xBC\x02\xA6\x00\x34\x9B\xAA\x00\x46\x9B\x48\x82\xA1\x81\x34\x9B\xAF\x00\x4D\x9B\x0E\x88\x70\x65\xB0\x00\x34\x9B\xB4\x00\x52\x9B\x0A\x01\xD7\x96\xC2\x09\xB5\x00\x34\x9B\xB9\x00\x3F\x9B\x04\x58\x0C\x58\x3A\x99\xFC\x75\xF4\x9A\x9B\x89\x6C\x96\x7C\x69\xBC\x00\x3F\x9B\x2E\x22\x11\x58\x6B\x9A\xDA\x0B\xBD\x00\x34\x9B\xC1\x00\x3F\x9B", - "\x11\x58\x73\x9A\xC2\x09\xC2\x00\x34\x9B\xC6\x00\x71\x9B\x82\x96\x1C\x68\xC7\x00\x34\x9B\xCB\x00\x78\x9B\x88\x96\xE9\x81\x34\x9B\xD0\x00\x7E\x9B\x0A\x01\x8A\x9A\xD1\x0D\xD1\x00\x34\x9B\xD5\x00\x83\x9B\xDF\x72\x91\x67\xD6\x00\x34\x9B\xDA\x00\x8A\x9B\x06\x01\x99\x9A\xD1\x0D\xDB\x00\x34\x9B\xDF\x00\x90\x9B\x2A\x82\x9C\x6A\xE0\x00\x34\x9B\xE4\x00\x97\x9B\x00\x00\x3A\x9B\xBC\x02\xE5\x00\x34\x9B\xE9\x00\x9D\x9B\xB1\x9A\xF3\x05\xEA\x00\x34\x9B\xEE\x00\x9D\x9B\x48\x9B\x44\x5B\x34\x9B\xF3\x00\x9D\x9B\xC1\x9A\x67\x04\xF4\x00\x34\x9B\xF8\x00\x9D\x9B\xC9\x9A\x67\x04\xF9\x00\x34\x9B\xFD\x00\x9D\x9B\x5A\x9B\xF3\x05\xFE\x00\x34\x9B\x02\x00\x49\x6B\x1A\x62\x22\x58\xEA\x92\x70\x65\x03\x00\x49\x6B\x03\x75\x0F\x00\xEB\x98\xC3\x9B\xF4\x92\x91\x67\x0E\x00\xC7\x9B\xDA\x74\xCA\x9B\x26\x98\x26\x6E\x19\x00\x49\x6B\xE2\x74\xE5\x0A\xA6\x19\xCB\x9B\x2E\x98\x31\x64\x25\x00\xD5\x9B\xEB\x74\xD7\x9B\x21\x58\x73\x91\xD3\x7E\xDD\x9B\xF3\x74\xDF\x9B\x1F\x58\x3C\x98\xCC\x67\x3D\x00\xE3\x9B\xFB\x74\xE5\x9B\x0A\x01\xD9\x9B\xC9\x5B\x70\x65\x49\x00", - "\xCF\x9B\xB8\x72\xD1\x9B\x77\x95\x86\x63\x54\x00\xEA\x9B\x0B\x75\xEC\x9B\x07\x01\xEE\x9B\x54\x98\x00\x72\xF8\x9B\x13\x75\xFA\x9B\x61\x60\x84\x99\x69\x64\x6C\x00\xFF\x9B\x1B\x75\x01\x9C\x05\x01\xFC\x9B\x8D\x99\x7A\x1C\x78\x00\x06\x9C\x22\x75\x08\x9C\x00\x00\xFC\x9B\x95\x99\x7A\x1C\x84\x00\x0E\x9C\x29\x75\x10\x9C\xFC\x9B\x75\x98\xBC\x2A\x90\x00\x16\x9C\x32\x75\x18\x9C\x7C\x98\x8A\x97\x49\x6B\x3A\x75\x58\x9A\xE0\x9B\x0C\x55\x40\x62\xA9\x00\x1D\x9C\x43\x75\x1F\x9C\x8B\x98\xE6\x78\x29\x9C\x4B\x75\x2B\x9C\x92\x98\xEF\x65\xC1\x00\xF2\x9B\xB3\x89\xF4\x9B\x96\x94\x40\x62\xCC\x00\x34\x9C\x6B\x7E\x36\x9C\xCA\x95\x54\x78\x22\x9C\x63\x75\x8A\x0A\xEC\x1A\xFC\x9B\xCC\x99\xE4\x00\x3F\x9C\x6B\x75\x41\x9C\x25\x9C\xAE\x98\xCC\x67\xF1\x00\x2E\x9C\x74\x75\x8A\x0A\xD8\x9B\xDA\x99\x1C\x68\xFD\x00\x4D\x9C\x7C\x75\x4F\x9C\x49\x9C\xE2\x99\x86\x63\x09\x00\x5D\x0D\xED\x6E\x43\x00\x8A\x0A\xA8\x19\xFC\x9B\xFD\x91\x74\x9A\x5D\x0D\x8C\x75\x56\x9C\xE6\x9B\xCB\x98\xCC\x67\x22\x00\x63\x9C\x94\x75\x65\x9C\xED\x9B\xD9\x98\xF3\x05\x2E\x00\x5B\x9C", - "\x64\x06\x6E\x00\x48\x9C\x66\x9C\xF8\x99\x9D\x64\x71\x9C\x07\x80\x74\x9C\x6D\x9C\xBD\x97\x1C\x68\x48\x00\x78\x9C\xA8\x10\x8E\x00\x7A\x9C\xFB\x9B\x21\x92\x86\x63\x55\x00\x7F\x9C\x80\x19\x9E\x00\x82\x9C\x02\x9C\x14\x9A\x69\x64\x62\x00\x87\x9C\xD8\x1A\xAE\x00\x5E\x9C\x57\x9C\x11\x7C\xFD\x6D\x8F\x9C\x19\x18\xBD\x00\x92\x9C\x75\x9C\x1B\x91\x5C\x6D\x6A\x9C\x90\x80\x5D\x0D\xCE\x75\x6C\x9C\x83\x9C\xE8\x83\x7A\x92\x9D\x9C\x9E\x6E\x9F\x9C\xE3\x5A\xA1\x9C\x8B\x9C\x3D\x96\x4C\x66\x98\x00\xA5\x9C\x1B\x7C\xA7\x9C\x13\x5B\xA9\x9C\x09\x9C\x3F\x9A\x4C\x66\xA6\x00\xAE\x9C\x26\x7C\xB0\x9C\xEB\x75\xB2\x9C\x11\x9C\x25\x99\x7C\x69\xB4\x00\xB7\x9C\x66\x60\xB9\x9C\x7D\x01\xDC\x5A\x50\x9C\x05\x98\x1C\x68\xC2\x00\x96\x9C\xD4\x59\xC2\x9C\xAD\x2C\xDC\x5A\xA8\x19\x2A\x58\xAB\x87\x91\x67\xD1\x00\x5D\x0D\x68\x9A\x71\x26\xCF\x9C\xB1\x87\x17\x73\x5D\x0D\xF7\x18\xDA\x00\x5D\x0D\x1A\x62\xD6\x9C\x8D\x8F\xEF\x65\xDB\x00\xD9\x9C\xF3\x5A\xDC\x9C\x64\x06\xDE\x9C\xD1\x85\x91\x67\xE2\x00\xE2\x9C\x13\x5B\xE4\x9C\x1F\x6F\x13\x9B\x8E\x73\xE9\x00\xEA\x9C", - "\x18\x7E\xEC\x9C\xA8\x10\xE6\x9C\x05\x01\x85\x9B\xDA\x0B\xF0\x00\xF1\x9C\x21\x81\xF3\x9C\xCA\x8D\x91\x9A\x31\x64\xF7\x00\xFA\x9C\xC1\x5C\xFC\x9C\xD8\x1A\xF5\x9C\xE0\x87\x99\x70\x01\x9D\xAB\x01\x0F\x0E\xDD\x9C\x8D\x7C\x91\x67\x05\x00\x0F\x0E\xF7\x18\x0B\x00\x0A\x9D\xE5\x9C\xBD\x92\x9C\x6A\x0C\x00\x0F\x9D\x3C\x2B\x12\x9D\xED\x9C\xE5\x5A\x48\x73\x17\x9D\xBF\x08\x19\x9D\xF4\x9C\x00\x88\x60\x62\x1D\x9D\x0A\x01\x20\x00\x1F\x9D\xFD\x9C\x07\x88\x9C\x6A\x21\x00\x23\x9D\x7D\x04\x26\x9D\x04\x9D\xCF\x96\xF8\x74\x2B\x9D\xEE\x1D\x2D\x9D\x19\x18\x05\x9D\xBC\x9B\x67\x04\x2F\x00\x31\x9D\x82\x2A\x33\x9D\xED\x1A\xDE\x5E\xF8\x97\x62\x9B\x11\x7B\x40\x58\xF1\x43\x29\x67\x0F\x0E\xD4\x9C\xBA\x8B\x4B\x85\x78\x89\x39\x9D\x13\x0A\x3B\x9D\x2E\x22\x42\x58\x00\x00\x73\x9B\x1B\x7D\x49\x9D\x46\x00\x4B\x9D\xB3\x19\x4D\x9D\x7B\x9A\xDA\x0B\x47\x00\x49\x9D\x4D\x00\x53\x9D\xA1\x22\x4D\x9D\x96\x92\xD1\x0D\x4E\x00\x49\x9D\x54\x00\x5B\x9D\xB8\x22\x4D\x9D\xF7\x9C\xC2\x09\x55\x00\x49\x9D\x5B\x00\x63\x9D\x82\x27\x4D\x9D\x22\x9B\xD1\x0D\x5C\x00\x49\x9D", - "\x62\x00\x6B\x9D\x71\x26\x4D\x9D\x92\x9B\xDA\x0B\x63\x00\x49\x9D\x69\x00\x73\x9D\x46\x9D\xF2\x85\x60\x8B\x49\x9D\x70\x00\x7B\x9D\x01\x62\x4D\x9D\x9F\x9B\x5F\x4A\x49\x9D\x77\x00\x81\x9D\xBC\x02\x4D\x9D\xA5\x9B\x67\x04\x78\x00\x49\x9D\x7E\x00\x88\x9D\x41\x9D\xAB\x9B\xEE\x4F\x49\x9D\x85\x00\x90\x9D\x33\x58\x28\x9D\x91\x67\x86\x00\x49\x9D\x8C\x00\x96\x9D\x37\x58\x53\x9B\x58\x81\x49\x9D\x93\x00\x9D\x9D\x3B\x58\x78\x8F\x70\x65\x94\x00\x49\x9D\x9A\x00\xA3\x9D\x90\x58\x97\x9D\xF2\x9A\xDE\x9A\xA1\x22\xAF\x58\x37\x7D\xD3\x53\xAA\x9D\x8B\x14\xDC\x5A\x80\x03\xAF\x58\x2F\x88\x7A\x1C\x9C\x00\xB3\x9D\x61\x17\xB5\x9D\xB7\x58\xF1\x62\x70\x65\x9D\x00\xBB\x9D\x23\x00\xBD\x9D\xB9\x58\x6F\x43\x5E\x69\xBB\x9D\x24\x00\xC4\x9D\xA8\x58\x45\x88\x31\x64\x9F\x00\xBB\x9D\x25\x00\xCA\x9D\xAA\x58\xC7\x68\x31\x64\xA0\x00\xBB\x9D\x26\x00\xD1\x9D\xAC\x58\x55\x88\xEF\x65\xA1\x00\xBB\x9D\x27\x00\xD8\x9D\xAE\x58\xFB\x6F\x1C\x68\xA2\x00\xBB\x9D\x28\x00\xDF\x9D\xB0\x58\x21\x2D\x77\x63\xBB\x9D\x29\x00\xE6\x9D\xAF\x58\x6D\x88\x42\x56\xBB\x9D\x2A\x00", - "\xEC\x9D\x03\x2B\x33\x78\xBB\x9D\x2B\x00\xF2\x9D\x77\x7D\x86\x63\xA6\x00\xBB\x9D\x2C\x00\xF7\x9D\x3B\x63\x51\x74\xBB\x9D\x2D\x00\xFD\x9D\x41\x63\x86\x63\xA8\x00\xBB\x9D\x2E\x00\x02\x9E\x15\x40\x27\x9C\xBB\x9D\x2F\x00\x08\x9E\x6E\x30\x70\x65\xAA\x00\x3B\x9D\xAB\x00\x0F\x0E\x16\x02\xE6\x9D\xC6\x58\x64\x9A\xF3\x05\xAD\x00\x44\x9D\xE4\x9A\xC7\x58\x47\x9D\xEF\x65\xB0\x00\x49\x9D\xB6\x00\xBB\x9D\xC6\x58\x4F\x9D\x67\x04\xB7\x00\x49\x9D\xBD\x00\x22\x9E\x79\x9B\x44\x6A\xBE\x00\x49\x9D\xC4\x00\x29\x9E\x7F\x9B\x03\x73\x49\x9D\xCB\x00\x2F\x9E\x84\x9B\x79\x6B\x49\x9D\xD2\x00\x34\x9E\x8B\x9B\xEF\x65\xD3\x00\x49\x9D\xD9\x00\x39\x9E\x91\x9B\x82\x70\x49\x9D\xE0\x00\x3F\x9E\x98\x9B\x58\x6F\x49\x9D\xE7\x00\x44\x9E\x9E\x9B\xD0\x90\x49\x9D\xEE\x00\x49\x9E\x8B\x9D\xBC\x02\xEF\x00\x49\x9D\xF5\x00\x49\x9E\x92\x9D\xEB\x75\x49\x9D\xFC\x00\x49\x9E\xB0\x9B\xBC\x02\xFD\x00\x49\x9D\x03\x00\x88\x17\x1A\x62\xC6\x58\xB6\x9B\xBC\x02\x04\x00\x88\x17\xF0\x7A\x5F\x9E\x8A\x6E\xD0\x9A\xCC\x67\x0B\x00\x65\x9E\x71\x03\x67\x9E\x1B\x0A\xE0\x58\x80\x8F", - "\x4C\x66\x12\x00\x88\x17\x45\x9D\x01\x62\x70\x9E\x74\x61\x70\x65\x15\x00\x6C\x9E\x0A\x26\x6E\x9E\x51\x6C\xEB\x8F\x1C\x68\x1C\x00\x7B\x9E\x29\x33\x7D\x9E\x80\x19\x77\x9E\x00\x00\x56\x9D\xC2\x09\x23\x00\x82\x9E\x5B\x5F\x84\x9E\x64\x76\xEE\x9C\x26\x6E\x2A\x00\x8B\x9E\x90\x05\x8D\x9E\x19\x18\x86\x9E\x66\x9D\xF3\x05\x31\x00\x92\x9E\x05\x01\x37\x00\x94\x9E\xED\x1A\x86\x9E\x6E\x9D\xDA\x0B\x38\x00\x9A\x9E\x4E\x6E\x9D\x9E\x2E\x22\x86\x9E\x76\x9D\x15\x7D\xA3\x9E\x45\x00\xA5\x9E\xB3\x19\x86\x9E\x31\x9B\xDA\x0B\x46\x00\xA3\x9E\x4C\x00\xAC\x9E\xA1\x22\x86\x9E\x84\x9D\x30\x3F\xA3\x9E\x53\x00\xB4\x9E\xB8\x22\x86\x9E\x4F\x9E\x5D\x15\xA3\x9E\x5A\x00\xBB\x9E\x82\x27\x86\x9E\x55\x9E\x5C\x06\xA3\x9E\x61\x00\xC2\x9E\x71\x26\x86\x9E\x5A\x9E\xA5\x02\xA3\x9E\x68\x00\xC9\x9E\x62\x28\x86\x9E\x62\x9E\x5D\x47\xA3\x9E\x6F\x00\xD0\x9E\x76\x9E\x69\x9E\x55\x6D\xA3\x9E\x76\x00\xD7\x9E\xBC\x02\xE5\x58\xDE\x58\xE7\x9A\x71\x92\x2E\x22\x0B\x5A\xB1\x9D\x9D\x4E\xDD\x9E\x4C\x22\xE6\x9D\x0B\x5A\xB8\x9D\xD1\x0D\x78\x00\xE7\x9E\x40\x57\xE9\x9E\x37\x88", - "\xFB\x6B\xEE\x9E\x18\x04\xF0\x9E\xE2\x7C\x1C\x68\x7A\x00\xF3\x9E\xA2\x57\xF5\x9E\xE8\x7C\x69\x64\x7B\x00\xF9\x9E\xB1\x6B\xFB\x9E\xEF\x7C\x69\x64\x7C\x00\xFF\x9E\xA4\x88\x01\x9F\xF6\x7C\xCC\x67\x7D\x00\x05\x9F\x19\x26\x07\x9F\xFC\x7C\x69\x64\x7E\x00\x0B\x9F\xDC\x99\xCF\x2A\x0B\x5A\x65\x88\x42\x4F\x0B\x9F\x39\x00\x0D\x9F\x6B\x7D\xCC\x67\x80\x00\x0B\x9F\x3A\x00\x19\x9F\x74\x88\x2D\x5F\x0B\x9F\x3B\x00\x19\x9F\x14\x7D\xF3\x05\x82\x00\x0B\x9F\x3C\x00\x19\x9F\x7C\x7D\xBC\x02\x83\x00\x0B\x9F\x3D\x00\x19\x9F\x20\x7D\xBC\x02\x84\x00\x0B\x9F\x3E\x00\x19\x9F\x88\x7D\xBC\x2A\x85\x00\x0B\x9F\x3F\x00\x19\x9F\x8E\x7D\xC2\x09\x86\x00\x9D\x9E\x87\x00\x88\x17\xC2\x01\x40\x00\xE6\x9D\x0E\x59\x17\x9E\x67\x04\x89\x00\x74\x9E\x1B\x9E\x0E\x59\x6C\x9B\xC2\x09\x8C\x00\xA3\x9E\x92\x00\x0B\x9F\x0E\x59\x24\x9E\xBC\x02\x93\x00\xA3\x9E\x99\x00\x52\x9F\x2A\x9E\x8E\x73\x9A\x00\xA3\x9E\xA0\x00\x59\x9F\x30\x9E\xDB\x9D\xA3\x9E\xA7\x00\x5F\x9F\x35\x9E\x9C\x6A\xA8\x00\xA3\x9E\xAE\x00\x64\x9F\x3A\x9E\xCC\x67\xAF\x00\xA3\x9E\xB5\x00\x6A\x9F\x40\x9E", - "\xF0\x91\xA3\x9E\xBC\x00\x70\x9F\x45\x9E\xEF\x65\xBD\x00\xA3\x9E\xC3\x00\x75\x9F\x4A\x9E\x9C\x6A\xC4\x00\xA3\x9E\xCA\x00\x7B\x9F\xBE\x9E\xC8\x59\xA3\x9E\xD1\x00\x7B\x9F\xC5\x9E\x12\x8F\xA3\x9E\xD8\x00\x7B\x9F\xCC\x9E\xF2\x85\xA3\x9E\xDF\x00\x7B\x9F\xD3\x9E\x0F\x01\xE0\x00\xA3\x9E\xE6\x00\x7B\x9F\x36\x9D\x06\x81\xA3\x9E\xED\x00\x0B\x9F\x6D\x59\x47\x9F\xBC\x02\xEE\x00\x4A\x9F\x0D\x94\x6D\x59\x4D\x9F\xF3\x05\xF1\x00\xA3\x9E\xF7\x00\x9B\x9F\x7F\x9E\x44\x6A\xF8\x00\xA3\x9E\xFE\x00\xA8\x9F\xF1\x8F\x13\x8D\xA3\x9E\x05\x00\x29\x0D\x1A\x62\x6D\x59\x5E\x9D\xDA\x0B\x06\x00\x29\x0D\x14\x63\xB3\x9F\xC6\x6F\x19\x9B\x3A\x76\xB9\x9F\x66\x05\xBB\x9F\x1B\x0A\x6D\x59\xA0\x9E\x9C\x66\xBF\x9F\x99\x2D\xC1\x9F\xA8\x10\x6D\x59\xA8\x9E\xF3\x05\x1B\x00\xC6\x9F\xE5\x1D\xC8\x9F\x80\x19\x6D\x59\xAF\x9E\xC2\x09\x22\x00\xCE\x9F\xC9\x78\xD0\x9F\x03\x78\x14\x9D\x91\x67\x29\x00\xD6\x9F\x00\x38\xD8\x9F\x19\x18\x6D\x59\x82\x9F\x72\x0D\xDD\x9F\xA4\x88\xDF\x9F\xBE\x80\x21\x9D\x86\x63\x37\x00\xE4\x9F\xA3\x0D\xE6\x9F\x2E\x22\x6D\x59\x8C\x9F\x0A\x01", - "\x3E\x00\xEB\x9F\x44\x00\xED\x9F\x87\x6D\x2F\x9D\x40\x62\x45\x00\xEB\x9F\x4B\x00\xF5\x9F\xA1\x22\x6D\x59\x97\x9F\x7F\x87\xEB\x9F\x52\x00\xFC\x9F\xB8\x22\xC9\x59\x0A\x01\xDF\x9E\xAD\x9D\x1B\x9E\xCE\x59\x0E\x5A\x40\x85\x76\x92\x71\x26\xD0\x59\xAF\x59\x3F\x9D\xCA\x7D\xE7\x59\x39\x96\xEA\x6D\x03\xA0\x82\x27\x41\x00\xE6\x9D\x13\xA0\xD6\x23\x20\x84\x16\xA0\x71\x26\x42\x00\x19\xA0\xF1\x9E\xEC\x68\x1D\xA0\x62\x28\x43\x00\x20\xA0\xF6\x9E\x44\x6A\x56\x00\x23\xA0\x01\x62\x44\x00\x26\xA0\xFC\x9E\x1C\x68\x57\x00\x2A\xA0\xBC\x02\x45\x00\x2D\xA0\x02\x9F\x32\x6B\x31\xA0\x4B\x02\x34\xA0\x08\x9F\x4C\x66\x59\x00\x37\xA0\x62\x3B\x39\xA0\x0E\x9F\x15\x91\x3D\xA0\xAB\x04\x3F\xA0\x02\x7D\x69\x64\x5B\x00\x42\xA0\xC8\x3C\x44\xA0\xEE\x9D\x61\x0A\x48\xA0\x72\x3D\x44\xA0\x20\x9F\x41\x0A\x4D\xA0\xE5\x3D\x44\xA0\x25\x9F\x67\x04\x5E\x00\x52\xA0\x75\x3E\x44\xA0\x2B\x9F\xD1\x43\x58\xA0\x4D\x00\x44\xA0\x31\x9F\x31\x44\x58\xA0\x4E\x00\x44\xA0\x37\x9F\x87\x8F\x58\xA0\x4F\x00\x44\xA0\x3D\x9F\xF3\x05\x62\x00\xE6\x9F\x63\x00\x29\x0D\xC2\x01\x50\x00", - "\xE6\x9D\xF5\x63\xF7\x9A\x9C\x6A\x65\x00\x29\x0D\x75\x9E\xC2\x90\x1D\x9E\xCC\x67\x68\x00\xEB\x9F\x6E\x00\x58\xA0\x73\xA0\x05\x9B\xEF\x65\x6F\x00\xEB\x9F\x75\x00\x7F\xA0\x5A\x9F\x26\x6E\x76\x00\xEB\x9F\x7C\x00\x86\xA0\x60\x9F\x09\x9F\xEB\x9F\x83\x00\x8C\xA0\x65\x9F\x91\x67\x84\x00\xEB\x9F\x8A\x00\x91\xA0\x6B\x9F\x4C\x66\x8B\x00\xEB\x9F\x91\x00\x97\xA0\x71\x9F\x2A\x9B\xEB\x9F\x98\x00\x9D\xA0\x76\x9F\xCC\x67\x99\x00\xEB\x9F\x9F\x00\xA2\xA0\x7C\x9F\x7D\x7B\xEB\x9F\xA6\x00\xA8\xA0\xE2\x9F\x47\x93\xEB\x9F\xAD\x00\xA8\xA0\x87\x9F\x65\x8E\xEB\x9F\xB4\x00\xA8\xA0\xF0\x9F\x07\x01\xB5\x00\xEB\x9F\xBB\x00\xA8\xA0\x91\x9F\x1F\x9B\xEB\x9F\xC2\x00\xA8\xA0\xFF\x9F\x59\x58\xEB\x9F\xC9\x00\x58\xA0\x09\x5A\xE5\x9E\x83\x59\x58\xA0\x51\x00\xE6\x9D\x09\x5A\xEB\x9E\xDA\x0B\xCB\x00\x58\xA0\x52\x00\xCD\xA0\x21\xA0\x7C\x69\xCC\x00\x58\xA0\x53\x00\xD4\xA0\x27\xA0\x8E\x73\xCD\x00\x58\xA0\x54\x00\xDA\xA0\x2E\xA0\x44\x6A\xCE\x00\x58\xA0\x55\x00\xE0\xA0\x35\xA0\x44\x6A\xCF\x00\x58\xA0\x56\x00\xE6\xA0\x3A\xA0\x7C\x69\xD0\x00\x58\xA0\x57\x00", - "\xEC\xA0\x40\xA0\x44\x6A\xD1\x00\x58\xA0\x58\x00\xF2\xA0\x45\xA0\xCE\x69\x58\xA0\x59\x00\xF8\xA0\x4B\xA0\x25\x5A\x58\xA0\x5A\x00\xF8\xA0\x50\xA0\x33\x5A\x58\xA0\x5B\x00\xF8\xA0\x55\xA0\xBC\x02\xD5\x00\x58\xA0\x5C\x00\xF8\xA0\x5B\xA0\x2D\x74\x58\xA0\xF2\x99\xCF\x2A\x09\x5A\x60\xA0\x9A\x5A\x58\xA0\x5E\x00\xF8\xA0\x65\xA0\x7A\x1C\xD8\x00\x58\xA0\x5F\x00\xF8\xA0\x6A\xA0\x67\x04\xD9\x00\xE6\x9F\xDA\x00\x6F\xA0\x31\x44\xE6\x9D\xF1\x5E\x2C\x8E\x91\x67\xDC\x00\x58\xA0\xFF\x6F\x7A\xA0\x4C\x66\xDD\x00\x29\x0D\x7A\x03\xE1\x00\x58\xA0\x27\xA1\xDF\x9C\xCC\x67\xE2\x00\x30\xA1\x0F\x5B\x33\xA1\x87\xA0\xBC\x2A\xE7\x00\x38\xA1\x21\x5B\x3A\xA1\x8D\xA0\x4C\x66\xEC\x00\x3E\xA1\x4F\x5B\x40\xA1\x92\xA0\xB8\x79\x44\xA1\xE5\x5B\x46\xA1\x98\xA0\x7C\x69\xF6\x00\x49\xA1\x29\x81\x4B\xA1\x9E\xA0\xEF\x65\xFB\x00\x4F\xA1\xAD\x01\x51\xA1\xA3\xA0\x4C\x66\x61\x6E\xEB\x68\x3E\x05\x5C\x3A\x1A\x62\x34\xA1\xD2\x88\x50\x8C\x5C\x3A\x2C\x68\x5D\xA1\x7A\x7F\x41\x9B\x11\x7E\x62\xA1\xED\x04\x64\xA1\x1D\x6B\xE8\x9F\x31\x64\x0F\x00\x68\xA1\x60\x0B\x6A\xA1", - "\xA8\x10\x5F\xA1\x05\x01\xB8\xA0\x26\x0B\x6F\xA1\xAF\x30\x71\xA1\x80\x19\x73\xA1\x70\x8F\x42\x76\x77\xA1\x07\x01\x1D\x00\x79\xA1\xD2\x8D\xD9\x9E\x7C\x69\x1E\x00\x7E\xA1\x25\x18\x81\xA1\x19\x18\x56\x7C\xE3\x24\xDD\x82\x54\x91\x60\x74\xF5\x57\xED\x9A\x37\x95\x0C\x9B\xF6\x57\x11\xA0\xB7\x71\x5E\x5A\xEF\x9A\x5C\x9A\x86\x8C\xB6\x7A\x60\x9B\xE1\x9E\x3D\x95\xD8\x1A\xAE\x5A\xFC\x9B\x98\xA1\x64\x06\x28\x80\x54\x58\xA1\xA1\x1B\x0A\x30\x80\xAF\x58\xA5\xA1\xA8\x10\x95\x7C\x05\xA0\x90\xA1\xE3\x71\x9D\x7C\x0A\xA0\xAD\xA1\x3B\x99\xC4\x8F\x6B\x61\x94\xA1\x54\x91\xAD\x7C\x1A\xA0\xA9\xA1\x70\x90\x08\x5A\xB5\xA1\x71\x92\xFD\x7A\xBC\x15\x8C\xA1\xB8\x22\x61\x00\xE6\x9D\xFD\x7A\xBE\x71\xC5\x26\xB7\x71\x62\x00\xE6\x9D\xF6\x5E\xC4\x9B\x9C\x6A\x23\x00\x5C\x3A\x03\x75\x63\x00\x17\x9A\xCA\xA1\xCC\x9B\x91\x88\xCE\xA1\x1F\x6C\xD1\xA1\xD2\x9B\xBC\x2A\x39\x00\x5C\x3A\xCC\x6E\x7D\x00\xC4\x9C\xF1\x5A\x00\x97\x44\x6A\x45\x00\xDB\xA1\x64\x06\x8B\x00\xDE\xA1\x92\x9F\xE1\x9B\x1C\x68\x51\x00\xE3\xA1\xE3\x91\xE6\xA1\x2B\x99\x3B\x94\x7C\x69\x5D\x00", - "\xEB\xA1\xA8\x10\xA7\x00\xED\xA1\x07\x01\xD2\xA1\x1B\x83\x70\x65\x69\x00\xD5\xA1\x58\x90\xD7\xA1\xF5\x9B\x31\x64\x74\x00\xF2\xA1\x80\x19\xC2\x00\xF5\xA1\xF0\x67\x47\x8D\x40\x62\x80\x00\x01\xA2\xD8\x1A\xD0\x00\x04\xA2\x05\x01\xF7\xA1\xF5\x51\x9C\x6A\x8C\x00\x09\xA2\x19\x18\xDE\x00\x0C\xA2\x00\x00\x0E\xA2\x51\x89\x91\x67\x98\x00\x12\xA2\xED\x1A\xEC\x00\x15\xA2\x17\xA2\x13\x9C\xD1\x0D\xA4\x00\x1B\xA2\xD4\x83\x1E\xA2\x9D\x99\x44\x6A\xB0\x00\x23\xA2\xB3\x19\x08\x00\x07\x0B\xA6\x19\x17\xA2\xA5\x99\xED\x25\xBC\x00\x5C\x3A\xED\x6E\x75\x9A\xB9\x2C\x17\xA2\x59\x97\xC9\x00\x29\xA2\xAE\x64\x2C\xA2\xDF\xA1\x2C\x9C\x40\x62\xD5\x00\x39\xA2\xB8\x22\x33\x00\x3B\xA2\xE7\xA1\x8E\x94\xE0\x69\xFB\xA1\xA8\x10\x41\x00\x07\x0B\xF1\x04\x17\xA2\xB2\x90\x26\x6E\xEC\x00\x47\xA2\x80\x19\xB3\x9A\x58\x11\x17\xA2\xCC\x99\xF7\x00\x32\xA2\x64\x06\xBD\x9A\x71\x2C\x54\xA2\xBB\x80\x04\x00\x7B\x09\xED\x6E\x6B\x00\x07\x0B\xEC\x1A\x17\xA2\xDA\x95\x7A\x1C\x11\x00\x7B\x09\xCC\x6E\x7B\x00\x43\xA2\xEE\xA1\xEF\x91\x91\x67\x1D\x00\x67\xA2\xDC\x91\x6A\xA2", - "\xF6\xA1\x93\x93\x44\x6A\x29\x00\x5E\xA2\xB8\x95\x07\x0B\xA8\x19\x17\xA2\x61\x9C\xC2\x09\x36\x00\x6F\xA2\x8C\x92\x71\xA2\x05\xA2\xA1\x93\x31\x64\x42\x00\x7E\xA2\xA8\x10\x57\x9B\xBC\x2D\x17\xA2\x0C\x92\x14\x65\x76\xA2\x87\x78\x61\xA2\x3C\xA2\xD2\x98\x46\xA0\x8C\xA2\x8F\x78\x8E\xA2\x44\xA2\xB5\x97\x26\x6E\x68\x00\x92\xA2\x80\x19\xE2\x00\x94\xA2\x6B\xA2\x96\xA2\xA1\x8F\x99\xA2\xD8\x1A\xF2\x00\x9C\xA2\x72\xA2\x8C\x9C\x1C\x68\x82\x00\xA0\xA2\x5B\x70\x49\x6B\x79\xA2\x23\x96\xED\x25\x8F\x00\xA8\xA2\xED\x1A\x11\x00\xAA\xA2\x8F\xA2\xD5\x97\x8A\x97\x85\xA2\xD4\x57\x7B\x09\xC2\x01\x20\x00\x49\x6B\x2D\xA2\x0A\x99\x86\x63\xAA\x00\xB6\xA2\x06\x01\xB6\x00\xB8\xA2\x41\x02\xBB\xA2\xB3\xA2\xF1\x83\xC5\x92\xC0\xA2\xAE\x58\xC3\xA2\x23\x6E\xC5\xA2\x95\xA2\xCA\x8E\xEF\x65\xC6\x00\xC9\xA2\x79\x61\xCB\xA2\xAB\x3D\xCD\xA2\x9D\xA2\x4F\x96\x4C\x66\xD4\x00\xD2\xA2\xE0\x00\xD4\xA2\xEE\x41\xD6\xA2\xA4\xA2\x2C\x95\x86\x63\xE2\x00\xAF\xA2\xEF\x00\xDD\xA2\x55\x29\xB2\xA2\x0F\x01\x19\x64\x74\xA0\x01\x7E\x7B\x09\x49\x85\xEA\xA2\x73\x96\x91\x70", - "\x7B\x09\x7A\x03\xF6\x00\xED\xA2\x64\x06\xEF\xA2\x7C\x96\x52\x89\xF2\xA2\x8D\x5C\xF5\xA2\x7F\x97\x3B\xA1\xED\x25\xFC\x00\xFA\xA2\xAB\x3B\x09\x65\xF7\xA2\x73\x5A\x70\x65\x01\x00\x3F\x3B\xF5\x87\x3F\x3B\x1A\x62\x04\xA3\x97\x9E\x67\x04\x06\x00\x08\xA3\x42\x2B\x0A\xA3\xF6\xA2\xFE\x9C\x69\x64\x0B\x00\x10\xA3\x1C\x01\x12\xA3\xFD\xA2\xAC\x8F\x08\x88\x17\xA3\x5B\x2B\x19\xA3\xA8\x10\x04\xA3\xD3\x9F\xF3\x05\x15\x00\x1D\xA3\xC1\x0A\x1F\xA3\x98\x78\xDA\x9F\xEF\x65\x1A\x00\x25\xA3\xFD\x2F\x27\xA3\x52\x95\x66\xA1\x27\x88\x2C\xA3\xE3\x33\x2E\xA3\x19\x18\x04\xA3\xB3\xA0\x6F\x06\x32\xA3\x04\x36\x34\xA3\xED\x1A\x04\xA3\x75\xA1\x96\x36\x39\xA3\x2D\x00\x3B\xA3\x2E\x22\x04\xA3\xBE\xA0\x98\x05\x39\xA3\x32\x00\x42\xA3\xB3\x19\x04\xA3\xC3\xA0\x18\x04\x39\xA3\x37\x00\x49\xA3\xA1\x22\xDD\x5D\xEB\xA2\xEF\x65\x38\x00\x50\xA3\x71\x92\x52\xA3\xF0\xA2\x78\x89\x39\xA3\x3D\x00\x56\xA3\x82\x27\x58\xA3\xF8\xA2\x91\x67\x3E\x00\x39\xA3\x42\x00\x5D\xA3\x71\x26\x5F\xA3\x87\x9E\x70\x65\x43\x00\x39\xA3\x47\x00\x65\xA3\x62\x28\x67\xA3\xB6\x9F\xC2\x09", - "\x48\x00\x39\xA3\x4C\x00\x6D\xA3\x01\x62\x67\xA3\x0D\xA3\xBC\x02\x4D\x00\x39\xA3\x51\x00\x75\xA3\xBC\x02\x67\xA3\xC4\x9F\xEC\x8B\x39\xA3\x56\x00\x7D\xA3\xF5\x5A\xEB\x85\x44\x6D\x39\xA3\x5B\x00\x84\xA3\xF9\x5A\x0C\x9D\xEF\x65\x5C\x00\x39\xA3\x60\x00\x8A\xA3\x0A\x01\x67\xA3\xB7\x9E\x36\x04\x39\xA3\x65\x00\x91\xA3\x07\x01\x67\xA3\xAE\xA0\x55\x29\x39\xA3\x6A\x00\x98\xA3\x06\x01\x67\xA3\x37\xA3\x6B\x00\x39\xA3\x6F\x00\x9F\xA3\x05\x01\x67\xA3\x3E\xA3\x99\x6D\x39\xA3\x74\x00\xA6\xA3\x00\x00\x67\xA3\x45\xA3\x3D\x4D\x39\xA3\x79\x00\xAD\xA3\x67\xA3\x4C\xA3\xD9\x4E\x39\xA3\x7E\x00\xAD\xA3\xD8\x5D\x53\xA3\xCC\x67\x7F\x00\xAD\xA3\x2E\x22\xBB\xA3\x59\xA3\xEF\x65\x80\x00\x39\xA3\x84\x00\xBA\xA3\xA9\x9F\x8E\x73\x85\x00\x39\xA3\x89\x00\xC7\xA3\xAF\x9F\x4C\x66\x8A\x00\x39\xA3\x8E\x00\xCD\xA3\xF7\x8F\x45\x84\x39\xA3\x93\x00\xD3\xA3\xFC\x8F\x91\x67\x94\x00\x39\xA3\x98\x00\xD8\xA3\x02\x90\x4C\x66\x99\x00\x39\xA3\x9D\x00\xDE\xA3\x08\x90\xBD\x6A\x39\xA3\xA2\x00\xE4\xA3\x0D\x90\x64\x69\x39\xA3\xA7\x00\xE9\xA3\x94\xA3\xD4\x57\x39\xA3", - "\xAC\x00\xE9\xA3\x9B\xA3\x65\x77\x39\xA3\xB1\x00\xE9\xA3\x37\xA3\xB2\x00\x39\xA3\xB6\x00\xE9\xA3\xA9\xA3\xB7\x00\x39\xA3\xBB\x00\xE9\xA3\xB0\xA3\x38\x9B\x39\xA3\xC0\x00\xE9\xA3\xB6\xA3\x06\x01\xC1\x00\x39\xA3\xC5\x00\xAD\xA3\x01\x5B\xD0\x9C\xD0\xA2\xBF\xA3\xB3\x19\x0E\xA4\xD7\x9C\x8F\x77\x39\xA3\xCB\x00\x0D\xA4\xC8\xA3\x26\x6E\xCC\x00\x39\xA3\xD0\x00\x18\xA4\xCE\xA3\x7C\x69\xD1\x00\x39\xA3\xD5\x00\x1E\xA4\xD4\xA3\xCC\x67\xD6\x00\x39\xA3\xDA\x00\x24\xA4\xD9\xA3\xE0\x9C\x39\xA3\xDF\x00\x2A\xA4\xDF\xA3\x7C\x69\xE0\x00\x39\xA3\xE4\x00\x2F\xA4\xE5\xA3\x91\x67\xE5\x00\x39\xA3\xE9\x00\x35\xA4\xEA\xA3\xCF\x8D\x39\xA3\xEE\x00\x3B\xA4\xEF\xA3\x06\x01\xEF\x00\x39\xA3\xF3\x00\x3B\xA4\xF4\xA3\x45\x6A\x39\xA3\xF8\x00\x3B\xA4\x37\xA3\xF9\x00\x39\xA3\xFD\x00\x3B\xA4\xA9\xA3\xFE\x00\x39\xA3\x02\x00\xD9\x0E\x1A\x62\x13\xA4\x10\x64\xC5\x9B\xD9\x0E\x7A\x03\x07\x00\x55\xA4\xBC\x8A\x83\xA1\x40\x62\x08\x00\x5A\xA4\x9A\x01\x5D\xA4\x1B\x0A\xFE\x5E\x07\x01\x57\xA4\x9C\xA1\x6A\x96\xA8\x10\xF7\x74\xEB\x92\xF3\x05\x0D\x00\xD9\x0E\x03\x75", - "\x75\x00\x46\x9C\x67\x99\xF0\x96\xD0\x79\x70\xA4\x5F\x6D\x73\xA4\x68\x70\xD8\xA1\xED\x25\x23\x00\xD9\x0E\xCC\x6E\x8F\x00\xDF\xA2\x06\x01\xF7\x74\x57\x99\x00\x38\x7E\xA4\x39\x8E\x81\xA4\x10\x93\x17\x8A\xCC\x67\x3B\x00\x86\xA4\x61\x7B\x88\xA4\xF3\x7E\xEF\xA1\x40\x62\x47\x00\x8D\xA4\xA8\x10\xB9\x00\x8F\xA4\xF7\x74\x70\x99\xBC\x2A\x53\x00\x77\xA4\x1B\x0A\xC7\x00\x79\xA4\x82\xA4\x75\x99\xBC\x85\x94\xA4\x80\x19\xD4\x00\x97\xA4\x06\xA2\x86\x63\x6A\x00\xA3\xA4\xD8\x1A\xE2\x00\xA6\xA4\x31\x93\x75\x97\xAA\xA4\x19\x18\xF0\x00\xAD\xA4\xCB\x86\x35\x81\xB0\xA4\xED\x1A\xFE\x00\xB3\xA4\x7C\x7B\xEF\x65\x8E\x00\xB6\xA4\x2E\x22\x0C\x00\x5D\x0D\xA6\x19\xF7\x74\x1A\x9C\xED\x25\x9A\x00\xBD\xA4\x41\x67\xC0\xA4\xEF\xA1\x2F\xA2\x7A\x1C\xA6\x00\xD9\x0E\xED\x6E\x28\x00\x5D\x0D\xA8\x19\xF7\x74\x59\x97\xB3\x00\xC6\xA4\xA1\x22\x37\x00\xC8\xA4\xE7\x9B\x47\x75\x9C\x6A\xBF\x00\xD5\xA4\xB8\x22\x45\x00\xD8\xA4\x74\xA4\x29\x64\x70\x65\xCB\x00\x9C\xA4\xFB\x74\xC9\x9C\xF7\x74\x4D\xA2\xBC\x2A\xD6\x00\xE5\xA4\x80\x19\x60\x00\xE7\xA4\xB9\x90\xE0\x69", - "\xCD\xA4\x16\x7A\x5D\x0D\xEC\x1A\xF7\x74\xCC\x99\xEE\x00\xF2\xA4\x27\x6C\xF4\xA4\xEF\xA1\x64\xA2\x37\x73\xDD\xA4\x82\x27\x8D\x00\xE0\xA4\x7A\xA4\x6C\xA2\x80\x7C\x8E\x23\x94\x86\x02\xA5\xA0\xA4\x8F\x97\x69\x64\x13\x00\x8E\x23\xED\x6E\xA9\x00\xD0\xA4\xEF\xA1\x7B\xA2\xF3\x05\x20\x00\x06\xA5\xEE\x7B\x08\xA5\x89\xA4\x04\x92\x58\x96\x15\xA5\x6F\x9E\x17\xA5\x90\xA4\xA6\x97\xE9\x7C\x0D\xA5\x4B\x95\xFB\xA4\xD9\xA4\xCA\x76\x9C\x6A\x45\x00\x21\xA5\x1B\x0A\xE4\x00\x23\xA5\xE1\xA4\xC1\x83\x9C\x6A\x52\x00\x28\xA5\xA8\x10\xF4\x00\x2B\xA5\x03\xA5\x9E\xA2\xED\x25\x5F\x00\x30\xA5\x80\x19\x04\x00\x0F\x0E\xF5\xA4\xC5\x97\x04\x9C\x38\xA5\xD8\x1A\x14\x00\x0F\x0E\xD1\xA4\xAC\xA2\x7A\x1C\x79\x00\x3F\xA5\x19\x18\x23\x00\x42\xA5\xEF\xA1\xFF\x98\xBC\x2A\x86\x00\x1B\xA5\x0D\x52\x8E\x23\xC2\x01\x32\x00\x0F\x0E\xC1\xA4\xBD\xA2\x31\x64\x94\x00\x4F\xA5\x24\x8B\x51\xA5\xA3\x38\x54\xA5\xEF\xA1\x2C\x91\x8E\x73\xA2\x00\x59\xA5\x06\x01\xAE\x00\x5B\xA5\x71\x3F\x5D\xA5\x24\xA5\xAB\x7E\xB9\x67\x62\xA5\x38\x9B\x65\xA5\x61\x0A\x67\xA5\x2C\xA5\x5E\x92", - "\x1C\x68\xBE\x00\x6B\xA5\x00\x00\xCA\x00\x6D\xA5\xB0\x47\x6F\xA5\x34\xA5\x22\x8E\xEF\x65\xCC\x00\x47\xA5\x7C\x6B\x77\xA5\x06\x01\x8D\x9D\xB9\x2C\x1B\x64\x16\x98\x91\x67\xDB\x00\x8E\x23\x49\x85\x84\xA5\x75\xA4\xEF\x65\xDC\x00\x88\xA5\x1B\x9E\x8A\xA5\xF8\x96\x91\x67\xDD\x00\x80\xA5\x19\x18\x87\x00\x3B\x9D\x90\xA5\x70\x8B\x4C\x66\xDF\x00\x94\xA5\xED\x1A\x88\x00\x97\xA5\xE8\xA1\x44\x6A\xE1\x00\x9C\xA5\x01\x79\x9F\xA5\x24\xA5\x40\x62\xE3\x00\xA3\xA5\x8D\x85\xA5\xA5\x81\x91\xF9\x7D\x8E\xA5\x0D\x94\x98\xA5\x4B\x98\xED\x25\xE6\x00\xA9\xA5\xA1\x22\x8B\x00\xAB\xA5\x8F\x91\x91\x67\xE8\x00\xB4\xA5\xB8\x22\x9C\x9D\xCF\x2A\x98\xA5\x5C\x98\xD1\x0D\xEA\x00\xBB\xA5\x00\xA5\xB7\xA5\xCD\x7A\x9A\x6B\xC3\xA5\x71\x26\x8E\x00\xC5\xA5\x42\x4B\x9C\x6A\xEE\x00\xC8\xA5\x62\x28\x8F\x00\xCB\xA5\x6F\x84\x9C\x6A\xF0\x00\xCF\xA5\x01\x62\x90\x00\xD2\xA5\xCA\xA4\xD1\x0D\xF2\x00\x8E\x23\x15\x69\x91\x00\x13\x9E\x12\x01\x98\xA5\x59\x97\xF5\x00\xD6\xA5\x55\x9F\xD2\xA5\x60\x97\x8E\x73\xF7\x00\xE5\xA5\x42\x6E\xD2\xA5\xBC\x95\x69\x64\xF9\x00\xAE\xA5", - "\x91\xA1\x00\x00\x98\xA5\xE9\xA4\xED\x25\xFA\x00\xF1\xA5\xE3\x71\x98\xA5\xCC\x99\xFB\x00\xDD\xA5\x64\x06\x95\x00\x1A\x9E\x11\x5B\xF0\xA4\xF0\x94\xFD\xA5\x1B\x0A\x98\x00\x00\xA6\x0A\x01\x98\xA5\xFD\xA4\xDA\x0B\x01\x00\xB1\x22\x9E\x68\x9B\x00\xD2\xA5\xB3\x94\xBC\x2A\x03\x00\x0D\xA6\x6E\x6D\xD2\xA5\xBB\x94\xD1\x0D\x05\x00\xB1\x22\x15\x69\xC1\x9D\xDF\x2A\x98\xA5\x12\xA5\x67\x04\x08\x00\x14\xA6\x1B\x0A\xCE\x9D\xBE\xA5\x9F\x97\x40\x62\x0A\x00\x22\xA6\xA8\x10\xD5\x9D\x25\xA6\x1F\xA5\x69\x64\x0C\x00\x1A\xA6\x64\x06\xDC\x9D\x12\x64\x98\xA5\x8A\xA2\x6D\xA1\x30\xA6\x1B\x0A\xA4\x00\x07\xA6\x0C\x5B\x84\x9C\xC7\x8B\x37\xA6\xF3\xA1\x3A\xA6\x06\x01\x98\xA5\xE1\x98\x86\x63\x15\x00\x3E\xA6\x80\x19\x10\x9E\x33\xA6\x3D\xA5\x1C\x68\x18\x00\x46\xA6\x9D\x96\xE0\xA5\x01\xA6\x32\x6E\x9C\x6A\x1B\x00\x4D\xA6\x19\x18\xAF\x00\x4F\xA6\x08\xA6\x6F\x8F\x40\x62\x1E\x00\x29\xA6\x3B\x31\x5C\xA6\x5A\x98\xD2\xA5\x41\x92\xBC\x2A\x22\x00\x5E\xA6\xAD\x34\x64\xA6\x34\x66\xD2\xA5\x5F\xA5\x26\x6E\x26\x00\x66\xA6\x28\x00\x66\xA6\xB3\x00\xD2\xA5\x69\xA5", - "\x31\x64\x2A\x00\x66\xA6\x2C\x00\x66\xA6\xB4\x00\xD2\xA5\x71\xA5\x89\x82\x66\xA6\x30\x00\x66\xA6\xB5\x00\xD2\xA5\x51\x9A\x69\x64\x32\x00\x54\xA6\xB0\x5A\x66\xA6\x21\x9E\xDF\x2A\x3D\x70\x6D\xA4\x67\x04\x37\x00\xB1\x22\x1A\x62\xB8\x00\x3B\x9D\x3D\x70\x5F\x91\x43\x8F\x8C\xA6\x64\x06\xB9\x00\x8F\xA6\x7B\xA4\x9A\x9A\x66\xA6\xE9\x9A\x57\xA6\x85\xA5\xA2\x73\x51\x97\x99\xA6\xB3\x19\xBC\x00\x9B\xA6\x40\x95\x8A\xA4\xA4\x91\x9F\xA6\xA1\x22\x2C\x9E\x87\xA6\x91\xA4\x86\x63\x3F\x00\xA6\xA6\xB8\x22\xC0\x00\xA2\xA6\x7B\x6E\x19\x97\x7C\x69\x41\x00\x93\xA6\x87\x78\x96\xA6\xFE\xA1\xF3\x6E\xAD\xA6\x82\x27\xC3\x00\xB0\xA6\x87\x6B\xA7\xA4\x31\x64\x44\x00\xBA\xA6\x71\x26\xC5\x00\xBD\xA6\x3D\x70\xC0\xA5\xB0\x9E\xC2\xA6\x62\x28\xC7\x00\xC5\xA6\x8E\x95\x86\x63\x48\x00\xC9\xA6\x01\x62\xC9\x00\xCC\xA6\xA3\x91\x7C\x69\x4A\x00\xD0\xA6\xBC\x02\x33\x9E\xA9\xA6\x8D\x90\x07\x65\xD7\xA6\x6B\x61\xD3\xA6\xA4\x95\xCC\x67\x4E\x00\x83\xA6\x2E\x22\xCF\x00\x40\xA6\xB1\xA6\x26\x9C\x86\x63\x51\x00\xDD\xA6\x56\x74\xDF\xA6\xFA\x6E\xB4\x71\xEB\xA6\x35\x5A", - "\xED\xA6\x42\xA4\xC3\x71\xB5\xA6\xC6\x6B\xB7\xA6\x37\x9C\x86\x63\x56\x00\xF5\xA6\x80\x19\xD7\x00\xF7\xA6\x3D\x9C\xCC\x67\x57\x00\xE3\xA6\xB3\x19\xD8\x00\x0F\x0E\x7A\x03\x3D\x70\xCC\x99\x5A\x00\x02\xA7\xA1\x22\xDC\x00\x05\xA7\x41\x99\xA0\x8D\x9C\x6A\x5D\x00\xF0\xA6\xF6\xA1\xF2\xA6\x93\x83\x9C\x6A\x5F\x00\x12\xA7\xA0\xA3\x14\xA7\xEE\x3C\x91\x67\x61\x00\x0A\xA7\xB8\x22\xE4\x00\xE6\xA6\xBE\xA6\xC3\x94\x9C\x6A\x64\x00\x18\xA7\xCA\x7A\x1A\xA7\xE6\x8A\x8E\x73\x66\x00\x26\xA7\x87\x6B\x1A\xA7\x35\xA6\x69\x64\x68\x00\x1E\xA7\x82\x27\xEB\x00\x0D\xA7\x16\x84\x6E\x9C\x67\x04\x6B\x00\x32\xA7\x71\x26\x51\x9E\x39\x67\x3D\x70\x43\xA6\xDC\x6F\x3A\xA7\x62\x28\xF3\x00\x35\xA7\xCB\xA1\x35\xA5\x7A\x1C\x71\x00\x41\xA7\x01\x62\xF7\x00\x44\xA7\x9C\xA6\xBF\x79\xBB\x78\x49\xA7\xBC\x02\xFB\x00\x21\xA7\x3D\x70\xCD\x97\xED\x25\x77\x00\x50\xA7\xAC\x78\x53\xA7\x59\xA6\x86\x63\x7A\x00\x66\xA6\x7C\x00\x66\xA6\x01\x00\x42\x9F\x0E\xA7\x98\x8F\x0D\x9B\x66\xA6\x80\x00\x66\xA6\x5E\x9E\xDA\xA6\xAB\x9C\x7C\x69\x82\x00\x66\xA6\x84\x00\x66\xA6\x05\x00", - "\x62\xA7\x36\xA7\x46\x96\x40\x62\x86\x00\x66\xA6\x88\x00\x66\xA6\x07\x00\x72\xA7\x45\xA7\xD8\xA2\x7C\x69\x8A\x00\x66\xA6\x8C\x00\x66\xA6\x09\x00\x7B\xA7\x4D\xA7\x9E\x40\xBB\xA4\x83\xA6\x91\x00\x66\xA6\x6B\x9E\x12\x64\x03\x5F\x07\x01\x22\x64\xBB\x72\x58\xA7\x1B\x0A\x46\x70\x89\xA6\x07\x6F\xFB\xA6\xD8\x1A\x0E\x00\x9D\x9E\x46\x70\x91\xA6\x26\x6E\x97\x00\x96\xA7\x19\x18\x0F\x00\x99\xA7\x97\xA6\xD1\x0D\x98\x00\x2C\xA7\x10\x00\x84\xA7\x8B\xA5\xDA\x9B\x69\x64\x9A\x00\x2C\xA7\x73\x9E\xDF\x2A\x46\x70\x5F\x99\xED\x25\x9C\x00\x2C\xA7\x14\x00\xA7\xA7\x47\x95\x7A\xA5\x14\x6C\x2C\xA7\x16\x00\xB5\xA7\x85\x6E\xB2\xA6\x40\x62\xA0\x00\x9E\xA7\x13\x7F\xA1\xA7\xB8\xA6\x1C\x68\xA1\x00\x2C\xA7\x19\x00\xBB\xA7\x46\x70\x27\x97\x7A\x1C\xA3\x00\x2C\xA7\x1B\x00\xC8\xA7\x03\x9C\x1C\x68\xA5\x00\x2C\xA7\x1D\x00\xCF\xA7\x60\x94\x7C\x69\xA7\x00\x2C\xA7\x1F\x00\xD5\xA7\x87\x90\x91\x67\xA9\x00\x2C\xA7\x21\x00\xDB\xA7\x3D\x6D\xCC\x67\xAB\x00\x2C\xA7\x8A\x9E\xAE\xA7\x20\x9C\x31\x64\xAD\x00\x91\xA7\xFC\x24\xA0\x9F\x8B\x86\x0F\x55\x23\x8C\x2C\xA7", - "\x28\x00\xE1\xA7\x06\x01\xE8\xA5\x26\x6E\xB2\x00\x2C\xA7\x91\x9E\xE7\xA7\x45\xA2\xB0\x8D\xC0\xA7\x2E\x22\x2C\x00\xC2\xA7\xF8\xA6\x31\x64\xB5\x00\xFD\xA7\xB3\x19\x2D\x00\x00\xA8\xFF\xA6\x4C\x66\xB6\x00\xEB\xA7\x98\x05\x88\x17\x7A\x03\x46\x70\xCC\x99\xB9\x00\x0B\xA8\xE4\x5C\x0D\xA8\x1E\x98\x4C\x7A\x70\x65\xBC\x00\x2C\xA7\x36\x00\xF3\xA7\x15\xA7\x97\x6E\x2C\xA7\xA2\x9E\xFA\xA7\xF6\x91\xCE\x81\x12\xA8\x2C\x67\xED\xA7\xD3\xA1\xAA\x47\x72\x70\x2C\xA7\x3D\x00\x1B\xA8\xDD\x73\x9C\x6A\xC5\x00\x2C\xA7\x3F\x00\x2B\xA8\x2F\xA7\x7A\x9B\x23\xA8\x48\x18\x14\xA8\x49\x99\x76\x9C\x31\x64\xCA\x00\x34\xA8\xAB\x9E\x39\x67\x46\x70\x3F\xA7\xEB\x7D\x34\xA8\x49\x00\x36\xA8\xEE\xA7\xFE\x90\xEE\xA0\x34\xA8\x4D\x00\x43\xA8\x26\xA8\x0B\x39\x91\x67\xD3\x00\x34\xA8\x51\x00\x25\xA8\xA8\xA7\x1C\x9A\x8C\x9B\x34\xA8\x54\x00\x50\xA8\xB6\xA7\x9B\x9C\xF2\x7D\x66\xA6\xDB\x00\x66\xA6\x57\x00\x2B\xA8\x61\xA6\xED\x25\xDD\x00\x66\xA6\xDF\x00\x66\xA6\x59\x00\x2B\xA8\x69\xA6\xBC\x2A\xE1\x00\x66\xA6\xE3\x00\x66\xA6\x5B\x00\x2B\xA8\x71\xA6\x69\x64\xE5\x00", - "\x66\xA6\xE7\x00\x66\xA6\x5D\x00\x2B\xA8\x79\xA6\xEF\x9C\x66\xA6\xEB\x00\x66\xA6\x5F\x00\x2B\xA8\x80\xA6\x1C\x68\xED\x00\x83\xA6\xF0\x00\x66\xA6\xC8\x9E\x12\x64\x08\x5F\x0A\x01\x8F\xA7\x4E\x6C\x34\xA8\x2E\x22\x99\x6A\x94\xA7\xE7\x5B\x04\xA8\xB7\x76\x9D\x9E\x99\x6A\x9B\xA7\xBC\x2A\xF6\x00\x8F\xA8\xB8\x22\x65\x00\x91\xA8\xA2\xA7\xDA\x0B\xF7\x00\x2C\xA7\x66\x00\xBB\xA7\x99\x6A\x84\xA4\x1E\x5F\x2C\xA7\xCF\x9E\xDF\x2A\x99\x6A\xB0\xA7\xE2\x8E\x2C\xA7\x6A\x00\x9F\xA8\xAA\xA6\x52\x9A\x2C\xA7\x6C\x00\xAB\xA8\x43\x98\x8F\x71\x96\xA8\x82\x27\x6E\x00\x99\xA8\xC3\xA7\x44\x6A\xCC\x70\xD4\x2A\xA8\x10\xD6\x9E\xA5\xA8\xBF\xA6\x69\x64\x02\x00\xC7\x3D\x9E\x68\x71\x00\xB0\xA8\x59\x84\x41\x71\xC1\xA8\x64\x06\x73\x00\xC4\xA8\x39\x93\x7C\x69\x06\x00\xC7\xA8\x26\x7B\xCA\xA8\x98\x70\x9C\x6A\x08\x00\xCE\xA8\x6D\x7C\xD0\xA8\x0B\x72\x84\x86\xD4\xA8\x80\x19\x79\x00\xD6\xA8\x10\x72\xCC\x67\x0C\x00\xC7\x3D\x15\x69\xFE\x9E\x12\x64\x99\x6A\x59\x97\x0F\x00\xD9\xA8\x36\x80\xDC\xA8\xF5\xA7\xBC\x2A\x11\x00\xE7\xA8\x19\x18\x1C\x9F\xBD\xA8\xFB\xA7", - "\x86\x63\x13\x00\xC7\x3D\x3F\x82\xB6\xA8\x01\xA8\x69\x64\x14\x00\xF4\xA8\x08\x83\xF6\xA8\x08\xA8\x7C\x69\x15\x00\xE0\xA8\x64\x06\x33\x9F\x39\x67\x99\x6A\xCC\x99\x18\x00\x00\xA9\xF3\x6A\x49\xA8\x37\x5B\xF2\x8B\xCC\x67\x1B\x00\xED\xA8\xED\x1A\x4F\x9F\xF0\xA8\xA7\x89\xCC\x67\x1D\x00\x0E\xA9\x2E\x22\x8E\x00\xDC\xA8\x17\xA6\xDA\x0B\x1F\x00\x07\xA9\xA8\x10\x90\x00\x56\xA8\x43\x9A\xE9\x99\xED\x8D\x15\xA9\xB3\x19\x56\x9F\x11\xA9\x19\xA5\xEF\x65\x24\x00\x23\xA9\xA1\x22\x95\x00\xDC\xA8\x32\xA8\xDB\x79\x1C\xA9\x80\x19\x97\x00\x09\xA9\x39\x5B\x37\xA7\xBC\x02\x29\x00\x30\xA9\xD8\x1A\x9B\x00\x33\xA9\x20\xA9\x7C\x9C\x44\x6A\x2C\x00\x38\xA9\x19\x8F\x3B\xA9\x99\x6A\x3F\xA8\x1C\x68\x2F\x00\x40\xA9\xED\x1A\xA3\x00\x42\xA9\x4A\xA6\x44\x6A\x32\x00\x47\xA9\x2E\x22\x63\x9F\xE3\xA8\x44\xA5\xD1\x0D\x35\x00\x4E\xA9\xB3\x19\xAA\x00\x1F\xA9\x99\x6A\x4C\xA5\xED\x25\x38\x00\x0E\xA9\x3A\x00\x0E\xA9\xAD\x00\xDC\xA8\x5F\xA8\x7A\x1C\x3C\x00\x0E\xA9\x3E\x00\x0E\xA9\x6D\x9F\x26\xA9\xC7\xA2\xB1\x75\x0E\xA9\x42\x00\x0E\xA9\xB1\x00\xDC\xA8\x6F\xA8", - "\x1C\x68\x44\x00\x0E\xA9\x46\x00\x0E\xA9\xB3\x00\xDC\xA8\x77\xA8\x26\x6E\x48\x00\x0E\xA9\x4A\x00\x0E\xA9\x6F\x9F\x69\xA9\x86\xA7\xCC\x67\x4C\x00\x47\xA9\x4F\x00\x0E\xA9\xB7\x00\x1F\xA9\x0D\x5F\x8E\xA7\x70\x65\x51\x00\x55\xA9\x54\x91\xA6\x7B\x99\x6A\xB9\xA1\xD8\x1A\xC6\x70\xC9\xA0\xE4\x29\xFA\xA8\x1B\x0A\xBA\x00\x9D\x9E\xC6\x70\xCF\xA0\x67\x9D\x96\xA9\x9D\x80\x99\xA9\xD5\xA0\x40\x62\x56\x00\x9D\xA9\xFC\x77\x9F\xA9\xDB\xA0\x99\x8C\xA3\xA9\xC4\x75\xA5\xA9\xE1\xA0\x98\x7D\xA8\xA9\xF8\x6C\xAA\xA9\xE7\xA0\x8E\x73\x59\x00\xAD\xA9\xED\x1A\xBF\x00\xAF\xA9\xED\xA0\x40\x62\x5A\x00\xB3\xA9\x2E\x22\xC0\x00\xB6\xA9\xF3\xA0\x8E\x73\x5B\x00\xBA\xA9\xB3\x19\xC1\x00\xBD\xA9\xF9\xA0\x44\x6A\x5C\x00\xC1\xA9\x5C\x9D\xC4\xA9\xFE\xA0\x2C\x0F\xC8\xA9\xB8\x22\x7A\x9F\xCF\x2A\xC6\x70\x03\xA1\xA6\x43\xCD\xA9\x82\x27\x7E\x9F\xD0\xA9\x7A\x88\x54\x92\xD4\xA9\xC3\xA6\xC4\xA9\x0E\xA1\x2F\x44\xDA\xA9\xD1\x9E\xC4\xA9\x14\xA1\x36\x04\xDF\xA9\x01\x62\xC7\x00\xC4\xA9\x19\xA1\xD1\x0D\x62\x00\xE4\xA9\xBC\x02\xC8\x00\xC4\xA9\x1F\xA1\xBC\x02\x63\x00", - "\xB3\xA9\x64\x00\x0E\xA9\xC9\x00\x9D\x9E\x11\x5F\xE7\xA6\x20\x72\xEB\xA9\x91\x59\xF6\xA9\x15\xA8\xE2\x95\xFA\xA9\x83\x9F\xCF\x2A\xF7\xA9\x24\x94\x5F\x79\x2A\xA9\xB8\x22\xCC\x00\xBB\xA7\x02\xAA\xA1\xA8\xDE\x47\x05\xAA\x82\x27\xCE\x00\x08\xAA\xA0\xA5\x8E\x73\x6C\x00\x0C\xAA\x71\x26\xD0\x00\x0F\xAA\xA6\xA5\x86\x63\x6E\x00\x13\xAA\x62\x28\xD2\x00\x16\xAA\xAC\xA5\x7C\x69\x70\x00\xFF\xA9\x35\x5A\xFC\xA9\xB7\xA8\x8E\x73\x71\x00\x1A\xAA\x01\x62\xD5\x00\x1D\xAA\xB8\xA5\xC6\x86\x27\xAA\xBC\x02\xD7\x00\x2A\xAA\x96\x91\xEF\x65\x75\x00\x2D\xAA\xDF\x5A\x30\xAA\x7F\x90\x9C\x6A\x77\x00\x34\xAA\xE5\x5A\x36\xAA\x60\x4B\x70\x65\x79\x00\x3A\xAA\x0A\x01\xDD\x00\x3C\xAA\xC3\xA4\x7A\x1C\x7B\x00\x40\xAA\x1A\x86\x3C\xAA\xDA\xA5\xB9\x96\x8D\xA9\xB8\x22\xE1\x00\x1F\xA9\x02\xAA\x59\x97\x80\x00\x47\xAA\x06\x01\xE4\x00\x3C\xAA\xEA\xA8\xED\x25\x82\x00\x53\xAA\xA7\x6E\x3C\xAA\xEE\xA5\x1C\x68\x84\x00\x21\xAA\x8E\xA7\x23\xAA\xF7\xA8\x1C\x68\x85\x00\x60\xAA\x16\x5B\x62\xAA\xFD\xA8\x75\xA7\x4C\xAA\x82\x27\xEA\x00\x3B\xA9\x02\xAA\xCC\x99\x89\x00", - "\x6B\xAA\x71\x26\x9F\x9F\x39\x67\x02\xAA\x0A\xA6\x4E\x9F\x5A\xAA\x00\x00\xF2\x00\x3C\xAA\x11\xA6\xED\x25\x8E\x00\x79\xAA\xF4\x00\x3C\xAA\x19\xA9\xC2\x09\x90\x00\x72\xAA\x16\x6D\x4F\xAA\x21\xA9\x1C\x68\x93\x00\x79\xAA\xF9\x00\x3C\xAA\x29\xA7\x26\x6E\x95\x00\x79\xAA\xFB\x00\x3C\xAA\x2E\xA9\x8E\x73\x97\x00\x86\xAA\x01\x62\xFD\x00\x6E\xAA\x35\xA9\x69\x6A\x98\xAA\x93\x5E\x55\xA1\x00\x00\x02\xAA\x44\xA9\x80\x8B\x9E\xAA\x5F\x04\xA0\xAA\xA2\xAA\xBB\x80\xA0\x00\xA5\xAA\xB7\x2B\xA7\xAA\x4B\xA9\x8E\x73\xA3\x00\xAB\xAA\xF0\x04\x77\xA0\x5F\x5B\x52\xA9\xDA\x0B\xA6\x00\xB1\xAA\xA3\x06\xB3\xAA\x61\x5B\x5B\xA7\x31\x64\xA9\x00\x0E\xA9\xAB\x00\x0E\xA9\x13\x00\x24\xA1\xBB\xAA\xA3\x9C\xF9\x75\x67\xA9\x0E\xA9\x15\x00\xC3\xAA\x63\x5B\x35\x9A\x91\x67\xB1\x00\x76\xA9\x0E\xA9\x17\x00\xCA\xAA\x5D\x5B\xB4\x9C\xE6\x78\x86\xA9\x0E\xA9\x19\x00\xD2\xAA\x06\x01\x02\xAA\x79\xA9\xBC\x2A\xB9\x00\x0E\xA9\xBB\x00\x0E\xA9\xCD\x9F\xDF\x2A\xA2\xAA\x70\x65\xBD\x00\x47\xA9\xC0\x00\x0E\xA9\x1D\x00\xBA\xAA\x1A\x81\x12\x01\x88\xA8\xAD\x76\xB8\xAA\xD8\x1A", - "\xFF\x74\x8D\xA8\xBC\x58\x66\xAA\x56\x31\xE6\x9F\xFF\x74\x93\xA8\xED\x25\xC6\x00\xF5\xAA\xCB\x14\xF7\xAA\x9A\xA8\xC2\x09\xC7\x00\x79\xAA\xD5\x9F\xDF\x2A\xFF\x74\x0A\xAA\xC9\x00\x79\xAA\x24\x00\xD9\xAA\xEF\x9B\x35\x98\x7C\x69\xCB\x00\x79\xAA\x26\x00\x0A\xAB\x18\x93\x17\xAA\x31\x64\xCD\x00\x79\xAA\x28\x00\x11\xAB\xFF\x74\x99\xA4\xED\x25\xCF\x00\xFC\xAA\x2A\x00\xFE\xAA\x24\xAA\x26\x6E\xD0\x00\x79\xAA\x2B\x00\x18\xAB\xBE\xA8\xCE\x69\x79\xAA\x2D\x00\x25\xAB\xAE\xA4\x7C\x69\xD4\x00\x79\xAA\x2F\x00\x2A\xAB\xB4\xA4\x87\x95\x79\xAA\x31\x00\x30\xAB\xBA\xA4\xCC\x67\xD8\x00\x79\xAA\x33\x00\x35\xAB\x45\x5F\x82\x70\x79\xAA\x35\x00\x3B\xAB\xFA\x6F\x27\x71\xF0\xAA\x9B\x9E\xEB\xAA\x6F\x99\xC6\x8B\x69\x64\xDF\x00\x79\xAA\x3A\x00\x40\xAB\x00\x00\x57\xAA\x7A\x1C\xE1\x00\x79\xAA\x3C\x00\x4C\xAB\x5D\xAA\x44\x6A\xE3\x00\xFC\xAA\xF2\x9F\xCF\x2A\xFF\x74\xF5\xA5\x7A\x1C\xE4\x00\xFC\xAA\x3F\x00\x1F\xAB\xC4\x99\x70\xA8\x43\xAB\x2E\x71\xA0\xAA\xFF\x74\xCC\x99\xE8\x00\x63\xAB\xF4\x9F\x39\x67\xFF\x74\x77\xAA\xF3\x05\xEB\x00\x79\xAA\x48\x00", - "\x4C\xAB\x7D\xAA\x7A\x1C\xED\x00\x79\xAA\x4A\x00\x4C\xAB\x83\xAA\xF3\x05\xEF\x00\x63\xAB\x4C\x00\x45\xAB\xF8\xA1\x23\xA7\x91\x67\xF2\x00\x79\xAA\x4F\x00\x4C\xAB\x8F\xAA\x81\x75\x79\xAA\x51\x00\x4C\xAB\x95\xAA\x26\x6E\xF6\x00\x63\xAB\x53\x00\x65\xAB\x9C\xAA\x82\x5C\x63\xAB\x30\xA0\x6B\xAB\x3C\xA6\xEB\x87\x63\xAB\x47\xA0\x95\xAB\x3D\xA9\x39\x85\x63\xAB\x5F\x00\x90\xAB\xA5\xA2\x44\x6A\x02\x00\x51\x3E\x15\x69\x6E\xA0\x12\x64\xFF\x74\x55\xA7\x7A\x1C\x05\x00\xA3\xAB\x39\x7B\x7E\xAB\x0B\xAB\xD3\x6D\x70\x65\x08\x00\x51\x3E\xC2\x01\x0A\x00\xB2\xAB\x5D\x47\x4C\xAB\x62\xA9\xD1\x0D\x0C\x00\xB5\xAB\x02\x05\xBB\xAB\x11\x77\x4C\xAB\x67\xA8\xED\x25\x10\x00\xBD\xAB\xF7\x21\xC3\xAB\xA1\x48\x4C\xAB\x71\xA9\x44\x6A\x14\x00\xC5\xAB\xEB\x2C\xCB\xAB\x4C\x49\x4C\xAB\xDC\xAA\xED\x25\x18\x00\xCD\xAB\x1A\x00\xCD\xAB\x71\x00\x4C\xAB\x7E\xA8\x44\x6A\x1C\x00\xAB\xAB\x08\x31\xCD\xAB\x73\x00\xAD\xAB\x45\x6A\xED\xAA\x2F\x8B\xDB\xAB\xF2\xA5\x2C\x64\x00\x00\xEE\xAA\x4C\x66\x24\x00\xCD\xAB\xCA\x7D\x33\x64\x7C\xA7\xA1\x75\xEA\xAB\xB3\x19\x89\xA0", - "\xCF\x2A\xEC\xAB\x4A\xA8\xF8\x74\xEF\xAB\xA1\x22\x77\x00\xE6\x9F\xF3\xAB\xD3\x71\xEF\x65\x2A\x00\xE3\xAB\x69\x73\x11\xAB\xFA\xAB\xE2\x7E\x7C\x69\x2D\x00\xFE\xAB\x16\x8C\x00\xAC\x10\xAA\x26\x6E\x30\x00\x05\xAC\x19\x18\x8B\xA0\xDF\x2A\x01\xAC\x1E\xA5\x91\x67\x33\x00\x0B\xAC\x45\x80\x07\xAC\xB1\xA8\x7C\x69\x36\x00\xF6\xAB\x6F\x80\xF9\xAB\xA1\xA4\x26\x6E\x38\x00\x13\xAC\x2E\x22\x81\x00\x15\xAC\x7D\x99\xEF\x65\x3B\x00\x1F\xAC\xB3\x19\x90\xA0\x0E\xAC\xD0\xA7\x44\x6A\x3E\x00\x26\xAC\x9D\x82\x22\xAC\xCB\xA8\x40\x62\x41\x00\x2D\xAC\xB8\x22\x87\x00\x2F\xAC\xD1\xA8\x91\x67\x44\x00\x33\xAC\x82\x27\x89\x00\x36\xAC\xD7\xA8\x91\x67\x47\x00\x3A\xAC\x71\x26\x9A\xA0\x29\xAC\x50\x97\xFA\x64\x51\x3E\x55\xA0\x8D\x00\xDF\xAB\x0F\xAC\x59\x97\x4E\x00\x41\xAC\x79\x98\x3D\xAC\x4D\xAB\x8B\xA9\x4E\xAC\x01\x62\x92\x00\x50\xAC\x54\xAB\x8E\x73\x54\x00\x19\xAC\x82\x27\x94\x00\x1B\xAC\xBE\x99\x31\x64\x56\x00\x5A\xAC\x71\x26\x95\x00\x5D\xAC\x61\xAB\x32\x6B\x47\xAC\x00\x89\xA0\xAA\x0F\xAC\xCC\x99\x5C\x00\x67\xAC\x38\x6C\x69\xAC\xD3\x99\xF3\x8B", - "\x53\xAC\xAE\x8E\x50\xAC\x73\xAB\xD1\x0D\x63\x00\x72\xAC\xD9\x79\x50\xAC\x79\xAB\x67\x04\x66\x00\x6D\xAC\xA8\x10\xA2\x00\x4A\xAC\x89\xAA\x44\x6A\x6A\x00\x78\xAC\x44\x56\x50\xAC\x86\xAB\xED\x25\x6D\x00\x85\xAC\x95\x63\x50\xAC\x8B\xAB\xDB\x5E\x7E\xAC\x80\x19\xA9\x00\x6F\xAC\x2D\xA6\x1C\x68\x74\x00\x90\xAC\x9D\x96\x93\xAC\x46\xA7\xEC\x9E\x97\xAC\x19\x18\xB1\x00\x99\xAC\x45\xA8\x40\x62\x7C\x00\x9C\xAC\xA7\x9A\x9F\xAC\x4E\xA7\x07\xA2\xA3\xAC\x70\x91\x81\xAC\x51\xA6\x93\xA0\xA8\xAC\xA0\xA6\xAA\xAC\xAF\xAB\x70\x7B\x13\xAC\x8B\x00\xCD\xAB\xBF\x00\x50\xAC\xB8\xAB\x0E\x66\x13\xAC\x90\x00\xCD\xAB\xC1\x00\x50\xAC\xC0\xAB\x7A\x1C\x92\x00\x13\xAC\x95\x00\xCD\xAB\xC3\x00\x50\xAC\xC8\xAB\x96\xAA\x13\xAC\x9A\x00\xCD\xAB\xC5\x00\x50\xAC\xD0\xAB\xB9\x9D\x13\xAC\x9F\x00\xCD\xAB\xC7\x00\x50\xAC\xD8\xAB\x8E\x73\xA1\x00\xA3\xAC\xA5\x00\xCD\xAB\xC6\xA0\x12\x64\x90\x5C\x85\xA7\xD7\xA7\x51\x3E\x1A\x62\xD7\xA0\xCF\x2A\xDC\xAC\x51\xA8\xF1\x84\xDF\xAC\x64\x06\xDD\xA0\xE2\xAC\xFF\xAA\xF3\x05\xA9\x00\x61\xAC\x62\x28\xE3\xA0\xDF\x2A\xE3\xAC", - "\x02\xAC\x61\x70\xED\xAC\x01\x62\xEF\xA0\xF0\xAC\x08\xAC\xBC\x2A\xAD\x00\xF4\xAC\xBC\x02\xD2\x00\x11\xAB\xF1\xAC\x10\xAC\xC0\x89\xFB\xAC\x31\x5A\xFE\xAC\xBD\xA7\x86\x63\xB1\x00\xE6\xAC\x1B\x0A\xD6\x00\xE6\x9F\xFF\xAC\xB1\xA5\x7A\x1C\xB2\x00\x02\xAD\x15\xA1\xF7\xAC\x6C\x8A\xCC\x67\xB4\x00\x10\xAD\xCE\x7A\x04\xAD\x2B\xAB\x40\x62\xB6\x00\x16\xAD\xE9\x67\x18\xAD\x31\xAB\x31\x64\xB8\x00\x1C\xAD\x6E\x71\x1E\xAD\x36\xAB\xB6\x73\x22\xAD\x39\x9A\x24\xAD\x3C\xAB\xFD\x8F\x27\xAD\x00\x00\x32\xA1\x12\xAD\xE0\xA6\x4C\x66\xBE\x00\x8B\xAC\x07\x01\xE3\x00\xDF\xAB\xFF\xAC\x59\x97\xC1\x00\x2C\xAD\xE6\x00\x29\xAD\xDA\xA4\x91\x67\xC3\x00\x2C\xAD\xE8\x00\x3C\xAD\x00\x00\x57\xAC\x26\x6E\xC5\x00\x08\xAD\x3B\x79\x0B\xAD\x98\x98\x44\x6A\xC6\x00\x47\xAD\x80\x19\xEB\x00\x49\xAD\x9E\x98\x40\x62\xC7\x00\x33\xAD\x06\x01\x43\xA1\x39\x67\xFF\xAC\xCC\x99\xCA\x00\x54\xAD\xC5\x70\xA0\xAA\xFF\xAC\x6D\xAB\x67\x04\xCD\x00\x2C\xAD\xF4\x00\x42\xAD\x75\xAC\xDA\x0B\xCF\x00\x2C\xAD\x4E\xA1\x2F\xAD\x58\x9C\x31\x64\xD1\x00\x5B\xAD\x7E\x5C\x36\xAD\x82\xAC", - "\x8E\x73\xD4\x00\x2C\xAD\x54\xA1\x6A\xAD\xF0\x99\x9C\x6A\xD6\x00\x2C\xAD\xFD\x00\x42\xAD\x8E\xAC\xB1\x8E\x6E\xAD\xFF\x00\x5D\xAD\x91\xAB\xFA\x72\x6E\xAD\x03\x00\x86\xA1\x05\x01\xFF\xAC\xA3\xAA\x8E\x73\xDE\x00\x6E\xAD\x07\x00\x86\xAD\x7E\x5C\x96\xAB\x1C\x68\xE1\x00\x6E\xAD\x0B\x00\x8E\xAD\xFF\xAC\xAB\x7F\xF3\x05\xE4\x00\x6E\xAD\x6E\xA1\xDB\xAC\xB5\xAA\xC2\x09\xE7\x00\x6E\xAD\x12\x00\x5C\x3A\xCC\x01\xFF\xAC\x5A\xA9\x7A\x1C\xEA\x00\xCD\xAB\xEC\x00\xCD\xAB\x15\x00\x5C\x3A\xC2\x01\xFF\xAC\xB7\xAC\xC2\x09\xEE\x00\xCD\xAB\xF0\x00\xCD\xAB\x17\x00\xAC\xAD\x93\x5C\x6B\xA7\x40\x62\xF2\x00\xCD\xAB\xF4\x00\xCD\xAB\x19\x00\xB6\xAD\x96\x5C\x74\xA7\x86\x63\xF6\x00\xCD\xAB\xF8\x00\xCD\xAB\x1B\x00\xBF\xAD\x70\x72\xBD\x9C\x40\x62\xFA\x00\xCD\xAB\xFC\x00\xCD\xAB\x80\xA1\x76\xAD\x81\xA9\xC0\x79\x13\xAC\x01\x00\xC1\x3E\xE0\x1E\xA2\xAD\x84\x5C\x74\x5C\xEF\x65\x03\x00\xC1\x3E\x78\xA0\xD9\xAD\x86\x5C\x70\x65\x06\x00\xC1\x3E\x14\x63\xC1\x3E\x1A\x62\x89\x5C\xC9\xAD\xD8\x9A\xAE\x9D\xB8\x22\xA0\x6A\x6C\x5C\x70\x65\x0D\x00\xE5\xAD\x1B\x9E", - "\xEC\xAD\x05\x01\xE7\xAD\xEF\x65\x0E\x00\xC1\x3E\x7A\x03\x12\x00\xF0\xAD\x91\x7F\x63\xA7\x40\x62\x13\x00\xDD\xAD\xBB\x93\xC8\xAD\x07\x01\x36\x64\xF4\xAB\x1A\x7E\xFF\xAD\x1B\x0A\x24\x00\x01\xAE\x06\x01\x03\xAE\xFB\xAB\xCC\x67\x19\x00\xF7\xAD\x64\x06\x26\x00\xD8\xAD\x94\x5C\xE0\xA1\x8E\x73\x1D\x00\x0F\xAE\x96\x76\x12\xAE\x91\x5C\xF8\xAC\xED\x25\x21\x00\x17\xAE\xA8\x10\x2C\x00\x19\xAE\x02\xAE\xAC\xA8\x69\x64\x25\x00\x1E\xAE\x80\x19\x2F\x00\x21\xAE\x0A\xAE\x05\xAD\x31\x64\x29\x00\x06\xAE\xA8\x10\x32\x00\x09\xAE\x05\x01\x0B\xAE\x4A\x98\x70\x65\x2C\x00\x26\xAE\xE1\x8A\x29\xAE\x32\xAE\x26\xAB\x44\x6A\x30\x00\x37\xAE\x5B\x6F\x39\xAE\x35\x64\x2A\xAC\x8E\x73\x34\x00\x3E\xAE\xED\x1A\x3A\x00\x40\xAE\x33\xAE\x18\xA2\x54\xA3\x45\xAE\x2E\x22\x3D\x00\x48\xAE\x96\x95\x69\x64\x3C\x00\x4C\xAE\x68\x8A\x4F\xAE\xDB\xA6\x88\x85\x53\xAE\xEF\x86\x55\xAE\x30\xAD\x9F\x98\xC1\x3E\x74\x88\x46\x00\x8E\xAD\x49\xAE\x59\x97\x49\x00\x58\xAE\xB8\x22\x4A\x00\x5A\xAE\xEE\xA6\x98\x71\x64\xAE\x82\x27\x4D\x00\x67\xAE\xF3\xA6\x05\x77\x2E\xAE\x80\x19", - "\x50\x00\x31\xAE\x41\xAE\x5E\xAC\xA7\x85\x70\xAE\xD8\x1A\x52\x00\x73\xAE\x49\xAE\xCC\x99\x57\x00\x5D\xAE\x63\x89\x5C\x3A\x5E\x03\x7B\xAE\x85\x83\x7E\xAE\x1B\x0A\x59\x00\x80\xAE\x56\x8C\x70\xAC\xCC\x67\x61\x00\x6A\xAE\xFF\x66\x6D\xAE\x1C\xA8\xEF\x65\x65\x00\x8C\xAE\x62\x28\x61\x00\x8E\xAE\x1B\xA7\xEF\x65\x69\x00\x84\xAE\xA8\x10\x64\x00\x60\xAE\x71\xAD\xED\x88\x92\xAE\x01\x62\x68\x00\x95\xAE\x88\xAC\x7A\x1C\x72\x00\x9F\xAE\xBC\x02\x6B\x00\x95\xAE\x7D\xAD\x7A\x1C\x76\x00\x99\xAE\x0B\x75\x87\xAE\x13\xAE\x94\xAC\x44\x6A\x7B\x00\xAD\xAE\x1F\x8D\xAF\xAE\x1A\xAE\x9B\xAB\x26\x6E\x80\x00\xB4\xAE\x19\x18\x78\x00\xB6\xAE\x22\xAE\xB8\xAE\x38\x9F\xBB\xAE\xED\x1A\x7D\x00\xBE\xAE\x2A\xAE\xA0\xAB\x8E\x73\x8A\x00\xC2\xAE\x2E\x22\x82\x00\x9C\xAE\xAB\xAC\x45\x84\xCA\xAE\xB3\x19\x86\x00\xCD\xAE\xB0\xAC\xDA\xA3\x45\xAE\x98\x00\xD6\xAD\x9B\x10\x95\xAE\xAF\xAD\xF3\x05\x9A\x00\x45\xAE\x9E\x00\xD8\xAE\x9A\x51\x95\xAE\xBE\xAC\xD1\x0D\xA0\x00\x45\xAE\xA4\x00\xE0\xAE\x0A\x01\x90\x00\x95\xAE\xC6\xAC\x26\x6E\xA6\x00\x45\xAE\xAA\x00\xE8\xAE", - "\x07\x01\x93\x00\x95\xAE\xCD\xAC\xD1\x0D\xAC\x00\x45\xAE\xB0\x00\xF1\xAE\x20\x76\x95\xAE\xD4\xAC\xF6\xA7\xC2\xAE\xB7\x00\xFA\xAE\x3B\x53\x8E\xAD\xD7\x5C\x73\xA7\x91\x67\xB9\x00\x01\xAF\x68\x8E\x73\xAE\x04\xAF\x44\xA8\xCC\x67\xBB\x00\x08\xAF\x28\x8F\x0A\xAF\xEA\xAC\x67\x04\xBD\x00\x77\xAE\x19\x18\xA1\x00\x40\xAE\x0B\xAF\x9D\xA6\x86\x63\xC0\x00\x15\xAF\x55\x91\x18\xAF\x1B\xAE\x7A\x1C\xC3\x00\x1D\xAF\x4F\xA9\x1F\xAF\x13\xAB\x69\x64\xC6\x00\x23\xAF\x56\xA9\x25\xAF\x1E\xAA\x40\x62\xC9\x00\x0F\xAF\xBE\x96\x11\xAF\x20\xAB\xBC\x2A\xCB\x00\x29\xAF\xA1\x22\xAF\x00\x2B\xAF\x2B\xAA\xCC\x67\xCE\x00\x35\xAF\xB8\x22\xB2\x00\x38\xAF\x31\xAA\xCC\x67\xD1\x00\x3C\xAF\x69\x9A\x3F\xAF\x37\xAA\x17\x73\x43\xAF\x4A\x6C\x45\xAF\x3D\xAA\xA8\x79\x48\xAF\x62\x28\xBB\x00\x4A\xAF\x44\xAA\xD1\x0D\xDA\x00\x4D\xAF\x01\x62\xBE\x00\x4A\xAF\x4A\xAA\xC2\x09\xDD\x00\xA6\xAE\x2B\x58\x03\xAF\x47\xAB\x91\xAD\x54\xAF\xBC\x02\xC5\x00\x4A\xAF\x4E\xAB\xD1\x0D\xE4\x00\x60\xAF\xE6\x58\x4A\xAF\x44\xAD\x3C\xA1\x2F\xAF\xA1\x22\xCB\x00\x31\xAF\x63\xAA\x44\x6A", - "\xE9\x00\x6C\xAF\xB8\x22\xCD\x00\x6F\xAF\x69\xAA\x86\x63\xEB\x00\x5B\xAF\x0F\x01\xCF\x00\xC5\xAE\x30\x81\x02\xA6\x86\x63\xEF\x00\x7A\xAF\x35\x5A\x7D\xAF\x00\x00\x19\xAF\x23\x6F\x9C\x6A\xF3\x00\x67\xAF\xF2\x85\x4A\xAF\x65\xAD\xC2\x09\xF6\x00\x8A\xAF\x0A\x01\xDC\x00\x4A\xAF\x7B\xAC\xBC\x02\xF9\x00\x82\xAF\x1A\x86\x5D\xAF\x80\xAB\xEF\x65\xFD\x00\x90\xAF\x34\xAD\x4A\xAF\xA3\xAE\x7A\x1C\x42\x3F\x15\x69\xE6\x00\x4A\xAF\xAA\xAE\xCE\x5D\x42\x3F\x55\xA0\xE9\x00\x84\xAF\x86\xAF\x92\x41\xBB\x80\x07\x00\xA8\xAF\xFA\x90\xAB\xAF\x90\xAD\x44\x6A\x0B\x00\xB0\xAF\xAA\x98\xB2\xAF\xC0\xAE\xED\x25\x0F\x00\xB6\xAF\xA8\x10\xF8\x00\xB8\xAF\x09\x8B\xF2\xA8\xBC\xAF\x80\x19\xFD\x00\x99\xAF\xAC\x5D\xC0\x7E\xC2\xAF\xD8\x1A\x01\x00\x01\xA3\x0A\x01\xAC\xAF\x23\x9A\x0C\xA9\xA2\xAF\x21\x30\x42\x3F\xAE\x07\x7B\x09\xCC\x01\xCD\xAF\xDB\xAE\x67\x04\x20\x00\xD0\xAF\xD6\x33\xD2\xAF\x4E\x2B\xD4\xAF\xAC\x78\xCC\xAA\xEF\x65\x25\x00\xDA\xAF\xC3\x64\xDC\xAF\x34\x2B\xDE\xAF\x0F\x01\xCD\xAF\xEC\xAE\xBC\x2A\x2A\x00\xE3\xAF\xE3\x0F\xE5\xAF\x1D\x05\xE7\xAF", - "\xCC\xAF\xCA\xAD\x86\x63\x2F\x00\xED\xAF\xE4\x5C\xEF\xAF\x88\x2B\xF1\xAF\x07\x01\xCD\xAF\xFD\xAE\xBC\x2A\x34\x00\xC8\xAF\x61\x57\xF8\xAF\x26\x0B\xCB\xAF\x07\x5D\x3B\x64\xF1\x77\xF6\xAF\x8C\x7A\x0B\x01\x2E\x01\x61\x03\xAB\x64\x42\x3F\xF7\x18\x43\x00\x42\x3F\x20\x62\x5F\x04\x0C\xB0\x86\x63\x44\x00\x0E\xB0\x9E\x3D\x11\xB0\xFD\x07\x11\x2B\x14\xB0\x55\x7D\x17\xB0\xB7\x40\x19\xB0\x6D\x62\x61\x03\xF3\xAA\x36\x41\x02\xB0\x19\x18\x18\x00\xE6\xA2\x18\x63\xF9\xAA\x7A\x1C\x54\x00\x25\xB0\xED\x1A\x1A\x00\x28\xB0\x2D\x64\x50\x99\x21\x5E\x08\xB0\xED\x1A\x1C\x00\xFA\xAF\x06\x62\x0A\xAA\x59\x00\x34\xB0\x06\x68\x37\xB0\x18\x63\xA7\xA8\x6F\x9D\x3B\xB0\xB3\x19\x22\x00\x3D\xB0\x2D\x64\x11\x97\xBC\x2A\x5F\x00\x41\xB0\xAE\x64\x44\xB0\x80\x63\x1A\xAB\x7A\x1C\x62\x00\x2D\xB0\x2E\x22\x28\x00\x30\xB0\x80\x63\x0D\xAD\xD1\x0D\x64\x00\x49\xB0\xB8\x22\x2A\x00\x4B\xB0\x61\x03\xCA\xA7\xD1\x0D\x67\x00\x58\xB0\x82\x27\x2D\x00\x5B\xB0\x19\xAD\xA8\xA4\x60\xB0\x71\x26\x30\x00\x63\xB0\x1F\xAD\x27\x69\x66\xB0\x62\x28\x33\x00\x69\xB0\x25\xAD\x1F\xAA", - "\x6C\xB0\x01\x62\x7D\xA2\x12\x64\x80\x63\x51\xAF\xDA\x0B\x73\x00\x72\xB0\xBC\x02\x39\x00\x6F\xB0\x8B\x7B\x69\x87\x00\xB0\xED\x1A\x3C\x00\x04\xB0\x06\x62\x59\x97\x7A\x00\x7A\xB0\xA3\x38\x7D\xB0\x3D\xAD\x1C\x6F\x87\xB0\x84\x22\x89\xB0\x43\xAD\x70\x65\x80\x00\x50\xB0\xB3\x19\x46\x00\x53\xB0\x61\x03\x5B\xAB\xD1\x0D\x82\x00\x92\xB0\xA1\x22\x48\x00\x95\xB0\x51\xAD\x86\x63\x84\x00\x80\xB0\x2E\x22\x4A\x00\x7B\x09\x5E\x03\x80\x63\xCC\x99\x88\x00\xA1\xB0\xB3\x19\x4F\x00\xA4\xB0\xF1\x61\xC9\x90\xA7\x72\x8C\xB0\x77\x16\x8E\xB0\x8D\xAF\xF3\x05\x8F\x00\xB0\xB0\x43\x03\x8E\xB0\x94\xAF\x62\x52\xA9\xB0\xA1\x22\x5A\x00\x83\xB0\x18\x63\x1F\xA6\x07\x6F\xB6\xB0\xAD\x43\x8E\xB0\xA0\xAF\xD8\x96\xC2\xB0\xC5\x05\x8E\xB0\xA6\xAF\xDA\x0B\x9C\x00\xBB\xB0\xB8\x22\x64\x00\xAC\xB0\xCD\x2A\xCA\xB0\xC2\x09\xA0\x00\xCD\xB0\x82\x27\x69\x00\xD0\xB0\xCB\x2A\x89\xAD\x26\x6E\xA4\x00\xD5\xB0\x71\x26\x6E\x00\xD8\xB0\x20\x63\xDA\xB0\xBC\x2A\xA8\x00\xDD\xB0\x62\x28\x73\x00\xE0\xB0\x06\x62\x97\xAD\x67\x04\xAC\x00\xE5\xB0\x01\x62\x78\x00\xBE\xB0\x2D\x64", - "\xA8\xAB\xD1\x0D\xB0\x00\xED\xB0\xBC\x02\x7C\x00\xF0\xB0\x80\x63\xA5\xAD\xD1\x0D\xB4\x00\x34\xB0\xB7\x00\x2D\xB0\x80\x00\x8E\xB0\xD7\xAF\xBC\x02\xB9\x00\x34\xB0\xBC\x00\x2D\xB0\x83\x00\x8E\xB0\xE3\xAE\xDA\x0B\xBE\x00\x34\xB0\xC1\x00\x2D\xB0\x86\x00\x8E\xB0\xEA\xAF\xED\x25\xC3\x00\x34\xB0\xC6\x00\x2D\xB0\x89\x00\x8E\xB0\xF5\xAE\xDA\x0B\xC8\x00\x34\xB0\xCB\x00\x2D\xB0\x8C\x00\x8E\xB0\xFD\xAF\xED\x25\xCD\x00\x80\xB0\xD1\x00\x2D\xB0\xAE\xA2\x39\x67\x39\x5D\xAF\x5C\x40\x62\xD3\x00\xC7\xB0\xED\x1A\x39\x5D\x43\x64\x8C\x9B\x1E\xB0\x91\xAF\x20\xB0\xA8\x10\x39\x5D\x05\x00\x1C\xB0\x69\x64\xDD\x00\x33\xB1\x34\xAD\x35\xB1\x04\x97\x51\x64\x39\xB1\x3A\x8D\x3C\xB1\x06\x01\xEA\x00\x3E\xB1\xD8\x1A\x60\x5D\x05\xAF\xEF\x65\xEB\x00\x9A\xB0\xB8\x22\x93\x00\x30\xB0\x48\xB1\x0C\xAF\x4C\x66\xED\x00\x4C\xB1\x82\x27\x95\x00\x4F\xB1\x61\x03\x32\xB0\xED\x25\xEF\x00\x2E\xB1\x97\x00\x44\xB0\x50\xB1\x1A\xAF\x31\x64\xF2\x00\x2E\xB1\x9A\x00\x5E\xB1\x61\x03\x3F\xB0\xDA\x0B\xF5\x00\x2E\xB1\x9D\x00\x65\xB1\x26\xAF\x1C\x68\xF8\x00\x2E\xB1\xA0\x00", - "\x6C\xB1\x2C\xAF\x86\x63\xFB\x00\x54\xB1\x71\x26\xA3\x00\x57\xB1\x32\xAF\xED\x25\xFD\x00\x2E\xB1\xA5\x00\x72\xB1\x39\xAF\x59\xA1\x6C\x1E\x15\x69\xA8\x00\x7F\xB1\x40\xAF\x4C\x66\x03\x00\x82\xB1\x64\x06\xAB\x00\x85\xB1\x46\xAF\xA5\x95\x89\xB1\x1B\x0A\xAE\x00\x8C\xB1\x4B\xAF\x91\x67\x09\x00\x8F\xB1\xA8\x10\xB1\x00\x92\xB1\x77\xB0\x65\x9A\x96\xB1\x80\x19\xB4\x00\x92\xB1\x58\xAF\xF3\x05\x0F\x00\x6C\x1E\x55\xA0\xB7\x00\xF0\xB0\x5F\xB1\x08\x55\x91\x67\x13\x00\x9C\xB1\xD8\x1A\xBB\x00\x92\xB1\x64\xAF\x74\x9A\xAB\xB1\xF8\x6C\x92\xB1\x6A\xAF\x06\x7B\x6C\x1E\x9E\x68\xC1\x00\x79\xB1\x70\xAF\x8E\x73\x1B\x00\xB6\xB1\x16\x6B\xB9\xB1\x77\xAF\x31\x64\x1D\x00\xA3\xB1\x8A\x6E\xE8\xB0\x19\x22\x61\x03\xCC\x99\x21\x00\xC3\xB1\xC2\x9F\xC5\xB1\xE0\x2A\x61\x03\x5F\xAD\xBC\x02\x25\x00\xB1\xB1\xED\x1A\xCF\x00\x92\xB1\xB3\xB0\x67\x04\x28\x00\xD2\xB1\x2E\x22\xD2\x00\x92\xB1\xB9\xB0\x4A\x16\xCA\xB1\xA8\x10\xD5\x00\xA6\xB1\x61\x03\xC0\xB0\xF7\x37\xD9\xB1\xB3\x19\xD9\x00\x92\xB1\xC5\xB0\xC2\x09\x32\x00\xE6\xB1\x0B\xA7\x92\xB1\xD2\xB0\xF3\x05", - "\x35\x00\xDF\xB1\x90\x6A\xCC\xB1\xA7\xB1\xAD\xAF\x9C\x6A\x39\x00\xF3\xB1\xD8\x1A\xE4\x00\xF5\xB1\x61\x03\xE2\xB0\xED\x25\x3D\x00\xFA\xB1\x19\x18\xE9\x00\xFD\xB1\xB9\xAF\x7A\x1C\x41\x00\x02\xB2\xA3\x6E\x05\xB2\xC0\xAF\x0B\x74\x09\xB2\x2E\x22\xF3\x00\xE2\xB1\xCE\xAE\xDD\x6B\x0E\xB2\xB3\x19\xF7\x00\x11\xB2\xD4\xAE\xEF\x65\x4D\x00\xD2\xB1\x50\x00\xBD\xB1\x8A\x5C\x92\xB1\x02\xB1\x2E\x41\xD2\xB1\x55\x00\x1D\xB2\xCC\xAF\x92\xB1\x0A\xB1\xC2\x09\x57\x00\xD2\xB1\x5A\x00\x24\xB2\xAA\x1D\x3F\x3B\xCC\x01\xF6\xB1\xDF\x8E\x12\x69\xD2\xB1\x5F\x00\x2C\xB2\x94\x01\x2E\xB2\xEB\x24\x61\x03\x1A\xB1\xC2\x09\x61\x00\xD2\xB1\x64\x00\x35\xB2\xC1\x61\x37\xB2\xA9\x25\xFE\xB1\x81\x8D\x09\xB2\x6A\x00\x3F\xB2\x41\x2C\x39\xA3\x62\x5D\xBB\x5C\x9C\x6A\x6C\x00\xED\xB1\x71\x92\x4A\xB2\x66\x01\x41\xB1\x44\x6A\x6F\x00\x6C\x1E\xF7\x18\x75\x00\x6C\x1E\x5D\x62\x61\x03\x38\xB1\x9C\x6A\x76\x00\x55\xB2\x04\x55\x58\xB2\x64\x06\x50\xB2\x1A\x2B\x52\xB2\x8E\x73\x7D\x00\x5E\xB2\x36\x5F\x60\xB2\x93\x62\x61\x03\xCD\xAF\x91\xA9\x45\x8A\xEF\x62\x60\x82\xE2\x9E", - "\xCC\x94\xF5\x64\x64\xB2\x26\x6E\x14\x8D\xB3\x19\x07\x00\x61\x03\x2B\xB1\x9F\xB0\x69\xB2\xF2\xA5\x78\xB2\x4B\x01\x74\xB2\x38\x9F\x09\xB2\x89\x00\x7C\xB2\x4A\x79\x5A\xB2\x80\xB2\xED\x25\x8A\x00\x09\xB2\x8E\x00\x84\xB2\xD8\x1A\x7E\xB2\xCA\x26\x87\xB2\x7A\x1C\x8F\x00\x09\xB2\x93\x00\x8C\xB2\x21\x63\x22\xB0\xA6\x9D\x14\xB2\xA1\x22\x0E\x00\x41\xB2\x30\x2B\x61\x03\x2A\xB0\xA3\xA7\x99\xB2\xB8\x22\x11\x00\x9C\xB2\x5E\x2B\x58\xB1\x70\x65\x9C\x00\x6C\x1E\x74\x88\x14\x00\x39\xA3\x08\x00\x61\x03\x0A\xAA\xA1\x00\xA9\xB2\xA5\x5F\xAC\xB2\x66\xB1\x23\x7C\xB1\xB2\x1B\x0A\x1C\x00\xB3\xB2\x6D\xB1\x44\x6A\xAB\x00\xB6\xB2\xAD\x5F\xB9\xB2\x73\xB1\x0B\x8D\xA1\xB2\x82\x27\x24\x00\xA4\xB2\x8E\x2B\x61\x03\x55\xB0\xDA\x0B\xB4\x00\xBD\xB2\x80\x19\x27\x00\xBF\xB2\x80\xB1\x7C\x69\xB9\x00\xCB\xB2\xD8\x1A\x2B\x00\xCE\xB2\x86\xB1\x7C\x69\xBE\x00\xD2\xB2\x6C\x87\xD5\xB2\x8D\xB1\xCC\x67\xC3\x00\xD9\xB2\xED\x1A\x33\x00\xDB\xB2\x93\xB1\xEF\x65\xC8\x00\xDF\xB2\x2E\x22\x4F\xA3\x39\x67\xAD\xB2\x56\xAE\xF7\x78\xE6\xB2\xB3\x19\x3B\x00\xE2\xB2\xA0\xB1", - "\x67\x04\xD2\x00\x67\xB2\x33\x92\x3F\x3B\x5E\x03\xEA\xB2\xEF\xA7\x40\x62\xD8\x00\xED\xB2\xA1\x22\x44\x00\xE2\xB2\xAF\xB1\x59\xAF\xFC\xB2\xB8\x22\x72\xA3\xE9\xB2\x61\x03\xB4\xB1\x7A\x1C\xE2\x00\xC2\xB2\x71\x26\x74\xA3\x12\x64\xF8\xB2\x58\x5B\x91\x67\xE6\x00\x0A\xB3\x62\x28\x4F\x00\xC5\xB2\xE5\x26\xC7\xB1\xBB\x80\xEA\x00\xF4\xB2\xAE\x66\x3F\x3B\xF7\x18\x0E\xB3\xAB\x73\xD4\xA5\x1A\xB3\xD8\x1A\x58\x00\x1C\xB3\x4E\x2B\xCE\xB1\x37\x71\x02\xB3\x82\x27\x5E\x00\xE2\xB2\xD6\xB1\x51\xA7\x28\xB3\x71\x26\x62\x00\xE2\xB2\xDD\xB1\x2C\x85\x7C\x7D\x66\x00\xF6\xB2\x25\xB3\x9A\xAF\xCC\x67\x06\x00\x39\x40\x74\x88\xA3\xA3\x05\xB3\x82\xA2\x15\xA3\x3B\xB3\xCE\x91\xE2\xB2\xF0\xB1\x67\x04\x10\x00\x39\x40\x7C\x7D\x73\x00\x24\xB3\x7D\x2B\x61\x03\x44\xB3\xBC\x02\x16\x00\x47\xB3\x0E\x87\x4A\xB3\x9D\xB2\x06\xB2\xD1\x0D\x1C\x00\x50\xB3\x1B\x0A\xBE\xA3\x34\x64\x1E\xB3\x07\x9A\x68\x9C\x57\xB3\xA8\x10\xCA\xA3\x5A\xB3\x61\x03\xEA\xB0\xBC\x02\x28\x00\x5E\xB3\x80\x19\x8B\x00\x36\xB3\x4B\xB3\x12\xB2\x4C\x66\x2E\x00\x66\xB3\xCF\x76\x69\xB3\x53\xB3", - "\x18\xB2\x67\x90\x41\xB3\x92\x38\x39\x40\xC2\x01\x95\x00\xE2\xB2\x20\xB2\x87\x09\x74\xB3\xAC\x5D\x76\xB3\x23\x53\xE2\xB2\x27\xB2\xF3\x05\x42\x00\x7C\xB3\x59\x3B\x7E\xB3\x0B\x8A\xE2\xB2\x12\xB1\x7A\x1C\x49\x00\x84\xB3\x92\x3F\x86\xB3\x20\x56\xE2\xB2\x3A\xB2\x72\x7D\x8C\xB3\xBE\x41\x8E\xB3\xA6\x56\xE2\xB2\x22\xB1\x7A\x1C\x57\x00\x6E\xB3\x55\x0C\x95\xB3\xC3\x6C\x70\xB3\x7F\x2B\x97\xB2\x16\xA7\x39\x40\x15\x69\xAE\x00\x15\xB3\x41\x2C\x9E\xB2\x88\x65\xA3\xB3\xF1\x6C\xA6\xB3\x45\x64\x11\x89\x86\x63\x65\x00\x39\x40\x55\xA0\xB4\x00\x39\xA3\xAD\xB3\x18\x76\xF9\x99\xB1\xB3\xEE\x7B\xB4\xB3\xB4\xB2\xF3\x6B\xB8\xB3\x1B\x0A\xBC\x00\xBA\xB3\xBA\xB2\x25\xAA\xBD\xB3\xF4\x9C\xC0\xB3\xC0\xB2\x69\x64\x75\x00\xAA\xB3\x1B\x0A\xC4\x00\xAC\xB3\xC7\xB2\x70\x65\x78\x00\xC3\xB3\x80\x19\xC7\x00\xC5\xB3\xCF\xB2\xA1\xAC\xD0\xB3\xD8\x1A\x17\xA4\x39\x67\xB5\xB3\xC8\x6E\x8D\x72\xD6\xB3\xEF\x6F\xD3\xB3\xC6\xA5\x0B\x89\xDD\xB3\xED\x1A\xD3\x00\xDF\xB3\xCC\xA5\x91\x67\x88\x00\xE2\xB3\x2E\x22\xD7\x00\xE5\xB3\xD3\xA5\xA7\x72\xE9\xB3\xB3\x19\xDB\x00", - "\xEC\xB3\xF1\xB2\xBC\x02\x90\x00\x93\xB3\xED\x1A\x2E\xA4\x2C\x63\xDA\xB3\xA8\xB1\xEF\x65\x95\x00\xEF\xB3\xA1\x22\x34\xA4\xD9\xB3\x61\x03\x00\xB3\xF3\x05\x99\x00\xFE\xB3\xB8\x22\xE8\x00\xEC\xB3\x07\xB3\xD1\x0D\x9D\x00\xC9\xB3\x36\x6F\xCC\xB3\x75\xAE\x1C\x86\x0D\xB4\x80\x19\x43\xA4\x12\x64\xFA\xB3\x66\x81\x9C\x6A\xA3\x00\xF6\xB3\x47\x83\x52\xB3\xA0\xB3\x9E\xB0\x90\x97\x1A\xB4\xB3\x19\x4A\xA4\x44\x64\x26\xB3\x8D\x87\x06\xB4\x82\x27\x52\xA4\x01\xB4\x04\xA5\xCC\x67\xB1\x00\x26\xB4\xF6\x62\x62\xA4\x50\x2B\x61\x03\x32\xB3\xB9\xA0\x20\xB4\xA1\x22\x06\x00\xD9\x0E\x5E\x03\x16\xB4\xB7\x8D\x9C\x6A\xBA\x00\x2D\xB4\x38\x64\x2F\xB4\x60\x2B\x61\x03\xEA\xB1\xF3\x05\xBE\x00\x3D\xB4\x01\x62\x0F\x00\x3F\xB4\x1D\xB4\x90\xA2\x1C\x68\xEF\x62\x04\x00\x76\xAC\x00\x00\xC2\x50\x00\x02\x83\x85\x03\x82\x83\x7F\x08\x89\x88\x86\x86\x83\x08\x24\x86\x00\x06\x10\x80\x0A\x01\x00\x88\x29\x02\x10\x8A\x8A\x83\x8D\x8C\x01\x63\x01\x8C\x85\x9A\x8B\x8B\x87\x89\x0C\x0F\x8C\x92\x90\x85\x88\x88\x29\x8C\x0C\xA5\xA6\x9E\x8C\x84\x65\x90\x83\x23\xB1\xB2\x9D", - "\x8F\x09\x96\x83\x95\x0C\xAD\x8C\x8F\x94\x95\x90\x9A\x88\xD1\x37\x84\x93\x82\x9F\x7D\x8F\x12\x3E\x83\x80\xA6\x82\xA6\x81\x20\xA6\x3B\xC7\x86\x96\x6A\xA2\x81\x9D\x83\x59\x90\xAB\x11\xAE\xAB\x89\xAB\x81\x40\x58\x86\xBA\xA3\x83\x6D\xAE\x00\x5F\x83\x8D\xBD\x80\x1C\xB0\xB8\xB3\x16\x8C\x9F\x4A\xBB\x8C\xB7\x80\x70\x6F\x84\x13\x84\x7F\xB0\x98\x87\x1A\x76\x82\xEC\x99\xB6\x80\x50\xBE\x8E\x7E\x80\x26\x61\xC3\x8A\x75\xC3\x89\x39\x09\xF8\xB0\x8D\x4F\xC5\x85\xC8\x00\x6C\x54\xD0\x80\x7F\xC8\x89\x1E\x9A\x8B\xD0\x9E\x4E\xCB\x98\xB6\x79\xA3\x8C\xB6\x66\xDC\x81\x21\xD5\xA0\x8C\x83\xA1\x4D\xDE\xA1\xC8\x7D\xD8\x06\xFC\x74\xC6\x85\x27\xD8\xAB\xDC\x02\xEF\x80\x13\xB1\xCE\x7F\xB7\xB8\x02\x83\x11\x30\x86\xC6\x81\x24\xBB\xD0\x80\x0B\x08\xE0\x01\x04\xEE\xE6\x7E\x85\x13\xEC\x83\x04\xDD\x8E\xF0\x0C\xDB\xD0\x92\x0F\xE9\xB0\xB6\x04\xE3\xBF\x93\x8E\x01\xFB\x80\xEF\xE5\xEE\x86\xAA\xEC\x83\x0D\xF7\xB4\xBF\x0F\x35\x72\x43\x54\x03\x55\x02\x80\x00\xF7\x68\x7A\x7C\x77\x14\x3E\x7D\x5D\x64\x16\x07\x84\x82\x40\x1C\x07\x89\x81\x7E\x03\x7B\x76\x41\x05", - "\x0E\x90\x6E\x5D\x07\x12\x93\x43\x0A\x85\xE6\x53\x4C\x00\x77\xE9\x25\x8E\x5C\x09\x07\xA5\x75\x53\x83\x10\x4E\x16\x5E\x8B\x0C\x67\x80\x47\x3A\x2A\xAC\x57\x09\x8B\x39\x86\x41\x17\x8C\x26\x9C\x70\x19\x8F\x47\x6A\x07\x82\x62\x3A\x7F\x7C\x40\x15\xC6\x43\x46\x8C\x43\x62\x04\x94\x4E\x0B\x47\x92\x90\x00\x16\x4D\x82\x4F\x92\x41\x96\x16\x9D\x46\x0C\x55\xAF\x8E\x84\x43\x5C\x19\x90\x03\x96\x03\x66\x3E\x97\x44\x36\x21\x99\x90\x8C\x0C\x60\x16\x98\x9A\x02\x73\x3B\x98\x44\x3A\x3C\x82\x9B\x67\x13\x64\x10\x90\x44\x74\x80\x05\x23\x9D\x0C\x7D\x0E\x98\x58\x4A\x86\x47\x1B\x9C\xDC\x4C\x24\xA2\x55\x87\xB2\x58\x86\x40\x6B\x0C\xA0\x45\x23\x8F\x83\x45\x11\xA4\x02\x4A\x83\x43\x1B\x96\x8C\x41\x1D\xA6\x02\x49\x1C\xA4\x7E\x89\x83\x43\x1D\xA8\x06\x72\x14\xA8\x00\x4D\x27\xAE\xA6\x40\x77\x2C\xA3\x42\x21\xAF\x91\x12\xAF\xA4\x00\x3B\x16\xAE\x40\x4A\x2F\xA5\x17\x81\xD9\x73\xA0\x03\x1F\xD8\x41\x90\x46\x1E\xAF\x9A\x1B\xAD\xAA\x02\x44\x2F\xAD\xAF\xAF\x9E\x1F\xB0\x9C\x06\x48\x23\xB7\x3B\xAF\xA2\x1A\x9F\x9B\x63\x86\x4C\x23\x9F\x35\x9C\x70\x3F\xAB\x65", - "\x1F\xB8\xA0\xB6\x03\x4F\x24\xBA\x41\x81\x8E\x15\x75\xA7\xBC\x9D\x48\x18\xB1\x56\x92\x26\x5F\x84\x67\x9C\x72\xBF\x9E\xAE\x5A\x5D\x18\xBE\x00\xFD\x60\x44\x26\xFB\x8A\xBC\x41\x25\xAF\xB2\x17\xB5\xB8\x03\x5E\x23\xB5\x24\xAF\xB6\x1F\xC0\x9F\x10\x62\x23\xB5\x12\xAF\xBA\x14\xC0\xB8\x18\xCC\x46\x29\xB2\x80\x9C\x7A\x1B\xAB\x7F\x17\xC1\xC3\x40\xAB\x13\xB0\x1F\xAB\x83\x2A\xC6\xC0\x43\xAF\x13\xB8\x45\xC1\xA0\x47\x2F\xC7\xBA\x10\xC2\x43\x2D\xC2\x25\xD7\x43\xBC\xAA\xEC\xB4\x4C\x23\xCE\x92\x90\xB0\x01\x2E\x40\xE5\xBE\x4B\xD0\xC6\x9D\x41\x24\xD2\xF4\x8A\xDF\x2D\xD3\xF0\x9C\x74\x50\xC8\x2B\xF4\x46\x24\xD5\x44\xFD\xC0\x01\x31\x58\xCE\x9C\x77\x55\x38\xD1\x6B\x24\xD8\xC6\x8B\x34\xCA\xD3\x0C\x69\x59\xDA\x5F\xA0\x2C\xDC\xAC\x34\x6F\xD9\xD0\x47\x5E\x73\xEC\x55\x2B\xA9\xA9\x07\x83\xD0\x00\xD5\x13\xBE\x61\xDF\x5A\x6B\x27\xAB\x2B\x82\xD3\x49\x37\xB4\x9D\x48\xE7\x51\x2C\xA7\xB5\x2D\xE0\x44\xDD\x13\xBC\x6A\xE4\x34\x77\x27\xAB\x2E\x97\xCC\x41\x3B\xB4\xBB\x5C\xEE\x45\x2F\xA7\x81\x31\xEA\x41\xE5\x13\xBA\x71\xD4\x13\x43\x30\xD8\x32\xAB\xC3", - "\x49\x39\xDE\x03\x4D\x0C\x76\x77\xA6\xDD\x4A\x32\xBA\x49\xC5\xD1\xD9\xC8\x06\x7A\xEB\x79\x87\xC4\xC7\x5D\x31\x88\x10\x53\x34\x8A\xE9\xC6\xFC\x78\xF1\xD7\x1E\x54\x3C\xF0\x43\xDA\x0F\xFC\xD7\xCC\xC5\xCC\x83\xF4\xF7\x47\x5B\x37\xF6\x41\xE1\x1A\xFC\xCD\xF2\x02\x51\xFB\x87\xF7\xA0\x62\x33\xFB\x40\xE8\x26\xF1\xF2\xD8\x0E\x28\x8F\xA9\x3A\xC0\xD5\xD2\xF2\x3B\xEF\x83\x45\xFF\x8D\xAF\x4C\x1D\xFE\x43\x74\x7B\x78\x3D\x7A\x20\xFF\x71\x4F\xAB\x6F\x12\x67\x8E\x34\x1E\x4C\x09\x86\x21\x94\x3D\x73\x23\x79\x0D\x83\x22\xF8\x10\x80\x77\x5D\x44\x82\x88\x37\x1F\x82\x10\x3C\x1E\x06\x90\x2A\x4D\x0E\x8C\x23\x1F\x20\x90\x20\xC7\x0C\x28\x48\x83\x11\x83\x20\x76\x46\x87\x41\x03\x86\x58\x02\x2B\x86\x20\x34\x4E\x84\x77\x03\x52\x87\x81\x02\x02\x0A\x10\x2D\x87\xFC\x68\x70\x01\x03\x37\x83\x20\x42\x88\x81\xA3\x2F\x56\x00\x20\xAC\x86\x4A\x0B\x07\x8A\x40\x49\x80\x01\x17\x82\x20\x53\x3D\x82\x22\x02\x4E\x86\x20\x2A\x86\x5F\x01\x52\x80\x00\x15\xD6\x80\x01\x51\x59\x8D\x8A\x5C\x88\x8A\x95\x13\x01\x8D\x31\x9C\x3E\x55\x67\x92\x01\x1A\xD3\x86\x4B\x0B\x2D", - "\x8B\x3E\xDC\x38\x57\x19\x96\x03\x8E\x31\x96\x4B\x03\x77\x90\x20\x19\xC1\x57\x8C\x0D\x3D\x8D\x58\xBC\x5F\x01\x18\xD9\x34\x8C\x66\x67\x8F\x03\x7D\x9E\x88\xAF\x24\x01\x90\x86\x24\x8B\x0F\xAF\x43\x05\x24\xD6\x48\x05\x4A\xBA\x80\x22\xDC\x47\x8F\x09\x7D\x89\x87\x21\x94\x7C\x05\x61\x85\x96\x12\xA4\x3F\x54\x15\x24\x96\x4A\x2F\x09\x94\x1E\xB1\x40\x6B\x7A\x53\x25\x05\x87\x96\x4A\x0C\x61\x8C\x5E\x32\xBF\x5B\x7B\xA0\x32\x05\x2E\xA6\x78\x06\x5E\xB3\x93\x61\xAF\x57\x07\x26\xA6\x7E\x06\x4F\xBE\x7C\x3B\x14\x67\x8F\x0E\x4B\x90\x99\x89\x02\x0E\x99\xAB\x8C\x21\x18\x84\x80\x7C\x9A\x3F\x03\x98\xD5\x90\x22\x11\x0B\x97\x98\x83\x27\x67\x8C\x44\x14\x9B\xF9\x54\x7B\x08\x6C\x95\x8C\x3B\x2F\x67\x8C\x12\x6A\x96\x95\x6E\x80\x07\x09\xEE\x84\x8F\xCD\x61\x9C\x2C\x26\x20\x9B\x9D\xF6\x93\x0A\x31\x82\x9C\x3B\x7D\x80\xA0\x34\x51\x1F\x9D\x3D\x9D\x29\x0B\x81\x96\x92\x6B\xB5\x8A\x69\x47\x56\x0A\xA0\xFD\x62\x6F\x0B\x0E\xBF\x93\x50\x11\xA2\x79\x8E\x1B\x0D\xA2\xDC\x9D\x21\x19\x19\xAF\x98\x88\x28\x6C\x9F\x5A\x20\x0C\x48\xC6\x5B\x0C\x72\x84\xA0\x22\x72", - "\x68\xA7\x51\x65\x0B\xA4\x5E\x70\x0E\xA5\x0F\xBB\x6F\xAB\x6A\x04\x9E\x81\x2E\x0D\x8F\x83\x75\x0D\x3E\xDC\x37\x70\x99\xB4\x20\x0E\x3D\xA0\x00\x1D\x40\xA3\x23\x3C\x03\xAC\x33\x15\x69\xAA\x1E\x4C\xA0\x23\x3E\x0F\xAC\x21\x9B\x66\xAA\x47\x7C\x09\xA8\x40\x14\xAC\x21\x81\x17\xAA\x41\x25\x7A\xAB\x8E\x02\x11\xA9\x86\x1F\xAA\x41\x05\x12\xAD\x81\x2F\x76\x96\x10\x28\x10\x48\x8D\x1A\xAD\x81\x09\x10\xA7\x06\x2F\x03\xEE\x6C\x71\x33\x47\x2F\x96\x74\x5F\x9C\x38\x7B\x67\x82\x13\x3E\xBC\x58\x13\x7D\x97\x42\xD2\x7A\xA0\x23\xFE\x27\x89\x13\x86\xB3\x23\x27\x09\xB6\x4A\xC6\x8C\x25\x41\x67\x80\x15\x64\x90\x26\x14\xCA\xA6\x76\xB2\xEB\x67\x8F\x29\x1B\xBC\x21\x56\x1E\xB2\xAB\x10\x16\x7F\x19\xAE\x1F\xAE\xAD\x8E\x12\x96\x10\x29\xB4\x00\xE7\x81\x17\xD6\x87\xA3\x22\x91\x10\xB4\x43\x32\xBA\x81\x33\xB4\x11\xA9\xC6\x54\x12\x3B\xBC\xB2\x83\x57\x78\x10\xB8\xBC\x58\x13\x70\x9B\x8F\x54\x5E\x08\xBA\x69\x9C\x0B\xB8\x09\xAF\x50\x19\xE7\x82\x78\x14\xD2\xAC\x21\x0C\xE5\xA3\x22\x62\x36\xB3\xA1\x13\x24\x16\x6E\x86\x24\xB9\x81\x3C\x84\xBB\x10\x27\x1A\x75", - "\xE2\x67\x15\xEC\xA2\x5F\x55\xCB\x0B\xBC\x11\xAB\x1E\xBD\x81\x18\x88\xBD\x0C\x2F\x1A\x7C\xD4\x7F\x15\xFA\x82\x26\x8C\xF8\xA6\x23\x34\x7B\xB6\x9F\x59\x3E\xB8\x00\x70\x81\xC3\x40\x57\x14\xC1\x8E\x37\x17\xC0\x7A\x8A\xC2\x40\x5B\x1D\xC1\x89\x3B\x17\xC0\x84\x92\xC0\x00\x5F\x15\xA6\xAB\x78\xAB\x20\xE5\xA2\x22\x23\x9A\xC4\x1D\x0A\xD0\x24\x18\x07\xD8\x93\x19\xE8\x16\xC4\x86\x08\x1F\xC0\xA1\x9A\xC0\x3B\x5F\xB6\xA2\x22\x8C\x1B\xBC\x20\xC6\x5F\x02\xB4\xC1\xA5\x89\x0F\x18\xC7\x02\x21\xC4\x00\x3F\x97\xB6\xBF\x32\x1D\xC3\xC2\x72\x18\x49\xC1\xCE\x5E\x8E\xA2\x6D\x23\xF7\x08\xCA\xD8\x58\x1B\xC8\x00\x02\xCC\x61\x67\x9C\x1D\x8B\x86\x2E\x1B\x03\xD1\x9A\xC3\x00\x13\x09\x10\xD6\x42\x1D\x03\xDB\x98\x76\x41\x82\xCE\x48\x56\x46\x1D\x0F\xCC\xC8\x22\xE7\x9A\xC1\x02\x6A\xCD\x8A\x2B\x6B\x1F\xC0\xF1\x9A\xC1\x03\x74\xCA\x8C\xD3\x6F\x1F\xC0\x06\xA0\xBE\x5F\x11\x0C\xCF\xB2\x26\x73\x1E\x55\xC2\xC9\xA0\xB5\xC4\x7B\x8E\x16\x05\xD0\x77\x26\x75\x3E\x09\xD0\xA3\x33\x9B\x00\xD2\x88\x8A\x6B\x3F\x14\xDF\x69\x33\xA0\x00\xD3\x56\x45\x01\x86\xD2\x23\x22", - "\x21\xE7\xA5\xC8\x6C\x25\x04\xA8\xA6\x7B\x01\x51\xC6\xD3\xB7\xDC\x31\xA4\xAA\xDA\x2A\x05\x55\xE8\xB6\xD5\x91\xD0\xD6\x4E\xE7\x8F\x04\x48\xD4\x8B\x06\x90\xC3\x71\x05\x38\xD4\x8A\x21\xC5\xAB\xD6\x47\x35\x06\xAF\x98\x31\xD9\x93\x04\xDD\xD4\xDC\x31\x72\x86\xBB\x0B\xD8\x88\x3F\x05\xD9\x10\x3D\x03\xB3\xB1\xBC\x3B\xAC\x88\xDC\x26\x41\x15\xD8\x43\x45\x08\xDA\x86\x21\x03\xDB\xBA\xCC\x20\x59\xDF\xDE\x23\x23\x22\xDE\x20\x4B\x05\xDE\x41\x25\x08\xDC\xF2\x9A\x6F\x55\x4D\x16\xD6\x41\x52\x02\xDF\x81\x29\x00\xD7\xD9\x31\x03\x5E\xE7\x84\x0A\x48\xEA\x95\xC7\xA6\x62\xE3\xF1\x67\x87\x0A\x48\xFC\x5D\x0B\x90\xCA\xB2\xF0\x0A\xE2\x7B\x33\x9E\x0E\xE1\x7D\x51\xE2\x95\x14\xE6\x20\xCC\x9A\xC5\x0C\x18\xF0\x23\x1A\x1A\xE9\xE0\xEE\x1C\x47\x8C\x6C\x01\xE4\x43\x72\x04\xE4\xAD\x83\xB0\x37\x67\x86\x5A\xCC\xBC\x5E\xB0\xB8\x6C\xDF\x3C\xBC\x53\xE6\xD2\x1E\xEA\xA3\x9B\xD6\x4A\xE7\xC2\x67\xE5\xBA\xBE\xE0\xB1\x9C\xFC\x56\x02\x03\xFA\xC3\x1C\x2D\xEC\xDC\x63\x48\xEB\xE1\x1A\xD4\x0F\xBB\x83\x28\x0E\xA6\xC2\xD4\x21\x4F\xF5\xE2\x86\xF9\x03\xEA\x81\x3D\x0E", - "\xEA\x8C\xD6\x9D\xD6\x9D\xEC\xAE\xBF\x3E\x0D\xEB\x00\x02\x10\xD8\x88\xE8\xEA\x93\xE5\xEC\x2D\x83\x08\xEF\x21\x6B\xE6\x59\x0B\x2A\xB2\xC3\x88\x1A\xDF\xD5\x86\x2E\x05\x7A\xC3\x26\xEE\xB3\xBA\xC1\x23\x7A\xE1\xED\x2F\x7E\xEA\x20\x80\xFD\xB6\x86\x92\x1A\xE4\x76\xF6\x00\xE0\x13\x29\xF1\x71\xE7\x88\x13\xC6\xFB\xEB\x20\x3B\x10\xF0\x44\x12\xF3\x20\x0E\x9A\xC6\x13\x96\xE5\xF3\x44\x40\x0A\xF2\x86\x1C\xF2\x20\x25\x9A\xC0\x29\x21\xFC\xEC\xE2\x25\xF6\x20\xA7\xE0\x03\x76\xC4\xEC\x20\x55\x04\xF5\xF5\x03\x2A\x0B\xE1\x80\x01\xF7\xF3\xB4\xF6\x20\xAF\x0C\xF6\xB1\x4E\x0F\xF5\xBF\xCB\x8F\x8C\xB5\x02\xF8\xAF\x53\x05\xF8\xC4\xDC\x3F\xBE\xBF\xE3\x23\x2E\x4A\xFA\x68\x2C\x0D\xFC\xF7\xDC\x20\xC1\xF4\x82\x21\x18\xEA\xC2\x7D\x0B\xD7\xF1\xF5\x82\xDB\xFF\x22\xEF\xE2\x6A\x0C\xE1\xF9\x8F\xAB\x4D\x16\xFC\x22\xA7\x09\xFD\x10\x38\xD4\xEE\xB4\x23\x1A\x48\xC7\x06\x4A\x6C\x18\xD4\xBF\x31\xF3\xC4\xF2\xDA\x1D\xFD\xD4\x32\x07\xF0\x7C\x10\x2A\x6A\x61\xE0\x00\x80\xF6\x47\x07\x03\x86\x10\x31\x64\x7E\xE6\x07\x7B\xC6\x2C\x07\xBB\x71\x7B\xE7\x27\x46\xEB\x00", - "\x81\xBC\x20\x08\x13\x8D\x64\x67\x40\x0F\xF6\x76\x25\x84\x08\x6B\xF7\x7B\x79\x1C\x8A\x61\xF7\x0F\x81\xA6\x3B\x08\x22\x81\x79\xDC\x18\x65\x1A\x6E\x0F\x08\x8D\x11\x92\x0B\x80\x03\x1F\x65\xE4\x74\x00\x54\x00\x11\xFC\x26\x2C\x97\x04\x83\xA5\x2F\x2A\x0A\x09\x83\x0C\x13\x82\x5A\x5C\x09\xFA\x7C\x82\x70\x6F\x2A\x11\x02\x84\xF2\x16\x3A\xA2\x0E\x83\x00\x09\x67\xE4\x77\x01\x4C\x84\x6A\xA6\x37\x0A\x50\x8B\x68\xF3\x7E\x11\x1D\x05\x85\x02\x14\x84\xEC\x6C\x0A\x2B\x84\x82\x42\x37\x46\x24\x0E\x85\x45\x46\x25\xB3\x03\x86\xA6\x75\x69\x1A\x6B\x02\x68\x80\x86\x97\x72\x10\xBA\x0C\x86\xB0\x7E\x86\xE4\x72\x03\x71\x86\x25\xC1\x06\x87\xC6\x76\x52\xAF\x29\x03\x7B\x86\x3A\xC8\x07\x84\x64\x81\x37\xAF\x20\x04\x83\x8A\x55\xCE\x06\x88\x6D\x8B\x6B\x1A\x67\x04\x68\x8C\x2F\x4D\x08\x86\x83\x34\x0D\x50\x87\x6C\x73\x8E\x11\x4F\x03\x89\x13\x15\x05\x96\x8E\x38\x50\x82\x6D\xE4\x77\x05\x9E\x80\x11\x5D\x01\x8A\x10\x1E\x0D\x50\x8E\x6D\x9B\x8D\x11\x5F\x07\x8A\x0C\x15\x06\xAA\x8C\x10\xE3\x00\x85\xEB\x6F\x8A\x13\x17\x06\xB2\x86\x10\x6D\x05\x8B\x06\x18\x0E", - "\x50\x8F\x56\x12\x53\x11\x6F\x0B\x88\x06\x16\x07\xC0\x83\x10\xED\x0E\x88\x06\x19\x01\x77\x74\x7E\x78\x08\x86\x92\x4A\x34\xF3\x0B\x7B\xD0\x81\x78\xE4\x7C\x07\xD4\x86\x25\xF7\x08\x8D\x42\x2F\x2A\x80\x08\x86\x99\x62\x3C\xFB\x07\x7D\xD9\x80\x25\xAF\x25\x08\xE4\x8E\x25\x4B\x00\x11\xD9\x19\x8E\x5C\x2F\x2A\x8A\x0D\x8E\xA6\x35\x00\xEF\x8B\x66\x10\x12\x8F\x69\x2F\x2A\x8F\x06\x8F\x5A\x5A\x00\xF9\x88\x13\x27\x1C\x1D\xB3\x7A\x8B\x10\x14\x09\xDD\x8F\x59\x03\x9D\x67\x0C\x1C\x8F\x02\x1E\x7B\x08\x9C\x10\x98\x00\x90\xEC\x63\x01\x0D\x9F\x6A\xCF\x87\x7C\x1A\x6D\x09\x16\x9B\x89\x18\x09\x91\xB9\x6B\x91\x97\x2F\x2A\xA2\x0F\x91\xA2\x79\x6D\x22\x91\x8F\xD9\x7F\x2A\xA7\x08\x92\x5B\x82\x02\x2B\x95\x90\x10\x13\x7E\x13\x96\x10\xAC\x00\x93\xC6\x27\x02\x33\x9B\x8F\xEA\x74\x5B\x3A\x9C\x2B\x2C\x0D\x93\x0F\x9C\x1D\xF2\x78\x66\x0C\x16\x0B\xBD\x8B\x89\x31\x02\x92\xFC\x20\x91\x00\x0D\x7F\x37\x93\x10\xBC\x01\x94\x4A\x37\x03\x44\x94\x92\x04\x8F\x2A\xC1\x06\x95\xC2\x3C\x03\x59\x93\x10\x50\x9D\x80\x53\x92\x10\xC6\x0B\x90\x5A\x51\x04\x22\x94\x45\x50", - "\x95\x81\x1A\x6A\x0C\x68\x9C\x6E\x45\x0B\x96\x34\x9C\x10\x44\x65\x96\x00\x0E\x0C\x4B\x99\x92\xDA\x42\x92\x72\x82\x10\x50\x97\x97\x7C\x9A\x15\xD4\x0B\x97\x5B\x80\x05\x7E\x95\x97\x06\x1E\x82\xFE\x7E\x95\x62\x37\x05\x61\x90\x98\xD0\x4F\x2A\xDF\x0E\x98\x44\x4C\x05\x91\x90\x00\x50\x97\x66\x70\x5C\x10\xE4\x06\x98\xC6\x21\x06\x4E\x9A\x98\x03\x11\x67\xE4\x7A\x0E\x96\x94\x3D\x67\x09\x99\x50\x92\x85\x78\x9F\x0E\xA9\x96\x4F\x6C\x0C\x9A\x05\x5E\x64\x44\x4E\x40\xA0\x9C\x2B\x71\x09\x98\x3E\x95\x86\x1A\x6A\x0F\xB9\x9A\x34\x78\x0C\x9B\x45\x9D\x69\x60\x65\x05\x3A\x86\x25\x7F\x04\x9C\x5A\x96\x10\x5B\x34\x7E\x06\x08\x9C\x2A\x16\x25\x86\x0C\x9C\x62\x97\x36\xAF\x2C\x00\xD2\x9D\x84\x5A\x5D\x08\xA3\x9D\x9B\x88\x81\x47\xDB\x96\x85\x5A\x53\x09\xDF\x95\x9C\x7A\x1F\x2A\x18\x03\x9E\x1A\x93\x10\x1D\x0C\x9E\x00\x03\x38\x99\x04\x9B\x10\x1A\x89\x83\x97\x14\x1F\x00\x9F\xD9\x14\x02\xF0\x93\x38\x9E\x04\x9F\x0C\x14\x8A\x78\x96\x02\xFA\x93\x11\x2B\x0D\x9F\x13\x13\x0A\x00\xA6\x10\xAE\x87\x9F\x34\x1D\x02\x05\xA0\x11\x32\x08\xA0\x10\x18\x0A\x0B\xAA", - "\x1B\xAF\x24\x03\x11\xAC\x10\x39\x04\xA1\xA5\x57\xA1\xC9\x1F\x2A\x3B\x00\x9F\xFC\x21\x04\x1E\xA6\x10\xB2\x07\x9E\x06\x1A\x01\xDC\x18\x01\x6F\x7A\x15\x43\x00\x9F\x07\x70\x74\x62\x3C\xA2\xD9\x6F\xA2\x47\x16\x04\x24\xA3\x11\x4C\x00\x9F\x12\x75\xA3\xDC\x1E\x01\x38\xA4\x13\x4D\x0B\xA3\x10\x13\x05\x3E\xAF\x47\xD1\x88\x97\x54\x00\x9F\xD5\x82\x3C\xB8\x04\x97\x10\x1B\x01\xDC\x18\x23\x67\x48\x05\x4E\xA6\x25\xBC\x02\xA5\x0C\x14\xA5\x10\x13\x24\x67\x4C\x05\x1B\xAC\x6E\xC0\x09\x99\x5E\xAA\x8E\x67\x41\x06\x63\xAB\x89\xC5\x06\xA6\xCC\x57\x46\x66\x0B\xA6\x0E\xA0\x00\xCA\x0E\xA6\xD3\x57\x46\x6B\x02\xA7\x5B\x8F\x0C\x76\xAA\x5D\xAF\x20\x07\x59\xA6\x3A\xD4\x0C\xA5\x06\x17\xA6\x6B\x5F\x2A\x74\x0A\xA7\xC6\x28\x0D\x7D\xAF\x5E\x67\x49\x07\x8A\xAC\x2B\xDD\x0D\xA8\xF6\x5F\x2A\x7E\x01\xA9\x4A\x32\x0E\x94\xAF\x5F\x30\x38\xA9\xC2\x37\x0E\x9B\xA8\x60\xAF\x28\x08\x9E\xA2\x36\xEC\x01\xAA\x11\x64\x7E\x8D\x05\xAA\x44\x41\x0F\xA1\xA7\x94\x9D\x96\x10\x92\x06\xA4\x5A\x56\x0F\x2A\xA3\x10\x86\xA3\x10\x52\x93\xA7\x1D\x18\x09\xAC\xA4\x3D\xFC\x01\xAA", - "\x05\x84\x7E\x9D\x0F\xAB\xF6\x41\x00\x4C\x00\x8F\x13\x19\xAB\x02\x14\x96\xBC\xA3\x11\xA2\x01\xA8\x5A\x56\x00\xC9\xAF\x44\x53\xAA\x63\x67\x46\x0A\xD2\xAC\x6E\x0A\x05\xAD\x75\x67\xAD\xB4\x47\x46\xAA\x04\xAB\xEC\x6E\x00\xDE\xA3\x10\x7F\x90\x00\xCC\xA3\x64\xB6\x9D\x68\x13\x10\x0B\xE4\xAB\x89\x15\x07\xAE\x5F\x8B\xAC\x2D\x8F\x2A\xB6\x06\xAC\x1D\x1C\x01\xF4\xA3\x92\xB8\xA3\x99\x67\x4B\x0B\xFA\xA3\x11\x21\x0D\xAF\xD9\x1B\xAE\x9C\x95\x8C\x10\x10\x0C\xF1\xA3\xA7\x26\x0D\xAF\xFC\x2B\xAE\xA6\x98\x97\xC6\x03\xB0\x10\x1C\x02\x06\xB6\xAF\x10\x1E\x9A\xCF\xA0\x11\xCB\x06\xB1\x0C\x11\x03\x19\xB0\xAE\x0C\x1A\x85\x48\x96\x10\xD0\x0D\xB0\x5B\x86\x03\xFD\xA9\xAE\xEB\xA6\xB2\xB1\xA3\x10\xD6\x0A\xB2\xC6\x2D\x03\x2D\xBA\xB1\x1B\x57\x46\xDC\x04\xB3\xBC\x24\x04\x37\xB4\xB2\xCE\x9D\xAE\xF6\x4D\x11\xE2\x0C\xB3\x4A\x3B\x04\x3F\xBD\xA5\xD8\x9B\x62\x46\xB2\x3C\x52\x00\xB1\x38\xB6\x10\xB2\x68\x97\xEE\x0D\xB4\x62\x38\x05\x50\xB0\xB4\x03\x1C\x37\x1A\x64\x0F\x7A\xA9\x0F\x27\xA3\x10\x5E\x03\xB2\x4A\xB5\x9F\xAF\x2B\x0F\x7A\xA0\x00\x56\x04\x1D\x13", - "\x13\x06\x64\xB5\xA8\xD1\x6F\x2A\x02\x0B\xB6\xFA\x83\x84\x74\xB6\x10\x83\x38\x06\x6F\xBF\xAF\xAB\x1F\x2A\x09\x07\xB7\x4B\x12\x48\x80\xB2\x10\x83\x3D\x06\x7B\xB2\x10\xEB\xA9\x8B\x1D\xBB\x5B\x83\xBE\xAF\x02\x15\x01\x8D\xB3\x38\x72\x07\xB8\xEA\xA7\x6F\x67\x47\x01\x8D\xBC\x2F\x1D\x01\xB9\x13\x17\x07\x59\xBC\x10\x1C\x0D\xA2\x43\xAE\x11\x1F\x0D\xB8\x33\xA6\x74\x4A\x31\xBA\x37\xA7\x46\x22\x09\xB9\x13\x18\x02\x8D\xBF\xA3\x44\x4A\xBA\x0C\x12\xA4\x67\x49\x02\xAE\xB0\x11\x2F\x01\xBB\x56\x2D\x01\xDC\x10\x95\x27\xBB\x89\x34\xA4\x44\xB6\xB5\xB6\x1A\x63\xBC\xD4\x36\x2C\x1F\x02\xBA\x67\x40\x03\xBC\xB5\x74\x4A\x3B\xBC\xAB\xBA\x61\x31\x0D\xB8\x54\x45\x03\xCF\xBA\x55\xD2\xB5\xBB\xA3\xBD\x11\x36\x06\xBD\x13\x1A\x03\xD9\xBC\x6E\x20\x0B\xA4\x8B\xB6\x10\x3B\x09\xBB\x5A\x5D\x07\x94\xB5\xBE\xDA\x88\x97\x41\x0A\xBE\xEC\x62\x08\xED\xB1\x8E\x67\x47\x04\x8D\xB9\xAE\xC6\x27\x08\x9F\xB6\x10\xEE\xB8\xA6\x1A\x6E\x04\xF9\xB6\x25\x8D\x0D\xBF\x03\x1F\xBF\xF3\x87\x46\x55\x03\xC0\xA6\x33\x09\x06\xC2\x10\x08\xCD\x8F\x61\xAC\xC0\x5A\x59\x09\x0F\xC0", - "\x00\x11\xC5\x27\xAF\x23\x06\xF2\xBB\x89\x9F\x05\xBF\x10\x12\x91\xE7\xB3\x10\x69\x04\xC1\xEC\x64\x0A\x17\xC9\xC1\x00\x0E\x28\x67\x40\x07\x26\xCB\x89\xAA\x09\xC2\xCF\x7F\x2A\x77\x0F\xC2\x73\xA0\x0B\x32\xC0\x11\xDA\x78\x97\x7E\x06\xC3\x5B\x86\x0B\x39\xCB\x72\xEB\x8E\xC3\xC6\x2C\x0B\x41\xC6\x10\xA9\xA8\x97\x8C\x04\xC4\xBC\x22\x0C\x47\xC9\x7B\xAF\x23\x09\x8D\xB8\x00\x56\x28\x0C\x49\xBE\xBF\xDC\x1B\xAB\x5B\x8D\x11\x9B\x0C\xC4\x4A\x3F\x0C\x4F\xC2\x10\xC3\xA8\x97\xA2\x0E\xC5\xC2\x35\x0D\x61\xC0\x00\xCE\xAB\xC5\x13\x19\x0A\x1D\xC3\xA7\xDB\x00\xC2\x0C\x1E\x96\xE4\x7F\x0A\x6F\xCB\x85\xE0\x02\xC7\x06\x12\x98\x6C\xC0\x11\xB5\x03\xC5\x56\x25\x0E\xFD\xA4\xC5\x10\x1A\xC2\x7C\xC1\xBC\x02\x1D\x0B\x80\xC6\x3A\xED\x03\xC8\x13\x1A\xC2\x8C\x98\x97\xC5\x06\xC6\x62\x35\x0F\x69\xC6\x83\x78\x9C\x0C\x94\xC4\x44\xFB\x09\xC6\x09\xBD\x51\x13\x13\x0D\x8B\xCA\x55\x01\x0D\x04\x10\x19\xAE\x2A\xC3\xB1\x23\xC3\x61\x9B\xC4\x3D\x08\x06\xCA\xD3\x95\xC8\xF0\x4F\x2A\xE2\x0D\xCA\xF6\x4E\x00\xB0\xCC\x9D\x58\xCE\x9B\xE4\x79\x0E\xA3\xCC\x6E\x14\x09\xCB", - "\x03\x14\xC8\x0C\x1A\xC2\x30\xBA\xB0\x0C\x11\x0F\xBF\xCB\x89\x1C\x02\xCC\x02\x14\xCC\xBB\xC9\xB3\x1A\x69\x0F\xCB\xC3\xA7\x24\x0E\xCC\x00\x00\xCD\x07\xC8\x87\x78\x91\x00\x57\x00\x11\xDA\xC3\xA7\x2C\x08\xCD\xE1\xC8\xC1\x4B\xB2\x67\xDF\xCC\x10\xE5\xC6\x2C\x34\x08\xCD\xA8\xC1\x6B\x4A\x89\xCE\x06\x1B\xCE\xBC\x2B\x03\xEE\xCF\xC8\xDC\x1C\xB5\xE4\x79\x01\xF2\xC8\xAE\x8F\xCD\xCF\x84\xB6\x4D\xD8\xCC\x2F\x2A\xC6\x9F\x7D\xCC\x10\x22\x00\xD0\x69\x80\x11\x29\x0A\xD0\x83\x38\x04\x03\xD8\xCF\x50\x57\x46\x2B\x0A\xD0\xE9\xA2\x03\x0E\xD3\x11\x4E\x01\xD1\xB2\xCD\xB7\x67\x44\x03\x16\xD3\x11\x3B\x09\xD1\x10\x14\x05\x1C\xD5\xCC\xDC\x1A\xB8\x07\xD6\x10\x3D\x01\xD2\x10\x14\x04\x24\xDC\x10\x5A\x07\xD2\xD1\xCE\x9C\xAF\x26\x04\x0A\xD5\xCE\x4E\x01\xD3\x06\x10\x06\xF7\xC0\x11\x22\x06\xBE\x2B\xDE\x56\x0A\xD5\x8E\x62\x37\x06\xD8\xC9\x1D\x41\xDF\xBE\xAB\xC0\x00\x55\x05\xD4\xF8\x79\xD4\x13\x1B\xD4\x8A\x74\x7E\x5A\x0A\xD0\x3B\x8A\x9B\x34\xD3\x10\x54\xD3\x79\x1A\x60\x06\x58\xD6\x25\x77\x0B\xD5\x02\x1D\xD5\x9D\x7F\x2A\x66\x01\xD6\xA6\x3D\x07\x64", - "\xD0\x00\x66\xD8\x7A\xAF\x2C\x06\x6A\xDA\x55\x83\x0D\xD6\x6F\xD2\x7B\x0D\x30\xD5\xA6\x39\x08\x52\xD0\xD4\x3B\x44\xC3\x73\xDC\x6E\x8E\x06\xD7\x1C\x94\x7E\x7D\x01\xD8\x9B\x84\x09\x84\xD5\x92\x67\x43\x08\x88\xD3\xA7\x9A\x0B\xD8\xA2\x2F\x2A\x89\x0F\xD8\x5B\x80\x0A\x92\xDD\x2A\xFE\x86\xD9\xC6\x26\x0A\x99\xD7\x2B\xAF\x25\x09\x9C\xDC\x2B\xAC\x0F\xD9\xC0\x2F\x2A\x9B\x0E\xD2\x5A\x52\x0B\x3F\xD8\xD0\x59\xC6\x92\xA3\xDA\x34\xB9\x06\xDA\xD4\x27\x46\xA8\x01\xDB\xC2\x3F\x0B\xB4\xDB\xC6\x88\xC0\x00\xAE\x0A\xD7\x5A\x55\x0C\x7D\xDE\xDA\xAC\x47\x46\xB3\x00\xDC\xEC\x6A\x0C\xC3\xD6\x10\x77\xD7\xC8\x31\xB2\x10\xB8\x0A\xDA\xEC\x6F\x0C\xE4\xC3\xD5\x25\x84\x7E\xBF\x02\xDD\x9B\x87\x0D\xD5\xDE\xD7\x10\x11\xC9\x4D\xD6\x0C\xB8\xD2\x36\xDF\x04\xDB\x98\xCD\xD4\xCC\x03\xDE\x44\x45\x0E\xB4\xDF\xC9\x4F\x63\x11\xD2\x0A\xDD\x73\xAB\x0E\xAD\xDC\xDC\x26\x3F\x2A\xD9\x0A\xDE\xD4\x32\x0F\xB4\xDC\xB1\x43\xD2\x10\xDF\x0A\xDF\xF6\x48\x0F\xB4\xD7\xCC\xA0\xC0\x11\xE5\x02\xDF\x5B\x8E\x0F\xDD\xD4\xDC\x25\xB2\xB4\xA0\x1C\x0E\x0A\xE6\x2C\x06\x0E\x04\xE0\xC6", - "\xDD\xC6\x94\x7E\xF3\x03\xE1\xBC\x2E\x00\x16\xEA\xCE\x18\xE2\xCD\xE4\x7A\x0F\x1C\xEA\x34\x16\x0F\xE1\xF3\xC1\xE2\x56\x1F\x2A\x01\x08\x05\xA7\xC6\x25\x1E\x08\xE2\xFE\xCE\xDD\xE1\x9A\x61\x08\x0E\xE2\x43\x86\x25\x25\x02\xE3\xF5\xA4\xE3\x06\x1A\xCF\x78\x9F\x00\x38\xEA\xCB\x05\x23\xE4\x3E\x43\x11\x2C\x0C\xE3\x11\x1A\xE2\x03\x16\xD0\xBD\xD7\x01\x46\xE3\x20\x13\x1D\x01\x51\xE1\x9F\x13\x12\x03\x4A\xEC\x2F\x77\xD2\xA0\x4D\xDF\x01\x55\xEC\x2F\x25\x05\xE5\x83\x38\x03\x59\xEC\xE4\x02\x1D\xA0\xFF\xD0\x00\x27\x0F\xE5\xB7\x42\xE6\x13\x1E\x03\x65\xEE\xE3\x18\xAC\x6B\x6C\xE0\x11\x35\x0E\xE6\x2F\xD1\xE7\x0E\xE6\xD3\x67\x47\x03\x55\xE9\xAE\x3E\x08\xE7\x0C\x1A\x04\x4A\xE9\xAE\x23\x0C\x1D\x21\x0D\xBD\xA3\x75\xE5\xA7\xBA\x69\xBC\x27\xE8\x10\x1E\x02\x8A\xE0\x11\x43\x05\xE7\xDA\x45\xE5\xB2\xB4\x3D\x90\xEC\x10\x2F\x03\xE9\x83\xE6\xE9\xCE\x98\xE9\x56\x2B\xE9\x06\x10\x03\x9E\xEE\x23\xA0\xE3\x10\x57\x02\xEA\xA6\x34\xEA\x03\x11\x03\xA7\xE3\x10\x58\x09\xEA\x02\x1E\x05\xAC\xEA\x55\xAE\xE2\x10\x32\x01\xEB\x02\x1F\x05\xB4\xE0\x00\x65\x07\xEB", - "\xEC\x69\xEB\x00\x03\x03\xBC\xE0\x00\x66\x0F\xEB\x6C\x02\xEC\x9B\x84\x02\x42\xDD\xDB\x6D\x05\xE5\x46\xD4\x44\x51\x0A\xE4\xFB\x95\xA5\x0D\x32\xED\x56\x26\x05\xD6\xE3\x11\xCE\xEF\xA5\x34\xCF\xEB\xC6\x2B\x05\x7A\xE6\x10\xDF\xE0\xC0\x86\xD2\xEE\xBC\x21\x06\xE5\xE3\x10\xE7\xE9\xC0\x1A\x63\x08\xEA\xEA\x34\x67\x0D\xEE\x02\x1F\xEE\x12\xCA\x61\x89\x03\xEF\xC2\x3D\x06\xF6\xE0\x00\xF8\xEA\xC1\x67\x4F\x08\xDA\xE6\x3A\x73\x0D\xED\x10\x11\xF0\x82\x2F\x2A\x94\x0C\xEF\x62\x38\x07\xFF\xEA\xF0\x2C\xCA\x61\x9A\x0E\xF0\x44\x4E\x07\x11\xF3\xC3\x99\x56\xF1\xD4\x34\x08\x19\xFA\xC3\xAF\x26\x0A\x1C\xF6\x4F\x8A\x0F\xF1\x42\xC7\x46\xAC\x03\xF2\x1D\x10\x09\x26\xF8\xC4\xAF\x22\x0B\x2A\xF3\x11\x96\x0D\xF2\x50\xC7\x46\xB8\x0F\xE7\x56\x2C\x09\x85\xEE\xED\xAF\xD7\x46\xBF\x01\xF3\x10\x13\x0A\x34\xF2\xC6\xAF\x25\x0C\x40\xFC\x10\xA9\x03\xF4\x6A\xC0\x5F\x05\xFA\x55\xAF\x08\xF0\x0C\x1A\xF0\x74\xC8\x97\xD0\x0D\xF4\xEC\x64\x0B\x50\xF6\xEE\xD7\xD8\x97\xD5\x08\xF3\xA6\x39\x0B\x4A\xE5\xCE\x0A\xFE\xDC\xC8\xC6\x10\xDC\x0E\xF5\x5A\x51\x0C\x61\xFC\xF3\xDF", - "\xDF\x2A\xE3\x07\xF4\x06\x19\x0C\x4A\xF7\xDE\x69\xE9\x0E\x70\xF3\x10\xCF\x0A\xF4\xEE\xD7\x9B\x13\x1F\x0E\x68\xFC\x6E\xD5\x0B\xF3\x09\xF7\xDF\x67\x46\x0F\x77\xF2\x10\xDC\x0A\xF4\xFE\xDD\xDB\xFC\x07\xF8\x00\x02\x0E\x4A\xF6\xE0\xEF\xD4\x1D\x59\x0F\xE2\xA6\x38\x0E\x6B\xF3\xF8\xBC\xC8\x97\x09\x05\xF9\x39\xE6\x3A\xF0\x09\xF9\x51\xFC\xCD\x4D\xD0\x01\x9E\xF6\x10\xFA\xBC\x2B\xF8\x02\xFA\x5A\xF9\xE1\x78\x97\x01\xA7\xF3\xE3\x65\x5F\x04\x17\xEA\xF9\xB5\x1F\x2A\x1E\x01\xFB\x3D\xEA\x55\x08\x04\xFB\x9F\xF3\xFA\x30\x5F\x2A\x25\x0A\xFB\x0B\xDA\x55\x0F\x0E\xFB\xA8\xFC\xF6\xE9\x97\x46\x2C\x04\xFC\xFC\x22\x03\xC4\xF3\x38\x16\x08\xFC\xE4\x9D\xFA\x0C\x1E\xE4\xCF\xD0\x00\x34\x0E\xFC\xE1\xB1\xFD\x13\x1C\x01\xD4\xF2\xE5\xB6\xF6\x10\x5C\xE9\xE6\x3C\x0C\xFD\x10\x12\x04\xDE\xF0\xD4\xE1\xFB\xE4\xE3\xF1\x31\xAF\x24\x04\xE8\xF3\xE8\xEB\xFC\x10\x28\x0D\xFE\xFC\x2A\xF0\x2A\xDD\xDB\x4C\x03\xFF\xFB\x65\xFF\x7C\x38\xFF\x4A\x7E\x3E\x7A\x61\x54\x00\xF1\x69\x57\x5B\x00\x00\x83\x08\x1A\x0D\xFE\x69\x55\x09\x08\x74\xC7\x75\x0B\x04\x7F\x46\x72\x3C\x46", - "\x17\x03\x91\x74\xC7\x70\x0C\x3E\x7F\x81\x06\x06\x44\x7D\xA6\x76\x27\x17\x84\xD3\x47\x77\x33\x0B\x01\x82\x09\x1B\x1E\x80\x3A\x74\x3B\x26\x75\x33\x2E\x06\x25\x82\x52\x28\x81\xA6\x19\x04\x86\x08\x58\x77\x46\x75\x02\x0B\x9B\x03\x30\x82\xAB\x32\x81\x81\x0B\xEB\x67\x20\x1F\x0E\x81\x82\x01\x07\xAC\x37\x1D\x82\x10\x46\x75\x63\x6E\x81\x89\x02\x08\x9B\x44\x13\x0F\xEC\x59\x7E\x22\x04\x7E\xD3\x74\x7A\x3B\x01\xF6\x79\x1D\x4C\x80\x53\x69\x73\x8F\x00\x0A\x96\x12\x20\x04\x05\x93\x0A\x15\x95\x6A\x78\x4C\x12\x2E\x80\x63\x15\x04\x02\x80\x44\x1F\x82\x5E\x6C\xFC\x1A\x05\x31\x8C\x2B\x4B\x02\x19\x8C\x08\x68\x87\xAC\x59\x2C\x36\x8A\x34\x51\x03\x1B\x86\x08\x71\x80\xAE\x59\x56\x3A\x82\x3C\x57\x03\x1D\x83\x08\x79\x80\xAF\x68\x78\x2D\x86\x3A\x5D\x01\x17\x87\x83\x7F\x6C\xB6\x3C\x83\xF3\x3F\x07\x82\x09\x20\x93\x78\xE4\x3F\x16\x0B\x84\x22\x28\x06\x0D\x84\x00\x01\x84\xD0\x38\x2F\x7D\x05\x49\x84\x3D\x6E\x02\x25\x81\x84\x3B\x65\xA9\x43\x06\x4E\x86\x4F\x74\x03\x27\x8F\x23\xAF\x11\x19\x24\x85\x8E\x0A\x07\x27\x84\x44\x09\x62\x4D\x6F\x19\x2B\x85", - "\x89\x00\x08\x2E\x87\xA0\x6F\x15\xD5\x07\x00\x94\x4F\x06\x8E\x05\xBD\x7A\x86\x3C\x06\xB3\x87\x52\x36\x84\x83\x03\xC6\x4D\x6A\x38\x01\x86\x0C\x0B\x12\x03\x87\x81\x0C\xDB\x59\x7C\x3A\x04\x84\x15\x67\x10\xB0\x82\x6C\x5A\x61\x6D\x04\x34\x8C\x37\x9E\x02\x1A\xB8\x83\xAD\x7D\xD4\x72\x06\x2E\x86\x1D\xA3\x05\xFD\x65\x67\x40\x84\xF6\x07\x70\x43\x19\x07\xDF\x82\xAB\x2B\x04\x71\x8D\x0B\xED\x7B\x19\x20\x00\x5A\x01\x39\x66\x1D\x59\x0B\x0C\x82\x08\xDD\x7D\x6D\x06\x01\x1E\xB1\x64\xAD\x29\x0B\x75\x84\x00\x1B\x7B\xEE\x50\x50\x3A\x87\xE4\x76\x3A\x3F\x04\x2F\x88\x84\x49\x47\x8C\x13\x01\x81\x85\xFD\x1B\x46\x31\x1E\x87\x8B\x79\xFB\x59\x00\x86\x82\xFE\x5A\x28\x33\x1E\x87\x92\x7C\xEF\x50\x09\x0F\x04\x11\xC5\x7C\xBB\x32\x06\xEC\x80\x21\x8F\x71\x33\x26\x02\x1D\x89\xEA\x6A\x1A\xDA\x01\x24\x93\x86\xD7\x7D\xD4\x2D\x02\x49\x84\x33\x2A\x8B\x1B\xAC\x89\x34\x74\x03\x2F\x8A\xE9\x0A\x07\x31\x88\x10\xA7\x66\xF2\x3B\x03\x36\x8A\x56\x32\x07\x07\x8B\x25\xB5\x70\xF2\x32\x04\x3E\x88\xBB\x39\x07\x41\x8A\x26\x8B\x7E\x0D\x39\x04\x1D\x88\xBF\x0F\x02\x1D", - "\x8B\x70\x00\x01\xB7\x0C\x2F\x01\x84\xF6\x65\x7B\x03\x09\x0A\x0E\x8B\x89\x07\x05\x51\x8B\x44\x06\x00\x54\x8D\x1D\x81\x51\x57\x19\x05\x5B\x88\x44\x1F\x02\x5E\x88\x50\x21\x8A\x91\x8C\xA0\x2F\x15\x18\x06\x8B\x0C\x0F\x0C\x29\x8A\x86\x02\x01\x6B\x8A\x50\x83\x2B\xAF\x11\x0D\x30\x8A\x83\x0F\x06\x73\x8A\x41\x18\x00\x76\x8A\x29\x84\x80\xF2\x31\x07\x46\x88\xD5\x3E\x8B\x03\x0E\x03\x2F\x0B\x74\x57\x02\x10\x83\x19\x3A\x03\x1D\x8C\x02\xA2\x1B\x9D\x4C\x1D\x12\x77\x19\x3D\x03\x7B\x8B\x20\x03\x05\x8E\x8F\x01\x9D\x09\x63\x9A\x5D\xC7\x74\x10\x19\x8C\x81\x0A\x08\x1C\x8E\x95\x1F\x8C\x0C\x0B\x05\x9A\x31\x45\x03\x1A\x80\x01\x24\x06\x8D\xA6\x18\x35\xB3\x81\x63\x72\x09\x2D\x8C\x26\x10\x8D\x5A\x2A\x36\xBC\x81\x63\x79\x09\x2D\x8F\x27\x18\x8D\xEC\x32\x37\x85\x83\x63\x70\x0A\x2D\x8E\x29\x00\x8E\x9B\x40\x05\x0D\x82\xAC\x82\x10\x27\x05\x47\x91\x82\x20\x87\x39\x2F\x5C\x6C\x78\xF2\x4F\x8E\x95\x0A\x01\xD2\x88\x22\x0A\x8E\x70\x74\x5B\x2D\x8E\xB1\x0F\x01\x81\x8B\x20\x1B\x8E\x74\x78\x97\x37\x06\x77\x9C\x15\x35\x01\x3C\x82\x09\xF1\x80\xEF\x64\x3D", - "\x2F\x07\x8F\x4A\x1B\x07\x2A\x8E\x00\x0C\x1E\xF9\x74\xF9\x23\x06\xF0\x8A\x78\x01\x03\xF9\x85\x1F\x82\x7A\x86\x29\x06\xD6\x8E\x74\x07\x03\xEC\x86\xFF\x09\x86\x86\x2E\x06\xF9\x8A\x6C\x0C\x02\xFE\x85\xD8\x78\x48\x35\x09\x90\x44\x22\x0A\x0C\x90\xC6\x6A\x61\x5A\x04\x84\x94\x1E\x58\x03\x42\x93\x6D\x33\x20\x0E\x17\x92\x3D\x3E\x02\x1A\x92\xB3\x67\x22\x73\x0E\x21\x9D\x08\x19\x01\x91\xA0\x6F\x8C\x2C\x07\x12\x93\x11\x6A\x00\x8A\x87\x6D\x67\x22\x1E\x06\x8D\x39\x50\x07\x0B\x8F\x74\x8B\x16\xAF\x11\x1F\x2C\x90\x88\x07\x07\x2F\x91\x6D\x67\x5E\x3B\x94\x21\x3D\x02\x1F\x9D\x0C\xCC\x8C\x5C\x1B\x02\xCA\x56\x74\x03\x04\x02\x96\x10\x7D\x8C\x00\x13\x7A\x4D\x6A\x01\x08\x93\xBA\x5C\x6E\x08\x04\x93\x82\x8F\xDC\x81\xCD\x4F\x01\x29\x94\x10\xDD\x4F\x5B\x05\x67\x4E\x95\x1C\x93\x7C\xAC\x3C\x25\xB2\x7C\xBB\x35\x04\x5F\x97\x46\x88\x27\x33\x2D\x01\x65\x91\x45\x8C\x37\x9D\x06\x47\xB7\x87\xEC\x73\x02\x6E\x92\xFB\x7A\x2A\xA3\x06\x47\x80\x89\xA1\x53\x11\x29\x02\x9D\x87\x89\xC2\x19\x15\x36\x90\xED\x84\xF8\x1A\x30\x0C\x16\x93\x59\x6A\x69\x30\x04\x1F", - "\x91\x11\xC6\x92\x0D\x08\x94\x56\x16\x16\x3E\x91\x8C\x81\x10\x8C\x08\x0F\x1F\x93\x5A\x51\x4D\x84\x95\xCD\x7D\xD4\x43\x00\xA6\x86\x1D\xC4\x02\x53\x85\x91\x99\x8D\xDB\x4A\x03\xA7\x96\x88\xA2\x95\x49\xA4\x7D\x34\x71\x05\x27\x94\xBB\x34\x06\xA9\x90\x4B\x80\x45\x2B\x5E\x2A\x9B\x44\x37\x03\x94\xA3\x93\x28\xB8\x4B\x2F\x05\x2B\xF3\x53\x38\x18\x95\xAA\x90\x12\x64\x3E\x33\x00\x29\x90\x08\x1B\x16\x93\x83\x1E\x32\x32\x87\x5C\x9D\x18\x2F\x16\x1B\x05\x96\x0C\x0C\x0E\x08\x97\x89\x05\x1A\x4B\x95\xB0\x83\x8B\x67\x26\x0E\x10\x96\x83\x0C\x07\x53\x94\x44\x13\x0D\xD6\x92\x56\x98\x2A\x4B\x5B\x2D\x83\x08\x21\x1E\x96\x0C\x0A\x38\x21\x97\xF5\x89\xD2\x2F\x16\x21\x05\x97\x02\x0C\x11\x28\x96\xBC\x5F\x3E\x6C\x96\x4B\x0F\x15\x8E\x05\x57\x80\x01\x4A\x03\x2F\xC3\x67\x81\x09\x57\x29\x06\x31\x9A\x31\x4B\x06\x27\x92\x8C\x11\x26\x16\x01\x98\x03\xA7\x22\x4D\x00\x2F\x80\x00\x28\x16\x93\x9D\x8D\x4F\x9C\x0F\x4E\x77\x46\x21\x05\xC3\x87\x05\x10\x9E\x4A\x09\x99\xD4\x87\xEC\x28\x05\xC3\x8E\x05\x19\x9E\x74\x1B\x99\xD9\x87\x46\x2F\x05\xC3\x95\x05\x21\x9A", - "\xAB\x23\x99\xDD\x87\x46\x36\x05\xC3\x9C\x05\x29\x9C\xDD\x2B\x99\xE1\x87\x46\x3D\x05\xC3\x83\x06\x31\x9B\x13\x6A\x01\xE5\x86\x0E\x86\x08\x31\x16\x93\xD0\x8D\x23\x01\x11\x24\x9C\x10\x3B\x9B\x15\x9D\x6D\xC9\x00\x68\x96\x12\x0A\x00\x36\x46\x98\x18\x8D\x6A\xCE\x05\x61\x86\x17\x0C\x05\x2F\x80\x02\xD3\x89\x83\x0E\x92\x6A\x89\x25\xAA\x97\x35\xF2\x81\x85\x9A\x9A\x4A\x1D\x04\x1C\x9A\xEE\x09\x7A\x64\x3C\x38\x00\x9B\xC2\x1B\x05\x23\x9A\x88\x07\x90\x4D\x6A\x39\x0A\x9A\xA6\x19\x06\x0D\x9A\x03\x94\x7E\x6B\x04\xDA\x82\x1B\x6D\x13\x5D\x96\x9B\x06\x9D\xD4\x71\x07\xDD\x84\x22\x3C\x03\x6D\x8C\x09\x4C\x8D\xD4\x77\x07\xDF\x94\x1E\x42\x02\x70\x86\x09\x50\x89\xE6\x7D\x07\xE1\x96\x27\x48\x02\x71\x83\x08\x9B\x4D\xD4\x03\x00\x17\x1A\x9B\xC3\x3A\x72\x82\x08\x58\x89\xE6\x09\x03\xE5\x9B\x87\xEC\x34\x0A\x1A\x9C\x00\x00\xAB\x46\x93\x03\x1F\x9C\x5D\x94\xDD\x0E\x16\xCB\x75\x34\xBE\x84\xF9\x36\x00\xA8\x9D\x21\xB3\x53\x30\x03\x3A\xC5\x85\x9A\x7C\x00\xB1\x9F\x4D\x9B\x45\x33\x03\x3A\xC5\x91\xCF\x9C\x6A\xB9\x9E\x71\x5B\x43\x81\x14\x34\x86\x09\xD7", - "\x82\x08\x50\x91\xCD\x67\x01\xE0\x91\x34\x93\x0A\xC3\x05\x9E\x03\x0F\x78\xAC\x56\xE6\x71\x3C\x80\x96\xD8\x17\x03\x07\x15\x9C\x52\x9E\x31\x9A\x11\x8C\x0B\x0C\x15\x9E\xCA\x49\x7B\x93\x08\xE9\x90\xDE\x69\x72\x0E\x01\x9E\x89\x92\x78\x3A\x18\xBD\x92\x3D\xF3\x92\x91\x80\x02\xE8\x9C\x80\x63\x9D\x3D\x90\x1A\x46\x00\xF8\x8D\x60\xFF\x93\x7C\x85\x94\xF2\x3D\x04\x71\x9E\xE9\x1A\x04\xA3\x9D\x51\xBF\x9C\x81\x03\x05\x7E\x9E\x56\x35\x1B\xEC\x9D\x36\x67\x23\x2C\x07\x3F\xDA\x2A\x29\x02\x9F\x10\x0A\x7A\x94\x94\x3E\x9F\xA5\x0D\xA0\xBB\x2E\x05\x10\xA5\x75\xA4\x95\xEC\x77\x06\x16\xA3\x26\x56\x05\x19\xA6\x78\xAB\x95\xDE\x6E\x06\x1E\xA3\x9C\x5E\x05\x21\xA1\x7A\xBB\x88\xBC\x45\x07\x26\xA3\x16\x46\x06\xF9\x99\x82\xB0\x66\x1F\x8E\x42\xC6\x17\xF2\x0C\x9D\x22\xA2\x58\xB8\x4B\x41\x06\x40\x86\x09\x22\x01\x9E\x97\x43\x74\x97\x8B\x01\xA0\x00\x0B\x05\x0F\xB5\x41\x40\xA3\x22\x19\x1F\x04\xA3\xD1\x1A\x33\x24\x07\xA2\x02\x09\x13\x09\xA2\x88\x00\x0E\x23\x9C\x9A\x7D\x6D\x9B\x00\x8A\x80\x01\x50\x03\x45\x8C\x0A\x39\x03\x9D\xFB\x79\xFB\x63\x04\x2D\xA9", - "\x0A\x5D\xA2\x41\x02\x20\x4C\xA3\x28\x2F\x15\x55\x0E\x42\xB2\x06\x19\xA3\x08\xF2\x01\x86\x8C\x09\x15\x02\x30\xE4\x3C\x2D\x01\x9E\x06\x99\x79\x7C\x14\x3A\xAA\x30\x9A\x33\x2D\x1A\xA2\xBD\x01\x78\x91\x98\xB1\x03\x31\xC7\x76\x2F\x1A\xA2\xC4\x02\x90\x96\x12\x3E\xAC\x31\xE7\x21\x31\x1A\xA2\xCB\x02\x91\xA6\x1C\x46\xA4\x32\x9A\x30\x33\x1A\xA2\xD2\x02\x92\x9A\x2A\x4A\xAC\x32\x9A\x33\x34\x1A\xA2\xD9\x02\x93\xAC\x36\x4E\xA4\x33\x95\x92\x16\xA0\x07\xA2\xA3\x13\x6C\x00\x9E\x93\x26\xE4\x1C\xF3\x96\x12\xF9\x00\x6C\x2B\xA5\xA3\x99\xFD\x66\x07\x2B\xA6\x1D\xFE\x02\x96\xB6\x5E\x0D\x3B\x0E\x5A\xA2\xB1\x03\x00\xA4\x2E\x20\x33\xA4\xF2\x8D\x37\xBE\xA4\xAF\x09\x00\xC1\xA3\x20\x03\xA7\xF6\x88\x97\x77\x06\x31\xAB\x2C\xC9\xA2\x20\x0B\xA6\xFB\x88\x97\x7D\x07\x33\xA1\x3A\xD1\xA0\x00\x13\xA6\xFF\x84\x7E\x03\x01\x17\x10\x9E\x73\x53\x03\x20\x29\x6D\xAB\xF0\x67\x20\x02\x1F\xA6\xA0\x9B\x13\x60\x01\x6C\xA4\x4E\x90\x84\x5E\x4E\x00\xE8\xA4\xC8\x4E\x58\x76\xAA\xF1\x1A\x30\x05\x11\xA7\xB2\x9B\x0B\x6C\x00\x7A\xA0\xF2\x05\x24\x3E\xBA\x9D\x73\x52\x98", - "\x3A\x9A\x72\xA4\x39\xE9\x70\x08\x1F\xA7\x77\x94\xDD\x38\x00\x7E\xAC\x10\x1C\x9D\x6F\x66\x01\x08\xA9\x7D\xA2\x1A\x1F\x0C\x50\x86\x09\xE9\x84\xA2\x2C\x00\xA1\x96\x9E\x22\x29\x4E\x38\xA2\x32\xAE\x9D\x78\x4B\x06\x11\xA8\x2B\x1B\x04\x15\xAB\x40\x16\x9D\xBD\x69\x07\x23\xA8\xD3\x19\x50\x03\xA8\x77\x1E\x9D\xAD\xA3\x20\x3F\x00\x84\xAD\x3C\x90\x0B\x15\x03\xA7\xD4\x84\xFC\x04\x02\x9A\xA6\x25\x5C\x00\x4E\xA1\x57\x4C\x8A\xA3\x96\x13\x30\x0D\x47\x65\x64\x39\xBC\x9E\x95\x96\x39\x42\xAA\xD3\x19\x06\x45\xA8\x92\x77\x57\x0C\x3B\xA5\x9A\x2B\x38\x06\x52\xF6\x87\xAB\x1D\x02\x52\xAC\xDD\x37\x03\xAA\xAF\x0F\x9B\x63\x52\xAB\x5F\x7D\x21\x5D\x64\xA6\x55\x69\xE6\x6A\x01\x56\xBB\x44\x84\x04\xAB\x82\xA1\x98\xA2\x10\x70\x03\x59\xB3\x53\x8A\x04\xAB\x93\xA0\xD0\x06\x07\x5F\xA8\xBB\x30\x04\x4E\xAF\x62\x4A\xA0\x0D\x3D\x07\x76\xAB\x26\x48\x2C\xB5\x7C\x21\x24\xA7\xE7\x48\x97\x04\x06\x5F\xB3\x53\x9A\x29\xB0\x82\xA7\x11\xA9\xFD\x0B\x07\x61\xBB\x42\xA8\x01\xAF\x82\xAD\x15\xAD\xD4\x12\x07\x63\xA6\x16\xB0\x01\xAC\x8F\xAB\xE0\x7F\x58\x17\xAC\xAF\x17", - "\x05\x9A\xAA\xAF\xBA\xA1\xA6\x60\x0A\x6F\xA8\x00\x06\x05\x08\xAB\x70\x3E\x04\xAE\xA3\x44\xEC\xA8\x00\x08\x05\xA6\xAE\x15\x29\xAD\xEE\x2C\x55\xE5\x7D\x6F\x70\x05\xA6\xAE\x16\x33\xAC\x88\x0A\x0C\x5C\xAB\x15\xB9\x7E\xB8\x06\xB4\xBE\x05\xDD\xAC\x10\x50\x04\x57\xA1\xA3\x46\x90\x18\x26\xAC\x63\x04\x5C\xDB\x08\x57\xA4\x46\x44\xA0\x19\x0F\xAD\x67\x0D\x5C\x83\x08\x37\x01\xAD\x0C\x0D\x05\x35\xA2\xBC\x41\x0D\x08\xA9\x1E\xB6\x27\xC6\x12\xBB\xBD\xA2\xF2\x34\x0D\x26\xAE\x36\x08\xA8\x83\xA1\xBB\x85\xA5\x33\x2B\x0D\x26\xAD\x38\x08\xAF\x56\x12\xBC\x8D\xA4\x0D\x32\x0E\x26\xAC\x3A\x10\xAF\xA6\x1A\xBE\x95\xA5\x5E\x66\x5A\xEF\x04\x7E\xBA\x2A\xFA\xAD\x93\xA4\x3E\x78\x06\x5A\xF6\x07\x7F\xAC\x37\x01\xB5\x94\xA4\x3F\x7B\x06\x5A\xFD\x07\x81\xBB\x44\x96\x8B\xCF\x78\x4A\xE4\x50\x5E\xBC\x14\xC5\x80\x7E\xC7\x58\x75\x55\x80\x5E\x1A\x1A\x82\x8F\x84\xBA\xB0\x93\x8C\x57\x34\x80\x66\x9F\x61\x8E\x76\x89\xA2\x1E\x3D\x82\x83\x99\xB1\x13\xB1\x62\xCA\x1A\x11\x93\xAC\x31\x38\xC4\x87\x98\x5E\x14\x03\x5B\xAD\x53\x7E\x07\x0F\xB3\x4E\x6C\x67\xCA\x87\xEC", - "\x7F\x04\x42\xB4\x22\x03\x06\x0B\x10\x09\xF4\xA6\x10\x35\xB0\x68\x87\x23\x04\x02\xC8\x96\x56\x75\x6A\x64\x86\x08\x91\xAB\x80\x2A\x87\xD8\x49\x01\x26\xBE\x90\x45\x1C\x95\xA2\x08\x4F\xB2\x20\x06\xB3\x90\x57\xEC\x0E\x03\x95\xBE\x23\xEB\x0F\xCB\x99\xB2\xED\x7C\x1D\x29\xB0\xF9\x33\x00\x5F\xB4\x8A\x17\x00\x31\xB6\x25\x5B\xB2\x41\x0F\xB1\xE4\x38\x03\x29\xB3\xEF\x7C\x66\xA6\x1D\x0D\x0C\xA5\xDD\x9E\x20\x1D\x01\x2F\xBB\x51\xD4\x1F\x38\x19\xA6\x77\xB4\x96\x86\x92\x12\x0C\x67\xD6\x11\x3A\x00\xB4\xBB\xA4\xFC\x2B\x01\x2F\xB4\xCF\x4A\x1B\x3B\x18\xAE\x06\x09\xD0\x84\xA7\x34\x73\x03\x0C\xB6\x95\x16\x07\x90\xB3\x20\x12\xB4\x66\xAD\xD4\x3B\x02\xA5\xA6\x1D\xFD\x01\xD3\x82\x09\x4D\xB4\x4D\x9D\x97\xA7\xBA\x2A\x04\x00\x05\x47\x0C\x83\x4F\x2A\x4B\x01\xA1\xAC\x35\xAC\x3C\xD4\x91\x49\x57\x12\x05\x27\xB4\xBB\x24\x34\x1E\xAB\xD4\xBC\x9B\x34\x7A\x05\x36\xB4\x48\x4A\xB5\x91\xB5\x9E\xA4\x3E\x31\x0E\x6B\xF3\x53\x07\x00\xB6\x9A\xB5\x25\x67\x22\x35\x05\x6C\xDB\x42\x09\x08\xB6\xBA\xB5\x26\x4D\x19\x66\xB1\x5E\xD0\xB4\x00\x12\xB5\x00\x06\xA1\x99", - "\x7E\x3D\x04\x6D\xB4\xB2\xB5\xB8\xB6\x17\xAE\xB5\x82\x05\x2F\xB9\x00\x56\x10\xB5\x2A\xAC\xC9\xB0\x47\xA7\x23\x45\x0D\x6D\xCA\x1B\x10\x1F\xB6\xDC\x08\xA5\x99\x7F\x49\x0D\x6E\xC2\x1E\x12\x10\xB7\xA0\x20\xB5\x6F\xB4\xAD\x21\x05\x31\xB5\x4E\xA4\x63\xFB\xB4\xDD\x0D\x38\xBD\x98\x6D\xC8\xA8\x05\xA8\x7A\xE4\xB6\x4A\x10\x38\x88\x05\x6E\xF6\x71\x96\x9D\x6D\xB2\x01\xE1\xA6\x1C\x33\x00\x69\x0D\xBB\xAA\xAE\x87\x1A\x33\x17\x35\xB6\xB1\x1F\x06\x78\xB4\x43\x0E\x9F\x44\xA3\x18\x1B\xB8\x22\x26\x07\x1E\xBA\x75\x10\x2F\x12\xBB\x7D\x50\x35\x72\x68\x6D\xE4\xA9\x6F\x74\x06\x23\xBC\x7A\x05\x04\x93\xB3\x10\x6B\xA9\x9E\xB6\xAE\x31\xBE\x9E\x0C\x04\x9A\xB2\x10\x73\xA9\x64\x04\x07\x29\xBC\xDD\x13\x05\x8A\xB3\x11\x58\xB6\xCF\xBE\x0B\xED\x01\xE8\x9B\x44\x4E\x04\x74\x8E\xBB\x06\xA6\x92\xF6\x02\xE9\xB3\x53\x52\x0D\x74\x97\xBA\x88\x73\xB0\x52\xBB\x0B\x6E\x05\xAA\xB1\x6C\xB3\x96\x8D\x7F\x02\x0C\xBE\x4A\x37\x05\x95\xB5\x74\xB3\xA2\x86\x31\x00\x60\xBC\x21\x16\xB8\x76\x3F\x0B\x64\xBA\xD3\xAB\x8A\xE4\x3A\x03\x29\xBB\x14\x70\xD4\x73\xBB\x91\x69\x2F", - "\x3C\xBE\x61\xAF\x14\x12\x06\x77\xCF\x64\x92\x7D\xBB\x56\x70\x22\x0E\x07\xBC\xB6\x5B\xD9\x7E\x0B\x00\xBC\xE5\x66\x06\x00\xBD\xC1\x15\x0D\x79\xBB\x6F\xA6\x92\x38\x00\xF1\xA3\x3D\xC5\xB3\x11\x5C\x05\xDE\xA8\xAE\x44\xA2\x08\x12\xBD\xF8\x34\x79\x90\x0B\x38\x19\xBB\xD0\xAE\xB5\x8C\x02\xC0\xBB\x76\x83\x09\x15\x1D\xBC\x0C\x0A\x1D\x2E\xBA\x86\x07\x03\x78\xB1\x52\xAA\x75\x80\xBA\xA2\x84\x22\x79\x0C\x7A\x2D\xBE\xA0\xA4\xA2\x5D\x01\xF6\x96\x12\x7C\x05\x7B\x89\xB4\x5E\x43\x03\x80\xBD\xCF\xB6\x26\x18\x49\x6B\x80\x02\xED\xB3\xB4\xBD\x6A\x0D\x01\xBF\x50\x38\x8C\x03\x0B\xF1\xBC\xB4\x69\x71\x0E\x0B\xBE\xD3\x1C\x00\x4D\xBE\x40\x0F\xBE\xA5\xB1\xCD\x78\x03\xE9\xBA\x55\x13\x02\xF5\xA6\xBE\xAC\xB7\x8C\x3F\x02\xDD\xB6\x3A\x1A\x02\x61\x58\xBE\xB3\xB7\x8C\x05\x04\xEE\xB4\xBE\x5F\xBC\xFA\xAB\x61\xAF\x14\x11\x2C\xBF\x4D\x47\x02\x6E\xBE\xB0\xB8\x4B\x93\x03\xFE\xB3\x52\x17\x06\x7F\xFD\xA4\xC5\x7A\xBF\x5B\x45\x06\x3D\xBF\x93\x7A\x61\x21\x04\x00\xC6\x16\x3C\x03\x00\xEE\x78\xDB\x67\x80\xBC\x17\x10\x0A\xC0\x35\x7A\xC3\x2F\x05\xCD\xBA\x55\x4A", - "\x00\x1A\x45\x67\xEF\xBA\x8B\x7D\x6D\x5B\x0D\x80\xCA\x1A\x14\x10\xC0\x44\x7F\x8C\x3E\x05\x0E\xC2\x3C\x59\x00\x08\xCB\x7A\x8E\xA4\xFC\x9A\x2A\x30\x07\x7E\xFF\xB5\x53\x6B\x06\x2A\xC4\xDD\x26\x03\x16\xC0\x54\xE4\x3D\x34\x14\xC0\xEC\x34\x0D\x28\x43\xD2\xB7\x7D\x8F\xB9\xF6\x79\x06\x38\xC3\x13\x75\x03\x1D\xC3\x11\x6F\xBD\xF9\x9D\x6D\xE1\x04\x04\xE2\x1A\x3F\x07\x82\xA0\xBA\x6B\xA8\x07\x4A\xC4\x88\x2C\x47\xE2\xBF\x7E\xF4\x9D\x64\x0F\x07\x41\xC3\x4E\x4C\x05\x0B\xC5\x84\xFB\x9D\x33\xB1\xC2\xD4\x1A\x21\x54\xC3\x59\x67\x46\x7E\x04\x18\xD6\x27\x9B\x07\x04\xC7\xBA\xB6\x05\x00\x60\x50\xDD\xBA\x2A\x27\x49\xEC\x90\x09\xF7\xBB\x86\xDA\x09\x03\x0E\xC3\xC3\x66\x4A\x2B\x04\x22\xC3\x87\x8C\xAE\x91\x95\x00\x78\xC6\xEF\xA6\x1C\x5A\x0C\x87\xAC\xBE\x1F\xC4\xA2\x1D\x01\x10\xD9\x66\x2B\x1D\x0B\x05\xC6\x41\x0F\xBF\xA7\x30\x2F\x65\x00\x45\xCD\x68\xC2\x1F\x59\x48\xB7\x3D\xC4\xB3\x9A\x31\x16\x04\x89\xD6\x12\x5E\x58\xC4\xE0\xBB\xB4\xA9\x73\x1A\x0A\x88\xE9\x54\x0F\x0A\xC4\x83\x1E\x1A\x27\xC1\xD6\xA7\x73\x82\x0A\x0F\x05\xC5\x13\x0D\x08\x28\xC5", - "\x89\x0D\x0D\x27\xC1\xE1\xA6\x92\x47\x00\x16\xF1\x11\x59\xC0\x11\x1F\x4F\x18\xDE\x68\x1A\x30\x0A\x3A\xC4\x86\x07\x05\x3C\xC4\x43\x0B\x07\x27\xC0\xF3\xAE\xAD\x2C\x03\x8C\xBD\x6A\x31\xC6\x08\xF2\x07\x04\xE1\xBD\x56\xC0\x00\x62\x01\x27\xD0\x33\xCF\xC3\x20\x39\x06\x2E\xC0\x11\x38\x00\x77\x16\x01\xC7\x74\x0D\x0A\xC5\xEF\xA8\x73\x4A\x1A\x37\xD0\x08\x39\x07\xD8\x6F\x02\x45\xCC\x2F\x75\x02\x22\xC3\xB3\xE9\xC5\x0F\xF1\xB0\x16\xB3\x63\xCA\x1A\x0E\x1F\xC6\xC7\x76\x0E\x2F\xC7\x9F\x3C\x2B\x77\xC4\x3A\xC7\x76\x77\x02\x11\xD4\x23\x3D\x0B\x8F\xA6\x1F\x0E\x0E\xBD\x07\xBC\x5B\x97\xC6\x52\x60\x9F\x69\x57\x41\xD7\xBD\xAE\xAC\x10\x0B\xC8\x76\x38\x00\x0D\xCA\x48\x7E\xBD\x4D\x6C\x11\x0A\xC4\x1E\xCB\x85\x0F\x00\x7C\x45\x67\x0F\xC8\xF9\x99\x7F\x4A\x0B\x91\xF5\x23\x47\xD7\xC8\x10\x0E\xF3\x24\x3E\x4F\x05\x92\xA6\x1D\x7E\x40\xC5\x21\xCE\x20\x25\x9A\xBC\x47\x0A\x2D\xC9\x6E\x87\xC9\x10\x09\x26\xF0\x21\x57\x10\x0B\x13\xCB\x26\x4F\x01\x16\xC9\x27\xF4\x9A\xBC\x48\x0B\x36\xCA\xE3\x38\xC9\x0C\x0A\x27\xF1\x96\xAE\x46\x94\x9B\x46\x0F\x08\xCA\xE8", - "\x5F\xFE\x8D\x6A\x65\x0D\x94\xF3\x52\x8E\x50\xC9\xCA\xB6\x93\x95\xCB\x2D\x4E\x04\x50\xC8\xE6\x28\x85\x3A\x5B\x2B\xC6\x16\x2B\x0E\x95\x82\x0A\x52\xD9\xB6\xAF\x15\x1C\x22\xCA\x5E\x1E\x05\x65\xC8\x00\x07\xCB\xE1\xB4\x1A\xEE\x06\x45\xCA\x00\x56\x11\x9C\x52\xC3\x49\xC8\xA4\x8D\x6A\x7C\x0B\x96\xCA\x1B\x1B\x0E\xCB\x67\xCA\xDE\x86\x93\x00\x01\x06\x78\xCA\x56\xA0\xCC\x2F\xA8\x08\x45\xCC\x10\x76\x3A\x7F\x01\x50\xD9\xCB\xC5\x6A\xC3\x12\x01\xC5\xCF\x86\xEC\x36\x21\x0F\xCC\x51\xCD\x06\xF8\x4A\x0D\x04\x99\x83\x09\x5D\xC6\x1D\xAB\x54\x25\x28\xC8\xBB\x40\xE1\x11\x0C\x09\x1D\xCC\x5A\x26\x4A\x17\x04\xF8\x4F\x99\x90\xCF\x9A\x9A\x30\x2E\x00\x35\xDD\x0E\x2B\x11\x0A\x08\xCC\x44\x0E\xC2\xD4\xC7\x06\x32\xCC\x8E\xC6\x2C\x29\x06\x6D\xDA\x26\x89\x42\x36\xED\xCC\x76\x31\x0B\x70\x4C\x47\xC7\xCB\x2E\xB9\xFB\x4A\x03\xDD\xC6\x25\x3A\x07\x6F\xC6\x08\x36\xBF\xF5\x84\xA0\xE6\xC6\x3A\x42\x07\x73\xC3\x08\x75\xC7\x28\x1C\x02\xE1\xC6\x25\x4A\x04\x6B\xC3\xCD\xFB\x35\x34\xFE\x0A\x33\x0C\x9D\x82\x57\x77\xC2\xCA\x4F\xBC\x88\xB0\x03\xF2\xCA\x55\x5E\x07", - "\x79\xCE\xCD\x41\x5F\x31\xAC\xCE\x76\x38\x0E\x6F\xCD\x66\xD7\x7D\x67\x24\x10\x33\xCF\x4D\x42\x0F\x46\xCC\x78\xC8\x0B\xF8\x93\x3F\xF3\x52\xB4\x56\x98\xDF\xCA\x28\xDD\x6D\x98\x04\x3A\xEA\x36\xD9\xC3\x38\x04\x01\x35\x6F\xCB\x44\x2F\x55\x23\x04\x05\xD8\x93\x0C\xD2\x89\x0F\xD0\x67\xCF\x16\xC4\xA2\x57\x04\xA1\x83\x0B\x2D\x16\xD0\x10\x0C\x02\x18\xD1\x6E\x3F\x2A\x39\x05\x87\xC2\x08\xC2\x00\x44\xE0\x5D\x11\xD0\x11\x4A\xC4\x35\xC4\x06\x27\xD0\x00\x0D\x06\x15\xD6\xEE\x2C\xD2\x1A\xA7\x23\xCF\x02\x40\xC0\x01\x6C\x04\xA3\xCA\xA5\xE3\x5C\xC8\x3D\x00\x21\xE0\x0D\x6D\x02\x9B\xC2\xBD\x47\x18\x5E\xC5\xB9\x48\xD0\xC8\x6A\xC2\x0E\x45\xD2\x95\x1C\x01\x3E\x62\x49\xCF\x9B\xBA\x72\x9B\x95\xC6\xD8\x03\x02\x0F\xD2\x4A\xD8\x9B\xBE\x95\xA5\xA4\xA9\x96\xCF\x53\xD3\x65\x4B\xE6\x1D\x29\x0F\xA5\xF7\x52\x86\x21\x00\x13\x25\x32\xDB\x45\x2D\x05\xA6\xFE\x53\x19\x29\x00\x69\xD6\x4C\x9B\x44\x0E\x69\xA4\xC3\xC9\xE9\x71\xD3\x82\xC2\xAB\x2A\x03\x36\xDE\xA8\x1A\x30\x06\x18\xD3\x8B\xC6\x74\x32\x02\x3E\xD5\xA9\x1E\x34\xA0\xD6\xD2\x44\x22\x0F\x04\xD4\x4E", - "\x57\x46\x28\x03\xA1\xD6\x12\x82\x03\x51\xE2\x55\xE6\x5F\xA8\xA6\x1E\x22\x12\xD4\xDA\xB0\xF2\x95\xD4\xAD\x22\x09\x12\xD5\x5C\xD2\xCE\x00\x00\x08\x00\xD4\xDE\xCC\x2B\x1A\x07\x8F\xD3\x08\x5A\xD2\x57\x6F\x15\x24\x0B\xA9\xEC\x37\x28\x12\xD4\x82\xCC\x88\x91\x03\x56\xDB\x89\x2B\x06\xA4\xD0\xA9\xD4\xC1\x0B\x00\xD4\x23\xD3\x11\x33\x05\x94\xCE\xC1\x69\x70\x0C\x3B\xD5\xE6\xCF\xAB\x9A\xCD\x53\x67\x03\xA3\xD4\x0F\x4D\x5D\xE1\xC3\x10\x29\xD6\x40\x06\xB8\xA0\x08\x0E\x09\xD6\xD3\x1B\x0C\x4B\xD4\xAA\xD0\xAA\x5B\x3C\x56\xF3\x53\x6A\x02\xA9\xB8\xCC\xA8\xC1\x04\xDA\xD3\x0B\x5D\x06\x49\xD6\x85\xFE\x09\x22\x13\xD6\x5A\x2D\x1C\x27\xD5\xD3\x0E\x85\x95\xAD\xB8\xC6\x16\xEE\x02\x52\xD1\xCF\x84\xC3\x10\x1A\x07\xBB\xDC\x15\xF6\x02\x52\xD9\xCE\x9A\x02\x0A\x68\xD4\xBB\x3E\x07\xD6\xD4\x5D\xDC\x95\x34\x7B\x0A\x7E\xD7\x26\x48\x00\x0A\x6C\x59\xC2\x08\x67\xD3\x15\xE2\xCC\x5B\x14\x05\x06\xDB\x4E\x52\x01\x84\xD7\xAD\xE9\xCE\x6B\xBD\x05\x11\xDB\x0B\x5C\x00\x8A\xD2\xB0\xF8\xCE\x86\x26\x06\x19\xDE\x58\x26\x00\x85\x60\xA4\xE6\xB8\xF9\x2F\x06\x21\xDE", - "\xC2\xA4\xD9\x8A\xD0\x77\xF8\x48\x36\x01\xD7\xE0\x00\x50\xE3\x73\x9C\x6C\xB2\xCD\x97\x19\x22\x07\xE1\xD2\x1D\x32\xD9\xD1\x34\xB3\x9D\xD8\xF9\x61\x20\xE1\xD4\x1E\x3B\xD8\x88\x08\x04\x3D\xD9\xA1\x04\xD1\x85\x79\x5C\xFE\x07\xA1\xD3\x14\x46\xD8\x4B\x6D\x97\xEF\x83\x0C\x20\xC4\x04\x02\xB5\x8C\x0B\xE0\x18\x02\x4E\xDD\x59\xD6\x5C\x0D\x3A\x00\x55\xDA\x41\x1C\xC8\x13\x06\x6B\xF7\xBB\x38\x1B\xB2\x90\x0A\x0F\x1C\x0E\x3C\x07\xD8\x55\x00\xB1\xD1\x1D\x7C\xC6\xD2\x07\xDB\xD6\x37\xD8\x58\x00\xB6\xD9\x50\x89\x8C\xDD\xC3\xB3\x3F\x04\x3B\x0C\xD9\xDE\x64\x61\xE5\xC6\xF0\x00\x02\x68\xDF\xD8\x5F\x01\xBB\xDE\xB6\xFF\xD8\x77\x19\xDB\x9E\x34\x6E\xD4\x22\x12\x04\xB8\xA6\x1D\x10\x02\xD2\x91\x0D\x04\x34\xDA\x52\xDA\x34\x69\x01\xD6\xC2\x08\x8F\xDB\x49\xE0\xD4\x17\x03\xB9\xD6\x11\x1C\x17\xDC\x00\x01\x73\xD3\xD3\xDE\x67\x03\x74\xDA\xC2\xDB\x42\x79\x05\x6C\xF5\x0C\xEE\x00\xA8\xE9\x71\x10\x06\xDD\x90\xD2\x75\xD6\x0A\x30\xD4\x7E\x4B\x00\xEC\xC9\x41\xB2\xDB\x20\x22\xDC\x99\xC2\x2C\x37\xDE\x56\x34\x04\xB9\xD8\x73\xE1\xBE\x0D\x3F\x05\x1D\xDE\xE9", - "\x1D\x04\xA0\xDB\x77\xE6\x2F\x57\x18\x06\x3E\xDC\xBB\x25\x05\xC1\xD9\x74\xFB\xB5\xDE\x62\x07\x4E\xDF\x26\x5F\x6D\x05\xD2\x78\xD4\x91\x6D\x46\xBD\xF3\x53\x2D\x11\xDE\xCA\xDC\x51\xDA\x30\x43\x0D\xBD\xDB\x40\x30\x00\xDF\x60\xCA\xC3\x10\x05\xF2\xD6\x2C\x49\x04\xFA\xCF\x85\xAF\x12\x13\x2C\xDE\x5E\x11\xDF\x59\xDE\xF4\xD1\x3F\xAF\x14\x14\x34\xDB\x05\x06\x25\x5B\x04\xC7\xCB\xDD\xEA\xB2\x02\xF3\xDE\xA5\x19\xE0\x76\xDD\xF8\xDF\x91\xE4\x39\x17\x03\xE1\xFD\x1F\xBE\x8C\x08\xAE\xC0\xD5\xC3\x06\x78\xDA\x2B\x7B\x09\xBC\xC0\xD5\x6F\x6C\x06\x12\xE5\xE9\x15\xE0\x63\xD9\xE6\x55\x07\xFE\xD6\x12\x07\x05\xCA\x7C\xDE\x93\x2E\x83\xC6\x90\x38\x1F\xE0\xA6\x1A\x02\x22\xE1\x89\x07\xC0\xC7\xC1\xF6\x6B\x07\x0B\xE2\x6C\x14\x72\x03\xE0\xB0\x1A\x31\x3D\x11\xE1\x44\x26\x04\x15\x72\x8E\xC7\xC0\xE5\xD4\x5B\x1F\x07\x28\xE2\xAB\x2F\x01\x2A\x77\xBA\x87\xE1\x72\xC6\x92\x0A\x04\x0C\x22\xCC\xD3\x19\x03\x3B\xE0\x0B\xE4\xC3\xF6\xA2\x89\xC1\x0A\x2B\x12\x04\x4E\xE0\x09\xE3\xD8\xBD\x6E\x03\x12\xE2\xFD\x04\x52\xAB\xE3\x15\xE3\x89\x1A\x31\x05\x1B\xE3\x0C\x1B", - "\xED\x5E\xE0\x00\xF7\xBA\x4D\x6C\x06\x23\xE2\x81\x03\xC2\xDA\x29\x18\x06\xE3\xB3\xDE\x62\xD4\xC7\x1F\x0B\xC6\xDA\x0C\xFE\x30\xE3\xBA\xDC\xB2\xA9\x72\x25\x05\xC7\xED\xE2\x56\xA4\xE2\x4F\xE2\x13\xE4\x3F\x2A\x0D\xC7\xD6\x11\x20\x00\xE4\x5F\xE7\xC7\x6F\x14\x30\x05\xC7\xA7\xDE\x1A\x15\xE3\x83\x1B\x11\x16\xE3\x33\xE6\xB3\x9A\x30\x1B\x0D\xE4\x13\x0E\x0E\x10\xE5\x89\x0D\xF0\x34\xE1\x13\xB2\x46\x98\xE0\x22\x02\x05\x4D\xEC\x19\x13\xE5\x1C\xE3\x97\xF9\xC9\x94\xCC\x08\x47\x04\xCA\xA2\x1A\x29\xF9\xE3\x2D\xD7\x55\x10\x04\x55\xE6\x10\x1A\x05\x2B\xE0\x3E\xAF\xE2\x7B\xF7\xD0\x0D\x3C\x09\x05\xE4\x44\x07\x05\xB7\xE3\x20\x37\x79\x25\xEC\x10\x43\x00\xE4\xDE\x0B\xA9\x05\x8E\xC8\xD4\xEA\x12\x0C\x55\x71\x39\x66\xE6\x9A\xDC\x5E\xC2\x09\x58\x0A\xCC\xDD\xCE\x33\xF3\x08\xD0\xE3\x74\xD9\x7F\x5C\x05\xC7\x94\xDD\x92\x39\xE5\x00\x01\x9B\xDB\xD3\x34\x72\x0C\x5D\xE5\xFF\xC0\xE7\xE2\xE6\x6B\xA4\x3F\x65\x06\xCE\xA6\x1C\x39\x08\xE7\x64\x9F\x55\x14\x07\x76\xEA\x55\x6D\x04\x3C\xEC\x9B\xAF\x15\x1B\x15\xE6\xD3\x16\xF8\x20\xC5\x3A\xE9\xBF\x1A\x35\x1C", - "\x34\xE7\x7F\xD7\xCF\x8C\x0A\x3B\xAD\x6A\xEE\x03\xA0\xDB\x45\x03\x04\xFC\x1C\xCB\x3F\xE0\x00\x84\x99\xCD\x77\x06\x85\xE3\xA7\x26\x7E\xFD\xCF\xE8\x8C\x9D\xB7\x40\x76\xFB\xD3\x35\x8D\xE8\x36\xE9\xDF\xE4\x39\x01\x25\x02\x8E\xEC\x2B\x22\x02\x47\xF4\x74\x3F\x4A\x32\xE3\xE8\xB5\xBB\x48\xA7\xE9\x31\xE6\x4A\xAF\x13\x03\x2B\xE8\xAA\x0D\x66\xC4\x7F\xE9\xCF\xE8\x1A\xC1\xFB\x65\x01\x99\xE3\x10\x5E\xE7\x44\xAE\xE9\x06\x0F\xA1\xF1\xD4\xD7\xAE\x02\x3C\xEA\x40\x1E\xE9\x44\x27\x08\x00\xEB\x81\x0F\xD0\x8F\xE2\x34\xE6\xBE\x46\xE9\x50\xDA\x2A\x28\x04\xFC\x4F\xE6\x05\xF9\x7E\x3F\x01\xAA\xCB\xE6\x7B\x28\x05\x55\xEB\x47\xFC\xE0\xBD\x6F\x08\x11\xEB\xD3\xD6\x2C\x1A\x80\x44\x1E\xE3\x4C\xED\x84\xF2\xD5\xB1\xE6\x25\x6B\x00\xF1\x68\xEB\x02\x0F\xA1\xEE\xE0\x23\x9B\x05\x51\xE8\x52\xF4\x1E\x76\x03\xA9\xF1\xEB\x1A\xE4\x7E\x64\x02\x5D\xEA\x4E\x7A\xE9\x9C\xDC\x0E\x1F\xE2\x30\x6C\xEA\xE9\x08\x04\x36\xEF\xAB\xCC\x09\x23\xE4\x44\xF7\x03\x5F\xE6\x1D\x92\x01\xB0\xCF\xE9\x79\xD0\x1A\x00\x07\x63\xFA\x2A\x9B\x02\xB2\xFB\xAA\xF2\x39\x08\x06\xEE\x56\x24", - "\x05\x6F\xEA\xB1\xE1\xCF\x33\x23\x09\x1E\xEC\xBB\x2F\x05\xA1\xE8\xA5\xF2\xE2\x50\xDD\x09\x26\xEF\x26\x5A\x05\xA9\xEF\xA5\xEB\xED\xA7\xE7\x0A\x2E\xEF\x9C\x45\x06\xB1\xE9\xA8\xFA\xE3\xDE\x61\x0B\x36\xEF\x16\x50\x06\x89\xEA\xB5\xFA\x95\xA6\x6B\x0B\x3E\xEE\xB1\x1A\x06\xC1\xEA\xB6\xED\xD9\xA6\x65\x0C\x17\xEE\x41\x0E\x06\x51\xEB\x70\x24\x06\xCD\xE6\xB6\x67\x20\x34\x0E\xEE\x03\x09\x1B\x11\xEF\x89\x06\x0D\x97\xE9\xDC\x4C\xAF\xD8\xEA\x20\x24\x07\xED\xEF\x2D\xD4\xEC\x2A\xFA\x30\xE6\x01\xBC\xEA\x62\xF2\xE1\x13\x66\xEC\x5E\x87\x23\xF1\x02\xBD\xFA\x06\xF6\xE3\xCF\x1D\x8A\x43\xFB\xDA\xE4\x3C\x1F\x3E\xEC\x03\x06\x06\x6C\x58\x44\x11\x00\x1D\x8F\x74\xC4\x02\xEE\x02\x04\x47\x74\x02\x1D\xEF\xE4\x0D\x70\xE2\x1B\x01\xF0\x11\x45\x03\xB1\x6B\x00\x08\xF2\x9E\x80\x01\x08\x01\xE1\xF6\x0E\x95\x0E\xF0\xC2\xEC\xFC\x3D\xDA\x2B\x16\x04\x04\xF3\xB1\x72\x00\x15\xF0\xCB\x8A\xF0\x22\x2D\xE1\x8D\xF3\xB1\x73\x00\x21\xF0\xCC\xA6\x3D\x14\xF3\x66\xC7\x03\x31\xEC\x0B\x18\x01\xC5\xE4\xEA\x5E\x1B\x01\x76\xEF\x44\x0E\xF1\xD1\xE0\x34\x22\x00\x19\xF6\x25", - "\x24\x02\x8D\xF0\x08\x38\xF2\x9B\xC6\x92\x16\x09\xE2\xF0\xEB\x16\x4E\x89\xC4\xE6\x20\x01\xF3\x71\xE4\xBA\xC5\xF2\x95\x17\x01\x01\xF7\xC6\xF4\xDC\xBC\x42\x04\x4E\xF2\xE3\xD1\xF2\x40\xF1\x9E\xE7\x23\x26\x06\xE5\xDA\x2B\x12\x18\xF2\x0C\x0B\xC9\xFB\xC9\x2B\x5C\xE3\xA6\x1D\x15\x1F\xF1\x61\xF6\x4E\xE9\x72\x31\x0D\xE5\xEC\x36\x17\x00\xF3\x4A\xF3\x7A\xD9\x7F\x36\x0D\xE6\x9B\x44\x1A\x10\xF3\x03\x0A\xCC\xD7\x23\x57\x18\x07\x75\xF3\x9C\x52\x03\x78\xF2\x20\x3A\xF3\x32\x20\x33\x7E\xF3\x16\x5C\x03\x81\xF0\x00\x03\xF5\x82\xAD\xDB\x0E\x06\xA1\xE6\x16\x86\x01\xD1\xC3\xF5\x4C\xD4\x44\x99\x07\xA3\xFC\x15\x90\x02\xD2\xF0\xE9\x33\x24\x0A\x29\xF0\x03\x16\x12\x9A\x05\x23\x86\xF3\x41\xF9\xD3\xC6\x90\x2C\x17\xF4\x4A\x1D\x14\x1A\xF4\x88\x03\xD4\xD4\xC7\x2E\x08\xF5\xC2\x1F\x15\x2B\xF4\x07\xEF\x2A\x46\x05\x99\xFC\x87\x68\xF1\xCE\xD1\xCC\xF2\x30\x0D\x37\xF4\xBB\x22\x06\xB9\xF1\xCF\xEA\xEA\xD7\xAA\x0D\x1E\xF6\x95\x0B\x06\x1D\x8F\xD3\xD9\xF2\xB0\xE5\x4B\xC6\xF6\xE9\x17\x06\xC9\xF2\xCA\xD8\xB8\xF2\x32\x0F\x30\xF6\xD8\x03\x07\xB3\xF6\x20\x1E", - "\xD7\xA7\xED\x0F\x56\xF4\x11\x2D\x07\xD9\xF3\x20\x04\xED\xA3\x08\x00\x67\x00\xA0\x1E\x46\xA2\xF2\xDA\xCB\xED\x57\x14\x01\x66\xF5\x7A\x16\x12\x02\x06\x4E\xA7\xDD\x41\xF4\xD9\x91\x0F\x07\x0E\xF7\x5C\xE4\xFA\xB2\xF6\x75\xF3\xDA\x9A\x32\x0A\x18\xF7\x4E\x16\x4A\x16\x00\x3B\x9A\xEC\xE9\xF0\x16\xF9\x7E\x36\x00\xE0\xDA\x12\x2B\x12\x02\x04\xF8\xBF\xEE\x2B\x0E\xDA\x2B\x02\x02\x85\xF7\x26\x56\x12\x0B\x0E\xF8\xCB\xF0\x8D\xE9\x72\x27\x04\xF1\x85\xF8\xBB\x3A\x01\x18\xFE\xE0\xDE\xD8\xAB\x6D\xF1\x9C\xF2\x9D\x83\xF5\x26\xD8\x2F\x66\x03\x92\xFC\x52\xA7\xFB\xC3\xE2\x08\x40\x75\xA9\x72\x02\x8A\xF6\xE4\xFD\x00\xC5\xE3\x1C\x5C\x03\xDF\xD9\xF9\x4A\xE4\x7E\x7F\x00\xCD\xF3\x08\x8A\x07\xE6\xD3\x08\x62\x99\xE4\xC2\xF7\x27\xEA\x62\x3F\xF8\x22\x17\x04\xA1\xFB\xB1\x3A\xFA\xC8\xED\x8B\x8F\x29\xE9\xCC\x08\x52\x0C\xF4\x8C\x0A\x1E\x0E\xFA\xBA\xF2\xDD\x21\x78\xA9\xF6\x10\x31\x05\xD5\xE6\x08\xE7\x95\xE8\xC2\xF4\xFC\xE8\x97\x33\x04\xCB\xEC\x08\xBF\x07\xEB\xC3\x09\x7C\x97\xD6\x93\x09\x12\x0F\xF1\x5A\x09\x18\x14\xF9\xBB\xE6\x4F\x19\x06\x9D\x9C\xC8", - "\x6F\xF9\xC7\xD1\x0C\x65\x03\xF7\xD6\x12\x28\x17\xFB\x6E\xF8\x23\xE9\x73\x69\x04\xF1\xB3\xF2\xD2\x0B\x05\x58\xFA\xDC\xEC\xDD\x7C\xE5\xF8\xD6\x10\xCA\x82\xFB\xFF\x83\xCA\xCD\x6B\x73\x0D\xF8\x85\x89\xE2\xE5\x15\x5A\xF2\xC3\x31\x07\xCA\xFA\x55\x49\x98\xE4\xF9\xFB\x6E\xD2\xC3\x3B\x07\xBE\xF6\x3A\x53\x04\xE0\xEA\x21\x6A\xF5\xB7\x44\x00\x34\x00\xF9\xC6\x14\x37\x17\xFC\x91\xF8\x22\x07\xE9\x34\x7E\x00\x2C\xFF\x14\xE6\x1D\x6F\x9F\xF3\xD2\xCB\x34\x78\x01\x36\xFC\x4D\xE0\x7D\xB0\xF8\xF4\xCB\x9D\x57\x12\x02\x3E\xFE\x67\xD6\x12\xFA\x01\xF8\xE0\xE8\xBC\x4C\x02\x46\xFD\x6A\xC6\x1D\x04\x01\x78\xA7\xDC\xE1\xF9\x22\x9A\x32\x0D\x0E\xFE\x14\x0E\x4A\x0E\x00\xE9\xF1\xF8\xF8\xDF\x19\x20\x02\xD8\xFE\xC8\xC6\x16\x0C\x01\x3C\xC6\xF0\xF5\xE2\x31\xAD\xB0\xFB\xC6\xFC\xE1\x13\x02\x5C\xFC\xEA\xEC\xF5\xC2\x12\xFD\xF1\xAE\xF7\xFA\x4D\x09\xCF\x19\x3F\x02\xD8\xFC\xEE\xDD\x09\x1B\x01\x3C\xF8\xFB\x55\xE6\x92\x68\x01\xFE\x7B\x05\x7D\x7F\xDD\x7C\x69\x67\x46\x31\x01\xE1\x7E\x95\x09\x04\x01\x4F\x1E\x7E\xE2\x7C\xEC\x46\x49\x7C\x01\x02\x86\xE6\x4C\x80", - "\x05\x83\x62\x2F\x2A\x07\x02\xF2\x7E\xE9\x01\x06\x34\x7F\xD6\x04\x5F\x78\x97\x11\x02\x19\x82\x56\x1B\x06\x1C\x80\x0E\x80\x70\x67\x46\x1B\x02\x12\x82\x56\x1D\x42\x6D\x7D\xEF\x7F\xBA\x79\xAD\x21\x80\xEC\x18\x20\x04\x02\x98\x7E\x1B\x2C\x4F\x60\x03\x9B\x22\x8A\x03\x0C\x81\xFB\x60\x71\xE4\x1E\x2E\x09\x02\xAC\x1B\x94\x00\x05\x8D\x02\xBD\x7B\xE4\x1D\x31\x0F\x03\x9B\x22\xA0\x02\x10\x85\xFF\x73\x76\xA0\x04\x34\x07\x04\xB3\x29\xAC\x02\x12\x8D\x01\x8C\x81\x91\x07\x36\x0F\x04\x9B\x21\xB8\x02\x14\x85\x02\xAB\x38\x23\x4B\x15\x86\x2C\x09\x52\x2C\x83\x12\x83\xDC\x69\x39\xF1\x02\x17\x8C\x2B\x0F\x03\xE5\x7D\x05\x8B\xB5\x2F\x0A\xFC\x03\x0D\x83\x20\x29\x01\xFE\x74\xF6\x0A\x03\xA7\x7F\x7A\x5E\x39\x50\x07\xB7\x7E\x74\x47\x1D\x88\xB7\x03\x06\x73\x83\x77\x76\x4F\x7A\x81\xC7\x7C\x44\x0E\x01\x00\x82\x01\x34\x44\x0E\x0E\x3D\x81\xC0\x60\xF9\x10\x02\x04\x82\xD9\x7D\x04\x5C\x08\x83\x0E\xF8\x00\x22\x8A\xF5\x4C\x3F\x8C\x83\xE9\x66\x03\x0F\x82\x13\x06\x00\x08\x50\x53\x7F\x64\x7D\x53\x38\x03\x0C\x82\x46\x7B\x10\x08\x09\x80\x0A\x08\x56\x91\x7A", - "\x04\x1C\x07\x48\x03\xB1\x35\x04\x0C\x82\xE4\x62\x95\x07\x0A\x90\x04\x4B\x03\xB1\x38\x04\x0C\x82\xFC\x0A\x13\x0C\x08\xA3\x59\xB1\x83\x10\x85\x62\x5B\x58\xF4\x60\xF5\x0C\x04\x28\x82\xC7\x3B\x13\x07\x0B\xA3\x78\xBE\x80\x77\x09\x0B\x81\x63\x8C\x80\x15\x14\x05\x03\x83\xA6\x0D\x13\x00\xF7\x47\x05\x55\x01\x25\x85\x47\x1B\x82\x13\x06\x33\x8A\xF7\x7E\x05\x5F\x02\x34\x86\x3A\x21\x00\xD4\x80\x44\x06\x0D\x82\x79\x44\x51\x1A\x00\x0A\x8B\x52\xA5\x81\x35\x8B\xF8\x67\x11\x74\x03\x38\x86\x3A\x36\x00\xE5\x82\x37\x82\xF9\x69\x39\x7F\x02\x3A\x89\x96\x2D\x83\x0C\x07\x37\x8C\xBB\x67\x11\x8A\x02\x3C\x8C\x6E\x0C\x01\xF4\x82\x41\x06\x0F\xA3\x79\x1A\x19\x25\x0A\x0D\x9A\x15\x57\x01\x37\x85\x0F\xA9\x7E\xD9\x3F\x27\x0A\x0F\x9B\x22\x61\x01\x3F\x83\x10\x3F\x83\x4B\x66\xB8\x2B\x10\xB3\x29\x6C\x02\x43\x82\x10\x10\x84\x10\x77\xAB\x05\x0B\x13\x84\x5B\x23\x1D\x06\x11\xB0\x0A\x59\x64\xF9\x10\x0C\x1C\x84\xC6\x0A\x20\x0F\x11\x98\x84\x8C\x79\xF6\x3B\x0C\x24\x84\xBC\x09\x23\x07\x12\xA9\x74\xE4\x1E\x35\x0C\x12\x8A\x0D\x98\x03\x4B\x8E\xFD\x5A\x18\xE1", - "\x00\x23\x8D\x00\xB3\x29\xA3\x00\x42\x5B\x13\xA0\x84\x01\x70\xF9\x1D\x0E\x33\x84\xB1\x7A\x4D\x8B\x95\x27\x11\xF8\x00\x51\x82\x36\x3A\x02\x46\x84\x03\x2F\x2A\x03\x00\xAA\x33\xFA\x72\x36\x05\x03\x06\x86\x3F\x8F\xFF\x44\x51\x0D\x01\x54\x86\x25\x14\x57\x90\x7C\x46\x80\xAD\x51\x06\x17\x02\x2A\x3F\x13\x86\x0B\xD9\x00\x42\x5D\x00\x26\x83\x0F\x80\x11\x53\x02\x22\x85\x6C\x1A\x59\x88\x16\xAF\x66\xE4\x1F\x0B\x0A\xCA\x22\x7F\xBC\x0B\x3C\x0D\x14\xB5\x20\xAF\x0A\x0E\x03\x17\x96\x09\x38\x59\x18\x86\x15\xAA\x10\xAF\x09\x11\x0C\x16\xA6\x0E\x53\x5B\xB9\x7E\x0E\x89\x44\x1A\x19\x14\x0B\x17\xA6\x0E\x15\x03\x97\x56\xE4\x58\x84\xF5\x7A\x5F\x0C\x05\x0B\x86\x5A\x14\x08\x0E\x18\xAF\x85\x44\x80\x5E\x27\x06\x03\x86\x9B\x53\x97\x57\x16\x87\x86\x3C\x80\x5E\x23\x07\x1C\x86\x0A\x56\x67\x88\x19\x90\x7C\xE2\x5C\x69\x8B\x89\x05\x01\xA6\x84\x68\x81\x9F\x6B\x46\xAA\x87\x9C\x25\x6B\x50\x04\x9F\x87\x41\x8E\x75\x64\x1F\x97\x01\x6C\x8B\x85\x1F\x01\x5F\x5B\x4F\x88\x11\x93\x2D\x4D\x37\x28\x0A\x1B\xAC\x14\xBD\x87\x69\x80\xF3\x6F\x0A\xAF\x00\x65\x86\x10", - "\x3A\x02\xAA\x33\xE0\x07\x07\x17\x86\xAE\x85\x93\x3D\x5C\x0A\x87\x03\x07\x31\x0D\x1C\x93\x04\xE3\x5A\x5F\x8F\x10\xBE\x81\xE4\x1D\x32\x04\x1D\x82\x04\xD4\x03\x75\x87\x29\x10\x87\xB6\x87\x79\x71\x13\x9F\x87\x00\x01\x38\x02\x1E\x94\x24\xE4\x87\x5F\x83\x09\x9A\x18\xE3\x00\x7A\x8E\x0E\x2B\x87\x06\x07\x28\x0D\x1E\x9B\x87\xF7\x49\x07\x2A\x1B\xBC\x03\xF4\x87\x40\x0E\x0A\x05\x87\x10\x07\x13\x0F\x0C\xB4\x04\xFE\x02\x56\x86\x3A\x3A\x02\xF7\x86\x40\x02\x20\x97\x83\xEF\x07\x1A\x0D\xFA\x7C\x0A\xC5\x01\x82\x87\x4F\x02\x7E\xBD\x36\x04\x0E\x20\xAF\x7B\xA6\x0C\x34\x00\x20\x8C\x04\x0B\x8A\x48\x66\x24\x5D\x00\x17\x89\xBE\x7A\x55\x1C\x03\x1B\x8A\x41\x0D\x21\x90\x5F\xBD\x34\x0A\x01\x22\xA4\x71\x97\x3D\x89\x83\x10\x27\x88\xD9\x5D\x6F\x33\x03\x2B\x88\x6C\x72\x95\x04\x0F\x2E\x88\x0A\x8B\xF0\x64\x7E\x3E\x00\x34\x89\x23\x85\x56\x00\x5E\x46\x78\x8C\x80\xD0\x64\x1F\x48\x01\x8F\x84\x17\x8A\x0D\x0B\x00\xE0\x5F\x13\x82\x89\xF0\x5F\x19\x13\x05\x06\x89\x75\x12\x92\x83\x11\x0C\x89\x11\x75\x6F\x3E\x05\x10\x89\xAD\x3A\x94\x81\x20\xA1\x84\x78\x25", - "\x1A\x08\x25\x82\x71\x5A\x88\x87\x8B\xFC\x4D\x35\x74\x03\x97\x8C\x6E\x3B\x00\x61\x8A\x89\x80\x13\xB8\x25\x7F\x02\x99\x8B\x89\x07\x01\x69\x8B\x8B\x8B\xE9\x5A\x18\x8A\x01\x8F\x83\x16\x8B\x1F\x80\x5D\x6D\x8A\x26\x81\x85\x78\x26\x25\x0E\x26\xB3\x29\x60\x01\x9C\x89\x23\xB0\x7F\x15\x4F\x9F\x8B\x85\x2C\x01\x82\x8B\x84\x89\x6F\x68\x3C\x3D\x8A\x54\x84\x44\x1B\x5F\xDA\x87\xA0\x83\xC7\x38\x2B\x8D\x8A\x95\x03\x08\x00\x89\x53\x8B\xB0\x74\x8D\x40\x03\x76\x8A\x95\x0E\x08\x00\x5E\x0E\x01\xA6\x89\x16\xAE\x56\xCC\x01\xA7\x86\x3A\x1C\x02\xA0\x8A\xA8\x80\x17\xAE\x6C\x86\x8A\xB1\x0A\x0A\x09\x8A\x4C\x8B\xB6\x70\x1A\x23\x03\xAD\x88\xAF\x06\x0B\x30\x8A\x83\x77\xAB\x0E\x0E\x26\x8A\x5A\x16\x30\x09\x27\xAA\x8A\xE6\x13\xAB\x0A\x0F\x35\x8A\x5F\x30\xAE\x85\x03\xA7\x11\x05\x00\x1B\x01\x29\x9B\x21\xDB\x02\xB1\x81\x1A\xA5\x3E\xCA\x89\x8D\x06\x25\x27\x03\xA9\x8B\x96\x87\xF0\x46\x49\x1C\x01\xB4\x80\x2F\x16\x09\xF5\x01\xB5\x82\x26\x94\x81\x7E\x04\x0A\x0A\x2D\x81\x7C\xA6\x0F\x00\x0A\x88\x61\x8A\xD6\x8A\xC6\x7D\xDB\x34\x00\xE3\x8B\xC2\x79\x70\x27", - "\x8B\xC0\x8A\xEE\x69\x88\x2D\x8B\x15\x7E\x4B\x6A\x88\x7A\x89\x72\x8A\x20\x78\x97\x0C\x01\xF4\x8B\x9D\x8A\x34\x2C\x00\xF7\x89\xBC\x87\x1C\x97\x29\xF4\x8A\x91\x73\x06\x34\x8B\x83\x0D\x0E\x0A\x88\x4B\x89\x11\x6B\x19\x15\x06\x05\x8C\x13\x04\x1C\x08\x30\xB1\x62\x0B\x8E\xC0\x80\x00\x1A\x68\xAE\x56\x1C\x00\x31\x95\x15\x13\x8C\x44\x01\x05\x15\x8C\xE9\x88\xD4\x7A\x61\x3F\x01\x1B\x8C\x43\x0A\x08\x1D\x8C\x0C\x05\x17\x00\x32\x9F\x8B\xEF\x84\xF9\x1C\x08\x25\x8C\x06\x07\x25\x08\x32\x86\x04\x69\x03\xCA\x8B\x27\xBB\x72\xE4\x1D\x26\x0D\x2F\x93\x04\xA5\x03\xCC\x83\x10\x2E\x63\xB4\x87\x44\x00\x05\x03\x88\x1E\x07\x29\x04\x2F\x8E\x8A\xD4\x0E\x20\x0A\x88\x46\x79\x43\x8C\x83\x8A\x15\x31\x02\x47\x8C\x01\x3B\x34\x82\x8D\x14\x89\xF6\x3B\x0B\x30\x8C\x7F\x56\xCD\x8E\x56\x27\x83\x1F\x6C\xD6\x83\xA7\x24\x02\x5A\x8D\x72\x0F\x0E\xBD\x36\xD1\x02\xD7\x8B\x85\x3D\x64\x86\x87\x50\x09\xF9\x64\x1F\xDC\x02\xD9\x85\xC4\x21\x8D\x53\x46\x8E\x88\x97\x27\x03\x51\x8C\x21\x23\x35\xAE\x04\x08\x86\x91\x41\x0F\x2E\x8D\xBC\x0B\x34\x00\x37\x8D\x8D\x06\x74\x1B", - "\x8C\x37\x8A\x0D\xDF\x03\xDF\x8B\xFB\x7D\x36\x07\x01\x1B\x0B\x2C\x86\x0B\xEB\x02\xE1\x8E\x7F\x64\x1F\x12\x02\xE2\x88\x21\x93\x70\x8E\x8C\x01\x64\x7E\x1D\x00\x92\x8E\x88\x8C\x6E\x03\x00\xB2\x67\x4F\x80\x38\x8B\x60\x1A\x18\x0A\x09\x39\xAC\x88\xC6\x3D\xE7\x84\x35\xB7\x84\xE4\x1F\x0C\x03\x3A\xAE\x8B\x5A\x17\x06\x02\x9B\x78\x8B\x62\x8C\x9F\x8D\xD4\x3F\x00\xAB\x8E\x1D\x76\x3A\x28\x00\xA6\x8C\xDE\x84\x28\x9A\x18\x4A\x01\xED\x87\x24\x82\x0F\x34\x01\xEE\x8A\x36\x8B\x8A\x1A\x19\x15\x05\x3B\x88\x8D\xF6\x10\x10\x02\x9B\x4C\x8D\x57\x86\x6B\x5F\x05\x07\x8F\x24\x57\xF2\x87\x3A\x86\x80\x1A\x19\x1A\x05\x3B\xBE\x8B\xC2\x0E\x15\x02\x9B\x68\x8B\xC3\x8C\xF5\x84\x7E\x35\x01\xD7\x8E\x95\x04\x06\x1B\x8F\xD3\x8E\x05\x87\x46\x01\x02\xBE\x8E\x95\x02\x07\x02\x8F\xCE\x26\x07\x89\x91\x69\x8F\xA6\x0E\x1F\x0C\x3E\x9B\x8D\x80\x87\x19\x17\x09\x21\x8F\x96\x6B\xEB\x85\x3E\xA5\x26\x12\x68\xFC\x8A\x55\x17\x02\xF3\x8D\xEC\x8C\x10\x11\x86\x6C\x06\x2B\x0E\x3F\xAE\x6A\x01\x91\xDC\x87\x2D\x84\x51\xB9\x00\xFE\x8E\xF4\x24\x8F\xBA\x8F\xB3\x89\xE6\x05\x03", - "\x0E\x90\xBB\x1D\x0B\x10\x90\xDD\x8F\x6B\x86\x83\x55\x90\x9B\x23\x32\x08\x41\xAD\x8F\xE0\x88\x5B\x0D\x0D\x1C\x90\x73\x28\x8F\x62\x48\x3B\x8F\x98\x6F\xFD\x04\x42\x9B\x21\xE7\x02\xFE\x81\x41\x92\x2D\xAF\x09\x3D\x0B\x42\x86\x0B\xF4\x02\x0B\x99\x41\xAB\x81\x67\x11\x00\x0E\x06\x0B\x8B\x0C\x03\x0E\x96\xB5\x53\x04\x68\x69\xDA\x80\x42\x97\x3F\xAF\x0A\x03\x0E\x43\x9A\x8E\x62\x27\x11\x93\xB6\x45\x0F\x80\x6A\xE7\x8C\x1D\xB8\x25\x1B\x02\x12\x95\x23\xA7\x41\x52\x91\xE0\x5F\x90\x0D\x91\x28\x90\x00\x0F\x78\x44\x51\x28\x01\x15\x96\xE4\x73\x00\x55\x93\xE0\x05\x02\x18\x91\x2F\x93\x9C\x3A\x61\x35\x00\x5E\x93\xE8\x11\x46\x93\x04\x31\x00\x19\x97\x43\xA1\x28\x67\x12\x10\x05\x45\xBF\x84\x4E\x03\x1A\x97\x1A\x00\x6A\xB0\x8C\x00\x01\x05\x3E\x0B\xC7\x38\x14\x05\x45\xA3\x59\xC6\x0A\x14\x0A\x35\x3D\x58\x32\x5A\x1E\x5A\x34\x13\x01\xDC\x04\x93\x8C\xB7\x45\x92\x15\x5A\xD2\x04\x05\x3C\x91\x67\x11\x14\x05\x45\xB5\x54\x5A\x17\x23\x97\xA4\x04\x92\x4A\x0E\x15\x05\x45\x8F\x29\x62\x0D\x15\x04\x34\x9D\x04\x5A\x01\x15\x98\x3C\x9D\x04\x4A\x00\xA0\x66", - "\xE4\x5E\x92\x4E\x8F\x51\x04\x06\x22\x92\x56\x09\x15\x06\x4A\x9F\x22\x55\x8E\x91\x4E\x06\x29\x91\xA6\x0E\xB0\x62\x44\xA6\x5E\x5C\x8C\xF9\x19\x07\x34\x92\x5A\x14\x1B\x0E\x46\x86\x04\xA8\x90\x43\x0A\x92\x45\x56\xBC\x90\xBB\x18\x07\x3F\x92\xB8\x92\x99\x64\x7E\x0F\x02\xC5\x90\x5A\x58\x4C\x82\x04\xC1\x92\x41\x0D\x36\x69\x39\x9A\x00\x2B\x96\x3A\x10\x02\xAF\x90\x44\x01\x4D\x8B\x6F\x9C\x79\x33\x93\xA7\x1B\x02\xCF\x92\x53\x32\xE7\x46\x49\xAF\x02\x37\x9B\x85\x27\x02\xE1\x93\x36\x9B\xE7\x67\x11\xBA\x02\x39\x96\x2C\x33\x02\xE9\x90\x97\x8C\xDC\x6E\x93\xBC\x0B\x2F\x01\x4F\x92\x5B\xD6\x74\x3D\x9A\x34\x0B\x03\xF7\x91\x43\x5F\x2A\x1B\x03\xFA\x92\xF0\x07\x0D\x3D\x93\x16\x57\xAB\x06\x0E\x33\x91\x56\x0B\x38\x08\x47\xB0\x92\xB2\x8D\x9A\x32\x0F\x01\x94\x62\x0C\x3C\x04\x50\xA7\x54\xAF\x09\x3F\x00\x51\x84\x11\xFC\x03\x44\x9D\xAC\x2F\x0A\x08\x03\x1B\x0F\x20\x8A\x0D\x54\x6F\xB2\x8A\x4E\x8F\x49\xAF\x0A\x04\x0E\x51\xB8\x81\x17\x25\x10\x70\x4C\x9A\x8A\xA0\x68\x07\x07\x52\x9B\x8B\xA6\x0E\x07\x04\xB7\x5C\x8F\x2B\x97\xA8\x84\x8D\x68\x00\x2F", - "\x94\xB9\x8A\x55\x2C\x00\x33\x94\x43\x9B\x2A\xA9\x71\x39\x97\x14\x9A\x55\x3A\x00\x74\x6F\x4F\x83\x52\xB2\x8A\x91\x07\x0F\x01\x54\xB6\x8E\x5A\x16\x11\x05\x54\xBE\x94\x27\x5F\x19\x1A\x04\x0B\x95\xD8\x8E\xD8\x02\x05\x34\x6D\x79\x93\x48\x9C\xD8\x6E\x56\x56\x03\x52\x9F\x3B\x97\x14\x4F\x96\x36\x90\xC5\x64\x1F\x61\x02\x57\x9D\xD6\x61\x95\x0C\x07\x48\x9B\xAF\x5E\x04\x6C\x00\x55\x92\xD6\x3D\x94\x62\x97\x02\x9E\x5A\x78\x01\x6E\x96\xE9\x05\x08\x30\x95\x69\x97\x21\x61\x91\x75\x95\xE5\x24\x5E\x95\x53\xAA\x8B\xD9\x3C\x24\x0C\x57\xAC\x1B\xA1\x02\x5F\x99\x4C\xA3\x7C\x78\x24\x27\x03\x58\x9B\x22\xAF\x00\x56\x90\x55\x80\x68\xB6\x37\x62\x93\xA7\x3C\x02\x8E\x95\x5C\x9B\xDC\x69\x39\xB4\x02\x59\x90\x11\x3F\x02\x4B\x97\xE0\x09\x0C\x28\x95\x7F\x94\xCF\x78\x97\x01\x03\x9A\x95\x4D\x0D\x59\x93\x04\x1E\x73\x2D\x90\x4D\x8F\x91\x50\x4D\x69\x96\x10\x19\x03\xA7\x94\x44\x01\x0E\x20\x96\x87\x96\xC8\x84\x7E\x1B\x03\xAE\x95\x9A\x01\x5B\x8C\x04\xED\x00\x6D\x9B\x5A\xB1\x72\x2B\x19\x6E\x95\x27\x3B\x96\x06\x05\x3E\x0E\x5B\xA2\x93\xF9\x86\x0D\x72\x59", - "\x88\x08\x1C\x2F\xE0\x05\x00\x35\x71\x79\x93\x15\x0F\x49\x93\x04\x03\x00\xC7\x23\x4A\x93\x04\x12\x01\x1D\x7F\x13\x92\x97\xA9\x90\x4D\x0D\x00\x16\x97\x30\x3A\x76\x9C\x15\x71\x92\x44\x53\x05\x0C\xB1\x1F\x95\x44\x12\x0A\x00\x5D\xA3\x97\x10\x05\xEB\x6D\xDB\x22\x00\xE7\x97\x93\x7B\x5E\xB6\x54\x63\x8D\xF6\x3D\x02\x31\x97\xA6\x0C\x11\x03\x5F\x84\x63\x6B\x8C\x5E\x28\x03\x38\x97\xFC\x5B\x7E\x96\x10\x1C\x97\xA1\x7C\xF9\x13\x04\x20\x97\xA6\x0E\x17\x02\x5E\xB4\x97\x21\x30\xBE\x10\x60\xAC\x1B\x8F\x71\xD0\x8C\x60\x81\x8E\x57\x2B\x83\x9B\x89\x37\x01\x02\x9A\xAA\x37\x38\x99\x3F\x63\x02\x85\x93\xA7\x04\x02\x19\x9A\x40\x04\x60\x83\x7F\x2C\x42\x87\x9B\x85\x11\x02\x21\x98\x00\x03\x62\x93\x4E\xAF\x09\x1E\x06\x62\x86\x0B\x9E\x01\x8A\x9B\x62\x9B\x4E\xAF\x08\x21\x0F\x62\xBC\x0A\xAB\x02\x8C\x93\x27\x8B\x93\x1C\x2D\x55\x94\x44\x38\x02\x75\x70\x4D\x9A\x61\x8D\x94\x58\x53\x8D\x9A\x34\x06\x03\x3A\x9B\xEE\x84\x7E\x26\x02\x46\x9A\xF0\x03\x0D\x09\x99\xB4\x78\x6D\x18\x60\x9A\x15\xE0\x03\x82\x9C\x5F\xBB\x7A\x78\x27\x2E\x03\x65\xAC\x1B\xEC\x02", - "\x95\x93\x60\xAC\x94\x4F\x75\x31\x0D\x63\xBB\x5E\x75\x73\x03\x0C\x5E\x9E\x8F\xDC\x57\x98\x96\x3A\x07\x00\x51\x76\x99\x93\x61\xA6\x8F\x1A\x19\x37\x0D\x64\xA2\x0D\x16\x01\x54\x71\x5D\xAE\x8F\x69\x38\x3A\x03\x67\x84\x11\x23\x02\x9D\x97\x66\x91\x95\x1A\x1B\x3C\x0A\x66\x9A\x15\x30\x01\x54\x72\x64\xA2\x98\xED\x69\x9A\x3F\x0F\x3B\x99\xD4\x0E\x0F\x0E\x67\xAF\x99\x35\x5C\x10\x21\x0A\x68\x97\xEC\x13\xA3\x97\x65\x92\x90\xBD\x35\x05\x01\x0A\x7E\x98\x18\x49\x9B\x9F\x67\x98\x67\x11\x7F\x51\x01\x02\x1B\x9A\x56\x0B\x19\x0E\x69\x90\x9A\xC9\x05\xA8\x9F\xA0\x24\x9A\xA6\x0E\x1D\x07\x6A\x97\x9A\x1A\x90\x5E\x29\x03\x2C\x9A\x5A\x15\x21\x0F\x6A\x9F\x99\xB7\x84\x5E\x25\x04\x34\x9A\x40\x82\xA1\x9F\x69\x82\x04\xC0\x84\xAB\x4C\x6B\x9B\x22\xA2\x02\xAF\x98\x6A\x80\x00\x31\x7D\x9A\x3D\x05\x13\x9A\x13\x04\x1A\x01\x0A\x43\x0E\xB0\x02\xA5\x98\x6B\x84\x91\xCB\x58\xB3\x90\x11\x35\x01\xCF\x9B\x44\x0D\x0B\x12\x9B\x43\x98\xB6\x4A\x61\x37\x01\xD6\x98\x43\x02\x08\x19\x9B\xBC\x54\xB7\x98\x68\x89\x82\x85\x55\xB8\x96\x10\x0F\x02\xE4\x98\x43\x07\x0D\x26", - "\x9B\x2A\x98\xD4\x6A\x61\x11\x02\xEA\x9B\x40\x0C\x09\x2D\x9B\x06\x07\x78\x72\x61\xB0\x9A\x6E\x17\xAB\x0E\x09\x03\x9B\x02\x06\x2A\x08\x6F\x83\x04\xF1\x77\x09\x90\x11\x18\x01\xDC\x06\x15\x07\xEC\x2C\x02\xA1\x41\x2B\x86\x3A\x19\x01\xDC\x07\x8C\x9A\x68\x8C\x92\x7E\x6E\xD8\x0A\x05\x09\x9C\xC7\x3B\x2B\x01\x0A\x54\x92\xAA\x4C\x77\x00\x71\xB3\x63\xC2\x0C\x2D\x01\x0A\x5C\x92\x44\x13\x16\x03\x5D\x90\x04\xB8\x01\xBD\x9A\x63\x51\x75\x3F\x86\xC9\x9D\x5D\x9E\x04\xC3\x02\xCA\x9B\x85\x10\x78\xAA\x94\x00\x0E\x72\xA0\x83\xAE\x56\x33\x00\x70\x9B\x21\x17\x01\x8A\x79\x47\xB7\x9C\x4C\x79\xF6\x3A\x0D\x3B\x9C\xC6\x08\x09\x0E\x73\x93\x04\x40\x9E\x3A\x78\x97\x26\x03\x44\x9E\x88\x57\x74\x90\x04\x49\x9E\x1E\x4A\x61\x32\x03\x4D\x9F\xDB\x6F\x74\x8C\x04\x51\x9E\x20\x4F\x82\x32\x9C\xC6\x0B\x12\x0E\xEC\x58\x9D\x79\x8C\x11\x59\x00\x14\x4E\x9C\x9A\x3D\x17\x05\x17\x9D\x06\x05\xD6\x93\xFB\x59\x9A\x64\x9E\xF8\x88\x76\x83\x04\x59\x9D\x95\x89\xFD\x21\x00\x6D\x9E\xE9\x01\x07\x2F\x9D\x02\x05\xD6\x99\xD1\x76\x97\x75\x9E\x56\x1E\x07\x38\x9D\x36\x9F\x98", - "\x89\xE6\x39\x00\x7D\x9C\xBB\x1B\x08\x00\x9E\x59\x9C\xA5\x7E\x5A\x45\x01\x85\x9F\x5F\x58\x78\xBB\x98\x78\x25\x14\x04\x39\x79\x91\xC6\x09\x29\x09\xE2\x47\x9A\x81\x9C\x91\x99\xFD\x1E\x01\x8D\x9F\x9C\x23\x0B\x0F\x9E\x4A\x98\x5E\x2A\x06\x1D\x9E\xE6\x6C\xE8\x91\x65\x9A\x18\x76\x00\xE5\x44\x69\xB6\x13\xCD\x03\xD7\x99\x76\x8D\x8F\xD4\x61\x20\x0A\x7A\x96\x09\xD9\x02\xEB\x90\x77\xA0\x99\xA0\x04\x23\x03\x79\x81\x32\x29\x7A\x9B\x90\x76\xB6\x94\xA0\x69\x26\x0B\x7B\xA6\x0E\xF4\x01\xEF\x98\x74\x98\x6B\x4B\x98\xE9\x9F\x4B\x54\x7C\x3F\x9C\x9E\x90\x71\x4A\x9F\xBC\x08\x04\x0C\x7C\x87\x9F\xF5\x8E\x86\x1E\x0B\x03\x9F\x5A\x15\x07\x04\xF1\x58\x9E\x59\x9F\x56\x94\x8D\x4B\x03\xD0\x9E\xD2\x0B\x02\x13\x9F\x50\x9F\x58\x98\x97\x17\x03\xE1\x9E\xF0\x08\x03\x24\x9F\xBF\x9C\xA6\x99\xFD\x23\x03\xD8\x9E\x5C\x24\xF1\x7E\x9E\xAF\x9E\x5C\x94\x8D\x70\x03\xF1\x9F\x26\x24\x05\x33\x9F\xD4\x9C\x60\x96\x24\x7D\x03\xF9\x9F\x9C\x23\x06\x3C\x9F\xE5\x9D\x08\x9A\x15\x0A\x00\x73\x03\xBE\x9C\x6E\x33\x7C\x10\x04\xFD\x97\x7B\xB9\x9A\x4D\x37\x05\x09\x80\x8C\x04", - "\x94\x9C\xAF\x01\x08\x1B\x9F\xFD\x9C\x0C\x96\x86\x13\xA0\xC5\x0E\x95\x0F\x08\x18\xA0\x05\xA3\x65\x9D\xDB\x31\x00\x1C\xA2\x4E\x9C\xD2\x25\xA0\x85\x81\x80\x2C\x7E\xB5\x9F\xD4\x9A\x86\x1F\x03\x28\xA0\xF5\x88\x43\x0B\x04\x30\xA0\x83\x0E\x2A\x0B\x82\x8F\xA0\xDE\x98\xFF\x40\x83\xBF\x84\x59\x00\x0D\xA3\x11\x37\x02\x37\xA1\xDE\x98\xB4\x5A\x18\x5B\x03\x0E\xAB\x8B\x3E\xA0\x27\x19\x10\xA9\x79\xAD\x8C\x5D\x8A\x11\xA7\x6D\x88\xA1\x0C\x05\x34\x0A\x84\x99\x9D\xD3\x60\xA8\x67\x07\x30\xA0\x79\x90\x21\x00\x85\x9C\x19\x20\xA1\xCA\x8C\x1D\x1C\x01\xC7\x3A\x21\x0B\x85\x82\x2F\x6C\x66\x90\x07\xEC\x08\x02\x30\xA0\x20\x9C\x2B\x20\x01\x27\x9C\x43\x09\x08\x30\xA0\xAB\x9D\x47\x0C\x0E\x0A\xA1\x6C\xA3\xCB\x9D\x11\x14\x02\x70\xA0\x2C\x54\x87\xA4\x97\xAE\x57\x27\x0E\x84\x93\x2B\xD8\x7C\xE6\x95\x87\x9E\x88\x44\x53\x2A\x0F\x87\x80\x33\x81\xA3\x44\x03\x88\xA8\x88\xD9\x3F\x2D\x07\x88\x9B\x22\xC5\x7E\xC1\x91\x27\x3D\x97\xA2\x43\x23\xA3\xA7\x30\x00\x89\xA3\x97\x22\x37\xB1\x42\x79\xA0\x33\x18\xFD\x79\x91\x8B\xA0\x37\x95\x21\x56\xA2\x5B\x23\x12\x09", - "\x89\x93\xA2\xB2\x7E\x41\x94\x8A\x86\x0B\x59\x03\x29\xAD\xD3\x1B\x98\x46\x4A\x3C\x0B\x8A\xBC\x0A\x67\x02\x2B\xA3\x10\x21\xA2\xE2\x6C\xF9\x1E\x0F\x33\xA2\x4A\x0D\x1D\x06\x8B\x82\x04\xB8\xA3\xA4\x6C\xB5\x74\x01\x35\x9E\xB1\x03\x08\x3F\xA2\x00\x01\x30\xAA\x78\x94\x63\x16\x00\x31\xA2\x2D\xA6\x0E\x20\x82\x24\xAF\x8A\xA8\x8E\x78\x26\x08\x0E\x8C\x9D\xA0\xA6\x0F\x27\x08\xFD\x4E\xA0\xC0\xA2\x5E\x69\xE6\x2F\x00\xD7\xA2\x09\xA7\xBD\x48\xA3\xC1\xA1\xAB\x70\xAA\x7B\x00\xE1\xA0\xEB\x8C\x6E\x3C\x02\xE4\xA2\xFD\x71\x89\x29\xA3\x4C\x95\x72\x3F\x89\x8A\xA2\xB0\x9C\xA8\x62\x05\x30\xA3\x71\xA3\x44\x07\x0D\x33\xA3\x9A\xA0\xF0\x9F\xD4\x5D\x01\xF0\xA1\x05\xAA\x34\x24\x03\xD8\x7C\x04\x04\x8F\xBE\xA3\xA0\x06\x1A\x01\x90\xB6\x88\x05\xA7\x41\xAF\x53\xA9\x39\x77\x00\x3C\xA5\x76\x9D\x04\x04\x00\x23\x82\x88\x8E\x9F\xD9\x3F\x20\x02\x91\x96\x09\x12\x02\x45\xAE\x90\x80\x9A\xCB\x93\x42\xA6\x3A\x0B\x82\x0D\xA3\x47\xAC\x3F\xA7\x11\x9C\x03\x46\xA6\x3A\x2F\x00\x1E\xA5\x3F\xA3\x40\xAF\x0A\xA8\x02\x4A\xAA\x55\x3D\x00\x2D\xA4\x2A\xAE\x7E\x86\x49\xB4", - "\x02\x48\xAE\xE5\x4C\x82\x06\xA6\x4B\xA9\x19\x8D\x35\xC1\x02\x4E\xAC\x6E\x1B\x01\x3C\xA6\x49\xA9\x6A\xA7\x11\xCE\x02\x50\xAB\x89\x2B\x01\x45\xA6\x4F\xA8\x1A\x9A\x18\xDB\x02\x52\xA3\xA7\x3B\x01\x4D\xA6\x4D\xAC\x05\x9A\x18\xE8\x02\x54\xAB\x85\x0B\x02\x8C\x80\x37\xA9\x8C\xA9\x7C\x4D\x35\x3D\x0A\x95\x86\x0B\x9A\x01\x57\xA6\x94\x88\x9B\x72\x2D\x1D\x05\x73\x8E\x00\x6A\xA7\x0F\x90\x11\x29\x02\x35\xA7\x34\xAD\x82\xA4\x1F\x10\x01\x5B\xA0\x53\xA0\x2E\x76\xA7\x12\x9E\xA1\x71\xA5\xB7\xA0\x6B\x99\xE6\x1E\x00\x79\xA6\x3A\xA1\x3D\x41\xA6\x56\x92\x41\x05\x0C\x3C\xA5\xDD\xA0\xBA\x9D\xD4\x2C\x00\x84\xA7\x4F\x88\x03\x04\xA6\x83\x0F\x34\x08\x98\x9F\xA5\xC0\x96\x86\x1A\x03\x0D\xA6\x13\x06\x11\x00\x99\x93\x04\x39\x86\x34\xAD\x97\x89\x97\x44\x88\x61\xA9\x55\x9B\xA6\xA0\x12\x59\xA0\x11\x21\x01\xDC\x06\x19\x07\xEC\x17\x01\x84\xA7\x98\x5E\x0F\x0C\x83\x50\x08\x77\x0F\x05\x07\x3B\x58\x01\x6B\xA4\x0C\xB6\x13\x63\x00\x77\x08\x9A\xA0\x9C\x2D\x58\x2F\x82\x3C\x24\x01\xA9\xA7\xB1\x39\x05\x36\xA6\xD0\x2E\xF0\x0A\x9A\x90\x04\x29\x0B\x19\x1A\x05", - "\x18\xA6\x80\x17\x64\xA7\x9C\x87\x63\x68\x34\x73\xAA\x55\x19\x85\x9E\xA6\x40\x0F\x9C\xBD\x34\x0D\x0E\x68\xAF\x47\x2A\x32\x5E\xA7\x75\xA3\x10\x2E\x97\xD9\x3F\x1F\x0A\x9D\xA6\x0E\x2A\x00\x77\xA3\xF4\x75\x97\x46\x48\x23\x03\x9E\x9A\x15\x39\x02\x79\xA0\x11\x1E\xA7\xD6\xA4\x6F\x44\x9A\x9A\x15\x48\x01\x7F\x81\x9F\x90\x04\x69\x00\x26\x9E\x9B\xBD\xA6\x62\x0C\x7C\xA2\x19\x28\x36\xEB\xA4\xBB\x1A\x04\x2E\xA7\x0C\x06\x7F\xA3\x4D\xBD\x36\xA8\x02\x74\xAC\x6E\x19\x01\xAA\x30\xE6\x9E\x9F\xA2\x30\x98\x95\x80\xAB\x3B\x44\xA8\x06\x06\x7F\xAB\x76\x99\x3F\xC1\x02\x84\xA3\xA7\x36\x01\x14\xA8\x07\x40\x8B\x84\x51\xCE\x02\x86\xAB\x85\x05\x02\x1D\xAB\x7D\xAB\x21\x50\xA5\x22\xA9\x70\x15\xA2\x88\x3B\x82\x9D\x6F\x38\x0E\x29\xA8\xBC\x0A\x70\x85\x92\xAF\xA7\x6B\x89\x58\xA0\xA3\x8A\x0D\xB2\x03\x8A\xAE\x9F\x9F\x6A\x4F\x76\x00\x06\x07\x15\xA7\x5B\x21\x30\x0A\xCA\x3D\xA4\x05\xAA\x37\xAD\xDB\x10\x00\x3F\xA8\x05\xA6\x25\x11\x03\x3A\xA9\xBC\x5F\x2A\x1D\x00\x49\xA8\x36\xA4\x65\x8D\xA9\xC4\x8C\xF9\x1A\x02\x11\xA9\xE2\xA3\x9C\x2F\x0E\x0D\xA8\xE7\xA4", - "\x96\x9D\xD4\x36\x00\x58\xAA\x60\xA3\xA7\x3D\x03\x5C\xA8\x8D\xA8\x90\x91\x06\x42\x01\x98\xA5\x45\x10\x11\x3D\x89\x04\x0D\xA5\xA8\x99\x4D\x34\x14\x0A\xA6\x98\x9E\xC6\x08\x07\x0D\xA6\xAF\xA9\x70\x98\xF9\x1E\x05\x2A\xA9\x02\xA6\xF0\x0D\x02\x3D\x88\xDD\xA4\x46\xA6\x24\x6B\x01\x7C\xAB\x93\x60\xA8\xB8\xA9\xE2\x78\x9F\x73\xA7\xA4\x54\x3D\x88\x91\xA5\xA1\x89\x9A\xBD\x36\x21\x05\xA8\xA6\x0E\x5B\x03\xA1\xA6\xA6\xAF\xA4\xA4\x77\xA4\xAA\xA7\x56\xAA\x45\xA8\x72\xA4\x1C\x6A\xA9\x63\x59\x1E\x0D\x23\xB7\x07\xFE\xA7\x26\x07\xEC\x21\x02\x6A\xAB\xE0\x06\x2C\x3A\x01\x3D\x8B\xE0\x0E\x9F\x9C\x01\xAA\x9A\x47\x03\x0A\x29\xAA\x56\x08\x1F\x0D\xAA\x88\xAA\x02\x07\x38\x07\xEC\x25\x02\xA0\xAA\x95\x0E\x07\x23\xAA\xB8\xA8\x00\x05\x0E\x07\x3B\xA6\x01\xAF\xAD\x98\x40\xAB\x97\xA8\x03\x27\xEC\x27\x02\xC6\xAA\x56\x10\x08\x08\xAB\x9D\xAA\x17\x5D\x31\x4D\xAB\xEC\x19\x20\x00\xAD\x8F\xAA\x10\x04\x3B\x07\xEC\x29\x02\xD4\xAB\x26\x22\x08\x17\xAB\x1E\xA9\x55\x17\xEC\x2A\x02\xB4\xAA\x92\x47\xAB\x89\xAB\x03\x05\x25\x0B\x70\xA5\xAB\xB5\x9B\xB9\xA1\xAD\x87", - "\x04\xC7\x3A\x2B\x0D\xAD\xB3\x29\x87\x00\xB8\xA6\xA2\x86\x04\x8B\x01\xC6\x9C\xAE\x95\x49\xEE\xA8\xB6\xAC\x10\x32\x03\xC7\x39\x2C\x03\xAF\x9B\x21\x75\x8B\x90\x51\xAC\xAB\x95\x1D\x06\x2C\x0B\xA8\xA9\x20\x77\xA8\xBA\xAD\x73\x71\xAA\x1D\x04\x30\x0B\xB0\x85\x21\x0D\xAF\xBB\xAF\x94\xA4\x1F\xCE\x03\xC4\xAC\x6E\x2D\x02\x15\xAE\xBF\xA1\x6B\x8D\x35\xDC\x02\xC6\xAB\x89\x3E\x02\x1D\xAD\xB8\xAC\x10\x39\x02\xC7\x3A\x3A\x0A\xA6\x8E\x9C\xF9\x15\x8F\x87\x70\x3E\xA7\xBA\x03\xB1\x3D\x0E\x2B\xAC\x56\x0A\x34\x0E\xB2\x81\xAB\xBB\x03\xB1\x30\x0F\x34\xAC\xA6\x0D\x35\x07\xB3\x8E\xAC\x00\x00\x2F\x07\xEC\x33\x03\x3C\xAE\x56\x18\x0D\x3F\xAC\x16\xAD\x22\x37\xEC\x36\x03\x45\xAC\xBB\x1B\x0D\x08\xAD\x1E\xAF\x40\x0E\x0C\x07\x3B\xF9\x03\xBE\xAB\x89\x1E\x03\xFD\xAA\xC9\xA6\x10\x15\x03\xC7\x3B\x3E\x06\xB5\xB3\x29\xE0\x01\xD6\xA7\xAF\xB2\x8B\x67\x11\x3F\x02\xB2\xB3\x29\xE2\x01\xA3\xA1\xAC\x9A\x02\x0F\x7B\x1D\x01\x07\xAC\x1B\xF2\x02\xD8\xAC\xA2\x9C\x06\xC7\x39\x03\x0E\xB6\xAE\xA5\x0C\x07\x03\x07\xB7\xBB\x81\x10\x04\x3D\x02\xB7\xBE\xA7\xC1\x99\x6F", - "\x31\x01\x3B\xAD\xFE\x0F\xA5\x5A\xB6\x80\xAD\xC9\x99\x6F\x3F\x01\x04\xAE\xE9\x0C\x92\x3C\xB8\x85\xA6\x52\x04\xBD\x81\xA8\xA2\x1C\xFA\xA6\xD8\x0E\x02\x0F\xAE\xAA\xA8\xAF\x0E\x9F\xAC\x62\xA0\x68\x0C\x0F\xB8\xB9\x91\x3D\x00\xE6\xA3\x11\x15\x00\x92\xAD\xB0\xA8\x31\xB3\x71\x9F\xAC\x8F\x22\xBA\x89\x3C\xA5\xAC\xD0\xAB\x45\xAE\x56\x4E\x01\xEA\xA0\x75\xAB\xAE\xDE\x4D\xEB\xA9\xB4\x9B\x51\x57\x56\xEC\xAB\xD8\x74\xAE\x06\x06\x10\x06\xBB\x91\xAD\x70\x92\x25\x7F\xB8\x98\x9E\x7A\x00\xEF\xA9\x15\x74\x8B\x8E\xAB\x40\x07\x06\x2D\xA1\xDC\x4B\xE3\xA3\x91\x93\x04\x61\x00\xBD\x88\x79\x8B\xAF\x76\xA3\x44\x08\x08\x0E\xAF\x56\x0B\x1B\x02\xBD\xBB\x22\x7C\xA0\x35\x64\x09\x3A\xAE\xEC\x19\x1F\x0F\xBB\x8A\xAF\xB9\x90\x5E\x21\x0A\x20\xAF\x9B\x23\xCB\x83\xA3\xB1\x45\xE8\xA7\x86\x68\xBE\x9F\x93\xE3\xAE\x40\x04\xBD\xB7\xAE\xBD\x37\x2E\x06\xBC\xB3\x29\xAA\x02\xCF\x82\xBF\x9C\x07\xF9\xA4\x6F\xA5\x8F\x7B\xA7\xEE\x1C\x25\xA9\xE6\x3D\x02\xEF\xAF\x16\x2C\x0A\x31\xAF\x00\x03\xFC\xA2\x4D\xAF\x0A\xCA\x00\xF6\xA6\x3A\x17\x8D\x40\xAA\x02\xB2\x8A\xB1\x84", - "\x05\xB1\xFB\x68\xC0\x92\xB0\x11\x84\x7C\x85\xC1\xBC\x0A\xD8\x03\x05\xBF\xA1\xAE\x56\xF0\x03\x06\xBA\x34\x34\x8D\xEB\xAE\xA2\x02\x4F\x8D\x4E\x22\xB2\xF0\x06\x0F\x1E\xB0\xF8\x90\xD7\x68\x07\x0A\xA0\x9B\x21\x01\x05\x3B\x9E\xA5\x18\xB0\x5A\x67\xB9\x2F\xB0\x4A\xAA\xE9\x04\x01\x33\xB0\xDC\xAC\x35\xAD\xD4\x24\x00\x38\xB2\x0B\x13\xEA\x35\x8E\xC9\xAF\xFE\xAA\x79\x86\x49\x32\x01\x10\xB9\x3B\x16\x09\xAA\x8D\x09\xB4\xBE\xA1\x9E\xB3\x8E\x12\xBD\xB8\xA6\x0E\x42\x00\x0F\xB0\x11\x35\xB0\x4E\x74\x68\x0C\x04\x12\xB1\x31\xA0\xBB\x11\x05\x35\x8E\xD3\xAD\x3D\xAF\xD4\x58\x01\x5C\xB3\xF3\xA7\x16\x60\xB1\x3D\xB0\x9C\xA9\xE6\x24\x01\x5C\xB0\x9D\xAC\x2B\x2D\x01\xB5\x8E\x9B\xA7\xC5\xB8\x9E\x91\x06\x1C\x0D\xC6\xBE\xAA\x71\xB1\x1A\xB9\xA7\xB8\x25\x80\x00\x17\xBD\xA7\xA2\x0D\x8F\x02\x15\xBC\xBE\xB7\x66\xAF\x09\x23\x0E\xC7\x96\x09\x9E\x02\x20\xB6\xC2\x95\x9F\x6A\x43\x1D\xB6\x3A\x2D\x02\x44\xB2\x1E\xB7\x92\x9A\x18\xA8\x03\x21\xB6\x3A\x3D\x02\x8A\xB3\x13\xB8\xA9\x9A\x18\xB5\x02\x25\xB6\x11\x59\xB2\x46\xB0\x43\x09\x0E\x07\x3B\xC2\x00\x17\xB3", - "\x66\x5B\x03\xB5\x8F\x7D\x05\xC3\xA6\xAA\x67\x13\x30\x0C\xC5\x99\xAE\x4A\x0C\x37\x05\x3B\x83\x0E\x35\xB0\xAC\xAE\x48\x6F\xB2\x56\x0A\x37\x03\xCB\x92\xB2\xB9\xAB\xB1\x37\x0C\x26\xB2\x56\x08\x38\x09\xCA\xBC\xB2\xC2\xAB\xB1\x38\x0C\x00\xB3\xA6\x0D\x38\x03\xCC\xB3\xB1\xA0\x13\xB1\x39\x0C\x08\xB3\x5A\x16\x38\x0B\xCC\x83\xB2\xD2\xAB\x19\x1A\x0C\x10\xB3\xEC\x1B\x38\x03\xCD\x8B\xB2\x0C\x06\xB6\xA7\x46\x0B\x03\xD8\xB3\x26\x24\x0E\x1B\xB3\x9A\xB2\x41\x0D\x07\x07\x3B\xCC\x00\x2E\xB6\x3A\x25\x03\xBB\xB0\x33\xBB\x30\x07\x3B\xCE\x02\x3A\xBA\x55\x27\x03\xED\xB0\x35\xB0\xAF\x96\x77\xE1\xB3\x9C\x29\x0E\x24\xB3\xA1\xB0\xBE\xA7\xEC\x11\x03\xF2\xB0\xBB\x1A\x0E\x35\xB3\xDC\xB0\x34\x67\xEC\x13\x03\xF9\xB3\x16\x2C\x0E\x3C\xB3\x09\xB3\x66\x7E\x20\x4E\xB2\xF5\x71\x1E\xBE\xCE\xBF\xA4\x69\x3A\x38\x00\xD1\xBF\x6B\x12\xB6\x3D\xB7\xB1\xB8\x25\xF0\x03\x45\xBB\x89\x0F\x00\x55\x92\x1C\xBA\xD1\x87\xA5\x2F\x22\x47\xB3\xA7\x20\x00\x21\xB4\x31\xB8\xB2\xA7\x11\x0C\x01\x1E\x00\x11\x2C\xAC\x33\x41\x15\x97\x70\x35\xB0\x31\xAF\x19\x1F\x00\x2E\xB4\x09", - "\x7A\xE9\x04\x03\x32\xB4\xC4\xB1\xCE\xA1\x47\x38\xB4\x38\x13\x93\x7C\xD3\x93\xB4\x54\x26\xDA\x60\xD4\x83\x04\x30\xB7\x40\x0A\x03\x03\xB5\x23\xB4\x00\x0D\x0B\x32\x6D\x47\xB5\xDB\x66\x3A\x3D\x00\x4C\xB5\x41\xB2\xB5\x87\x3B\x1B\x01\x54\xB0\xB9\xB3\x29\x40\x02\x1D\x9D\xD4\x9C\xAD\x6C\x4A\x56\xB0\xCB\x82\x0F\x72\x93\xDB\xA5\xCE\xA4\xAD\x1A\x1B\x07\x0A\xD5\xAE\xB1\x4A\x0C\x11\x05\x45\x85\xB1\x0D\xB4\x44\x0C\xB6\xA7\x11\x2D\x02\x58\xB6\x25\x14\x01\x5E\xB6\x55\xB2\x10\x1D\x02\xC7\x3B\x0B\x06\xD7\x90\x04\x31\x03\x5F\xBC\x10\x1A\x92\x66\xB5\x3F\xB0\x59\x9A\x18\x33\x03\x5A\xB6\x25\x18\x01\x6F\xB4\x31\xB9\xB8\x99\x3F\x41\x02\x56\xB9\x47\x8E\x01\x82\xB6\x41\x08\x06\x15\x91\x34\xB0\x77\x0B\x06\x15\xAE\x44\x10\x14\x05\xD9\xBB\x4E\x0D\x8E\x86\x12\x05\x12\xB6\x13\x07\x17\x0F\xD9\xB4\x0A\x98\xB4\x31\xB7\xBA\xA0\x6A\x61\x00\x69\xB0\x11\x2E\x01\xA7\xB5\xB6\x59\xDA\x84\xB5\x67\x3B\x9F\x2E\xDA\x82\x49\xB1\xB5\x25\x03\xDB\x8D\xB5\x2E\x68\xA8\x6F\x07\x37\xB6\xE2\x09\x6C\xB4\x0A\x3B\xB6\x7A\xB7\x54\x48\x2F\x4A\xB6\x10\x04\x27\x01\xDB", - "\xB3\x02\x8D\xB4\x44\x08\x06\x3C\xAF\x9C\xB6\x21\x90\xC0\x94\x0F\xFD\xAF\x2C\x27\xEC\x1E\x02\x5A\xB6\x1A\xAA\x34\x2A\x01\xDC\x07\x73\xBE\xBF\x92\xB7\xFC\xA4\x11\x1B\xD9\xB0\x19\xD1\xB5\x23\x93\xDD\xB2\x26\xC1\xA7\x19\x1F\x09\x31\xB6\xC6\x0B\x30\x0F\x47\x93\x04\x6C\x00\x77\x07\xCE\x95\x4C\xEC\xB4\xAF\x04\x0C\x2F\xB7\xAF\xB4\x77\x0D\x06\x07\x3B\xA3\x01\x7D\xBD\x0B\xB6\x13\x6F\x02\x7E\xBB\xAB\xBE\xB7\xE7\xB5\x47\x00\x07\x32\xB7\xCB\xA9\x76\xB7\x9B\x9D\x04\x72\x00\xF3\xA3\x10\x28\x02\x5A\xB5\x3E\xA0\x11\x05\x03\x55\x91\x1E\x9D\xE0\x95\xAF\x10\x07\x2C\x01\xE1\xB5\xAC\x15\xBA\xF3\x4D\xBD\xA0\x6A\xBE\x02\x56\xB6\xC6\x8C\x04\xDF\x01\x15\x98\x79\x97\xB8\x84\xA2\x6B\x5A\x0C\x22\xB8\x56\x09\x3B\x06\xE2\x9E\xB8\x29\x67\xAB\x06\x0D\x2C\xB8\xA6\x0F\x3E\x0F\xE2\xB5\x24\x02\xB1\x6F\x32\x0E\x34\xB8\x5A\x15\x02\x0B\x54\xA7\xB8\x9B\xA1\x9A\x3E\x0E\x1B\xB8\xA6\x0F\x05\x0B\x54\x96\xB8\x61\x9E\x6B\x59\x0F\x3C\xB8\xEC\x18\x09\x0F\xE3\xB0\xB8\x14\x9A\x86\x15\x00\x3B\x2A\x23\xBA\x41\x02\x03\x0F\xB9\x38\xBB\xF6\x68\x97\x11\x00\x54\xBB", - "\x16\x48\xE5\xAB\x1C\x27\xB1\x6F\x3D\x01\x1D\xB9\xA6\x0E\x13\x0F\xE5\xAD\x0A\x2D\xA9\xF6\x39\x02\x24\xB9\x5A\x14\x17\x07\xE6\x93\x4E\x35\xAB\x28\x6C\xE6\x90\x98\x6F\xBA\x40\x08\xE2\x85\x94\x67\x11\x10\x0B\xAB\x3F\xB1\x8F\x8B\x52\x9E\x95\xB7\xB9\xAA\x6B\x19\x1E\x04\x33\xB9\x9B\x23\x21\x05\xE7\x88\x18\x4E\xAA\x72\xA4\xE8\xB3\x29\x95\x03\xA1\xB0\xE8\x9B\x94\x70\x2B\xAE\x22\xE1\x8C\x04\xA3\x03\x91\xB0\xE5\x86\x04\xC9\x4D\x6F\x31\x07\x12\xBA\x56\x08\x2C\x06\xE9\x99\xB9\x6A\xB1\x6F\x3C\x07\x3B\xB9\x8C\x63\x52\x90\xD7\x8F\xBA\xD3\x4E\xBE\x34\xEA\xA6\x0E\xCD\x02\xA9\xB7\xE9\xA9\xAB\xAF\x0A\x25\x0B\xE8\xA2\x6B\x8E\xBA\xA0\xA4\x44\x62\x02\xB3\xB8\xE3\x85\xEB\x8C\xB2\x78\x26\x2B\x0B\xEA\x9A\x15\xF9\x02\x9F\xBF\xEA\x82\x04\xDE\x9C\xA8\x6B\x0B\x39\xBA\xBC\x08\x02\x0C\xB1\x00\xB9\xC7\x8A\x86\x17\x0C\x08\xBB\x26\x3B\xB2\xB3\xEC\x80\x00\x73\x01\x79\xB5\x71\xBF\xAF\x62\x0C\xAA\xB8\xB0\xA1\x32\xBF\xB9\x93\xBC\xB1\x27\xBA\x0E\xB5\x53\x30\x0E\x1D\xBB\x9B\x20\x0D\x0F\xED\x93\xBB\x84\x55\x53\x3D\x0E\x24\xBB\x73\x28\x11\x07\xEE\xA0", - "\xBA\x1F\xAD\x9A\x3A\x0F\x2C\xBB\x5B\x20\x15\x0F\xEE\xA0\xB9\x10\xA1\x9A\x37\x00\x05\x43\x7C\xB8\xF5\x04\x06\x1C\x2C\x7F\xB8\x58\xA9\xE6\x14\x00\xFC\xBA\x95\x03\x07\x00\xBC\xD3\xBB\x63\xB6\x24\x61\x00\xC5\x43\x4F\x8D\x02\x05\x43\x83\x0E\x20\x02\xED\xB0\xBB\xD2\x84\xAF\x1D\xF0\xA2\x34\x10\xBF\x44\x00\x09\x13\xBC\xF8\xB9\x0E\xA8\x97\x3D\x00\x17\xBE\x0A\x19\xF1\xAB\x06\x1C\xBC\x9A\xBA\x98\xA9\x39\x4B\x01\xC8\xB4\x8C\x63\xBC\x0C\x04\x2B\x05\xF2\xB0\xB9\x95\xA4\xF9\x19\x05\x2A\xBC\x06\x05\x19\x0C\xF2\x8B\x87\x2F\xBE\x9D\xBD\x09\xA9\x39\x67\x01\xC1\xB0\x11\x34\x01\x37\xBF\x40\x08\x0C\x08\xBC\x10\x05\xB5\xB0\x11\x3C\x01\xD6\xB9\x26\x71\xF4\xB3\x29\x74\x00\x77\x03\xD6\xB3\x95\xC5\x43\x98\x57\x0D\x1C\x2C\xF7\x05\xD3\xB0\xD8\xAD\x98\x51\xBE\x95\x08\x0D\x14\xBD\x13\x06\xD5\xBC\x10\x1D\x00\x1D\x0D\xD6\xB6\x3A\x19\x03\x5C\xBF\xCF\xBC\x1D\x16\x00\xAF\x0B\x1E\x02\xF6\x9A\x15\xDA\x01\xD9\xB1\x2D\x66\x1C\xAF\x08\x1F\x0B\xF6\x8E\xAD\x6E\xBE\x41\x0E\xF5\x9D\x1C\xAF\x09\x1F\x03\xF7\xB6\x4A\x75\xBF\x40\x07\xF7\x83\x04\x1C\x02\xA5", - "\x2B\xF7\xB3\x29\x72\x9A\xC1\xA6\xF6\x85\xA3\xE1\xA7\xE0\xBB\x85\x1E\x03\x7D\xBE\x40\x0F\xF7\x82\x95\xE4\x1C\x20\x0A\xF8\x86\x0B\xDF\x01\xE3\xBA\x54\x1C\x07\x1B\x03\xAB\x01\x08\x13\xBE\xBC\x08\x38\x06\xF9\x8F\xBE\xC2\x4D\x6F\x32\x08\x1C\xBE\x4A\x0D\x38\x0F\xF9\x9C\x07\x24\x9C\xA8\x63\x08\x24\xBE\xC2\x0E\x38\x07\xFA\x98\x4E\xD9\x3C\x21\x0C\xFA\x97\x7B\xAF\xBC\x7F\x0B\x8E\x33\xBE\x44\x10\x39\x05\xFB\xB0\x1E\xEE\x48\xEE\xB4\x3D\x25\x03\xBB\xBD\x62\x47\x01\x8A\xBE\x88\x03\xD2\xB2\x19\x16\xBE\x75\x02\x83\xB4\x1A\x45\x43\x93\xBA\x41\x07\x0E\x1C\x2C\x79\x91\xF2\xB8\xE1\x8B\x0C\xCC\xBE\x8D\x80\xFD\x93\x04\xD2\xBC\xCE\x94\x8D\x60\x02\x34\xBF\x26\x21\x00\x21\x42\x98\x9D\xF6\xB1\x74\x86\x49\xAC\x01\xF7\xB3\xA7\x0F\x00\xE0\xBC\xF6\xBD\xBE\xAE\x56\xB8\x02\xF9\xBB\x85\x1D\x00\xE9\xBF\xB5\x99\xE3\x99\x3F\xC4\x02\xFB\xB6\x2C\x2B\x00\xF1\xBC\x43\x02\xFE\x80\x84\xBC\x79\xF5\xBC\xC4\x61\x42\xD1\xBD\x92\xB4\x8D\x5B\x03\xF6\xBC\xAF\x06\x04\x39\xBF\x06\x07\xFE\xB9\xC1\xA4\x1F\xE7\x01\x01\xCE\x48\x88\xC0\x3F\x8F\x07\xB4\x8D\x73\x03", - "\x0E\xC2\xF0\x02\x06\x10\xC0\x02\x06\x02\xC4\xE8\x71\x1C\x15\xC2\xD8\x00\x07\x18\xC0\x00\x02\x06\xC9\x12\x86\x49\x0B\x00\x1F\x08\xF8\x8A\x0D\x7E\x00\x08\xCA\x01\xCB\xA3\xA0\x6B\x05\x06\x02\xCF\xA3\x5A\x14\x23\x0A\x02\xD0\x9E\x4D\x37\x08\x0F\x02\xD2\xA9\xEC\x1A\x26\x01\x0A\x5E\xA5\x1A\xC1\xA9\x74\x44\x70\x00\x37\xC1\x96\xAB\x85\x29\x02\x33\xC0\x14\xB6\xFE\x01\xC1\x62\xAB\x16\x27\x0B\x05\xC1\xA7\x9C\x91\x88\x04\xF1\xA3\x6C\x28\x00\xCA\xFE\x9E\xA9\x69\x3B\x14\x0F\x04\xCD\xBF\x03\x06\x34\x02\x05\xF2\xBF\x67\xAA\x5F\x0E\x05\x0F\xC1\xFD\xBA\x3D\x1F\x0D\x21\x42\x70\xB6\x06\xCF\x15\xBE\x05\x6B\x00\x18\xC6\x25\x2F\x03\x64\xC3\x14\xCF\x90\xBD\x36\x78\x03\x13\xC5\xE5\xB2\x05\x4C\xC2\xB6\x75\x63\xB2\xC1\x56\x09\x03\x04\x39\x61\xBF\xB9\x8B\x19\x10\x09\x2A\xC1\xA6\x0F\x06\x04\x39\x7C\xC0\x90\xA9\xF6\x3D\x09\x38\xC1\xE4\xA7\x1E\xCE\x06\xD0\x67\xAF\x09\x2A\x08\x08\xDA\x15\x38\x02\x22\xCC\x05\xF7\xA4\x44\x51\x2D\x00\x08\xCD\x95\x94\x4D\x19\xC1\xEE\xA4\x73\x97\xC0\xBB\x16\x05\x19\xC2\x8B\xC3\x46\xB1\x0B\x5D\xC2\x9B\x22\x19\x00", - "\x0A\xD3\xC2\xF1\xB9\x6F\x3C\x0D\x24\xC2\x1B\xAB\x29\xCA\xFF\xBB\x76\xD9\x3D\x3A\x0C\x0A\xDB\x21\x86\x03\x20\xC1\x0A\xC0\x9B\xAF\x0A\x3D\x03\x0B\xC6\x0B\x95\x02\x2D\xC8\x0A\xF8\x90\x1A\x1B\x00\x0D\x07\x35\x9C\x0F\x03\x30\xC8\xB7\x86\x04\xA4\x02\x24\xCF\x0A\xD5\x77\x67\x5E\x31\xC7\x97\xBA\x59\xCE\xC2\x5E\xA2\x10\x32\x02\xCA\xC1\x02\xCE\x97\x8A\xAE\xD1\xC1\x12\xCB\x02\x19\xC3\x5B\xB4\x00\x00\x0C\x15\xC3\x11\xC3\xC9\xBD\xDB\x2D\x00\xDC\xC3\x4F\x89\x03\x1C\xC3\x83\x0E\x33\x00\x0E\xD9\xC0\xF2\x98\x4F\x45\x0E\xF7\x78\xE8\xC1\xE5\x5B\x0E\xE1\xC0\x3B\xBD\x6F\x39\x04\x1C\xC3\x79\x92\x15\x01\x0F\xD0\x04\xEA\x02\x2F\xCC\x10\x36\x01\xE9\xB6\x86\x18\x05\x1C\xC3\x63\x59\x3E\x04\x39\x77\x07\x77\x01\x40\xC2\xF3\xBB\xC3\x5A\x16\x3E\x04\x39\x4E\x87\x08\xBB\x19\x1B\x05\x0C\xC4\xEC\x18\x3F\x0F\x10\xD3\x04\x78\x01\xF6\x11\x01\x44\xC4\x0B\xB9\x53\x1A\x11\xE6\x0E\x83\x0E\x17\x0C\x11\xC5\xA7\x62\x0D\x1E\x0C\x1D\x09\xC4\xA6\x0E\x76\xB5\xE0\x93\x04\x7A\x00\x77\x00\x10\xDF\xB7\xE6\xB5\x78\xB4\x3D\x3B\x01\xDC\x06\x06\xCB\x48\xBF\xB7\xD7", - "\xB8\xF5\x08\xF4\x87\xBE\x2B\x5B\x4A\xCB\xD6\x2F\x11\x49\xBC\x49\xC7\xF1\x1C\x07\x81\x01\x50\xCA\x55\x06\x0B\x7E\x00\x77\x02\x08\x06\xC5\x4D\x1D\x06\x2C\x1D\x3F\x01\xC7\x3B\x17\x04\x11\xE4\xA1\x4A\x0D\x51\xC0\x11\x10\xC5\x69\x2B\x54\xCA\x63\x7C\x0A\x4B\xC4\x44\x00\x08\x0C\xC5\x54\xC6\xF0\x03\x08\x2D\x20\xC7\x3B\x18\x03\x12\xC7\xC5\xBC\x0B\x58\xC0\x11\x39\xAB\x67\x10\x19\x07\x16\xCD\xC5\x4A\x0D\x21\x09\x47\x20\xC5\x02\x05\x19\x0A\x15\xF4\xC2\x44\xC4\x5D\xCB\xE0\x07\xC4\x13\x06\x21\x0A\x14\xFA\xC5\x32\x1C\x5F\xC0\x11\x07\x02\xCA\xBD\x02\xBC\x0D\xD8\xC1\xAA\x08\x0C\xB2\x10\x04\xC6\xD3\xBD\xAB\x07\x18\xF9\xC1\x58\xA3\x44\x0C\x18\xDA\xBF\xA0\x69\x1F\x0F\x0E\xE5\x5F\x30\xA0\xE6\x93\x19\xE3\xBF\x44\x51\x22\x07\x19\xDA\x15\x28\x01\x66\xC2\x19\xEB\xBF\xD4\x61\x25\x0F\x19\xCE\x1E\xA2\xC7\x60\xC3\xFF\x86\x49\xA1\x03\x69\xCB\x89\x04\x01\xA9\xC4\x43\x0B\x19\xFC\xBF\x78\x25\x2B\x0F\x18\xE6\x0E\x52\x01\x64\xCA\x1A\xCD\x98\x36\x3E\x6B\xC3\xA7\x1F\x01\xB1\xC6\x41\x03\x1B\xCB\xC0\x78\x24\x31\x0E\x1B\xC3\x4F\xC1\xC7\x40\x03\x1C", - "\xD9\x84\xD6\x77\x71\xC6\x2C\x3B\x01\xC9\xC7\x62\xC1\xE6\x99\x3F\xDC\x02\x73\xCC\x2B\x2F\xA1\x40\xAB\x72\xC3\x02\xC4\x51\xE8\x02\x75\xCA\x34\x17\x02\xD1\xC4\x00\x0B\x1C\xEC\xC0\x4F\x74\x3D\x0E\x1D\xC2\x0F\xA5\x01\x78\xCB\x1C\xFC\xA8\xA0\x04\x00\x0E\x07\x0A\xC6\x5B\x23\x2C\x00\x83\x9E\xA5\xCB\xC6\x0F\xCE\x5A\x4D\x00\xEF\xC4\x0C\xCF\xEB\x6A\xC7\x89\xBA\x86\x19\x01\x39\xC7\xCF\xC3\x26\x20\x0D\x3C\xC7\x55\xAA\x24\x60\x20\xE4\x8E\xEC\x1A\x37\x0A\x1B\xF2\xC6\x62\xB0\x68\x00\x03\x07\xC8\x90\xBF\x26\x2B\x0E\x0B\xC8\xC2\xC4\x1D\xBE\x17\x3B\x00\x10\xC8\x00\x01\x06\xDD\x04\xF8\x00\x0C\xA0\xD7\x8B\xC7\x67\xC0\x5B\x08\x04\x19\xC8\x1B\xCB\x44\x08\x00\x30\xA3\x1F\xC8\xF2\x98\x97\x15\x01\x19\xCB\x1C\xC2\x10\x18\x00\xF0\xA2\x66\xC6\xEB\xAE\x56\x61\x01\x8B\xC6\x25\x26\x00\x31\xCB\x68\xCC\xEB\x8D\x35\x6D\x00\x89\xCD\x66\x70\xA3\xF4\xC5\x21\xC6\x24\x7A\x01\x36\xCA\xE9\x03\x04\x39\xC8\xBB\xC7\x26\xB4\x7E\x06\x02\x45\xC8\xBF\x58\x24\xCC\xC8\xF6\x9C\xA8\x62\x09\x3E\xC8\xA6\x0F\x17\x08\x22\xFA\xC8\x94\xC1\x1F\xA4\x25\xDA\x15\x6F\x03", - "\x95\xC9\x24\xE9\xC2\xD9\x3C\x2B\x0B\x25\xEC\x1B\x7F\x02\x97\xC0\x25\xFE\x9F\x0C\x93\x98\xCB\x89\x0F\x02\x66\xC9\x85\xC9\xEF\xBD\x36\xC6\x02\x9A\xC3\xA7\x1F\x02\x40\xC8\x96\xCA\x81\x9E\x52\x72\xCA\xD6\x55\x27\xDF\xC9\xC0\xC2\xD9\x4D\x24\xE7\x51\x19\xCB\xE0\x0D\x0B\x0F\xC9\x6E\xCB\x5C\xA4\xB5\x3F\xC9\x03\x06\x3E\x01\x28\xD3\x04\xCB\x00\xA1\xCA\x1C\xD7\xC3\xD9\x3C\x3F\x08\x28\xCF\x33\x7F\x01\x61\xBB\xA3\x4E\xCA\xD2\xC6\x38\xC9\xFD\x0A\x00\x95\xCA\x7E\xC3\x10\x16\x00\x9D\xC8\xDF\xAC\x10\x27\x03\x98\xCA\x78\xCD\x0E\xF8\x25\x18\x01\xA8\xC2\x04\xE4\x00\xAA\xC9\x0A\xA6\x10\x22\xA5\xD9\xC5\x3D\xC9\xFD\x26\x00\xAD\xCA\x86\xC3\x11\x33\x00\xB5\xCB\xE0\x03\x00\x04\xA6\x5E\xA4\x22\x0A\x10\xF8\x25\x35\x01\xAD\xC3\x66\x52\x00\xC4\xA6\x1B\xAC\x1D\x04\x02\xC7\x3A\x0D\x02\x2C\xDD\xC4\x10\x06\x22\x0C\x1D\x3E\xCA\x30\xC5\x4E\xC1\x13\xC4\x11\x6C\xC4\x43\x02\x17\xD1\xCB\xCC\xCA\x41\x75\x18\xF7\x00\xB5\xC8\x62\xC0\x00\x13\x00\x22\xA8\x23\x04\x1D\x5A\x18\x42\x01\xB7\xC6\x25\x20\x00\xE1\xCB\x87\xBF\xD4\x4D\x01\xB5\xCA\x8B\xC0\x00\x2D", - "\x00\x84\xA4\xE6\x92\x2E\xED\x97\x64\x45\xBB\xC6\x6E\x71\xCB\x13\x07\xBC\xC2\x4C\xA8\x0B\xF6\xCA\xE9\x09\x04\x38\xCB\xB2\x7F\x6A\xC4\x44\x71\x01\xFD\xC8\x41\x80\x30\xDA\xCB\xF8\x73\x65\x46\x2E\xE6\x0E\x65\x01\xBA\xCC\x1B\xF8\x1D\x05\xCF\x02\xA7\x30\xE2\x0B\xE3\x90\x11\x54\x09\x11\xCC\x9B\x20\x20\x03\x31\xC3\x04\xFA\xCA\x41\x02\x77\x86\x49\xA0\x00\xC6\xC3\xA7\x0E\x02\x1B\xCD\xBC\x43\x1D\xE4\xBF\x22\xCF\x16\x2C\x09\x25\xCC\x2B\x31\x9A\xB6\x24\x78\x02\x29\xCE\xAB\x8C\x32\xDD\xCC\xD5\x7C\xF9\x14\x0C\x31\xCC\xBC\x08\x2E\x03\x33\xF4\xC0\x69\x38\x34\x05\x2B\xE5\xC8\x10\x06\x31\x0C\x2B\xF9\xCB\x46\xA9\xF6\x3D\x0D\x38\xCC\x4A\x0D\x35\x0B\x33\xC6\xC1\xBD\x35\x3A\x08\x34\xC2\x0F\xE3\x03\xD2\xCD\x04\xF8\x25\xF5\x03\xC2\xCA\x55\x31\x03\x0E\xCF\xA4\x8F\x0E\x40\x02\x8B\x8C\xAF\x0E\x0F\x19\xCD\x7B\x30\xC4\xA3\x11\x0B\x00\x5C\xCD\x0E\xBA\x55\x0B\x00\x6A\xA8\x5C\xB4\x33\xCF\x6B\x62\xCC\x44\x08\x01\x25\xCD\x38\xC3\x26\x2B\x01\x29\xCD\x44\xCF\xB4\x72\x89\x70\xCD\x42\xC3\xFD\xB7\xB6\xAD\xCC\x84\xB3\x19\x11\x03\x38\xCD\x49\xC2\xB1", - "\x09\x03\x3B\xCD\x6B\xCD\x57\x57\x46\x3D\x00\x80\xCE\xAD\xC2\x20\x6A\xA9\x5E\xA5\xE1\xC5\xEC\x8F\x75\x4A\x01\xE2\xCE\x2E\xD6\x01\x84\xCE\xF9\x9D\xD4\x16\x01\x92\xCE\xF8\x85\x39\xD1\xC9\x4F\x76\x18\x09\x38\xC0\xCD\x2B\x1C\xDD\xC1\x30\xDC\xCE\xA0\x07\x1B\x0F\x39\xD0\x6A\xA2\xCC\xC2\xC8\x26\xEE\x56\x7C\x03\xE9\xC0\xD9\x69\xCE\x14\xCE\x01\xA7\x14\x09\x02\xAE\xCC\x1C\x60\x3B\xDC\xCC\xB0\xC2\x91\x46\x09\x35\xCE\xEC\x1A\xC2\xAE\xC4\xA6\xCC\xFA\x89\x70\x8C\x3B\xDB\x22\xC1\x00\xE3\xC5\x37\xE2\xA0\xD9\x3C\x2C\x09\x39\xD0\x04\xBC\x01\xE2\xC3\x38\x10\x03\x9B\xCE\xA1\xCD\xD4\x3E\x02\xCB\xCC\x43\x0A\x0C\x0E\xCF\x13\x06\x37\x01\x3D\xFF\x6C\x67\x10\x33\x05\x3D\xC6\x04\xD8\x00\xF6\xC9\xAD\x9B\xCF\xF0\x3F\x19\x1A\x0D\x1F\xCF\x69\x0A\xF8\xCC\x10\x3A\x03\xE4\xCE\x40\x0D\xDB\x8F\x75\xE8\x00\xFA\xC2\x10\x34\x03\xEA\xCF\x3C\x33\xBC\x87\xCF\x83\x44\x5E\x26\x0F\x03\xCF\xD1\x05\x20\x06\x29\xD6\x00\x8F\xAE\x57\xAD\x08\x10\x13\x80\xC4\xC5\x93\x11\x03\xD0\x4E\xA5\x53\x35\x00\x3E\xCF\x0C\x07\x98\x55\x02\x0F\xAE\xF7\x04\x02\xDC\x10\x12\x02", - "\x05\xD0\x4E\xC3\x11\x0E\x02\x04\xD0\xB6\xC2\x14\xD4\x0F\x18\xD1\x02\xD9\xE6\x06\x00\x0C\xD2\x93\x57\x23\xD0\xD0\x17\xD0\x77\x04\x41\xDA\xD0\x68\xC6\xD2\x0F\x08\x3F\xCA\x4D\x37\x01\x01\x42\xD6\x78\xB1\x44\x09\xD0\x11\x10\x02\x19\xD1\x4F\xC2\x13\xD3\xCB\xD4\x0D\x24\x07\x2C\xC6\x78\x2F\xD2\x88\x7B\x41\xF6\x13\x27\xD0\x43\x0B\x42\xE8\xD0\x70\xC6\xF0\x03\x09\x0F\x1F\x15\xD2\x4F\xCC\x10\x14\x02\xDC\x07\x11\xD4\x44\xE1\xC5\x62\x0E\xBA\xA3\x3A\xF6\xD0\xD8\xB9\x15\xD4\x3D\x16\x02\xDC\x04\x2B\xB2\x67\x3D\xD0\x08\x09\xB6\xCC\x25\x1C\x07\x73\xB4\xD7\x6C\x45\xEA\xC4\x62\x0C\x16\xD4\xB7\xA7\x11\x0B\x03\x18\xD6\x22\x1C\xD1\x4F\xBC\x11\x18\x09\x1C\x07\x97\x01\x97\x5A\x46\xFF\xD0\x1D\x05\x26\x00\x47\xC7\x3B\x0F\x03\x1C\xD9\x42\xC2\x0F\x61\xD2\x41\x0F\x46\xCF\xD1\x5B\xC6\xD2\x0D\x47\xDA\xAD\x78\x24\x04\x0A\x47\xEC\x1B\x28\x02\x0C\xDC\x10\x1A\xD1\x63\x16\x5E\xC1\x01\x2C\xD1\x39\x3D\xB4\x1A\x17\xD3\x00\x90\xD3\xF1\x65\x18\xD5\x00\x5C\xD2\xB7\xC9\x02\x05\xB0\x7C\xB5\x63\xC7\xC0\x19\xD2\x56\x0A\x0D\x0C\x49\xEA\xCB\xA0\x07\x0A\x0C", - "\x45\xEE\xCB\x43\x03\xFD\xC7\x46\xFA\x05\x49\xD3\x0D\xDD\x11\x1D\xD2\x29\xB9\x6E\x67\x4A\xD6\x09\x51\x02\x2A\xD1\xA0\x24\xC6\xA0\x6B\x10\x03\x4B\xD5\xC9\xB6\xD0\xF9\x32\x30\xEE\x56\x4F\x03\x2E\xDA\x55\x2D\x01\xBD\xD3\x40\x00\x4B\xCB\xB0\x12\xC4\x28\xD6\x3A\x3B\x01\xA3\xD3\xC3\xC3\x2C\x42\xD3\x55\x49\x31\xDB\xD7\x95\xCC\x19\x8C\x34\xDB\x89\x16\x02\xD2\xD3\xC5\x82\x01\xE0\x6A\x7E\x02\x35\xDF\x35\x99\xD3\xC7\xD3\x40\x0B\x77\x86\x49\x8A\x02\x37\xDB\x85\x32\x02\xE0\xD2\xCB\xC4\x44\x56\x02\xE6\xD2\xB1\x00\x0C\x29\xD3\xF0\x6F\x19\x12\x0A\x2D\xD3\xBC\x0A\x33\x00\x4F\xF7\x42\xAB\x14\x17\xD0\x3A\xE6\x3D\x01\xD3\x44\x01\x4E\xE8\x7F\x01\x2C\x3D\xDA\x34\x2B\x03\xF7\xD0\x31\x4F\x2A\x07\x03\x02\xD6\xF0\x09\x0F\x05\xD4\xCC\x43\xAB\x03\x0D\x0A\xD3\x5A\x17\x01\x0E\xC9\xBE\xD2\x54\xC1\x6F\x3E\x0D\x10\xD4\xC0\x33\x44\xD6\x4C\xD6\xC8\x6C\x05\x3A\x0A\x4F\xD6\x09\x21\x00\x17\xB0\xD7\xBF\xD3\xA9\xB8\xF9\x16\x0F\x1F\xD4\x71\x4E\x48\xDE\x4F\xEA\xC8\x95\x4E\x20\x07\x02\xFA\x47\x26\xB6\x36\xDD\x37\xDA\x18\x0F\x02\x4B\xDE\x29\xF3\x29\x4F", - "\x01\x4C\xD4\x52\xE3\x7B\x34\x07\x06\x06\x53\xF1\xCD\x73\x29\x17\x0C\xC5\x9E\xA5\x24\xD7\xE3\xC0\x1A\x28\x00\x3F\xD5\xDE\xCC\x2B\x2C\x01\x3A\xD6\xE5\xC4\x13\x49\xD5\x81\xCC\xAF\x0A\x07\x0D\xD5\xA4\xCD\x64\x00\x04\x10\xD5\x8A\xCE\x56\x18\x08\x2A\xD4\xAB\xD0\x45\xBD\xDB\x0D\x01\x58\xD7\x3E\xD3\x10\x18\x02\x5C\xD7\x2D\xD2\x3B\xF4\x04\x5A\x01\x58\xD6\x25\x15\xB2\xB1\x17\x4A\xD7\x56\xDE\x04\x67\x02\x5A\xD6\x3A\x38\x02\x65\xD4\x45\xD8\x58\xA4\x89\x72\xD6\x56\x17\xCC\xBF\xCE\x32\xD7\x18\x8D\xDB\x01\x02\x79\xD4\xBB\x17\x0D\x03\xD5\x6E\xD4\xF2\xC6\x24\x4E\x02\x58\xD7\x4F\x8A\x09\x18\xD5\x83\x0E\x39\x04\x55\xD2\xCF\x69\x38\x27\x09\x58\xD3\x04\xA8\x00\x63\xD3\x11\x34\x03\x8F\xD4\xF7\xCA\x61\x2A\x02\x93\xD4\x44\x06\x0B\x16\xD6\xD4\x04\x72\xB6\x56\xE6\x87\x44\x65\x67\xDC\x10\x04\x03\xA0\xD7\x6E\x12\x5A\xF6\xD5\xEF\x77\xC7\x66\x5A\xC6\x04\xD2\x01\x6A\xD6\x10\x1E\x00\xAB\xD7\x46\xD0\x9A\x8E\x48\x81\xD7\x40\x01\x0E\x32\xD6\xCA\x52\x56\xBE\x95\x9E\x02\x85\xC7\x38\x08\x55\xDE\xCB\x3B\x00\x70\xB1\x31\x23\xCB\xE4\x1E\x3B\x03\x5C", - "\xD6\x09\x48\x02\x71\xD7\xE6\x24\xD2\x91\x05\x3E\x0F\x5A\xDB\x22\x55\x01\x6D\xDF\x5C\xF4\xCB\xC8\x8B\x20\x0F\x52\xE2\x0D\x63\x02\x75\xDA\x45\xB8\xD2\x4F\x75\x04\x0A\x5D\xF7\xD4\x5B\x21\x1C\x0E\x5D\xC0\xD7\xCA\x90\x5E\x2D\x01\x23\xD7\x01\xCB\x9C\x2F\xDB\x80\xA9\xE8\xD5\x81\x98\x97\x29\x00\xEC\xD4\x82\xCB\x89\x0D\x02\xCE\xD7\x77\xDE\x4C\xF8\x25\x34\x01\x7D\xD1\x55\xC2\xD2\xE7\xD4\x35\xD4\x8D\x40\x01\xFE\xD5\x17\xBB\x89\x10\xB8\xF0\xD7\x36\xDF\xD4\x4C\x01\x05\xDA\xBB\xC6\x0B\x01\xD8\x8F\x8C\x5E\x28\x05\x0D\xD8\x56\x08\x31\x00\x61\xD6\x8E\x78\x24\x19\x04\x61\xE6\x0E\xD2\x03\x85\xD0\x3A\xA4\x1F\x70\x03\x86\xD4\x65\x9E\xD8\x11\x63\x36\x25\x60\xE2\xD5\x02\x07\x90\xBC\x57\xF1\xD7\x06\x06\x7D\xC4\x8D\x49\x02\x22\xD8\xBB\x1D\x0F\x24\xD8\x21\x61\x40\x81\x63\xDB\x22\x0B\x03\xAE\x28\x79\xAC\xD8\x0D\xD5\xC5\x45\x60\xDE\xCB\x19\x00\xBD\xBC\x63\xC8\x4F\xAF\x08\x2B\x0F\x63\xF7\xC8\x42\xD8\x47\xDA\x15\x37\x02\x27\xD8\x13\xBB\xAB\x30\xB5\x43\xD9\x49\xD5\x1C\xCD\xD9\x46\xCB\x93\xD3\x11\x11\xD9\x73\x74\x11\x51\x0D\x37\xD8\x73\x2B", - "\x14\x0A\x63\xD7\xD9\x33\xC8\x35\x6D\x0D\x1C\xD9\x5B\x21\x18\x0F\x65\xEB\x06\x7D\xC2\x86\x19\x0E\x14\xD9\x5C\xCB\xAE\x2F\x5B\xC2\xC9\x44\x52\x3D\x04\x66\xC8\xC5\x67\xD8\x56\x1E\x54\xFD\x36\x02\x00\x21\x0B\x5D\xC4\x11\x8C\x01\x9D\xDC\xA0\x1B\xC2\xBD\x36\x03\x0A\x67\xE6\xCD\x39\xC2\x95\xD8\x66\xD5\xD5\x7E\x07\x06\x03\x68\xC0\xD5\x5B\x22\x2A\x06\x68\xF6\xD9\x6F\xD5\x47\x08\x02\x0B\xDA\x4B\xB3\x81\x8F\x68\xFF\xD9\x91\xD9\xD1\x54\x69\xD3\xB1\x5A\x16\x32\x07\x69\xC7\xD7\x6F\xC9\xF6\x32\x04\x1B\xDA\x59\xD4\xBB\x1A\x0D\x2E\xD9\x60\xD9\xF0\xC9\xE6\x0F\x01\xA4\xD8\x8A\xD0\x00\x29\x03\xA8\xDB\xA1\xD6\x58\xC4\x51\x5C\x00\xA9\xDF\x13\xA8\x01\xA4\xD8\x24\x8E\x67\xE0\xDA\x90\xD5\xF2\x56\x6B\xD9\x72\xB9\xDB\x57\x45\x0C\x7B\xD8\x90\xCA\x91\x48\x07\x3F\xDA\x10\x04\x21\x01\x6C\xE1\x68\xC3\xD9\xAA\xD4\x5A\xCD\x35\x86\x00\xB2\xD3\x41\xCB\xDB\x08\x35\xB3\xD2\x6B\xED\xD6\xE4\x1C\x25\x02\x6D\xCD\x06\xD4\xD9\xA9\x36\x6D\xD0\xDA\x38\x8C\x19\x3D\x6A\xD3\x04\xAF\x01\xB7\xD3\x10\x3E\x00\xC5\x42\x57\xAF\x09\x37\xD1\xB4\x14\xA9\xD4\x46\xC4", - "\x11\xA0\x01\x3E\x3D\x4A\xD6\xD1\xF6\x11\xBC\xD7\x6D\xFB\x82\xAE\xD0\x6D\x6C\x1D\x1C\x02\xF3\xD8\x78\xB4\x44\x22\x02\xDC\x06\x29\x07\xEC\x32\x02\xEE\xD9\xAF\x66\x6E\xF3\x29\x00\xDC\x44\x04\x0A\x07\x3B\xB5\x01\xC1\xD4\x47\xE1\x17\x2C\xD1\x9A\x36\x0B\x0E\xDC\x5A\x15\x13\x0A\xF8\xA5\x02\xDC\x07\x28\x07\xEC\x37\x02\x14\xDD\x11\xD2\x36\x02\xDC\x40\xAD\x6F\x38\x0B\x1D\xDC\x9B\x22\x13\x0A\xF8\xA7\x02\xDC\x07\x4A\xBA\x61\x39\x02\x24\xDD\x20\xD2\x3C\x28\xDC\x10\x05\x4D\xBA\x61\x3A\x02\x2D\xDF\x16\x26\x2C\x30\xDC\x0C\x06\x4F\xB9\x71\x75\xDC\x1B\x7B\x2F\x7C\x1D\x02\xAD\x67\x10\x2F\x0C\x73\xC6\xD0\x3E\xDC\x44\x0F\xD4\xB5\x4C\x43\xDE\x05\xDF\x96\x9C\x07\xA8\x02\x21\x54\x6A\xC9\xB5\xF8\xAC\xD3\xD7\xEC\x01\x03\x4F\xDE\x17\xDC\x32\x12\xDD\x67\x10\x31\x05\x75\xCF\xDC\x10\x04\x2B\x0C\x1D\x2B\x02\xFD\xD8\x0E\xD6\x4F\x2D\x02\xDC\x06\xD7\xD0\x48\xF6\xDC\xBC\x0A\x2B\x0C\x1D\x2A\x02\x61\xDE\xB4\xCD\x11\x2F\x02\xDC\x04\xD9\xD7\x76\xFD\xDC\x0C\x04\x2C\x08\x75\xCE\xBB\x5B\xDF\x1E\xD2\x36\x31\x02\xDC\x06\xDD\xD3\x77\xC4\xDD\x0C\x06\x2C", - "\x07\x77\xE4\x1F\xCA\x01\xDE\xDE\x71\xC4\x11\xB3\x00\x77\x02\x78\xFF\xDD\x4A\xDC\x43\x04\x0B\x1C\x07\xA9\x01\xDB\xDE\xF8\x5C\x07\x6A\xDC\xE3\xDA\x44\xC6\x04\xB6\x00\x77\x00\x77\xD6\xDE\xF9\xD8\x44\x07\x0B\x1C\x07\x7C\xDC\xE7\xD4\x6F\xDD\x04\xB8\x00\x77\x09\x78\xE2\xDE\xFE\xD8\xF5\x0A\x72\xC6\x04\x8F\xDC\xEA\xD2\x76\xDD\x04\x32\xDE\x41\x05\x0B\x12\xDE\x0F\xB0\x77\x09\x79\xEE\xDE\x6E\xDF\x44\x00\x74\xCC\x04\x9F\xDC\xEE\xDC\x88\x5C\x07\xA5\xDE\xEF\xD6\x3A\x3E\x02\xDC\x04\x30\x07\xEC\x0D\x03\x35\xDE\x33\x07\x70\xE6\x6F\xDC\x07\x2F\x07\xEC\x10\x03\x49\xDF\xE5\xD3\x10\x01\x03\xDC\x07\x30\x0F\xCF\x91\xDF\x9D\xDC\x43\x06\x7D\xDE\x2C\x7A\xC6\x34\x0B\x7C\xDF\x81\xDC\x06\x32\x04\x7B\xDA\x15\xC4\x01\xF1\xD7\xEC\x14\x03\x35\xDD\x35\x0B\x7C\xCF\x01\x8A\xBD\x31\x0C\x1D\x06\x03\xE3\xDC\xBB\x1E\x7E\xFC\x56\xF1\xDE\x43\x46\x7E\xE7\x11\xD7\x01\xCD\xD8\x0D\x0B\xDF\x50\x02\xE2\xB7\x0C\x2F\xDF\xF5\xDF\x9C\x2F\x7F\xF4\xDF\xC2\xDE\x5E\xD1\x71\xFD\x36\xDA\x00\xF6\xD4\xED\x0A\xBE\xC9\x00\x77\x02\x0C\x07\x3B\xDB\x02\x02\xE9\x7A\xF6\x13", - "\xE2\xDC\x44\x08\x0C\x01\xE0\x5B\x23\x32\x0C\x1D\x25\xDF\x05\xE0\xBB\x1C\x0C\x29\xDC\xC7\x38\x37\x0F\x7D\xFC\x0A\x52\x02\xE2\xBF\x81\xF1\xDC\xC7\x3A\x37\x03\x82\xC7\x92\x26\xE0\x77\x0A\x73\xE6\x4D\x2B\xE2\xF0\x04\x05\x2D\xE0\xCC\xCF\xB1\x32\x0E\x31\xE0\x9D\x90\x0D\xEC\x10\x07\xDD\x24\x18\x0E\xE4\x44\x16\x01\x3A\xE3\x73\x77\xEC\x26\x03\x12\xE3\xEB\xD3\x11\x27\xE0\x0C\x04\x58\xBA\x61\x27\x03\x45\xE1\xEE\xD2\x78\x5C\x07\xD4\x02\x5E\xC8\x0E\x3E\xE0\xD4\x0F\x33\x05\x18\xEA\x03\xA4\xDA\xB7\xC7\x05\x3E\xBC\xF9\x14\x72\xD4\x35\xD9\xE1\xE2\x8C\x17\xE6\x10\x16\xE1\xDC\x44\x98\x12\xC2\x2E\xCB\x71\x03\xB7\xD3\x86\xE5\xAF\x4D\x34\x03\x07\x86\xCA\x27\x6A\xE0\xDE\x30\x5E\xE0\x06\x18\x03\x1B\xE0\x9A\x71\xE1\x02\x04\x19\xEE\x45\x7B\x5D\x76\xE0\x66\x78\x87\xC0\x00\x7A\xE0\x6C\xD8\x81\xC6\x0B\x81\xE0\x6D\xCD\xD4\x30\x00\x22\x32\xB7\xC9\x0A\x22\xE1\x72\xE3\x7E\xDD\x69\x7D\xE1\xEC\x1A\x2D\x0F\x87\xC5\xE2\xC4\xC5\x53\x37\x04\x10\xE2\x9B\x21\xFD\xB0\xA4\x94\xE2\xCC\xC6\x86\x13\x05\x18\xE2\x73\x2A\x34\x03\x89\xE7\xCC\x44\x53\x17\x00", - "\x8A\xF8\x31\xA3\xE1\x0B\xB4\x7E\x2B\x01\xA7\xE0\xBC\x69\x8A\xFE\x93\x67\x13\x1D\x0D\x8A\xFC\x0A\xFC\x03\x2B\xE8\xE7\xB1\x3B\x22\x32\xAB\xDA\x00\x0F\xC1\x5E\xA4\x27\xEE\x62\xE0\x6A\x90\x03\x2C\xEA\x34\x19\x00\x4F\xC0\xE6\x9C\x89\xE6\xA3\x4F\x74\x27\x02\x8C\xC2\x0F\x27\x01\x31\xEE\x63\x2E\xA3\xE4\x1C\x2A\x09\x88\xD6\x09\x35\x03\x2C\xCC\x89\xD9\xBA\xD9\x3F\x2C\x03\x8D\xD4\xB1\xD6\xE2\x92\xD7\x14\x3E\x02\xB9\xE2\x95\x0F\x04\x0F\xC1\x70\xB4\x27\xE1\x22\xDA\x05\xCB\x01\x38\xE5\x25\xE4\xE3\xCF\xE2\xDD\xCD\xD4\x18\x03\xCB\xE0\xC7\x5E\x8C\xD0\x04\x9C\xE0\x52\x9E\x17\x24\x03\xF1\xE0\x11\x1D\x07\x33\xE3\x5D\xE3\x8E\xC9\xE6\x30\x03\xEA\xE2\x56\x1B\x08\x3C\xE2\xED\xE2\x0B\x8A\x61\x3D\x03\xF9\xE0\xF5\x0A\x09\x3C\xE3\x6B\xE1\xB3\xB1\xD2\x70\x42\xEE\xC8\x2A\x0C\x90\xCD\xE2\x59\xC8\x35\x65\x01\x30\x42\xAE\xDA\x2D\x0C\x8E\xF4\xE3\x80\xD9\xF6\x32\x02\x18\xE4\x56\x0A\x31\x0B\x91\xFD\xE3\xAB\xCC\x35\x6F\x02\x20\xE4\xA6\x0E\x35\x03\x92\xCD\xE4\x25\xE4\xA8\x6C\x03\x28\xE4\x5A\x16\x39\x0B\x92\xD4\xE4\x57\xA4\xF9\x19\x04\x30\xE4\xEC", - "\x1A\x2E\xCC\x57\xDC\xE2\x81\xAD\xF6\x36\x05\x38\xE4\x31\xB0\x37\xCD\x8B\xF9\x33\x1B\x30\x44\xE6\x8C\x30\x42\x83\x0C\x05\x0C\x0D\xC6\xE3\xA1\xB4\x61\x46\x94\xD5\x15\x48\xE7\x54\x3B\x94\xC5\xE4\x9A\xD5\xCF\x7F\x94\xCC\x04\x8B\x01\x54\xE0\x11\x30\x00\x53\xE4\x47\xEA\x29\xC6\x49\x8D\x03\x55\xE6\x10\x19\x02\x5A\xE4\x43\x0E\x03\x1D\xE5\x24\xE4\xB6\xD8\x97\x1B\x02\x62\xE7\x40\x07\x0A\x25\xE5\x06\x04\x13\x08\x96\xEC\xE4\xF9\xCD\x53\x39\x0A\x00\xE5\x02\x06\x2D\x00\x97\xC3\x04\x5A\x02\x50\xE3\x11\x10\x03\x85\xC4\x2E\x00\x0B\x5E\xCB\x69\x00\x3E\xCF\x97\xDE\xE1\xA2\x43\x60\xE6\x25\x36\x01\x86\xE4\x44\x00\x98\xE5\xE1\x18\xAD\x5B\xE3\xA7\x03\x02\x73\xE7\x40\x0F\x98\xF1\xD2\xA0\x6A\x36\x02\x99\xE7\x98\x95\xE6\x40\x07\x99\xCC\xA2\x46\x4A\x39\x0B\x99\xC6\x0B\x9F\x01\x67\xE0\x00\x1F\xE6\x31\x89\xF6\x32\x0F\x23\xE6\xBC\x0A\x6D\xC0\xA4\xA8\xE6\xDC\x50\x5E\x2E\x0F\x0A\xE6\x0F\xB1\x63\xE5\x5C\x42\xC0\xA0\x69\x02\x07\x08\x3B\xD9\xD4\x0C\x32\x06\x9A\xF0\xE6\x4D\x8A\x86\x15\x01\x3B\xE6\xE4\xD6\xB1\x06\x0D\x3F\xE6\x0A\xD8\x68\x01\x02", - "\x04\xE7\xED\xD7\x16\x24\x0E\x08\xE7\x11\xD9\x4B\x4C\x9C\xCA\xD5\x4A\x0E\x3C\x00\x9D\xD8\xD8\x4D\x35\x0E\x03\x9D\xFF\xD7\x1D\x15\x86\xC8\x79\x80\xE7\xE4\xC4\x68\x05\x04\x1B\xE7\x06\xDB\x9C\x2E\x00\x1E\xE7\x87\xE6\x0F\xBC\x2A\x64\xE7\xAE\xD8\x07\x09\x21\xDE\xA5\xC0\xE7\x2F\xEF\xD4\x5E\x01\xE4\xE6\xBB\xCB\x02\x28\xE7\x8E\xE5\x7F\xC4\x7E\x2A\x01\xF5\xE6\x95\x09\x03\x38\xE7\xB7\xE5\x81\xCD\xD4\x36\x01\xE4\xE6\xB7\xC7\x04\x39\xC9\xC0\xE4\x36\xE6\x24\x41\x02\x05\xEB\x5D\xB8\xA0\xDE\xE3\x46\x0C\x7B\xE3\x54\x59\xC8\x70\xB4\x70\xE7\x8E\xC7\x05\x99\x02\x84\xE6\x77\x94\xE8\xE9\xE7\x1B\xC9\xFD\x26\x02\xFD\xE6\xE9\x01\x08\x00\xE8\x28\x2D\x98\xD0\xAA\x72\x02\x21\xEA\x56\x1F\x08\x24\xE8\x96\xE5\x9A\xD4\x7E\x3E\x02\x1A\xEA\x56\x1D\x09\x2F\xE7\x1D\xE9\xB0\x8F\xCD\xA9\xE8\x61\x20\x8B\xEE\x99\xF7\xD9\xD9\x3F\x35\x08\xA3\xEF\x76\x3A\xEB\x69\xED\x91\xC6\x49\xE3\x01\x8C\xEC\x6E\x08\x03\x1C\xE9\x7E\xE8\x68\xEC\x05\xF0\x02\x91\xEB\x89\x18\x03\x49\xE9\x80\xED\x92\xDC\x7B\x4E\xEB\x9C\x28\x0E\x11\xE9\x25\xE9\xA6\xDC\x12\x08\x02\xF0\xC6", - "\xB1\x08\x0F\x18\xE9\x2D\xE9\xA8\xD6\x24\x57\x00\x5C\xE8\xA1\xD7\xB0\x75\xCA\xF0\xE6\xC0\xBD\xDB\x24\x00\x65\xE8\xA3\xD5\x77\x28\xE9\x35\xE9\x9F\xC8\x97\x31\x00\x6D\xEA\x10\xCD\x03\x35\xE9\xAE\xC8\x20\x45\x2B\xDF\xE7\x4D\xE4\x5E\x2F\x03\x38\xE9\xE5\xE4\x00\x0B\x04\x00\xEA\x83\x0C\x0D\x0B\xA7\xF1\xE9\x7B\xB4\xBE\x10\xA8\xFC\xA0\x84\xEA\x35\x17\xA8\xCA\xE9\xCF\xD9\x9A\x3B\x05\x0B\xEA\xBB\x21\xA3\xEE\x12\x0F\xEA\x52\xEA\x5A\xED\xD4\x29\x01\x94\xEB\xB5\x96\xA9\xCC\x04\x5E\x00\xA6\xE9\xA5\xE1\xDB\x4D\x37\x1D\x00\xA8\xD9\xA1\x9F\xEA\x41\x0C\x06\x30\xE9\x48\x04\x77\x0D\x0C\x21\xA1\x80\xE8\xD4\xDB\x85\x12\x03\xDC\x05\x34\x03\x88\xFD\x8D\xDC\x04\x70\xE7\x13\xD2\xDF\x73\x2B\x34\x0C\x1D\x34\xEA\x1D\xE3\x26\x21\x85\xDE\xE5\x54\xD3\x04\xEE\x84\xC9\xE1\xDC\x07\x36\x0A\x17\xC9\x02\xA9\xEB\x26\x26\x0D\x05\xC6\x8B\x00\xA0\xEE\x2D\xFB\x01\x3F\xCF\x44\x0F\xAC\xDE\xD2\x02\x06\x25\x02\xAD\xD6\x09\x88\x01\xB5\xE0\x11\x17\xEB\x94\xC7\x53\x71\x0A\x1D\xEA\x5A\x15\x25\x02\xAA\xF2\x2C\x6C\xE1\x9A\x3D\x0A\x24\xEB\xAE\x6B\xB9\xE2\x10\x20", - "\xEB\xA0\xE4\x03\x9C\xAE\xDB\x22\xB1\x02\xBB\xE0\x00\x30\xEB\xA9\xE6\x91\x45\x0C\x33\xEB\x73\x2B\x2F\x06\xAF\xF8\xEB\x02\x05\x36\x07\xAB\xCA\x0D\x00\xEE\xD6\x96\x83\x5B\xEB\xAC\xBA\xB7\xEC\x10\x05\xEC\x10\xAA\x2A\xCC\xAF\xDB\x21\xDA\x03\xBF\xE2\x60\xE0\x6A\xE8\x03\xC3\xE6\x2C\x28\x03\x12\xEE\x96\xBD\xD4\x34\x03\x16\xEC\xBE\x69\xB1\xE7\xA8\xE4\x1C\x00\x09\x08\x3C\xE6\xF6\x10\x01\x09\x38\xD8\x9E\x05\xEF\x76\xCE\x5A\x4C\x00\x23\xED\x71\xEC\x2B\x12\x00\x27\xEE\xB5\xE1\xE7\xBD\x36\x18\x01\xCB\xED\x9C\xC6\x0B\x20\x01\xCC\xEF\xAD\xFC\xCC\x6B\xEA\xCD\xE5\x69\xDA\x15\x2E\x01\xE2\xCE\x95\x85\xEC\xF2\xE4\x68\x01\x03\x3E\xEC\xDC\xE6\xD8\x08\x38\xC0\xA9\x05\xEC\x32\xE0\x1A\x3D\x00\x48\xED\xA0\xED\x75\xBA\xEC\x0B\xEC\x34\xE8\x97\x09\x01\x51\xEE\xB7\xC9\x05\x3C\xCF\xF7\xE9\x83\xC1\x19\x14\x01\x59\xEE\x5D\x6C\xB5\xC5\xEC\x17\xE8\x4D\x0F\x05\x11\xED\xAE\xDB\x1C\x09\x38\xF0\xB5\x64\xED\xDB\xCC\x10\x2C\x01\x68\xEE\xA5\x8B\xB6\xF2\xEC\xEE\xE1\x9A\x39\x07\x11\xED\xEE\xCB\x24\x04\xB5\xDB\x05\x26\xEB\x53\x75\x08\x38\xED\xB4\x67\xDE", - "\xE8\xAE\xFE\xE3\xBD\x35\x24\x01\xB7\xE6\x0E\xAF\x02\xD0\xE4\xB7\xC6\xE4\x2B\x64\xE0\xE3\x7C\xC2\xEE\xEF\xE8\x8F\xE6\x24\x6A\x02\x8E\xEE\x45\x40\xB9\xDD\xED\x4B\xEA\x56\x06\x0B\x07\xEE\x6C\xBF\xDC\xEB\xB3\xD9\xEE\x47\x07\x30\x0C\xB9\xC2\xB4\x9E\xED\xD5\xEA\xA5\xC5\x57\xA3\xEF\x26\x2A\x0F\x25\xEE\x7C\xEF\xE9\xE6\x10\x1D\x03\xA9\xEF\x9C\x2A\x00\x1C\xD1\x6C\xED\xEE\xC4\x44\x6A\x03\xB1\xEF\x16\x2A\x01\x1C\xD1\x43\xEE\x9A\xE9\xFD\x37\x03\xB9\xEC\xC2\x4C\xBB\xCB\xEE\x8A\x70\x92\x5A\x08\x35\x9C\x10\x03\xF1\xE7\x0C\xC3\x04\x38\x00\x17\xD8\xB2\xFD\xE9\x4D\x36\x04\x0A\xBC\xCD\xE7\x1E\x03\xF4\xE2\x0D\xC0\x00\x46\x02\xF3\xE4\xBC\xC6\xD3\xAF\x08\x08\x06\xBD\xC9\xC1\x2C\x03\xF7\xED\x0D\xD4\x01\xDA\xEF\xE7\xE1\xA9\xFD\x36\x2E\x02\xF8\xEF\x13\xBA\x00\xE2\xEF\xE0\x02\x06\x25\xEF\xA6\xEC\x13\xAD\xD4\x3C\x00\xEA\xEF\x44\x08\x04\x2D\xEF\x11\x8C\xFC\xED\xBA\xE4\xEA\x7B\x72\xF8\xE1\x5D\xB8\xEF\x10\x05\x37\xDC\x57\xD7\x03\x85\xC5\x16\x02\xBE\xDE\xCB\x8D\x00\x4A\xDE\x6E\x88\xE6\x6B\xB3\x01\xF0\xEA\x4A\xF0\x06\x04\x01\xF0\x99\xF8\x25", - "\x6F\x01\xFD\xE7\x85\x3A\xEF\x0B\x19\xBA\xED\xDB\x3B\x01\x16\xF2\x56\x15\x0B\x18\xF0\x02\x06\x04\xFB\x2F\xE7\x11\x87\x01\x07\xFC\x6E\x03\x03\x20\xF0\x00\x02\xC2\xF7\x83\x4E\x52\x09\xFB\x89\x11\x03\x29\xF3\x0A\xF6\x88\xE9\x39\x9F\x02\x03\xF6\x3A\x1F\x03\x10\xF1\x06\xFE\x88\xE9\x39\xAA\x02\x0B\xF3\xA7\x2C\x03\x31\xF3\xC4\xEF\xD4\x76\x02\x3E\xF3\x16\x2A\x0F\x01\xF1\x1A\xEC\x39\x75\xC4\xC6\x0B\x08\x00\x56\xD8\x79\xB2\xF0\xB9\xA0\x5E\x2E\x0C\x0B\xF1\x47\x1E\x13\xFA\x8F\xAA\xD3\xC4\x78\x15\xFA\x34\x24\x00\x56\xF0\x44\x00\xC5\xF6\xB0\xE8\x76\x16\xF8\x62\x5D\xF1\x0B\xF2\x7A\xED\xDB\x32\x03\xFE\xEF\x16\x48\x55\xDE\xA5\x5F\xF1\xD1\xE1\x19\x3F\x03\x62\xF2\xD8\x0F\x04\x24\xF1\x11\xF2\x7E\xE8\x97\x0B\x00\x8B\x00\xC9\xED\x11\x1D\x01\x74\xF2\x0E\xF3\x35\xD1\xA0\x79\xF3\xE4\x8C\x6E\x2B\x01\xB9\xD5\x08\xFE\xB5\xFE\x05\x22\x01\x20\xF8\x44\xB3\x29\x78\x01\x21\xFA\xC2\xD0\xE8\x1E\x05\x0B\x0A\xC8\xFF\xEC\xEC\x19\x21\x08\x55\xF0\xB5\x5F\xF1\xD9\xEE\x11\x3A\x00\x93\xF0\xA7\xD7\x26\x57\xF2\x57\xF1\xDD\xE1\xD6\x5D\xF2\x52\xEC\xAF\x05", - "\x0A\x3D\xF1\x86\xF3\x4C\xD4\x7E\x13\x01\xA4\xF2\xBB\xC3\x0B\x28\xF2\x8F\xF0\xE1\xE9\xFD\x1F\x01\xA4\xF2\xAB\xD1\x0C\x2B\xF1\xA1\xF0\xE3\xE8\x97\x2C\x01\xAD\xF2\x95\x00\x0D\x30\xF2\x5F\xF0\x01\x9A\x15\x38\x01\xBD\xF2\xE9\x0E\x0D\x00\xF3\x43\xE8\x11\x54\x08\x35\xF2\x56\x08\x3B\x00\xCA\xDE\xF1\xC9\xF2\x6B\x51\x09\x0C\xF3\xA6\x0C\x3F\x0F\xCC\xE5\xF1\x53\xE8\x68\x0E\x09\x14\xF3\x5A\x14\x03\x05\x60\xD8\xF2\x7A\x94\x35\x6B\x0A\x1C\xF3\xEC\x18\x07\x0F\xCD\xF9\xF2\x35\xE4\x51\x64\xCE\xEA\x52\x05\xD8\x1B\xFE\xBB\xFA\xEB\xEB\xF3\x9C\x2B\x03\x2D\xF3\xE8\xF2\x9C\xED\xD4\x12\x03\xC5\xF0\x43\x0E\x0D\x24\xF2\x83\x0E\x12\x05\x60\xCF\xF1\xD0\xED\x9A\x30\x0E\x39\xF3\x67\x50\x3F\xF3\x11\x13\xD8\x40\xAB\x17\xFB\xDA\x8F\x75\xEE\x00\x41\xF9\x28\xC6\xF4\xEF\xA7\x3F\xF5\xCF\xF5\xB6\x59\x1A\x43\xFF\xCC\x07\x74\x83\x0C\x1D\x02\xD1\xD0\xF3\x31\xBC\x5E\x2A\x00\x07\x74\x3F\x86\x05\x08\xD1\xD8\x87\x1B\xF4\x36\xF5\x97\xFC\x7E\x07\x75\x1E\x95\x02\x23\xF4\x33\xD0\x3D\xF0\x11\x18\x03\xAE\xEB\xB1\x37\x02\x07\x74\xB2\xE8\x59\x8C\x1D\x30\xF4\xC1", - "\xEB\x9C\x2A\x0D\x1C\x07\x5F\xF3\xAE\xE9\x7D\xE6\xDA\xDC\x06\xC0\xE9\xD3\xCC\x8B\xDC\x05\xC1\xEE\xD3\xE3\xDE\x56\x08\x37\x0C\x1D\x1E\x03\x03\xEE\xF0\x0A\xD4\xD0\x04\xDB\xDE\xBF\x77\xD0\x63\x59\x9F\x01\x81\xD7\x1F\x1D\x03\x4B\xF5\x53\xF2\x36\x18\xF5\x50\xF7\xB1\x3B\x02\x13\xF5\x56\x08\x28\x06\xD5\xD9\xCF\x31\xF4\xF3\x30\xD6\xDC\xDD\x24\xB8\x77\x0F\xD4\xC5\xEB\x46\xE2\xE9\x00\x0E\x05\xC6\x2D\x00\x48\xF4\x9B\x6C\xD9\x06\x07\x5B\xF8\xAD\xC0\x00\x39\x02\x5C\xF6\x3A\x2E\x02\x74\xF7\x5F\x00\x5D\xFE\x05\x45\x01\x4A\xF6\x25\x3B\x02\x25\xF5\x5D\xFA\xC1\xD9\x3F\x52\x02\x60\xF6\x3A\x09\x03\x85\xF6\x5F\xF1\xE3\xB7\x7F\x8A\xF6\x56\x17\x0D\x0D\xF6\x02\x06\x5D\xF4\xBF\x99\x3F\x6C\x00\x4B\xF9\xAE\x63\xF5\x54\x53\x2F\xD4\x8D\x6E\x01\x91\xF4\xBB\x16\x0E\x14\xF6\x00\x02\x65\xF8\x4C\xDA\x18\x7B\x02\x5E\xFA\x55\x34\x03\x7D\xF5\x65\xF8\x9B\xCF\x75\x87\x01\x68\xFE\xFD\xA4\xDA\x98\x9E\x69\xFC\x31\xCC\x3C\xB2\xF7\xF9\xB4\xDB\xD3\x04\xB6\xF7\x3A\x95\x80\x79\xF6\xEF\xBF\x6E\xFD\xD9\xD1\xE7\x69\x3A\x2B\x00\xDC\xF7\xBF\xC2\xF4\x43\x0D\xDB", - "\xC2\xA3\xE4\x1F\x2E\x07\xDC\xFC\x0A\x39\x01\x72\xF6\xD8\xF1\xD3\x1A\x18\x32\x0F\xDC\xCA\x0D\x47\x02\x74\xFE\xD8\xF8\xD3\x1A\x19\x35\x07\xD0\x6C\xB5\xC2\x0D\x15\x04\x6A\xDE\xA5\xCB\xF6\x1B\xFE\x17\x23\x03\xD7\xF7\x6F\xAA\xDD\xEE\xF6\x4C\xCD\xF6\x30\x0F\x29\xF7\xD9\xBB\x7A\xF5\xDA\xD6\xED\x4D\x35\x3F\x0A\xDA\xF1\x80\xE3\xDB\x70\xFA\x35\xF2\x19\x84\x4E\xBB\xCD\x08\x39\xF7\xCA\xF4\x24\xFD\x11\x15\x00\x84\x4C\x78\xF2\x36\x1A\x02\xA4\xD8\x5C\xBB\xDC\xDA\xF2\x1D\x07\x08\x05\xE0\xD6\x09\xAA\x01\x82\xFC\xDB\xEC\xD4\x69\x39\x0C\x04\x38\x6E\xDA\x34\xDC\x90\xAB\xDC\xF6\xE3\x6C\x06\x0F\x07\xE1\xD5\x31\xF2\xF7\x72\xFC\x53\xDE\x04\x4B\x03\x83\xF9\x92\xE3\xF7\x13\xF8\x62\x82\xF3\x9F\xF8\xEB\xB1\x88\xF2\xB9\xC4\x51\x66\x00\x8B\xFA\x55\x33\x03\x2E\xFA\xA7\xA7\x46\x33\x01\x84\x4F\xBB\xD4\x3D\x0B\xF7\x8C\xD0\x5E\x24\x07\x04\x4E\x6D\xD0\xF5\x01\x00\x22\x30\xF7\x07\x72\xF6\xCB\xA8\x9E\x40\xF8\xBC\x74\xE4\xE9\xF8\xB6\x23\xB1\x38\x07\x39\xF8\x56\xDC\x7B\xFC\x10\x03\xAB\x8F\x28\x94\xF8\xD6\xD3\xF7\x0E\x73\xB1\x3A\x07\x16\xF9\x7A\xDC", - "\x11\x1B\xDC\xE6\x03\xC7\x3B\x1E\x0C\xE5\xC7\xDE\x3B\xF8\x77\x0E\xCD\x9A\x18\x7C\x03\x98\xF0\x45\xDE\xF9\x11\xC4\x5F\x59\xE4\xE5\x8B\x4B\xFA\x7E\xFB\x98\x07\x3B\x7F\x03\x9B\xF8\x6A\x71\xF9\x01\xFA\x46\x07\xEC\x01\x02\x6A\xFA\xCB\xD2\x36\x0B\xF7\xD5\xC8\xF9\x12\x08\x36\xF9\xEC\x19\x01\x08\xE7\xD8\xF9\x06\xB5\x7E\x6D\xE7\xE8\xDD\x4A\x0F\x72\xFB\xED\xA1\x30\x26\xFB\xB4\x22\xC2\x0A\xF8\xD1\xF0\x35\x63\x09\x11\xFA\xEC\x1A\x05\x03\xE9\xCC\xF9\x60\xC8\x6B\xC8\xE9\xCB\x41\x9B\xFA\x9C\xF2\x0A\xE9\x39\xAF\x03\xA7\xF3\xA7\x36\x00\xA1\xF9\x9E\xF7\xB2\x87\x3B\xBD\x00\xE1\x42\xAB\xC6\x01\x22\x33\xE0\x0B\xDC\xF1\xDE\x78\x24\x30\x0E\xEA\xCC\xD7\xB1\xF8\xA7\xF2\x7D\x07\x3B\xC3\x03\xAD\xF6\x3A\x0A\x01\xB9\xFA\xA8\xF2\x10\x3B\xDE\xE4\x1E\x31\x0E\xEB\xDA\x15\x4C\x01\xB0\xFA\xEA\xC6\x04\x3C\xE1\x77\x87\xEC\xEC\x1B\x4E\x02\xB2\xF8\xE8\xD7\xB5\xDD\xCC\xA1\xFB\x89\x10\x01\x87\xFB\x76\xFB\xB5\xB0\xB3\xD6\xFB\x9C\x21\x05\x19\xFB\x52\xF9\x3A\xFD\xD4\x10\x03\xA6\xFB\x16\x22\x05\x22\x30\xE4\xF4\x18\xD9\x82\xDD\xFB\x65\xD8\xB8\xF3\xDF\xDD", - "\xD5\x78\x24\x38\x0C\xEE\xE2\x03\xEC\xFA\x18\x0E\xEE\xCB\xF7\x3D\xE6\x91\x44\x0E\x25\xFB\xC6\x0B\x18\x08\xEE\xFA\xFA\x03\x8F\xD4\x92\xE3\xC7\x04\xEC\xFA\x1C\x02\xC2\x35\xF6\x01\xF5\x6F\x31\x00\x0E\x02\xF0\xC6\x03\x0C\xF0\xCB\xEF\x02\x04\x20\x07\xF0\xC0\xFC\x17\x8F\xAB\x00\x01\x0F\xFC\x8C\xD9\x07\x08\xF1\xD7\xEF\x8E\x03\xC4\xF2\xEC\xDA\x91\xAF\x0B\x07\x0B\xF1\xDE\xF2\xCA\x53\xC8\xFD\x0D\xCA\xE3\x1A\xFB\xA9\xCD\xD4\x2E\x00\x26\xFD\x1E\x9B\x03\x26\xFC\x35\xA2\xC7\xFB\xEC\xFD\x9B\x87\xCE\xC9\xF8\x79\x8B\x01\x30\xFF\x44\x08\x0B\x3F\xFB\x10\x06\x38\x0C\x1D\x21\x03\xC7\x39\x13\x06\xF2\xFA\xF8\xF6\x12\xAE\xAD\xF3\xDA\xF5\xB9\xBF\xCF\xF7\xEC\x0E\x01\x43\xFD\x94\xF5\xCC\xBD\x62\x48\xFC\xF5\x00\xE6\xC8\xA7\xAF\x0B\x13\x06\xF2\xDE\xCB\xC7\x01\x40\xE2\x93\x4C\xF0\xBD\x36\x16\x07\xF5\xD6\x09\xD4\x02\xD6\xF9\x26\x3F\xF5\x6C\x05\x19\x06\xF2\xEE\xCB\xE1\x02\xCC\xFB\xF5\xD8\xD7\x1A\x19\x1C\x07\xF6\xEB\xC1\x6A\xFF\xD8\xFF\xD8\xFC\x55\x6F\xFC\xA8\x51\xF7\xE8\x1E\x9E\xF4\xA8\x69\x08\x35\xFD\x67\xCC\x2C\x48\x79\x93\xFD\xF2\xD5\x53", - "\x35\x09\x1F\xFD\xA6\x0D\x06\x08\x97\xD2\x06\xAF\xF4\x68\x00\x0A\x3C\xFD\xEC\x1A\x09\x0E\xF7\xD3\x04\x80\xFD\x9F\x64\x7E\x2C\x02\x8C\xFD\xB9\xBF\xF8\xE4\x10\xC9\xE5\x64\x08\x0B\x15\xFE\x73\x2A\x10\x07\xF9\xD5\xB3\x20\xED\x71\xCC\xF9\xC7\x26\x9F\xFF\xDA\xF8\x9D\xFD\xCC\xA3\xFE\xB1\x0E\x05\x25\xFE\x72\xFC\x2C\xEF\x0B\x69\xFE\x4B\xD4\xEB\xF8\xF7\xE6\xF1\xCE\x41\xCB\xF6\x25\x3A\x01\xB0\x42\x57\xA1\xF9\xC1\xBA\x36\x70\xEC\xFA\x34\x09\x02\xB2\xFC\xE2\xFD\xDE\xC3\x66\x8F\x02\x1E\xF3\x11\x17\x02\xC1\xFF\xEE\xF0\xE9\xBA\x19\xC5\xFE\x20\xFB\x89\x25\x02\x87\xFE\xF2\xF4\x52\xA7\x11\x18\x01\xF3\xFB\xC8\xE7\xD3\xD1\xFE\x80\xF2\x22\x16\xFF\x94\xF3\x26\x2F\x0B\x30\x42\x70\xB6\xF4\xFC\xE0\xD3\x04\x30\x00\xF7\xF4\xF2\xF3\x29\xCF\x00\xF8\xF0\xF9\xD4\xF8\xBD\x35\x0F\x06\xFE\xE5\xF2\x84\x8D\xF2\xFD\xB7\xE0\x06\x49\x03\xFB\xFE\x2E\xED\x03\xF2\xFE\x2C\xF6\x24\x55\x01\xEF\xFE\xAB\xDB\x0F\x39\xFE\xEB\x7E\x15\x7C\x5E\x12\x0C\x06\xFF\x76\x12\x0A\x00\x64\x73\x7F\x7F\x17\x7E\x6B\x2E\x0D\x05\x00\x86\x1D\x18\x00\x08\x80\x01\x81\x8A\x70\xA8", - "\x32\x0F\x0D\xFF\x77\x91\x64\xE7\x61\x7F\x95\x7C\x50\x37\x21\x05\x02\x8B\x0E\x57\x00\x91\x00\x9D\x7D\x16\x66\x0E\x81\x53\x4E\x03\x88\xF9\x6E\xDD\x7A\x06\x22\x80\x9E\x60\x12\x80\xE8\x7A\xDC\x75\xDC\x68\x01\xA5\xC2\x64\x73\xBA\x7F\x77\x78\x11\x2B\x17\x0E\x02\x93\x53\x35\x01\x30\x80\x1F\x80\x7B\x79\x9A\x18\x19\x0D\x00\x8C\x08\x14\x03\x6F\x7F\x83\x06\x42\x00\x04\x85\x04\x8D\x6B\x79\x7E\x16\x03\x3D\x80\x06\x02\x71\x00\x10\x83\x22\x02\x09\x03\x02\xAB\x00\xDC\x77\x67\x08\x72\x00\x12\x83\x20\x00\x0F\x0B\x02\xB5\x27\x4E\x80\xA6\x7E\xDB\x48\x5E\x12\x1E\x03\x05\x82\x08\x3E\x03\x56\x80\x0C\x02\x57\x00\x16\x85\xF5\x7A\xA9\x69\x73\x00\x00\x10\x01\x35\x4E\x06\x00\x1A\x80\xE2\x71\xB4\x43\x03\xB3\xFE\x7C\x77\x81\x6D\x35\x80\xA3\x6B\x03\x02\x07\x97\xDE\x4A\x03\x38\x80\x10\x03\x73\x02\xD2\x7C\x4D\x25\x07\x9E\xA1\x5D\xF9\x54\x07\xE8\x00\xEE\x02\x1E\x83\xA8\x76\x2C\x03\x65\x77\x08\x7A\x62\x1E\x01\x3E\x81\x37\x66\x58\x0A\x0E\x1B\x03\x9A\x18\x20\x00\x8A\x80\xA2\x7D\x47\x03\x1D\x0C\x1D\x0D\x04\x84\x02\xBC\x05\x67\x7C\x83\x01\x72\x52", - "\xC3\x01\x02\x0A\x04\x9E\xCB\x59\x01\x55\x75\xD0\x00\xD7\x79\xFB\x1C\x02\x1E\x04\xAC\x19\x21\x81\x99\x81\x5B\x51\x32\x0A\x11\x8E\x2E\x73\x07\x2E\x01\xA2\x81\x86\x41\xA8\x7E\x3D\x09\x15\x82\x10\x00\x4F\x46\x49\x43\x00\xAC\x80\x2B\x05\x00\x00\x50\x78\x79\x54\x05\x80\x00\x43\x49\x4D\x1B\x27\x01\x2E\x87\xB3\x0C\x0B\x93\x08\x3E\x02\xB3\x32\x4D\x1B\x2D\x03\x30\x81\xFB\x45\x0C\x99\x56\x41\xB9\x3D\x1B\x67\x00\x53\x83\x24\x2F\x54\x76\x0C\x89\xFC\x75\xB1\x4B\x81\x0A\x2B\x66\x81\x37\x5A\x88\x70\x1A\x1E\x03\x18\x03\x9B\x11\x46\x00\x6D\x83\x19\x29\xF3\x7E\x17\x0A\x04\x1F\x03\xF3\x14\x54\x00\x71\x83\x40\x06\x17\x83\x4E\x6B\xA7\x67\x03\xDB\x10\x62\x00\x75\x82\x40\x06\x17\x8A\xB2\x74\xC6\x22\x02\x6F\x81\xC6\x04\x38\x02\x3C\x80\x16\x8E\xFA\x64\x3F\x2E\x02\x78\x81\xBC\x04\x3F\x03\x3E\x86\x17\x8C\x1E\x71\x0C\x3A\x02\x0A\x81\xAE\x6C\x46\x00\xA0\x76\x2B\x5E\x0B\x86\xEF\x6C\x05\x47\x01\x00\x82\xA5\x07\x26\x03\x20\x86\xC7\x6D\x6A\x13\x03\x11\x82\x81\x24\x8A\x82\x80\x71\xCD\x1F\x0D\x12\x06\x9A\x15\x37\x01\xD4\x80\x67\x81\x45\x69\xFB", - "\x1A\x0E\x1E\x08\xAC\x1B\x44\x01\x21\x83\x6D\x81\x17\x64\x2D\x05\x0F\x08\x08\x8B\xA9\x00\x75\x70\x5A\x5F\x83\xF8\x7C\x3A\x07\xDE\x0E\xB5\x61\x03\x30\x82\xD5\x80\x51\x79\xF6\x1F\x01\x07\xDE\x0E\x97\x71\x03\x1A\x82\x1F\x2F\x98\x39\x4F\x87\xE7\x00\x14\x80\x49\x78\x25\x27\x00\x35\x83\x3C\x61\xD4\x74\x21\x80\x67\x6E\xAD\x34\x00\x43\x82\xA6\x06\x0E\x01\xD4\x75\x17\x8A\x00\x83\xB0\x50\x05\xDA\x0A\x2A\x01\xA9\x81\x4E\x82\x02\x8B\x60\x69\x0A\x84\x13\x51\x76\x31\x83\x0C\x83\x53\x39\x0B\x0E\x15\x94\x4F\x60\x05\xDB\x82\x20\x80\xD7\x2A\x19\x05\x2C\x8C\x6E\x18\x02\x27\x05\xA2\x82\xD9\x79\xC8\x03\x1C\x04\x2D\x86\xE7\x2F\x0B\xAA\x04\xF7\x6A\x69\x1C\x40\x00\x5D\x84\x91\x7B\x14\x88\x0B\x87\xB6\x2A\x15\x7B\x83\x2D\x13\x21\x05\x2F\x80\x17\x85\xDE\x54\x3C\x57\x82\x06\x02\x53\x03\x79\x1B\x70\x06\x09\x1A\x0A\x85\x06\x95\x5E\x94\x58\xC4\x83\x40\x04\x16\x0B\x18\x81\x2F\x0E\x06\xF7\x82\x55\x72\xBC\x12\x2D\x02\x32\x88\xA2\x35\x0C\x90\x04\x32\x01\x97\x83\x71\x83\x57\x74\x88\x24\x0C\x1C\x0C\xA7\xE6\x1E\x83\x0C\x02\x60\x01\x68\x83\x1D\x8A", - "\xF2\x69\x73\x12\x03\x26\x83\xDE\x00\xD4\x83\x73\x3B\x35\x83\x0F\x92\x95\x66\x70\x01\x83\xED\x00\xD9\x82\x75\x2C\x30\x8C\x5B\x5C\x0E\x2E\x03\x32\x81\x1D\x03\xDF\x82\x6C\x4F\xD8\x1F\x0E\x07\x6F\x12\x02\xFD\x1E\x85\x62\x78\x03\x79\x1E\x5B\x6B\x0E\x19\xDD\x6F\x03\x23\x81\x46\x25\x7D\x03\x72\x83\xF7\x2E\x1C\x84\xFB\x5A\x05\x06\x00\x92\x00\xE3\x7C\x3C\x12\x7C\x78\x79\x4F\x0E\x90\x04\x71\x01\xC0\x82\xE4\x80\xDB\x78\x72\x49\x1D\x8E\xD9\x4A\x0D\x13\x00\xDC\x82\xF1\x83\x08\x7A\xC3\x0E\x01\x05\x0F\xB7\xEC\x3C\x05\x21\x01\xF4\x81\x33\x59\xBD\x6D\xD4\x0A\x01\x2E\x07\xD4\x73\xC2\x07\x17\x02\x7C\x81\xCB\x79\x30\x76\xFE\x37\x07\x91\x64\x73\x15\x1E\x01\x1A\x7B\x3E\x86\x2D\x6F\x15\x01\x01\x7F\x83\xF0\x7E\x7B\x2F\x7E\x82\x59\x59\x8A\x5B\xF2\x08\x08\xEE\x65\x58\x01\x05\x84\x33\x24\x1C\x8C\x16\x19\x02\x0F\x08\xF6\x32\x12\x85\x66\x14\x29\x76\xB5\x25\x06\x17\x10\xA6\x0E\x74\x00\x19\x84\x35\x18\x16\x7C\x1A\x31\x07\x1E\x10\x9A\x15\x02\x01\x21\x84\xEF\x81\x3F\x80\x2F\x1D\x07\x06\x11\xB7\x55\x29\x84\x3C\x77\xEC\x1D\x22\x00\x41\x8E\x6A", - "\x7E\x04\x22\xEF\x5E\x52\x2A\x85\x16\x6D\xAC\x5E\x45\x8B\x89\x0D\x05\x30\x08\xC3\x7F\xB7\x5C\x1E\x87\x9C\x13\x17\x0F\x23\x9F\xE3\x45\xF7\x08\x84\xDE\x65\x64\x03\x80\x84\x3F\x8B\xDF\x69\xE0\x08\x09\xD6\x04\xD6\x01\x25\x84\x83\x81\xD4\x54\xFF\x54\x11\x89\x94\x62\x77\x70\x5B\x1C\x87\x40\x03\x26\x81\x85\x56\x12\x87\x1A\x58\x84\xEA\x83\x3D\x59\x53\x1E\x1B\x02\x24\x9B\x42\x03\x00\x24\x79\xDD\x83\xF9\x7D\x64\x02\x1D\x05\x26\x86\x16\x11\x00\x68\x84\x61\x85\x44\x55\xE1\x1E\x4B\x8A\xBD\x04\xE5\x78\x08\xCD\x82\xD4\x31\x01\x03\x24\x02\x3B\x8C\x10\x0E\x01\x30\x09\x84\x84\x8C\x60\x9B\x5B\x9E\x86\x3C\x8F\x95\x1F\x13\x8C\x09\xDE\x6A\xD9\x1F\x0D\x03\xA0\x86\x4D\x7C\x2B\x0A\x02\x24\xF2\x59\x84\x62\x83\xA3\x6B\xA2\x85\xFB\x73\xA7\x1A\x02\x0F\x0A\xF1\x84\x24\x5A\xF2\x0D\x0D\x03\x52\x87\xFE\x7B\x42\x2A\x01\x17\x85\x80\x85\x51\x7D\x6F\x1A\x08\x0C\x29\x85\xB5\x5B\x22\x7A\x00\xA0\x85\x43\x84\x5A\x5C\xFC\x0F\x04\x05\x15\xAE\xDA\x0A\x01\x76\x84\x4C\x85\xA8\x37\x55\x0C\x05\x0E\x15\x96\x09\x19\x01\xB1\x85\x50\x85\xC0\x7C\xFC\x09\x06\x05", - "\x15\xBF\x84\x75\x00\xA5\x85\xC1\x04\x2A\x06\x50\x83\x25\x82\x2D\x65\xEA\x3E\x85\x13\x03\x41\x01\xB0\x83\x22\x06\x0B\x04\x16\x93\x08\xC7\x3E\x4D\x1B\x42\x00\xB2\x87\x36\x3B\x2C\x87\x31\x0E\x0B\x9A\x84\xA3\x82\xD7\x2B\x24\x03\x5A\x8A\x17\x15\x16\x8C\x04\x78\x79\x40\x54\x2D\x86\xFB\x67\x55\x01\x0A\x1C\x16\x86\x04\x2D\x01\xDE\x85\xBA\x7B\xB5\x82\x44\x87\x5B\x6D\x6A\x2F\x02\x36\x85\xCC\x67\x74\x87\x40\x05\xA1\x7C\x57\x70\x07\x1C\x07\x60\x83\x97\x80\xA5\x04\xBE\x82\x74\x06\x48\x25\x15\x87\x07\x90\x02\x00\x57\x90\x6D\xF6\x1F\x17\x0E\x2F\x96\x12\x3D\x03\x24\x79\xF7\x03\x79\x02\x23\x82\x24\x45\x30\x97\xF2\x70\x10\x5C\x03\xFA\x01\xF0\x80\xDB\x24\x3B\x07\x0F\x12\x18\x8C\x04\x74\x01\xDC\x03\x7C\x02\x5E\x61\x18\x02\x2F\x93\x53\x35\x03\x07\x70\xD9\x1F\x61\x01\xC3\x82\xAB\x0E\x0F\x08\x18\x93\x04\x76\x01\x0B\x87\xE2\x63\xC8\x84\xCC\x76\x4F\x08\x19\x9E\x10\x16\x86\x06\x03\x8A\x86\xC0\x82\x5F\x7B\x32\x82\x5E\x26\x0C\x90\x02\xF8\x01\x94\x85\x78\x1D\x66\x8E\xE7\x64\x22\x1A\x0C\x90\x02\x1F\x87\x7C\x86\xF0\x01\x62\x8D\xB7\x50\x19", - "\x83\x04\x7B\x01\x85\x63\x63\x01\xA9\x86\x5B\x61\x9C\x74\x14\x80\x00\x48\x86\x77\x7A\x69\x03\xD2\x81\x0F\x60\xDC\x70\x1A\xA1\xEB\x20\x03\xDD\x00\x73\x87\x26\x12\x03\x0F\xDD\x73\x08\x16\x0D\x9C\x63\xAE\x2B\x74\x02\xD6\x83\x4E\x18\x02\x1D\x1A\x90\x04\x5F\x86\x4A\x4F\xB0\x53\xD8\x83\x65\x16\x36\x87\x21\x39\xFD\x4F\x3A\x01\x00\x4A\x00\x9F\x86\x20\x04\x04\x0D\x1B\x86\x04\x68\x86\xB1\x73\xA6\x19\x03\x02\x6E\x8E\xFC\x72\x0D\x55\x0D\xD6\x81\x7E\x02\x0C\x00\xDF\x87\x3D\x8A\x34\x1F\x02\x36\x0D\xC7\x86\xDC\x80\xD3\x33\xE0\x80\x3F\x82\x36\x0D\x03\x07\x0E\x82\x02\x78\x87\x4E\x70\xF9\x08\x06\x0B\x38\x89\xDA\x44\x11\x29\x7B\x40\x55\xC8\x85\x3B\x86\xB5\x2C\x03\x15\x1C\x89\x08\xE2\x06\x89\x01\xC7\x87\xD3\x83\x44\x80\xAA\x28\x02\x1E\x0E\xEE\x65\x97\x00\xD1\x85\xE4\x81\x3C\x7F\xB5\x67\x1D\x96\x09\x25\x01\xAA\x87\x18\x86\x91\x20\x0C\x0E\x39\x8E\xB5\x73\x02\x07\x3A\x5E\x53\xC8\x86\x43\x82\x60\x0E\x3A\x95\xCE\x31\x0E\xC0\x84\xAE\x2B\x3C\x01\xEF\x82\xAB\x00\x0D\x1F\x1D\x86\x09\xBD\x1B\x85\x00\xCF\x86\xB7\x66\x1B\x0F\x37\x83\x09\x86", - "\x49\x10\x01\xCA\x86\x3B\x0D\xF3\x84\x4A\x86\x24\x3B\x04\x35\x0E\xBB\x2F\x07\x3A\xB8\x59\xE4\x84\x4B\x86\x10\x08\x05\x17\x0F\xA6\x07\x08\x00\xC2\x26\xF6\x84\xFD\x79\xFD\x15\x05\x03\x0F\xEC\x0D\x18\x01\x72\x7D\xE4\x84\xC3\x71\xF7\x27\x1F\x8B\x41\x6A\x87\x2E\x74\xBC\x11\x33\x07\x7B\x8A\x55\x14\x01\x04\x4E\x39\x87\x78\x85\xCC\x72\xFB\x83\x4E\x13\x04\x10\x1F\x8E\xE4\x4B\x4E\xFB\x87\x2D\x11\x14\x06\x7F\x8C\x15\x80\x0D\x32\x03\x74\x87\xEC\x0D\x2F\x02\xF8\x86\x6B\x81\x29\x8F\xE3\x48\x10\x9B\x11\x6F\x01\x05\x8B\xD9\x81\x9C\x70\xAA\x2C\x00\x20\x37\x2E\x6D\x75\x7D\xB6\x6B\x04\x8E\x04\x80\x98\x17\x20\x9E\xA0\x12\x88\x6E\x86\x31\x74\x11\x2E\x04\x0E\x41\x99\x46\x77\x0F\x8C\x88\xAA\x6C\x19\x45\x09\x8A\xAB\x0E\x0A\x07\x21\x9B\x10\xB3\x6D\xAE\x2A\x20\x00\x78\x1F\x27\x4C\x04\x00\x6F\x02\xCA\x04\x88\xC6\x85\x8D\x3F\x0C\x8B\x22\x0A\x05\x16\x21\x8C\xCA\x38\x88\x50\x80\x0D\x0C\x17\x03\x87\x8E\xDC\x5E\x21\x90\x04\x59\x01\x40\x88\x8A\x7A\x86\x0A\x0D\x04\x44\x9F\x87\x46\x11\xA3\x65\x49\x88\xDC\x57\x19\x08\x0F\x0D\x44\x80\xFB\x0F\x11", - "\xAF\x65\x51\x89\x2A\x53\x53\x3E\x10\x0B\x42\x86\x08\x13\x02\x57\x88\x48\x5A\x93\x7E\x57\x54\x1F\x00\x32\x86\x92\x15\x02\x60\x1B\xC3\x65\xA6\x7C\x44\x05\x1F\x0A\x33\x89\x73\x16\x02\x68\x88\x4E\x7E\x7F\x00\x77\x04\x8C\x82\x34\x93\x8C\x1C\x07\x11\x87\x47\x7A\x63\x76\x97\x03\x68\x00\xF4\x76\x1F\x70\x11\x8E\x86\x58\x2D\xC1\x06\xDB\x74\x65\x87\xAC\x78\x5B\x3C\x11\xC7\x1D\x98\x00\x30\x89\xCF\x84\x7A\x03\x00\x07\x24\x8B\x4C\x0A\x89\x8C\x7C\xE1\x04\x01\x06\x91\x8C\xCB\x30\x24\xB4\xDD\x38\x02\x94\x89\x95\x32\x25\x88\xF0\x6F\x13\x19\x24\xB8\x25\x20\x01\x9B\x89\xC6\x6C\xEA\x1E\x93\x8D\xD4\x02\x05\x21\x12\xBC\x75\xD9\x19\xA1\x06\x02\x03\x90\x83\x10\x04\x05\x3F\x11\xFF\x80\xF6\x09\x55\x89\x6C\x0C\x95\x83\x75\x27\x25\xA2\x0D\x0B\x00\x43\x06\x07\x00\x2D\x89\x92\x8F\xD3\x79\x10\x03\x0D\x24\x00\xBB\x89\x53\x02\x2D\x8C\x88\x03\x01\x19\xF9\x67\x75\x43\x06\x37\x01\x5D\x89\x2A\x07\x95\x86\x10\x0A\x05\x10\x12\x95\x00\x6A\x89\x1A\x07\x2F\x8B\x97\x8C\x0A\x03\x26\x94\x0F\x16\x00\xC6\x88\x69\x8B\x1C\x33\x97\x8E\x0A\x0C\x26\x83\x04\x2F", - "\x01\x90\x88\x0C\x01\x34\x8D\x78\x03\x34\x09\x00\x3B\x12\xB1\x01\xDE\x89\x45\x8B\x2D\x1B\x68\x0D\x00\x1B\x25\x97\x12\x9F\x5A\x43\x06\x06\x02\x3B\x8C\x93\x80\x4F\x82\x24\x33\x13\xA2\x89\x9B\x10\x08\x03\xD0\x00\x97\x85\x47\x84\x22\x11\x00\x43\x06\x1A\x01\x5D\x8A\x2C\x01\x9D\x8C\x4B\x84\x26\x83\x0D\x14\x00\xF7\x88\x54\x8A\xB1\x00\xA1\x80\x11\x16\x00\x09\x14\xBD\x89\x73\x14\x86\x89\xD4\x1B\x97\x83\x0B\x16\x26\xB6\x13\x19\x00\xD9\x89\x8E\x0C\x32\x8B\x97\x85\x0B\x04\x28\xB6\x02\x10\x89\x1B\x01\x71\x89\x81\x03\x9A\x86\xF3\x16\x28\xBB\x2B\x19\x8A\x23\x8B\x6D\x88\x3B\x4C\xA0\x8B\x0B\x10\x24\x9E\x00\x22\x8A\x02\x02\x87\x8B\xCC\x84\x88\x2D\x0B\x04\x28\x8A\x2F\x30\x8A\xBC\x0F\xA1\x06\x04\x03\x97\x8E\x0B\x16\x29\xB4\x13\xAF\x64\x43\x07\x0A\x03\x43\x88\xA9\x7E\x00\x83\x1A\x32\x14\xEC\x7A\x85\x89\x4D\x11\x06\x07\xA0\x83\x54\x9A\x23\xA5\x5F\x43\x06\x13\x01\xA6\x89\x5B\x7A\xAB\x01\x50\x9B\x47\x12\x15\x9D\x02\xBF\x00\x93\x8B\xB2\x13\x68\x01\x02\x1B\x25\x81\x03\x3E\x8A\xF8\x88\x81\x01\x07\x03\x68\x0F\x01\x17\x2A\x8E\xFD\x63\x8A", - "\x2C\x03\x5D\x8A\x30\x00\xAC\x82\x3C\x00\x01\x38\x14\xE8\x8A\x0C\x03\xAA\x8A\x86\x0B\x18\x0C\x56\x82\x1B\x21\x00\x38\x8A\x1E\x00\xB2\x8A\x59\x88\x90\x80\x00\x19\x2B\xA9\x15\xD9\x6E\x75\x8A\x22\x0A\x08\x00\xAF\x80\x50\x9B\x25\x85\x03\x01\x8B\x9A\x1C\x9C\x89\x59\x88\x22\x0C\x01\x1B\x25\x86\x03\x08\x8B\x53\x8A\xFF\x16\x5E\x8D\x9F\x84\x3D\x00\x01\x2A\x12\xBB\x89\xC7\x00\xC8\x89\x47\x04\x04\x08\x53\x96\x2C\x90\x04\x72\x8A\xE4\x0E\x64\x02\x66\x8B\x22\x05\x02\x18\x29\x9D\x15\xD9\x0D\x7B\x8A\x58\x89\x47\x02\x04\x04\x52\x9F\x8F\x23\x16\xA6\x07\xC0\x89\x08\x29\x6A\x8E\x20\x0A\x0C\x1A\x2A\x90\x04\x25\x00\x43\x06\x13\x03\x6C\x8B\x20\x0C\x0C\x16\x2D\xB0\x41\x43\x06\x23\x01\x5D\x8A\x33\x07\xB5\x8A\x55\x1A\x2D\x90\x04\x27\x00\xBB\x8A\x75\x8A\x67\x23\x68\x0B\x09\x87\xD9\x20\x37\x5E\x65\x26\x00\xDB\x7F\x71\x8B\x68\x06\xA5\x15\x90\x0F\x17\xCC\x58\xD2\x8A\x86\x00\x72\x8B\x82\x7D\xD4\x05\x07\x15\x11\x9B\x11\x40\x00\x9B\x7F\x44\x03\xBB\x88\x99\x6F\xEA\x31\x03\x5F\x8B\x73\x14\xA6\x7C\x90\x54\xBC\x81\xAF\x6E\xAD\x3D\x03\x68\x8B\x5B", - "\x10\x2E\x02\x78\x8B\xBA\x84\x1F\x9D\x9C\x00\x03\xEE\x65\x6A\x01\xF9\x8A\x76\x8B\x68\x07\xA0\x59\x7E\x15\x00\x40\x81\xDE\x64\x3C\x01\x76\x8E\x20\x0C\x5E\x93\x60\x78\x25\x20\x00\xF7\x8A\x2B\x05\x21\x02\xBF\x84\x60\x83\x1A\x17\xA8\x43\x3C\x09\x8D\x06\x18\x83\x8B\x20\x05\x60\x9E\xED\x64\x1F\x38\x00\x11\x8C\xAD\x09\x28\x03\xC2\x82\x10\x15\x30\x9B\xC0\x1A\x0C\x44\x01\x0C\x8F\x69\x3C\xC3\x8A\xE6\x03\x1A\x35\x03\xA0\x35\x50\x00\x11\x8F\x26\x15\x17\x04\x62\x9E\x30\xAC\x0E\x92\x43\x2A\x8D\x39\x17\x32\x05\xC5\x83\x34\x05\x08\xBE\x05\x68\x00\xC0\x80\x57\x6D\x36\x02\x8C\x83\x5E\x83\x1A\x3B\x0E\xC7\x02\x75\x01\x18\x8F\x16\x10\x1D\x04\x63\x80\x1E\xB1\x9E\x42\x8C\xC6\x04\x7B\x01\x91\x8F\x78\x89\xFD\x0D\x04\x00\x18\xD6\x04\x04\x01\x1A\x81\x89\x8E\x79\x84\x44\x38\x04\x0F\x19\x89\x0E\x52\x8C\x0F\x8C\xF7\x83\x20\x03\x0A\x19\x31\xB0\x38\x6F\x7F\x70\x5A\x2D\x8F\x2E\x88\x16\x0E\x65\x86\x1D\x2E\x00\x60\x8C\x3D\x8C\x9D\x82\x91\x25\x17\x08\x64\x9C\x15\x3E\x00\x6F\x7F\x98\x4E\x0F\x8C\xFB\x87\x28\x09\x0C\x0D\x33\x8A\x0D\x4C\x00\x70\x8D", - "\x34\x8E\x09\x45\xBB\x75\x66\x9A\x2A\x1A\x01\x6F\x7F\x5E\x52\x0F\x8E\x51\x69\x32\x02\x0E\x16\x33\x82\x0F\x69\x00\x79\x8C\xFA\x8A\x92\x64\x6A\x16\x68\x97\x9E\x09\x1A\xFB\x8B\xA0\x76\x9A\x02\x3E\x05\xCF\x85\xC9\x68\x33\x8A\x1A\x88\x85\x46\x25\x03\x03\x25\x05\x4B\x7C\x2B\x15\x04\x16\x1A\x90\x8D\x71\x82\xBF\x00\x05\x03\xD3\x86\xA6\x73\xBA\x1F\x1A\x8D\x8C\x1C\x88\x00\x01\x08\x04\xD4\x8C\x28\x8A\x1A\x35\x02\x27\x8D\x14\x8D\xA1\x05\x24\x33\xE5\x7C\x6A\x8E\x1A\x86\x0B\x45\x01\x80\x8C\x3D\x8F\x9D\x64\x27\x25\x6B\x9D\x14\x86\x0B\x3F\x80\x7C\x6A\x0F\x8E\xC2\x5C\x88\x28\x04\x1D\x35\x81\xEA\x54\x00\xC6\x8D\xC1\x07\x38\x07\xD1\x88\x6A\x85\x02\x86\x49\x56\x00\xC6\x8D\x9F\x42\x18\x01\xD9\x83\x11\x11\x07\x0C\x1B\xB1\x8D\xD0\x85\x35\x59\xB4\x89\x62\x44\x6D\x9A\x08\x17\x1B\x9D\x8C\x43\x07\xD7\x54\x35\x32\x0E\x0B\x6D\x81\xE0\x5D\x1B\x94\x50\x8A\x81\x38\x8F\xD0\x07\x7D\x65\xD9\x25\x37\x86\x74\x67\x8D\x85\x15\x74\x8E\xAE\x8C\xE6\x7A\x61\x0E\x04\x06\x1B\xF9\x48\x9B\x00\x78\x8E\xBF\x0A\x11\x8E\x95\x48\x01\x00\x17\xBB\x89\x9D\x00\x63", - "\x8F\xBF\x84\x21\x09\x02\x03\x1A\x3E\x1B\x94\x8B\xF6\x08\x15\x03\xD0\x00\xB7\x88\x70\x9D\x08\x2B\x00\x43\x06\x2D\x01\x5D\x8A\x27\x02\xE0\x8E\xF4\x71\x38\x80\xB6\x49\x8B\xC8\x4C\x7D\x8F\xFE\x2B\x68\x00\x03\x18\x38\xAF\x13\x82\x02\x2E\x01\xD6\x88\xF9\x09\x14\x0A\x71\x9B\x42\x38\x00\x0A\x81\x83\x07\x90\x8F\x2F\x3B\x97\x83\x0A\x06\x36\xB2\xEA\x3A\x00\x8A\x81\x83\x0E\xCA\x8C\x21\x08\x0A\x1B\x25\xA6\x02\x2E\x8E\x56\x05\x1E\x01\xCC\x8B\x22\x03\x73\x99\x16\x0A\x13\xB8\x8E\xA6\x06\x20\x02\x22\x84\x8A\x0D\x73\x96\x2B\x14\x13\xC0\x8E\x5A\x0A\x22\x03\xD0\x8C\xE7\x83\x34\x1B\x32\x82\x04\x2F\x01\x48\x8E\x76\x0C\x12\x03\xE9\x81\xE9\x0D\x3A\x82\x14\xD1\x8E\x9B\x10\x26\x00\xD5\x8D\x4F\x83\x34\x07\xF2\x64\x1F\x35\x01\x58\x8F\x39\x14\x14\x03\xE7\x85\x75\x8A\xFA\x3B\x12\xB8\x01\x61\x8F\x2D\x13\x14\x04\xEC\x8C\x75\x8A\xB8\x7B\x12\xBB\x01\x69\x8F\xB1\x30\xDB\x8C\xEF\x03\x34\x03\x06\x3C\x14\xF1\x8E\xBC\x05\x2C\x03\xDC\x8B\x20\x05\x74\x82\x08\x09\x03\x5E\x8A\x78\x8E\xA5\x04\x17\x03\xEF\x80\x72\x83\x1A\x19\x03\x3B\x89\xC4\x01\xC0\x8E", - "\xF0\x07\x0B\x04\x78\x80\x00\x3D\x1D\x80\x00\x6E\x00\xCC\x8A\xE2\x8F\xFC\x0D\x78\x8F\x3C\xB3\x03\x3B\x89\xCA\x01\xC9\x8C\x11\x0D\x0C\x0B\x75\x94\x3B\x90\x04\x65\x00\xBB\x89\x66\x02\xE6\x8C\xBA\x55\x79\x83\x1A\x0F\xFA\x45\x2B\xA3\x8E\xD9\x11\xE7\x8C\xEF\x86\x7A\x9B\x25\x93\x03\x29\x8F\x06\x5D\xD5\x8D\xE1\x8C\xD5\x3B\x4B\x96\x06\x30\x1E\xDD\x5E\xA5\x8E\xA0\x87\x2E\x89\x1B\x07\x7B\x9C\x91\x32\x1E\x8E\x8F\x43\x07\x74\x5D\x9A\x1C\x1B\x0D\x7B\x84\x40\x3F\x1E\x8F\x8F\xC2\x8F\xDE\x1B\x37\x05\xF8\x86\x10\x1F\x03\x07\x1F\xC3\x06\xF2\x01\x5D\x8A\x38\x04\xF9\x8A\x19\x2F\x3E\x90\x04\x16\x8E\x01\x3A\xEA\x8F\x62\x61\xF7\x8D\x40\x6A\x25\x2E\xA8\x5A\x8F\x00\x00\x73\x83\x4B\x5B\x22\x0F\x02\x1C\x38\x9E\x1C\xBF\x8A\x00\x01\xF2\x8D\xC2\x1B\x97\x8B\x0E\x05\x39\x86\x0B\x0D\x01\x28\x8E\xF2\x8F\xD0\x07\x14\x0B\x4B\x8D\x07\x20\x1F\x8F\x01\x8D\x8E\xF5\x8C\xCD\x8B\x97\x80\x0F\x00\x3F\x92\x02\x79\x8F\x43\x06\x44\x03\x2E\x8B\x1E\x00\x7E\x95\x04\x3F\x1E\xFA\x8F\x3E\x29\x5D\x8A\x3D\x00\xFC\x89\x09\x07\x40\x96\x1D\xE7\x08\xF9\x00\xF0\x8D\x27", - "\x06\x01\x9B\x12\x9A\x0A\x3C\x03\x60\x8F\xA1\x00\x0A\x90\x99\x06\x9D\x80\x7E\x85\x05\x00\x20\xE6\x8E\x67\x08\x01\x00\x26\x03\xFC\x86\x3A\x08\x05\x1F\x20\xD3\x3E\xBB\x89\x02\x03\x08\x91\xA7\x5A\x0E\x27\x41\x86\x04\x76\x8E\xE6\x29\x15\x91\x50\x5B\xAF\x7E\x82\x83\x08\x3F\x1D\xE8\x68\x32\x90\xA4\x5A\x95\x01\x16\x05\x83\x81\xD8\x7B\x12\x8E\x00\x39\x90\xA9\x5A\x56\x0C\x16\x0D\x83\x90\x3C\xBB\x12\x91\x00\x41\x90\x00\x02\xAC\x77\x16\x05\x84\x97\x3C\xA7\x11\x14\x00\x49\x90\x59\x77\x41\x83\xCC\x0A\xBB\x03\x1A\x20\x1E\x97\x17\x51\x90\x2B\x06\x2F\x05\x08\x97\x7A\x8B\x51\x19\x21\xA6\x07\xC1\x00\x0D\x90\xA6\x88\x11\x3F\x85\x81\x6E\x22\x21\xA7\x2A\xBB\x88\x10\x01\x19\x94\xDD\x09\x0C\x05\x42\xB5\x03\x3B\x89\x23\x01\x35\x93\x26\x14\x19\x07\x86\x99\x14\x83\x28\x72\x90\x73\x14\x68\x01\x1D\x95\x61\x37\xBB\x18\x43\x9B\x21\x54\x01\x7B\x91\xE8\x8C\xF3\x1E\x0F\x9B\xA8\x1B\x43\x98\x1F\xF1\x42\x84\x90\x5E\x04\x37\x05\x08\x91\x00\x1E\x3E\x99\x3F\x32\x00\x89\x90\xC2\x45\xE3\x8D\xE3\x87\xB1\x1B\x25\xB5\x00\x49\x90\x03\x8F\x19\x23\xD0\x07", - "\xF1\x89\x47\x91\x2C\x9B\x22\x32\x00\x22\x8E\xBC\x12\x0D\x01\x09\x91\xE4\x76\x27\x22\x03\x11\x81\x57\x1D\x8D\x8B\x19\x08\x07\x08\x89\x98\x0C\x24\x22\xED\x2C\xA1\x91\x4E\x2D\x2B\x96\x74\x03\x0E\x08\x45\x90\x04\x34\x00\xAA\x90\xA4\x8B\x44\x04\x07\x0F\x8A\x96\xB3\x03\x0D\x25\x91\xA0\x02\x1F\x03\x2C\x92\xAB\x04\x0E\x16\x45\x87\x06\x43\x06\x31\x01\x57\x07\x0F\x03\x18\x9C\x6E\x05\x07\x06\x23\x91\x2D\x43\x06\xB0\x5F\xF7\x3C\x19\x9B\x89\x06\x07\x0F\x23\x9A\x2D\x46\x8A\x03\x84\x35\x93\x4E\x17\x0E\x17\x46\xA3\x5A\x41\x8A\xAF\x04\x21\x03\x36\x93\xC8\x8E\x8D\x97\xB6\x07\x14\xAF\x05\x43\x01\x71\x91\x21\x85\x1C\x95\x03\x03\x1A\x01\xBE\x68\x09\xEA\x90\x5E\x05\x49\x86\xF0\x57\x8C\x93\x1B\x87\x05\x45\x00\xF1\x91\x81\x68\x3B\x93\x9F\x87\xD3\x19\x47\x82\x0F\x6C\x01\xFB\x91\x29\x17\xAB\x07\x08\x0E\x8F\x82\x1B\x2D\x03\x01\x92\x54\x24\xBC\x10\x12\x05\x20\x94\x44\x0E\x07\x08\x24\xDF\x15\x4C\x22\x86\x90\xF5\x07\x1D\x0F\x90\x99\xA7\x25\x4A\x12\x92\xF6\x08\x78\x01\x45\x92\x20\x03\x01\x0D\xB5\x18\x24\x9D\x02\xF1\x01\x8D\x90\xEF\x0F\x55", - "\x0C\x04\x1F\x48\x93\x04\x72\x01\x22\x92\x0F\x00\xBE\x0B\x1C\x9E\x04\x1D\x45\x9A\x17\x65\x91\x36\x01\xA1\x07\x0C\x03\x97\x80\x05\x06\x49\xA6\x0E\x49\x89\x76\x1D\xF3\x8D\x58\x88\x00\x08\x03\x03\x1A\x3A\x00\x3A\x92\xA8\x89\x9F\x90\x44\x04\x07\x00\x94\x90\x28\x80\x00\x42\x92\x13\x8B\x48\x4A\x4B\x94\xDD\x04\x0F\x11\x3F\xB8\x09\x39\x91\xAB\x79\x71\x90\x15\x03\x29\x93\x10\x16\x07\x25\x23\xBB\x00\xB1\x91\x34\x1E\x15\x04\x2A\x93\xA7\x17\x07\x0E\x25\xC9\x32\x50\x92\x09\x6F\x38\x91\x0B\x0C\x95\x80\x00\x39\x03\x65\x91\x44\x92\x74\x31\x51\x94\xA8\x85\x28\x03\x1A\x18\x25\x8D\x8E\xA8\x35\xA1\x05\x5A\x92\x17\x9C\x57\x9E\x01\x03\x0D\x7E\x53\xBD\x1B\x2D\x01\x59\x96\x58\x0A\x0F\x05\x47\xB6\x25\x9C\x0B\x11\x21\xB2\x93\x17\x05\x2C\x9B\x0F\x1E\x4B\x83\x0D\x0B\x6E\x69\x15\xBD\x90\x2D\x75\x1C\x90\x04\x03\x1A\x3F\x00\x3B\x89\x63\x00\xC5\x93\x4E\x91\x08\x0E\x98\x9B\x25\xA5\x01\x12\x93\xA8\x88\x21\x03\xD0\x04\x08\x0B\x96\x8E\x2A\x8C\x04\x1C\x93\xF1\x0F\xCE\x92\x27\x92\x20\x00\x9A\x89\x4A\x9A\x18\x67\x00\x98\x92\xB1\x05\x3F\x07\x2B\x94", - "\x37\x81\x4B\x9B\xEA\x63\x91\x6A\x01\xBD\x91\x39\x95\x08\x09\x95\x9D\x6D\x2C\x01\x29\x93\xB7\x12\xDD\x82\x40\x04\x36\x9A\x52\x9A\x30\x2E\x01\x63\x91\x6F\x01\xB2\x92\x00\x06\x38\x89\x99\x5F\x45\xAF\x0A\x71\x00\x36\x92\xF2\x00\x71\x92\x9C\x08\x8C\x8D\x18\x09\x27\xDD\x08\xCB\x92\x86\x02\x11\x01\x1A\x9F\x2A\x13\x03\x0F\x27\x84\x02\xD1\x92\x83\x03\x74\x95\xA1\x88\xA8\x17\x4E\x83\x08\x59\x93\x03\x03\xED\x90\x43\x05\x02\x0F\x2A\x15\x03\x1E\x27\xC5\x08\xE0\x92\x81\x02\x78\x90\xEF\x59\x2D\x27\x4F\x88\x00\x69\x93\xD8\x76\x77\x90\x0D\x1F\x3C\x99\x00\x10\x4F\xAB\x27\x8C\x87\xD4\x30\x3C\x03\x79\x92\x01\x06\x9F\x9C\x47\x8F\x2A\x67\x93\x0B\x01\xFE\x92\x40\x97\x31\x27\x9E\x8C\x00\x02\x28\x89\x92\x4D\x1B\x3D\x03\x79\x95\x01\x07\xA0\x90\x48\x9B\x23\x67\x93\x0E\x01\x06\x96\x45\x91\xFB\x1D\x07\x07\x4F\xBC\x04\xF4\x91\xDA\x92\xA8\x8A\xA5\x17\x3C\x90\x01\x12\x50\x88\x1E\x28\x06\xE7\x93\x08\x02\x87\x95\xAF\x82\x8E\x03\x47\x81\x02\x65\x92\x12\x00\xF8\x93\x11\x03\x68\x03\x04\x02\x4D\x89\x15\x82\x02\x48\x00\x16\x96\x8B\x92\x01\x43\x34", - "\x11\x51\xB0\x25\xAA\x08\x77\x93\x63\x1F\x20\x00\x37\x94\x3D\x13\x00\x3A\x26\xFF\x21\x43\x06\x90\x6E\x86\x0D\x10\x05\x96\x87\x04\x25\x25\x95\x00\x3F\x95\x24\x03\x61\x97\xD8\x19\x08\x1C\x51\xB6\x13\x17\x00\x3F\x94\x25\x03\xD0\x07\x3E\x9D\xD4\x1F\x38\xA5\xA2\x43\x06\xBC\x92\xBA\x92\x6A\x8B\x22\x0B\x04\x15\x31\xB3\x28\xA6\x07\x4C\x01\x07\x92\x96\x94\x90\x8C\xA3\x0D\x3D\xB7\x28\x8C\x02\x61\x95\x54\x8E\x95\x93\xF8\x03\x34\x0D\x02\x3B\x12\x8B\x01\x4E\x95\x17\x97\x3D\x0D\x4D\x9B\x4B\x8D\x04\x31\x29\xD6\x04\xC2\x8F\x27\x03\x97\x94\xDF\x24\xA7\x83\x78\x37\x29\xB8\x63\x43\x07\x28\x03\x9E\x94\xDD\x03\x05\x02\x53\xA4\x1F\x11\x01\xE7\x93\x0C\x00\x7C\x95\x50\x95\x81\x87\x0A\x12\x02\x67\x93\x1A\x01\x45\x96\x99\x96\x89\x27\x9E\x9B\x00\x12\x2A\x91\x8D\x1E\x02\x4A\x03\x79\x94\x03\x07\xA9\x81\x35\xAC\x05\x15\x01\xE7\x93\x0E\x01\xA7\x91\x2D\x84\x8D\x36\x04\x27\x27\x9E\x00\xF0\x93\x2A\x03\xD0\x07\x0A\x08\x71\x97\x04\x3F\x29\x83\x5B\x9B\x93\x41\x97\x40\x07\x03\x00\x9F\x8C\x55\xAF\x34\x32\x95\x10\x18\xF8\x90\x16\x03\x68\x04\x05\x1B", - "\x25\x99\x02\x11\x91\xA8\x89\x2C\x00\xAF\x93\x97\x8C\x09\x00\x56\x86\x25\xDA\x00\x5D\x8F\x5D\x8B\x27\x07\x3C\x96\x2C\x1E\x3A\x83\x04\x5D\x00\x18\x8E\x50\x03\xAB\x96\x20\x00\xAD\x9F\x52\x38\x2A\xDB\x10\xD5\x94\x50\x77\xB5\x92\xF5\x76\x9C\x92\xA7\x67\x27\xA1\x00\xF0\x92\x2F\x01\x73\x97\x8C\x03\x0A\x07\x4F\xA2\x00\x61\x95\xD4\x92\x4E\x3F\x79\x93\x04\x08\xAE\x9C\x4E\xA7\x11\x25\x01\xE7\x92\x12\x01\xBB\x93\x3C\x91\xF2\x07\x4F\xA5\x00\x73\x95\xEC\x92\x0D\x0F\x29\x07\x3C\x96\x02\x18\x57\x80\xBE\x30\x52\xE7\x92\xA4\x80\x86\x92\x6C\x11\x4F\x8D\x84\x67\x27\xA8\x00\xFE\x94\x00\x84\x0F\x7F\x3C\x99\x02\x09\x58\xAA\x2B\x6B\x28\xE7\x92\x15\x02\xC3\x94\xE3\x47\x14\x0C\x05\x27\x27\xAB\x00\x0E\x97\xD4\x5F\x53\x3D\x15\x07\x9E\x8C\x01\x0E\x2C\xB2\x2F\xA0\x34\x57\x03\x79\x95\x05\x0E\xB0\x9D\x48\xA5\x4C\x67\x93\x2E\x00\x87\x97\x05\x04\x27\x37\x9E\x8F\x01\x0E\x2C\xAA\x92\xB4\x0B\x71\x92\x2C\x05\x2C\x90\x03\x10\x4F\x9F\x01\x43\x06\x60\x01\x6D\x97\x1A\x54\xB9\x8F\x2A\x14\x05\x09\x21\xDE\x65\x31\x01\xC0\x81\xCE\x97\xAE\x7F\x0B\x1F\x59", - "\x96\x09\x3E\x00\x42\x96\x9C\x94\x03\x59\x09\x9E\x2E\x6B\x02\x27\x37\x02\x51\x43\x06\x5B\x80\x11\x2E\x1A\x0C\xB4\x96\x12\x24\x05\xC0\x54\x43\x97\xF5\x80\xF9\x0A\x1C\x05\xB5\x86\x1D\x27\x01\x4F\x96\x8A\x51\xA1\x04\x32\x82\xC8\x5D\xB5\x8A\x01\x60\x2D\xD6\x95\xFD\x83\x11\x1E\xD1\x92\x49\x29\xB4\x9B\xE1\x7D\x36\x05\x00\x99\x00\x7B\x92\x40\x00\x12\x07\xB6\x91\x13\x0E\x18\xCA\x10\x71\x96\x42\x86\xD8\x06\x13\x05\xB7\x9D\x69\x03\x0D\x1F\x66\x88\x31\xBC\x94\xE1\x82\x78\x0C\x0A\x1D\x5B\xB7\xA2\x43\x06\x9B\x86\x6A\x31\x0A\x02\x70\x98\x9F\x94\x1E\x3A\x02\x06\x97\xC0\x50\x13\x8F\xAB\x05\x06\x0C\xB8\x96\x1C\xBD\xE6\x10\x97\xC9\x51\xA1\x07\x8B\x8C\x2D\x01\x04\x15\x5C\x9F\x0E\xC4\x08\xD6\x00\xCC\x95\xD6\x97\x16\x7C\x3F\x3E\x5C\xAE\xDA\x64\x01\xE7\x1A\xAF\x53\xE8\x94\xF7\x76\xD5\x1E\x5C\xAD\x02\xA2\x97\x43\x06\xA7\x75\x64\x06\x0C\x0E\xBA\x9A\x05\x88\x08\xD0\x96\x1B\x82\xEA\x36\xE7\x96\x5B\x6F\x00\x14\x13\xBE\x2D\xD4\x8C\xAE\x2B\x3E\x03\xEE\x96\x4A\x0C\x01\x1E\x5D\x87\x2E\x8D\x95\x34\x02\x44\x02\xE9\x92\x63\x28\x20\x90\x6B\x6B", - "\x2E\xEC\x66\x67\x09\x4A\x03\xF2\x94\x89\x3D\xBC\x81\x5B\xAA\x19\xB7\x5D\xB5\x96\x7F\x67\xED\x96\x7A\x91\x14\x8B\x2D\x19\x2F\x84\x42\xDB\x96\xB4\x97\x9E\x8D\x07\x43\xBD\x9A\x2A\x1D\x08\xFC\x6A\xCF\x96\x00\x03\xA0\x8E\x2F\x07\x0C\x1F\x5E\xAC\x1B\x74\x00\xE1\x96\xBB\x97\xFF\x86\x22\x8E\xBE\x9E\x56\x71\x2F\xBF\x97\x05\x89\xC8\x03\x37\x05\x7C\x97\x57\x35\x5E\xA2\x2F\xE3\x90\xAE\x2A\x76\x00\xFF\x90\x09\x4E\xBF\x92\x5F\x9E\x2A\xDA\x02\xF9\x01\x01\x9B\x0D\x1D\x80\x98\xBF\x84\x55\xA0\x6A\x06\x00\x9A\x00\x4E\x8E\xD2\x00\x18\x0C\xC0\x87\x5E\xB8\x05\xBD\x1B\x13\x01\x08\x99\xA9\x8F\xB7\x38\x20\x8A\x5D\x83\x0D\x79\x7D\x44\x28\x10\x02\x06\x9D\xD5\x82\x3C\x1F\x06\x1D\x30\xDC\x97\x86\x82\xF2\x0D\x0B\x03\x84\x92\x04\x79\x01\x2C\x30\xF9\x74\x29\x6D\xFB\x96\x05\x99\x87\x8D\xDB\x1B\x01\x2F\x30\x81\x75\x47\x01\x1B\x9B\xE0\x04\x1F\x02\xC3\x91\x5C\x99\x1B\xF6\x61\x37\x98\xA3\x4A\x0E\x9E\x2C\x05\x2A\x98\x5D\xA7\xEF\x59\x1F\x57\x01\x20\x99\xDB\x13\x88\x9E\x36\x65\x62\xA8\x30\xE6\x48\xE4\x0F\x32\x02\x12\x9A\x87\x1C\xC4\x90\x83\x0E\x31", - "\xFF\x97\xF4\x8C\xF2\x0F\x1C\x07\x86\x99\x47\x40\x04\x15\x31\xC5\x2C\xA5\x84\xAF\x51\x18\x03\x68\x0B\x05\x1B\x25\x82\x02\x37\x98\x99\x91\xEF\x53\xD0\x03\x8C\x97\xA6\x86\x08\x23\x01\x56\x90\xBB\x89\x41\x00\x1A\x9E\xE9\x77\x85\x8C\x08\x2B\x01\x18\x8E\x84\x01\x2F\x99\x29\x65\x5B\x93\xBE\x33\x63\x86\xC9\x3C\x86\xC8\x1D\x71\x96\x86\x0F\x10\x0E\xC7\x89\x3A\x80\x32\xE6\x00\x43\x07\x34\x02\xCE\x92\x69\x08\xC8\x99\x36\x23\x2A\x05\x99\x72\x13\x43\x99\x36\x97\x8C\x09\x08\x10\x64\xA0\x03\x92\x99\x10\x02\xF2\x90\x3E\x46\x92\x93\xA7\x07\x02\x18\x32\x97\x0B\xAF\x05\x45\x00\x27\x9B\x0B\x18\x04\x1F\x64\x86\x04\x6F\x91\x1A\x0C\x46\x03\x28\x9E\x58\x09\x04\x06\x65\x8D\x2E\xCF\x3A\x8D\x01\x55\x99\xA3\x86\x95\x9A\xB0\x8D\xF4\x32\x32\xC7\x16\xB4\x99\x87\x97\xC0\x1F\x96\x92\x3C\x0C\x02\x39\x32\x94\x96\x34\x02\x48\x00\x2F\x9A\x6C\x0D\x04\x19\x65\x9A\x2C\xA0\x03\x91\x01\x61\x98\x11\x0E\x09\x09\xCB\x80\x59\x8F\x75\x12\x01\xCA\x98\xEA\x05\xAB\x83\x60\x96\x9D\x5A\x50\xA4\x76\x51\x99\xF6\x08\x28\x01\x2E\x9B\x65\x97\x46\x14\x04\x18\x33\x9D", - "\x02\x51\x01\x5C\x98\xCC\x91\x20\x43\xCA\x96\x04\x3A\x31\xBD\x2E\x80\x99\x33\x00\x1F\x9C\xFC\x08\x09\x1F\x66\x93\x04\x53\x00\xE9\x98\x41\x99\xCE\x46\x9D\x95\xD2\x11\x67\x8E\x32\x8B\x26\xF4\x99\xB4\x4A\x3D\x98\xEB\x08\xDA\x19\x67\x86\x04\x56\x00\xFB\x99\x0D\x07\xAB\x04\x13\x0E\xCF\x8A\x75\x01\x34\x83\x02\x14\x01\x57\x05\x27\x05\xA0\x92\x10\x18\x02\x07\x34\x94\x04\xFE\x4C\x86\x98\x00\x01\x0B\x0F\xD0\x9F\x5C\xA0\x6A\x1F\x01\x12\x9A\x2D\x01\x45\x9C\x69\x83\x11\x00\x05\x12\x34\xDB\x00\x15\x9B\xCC\x5D\xC5\x22\xA2\x95\x2B\x94\x66\x89\xB0\x43\x06\xC0\x98\x8F\x02\x28\x02\xA2\x9D\x05\x15\x68\x87\x33\x91\x03\xA3\x00\x89\x9A\x17\x05\xA2\x9E\xCC\x80\x0D\x24\x02\x12\x9A\x5F\x01\x8A\x9A\xC9\x92\xC3\x05\x0A\x12\x68\xA0\x01\x15\x9A\xDC\x98\x0D\x0E\x29\x02\xA2\x91\x06\x15\x68\xA3\x33\xE4\x0F\xA7\x01\x51\x98\x2A\x07\x9C\x95\x8D\x20\x64\xA8\x01\x43\x06\x64\x01\x5D\x8A\x2A\x02\xA2\x96\x2C\x0A\x64\x8E\xB7\x0B\x99\xC2\x06\x35\x03\xD0\x02\x9D\x9D\xC6\x85\x4D\x09\x32\xD8\x9A\x62\x07\x3B\x9B\x7B\x50\xAC\x94\x44\x0C\x03\x03\x0D\x11\x8F", - "\x67\x09\x55\x00\x55\x9C\x57\x08\xD6\x8C\x08\x38\x01\x18\x8E\xAC\x00\xA6\x9A\xB1\x07\x0D\x0B\xCE\x9D\x75\x52\x34\xE3\x00\x80\x98\xBA\x9B\xD5\x5D\x64\x22\xD1\x84\x03\x39\x35\xE9\x95\x1A\x0C\x58\x02\x44\x9D\x0C\x0F\xD7\x8E\x57\x9A\x18\x31\x01\x12\x9A\x33\x01\x61\x9C\x5E\x97\x46\x12\x05\x12\x34\xE7\x00\x8B\x9B\x7C\x94\xF9\x0B\x16\x02\xD1\x88\x03\x11\x36\xFF\x95\xBE\x0A\x89\x99\xAF\x86\xA4\x9A\xD7\x9A\x5B\x94\x63\x35\x01\x12\x9A\x35\x03\x65\x9D\x96\x99\xFD\x16\x05\x12\x34\xEB\x00\xA3\x9A\x5D\x9A\x1F\x2A\xA2\x9C\x06\x09\x6D\xA9\x34\xA4\x6F\x12\x9B\x36\x01\x6A\x9F\xA5\x9E\x17\x19\x05\x12\x34\xEE\x00\xA9\x9B\x9A\x9A\x41\x82\xA2\x9F\x06\x09\x6D\xBB\x34\xCD\x7B\x12\x9A\x38\x01\x6A\x99\xA8\x94\x7E\x1C\x05\x12\x34\xF1\x00\xA9\x9B\xA3\x9A\x26\x23\x94\x9E\x0B\x0C\x6A\xB2\x01\x00\x99\x70\x00\xC4\x94\xC6\x88\x18\x02\xD7\x9A\x4D\x03\x0D\x74\x00\x64\x9A\xEA\x05\x1C\x06\xC4\x89\xDD\x96\x27\x1B\x37\x90\x02\x76\x01\xEE\x98\x83\x5B\x68\x03\x07\x18\x38\x82\x03\x55\x9B\x4A\x07\xF2\x9B\xCF\x5A\xBC\x93\x11\x0A\x6F\xBF\xC3\x6C\x9B\xEB", - "\x9B\x6B\x4C\xC6\x8C\x18\x08\xDE\x82\x1E\x35\x01\x43\x06\xE1\x9B\xAE\x9A\x40\x01\xBF\x9C\x10\x0D\x03\x0E\x16\xEB\x9A\x4A\x07\x3B\x03\xD0\x01\xBA\x9A\xDF\x80\x00\x2F\x35\x90\x02\x9D\x9A\x0D\x3C\xFA\x8E\x58\x09\x07\x11\x5D\x98\x16\x80\x9C\xC2\x07\x3D\x01\x8E\x97\x8C\x08\x0C\x12\x68\xB3\x01\x00\x99\x7C\x00\x1F\x8F\x2E\x89\x19\x00\xE1\x82\x1B\x3D\x01\x75\x9A\x53\x33\xFA\x9A\xD8\x04\x0E\x00\xC8\x9F\x70\xBB\x35\x96\x29\x22\x9C\x22\x08\xB0\x86\xA4\x96\xE2\x9F\x7A\x6F\x0A\x4E\x01\x29\x9C\xBC\x39\x89\x9B\x92\x9A\x61\x10\x06\x31\x38\x89\x10\x33\x9D\x4C\x9B\xAB\x02\x1A\x07\xE3\x9D\x08\x38\x01\x39\x9C\xA0\x99\x33\x08\x35\x05\xC7\x9D\x54\x00\x72\xA7\x32\xB2\x5C\x44\x9D\x65\x06\x91\x9F\x95\x90\x1A\x18\x06\x09\x39\x84\x10\x4B\x9C\xD2\x9A\x91\x22\x1B\x0F\xE4\x9C\x96\x11\x39\xAA\x9B\x6C\x47\x2A\x9F\x40\x05\x0F\x07\xE5\x8F\x6D\x99\xCF\x5A\x9C\x02\x02\x3F\x03\x95\x9C\xB6\x9C\x16\x00\x07\x20\x39\xC7\x05\x57\x9C\xDD\x9A\x5F\x02\x1C\x07\xE6\x80\x04\x17\x39\xBF\x9B\x78\x12\x72\x03\x99\x99\x10\x07\xE5\x84\x6E\x8B\x9D\x67\x9C\x82\x01", - "\x2B\x9E\x72\x9D\xA9\x18\x0E\x0C\x6A\xAA\x03\x4C\x9A\xCA\x84\x93\x9B\x1F\x04\x67\x9A\x22\x37\x61\x9E\xCB\x04\x01\xF0\x84\x86\x03\xA0\x9F\xAE\x77\x0F\x06\x74\x96\x09\x11\x01\x89\x9D\xE6\x8E\xD2\x91\x04\x9B\x09\x12\x5B\x9A\x91\x57\x98\x8A\x9D\xA8\x95\x11\x4D\xD2\x9E\xD9\x94\x1E\x2C\x02\x18\x9D\x92\x9D\xB9\x7D\xDC\x2C\xD3\x93\xB8\x8B\x0A\x60\x3A\x83\x02\x8B\x9D\x3D\x70\x49\x24\xD4\x9C\xE4\x93\x08\x08\x03\x27\x9D\x02\x03\x54\x9E\x41\x03\x10\x00\xDF\x99\x74\xA9\x2D\xF8\x12\x32\x00\x56\x9E\x94\x9A\x78\x06\x0D\x11\x74\xA8\x3A\xC3\x06\x0D\x77\xEC\x1D\x0F\x02\xD7\x96\xD1\x85\xFA\x70\x3A\xC7\x05\x77\x97\x33\x09\x12\x04\xD8\x9E\x13\x87\x76\xB2\x3A\x85\x35\xC5\x46\x66\x9F\xCF\x0E\xD9\x98\xB8\x8E\x8B\x12\x3B\xD0\x07\x9E\x86\xCC\x4F\xB3\x9E\xCE\x5F\x2A\x0D\x03\x17\x3B\xAD\x47\xD9\x9D\x89\x03\xB6\x98\x8C\x7A\x4B\x5F\x76\xB2\x4C\x61\x9D\x57\x63\x1A\x8F\x3A\x14\xD8\x9E\x6A\x77\x01\x1E\x0E\xDE\x52\xE3\x9D\x1F\x8C\x4D\x02\x12\x06\xEE\x80\x07\xA8\x3B\xB6\x9D\x47\x43\xCF\x0D\xBD\x98\x1D\x87\xEF\x81\x75\x8C\x19\x93\x77\xC4\x9C\x6F", - "\x66\x18\x07\x81\x81\xEB\x83\x1A\x0A\xE8\x15\x61\x01\x9F\xEC\x54\xC1\x98\xD9\x98\xBC\x9E\x08\x00\x03\x6C\x9D\xB5\x54\xCF\x84\x5C\x5B\xDC\x9E\x74\x92\xD1\x10\x3C\xA6\x07\x8C\x00\x89\x9E\xB8\x9B\x68\x09\x65\x64\xF6\x3B\x3B\xAA\x66\xFD\x9D\x5F\x9E\x2A\x7B\xE9\x4F\xF1\x8E\x15\x61\x3C\x85\x9E\xFA\x7E\x22\x2A\x3C\x07\xE2\x9A\x55\x18\x05\x2F\x3B\x9B\x9E\x02\x81\x2A\x95\xC9\x9C\x57\x07\x0C\x07\x79\x8C\x3C\x8B\x8D\x4D\x1B\x05\x00\x27\x06\xD2\x95\x0D\x16\x79\xA3\x3B\xDD\x90\x7F\x0F\x9D\x9F\x06\x9E\x58\x03\x0E\x1A\x78\xA9\x3B\x98\x95\x9B\x8A\xA1\x9C\x09\x9A\x6C\x03\x0F\x06\x7A\xB8\x3B\x8E\x98\x4F\x3B\x18\x02\xD2\x9E\xD6\x8C\x2B\x03\x00\x20\x37\x13\x9E\xC1\x8F\x5D\x8A\x0F\x03\xEA\x9E\x6B\x94\x39\x17\x3D\xB0\x9E\x17\x99\xEC\x1F\x12\x04\xEB\x96\x2A\x93\x53\x23\x00\x60\x1B\xF0\x9D\x0F\x9B\xAB\x00\x0B\x04\xF6\x8E\xB5\x72\x00\x68\x9E\x60\x9F\x14\x98\x5E\x15\x0C\x04\xF6\x9F\x09\x71\x01\x64\x9E\x83\x07\x20\x00\x78\x1A\xDB\x93\x34\x1C\x5C\x4F\x75\x73\x00\x75\x9E\x71\x9C\xDE\x9B\x4A\x4B\xF7\x91\x7B\x81\x11\xE4\x0F\x81\x01\xC0\x9F", - "\xA5\x03\xF0\x98\x8A\x05\x7C\x87\x3D\xC7\x98\x46\x25\x47\x02\xE2\x9B\x91\x6C\xF8\x96\x63\x8E\x3E\xCF\x9E\x50\x98\xBC\x11\x27\x03\xF2\x96\x10\x09\x05\x15\x3E\x86\x02\x79\x01\xCB\x9E\xBF\x9F\xA4\x7D\xDB\x0B\x05\x2D\x3D\xBA\x7E\x9F\x9E\xE5\x60\xDC\x9E\x2B\x63\x34\x01\x04\x35\x3A\x86\x02\x80\x01\xA1\x04\xAD\x9D\xC0\x9E\xFA\x94\xFA\x6C\x93\x64\x9E\xDE\x65\x37\x88\x7C\x65\xF6\x90\x9D\x4E\xA4\x38\x3E\xD6\x04\xA3\x01\x2E\x8B\x40\x04\xF7\x98\x9D\x56\xEE\x1C\x3E\x9B\x11\xB0\x00\xD1\x9F\xF0\x9A\xD3\x9A\xB3\x07\x7E\xA7\x50\x4A\x9F\x02\x02\xE2\x9D\xDA\x81\xCF\x4E\xFC\x9B\x42\x3D\x16\xC0\x54\xD2\x9E\xA9\x4C\xF9\x0C\x1E\x05\xFD\x87\xEE\x10\x3F\x80\x00\xD9\x9E\x83\x74\x5E\x15\xE2\x7D\x37\x83\x32\x82\x3F\xD1\x9F\xC0\x9D\x57\x07\x02\x04\xCB\x1E\x2E\x75\x07\x1F\x3F\xE1\x9F\x0F\x8D\xF2\x48\xFB\x9E\x4A\x03\x00\x00\x06\x98\x9E\x61\x9F\x80\x96\xD7\x2B\x08\x03\xFE\x99\x70\x16\x7F\x93\x04\x61\x9F\x89\x96\x50\x37\x0B\x04\xFF\x9A\xBD\x1E\x7F\x90\x04\x61\x9F\x27\x8D\xA7\x3B\x0E\x04\x00\xA8\x60\x26\x80\xA0\x15\x1A\x97\x03\x92\x06\xA3\x26", - "\x13\x07\x0E\x00\xA6\x08\x21\x3F\xB6\x8C\x6C\x03\x29\x00\x97\x1E\xD5\x69\x04\x00\x06\x9E\xA5\x61\x9F\xF2\x9C\x8F\x00\x18\x02\x02\xA3\xA7\x18\x02\x15\x40\xCB\x9F\x46\x8C\x50\x34\x1B\x04\x04\xAB\x85\x06\x03\x27\x40\xE8\x9F\xB9\x97\xEC\x1C\x1E\x04\xCB\x1E\x2D\x74\x03\x14\x1A\xA8\xA0\x4D\x85\x1D\x28\x0D\xA6\x90\x37\x03\xB0\x81\x94\x0F\xC4\x28\x8E\x01\x0D\xA2\xA7\x40\x18\x80\xD7\x41\x7F\x95\x3C\x9B\x01\x42\xA0\xD3\x06\x27\x04\x08\xAF\xFF\x9C\x78\xB0\xA4\x2C\xA0\xC6\x04\x57\x03\x0B\xA0\xFC\x93\x34\x13\x33\xB4\x04\x34\x01\x50\xA0\x5E\x04\x2F\x03\x0A\xA1\xFE\x83\xF1\x51\xAC\x49\xA0\x9D\x6C\x0F\xA1\x13\xA1\xE6\x99\xE6\x0D\x06\x19\x41\xCA\x06\xD9\x00\x2E\xA3\x80\x98\xBF\x17\x06\xBF\x54\x2A\x41\xC8\x9E\x13\x03\x72\x00\x18\xA4\xDD\x05\x0F\x0C\x82\x87\x40\x93\x95\xD4\x3D\x39\xA1\x0C\x5E\xD8\x85\x04\xB9\x7A\xB1\x1C\x7A\xA0\x73\x15\x0A\x00\x1F\xA3\x0C\xA7\xC0\x87\x0A\x0C\x00\x0D\x14\xAE\x6D\x12\x03\x20\xA7\x0E\xA2\x42\x8E\xAD\x19\x00\x08\xA1\xD4\x70\x63\x8F\x07\xA2\xED\x94\x12\x30\x84\xB9\x97\x12\xA1\x84\xA0\xB9\x9D\x53\x1B", - "\x06\x0D\xA0\x1F\x09\x7F\x00\x0D\x14\x83\x07\x29\x02\xB1\x8F\xFE\x9D\xF7\x86\x10\x9D\x42\xD5\x41\xA0\xA0\xE8\x57\x28\xA1\x13\xA7\xF8\x98\x4B\x0F\x01\x27\xA1\x50\x4F\x54\xA0\x82\x9B\x15\xAC\x08\xB0\x7C\xB8\x5E\x30\xA1\x0C\x03\x34\x02\x2C\xA2\x48\x24\x0B\xAF\x80\x9D\xF4\x4D\x1A\x6B\x00\x5C\xA2\x41\x07\x0E\x0B\x0B\xB8\x57\x7D\x42\x96\xA0\xC1\x8F\x16\x4E\x25\xA5\xA1\x25\x0C\xA3\x08\x19\x02\x18\xA1\xA2\x39\xD6\x9F\xEB\x9B\x20\x02\x08\x12\x7D\x93\x43\x82\x02\xB3\x9E\x86\x02\x1F\x03\x97\x88\x08\x0D\x50\x29\x31\xD1\x05\x43\x07\x71\x9D\x27\x92\x4E\x96\x2C\x05\x04\x01\x20\xD7\xA1\x82\x05\xA1\x05\x22\x00\x1D\xA7\x08\x1A\x5C\xBB\x12\x89\x01\xCD\xA0\xE5\x8A\xF5\x56\x1D\xAB\x6E\x31\x87\x85\x14\xD4\x07\xEB\xA1\xC1\x60\x3A\xA2\x11\x07\x0E\xA7\x23\x0D\x02\x5E\xA1\x6B\x6A\x8A\x8D\xB3\x62\x1D\xAB\x4B\x8E\x04\x00\x44\xA6\x07\xA9\x00\x81\xA2\x41\x3B\x68\x0E\x08\x08\x87\x8C\x02\x35\x93\xD9\x1F\x47\x02\x3D\xA6\x55\x45\x72\x8F\x88\xBD\x26\x87\x95\x07\xA3\x09\x6A\x3D\xA4\x15\x0A\x10\xBE\x98\x50\x44\xC6\x24\x94\x01\x89\xA1\x6B\x75\xE4", - "\x8D\x08\x0E\x4D\xAE\x11\x99\xA2\x31\x46\x7B\xA0\xD4\x8E\xA4\x9D\x10\xB0\x08\x0F\x02\x68\xA1\x2D\xA3\xCB\x7A\x91\x21\x13\x08\x12\xA8\x7E\x9D\x44\xED\x05\x20\x9C\x6A\x4A\x48\xA2\x69\x01\x0B\x05\x39\xAF\x44\xB3\x8A\xAE\x2A\x4E\x01\x4D\xA6\xF3\x47\x13\xA2\x08\x3F\x44\xA1\x16\x0A\x9B\x9D\xA1\xC8\x4E\x27\xA0\xD8\x84\x3F\x1F\x02\x4A\xA2\x62\x06\x5B\x00\x53\xA6\xB0\x93\x72\x90\x8A\xBF\x98\x53\xA2\x8C\x9A\x0D\x0F\x28\x06\x2A\xAE\xB8\x98\x8A\x92\x36\xF8\x12\xA5\x00\xAE\xA2\x3D\x0C\x17\x0E\x15\xB8\x6C\xBA\x2B\xE2\xA2\x1D\x02\x5F\x01\x59\xA6\x72\x9F\xD4\x29\x05\x28\x45\x93\x02\xC0\x01\xB5\xA0\x14\x65\xA9\x1B\x0A\x0F\x8B\x90\x04\x42\x01\x72\xA2\x91\x9A\x86\x0D\x15\x06\x17\xA7\xAD\x72\x45\xDE\x9C\x10\x03\x57\x01\x5F\xA6\x20\x06\x0C\x12\x8B\xA4\x39\xCF\x46\x83\xA2\xA1\x5E\x5C\xA2\xCD\x9C\x16\x13\x05\x09\x46\x82\x02\x99\x8E\x4B\x67\x51\xA5\x21\x0A\x11\x4F\x8C\x80\x00\x4C\x01\x72\xA2\x3B\x9D\x53\x1F\x16\x06\x19\xAE\x06\x32\x45\xFB\x9C\x69\x1D\x5C\x02\x3D\xA3\x17\x06\x0F\xB0\x06\x25\x1C\x90\x01\x39\xA3\xDE\x19\x2F\x06\x32\xA2", - "\x0D\x07\x8D\xB2\x33\xF8\x12\xBF\x00\xCB\xA0\x35\x06\x35\xA7\xCF\x9A\x30\x01\x03\x16\xA3\xB6\x8E\x4B\x64\x6A\xA4\x2A\xA8\x97\x03\x06\x16\x46\xD8\x01\xB4\xA3\xAC\xA1\x11\x46\x32\xAA\x0D\x01\x8E\x9F\x45\xCD\x1A\xC7\x00\xCB\xA0\xF1\x8A\x37\xA2\x9F\x87\x23\x09\x03\x16\xA3\xDE\x00\xE3\xA1\xAB\x9E\x2F\x0B\x0C\x16\x8C\xA0\x03\x52\xA3\xBB\x9C\xD7\x29\x33\x06\x32\xA3\x7D\x8C\x8E\x83\x28\x9A\x0C\xCF\x00\xCB\xA0\x39\x00\x3B\xA1\xFA\x59\x7E\x11\x03\x16\xA3\xE6\x00\xF2\xA3\x61\xA7\x28\x03\x0D\x16\x8C\xA8\x03\x64\xA3\x8C\xA2\xAD\x01\x35\x06\x32\xAA\x0E\x04\x8F\xB0\x39\xCD\x1A\xD7\x00\xCB\xA0\x3B\x04\x3C\xAA\x19\xA9\x73\x19\x03\x16\xA3\xEE\x00\xF2\xA0\x68\xA5\xB7\x1B\x0D\x16\x87\x9D\x03\x76\xA1\xFD\x8E\x4B\x65\x24\x03\x68\x0B\x08\x1B\x25\x9F\x03\x43\xA2\xF7\xA0\x20\x6B\xD0\x03\x37\xA3\xA6\x8B\xF3\x54\x0F\x12\x01\x13\x9C\x03\x10\x84\xA6\x58\x02\x0F\x05\x8A\x80\x00\x13\x01\x7F\x96\x74\xA0\x88\xA0\x22\x01\x13\xAA\x70\xBB\x24\xC1\x0B\x0E\x8C\x74\xA1\x25\x03\x68\x07\x09\x1B\x25\xA1\x03\x1B\xA4\xE8\x8F\x16\xA4\x50\xA4\x49\x30\x23", - "\xB6\x46\x1E\x48\x98\x01\x43\x06\x4B\x03\x2E\x8B\x1C\x05\x23\xA8\x25\x99\x02\x43\x06\x9B\x00\x74\xA3\x8F\xA4\x33\x08\x0E\xA1\x92\x96\xCA\x3D\x1B\xE4\x01\x1E\xA6\xD8\x04\x1E\x0E\x21\xA6\x92\x81\x28\x45\xA4\xAF\xA3\xEE\x8A\x92\xA4\x88\x05\x0F\x0D\x92\x8D\x45\xCB\x4E\x53\xA4\xEA\x07\x02\x96\xA4\x9E\x24\xA6\x08\x28\xBD\x67\x08\xE7\x01\x2C\xA6\x3D\x0F\x1E\x06\x25\xBA\x71\xAB\x18\x62\xA4\x1C\x65\x32\xA5\x90\x9A\xCD\x68\x26\xB3\x08\x11\x20\xDC\xA4\xCD\xA2\x0D\x0E\x3A\x05\x4D\xA0\x11\x1A\x07\x2A\x49\xA5\x9D\xD4\x31\x75\x00\x9D\xA7\x84\x07\x27\xB6\xAF\x4D\x35\x6C\x01\x7B\xA5\xE0\x01\x9F\xA0\x71\x1F\x2A\x0D\x07\x01\x4A\x83\x02\xFD\x01\x41\xA5\x79\xA6\x48\x2E\x0E\x07\x94\x9E\x01\x8A\xA5\xEB\xA2\x9A\x03\x3B\x06\x51\xAB\x1C\x0A\x94\xB1\x47\xC7\x02\xF0\x00\x4A\xA4\x00\x03\x1C\x9D\x25\xA3\x08\x37\x47\xE4\x40\x94\xA5\x00\x00\xA7\xA3\x68\x0D\x1F\xA7\xE3\x54\x4A\xA2\x90\x70\xA4\x41\x43\xAB\x03\x1E\x00\x21\xB4\x07\x36\x43\x83\x00\xE3\x90\x4E\x01\x6A\xA1\xFB\x16\x0F\x14\x94\x84\x00\x31\xA5\x51\xA4\x89\x38\xA5\xA2\x05\x96\xD2\x92", - "\x95\xB5\x46\xE4\x0F\xF8\x00\x4A\xA6\x01\x00\x57\xAC\x1B\xAD\x6A\x39\x03\x14\xA5\x07\x00\x62\xA6\x70\xA0\x2F\x1A\x0F\x14\x94\x88\x00\x4A\xA5\xC7\xA3\x34\x1F\x3E\x04\x52\xA9\x00\x10\x96\xA6\x45\xF9\x3B\x94\xA4\x05\x02\xB5\xA4\x2D\xA0\x1A\x1D\x07\x14\x4A\x8B\x00\xDB\xA5\xB9\xA1\x9A\x1E\x1F\x04\x29\xAC\x00\x21\x4B\xFA\xA2\x1A\x3C\x4A\xA5\x03\x01\x5C\xA0\x18\xA3\xAD\x23\x59\x40\x90\xBD\xA5\xA1\x05\xA4\xA6\x23\x01\x00\x11\xF9\x23\x59\x0F\x00\xE1\xA5\x4B\xA4\x4D\x02\x00\x06\x2F\xB6\x12\x10\x00\x61\xA5\x9F\xA5\xDE\x1B\x00\x05\x5F\xA9\x70\x01\x97\xA5\x4A\xD9\x1F\x04\x00\x82\xA6\xCB\x09\x5C\xA3\x20\xB9\x7E\x05\x00\x0A\xA6\x3F\x03\x98\x3F\xE0\x03\x02\x03\x8E\x9D\x04\x3D\x3D\xE8\xA1\x16\xA7\xF5\x8E\x39\x2A\x62\xAB\x34\x25\x4B\x99\x4C\x8C\x02\xF4\x8F\x33\x0A\x02\x01\xE6\x32\xAB\x76\x00\x3E\x21\x9F\xA6\xDD\x87\x5D\x89\x03\x04\x64\xA6\x25\x19\x00\x27\x4C\xFD\xA1\x1A\x0C\x08\x00\xCB\xA1\x2A\x89\x84\x94\x22\x28\x4C\xC6\x8E\x0A\x23\x99\xA5\x65\x45\x66\xAE\x4F\x66\x54\xB8\x25\x16\x00\x3A\xA7\x26\x5C\xCF\xA4\x48\xAD\xF0\x9D\x08", - "\x19\x00\x41\xA6\xC9\x23\xA1\xA7\x93\xA0\x22\x0E\xAC\x8D\x6A\x1C\x00\x48\xA6\xE2\x19\x97\xA4\x08\x91\xAD\x50\x35\xBB\x42\x2F\x00\x52\xA6\x28\x90\xD6\x15\xD5\xA6\x58\x00\x89\x84\x41\x8B\x4D\xDA\x6F\xBB\x89\x12\x03\xD6\xA0\x3D\x28\x35\xB1\x7B\x3B\x12\xA8\x00\x63\xA6\x73\x31\xD9\xA1\xBB\x3B\x4B\x8B\x01\x29\x4D\xC2\x07\x3B\x01\xB5\xA6\x4F\x0B\x97\x8E\x02\x0F\x9B\x93\x54\x72\xA6\xB2\x0F\x5D\x89\x0C\x06\x6E\xA4\x44\x01\x02\x0A\x4D\xE4\x1F\x70\x99\x8F\x18\xDF\xA4\x7A\x08\x8F\x9E\x9A\x80\x4E\xF0\xA0\x73\x31\xC1\xA4\xE4\x27\x6F\xA6\x4C\x78\x83\xB8\x25\x3A\x00\x8A\xA7\x8E\x01\x49\x94\x0A\x9F\x35\xA4\x86\x3B\x12\xBD\x00\x91\xA6\xA1\x44\xDE\xA7\x0D\x9F\xFD\x39\x9C\x87\x29\x0C\xA7\x7B\x5A\x3F\xA2\x86\x0B\x08\x0E\x39\xA4\xC6\x20\x4E\x97\x46\xA2\xA6\xF2\x0E\x11\x05\x74\xA9\x76\x47\x9D\xB7\x4C\x82\x02\x82\x90\xA6\x20\xEB\xA3\x20\x03\x98\x94\x9C\x87\x4E\xD9\x2B\xBB\x88\x26\x03\xEC\xA2\x20\x01\x99\x86\x9C\x8D\x4E\x90\x02\xA7\x8A\x0D\x0F\x13\x00\x62\xA5\x0A\x75\x98\x83\x0D\x0D\x91\x67\x08\x28\x03\xEE\xA1\x81\x5E\x87\x9E\x04\x17", - "\x4C\x85\x9C\xCE\xA6\x8D\xA6\x27\x74\x63\xA6\x3A\x11\x4D\x96\xCA\x51\xA7\x20\xA7\x5D\x89\x15\x03\x79\xA7\x9B\x9E\x9D\xA7\x39\x43\x06\x35\x8F\x2B\x17\xF2\xA1\x38\x9E\x3D\xBA\x22\x70\x4C\xE4\x0F\x5B\x01\xE5\xA6\x1C\x07\x74\xA8\x3D\xA9\x40\x96\x1C\x4B\xA7\x76\x00\xF6\xA6\xCF\xA5\xA9\x11\x06\x0B\x9E\xBA\x01\x72\xA7\x45\xA7\x3E\x07\xF2\xA6\x0F\x08\x3F\xBB\x40\xA7\x11\x67\x00\xCB\xA6\x41\x01\xF3\xA4\x45\xAB\x4B\x8A\x03\x0B\x4F\xC4\x94\xE5\xA7\xF6\xA5\x2B\x8B\x97\x8D\x06\x0B\x9E\x88\x02\x03\xA8\x50\x7B\x5D\x88\x1C\x03\x79\xA0\xA7\x89\xA0\x83\x0D\x37\x90\x4A\x0F\xE5\xA6\x23\x00\x82\xAC\x10\x07\x3C\x99\x4B\x4B\xA7\x88\x94\x0B\xAB\x6B\x5B\x97\x89\x07\x0B\x9E\x9A\x2A\xA2\xA8\xDA\x0B\x5D\x88\x1F\x03\x79\xAE\xAA\x96\x9D\x91\x0C\x01\xA7\x23\x47\xE5\xA7\x26\x04\x83\xA0\xC0\x94\xC6\x02\x02\x4B\xA7\x9E\x01\xFE\xA5\x0D\xA8\x54\x35\x08\x0B\x9E\xA2\x02\x3A\xA8\x68\x91\x33\x08\x22\x03\x79\xA6\x0A\x14\xA1\x83\x04\x1C\xA7\xAB\x23\xE5\xA5\x2A\x00\x88\xA6\x87\x8D\x6A\x0E\x02\x4B\xA7\x1C\x96\x17\xAB\xF7\xA1\xD5\x81\x09\x0B\x9E\xB1\x02", - "\x4C\xA8\x00\x01\xD8\xA5\xB6\x6B\x79\xA5\x0B\x18\xA2\x87\x22\xF8\x12\x97\x01\xE5\xA5\x2E\x06\x88\xA2\x10\x01\x9E\xAA\x41\x44\xA7\x93\x4B\x71\x92\x02\xA8\xCB\x2E\x88\x95\x1E\x8B\x4F\xBD\x01\x7E\x91\x4F\x03\xF3\xA5\x42\xA2\x0F\xB5\x4F\x03\x0D\x1A\x01\xE8\xA1\x50\x03\xD0\x06\x57\xA4\x47\xB1\x90\x9D\x04\x7A\xA8\x44\xA7\x3E\xAA\x95\x92\x14\x03\x7F\x92\x38\xA8\x51\xFE\xA8\xD0\x14\xF0\xA6\xB2\x97\x90\xA3\x48\xA7\x4C\xBB\x12\xA0\x01\x8C\xA8\xF4\x8C\x29\x03\x68\x05\x0A\x18\x38\xA1\x02\x54\xA7\x5A\x0B\x4A\xA8\x44\x05\x53\xA5\xA5\x88\x3F\x80\x03\x63\x91\x9A\xA9\xCA\xA4\xBE\x6C\x2D\x96\x10\x01\x06\x23\x23\xA6\x01\x43\x07\x51\x00\xCB\x89\xE6\x39\xD2\x97\xB9\x43\x0D\x2B\x01\x18\x8E\x54\x00\x26\xAC\xDD\x01\x3E\xAD\x79\x58\x1C\xAA\x01\xB3\xA9\x4D\x11\x2A\x00\x48\xA7\xAD\x82\x06\x23\x23\xBB\xA9\x81\xA8\x13\xA4\x2A\x8B\x18\x03\x8E\x8A\x05\x29\x52\xD4\x89\xAC\xA8\xA7\x7C\x2C\xAF\x2D\x58\x0E\xAC\x05\x3C\x52\xC3\x7A\xC4\x01\x71\x92\x33\xA9\x98\xA3\x4A\xBE\x4C\x86\xA6\x63\x91\xAD\x01\x63\xA8\x6D\x09\x99\xAC\x57\x8E\x05\x03\x0D\x30", - "\x01\xBB\x88\x5B\x03\x21\xAF\x16\x09\x4B\xB7\x61\x03\x0D\x2F\x01\xBB\x89\x5C\x01\x24\xAB\x27\x91\x0B\x1F\x88\x84\x51\x3A\x01\xE5\xA9\x17\x2B\x38\x95\x9D\xAE\x79\x7B\x25\xBC\x02\x07\xA9\xBD\x01\x78\xAB\x3B\x4E\x9D\xAE\x5A\x3F\x05\x2B\x53\xC2\x07\xC7\x01\x71\x93\x2C\x03\x68\x07\x0B\x13\x6E\xBA\x53\xBC\x05\xB4\x01\xA1\x06\x2D\x06\xBC\x97\x50\xAE\x35\x83\x0D\x32\x01\x88\x8F\xE5\xA6\xB1\x03\xA1\xAE\xC7\x08\x87\x85\x54\x90\x02\x09\xAB\x02\x9C\x2E\x04\x9F\xA4\x8D\x27\x06\x0D\x54\xC2\x07\xC8\x01\x71\x93\x46\xAB\x61\x1B\xE1\x87\xA4\x8A\x03\x1F\xAA\x4B\x42\x8E\xA8\xA8\x34\x19\x0F\x4F\xA2\x1B\x09\x03\x63\x91\xBA\x01\xA1\x04\x30\x00\xE3\x8D\x0C\x08\xA9\x84\x11\x3B\x01\xDF\xA9\x5D\x8B\x33\x07\x90\xA0\x0D\x11\xA7\x8A\x03\x63\x91\xBC\x01\xA1\x05\x2F\x00\x1D\xA1\x54\xBB\x2C\x68\x43\xC3\xAA\x10\x02\x70\xAB\x19\x0A\x1A\x07\x48\xB3\x06\x31\x53\xCB\x01\xE3\x90\x5F\x02\x50\xA8\x1D\xA2\x55\xA6\xAA\x85\x38\xBF\x01\x43\x07\x5C\x03\x2E\x8D\x1A\x02\x51\xBC\x15\x33\x54\x90\x02\x38\xAB\x02\x9D\x30\x05\xEE\x8B\x4B\x98\x06\x2D\x54\xA4\xA9", - "\xD3\x6F\x0B\xAB\xEE\x8F\xAC\xA6\x4D\xA3\x08\x30\x20\xAE\x0C\x18\x8E\x6D\x02\x4D\xAC\x7A\x04\x0C\x0A\xA9\x8F\x75\x5C\x01\x73\xAA\x7B\x08\x33\x05\x2C\x95\x57\xB5\xA7\xA7\x11\x5E\x01\x87\xA9\x6F\x01\x3C\xAE\x19\x03\x8E\x85\x06\x03\x0D\x47\x01\xE8\xA0\xC3\xAA\xF4\xA4\xFC\x01\x0E\x19\xAB\x9D\x04\x4F\x01\x65\x92\xC5\xA8\xEF\x6B\x47\xA7\x48\xA4\x07\x31\x53\xD1\x01\xE3\x90\x63\x03\x61\xA8\x1D\xAA\x59\xAB\xAC\x8B\x9D\x0E\xAB\xF0\x1B\xB2\x91\x67\xAB\xB2\xAB\x62\x07\xA4\xA9\x03\x71\xA9\xD4\x01\x71\x90\x62\xAF\x2E\xAC\x7E\x9D\xAA\x8A\x0D\x48\x01\x43\x07\xBE\xAA\x20\xA8\xFD\x88\x41\xA3\xC3\x58\x1C\xEE\x01\xA0\xAA\xDE\x2A\x5D\xA8\x34\x00\x0F\x19\xAD\x89\xE1\x65\x92\xCA\x00\x82\xAB\x2E\x8A\x1E\x07\x48\xB3\x07\x31\x53\xD7\x01\xE3\x91\x65\x03\xD0\x06\x19\x08\x0E\xAA\xAE\x9E\x56\xE1\x52\xBE\xAA\xF0\x65\x59\x96\xB9\xA6\x9A\x8B\xB0\x11\x57\x83\x02\xDA\x01\xE9\xAA\x70\xA8\x02\x97\x48\xBA\x07\x31\x53\xDC\x01\xC9\xAA\x99\xAB\x2E\x8C\x1F\x07\x48\xBD\x07\x31\x53\xDD\x01\xE3\x90\x66\x03\x72\xA8\x1D\xAA\x5E\xAF\xAE\x8A\x9A\x57\xAB\x02", - "\x02\x6F\x01\x59\x95\xBD\xA5\x5D\xBD\x66\x36\x27\x40\x91\xBC\x7B\xF9\xAB\x76\xA9\x18\x66\x9F\x17\x0F\x04\x00\x77\xAB\x13\x02\xAE\x96\x49\x9C\xBE\xA6\x10\x1F\xAA\x9A\x18\x06\x00\xFD\xAB\x89\x03\x01\x00\xC0\xAE\x79\x23\x47\x8D\x03\x6B\xAB\x05\x9D\x07\xAE\x7B\xAD\xB7\x19\x00\x0C\xB0\x84\x23\xE5\x92\x12\xAD\xD4\x83\x2E\x8B\x01\x09\x60\xA0\x14\x16\x58\xB2\x32\xE3\x90\xE6\xA8\x6B\xAF\x8C\x0E\x00\x16\x4F\x35\xF4\x67\x40\x43\x07\xE0\xA9\x81\x98\x1A\x0B\x5B\xB1\x0C\x11\x00\x1F\xAC\x9B\x11\x73\x03\x38\x94\xC5\xAF\xAD\x7B\x25\x93\x00\x1D\xAC\x97\x0A\x18\xAD\x28\x75\xC5\xAE\x17\x16\x00\x38\x58\xF4\x33\xE3\x90\x69\x03\xD0\x06\x1A\x08\x71\x97\x00\x3A\x58\xDB\x10\xD3\x01\x59\xA6\x91\x21\x03\x0F\x63\xBB\x44\x29\x03\x63\x91\x49\xAD\x13\x9D\xDC\x2D\xC9\xA3\xA7\x0A\x07\x10\x59\xD7\xA4\x4D\x1B\x0D\x00\x95\xAB\x0B\x1B\x0E\x17\xB2\x85\x4B\xB7\x27\x5B\xAC\x63\x04\x3B\x06\xCB\xAB\x2C\xAD\x6A\x1D\x00\x61\xAC\xBC\x05\x76\x00\x99\xA9\x5A\xA9\xC5\x28\xB3\x8A\x0D\x6E\x01\x6B\xAD\x6B\xA4\x5E\x17\x03\x0E\x66\xA2\x1E\x2F\x03\x71\xAC\xDC\xA5", - "\xC8\x00\x08\x05\xCE\xA1\x51\x58\xB3\xA2\x4B\xBD\x1B\x21\x00\x3E\xAD\xAB\x16\xCF\xA8\x2E\xB5\x46\x42\x5A\xFB\x1B\x7E\xAD\x76\xA6\x41\x03\x04\x07\x68\xB6\x27\x33\x03\x7E\xAC\xF3\xA5\xCD\x89\xA3\xAE\x81\x0E\x67\xBA\x97\x9E\x04\x25\x00\x93\xAD\x89\x01\x3D\x06\xCF\xA1\x30\xB3\x95\x59\x5A\xDF\x25\x7E\xAD\x83\xA6\x91\x27\x04\x0F\x69\xAC\x08\x37\x03\x7E\xAC\x0D\xA6\x23\x24\x0A\x03\xCB\xA9\x02\x07\xB2\xB8\x03\x63\x91\xD4\x01\xA1\x05\x34\x05\x6D\xA5\x6A\xA0\x7C\x03\x0D\x31\xAD\x05\x9C\x22\xAD\xF3\x00\x1D\xA7\x0D\x06\x3C\xBB\x12\xAC\x00\xB5\xAD\x4D\x12\x07\xAC\x21\x0D\x0D\x18\x38\xAD\x00\x47\xAC\xC7\x3B\xA1\x04\x37\x00\x1D\xAA\x0D\x1C\xB1\xAC\x05\x2F\x00\xC8\xAC\x5E\x05\x3E\x05\x2C\x9D\x6C\xB5\xB1\xBE\xCD\x5B\xAC\x32\x01\x23\xAF\x3E\x03\x1C\x9B\x0D\x0A\xB6\xA8\x43\xDD\xAD\x13\xAD\xEC\x1C\x0D\x01\xDA\xAA\x34\x1C\x07\x25\x25\xE0\xAD\x0B\x77\x5D\x8A\x0D\x03\xCB\xA7\x03\x07\xB2\xBE\x03\x63\x91\xCB\xAD\x97\x7B\x2E\x89\x07\x01\x6C\xA4\x7C\x43\x0D\x55\xAD\xB3\xAB\x9D\x92\x37\x04\xBA\x88\x0E\xBB\xB7\x99\xAB\x7D\xAD\x43\x07\x76", - "\x00\xC0\xAE\x10\x48\x0E\xA0\x07\x03\x0D\x5F\x01\xBB\x88\x1D\x02\x7D\x13\x5E\xA6\x2C\x01\x07\x03\x0D\x06\xAE\x05\x9C\x71\x00\x1F\x88\x1D\xA3\x0E\x03\x1A\x12\x5C\x85\x9C\xE4\x01\x83\xAE\xD6\x9B\xE1\xAE\xF4\x65\x07\x03\x0D\x15\xAE\x05\x9C\x73\x03\xD0\x01\xE3\xA5\xE0\x87\x07\x1A\x5C\xF1\x48\x1C\xAE\xBE\x88\x3A\x03\x68\x06\x72\xA5\x70\xA9\x03\x43\x06\x2B\xAF\x02\x9E\x3A\x07\xE4\xAA\x61\x06\x02\x29\x5C\xDB\x94\x37\x05\xA1\x06\xC7\xAD\xC0\x9C\x0E\x02\x5B\xA8\x43\x82\xAE\xC8\x52\x74\xA2\x3B\x03\x68\x03\x73\xA5\x70\xAF\x03\x7C\x8B\xE8\xA1\xA3\xAE\xEE\x8E\xE8\xA0\x7D\x88\x87\xB1\x03\x06\x9E\xBB\x88\x25\x00\xB9\xA8\x95\x8A\x45\xA4\x38\x68\x43\xCE\x90\x73\x19\xDC\xA7\xD4\xAE\x28\x94\x0F\x10\xBA\x82\xBA\x5B\xAE\x68\xAA\x81\x00\x12\xAE\x20\x0D\x75\xA5\x70\xB6\x03\x48\xAE\xC9\xA7\x7A\xAF\x72\x03\x1C\x97\x76\xAB\xBA\x89\x86\x6A\xAE\x00\x00\xCF\x97\x7D\x05\xED\xAF\xAF\x5B\x25\x92\x01\x6A\xAE\x01\x00\xB9\xAC\x06\x0B\x68\x0E\x0F\x18\x38\x93\x01\x60\xAE\xD4\x07\x7C\x02\x92\xAC\x88\x25\x05\x0A\xBB\x82\x00\x7A\xAE\x10\x02\xC1\xAE", - "\x94\xA8\x2F\x16\x05\x0A\xBB\x83\x00\x08\xAF\xE7\x20\x2C\xAD\x9A\x1F\x0A\x0A\x76\xA4\x00\x10\x5E\xC5\x4B\x34\x9C\xF2\x0C\x16\x02\xED\xA0\xB7\x86\x69\x8A\x5E\xE5\xAC\x69\x1D\x2C\x02\xDA\xAE\x00\x07\x79\xBA\xC6\x27\x23\xCA\x53\x6A\xAF\x03\x01\xE9\xAA\x20\x0F\x79\xA7\x72\x92\xC4\x6A\xAE\x08\x01\xD5\xAE\x59\x95\x60\x91\xA6\x0A\xBB\x89\x00\x32\xAF\xAD\xAE\x3F\xA6\xB2\x4A\xED\xAA\x00\x18\xBD\x83\x0D\x05\xAD\x4D\x1A\x2F\x02\xDA\xAB\x01\x0E\x7B\xA0\xA7\x29\x39\x5F\x00\x6A\xAE\x06\x01\xF1\xAB\xC9\x24\x7E\x00\x03\x2A\x5D\x8D\x00\xCB\xAE\x09\x3D\x6F\x19\x0C\x0A\x76\xAE\x00\x11\x5F\x9E\xA5\xDD\x04\xB5\xAF\x03\x07\xFA\xAF\xA1\x87\x23\x23\x01\x6A\xAE\x10\x00\xEE\xAC\x89\x95\x2D\x6B\x65\xA5\x03\x07\x59\x91\x00\xB2\xAE\x7D\x03\xD0\x03\x1F\x08\x0E\xAA\xBF\xB9\x5C\xC3\x7A\x12\x01\xF4\xAF\xD0\x05\xE7\xA3\xD4\x73\x00\x32\x5F\x90\x02\x40\xAF\x7C\xAE\xF0\x04\x02\x07\x7F\xAC\x08\x03\x5D\xC3\x7A\x15\x00\xD9\xAC\xFB\xAE\xF6\x97\x9A\x96\x4F\x1E\xCB\x16\x00\x0A\x99\xA7\x84\x75\x8D\x61\x06\x80\xA3\x75\x09\x60\x83\xB0\x57\x87\xC8\x01\x1F", - "\x06\x3E\x1E\x2E\x70\x01\x1E\x2E\x98\x4F\x10\xB0\xB0\x87\x8B\x6C\x02\xB7\xB4\x97\xC0\x9E\x0D\xB9\xA4\xA1\x1A\x0E\xB0\x98\x96\x03\xB7\x36\x82\x5B\xA4\x0B\xA2\xB0\x7E\x8C\x12\xB3\x09\x0C\xBF\x8F\x2A\x0D\x05\x0D\x60\xA6\x07\x68\x01\x07\xB1\xFA\x9E\xE6\x18\x82\xAC\x37\x35\x01\x2A\xB0\x77\x87\x64\x9E\x86\x0C\x18\x05\x83\xBB\x44\x03\x02\x38\xB0\x47\x87\xBF\x97\xAB\x00\x1A\x0D\x83\xB3\x53\x11\x02\x40\xB0\x90\x87\x6A\x9E\xCE\x15\x08\xBB\x85\x1F\x04\x08\x61\x8A\xB0\xAA\x70\xBC\x10\x3A\x04\x09\xB6\x2C\x0D\x05\x0F\x61\x99\xB0\x35\x66\xBC\x10\x3D\x04\x0A\xBC\x2B\x1B\x05\x17\x61\xEA\x9D\xEF\x20\xC5\x16\xAB\x69\x19\x0E\xB9\x99\x1D\xBE\x18\xAF\x05\x0D\x00\xC5\x16\xBB\x60\x1B\x0F\x85\xA9\x81\x8F\x75\x19\x00\x6A\xB0\x36\x0D\x1B\xB7\xDF\x94\x44\x25\x01\x0A\x2E\x5E\x65\xF4\x00\x19\xB0\xF0\x94\x1A\x30\x03\x17\xC3\xBA\x02\xDC\x98\x1F\xB1\xFC\xA5\x4E\x32\x0C\xBA\xFD\x37\x61\x9A\x0F\xF3\xA7\x69\x1C\x24\x00\x21\xB1\xA6\x46\x88\xA1\xC4\x9E\xE8\x7B\x7F\x71\xB0\x33\x8F\x0D\x98\x03\xB5\x05\xAE\x8B\x11\x62\xDA\x0A\x3C\x01\x49\xB2\x23\xB6", - "\x28\x8C\x23\x6B\xC4\x95\x60\x37\x98\x66\xB0\x32\xA1\x6F\x1A\x0F\x07\x89\xAB\x50\x5A\x62\xA5\xB0\xF3\x97\x34\x1E\x21\x05\x14\xBB\x3B\x27\xC5\xAB\x60\x88\xA7\x13\x68\x4F\xB2\x0D\xB5\x11\xB8\x8A\xB9\x5F\xBE\x05\x1F\x01\xB2\xB1\x4D\x11\x21\x04\x16\xBF\x8A\xA5\x84\xB4\x04\x2C\x01\xB9\xB0\x46\x5C\x2F\xB1\x07\xB9\x6A\x99\x05\x01\x63\xDB\x10\x3D\x9A\x0D\x89\x2F\xB4\x05\x80\x27\x67\xC6\x86\x0B\x20\x9B\x7C\x6A\x2C\xB0\x2E\x67\x8C\x03\x0D\x0E\xC6\xB6\xB7\x20\xB1\x9B\xB0\x1D\x81\x6F\x18\x1C\x0C\x8A\xB3\x07\x8A\x2E\x11\x53\xAE\xB0\x62\xB2\xB3\x8C\x88\x2E\x0E\x1D\xC6\x80\x00\x7A\x01\xDF\xB0\xCE\x51\x38\xB1\x08\xBF\xC3\x91\x94\x66\x63\x88\x00\xA2\x00\x4B\x67\x3B\x03\x1D\xB9\x84\xB9\x16\x94\x63\x0A\x00\xF1\xB0\xF2\x6A\x05\x01\x1F\xB2\x2A\x66\x08\x3D\x03\x74\xB1\x50\xB0\xF9\x74\xEF\x3C\x1F\xBB\x2A\x64\xC8\xB0\x30\xDA\x03\xC4\x9C\x4A\xB1\xBB\x81\xCD\x16\x02\x06\xC8\xA5\x3D\xC5\x1D\x0E\xB3\xC1\x05\x06\x04\xD8\x93\x46\x9C\xB7\x83\xF5\x28\x00\xC4\x9D\xFB\x00\x3F\x03\xFE\xA7\xAD\x89\x01\x19\x64\x93\x02\x1B\xB2\xFC\xAF\xB5\x92\x05", - "\x0F\x91\xA1\x21\x03\x0D\x7F\xAF\xFA\xAE\xB1\x07\x0A\x05\x24\xBC\x10\x1D\x07\x03\x0D\x77\x01\x96\x90\x87\xB3\x37\xA0\x00\x0D\x77\xA9\xBC\xA8\x43\xFF\x01\xC7\xA7\x36\xA8\x11\x2E\x06\x02\x93\xAE\xFA\x48\x4F\xEA\x19\x3A\xB2\xD7\x2A\xB1\x07\x06\x01\x91\xB0\xF7\x2A\x12\x78\xAB\x7E\x03\x1C\x01\x4F\xB6\x74\x0C\x02\x0C\xC9\xB8\x2D\x2A\x09\xC9\x91\x33\x0A\x0E\x03\x29\xB0\x60\x2E\xCA\xBE\x10\x2A\x09\xD2\x91\x69\x0C\x55\xB4\xDD\x0E\x02\x16\xCA\x84\x2E\x2A\x09\x5F\xA4\x0D\x0C\x0F\x03\x2B\xBF\x93\x3E\xCA\xB1\x27\x2A\x09\x9A\x98\x0D\x0D\x0F\x04\x2C\xB7\x89\x46\xCB\x82\x00\x2A\x09\x09\x9B\x33\x0A\x0F\x04\x2D\xBB\x85\x11\x01\x2E\x65\xAA\x09\xA8\x98\xF2\x0F\x0F\x04\x2E\xBC\x35\xB7\xCB\x96\x3A\x9D\x02\x40\x00\xBE\xB0\xAF\x03\x06\x0E\x97\xA5\x7F\xBD\x36\x41\x00\x82\xB2\xA5\x04\x0D\x05\x30\xB5\xA8\x01\x47\x89\x66\xC2\x07\x35\x00\xC6\xB1\xE0\x13\x74\xAF\x98\xB8\x9B\x12\x66\xF4\x08\xE8\x09\xCA\xB0\x11\x0F\x06\x07\x99\xB5\xDB\x0D\x35\x45\x00\x9A\xB2\xEA\x04\x0E\x05\x33\xBD\x69\xA6\x92\x06\x01\x21\xB3\xF6\x09\x1C\x01\x67\xB2\xD4\xA4", - "\x44\x27\x02\x28\x66\x9D\x02\x3A\x01\xCE\xB1\xAA\xAC\xD8\x84\x97\xA9\x02\x05\x65\xB9\x32\x66\xB3\x01\x03\x51\xB5\xD5\x2F\x9A\xBB\x45\xB9\x66\xD0\xB2\x24\x93\xDE\xB3\x69\x07\x37\xBF\x2B\xB8\x4B\x0D\x01\x42\xB3\x66\x72\xE2\xB0\x3F\x9A\xD0\x58\x9C\xA6\x08\x3F\x00\x4A\xB3\x02\x9B\x33\x0B\x13\x05\x39\xB8\x16\x10\xCE\x88\x34\xAF\x05\x50\x00\xEA\xB0\xE6\x36\x3A\xB0\xD1\x91\x24\x5A\x67\x80\x00\x42\x00\xEE\xB1\xB1\x98\x34\x02\x05\x1F\xCE\x83\x01\x62\xB3\x1C\x9B\x23\x17\x77\xB4\x08\x02\x9E\xA0\xBE\xA9\x39\x54\x00\xDF\xB3\x22\x02\x78\xB2\xD1\xA6\x7A\x3F\xCE\x86\x01\x62\xB3\x91\xAD\x89\x02\x15\x07\x3B\xB7\x04\x02\xCF\x96\x5A\x9D\x02\x57\x01\xEF\xB0\x12\x02\x3C\xB5\x9A\xA4\xA2\x18\x01\x5F\xB3\xCB\x9C\x93\x9A\x6E\xB3\xF3\x04\x16\x3F\xCE\x8A\x01\x62\xB3\xB3\xB2\xD7\x2A\x16\x04\x2E\xBB\x05\x17\xCD\xB2\xA0\x66\xB2\x04\x01\x83\x0D\x50\xB4\x1A\x3D\x05\x1F\xCE\x86\x0B\x05\x00\xAA\x09\x0C\xB5\x81\x9E\x00\x0A\x4A\x00\xD1\x85\x38\x87\x00\xAA\x09\x05\xB5\x4A\xB1\xEC\xA9\xCD\x07\xCA\x9B\x68\xA0\x35\x6B\x95\x63\x2A\x2A\x09\x64\xAA\x61", - "\x1E\x02\x16\x68\xFB\x41\x66\xB3\x04\x02\x2A\x0D\x96\xAD\x7C\xB7\xD1\x9B\x22\x4D\x00\x39\xB4\x55\x0A\x00\x97\x8C\x02\x06\x1E\xD1\xA9\x17\xC4\x9D\x83\x06\x1D\xB4\x44\x01\x1F\xAA\x61\x04\x03\x06\x69\x87\x13\x48\xB5\x89\x02\x92\xB7\x07\xAA\x16\x8F\xD2\x81\x92\x51\xB4\x0C\x2E\x55\x09\xC5\x98\x0D\x06\xA5\xBC\x15\x14\x01\x58\xB4\x6A\x2E\x55\x09\xD3\xA5\xAC\x2D\xA5\xB9\x24\x41\x69\xD3\xA6\xE4\x0E\x36\x01\x99\xB5\x0F\x27\xA6\xB9\x9A\xBE\x26\xEB\xB4\x57\x17\x36\xB7\x0B\x92\x82\xA0\xA7\xA4\x22\x19\x01\x72\xB4\x36\x91\x5D\x8A\x1C\x05\x4E\xB4\x3D\x1A\x02\x38\x69\xBE\x90\xE8\x40\x3E\xB6\x3D\x0B\x0B\x0F\xA7\xA6\x42\x99\x4B\x02\xB5\x1D\x02\x2E\x01\xA1\xB0\xEB\xA2\x8D\x08\xD4\x93\x04\x5D\x00\x60\xB5\xAF\x36\x2A\x0D\x8E\x94\x7E\x1A\x03\x0E\x6A\xE7\x22\x85\xB4\xA0\x9E\x40\x04\x0F\x07\xA9\xB1\x13\x11\x6A\xBD\x3A\xAA\x08\x4D\xB6\x7B\x65\x53\xB2\x41\x1F\xD4\x87\x75\x2A\x09\x12\x9D\x33\x08\x20\x04\x54\xB3\x10\x04\x03\x05\x6A\xE3\xAE\x78\x12\x41\x00\xAB\xB5\x2E\x66\xAA\xBD\x0E\x2A\x12\x49\x8F\xB1\x5F\x59\xB5\x02\x5D\x56\xB3\xA5\xB0", - "\x7A\xA0\x06\x06\x01\xBA\xB5\x34\x00\xAF\xB2\x95\x05\x75\xAD\x6A\x08\x02\x3A\xB5\x6B\x01\x61\xB7\xF5\x8B\x97\x8A\x08\x1A\xD5\x9E\x3B\xA6\x9A\xBD\xB4\xFB\x03\x8B\xB7\xA9\x3C\x08\x1A\xD5\xAE\x01\x66\xB2\x0B\x00\x55\x0A\x02\x03\x5A\xB0\x1A\x0E\x04\x3A\x6A\xC6\x05\x0C\x00\x6D\xB4\xB7\xB1\x32\x00\x09\x1F\xD6\xBC\x0A\x0D\x00\xE2\xB4\xC2\x0A\xB9\xB2\x69\x0E\x00\x09\xD7\x9A\x18\x14\x01\xEB\xB4\xE1\x07\x03\x06\x5D\xB4\x7E\x16\x04\x31\x6B\xE2\x06\x10\x00\x7A\xB4\x5E\x10\x13\x07\xAF\xBE\x27\xBA\x6B\xCD\x1A\x9A\x01\x7E\xB4\xF5\x02\x02\x0F\xAF\xB1\xAC\x42\x6C\xF6\x09\x13\x01\x82\xB5\x6F\x1E\x13\x07\xB0\xBD\x08\x14\x00\x0A\xB6\xD9\x1E\x50\x01\xC3\xB3\x74\x50\xB1\xA6\x92\x22\x02\x13\xB6\x0D\x8B\x8A\xB4\x11\x2C\x14\x08\xB1\xA6\x3D\x1A\x6C\xAE\x2B\xA6\x01\x8E\xB7\x5F\x22\x95\x01\x5B\x94\x64\x7A\x6A\xEF\x00\x66\xB2\x0C\x03\x8C\xB2\xAA\x9E\x90\xB2\xD5\x70\x01\x35\xB5\x2A\xB7\x0A\x17\x2E\x8D\x15\x0D\xB2\xAA\x1F\x70\x6C\xC2\xB4\x63\x8D\x9A\xB7\x87\x84\xD8\x97\x70\x11\xD9\xAE\xA1\x14\x8A\x3A\xB6\xAD\x0B\x1D\x04\x67\xB3\x11\x1E\xD9", - "\xA1\xCD\x2D\x26\x41\xB6\x76\x0E\x1E\x04\x68\xBE\x36\x7A\xD2\xA9\x53\xC9\xB6\x9B\x11\x3E\x00\xD3\xB4\x21\x06\xB4\xA3\x08\x23\x69\xBD\x1B\xBC\x00\xA8\xB7\x9C\x10\x10\x07\xB3\xA8\xD3\xB0\x46\xDA\xB6\x5B\x10\x41\x01\xD7\xB6\x4D\xB4\x7E\x02\x06\x20\x6D\xC6\x05\x84\x01\xB1\xB7\x9C\xB6\x91\x27\xB6\xBC\x15\x06\x02\x6A\xB6\x79\xB4\x0A\x9D\xDB\xB2\x69\x08\x08\x10\xDB\x80\x6A\x9A\x0C\xCB\x01\xB9\xB6\xF0\x02\x11\x06\xB7\xA6\xD4\x87\x48\x7A\xB6\x62\x06\x46\x01\xDF\xB4\x51\xBC\x5D\x20\xDC\x84\x11\x0E\x01\x53\xB7\x91\xB7\xE7\x8B\x97\x84\x0D\x06\xDC\xB9\xD0\x7D\xB6\xA2\xB5\x6B\x02\xE3\xB6\x9E\x03\x09\x09\xDC\x83\x04\x55\xB6\x0F\x56\xF3\x67\xE4\xB5\x23\x06\x09\x16\xDC\xAF\xC8\x28\xB5\xBB\x89\x6E\x03\xE6\xB3\x22\x09\x09\x1D\xDB\xB0\x6A\xE2\x5D\xA3\xB7\x4D\xAA\xE7\xB0\x00\x08\xB9\xBC\x43\xB0\x87\x29\xB7\x58\x0B\xD5\xB5\xEB\xB0\x57\xB1\x9A\x70\xDD\xA3\x15\x32\xB7\xC4\xB5\x5D\x89\x3A\x06\x76\xBD\x4A\x98\xDD\x8B\x6B\xAA\x24\xBC\xB7\xE6\x21\xDF\xB7\x27\xB4\x7E\x0F\x07\x01\x6F\x80\x00\xA9\x01\x5A\xB6\x06\x04\x64\xB3\x5C\xBF\xCE\xAB", - "\x02\x66\xB2\xCB\xB7\x95\x8F\x19\x0B\x1E\x0A\xAB\xAC\x05\x0A\x6F\xBB\xB4\xBB\x89\x7A\x02\xAE\xB6\x15\x07\xBD\xB1\x2B\x3B\x12\xF7\x01\xBA\xB4\x58\x03\xEA\xB1\x7A\xBF\xB3\xB0\x40\xBA\x6A\xB3\x01\xE3\xB6\xA7\xB7\x19\x0B\x1F\x0A\xAB\xB6\x05\x29\x6F\x82\xB1\x2D\xB2\x5D\xB5\x2E\x07\x7D\xBE\x3F\xA7\x5E\x3A\x6A\xBC\x01\xDD\xB6\x86\x02\x8C\xA7\x4C\x33\x0A\x07\x92\xBC\x0A\x3E\x01\xF9\xB6\x64\x63\x2E\x8B\x00\x0D\xBF\xAC\x03\xAE\xD3\x01\xB8\x6E\xAB\x14\x91\x01\xBD\x1F\xBB\x89\x02\x06\x08\x70\xFE\x8E\xBB\x89\x03\x03\x02\xBF\x7A\x7F\x05\x4F\xE0\xBB\x68\x3B\x89\x09\x01\x09\xBB\x41\xB6\x58\x06\x0C\x16\xE0\xAD\x35\xE4\x0F\x0B\x00\x0D\xBB\x22\x84\x57\x08\x0C\x16\xE0\x84\x6E\xFA\x86\x22\xB8\xA4\xB2\xF5\x64\x7E\xB5\xF3\x5B\x25\x8F\x00\x29\xB8\x56\x05\x66\x02\x05\xBA\x54\xB1\x01\x10\xE1\xA6\x0E\x4F\x01\x2C\xB8\x50\x4E\x42\x26\x86\xBA\x55\x12\x06\x39\x70\xE2\x18\xBB\x89\x0A\x00\x0F\xB8\xF0\x16\xC1\xA7\xDD\xA9\x39\x17\x00\x43\xB9\xED\x1B\x0F\xBE\x75\xBB\xCF\x09\xE2\xBA\xF4\x4B\xB8\xB4\xB6\x22\x2B\x06\x06\x89\xB2\xAE\x2B\xE2\x85\x6B", - "\xE9\x1C\x1D\x00\x2A\xBA\xB1\x00\x1C\x0B\xC4\xBF\xA2\x9D\x39\x5A\xB8\xBC\x05\x71\x02\x05\xBC\x78\xB8\x97\x01\x01\x20\x71\x84\x38\xB5\xB5\x0D\x02\x2A\x09\x03\x03\xAE\xBE\x0B\x23\x00\x22\xB8\x33\xB2\x0E\x02\x2A\x0E\x03\x0D\xC6\xAC\x0B\x24\x00\x70\xB8\x4E\x7E\x39\xBB\x46\x25\x8E\xBA\x15\x05\x01\x38\x71\xE7\x20\x67\xB8\xE1\x04\x1D\xB9\xDB\x0C\xC7\xA7\x0A\x28\x00\x7F\xB8\x38\xAE\x86\x03\x07\x00\x2B\xB5\xC8\xB4\x09\x29\x00\x08\xB9\x64\x95\x42\x1B\x1C\xBD\x91\xBE\x11\x0A\x01\x01\x72\xE2\x06\xE7\x00\xB3\xB0\x08\x02\x95\x0B\xC8\xAC\x7E\x14\x71\xAE\x00\x54\xB8\x74\x02\x59\xB2\x04\x0A\x4A\x01\x01\x14\x72\xF4\x02\x90\xB8\x0B\xA6\x3D\x0C\x94\xB2\x08\x47\xE5\xAC\x91\x29\xB9\xFA\x59\x51\xB8\x27\xBE\x95\xB2\xA1\x10\xE5\x85\x3B\x54\xB8\xEA\x00\xB3\xB3\x08\x05\x94\xB4\xCB\xA7\x0C\x36\x72\xD6\x94\xBB\xB9\x56\xBB\x19\x0E\x06\x0F\xCB\xBC\x15\x2B\x03\x3A\xB9\xB3\xB9\x3E\x1E\x2D\xB8\x07\x04\xC5\xAC\x07\x26\x65\xA4\x00\xAA\x08\x13\x01\x2F\xBE\x20\x0A\x03\x05\xE6\xBB\x24\xD2\xB9\xC2\xB9\x69\x0F\x25\xBF\xDB\x35\xAB\xB8\xE6\x8A\x72\xD3", - "\xB9\xCD\x34\x2A\xBB\x0F\x04\x8A\xBF\x0E\x15\xD5\xA7\x00\x2A\x09\x28\x00\x70\xB9\x1D\xA9\x37\x2A\x4A\x0A\x01\x2A\x73\x88\xA9\xB7\x47\x49\xB9\x9E\x5B\x9B\xB5\x40\x15\xD5\xA9\x73\xFB\xB8\x67\x09\x21\x00\x15\xBD\x08\x04\xC5\xB3\x07\x35\x6A\xA9\x00\xE8\xB9\x77\xB9\x8C\xB2\x69\x00\xD0\xB1\xA0\x02\x74\x8B\x9C\xBC\x04\x77\xBB\x6D\x8F\x9D\xB7\x04\x16\xE6\xA8\x12\xAB\x00\xAA\x08\x18\x03\x41\xBA\x69\x08\x04\x14\xE7\xB6\x13\x2D\x00\xAA\x08\x16\x03\x44\xBA\xA1\x8C\x2B\x18\xE8\xA1\x5B\xC6\x24\x4A\x00\x8B\xB9\x47\x05\x1E\x05\xAB\xBE\xE8\x99\x4F\xE7\x08\x4C\x00\x11\xBA\xAC\x77\x1E\x0B\xBA\xA6\xE9\xA9\x4C\xD2\xB3\x2A\xBA\xE4\x3D\x4B\xB8\x67\xB7\x46\x12\x02\x31\x74\xA0\x2D\xC4\x9C\x2A\x0A\x4B\xB8\x67\xA5\x3C\x57\xE9\xA4\x32\x64\x9E\x3A\xBA\xF5\xB6\x40\x66\xA7\xB5\xE8\x60\xEA\xB7\x12\x42\xBA\xE8\xA6\xA2\xBB\x26\x11\x01\x06\xD4\xB7\x3E\xA2\x69\xBB\x89\x5E\x00\xA5\xBB\x9C\x15\x01\x04\xF6\x87\x38\x3B\x74\x82\x02\xFB\xB6\xB2\x4A\x54\xBB\x0B\x10\x01\x15\xEA\x87\x75\xEE\x8E\x6D\x63\xAD\xBA\xB1\x03\x02\x0E\xD5\xAE\xEA\x91\x50\xFF\xA7", - "\x62\xBB\xA3\x0D\x59\xB9\xBB\x2A\x4A\x15\xAD\xA2\x9E\x69\xBA\xC3\x71\xB5\xBA\x41\x07\xAA\xB7\xC1\xA7\x23\x2D\x01\x70\xBA\xC2\x06\x0E\x02\x5C\xBB\x20\x04\xD7\xBF\xE0\xB8\x25\x70\x00\x78\xBA\xB1\x07\x07\x03\xAF\xB2\x10\x14\xEB\xA7\x70\xE9\x1C\x73\x01\xC0\xBA\x60\x8D\xA9\xBC\xD6\xAB\xDC\x99\x4B\x0A\xBB\xD4\x06\x13\x00\x61\xBF\x5D\x61\xAA\xA4\xA1\x90\x76\xF6\x09\x29\x00\xC6\xBB\x5C\xBD\xB2\xBE\x03\x37\xEC\x9D\x04\x2D\x00\x9A\xBA\xBE\xB8\xE8\xB2\xFC\x2E\xD9\xAC\x23\x53\x76\xF4\xBA\x46\xB8\xD1\x5D\x69\xBF\x16\x91\xDA\xA5\xEC\xB7\x6A\xBB\x89\x85\x01\xD5\xB8\x43\x00\x07\x0D\xDA\xB4\xEC\xA9\x1A\x88\x01\xB2\xBA\x83\x00\x0F\x05\xB6\xB4\xD7\xB7\xE2\xBD\x36\x0B\x01\xB9\xBA\xB4\x00\x6F\xB9\x9A\xBF\xCE\xAE\x04\x0E\x74\x8B\x3C\x64\x9F\xFB\x00\x5D\xBE\x8B\xB8\x05\x21\xEE\xBB\x26\xA7\xBB\xAA\x08\x32\xB9\x65\x2E\xB9\xB0\x00\x08\x02\x13\x76\xAE\x00\x19\xBB\x8D\xBA\x51\x96\x58\x08\xDD\xBF\xE8\x84\x51\x15\x01\x22\xBA\x2E\x95\xEA\x98\xE4\x8B\xB2\xB6\x1F\x54\x77\xCD\x00\xD7\xBA\xEC\xB7\xC2\x24\xBA\xB0\x05\x09\xEF\x9E\x6F\xE7\x08\x9D", - "\x00\xEA\xBB\x14\x05\xB6\xBD\xDD\xA5\xDF\x9A\x18\x20\x01\xD4\xBB\x2B\x00\x7D\xB8\xA9\xB8\x97\x03\x05\x14\x77\xDB\x00\xFB\xBA\xF8\xB5\x62\x84\xBA\xBF\x05\x01\xF0\xB5\x6F\xE4\x0F\xA9\x00\xEA\xBB\x18\x06\xBD\xBA\xBF\xB4\x26\x94\x77\xE6\x00\x0C\xBC\x01\xB9\xC9\x24\xBA\xB9\x06\x11\xF0\x89\x70\x8D\x9B\xD4\xBA\x36\x02\x85\xB8\x82\xB8\x7C\x14\xEE\xAF\x01\x1B\xBC\x75\xBA\x0D\x0C\x2E\x04\xBA\xB2\x07\x00\xF1\xBE\x75\xC4\x3B\xD4\xBB\x3A\x00\x88\xBF\xB0\xBD\xDB\x1E\x05\x14\x77\xF8\x00\x06\xBD\x16\xBB\x19\x09\x18\x04\xDD\xBC\x03\x20\x78\xA2\xB5\xC4\x00\xEA\xBB\x1F\x01\xC6\xBA\xC3\xAE\x76\x54\x77\x83\x01\x3C\xBC\x20\xBA\x35\x5C\xBA\xB7\x08\x00\xF1\xA9\x76\xD9\x1F\xCD\x00\xEA\xBA\x22\x01\xC8\xBC\xC4\xB4\x7A\x14\x77\x8E\x01\x4C\xBD\x28\xBA\x6B\x2B\x1A\x04\xDD\xB2\x04\x0C\x79\xBE\xBB\x46\x80\xEA\xBA\x25\x04\xC9\xBE\xCD\xA4\x3F\x19\x03\x47\xBB\x44\x08\x4D\x01\x72\xBC\xE7\x8A\x4A\x0C\xEE\x88\xE0\x54\xBB\x9B\x00\x10\xBE\x74\xB9\xCD\x1D\x0D\x14\xEE\x9E\x02\x13\xBB\x2F\x01\xEC\xB9\x81\x99\xCE\xBE\xDD\xAE\xAD\x20\x03\x61\xBB\x2D\x35", - "\xF1\xB9\xFA\x8D\xBC\xB4\x5F\x34\xEE\xA3\x02\x70\xBC\xEA\xBB\x80\x38\x75\xBE\x14\x00\xE8\xAF\xEF\x98\xA5\x54\xBB\x9E\x9E\x29\xAB\x9E\xBB\x49\xBC\x7E\x94\xEE\xAD\x02\x35\xBB\x74\xBC\x2A\xB6\x5C\x34\xBA\xB1\x0B\x10\xF4\xBC\x77\xFD\x26\xD4\xBB\x5A\x02\xA5\xBC\x69\xAB\x4B\x94\x07\x14\x77\xB9\x01\x85\xBD\x06\xBF\x19\x0F\x1E\x04\xDD\xBC\x05\x21\x7A\x92\xBC\xBF\x12\xEA\xBB\x2F\x07\xD4\xB7\xE1\xA7\xC8\x54\x77\xC2\x01\xAC\xBC\x0E\xBC\x98\x0C\x14\x05\x3E\xB7\x35\xB1\x7A\xA1\xBC\xDD\x28\x5A\xBC\x0B\x97\x48\x77\xEB\xA7\xF1\x9F\xD0\x3A\xBD\x33\x90\xAD\x0B\x32\x07\xD6\xBC\xE2\xB9\x7E\x09\x00\x40\xBD\x3A\x90\xD3\x06\x33\x03\xD3\xB3\x8B\x1B\x25\x8C\x00\x48\xBD\x42\x91\x8F\x23\xAD\xBA\x54\xBF\x00\x10\xF6\x8A\x21\xD6\x04\xD5\x00\x66\xBF\x0E\xAF\xA9\x32\x01\x16\xF6\xB2\xEA\x59\x01\xDA\xBD\x20\xAA\x70\x76\xDB\xB6\x25\x1D\x06\x37\x7A\xC7\xBC\x46\x24\x0C\x00\xB9\xBE\xAD\x71\xEE\xAD\xA2\xA9\x39\x1B\x00\xEB\xBC\x62\x91\xBB\xBD\xC9\xBD\xD4\x1E\x00\x31\x7B\xF4\x33\xF3\xBC\x2C\xBF\xC2\x5F\xDE\xBB\x89\x0C\x07\x33\x7B\xE6\xBC\xD9\x1E\x12", - "\x00\xBF\xBB\x4E\x10\x0F\x17\xF5\xAB\x79\xBD\x1B\x27\x01\x81\xBF\x16\x13\x1E\x03\xD9\xB2\xE8\xA6\x75\xAB\xB4\x6D\xAA\x81\x01\x0C\x02\x95\x03\x03\x0F\xE7\xAA\x00\x56\xBD\x33\xB3\x89\xBE\x9D\x1F\x9D\xBB\x02\x18\xF8\x8E\xFD\x15\xBE\x5B\x72\xED\xB8\x11\x0C\x05\x06\xED\xA3\x1C\x36\x03\x63\xBC\xB7\x90\x55\x0A\x0C\x07\x9D\xBE\x02\x0A\xF8\x96\x29\xB5\x00\x11\xBA\x91\xBC\xF5\x01\x06\x05\xF2\xB3\x08\x37\x03\x28\xBE\x0C\x02\x1B\x02\xCA\xBF\x9D\xB3\x03\x0E\xF9\xA8\x1F\xB7\x00\x07\x0E\x2F\x05\x53\x06\x9E\x01\x97\xA2\x35\xA0\x06\x1C\x32\x1E\x03\x72\x1A\x47\x02\x02\x00\x1A\x0C\xFA\x91\x06\x4E\xBE\x7E\x02\xA8\xBC\x5B\x02\xEA\xB7\x1D\x80\x0D\x19\x07\x1E\x02\x46\x3C\xAC\xBC\x68\x01\xEB\xBD\x11\x1C\xFA\xA3\xCD\x5B\xBE\x60\xBF\xC8\x01\xD0\xBD\x23\x02\x15\x3D\x08\x37\x07\x1E\x02\x22\x5A\xB6\x01\xDA\xBA\x2B\x0B\xF6\xA7\x0A\x2D\x7D\xB4\x02\xE9\x14\x8F\x00\x15\x0D\x3D\x6E\x11\x07\xDD\x1E\x04\x3F\x42\x1E\x03\x4F\xA5\xDE\xB8\x34\x08\x79\x5E\x08\x30\xB5\x7E\xBE\xA0\x03\xBF\xBD\x47\x01\x8F\x4E\x11\x1E\x4A\x45\x7E\xA0\x03\x78\xBF\x8E\x02", - "\xDE\xBD\x23\x0D\xF7\xBD\x08\x02\x7E\x93\x02\x84\xBE\xA1\x24\x68\x01\x2D\xBC\x16\x14\xFC\x9A\x05\x16\xBF\x30\x68\x60\x0B\x07\x27\x1F\x07\xF6\xA6\xFB\xA0\x06\x1D\xBF\x99\x40\xF3\x01\x29\x90\x27\xB0\x1A\x05\xFB\xA1\x7E\xE2\xBE\xE6\x03\xEF\x2B\x3F\x07\xE0\x03\xF7\xAC\xFD\x9D\x04\x2E\xBF\xD4\x4B\xD3\xBD\xF9\xA2\x2A\x27\x70\x14\xFD\xB2\x7E\xBB\xBD\xD7\x77\x6B\xBE\x49\x9A\xF7\xBD\x40\x6F\xFD\x80\x91\x3E\xBF\xBB\xBE\x0D\xB4\xF0\xB8\xF7\xB9\xEC\xA4\xFE\x91\x7B\xC5\xBF\xC6\xBF\xA0\xBE\xF0\xB9\xF6\xB1\x19\x07\x66\x9A\x2C\xFF\x01\x73\xBE\x8A\x53\xEF\xBB\x22\x01\x34\x30\x8E\x3F\x03\x57\xBE\x1D\x03\xEC\x03\xD9\xBD\xA6\x9E\xCC\x9F\x07\x3C\x0B\x1E\x02\xFC\x05\xED\xBF\xF4\xBD\xF8\x23\x17\x02\xBE\x3F\x03\x06\x1D\x1D\x02\xF4\xBE\x82\xAE\x2C\x09\xFE\xAC\xFF\xAB\x7F\x90\x3F\x1E\x23\x81\x01\x08\x05\xFD\xB0\x3C\xB4\xFF\xA6\x1B\x76\xBF\x06\x03\xF9\xBF\xFB\xBF\xFE\xBB\xFF\xB9\xFF\xB8\x7F\xDC\x1A\xFF\xBF\xB2\x19\x00\xC6\xAD\x13\x00\xC2\x01\x05\x80\x87\xC0\xFD\xBF\xDC\xBD\xBA\x10\xEF\xBB\x00\xC3\x00\xCC\x80\xA6\x04\x0E\xC1\x08\xC1\x02", - "\xC1\x09\x61\xFF\xB4\x00\xE9\x2B\x06\xBF\xE9\x15\xBF\xBF\x05\xC3\x00\xC8\x01\xD3\x08\x1D\x80\xFC\x6A\x15\xC0\x2B\x0F\x00\xC2\x03\xC5\x6A\x1C\x00\xE3\x80\x83\xC0\x1E\x03\x74\x14\xE1\xBA\x05\xC3\x00\xCB\x01\xD0\x7E\xAD\xC0\x30\xC1\x09\xC2\x67\xB3\xF7\x12\x42\x72\x01\xE0\x00\x03\xC0\x37\xC0\x1B\xC0\x0E\xC3\x00\xCF\x01\x1C\x01\xFE\x80\xB2\xC0\x3D\xC0\x19\xC1\xDF\xB9\x5D\x13\x04\xD3\x0F\x03\x80\xC5\xC0\x40\x55\x10\xC0\x12\xC6\x92\x03\x00\xD3\xFB\xA9\x2B\x41\xBE\xE9\x15\xB8\xBD\xBA\x12\xE9\xB9\xAE\x17\xFA\xA9\x2B\x7A\xBE\x57\xC1\x01\xC0\x16\xC3\x22\x0B\x05\xCD\x2C\x03\x80\xEF\xBE\x21\xC0\x30\xC1\xBA\x12\x0C\xC3\x11\x04\x03\xFF\x77\x5F\xC0\x68\xC0\x19\xC0\xD5\xBA\x4E\x32\x10\x0B\x03\xF4\x80\x83\x02\x6E\xC1\x10\xC1\x1C\xC1\x5D\x13\x07\xD8\x2E\x43\x80\xF5\xC0\xEB\x03\x3B\xC1\x1A\xC5\xF8\x28\x07\xCC\x08\x26\x81\xF4\x22\x03\xC1\xA2\xBF\xEF\x19\x5A\xA1\x02\xD8\xFC\xAF\x81\x8F\x17\x03\xC1\xB0\xB3\x20\xC7\x53\x69\x08\xC3\x00\xE0\x46\xA1\xC0\x8F\xC1\x74\x15\x56\xB3\x11\xC2\x56\x83\x00\xF9\x65\xA9\x27\x72\xAC\x36\xC0\x00\x02", - "\x03\x03\x00\xDC\x04\xF2\x80\xEE\xB3\x21\xC1\x4B\xC2\x26\xC6\x13\xC5\x7C\x20\x05\xE9\x2B\x19\x00\x03\xC0\x54\xC2\x0C\xC0\x03\x03\x00\xCC\x05\xF2\x80\xDD\xC0\x7E\xC0\x3D\xC2\x0C\xC2\x10\xC8\x09\xC8\x04\xF2\x80\x8A\xC1\xB5\xC1\xF1\xAD\xF1\x2B\x12\xC9\x0B\xC2\x05\xC7\x82\x9B\xC1\x03\xC0\x53\xC3\x49\x05\x15\xC3\x00\xDD\x8F\xA1\x80\xC6\xC1\xE9\x14\x64\xC3\xD7\xBA\x06\xC4\x02\x03\x00\xC8\x7D\xE9\x15\xCF\xC0\x29\xB5\x47\x03\xAB\x32\xD5\x20\x28\x3F\x03\x65\x19\x67\xBE\x6C\xC3\x34\xC7\xF6\xBA\xA6\x27\xC8\x95\x83\x93\xB3\x8C\x32\x04\x95\x9E\x34\x20\x16\x22\x73\x08\x33\x7D\xE5\x19\xE7\xC0\x73\xC3\x36\xC5\x7C\xAF\x0D\xC7\xFE\xB9\x61\x11\x03\xFA\x3E\xBA\x3F\x3F\x04\x23\x37\xF6\xB4\x07\xDD\x04\x76\xC1\xD2\xC1\xC8\x03\x28\x48\x79\x4F\x0F\x07\xDD\x01\x7D\xFE\xC1\x1D\x03\xD3\x37\xD9\xBA\x20\xC1\x10\xDC\x06\xC1\x82\x6C\x80\x3E\x45\x60\xBC\x4A\x49\xF3\xBB\x10\xDE\x06\xF6\x7D\xDD\xBE\xE6\x03\xD5\x4F\x3F\x06\xC8\x31\xF4\xB4\x08\xD0\x84\xBB\xBF\x46\x3D\xB3\xBE\x91\x3A\x2A\x2B\x11\xD7\x08\xCC\x5F\xD7\x7F\x73\xBE\x8B\xC3\x32\xC5\xF7", - "\xB3\x12\xCC\xE0\xBA\x5E\xA1\xC2\x88\xBE\xF3\x01\xD9\x4F\x1F\x0F\x13\x47\xFB\xAD\x84\x9D\x02\x3F\x42\xA9\x21\x4C\xC0\x26\xC3\xFE\xA4\xAF\x72\x84\xA0\x03\x1B\x65\x30\x63\x3F\x01\x8F\x4F\xFD\xBC\x09\xC3\x7E\xB5\xC2\x8C\x6D\xB3\xBD\x1E\x49\xE8\xB3\x14\xDF\x09\xC6\x5F\x8F\xB2\x57\xBF\x3C\x4A\x54\x22\x29\xC6\x14\xDF\x08\xCE\x0D\xF3\xBE\x3E\xC3\x17\xC3\xEE\xBD\x28\xC2\x15\xC2\x07\xCF\x64\xCB\xC2\xEA\xC1\xAA\xC0\x5B\x06\xC0\x7F\x19\x1C\x0A\xC9\x04\x18\x4F\x67\xBE\xB0\xC0\xE3\xB8\x28\xC5\xB8\x51\x0C\x1E\xA5\x73\x02\x67\xC3\xA6\x02\x57\x57\xEC\xBB\x16\xD2\xFC\xBB\x7E\x86\xBF\x8E\xBE\xF3\x00\x5C\x5B\xE8\xB0\xD7\x47\xFB\xB5\x85\xF1\xC2\xBB\xBF\xC7\xBF\x19\xC0\x67\x0F\xF6\xA3\xFA\xAF\x7D\xE7\xBE\x7F\xC3\x8E\x01\x60\xC5\x0C\xCD\xF4\xA6\x0F\x2E\x81\xC3\xBE\x6E\xC1\xB3\xBD\x62\xC5\x23\x0B\x18\xD6\x03\xFB\x7E\x8D\xC3\x79\xC1\xC8\x01\x81\xB4\x23\x03\x19\xCA\x08\x1F\x4A\xE7\xBE\x97\xC2\xC5\xBC\x59\xC4\x23\x90\x1A\x14\x05\xC5\x1E\x1E\xC3\xDC\x09\x7F\x00\x68\xC6\x23\x06\x08\xD3\x0B\x25\x86\xCD\x02\x86\xC0\xD2\xC3\xE4\xBB\x35\xC0", - "\x21\x06\x0F\x38\x82\xE1\x0E\xFF\x01\xD7\xC0\x4D\x02\x36\xCE\x11\x14\x0D\xCE\x1A\x20\x03\xB6\xC3\x89\x01\x6E\xC4\x41\xB8\x33\x0C\xCD\x9B\x04\x46\xC1\x1D\x03\xFE\xA3\xD9\xBE\x15\xC0\x4C\x04\x0E\xD6\x83\xC6\xC3\x5A\x02\xE4\xC3\x51\x02\x39\xC4\x13\x0C\x0E\xDE\x04\x4E\xC3\x1D\x02\xE8\xC1\xD1\xB4\x0E\x74\x1D\xD1\x0C\x12\x87\xEE\x66\xD5\xC2\xBF\x02\x2A\xC0\x98\x0B\x1D\xD6\x06\xDD\x87\x8C\xC2\xCF\x10\xD0\x03\x77\xC6\x0F\x81\x57\x86\x0F\x24\x82\xD6\xC1\xE7\xC2\xF0\xC3\x40\x01\x3D\xC4\x1E\xCB\x51\x1B\x86\xC0\xC1\xBB\xBE\xF6\xC1\x17\x6B\x22\x02\x1F\xC7\xFB\xB5\x87\x9D\x02\xF2\xC2\x8F\x01\x7E\xC0\x3F\xC0\x1A\x1B\x0F\xF4\x87\xFD\xC3\x00\xC5\xC8\x02\x7F\xC7\xB3\x81\x20\xC9\xB4\x66\x07\x6E\xB3\x43\xBE\x50\xC1\x47\x02\x41\xCB\xAC\x00\x0D\x2E\x67\xE7\xBE\x0F\xC5\x05\xC7\x7B\xC1\x42\xCD\x20\xDB\xFD\x94\x88\xDF\xA3\x35\xC0\xC6\x8A\x79\x06\x17\xC3\xF4\xBE\x05\xDE\x04\x1E\xC4\xFB\x14\xD0\x00\x2F\xC5\xF0\x03\x22\xC1\x0D\xE5\x88\xC1\xBE\x25\xC5\xB3\xBD\x89\xC2\x2A\x2B\x22\xDD\x08\x2D\x88\xD3\x1C\xEF\xC3\x17\xC5\x71\xB7\x28\x05\x22", - "\xDC\x42\x19\x85\xB3\xC4\x2A\x3C\x17\x9C\x3B\xC1\x45\xCE\x22\xC6\x08\xD5\x82\x91\x03\x25\xC5\xB9\xBF\x89\xC5\x47\xCB\xFB\xB2\x11\xFA\x88\x9F\x04\x37\xC5\xDA\x16\x79\x01\x42\xBA\x10\x0F\x04\xFC\x04\x66\x03\x41\xC1\xED\x07\x3F\x01\x4A\xCC\x16\x14\x12\xDA\x05\x56\xC4\xF8\x12\xD0\x00\x96\xC4\x26\x0B\x25\xC4\x5D\x1A\x89\xDF\xC4\x7A\xAC\xF3\x01\x0E\xC2\x4A\xC3\x26\xD9\x10\xC5\x33\x6F\xC3\x65\xC4\xF5\xC0\x04\x18\x4D\xCC\x26\xDB\xFD\xA9\x89\xED\xC3\x07\x18\x1F\xC4\x06\x1A\x4E\xCF\x26\xDD\x86\x73\x89\x96\x65\x77\xC4\x84\xC1\x9D\xC2\x2A\x2B\x27\xDD\x08\x35\x89\x9E\x02\x7F\xC4\x3F\xC4\x68\x01\x50\xC4\xB0\x06\x0F\x3A\x7F\xD2\xC4\x87\xC4\x85\xC2\xFF\xBC\x1D\xC9\x28\xD5\xB2\x0B\x8A\xCE\xC2\x65\xA9\xAF\x21\x47\x05\x51\xC0\x50\x31\x14\xFA\x4D\x2A\x8D\xEF\xC2\x4A\xC7\x7C\xC5\xFE\xBB\xFB\xBA\x14\xF1\x7D\x9E\xC5\x93\xC4\x19\xC0\xA6\xC7\x28\xCA\x29\xD7\xFA\xA5\x8A\xA1\xC5\xF0\xBE\x4D\xC6\xDD\xBA\x55\xC8\x2A\xCD\x08\xD6\x8A\xAE\xC5\xA3\xC4\x58\xC4\xAB\xC5\x50\xC9\x2A\xCE\xFF\x9C\x8A\xAC\x3A\xB4\xC4\x5C\xC7\xAD\xC7\x6B\x3D\x2A\xDC", - "\x15\xF9\x8A\xBE\xC5\xBB\xC4\xDD\xAD\xAC\xC7\xFA\x73\x2C\xD9\xFD\x9A\x8A\x9E\x02\x9A\xC4\xC2\xBE\xA6\xC2\xE9\xBA\x29\xDD\xFB\x9A\x8A\xF8\xBE\x06\xC0\x9C\x05\xB4\xC2\x4A\xC3\x2D\xCC\x0B\x15\x8B\xDA\x02\xD7\xC5\xA3\x01\xB6\xC4\x26\x0B\x2D\xDE\x08\x1D\x8B\xAB\x8B\xA0\x03\x11\x02\x79\x02\x5C\xC5\x30\x1F\x07\x24\x8B\xEE\xB8\xE1\xC5\x74\xC5\x64\x07\x5C\xCC\x16\x0C\x17\xDA\x05\x6E\xC5\x47\x02\x78\xC4\x4D\x05\x19\xC8\x33\x14\x17\xD2\x89\xF6\xC5\x76\xB8\xD0\x00\xBE\xC2\x2B\x0B\x2F\xC7\x0A\x3D\x8B\xB4\x02\x25\x00\xF3\x01\xC0\xC5\x5C\xC3\x30\xDE\x0B\x05\x8C\xA9\x0D\xA0\x03\x83\xC5\x1F\xB9\x61\xCC\x30\xD1\x0C\x26\x00\x66\x03\x0F\xC7\x72\xC5\xC4\xC6\x2F\x03\x31\xCC\x0B\x15\x8C\xDA\x02\x17\xC7\xA3\x01\xC6\xC4\x26\x07\x02\x06\x0F\x1D\x8C\xE5\xC5\x1F\xC6\xBF\x01\xC8\xC2\x47\x00\x1A\x03\x19\xDA\x05\x28\x00\xE6\x02\x94\xC5\xB9\xC2\x65\xC1\x2E\x47\xAA\x6E\x8C\x91\x03\x29\x00\xF3\x01\xCC\xC5\x5C\xC3\x33\xDE\x0B\x35\x8C\xE6\xC4\xC6\x26\xF3\x02\x0A\x04\x37\x0F\x0F\x1B\x19\xD1\x06\x3E\xC6\x7E\x02\xA0\xC4\x5B\x02\x68\xC4\x6B\x00\x0D", - "\x04\x8D\xC5\x04\x46\xC7\x52\x6A\x79\x03\x05\x0C\x33\xCC\x1A\xF8\x89\xCE\xC6\x24\xC2\xB1\x03\x7B\xC0\x6A\xCC\x16\x14\x1A\xDA\x05\x2C\x00\xE6\x02\xAC\xC5\xB9\xC2\x6B\xCE\x17\x1C\x1A\xF8\x8C\xCA\x29\xA0\x02\xAF\xC7\xD5\xC7\x3D\xCD\x02\x06\x0F\x25\x8D\xE5\xC5\x67\xC6\xBF\x01\xDA\xC4\x2D\x0B\x36\xDA\x0A\x2D\x8D\xC7\x02\x6F\xC7\x07\x14\x68\x01\x6E\xCE\x11\x0E\x01\x26\x07\x76\xC6\xE5\xC4\xBC\xC6\x5F\x02\x6F\xCC\x16\x1C\x1B\xDA\x05\x7E\xC6\x47\x02\xC0\xC7\x94\x00\x34\x02\x38\xDE\x08\x2F\x00\x66\x03\x87\xC7\x72\xC5\xE2\xC6\x2F\x0B\x38\xCF\xB6\xA0\x06\x0D\xC7\x5A\x02\xC8\xC7\x51\x02\x72\xC4\x13\x14\x1C\xC6\x8E\x8F\xC7\x98\xC7\xC8\x02\xE5\xC4\x2E\x06\x1E\x10\x01\x3C\x8C\x9E\xC7\x91\x02\xD0\xC6\x5F\x01\x2A\xB0\x4C\x04\x1D\xD6\x83\xA6\xC7\x5A\x02\xD4\xC7\x51\x02\x75\xC4\x13\x0C\x1D\xDE\x04\x2E\xC7\x1D\x02\xD8\xC7\x95\x1E\x3C\x02\x03\x1C\x19\xF5\x8E\xBB\xBF\xB7\xC6\xBF\x01\xEE\xC7\x6B\xC5\x04\x26\x0F\x33\x00\x3C\xC6\xBF\xC7\xC8\x01\xF0\xC6\x2F\x03\x3C\xCC\x0B\x05\x8F\xDA\x02\xC7\xC7\xA3\x01\xF2\xC4\x26\x0B\x3C\xDE\x08\x0D", - "\x8F\x9D\x02\xCF\xC7\x89\x00\x0D\x06\x3C\x03\x3D\xC5\x17\xD5\x8F\xFE\x02\xD7\xC6\xB6\x01\x0D\x06\x3C\x0B\x3D\xC5\x17\xDD\x8F\xFE\x02\xDF\xC6\xED\xC4\x68\x01\x7C\xCA\x15\x04\x1F\xC9\x1B\x63\xC7\xA0\x02\x1B\x02\x79\x02\x7D\xC5\x2E\xCC\x1F\xFE\x05\x6E\xC7\x6C\x02\xF8\xC6\x56\x02\x7E\xCE\x0D\xD4\x1F\xDB\x8A\xB9\xBE\x72\xC4\xFB\xC6\x54\x22\x7F\xCE\xBD\x0F\x0F\xF6\x8F\xE7\xBE\x37\x00\xF3\x01\x00\xCD\x5C\xC3\x40\xDE\x0B\x38\x00\x66\x03\x07\xC9\x72\xC5\x02\xCE\x80\xC0\x1A\x0B\x20\xEC\x05\x0E\xC8\x5A\x02\x08\xCB\x51\x01\x07\x06\x1E\x14\x20\xE5\x8B\x96\xC8\x49\xB2\xD0\x00\x06\xCC\x2D\x0B\x41\xDA\x0A\x1D\x90\x93\xC8\x1A\xC8\xD0\x02\x0E\x06\x3C\x03\x42\xC5\x17\xE5\x90\xFE\x02\x27\xC8\xB6\x01\x0A\xCA\x2B\x0B\x42\xC7\x0A\x2D\x90\xB4\x02\x2F\xC9\x4D\x7B\x7B\xC7\x85\xC7\xF6\xB4\x21\xF0\x66\xB3\xC8\x38\xC9\xDD\xBE\x0D\xCA\xA4\x16\x1E\x1B\x01\x3C\x8C\xBE\xC8\x91\x02\x20\xCB\x85\x60\x34\x02\x44\xCC\x0B\x05\x91\xDA\x02\x3C\x00\xF3\x01\x12\xCD\x5C\xCB\x44\xDE\x0B\x0D\x91\xEC\x02\x4F\xC8\x24\xC8\x68\x01\x8A\xC7\x14\x1D\x01\x26\x07", - "\x56\xC8\xE5\xC4\x2C\xCA\xF1\xB8\x00\x0A\x45\xCA\x14\xCD\x6B\x4C\xBF\xA7\x02\x30\xC9\xA1\x07\x3D\xCD\x45\xC8\xFE\xAC\x34\x64\xC8\x72\xC5\x32\xCA\x37\xC2\x8D\xC6\x27\xCC\x23\xDE\x04\x6C\xC8\x41\xBE\x36\xCB\xD9\xBC\x8D\xC2\x15\x2E\x23\xDD\x04\x3E\x00\xE6\x02\x3C\xC9\xB9\xC2\x8F\xC1\x35\xC6\xCB\x6F\x87\xFC\xC8\x26\xC2\x57\x31\x30\x90\x34\x0F\x03\x06\x0F\x05\x92\xE5\xC5\x87\xC8\xBF\x01\x22\xCC\x2D\x0B\x48\xDA\x0A\x0D\x92\xC7\x02\x8F\xC8\x6F\x08\x21\xC8\x34\x00\xC2\x9C\x08\x15\x92\x8A\x02\xC1\x4C\x8F\x01\x26\xC8\x30\xB4\x49\xDD\x24\xD6\xD5\x1E\xC9\x7E\x03\x4D\xC8\x0B\x3E\x3C\x03\x6B\x81\x0D\xE5\x92\xF8\xBE\xA5\xC8\xBB\xBD\x29\xC9\xEE\xB5\x4A\xD7\xFA\xA5\x92\xDF\xBF\xA5\xC8\xA5\xBD\x29\xCA\x2A\x25\x4A\xD9\xFA\xA5\x92\x9E\x02\xA5\xC9\xA0\xBD\x29\xCB\xEE\xB5\x4A\xC8\xFA\xA5\x92\xE7\xBE\x42\x00\xF3\x01\x30\xCD\x5C\xC3\x4C\xDE\x0B\x05\x93\xEC\x02\x43\x00\xF3\x01\x32\xCD\x5C\xCB\x4C\xDD\x23\xC1\x75\x20\x03\x44\x00\xF3\x01\x34\xCD\x5C\xC3\x4D\xDE\x0B\x15\x93\xEC\x02\x45\x00\xF3\x01\x36\xCD\x5C\xCB\x4D\xC0\xEC\x62\xE7\x5F", - "\xC9\x91\x03\x6E\xC8\x5B\x06\x08\x06\x1E\x04\x27\xE5\x8B\xE6\xC9\x7E\x02\x74\xCB\x38\xCD\x7E\x20\x1A\x07\x02\x26\x07\x6E\xC9\xE5\xC4\x78\xCA\x5F\x02\x9E\xCC\x16\x14\x27\xEA\x89\x8A\x3D\xEF\xC3\x8E\x00", + "\x00\x00\x10\x00\xBB\x5D\x00\x00\x73\x00\x01\x82\x80\x0A\x23\x82\x81\x82\x06\x89\x82\x92\x1A\x87\x1A\x84\x1E\x0A\xFF\x52\x93\x84\x8D\x8A\x8B\x89\x51\x0A\x9C\x6A\x8A\x72\x84\x78\x85\xFC\x0A\x8B\x01\x09\x84\x08\x92\x83\x29\x27\x83\x8F\x1A\x92\x81\x1B\x96\x01\xBB\x30\x80\x01\x23\x99\x25\x99\x4F\x33\x92\x33\x98\x2B\x98\x31\x99\x64\x33\x97\x9F\x72\x3B\x9B\x43\x99\x93\x33\x98\x53\x96\x53\x99\x55\x99\xB4\x33\x88\x73\x90\x7B\x99\x7D\x99\x03\x02\x09\x8A\x0A\xAE\x83\x09\xAE\x03\x9A\x20\xA2\x83\xA0\x13\xB1\x80\x43\xC3\xA4\x07\xB0\x04\x1C\xB7\x22\x6C\xCE\x2C\xBB\x2C\xB7\x2C\xB7\xA1\x67\x6C\xB4\x37\xB7\x88\x3C\xBE\x8B\x94\x7F\x95\x97\x4C\xB6\x4C\xB6\x54\x6C\xB6\x6C\xBD\x52\xC1\xB7\x88\x62\x6C\xDF\x6C\xA9\x7C\xB0\x7C\xB6\x7E\x6C\x80\x03\x09\x84\x03\xCE\x83\xA1\x0B\x1E\xC3\x83\x49\x30\x9B\xA0\x85\x00\x27\xD1\x97\x88\xD2\xD5\x84\xD7\x9F\xAC\xEB\xD6\x8D\xD2\xDB\xD6\xDB\xB1\xB4\xF3\xD5\x85\xDA\xDF\xDA\xDF\xB9\xBC\xFB\xD4\x8D\xDA\xE3\xDE\xE3\xC1\xC4\xC3\xF3\x88\xD0\xD7\x99\xD4\xB8\x83\xB0\xD2\xE1\xEC\xB1\xEA\xB4\xD7\xD0\xC0\xF4", + "\xEB\xEE\xE9\xEF\x80\xCF\xCF\xD3\xFE\xE8\xE3\x81\xCD\xE7\xA2\x83\x8F\xE4\x0A\x87\xE5\x03\xF6\x0A\x86\x30\xE9\x87\x03\xFA\x82\x04\xF6\x83\x89\x19\xF2\x82\x04\xFF\x80\x0B\x3F\x70\x00\x03\x02\xA3\x78\x77\x77\xDA\x65\x74\x7A\x72\xC7\x4C\x89\x70\x73\xCB\x52\x45\x72\x83\xDC\x4A\x87\x82\x85\x09\x94\x8B\x80\x84\x0D\x9C\x8F\x82\x84\x11\xBF\x33\x86\x87\x15\x9A\x87\x86\x89\x00\x0D\x05\x81\x76\x06\x99\x84\x8A\x40\x0E\x2B\x88\x81\x8B\x34\xAC\x86\x8F\x8C\x37\x98\x85\x8C\x8E\x3C\xBA\x89\x8C\x8A\x3B\xBE\x8D\x8C\x90\x3F\xAF\x87\x8A\x91\x2E\xA0\x8D\x86\x92\x1F\xA2\x81\x8B\x88\x4C\xA5\x88\x91\x90\x44\x83\x93\x95\x91\x51\x9B\x89\x97\x91\x5B\x89\x9E\x93\x92\x5F\x8D\x90\x95\x98\x52\x9D\x94\x97\x95\x56\x9D\x9F\x02\x8C\x42\xAD\x95\x96\x9B\x68\xB0\x96\x98\x96\x64\x9A\x95\x9C\x97\x77\x9E\x93\x9B\x9E\x4F\xBD\x90\x98\x9F\x7F\xBE\x92\x9A\xA0\x65\xB9\x97\x9B\x9C\x69\x86\xA4\x9C\xA0\x83\x81\xAE\xA1\xA3\x90\x85\xAC\xA2\xA4\x84\xB6\x93\xA6\xA5\x95\xB8\x97\xA6\xA6\x99\xBA\x9D\xA7\xA1\x8A\x89\xAB\xA6\xA7\x8F\x94\xA5\xA8\xA6\xA7\x9C\xA9\xA8\xA9", + "\x91\xA8\xAD\xAA\xAA\xAF\xAC\xA6\xA9\xAC\xA0\xA3\xA5\xAF\xA7\x8B\xB8\xA2\xAA\xAE\x72\xA1\xAD\xAE\xAD\xB9\xAB\xA7\xAE\xB0\xC1\xB4\xA5\xB3\xAC\xC8\xAE\xA9\xB0\xAC\xCB\xB2\xAA\xB3\xB3\xCC\x90\xBE\xB1\xB4\xD4\x93\xB6\xB7\xB0\xC6\xBB\xA4\xB2\xB6\xD9\xBF\xAC\xAF\x9B\xE0\xB1\x91\xB8\xA2\xDE\x9B\xB5\xB9\xB7\xE3\xBE\xA9\xB8\xB0\xDC\x8D\xB8\xB6\xBB\xC7\x92\xBF\xBA\xBC\xF1\x95\xB3\xBE\xBD\xF5\x97\xB9\xBF\xBD\xFA\xAD\xB4\xBE\xBF\xF8\x80\xCD\xBF\xB9\xF0\x82\xCC\xBF\xC1\xFB\x89\xC6\xC2\xC2\x04\xFF\xBD\xC1\xC0\x0F\xC3\xCB\xBB\xB7\xE2\x95\xC4\xBB\xC4\xE6\x98\xC8\xBA\xC5\xEA\x9C\xCC\xB9\xC4\x08\xCB\xC2\xC8\xC8\xF9\x90\x0C\x9A\xC6\x05\xE4\xC2\xC1\x04\x02\x92\x01\x7C\xC5\x17\xDE\xC0\xCD\xC7\x31\xF5\xC4\xCF\xCD\x1F\xE8\xCE\xC2\xCE\x10\xFC\xC2\xC6\xCC\x19\xC0\xDB\xC6\xCD\x39\xC2\xD9\xCA\xCF\x21\xEA\xCA\xD0\xD2\x0C\xCC\xD3\xCA\xD3\x4B\xC6\xDB\xCE\xD4\x3D\xD4\xDF\xCC\xD1\x33\xC5\xD8\xD5\xD0\x5B\xC3\xD8\xCD\xD6\x60\xDC\xDF\xD6\xD8\x5A\xE3\xDE\xD5\xD9\x68\xE1\xD7\xDA\xDA\x47\xD6\xD9\xD0\xD4\x70\xEE\xDD\xD2\xDC\x08\x98\x02\x81\x06\x2F", + "\xE4\xDC\xDB\xD4\x5D\xED\xDD\xDC\xDF\x66\xFE\xD1\xE0\xE0\x69\xFA\xD6\xE3\xDA\x87\xC2\xE5\xE0\xE2\x8C\xCA\xEB\xDD\xD5\x7F\xD0\xE3\xE2\xE4\x8B\xCE\xE9\xE0\xE1\x8F\xD7\xD3\xE6\xE6\x95\xD8\xE7\xE4\xE5\x99\xEF\xD4\xDD\xD4\x91\xDC\xE1\xEB\xDC\xA5\xE2\xE9\xE8\xEA\x9B\xEA\xED\xE8\xEB\x9D\xE0\xEF\xE6\xE9\xB3\xED\x8F\x06\x80\x20\x39\xDD\xE2\xE7\xBB\xF2\xED\xEC\xED\xBF\xEE\xE1\xEC\xF0\x96\xC1\xF0\xEF\xE9\x4F\xE3\xE1\xDF\xEA\xC9\xCC\xF4\xEB\xEB\xCD\xD0\xFF\xF3\xF0\xC2\xC8\xF3\xF6\xF5\xCB\xD2\xF9\xF4\xF5\xC7\xF5\xED\xF6\xF1\xD1\xDC\xF1\xF8\xF6\xCA\xE5\xFE\xF3\xF6\xE4\xE7\xF6\xFA\xF6\xEB\xE2\xF7\xF6\xF7\xE3\xF0\xFF\xF8\xF8\xF3\xC3\x46\x0B\xC9\xED\xE9\xFC\xF9\x97\x27\x38\xF5\xE8\x0A\x02\x49\x06\x80\x2A\x02\x41\x15\x02\x44\x05\x02\x4D\x06\x80\x2E\x02\x41\x17\x02\x40\x06\x02\x51\x06\x80\x0C\x29\x20\xF1\x1F\x7D\x78\x18\x9C\x75\x06\xBE\x7B\x82\xE2\x52\x5B\x06\xFE\x7B\x7D\x9E\x34\x01\x84\xF7\x68\x7A\x7E\x27\x94\x7D\x0A\x9D\x85\x7A\x14\xB9\x7E\x85\xEA\x71\x86\x08\xA6\x8F\x84\x15\x96\x6D\x06\x25\x9A\x7C\x0D\xB2\x8B\x87\x19\xBA\x87", + "\x87\x30\x9E\x87\xAA\x36\x09\x87\x20\xA3\x56\x21\x15\x99\x70\x0E\x45\x81\x57\x1C\x02\x42\x07\x02\x5B\x06\x80\x10\x29\x89\x84\x3D\x02\x40\x3E\x02\x43\x0F\x02\x40\x08\x01\x41\x0A\x40\x42\x02\x43\x10\x4C\x8C\x85\x0B\x9A\x87\x8C\x1C\x88\x8E\x07\xE9\x81\x20\x22\x24\x8A\x8D\x45\x0F\x8C\x1B\xEB\x84\x8F\x16\xB6\x84\x87\x40\x97\x8E\x10\xFA\x8D\x87\x3E\xB9\x8D\x8C\xF1\x7C\x8D\xA7\x46\x02\x8F\x3A\xA6\x8B\x8E\x76\x80\x91\xFD\x6A\x89\x90\x46\x87\x96\x90\x81\x8D\x5B\x11\x05\x9D\x90\x44\x8F\x95\x92\x90\x8B\x92\x25\x91\x9E\x90\x4E\x9B\x92\x93\x99\x8B\x85\x27\xA0\x98\x93\x52\x97\x97\x94\x9E\x81\x95\x0D\x8A\x92\x95\x4F\xAD\x92\x95\x78\x86\x8B\x1F\xA3\x9F\x94\x4C\x88\x0A\x40\x49\x1A\x74\x2B\xAB\x94\x96\x5E\xAE\x96\x97\xB0\x9B\x8F\x2E\xB1\x92\x90\x59\x86\x9D\x98\xC8\x83\x9A\x30\xBD\x94\x98\x65\xBE\x8F\x98\xCE\x93\x97\x2F\xCD\x9C\x99\x65\x93\x9E\x9A\xC1\x8F\x99\x32\xD5\x9A\x9B\x68\x90\x9C\x9B\xD2\x99\x99\x38\xA6\x99\x94\x72\xA4\x90\x95\xE7\x85\x9C\x3A\xBE\x6F\x08\x4A\xAB\x98\x98\xE6\x95\x97\x3B\xD4\x97\x9B\x6E\xA0\x9F\x9B\xF5\x83", + "\x9F\x3C\xD8\x91\x9E\x78\xBB\x9E\x9E\xF9\x98\x9E\x38\x82\xAD\x9E\x7A\x83\xA3\x9B\x01\xA8\xA3\x41\xDE\x96\x20\x28\x02\x41\x23\x09\x32\x3C\x41\xFF\x9A\x9E\x75\x96\xA1\x9D\x18\xB2\x9F\x45\x9A\xA9\xA2\x7F\x9B\xA6\xA3\x1D\xA6\xA1\x41\xFC\x94\xA3\x89\x9F\xA2\xA4\x25\xAA\xA3\x48\x80\xAB\xA1\x7B\xAA\xA1\xA5\x0C\xB1\xA6\x4B\xB2\xA9\xA0\x9A\xB4\x8F\x0A\x02\x58\x0A\x2E\xB3\xAC\xA7\x9A\xBD\xA5\xA5\x3E\xA1\xA8\x50\xC3\xAB\xA5\x8A\xA1\xA4\xA4\x27\xA8\xAB\x51\xAC\xA5\xA8\x93\x8B\xAE\xA8\x1C\xB1\xA8\x48\xD2\xA8\xA5\xA4\x8C\xA8\xA6\x3F\xAD\xAB\x4B\xD6\xA0\xAB\xA9\x9E\xAD\xAA\x4F\xAE\xA8\x55\xCA\xAE\x66\x2F\x2E\x9C\xAB\x02\xBF\x0A\x80\x60\x05\x91\x30\x02\x42\x0C\x02\x43\x0E\x80\x64\x02\x41\x32\x02\x46\x0C\x02\x47\x0E\x80\x68\x02\x41\x34\x02\x42\x0D\x02\x4B\x0F\x59\xE1\xAB\xAA\xC2\xB6\xA0\x93\x6C\x03\xB2\xCF\x6D\x0A\xB1\xAF\xA4\xAE\xB1\x57\xA8\xAD\x61\xE3\xA1\xB2\xC3\x99\xA8\xAB\x42\xBC\x5E\x1B\x0D\xB0\xAC\xCA\x9D\xAD\xB3\x90\xBF\xB3\x63\xA5\x7F\x0C\xCE\xA3\xB7\xB4\xA8\x30\x0E\x69\xA8\x31\x0E\x01\x72\x0A\x40\x00\x35\x8A\x41\x74", + "\x02\x41\x3A\x02\x46\x0E\x02\x57\x0E\x80\x78\x02\x41\x3C\x02\x42\x0F\x02\x5B\x0F\x6A\xA2\xB5\xB2\xCF\xA2\xAE\x6A\x7C\x03\xBB\xAA\x7D\x0A\xB9\xC9\xA1\xB7\xB8\xA0\xB1\xB8\x6A\xC4\xB4\xBA\xE8\x93\xBE\xBA\x2C\xBE\x0D\x73\x87\xB8\xB2\xA2\x9D\xBA\xAB\xDC\xA9\x97\x1F\x5B\xB7\xB3\x54\x80\x14\xBC\x01\x21\x12\x80\x02\x12\x41\x41\x02\x44\x10\x02\x45\x12\x80\x06\x12\x41\x43\x02\x40\x11\x02\x49\x12\x80\x0A\x12\x41\x45\x28\xBE\xBB\x92\xA1\xBE\x65\xF3\x8C\x11\xFF\xAD\x45\x11\x06\xDF\xBA\x82\x81\xC5\xBD\x01\xC0\xC6\xC1\xE0\xAD\xC2\x71\xCE\xB5\x74\x47\x09\xC4\xC1\xD5\x4F\x12\x80\x10\x1B\xA7\xCC\x8B\xC0\xC2\x1F\xD3\xC2\x80\xA2\xC2\xC3\xE7\x94\xC7\xBA\x27\xC5\xBA\x89\xA3\xCB\xC5\x12\xD2\xBA\xC5\x2F\xD5\xB9\x8A\xB2\xCC\xC5\x18\xD8\xBC\xC6\x2E\xC8\xC5\x8D\xBA\xC9\xC6\x18\xFC\xC6\xC3\x18\xCF\xC0\x8A\x16\x17\xC2\x10\xC1\xC9\xC2\x40\xC6\xCA\x92\xA4\xC9\xC8\x26\xC2\xCD\xC5\x4D\xD0\xCB\x93\xB6\xC3\xC7\x1B\xD6\xCD\xCA\x58\xDB\xC6\x8F\xDB\xC8\xC7\x28\xD4\xCA\xCB\x5D\xD3\xCB\x8F\xC3\xA7\x13\x22\xCE\xC8\x13\x66\xD2\xC8\x92\xE2\xCC\xCB\x2B", + "\xE0\xCE\xCD\x3D\xC1\xCF\x9A\xF3\xC1\xC4\x35\xF5\xCF\xCB\x71\xD0\xCE\x97\xE3\xC4\xCF\x23\xF7\xCC\xCF\x7F\xCD\xCD\x96\xF9\xC3\xD1\x6A\x59\x11\xCD\x78\xDB\xCE\xA0\xEF\xC5\xD0\x36\xF2\xC9\xD0\x8F\xDE\xCE\xA4\xCB\xC6\xCF\x49\xCE\xCD\xCF\x94\xC9\xD2\xA3\xFA\xCB\xD3\x58\x5A\x12\x40\x9B\x1D\xC1\xA7\x8C\xD4\xD4\x42\xE5\xD2\xD1\x91\xD9\xD0\xA0\x96\xD5\xD2\x55\xCB\xD6\xD4\xB0\xC8\xD4\xA7\x98\xD7\xD2\x48\xF3\xD6\xD6\x8D\xD4\xD5\xAB\xB5\xDC\xD4\x4D\xE1\x12\x40\xA2\x02\xD6\xAE\x9A\xD3\xD9\x55\xEE\xD1\xD5\xBC\xC7\xDB\xAD\xBD\xD6\xD9\x64\xCE\xDB\xD7\xD0\xC4\xD8\xAE\xA7\xD3\xD5\x58\xD5\xDA\xD6\xB9\xD3\xDA\xB5\xC5\xDF\xD5\x39\xA8\x12\x40\xA9\x02\xDA\xB6\xD8\xD4\xDA\x6E\xC8\xD9\xDA\xCD\xC8\xDD\xB7\xD7\xDC\xDC\x73\xCB\xDA\xD9\xD9\xCC\xDB\xBA\xEE\xD1\xDE\x78\xE5\xDB\xDC\xED\xD8\xDC\xBD\xF7\xD2\xDF\x73\xD2\xDD\xDF\xAB\x4F\x14\xA2\xE9\xD5\x74\x58\x3F\xB9\x16\x02\x52\x16\x80\x33\x12\x40\x5A\x02\x45\x16\x02\x56\x16\x80\x37\x12\x40\x5C\x02\x41\x17\x02\x5A\x16\x80\x3B\x13\xE1\x79\xFA\xDF\xE3\x08\x5C\x15\xC7\x8A\x2D\x17\x91\xEF\xDF\xD9", + "\xFF\xD6\xDF\xB6\xA0\xEA\xE4\x72\xEB\xE2\x60\xBE\x06\xE5\xA3\xBF\x12\x40\x60\x22\xD8\xE0\xF5\xC8\xE4\xC1\xBB\xEE\xE2\x9C\xFC\xDD\xE5\xF9\xDE\xE7\xCB\xC0\xEB\xDF\xA1\xFA\xE5\xE7\x44\xEC\xE7\xD1\xFE\xDC\xE6\xA6\xC8\xEB\xE9\x27\xEA\xDE\xD3\xD3\xE1\xEA\x83\x86\x1A\xE6\x3F\xF0\xE9\xCE\xD2\xE5\xEB\xA6\xDD\xEF\xE9\x5C\xFB\xE9\xCA\xDA\xE9\xEB\xB0\xE5\xEB\xEC\x66\xE6\xE9\xDA\xAE\xEC\xED\xA0\xC9\xEA\xE8\x6D\xED\x47\x31\x58\xEA\xEC\xB4\xF6\xEE\xEB\x62\xF8\xEF\xD9\xFA\xE5\xEE\xBE\xF1\xEA\xE9\x6B\xEE\xEC\xD9\xFD\xE0\xED\xBB\xC5\xF3\xCC\xC8\x02\x41\x32\x37\xEF\xED\xC6\xC3\xF7\xEF\x70\xE2\xF1\xE0\xC5\xE0\xF2\xC7\xD3\xF0\xF0\x86\xF4\xE9\xDE\x87\xFC\xF2\xCD\xFB\xED\xF3\x5F\xFE\xF0\xE1\xE1\x9F\x18\x01\x50\x1C\xF1\x8F\xF2\xF1\xE6\xA1\xFC\xF5\xCD\xE2\xF5\xF2\xA9\xF4\xF2\xEA\xFE\xE3\xF6\xD0\xEE\xF5\xF5\x9F\xEF\xF5\xED\xBA\xF2\xF7\xDE\xD8\xF0\x9B\xD6\x02\x43\x35\x28\xF7\xF3\xC8\xFE\xF6\xF8\xBF\xF6\xF5\xEE\xB8\xF3\xF4\xE6\xF0\xF5\xF8\x96\xEB\xF7\xED\xD3\xFB\xF8\xEA\xCD\xFE\xFA\xCF\xF2\xF9\xF5\xCD\x5D\x1A\x01\x5E\x1C\xF8\xDA\xF7\xFB", + "\xF6\xE2\xF4\xFD\xEC\xF4\xF7\xF8\xD1\xE7\xFD\xF2\xBC\xFB\xFC\xE7\xFB\xF6\xFD\xE8\xF1\xF5\xFB\xD8\xFF\xFC\xFA\xD8\x94\x1C\x02\x45\x1C\xF8\xEA\xF8\xF9\xFE\xE9\xFA\xF9\xE5\x75\x7F\xE3\x76\x7E\x00\x84\x80\xEC\x7E\x7F\xF2\x78\x80\xD0\x79\x80\xFF\x77\x80\x0D\x80\x7F\xF3\x73\x80\x02\x81\x80\xF1\x7B\x80\x16\x81\x7E\x06\x80\x81\x0A\x88\x81\x13\x89\x81\xF6\x71\x81\x14\x80\x82\x1E\x82\x81\x15\x8C\x81\x98\x4B\x0E\x74\x7D\x76\xEC\x02\x20\xED\x0B\x7F\x05\x8D\x81\x30\x85\x82\xFC\x7F\x80\x1F\x8B\x81\x33\x8C\x80\x38\x87\x81\x37\x8A\x83\x2F\x82\x83\x3D\x82\x82\x31\x80\x84\x3E\x81\x4E\xF3\x02\x20\xF4\x0E\x82\x0E\x89\x83\x26\x82\x84\x4C\x86\x83\x3F\x8E\x84\x49\x8C\x83\x51\x8B\x84\x50\x8A\x81\x34\x84\x82\x4D\x87\x85\x21\x85\x85\x35\x8A\x85\x23\x8B\x85\x11\x3A\x0F\x29\x84\x47\xFB\x0F\x5F\x21\x12\x5B\x1D\x4D\x0F\x02\x2E\x0F\x05\x22\x20\x00\x03\x13\xE1\x10\x87\x0A\x12\x00\x72\x89\x10\x03\x05\x87\x06\x14\x00\x78\x83\x10\x05\x0B\x87\x02\x16\x00\x7E\x81\x10\x07\x01\x88\x41\x8C\x85\x58\x82\x30\x08\x04\x88\x98\x49\x00\x8A\x89\x85\x4A\x8B", + "\x83\x54\x8E\x85\x85\x82\x89\x43\x8B\x15\x8D\x86\x88\x60\x8F\x88\x4F\x84\x89\xDD\x53\x12\x68\x89\x89\x52\x86\x85\x9A\x83\x85\x90\x85\x8A\x9B\x83\x8A\xA2\x81\x8A\x5D\x88\x8A\xAB\x8A\x8A\x87\x8E\x60\x0C\x04\x88\x0D\x03\x13\x12\x5D\x8A\x91\x8C\x8A\xAF\x88\x8B\xA0\x87\x8B\xAE\x8B\x8B\xA6\x84\x8A\xA7\x8D\x8B\x5F\x83\x8C\x93\x8A\x8B\xC4\x85\x89\xB6\x8F\x8B\xAB\x23\x01\x84\x86\x12\x11\x50\x8C\xD0\x89\x8A\xBC\x83\x8D\xCA\x89\x8C\xC1\x84\x8D\xD7\x85\x8D\xB9\x82\x8C\xC5\x8C\x8D\xC8\x8B\x8D\xD8\x81\x8D\xD6\x81\x4E\x1A\x04\x88\x1B\x04\x8B\xE2\x80\x8E\xDA\x8E\x8B\xD9\x8D\x8E\xE9\x8C\x8E\xEF\x87\x8C\x8E\x8E\x8D\xF3\x81\x8E\xD2\x8B\x8E\xF2\x88\x89\xF9\x8C\x89\xFA\x8D\x8D\xF6\x83\x8E\x9C\x61\x02\x97\x8C\x8F\x04\x96\x8C\xFE\x88\x8F\x07\x9E\x8E\xF7\x8A\x90\x00\x9D\x90\xEA\x8C\x90\x0F\x91\x8F\x30\x82\x02\x03\x96\x90\xDF\x80\x8F\x0B\x92\x91\x17\x9B\x8F\x16\x95\x8F\x08\x9B\x91\x09\x9A\x91\x1E\x90\x91\x18\x9E\x90\x25\x91\x91\x19\x99\x92\x8D\x63\x02\x15\x94\x8F\xFD\x80\x92\x30\x93\x92\x22\x9F\x92\x32\x9A\x92\x28\x96\x92\x1C\x9E\x92", + "\x05\x9A\x93\x1D\x94\x93\x3E\x92\x89\x24\x0D\x92\xFF\x87\x93\x44\x97\x92\x46\x99\x93\x43\x97\x94\x21\x96\x93\x4A\x91\x93\x3F\x9D\x93\x3B\x99\x94\x48\x9F\x91\x35\x98\x93\x43\x55\x02\x42\x94\x95\x4F\x9C\x93\x5C\x92\x95\x4B\x96\x95\x4E\x91\x95\x5A\x92\x96\x24\x93\x95\x65\x9F\x95\x36\x56\x02\x59\x97\x96\x61\x90\x95\x6E\x9D\x95\x63\x9F\x96\x5E\x9D\x96\x70\x9C\x96\x55\x95\x94\x66\x93\x93\x64\x9A\x97\x72\x91\x97\x75\x9C\x97\x7F\x93\x3B\x27\x0B\x96\x80\x93\x97\x77\x9D\x94\x87\x99\x97\x4C\x9A\x98\x60\x99\x98\x68\x98\x98\x5B\x96\x98\x02\x38\x02\x84\x89\x12\xCF\x8B\x98\x8F\x9C\x98\x78\x99\x99\x9C\x94\x97\x92\x9B\x97\x98\x9E\x99\x7E\x9F\x99\x7D\x96\x97\x91\x93\x9A\xA8\x96\x9A\xA0\x9D\x98\xA7\x9A\x9A\x28\x2C\x12\x9F\x8A\x99\x90\x9B\x9A\x9B\x92\x9A\xAE\x91\x98\xAC\x94\x9B\xB3\x95\x9A\x85\x99\x9A\xBD\x97\x9B\xA4\x90\x4C\x30\x04\x98\xA1\x99\x1D\x31\x04\x9C\xB1\x22\x03\x84\x83\x03\x84\x84\x03\x84\x8F\x12\xB1\x90\x00\x36\x04\x88\x37\x04\x88\x38\x04\x88\x39\x04\x88\x3A\x04\x88\x32\x11\x9D\x3C\x08\x9C\xB5\x9E\x98\x6B\x6D\x03\xE0", + "\x9A\x46\x3E\x05\x9E\xB2\x99\x9E\x9D\x92\x9E\xEC\x9D\x9A\x61\x6F\x03\xE8\x9B\x9E\xA9\x40\x04\x84\x85\x13\xD1\x96\x9B\xBF\x9A\x10\x42\x01\x9F\x98\x43\x04\xF1\x94\x04\xF1\x95\x04\xFC\x9D\x9E\xBA\x92\x54\x46\x04\x88\x47\x04\x88\x48\x04\x88\x37\x11\x9D\x4A\x04\x88\x4B\x01\x9F\x4C\x04\x88\x4D\x03\x13\x99\x18\x49\x39\x11\x9D\x50\x04\x88\x51\x04\x88\x3B\x11\x9D\x53\x03\xA0\x08\x24\x05\x84\x85\x05\x22\xA5\xA0\xF2\x98\xA2\x98\x46\x05\x84\x87\x05\x27\xAC\x9B\xB3\x3D\x13\xF7\x9F\x48\x59\x04\x88\x5A\x04\x88\x5B\x04\x88\x5C\x04\x88\x5D\x04\x88\x5E\x04\x88\x5F\x0F\xA2\xB8\x91\x9E\xEE\x95\x9C\x45\xA9\x9B\x30\xA8\xA4\x43\xAB\x9B\x4B\xAA\x9E\xF8\x96\xA4\x2A\xA4\xA0\x49\xAB\x99\x3F\x13\xA3\x47\xA4\xA4\x92\x81\x06\x42\xA1\x9C\x5C\xAE\x9B\x50\xA3\xA5\x4C\xAD\xA5\xC0\x9E\xA5\x4A\xA2\xA6\xF9\x9F\xA5\x4D\xA9\xA2\x28\x22\x06\x84\x83\x06\x5B\xA4\xA6\x9B\x91\x14\x56\xAE\x60\x65\x01\x9F\x66\x01\x9F\x67\x0F\xA6\x63\xAB\xA7\x99\x38\x06\x84\x85\x1A\xD1\x9A\x06\x84\x8B\x06\x84\x8C\x06\x84\x8D\x06\xF1\x9E\x06\x84\x8F\x06\x16\xA1\x4E\x71\x04", + "\x88\x45\x11\x9D\x73\x04\x88\x74\x04\x88\x75\x0A\xA7\x0A\x16\x07\x84\x87\x07\x98\xA8\xA6\x66\xAE\xA9\xD8\x48\x07\x84\x89\x07\x9D\xA5\xA6\x9B\x3A\x07\xA5\xAD\x2C\x7B\x04\x88\x7C\x04\x88\x7D\x04\x88\x7E\x04\x88\x7F\x04\x88\x80\x04\x88\x81\x09\xAA\x02\x12\x08\xB8\xAE\xA4\x52\xA9\xA6\x4F\xA6\xAA\x7C\xA0\xAA\xC1\xA0\xAC\x67\xA4\xAC\xC2\xA5\xAC\x58\xA0\xA6\xBC\xA7\xA5\x61\xA0\xA7\xCD\xA3\xAC\xC9\xAE\xAB\xBD\xAF\xA9\xC6\xA5\xAD\xD1\xA4\xAD\xD7\xAE\xAC\xCB\xA8\xA2\x83\x0B\xAB\x6A\xA2\xAD\xCC\xAB\xAD\xCA\xAF\xAD\xD8\xAF\xAC\xC8\xA6\xAE\xC7\xA9\xAE\xD6\xA8\xAE\xEB\xA2\xAE\xE0\xA1\xA5\xA9\x44\x08\x84\x85\x08\xDE\xAF\xAB\x12\x86\x08\xF5\xA9\x2F\x47\x13\xA7\x28\x28\x08\xF1\x99\x08\xF9\xA1\xAE\xE4\xA8\x4D\x8A\x04\x88\x8B\x04\x88\x8C\x04\x88\x8D\x04\x88\x8E\x04\x88\x8F\x01\x9F\x90\x04\x88\x91\x0D\xA8\x02\x59\x14\xD1\x94\x09\x84\x85\x09\x84\x86\x09\x84\x87\x09\xDE\xAB\x14\xD1\x99\x09\x01\xB0\xAF\x24\xB3\xAE\x2D\x2A\x09\x84\x8B\x09\x23\xB6\xB2\xD9\x1C\x09\x2B\xB8\x24\x9D\x04\x88\x9E\x04\x88\x9F\x04\x88\xA0\x04\x88\xA1\x04\x88", + "\xA2\x04\x88\xA3\x0E\xAD\xA4\x0F\xB2\xE5\xAE\xAE\x41\xB3\xB0\xD0\xAC\xAE\xD9\xA5\xB4\x42\xBA\xAD\x44\xB7\xAE\x49\xB8\xB4\x4B\xBA\xAE\x47\xBC\xB4\x9C\x95\x0A\x40\xBA\xB4\xF6\xA6\xB4\x58\xBD\xB4\x52\xB7\xB5\x5A\xB0\xB5\x59\xBF\xB4\xED\xA0\xB6\x51\xBE\xB5\x5D\xB1\xB6\x5C\xB2\xB6\x5F\xB7\xB6\x20\x9D\x14\xFC\xA9\xA6\xA7\x05\xB5\x4E\xBA\xB6\xD3\xA6\xB5\x73\xB3\x2A\xA8\x00\xB7\x0A\x1F\x14\x6D\xBC\x81\xAA\x08\xB7\x64\xB8\xB6\x65\xB3\xB6\x66\xB5\xB7\x5B\xB4\xB8\x7F\xB2\xB7\x02\xB8\xB8\x25\xBF\xAE\x2C\xB9\xB8\x86\xB3\xB8\x8E\xB1\xB9\x8B\xB3\xB4\x8A\xBD\xB8\x93\xB4\xB7\x92\xB6\xB9\x9A\xBC\xB8\x9C\xBC\x81\xAB\x0E\xB7\x8D\x6C\x0A\xA0\xB2\xB8\xA4\xB9\xB6\x8F\xB5\xBA\x81\xB6\xBA\x99\xBD\xB9\x98\xB7\xB9\x71\xB7\xBA\xAA\xBE\xBA\x85\xBB\xBA\x94\xB0\x84\xAD\x03\xBA\xB1\xBB\xB9\xB5\xB4\xBB\xAD\xBA\xBB\xBD\xBC\xBA\xAF\xBC\xBB\xC1\xB2\xBB\x87\xB0\xBB\xA9\xB7\xBC\x00\x0E\x0A\xF1\x9F\x0A\xB8\xB8\xBC\x95\xB0\xBC\xB3\xB4\xBC\x90\xB2\xBD\xA8\xB0\xB8\xD6\xBF\xBC\xBB\xB4\xBD\xB9\xB0\xBD\xC5\xB2\xBC\xD1\xBE\xBB\xC3\xB0\xBE\xDF\xBC\xBD\xD3", + "\xB2\xBE\xDD\xB1\x31\xB0\x0D\xBC\xD7\xB6\xBC\xEB\xBE\xBD\x09\x11\x0B\xEA\xB8\xBD\xBF\xB9\xBD\xE6\xB5\xBE\xE4\xB5\xBD\xF2\xB1\xBE\xF7\xBB\xBD\x5E\x92\x0B\xF1\xBC\xBE\xF9\xB3\xBE\xF4\xBB\xBF\xCE\xB0\xC0\x06\xCE\xBE\xF6\xB3\xC0\x0A\xC3\xBF\x0C\xCA\xBF\x0B\xCE\xC0\x0D\xC2\xB5\xB3\x0F\xBF\x08\xC8\xBF\x07\xCA\xBD\x05\xC5\xC1\xFC\xB1\xC1\xE7\xB5\xBF\x16\xC1\x64\x51\x11\x9D\xB5\x04\xC1\x18\xC3\x54\xB6\x04\xC2\x28\x27\x0B\xF1\x98\x0B\xF1\x99\x0B\x28\xC4\xC0\xD6\xBA\x0B\x84\x8B\x0B\x84\x8C\x0B\x84\x8D\x0B\x84\x8E\x0B\x84\x8F\x0B\xF1\x90\x0C\x84\x81\x0C\x14\xBA\x50\xC3\x04\x88\xC4\x04\x88\xC5\x04\x88\xC6\x04\x88\xC7\x0E\xAD\x53\x11\x9D\xC9\x0F\xC2\x0F\xC2\xC0\x08\x9A\x0C\x84\x8B\x0C\x50\xCA\xB4\xCC\x0A\xBE\xCD\x04\x88\xCE\x04\x88\xCF\x04\x88\xD0\x04\x88\xD1\x04\x88\xD2\x04\x88\xD3\x0E\xAD\xD4\x07\xC5\x10\xCB\xC6\x52\xCC\xC6\x1D\xC0\xC3\x01\xCF\xC6\x51\xC2\xC7\x1C\xC9\xC0\x75\xCF\xC1\x25\xC1\xC7\x76\xCE\xC6\xBF\x35\x0D\x6A\xCD\xC6\x80\xC4\xC7\x7C\xC8\xC7\x1E\xCB\xC1\x83\xC6\xC8\x81\xCB\xC7\x89\xC4\xC8\x70\xC9\x1D\xD6\x0F", + "\xC7\x82\xCB\xC8\x88\xC1\xC9\x94\xCA\xC8\x95\xCC\xC8\x73\xC6\xC9\x9A\xC8\xC9\x77\xC2\x2D\xD7\x00\xC9\x8D\x68\x0D\xDE\xA9\x0D\x84\x8A\x0D\x84\x8B\x0D\x84\x8C\x0D\x84\x8D\x0D\x84\x8E\x0D\x84\x8F\x0D\x84\x80\x0E\x84\x81\x0E\x84\x82\x0E\x84\x83\x0E\xA0\xCC\xC9\x67\x94\x0E\xEA\xB5\x0E\xB9\xC3\xC9\x9B\xC0\xCC\xBA\xC2\xC9\x01\x16\x0E\xBF\xCA\x9E\xE7\x04\x88\xE8\x07\xCC\xED\xB0\x4A\xE9\x0C\xCC\xEA\x01\x9F\xEB\x01\x9F\xEC\x0C\xCC\x7A\xCB\x99\xED\x04\x88\xEE\x04\x88\xEF\x04\x88\x55\x11\x9D\xF1\x04\x88\xF2\x01\x9F\xF3\x04\x88\xF4\x01\xC4\x36\x56\x0F\x84\x87\x0F\x84\x88\x0F\x84\x87\x15\xD1\x9A\x0F\xDE\xAB\x0F\x84\x8C\x0F\xD6\xC7\xC1\x85\xCD\x76\xFD\x04\x88\xFE\x07\xCF\x2F\x9A\xBE\x00\x0C\x16\xE1\x12\xD0\x73\x84\xD0\x76\x86\xD0\x79\x88\xD0\x7C\x8A\xD0\x7F\x8C\xD0\x73\x47\x00\x0E\xDD\xCC\xF9\xC2\xD1\x8D\xCA\xC1\x19\xC9\xC7\xF8\xC5\xD1\x18\xD6\xD1\x14\xD9\xC9\xC3\xC7\xC9\xC2\xC1\xD2\x17\xD6\x90\x08\x01\xD1\xD7\xC2\xD2\x1D\xDD\xC9\x23\xDA\xD1\x13\xD7\xD2\x2B\xDE\xD1\x28\xDE\xD2\x29\xD7\xC8\x2F\xDA\xD2\x33\xD4\xCC\x37\xD0\xD2", + "\x35\xD4\xD3\x39\xD1\x2B\x09\x06\xD2\x19\xD0\xD3\x3B\xD8\xD3\x32\xD5\xD4\xF9\x2C\x15\x7B\xB6\xD3\x46\xDC\xD1\x4B\xDB\xD1\x4E\xDD\xD2\x41\xDA\xD4\x51\xDE\xB4\x0B\x00\xD4\x4C\xD3\xD5\x44\xD8\xD5\x3A\xDD\xD3\x1F\xD1\xCC\x43\xDB\xD5\x4D\xD0\xD5\x57\xD3\xD6\x4F\xDC\xD2\x81\x7C\x00\x56\xDE\x60\x0D\x09\xD6\x28\x2E\x00\x6C\xD8\x24\x0F\x0F\xD6\x42\xDC\xD5\x3F\x50\x01\x11\xD1\x01\x11\xD2\x01\x11\xDF\x15\xD1\x94\x01\x72\xD9\x27\x15\x01\xD1\x16\x0C\x16\x17\xAD\x5D\x18\x01\xD1\x19\x01\xD1\x62\x11\x9D\x1B\x0F\xD7\xA3\x2C\x01\x11\xDD\x01\x8E\xD9\xD5\x64\xD3\xAE\x1E\x01\xD1\x1F\x03\xD9\x60\xD9\x1D\x66\x19\xD4\xC3\x31\x02\x11\xD2\x02\x11\xD3\x02\x11\xDB\x16\xD1\x95\x02\x11\xD6\x02\x11\xD7\x02\x9A\xDE\xD5\x74\xDF\xD5\xAE\xD1\xD6\x66\xD3\xD7\xB2\xD4\xDB\x5A\xD1\xDB\xB7\xDD\xD5\xBA\xD1\xD3\xB9\xDC\xDB\x95\xD3\xDB\x52\xDF\xDB\xB6\xD2\xDC\xC1\xD5\xD6\xC3\xD6\xDC\x36\xD8\x02\xAD\xDB\x99\x29\x01\xD1\x2A\x0C\x16\x31\x2B\xD9\xC4\xDC\xD3\xB5\xD5\xDC\x62\xD8\xDC\xD4\xDD\xDB\xB0\xDB\xDB\xDB\xDE\xDB\xD8\xDA\x44\x11\xD9\x03\xCB\xDE\xDD\xA9", + "\x7A\x03\xE3\xD2\x54\x3B\x07\xDE\x6D\x1A\xDE\x3D\x0A\xDE\xD5\xDC\xD3\x3E\x01\xD1\x3F\x01\xD1\x40\x01\xD1\x41\x01\xD1\x42\x01\xD1\x43\x0A\xDE\x44\x01\xD1\x70\x19\x10\x85\xD9\x4A\x47\x01\xD1\x48\x01\xD1\x49\x01\xD1\x4A\x01\xD1\x4B\x0E\xDE\xD9\x1C\x04\x11\xDD\x04\x0C\xE3\xDD\x94\xD2\x89\x72\x11\x9D\x4F\x01\xE1\xDF\xD9\x10\x50\x08\xE1\x3E\x31\x05\x11\xD2\x05\x11\xD3\x05\x11\xD4\x05\x11\xD5\x05\x11\xD6\x05\x11\xD7\x05\x1C\xE8\x24\x58\x01\xD1\x59\x00\xDD\x13\xE7\xDD\x32\xE0\xDC\xD9\xD2\xE1\xD2\xD9\xE1\xB8\xD6\xE3\x39\xE8\xE3\xDC\xDF\xDA\x3E\xEF\xDE\x12\x99\x17\x9E\xD1\xE3\x34\xE4\xE4\xC7\xD3\xE3\x47\xE5\xE4\x37\xE8\xE4\xD6\xDA\xE4\xBF\x38\x06\x11\xD9\x06\x2B\xE9\xE4\x1C\x8A\x06\x53\xE8\x4D\x6B\x0A\xDE\x6C\x0A\xDE\x6D\x07\xE5\x35\xE5\xC2\x6E\x01\xD1\x6F\x01\xD1\x70\x01\xD1\x71\x01\xD1\x72\x01\xD1\x73\x0A\xDE\x7B\x11\x9D\x75\x04\xD8\xE1\x47\x07\x11\xDE\x17\xD1\x99\x07\x11\xDA\x07\x11\xDB\x07\x5E\xEA\x10\x7C\x01\xD1\x7D\x0B\xE7\x4B\xEE\xE4\x12\x8E\x07\x11\xDF\x07\x80\xEE\xDA\x80\x07\xE8\xCD\x21\x08\x11\xD2\x08\x11\xD3", + "\x08\x11\xD4\x08\x11\xD5\x08\x11\xD6\x08\x11\xD7\x08\x8A\xEF\x53\x88\x01\xD1\x89\x09\xE9\xDD\xDD\x76\x8A\x0E\xE9\x74\x4B\x08\xEA\xDC\x08\xEA\xDD\x08\xA2\xE0\xE4\x7F\xBE\x08\x11\xDF\x08\x11\xD0\x09\x11\xD1\x09\x11\xD2\x09\x11\xD3\x09\xEA\xD1\x18\xD1\x95\x09\x70\xE2\x50\x84\x11\x9D\x98\x01\xD1\x99\x01\xD1\x9A\x01\xD1\x9B\x02\xEA\x9C\x01\xD1\x9D\x09\xEA\xDA\xDF\xE3\xF8\x66\x18\xD1\x9F\x09\xCA\xEC\xD1\xA0\x01\xED\x18\x21\x0A\x11\xD2\x0A\x11\xD3\x0A\x11\xD4\x0A\x11\xD5\x0A\x11\xD6\x0A\x11\xD7\x0A\xA2\xE8\x18\xD1\x99\x0A\x30\xE1\xE8\x54\xED\xE4\xE9\xEF\xE5\x4C\xEC\xEE\x82\xE4\xDE\xEF\xEF\xE9\xCC\xEA\xE3\x3D\xEA\xEA\x3B\xED\xEE\x9D\x27\x0B\xD4\xE8\xEF\xE8\xEA\xEE\xFE\xEE\xEE\xEB\xE6\xE4\xFF\xE2\xF0\x00\xF3\xF0\xFD\xEB\x6E\xB8\x0B\xEF\xF1\xE3\xEF\x3C\xE0\xEF\x01\xF7\xF0\x04\xF1\xF1\x10\xF3\xF1\xF7\xEB\xF0\xF6\xEB\x99\xB9\x0A\xF0\x0F\xF5\xF1\x1B\xF5\xEF\xCB\xE7\xF1\x0E\xF6\xF0\x1C\xF2\xF2\x36\x5A\x0B\x11\xDB\x0B\x1A\xF4\xF2\x3F\x5C\x0B\x29\xF3\x2A\x8C\x13\xE4\x09\x1E\x0B\xEA\xDF\x0B\x2D\xF2\xF1\x56\x90\x0C\x11\xD1\x0C", + "\x11\xD2\x0C\x11\xD3\x0C\x11\xD0\x19\xD1\x95\x0C\xEA\xD6\x0C\x11\xD7\x0C\xBB\xEA\x50\xC9\x01\xD1\xCA\x01\xD1\xCB\x01\xD1\xCC\x01\xD1\xCD\x02\xEA\xCE\x01\xD1\xCF\x05\xF3\x14\xFE\xF1\x41\x60\x0D\x11\xD1\x0D\x56\xF1\xB6\xD2\x0D\xF5\x03\x13\x0D\x11\xD4\x0D\x11\xD5\x0D\x11\xD6\x0D\x11\xD7\x0D\x11\xD8\x0D\x11\xD9\x0D\x60\xFA\x46\xDA\x01\xD1\xDB\x0F\xF6\xF2\xE8\x49\xDC\x04\xF7\xD6\x2D\x0D\xEA\xDE\x0D\xEA\xD2\x19\x30\xF3\xF2\x3C\xD0\x0E\x11\xD1\x0E\x11\xD2\x0E\x11\xD3\x0E\x11\xD4\x0E\x11\xD5\x0E\xEA\xD6\x0E\x11\xD7\x0E\x47\xF6\x53\x94\x11\x9D\xEA\x01\xD1\xEB\x01\xD1\xEC\x01\xD1\xED\x02\xEA\xEE\x01\xD1\xEF\x08\xF7\x20\xF5\xF7\xDD\x50\x0F\x11\xD1\x0F\xA0\xFE\x98\xF2\x08\xF7\xF3\x01\xD1\xF4\x01\xD1\xF5\x01\xD1\xF6\x01\xD1\xF7\x01\xD1\x96\x11\x9D\xF9\x02\xEA\xFA\x01\xD1\xFB\x07\xEE\x80\xF6\xF3\x58\xFD\xF0\xA2\xF4\xEF\x21\xF5\xF0\xC4\xFE\xFB\xC3\xF6\xFC\xC1\xF0\xFC\x0C\xFC\xEF\x8D\x69\x00\xE9\x10\x1E\xC8\xFB\xFC\x16\xFF\xF1\xD4\xF2\xFC\xC9\xFC\xFC\xBF\xF8\xFD\xC7\xF7\xF5\xD6\x6A\x00\xCF\xFF\x86\xD1\xF1\xFA\xD2\xFD\xF1\xDB", + "\xFD\xFB\xDC\xF7\xFD\xD3\xF6\xFD\xE3\xFA\xF2\xE8\xF4\xFE\x00\x2F\xFD\x16\x4A\xFE\xE2\xF3\xFF\xD5\xFA\xFC\xF4\xF2\xFF\xF5\xFA\xFD\xC8\xBC\x00\xF0\xFA\x10\x0D\x0F\xFD\xD1\x6E\xFC\x42\x81\xEC\x79\xFE\x76\x7D\xFE\x65\x80\xFA\x7B\xFD\x45\x7F\xF3\x7A\x00\xE1\x7F\x01\x8E\x7F\x0D\x84\x01\xB7\x7E\x03\x88\xFF\x15\x80\x05\x97\x80\x09\x82\xFC\x5B\x01\xFE\x72\x01\x8F\x80\xFB\x74\x23\x1C\x04\x03\x83\x81\xF2\x74\x00\x9A\x35\x07\x02\x81\x25\x87\x03\x93\x81\x0C\x8E\x01\x8B\x83\x08\x8D\x7F\x2A\x85\x05\x8E\x80\x0B\x8C\x02\xB4\x80\x02\x97\x81\x10\x83\x05\xB8\x81\x3C\x1E\x01\x28\x80\x09\x9F\x81\x30\x83\x78\x1F\x00\x1F\x81\x04\xB3\x80\x06\x80\x26\x20\x04\x08\x91\x81\x17\x8B\x04\xA9\x82\x0B\x8E\x82\x46\x87\x95\x21\x00\x25\x82\x02\x4A\x82\x0E\x9C\x40\x23\x06\x0A\x9D\x2E\x12\x0A\x05\x88\x11\x09\x1D\x82\x18\x16\x04\x20\x83\x1A\x8A\xFC\x27\x02\x12\x88\x01\x4A\x81\x05\x0A\x82\x15\x0A\x04\xAB\x02\x12\x8C\x01\x63\x80\x49\x2D\x00\x25\x8E\x02\x5F\x7D\x80\x60\x25\x30\x02\x09\xB1\x00\x25\x82\x03\x4A\x83\x0C\x0A\x82\x34\x01\x0E\xA5\x1D\x1A\x0A", + "\x04\xB6\x02\x20\x91\x81\x36\x86\x2B\x77\x00\x25\x88\x03\x07\x87\x13\x82\x08\x39\x06\x11\x99\x1C\x1D\x0A\x04\xBB\x02\x12\x9C\x01\x4A\x85\x07\x0A\x82\x1F\x0A\x04\xBF\x02\x12\x80\x02\x92\x83\x55\x01\x02\x25\x82\x04\x00\x81\x14\x9B\x81\x8F\x85\x08\x9D\x81\x44\x88\x08\xC7\x81\x0E\x92\x81\xAB\x86\x15\xAD\x84\x32\x84\x0B\xE9\x50\x14\x01\x85\x4C\x87\x0A\xB3\x84\x54\x87\x0A\xAF\x84\x2B\x89\x85\x4D\x80\x08\x81\x86\x55\x8D\x68\x51\x00\x2E\x90\x82\xB1\x85\x16\xBE\x84\x59\x80\x0C\xBA\x85\x33\x90\x85\x56\x4A\x0A\x0A\x83\x29\x07\x0C\xC2\x87\x9A\x34\x02\xD5\x82\xA8\x15\x03\x6C\x80\x00\x56\x00\x37\x97\x02\x4A\x80\x0B\x1C\x86\x67\x82\x91\x59\x02\x12\x9A\x02\x4A\x83\x0B\x0A\x82\x2E\x0A\x04\xDD\x02\x12\x9E\x02\xDC\x87\x0B\x0A\x82\x30\x06\x07\xE1\x26\x18\x0A\x82\x63\x02\x09\xA4\x02\x25\x85\x06\x4A\x82\x19\x03\x87\xD9\x0F\x0C\x0A\x82\x34\x00\x10\xBF\x85\x2F\x83\x33\x69\x02\x09\xAA\x03\x82\x8A\xFC\x6B\x00\x43\x9E\x19\x6C\x02\x09\xAD\x02\x25\x8E\x06\x4A\x83\x1B\x0A\x82\x70\x02\x09\xB1\x02\x25\x82\x07\x0F\x8A\x94\x33\x03\x4A\x84\x0E", + "\x1E\x89\x65\x8E\x64\x75\x03\x48\x98\x26\x76\x04\x1B\xB7\x02\x6E\x88\x07\x27\x8B\x33\x82\x58\x79\x02\x09\xBA\x02\x25\x8B\x07\x4A\x80\x1F\x0A\x82\x7D\x02\x09\xBE\x02\x6E\x8F\x07\x4A\x80\x20\x15\x87\x02\x2A\x10\x0A\x83\x41\x0A\x04\x84\x06\x12\x85\x04\x4A\x86\x10\x2E\x88\x85\x07\x08\x4A\x80\x22\x0B\x8A\xC9\x84\x17\x82\x29\x44\x0A\x04\x8A\x04\x54\x8E\x6D\x8B\x07\x2A\x8D\x16\x46\x0A\x04\x8D\x06\x12\x8E\x04\x4A\x87\x11\x0A\x82\x48\x0A\x04\x91\x06\x12\x92\x04\x5A\x8A\x20\x13\x04\x25\x84\x09\x26\x85\x54\x84\x89\x52\x89\x17\x90\x86\x64\x82\x17\x86\x8B\x5B\x9B\x85\x70\x89\x2F\xB8\x8B\xBD\x8E\xB4\x22\x05\x5A\x8D\x3B\xA3\x07\x2F\x83\x87\xC1\x84\x0E\xF7\x8B\x4B\x8C\x86\x07\x8F\x30\x8A\x86\xBE\x89\x18\xD2\x58\x29\x02\x8C\xA5\x02\x30\xA6\x04\xC1\x85\x18\xCC\x83\x29\x00\x8A\x8D\x31\x15\x14\x8C\x20\x4A\x0A\x1B\x8C\x82\x0B\x05\x9E\x88\x31\x89\x08\x56\x0A\x04\xAD\x06\x12\x8E\x05\x4A\x87\x15\x0A\x82\x58\x08\x19\x83\x0A\x2C\x0A\x82\xB3\x07\xFB\x5F\x7E\x00\x06\x0B\x2D\x8E\xB4\x18\x05\xA1\x8B\xA2\x79\x05\xDC\x81\x17\xF4\x8A\x6F\x9F", + "\x5A\xBA\x02\x30\xBB\x04\xC1\x8C\x0B\x3C\x8E\x5E\x80\x86\xBD\x06\x36\xAD\x3B\x5F\x06\x1C\x88\x48\x30\x0D\x8E\xA8\x09\x18\x10\x8F\xE8\x72\x0C\x4A\x83\x30\x0A\x82\xC4\x02\x09\x85\x06\x25\x86\x0C\x4A\x8C\x00\x08\x06\x4A\x81\x19\x32\x8C\x85\x0C\x0C\x5E\x8D\x8B\x0E\x06\xD3\x8F\x6F\x4F\x07\xF4\x81\xB6\x50\x06\x12\x91\x06\x6E\x8D\x2E\xA2\x8C\xF9\x8B\x18\x8A\x8D\x6F\x96\x86\x73\x88\x3F\xB6\x8A\xFA\x87\x1F\xD5\x17\x37\x0A\x82\xE0\x01\x3E\xBF\x8C\x62\x83\x20\x84\x8D\x7E\x84\x90\xFA\x8B\x3E\x85\x91\xCA\x8B\x20\x87\x90\x67\x4E\x07\x4A\x87\x1D\x2C\x8F\x06\x92\x30\x70\x07\x84\x92\x16\xF1\x04\x1B\xB2\x06\x6E\x83\x0F\x17\x90\x82\x8A\x4F\xF4\x02\x09\xB5\x06\x25\x86\x0F\x4A\x83\x3D\x0A\x82\xF8\x02\x09\xB9\x06\x6E\x8A\x0F\x4A\x83\x3E\x06\x8F\x8F\x25\x1F\x0A\x82\x7F\x06\x05\xCA\x80\x00\x0C\x0F\x06\x09\x3C\x38\x90\xF5\x09\x39\x02\x03\x8E\x82\x08\xE8\x0F\x47\x90\x7E\xC3\x8D\x18\x9C\x34\x01\x02\x92\xE0\x79\x21\x05\x00\x24\x91\xFF\x0A\x93\x1F\x4C\x92\xE1\x27\x00\x10\x93\x84\x08\x00\x53\x92\x41\x09\x00\x56\x93\x20\x0A\x01\x2C\x92\x10", + "\x0B\x00\x97\x81\x08\x0C\x07\x4B\xA9\x10\x31\x92\x7B\x0E\x02\x98\x8F\x00\x64\x96\x41\xAB\x32\x08\x09\x26\xC1\x31\x04\x0D\x93\x18\x12\x02\x30\x92\x14\x13\x01\x73\x91\x7F\x9E\x71\x14\x02\x4C\x95\x00\x31\x96\x01\x62\x93\x05\x02\x93\x18\x02\x4C\x99\x00\x3B\x9D\x25\x1A\x02\x98\x9B\x00\x48\x97\x0E\xAF\x25\x0E\x02\x26\x9E\x02\x98\x9F\x00\x62\x90\x04\x22\x93\x10\x04\x28\x9B\x1E\x08\x02\x93\x23\x05\x52\xB6\x8F\xE3\x81\x66\x24\x02\x98\x85\x01\x9A\x91\xFA\x66\x01\x50\x92\x98\x62\x90\x0A\x02\x93\x29\x02\x4C\xAA\x00\x31\x9B\x02\x62\x90\x0B\x02\x93\x2D\x04\x54\xB1\x14\x17\x02\x26\xAF\x00\x92\x81\x80\x14\x96\x49\x9F\x90\x03\x9B\x1F\xB9\x95\x7D\x85\x92\xFC\x8C\x53\x84\x93\x61\x96\x10\x3D\x02\x98\x9E\x01\xB7\x90\x58\xBE\x95\x3B\x9C\x20\x89\x93\xAF\x84\x96\xCB\x92\x58\x81\x96\xC6\x80\x2D\xCE\x94\xB3\x98\x37\x4C\x02\x56\x9D\x21\x26\x0A\x2D\xD6\x96\xB4\x91\x96\xD4\x93\x5A\x9B\x95\x70\x90\x2E\xE3\x96\xB9\x8A\x96\xD2\x16\x09\x1D\x97\x5D\x9D\x2C\xEC\x96\x9A\x8F\x97\xBD\x96\x5B\xA4\x96\x79\x90\x0C\xCF\x02\x98\x90\x02\xEB\x94\x57\x8E", + "\x31\x28\x09\x2F\x98\x26\x14\x19\x97\x53\x01\x5F\x94\x03\x7E\x90\x2F\xA8\x51\x15\x02\x93\x56\x02\x4C\x97\x02\x31\x98\x05\x62\x91\x16\x02\x93\x5A\x01\x5F\x9B\x02\x31\x9C\x05\x09\x95\x38\x3E\x02\x62\x97\x0B\x22\x92\x30\x02\x26\xE1\x02\x98\x82\x03\x04\x98\x41\x23\x02\x31\x94\x06\x21\x9A\xAE\x9A\x97\x4E\x35\x0C\x22\x92\x33\x06\x32\x89\x83\x19\x0D\x99\x56\x18\x0D\x22\x93\x34\x02\x26\xEA\x02\x98\x8B\x03\x62\x94\x0D\x22\x93\x36\x02\x26\xEE\x00\xCC\x9F\x96\xF4\x92\xF7\x2F\x03\x9F\x9B\x39\x70\x00\xD1\x87\x97\xD5\x96\x5D\xB1\x96\xA5\x97\x32\xED\x94\xCA\x8B\x78\x71\x02\x4C\xB2\x03\x64\x99\x34\xCF\x98\xD0\x8C\x9A\xCF\x92\x5C\xA8\x96\xAC\x97\x2D\xCB\x9A\xD5\x9F\x80\x80\x02\x4C\x81\x04\xAA\x9A\x35\xD5\x9A\xD3\x87\x9B\x05\x99\x6B\xA5\x97\xAD\x9F\x35\xC8\x99\xD9\x8E\x6D\x8F\x02\x4C\x90\x05\xA3\x9C\x36\xFC\x15\x24\x14\x9B\xB3\x1A\x12\x39\x97\x49\x09\x2F\x94\x04\xDE\x8F\x9B\x9B\x4D\x12\x22\x92\x4B\x02\x26\x97\x06\x98\x98\x04\x62\x91\x13\x22\x92\x4D\x09\x2F\x9B\x06\x98\x9C\x04\x16\x9A\xA0\x1E\x04\x31\x9F\x09\x62\x90\x28\x02\x93", + "\xA1\x02\x4C\xA2\x05\xBF\x93\x10\x23\x06\x98\x84\x05\x9C\x99\x68\xA6\x9B\x7C\x15\x0A\x62\x92\x29\x01\x9D\xF2\x77\x14\x28\x9C\x6B\x18\x0A\x62\x91\x2A\x02\x93\xAA\x02\x4C\xAB\x04\x31\x9C\x0A\x62\x91\x2B\x02\x93\xAE\x03\x75\xAF\x04\x31\x90\x0B\x64\x9B\xDA\x83\x9D\x5E\x98\x6D\x81\x9F\xB4\x9D\x35\xCD\x98\xF1\x97\x9A\x6D\x9D\x6E\x87\x9F\x79\x9D\x76\x3E\x07\xEA\x82\x9E\xC6\x9B\x78\x92\x9F\xE8\x94\x3D\xEA\x9A\xE8\x80\x9C\xD7\x9F\x77\x8A\x29\x5F\x0F\x3C\xCB\x9E\xDB\x9A\x9E\xE0\x99\x7B\xA2\x9E\xAE\x98\x3C\xD0\x9E\xF5\x84\x46\xC0\x05\x7B\xBD\x47\x60\x0B\x3A\xC2\x06\x98\x83\x06\x62\x94\x18\x22\x93\x62\x02\x26\xC6\x06\x98\x87\x06\x62\x90\x19\x22\x93\x64\x02\x26\xCA\x06\x98\x8B\x06\x62\x94\x19\x2A\x9F\xEA\x9C\x8D\x4D\x07\x00\xA8\x11\xCE\x07\x80\x85\x9F\xF3\x99\x3C\xC0\x9D\xC4\x0F\x06\x0A\xA4\x03\x50\x06\x31\x91\x0D\x3E\x9F\xF8\x8D\xA0\xD8\x9C\x7C\x8C\x9E\x0C\xA1\x3E\x9A\xA3\xF7\x97\xA0\xE6\x9B\x81\xA2\xA1\xF2\x98\x6F\x5F\x05\x04\xBB\xA0\x21\xA4\x84\x93\x9E\x06\xA9\x42\xA8\xA2\xF7\x8A\x9E\x2B\xA3\x84\x9B\x1C\x70\x07\x42\x9F", + "\xA2\x07\xB0\xA1\x04\xA2\x85\xB9\xA0\x17\xA1\x43\xF3\x69\x38\x02\x93\xE2\x05\x86\xB8\xA0\x14\x13\x0E\x42\xA3\xAA\x04\x07\xF9\x95\x1C\x22\x92\x73\x02\x26\xE7\x06\x11\xB9\xA0\x30\x40\x1D\x22\x93\x74\x02\x26\xEA\x06\x98\x8B\x07\x62\x94\x1D\x22\x93\x76\x09\x2F\xEE\x06\x98\x8F\x07\x91\x9A\xA1\x31\x06\x31\x92\x0F\x62\x93\x3C\x02\x93\xF4\x02\x4C\xB5\x07\xD5\x96\x0F\x62\x93\x3D\x0F\xA2\x1D\xA4\x83\x92\x16\x7C\x02\x26\xF9\x04\x1C\xBF\x5A\xFA\x07\x8E\x81\x09\x7D\x02\x26\xFC\x06\x98\x9D\x07\x62\x96\x1F\x24\x92\x31\x90\x00\x6F\x0D\x8E\x8D\x0F\x86\xA4\x47\xAE\x3E\x01\x09\x48\xC0\x92\x42\x03\x00\x8D\xA3\x48\x90\xA3\x35\x34\x00\x11\xA5\x92\x8D\x34\x05\x06\x92\x8D\x92\x14\x16\x00\x1A\xA6\x42\x07\x00\x9E\xA4\x4A\xA1\xA5\x49\xAC\xBE\x09\x03\x28\xBA\x92\xA7\xA5\x4B\xA9\xA4\x30\x9B\x4A\xA9\x11\x2B\xAE\x00\xAD\xA5\x45\x0F\x01\x56\xA0\x01\x16\xA6\xA2\x80\x26\x12\x05\x95\x93\x01\x56\xA4\x01\x2D\xA5\x05\x0D\xA5\x16\x01\x96\xB9\x17\x0B\x0D\x4A\x98\x02\x30\xBD\xA1\x3C\xA6\xC1\x19\x01\x56\xAA\x01\x47\xA7\xC9\x9B\x00\xCE\xA7\x95\x1C\x01", + "\x56\xAD\x01\x2D\xA6\x07\x0D\xA5\x1F\x05\x95\xA0\x01\x56\xA1\x02\x2D\xA6\x08\x11\xA6\x81\x3B\x04\x2D\xA4\x12\x00\x4E\xBA\xA2\x93\x25\x01\xE5\xA3\xCC\x26\x01\x74\xA8\x1A\x27\x00\x3B\xAA\x08\x28\x07\x9D\x8E\xA1\x71\x59\x02\x2D\xA6\x0A\x0D\xA5\x2B\x05\x95\xAC\x01\x56\xAD\x02\x2D\xA6\x0B\x12\xA7\x06\x0F\x05\x2D\xA4\x18\x06\x4B\xE1\x26\x0C\x0D\xA5\x33\x05\x95\xB4\x01\x56\xA5\x03\x2D\xA6\x0D\x00\xA8\xCD\x17\x06\x2D\xA4\x1C\x00\x51\xA0\xA3\x0B\xB3\x1D\x39\x05\x95\xBA\x01\x8A\xAB\x2B\xBB\x00\x47\xB4\x23\x3C\x05\x95\xBD\x01\x56\xAE\x03\x2D\xA7\x0F\x0D\xA5\x40\x05\x95\x81\x03\x56\xA2\x04\x1F\xA9\x0B\xB6\xA1\xD6\x13\x08\x05\xA9\x79\xA2\x43\xB0\xAB\x4B\xA3\xA2\x35\xA8\xA7\xA6\xA7\x9C\xAB\x2A\x45\x01\x2B\xA6\x02\x96\xA0\x57\x96\xA8\x64\xA6\x53\x97\xA8\x29\xA4\xAA\x3A\xA9\x99\xAC\xA0\xA3\xA1\x47\xB7\xA8\x4D\xA3\x5A\x54\x06\xA5\x8C\xAB\xA1\xAB\x43\xC5\xA8\x52\xAF\xAA\x4A\xAC\xA7\xA1\x5B\x2A\x0D\x4A\xD6\x02\x54\xB7\xAA\xBF\x1F\x0A\x1F\xA8\x2C\x03\x53\xBF\x1E\x16\x1F\xA8\x5B\x05\x95\x9C\x03\x56\xAD\x05\x5F\xA9\x55\xB2\x48\x5E", + "\x05\x95\x9F\x03\x56\xA0\x06\x2D\xA5\x18\x0D\xA5\x62\x05\x95\xA3\x03\x8F\xA4\x06\x2D\xA5\x19\x05\xAB\x36\x2F\x0C\x2D\xA4\x34\x0D\x4A\xE9\x01\x2B\xAA\x03\xAD\xA3\x0D\x2E\xAA\x14\x1C\x06\x2D\xA5\x1B\x0B\xAC\x5A\xAD\xA9\xB9\x16\x37\x0D\x4A\xEF\x00\x64\xB0\x80\x70\x07\xB2\x9B\x1D\x38\x0D\x4A\xF2\x01\x2B\xB3\x03\xAD\xA4\x0E\x2D\xA5\x3A\x0D\x4A\xF6\x01\x2B\xB7\x03\x9A\xA8\x35\x38\x03\x56\xA9\x07\x41\xA9\x52\xB6\xAA\x6F\xA8\xAB\xB0\xAD\xA5\xA0\x56\x92\xAD\x6D\xB4\xAA\x0C\xA7\x10\x2D\xA4\x44\x0E\x5A\xB2\xAF\x6B\xBF\xAD\xBE\xA9\xB8\x87\xAB\xD8\xA3\x5C\xB4\xAC\x71\xBD\x71\x96\x05\x95\x97\x05\xDE\xA5\x5C\x91\xAC\x6E\xAE\xAE\x37\xA2\xB8\xB6\xAD\xE3\xAF\x5C\xBB\xAA\x75\xB9\x13\xA5\x05\x95\xA6\x04\xE6\xA3\x5D\xC6\xAE\x77\xB0\xAE\x72\xA1\xBA\x8D\xAF\xEB\xA3\x5B\xE0\xAE\x53\xB1\x15\xB4\x05\x95\xB5\x04\xEE\xA5\x5D\xD9\xA8\x79\xA0\xAE\xE3\xAE\xBD\xB2\xAF\xF2\xAF\x5E\xD2\xAD\x7B\xA3\x1E\xC3\x05\x95\x84\x07\xD4\xA0\x5F\xCD\x15\x31\x1C\xAF\xB3\x1E\x18\x1F\xA9\x63\x0F\x51\xC8\x05\x2B\xA9\x06\x00\xB1\xBE\xAB\x36\x65\x0D\x4A\xCB\x05", + "\x2B\xAC\x06\xAD\xA5\x19\x2D\xA4\x67\x0D\x4A\xCF\x07\x47\xB0\x06\xAD\xA1\x1A\x00\xAD\x9F\x23\x0D\x2D\xA4\x35\x0D\xA5\xD5\x05\x95\x96\x07\x56\xA7\x0D\x09\xB3\x40\x18\x06\xAD\xA1\x1B\x26\xB1\xFB\xAD\x5F\x82\x0A\x36\x0D\xA5\xDB\x03\xC5\xB2\x76\x6E\x02\x63\xF9\x79\x2B\xBE\x06\xAD\xA7\x1B\x2D\xA4\x70\x0D\x4A\xE1\x05\x2B\xA2\x07\xAD\xA3\x1C\x35\xB1\xF3\xAD\x5D\xC8\x10\x39\x03\xB2\xDD\x2D\x1C\x08\xB3\xDB\xA2\x5E\xC5\xB1\x7D\xAA\xB0\x2D\xB5\xC9\xAC\xB0\x81\x26\x0E\x2D\xA7\x39\x0B\xB2\xD4\xAD\x5A\x28\x06\x2C\xBE\x33\x69\x07\x47\xAA\x07\x1F\xAB\x1D\x1C\xB2\xF3\xA8\x6F\x6C\x05\x2B\xAD\x07\xAD\xA6\x1D\x2D\xA5\x77\x0D\x4A\xF0\x05\x2B\xB1\x07\x1F\xAA\x1E\x2D\xA5\x79\x0B\x61\xC2\x29\x3D\x0D\xA5\xF6\x05\x95\xB7\x07\x56\xA8\x0F\x2D\xA5\x3E\x15\xB1\xFA\x05\x95\xBB\x07\x31\xBF\x64\xCE\xB1\x9E\x1C\x07\xAD\xA5\x1F\x04\xB4\x9B\x6E\x0F\x0B\xB5\x6B\x0D\xA5\x00\x05\x16\x4E\xA5\x0A\x22\x69\x92\xA6\x79\x15\xB4\x97\xA3\x20\x03\x00\x4C\xBB\x1E\x1C\xB6\x42\x05\x00\x9E\xB6\xBE\x92\xB2\xA1\x26\x00\x21\xB6\x55\x47\x00\xA6\xB6\xD0\xB4\xAF\xF9", + "\xA1\x65\xE1\xAE\xAB\xA4\xB2\x53\xB7\x77\x08\x01\x54\xB2\x10\x09\x00\xA6\xA2\xAA\xA3\xB7\xD5\x93\xAB\x5C\xB0\x6B\xBC\xB7\xAE\xBA\xB5\x4C\xB0\xD8\x99\xB3\xA1\x27\x01\x34\xB5\x40\x18\x00\xC6\xB2\xD8\x8E\x33\x0C\x09\x6C\xEB\x32\x06\x0D\xB6\xD9\x0B\x03\x10\xB6\x04\x1C\x01\x53\xB7\xB0\xA7\x5B\x1D\x01\xD9\x9E\x01\x64\xBF\x01\x49\xB4\x08\x09\xB6\x21\x01\xD9\xA2\x00\x6B\xB8\x22\x23\x01\xB2\xA4\x01\x98\xB7\x96\x86\x28\x13\x09\x6C\xA7\x01\xB2\xA8\x01\xC9\xB1\x05\x09\xB6\x15\x04\x6E\xD6\x1B\x0A\x09\xB6\x2C\x05\xDE\x85\xB5\x58\xBD\x41\x2D\x01\xB2\xAE\x01\xFA\xB3\x83\xAF\x01\x80\xB3\x3C\x30\x01\xB2\xB1\x01\xC9\xB2\x06\x09\xB7\x19\x09\x6C\xB4\x01\xB2\xB5\x01\xC9\xB6\x06\x04\xB9\x56\xBD\x6B\xBE\x73\x0D\x13\xB8\xA2\xB2\xD9\xA4\xB2\x81\x18\x03\x18\xB8\x94\xB9\xB8\x15\xB9\xE4\x8B\x77\x1C\x09\x6C\xBA\x02\xC7\xAA\xB5\x99\x1B\x07\x27\xB9\x9F\x2C\x03\x2B\xB9\x40\x1D\x01\x2E\xB8\x00\x3E\x01\x98\xB2\x72\xFD\x47\x0F\x09\xB6\x40\x01\xD9\x81\x03\x64\xB2\x04\x49\xB7\x10\x09\xB6\x44\x01\xE6\x85\x03\x64\xB6\x04\x69\xB5\x38\x28\x02\xC9\xB1", + "\x09\x09\xB6\x25\x09\x6C\xCB\x01\xB2\xAC\x02\x34\xB9\x3B\x0D\x03\x64\xBE\x04\x51\xB9\xB0\xB5\xB9\x18\x17\x09\x09\xB6\x28\x06\x75\xCA\x7D\x14\x1D\xBA\x3E\x1A\x0A\x09\xB7\x29\x09\x6C\xD4\x01\xB2\xB5\x02\xC9\xB6\x0A\x09\xB7\x2B\x09\x6C\xD8\x00\xD8\xBB\xB8\xD7\xB1\x3B\x19\x03\xB7\xBC\x81\x5A\x00\xDD\xAC\xB5\x20\xBF\xD7\x98\xBB\xEF\xAB\x6F\xBE\xB7\xD5\xAF\x24\x5B\x01\xD9\x9C\x03\xBB\xBB\x6A\xA3\x15\x17\x04\xBC\x99\x1E\x0B\x31\xB9\x2F\x01\x73\xE0\x00\xE2\xB9\xBB\x91\x39\x0C\x09\xB6\x31\x09\x6C\xE3\x01\xB2\xA4\x03\xC9\xB5\x0C\x09\xB6\x33\x01\x73\xE7\x01\xB2\xA8\x03\x46\xBA\xA0\x2A\x03\x64\xBB\x06\x49\xB4\x1B\x09\xB6\x6D\x01\xD9\xAE\x03\xC7\xB6\x10\x6F\x01\xB2\xB0\x03\xAC\xB8\xE5\x99\xB9\x38\x09\x6C\xF2\x01\xEC\xA8\x69\x73\x07\xF6\x95\x16\x3A\x09\x6C\xF5\x01\xB2\xB6\x03\xC9\xB7\x0E\x09\xB6\x3C\x09\x6C\xF9\x01\xB2\xBA\x03\xBA\xBA\xE3\xBD\xBA\x6B\x1B\x07\x49\xBF\x9A\x3C\x03\xCE\xBA\xEF\x92\xBF\xBF\xB4\x7D\xF1\xB9\xF5\xBC\xBB\x1F\x85\x0F\x09\xB6\x3F\x07\x6B\x94\xBB\xF4\xB6\xBE\xE0\xB8\xFB\x85\xBC\xEF\xB7\x7D\xF0\xBA\xF8", + "\xA4\xBF\xE1\xBE\xFC\xAA\xBF\xE5\xBB\x77\xEB\xBC\xDE\xBF\xB8\xF0\xBC\xDA\x0C\x05\xE8\xBC\xD1\x0D\x05\xB2\xAE\x04\xF4\xB9\xFD\x9D\x13\x47\x09\x7F\xBE\x18\x24\x11\xB9\x91\x01\xE6\x92\x05\xFE\xBE\x7E\xEB\x37\x24\x09\xB6\x94\x01\xD9\x95\x05\x64\xB6\x09\x49\xB7\x25\x09\xB6\x98\x01\xE6\x99\x05\x64\xBA\x09\x21\xBE\x42\x3C\x04\xC9\xB5\x13\x09\xB6\x4F\x09\x6C\x9F\x05\xB2\xA0\x05\xC9\xB9\x14\x09\xB6\x51\x04\x80\xEC\xBF\xAF\xA3\x05\xC9\xB4\x14\x25\xC0\x9B\x65\x0A\x2B\xC0\x6A\x06\x05\xC9\xB7\x14\x09\xB6\x54\x09\x6C\xA9\x05\xB2\xAA\x05\xC9\xB3\x15\x09\xB6\x56\x0E\x82\xE8\xBF\xF9\xB8\x4C\xAD\x05\x07\xD0\xBC\xFD\xBB\x41\xAE\x06\x10\xD1\xBF\xFC\xB1\x09\xFE\xBB\x12\x6F\x0A\x49\xB4\x2C\x07\xC2\xB2\xBE\x20\x31\x04\x28\xC2\x2D\x32\x05\xCC\xB3\x05\x31\xBC\x16\x14\xC3\x25\xC9\x7A\x35\x05\xB2\xB6\x05\xC9\xB7\x16\x09\xB6\x5C\x09\x6C\xB9\x05\xB2\xBA\x05\x31\xBB\x17\x09\xB6\x5E\x06\x81\xB6\x2A\x2F\x09\xB6\xBF\x01\xD9\x80\x07\x64\xB1\x0C\x49\xB6\x30\x09\xBE\xC3\x01\xD9\x84\x07\x2D\xCA\x7C\xEF\xBF\x40\x05\x06\xC9\xB6\x18\x3C\xC3\xB3\x57", + "\x0C\x7C\xC0\x32\x09\xB6\xC9\x01\xD9\x8A\x07\x64\xBB\x0C\x49\xB4\x33\x09\xB6\xCD\x01\xD9\x8E\x07\x41\xCF\x7D\x8C\xA3\x33\x14\xC4\xA9\x20\x1A\x18\xC4\x22\xC3\x7E\xC3\xC3\x0F\xC8\xC2\x5C\xC5\x00\xD1\x7F\x68\x09\x6C\xD2\x07\x26\xDF\xC4\x61\x7F\x14\xC8\x12\x6A\x01\x73\xD5\x05\xCC\xB6\x06\xAA\xC6\x04\xC1\x33\x6B\x09\x6C\xD8\x05\xB2\xB9\x06\xC9\xB2\x1B\x09\xB7\x6D\x09\x6C\xDC\x05\xCC\xBD\x06\xC9\xB6\x1B\x2D\xC3\x9F\x20\x0E\x49\xB5\x38\x09\xB6\xE2\x01\xD9\xA3\x07\x64\xB4\x0E\x49\xBD\x39\x09\xB6\xE6\x01\x16\xFE\xC3\x0B\xA7\x0E\x49\xB4\x3A\x12\xC6\x67\x49\x1D\x3C\xC2\x75\x09\x6C\xEB\x05\xB2\xAC\x07\xC9\xB5\x1D\x09\xB6\x77\x09\x6C\xEF\x05\xB2\xB0\x07\xD8\xC6\x07\xCB\x79\x78\x09\x8E\xB3\x1E\x3C\x0D\xC7\xA0\xC5\x0F\xDD\xC5\x78\xCD\x7E\xB2\xC4\x27\xDA\x3D\xF3\x01\xD9\xB4\x07\xEE\xBE\x89\xA2\xC5\x3F\xD6\xC7\xA8\xC2\x09\xF2\xC6\x75\xC0\x90\xFE\xC4\x3D\xD5\xC4\x0B\x7A\x00\x35\x0F\x43\xAF\x8F\xD3\xC5\x28\xC5\xC8\x10\xCE\x21\xC3\xC9\x86\xC3\x8F\xD1\xC3\x66\x43\x00\x0B\xCA\x91\x87\xC9\xF2\xB1\x91\x95\xCA\x40\xD5\xC7\x12\xC8\x24", + "\xDE\xC9\x87\xC1\x92\x88\xC9\x47\xCA\x08\x04\x01\x23\xD3\xB5\x8D\xC7\x8F\x94\xC8\x41\xC5\xC9\x1C\xC8\x26\xED\xC8\x96\xC1\x90\xB9\xB5\x01\x0A\xC9\x96\xB7\x23\xE6\xC8\x99\xC5\x93\x93\xC8\x4D\xC6\xC8\x16\xCA\x27\xF1\xC9\x75\x36\x00\x38\xC9\xA6\xA2\xCA\x33\xC9\x28\xE4\xC9\x91\xCE\x93\xCA\xC9\x53\xC8\xCA\x3D\xCA\x24\xEF\xC8\xA6\xC2\x95\x82\x2B\x01\x06\xCA\x9B\xA1\x4D\x48\x00\xAC\xCA\x10\x09\x02\x51\xD8\xB5\x4F\xCB\x29\xD3\xCB\xB1\xCE\x92\xE5\xCB\x4F\xC7\xC9\x66\xCE\x29\xD5\xCB\xB3\xCC\x93\xC0\xC8\x54\xCE\xCB\x62\xC9\x2D\xEF\xCA\x0E\x47\x01\x5C\xCB\xDF\x58\x00\x76\xCE\x20\x19\x01\xAF\xC4\x96\xEC\xC8\x55\xDB\xC9\x7F\xCB\x28\xFD\xCA\xB5\xC0\x98\x83\xCE\xB4\x07\x01\x79\xCB\x20\x28\x01\xC4\xC3\x97\xD8\x25\x0A\x0C\xCC\x6D\x3A\x05\x10\xCC\x6B\x1B\x02\x13\xCD\x8B\x0C\x01\x96\xCD\x30\xD8\x4D\x16\x03\x99\xAE\x03\x64\xCF\x01\x93\xC8\x06\x13\xCD\x18\x03\x99\xB2\x01\x66\xC8\x10\x33\x03\x32\xF4\x00\xA3\xCA\x6E\xD8\x26\x0D\x13\xCC\x37\x03\x32\xF8\x01\xC9\xC9\x03\x13\xCE\x0E\x07\xCD\x11\x1B\x07\x13\xCC\x1E\x08\x9B\xD1\xCA\x66\xD1", + "\x15\x3D\x03\x32\xFE\x01\xDE\xC7\x27\xBF\x00\x71\xC6\x28\x40\x03\x32\xC1\x03\xC9\xC2\x04\x13\xCF\x10\x13\xCC\x44\x03\x32\xC5\x03\xC9\xC6\x04\x47\xCF\xE6\x07\x02\x93\xC8\x09\x3C\xCA\xB9\xC1\x97\xFE\xCA\x61\xDD\xCE\x84\xCA\x30\xDC\xCF\xB0\xC4\x9E\xEB\xC9\x78\xD1\x18\x56\x06\x3A\xC1\xCD\xA4\xCD\x98\xEB\xCE\x6F\xC2\xCF\xDE\xCC\x01\x97\x03\xC9\xC8\x05\x5B\xCD\x7C\xD7\xCF\xE7\xCF\x3D\xEC\xCE\xF0\xCD\x9E\xDF\xCD\x79\xDF\xCD\xD4\x36\x0C\x2A\xCE\xFF\xC6\x9E\xFD\xCF\x78\xC5\xD0\xFC\xC9\x41\xFF\xCE\xF8\xC9\x9F\xF0\xCA\xB5\x07\x03\x03\xD7\x6F\x68\x03\x08\xD1\x2B\x69\x03\x64\xCA\x03\x93\xCB\x0D\x13\xCC\x36\x03\x99\xED\x03\x64\xCE\x03\x93\xCF\x0D\x13\xCC\x38\x03\x99\xF1\x03\x64\xD2\x03\x93\xCB\x0E\x14\xD1\x06\xDE\x95\x74\x03\x8A\xCA\x23\x75\x07\x45\xCA\xD0\x04\xDB\xA0\xCA\x7E\x1D\x12\xD1\x9C\x4F\x0E\x13\xCC\x3C\x06\x9F\xAC\xD1\x5B\xC8\xCB\xF8\xCE\x40\xC1\xD3\x19\xD0\xA0\xC2\xD1\x1C\xA6\x04\x93\xCF\x10\x3D\xD0\x23\xDC\xA4\xC4\xD0\x83\xCD\xD2\x35\xD2\x3F\xD2\xD2\x07\xD4\xA3\xD5\xD1\x91\xCE\xD2\xFB\xC8\x00\x15\x04\x1C\xD6\xA5", + "\xCF\xD0\x96\xD3\xD2\x40\xD6\x47\xEE\xCF\xC0\x36\x09\x5C\xD2\x63\x57\x04\x66\xD0\x41\x18\x05\xC9\xC9\x09\x13\xCE\x26\x13\xCC\x9B\x03\x32\xDC\x05\xC9\xCD\x09\x13\xCE\x27\x13\xCC\x9F\x03\x32\xE0\x05\xC9\xC1\x0A\x13\xCE\x28\x09\xD3\x59\xD2\xF6\x23\x04\x40\xDE\x33\x24\x04\xA1\xD4\xD2\x57\xD1\x4A\xF0\x61\x52\x07\xA8\xDE\x4A\x29\x13\xCC\xA7\x03\x49\xDF\xD2\x44\xDE\xA5\x8A\xD5\x98\xD0\xD2\x5D\xD1\x50\xC9\xD4\xF1\x75\x0B\x13\xCE\x2D\x12\xD4\x96\xD7\x47\xE2\xD5\x31\xD7\xA9\x93\xD5\xA9\xC1\xD5\xA4\xD3\x54\xC4\xD1\x4D\xDC\xAA\xC1\xB4\x31\x0D\xD4\xAA\xD7\x40\xED\xD4\x4D\xD5\xA9\x99\xD4\x98\xD1\xD5\x43\xD6\xC7\x45\x06\x58\xD9\xAA\xBD\xD7\xAA\xD5\xD5\xB3\xD7\x56\xFE\xD4\x59\xD0\xAC\x82\x5A\x31\x1C\xD5\xBF\xD4\x56\xCA\xD6\x61\xD9\xAC\xCC\xD4\xB1\xD8\x10\xC7\x00\x59\xD8\x4C\x64\x02\xAD\x86\x09\x32\x13\xCC\xCA\x03\x32\xCB\x07\xC9\xCC\x0C\x13\xCD\x33\x13\xCC\xCE\x03\x32\xCF\x07\xC9\xC0\x0D\x13\xCD\x34\x13\xCC\xD2\x03\x32\xD3\x07\x6A\xD2\xA6\xE1\x30\x35\x0C\xD7\xD2\x15\x1A\x30\xD6\x53\xD8\xAB\xED\xD7\xDF\x56\x06\xF3\xD0\x06\x57", + "\x07\xC9\xC8\x0D\x20\xD6\xAD\xD4\xD4\xCB\xD0\x60\xCE\xD7\x5C\xDF\xAF\xA7\xD5\xC1\xD5\xD7\x98\xD1\x5F\x26\x07\x7C\xD0\x92\x67\x05\xBE\xC8\x07\x93\xC9\x1D\x13\xCC\x75\x03\x99\xEB\x07\x64\xCC\x07\x93\xCD\x1D\x13\xCC\x77\x03\x99\xEF\x07\x64\xD0\x07\x93\xC9\x1E\x13\xCC\x79\x0C\xB0\xC1\xD6\x94\x33\x07\x25\xD8\x41\x34\x07\x94\xD1\xB0\x86\xDA\xC9\xDE\x4A\xF5\x04\x65\xE9\x3C\x7B\x03\x99\xF7\x06\xBF\xCF\xD9\x08\xDC\x5E\xC3\xD6\x82\xD8\xB3\xBB\xDA\xBD\xDC\xD9\xEA\x7D\x00\x38\x0E\x86\xC6\x10\x06\x03\xD0\xDA\xC8\x3F\xDD\x83\x07\x01\xA3\xDB\x92\xD4\x34\x02\x0C\xDA\x39\xCD\x5A\x09\x00\xA8\xD7\x94\xD5\x16\x02\x14\xDA\x59\xCE\x65\xFD\x47\x05\x08\xB5\x8A\x08\x03\x1D\xDA\x09\x0D\x01\x20\xDA\x83\x0E\x00\x63\xDB\x40\x0F\x00\x66\xDA\x20\x10\x01\xB4\xD5\x2D\x11\x00\xDB\xC0\x00\x12\x04\x6A\xED\xCD\xE1\x14\x01\x6F\xD9\x05\x0F\xDB\x16\x07\x6D\xD7\x01\xB7\xD8\x01\x6F\xD8\xBF\x19\x00\x6F\xDA\x03\x3E\xDB\x9E\xDD\x6A\x9B\x03\xDB\xDC\x00\x83\xDE\x6B\x9D\x01\xC4\xD0\x4A\x1E\x03\xDB\xDF\x00\x6F\xD8\x04\x2F\xDB\x10\x0F\xB6\xA2\x03\xDB\xC3\x01", + "\x6F\xDC\x04\x0C\xDC\x9F\x15\x02\x6F\xDA\x09\x14\xDA\x60\xCF\x60\xFE\xD9\x84\xD5\xAC\xAD\xD9\xCE\xC8\xD5\xCD\xD2\x60\xCB\x78\x1A\x0F\xB6\xB5\x03\xE6\xCA\xDD\xA5\x1E\x06\x2F\xDC\x4D\x37\x03\x33\xDD\x9E\x18\x01\xB6\xD8\x35\x39\x01\xDC\xD9\xBA\x9C\x42\x0E\x0F\xDB\x3B\x07\x6D\xFC\x01\xB7\xDD\x03\x6F\xDA\x0F\x0F\xDB\x3F\x04\x77\xC9\x08\x20\x0F\xB6\xC1\x02\xDC\xC1\x27\x43\x07\x6D\xC4\x03\xB7\xD5\x04\x6F\xDA\x11\x0F\xDB\x47\x02\x79\xF1\x14\x24\x0F\xB6\xC9\x02\xF6\xC9\xDA\x02\xCA\x09\x2F\xDB\x25\x0F\xBD\xC2\x84\x13\x05\xDF\x73\x25\x09\x2F\xDA\x27\x0F\xB6\xCF\x03\xDB\xD0\x02\x6F\xD9\x0A\x2F\xDA\x29\x0F\xB6\xD3\x00\xFA\xC8\xDD\xCF\xD3\x60\xE0\xDE\xF5\x44\x05\x77\xDE\xE8\xDD\xDD\xA7\xDF\x7F\xF9\xDE\xD8\xD1\xC0\xDD\x2D\x15\x1E\xDF\x84\xDB\x80\xDA\xDA\xD3\xD3\xBA\xBA\xD8\x00\xED\xE0\xE4\xCE\x0A\x08\xE1\xD2\xDA\xBF\xA4\xDC\x03\xEF\xE0\x18\xE2\x81\xC5\xE0\x0A\xE2\x65\x57\x03\x04\xF7\xE0\x1A\xE0\x82\xC2\xE0\xA0\xD0\xC2\xA4\xE1\x05\xEE\xE0\x02\x28\x0B\x1F\xE1\x13\xE8\xBF\xA6\xE0\x01\xE2\xE1\x09\xE6\x85\xCB\xE0\x16\xED\x22\x59", + "\x03\x0A\xEF\xE1\x19\xE2\x86\xDB\xE1\x12\xEB\xBF\xAD\xE1\x0F\xE3\xE1\x3D\x72\x0B\x37\xE1\x19\xE8\xC3\xA1\xE1\x0E\xFF\xE1\x31\xE0\x89\xDC\xE0\x22\xEC\xC4\xBB\xE0\x0B\xFB\x02\x43\xE6\x89\xC5\xE2\x1D\xE0\xC3\xCB\xE2\x14\xED\xE2\x55\xE4\x87\xFF\x28\x2E\x01\xC5\xD9\xE0\x0D\xE9\xE2\x16\xE7\x8B\xD6\xE2\x2F\xE3\xC5\xCA\xE2\x83\x3D\x02\x5D\xE7\x88\xE1\xE3\x32\xEB\xC6\xD8\xE2\x1A\xE8\xE1\x54\xE7\x8D\xC0\x00\x2F\x09\xC6\xC6\xE2\x1D\xF1\xE3\x77\xE6\x8C\xE2\xE2\x2D\xE0\xC7\xFA\xE0\x92\x1F\x02\x75\xE0\x8F\xC2\xE4\x3F\xEE\xC6\xF9\xE1\x1B\xF7\xE2\x88\xE4\x8C\xDD\x12\x30\x01\xC8\x84\xE5\x22\xF2\xE3\x40\xE7\x90\xCA\xE5\x47\xE6\xC8\xB9\xB5\x18\x0D\xE4\x92\xE0\x92\xE0\xE3\x3E\xE9\xC9\x95\xE6\x0F\xFD\xE4\x0A\x2A\x0C\x18\xE4\xA1\x23\x06\x23\xE7\x27\xFC\xE4\xA8\xE7\x94\xEA\xE5\x16\x14\x06\x6F\xD9\x19\x00\xDD\x9A\xE3\x8C\xF1\xE4\x3E\xEB\xCA\x9B\xE5\x2D\xF2\xE5\x9E\xE3\x0E\x2F\xDA\x3A\x00\xCB\x9E\xE5\x24\xE9\xE5\xBF\xE7\x96\xF4\xE5\x60\xE4\xCC\xB6\xE6\x20\x0F\xDB\x83\x05\x97\xC3\xE4\x50\xEE\xC8\x93\xE6\x33\xF3\xE5\x7B\xE1\x9A\xEC\xE2", + "\x60\xE6\xCB\xEB\x31\x24\x06\xE5\xC5\xE0\x97\xCB\xE6\x6A\xEA\xCD\xCD\xE5\xAB\xB2\x04\x6F\xDB\x12\x18\xE7\x44\xD4\x09\x63\xE6\xC0\x15\x04\xF7\xDE\x12\x37\xDF\x4B\x06\xCE\xC3\xE7\x23\x38\x04\x6F\xD9\x13\x2F\xDA\x4D\x0F\xB6\x9B\x07\xDB\xDC\x04\x6F\xDD\x13\x37\xDE\x4F\x0F\xB6\x9F\x07\xF3\xC2\x28\xA1\x07\x6D\xE2\x05\xB7\xD3\x0A\x6F\xD8\x29\x0F\xDB\xA5\x06\x94\xE6\x05\xB7\xD7\x0A\x6D\xE6\x34\xE8\x9E\xA8\x07\x6D\xE9\x04\x87\xE0\xC3\x2A\x04\x45\xFD\x12\xAB\x07\x6D\xEC\x05\xB7\xDD\x0A\x6F\xDA\x2B\x0F\xDB\xAF\x07\x6D\xF0\x05\xB7\xD1\x0B\x17\xE8\x25\xF6\x4A\xB2\x06\xA4\xEF\x41\x59\x06\xCA\xB4\x07\xDB\xD5\x05\x6F\xDE\x16\x2F\xDB\x5B\x0F\xB6\xB8\x07\xDB\xD9\x05\x6F\xDA\x17\x2F\xDB\x5D\x0F\xB6\xBC\x07\xDB\xDD\x05\x6F\xDE\x17\x2A\xE8\x68\xE6\x35\x3F\x07\x50\xE9\x08\xC0\x07\xA8\xDB\xE6\x61\xEF\xD0\xE3\x31\x30\x0A\xEA\xDE\xE6\x97\xDD\x2E\x61\x07\xBF\xC3\x04\x54\xEC\xE6\x58\xEC\x9B\xEE\xE7\x6E\xE9\xD5\xE4\xCC\x31\x0F\xDB\xC5\x07\xAA\xCA\xD0\x63\x02\xD6\xD6\x17\x31\x17\xDF\xC8\x07\x7E\xC9\x07\xB2\xE9\xCD\x91\x1A\x32\x0F\xDB\xCB", + "\x07\x6D\xCC\x07\xB7\xDD\x0C\x6F\xDA\x33\x0F\xDB\xCF\x07\x7E\xD0\x07\xB7\xD1\x0D\x7F\xE6\x42\x33\x06\x6F\xDC\x1A\x2F\xDB\x6A\x0F\xB6\xD6\x07\xDB\xD7\x06\xA6\xE0\x1B\x2F\xDB\x6C\x0C\xD6\xD5\xE4\xFB\x5A\x06\x6F\xDB\x1B\x0D\xEC\x81\x5C\x0D\x65\xE9\x37\x0F\xDB\xDE\x07\x6D\xDF\x07\xB7\xD0\x0E\x6F\xD9\x38\x0F\xDB\xE2\x07\x6D\xE3\x07\xC9\xEB\xD5\xA5\xED\x53\xEF\xE6\x52\xEC\xAB\xDA\xEB\xD3\xE4\xD4\x86\x28\x39\x0F\xDB\xE5\x04\xB4\xFD\xC8\x73\x02\xDB\xC8\x13\x39\x17\xDF\xE8\x07\x7E\xE9\x07\xDA\xE5\xC8\xBF\x1E\x3A\x0F\xDB\xEB\x07\x6D\xEC\x07\xB7\xDD\x0E\x6F\xDA\x3B\x0F\xDB\xEF\x07\x7E\xF0\x07\xB7\xD1\x0F\x7E\xEA\x4D\x33\x07\x6F\xDC\x1E\x2F\xDB\x7A\x0F\xB6\xF6\x07\xDB\xD7\x07\xA6\xE0\x1F\x2F\xDB\x7C\x0C\xDB\xA7\xE9\x8F\x7A\x07\x6F\xDB\x1F\x1D\xEF\xB3\x4C\x0F\x65\xE9\x3F\x0F\xDB\xFE\x06\x6F\xEF\xDA\x00\x0B\x1F\x44\xDA\x7A\x0D\xEF\x48\xDA\x20\x02\x00\xF8\xED\xB4\x82\x0B\x00\x14\xEF\x51\xDC\x8E\x04\x00\xFC\xE5\xB5\xCC\xEB\x34\xFE\xEF\xBD\xE9\xAA\xCB\xEB\xB6\xEC\xDA\xA9\xEE\x83\x25\x00\xFC\xEF\x39\x06\x01\x04\xFD\xDA\xF9\x13", + "\x01\x0C\xF0\x9C\x30\x01\x10\xF0\x9F\x63\xE1\xCD\x16\x02\x15\xF0\x5D\xEA\xF6\x0B\x00\x0C\xF0\x26\x9C\xF1\x8A\x1E\xF0\x0E\x06\xC3\xCF\x00\x0F\xF0\x01\x1E\xF1\x8B\x11\x00\x1E\xF2\x02\x3C\xEF\xB9\xD9\x39\x14\x02\x87\xF5\x00\x1E\xF6\x02\x1E\xF1\x0B\x0E\xE1\x98\x02\x89\xF9\x17\x19\x06\xC3\xDA\x01\x1B\xFA\xDA\xE4\xCF\x06\x1E\xF0\x1C\x04\xC7\xE7\x99\x0E\x02\xE4\xAF\x26\x07\x1E\xF0\x1F\x06\xC3\xE0\x00\x0F\xF1\x02\x1E\xF2\x08\x1E\xF0\x23\x06\xC3\xE4\x01\x22\xF6\x35\x25\x00\x95\xE1\xF0\x19\xF6\xB1\xFD\xF0\x02\xFF\xDF\xDC\xF0\x96\xEB\xED\xC0\x26\x04\x1E\xF1\x13\x07\xE5\xDE\xEE\xB4\x08\x01\x65\xF4\xA5\x29\x01\x34\xFA\x10\x2A\x00\x9B\xE9\x08\x2B\x07\xCD\xC3\xF1\xEE\x2C\x02\x1E\xF1\x0B\x1E\xF0\x2E\x06\xC3\xEF\x00\x0F\xF0\x03\x1E\xF1\x0C\x12\xF3\x03\x0A\x06\x1E\xF1\x19\x0B\xE2\xE1\x25\x0D\x1E\xF0\x36\x06\xC3\xF7\x00\x0F\xF8\x03\x1E\xF1\x0E\x00\xF4\xD2\x12\x07\x1E\xF1\x1D\x00\xE9\xE0\xF3\xF2\xBC\x01\x1E\xF5\x07\x15\xF5\xC1\x8E\x03\x1B\xF4\xBF\x1F\x01\x1E\xF0\x08\x1E\xF1\x20\x0E\xE1\xC2\x02\x87\xE3\x02\x1E\xF4\x08\x1E\xF1\x22", + "\x0E\xE9\xD9\x0E\x11\x0D\xF5\x5B\xF2\xCB\xE6\xED\x2E\xF2\xEB\x85\xF3\x9C\xF1\xF5\xB8\xF0\x43\x07\x02\x0F\xF8\x04\x30\xF4\x2D\xE9\x02\xBE\xF7\x95\x0A\x03\x4D\xFB\x04\x1B\xF4\x13\x01\xF6\xB4\xF1\xC8\x0D\x02\x0F\xFE\x04\x1E\xF3\x13\x1E\xF0\x50\x06\xC3\xD1\x02\x0F\xF2\x05\x1B\xF7\x14\x1E\xF0\x54\x05\xD0\xC2\x28\x2B\x0E\xE1\xD7\x02\x87\xF8\x02\x1E\xF1\x0B\x1E\xF0\x2D\x08\xEC\xDD\x13\x16\x1E\xF0\x5C\x05\xDC\xE6\xF3\x5C\xBD\x05\x1E\xF2\x17\x0A\xF7\x3C\x6F\x0B\x30\xF7\x4E\x10\x06\x1E\xF1\x18\x1E\xF0\x62\x06\xC3\xE3\x02\x0F\xF4\x06\x1E\xF1\x19\x1E\xF0\x66\x03\xDE\xC9\x09\x33\x02\xF0\xB7\xF7\xAC\xFF\xF2\x00\xF3\xDD\xC9\xF8\xD4\xE6\xF0\xB6\xF5\xB3\x08\x03\x1E\xF1\x0D\x05\xF9\x1E\xEA\x06\x13\xFA\x1A\x2B\x03\x9B\xF4\x0D\x1B\xF5\x36\x06\xF1\x96\xF7\x98\x2E\x03\x1E\xF7\x0D\x1E\xF0\x38\x0E\xE1\xF1\x02\x87\xF2\x03\x1E\xF3\x0E\x1B\xF4\x3A\x0E\xE1\xF5\x02\xB6\xEA\x28\x77\x06\xC3\xF8\x02\x0F\xF9\x07\x1E\xF2\x1E\x1E\xF0\x7B\x05\xE3\xC0\x00\x3E\x0E\xE1\xFD\x02\xCE\xFE\xF2\x1F\x86\x0F\x1E\xF1\x3F\x0F\xF3\xEC\x5C\x20\x05\xFA\x08\x11", + "\x10\x1E\xF0\x41\x0E\xE1\x83\x06\x87\xE4\x04\x1E\xF5\x10\x1E\xF0\x43\x0E\xE1\x87\x06\xCE\xE8\x04\x48\xFF\xE0\xCA\xF8\xA0\xFC\xF0\x82\xF2\xD7\xF9\xF2\xB9\xF1\x01\x89\x05\xAC\xFE\xF0\xE0\xFA\xD6\xFD\xFA\x66\xFD\xEC\xDE\xF8\xB4\xFB\xF6\x9D\x16\x22\x04\xFB\xE0\xAB\x11\x30\xFA\xAF\x4C\x08\x3A\xF9\x23\x1E\xF0\x8E\x06\xC3\xCF\x04\x0F\xF0\x09\x1E\xF1\x24\x1E\xF0\x92\x06\xC3\xD3\x04\x0F\xF4\x09\x1E\xF1\x25\x1E\xF0\x96\x06\xC3\xD7\x05\xB9\xFB\xF5\xEF\xE4\xE3\xE8\x0D\x99\x07\xF1\xCD\xF0\xB6\xFB\xF0\x9D\x16\x26\x12\xFC\x7F\x5B\x13\x1E\xF0\x4E\x08\xF9\xF1\xC5\x27\x1D\xFC\xCD\x16\x13\x1B\xF5\x4F\x0B\xE9\xA0\x04\xE8\xE9\xFB\x56\x19\x14\x1E\xF0\x51\x0E\xE1\xA3\x06\x87\xE4\x05\x1E\xF5\x14\x1E\xF0\x53\x0B\xE9\xA7\x06\x87\xE8\x05\x2F\xFE\xA6\x2A\x04\x0F\xFB\x0A\x1E\xF0\x2B\x1E\xF0\xAD\x06\xC3\xEE\x04\x9D\xFF\x0A\x1E\xF0\x2C\x07\xFD\x6D\xFB\xAB\x71\x04\x0F\xF2\x0B\x48\xFE\xF5\x53\x05\xCE\xFC\x16\x1E\xF1\x5A\x0E\xE1\xB6\x06\x87\xF7\x05\x1E\xF0\x17\x1E\xF1\x5C\x0E\xE1\xBA\x06\xF3\xFC\xFA\x93\xF9\xFC\xC6\xF0\xB5\xF5\xF9\xE3\xFD\xB2", + "\xF9\xD2\xBB\x06\xC3\xFC\x05\xEF\xFF\x6B\xBD\x04\xFB\xE8\x10\xBE\x03\xD3\xFF\x05\x4D\xF0\x0C\x6F\xFF\xD9\xFD\x14\xC1\x06\xC3\xC2\x06\x0F\xF3\x0C\x1E\xF0\x31\x1E\xF0\xC5\x02\x87\x76\x0C\x1B\x7A\xC7\x02\x87\x78\x0C\x39\x7E\x3F\x16\x32\x0E\xE1\x4B\x03\x1E\x78\x33\x0E\xE1\x4D\x03\x1E\x7A\x33\x0A\xF3\x4F\x03\x1E\x78\x34\x06\xFF\x64\x7F\x32\x35\x34\x0E\xE1\x52\x03\x17\x81\x9A\x23\x0D\x0E\x7F\xD4\x02\x87\x75\x0D\x1E\x78\xD6\x02\x87\x77\x0D\x1E\x78\xD8\x02\x87\x79\x0D\x1E\x78\xDA\x02\xCE\x7B\x0D\x1E\x78\xDC\x01\x07\x88\xF0\x60\x7F\xE6\x7F\x0C\x85\xEB\x67\x7F\x18\x83\x0D\x80\x01\x5D\x03\x32\x81\xE3\x71\xF6\x78\x80\x40\x82\x0D\x8F\x03\x82\x81\xF7\x7C\x66\x2E\x0D\x1E\x78\xDF\x01\x0F\x84\xF9\x74\x80\x0D\x7D\x10\x8E\x03\x85\x81\x4D\x80\x11\x83\xD1\x20\x03\x1E\x79\x38\x0A\x04\xAC\x4D\xE2\x03\x15\x89\x10\x23\x03\x9B\x78\x39\x0B\xE9\x65\x03\x5A\x81\x14\x89\x27\x26\x03\x1E\x7B\x39\x0E\xE1\x68\x03\x1E\x79\x3A\x0E\xE1\x6A\x03\x1E\x7B\x3A\x0B\xE9\x6C\x03\x1E\x79\x3B\x08\x00\x82\x15\xEF\x02\x87\x70\x0F\x1E\x78\xF1\x02\x87\x72\x0F", + "\x1E\x78\xF3\x02\xCE\x74\x0F\x1E\x78\xF5\x01\x18\x8F\xF5\x48\x2F\xF6\x02\x87\x77\x0F\x02\x82\x4A\x24\x3E\x0E\xFC\x79\x03\x1E\x7A\x3E\x0E\xE1\x7B\x03\x1E\x78\x3F\x0E\xE1\x7D\x03\x1E\x7A\x3F\x06\xE2\x48\x82\xC9\x7E\x18\x8B\x04\xBA\x80\x4F\x81\x0E\x83\x04\x9D\x82\xFF\x74\x00\x0E\x1F\x2E\x77\x40\x4B\x28\x81\xDF\x59\x82\xCD\x0A\x00\x06\x0A\xB5\x77\x6D\x1F\x00\x0B\x0A\xB9\x77\x2D\x08\x01\x0F\x0A\xBD\x77\x2D\x09\x01\x03\x0B\x99\x6D\xA0\x80\x07\x26\x00\x37\x82\x9F\x50\x2F\x84\x25\x7E\x82\x57\x48\x30\x8A\x25\x42\x83\x5D\x48\x31\x85\x2D\x0C\x00\xC6\x81\x8A\x03\x0B\xAC\x78\xB3\x0F\x03\x09\x0C\x90\x00\xC9\x81\x04\x09\x0C\x92\x00\xC9\x83\x04\x09\x0C\xBC\x0B\x14\x01\x32\x85\x01\x17\x83\x9C\x80\x4C\x56\x01\x09\x83\x17\x00\x37\x8E\x35\x58\x00\xE2\x80\x28\x19\x01\x09\x83\x1A\x01\x32\x8B\x01\x09\x83\x1C\x01\x32\x8D\x01\x09\x83\x1E\x01\x32\x8F\x01\x25\x83\x3E\x0C\x08\x09\x0C\xA1\x00\xB3\x83\x6C\x4C\x04\x83\x82\xE5\x7E\x26\x82\xFE\x7E\x83\x35\x81\x2E\x8B\x41\x64\x00\xC9\x81\x09\x04\x0F\x8E\x81\xA8\x06\x09\x07\x10\x9A\x1A\x27\x03", + "\x42\x89\x27\x28\x00\x0E\x84\x6A\x09\x02\x11\x84\xFF\x82\x4D\x1A\x02\x09\x83\x2B\x01\x32\x8C\x02\x09\x83\x2D\x01\x32\x8E\x02\x09\x83\x2F\x00\x45\x89\x10\x30\x00\xC9\x81\x0C\x0B\x0C\xA1\x13\x33\x01\x32\x84\x03\x09\x83\x35\x01\x32\x86\x03\x09\x83\x37\x02\x48\x81\x2B\x38\x00\xC9\x81\x0E\x02\x13\xBC\x83\x4E\x4E\x0E\x09\x0C\xBB\x00\x37\x86\x30\x4C\x03\x3D\x84\x73\x11\x0F\x09\x0C\xBE\x00\xC9\x83\x0F\x09\x0C\x80\x01\xC9\x81\x10\x09\x0C\x82\x01\xC9\x83\x10\x00\x14\x96\x0B\x44\x01\x32\x85\x04\x39\x83\x15\x84\xEA\x72\x05\x88\x84\x55\x84\x2A\x86\x15\x82\x84\x30\x54\x12\x09\x0C\x89\x01\x4F\x85\x30\x7A\x04\x21\x85\x8F\x13\x12\x0F\x14\x8C\x01\x4F\x85\x13\x04\x16\x9F\x82\x2C\x16\x13\x09\x0C\x8F\x01\xC9\x80\x14\x09\x0C\x91\x01\xC9\x82\x14\x09\x0C\x93\x01\x4F\x84\x15\x09\x0C\x95\x01\x27\x86\x40\x17\x05\x09\x83\x58\x01\x32\x89\x05\x09\x83\x5A\x01\x32\x8B\x05\x2B\x85\x18\x08\x17\x09\x0C\x9D\x01\x88\x86\x27\x87\x32\x5E\x01\xC9\x83\x17\x0D\x18\x8B\x3C\x60\x03\x64\x85\x3A\x21\x01\xC9\x82\x18\x09\x0C\xA3\x01\xC9\x80\x19\x09\x0C\xA5", + "\x01\xC9\x82\x19\x09\x0C\xA7\x01\x96\x85\x9E\x08\x06\x09\x83\x69\x00\x55\x81\x10\x9B\x82\x6C\x85\x56\x8D\x0F\xB8\x84\xDD\x82\x6B\x81\xCC\x6C\x01\xA5\x84\x6B\x80\x05\xB0\x86\xAD\x87\x6A\x82\x1B\xB1\x86\xBA\x87\xEC\x0D\x06\x35\x86\xBB\x85\x6E\x80\x10\x83\x87\xB8\x87\x6D\x8B\x15\xB6\x86\xA9\x1E\x1B\x00\x1C\xBD\x86\xC4\x87\x71\x81\x1C\x86\x87\x5A\x85\x74\x8A\xCA\x6F\x01\xC9\x80\x1C\x0A\x1A\x8D\x87\xD2\x87\x3E\x8E\x1C\x8C\x87\xC5\x86\x63\x8E\x1D\xB7\x49\x73\x01\x32\x84\x07\x0B\x87\xB9\x69\x1D\x04\x1E\x9D\x10\x76\x03\x53\x87\x07\x0F\x85\x78\x03\x79\x8B\x1D\xBF\x0E\x79\x01\x32\x8A\x07\x09\x83\x7B\x01\x32\x8C\x07\x09\x83\x7D\x01\x32\x8E\x07\x0F\x85\x7F\x01\x32\x80\x08\x3D\x85\x0A\x16\x20\x09\x0C\x83\x02\xC9\x80\x21\x09\x0C\x85\x02\xC9\x82\x21\x0E\x1E\x81\x04\x87\x01\x32\x88\x08\x0B\x88\xAF\x86\x30\x49\x08\x09\x83\x8A\x00\x84\x82\xD3\x0B\x02\x16\x89\x76\x0C\x08\x09\x83\x8D\x01\x32\x8E\x08\x09\x83\x8F\x01\x32\x80\x09\x09\x83\x91\x01\x32\x82\x09\x19\x88\xC2\x85\x77\x88\x15\x9C\x87\xEF\x86\x8A\x87\x15\xAF\x88\xA7\x6F\x24", + "\x09\x0C\x94\x02\x28\x89\x96\x65\x09\x35\x88\x3E\x0E\x25\x0F\x14\x97\x02\x4F\x84\x26\x08\x23\xAB\x88\xBF\x0D\x26\x09\x0C\x9A\x02\xC9\x83\x26\x09\x0C\x9C\x02\xC9\x81\x27\x09\x0C\x9E\x02\x4F\x87\x27\x09\x0C\xA0\x02\x00\x8A\x4D\x12\x0A\x09\x83\xA3\x01\x32\x84\x0A\x09\x83\xA5\x01\x32\x86\x0A\x10\x88\xA7\x01\x32\x88\x0A\x3F\x88\x30\x88\x4F\x39\x0A\x09\x83\xAA\x00\x98\x86\xD3\x2B\x02\x66\x88\x6A\x0C\x0A\x09\x83\xAD\x01\x32\x8E\x0A\x09\x83\xAF\x01\x32\x80\x0B\x09\x83\xB1\x01\x32\x82\x0B\x10\x88\xB3\x01\x32\x84\x0B\x33\x82\x48\x49\x84\x89\x1D\xBC\x86\xD8\x86\x9F\x82\x28\x9A\x87\x7F\x89\xB0\x58\x0B\x09\x83\xB9\x01\x9A\x8D\x6A\x7A\x02\x8A\x8B\xAA\x0B\x0B\x0F\x85\xBC\x03\x53\x8D\x0B\x0D\x8A\x81\x89\x8B\x0E\x0B\x09\x83\xBF\x01\x32\x80\x0C\x09\x83\xC1\x01\x32\x82\x0C\x09\x83\xC3\x03\x53\x84\x0C\x09\x83\xC5\x01\x94\x8F\x53\x07\x03\xC9\x80\x32\x09\x0C\x89\x03\xC9\x82\x32\x09\x0C\x8B\x03\x10\x88\x33\x09\x0C\x8D\x03\x94\x8A\x8B\x86\xD3\x0E\x03\xC9\x83\x33\x05\x2B\x9F\x2D\xD0\x03\xAE\x81\x10\x11\x03\xC9\x82\x34\x09\x0C\x93\x03", + "\xC9\x80\x35\x09\x0C\x95\x03\xC9\x82\x35\x09\x0C\x97\x03\x10\x88\x36\x09\x0C\x99\x03\x7C\x8B\x73\x8F\x1D\xA1\x89\xD2\x88\x90\x86\x2B\x88\x87\xD6\x88\x4A\x3D\x0D\x09\x83\xDE\x02\xAF\x84\x9E\x5F\x03\xDE\x89\x8B\x00\x0E\x0F\x85\xE1\x03\x53\x82\x0E\x21\x8B\x80\x89\xB3\x03\x0E\x09\x83\xE4\x01\x32\x85\x0E\x09\x83\xE6\x01\x32\x87\x0E\x09\x83\xE8\x03\x53\x89\x0E\x09\x83\xEA\x02\xA9\x82\x54\x2C\x03\xC9\x81\x3B\x09\x0C\xAE\x03\xC9\x83\x3B\x09\x0C\xB0\x03\x10\x89\x3C\x09\x0C\xB2\x03\xE8\x89\x8A\x8F\xB5\x33\x03\xC9\x80\x3D\x09\x30\xA8\x28\xF5\x02\xB7\x86\x0F\x09\x83\xF7\x01\x32\x88\x0F\x09\x83\xF9\x01\x32\x8A\x0F\x09\x83\xFB\x01\x32\x8C\x0F\x10\x88\xFD\x01\x32\x8E\x0F\x11\x8B\x2C\x89\xA1\x80\x1D\x83\x8A\xE9\x89\x8B\x8A\x32\xA6\x8C\x09\x42\x00\x01\x20\x24\x82\x01\x07\x00\x0F\x32\xA7\x82\x28\x8C\x82\x04\x00\x33\x8C\xAC\x80\xBB\x15\x00\x38\x8C\xB0\x81\x76\x06\x00\x3C\x8C\xB4\x81\x76\x07\x00\x00\x8D\xB8\x80\xB6\x8A\x69\x08\x00\x44\x8D\x57\x69\x34\x9B\x05\x4B\x8E\x41\x0B\x00\x0D\x8D\x03\x04\x03\x00\x35\x82\x04\x0D\x03\xD4\x85", + "\x2D\x0E\x00\x56\x8C\x00\x0F\x00\x00\x8D\xCC\x83\xEF\x01\x01\x19\x8D\x12\x01\xD6\x83\x01\x19\x8D\x14\x01\xD6\x85\x01\x19\x8D\xFC\x0A\x05\x09\x35\x97\x00\x68\x8D\xCA\x89\x6B\x58\x00\x59\x8D\x06\x0D\x36\x9E\x4D\x1A\x03\xDC\x80\x4A\x1B\x00\x59\x8C\x07\x09\x35\x9D\x00\x59\x8E\x07\x09\x35\x9F\x00\x59\x8C\x08\x09\x35\xA1\x00\x76\x8E\xCF\x02\x02\x19\x8D\x23\x00\xD0\x8D\x27\x84\x8A\x35\x8F\xC9\x8C\x38\x8F\x8E\x6E\x8D\xE3\x83\x2D\x9C\x85\x0A\x07\x09\x05\x38\x99\x8B\x2C\x8C\xE6\x82\x39\x9A\x8E\x90\x8E\xC2\x89\x39\xBF\x0F\x97\x8C\xB5\x85\x32\x9B\x8E\xA2\x8D\xA5\x81\x39\x9D\x8E\x8E\x8C\x10\x29\x02\x21\x8E\x94\x8F\xE8\x88\x3A\x93\x8E\x46\x8D\xEB\x86\x3A\x9E\x8E\xAE\x5A\x0A\x0C\x3A\xB1\x8E\xB8\x8D\xB5\x85\x3A\x97\x8B\xBA\x8E\xEC\x8D\xE3\x2B\x00\x59\x8C\x0B\x0A\x38\xBD\x8E\xB9\x8E\xEB\x87\x3A\x87\x8F\xB4\x8F\xEB\x8C\x39\xB8\x1B\x30\x01\xD6\x81\x03\x37\x8E\x72\x72\x0C\x00\x3D\x82\x14\x33\x03\xF4\x86\x10\x34\x00\xD6\x8F\x40\x05\x03\x19\x8F\x2B\x8F\x50\x16\x03\x19\x8D\x37\x01\xD6\x88\x03\x19\x8D\x39\x01\xD6\x8A\x03\x19\x8D\x3B", + "\x00\xF7\x81\x10\x3C\x00\x59\x8D\x0F\x0C\x35\xA1\x13\x3F\x01\xD6\x80\x04\x19\x8D\x41\x01\xD6\x82\x04\x19\x8D\x43\x02\xFA\x80\x15\x99\x8D\x45\x02\xFE\x8A\x3C\x90\x40\x46\x01\xD6\x87\x04\x3E\x8F\xCB\x38\x12\x04\x40\x82\x0C\x49\x01\xD6\x8A\x04\x19\x8D\x4B\x01\xD6\x8C\x04\x19\x8D\x4D\x01\xD6\x8E\x04\x19\x8D\x4F\x03\x01\x99\x3A\x89\x8F\xC8\x8F\x05\x9A\x41\xB0\x8E\xC4\x8D\x07\x9F\xB7\x10\x01\x59\x8D\x14\x06\x41\xA4\x7F\x52\x03\x08\x90\x4C\x13\x01\xFA\x8C\x15\x0A\x3F\x95\x01\x26\x93\xEE\x8F\x53\x16\x01\x59\x8F\x15\x09\x35\x98\x01\x59\x8D\x16\x09\x35\x9A\x01\x59\x8F\x16\x0A\x3F\x9C\x01\x59\x8D\x17\x0F\x3E\xA9\x15\x59\x8C\x18\x09\x35\xA1\x01\x59\x8E\x18\x09\x35\xA3\x01\x2D\x91\x9E\x04\x06\x19\x8D\x65\x01\x12\x95\x3C\xAE\x36\x66\x01\xD6\x87\x06\x0E\x91\x38\x34\x1A\x04\x45\xAB\x0A\x69\x01\xD6\x8A\x06\x19\x8D\x6B\x01\xD6\x8C\x06\x19\x8D\x6D\x01\xD6\x8E\x06\x19\x8D\x6F\x03\x15\x96\x10\x30\x01\x59\x8D\x1C\x0F\x43\xB3\x8E\x1B\x93\xF2\x88\x41\xAF\x91\x6D\x92\x0B\x9F\x39\x8A\x2D\x73\x01\xD6\x84\x07\x26\x91\x3D\x71\x1D\x08\x47", + "\xAA\x11\x76\x02\xFE\x87\x07\x3A\x8F\x78\x03\x1E\x93\x47\x83\x0F\x79\x01\xD6\x8A\x07\x19\x8D\x7B\x01\xD6\x8C\x07\x19\x8D\x7D\x01\xD6\x8E\x07\x3A\x8F\x7F\x01\xD6\x80\x08\x2B\x91\x36\x16\x20\x09\x35\x83\x02\x59\x8C\x21\x09\x35\x85\x02\x59\x8E\x21\x02\x48\x80\x00\x87\x01\xD6\x88\x08\x1F\x92\xFF\x8E\x4D\x39\x08\x19\x8D\x8A\x00\x29\x9C\xBE\x0B\x02\xAA\x90\x82\x0C\x08\x19\x8D\x8D\x01\xD6\x8E\x08\x19\x8D\x8F\x01\xD6\x80\x09\x19\x8D\x91\x01\xD6\x82\x09\x1F\x92\x93\x01\xD6\x84\x09\x14\x92\xDD\x8D\x29\x9F\x44\xBC\x8E\xC6\x8C\x1C\x9C\x41\x85\x93\x71\x92\xEF\x81\x4C\xB9\x0B\x96\x01\x2B\x99\x4C\x83\x93\xCB\x92\x31\x9E\x46\x8F\x93\x1E\x91\xA0\x87\x09\x0E\x93\xC7\x90\x1B\x99\x4D\x84\x93\xDA\x90\x92\x08\x09\x19\x8D\x99\x00\x30\x93\x48\x95\x93\xDC\x91\x39\x91\x4D\x94\x93\xC8\x93\x36\x96\x6D\x1B\x02\x59\x8C\x27\x08\x4D\x8E\x68\x9D\x03\x3B\x95\x3A\x1E\x02\xFA\x8F\x27\x0A\x3F\xA0\x02\xF2\x92\x32\x93\x47\x21\x02\x59\x8E\x28\x09\x35\xA3\x02\x59\x8C\x29\x09\x35\xA5\x02\x59\x8E\x29\x0A\x3F\xA7\x02\x59\x8C\x2A\x02\x4E\x83\x15\xAA\x01", + "\xD6\x8B\x0A\x19\x8D\xAC\x01\xD6\x8D\x0A\x19\x8D\xAE\x03\x27\x9F\x0A\x19\x8D\xB0\x01\x3E\x90\x4D\x88\x2F\xB1\x01\xD6\x82\x0B\x1A\x94\x12\x30\x48\x99\x10\x34\x02\x59\x8D\x2D\x09\x35\xB6\x02\x59\x8F\x2D\x09\x35\xB8\x02\x59\x8D\x2E\x09\x35\xBA\x02\x22\x95\x37\x92\x47\xA4\x8E\xFA\x90\x4D\x9B\x51\xB6\x94\xE4\x93\xD7\x2B\x0B\x19\x8D\xBC\x01\x4C\x9E\x94\x7D\x02\x3E\x96\xB4\x0E\x0B\x3A\x8F\xBF\x02\xFE\x80\x0C\x01\x95\xE3\x93\xAA\x01\x0C\x19\x8D\xC2\x01\xD6\x83\x0C\x19\x8D\xC4\x01\xD6\x85\x0C\x19\x8D\xC6\x02\xFE\x87\x0C\x19\x8D\xC8\x03\x42\x98\x49\x0A\x03\x59\x8F\x32\x09\x35\x8C\x03\x59\x8D\x33\x09\x35\x8E\x03\x9F\x93\x33\x09\x35\x90\x03\x48\x94\x4E\x9F\xB7\x11\x03\x59\x8E\x34\x09\x56\xA7\x2D\xD3\x01\x5A\x94\x0D\x19\x8D\xD5\x01\xD6\x86\x0D\x19\x8D\xD7\x01\xD6\x88\x0D\x19\x8D\xD9\x01\xD6\x8A\x0D\x1F\x92\xDB\x01\xD6\x8C\x0D\x00\x8D\x98\x5A\x5A\x92\x53\xB5\x94\xC2\x91\x4E\x99\x54\x87\x96\x37\x94\x26\x12\x0E\x19\x8D\xE3\x03\x5B\x9F\x6B\x64\x03\x92\x94\x82\x05\x0E\x3A\x8F\xE6\x02\xFE\x87\x0E\x15\x96\xE8\x92\x41\x08\x0E\x19", + "\x8D\xE9\x01\xD6\x8A\x0E\x19\x8D\xEB\x01\xD6\x8C\x0E\x19\x8D\xED\x02\xFE\x8E\x0E\x19\x8D\xEF\x02\x56\x9F\x48\x31\x03\x59\x8E\x3C\x09\x35\xB3\x03\x59\x8C\x3D\x09\x35\xB5\x03\x9F\x92\x3D\x09\x35\xB7\x03\x9C\x96\x3A\x98\xBC\x38\x03\x59\x8D\x3E\x0D\x5B\xA9\x29\xFA\x01\x5A\x9B\x0F\x19\x8D\xFC\x01\xD6\x8D\x0F\x19\x8D\xFE\x00\xDA\x89\x35\x83\x08\xD1\x25\x00\x04\x20\x30\x8C\x74\x12\x00\x03\x5D\xB4\x8C\x03\x03\x75\x9F\x87\x0A\x96\x86\x96\x39\x9B\x58\x9E\x97\xDD\x97\x39\x9E\x5B\xB0\x20\x09\x02\x76\x99\xDF\x4A\x00\xE6\x95\xD0\x84\x3B\x8B\x00\xE9\x95\xD1\x81\x4E\x0C\x00\xED\x95\xA7\x0D\x00\x31\x97\xAB\x0A\x03\x04\x5F\x8C\x96\xE1\x13\x03\x07\x5F\x83\x04\x10\x03\x7E\x92\x10\x11\x00\xFE\x95\x40\x02\x01\x01\x98\x00\x03\x04\x04\x60\x94\x00\x04\x99\x8B\x05\x01\x04\x98\x16\x01\x7A\x9D\x35\x9D\x10\x18\x00\x81\x99\x01\x04\x98\x1A\x00\x81\x9B\x01\x04\x98\x1C\x01\x82\x99\x2F\x1D\x00\x04\x9A\x07\x0A\x61\x92\x93\xC8\x4F\x07\x04\x60\xA0\x00\x1F\x9B\xC9\x41\x02\x25\x98\xAF\x12\x08\x04\x60\xA3\x00\x04\x98\x09\x04\x60\xA5\x00\x04\x9A\x09", + "\x04\x60\xA7\x00\x04\x98\x0A\x08\x62\x96\x0D\x29\x00\x81\x9A\x02\x29\x97\x85\x95\x62\x99\x4E\x93\x93\xE3\x96\x8F\x98\x5F\xBF\x98\x33\x94\x26\x10\x03\x04\x98\x31\x03\x8D\x93\x53\xB2\x00\x4A\x9B\x98\x13\x03\x0D\x99\xA8\x04\x0D\x00\x65\x8A\x04\x35\x03\x94\x94\x64\xAE\x66\x04\x9B\x0D\x04\x60\xB8\x00\x04\x99\x0E\x04\x60\xBA\x00\x04\x9B\x0E\x06\x65\x86\x04\x3C\x00\x81\x9D\x03\x0E\x98\xF0\x8C\x81\x90\x04\x04\x98\x41\x00\x81\x92\x04\x04\x98\x43\x03\x98\x9D\x2C\x04\x01\x04\x99\x11\x02\x67\xA2\x97\x0B\x3E\x11\x04\x60\x87\x01\x77\x9B\xAE\x48\x04\x3D\x99\x74\x11\x12\x04\x60\x8A\x01\x04\x9B\x12\x04\x60\x8C\x01\x04\x99\x13\x04\x60\x8E\x01\x04\x9B\x13\x00\x68\xAD\x08\x50\x00\x81\x91\x05\x3C\x98\xDC\x96\x90\x90\x5E\x96\x9A\x78\x99\x91\x99\x41\x81\x99\x8F\x13\x15\x04\x60\x98\x01\x8F\x9A\x2D\x79\x05\x21\x9A\xA9\x12\x16\x00\x68\x9B\x01\x80\x98\x17\x04\x6A\x9D\x96\x1D\x11\x17\x04\x60\x9E\x01\x04\x9B\x17\x04\x60\xA0\x01\x04\x99\x18\x04\x60\xA2\x01\x80\x9B\x18\x04\x60\xA4\x01\x68\x9A\x40\x16\x06\x04\x98\x67\x00\x81\x98\x06\x04\x98", + "\x69\x00\x81\x9A\x06\x2B\x9A\x28\x0B\x1A\x04\x60\xAC\x01\xC8\x98\x90\x9B\xF0\x2D\x01\x04\x9A\x1B\x0D\x6C\x90\x40\x6F\x03\xB4\x95\x34\x44\x98\x71\x00\x81\x92\x07\x04\x98\x73\x00\x81\x94\x07\x04\x98\x75\x00\x81\x96\x07\x16\x9B\xA8\x07\x1D\x04\x60\xB8\x01\x94\x9B\x95\x9D\x58\x9B\x9A\xCE\x9A\xA6\x90\x62\x88\x96\xEC\x98\x07\x2E\x07\x04\x98\x7F\x00\xB9\x9E\x9F\x40\x02\xF6\x9B\xEC\x01\x08\x00\x9A\x82\x00\xA0\x93\x08\x39\x9B\x43\x99\xAC\x04\x08\x04\x98\x85\x00\x81\x96\x08\x04\x98\x87\x00\x81\x98\x08\x04\x98\x89\x00\xA0\x9A\x08\x04\x98\x8B\x01\xAF\x9A\x50\x0D\x02\x04\x9A\x23\x04\x60\x8F\x02\x04\x98\x24\x04\x60\x91\x02\x00\x9F\x40\x02\x09\x04\x98\x93\x01\xC7\x99\x69\xB6\x34\x94\x00\x81\x95\x09\x22\x9C\xF2\x3A\x25\x08\x72\x96\x0B\x97\x00\x81\x98\x09\x04\x98\x99\x00\x81\x9A\x09\x04\x98\x9B\x00\x81\x9C\x09\x04\x98\x9D\x03\xCA\x9E\x09\x04\x98\x9F\x01\xBA\x91\x70\x97\x9A\xF1\x98\xBC\x9F\x6E\xAB\x9B\x43\x9D\xA5\x91\x39\xA5\x02\x2B\x9C\xA6\x9F\x5D\xA3\x9C\x44\x9C\xAB\x9C\x74\x86\x9D\x1C\x36\x29\x09\x74\x81\x9D\x4D\x9C\xA7\x95", + "\x74\xAA\x9B\x50\x9E\xD3\x9B\x2B\x67\x02\x53\x9F\xD5\x9F\x73\x8F\x9D\x58\x9D\xD8\x9F\x75\x8B\x9D\x64\x9C\x00\x08\x0A\x1D\x9D\x5A\x9D\x78\x95\x76\x8A\x9D\x6A\x9D\xDB\x9C\x76\xB4\x68\xA9\x00\xDA\x96\x75\xA9\x9D\x6F\x9C\xD5\x99\x75\xB3\x9D\x78\x9F\x9D\x4A\x0A\x32\x9D\xED\x9A\xD0\x94\x77\xB6\x9D\x62\x9C\xD0\x9E\x75\x8D\x0B\xAB\x00\x81\x9C\x0A\x3E\x9C\x82\x9F\xDF\x93\x78\xA0\x9D\x63\x9E\xDB\x90\x78\x8D\x9E\xB2\x00\x81\x93\x0B\x3C\x9D\xA7\x68\x2D\x04\x79\x9B\x0E\xB5\x00\xA0\x96\x0B\x00\x9A\xB7\x03\xE5\x95\x75\x88\x09\xB8\x00\x81\x99\x0B\x04\x98\xBA\x00\x81\x9B\x0B\x04\x98\xBC\x00\x81\x9D\x0B\x00\x9A\xBE\x00\x81\x9F\x0B\x12\x9C\x36\x15\x30\x04\x60\x82\x03\x04\x9B\x30\x04\x60\x84\x03\x04\x99\x31\x0B\x72\x86\x03\x04\x9B\x31\x0E\x79\xB7\x9D\xDC\x20\x32\x04\x60\x89\x03\xBF\x9F\xDF\x2A\x0C\x05\x9F\x06\x07\x32\x04\x60\x8C\x03\x04\x99\x33\x04\x60\x8E\x03\x04\x9B\x33\x04\x60\x90\x03\x04\x99\x34\x08\x7C\x89\x9E\x79\x9E\xBB\x9A\x78\x9B\x9F\xD9\x9E\xDF\x9D\x7D\xAB\x1B\xD2\x00\x81\x93\x0D\x17\x9F\x02\x64\x35\x04\x7E\x95\x0B\xD5", + "\x00\xA0\x96\x0D\x00\x9A\xD7\x03\xF9\x9E\x78\x88\x08\xD8\x00\x81\x99\x0D\x04\x98\xDA\x00\x81\x9B\x0D\x04\x98\xDC\x00\x81\x9D\x0D\x00\x9A\xDE\x00\x81\x9F\x0D\x30\x9E\x3F\x15\x38\x04\x60\xA2\x03\x04\x9B\x38\x04\x60\xA4\x03\x04\x99\x39\x0B\x72\xA6\x03\x04\x9B\x39\x0E\x7E\xB5\x9D\xFD\x20\x3A\x04\x60\xA9\x03\x0F\xA2\x63\x2A\x0E\x2E\x9F\xEB\x00\x81\x9C\x0E\x04\x98\xED\x00\x81\x9E\x0E\x04\x98\xEF\x00\x81\x90\x0F\x04\x98\xF1\x03\xCA\x92\x0F\x04\x98\xF3\x01\x05\xAB\x78\xAB\x9D\x8F\x9C\xF6\x9D\x77\x9F\x9E\xDA\x9F\xF7\x90\x7C\xB1\xA0\xE0\x54\x3D\x0A\x82\x9C\x9F\x2F\xA3\x0C\xAE\x7D\xB7\x49\xF5\x00\x81\x96\x0F\x37\xA0\x32\xA1\xE0\x9C\x78\xAE\xA0\x34\xA1\x11\xAB\x83\xB3\x94\xF7\x00\x81\x98\x0F\x00\xA1\xE0\x55\x3E\x0C\x84\x9D\x09\xFA\x00\xA0\x9B\x0F\x00\x9A\xFC\x03\x13\xA7\x84\xB9\x09\xFD\x00\x81\x9E\x0F\x09\x98\x04\x99\x8A\x01\x5D\xAA\x08\xD4\x96\x00\x00\x86\xB4\x8C\x2D\x0B\x00\x03\x86\xB9\x8C\x04\x03\x19\xA1\x10\x0F\x98\x6A\x12\x01\x0A\x86\xBD\x77\x07\x03\x1B\xAF\x1C\x08\x00\x72\xA1\x57\x65\x87\x9B\x05\x77\xA3\xEF\x0B\x00", + "\x39\xA1\x51\x8C\x1F\xA3\x84\x82\x43\x0D\x02\x1F\xA1\x10\x0E\x00\x82\xA2\xAB\x5F\x00\x05\xA2\x98\x10\x04\x05\x88\x91\x00\x85\xA2\x04\x05\x88\x93\x00\x85\xA0\x05\x05\x88\x95\x00\x85\xA2\x05\x08\x88\xAD\xA0\x7F\xA0\x0B\xAB\x82\xAF\x9F\x38\xA2\x11\xA0\x83\xB4\x1E\x17\x01\x21\xA8\x01\x17\xA2\xB4\x8D\x06\x04\x8A\x8E\x18\x1A\x03\x29\xA8\x22\x1B\x00\xAA\xA0\x92\x0C\x01\x2D\xA2\x9E\xA1\x38\x1D\x01\x05\xA2\x1E\x01\x21\xAF\x01\x05\xA2\x20\x01\x21\xA1\x02\x05\xA2\x22\x00\x2C\xA9\x27\x23\x00\x85\xA0\x09\x0F\x86\xAC\xA1\x73\x12\x09\x05\x88\xA7\x00\x85\xA0\x0A\x05\x88\xA9\x00\x85\xA2\x0A\x0E\x8B\xA3\x0A\x2B\x01\x21\xAC\x02\x0F\xA3\x3A\xA2\xD3\x2D\x02\x05\xA2\x2E\x00\x35\xAC\x00\x6F\x00\xDA\xA3\xEF\x00\x03\x05\xA2\x31\x01\x21\xA2\x03\x05\xA2\x33\x01\x21\xA4\x03\x05\xA2\x35\x01\x21\xA6\x03\x1D\xA3\x11\x55\x21\xA8\x03\x2C\xA3\x99\xA0\x27\xA1\x84\x8D\x9E\x10\xA1\x27\xA7\x85\x9F\xA2\xF8\xA1\x35\xA1\xFD\x39\x00\xF0\xA2\x26\xA6\x8F\xB9\xA3\x42\xA1\xAE\x5A\x03\x05\xA2\x3B\x01\x3F\xA2\x8F\xB9\xA0\x01\xA7\x41\xA1\x8B\x89\xA4\xF5\xA3", + "\x78\x9C\x03\x05\xA2\x3D\x02\x41\xA1\xCC\x7E\x00\x12\xA7\x23\x1F\x03\x06\xA4\x40\x02\x41\xA1\x04\x15\xA4\x9B\xA0\xBF\x02\x04\x05\xA2\x43\x01\x21\xA4\x04\x05\xA2\x45\x01\x21\xA6\x04\x05\xA2\x47\x02\x41\xA8\x04\x05\xA2\x49\x03\x30\xA1\x4E\x0B\x01\x85\xA0\x13\x05\x88\x8D\x01\x85\xA2\x13\x05\x88\x8F\x01\x1C\xA4\x86\x00\x05\x05\xA2\x51\x01\x4E\xA3\x8F\xBD\x38\x52\x01\x21\xA3\x05\x3E\xA4\x0B\x3C\x15\x04\x94\xA5\x0E\x55\x01\x21\xA6\x05\x05\xA2\x57\x01\x21\xA8\x05\x05\xA2\x59\x01\x21\xAA\x05\x05\xA2\x5B\x03\x51\xA7\x8F\xBA\xA3\x0C\xA4\x26\xAE\x8F\xBF\xA4\xF1\xA1\x43\xA8\x24\x1C\x01\x85\xA1\x17\x06\x95\x90\x70\x5E\x03\x58\xA9\x39\x1F\x01\x06\xA4\x18\x06\x90\xA1\x01\x66\xA5\x56\xA8\x20\x22\x01\x85\xA3\x18\x05\x88\xA4\x01\x85\xA1\x19\x05\x88\xA6\x01\x85\xA3\x19\x06\x90\xA8\x01\x85\xA1\x1A\x0E\x92\x82\x14\x6B\x01\x21\xAC\x06\x05\xA2\x6D\x01\x21\xAE\x06\x05\xA2\x6F\x01\x5B\xA7\x46\x85\xA2\x71\x02\x62\xA4\x84\xB6\x34\x72\x01\x21\xA3\x07\x0E\xA6\x28\x34\x1D\x04\x99\x95\x0B\x75\x01\x21\xA6\x07\x05\xA2\x77\x01\x21\xA8\x07\x05", + "\xA2\x79\x01\x21\xAA\x07\x05\xA2\x7B\x03\x65\xAB\xF3\x45\xA2\x7D\x02\x69\xAE\x95\x8B\xA4\xF4\xA2\x56\xAA\x90\x97\xA5\x6E\xA7\x3F\xA8\x95\xAD\xA6\x1C\x36\x1F\x0A\x9A\xAE\xA6\xAB\xA4\x6C\xA4\x9B\xA5\x30\x7F\x01\x21\xA0\x08\x37\xA6\x1D\xA4\x6E\xA2\x9C\x81\xA7\xC4\xA6\x6C\xA1\x9B\x8C\x50\x81\x01\x21\xA2\x08\x00\xA7\x59\x6B\x20\x0C\x9C\xBE\x0C\x84\x02\x41\xA5\x08\x06\xA4\x86\x03\x73\xA8\x90\xB1\x0A\x87\x01\x21\xA8\x08\x05\xA2\x89\x01\x21\xAA\x08\x05\xA2\x8B\x01\x21\xAC\x08\x06\xA4\x8D\x01\x21\xAE\x08\x3F\xA5\x0A\x14\x24\x05\x88\x91\x02\x85\xA2\x24\x05\x88\x93\x02\x85\xA0\x25\x06\x9A\x95\x02\x85\xA2\x25\x06\x9D\xAC\xA6\xD5\x2F\x25\x05\x88\x98\x02\xF7\xA6\x4D\x39\x09\x3D\xA7\xA8\x06\x26\x05\x88\x9B\x02\x85\xA0\x27\x05\x88\x9D\x02\x85\xA2\x27\x05\x88\x9F\x02\x85\xA0\x28\x00\xA0\xB3\xA6\x8F\xA4\x40\xAB\x9B\x9C\xA5\x5B\xA7\x75\xA0\x5E\xA1\x02\x85\xA2\x28\x0F\xA0\x99\x5C\xA3\x03\x86\xA1\x2B\x24\x02\x06\xA5\x29\x06\x90\xA6\x02\x1E\xA9\x84\xAA\x10\x27\x02\x85\xA0\x2A\x05\x88\xA9\x02\x85\xA2\x2A\x05\x88\xAB\x02\x85\xA0\x2B", + "\x06\x90\xAD\x02\x85\xA2\x2B\x08\x9E\xB6\x14\xB0\x01\x21\xA1\x0B\x05\xA2\xB2\x01\x21\xA3\x0B\x05\xA2\xB4\x02\x69\xA5\x0B\x05\xA2\xB6\x01\x89\xAD\x95\x80\x21\xB7\x01\x21\xA8\x0B\x06\xA9\xC8\x2D\x2E\x0C\xA4\x80\x00\xBA\x01\x21\xAB\x0B\x05\xA2\xBC\x01\x21\xAD\x0B\x05\xA2\xBE\x01\x21\xAF\x0B\x05\xA2\xC0\x02\x69\xA1\x0C\x05\xA2\xC2\x03\x93\xA9\x9B\x92\xA8\x26\xAB\x71\xA6\xA1\x87\xA9\xC5\xA4\x85\xAE\xE3\x03\x03\x62\xAB\x70\xA6\x9C\x93\xA8\x67\xA9\x85\xA8\x9F\x8A\x25\xC4\x01\x21\xA5\x0C\x2D\xA9\x69\xA9\x9C\xAF\x9A\xA4\xA9\x68\xAB\x9B\xA5\xA6\x8C\x41\xC6\x01\x21\xA7\x0C\x38\xA9\xC3\x58\x32\x04\xA8\xA8\x08\xC9\x02\x41\xAA\x0C\x06\xA4\xCB\x03\xA1\xAA\xA7\x8C\x03\x85\xA1\x33\x05\x88\x8E\x03\x85\xA3\x33\x05\x88\x90\x03\x85\xA1\x34\x06\x90\x92\x03\x85\xA3\x34\x07\xA3\xBF\x14\xD5\x01\x21\xA6\x0D\x05\xA2\xD7\x01\x21\xA8\x0D\x05\xA2\xD9\x02\x69\xAA\x0D\x05\xA2\xDB\x02\xA3\xA3\xA7\xAA\x27\xDC\x01\x21\xAD\x0D\x2E\xAA\x4A\x2E\x37\x0F\xA4\x9F\x03\x85\xA0\x38\x05\x88\xA1\x03\x85\xA2\x38\x05\x88\xA3\x03\x85\xA0\x39\x05\x88\xA5\x03", + "\xA6\xA6\x39\x05\x88\xA7\x03\xB4\xA8\x9F\xA2\xA7\xBA\xA6\x7F\xA9\xB3\xAD\xA7\xAA\xA9\x63\xA8\x84\xAF\xAC\xBA\xA9\xD1\xAA\x99\xAF\xAA\xBB\xA9\x61\x18\x3A\x05\x88\xA9\x03\xC9\xA8\xDB\x4A\x0E\x1D\xAB\x09\x07\x3A\x06\x90\xAC\x03\x06\xA5\x3B\x00\xAE\x81\x8A\xEE\x01\x21\xAF\x0E\x05\xA2\xF0\x01\x21\xA1\x0F\x05\xA2\xF2\x01\x21\xA3\x0F\x06\xA4\xF4\x01\x21\xA5\x0F\x1F\xAA\x42\x17\x3D\x05\x88\xB8\x03\x85\xA1\x3E\x05\x88\xBA\x03\x85\xA3\x3E\x06\x9A\xBC\x03\x85\xA1\x3F\x07\xAE\x8E\xAB\xC4\x22\x3F\x08\x88\x87\xAC\x4A\x24\x00\x08\x6B\x6E\x97\xB3\x0D\x00\x0F\xB0\xB3\x21\x13\xAE\x1D\x25\xB1\xB9\x21\x17\xAC\x1F\x29\xB1\xBF\x21\x1B\xAE\x20\x2D\xB1\xB0\x20\x08\x03\xC7\xA9\x00\x1F\xAC\x8C\x8E\x02\x04\xB2\x9D\x22\x27\xAC\x82\x0C\x00\x29\xAC\x18\x09\x03\x0C\xB2\x90\xAB\x8F\x12\x03\x0F\xB1\x8F\x00\x1F\xAC\x04\x0F\xB1\x91\x00\x1F\xAE\x04\x0F\xB1\x93\x00\x2F\xAC\x92\x04\x01\x1F\xAC\x15\x00\xAE\x54\x8C\xB4\x11\x17\x03\xC7\xA8\x01\x1F\xAC\x19\x03\xC7\xAA\x01\x1F\xAC\x1B\x01\xCF\xA5\x3A\x1C\x00\x1F\xAD\x07\x0E\xB4\x8C\xAB\xC2\x42\x07\x0F", + "\xB1\x9F\x00\x53\xAC\x30\x40\x02\x19\xAD\x99\x0D\x08\x0F\xB1\xA2\x00\x1F\xAF\x08\x0F\xB1\xA4\x00\x1F\xAD\x09\x0F\xB1\xA6\x00\x1F\xAF\x09\x0C\xB5\xAB\x0A\x28\x03\xDA\xA0\xA7\x97\xAB\xD5\xAB\xDB\xA4\xB5\x8B\xAB\xCA\xA8\xB6\xA3\x3A\xA9\x00\x6E\xAC\xC2\xA6\xB7\xB2\xAD\x75\xAD\xDC\xAA\xB7\xBE\xAD\x01\x22\x0A\x09\xB7\x93\xAB\x70\xAE\x9B\xA0\xB3\xB9\xA9\x85\xAE\xD7\x4B\x02\x1F\xAC\x2C\x03\xE0\xA2\x1D\xAD\x00\x8E\xAF\x50\x1E\x02\x11\xAE\x2F\x01\xE4\xA0\x03\x11\xAE\x80\xAD\xB5\x01\x03\x1F\xAC\x32\x03\xC7\xA3\x03\x1F\xAC\x34\x03\xC7\xA5\x03\x1F\xAC\x36\x01\xE4\xA7\x03\x1F\xAC\x38\x02\xD0\xA1\x4E\x3A\x00\x1F\xAF\x0E\x0F\xB1\xBC\x00\x1F\xAD\x0F\x0F\xB1\xBE\x00\x98\xAD\x76\x0F\x03\x1F\xAC\x40\x01\xED\xA8\xB8\xB6\x34\x41\x03\xC7\xA2\x04\x3A\xAE\xCA\x3F\x10\x00\xBC\xBE\x0C\x44\x03\xC7\xA5\x04\x1F\xAC\x46\x03\xC7\xA7\x04\x1F\xAC\x48\x03\xC7\xA9\x04\x1F\xAC\x4A\x03\xF0\xA8\x24\x0B\x01\x1F\xAC\x13\x02\xBD\x89\xAE\x7E\xA8\xE1\xA3\xB7\xBB\xAD\x7F\xAE\xE1\xA4\xAD\x9E\xAF\xD8\xAF\xE1\xA9\xBD\xB4\xAD\xD2\xA8\xF9\xA8\x99\x0D\x01\x1F", + "\xAE\x13\x07\xBD\x8A\x7C\x4F\x03\xFA\xA3\x3C\x10\x01\x91\xAD\x14\x01\xB9\x92\x01\xEE\xAD\xF9\xA0\x00\x13\x01\x1F\xAC\x15\x0F\xB1\x95\x01\x1F\xAE\x15\x0F\xB1\x97\x01\x1F\xAC\x16\x01\xB9\x99\x01\x1F\xAE\x16\x0A\xBA\x82\x14\x5C\x03\xC7\xAD\x05\x1F\xAC\x5E\x03\xC7\xAF\x05\x1F\xAC\x60\x01\xFD\xA9\x10\x21\x01\x1F\xAE\x18\x02\xC1\xBC\xAD\x12\x27\x18\x0F\xB1\xA4\x01\x17\xB1\x8F\x35\x06\x1D\xB0\xD2\x0A\x19\x0F\xB1\xA7\x01\x1F\xAC\x1A\x0F\xB1\xA9\x01\x1F\xAE\x1A\x0F\xB1\xAB\x01\x1F\xAC\x1B\x00\xC2\x81\x04\x6D\x03\x0B\xBC\xBD\x9A\xAF\x7D\xAC\xF8\xAB\xBD\x99\xAE\x33\xB2\xF9\xAE\xDA\x2E\x01\x32\xB0\x0E\xBE\xC3\xB6\xB0\x35\xB3\xEE\xA1\xC4\xA8\x28\x6F\x03\xC7\xA0\x07\x3D\xB0\x89\x69\x1C\x08\xC4\x82\x0C\x72\x01\xE4\xA3\x07\x11\xAE\x74\x03\x12\xB3\xBE\x80\x00\x75\x03\xC7\xA6\x07\x1F\xAC\x77\x03\xC7\xA8\x07\x1F\xAC\x79\x03\xC7\xAA\x07\x11\xAE\x7B\x03\xC7\xAC\x07\x07\xB0\x0A\x16\x1F\x0F\xB1\xBF\x01\x1F\xAC\x20\x0F\xB1\x81\x02\x1F\xAE\x20\x02\xC3\x83\x02\x1F\xAC\x21\x02\xC5\xA2\xAF\xE3\x29\x21\x0F\xB1\x86\x02\x73\xB0\x0C\x37\x08", + "\x39\xB1\x5D\x08\x22\x0F\xB1\x89\x02\x1F\xAE\x22\x0F\xB1\x8B\x02\x1F\xAC\x23\x0F\xB1\x8D\x02\x1F\xAE\x23\x0C\xC7\xB7\xB0\x40\xB2\xFD\xAF\xC3\x82\xB1\x8E\xB1\x23\xB8\x99\x0F\x02\x8B\xB3\x10\xB4\xC7\x9F\xAF\x90\xB2\xB5\xAC\xC8\x99\xB2\x18\xB2\x26\xB6\xC9\x98\xB2\x53\xB0\x48\x20\x09\x15\xB2\x91\xB0\x27\xBD\xBD\xA6\xB2\x34\xB1\x29\xB1\xCA\x92\xB2\x9D\xB1\xAE\x61\x09\x1F\xAC\x92\x00\x29\xB9\x71\x53\x02\xB2\xB1\xAC\x04\x09\x11\xAE\x95\x01\xE4\xA6\x09\x35\xB2\x7A\xAF\x25\x0F\xB1\x98\x02\x1F\xAD\x26\x0F\xB1\x9A\x02\x1F\xAF\x26\x0F\xB1\x9C\x02\x91\xAD\x27\x0F\xB1\x9E\x02\x64\xB2\x4D\x10\x0A\x1F\xAC\xA1\x03\xC7\xA2\x0A\x1F\xAC\xA3\x03\xC7\xA4\x0A\x32\xB0\xA5\x03\xC7\xA6\x0A\x3C\xB2\xA9\xB2\xFB\x17\x0A\x1F\xAC\xA8\x00\x37\xB8\xBC\x29\x02\xE2\xB0\x00\x0A\x0A\x1F\xAC\xAB\x03\xC7\xAC\x0A\x1F\xAC\xAD\x03\xC7\xAE\x0A\x1F\xAC\xAF\x03\xC7\xA0\x0B\x25\xB3\x8F\xB2\xF2\x31\x0B\x34\xB3\xAC\xB3\x29\xBB\xCA\xA8\xB2\x3A\xB1\x81\x42\x0B\x38\xB3\xFC\xB1\x0E\xB2\xD0\xB5\xB3\x97\xB1\xF8\xA0\xCA\x85\xB4\x12\x67\x2C\x00\xD0\xBB\xB3\x0C\xB4", + "\x42\xBF\xC9\x86\xB4\x10\xB7\x26\xB3\x6C\x74\x02\x0B\xB6\x43\xBA\xCA\x96\xB4\x9E\xB3\x45\xB7\xD0\x9B\xB4\x11\xB7\x43\xB2\xD1\x98\xB4\xAD\xB2\x3E\xBE\x64\x35\x02\x1F\xAE\x2D\x05\xD1\xA0\x57\xB7\x03\x49\xBD\x25\x38\x02\x91\xAD\x2E\x0D\xCC\x82\x04\xBB\x03\xC7\xAC\x0B\x2A\xB4\xDB\xAD\x2F\x0F\xB1\xBE\x02\x1F\xAF\x2F\x0F\xB1\x80\x03\x1F\xAD\x30\x0F\xB1\x82\x03\x91\xAF\x30\x0F\xB1\x84\x03\x2F\xB6\x50\x16\x0C\x1F\xAC\xC7\x03\xC7\xA8\x0C\x1F\xAC\xC9\x03\xC7\xAA\x0C\x32\xB0\xCB\x03\xC7\xAC\x0C\x1F\xAC\xCD\x03\xC7\xAE\x0C\x05\xB5\x00\x00\x34\x0F\xB1\x91\x03\x1F\xAE\x34\x0F\xB1\x93\x03\x1F\xAC\x35\x0F\xB1\x95\x03\x91\xAE\x35\x02\xC3\x97\x03\x1F\xAC\x36\x01\xB9\x99\x03\x34\xB7\xBA\x1A\x0D\x1F\xAC\xDB\x01\x5B\xB9\x39\x1C\x03\x1F\xAD\x37\x0F\xB1\x9E\x03\x91\xAF\x37\x0F\xB1\xA0\x03\x91\xAD\x38\x0F\xB1\xA2\x03\x1F\xAF\x38\x08\xD5\xA5\x03\x1F\xAE\x39\x0F\xB1\xA7\x03\x1F\xAC\x3A\x0F\xB1\xA9\x03\x72\xB7\xAA\x0A\x0E\x1F\xAC\xEB\x01\x63\xB0\x45\x6C\x03\x92\xB7\x40\x0D\x0E\x11\xAE\xEE\x00\x56\xB0\x0F\x1F\xAC\xF1\x01\x65\xBD\x3D\xB2", + "\x03\x1F\xAF\x3C\x0F\xB1\xB4\x03\x1F\xAD\x3D\x0F\xB1\xB6\x03\x1F\xAF\x3D\x01\xB9\xB8\x03\x1F\xAD\x3E\x08\xD5\x98\x12\xFB\x03\xC7\xAC\x0F\x1F\xAC\xFD\x03\xC7\xAE\x0F\x24\xAC\x32\xB2\xD6\x81\x5D\xAB\x09\x61\xA0\x6F\xB8\x5D\xBE\xB6\xF2\x77\xA7\x50\xDC\xB9\x77\x06\x03\x70\xB0\x87\x86\xB7\x73\xA0\x72\xBD\x95\x4A\xB7\x5B\x04\x73\xB1\x2B\x0B\x00\xCE\xB5\x07\x1C\x00\x11\xB7\x54\x8C\x75\xB7\x35\x96\xB7\x3E\x3B\x03\x08\xDD\x90\x00\xD8\xB4\x48\x21\x01\x18\xB7\x12\x00\x76\xB3\x01\x1D\xB7\xD9\x04\x05\x08\xDD\x95\x00\xE4\xB4\x82\x06\x01\x18\xB7\x17\x00\x76\xB8\x01\x06\xB7\x99\x06\x06\x08\xDD\x9B\x00\xD8\xB4\x07\x08\xDD\x9D\x00\xD8\xB6\x07\x09\xDE\x8D\xB4\xFF\x77\x07\x0B\xDF\xA0\xB4\x22\xB4\x47\xBF\xD1\x82\xB8\x10\x70\x08\x0F\xDF\x84\xB8\x1A\xB5\x47\xB9\xE0\x83\xB8\x0A\xB9\x46\xBE\xE0\x90\x51\x21\x03\x81\xBD\xE0\xA1\xB4\xDD\xB0\x85\xBD\xCF\x95\xB8\x01\xB8\x07\x22\x02\x12\xB8\x0C\xB9\x87\xBE\xD1\x9F\xB8\x0B\xB8\x88\xBF\xE0\xB1\x51\x23\x00\x87\xB2\xE2\x96\xB8\x02\xB4\x09\x06\xE2\xA1\xB8\x2C\xBB\x88\xB8\xE1\xAF\xB8\x17\xB9\x8C", + "\xB3\xD0\xB9\xB3\xDD\x8D\x09\x0B\xE2\xAE\xB8\x32\xB8\x41\xB8\xE0\xB8\xB8\x33\xB9\x40\xB2\x7B\x26\x00\x37\xB8\x8A\xBA\xE3\x93\xB8\x19\xBA\x87\xBD\xE2\x82\xB9\x34\xB9\x8E\xB9\xE4\xBD\xB8\x53\xB3\x09\x01\xE4\x85\xB9\x27\xB8\x94\xB7\xE4\x92\xB9\x3C\xBB\x90\xB6\xE4\x95\xB9\xAE\xA4\x0A\x08\xDD\xA9\x00\x4F\xB9\x57\x7A\x02\x1D\xB9\x42\x17\x0A\x00\xE6\x80\x00\x2C\x03\x98\xBD\x02\x23\xB9\x56\xB8\x6A\x0E\x02\x18\xB7\x2F\x00\x76\xB0\x03\x18\xB7\x31\x00\x76\xB2\x03\x18\xB7\x33\x03\x98\xB4\x03\x18\xB7\x35\x00\x7C\xB1\x4E\x37\x00\xD8\xB4\x0E\x08\xDD\xB9\x00\xD8\xB6\x0E\x08\xDD\xBB\x00\x68\xB9\x76\x0C\x03\x18\xB7\x3D\x03\x98\xBE\x03\x05\xBA\x3E\xB8\xBE\x1F\x03\x18\xB7\x40\x00\xA3\xBA\xFC\x01\x01\x92\xBA\xCF\x02\x04\x18\xB7\x43\x00\x76\xB4\x04\x18\xB7\x45\x00\x76\xB6\x04\x18\xB7\x47\x00\x76\xB8\x04\x15\xBA\x3B\xB8\x92\xBD\xE8\xA7\xBA\xFC\xB4\x91\xBD\x3D\x89\x01\xA4\xBA\xAA\xBB\x2B\x4A\x01\xAD\xBA\xD2\x2B\x04\x31\xBA\xA8\x04\x13\x08\xDD\x8D\x01\xD8\xB6\x13\x08\xDD\x8F\x01\xD8\xB4\x14\x08\xDD\x91\x01\xD8\xB6\x14\x08\xDD\x93\x01", + "\xD8\xB4\x15\x08\xDD\x95\x01\xD8\xB6\x15\x04\xEB\xB6\xAF\x57\x03\xB2\xBB\x2A\x18\x01\xCE\xBA\xA9\xB9\xEA\x9B\x50\x59\x01\xB4\xB1\xC4\x58\xB7\x5B\x02\xB5\xB0\xA5\x5C\x01\xDA\xBB\x1C\x1D\x05\x23\xB9\x5E\x03\x98\xBF\x05\x1D\xBB\x4C\xB8\x8A\x00\x06\x18\xB7\x61\x00\x76\xB2\x06\x18\xB7\x63\x00\x76\xB4\x06\x18\xB7\x65\x03\x98\xB6\x06\x18\xB7\x67\x02\x9E\xB2\x50\x29\x01\xD8\xB6\x1A\x08\xDD\xAB\x01\xD8\xB4\x1B\x08\xDD\xAD\x01\xE4\xBA\x1B\x08\xDD\xAF\x01\xE4\xB9\x9A\xBA\x7B\x30\x01\xD8\xB5\x1C\x05\xF0\xAC\x2F\x72\x03\xC2\xB8\x20\x33\x01\xD8\xB4\x1D\x08\xDD\xB5\x01\xD8\xB6\x1D\x08\xDD\xB7\x01\xD8\xB4\x1E\x08\xDD\xB9\x01\x0E\xBF\xB4\xB0\x0C\x7A\x01\x1D\xBC\x80\xB0\xE3\xA5\xBB\xA5\xB8\x95\xB2\xED\xA2\xBC\x42\x17\x1E\x01\xF2\xA5\xBC\x23\xBC\xE3\x8C\x07\x2B\xBC\xAE\xB8\xC9\xB3\xD7\x3D\x01\x30\xBF\x95\xB7\xF2\xAC\xBC\x4A\xB8\xAA\xB8\xF2\xB2\xBC\x63\x1A\x1F\x05\xF3\x91\xB9\x2D\xBF\x92\xB6\xF0\xBF\x2D\x7F\x03\xCF\xB3\xE5\x81\xBD\x3A\xBC\xCE\xB6\x2D\x00\x02\x46\xBC\x96\xB9\xF4\xB1\xBC\x43\xBF\xCD\xB0\xF5\x8F\x12\x81\x01\xD3\xB2", + "\xF5\xB6\xBC\x26\xBD\xD6\xB8\xF4\x9E\xBC\x47\xBE\x50\x12\x08\x16\xBD\x5A\xBD\xCE\xBC\xF5\x8E\xBD\x63\xBF\xD5\xB0\xF4\x88\x2F\x83\x00\xD8\xBB\xF5\xBB\xBC\x51\xBD\xD8\xBC\xF3\xA7\xBD\x6F\xBD\xD7\xB1\xF7\xBC\xB8\x84\x02\xDA\xB1\x10\x05\x02\x76\xBF\xDC\xB6\xF6\xB2\xBD\x6D\xBF\xDA\xBA\xF4\xBD\xBD\x62\xBC\xDB\xB2\xF4\x83\xBE\x4F\xBC\xD6\xBE\xF7\x93\xBD\x9B\xA2\x21\x09\xF7\xA7\x2D\x87\x00\x76\xB8\x08\x0B\xBE\xBF\x59\x22\x00\xF9\x88\x08\x8A\x03\x98\xBB\x08\x23\xB9\x8C\x03\xE4\xB9\x76\x8D\x02\xD8\xB6\x23\x08\xDD\x8F\x02\xD8\xB4\x24\x08\xDD\x91\x02\xD8\xB6\x24\x03\xE6\x93\x02\xD8\xB4\x25\x06\xEF\x8A\x14\x96\x00\x76\xB7\x09\x18\xB7\x98\x00\x76\xB9\x09\x18\xB7\x9A\x00\xB9\xBB\x09\x18\xB7\x9C\x02\xE6\xB2\xF8\x91\x1E\x9D\x00\x76\xBE\x09\x3A\xBE\x69\x2B\x27\x09\xF7\xA0\x02\xD8\xB5\x28\x08\xDD\xA2\x02\xD8\xB7\x28\x08\xDD\xA4\x02\xD8\xB5\x29\x08\xDD\xA6\x02\xC0\xBC\xE2\xBA\xFC\x27\x02\xD1\xBE\xE1\xB1\xF8\xBF\xBD\x84\xBD\xD9\xB5\xBD\x28\x02\xD5\xBC\xDC\xB0\xF8\xBA\xBD\x6E\xBF\xF7\xB2\xFE\x99\xBF\xBB\xBF\xC9\x49\x0A\x1D\xBF\x7C", + "\xBC\xF9\xB8\xFD\x85\xBE\xDE\xBD\x77\x1A\x0A\x18\xB7\xAB\x00\xFA\xB5\x35\x6C\x02\xF2\xBE\x41\x0D\x0A\x23\xB9\xAE\x03\x98\xBF\x0A\x35\xBF\xE0\x94\x2C\x08\xDD\xB1\x02\xD8\xB6\x2C\x08\xDD\xB3\x02\xD8\xB4\x2D\x08\xDD\xB5\x02\x63\xBA\x2D\x08\xDD\xB7\x02\xAB\xBE\x4D\x19\x0B\x18\xB7\xBA\x00\x76\xBB\x0B\x18\xB7\xBC\x00\x76\xBD\x0B\x24\xBB\xBE\x00\x76\xBF\x0B\x3C\xBF\x87\xBF\x98\x10\x0C\x18\xB7\xC1\x00\x07\xCA\x9E\x02\x03\x79\xBF\x30\x08\xDD\x84\x03\xD8\xB5\x31\x08\xDD\x86\x03\xD8\xB7\x31\x08\xDD\x88\x03\xD8\xB5\x32\x02\x02\xE0\xBF\x1D\xC1\xFB\xBC\xFE\xAE\x86\xCA\x03\x0C\xC3\xFE\xB7\xC0\x64\xBD\xF9\xBE\x03\xC8\x09\xCB\x01\x03\xC5\x03\xE9\xBF\x3C\xC3\xDE\xBD\x03\xE9\x29\xCD\x02\x0E\xCA\xFE\x92\xBF\x3F\xC0\x13\xCB\xFE\xA8\x28\xCE\x00\x76\xBF\x0C\x0A\xC1\x5E\x4C\x34\x03\x03\xD1\x03\x63\xBA\x34\x03\xE6\x93\x03\x54\xC3\xC9\x84\x0D\x18\xB7\xD5\x00\x76\xB6\x0D\x18\xB7\xD7\x00\x76\xB8\x0D\x18\xB7\xD9\x03\x98\xBA\x0D\x18\xB7\xDB\x02\x10\xC2\x54\x1D\x03\xD8\xB6\x37\x08\xDD\x9F\x03\xD8\xB4\x38\x08\xDD\xA1\x03\xE4\xBA\x38\x08\xDD", + "\xA3\x03\x5D\xC1\x13\xC3\x66\x24\x03\xD8\xB5\x39\x0D\x07\xDC\x23\xE6\x01\xDE\xB7\x0E\x18\xB7\xE8\x00\x76\xB9\x0E\x18\xB7\xEA\x00\x76\xBB\x0E\x18\xB7\xEC\x00\x76\xBD\x0E\x03\xC2\x4E\xC0\x04\x4E\x0E\x14\xC2\xD6\xBC\x0D\xC5\x76\xAF\x03\xD8\xB4\x3C\x08\x09\xF6\xC0\xDA\xBF\x10\xCC\x00\x71\x03\x9F\xC0\x11\xC1\x0A\xCA\x68\xF2\x00\x76\xB3\x0F\x25\xC2\x47\xC1\x25\xC9\x09\xCE\x4D\xF4\x00\x2B\xC6\x04\xF3\xC2\xE1\xBF\x12\xCF\x0A\xF6\xC2\x94\x7D\x3D\x02\x0B\xF5\xC2\x45\xC0\x2F\xC7\x0A\xDA\xC2\x74\x12\x3D\x0B\x0B\xE2\xC2\xB4\xC0\x31\xCE\x0B\xFE\xC1\xA0\xC0\x32\xCE\x1A\xB7\x03\xC3\xC3\xF5\xBE\x0A\xC9\xC3\x4F\xC2\x32\xCD\x0A\xF7\xC2\x41\x18\x3E\x0D\x0C\xC0\xC3\x3B\xC3\x2F\xC9\x0D\xD2\xC3\xC5\xC2\x74\x89\x0F\x17\xC3\xDB\xC1\x34\xC2\x0E\xCF\xC3\xA6\xC0\x37\xC1\x47\x7A\x03\xE0\xC0\x2E\xC5\x0E\xE3\xC3\xD4\xC2\x36\xCA\x0E\xD3\xC3\xD0\xC0\x39\xC3\x3B\x3B\x03\xE9\xC1\x2F\xCD\xD5\x7C\x03\x63\xB9\x3F\x05\x0F\xEE\xC3\xF6\xC2\x33\xCD\x0E\xE6\xC3\xC6\xC1\x40\xC9\xB0\xBB\xC3\x00\xC6\x3F\xC1\x0F\xFF\xC3\xEC\xC3\x41\xC2\xC2\x44\xC4\x09\xC7", + "\x3A\xC2\x0F\xDD\xC3\xD8\xC3\x3B\xC0\x11\xCC\x8E\x00\x02\xC9\x04\x5D\xAB\x19\x01\x02\x45\xC4\x86\x92\xC4\xC7\xC1\x43\xC0\x0F\xCE\xC4\x08\xC7\x43\xCD\x11\xE2\xC4\x02\xC5\x44\xC1\xD0\x82\x00\x1A\xC5\xCE\x81\x0E\xE4\xC4\x06\xC4\x48\xCA\x10\xEE\xC4\xAD\x5B\x00\x09\x12\xFD\x8C\x95\x68\x01\x03\x13\xFD\x77\x05\x03\x4D\xC0\xB1\x8B\x75\x06\x02\x4E\xCD\x29\x07\x00\x3E\xC7\xEC\x08\x00\x01\xC5\x3E\x34\x51\xC6\xE1\x46\xC5\x25\xC5\x8B\x0B\x00\x08\xC5\x60\x48\x53\xC9\x22\x0E\xC5\x0E\x02\x53\xCF\x00\x0E\xC5\x10\x02\x53\xC7\xE2\x4E\xC5\x12\x03\x4D\xC3\xB4\x98\x83\x4E\xC5\x05\x0E\x14\xD6\x00\x4E\xC7\x05\x0E\x14\xD8\x00\x56\xC4\x8E\x7E\x14\xDA\x00\x65\xC5\x3F\xC6\xBD\x1B\x00\x4E\xC4\x07\x09\x16\xC3\x79\x6F\xC6\x91\x7E\x14\xDF\x00\x4E\xC4\x08\x0E\x14\xE1\x00\x4E\xC6\x08\x0E\x14\xE3\x00\x4E\xC4\x09\x01\x17\xC1\x1E\x25\x02\x53\xC6\x02\x3F\xC5\x33\x97\x09\x04\x18\xE3\x19\x28\x03\x61\xC2\x11\x8A\xC6\x6D\x78\x63\xCF\x11\xF0\x79\x4E\xC4\x0B\x0E\x14\xED\x00\x4E\xC6\x0B\x0E\x14\xEF\x00\x4E\xC4\x0C\x0E\x18\xC6\x04\x31\x02\x53\xC2\x03\x1A", + "\xC5\xE1\x10\x0D\x0E\x14\xF5\x00\x4E\xC6\x0D\x0E\x14\xF7\x00\x4E\xC4\x0E\x0B\x19\xCD\x0B\x39\x02\x53\xCA\x03\x2B\xC6\x49\xC4\x10\x2B\x03\x0E\xC5\x3C\x00\x6C\xCB\x2B\x7D\x00\xB6\xC4\x1D\x1E\x03\x0E\xC5\x3F\x02\x53\xC0\x04\x0E\xC5\x41\x02\x53\xC2\x04\x0E\xC5\x43\x02\x53\xC4\x04\x39\xC6\x2D\x09\x11\x08\x1C\xDC\xC4\xB1\xC6\x5A\xCB\x12\xE1\xC4\xD0\xC7\x4B\xCF\x18\xF1\x0A\x46\x02\x53\xC7\x04\x0B\xC7\xCE\xC4\x73\xCD\x12\xD3\xC7\x23\xC5\x74\xC1\xFD\x08\x01\xD8\xC4\x3F\xC2\x1E\xC5\xC4\x26\xC7\x78\xCE\x11\xD3\xC4\xDA\xC5\x79\xC4\x1E\xCF\xC7\xD2\xC6\x42\x19\x04\x0E\xC5\x4A\x01\x78\xCB\x1E\xE9\xC7\xEC\xC4\x4C\xCC\x1D\xCD\xC7\xE6\xC4\x4B\xCA\xCA\x4B\x01\xF2\xC7\x79\xCD\x1D\xED\xC7\xFF\xC6\x7D\xCA\x50\x0C\x01\xFD\xC6\x7E\xC5\x1F\xF7\xC7\xDB\xC4\x7A\xC9\x1D\xCB\xC8\xF9\xC4\xED\x1D\x04\x05\xC8\xDE\xC4\x82\xCA\x1E\xFE\xC7\xF8\xC7\x7C\xCC\x20\xD6\xC8\x0D\xC8\x80\xC5\x21\xD6\x0D\x4E\x00\x84\xCA\x21\xC9\xC8\x01\xCA\x84\xC7\x20\xCA\xC8\x19\xC9\xAB\x5F\x04\x1E\xC8\x02\xC9\x88\xC4\x22\xD8\xC8\x2C\xC8\x85\xCA\xA0\x50\x01\x28\xCA\x88", + "\xC4\x1F\xF3\xC8\x17\xCA\x8B\xC3\x21\xC8\x7C\x51\x01\x8C\xCB\x22\xF6\xC8\x23\xCA\x8A\xCE\x23\xDB\xC8\x06\xC8\x8D\xC2\x89\x12\x01\x3A\xCB\x8F\xC0\x22\xC0\xC9\x11\xCB\x8E\xC1\x24\xF5\xC8\x4B\xC9\x89\xCC\x69\x13\x01\x45\xC8\x92\xCF\x21\xD6\x2F\x54\x01\x94\xC7\x24\xD7\xC9\x37\xC9\x92\xC6\x24\xD9\xC9\x53\xC9\x8F\xC2\x0C\x55\x01\x56\xC8\x97\xC9\x22\xD2\xC9\x63\xC9\xD9\x96\x05\x21\xC9\x5E\xC8\x96\xC9\x26\xE2\xC9\x32\xC8\x93\xCA\x25\xE4\xC9\xEE\x1F\x15\x08\x26\xC2\xC9\x2D\xC9\x93\xC5\x27\xEF\xC9\x6A\xC8\x10\x28\x05\x33\xC9\x41\x19\x16\x0C\x27\xCE\xC9\x4A\xC8\x9E\xCC\x26\xC1\xCA\x5D\xCA\x83\x4A\x05\x3F\xC9\x77\xC9\xA1\xC1\x64\x1B\x01\x4E\xC4\x17\x09\x1B\xDD\x01\x88\xC8\x8F\xC4\x27\xD2\xCA\x6A\xC6\x17\x01\x29\xF6\xC9\x94\xC8\xA0\xCB\x25\xEB\xC9\x9C\xCB\xA4\xC8\x29\xDF\xCA\x82\xC9\xA7\xC1\x64\x1F\x01\x97\xC9\xA8\xCE\x29\xE6\xCA\x6E\xCA\xA2\xCA\x29\xF0\xC9\x06\x04\x18\x05\x2A\xEA\xCA\x89\xC9\x99\xC3\x28\xDB\xCA\xA7\xC8\xAC\xC9\x29\xF1\xCA\x6D\xCB\x2F\xC1\x06\x2F\xCA\xB2\xCA\xA8\xCB\x2A\xF9\xC9\xA9\xC9\xAF\xC5\x2B\xC2\xCB", + "\xC1\xC9\xAE\xC8\x2B\xC4\xCA\xC4\xCB\xAF\xCA\xCA\x62\x01\xBC\xCA\xB1\xCA\xF4\xA3\x01\xCD\xC8\xB2\xCE\x2C\xE0\xCA\xB6\xCA\x57\x24\x06\x11\xCB\xB4\xCA\xFA\x35\x06\x18\xCB\x3F\x16\x19\x0C\x2D\xC0\xCB\xCA\xCA\xAF\xC7\x2C\xD9\xCB\xE1\xCB\xB0\xC3\x2D\xE8\xCA\xE5\xC9\xB1\xC6\x10\x27\x01\xDF\xCB\xAC\xC2\x0C\x68\x01\xED\xC8\x26\x19\x06\x31\xCB\xE6\xCA\xB4\xC6\x2F\xE4\xCB\xE3\xC8\xAB\xC6\x53\x2A\x01\xF4\xCA\xBA\xC8\x2F\xF7\xCA\x00\xCC\xB5\xCA\x10\x2B\x01\xFD\xC9\xBA\xC6\x30\xF9\xCB\xE0\xC8\xC2\xCE\x2E\xC9\xCC\x0E\x68\x1B\x05\x30\xCA\xCC\xE2\xC9\xC0\xC8\x2E\xD0\xCC\xF5\xCA\xDE\xAD\x06\x0F\xCC\x12\xCD\xB5\xC3\x31\xD9\xCC\xC9\xC8\xC5\xCE\x2F\xFA\xCB\x20\xCC\xC3\xC0\x01\x6E\x01\x4E\xC7\x1B\x0E\x14\xF0\x01\x18\xCE\xC0\xC7\x2E\xDA\xCC\x2C\xCD\xC7\xCC\x31\xEB\xCC\x2E\xCE\xCA\xC7\x2F\xE1\xCC\x0B\xCD\xCD\xC2\x7B\x31\x01\x29\xCE\xD2\x22\x07\x0E\xC5\x73\x01\xCE\xC0\x53\x74\x01\x3E\xCE\x42\x05\x07\x39\xC6\x76\x01\x6E\xC7\x07\x0E\xC5\x78\x01\xD0\xCE\xC9\x79\x01\x4E\xC6\x1E\x0E\x14\xFB\x01\x4E\xC4\x1F\x0E\x14\xFD\x01\x4E\xC6\x1F\x09", + "\x1B\xFF\x01\x4E\xC4\x20\x00\x1A\xC1\x45\x4E\xC7\x20\x0E\x14\xC4\x02\x4E\xC5\x21\x0E\x14\xC6\x02\x61\xCB\x21\x0E\x14\xC8\x02\x4A\xCF\xCC\xC3\x47\x09\x02\x4E\xC6\x22\x09\x36\xDB\x26\x8B\x01\xBB\xCC\x08\x0E\xC5\x8D\x02\x53\xCE\x08\x0E\xC5\x8F\x02\x53\xC0\x09\x0E\xC5\x91\x02\x53\xC2\x09\x2F\xCD\xD2\x0B\x24\x0E\x14\xD4\x02\x80\xCD\xAE\x55\x09\x05\xCE\x00\x02\x25\x09\x1B\xD7\x02\xB9\xC4\x26\x08\x38\xCC\x8E\x99\x02\x53\xCA\x09\x0E\xC5\x9B\x02\x53\xCC\x09\x0E\xC5\x9D\x02\x53\xCE\x09\x39\xC6\x9F\x02\x53\xC0\x0A\x1B\xCD\x0A\x16\x28\x0E\x14\xE3\x02\x4E\xC4\x29\x0E\x14\xE5\x02\x4E\xC6\x29\x01\x26\xE7\x02\x4E\xC4\x2A\x0F\x38\xD5\xCC\x6A\x11\x2A\x0E\x14\xEA\x02\xAF\xCD\x3F\x2B\x0A\x2D\xCB\xAC\x02\x53\xCD\x0A\x0E\xC5\xAE\x02\x53\xCF\x0A\x0E\xC5\xB0\x02\x53\xC1\x0B\x0E\xC5\xB2\x01\x98\xC3\x0B\x35\xCE\x07\xCF\xCB\xCA\x36\xF6\xCC\xB0\xCE\xC8\xCB\x31\xCB\x5F\xB4\x00\xF2\xCE\x31\xC9\xCF\x32\xCF\xBF\xC5\x3D\xF4\xCC\x20\x25\x2D\x02\x3D\xD6\x0D\xB6\x03\xF6\xC7\x3D\xCE\xCF\x2D\xCC\xCC\xC2\x3E\xCB\xCF\x6B\x1B\x2D\x0E\x3D\xCF\xCF\xE8", + "\xCD\xF8\xC4\x3E\xCD\xCF\xCC\xCF\xC7\xC0\x3E\xF1\xCC\xE9\xCE\xFD\xA8\x0B\x27\xCF\x2F\x21\x2E\x0E\x14\xFA\x02\xF4\xCD\xF4\x3B\x0B\x08\xCE\xBC\x01\x6E\xCD\x0B\x39\xC6\xBE\x02\x53\xCF\x0B\x39\xCF\xE3\x64\x30\x0E\x14\xC1\x03\x4E\xC6\x30\x0E\x14\xC3\x03\x4E\xC4\x31\x0E\x14\xC5\x03\xB9\xC6\x31\x0E\x14\xC7\x03\xA0\xCE\x4D\x19\x0C\x0E\xC5\xCA\x02\x53\xCB\x0C\x0E\xC5\xCC\x02\x53\xCD\x0C\x21\xC9\xCE\x02\x53\xCF\x0C\x04\xD0\xEB\xCC\x82\x00\x0D\x0E\xC5\xD1\x00\x09\xD2\x81\x12\x03\xED\xCB\x34\x0E\x14\xD4\x03\x4E\xC5\x35\x0E\x14\xD6\x03\x4E\xC7\x35\x0E\x14\xD8\x03\x4E\xC5\x36\x0A\x42\xEE\x58\x4E\xC7\x36\x0B\x43\xFB\x4A\xDC\x00\xE2\xCD\x0D\x39\xC6\xDE\x01\x6E\xCF\x0D\x3F\xD0\x82\x88\x38\x0E\x14\xE1\x03\x4E\xC6\x38\x0E\x14\xE3\x03\x4E\xC4\x39\x0E\x14\xE5\x03\xB9\xC6\x39\x0E\x14\xE7\x03\x15\xD3\x4F\x19\x0E\x0E\xC5\xEA\x02\x53\xCB\x0E\x0E\xC5\xEC\x02\x53\xCD\x0E\x21\xC9\xEE\x02\x53\xCF\x0E\x08\xD1\x11\xCD\x97\x00\x0F\x0E\xC5\xF1\x00\x1A\xD8\x6F\x32\x03\xED\xCB\x3C\x0E\x14\xF4\x03\x4E\xC5\x3D\x0E\x14\xF6\x03\x4E\xC7\x3D\x0E\x14", + "\xF8\x03\x4E\xC5\x3E\x01\x26\xFA\x03\x6E\xD2\xFB\xCD\x3E\xD4\xCF\xF1\xCF\xF8\xC6\x3D\xC5\xD2\xAE\x37\x3E\x01\x48\xC4\xD2\xEA\xCF\x21\xDD\x48\xD8\xCF\xEC\xCC\x26\x1C\x0F\x0B\xD2\x28\x09\x3F\x04\x49\xCA\xCF\x8E\xD0\xFC\xCF\x48\xEF\xCF\x86\xD2\x1A\x1E\x0F\x17\xD2\xDF\xCF\x20\xD3\x3D\xE3\xD2\x98\xD0\x24\xD5\x4E\x20\xD2\x88\xD1\x26\xDC\x00\x40\x00\x2C\x0F\x45\xC1\x49\xEF\xD2\x82\xD1\xC5\x51\x00\x2D\xD2\x1B\xC5\x2C\xD0\x4B\xE7\x8C\x02\x00\x2D\xDA\x12\xF7\xD2\xA4\xD1\xE9\x03\x00\x3A\xD2\x34\xC4\x23\xDA\x49\xC3\xD3\x9D\xD0\x27\xD5\x42\xC2\xD3\x9E\x70\x01\x00\x4C\xEA\x97\xC8\xD3\x31\xDD\x4B\xE9\xD2\xA6\xD1\xC4\x05\x00\x0B\xD3\x0A\x78\x35\xDE\x1A\x87\x00\xD6\xD1\x84\x79\x4D\xFE\x34\xCB\xD3\xD0\xAB\x00\x1B\xD3\xAA\xD2\x41\x0C\x00\x20\xD3\x54\x8C\x39\xD3\x88\xA6\xD3\x5A\x8C\x3A\xD0\x01\x28\xD3\x11\x00\x3A\xDD\x22\x12\x00\xE8\xD3\x04\x0D\x4D\xE1\x13\x15\x00\x3A\xD6\x01\x28\xD3\x17\x00\x3A\xD8\x01\x28\xD3\x19\x02\x3B\xD9\x2F\x1A\x00\xE8\xD3\x06\x08\x4E\xDC\x00\xE8\xD1\x07\x03\x4F\xC9\x04\x1F\x00\x3A\xD0\x02\x28\xD3\x21\x00", + "\x3A\xD2\x02\x28\xD3\x23\x00\x3A\xD4\x02\x3E\xD3\x5E\x40\x45\xD1\x31\x26\x00\xE8\xD3\x09\x06\x51\xE8\x08\x28\x03\x46\xD0\xC3\x29\x00\xE8\xD2\x0A\x0E\x51\xDE\x25\x2B\x00\x3A\xDC\x02\x28\xD3\x2D\x03\x48\xD9\x27\x2E\x00\xE8\xD3\x0B\x0A\x52\xE8\x06\x30\x00\x3A\xD1\x03\x28\xD3\x32\x00\x3A\xD3\x03\x28\xD3\x34\x00\x3A\xD5\x03\x28\xD3\x36\x00\x3A\xD7\x03\x2F\xD4\xC4\xD2\x33\xD5\x4A\xC6\xD3\xE1\xD1\x51\xD7\x41\x78\x00\x40\xD5\x31\xD2\x4A\xC3\xD5\x4B\xD5\x28\xD9\x46\xD0\xD3\xA9\x71\x0E\x09\x54\xC2\xD5\x4E\xD4\x2F\xDC\x54\xCF\xD5\x2C\x16\x0E\x03\x55\xC6\xD5\x44\xD5\x34\xDF\x4C\xDB\xD2\x4D\xD4\x54\xD4\x9E\x7B\x00\x5B\xD6\x57\xD7\x55\xD6\xD5\x55\xD6\x2D\xD2\xB0\x3C\x00\xE8\xD1\x0F\x05\x56\xD2\x87\x3E\x03\x5B\xD3\x54\x3F\x00\x72\xD4\x10\x02\x57\xC1\x01\x72\xD7\xF7\xB2\x04\x28\xD3\x43\x00\x3A\xD4\x04\x28\xD3\x45\x00\x3A\xD6\x04\x28\xD3\x47\x02\x5C\xD8\x04\x28\xD3\x49\x03\x41\xDA\x50\x0B\x01\xE8\xD0\x13\x08\x4E\xCD\x01\xE8\xD2\x13\x08\x4E\xCF\x01\x79\xD5\x76\x00\x05\x28\xD3\x51\x01\x65\xDA\x56\xC0\x1D\x52\x00\x3A\xD3\x05\x1A", + "\xD6\xCA\x3C\x15\x00\x5A\xFE\x0C\x55\x00\x3A\xD6\x05\x28\xD3\x57\x00\x3A\xD8\x05\x28\xD3\x59\x00\x3A\xDA\x05\x28\xD3\x5B\x03\x68\xDF\x95\xB2\xD6\x69\xD5\x33\xDC\x55\xE1\xD5\x60\xD4\x56\xD1\x54\xD5\x2F\x5D\x00\x6D\xD2\x56\xFA\xD6\x4A\xD4\x70\xD4\x55\xFF\xD6\x68\xD4\x71\xDB\x59\xDF\xD5\xBB\xD6\xB4\x0E\x05\x3E\xD6\x2F\x23\x17\x0C\x5C\xC9\xD7\x5D\xD5\x74\xD8\x5B\xD0\xD7\xD3\xD5\x70\xDB\xEC\x20\x01\xCF\xD6\x75\xD7\x5C\xE7\xD5\xDB\xD5\x6D\xD6\x90\x21\x01\xE8\xD2\x18\x09\x5D\xF9\x6A\x63\x02\x5C\xD4\x06\x23\xD7\x03\x05\x19\x02\x57\xE6\x01\x72\xD7\x19\x08\x5E\xE3\xBC\x68\x00\x3A\xD9\x06\x28\xD3\x6A\x00\x3A\xDB\x06\x28\xD3\x6C\x00\x3A\xDD\x06\x32\xD5\x6E\x00\x3A\xDF\x06\x0A\xD6\x36\x15\x1C\x08\x4E\xF2\x01\xE8\xD3\x1C\x08\x4E\xF4\x01\xE8\xD1\x1D\x0F\x5E\xC1\x04\x76\x00\x3A\xD7\x07\x0B\xD8\xD5\xD5\xA3\x18\x07\x28\xD3\x79\x00\x84\xD2\xD3\x3A\x01\x16\xD9\x76\x0B\x07\x28\xD3\x7C\x00\x3A\xDD\x07\x28\xD3\x7E\x00\x3A\xDF\x07\x28\xD3\x80\x00\x3A\xD1\x08\x19\xD8\xDD\xD4\x36\x12\x08\x28\xD8\xB6\xD6\x59\xDE\x5D\xDC\xD7\x2D\xD9\xB5", + "\x03\x08\x2C\xD8\xC8\xD6\x76\xD1\x63\xD1\xD8\xB7\xD6\x70\xDB\x99\x04\x02\xE8\xD1\x21\x04\x63\xCE\x68\x86\x02\x5C\xD7\x08\x10\xD8\x88\x02\x5C\xD9\x08\x32\xD5\x8A\x03\x8F\xD1\xF3\x8B\x02\xE8\xD0\x23\x08\x4E\xCD\x02\xE8\xD2\x23\x08\x4E\xCF\x02\xE8\xD0\x24\x02\x57\xD1\x02\xE8\xD2\x24\x00\x60\xFF\x14\x94\x00\x3A\xD5\x09\x28\xD3\x96\x00\x3A\xD7\x09\x28\xD3\x98\x00\x84\xD9\x09\x28\xD3\x9A\x02\x92\xD6\x5C\xCE\x18\x9B\x00\x3A\xDC\x09\x2A\xD9\x4E\x2D\x27\x00\x67\xCA\x04\x9E\x00\x3A\xDF\x09\x28\xD3\xA0\x00\x3A\xD1\x0A\x28\xD3\xA2\x00\x3A\xD3\x0A\x28\xD3\xA4\x03\x9C\xD6\x63\xFE\x0C\xA5\x02\xA0\xD3\x5C\xF9\xD6\xC5\xD4\xA2\xD2\x48\xE6\x02\x86\xD9\x8E\xD9\x68\xD4\xD7\x3A\xDA\x8B\xDB\x66\xF5\xD8\x96\x45\xA3\xD2\x69\xCA\xDA\x37\xD9\xA4\xD9\xCA\x68\x02\x96\xDA\x74\xDA\x69\xF8\xD8\x97\xDA\xD4\x29\x0A\x28\xD3\xAA\x01\xA7\xD0\x6A\xDE\xDA\x8F\xDB\xA0\xD0\x63\xD4\xDA\x8E\xDA\xD7\x4B\x0A\x26\xDA\x9F\xD9\xC5\x5C\x0A\x30\xDA\xA9\xDB\xA1\xD0\x69\xF5\xDA\x4E\x65\x2B\x04\x6B\xE9\xD8\x98\xD8\xAB\xD1\x6A\xD8\x26\xAE\x03\xAE\xD9\x69\xF8\xDA", + "\x23\xBF\x2B\x02\x6C\xFE\xDA\xA8\xD8\xAF\xD7\x6B\xFD\x78\xB0\x03\xB1\xDB\x6A\xCF\xDB\x2F\xD9\xB4\xD3\x69\xD0\xDB\xD3\xD9\xCC\xB1\x0B\x0E\xDB\xD2\xD9\xAF\xD4\x6D\xDA\xDB\xD9\xD8\x75\xD2\x0B\x18\xDB\xD5\xD9\xB8\xDC\x6D\xE2\xDB\xAE\x87\x2C\x08\x4E\xF4\x02\xE0\xD8\x4C\x55\x0B\x29\xDB\x0A\x06\x2D\x02\x57\xF7\x02\x72\xD4\x2E\x0C\x6E\xE3\x8E\xB9\x00\x3A\xDA\x0B\x28\xD3\xBB\x00\x3A\xDC\x0B\x28\xD3\xBD\x00\x3A\xDE\x0B\x32\xD5\xBF\x00\x3A\xD0\x0C\x1B\xD9\x42\x16\x30\x08\x4E\xC3\x03\xE8\xD0\x31\x08\x4E\xC5\x03\xE8\xD2\x31\x00\x61\xC7\x03\xE8\xD0\x32\x03\x6F\xF6\xDA\xAB\x09\x32\x08\x4E\xCA\x03\x13\xDF\x66\x2B\x0C\x26\xDA\xCC\x00\x3A\xDD\x0C\x28\xD3\xCE\x00\x3A\xDF\x0C\x28\xD3\xD0\x00\x3A\xD1\x0D\x28\xD3\xD2\x01\xC6\xDF\x6B\xF4\x1F\xD3\x02\xCA\xD9\x6C\xC3\xDB\xCA\xDA\xAA\xD8\xF0\x54\x03\x2E\xDF\xA9\xD6\x73\xF1\xDA\xC4\xDB\xCB\xD8\x6C\xF7\xDC\xB6\x71\x35\x05\x73\xF8\xDC\x31\xDC\xC5\xD2\x74\xED\xDA\xBF\xC2\x35\x0F\x73\xF9\xDC\x3C\xDD\xD0\xD4\x74\xCC\x50\xD7\x03\xD1\xDA\x74\xEB\xDC\x4B\xDF\xB6\xDB\x6C\xF0\xDC\x54\xDC\x8A\x08", + "\x0D\x0E\xDD\x55\xDE\xD4\xD2\x73\xE4\xDB\x3C\xB9\x36\x08\x75\xFB\xDC\x40\xDD\xD6\xDD\x6D\xDB\xDD\x53\xCA\x36\x0F\x75\xDA\xDD\x43\xDC\xD4\xDA\x76\xFA\xDC\x68\xDF\x40\x0B\x0D\x27\xDD\x63\xDD\xDA\xDC\x76\xF1\xDD\x51\xDC\xDD\xD2\x2D\x1C\x03\x70\xDC\xD7\xD2\x77\xC9\xDD\x62\xDE\xDE\xD7\x5B\xDD\x03\x79\xDF\xB8\xD2\x78\xD3\xDD\x60\xDC\xD2\xD8\xC3\x9E\x03\x81\xDC\xE1\xDD\x76\xEB\xDD\x7C\xDD\xE1\xDF\x74\xF3\xDD\x7E\xDC\xE3\xD1\x76\xCE\xDE\x0E\x1B\x37\x09\x78\xE4\xDD\x8A\xDE\xDD\xD0\x79\xC3\xDE\x98\xDD\xE7\xDB\x77\xD3\xDE\x8B\xDF\xE6\xD9\x79\xE7\x6E\xE0\x03\xE5\xDF\x79\xC9\x6A\xE1\x00\x3A\xD2\x0E\x26\xDE\x75\xDD\xE4\xD2\x7A\xCA\xD5\xE3\x00\xEB\xD2\x79\xF6\x72\xE4\x02\xEC\xDF\x7A\xE7\xDE\x8F\xDD\xCD\xC5\x0E\x36\xDE\x74\x12\x39\x0C\x7B\xE0\xDE\x9A\xDD\xE3\xD1\x7A\xC2\xDF\xC1\xDC\xF0\xD9\x27\x27\x03\xBF\xDE\xE1\xDA\x7C\xF9\xDE\xC6\xDC\xE7\xD8\xE2\xA8\x03\xC9\xDC\x82\x09\x0E\x11\xDF\x7D\xDE\xF3\xDD\x7A\xD6\xDF\xB3\xDC\xED\x8A\x0E\x14\xDF\x94\xDD\xF7\xD3\x7C\xCD\xDF\xA3\xDC\xF6\xD7\x7B\xD7\xDF\xE1\xDE\x1C\x7B\x0E\x1C\xDF\xDF", + "\xDF\xF2\xD5\x7D\xE5\xDF\x9E\xDC\xF9\xDD\x7E\xF4\xCC\xEC\x00\xFA\xD5\x7C\xEA\xDF\xDE\xDF\xFC\xDC\x7C\xE9\xC7\xED\x00\x3A\xDE\x0E\x32\xDF\xAE\xDC\xF1\xDD\x7F\xDF\xBF\xEF\x00\xFF\xD2\x7E\xEA\x72\xF0\x02\x00\xEC\x7E\xF8\xDE\xEB\xDE\x27\x71\x0F\x06\xE0\xEF\xDE\xBC\x32\x0F\x0C\xE0\x08\xE1\xFD\xDF\x7F\xF4\xDF\x30\x33\x3C\x00\x81\xEE\xDF\x11\xE1\xFA\xD7\x7F\xDB\xE0\x09\xE0\x44\xC4\x0F\x17\xE0\x02\x05\x3D\x00\x82\xE3\xDF\xD9\xDD\x07\xE8\x81\xE7\xE0\xDD\x8E\x3D\x03\x82\xFE\xDF\x03\xE0\xF8\xDD\x80\xEC\xE0\x07\xE0\x0A\xE4\x82\xF2\x3B\xF7\x03\x0A\xEE\x82\xCA\x14\xF8\x02\x0D\xE4\x81\xF6\xDF\x26\xE1\x09\xE2\x81\xC3\x0F\xF9\x02\x0E\xEC\x81\xFF\xE0\x31\xE2\x0F\xEA\x81\xFD\xE0\x33\xE0\x0C\xE3\x3B\x3A\x03\x42\xE0\x12\xEA\x84\xD9\xE0\x43\x2F\x3E\x06\x6A\xFC\x03\x4D\xE0\x11\xE3\x3A\xBD\x03\x55\xE3\x11\xE6\x85\xD0\xE1\x4A\x2E\x3F\x00\x6B\xD9\xE1\x43\x2C\xDC\x6F\xF7\x32\xE0\x4F\xE0\x19\xE7\x83\xE6\xE1\x3B\xE3\x04\xEC\xD1\x01\x00\x2E\x0E\x2B\xD3\x84\xDA\xE1\x70\xE3\x4C\x92\x00\x2D\xE1\xB5\xD0\x28\x13\x00\x34\xE1\xBB\xD3\x1B\xEC\x83", + "\xE8\x08\x04\x00\x1E\xE1\x4C\xDB\xE1\x68\xE2\x1E\xEA\x86\xCE\xE1\x67\xE3\x4F\x15\x00\x3E\xE1\xCC\xD0\x20\xE6\x84\xFB\xE1\x71\xE3\x20\xEA\x88\xC9\xE1\x85\xE0\x24\xE9\x86\xED\xE0\x93\xE1\x11\xE2\x89\xC2\xE2\x94\xE1\x90\x16\x00\x08\xE2\x3B\xC5\x20\xE4\x88\xD5\xE2\x2F\xE1\x24\xE5\x33\xC7\x00\x9C\xE2\xD4\x28\x00\x25\xE2\xA1\xE1\x29\x58\x8A\xDC\xE1\x99\xE3\x27\xE8\x89\xFE\x67\x0A\x03\x2A\xE3\x10\x0B\x00\xB2\xE1\xF7\x8C\x00\x35\xE2\x6D\x1D\x03\x08\x8B\xD6\x0B\x0E\x03\x2E\xE2\x4B\x7E\xE2\xEC\xCC\x04\x0B\x8B\xD1\x00\xBB\xE2\x04\x0B\x8B\xD3\x00\xBB\xE0\x05\x0B\x8B\xD5\x00\xC0\xE2\x7A\xBB\x8B\xD7\x00\x88\xE3\x56\xC8\xE3\x7B\xE2\x1A\x03\x2E\xEB\x01\x3B\xE2\x1C\x03\x2E\xED\x01\x0D\xE3\x11\x0E\x07\x0B\x8B\xDF\x00\xDC\xE3\x23\xEC\x6E\x20\x00\xBB\xE1\x08\x01\x8E\xF7\x49\x22\x03\x39\xE6\x50\x23\x00\xBB\xE0\x09\x0B\x8B\xE5\x00\xBB\xE2\x09\x0B\x8B\xE7\x00\xBB\xE0\x0A\x0B\x8B\xE9\x00\xEA\xE3\xE6\x0A\x02\x39\xE3\xAD\xE2\x38\xE2\x8A\xFF\xE3\xA0\xE0\x2B\xE6\x89\xF0\x20\x2B\x00\x3F\xE3\x90\xC0\xE4\xAF\xE1\x2A\xE9\x90\xE1\x2D\x2C\x02", + "\x41\xEA\x90\xEE\xE2\x10\xE6\x3F\xE1\x90\xDE\xE2\x12\xE7\x42\xE4\x91\xFF\x77\x2D\x02\x43\xE2\x90\xCF\xE4\x15\xE5\x44\xED\x88\xFD\xE3\x1F\xE7\x41\xE3\x91\xCB\xE2\x8E\xE1\x48\xE5\x35\x6E\x00\x1A\xE7\x45\xE3\x53\xAF\x00\x29\xE6\xB4\x00\x03\x2D\xE4\x9A\xAC\x4C\xE5\x86\xD2\x0B\x32\x01\x34\xE1\x66\x34\x00\x32\xE7\xD9\x25\x03\x39\xE4\xF9\x0A\x0D\x0C\x93\xC1\x5B\x37\x03\x2E\xE8\x03\x3B\xE2\x39\x03\x2E\xEA\x03\x3B\xE2\x3B\x02\x4D\xE6\x45\x3B\xE2\x3E\x00\x22\xE3\x1B\x41\x01\x4A\xE5\xAC\x03\x04\x3F\xE4\xCA\x3C\x11\x04\x95\xDD\xE4\x3B\xBD\x11\x07\x95\xC8\x09\x46\x03\x56\xED\x25\x07\x01\x5E\xE5\x49\xED\x25\x08\x01\x51\xE4\xB5\x1A\x04\x21\xE5\x67\x27\x12\x08\x96\xDD\x0A\x4C\x03\x5A\xE5\x35\x4D\x01\xBB\xE2\x13\x0B\x8B\xCF\x01\xBB\xE0\x14\x0B\x8B\xD1\x01\x65\xE6\x40\x03\x05\x3B\xE2\x54\x02\x53\xEA\x10\x17\x01\x79\xE5\xB5\x09\x05\x2E\xE5\xAE\x36\x16\x04\x98\xFD\x38\x5B\x03\x61\xE4\x92\xE0\xE4\x8C\xE1\x63\xE2\x96\xCF\xE6\x8C\xE4\xED\x1C\x05\x0A\xE6\x97\xE2\x47\xEE\x98\xD1\xE6\x98\xE7\x40\xED\x05\x14\xE6\x33\xE5\x65\xE8\x95\xC3", + "\xDF\x5E\x00\x67\xE8\x90\xD6\xE6\x90\xE6\x48\xE6\x91\xCB\xE6\xA6\xE5\x96\x6F\x05\x22\xE6\x23\xE6\x67\xE6\x92\xCB\xCF\x60\x00\x6B\xE7\x9A\xED\x1D\x61\x02\x6C\xE2\x89\x22\x01\x9C\xE7\x18\x0B\x8B\xE4\x01\xBB\xE1\x19\x0B\x8B\xE6\x01\xBB\xE3\x19\x0B\x8B\xE8\x01\xBB\xE1\x1A\x0B\x8B\xEA\x01\xBB\xE3\x1A\x0B\x8B\xEC\x01\xBB\xE1\x1B\x06\x9B\xFB\xBC\x6E\x03\x73\xE8\x24\x2F\x01\xD2\xE7\x65\xE9\x9A\xFE\x0C\x70\x01\x75\xE4\x7B\x31\x01\xDA\xE5\x66\xEC\x91\xEF\xE6\x2A\xE5\x69\xEF\x9D\xF1\xBC\x72\x01\x77\xE7\x9D\xE0\xE7\xA8\xE7\x78\xE2\x9E\xDB\xE4\x06\x07\x1C\x06\x9E\xEA\xE7\xDE\xE4\x7B\xEB\x25\xF4\x01\xBB\xE1\x1D\x0F\x9E\xF2\xE7\xE9\xE4\x7E\xEE\x9A\xD6\xE7\xF0\xE5\x98\x16\x07\x37\xE7\xE1\xE5\x7C\xE1\xA0\xE7\xE7\xFC\xE7\x52\x77\x07\x00\xE8\xF9\xE7\x80\xED\x9F\xCB\xE8\xFA\xE5\x67\xEE\xA0\xE3\xE6\x6A\xA8\x1E\x08\xA0\xFB\xE7\x1B\x51\x1E\x0B\x8B\xFA\x01\x13\xEB\x83\xED\x9A\xDA\xE8\xB3\xE4\x87\xE4\x9A\xC2\xE8\x09\xE8\x4A\x3B\x07\x3B\xE2\x7C\x01\x86\xE0\xA1\xE8\xE7\x14\xE8\xDC\xBD\x07\x26\xE8\x1B\xE8\xE3\x8E\x07\x2C\xE8\x1D\xEB\x89", + "\xE5\xA0\xFA\xAD\x7F\x00\x8C\xEF\xA1\xD9\x0E\x80\x02\x8D\xE9\x7A\x01\x02\x9C\xE6\x20\x0B\x8B\xC3\x02\xBB\xE0\x21\x0B\x8B\xC5\x02\xBB\xE2\x21\x0B\x8B\xC7\x02\xBB\xE0\x22\x0B\x8B\xC9\x02\xBB\xE2\x22\x0B\x8B\xCB\x02\xBB\xE0\x23\x0A\xA3\xFA\xA9\x8D\x01\x86\xEE\x08\x13\xE9\x33\xE9\x88\xE9\x61\x18\xE9\x63\x18\x24\x0C\xA5\xE0\xE8\x29\xE8\x81\xEB\x9E\xCA\xE8\x4B\x75\x24\x0F\xA5\xE2\xE9\x60\xEA\x87\xEF\x99\xD9\xE9\x61\xEB\xE8\x82\x09\x27\xE9\x09\x07\x24\x00\xA7\xCD\xE8\x32\xEB\x98\xE3\xF2\x94\x02\xBB\xE1\x25\x03\xA7\xE4\xE9\xD4\x1A\x25\x0B\xA7\xDA\xE9\x6A\xE8\x8A\xE1\xA8\xEC\xE9\xC0\xC3\x25\x0F\xA7\xF3\x11\x98\x03\xA1\xE3\xA8\xF6\xE9\x6D\xE8\x9D\xED\xA2\xD1\x8E\x99\x03\x2E\xEA\x09\x0A\xEA\x75\xE9\x9A\xE5\xA9\xFE\x67\x9B\x00\xA5\xEF\xA8\xFD\x78\x9C\x02\xA6\xE1\xA3\xDB\xEA\x37\xD8\x00\x00\x10\x00\x28\xC4\x00\x00\xFF\x00\x81\x80\x80\x04\x85\x80\x82\x81\x02\x86\x86\x88\x81\x82\x85\x82\x86\x03\x8E\x80\x10\x8F\x7A\x8B\x88\x88\x16\x94\x99\x98\x82\x8A\x8D\x8E\x8E\x0E\x9E\xA1\x80\x9A\x82\x91\x92\x92\x0B\xA8\x85\x9D\x42\x0E\x85", + "\x01\x8F\x0C\x9B\xB1\x90\x98\x82\x99\x9A\x9A\x09\xB8\x8D\x9A\x91\x8B\x93\x98\x9F\x37\xC0\xB9\x82\xAB\x9C\xA1\x9F\x93\x3F\xC8\x81\xAA\xA3\xA4\xA5\xA2\xA7\x47\xA9\x89\xB2\xAB\xA4\xA9\xA6\xAB\x4F\xD8\x91\xAF\x8A\x97\x81\xAF\x8B\x53\xDC\xA1\xA4\x8E\x4D\x96\x85\x97\x46\x95\xBC\x8A\xB9\xB6\x9B\xAA\xB1\x55\xF0\xAF\xBE\xA3\xB0\xB1\xB8\x82\x9F\x66\x86\x88\xB0\xAC\xB5\xBE\x8B\xA0\x7A\x85\x9C\xB6\x81\x52\xC0\x82\x84\x85\xA2\x47\xC0\x01\xC4\x83\x51\x8C\x8E\xC0\x04\x51\xCA\x89\x53\xCA\x0E\xA6\x58\xCA\x87\x53\xCE\x82\x54\x9E\x85\xA9\x41\xD4\x82\x54\xD2\xBB\x73\xA8\xD9\xB2\xBB\xD4\xBB\xBA\xD5\x5B\xAE\xE9\xC6\x9A\xAE\xBD\xDA\xB7\xAD\xB0\xF6\xCC\xD1\xDA\xDC\xDD\xDE\xB4\xBC\xFB\xD2\xD9\xD9\xE0\x83\x55\xA7\xC6\xFE\xCB\xB6\x8C\x55\xE5\xAF\xCA\xD1\xD0\xF3\xE5\xBA\xE9\xEA\xEA\xAF\xD6\xD9\xF8\xE3\xDC\xED\xE2\xEF\xC0\xE0\xC3\xEB\xED\xB4\xE6\xF3\xF2\xE8\xFF\xA7\xEA\xF9\xF7\xDB\xF4\xF7\xED\xC2\xFF\xC3\xFA\xED\xEF\xEB\xFB\xDB\xF8\xF6\xEF\xDD\x57\xE6\xFD\xEF\xFF\x61\x71\x80\x7D\x5F\x6E\x2E\x7D\x7E\x08\xBB\x7A\x80\x80\x09\x8C\x8B\x82\x80", + "\x0D\x90\x8F\x80\x81\x03\xB3\x76\x87\x7B\xF2\x58\x84\x72\x84\x0E\x9D\x8C\x87\x87\x14\x91\x81\x8B\x84\x17\xB1\x7B\x87\x88\x1E\xA8\x80\x89\x89\xEC\x6D\x80\x7E\x8B\x19\xA6\x84\x78\x8C\x27\xAC\x8F\x8B\x8D\x31\xB4\x83\x8C\x8E\x35\x9A\x8B\x8D\x8E\x3C\xBF\x8D\x8E\x8C\xF5\x69\x86\x8C\x90\x48\x83\x9A\x8D\x91\x2B\xBE\x8C\x92\x8A\x50\x87\x9A\x91\x90\x4F\x92\x92\x93\x95\x55\x8E\x92\x7A\x95\x59\x84\x9B\x96\x96\x15\xA0\x92\x88\x97\x5F\x9E\x91\x9A\x99\x63\xA2\x94\x8A\x8F\xAF\x07\x8B\x98\x9A\x6F\x8B\x95\x9A\x9C\x67\xB4\x99\x98\x9C\x46\xAA\x99\x9C\x9E\x4D\xBC\x91\x96\x9E\x7D\xB6\x91\x9C\x95\x73\x84\xA5\x9E\xA1\x77\x82\xAB\x9E\xA2\x81\x88\xA3\xA1\x92\x58\x85\xA0\xA5\x97\x8C\xBF\x9E\x9C\x99\x87\x93\xA2\xA7\x94\x9A\x99\xAC\xA7\xA7\x91\x9E\xA1\xA9\xA2\x8E\x8B\xA5\xA9\xA3\x9D\xA4\xA9\xAB\xA3\xA0\x94\xA7\xAA\xA5\x95\x98\xAA\xA9\xAB\x9B\xA3\xAC\xAA\xAD\xA6\xAB\xA9\xAC\xAD\xA2\xAE\xAA\xAC\xAA\xBC\xB3\xA8\xAC\xB0\xC3\xB0\xAF\xAA\xAC\xB7\xB0\x2E\x9B\xAE\xC5\x96\x41\x2F\xB2\xC4\xBE\xA1\xB3\xAD\xD2\x8D\xB0\xA2\xB1\xBF\x98\xB3\xB4\xB3\xD5", + "\x9D\xB5\xAE\xB7\xBD\x9F\xB2\xB9\xB8\xE4\x82\xB0\xBA\xB9\xE3\xA8\xB5\xB8\xB5\xE9\xAC\xBB\xB8\xB7\xED\xB0\xBF\xB9\xB4\xF1\xB4\xB3\xBE\xB6\xD6\x97\xA2\x46\x2C\xA7\x73\x20\xB4\xBE\xE7\xAE\xBA\xBB\xC0\x02\xC5\xC2\xBC\xC1\x07\xC6\xC6\xBC\xC2\xC4\xB4\x2F\xBC\xB2\x09\xD1\xCB\xC2\xC2\x00\xF5\xB5\xC7\xBD\x10\xD3\xC2\xC7\xC5\x0C\xDC\xC4\xC5\xC6\x1E\xDB\xC0\xCB\xC8\xD7\xA4\xCA\xBF\xC9\xB1\xA5\xCA\xC8\xCA\xC7\xAB\xC9\xC8\xCB\xD9\xA6\xCF\xCB\xCC\x2D\xF0\xCB\xB6\xC6\x38\xE1\xC9\xCE\xCC\x35\xF4\xC1\xCE\xCB\x3D\xC1\xDF\xCE\xCD\xF9\xBE\xC7\xCE\xCE\x48\xD6\x95\x2F\xC3\x40\xC3\xDA\x8E\x2D\x4C\xC4\xD1\xC2\xC8\x4D\xC7\xDC\xCE\xD3\x42\xD6\xD5\xD5\xD1\x59\xDC\xD8\xD7\xD7\x5A\xD2\xD6\xC7\xD5\x61\xC6\xDE\xD5\xD9\x5D\xD3\xDB\xCF\xD6\x6A\xC9\xDC\xDB\xD8\x6F\xD8\xC1\xDD\xC7\x64\xE7\xD6\xDD\xDB\x75\xF8\xD3\xDF\xC7\x7B\xD4\xD2\xDA\xDC\x7F\xF4\xDD\xDD\x6F\xB7\x11\xD6\xDA\xDE\x81\xFC\xD9\xE2\xDF\x87\xF0\xDB\xE3\xDA\x8F\xEE\xD1\xE5\xDE\x8E\xCD\xE0\xE2\xE5\x82\xD3\xE3\xE2\xE4\x98\xCA\xED\xE4\xE3\x69\xD5\xE1\xEB\xE5\xA3\xD9\xEF\xE4\xE4\xA7\xDC", + "\xE5\xEA\xE7\xAB\xE0\xE0\xDB\xDD\xA2\xEF\xE8\xE2\xD9\xB8\x06\xED\xE8\xEA\xB7\xEA\xE2\xED\xEC\x68\xFB\xE4\xEA\xEF\xA6\xF9\xE4\xE7\xEF\xBD\xC5\xF0\xEC\xF1\xC7\xC1\xF0\xF0\xEB\xCB\xEE\xE6\xF3\xEC\xC2\xDB\xE3\xF2\xF2\xCF\xF5\xA9\x2E\xED\xCD\xF8\xE9\xF6\xEE\xD5\xC8\xF0\xF7\xF6\xD3\xCC\xFD\xF4\xF5\xC9\xE9\x6A\x2C\xF6\xE3\xE2\xF5\xFA\xF3\xEB\xDA\xF9\xF8\xFB\xDF\xEF\xFE\xF9\xFB\xDC\xF4\xF1\xF8\xFC\xBC\xF6\xF2\xF7\xFE\x9A\xFD\xF9\xEB\xFD\xF3\x71\x7E\xFE\x7E\x71\x7A\x87\x3B\x10\x7D\x03\x9F\x7C\xFF\x0A\x84\x80\xF0\x4B\x85\x80\x0C\x91\x80\x04\xC1\x4C\x16\x04\x82\x87\x82\xF9\x78\x82\xF7\x19\x8C\x83\x0D\x9E\x84\x7C\x1A\x80\x85\x07\xA2\x8F\x82\xF5\x61\x86\x84\x23\x88\x85\x09\xF8\x7B\x85\x00\xA9\x84\x85\xAF\x3D\x16\x05\xAF\x8E\x85\x16\xB5\x7F\x84\x30\x8A\x84\x09\xBB\x8A\x87\x1E\xB9\x87\x87\x35\x9C\x84\x10\xB7\x84\x86\x22\xB6\x80\x80\xF5\x7E\x17\x0C\xC7\x8F\x80\x07\x8D\x82\x7E\x46\x82\x89\x10\xBE\x83\x8B\x21\x88\x8F\x8A\x4D\x90\x88\x16\xCF\x89\x81\x09\x8E\x8A\x82\x5F\x9E\x8A\x16\xD9\x8D\x8B\x30\xA6\x8B\x8C\x5C\x98\x85\x15\xEB", + "\x81\x8A\x2A\xAD\x8E\x8A\x5B\x7F\x17\x12\xD2\x8F\x8C\x36\x9B\x88\x8C\x68\x98\x8D\x19\xF9\x82\x8D\x3D\xBE\x8A\x8D\x75\x81\x93\x1D\xFD\x80\x91\x41\xA7\x8F\x8F\x45\x86\x90\x1F\x87\x95\x90\x32\x8D\x91\x8D\x89\x8E\x91\x24\x90\x9C\x88\x4A\xB4\x8A\x91\x7E\x80\x1B\x1C\xEE\x88\x93\x47\xBA\x8E\x93\x84\x93\x93\x27\xA2\x91\x95\x4A\xA3\x96\x94\xA5\x97\x92\x24\xA8\x9C\x90\x52\xAD\x94\x95\x8B\x91\x94\x22\xB0\x93\x96\x55\x96\x94\x93\xAB\x96\x97\x29\xBA\x99\x94\x5C\xB7\x90\x8E\xBF\x96\x8D\x2E\xBE\x9B\x96\x62\xBD\x90\x98\xC5\x88\x9B\x31\xC2\x91\x98\x41\x83\x9A\x99\xAF\x9C\x95\x34\xC6\x93\x9A\x68\xB2\x90\x94\xD5\x8C\x99\x32\xDA\x9B\x98\x67\x8D\x9D\x93\xAE\x97\x99\x38\xB5\x94\x9A\x71\xB4\x90\x9B\xC6\x61\x1B\x26\xD6\x94\x9C\x76\xA8\x9D\x9D\xDC\x85\x22\x30\x6B\x94\x59\x61\x34\x9E\x9B\xDB\x98\x9D\x37\xE0\x97\x9D\x71\xAF\x9F\x9F\xFE\x81\xA1\x3F\x83\xA2\x9A\x73\x85\xA0\x9E\xFA\x99\x99\x42\x86\xA5\x9C\x84\xBC\x9F\xA0\x00\xA4\xA1\x43\x91\xA0\xA3\xAF\x04\x1F\x9E\x0F\xAA\x7D\x31\x18\xA2\x22\x63\x27\x37\x18\xA7\x28\x1B\x69\x49\x17\x34\x65", + "\x27\x33\x19\xA7\x2C\x1B\x69\x4D\x17\x34\x67\x27\x37\x19\xA7\x30\x18\x47\xDF\x9F\x99\x78\x8C\xA4\x59\xD1\x13\xA6\x8E\x52\x1A\xA7\x7D\xB5\xA3\xA1\x0E\xBF\xA5\x46\xEE\x92\xA1\x8A\x92\xA4\x9D\xD3\x1D\xA6\x42\xC3\xA6\xA7\xA0\xB4\xA4\x68\xD4\x0A\xAB\x4D\xCD\xA4\xA3\x89\x85\xAE\xAA\x47\xB4\xAB\x55\xC4\xA9\xAA\xA0\x95\xAC\xAB\x46\xA1\xAC\x56\xE2\xA0\xAD\xB1\xA6\xAD\xAC\x68\xBA\xA9\x57\xD6\x45\x1B\xD3\x16\x1A\xAA\x4E\xB9\x9C\x53\xE3\x37\x1A\xB8\x95\x58\x1B\x08\x99\x18\x02\xDA\x16\xAF\xAD\xAA\xAC\xAC\x4D\xBB\x1B\x69\x5C\x17\x35\x6E\x27\x36\x1B\xA7\x3F\x1B\x69\x60\x18\x81\x70\x27\x32\x1C\x8C\x22\x00\x19\xE4\x17\x35\x72\x27\x36\x1C\xA7\x27\x1F\x69\x68\x10\xAF\x74\x27\x32\x1D\x7D\xAB\xAE\x50\xA3\xBF\xA8\xB9\xBE\x43\x1D\xA7\x2C\x1D\x68\x80\xB0\xA9\x76\x2B\xB1\x35\xEE\x07\x37\x3B\x27\x30\x1F\xD3\x31\x1F\x34\xF2\x07\x37\x3C\x27\x34\x1E\xB8\xB5\x1F\xB5\x69\xBE\xAA\x5F\xC2\xB2\xB5\xD2\xBE\xA6\xB8\x4B\xA4\xB6\x69\xC8\xB3\xAA\xE2\xAC\xB3\xAE\xD0\xAA\xBB\x71\xCB\xB4\xBB\xE9\x96\xB9\xB9\xCC\xB1\xAF\x75\xCD\xB1\xBB\xEC\x9F\xAF\xAF", + "\x67\xA4\x5A\x3D\x40\xB0\xBD\xE0\x9D\xBD\xBA\xD8\xA8\xBC\x77\xD2\xB9\xBD\xED\x9A\xBD\xBD\xF0\xAB\xBE\x77\xC3\xB7\xBC\xF7\x9F\xBE\xB9\xE1\xB8\xBE\x79\xEC\xB2\xBE\xF5\xAF\xBD\xBF\xF6\xB4\xBC\x7F\xFF\xB4\xC1\xFB\xB5\xB9\xBE\x05\xC2\xC3\x7C\xC5\xBE\xBE\x03\xC3\xC7\x9D\xF7\x04\xBE\x7E\xE5\xB4\xC3\x09\xD6\xC7\xC0\x00\xC8\xC2\x83\x8B\xCF\xB9\x07\xCA\xC5\xC1\x1F\xC1\xC0\x83\xA2\xCD\xC2\x0E\xF9\xB8\xC3\x09\xC3\xC6\x86\xA1\xCB\xC4\x15\xD9\xC7\xC5\x29\xC5\xC4\x88\xAE\xC1\xC7\x13\xDE\xC4\xC6\x1B\xD3\xC6\x8C\xA4\xC6\xC6\x13\xFB\xBE\xC7\x15\xC8\xC5\x8E\xBC\xCF\xC6\x1D\xFD\xC6\xC8\x45\xC4\xC9\x6F\x78\x12\xC2\x21\xEC\xC0\xC6\x43\xCD\xC7\x6B\x79\x1D\xC9\x1B\xEF\x32\x1F\xA7\x3B\x1C\x02\xFC\x17\x35\x7E\x27\x36\x1F\xC9\x27\x34\x00\x13\x0E\x24\x89\x01\x04\xCC\x67\x32\x22\x00\x68\xCB\x2E\x89\x03\x04\xCD\x83\x32\x20\x01\x70\xC8\x30\x89\x05\x04\xCE\x8D\x32\x22\x01\x78\xC2\x33\x28\xD0\xCF\xC9\x04\xC7\x00\x9F\xE4\x88\x01\x41\xC0\xCF\xC2\x56\xC7\xCA\x92\x88\xD7\xD0\x27\xF8\xC1\x7F\x09\x06\xD0\x92\xC1\xC9\xD1\x24\xD2\xCD\xA1\x0A\x12\xD3", + "\xA2\x98\x9B\x00\x4D\xEF\x74\x01\x9E\xC4\x21\x03\x21\xD0\x00\x07\x24\xD7\x01\xA4\xD0\x00\xA9\x91\x04\xD4\x09\x24\xD3\x02\xA4\xD4\x00\xA9\x95\x04\xD4\x0B\x24\xD6\xCF\x35\xD6\xD0\x8C\x97\x07\xD7\xFC\x58\x05\xD7\x8F\xC1\xDB\x8E\x97\xDA\xD7\x5C\xD4\xD5\xD1\x95\xC4\x59\x06\x40\xD3\xD8\xE3\x5A\x04\xD9\x8A\xC4\xDB\xB1\x93\xDC\xD0\x6A\xCE\xD5\xD9\xC6\xD5\xDB\xA6\xC9\xDA\xDA\x69\xDD\xDF\xCF\xC2\xD1\xD8\xB8\xD8\xD8\xD7\x72\xC0\xD6\xDC\xE1\xC5\xD8\xBA\xE4\xD0\xD1\x0D\x10\xDA\xDD\xE7\xD1\xDD\xBA\xD3\xDB\xDA\x64\xF6\xDE\xDA\xDC\xD7\xDA\xB8\xD9\xDA\xDE\x78\xF3\xDF\xDB\xFC\xD9\xDE\xC0\xF7\xD5\xDE\x7C\xD9\xBC\x03\xEF\xD4\xDC\xA4\x1D\x09\xE0\x80\xEB\xDB\xDF\x0F\xFE\xDC\xBB\xFF\xDD\xDE\x85\xE3\xD8\xE2\xF2\xD3\xE2\xC6\x98\xE4\xE3\x81\xC6\xE7\xE3\x05\xE1\xE6\xB7\x95\xE3\x3C\x0F\x0D\xE4\xE4\x28\xFE\xE2\xC8\x97\xE2\xE2\x8E\xDB\xE5\xE5\x30\xF6\xE1\xC0\x84\xE3\xE4\x95\xF5\xE4\xE6\x2C\xF2\xE5\xC4\xBA\xE9\xE2\x97\xFE\xE1\xE6\x0E\xFD\xE4\xD0\xA9\xE8\xE7\x99\xE0\xE7\xE6\x47\xF9\xE4\x50\x9F\x07\xE4\x9B\xCA\xEC\xE8\x49\xE6\xEB\xCA\xD2\xE8", + "\xE9\xA9\xFB\xE1\xE8\x1D\xE5\xEB\xD5\xD0\xE6\xEA\xA1\xFC\xE1\xEB\x51\xFB\xEA\xD3\xD4\xEF\xE9\xB1\xE2\xEA\xEB\x5E\xF8\xEB\xCB\xDF\xEB\xEC\xB5\xFF\xE4\xED\x6F\xEE\xEF\xD0\xE6\xE9\xEC\xAE\xD5\xEF\xEE\x65\xE8\xEC\xD8\xDD\xEB\xEF\xD7\x60\x05\xE9\x7A\xED\xEE\xDD\xF9\xEE\xBF\x10\x00\xF1\xEC\xB5\x42\x07\xE1\xC1\x43\x04\x52\xE4\x04\xD4\x25\x04\xD6\x09\x24\xD7\x04\x52\xE8\x04\xD4\x29\x04\xD6\x0A\x24\xDB\x04\x52\xEC\x04\xD4\x2D\x0B\xF0\xDE\xE4\xE4\xF5\x6A\x6E\x02\xF4\xC6\x6F\x04\xEA\xA5\xF5\xEE\xBA\xFD\xEC\xF0\x7C\xE2\xF3\xD8\xB0\x0B\xF5\xB3\xC8\xF7\xF5\xAC\xF8\xF6\xED\xB1\xF1\xEF\xC1\xF9\xF2\xF6\x81\xFD\xF6\xEB\xC0\xF7\xF6\xE2\xFC\xF3\xEE\xC1\xE5\xD9\x0C\x35\xFD\xF5\xE4\xF0\xE8\xF9\xFE\xB2\x07\xEA\xB3\x0C\xF8\xE4\x74\x05\xFA\xC6\xE3\xF7\xEE\xDA\xFD\xF9\xE2\xC2\xFE\xF9\x72\xEF\xFA\xF8\xE1\xF4\xFC\xDF\xDB\xF8\xF6\xDC\xFA\xF5\xF7\xC7\xF3\xFC\xF3\xEB\xF9\xFD\xD9\xE8\xFE\xFC\xBF\xFF\xFA\xEF\xD0\xFC\xFD\xE5\xE3\xF9\xFD\xF8\xF6\x4B\x1A\x18\xFB\xFF\xF0\x70\x80\xF3\x7F\x4E\x36\x0F\x7F\xC5\x67\x03\x06\x8D\x7E\xFA\x77\x7F\x01\x8C", + "\x80\x03\x8F\x7E\x0F\x8A\x7E\x12\x81\x7F\xF4\x7E\x80\x15\x8A\x80\xE0\x7E\x7E\x13\x82\x80\x17\x89\x7F\x19\x8B\x80\x18\x86\x7F\x21\x8C\x7F\x20\x8E\x81\x22\x86\x82\x24\x8F\x81\x2A\x81\x75\x38\x09\x80\x28\x8D\x80\x23\x80\x83\x2F\x83\x7F\x39\x0E\x82\x1A\x84\x81\xE7\x7D\x81\x37\x8C\x81\x39\x8D\x83\x10\x8A\x83\x25\x8B\x83\x16\x8E\x83\xB8\x7A\x03\x36\x81\x84\x48\x8B\x82\x29\x87\x82\x42\x81\x83\x11\x88\x83\x3F\x84\x84\x50\x8B\x81\x43\x81\x85\x56\x84\x85\x4E\x80\x84\x4A\x82\x83\x4D\x83\x83\xA4\x7B\x03\x47\x8B\x85\x4F\x8C\x83\x57\x83\x85\x66\x84\x86\x58\x8E\x85\x52\x88\x86\x67\x85\x85\x69\x8D\x85\x70\x89\x84\x4C\x82\x11\x3C\x01\x86\x73\x82\x86\x5A\x87\x87\x7A\x8B\x84\x7C\x8C\x85\x72\x8D\x87\x63\x8E\x86\x6D\x89\x85\x6B\x82\x88\x6C\x87\x88\x86\x89\x88\x84\x85\x86\x88\x8B\x88\x6F\x8F\x87\x7E\x88\x87\x85\x8E\x88\x14\x8D\x03\x76\x80\x88\x79\x88\x89\x93\x8A\x86\x8C\x8A\x88\x9C\x8F\x88\x92\x8D\x89\x94\x8D\x88\x9F\x83\x88\xA5\x84\x8A\x71\x81\x8A\xA0\x8B\x87\x91\x8C\x8A\x81\x83\x8A\x9E\x89\x8A\x0A\x1E\x03\x97\x8D\x8A\x9A\x82\x8A", + "\xA7\x81\x8B\x90\x8F\x8A\xB9\x80\x8B\xBE\x8D\x8B\xC0\x82\x8B\xB7\x88\x3C\x3F\x05\x8B\xBC\x82\x8C\xB6\x89\x8C\xC7\x8B\x8B\x99\x8A\x8C\xCD\x8B\x8C\xAA\x86\x8A\xC8\x80\x8D\xAE\x8F\x8C\xD6\x8B\x89\xD3\x87\x8D\xB8\x88\x62\x40\x06\x8C\xD6\x81\x04\xDE\x82\x04\xA4\x63\x04\xA4\x64\x04\xA4\x65\x04\xA4\x66\x04\xA4\x67\x04\xA4\x68\x04\xA4\x69\x04\xA4\x6A\x04\xA4\x6B\x04\xA4\x6C\x04\xDE\x88\x8D\xCC\x82\x40\x4D\x07\x8F\x5F\x1E\x04\xFC\x8B\x8A\xC3\x82\x8D\xF9\x8B\x8D\x03\x98\x3C\x4F\x0F\x8F\x02\x91\x8D\xA8\x85\x90\x09\x95\x8D\xF8\x8A\x90\xBA\x80\x91\xBF\x89\x8D\x0F\x9E\x90\x04\x92\x91\xC1\x8C\x90\x0B\x92\x23\x50\x04\x6A\x51\x08\x90\x1B\x91\x75\x52\x00\x92\xCC\x23\x05\xAB\x74\x05\xAB\x75\x05\xA4\x66\x05\x24\x93\x91\x1A\x9C\x2C\x57\x04\x6A\x58\x04\x6A\x59\x04\x6A\x5A\x04\x6A\x5B\x04\x6A\x5C\x0B\x7A\x5D\x04\x6A\x5E\x08\x67\x92\x5C\x45\x60\x04\x6A\x61\x04\x6A\x62\x04\x6A\x63\x04\x6A\x64\x0E\x8D\x65\x04\x6A\x66\x0D\x92\x19\x98\x91\x14\x95\x2B\x67\x04\x6A\x68\x00\x95\x53\x95\x17\x69\x08\x95\x12\x1A\x06\xA4\x6B\x06\xA4\x6C\x06\xA4", + "\x6D\x06\xA4\x6E\x06\xA4\x6F\x06\xA4\x60\x07\x5C\x92\x95\x2F\x9E\x92\x32\x21\x07\x6B\x9A\x47\x72\x01\x97\x01\x91\x92\x75\x91\x91\x16\x90\x90\xCE\x85\x91\x77\x9E\x96\x79\x9D\x90\x7D\x95\x3F\x73\x04\x6A\x74\x04\x97\x7B\x90\x68\x75\x06\x98\xA0\x26\x07\xAB\x77\x07\xAB\x78\x07\x8A\x9A\x8D\x7A\x96\x3C\x79\x04\x6A\x7A\x04\x6A\x7B\x04\x6A\x7C\x04\x6A\x7D\x04\x6A\x7E\x0B\x7A\x7F\x04\x6A\x80\x00\x94\x64\x42\x08\xA4\x63\x08\xA4\x64\x08\xA4\x65\x08\xA4\x66\x08\xDE\x87\x08\xA4\x68\x08\x91\x9C\x97\x87\x93\x99\x57\x29\x08\xA4\x6A\x08\xB3\x97\x91\x0A\x1B\x08\x91\x9C\x08\xA4\x6D\x08\xA4\x6E\x08\xA4\x6F\x08\xA4\x60\x09\xA4\x61\x09\xA4\x62\x09\xBB\x96\x9B\xB4\x94\x8D\x41\x23\x09\xCD\x94\x3E\x94\x03\x9D\x76\x95\x9B\x80\x98\x9D\xD7\x90\x9D\xDA\x98\x97\x81\x99\x95\xD9\x9C\x9D\xE2\x90\x00\x95\x06\x9D\xDE\x9D\x9D\x7E\x9F\x9D\x6D\x91\x95\x7F\x9B\x9D\x92\x91\x9E\xEF\x9E\x9E\xCF\x91\x9F\xE7\x93\x9E\xF3\x97\x9F\xBC\x9A\x9E\x6C\x92\x23\x96\x06\x9E\xE9\x98\x9E\xEC\x9A\x9F\xED\x95\x9F\xF4\x9F\x9F\xF6\x99\x9F\x00\xA0\x9E\xF2\x98\xA0\x07\xAE", + "\x9C\x0C\xA5\xA0\x01\xA9\xA0\xEB\x96\x11\x97\x04\x9A\xFB\x93\xA0\x06\xA0\xA1\x0A\xA4\xA0\xF8\x9E\xA0\x1E\xA0\x9F\x1D\xA0\xA2\x0F\xA1\xA2\x0B\xAF\xA1\x25\xA2\xA2\x26\xAC\xA1\x23\xAB\xA2\x29\xA9\xA1\x24\xAA\xA2\x2D\xA1\xA1\x0D\xA4\x81\x99\x0E\x9F\x32\xAA\xA1\x13\xA9\xA3\x17\xA2\xA0\x3C\xA2\xA1\x3B\xAE\xA3\x18\xA7\xA3\x2F\xAE\xA2\x2C\xA8\xA2\xE4\x3A\x09\xA4\x6B\x09\x36\xAB\xA1\x44\xA1\xA3\x4C\xA2\xA4\x45\xA7\xA2\x52\xA0\xA3\x46\xAB\x6F\x9C\x0B\xA4\x3A\xA1\xA4\x4F\xAB\xA5\x63\x7D\x09\x58\xAF\xA3\x33\xA3\xA5\x4D\xA5\xA5\x54\xA2\xA6\x50\xAE\xA4\x59\xAE\x5E\x9E\x0F\xA5\x5A\xA9\xA6\x40\xAD\x35\x9F\x0C\xA6\x41\x20\x0A\x72\xAF\xA6\x76\xA1\xA6\x65\xA9\xA7\x63\xA6\xA6\x5C\xA0\xA6\x38\xAE\xA7\x43\xA7\xA6\x64\xA9\xA1\xA1\x05\xA7\xC6\x32\x0A\xAB\x73\x0A\xDE\x84\x0A\xA4\x65\x0A\xA4\x66\x0A\xA4\x67\x0A\xA4\x68\x0A\xA4\x69\x0A\xA4\x6A\x0A\xA4\x6B\x0A\xA4\x6C\x0A\xA4\x6D\x0A\xA4\x6E\x0A\x86\xAF\xA7\x6D\xAE\x10\xAF\x01\x99\xB0\x01\xAA\x81\xAD\xA7\xA3\xAB\xAA\x3D\xA0\x63\xB1\x08\xAA\x51\xAA\xA7\x82\xA9\x1A\xB2\x00\xAB\xB4\x43\x0B", + "\xDE\x84\x0B\xA4\x65\x0B\xA4\x66\x0B\xA4\x67\x0B\xA4\x68\x0B\xA4\x69\x0B\xA4\x6A\x0B\xA4\x6B\x0B\xA4\x6C\x0B\xA4\x6D\x0B\xA4\x6E\x0B\xB6\xA3\xA8\x37\xAF\x0B\x91\x90\x0C\xCF\xAC\xA7\x6E\xA8\xA7\x7B\xA2\xAB\x28\x61\x0C\xD5\xAC\x3E\xC2\x0D\xAD\xD9\xA1\xAE\xB3\xAA\xAD\xD7\xA2\xAA\xAD\xA6\xAE\x77\xA8\xAE\xD8\xA3\xAE\xE2\xAA\xAA\xE7\xA9\xAA\xE5\xA0\xAF\x45\x73\x0C\x91\x94\x0C\xE0\xAC\xAE\xF8\xAE\xAE\xE9\xA2\xAF\xAC\xAB\xAF\xB1\xAD\xAE\xF1\xAF\xAF\xF9\xA1\xB0\x68\xA5\x74\xC5\x07\xAF\x56\x26\x0C\x08\xB4\xB0\xD0\xAA\xAF\xEB\xAE\xB0\xEA\xA1\xB1\xFC\xAF\xAE\x02\xB0\xB1\x13\xBE\xAF\x05\xBD\xAF\x04\x17\x0C\x0B\xB0\xA8\x15\xBC\xB0\xD6\xAE\xB1\x19\xB4\xB1\x23\xB8\xB1\x0D\xB0\xB2\x16\x88\x0C\x1D\xBA\xB1\x12\xBF\xB1\x22\xB7\xB2\x2F\xB1\xB2\x2C\xB7\xB1\x0F\xB8\xB2\x00\xB1\xB3\xE4\xA8\xB3\x37\xB3\xB3\x2E\xBC\xB3\x25\xB5\xB3\x3A\xB3\xB0\x41\xB6\x11\xC9\x0B\xB2\x24\xB0\xB3\x3E\xB8\xB4\x47\xB2\xB3\x4B\xB9\xB3\x49\xBC\xB4\x26\xB0\xB5\x40\xBF\xB4\x4E\xBD\xB4\x3B\xB6\xB5\x42\xB4\xB5\x57\xB1\xB5\x55\xBC\xB5\xC4\x2A\x0C\x46\xBE\xB5\x59", + "\xB8\xB5\x16\xBD\xB3\x64\xB6\xB3\x63\xB2\xB6\x65\xBF\xB3\x57\x2B\x0C\x61\xB3\xB5\x67\xB3\xB4\x68\xBB\xB6\x4A\xBA\xB6\x73\xB7\xB7\x72\xB9\xB7\x5A\xB9\xB6\x70\xB6\xB7\x7A\xB1\xB7\x7B\xB8\x62\xCC\x0F\xB6\x2D\xBC\xB6\x34\xB5\xB8\x75\xBD\xB7\xC6\x3D\x0C\x84\xB7\xB8\x8E\xB6\xB6\x7E\xB1\xB8\x78\xB2\xB9\x7F\xB1\xB9\x80\xB7\xB9\x96\xB9\xB9\x8A\xB8\xB8\x52\xBC\xB9\x5D\xBB\xB9\x8F\xB6\xB8\x90\xB0\xBA\xA3\xBE\xB9\x5B\xB4\xBA\xA2\xB9\xBA\x89\xB6\xBA\x7C\xBE\x47\xCE\x0D\xB8\xA5\xB1\xBA\xD8\x6F\x0C\xB0\xB5\x17\xD0\x0B\x7A\xD1\x0E\x8D\xD2\x04\x6A\xD3\x04\x6A\xD4\x04\x6A\xD5\x04\x6A\xD6\x04\x6A\xD7\x04\x6A\xD8\x04\x6A\xD9\x04\x6A\xDA\x04\x6A\xDB\x04\x6A\xDC\x05\xBB\xAB\xB8\x6B\xDD\x01\x99\xDE\x00\xBD\x9D\xB2\xBB\xD7\xB1\xBB\x0F\xAF\x0D\xD6\xBF\xB9\xAC\xBE\x7B\xE0\x0D\xBD\xF3\x31\x0E\xDE\x82\x0E\xA4\x63\x0E\xA4\x64\x0E\xA4\x65\x0E\xA4\x66\x0E\xA4\x67\x0E\xA4\x68\x0E\xA4\x69\x0E\xA4\x6A\x0E\xA4\x6B\x0E\xA4\x6C\x0E\xE2\xBD\xBA\xB8\x6D\x0E\x91\x9E\x0E\xFB\xB4\xB7\xD9\xBA\xBA\x03\xC0\x9F\xEF\x01\xC0\x93\xB8\xB9\xA8\xB8\x6D\xF0\x0E", + "\x8D\xF1\x0E\x8D\xF2\x08\xC0\x95\xBB\xB9\xF3\x06\xA1\xFE\x55\x0F\x12\xC6\x36\xF6\x01\x99\xF7\x09\xC1\x98\x88\x0F\xA4\x69\x0F\xA4\x6A\x0F\xA4\x6B\x0F\xA4\x6C\x0F\x16\xC6\x10\xFE\x07\x6B\x78\x63\x00\x6A\x64\x01\x0E\x11\x94\x3A\x24\x00\x30\xC9\x66\x44\x35\x00\x35\xCD\x66\x7E\xA6\x00\x39\xC1\x67\x13\xCF\xBD\x09\xCA\xB9\xA4\x77\x00\x3D\xC5\x67\x44\x38\x00\x45\xC9\x67\x44\x39\x00\x49\xCD\x67\xDA\xB4\xC0\xC5\x6A\x00\x49\xC2\xC3\xEE\x5C\x00\x4D\xC1\xC4\xA2\x67\xC5\x5C\x4E\x00\x5A\xC4\xB9\xFE\x5F\x00\x5D\xC6\x10\x10\x01\xC6\x05\x11\x01\x64\xC4\x10\x12\x07\xC6\x63\x63\xC5\x12\x15\x01\x6A\xC6\x01\x49\xCE\xC2\x0E\x19\x01\x6C\xC2\x23\x1B\x0A\xC6\xD5\x2C\x01\x78\xCF\xA0\x1D\x0B\xC7\x50\xC7\xBA\x40\xCF\xC3\xB8\x6E\x01\x7E\xC1\xBD\x4F\xC6\xC8\x7F\xCC\xBF\x87\xC5\xC0\x8C\xCE\xBD\xD8\xBE\xC8\x5F\x1F\x01\x85\xCD\xC8\x80\xCF\xC8\x95\xCB\xC8\x90\xC9\xC8\x02\xC9\xC9\x88\xCD\xC9\x94\xCA\xC8\x9A\xC8\xC5\x81\xCE\xC5\x41\x20\x02\x93\xCC\x3E\x21\x07\xCA\x97\xC1\xCA\x82\xC8\xC9\xAB\xCE\xC9\x9C\xCF\xC9\x9B\xCF\xCA\xB2\xC2\xCA\x96\xC0\x54", + "\x22\x0A\xCA\x00\x73\x02\xBA\xC3\xCB\xA0\xC0\xCB\xB4\xC1\xCB\xC2\xC1\xCC\xC4\xCF\xCB\xB5\xCD\xCA\xAC\xC4\xCA\x87\x44\x02\xBD\xC3\x76\x25\x0D\xCC\x0E\x16\x02\xD0\xCA\x23\x27\x0A\xC6\x28\x0A\xC6\x29\x0A\xC6\x2A\x0A\xC6\x2B\x0A\xC6\x2C\x0A\xC6\x2D\x0A\xC6\x2E\x0A\xC6\x2F\x0A\xC6\x30\x0A\xC6\x31\x03\xCD\x0A\xC3\xCA\x41\x22\x03\xEA\xCF\x3A\x33\x0F\xCE\x0B\xC7\xCC\xCA\xC3\xCF\xC3\xC0\x54\x34\x02\xCF\xEC\xC2\xC4\xB7\xC6\x11\x35\x0A\xCF\xF3\x96\x03\x00\xDF\x15\x37\x0A\xC6\x38\x0A\xC6\x39\x0A\xC6\x3A\x0A\xC6\x3B\x0A\xC6\x3C\x0A\xC6\x3D\x0A\xC6\x3E\x0A\xC6\x3F\x0A\xC6\x40\x0A\xC6\x41\x03\xD0\xC9\xCB\xCE\x42\x0A\xD1\xC2\x23\x04\x1E\xD4\xCF\xEB\xCD\xCF\xB6\xCE\xCA\xE3\x14\x04\x21\xD7\xCF\xBE\xCB\xD2\xA2\xC5\x04\x29\xDD\x1B\x46\x0F\xD2\xE3\x17\x04\x32\xDC\xD2\xC8\xC4\x3E\x48\x05\xC7\xFE\x5A\x04\x35\xDC\x8C\x4B\x0D\xD3\x32\x2C\x04\x40\xD5\xCF\x76\x3D\x04\x6A\xCE\x04\x6A\xCF\x04\x6A\xC0\x05\x6A\xC1\x05\x3A\xD6\x10\x53\x0A\xC6\x54\x01\xC7\x12\x17\x05\x4F\xD0\x29\x59\x03\xD4\x06\x1A\x05\x5A\xD3\x7A\x5B\x0D\xD5\xF6\xC5\xCC\x36", + "\xD4\xD4\x02\x4C\x05\x60\xD0\x00\x5D\x07\xD6\x5E\x07\xD6\x24\xD7\xD3\xB7\x2F\x05\x57\xD0\x63\x61\x0C\xD6\x3F\x82\x06\x74\xD5\x17\x63\x07\xD7\xC0\xC8\x2F\x64\x0A\xC6\x65\x0A\xC6\x66\x0A\xC6\x67\x0A\xC6\x68\x01\xD7\x00\x0A\x06\x6A\xCB\x06\x54\xDE\x10\x6E\x06\xD8\xCA\x10\x07\x67\xD1\x07\x7A\xDB\x6F\x72\x03\xD9\x2A\xD5\xD2\x1B\xDC\xCF\x5F\x13\x07\x96\xD2\xD6\x98\xDB\xD7\x63\xD3\xD2\x26\xD1\xDA\x9A\xD9\xD9\x61\xD0\x54\x74\x0D\xD9\xC6\xC7\xD9\x6E\xDC\xDA\x64\xD3\xDA\x9F\xD2\xD2\xA5\xD0\xDA\xB1\xDE\xDA\xA2\xD6\xDA\xFB\xC7\xDA\x56\x25\x07\xAA\xD6\x11\x76\x0D\xDB\xB5\xDE\xD9\xAD\xD2\xDC\xAF\xD8\xDB\x6D\xD5\xDC\xB4\xD3\xDC\xAB\xD4\xDC\x53\x77\x07\xC0\xD4\x34\x78\x0F\xDC\xC8\xD2\xDB\xBA\xD1\xDC\xCB\xD7\xDD\xA4\xD5\xDD\xCA\xD9\xDD\xB9\xDD\xDD\xF3\x99\x07\xD2\xDD\x47\x7A\x0A\xCF\x7B\x07\xD6\x7C\x0A\xC6\x7D\x0A\xC6\x7E\x0A\xC6\x7F\x0A\xC6\x80\x0A\xC6\x81\x0A\xC6\x82\x0A\xC6\x83\x0A\xC6\x84\x0A\xC6\x85\x0A\xC6\x86\x01\xDE\xB3\xDE\x9E\x87\x0C\xDF\x04\x18\x08\x00\xEE\xDD\xB0\xDB\xDD\xD6\xD9\x8D\x89\x03\xE0\xC7\xD7\xDB\x14\x8A", + "\x08\x0A\xE0\x68\x8B\x07\xD6\x8C\x0A\xC6\x8D\x0A\xC6\x8E\x0A\xC6\x8F\x0A\xC6\x90\x0A\xC6\x91\x0A\xC6\x92\x0A\xC6\x93\x0A\xC6\x94\x0A\xC6\x95\x0A\xC6\x96\x0F\xE0\xC6\xDF\x83\x97\x03\xE0\x98\x08\xE2\xC9\xD3\xDD\xB6\xDD\xDF\x04\xA9\x09\x2E\xE4\xDD\x04\xE9\xE2\x34\x6A\x09\x67\xDB\x09\x67\xDC\x09\x35\xE1\xE3\xDA\xDA\x23\x9D\x0E\xD8\xE3\x4F\x09\x3F\xE2\x73\xA0\x03\xE0\xA1\x07\xE4\xD8\xD2\x11\xA2\x0A\xC6\xA3\x0A\xC6\xA4\x0A\xC6\xA5\x0A\xC6\xA6\x06\xD8\xA8\x0A\xC6\xA9\x0B\xD8\x0A\x1C\x0A\x44\xE5\x17\xAE\x07\xD6\xAF\x0C\xE4\x98\x40\x0B\x64\xE7\xE0\x68\xE6\xE0\x78\x81\x0B\x67\xD2\x0B\x67\xD3\x0B\x67\xEA\xE6\x44\xD4\x0B\x5F\xE7\x50\xB6\x01\xE7\xFE\x57\x0B\x03\xE8\x0B\x78\xEB\xCE\xB9\x0A\xC6\xBA\x0A\xC6\xBB\x0A\xC6\xBC\x0A\xC6\xBD\x06\xD8\xBF\x0A\xC6\xC0\x0C\xE5\x06\x13\x0C\x75\xE9\x1A\xC5\x07\xD6\xC6\x0D\xE7\x87\x47\x0C\x94\xE1\xE4\x0C\xE6\xE3\x87\xB8\x0C\x97\xE7\xE3\x2F\xE9\xE9\x40\xEE\xE9\x9A\xE5\xE0\x30\xEC\xDC\x42\xC9\x0C\x9D\xEB\xE0\x32\xE6\xEA\x98\xEB\xEA\x4D\xE2\xE7\xA0\xEC\xEA\xA2\xE1\xEA\xAA\xED\xEA\xB6\xE3\xEB", + "\x19\xAA\x0C\x03\xEB\x0C\xA9\xE4\xEA\xB1\xEF\xEA\xA5\xE0\xEC\xBF\xEC\xDD\xB5\xE8\xEB\xC2\xEE\xEA\xC4\xEE\xEB\xC8\xE9\xE6\xC1\xE9\xEC\x38\xEF\xE9\xCB\xE0\xEB\xD1\xEA\x47\xCC\x0D\xEB\x6C\xBD\x0C\xD6\xE0\xED\xA0\x2E\x0C\xD9\xE9\x1A\xCF\x0D\xED\xB4\xEA\xEC\xB7\xE5\xEC\xE4\xE2\xEE\xC6\xEE\xEC\xDA\xE7\xEE\xCC\xE3\xEC\xEB\xE3\xED\xEC\xE2\xED\xE3\xE6\xEE\xE5\xEF\xEC\xA3\xE8\xDB\xD0\x00\xEE\xB2\xE3\xEF\xE9\xEA\xEF\xF5\xEB\xEF\xF2\xEF\xEF\xF4\xE1\xEE\x01\xF9\xEF\x00\xF4\x3E\xD1\x08\xEF\xC7\xE1\xEF\x03\xF9\xF0\xEA\xE0\xEF\x0D\xFD\xEC\xED\xEA\xF0\xFE\xEB\xF0\xE8\xED\xEF\x16\xF1\xEA\xD2\x08\xF0\x15\xF2\xF0\x13\xFD\xF1\x17\xF4\xF0\x14\xF1\xF1\x57\x23\x0D\x1A\xF2\xF2\xFC\xEC\xF1\x1F\xFC\xF0\x27\xF0\xF2\x1E\xF8\xF2\x2E\xFC\xF2\x29\xFB\xF1\x30\xFF\xF2\x2A\xF0\x68\xD4\x05\xF2\x0E\xFB\xF2\x35\xF1\xF2\x39\xF5\xF0\x31\xF2\xCA\xD5\x08\xF3\x66\x36\x0D\x42\xFF\xEE\x10\xFD\xF3\x3C\xF7\xF4\x4A\xF6\xF4\x4C\xFE\xEE\x4E\xF2\xF1\x3F\xF8\xF4\x2D\xF9\x85\xD7\x05\xF4\x4F\xFF\xF0\x4D\xF0\xF5\x34\xF2\xF3\x3B\xF3\xF5\x5D\xF1\xF5\x4B\xF7\xF5\x3A", + "\xFC\xF5\x64\xF6\xF2\x3E\xFB\xF5\x66\xF9\xF4\x59\xF8\xF5\x05\x18\x0D\x56\xFA\xF5\x19\xA9\x0D\x6F\xFC\xF6\x70\xFF\xF5\x68\xF2\xF5\x60\xFB\xF6\x63\xF9\xF6\x5E\xF5\xF6\x78\xF7\xF7\xFE\x5A\x0D\x73\xFB\xF7\x7F\xF3\xF3\x86\xF6\xF7\x87\xFE\xF7\x44\xDB\x0D\x83\xF7\xF6\x89\xFC\xF7\x79\xF2\xF6\x8E\xF8\xF8\x94\xFA\xF8\x7A\xF3\xF9\x96\xF2\xF9\x6A\xFA\xF9\xE9\xEC\x0D\x8D\xFB\xF9\x75\xF9\xF9\xA1\xF0\xF9\x80\xF7\xF9\x6C\xBD\x0D\x9F\xFD\xF7\x3E\x2E\x0D\xA9\xFE\x9E\xDF\x0D\xFA\xA5\xFC\xF9\x91\xF3\xFA\x85\xF5\xF9\xA4\xFF\xF8\xB5\xF2\xFA\x74\xFB\xFB\x84\xF1\xF6\xB4\xFE\xFB\xBC\xF8\xF9\xB7\xF6\xFB\xB9\xF2\x11\xE0\x00\xFB\xB8\xFA\x23\xE1\x08\xFC\x37\xA2\x0E\xCC\xFA\xFB\xBD\xF6\xFA\xAA\xF5\xFC\xD4\xF0\xFC\xD1\xF2\xFB\xCC\x23\x0E\xCF\xF3\xFC\xD0\xF2\xFC\xD5\xF2\xFD\xB3\xF1\xFC\xA0\xF2\xFE\xD3\xF6\xFD\xDE\xF6\xFE\x6C\xB4\x0E\xDB\xFF\xFD\xD8\xF9\xFC\xE0\xF1\xFB\xBF\xFF\xFE\xEE\xFD\xFE\xC4\xF8\xFE\xE5\xF2\xFF\xF5\xF8\xFF\xDD\xF3\xFE\xD7\xF1\xFF\xF4\xF9\x8D\xE5\x07\xAC\x66\x07\xF5\x76\xFF\x7B\x37\x39\x04\x80\xFA\x7C\xFB\x4A\x80\xF6\x7E", + "\xFF\x0D\x80\xF9\x61\x7F\xFD\x7F\x01\xB0\x7E\x09\x83\xFF\x0E\x81\x04\x97\x80\xE7\x79\x01\xBE\x52\x74\x0A\xC6\x69\x04\x02\x9F\x7F\x0B\x85\x00\x93\x80\x0C\x8C\xFF\x19\x80\x08\x8C\x80\x14\x81\xFF\x67\x80\x11\x85\x01\xA9\x83\xFE\x77\x7F\x2B\x82\x03\xAC\x80\x15\x86\x01\xA6\x81\x0D\x85\x81\x34\x32\x1D\x1F\x81\x1B\x80\x03\xBC\x82\xFA\x0B\x07\x3B\x86\x05\xA1\x80\x19\x84\x04\xB1\x82\x11\x9E\x81\xEC\x1C\x1D\x01\x82\x12\x8D\x03\xDD\x6D\x3B\x07\x6B\xEE\x03\x09\xB6\x80\x21\x88\x02\xCC\x80\x04\x93\x82\x56\x84\x59\x2F\x06\x29\x88\x03\xCD\x83\xE1\x50\x07\x67\x69\x1E\x1C\x82\x2F\x88\x05\xE5\x81\x17\x97\x82\x67\x83\x04\xB5\x14\x79\x03\x06\xA9\x0F\x3C\x0D\x83\x6A\x81\x0D\xAD\x81\x2C\x83\x07\xE6\x80\x19\x92\x83\x34\x84\x0A\xB3\x81\x17\x88\x06\xF0\x4C\x3D\x10\x83\x75\x80\x0F\xBC\x83\x38\x87\x07\x85\x85\x1F\x87\x84\x84\x80\x11\x81\x84\x43\x89\x08\x8D\x87\x22\x8A\x84\x79\x84\x0E\x91\x85\xFC\x15\x0F\x00\x87\x24\x82\x84\x43\x85\x20\x36\x06\x4B\x83\x08\x8F\x86\x23\x97\x84\x8C\x86\x13\xA2\x84\x7C\x17\x0F\x1C\x85\x26\x88\x82\x80\x60\x1F", + "\x27\x6B\x7C\x06\x0A\xD5\x82\x1D\x90\x84\x9D\x80\x14\xB0\x85\x53\x80\x00\x7A\x05\x2B\x9B\x83\xB4\x83\x3E\x7B\x07\xB3\x6C\x0F\x37\x85\x11\x88\x85\xB2\x87\x13\xB1\x85\x61\x89\x0B\xDF\x09\x3F\x1E\x85\x05\x0E\x1F\x08\x86\x60\x84\x0C\xAE\x84\x26\x8E\x86\xA1\x81\x18\xA3\x85\x66\x88\x0B\xD0\x87\x2C\x96\x86\xDC\x13\x19\xBA\x83\x5F\x8B\x0D\xC7\x81\x37\x8C\x86\xC5\x87\x19\x95\x87\x71\x8C\x0D\xD5\x14\x00\x15\x00\x65\x30\x1B\x93\x87\x70\x81\x0D\xD4\x85\x39\x8F\x85\x16\x41\x00\x28\x86\x1B\x64\x0E\xDE\x86\x24\x8E\x87\xF6\x80\x1E\xAB\x86\x75\x82\x0D\xFD\x84\x3E\x80\x87\xFC\x87\x1F\x9F\x86\x00\x02\x00\x73\x86\x0E\x75\x87\x00\x88\x21\x83\x89\x7B\x8C\x0E\xD7\x85\x35\x43\x00\x06\x8E\x87\x4A\x88\x86\x85\x74\x04\x01\x44\x86\x62\x44\x6D\x00\x17\x88\x25\x66\x36\x06\x03\x46\x92\x0C\x07\x07\x23\x92\x08\x04\x02\x12\x8E\x09\x02\x05\x89\x0A\x0A\x01\x28\x88\x83\x0B\x00\x2B\x89\x41\x0C\x00\x2E\x8A\xD4\x31\x89\x52\x33\x13\x8F\x03\x4C\x90\x00\x33\x8C\x22\xAC\x59\x08\x09\x13\xF9\x1E\x04\x1D\x89\xE2\x87\x1D\x81\x8B\x7C\x82\x2A\x13\x00\x50\x90", + "\x4F\x14\x07\x28\x8E\x88\xA1\x8D\x0E\x8D\x8A\x30\x8E\x8A\xFB\x83\x22\xBA\x86\x7F\x80\x15\xD4\x89\x40\x8D\x63\x4A\x8F\x29\x97\x8B\xAD\x82\x15\xC3\x89\x42\x8C\x8A\x4B\x8C\x28\x8D\x8A\x87\x76\x01\x59\x89\x54\x80\x8B\x5A\x8D\x2B\xA3\x8A\xB5\x81\x16\xDF\x8A\x58\x8D\x8B\x0B\x8B\x2A\x82\x88\x9D\x88\x16\xE7\x8B\x5B\x84\x50\x17\x06\x2C\x96\x8A\xB6\x89\x16\xF5\x8B\x5E\x9E\x8B\x73\x8A\x2E\x95\x8B\xC0\x8E\x15\xF1\x89\x61\x94\x8B\x77\x8E\x2E\xAE\x8B\xC5\x86\x18\xEB\x88\x60\x83\x8C\x90\x8E\xE1\x58\x00\xBD\x84\x18\x8E\x8D\x62\x98\x17\x19\x04\x32\xBE\x10\x0D\x0A\x19\xDC\x8B\x63\x9E\x8C\x97\x8D\x32\xB0\x8A\xC4\x80\x2A\x1B\x01\x67\x9C\x8B\x8A\x8D\x31\xB7\x14\x0E\x07\x1A\xC1\x11\x07\x0D\x8D\xA1\x89\x32\xA8\x8D\xBF\x81\x1B\xA0\x8C\x63\x95\x16\x1E\x00\x36\xA3\x4F\x0F\x0A\x1B\xAA\x8D\x5F\x95\x8D\xB3\x8A\x34\xBF\x8D\xDB\x82\x18\xB6\x8E\x6F\x89\x8D\xA4\x8F\x38\xB5\x1E\x10\x0D\x1B\xC9\x8E\x73\x85\x8E\xC1\x8A\x36\x9F\x8D\xE8\x86\x1C\xCF\x8F\x61\x90\x8E\xD3\x89\x3B\x80\x8E\xED\x84\x1C\xB4\x25\x08\x1D\x8D\x22\x03\x26\xA3\x01\xE6\x88\x1D", + "\xDB\x8E\x79\x9D\x8E\x96\x88\x3D\xA3\x8D\xF2\x8A\x1E\xC3\x8E\x72\x82\x8E\xC8\x8C\x3D\xAF\x8E\xE9\x87\x1E\xF3\x8D\x75\x92\x8F\xD6\x89\x3D\x83\x88\x12\x04\x1E\xD7\x8E\x7F\x9A\x8F\xF9\x8B\x3D\xBF\x8E\x01\x90\x20\xF8\x8E\x81\x94\x31\x25\x05\x3F\x85\x91\x01\x9C\x3E\x26\x02\x82\x8E\x4F\x27\x07\x41\xB9\x0C\x14\x03\x13\xA9\x03\x4C\x8A\x01\x33\x8B\x05\x33\x88\x16\x03\x13\xAD\x03\x4C\x8E\x01\x33\x8F\x05\x33\x88\x18\x03\x13\xB1\x03\x4C\x92\x01\x12\x91\x3E\xB8\x3D\x19\x09\x22\xF8\x14\x0D\x0D\x91\xF0\x8C\x36\xAD\x8F\xD4\x85\x03\x30\x90\x7D\x8C\x8C\x36\x06\x46\xBE\x53\x1B\x0B\x11\x84\x03\x8D\x96\x8F\xD4\x89\x48\x9C\x8E\x20\x93\x24\x81\x91\xB1\x3B\x01\x33\x8C\x07\x3A\x90\x21\x90\x29\x3D\x03\x92\x9D\x1A\x3E\x05\x37\xBF\x01\xDE\x80\x04\x4F\x91\x7D\x98\x35\x41\x03\x26\x82\x03\x99\x83\x04\x33\x88\x11\x13\x89\x45\x03\x26\x86\x03\xDE\x87\x04\x33\x88\x12\x1B\x88\x54\x67\x90\x0A\x03\x99\x8B\x04\x33\x88\x13\x13\x89\x4D\x03\x26\x8E\x02\x2B\x94\x10\x4F\x03\x4C\x90\x02\x74\x94\x48\xB5\x8F\x28\x03\x13\xD2\x01\x9E\x87\x5C\x53\x07\x4F\x9F", + "\x0A\x2A\x03\x13\xD5\x03\x4C\x96\x02\x33\x8F\x0A\x33\x88\x2C\x03\x13\xD9\x03\x4C\x9A\x02\x82\x94\x41\xAA\x91\x83\x2B\x05\x3D\x93\x8F\x86\x92\x93\x94\x40\x9A\x94\xF7\x88\x29\xB2\x92\xDD\x1F\x02\x91\x93\x41\xA2\x95\x4D\x99\x29\x9C\x97\x81\x83\x95\xA6\x92\x52\x9E\x95\x77\x20\x06\x21\x94\xA9\x8B\x95\xA7\x97\x55\xB1\x91\x59\x97\x29\xB1\x95\xAA\x88\x95\xF3\x19\x0C\x2E\x95\x5B\x92\x2B\xB5\x96\xAA\x94\x95\xF7\x8F\x57\xBE\x94\x5C\x90\x2B\xF5\x0A\x18\x1B\x95\xA5\x91\x59\x85\x96\x62\x90\x2C\xCC\x93\x8C\x8B\x96\xBD\x91\x58\x8C\x97\x61\x9E\x9E\x63\x00\xB2\x90\x96\xBC\x91\x5B\x8A\x97\x66\x95\x24\xB6\x97\xB6\x94\x96\xDA\x90\x5B\x9F\x96\x69\x9B\x6F\x64\x03\xB5\x9C\x96\x57\x96\x5B\xA2\x97\x75\x98\x2E\xCF\x95\xBB\x91\x58\x65\x07\x5C\xA0\x97\x71\x9E\x2C\xFA\x92\xBB\x93\x97\xEC\x92\xE4\x66\x02\x79\x94\x2E\xE1\x97\xBB\x9D\x94\xFF\x92\x5D\x81\x98\x61\x9D\x2F\xF4\x95\xB7\x98\x3D\x67\x04\x5F\xB5\x96\x80\x98\x2F\x83\x9B\xB4\x85\x98\xF9\x90\x62\x99\x46\x34\x0A\x30\x87\x9B\xC3\x8B\x98\x02\x9D\x61\x9A\x98\x89\x9B\x31\x98\x98\xC1\x9E\x98", + "\x17\x9C\x1B\xA9\x03\x8A\x99\x2E\x9F\x9A\xC5\x91\x96\x20\x98\x65\xA7\x98\x7F\x93\x60\x6A\x00\xC9\x97\x97\x1C\x99\x66\xA9\x98\x96\x92\x33\xAB\x9A\xC1\x85\x08\x6B\x07\x65\xB6\x97\x9D\x9C\x30\xB5\x99\xC9\x81\x99\x3F\x9A\x65\x81\x9A\x9A\x93\x33\xBD\x0C\x1B\x1A\x99\x3D\x9D\x68\x91\x98\xA5\x9E\x30\xC2\x98\xCC\x8C\x9A\xCC\x45\x0D\x08\x9B\x8C\x9E\x33\xCF\x9A\xCD\x8B\x9A\x57\x9D\x69\x84\x9B\xAC\x9E\x23\x6E\x03\xD4\x86\x99\x43\x9F\x66\x96\x9B\xB0\x98\x35\xE4\x9A\xD6\x82\x9B\x3C\x9C\x6A\x90\x9B\xAA\x99\x36\xE0\x9B\xD8\x8F\x9B\xD6\x47\x0D\x1F\x9A\xA0\x90\x37\xC9\x98\xD7\x8C\x9B\x76\x9E\x6C\xBF\x90\x38\x03\x37\xCE\x99\xDB\x94\x9B\x7F\x9E\x6F\xB9\x9B\xBA\x9A\x36\xF7\x98\x51\x71\x03\x7D\x9B\x6B\xBA\x9A\xBC\x95\x38\x8B\x9F\xDA\x8F\x9C\x86\x99\x72\x8E\x9D\xB5\x72\x07\x09\x9C\xDA\x83\x9C\x81\x9A\x71\x84\x9C\xB7\x99\x39\x97\x9D\xE3\x9B\x9C\x80\x98\x73\xA2\x9D\xCF\x9D\x39\xE5\x98\xE8\x82\x9C\xA4\x99\x39\xB3\x02\xCB\x96\x3A\xBB\x98\x1D\x0C\x9D\x28\x35\x0E\x39\x92\x3B\x03\x13\xF7\x03\x4C\x98\x03\x33\x89\x0F\x33\x88\x3D\x03\x13\xFB", + "\x03\x4C\x9C\x03\x33\x8D\x0F\x33\x88\x3F\x03\x13\xFF\x03\x4C\x80\x04\xB0\x9D\x63\x9D\x1B\x40\x0A\x33\x82\x05\xF2\x8C\x9C\x9C\x9B\x74\xB4\x25\x41\x0F\x3C\x90\x9E\x37\x84\x04\xD5\x9E\xBD\x05\x05\x3C\x96\x08\x33\x8B\x21\x13\x89\x88\x03\x26\x89\x05\x99\x8A\x08\x33\x8B\x22\x13\x89\x8C\x03\x26\x8D\x05\x99\x8E\x08\x33\x8B\x23\x13\x89\x90\x01\x7B\x93\x9D\xD7\x11\x09\x3A\x9A\x24\x12\x9F\xA7\x9A\x73\xA5\x9C\xDF\x33\x09\x78\x9E\x1F\x34\x04\xFE\x9A\x7A\xA1\x9D\xD4\x94\x40\xD1\x9D\x01\xA3\xA0\x06\xA1\x81\x88\xA1\x05\xA9\x1A\x15\x05\x00\xA7\xA0\xA8\x9A\x81\x91\xA0\x06\xAA\x3F\x82\xA3\x04\xBD\x5C\x96\x07\x81\x92\xA1\x0A\xA0\x41\x9C\xA3\x06\xBE\x9C\x1F\xA5\x75\x96\xA0\xF6\x17\x09\x1A\xA0\x05\xA0\xA1\x27\xA2\x84\x9D\xA0\x14\xA7\x41\x9E\xA1\x0A\xAF\x97\x98\x06\x84\xAD\xA0\x16\xAE\x42\xB3\xA2\x0A\xA1\xA1\x67\x9F\x86\xAF\xA0\xE5\x98\x60\x19\x06\x0C\xB5\xA1\xC5\x32\x13\x28\x93\x01\x3C\x09\x3F\xA1\x53\x3D\x04\x3A\x9E\x13\x06\xA3\xD6\x5F\x09\x33\x88\x28\x13\x89\xA1\x03\x26\xA2\x05\x99\x83\x0A\x43\xA2\x43\x05\x05\x33\x8E\x14\x1B\x88", + "\x39\x6A\x10\x29\x06\x15\xBA\x11\xAB\x03\x89\xBE\x3C\x56\x02\x46\xBC\xA1\xFE\x94\xA1\x68\xA2\x87\xB6\xA1\x1C\xAC\x46\xE6\xA3\xFE\x9B\x1A\xAD\x05\x8C\x90\x9F\x1D\xA3\x47\xEB\xA2\x1B\xA3\xA1\x69\xA5\x8D\xAC\x9A\x57\x02\x47\xD6\x9F\x19\xAA\xA3\x40\xA1\x8F\xB7\xA3\x15\xA0\x48\x82\xA4\xD1\x0F\x05\x7D\xA2\x72\xBF\xA2\x3D\xAE\x47\xEF\xA1\x1D\xA1\xA4\x85\xA1\x92\xB5\x1A\x58\x09\x48\xF3\x9F\x22\xA3\xA4\x38\xA0\x93\xB4\xA3\x46\xA8\x47\x92\xA6\x44\x11\x05\x95\xA7\x92\x8F\xA4\x43\xAC\x49\x84\xA4\x23\xAA\xA4\x8E\xA5\x94\xB5\x0A\x59\x01\x4A\xA9\xA4\x2A\xBD\xA4\xA7\xA6\x92\xAE\xA4\x59\xA0\x4B\x9A\xA5\x6A\x13\x05\xAD\xA5\x96\xA3\xA4\x4F\xAB\x4B\xB1\xA6\x28\xAA\xA5\x9B\xA3\x48\xB4\x05\x5C\xA6\x4A\xB6\xA4\x24\xBE\xA5\xB3\xA7\x97\xAF\xA5\x62\xAC\x36\xB5\x04\x31\xB9\xA4\xBD\xA6\x98\xA4\xA5\x65\xA0\x4D\xC0\xA6\x1D\xA8\x81\xB6\x07\x99\x81\xA6\x5A\xAC\x4C\xD6\xA7\x31\xB2\xA6\xBC\xA6\x9B\xA9\x8D\x5B\x0A\x4D\xD7\xA6\x38\xA1\xA7\xD4\xA3\x9B\x8A\xA6\x6E\xA5\x4D\xC3\x90\x2E\x05\xA7\xDF\xA1\x9A\xB2\xA7\x73\xA8\x4C\xBA\xA4\x3D\xA0\xA7\xDC", + "\x69\x17\x30\xA7\x69\xAC\x4E\xEA\xA5\x32\xBF\xA7\xF6\xA1\x9D\xA6\xA6\x81\xA1\x4F\xF7\xA4\x17\x3A\x05\x79\x93\x17\x3B\xA6\x74\xA7\x48\x3C\x07\x17\xAE\x2F\xBE\x03\xA1\xB5\x1B\x5F\x0A\x33\xC0\x06\x44\xAC\x46\xC1\x03\x26\x82\x07\x99\x83\x0C\x33\x88\x31\x13\x89\xC5\x07\xA1\x85\x09\x63\x03\x13\xC8\x07\x16\xB2\x08\xCB\x02\xA4\xA0\x15\x66\x07\x51\xD9\x2E\x33\x0D\xA9\x06\xA9\xA6\x84\xA8\x7E\xAB\x4E\xB5\xA8\x40\xBD\xA6\x33\xAC\xA1\xB6\xA9\x80\xA0\x29\x4F\x05\x9E\x90\x06\x30\xA9\xA7\xB5\x1B\x68\x0A\x52\x84\x33\x34\x01\xAA\xAF\x1C\x1A\x3A\x99\x6A\x08\x54\xE3\x4E\x35\x13\x89\xD7\x03\x26\x98\x07\x99\x89\x0D\x33\x8A\x36\x05\xAA\xDC\x03\x26\x9D\x07\x93\xAE\x10\x60\x05\x51\xAA\x0E\xE2\x05\xA9\x84\x31\x71\x02\x56\xEF\x24\x39\x05\xAB\x38\xAD\x9F\x83\xA8\xB5\xA5\x50\xC2\xA8\x3E\xAF\xAB\xF3\xA6\x20\x25\x06\xB4\xAD\x4E\xEC\xA8\x4D\xB7\xA9\x75\xAB\xA7\xA9\xAA\x07\x86\x0E\x74\xAA\x3F\xBC\xA9\x7A\xA9\xAF\xB8\xAB\xBF\xAB\x57\x83\xAF\x5A\xB0\x31\xE7\x06\xAF\x87\xAC\xC3\xAD\x56\xF6\xAA\x4E\xAC\xAC\x77\xA8\xB0\xBB\x7C\x74\x0A\x58\x8D\xAD", + "\x60\xA4\xAC\x82\xAA\xB2\x9A\xAD\xC2\xAB\x59\x9C\x9D\x3A\x15\xAC\x91\xAC\xB3\xA2\xAD\xCC\xA3\x5A\x98\xAE\x69\xBC\x40\xEA\x00\xB4\x8F\xAD\xCE\xA7\x5A\x96\xAC\x64\xAB\xAD\xA5\xAB\xB1\xAC\xAD\x5B\x1B\x0E\x7E\x9C\x3B\x0A\xAD\xF5\xA1\xB6\xAE\xAD\xD9\xAB\x5B\xBA\xAD\x68\xB8\x3D\xED\x00\xB7\x92\x08\x77\x0E\x3F\xEF\x06\x70\xB1\xAB\x8E\xA9\xB7\xA4\xAD\xE5\xAD\x5A\xBF\xAC\x05\x50\x07\xC7\xAA\xA6\x89\xAE\xB8\xA2\x5D\x97\xAE\x6C\xBE\xAD\x40\x29\x1E\x11\xAE\xB7\xA8\x5C\xD6\xAD\x6F\xAC\xAE\xD7\xA8\xBC\x9F\xAF\xE6\xA0\x5B\xEC\x5A\x3C\x1B\xAE\xD3\xAD\xBB\xAF\xAC\xE5\xA4\x5E\xEC\xAD\x78\xB4\x40\xF3\x00\xBD\x9E\xAF\x0C\x54\x0F\x3D\x8D\x3D\x12\xAF\xEB\xAC\xBA\x9C\xAF\xEA\xA9\x5F\xEA\xAC\x6F\xA2\x2F\xF8\xAF\xBF\xA5\xAF\xF6\xAA\x5F\xE9\xAC\x7F\xA2\xB0\x98\x27\x1E\x01\xB0\xEC\xAE\x7B\x78\x05\x6F\x99\x07\x0B\xB2\xBC\x8E\xAF\xF7\xA4\x61\xE3\xAD\x85\xAD\x81\xFA\x01\xC2\x84\xB0\xFF\xAC\x60\x85\xB3\x7C\xA3\xB0\x17\xB0\xC4\x96\xB1\x11\xB3\x61\xA4\xB2\x88\xA5\xB1\x28\xB4\xE1\x7B\x07\x99\x8C\x0F\x1A\xB1\x88\xAE\xAF\x26\xB0\xC6\xA9\xB0\x19", + "\xB7\x62\xB5\xB0\x8D\xAF\x97\xFD\x06\xC5\xB1\xB0\x51\x6E\x0F\x7F\x92\x8E\xB3\xB1\x16\x0E\x02\x31\x61\x01\x32\x00\x42\xB0\x3D\x8B\x67\x03\x06\xC8\x87\x89\x3E\x24\x00\x4A\xB2\x44\x88\xA5\x05\x06\xC9\x98\x88\x83\x06\x00\x52\xB0\x47\x86\x08\x07\x06\xCA\x92\x0C\x04\x0A\x65\x92\x09\x02\x16\xB2\x69\x94\x20\x0B\x01\x2E\xBE\x10\x0C\x02\x95\xBC\xA2\x06\x0F\x01\x20\xB2\x89\x01\x01\x64\xB2\x42\x12\x00\x6E\xB4\x1B\x93\x01\x38\xBE\x0D\x94\x00\x9D\xBF\xB0\x37\xB4\x8C\x15\x01\x3B\xB6\x37\x16\x00\x9F\xA8\xB0\xE5\x57\x02\x2B\xB3\xEC\x29\x01\x7F\xB1\xE9\x5A\x00\x86\xB0\x79\x1B\x01\x44\xB0\x38\x9C\x00\x9F\xBD\x00\x7C\xB6\x03\x3C\xB3\x0F\x0C\x67\xA0\x03\xA0\xAA\x08\x22\x04\xCF\xA3\x01\x33\xB2\x11\x26\x03\xA5\xA6\x08\x28\x04\xCF\xA9\x00\x46\xB1\xFE\x2A\x00\xA9\xB3\x80\x2B\x07\xD4\x80\xB2\x0E\xB2\x2A\x2C\x02\xAA\xB8\x17\x2D\x07\xD5\xB9\xB2\x3F\x5E\x02\x1F\xB4\x82\x30\x01\xB2\xB5\x5C\x71\x01\x5C\xB4\x34\x32\x00\xAF\xB5\x97\x33\x04\xCF\xB4\x00\x3E\xB5\x03\x7C\xB2\x0D\x1C\xB3\x37\x06\xD6\x84\x09\x1C\x0C\x67\xBA\x00\xA7\xAE\x08\x3D\x02", + "\xD9\x97\x13\x1F\x0F\x6B\xEB\x78\x10\x15\xB6\x06\xB3\xBF\xAE\x2F\x20\x08\x6D\xF8\xB2\x87\xBD\xAF\x07\xB5\xC3\xAC\xB5\x0D\xB1\x6E\x92\xB2\x8D\xBF\xB6\x80\xB3\xDC\xAF\xB0\x74\xB9\x3F\x42\x01\xB7\xB6\x46\x43\x07\xDD\xA9\xB7\x72\xBF\x1A\x44\x02\xBC\xBF\x0A\x45\x07\xDE\xA6\xB7\x6C\x46\x04\x52\xB7\x3B\x28\x02\xFA\xB0\x3E\x49\x03\x80\xB7\x2B\x4A\x00\xC1\xAE\x8F\x4B\x04\xCF\x8C\x02\x3E\xBD\x04\x7C\xB2\x13\x1C\xB3\x4F\x02\xDA\x91\x02\x3E\xB2\x05\x4F\xB6\x42\x15\x02\xD2\xB7\x0A\x3C\xB2\x2C\x07\x70\xB2\x75\x16\x1D\xB8\x0C\x7A\x0B\x20\xB9\x59\xB4\x6F\xA9\x0F\x16\x03\xB9\x12\x0C\x0B\x28\xB8\x75\xB6\x81\x5D\x02\xBF\xA3\x27\x5F\x03\xE5\x95\x46\x30\x02\x73\xC1\x11\x18\x15\xB9\xDE\x82\x0C\x3C\xB3\x31\x0C\x67\xE4\x00\x9F\xA5\x03\x7C\xB6\x0C\x12\xB6\x34\x0C\x67\xE9\x02\xC5\xA6\x08\x6C\x02\xDA\xAE\x02\x3E\xBF\x06\x38\xBB\xAD\x70\x03\x4E\xBD\xBB\x71\x03\xA8\xB3\x6F\xDA\xB5\x41\x12\x03\x51\xBB\x0E\x14\xBA\x71\xB1\x75\x74\x03\xCB\xB4\x25\x76\x03\xEB\xB8\x3D\x3B\x02\x76\xAF\x0C\x1E\x05\xBB\xE1\x79\x0F\x3C\xB2\x3D\x0C\x67\xFB\x00\x9F", + "\xBC\x03\x7C\xB5\x0F\x12\xB7\x3F\x0C\x67\x80\x07\xD1\xA5\x08\x83\x07\xEB\xAF\x0D\x42\x08\x76\xDE\x5E\x21\x1D\xBB\xAB\xB5\xE4\x8C\x17\x43\x00\x78\xE7\xB4\xCB\xA1\xBC\x56\xBE\xDB\x87\xBC\xC3\xB2\x78\x88\xBD\xB6\xAF\xBC\x8A\xBD\xF1\x8C\xBD\xC4\xB6\x37\x08\x05\xE1\xA8\x31\x7B\x03\x07\x03\xB3\xB4\x05\x2D\x61\xB2\x6E\x1D\xBC\x6B\x08\xF4\x9C\xBD\x5A\x1E\x79\x94\x0A\xE8\xBD\x0B\xA7\xBD\x36\x29\xBC\xE1\x0B\x7A\xA7\x11\xEB\xBF\xBC\xA4\xB9\xF4\xB1\xBD\xD1\xB2\x2A\x25\xBE\xE9\xB5\xBD\xB2\xB8\xF7\xB4\xBC\x61\x16\x7B\xB7\xBF\xAD\x13\x0F\x92\x0E\x47\x8E\x08\x2F\x0B\x16\x05\x02\x44\x0D\x05\x66\x32\x22\x07\x01\xDC\xB8\x10\x42\xBE\x42\x04\xBE\x69\x0E\xF8\x8E\x08\xE4\xB9\x0E\x8A\x0B\xF2\xBB\xBD\x02\x0D\xF7\xBE\xBC\x80\x08\x66\x90\x16\xF3\xA6\x08\xD0\xBD\x2F\x12\xBE\x85\x04\x7D\xC7\xB1\x41\x17\xBE\xA8\xB8\x22\x1A\xBF\xED\xBD\x7D\xA0\x17\xF7\xA5\x08\xE1\xBD\x36\x23\xBE\x83\x05\x7E\xCB\xB3\xF9\xAC\xBE\xD9\xB8\xFF\x81\x09\xF6\xB7\x25\x6F\xBC\x41\x11\xBF\xC2\x0B\xFE\x85\x09\xFA\xBF\x64\xF7\xBC\xF6\xA1\x08\xEB\xBE\xF7\xBC\xBE\xE5\x0E", + "\x7F\x80\x00\x00\xC7\x11\x02\xC4\x20\x04\xC1\x29\xB6\x80\xE9\xBC\x43\x09\xC0\xB7\xBB\x01\xDF\x0B\x06\xCF\x80\xBA\x0D\x04\xC0\x00\x13\xC7\xCA\x95\xC0\xD5\xBA\x7E\xFA\xBC\xF7\xBE\x11\x92\x09\x01\x09\xBE\x87\x0D\x80\xC3\x01\xF1\xB2\x08\x7F\x03\x05\xD6\xBE\x13\xCF\x0F\x29\xC2\x0C\xC6\x08\x2D\xC7\x05\xCE\x09\x18\xC5\x7D\xD8\xB0\x0D\xD8\xC0\xA6\xBA\x03\xF5\x0A\x1B\xCD\x83\x85\x09\x0E\xD1\xBE\x30\xC7\x06\xE3\xC0\xD6\xB5\x82\x87\xC3\x09\xD2\x11\x44\xC6\xFC\x84\x09\x23\xC2\x7E\xC9\xC1\x11\xC4\x08\xE8\xBC\x04\xD7\xC0\x1A\xC2\x84\xAF\x0D\x14\xD6\xBF\x53\xC2\x22\x2E\xC0\x24\xCB\x83\xCA\xC0\x16\xDF\xC1\x5C\xC0\x05\xDE\xB2\x33\xC0\x00\x54\xC2\xFC\xB6\xC2\x52\xC0\x00\x19\xC2\x26\xCB\x85\xCE\xC3\x3F\x1D\xC2\xA9\x0F\x0B\xC5\xC1\x30\xCE\x10\x63\xC1\x15\xC5\xC3\x57\xC2\x0E\xE8\xC2\x3B\xC8\x87\xB9\x0F\x96\xAC\xC3\x6E\xC1\x00\xF0\xC2\x30\xC2\x88\xF6\xC3\x21\xC1\xC4\x89\xC0\x02\xCB\xC5\x3D\xCD\x88\x96\xC0\x42\x00\xC2\x14\x0D\x10\xFD\x0D\x47\xC1\x87\x91\xC6\x07\xD3\xC4\x14\xC7\x0C\xF6\xC2\x4C\xC0\x11\x1A\xC7\x78\x1C\xC4\x8C\xC6\x13", + "\xD4\x09\x0F\xCC\x83\xF1\xC3\x1C\xCE\xBD\x4D\xC6\x12\xC2\x08\x53\xC6\x11\x28\xC4\x25\xCA\xC5\x10\x0C\x15\xEC\xC3\x57\xC0\x7B\xF5\xC2\x2C\xDB\xBF\x6A\xC6\x21\x08\x00\x44\xC2\x86\xBA\xC2\x42\x0D\xC5\x8C\xC4\x17\xDB\xBF\xFC\xB4\x88\xC1\xC6\x42\x03\xC6\x90\xC5\x18\xE4\xC3\x63\xCB\x8B\x83\xC7\x2F\xCF\xC2\x3A\x14\x14\xFA\xBD\x6B\xC8\x2F\x5A\xC4\xEF\xB4\xC1\x56\x16\x1B\xF7\x14\x71\xCC\x2C\x64\xC4\xB1\x06\xC7\xDD\xC0\x1C\xFE\x10\x74\xC1\x8E\xEA\xC6\x8C\x0C\xC7\xEB\xC6\x1D\xD9\xC6\x79\xC1\x24\x70\xC7\x3B\xD4\xC7\x90\x16\x1E\xFA\x11\xF9\x0D\x80\xFA\xC5\x3D\xD8\xC7\xA0\x16\x1F\xF9\xC6\x80\xC7\x25\x02\xC9\x40\xC4\xC8\xCA\x0E\x20\xC5\xC8\x84\xCF\x15\x0A\xC9\x42\xCC\xC8\x75\x0E\x21\xCD\xC8\x88\xCF\x1A\x12\xC9\x44\xD4\xC8\xA9\x0E\x22\xEF\x0C\x7E\xCC\x86\x96\x0B\x07\xCD\xC0\x31\x06\x18\xC6\x08\x31\x0C\x86\x9F\xC1\x18\x0E\x33\x76\x32\x22\x23\x03\x94\xCE\x10\x4A\xC7\x32\xC0\x08\x92\x0E\x23\xF2\x32\x89\x01\x92\xD3\xC7\x48\xC5\xC9\x12\x0F\x24\xCE\x08\xFE\xBF\x81\xAB\xCA\x43\x1F\xC0\x2E\xCF\x25\xE8\xC6\x5A\xCD\x91\xAC\xCA\x42\x00", + "\xC9\x22\xCD\x20\x24\xC9\x40\xC6\x92\xA8\xCB\x4F\xCA\xC9\x46\xCE\x07\xE3\xC5\x34\xC0\x85\x96\x09\x54\xC6\xC2\x34\xC9\x29\xC4\x09\xA5\xC1\x87\xCD\xCB\x4E\xD7\xCA\x04\x0E\x27\xCA\x08\xA0\xC6\x8D\xDA\xC0\x42\x04\xCA\x81\xC2\x26\xEC\xC1\xAC\xC6\x93\xCA\xC8\x4E\xCE\x08\x3A\xCA\x21\x3C\xC8\xA8\xCF\x94\xAD\xC9\x59\xD4\xC3\x67\xCE\x19\xD6\xCB\x82\x0F\x91\xEC\xCB\x1F\xCA\x08\x5C\xCC\x11\xDE\xCA\xB9\xC0\x96\x80\x02\x58\xC6\x08\x64\xCB\x2A\xCD\xC7\xAA\xCB\x97\x88\xCF\x4C\xCE\x08\x35\xCF\x2F\xF7\xC8\xA6\xC9\x93\xCE\xCB\x58\xD4\xCB\x97\xCE\x2E\xCA\xCC\x6E\xC8\x96\x8D\xCF\x89\x1E\xBC\x92\x0E\x00\x04\xC7\x3E\xCA\x95\x80\x00\x32\xD4\xC4\x41\xCB\x19\xE1\xCD\xD1\xCA\x10\x7E\xC3\x1B\xC0\xC4\xAE\xC7\x2E\xF0\xC4\x86\x0D\x99\x8C\xC6\x68\xD1\xC6\xA4\xCD\x2D\xC4\x09\xD3\xC1\x8A\x95\xC6\x59\xCC\xC6\x9C\xCA\x2F\xC5\x09\xDB\xCD\x89\xD2\xC6\x64\xC5\x08\xBC\xCA\x04\xE2\xC4\x6E\xC3\x94\xC2\xCC\x41\x04\xCE\xA9\xC6\x38\xEF\xCC\x6A\xC1\x88\xA9\xCF\xF6\xAD\xCE\x8C\xCA\x21\x10\xCF\x5B\xC2\x9D\x8A\xC4\x6C\xC9\xC6\xB2\xCD\x17\xF9\xCB\xEC\xC4\x65", + "\xAC\xCE\x41\x0E\xCD\xDE\xCC\x3A\xF1\xCD\xCD\xCF\x9B\xC0\xC4\x79\xDC\xCB\xE6\xCD\x20\x28\xCE\x49\xCF\x9D\xA8\xCC\x0D\xD2\x0C\x1F\xC1\xF8\x9D\xCE\xFA\xCA\x9E\xE0\xCC\x7B\xD8\xCB\xB3\xC6\x39\xC0\x01\xFC\xCF\x98\xAD\xCD\x69\xC9\xCE\x20\x89\x3C\xEF\xC8\x6C\xC1\x24\x78\xCD\x7C\xC4\x08\xF3\xCF\x13\xF5\xCF\xDE\xC6\x9D\xBE\xBC\x76\xDA\x11\x0E\xD0\x37\xC6\xD0\xDD\xC6\x9A\xD5\xC7\x7F\xD3\xCD\xE3\xC8\x43\xC5\xCC\xFD\xC9\x9B\xC7\xCF\x6E\xDE\xD0\xCC\xCC\x2A\xE2\xD1\xBA\xC5\x9C\xA5\xD3\x74\xC6\x08\x08\xD2\xF9\x8A\xD1\x05\xD5\x9B\x85\x0A\x46\xD9\xC8\x18\xC9\x37\x1C\xC9\xCD\xBC\x8D\xED\xC6\x1D\xDE\xD1\x3D\xD1\x1E\xFF\xD0\x21\xD1\xA4\xF7\xC7\x90\xC6\xD2\x45\xD3\x1E\xC7\xD2\x25\xD9\xA4\xFF\xC7\x92\xCE\xD2\x4D\xD3\x20\xCF\xD2\x29\xD1\xA5\x87\xCB\x94\xD6\xD2\x55\xD3\x21\xD7\xD2\x2D\xD9\xA5\x8F\xCB\x96\xDE\xD2\x5D\xD3\x22\xDF\xD2\x31\xD1\xA6\x97\xCB\x98\xC6\xD3\x65\xD5\x22\xF9\xD1\xDE\x07\xA3\xB9\x0D\x9B\xCC\xD3\x6B\xD3\x3C\x2F\xD2\x39\xD1\xA7\x96\x0B\x9C\xD6\xD3\x75\xD2\xCD\x39\xD2\x1E\xDD\x9E\xE7\xC7\x9E\xCA\x08\x77\xD2\x4F\xE7", + "\xD2\x35\xD3\xA8\xB8\xD1\xA1\xCE\xD3\x7F\xD6\x20\x01\xD4\x3E\xD0\xA0\xE5\xC5\xA2\xD6\xD1\x8F\xD4\x20\x0B\xD4\x40\xD1\xA9\x84\x89\xA5\xCD\xC0\x28\x05\x34\xCE\x02\x41\xD9\x99\x8A\x0B\x13\x1A\x33\x32\xD6\x0E\xD8\xD4\x4D\xDC\xA9\x8E\xCE\x43\x1F\xD4\x0E\x0B\x3B\xCB\xCF\x3E\xDF\x0F\x17\xD1\x90\x03\xD5\x1C\xD3\x53\xCC\xD4\x82\x0F\x81\xA8\xD6\x76\xC1\xD5\x29\xD3\x31\xF3\x60\x89\x09\xA9\xB1\xD5\xA9\xD0\xCF\xA7\xD0\x54\xDA\xCD\x5C\xD1\x9C\xB2\x10\xAC\xC6\xD1\x00\x02\x56\xD4\xD4\x16\xD6\x10\x36\xD5\x79\xC3\xD6\xAC\xD6\x55\xDE\xBE\x5E\xD4\xAA\xB3\xD7\x80\xD2\x08\xCE\xD3\x38\xF8\xD5\x68\xDA\xA2\xAF\xD4\xB5\xDE\xD5\xD6\xD5\x56\xC2\xD7\x19\xCF\xA1\xE2\xCD\x80\xD2\x11\xF3\x0F\x03\xF3\x0E\xFE\xBB\xA3\x9E\xCE\x6E\x12\x0C\x92\x0C\xFF\xA4\xD1\x0D\xD8\xAC\xB1\xD0\xB4\xCD\xD4\x30\xCE\x32\xD1\xCE\x17\xD9\x9E\xB0\xD0\x8A\xDC\xD6\xBA\xD5\x41\xFA\xD6\xEE\xCC\xAF\xFC\xCE\xBF\xD5\xCE\x33\xD7\x25\xF5\xD1\xDE\xC2\xAF\x85\xD3\x79\xC7\xD0\xFF\xD0\x5F\xED\xD5\x6E\xD0\x29\x71\xD7\x83\xC0\x00\x11\xD3\x15\xE0\xC4\xE5\xCE\x9B\x92\xDA\xB4\xC0\x15", + "\x16\xDA\x43\xCF\xD8\x0E\xD6\xAF\xE4\xD4\xB1\xCC\xD5\x0B\xDC\x63\xCD\xD9\xB5\xC5\xB0\x92\xD1\x7F\xD6\xCF\xE5\xD3\x41\xF7\xC2\x01\xD0\x9A\x8E\xDA\x7C\xD0\xD8\x08\xDE\x11\xFF\xD5\xDE\xC8\x8B\x8C\x0A\x2E\xD9\xD9\x27\xDA\x62\xE9\xD8\xC9\x05\xB3\xAC\xD8\xBD\xCF\xD1\xC8\xC9\x62\xE0\xD0\xE0\xC8\xB2\xB4\xDB\xC5\xD9\xD8\xB9\xC3\x63\xC9\xD1\x98\xD4\xA3\xCE\xDA\xC8\xD7\xD9\x24\xDA\x69\xE6\xD6\x04\xC4\xB1\xA0\xDB\xCE\xDC\xD8\x3D\xD8\x21\x3F\xD9\xF5\xC1\xB4\xCB\xDA\x7B\xCB\xD1\xCB\xD5\x45\xC7\xDB\x7E\xD9\xB4\xC0\xD8\xC0\xC5\xD6\x68\xDC\x11\xF3\xD7\x91\xD5\xAF\xDA\xDA\xCC\xD0\xD7\x4F\xD8\x67\xE4\xDB\xB7\xDD\xB4\xEF\xCD\x6F\xD3\xDB\x58\xDD\x6E\xEE\xDA\x8F\xDD\xB5\xD7\x10\xDE\xD7\xDA\x10\xD2\x6F\xFE\xCF\xB2\xDB\xB5\x8C\xD1\xC5\xCC\xC3\x80\xD9\x71\xD9\xDB\xC1\xD6\xB6\x80\x0B\xC7\xC6\xDC\x90\xDE\x66\xD2\xDC\xC1\xDB\xB7\x84\xDD\xC0\xCF\xDC\x81\xC1\x72\xD8\xD8\xC5\xD0\xB3\x8C\xDE\xCC\xC9\xD9\x93\xD2\x51\xD5\xD5\xD4\xD0\xA9\x87\xD4\x9C\xCE\xDD\x74\xD0\x76\xF8\xD2\xD9\xDF\xB5\xB2\xD8\x90\xCC\xD5\xB7\xDA\x62\xF9\xDD\xCA\xD9\x8E\xB4", + "\xDE\xB5\xD6\xDD\x44\xD0\x77\xC1\xDE\xDD\xD3\xBC\xBC\xDE\x95\x0D\xC0\x3F\x05\x34\xF7\x02\xBB\xDB\xA0\xC8\xDE\xF2\xCC\xDE\x42\xCD\x70\xCC\xC0\x89\x09\xBC\x9C\xD3\xF2\xD4\xDC\x8D\xDB\x62\xDF\xDC\xF7\xB4\xBD\xCF\xDC\xF6\xD2\xD9\x97\xDB\x7A\xCE\x09\xEA\xD8\xAC\xD7\xDD\xE7\xDC\xDD\xE1\xDB\x03\xDD\xDE\xEB\xD0\xBD\xCB\xC5\xFA\xD5\x0B\xCE\xDC\x7D\xDF\xDF\x05\xDF\xBE\x9B\xCB\x5A\x0C\xD7\x6B\x0D\x68\xE6\xD9\x7D\xDB\xB6\x86\xD9\xDB\xC7\xDF\xD9\xDB\x6A\xEA\xDA\xBA\xD8\xB4\xA7\xD3\xFC\xD1\xDE\xDB\xD8\x73\xF7\xD6\x9E\xDB\x9F\xAE\xDB\xC1\xC0\xE0\xE0\xDA\x7A\xDF\x0A\x01\xEC\xBF\x84\xE0\xDB\xC6\xE0\x10\xE4\x7E\xD2\xE1\x21\xCB\xAD\x84\xD9\xFF\xCE\xE0\xFF\xDB\x71\xFC\xDA\xA1\xD2\xA0\xBC\xC6\xE8\xD0\xDA\x3E\xDA\x6A\xDD\xE0\xF4\xDB\xC1\xDE\xC3\x0A\xE0\xDB\x0D\xE2\x63\xD3\xD0\x8E\xD5\xA1\xB7\xBD\xFD\xD9\xC3\x9A\xD8\x86\xED\xD8\x19\xEF\xB2\x94\xD3\x7D\xD9\xE1\x27\xE4\x74\xFE\xE0\xAA\xDA\xB0\x82\xD1\x03\xC1\xE2\x93\xD9\x83\xC8\xE0\xB8\xD2\xB0\xC6\xD9\x05\xE1\xDC\x05\xE5\x43\xC7\xE0\xF7\xDD\xC2\xB8\xE2\x13\xFE\xE0\x16\xE6\x7F\xD8\xE0", + "\x11\xEE\xB9\xCC\xE0\xE8\xC7\xCA\x79\xD9\x89\xDC\xE2\x16\xE9\xC0\xCA\x0E\xE8\xC8\xE2\x9C\xDB\x8C\xD9\xDF\x1B\xE6\x88\xEE\xD4\x03\xFB\xE1\x51\xDB\x86\xD4\xE0\x89\xD1\x93\xE1\xE1\x1A\xE5\xDD\x23\xE4\x77\xC3\xDA\x37\xEA\xC3\x9F\xE0\x0F\xEF\xE0\x6A\xE1\x82\xE5\xE3\x09\xEC\xC7\xE8\xE1\x14\xE5\xD9\x52\xCE\x74\xD5\xDA\xBF\xD6\x95\x86\xE7\x05\xF2\xE2\x4A\xE4\x8A\xC3\xE4\x0E\xEE\xC6\x8E\xE6\x16\xF0\xE4\x81\xE2\x83\xD3\xE4\x17\xE5\xC9\xB9\xE0\x0A\xE2\xDB\x2A\xE3\x81\xEB\xE3\x2A\xE9\x1B\x0D\xC1\x12\x05\xCD\x8B\x04\x8F\xF5\xE0\xD3\xB6\xCA\xA8\xE6\x2A\xE9\xD8\xCB\xC1\x65\xED\xE4\x0E\xD9\xCA\xEE\xE3\x2A\xF4\x08\x6C\xE5\x37\x33\xE4\x64\xD5\xCB\xEE\xD7\x2D\xF1\xC5\x7D\xDB\x57\xCE\x09\x53\xE4\xCB\xAF\xE4\x11\xF1\xE5\x3E\x13\x97\xD1\xE3\x5E\xEE\x99\xBF\xE6\x2F\xC1\xE6\xDE\xD3\x98\xEE\xE4\x5B\xE0\xCB\xEC\xBD\x32\xF2\x08\x47\x05\x34\xC9\x04\x63\xEC\x8D\x8D\xC1\x36\xFC\xD0\xDB\xE4\x9A\xC7\xE6\x6B\xE6\xAC\xD8\xE6\x36\xFC\xE6\x79\xE1\x7B\xF2\xE4\x73\xE0\xCE\xE8\xE5\x17\xF0\xE6\xD3\xD6\x21\x1F\xE6\x64\xD1\xCE\xBE\xE5\x35\xEA\xC0\xD7", + "\xE2\x9E\xE7\xE6\x71\xEA\xC8\xC5\xE1\x39\xFA\xE7\xED\xE4\x9F\xE9\xE7\xD3\xDE\x23\x73\x0E\xE7\xAD\xC0\x0B\x05\x34\xD9\x00\x3E\xEF\x81\x98\x03\xD7\xCE\xE6\xCD\xBA\x22\x09\xE8\x0E\xDB\xD0\xEE\xE1\x43\xEF\xE8\xF7\xE1\x03\xF9\xE6\x85\x03\xD1\xC8\xD5\x45\xEE\xD7\x17\xEE\x5A\xD0\xE8\xA6\xD4\xC2\xFF\xE4\x47\xEA\xE8\x0C\xEA\x22\x0E\xE8\x91\xE9\xD1\xC1\xC3\x46\xEC\x89\x28\xEE\xA2\xEA\xE8\x8C\xE3\xCE\xF8\xE6\x49\xF0\xE9\x14\xE9\xA5\xCE\x09\x95\xE9\xB6\x89\xE7\x40\xEB\xE4\xC2\xE7\xA4\xF9\xE8\x99\xEB\xD3\xB4\xE9\x3F\xE8\xE6\x37\xED\x20\x3E\x01\xD2\xC6\x07\x6E\xE4\xEF\xCD\xC0\x4B\xEC\x43\xCD\xEA\x81\xEF\xCE\xA5\xE9\x50\xE6\x08\x51\xE8\x59\xD3\xEA\x7B\xE5\xD3\x9A\xE9\x52\xE4\x08\x59\xE9\x8A\xDB\xEB\x66\xED\xD2\x99\xC7\x4B\xEA\xEA\x4C\xEE\xA9\xE3\xE5\x4D\xE9\x1A\x50\xE9\x5A\xF4\xEA\x64\xE6\x8B\xDC\xDE\x87\x01\xD6\x8F\xE7\x58\xED\xCC\x23\xEC\x6B\xEC\xEA\x44\xDE\xBB\xEE\xD6\x59\xFF\xDD\x0B\xD3\x77\xD9\xDE\xC1\xE0\xBC\xC8\xD2\xF0\xC6\xEC\xC4\xD8\xB1\xC6\xDF\xE2\xD3\xD8\x8C\xED\x61\xEC\xD2\x87\xE8\xB2\xC9\xEC\xC9\xEB\xD8\x8A\xED", + "\x63\xF6\xEC\x8F\xE8\x4A\xD1\xEC\xCD\xE3\xD9\xC1\x13\xBA\xD9\xDC\x57\xE4\x0F\xCA\x09\xC8\xC1\xC5\x81\xCD\x63\xC3\xCC\xAA\xDC\x59\xC5\x09\xC3\xC8\x95\xA2\xE7\xDD\xD7\xD8\x48\xCC\x43\xE6\xED\xBD\xC8\xDA\xAD\xDD\xA7\xC6\x08\xAC\xEA\xB4\xFE\xE9\xAA\xEA\xC7\x82\xD2\xE8\xD1\xED\xC8\xD3\xB6\xD6\xCB\xDA\xE2\xA9\x85\xCD\x6E\xED\xC3\x2F\xE2\x90\xF2\xEA\x05\xE3\xC0\xAD\xEF\x68\xE5\xCD\xC2\xEA\x2D\xCA\x09\xB8\xC9\xDA\xB7\xEF\x6A\xF9\xE1\x79\xEE\x72\xE4\xE5\x4D\xC0\xDB\xFE\xC9\x69\xFA\xE9\xD3\xEF\x6B\xFD\xC8\xEC\xE5\xD6\xA5\xC6\x6F\xF9\xE1\xC0\xEF\xBB\xC4\xEB\xF0\xE1\xAE\x98\xCC\x0E\xC9\xEE\x9A\xE3\xB9\xE6\xE3\xEE\xE0\x99\xD0\xEC\x78\xE6\x08\xD4\xEE\xB6\xE6\xD4\x85\x07\xDC\x8D\xC1\x76\xFA\xDE\xF2\xEA\x7D\xCE\x08\x26\x05\x9A\x90\x06\x5A\xF2\xD9\x0D\xC4\xC0\xDC\xD0\x03\xF0\xD7\xEB\xE9\x80\xF0\xDF\x12\x0A\xC1\xC8\xD6\x06\xFC\xD5\xC7\xE8\x39\xF7\xEA\x05\x0A\xC2\xD1\xE2\x0A\xF4\xD6\xDD\xEA\x4B\xFF\xEA\x00\x02\xC3\xCF\xE4\x0E\xF8\xD7\xE5\xEC\x6D\xC7\xEB\x04\x0A\xC4\xD7\xE4\x12\xFB\x97\xFF\xED\x2E\xE3\x0F\x09\xF5\xC0\xC7\xF1\xF8", + "\xE0\xCF\xF3\xEA\x42\x1D\x00\xA5\xCA\x07\x33\xF1\x97\xCD\x80\xB8\xF0\x87\xDA\xF1\x0D\xF2\xB9\xF5\xF1\xFE\xB2\x11\x3E\xF0\xB2\xC0\xF2\x15\xF7\xA7\xFE\xE6\x0C\xF4\x10\x46\xF1\x14\xE8\xF2\x1D\xF6\xC2\xF6\xE8\x26\xF0\x00\x4E\xF3\x23\xF0\xF2\x25\xF6\xC3\xFF\xEA\x2A\xF6\xE5\x97\xE4\x96\xED\xF1\x26\xF1\x44\xD1\xE7\x1B\xF9\xE3\xBB\xF2\x24\xEF\xF0\xF6\xD9\x2D\x1E\xBC\xE0\xBC\xC7\x94\x09\x1D\xE9\x0B\x6F\xF5\x2F\x31\xF3\xDA\x03\xE7\xC2\x0F\x1C\xFC\xDD\x2E\xF3\xBB\xE3\x0F\x3C\xFB\xD7\xBD\x0C\x9F\xE8\xF3\xA9\x0F\xCF\xC3\xF2\xE5\x02\xE8\xD6\xE9\x90\x05\xF4\xBD\xE8\x5D\xF9\xDF\xDA\xD1\xD8\x8E\xED\xA3\xF8\xEC\x8F\xF4\xB2\xD7\xEC\x49\xF9\xD9\xD4\xD3\x66\xF6\xF4\x9D\xE8\xD3\xD5\xEC\x4A\xF1\xE9\x9C\xEF\xA6\xFE\xF4\x93\xF0\xD4\xD5\xF4\x2C\xD7\xE9\xA4\xF5\xA6\xE6\xF5\x9F\xF2\xD3\xE1\xF4\x55\xF3\xEA\xDC\xD1\xA9\xEE\xF5\xA7\xF0\xD6\xE9\xF4\x54\xFB\xEA\xB4\xF5\xAB\xE0\xD3\xAF\xF0\xD7\xF1\xF4\x5D\xF3\xEB\xB2\xF5\xAD\xFE\xF5\xB7\xF4\x4C\xF9\xF4\x61\xFB\xEB\xC4\xF5\xAF\xFC\xF5\xBF\xF0\xD9\xC1\xF6\x34\xD3\xEC\x8C\x0A\xAA\xD6\xD4\x7D\xED", + "\xBA\xCD\xF6\x42\xD9\xA6\x86\xD5\xB5\xFC\xEB\xD7\xF7\x75\xD9\xF7\xD8\xDB\xED\xFC\xBC\xEB\xC5\xEE\xD1\xF2\xBF\xC5\xF6\x66\xF3\xEE\xD4\xF7\xB4\xF6\xF6\xE7\xF0\xDB\xE9\xF6\x6D\xFB\xEE\xB0\xF0\x9B\xA5\xCD\x25\x07\xBE\xC5\x08\x13\x06\xD4\xED\xF4\xD1\xCB\xDD\xF8\xF1\xDC\xE0\xF7\x6D\xF3\xBB\xFC\xF4\xA3\xEF\xC9\x84\xED\xD3\xEC\xF4\x81\xF6\xEB\x84\xF8\xB0\xE6\xF8\xCA\xF0\xE1\xC6\xF7\x64\xFB\xF0\xCB\xF6\xB9\xE5\xF7\xE8\xF0\xE2\xEA\xF6\x89\xFC\xEE\x94\xFB\x3F\x0F\xF6\xDF\xF0\xDA\xFE\xF6\xC0\xE0\xF0\x8E\xF5\xC7\xF0\xF4\x1F\xFC\xD3\xE1\xF8\x51\xFA\xF0\xA7\xF0\xC7\xEB\xC6\x01\xFB\xE4\xC3\xF8\x95\xF5\xF0\xAC\xFB\xC1\xEE\xF9\x09\xF8\xE6\xCD\xF9\x92\xFF\xF0\xC7\xF6\x80\xEA\x08\x11\x00\xDE\xF2\xF6\x82\x04\xEF\xAC\xEA\x96\xF3\xBD\x1B\xFD\xA7\xD6\xF9\x7E\xFD\xEE\xC4\xFB\xD0\xFF\xF7\x28\xFE\xE3\xC9\xFA\x90\xFB\xF4\xA2\xF9\xD3\xE4\xF9\x32\xFC\xDC\xF6\xF8\xA9\xFC\xF0\xD4\xFA\xC3\xF1\xF8\x53\xFD\xE6\xD5\xFA\xAD\xF7\xF5\x93\xF9\xD6\xF8\xFA\x5B\xFA\x20\x18\xF9\x7C\xF1\xF4\xD2\xF7\xD1\xE7\xF9\xDB\xB9\xE5\xCF\xFB\x95\xFB\xF6\xAD\xF9\xDB", + "\xFA\x0D\xDE\xF4\xEC\xC5\xFA\xA4\xF9\xF6\xCA\xF9\xDD\xEC\xFA\x77\xFE\xE9\xF9\xFA\xA8\xFF\xF6\xB1\xF9\xDF\xF7\xF9\x06\x0F\x05\x25\xCD\x0E\xC2\xDD\x86\x0B\x17\x15\xF7\x16\xFF\xDE\xFA\xF6\x8D\xF3\xF7\xE8\xFA\xEF\xAA\xFB\x7B\xFC\xED\xD1\xFC\x50\x16\xD0\xB9\xE1\x03\x05\xCD\x1E\x00\xF1\xDF\xFB\x80\x0A\xF8\xE5\xF9\x63\xCE\xF3\x6D\xF0\x98\xE2\xF7\xCD\xFA\xCB\xF4\x41\x69\xD2\x03\xE2\xEA\x22\x33\x02\xF2\xE0\xBB\xF1\xFB\xE2\xF9\xF8\xB0\xFA\xEE\xE7\xFA\xA1\xF4\xFA\xDC\xF5\xE3\xF4\xFD\x61\xFE\xEB\xF9\xFD\x8A\xF5\xFB\xC6\xF9\xEF\xF4\xFB\x8F\xFE\xEE\xC1\xFE\xBC\xF3\xFC\xFA\xF9\xF1\xFC\xFB\x93\xFF\xE5\xFF\xFA\x67\xF0\xFC\xB7\xBC\xE4\xE7\xFE\x92\xF8\xFA\xEE\xFB\xE4\xFE\xF7\xD4\xFF\xCC\xF1\xFA\x5C\xFC\xE6\xE7\xD6\xDC\xFD\xF5\xBC\xFF\xEE\xF6\xFD\xB3\xFE\xEC\xFF\xFC\xC7\xFE\xFC\xC2\xFD\xF9\xE4\xFE\xE7\xFE\xF8\xE9\xFF\x31\xFB\xDF\xD1\xE3\x03\x1A\xFC\xDF\xF8\x7F\xF0\xF3\xE6\xF6\x7A\xCF\xFF\xFA\xF1\xFE\xF7\xFB\xFA\xD2\xFE\xE5\xF6\xFD\xD6\xFA\xF6\xFA\xFD\xDD\x7C\xF8\x73\xFE\x5C\x7F\xFF\x7E\xF7\x71\x00\xBE\x7E\xDF\x7C\x02\x87\x00\xB4", + "\x7F\xAF\x5F\x02\x84\xFE\x75\x7F\xE6\x7C\x04\x88\xFE\x52\x80\xEA\x7C\x05\x88\xFC\x7B\x7F\xD5\x7C\x06\x87\xFD\x4B\x7F\xD9\x7C\xF6\x70\xF6\x4E\x80\x04\x82\x07\x80\x00\x85\x80\x02\x81\x02\x8C\x00\x80\x7D\xB7\x7E\xF8\x76\x02\x8F\x80\x0D\x80\x09\x8A\x00\xAE\x80\x27\x83\x80\x03\xF6\x6F\x7E\xB2\x7F\x00\x8A\x02\xA0\x80\x37\x80\x0C\x8C\x02\xA8\x80\x16\x7E\xEB\x7E\xF9\x7B\x7B\x29\x83\xE8\x7B\x02\xA1\x80\x1C\x83\x07\x8A\x03\x84\x81\xFD\x7D\x07\x85\x04\xA3\x80\x22\x81\xE9\x7E\x10\x33\x00\xA5\x67\x19\x0F\x96\x4A\x04\x66\x00\xEB\x7B\xED\x6A\x6B\xF7\x6D\xE8\x7F\xCC\x4E\x77\x06\x04\x09\x05\x9A\x44\x01\x66\x7B\x75\x65\x03\x83\x81\x39\x81\x13\x85\x02\xB8\x80\x42\x80\x1A\x80\x04\xA1\x7F\x69\x83\x11\x85\x06\x8B\x81\x06\x82\x1B\x8D\x06\xA6\x81\x2F\x80\x1D\x81\x03\x9F\x63\xB0\x6F\x0C\x8F\x03\x8C\x7E\x6C\x83\x1A\x86\x03\xB3\x81\x70\x83\x19\x82\x07\xBE\x81\x64\x80\x20\x89\x04\x9B\x7F\x6F\x83\x21\x8C\x04\x81\x82\x75\x80\x23\x87\x07\xA3\x63\x63\x82\x1A\x8C\x07\xBF\x81\x84\x82\x24\x8C\xE6\x61\x76\x68\x35\x69\x6C\x0A\x2D\x6F\xDB\x5D\x03", + "\x6D\x05\x1A\x82\x9C\x82\x85\x6A\xE7\x56\x04\x9E\x80\x28\x83\xC5\x62\x81\x7D\x7A\xBB\x7E\x10\x1F\x82\x1C\x6B\x26\x87\x0A\xA2\x82\xA9\x80\x29\x82\x11\x2C\x82\xC8\x6A\x2B\x81\xC9\x68\x82\x80\x79\x29\x73\x0B\xA6\x82\xB7\x80\x2C\x89\x0B\x8E\x81\x0A\x04\x2D\x81\xC5\x76\x82\x99\x73\x12\x73\xE8\x40\x7E\x05\x06\x30\x8F\xC8\x44\x83\x78\x70\x6F\x7A\xCE\x68\x78\x99\x81\x2B\x81\x0A\xB6\x70\xA3\x81\x0E\x7A\x0C\x97\x72\xCC\x83\x10\x72\xE5\x5E\x75\x54\x7B\x35\x80\xC2\x44\x04\xD9\x80\x0D\x71\xE6\x48\x82\xF1\x71\x30\x8C\x0B\x85\x83\x67\x7B\x31\x80\xE1\x6B\x82\xE7\x81\x33\x81\xD7\x6A\x83\xAF\x05\x29\x82\x0D\xAF\x82\xD4\x81\x2C\x86\x0D\xAD\x83\xDA\x82\x92\x78\xD4\x55\x80\x2D\x82\x1D\x8B\x03\x9B\x63\x41\x81\x25\x83\x08\x93\x82\x85\x82\x40\x8E\x0F\x88\x81\x1A\x82\xFF\x77\x10\x89\x82\x09\x86\x12\x8A\x08\xB1\x81\x0B\x86\x21\x8D\x10\x86\x81\x11\x86\x41\x8E\x08\xBF\x83\x78\x83\xB6\x7A\x07\x81\x84\x04\x86\x24\x81\xFB\x74\x80\x20\x87\x1E\x83\xA7\x7E\x80\x1C\x87\x47\x82\x12\x91\x82\x03\x86\x49\x85\x12\x97\x6A\x12\x05\x10\x05\x9A\x7D\x01", + "\xD3\x80\x2B\x7D\x12\xAF\x84\x31\x84\x2E\x75\x0D\x98\x82\x2E\x84\x87\x60\x13\xB4\x83\xA6\x5F\x8B\x72\x0B\x8E\x04\x39\x84\xB2\x6B\x13\xBD\x82\xF5\x83\x2F\x8A\x0A\x8A\x04\x41\x85\x14\x73\x14\xA8\x83\xB8\x80\x3C\x8D\xD6\x73\x84\x3A\x85\x4D\x82\xFA\x49\x7A\x54\x79\x52\x8F\xC8\x4B\x85\xEE\x82\x83\x7E\x14\xBA\x82\x40\x84\x4D\x8C\x13\xB6\x84\xF6\x80\x4E\x8E\x15\x84\x85\x3D\x87\x4D\x80\xC6\x5D\x85\x51\x87\x57\x83\x15\x8F\x83\x20\x7A\x55\x87\xC9\x58\x85\xF9\x82\x33\x84\xD0\x6D\x85\x63\x84\x53\x8E\x0B\x9B\x85\xC0\x82\x41\x0E\x16\x9F\x83\x00\x00\x5C\x82\x0E\xBF\x7C\x26\x7D\x55\x85\x17\x99\x85\x42\x7A\xA1\x75\x0E\xBA\x85\x83\x85\x5C\x8F\x0E\x86\x86\x94\x7F\xA2\x78\x11\x90\x82\x21\x87\x4A\x81\x19\xBD\x81\x1D\x85\x4A\x88\x12\x95\x84\x95\x84\x66\x8A\x12\x94\x86\x9B\x84\x25\x89\x19\x97\x84\x08\x85\xFE\x7C\xFF\x53\x84\x8B\x83\x43\x87\xF1\x4F\x82\x8E\x6B\x64\x8E\x19\x9D\x86\x05\x87\x67\x86\x1A\x8D\x82\xA6\x84\x49\x8C\x19\x97\x86\xA0\x84\x43\x82\x1A\x99\x80\xB7\x87\x06\x8F\x1A\xA8\x86\x7E\x6A\x6A\x8D\x1A\xAC\x86\x1E\x84\x6D\x8B", + "\x1B\x8F\x86\xA9\x87\x49\x8E\x1B\x81\x87\xC7\x86\x65\x89\x1C\x9A\x86\xC2\x84\x69\x80\x11\xB5\x86\x12\x85\x6E\x8C\xFC\x44\x87\xBD\x86\x71\x86\x1D\x92\x86\xD7\x87\x6C\x8D\xFA\x7C\x86\xBD\x6D\x76\x8B\x1A\x8D\x87\xD2\x86\x43\x8E\x1C\x82\x82\xCC\x87\xE2\x7D\x80\x69\x6B\x7C\x72\xE7\x54\xA0\x58\x82\xFF\x77\x79\x85\x9A\x48\x80\xEB\x87\x59\x8B\xBF\x72\x85\x40\x74\xFB\x7F\xF9\x71\x71\xEE\x6A\x7A\x87\xB1\x48\x7A\x6C\x84\x95\x78\x1E\xAE\x71\xFA\x84\xE2\x6D\xB1\x4B\x86\x54\x86\x7D\x8B\x97\x7F\x71\x8D\x65\x80\x8D\xDC\x6B\x6A\xF4\x87\x92\x76\x20\x96\x65\x08\x8B\x5E\x6A\x20\x8F\x71\x0C\x88\x81\x8D\x1F\x8F\x88\xFF\x85\x7E\x83\xA2\x56\x81\xFA\x83\x85\x78\x21\xAF\x87\xA9\x7E\x80\x8C\x1F\xB3\x85\xFE\x84\x88\x8D\xDE\x62\x88\xE3\x83\xD9\x6F\x21\x9C\x68\xF0\x87\x7E\x89\x22\x8E\x6E\x36\x7A\x67\x61\x21\x96\x65\x13\x88\x16\x7B\x84\x56\x88\x24\x8B\x8A\x88\xAC\x6D\x88\x28\x88\x60\x82\xE6\x47\x86\xF7\x85\x0A\x70\x20\x9B\x88\xEC\x87\x8B\x83\xB3\x60\x78\x19\x8A\x67\x65\x23\xAF\x71\xF3\x84\x8E\x85\x1F\x80\x89\x07\x88\x7E\x8A\x24\x84\x89\xF2", + "\x87\x6E\x7E\x24\x8E\x88\x90\x09\x92\x81\x24\xBF\x88\x51\x88\x43\x0D\xF9\x58\x87\x60\x8A\x76\x8E\x1D\xBF\x86\xE0\x86\x05\x88\xFF\x66\x89\xFA\x7D\x78\x84\x11\x90\x87\x16\x87\x70\x81\x1A\xA8\x89\xA3\x86\x9A\x85\x1A\xA3\x87\xB0\x84\x9D\x8C\x1D\xB6\x7F\x70\x88\x45\x0B\x11\xA2\x89\x61\x8B\x77\x8B\x1C\xAC\x89\xAE\x86\x9D\x84\x1D\x90\x09\xB2\x86\x9F\x83\x26\x88\x87\x87\x8A\x72\x89\x28\xA5\x87\x8B\x88\xA0\x80\x1C\x8A\x8A\x7D\x88\x99\x8F\x27\xAE\x89\xB6\x85\x9E\x8A\x1B\x82\x8A\x6F\x89\x3F\x8E\x28\xA5\x89\x9A\x88\xA5\x81\x1D\x96\x8A\x0A\x87\xA6\x89\x07\xB7\x89\x11\x81\xA7\x88\x29\x95\x8A\xA6\x8A\x9C\x8F\x1C\x9E\x8A\x6D\x8B\x78\x85\x28\x92\x8A\x8D\x88\xAB\x81\x28\xAA\x8A\xE4\x86\xA8\x81\x2B\xA7\x8A\x9F\x89\xB5\x0D\x80\x5F\x74\x51\x70\x0C\x01\x22\x8F\x77\x45\x8A\xA8\x62\x11\x3C\x8A\x8F\x72\xAF\x87\x22\x80\x8B\x55\x8B\x8D\x8A\x15\x8C\x86\x44\x7B\x1C\x35\x9A\x46\x8B\xB8\x7F\x07\x64\xDA\x5C\x81\xCA\x89\x61\x85\x20\x90\x89\x00\x00\xB1\x87\xC9\x50\x8B\x2A\x82\xB4\x8C\x21\x8D\x88\xFB\x83\x83\x8A\x2D\xBC\x85\xDC\x8A\x10\x8E\x2D", + "\x81\x8B\xDB\x83\x87\x74\xE5\x63\x8B\x33\x89\xB9\x84\x08\xA7\x8B\xC9\x89\x85\x8B\x2C\x97\x8B\x31\x89\x41\x0C\x2E\x92\x89\x05\x06\xBB\x84\x10\xB0\x8B\xEF\x76\x6B\x74\xE3\x4C\x8B\xE2\x6E\x42\x07\x2F\x82\x89\x0A\x06\xBE\x8B\x24\x80\x00\xD3\x8A\x6E\x75\x2D\xBF\x8B\xF4\x89\xB3\x82\x30\x8F\x8B\xBF\x8A\x41\x09\x30\x88\x77\xFE\x8A\x31\x80\x30\x88\x83\x04\x07\xC0\x80\xCA\x4E\x04\x06\x8D\x61\x63\x31\xBE\x77\x46\x8B\x3A\x7E\x2C\x9C\x68\x1D\x8E\x6A\x74\x10\x1F\x8C\xF0\x76\xC5\x8D\x30\x81\x8C\x06\x06\xC6\x82\x10\x1F\x60\x25\x8E\x75\x77\x32\x9F\x8B\x57\x89\xB8\x88\x2D\xAE\x8C\x01\x04\xCC\x81\x31\x85\x04\x28\x8D\xC5\x89\x0E\x97\x8C\xEB\x83\xC3\x84\x32\xBB\x8C\x33\x8C\xBA\x8D\x21\x93\x79\xE2\x88\xC4\x87\x2C\x92\x8C\x34\x8F\xBC\x87\x21\x99\x89\x26\x89\x5F\x02\xFF\x72\x79\x6C\x62\xFE\x6D\x2F\x85\x8C\xA5\x64\x18\x02\x15\x9E\x89\x5F\x6E\xE8\x6A\x2F\xB3\x88\x5A\x8E\x5A\x8B\x05\xAB\x8C\x84\x72\xB5\x6E\x35\x99\x8D\x5B\x8F\x25\x66\x16\x8C\x62\x56\x8C\xB5\x84\x10\x1F\x8D\xF8\x88\x41\x01\x36\xA4\x85\x60\x86\x51\x85\x8B\x5D\x8D\x39\x70", + "\xDC\x84\x30\x86\x04\x73\x8E\x5D\x85\x14\xB8\x85\xA7\x60\xDE\x88\x09\xBA\x8D\x1B\x8E\x42\x0D\x37\x84\x86\x0C\x8F\xD3\x8E\xB5\x66\x8D\x79\x8C\xDA\x82\x36\xAA\x8D\x61\x85\x1C\x6D\x36\x8A\x8C\x6F\x8E\xE3\x84\x37\xAB\x85\x39\x8B\x17\x7A\x02\xA7\x8D\x1C\x6B\xE1\x8A\x18\x8E\x8D\x99\x8F\xE2\x88\xFB\x5C\x8E\xC8\x6A\xE7\x8F\x17\xA9\x8B\x5B\x79\x13\x73\x3A\x8D\x8E\x9D\x8D\xDA\x84\xD2\x64\x8D\x94\x73\xEA\x83\x38\x96\x8E\x7E\x8D\x59\x81\x39\xAC\x8D\x17\x6C\xE1\x8F\x32\x92\x04\xA6\x8F\x9D\x70\x3A\x8F\x89\xA2\x8F\xE6\x8C\x3A\xA5\x8E\xAE\x8E\x5E\x76\x37\x95\x8D\xB9\x8C\xED\x88\x38\xAA\x8C\x8A\x8D\x9C\x80\x2A\xA9\x79\x7D\x07\x9A\x7B\x16\x3D\x63\x95\x69\xE5\x7E\xC6\x54\x04\xD4\x8F\xA4\x88\x2B\xAD\x8A\xB4\x89\x9D\x8D\x3D\xA4\x8A\x13\x81\xAA\x8F\x3C\xAB\x89\xB2\x8B\xA3\x8C\x28\x91\x8A\x88\x88\xFA\x80\x29\xBC\x89\xEC\x8D\xED\x7B\x27\x86\x8A\xEA\x8F\xF9\x8D\x3E\xB0\x8A\xF1\x8D\x20\x8F\x2A\xA9\x8F\xF3\x8C\xFE\x80\x3F\xB9\x8F\xEB\x8F\xFE\x8E\x19\x8D\x60\x2E\x01\x69\x6E\x0D\x99\x68\xE6\x83\x57\x66\x32\x80\x00\x5C\x03\xB8\x66\x25\x99", + "\x6F\x00\x92\x00\x93\x05\x86\x04\xDE\x83\x5C\x6E\x10\x09\x90\xA9\x69\xCA\x8F\x33\xB0\x8E\xF1\x82\x44\x01\x40\x9C\x68\x03\x91\x61\x61\x41\x85\x66\x14\x93\xAD\x6E\x33\x8D\x85\x40\x8D\x06\x9E\x10\x1B\x90\xC8\x69\x07\x97\x40\x9F\x90\x07\x91\x08\x9F\xAC\x4D\x89\xBF\x8C\x96\x85\x2F\x84\x04\x28\x91\x14\x7A\x42\xB2\x8C\xD1\x80\x61\x6D\x42\x8A\x90\x0B\x8C\xF3\x81\x3A\x8E\x8C\x06\x05\x0D\x9F\xC8\x77\x90\xED\x7D\x32\x83\xB0\x74\x6A\x29\x5C\x0F\x92\x2F\x96\x8B\xCD\x8C\xCB\x85\x10\x02\x91\x97\x70\x11\x90\xAC\x45\x90\x3A\x90\x0E\x9E\x42\x9A\x6B\x23\x93\x5D\x85\x42\x8F\x85\x27\x92\x03\x94\x99\x6C\x83\x06\x92\x15\x9A\x44\x83\x88\x31\x92\xCD\x83\x43\x80\x00\x50\x90\x5F\x82\x45\x88\x91\x60\x91\x15\x95\x44\x84\x04\x57\x93\x73\x66\x41\xA4\x90\x18\x90\x17\x9A\x10\x29\x91\x33\x8B\x1A\x97\xAD\x6D\x91\x06\x06\x04\x9A\x10\x31\x91\x00\x03\xB3\x73\x22\x80\x8F\x40\x93\x13\x9E\x45\x9D\x65\xBB\x81\x18\x9F\x46\x88\x90\x63\x93\x20\x92\x43\x85\x92\x34\x93\x21\x92\x98\x49\x92\x6E\x93\x14\x96\x10\x00\x92\x82\x91\xC8\x80\x0D\xB8\x91\x71\x8D\x0E", + "\x93\x49\xBC\x91\x05\x06\x1F\x97\x49\x8D\x92\x9A\x90\x88\x7C\x49\xBB\x8D\x46\x93\x17\x94\x45\xBD\x91\x20\x90\x29\x9E\x23\xA4\x83\x67\x93\x29\x95\x38\x90\x90\x0F\x91\x2A\x95\x49\xAC\x91\x7F\x92\x2B\x98\x3A\xA6\x77\x8A\x79\x5A\x0C\x8B\x5A\x89\xDC\x8F\xF8\x83\x27\x9F\x8F\x83\x88\x9E\x82\x3E\x87\x93\xB5\x08\x30\x93\x2B\x82\x93\xAB\x8B\xF6\x8B\x4C\x88\x93\x00\x84\xFF\x82\x3F\xBE\x8F\xF4\x8E\x34\x96\x2B\xAD\x7B\xEF\x8D\x35\x94\x4D\xBA\x8F\xDA\x91\x37\x9C\x4D\x81\x80\xF7\x8D\xFF\x8E\x4D\xA2\x93\xDF\x90\x39\x96\x4E\x93\x93\xE3\x90\x3A\x95\x4E\xAA\x93\xE7\x93\x35\x96\x4D\xA5\x8F\x9C\x88\x0F\x8B\x4D\xAD\x93\xF0\x92\xF6\x84\x4C\x99\x8A\xF2\x91\x3A\x91\x08\x99\x93\xEB\x92\x3B\x93\x4F\xAC\x93\x00\x96\x3F\x91\xFF\x60\x8F\xFC\x81\x3E\x9D\x4F\xB5\x93\xB7\x8B\x3D\x98\x2A\x86\x94\x03\x85\x03\x6A\x79\x5C\x68\x71\x01\x2D\x94\x10\x30\x01\x47\x90\x19\x98\xE0\x52\x04\x0F\x94\xB2\x61\x51\xAA\x92\x06\x04\x45\x9A\x48\xBD\x90\x17\x91\x13\x98\x31\x80\x00\x19\x95\x14\x7B\x51\x88\x92\x0E\x06\x47\x97\x4B\x96\x94\x89\x8F\x0F\x9E\x44\x84\x04", + "\x25\x97\x23\x77\x52\x9F\x92\x0A\x06\x4A\x9C\x4A\x99\x91\x7F\x8F\x16\x9C\x15\x8A\x04\x31\x97\x25\x73\x53\x94\x62\x1F\x62\x4D\x91\x4A\xB3\x91\x5A\x91\x1D\x9B\x53\x86\x04\x3D\x94\x5F\x8F\x53\xBD\x66\x41\x95\x45\x9E\x48\xA6\x91\x90\x90\x49\x95\x9A\x4B\x95\x1C\x6D\x53\x9F\x51\x8B\x91\x2D\x94\x21\x9F\x52\x92\x95\x10\x96\x44\x90\x00\x02\x95\x04\x04\xFF\x5F\x54\x9E\x88\xD8\x89\x52\x93\x23\x94\x95\x04\x91\x47\x9E\x54\xA5\x92\x54\x7A\x59\x9D\x49\xA8\x95\x85\x64\x58\x90\x00\x22\x95\x6C\x97\x83\x8E\x56\xA8\x92\x04\x04\x5C\x97\x40\xB2\x95\x74\x97\x2B\x9A\x22\xA5\x95\x53\x96\x57\x9C\x57\x84\x95\x39\x96\x51\x99\x17\x85\x04\x77\x97\x2C\x95\x10\x3A\x95\x38\x93\x60\x98\x53\xB6\x8E\xC7\x8C\x26\x89\x58\xBB\x8E\x0E\x04\x63\x9B\x48\x8E\x96\x30\x90\x13\x9E\x52\xA3\x94\x93\x95\xCE\x82\x11\x16\x96\x96\x91\x41\x08\x59\x8B\x90\x9A\x96\x56\x9F\x15\x2D\x6B\x32\x89\x27\x98\x5A\xB9\x8A\x0C\x95\x40\x98\x50\xAD\x7B\x9E\x5F\x9C\x6C\x4F\xB4\x93\xCE\x92\xF9\x82\x50\x87\x94\xB5\x95\x3C\x92\x03\x84\x94\x17\x82\x42\x9C\x5A\x91\x93\xFF\x92\xFD\x8C", + "\x5B\x82\x07\xE1\x92\x6B\x9E\x4C\xAB\x96\xC1\x90\x34\x99\x11\xB5\x8F\xA6\x85\x6C\x91\xA7\x73\x96\xC6\x96\x6F\x99\x5C\xAD\x96\xB7\x94\x6D\x92\x5D\x8F\x93\xD4\x96\x69\x80\x5D\x95\x97\xD1\x94\x33\x95\x2B\xAF\x96\x3D\x83\x70\x97\x22\x05\x97\xDC\x94\xA0\x8D\x80\x7D\x00\xA5\x65\x1D\x0E\x55\xB4\x01\x6B\x96\xB0\x80\x6D\x69\x97\xEB\x95\x7B\x9B\x4B\x81\x86\x0F\x88\x7A\x9C\xA1\x6A\x97\x1C\x95\x41\x0C\x5E\x97\x95\x2C\x96\x0F\x96\x5A\x81\x8D\x06\x06\x7D\x98\xAC\x78\x97\x28\x96\x42\x0B\x5F\xAB\x94\x63\x94\xD2\x88\x2D\x82\x98\x51\x70\x81\x94\x53\x86\x04\x07\x9B\x4D\x99\x59\x99\x95\x8F\x93\x56\x9C\x60\x8F\x72\x0E\x98\x50\x92\x11\x11\x98\x43\x97\x63\x95\x37\x80\x8E\x3F\x86\x42\x07\x61\x97\x72\x19\x98\x53\x9B\x61\xB2\x97\x47\x8C\x37\x85\x5F\xB0\x97\xF9\x94\x41\x0C\x61\xA1\x95\x84\x94\x64\x90\x62\xB9\x70\x23\x98\x5F\x85\x62\x95\x95\x27\x98\x7F\x99\x60\xAA\x98\x0B\x98\x8B\x95\x60\x90\x98\x28\x98\xB8\x84\x56\xA7\x91\x35\x9B\x8C\x87\x63\xA9\x95\xFA\x95\x90\x95\x33\x83\x99\x51\x95\x91\x9D\x49\x87\x99\x85\x67\x8B\x93\x57\xB1\x98\x1F", + "\x9A\x4E\x97\x58\x84\x04\x4E\x98\x5E\x90\x00\x10\x99\x07\x92\x94\x9D\x57\xB3\x97\x5C\x89\x93\x9E\x63\x8F\x98\x49\x9A\x8E\x95\x57\xBD\x98\xF7\x95\x7C\x96\x66\xBE\x95\x30\x88\x73\x7E\x99\x64\x8E\x51\x71\xEF\x84\x65\x90\x04\x75\x78\x93\x86\x10\x3A\x8E\x9E\x96\x43\x02\x67\x9E\x98\x98\x8F\x7F\x9C\xC9\x6E\x6B\x70\x9B\x23\x7B\x67\x93\x98\xFE\x95\x85\x95\x36\x80\x9A\xC3\x8D\x9C\x95\x3C\x9A\x77\xB7\x8C\x25\x67\x37\xB3\x8E\xAD\x8F\xE3\x8F\x3A\xA2\x94\xB1\x8F\x9B\x99\x68\x82\x9A\x8B\x98\x80\x73\x63\xA9\x65\xC9\x8D\xA4\x97\x39\xA3\x8D\x94\x9B\x9F\x96\x69\x90\x9A\xC4\x8E\xA4\x96\x3C\x9B\x9A\x71\x63\xA3\x91\x2F\x80\x00\x78\x98\x40\x0F\x81\x43\x9A\xA4\x94\x85\x90\x55\xB3\x77\x9D\x70\xA9\x9A\x68\xA6\x9A\x8C\x99\x64\x99\x6A\x9D\x9A\xA5\x9B\xA7\x90\x39\xBA\x9A\x8C\x62\xAA\x97\x35\xB7\x99\xCA\x8F\xE7\x85\x5A\x86\x9A\x95\x99\x63\x61\x68\x97\x72\xB0\x98\x48\x94\x47\xA1\x9A\x56\x70\xA2\x96\x6B\x98\x9A\xB8\x9A\xA6\x96\x65\x81\x8E\xB5\x9B\xAA\x9D\x6A\xBF\x03\xAF\x99\xA6\x9E\x13\xA2\x97\xCE\x8E\x72\x90\x19\x89\x94\xDE\x96\xF7\x85\x6E", + "\xA0\x9B\xB8\x87\xB9\x95\x4C\xA5\x8A\xD9\x95\x6E\x96\x4F\xAA\x9B\xF8\x90\x70\x9A\x4F\xA0\x97\xEE\x8C\xBA\x97\x29\x97\x97\xB6\x94\xBD\x93\x6F\xAE\x9B\xDD\x7A\xBD\x91\x2A\xBA\x9B\xB8\x94\xBE\x9A\x5B\x8B\x97\xEF\x90\xBF\x9C\x5C\x86\x9C\x05\x9E\xC0\x9F\x6E\xA2\x9B\xC5\x87\xC1\x9A\x70\xA4\x9B\x0C\x9D\x75\x8E\x70\xB0\x9B\x0B\x96\xBC\x91\x70\x9E\x97\xDB\x94\xC0\x96\x5D\x94\x9C\xBF\x94\xC1\x91\x5C\x9A\x9C\x66\x80\x79\x90\x72\xA5\x97\x23\x9D\xC9\x98\x70\x9F\x9C\x27\x9D\x6B\x87\xB8\x4A\x04\x2A\x60\x26\x86\x04\x25\x66\x86\x00\xD1\x80\x00\x31\x9C\x98\x83\x07\x65\x08\x05\x66\x1F\x63\x21\x0F\xC2\x5F\x60\x88\x03\x1A\x67\x40\xBD\x9C\x0E\x05\x47\x71\x6B\xAF\x64\x2B\x9E\x41\x0D\x72\xAB\x9A\x2F\x9C\x87\x64\x73\x91\x8B\x12\x07\xD2\x93\x6C\xA1\x96\x04\x07\xCD\x97\x40\xB9\x9C\x3B\x9E\x44\x00\x74\xAC\x9C\x85\x67\xD5\x98\xD3\x44\x9A\x21\x97\x66\x99\x6C\xBD\x66\x47\x9F\xD3\x94\x10\x09\x9D\xC8\x6A\xD3\x96\x2E\x8D\x9D\x39\x72\xCD\x98\x73\x92\x04\x3A\x9E\x28\x7C\x73\xBE\x9C\x38\x92\xD6\x95\x10\x02\x9D\xCE\x99\x51\x90\x6D\xAD\x71\x81\x61", + "\xD8\x9E\x36\x80\x00\x64\x9D\x14\x76\x76\xAF\x8B\x68\x9D\xCD\x92\x11\x12\x9D\x38\x90\xD5\x9E\x76\x96\x9D\x70\x9F\x22\x92\x77\xA2\x59\x73\x98\xA8\x9E\x75\xA2\x9A\x94\x62\xDE\x94\x39\xBC\x9D\x30\x9E\xCC\x9F\x77\x94\x8C\x38\x90\xE1\x9B\x48\x86\x9E\x30\x93\xDB\x96\x12\x59\x9D\x12\x75\xE3\x9F\x6B\xA8\x9A\x72\x6D\xE2\x9B\x77\xBD\x9D\x8F\x73\xE5\x97\x30\x97\x9E\x0D\x62\xDA\x93\x75\xAC\x9D\x55\x9E\x43\x0B\x78\x80\x00\x92\x9F\x1E\x9A\x10\x33\x9E\x74\x9C\x56\x95\x68\xB3\x9A\x87\x98\x23\x65\x7B\x8D\x60\xA8\x9F\x25\x7A\x7A\x85\x66\xAC\x9D\x61\x6A\x79\x90\x9D\xB6\x9E\x41\x0D\x76\x9D\x9E\x88\x9F\xE7\x9F\x73\xA1\x9E\x7C\x9A\xE3\x9E\x67\x91\x9B\xBE\x9D\x0E\x71\x7C\xBC\x85\xC3\x9F\x01\x95\x7C\x87\x90\xC7\x9C\x2E\x9B\x48\x8B\x9F\x0B\x92\xE7\x98\x75\x8F\x9F\x41\x9E\xE8\x93\x69\x8F\x9E\xD4\x9D\xE4\x96\x7D\x95\x9E\x4B\x8D\x41\x0B\x7D\x99\x9E\x6B\x9E\x43\x00\x7E\x8A\x8B\xE2\x9E\xD1\x90\x7A\xA5\x9F\xD1\x9F\xE8\x97\x6D\x82\x9B\xEA\x9E\xCB\x9C\x7E\x8C\x9D\x0E\x07\xFB\x9B\x48\x9D\x9F\xC9\x9C\xF2\x93\x7F\xB2\x8B\xF5\x9D\x41\x05\x7B\x89", + "\xA0\x8C\x9D\xFE\x97\x7E\x93\x9F\x78\x9D\x1C\x6F\x7B\x92\x04\xD7\x9F\x8C\x89\x7D\xB8\x90\x02\xA0\xF2\x94\x80\x9F\x60\x9C\x9D\xF8\x9D\x7C\xA3\x9F\x71\x9C\xF4\x9C\x75\x8F\x9B\xE8\x9D\x04\xA5\x7D\xBE\x9F\x4A\x9E\xE5\x99\x76\x83\x9E\xF1\x9E\x42\x07\x80\xA4\x91\x0C\xA0\xED\x97\x7F\x82\x75\x23\xA2\xDD\x95\x82\x9C\x77\x79\x9F\xFA\x99\x82\xAD\x9F\x04\x05\x06\xAE\x7D\x85\x04\x1B\xA1\x61\x6F\x82\xBC\x62\x31\xA3\x02\xAF\x81\x9B\x9D\x43\x9D\xD7\x90\x81\xB8\xA0\x12\xA2\x0E\xA5\x76\xAA\xA0\x82\x9E\x43\x01\x84\x87\x90\x43\xA3\x0C\xA6\x7F\xA4\x9F\x34\xA1\x12\xA4\x82\x8B\xA1\xD8\x99\x13\xA8\x82\x8F\xA1\x3C\xA3\xCC\x9B\x82\x92\xA1\x2D\xA2\xF2\x91\x7B\xB7\x9E\xA6\x9F\x0F\xA1\xE0\x22\xA0\x5A\xA2\x0D\xAC\x85\xBC\x9F\x7B\x65\xEE\x98\x79\x86\x04\x15\xA1\x27\x97\x81\x8B\x92\x3E\xA1\x01\xA1\x75\xA5\xA1\x05\x05\x15\xA8\x85\x97\xA1\x21\xA0\xFE\x95\x83\xB7\x5E\x75\x98\x00\x02\x87\x80\x9F\xFF\x9D\xB7\x81\x78\xAB\x9A\xAE\x9D\xE1\x90\x7B\x87\x9E\xB2\x9D\x1A\xAA\x87\x80\x00\xB8\x9E\xF9\x97\x6A\xBB\x9F\x45\x66\x20\xA2\x76\x94\x9E\x3B\xA0\x00", + "\xAA\x10\x39\xA1\x8D\xA3\xE6\x9F\x88\x8C\x9F\x91\xA2\xF3\x91\x88\x99\xA1\x75\x9D\x61\x97\x77\x8C\xA1\x9E\x67\x21\xA4\x81\x89\xA2\x67\x9D\x00\xA3\x86\x8A\x04\x53\xA0\x0E\x9E\x87\xA7\xA2\x80\xA2\xE2\x9C\x86\xA9\xA2\x32\x98\x26\xAC\x69\x9A\xA2\xA7\x9C\x2C\xA0\x78\xB2\xA2\x51\xA0\x2D\xAC\x87\x84\x04\xB7\xA2\x2E\xA6\x8A\x8A\xA3\xA8\xA2\xEE\x9A\x84\x88\x9B\x90\x9D\x1C\xAE\x84\xBE\x9D\x50\xA0\x23\xAC\x82\xAF\x9E\xF2\x9F\x19\xA6\x10\x33\x9E\x46\xA1\x29\xAD\x8C\xBD\x97\xCF\xA0\xEF\x9F\x75\x96\x65\xAE\xA2\x43\x05\x87\x9A\x99\x77\xA0\xF2\x90\x8A\x97\xA3\x8E\xA1\x36\xA0\x89\xA8\xA1\xCB\xA0\xF2\x95\x89\x8E\xA0\x97\xA2\x61\x9D\x85\xAD\xA2\xD3\xA1\xEA\x95\x8D\x9B\xA2\xA1\xA0\xF2\x9D\x81\xB4\x9F\x47\xA2\x02\xA6\x85\xB3\x9D\x96\xA1\xAE\x94\x7A\x8E\x9A\xBB\xA3\xE4\x97\x8E\x8A\x96\x3D\xA3\x3E\xAB\x77\xBD\xA3\x6A\xA3\x24\xA9\x8C\xB2\xA3\x92\xA1\x0C\xA2\x87\xBB\x98\xEA\x8A\xEA\x88\x8F\x9F\xA1\xD4\xA1\x18\xAB\x8E\xA4\xA1\xD8\xA2\x0B\xAA\x8D\x85\x04\xDC\xA3\x40\xAD\x80\x83\xA2\xBD\xA2\x3D\xA0\x87\xA4\xA3\xF9\xA2\xF0\x9E\x90\x93\x9E", + "\x10\xA7\x24\xAF\x8F\x88\xA0\x01\xA4\x41\x0D\x8D\xB0\xA3\xDF\xA0\x46\xA9\x3A\x9A\x8E\x8D\x65\x39\xAA\x10\x0B\xA4\x94\x97\x27\xAF\x92\xB3\xA1\x1A\xA3\x31\xA0\x00\x13\xA4\x11\xA5\x49\xAF\x87\x84\xA4\xF4\xA2\x41\xAE\x8B\xBB\x9A\xC0\xA2\x42\xA2\x8C\xBB\x8B\x8B\xA0\x3F\xAC\x8E\xA2\xA2\xEE\xA0\x29\xA8\x93\xB9\xA2\x14\xA5\x54\xA0\x8E\x9B\xA1\xD0\xA1\xFA\x92\x8D\x9C\xA4\xFA\xA2\x47\xA3\x8B\x86\x04\xB5\xA3\xF7\x93\x92\xAB\xA1\xF1\xA1\x52\xA9\x90\x9F\xA5\x6E\xA1\x58\xA6\x82\xBD\xA4\x2D\xA4\xF6\x93\x94\xAD\x9E\x57\xA6\x3F\xA3\x8A\x9E\xA0\xDE\xA0\x57\xAE\x96\x9E\xA5\x3A\xA4\x2F\x9B\x8F\x6B\x05\x0A\x02\x16\x88\x10\x10\x63\x7E\x74\x44\x09\x71\xA9\x9C\x17\x9D\xC4\x9D\x1D\x93\x9C\x8E\xA6\x31\x9D\x6E\x8F\x9C\x90\xA7\x64\xAC\x71\x93\x97\x16\x9F\xC6\x91\x99\xAC\x9B\xBB\x97\xBA\x91\x3E\x96\xA6\x9B\xA7\x67\xA9\x99\x9D\x97\x4F\x0A\xC8\x9C\x98\x9A\xA6\xA0\xA5\x6A\xA3\x9A\xA4\x9C\xA7\xA4\x66\x8F\xD9\x57\x8F\x74\x99\x0E\x70\x48\x94\x04\xED\x85\x12\x9E\x4B\xA7\x99\x67\x93\x6C\xA0\x11\x01\xA6\xF4\x94\xB6\x8A\x9B\x8C\x04\xBC\xA5\x98\x9B", + "\x55\xBF\xA6\x08\x05\x70\xA0\x4B\x91\x95\xC4\xA6\x40\x06\x9C\xBF\x95\xB9\xA7\x5A\x0B\x9C\xAD\x99\xC3\xA6\x73\xA8\x9B\x88\xA7\xD2\xA4\x9B\x97\x24\x94\x79\xC9\xA5\x40\x0F\x9C\x97\xA7\x0F\x89\x76\xA0\x10\x1B\xA7\x22\x8D\x2E\x97\x9B\x96\xA7\xE1\xA7\x28\x93\x9E\xA0\x99\xC7\xA5\x74\xA7\x9E\xA9\x98\x19\xA6\x6F\xA5\x9D\xA8\xA7\xCC\xA6\x9B\x94\x89\x4B\x9B\x7C\x85\xB3\x9E\x8C\x9B\x5F\x45\x9E\x8D\x85\x39\x9E\x9A\xB5\x8D\x95\x9A\x92\xA0\x76\x0B\x88\xAB\x95\x6C\xA7\x8E\xEC\xA7\x4E\xA1\x3C\xB3\xA7\x97\x98\xB3\x9E\x6D\xAB\x8D\x08\xAA\x80\x8B\x6D\x9D\x9B\xD5\x9B\xB7\x91\xBA\x7C\x9A\xB7\x9A\xAF\x9F\x80\xB2\xA5\xAC\xA1\x83\xAA\x6D\x83\xA8\xBE\x8F\xB1\x92\x8E\x91\xA3\x1C\x6C\x7D\xA0\x36\x8B\xA8\x8D\x9B\xDF\x64\xA1\x94\x9B\x16\xA9\x3D\xAB\x8A\xB7\xA3\x1A\xAB\x26\xAF\xA0\xBC\x8E\x24\xA8\xB0\x9D\xA2\xBA\xA7\x02\xA8\x7F\xAB\x3C\xA1\xA3\x4C\x98\xAD\x91\x87\x62\xA8\x9D\x92\x7D\xA0\x97\xAA\xA2\x37\xA0\x8B\xA6\xA2\x93\x9B\x0A\xA9\x84\xAC\xA0\x83\xA9\x01\xAB\x8B\xAA\x67\xB1\xA8\x07\xA4\x92\xA4\x21\xB5\xA8\xBD\x99\x7F\xAD\x67\x98\xA8\xDF", + "\x95\x6B\xAC\x9A\x94\xA6\x09\x9F\x65\xA8\x5D\xAB\xA6\x26\x9C\x96\xA8\x72\x9E\xA9\xFB\x98\x98\xAD\x98\xAA\xA6\x1E\x9D\x98\xA8\x71\xBE\x9B\xE2\x86\x98\xA8\x9A\x9C\xA9\x56\xA9\x97\xAE\x5D\xA6\xA6\x6A\xA8\x69\xA4\xA6\xA3\x9B\x95\xA4\x9B\xA1\xA7\xA6\x97\x12\x06\x70\x73\x23\xB5\x02\xF0\x7F\x45\x9E\x10\x3A\xA9\x9D\x90\x9F\xAE\xF3\x70\xA7\xD0\xA7\x48\x90\xA8\x9A\x99\x82\xA8\xEE\x70\x9E\x90\x83\x87\xA8\x43\xA0\x00\x09\xAA\x2A\x83\xA2\xA0\xE2\x4D\xAA\x41\xA6\x41\x00\xA9\x82\x81\x92\xA8\x95\x74\xA9\xB9\x99\x0A\x07\xA5\xA4\x08\x99\xAA\x0F\x8B\xA6\xAE\x6A\x92\x04\x9E\xA8\x41\x80\xAA\x98\x8B\xA2\xA8\xB7\x94\xAA\xBD\xA9\xB2\x99\x8E\xA6\xA8\xA5\x66\xA5\xAA\xE7\x57\xAA\xA7\x91\xA9\xAB\x07\x61\xAB\x85\xA4\xD6\x9B\x7F\xA8\x09\xB5\xAA\xAB\xAB\xA0\xA5\xA0\x82\xA6\xA1\xA8\xAC\xAC\xAA\xBB\x9E\xAE\xA8\x80\x9E\x96\x5C\x68\xB7\xA9\x53\xA9\xAB\xAB\xA8\x21\x9B\x64\x68\xAC\x49\xAB\x28\xA6\x7F\xAC\xAC\xB9\x70\xBC\xAA\x43\x00\xAD\xAD\xA1\x40\xAB\x1B\xA6\x98\x87\xA7\x97\x81\xBC\x95\xA6\xA3\xA9\x76\xAA\x96\xA9\x6F\xAD\xA9\xE4\xAB\x9D\xAE\xA6", + "\xA1\xA6\x05\x95\xB8\xA8\xAE\xBD\x96\xE2\xA8\x4B\x8E\x10\x07\x77\x33\x8A\x2D\x03\xAC\x8B\x63\x0D\x60\xBC\xAD\x49\xB2\xAB\xBE\xAA\x90\x9A\x60\xA7\x91\xF6\xAA\x96\x98\xAF\x8A\xAA\xD3\xA7\x56\x9D\xAF\x8E\xAA\xFF\xA9\xA4\xA1\xB0\xA3\x94\x03\xAD\xA5\xA5\x10\x05\xAC\x98\xAB\xC1\xA6\xAC\xA1\x65\xA5\x64\xC3\xAF\xA9\x8E\xAC\x26\x90\x7F\x71\xB1\xB3\xAB\x60\xA7\x87\xA6\x47\xB8\x76\x17\xAD\xBE\xAB\x64\xBB\xAB\x51\x95\xC2\xAC\xA9\x86\x04\x12\xAE\xA9\xA4\xB1\x9B\xAC\xD7\x74\x87\x65\xB2\xB2\xAA\x27\xAF\x51\x99\xB2\x88\x6B\x2B\xAC\xAE\xA2\xA1\xAB\x9A\x22\xAF\xA8\xAE\x10\x31\xAC\xCA\xAB\xCC\xAB\x89\xB5\xAC\xAA\xAB\xCD\xA8\xB1\xB1\xA5\x1A\xAE\xCB\xA0\xB1\xAA\xAC\x3F\xAD\xB6\xA4\xA5\x8D\xAB\x2F\xAD\x14\x78\xB3\x91\xAB\x53\xA9\xD0\xAD\x1B\x2F\xA6\x89\xA4\xD7\x8E\x99\xA9\xAB\xDF\xAB\x9A\xA5\xB5\xAE\xA6\x6B\x07\x62\xA6\xAE\xA5\xAB\xED\xAB\xC2\x93\xA7\x8D\x9C\x59\xAB\xBA\xA7\x26\xA2\xAD\x69\x8B\x99\xA3\xB5\xAC\xAB\x64\xAD\xB8\x9F\xB5\x92\x9C\x61\xAE\x78\x00\xA7\x9D\xAD\x10\x9F\xDA\xAF\x98\xAD\xAD\xEA\xAA\xDC\xA2\x99\xB5\xAD\x78\xAF", + "\xD5\xA7\xA5\x9A\xA9\xF3\x06\xD6\xA0\xB7\xB5\xA9\x7A\xAF\xB9\xA6\xB7\x9C\xA6\x81\xAC\xD7\xA9\xB6\xA9\x9B\x87\xAE\x62\xA8\xA6\xA4\x8F\x86\xAF\xE0\xA2\x9A\x85\xAE\x5B\xAC\xAD\x8F\xB6\x89\xAE\xFF\x99\xE3\xA9\xB7\xB4\xA9\x74\xAC\xE4\xAF\xB7\x99\xAE\x98\xAF\x97\xAB\xB9\x9E\xAE\x94\xAD\x9A\xAF\xB9\xA6\xA9\xA1\xAC\xE3\xA1\xB9\xA3\xAE\xE0\xAA\xE6\xA5\xBA\x81\x04\x7E\xAF\xEA\xAD\x4C\xA7\xAE\xAE\xAD\x95\xA0\xBB\xAE\xAD\x8B\xAF\x30\x98\xBA\x96\xAD\x9D\xAC\xE9\xAE\xB8\x94\xAD\xBF\x5D\x16\x80\x9B\x9A\x99\x0D\x60\x9E\x1C\x17\xAB\x00\x5E\x94\xF1\xA1\x86\x86\xAF\xAB\x99\x6D\xAE\x10\x02\xAF\x33\x88\xF2\xA4\x66\x84\x04\xCE\xAD\x2C\xAA\x10\x11\xAF\x93\x9F\xAC\xA1\x55\x8C\xAF\x9D\x90\xF5\xA8\x63\x8E\x04\xDA\xAF\xC1\x8A\xBD\xA0\x8C\xE4\xA4\x34\x88\xBD\x9A\x99\xDA\xAC\x92\x90\xBD\xB2\x9C\xDF\xAE\xCC\xA7\xA4\x84\xA5\x04\x07\xF8\xAE\xA8\xA5\xAF\x85\x65\xF7\xA1\xBF\x8D\x8D\x1E\xA9\xB1\xA5\xB1\x86\x04\xEE\xAE\xC2\xA7\xBE\xAD\x98\x00\x02\xFC\xA7\x40\xA9\xAF\x39\xAF\xFA\xA1\xBC\xA5\x66\xF0\xAF\xFF\xA8\xBE\xB4\xAF\xAD\xA8\xC8\xAB\x55\xB9", + "\xAF\x23\xAD\x41\x05\xC0\xB8\x90\xFE\xAC\x04\xB8\xC0\x84\xAB\x0A\xB3\x48\x9C\xC0\xB6\xAC\xD3\xAD\xF1\xA7\xC0\x86\x8D\xFA\xA8\x8F\x97\x46\x97\xB0\x3D\xAD\x06\xBC\xBF\x91\xB0\x8B\x90\x00\xBC\xB4\x92\x9F\x47\xAD\x0E\x70\xC2\x9F\x60\x0F\xB1\x09\xBB\xC1\x89\xAF\x2D\xAF\x95\x93\x66\x04\xB0\x1A\xB3\xF1\xA3\xC1\xB8\xA8\x15\xB3\xC3\xA3\xC3\x9C\x68\x2D\xB0\xF2\x94\xC2\xBE\xB0\x37\xB1\xC6\xA6\xBF\xA8\xAC\xED\xAC\x0D\xB3\xC2\xAF\xB0\x9B\xA2\xF5\xAB\xC0\x86\xB1\x3F\x9A\x03\xB8\xC4\xBB\x9D\x4A\xB3\x69\x99\xB5\xB5\xAE\xAF\xAF\xED\xA8\xB5\xA9\x05\x53\x8D\x14\x73\xAE\x97\x97\x7D\xAC\x15\xB2\xBB\x96\xB1\x7B\xAD\xEC\xA6\x6E\xA2\xB1\x5E\xB3\x18\xBB\xBB\xA8\xAD\x67\xB2\x70\x0D\xBA\xA9\xB1\x65\xAC\x19\xB7\xB6\xA3\xAD\x6C\xB0\xDC\x75\xC6\xB3\xB1\x6F\xB1\x1B\xB1\xC7\x88\xAE\x77\xB3\xBD\x9A\xA5\x8D\x60\x22\x01\x69\x64\xBE\x51\x79\xAC\x68\x1F\xBE\xC7\xA1\x81\x40\xAF\x10\xB2\xB4\x80\x00\x7D\xB0\x87\x6F\xC7\x99\x79\x84\xA8\x77\xA8\x2D\x89\xB2\xC8\x6B\x22\xB0\xE6\x61\xAF\x20\x78\x24\xB1\xC5\x52\xB2\x56\x65\x14\xBA\xC3\x96\xB2\x8F\x70\x26", + "\xB6\x11\x1A\xB2\xF7\xAD\x41\x0C\xC9\x97\x72\x9E\xB2\xFA\xA5\xA2\xAC\xAF\x88\xB3\x20\xB1\xE4\x49\xB0\x1E\xB1\x54\x93\xCA\xBC\x85\xA5\xB1\x00\xB7\xCA\x82\xB2\x8A\xB0\x21\xB6\xB4\x8E\xAD\x47\x86\x41\x0F\xCA\xB3\x88\xB1\xB3\x09\xBA\x7F\xBA\xAA\xAB\x9B\x2E\xBD\x49\xBD\xB2\xD8\xA9\x4A\xA3\xAD\x98\x82\xC2\xB2\x96\x94\xCC\xBC\xA2\xD2\xA9\x90\xA8\xB4\x84\x04\xC9\xB2\xA3\xAB\xCC\xB7\xA7\x85\xB1\x0E\xB1\xCA\x90\xB3\xAA\xB1\x92\x7D\xC1\xAD\xA7\x67\x91\x0B\x05\x9A\x5B\x01\xB6\xB2\x4C\x8E\x10\x1E\xB3\x1C\x68\x38\xBB\xCA\x94\xB0\xAD\xB3\x56\x94\xCE\x88\x6B\xE6\xB2\x36\xBF\xB1\xA9\xB3\x23\x97\x3A\xB1\xC5\x6D\xB3\x80\xB3\x36\xB6\xA0\x91\x95\xF2\xB3\x23\x74\xCF\x8C\xB2\xBF\xA9\x6F\xAD\xCD\x9F\xB3\xE1\xB1\x33\xBA\xAD\x98\x82\xF9\xB3\x25\x7B\xCF\x93\xB2\x8D\xB1\x79\xA5\x10\x05\xB4\x7C\x87\x41\xB9\xC9\xB1\xB0\xB9\xB3\x42\xB0\xD0\xA7\xB3\x38\xB0\x3C\xBA\xC3\x8C\xB4\x33\x8A\x43\xBF\xC9\x90\xB4\xCF\xB0\x00\x08\xD1\x9D\x92\x1A\xB6\x29\xB2\xA3\x93\x9E\x1F\xB6\x96\x91\xD2\xB2\xB2\x23\xB4\x2A\xB5\xD2\x8E\xAA\x27\xB6\x2F\xB7\xA1\xB8\xB2", + "\x1D\xB7\x4A\xBA\xBF\x80\x00\x2D\xB5\x31\xB2\xD0\xA9\xB0\x04\xB7\x44\xBE\xCE\xA5\x91\x86\xB2\x0C\xB8\x04\x25\x66\x8A\x01\x40\xB0\x11\x0D\x60\x3F\xB4\x87\x61\xD4\x94\xB4\x42\xB2\x35\xB4\xC4\x80\x00\x45\xB4\xB2\x67\xD4\xBB\xB4\xF5\xAE\x52\xB7\xC8\x8D\xB5\x51\x73\x53\xB5\xCF\xAF\xB3\xDC\xB1\x54\x94\xD5\x8F\x72\x56\xB4\x3F\xB6\xCF\x80\xAB\xD8\x8B\x56\xB7\xC9\x5D\xB5\x08\xB5\x3F\xB2\x9C\xA3\x94\x62\xB4\x5F\x84\xD6\x8F\xB4\x94\xB0\x95\x79\xD6\xB3\x88\x6B\xB7\x46\xBD\xD6\x8F\x88\x6F\xB5\x27\x91\xD7\xA2\xB4\x4D\xA8\x2A\xB5\xD7\x9A\x99\x77\xB4\x4A\xB9\xD7\x84\xB5\x40\xB6\x50\xB8\xC2\xB0\xB4\x39\x73\x5E\xBE\xA8\xBD\xB5\x2E\xB6\x8A\xAE\xCC\x85\xB6\x81\xB4\x52\xB5\xCD\x96\xB4\xD7\xB0\x53\xBD\xD8\x90\xB5\xAC\xB1\x56\xBB\x55\x86\xB6\x33\xB4\x62\xB6\xD3\x8D\xAD\x3D\xB5\x44\xB4\x10\x02\x01\xA5\x66\x1F\x02\xD8\x91\x74\x0E\x04\x68\xBC\xA1\x62\xB6\x8E\xB7\x2D\xBD\xD9\x9D\xB4\xA6\xB4\xB2\x68\xDA\x94\xB6\xE8\xB2\x65\xB3\x52\xAD\xB6\x51\x73\x6B\xB7\xD5\xBC\xB4\x52\xB6\x0C\xB4\xDB\x8F\x72\xB6\xB6\x57\xB8\xD5\xB7\xB3\x5B\x97\x6E\xB7", + "\xC9\x7D\xB6\x65\xB7\x57\xBE\xCF\x91\x95\xC2\xB4\x5F\x84\xDC\xAC\xB5\x09\xB4\x34\x89\xDC\xB3\x88\xCB\xB6\x5C\xBD\xDC\xA0\x78\xCF\xB5\x27\x91\xDD\xB8\xB5\x4F\xA7\x26\xA5\xDD\x9A\x99\xD7\xB6\x5F\xB9\xDD\xBB\x9D\xDB\xB6\xA3\xAD\xDD\x89\xB6\x4E\xA4\x30\xBA\xDD\xA1\xB6\xA3\xB7\x4B\xBB\xDA\xB9\x70\xE1\xB7\x4C\xB3\xDE\x9B\xB6\x83\xB7\x7A\xB8\x09\xAD\xB7\x0D\xB0\x41\x0F\xDE\x8C\xB3\x9C\xB5\x6E\xBE\xD9\x80\x00\xF4\xB4\x06\xB6\x10\x37\xB7\xD4\xB2\x6A\xBA\xDF\x9D\xB4\x57\x01\x69\x62\x0A\x29\xB7\x01\x05\x03\x65\xE0\x9C\x68\x07\xB9\x6A\xB6\xCC\x8B\xB6\x98\x83\x82\xB8\xAC\x4D\xB8\xB0\xB5\x45\xB2\xDB\xBA\xB0\x12\xB9\x14\x74\xE1\xB7\xB6\x51\xB4\x64\xBB\xD4\x99\xB8\x8F\x73\x86\xBE\xDB\xB8\xB6\x1E\xBB\x21\xB0\xE2\x97\x72\x22\xB9\x71\xBF\xDB\xA0\xB5\x67\x93\x89\xBC\x17\xA9\xB8\xCC\xB6\x59\xB9\x9E\xA3\x94\x2E\xBB\x8C\x80\xE3\x92\xB7\x32\xB9\x7C\xAB\x55\xB5\xB8\x9D\x93\x8D\xB8\xDD\xA6\xB7\x7B\x9C\x8F\xBA\x65\xBE\xB8\xDE\xB4\x90\xB3\x79\x82\xB9\x8E\xA8\x91\xB4\xDE\x8B\xAB\x10\xBB\xAA\x98\xE4\xB3\xB4\x4A\xB8\x7C\xBF\xCB\x87\xB3\x4E", + "\xBA\x81\xB8\xE0\xA5\xB7\x54\xBB\x26\xAF\xE4\xB5\xB7\x00\x01\x94\xB8\xDF\xB1\xB7\x03\xB9\x0E\x7B\xE5\xBE\xB7\x8A\x07\x95\xBC\xE4\x83\xB4\xDE\xA9\xEE\xA9\xBA\xAA\xB9\xB8\xAC\xD8\xAE\x19\x8A\x93\x5B\xB0\x18\xB2\xB8\x97\xAE\x6E\xBA\xEE\xA4\xE7\xAC\xAD\xA0\xAD\x1E\xB3\x1D\xA9\xB9\x75\xBB\x9A\xBD\xE7\xAD\xB9\x78\xBA\x9D\xB2\x22\x13\xAE\x7A\xBA\xE8\xAE\xC6\xBC\xB9\x81\xBA\x9F\xB9\xE8\x83\x84\x50\xAD\x6A\x9A\x65\xB1\xB9\x87\xB9\xC5\x9A\xBA\x85\xBA\xA6\xAE\x9C\xB6\xB9\x93\xBA\x77\xBB\xDC\xA9\xE7\x99\xBA\x77\xAC\xA6\xBE\xE9\x93\x08\x6B\xB0\xA7\xB4\xB8\xAC\xB9\x72\xAA\xA8\xBF\xB8\x93\x08\x84\xBA\xA9\xBC\xBB\xBF\xB9\xA5\xBB\xA7\xBC\xEA\xA1\xB1\xC9\x92\xEF\xA1\xB5\x8E\xAA\x0D\x60\x62\xA1\xC5\x42\xAF\x85\x7D\x41\x0C\x18\x14\xA5\x0E\x07\xAE\xB0\xBE\x9D\x73\x23\x45\x69\x68\xEB\x85\x66\xBB\xBB\xC1\x8E\xEB\xBF\xB8\x59\xBB\xDE\x96\xEB\x8F\x72\xC3\xBB\x01\x95\xEC\x84\xBB\x41\xB3\x63\xB7\xE1\x91\xB6\xCB\xBB\x25\x7D\xEC\xB8\x90\xCF\xBA\xB3\xB1\xED\x82\xB8\x25\xBA\x0C\xB5\xED\xBC\x85\xD7\xBB\x22\x99\xED\x98\xBB\xDB\xBB\x83\xB8\xE6", + "\x9B\xA2\xDF\xBB\x8C\x81\xEE\x88\x9F\xE3\xBA\xB8\xB5\xEE\xB7\xB4\x84\xB4\x26\x89\xEE\x9D\x92\xEB\xB9\x44\xAD\xEE\xAC\xBB\xEF\xB9\x7E\xBD\xED\xBB\xB7\xF3\xBA\x96\x95\xEF\x93\xA2\xF7\xBA\xBD\xB9\xEF\xA0\xB9\xFB\xB9\x47\xBD\xEF\x8E\xAA\xFF\xBB\x07\x61\xF0\x80\xBC\x03\xBF\x94\xBD\xE4\xA8\xBB\xC2\xBB\xCE\x70\x00\x0B\xBC\x0A\xBD\xC3\xBA\xDE\xA1\xB9\xF2\xB9\xC4\xBB\xDE\x46\x04\x14\xBE\x44\x07\xEC\x85\xB9\xC9\xBB\xE4\x97\xF0\xB3\xB4\x09\xBE\xC7\xB2\x73\x9F\xBC\x4B\xBA\xCE\xAA\xEC\x9A\xBC\x20\x76\xC9\xB1\x86\xA8\xBC\x52\xBB\xC5\xB5\xF0\xB9\x70\x23\xBC\x97\xB5\xF2\xBD\xBA\x27\xBE\xC5\xBA\xD8\xA7\xBB\x2B\xBC\x87\x67\xF3\xAF\x59\x39\xBC\x07\xBB\xE2\x87\xB7\x78\xB2\xAA\xB8\xC6\x86\xBD\x70\xB0\xD2\xB6\xC7\x8A\xBD\x6A\xAC\xD3\xB5\xF4\xAE\xBA\x8B\xB9\xAB\xB4\xEA\xB0\xBA\x4E\xBE\xE2\xA5\xC7\x8D\xBD\x50\xBE\xA6\xB2\xE8\x93\xBD\x73\xBB\xA0\xB4\xC7\x88\xBA\x5A\xBE\xA2\xB1\xF6\x80\xBA\x63\xBE\xD4\xBC\x2C\x33\x07\xB5\x9C\x9C\xB3\x70\x9C\xBD\x97\xB8\xDB\xB3\xBB\x95\xBD\x95\xAF\xDB\xB9\xF5\x9D\xBA\x6E\xBE\xA5\xB2\xF7\xB5\xBD\x91\xB9", + "\xC7\x90\xEA\x9F\xBD\x92\xB8\xDE\xB4\xE9\xB6\xAE\x79\xBC\x66\xAE\xF5\x97\xBD\x4F\xBE\xDF\xB0\xF7\x86\xBA\x7F\xBD\x15\xB1\xF8\x90\x88\xBB\xA7\xB6\xA1\x10\x35\x9E\x90\xB9\xE2\xBF\xC5\x8B\xBE\x91\xBF\xE1\xB5\xE9\x94\xBE\x6B\xBF\xAB\xBD\xF5\x86\xBE\x73\xBF\xA8\xB9\x22\x21\xBA\x9D\xBF\xA9\xBA\xF9\xAD\xBD\xA3\xBF\xDD\xB9\x22\x29\xBA\xA1\xBF\xAA\xB1\xF5\x94\xBD\xA9\xBF\xD1\xBD\xFA\x90\x8D\xEB\xA7\x96\x82\x10\x35\x9E\x85\xA1\x61\xA8\x09\x80\x01\xA5\x64\x1F\x02\xF1\xB9\x01\x67\xA5\x41\x08\x07\x23\x91\x1F\x63\xEF\xB2\x8C\x45\x66\x7B\x02\x44\x06\xFB\x8B\xB9\xB5\xBD\x0E\x78\xFB\x9C\x68\xBA\xBF\xC6\xB5\x10\x3C\xBE\xC5\xA2\x41\x02\xFC\xA2\x90\x38\x93\xF4\xB6\x10\x1F\xBB\x1F\x61\xF1\xBE\x10\x07\xBF\x31\xBF\xCE\xB8\xD3\x90\xA5\x29\x46\xF2\xB9\xFB\xBB\xBE\xBD\xBC\x41\x06\xFD\x98\x91\xD5\xBD\xB0\xB7\x40\x9A\xBF\xE1\xBC\xC8\xBF\xF0\x88\xA4\xDB\xBE\xF8\xBC\xFC\xA4\xBF\xD1\xBE\xEF\xB0\xFC\x92\x04\xE7\xBC\x41\x08\xFD\x92\x04\xEC\xBE\x41\x0C\xFD\x9F\xB9\x0E\xBC\xCF\xBD\x9B\x56\x04\xFF\xBF\xE4\x9B\xFC\x88\x6B\xCD\xBD\xCB\xBE\x10\x10", + "\xBF\xD6\xA2\x43\x09\xFF\x81\x92\x85\x67\x03\xCB\xFF\x8E\x04\xFD\xBD\x41\x05\x00\xFF\xA8\xE6\xBB\xF7\xB1\x6C\x86\xBF\xF2\xBC\x02\xC4\xFF\x8D\xC0\x0A\x07\x03\xCF\xEC\x41\xBF\xEA\xBC\x0E\x95\x01\xC4\x04\x17\xC0\x28\xB2\x96\x96\x65\x17\xC1\x03\x67\x00\xD1\x71\x09\xC2\x67\x6F\x81\x4C\xC0\x56\xA6\x03\xC7\xFF\xB6\xC0\xC3\xBF\xFA\xBC\x01\xEE\xBF\x02\xC0\xC7\x64\x00\xDD\xC0\x30\xC3\x07\xC5\x03\xE1\xC0\x37\xC0\x11\xC9\x03\xE6\xC0\x3B\xC1\xCA\xBB\xBE\x89\xBF\xB7\xBF\xF8\xBE\xFC\x84\x04\x34\xC3\x43\xA8\xFF\x85\xC1\xD2\xBD\x09\xCB\x48\xA7\xC0\x00\x01\x0A\xCC\xD1\x99\xA2\xED\xBF\xAA\x9F\x02\xCF\x72\x31\xC3\x69\x72\x11\x11\xC1\x30\xA7\x14\xC5\x41\x87\x90\x12\xC0\xF1\xB9\x04\xDD\xBF\x58\xBB\xFB\xB3\x00\xEB\xC1\x7B\x9F\x17\xC7\xC9\x61\xC1\xB4\x77\x18\xC5\xFE\x80\x00\x22\xC1\x04\xC6\x05\xC8\x9F\x58\xC2\x16\xC3\xD7\xBC\xA4\x7B\x65\x0B\xC2\x11\x32\xC1\x7C\x84\x1D\xC3\xDC\x76\xC1\xF5\xBE\xF9\xB4\x05\xF6\xBF\x47\xC3\x15\xC0\x07\xC1\xB8\x19\xC1\xBC\xB0\xFE\xBE\xBF\x40\xC0\x18\xC2\x04\xD2\xC1\x38\xC0\xF5\xBB\x48\xA9\xC1\x3A\xC1\xFC", + "\xBC\x03\xDA\xC0\xF0\xBD\x17\xCB\x89\x84\xC2\x33\x8A\x21\xC9\xEB\x90\xC1\x77\xC1\x1E\xC8\x06\xFB\xC1\x11\xA5\x1F\xC8\xEC\xAE\xC1\x3E\xC3\x23\xC8\xCA\xA4\xC2\x9D\x92\x29\xC5\x98\x64\xC1\xA8\xB0\x09\xC7\x06\xE9\xBF\x8D\xC0\x1F\xC2\x0B\xEA\xC0\x3A\x6B\xF4\x8C\xF7\xBA\xBD\xA5\xBE\xDD\xB6\x0C\xD8\xBE\x5E\xAE\xE5\xB0\xF8\x92\xBE\x66\xB2\x32\xCA\xF8\x8C\xC3\xC3\xC2\xE0\xBB\xF7\x84\xBE\x7A\xB0\x32\xC1\xB7\x8E\xC3\x93\xBC\xED\xA4\x0D\xF1\xBD\xC7\xC0\x34\xCB\x0D\xC8\xBE\xD8\xC1\x33\xC2\x2C\x33\x07\x72\xA3\x7C\x0C\x8B\x55\xBE\xAF\xBF\xD2\xB9\x0E\xD8\xBD\x9C\xBD\x3B\xC5\x0C\xD6\xC3\x80\xAE\x3B\xCB\xFA\x9B\xBE\xEF\xC2\xE4\xB0\xFA\xB2\xC3\x65\xBC\xEB\xB8\x0F\xF4\xBD\xF5\xC3\x80\x08\xFA\xBB\xC3\x9E\xBF\x3C\xC4\xFA\x82\xC4\xA6\xBC\x41\xCC\xB7\xAB\x05\x69\xBF\x5A\x02\x87\xA8\xC3\x00\xC6\xE8\xB6\x10\xF0\xC3\x9C\xAD\x3F\xCB\x0E\xC5\xBE\x12\xC5\x43\xCA\xFA\xB9\xC3\xF4\xC3\x43\xC2\x1E\x37\xC3\x15\xC5\x47\xCA\x11\xE1\xC3\xD1\xC3\x96\xA3\xF8\xA0\xBD\xFC\xC3\x47\xC3\x11\xD5\xC3\xDE\xC0\x49\xC1\x10\xF8\x0B\x68\xBE\xE3\xB0\x10\x32\xA1", + "\xF9\xA4\x41\x0C\x00\x15\xC2\x73\xC2\xC4\xBA\x07\x37\xC1\xB8\xC3\x08\xC6\x06\xCF\x63\x7A\xC2\x27\xC8\x04\xE5\x59\xB8\xA9\x4C\xC0\x00\x33\xC4\x4D\xC3\xFC\xBF\x04\xC0\x00\x37\xC5\x22\xC0\x00\x39\xC4\x3D\xC4\x4F\xCB\x0A\xFE\xC4\x8E\xC0\x50\xCF\x09\xD2\xC2\xA5\x9E\x54\xCE\x05\xCE\xC1\x0A\xC2\x42\x09\x14\xE0\xC0\x06\x04\x53\xCF\x14\xCE\xC5\xBC\xC2\x28\xCE\x0B\xD6\xC5\x6C\xC3\x99\xB0\x0A\xCE\xA9\x2F\x44\x4D\xC5\x08\xF6\xC4\x38\xC7\x22\xCA\x08\xFD\xC2\x11\xA7\x03\xC7\x01\xD9\xBF\x12\x04\x51\xCA\x04\xE7\xB2\x42\xC6\x5D\xC3\x0A\xD8\xC5\x32\xC2\x44\x0B\x15\xC3\xC1\x5D\xC6\x5B\xC8\x07\xEC\xC2\x93\xA2\x5C\xCA\x06\xE4\xC5\x00\xC2\xCC\xB3\xED\xAB\xC0\x92\x06\x5E\xC1\x07\xFC\xC5\x62\xC2\x43\x0F\x17\xD8\xC2\x0A\x06\x57\xC1\x16\xD7\xBF\x4D\xC4\x25\xCD\x09\xCA\x04\x8E\xC4\x24\xC0\xEF\xB2\xB7\x3B\xA9\x5D\xCA\x16\xE5\xC2\x6C\xC6\x52\xC6\x19\xDB\xC2\x84\xC6\x2E\xC2\x16\xED\xC2\xA2\xC7\x54\xC0\x1A\xD5\xC5\x9C\xC7\x68\xC5\x0B\xE5\xC6\x5C\xC7\xF3\xB2\x18\xDC\xC2\x97\xC6\x05\xC7\x18\xF1\xC6\xAE\xC4\xC6\xB1\x1A\xC8\xC6\x06\xC0\x64\xC5", + "\x07\xD2\xC6\x6D\xC7\x2E\xC8\x1A\xF0\xC5\x85\xC6\x2C\xC4\x17\xC0\xC7\x18\xC3\x67\xCE\x1B\xF0\xC6\x06\x05\x67\xC3\x0B\xC2\xC7\x87\xC0\x71\xC6\x1A\xF7\xC6\xA9\xC7\x4E\xCA\x19\xFF\xC4\xBC\xC7\x5D\xC9\xD2\xB9\xC5\xB2\xC6\x96\x96\x0B\xC7\x90\x93\xC5\x19\xCB\x00\xD8\xC7\xC8\xC6\x6A\xCB\x1D\xD1\xC5\xDD\xC5\x59\xCA\xF2\xA8\xC5\x32\xC5\x78\xCE\xA8\xA3\xC7\x38\x91\x79\xC9\x0B\xC8\xC2\x9A\xC0\xF2\x98\x1B\xC7\xC7\xAB\xC7\x24\xA8\x05\xD2\xC7\xC0\xC1\x86\xAD\x9B\x52\xC7\x2E\xC0\x75\xC7\x0A\xC8\xC5\xC5\xC5\x7E\xC1\x17\xD9\xC7\x99\xC3\x7A\xC3\x16\xED\xC7\x89\xC6\xF7\xB4\x15\xF3\xA8\xF1\xC5\x51\xCE\x01\xC7\xC5\xF6\xC4\x5E\xA7\x1E\xC6\xC7\xFA\xC4\x83\xC6\x04\xFD\xC7\xCB\xC4\x84\xCE\x19\xFA\xBB\x8B\xC7\x5C\xA3\x20\xF2\xC7\x33\xB4\x7D\xCB\x48\x99\xC8\xB7\xC0\x7A\xC0\x16\xFC\xC7\x0E\xC8\x6B\xCC\x1C\xC1\xC8\xE3\x06\x32\x9D\xE8\xB2\xBE\xF1\xA6\xF5\x83\xEB\x93\x9A\x3A\xCB\x26\xA2\x03\x25\x66\x65\x02\xC4\xB4\x06\x05\xAD\xE2\xB2\x42\x0F\x23\xDC\x68\x41\xCB\x51\xC3\x24\xDE\xAC\x24\xB9\x89\xC2\xC3\x87\xC9\xC8\x69\x92\xC9\x15\xC6\x04\x4B", + "\xC8\xC0\xAF\x07\xE7\x91\x50\xC9\x14\x72\x25\xFD\xC5\x0E\x05\x95\xC6\xB0\x97\xC9\x51\x95\x96\xCF\xC8\x5B\xC9\x91\xC6\x42\x0E\x25\xCD\xAC\x60\xCB\x56\x92\x26\xD7\x72\x64\xCB\x70\xC6\x26\xC4\xC9\xCE\xC7\xCC\xB8\x09\xAB\xC9\x7C\x85\x9B\xC5\x1D\xEF\xC9\x4C\xC9\x87\xBE\x24\xFB\xB7\x74\xCB\x8C\x86\x27\xC7\xC8\x67\xCB\xC4\xA9\x26\xE3\x94\x7D\xC9\x27\x9F\x27\xC5\x66\x81\xCA\xC9\xA3\x28\xFA\xB0\x85\xCA\x96\x97\x28\xC7\x90\x89\xC8\xCB\xAB\x28\xD1\xB6\x8D\xCA\xA3\xAF\x28\xF8\x90\x91\xCB\x2B\xCD\x03\xCD\x60\x95\xCB\x4C\xB7\x29\xCB\x92\x99\xC9\x6F\xC2\x27\xEB\x9A\x9D\xC8\x97\xBF\x29\xC8\x9F\xA1\xCA\x77\xCF\xD7\x92\x04\xA5\xC8\x99\xB4\x10\x27\xCA\x11\xA5\xAA\xCE\x1E\xC2\xB0\xAC\xC8\x90\xC2\x24\xF0\xC9\x24\xC8\x70\xB2\xC5\xAA\x79\x39\x73\x05\xC3\x23\x97\x00\x12\xBE\x95\x5A\x28\xC0\xBB\x50\xC7\x23\x70\x2C\xC7\xC5\xC2\xCA\xA4\xC3\xDD\x94\x79\xBE\xC9\x27\x97\x2C\xD3\xC9\x05\x05\xB2\xCA\x29\xE7\xC5\xA8\xB1\xB3\xCA\x65\x8F\xCB\x5C\xCA\x42\x02\x2D\xE2\xCA\x7B\xC9\x47\xB6\x2D\xCE\xAA\xD8\xC9\x99\xC6\x10\x1B\xCB\xAA\xCB\x77\xB3\x79", + "\x9F\xCB\x33\xB5\xB8\xCE\x26\xE3\xCB\xB8\xC8\xC1\xBD\x2D\xFD\xCA\xA5\x66\xBA\xC7\x27\xEC\xCB\x79\xC9\x65\xBA\x2B\xFA\xB0\xE8\xC8\x97\xB2\x2F\xC7\xC8\xE4\xCB\xAC\xC3\xCB\xB2\xC2\xBF\xC9\xB0\xCD\x2E\xC1\xC0\xD4\xC9\x03\x69\x2F\xEE\xCA\x00\x03\xBE\xC5\x98\x7D\xCB\x11\xC9\x1B\xCB\x29\xC0\xCC\xCE\xCA\xC0\xC5\x2F\xF1\xB6\xF7\xC9\x64\xB7\x30\xE1\xB0\x06\x06\xC2\xC7\x40\x8C\xCC\x23\xCA\xBB\xC5\x31\xCB\xB5\x17\xCF\x07\x6A\x31\xF8\x90\x1C\xCD\x73\xC9\x2B\xEC\xB8\x51\x95\xC8\xC2\x11\x23\xCC\x8B\x91\xC9\xC4\x23\xDE\xCB\xF1\xCA\xC4\xC6\x25\xCB\xCB\xAE\xBE\x45\xC5\x33\xDE\xC4\x18\xC7\x40\xC9\x33\xC5\xC4\x3B\xCD\x37\xC0\x12\xDF\xC3\x97\xBD\x4A\xCD\xF7\xB8\xCC\x25\xC4\x94\x0C\x11\xE6\xC4\x36\xCD\xD2\xB7\x12\xDC\xC3\xB1\xAF\x3F\xC4\x34\xEB\xC4\x45\xCD\xD4\xC0\x35\xD3\xCD\x0E\xC4\xBE\x02\x14\xCD\x60\x58\xCD\x69\x62\x1D\xC7\xC8\x0E\x02\xCC\x97\xF9\x42\xBD\x01\x70\x7D\x7B\x6A\xB3\x88\x5B\xCD\x61\x6D\x35\xE1\xA1\x5F\xCC\x0C\xB3\x29\xCC\xC6\xE8\x75\x0E\x74\x36\xD2\xBC\x67\xCE\x27\xA6\x10\x29\xCD\x49\xB3\x16\xC3\xA1\x98\x82\x59\xCC", + "\x87\x65\x36\xC7\x90\x71\xCE\x22\xAE\x10\x34\xCD\x50\xB2\xDD\xCF\x1B\xEB\x9A\x79\xCC\xB2\x6B\x37\xF8\x90\x7D\xCE\xF4\xA3\x37\xFA\xBC\x0E\xCC\xB5\xC7\x35\xED\xCD\x7A\xCC\xDC\xCE\x35\xCC\xCE\x66\xC7\x84\xC0\x1F\xE8\xB2\x85\xCD\x14\x77\x38\xCB\x92\x89\xCF\x30\xAA\x10\x00\xCE\xD5\xAE\xE0\xC0\x1D\xFB\x9D\x99\xCF\x23\x7B\x39\xC8\x9F\x9D\xCC\xAF\xBF\x39\xD4\xCE\xEF\xC5\x88\xA0\x39\xE3\xCD\x9D\x93\xE9\xC1\x91\xA9\xCE\x07\x8C\xE8\xC8\xCA\xAF\xCC\x00\xAB\x26\xA5\x3A\xD7\x72\xB2\xCF\x24\xA4\x3B\xC5\x66\xB6\xCF\xAF\xB9\xE3\x85\xAA\xE3\xA3\x6F\x7E\x36\xF1\xCE\x92\xCC\xDA\xCC\x3A\xCB\xC1\x62\xCF\x26\xAF\x36\xC7\xC5\xBF\xCF\x01\x91\x3C\xD3\xCB\x96\xCE\xEB\xC8\x37\xC7\xCF\x5A\x99\xEF\xCF\x81\x51\xCF\x38\x93\xF4\xCC\x2D\xDF\xCC\x26\xC9\x1F\x7A\x3B\xDA\xCD\xC9\xCE\xDC\xC5\x10\x1E\xCF\xE5\xCA\x91\xB6\x3D\xC4\xCE\xD8\xCE\xA3\xAA\x3D\xD2\x04\xDC\xCF\x22\x98\x3E\xFE\xCB\x29\xB7\x8D\xC7\x39\xFC\x5F\x0D\x63\x07\x05\x9A\x7C\x00\x12\xBD\x8D\x9F\x65\xAC\x6A\x42\xC4\xFE\xC2\x11\x3A\xCF\x1C\x68\xFF\xC7\x14\xFE\xCF\xD4\xCF\x6B\xC4\x21\xD3", + "\x99\x98\x80\x01\xD8\xAC\x46\xD0\xD0\xC8\x96\x9A\x64\x8D\xC9\xE0\xCE\x80\xCA\xB2\x79\x70\x0E\xD1\x14\x70\x41\xD9\xCB\x01\x9B\x04\xDA\x27\xD5\xD0\x42\xAB\x05\xDD\x40\xFB\xCF\xFD\xCE\x07\xD6\x2F\xE8\xCC\x3A\xA8\x23\x62\x40\xCE\x04\x19\xD3\x23\x7B\x41\xE2\xCB\x05\x04\x02\xDF\x3D\xE8\xD0\xBD\x9C\x25\x6B\x42\xCA\x04\x2D\xD3\x25\x7F\x42\xEB\xCB\x31\xD2\x09\xD4\x31\xF4\xD0\xC5\xCD\x45\x99\x3F\xE4\xD0\x07\xD2\x0F\xD6\xE1\xA0\xD0\x2B\xA5\xC8\x6B\x6A\xB9\xD0\x7C\x87\x0E\xD3\x2F\xFD\xD0\x6B\x98\xCD\xC0\x08\xE2\xD0\x4B\xD0\x11\xD1\x41\xC0\x00\x32\xD1\xFA\xC1\xF2\xAB\xCF\x12\x9B\x26\xAC\x44\xF3\x88\x4E\xD3\x81\xC9\x45\xF4\xCF\x79\xB5\x00\xD8\x41\xD6\xD1\x1C\xD0\x14\xD8\x60\xA2\xCE\x0B\xD3\x0D\xD6\x10\x1F\xD1\x9D\x91\x18\xD5\x98\x63\xD1\x0D\xCD\xE5\xCA\x40\xF7\xCF\x67\xD1\x01\xD5\x42\xD1\xD1\xC3\xCE\x23\xB7\xA0\x8C\x6C\x79\xD3\x03\xDB\x47\xEB\xD1\x6B\xCD\x30\xCC\x2B\xC0\xCD\xCB\xC3\xCF\xCA\x12\xD5\xCD\x52\xCC\x23\xD4\x35\xD7\xC4\x8D\xD0\x24\xDF\x48\xF7\xCC\x48\xCF\xD3\xCE\x48\xCC\x72\x4A\xD3\x26\xA9\xDF\x57\x72\xB2\x02\xC4", + "\xB4\x0B\x32\x9C\xB3\x02\x11\xD8\x9F\xAC\x61\x6E\xD1\x41\x0B\x49\xFC\x85\x9D\xD3\x51\xCF\x49\xE1\xA1\xA1\xD0\x1F\xD6\xDC\xA7\xB5\x41\xD0\x7F\x9D\x80\x67\xD2\x33\x89\x2A\xD7\x45\xEB\xD2\xE6\xCC\x41\x0D\x4A\xC4\xD2\x52\xD3\x1F\xD4\x45\xDA\xD2\xA5\x66\x2D\xD9\x46\xC4\x04\xB8\xD2\xDF\xCA\x10\x3B\xD2\x5D\xD1\x1D\xDD\x3A\xE6\xD1\x98\x80\x2D\xDD\x49\x82\xD3\x30\xD0\x31\xD0\x4A\xE2\xD2\xD2\xB8\x12\xD9\x3B\xDD\x98\xAB\x9A\x33\xDA\x65\x90\xD3\x3C\xD2\x34\xDC\x4A\xD4\xD3\xDC\xBB\xBB\xC7\x37\xEB\x94\xB3\xD1\x30\xDE\x49\xD3\xD3\xAE\xD3\xD0\xB0\x4B\xE0\xA8\x99\xD3\xDE\x9A\x4D\xCE\xAA\xDC\xD3\x13\xDE\x4D\xF9\xD2\x00\x00\x32\xD8\x4D\xE4\xD1\xE6\xC8\x17\xD7\x4F\xEE\xD3\xE6\xD2\x2A\xD8\x4E\xFC\xD2\x7D\xD3\x1E\x71\x88\x65\xD2\x04\x07\x3B\xD3\xD3\xB1\xD3\x07\xC9\x31\xDA\x38\xC5\x04\xF6\xD0\x8C\x93\x43\xC4\xBD\x35\xD0\x20\xDD\x4C\xFD\xD3\xB7\xD3\x3F\xD9\x4C\xDD\xCC\x04\xCD\xF5\xCC\x4C\xD9\xD3\x14\xD7\x30\xD0\x00\x0A\xD4\x9E\xCE\x41\x0D\x50\xCC\xD0\x5A\xD0\x2C\xCB\x51\xC0\xD3\x1C\x68\x42\xD5\x98\x60\xD4\xAA\xCE\x48\xD0\x4E\xD1\xC2", + "\x77\xD2\x3E\xDE\x50\xDC\xD4\x29\xD7\x39\xDF\x4D\xE9\xD3\x14\xD0\x10\xDC\x4E\xC2\xD1\x95\x65\x4D\xDE\x4F\xF7\xD4\x00\xD7\x2B\xD3\xE3\xA3\xA3\x04\xD4\x2A\xB9\x28\xF3\x88\xB7\x02\xC4\xB8\x0B\x14\xCE\xED\xD3\xE4\x9D\x80\x47\xD5\x9D\x91\x52\xD7\x14\xCB\xD5\x60\xCF\x07\xDA\x53\xEB\xC0\x45\xD7\x53\xD5\x9A\x52\xD5\x57\xD0\x55\xDA\x36\xFD\xD2\xF2\xA7\x4C\xD3\x3E\xDD\xC9\x5B\xD6\x52\xDB\x3C\xF8\xC5\x3C\xD4\x26\x80\x55\xDA\x99\x5C\xD6\x47\xDE\x55\xF5\xCD\x85\xD2\x05\xD9\x55\xD2\x04\x6B\xD6\xA3\xAD\x56\xD1\xD3\x00\x03\x5B\xD1\x38\xF1\xD5\x21\xD3\x5C\xD4\x56\xDC\x68\x77\xD5\x37\xD9\x57\xE7\xD5\xDF\xC5\x5A\xDB\x6A\xB5\xD5\x33\xB5\x60\xD2\x4F\xC3\xD6\x55\xD7\x09\xD0\x51\xC4\xD5\xAF\xCC\x95\xC5\x56\xD3\xD5\x84\xD5\x19\xD6\x58\xDB\xA2\x88\xD4\x97\xBA\x58\xC7\xC8\x7A\xD5\xE8\xCC\x57\xEB\xA4\x7E\xD4\x9E\xC8\xAC\x5B\xD6\x85\x65\x67\xD7\x3B\xEC\xD1\x12\xD4\xFB\xCF\x57\xE3\xD6\x66\xD5\x63\xDF\x43\xCF\xD6\x20\xA9\x68\xD2\x59\xC0\xD6\xAD\xD7\x57\xD1\x50\xC2\x68\xB2\xD5\x41\x09\x59\xC8\xCC\xA4\xD7\x01\x96\x5A\xC2\xCF\x42\xD6\x8E\xB1", + "\x51\xE4\xD4\x63\xD6\x68\xD1\xC5\x7D\xD6\x38\x93\x6F\xD9\x40\xCF\xC7\x38\xC9\x9B\x9C\x10\xD6\xD2\x92\xD3\x25\xD1\x5D\xD3\xD7\x94\xD1\xCF\xC0\x11\xDB\xBA\x4B\xCC\x38\xC9\x5D\xC1\xCD\xA2\x0B\xE3\xCA\x56\xD3\xD6\x57\xD1\x2E\x05\x51\x9F\x60\xCA\xD6\xB2\xAE\x5D\xC7\xD6\xE0\xD6\x47\xD2\x5E\xFC\x97\xE4\xD5\x65\xD9\x4F\xE7\xD7\x98\xD5\x7A\xD8\x57\xEB\xD7\x2B\x95\x7B\xDE\x5A\xC7\xD1\x57\xD5\xF8\xC6\x3C\xEB\xD6\xC7\xD6\xC4\xB4\x5F\xD7\xD4\x93\xA1\x79\xD5\x52\xFD\xC0\xF0\xD7\xDE\x9B\x5B\xD8\xCC\x05\x04\x72\xDB\x48\xBF\xD7\xFB\xD1\x44\xA2\x60\xF8\xD3\xEA\xCD\x81\xD3\x79\x87\xD8\x1F\x62\x82\xD8\x7C\x8C\xD8\x62\xD4\xF2\x9F\x60\xCA\xD3\xCC\xCE\x80\x8A\x55\xF4\xD6\x47\xC4\x86\xD4\x5C\xDA\xD8\xEE\xD5\x84\xDD\x3C\xFA\xD6\xF2\xD6\x60\xD2\x62\xE2\x92\x05\x07\x86\xD8\x51\xCA\xC6\xD6\xD3\x38\xD5\x5C\xF3\xD6\xAC\xD5\x88\xD3\x5E\xD2\x04\x2E\xDA\xC9\xCE\x31\xF9\xD7\x16\xD3\x7E\xD6\x5C\xCF\x72\x16\xD9\x44\xAB\x62\xE5\xD6\x25\xDB\x16\xD2\x61\xC6\xD5\x29\xDB\x62\xD3\x64\xFE\xD6\x45\xDA\x49\xD7\x62\xC4\x04\x14\xDA\x44\x01\x64\xD3\xA2\x4B", + "\xD9\x72\xDD\x64\xC4\xD8\x4F\xD8\x00\x01\x65\xCE\x04\x53\xDB\x07\x65\x65\xCB\x92\x39\xD8\xEE\xC2\x63\xE4\xCE\x74\xD5\x92\xD7\x20\xDF\xD9\x24\xDB\x7D\xD9\xD4\xA3\xCA\xA3\xCE\x53\xD5\x66\xE0\xD8\xE1\xD7\x8D\xDE\x10\x21\xD9\xA8\xD4\xC7\x6E\x79\x45\xD5\x5B\xDA\x42\x0D\x65\xF8\xD8\x2F\xD4\xE8\x76\xAD\x78\xD9\x66\xD8\x91\xD8\x53\xD6\xD5\xB0\xD7\x0A\xC7\x67\xF9\x70\x79\xDA\x41\x0B\x67\xF3\xD9\x7D\xDB\xC9\xC5\x68\xE1\xCF\x87\xDB\x77\xD0\x67\xEE\xD5\x8D\xDB\x8E\xDF\x68\xD6\xD0\x91\xD8\x7A\xD3\x69\xF8\xD5\xA6\xD7\xFF\xC1\x5C\xC4\xCF\x20\xA9\xA6\xD1\x5F\xDB\xDA\x82\xD5\xA7\xDB\x5C\xEC\xD9\x94\x62\xA8\xD6\x60\xC1\xDA\x4C\xDB\xA0\xDE\x58\xEB\xD3\x86\xDB\x65\xD8\x62\xE4\xDA\x8B\xD6\xA9\xDF\x50\xF0\xDA\x90\xDA\xAC\xD0\x65\xEC\xDA\x56\xDA\xAB\xDF\x5A\xF8\xDA\x98\xDA\xAE\xDA\x65\xFC\xDA\x60\xD9\xA5\xD9\x51\xF1\xD4\x5F\x89\x83\xD8\x64\xF4\xDA\x9C\xD6\xB1\xD0\x63\xFC\xD8\x21\xD2\xAA\xD3\x61\xC4\xDB\x69\xD9\x50\xDA\x4E\xC3\xD5\xA1\xDA\xB0\xD9\x68\xC9\xD8\xB5\xD4\x80\xD2\x66\xD2\x8E\xDA\xD8\xB5\xDE\x60\xCE\xDB\x12\xC8\xB2\xDF\xB5", + "\x40\xDA\xCC\xDA\xA0\xD6\x6D\xF9\xD4\x97\xD9\x8D\xCE\x18\xBB\xC8\x2A\xA9\x8F\xC4\x0C\xD5\xD2\xF4\xDA\x75\xD2\x34\xF3\xDB\xF6\xDA\x22\xD3\x34\xF5\xDB\x91\xD1\x75\xDD\x6F\xCA\xCD\x49\xCE\x3A\xC7\x2B\x05\xA2\xE8\xD9\x8D\xD1\x67\xE1\xA1\xB6\xD8\xF2\xBC\xC7\x45\xDC\xFD\xD6\x8D\xD8\x70\xE4\xDB\x8D\xCE\x46\xDB\x70\xC8\xDA\xE2\xD8\x95\xD2\x73\x89\xDC\x10\xDA\x91\xD3\x71\xD2\xDA\x06\xDE\x7A\xD7\x71\xD0\xDC\x76\xD0\x73\xDF\x06\xF2\xD2\x6F\xD9\xC7\xD3\x5F\xDF\xDC\xBE\xD8\x7E\xDD\x6E\xEB\xA4\x16\x04\xC3\xD0\x64\xFE\xD7\x28\xDF\xBA\xD4\x68\xC0\xDB\x21\xD1\xCB\xD4\x71\xE9\xDB\x07\x92\x88\xD7\x30\x98\xDC\x1C\xD8\x5A\xDE\xC6\x6E\xDC\x97\x73\xA2\xDA\x10\x3A\xDC\xEA\xDA\xB7\xD5\x67\xC4\xDC\x37\xDE\xC9\xDA\x62\xF1\xDC\x46\xDF\x67\xDC\x05\xC0\xD8\x1F\xDA\xD2\xDA\x64\xCC\xDD\xCA\xDB\xB7\xDB\x01\xE4\xDC\xFC\xD7\xCB\xDE\x70\xF4\xD3\x3C\xDF\x8B\xD5\x6E\xE2\xDC\xB1\xC0\xD6\xDF\x63\xC1\xDD\x30\xDF\xC3\xD9\x72\xEB\xD9\xE2\xD3\x24\xCA\x6C\xD1\xDD\x0D\xDF\xC1\xDC\x75\xE0\xDC\xCB\xD3\xC6\xDA\x69\xD2\xDD\x67\xD8\xD5\xD9\x61\xDE\xDD\x11\xDE", + "\xB9\xDF\x73\xC9\xDD\x6D\xDE\xC7\xD6\x76\xF2\xDC\xAF\xD8\xB6\xDC\x5D\xDB\xD7\x89\xD0\xE1\xDF\x0C\xFA\xDB\xF8\xDB\xBF\xD2\x70\xD0\xD7\xFE\xDB\x24\xD0\x70\xCC\xDE\x8F\xDC\xBF\xD0\x0D\xAC\x00\xA5\x65\x16\x02\xF1\x9A\x01\x03\xCE\x40\x0D\x80\x54\xDE\x1C\x6A\xE5\xD7\x14\xD8\xDE\x13\xCE\xCA\xD4\x73\xDD\xB4\x9C\xDC\xB2\x6E\x79\xD7\xD1\xA0\xDF\xCC\xC7\x5B\xE0\x78\xA5\xDD\x14\x77\x7A\xDE\xD4\xA9\xDF\x97\xC0\x56\xDB\x95\xAD\xDF\x23\x7F\x7A\xF8\xD5\xB1\xDC\x9A\xC3\x7B\xE3\x94\xB5\xDF\x25\x77\x7B\xC2\xD6\xB9\xDE\xA0\xCB\x7B\xFA\xB0\xBD\xDC\x5F\x8F\x7B\xCB\xD6\xC1\xDF\xB0\xCB\x7A\xD4\x79\xC5\xDF\x8C\x87\x7C\xC7\xC8\xC9\xDE\xB2\xCB\x7C\xCF\x88\xCD\xDD\x27\x9F\x7C\xC5\x66\xD1\xDF\xA9\xD9\x76\xDB\xA2\xD5\xDE\x96\x97\x7D\xC7\x90\xD9\xDF\xAD\xD2\x78\xC7\xB2\xDD\xDE\xA3\xAF\x7D\xF8\x90\xE1\xDF\x80\xD5\x30\xD2\x04\xE5\xDF\x4C\xB7\x7E\xCB\x92\xE9\xDD\xC6\xD0\x0B\xDB\xDE\x95\xDF\xE5\xD9\x79\xDF\xDD\xA8\xDB\xE4\x9D\x7E\xDC\xB9\xEF\xDC\xF2\x91\x7F\xFD\xDC\x29\xB4\xFD\xDD\x79\xF6\xDF\xA1\xDC\xDA\xD1\x63\xCB\xD2\xD4\xD5\xE4\xD9\x6F\xC6", + "\xDE\xD9\xC0\xE2\xD2\x0D\xD0\xDE\x8B\xDE\xE4\xD2\x5D\xCD\xDE\x13\xE2\x02\xEA\x78\xEC\xC3\x9F\xBD\x48\xCF\x5C\xD2\xE0\x09\xE1\x04\xEB\x80\xE8\xBA\x1A\xE1\xE6\xBC\x81\xD4\xE0\x1D\xE0\x06\xE3\x82\xD8\x8B\x4B\x01\x69\x6E\x08\x12\xBC\x8F\x02\xCC\x9D\x82\xE1\xA4\x06\x05\x23\x0A\x4B\x81\xB2\x12\x05\x0A\xEC\xA1\x6B\xE0\x47\xC7\x0B\xE4\x4F\xFA\xE0\x58\xA6\x42\x02\x83\xDC\xC8\x78\xDD\xC8\xD9\x7F\xE8\xB2\x36\xE0\xB2\x68\x83\xD7\xD1\x3C\xE3\x42\xD4\x10\x09\xE1\x11\xA7\x07\x6F\x83\xCA\xC8\x3A\xDB\xB1\xD0\x76\xCD\x60\x45\xE1\x14\x77\x84\xDE\xD4\x4C\xE1\x4B\xD5\x10\x19\xE1\x1C\xA2\x44\x0F\x84\xEF\x90\xF2\xDF\xC3\xCE\x10\x15\xE1\x8F\x73\x15\xE8\x57\xD9\xE1\x07\x8C\x17\xE5\x98\x5F\xE1\xE8\xBD\x18\xEB\x7E\xE3\xE1\x2A\xE0\x0B\xEE\x82\xC6\xA5\x6C\xE2\x1C\x92\x7E\xC2\xD7\x3A\xB0\x19\xE7\xC9\x66\xE1\x82\xD4\x1A\xE5\x98\x6A\xE1\x07\x91\x1D\xE0\x01\xF7\xE1\xA0\xDB\x52\xBA\x87\xFC\x85\x7C\xE3\x62\xDE\x87\xC7\x90\x80\xE0\x0E\x92\x88\xD9\x92\x4E\xDC\x26\x87\x88\xF3\x88\x89\xE3\x81\xCB\x88\xF8\x90\x8D\xE3\x22\x9F\x88\xDA\xDF\x07\xE3\x26", + "\xA3\x89\xDD\x92\x95\xE3\x1F\xE3\x87\xF0\xE0\x05\x07\x26\xE4\x88\xFE\xD1\x51\x97\x27\xEA\x65\xA1\xE2\x8C\xE3\x28\xED\x8E\xBE\xE0\x33\xE3\xA7\xD8\x8A\xDB\x95\xAA\xE2\xA3\xAC\x8A\xD8\xE2\xAE\xE1\x0F\xE1\x83\xF1\xE2\xD7\xD8\x1E\xE1\xD9\xB5\xE2\x33\xB7\x2D\xEB\x48\x97\xE2\xC3\xE0\x1D\xEC\x8B\xEC\xDB\xA3\xDD\x0E\x70\x8C\xDC\xB9\xC2\xE0\xF2\x94\x8C\xCE\xE3\xC6\xE0\x10\xE1\x85\xCF\xDB\x2B\xDE\x32\xE1\x87\xF9\xE0\xB9\xE2\x5E\xAE\x10\x26\xE2\xEA\xDD\xF5\xCB\x81\xDF\xE0\x10\xE2\x09\xE0\x8E\xE7\xE0\x1E\xE3\x05\xE4\x11\xE4\xE3\xE2\xE2\x39\xE8\x12\xCE\xE0\x22\xC5\xC0\xDA\x1B\x07\xCD\xE3\xE1\x3C\xEA\x8E\xCC\xCD\xF7\xDB\x03\xE0\x22\x0E\xCD\xE8\xE3\x39\xE2\x8F\xCE\xDE\xE5\xE0\x3F\xE9\x8E\xC5\x74\xC2\xC3\xEF\xA8\x10\x05\xA2\x7E\xD8\xBC\xD9\xAF\x42\xE4\x02\x04\x41\xE1\x9B\x88\xE4\x9C\x7E\x4B\xC5\x83\x4E\xE4\x0A\xE6\xD4\xA6\x90\xCF\xE4\x0C\xE7\x41\xE3\x91\xD1\xE4\x03\xE6\x43\xE9\xC5\xB6\x79\x39\x73\x09\x05\x9A\x4D\x01\x66\xB9\x03\x6E\x91\xDC\x68\x20\xE6\x83\xB1\x27\xDB\xDF\x7B\x9F\x48\xE8\xAC\x65\xE4\x15\xBA\x01\xE0\x6D\xDD\xB4", + "\x2A\xE5\x14\x7C\x92\xDC\xB8\x81\xDE\x2F\xEB\xD4\xB1\xE4\x8F\x73\x4C\xE3\xE2\xB3\xDC\xE3\xDE\x0C\xB8\x93\xD7\x72\x3A\xE6\x8A\xB8\x8C\xFD\xE4\xFB\xB7\x4F\xEC\x17\x81\xE5\x31\xBA\x2C\xEA\xD0\x84\x04\x46\xE7\x8C\x88\x94\xF8\xB8\x4A\xE4\x34\x8D\x94\xDD\x92\x4F\xE4\x27\xEF\x92\xDD\xE4\x1F\xE6\x99\xBD\x3A\xE2\xE4\x59\xE6\x49\xEE\x68\xC9\xE3\x98\x83\x54\xEA\x65\x95\xE5\xA7\xE3\x52\xE0\x00\x22\xE5\x8E\xA8\x59\xED\x8D\xF1\xD4\x5C\xE4\x49\xEA\x95\xF4\xCA\x0E\x04\x5A\xE3\xD3\xAA\xE5\x6E\xE1\xF5\xCF\xDF\x56\xDD\x00\xE1\x5E\xB8\x97\xC1\xE1\xAD\xCF\x5E\xE3\x8D\xF8\xDF\x28\xE4\x5F\xEB\xBE\xBE\xE5\x84\xE5\x9D\xD5\x98\xD1\xE2\x6B\xE4\xD8\xD7\x98\xDC\x63\x8B\xE7\xF4\xD0\x29\x0D\xE6\x51\xE6\x8C\x00\x99\xFD\xE2\x85\xE1\x6E\x03\x99\xC3\xE5\x36\xE6\x65\xE6\x98\xDB\xE6\x88\xE5\x5D\xE1\x53\xD7\xE6\x3C\xE5\x66\xEF\xB4\xAF\xDB\xFB\xDB\x3E\xE5\x81\xFD\xE3\xA7\xE7\x3F\xE9\x9A\xFA\xE3\xF3\xE2\x76\xDE\x8E\xEC\xE6\xFE\xE0\x6C\xEB\x9A\xEB\xE3\x0C\xE0\x3C\xED\x9A\xC3\xDE\xAF\xE4\x6D\xE9\x9B\xF4\xE3\xFE\xC1\x08\xE9\x0C\xCC\xE0\xE2\xC3\x6E\xEE", + "\x9A\xE1\xE3\xB2\xE5\x09\xE5\x9C\xE4\xE0\xC8\xE6\x05\xE1\x9B\xFA\xE6\xC4\xE4\x73\xE9\x8F\xCE\xE7\xA6\xE6\x71\xE0\x9D\xF7\xE6\x86\xD1\xF4\x8E\x90\xCE\x97\xBF\xE6\x70\xE8\x9B\xCD\xE7\xBC\xE4\x70\xEE\x9B\xD7\xC3\xDE\xE4\x22\xD7\x78\xE1\xE7\x08\xE1\x72\xE8\x9A\xFD\x05\xB6\xE7\x72\xED\x9D\xDA\xE7\x85\xDC\x7B\xE3\x9E\xE0\xE0\xE2\xE5\x03\xE4\x9E\xE5\xE6\xD4\xE7\x7B\xEC\x9D\xC3\xE7\xCF\xE7\x7A\xE7\x9F\xDB\xE7\xF9\xE4\x7E\xE1\x9D\xE6\xE7\xAA\xE6\x74\xEA\x9F\xFD\xE7\xFC\xE7\x7F\xEA\x9C\xF3\xE6\x03\xEA\xD1\xCF\x9D\xF1\xC3\xFB\xE5\x7B\xED\xA0\xF6\xE7\xF7\xE3\x82\xE1\x11\xC4\xE8\x0E\xE8\x85\xE0\xA1\xC6\xE8\xBE\xD0\x02\x8D\x80\x76\xC9\x33\x8B\x2E\x0E\x55\xBA\x02\xF7\xDD\xDE\xDA\x33\xF5\xE7\xF2\xE6\x7B\xE5\xA2\xCF\xE8\x27\xEA\x85\xE9\xA2\xD8\xE8\x01\xE8\x80\xE7\x9C\xC7\xE8\x02\xEA\x7F\xED\xC5\xB1\xE7\xC1\xE4\x8A\xE5\xA3\xEA\xE8\x37\xE8\x8B\xE7\xCF\x9F\xE3\x24\xE9\x8E\xED\xA3\xD2\xE8\xD8\xD7\xC0\xD8\x3C\x98\x82\x1C\xE9\x27\x9E\xA1\xFC\xAF\x20\xE9\x01\xE5\x4D\xF5\xE3\xED\xE2\x8D\xE0\xA4\xDB\xBD\x4E\xE8\x8D\xEF\xA4\xE2\xBD\x3F", + "\xEA\x94\xE6\xA5\xE5\xE7\x30\xE9\x6D\x09\x9E\xC8\xE8\x32\xEA\x7A\xED\xA5\xDC\xE9\x05\xEA\xFD\xCD\xA4\xF8\xE8\x53\xE8\xD9\xB5\xA5\xD8\xE9\xE7\xE6\x46\xAD\x98\x45\xD5\x70\xD2\x96\x9E\x44\xC7\x8C\x74\xD2\x60\xE9\x9D\xD1\xE9\x68\xE9\x8B\xE9\xA5\xF7\xE9\x69\xE8\x9E\xE6\xA7\xF9\xE9\x7C\xEB\x9E\xEE\xA7\xEF\xE8\x7D\xE8\xA0\xEF\x8E\xE5\xE9\x66\xBC\x99\xE7\xA5\xF4\xE7\x5E\xEB\x71\xAC\xA3\xC9\xEA\x15\xEA\x8E\xE3\x9D\xCC\xEA\x17\xEA\x95\x08\x74\xD3\xD4\x1C\x68\x4B\xD6\xBE\x80\x00\xF1\xD3\xC1\x83\x52\xDE\xDA\x94\xE6\xA3\xE9\xA0\xE7\xE9\x88\xE8\x98\xED\xA8\xE0\xEA\x89\xDC\xA4\xEB\xA2\xE4\xEA\xF6\xE2\xA7\xEF\xA5\xF1\xE8\x61\xEB\x14\xB7\xA8\xE5\xEA\xA2\xE9\xA4\xE6\xAA\xFE\xE8\xA6\xE8\x3E\xEA\xAA\xED\xEA\xB1\xEB\xA9\xE3\xAB\xC4\xEA\x80\x89\xB2\xD4\x08\x9B\xE8\xA5\x67\x91\xED\xC4\x84\x04\x49\xEA\xEA\xD2\xB1\x7F\x77\xDD\xA9\xA8\xEC\xAA\xE3\xEA\xBB\xEB\xAB\xE9\xAA\xE8\xEA\x63\xEB\xAD\xEC\xAC\xF9\xEA\xB4\xE8\xB5\xEC\xAB\xD9\xC4\xD2\xEA\xAC\xE6\xAD\xCE\xEB\xD1\xE8\xB4\xEB\xA8\xDB\xEB\x75\xEA\xA0\xE2\xAE\xCF\xEA\xE0\xEA\xB2\xEE\xA2", + "\xE4\xEB\xE8\xE7\xB5\xE3\xA2\xCD\xEB\xE1\xE8\xBA\xE7\xAE\xC7\xB7\xDF\xEB\xB2\xEA\xAD\xF2\xEB\xBA\xE9\xB9\xE0\xAB\xF4\xEB\xD5\xE8\xBE\xEA\xAE\xFC\xCC\xDE\xEA\x08\xE9\xAD\xF5\xEB\xFA\xE8\xB7\xE1\xAF\xEF\xEB\xAB\xEA\x96\xEB\xAF\xFE\xCC\xF3\xE7\xBD\xE4\xB0\xF8\xEA\x52\x8F\xC1\xE7\x5D\xD0\xE9\x86\xE9\xBB\xEF\xA9\xC2\x68\x1F\x61\x6E\xDC\x3B\xE5\xCF\xC6\xD3\xE2\xC7\x76\xFE\x5E\x97\xEA\xC5\xEC\x17\xAF\xCF\x0E\x05\xFC\xC8\x7C\xB6\xCE\x9C\xE8\x66\xE5\x99\xE3\xE6\xF3\x7E\xB2\xAE\x97\xC3\xEC\x7A\xEB\xB8\xE3\xB1\xF6\xEB\xCF\xE8\xBB\xE6\xAE\xED\xEC\xEE\xE8\xCD\xEF\xB2\xC1\xEC\x12\xED\xC1\xE6\xB3\xC8\x04\x5B\xE8\xCE\xE3\xB3\xC1\xEA\x35\xEC\xD0\xE7\xB3\xF5\x06\xB6\xE9\xBF\xE3\xA7\xD1\xEC\x3F\xEF\x9F\xE1\xB4\xCA\xED\x43\xEF\xCE\xEC\xB0\xCB\xEC\xD3\xEA\xCF\xEA\xB0\xCE\xED\x51\xEC\xD4\xE3\xAF\xD6\xED\x00\xEC\xD6\xE9\xAF\xD8\xED\x3D\xEE\xD6\xEE\xB0\xCC\xE9\x2C\xEF\x78\x9F\xB5\xEC\xE3\x61\xEC\xD3\xEA\xB3\xC2\xED\x20\xAB\x05\xCE\xB1\xCF\xCF\x57\xD2\xC8\xE1\x91\xA4\xEC\x41\xC6\x2C\xCB\xB6\xC8\xCF\xD0\xCF\xE4\xCB\xB1\xE1\xD3\x9D\xE0", + "\x25\x6A\xB6\xD1\xD6\xA6\xCC\xC6\xEA\x84\xC0\x00\x70\xED\x59\xE2\xA0\x7B\xED\xD7\xCD\xE4\xC5\xB7\xCA\xCF\x77\xEC\x4C\xD0\x76\xE5\xED\x2E\xEF\xD9\xE6\xB6\xCF\xED\x54\xEF\xD5\xE1\xB9\xD9\xED\x93\xEF\xD6\xE5\xB9\xE3\xED\x09\xED\xCC\xE9\x16\x1D\xED\x97\xEE\xC0\xEE\xAF\xC6\xED\xFD\x9A\xE7\xE7\xB4\xFF\xEB\x96\xEC\xDA\xE0\xB9\xE6\xEE\xE1\xCF\xB7\xB3\xB7\xD9\xCF\x7E\xED\x48\xD7\x3E\xE0\xDC\xB6\x63\xDD\xD8\x39\xE4\xCF\x87\xEC\x3D\xD1\xB8\xC9\xE6\x43\xE1\xEC\xE3\x62\xEE\xD9\x86\xED\xDB\xE6\xB7\xC0\xDE\xBF\xD8\x51\xEB\x92\xAA\xEE\x7C\xEF\xC5\xE5\xBB\xD9\xEC\xAF\xED\xE2\xE7\x92\xF9\xED\x9A\xEE\xD4\xED\xBC\xDE\xED\xA2\xEC\x78\xE6\xA2\xE5\xEE\x8F\xED\xD5\xED\xB9\xF9\xEC\xA7\xED\xF5\xE2\xB9\xE8\xEE\x00\x04\xE7\xEC\xBD\xD4\xEE\xDF\xEC\xF5\xED\xB8\xD9\xEF\x3B\xEB\xE7\xE2\xB3\xD3\xED\xE1\xEC\xE6\xE3\xBD\xEC\x61\xB5\x9F\xEA\xEE\x3E\xED\xEE\x5A\xE2\xA8\x10\xBB\xD2\xA2\xEE\xEF\x4C\xB0\xB2\xCA\x04\x6E\xEF\x24\xA7\xBB\xDE\xE6\x60\xDE\x1E\x62\xBB\xFB\xCE\x1F\xEC\xFC\xE5\x3B\xF0\xDD\x1D\xD8\x08\xA0\x75\xED\xCF\xF6\xEE\x00\xF0\x3C\xC4", + "\xF0\xA7\xB1\xB2\xED\x5C\xD4\xE4\x17\xE4\xAE\xA0\x9A\xF5\xE4\x27\xEF\x9E\x75\x67\xCC\xEE\x4B\xEF\xF8\xE6\xBD\xE9\xEF\xD1\xEC\x83\xE8\xB4\xE8\xEF\xDA\xEC\xF8\xE1\xC2\xE2\xEF\x19\xF1\x09\xFB\xE7\x89\xED\x1A\xF3\xF6\xE3\xC2\xEA\xEF\x28\xE9\xD1\xE7\xBE\xCF\xEF\xD7\xEC\x0A\xF6\xC2\xCE\xEE\x29\xF2\x08\xF5\xC3\xE4\xF0\x4D\xEC\x07\xF8\xBD\xDB\xF0\x2B\xF1\x07\xF3\xA1\xE4\xEE\x2C\xF3\x07\xF0\xC3\xDF\xEF\xDE\xED\x0F\xFB\xC3\xEA\xF0\x37\xF1\x10\xF4\x28\x8A\xF1\xA0\xEE\x07\xF0\xC4\xFE\xF0\x9E\x86\xAF\xEB\xBB\xF3\xEE\xBD\xEE\x47\xD9\xBF\xDF\x60\xFB\xED\x1D\xD2\xC5\xF5\xEF\x5C\xBB\xFD\xE6\x10\x17\xF1\x12\x05\x16\xF2\xA7\xC5\xD6\x7F\xD9\xF1\xE1\xC0\xC7\xEF\x7F\xEE\x18\xFF\x97\xE2\xE8\xB9\xEF\xB9\xD6\xC6\xEC\xED\x56\xF3\xEF\xED\x74\xC3\xDF\xD9\xDA\xD8\xDE\x3C\xF4\xED\xBE\xEC\xE2\xE0\xBC\xE2\xDE\xC2\xEC\x13\xFF\xC2\xDD\xEB\x7F\xF0\x06\xF9\xC3\xC6\xF1\x32\xF3\x20\xF9\xC4\xD0\xF1\x10\xEF\x13\xF7\xC4\xE7\x86\x88\xF0\x95\xE1\xC8\xE6\xEF\xB9\xEA\x0B\xF0\xB3\xC0\xF2\x93\xF2\x20\xF4\xC3\xF3\xF0\x2B\xC3\xB3\x7C\xC5\xC8\xCC\x5E\xF1\x41", + "\x00\xC6\xFF\xCD\xF3\xEE\x34\xEB\xC9\xC8\xD8\x15\xC9\x1E\xF6\xBB\xCC\xF0\x64\xF0\x14\xE3\xCA\xDF\x60\x9D\xF0\x41\x0F\xC9\xEB\xCE\xCA\xEF\x57\xED\xC7\xC1\x62\x9A\xF3\x1B\xF8\xC7\xF1\xF1\x7A\xF3\x1C\xFE\x98\xFE\xD2\xB5\xF1\xE1\xE6\x38\xCA\xF0\xD2\xCC\x2A\xF9\xD7\x96\xF2\xE4\xEC\x26\xFC\xC3\xC7\xF2\x8B\xF0\x0E\xF7\xC9\xC6\xF2\xC6\xF0\x12\xFD\xCC\xF6\xF0\xCF\xF2\x32\xF5\xCC\xE7\xF0\x20\xF0\x32\xF5\xC8\xCB\xF3\xD8\xF3\x34\xF9\xCD\xF1\xA7\xC4\xF3\x31\xF1\xCD\xFE\xF1\x95\xF1\xA5\x6E\x3B\xAB\xF2\xAD\xC6\x29\xF8\xBC\xF2\xEF\xB1\xF2\x44\xEB\x40\xA4\xF3\xCC\xC4\xD7\xC2\xC7\xD5\xDD\x47\xDF\x0B\x7C\xCE\xE2\xC8\x8B\xD7\x2B\xFA\xB1\xFB\xF1\x2E\xE5\x35\xE8\xBD\x73\xF3\xD1\xC4\x30\xFD\x3D\xC2\xF3\xEF\xD6\x3C\xF6\xCB\xEC\xEE\x68\xF2\xEB\xE8\xCE\xF8\xF3\x4B\xEA\x3E\xF9\xCC\xE0\xF3\xCE\xEC\x25\xFD\xD0\xDD\xF3\xCE\xF0\x33\xF2\xD1\xDB\xF3\x11\xF4\x45\xF0\xCD\xD3\xF4\xDA\xF2\xD8\x7C\xD0\xD0\xEF\x0B\xF5\x23\xF6\xA6\xF2\xBA\xD7\xF1\x46\xFE\xCD\xD8\xF4\x23\xF6\x45\xF2\xCD\xE5\xF4\x58\xD6\xB0\xDD\x80\x70\xF1\x78\xD6\x3D\xF9\xBC\xC8\xF4", + "\x84\xA1\x45\x9C\xCF\xE9\xC5\x05\xF5\xFC\xE0\xB8\xC0\xF4\x26\xD8\x7F\x93\xD3\xE5\xF2\xB8\xF3\x29\xF9\xCE\xD2\xE1\x6D\xF2\x4E\xF3\xD0\xEF\xEF\x35\xF7\x00\xFF\xD3\xD4\xE3\x60\xE5\x1C\x6C\x7F\x7B\xF4\x43\xC6\x3F\xF2\x3F\xF8\xF4\x5B\xD2\x03\xFD\x25\x99\xE4\x15\xE4\x04\xFE\xE8\x94\xF5\x4B\xBB\x04\xF1\xBC\xE2\xE6\x16\xF1\x67\xE9\x97\xF9\xD3\x10\xF7\x45\xF6\xD2\xDB\xF4\x31\xF1\x35\xFF\xCD\xDE\xF4\x85\xEA\x22\xF1\xD2\xE8\xF4\x6C\xF5\x45\xFA\xD1\xE8\xF5\xFA\xC0\x9D\xEB\xD6\xEE\xF5\x6D\xF4\x2A\xE1\xD6\xE7\xF4\x74\xF5\x5E\xF2\xD6\xE2\xF4\x7A\xF4\x5E\xFB\xD7\xF5\xF5\x7E\xF5\x60\xF4\xD6\xFA\xF0\x73\xF7\x5F\xFD\xD7\xC3\xF6\x84\xF2\x59\xF4\xD2\xFA\xF5\x45\xF2\x35\xFA\xD8\xE3\xF5\x70\xF4\xB6\xE2\xA6\xF7\xF5\x88\xF6\x63\xF3\xC4\xC9\xF6\x97\xF5\x0A\xDC\x94\xA4\xD3\x08\xF1\x17\xFE\xD4\xE3\xEC\xA1\xF3\x37\xAC\xD4\xED\xF2\xA5\x1B\x3B\xF2\xBB\xFE\xE5\x92\x06\x1C\xA3\xDA\xDF\xF6\x6F\xEC\x54\xF0\x0B\xD4\xF6\x91\xF7\xBA\xE1\xCE\xE3\xEE\x4D\xF3\x0F\xF5\xDB\xC1\xE9\x72\xF7\x63\xFC\xD7\xCC\xF2\x1D\xF5\x6F\xF5\xD8\xC2\xF6\xB1\xF4\xBF\xE0", + "\xD2\xFA\xF6\x80\xF5\x65\xF7\xD6\xFE\xF6\xC4\xF7\x61\xF1\x88\x52\xC7\xAB\xF5\x51\xFB\xC0\xC7\xF5\x0D\xE4\x73\xCD\xDC\xE6\xF3\x69\xF2\x6B\xF8\x65\xD2\xF7\x43\xF5\x02\xFE\xDC\xC1\xF3\xD0\xF4\x1B\xF1\x98\xCC\xBE\xEA\xF3\x03\xFD\xA1\x8B\x68\x5A\xF4\x1F\xFC\xD5\xC0\xF7\xC8\xF5\x66\xF7\xDC\xFF\xF6\xC6\xF7\x62\xF6\xD8\xEF\xF7\xE8\xF4\x7B\xF1\xDC\xC8\xEC\xEB\xED\x7C\xED\xD8\xEB\xF7\xC9\xF4\x7C\xFD\xDE\xD6\xF4\x92\xF3\x43\xF0\xC9\xFE\xF7\xB4\xF7\x23\xF1\xE0\xF3\xF6\xD2\xED\x6E\xFA\xDE\xEE\xF7\xF1\xF5\x7E\xF9\xE0\xC7\xF8\x90\xF5\x7A\xFE\xD0\xDC\xF4\x85\xF7\x7D\xF8\xE0\xFB\xF7\xBB\xF7\x82\xFF\xE0\xC4\x97\x14\xF9\x71\xF3\xDF\xCF\xEC\x8E\xF0\x23\x7B\xEB\x93\xF7\x3D\xF7\x39\xF7\xD3\xDD\xF7\x56\xF6\xAE\xBA\xD2\xF4\xEE\xD4\xF6\x41\xF3\xE2\xF0\xF4\x8A\xED\x50\xF0\xF4\xB6\xF1\x7B\x9C\x4B\xF2\x58\xEE\xF4\x07\xF6\x2E\xF1\x99\xF1\x6D\x26\xF8\x8C\xF3\x79\xB2\xF8\xF5\xF2\x69\xF3\xC5\xE8\xF6\x2E\xBC\x67\xF8\x09\xBC\xF8\xEE\xF1\x2E\xF0\xCF\xDE\xF5\xBD\x67\x87\xF9\xDD\xDE\xF6\xDB\xF7\x3F\xF4\xE2\xF1\xDD\x38\xBE\x8E\xF8\xCA\x84\xF9\x66", + "\xCE\x8F\xF5\xB2\xE1\xE6\x15\xF2\x85\xF0\xDB\xCE\xF8\x5B\xFA\x7C\xFC\xE5\xFF\xF7\x10\xFA\x82\xF9\xE1\xCA\xF7\x5F\xFB\xA8\x8B\xE1\xE0\xED\x60\xF9\x59\xFC\xE0\xCA\xEA\x69\xF8\x61\xF2\xE6\xE7\xF9\x64\xEE\x38\xF1\xC6\xE7\xF8\x55\xF1\x4B\xF6\xE5\xF1\xED\xA0\xF2\x94\xFB\xD2\xF7\xF2\x76\xFA\x91\xF7\xDA\xF1\xF3\x79\xFA\x90\xF0\x3B\xC4\xF4\x29\xFA\x4D\xFA\xC6\xC0\xF9\x81\xFB\x01\xF3\xE4\xFC\xF9\x33\xFB\x9D\xF2\xB8\xCC\x72\x6A\xF0\x00\xF4\xE5\xFC\xCD\x8E\xF8\xEE\xEF\xDD\xD2\x06\x91\xF9\x67\xFC\xC9\xEC\xF6\xFA\xEE\x75\xFE\x38\xF3\xF9\x7A\xF8\x8A\xF1\xE2\xD5\xF7\x4F\xFB\xFA\xAD\xE5\xEF\xF9\x65\xF9\x81\xF2\xC4\xD7\xF8\x6E\xFB\x9A\xFA\xE1\xE9\xFA\x4E\xF3\x6D\xF9\xC8\xF3\xE8\xB0\xFA\x6D\xF2\xE0\xEA\xFA\xFF\xE9\x7F\xF1\xE6\xEE\xFA\x64\xFA\x97\xFE\xEB\xE8\xFA\xBF\xF9\x6F\x6F\xFE\x61\xFA\x75\xF9\xA3\xFE\xE7\xFF\xF8\x3F\x72\x43\x03\xEC\xC2\xFA\x77\xF0\xA1\xF3\xEA\xEA\xF8\x87\xF8\xA0\xFA\x10\x0B\xFB\x8A\xFB\xA0\xF4\xD4\xC5\xFA\x46\xF4\x8B\xFB\xBC\xD7\xE5\x81\x60\xB5\xFB\x76\xDA\xFA\xA4\xF1\x53\xFD\xE4\xCF\xF5\xA5\xFA\xCF\xD3\xED", + "\xF4\xF9\xBF\xF3\xB8\xF0\xDA\xE5\xFB\xA9\xF1\x9A\x58\xEE\xDA\xCE\x9C\xF8\x16\xFE\xE9\xD2\xDC\xCA\xFB\xBB\xFD\xB7\xEA\xFB\xAD\xF4\xBB\xF3\xCC\xED\xF9\x98\xF4\xAB\xFD\xEF\xE7\xFA\xBC\xFA\x7E\xF0\xE7\xD9\xEE\xFE\xFA\x65\xF5\xF0\xF8\xF7\x01\xFE\x84\xFD\xE0\xC1\xFB\x07\xFF\x84\xF3\xF0\xF0\xE7\xB5\xF8\x6E\xFB\xEA\xC0\xFC\x0D\xFF\xC2\xF4\x89\x79\x7C\xC4\xF9\xBA\xF8\xED\xCF\xF7\xDA\xFB\x42\xE8\xF3\x76\xFB\xC6\xEF\xC6\xFC\xDD\xDD\xFC\x96\xD9\x52\xFC\x88\x58\xFC\xCC\xF9\x8C\xFC\xE8\xFD\xF8\xC7\xFB\x95\xF4\xC1\xF3\xE2\xC3\xD4\xCA\xF5\xED\xCD\xFB\xD7\xFB\xB3\xF6\xE8\xF3\xFB\x7A\xDF\xC7\xF9\xF1\xF0\xFB\xF8\xF9\xA7\xFA\xEF\xC1\xF4\x0E\x06\xCC\xFF\xED\xCB\xFA\xCE\xF9\x9F\xFE\xD3\xE4\xFC\x40\xF7\xA5\xFF\xEE\x7B\xFC\xF7\xFA\xC8\xFE\xE4\xC8\xFD\x48\xF7\x2C\xF1\xF1\xF3\xFA\xB7\xF9\xAC\xF5\xF5\xF6\xFA\x04\xFA\xD5\xF9\xF5\xD8\xFD\x00\xFA\x46\x83\xE6\xC2\xFC\x53\xFD\x87\xF4\xAF\xFA\xFA\x6A\xF9\xC5\xF5\xE1\xDF\xFD\x5A\xFA\x9C\xF1\xB2\xE0\xFC\x67\xF2\xD3\xF4\xEE\xD0\xFD\xD1\xF4\xFE\xEC\xF6\xD3\xFA\x88\xCD\xA5\xFC\xBF\xEE\xF8\x5F\xF3", + "\xDC\xFB\xF2\xC5\xF9\x47\xFE\x8D\xFD\xA9\xC2\xD4\x72\xFC\xD3\xF1\xF2\xF6\xFC\xD9\xFA\xDF\xF6\xB2\xF0\xFC\xE3\xA1\xEA\xC0\xE2\xC6\xFD\x22\xF9\xB4\xF8\xE4\xDC\x6C\x8A\xFF\x92\xFB\xE9\xFD\xFC\xF2\xFB\xCF\xF9\xD3\xC1\xFE\x29\xFF\x8E\xFB\xF7\xD5\xF9\x2D\xFE\x55\xEA\xD0\xCC\xFC\x14\xFD\xE8\xFC\xEF\xC6\xFC\xA2\xFF\x80\xFD\xF5\xDA\xFD\xA7\xFE\xC5\x7A\xF0\xE7\xFD\x0F\xFE\x81\xF6\xF6\xF5\xF5\x64\xFD\xAB\xFF\xFA\xFD\xFA\xC0\xF9\xED\xF1\xF0\xD6\xF8\x92\x04\x04\x0A\xF7\xC5\xFD\xC6\xF9\xDF\xF7\xE4\xDC\x63\xB9\xFF\xEE\xF5\xF3\xCC\xFE\xA4\xF8\xDC\xFE\xDD\xCC\xEF\x1C\x6E\xEE\xF2\xF8\xED\xFD\x84\xFC\xC7\xF6\xF8\xD8\xF9\x88\xFC\x88\xAA\xFC\xD9\xFE\x53\xFB\xE6\xF4\xE9\xDD\xFE\x8F\xF8\x8E\xF4\x10\x13\xFF\x33\xFE\xCA\xFC\xFB\xEC\xFC\xBE\xFF\x9F\xFF\xF8\xC1\xFF\xCB\xFC\xDD\xFC\x39\xF6\xFD\x5F\xF7\xE5\xF2\xC6\x02\xFF\xDA\xF6\xDB\xFB\xEE\xC6\xFF\x42\xE3\x77\xF2\xD5\xE0\xF7\x58\xF7\x55\xF9\x90\xD0\xE4\xF8\xFD\x55\xF3\xDE\xEF\x64\xE5\xF5\x3E\xF6\xF2\xE9\xFF\x5B\x69\xFE\x7D\x42\x7F\xFF\x73\xC6\x7B\xF7\x66\xFE\x3B\x7D\xB3\x7E\xB0\x7C\xE8", + "\x7B\xF4\x78\xF0\x69\x00\xA9\xFD\x07\x80\x65\x7F\xD2\x7E\xD7\x7D\xF5\x73\xF1\x6C\x00\x8E\xFC\x0B\x79\xB1\x7F\x7F\x7E\x05\x86\xE2\x77\xFB\x68\xFB\x5E\x00\x94\x80\x6A\x7A\xDB\x7E\x03\x87\x03\x81\xF6\x7F\xE8\x5B\xFD\x12\x7E\x21\x81\x84\x7C\x09\x83\x01\x80\x01\x92\xFD\x63\x84\x2B\x80\x22\x80\x09\x80\xEA\x78\x01\x82\x19\x02\x5E\x4B\xFE\x3D\x7F\x8D\x7F\xD0\x78\xFE\x54\xFD\x7C\xE4\x6E\xFF\x79\xFB\x70\x7F\xAD\x67\xF9\x7F\x5D\x77\x82\x7B\x01\x8C\xFD\x65\x00\xE9\x7A\xB2\x7C\xB1\x7C\x02\x82\x06\x8C\xF5\x6B\x02\x85\x01\xAC\x57\x30\x81\x0E\x80\x08\x81\x09\x84\x02\x59\x00\xA4\xFE\x4F\x80\xB4\x7E\x29\x83\x11\x81\xAE\x75\x01\x8D\x01\x9A\x00\xDE\x80\x57\x80\x30\x81\x03\x84\x09\x88\x02\x94\x02\xA6\x81\x2B\x7F\xAF\x7C\x16\x80\xAE\x7E\x0C\x82\x5C\x53\x02\x97\xFD\x65\x80\x6F\x80\xAA\x7C\x23\x39\x89\x13\xC5\x72\xF4\x56\xFF\x75\x7E\xD8\x7E\x85\x6E\x43\x04\x0E\x87\x03\x80\xFF\x79\x00\x96\x7F\x51\x7B\xB5\x03\xFE\x7B\x19\x3B\xB2\x78\x02\x8A\x00\xB1\x80\x86\x81\x07\x83\x1A\x81\x0E\x8A\x04\x91\x00\x89\x02\xDF\x7E\x68\x81\x2C\x83\x08\x86", + "\x0D\x87\x02\x83\x28\x54\x02\xA9\x7F\x70\x81\x4A\x81\x23\x86\x05\x8F\x08\x97\x04\x8E\x01\xE2\x80\x17\x80\x35\x83\x0C\x86\x11\x80\x0A\x9C\x00\x89\x00\x91\x81\x87\x80\x2D\x82\x28\x85\x09\x83\xB9\x76\x02\xA3\x01\x9D\x81\x5B\x80\xC9\x7B\x1F\x7A\x32\x0B\x11\x35\x03\xA0\xFB\x2C\x79\xF1\x7C\x50\x7C\xFC\x7C\x16\x8C\x03\x93\xFC\x7E\x00\xBE\x7E\x40\x81\xF5\x56\x10\x84\x06\x35\x08\x85\x05\x86\x01\xAB\x81\x99\x80\x4C\x82\x1C\x82\x19\x8B\x09\x9F\x02\x8B\x02\x9A\x81\x24\x40\x54\x82\x22\x83\x14\x8C\x09\x86\x06\x9C\xF3\x30\x81\xC8\x81\x65\x83\x27\x87\x19\x8C\x0C\x86\x01\x9D\x03\xC8\x80\x8C\x80\x6F\x83\x36\x84\x1A\x8E\x0C\x84\x07\xA1\x01\x93\x80\xB1\x80\xD9\x7B\x37\x84\x0B\x89\xEB\x71\x02\x93\x02\xE9\x81\xC2\x7A\x68\x80\x66\x42\x74\x3D\x07\x9C\xFB\x7F\x01\xBB\x81\x39\x39\x7A\x80\xE7\x79\xFC\x78\xEC\x6F\xFC\x43\x03\xF6\x30\xC5\x80\x6E\x83\x38\x84\x15\x85\x0D\x82\x08\xA4\x02\x86\x82\x05\x82\x73\x83\x2B\x86\x1A\x8D\xBD\x6E\x07\xA4\x01\xDA\x81\xAD\x80\x87\x80\x36\x80\x11\x8C\x10\x89\x05\x91\xEB\x01\x82\x0A\x83\x50\x80\x45\x80\x21", + "\x85\x0E\x84\x08\x9D\x04\xC9\x81\x03\x82\x90\x83\x41\x80\x9B\x42\x11\x95\x08\x93\x03\x9E\x82\xE5\x76\x93\x81\x49\x84\x23\x87\x0E\x99\x08\xA6\x02\x8F\x82\xCD\x81\x96\x80\x4A\x83\x21\x8C\x12\x94\x09\xAE\x04\xC7\x81\xF9\x7A\x69\x83\x4A\x87\x26\x89\x06\x99\xEF\x6E\x02\x9A\x82\xAA\x81\x8D\x80\x4F\x82\x12\x89\xF1\x2D\xC0\x2A\x00\x25\x33\x51\x00\x89\x5F\x14\x02\xE6\x42\x05\x14\x9C\x62\xE9\x73\x7F\x30\x82\x71\x83\x48\x83\x26\x80\x14\x8F\x07\x99\x03\xB1\x82\x36\x82\xAA\x83\x4B\x87\xB9\x4B\x13\x9A\x0A\xB8\x04\xC1\x82\x01\x7F\x9F\x83\x56\x82\x25\x8E\x09\x93\x0A\xA8\x00\x98\x82\x5E\x83\x9E\x80\x58\x86\x2A\x82\x14\x89\x0B\x84\x05\x93\x82\x6B\x83\xA8\x80\x38\x81\x57\x7A\x13\x85\x0B\x89\x04\xEE\x82\xEF\x7A\xB1\x83\x57\x84\x2D\x81\x17\x90\x0B\xBC\x05\xFF\x82\x93\x74\xD5\x6A\xC6\x7D\xF9\x73\xF2\x6F\xFE\x64\x80\x52\x78\x58\x83\xAA\x82\x5C\x84\x1D\x8C\x06\x92\x05\xB2\x03\x8C\x83\xE1\x81\xB9\x80\xBD\x75\x2E\x80\x0F\x94\xEF\x6E\xFE\x61\x7A\x7A\x82\xB5\x83\x5F\x83\x31\x8E\x18\x8D\xE8\x5B\xA7\x0D\x83\xEA\x81\x90\x80\x44\x87\x2E\x82", + "\x12\x84\x0D\xA3\x06\x9F\x82\xA7\x82\x99\x81\xBD\x4E\x2E\x88\x1A\x89\x0C\xA3\x05\xA1\x77\x95\x82\x0E\x7E\x54\x86\x34\x8E\x1A\x9B\x0B\x8D\x60\x49\x6F\x33\x45\x53\x02\x57\x48\x15\x00\x72\x72\xB7\x7D\x05\xE4\x82\xB1\x82\x34\x7F\xE2\x3A\xED\x50\x1C\x97\x0A\xB3\x06\xAD\x83\xC7\x82\xD5\x81\x6A\x87\x99\x74\x19\x86\x0E\x92\x06\xA2\x83\xB5\x82\xCD\x80\x67\x81\x34\x86\x16\x8B\x0E\x8A\x06\xFE\x82\x98\x83\xAE\x81\x69\x80\x39\x81\x72\x4E\x07\xBE\x06\x9B\x83\xD8\x83\xF0\x81\x71\x85\x2D\x8B\x1D\x86\xF8\x44\x07\xB5\x82\xD7\x83\xF1\x83\x6F\x80\x3D\x8F\x1A\x83\x0A\xAF\xF7\x4D\x83\xE4\x82\xEB\x81\x7B\x80\x2F\x87\x12\x85\x0F\x99\x05\xF6\x83\xE9\x82\xF6\x83\x5E\x83\x3A\x82\xB9\x5A\x0E\xB2\x07\xFB\x83\x71\x35\xCC\x82\x24\x87\x3B\x8C\x1F\x96\x0C\xAB\xFA\x4A\x49\x0D\x31\x67\x3F\x8C\x42\xE8\x76\x62\x4E\x08\x1C\xFF\x3A\x6F\xED\x3C\xF7\x40\x16\x5E\x1D\x83\x04\x96\x4E\x60\x06\xF1\x81\xEB\x81\xCE\x80\x74\x81\x39\x87\x1F\x9F\x0F\x92\x07\xE2\x83\xFA\x82\x28\x80\x6B\x82\x39\x81\x1D\x88\xD9\x56\xE7\x23\x84\x28\x67\x02\x86\x6C\x87\x39\x85\x1D", + "\x96\x04\x43\xF7\x6B\x83\xEE\x83\xFA\x82\x87\x87\x2D\x8A\x1E\x80\x0F\xB5\x08\xAA\x84\xC2\x83\x10\x84\x8D\x82\x47\x86\x11\x98\x11\xB1\xF9\x37\x84\x20\x85\x18\x86\x17\x58\x3E\x80\x23\x94\x0F\xBE\x07\xE0\x49\x47\x84\x0E\x85\x7E\x82\x48\x88\x22\x8B\x12\x94\x86\x0D\x30\xDA\x57\x19\x46\x15\x02\xCE\x6A\x10\x18\x02\x06\xA5\x54\x00\x6B\x52\x00\x02\x8B\x5F\x26\x56\x10\x15\x02\x2F\xA5\x4A\x57\x22\x58\x64\x37\x94\x84\xBD\x62\x11\x16\x12\xA4\xE2\x04\x02\x58\x85\x77\x52\x41\x03\x4B\x85\x98\x3E\x12\x80\xA6\x71\x34\x17\x61\xF9\x03\xB7\x5C\xD6\x76\xFF\x69\x70\x79\xFF\x41\x83\xA2\x04\x02\x85\x90\x86\x48\x8D\x24\x93\x0F\xB8\x07\xFE\x84\x33\x85\x1E\x87\x9E\x87\x4F\x8F\xD6\x78\x13\x84\xFC\x3E\x84\x0C\x70\x01\x86\xA0\x80\x48\x8C\x28\x9C\x11\x96\xF8\x0D\x30\x23\x01\xD2\x31\x72\x5F\x60\x4B\x17\x5A\x90\x48\x85\x59\x84\x84\x61\x09\x63\x07\x3E\x0F\x6B\xED\x30\x7C\x43\x0A\x81\x85\x32\x85\x12\x87\xA2\x86\x51\x89\x24\x8C\x11\xB4\x06\xCA\x84\x3C\x77\x52\x84\x64\x87\x31\x8A\x21\x98\xF0\x7D\x09\x80\x84\x8D\x84\x26\x86\x83\x7C\x4E\x8F\xC0\x7B", + "\xC8\x57\x72\x50\x82\x9F\x84\x51\x85\xA8\x80\x55\x80\x2B\x84\x15\xAF\x0A\x9F\x84\xB1\x84\xBC\x80\x91\x86\x46\x8E\x2B\x86\x14\xA6\xE8\x0A\x85\xBB\x84\x53\x84\x77\x83\x55\x8D\xD0\x6D\x89\x5C\xEB\x34\x85\x53\x7B\xD9\x5D\x48\x60\x5A\x8F\x17\x8E\x16\xAB\x9A\x0E\x5A\x33\x45\x55\x02\xCC\x49\x15\x06\x94\x4A\x05\x04\xC6\x48\x75\xEF\x53\x3A\x84\x40\x02\x42\x8D\xB0\x7A\xFF\x6A\x0A\xB1\x43\x39\x38\x6F\x7F\x25\x3F\x95\x52\x7D\x72\xD8\x0D\x60\x6A\x85\x7C\x42\x76\x84\xAE\x50\x57\x83\x1C\x82\x04\x9A\xE4\x67\x85\xC7\x4A\x57\x76\xB1\x87\x32\x89\x2B\x9C\x15\x80\x0B\xC5\x85\xCE\x82\x66\x84\xD7\x70\x5F\x88\x21\x9B\x10\x8A\x0B\xA9\x82\x00\x87\xF8\x82\xAE\x84\x60\x86\x20\x89\x01\x84\x0B\xB2\x85\x01\x87\x56\x87\xA9\x87\x60\x8D\x21\x8B\x18\xBF\x0A\x8C\x7B\x0C\x87\x15\x86\xC0\x81\x22\x87\x31\x83\x15\x90\x0C\x8A\x86\xFE\x84\x19\x59\xEA\x63\x46\x41\x02\x1E\x2A\x60\x00\x54\x84\x6F\x68\xA7\x82\xBE\x82\x5C\x81\xEE\x7A\x13\xB0\x6E\x08\x83\x21\x87\xFD\x5B\x83\x87\x92\x31\x29\x9C\x5F\x5E\x81\x4A\x74\x78\x76\x26\x75\x53\x6E\x16\x8E\x10\x09\x13", + "\x88\x6B\x20\x01\x3A\x80\x1A\x55\x03\x36\x67\x81\xC5\x20\x1A\xAA\xD9\x1C\x76\x5F\x37\x67\x3F\xD0\x85\x34\x36\x34\x90\xC2\x60\x0B\xAC\x44\x01\x72\xB5\x6C\xEF\x72\x21\x04\x34\x8F\xE4\x0D\x0D\xF0\x6A\xB0\x83\x27\x54\x00\x7D\x6A\x87\xC9\x37\x1A\xBB\xD5\x59\x86\xB5\x85\x7B\x85\x55\x7A\x7A\x47\x48\x73\xC8\x64\x0D\xA7\x84\x11\x78\x6E\x75\x03\x35\x29\x8C\xA1\x3B\x04\x2F\xE5\x75\x85\x29\x77\x89\x73\xB0\x80\xB9\x44\xFF\x65\x14\x8C\xFC\x74\x86\xD4\x85\xA2\x82\x44\x03\x29\x8C\xA1\x3D\x04\x1E\x95\x1C\x01\x28\x87\x82\x00\xE0\x87\x4C\x80\x00\x1E\x04\x1F\x0B\xF1\x34\xBF\x48\xD2\x70\xC8\x84\x62\x85\x17\x14\x17\x89\x0C\xC5\x84\x84\x84\xCD\x83\x79\x87\x63\x80\x39\x80\x15\x99\x0C\xB9\x84\xEE\x83\x61\x84\xA2\x85\xBE\x7B\x2F\x91\xD0\x5D\x0C\xC9\x85\x1B\x87\x89\x85\xE8\x83\x59\x82\x31\x84\x1D\x94\x07\xA2\x87\xA5\x86\x12\x85\xCC\x80\x74\x89\x3A\x95\x18\x91\x03\x97\x87\x3F\x85\xC7\x85\x02\x80\x59\x80\x3B\x87\x14\xBD\x0B\xF3\x81\x6A\x3B\x06\x31\xB6\x37\x92\x37\x09\x1E\x2A\x56\x02\x01\x87\x04\x02\x4C\x03\x0B\x3F\x69\x89\xAE\x75\xEA\x64", + "\x0B\xD1\x38\xDF\x82\xC7\x84\xE5\x87\x61\x8C\x27\x93\x15\xA5\x66\x1B\x87\xFC\x85\x60\x85\xE4\x83\x47\x89\x39\x95\x1D\x9C\x0E\x91\x86\xA7\x86\x39\x5B\xE7\x86\x7A\x81\x3D\x92\x1D\x90\x0F\xDD\x80\xDE\x87\xDB\x87\xE8\x82\x75\x8C\x38\x80\x14\x96\x0C\x8B\x79\x9A\x86\xF1\x85\xEB\x86\x49\x85\xFB\x34\x1D\x9B\x0F\xEF\x87\x9D\x86\x87\x86\x50\x64\x17\x3A\x3B\x85\xCD\x3D\x0E\xFC\x57\xBF\x86\x32\x86\x43\x02\x78\x82\xCA\x24\x1E\x86\xEC\x46\x87\x0E\x72\x2C\x41\xD9\x84\x65\x8E\x3E\x93\xC8\x45\x10\x8B\x49\x9F\x01\x10\x74\x94\x00\x66\x85\x3E\x9D\x15\x8B\x0F\xDF\x87\x0E\x86\x08\x8B\x85\x85\x61\x83\x41\x91\x5D\x69\x0F\xD2\x87\x96\x86\xF8\x84\xF6\x85\x60\x8D\x22\x8B\x1D\x9C\x0F\xE0\x87\x0F\x89\x00\x87\x07\x89\x82\x86\x08\x87\x20\x8B\x0E\xE3\x87\xAE\x87\x06\x8B\x21\x5B\x95\x3E\x3F\x9C\xC8\x58\x82\x74\x80\xB4\x53\x38\x34\x03\x88\x85\x8C\x3E\x99\x20\xB1\x0F\x95\x88\x98\x87\xE6\x87\x06\x8C\x82\x81\x19\x9B\x27\x63\x10\xB8\x88\xB1\x87\x76\x3E\x09\x8D\x72\x87\x3E\x9B\x21\x9A\x0C\xB2\x45\x0D\x30\x79\x67\x8C\x41\x8D\x43\x08\x8D\x2E\x77\x09", + "\x9B\x51\x29\x01\xD2\x30\x14\x01\xD3\x4E\x32\x81\x1F\xB0\x0D\xE8\x86\x46\x89\x1C\x8B\xF4\x86\x63\x8A\x43\x87\x21\xAB\x0F\xE6\x87\x31\x87\x0B\x8A\x15\x8B\x8C\x8E\x1E\x83\x22\x8C\x0F\xDB\x88\xAC\x87\xEC\x86\x79\x82\x71\x83\x79\x45\x02\x25\x66\x04\x01\x4C\x55\x2E\x8B\x5A\x85\x8A\x81\x42\x98\x20\x85\x11\xDE\x88\x6A\x89\x14\x88\x0D\x88\x8C\x87\x06\x9F\x21\xBD\x10\xDF\x88\xBB\x7A\x33\x8A\x04\x8F\x8F\x89\x47\x95\x0A\x9F\x07\x8D\x30\x4A\x01\xD2\x30\x23\x01\x8E\x8F\x3F\x52\x08\x07\x7E\x1C\x34\xB1\x00\xAF\x48\x2C\x07\x0E\x6E\x0A\x02\x8C\x6F\x02\x07\x87\xB0\x37\xB3\x85\x6D\x01\x71\x89\x16\x19\x1E\x7B\x81\x0D\x30\x8F\x88\x64\x35\x24\x8C\x7F\x53\x49\x8A\x8A\x55\x12\xD2\x71\x1F\x31\x4B\x88\x72\x65\x85\x87\x22\x07\x87\x6E\xAB\x0A\x02\xA1\x89\x28\x3B\x28\x8B\x58\x70\x00\x05\x25\xB5\xC6\x04\x02\xA7\x88\x28\x71\x2A\x88\x93\x87\x05\x42\x1B\xB7\x10\x84\x89\x1C\x88\xD4\x85\x21\x8C\x8F\x8B\x47\x8E\x20\xB2\x11\xE7\x88\x81\x84\x31\x89\x1D\x8C\x8C\x88\x17\x82\x24\xAA\x0F\xC3\x89\xC6\x88\x34\x89\x48\x65\x01\x3D\x06\x05\xCD\x04\x03\x32", + "\x4E\xC5\x00\x95\x87\x84\x86\x5C\x88\x09\x45\x19\x9C\x68\x75\x3A\x42\x73\x00\x42\xE8\x32\x0A\x4C\xA1\x3E\x05\x26\xB9\x15\x84\x8C\x72\x62\x82\x3A\x8E\x42\x80\x90\x71\x1B\xAC\x0C\x9F\x30\x61\x7B\x19\x88\x20\x89\xEE\x7B\x89\x4A\xD6\x11\x71\x15\x01\x5E\x4A\x4A\x01\x6F\x83\x65\x8F\xC0\x67\x1E\x8F\x72\x74\x88\x94\x43\xA7\x80\x3F\x8C\x88\x87\x18\x9F\xFA\x72\x13\xCE\x49\x0D\x30\xA4\x73\x8C\x42\x12\x02\x73\x51\x04\x37\xC1\x13\x01\xC3\x87\x38\x36\x00\x8D\x78\x86\x40\x8F\x22\x8F\xF0\x58\x73\x7B\x40\xBA\x84\xC5\x7A\xA3\x8E\x17\x8D\xC0\x13\x11\x9C\x34\x99\x00\x99\x4E\x26\x03\x9F\x8D\x49\x9E\x0E\xB6\x0B\xCF\x85\x27\x8B\x8A\x88\x26\x46\x89\x1F\xE8\x5E\x2A\x4B\xF5\x05\x33\x96\x85\xB2\x60\x47\x8E\x8E\x8E\x41\x9A\x20\xB8\x11\xC1\x89\xA6\x86\x9C\x88\xF9\x85\x98\x8F\x2F\x84\x09\xB6\x14\x84\x8A\x2A\x88\xEA\x85\x78\x4F\xA7\x88\x4C\x97\x23\x80\x15\xBC\x8A\x32\x58\x96\x8A\xA3\x53\x72\x43\x89\x4F\x29\x87\x90\x31\x8A\x75\x68\x6A\x84\x40\x8F\xCD\x59\x52\x8C\x19\x9E\x12\xCB\x89\xEE\x82\x8C\x8A\x4F\x8F\x97\x8C\x2A\x90\x26\xBD\x14\xC2\x85", + "\x7E\x89\xAE\x89\x7F\x81\x3E\x7E\x4C\x97\x22\xB5\x06\x57\x8A\xC7\x89\xB0\x7A\x56\x8A\xF5\x71\x56\x99\x10\x9E\x15\xC2\x8A\xAB\x82\xAE\x8A\x5B\x8A\xA7\x89\x22\x82\x21\x84\x15\x8D\x30\x5F\x3C\xBE\x40\x43\x5F\x52\x7F\x06\x04\x29\x98\x11\xB7\x8A\xDE\x4B\x83\x88\x17\x5D\xAA\x80\x58\x87\x22\xAF\x15\xDC\x88\xD2\x88\xA2\x8B\x20\x8A\xAC\x8C\x43\x80\xF1\x31\x7B\x1C\x34\x6E\x89\xA3\x63\xF5\x4F\x52\x73\xCF\x26\x0C\xA6\x81\x6B\x8A\x5B\x88\xC1\x8A\x96\x50\x9D\x8D\x47\x79\x1B\xA5\x10\x8E\x72\x0B\x62\x43\x82\x66\x89\x76\x53\x5A\x9A\x22\xB6\x10\xD9\x88\x41\x89\xB4\x8B\x33\x8C\xAE\x85\x43\x86\x2A\xB2\xD4\x00\x00\x33\x86\x54\x59\xCF\x38\x59\x39\x48\x81\x43\x75\x16\xAF\x71\x06\x03\xDB\x88\x5F\x52\x21\x04\xCC\x26\xE0\x48\x9F\x07\x71\xB6\x67\x0F\x32\x8A\x3D\xB4\x77\x40\x49\x6B\x71\x16\xFF\x3B\x42\x63\xD8\x89\x03\x33\xB6\x81\xC5\x3A\x2D\xBF\xED\x4E\x8B\x4D\x70\x89\x00\x74\x88\x06\x52\x11\x1D\x2D\xBE\xA5\x13\x51\xC0\x8B\xC2\x33\x70\x89\x75\x6F\x81\x26\x2E\xB3\x0B\xEB\x02\xF0\x85\x78\x8B\xB4\x83\x2D\x0D\x3B\x74\x08\x31\x09\x8A\x62\x0E", + "\x72\xE9\x62\x78\x8D\x63\x85\x5A\x89\x2D\x89\x16\xF2\x8A\x06\x86\xA4\x88\x62\x8F\xB4\x85\x58\x86\x2D\x92\x82\x05\x51\x0C\x84\xD9\x89\x69\x33\xBA\x87\x30\x53\x2E\x9D\xE1\x0E\x02\xD3\x8A\x22\x52\x44\x04\xA1\x5A\x29\x86\x08\x16\x17\xBA\x63\x07\x49\x43\x70\x77\x89\xC2\x32\x11\x10\x17\x9D\x17\xCB\x7E\x7A\x80\x77\x35\x7E\x8B\xB9\x8B\x5F\x92\x39\x7E\x17\x85\x33\x01\x8D\xC2\x30\x81\x8D\x30\x37\x60\x88\x81\x45\x66\x0A\x8C\xDA\x8B\x06\x8D\x61\x31\xAD\x59\x5F\x8C\x25\xBA\x06\x31\x8B\xEB\x8A\xE7\x85\x5A\x06\x76\x64\x0E\x69\x2F\x8E\xE4\x34\x5F\xE9\x42\x87\x73\xB7\x5D\x10\x5A\x49\x82\x0E\x33\x18\xDE\x4A\x72\x85\x6B\x69\x44\x51\xC7\x81\x88\x2D\x17\x91\x0B\x81\x02\x37\x8C\x26\x64\x8F\x8B\x22\x7E\x4F\x87\x11\x2D\x17\xE3\x61\x84\x8B\x1F\x8F\xB8\x87\x3A\x7D\x56\x91\x2F\xB3\x13\xF0\x8A\xF4\x8B\xA3\x8B\x93\x8B\xBE\x8E\x5A\x99\xF8\x33\x14\xCC\x89\xEF\x8A\xD4\x8A\xED\x84\xA6\x81\x54\x94\x32\xB5\x14\xF0\x8B\x93\x76\x65\x8A\x6A\x8C\xCB\x82\x5F\x85\x2B\x98\x19\xD1\x8C\x45\x8B\x2F\x8F\x26\x55\x0A\x4C\xA1\x3B\x2B\x85\x66\x3D\x01\xC0\x86", + "\x00\x00\x2F\x05\x30\x36\x62\x9A\x13\x63\x17\xEE\x89\xF5\x8B\x3C\x87\xF3\x83\xB5\x8D\x58\x93\x2B\xBD\x19\xCE\x8C\x87\x8B\x34\x88\x6B\x8C\x98\x83\x65\x82\x34\xBF\x19\x9D\x88\x5D\x8C\x43\x8E\x61\x8B\xD0\x81\x4D\x88\x33\x8D\x60\x19\x3F\x6D\x8C\xAF\x49\x52\x4E\xE5\x7D\x47\x80\x20\x95\xF5\x13\x8A\xB5\x02\xCC\x89\x6B\x42\x79\x83\x66\x87\x33\x95\x19\xFC\x8C\x8B\x8D\x43\x8E\x30\x8C\xD1\x82\x39\x91\x1A\x75\x06\x73\x84\x03\x8B\xBA\x85\x40\x07\xBC\x81\xFB\x4A\x32\xBF\x03\x28\x8D\x69\x02\x56\x8D\x5F\x01\x21\x61\x6B\x99\xE1\x20\x81\x11\x8D\xFC\x56\x41\x01\x9C\x88\x10\x06\x94\x41\x04\x19\x09\x83\x01\x92\x51\x3A\x8F\x50\x5C\xC9\x87\x57\x92\x08\x23\x09\xC8\x35\xA1\x00\x46\x88\x9A\x8B\xB1\x8E\x67\x81\x35\x8E\x1B\xF6\x8B\x6A\x8D\x3C\x8F\x96\x8E\xD3\x81\x6D\x93\x23\xBB\x19\xE4\x8C\x85\x8D\x26\x8C\xA2\x8A\xBE\x8E\xD7\x62\x33\x99\x19\xD2\x8D\xD7\x86\x9F\x82\xB6\x8B\xD4\x82\x6A\x99\x29\x87\xC4\x5B\x89\x13\x72\x78\x88\xA8\x88\xDA\x89\x68\x83\x37\xA6\x1B\xCF\x8D\xEE\x8B\x65\x8C\x57\x82\xB1\x8B\x6E\x91\x37\x88\x09\xF4\x8D\xD8\x8D\x40", + "\x8E\x49\x88\xDD\x8F\x4E\x99\x07\xA5\x66\x65\x61\x85\x33\x0B\x63\xC1\x42\x10\x6A\xAC\x5C\x34\x9B\x11\xCC\x8A\x42\x62\x1B\x67\x5A\x07\xDB\x59\x62\x9A\x32\x93\x08\x18\x72\xD2\x84\x7C\x8C\xB5\x8D\xDD\x82\x71\x98\x2A\x9D\x1A\x96\x8E\xDF\x8C\x29\x8E\xBE\x8D\xE2\x87\x71\x9D\x38\x99\x1C\xE9\x8C\x14\x8E\x30\x8C\xB9\x8A\x57\x41\xE4\x71\xE2\x11\x11\xFC\x57\x27\x8F\x5B\x8B\x59\x72\x30\x6D\xAB\x20\x91\x52\x04\x47\x82\x33\x65\x38\x35\x68\x8E\xAC\x82\x1C\x1C\x24\xBD\x05\x41\x8C\xB8\x3F\x22\x8C\x5F\x43\xB2\x7D\x51\x93\xE9\x1C\x68\x02\x3F\x46\x55\x1A\x86\xC1\x8B\xD3\x87\x6D\x93\x38\x9C\x1B\xEE\x8D\x3B\x8B\x6C\x8C\xC7\x8F\xE3\x8C\x6C\x80\x34\xA4\x1A\xD0\x8C\x9F\x8D\x7C\x8F\xD3\x8E\xCB\x81\x72\x97\x1B\x8B\x1C\xC8\x8E\xCF\x78\x4D\x8D\x00\x46\xDB\x82\x6F\x92\x3A\xA5\x1B\xB5\x78\x5C\x8F\xA8\x8C\x8F\x82\x51\x86\x66\x8B\x1E\x83\x19\x8E\x8E\xDD\x86\xD8\x4B\x90\x80\xEB\x8D\x5A\x95\x36\xA0\x1C\xBE\x88\x4B\x8F\xAE\x8C\xD8\x81\x2C\x8C\x76\x90\x1E\x67\x1A\xCF\x6E\x02\x53\x5F\x51\x7F\x65\x01\x32\x1D\x73\x11\x6E\x19\x87\x48\x1A\x01\x38\x8C", + "\x07\x02\x30\x63\x78\x8A\x13\x85\x04\x5D\x3C\x32\x51\x03\x4B\x06\x07\x17\x61\xA7\x3A\x39\xB3\x88\x49\x87\x45\x8E\x8E\x42\x67\x8E\xEB\x80\x6F\x93\x36\x98\x1C\xF2\x8E\x97\x8E\xB1\x8D\xE6\x8E\xED\x8D\x74\x9B\x36\x8A\x1D\xA2\x8E\xEF\x8C\x76\x8F\xD1\x8D\xAA\x7E\x29\x94\x3C\x92\xBE\x5A\x8E\xAF\x87\xB8\x8E\xE6\x8E\xE3\x89\x4C\x95\x3B\x8D\x1A\xF7\x8D\x18\x80\xD7\x8D\x75\x75\x36\x05\x7A\x86\x3A\x93\x19\xA8\x8F\x95\x8C\xD0\x8D\xD2\x8B\xE3\x8A\x7B\x8C\x0E\xB2\x1E\xD0\x8E\x55\x80\x2F\x59\xD9\x8F\x98\x86\x2D\x8D\xB3\x59\xC1\x43\x74\xDF\x50\xBE\x8D\x69\x37\xEF\x88\x43\x41\x3C\x8A\xC5\x05\x8F\x5A\x52\x83\x00\xF4\x88\x33\x67\x40\x48\x3C\xB3\xC5\x12\x02\x8B\x8F\x37\x84\xEC\x30\xD3\x8A\xC6\x5E\x25\xAC\x0C\xF3\x86\x91\x8E\xD6\x8F\xEA\x8C\xE9\x85\x6F\x96\x3C\xA2\x1F\x9C\x8F\xE5\x8F\x70\x8E\xC6\x8B\xEA\x8A\x68\x82\x3D\x9F\x1E\xE8\x8E\x20\x88\xE2\x8F\xD5\x8A\xF5\x81\x33\x98\x3D\xB0\x1D\xBD\x8F\x6D\x8F\xAA\x8C\xB8\x88\x45\x71\x76\x88\x3F\x95\x04\xE4\x8E\xBF\x8E\x77\x6D\x5A\x04\xE1\x89\x7E\x88\xD1\x76\x1F\xDA\x4B\x01\x91\xF6\x8E\xBD", + "\x89\x8C\x89\x80\x9F\xFA\x40\x20\xF4\x8F\x57\x59\x9B\x8E\x8E\x89\xF1\x83\x38\x71\x91\x68\xB2\x7D\x8E\x9D\x48\xE6\x8F\x22\x4E\xF9\x85\x5F\x72\x08\x13\x1F\xED\x70\xC8\x4F\x0F\x90\x4D\x56\x21\x08\x78\x9C\x12\x85\x04\x59\x8F\xFD\x62\x61\x8C\x43\x06\xF1\x8A\x5A\x49\x32\xAA\x1A\xD8\x5C\x90\x8E\x0E\x36\xDE\x86\x21\x02\x82\x9C\x0B\x79\x00\x6F\x86\x3C\x85\x23\x8D\xEF\x50\xCF\x83\x79\x48\x41\x91\x71\x34\x00\x12\x5F\x1B\x02\x57\x48\x07\x01\x67\x96\x01\x0C\xD5\x7C\x38\x2C\x90\x2D\x4E\x40\x8B\x80\x8B\x7F\x80\x11\x3A\x20\xE7\x5E\x2E\x90\x6A\x86\x50\x60\xD6\x83\x6B\x97\x33\x94\x14\xC6\x8F\x54\x90\xDA\x8D\x0E\x3E\x07\x9F\xC8\x20\x42\x87\xC5\x42\x90\xFC\x56\x22\x92\xFE\x82\x21\x06\x84\x8A\x8A\x75\x00\x46\x52\x67\x90\xC3\x8C\x41\x05\x0C\x9F\x22\x7A\xE2\x48\x21\xAF\x8C\x56\x90\xA2\x74\xB1\x88\xFF\x86\x77\x8E\x21\xB4\x21\xF7\x7F\x97\x8C\x83\x89\x00\x8A\x0F\x9A\x77\x80\xC3\x7B\x9D\x1C\x90\x51\x38\x0D\x90\xF2\x4C\x4E\x6C\x62\x64\x08\x34\xC9\x50\x8A\x04\x02\x28\x42\x34\x72\x05\x93\xE5\x43\x3A\xA2\x0A\x90\x8E\x5C\x5D\x86\x8F\x03\x7A", + "\xDD\x85\x11\x82\x8A\x6B\x66\x18\x41\x80\x91\x47\x3A\x20\x91\x22\x54\x88\x85\xCC\x07\x22\x85\x33\x8A\x90\xA7\x85\x9C\x37\x00\x97\x58\x8F\x42\x84\x0B\x0E\x91\xFE\x8E\xDB\x8C\xEF\x88\xFE\x84\x42\x86\x3D\x8B\x20\xFA\x8F\x6B\x83\x06\x33\xF1\x6B\x46\x44\x0A\x12\x78\x65\x02\x5E\x4A\xA6\x00\xBF\x8B\x59\x8B\x0E\x96\x75\x9C\x41\xAF\x20\xFF\x01\x68\x8B\xCC\x8A\x43\x71\x18\x91\x28\x82\xDD\x26\x09\xC8\x35\x9B\x91\x49\x53\x28\x02\x17\x92\x1C\x04\x45\xB4\x8A\x7D\x8F\xDD\x83\x3E\x92\x10\x47\xEC\x8B\x40\x7C\x3E\xA7\x08\x04\x90\xAE\x90\xF3\x8C\xF9\x89\x1B\x9A\x7E\x8F\x3B\xAF\x1F\xCD\x90\x0E\x87\x16\x8D\x55\x7D\x06\x93\x1F\x02\x96\x73\x07\x79\x8B\xF3\x02\xDB\x65\xE7\x8B\xE4\x8E\x7E\x8B\x45\xA0\x23\xC0\x88\xDA\x90\xCC\x8C\x58\x88\x02\x93\x7A\x97\x43\xB0\xFE\x0D\x90\xF4\x91\x6F\x92\xB5\x89\x2D\x04\x8E\x8B\x0B\x26\x23\xEB\x02\xE8\x91\xB5\x02\xED\x62\x28\x60\x2F\x85\x44\x4A\x17\xF4\x3F\x1F\x30\x6C\x90\x0E\x4D\xC0\x88\x7C\x5F\x76\x42\x18\xE3\x59\x1E\x65\xEB\x8B\xF5\x8A\x94\x32\x1D\x7F\x2F\xA7\xFB\x07\x48\xCF\x3D\xD8\x8A\x45\x96\x20", + "\x04\x07\x9F\xC0\x0F\x7B\x35\x81\x1B\x93\x82\x01\x26\x91\x22\x5F\xEC\x3C\x42\x91\x17\x8E\x02\xAF\x58\x8F\x92\x44\x05\x66\x81\x61\x9E\xCC\x34\x01\x85\x51\xB5\x80\x62\x93\x8C\x42\x21\x9B\x48\x4C\x48\x91\xA4\x0E\x92\x1A\x8D\x88\x91\xDE\x8E\xE5\x84\x91\x86\x4A\x4E\x18\xE3\x48\x1A\x93\xC2\x31\x47\x93\x8C\x40\x92\x85\xCC\x23\x24\x93\x51\x25\x92\xA3\x51\x4A\x93\x8C\x4C\x92\x85\x8B\x42\xC5\x47\x92\x42\x62\x93\x90\x2A\x58\x08\x39\x90\x92\x39\x76\x24\x93\x51\x38\x93\x03\x4B\x86\x8F\x80\x45\x7B\x53\x48\xB0\x90\x15\x92\x85\x33\x9F\x92\x34\x71\x28\x97\x40\x43\x4A\x92\xE3\x45\x92\x80\x8F\xC2\x31\x52\x94\x70\x8B\x94\x92\xC6\x4D\x25\xEE\x90\x6E\x39\x57\x5A\x50\x67\x2D\x93\x79\x54\x4A\x84\xC6\x07\x46\x57\x93\xAA\x92\x1A\x96\xA3\x5A\x93\x96\x49\x4A\xC7\x2F\x38\x60\x93\x03\x4A\x58\x90\x0A\x74\x96\x98\x21\x66\x25\xD0\x70\x68\x93\xE6\x8E\x5A\x90\xFB\x8A\x94\x8B\x4C\x8E\x04\x74\x92\x6B\x78\x28\x06\x37\x8B\x22\x77\x32\x95\xEA\x4C\xD1\x73\x03\x90\x8D\x89\x70\xE2\x8B\x3E\x03\x2E\x53\x0F\x3C\x74\x2C\x86\x2C\x66\xE1\x03\xBF\x5C\x22\x0B", + "\xEB\x53\x0F\x29\xCE\x45\x8F\xA9\x6D\x17\x38\x35\x96\xD5\x89\x84\x95\xFF\x62\x00\xA8\x91\xB0\x90\x6F\x92\x3B\x93\xFD\x8F\x75\x9A\x23\xBA\x23\xB2\x93\xEC\x8E\x7C\x92\x3D\x90\xF8\x81\x9B\x8B\x47\xA1\x1E\xAF\x91\xF5\x90\x56\x93\xF1\x32\x12\x5E\x77\x9E\x2A\x7C\x01\x85\x33\x89\x92\x99\x89\xB8\x87\x81\x7F\xEC\x38\x1B\xAC\x11\xB8\x93\xB5\x92\x50\x4E\x6C\x4A\x37\x92\x9C\x80\x26\x91\x27\xA9\x85\xF9\x91\xD9\x93\xEC\x82\xF8\x84\x21\x8B\x27\xA9\x13\x80\x82\xDE\x92\x56\x34\x67\x8F\x58\x71\x9E\x84\x4F\xA0\x27\xE7\x93\xDF\x93\x46\x58\x3C\x96\x44\x7E\x8C\x86\x5B\x7B\x26\xD4\x8E\xC1\x93\x77\x92\xA9\x70\x1A\x91\x9F\x94\x4D\xA5\xA6\x5C\x93\xD9\x93\xDC\x91\xC7\x85\x3D\x9F\x24\x14\x4F\xB7\x26\xBE\x93\xBB\x8F\x67\x90\x75\x92\x3E\x9C\x6F\x82\x37\x84\x15\x9F\x30\xC5\x6E\xA8\x71\xA7\x70\x5A\x7D\x80\x37\x41\xAD\x1A\x8C\x48\x12\x02\x30\x90\xB2\x35\x9A\x8E\x95\x65\xF9\x5D\x23\x8D\x30\x6C\x91\x28\x38\x1B\x02\xE2\x5B\xA1\x81\x3A\xB2\x0E\x98\x94\xA5\x33\x0E\x97\x15\x6A\x44\x92\xA5\x56\x50\xA9\x1D\xE7\x8F\x11\x91\x4C\x8F\x30\x93\xDF\x8F\x57", + "\x8C\x4D\xB9\x70\x62\x90\xC8\x34\x37\x02\x57\x4A\x46\x90\x08\x8E\x2D\x85\xA2\x7D\x32\x0E\x02\x2F\x90\xB2\x32\x0D\x0E\x55\x4B\x03\x31\x19\xE8\x00\x77\x61\x34\x00\x9D\x8E\x48\x4B\x9E\x86\x40\xAB\x1D\xF9\x93\xD7\x93\xD7\x8D\x2A\x93\xAB\x85\x9D\x8C\x2C\x8D\xCD\x78\x93\xEF\x92\xDC\x7E\xC4\x5D\x01\x3A\xA3\x91\xE2\x3C\x28\xFC\x57\x3E\x95\x31\x92\x41\x00\x48\x9A\x14\x62\x52\x87\x90\x1F\x83\xD6\x93\xD8\x54\x7F\x93\x23\x63\xA0\x96\x4F\xAD\x23\xD3\x8E\xFE\x92\xED\x91\x76\x84\xAC\x85\xA6\x81\xBB\x78\x90\x54\x94\xA5\x33\x2B\x94\x2D\x89\x4B\x9D\x81\x8E\x08\x1C\x29\xAA\x8E\x5E\x94\x1C\x48\x98\x96\x49\x97\x7A\x87\x52\x91\x29\xED\x94\x00\x94\xAB\x5F\x9F\x90\x49\x97\x9F\x8C\x53\x84\x15\xB1\x90\x54\x47\x31\x6D\x44\x50\x4E\x9C\xA1\x32\x53\x8F\xAF\x00\x00\x74\x94\x00\x6F\x07\x37\x4E\x90\x18\x65\x08\x39\x29\x8B\x49\x7B\x95\x66\x8D\x9F\x96\xBE\x70\xA8\x85\x40\xB1\x1F\xF1\x8A\x4D\x94\x4D\x94\x36\x67\x01\x93\xA8\x8E\xF0\x42\xC5\x38\x94\x0A\x03\x2A\x97\x23\x3E\x51\x9A\x61\x4E\x08\x11\x2A\xCA\x6D\x93\x95\x20\x97\x90\x94\x9D\x8C\xA7\x98", + "\x86\x63\x29\x9D\x53\xA5\x95\x50\x96\xD3\x89\x49\x95\xD7\x69\x53\xBA\x27\xEF\x93\xA4\x94\x5D\x95\xD9\x7F\x54\x99\xC3\x2A\x55\x97\x72\x2C\x95\x0D\x84\x85\x03\xAB\x92\x76\x71\xAB\x9D\x52\xB3\x2A\xEA\x93\x61\x95\x4D\x94\xFA\x85\x53\x9C\x8D\x87\x51\xA0\x2A\x84\x94\xA2\x95\x44\x84\x94\x92\x58\x9D\x18\x4C\x42\xAE\x1A\xBB\x86\x05\x72\x00\x6F\x3D\x5E\x14\x32\x6D\x7A\x0D\x25\x2B\xF6\x8C\xFC\x4B\x70\x96\xB2\x6A\x5A\x5D\x3A\x68\xC7\x2E\x2B\xC6\x44\xEF\x94\xEB\x51\xBC\x95\x91\x53\xAF\x9B\xE5\x57\x09\x64\x95\x15\x4A\x69\x56\x29\x35\x01\x3B\xAF\x99\x57\xAB\x85\x26\x31\xE0\x95\x61\x8D\xBA\x96\xE3\x72\xAE\x9F\x57\x91\x0D\x85\x96\xA0\x4D\x7E\x97\xC0\x91\xBC\x72\xBB\x63\x57\xA9\x1A\xA6\x31\x4E\x8B\x72\x87\x4A\x48\x61\x86\x00\x94\x57\xB0\x2B\x97\x96\xF2\x94\x8C\x96\xC5\x94\xAF\x6B\xB2\x20\xB7\x4B\x2C\x8E\x55\xA6\x30\x13\x3B\x1B\x97\x63\x93\xD3\x58\x57\xA4\x2C\xAA\x54\x00\x96\x7F\x95\xC2\x97\x60\x9B\xAE\x86\x58\x9E\x2B\xD3\x78\xD8\x46\x95\x94\x69\x5B\x62\x92\xA8\x88\x58\x87\xA6\x32\x96\x76\x87\x96\x94\x43\x04\x78\x75\x6B\x87\x59", + "\x98\xB9\x26\x96\x34\x97\xE3\x58\xD0\x96\x66\x93\x69\x54\x31\xB8\x2C\xA2\x84\x15\x90\xE4\x4E\x29\x35\x97\x79\xA8\x81\x5A\xAE\x26\x8D\x96\x04\x96\x9D\x97\x94\x5B\x68\x92\xB5\x98\x43\x8E\x2D\xD6\x96\x44\x96\x94\x97\x73\x94\x6A\x90\xB5\x8B\x59\xAF\x2C\xDC\x96\x30\x96\x97\x95\x8B\x91\x6C\x9E\xB5\x83\x5B\xA0\x2D\xE7\x96\x5B\x97\xB4\x97\xD7\x92\x6D\x96\xB6\x8C\x5B\xAA\x28\xBE\x96\xCB\x54\xB4\x95\x49\x88\x6E\x97\xAE\x91\x5A\x9D\x2D\xE1\x4C\x29\x97\x41\x44\xEA\x32\x63\x95\xB1\x9D\xA3\x75\x2B\xD7\x4D\xA6\x91\xF8\x7C\x08\x6C\x17\x36\x8A\x35\xD8\x4B\x27\xF7\x96\x11\x8F\xAB\x95\x40\x00\x26\x63\xB2\x8A\x5C\x80\x04\x3C\x96\x7D\x03\x0B\x63\xFC\x87\x68\x9F\xB8\x94\x5C\xB1\x2D\xA5\x33\x85\x96\xCB\x94\xE4\x97\x6D\x9E\xB8\x80\x46\x96\x2E\xFC\x95\x6E\x97\x66\x92\xE5\x91\x62\x91\xC5\x26\xC5\x1B\x2E\xAE\x85\x9D\x96\xD2\x94\xEA\x91\x6B\x9D\x66\x52\x5B\xAD\x2D\xBE\x91\x79\x97\xCE\x95\xC0\x94\x61\x94\xB6\x98\x4E\x9D\x2E\xA7\x97\x9F\x33\xCF\x97\xE8\x94\x3B\x49\xB2\x30\x58\xBA\x2E\xF0\x96\xA0\x97\x07\x96\xEB\x92\x0E\x94\xB7\x9B\x5D\x85", + "\x2F\xF0\x96\xAA\x97\x4B\x3A\xEF\x90\x79\x96\xB9\x96\xB9\x45\x28\xA9\x75\x2F\x3D\xF6\x74\x42\x66\x72\x9A\xC6\x74\x08\x11\xFE\x3D\x96\x9D\x96\xC2\x75\x5F\x07\x7A\x9D\x17\x10\x17\x8B\x2F\x9D\x97\x86\x97\xE7\x95\xED\x97\x38\x5F\xBD\x8C\x5D\xA5\xF8\x29\x75\xBD\x97\xD0\x97\x89\x01\x78\x97\x85\x95\x5A\x88\x2D\xE6\x97\xCC\x7A\xC2\x52\xE5\x91\x7E\x98\xBD\x90\x5F\x96\x2E\xB3\x97\x78\x97\x17\x87\xF8\x97\x7D\x9E\xBE\x9F\x4E\x56\x2E\xCC\x96\x9B\x89\xDF\x95\xE7\x94\x7D\x91\xC0\x90\x5B\xB8\x2E\xBA\x03\x84\x97\xF9\x8D\xEA\x96\x78\x9D\xB9\x80\x60\xB5\x1C\xFF\x97\x96\x96\x57\x8B\x29\x5B\x6F\x93\xC1\x9E\x11\x21\x2C\x96\x97\xE1\x96\x89\x96\xF9\x94\x80\x92\x1C\x1C\x60\xA2\xED\x40\x97\x02\x99\xD2\x71\xFA\x92\x46\x05\xBE\x9D\x5F\xA8\xE2\x25\x98\x88\x97\x55\x8F\xFC\x94\x81\x96\xBE\x99\x60\x95\xD7\x23\x98\x4D\x96\xF3\x94\xFE\x90\x6B\x96\xC2\x89\x5E\xBA\x06\x1E\x98\xDA\x87\x01\x98\x0B\x9E\x84\x98\xC3\x91\x59\x8C\x2F\xA0\x98\x3F\x98\x1D\x9A\x43\x00\x08\x0B\x48\x9C\xE3\x06\x31\xC7\x98\x48\x99\x24\x9A\x12\x9B\x89\x93\x81\x96\x44\x8D\x31", + "\xCF\x98\x8A\x95\xD7\x8A\x14\x7A\xD3\x84\xC5\x9F\xDA\x15\x31\xD6\x35\x57\x98\xDC\x3D\xB9\x96\x86\x9C\xC5\x92\xE9\x5E\x31\xC2\x7A\x60\x99\x95\x4A\xC7\x70\x80\x74\xC6\x86\xE3\x65\x31\xBE\x79\x33\x6C\x6D\x70\x6E\x8A\x8D\x9A\x8B\x6C\x63\xAE\x31\xA7\x92\x6B\x98\x3B\x70\x14\x77\xD9\x34\xC7\x83\x23\x75\x31\xD2\x71\x77\x99\x39\x9A\x1D\x9F\x18\x7C\x8B\x3D\x63\x91\x14\xFD\x87\x7F\x98\x18\x4A\x1F\x98\x90\x92\xCA\x3F\x76\x5D\x25\xEF\x52\xD2\x62\xDB\x65\xEA\x60\x5E\x81\x5B\x99\x2F\xBB\xBA\x42\x57\x74\x80\x43\x9A\x2C\x62\x0E\x59\xC8\x90\x9F\x62\x18\x8E\x84\x10\x8C\x8E\x5E\x44\x00\x92\x94\x18\x67\x64\x9E\xA5\x15\x99\x6B\x7F\x7A\x7C\x26\x99\xE8\x75\x72\x85\x08\x1C\x32\x8E\x02\xB5\x80\x49\x99\xB1\x67\x24\x5D\xCF\x69\xF4\x5E\xF2\x17\x99\x0A\x03\x46\x99\x29\x9D\x88\x5B\x07\x8D\x63\x1D\x32\x93\x99\xE5\x79\x7B\x79\xDE\x7A\x94\x91\xCB\x99\x64\xB9\xF8\x0A\x02\xA7\x98\x85\x01\x2A\x9A\x12\x57\x01\x74\x64\xBA\x02\xBB\x99\x17\x93\x5E\x98\x29\x99\xCA\x70\xCC\x92\x08\x34\x01\xC3\x99\x6D\x53\xE3\x8F\x27\x9F\x98\x9F\xCA\x9C\x65\xAB\xFF\x4B", + "\x99\x2F\x7D\x66\x99\x2D\x98\x39\x6E\xC9\x9F\x46\x60\x32\x98\x7F\xEE\x7D\x51\x9A\xCE\x79\x9B\x9B\x03\x9B\x66\x82\x33\xB7\x99\xAB\x98\x43\x51\x2E\x9F\xA5\x78\xCC\x81\x67\x8A\x33\xE3\x99\x9A\x99\xE5\x56\x33\x9E\x96\x9C\xCD\x98\x65\x8C\xC7\x0A\x99\xB0\x99\x6B\x98\x3C\x9F\x97\x95\xCE\x8A\x08\x0F\x33\xE8\x99\xFD\x62\x63\x9A\x2B\x9E\x95\x79\xCF\x85\x08\x32\x32\xCC\x99\xFD\x98\x8E\x90\x3D\x9D\x0D\x9E\x97\x89\x67\x82\x34\xB0\x79\xE0\x99\x82\x00\x23\x9E\x97\x98\xC6\x1B\x64\xB3\x33\xA8\x99\x00\x9A\x0B\x93\x43\x9A\x97\x95\xCD\x89\x66\xBA\x33\x86\x02\x8E\x98\x8B\x9A\x39\x9E\x20\x00\xCD\x9E\x2D\x9E\x18\xD3\x99\x03\x9A\xE2\x8A\x47\x9E\xA0\x94\xD1\x93\x78\x62\x34\xFE\x99\x0B\x9A\x7A\x64\x43\x9C\x02\x9A\xD1\x8B\x67\xB5\xF8\x1D\x9A\xEE\x99\x8F\x99\x19\x1B\x96\x9B\xC3\x50\x69\x98\x34\xF5\x99\x0E\x9A\x9B\x9B\x8A\x7D\x9D\x92\xD1\x92\x08\x07\x34\xE4\x99\xA6\x99\x8B\x9B\x4C\x9D\x9B\x98\x84\x54\xE9\x50\x34\xC4\x9A\x04\x03\x89\x98\x36\x99\x9E\x9A\xCD\x9E\x69\xA7\x33\x8E\x02\xF2\x64\x55\x99\x40\x9A\xA8\x98\xCF\x96\x66\xAC\x34\xD3\x9A", + "\xFC\x99\xA4\x9B\x48\x9D\x20\x05\xD2\x92\x48\x88\x32\xD4\x99\x04\x9A\xAF\x9B\xF6\x7D\xA5\x9F\xC8\x8A\x6A\xA4\x34\x99\x9A\x08\x8C\x6F\x98\x5A\x9A\xA5\x99\xD3\x9F\x6A\xBB\x33\x95\x9A\xF2\x99\xB1\x98\x41\x05\x16\x82\x2C\x7A\x6A\xB5\x34\xF7\x99\x96\x98\xB5\x98\x6C\x8C\xAD\x9F\xD2\x8A\x68\xBF\x34\xCB\x9A\xF6\x98\x7A\x79\x57\x9B\xA5\x9B\xD6\x80\x6B\xB8\x35\xD5\x9A\x86\x9B\xAB\x98\x62\x99\xA8\x90\xD8\x81\x65\x8C\x36\x83\x9B\x8E\x9A\x97\x99\x5E\x9E\xAA\x9F\xD6\x98\x6A\xB0\x35\xA7\x9A\x72\x9B\x94\x9B\x22\x9E\xA8\x94\xD8\x9B\x6C\x91\x36\x9D\x9B\x0A\x03\xAC\x98\x31\x9F\xAC\x92\xDA\x85\x68\x8D\x36\xF7\x9A\x9A\x9A\xC8\x99\x41\x07\x9F\x9E\x10\x1D\x6B\xAB\x36\xA8\x9A\x4F\x9A\x9C\x99\x51\x9A\x9C\x90\xD2\x9C\x69\x81\x33\xA8\x9B\x32\x9A\xEA\x8E\x49\x9A\x9A\x91\xDA\x99\x6D\xA9\x35\x97\x9B\x47\x9A\xAA\x99\x42\x9B\xB6\x91\xD3\x85\x08\x3E\x35\xF1\x9A\x4D\x9A\x9E\x78\x3B\x9A\xB7\x91\xD5\x84\x6D\x99\x36\xED\x9A\x7A\x9B\x73\x23\x67\x9C\xB8\x91\xDD\x82\xF7\x46\x37\xF4\x9A\xBB\x9B\x77\x99\x6F\x98\xA1\x92\xD6\x9C\x6C\xA4\x35\xDB\x9B\xC5", + "\x98\xAE\x99\x60\x98\xB9\x95\xDA\x92\x6D\x84\x04\x34\x9B\x93\x9B\xAD\x99\x65\x99\xA2\x95\xDD\x9C\x6D\xBB\x34\xE4\x9B\xB4\x98\xF3\x9B\x5E\x98\xBD\x9C\xDA\x9F\x6E\xA3\x36\xF6\x9B\x04\x03\x90\x9A\x69\x9C\xB9\x97\xD8\x81\x6E\x85\x04\x1F\x93\x3B\x93\xBF\x9A\x62\x9B\xBD\x95\xD7\x8F\x6D\xA3\x37\xC8\x9A\xF9\x9B\xD3\x9B\x81\x9F\xB6\x95\xDC\x9C\x68\x87\x37\x8D\x9C\x98\x9A\xD8\x98\x76\x9A\xBF\x90\x00\x08\x70\x8D\x34\xF2\x9B\x0B\x9C\xCB\x98\x86\x99\xB9\x91\xD6\x91\x70\x84\x38\x92\x9B\x06\x02\x0F\x9C\x4D\x98\xBA\x9B\xD9\x6D\x65\xBE\x37\xAE\x9B\x19\x9D\x07\x9E\x72\x9D\xBC\x92\xE1\x9B\x6F\x85\x75\x51\x99\xE9\x9B\xF9\x98\x54\x98\x00\x02\xD5\x9A\x70\x85\x36\xA7\x9C\xC0\x9B\x09\x9C\x8E\x9D\xBF\x96\xE1\x80\x6F\xB5\x37\xE2\x9B\xF7\x9A\x08\x9D\x4F\x9D\xC6\x9A\xDD\x97\x71\x83\x37\xB9\x9C\x21\x9C\xFA\x98\x8F\x9E\xBA\x9E\xE3\x83\x70\xAF\x37\xBE\x8E\x4F\x9C\x22\x9F\x74\x9F\xC2\x91\xDE\x9A\x69\x81\x38\xBE\x9B\x6E\x9B\xF3\x9A\x93\x9E\xAC\x98\xDB\x85\x72\xBF\x37\xC8\x9C\x5F\x9C\xFC\x9B\x92\x98\xC8\x92\xE6\x8A\x08\x2A\x38\xCC\x9A\x2D\x9C", + "\xA7\x9A\x99\x98\xC6\x94\xE2\x8F\x6C\x8B\x37\xD7\x9C\x05\x9C\x21\x9D\x96\x9D\xCC\x9B\xE5\x86\x72\x93\x39\x80\x9C\x00\x00\x01\x9E\x7B\x98\x00\x00\xDF\x89\x71\x94\x38\xDD\x9B\xDF\x99\x1D\x9D\x8F\x9A\xC6\x95\xE2\x8B\x73\xB8\x39\xA8\x9C\x7A\x9C\x32\x9D\x85\x9D\xCF\x97\xE6\x9E\x72\x81\x3A\xE0\x9C\xD9\x9B\x5A\x83\x9B\x99\xB1\x9E\xE2\x93\x73\x82\x36\xF5\x9C\xB1\x9B\x3B\x9C\xA1\x9D\xB9\x94\x10\x02\x96\x5B\x3A\x94\x9B\x51\x9C\x45\x9C\x95\x9C\xD1\x96\xE7\x94\x71\xAC\x39\xB6\x9C\x6E\x9D\x43\x9D\x9C\x9A\xBA\x97\xD3\x9C\x72\x87\x39\x96\x9D\x82\x9C\x51\x9C\x1D\x87\xD4\x90\xE2\x9D\x74\x94\x3A\xF4\x9C\xED\x9A\x5D\x9C\xA9\x99\x61\x68\xE5\x92\x74\x88\x3A\xF3\x9A\x95\x9C\xBB\x98\xAB\x99\xD4\x9E\xEA\x8F\x74\x81\x39\x84\x02\xBC\x9C\x05\x9E\xAF\x9D\xD6\x9E\xE7\x8B\x74\x89\x39\xB3\x9C\x26\x9C\x67\x9D\x9B\x9E\xD0\x93\xE4\x9C\x73\x94\x3B\xC9\x9D\x0E\x9D\x6B\x9D\xA3\x9F\xB7\x9B\xED\x91\x96\x45\x3B\x89\x9C\x2C\x9C\x56\x9A\x9C\x9F\xD7\x9F\xE9\x81\x76\x8D\x3B\xA3\x9D\x79\x9C\x68\x9E\xAC\x9A\xDD\x94\xEB\x83\x6A\x94\x37\xFF\x9C\x68\x9D\x4B", + "\x9E\x9A\x9C\xDC\x90\xEB\x9C\x76\xBB\x39\x93\x9D\xDF\x9C\x60\x9F\x75\x9F\xC7\x9A\xED\x9D\x77\x85\x04\x72\x65\xD1\x9D\x74\x9E\x3A\x9A\xC7\x97\xEF\x96\x76\xA9\x39\xCA\x9C\xFC\x9D\x26\x9D\x6A\x9F\xDC\x9F\xE1\x92\x76\xAB\x3B\x81\x9E\xED\x9D\x81\x9E\x95\x98\xDE\x90\xE9\x85\x75\x94\x3C\xAB\x9C\xA0\x9B\x63\x9D\x6B\x99\xE3\x95\xE5\x83\x74\x85\x3A\xE6\x9D\x63\x9C\x74\x9D\xC8\x9B\xD6\x9E\xDD\x9E\x74\xAC\x37\x9A\x9E\x26\x9F\x61\x9D\xC2\x9B\xE5\x94\xEF\x8D\x79\xAC\x3B\xAF\x9E\x25\x9E\x61\x9D\xBC\x9D\xC3\x93\xEF\x8B\x78\xA9\x3A\x8D\x9E\xAB\x9C\x71\x9D\xAB\x99\xDB\x9C\xF1\x8F\x76\xBC\x3C\xDD\x9D\x00\x9E\x7B\x9E\xAD\x98\xDF\x98\xEB\x98\x74\x9C\x38\x9A\x9D\x3D\x9F\x8D\x9B\xCD\x9B\xC4\x9E\xEE\x84\x7A\xA7\x3C\xF2\x9D\x48\x9E\x91\x9F\x8B\x9C\xE4\x9B\xEC\x9B\x70\x8C\x39\xFC\x9A\xC3\x45\xA8\x9E\x7A\x9A\xC4\x9D\xE5\x8A\x76\x82\x3D\xCC\x9D\x56\x9F\xB0\x9D\xD6\x9C\xE5\x99\xE8\x80\x7A\x80\x3A\xB9\x9D\xEF\x9C\x3A\x83\xB8\x40\xCE\x95\xF3\x8D\x7B\x8B\x3D\x8E\x9E\xFA\x9C\x88\x9D\x98\x9E\xE0\x99\x31\x42\x7B\x8C\x3C\xF7\x9E\x41\x9F\x87\x9C", + "\xB6\x9E\xD1\x95\xF4\x85\x77\xBD\x3D\xEB\x9E\x75\x9E\x64\x9E\xC0\x99\xE7\x91\xF7\x83\x76\xB3\x3D\x9C\x9D\x17\x9E\xA5\x9D\xB5\x99\xF0\x99\xF7\x83\x7C\x91\x3C\xB5\x81\x8F\x9E\x54\x9F\xB4\x9A\xF2\x90\xEE\x91\x71\xA7\x3D\xDE\x9E\xAF\x9D\x6C\x46\xDF\x9F\xE7\x90\xF8\x8F\x7B\x8E\x3D\xDF\x9E\x6A\x9F\x7F\x9E\xD6\x9E\xE5\x94\xF5\x90\x79\xBA\x3C\x9D\x9E\xA2\x9E\xC4\x9E\xCF\x9B\xF3\x9B\xD8\x8D\x7D\x8C\x3E\xE9\x9E\x3B\x9F\xCC\x9D\xAF\x99\xF2\x95\xFB\x85\x7B\xA1\x3B\x82\x9F\xE3\x9D\xBD\x9E\xC4\x9D\x65\x43\xFA\x94\x7D\x8C\x38\xBE\x9F\x9E\x9E\xE0\x9F\xD0\x9C\xF0\x97\xF5\x91\x7D\xAA\x3E\xEC\x9E\x8A\x9E\xAE\x9F\xE7\x9C\xE0\x95\xF8\x9C\x7B\x8E\x3F\xC6\x9D\xD0\x9F\x91\x9C\xCE\x9D\xEB\x94\xFD\x8D\x7E\x82\xCB\x3A\x9F\x16\x9F\x7A\x9D\xEF\x9F\xD6\x96\xF6\x8A\x7E\xA8\x3D\xCC\x9F\x8E\x9F\xE2\x9C\xEF\x9F\xF8\x94\xFE\x9F\x7D\x95\x3E\xC1\x9F\xD9\x9A\xF0\x9E\xC2\x9A\xEA\x98\xF1\x9B\x7E\x93\x3F\x9B\x9E\xCD\x9E\x79\x66\xFC\x9C\xE6\x93\xFB\x8B\x7F\xA4\x3D\xED\x9F\xC9\x9F\xF7\x9F\xF2\x9F\xF2\x99\xFA\x98\x7E\x89\x3E\xDA\x9F\xB6\x9E\xEE\x9C\xFE", + "\x99\xFD\x92\xFB\x94\x7F\x9C\x3E\x8B\x9F\x0A\xA1\x98\x9F\xCE\x9F\xFB\x9A\xFE\x82\x7F\xAC\x3F\xCC\x9E\xE5\x9E\x01\xA3\xF9\x9C\x00\xA3\x32\x4F\x7E\x87\x40\xDB\x9E\xF6\x9E\xF3\x9C\xE8\x9D\xE0\x93\xFC\x96\x17\x55\x40\xB6\x9E\xF5\x9F\x04\xA3\xFD\x9A\x02\xA0\xFB\x9A\x7F\xA7\x40\xF6\x9E\x93\x9E\xD3\x9F\xBE\x9A\xF8\x95\x0B\x8E\x81\x8D\x40\xE3\x9E\x52\x9C\xBC\x9C\xDC\x98\xF7\x90\xFB\x94\x80\xB7\x40\xFF\x9E\x31\xA1\x7C\x9F\x0E\xA0\xFD\x93\x01\xA5\x80\xAA\x3C\xDC\x9B\xD9\x9E\x10\xA2\x0A\xA2\x04\xAD\xFD\x8C\x80\x9E\x40\xFD\x9F\x16\xA1\xFF\x9C\x06\xA6\xFD\x93\x04\xBC\x80\x82\x8D\x4F\xA0\x0E\xA1\xF1\x9F\x14\xA1\x00\xA5\x05\xB4\x81\x86\x41\x95\x9E\xF3\x9E\x1C\xA2\xAA\x9A\x06\xAA\xF7\x99\x74\x9F\x41\xA0\x9E\x48\xA1\x0F\xA0\xEB\x98\xF9\x90\xEA\x83\x81\x95\x3F\xA5\xA0\x87\x9E\x2C\xA2\x18\xA6\xED\x92\x04\xA7\x7D\xA1\x3E\xE0\x9E\x0E\x03\xA3\x92\x54\x95\x06\x94\xF7\x90\x82\xA8\x40\x8F\xA0\xD2\x9E\x26\xA3\x02\xA4\x06\x9F\x02\xB1\x7E\xA1\x40\x9A\xA0\x6E\xA0\x3A\x80\x1F\xA0\xF2\x91\x05\xB9\x81\x94\x3E\xDD\xA0\x66\xA0\x42\xA3\x0F\xA4", + "\xF4\x91\x04\xAD\x7A\xB3\x40\x91\xA1\x0A\x03\x45\xA2\xE6\x9E\xFF\x9E\x08\xA4\x83\x96\x3E\xDE\xA0\x92\xA0\x39\xA0\x10\xA5\xF3\x9D\x06\xAD\x82\xBB\x3C\x9A\xA1\xBB\x9F\x46\xA3\x18\xA5\x0E\xA7\x09\xBC\x70\xA8\x42\xE1\x9F\x7F\xA0\x2D\xA2\x0E\xA6\x0E\xA4\x02\xB5\x05\xAF\x42\xE1\xA0\xA3\xA0\x08\xA3\x0A\xA7\xF5\x96\xF4\x97\x85\xBC\x3F\xD9\xA0\x17\xA1\x59\xA1\x2B\xA0\xF5\x91\x0A\xA6\x80\xBE\x41\xB0\xA0\xA4\xA1\xAA\x9C\x11\xA0\xF6\x9E\x0B\xA9\x83\x87\x43\x86\xA1\x4B\xA0\x44\xA2\x29\xA4\x19\xA5\x08\xA8\x80\xAC\x41\xCA\xA1\x56\xA0\xE9\x8D\x35\xA2\x09\xA7\x0D\xAE\x7D\x8D\x3E\xC5\xA0\xC5\xA1\x23\xA0\x94\x9E\xF8\x92\x05\xA2\x86\xA5\x41\xCF\x9E\x1E\x91\x6D\xA3\x1A\xA0\x00\xA5\x0A\xA3\x84\x99\x42\xEA\xA1\x53\x9F\x6E\xA3\xED\x9B\x19\xA6\xF4\x92\x97\x4D\x43\xE3\xA1\x9C\xA1\x55\xA2\x25\xA7\x1C\xA4\x0C\xAF\x87\x93\x42\xE4\xA1\x9D\xA0\x56\xA0\x3F\xA7\x0E\xA9\x0E\xBF\x87\xB9\x43\xF4\xA0\xFB\xA1\x4F\xA0\x26\xA6\xC0\x94\x10\x17\x87\x9A\x39\xA9\xA0\xF2\xA1\x08\xA0\x2F\xA6\xF0\x90\x00\x0E\x88\x9E\x3B\x80\xA1\x87\xA0\x48\xA0\x3A\xA1\x1C", + "\xA0\x06\xBF\x85\xB3\x41\xA5\x9F\x02\xA2\x85\xA3\x46\xA3\xE2\x9C\x11\xA8\x83\xB8\x43\xAA\xA1\x08\xA3\x0C\xA2\x46\xA5\x1F\xA9\x31\x65\x88\xA2\x42\x94\xA1\xC9\xA0\x6F\xA0\x0F\xA6\xE8\x92\x2C\x76\x88\x89\x3D\xB2\xA1\x8F\xA0\x5A\xA3\x1B\xA0\x0F\xAE\x0F\xAF\x89\x80\x44\xFA\xA1\x2A\xA2\x9D\xA1\xF3\x9E\x26\xAB\xFA\x91\x87\xAC\x43\xD8\xA1\xA0\xA1\x9E\xA2\x31\xA0\x18\xA5\x0E\xB9\x89\x83\x43\x84\xA2\x25\xA3\x3E\xA0\x53\xA1\x20\xA9\x10\xB0\x7F\xA3\x44\xDA\xA1\x06\xA2\x94\xA0\x48\xA5\x2A\xA3\x00\xA9\x8A\x98\x45\xBE\xA2\x07\xA3\xAD\xA1\x50\xA7\x29\xA5\x0B\xB2\x08\x02\xCB\x08\x8F\x68\xA3\x22\x3E\x5A\xA4\x04\x9B\x16\xA4\xF3\x2C\x45\xEF\xA2\x6E\xA3\xB8\xA2\x41\x01\x2D\xA0\x17\xB3\x8B\x92\x04\x19\x93\x4B\xA3\x8F\xA1\x25\xA3\x2C\xA3\x10\xA4\x81\xB8\x45\xE2\xA1\x0F\xA2\x8C\xA1\x34\xA3\x25\xA1\xFA\x9F\x8B\x9D\x44\xCE\xA1\x53\xA2\xA0\xA0\x15\xA2\x28\xA3\xEC\x86\x8C\xA6\x44\x81\xA3\x38\xA2\x4F\xA2\x55\xA4\x25\xA5\x10\x0E\x8C\x92\x45\xFA\xA2\x31\xA3\x79\xA1\x36\xA5\x32\xA0\x0F\xB0\x88\x87\x45\xB2\xA2\xF4\xA0\x8A\xA2\x65\xA4\x11\xA1", + "\x0B\xA1\x86\x8E\x45\xFD\xA2\x6F\xA1\xD1\xA3\x26\xA2\x2B\xAB\x17\xAB\x8C\xA4\x45\xBB\xA2\x77\xA3\xCE\xA2\x60\xA1\x22\xAB\x0B\xBF\x86\xB0\x3E\xAA\xA3\xA9\xA1\xD2\xA1\x53\xA2\x32\xAD\x15\xAB\x88\x9C\x46\xD9\xA2\xBA\xA2\xAA\xA0\x5F\xA2\x24\xA4\x19\xA4\x08\x38\x46\xB0\xA1\xC8\xA0\x5D\xA2\x20\xA4\x05\xA6\xF4\x87\x8E\xB8\x42\xB0\xA2\xCA\xA2\x69\xA2\x3B\xA5\x39\xA2\x1B\xB1\x8C\xA1\x44\x93\xA3\x50\xA2\x6D\x65\x6C\xA0\x38\xA9\x1C\xA1\x84\x92\x47\xCC\xA3\xA2\xA3\xEA\xA2\x69\xA4\x37\xAB\x01\xA2\x7E\x8E\x47\x9E\xA2\xB9\xA0\xEF\xA0\x61\xA5\x2C\xAE\xD9\x8E\x08\x27\x47\x88\xA3\x98\xA3\xE8\xA3\x7A\xA0\x36\xAE\x1E\xA2\x8F\xBB\x46\xD7\xA3\xBD\xA3\xAB\xA3\x6F\xA0\x2C\xAC\x1A\xB9\x8C\x92\x44\xB6\xA3\x34\xA3\xED\xA0\x7F\xA1\x38\xAA\x18\xBC\x82\x8C\x46\xBB\x9E\xEF\xA3\x93\xA0\x81\xA1\x25\xAE\x1A\xA8\x8D\x8D\x3F\x89\xA4\x90\xA3\xF1\xA0\x7E\xA5\x3C\xAE\x1B\xA4\x08\x32\xCB\x10\xA4\x17\xA2\xEB\xA0\x57\xA4\x42\xAA\x1F\xB6\x90\x82\x48\xF9\xA2\xE9\xA3\x8C\xA3\x81\xA5\x07\xAF\x21\xA0\x8C\x99\x48\x92\xA4\x1B\xA5\x44\xA3\xB0\x9A\x58\x68\x21", + "\xB7\x89\xA8\x48\xC3\xA3\xD8\xA2\xF6\xA2\x42\x05\x45\xA5\x14\xBE\x8C\x9B\x41\xED\xA1\xE0\xA2\xEB\x9C\x8D\xA1\x09\xAB\x0E\xB7\x91\x88\x45\x95\xA4\x00\x01\x1D\xA6\x1A\xA6\x28\xAE\x23\xA0\x8D\x9B\x46\xC6\xA3\xF6\xA2\xE1\xA1\x83\xA4\x38\xA9\x1D\xA6\x08\x02\x49\xCF\xA1\xD6\xA1\xCF\xA2\x66\xA6\x2B\xA8\xF2\x9A\x8E\xAD\x47\xD6\xA4\x24\xA3\x2C\xA4\x43\xA0\x00\x02\x2C\x62\x96\x4C\xD1\x17\xA3\x21\xA5\xC1\xA3\x88\xA1\x65\x8C\x1D\xB0\x86\xB4\x46\xCB\xA3\x13\xA2\x82\x03\x97\xA4\x34\xAD\x1D\xA2\x91\xAF\x46\xCD\x9F\x6B\xA5\xD5\xA3\x82\xA2\x2C\xAB\x24\xB1\x91\xB4\x47\xB8\x68\x49\xA5\x02\xA4\x8E\xA1\x4D\xA0\x07\xA0\x00\x31\x49\xB9\xA3\x6D\xA4\x31\xA7\x9B\xA3\xD8\x9F\x27\xA8\x8E\xA6\x49\xD2\xA4\xFF\xA3\x99\xA1\x41\x05\x50\xAF\x1C\xBF\x89\x8C\x48\x86\xA4\x83\xA5\x9D\x9C\xA3\xA0\x3D\xA0\x1D\xAA\x8F\xA3\x49\x94\xA2\x93\xA4\xF8\xA1\x98\xA7\x4C\xAF\x1D\xBC\x93\xB5\x02\x99\xA5\x0A\xA5\x40\xA4\xA7\xA3\x3E\xA0\x27\xB9\x93\x8F\x4A\xFB\xA4\x00\xA4\x4C\xA6\xA9\xA4\x4E\xA0\x29\xAE\x90\x84\x4A\xAB\xA5\xAD\xA3\x56\xA4\x93\xA2\x46\xAB\x25\xA0", + "\x95\x91\x48\xF7\xA3\x29\xA5\x69\xA2\xD1\x9E\x56\xA7\x22\xB8\x95\xB0\x48\xF9\xA3\x4C\x9C\x5E\xA6\x8B\xA6\x57\xA5\x27\xA0\x96\x8D\x49\x87\x9E\x03\x68\x58\xA6\x7F\xA5\x36\xAA\x28\xB6\x7E\x82\x4B\xB5\xA4\xB3\xA2\x44\xA4\xB3\xA1\x34\xAE\x2C\xAA\x96\xB2\x47\x97\xA5\xD6\x9E\x2F\xA6\xB5\xA6\x52\xA1\x29\xB0\x7D\x8F\x4B\xBC\xA4\x44\xA4\x73\xA3\xAC\xA7\x4E\xA4\x26\xA3\x90\xA2\x4A\xD2\xA5\x68\xA5\x54\xA6\xF5\x9A\x5E\x6F\x2D\xA3\x92\xB6\x48\xE2\xA5\x76\xA5\xFC\x9D\xB2\xA5\x4C\xA1\x25\xA5\x92\x93\x49\xC0\xA4\xDA\xA4\x7A\xA4\x37\xA0\x5D\xAD\x29\xAA\x97\xBD\x49\xF9\xA5\xE6\xA5\x43\xA6\xBD\xA1\x51\xA4\x2D\xBD\x93\xAD\x4B\xD0\xA4\xFB\xA5\x81\xA7\xB4\xA7\x48\xAE\x27\xBB\x96\xAE\x49\xAE\xA5\x92\xA4\x87\xA6\xA0\xA0\x62\xAE\x2D\xB2\x98\xA3\x4A\xD8\xA5\x06\xA6\x8B\xA4\xBF\xA4\x54\xAB\x22\xB2\x08\x15\x26\x81\xA6\xF5\xA4\x78\xA6\xB1\xA4\x04\xAF\x31\xA0\x91\x95\x4A\x8F\xA6\xE3\xA4\x3A\x81\xC9\xA6\x44\xA3\x2C\xAA\x92\xB2\x4A\xF1\xA5\xC3\x9D\x95\xA7\x61\xA1\x54\xA2\x30\xA2\x99\x9C\x48\xC5\xA3\x00\x00\x99\xA7\x63\xA5\x57\xAE\x32\xA8\x95", + "\x8D\x4B\xFD\xA4\x3A\xA6\x30\xA7\xC9\xA3\x62\xA9\x32\xB1\x99\x9A\x4C\x8A\xA6\xE9\xA5\x9F\xA5\xD0\xA4\x4D\xA5\x33\xA7\x8D\x85\x4D\xBB\x9E\x4B\xA6\x39\xA7\xB9\xA0\x69\xAD\x2F\xBF\x99\xB5\x02\xD1\xA6\x80\xA5\xA6\xA4\x79\xA2\x45\xA0\x35\xA7\x9A\xB6\x4C\xDC\xA6\xB0\x9E\xAC\xA6\xA1\xA1\x64\xAE\x34\xB0\x99\x9D\x4D\xFA\xA5\x3D\xA5\xAF\xA6\xAE\xA4\x22\xA2\x36\xAD\x94\xA1\x45\xB1\xA5\x3E\xA7\x82\xA4\x4F\xA6\x20\x0D\x36\xB4\x94\x8E\x4A\xAC\xA5\x71\xA6\x86\xA5\xDD\xA2\x53\xA3\x34\xB7\x98\x9D\x4B\xF4\xA6\x5E\xA7\xB2\xA7\xC8\xA4\x5C\xA8\x2C\xAE\x08\x3B\x4D\xB4\xA6\x64\xA7\xAD\xA7\xDA\xA6\xFA\x97\x38\xB7\x95\xBD\x4C\xBF\xA4\x1D\xA5\x9C\xA5\xE0\xA2\x71\xA3\x1D\xB4\x88\x82\xCB\x0D\xA7\x3C\xA6\x3D\xA4\xE4\xA0\x67\xA8\x39\xAD\x99\x9A\x4E\xC6\xA4\x54\xA4\x82\x01\xE7\xA0\x5A\xAA\x21\xBF\x95\xB7\x4C\xC7\xA5\x1E\xA4\xC3\xA7\xE4\xA3\x42\xA0\x36\xB5\x87\x9E\x4C\xAB\xA7\xB9\xA5\xCA\xA5\xB6\xA7\x75\xA8\x36\xA1\x97\x82\x4E\xA7\xA7\xB4\xA5\x2A\xA4\xE0\xA5\x76\xAF\x2E\xB7\x9D\xAD\x4E\xEC\xA6\xB0\xA6\xD3\xA7\xEF\xA4\x71\xA1\x3C\xA5\x96\xB8", + "\x4E\x84\xA7\xA2\xA7\xE2\xA7\xCB\xA3\x70\xAD\xFC\x83\x9D\xA0\x4B\xBD\xA7\x94\xA7\x1C\xA4\xD0\xA2\x79\xA9\x37\xA1\x9D\x9C\x49\x92\x02\x93\x92\x93\xA7\xDD\xA0\x6E\xAB\x39\xA1\x7D\x99\x4F\xAC\xA6\xA4\xA7\x17\xA6\xF1\xA3\x78\xA0\x00\x1F\x9E\xB3\x4C\x8E\xA7\x9F\xA7\x7B\xA5\xE4\xA6\x7C\xAB\x33\xBE\x9C\xA7\x4A\xDD\xA7\xB9\xA6\x82\x00\xFB\xA2\x68\xAB\x3D\xAB\x96\x89\x4D\xF2\xA6\xD8\xA6\xEA\xA4\xFC\xA0\x79\xA5\x3E\xBA\x9F\xA0\x4E\xD9\x9B\xF3\xA6\xA6\xA5\xE2\xA4\x75\xAB\x38\xBD\x93\x81\x50\xD2\xA6\x5A\xA6\x02\xAA\xEC\xA6\x80\xAE\x3F\xAA\x9F\xB8\x4C\x87\xA8\x59\xA7\x01\xA9\xEC\xA2\x7A\xA5\x0B\x90\xA0\xA3\x4D\x89\xA6\x6A\xA7\x05\xA9\x05\xAD\x81\xA4\x30\xAC\x98\x96\x50\xEE\xA6\xFD\xA3\x6B\xA7\xDF\xA6\x72\xA9\x3F\xBC\x9D\x91\x4B\xD4\xA6\x1C\xA7\x9D\x9F\x07\xAE\x6E\xAF\x36\xB6\x9F\x95\x4D\x85\xA6\x2B\xA8\xBE\xA5\xFD\xA2\x84\xA4\x31\xAE\x9D\x8E\x04\x31\xA8\x88\xA6\x0C\xAA\xEF\xA5\x80\xAB\x41\xA6\xA1\xA5\x4E\xE3\xA7\x3C\xA9\x12\xA8\xC8\xA2\x87\xA1\x3D\xBE\x94\xA6\x45\xC2\xA8\xDA\xA7\x16\xA8\x0D\xAF\x69\xA0\xFB\x98\xA1\xA8\x4F", + "\xEF\xA7\xFF\xA7\xF5\xA4\x07\xAB\x61\xA6\x3D\xB2\x97\x4E\x51\x99\xA7\x50\xA8\x07\xA8\xEA\xA4\xD8\x97\x43\xB3\xA2\xB7\x4F\x8C\xA6\xC2\x65\x2B\xAA\xFB\xA0\x6F\xAB\x3F\xBE\x7E\x88\x51\xE0\xA7\xCF\xA7\x13\xA9\x06\xAC\x82\xA7\x46\xA7\x9F\x98\x51\xE4\xA8\x51\xA9\x07\xAA\x17\xAF\x85\xAE\x41\xB3\xA3\xA9\x50\xCD\xA8\x76\xA8\x8C\xA5\x0F\xAB\x88\xA9\x36\xBB\xA1\x9A\x50\xC7\xA8\x28\x93\x3C\xAB\x08\xA8\x9B\x5E\x43\xA2\x9F\x8B\x4F\xC7\xA7\x74\x81\x57\x58\xFD\xA2\x89\xAC\x2D\xB5\xA1\x94\x44\x8A\xA9\x02\xA8\x22\xAA\x02\xAC\x8D\xA1\x48\xA5\xA4\x84\x4B\x87\xA9\xE4\xA7\x5A\x80\x24\xA8\x81\xA2\x41\xA2\x9E\x81\x51\x95\xA9\x7C\xA8\xDB\xA5\x11\xAE\x5F\xAB\x49\xB1\xA0\x92\x52\x93\xA8\x46\xA8\x50\xA9\x12\xA9\x84\xAD\x48\xAC\xA2\x86\x3D\xA5\xA9\x17\xA9\x3E\xAB\x28\xAE\x6A\xA2\x11\x10\xA5\xA0\x50\xF3\xA4\xDC\xA7\x38\xAB\x16\xAE\x96\xAC\x42\xAC\xA5\xA8\x4C\xE6\xA6\xB0\x9E\x5E\xAA\x0C\xAC\x91\xAF\x4B\xAC\x9E\x83\x3B\xC2\xA9\x39\xA8\x59\xAB\x24\xA9\x95\xA8\x25\xBA\x65\x42\x52\x8E\xA9\xD6\x9E\x64\xAB\x13\xA8\x8E\xAA\x45\xA4\x81\x92\x53\xEF", + "\xA8\xB9\xA9\x6A\xA8\xFF\xA2\x5E\x67\x4D\xA3\xA3\x99\x53\x9D\xA8\xD6\xA7\x6E\xA9\xF8\xA7\x92\xA5\x3D\xA0\x92\xA2\x53\xE9\xA8\x3F\xA8\x4C\xAB\x27\xAD\x99\xA2\xCA\x4F\xA6\xAE\x52\x8F\xA9\xEE\xA8\x60\xAB\x2B\xA9\x9E\xA6\x4C\xBB\x79\x9C\x53\xF4\xA9\x88\xA9\x61\x9F\x3D\xAE\x92\xAF\x38\xBA\xA5\xB1\x4F\xD7\xA7\xAA\xA8\x34\xAA\xBB\xA2\x8D\xAE\x47\xB4\xA4\xAC\x53\x84\xA9\xA1\xA8\xE8\xA7\x32\xAE\x5F\xAA\x49\xB8\xA7\x99\x52\xB5\xA9\x0E\xAB\x75\xAA\x33\xAC\x9F\xA9\x3E\xA0\xA7\xA6\x53\x91\xAA\x7F\xA9\x80\xAA\x1B\xAE\x9B\xAE\x42\xB7\xA3\x81\x48\x8F\x93\x18\xAA\xE9\xA4\x64\x93\x91\xAE\x4B\xA4\x9A\xB2\x53\x85\x02\x23\xAB\x48\xAA\x32\xA8\x95\xAC\x50\xAB\x49\xA1\x54\xCC\xA9\x06\x03\x94\xA8\x27\xAF\x94\xAE\x49\xB9\xA8\x8A\x04\x32\xAA\xA6\xA9\x95\xA9\x4D\xAE\xA0\xA1\x53\xAF\xA9\xBE\x4B\xB8\xAA\xB1\xA8\x51\xAB\x42\xAC\x96\xA0\x52\xB4\xA8\x99\x51\x96\xAA\x91\xA6\xA0\xAB\x2D\xAB\x6A\xAB\x46\xB0\xA9\xA8\x54\xBE\xAA\x44\xAB\x9B\xA8\x54\xA8\x7F\xA5\x54\xA9\xA8\x84\x54\xB3\xA9\x54\xAA\xA9\xAA\x51\xAC\x9A\xA8\x54\xB8\x99\x82\xCB\x4A\xAA", + "\xBD\xA8\x5C\xA9\x47\xAA\x8F\xAE\x52\xBB\xAA\x9F\x53\xD4\xA8\xD9\x9A\xB0\xAB\x30\xAD\xA4\xAE\x37\xB0\xA6\xBD\x49\xF2\x65\x6A\xAB\x64\xAA\x50\xAC\xA5\xA1\x55\xBD\xA9\xA6\x55\xE3\xAA\x83\xA9\x3E\xA5\x5C\xAB\x9A\xA7\x56\xBF\xA2\x96\x4F\xDF\xAA\x53\xAA\x86\xA7\x5E\xA8\x9B\xA8\x57\xAE\xAB\xB5\x02\x83\xAB\x1C\xAB\x25\xAB\x49\xAB\x5D\xA5\x56\xB6\xAA\xA9\x53\xE5\xA9\x91\xA6\xB8\xA9\x60\xAF\xAF\xAD\x58\xAB\xA5\xA2\x55\x8A\xAB\xF5\xA8\x12\xA5\x55\xAE\xB2\xAC\x54\xA5\xA8\x8E\x55\x84\x02\x88\xAB\x71\xA9\x3F\xAA\x9B\xAD\xFC\x81\xAD\xA8\x53\x86\xA9\x90\xAA\x9C\xA6\x69\xAB\xA0\xAF\x58\xA5\xA3\x83\x3B\xAB\xAB\x08\xA6\x9D\xA8\x10\xAE\xA6\xA6\x57\xAE\xAC\xA8\x56\xAE\xAB\xE0\xA0\x85\x03\xCD\x82\x21\x0F\x58\x8A\x08\x0C\x17\x82\xAA\xB1\xAB\xB9\xAB\x4E\xAC\x4F\xAF\x5B\xBB\xA8\xA2\x56\x95\xAA\x68\xAA\x0E\x9D\x71\xAD\x7D\xA7\x5C\xA7\xAA\x89\x57\xB8\xA6\xCB\xAA\x92\xAB\x65\xAD\x95\xAB\x58\xBD\x93\x91\x57\xAA\xAA\xC2\xAB\xD9\xA8\x4F\xAB\xDE\x33\x59\xA0\x92\x97\x57\xB3\xAA\xB2\xAA\x75\xAB\x02\xAF\xBB\xA9\x53\xB9\xAE\xA2\x57\xDB\xAB\x3C", + "\x3F\xEE\xA9\xE4\xA4\xBC\xA1\x54\xAA\xA8\xB4\x55\xD9\xAA\x06\x02\xF6\xAB\x52\xA9\x81\xAF\x5E\xAC\x98\xB2\x57\xE1\xAA\x9D\xAA\xAC\xAA\x7D\xAA\xBD\xA0\x5D\xBC\xAF\x9B\x51\xC2\x65\xF7\xAB\xB5\xAB\x74\xAD\x98\xA9\x4F\xBB\x79\x81\x58\xF2\xAA\xEE\xAB\xE1\xAA\xBF\xA7\xC0\xAC\x57\xA5\xAC\xAF\x53\x8C\xAB\xD1\x18\xFF\xAB\x3F\xAC\xC1\xA4\x58\xB8\xAC\x85\x58\xB0\x9F\x14\xAD\xC4\xA8\x75\xA9\xB3\xAF\x51\xBE\xAD\x92\x58\xFC\xA7\x19\xAD\xE6\xA8\x57\xAF\xB9\xAB\x45\xA1\xB1\xA7\x56\xE4\xA9\xB8\xAB\x16\xA1\xA7\x2F\xC3\xA2\x2F\xB1\xB0\xB7\x55\x96\xAC\x0F\xAB\xDA\x9B\x8A\xAF\xC5\xAB\x61\xB7\xB0\x9D\x58\xF1\xAB\x2C\xAD\x61\x9E\x89\xAC\xB5\xA7\x5B\xBE\xA7\xA0\x58\xB9\xAC\x06\xAC\x20\xAC\x86\xAA\xC8\xA6\xF4\x9B\xB1\x81\x57\x89\xAC\xDA\xAB\xCF\xA8\x40\xAA\x21\x06\x94\x72\xAE\xB9\x57\xC3\xAA\x05\xA7\x26\xAC\x76\xA8\xC9\xA7\x5E\xBC\x93\x92\x59\xE0\xAB\xE6\xAB\xD4\xAB\x16\xAF\xCA\xA5\x5E\xB4\xB2\x9A\x59\xFF\xA9\x5C\xAD\xF6\xAB\x55\xA8\xCA\xAC\x30\xA1\xB3\xB3\x57\x9D\xA9\x49\xAD\x96\xA9\x5C\x74\xC8\xA5\x10\x06\xB3\xB8\x57\xF4\xAB\x0A\xAD", + "\xBA\xA9\x9B\xAC\xCD\xA6\xFD\x8E\xB3\x82\x58\xCF\xAC\xF5\xAA\xEB\xA6\x9D\xA8\xC1\xA3\x66\xB9\xB3\x80\x49\xFB\xAC\x0D\xAC\x18\xAE\x44\xAB\xCE\xA4\x63\xA4\xB0\xB1\x58\xCC\xAC\x74\xAD\x7F\xA6\x44\x00\xD0\xA5\x61\xB5\xB1\x87\x5A\x86\x02\x8C\xAC\x0D\xAE\xA1\xAD\x80\xA1\x69\xA2\xB1\xBD\x55\xF4\xA8\x55\xA9\x45\xAD\xA2\xAD\x16\x85\x69\xA7\xB1\xA3\x56\xDD\xAA\x5B\xAD\x4D\xAC\x20\xA8\xD1\xA5\x68\xA6\xA9\x9C\x58\x94\xA2\x9D\xAC\x1E\xAC\x8A\xAE\xC7\xAD\xFC\x89\xB5\x87\x59\xFD\xAC\x71\xAC\xF8\xA9\xE1\xA4\xD4\xA6\x5B\xAB\xB5\xA4\x56\xFA\xA9\x9A\xAD\x52\xAD\x5B\xAF\xC1\xAA\x68\xAB\xB3\xBA\x5A\x9B\xA6\x64\xAA\x19\xAE\xAF\xAD\xD6\xAF\x69\xA4\xB1\xA0\x59\xA2\xAD\xC3\xAC\xCE\xA8\x9C\xA9\xCD\xA2\x67\xAC\xCA\x48\x5B\xB4\xAD\xCA\xAC\x34\xAD\x95\xAA\xCD\xA0\x6D\xA0\xAE\x89\x46\xCE\xAB\x7E\xAA\x7C\xA7\xB7\x34\xD8\xA8\x5C\xB9\xB6\x9C\x38\xAD\x8E\xD1\xAC\x9A\xA8\xB3\xAD\x60\xA0\x6E\xB6\xB6\xB1\x47\x8E\xAD\x83\xAC\x82\x01\xB9\xAE\xB8\xAE\x69\xBD\xB6\x98\x5A\xC0\xA4\xEB\xAC\xE6\xA9\xBB\xA8\xDB\xAF\x6E\xB1\x9C\xB1\x5B\xCE\xAC\xCB\xAD\x69", + "\xAD\xB3\xA8\x00\x07\x6F\xB3\xB2\xB0\x5A\xE3\xAD\x11\x9F\x7E\xAC\x96\xAE\xCB\xA9\x62\xA6\x7A\x82\x5C\xDD\xAC\xFF\xAC\x7D\xAE\xAC\xAA\xDD\xAF\x6C\xA0\xB5\x0D\x5C\x85\x02\x07\xAE\x31\xAD\x6B\xAC\xD5\xA3\xEC\x91\xB8\xA7\x59\xE2\xAD\x0A\xAE\x86\xA6\xC5\xAF\xCD\xA2\x6D\xBF\xB2\xBC\x4F\xC2\x65\x1B\xAF\x3B\xAD\xBE\xAE\xE3\xAD\xFC\x81\xB9\xBC\x59\x93\xAE\xB7\xAC\x87\x02\xC9\xA9\xD0\xA8\x6E\xB4\xAD\xB3\x5A\x8E\xAE\xBF\xAC\x14\xA9\xB0\xAA\x21\x0B\x72\xAD\xB4\x93\x5A\xAE\xAE\x0C\xAF\x98\xAD\x53\xAC\xDA\xAB\x25\xB5\xB9\x92\x5A\xA6\xAD\x36\xAC\x8A\xA2\xCF\xAE\xD2\xAE\x60\xB5\xAE\xB5\x02\xC3\xAE\xF3\xAD\x11\xAE\xB7\xA8\x67\xA2\x2F\x68\xBA\xAA\x5A\xC5\xAD\x4B\xAF\x2D\xA9\xD3\xAF\xE1\xAE\xF1\x8A\xB9\x94\x5D\xCB\xAC\x30\xAE\x6E\xAC\xBD\xAE\xA3\xA2\x74\xB7\xBA\x8E\x5D\xAF\xAD\x28\xAE\x50\xAF\x3F\xAF\xEB\xA7\x6D\xAA\xBA\xB5\x5B\xB8\xA6\x64\xAF\x73\xAF\xCD\xA8\xBD\xAC\x6F\xB7\xBA\x82\xCB\x29\x8E\x06\x02\x98\x8E\x42\x00\xEE\xAE\xC4\x4E\x08\x05\xDF\x74\xAE\xFB\x56\x85\x00\x43\x58\xEF\xAD\xBF\x43\x30\x92\x04\x7C\xAE\xDA\x57\x34\x48", + "\xE0\xAA\x22\x00\x74\x93\xBB\x92\x04\x5A\x57\xFA\x45\xC1\xAE\xDD\xAF\xEF\xA7\x78\xBE\xEE\x05\x04\x0A\xAF\xC8\x44\x83\x00\xE4\xAE\x20\x04\x27\x73\xBC\x85\x04\x21\x91\x92\xAF\xC6\xAD\x8E\x94\xF1\xAC\xBD\x52\x08\x29\x21\x86\xAF\x9D\xAF\x2E\x4A\x43\x06\xF2\xAB\x86\x9C\xBC\xA1\x09\x86\x02\xC6\x94\x00\x00\xE9\xA8\x8D\x46\x7A\xA6\x08\x1A\xAF\x29\xAF\xAB\xAE\x09\x95\xE6\xA9\xF4\xAA\x10\x10\x51\x86\x04\x0E\x94\x0A\x02\xB9\xAF\xED\xAA\xF3\xAA\x10\x05\xBE\x78\x5E\xAE\xAF\x7E\xAE\x87\x03\xEF\xAD\xEE\xAA\x77\xB2\x08\x03\x5F\xF9\xAE\x41\x48\xE3\xAC\xEF\xA9\xF0\x3A\x7C\xB4\xBD\x84\x9B\x42\xAF\xCB\xAF\x82\x02\xEF\xA9\xFA\xA5\x34\x4A\x08\x07\x5F\xFD\xAE\xF5\x3A\xE8\xAE\xF3\xAD\x20\x04\x27\x77\xBE\x9A\xAF\x18\xAF\x05\x02\xEF\xAE\x44\x01\xF5\xA2\x7E\xAE\x08\x1F\x5E\xBB\xAF\xDB\xAF\x48\x4A\xF6\xAF\xF4\xA5\x10\x19\x50\xA1\x5F\xD4\xAF\x00\x00\xF2\xAC\xFC\xA9\x8D\x45\x7E\xA9\x55\x8D\x5F\xEC\xAF\x04\x02\xD9\xAF\xFB\xA9\xFD\xA0\x00\x16\xBD\x85\x04\x79\x8A\xF8\xAD\x8E\xAD\xC1\xAF\xFF\xA9\x68\xA0\xC0\xBE\x5B\xE1\xAE\xC6\xAC\xFE\xA6\x01", + "\xB3\xE0\xA9\x70\xA4\xB9\x83\x3B\x8B\xB0\x08\xAE\x04\xB1\xD4\xAF\x9F\xA0\x81\xB2\xB8\xBD\x58\xA9\xAE\xB0\x9F\x0A\xB3\xC5\xA9\xBC\xAE\x80\xAE\x08\x1A\x60\x9C\xAE\x18\xAF\x0E\xB1\x06\xB7\xEA\xAF\x81\xA2\xB9\x82\x60\x94\xAE\x3B\x9F\x12\xB3\xC9\xAF\x02\xB2\x76\xAA\xC0\xA4\x60\xAF\xB0\x3A\xAE\xCF\xA8\xCF\xAA\x77\xA4\x80\xB1\xC1\xBA\x57\xD6\xA7\x2A\xB0\x96\xAF\xDA\xAC\x4F\xA9\x83\xB6\xB9\x80\x5D\x8F\xAD\x2F\xAF\x1A\xB2\xD6\xAE\xEC\xAC\x75\xB6\x7E\xBD\x60\xBF\xAE\xBB\xAC\xA3\xAE\x44\x07\x08\xB4\x74\xA2\xB4\xB8\x5C\xD8\xAE\x42\xB1\x70\xAC\x07\xB3\x00\xB6\x84\xB0\xC1\x83\x61\x97\xAD\x45\xB1\xB7\xAB\x12\xB7\xEA\xA2\x2F\x6C\xC2\x89\x5D\xD8\xB0\x33\xAF\x2D\xA6\x17\xB7\xE9\xAE\x6E\xB9\xC2\xB3\x4D\xD1\xB0\xE6\xAD\x4D\xA4\xB0\xA9\xAF\xA5\x0B\x83\xC3\xA0\x5D\xAC\xB0\x09\xB1\xE6\x9E\x1B\xB5\xEC\xA0\x86\xAC\xC3\x9B\x61\xB6\xB0\x64\xAC\x1C\xB2\x15\xB2\x0A\xB9\x65\xB4\xC2\xBD\x5A\xBC\x4A\x89\xAD\xA4\x49\x00\xB1\x04\xBE\x87\xA2\xC4\x87\x60\xF0\xB0\x13\xB0\xFE\xA6\x21\xB4\x01\xB2\x81\xA7\xBB\x9B\x51\x8B\xB1\x11\xB0\x44\xB2\x23\xB7", + "\x9F\xA0\x89\xB6\xC0\xB6\x5A\xAD\xB0\xCD\x9F\x4A\xB3\x06\xB5\x0F\xB8\x82\xA0\xC4\xB8\x61\xFE\xAC\x91\xA6\x4D\xB0\x08\xB3\x0A\xBD\x89\xA6\x7A\xA2\x62\xA6\xB0\x84\xB1\x52\xB0\x45\xA7\x14\xBB\x82\xB7\xC4\xB1\x61\xC3\x9D\xAC\xB0\x1D\xB3\x0F\xB1\xDD\xAC\x55\x57\xC2\x85\x5D\xA7\xAD\xD6\x9F\x58\xB2\x0F\xB1\x09\xB8\x8B\xBF\xC3\x88\x95\x57\xAE\xBA\xB0\x24\xB3\x1A\xB6\xAD\xA1\x8C\xAD\xC2\xAD\x5C\xEC\xAE\xF2\x65\x62\xB3\x17\xB7\x16\xB1\x74\xB9\xC5\x80\x63\xEE\xAE\x18\x4B\x67\xB3\x27\xB1\xD6\xAC\x30\xAA\xC6\xA4\x61\xDB\xAE\x61\xB1\x20\xB0\x4C\x4C\x0B\xB1\x8D\xB3\xC6\x80\x5C\x94\xAB\x0E\x02\x6B\xB3\x1B\xB6\x15\xB9\x88\xA6\xA3\xA1\x63\xD2\xB1\xB6\xB0\x27\xB0\xDB\xAA\x1C\xB4\x87\xAC\xC6\x80\x61\xDB\xB1\xDE\xB1\x8C\xAE\xF5\xA4\x1D\xBA\x76\xB3\xC5\x8F\x61\xF4\xB1\x6A\xB0\x99\xAE\x1D\xB2\xD8\xAA\x10\x0E\xA2\x43\x62\xA4\xB1\x18\xB0\x83\x02\x3F\xB7\x10\xB4\x8E\xB3\xC4\xAF\x41\x83\xB2\x8C\xB0\x49\xB2\x19\xB6\xF4\x31\x8F\xA2\xC1\x86\x3D\x88\xB2\x91\xB1\x82\xB3\x42\xB6\x21\x00\x91\xB6\xC4\x90\x5D\x86\xB2\xCD\x9F\x8A\xB3\x26\xB4\xE0", + "\xAA\x8A\xA4\x08\x1A\x64\xA3\xB1\x9C\xB1\x80\xB0\x45\xA7\x23\xB8\x8A\xA0\xC8\x98\x62\xC3\x9D\x24\xB3\x56\xB3\x45\xB3\x22\xBD\x8F\xB7\xBA\xA9\x64\xB2\xB1\xBC\xB1\x66\xB1\x9F\xA7\x25\xBB\x8B\xA3\xC6\xBC\x5A\xB5\x81\x34\xB2\x61\xB2\x3E\xB6\xB0\xA3\x6A\xA2\xC8\xAE\x64\x89\xAD\x39\xB2\x63\xB3\x0E\xB3\x06\xB9\x3A\xAD\xC9\x8D\x64\xFE\xB0\x38\xB3\x9F\xB3\x51\xB5\x23\xBE\x8B\xA5\x08\x01\x65\xCB\xB1\xEA\xB0\x25\xAF\x53\xB7\x1A\xB4\x84\xB9\xC6\x9E\x64\xDC\xB1\x14\xB2\xAC\xB2\x51\xB1\x1D\xB7\x8C\xAA\xB2\x82\xCB\x53\xB2\xE3\xB1\x95\xB2\x55\xB0\x0A\xB7\x95\xAB\xCA\xA2\x64\xD6\x9F\x60\xB3\x76\xB1\x54\xB4\x28\xB0\x00\x09\xCB\xB5\x63\xB1\xB2\xEF\xB1\xB6\xB2\x52\xB4\x2B\xB3\x94\xBB\xB7\xAE\x65\xF9\xB1\x3B\xAF\x7D\xAE\xB0\x65\xC6\x4F\x8F\xA1\xC9\xA7\x64\xEF\x4B\x66\xB3\xBF\xB2\x88\x4F\xEA\xAC\x97\xA4\xC8\xA2\x65\xFB\xB1\x83\xB3\xC0\xB3\x2B\xB3\xE7\x95\x98\xA9\xC8\x92\x64\xE3\xB2\x8D\xB3\x88\xB3\x61\xB6\xAD\xA1\x99\xB6\xC8\xA5\x61\x90\xB3\x84\xB3\xCC\xB2\x62\xB5\x1C\xB3\xEC\x95\xCC\x9B\x64\x8D\xB0\x48\xB2\x89\x02\x67\xB0\x24\xBC", + "\x91\xA7\xCB\xBD\x49\xA3\xB3\x25\xB2\xBF\xB3\x62\xB2\xB3\xA9\x98\xB4\xCB\xB6\x63\xEC\xAE\xA8\xB2\x95\xB3\x65\xB1\xAF\xA1\x9B\xB0\xC9\xB6\x64\xCA\xB0\x57\xA5\x0E\x6B\x66\xB0\x23\xBD\x99\xBA\xCC\xAE\x66\xF0\xB2\xB4\xB1\xBD\xB2\x6F\xB4\x0F\xB5\x9A\xA2\xCC\x86\x3D\xB5\xB3\x35\xB3\x9D\xB3\x4D\xB3\x65\x62\x9A\xBA\xCA\xBA\x66\xBF\xB3\xB7\xB3\x5E\xB3\x19\xB2\x82\x6B\x9B\xAC\xC9\x9B\x49\xC8\xB3\x3A\xB3\xBC\xB3\xC2\xA8\x8B\x63\x9C\xA9\xC3\xBD\x4D\xD1\xB3\x32\xB3\x5A\x80\x76\xB2\x28\xBF\x9A\xAA\xB2\xA3\x67\xD0\xB2\x5D\xB2\xB6\xB3\x79\xB4\x2A\xB5\x87\xBC\xC9\xBC\x63\xD8\x3A\x12\x02\x70\x88\x00\x02\x3E\xB4\x9F\xB1\xCF\xB6\x67\xF4\x3A\xF7\xB3\x59\x11\x7E\xB0\x3E\xB8\x9F\xBD\xCF\xBA\x67\xFE\xB3\x06\x02\x4C\x5B\x73\x9C\x34\xB0\x9A\xAC\xCA\x82\x68\x89\xAD\x07\xB5\xEA\xB3\x58\xB1\x41\xB0\x9D\xAA\xCE\xB8\x66\x8A\x02\x0C\xB4\xE2\xB1\x81\xB6\x34\xB5\x0B\x91\xD0\x9E\x67\xB3\xA8\xE9\xB3\x7D\xAE\x85\xB4\xDD\xAC\x9E\xAE\xC7\x85\x50\x9B\xB4\xF2\xAD\x0E\xB7\x5A\xB2\x43\xBC\xDF\x89\xCE\x9A\x67\x8C\xA6\x20\xB5\xBE\xB1\x71\xB3\x35\xB6\xF4", + "\x89\xD1\x86\x66\xB3\xB3\xEE\xB2\x08\xB5\x89\xB1\x3B\xB2\x83\xA4\xD1\x80\x35\x92\xB3\x30\xB5\xE5\xB3\xF8\x33\x46\xB4\x9E\xA0\xCE\x8F\x61\xC2\x65\x2E\xB4\xC7\xB3\x64\xB2\x47\xB2\xA3\xB7\xD1\x96\x66\xD8\xB1\x79\xAB\x20\xB4\x8E\xB0\x49\xB1\xA3\xAD\x89\xBB\x68\xC6\xB4\x9F\xB3\x46\xB2\x75\xB5\x20\x0A\xA4\xA7\xD2\x95\x65\x88\xB3\x01\xB4\x1E\xB4\x7A\xB5\x2E\xBB\x9D\xA0\xD2\x9A\x69\xA2\xB4\x19\xB5\xED\xB1\x95\xB1\x4A\xBA\x90\xAB\xD0\x9F\x69\xE1\xB2\x39\xB5\x07\xB6\x93\xB5\x48\xB1\xDF\x96\xD2\xAD\x67\xC4\xB4\x6B\xB5\x2C\xB4\x94\xB4\x40\xB2\xA5\xA3\xCB\x9E\x69\xF3\xB4\xA9\xB3\x15\xB4\x67\xB1\xB7\xA2\xA7\xAD\xD3\xA4\x69\x8F\xB3\x58\xB4\x2A\xB7\x99\xB2\x2D\xB1\xA6\xA8\xD1\x83\x6A\xEF\xB2\xE0\xB3\xB8\xB3\x98\xB4\x4E\xB5\xA6\xA1\xD4\x84\x04\x0B\xB5\x79\xB5\x09\xB6\x71\xB4\x22\xA0\xA9\xB2\xCD\x8C\x69\xF0\xB4\x34\xB0\x82\x01\xA6\x81\xD1\xAB\xA9\xAA\xD0\xB9\x55\x9D\xB5\x0D\xB5\x13\xB6\xF5\xA0\x54\xB2\xA1\xB5\xD3\x8E\x6A\x80\x00\xA4\xB5\x0B\xB4\x31\xAD\x3C\xBC\x96\xA9\xD5\x9C\x68\xE8\xB4\x97\xB4\x35\xB5\x41\x06\x55\xB1\xA2\xB0", + "\xD5\x97\x69\xEE\xAA\xB4\xB4\x15\xB6\xA4\xB4\x45\xB4\x11\xB9\xD5\xAF\x68\xB1\xB5\xD2\xB3\x41\x63\xA1\xB0\x2F\xB5\xA3\xBB\xCE\xBE\x6A\xC2\xB4\x69\xB5\x60\xB7\x10\x9B\x58\xBF\x9D\xAE\xD0\x8A\x6B\x8A\x02\xC7\xB5\x25\xB7\xAD\xB0\x53\xBA\xA9\xAC\xD6\x98\x68\xDC\xB4\x60\xA8\x61\xB4\x9E\xB6\x52\xB3\xAD\xB2\xD5\x95\x6B\xDB\xB5\xB6\xB2\x67\xB6\x4C\xB1\x5A\xBE\xA6\xBE\xD0\x8F\x61\xF2\x65\xE4\xB5\x3F\xB7\x90\xB6\x5B\xB8\xAA\xB6\xD6\xAB\x6A\xBE\xB4\x6C\xAF\x74\xB4\xA3\xB0\x50\xBD\xA4\xB9\xD4\xAD\x6B\xE0\xB5\x26\xB5\x62\xB4\xC3\xA2\x5E\xB1\xA9\xA6\xD5\xB5\x6B\xDF\xB5\x7E\xB5\x79\xB7\xBA\xB7\x59\xB1\xA7\xB3\xD5\xAE\x6B\xEC\xAA\x89\xB4\x5A\xB0\xBA\xB7\x60\xB3\x60\xAC\xD5\xBA\x65\xDA\xB5\x01\xB7\x7E\xB5\xA3\xB7\x5F\xB4\x96\xB7\xD7\x91\x6C\xDC\xB5\x6F\xB4\x76\xB4\xBF\xB0\x63\xB6\xAE\xB1\xD7\x8C\x6C\xF8\xAC\xD4\xB1\x51\xB7\xC7\xB3\xE4\xA1\x9A\xAB\xD6\xB8\x6B\xB4\xB4\x37\xB0\x20\xA7\xC6\xB1\x5C\xB2\xAA\xBA\xB6\xA8\x85\x17\xB6\x2C\xB6\x7D\xB6\xF0\x9B\x2F\x43\xA0\xB2\xD8\xB4\x6B\xBC\xAD\x34\xB7\xAB\xAD\xCE\xB6\x53\xB4\xB1\xBB\xD9", + "\xA1\x6A\xB2\xB6\x40\xA4\x9F\xB5\xA9\xB3\x62\xB4\xAD\xA0\x00\x02\x6D\xAA\xB5\x08\xB6\x71\xB4\xF9\xA7\x68\xBF\xAA\xA4\xD4\x98\x6B\xD6\xA7\x4C\xB7\x5A\xB6\xD3\xB6\x61\xBB\x9D\xB1\xDA\xBA\x6A\xFE\xB5\x45\xB6\xAB\xB7\xAF\xB5\x5B\xB4\xB0\xA5\x08\x1A\x6D\xC8\xB5\xC0\xB5\xF0\xB0\x54\x40\x66\xB9\xAF\xA9\xD9\x91\x4E\xDF\xB6\xD2\xB5\x8C\xB5\xD7\xB5\xEA\xA7\x29\x87\xD9\xBD\x68\x89\xB6\x4F\xB0\xB4\xB5\xB9\xB3\x44\xB5\x30\xB2\xDB\xAA\x6B\xC9\xB5\x62\xB7\xDC\xB2\xD7\xB3\x64\xB7\x82\xB4\xD0\xA3\x6D\xC2\x9B\x43\xB7\x9B\xB4\xBB\xB6\x6E\xB2\xB0\xB8\xDB\xB1\x65\xC2\x65\x84\xB6\x9B\xB7\xC0\xB1\x6F\xBD\xB6\xA4\xDB\xA8\x6C\xF9\xB0\x41\xB6\xBE\xB5\x2A\xB6\x6F\xBA\xB7\xA4\x08\x09\x6E\x9C\xB6\x74\xB6\x86\xA6\xBC\x67\x72\xB1\xB3\xA6\xDB\x9E\x55\xFF\xB6\xCE\x9A\x68\xB3\xCB\xB0\x70\xB8\xB4\xAD\xD8\xB0\x6B\xCA\xAC\x9C\xB7\xB2\xB4\xE4\xB7\x6C\xB2\xB9\xA6\xC9\xBC\x6A\xD6\x9F\xA9\xB7\xC7\xB4\x28\xB0\x67\xA1\xBB\xAF\xDB\x8A\x6D\xB4\xB1\xB5\xB7\x2D\xB4\xD5\xB1\x5B\xB5\xDA\x4D\xDD\xAA\x66\xFB\xB4\x0A\x03\xE4\x59\xCD\xB0\x73\xB5\xA8\xA2\x7E\x82", + "\x6F\xD7\xAE\xC7\xB6\x9E\xB5\xD1\xB1\x79\xBF\xB3\xBE\xDC\x9B\x51\xCC\xB7\x81\xB7\xC5\xB5\x5C\xB0\x7A\xB5\xBA\xA0\xD9\x9F\x63\xD9\x9B\xD4\xB7\xA6\xB4\xA2\xB7\x76\xBF\x84\xB9\xDE\x92\x6D\xDB\xB7\x2D\xB7\xC8\xA6\xF7\xB7\x6A\xB4\xB4\xAC\xD7\xA3\x6F\xDB\xB6\x6A\xB6\xC6\xB6\x41\x07\x7C\xB0\xB6\xBC\xDA\xAA\x6F\x85\x02\xEC\xB7\xB4\xB5\xC7\xB2\xC9\xA1\xBF\xB3\xDB\x85\x6F\xAE\xB6\xC1\xB6\xDF\xB6\x9E\xB4\x37\xBB\xF3\x95\xDF\xB7\x6D\xE1\xB6\xE4\xA6\xFF\xB5\xE1\xB0\x80\xBA\xB0\xB2\x08\x02\x70\x8A\xB7\x86\xB6\x5A\xB3\x01\xBC\x78\xBF\xB4\xA0\x92\x8B\x70\x9D\xB7\xAB\xB7\xCF\xB5\xEF\xB6\x6D\xBA\xBB\xA7\xDD\xAC\x65\x8F\xB8\xAA\xB7\xD9\xB7\xF3\xB2\x7F\xBB\xAB\xA0\xDE\xB6\x50\xF9\xB7\x14\xB8\x30\xB5\x03\xB9\xB2\xA6\xC0\xBC\xE0\x98\x6D\xEC\xB5\xC2\x64\x0C\xBA\xEC\xB1\x64\xB8\xBF\xAB\xDF\xA6\x70\xE5\xB7\x6B\xB6\xFE\x5B\x0B\xBA\x70\xB1\xC3\xAA\xE1\xB6\x6E\xE1\xB7\x38\xA6\x1B\xB9\x05\xB8\x6E\xBC\x76\xBA\xE1\xA2\x70\xBB\xB7\xD6\xA6\x1F\xBA\xAD\xB1\x7D\xB7\xB8\xAD\xE0\x24\x6F\xB4\xB8\x32\xB3\x08\x37\x11\xBA\x7A\xB5\x40\xAA\xE2\xA8\x6F", + "\xF3\xB7\x6C\xB2\x27\xB9\xFB\xB4\x88\xB4\x8B\xB2\xE2\xB2\x6F\x99\xB7\xD6\xA6\x2B\xBA\xFD\xB3\x84\xB8\x33\xBA\xE2\xBF\x6F\xEE\xB7\xE4\xA6\x2F\xBB\x00\xB8\x8C\xB5\xC5\xB7\xBA\xA2\x71\x88\xB8\x04\xB9\x27\xB3\x19\xBC\x81\xB0\xC4\xA0\x92\xAB\x71\x90\xB8\x1A\xB9\x7F\xAB\x1B\xB9\x83\xBC\xC2\xB1\x9C\xB3\x71\xAB\xB8\xD7\xB7\xC8\xA6\xB0\x67\x8E\xB7\xC3\xA0\xDA\xB6\x71\x89\xAD\x7C\xB9\x1D\xB8\xF7\xB0\x19\xB6\xC4\xAF\xE2\x98\x71\xEE\xB8\x66\xB8\xD1\xB7\x07\x3B\x89\xB9\xC0\xAA\xE3\x89\x72\xCA\xB7\xEC\xB4\x79\x65\x20\xBF\x87\xB6\xC1\xBB\xB7\x92\x72\x8A\xB9\x59\x39\xEF\xB4\xB1\xB6\x79\xBF\x4F\xBB\xE3\x8F\x72\xCD\xB7\x11\xB9\x2D\xAB\x24\xBB\x88\xB0\xC5\xBB\xB7\xA3\x72\xD3\xB6\x95\xB9\xED\xB3\x29\xB8\x7C\xBE\xC7\xBD\xE2\x98\x72\x85\x02\xB7\x8C\x50\xB9\x1C\xBF\x0D\xA1\xCB\xB1\xDE\x8D\x72\xD2\xA7\xB5\xB9\xEA\xB4\xC9\xB4\x29\xB5\x0B\x99\xE5\x9A\x6F\x9B\xB9\xA1\xB9\x7F\xAA\x2F\xBA\x93\xBD\xAC\xB8\xE1\x9B\x51\xC3\xB9\x8C\xB9\x34\xB8\xDB\xA8\x99\xB6\xC8\xB7\xDF\x9C\x38\xCC\xB9\x53\xB9\x52\xBB\x76\xB0\x9A\xB7\xC5\xAE\xE6\xB8\x4C\xD4", + "\xB9\x5B\xB9\x36\xB9\xE4\xA0\x9B\xBF\xC5\xB4\xE2\x8F\x61\xDC\xB9\x63\xB8\x6F\xBB\x32\xBF\xEA\xA0\xCE\xA8\xE3\xA4\x71\xBF\xB4\x12\x03\x72\xB8\x1B\xB9\x95\xBC\x30\xAA\xE7\xB0\x71\xF5\xB8\x4C\x9C\x77\xB8\x1D\xB9\x8F\xBC\x74\xA9\xE7\xA4\x73\xF7\xB9\x90\xB9\x18\xBA\xB0\x62\x9E\xB8\xC7\xB2\xC7\x80\x49\xFC\xB9\x7D\xB8\x4E\xB8\xFF\xA0\xA0\xB2\xC8\xA6\xE6\xBF\x53\xF2\x65\x04\xBA\x4A\xB8\x0F\xBA\xC9\xA8\xD0\xAF\xE5\x84\x04\x09\xBA\xA4\xB9\x43\xBA\x1E\xBE\x9E\xB9\xCF\xAF\xDF\x8F\x74\xF8\xB9\xB2\xB8\x78\xBB\x31\xB8\xA3\xB6\xCB\xAA\xE6\x8A\x59\x90\xBA\xA8\xB9\x85\xB8\x5B\xB2\x58\x61\x59\x99\xE8\xB4\x73\xA1\x9F\x25\xBB\x8E\xBB\x39\xBA\x7A\xA9\xD2\xBA\xE5\xBD\x6D\x93\xB5\xD6\x9F\x96\xBB\x2F\xBD\x98\xBD\xCA\xBB\xA2\xB2\x74\xC4\xB9\xD7\xB4\x6D\xB8\xCE\xA7\xA6\xB9\xCC\xAB\xE9\x8A\x59\xBC\xBA\xCD\xB8\x2E\xB8\x4A\xBF\xEA\xA0\xD4\xB1\xE6\x92\x74\xBB\xBA\x44\xBB\xA4\xB9\x45\xB9\x2E\xB5\xD4\xB5\xE6\x82\x75\xFF\xA9\x4D\xBB\x6C\xB8\x3B\xB8\x1C\xBA\x10\x11\xEA\x9D\x73\xD2\xB9\x0C\xA6\xAB\xB9\x38\xB8\xAB\xB2\xFC\x9A\xEA\xA6\x73\xE2\xB9", + "\x0C\xBA\x89\x02\x57\xBB\x9D\xB2\xD2\xBB\xB7\xA3\x75\xEF\xB9\x27\xBA\xA8\xBA\x43\xB8\x00\x07\xD6\xB3\xE7\xBE\x73\x91\xA7\x6D\xBB\x7E\xBA\x43\xB4\x22\xA1\xD7\xA1\xE8\x81\x73\xDB\xA9\x62\xBA\xE7\xB1\x41\x05\xAE\xB5\xD0\xB5\xE9\x9D\x72\xF9\xBA\x4B\xBB\xE0\xB0\x60\xBE\xA4\xBF\xD6\xA8\xEA\x81\x76\xCF\xB0\x7C\xBA\x85\xBB\x20\xBF\xA7\xBA\xD4\xA4\xEC\xB3\x75\xB1\xBA\x6B\xBB\xEB\x4D\x4F\xB8\xAC\xBE\x2F\xB2\xEC\x81\x75\xBA\xBA\xA1\x9E\xCB\xBA\x51\xBE\x9A\xBB\x45\xBA\xEC\x8E\x75\x98\xBB\xFF\xA8\xCF\xBA\x54\xBD\xAC\xBB\x9D\xA2\xED\x97\x75\xC7\xBA\x9D\xBB\x44\xAE\x69\xBB\xAB\xB8\xDA\xA1\xED\x97\x5D\xAB\xBB\x5F\xBA\xAE\xB8\x90\xA0\xB6\xB4\xD6\xAB\xEC\xAC\x65\xB4\xBB\x68\xBB\xC2\xB9\x6A\xBF\xB0\xBC\x76\xB8\xED\xAE\x75\x8F\xBB\x4D\xB3\xB1\x4F\x6B\xBA\xB5\xBA\xD7\xA2\xEE\xBC\x76\xCA\xAC\xBE\xBA\xB9\xB9\xC9\xB7\x27\x51\xD9\xA3\xEE\x87\x77\xB7\xBB\xC5\xBA\x4E\x52\x63\xBB\xB9\xB5\xB0\xA6\xEE\x93\x77\xBC\xB9\x3D\xB3\x82\x01\x72\xBE\xAE\xB3\xCB\xA6\xC7\x8C\x77\xCF\xBB\xFB\xAD\xED\xB9\x5F\xBA\xA0\xBD\xFC\x82\xEF\x8A\x76\x86\xBA\xFC", + "\xA6\xF3\xB9\x44\xBC\xB3\xBE\xDA\xA0\xEF\xA5\x76\xEB\xBA\x95\x8A\x97\xBB\xE4\xB0\xA6\xB0\x00\x11\xEF\xB3\x74\xB9\xBA\x53\xBB\xEC\x9A\x7D\xB8\xA7\xBF\xAE\xA4\xED\x8C\x4C\xFB\xBB\x93\xBA\xD9\xB9\xE4\xA0\xC0\xB7\xD9\xB9\xEF\x83\x78\xD7\xAE\x04\xBD\xCD\xBB\x53\xBF\x0D\xA9\xE0\xBF\xEC\x86\x78\xB8\xA6\x0D\xBD\xD1\xBA\x6D\xBB\xDF\xA1\xE1\xA7\xED\xAC\x77\xFC\xA7\x15\xBC\xD6\xBB\x85\xBD\xF9\x99\xE1\xB1\xED\xAD\x76\x98\xBC\x08\xBC\xF8\xB9\x88\xBE\xBD\xB1\xF1\x9D\xF0\xB5\x76\xE8\xBB\x2D\xAC\x85\x02\x89\xB9\xB7\xB0\xDC\xB5\x05\xAB\x78\xBF\xBB\xD4\xBB\x82\x03\x8B\xBA\xB9\xB8\xDD\xAF\xCF\xB2\x78\xA3\xBC\xD7\xBA\xCA\xB6\x8A\xB9\xBA\xB3\xE3\xBC\xEE\x9A\x74\x87\xBA\xEC\x39\x1C\xBC\x7D\xBB\x3A\xB5\xDF\xA2\xF1\xA4\x78\xD6\xA7\x3D\xBD\xF1\xBB\x5D\xBC\xC3\xB8\xE3\xAA\xE9\x94\x76\x94\xBC\x4D\xBC\xF9\xBA\xEB\xB6\x83\xB4\x42\xAE\x08\x29\xB5\x01\xBC\x1F\xBC\x3A\x83\x95\xBD\xC0\xBE\xDF\xA2\x7E\x9B\x79\x8A\xBC\xA0\xBA\xFE\xA7\x97\xBE\xC1\xBD\xE5\xA0\x92\xA3\x79\x92\xBC\x28\xBD\x61\x9F\x99\xBE\xC2\xBB\xE0\xAD\x7E\xAB\x79\x9A\xBC\x6D\xBC", + "\x89\x03\x9B\xBE\xC3\xBB\xE1\xAA\xF3\x97\x5D\xF3\xBC\x27\xBC\xBF\xBA\x98\xBF\xCE\xBC\xE7\xA7\xF2\xA6\x79\xEB\xBA\x78\xBC\x16\xBD\x8C\xBC\x20\x01\xE8\xB0\xF1\x8C\x65\x85\xBD\x34\xBC\x1D\xBD\x75\xBA\xB2\x5E\xE7\xB1\x9C\x88\x7A\xBE\xBC\x69\xBB\x3D\xBD\xA3\xBA\x82\xBA\x10\x0F\xF4\x8A\x79\xDD\xBB\x76\xBD\x49\xBF\x16\xAE\xD2\xB7\xDE\xBA\xF3\xA9\x78\x86\x02\x9C\xBD\xF5\xB9\x9C\xBE\x9E\xA2\xE7\xA0\xF4\xA6\x7A\x9A\xBD\xFF\xA9\x50\xBD\x48\xBB\xC2\xBB\x9D\xAA\xF5\xAC\x72\xE4\xBB\x99\xBC\x21\xBF\xEB\xB5\x4F\xAE\xEA\xA0\xE6\x98\x7A\xBB\x9E\xB5\xBC\x9A\xB8\xAC\xBC\x4F\xB5\x10\x1D\x30\xBC\x77\xC9\xB6\x69\xBC\x69\x38\xAA\xBF\x0D\xAE\xEB\xB8\xF2\xB5\x79\xBB\x9E\xC5\xBC\x2E\xBC\xAB\xBC\x61\xA9\xEC\xA0\xF3\x8F\x78\xDB\xA8\xCD\xBC\x32\xBF\xB2\xBE\x7A\xA1\xED\xA8\xF3\x9E\x7A\xD5\x8B\x57\xAF\x6A\xBC\x9B\xB9\xCC\xBD\xFC\x9A\xF6\xB0\x79\xDC\xBD\xC3\x9C\x6F\xBC\x9D\xBB\xD4\xB0\xFB\x82\xF7\xB9\x79\xBB\xBD\xE5\xBD\x6C\xBF\x5A\xBE\xDC\xB2\xE8\xB5\xF1\xBC\x16\x89\xAD\xEC\xBC\x43\xBE\xA2\xBA\x1B\xB0\x00\x11\xF7\x89\x7A\xC3\xBC\xD8\xBD\x61", + "\xBD\xB7\xBB\xDD\xBA\xEE\xBA\xF7\xA1\x7B\xD1\xBB\xF6\xBC\x48\xBE\x6E\xB8\xC8\xB2\xEC\xB2\xF5\x94\x79\xB3\xA7\x05\xBE\x27\xBE\x80\xBC\xD2\xB6\x60\x9D\xF7\x86\x7C\xFC\xB7\xE9\xBC\x7F\xBC\xB2\xBE\xE1\xBA\xF0\xB9\xF2\xBF\x7B\x92\xBE\xAC\xB3\xDC\x89\xA2\xAB\xBA\x86\xEC\xA4\xF7\x9A\x7C\x98\xBE\x46\x9E\x8E\xBE\xB2\xB9\xD8\xB0\xFB\x82\xF9\x8E\x7B\xE5\xBC\x91\xA6\x93\xBE\xB4\xBC\xE4\xB1\xF2\xBB\xF8\x97\x5D\xAA\xBE\xD6\xBC\x74\xBD\xCB\xB8\xE4\xB4\x11\xB0\xF9\x9B\x7B\xCF\xBD\xFF\xA8\x9B\xBF\xB7\xB8\xE7\xBC\x3F\xBA\xF9\xA3\x7B\xE0\xBD\x3B\x9E\x9F\xBF\xB9\xBB\xC9\xBD\x31\xA0\x30\xAF\x7C\xAE\xBE\x34\xBE\x08\xAE\x42\x02\xE8\xBD\xEE\xB3\xF7\x84\x04\x4C\xBE\xF2\xBC\x7C\xBE\xD1\xB9\xE9\xB1\xDC\xA0\x00\x10\x7D\xF7\xBD\xB3\xBD\x5A\x83\xD5\xBA\xE0\xBD\xE2\xB2\x2E\x91\x77\xDB\xBE\x97\xBD\x1F\xBC\x5E\xBB\xEA\xBF\xF0\xB3\xD2\xAC\x6D\x9F\xBE\x65\xBE\x3B\xB6\xD7\xBC\xEA\xBA\xF5\xA7\xFA\xAC\x7D\xEB\xBE\x69\xBF\x53\xB4\xD8\xBD\xD3\xB2\xF3\xB5\xF9\xAB\x75\x87\x71\x1D\xBE\xA0\xBE\x42\x00\xEF\xB3\xF2\xB7\xF6\xB0\xE1\x6F\xBE\x7F\xBF\xB8\xBC", + "\xC5\xB4\xEF\xB7\xF2\xB3\xF6\x80\x49\x84\xBF\x2B\xBE\xBF\xBC\xEC\x98\xF1\xB1\xF3\xA4\xFA\x81\x7E\x95\xBE\xC7\xBD\xC5\xBF\xD5\xAC\xF1\xB7\xF3\xA8\xF9\xB8\x4C\x94\xBF\x3B\xBE\xCB\xBF\x16\xA8\xF3\xBF\xF3\xBC\xF9\x8D\x3F\x9C\xBF\x43\xBF\x5B\xBE\xE4\xB8\xF0\xB7\x50\xA0\x00\x20\x7E\xCD\xBE\x52\xBF\xBD\xBD\xA2\xAF\xF4\xB1\xF5\xB9\xFA\x8C\x67\x8F\xBF\x52\xBD\xDF\xB4\xC4\xBE\xE8\x9C\xFA\xB8\xFA\x87\x7C\xFD\xA4\xB5\xBE\xAE\xBF\xA0\xBD\x62\xB9\xFB\xA1\xFB\x91\x7A\x9F\xBF\x93\xBF\xE8\xB9\xEF\xBC\xEE\xBE\xF8\xAA\xB1\xB0\x7E\xF7\xBB\xFD\xBA\xC3\xBF\x44\xBF\xF8\xBF\xEB\xA6\xDD\x9A\x7E\xFF\xBA\xCC\xBF\xBC\xBE\xE7\xBB\xD8\x93\xFC\xA2\xF5\xBA\x7D\xB4\xBF\xC1\xBE\xD2\xBE\x41\x05\xFA\xBB\xEA\xAC\xF9\x94\x44\xDC\xBF\xAF\xBD\xE2\xBF\x8D\xA9\xC3\x3C\x60\x83\xF0\x25\x7F\x8A\x02\xC3\x8B\xF4\xBF\xF9\xBE\x20\x0A\xFE\xA6\xFF\xAE\x7F\xE8\xBF\xEB\xBE\xF2\xBF\xFB\xBE\x20\x08\x94\x75\xFF\x92\x04\x76\xBF\x0E\x02\xFC\xBE\x42\x02\xFF\xB4\xFF\xB7\xFF\xBE\x7F\xF9\xBF\xFF\xBF\xFD\xBD\x00\xC6\x20\x06\x4F\x85\x08\x05\x80\x84\x02\x07\xC1\x64\x36\x44", + "\x01\x01\xCC\x00\xCB\x00\xCE\x80\x8E\x02\x0D\xC0\x08\xC3\x03\xC2\x21\x01\x01\xD4\x00\xD8\x6B\x17\xC0\xC1\x35\x0C\xC2\xA7\x30\x03\xCB\x01\xDA\x00\xCD\x6B\x1C\xC0\x1F\xC0\x0F\xC1\x41\x03\x77\x80\x00\x04\x01\xE6\x80\x92\x02\x1F\x8A\xC1\xBC\xAF\xA9\x05\xC0\xF9\xBE\xF8\x85\x04\x2C\xC0\xB1\xBF\xFD\xB6\xD9\xB8\x00\x00\x03\xC8\xFE\x80\x7B\x8A\xBF\x46\x9F\x1A\xC1\xF3\xBE\x7A\xB3\xF0\xBC\x9F\xBA\x80\xD2\xBF\xCF\xBE\x1F\xC1\xA2\xAF\x07\xCD\xF7\xB5\xFB\x96\x3F\xC4\xC0\x85\xBE\xEF\xBF\x11\xC7\xEA\xA8\x04\xC9\xFC\x86\x81\xFD\xA4\x4D\xC1\xC6\xBE\xE8\xB9\x07\xCC\x04\xCB\xEB\x91\x81\x95\xBF\xCA\xBE\x9C\xA7\x15\xC1\xF3\xB9\x05\xC1\x7D\x9B\x81\x9D\xBF\x41\xC1\x4F\xBF\x0B\xC5\x0A\xCA\xFD\xA3\x03\xE5\x81\xE7\xBE\x66\xC0\x15\xC0\xBB\xB7\x0B\xC1\xFA\xA2\xFB\x8D\x3F\xEC\xC0\xA8\xBE\xD7\xBD\xE5\xB4\x06\xC1\xDD\xB0\x03\xED\x7E\xB7\xBF\x44\xBC\x3B\xC2\xED\xBB\xF6\xB5\xE5\xAA\x08\x3A\x81\xBA\xBF\xEE\xBC\x83\x03\x1F\xC6\xF7\xBD\x03\xCF\x03\xE4\x81\xEA\xC0\x31\xB9\x41\xC0\xF1\xBB\x0A\xC4\x11\xAA\x04\xD6\x7F\xD3\xBF\xBC\xBC\x82\x01\x52\x84", + "\xEA\xB3\x09\xC8\x04\xF2\x64\x95\xC1\x2D\xC1\xEB\xBC\x45\xA0\x13\xC1\x03\xDD\xE0\xBC\x81\xD6\x9F\x9C\xC0\x1B\xC2\xF3\xBD\x0B\xCF\x4F\xA1\x05\xFB\x80\xBB\xB9\x4E\xBE\x00\x02\x29\xC0\x08\xC4\x0A\xCF\x83\xAB\x82\xC5\xC0\xE2\xBF\x4D\xC3\xD5\xAF\x15\xC9\x04\xD8\x01\xF2\x82\xE7\xC0\xAA\xC1\x59\xC2\x2E\xC0\x17\xC2\x2C\x74\x05\xCE\x81\xB1\xC1\xA0\xC1\x44\xAE\x2F\xC2\x0A\xCE\x06\xD8\xB5\x8E\x04\x43\xC1\x58\xC0\x25\xC1\x9F\xA0\x19\xCC\x05\xCA\x06\xF5\x02\xCC\xC1\x60\xC1\x56\xC2\x77\xBE\x20\x00\x0D\xCD\x03\xFF\x7E\xC3\x9D\xD5\xC1\x38\xC0\x1E\xC2\x22\x09\x0D\xD7\x03\xDF\x82\xDA\xB0\xC7\xC1\xE8\xB9\x37\xC3\x0F\xC3\x03\xDD\x05\xEB\x75\xE3\xC1\x80\xC1\x54\xC0\x3A\xC4\x10\xCD\xF5\xA1\x07\xF8\x82\xEB\xC1\x8B\xC1\x62\xC3\xCE\x98\x1E\xCF\x08\xC1\x03\xD8\x83\xEB\xBA\x6C\x86\x4B\xC0\xF9\xA1\x1F\xC9\x09\xD0\x04\xCA\x04\x7C\xC1\x9D\xC1\x13\xB9\x0C\xB8\x20\xC2\x0A\xDC\x01\xED\x83\xFF\xC1\x57\xAE\x82\xC3\x29\xC7\xA5\xB2\x07\xC8\x08\xD4\x7D\x8A\xC2\xAC\xC0\x67\xC2\x44\x00\x22\xC0\x0B\xCC\x04\xD6\x3F\x94\xC2\xB5\xC1\x27\xC1\x2D\x80\x23", + "\xCF\x0B\xD6\x08\xFD\x49\x9C\xC2\xC4\xC1\x6B\xC3\xCE\x98\x24\xC9\x0C\xD6\x05\xD7\x84\xF8\xC1\x09\xC3\x44\xAC\x49\xC5\x19\xC6\x12\xC0\x07\xCE\x84\xFA\xC1\xB4\xB1\x95\xC1\x34\xC2\x22\xCE\x10\x12\x09\xD6\x83\x85\xC1\x45\xBF\x97\xC1\x3F\xC6\x1E\xC3\x12\xC9\x09\xF8\x82\xF2\x65\x36\xC2\x6D\xC3\x37\xC5\x06\xA3\x11\xC8\x09\xFC\x82\xC5\xC2\xB8\xC1\xA0\xC2\x37\xC3\x06\xCA\x14\xC4\x07\xE3\x65\xCD\xC2\xE9\xC1\xD4\xBE\x41\x00\x2A\xCC\x0E\xDB\xFD\x94\x85\xF1\xC1\x22\xC3\x8C\xBD\x41\x04\x6F\x8A\x10\x1C\x0A\xD0\x35\x7B\x86\x60\xC2\x87\x02\x57\xC3\x2B\xC1\x16\xDD\x0A\xE5\x85\xDF\xC2\x62\xC3\xB3\xC0\x59\xC1\x2D\xCC\x16\xD0\x7D\xB5\x02\xEF\xC2\xC3\x9C\xB8\xC3\xCE\x9A\x2E\xCA\x15\xD6\x7E\x84\x85\xF3\xC2\x39\xC2\xA3\x9C\x5D\xC3\xD1\xB7\x17\xD5\x0B\xD5\x7D\xFB\xC2\x14\xA2\xC0\xC0\xC2\xBC\x6A\x82\x11\x1C\x1A\x80\x00\x06\xC3\xB5\x80\xC4\xC1\x61\xC3\xD8\x9A\x18\xDD\x19\x8B\x86\xBB\x9E\x8D\xC2\xC2\xC0\x64\xC4\x31\xC4\x19\xD3\x0C\xD1\x82\x87\xC3\x95\xC2\xC9\xC2\xF1\xBA\x33\xC6\xF4\x91\x0C\xC6\x04\x1E\xC3\xF6\xB4\xD0\xC0\x9A\x81\x33\xCF", + "\xC1\xBF\x0C\xC6\x83\x9C\xC3\x7D\xC0\xD3\xC3\x65\xC2\x34\xC8\x19\xD6\x0C\xF0\x3E\xAC\xC3\xB0\xC3\xBC\xC1\x41\x06\x4D\x87\x71\x32\x08\x34\x86\xC6\x9E\xB7\xC2\x8A\xA1\x6E\xC6\xFA\x9B\x1B\xDD\x93\xBD\x86\xBD\xC3\xB5\x80\xE0\xC2\x6D\xC3\xD8\x92\x1C\xCE\x08\x05\x87\xB5\xC3\x3B\x9F\xE3\xC3\x96\xA2\x39\xC3\x1B\xC3\x0E\xE4\x7A\xC6\xC3\xC4\xC3\xE8\xC3\x65\xC4\x39\xC4\x10\x14\x0E\xC0\x00\x56\xC3\xF2\x64\xEC\xC2\x73\xC6\x2F\xC6\x1D\xC2\x96\x56\x87\xDF\xC3\xD2\xC2\xD8\x9C\x78\xC7\x32\xC7\x6C\x86\x08\x25\x87\x85\x02\xE7\xC2\xEB\x9D\x7A\xC5\x4F\xAB\x1E\xD5\x05\xAD\x87\xC6\x8D\xF0\xC3\x9D\x9F\x7B\xC6\x21\x03\x1F\xCA\x08\x35\x87\xE6\xC3\xC3\x9D\xFB\xC0\x7A\xC2\x36\xC4\x10\x1A\x0F\xFD\x87\xF1\xC3\x9B\xC2\xFC\xC2\x7C\xC1\x3F\xCC\x1F\xC0\x00\x3E\x87\x86\xC4\x04\xC5\xE7\xC2\x7D\xC7\x34\xC2\x20\xDE\x0B\xC7\x88\xC2\x65\x07\xC5\x08\xC5\x82\xC0\xF6\x92\x21\xD7\x0C\xEE\xB8\x17\xC4\xC3\x9C\x17\x5D\x2D\x82\x43\xC5\xD5\x19\x10\xDD\x88\xBB\x9E\x1C\xC4\x87\x01\x88\xC2\x21\x03\x22\xCB\x13\x9E\x88\xA0\xC4\x05\xC5\x12\xC5\x41\x00\x43\xCA\x20", + "\xC6\x11\xE8\x88\xAF\xC4\x7E\xC2\x15\xC4\x41\x02\x46\xCA\x25\x8C\x10\xEB\x88\xB6\xC4\x33\xC5\x14\xC6\x8E\xC0\x46\xC6\xF4\x94\x11\xFE\x88\xA7\xC4\x7E\xC3\x63\x92\x41\x02\x48\xC5\x10\x04\x12\xD6\x3F\xC6\xC4\x7D\xA4\x24\xC5\x2D\x82\x49\xC5\x26\x8D\x12\xFB\x3C\xCC\xC4\x0E\x02\x28\xC5\x95\x83\xD8\x92\x25\xC3\x12\xD4\x89\x85\xC4\x55\xC5\x22\xC6\x93\xC1\x40\xCA\x25\xCF\x12\xD7\x89\x97\xC3\x59\xC4\x82\x01\x98\xC0\x00\x03\x26\xD2\x97\x65\x89\xDB\xC4\xE3\xBE\x31\xC4\x96\xC7\x4B\xC0\xFB\x83\x13\xEE\x89\xEC\xC4\x69\xC4\x00\x03\xF1\x6B\x4E\xC2\x11\x14\x13\xCE\x04\x76\xC4\x0A\x02\x3C\xC6\x41\x02\x4F\xC5\x10\x1C\x13\xC4\x04\x7E\xC4\x72\xC4\xE1\x9C\x1D\x85\xF9\x94\x28\xC3\x76\x85\x8A\xC0\xA4\x87\xC4\xD8\x9D\xA2\xC6\xE8\x9B\x28\xC9\x0D\xDB\x51\x83\xC5\x38\xC4\xFE\xA5\xA3\xC3\x30\xC8\x33\xB3\x14\xEE\x84\xF5\xB9\x2D\xB9\xFF\xAA\xF5\xA6\x52\xC5\x0B\x9C\x14\xD4\x75\xDB\x1A\x12\x03\xE4\x6D\xF2\x6D\x16\x83\x2A\xC1\x15\xC3\x3B\xA5\xC5\x0E\x02\x51\xC7\xA9\xC3\x55\xCB\xF3\x88\x15\xCA\x04\x2E\xC5\xA0\xC5\x56\xC5\x81\xC0\x56\xC5\x10\x0A", + "\x15\xED\x88\xB5\xC5\xAC\xC4\xD8\x9C\xAD\xC0\x0D\xC4\x10\x1B\x15\xC0\x00\x3E\xC5\xBE\xC4\x79\x65\xB0\xC6\x54\xC7\x19\xDE\x15\xC2\xCB\x40\xC5\xB9\xC4\xA3\x9C\xB2\xC2\x56\xC7\x19\xD1\x78\x8E\x8B\xD6\xA7\x0C\xA7\x68\xC4\xB4\xC2\xF8\x92\x2D\xC0\x92\x95\x8B\x91\xA7\xD7\xC4\x9C\xA4\xEF\xB4\xED\xAF\x2C\xC0\x92\xB2\xCB\x59\xC5\x5B\xA9\x6D\xC6\x92\xA8\x5C\xC4\xF0\xA4\xE4\xA8\x73\xE7\xC5\xDC\xC5\x69\xC6\xB5\xC2\x5D\xC8\x2D\xDF\x14\xC5\x04\x0E\x5A\x74\x80\x78\xC6\x44\x02\x5E\xCB\xF3\x94\x17\xF0\x3E\xF6\xC5\x46\x9E\x7C\xC4\x45\xA2\x5F\xC4\x10\x1C\x17\xFD\x49\xFE\xC5\xB5\x80\x80\xC7\xBC\xC6\x7A\xA2\x30\xCE\x08\x05\x8C\x8A\x02\x07\xC7\x2D\xA5\xC2\xC7\x5D\xC2\xFC\x8B\x18\xC5\x65\x86\x02\x0E\xC6\x9A\x58\xC1\xC6\x5D\xCD\x2F\xD3\x18\xC0\x49\x91\xC6\xF2\x64\x8C\xC7\xC0\xC1\x53\xC5\x31\xDC\x18\xD2\x8C\x97\xC6\x16\xC7\xC8\xA5\xC4\xC3\x64\xC4\x31\xCC\x24\x59\x37\x80\x49\x74\x80\x94\xC7\xB0\x9A\x65\xCB\xF3\x8C\x19\xF0\x3E\xAE\xC6\x46\x9E\x98\xC5\x41\x02\x66\xC6\xFD\x94\x19\xFD\x49\xB6\xC6\xB5\x80\x9C\xC6\x6D\x51\x72\xAA\x33\xD3\x20", + "\x65\x8C\xBD\xC6\xE2\x52\x0E\x9C\xD0\xC3\xD1\xB3\x34\xD3\x19\xD6\x4F\xC5\xC6\xBC\xC4\x93\xC4\xCF\xC7\x68\xC9\x69\xBE\x19\xDE\x8B\xBB\xC6\x0C\xBE\xA3\xC6\xC7\xC0\x69\xCA\x34\xD8\x99\x94\x8D\xD7\xC6\x4C\xC6\x8F\xC6\x37\x44\x0E\x8B\x35\xD4\x24\x78\x4C\xDD\xC6\x3B\x9E\xB0\xC4\xEC\x9A\x6C\xC6\xF4\x84\x1B\xF6\x92\x5F\xC6\xD6\xA6\xB3\xC6\xF5\x9A\x6D\xCD\x27\xAC\x1B\xF5\x02\xEE\xC6\x5E\xC6\x4D\xC4\x28\x4F\x9F\xAC\x36\xD0\x1B\xF3\x81\xF6\xC6\xAB\x49\x2D\xA8\xDE\xC3\x4B\xAB\x37\xC7\x1B\xFA\x8D\xCD\xC6\x79\xC7\x72\xC4\x2D\x4A\x6B\xC5\x32\xDD\x1B\xC4\x04\x06\xC7\x9E\x49\xBF\xC4\x90\xA0\x71\xC8\x38\xC2\x96\x64\x4F\x8F\xC7\xB4\xB1\xB8\xB2\xE4\xC1\x72\xC5\x40\xB3\x1C\xCF\x61\x96\xC7\x6C\xAE\xCC\xC6\x92\xAD\x88\xB7\xAA\xB0\x1C\xE7\x6B\xE3\xB2\x9A\xC7\x91\xB8\xE8\xC4\x72\xCF\x39\xC7\xD5\xB2\xCB\x1C\xC7\x14\xB6\xC7\xC4\xE9\xC1\x73\xCB\x3A\xDB\x1C\xED\x8E\xA2\xC7\xC3\x2F\x02\xA9\x07\x31\xE2\x93\x3B\xD6\x9E\xB5\x8E\xC0\xA4\xB7\xC7\xC8\xA5\xEE\xC0\x67\xAB\x3B\xC1\x7D\xBD\x8E\xFF\xA9\xBF\xC6\xFE\xA5\xF0\xC5\xF9\x93\x3C\xC3\x76\x85", + "\x8F\xBB\x9E\xC7\xC6\xD8\x9D\xF2\xC1\x4E\xCB\x3C\xD4\x88\x8D\x8F\xFF\x2F\x05\xB9\xD8\xC7\x13\xB7\x79\xCD\x27\xB4\x1E\xC4\x79\xD6\xC7\x12\x02\xEC\xC6\xF4\xC6\x5C\xCF\x7C\x31\x1E\xDD\x8F\xE8\xC5\xE0\x2E\xC1\xBB\xF6\xC2\xC9\xAA\x3D\xDF\x1E\xEC\x5D\xE5\xC7\xE1\xC7\xE9\xC6\xF8\xC0\x96\x85\x40\xB1\x25\xBE\x4B\xEE\xC7\xFB\xAC\xF8\xC7\x76\xB2\x7E\xCC\x30\xB4\x1F\xD6\x4F\xF6\xC7\xD9\x9A\xFC\xC5\xE4\xA2\x7F\xC8\x33\xBC\x1F\xDB\x51\xFE\xC7\xFF\xA8\x00\xC8\xFF\xA2\x80\xCD\xFC\x84\x20\xC5\x88\x86\xC8\x3B\x9E\x04\xC8\xFB\xC5\x74\xCB\x40\xCC\xBB\x8A\x90\xC6\x9E\x0F\xC8\x47\xC4\x41\x01\x82\xC6\xFD\x94\x20\xFD\x49\x96\xC8\x7D\xC2\xC3\x3E\xF7\xC2\x83\xC0\x3E\xC5\x08\x18\x90\xD9\xBB\x13\xC8\x5A\xB3\x07\xCE\x21\x03\x42\xCD\x20\xCA\x59\xA5\xC8\x1C\xC8\xB6\xAE\xB0\x66\x74\x41\xF1\x8C\x21\xC2\x3F\xAE\xC8\x40\xA4\x18\xC9\xE4\xA2\x86\xC8\x33\xB4\x21\xDB\x51\xB6\xC8\x24\xA0\x1C\xC8\xFF\xA2\x87\xCD\xFC\x9C\x21\xC3\x3B\xBE\xC8\x3B\x9E\x20\xC8\xEC\x9A\x88\xC6\xF4\x84\x22\xD2\x90\x80\x00\x46\xC8\xEB\x9D\x12\xC8\x89\xCB\x41\xC5\x08\x0B\x91", + "\xB5\x81\x4F\xC8\x18\x55\x07\xCA\x6E\x44\x8B\xB1\x22\xCB\xA9\x0C\xC8\x7C\x47\x26\xC8\x15\xCB\x8A\xCC\x44\xDC\x22\xD6\x91\x86\x47\x55\xC9\x30\xCB\x13\xB7\x8B\xC9\x45\xDC\x22\xE7\xD2\x11\x9E\x67\xC8\xE1\x9D\x1A\xC8\x48\xAB\x46\xD1\x9C\xAD\x91\xB8\xA6\x6F\xC9\x2D\xA9\x1C\xCC\x04\xA3\x47\xDC\x9F\xB5\x91\xCD\x9F\x77\xC9\x61\x9D\x1E\xCB\xE7\x9B\x47\xD0\x7D\xBD\x91\xC6\x9E\x7F\xC9\x23\xC9\x20\xCE\xFA\x93\x48\xC0\x00\x05\x92\x99\xC8\xA6\x68\x5A\xB3\x21\xCD\xA7\x6A\x42\xCC\x24\xCA\x59\x8B\xC9\x70\x32\x2D\xCA\x21\xCA\x92\xC0\x49\xC5\xFD\x95\x92\xDB\xA4\x97\xC9\x44\xCB\x13\xB1\x93\xC5\x50\x6A\x24\xDE\x92\xDC\xC8\x59\xB1\x50\xCB\x58\xB3\x06\xC4\x4A\xC3\x25\xD8\x4C\xA5\xC9\xA7\xB4\x54\xC8\xC5\xB2\x95\xC5\xB4\xA5\x07\xFB\x7E\xA2\xC9\xA6\xC7\x57\xCA\x29\xCF\x54\xB2\x2C\x6C\x25\xEC\x6B\xB3\xC0\xF2\x64\x5C\xCB\xEE\xBD\x96\xCA\xF6\xA1\x04\xCD\x84\xD2\xC2\xBF\xC9\x60\xCB\x36\xC6\xC6\xBB\x95\x38\x98\x82\x77\x64\xA7\xC7\xC8\x5A\xB1\x32\xCF\x09\xBB\x4C\xCC\xBB\x8D\x93\xCA\xAC\xCF\xC8\x7F\xA5\x34\xCB\xDF\xA3\x4D\xDB\xCE\x95\x93\x8C", + "\xA6\xD7\xC8\xEB\xA5\x36\xC8\x48\xAB\x4D\xD1\x9C\x9D\x93\xD1\xC6\xC5\xC9\x53\xB7\x37\xC9\xF4\x93\x4E\xC2\x1C\xC7\xAB\x14\xB6\xE5\xC8\xFE\xA5\x3A\xCB\x1A\xC7\x4E\xC5\xDA\xAB\x93\xC3\x9D\xEF\xC9\x5B\xC5\x38\xCC\x62\xB2\x2F\x71\x27\xFE\x85\xF6\xC9\x71\xC4\x7C\xC8\x45\xA2\x9F\xC6\xFD\x9C\x27\xFD\x49\xFE\xC9\xB5\x80\x80\xC9\x9E\x55\x97\xC6\xB1\x59\xAB\x87\x77\x64\xA7\x07\xCA\x5A\xB1\x42\xCF\x09\xBB\x50\xCC\xBB\x8D\x94\xCA\xAC\x0F\xCA\x7F\xA5\x44\xCB\xDF\xA3\x51\xDB\xCE\x95\x94\x8C\xA6\x17\xCA\xEB\xA5\x46\xC8\x48\xAB\x51\xD1\x9C\x9D\x94\xE0\xC9\x86\x33\xB1\xB3\x47\xC9\xF4\x93\x52\xC6\x27\xC3\xAD\x14\xB6\x25\xCA\xFE\xA5\x4A\xCC\x9D\xC7\x52\xC5\xDA\xAB\x94\xC3\x9D\x2F\xCA\x79\xC9\x48\xC9\x96\xCF\xAE\x44\x28\xDC\xAC\x34\xC9\xEE\x3A\x76\xB5\x4C\xC8\xF6\x9B\x53\xC6\x7A\xBD\x94\x94\xA2\x3F\xCA\xEB\x9D\x50\xCD\xEA\xB0\xDC\xA5\x2A\xFB\x7E\x87\xC2\x1E\xC3\x5A\x80\x52\xCA\x1E\xC0\x0C\xDD\x93\x8B\x95\xD9\xC2\x46\x9F\xA7\xC8\x4E\xC3\xE7\x92\x55\xD2\x2A\xC2\xCB\x55\xCA\x7E\xB0\xA9\xCA\xBC\x60\xAB\xCE\x4B\xD0\x2A\xC7\x91\xDC\xCA", + "\xA9\xC0\xAD\xC9\x4B\xC0\x91\xCE\x55\xD4\x14\xCC\x95\xF1\xC4\x60\xCA\x60\xC9\x59\xCE\xA9\xC7\x54\xCD\x2B\xDD\x95\x95\xB6\x89\x65\x2C\xB1\x5C\xC8\x63\xA3\x57\xC7\xD5\xB5\x95\x94\xB6\x77\xCB\xA2\xB5\x5E\xCC\x5D\xBB\x57\xDD\xC5\xBD\x95\x96\xBA\xC3\x6D\xB7\xCB\x5F\xC9\x2E\xB3\x58\xD4\xC5\x85\x96\xCF\xB0\x87\xCA\xB6\xAD\x62\xCE\x2B\xB5\x72\x6A\x2B\xC1\x96\xA6\xB3\x8B\xCA\xB6\xB2\xBC\x61\xB2\xCB\x6F\xB4\x2C\xDB\x67\x96\xCB\xE2\xC5\x59\x6D\x2A\xC0\xB3\xC6\x3D\xBC\x2C\xCF\x8D\xD9\x6E\xC3\xC8\x2D\xA6\x66\xCE\xB1\xC2\x2C\x7E\x2C\xCB\x7F\xE3\x6E\x43\xC3\xC6\xCA\x30\xCF\xB1\xCE\x58\xC6\x2D\xF8\x4C\xAE\xCB\x5B\xA8\xD8\xC8\xF4\xBA\x21\x06\x27\x79\xC2\xB5\x96\x98\xA6\xB7\xCB\x53\xB5\x6E\xCC\x62\xBB\x5B\xC5\xDA\xBD\x96\xEC\xB5\xBF\xCB\x5E\xB1\x70\xC8\xB0\xC3\x5C\xD1\xCB\x85\x97\xB4\xB1\xC7\xCB\x27\xB1\x72\xCC\xED\xAB\x5C\xCA\xB2\x8D\x97\xB0\xC7\xB4\xCB\xDD\xBF\x73\xCF\x67\xA3\x5D\xDB\xCE\xB2\xCB\x55\xCB\x0C\xA6\xEC\xCA\xF5\xA2\xBB\xCE\x31\xDC\x2E\xD1\x4E\xDE\xCB\x38\xA6\xF0\xCA\xD4\xAA\x22\x02\x5E\xC6\x29\xC0\x00\x65\xCB\x1F", + "\xAE\xF2\xCB\x2E\xCA\xBD\xCF\x56\xC8\x2F\xCD\x3F\xEE\xCB\xC3\x9C\xF8\xCB\xCE\x9A\xBE\xC0\xFB\x94\x2F\xF1\x89\xEC\x8C\xA6\xB2\xFC\xC8\x7D\xBA\xBF\xCB\x5A\xDC\x2F\xE1\x96\x86\x02\xFE\xCB\xD4\xCA\x43\x01\xC0\xC3\x03\xC4\x30\xD8\x4C\x86\xCC\xA7\xB4\x04\xCC\xC5\xB2\xC1\xC5\xB4\xAC\x30\xEC\x6B\x8E\xCC\x31\xB8\x08\xCC\x60\xCA\xC2\xC8\x3A\xC0\x30\xFB\x7E\x94\xCC\x05\xA8\x0C\xCC\x16\xCD\x20\x0A\x61\xCC\xBB\x9D\x98\xCA\xAC\x1F\xCC\xE8\xCA\x85\xCF\xAD\xC1\x62\xDB\xB7\xA5\x98\xD6\xCB\x12\x03\x13\xCE\xE6\xB1\xC5\xCB\x5E\xC3\x30\xED\x98\xD4\x40\x17\xCD\x18\xCC\x89\xCA\xC6\xC9\x0A\xCA\x31\xE5\x8C\xE4\x89\xA6\xB2\x1C\xCC\x7D\xBA\xC7\xCB\x5A\xDC\x31\xFF\x97\x85\x02\x3E\xCC\x01\xCE\x42\x01\xC8\xC3\x03\xC4\x32\xD8\x4C\xC6\xCC\xA7\xB4\x24\xCC\xC5\xB2\xC9\xC5\xB4\xAC\x32\xEC\x6B\xCE\xCC\x31\xB8\x28\xCC\x60\xCA\xCA\xC5\x61\xC0\x32\xFB\x7E\xD4\xCC\x05\xA8\x2C\xCF\x86\xCC\x20\x0A\x65\xCC\xBB\x9D\x99\xCA\xAC\x5F\xCC\x11\xCE\x95\xCF\xAD\xC1\x66\xDB\xB7\xA5\x99\xA8\xCC\x0E\x03\x33\xCF\x8A\xC9\xCD\xCF\x62\xC6\x08\x2A\x99\xB7\xCC\x57\xCD", + "\x38\xCC\x99\xCA\xCE\xC9\x0A\xCF\x33\xDE\x8C\x94\x95\xB3\xBC\x3C\xCF\xED\xBA\xCF\xC2\x64\xDB\x52\xBB\x7E\xFC\xCC\x33\xC0\x40\xCF\x58\xB2\xD0\xC9\x57\xA4\x34\xD4\x6C\x86\xCD\x45\xB6\x44\xCC\xBB\xB2\xD1\xC1\xC3\xAC\x34\xC0\x96\x8E\xCD\x71\xB2\x48\xCF\xFA\xC6\xCF\xCF\x56\xD2\x34\xCB\x50\x96\xCD\xDC\xC6\x4A\xCD\x2A\xC0\xD3\xCA\x64\xBC\x34\xE2\x99\x84\x02\x9E\xCD\x7D\xAD\xA8\xCB\x3B\xB3\x6A\xCB\x33\xCA\x04\x25\xCD\x80\xC6\x4D\xCC\x69\xCA\x22\x08\x6A\xD7\x33\xFF\x99\xAF\xCD\x95\xCC\x58\xCF\xA6\xCD\xCD\xC6\xA9\x9E\xC3\x97\x2A\xB3\xBD\xB7\xCD\x1F\xCC\x41\x01\xD7\xCD\x67\xD5\x35\xEF\x95\xBC\xCD\x33\xC0\x60\xCC\xC6\xA2\xD8\xC7\xAA\xA4\x36\xD4\x6C\xC6\xCD\x45\xB6\x64\xCC\xBB\xB2\xD9\xC1\xC3\xAC\x36\xC0\x96\xCE\xCD\x55\xCD\x5D\xCF\xEE\xB8\xDA\xC5\x40\xB4\x36\xDB\x99\x80\x00\xD6\xCC\xB6\xAD\xB6\xCA\xC9\xAB\x6D\xDF\x34\xD8\x9B\xD3\xCD\xE0\xCD\xB7\xCA\xBC\x65\xDB\xC6\xC9\xB2\x08\x24\x9B\xDD\xB4\xE6\xCC\x5A\xCE\xB4\xCF\xD7\xC1\x6E\xC9\x05\xE7\x9B\x8C\xA6\xEF\xCC\xEB\xA5\xBC\xCE\x63\xCA\x0C\xD5\x37\xE3\x95\x96\xBE\x3B\x9E\x9A", + "\xC2\x0B\xC6\xFA\x96\x6F\xDA\x08\xF8\x9B\xB0\x9F\xFA\xCC\x4D\xC0\xBF\xCF\xDE\xC1\xF9\xA6\x7A\x81\x9C\xF6\xB5\x07\xCE\x9E\xC3\xBE\xCF\x52\xCE\x0F\xC6\x38\xC4\x9C\x8B\xCE\x44\xBD\x84\xCE\x34\xC3\xD8\x92\x71\xD2\x97\x55\x9C\xFF\xCD\x71\xC4\x89\xCE\xB0\x62\xE2\xCC\x71\xCF\x38\xC2\x9C\xFD\xA4\x1D\xCE\x7F\xCC\x31\xCF\xB0\x1D\x12\xC8\x56\x93\x95\x8A\x02\x26\xCE\xA9\xC9\xCA\xCB\xF7\xBB\x72\xCF\x2B\xED\x9C\xA9\xC1\x2F\xCE\xFA\xB9\xCC\xCB\xB5\xC3\x73\xDA\x35\xE4\x9C\xA2\xCE\x28\xCE\x8F\xCD\x41\x05\xE6\xCD\x6B\xC4\x08\x3C\x9C\xB3\xC0\x3F\xCE\x9B\xCB\xCE\xCA\xE7\xCE\x73\xC5\x39\xC4\x9D\xDC\xA8\x39\xCE\x9C\xCE\x41\x01\xE8\xC7\xAA\xAC\x3A\xE9\x8E\xDD\x12\x47\xCE\xA7\xCD\xD1\xB2\xEA\xC1\xC9\xB0\x3A\xCA\x9D\xF4\xBD\x54\xCE\x7D\xBA\xD5\xCD\xA9\xC4\xE4\xB9\x3A\xC0\x96\xDE\xCE\x71\xB2\xB0\xCC\x2D\xB2\xEC\xCF\x84\xA4\x3B\xEC\x5D\xE6\xCE\x8C\xCA\x24\xB8\xF9\xA3\xE1\xB1\xFA\x8C\x3B\xFF\x53\xEE\xCE\xFC\xA6\xB8\xCD\xF3\x9A\xEE\xC3\xEC\x94\x3B\xEA\x9D\xB4\xB1\x76\xCE\xD8\x9D\xDE\xCE\xE8\x9B\x77\xD4\x88\xBD\x9D\xD6\x9F\x7F\xCF\x3E\xA5", + "\xE0\xCC\xC8\xB3\x78\xD0\xE1\xB2\x64\x85\xCF\x73\xC0\xC4\xCC\x13\xBF\x09\xBA\x78\xDB\x92\x8D\x9E\x9E\xBA\x6C\xB3\xC7\xCF\xC3\xC0\xF2\xC5\x6E\xD7\x3B\xDC\x91\x92\xCF\x15\xB6\xCC\xCE\xE6\xC8\xE3\xCE\x77\xDC\x3C\xC0\x9E\x9E\xCF\x82\xCE\xD0\xCC\x91\xBB\x59\x93\x71\xCE\x55\xA0\x9E\xA4\xCF\x12\xCE\xD4\xCF\xD1\xCA\xF5\xC7\x75\xC4\x08\x2C\x9E\xDC\xCE\x12\x03\xD7\xCE\x47\xC2\xF6\xC7\x56\xD4\x88\xB4\x9E\xEB\xCA\xB5\x81\xDB\xCF\xC9\xCE\xE8\x9A\x7B\xD2\x2A\xFD\x9E\xBB\xBF\xBF\xCF\xB7\xC9\xF0\xC9\x15\xC2\x2C\x63\x3E\xCE\x96\xC6\xCF\xB3\xBC\xE4\xCE\xCD\xCA\x5E\x6A\x7C\xDD\x39\xD0\x2A\xA2\xCF\xB1\xCE\xE8\xCF\xC8\xCD\xF9\xC3\x03\xD4\x3E\xE3\x65\xD6\xCF\x34\xCA\x65\x96\xF4\xCA\xB4\xCE\x7A\xDB\x3E\xDB\x49\xD8\xCF\x4F\xCE\xD3\xCD\xC1\xCE\xF6\xCE\x7D\xD8\x99\x25\x9F\xDD\xCF\xE3\xCE\xEB\x9C\xF8\xCD\x68\xBB\x7E\xC8\xE1\xA8\x82\xF4\xBB\x02\xC2\x99\xB1\xFC\xC9\x2E\xB3\x7F\xD4\xC5\xB5\x9F\xCF\xB0\xF7\xCE\xB6\xAD\xFE\xCC\x4F\xAB\x7F\xCC\xCB\xBD\x9F\xFB\xAD\xFF\xCF\xED\xB1\x00\xD4\x61\xA3\x80\xD6\x9E\x85\xA0\xC0\xA4\x07\xD1\xD3\xCB\x94", + "\xBE\xF9\xC9\x80\xCC\x72\x8D\xA0\xE3\xCB\x0C\xC2\x9B\xCF\x03\xD7\x9F\xA3\x81\xC9\x2F\xD1\xA0\x8C\xD0\x86\xCE\xFA\xCD\x06\xD2\x92\xC5\x81\xC2\x03\xF2\x80\xC2\xCE\x1F\xD0\x9C\xCB\x05\xD3\x06\xCD\x81\xC3\x76\xA5\xA0\xBB\x9E\x27\xD0\xD8\x9D\x0A\xD6\xE8\x9B\x82\xC7\x22\xE4\x28\x94\xCF\x05\xA7\x17\xD2\x4F\xBE\x5F\xA2\x83\xCF\xF2\x9B\x67\xB5\xD0\x98\xCE\x1C\xD3\xF9\xC8\x00\x0A\x83\xC9\x3F\xFD\x49\xBD\xD0\x0B\xCE\x20\xD3\xC7\xCD\x16\x82\x84\xCD\x38\xD4\x44\xC5\xD0\x0A\xCE\xA3\x9C\x12\xD5\xF4\xC0\xFB\x8B\x42\xD2\x9C\xCE\xD0\x47\xCE\x28\xD1\xEB\xCD\x62\xB2\x85\xD0\x3D\xCE\x04\x55\xD0\x1E\xC2\x2C\xD1\xED\xCA\xE9\xB8\x74\x3B\x40\xCF\x61\xDA\xD0\xB8\xCE\x89\x00\x18\xD3\xF7\xCE\x82\xDE\x42\xEC\x5D\xE3\xD0\x52\xCA\x34\xD3\xEE\xBA\x5E\x6A\x86\xC2\x37\xE2\xA1\xE6\xD0\x69\xCE\x85\x01\x1B\xD4\xF8\xCF\x86\xD6\x3C\xE7\xA1\xF0\xD0\x6C\xB3\x39\xD2\x63\xCA\x0F\xDB\x5A\xDC\x43\xF6\x9C\xFE\xD0\xCE\xCE\x61\x66\x41\xC6\x0F\xB3\x88\xCC\xCA\x85\xA2\xA9\xC1\x87\xD0\xC7\xC9\x22\xD3\xB5\xCB\x88\xD6\x39\xCD\xA2\xDF\xC1\x8F\xD1\x19\xC1\x24\xD3", + "\x2C\xB3\x89\xC7\xD5\x95\xA2\x94\xB6\x97\xD1\xA2\xB5\x26\xD4\x5D\xBB\x89\xDA\x3A\xF6\x7A\xDB\xD0\x7D\xA5\x4E\xD2\x4C\xB2\x14\xD1\x97\xB2\x97\x64\xA2\xB4\xB1\xA7\xD1\x27\xB1\x2A\xD5\x91\xCF\x89\xC1\x43\xED\xA2\xE4\xD0\xD6\x9F\x55\xD1\x58\xBF\x15\xD2\x56\xD4\x45\xEA\x9B\xA3\xC1\x1A\xCF\xF0\xBD\x52\xCA\x17\xD0\x8A\xD5\x05\xB2\xA2\xEC\xB2\xBF\xD1\x7D\xAD\x30\xD3\x3B\xB3\x8C\xD9\x2C\xC4\x04\x14\x94\xF3\xBB\x59\xBC\x32\xD3\x01\xD9\x85\xAB\x46\xF2\x7E\xB3\xC0\xCE\xD1\x10\xD0\xC5\xB1\x1A\xDE\x09\xD0\x46\xEF\x9F\xAB\xCB\xD4\xD1\x16\xD3\x31\xD7\x1A\xD6\x73\xD9\x46\xF8\xA1\xFB\xAD\xDE\xD0\x3B\xD2\x92\xA9\x1C\xDB\x78\xCC\xBB\xA4\xA3\xB7\xB9\xE3\xD0\x6E\xD2\xF3\xCF\x1C\xD0\x83\xC6\x46\xC0\x00\x6C\xD1\x33\xD0\x70\xD2\x3A\xD5\x19\xD3\x8F\xC3\xCB\xB2\xCB\x70\xD1\x36\xD0\x86\xA4\x3E\xD0\xF3\xCB\x8F\xDB\x41\xC2\xCB\x7D\xD1\x3E\xD1\x5A\x80\x40\xD0\xE2\xC2\x11\x03\x48\xC3\xA1\xAF\xBF\x0A\x02\x83\xD2\x11\xD4\x0B\xD5\x10\x0A\x48\xC9\xA1\xC7\xC8\x0E\xD2\x26\xD1\x9C\xC1\x22\xD2\x71\xD4\x48\xC7\x9D\x96\xD2\x53\xD0\x8C\xD2\x15\xD1\x21", + "\xD5\x8F\xC7\xD5\x9A\xA4\xBB\xD1\x23\xCF\xEE\xBD\x4B\xC2\x24\xDF\x04\xC4\x49\xDB\xA4\xD1\xC2\xAB\xCA\x93\xD0\x48\xD6\x29\xC7\xAA\xAA\x49\xE0\xA2\xAE\xD2\xAE\xD0\x96\xD0\xC5\xB0\x26\xD0\x8B\xDD\x93\xB4\xA4\xD2\xCA\x37\xD3\xDD\xBD\x4E\xD7\xAD\xCB\x93\xD4\x43\xCB\x85\xE3\xB2\x3D\xD2\xFA\xB9\x50\xD3\xB5\xC2\x2F\x63\x4A\xF6\x9C\xC6\xD2\xCE\xCE\xA4\xD2\x2B\xCF\x27\xDD\x92\xDC\x45\xF1\xA4\xA8\xD2\xCB\xCE\xA1\xC2\x2E\xCC\x29\xD1\x7E\xD2\x49\xC5\x6D\xC2\x65\x4A\xD2\xA0\xD2\x53\xD5\x26\xD5\x0B\x99\x4A\xCD\xA5\xB6\xD1\x3C\xD3\xAD\xD0\x4E\xD2\x2C\xD7\x8B\xD4\x51\x96\xA5\xD5\xAB\x66\xD2\xA8\xD3\x37\xC1\x2D\xD5\x15\xCF\x2B\xEC\xA5\xD8\xC2\x5C\xD2\x89\x03\x5B\xD5\x1E\xC2\x91\xD4\x88\xB3\xA5\xDE\xD2\x14\xB7\xBB\xD0\x59\xD4\x29\xBA\x97\xC0\x4B\xE9\x82\xFD\xD2\xBA\xBD\x93\xD1\x41\x00\x30\xD8\xDF\xAF\x48\xD6\x3F\x84\xD3\xC9\xBE\x89\xCC\x62\xD7\x06\xC3\x85\xCB\x4C\xF8\xA2\xC7\xCE\x8E\xD3\x62\xD1\xC9\xC1\x32\xDD\x91\xD9\x4B\xD2\xA5\x98\xA6\x94\xD3\x11\xD2\x3D\xD2\x2E\xD7\x99\xC7\xD5\x99\xA6\xC9\xD1\x36\xCF\xCF\xD0\x33\xD0\x04\xD0", + "\x00\x02\x4D\xCF\xA3\xE3\xB2\xA6\xD2\x69\xD1\xD1\xB1\x35\xD5\x8D\xDB\x4C\xCC\x36\x1D\xD3\xF4\xC8\xCE\xD0\x55\xD7\x2A\xD2\x9B\xC7\x4B\xDE\xA2\x8A\x02\xAC\xD2\x6D\xD1\x9F\xA1\x37\xDF\x8D\xDB\xCE\xBC\xA6\xE2\xD1\x6C\xB3\xDF\xD1\x39\xD2\xC9\xA2\x9C\xC8\x47\xC1\xA7\xB0\xD3\xB4\xD2\x87\x01\x5F\x8B\x36\xD5\x5D\xAB\x4E\xF6\xA6\xB2\xB2\xCE\xD2\xB5\xD3\x0C\xC1\x3A\xDD\x96\xC9\x05\xD4\xA7\xF0\xD2\x52\xCB\xEB\xD0\x5D\xD2\xE2\xCA\x9D\xD8\x4B\xFC\x5A\xDD\xD3\x7B\xD2\xEB\xD0\x72\xD4\x5D\xB0\x9E\xDE\x4B\xCE\x96\xE5\xD3\x81\xD3\x95\xD2\x41\x00\x3D\xD5\x98\xD5\x4B\xD6\x3F\xEC\xD3\x89\xD3\xA3\xCC\x7C\xD4\x31\xD2\x98\xC9\x1A\xF3\xA7\x8F\xD3\x53\xD1\xFB\xD2\x64\xD1\xBB\x9A\x9F\xD5\x4C\xC5\x6D\xF2\x65\xFD\xD2\xCD\xD3\xA9\xB1\x40\xD0\x9A\xCE\x3E\xC4\xA8\xA3\xD3\x22\xD0\x85\x03\x81\xD7\x34\xD3\xA0\xC3\x4F\xF1\x70\x8B\xD4\xAA\xD3\xAA\xCE\x72\xD6\x41\xD0\x58\xC0\x50\xD4\xA8\xD1\xCD\x00\x00\x08\xD5\x6B\xD1\x41\xDB\x9E\xD7\x50\xF4\x62\x9A\xD4\xBA\xD3\x5A\x80\x88\xD5\x37\xDC\x30\xA3\x51\xC0\xA7\xFB\xAD\x26\xD5\xE1\xD0\x5B\xB1\x45\xD6\x9C", + "\xCF\xD8\x99\x84\xCD\xCA\x37\xC2\xE0\xB9\x8C\xD3\xF7\xB3\xA3\xCF\x2B\xF5\xA8\xA9\xC1\x37\xD4\xC7\xC9\x8E\xD3\xD6\xBB\xA3\xD6\x39\xFD\xA8\xCE\xCF\x3F\xD5\x19\xC1\x90\xD3\x2C\xB3\xA4\xC7\xD5\x85\xA9\x94\xB6\x47\xD5\xE4\xD1\x47\xC5\x17\xD5\x11\xC0\x45\xC9\xA9\x92\xD4\x4B\xD5\xA7\xD1\x49\xC3\x0A\xDF\xA4\xD7\x4D\xE1\x84\xF1\xD2\x2F\xD4\xF5\xD3\x94\xD5\x3E\xD8\x74\xD7\x52\xF5\xA2\xD1\xD4\x58\xD5\xD2\xBD\x95\xD0\xB0\xC2\x2C\x63\x53\xF1\x65\xE6\xD4\xB4\xB0\x34\xD7\x13\xB2\x4D\xDC\x76\xAC\x53\xCA\x59\xEE\xD4\xDE\xCC\xB9\x48\x9C\xD7\x67\xA2\xA7\xDE\x50\xCB\x50\xF5\xD4\xCC\xD3\x18\xB8\x9E\xD7\x39\xD1\x97\xBB\x53\xD2\xA7\xE3\xB2\x7E\xD5\xEA\xD2\x63\xC9\x50\xD8\x9D\xDE\xC3\x84\xAA\xDB\xD3\x47\xCF\x43\xD6\x77\xD4\x5D\xBA\xA8\xC1\x4F\xC3\xAA\xCD\xD4\x52\xD5\x89\x48\xA4\xD1\x4C\xDA\x56\x59\x52\xCC\xA9\xA9\x4A\x93\xD4\xAB\xCA\x44\x05\x51\xD6\x9E\xCB\x2D\xDC\xAA\xE9\xD3\xA0\xD1\x4F\xD5\x7B\xD7\xE2\xC8\xA9\xD6\x54\xD1\xAA\xDF\x4A\x99\xD5\xDD\xBE\xA8\xD1\x3E\xD3\x85\xC2\x96\x6B\xAA\xF4\xD3\x5A\xD4\x49\xD6\xA9\xD4\x52\xD2\x5A\x49", + "\x55\xEE\xA1\xA5\xD5\x60\xD5\x2F\xD5\xA5\xD1\x57\xD7\x8B\xCF\x55\xF8\xA7\xDC\xD4\xAE\xD4\x5B\xD5\x2A\xC6\x57\xDB\x9F\xD1\x9C\x84\xAB\xFE\xD3\x8C\xD4\x61\xD7\xA3\xD3\x56\xD2\x55\xC7\x56\xC2\xA8\xD5\xD2\x3B\xC2\xF7\xD3\x42\xC5\x40\xD9\x85\xB1\x08\xC7\x9D\xD6\xD5\x53\xD0\x6C\xD4\x97\xD2\x5B\xD1\xAB\xD3\x56\xC8\xA8\xEE\xAA\xDC\xD5\x4B\xD4\x4C\xC7\x09\xB1\xAE\xC7\x55\xE5\xAB\xB4\xD5\x05\xC2\x64\xD5\x0C\xBF\x5C\xD2\x55\xCC\x57\xF7\xA2\xEE\xD5\x6F\xCA\x78\xD6\x69\xB2\x5E\xDE\x58\xD2\x97\x74\xAB\xAB\xCB\xF7\xD4\x9B\xCD\xBE\xD1\x10\xD7\x75\xBB\x57\xF3\x80\xFE\xD5\xAE\xD3\x71\xD5\xA6\xC9\x20\xC4\xA2\xC5\x19\xC0\xAC\x9C\xD4\x04\xD7\x13\xD7\x76\xB7\x60\xD4\xB1\xAC\x58\xC5\x6D\x8E\xD6\xEC\xB4\x88\xD7\xBA\xD2\x59\xDB\x5A\xC2\x96\x54\x95\x12\xD6\x32\xB3\x8B\xD4\xC5\xD7\xF6\xBA\xB1\xCC\x56\xFB\x7E\x9D\xD6\xBC\xD5\xB7\xC8\xC8\xD6\x4B\xDF\xB1\xD7\xBA\xA3\xAC\xDB\xD4\x1E\xC3\x93\xD4\x4B\xC3\x0A\xDA\xB2\xD3\x09\xC7\x9D\xAD\xD6\x73\xD5\xED\xB0\xCC\xD6\x4E\xDC\x76\xB3\x59\xF9\xA9\x80\xCB\x36\xD6\x3E\xD4\x2D\xB1\x67\xDF\xA7\xC8\x58", + "\xF9\x95\x26\xD6\x89\xAC\x9E\xD6\xA0\xD4\x28\xDF\x59\x40\x5A\xF8\x82\xC2\xD6\x85\xD5\xB7\xCA\xC5\xD6\x68\xD2\xB0\xCA\xB2\x88\xAD\x88\xD5\x53\xD0\x79\x67\xD3\xD3\x51\xD1\xC3\xB2\x5A\xEB\x75\xD3\xD6\x8E\xD5\x8A\xD5\xD1\xD7\x68\xDC\xB4\xD1\x56\xD2\x9C\xD8\xD6\x9D\xD4\x9B\xCC\xD8\xD0\x54\xD7\xAA\xC3\x5B\xE3\xAA\xC7\xCE\xC2\x64\xD4\x3E\x43\x03\xF5\x3E\x10\x12\x32\x58\xAC\xE4\xA7\x6C\xD6\x03\x4D\xA2\xA9\x6E\xD0\x64\x58\x05\xF4\xAD\xE5\x4C\x4D\xD6\xB6\xB3\xDD\xD6\xC5\x47\x75\xBB\x5B\xDB\x99\x2A\x3F\x39\x4D\xBC\xD7\xBE\xAE\x6F\xDE\xB6\xDB\x58\xDF\x83\x84\xD7\x7D\xD7\xC0\xD6\xD7\xD7\xE8\xC8\xB8\xD6\x5B\xCA\xAE\x89\xD6\x2A\xD5\xC1\xD7\xE3\xD1\x5D\xDF\xAC\xC5\xDA\x8D\xAE\x82\xD7\xDB\xB3\xCB\xD7\xE2\xD5\x55\xD0\xB8\xCD\x5B\xC9\xAE\x9E\xD7\x54\xBE\xCD\xD4\xE4\xD5\x45\xD8\x66\xCA\x08\x22\xAE\x94\xD7\xD4\xD5\xB1\xB3\xE9\xD6\x5B\xDC\xA0\xD4\xD8\xAB\xAE\xEF\xD6\x93\xCD\x82\x03\xEB\xD6\x70\xD3\x03\xD3\x5D\xDE\xAC\xEF\xCA\x7E\xD6\xBF\xD7\x5D\x3C\x20\x0E\xB7\xC6\xDF\x06\x04\x39\xD7\x9D\xD6\xD3\xD5\xF0\xD7\x77\xDA\x1D\x72\x5D\xF8", + "\xC7\x44\xD7\x6B\xD7\xE3\xD6\xF1\xD1\x79\xD0\xBA\xD8\x5C\xE6\x9A\xC8\xD7\x72\xD7\x9F\xC3\xF0\xD5\x20\x06\x1F\x78\x82\x7E\xAD\xF6\x63\xD7\xD7\xE9\xD4\xDF\xD7\x28\xCC\xBC\xCA\x08\x3B\xAE\x80\x00\xBA\xD6\xED\xD4\x00\x05\x70\xD7\xBB\xDE\x49\xC2\xAF\xCD\xD7\x9B\xD6\x2E\xD6\xED\xD1\x64\xD9\x0A\xCB\x5F\xE4\xAC\xB8\xD7\x93\xD6\xD6\xD5\x84\xD1\x86\xBE\xBE\xC8\x59\xE2\xAB\xD0\xD7\x75\xD6\xE7\xD5\xC9\xC6\x10\x64\xBE\xCC\x5F\xF4\x77\xFC\xD7\x89\xAC\x00\xD8\x2E\xC2\x80\xDA\xBF\xC0\x92\x84\xB0\xE9\xD7\xDD\xD4\x43\x63\x8D\x4F\x80\xD3\xBA\xCD\x47\xD6\x4F\x8C\xD8\xA8\xD7\x6F\xD4\xAF\xA8\x82\xD2\xBF\xDB\x50\xD4\x6C\x94\xD8\xB0\xD7\x27\xB0\x06\xDC\x76\xD3\x96\xBB\x60\xE5\xAF\x8E\xCB\x1E\xD8\xFF\xD7\x6A\xC9\x84\xDF\xBE\xC9\x05\xE4\xB0\xF6\xD7\xA7\xD4\x61\x67\x09\xDB\x65\xDC\xA5\xCB\x61\xEE\xAC\xCF\xC0\x2E\xD9\x98\xD7\xF3\xD5\x20\x01\xC3\xD4\x59\xCA\x59\xB5\xD8\x37\xD7\xB8\xB0\x0E\xDA\x67\xDC\x45\xDB\x61\xFD\xAC\x97\xD8\xF1\xD7\x0C\xD8\xDB\xAE\x10\x66\x08\x7F\x5E\xC6\xC2\x3E\xD7\x34\xD8\x89\x00\x11\xDA\x89\xDC\xC4\xCE\x08\x06\xC2", + "\x0F\x60\x86\x60\x5C\x63\x12\xDB\x43\x6A\x10\x13\x62\xD1\xAF\x85\xD8\x24\xB8\x27\xD9\x10\xDC\x83\xD9\x7D\xC6\x08\x06\xC2\x55\xD7\x4D\xD8\xAD\x61\x18\xDE\x20\x06\x1F\x7E\x61\xC3\xAD\xB6\xCE\x2A\xD8\x89\x02\x11\xDA\x8D\xD3\xC6\xD8\x5B\xC8\xB0\xF7\xD7\xF6\xB4\x33\xD9\xD2\xD6\x84\xDB\xC5\xDF\x60\xE3\xB0\xF5\xD8\x22\xD8\x9B\xCE\x1C\xD8\x6A\xDD\xC2\xD8\x63\xE5\xB0\xA0\xD8\x7E\xD8\x14\xD8\xBA\xD5\x62\xBE\x17\x4B\x6E\x49\x67\x42\xD8\x7C\xA5\x43\xD8\x17\xDE\xAD\xAA\xC8\xD6\x63\xF6\x9C\x8D\xD9\x79\xD8\xE7\xCC\x24\xDF\x8F\xDB\x5A\xD3\x64\xC2\xB2\xD2\xCA\x96\xD8\x16\xDA\x47\xC1\x93\xDF\xC2\xDC\x52\xDC\xB2\xB2\xD8\xD6\xA7\x4F\xDA\x0D\xDC\x2D\xB2\xCA\xD9\x61\xF4\x62\xA5\xD9\x3C\xD8\xB6\xAC\x2A\xDF\x87\xD5\xB4\xAB\x65\xE7\xB1\xFC\xD5\x33\x38\x44\xD8\x29\xD9\xD1\xAE\xCA\xD3\x63\xF5\xAB\x9B\x36\xB2\xD9\x7D\xAD\x2D\xDC\x8F\xDD\xAD\xDB\x65\xD4\xAD\xE4\xD4\xB8\xD9\x45\xD9\x2B\xDF\xEA\xAE\xCB\xD9\x5A\xD1\xA5\xB1\xD9\xC2\xD8\x28\xD4\x20\x3D\x81\xD1\x8F\xC8\x37\xC8\xB3\x8E\xD9\xB0\xD9\x1E\x39\x05\xD9\x44\xD1\xCC\xD0\x66\xF3\x80\xC5", + "\xD9\x61\xD6\x49\xD8\x31\xDB\x9B\xDC\xBD\xCA\x08\x3C\x1A\x8E\x02\xDF\xD8\x6F\xDA\x44\x01\x9C\xD6\x10\x04\x67\xC5\x04\x66\xD9\x04\x02\x74\xD8\x00\x02\x9D\xDC\xCE\xC3\x67\xEE\xB3\xE0\xD9\xEF\xD8\x71\xD8\x3C\xDE\x21\x0E\x6B\x94\xFA\xB5\xB3\xD8\xD8\x4C\x9D\x7B\xDB\x1B\xDF\x54\xDA\xCF\xCC\x66\xF9\xA3\xD6\xA7\xFD\xD9\x08\xD9\xEB\xD5\x68\xB1\xD0\xD3\x66\xC5\xAC\xC0\xA4\x05\xDB\x5C\xD9\xC1\xA1\xA1\xD9\xCC\xD1\xE1\x8C\xB4\xD6\xD9\x63\xB3\x87\xD9\x24\xDB\x06\xC2\xD1\xD4\x64\xF6\x9C\x95\xDA\x97\xD9\xDD\xBC\x46\xDA\x93\xD0\xC7\xC4\x08\x1B\xB4\x9D\xD9\xDD\xD4\x61\x67\x47\xD8\x94\xD8\xD0\xC9\xB4\xA3\xB4\xA3\xD9\x95\xCE\x85\x03\x49\xDE\x94\xDF\x84\xAB\x69\xE9\xB2\xCA\xAC\x2E\xDA\x56\xDA\xFB\xCC\x9E\xD7\x75\xB1\x69\xEF\xB2\x94\xDA\xD1\xBA\x9B\xDA\x2D\xDC\x68\xD4\xD3\xDD\x66\xC6\x04\x3A\xDA\xBC\xD9\x8E\xD9\xC5\xB0\xA8\xDF\xCB\xD1\xCB\x84\xB5\xC6\xD9\xCE\xCF\xA3\xD9\x36\xD8\xA7\xD8\x0B\xCA\x6A\xE4\xAD\x83\xD9\x4E\xDB\xB3\xD4\xE7\xD6\x21\x0A\x6B\x8E\x08\x00\x1B\x8E\x02\x7E\x43\xAB\xDA\x42\x03\xB9\x50\x47\x94\xFA\x9D\xB5\xF8\xD9", + "\xA1\x9F\xAF\xDB\x3E\xDB\x90\xD2\xD6\xDE\x67\xD8\x9E\xE5\xDA\x02\xDB\xF9\xD4\x60\xC8\xAD\xD6\xD0\xCA\x58\xCC\x4C\xEC\xDA\x0A\xDB\x88\x9C\x5C\xDD\xA1\xDB\xD6\xD7\xBA\xB3\xB5\x90\xDA\xA7\xB5\xBB\xDB\x44\xDB\x2C\xBA\xD7\xD6\x68\xCE\x9F\xFD\xDA\x19\xDB\xB7\xC8\x60\xDC\xA3\xD9\xC2\xD2\x08\x03\xB6\xA0\xDA\x42\xDB\xC3\xD8\x49\xDC\xC3\x9A\xD8\xC8\x69\xE5\xAE\x86\x02\x8D\xDA\x96\xD8\xDB\xA9\xB2\xDF\xD2\xCC\xCB\x94\xB6\xB2\xDA\x56\xD5\x82\x03\x65\xDF\xA6\xDC\xD7\xD6\x6B\xD1\x77\x9B\xDB\x3B\xDB\x63\xDA\x42\x00\xB4\xD1\xD4\xC5\x6C\xCE\x04\x24\xDB\x45\xDB\xD8\xD4\x41\x00\xB5\xD8\xD4\xD3\x01\xEC\xB6\xCB\xDA\x9D\xDA\x5C\xC3\x6B\xDF\xA9\xD2\x55\xD3\x6D\xD2\xB5\xDC\xD4\xB6\xDA\x56\xD4\xB0\xD1\x2F\x5D\x90\x54\xFA\x97\x9E\x71\xDA\xC2\x9F\xDF\xD8\x5D\xD9\x2E\xB2\xDC\xD8\x6B\xD4\x6C\xC5\xDB\x7B\xDB\x53\xB4\x72\xDE\xAF\xD3\x03\xCB\x6E\xC1\xB6\xA6\xB3\xCE\xDA\xC2\xDB\x20\xD9\xBA\xD8\xD8\xC7\x55\xD4\xB7\x8B\xDB\x38\xA7\xEB\xDA\x63\xDC\x61\xAA\xDD\xD2\x6C\xCA\x59\xDD\xDB\x95\xDB\x7D\xAC\x78\xD8\xB3\xD0\xCC\xC4\x46\x60\xB5\xFF\xA9\xE3", + "\xDA\xCE\xD9\x5E\xA9\xBD\xD1\xDA\xCE\x3E\xF2\xCB\x6C\xDB\xA5\xDB\xE9\xDB\xD5\xA8\xBE\xD9\xDA\xDC\x22\xF4\xB7\xAD\xDB\x63\xB3\xFB\xD8\x6C\xDA\xB9\xD1\xDD\xBA\x6F\xF4\xB6\xEB\xD0\x55\x52\xB3\xDA\x3F\xD1\xC0\xD9\xD6\xD6\x60\xCA\xA9\x86\x02\xFE\xDB\xDB\xD9\xB7\xD1\xC1\xDA\xDB\xCB\x70\xF3\xB7\x8F\xDC\xB8\xC0\x06\xDC\xAC\xD2\xA8\xD2\x2C\x6F\x41\x40\xB7\xD9\x9B\x16\xDD\xE1\xD9\x01\xA9\xC3\xD6\xDC\xC5\xDA\x9C\xB8\xC9\xDB\x14\xB7\x0F\xDC\x73\xDB\x2C\xB2\xE2\xCF\x6E\xCE\x96\xA5\xDC\xD2\xDA\xE0\xB8\x8A\xDD\xBA\xD3\xC8\xCB\x71\xD8\xB7\xDB\xA8\x2E\xDD\xED\xDA\xF5\xA1\xC6\xDE\xDD\xCC\xCB\xB4\xB8\xE1\xDB\xDB\xB3\x1B\xDC\x79\xD9\x2E\xBA\xE3\xCA\x6F\xD0\xAB\xFD\x50\x57\xAF\x1E\xDD\x7B\xD9\x0B\xB2\xE4\xD1\x6F\xFA\xAA\xC0\xDC\xB8\xC1\x22\xDD\x7D\xDC\xED\xAA\xE4\xD8\x6F\xFE\xAC\xC7\x52\x41\xDD\x28\xDE\xF4\xD1\x2B\x53\xD6\xC7\x72\xC8\xA3\x6B\xBA\x4D\xDD\xFD\xDB\x8F\xDF\xCA\xD9\xE4\xD2\x72\xE7\xB7\xFC\xA7\x59\xDD\xFF\xDB\x5B\xC9\xCC\xDA\xE0\xC2\x6A\xE4\xB9\x8D\xDC\x14\xDD\x9A\x50\x00\x05\x9E\x36\x10\x0B\x6B\x4C\x73\x05\x02\x45\x99", + "\x2F\xDC\x1D\x81\xCE\xD5\xE5\xDE\xC3\xB4\xB9\x82\xDC\x01\xD2\x89\x03\x9D\xDD\xC0\xD4\xCD\xCE\x08\x3B\xB9\xED\xDA\x91\xD7\xED\xB3\x9F\xDF\xC2\xD1\x39\xA3\x74\xDA\xB8\x8B\xA8\x86\xDD\x0E\xDC\xBB\xB1\xD1\xD0\xE2\xC5\xDA\x8C\xBA\xA3\xDC\xA7\xB5\x47\xDE\x89\xDB\xB5\xC2\xE9\xC9\x71\xFB\x7E\x95\xDD\x2C\xDC\xA9\xC8\xA6\xDF\xC5\xD3\x5B\xC6\x08\x1B\xBA\xB2\xDC\x40\xA5\x4F\xDD\x8D\xDF\x67\xA2\xEA\xD8\x71\xF3\xB0\x84\x02\xA5\xDD\x1D\xDC\x2D\xB1\xD5\xDE\xE3\xCE\x74\xEB\x75\xAC\xDD\x43\xDD\xB1\xB0\xAC\xDE\xC8\xD7\xE9\xD1\xEE\xB3\xBA\xCB\xDC\xB3\xD0\x85\x03\xAD\xDE\xC9\xDB\xE5\xC0\x00\x3B\xBA\xDA\xDC\x07\xDC\x38\xDF\xD5\xAF\xD7\xD2\xE6\xC9\x05\xC4\xBB\xE5\xDC\xA7\xD5\x63\xDC\x9A\xD9\xD9\xD3\xEC\xCB\xEB\x82\xE2\x04\xDD\x4C\x9D\x67\xDF\xA1\xDA\x7A\xA2\xED\xCA\x74\xF1\x70\xD5\xDD\x8D\xDC\x76\xB4\xB6\xD8\xD2\xD4\xB1\xBB\x76\xD3\xBA\xB6\xCE\xDE\xDC\x4B\xDC\x53\xB1\xDC\xD9\xE9\xDB\xFD\xA4\xBB\x9C\xDD\xFC\xA7\x73\xDC\xA8\xD9\x72\xAA\xEE\xC3\x75\xDB\x67\xED\xDD\xA6\xDC\xEB\xA4\xBC\xDA\xD5\xDF\x84\xB3\x77\xED\xBA\xB3\xDA\xB0\x70\x5C", + "\xC2\xBD\xD9\xD6\xD9\x57\xBB\x77\xF4\xBA\xB7\xD5\xF9\xDC\x39\xDF\xB0\x9E\xDF\xD8\xEB\xCC\xCB\x84\xBC\xBC\xDD\xC1\xDC\x82\x03\xC1\xD8\xD8\xDA\xED\xD7\xBA\x8B\xBC\xC5\xDD\xB7\xD9\x6D\x71\x74\xBF\xE1\xD8\xEC\xC3\x64\xC2\xCB\x14\xDE\xCB\xDC\x8B\xDE\x17\x76\xE1\xDC\xF1\xDA\x77\xDD\xBC\x82\xDE\x3B\x9E\x8C\xDF\x84\xDE\xB4\xDA\x10\x09\xC4\x59\xE1\x2C\x3C\x00\x00\x87\x8A\x43\x04\xA1\x84\x01\x72\x08\x10\x14\xD4\xBE\x2F\xDE\x90\xDE\x42\x01\xE6\xD5\xE7\xCF\x2B\xF4\xBC\xF8\xDC\x04\xD2\x87\x03\xCD\xDC\xCF\xD7\xD0\xD1\x9C\xBB\xBC\x80\xDD\xA4\xD6\x86\xA7\xCF\xD8\xDA\xD1\xFA\x83\x7A\xD3\xBB\xCA\xAC\x46\xDE\x6B\xDC\x60\xC9\xE9\xD9\xED\xD1\xE1\x8C\xBD\xDC\xDD\x45\xB7\xA7\xDF\xB7\xDE\xF9\xC2\xF5\xC2\x77\xE9\x82\xD5\xDE\xE5\xDC\xA5\xD6\xCB\xDF\xEA\xA8\xF5\xC8\x77\xF4\x01\xDD\xDE\xEB\xDC\x4C\xC7\xCC\xDC\xEB\xD4\xF6\xDE\x69\xC5\x04\x60\xDE\xEE\xDC\xA1\xDD\xD9\xDA\xE6\xD5\x1A\xC7\x7B\xD1\x77\xE8\xDE\xF1\xDC\x8F\xC4\xDC\xDC\xDE\xDC\x8A\xC3\x7B\xF8\x82\xF3\xDE\xF7\xDC\xA7\xDF\xDA\xDD\xE6\xD7\xF5\xDB\x7B\xF8\xBC\x87\xD2\x23\xCE\x7D\x88", + "\xD5\xBA\xF0\xDC\xF6\xC5\x08\x04\xBE\xFC\xDE\x8E\xCB\xC3\xDF\xDF\xDB\x21\xDD\x27\xAA\x7C\xFC\xBC\xEE\xDA\xD6\xA6\xC7\xDC\xD0\xDE\x81\xD0\x24\xB2\x7C\xC4\xBD\xA4\xA0\x96\xDF\xA3\xDC\x5B\xB1\xF3\xDA\xF4\xD1\xCB\x9C\xBE\xCD\xDE\x80\xCB\xCF\xDC\xD4\xDC\x5D\xB2\xFA\xD3\x7A\xF3\x80\xA5\xDF\x56\xDF\xC4\xDF\x5A\xB8\xF5\xD9\xF5\xC9\x05\xEC\xBE\xDE\xDE\x12\x03\xD7\xDD\xD8\xD8\x02\xDA\x10\x12\x7D\xE9\xBD\x91\xDF\x57\xAE\xDB\xDD\xDC\xDA\x01\xD6\xF8\xD9\x7D\xFE\xBE\xD3\xDC\xB5\xDF\xE8\xBA\xEE\xDC\xEE\xD1\x87\xC6\x08\x03\xBF\xF9\xDE\xE5\xDB\xE0\xDC\x2E\xC7\xF8\xDC\xEF\xD4\xD8\x8C\xBF\xFF\xDD\xAE\xDF\xDF\xDD\xE1\xDE\xFA\x9F\xFC\xC5\x78\xEE\xA8\x8A\x02\xF8\x88\xAA\xBD\xF6\xDB\xFA\xD4\x9E\x17\xBA\x9B\xBF\x88\xDF\xAB\xCB\xEF\xDF\xE2\xDE\x30\xDD\x27\xA2\x7F\xCF\xBE\x81\xDD\x0C\xA6\xF3\xDF\xE4\xDD\x99\xD1\xF1\x8A\x7F\xD7\xBE\xFC\xA7\xEE\xDE\xCD\xDF\xBE\xA9\xFE\xDD\xF9\xD4\xC5\xB4\xBF\xA0\xDF\x71\xB3\xFB\xDF\xE8\xD9\x86\xBA\xFF\xC6\x7D\xE3\x65\xFD\xDF\xA9\xDE\xAD\xD6\x43\x00\x00\xED\xFA\xCE\x2C\xC4\xC0\xB0\xDF\x03\xE1\xE8\xBB\x01", + "\xE3\xF6\xDF\x4F\xAB\x80\xF7\xBE\xC0\xA4\x0E\xE1\xDD\xDC\x48\xC9\x02\xE4\xFC\xCC\xCB\x94\xC0\xC8\xDF\xF9\xDE\x05\xE2\x06\xE6\xEC\xD4\x10\x17\x80\xCD\xBF\x89\xDE\xDD\xDE\x5C\xC2\x07\xE0\xFA\xD6\x00\xFE\x7E\xE6\xC0\xA2\xE0\x6B\xBB\xFC\x84\xF7\xDA\x05\xE0\xFE\xD7\xFD\xAC\xC0\xE3\xDF\xD2\xD5\x5A\x83\x0B\xE7\xFC\xD1\xF4\xD6\x9E\xB3\xC0\xEB\xDF\xFF\xD8\x20\xA7\x0D\xE7\xFD\xDD\xFC\x9B\x81\xF2\xBF\x85\xA6\x3E\xE1\xFA\xDF\x13\xB1\x08\xE8\xFF\xD4\xC5\x84\xC1\xFB\xDF\x80\xCB\x23\xE2\xFF\xDF\x54\xBA\x04\xE1\x80\xF6\x9C\xCD\xE0\x05\xE1\xD5\xC8\x14\xE0\x01\xEE\x17\xD3\x82\xCC\xC0\xFC\xA7\x56\xE1\x07\xE0\x87\x99\x0B\xE2\x01\xF4\x7D\xC6\x04\x5C\xE0\x15\xE1\x7D\xAC\x18\xE0\x03\xE6\x04\xE9\x81\xD7\x5D\xE3\xE0\x1F\xE0\x76\xB4\x1A\xE4\x04\xEC\xD3\xCA\x08\x2B\xC1\xD6\xDF\x8F\xDB\x82\x03\x1B\xE0\xE1\xD8\xEF\xDF\x82\xE6\xC1\xB8\xC1\x73\xE0\x86\xDD\x0C\xB9\x0F\xE0\xF1\xD2\x82\xE7\xC1\xFF\xE0\x1C\xE0\x00\x03\xFD\x82\x21\x0C\x3F\x97\x62\xED\xC0\xDF\xC1\xFD\xD6\x24\xE0\xF9\xA1\x11\xEB\x04\xF4\xD8\x8C\xC2\xCE\xE0\xCE\xCF\x47\xE1\x14\xE6", + "\xE6\xC7\x63\x52\x84\xD4\xC1\xC6\x9E\x96\xE1\x2B\xE0\x1D\x81\x13\xEA\x05\xF8\x99\x9C\xC2\xDD\xE0\xFF\xA9\x4F\xE1\x18\xE3\x3B\xB2\x0A\xE4\x83\xCF\x61\xA5\xE1\x69\xE1\x18\xB8\x2A\xE4\x0D\xE6\x73\xCB\x85\xF0\xC1\xEE\xD1\xAE\xE0\x3A\xE2\x2A\xE1\xD1\xA1\x0B\xFA\x83\xD5\xA8\x81\xD9\x90\xE1\x19\xC1\x2D\xE5\x0F\xED\x0A\xEB\xEB\xBB\xC2\x95\xDE\x52\xCB\x5F\xE1\xC6\xDA\xAA\xCF\xBD\xC8\x62\xEF\xC5\x15\x63\xCA\xD7\xED\xD4\xF7\xDC\xAC\xC3\xBE\xD1\xEE\xA0\xB1\xD6\x63\x62\xD8\xF4\xD4\x0C\xE1\x17\xDE\x10\x1F\x5E\xDF\xAF\xC2\xE1\x23\xDE\x8D\xDE\x34\xE4\x06\xE4\xF9\xD1\x9C\x98\xC3\xBF\xD5\xDD\xD5\x6F\xE1\xB1\xD6\x13\xE7\x75\xA2\x87\xEA\xAB\x80\xCB\xE6\xE1\xCA\xD5\x1D\xE5\x20\x01\x52\x94\xFA\xAD\xC3\xDC\xDF\xEF\xE1\x43\xE3\x0C\xC1\x1E\xE3\x0D\xE7\x3A\xF4\xC3\xDC\xE1\xEC\xDE\xEB\xA7\x3D\xE0\x07\xE8\x79\xDB\x87\xFC\xC0\x92\x02\xFE\xE1\x1F\xE0\xC3\xA1\x20\xE2\x04\xEC\xBB\x84\xC4\xC5\xE0\x4F\xB1\x83\xE2\x22\xE4\x16\xBA\x10\xED\x84\xC5\x6D\x8D\xE2\xB9\xE1\xB1\xB0\x44\xE3\x12\xE1\xCD\xC6\x08\x13\xC4\x97\xE1\x14\xA3\x8B\xE2\x26\xE0\x20", + "\xE1\xDD\xBA\x88\xDD\xC2\xDB\xA8\x1E\xE2\x50\xE0\xFF\xA1\x24\xE3\x0A\xEE\x47\xE4\xC4\xA6\xE1\x06\xE3\xAB\xAF\x49\xE1\x15\xE7\x0B\xEE\x08\x2B\xC4\xAC\xE1\xEE\xDA\x8E\xE1\x20\xE7\x25\xEF\x0A\xE5\x19\xF4\xC4\xB2\xE1\x80\xCB\x9B\xE2\x2D\xE1\x2E\xBA\x13\xFC\x85\xCE\x9F\xBD\xE2\xC0\xE1\xDD\xBC\x50\xE3\x18\xE2\x14\xEB\xEB\xA3\x14\xD4\xBE\x47\xE2\xEE\xDD\x52\xE2\x1E\xE3\x96\xAB\x8A\xF5\xC3\xD3\xD0\x4E\xE2\x7C\xE1\x0E\xE1\x72\xA1\x15\xFC\x87\xFB\xA0\xD5\xE2\xFF\xE0\x87\x00\x56\xE2\x20\xE6\x3D\xBB\x8A\xC5\xC4\xCA\xAC\x5E\xE2\x84\xE0\xDB\xA9\x2C\xEB\x10\xEF\xC2\xA4\xC5\x8E\xE2\xEC\xB5\xB3\xE1\x44\xE7\x54\xBA\x16\xF4\x88\xCB\xA5\x8A\x02\x6D\xE2\x8C\xE2\xF5\x99\x2E\xEB\x11\xFA\x8A\xD1\x77\xF4\xE2\x1F\xE3\x7F\xA8\x5E\xE2\x24\xED\xFC\x9B\x8B\xE5\xC4\xA5\xC6\x7E\xE2\x94\xE0\x58\xE7\xEA\xA1\x18\xEC\x89\xE5\xA2\x92\x02\x85\xE2\x98\xE3\x54\xD0\x2E\xE6\x14\xED\x8C\xF8\x82\x89\xE3\x35\xE2\x20\xA4\x64\xE0\x27\xE1\x97\xB3\x8C\xFB\xC4\xB4\xB1\x96\xE2\x9F\xE3\x0C\xC1\x33\xEB\xF9\x80\x29\xF0\x07\x00\x2D\x2C\x01\x00\x0D\x00\x01\x82\x80", + "\x0E\x03\x82\x81\x07\x06\x81\x90\x09\x80\x01\x08\x86\x09\x0C\x93\x0C\x94\x0C\x85\x08\x86\x0B\x0C\x9B\x4C\x89\x0C\x82\x04\x87\x05\x0C\x8C\x0C\x80\x89\x85\x81\x84\x84\x09\x8B\x89\x8E\x89\x80\x89\x84\x89\x09\x94\x89\x9A\x89\x84\x8D\x84\x8F\x09\xA0\x89\x82\x99\x84\x92\x82\x93\x06\xA8\x86\x8A\x96\x84\x96\x82\x97\x06\xB0\x86\x92\x96\x84\x9A\x82\x9B\x06\xB8\x86\x9A\x96\x84\x9E\x82\x9F\x03\xC0\x83\x82\xA3\x84\xA3\x80\xA3\x03\xC8\x83\x8A\xA3\x84\xA7\x80\x8B\x33\x9B\x9D\x9F\x81\x93\x90\x86\xAD\x07\x8C\x9E\xA2\x80\xB2\x82\xB0\x81\x64\x82\xA6\xA2\x88\xB5\xA6\xB5\x9B\x6C\xBB\xAE\xA5\x9C\x84\xAE\x81\xB9\x01\xF5\x81\x97\xB1\x81\xBD\x81\xBD\x01\xFD\x83\x8E\xA3\x80\xAB\x80\xA9\x03\xD4\x83\x96\xA3\x80\xAE\x80\xB8\x01\x86\xCA\x8C\x8A\xC0\x00\xC6\x00\x8E\x80\x10\xC0\x02\xCA\x80\xCA\x81\x96\x82\x98\xC2\x8A\xCA\x80\xCE\x81\x9E\x81\xA0\xC0\x02\xD0\x00\xC5\x86\x0F\x91\x93\x99\x8F\xB9\xA9\xC1\xAA\x83\xBF\x85\xD2\xB4\xD1\xE3\x97\xE1\x09\xAD\xC1\x8F\xD1\x81\xD9\x81\xD9\x01\xB5\xC1\x97\xD1\x81\xDC\x83\xE5\x29\xCD\xED\x82\xE1\x9D\x88\xE3", + "\x9A\x6B\xB9\xAD\xBD\x9F\xB0\xF3\xA0\xF1\x47\xE4\xCB\xA6\xF9\xB0\xF4\xC0\xF5\x82\xEC\xC4\xC7\x9C\xE3\x96\xE7\xA4\xD0\x46\x42\x74\x00\xD4\x40\x06\x74\x00\xD8\x40\x0A\x74\x00\xDC\x40\x0E\x77\x6E\xBD\x7F\x65\x6B\x69\xA9\x6B\x63\x81\x81\x07\x89\x8B\x81\x83\x0F\xAE\x7D\x54\x7C\x61\x72\x75\x58\x7D\x7E\x76\x76\x70\x7E\xC8\x7A\x7A\x70\x7F\xE1\x7E\x73\x7B\x73\xE5\x51\x77\x47\x79\x4F\x69\x73\x57\x7A\x57\x6D\x7C\x8B\x7B\x2E\xB1\x70\x8F\x7C\x32\xB5\x75\x8F\x7D\x37\xB9\x79\x8F\x7E\x41\x7D\x75\x53\x7F\x63\x41\x83\x65\x71\x97\x47\x7B\x65\x72\x59\x5E\x87\x60\x88\x76\x62\x8A\x5C\x89\x03\x57\x04\x8D\x65\x36\x99\x68\x8D\x67\x3A\x89\x9D\x8B\x92\x2F\x80\x81\x8E\x80\x5F\xB0\x61\x98\x6D\x63\xB8\x65\x9B\x56\x4A\x9F\x5C\x90\x5E\x4E\xBC\x5D\x99\x75\x6F\x99\x71\x9D\x77\x73\xB1\x57\x9A\x9D\x69\x8D\x9B\x9B\x59\x33\x82\x90\x98\x91\x62\x86\x94\x98\x92\x74\x83\xA4\x5F\x9D\x8D\x79\x91\x67\x9E\x06\xBD\x9A\x83\x9F\x0E\x81\xA1\x69\x9D\x93\x85\xA8\x9F\xA1\x7A\x8A\xAE\x98\xA3\x70\x8E\xA2\x9C\xA4\x82\xBC\x88\x9A\x8F\x6A\x80\x9C\x99\x42\x5E\xA6\xAC", + "\x9C\xAA\x7E\xAA\xA0\xA0\xAB\x9F\x92\xA9\x60\xA5\xA8\x56\xAC\x68\x43\xB5\xA5\x83\x93\x89\x45\xA9\x87\x93\x8A\x66\xAE\xA4\xA0\xAC\x86\xB2\xA8\xA1\x42\x18\x76\xA9\xA4\xAE\x9B\xBA\xAD\xA4\xAF\xBC\x60\xAF\xAE\xA8\x95\xA4\xA7\xA4\xB5\x98\x99\x82\x96\x6D\x54\x9F\x66\x97\x68\x3D\xA1\x8F\x8F\x88\x41\x86\xBB\xA0\xB2\x8D\x8A\xBF\xA0\xB3\x91\x8E\xB1\xA8\xB4\xA3\x92\xB5\xAA\xBC\xA7\xB4\xB9\xAA\xBD\xAB\xB8\xBD\xAB\x87\xED\x99\x9F\xBB\x96\xF1\x8F\x96\x89\x94\x28\x93\x9A\x89\x95\x3B\x88\xCF\xAA\xBB\xB1\xB0\xB3\xAC\xC0\xB7\x82\xC9\xAC\xC1\xBB\x86\xCD\xAE\xBE\xDF\xBC\xB1\xBA\xBF\xE3\x9C\xC7\xB6\xC7\xD9\xA0\xCB\xB6\xC8\xDD\xBE\xA0\x70\xB8\xC1\xA2\xB3\xB0\xB9\x09\x5C\x2C\x41\x27\x0C\x5E\x2C\x43\x27\x50\xB2\x67\xBB\x76\xE9\xBA\x6B\xBA\x6F\x58\x8B\x6A\x97\x63\x3F\xC1\xD7\x77\xD0\x0C\x85\xDF\x75\xC5\x57\x89\xCA\xD3\xC2\x4C\xC9\x40\xD3\xC3\x42\xD1\xC8\xBB\xC4\xEA\x94\xDC\xBB\xC5\x0A\xD9\xCC\xC3\xC6\x03\x5B\xD7\xB0\xC4\xC9\x92\xCB\xB0\xC5\xCD\x96\xCF\xB0\xC6\xD1\x9A\xC3\xB6\x41\x6A\xF3\xBC\xD9\xBD\x6E\xF7\xB0\xDD\xBE\x72\xFB\xB4\xDD", + "\xBF\x76\xFF\xB9\xDA\xD3\x08\x90\xDC\x86\xA7\x31\xE4\xC3\xCE\xC9\x35\xE8\xC7\xCC\xDE\x88\xDA\x8C\xA5\x87\x62\xC8\xD6\xD6\x69\x4B\xEA\x6D\xD0\xD7\x4F\xDE\xD4\xD0\xD8\x46\xD9\xE2\x84\xB0\x15\x9C\x92\x41\xDE\x01\xFB\xD3\xC1\xDF\x05\xFF\xD7\xC1\xD5\x64\xD7\xD6\xD9\xD6\x68\xEB\xE5\xE6\xE2\x52\xD0\x8E\xB7\xE3\x83\xE7\xC5\xE1\xCA\x87\xE0\xE9\xE2\xE8\x51\xE4\xE3\xD5\xDC\xB4\xF3\xD5\xD9\xDD\x67\xF7\xD5\xF3\xDA\x5D\xED\xDF\xD7\xDB\x61\xCC\xF3\xDA\xF3\xB6\xD0\xF8\xEE\xF4\xBA\xC6\xF6\xE6\xB6\x98\xDA\xFA\xE5\xED\x9C\xD8\xDE\xE5\xC3\xE1\xD4\xF1\xEA\xF5\xA3\xD8\xF5\xEA\xF9\xA7\xF4\xC9\xE8\xFB\x01\x55\xB4\xE6\xF8\xBC\xCA\xFE\xEE\xCC\x13\x5D\x72\x85\x1F\x7E\x7D\xE3\x70\x79\x79\xF2\x6B\x78\xE0\x4D\x72\x71\xE7\x44\x71\x7A\xED\x7A\x6D\xF5\x7C\x67\x7A\xBF\x59\x7B\x81\xDB\x6D\x81\xF7\x0F\x8F\x7A\xC3\x42\x25\x58\xD3\x72\x83\xFB\x14\x81\x7E\x0B\xB3\x78\x83\xE7\x7C\x79\xFA\x37\x7B\x7D\xDC\x41\x24\x75\x1D\x6E\x77\xC7\x30\x71\x64\xD9\x63\x61\x70\x25\x61\x79\xE4\x43\x73\x73\x10\xAD\x73\x82\xAF\x75\x81\xEC\x17\x83\x77\x0C\xB9\x86\x81\xC2", + "\x70\x80\xF1\x02\x2A\x7E\x1F\xB1\x80\x88\x33\x82\x89\x0D\xC4\x87\x86\x06\x87\x8B\x83\x49\x9D\x83\x12\xAF\x8B\x76\xE4\x4B\x74\x5B\x11\x49\x6B\x0A\xDE\x7D\x84\xF0\x5C\x8C\x7F\x5E\x9D\x77\xD1\x75\x70\x73\xFB\x6E\x80\x00\x20\x91\x83\x0F\xA3\x81\x89\x12\x83\x8F\x84\x45\x89\x86\x06\xE3\x8C\x83\x32\x9E\x81\x20\x71\x87\x8D\x01\xE3\x7E\x65\xF2\x68\x84\x8D\x3A\x8E\x8E\x19\x80\x0D\x88\x39\x8F\x8C\x8E\x51\x96\x8F\x14\xF8\x85\x8A\x23\x80\x78\x89\x3B\x8A\x89\x0F\xCC\x84\x80\x11\x86\x84\x84\x08\x86\x86\x02\xF9\x88\x90\x4C\x8A\x97\x8F\x00\x10\x87\xCA\x32\x8D\x64\x1A\xAF\x66\x86\x8D\x78\x87\x25\xD8\x89\x92\x2D\x9B\x92\x90\x9E\x84\x92\x2B\x86\x94\x94\x31\x94\x42\x58\x03\x4A\x96\xB9\x69\x8E\x7F\x35\xBE\x92\x80\xAA\x78\x97\x1C\x9F\x95\x8F\x50\xB7\x8B\x94\x95\x9A\x8F\x15\xFC\x89\x8A\x3F\x9B\x89\x95\x5D\x87\x83\x17\xB0\x61\x8D\xCD\x7F\x96\x66\x03\x4D\x91\x40\x20\x1C\x21\x50\x0C\x22\x14\xE5\x8C\x23\x28\x67\x9A\x9C\x86\x24\x14\x9D\x09\x2F\x9D\x42\x25\x10\x9E\x83\x34\x99\x21\xA6\x0C\x23\x29\x0C\x28\x14\x86\x29\x14\x21\xAA\x0C\x23\x2A", + "\x0C\x2C\x14\x86\x2D\x11\x9B\xA0\x9B\x98\x2C\xDD\x98\x7D\x6F\x92\x77\xA0\x68\x9A\x9A\x1A\xA6\x77\x98\xF5\x6B\x30\xA2\x83\x9D\x7D\x02\xFF\x7E\x71\x00\x96\xA1\x99\x00\x18\xA1\x2E\x9A\xA2\x94\x8E\xB2\x96\xA3\x2C\x83\x81\x42\x22\xAB\x98\x5D\x92\x8F\x95\x54\x91\x96\x15\xB3\x94\x9B\x5A\x96\x9F\x96\x21\xA8\xA1\x33\x8A\xA1\xA6\x86\xAA\x86\xA1\x3C\x83\x40\x4B\x8F\x9C\x99\x48\x8E\x9B\x92\xD0\x92\xA6\x25\xA8\xA4\x8D\x8B\xBA\xA6\xA8\x3C\xB4\x92\x52\xD2\x94\xA6\xA0\x9A\x92\xA8\x4F\xAD\x97\x4B\xBC\x91\x9B\x52\xB4\x97\x94\xD7\x83\xAB\x2A\xD0\x8A\xAA\x49\xB0\xA2\xAA\x3E\xBB\x8E\x55\xB6\x98\xAB\x88\x89\xA3\xA2\xF4\x75\xA1\x4A\xA0\xA2\xAD\x61\x92\xA5\x98\x14\xBE\x98\x32\xF8\x79\xA6\xB7\xBB\xA0\xAE\x87\x92\xAD\x53\xF4\xA9\xAB\x0D\x40\xB5\x97\x7A\xBF\xA0\x5F\xE2\x9D\xAF\x8C\x84\x9B\xA3\xC6\x89\xB3\x5C\xFC\xA5\xAE\x4D\x46\xB0\xAF\x71\xB2\xB3\x60\xAB\xA5\xB1\xCB\x4C\x71\xAD\xD3\x8B\xAF\x4D\x83\x41\x91\xC6\xA3\xA7\xB1\x25\xB1\xB1\x43\xFB\xAF\x8D\xCA\x98\x5F\xB2\x90\xB9\xAF\x6A\x8A\xBD\xB5\xCE\xA4\x7F\xB3\xBF\x6C\xA9\x1F\xAA\xA6\x20", + "\xC6\xAE\xB4\x65\xB0\xA9\xB6\x6C\xBF\xAC\xB5\x45\xBF\xB4\x95\xC1\xAF\x9A\x49\xB3\xAA\xB7\x6A\xBC\xB3\x20\xC7\xA4\xAD\x72\xC8\xAB\xB9\xA5\xA8\x70\x98\xC4\x46\xA2\x6D\x85\x98\xB6\x00\x97\xB8\x9C\xD9\xBC\xB2\x5F\xD0\xA7\xB1\xAE\x82\xB3\xB7\x20\xBE\xB7\x76\xBB\x9D\xBB\x8E\x9F\xBA\x72\xE1\x9A\xBB\x78\xE5\xA7\xA9\xB3\x89\xA8\xB4\x55\xA5\xB8\x2A\xD1\xB0\x92\xFA\x91\xAF\xBE\xB9\xAF\xBD\x50\xF2\xBE\xB1\xBB\xB1\xB1\xB3\xB3\xB3\xB1\x6D\xF3\xB3\xBA\xFB\x95\xBC\xAA\xCD\xB6\xA7\x73\x82\x2C\xBF\xA2\xBE\xBD\xBC\x53\xBE\xA9\x4D\xE0\xA8\xA7\x0A\xEE\xA6\xAC\x5C\xB9\xC3\x79\xCE\xB9\xBC\x86\x2E\x14\x21\x2A\x06\xC4\x43\x2B\x0C\x20\x16\x2A\xC1\x21\x2C\xC9\x21\x0B\x2F\xC6\x21\x18\xC6\x23\xC6\x09\x27\xC4\x8C\x8C\x2E\x04\x1A\xC3\x26\xC6\x03\x2F\x06\x8F\x82\x20\xC8\x81\x30\x03\xC8\x01\x25\xC9\x40\x2E\xC9\xC7\x15\xCC\x21\x06\x48\xC0\x02\x92\x80\x00\xCB\x26\xFB\xC1\x21\x32\x11\xCB\x94\xB3\x0A\xCA\x86\x34\x05\xCB\x09\x35\x04\x98\x86\x2D\xC6\x2B\xF5\xC4\x21\x36\x03\xCF\x40\x5F\xC6\xCD\x1F\xFC\xC2\xCD\x02\x2C\xCE\x41\x3A\xC7\xCD\x84\x37\x00", + "\xCE\x01\x38\x04\x43\x2F\x18\xC5\x3D\xCE\xC9\x21\x4C\xC6\x20\x9F\xD7\xC7\xC6\x3F\xC4\xD3\x20\x38\xC2\xD3\x9F\xE4\xC6\xD1\x3A\xC6\x22\xC8\x09\x23\xD2\xA3\x83\x27\xC9\x48\xCB\xD3\x20\x81\xC3\x22\xA4\xEE\xC9\x21\x2A\xCA\xD7\xD0\x02\x3E\xD2\xA6\x97\xD2\x21\x2C\xD6\xD0\xD4\x01\x3C\xCB\xA9\x93\xD1\xCF\x46\xDC\xD6\x20\x62\xCB\xD7\xAB\x83\x25\xCD\x4F\xEC\xD1\x20\x69\xD2\xD4\x91\xDE\xCE\xD5\x5D\xC9\x25\xD6\xA3\xC8\xD4\x00\x72\xC1\xD9\x5B\xC0\x07\xCE\xBA\xC9\xC8\x43\x7A\xC9\x20\x74\x89\x20\x16\x0C\x31\x15\xB4\xD3\xD9\x20\x69\xD5\xDC\xDA\x06\x36\xD9\xB6\xD8\xD3\x20\x6D\xDD\xDC\xDB\x02\x3E\xD9\xB8\xE0\xD1\x20\x71\xC1\x22\x16\x0C\x33\x15\xBA\x8C\x24\x17\x7A\x83\x25\xDD\x09\x35\x16\xBB\x82\x22\xDF\x84\x36\x14\x21\xF7\xD6\xDC\xBE\xFB\xDA\xDF\x7E\xC6\x21\xDF\xFF\xDC\xDD\xC0\xFE\xD3\x20\x80\xC5\xE2\xE0\x07\xE9\x23\x2D\x0C\x28\xDC\x85\xEB\xDE\xE1\x09\x2A\xDD\x42\x38\x13\xDF\x80\x14\xE1\x21\xB9\x15\xE0\x00\x19\xE9\x20\x5D\x0C\x26\xE3\x1D\xFF\xE2\xC8\xA1\xE4\xE4\x83\x20\xE6\xE4\x23\xE8\xE5\xC9\x83\x27\xE4\x96\xE9\xE6\xE5\x09\x3B", + "\x14\xC3\x8C\x22\xE7\x88\xF4\xE7\xE1\x06\x3C\x14\x43\x3A\xE9\x20\x9E\xF9\xE3\xE7\x40\xFD\xE5\xD0\xBF\xE2\xE9\xA2\xC4\xEF\xE8\x03\x3E\xE5\xD2\xC3\xE3\x21\x5E\x2B\xBB\xAB\xED\xA7\xA6\x80\x9A\x9E\xE8\x06\xDE\xB0\x8C\x01\xD6\x7E\xB0\x55\xE5\xC1\xB7\x98\xB1\xB0\x9A\xA8\xBC\x5F\xDC\xE7\xB4\x03\xC2\xB8\xC1\xC4\xB4\xB7\x22\xE4\xED\xA4\x92\x8A\xBA\xB5\x69\xEA\xC3\xDA\xCF\xE0\xC5\xA8\xCC\xBB\xEA\x6C\xAC\x20\xDB\xC4\xAF\xC3\xFA\xA1\xC0\xBF\x11\xDC\xC3\xDE\xE3\xAD\xBF\x06\xFF\xE9\xEB\x6D\x98\xB9\x42\x03\xF6\xAE\xAF\xC7\xC0\xEC\x09\xDB\xB3\x1B\x8C\xF6\xB3\xAB\xDC\x98\xF1\x89\x8A\xF2\x41\x14\xFF\xB4\xCB\xCB\xA0\xF3\xA6\x9A\xF1\xD3\xF4\xEE\xEE\xBB\xD6\xBA\xEB\xE0\xAB\xF0\xE9\xFF\xBF\xC0\x0D\xE2\xB3\xC2\x01\x3C\xF0\x70\x9E\xFD\xA6\xD0\xDF\xAA\xF4\x9C\x8A\xF6\xD5\xB7\xB8\xEA\xEF\xA8\xF0\xBE\x7A\xEB\xF4\x86\x80\xF8\xEF\x9B\xB2\xF0\xB9\xB4\xE8\xAE\xED\x9B\xC8\xF6\x40\x81\xFB\xF7\xDC\xBD\xF6\x7B\xBF\xF3\xC0\xDD\xDD\xEF\xAF\x5F\xE8\xB1\xE4\xE2\xE3\xF2\xE1\xD9\xFE\xBC\x61\xE4\xC7\x62\xCF\xF7\xFA\xF2\x9F\xFA\xC4\xE1\xF2\xC0\x48\xC7", + "\xF2\xBB\xE4\xC0\xC6\xF7\x89\xE9\xF7\xE6\xDE\xFF\xF0\xED\xF1\xEA\xF2\x8B\x85\xB4\xFB\x85\xFE\xFD\xD6\xE3\xC2\xFD\x7C\x5A\x7F\xF4\x77\x76\x90\x77\x7F\xDC\x7B\x48\x8C\x5B\x7F\x16\x66\x78\xA6\x70\x61\xC5\x70\x7B\x8C\x44\x7E\x65\x7E\x78\x04\x86\x7F\x6A\x5A\x5F\xD7\x4A\x80\x7D\x7C\x7A\x70\x77\x81\x6A\x78\x4A\x1A\x8E\x76\xD4\x5D\x81\xA1\x58\x81\x38\x51\x82\xA8\x5F\x76\xC3\x5E\x81\x72\x70\x82\x03\x8A\x82\x68\x7C\x82\xF8\x7E\x82\xD0\x7C\x5E\xD2\x72\x75\xD4\x77\x55\x89\x26\x10\xBE\x0C\x10\x3D\x89\x10\x3F\x8C\x83\x3E\x83\x84\x40\x84\x84\x42\x85\x84\x48\x87\x84\x4A\x83\x10\x41\x8C\x84\x46\x83\x10\xBF\x0C\x10\x51\x89\x10\x53\x86\x10\x55\x80\x85\x52\x89\x85\x54\x8A\x85\x56\x8C\x85\x58\x8B\x85\x60\x8D\x85\x61\x83\x10\xC0\x0C\x10\x65\x89\x10\x67\x86\x10\x69\x84\x86\x66\x8D\x86\x68\x8E\x86\x6A\x80\x87\x6C\x8F\x86\x74\x81\x87\x75\x83\x10\xC1\x0C\x10\xC2\x0A\x87\x7C\x89\x10\x7B\x8E\x87\x7D\x86\x10\x7F\x82\x88\x81\x83\x10\x83\x86\x88\x85\x82\x10\x87\x8A\x88\x89\x81\x10\x8B\x81\x10\xC3\x0F\x82\x23\x8B\x82\x25\x8F\x81\x90\x82\x89", + "\x0E\x64\x82\xF9\x56\x89\x00\x01\x89\x35\x80\x75\x37\x87\x77\x39\x89\x77\x09\x1E\x89\xE5\x77\x61\xE7\x74\x7C\xA3\x83\x5A\x0C\x16\x8A\x13\x88\x7D\xF5\x70\x7E\xDB\x72\x7E\x6F\x4E\x8A\x6D\x79\x82\x93\x81\x83\x95\x8D\x82\xD7\x46\x8B\x7C\x72\x82\x99\x84\x89\x9B\x8C\x8B\x9D\x88\x89\x87\x70\x7F\x99\x72\x7F\x03\x1E\x8B\x84\x7B\x80\xFD\x7A\x89\x81\x7D\x7C\xC5\x8F\x89\x75\x71\x8A\xA7\x71\x7F\xC0\x75\x8A\xC6\x8D\x80\xAE\x76\x82\x03\x2C\x8C\x8D\x70\x8B\x15\x82\x8B\x06\x84\x8B\x8B\x40\x8E\x95\x7C\x7B\x97\x78\x8C\xA1\x7A\x8C\x02\x18\x8E\x9D\x7A\x8E\x9F\x7C\x8E\xB7\x7E\x8E\xF9\x3D\x8A\xDB\x86\x8D\x0E\x8B\x8A\x10\x80\x8F\xB3\x72\x8F\xB5\x74\x8F\xCC\x76\x33\xFE\x88\x7C\x00\x9A\x7C\x02\x9F\x7A\x20\x55\x5A\x05\x9D\x7E\x07\x9F\x7E\xD3\x78\x8D\xD5\x76\x10\x0D\x9C\x7F\x0F\x9E\x7F\xE9\x7C\x61\xDF\x89\x8F\xEB\x81\x91\xC9\x89\x8D\xBD\x58\x8F\xD4\x85\x7A\xFA\x8D\x8D\x9C\x8B\x91\x23\x9C\x81\xC2\x81\x8D\xF6\x83\x8D\xA7\x8C\x80\x25\x9F\x7F\x1A\x91\x5E\x14\x9C\x91\xF3\x8E\x91\xED\x80\x92\x5D\x22\x92\x2F\x9F\x8C\x2B\x9F\x80\x25\x6A\x8D\x29", + "\x93\x7C\xCB\x7A\x90\xE3\x72\x94\x3D\x97\x91\xD0\x80\x94\x7C\x55\x91\xCE\x8A\x94\x3F\x9C\x8F\x20\x5E\x94\x1B\x84\x94\x09\x9E\x8D\x3C\x9F\x8A\xE6\x71\x8B\xE8\x73\x8B\x00\x85\x8B\x36\x91\x90\x38\x95\x8F\x3A\x9F\x8E\x61\x98\x90\x63\x93\x90\x65\x97\x8F\x09\x14\x0C\x67\x90\x91\x38\x82\x91\x9A\x4E\x96\x43\x99\x8A\x45\x96\x82\x74\x99\x94\xD1\x7D\x91\x71\x9F\x91\x13\x93\x10\x79\x9A\x95\xA8\x8C\x95\xAA\x82\x97\xA4\x86\x10\x81\x97\x8B\x66\x70\x83\x05\x82\x83\x07\x88\x4A\x89\x9F\x8B\xB8\x81\x8C\xBA\x83\x8C\x33\x87\x4D\x91\x9D\x8C\x55\x96\x97\x57\x9C\x89\x99\x91\x8E\x5B\x93\x8E\x5D\x95\x8E\x5F\x9B\x48\x9F\x99\x8E\x7B\x97\x93\x7D\x99\x93\x7F\x92\x10\xA7\x91\x8F\xA9\x92\x96\xAB\x94\x96\xAD\x91\x10\xAF\x9F\x8F\xB1\x98\x96\xB3\x9A\x96\xB5\x90\x00\xB7\x96\x90\xB9\x90\x97\xA2\x86\x98\xAC\x8D\x96\x6F\x98\x91\x5E\x93\x93\xC6\x95\x97\x84\x97\x97\x27\x9B\x83\x80\x97\x9C\x4B\x92\x95\x7C\x5F\x9B\x0E\x91\x9C\xC8\x94\x9A\x1C\x66\x9D\x16\x98\x9D\xD3\x94\x9C\x10\x85\x5A\xDC\x9F\x94\xDE\x91\x95\xE0\x90\x52\xE3\x9B\x99\xCD\x9D\x99\xC4\x83", + "\x20\xE9\x90\x8C\xC7\x89\x96\x46\x9F\x46\x8C\x5F\x9E\x93\x91\x9F\xBB\x93\x9F\xA6\x92\x9D\xE6\x9E\x97\x3A\x8B\x9C\x7A\x96\x83\x7C\x93\x9C\xFE\x97\x98\x3B\x90\xA0\x82\x90\x93\x03\xA7\x8D\x05\xA5\x9C\x06\x12\x9E\xFC\x95\x99\x2C\x9B\x96\x11\x88\xA0\x8A\x94\x81\x8C\x96\x81\xBB\x87\x99\x38\x55\x9F\x11\xAD\x98\x1B\xAF\x98\x98\x9F\xA1\x1A\xA6\x99\x22\xA8\x53\xF6\x9B\x98\xB9\x80\xA2\x26\xA6\x8E\x90\x94\xA2\xE4\x8E\x98\x2E\xA3\xA2\xCC\x92\x9A\x85\x9D\xA0\x10\x89\xA2\x18\xAB\xA2\x25\xA3\xA1\xBD\x9C\x58\xC5\x0A\x71\x41\xA9\x10\xC6\x0A\x71\x45\xA9\x10\xC7\x0C\x10\xC8\x0D\x88\x00\x09\x0C\x4A\xAC\xA4\x4B\xA0\x88\x09\x11\xA5\x84\x83\xA5\x50\xA7\xA5\x52\xA6\x10\x54\xA8\x88\x56\xA9\xA5\x03\x1B\xA5\x8C\x8D\xA5\x55\xAA\xA5\x58\xA3\xA6\x5F\xA5\xA6\x5C\xA4\xA6\x5E\xA2\x10\xCA\x0C\xA4\x6D\xAB\xA6\x01\x1F\xA6\x66\xAC\xA6\x6E\xA5\xA7\x70\xA0\x00\x72\xA9\xA6\x03\x19\xA7\x61\xA6\x10\x7C\xAE\x88\x0C\x1F\xA7\x00\x0F\x88\x78\xA6\xA7\x73\xA1\xA7\x86\xAA\xA7\x74\xA7\xA7\x82\xA4\xA8\xCB\x0C\x10\xCC\x0C\x10\xCD\x02\xA9\x94\xA9\x10\x93\xA6\xA9", + "\x95\xA6\x10\x97\xAA\xA9\x99\xA3\x10\x9B\xAE\xA9\x9D\xA2\x10\x9F\xA2\xAA\xA1\xA1\x10\xA3\xA1\x10\xCE\x0C\x10\xA9\xA9\x10\xAB\xA6\x10\xAD\xA3\x10\xAF\xA2\x10\xB1\xA8\xAA\xAA\xA5\xAB\xAC\xA6\xAB\xAE\xA8\xAB\xB0\xAA\xAB\xB2\xAC\x10\xCF\x0D\x67\x09\x1F\xAB\xC2\x69\x69\x02\x12\xAC\xC6\x69\x68\x03\x16\xAC\xB3\x62\x10\xC8\xA5\xAC\xA4\x61\x10\xC0\x6E\xAC\xC2\x60\x69\x06\x1A\xAC\xBE\x66\x10\x95\x65\xAD\xCF\xA0\x00\xC4\xA1\x10\xD6\xAA\x6C\x9D\x6E\xAB\xDB\xA2\x6A\xD2\xA6\x6C\xA6\x6A\xAD\xC2\x6A\x6A\xE8\xA6\x6C\xC4\x65\xAE\xCB\xA1\x10\xB1\x6B\xAE\xEF\xA0\x00\xD1\xAE\xAD\xDB\xA9\x6B\xF2\xA7\xAD\x6B\x62\xAE\xC2\x65\xAF\x00\x0F\xAD\x52\x6C\x6B\xC1\xAB\xAD\xC8\x66\x10\xD0\x0C\xAF\xC6\x6C\x6C\x06\x11\x0D\xC0\xAB\xB0\xDB\xAD\xAD\x00\x0C\xB0\xC2\x6D\xAC\x01\x12\xB1\xC7\xAC\x10\x16\xB3\xAF\xFE\xA9\xB1\xFA\xA2\x10\xD4\xA3\x10\x1C\xB0\xAE\xD8\xA8\xB1\x0F\xB4\xB2\xC2\x64\xAE\x15\xB3\xAE\x26\xB6\xAE\x2B\xB3\xAF\xEA\xA0\xB2\xDB\xAD\xAE\x29\xB2\x6C\xF1\xA0\xB3\xFD\xAD\xB2\x1D\xB8\x6B\x38\xB2\xB2\xFB\xA9\x10\x21\xB1\xB0\xBF\x6B\xB3\x40", + "\xB6\x10\x32\xB1\xB1\x04\xBC\x10\xD2\x02\xB4\x53\x6A\xB0\x03\x13\x0D\x0C\x1E\xB4\x09\x10\xB5\x06\x12\xB5\x4D\xBF\xB4\x56\xB1\xB5\x57\xB3\xB5\x59\xB5\xB5\x58\xBD\xB5\x5A\xBE\xB5\x03\x14\x0D\x0C\x12\xB6\x09\x14\xB6\x06\x16\xB6\x61\xB3\xB6\x6A\xB5\xB6\x6B\xB7\xB6\x6D\xB9\xB6\x6C\xB1\xB7\x6E\xB2\xB7\x03\x15\x0D\x0D\xB5\xB7\x25\xB9\x10\x76\xB3\xB1\x0C\x1B\xB7\x17\xBA\xB7\xDB\xAE\xAF\x7E\xB3\xAF\x1F\xB2\x10\x83\xB9\xB3\x00\x09\xAD\x78\xB3\xAC\x7D\xBA\xB2\x80\xB7\xB2\x8D\xB2\x6C\xE7\xAB\xB8\xC6\x6F\xB2\x86\xB1\xB3\x91\xB6\x6C\x35\xB7\xB9\x37\xBF\xB8\xC6\x68\xAF\x94\xB3\xAF\x45\xB7\xB8\x3C\xB2\x10\x82\xB8\xB9\x9E\xB3\xAF\x05\xB3\x10\xD6\x09\xB9\xF3\xAC\xB4\x02\x17\x0D\x77\xB1\xBB\x79\xB6\x10\xB2\xBC\xB7\x09\x17\xBB\x7F\xB6\xBB\x81\xBC\x10\xBA\xB4\xB8\xBE\xBB\xAD\x8A\xB4\xBB\x8C\xB9\xBB\x8E\xBC\xBB\x90\xB6\xBC\x92\xB1\xBC\xE9\xAC\xBC\xEC\xAE\xBC\xF3\xAB\xB9\x01\x1F\xBB\x88\xBE\xAF\xD4\xB5\xBA\x3A\xBA\xBC\xCF\xBA\xBD\x1A\xB0\xBD\x88\xB5\xB4\xD7\xB3\xB4\x03\x1B\xBA\x02\x18\x0D\xDE\xB8\xBD\x00\x00\xBB\x01\x19\x0D\x0C\x1C", + "\xBE\x09\x1E\xBE\x06\x10\xBF\x03\x12\xBF\x02\x14\xBF\xEB\xBD\xBE\xF8\xBF\xBE\xF9\xB1\xBF\xFB\xB3\xBF\xFD\xB5\xBF\x0C\x1A\x0D\x01\xC3\xC0\x09\x12\xC0\x05\xC4\xC0\x06\x16\xC0\x09\xC8\xC0\x03\x1A\xC0\x0D\xCC\xC0\x02\x1E\xC0\x11\xC0\xC1\x01\x12\xC1\x01\x1B\x0D\xB3\xB7\xC1\xB5\xB3\x10\x18\xC8\xBB\x06\x1D\xC1\xBB\xBC\xC1\xBD\xB9\x10\x20\xC0\xBC\x24\xC2\xBC\x0C\x15\xC2\x88\xB0\xB1\x2A\xC8\xBE\x28\xB0\x00\x2D\xC2\xBE\xA1\x69\xC2\xDB\xA3\xB9\x02\x11\xC3\x5B\x64\xC3\xC2\x65\xB4\x38\xCC\x10\xD2\xB0\xC3\x23\xCF\xC1\xF7\xAA\xC3\xDB\xB2\xC4\x9D\xB6\xC4\x45\xC2\xC2\xC2\x64\xBE\x01\x1C\x0D\x44\xCF\xBA\x0C\x1D\x0D\x19\xC0\x00\x52\xC5\xBC\x06\x15\xC5\x21\xC2\x10\x58\xC3\xAF\x14\xB4\xC5\x41\xC3\x10\x5B\xC8\xB8\x85\xB1\x10\x61\xC8\xBE\xC3\xB4\xC6\x1B\xCA\xC5\xC7\xB0\xC6\x6B\xCA\xC6\xCB\xB9\x10\x65\xC2\xC3\xA9\x61\xC5\xA8\xB7\xC5\xDB\xAF\xC3\x71\xC3\x65\xFE\xA9\xC7\x68\x64\xC7\x3B\xCE\xC7\xC6\x6B\xC7\x75\xCC\xC6\x4B\xCC\x10\xDE\x00\xC8\x50\xC9\x10\xDF\x0C\x10\xE0\x0C\x10\xE1\x0C\x10\xE2\x0C\x10\xE3\x0C\x10\xE4\x0C\x10\xE5\x0C\x10", + "\x8B\xC9\x10\x97\xC9\x10\xE6\x08\xC9\x0C\x1D\xC9\x09\x17\x0E\x9E\xC1\xCA\x0C\x18\x0E\x8E\xC5\xCA\x0C\x19\x0E\xA7\xC9\x10\xAA\xC9\x10\xEA\x0B\xCA\x06\x1F\xCA\x09\x1B\x0E\x0C\x1C\x0E\x0C\x1D\x0E\xB7\xC9\xCB\x09\x18\xCB\xBB\xCA\xCB\x06\x1C\xCB\xBF\xCE\xCB\x03\x10\xCC\xC3\xC2\xCC\x02\x14\xCC\xC7\xC6\xCC\x01\x18\xCC\x01\x1E\x0E\x0C\x14\xCB\x09\x1E\xCC\x09\x1F\x0E\xCF\xCC\x10\xD4\xC9\x10\xF0\x0C\x10\xD9\xC8\xCD\xDA\xCD\xCD\xDC\xCF\xCD\x06\x1B\xCD\xE1\xCE\xCD\xE3\xC0\xCE\x03\x12\xCE\xE7\xC4\xCE\xE9\xC9\x10\xF1\x00\xA3\xA3\x92\xA3\xA5\x92\x10\xED\xC5\xA3\x19\xA1\xA3\x21\xA3\xA3\x00\x03\xCF\x01\xA0\x8A\x0B\xAB\x8F\xE7\x9C\x57\xFA\xC9\xA0\x3E\x92\xA1\x4C\x9F\x46\x01\xD7\xA1\xE2\x85\xCF\xEF\xC7\xCF\xF1\xC7\x4D\x07\xD2\x99\x2A\xA4\x99\x2C\xAE\xA3\xFF\x96\x10\x0F\xDA\x99\xF0\x9C\x8D\x32\x92\x2C\x17\xD0\x9A\x83\x96\xA3\xCE\x9D\x9E\x0C\x1D\xD1\xA8\x92\xA0\xAA\x94\xA0\xAC\x95\xD1\x03\x14\xD2\xB0\x96\xD2\xB2\x98\xD2\xB4\x9A\xD2\xF2\xCE\xCE\x37\xA9\xD2\x06\xA3\xD3\xF4\xCC\xA3\xF6\xCD\xA2\x0D\xD8\x53\x2C\xD8\x9B\x2E\xDA\x9B\x30", + "\xDC\x9B\x32\xD1\x10\x3F\xD0\x9C\x41\xD2\x9C\x0C\xA6\xD3\x0E\xA3\x10\x8C\x57\xD4\xD7\x99\xD4\xD9\x90\xCF\xCA\x96\xD1\x34\xD1\xD2\x1C\xA0\xD5\xDD\x92\xD5\xDF\x98\xA3\x0B\x93\xD2\x57\xDC\x9E\x1C\xA3\x20\x5A\xD4\x9E\x5C\xDD\x9F\x4C\xD0\x81\x65\xDA\x9E\x20\xD2\xD6\x27\xA1\x5F\xEC\xC1\xD6\xF2\x98\x95\x71\xD9\xD3\x12\xDD\xA3\x05\xDB\x48\x6B\xD9\xD1\x31\x99\x91\xD2\x85\x5A\x7B\xD7\x9F\x1A\xDE\xD7\x2D\x90\xD8\x72\xD9\x9F\x74\xD1\x92\x75\xDB\xCF\xD5\x8D\xCF\x26\x92\xD2\x38\x36\xD5\x76\xD8\x9F\x43\xDA\x9F\xA8\x41\xD8\x11\xD4\xD9\x4B\xD1\xD3\x37\xD6\xD4\x87\xD5\xD9\x89\xDB\xD2\x9F\xDB\xD9\x44\xDD\xD9\xF9\xC3\xDA\xFE\xCE\xD5\x00\xD8\xDA\x8F\xD3\xD6\xD0\x92\x10\xF2\x0C\x10\xB1\xD9\x10\xB3\xD6\x10\xB5\xD3\x10\xB7\xD0\xDB\xB2\xDB\xDB\xB4\xDC\xDB\xB6\xDE\xDB\xB8\xD0\xDC\xBA\xDD\xDB\x09\x13\x0F\x0C\x16\xDC\xC5\xD7\xDC\xCA\xD9\xDC\xCC\xD6\x10\xC8\xDE\xDC\xCB\xD0\xDD\xCD\xD3\x10\xCF\xD4\xDD\xD1\xD6\xDD\x80\x6C\x10\x5D\xCD\xC5\xFE\xA3\xC6\x89\xBD\x62\x4F\x61\xDE\x58\x6C\x10\x96\xB1\x10\x45\xBF\xC3\xFE\xA0\xBA\xAD\x61\xB4\x09\x15", + "\xB4\x4C\xC9\xBE\x53\xC3\x65\x10\xB3\x65\x5D\xC4\xDF\x5F\xC2\xC6\x28\xC6\xC5\xF3\xAF\xC2\x53\x6C\xDF\x0C\x16\xC3\xE8\xB5\xDE\x72\xC3\x6C\x77\xC7\xDF\xE8\xBA\xDE\xE8\xB5\xB4\x7A\xC3\xC8\x88\xBF\xDE\x4B\xBC\x10\xF4\x0C\x10\xF5\x00\xDE\x09\x13\xE1\x32\x62\xE1\xDA\xD8\xE1\xEC\xD6\x10\x16\xEF\x68\x1A\xE3\xB2\x15\xE4\xE1\x1C\xE2\xDE\x23\xE1\xAE\x21\xE3\xDE\x27\xE6\x10\x02\xED\xE1\x3D\xB5\xE2\xB0\x6F\xE1\xB4\x60\xE3\x02\x18\xE0\x00\x0C\xE2\xEB\xDE\xE2\x31\xE9\xE2\x2D\xE3\x10\x36\xE1\x10\xEF\xDD\xE3\xF0\xD9\x10\xF6\x0C\x10\x43\xE9\x10\xF7\x0C\x10\x47\xE9\x10\xF8\x0C\x10\x4B\xE9\x10\xF9\x04\xE4\x0C\x1F\xE4\x42\xEC\x10\xFA\x00\xE5\x09\x15\xE5\x53\xE9\x10\xFB\x03\xC5\x5B\xEA\xDF\x02\x1D\xE5\x59\xC1\x10\x60\xEC\xC5\x0C\x13\xE6\xD5\xB5\xE6\xDB\xAE\xDD\x66\xE6\xC6\x68\xEE\xE5\x62\xED\xC6\x6F\xE9\xBC\x06\x1B\xE6\x03\xE0\xE0\x00\x04\xE7\x39\xCA\xE5\x0C\xE1\xE7\x9A\xBD\xE6\x81\xCE\xE7\xF3\xA4\xE3\x78\xE2\xB0\x73\xE6\xE0\x77\xEB\xE7\x00\x0C\x0F\x80\xED\xE0\x8B\xE8\xBE\xEA\xB0\x00\xFD\x03\xC5\x91\xEE\xE6\x90\xEB\xAD\x5D\xC3\xE9", + "\x61\xE5\xE9\x47\xC3\x10\x98\xE6\xC2\x06\x1D\xE9\x88\xB7\xC6\x9A\xE6\x6C\x10\xB0\xEA\x2E\xCC\x10\xA6\xE3\xE0\x2F\xC9\xEA\x53\x66\xE7\xAC\xE4\xDE\xA8\xE8\xE8\xAF\xE1\x66\xB1\xEB\xE9\x02\x13\xEB\x06\x14\xE3\xB8\xEB\xE3\xB7\xE6\xE8\xBB\xE7\xE3\x03\x1E\x0F\xB5\xE6\x6C\xEF\xDF\xEB\x79\x6C\x10\xFF\x03\xC5\xC9\xE4\xE9\xCB\xE9\xE9\xCD\xE4\xE6\x09\x1F\xEC\x67\xE1\xED\x69\xE8\xEC\xF9\xD6\x10\xD2\xE8\xBE\x10\xB9\xED\xAA\xE6\xED\x72\xE3\x10\xDC\xED\xEA\xDE\xE5\xB9\xE3\xE2\xBA\xE5\xE8\xB8\x3F\xC1\xEE\x6F\x64\xED\xC2\x64\xE3\xEA\xED\xDE\xE7\xE8\xBE\xFE\xAF\xEE\x44\xB1\xEF\x03\xEF\xDE\xF4\xE3\x10\x8F\xE0\x00\x01\x09\x10\x29\x6C\x10\xFD\xE4\xEA\x0C\x1C\xEF\x1E\xC6\x10\x01\xF0\xED\x09\x17\xF0\xD3\xE9\xF0\xD3\xA3\xF0\x0A\xFC\xE6\x00\xF4\xE9\x04\xF6\x6C\x2F\xC3\xF1\xFB\xDE\xF0\x6F\xCC\xF0\xE4\xE1\xF1\x49\xC3\x10\x0F\xF3\xE0\x3F\xC6\xF1\x0B\xF6\xF0\xED\xE8\xF1\x1D\xF2\x10\x1F\xFB\xE0\x1C\xF6\xEE\x09\xFF\xF1\x22\xF8\xBE\xEF\xDF\xF2\x03\xEF\xE8\x02\x0F\xF1\xFF\xE6\x10\x35\xF4\xE9\x39\xF9\xE9\x3B\xF8\xF0\x03\x1D\xF3\x23\xF2\x10\x40", + "\xF8\xBE\xDE\xD3\xF4\x03\xE2\xEA\x46\xF2\xDF\x0C\x19\xF4\x24\xEF\xF3\x29\xFD\xF4\x42\xFF\xF4\x28\xE8\xF3\x52\xFA\xE2\x4B\xF5\xF5\xBC\xE1\x10\x4C\xF4\xEB\x09\x1B\xF5\x8C\x6D\xF5\x58\xF3\xE3\x57\xFF\xC7\x60\xF6\xEB\x5A\xF1\xF6\xE6\xDC\x10\x03\x0F\xF1\x5E\xF3\xBE\x63\xF9\xB0\x0C\x14\x00\x36\xF1\xF7\x68\xFC\xAD\x74\xF5\xF0\x02\x12\xF7\x78\xF1\x10\x7A\xFF\xE7\x09\x1D\xF7\x9E\xE3\x10\x80\xF1\xEA\x77\xF2\xF0\x7F\xF5\xF7\x2F\xC3\xF8\xA7\xE7\xF8\x19\xF2\xF8\x75\xF2\xE0\x8A\xF3\xE0\x45\xB1\xF9\x53\x6F\xC3\x94\xFB\xEE\x06\x17\xF9\x09\x14\xE3\x9A\xF5\xEF\x8C\xFE\xF7\x99\xF5\xF7\x93\xF5\xF7\xEF\xDD\xF9\xFA\xEB\xF4\x2B\xF4\xF2\xD1\xE5\x00\x2E\xFA\x29\xFF\x0F\xFA\xB0\xFF\xFA\x03\xF3\xF0\x6A\x0A\x03\x1A\xF3\xFB\x03\x18\x00\xC8\xE1\xFB\xB0\xF8\xFB\x09\x1B\x06\xB6\xFA\xFA\xBE\xF4\x4B\xBC\xFD\xFB\xC3\xF2\x10\x6C\x01\xFC\x1E\xF7\xFC\xC4\xF5\xFC\xDC\xE3\xFB\x6D\x0A\xFC\x28\xFC\xFC\x54\x5E\xFC\xCF\xF3\xF0\x6E\x02\xFD\x01\x1D\xFA\x0C\x1A\x01\xBB\xF5\xFC\xD4\xF0\x00\x6F\x0A\xFD\x32\xF3\xFB\x24\x0F\xFD\xBC\xF1\xFE\x70\x04\xFE\xDC\xF9", + "\x10\xA2\xE6\xFD\x03\xF3\x00\xE8\xF1\xFB\x03\xFB\x1A\x45\xB0\xFF\xD4\xF1\x07\xE4\xF2\x00\x9D\x31\x05\x1F\xF8\xFF\x09\x0A\xFE\x49\x09\x39\x0C\xFE\x40\x16\x12\x1F\x7F\xCE\x79\xFE\x73\x7E\xE3\x7B\x39\x42\x00\x02\x80\x7F\x6A\x7B\x01\xB2\x7D\xDF\x10\x04\x0F\x81\xFA\x71\x80\x09\x0C\x0E\x05\x81\xCC\x1A\x03\x16\x80\xFD\x78\x80\x06\x0D\x0E\x1B\x80\x98\x14\x03\x1E\x80\x03\x86\x08\x02\x86\x20\x36\x03\x11\x82\x4A\x2E\x02\x09\x93\x80\x01\x84\x21\x37\x02\x16\x8F\x52\x28\x03\x0B\x8F\x7E\x29\x83\x20\x38\x02\x1A\x86\x54\x13\x03\x0D\x8A\x80\x09\x09\x0F\x3C\x80\x0B\x3A\x00\x3F\x80\x08\x83\x08\x7A\x03\x08\x87\x10\x3A\x70\x00\xA8\x80\x43\x1B\x03\x43\x82\xF7\x53\x66\x09\x88\x03\x8C\x08\x1F\x03\x82\x07\x00\x95\x51\x77\x04\x87\x04\x82\x09\x1F\x03\x82\x39\x82\x20\x2D\x5D\x2D\x80\x01\xB1\x81\x42\x1E\x03\x43\x80\x62\x64\x5C\x00\x0D\x04\xC3\x7F\x1F\x1B\x7F\xC2\x16\xDD\x5C\x82\xE6\x71\x08\x43\x83\x6A\x04\x7F\x6C\x83\x0E\x87\x7E\x41\x03\x04\x8C\x2C\x11\x14\x82\xE1\x7B\x10\x3D\x82\x86\x0F\x07\xE4\x83\x05\x8C\x7E\x84\x06\x0E\x8C\x08\x24\x00", + "\x08\xD4\x7D\x21\x03\x82\x03\x7F\x09\x0D\x84\xE6\x76\x08\x0A\x85\x42\x0D\x02\x93\x87\xF8\x47\x04\x4B\x86\x10\x57\x01\x26\x83\x7E\x88\x04\x13\x83\x08\x2E\x0F\x09\xBE\x7D\x22\x02\x85\x02\x0B\x0B\x25\x84\xDC\x7A\x08\x28\x85\x40\x02\x03\xAB\x83\xF6\x4B\x04\x57\x80\x00\x61\x01\x2C\x83\x78\x8C\x03\x08\xBC\x7F\x84\x06\x06\x37\x84\x43\x0D\x04\xBA\x84\x21\x28\x02\x5F\x89\x10\x0E\x04\x2D\x8B\x03\xC4\x86\x20\x0F\x04\x5A\x80\x07\x49\x87\x40\x10\x04\xCC\x86\x19\x82\x09\x48\x03\x04\x85\x86\x41\x12\x03\xD2\x81\x20\x12\x05\x21\x85\x02\x54\x73\x2E\x80\x77\x7A\x83\xF8\x53\x04\x38\x89\x10\x43\x01\x99\x7F\x86\x02\x0D\x0D\x82\x09\x30\x81\x10\x15\x07\x10\x94\x71\xED\x00\x1D\x81\x08\x75\x81\x10\x6C\x84\x00\x16\x04\x43\x82\xC0\x6E\x06\x79\x89\x07\xE5\x82\x13\x89\x08\x97\x01\x0D\xB2\x6C\x7E\x84\x0F\x80\x02\x3D\x98\x04\x43\x85\x8B\x77\x06\x82\x81\x0E\xEB\x84\x43\x19\x04\x43\x85\x68\x6F\x06\x86\x8E\x0F\x83\x0A\x3D\x9A\x04\x43\x84\x07\x1A\x66\x8A\x87\x08\xFF\x85\x53\x03\x82\x3E\x04\xC8\x5C\x89\x0F\x86\x06\x86\x08\x27\x03\x82\xDE\x6C\x1E", + "\x23\x89\x13\x86\x11\xBB\x1B\x10\x81\x02\xCF\x63\x25\xB0\x80\x8F\x83\x10\x1E\x07\x10\x9E\x57\xF1\x02\x26\x95\x82\xAD\x13\x04\xA2\x75\x3D\x1A\x89\x40\x86\x20\x20\x05\x21\x86\x02\x47\x6C\x50\x9D\x82\x01\x09\x14\x03\x82\x21\x05\xCB\x47\x89\x49\x83\x08\xA2\x05\x1A\x8C\x08\x6C\x86\x08\xA4\x8B\xF1\x63\x05\xB4\x82\x0F\x19\x86\x00\x04\x0A\x64\x86\xE4\x19\x03\x5B\x8E\x14\x19\x8B\xAD\x87\x0A\x5E\x88\x0F\x21\x04\x5B\x89\x15\x10\x84\x86\x05\x08\x5B\x8A\x2A\x03\x82\x2E\x7D\x11\x1B\x8B\x55\x00\x17\x8C\x08\x22\x1B\x8A\xAC\x05\x2E\x89\x08\x45\x0B\x15\xAD\x06\x5E\x86\x08\x77\x8D\x2A\xAC\x88\xDF\x7E\x0A\x34\x84\x25\x1B\x8A\xAF\x04\x16\x96\x05\xAD\x80\x0B\x34\x85\x26\x1B\x8A\xB1\x04\x16\x85\x11\x82\x83\xF0\x32\x04\x2D\x9C\x19\x82\x8B\x26\x83\x7F\x59\x04\x0B\xE6\x25\x66\x97\x7E\xEC\x34\x16\xAB\x27\xCF\x81\xFE\x35\x04\x2D\x97\x27\xD8\x75\x21\xB8\x7C\x5B\x04\x0B\x8D\x39\x6A\x95\x88\xBE\x7F\x16\x2B\x8A\x82\x39\x0E\xAA\x8F\xEC\x78\x05\xB3\x8A\xE5\x2F\x8D\x8E\x83\xFC\x39\x05\x6E\x93\x43\xBB\x8E\x2A\x83\x7E\x5D\x0F\x1B\xFD\x50\x38\x90", + "\x8D\xB8\x7B\x17\x34\x85\xCC\x44\x19\xBB\x3A\x59\x93\x4B\x5B\x8E\x17\x0F\x8E\x5B\x26\xBE\x24\x8C\x52\x9D\x87\xBC\x8E\xF7\x71\x61\xE6\x88\x86\x51\x83\x28\x61\x8E\x83\x88\xF7\x41\x06\xEF\x89\x10\x0F\x66\x75\x8C\x7E\xC2\x04\x3C\x86\x09\x49\x67\x1E\xC7\x7F\x30\x0A\x8F\x03\x0B\x93\x60\x8E\xCD\x8E\xFB\x44\x04\x7C\x82\x08\xA2\x65\x3D\x83\x7F\x62\x05\x1C\x81\x09\x25\x7A\x8F\xBE\x7E\x18\x37\x8F\x65\x6B\x15\xC7\x06\x12\x97\x6E\xB5\x88\x39\xB3\x7C\x64\x07\x20\xBA\x71\x82\x99\x8E\xB8\x79\x19\x0D\x90\x83\x09\xE4\x73\x8C\x68\x89\x08\xCA\x03\x08\x89\x10\x6E\x7C\x1D\x86\x0B\x32\x1A\x90\x00\x7E\x08\x8C\x7E\x66\x00\x22\x81\x82\x88\x87\x7E\xCD\x05\x44\x86\x08\xD6\x70\x20\xB8\x7E\x33\x03\x82\x0B\x16\x01\x27\x91\xE1\x7F\x0C\x30\x92\x5C\x13\x91\xBE\x78\x1A\x03\x83\x06\x17\x01\x38\x90\xEE\x71\x06\x3B\x94\x21\x19\x00\x1F\x93\xFB\x52\x05\x90\x89\x08\x1B\x04\x48\x83\x79\x69\x07\x24\x86\x09\x07\x0A\x92\x63\x5D\x49\x83\x09\x0F\x00\x25\xFA\x5A\x94\x82\x08\x21\x05\x4A\x86\x08\x6B\x03\x04\xDE\x0C\x0B\x1A\x92\x03\x0F\x1A\x03\x83\xDD\x02\x03", + "\x60\x91\xF9\x43\x82\xBD\x08\x07\x26\x93\xF5\x53\x04\xBF\x0E\x0F\x0B\x93\x00\x02\x1B\x03\x83\xD3\x07\x04\x70\x93\x36\x13\x93\x0C\x0E\x08\x30\x92\x6E\x03\x04\xA9\x0D\x13\x10\x93\xDD\x04\x16\x97\x02\x38\x9E\x0D\x03\x85\x42\x16\x02\x70\x97\x1B\x03\x83\x10\x0C\x10\x5B\x00\x9C\x80\x07\xB4\x81\x1D\x30\x93\x70\x03\x1D\x95\x52\x41\x0B\x07\x44\x96\x1E\xA3\x07\x21\x8B\x01\x35\x65\xA6\x94\x64\x09\x8C\x21\x2A\x06\x38\x95\x0E\x15\x94\x06\x17\x65\x9F\x91\x94\x43\x82\xEF\x73\xCD\x29\x96\x41\x08\x07\x43\x80\x04\x0C\x08\x77\x0E\x2A\x83\x09\x3A\x03\x82\x1D\x04\x21\x07\x07\x5A\x92\x10\x6A\x07\xA2\x8D\x94\x70\x93\x1D\x06\x94\x83\x02\x06\x3C\x95\x40\x0C\x07\x43\x87\x54\x89\x09\x31\x06\x2C\x80\x01\x3B\x14\x85\x6E\x00\x4E\xAE\x07\xFE\x82\xFE\x70\x93\x3B\x10\x96\x70\x90\x1E\x03\x97\x81\x0D\x06\x70\x91\x3C\x03\x82\xA5\x2C\x0D\x30\x92\x79\x04\x0B\xF8\x00\x9C\x93\x07\x95\x94\xB1\x37\x02\x38\x95\x0F\x65\x94\x9C\x96\x07\x95\x93\x35\x05\x04\x38\x98\x0F\x43\x83\x80\x1F\x03\x70\x91\x1F\x36\x96\x86\x08\x2F\xAD\x93\xEC\x7A\x07\xDB\x92\x20\x01", + "\x04\x38\x9B\x0F\x01\x99\x40\x0A\x04\x70\x94\x1F\x34\x85\x48\x00\x27\xFD\x07\xC2\x90\x93\xFE\x06\x60\xB7\x86\x38\x9F\x0F\x12\x9A\x25\x10\x93\x00\x03\x07\x37\x7D\x81\x0E\x01\x06\x28\x9C\x81\x00\x1A\x9A\xF8\x5C\x99\x3D\x30\x27\x82\x01\xC8\x8B\x7E\x91\x6D\xDB\x30\x93\x01\x07\x32\xD3\x7E\xCD\x1B\x05\x70\x94\x00\x2D\x99\xED\x72\x2C\x30\x9A\xBF\x83\x78\x05\x03\x66\xA5\x7F\xD5\x02\x0C\x70\x92\x01\x1A\x99\x2E\x7C\x67\xB0\x93\x03\x00\x34\x8C\x0B\x07\x0C\x08\xC5\x00\x4E\x88\x01\xA2\x99\x10\x47\x99\x42\x09\x9A\x37\x9B\x23\x0C\x9A\xC9\x10\x0D\x70\x92\x02\x13\x9A\x3C\x25\x1A\x30\x93\x05\x08\x35\x9A\x24\x36\x10\x93\x0C\x05\x6B\xAC\x4B\x0F\x60\x27\x8D\x02\xD8\x96\x94\x03\x0E\x1B\x30\x92\x07\x07\x36\x8C\x2C\x38\x10\x93\x0F\x07\x6C\xAB\x0C\x73\x00\x27\x90\x01\xDB\x96\x64\x70\x91\x02\x27\x9B\x13\x08\xE4\x70\x92\x04\x07\x9B\xDD\x81\x21\x1C\x00\xA7\x87\xFC\x13\x02\xCE\x9C\x87\x00\x04\x6F\x86\x72\x38\x95\x01\x7B\x9B\xC0\x64\x9C\xC3\x7E\x02\x0E\x9C\xD4\x76\x21\xE1\x7F\x05\x17\x9B\xD1\x70\x4E\x98\x01\xB3\x92\x02\x0C\x0A\x01\x10\x9C", + "\xBE\x79\x03\x27\x9B\x11\x0C\x10\x08\x00\xE8\x98\x7D\x1A\x04\x73\x9E\x9D\xD3\x93\xFB\x1B\x03\xE8\x85\x9D\xAC\x9B\xE0\x5C\x00\xD5\x99\x10\x1F\x9D\xD4\x89\x08\x1D\x07\x75\x89\x08\xD3\x97\x3B\x86\x0A\x07\x12\x9B\xA4\x09\x76\x86\x9B\xB3\x96\x0D\xDD\x12\xF0\x89\x08\x20\x04\x78\x84\x17\xE3\x96\x10\x21\x00\xE0\x8C\x08\x83\x9D\x77\x83\x08\x11\x07\x36\x83\x7A\x07\x0C\x9E\x03\x0B\x04\x18\x9C\x83\x02\x02\x2C\x9E\x3D\x84\x01\x67\x9C\x03\x0C\x09\x11\x0E\x3D\x8C\x09\x09\x13\x9C\x37\x30\x7B\x82\x08\x13\x08\x3E\x88\x36\xFA\x81\x08\x27\x05\x7A\xAB\x31\xF7\x90\x00\x28\x03\xD9\x89\x01\x0C\x09\x05\x34\x9F\x14\x0D\x3E\x82\x09\x0D\x14\x9F\x2A\x05\x7F\xB0\x56\xFA\x9B\x02\x72\x9D\x42\x13\x01\xF4\x9C\x05\x37\x9F\x27\x34\x3F\xAD\x02\x01\xA6\x08\x41\x04\x7E\xAE\x00\xE0\x99\x10\x44\x00\xFD\x8F\x01\x0F\xA3\x20\x0C\x02\xFA\x90\x03\x19\xA2\x40\x1B\xA0\xD2\x99\xD4\x1E\xA1\x80\x09\x05\x74\x9E\x0C\x1B\x9E\x03\x0E\x0B\x34\x9F\x19\x03\x42\x80\x02\x19\x14\x9F\x34\x07\x70\x82\x16\x31\x04\x3F\xB6\x00\x05\xA6\x08\x64\x04\x7E\xB7\x00\x01\xA0\x00\x71", + "\x00\xFD\x98\x01\x3C\xA6\x87\xA1\xA1\x80\x09\x03\x28\xA2\x40\x0F\x03\xF4\x9A\x07\x27\x9B\x17\x60\x07\x74\x9F\x0E\x06\xA2\x01\x08\x89\x83\xA2\x00\x0C\x03\x4B\xA0\x43\x0D\xA2\x53\xA5\x07\x10\xA2\xF1\x74\x3F\xBE\x03\x16\xB7\x03\xF4\x9F\x07\x2D\xA1\x40\x04\x3F\xC0\x03\x18\xB4\x9F\x41\x02\x79\xA7\x82\xFA\x92\x04\x67\x9B\xF9\x69\x08\x7F\x04\x7E\x83\x02\x35\xA6\x10\x7E\x00\xFD\x84\x02\x6E\xA4\x5F\xB4\x9F\x22\x0D\x42\x89\x04\xFD\x86\x02\x7D\xA4\x7E\x87\x02\x3A\xA3\x10\x06\x04\xFD\x88\x02\x79\xA1\x21\x07\x04\xFA\x99\x04\x04\xA6\x40\x06\xA4\x53\xA2\x09\x09\xA4\x83\x0B\x48\xD3\xA3\x12\x0D\xA1\x91\x04\x7E\x8C\x02\x4C\xA4\x3F\xCD\x02\x23\xA1\x08\x8E\x04\x7E\x8E\x03\x49\xA3\x10\x0F\x04\xFD\x8F\x02\x9F\xA0\x00\x21\xA5\x29\xA0\x05\x24\xA6\x40\x06\xA5\x53\xA1\x0A\x0F\x9F\x84\x09\x09\x74\x9E\x14\x12\xA1\x09\x09\x70\x86\x09\x5A\xA3\x45\xD4\x03\x2C\xA2\x8A\xF4\x9D\x0A\x38\xA4\x83\x0A\x4B\x83\x08\x28\x14\x9F\x57\x07\x6C\x8F\x75\x51\x04\x3F\xD8\x02\x32\xA5\x27\xF4\x99\x0B\x27\x9A\x3C\x8C\x0A\x74\x9E\x16\x13\xA6\x06\x2C\x7E\x9B\x02", + "\x6C\xAB\x52\x74\x9C\x17\x07\x9B\x3A\x98\x00\x32\x04\xFA\x9D\x05\x60\xA5\xBA\x34\x9F\x5E\x06\x9C\x91\x38\xFA\x9F\x05\x3F\xA7\x40\x18\x05\xF4\x98\x0C\x03\xA7\x81\x05\x4C\x82\x08\x3C\xB3\xA2\x62\x05\x85\xBB\x04\xFA\x93\x06\x67\x99\x0F\x0C\x08\xC1\x04\x7E\xA4\x02\x7F\xA0\x50\xF4\x9D\x19\x0D\xA1\xC9\x04\x7E\xA6\x03\x1B\xA3\x10\x4B\x04\xFD\x87\x03\x2D\xA7\x1C\x34\x9E\x34\x0D\x42\xE6\x04\xFD\x89\x03\xEE\xA2\x20\x3A\x06\xFA\x9A\x06\x67\x9A\x39\x9A\x72\xE5\x9E\x5F\x85\x03\xA5\x7C\x0E\x9D\x93\x40\x0B\x03\xF3\xA2\x20\x23\xA9\x00\x85\x52\xB6\x8F\xC0\x6D\x03\x67\x9B\xA5\xA8\x81\x96\xAA\x20\xD8\x7F\xD9\x86\x02\x0C\x0F\x00\x34\xA8\x08\x93\xFB\x6F\x03\x4D\xBB\x08\x3B\xAA\x38\xBE\x7C\x38\x09\x4A\x8F\x01\x50\xA1\x8F\xB3\x79\x0E\x27\x9B\x23\x0F\x16\x47\xA8\x7D\x98\x7D\x72\x05\xA8\x8E\xAB\x0B\x96\x10\x73\x03\x52\xAD\xAA\x53\xA4\x0E\x12\xAB\x29\xA5\x07\x29\xA4\x05\x13\xAA\xE1\x7E\x0E\x17\xAB\x97\x00\x56\xD4\x7F\x1D\x1E\xAA\x65\xAC\xF9\x78\x03\xB1\xA9\x14\x69\xAB\xF1\x79\x03\x68\xAB\x8A\xBA\x03\xB3\x99\x08\x0C\x2C\xE5\x95\x9C\x5B", + "\x88\x71\xA6\xA9\x19\x6E\x2F\x85\x88\xE2\x9A\xAB\x2E\xAC\x21\x39\x95\xBE\xA6\x1B\x84\x03\x5D\xA7\x8E\x3C\xAB\xE0\x4C\x2D\x82\x85\x10\x86\x03\x61\xAF\x90\x42\xA8\xF7\x43\x10\xC6\xA6\x1B\xD2\x80\xCE\x7B\x8A\xAB\x0C\xB2\x8A\x91\x04\x10\x58\xB5\xA8\xF4\x91\x85\x05\x8D\x41\x1D\xAD\xC4\xAC\x29\x1A\xAC\x4F\xBB\x0D\xA3\xA9\xB2\xB3\x7D\x05\x16\x5A\xAA\xAF\x6F\x09\xAD\x48\xAB\xE0\x5D\x94\xC2\xAA\x20\xA7\x0C\x6C\xAF\xAA\xB3\x7D\x00\x20\xAC\xDB\x8B\x1A\x37\xAC\x55\xA2\x7C\xBB\xAA\x41\x8C\x2C\xDF\xA1\xFE\x0E\xAC\x6D\xBC\xA9\xCA\x97\xB2\x93\xA3\xD4\x0D\x5A\xC8\xA8\xAB\x8A\xAE\x78\xAC\xF9\x65\x2D\xE6\xA8\x5B\xE2\x9D\xD7\x7B\x8A\x1D\x9F\xB8\xAA\xAD\xEC\xA0\x5D\x88\xAE\x6A\xA8\x9C\xF6\x84\xBA\x8F\x7E\x59\x9B\x31\x90\xAC\x52\xB6\x87\x2E\x7A\xBC\x83\x78\x46\x9F\x14\xE6\xAC\x6E\xB6\x87\xF8\x9A\xBB\x88\xAB\x37\xAB\x22\xB1\x86\x3D\x97\x79\xDE\xA8\xA9\x85\x89\xF8\xA5\x5F\xFE\x96\x3D\x93\x32\xEA\xA8\xF3\x43\x08\xDD\xAE\x5F\xA2\x71\x7E\xB8\xAD\x05\x8A\xC0\x44\xB1\xE8\xA4\x13\xCC\x55\x70\xBC\xA9\x8F\x73\xC1\x87\xB1\x9D\x8F\xF5\x0C\xB3", + "\x84\xA3\x78\xFF\xA1\x21\x12\xB0\xF7\xAF\xFC\x06\xAD\x79\xB3\x87\xB6\x8D\x20\x8C\x8B\xBF\x71\x0B\x9E\xB2\x41\x1C\xAF\x17\xB1\x16\xB8\xA9\xDA\x95\x62\xCA\x75\x88\xB6\x8D\x4C\x06\x73\xAD\xB0\x61\x31\x60\x89\x0A\x14\x12\xB1\xFE\x96\xC4\x98\x35\x07\xBA\x5A\xD8\x00\x8E\xB6\xB0\x79\x79\xC3\x72\xAE\xDC\xAE\x05\x3F\xB1\x8A\xA4\xB1\x1B\x77\xC8\x80\xB3\x80\x04\x06\x46\xB0\x87\xB8\x99\xA9\x7F\xC9\xB1\x84\x35\x01\xF7\x31\x87\x86\xA1\x08\x28\xB2\xCA\xBE\x96\x37\x0E\x64\xA0\xB2\x82\x97\xB2\x00\x00\xBF\x9A\xB3\x25\xB0\x00\x74\x01\x97\xB8\x8E\xAA\xA8\xCC\x80\xB1\x17\xBA\x20\xDA\x88\x8B\xBE\x97\x60\xB3\xDB\x6C\xB2\x9E\xA0\x08\x67\xB1\x41\x80\xB3\x5D\x65\xC6\x86\x08\x43\x06\x67\xB6\x8C\x98\xB3\x77\x73\xB2\xB5\x8C\x05\x3E\xBA\x20\xC6\xAD\x77\xA3\xB3\x4A\xB3\x20\x12\x05\xC7\xA8\xFB\x2E\x7A\xA1\xA3\x08\x2F\x62\xCF\x83\x09\xC3\x87\x5D\x9F\xB1\xF9\x6F\xB4\x02\x0B\xB0\xA4\xB3\x82\x8B\x18\x95\xB7\xA1\xB4\x99\x6F\xB2\xB1\x5B\xB4\xDB\x88\x09\x0C\xB6\x41\x91\xB2\x01\x08\xD3\x97\x26\x49\xB2\x10\x1A\x06\xA9\xBA\xB1\x2E\x9E\x20\x2A\xB5\x9B", + "\x2C\x6A\x81\x0A\xCE\x1E\xB4\x03\xB0\xD5\x80\x01\x59\xB6\x5D\xA3\xB6\x82\x9E\x19\xB8\xB2\x20\x33\xB4\x47\xB5\x5A\x81\xB4\x52\xA4\x27\xC1\xB1\x20\x19\x82\x4B\xB3\x6B\xAC\xAE\xB1\xB8\xAD\xCE\x37\xD3\x80\x00\xCB\xA8\x32\xB2\xB4\x43\x13\xAD\xBE\xB4\xA7\xB2\x26\x69\xB7\x20\x44\xB6\x86\xBC\xB1\x48\xA9\x9F\x09\xB6\x0B\x3E\x6D\x99\x7C\xB8\xB8\xAD\xFD\x23\xDC\x8B\x11\x72\xB3\x10\x33\xB5\xAD\xA0\x00\x01\x2B\xDC\x8D\x10\x76\xBD\x47\x6F\xB5\x41\x23\xB7\xDE\x0C\xDE\x8E\x3F\x21\xBF\xFC\x74\x33\xCF\x6C\x1C\xFA\xB0\x00\x1C\xAF\x44\xB8\x68\x82\x08\xB4\x23\xB7\xBD\x0E\xE5\x4B\xB6\x69\xBF\x6E\xAE\x8F\xBF\xB2\x19\x0A\xB8\x71\x2F\xB6\x78\x32\x32\x85\xBA\xB2\xB0\x7A\x5E\xB4\xA7\x85\x89\x7A\x32\x6D\xA5\x0D\xC4\xB8\x9D\xE7\xB7\xF9\x4B\x39\x71\xB7\x1A\x1F\xBA\xA8\xA4\xB8\x19\xBA\xB5\x9C\x38\x69\xB9\x1A\x26\xBB\x22\x2F\xB7\x35\x3A\xDA\xAB\x0C\x97\xBA\x49\x6F\xB7\xE0\x28\x9C\x03\x14\xE6\x81\x09\x5E\xB8\x72\xE8\xB0\x52\xB7\x42\x42\x7F\xB5\x60\xB4\x83\x0B\x70\xAE\x27\xBB\xB9\x43\xE3\xB5\xB4\x3A\xB8\xFA\x2F\x6E\xCC\x44\xE2\x89\xAE\xD5\xB3", + "\x20\x05\xBA\x81\x08\x6D\xBD\xB9\x41\x83\x52\xD2\xB1\x03\x3A\xB5\xA9\xB1\x10\x60\xB3\xBB\xA9\x52\xE3\xB7\xB9\x91\xBA\x81\x0C\x75\x80\x00\xAC\xA9\xB9\xFA\xAE\x36\x8E\x53\x71\xB5\x75\xB1\xB6\xD4\xA4\xB4\x1A\xBE\x36\x8F\x55\x71\xBC\x73\xEE\xB8\xD9\xBD\x1C\xEF\xB7\x54\x40\x00\xC4\x9A\x69\xE3\xBB\xC5\xB4\x15\x21\xBB\xE0\x40\x58\xC4\x93\x70\xF6\xBB\xDF\xBE\x9D\x81\xBA\x68\x48\x9C\xA7\x95\x71\x81\x08\xB5\xAB\x26\xEF\xB4\x6A\x46\xBC\x9F\xB8\x5B\xDD\xB5\xE2\xB4\x5B\xC2\xB1\x16\x87\x11\x2C\xB8\x76\x88\xB2\x6D\x96\x60\xD3\xB2\xF3\xAE\xB0\x05\x95\x10\x91\x67\xEE\x82\xBD\x34\xB7\xD9\x8F\x7E\x59\x66\x10\x0F\xBD\xE7\xAF\x7E\x07\x12\xCE\xA4\xBC\xDB\x89\xDB\x0E\xBC\xEA\xA5\x34\xFC\xB3\xE0\x58\x73\xD6\xB7\x7B\xB9\x71\xB6\xBF\xAE\x1F\x7E\xF5\x94\xBD\xE7\x79\x20\x65\xBB\xBB\xA5\x82\x96\xB5\x20\xAB\xB7\xCB\xB3\x15\x1F\x7B\xD9\xA3\xBE\x03\x7B\x41\x1C\xBC\xE8\xB1\x0B\x8F\x03\xC7\x6E\xB7\xB6\x8B\x41\x22\xB3\xD7\xB3\xF0\x05\x89\x05\x17\xBE\xB1\x83\x41\x2B\xB3\xD9\xBA\x20\xC9\x91\xA8\xBD\xB9\x0B\x12\xF6\xB1\xBA\x05\x99\x25\xE7\xBE\xC5", + "\xB4\x2F\x79\xB2\xF5\x83\x79\x13\x00\x7E\xFE\x97\x82\x00\xB4\xE4\xBC\xA7\xAD\x01\xFA\xB4\x66\xF3\xB4\xF3\xA3\x08\x33\x06\xF9\xB1\x85\x06\x13\x7D\xEF\xB7\x0D\x1C\xBF\x3D\xBD\x41\x1B\xBE\xEA\xBE\x2F\xBD\x00\x02\xCF\xBF\x0D\x13\xFC\xAB\xBE\x9E\xA3\x04\x0F\xC0\xF7\xBC\x14\xEA\xBA\xB5\x85\x89\x24\x06\x81\x8C\xC2\xCB\x11\xBF\xF9\xBA\xB5\x8F\x03\x0E\xC1\x5A\x82\xB3\xFB\xA5\x88\x55\x04\x04\xF6\x8C\xEF\x04\x5C\xB1\x86\xA3\x83\xB7\xE4\xAD\xF1\xB6\x2F\x48\xB2\x7F\x8C\x09\x17\x0C\x7B\x0C\x0C\xBD\xB2\xC0\xEF\x05\x1A\x6F\xB7\x17\x1F\x78\xE9\xAB\x05\xC2\xAD\xFF\xB2\x10\x60\x00\x0E\xC9\x08\x9D\x9E\xD2\x9E\x0F\xC5\xA5\x83\x89\x09\xB1\x83\xB7\xA4\x9A\x09\xE0\x29\x77\xB4\x06\x47\xC2\x41\x14\xAF\x7E\xBE\xBE\x19\xAD\x26\xC6\x10\x66\x02\x15\xD4\xA7\xBA\xB6\x3B\x35\xBB\x0B\xCE\x2F\xE8\x03\x17\xCB\x9F\x61\xC5\xD8\xA1\xC0\xA4\xAA\x06\x67\xC0\xFC\x89\xC3\xC8\x1F\xDD\xA2\x97\x71\xB8\x02\x70\xC2\x41\x0D\xBB\x64\xC4\xCC\x91\x97\x71\xB3\x7D\xAE\x7A\x77\x1E\xBA\x5C\xC3\x20\x30\x02\x37\xC1\x66\xF6\xC0\x70\xB9\xBD\x53\x8C\x10\xD3\x32\x3F\xC0", + "\x77\x9A\xC2\x6D\x94\x03\x84\xC0\x62\x4C\xC4\xF5\x1F\x6E\xF6\x00\x21\xDD\x62\x93\xC7\x41\x44\xC3\x80\x06\x2E\xE3\xB6\xBF\x59\xC4\x23\x98\x11\xC9\x08\x3D\x04\x88\xDE\x6E\xCB\x68\xAD\x9B\xC0\x00\x3C\x02\x42\xC2\xEA\x27\xC4\xC6\xBE\xC0\x3D\xBE\x0F\x04\xC5\x17\x6E\x8A\xA0\xBA\x28\xC6\x08\x80\x04\x10\xF6\x73\x5A\xC7\x72\xA7\xC2\x6D\x82\x04\x84\xC2\xC0\x7C\xC5\x97\xB1\x88\x82\x08\x21\x04\xC4\x45\x5B\x18\xF5\xB9\x62\xC1\x10\x06\x04\x21\xDF\x61\xCA\xC3\xE7\xA9\xC4\x44\x04\x88\xB4\x71\x34\xD5\x2F\xEF\xB0\x61\xA3\xB7\xF7\x67\x8D\xCE\xB7\x1A\xD8\xAD\x8C\x04\x10\xCF\x75\x6B\xC8\x87\xB0\xC7\xFB\xAE\x04\x84\xC1\x07\x3A\xB5\xDD\x00\x88\xDF\xC7\xF3\x70\x04\x84\xC0\x0F\x97\xC7\xE7\xBF\x6E\x92\x04\x21\xC1\xA7\xD7\xC0\xFB\xAE\xC7\x81\x74\x09\x04\xC6\x46\x96\xB4\xBB\x0C\xB9\x8C\xC7\x89\x93\x6E\x99\xB2\x0C\xDB\x0D\xD3\xAB\x20\xD8\x04\x42\xC1\x12\x80\xC8\x43\x05\xBC\x79\xC5\xE7\x9A\x04\x42\xCF\x03\x3A\xB5\x6F\x0D\xC1\xFE\x94\x13\x04\xC4\x20\x06\x91\xAF\xC7\xBB\xBE\x04\x84\xC0\x26\x96\xB5\xDE\x0D\x77\xBE\xC6\x82\x80\x05\x84\xC3\xC4", + "\xB2\xC1\xDE\x0C\x84\xFB\xC7\x39\x24\xC4\x1F\xAB\x25\xD3\xC3\x81\xC4\x0A\x04\xC5\xF1\x93\xBC\xBD\x0B\x0B\xEE\xC8\x7C\x24\x88\xB2\xA9\x16\xDD\x0D\x63\xC6\x1C\xD1\xC8\x81\x08\x0A\x04\xC7\x8A\xB2\xC9\xDA\x17\xDD\xAA\x04\x42\xCC\x54\xA3\xC8\xD4\x16\xB7\x84\xC4\x11\x8E\xCA\x24\x99\x8A\xAE\x04\x21\xC9\x02\x1D\xCF\xDB\xB7\xC5\x81\x00\x0B\x04\xC6\x12\x19\xCA\xE6\xB3\x2B\xC2\x08\x59\x04\x88\xCB\x00\x58\xCD\xB7\xA9\xC4\x16\x04\xC5\x18\xB3\x95\xAC\x23\xBB\xB6\x05\x84\xC0\x13\xAD\xCB\x03\x5F\x7B\xC8\xA8\x2E\x04\xC4\x4E\x07\x2C\xC2\x08\x88\xC2\x94\xFD\xCA\x2E\x04\xC4\x92\x86\xD2\xBF\x0D\x20\xCB\x93\xB9\x3A\x00\xDE\x97\xBF\x0D\x00\xC3\xC8\x60\x0A\x82\x8A\x93\x6F\x0B\xC0\xEF\xB6\x18\x0D\xCC\x9E\xAF\x1B\x12\xC2\x23\xCA\x90\xCC\x03\x32\xEE\xAC\x03\xB6\x92\xBC\xAA\x34\x1A\xCC\x48\xAF\x37\x20\xC1\x09\xCA\x5A\xDF\x9A\xFB\xA3\xCA\x96\x20\xFF\xA4\xCC\xA4\xAA\x36\xA7\xCD\x5F\xC5\x0D\xBD\x0F\xDD\xA4\x06\x20\xC1\x0B\xA7\x0F\x6E\x0F\xB7\xE5\x04\x36\xFE\x97\xD3\x0D\x83\x83\xC8\xDD\x89\xBE\xB6\x89\x35\x1E\x0F\x77\xB7\x0E\x3A\xCC\x99\xB3", + "\xB9\xA9\xC0\x1D\x07\xCD\xE3\xC9\x3F\xA9\xC4\x3B\x00\xCD\xB8\xAB\x35\x10\xCD\x81\xC2\x0F\x50\xCF\xF3\x6B\x0D\x96\xC9\xED\x8A\x90\x7C\x06\x9D\xF5\x7C\x67\xC8\xCD\x7D\xCE\x1F\x1D\xCE\x61\x13\x9A\x97\xCC\x4F\xA4\x00\xFC\x82\x1F\xFC\xA9\xD5\x0A\x9A\xE6\xCE\x6A\xAA\x00\xE9\xC9\x16\xB9\xB9\x54\xC0\x01\x7C\x84\x3D\xD6\x8D\x03\x12\x31\xC5\xCD\xB2\x01\x9F\xFE\x97\x80\x13\xCE\xFB\xCA\x20\x1A\x01\xFE\xC4\x66\x83\x11\x76\xDE\xBC\x0A\x90\x04\x04\xD1\x9E\xB3\x20\x19\xC2\x76\xDC\xA9\x26\x03\x41\xEF\xBF\x01\x15\x9E\x8F\xD2\x6A\xAC\x01\x12\xD0\x3C\xC3\x11\xF6\xC6\xA1\xC8\xAA\x0C\x19\xD0\x7D\xCC\xB1\x04\xCD\xD5\xC8\x5B\xB8\x02\x7D\xD1\x85\x8C\x2A\x3F\xE4\xD1\xE7\x7C\x03\x20\xD1\x41\x8C\x2C\x00\xD3\x45\xC3\x78\x21\x0E\xA2\xB6\x8C\x63\x27\xD0\xCF\x7D\x20\x88\x03\x1A\xD2\x5C\xDF\xCD\x5F\xC5\x88\x4E\x04\x47\xFC\xA8\xC6\x25\xA1\x88\xD0\x4F\xB4\x02\x42\xD2\xB5\x8C\x2C\x0E\xD6\xA4\xAA\xAE\x16\x09\xD2\x48\xAD\xB4\x18\xC8\x32\xB0\x06\x7C\x84\xE2\x90\x02\xBA\xB5\xB4\x34\xC1\x00\xDF\x0A\xD6\xD0\x43\x11\x02\x59\xD3\x08\xE2\xCA\x26\xBE\xA5", + "\xB6\xB1\x98\xC9\x99\x9D\xCA\xB5\xAF\xA1\x71\xB3\x05\x67\xD3\x1B\x2F\xB7\x68\x05\x4C\xC6\x08\x2A\x0E\xA6\xBC\x23\xBB\xAA\x03\x72\xD3\x20\x15\x03\x3A\xD2\x10\x41\xCA\x1C\xD9\xD3\x02\x0E\x0A\x3C\xD2\xB3\x2F\x6E\xEE\x00\xA0\xC1\x08\x9E\x86\xD2\xA5\x2C\x6F\xC2\xA3\xD7\xA3\xA1\xC0\x00\x3E\xB2\x51\xD7\xB7\x54\xC2\x07\x0F\xD5\x16\x03\xD4\x00\x05\x1D\xCD\xD5\x0C\x8F\xA8\xDA\x00\xA6\xD7\xCF\x5C\xD0\x00\x36\x03\x47\xDA\x0A\x92\xD6\x6B\xCF\xB7\x78\x07\x51\xE4\x84\x53\xDE\x96\x83\xCA\x1E\x0F\xD4\x5D\x00\x53\xC9\xC9\x50\xDC\x07\x0F\xD5\x91\xAC\xD5\xA1\xC5\x2E\xF8\xAC\x3B\xA3\x6E\xDF\x02\xAE\xB0\xBA\x93\xBF\xDD\x80\x04\x7E\x81\x5E\xB6\x8C\xB0\xD8\xB2\xA9\xC3\x10\x3C\x86\x4D\xDA\x5A\xC7\xD5\x21\xC3\xD3\x00\x00\x11\x0B\xD7\x58\x8E\xAC\xB8\xD1\xF7\xB6\x8D\x8D\x03\x5A\xFE\x96\x67\xDE\xA0\xCD\xD0\x52\xB2\x04\xDA\xD4\xCC\x8E\xD7\x22\xD9\xA3\xB6\x8F\x25\x01\xD7\x3D\xBE\x59\xCC\xD3\x72\xDA\x20\x9C\x04\xBA\xCF\xBF\x5A\xB9\x21\x0E\xD7\x77\xB1\x0A\x7C\x87\x88\xCA\xAD\x62\xBA\x20\x31\xD6\x5D\xDF\xFC\x22\x06\xBD\xD1\x85\xE5\xC7\x5E\xDD", + "\xD0\xDC\xAC\x4C\xC8\xB0\x99\xA5\xC7\x2A\xD6\x3D\xC8\xAB\x53\x00\xA5\xB8\xAD\x39\xD1\xD1\x0A\xD8\xB7\xAD\x05\x86\xDF\xFC\x65\xC6\xB5\xD1\x85\xB3\x04\x62\xF2\xAC\x1F\xDF\x6E\xB9\x06\xC6\xD3\xD4\x17\x70\x5A\xFF\x05\x8F\xD4\x95\xC9\xB1\x9A\xC8\xAA\xC5\x04\x64\xC6\x09\xA0\xC2\xB0\xDE\xD4\x6E\xAE\xA8\x06\xDD\xE7\x81\xCB\x84\xD3\xB0\xCF\x7F\x33\x0A\xD9\x03\x09\x28\xD0\xD9\x9A\xD3\xF0\x55\x04\xCE\xDD\xD3\xDB\x57\xDD\x9B\x07\x9F\xD2\x8D\xD9\x6C\xB4\xC1\x07\x44\xD8\x00\x01\xCA\x72\xD7\xAD\x8A\x92\x44\xA7\xD5\xB6\x89\x28\xEB\xD7\xA6\xDC\x53\xF1\x84\xD4\xCA\x90\x25\xCB\xE8\x96\xBA\xDB\x83\x0F\x27\xD2\xBF\x99\xDA\x00\x04\x66\xEE\xD9\xE7\x7B\x10\xD7\xD8\x4F\xA0\xDB\x3B\xDB\x6C\xC3\x79\x7E\x09\xB4\xE0\xDB\xC5\xDE\xAF\xEC\x82\x3D\xEA\xAC\xB0\xDD\xAD\xEC\xD4\x4F\xA9\x00\x71\xD9\x16\xA0\xDA\xA6\xD5\x7D\xF9\xDB\xD7\xC6\xC1\xE0\xCE\xFB\xBE\xDA\x32\xBC\x97\xAD\xDA\xDD\xCA\xAD\x1B\x04\x1D\x85\xD6\x05\x9C\x97\xE2\xDB\xE1\xC8\xAA\x1E\x04\x1D\x8C\xD6\xC8\xD3\x7A\x9B\xD6\x41\x03\x01\x92\xD9\x16\xBC\xCB\xB7\xD4\x66\xA8\x01\xE6\xDE\x97", + "\x7C\xCD\x6E\xD4\xDA\xD5\xAD\x02\x1F\xDC\xE1\xC2\xB2\xFC\xD3\xE0\x72\x00\xD3\xDD\x73\xFC\xCB\xD4\xD1\x85\x37\x04\x75\xEF\xBE\xC6\xB9\x85\xEF\xB4\x0F\x0A\xDC\xB1\x84\x76\xC2\x08\xC7\xD3\xBA\xC8\xAB\x0F\x12\xDD\xE0\xCA\x77\xC1\x09\xB4\xDF\xB8\xB8\xAC\x11\x00\xDE\x7D\xCA\x78\xC3\x71\x77\xB9\x04\x48\xDD\x41\x8A\xDE\xA2\xD9\x16\x8E\x02\xE7\xD6\x1B\xCA\xDC\xDF\xDE\x97\x53\x04\x7A\xCA\x90\xE5\xDF\xBA\xFE\x94\x16\x1A\xDE\x3C\xA9\x06\xC3\x08\x1D\xCB\xB5\x8A\x91\x17\x0C\x87\x86\xDB\xBD\xBA\xB5\x77\xBE\x05\x6C\x84\xA8\xDC\xA9\xE4\xDB\x77\xE9\xC4\x31\x03\xB8\xBD\xB9\xFC\xC3\xDE\xA9\xC0\x0D\x35\xDF\xF7\xB7\xBF\xCB\xDF\x40\xCE\x03\xFB\xD8\x3C\xFD\xDF\xE8\xDE\x2F\xF4\x01\x00\xFD\xCB\xFD\xDF\x7A\xE4\xB2\x3D\x07\xC0\x85\x89\xFF\xDD\xDE\x64\xB0\x10\x0D\xE0\xDB\x89\x84\xB2\xC3\xBB\xA6\x04\xB8\xDE\x5F\x95\xE1\x81\x0C\xBB\xB1\x85\x22\x00\xDF\xAA\xAB\x83\xC2\x08\xE2\xDD\xBB\xB8\xAE\x23\x00\xE1\x48\xAA\x84\xE8\x5F\x77\xB3\x09\x28\xE0\x6E\xAA\xE1\x76\x78\x5A\xD8\x04\x17\xEF\xFC\x30\xE2\x02\xFD\xB9\x9D\x04\x86\xC3\x78\x18\xE0\xC1\xBD", + "\xBA\x28\x1A\xE1\xE3\x9E\xD4\xAF\xB7\x53\x0C\x0E\x88\x9C\x18\x1A\xB5\x51\xC4\x98\xA9\xC5\x54\x08\xBE\xB1\x85\x12\xF0\xB4\xA9\xC2\x15\x05\xE2\x86\x06\x0B\x96\xB7\x13\xF9\xB4\xA9\xC4\x15\x13\xE2\x27\xC8\xC4\xC2\xBB\x8F\xD6\x8D\xAE\x03\x8B\xC6\x09\x31\x0D\xC5\xFC\x2B\xBB\xB0\x05\x62\xE3\x20\x0D\xB2\x2B\xE2\x2C\x0D\xB9\x1A\xE2\x08\x65\x05\x8C\xEB\xD9\xB4\xCF\xC6\x81\x09\x2F\x8C\xE3\x49\xCB\x20\xF6\x05\x3A\xE0\x00\x67\x02\x1C\xE0\x25\xEF\xB0\x17\x3C\xE3\x61\x88\xC7\xF7\xC1\x2A\xDA\x05\x7C\xE1\x0D\x3F\xE2\x81\x03\xB9\xEA\xDB\xCE\x3C\xE3\x54\xB5\x90\xC7\xC5\xD4\xDE\x83\x7C\xE0\x32\x92\xE4\x99\xB8\x5A\xC0\x06\x3E\xEC\x06\x0B\xE5\x35\x2F\xB7\xC2\x04\x8F\xED\x02\x4F\xE0\x47\x29\xC4\x31\x1C\xE3\x5C\xB0\x93\xC1\x08\xBE\xC1\x99\xFC\xE3\x1B\x1A\xB5\x58\xC2\x20\x35\xA7\xC0\xD6\x1B\xC8\x05\x13\xFE\x97\xB3\xE5\xFC\x6F\xB7\x64\x03\xC1\x8A\x91\x2E\xFD\xE0\xFE\x97\x19\x2C\x86\xE1\xB5\x10\xB9\xE4\x09\xF1\x85\xD7\x03\x98\xF1\x85\x5C\xEC\xB9\xBD\xBB\x37\x0A\xE6\xB8\xE4\x63\xC3\xC9\x73\x00\xCD\xE4\xB1\x2E\xF7\xE1\xEF\xBF\x1D\x15\xE7", + "\x9E\xB9\xCB\xBD\xE3\xFB\xB7\x07\xDB\xE7\xFD\x85\x8A\xE0\xC1\xAA\xFF\x05\x06\xE4\xB3\xE3\xE7\xC4\xA9\xC4\x01\x07\x76\x8D\xE7\xF3\x69\xE7\x03\x0F\x98\xFE\x97\x03\x0D\xCE\xB1\x84\x3C\xE8\x5C\xEF\xB4\x01\x35\xE6\x7F\x97\xCF\xCB\x31\x2A\xD1\x00\xFB\xE0\x9D\xE8\xDD\xF2\xD3\xA4\x81\xE9\xCF\xBD\xE7\xF4\x51\x15\xDB\x00\x83\xEF\x7E\x8A\x9E\x05\xE3\xC8\x20\x07\xEC\x8B\xDC\x9E\xAE\xD0\x9C\xE1\x2A\xC3\x01\x0C\xE8\x3C\xD5\xE9\x11\xE9\x8A\xA8\x01\x46\xFD\xCB\x1B\xEB\x85\xC3\xC9\x16\x0F\xD1\x85\x89\x48\xF1\xE1\x94\xE0\xCB\x25\xE8\xDB\x87\xD2\xD8\xE4\x78\xD7\x01\x2B\xEA\x41\xA7\xE8\x6F\xE0\x9E\xBC\x01\x4C\xFC\xA9\x75\xC1\x21\x27\xE9\x77\xB1\x04\x67\xB9\xFA\xCD\xCE\x4D\x99\x15\xC2\x02\x9F\xE1\x0B\x8B\xC2\xF8\xC7\xD9\xB8\xAB\x08\x04\xEA\x7F\x93\x65\x30\xE3\xBB\xA4\x02\x4B\xEC\xCC\x90\x59\x2B\xE4\xCB\x8A\x91\x11\x11\xEA\x3D\xBD\x8B\x48\xE9\x77\xB6\x04\x58\xEB\xFB\xBE\x57\x39\xE9\xA5\xC6\x09\x23\x0E\xD5\xE0\xCE\x29\xC9\xC5\x48\x05\xAC\xFD\xCA\xEF\x60\xCC\xE4\xB1\x12\x12\xE8\xB1\x86\xBB\x72\xE6\x32\xBC\x04\x70\xEA\xBF\x9E\x6E\xCD", + "\xE7\xFD\x8F\x02\xBB\xE4\x66\xDE\x6C\x01\xE4\xB3\x52\x04\xAF\xFD\xB8\xEF\x6E\xD2\xFD\xC9\x15\x02\xEC\xEF\xBE\xBB\x74\xE9\xBE\xC8\x05\x08\xEC\x78\xC2\x75\xDE\x6F\xDD\x9B\x02\xB5\xE5\x10\xAF\x63\x94\xDD\xB9\x5C\x07\xEC\x88\x9D\x66\x86\x69\xAF\x63\x96\xD6\xDC\x29\xA2\xB3\xCC\x09\x38\x0A\x6B\xAF\x60\xD8\xCF\xB7\x60\x02\xB4\xC9\x08\xAA\x82\x83\xAF\x61\x4B\xC0\xED\x02\x0A\x0C\x2A\xED\xAA\xA5\xDA\xB3\xC9\xA8\xC4\x03\xB3\xEB\x20\x26\xB3\xCE\xED\xC6\x83\xCA\x19\x19\xED\x02\x0D\x0E\x35\xEC\xC1\x99\xBF\xC0\xED\x40\x16\x03\xC3\xEE\x65\x37\xD2\xE3\xE0\x00\x77\x01\x72\xE0\xE4\x03\xCC\x0D\x0C\xEE\x3C\x0F\xDC\xD4\xB9\x2A\xCE\x03\xCC\xE8\x2C\xBC\xEC\xAD\xC2\xD6\x82\xC4\x73\xEE\xB3\xAD\xED\xCA\x90\xD6\x39\x0C\xDC\xFB\x01\x75\xE9\xB5\xA9\xC4\x0E\x0C\xEE\x3E\x07\xDE\xB6\x29\x25\xCC\xEE\x7D\x05\xBD\xF3\xD4\xD8\xEC\x89\xCC\xEE\x1F\x0D\xEF\xAC\xE6\x55\xCC\xEF\x3F\x0A\x6B\xF6\x73\x21\x70\xD6\x7C\x04\xB9\xF5\xB2\xE5\x16\xE7\x0D\x64\xB4\xDE\x03\xCC\xEA\x2E\x84\xF0\x86\x0D\xA6\xD0\xD4\x20\x0C\xEE\xAE\xB4\x5B\x36\x73\x3D\xD0\xAD\x82\x04", + "\x73\xE9\xB7\x30\x1E\xCE\x47\x05\x54\xC4\x08\x4C\xEE\xC1\x31\x29\x76\x76\x7E\x5F\xE2\x05\x96\x08\x4C\xED\x66\x44\x93\x9F\x63\x1A\xCC\xEF\xA4\x5B\xE0\x99\x81\x2A\xCA\x04\xCC\xE9\x93\x59\xF0\x86\x01\xDF\xD0\xD4\x23\x0C\xEE\xCC\x61\xA9\x36\x73\xFB\xE0\xAD\x8E\x04\x73\xF4\x73\x28\xF1\x21\x2B\xE3\xEE\xE2\x10\x10\x04\x73\xE9\x00\x1F\x79\xC8\xC6\x09\x38\xE0\xAD\x92\x04\x73\xFD\x91\x12\xF6\x0A\xA9\xC4\x4A\x0C\xDC\xA5\x01\x92\xFF\x6F\x0C\x0F\x2B\xD0\xD6\x4B\x0C\xDC\x81\xC1\xE6\x16\x73\xA0\xBF\xDD\x98\x04\xE6\xEE\x00\xD1\xF0\x2B\x69\xC5\x9A\x04\xB9\xD0\x03\x8F\x7E\x1D\x76\x71\x0E\x0C\x9D\x05\x8C\x13\x0C\xEF\x1B\xCF\xE5\x8C\x08\x9F\xB0\xD6\x9E\x04\xB9\xF3\xC3\x19\xF9\x10\x02\x05\x2A\xC0\x05\xDF\xEF\xCA\xD3\x7B\x81\x08\x95\xD0\xD6\x28\x0C\xEE\xD4\xC5\xCE\xC9\x09\x58\xD0\xAD\xA4\x04\x73\xF7\x04\x82\xF6\x20\x36\x72\x32\xE0\xAD\xA6\x04\x73\xE5\x05\x91\xF3\x20\x36\x73\x1D\x00\xE7\xB6\x8C\x2A\x0C\xEE\xB3\x07\xE3\x7D\x0C\x3B\x7A\x03\x1D\xF6\x82\x8A\x05\xCC\xED\x67\x8A\xF4\x08\xA9\xC5\xCC\xED\x34\x02\xF5\x58\xF1\x21\x1C\xC8\x68", + "\xDE\x0A\x4C\xEF\xDB\x8B\xF5\xCF\x81\x15\xF0\x04\xE6\xEF\x0E\x19\xF5\xA9\x2C\x08\x91\x01\x15\xF2\x04\xE6\xED\x0F\x3E\xF5\x40\x16\x73\x8E\x01\x2D\xCC\xEF\x05\x0C\x0F\xCA\xF1\x29\xA9\xC5\xB6\x04\xB9\xD9\x01\x66\xF1\xEB\x86\x0B\xA2\xB0\xD6\xB8\x04\xB9\xE7\x00\x6A\xF3\xE8\x82\x08\x96\xD0\xD6\xBA\x04\xB9\xFF\x9F\xCC\x15\xB4\x02\x73\xBB\xBC\x05\x67\xBF\x7D\xEA\xAD\xF3\x69\x8A\xC0\x04\x65\xF6\x8D\x3F\x67\xBF\xC4\xF3\x80\x01\x0C\x4C\xEE\x05\xAA\x1E\x3F\x66\xC0\xF3\xF7\x4E\x4C\xDC\xD1\x00\x3F\x9E\x0E\x3F\x65\xC1\xFB\xF7\x62\x0C\xDC\xAA\xA0\xB7\x1F\x61\x14\xF3\xDF\xC7\x06\x3D\xFC\xED\xAF\x72\x22\xA9\xC5\xC9\x07\xBB\xCD\xF9\x81\x0F\xC3\x22\xF3\xBB\xAB\x06\x88\xF3\xE2\xFE\x9F\x14\xF0\xAD\xCD\x04\x73\xF6\x04\xFF\xF6\x87\x4C\x09\xDD\xEB\xEF\xCF\x04\x73\xE5\xD8\x30\x1F\x87\x75\xF1\x7D\xF1\x0D\x4C\xED\x2C\x1A\xF8\xF0\x54\x21\x3C\xF1\x7D\xF3\x0D\x4C\xEF\xC8\xC7\xF8\x0C\x0B\xC8\xC4\xE8\xD5\xA5\x0D\x4C\xED\x33\x10\xF9\x00\x07\x87\x4C\xF3\x7D\xF7\x0D\x4C\xEF\xD0\xD8\xF9\x09\x0C\xBD\xD0\xD7\x6C\x0C\xDC\xE9\x04\xD0\xFF\x61\x5A\xF3", + "\xDF\xDB\x06\xE6\xE5\xB6\xE6\x1F\x0F\x61\xF3\x03\xCD\x1B\x0C\xEE\x03\x0C\x0E\xBB\x0F\x0F\x6D\x65\xFB\xF7\x1B\x0C\xEF\xAF\xA8\xEF\x8C\x0B\x9B\xE7\xDA\xCC\xE9\x04\x2C\x87\xDE\x0F\xC3\x77\xF3\xBE\xE3\x07\xCC\xE8\x06\x1D\xFA\x91\xFD\xE7\xA9\xC5\x39\x0C\xEE\x3E\x03\xEE\xDC\x7A\x83\x05\xE8\xFB\xF7\x39\x0C\xEE\x4C\x03\xED\xF4\xFA\x83\x0C\xE8\xFB\xF5\x3A\x0C\xEE\x5B\x02\xEF\xCE\xF9\x31\xE9\x8A\xEB\x04\x73\xE9\x03\x8A\xFC\xE2\xCC\x08\x4E\xF0\xAD\xED\x04\x73\xF7\x03\x82\xFB\xEF\xC3\x09\x52\xF0\xAD\xEF\x04\x73\xF8\xE0\x99\x1F\x87\x62\xC9\x7D\xF1\x0F\x4C\xED\x25\x19\xFC\x8B\xFB\x20\x33\xF5\x7D\xF3\x0F\x4C\xEC\x29\x08\xFD\x92\xF9\x21\x10\x05\x54\xC5\x0F\x20\xF5\xE4\xFB\xF8\x09\x09\xD8\xD0\xD7\x7B\x0C\xDC\xC1\x07\xED\xF1\xF9\xC5\x81\x15\xF9\x06\xE6\xE2\xCC\xC8\xFA\x32\x89\xC5\xFB\x04\xB9\xDD\x07\xDF\xF1\xF4\x8C\x0B\xB5\xFB\xF7\xFD\x04\xB9\xEB\x06\xE6\xFF\xC3\x5F\xF7\xBE\xFF\x07\xCC\xE9\x1F\x30\xFC\xB1\x77\x40\xA9\xC5\x00\x17\xB2\xEA\xF0\xA9\xAF\x6F\x70\xAF\x6E\x85\x03\x95\xB7\xEC\x02\x0A\x1D\xC9\x08\x79\xFB\xF3\xC8\xAB\x01", + "\x07\xFF\xA5\x9F\xEC\x9E\x0E\xF5\xF6\x10\x7A\xF5\xFB\xF5\xBC\xF0\xF9\x3A\x32\xFE\xB3\xFC\xE0\xA9\xC7\x02\x19\xFF\xDC\x4F\xD9\x5B\x1B\x34\x7F\x7A\x69\x2A\x6D\x00\x00\x80\x94\x1A\x00\x8C\xFF\x4F\x7C\xD0\x6B\x03\x08\x00\x82\x04\x3E\x02\x02\x89\x10\x04\x80\x00\x30\xB4\x61\x01\x0F\x80\x01\x05\x5D\x7C\x2D\x14\x80\x01\x04\x28\x3B\xEF\x53\x00\x18\x80\x00\x0A\x05\x3B\x7F\x13\x83\xC8\x79\x8A\x55\x00\x21\x83\x19\x02\x01\x86\x04\x1C\x80\x00\x0B\xF2\x77\x7F\xCF\x3F\x05\x01\x02\xB5\x01\x2B\x83\x40\x0D\x02\xB3\x7C\x30\x83\xC0\x39\x01\x21\x80\x83\x01\x0D\x89\xFE\x79\x7C\x0A\x75\x08\x81\x09\x3E\x80\x44\x50\x43\x03\xF4\x79\x80\x82\x55\x08\x8F\x09\x04\x81\x00\x01\x0B\x8A\xF4\x7B\x7B\x1F\x01\x08\x8D\x0A\x0C\x81\x2D\x81\xD4\x78\x04\x89\x04\x21\x01\x08\x8B\x0B\x27\x5D\xBD\x05\x0B\x88\xF5\x61\x6A\x23\x01\x08\x8A\x0C\x14\x81\xA9\x31\x2A\x65\x02\x21\x80\xD8\x00\x09\x8C\x02\xA6\x7D\xA6\x78\x45\x71\x02\xB7\x7D\x99\x0D\x0B\x8E\xF6\x57\x81\x27\x59\x08\x84\x0F\x24\x81\x75\x7C\xB4\x6B\x02\x21\x80\x02\x03\x95\x53\x00\x8C\x04\x7D\x7C\x1D\x88", + "\x68\x21\x80\x10\x03\x95\x5D\x05\xB6\x60\xA9\x63\x0B\x01\x02\x91\x81\x1B\x80\x43\x04\xE9\x7B\x7B\x31\x01\x08\x8D\x02\x3E\x81\x0B\x82\x41\x04\xF9\x7B\x7B\x33\x01\x08\x8B\x03\x06\x82\x95\x83\xE6\x7D\x06\xAA\x56\x35\x01\x08\x8A\x04\x1C\x82\x25\x81\x42\x03\xFA\x42\x82\x02\x07\x0D\x01\x02\x99\x01\xA4\x83\x1A\x82\xEB\x69\x62\x39\x01\x08\x88\x06\x2D\x82\x36\x80\x43\x03\xFB\x50\x6B\x9B\x83\xB8\x57\x07\x14\x82\xA5\x82\x41\x0A\xFB\x7B\x7B\x3D\x01\x08\x85\x08\x3C\x82\xAE\x82\x41\x09\xEC\x50\x6B\x3F\x01\x08\x83\x09\x04\x83\xB5\x81\x42\x0F\x08\x29\x62\x41\x01\x08\x81\x0A\x0C\x83\x3F\x81\x42\x0F\xFC\x68\x82\x01\x07\x10\x01\x02\xAF\x02\xD4\x81\x11\x89\x10\x16\x7F\xD8\x80\x00\x05\x04\x21\x80\xBD\x00\x2D\x82\x10\x38\x41\x8F\x3B\xBB\x57\x04\x20\x7F\xB1\x41\x38\x5D\x02\xAF\x5B\x4B\x03\x95\x5F\xD3\x49\x04\xFF\x62\x41\x06\x05\x88\x75\xCF\x3C\x13\x01\x02\x85\x44\xF5\x80\xA1\x79\x8A\x4E\x01\xFB\x82\x6D\x4D\x0F\x82\x04\xA7\x80\x3E\x83\xF0\x10\x01\x01\x86\x82\x43\x10\x81\x04\xAB\x7D\x38\x82\x05\x09\x84\x3C\x57\x42\x80\x00\x20\x83\x06", + "\x84\x43\x04\x05\x10\x84\xAA\x55\x43\x66\x10\x15\x64\xD0\x6A\x15\x02\x0F\xB1\x42\x1C\x86\x41\x06\x90\x61\x83\x57\x03\x95\x53\xD1\x6A\x56\x0D\x84\x04\x89\x8A\x5A\x01\x1F\x86\xBF\x45\x10\x81\x04\x5A\x00\x91\x45\x10\x5B\x01\x21\x80\x33\x0D\x12\xAC\x7A\x09\x06\x4A\x61\x0E\x9D\x01\x37\x85\xCF\x5A\x13\xAA\x54\xA9\x62\x17\x0D\x13\xAF\x5F\x31\x67\x40\x01\x13\x90\x6B\x5F\x01\x08\x8D\x0C\x03\x85\x01\x07\x4D\x61\x10\x23\x84\x15\x85\x42\x01\x06\x2C\x83\x22\x54\x43\x05\x14\x91\x85\x4B\x78\x53\x8D\x97\x47\x65\x69\x4D\x2A\x66\x06\x21\x80\xCE\x03\x95\x5E\x1D\x1C\x85\x02\x06\xFD\x78\x15\x83\x04\xB3\x83\xB8\x5B\x0D\x22\x85\x79\x49\xFF\x70\xAD\x6A\x01\x21\x80\x3A\x0D\x0D\x80\x00\x64\x85\x40\x09\xF0\x61\x83\x6C\x01\x08\x86\x0F\x33\x85\x75\x84\x00\x0B\xE1\x50\x6B\x6E\x01\x08\x84\x00\x2A\x5A\xBB\x05\x5F\x86\xF1\x43\x64\x70\x01\x08\x82\x01\x04\x86\x6D\x84\x27\x34\xA9\x61\x80\x20\x02\xAA\x53\x16\xA6\x80\xD0\x68\x1D\x02\x09\x8C\x86\x09\x05\x5F\x8F\x02\xA7\x85\x02\x06\x1D\x0A\x09\x98\x86\x06\x05\x5F\x88\x03\x9C\x86\x9C\x61\x08\x89\x04", + "\x20\x86\x03\x05\x5F\x8A\xF3\x64\x86\x00\x02\x1E\x01\x02\x97\x01\xA8\x86\x40\x0D\x17\x87\x81\xAC\x84\x1F\x01\x02\xA5\x01\xB1\x85\x40\x0D\x17\x8F\x81\xE1\x82\x1F\x01\x02\xB3\x01\xB9\x84\x5D\x89\xE5\x69\x62\x80\x01\x08\x81\x08\x2A\x5A\xBD\x05\x5F\x8F\x05\xB4\x77\x00\x02\x20\x01\x02\x90\x02\xC1\x85\x5F\x80\xF6\x61\x83\x84\x01\x08\x8E\x09\x12\x86\x8D\x84\x0B\x8F\x09\x88\x55\x86\x01\x08\x8B\x0A\x08\x87\xD9\x85\x21\x53\x8D\x61\x80\xBA\x01\x74\x8C\x10\x3E\x79\xD0\x6A\x22\x01\x02\x88\x03\xE6\x85\x42\x01\x08\xAC\x86\x8C\x01\x08\x86\x0D\x20\x87\x99\x84\x22\x8D\xE3\x6F\x81\xED\x84\xE3\x70\xAD\x50\x02\x21\x83\x3C\x09\x1F\x83\x04\x97\x81\x38\x82\x09\x21\x80\x01\x00\xD7\x59\x1C\x8C\x04\x9C\x7F\xBE\x74\x09\x04\x82\x06\x89\x78\x84\x10\xA9\x62\x96\x03\x22\x8D\x20\xB5\x87\xAF\x82\x0C\x71\x02\xAE\x00\x13\x89\x68\x86\x0B\xA8\x79\x21\x81\x0F\x0C\x75\x45\x86\xC0\x79\x2A\x6C\x09\x21\x80\x4B\x03\x87\x8E\x20\xA0\x52\xA9\x62\x27\x0B\x0A\xA6\x88\x14\x8B\xF1\x70\xAD\x60\x02\x29\x80\x8B\x8A\x21\x96\x83\xA9\x62\x28\x03\x03\xB2\x88\xA9\x84", + "\x43\x04\x11\x95\x75\xDA\x58\x0F\x89\x21\x83\x04\x4D\x66\x48\x89\x8A\x66\x02\x26\x85\x2C\x42\x95\x63\x75\x4B\x72\x56\x8B\x81\x67\x88\x23\x78\x4F\x5A\x0A\x0A\x89\xB6\x47\x3D\x8A\xF5\x29\x62\xAB\x01\x08\x82\x09\x1C\x5D\x2E\x3E\x94\x84\x65\x29\x62\xAD\x02\x32\x88\x25\x83\x87\xB6\x63\xBE\x7C\x0D\xA3\x5B\x94\x03\x97\x89\x10\x1A\x89\xAF\x75\xC4\x6F\xFC\x31\x02\x21\x81\x25\x06\x26\xB6\x83\xB6\x74\x73\x83\x0B\x21\x80\x96\x03\x9B\x83\x10\x1A\x89\x3A\x64\x73\x85\x0B\x21\x80\x97\x02\x9D\x82\x10\x1A\x89\x7E\x6B\x40\x67\x0B\x21\x80\x98\x02\x9F\x81\x10\x1A\x89\x0D\x09\xC7\x61\x02\x99\x02\x86\x88\x00\x0A\x25\x8C\x6A\x6A\x8B\xC0\x3B\x0B\x21\x80\x9A\x01\xA3\x8A\x25\xA5\x63\x36\x5D\x08\x8B\x09\x16\x8A\x0C\x06\x3B\x75\xC2\x4F\x3F\xBF\x01\x08\x8C\x09\x1C\x8A\x31\x6C\x6B\x81\x0C\x21\x80\x9D\x00\xA9\x86\x6D\x50\x6B\xC3\x02\x75\x8A\x2A\xA4\x11\xEF\x59\x31\x0A\x04\xAF\x8A\x1F\x11\x2A\x67\x0C\x21\x80\xA0\x00\xAD\x8B\xCA\x50\x7C\xD2\x81\xA3\x86\x96\x6B\x7F\xA9\x63\x32\x01\x02\xA2\x02\x5C\x5E\x77\x0F\x2B\xB5\x7F\xA9\x63\x52\x83\x6E\x6F", + "\x02\xC5\x88\x43\x07\x2C\x83\x04\x02\x7D\x38\x8F\x0C\x21\x80\xBC\x00\x8E\x82\x10\x0F\x8B\x02\x07\x5D\x8C\x1A\x91\x03\x62\x82\xB5\x81\x10\x18\x8B\x01\x07\x5F\x84\xF3\x68\x81\xDE\x88\x00\x00\x2E\x80\x00\x87\x85\xA8\x65\x0D\x21\x80\xE6\x01\xB9\x87\x2E\x9E\x80\xE1\x83\x35\x06\x07\x8D\x8B\x09\x07\xB9\x84\xF2\x61\x83\xD9\x00\x81\x8E\x7A\x7B\x06\xE7\x8B\x66\x8C\x23\xAA\x56\x6B\x84\xC2\x5B\x2F\x8E\x8B\x32\x7D\x2A\x6D\x0D\x21\x80\x1D\x03\xC0\x85\x2F\x80\x81\xD0\x6B\x37\x01\x02\xAB\x00\x0A\x8E\x41\x07\x2E\xB4\x86\xFF\x88\x52\x51\x0E\x21\x80\x39\x01\xC4\x83\x10\x27\x8B\xBC\x84\x6B\x83\x0E\x21\x80\x47\x02\xC6\x87\x2D\xA0\x89\xFB\x79\x39\x01\x02\x95\x01\xAE\x5D\x6F\x07\x2E\x8B\x87\x91\x88\x43\x07\x0E\x21\x80\x64\x02\xC8\x8F\x2D\xA5\x81\xD0\x69\x3A\x01\x02\xB2\x01\xAE\x5E\xB1\x8C\x06\x90\x6B\xEB\x01\x08\x8F\x07\x29\x8C\x04\x8D\x42\x03\x07\xAC\x86\xED\x01\x08\x8E\x08\x32\x8C\xE6\x8B\x79\x89\x8A\x6F\x03\xA2\x88\xD2\x87\x2E\xAF\x87\x15\x8C\x6E\x51\x0F\x21\x80\xAA\x00\xD0\x8B\x30\x8B\x7A\xA9\x63\x3C\x01\x02\xB9\x02\x4E\x8E\x23", + "\x84\xFB\x61\x80\xC7\x01\xD7\x89\x10\x01\x88\xAC\x87\x3D\x01\x02\x95\x03\x56\x8E\xC4\x88\x20\x9B\x87\xB8\x55\x3E\x01\x02\xA4\x03\x69\x8F\xC6\x8C\x10\x2F\x84\x4D\x8A\x6A\x5B\x0F\x3D\x87\x71\x8F\xC8\x85\x21\x90\x7F\x7C\x82\x75\x0A\x32\x9B\x88\xD0\x6B\x3F\x01\x02\x91\x00\xD6\x04\xBF\x81\x22\x90\x6B\x01\x02\xAA\x5B\x78\x45\x8E\x41\x8E\x31\x89\x8A\x43\x00\x8A\x8E\x76\x3C\x38\x97\x8D\x2E\x8B\xBE\x75\x00\x11\x8E\x63\x8F\xE4\x8A\x36\xB4\x88\xD0\x6B\x01\x08\x39\xBC\x7D\x9A\x8E\xDC\x8F\x0D\xA9\x62\x09\x03\xE7\x83\x10\x17\x01\x7E\x8C\x43\x0C\x96\x42\x89\xD0\x6B\x02\x0A\x6A\x61\x7F\xB8\x56\x5C\x66\x10\x2B\x8E\xE1\x83\x03\x0A\x6A\x73\x83\x06\x05\x5E\x64\x39\xA1\x83\x10\x03\xED\x81\x0B\x41\x66\xB9\x8F\x3F\x7E\x3B\xBE\x4B\x3B\x88\x00\x00\x15\x91\x8D\xCF\x3F\x62\x8D\x5E\x60\x67\x60\x69\x42\x01\x2D\xAC\x86\x15\x02\xE9\x8F\x7E\x4D\x8F\x06\x06\xB6\x88\x3C\x83\x3C\x17\x02\xF4\x8C\x3C\x8C\x04\xE2\x89\x38\x89\x01\x1A\x8F\x7D\x64\xF5\x8E\xBF\x10\x6B\x1B\x00\xF8\x85\x10\x62\x8F\x02\x07\xBD\x8C\x1A\x9D\x00\xE6\x8E\x6D\x48\x3E\x81\x04", + "\xFE\x89\xDD\x88\x54\x5F\x00\xED\x8E\x82\x4F\x3E\x80\x00\xA3\x87\xF5\x89\x83\x75\x8F\x3C\x57\xFD\x8B\x1A\xBA\x8F\x09\x07\x08\x0C\x3F\xAA\x56\xF7\x8C\xC5\x82\x3F\xB8\x56\x25\x03\x00\x98\x54\x77\x8F\x1D\x8C\x00\x96\x10\x27\x00\x0A\x90\x6E\x57\x3F\x9A\x89\xEF\x59\x0A\x00\x3E\xA6\x01\xD6\x06\xCB\x37\x3F\xAC\x8C\x3C\x6F\x8A\x11\x41\x8F\x3F\xF7\x8F\xD9\x7B\xEF\x6D\x00\xE0\x8F\x19\x09\x41\x9F\x69\x76\x79\x22\x8F\x41\x83\x3C\xF7\x8C\x7A\x80\x09\xAB\x90\x28\x92\x7B\x89\x8A\x73\x00\xE0\x8C\x1A\x07\x42\x89\x04\xF7\x8D\xE1\x71\x0E\xB5\x00\x30\x90\x0E\x9E\x35\x90\x6B\x37\x01\x0F\x96\x10\x37\x8F\x64\x8E\x03\x96\x03\xA0\x8F\x69\x03\x0D\x93\x44\xAB\x8D\xB8\x80\xF8\x8A\x06\x0A\x91\x03\x07\xFD\x84\x37\xAF\x5B\x3D\x00\xF8\x8B\x06\x10\x91\x02\x07\xFD\x89\x12\x86\x91\x02\x07\x0F\x00\x3E\xAC\x01\x58\x91\x40\x07\x3F\xB7\x82\xFB\x79\x10\x02\x44\x91\x91\x87\x8F\xBE\x73\x04\x27\x91\x59\x90\x43\x07\x0C\xBB\x7B\x45\x00\x1B\x92\x46\x8C\x04\xCF\x80\xB4\x67\x04\x32\x91\x00\x03\xFD\x87\x0D\xAC\x86\xA7\x87\xB8\x57\x3E\xBA\x88\xA9\x63\x12\x00", + "\x3E\xAD\x01\x61\x90\x00\x0F\x3C\x81\x04\x74\x68\xB4\x6D\x04\x03\x8F\x64\x59\x22\x96\x10\x37\x58\xD0\x6A\x13\x0A\x6A\x67\x84\x48\x56\x23\x93\x10\x20\x5D\xFB\x79\x14\x0A\x6A\x5E\x8A\x16\x87\x93\x2D\x11\x9B\x92\xB1\x42\x25\x92\x10\x2B\x5D\xFB\x7B\x16\x00\x4A\xBE\x4B\xA2\x90\xA2\x20\xAD\x60\x01\xA7\x91\x23\x9C\x10\x33\x5D\xFB\x78\x6E\x8C\xDD\x7D\x5C\xA9\x90\x00\x01\xA9\x2F\x85\xAD\x90\x2D\x95\xAA\x07\x90\xCF\x3F\x1B\x09\x4B\xAF\x5F\xB5\x93\xAC\x2C\x4B\x83\x3C\x74\x03\x2F\x90\x9E\x75\x92\x00\x2F\xBB\x59\x07\x06\x93\x7D\x65\x2D\x97\xB0\x07\x78\xCC\x91\x41\x45\x4B\xBF\x2C\xEF\x5B\x20\x01\x4D\xB6\x46\xB5\x90\x8B\x7B\xEF\x48\x02\xD7\x92\x82\x45\x4B\x92\x5E\x5C\x91\x40\x0D\x08\x1D\x93\x47\x6B\xDB\x2C\x1A\x92\x02\xE4\x92\x6A\x56\x3D\x80\x00\xEC\x7C\x6B\x87\x09\x20\x8F\x6E\x02\x75\x0E\x1D\x2B\x93\x66\x85\x38\x90\x00\x19\x02\xE0\x8F\x1E\x02\x4F\x8C\x04\xEB\x93\x21\x93\x4C\x99\x04\xE0\x8C\x22\x01\x3A\x99\x8B\xFC\x91\x2A\x6D\x09\x20\x8F\x96\x03\x40\x96\x17\x9C\x8F\xA9\x63\x27\x00\x3E\xA4\x02\x0A\x94\x00\x0B\x4E\xA9\x8B\xCC", + "\x85\x28\x00\x3E\xB2\x02\x11\x97\x3A\x90\x2F\xAC\x86\xA3\x00\xF8\x80\x0C\x3B\x93\x09\x07\x3A\x9A\x3E\xB6\x93\xA5\x00\xF8\x8D\x0C\x19\x94\x34\x79\x2A\x67\x0A\x20\x8F\xDB\x00\x4A\x97\x06\x4B\x71\xE0\x8D\x3A\x0E\x52\xB8\x50\x54\x88\xF8\x87\x0F\x33\x94\x03\x06\x01\x9F\x6E\x6D\x02\xE0\x8D\x01\x08\x1D\x3B\x06\xEB\x91\x03\x9F\x4F\x91\x1A\xE0\x8F\x04\x0F\x53\x85\x94\x67\x89\x2A\x61\x0B\x20\x8F\x21\x00\x76\x0D\x1B\x2B\x93\x1C\x92\x23\x71\x71\x20\x8F\x30\x03\x51\x91\x52\xB4\x8C\xFB\x79\x2D\x00\x3E\xBE\x00\xD8\x07\x3C\x9B\x33\xBB\x7B\xB7\x00\xF8\x8B\x04\x0E\x95\x48\x97\x9E\x59\x8A\x79\x02\xE0\x8E\x16\x06\x55\x95\x8F\x4A\x8C\xB4\x6B\x0B\x35\x90\x6B\x95\x01\x82\x43\x90\x6B\xBD\x00\xF8\x86\x07\x24\x95\x57\x94\xD6\x82\xB2\x60\x8F\x85\x01\x5C\x94\x50\x8B\x4B\xA9\x61\x30\x00\x3E\x93\x02\x7E\x97\x42\x93\x36\xAC\x8D\xCF\x3F\x30\x00\x3E\xA1\x02\x78\x94\x5B\x99\x10\x09\x88\xE1\x81\x31\x00\x3E\xB0\x02\x8D\x96\x5C\x98\x13\x8A\x7C\xE0\x8F\x2F\x05\x59\xBF\x95\x06\x07\x16\x93\x54\x86\x04\xC9\x00\xF8\x8E\x0C\x1B\x96\x86\x96\x41\x04\x46", + "\xA1\x83\xCB\x00\xF8\x8D\x0D\x05\x96\x12\x95\x1A\x91\x0E\x8D\x03\xE0\x8F\x3A\x0C\x5A\xAB\x93\x6F\x92\xB4\x80\x3E\xB9\x03\xB3\x94\x1D\x99\x8A\x51\x03\xE0\x8F\x01\x0A\x1D\x00\x95\xCE\x7D\x2A\x63\x0D\x20\x8F\x15\x03\x6F\x95\x56\x83\x04\xC5\x8F\xBB\x55\x0D\x20\x8F\x23\x02\x76\x0D\x1B\x02\x6A\x66\x68\xB4\x67\x0D\x13\x92\xB1\x40\x74\x96\x10\x18\x92\xE1\x82\x36\x09\x4E\x88\x55\xD6\x97\x99\x2D\x30\x9B\x97\xB8\x55\x77\x93\x4A\xA9\x62\xE4\x00\x78\x9F\xFC\x22\x97\xAA\x92\xE1\x76\x5E\x83\x3C\xE8\x94\x00\x00\x4B\xA1\x83\xEE\x03\x7A\x9C\x10\x2D\x97\xB7\x90\xEB\x72\x5F\x87\x4A\xBB\x93\xBB\x58\x0F\x37\x97\x06\x05\x7B\x92\x4C\xAF\x5B\xFD\x00\x7F\x93\x10\x2D\x97\xC9\x93\x40\x62\x00\x1C\x5D\x9C\x90\x7E\x99\x10\x0F\x93\xFB\x7B\x01\x08\x60\x95\x97\x42\x2D\x3E\x7F\x60\xBE\x4B\xED\x96\x36\x91\x0E\x91\x00\x13\x98\x99\x5D\x5E\xA0\x93\x9F\x96\x53\x39\x61\xBD\x5C\xED\x94\xDA\x2C\x1A\x9B\x00\x1F\x9B\xFB\x59\xA8\x7D\x97\xA9\x60\x08\x0D\x28\x85\x44\x91\x6A\x41\x0D\x4E\xB6\x93\x21\x00\xD7\x58\x38\x72\x00\xDA\x06\x77\x0D\x62\x83\x04\xF5\x91", + "\x87\x92\x10\x23\x00\x32\x98\x43\x0F\x03\x35\x98\x0C\x07\x8D\x92\x10\x3E\x93\xEF\x59\x09\x0D\x63\x89\x04\x4C\x02\x71\x99\x10\x02\x99\xA5\x95\x38\x87\x02\x07\x99\x06\x06\x16\x0A\x64\x86\x04\x4C\x9A\x5F\x89\x8A\x69\x00\x50\x98\x5A\x83\x65\x83\x04\x55\x98\x45\x9D\x32\xB0\x18\x59\x99\x67\x8B\x65\x82\x04\x55\x9B\x46\x96\x4F\xAD\x00\x61\x99\x40\x04\x08\x00\x99\x4B\x98\x65\x8B\xEF\x6F\x00\x69\x98\x00\x01\x09\x23\x99\x01\x05\x95\x91\x3F\xAF\x5B\x31\x01\x9C\x9F\x09\x34\x99\x90\x69\xC1\x80\xAD\x73\x00\x71\x99\x2B\x0C\x67\x95\x99\xFF\x8E\x8E\x90\xAF\x31\x99\xBB\x03\xA0\x96\x04\xA9\x62\x37\x01\x9C\x99\x0C\x0A\x9A\x49\x7C\x2C\x81\x67\x97\x03\x90\x98\x9C\x88\x0B\xB1\x99\xE5\x02\x73\x91\x64\x94\x30\x86\x9A\xF1\x81\x67\xB4\x03\x95\x9A\xAD\x49\x8A\x7F\x00\x71\x9A\x00\x0C\x1D\x36\x98\x5F\x95\x38\x81\x04\x31\x99\x0F\x00\x77\x0D\x1B\x15\x99\x43\x8E\x3D\x93\x04\x31\x99\x1E\x00\x77\x0B\x1B\x15\x99\x2E\x91\x38\x85\x04\x31\x99\x2C\x02\xAD\x9B\x69\xB3\x95\xFB\x7B\x11\x01\x67\xBA\x00\xAE\x9B\xAF\x94\xF8\x69\x62\x49\x01\x9C\x99\x04\x3E", + "\x9A\x6D\x98\x60\x90\xAD\x65\x88\xE3\x5B\x15\x0C\x6C\x94\x99\x93\x7C\x62\x93\xF0\x0D\x01\x71\x99\x19\x05\x6C\x8D\x9B\x06\x04\x64\x9C\x1A\x8F\x01\x71\x98\x1D\x0B\x6D\x94\x9B\xA6\x81\x2A\x61\x05\x31\x99\x83\x03\xB8\x9C\x65\x8C\x04\x9E\x97\xBB\x53\x05\x31\x99\x92\x02\xBA\x94\x66\x80\x8E\xFB\x79\x15\x01\x67\xA1\x02\xD3\x9B\xBA\x99\xFB\x69\x62\x57\x01\x9C\x9F\x0A\x39\x9B\xF3\x99\xF0\x70\xAD\x59\x01\x71\x99\x2F\x00\x70\xB5\x99\xBA\x94\xB4\x6B\x05\x31\x99\xCB\x03\xC1\x9D\x67\x9C\x8E\xFB\x79\x17\x01\x67\x99\x03\x0E\x9D\x95\x99\x5C\x83\x64\x5F\x01\x9C\x97\x0E\x32\x9B\x24\x52\x21\x39\x8A\x61\x01\x71\x9A\x3D\x07\x6A\x8C\x04\x97\x69\x42\x09\x63\xAF\x5B\x63\x01\x9C\x93\x00\x39\x06\xDE\x05\xC9\x96\x10\x04\x99\x03\x65\x19\x01\x67\x90\x00\xB9\x07\x6E\x0E\x72\x96\x96\xE1\x83\x19\x04\x6B\xB5\x9C\x24\x9C\x43\x90\xAD\x69\x01\xBC\x98\xCF\x99\x10\x37\x9C\x15\x83\xBE\x7B\x06\x03\x9B\x42\x9E\x41\x04\x74\x9D\x80\xA9\x61\x1B\x01\x67\x88\x01\x2C\x9D\xCF\x9E\xE2\x50\x6B\x6F\x01\x9C\x95\x05\x09\x9D\x03\x07\xD2\x9E\x02\xA9\x62\x71\x01\x9C", + "\x93\x06\x18\x9D\x02\x06\xD6\x99\x3F\x9D\x9A\x73\x01\x9C\x91\x07\x20\x9D\x1D\x9E\x90\x79\x8A\x75\x01\x71\x9B\x1F\x08\x76\x80\x00\x5A\x9E\x4E\x93\x90\x77\x01\x71\x99\x23\x0F\x76\x9A\x9D\x42\x96\x32\x91\x67\x9B\x02\x77\x9C\xC9\x81\x0E\xBB\x01\x71\x99\x2A\x09\x1B\x3D\x06\x5A\x9D\x54\x95\xBC\x4F\x3F\x7D\x01\x9C\x98\x0B\x3D\x9D\x67\x78\xB4\x6F\x07\x31\x99\xC6\x01\xD4\x93\x74\xA9\x9A\xAC\x85\x20\x01\x67\x93\x03\x83\x9E\xD4\x96\x56\x90\x6B\x83\x01\x9C\x92\x0E\x0C\x9E\x06\x05\xAE\x9C\x1A\x85\x02\x71\x98\x3C\x00\x7A\xBE\x83\xD0\x6B\x21\x01\x67\xBE\x03\x99\x9F\xE4\x9A\x57\xBB\x7B\x89\x01\x9C\x9D\x00\x20\x06\x36\x9F\x0F\x9B\xEF\x4B\x02\x71\x9B\x06\x04\x7B\x9A\x9E\x00\x8A\xB5\x9F\x0B\x71\x99\x29\x00\x68\x04\x78\x8C\x91\xFB\x7B\x23\x01\x67\xB8\x00\xC2\x9C\xEF\x9F\x20\x90\x6B\x91\x01\x9C\x97\x04\x09\x9F\xAE\x9D\x67\x99\x8A\x53\x02\x71\x9A\x15\x00\x7D\x8A\x9D\xF4\x99\x38\x8E\x26\xA3\x5B\x65\x03\xEE\x91\x7D\x83\x04\xBF\x81\x38\x8D\x27\xA3\x5B\x73\x02\xF7\x98\x7D\x82\x9C\xFB\x78\xA3\x83\x6E\x41\x02\xE6\x9D\xD6\x99\x70\xBB\x7B", + "\x9B\x8B\xB8\x5F\x08\x2D\x9F\x61\x9D\x70\x90\xAD\x69\x8A\xE3\x59\x27\x04\x7F\xA9\x9D\x06\x07\xC5\x91\xAA\x5F\x02\x71\x9B\x2A\x07\x7D\x86\x85\x0C\x04\x24\x9B\xEF\x61\x02\x5C\x5C\xEC\x8F\xFC\x1E\x6A\x48\x29\x2A\x65\x0A\x1C\x5D\x72\x6C\x52\x5C\x80\xAA\x29\xFB\x7B\x2A\x00\x81\xB1\x42\x13\xA3\x40\x04\x4A\xA1\x83\xB1\x03\x05\xAE\x2F\x59\xA0\x8B\x28\x58\x9E\x81\xA4\x59\x20\xA1\x40\x0F\x5E\xAC\x86\xBD\x03\x08\xAD\x73\x65\xA0\xB6\x91\x2A\x63\x0C\x2A\xA0\xEF\x5C\x0B\xAA\x77\x7B\x72\x30\xA0\x78\x6C\x82\xBF\x97\x03\x67\x33\x05\x83\xBD\x65\x2C\xA1\x81\x9A\x2E\xBB\xA0\x05\x44\x0B\xAC\x60\xA1\x83\xDB\x00\x10\xA6\x1B\x6C\xA0\xD4\x93\x40\x61\x0E\x06\xA1\x0A\x48\x0B\xA6\x61\xAC\x86\xE7\x00\x13\xAC\x53\x6C\xA0\x1C\x9B\xBB\x5D\x0E\x12\xA1\x4E\x6A\x39\x96\x4F\xB3\x03\x58\xA0\x52\x55\xAA\x51\x99\xC2\x7F\x8A\x96\x1B\x6B\x6A\xE7\x9F\xBE\x7A\x0F\x22\xA1\xE6\x6E\xB1\x91\x0E\xBB\x03\x68\xA0\x4F\x57\xAB\x6E\x98\xA9\x60\x3F\x01\x67\xBA\x02\xA0\x06\x77\x0F\x86\xB8\x98\xA9\x62\x3F\x01\x67\x87\x03\x75\xA0\x43\x07\x87\x83\x99\xA9\x61\xE8\x52", + "\x6D\x54\x03\xFB\x9C\x00\x0F\x87\x8D\x99\xAC\x86\x00\x0E\x7A\x48\x4E\xE2\x01\x21\xA7\x88\x96\x99\xD0\x68\x01\x0B\x88\x9A\x33\x8E\xA3\xFF\x26\x4F\x86\x00\x93\xA1\x42\x0E\x0F\x15\xA2\x8E\x84\xB4\x68\x00\x19\xA2\x55\x06\x68\x06\x87\xAE\x99\xE1\x82\x02\x00\x8A\x83\x04\x19\x02\x68\x0B\x1B\x0F\xA2\x77\x9B\x40\x6C\x00\x27\xA2\x02\x07\x09\x0A\x8A\xBE\xA1\x7E\x9B\xBE\x7E\x00\x30\xA2\xF0\x2B\x2C\xA9\x10\x0F\xA2\x85\x9B\xBB\x50\x01\x38\xA2\x00\x03\x10\x0A\x8B\x86\x04\x8F\xA2\xDC\x91\xAA\x52\x00\xC0\xA1\x14\x03\x8C\xA9\x50\x52\x78\xB4\x64\x01\x00\xA3\x5F\x03\x32\xA2\x10\x0F\xA2\x14\x93\x40\x66\x01\x00\xA3\x6D\x02\x68\x0D\x1B\x0F\xA2\x86\x9F\xA7\x83\xF0\x18\x00\xC0\xA0\x1F\x02\x8D\x81\x04\x8F\xA3\x74\x8C\x1A\x9A\x00\xC0\xA2\x22\x02\x8A\xB4\xA2\x13\x82\xEF\x92\x38\x40\xA3\x97\x02\x36\xAC\x8E\x9B\x9E\xFB\x7A\x07\x00\x8C\xA6\x02\xE3\xA2\x21\xAD\x56\xBB\x7B\x20\x00\x30\xA4\x0B\x39\xA3\x8F\xA0\xD4\x8D\x69\xA2\x00\xC0\xA2\x30\x02\x8F\xBB\xA2\xF6\x87\xBE\x74\x02\x00\xA3\xD1\x00\x40\xA6\x7B\xA1\x83\x26\x00\x30\xAF\x0D\x0E\xA4\x87", + "\x94\xB4\x68\x02\x00\xA3\xED\x03\x41\xA4\x8C\x84\x9F\xE1\x82\x0A\x00\x8C\xBC\x03\x1A\xA4\x33\xA5\x6E\x90\x6B\x2C\x00\x30\xAB\x00\x08\x06\xDB\xA0\xBB\x99\x8A\x6E\x00\xC0\xA2\x06\x08\x92\xB3\xA3\xB9\x78\xB4\x60\x03\x00\xA3\x29\x00\x62\x0B\x8A\xAE\x96\xAC\x86\x0C\x00\x8C\xB7\x00\x36\xA4\x4C\xA2\x10\x35\x96\xAC\x84\x0D\x00\x8C\x85\x01\x3D\xA4\x42\xAE\x0C\xA9\x62\x36\x00\x30\xA3\x05\x05\xA5\x1B\xA4\xC4\x91\x0E\xB8\x00\xC0\xA1\x18\x0C\x94\xA2\xA4\xFD\x9D\x2A\x6A\x03\x00\xA3\x6F\x03\x4B\xA9\x10\x3E\x6A\xC0\x88\xB4\x6C\x03\x00\xA3\x7E\x00\x62\x0E\x1D\x1C\xA5\xC8\x88\xB4\x6E\x03\x00\xA3\x8B\x02\x58\xAC\x10\x24\xA5\xD0\x89\x2A\x60\x04\x00\xA3\x98\x03\x54\xA2\x10\x2C\xA5\x9C\x95\x38\x82\x04\x37\xA3\x72\xA5\x40\x04\x97\xA1\x8B\xA9\x60\x11\x0E\x8F\xB9\xA5\x00\x03\x5E\xA8\x2E\xA9\x62\x46\x01\x41\xA0\x98\x82\xA6\x66\x99\xA7\x98\x04\x00\xA3\xD0\x02\x5A\xAB\x95\xA4\xA2\xAC\x86\x12\x00\x8C\x9D\x03\x87\xA5\x4A\x90\xAD\x4C\x01\xC0\xA3\x3A\x05\x99\xAF\x94\x91\x90\x30\xA9\x0F\x1B\xA6\x34\x94\xB4\x60\x05\x00\xA3\x07\x02\x62\x0B\x1B", + "\x02\xA6\xC6\xA0\x73\x82\x05\x00\xA3\x15\x02\x69\xAB\x96\x8D\xA3\xFB\x78\x15\x00\x8C\xA3\x00\xAE\xA7\x63\xA9\x54\x9D\x84\xC0\xA1\x0C\x0A\x18\x3D\x06\x82\xA5\x37\xA1\x0B\x58\x01\xC0\xA0\x10\x05\x9B\x86\x04\x82\xA6\x39\xA6\x4F\x9A\x01\xC0\xA2\x13\x0A\x18\x23\xA5\x94\x9E\x3D\x9C\x05\x00\xA3\x5B\x03\x6E\xAF\x9A\x82\x8D\x41\x84\x30\xAA\x06\x03\xA7\x03\x06\x60\xA2\x7A\xB6\x93\x60\x00\x30\xA8\x07\x18\xA7\x73\xA4\x20\x83\xBF\x40\xA3\x86\x02\x74\xA6\x9B\x87\x9B\xD0\x69\xCC\x83\x6E\x55\x02\xE0\xA6\x5E\xAF\x90\xAC\x86\x66\x00\x30\xA3\x0A\x2D\xA7\x81\xA5\xB5\x90\xAD\x68\x01\xC0\xA1\x2C\x06\x9E\x84\xA7\x1C\xA4\x6B\x8A\x06\x00\xA3\xC0\x03\x7E\xA9\x9D\xB3\x8D\xA9\x60\x1B\x00\x8C\x8F\x03\x02\xA9\x78\xAB\x37\xA1\x83\x6E\x00\x30\xAE\x0D\x09\xA8\xEE\xA6\xEC\x79\x8A\x70\x01\x18\xA4\x7D\xA2\x98\xA1\x9F\xAC\x84\xCE\x83\x6E\x7B\x03\x16\xAA\x1B\x99\xDE\x40\xA3\x09\x00\x63\x07\x9A\xAF\x9F\xE1\x82\x1D\x00\x8C\x97\x00\x22\xAB\x74\xA6\xED\x69\x62\x78\x00\x30\xA5\x02\x29\xA8\xE7\xA4\x72\x99\x8A\x7A\x01\xC0\xA3\x0C\x0C\x18\x3D\x06\x47\x71", + "\x74\x9B\xEF\x7C\x01\xAE\x5E\x02\xA3\xF0\x39\xA8\xD7\x94\x71\x8E\x7A\x51\xA0\xB8\x54\x90\xAE\x5D\xBB\x7B\x86\x03\x90\xA1\x0B\x46\xA9\xE3\x96\x8D\x7A\xA4\xBE\x4B\x4C\xA9\x7A\x92\x20\x8F\xA9\x54\x6B\x2B\x99\x8A\x58\x02\x54\xA9\xCF\x51\xA5\xAD\xA0\x78\x79\x96\xAF\x7E\x5B\xA9\x33\xA0\x4D\x6E\xA5\xA0\x67\x5B\xA8\x0E\xA1\xAA\x55\x8D\x66\x6E\x6A\x5B\xA5\xBE\xA0\xCC\x84\x2C\x03\xA6\xBD\x65\x5B\xAB\x10\xAC\x1A\xB6\x02\x6F\xA9\x41\x4B\xA5\x89\xA1\xA1\x68\x2F\x05\xA7\xB6\x46\x5B\xAB\x13\xA6\x4F\x82\x03\x7B\xAA\x82\x4B\xA5\x95\xA1\x03\x64\x32\x01\xA8\xBC\x54\x5B\xAA\x88\x96\x4F\x8E\x03\x87\xAA\x6A\x55\xC5\x46\x04\x5B\xAB\xBB\x54\x0D\x2E\x5E\xB8\x8F\x40\x00\x0B\x71\xA8\xAC\x84\xDA\x84\xCE\x7C\x54\x8F\x80\x55\xA1\x0E\x96\x03\x94\xA9\x2C\x45\x68\x86\xA0\xF1\x89\x8F\xA2\xAA\xBA\x4A\xA9\x63\x36\x0D\xA8\x88\x55\x85\x98\x98\x26\x4F\xA1\x03\xAB\xA8\x6E\x55\x68\x9B\xA0\x50\xA1\xAC\xAF\xFC\x05\x9A\x82\x2A\x15\xA6\xAB\x83\x3C\x85\x9B\x09\xAB\x85\xBB\xAA\x0C\x8E\x41\x05\x5F\xA1\x83\xF9\x00\xB0\xAA\x76\x98\x2A\x81\x8E\xB1\xA1\x9A\xB9", + "\x2A\xD0\x69\x01\x06\x1D\x04\xA9\xB7\xA8\xC2\x21\x0E\x8B\x00\xCF\xAB\xA9\xAB\x60\xBF\x73\xD5\xAA\xBF\x45\x68\xB8\xA9\xCC\x87\x05\x09\xAD\xA4\x59\x85\x9A\x9F\xAD\x69\x9D\x00\xDF\xA9\xCF\x55\x68\x84\xAA\x60\x81\xB9\xAF\x7E\x45\x9A\x8A\xA9\xA7\x99\x02\x2A\xAB\xE0\x66\x01\x94\xFE\x43\x64\x2F\x02\x75\x08\x38\x42\x01\x8C\x06\xCB\x37\xC7\x46\x04\x7E\x70\xB4\x61\x03\x05\x92\x05\x47\xBE\xA3\x10\x1D\x72\xD0\x6A\x0C\x00\xB0\xB6\x46\xFD\xAA\x25\x83\x43\xB6\xAB\x56\x85\xBE\xA2\x0C\x4C\x04\x09\xAF\x0E\x97\xB0\x8A\x48\x84\x72\x41\x04\xB0\xBB\x7B\x36\x03\xC4\xAC\x53\x4A\x72\x5D\xA7\xBE\x77\x03\x0C\xAC\x15\x50\x63\x0E\x1D\x1C\xAC\x65\xA7\xBE\x79\x03\x20\xAC\x43\x92\xC8\xAC\x10\x24\xAC\x6D\xA4\x2E\x88\xB2\xA9\x50\x30\xAA\x41\x0C\xB2\xB5\xA5\xAC\x85\x0F\x0F\xB2\x88\x3F\x31\xAF\x40\x03\xB3\xBC\xA5\xC8\x83\xCD\xA1\x10\x3A\x01\x39\xAE\x40\x0B\xB3\x83\xA6\xD0\x69\x10\x0E\xB3\x91\x6B\x41\xAD\x40\x03\xB4\x89\xA6\xEF\x5B\x10\x07\xB4\x96\x02\x2A\xAD\x42\x03\xB4\xA3\x94\x9D\x99\x11\x07\xB4\xA3\x02\x49\xAC\x00\x03\xB4\xAD\xA2\xA1\x6B\x11", + "\x07\xB4\xB1\x02\x59\xAF\xD0\xA3\x76\x8C\x6F\x47\xAF\x2F\x01\xB6\x81\xAB\xE1\x83\x12\x07\xB4\x8D\x03\x67\xAD\x42\x09\x9A\x9F\x99\x06\x05\x13\x07\xB4\x9B\x03\x6D\xAE\x41\x09\x77\x83\x64\x4F\x03\xD1\xA9\x0E\x35\xAD\x77\x8A\xB9\x97\xB4\xB7\x03\x37\xAB\xCA\xAC\x69\xAE\x9B\x47\xAE\x01\x0E\x18\x3B\x06\x43\xAE\x71\xAD\x69\x95\x01\x47\xAC\x05\x0E\x18\x23\xAC\xCD\xA5\xA7\x98\x3A\xA3\x5B\x21\x02\x63\x0D\x1B\x03\xAD\xB1\x99\xA7\x99\x05\x07\xAD\x30\x03\xE1\xA2\xB8\xB9\x81\xA5\x93\xD1\xAE\x03\x1E\xAE\x52\xAE\x78\xA0\xAD\x5D\x01\x47\xAC\x13\x06\xB9\x9F\xAE\xE8\xA7\xBE\x7F\x05\x07\xAD\x5B\x00\xE9\xA2\xB3\xAF\xA7\xF6\x91\x18\x07\xB4\xA9\x01\xB2\xAE\xCE\xA6\x9F\xBB\x7B\x63\x03\xD1\xA7\x07\x2B\xAE\xA5\xAF\x63\x9E\x8E\x8B\x79\x47\xAE\x21\x00\xBC\xB3\xAE\x23\xA7\xBE\x76\x42\xAB\xA7\xC7\xAE\xEE\xAB\xA0\xAC\x86\x49\x93\xB8\x54\x0A\x0D\xAF\x42\xAD\xF6\x9C\x1A\x97\x91\xE3\x5B\x2C\x09\xBB\x95\xAF\xFB\x98\xB4\x64\x48\xA3\x5B\xC1\x03\xF6\xAA\xB4\x9E\xA8\x54\x9F\xD1\xAF\x0C\x22\xAF\x5A\xAC\x89\xAC\x1A\xB1\x01\x47\xAD\x37\x08\xBE\x83\xAD", + "\x7B\x92\x3D\x93\x07\x07\xAD\xEB\x03\xFB\xA0\x48\x90\x6B\x75\x03\xD1\xA9\x0F\x14\xAF\x01\x05\x24\x7F\x48\xA9\x62\x77\x02\x75\x09\x60\x86\x04\xFE\xAF\x25\x99\x8A\x7C\x01\xD6\x06\xF1\x56\x1B\x45\xB0\x02\x06\xAB\xAD\x69\x83\x02\x09\xB3\x94\x5C\x10\x34\xAA\xF6\x92\x22\x01\xC1\xBE\x4B\x0C\xB2\x94\xAC\x1A\x91\x02\x17\xB0\x99\x59\xC1\xAE\x97\x57\xA9\x07\xBD\x73\x5F\xB0\xC3\xA8\x6B\x8F\x09\x22\xB0\xEF\x5F\x07\xB1\xA6\xA1\x6A\xA6\x00\x0A\xB0\x9E\x5F\xB0\x66\xA8\x73\x8D\x0A\x2E\xB0\x7D\x67\x07\xBC\xA6\xB0\xAD\xEF\x18\x0D\xB5\x10\x5F\xB0\x72\xAA\x3D\x9B\x0B\x3A\xB0\x0B\xB1\x84\x93\x90\x42\x03\x40\xB2\x82\x4F\xC1\xA2\xAB\xBB\x71\x11\xBC\x53\x5F\xB0\xE8\xA8\x73\x80\x0D\x0A\xB1\xAA\x57\x07\xBD\xAE\xAF\x5B\xD7\x00\x14\xB8\x54\x57\x72\x04\xB1\x2A\x6E\x0D\x1A\xAC\xAA\x57\xC5\xAE\xBC\xA1\x7D\x5C\xB0\x52\x53\xCA\x5D\xAC\xE1\x80\x38\x07\xB4\x88\x00\x90\x06\x77\x03\xC6\xA5\xAC\xE1\x82\x38\x07\xB4\x95\x00\x69\xB0\x43\x0B\xC6\xAD\xAC\xFB\x78\x39\x07\xB4\xA2\x00\x90\x07\x6E\x03\xC7\xB4\xAC\xF6\x92\x39\x0C\xB9\xB9\xB1\x72\xB2\xCF\x9B", + "\xEF\x68\x03\xA2\xAC\x20\xB9\x10\x3B\xB1\xF7\x2C\xB4\x6A\x0E\x29\xAE\x86\xB2\x41\x08\xC8\xA2\x3F\xCE\x65\x18\xB8\x5B\x4F\xB2\x4C\xAF\x40\x6D\x0E\x07\xAD\x5A\x01\x1C\xB7\xC8\x90\xA6\xF6\x93\x3B\x07\xB4\xA7\x01\x8D\xB0\xB7\x46\x99\xA4\x7E\x47\xAD\x1D\x01\xCA\x82\x04\x8F\xB3\xD8\xA3\x90\x73\x03\x47\xAF\x20\x07\xCA\x81\x04\x8F\xB1\x2F\xA3\x90\x75\x03\x47\xAD\x24\x0F\xCA\x80\x00\x8F\xB3\xDB\xAD\x41\x86\x39\x47\xAF\x27\x07\xCB\x8F\xB2\x77\xAD\xA8\x69\x0F\x07\xAD\xAD\x03\x2F\xBE\x77\xAC\x86\xFB\x03\xD1\xAB\x0B\x10\x06\xBD\x07\x23\xBE\x9B\xBE\x4B\xFD\x03\xD1\xAA\x0C\x06\xB3\x8D\x9F\xF5\x77\xB4\x98\x03\x9A\xB2\x23\xB1\xB9\xAF\x5B\x01\x00\x76\x08\x38\x65\x03\xCC\xB1\x20\xB4\x9D\x90\x6B\x03\x02\x37\xB0\xE1\x14\xB3\xA1\x9D\x2A\x6E\x53\xA3\x5B\x02\x02\x74\x0A\xC7\xA6\xAE\x0D\x9A\x39\xB9\x12\x12\x07\xCD\xB1\x42\xA1\x0E\x89\x00\xF2\xB2\x41\x0F\x01\x2E\xB3\xE2\xB2\x7E\x8B\xEF\x4B\x00\xF9\xB0\xA2\x1C\xCF\x9B\xB2\x15\xA7\xBE\x7D\x00\x01\xB4\x02\x07\x0E\x04\xCF\xBD\xB3\x9E\x81\x03\x88\xD0\x87\x8A\x0B\xB4\x41\xB7\x59\x97\x98\x0F", + "\xB4\xDC\x91\xD1\x9A\xB3\xCF\xAE\x3D\x96\x54\xA3\x5B\x68\x03\x45\xB2\xCA\x92\xA8\xD0\x69\x05\x05\xD1\xB7\x01\x03\xB4\x46\xBE\x0B\xA9\x62\x17\x01\x45\xB5\x08\x25\xB4\x1F\xB6\xE3\x80\xAD\x59\x00\x15\xB7\x24\x0C\xD2\xA8\xB2\xEA\xAE\x3D\x9B\x01\x15\xB4\xA1\x03\x4C\xB0\xCB\xB6\x9F\xFB\x79\x07\x05\xD1\xAF\x02\x3A\xB4\x2E\xB7\xBF\x90\x81\x15\xB5\x2F\x0E\xD1\x82\x04\xA9\x70\x1C\xA0\xAD\x4D\x95\xE3\x58\x33\x02\x1D\x1E\x07\x49\xB4\x1E\xA0\xAD\x63\x00\x15\xB5\x36\x0F\xD4\x8C\x04\x51\xB4\x20\xA0\xAD\x65\x00\x15\xB6\x39\x01\xD4\x99\xB5\x88\xA2\x3D\x97\x02\x15\xB4\xF4\x03\x57\xB2\xC8\xA1\x83\x29\x01\x45\xB2\x00\x22\x13\xBB\x04\x58\xB4\xB4\xBB\x7B\x2B\x01\x45\xB0\x01\x2C\xB5\x58\xB4\xC7\x73\x42\x95\xB4\x1E\x02\x38\x10\xD5\x9C\xB2\x9D\x9B\x0B\x05\xD1\xAB\x00\x74\xB5\x42\x0E\xD6\x9C\xAD\xCC\x85\x0C\x05\xD1\xB9\x00\x81\xB6\x41\x0E\xD6\xAA\xB2\xA1\x6B\x0C\x05\xD1\x87\x01\x89\xB7\x40\x0E\xD6\xB2\xB2\xA1\x69\x0D\x05\xD1\x95\x01\x91\xB4\x52\xBB\x68\x80\x91\x15\xB7\x18\x09\xD9\x81\x04\x6E\xB5\x30\xBC\x1C\xB9\x00\x15\xB5\x1C\x0F\xD9", + "\x80\x00\x6E\xB5\x35\xA1\xAA\x7B\x00\x15\xB7\x1F\x02\x4E\x3D\x06\x6E\xB7\x33\xB4\x66\x7D\x00\x15\xB6\x23\x07\xDA\xAE\xB5\x8A\xAF\xBB\x5F\x03\x15\xB4\x9C\x02\x5E\xB5\xD7\xAD\xA3\x45\xAD\x45\xB9\x0A\x2F\xB6\xBF\xB4\x3D\xA1\x0E\x83\x01\x15\xB4\x2E\x07\xDB\xBB\xA3\xBA\x99\x45\xB6\x0C\x0B\xB7\xC0\x99\x38\x87\x04\x15\xB4\xD4\x00\x71\xB2\xD8\xB6\xB3\x7C\x91\x45\xB3\x0E\x10\xB7\xFE\xB1\xDA\xA5\xD1\xB1\x03\xDC\xB5\xEF\x9A\x48\x95\xB4\xFF\x02\x75\xBA\xD8\xBD\xA7\xF6\x93\x13\x05\xD1\x8E\x00\x81\x10\x6C\xB4\xA0\x90\x6B\x51\x01\x45\xBD\x01\x2D\xB7\xC5\xB6\xEA\x79\x8A\x53\x01\x15\xB4\x0B\x04\xDF\x97\xB7\x20\xB5\xBD\x95\xD1\xBB\x00\x81\x11\x5B\xB8\x93\xB6\x93\x57\x01\x45\xB9\x04\x01\xB8\xF5\xB7\x4F\xA9\x8A\x59\x01\x15\xB7\x15\x08\xE0\xBC\xB7\x95\x8D\x38\x8B\x05\x15\xB4\x65\x03\x83\xB7\xDE\x8E\xA5\xAC\x85\x17\x05\xD1\xB3\x01\x16\xBA\x64\xB3\xD4\xA1\x83\x5F\x01\x45\xB1\x08\x3B\xB7\x06\x07\x2B\x7A\xA3\xA1\x83\x61\x00\x76\x0E\xA3\x8C\x04\x26\xB9\x90\xA0\xAD\x65\x01\xD8\x04\xB4\xA3\xF0\x2D\xB8\x47\xA9\x38\x8B\x06\x31\xB8\xB1\x40", + "\x8D\xBD\xA4\xBB\x7B\x71\x00\x8E\xBE\x2F\x7A\xB8\x1A\xB2\x3D\x97\x07\x3E\xB8\x64\x58\x90\xB0\xC2\x90\x6B\x7D\x00\x91\xBD\x73\x46\xB9\x25\xB2\x3D\x93\x08\x0A\xB9\xEF\x5E\x91\xBB\xC2\x8C\x87\x89\x00\x94\xB0\x9E\x46\xB9\x31\xB0\x0E\xBF\x4A\x56\xB9\x7D\x66\x91\xB7\xC3\xBB\xB2\x06\x05\x25\x0C\xE5\x85\x44\x46\xB9\x0F\xBD\x69\x9B\x02\x63\xBA\x6D\x46\xE4\x9C\xAB\x5A\xB9\x52\x49\xE6\x8A\x48\x46\xB8\x12\xB3\x90\x67\x02\x6F\xB8\x4F\x56\xE4\x8D\xB1\x6D\xB9\x48\x15\xE7\xAA\x56\x46\xBB\x14\xB3\x90\x73\x02\x7B\xB8\x52\x5C\xD9\x57\xB8\xFB\x79\x2E\x08\x1D\x15\xAA\x02\x07\xA0\xB3\x10\x06\xB9\xEF\x5A\x2E\x07\xE8\xB1\x42\xA4\x77\x00\x49\x8A\x7B\x02\x8F\xBA\xBF\x41\xE9\x95\x05\xC3\xAD\xD2\x15\xD1\x90\x02\x81\x10\xE2\x47\xE9\x8A\x5A\x99\xBA\x40\x0E\x0B\x15\xB4\x92\x01\x20\x16\x0F\x5F\xBA\x42\xAD\xA8\xB1\x10\x00\x03\x15\xB5\x25\x06\xEA\xA3\x76\x0C\x07\x1C\x0A\xEA\x83\x2A\x15\xB4\x26\x0F\xEA\x89\x04\xA8\xB8\x11\x53\xEB\x84\x03\x15\xB7\x26\x07\xEB\x86\x04\xB9\xB8\x00\x0E\x03\x33\xBA\xC6\x01\x45\xBE\x09\x3F\xBA\x03\x05\xB0\xB3\xAA\x50", + "\x6B\xC8\x00\x4E\xB8\xEC\x82\x04\xC1\xBB\xAB\x60\xAD\x4A\x03\x15\xB4\x29\x0F\xEC\x81\x04\xC1\xBA\x2A\x03\xEB\x8C\x03\x15\xB7\x29\x07\xED\xBD\x50\x0C\x04\x2C\x03\xEB\xA3\x96\xE3\x5A\x2A\x0F\xED\x81\xBB\x37\x7F\xBE\x70\x0D\x15\xB4\xAD\x03\xB9\xBA\x23\xB3\xBA\xD2\x01\x45\xB0\x0B\x2E\xBB\x09\x04\x37\x03\xEB\x94\x03\x15\xB7\x2C\x04\xEF\xA3\x75\xB3\xBA\x35\x05\xD1\xB6\x02\xFB\xBA\x78\xBB\xEF\x58\x03\x15\xB5\x2E\x01\xF0\x82\x04\x5D\x03\xAC\xBA\x0D\x15\xB4\xBC\x03\xC1\xB1\x10\x1E\x03\xB3\xB8\x37\x05\xD1\xBF\x02\x0E\xBC\x00\x0E\x6D\xB6\x93\xDE\x01\x45\xB2\x0C\x15\xBC\xDD\x03\xAC\xB0\x0E\x15\xB4\xC5\x01\xC5\xB5\x01\x33\xBA\xE2\x01\x45\xB8\x0C\x15\xBC\x48\x6C\xB4\x64\x0E\x15\xB4\xCB\x03\xB7\xBC\xDA\x43\x04\x73\x01\x2A\x66\x0E\x15\xBA\x64\x5B\xCB\xB6\x1B\x33\xBA\xE7\x01\x45\xBE\x0C\x1D\xBA\x53\x46\xF3\x73\xEB\xA9\x03\x15\xB4\x34\x0E\xF2\xAB\xAC\xB3\xBA\x6C\x93\x6E\x53\x03\x43\xBF\x00\x43\xEB\xAD\x03\x15\xB6\x35\x09\xF4\x9A\x87\x9D\x7D\x55\xBF\xF4\x83\x04\xC3\xB8\xB4\x61\x0F\x15\xB4\xDC\x03\xD4\xBD\x19\xB3\xBA\xF3\x01\x45", + "\xBF\x0D\x1A\xBD\x3F\xAF\xAC\xB5\x0F\x15\xB4\xE2\x00\xD8\xB0\x6F\x73\xBA\xF7\x01\x45\xB5\x0E\x26\xBD\xE2\xB8\xB4\x68\x5B\xA3\x5B\xE8\x02\xD9\xB9\xEE\xAB\xA1\x15\xB7\x3A\x06\xF6\x90\x01\xB3\xB9\x3F\x05\xD1\xAE\x03\x66\xBE\xBD\xB1\x38\x9F\xB7\x66\xBF\x11\x03\xEB\x81\x00\xDA\x04\xE2\x44\x0F\x26\xBD\x45\x91\xA7\x93\x00\x05\xBE\x48\x3A\xD9\xB9\xF0\x8D\xAB\x8C\xBF\x95\x36\xF6\x90\xBC\x9D\x8D\xE4\xBF\xE9\x26\xBD\x17\xBD\xA7\x99\x00\x16\xBE\x06\x07\xB1\x66\x0F\x76\xBC\x64\x33\xAC\xBB\x00\x1C\xBE\xEB\x42\xE7\xBD\xF3\x91\x07\xB3\xB9\x03\x04\xFA\xA9\x5A\xA6\xBF\x6A\x7E\xC8\x33\xBA\x0F\x03\xEA\xB6\x20\x2D\xBE\xB4\x77\x89\xBC\x1A\x91\x00\xDA\x07\x8A\xB2\xE9\x8D\xA0\x21\xB6\x76\x02\xE3\xB1\xBA\x9E\x93\xBE\x7B\x01\x3E\xBE\xB1\x41\xCC\xB9\x10\x14\xB0\x9D\x99\x08\x04\xFC\xBE\x4B\xC6\xBE\x9F\x29\x8A\x67\x00\xCB\xBC\x99\x5D\xFC\x8D\x54\xA9\x61\x0B\x01\xFD\xBD\x5C\xD3\xBE\x40\x0D\xE4\x9D\x9A\x33\x03\xF5\xBF\x7E\x59\xBF\xA6\x28\x2C\x8E\xFD\xA0\x67\xE0\xBC\x00\x09\xE5\xA0\xB9\x03\x07\x8F\x99\xA6\x88\x55\xE5\xBF\x97\xB2\x55\x86\x04", + "\x45\x03\xF8\xBD\x97\x65\xBF\x66\xB8\x3C\x82\xFF\x85\x44\xE5\xBC\x9B\xB8\xFE\x99\x91\xF7\xBE\x6D\x45\xFE\xB2\xB9\xA1\x6B\x15\x0D\xFF\x8A\x48\xE5\xBC\x9E\xBB\xFF\x81\x04\x5D\x03\x00\xCC\x53\x65\xBF\x7E\xB9\xA8\x63\x06\x0A\xC0\xAA\x54\xD5\xA4\xAA\x90\xAF\xB9\xBD\x2C\x44\xB5\x98\x97\xAC\x85\x1B\x00\x01\xC8\x55\x54\xAE\x03\xBF\x6E\x73\x01\x1B\xC0\x6E\x54\xB5\x88\xBF\xCA\x91\x08\xCF\xFC\x14\xAD\xB9\xAB\x40\x6F\x07\x26\xC0\xC4\x92\x95\xA0\xAD\x45\x02\x2C\xC0\x5F\xBB\xFD\xAF\x5B\x8B\x01\x0C\xC3\x75\x9C\x2A\xCC\x9E\x0D\xC6\x10\x14\xAD\xE7\xBF\xFB\xB3\x10\x17\x02\x3A\xC2\x6E\x72\xAD\xAC\x86\x9D\x01\x10\xC9\x3E\x8C\x04\xF5\xBF\x40\x63\x0A\x06\xC1\x01\x04\xD5\xAA\xFF\xBE\xC0\x02\x05\x2A\x0C\x04\xE5\x59\x48\x2D\x2A\x6F\x0A\x13\xC1\x54\xAE\x01\xC0\x05\xC1\x04\xB5\x00\x16\xCA\x85\x9D\x9A\x89\x9B\xFA\xB8\x5B\x42\x77\x64\xB2\xA9\x82\xFB\x8C\x00\xC7\x6A\x77\x04\x06\xEC\xB1\xAC\x87\x30\x02\xFB\x99\x00\x69\xC0\x43\x0B\x06\xF4\xB1\x91\x96\xEC\xB6\x02\x07\x6B\xBB\x07\x1C\xCC\xC7\x9D\x9A\xC7\x02\xEC\xB4\x03\x38\xC1\x72\xC3\x59\xBC", + "\x1A\x8F\x9A\xE3\x5A\x10\x00\x08\xC9\x04\x7A\xC1\x22\xBB\xEF\x4B\x03\xB2\xBC\x14\x07\x08\xE1\x40\x76\xB7\x6B\x92\xFB\x9E\x01\x71\xC0\x22\xCC\xD7\xAF\x5B\xCF\x02\xEC\xBB\x06\x0F\xC2\x03\x05\x22\xCB\x75\x90\x6B\xD1\x02\xEC\xB9\x07\x1C\xC2\xC1\x75\x2D\xA1\x0E\x93\x03\xB2\xBF\x21\x04\x0A\xC1\x04\x9E\xC0\x65\xBC\x1C\x95\x03\xB2\xBD\x25\x0B\x0A\xC0\x00\x9E\xC2\x2E\xBB\x05\xC0\x00\x94\x9B\xB8\x53\x0A\x33\xC2\x9E\xC2\x68\xB9\xE7\x99\x03\xB2\xBD\x2C\x0C\x0B\xC7\xB3\xF6\x93\x36\x02\xFB\xBF\x02\xC7\x69\x6F\x0E\x09\xF2\xB6\x3D\x5D\x37\x02\xFB\x8E\x03\xC3\xC1\x35\xB1\x0E\x9F\x03\xB2\xBC\x37\x05\x09\xD0\xC2\xC0\xB7\xBE\x71\x0E\x32\xBE\xE9\x01\x32\xC1\x08\xE3\xB3\x6F\x7E\xEC\xB8\x0F\x11\xC3\xE9\xB0\xB4\x69\x69\xA3\x5B\x06\x03\xBE\x61\x53\x1E\xC2\x02\xA4\x71\x62\xFB\x94\x00\xEA\xC1\x34\x1E\x09\xFA\x90\xAC\x85\x3A\x02\xFB\xA3\x00\xF1\xC1\x52\x1E\x09\xDD\xAA\xAC\x87\x3A\x02\xFB\xB1\x00\xF9\xC1\x1E\xCB\xBB\xA1\x83\xED\x02\xEC\xBF\x03\x39\xC3\xCA\xC0\x7A\xBD\x69\xAF\x03\xB2\xBE\x13\x08\x10\xDF\xC3\x13\xB4\x6B\x81\x0F\x32\xBE\x5D", + "\x03\x43\xC6\x09\xD9\xB4\x9D\x9B\x3C\x02\xFB\xAC\x01\x16\xC4\x36\xC6\x5A\xB4\x7E\xB2\xBF\x1E\x01\x10\xD0\xC4\xE0\x9D\x2A\x67\x0F\x32\xBE\x89\x03\x48\xC7\x11\xEE\xB4\xFB\x79\x3E\x02\xFB\x97\x02\x2A\xC6\x47\xCF\xEC\x50\x6B\xFB\x02\xEC\xB5\x0A\x31\xC4\x9D\xC0\x4F\xB1\x0E\xBD\x03\xB2\xBF\x2C\x08\x13\xE5\xC2\xA3\x8D\xE0\x82\xFB\x81\x03\x1D\xC7\x40\x08\xDC\x65\xC1\xF6\x91\x00\x0C\x1D\x08\x4E\xD0\x01\x3E\xCE\x1D\x07\xC5\x6C\xC2\x3D\x93\x00\x0B\xC5\x51\x32\x53\xCC\x10\x10\xC5\x74\xC0\x6B\x85\x00\x14\xC5\xAE\x33\x4F\xC7\xDC\x47\x97\xAC\x87\x01\x0C\x15\xC6\x04\xF8\x02\x57\xC2\xAA\x42\xC2\xF6\x91\x02\x03\x16\xED\x5B\xF9\x69\x52\x18\x15\xC5\x9D\xD3\xAB\x5A\xCA\x17\x2D\xC5\xBB\x07\x5B\xCC\x74\x90\x6B\x0D\x02\x5C\xC1\x10\x22\x00\x6D\xC7\x53\xC7\x09\xC3\x64\xAD\x9B\xB8\x5F\x02\x34\xC5\x57\xC7\x28\xB7\x61\xBA\xC5\xC6\x8C\x61\xC9\x10\x36\xC5\xF8\x8D\x2A\x63\x01\x08\xC6\x4B\x02\x62\xCA\x02\x68\xAD\xD0\x8C\x62\xC9\x05\x12\xC6\x46\xC7\x66\xBB\xEF\x57\x00\x88\xC7\x19\x08\x19\xDD\x86\xB0\xA6\xF7\x88\x18\xF5\x01\x9F\xC7\x57\xC7\x9B", + "\x82\xBF\x88\xC7\x20\x0D\x16\xFD\x06\x8C\xC4\x33\xCF\x7E\x5D\x00\x88\xC6\x24\x05\x1A\xE7\xC5\xD2\xC0\x6B\x8F\x01\x08\xC6\xA0\x01\x5F\xC5\x18\xD9\xC3\xE1\x81\x08\x08\x18\xED\x02\xAB\xC7\x6E\xC6\xDC\xAC\x86\x23\x00\x62\xCC\x0B\x33\xC6\x8C\xC7\x76\xAD\x69\xA5\x00\x88\xC6\x32\x08\x1C\xF0\xB3\x4E\x98\x62\xC8\x0D\x01\xC7\x8B\xC4\x76\xB6\x4F\xA9\x00\x88\xC7\x39\x0F\x1C\xCE\x9B\x70\xB4\x62\xC5\x0F\x1B\xC7\x96\x83\xAC\xBD\x02\x08\xC6\x03\x00\x1E\x6C\x1A\xCA\xC4\xEF\x5B\x0B\x08\x18\xD2\x00\xE6\xC6\x70\xC3\x10\x13\x91\x03\x65\x0C\x08\x18\xE1\x00\xED\xC5\x75\xC8\x11\xEF\x5B\x33\x00\x62\xC0\x03\x35\xC7\x93\xC5\x7F\xBB\x43\x88\xC6\x3F\x00\x1E\x65\x17\xC3\xB8\x9D\x9B\x0D\x08\x18\xCD\x01\x02\xCA\x7B\xCA\xE0\x90\x6B\x39\x00\x62\xCB\x05\x09\xC8\xF6\xC5\x84\xBC\x1A\xBB\x00\x88\xC5\x1A\x00\x21\xFD\xC7\x2B\xA8\xB4\x6D\x03\x08\xC6\x77\x03\x85\xC9\x19\xC1\xC5\xFB\x7B\x0F\x08\x18\xC5\x02\xFC\xC7\x40\x0E\xDC\x76\xBE\xF6\x91\x10\x0C\x1D\x07\x08\x05\x47\x89\xCE\xE2\xBB\x7B\x4A\x00\x77\x00\x29\x88\x55\x2E\xC9\x8D\xBC\x1A\x95\x01\x32\xC9", + "\x2C\x45\x23\xFB\xB8\xE1\x80\x18\x09\x23\xFE\x4B\x3B\xC9\x90\xBD\x69\xAB\x01\x3F\xC8\x99\x51\x24\xC7\xB9\xFB\x7A\x1D\x05\x24\xFD\x5C\x47\xCB\x0C\xC3\x90\x41\x02\x4B\xCB\xFB\x57\x24\xD3\xB9\x79\xB8\x23\x01\x25\xE0\x67\x47\xC9\x0F\xC7\x78\x83\x3C\x97\x03\x95\xCD\x97\x47\xC9\xEE\xBF\x96\xC7\x4E\x1E\xC9\x2D\xC8\x12\xCC\x25\xA4\xC9\xB6\x47\x91\xCF\x04\xE2\xC9\x13\x1C\x9A\xCA\x20\x47\xC9\x00\xC0\x73\x83\x0C\x2E\xC9\x3C\x57\x91\xCA\x05\xEC\xC9\xAE\x28\x9D\xCA\x5A\x47\xC9\x0D\xC0\x73\x84\x71\xB1\x61\xB6\x44\x75\x78\x22\xDD\x9A\xE4\x03\x8A\xC1\x0B\x42\xCA\x2F\xC8\x41\xCA\x27\xC8\x55\x88\xCA\x8D\xC6\x4F\xB8\x03\x8B\xC8\x6E\x5D\x28\xFC\xC8\xAC\x87\xCA\x90\x28\xCA\x48\x93\xCA\x90\xCF\x6E\x4E\x00\xB9\x07\x8C\xC2\x29\xEE\xC0\xFB\x79\x06\x0D\x29\xC7\xCA\x90\x29\x2A\x64\x02\x23\xCA\xFE\x49\xA6\xC0\x00\x14\xC9\x07\xC0\x00\x0F\x02\x28\xCA\x64\x5A\xAA\xCA\x25\xDE\xA3\x08\x88\xAC\xCD\x73\x6A\xCA\x61\xC8\xAD\xC9\x10\x05\x01\xB6\xCB\xFB\x5A\x2A\xC9\xC1\xA1\x68\x14\x0D\x2B\xE0\x67\xAA\xCB\x9A\xCA\x2B\xC6\x04\x5B\x03\xB0\xCD\x97\x6A", + "\xCA\x71\xC9\x9E\xB6\x06\x0A\xCB\x05\x46\xAA\xC7\x27\xC7\xCB\xC9\xB8\xB4\xC1\x28\xDF\xC1\xEF\x58\x1F\x06\x2D\xCA\x48\xDA\x76\x41\x0A\x2A\xEF\x5B\x87\x01\x6E\x08\xE8\x81\x04\xDD\xCA\x89\xC3\x8D\x62\xCB\xB1\x40\x78\x7F\x21\xF0\x9E\xE8\xCA\xBF\x46\xDE\x48\xC5\x9D\x9A\x22\x09\x1B\x08\x4E\x94\x00\x1E\x6E\x1D\x2F\xCB\x51\xC5\xA7\x9C\x08\x33\xCB\xE5\x12\xBD\xCF\x04\x6E\x85\xFB\x7A\x23\x0C\x2F\xF9\x18\x1E\xCA\x40\x08\x2F\xF8\x9C\xAC\x84\x24\x03\x30\xF9\x1C\x05\xCD\x40\x07\x30\xC2\x04\xDD\x8F\x39\x9B\x30\xFB\x29\x0D\xCC\x00\x0F\x30\xCA\xC2\xE1\x80\x25\x03\x31\xE5\x2F\x15\xCF\xC5\xC0\x00\x15\xB2\xA1\x6A\x25\x0B\x31\xDD\x80\xFE\xC9\x42\x0E\x31\xD4\xAD\x62\x7B\xC8\xC0\x00\x33\x03\x1D\xCE\x61\xCC\x1A\x9A\x02\x2A\xCD\x00\x03\x86\x7B\x06\x1E\xCC\x63\xBC\x1C\x9C\x02\x2A\xCF\x03\x03\x33\xFF\xCB\xC7\xAB\xBE\x7E\x09\x2A\xCC\x1D\x03\xCE\xC6\x32\xDA\xC6\xE1\x80\x28\x0A\x32\xEB\x00\x42\xCE\x41\x0E\x31\xFE\xC2\xAD\xCA\x28\x0A\x32\xF9\x00\x49\xCF\x40\x0E\x31\xEA\xB6\xCC\x84\x29\x0A\x32\xC7\x01\x63\x61\x6F\x0E\x31\xEE\xC6\xE0\x66\x29", + "\x0A\x32\xD6\x01\x51\xCE\xC1\xC8\x55\xA1\x83\xA8\x02\xCA\xC4\x06\x23\x61\xF7\xCB\x36\xB3\x90\x6A\x02\x2A\xCD\x1C\x09\x35\xFC\xCC\xC3\xC6\x3D\x9C\x0A\x2A\xCC\x80\x01\xD8\xCE\x30\xCC\xB7\xAC\x86\x2B\x0A\x32\xCE\x02\x76\xCE\xC5\xC0\x1D\xEC\x86\xB0\x02\xCA\xCC\x09\x2F\xCD\x43\xCF\xEB\x91\x0E\xB2\x02\x2A\xCF\x2A\x0D\x37\xDE\xCC\xFC\xC2\x3D\x94\x0B\x2A\xCC\xB9\x03\xE2\xC3\x10\xF3\xA9\x2A\xCF\x31\x04\x38\xCA\xCD\xE8\xC7\x40\x6B\x78\xA3\x5B\xD6\x03\xE5\xC2\x35\xEF\xB7\xFB\x7A\x2E\x0A\x32\xE5\x03\x9E\xCE\xD8\xC7\x1F\xC3\x64\xBC\x02\xCA\xC4\x0F\x25\xCE\x77\xCE\x7F\xCC\x1A\xBE\x02\x2A\xCF\x00\x09\xB5\x74\xCC\x04\xCB\xBB\x50\x0C\x2A\xCC\x11\x03\xEC\xC0\x37\xC3\x04\x40\xA7\x9F\xAA\x32\xDF\x00\xBA\xCD\xE1\xC2\x21\xF6\x93\xC4\x02\xCA\xCD\x02\x01\xCF\x98\xCC\x86\xB6\x4F\x91\x9E\xE3\x5B\x0E\x08\x3C\xDF\xCE\x20\xC9\x38\x88\x0C\x2A\xCC\x49\x01\xD6\x6D\x1B\x02\x95\x1E\xCF\xBB\x5A\x0C\x2D\xCB\x64\x5A\x50\x9E\x09\xD7\x7C\xDC\xCD\xCF\x51\x3F\x93\xC0\xF6\x90\x33\x0A\x32\xC5\x44\xF1\x8C\x06\xCB\xA8\xB9\x06\xBA\xBE\x41\x01\x3F\x9E\xC0", + "\x03\x66\x34\x0C\x3E\xF1\x42\xF1\x8C\x09\xC3\x90\x56\x03\xF3\xCE\xBF\x41\x3F\xA9\xC0\xA1\x6A\x36\x09\x3F\xE4\x59\xF1\x8E\xAF\xAD\x69\x9E\x03\xFF\xCE\xF8\xC5\x2A\xD0\x6B\x9F\x9D\xA9\x80\x9E\x71\x8F\xAC\xCB\x2D\xC6\x0E\x05\xD0\xEF\x5D\xFC\x83\x2B\xF1\x42\xEA\x00\x04\xDB\x40\xC3\xC1\xF6\x92\x3B\x06\x41\xFD\x65\xF1\x8C\xB0\xCC\x1C\xB2\x03\x1B\xD0\xFA\xC2\xC4\xA1\x6A\xF6\x01\x08\xD6\x1B\x71\x8F\xCD\xC9\xAB\xCA\x0F\x26\xD0\x0A\x49\xFC\x83\x2D\xF1\x42\xAC\x9E\x02\xDC\x41\xD8\xCB\x06\x98\x68\x0D\x3E\xC3\x04\x63\x9C\xF9\xCD\x69\x86\x00\x36\xD1\x2C\x43\x76\xAA\xCF\x9D\x9A\x02\x00\x1A\x3F\xBE\x9C\xA4\x05\xAC\x3B\x83\xD1\x3E\xD3\x04\xB9\x8A\x56\x00\x48\xD2\xBF\x43\x76\xBC\xCF\xCC\x84\x07\x0D\x44\xE4\x59\x63\x9E\x00\xDF\x6E\x62\x00\x53\xD1\x2C\x67\x40\xFB\x7B\x28\x01\x16\xDF\x7E\x63\x9D\x0D\xD0\x9E\xC4\x6B\x1E\xD1\xE0\x67\xD8\x93\x41\xFE\x4B\x34\x00\x19\xDD\x97\x63\x9D\xB9\xC9\x2C\x4A\x03\x2A\xD1\x05\x47\xD8\x9E\x41\xF9\xB9\x40\x00\x1C\xD6\x1B\x63\x9D\xC6\xCA\x8A\x56\x47\xCA\x48\x63\x9D\x0A\xD7\x0B\xCC\x01\x7B\xD0\x4F\x53", + "\x76\xAF\xD0\xFE\x4A\x14\x01\x48\xEA\x56\x63\x9D\x9F\xC9\xE7\x98\x01\x87\xD0\x52\x5C\xDF\x70\xCB\xEC\x6C\x68\x08\x38\x58\x01\x59\x6E\x77\x0F\x48\xF9\xCB\xA8\x76\x24\xD6\x04\x95\xD2\xFC\x48\xC0\xC1\x0E\xA2\x01\x9A\xD3\x6A\x7F\x3C\xC2\x04\x97\xD0\xC2\xC6\x4F\xA4\x01\xA1\xD0\x2E\x63\x4A\xC1\x04\xA5\xD0\xC4\xCE\x15\xA9\xD2\xBC\xCF\x2A\xD0\x00\x2D\xD2\x18\xCC\x6B\x88\x06\x30\xD2\x02\x04\x27\x02\x4B\xF4\xD2\x1F\xCD\x2A\x6A\x06\x38\xD2\x01\x06\x2A\x0C\x49\xF0\x51\x7F\xC5\xA8\x6C\x06\x00\xD3\x00\x03\x2D\x0B\x4B\xEE\xCC\xF6\x92\x1B\x08\x4C\xC5\x03\xCB\xD1\x11\xD1\x0E\xB0\x01\xC8\xD3\x34\x01\x4D\xCB\xAB\xE1\x82\x1C\x08\x4C\xE1\x03\xD7\xD1\x4E\x99\xDE\x48\xD3\xEF\x01\x37\xD2\x10\x0C\xCD\xB7\xC2\x1D\x08\x4C\xFD\x03\xE2\xD3\xA1\x8C\xA2\x88\xD3\x0B\x00\x44\x6D\x1B\x3C\xD2\x5C\xCD\x5F\x6A\x07\x08\xD3\x1A\x00\x44\x6B\x1B\x3C\xD2\xB9\xB7\x40\x6C\x07\x08\xD3\x28\x00\x44\x66\x49\xEA\xCD\xA1\x6A\x1F\x08\x4C\xF5\x00\xEE\xD1\x27\xD0\x0E\xE1\x83\x80\x00\x32\xD4\x04\x36\xD3\x06\xD5\x39\xCB\xEF\x42\x02\xC8\xD2\x14\x0C\x50\xC4\xD3\xD1", + "\xB4\x6B\x84\x08\x08\xD3\x60\x01\x41\xD4\x51\xED\xAE\xE1\x82\x21\x08\x4C\xEF\x01\x13\xD6\x41\x0C\x4B\xCD\xCE\x9D\x98\x22\x08\x4C\xFD\x01\x21\xD7\x40\x0C\x4B\xC9\xBE\xD9\x60\x32\xDB\x08\x1A\xD4\x22\xD5\xE6\xC1\xAA\x4C\x02\xC8\xD2\x26\x00\x53\xEA\xD4\xA0\xCD\x38\x8E\x08\x08\xD3\xA9\x03\x4D\xD4\x4A\xEA\xA4\xFB\x84\x32\xD8\x0B\x3E\xD4\xAC\xD2\xF5\xA6\x4F\x92\x02\xC8\xD3\x31\x09\x52\xFF\xD4\xDD\xAE\x82\x88\x4C\xD5\x03\x4B\xD5\x51\xD8\x7E\xA1\x83\x96\x00\x32\xD3\x0E\x11\xD5\xB3\xD1\x4D\xBD\x69\x98\x02\xC8\xD1\x3C\x08\x55\xFC\xD2\xF1\xAD\xA7\x9A\x09\x08\xD3\xFF\x03\x57\xDF\xE1\xAC\x86\x9C\x00\x32\xDD\x00\x02\x6F\xBD\x07\x80\x7F\xBF\xB8\x79\xA0\x04\x25\x98\x5B\x6E\xD5\x06\xB0\xB4\x61\x0A\x20\x06\x03\xB3\x40\x04\x57\xCD\xB0\x43\x88\x5E\xD1\x0B\x7B\xD5\x01\x06\xFD\xC1\xAA\x42\xA0\xB3\x93\xFB\x50\x58\xC5\x2A\xD0\x68\x2C\x0E\x57\xFE\x4B\x87\xD6\x15\xD3\x90\x75\x02\x8B\xD5\x04\x7B\x45\xE1\x83\x74\xA1\x61\xD0\x9E\x47\xD6\x61\xD0\xB5\xC2\x10\x3F\x02\x91\xD5\xCF\x57\x58\xE7\xD1\x64\x58\x31\x0D\x59\xC6\xD6\x18\xD1\xA7\x99\x0C", + "\x23\xD6\x97\xD6\x99\xC0\xAD\x4E\x03\xA8\xD5\x5F\x67\x58\xF9\xD1\xFE\x4B\x34\x0D\x5A\xC5\x44\x87\xD6\x1F\xD2\x46\xE5\x2F\xB3\xD6\x6D\x47\x58\xC4\xD2\x64\x59\x37\x09\x5B\xCA\x48\x87\xD6\x22\xDD\x2A\xCD\xA2\x96\xD5\x5F\x68\x16\x49\x04\x87\xD4\x71\x60\x1A\x23\xCB\xCD\x85\x43\xD1\x0E\xA8\x03\xCB\xD5\x2C\x43\x08\x02\x71\x03\x65\x3A\x08\x4C\xDC\x00\xC2\x6E\xCB\x33\x5D\xE6\x38\xFB\x7B\x3A\x08\x4C\xDD\x00\xD9\xD4\x43\x0B\x5D\xCE\x49\xA9\x61\x3B\x08\x4C\xDE\x00\xE1\xD5\x42\x03\x5E\xCE\x35\x4B\x8C\x32\xDF\x01\x29\xD7\x06\x07\x7A\xD8\x4A\x2F\x5B\xF1\x00\x32\xD0\x02\x30\xD7\x03\x06\x7C\xD6\x4B\x2F\x5B\xF3\x00\x32\xD1\x02\x38\xD7\x02\x06\x7E\xDA\xB4\x74\x7E\xC8\xD2\x08\x00\x60\xC1\x04\x02\xD9\xA2\x83\x90\x77\x03\xC8\xD3\x08\x07\x60\xC0\x00\x02\xDA\xA7\xC7\x5B\xC1\x04\xF9\x00\x32\xD4\x02\x0F\xD8\x02\xD8\xA6\x83\x90\x7B\x03\xC8\xD1\x09\x08\x61\xDD\x8A\xA9\x61\x3F\x08\x4C\xE6\x00\x1F\xDA\x0C\xDF\x6E\x7F\x03\xC8\xD3\x09\x05\x62\xEB\x8A\xFB\x79\x00\x02\x1A\x08\x4E\x28\x03\x8A\xD0\x2B\x83\x64\x03\x03\x8B\xD9\x3F\x72\xD8\xB5\x89", + "\xB3\xA6\x63\xFE\x3B\x38\xDB\xAE\x8D\x39\xBB\xD8\x35\x1B\x83\xD4\x08\x05\xA0\xA4\x8E\x68\x02\x57\xCF\x3F\x43\xD8\xEF\xBB\xEF\x4C\x00\xA2\x05\x5E\xD6\x8C\x41\xBF\x17\x99\x93\xD1\x0B\x49\xD9\xA0\x97\x12\xD2\x65\xFE\x4B\x54\xDB\x9E\x2A\xD0\x57\xD9\x64\x59\x96\xD2\x10\x0E\xD6\xA1\x68\x08\x0C\x65\xFD\x5C\x5E\xD9\x40\x0E\x24\xE1\x6A\x25\x03\x98\xDF\x7E\x65\xD9\xAB\xC9\x2A\x6A\x02\x2A\xD9\xE0\x64\x9B\xD0\x5A\xC3\x76\x70\xD9\x5F\x6C\x66\xED\xD1\x68\xD1\x9D\xD5\x10\x6C\xD9\x73\xD1\xAB\xC9\x03\x3A\xD9\xB6\x44\x9B\xD0\x5B\xE4\x59\x3E\x00\xA0\xDA\x20\x6C\xD9\xB6\xD6\x66\xD9\x0D\x86\xDA\x3C\x54\x9B\xDC\x5B\xFD\x5C\x48\x00\xA3\xDA\x5A\x6C\xD9\xC2\xD7\x2D\xCD\x04\x12\xDA\x48\x55\x5B\x49\x10\x2C\xD9\xEF\x5A\x14\x02\x1A\x0C\xD7\x99\xAE\x80\xDE\x6E\x9F\xDA\xB1\x41\xC4\xCF\xF0\xA9\x62\x54\x00\x90\xD8\x69\x02\x6F\xBB\x06\xA9\xD0\x00\x27\x9C\x03\x66\x15\x0A\x6A\xE7\x83\xAC\xD8\x5A\xC6\x48\xA9\x62\x58\x03\xAC\xD1\x10\x08\x01\x6C\xD6\xAD\xDB\x4E\xAF\x5B\x5A\x02\xAE\xD0\x00\x17\x01\xBD\xD8\x03\x84\x49\x69\x62\x5C\x02\xB0\xD6\x06\x05", + "\xDB\xC7\xD9\x42\x0B\x08\x01\x85\xA4\xDA\xBF\x4E\x6A\xDE\x99\xAD\xC9\x34\xA3\x6E\x75\x01\xCC\xDB\x40\x0E\x6A\xE0\xCC\xCC\x85\x18\x02\x6C\xC4\x02\xB5\xDA\xB1\xD2\x04\xD0\x6B\x63\x02\xB0\xD2\x09\x19\xDB\xAE\xD1\x42\x04\xD8\xB9\xB9\x65\x02\xB0\xD1\x0A\x28\xDB\x3C\xAD\x1D\x59\x8A\x67\x01\xC2\xD8\x2C\x00\x6F\xD0\xA2\xD8\xD0\xF4\xA2\x6C\xFF\x02\xF7\xDA\xAB\xD6\x0B\xD3\xD8\x00\x03\x1A\x02\x6C\xCE\x03\xFD\xD9\x68\xC9\x01\xC2\xDB\xDD\x01\xC1\xD7\x1A\xE1\x83\x6F\x02\xB0\xDC\x0E\x02\x6F\xBF\x06\xAB\xD1\x4F\xC5\x44\x71\x02\xB0\xDC\x0F\x0A\xDC\x06\x05\x3E\xD1\xAA\x73\x01\xC2\xDB\x02\x07\xD4\x49\x15\xAE\xDA\x08\x91\x0E\xB5\x01\xC2\xD9\x06\x0F\x71\xD1\xDC\x29\x90\xB4\x67\x07\x02\xDB\x29\x03\xC7\xDD\x1B\x2E\xDA\xCA\xC6\x32\x92\x6C\xF8\x00\x2E\xDE\xAD\xDD\x0E\xC3\x64\x7B\x02\xB0\xD7\x04\x27\xDC\xB6\xD8\x3D\xC6\x4F\xBD\x01\xC2\xDB\x15\x05\x73\xE2\xDB\x02\x04\x49\xDF\x6E\x7F\x01\xCA\xDB\xD0\xDD\x6C\xE1\xC7\xD0\x69\x20\x02\x6C\xF5\x01\x3C\xDC\xD1\xD1\x10\x19\xBE\xD5\x92\xB0\xD5\x08\x11\xDD\x4B\xDF\x7B\xC9\x8A\x45\x02\xC2\xD9\x25", + "\x08\x75\xDA\xDB\x40\xD7\xBE\x77\x08\x02\xDB\xA5\x03\xD7\xD9\x6E\xDF\xC4\xD0\x69\x22\x02\x6C\xF5\x02\x4A\xDC\xD8\xDD\x54\xE1\x83\x8B\x02\xB0\xD4\x0C\x2D\xDD\x67\xDC\xEF\xC9\x8A\x4D\x02\xC2\xDB\x34\x04\x77\xF1\xDB\x33\xC5\xF1\x92\x6C\xE2\x03\x7B\xDC\xBE\xDA\x68\x69\x62\x91\x02\xB0\xD1\x0F\x01\xDE\xAE\xDA\xFF\x9C\x1C\x93\x02\xC2\xD8\x00\x07\xBF\x7F\x06\x81\x46\x52\xBB\xEF\x55\x02\xC2\xD8\x04\x07\xBF\x7B\x06\x91\xDE\x54\xBB\xEF\x71\xA3\xE3\x5A\x07\x07\x79\xF6\x45\x9E\xD0\x6B\x89\x09\x02\xDB\x2C\x03\xFD\x6D\x1B\x19\xDE\x7B\xC3\xBB\x5B\x09\x02\xDB\x3B\x02\xE9\xD0\x7A\xD2\xDD\x9D\x99\x27\x02\x6C\xCA\x01\xAE\xDD\x42\x08\x7A\xC1\x04\xCF\xD8\xB4\x6F\x09\x11\xDB\x64\x5B\xED\xDF\xD6\x85\xCD\xC2\xD9\x16\x05\x7B\xC0\x46\x91\xC0\x6B\x82\x0A\x02\xDB\x68\x03\xE7\xD6\x7B\xC5\xD3\x55\xCE\xB0\xD6\x07\x03\xDF\x03\x06\xEF\xDB\x6E\xED\xCA\xF8\xA3\xB8\x55\x08\x10\xDF\x02\x06\xEF\xD6\x33\xF9\xB9\xA8\x02\xB0\xD4\x09\x18\xDF\x01\x06\xEF\xDE\x0A\xF9\xB9\xAA\x02\xB0\xD3\x0A\x20\xDF\xD1\x68\xD1\xCC\x1A\xAC\x02\xC2\xDA\x2C\x08\x7E\xFE\xDE", + "\xE4\xD0\xC0\xDE\x0A\x02\xDB\xC1\x03\xFB\xD4\x0C\xDD\x9A\xB0\x02\xB0\xD0\x0D\x0F\xDE\xAF\xDF\x02\x30\xAD\x72\x02\xC2\xD8\x38\x06\x7F\xF5\xC6\x8E\xCE\xB0\xDF\x0E\x0A\xDF\xC4\xDC\x6F\xC3\xA7\x82\xDB\xFD\x00\xFF\xDB\x7C\xC7\xD4\xAC\x84\x2E\x02\x6C\xCD\x00\x2A\x73\xE9\xD8\x37\xF6\x93\xBA\x02\xB0\xDC\x01\x15\xE0\xFD\xDC\xEA\x9B\xEF\x7C\x02\xC2\xDB\x0A\x0A\xC2\x50\xDE\xD6\xC5\xA7\x9E\x0B\x2C\xDE\x1C\xE3\x03\xED\xDD\xAC\x86\xC0\x03\xEC\xD9\x82\xC9\xE0\x4C\xDF\xBE\x76\x90\xA3\x5B\x59\x03\x08\xED\x81\xE7\x83\xBB\xBA\xB0\xD9\x06\x36\xE0\x2A\xE2\xD6\xD0\xAD\x46\x03\xC2\xD9\x1E\x0C\x83\xF0\xE0\xF6\xB4\xB3\xB2\x6C\xC9\x02\x43\xE1\xF4\xD6\x54\xDD\x9A\xCA\x02\xB0\xD9\x09\x2F\xE0\x4A\xE3\xDB\xDC\x1A\x8C\x03\xC2\xD8\x2A\x00\x85\xD9\xDF\xE4\xAF\xBE\x7E\x0C\x02\xDB\xB7\x03\x15\xE1\x7E\xDA\xD5\xEF\x58\x34\x02\x6C\xC6\x03\x5E\xE1\xFA\xDA\x3C\xDD\x9A\xD2\x02\xB0\xD5\x0D\x25\xE1\xBE\xDE\xE2\xD9\xE7\x94\x03\xC2\xD8\x39\x09\x84\xC2\x04\x89\x02\xC7\x90\xAD\x56\x03\xC2\xD8\x3D\x0A\xC2\x7B\x06\x75\xE2\xC9\x99\x8A\x58\x03\xC2\xDA\x00\x04", + "\xD5\x7C\xE1\xA1\xDE\x3D\x9A\x0D\x15\xDE\x54\x75\x6F\x0D\x87\xCE\x96\xFB\x78\x37\x02\x6C\xDF\x00\x89\xE0\x43\x0B\x88\xEE\xDD\xFB\x7A\x37\x02\x6C\xEE\x00\x91\xE1\x42\x03\x89\xF0\xC5\xAC\x84\x38\x02\x6C\xFD\x00\x99\xE2\x41\x0B\x89\xF7\xC5\xFB\x7A\x38\x02\x6C\xCC\x01\x83\xE2\x24\xEC\x7C\xF9\xB9\xE4\x02\xB0\xDA\x05\x21\xE2\x03\x07\x28\xEF\x09\xFB\x7B\xE6\x02\x0E\xE0\x8B\xF4\xE1\xA6\xC0\x6B\x88\x0E\x02\xDB\x78\x03\x2D\xE1\x10\x32\xE2\xE3\xDD\xAB\xCA\x0E\x02\xDB\x87\x02\x2F\xE0\x00\x32\xE2\xFF\xDA\xA2\xD0\x00\x2C\x03\xC2\xDA\x25\x06\x8C\xF2\xE2\xF1\xDE\x32\xEE\x0E\x24\xDD\xCF\xE3\xFD\xDF\x6E\x70\x03\xC2\xD8\x2D\x04\xD5\x7F\x06\xB2\xE3\xC4\xD4\x7B\x72\xDD\xD5\xE0\x01\xED\x69\xB4\x03\x79\xDD\x2A\xEA\x89\xC0\xD4\xCC\x86\x3D\x02\x6C\xE1\x03\xDB\xE2\x2A\xE0\x81\xCF\xCA\x86\xDD\x38\xEE\x50\xE1\x83\xFA\x01\xE3\xD1\xCB\x53\x15\xB2\xE3\xCD\xD1\xAA\x60\xA4\x08\x5F\x3D\xEC\x8D\xE5\xE0\xEF\x5A\x3F\x0F\x88\xF7\xE3\x8A\xE0\xED\xAD\x69\x92\x13\x88\x4E\x0B\x04\x90\xEE\xE3\x31\xE1\x38\x82\x00\x08\x06\x88\x4D\x0F\x0E\x8F\xCC\xE4\x0D", + "\xB7\xBE\x74\x00\x10\xE4\x0C\x05\x13\x03\x91\xE7\xE3\xC9\xAD\x38\x86\x00\x18\xE4\x8B\x7B\x46\xE2\x8A\xE1\xDD\xE1\x80\x02\x00\x92\xCE\xB2\x22\xE5\x2C\xEB\x84\xC7\x5F\x27\xE7\x40\x0D\x07\x0B\xE4\x1C\xE7\x49\xB0\xAD\x4C\x00\x2D\xE6\x40\x0C\x08\x30\xE4\x23\xE7\x54\xDC\x1A\x8E\x00\x35\xE7\x74\x08\x93\xEA\xE4\x47\xA4\xB4\x60\x01\x3D\xE4\xF0\x5B\x4F\xE8\x8B\xE7\xE1\xEF\x5A\x04\x04\x94\xF9\x02\x46\xE7\x2F\xE7\x56\xF6\x93\x14\x00\x51\xE8\x0C\x29\xE4\x02\x04\x5F\x41\x93\xE1\x83\x16\x00\x62\x0C\x5C\xD6\xE5\x06\x07\xA0\x50\xAD\x57\x00\x5A\xE5\x2C\x49\x7B\xEF\xD5\xFB\x78\x06\x08\x18\x0E\xD9\xB8\xDC\xAA\xA0\xAD\x5D\x00\x88\x06\x02\xBA\x20\x63\xE5\x8E\xC9\xA7\x94\x02\x2D\xE5\x62\xE6\x12\xDA\x07\xB4\xE5\xFE\x48\x5C\xE1\x82\xA1\x83\x32\x00\x5E\xE4\x66\x7A\xE5\x26\xA0\x2C\x8E\x97\xFD\x5C\x80\xE4\x97\xAB\xEF\x40\x01\x83\xE7\xFB\x55\x98\xD9\xD6\xB1\x43\x11\x09\x98\xE0\x67\x85\xE7\x9C\xDF\x7E\x4E\x01\x8F\xE5\x5F\x65\x98\xF8\xD9\x64\x59\x15\x05\x99\xC5\x44\x85\xE5\x9F\xD7\x0B\xDC\x01\x9B\xE6\x6D\x45\x98\xC3\xDA\x3D\x5F\x18\x01\x9A", + "\xEF\xE5\x55\xC3\x5B\x87\x9A\xFC\x54\x85\xE7\xA3\xDF\x7E\x71\x01\xAB\xE6\x6A\x55\x98\xD5\xDA\x00\xDC\x1E\x01\x9B\xC8\x55\x5E\xE6\x41\x05\x98\xC7\xDD\x61\xE6\xBF\x4A\xE0\x52\xDE\x08\xD4\x51\xE8\x0D\x37\xE3\xBB\x07\x6F\xEA\x79\xE1\x83\x82\x00\x51\xE6\x0E\x04\xE7\xBF\x41\x21\xED\x69\x84\x02\x44\xE4\x3D\x0D\x94\xC0\x00\xC6\xE7\x51\xE8\xA4\xBD\xE6\x64\x59\x75\xE1\x10\x39\xE6\xE1\x83\x21\x08\x9D\xFD\x5C\xDA\xE5\x6B\x90\xAD\x48\x02\x44\xE7\x00\x03\xCB\x7D\x06\xE1\xE6\xAB\xD9\x8D\x44\xE5\x12\x03\x79\xED\x9C\xCE\xDB\xA9\x60\x23\x0F\x9D\xEF\x5F\xE1\xE4\xB5\xD7\x0B\xCD\x02\x44\xE5\x08\x0E\x9E\xC9\x04\xE1\xE4\xB7\xD9\xE7\x8F\x02\x44\xE4\x0C\x03\xCB\x45\xE7\xAB\xE1\xAB\xC1\x09\x04\xE5\x3E\x03\x7E\xE6\x10\x21\xE7\xD3\xDF\x2D\xC3\x09\x04\xE5\x4D\x02\x82\xE3\x10\x21\xE7\xDB\xDD\xAB\xC5\x09\x04\xE5\x5C\x02\x84\xE2\x10\x21\xE7\xC1\xE3\x2D\xC7\x09\x04\xE5\x6B\x02\x86\xE2\x4E\xAA\xDF\xF6\x91\x26\x04\x94\xFA\x01\x22\xE8\x75\xE6\x70\xF6\x93\x9B\x00\x51\xE9\x08\x29\xE8\xE1\xE4\xD5\xC9\xE7\x9D\x02\x44\xE4\x26\x03\xCB\x7F\x06\xE1\xE6", + "\x37\xEA\x20\x5F\x02\x44\xE4\x2A\x00\xA3\xE3\xCD\xAC\x85\x28\x04\x94\xF7\x02\x03\xEB\x7B\xE0\xF5\xBB\x7B\xA3\x00\x51\xE5\x0C\x37\xE8\x46\xEA\x78\x80\xAD\x65\x02\x44\xE5\x35\x0F\xA3\xE0\xAE\xE1\x83\x29\x04\x94\xE4\x03\x53\xE8\xDF\x7B\xC4\x44\xE5\xF3\x00\x93\xEC\x9F\xC0\xE4\x03\x67\x2A\x05\x9E\xFD\x73\xE8\xE6\x41\xEB\x53\xAC\xE7\x64\xE9\x93\xE9\xD0\xB3\xBA\xAF\x01\x7E\xED\xCF\x78\xE8\x32\xD4\x73\x81\x0B\x04\xE5\x31\x03\x9B\xEA\xA6\xC1\x04\xF0\xC5\xA8\x63\x0B\x04\xE5\x41\x02\x9D\xEF\xA5\xE7\xCE\xA1\x69\x2D\x04\x94\xD1\x01\x7E\xEB\x82\xEB\x92\xC2\x8A\x44\xE5\x18\x09\xA6\xFF\xE9\x32\xE5\xA1\xB4\x94\xF0\x01\x8B\xEA\xA1\xEA\x93\xFE\xB0\x44\xE7\x1F\x01\xA9\xD3\xE8\x60\xE3\x40\x6D\x0B\x04\xE5\x8E\x03\xA5\xEB\xA1\xFA\xC4\xAC\x87\x2F\x04\x94\xDD\x02\x9E\xEB\x88\xE1\x3D\xE6\x8A\x44\xE4\x2B\x05\xA8\xF6\xDD\x83\xC9\xD3\x58\x18\x07\xD9\x03\x3D\xEF\xC0\x00\x00\xD1\x91\x67\x59\xE1\x0B\x72\xEA\xF0\xCD\xA8\x6B\x0C\x36\xEA\xFE\x4A\xAC\xE2\x58\xCE\xB1\xBC\xE8\x99\x52\xAB\xD0\xD1\x79\xB9\x35\x01\xAC\xFD\x5C\xB2\xE8\x98\xDC\x1C\x9A", + "\x03\xC7\xEB\x39\x63\x59\xEC\x86\xDF\x01\xB3\xE0\x9E\x72\xEA\x8C\xE6\xBF\x44\x0E\x12\xEB\x7D\x66\xAC\xE2\x99\xE0\x67\xE9\x00\xB6\xE5\x10\x72\xEA\x98\xE5\xCF\x5E\x0E\x1E\xEB\xB6\x46\xAC\xEE\x99\xC0\xDC\xF3\x00\xB9\xEA\x20\x72\xEA\xA4\xE7\xFB\x58\x0F\x2A\xEB\x3C\x56\xAC\xE9\x68\xF1\x42\xFD\x00\xBC\xEA\x5A\x72\xEA\xAE\xE4\x78\x62\x00\x0A\x06\x68\xE6\x2A\x54\x43\xE1\x6A\xA5\xA5\x71\xD5\x10\x75\x91\x64\xE5\x38\x8C\x00\x0A\x06\xB0\xEA\x56\xD4\xAB\xC0\xC6\xFC\xE9\x2C\x44\xB0\xF1\xE5\xEF\x58\x05\x0D\xB0\xFE\x4B\x0F\xEC\xA5\xC6\x4F\x99\x00\x13\xEC\x99\x55\xB1\xDA\xCA\x03\x66\x07\x09\xB1\xFD\x5C\x1B\xEC\x92\xC1\x0E\xB4\xA6\x02\xEE\x6D\x41\xB2\xE7\xD9\xCC\x84\x0A\x0F\xB1\xEF\x5F\x21\xED\xB5\xE4\x66\x6D\x00\x2B\xEC\x78\x61\xB2\xDB\xEB\x7D\x66\x0C\x01\xB3\xFD\x65\x21\xED\xB8\xEF\x7E\x77\x00\x37\xEF\xC0\xEA\x5A\xFB\x7B\x3C\x01\xCF\xE6\xB2\xE3\xD0\xCC\x85\x10\x02\xB4\xCA\x48\x21\xEF\xBC\xEE\x2F\x46\x01\x47\xEC\x4F\x51\xB2\xF9\xEB\x7D\x67\x12\x0D\xB4\xEA\x56\x21\xEC\x6D\xEA\x8C\xD0\x01\x53\xEC\x52\x57\x5A\x82\x04\x3A\xD3\xBB", + "\x55\x05\x08\xEC\xB1\x43\xD6\xE1\x10\x0B\xEC\xA1\x68\x16\x09\xB5\xF8\x56\x62\xEC\x00\x09\xAB\xCC\x87\x5D\x03\xD9\xEF\x8E\x76\xE5\xFB\x7A\x18\x0E\xB6\xC3\x3C\x69\xEC\xB1\xED\x2A\xE7\x01\x73\xEF\x12\xEA\xAC\xF9\xB9\x6C\x01\xDE\xEE\x3A\xE6\xD9\x5C\x9E\xDF\xE8\x76\xF8\xC0\x49\xCA\xE0\xE1\x93\x8C\xAB\xFB\x7B\x1E\x06\xB8\xC5\x79\xA5\xD6\xB0\x6B\xB8\xC1\x04\x69\xEF\xB9\xEA\x8C\xC5\x02\x8F\xEC\x00\x09\xB6\xED\xEB\xE0\x66\x22\x05\xB9\xE9\xED\x4A\xEE\xC6\xEB\xB9\xDB\x2D\xAC\x84\x25\x0F\xB9\xD8\x5E\x25\xE9\xE5\xE8\xA1\x81\x04\x5D\xEF\x40\x6E\x09\x20\xED\xFE\x4B\xE9\xE3\xAB\xE9\x62\xA1\x02\xE9\xE0\x65\xEC\x86\xA6\x02\xEC\xE7\xFC\x94\x89\xB6\xEE\xF3\xB9\x58\xF9\xEE\xD4\xBC\xB4\x65\x0B\x3C\xEE\xDA\xBF\x21\x70\xBC\xE1\xBF\x22\x6F\xF0\xE6\xFE\xA6\x72\xC6\xEE\xCE\xE0\x9E\x49\x03\xC6\xEE\xE4\xE1\x0B\x4E\x03\xC6\xEC\xE6\xED\x97\x53\x03\xC6\xED\xE7\xED\x73\x58\x03\xC6\xEC\xD4\xE5\x10\x5D\x03\xC6\xEE\xD5\xE1\x0B\x62\x03\x95\xED\x58\xD9\xBA\xE1\x6A\xE7\x00\xEB\xE4\x66\x61\xD5\x64\xEC\x73\x8A\x0E\x21\xEF\xB3\xED\x27\xBC\xBE\xF7\xEE", + "\xD0\x68\x3D\x0F\xBE\xFA\xEE\x2D\xC7\xFC\xED\xBB\xFB\x7B\xFE\x02\xFD\xE1\xBC\xE4\xB3\x8C\x05\xBF\xE1\x56\xEE\xEC\x3D\x5C\x02\x0D\xBF\xF1\x42\x61\xD4\xCD\xE5\x10\x4D\x00\x03\xF2\xBF\x41\x56\xCA\xEF\x7D\x66\x04\x09\xC0\xE7\xEF\x3F\xED\x38\x88\xA2\xA5\xEC\x0A\x49\x58\xD2\xBD\xC5\x44\x1C\x03\x03\xFD\x73\x61\xD5\xD6\xEC\xFF\x6A\xC1\xEF\x5F\x61\xD6\xF6\xE6\x1B\x66\x00\x1F\xF0\x78\x61\x56\xDE\xEF\x4C\x75\x09\xFD\x97\x53\x02\x76\xE3\xBE\x70\x03\x0C\x06\x88\x4C\x2F\x0D\xCF\x5E\x07\x2C\xF2\x1F\xE5\xB0\xB0\xF0\x13\xB3\x0C\xFC\x10\x35\xF0\x2F\x9D\x2A\x64\x03\x38\xF0\x09\x06\x35\x0D\xCF\x7B\x06\x3C\xF2\x29\xDD\x69\xB6\x00\x40\xF2\x41\x04\x0E\x03\xF1\x3B\xF2\xAD\xDF\x6E\x78\x00\x49\xF0\x6E\x3C\xC4\xC9\x04\x45\xF0\x27\xE6\x4F\xBA\x00\x51\xF3\x40\x01\xD2\x44\xF1\x0C\x07\x25\x09\x8A\x7C\x00\x0E\xAE\xBF\x45\xC5\xE4\xE2\xE1\x81\x0F\x09\xC5\xFA\x06\x21\x74\x0D\xF5\xA0\xF7\xC2\x3F\x03\x19\xF0\x00\x1B\x00\x5B\xF1\x13\xFA\x6E\xD0\x83\x6E\xF1\x0A\x01\xC7\xD4\xF1\xB9\xE2\xAC\x9E\xC6\xF7\x00\x77\xF2\x41\x03\xC6\xC0\x00\x1D\xE8\xC0\xD5", + "\x04\x2E\xF1\x45\x01\x1F\xF3\x10\x3F\xF1\xC9\xE1\x63\xEE\xC6\xD3\x01\x86\xF2\x40\x0F\xC7\xD1\xE3\xB1\x41\x12\x0E\xC6\xE1\x01\x8D\xF1\x40\x0F\xC7\xF2\xE8\xAD\xCB\x12\x0E\xC6\xEF\x01\x21\x75\x6F\x0F\xC7\xFA\xE8\x3C\x55\x13\x0E\xC6\xFE\x01\x95\xF0\x00\x0F\xC7\xDA\xDC\xCC\x87\x13\x0E\xC6\xCC\x02\x69\xF2\x1C\xF7\xA4\xE1\x83\x51\x02\x1B\xF9\x09\x1D\xF2\xAE\xF2\x93\xEB\xEF\x53\x01\x6E\xF0\x2A\x05\xCA\xFF\xF1\x31\xDF\x40\x65\x05\x2E\xF1\xB6\x03\x2E\xFF\x37\xC4\xB8\x6E\xF0\x31\x04\xCB\xF8\xF1\x86\xCC\x6B\x89\x05\x2E\xF1\xD3\x02\x30\xFC\x1D\xD2\xB8\x6E\xF1\x38\x0E\xCC\xCD\xE4\x19\xBA\x1B\xFF\x0E\x07\xF3\x7E\xF1\x9C\xE9\xE7\x9F\x01\x6E\xF2\x3F\x08\xCD\xC7\xF2\x39\xD4\x6B\x81\x06\x2E\xF1\x0D\x01\x58\x79\x47\x3F\xF1\xED\x9B\x40\x63\x06\x2E\xF1\x1C\x02\x39\xF1\x4D\x3F\xF1\x69\xEF\xBB\x55\x06\x2E\xF1\x2B\x02\x3B\xF9\x54\x3F\xF1\xAE\xEF\xBB\x57\x06\x2E\xF1\x39\x02\x3D\xFC\xC5\xD3\xEA\x9D\x99\x1A\x0E\xC6\xC7\x01\xFE\xF1\x2D\xFF\x4A\x69\x62\x6B\x02\x1B\xF5\x05\x05\xF4\xC8\xF1\x86\xCB\xEF\x6D\x01\x6E\xF3\x18\x0C\xD0\xD9\xF3\xA7", + "\xEA\x3D\x9F\x06\x2E\xF1\x71\x02\x3D\xFD\x1B\x14\x5A\x61\xB8\xD7\x91\xC6\xE4\x59\x1C\xF7\x0F\xC4\xA9\x5F\xF4\x3D\x5D\x25\x0D\xC2\xE1\x83\x73\x02\x1B\xF0\x08\x36\xF3\xDE\x06\x49\xF6\xC3\xFB\x7B\x75\x02\x1B\xFD\x08\x2C\xF4\x0C\x06\x4B\xFD\xC3\xEA\xDC\x6E\xF2\x26\x03\xD1\xC3\x04\x36\xF6\x11\xFA\x4C\xB9\xF2\x3B\xF6\x40\x0D\xD3\xF5\xDD\xAC\x87\x1E\x00\xCC\xC1\xF5\xED\x42\x25\xAD\x69\xBD\x01\xC5\xF0\x52\xF0\x00\x03\xF5\x64\xF0\x6B\x8F\x07\x2E\xF1\xD2\x00\x4D\xF9\x10\x10\xF5\x54\xC1\xD3\xDE\xC6\xDF\x03\x4E\xF4\x56\xFD\xA0\xC0\xDC\x83\x02\x1B\xFD\x0E\x1D\xF5\x79\xF1\xA7\x95\x08\x2E\xF1\xFB\x00\x59\xFD\x33\xDD\xE7\x6E\xF1\x02\x0C\x79\x7B\x06\x58\xF5\x22\xFE\x2F\x49\x02\x6E\xF3\x05\x0F\xD6\xF5\xF4\x2B\xE9\xA7\x9B\x08\x2E\xF1\x25\x03\x5D\xF7\xD5\xD6\xE3\x03\x65\x23\x0E\xC6\xF3\x00\x9C\x5D\x6F\x08\xD5\xE0\xF2\x54\xEE\x1B\xF2\x04\x3E\xF5\x1D\xF6\x38\xEF\x6E\x51\x02\x6E\xF0\x14\x0C\x79\x6D\xF4\xE8\xE1\x9E\xB3\x09\x2E\xF1\x5D\x01\x61\xF8\xD7\xEF\xE3\x9D\x99\x25\x0E\xC6\xEC\x01\x8C\xF4\x4F\xF7\x81\xDD\x9A\x97\x02\x1B\xFA\x07", + "\x21\xF6\x42\xF7\x30\xFD\x69\x99\x02\x6E\xF0\x22\x0A\xD9\xFF\xF5\xC9\xF0\x8B\xEE\xC6\xD7\x02\xA8\xF5\x52\xFF\xCC\xC4\xC1\x6E\xF1\x29\x05\xDB\xCF\xF5\x93\xCE\x3D\x9F\x09\x2E\xF1\xB3\x03\x6B\xFD\xD8\xDD\x9B\xB3\xB9\x28\x0E\xC6\xC2\x03\xC2\xF6\x68\xFD\x91\xDC\x94\x6E\xF1\x34\x09\xDC\xE9\xF6\x80\xE8\x73\x85\x0A\x2E\xF1\xE0\x03\x73\xF6\xDB\xC3\xEE\x55\xEA\x35\xFB\xDB\xD8\xF5\xF9\xF3\x40\x69\x0A\x2E\xF1\xFD\x03\x76\xF9\x85\xE1\x83\xAB\x02\x1B\xFB\x00\x1B\x5F\x70\xF5\xA6\xE1\xAA\x6D\x02\x6E\xF1\x06\x08\xDE\xDB\xF6\x0E\xF5\x38\x8F\x0A\x2E\xF1\x27\x03\x7B\xF0\xDB\xD5\xA5\xD0\x68\xD8\xA3\x6E\x75\x00\xDB\x5D\x6F\x0D\x69\x43\xF7\xE1\x83\x2C\x04\xD2\xEF\x5F\xFF\xF6\x48\xF0\xAD\x74\x02\x03\xF8\x78\x6E\xC5\xED\xEA\x8F\xD6\x0A\xF5\x10\x4B\xF8\x89\xC8\x6B\x8A\x0B\x0C\x06\x6E\xE4\x4F\x50\xE1\xD0\xEC\x03\x65\x30\x04\xE1\xF1\x42\x17\xFA\xC5\xED\x69\x88\x03\x1B\xFA\xBF\x4D\xE1\xDC\xEC\xA1\x6B\x33\x01\xE2\xE4\x59\x23\xFA\xC8\xEC\x1A\x96\x03\x27\xF9\xCF\x59\xE2\xE8\xEC\x79\xB9\x37\x0D\xE2\xEF\x5F\x29\xF8\x00\xFF\x7E\x64\x03\x33\xFA", + "\x82\xFC\xAB\x36\x93\xEB\x01\x8E\xFD\x97\x69\xF8\x0C\xF1\x41\x42\x0F\x3E\xF8\x0F\xF9\x04\xFC\x1A\xB9\x03\x44\xFA\xB9\x64\xB4\xF9\xB9\xB5\x11\x85\xFA\x5A\x69\xF8\x1D\xF0\x78\x67\x00\x0E\x06\x4E\xF8\x52\x59\xE2\xE2\xF0\x0A\x4A\x03\x04\xE5\xDC\xF8\xFF\xE8\x73\x85\x01\x1B\xF9\xFE\x49\xA9\x50\x49\xC3\x64\x1C\x02\x63\x08\x38\x44\x01\xDB\x5E\x77\x02\xE6\xD8\xD2\x1D\xEE\x99\xFF\xA5\x69\xF9\x0C\x07\x9A\xF9\x15\xF6\x93\x20\x02\x9B\xFB\x8B\xB6\xF7\x06\x06\x9C\xF9\x7A\xC3\x64\x22\x02\x9D\xF6\xB1\xB8\xF9\x03\x06\x9E\xFC\x77\xEC\x86\x24\x02\x9F\xF8\x04\x40\xFA\x02\x06\xA0\xFF\x7B\xEC\x86\x26\x02\xA1\xF9\x7D\xC8\xFA\x01\x06\xA2\xFE\x9F\xED\xCA\x28\x02\xA3\xF1\x10\x16\x02\x70\xF9\x42\x0A\xE8\xE8\xCC\x03\x66\x0A\x06\xE9\xC0\x00\xA3\x00\xA4\xF0\x00\x0A\xFA\x5F\xF6\x32\xEC\x02\x1F\xFA\xB1\x02\xA8\xFA\xE8\xD5\xE8\xB7\xC2\x0B\x0F\xE9\xFF\x02\xAA\xF8\x65\xC6\x4F\x9D\xAE\xE3\x59\x33\x01\xEB\xEE\xAD\xA9\x62\x0C\x0F\xE9\xDB\x03\xB7\xFA\xDD\xAE\xC3\xDF\xFA\xE9\x01\xAF\xFD\xB7\x90\x6B\x36\x03\xA7\xF7\x0F\x3D\xF7\x71\xFB\xE0\xA3\x90\x78", + "\x00\x9F\xFA\x01\x0A\x64\x3B\x06\x8A\xF8\x2A\xF9\xE7\xBA\x00\x9F\xF8\x05\x0A\x64\x2A\xF9\x95\xF5\xAB\xCC\x03\x1F\xFA\x21\x02\x92\x1D\x1B\x0A\xFA\x99\xAF\xBB\x53\xBA\xA3\x5B\x30\x03\xB3\xF9\xEC\xD4\xE9\xAC\x84\x10\x0F\xE9\xFE\x00\xE6\xFA\xA6\xFA\xDA\xEF\x5B\x42\x03\xA7\xFC\x04\x1E\xFB\xE7\xF8\x47\xDC\x1A\x84\x01\x9F\xFB\x16\x0D\xEE\xF9\xF9\x66\xEB\x40\x66\x04\x1F\xFA\x69\x03\xBE\xF1\xE8\xFD\xF6\x8A\xA7\xA7\xF7\x07\x34\xFB\xEE\xFA\xF0\xA0\xAD\x4A\x01\x9F\xFA\x21\x08\xF0\xFC\xFB\xCB\xF6\x3D\x9A\xBA\xAB\xA7\x0F\xFF\xC0\xF1\xDD\xF9\xB9\x4E\x03\xA7\xF4\x0A\x15\xFC\x89\xFB\xA1\xE1\x2C\xDF\xFA\xB3\x02\xC0\xFD\xF1\xD2\xE1\xF6\x92\x14\x0F\xE9\xC1\x03\x22\xFD\xA4\xF3\xDE\xEC\x86\x54\x03\xA7\xFF\x0C\x29\xFC\xA3\xFA\x7A\xFC\x1C\x96\x01\x9F\xF9\x37\x00\xF3\xCA\xFA\x61\xD7\xBB\x58\x05\x1F\xFA\xEB\x03\xCD\xFF\x94\xDD\x9A\x5A\x03\xA7\xF9\x0F\x1C\xFC\x01\x07\x63\x49\x10\x00\x5B\xFB\x78\x17\x0E\x18\x0C\xD7\x46\xFE\x41\x01\xE1\x51\x9C\x4B\xFD\x2C\x4F\xF4\xDD\x85\xD0\x6A\x17\x0F\xE9\xC8\x00\xDD\x2A\x77\x03\xF5\xE5\x85\xA9\x60\x18", + "\x0F\xE9\xD5\x00\x59\xFC\x43\x0B\xF5\xC1\x04\x30\x9D\xA8\x62\x06\x1F\xFA\x22\x01\xB7\x2B\x1B\x23\xFD\xE2\xE7\xBE\x74\x06\x1F\xFA\x30\x02\xDA\xF2\xF6\xCE\xF1\xBE\x77\xBA\xF2\xF7\xC9\x04\x6C\xFE\x7D\xE0\x70\xE8\x01\xF2\xFB\xDD\xFE\xF4\xC5\xDF\xF6\x92\x1A\x0F\xE9\xDA\x01\x61\xFC\xDE\xFB\xC6\xC0\xDC\x6C\x03\xA7\xF7\x06\x3E\xFD\x03\x04\xDB\xF5\xEA\xF1\x42\x6E\x03\xA7\xF5\x07\x0C\xFE\xAD\x59\x59\xFF\x6E\x70\x01\x9F\xFB\x20\x04\xF9\xC1\x04\x6C\xFD\x20\xFA\x8C\xF2\x01\x9F\xF9\x24\x0B\xF9\xC0\x00\x6C\xFE\x5C\xF4\x66\x74\x01\x9F\xFB\x27\x03\xFA\xEC\xFD\x90\xF2\xBF\x46\x07\x1F\xFA\xAD\x03\xEA\xF0\xD8\xE1\x6A\x78\x03\xA7\xFB\x0B\x1D\x2B\xBD\x04\xDB\xF8\xD8\xC8\x55\x7A\x03\xA7\xFA\x0C\x32\xFE\x8E\xF6\x3E\xDF\xE9\xD8\x03\x85\xFF\xDF\xFA\x80\xF6\x93\x7E\x03\xA7\xF5\x0E\x38\xFE\x73\xFC\x67\xF2\xAC\x5F\xFA\xF4\x00\xF0\xF3\x8F\xEC\x86\x82\x03\xA7\xF2\x00\x14\x2C\x6B\xFF\xBB\xF3\x90\x44\x02\x9F\xF8\x04\x04\xB1\x39\xFE\x60\xE9\xA8\x66\xBC\xA3\x5B\x1F\x00\xF6\xFD\xFC\xEB\xE0\xF6\x90\x22\x0F\xE9\xED\x00\xE6\xFE\xE1\xF5\xD0\xA1\x83", + "\x8A\x03\xA7\xFB\x03\x1F\xFF\xE7\xFD\x45\xE1\x0E\x8C\x02\x9F\xFA\x12\x04\xFF\xEE\xFF\x11\xC6\x3D\x9E\x08\x1F\xFA\x59\x01\xFD\x7E\xF1\x7A\xFA\x4B\x1F\x5F\xF4\x68\x01\x02\x80\x8D\x7E\x8F\x7C\x73\x42\x12\x06\xF0\x6D\xFF\x43\x00\xA5\x62\xD0\x34\x4A\x03\xA7\x7D\x10\x0E\x00\x89\x00\x80\xF4\x6F\x2D\x96\x01\x4F\x7F\x24\x05\x02\x85\xF9\x61\xCA\x7B\x7B\x18\x01\x9F\x7D\x50\x00\x07\x84\xF3\x70\xAA\x76\x27\x5A\x02\x1F\x7D\xAF\x01\x11\x80\xE9\x7F\xE7\x7F\x6E\x3C\x04\x1F\xFA\x3D\x01\x08\x80\xD7\x00\x43\x07\xD6\x2E\x33\x71\xFA\x7E\x4B\x05\x04\x48\x7F\x70\x43\x27\x06\x06\x84\x66\x34\x01\x94\xFD\x7B\x3D\xA0\x01\x4F\x7C\x33\x04\x62\x1E\x1D\x1E\x01\x9C\xFD\x06\x3D\x9F\x7D\x6C\x00\x11\x83\x06\x8E\x9C\x6F\xB7\x13\xAF\x63\x2D\xE6\x00\x15\x82\x11\x81\xAC\x5D\x69\x46\x05\x10\xFF\x52\x80\x74\x7F\x50\x34\x2A\x06\xFA\x75\xAF\x1B\x0D\x13\x01\x8B\x7D\xF6\x48\x55\x01\xF7\x7D\x0B\x8C\x04\x9D\x44\x7B\x7B\x2C\x01\x9F\x7C\x0F\x01\xBD\x15\x08\x87\xF8\x6A\xC6\x6E\x02\x1F\x7D\x2B\x00\x32\x81\xCE\x04\x99\x68\x7F\x7F\xF4\x79\x00\x72\x80\x26\x22\xCB", + "\x7F\x40\x32\x16\x0F\xE9\x67\x02\x38\x01\x83\x02\x5F\x80\xCF\x7D\x2C\x24\x16\x0F\xE9\x75\x02\x3F\x01\xB9\x69\x24\x75\x4E\x4E\x2D\x07\xD3\x73\x06\x07\x04\xB6\x5A\x79\x7A\x81\x39\x4F\x7D\x1C\x06\x11\x80\x00\x1F\x02\x98\xF2\x37\x61\xBA\x01\x4F\x7F\x1F\x05\x5E\x1D\x1B\x1F\x02\xBB\xFE\x38\x2B\xBC\x01\x4F\x7E\x23\x04\x12\x8F\x05\x92\xF6\x6D\xCA\x3E\x01\x9F\x7C\x4E\x03\x1A\x85\x0C\x8F\xCA\x6C\xC1\x5F\xFA\x29\x01\x9C\x80\x56\x82\x2D\x79\x1C\x42\x0C\x1F\xF4\x78\x02\x24\x81\xA3\x7B\x77\x2C\x31\x07\xD3\x76\x0C\x18\x05\x95\xD4\x4B\x67\x9F\x7C\x6A\x01\x2C\x83\x0E\x81\xDB\x7F\xF0\x5F\xFA\x63\x01\xBE\x80\xF4\x7C\x13\x77\xD3\x71\x0F\x09\x06\x82\xBC\x61\x41\xCC\x01\x4F\x7F\x3F\x03\x18\x89\x07\x8A\xF8\x5A\xE1\x1F\x7D\x0E\x01\x31\x19\x27\x81\x9C\x76\x4F\x50\x06\x1F\xFA\x1D\x00\xDA\x80\x59\x82\x40\x01\x9D\x71\xAA\x32\x06\x1F\xFA\x2C\x00\xE1\x80\x62\x80\x76\x7C\x35\x44\x0D\x12\xFF\x63\x31\x5E\x80\xB5\x67\xFB\x67\xA7\x79\x09\x0F\x0E\x82\x07\xA8\x88\x50\x35\xD8\x01\x4F\x7F\x15\x05\x1E\x8A\x0E\x9D\xBB\x59\x97\x1F\x7D\x65\x00\x7E\x81", + "\x35\x81\xBE\x7C\x1A\x5C\x06\x1F\xFA\x73\x00\x02\x82\x40\x80\x0B\x83\x20\x3E\x0D\x1F\xF4\x41\x02\x69\x81\x06\x02\xCC\x23\x40\x85\x8C\x5C\x03\x98\xE1\x3D\x0C\x29\x31\xE1\x01\x8A\x83\xFB\x29\x07\x8C\xB5\x69\xC5\x22\x03\x0E\x03\xC4\x38\xDB\x20\x47\x83\x6C\x79\x8A\x2A\x07\x0E\x06\x1B\x24\x22\x83\xF6\x77\x38\x77\x24\x81\x0B\x23\x09\x8D\x29\x79\x50\x2C\x82\x7F\x26\x4B\x86\x6E\x77\x0B\x68\x63\x58\x0B\x05\x22\x2E\x83\xBD\x75\xAB\x62\x02\x00\x19\x08\x09\xBF\x5A\x4F\x75\xF6\x48\x0E\x01\x4F\x85\x25\x89\x5F\x43\xC8\x26\x00\x43\x82\x32\x83\x1D\x7D\xA7\x48\x06\x08\x14\x84\xB3\x2E\x04\xC1\x7C\xB6\x22\x1D\x01\x53\x85\xE7\x2E\x12\x8E\xDE\x7E\x4B\x44\x00\x53\x83\x8D\x83\x92\x7D\x55\x6E\x04\x19\x0A\xA0\x67\x2E\x82\x51\x7C\xC6\x3A\x57\x85\x2F\x3E\x12\x98\xF2\x7C\x54\x62\x00\x63\x82\x9C\x81\x97\x7C\x6F\x79\x16\x96\x8D\x2A\x12\x7B\x09\xD0\x34\x3B\x00\x64\x04\xB9\x68\x6C\x20\xCE\x6C\x86\x77\x00\x90\x02\xC4\x24\x24\x03\x8C\x1E\x1D\x15\x0B\x87\xE7\x2C\x43\x79\x01\xBC\x83\xCE\x04\x2F\x8C\x10\x1E\x0B\x9A\xB5\x09\x77\x82\x83\x84\x02\x2A", + "\x01\x21\x82\x10\x06\x0C\x94\x01\xEF\x2D\x7D\x01\xC4\x82\x41\x00\x17\x0C\x18\x83\x27\x19\x01\xCC\x43\x7F\x00\xC9\x83\x40\x06\x18\x05\x19\x80\x00\x0E\x06\xE0\x80\x9D\x4D\x40\x02\x66\x82\x20\x04\x0D\x1D\x0C\x9F\x06\x93\x7D\xB7\x60\x57\x5B\xB8\x2A\x1C\x04\x18\x89\x08\x1F\x06\x9C\x7D\xA1\x35\x42\x03\x68\x81\x20\x0F\x0E\x06\x0D\xB4\x01\xE0\x65\xB3\x82\x48\x1E\x6D\x82\x9A\x6C\x1A\x49\x04\x39\x06\x8B\x00\x67\x19\xDD\x03\x67\x82\x10\x89\x97\x79\x0D\x99\x00\x41\x83\x85\x83\x44\x83\xBB\x2D\x11\x09\x1B\x87\x01\x08\x07\xAE\x83\x90\x81\x81\x33\x23\x01\x37\x85\x03\x0F\x0E\x82\x45\x33\x7F\xCC\x42\x5B\x5B\xB8\x2B\x08\x07\xC6\x1D\x0D\x1F\x06\x9F\x81\xCF\x1F\x49\x01\x6E\x82\x0A\x06\x1D\x86\xA6\x00\xE9\x76\x49\x95\x01\xDC\x80\x18\x07\x8C\x1D\x17\x99\xF6\x5E\xE8\x39\x83\x6D\x01\xEE\x81\x72\x86\xF9\x73\x90\x39\x04\x39\x06\xFC\x00\xE5\x83\xC6\x81\x2E\x83\x20\x3B\x09\x19\x0D\x8A\x02\x79\x83\x96\x83\x5F\x81\xEC\x69\x37\x88\x09\x12\x0F\x90\x07\xC5\x81\xEF\x2C\x5F\x5B\xB8\x2F\x14\x00\x20\x9E\x0C\xBD\xFB\x21\x35\xA1\x01\xDC\x81\x2D\x05", + "\x41\x8F\x19\x8C\xA9\x4A\xC1\x39\x83\xC3\x00\x03\x87\x75\x86\x1A\x81\x0E\x45\x05\x39\x06\xD2\x01\x1A\x84\xF3\x81\xC4\x7D\xD3\x47\x0A\x19\x0D\xA1\x03\x21\x84\xFA\x83\x8B\x7D\xAB\x61\x15\x09\x1B\x90\x07\x28\x08\x81\x84\xEB\x80\x7B\x4B\x2A\x01\x37\x8F\x0F\x14\x10\xB1\x03\xEB\x7B\xB9\x83\x06\x00\xCA\x12\x38\x8B\xF2\x76\x27\x6F\x02\x39\x83\x1B\x01\x1D\x87\x7C\x83\x78\x6D\x69\x51\x05\x39\x06\xA9\x00\x42\x85\x03\x84\x41\x86\x9E\x43\x0B\x19\x0D\xB7\x00\x49\x84\x1B\x84\xFC\x79\x56\x49\x37\x85\x04\x08\x59\x3D\x06\x1E\x23\x06\x02\x71\x2C\x58\x4B\x2E\x81\x0B\x38\x12\x90\x45\x29\x31\xB8\x00\x2E\x86\xBF\x21\xDA\x2F\x03\x81\x07\x79\x02\x39\x83\x54\x00\x94\x16\x77\x04\x4C\x87\x04\x9B\xF7\x0B\xB3\x63\x2D\x61\x00\x35\x86\xC6\x0D\xEC\x7C\x1C\x5D\x05\x39\x06\xEE\x00\x50\x85\x2F\x85\x5E\x4B\xDF\x3F\x0B\x17\x0F\xB9\x09\x82\x02\x6C\x85\x41\x7E\x3D\x49\x18\x0E\x1F\x9F\x13\x81\x04\x01\x85\xA0\x83\xA6\x2C\x81\x86\x50\x80\x00\x08\x14\xA8\x06\x80\x6E\xC5\x01\xDC\x82\x29\x02\x4E\x8D\x6C\x0D\x03\xB1\x42\x47\x01\xB9\x83\x59\x00\xA3\x80\x51", + "\x8F\xF8\x7E\x97\x09\x03\x39\x83\xC1\x01\x4D\x86\x1E\x82\x57\x79\x1B\x8F\x06\x22\x0A\xEB\x7A\xAC\x43\x66\x01\x6E\x85\x1B\x07\x2A\x8B\xF2\x29\x62\x4F\x01\xB9\x83\x75\x01\xAB\x83\x20\x0D\xFA\x64\xB3\x11\x03\x39\x83\xF9\x01\x59\x87\x9F\x42\xB8\x49\x1B\x87\x00\x00\x38\x3D\x03\x88\x84\xF0\x81\xCF\x31\x37\x86\x01\x00\x70\x3B\x06\x08\x85\xA6\x81\x5B\x63\x35\x01\x37\x84\x02\x00\x70\x2B\x09\xEE\x83\x00\x6F\x6C\x01\x6E\x81\x06\x0F\x2B\x9A\x38\x21\xFB\x03\x32\xDB\x01\xDC\x80\x10\x06\x58\x8A\x71\x1D\xE5\x61\x6A\x5D\x01\xB9\x82\x27\x00\xB7\x85\x52\x82\x20\x8F\xB7\x1F\x03\x39\x83\x5C\x01\x6A\x84\xB9\x86\xDE\x7F\xAA\x59\x0D\xAB\x01\x63\x85\x06\x02\x44\x86\xD1\x6B\x20\x33\x0E\x19\x0D\xB9\x01\x70\x85\x7A\x84\x6A\x7A\x3D\x48\x9C\x53\x6E\x27\x04\x2A\x0B\xF1\x85\xDA\x79\x56\x67\x39\x01\x37\x86\x09\x1F\x17\xB9\x0B\xBE\x70\x86\x3F\xDC\x81\x29\x06\x60\x80\x28\x84\xC9\x7D\xC3\x39\x83\xB4\x00\x86\x87\xA1\x82\x01\x89\xE7\x4D\x07\x18\x08\xF8\x85\x0D\x86\x92\x7F\x42\x61\x37\x81\x0D\x18\x18\x93\x0C\x97\x80\x03\x33\x78\x01\x6E\x87\x1B\x0E", + "\x31\x8D\x14\xB2\xFC\x79\x5C\xF3\x01\xDC\x81\x3B\x05\x64\x88\x28\x99\xF9\x73\xB2\x39\x83\xFB\x00\x96\x87\x42\x81\x54\x37\x0F\x19\x0D\x89\x00\x65\x1B\xBD\x03\xD1\x22\x41\x03\xDB\x24\xAC\x42\x13\xA4\x59\x3A\x86\x03\x02\x2D\x84\x3D\x76\x67\x8D\x73\x3C\x19\x82\x04\x2F\x4C\x9D\x4D\x7D\x01\x6E\x80\x03\x05\xDE\x1E\x0E\x06\x0D\x81\x02\xB0\x6D\x50\x35\x3F\x01\x37\x85\x02\x0D\x1A\xAE\x13\x4D\x80\x03\x33\x7F\x01\x6E\x82\x06\x05\xDE\x1B\x0D\x0F\x0D\xED\x7E\xE1\x41\x00\x02\x74\x00\x71\x20\x04\x1D\x1A\x97\x0D\xB0\x6F\xEF\x2D\x01\x03\xD8\x84\x21\x0E\x04\x06\x1B\xB1\x13\x4A\x7A\xE5\x3F\xB5\x85\x42\x04\x0B\x0E\x36\x9B\x19\x80\xFE\x1D\x4D\x07\x00\xB9\x84\x01\x5E\x6A\x8F\x36\x97\x81\x77\xB3\x7A\x86\x26\x65\xBA\x87\x40\x07\x6B\x8D\x29\x84\xB3\x0B\x00\x00\x87\x02\x03\x42\x02\xE0\x82\x20\x0F\x35\x8C\xF5\x40\xDC\x0D\x00\x88\x86\x4B\x7B\xE2\x81\x20\x0F\x35\x84\x0E\xA4\x59\x0F\x00\x91\x86\x00\x01\x28\x03\x72\x8C\x15\x2A\x0E\x83\x64\x11\x00\x99\x87\x57\x00\xE7\x87\x6B\x85\x2B\x9D\xB9\x13\x00\x19\x87\xBD\x01\xD1\x84\x76\x81\xCF\x55\x01", + "\x19\x1C\x8B\x03\x38\x86\x67\x86\xFF\x6F\x66\x61\x73\x8A\x0D\x0A\x1D\x81\xFF\x21\x35\x19\x01\xCC\x84\x3A\x04\x6F\x86\x37\x87\xFE\x5D\x9A\x1B\x00\x99\x87\x7A\x00\xEC\x85\x6F\x81\x37\x63\x57\x59\x0E\x84\x00\x32\x16\xAF\x87\x7E\x81\x54\x3B\xCF\x44\xB9\x09\x0F\xB1\x87\x1E\x71\xDE\x61\xE6\x80\x04\x02\xB3\x1D\x0D\x1F\x0D\xBE\x6E\x9D\x4D\x11\x01\xE6\x87\x05\x0F\x3C\x84\x1E\x83\x04\x73\x85\x68\x6D\xCC\x85\x0F\x05\x7B\x8D\x3B\x9A\x17\x9D\x9A\x27\x00\x99\x87\x25\x01\xF5\x80\x7A\x88\x83\x70\xD6\x29\x00\x19\x87\x5A\x01\xF5\x86\xF7\x83\xF9\x40\xD7\x59\x1C\xA9\x01\x72\x87\xE5\x87\x22\x73\x08\x49\x73\x88\x07\x18\x1F\x83\x0E\x94\x86\xAD\x65\x17\x01\xE6\x87\x10\x04\x3E\x9F\x1F\x9A\x0C\xF8\x4C\x99\x87\x4A\x01\x01\x8C\x71\x8D\x23\x9C\x7E\x59\x0E\xA3\x01\x0B\x88\xCA\x87\xC9\x85\x55\x65\x03\x19\x1C\xB1\x02\x11\x88\x9D\x86\xA4\x73\x40\x37\x06\x09\x39\x9F\x05\x18\x10\xDF\x86\x6E\x70\x3F\x6D\xE6\x85\x19\x0E\x3F\x82\x08\x28\x46\x06\x88\xFB\x3C\x85\x5B\xA6\x52\xB5\x27\x42\x82\x08\x02\x0D\xAC\x43\x3C\x00\xE9\x00\x73\x6F\x85\x88\xBA\x69", + "\xC5\x3D\x00\x52\x03\x2C\x64\xDB\x20\x0D\x8F\x75\x70\xAD\x26\x02\x12\x07\x12\x6C\x03\x1F\x1D\x8B\xDA\x71\xCF\x51\x05\x1F\x21\xB1\x42\x3B\x88\xBF\x75\x3C\x5C\x17\x06\x88\x8E\x2F\x3B\x21\xB4\x04\x80\x6E\x67\x00\x26\x88\x99\x2B\x87\x8A\x13\x97\x85\x72\x01\x52\x88\x3D\x2F\x1D\x88\x8C\x7D\x55\x6D\x07\x18\x22\xAF\x5F\x3B\x88\x36\x7C\xF0\x30\x22\x06\x8B\x8D\x35\x6A\x0A\xAC\x70\x64\x88\x7D\x33\x1D\x88\x54\x87\xD7\x28\x46\x85\x88\x3B\x10\xD6\x82\x64\x2D\x54\x01\x1B\x8A\x87\x8B\x15\x97\x85\x74\x02\x73\x88\x0A\x25\x1D\x89\x58\x85\x20\x2F\x0B\x18\x23\xBC\x54\x3B\x88\x66\x82\xD5\x2A\x32\x06\x8F\x8A\x5A\x3B\x21\xA8\xF0\x64\x2C\xD5\x00\x42\x8B\xC2\x33\x48\x85\xC6\x52\x21\xB1\x42\x18\x3C\x16\x7E\x6D\x62\x23\x8E\x5F\x2F\x4F\x1A\x1A\x1E\x04\x93\x89\x64\x2D\x78\x2E\x41\x00\x92\x8E\x31\x58\x24\xBD\x5C\x03\x0A\x09\x03\x4A\x89\x1D\x5E\x93\x8F\x7E\x37\xB7\x06\x04\x62\x0A\xB8\x32\x52\x88\x78\x32\xAC\x03\xBE\x6C\x0E\x5E\xB5\x26\x6C\xB6\x22\xB1\x09\xFA\x71\xCF\x5A\x0E\x12\x0E\x04\xD1\x27\x89\x2A\x83\x6B\x72\x2D\x89\x16\x22\x56\x09\x22", + "\xAD\xCA\x76\x01\xBB\x88\x7F\x26\x58\x0F\x89\x8A\x8C\x7C\x07\x01\x13\xE4\x2C\x62\x0B\x2A\x88\xC0\x6B\xAD\x52\x06\x6F\x7E\x22\x15\x5B\x88\x35\x82\x71\x0B\x2D\x88\xBA\x05\x14\x81\xD5\x0E\x00\x52\x89\xBC\x88\x33\x8B\x40\x34\x02\x08\x4D\x82\x26\x8D\xEE\x03\x32\x1A\x01\x6E\x88\x32\x8E\xC8\x74\xE7\x62\x27\xBD\x5C\x62\x0A\x17\x79\x11\x7A\x39\x8F\xFD\x22\x56\x1B\x23\xB6\x46\x2C\x00\xEB\x89\x55\x88\xE8\x76\x9E\x42\x03\x11\x27\xBD\x65\x62\x0A\x87\x89\x9E\x2C\x0E\x06\x9E\x85\x10\x3E\xB7\x02\x04\x1B\x0D\xAC\x42\x1F\x02\x38\x0C\xB9\x60\x50\x95\x21\x88\x83\x62\x09\x37\x69\x7F\x8A\x5A\x72\x8D\x4C\x4F\x96\x8D\x05\x14\xEA\x76\xC8\x4D\x86\x8A\x82\x27\xA1\x8E\x4B\x97\x85\x4F\x01\x12\x8A\x3C\x2B\x87\x88\x31\x89\x16\x28\xD9\x4D\x26\x83\x3C\x0F\x8A\xCA\x88\x65\x73\x16\x00\xA3\x8A\x5A\x2F\x28\x90\x13\x80\x6E\x61\x00\x92\x88\x52\x2F\xA1\x81\x46\x9D\xCB\x27\x01\x2A\x8A\xB8\x2B\x87\x8A\x01\x7E\x36\x2D\x06\x10\x29\x8F\x3F\x0F\x8A\x6B\x89\x05\x62\x4D\x8F\xA3\x84\x4E\x9D\x34\x79\x01\x3B\x8A\xBD\x0D\x99\x17\xBE\x3E\xB5\x5E\x51\x81\x2A\x80", + "\x00\x6E\x89\x0A\x25\x42\x00\x50\x89\xD9\x00\x00\x01\x24\x88\x55\x0B\x01\x4B\x8A\x5B\x0C\xDC\x13\xDF\x31\x09\x11\x2A\x9C\x65\x27\x7A\xEE\x48\x71\x08\xE2\x24\x1B\x02\xB3\x1E\x0E\x07\x5C\x6C\x7C\xA1\x35\x4C\x02\x56\x89\x95\x1D\x55\x81\x77\x58\x0D\xA1\x35\x9B\x01\xB1\x8A\x90\x18\x83\x8F\x55\x9E\xE9\x43\x64\x1D\x01\x6A\x8B\xCC\x1E\xF4\x13\x37\x0D\x56\x84\xEA\x7E\xF6\x71\x8A\x61\x03\xB9\x8A\x59\x8A\x7F\x16\x57\x78\x2B\x82\x04\x20\x00\x7A\x8B\x67\x0F\xDD\x87\xDD\x23\x0A\x1E\x2B\x90\x2B\x52\x17\x5E\x8A\x4B\x86\xBF\x25\x14\x06\x58\x99\x98\x01\x16\x86\x02\x75\x8A\xF8\x46\x4A\x4D\xB1\x89\x04\x0F\x2C\x97\x15\xBC\x83\xF6\x49\xE1\x59\xB4\x4E\xB2\x86\x70\x32\xF5\x5D\x9A\x2B\x01\x8D\x8B\x32\x00\x67\x89\x20\x01\x59\x80\x00\x26\xFE\x67\x89\x8D\x8B\x39\x03\x68\x88\x00\x05\x5A\x85\x1D\xAF\x5F\x2F\x01\x8D\x8B\x40\x03\x6A\x8D\xB4\x87\x09\x80\xB8\x71\x02\x0D\x8B\x8F\x00\xE9\x15\x6F\x05\xB4\x82\x2C\x89\x37\x0D\x16\x9E\x01\xB3\x8B\xF3\x81\xA7\x4D\x16\x0D\x58\x8C\x05\x08\x16\xFB\x8A\xAD\x80\x7B\x4B\x2D\x05\xB1\x89\x0B\x1A\x2D\x88\x17", + "\xB3\x81\xAC\x43\x5C\x01\x63\x88\x19\x01\x5C\x88\xF7\x7E\xB0\x0D\x8B\xD6\x01\xEA\x8A\x96\x74\xAE\x4D\x58\x84\x07\x0E\x17\x82\x8B\x08\x85\x81\x33\x2F\x05\xB1\x83\x0F\x1A\x2E\x9F\x0F\x81\x4B\x8D\x8B\x00\x00\x82\x1C\xAE\x84\xF0\x6D\xBA\x0D\x16\x8F\x00\x08\x1D\xDD\x89\xC0\x87\x16\x65\x0C\x0D\x2C\x9E\x00\x71\x8B\xCF\x8A\xFA\x85\x38\x47\x18\x0D\x58\x8D\x01\x38\x17\xE0\x8B\x04\x81\x7D\x3D\x32\x05\xB1\x8C\x03\x1F\x2F\x90\x16\x80\x88\xB7\x61\x65\x01\x63\x8B\x09\x0B\x5E\x99\x2F\x81\x04\x5D\x7B\xA1\x35\x66\x01\x63\x89\x0B\x0D\x60\x80\x30\xAC\xEA\x25\x3E\x8D\x8B\x33\x01\x85\x8F\xC0\x8E\x01\x81\x07\x51\x03\x0D\x8B\x75\x01\x0D\x8F\x65\x8B\x49\x8D\x69\x53\x06\x0D\x16\x83\x01\x22\x8D\xCE\x89\x45\x7D\xD3\x45\x0D\x0D\x2C\x91\x02\x06\x8C\xDF\x0C\x06\x7D\xA8\x37\x1A\x06\x55\x83\x37\x0A\xD9\x61\x41\xDD\x00\x71\x09\x48\x82\x41\x26\x6E\x10\x28\xA6\xC3\x3A\x8C\xB1\x21\x1E\x8D\x45\x88\xE0\x6D\x0E\x00\x32\xBE\x4B\x3D\x8C\x1B\x8A\x7F\x25\x3D\x06\xC8\x84\x66\x3D\x31\xA1\x14\xF4\x75\x4C\x8D\x9E\x2D\x8F\x8F\xA4\x8A\x8C\x65\x00\x01\x12\x3B", + "\x8C\x3C\x2B\x1E\x8D\x4B\x8F\x80\x77\x65\x81\x32\x9A\x13\xA1\x35\x15\x01\x2E\x8F\x91\x8F\x9B\x81\xAA\x33\x6F\x67\x5E\x63\x8C\xD7\x55\xAD\x5A\x98\x8D\xC9\x85\x47\x80\xB8\x6D\x00\x6B\x8C\x52\x8D\xD4\x73\xBE\x3D\x06\x00\x67\x8F\xBF\x3D\x18\xCE\x8A\xB8\x2B\x1E\x01\x9D\x88\x3C\x3D\x63\x99\x27\xAF\x5F\x45\x00\x7B\x8D\xBE\x32\xC3\x2E\xC6\x8B\xEF\x2D\x02\x01\x12\x4C\x6B\x12\x0F\x82\x74\x6B\x46\x09\x01\x48\x1D\xD7\x49\x1A\xF5\x6A\xB7\x79\x40\x09\x95\x78\xB7\x2F\x68\x9C\xAB\x50\x6B\x5A\x00\x92\x8C\x8C\x34\xDC\x70\xC5\x59\x69\x9E\x97\x15\x1A\xA4\x7C\xCC\x42\x34\x01\xA7\x8C\xCC\x2F\x69\x8A\xF1\x56\xF4\x23\x8D\x3D\x2F\x52\x8C\x95\x89\x16\x26\x07\x08\x35\xAF\x5F\x25\x8D\x5B\x8D\x13\x6A\xAB\x88\x3C\x35\x6A\x93\x29\x87\xDA\x33\x8D\x7D\x33\x52\x8D\x4E\x8A\x36\x78\x6B\x85\x88\x25\x1A\xF0\x88\x1B\x79\x5E\x8E\x6D\x25\xD4\x89\x4E\x8A\x90\x19\x02\x42\x8D\x0A\x25\x52\x8C\x52\x8C\xA7\x20\x0A\x08\x36\xBC\x54\x25\x8D\x78\x8D\xE7\x1E\xB7\x59\x21\x03\x69\x8F\x7E\x25\x1A\xFE\x8C\xE0\x32\x57\x02\xB3\x8A\xB5\x24\x71\x23\x08\x25\x1A\xEF\x2D", + "\xB5\x01\x43\x8D\x2C\x24\xE3\x2F\x70\x3B\xF7\x00\xBC\x63\x2D\xA0\x00\x04\x1E\xCB\x1C\xDC\x8C\x57\x3B\xF7\x38\x02\x3C\x5E\x09\x03\x50\x02\xBA\x8C\x21\x0C\x6E\x81\x08\x27\x76\x03\x32\xBA\x00\x78\x8D\xBC\x83\xDE\x81\x6F\x1E\xE2\x27\x7B\x7A\x8D\x03\x03\x51\x00\xBF\x8E\x20\x05\x6F\x98\x29\x2F\x5B\x3E\x01\x00\x8E\xC6\x87\xC0\x8B\x20\x05\x70\x99\x13\x79\xB9\x40\x01\x09\x8F\x80\x01\x29\x03\xE1\x84\x6F\x1F\xAC\x10\x6B\x1B\x5E\xE3\x2C\x53\x00\xC5\x8C\x0B\x6A\x86\x2C\x0E\x44\x03\x11\x8E\x00\x01\x53\x03\xC6\x88\x00\x05\x70\x80\x22\xB1\x42\x46\x01\x20\x8E\x54\x03\xC8\x8D\xE0\x8A\x61\x61\xD5\x27\xBC\x63\x2D\xA9\x01\x95\x8C\x88\x6B\xDA\x50\x72\x8A\x05\x32\x1C\xB0\x89\xA1\x34\x66\x00\xC8\x8B\x15\x07\x73\x8C\xB1\x61\x83\x3B\x5E\xE3\x2C\x56\x01\xCF\x8B\xC6\x61\xAA\x22\x7A\x63\x5B\x2D\x01\x43\x8F\x1C\x6F\xBE\x3A\x1A\x00\x72\x8E\x05\x09\x1D\xBE\x6C\xFB\x3C\x6A\x00\xC8\x8F\x15\x03\x72\x9F\xF0\x06\x14\xFB\x3D\x4E\x5F\xA2\x88\x6D\x24\x24\x80\xAD\x39\x7A\x67\x19\xE4\x2C\x56\x8E\x1F\x8D\x1D\x59\xD0\x85\x10\x21\x3B\x83\x19\xCA\x71\xEC", + "\x00\xB2\x8E\x6D\x21\xEC\x89\x64\x84\xB3\x07\xBE\x5F\x8E\x3D\x2F\xB0\x8F\x93\x8E\x5F\x2C\x0F\x0A\x3B\x8A\x48\x61\x8E\xAB\x8D\x1C\x2F\xB1\x30\xCB\x8A\x5A\x21\x3B\xB1\x1A\x8A\x24\x68\x60\xB8\x8F\xFB\x29\xEC\x86\x6B\x8B\xCF\x3B\x1D\xB1\x21\x61\x8F\x5D\x8C\x52\x2C\x03\x07\x78\x9E\x97\x21\x1D\xC0\x8D\xEF\x2E\x12\x01\xE3\x88\xEC\x8D\x66\x86\xF5\x53\x1E\xF1\x8E\x72\x8D\x70\x43\x1F\x62\xF0\x80\x9E\x21\x3B\x91\x1B\x83\x1E\x3C\x01\xCB\x8F\xE0\x8B\x2D\x8D\x2A\x64\x02\x22\x1E\xE0\x33\x23\x2E\x45\x8E\xC4\x7F\x58\x3D\xAF\x69\x3D\x90\x1A\xB0\x79\xC7\x35\x6A\x8F\xC0\x1E\xF5\x86\x69\x9B\xF7\x18\x01\x31\x8F\xB1\x20\xDA\x8D\x60\x69\x15\x3F\x05\x18\x3D\xBE\x4B\x3A\x8F\x88\x6B\x7D\x3E\x19\x06\xF7\x84\x66\x20\x3E\xB3\x1D\xE4\x2C\x6D\x00\xE2\x8D\xCF\x28\xF8\x89\x77\x87\xFD\x4A\x1F\xEF\x2F\xC0\x8F\xBF\x8C\x4F\x2B\x0F\x0F\x7C\x88\x3D\x9F\x19\xCC\x43\x82\x01\xEA\x8D\x5F\x30\xF8\x8A\x78\x98\xAD\x09\x02\x5A\x8F\x05\x22\xE0\x8C\xE4\x88\x3C\x30\x09\x00\x3F\xB6\x46\x40\x8F\xC5\x8C\x0B\x7E\xF9\x8A\x41\x20\x7C\x8B\x36\xAA\x56\x1E\x01\xEB\x8E", + "\x9E\x28\xF0\x8F\xF3\x8C\x10\x05\x05\x31\x1F\xAA\x2B\xC0\x8E\x6C\x8D\x5F\x34\x15\x07\x7F\x96\xCB\x0C\x04\x40\x8F\xEF\x2D\x59\x03\xB1\x34\xB9\x6B\x72\x25\x37\xA1\x83\x34\x01\xC7\x34\xC4\x24\x2C\x03\xE4\x85\x80\x8D\x37\xA1\x83\x36\x01\x09\x91\x68\x0C\x03\x92\x4C\x3E\x6E\x91\x40\x89\x04\x32\x01\x13\x90\x34\x34\x06\x76\x02\x96\x10\x13\x05\x19\x20\xEF\x34\xA8\x66\x0E\x93\xBB\x0F\x03\x96\xA7\x23\xC8\x3E\x02\x22\x90\xF4\x0C\x12\x90\xD0\x32\x93\x38\x82\x81\x08\x36\x02\x2A\x90\x84\x35\x21\x59\x0B\x91\x99\x60\x83\x8C\xBA\x03\x64\x44\x01\x33\x90\x5C\x01\x0D\x95\xE5\x8C\x1C\x46\x06\x33\x20\xB9\x01\x35\x91\x7E\x75\x41\x20\x19\x03\x83\x9A\x05\x35\x20\x89\x8A\xE0\x32\x65\x03\x0C\x93\x17\x05\x83\x93\x26\xAF\x5F\x4C\x01\x33\x90\x5E\x01\x0D\x92\x20\x31\xAA\x30\x86\x63\x5B\x3D\x01\x35\x91\xF9\x39\x9E\x58\x1A\x03\x83\x9E\x05\x35\x20\xF9\x3B\xE5\x81\x19\x93\x2F\x03\xE4\x8D\x72\x1D\x08\x90\x6B\x54\x01\xC7\x34\x27\x91\x40\x05\x0C\x9C\x75\x9B\xF7\x1A\x03\x27\x8F\x7E\x33\x5C\x8B\x40\x32\x1C\x00\x87\x85\x88\x2C\x21\xAF\x82\x8A\x59\x3A", + "\x92\x6D\x27\x0E\x9D\x76\x9D\xB9\x32\x03\x7A\x90\x0A\x25\x3B\x93\xF1\x8D\xE7\x2A\x0F\x00\x44\xBC\x54\x77\x90\xCD\x8F\x9E\x2E\x00\x01\x1F\x6C\x77\x88\xAA\x37\x21\xD2\x8F\xEF\x32\x46\x91\x2C\x27\x0E\x95\x78\x8A\xAD\x12\x00\x12\x91\xFE\x25\x3B\x91\xF7\x8F\xF9\x1A\x01\x18\x44\xA4\x59\x77\x90\xE3\x8F\xBE\x32\x08\x06\x13\x9D\x73\x37\x43\xA9\x1F\xAA\x2B\x2A\x00\x52\x93\xFB\x2F\x0E\x9E\x7E\x9E\xD0\x2A\x22\xE0\x33\x77\x90\xFA\x8F\x63\x4F\x15\x91\x87\x84\xDD\x5D\x9A\x42\x00\xB4\x91\x82\x21\xCC\x2B\x20\x0D\x4A\x99\x73\x4A\x01\x79\x61\xFD\x75\x5D\x92\x40\x03\x96\x8D\x2A\x6F\x02\x39\xC3\x32\x8F\x37\x0E\x31\x15\x38\x46\x0A\x07\x8C\x91\x85\x02\x23\xBB\x8F\xA7\x57\x66\x92\xBF\x27\x19\x91\x7C\x81\x07\x64\x01\x52\x91\x64\x2C\x6A\x93\x20\x97\xFD\x2B\x06\x18\x46\xBD\x5C\x54\x91\x89\x91\xF7\x2E\x1C\x06\x1B\x9F\x7E\x34\x46\x90\x22\xC8\x2A\x79\x00\x72\x90\x78\x34\x1A\x95\x89\x88\xAA\x00\x02\x6A\x91\x7D\x32\x6A\x93\x26\x93\xE0\x17\x08\x10\x47\xBA\x22\xBD\x8A\xEF\x2C\x47\x02\x3D\x96\x36\x24\x8D\x87\x45\x88\x55\x15\x01\xFB\x90\x05\x24", + "\x35\x95\x15\x98\x5B\x3C\x04\x01\x24\xBC\x2A\xD4\x90\x59\x92\x41\x03\x14\x07\x90\x8A\xAD\x14\x23\xFA\x8F\x05\x22\x55\x01\x43\x90\xA9\x2A\x74\x16\xA7\x0A\x95\x79\x61\xCC\x6B\xC1\x0D\x03\x96\x9E\x42\x0B\x18\x48\xB1\x42\x4D\x10\x02\x02\x6A\x91\x00\x96\x23\x9E\x2F\x20\xBA\x13\x89\x07\x7C\xF9\x60\xC4\x24\x30\x03\xE4\x86\x92\x9B\x12\x50\x6B\x36\x01\x29\x92\x80\x28\x4B\x94\x02\x91\x0E\x58\x05\x31\x24\xFE\x10\x33\x92\x0D\x91\xA7\x4A\x17\x07\x93\x94\x48\x39\x24\xA0\x90\x79\x55\x9E\x90\x60\x17\x27\x95\x82\x81\xD5\x3E\x02\x42\x92\x02\x03\x62\x00\x51\x93\x05\x9B\xEF\x20\x06\x08\x25\x81\x02\xC6\x01\xA5\x91\x0C\x91\x54\x32\x0C\x0F\x4A\xB3\xEA\x52\x92\x36\x91\x50\x34\x31\x06\x2A\x98\x0C\x18\x4A\xBC\x20\xF9\x5C\xC6\x00\xAB\x91\x32\x00\x2B\x92\x84\x95\xE5\x16\x25\xCA\x01\x58\x92\x24\x91\x5F\x32\x19\x06\x95\x8B\x06\x18\x25\xEA\x90\x7D\x32\x66\x02\x55\x94\x19\x08\x95\x94\x42\x8C\x87\x4E\x01\x56\x93\x66\x00\x56\x92\x0B\x9D\x2A\x6D\x8A\x63\x5B\x4E\x01\x58\x92\x30\x90\x73\x42\x1A\x06\x95\x8F\x06\x23\x1C\xEB\x10\x66\x91\xA8\x8D\x3E", + "\x60\x2E\x98\x98\x8D\x43\x99\x97\x39\x91\xB6\x23\xC6\x92\xD8\x8D\x8D\x50\x99\x8A\x90\x12\x26\xE7\x8E\x14\x69\xCA\x90\x4F\x2A\x32\x9D\x87\x8F\xBF\x32\x03\x1A\x93\xAA\x2A\xC9\x93\x36\x90\x3C\x3A\x0F\x00\x4D\x88\x55\x12\x93\xE1\x90\x7D\x75\x5B\x65\x11\x98\x5B\x32\x4C\xA7\x23\xB8\x2B\x0A\x01\xD5\x91\x2C\x22\x32\x9D\x8E\x98\xAD\x12\x00\x32\x93\xFE\x24\xC9\x93\x3C\x95\xFB\x18\x9B\x84\xB3\x12\x26\xA1\x91\x05\x22\xBE\x60\xE7\x8D\x2F\x32\x99\x9E\x47\xB8\x56\x2A\x00\xBD\x93\x9E\x2E\x64\x94\x20\x9F\xFC\x12\x01\x09\x27\xEF\x2F\x92\x92\x85\x93\xE6\x3F\x39\x90\x9E\x32\x4C\x90\x24\xB6\x23\x42\x00\xEA\x91\x5F\x30\xE9\x2C\x70\x23\xC8\x0A\x01\x6D\x62\x4C\x63\x91\x8C\x77\x90\x8A\x37\x99\x40\x4F\x98\x2C\x62\x93\x34\x93\x45\x8E\x79\x91\x21\x02\x0D\x08\x4F\xBA\x24\xEF\x2D\x50\x01\xF5\x93\xD4\x16\x3D\x90\x94\x8A\x4D\x72\x27\xE1\x16\xF4\x93\xA2\x90\x73\x44\x0A\x07\x9F\x86\x5C\x39\x27\xCC\x92\xCB\x91\xFE\x91\x40\x06\x1A\x0F\x9F\x93\x4A\x8C\x87\x58\x00\x02\x94\x5C\x61\x81\x91\x2B\x9C\x1C\x5A\x02\x09\x28\xD8\x01\x0B\x95\xAF\x91\xAB\x64", + "\x0B\x09\xA0\x99\x06\x0B\x28\xE5\x92\x0A\x24\x2F\x01\x82\x92\x1B\x0B\xA0\x8A\x4B\xB6\xA9\x09\x94\xDB\x01\x05\x94\x5C\x95\x20\x22\x06\x09\x50\x9C\x03\x0B\x94\x76\x93\x3C\x5C\x19\x01\x41\x9D\x0D\x0B\x50\xBC\x25\xB7\x61\x66\x01\x04\x96\x37\x03\x41\x92\x98\x99\x73\x68\x01\x09\x94\xDF\x01\x91\x8C\xA1\x15\x17\x9D\x2A\x6A\x03\x2D\xC5\x6A\x92\x84\x14\x62\x93\x2D\x66\x0D\x0D\x16\x70\x4B\x84\x2A\x43\x88\xAD\x64\x3A\x01\x91\x91\x16\x24\xA8\x18\x4C\xBE\x4B\x7A\x00\x4B\x94\x7F\x24\xA1\x15\x33\x97\x59\x71\x52\xA4\x59\x0E\x15\xA9\x30\x43\x02\x95\x95\xE7\x24\xA8\x09\x4D\xBD\x65\x0C\x01\x5B\x95\xF7\x2C\xA1\x17\x35\x9F\xFC\x12\x8D\x5A\x1D\x87\x15\xC7\x76\x19\x39\x98\x90\x3C\x34\xA8\x1B\x4D\x87\xFD\x6B\x94\x7D\x32\x42\x14\x70\x96\x36\x24\x0A\x10\x53\x85\x44\x04\x15\xC6\x93\xE7\x1E\x2A\x06\x4E\x96\x1B\x24\x54\x0C\x27\x83\x1E\xB0\x00\x3E\x96\x82\x24\x50\x12\x9D\x82\x08\x36\x02\x02\x95\x3C\x2A\x42\x17\x75\x92\x41\x27\x1C\x67\x53\x8B\x23\x58\x8A\x7F\x55\x04\x94\x38\x00\xC1\x1E\x1D\x0C\x46\x11\x0D\x9E\x8E\x09\x95\x76\x00\xA5\x91\x2B", + "\x17\x18\x81\x07\x46\x03\x09\x94\xFA\x01\x14\x8F\x25\x13\x4F\x82\x3D\x69\x50\x88\x00\x4C\x18\xBB\x02\x66\x12\x7A\x73\x20\x3E\x1C\x63\xB7\x16\x00\x28\x95\x9C\x95\x5A\x69\xF9\x61\x41\x94\x02\x10\x55\x88\x25\x03\x02\x8F\x84\x65\x72\x33\x01\x41\x92\x03\x0C\x62\x15\x2A\x8A\x8B\x64\x2C\x68\x01\x82\x97\x07\x06\xAB\x95\x49\x33\xF1\x50\x35\xD2\x01\x04\x95\x13\x05\x58\x9F\xA8\x98\x2C\x9D\x9A\x54\x01\x09\x95\x2D\x00\xB3\x96\x2C\x18\x2A\x96\x27\x56\x03\x09\x94\x69\x01\x69\x97\xA8\x96\x55\x88\x0F\x89\x50\xB7\x01\x5A\x95\x2E\x12\x5A\x85\x2A\x32\x1B\x09\xA0\x85\x04\x20\x2B\xCC\x11\xB5\x8A\x65\x70\x37\x01\x41\x93\x09\x0C\x62\x3D\x06\x4C\x11\xBD\x8B\xF5\x3D\x82\x92\x14\x07\xAE\x82\x2E\xAF\x5B\x60\x01\x09\x94\x58\x02\xAF\x91\x56\x9D\x04\x44\x79\x49\x28\xBD\x01\xEE\x94\x7E\x97\xB5\x81\x54\x34\x0E\x09\x50\x8C\x03\x75\x95\xD6\x8B\x4E\x4E\x39\x03\x43\x98\xB0\x9B\x2E\x83\xB2\x09\x94\xE8\x01\x80\x97\xAD\x90\xE1\x55\x12\x89\x50\xB7\x03\x0D\x96\xE7\x8A\x68\x34\x3B\x01\x41\x95\x00\x0A\x5F\x29\x2A\xED\x8B\x03\x32\x77\x01\x82\x93\x02\x0A", + "\xBE\x0F\x57\xB3\x17\x80\x6E\xF0\x01\x04\x96\x08\x05\x64\x9C\xAF\x99\xD3\x5F\xD0\x09\x94\x31\x00\x96\x97\xC4\x94\x21\x49\x8A\x34\x07\x09\x28\xC0\x00\x32\x96\x63\x95\x8C\x85\xD3\x46\x0F\x09\x50\x8F\x01\x1E\x96\xFC\x94\x08\x8C\x73\x40\x1F\x09\xA0\x9D\x02\x00\x2D\xB3\x96\xFE\x74\x68\x36\x3E\x01\x41\x9B\x06\x07\x5A\xBA\x2C\xFE\x81\xAC\x42\x7E\x01\x82\x91\x0F\x0E\xB4\x8D\x56\xA4\x18\x81\x72\x09\x95\x43\x01\xD5\x94\x5A\x92\x25\x81\x07\x6F\xF1\x6B\x53\x39\x97\xE8\x12\x8C\x8C\x39\x42\x00\x18\xC3\x30\x25\x99\x13\x42\x94\x80\x6C\x02\x00\x0F\x3C\x9A\x8F\x7E\x19\x26\x48\x94\xB7\x60\x08\x00\xDB\x91\x16\x29\x99\x0E\x52\xA2\x6B\x73\x96\xFE\x25\xCC\x10\x95\x95\x2F\x30\x02\x18\x5B\xA1\xD6\x20\x65\xE1\x40\x14\x02\xDF\x95\xE7\x29\x99\x1E\x52\x85\x44\x7B\x63\xC3\x93\x82\x21\x66\x14\x4C\x93\xF0\x18\x01\x03\x2E\xEF\x2F\x99\x13\xDA\x93\xF3\x18\x08\x0F\xB8\x80\xCF\x19\x26\x6E\x94\x06\x02\x24\x01\xE5\x95\x2F\x39\x99\x13\x53\x8A\x48\x50\x00\x9B\x96\xC5\x95\xE5\x8F\x37\x51\xBA\x96\x8D\x19\x26\x7F\x94\x0C\x02\x30\x01\xE9\x92\x41\x29\x99", + "\x05\x54\x81\x04\x68\x00\xAB\x96\x9E\x29\x66\x13\x51\x9C\x53\x30\x03\x31\x2E\xAA\x2B\x58\x2F\x32\x84\x6B\x40\x0F\x08\x87\x28\x9C\x24\x02\x6A\x17\xDE\x03\xDC\x95\x9B\x81\x1C\x4A\x07\x1D\x5D\x91\x1B\x40\x97\x48\x27\xB3\x88\x73\x44\x0F\x06\xBC\x80\x42\x1B\x2D\x81\x02\xC2\x97\xC7\x83\x40\x36\x0F\x0D\xBC\x82\x56\x4F\x2F\x80\x00\xD1\x96\xC1\x6C\x6B\x40\x10\x05\xBD\x8D\x60\x17\x2F\xD9\x97\x7A\x7E\x65\x72\x20\x05\x7B\x92\x10\x08\x07\x1F\x2F\x83\x8B\xDB\x7E\xF2\x95\x40\x06\x1E\x08\xBC\x8F\x9A\x00\x2B\xBD\x2E\x86\x00\xF5\x96\x41\x24\x03\x4B\x1B\x19\x5E\x85\x0E\xBD\x2E\x88\x00\xF9\x95\x04\x04\x7E\x99\xBC\x8E\x56\x99\x63\x72\x97\x1F\x00\xFE\x96\xFB\x95\x5A\x9A\x2F\x72\x5F\xAD\x00\x02\x98\x06\x03\xEC\x97\x69\x8F\x1C\x32\xBF\x9B\x01\x08\x30\x83\x02\xD9\x96\xD7\x88\xF9\x8A\x7E\x99\x04\x0F\x60\x89\x25\xAB\x87\xAD\x64\x49\x02\xFC\x97\x0A\x0C\x01\x5D\x0D\x19\x2F\xF1\x95\x06\x03\x7A\x67\xB8\x2E\x0C\x06\xC1\x90\x5E\xB6\x2B\x83\x32\x96\x00\xF9\x94\x1D\x04\x03\x41\xBC\x90\x16\x8A\xE3\x18\x01\xF2\x97\x40\x01\x07\x9D\x7F\x95\x3C\x8F", + "\xB7\x1A\x02\x72\x97\x90\x01\x12\x98\xF6\x93\x79\x87\x33\x72\x5F\x9E\x02\x3A\x98\xD9\x96\x7D\x70\x73\x46\x13\x02\xBF\x8C\x05\x33\x30\x83\x98\xEC\x85\x4E\x4C\x28\x02\x7E\x9B\x0B\x00\x62\x8F\x08\xCC\x43\xA2\x00\xF9\x95\x32\x06\x89\x9F\xFE\x6C\x0D\x64\x02\x72\x97\xD7\x01\x23\x99\x02\x9F\x64\x9A\x8C\x66\x05\x32\x2F\xE6\x01\x5A\x98\x08\x98\x37\x85\xD3\x48\x0A\x12\x5F\xB5\x03\x61\x98\x17\x98\x15\x87\x2D\x62\x15\x02\xBF\x84\x00\x24\x3F\x1E\x98\x08\x8C\x80\x6C\x2B\x02\x7E\x93\x01\x04\x7F\x35\x2F\xB7\x84\xCC\x42\x57\x02\xFC\x91\x04\x06\xC7\x94\x61\x97\x18\xE1\x41\xB0\x00\xF9\x97\x0B\x05\x8F\x98\xC4\x90\x5A\x9C\x24\xF2\x97\x3D\x00\x42\x9B\x16\x9A\x83\x81\xAA\x34\x05\x32\x2F\xCB\x00\x8A\x98\x31\x9B\x8A\x8F\x2D\x32\xBF\x99\x02\x2F\x31\x8C\x02\x47\x15\x45\x9A\xBB\x88\x0F\x3C\x5C\x60\xA2\x7F\xF1\x1D\x36\x9C\x99\x58\x22\x03\x5A\x93\x84\x59\x61\x65\x9E\x0A\x82\x0A\x93\x5C\x53\x98\x99\x2A\x50\x16\x4A\x81\x07\x7C\x02\x2A\x99\x3D\x2E\x01\x6A\x3F\x8E\x9E\x4D\x0B\x10\x65\x8F\x21\x8E\x8C\x26\x70\x5B\x98\x78\x32\xEF\x2D\x6D\x81\xD5", + "\x7A\x32\xFD\x32\xC2\x49\x82\x8E\xED\x67\x97\x95\x10\x20\x58\x15\x24\x83\x85\xC4\x98\xDB\x22\x99\x5B\xF0\x00\xCA\x29\x66\x8A\x48\x3F\x16\x20\x92\x7B\x4B\x30\x06\x99\x9E\x99\x3E\x42\x2C\x86\x44\x01\xD4\x98\xD5\x28\x87\x4B\x3C\x9C\x1A\x45\x06\x19\x33\xC8\x2A\xED\x55\x4C\x9A\xA7\x97\x9B\x98\x5B\x2D\x57\x4C\x23\x5F\x2E\xE4\x99\xE7\x1F\x1A\x24\x47\x97\x0B\x68\x06\x38\x61\x09\x76\xA9\x17\x61\x91\xB0\x40\x0F\x3D\xAF\x6B\x83\x30\x2D\x80\x6E\xD0\x00\x7A\x99\x2C\x23\x0D\x26\xB7\x9D\xB9\x15\x03\x7A\x99\xFE\x25\x35\x23\xDE\x95\x20\x2A\x0D\x00\x68\x88\x12\x80\x97\xD0\x74\x83\x9A\x3F\x98\x28\x84\x28\x6A\x68\xAF\x5F\x6B\x20\x8C\x97\x54\x1A\x43\x98\x3C\x3B\x06\x32\x5C\x83\x3C\x6E\x01\x13\x9B\xBE\x33\x1A\x20\x73\x94\xDD\x19\x68\x85\x44\x6B\x20\x9E\x96\x9E\x28\x3E\x06\xA3\x96\x1B\x2B\x83\x39\x29\xEB\x36\x24\x9A\x05\x27\x1A\x20\x75\x9D\xF5\x03\xC3\x35\x33\xF3\x89\x78\x86\x97\x9B\x3E\x9C\xF4\x87\x0B\x6C\x00\x32\x34\xFE\x25\x63\x20\xD5\x8D\xA7\x49\x02\x03\x86\x2C\xAE\x79\x34\xAF\x8F\xAC\x42\x09\x03\x18\x30\x9E\x9B\x25\x32\x43\xA0", + "\x19\xC3\x9A\xB1\x21\x9F\x9A\x87\x7F\xDD\x28\x01\x08\x6A\xB8\x34\x81\x15\x0A\x3A\xA7\x98\x99\x2A\xA9\x91\x98\x70\xD6\x1E\x00\x52\x9A\x3D\x2E\xAA\x9A\x61\x75\x37\x68\xD5\x8F\xBF\x1A\x35\x91\x9A\x09\x02\x12\x01\x57\x98\x3C\x3A\xD5\x96\x68\x8C\x04\x27\x00\x63\x9B\xBE\x32\x56\x9C\xA3\x93\xC2\x29\x6B\x85\x44\x5A\x9A\x21\x9A\xD2\x36\x5B\x9E\x36\x2A\xD5\x87\x69\x8C\x04\x30\x00\x73\x9A\x05\x26\x56\x9C\xA5\x9A\xE2\x19\x6B\xBC\x54\x5A\x9A\xAE\x96\x00\x02\x0D\x06\xAF\x9A\x5A\x3A\x6A\xB4\x2E\xAA\x2B\x50\x67\xE5\x45\x5F\x31\x7C\x1C\xCE\x80\xB8\x7C\x00\x3D\x9A\xC8\x39\x85\x89\x19\x7C\xB0\x98\x54\x21\x5F\x37\x33\xCA\x71\x40\x00\xCA\x98\x6E\x29\x7C\x1D\xCF\x84\x0A\x5A\x36\xCF\x1F\xE1\x17\x81\x9A\x6D\x26\x08\x0F\xD9\x83\x78\x21\x2F\x23\x93\x7D\x33\x24\x01\x69\x9F\x7C\x1B\xD5\x8C\x0D\x4C\x01\x2B\x9B\xDC\x16\x52\x14\xB4\x37\x09\x00\xDB\x88\x5E\x08\xEE\x0E\x42\xB5\x9B\x30\x24\x99\x8C\x39\x45\x05\x19\x6D\x84\x2F\x06\x16\xB8\x6C\xDF\x9B\xF4\x13\x74\x9E\x2F\x3B\x02\x02\x37\xB8\x61\x99\x8E\xD6\x42\x17\x07\xB8\x91\xBE\x01\x6C\xA1\x01", + "\x4C\x9B\x34\x9A\x80\x6F\xD9\x62\xB1\x95\x10\x35\x8E\x36\x36\xB9\x4E\x90\x9A\x7F\x26\x88\x38\x69\x80\xA7\x23\xC3\x08\x4E\x68\x00\xE4\x1E\xEF\x02\x88\x3F\x52\x99\xE7\x4A\x03\x1E\x37\xF2\x60\xE1\x9A\xA5\x78\x9D\x84\x6F\x77\xDE\x9D\xF3\x11\x32\xD6\x78\x60\x86\xD6\x42\x1B\x05\xBD\x96\x5A\x4F\x6F\xB2\x2A\xDA\x97\xF6\x48\x38\x00\x7D\x9D\x26\x26\xDF\x80\x0D\xA1\x2F\xB1\x21\x72\x01\xFD\x9A\x40\x01\x2F\x2C\x2D\x02\xF1\x39\x2A\x96\x60\x02\x9D\x35\x91\x7A\x9C\xAF\x8B\x03\x69\xC5\x36\x01\x09\x9C\xB3\x75\xFE\x9A\x88\x3F\x7E\x9E\x2B\x70\x70\x95\x03\x12\x9C\xA3\x84\xE6\x42\x1E\x00\xC2\x9B\x29\x25\x70\x9E\x16\xD9\x65\x10\x9D\x6F\x26\x87\x98\xD7\x77\xE0\x30\x70\x95\x4C\x23\x9C\xBE\x7C\x07\x3C\x84\x9E\x6C\x28\xE2\x83\xF6\x4F\xD4\x10\x9C\xAE\x27\xCC\x06\x88\x38\x84\x93\x10\x04\x04\x10\x38\x81\x28\x2D\x9C\x81\x01\xB2\x80\xE0\x66\x08\x10\x70\x80\x51\x4A\x07\x22\x3C\x91\x6C\x6B\x40\x11\x00\xE1\x9C\xA3\x32\x38\xA9\x6E\xFB\x3C\x45\x00\x84\x9E\x97\x29\xE3\x81\x08\x1E\x0B\xCC\x43\x8C\x00\x08\x9D\x3E\x2D\xC9\x90\x00\x02\x62\xB9\xB9\x7C", + "\x66\xE3\x2C\xA2\x2B\x91\x99\xBC\x81\xAA\x30\x04\x10\x38\xFF\x00\x3A\x27\xDD\x02\x88\x38\x7C\x8B\x00\x90\x70\x8D\x02\x61\x9C\x4A\x7A\x0B\x85\xA8\x34\x12\x00\xE1\x9B\x04\x3A\x4C\x3D\x03\x22\x3C\xAA\x6C\x0A\x98\xC2\x9A\x0A\x0F\x73\x8A\xF5\x2E\x96\x79\x5C\x4C\x00\x84\x99\x17\x06\xE7\x8C\x70\xBA\x0F\xE1\x41\x9A\x00\x08\x9C\x32\x05\xCF\x9C\xBF\x1F\xDB\x5D\x9A\x03\x67\xE3\x2D\x6B\x00\x9A\x9E\xCF\x93\x0D\x29\x11\x50\x38\xE5\x01\x8B\x9D\x42\x9C\x4B\x65\x68\x60\xE1\x93\x07\x11\x3A\xE3\x47\x44\x85\x77\x2E\x28\x00\xC2\x91\x00\x0B\x08\x62\x39\xA5\x80\x9D\x4C\x52\x00\x84\x9F\x01\x0E\xE9\x8A\xEA\x61\x10\xB7\x61\xA6\x00\x08\x9D\x07\x03\x21\x4D\x1B\x00\xBD\x28\x7F\x60\x33\xA8\x00\x08\x9C\x0B\x03\x21\x4E\xF2\x00\xBD\x1F\x76\x64\x6F\x10\x9D\x16\x00\xAD\x9C\xD3\x47\x6F\x81\xD5\x2C\x02\x10\x9C\x2E\x01\x5D\x9F\x01\x1F\x3D\x93\x90\x2E\x05\x10\x38\xAF\x00\xC2\x9C\xD9\x84\x31\x31\x54\x30\x0B\x10\x70\xB0\x00\x49\x9D\x0F\x18\x9B\x05\xC3\x28\xC2\x91\x03\x10\x76\x93\x30\x44\x3B\x07\x7C\x08\x9E\x0C\x06\xDA\x95\xC1\x1D\x38\xB9\xB9\x36\x01", + "\x10\x9D\x19\x00\xB7\x99\x4E\x2F\x94\x3A\x9C\x50\x38\xB4\x00\xE3\x9C\xD0\x2E\x84\x90\x13\x80\xE1\x95\x01\x29\x3B\xB3\x8E\x1F\x70\x08\x9E\x0D\x07\xDD\x98\x73\x8C\x0E\x7E\x02\x10\x9C\x37\x00\x7A\x9E\xCF\x8C\x05\x7E\xE3\x9A\x77\x84\x1D\xCC\x43\xC2\x00\x08\x9D\x0E\x06\xDF\x9A\x74\x81\x07\x44\x03\x10\x9C\x3A\x00\x82\x9C\xD4\x8E\x53\x90\xE1\x9B\x01\x23\x3B\xB1\x18\xC1\x5D\x77\x2C\x32\x01\xBB\x94\x66\x31\x61\x0F\xB2\x3B\x39\x14\x9F\x9E\x2E\x13\x1B\xCC\x71\xAA\x2A\x06\x26\x38\xB6\x23\x1B\x9E\xB0\x88\x73\x44\x19\x0F\xF1\x8A\x90\x21\x3C\xF3\x7C\x9D\x4C\x67\x00\x84\x9C\x07\x03\xEE\x87\x79\xBB\xF9\x45\x8E\x10\x9D\x1E\x01\xCB\x9F\x32\x89\xE7\x52\x06\x10\x38\xBE\x00\x33\x9E\x46\x9E\x3D\x4C\x1A\x00\xE1\x9F\x01\x39\x3C\x86\x02\x07\x9C\x9C\x99\xC9\x9C\xA7\x2E\xF2\x8D\x82\x7F\xE1\x10\x9C\x40\x01\x9F\x9E\x4B\x73\x5C\x90\xE1\x81\x02\x0A\x3D\x82\x02\x8E\x86\x75\x94\x84\x9A\x08\x0F\xF4\x8C\xB2\x1A\xB1\x10\x9C\x43\x01\xAA\x9E\x69\x89\x15\x30\x0E\x10\x70\x84\x01\x5A\x9E\x12\x99\xBE\x32\x38\x05\xC8\x9A\xF5\x89\x57\xB1\x42\x64\x01\x10", + "\x9C\x23\x03\x42\x43\xAB\x8A\xEC\x61\xD5\x26\x03\x10\x9C\x48\x00\xAD\x9F\x8E\x9A\x19\x78\x0E\x03\x7A\xAA\x56\x45\x9E\xFD\x94\x45\x58\x84\x99\x09\x0B\xF6\x8C\x08\x38\x3D\x83\x96\xCC\x42\x76\x00\x84\x9B\x09\x0A\xF5\x8F\x72\xB9\xB9\x6E\x01\x10\x9C\x26\x02\xD6\x9E\xCA\x9D\x2A\x70\x07\x10\x38\xCD\x00\x7D\x9F\x7A\x5D\xF8\x7F\x83\x60\xE1\x8F\x02\x1A\x3D\xE4\x9C\x79\x5D\xD5\x67\xB8\x28\x0A\x0A\xF5\x8A\x73\xA9\xE3\x10\x9C\x51\x01\xC8\x9E\x41\x00\xEF\x92\xE7\x81\xD5\x38\x03\x10\x9C\x53\x00\xD1\x9F\x40\x00\xEF\x98\xE7\x8A\xA1\x50\x38\xD5\x00\xAA\x9E\x81\x00\xDE\x9C\x1C\x8C\x1C\x5C\x07\x10\x38\xD7\x00\xB1\x9F\x26\x19\x1C\x9A\x19\x7E\x0F\x10\x70\x99\x01\x5A\x9E\x42\x96\x26\x7D\xD6\x30\x71\x2A\x05\x1A\x7A\xB2\xEA\x6F\x2D\x02\x01\xE1\x9D\xA3\x22\xEB\x91\xB2\x6F\xB7\x04\x00\x4A\x9F\x73\x86\xAD\x9E\xCB\x81\x54\x36\x00\x10\x7E\x84\x7E\x5A\x9E\xA7\x9C\xB5\x96\xF5\x99\x85\x29\xFB\x8C\x27\x50\x2A\xC1\x68\xDB\x9F\x22\x33\xB8\x98\x69\x84\xDE\x8D\x95\x4C\x00\x61\x9F\x01\x03\x30\x03\xF8\x9A\x79\x99\xE7\x4E\x00\x28\x3F\x80\x00\x62\x01", + "\xEE\x9C\xD2\x87\xD7\x63\x90\x30\x00\x2F\x3F\xE4\x00\xF2\x9E\x9A\x9F\x4E\x87\xFD\x96\x06\x19\x7F\xBA\x3C\x9D\x4D\x14\x01\xF7\x9C\x1A\x06\xFF\x90\xF4\x8B\xA2\x6F\x3F\xEA\x00\xEB\x9E\xBF\x84\x6B\x40\x03\x0F\xFE\x8B\x03\x04\x40\xCB\x9E\xD0\x34\x0D\x03\xFB\x9D\x0D\x0F\x00\xB0\x7A\xA9\x62\x1C\x00\xEF\x9F\x37\x01\x05\xA6\xEA\x96\xD5\x8F\x7F\xB1\x01\x1B\xA0\x5B\x9E\x68\x34\x08\x07\xFD\x93\x07\x00\x81\xA1\x3D\xC1\x93\xEF\x9F\x3A\x00\x08\xA6\xEC\x9E\x2F\x24\x01\x2F\x3F\xF7\x00\x0B\x42\x7B\x20\xD2\x84\xC6\x9B\x3E\x2F\x7F\xBA\x01\x20\xA0\x73\x9F\x58\x20\x0A\x07\xFD\x9C\x07\x09\x80\x89\x17\x9D\x4D\x2A\x01\xF7\x9D\x1F\x01\x06\xAF\xFD\x80\x7C\xB9\xB9\x2C\x00\xEF\x9E\x40\x00\x08\xA6\xF0\x9D\x2A\x6E\x01\x2F\x3F\x82\x01\x20\xA0\xC6\x9F\x2D\x60\x06\x0F\xFE\x84\x04\x04\x41\xF0\x65\xD8\x87\x77\x2E\x0C\x07\xFD\x97\x08\x00\x81\x98\x3E\xAD\x65\x34\x01\xF7\x9D\x22\x00\x04\xAE\xF9\x99\x73\x76\x00\x6F\x9F\x8B\x01\x2B\xA2\x5D\x83\xEA\x63\xEB\x58\x01\x2F\x3F\x8E\x01\x6A\xA0\xDD\x94\x9E\x76\x2A\x5F\xFE\x91\x04\x31\x41\xC7\x86\x0E\x86\x7B", + "\x48\x0F\x07\xFD\x94\x09\x17\x83\xA7\xDA\x06\x9D\xE2\x7D\xF7\x9F\x25\x00\x04\xA1\xFC\x8D\x95\x40\x01\x6F\x9F\x99\x00\x10\xA3\xF1\x9B\x20\x32\x04\x0F\x7F\x9B\x02\x20\xA0\xCD\x9F\x81\x30\x11\x07\xFD\x9D\x09\x00\x81\x93\x3F\xCC\x43\x46\x01\xF7\x9F\x27\x00\x04\xA9\xFD\x8A\xC6\x48\x01\x6F\x9F\xA1\x00\x3F\xA0\x00\x02\xC6\x34\xC8\x10\x91\x59\x6D\x7D\x75\x39\x4C\xEE\x98\xDE\x57\xFD\x94\x0A\x03\x77\xB9\x98\x65\x9F\xB7\x61\x28\x03\xFB\x9D\x14\x0E\x0A\xAC\x7F\xAD\xCA\x53\x00\xEF\x9E\x53\x01\xF7\x99\xC7\x44\xFF\x81\xD5\x15\x01\x6F\x9F\xA8\x01\x5D\xA2\xFE\x9F\x16\x67\x05\x0F\x7F\xAA\x02\x42\xA1\xFF\x9F\x77\x2D\x16\x07\xFD\x9C\x0A\x08\x86\x85\x40\x8A\x4E\xEF\x9E\x57\x01\x2D\xA2\x01\xA6\x4F\x5D\x02\x2F\x3F\xAF\x01\xCE\xA0\x08\xA2\xEB\x57\xFD\x91\x0B\x19\x86\x96\x40\xD0\x35\x61\x01\xF7\x9F\x2C\x06\x1B\xAC\x01\xBC\x5D\x6F\x3F\xB5\x01\xE4\xA1\x10\xA1\x2C\x4F\xFD\x97\x0B\x09\x87\xA7\x40\x88\x56\xEF\x9F\x5C\x01\x3A\xA4\x05\xA4\x66\x29\x03\x2F\x3F\xBB\x01\xA2\xA1\x1C\x4C\x0D\xA1\x20\x0B\x06\x0F\x7F\xBE\x02\x69\xA1\x39\xA0\x7F\x25", + "\x1B\x07\xFD\x90\x0C\x13\x86\xBF\x40\xEF\x2D\x6F\x01\xF7\x9D\x30\x01\x1F\xA8\xE4\x81\x07\x71\x01\x6F\x9F\xC4\x01\x74\xA0\x13\xA7\x16\x63\x07\x0F\x7F\x86\x03\x69\xA1\x52\xA0\x80\x6D\x1D\x07\xFD\x98\x0C\x0C\x88\x9C\x39\xCC\x43\x77\x01\xF7\x9F\x32\x01\x1D\xAF\x05\xB7\x85\x79\x01\x6F\x9F\xCD\x01\x74\xA1\x19\xA5\x55\x6B\x07\x0F\x7F\x8F\x03\x1E\xA2\xC4\x7A\x24\x5F\xFB\x9A\x1A\x00\x13\xA8\x18\xA1\x83\x7F\x00\xEF\x9F\x6A\x01\x4D\xA3\x1C\x89\x8A\x21\x04\x2F\x3F\xD8\x01\x3B\xA2\xC8\x75\xB2\x37\xFD\x9B\x0D\x09\x87\x85\x42\xB7\x61\x85\x01\xF7\x9D\x37\x01\x1D\xAB\x08\xA1\xD5\x07\x02\x6F\x9F\xDF\x01\x74\xA1\x24\xA1\x54\x39\x08\x0F\x7F\xA1\x03\x69\xA1\x97\xA1\x3C\x5F\x22\x07\xFD\x93\x0E\x09\x87\x9D\x42\xB1\x21\x8D\x01\xF7\x9D\x39\x02\x14\xA6\x1E\x36\x63\x10\x6B\x0F\x01\xA7\xA1\xEF\x77\xF7\x9F\xDD\x24\x09\x0F\x7F\xA8\x03\x63\x9D\xA6\x2E\x91\x9D\x9E\x5E\x12\x0F\xFE\x89\x07\x30\x45\xB6\xA1\xB7\x60\x4C\x03\xFB\x9A\x1D\x0D\xFD\x91\x8B\xAE\x15\xA1\x35\x9A\x01\xF7\x9C\x3B\x05\x2F\xA3\x0C\xA0\xB8\x7A\xD2\x63\x2D\xEE\x00\xC2\xA1\x32", + "\xA2\x75\x7F\xFE\x90\x07\x0A\x46\xCF\xA1\x40\x81\xF7\x9E\x3C\x07\x2E\xA4\x0D\xBD\x34\x62\x02\x6F\x9F\xF3\x01\xC7\xA2\x36\xA1\x1C\x44\x0A\x0F\x7F\xB5\x03\x1A\xA3\xDF\xA1\x7D\x3E\x29\x07\xFD\x97\x0F\x00\x8D\xA5\x43\xE4\x66\xEF\x9F\x7C\x02\x69\xA2\x1D\xA1\x0E\x42\xA6\x5B\xA8\x2B\xA3\xEF\xA0\x05\x24\x2B\x07\xFD\x9D\x0F\x0B\x8D\xB4\x43\xBD\x2E\xAE\x01\xF7\x9F\x3F\x02\x14\xAE\x17\xB7\x76\xBB\x7B\x30\x01\xEF\x9E\x01\x03\xF1\x44\x11\x57\xC2\x81\xD5\x32\x02\x6F\x9F\x04\x01\xE3\x46\xCB\x1D\x37\xAA\xEB\x47\xF0\x6F\x3F\x85\x00\xC7\x46\x7B\x20\x73\xA0\x00\x06\x04\xAD\x95\x76\x02\x6F\x9F\x08\x01\xE1\xA0\x24\x1C\x87\x99\xE7\x58\x05\x2F\x3F\x8A\x00\xDA\xA3\x84\x03\x74\xA1\x23\xAA\x8C\x7A\x05\x2F\x3F\x8C\x00\xD1\xA3\xED\xA3\x47\xA1\xCF\x5C\x0B\x0F\x7F\x8F\x00\x61\xA3\x06\x03\xE9\xA1\x49\xA0\xE0\x6E\x0B\x0F\x7F\x91\x00\x70\xA3\x03\x03\xE9\xA3\x4A\xA7\x16\x60\x0C\x0F\x7F\x93\x00\x69\xA3\xE2\xA2\x2E\x98\x93\x97\xFD\x96\x01\x00\x90\xB1\x47\xE3\x98\xBA\x81\xF7\x9D\x06\x06\x40\xA9\x1F\xB9\x83\x9D\x9A\x46\x01\xEF\x9E\x0E\x00\x83\xA2", + "\x20\x03\x1D\xB1\xE7\x45\xAA\x6F\x9F\x1F\x00\xFC\xA0\x85\xA0\x8F\x99\xE7\x4A\x06\x2F\x3F\xA1\x00\x1A\xA5\x80\x03\x74\xA5\x29\xA3\xF2\x8F\x7F\xA3\x00\x21\xA4\x00\x01\xE9\xA3\x54\xA7\x2E\x9F\xFE\x85\x01\x28\x48\xD3\xA3\x59\xA3\xBE\x93\xFB\x9F\x04\x0F\x22\xB3\x19\x83\x26\xEF\x9F\x29\x01\x09\xA5\x40\x04\x3D\x26\x16\xB1\x3A\xA9\x45\xD6\x75\x6B\xA3\x81\x31\x36\x07\xFD\x9C\x02\x0A\x8E\x94\x32\x0C\x19\xA9\x55\xF7\x9D\x0B\x06\x48\xA9\x10\x1F\x8F\x37\xF4\x7B\x3D\xDD\x01\xF7\x9E\x0B\x00\x45\xAE\x24\xBF\x8B\x8C\x87\x5F\x01\xEF\x9E\x18\x00\x95\xA5\x30\xAA\x8C\x7C\xA6\x63\x5B\x32\x00\x5B\xA5\xC5\xA1\xA8\x33\x1C\x0F\xFE\x94\x01\x21\x49\x90\xA3\xE1\x41\x72\x03\xFB\x9E\x06\x0C\x24\xAA\xE2\x6F\x2F\xEF\x2F\xE7\x01\xF7\x9F\x0D\x07\x4C\xAB\x19\xB5\x87\x6F\x3F\xB9\x00\x74\xA5\xD0\xA1\x38\x43\x1D\x0F\xFE\x9B\x01\x39\x49\xA7\xA3\x44\x47\xF7\x9D\x0F\x07\x4F\xAC\x1A\xAC\x0D\x61\xD3\x63\x2D\x3F\x00\x42\xA5\x6C\xA4\xA7\x21\x0F\x0F\x7F\x81\x01\x04\xA5\xB7\xA3\xF7\x2F\x3C\x07\xFD\x93\x04\x1A\x91\x80\x00\x55\xA4\xBE\xA3\x70\x41\x3D\x07\xFD", + "\x96\x04\x04\x94\x81\x44\xE4\x2C\xF7\x01\xF7\x9C\x12\x05\x4D\xA3\x10\x18\x94\x8D\x47\xAD\x62\xEF\x9F\x24\x02\xA5\xA6\x54\xA4\x1D\xA8\xFE\x2F\x3F\xCC\x00\x84\xA5\x89\xA0\xC0\x68\x9D\x63\x6E\x2E\x02\x04\x4A\xE4\xA3\xA0\x2B\xF7\x9C\x14\x03\x55\xA3\xF9\x99\x73\x41\x00\x10\x32\x88\x27\x29\x00\xA1\xA3\x3E\xAA\x8C\x63\x00\x00\x4B\xFC\x49\x84\xA5\xFD\xA0\xC0\x6D\x00\x07\x2C\xA9\x08\x17\x01\x3C\xA5\x1C\x85\xB0\x61\xB3\xA1\xCA\x40\x2D\xBD\xFF\x5A\xBE\x53\xA5\x03\x03\x2E\x01\xB5\xA7\xCF\x9C\x1A\x4D\xA7\x63\x5B\x60\x00\xDB\xA4\xC6\x74\x5E\x60\x5B\xA5\x74\x64\x94\x87\x45\x80\x6E\x0F\x00\x72\xA5\x40\x05\x0C\x04\x28\xA4\x91\xB9\xB9\x11\x00\xEA\xA5\x3E\x38\xA1\xA3\x45\xA9\xE7\x53\x00\x31\x4B\xE9\x00\x84\xA5\x18\xA7\x2D\x65\x02\x01\x2F\xAB\x03\x04\x4A\xDF\xA2\xFE\x25\x0B\x01\xBC\xA5\x0D\x06\x29\xB2\x8F\x25\x42\xDE\x47\x10\x32\xB8\x91\x62\x52\x15\xAC\x3C\x91\x97\xB0\x01\x24\xA5\x02\x03\xC4\x50\x2C\xA0\xE0\x61\x02\x11\x97\xB1\x01\x10\xA6\x51\x7A\xB2\x7F\x45\x39\x5E\xA2\x07\x08\x91\x89\xA6\x3D\xA1\xCC\x43\x12\x01\xBC\xA4\x0E\x0E", + "\x31\xBC\x92\xB1\x42\x27\x00\xF1\xA4\x3B\x01\xC9\xA2\x4C\xAC\x1C\x49\x01\x31\x4B\xF8\x00\x2B\xA6\x34\xA4\x6B\x43\x05\x01\x2F\xBA\x03\x18\x4C\xBD\x69\x95\xA3\x77\x2D\x0B\x01\x5E\xAB\x07\x11\x99\xB5\x49\xF6\x49\x2F\x01\x78\xA5\x1F\x06\x67\xAA\x27\xAC\x0D\x71\x00\x71\xA5\x7F\x00\xA2\xA4\xA0\xA6\x9E\x43\x03\x11\x97\x81\x02\x4A\xA6\x85\xA4\x7B\x48\x41\x6B\xDC\x23\x08\x10\x9A\x8B\x4A\xAA\x2B\x37\x01\x78\xA5\x21\x00\x6A\xA1\x29\xA0\xCF\x39\x00\x71\xA5\x87\x00\x4B\xA5\x62\x53\x1F\xA9\x31\x31\x97\x8A\x02\x50\xA6\x9F\xA5\x9E\x2D\x0F\x01\x5E\xAC\x08\x17\x99\x89\xA6\x42\x9C\xF6\x49\x1F\x01\xBC\xA5\x11\x02\x36\xAD\x88\xAC\x86\x41\x00\xF1\xA4\x48\x00\xD4\xA2\x56\xAA\x8C\x63\x02\x31\x4B\x92\x01\x50\xA6\x5C\xA6\x48\x29\x5E\xA4\x09\x15\x9B\xAB\x47\xAD\x65\x47\x01\x78\xA7\x25\x00\x6A\xA4\x2C\xB1\xE4\x71\x4B\x99\x01\x50\xA6\x65\xA6\x32\x73\x09\x01\x2F\xBB\x04\x06\x4E\xB1\xA2\x85\x8D\x78\xA6\x27\x07\x72\xA6\x13\xBF\x36\x71\x4B\xA1\x01\x9C\xA6\x9E\xA0\x7C\x59\x5E\xA4\x0A\x01\x9D\x82\x45\xD0\x35\x53\x01\x78\xA7\x29\x00\x6A\xA7\x2E", + "\xAA\xC6\x55\x01\x71\xA5\xA9\x00\xA8\xA6\xBB\xA5\x55\x67\x05\x11\x97\xAB\x02\x50\xA6\xF4\xA5\x56\x65\x16\x01\x5E\xAD\x0A\x10\x9A\xBA\x4B\x80\x6E\x5B\x01\x78\xA7\x2B\x00\x6A\xA0\x30\xA4\xB3\x1D\x01\x71\xA5\xB1\x00\x4B\xA5\x7E\x25\x47\xA0\xE2\x50\xC8\x3D\xEB\x26\x19\x70\x19\x54\x30\x19\x00\x22\x3C\x5C\x6A\x5C\x53\x47\xF2\x79\xD4\xA7\x58\x22\xE2\x57\xD5\x9D\x97\x26\x03\x31\x4B\xB4\x01\x37\xA6\xC5\x57\xAD\x9D\x55\x68\x06\x11\x97\xB5\x02\x61\xA7\xE9\x93\xC0\x7D\xBC\xA6\x16\x08\x3E\xA4\x76\x86\xD3\x71\xA5\xB7\x01\xF6\xA5\x7D\x91\xCF\x5E\x06\x11\x97\xB8\x02\x72\xA7\xFA\x93\x3C\x5C\x1C\x01\x5E\xA9\x0B\x18\x9F\x80\x28\x99\x54\xF1\xA4\x5D\x02\xFF\xA6\x40\x99\xE7\x54\x03\x31\x4B\xBB\x01\x03\xA8\x06\x95\x9E\x5E\x0E\x01\x2F\xBC\x05\x09\x50\xEB\x9D\xB5\x73\x78\xA5\x2F\x01\x81\xA8\xA1\x9C\xA9\x3A\x01\x71\xA5\xBE\x01\x04\xAA\x87\x96\x36\x2C\x07\x11\x97\xBF\x02\x09\xA8\x23\x95\x3B\x69\xBC\xA0\x18\x09\x40\xA9\x51\xAD\xCA\x00\x01\xF1\xA5\x60\x01\x02\xAF\x45\x90\x70\x62\x04\x31\x4B\xC2\x01\x09\xA9\x1A\x95\xAB\x64\x10\x01\x2F\xA3", + "\x06\x37\x4C\xAC\x2F\x72\xA1\x4E\x4E\x21\x01\x5E\xA4\x0C\x17\xA1\x88\x49\xE3\x73\xF1\xA5\x62\x02\x0F\xAE\x79\x4F\xE2\x31\x97\x86\x03\x28\xA4\x38\xA9\x97\x9C\x94\x99\x5E\xA8\x0C\x08\xA2\xA6\x4C\xBD\x75\xF1\xA4\x65\x02\x13\xAC\x65\xA9\xE7\x50\x04\x31\x4B\xCC\x01\x53\xA8\x99\xA7\x51\x69\x5E\xAE\x0C\x03\xA2\x8D\x38\x91\x80\xF1\xA5\x67\x01\x16\xAF\x67\xAD\x69\x56\x04\x31\x4B\xD1\x01\x63\xA9\xA2\xA6\x3D\x48\x13\x01\x2F\xB3\x06\x29\x51\xCB\xA6\x62\x6B\x78\xA5\x35\x07\x8D\xA1\x35\xA7\x74\xB1\x4B\xD7\x01\x74\xA9\xAB\xA4\x52\x2E\x13\x01\x2F\xB9\x06\x34\x51\xDD\xA6\x7D\x32\x50\x01\xBC\xA3\x1B\x06\x29\xA9\xA2\x9D\x3B\x86\x3D\xF1\xA4\x6F\x00\x1D\xA9\x6D\xAF\x7E\x24\x05\x31\x4B\xE0\x01\x5E\xA8\x1B\x43\xAC\x5E\x14\x01\x2F\xA1\x07\x05\x52\xF6\xA6\xF6\x48\x54\x01\xBC\xA4\x1C\x04\x47\xBC\x9B\xB1\x42\x2A\x01\xF1\xA4\x73\x00\x1D\xAA\x70\xA4\x66\x2C\x05\x31\x4B\xE8\x01\x97\xA9\xC3\xA7\x2D\x66\x15\x01\x2F\xAB\x07\x34\x51\x8D\xA7\xFE\x24\x58\x01\xBC\xA5\x1D\x04\x47\xB2\x9C\xB1\x42\x32\x01\xF1\xA5\x77\x01\x2A\xA8\x73\xA7\x80\x91\x97", + "\xB2\x03\x3B\xA9\x9D\xA6\x7B\x4A\x2D\x01\x5E\xA5\x0F\x00\xA6\xA2\x4E\xEE\x8D\xF1\xA4\x7C\x02\x31\xAF\x74\xA1\x3A\x71\x97\xBB\x03\x74\xA8\xAD\xA7\x58\x20\x2F\x01\x5E\xAD\x0F\x14\xA3\xB3\x4E\xB7\x61\xBE\x01\x78\xA7\x3F\x04\x8E\xA9\x3B\xBC\x8F\xB1\x4B\x81\x00\x1A\x43\xA0\x2E\x2B\x18\xD4\x90\xCA\x31\x97\x83\x00\x61\xA9\x27\x93\x58\x1A\x8D\xA1\xCF\x54\x0C\x11\x97\x85\x00\x68\xA9\xA7\x2D\x84\x02\x2D\x1C\xE3\x9D\x83\x91\x97\x88\x00\x70\xA9\x2E\x1F\x79\xAA\x5C\xA5\x55\x68\x0C\x11\x97\x89\x00\x78\xA9\xB5\x18\xBC\xA0\xC0\x6A\x19\x01\x2F\xAA\x00\x30\x53\x88\x27\xFA\xA8\x2B\xA5\x9E\x5C\x19\x01\x2F\xAC\x00\x07\x54\x81\xAA\x68\x87\x81\x32\x33\x01\x5E\xAE\x00\x0F\xA8\xB2\x53\xF0\x86\x03\x32\x68\x01\xBC\xA0\x02\x06\x51\xA6\x08\x09\x54\x91\xA6\xA9\x30\x69\x01\xBC\xA2\x02\x00\x50\xB7\xA8\xB9\x4C\x83\x32\xD4\x01\x78\xA7\x04\x05\xA3\xA3\x10\x1F\xA8\x92\x16\xF7\x70\xF1\xA5\x0A\x00\x4B\xAA\x20\x0E\x52\xAD\x8C\x78\x03\xF1\xA5\x17\x01\x99\xAB\xB1\x27\xC3\x93\x90\x3A\x06\x31\x4B\x99\x00\x3A\xAB\x65\x72\xE7\x81\x54\x3C\x0D\x11\x97\x9B", + "\x00\x41\xAA\x35\xAA\x3D\xA8\x6E\x2E\x1B\x01\x2F\xBD\x00\x08\x55\x98\x98\xB7\x60\x70\x01\xBC\xA7\x03\x00\x4F\xB6\x87\x35\x54\xE4\xA6\xE2\x01\x78\xA6\x08\x07\xA9\xA7\x3B\x8C\x0E\x64\x03\x71\xA5\x24\x01\x92\xAA\x47\xAE\x85\x91\x0B\x26\x07\x31\x4B\xA5\x00\x55\xAA\x88\xA9\x0D\x9B\x20\x38\x0E\x11\x97\xA8\x00\x5C\xAA\xD3\x7E\x7B\x4A\x3A\x01\x5E\xAA\x02\x10\xAB\x91\x0F\xAC\x43\xEC\x01\x78\xA4\x0B\x01\xAD\xA6\x52\xA9\x62\xAF\x5B\x6E\x01\xF1\xA5\x17\x02\x5D\xAD\xE8\x69\x8A\x30\x07\x31\x4B\xB1\x00\x83\xAB\x80\x02\x2D\xAE\x5F\x22\x0F\x11\x97\xB3\x00\x7C\xAA\x63\xAB\x68\xA6\x3D\x4C\x1E\x01\x2F\xB6\x01\x10\x56\xAD\xAA\x08\xA5\x81\x32\x3D\x01\x5E\xA9\x03\x17\xAC\xB4\x54\x8E\xA4\xFA\x4B\x78\xA4\x0F\x06\xB3\xAB\x53\xA0\x84\x83\x64\x7A\x01\xF1\xA5\x1F\x01\x62\xAA\xCE\x41\x87\x51\x97\x81\x01\x2B\xAB\xD7\xA8\x80\x6E\x3F\x01\x5E\xA3\x04\x0B\xAD\x9D\x53\x80\x6E\x00\x00\xE1\x34\xE2\x25\x08\x0B\x5A\xBF\x9D\x8A\xE3\x02\x00\xBA\xAA\x86\x03\x11\x03\xB5\xA5\x3C\xBD\xB9\x04\x00\x41\xAB\xEE\x42\xD2\xAA\xB3\x25\x9A\x10\xAD\x26\x00\x02\x6F", + "\x70\x92\x39\x3C\x69\x1B\x92\x6A\x78\x3D\xB6\x97\x68\xAA\x55\xE1\x41\x14\x01\x07\x6D\x41\x27\x9A\x17\x29\x27\x01\x5A\x57\xB6\x23\xDC\xAB\x81\x02\x74\xA8\x2B\x72\xBC\x24\x6A\xAB\x33\x6B\xA0\x9D\x4D\x0C\x00\x72\xAB\x76\x41\x54\xA8\x67\x03\x2F\xA3\x4C\xEB\xAB\x81\x02\x13\x05\xBD\xA2\x50\xAA\xC6\x60\xD7\x1B\x9F\xCA\xAA\xF7\xAA\xF4\x94\x79\x81\x5F\xA3\x32\x79\x57\xCF\xA8\x64\x2D\xFF\x6B\xB8\x2E\x0A\x0F\x5F\xB4\xA2\xAD\xCA\x0E\x6C\x34\x71\x02\xAE\x16\xAB\x39\x6D\x5F\xA1\x08\x1C\x01\x74\xAB\x27\xAB\x50\x36\x8A\x6B\xDC\x2E\x05\x0A\xB0\xA4\x51\x95\x48\x0D\xAD\x5A\x22\x85\xAA\x8D\xAD\x69\x4B\x01\x19\x58\xE4\x00\x1B\xAC\x38\xAA\xCE\xA1\xC3\xA7\x06\x01\xB1\xB5\x51\xE9\x63\x19\xAC\x35\x02\x89\xAA\xA9\xAF\xFC\x11\x01\x19\x58\xED\x00\x26\xAC\x40\xA9\x82\x29\xC3\xA0\x07\x10\xA7\x8F\x5F\x7A\xAB\xE4\x9C\x68\x35\x0D\x01\xC3\xA4\x07\x06\xB1\x8C\x52\xAF\x3A\x19\xAD\x3B\x00\x84\xAF\x20\xA3\x90\x39\x01\x19\x58\xF9\x00\x36\xAC\x75\x1B\x23\x29\x15\x3B\x03\x19\xB0\xBD\x01\x26\xAC\x9E\xA9\x06\x31\x86\xA8\x10\x06\x62\xA4\xA5\xBD\x5C\x3F", + "\x00\x19\xAD\x41\x01\x92\xAE\x9C\x14\xB1\x85\x5A\x59\x58\x87\x01\x26\xAC\x58\xA8\x99\x2B\x08\x09\x61\xAA\x04\x26\x58\x8B\xAB\x64\x2D\x22\x01\x86\xAD\x11\x0B\x65\xA5\x67\x3C\x52\xAC\x43\x47\x01\x0C\xAD\x24\x05\xCD\xA7\x5E\xA1\xA6\x9D\x9A\x49\x00\x19\xAD\x4A\x00\x9D\xAA\x20\x08\x63\xB4\x7D\xB9\xB9\x4B\x00\x19\xAD\x4C\x03\x9E\xA9\x20\x08\x63\xB6\x90\xA1\x6A\x4D\x00\x19\xAD\x4E\x02\x89\xA9\x9A\xAE\x2F\x2F\x02\x19\x58\xA0\x01\x26\xAD\xD8\xAA\x32\x71\x0A\x09\x61\xA3\x05\x26\x58\xB7\xAB\xCA\x71\x29\x01\x86\xAE\x14\x06\x62\xBE\xAD\x9C\x14\x99\xAC\xA9\x00\x13\xAD\x71\xAE\xC4\x49\x61\xAC\x05\x03\x5A\x80\x00\xB5\x2E\xEF\x9F\xC0\x49\xC3\xA0\x0B\x01\xAA\xA9\x5A\x93\xA6\x22\x8B\x0C\xAE\x2C\x06\xD5\xA5\x5F\xB1\x85\x1D\x01\x19\xAC\xB4\x00\xE5\xA9\xAA\xA8\x64\xAB\xCD\x79\xB0\xB7\x02\x3A\xAD\x00\xAD\x9E\x2D\x18\x01\xC3\xAA\x0B\x00\xB6\x86\x58\xB7\x61\x63\x01\x0C\xAD\x2F\x06\xD8\xAB\x60\xB2\xE7\x59\x58\xC0\x01\xB4\xAD\x08\xAC\x73\x47\x0C\x09\x61\xA2\x06\x0C\x5B\x97\xAC\x03\x33\x34\x01\x86\xAD\x18\x07\x6D\xBC\xB0\xAF\x5B\x6B\x00", + "\x19\xAC\x64\x01\xB7\xAA\xC4\xA3\x90\x2D\x03\x19\x58\xCB\x01\xE3\xAD\x13\xAF\x40\x37\x0D\x09\x61\xAE\x06\x29\x5B\xAC\xAC\x03\x1F\x38\x01\x86\xA9\x1A\x09\x6E\xB2\xB1\xBE\xBF\x19\xAC\xD4\x01\x53\xAD\xAA\xAC\x6C\xA8\x6D\x63\xB7\x18\x03\x69\xAD\x3F\xAD\x2F\x65\x86\xAB\x1B\x01\x6D\xA4\xB2\xA1\x6A\x79\x00\x19\xAD\x6E\x02\xBE\xA8\x93\xAD\x69\x5B\x03\x19\x58\xE1\x01\xE9\xAD\x28\xAC\x00\x69\xC3\xA4\x0E\x09\xB7\x96\x59\xEF\x2F\x7F\x01\x0C\xAF\x39\x03\xE1\xAA\x4A\xA0\xB8\x41\x02\x19\xAC\xEB\x01\x74\xAE\x98\xAD\xE7\x23\x08\x19\xB0\xAE\x03\x69\xAD\x68\xAD\x9E\x2D\x21\x01\xC3\xA1\x0F\x1C\xB8\xAF\x59\xF6\x49\x87\x01\x0C\xAD\x3D\x06\xE5\xA6\x67\xAF\xB7\x09\x02\x19\xAC\xF9\x00\x9A\xAF\x31\xA8\xEE\x69\x61\xBD\x07\x3A\x5C\xCC\xA9\xE1\x41\x46\x01\x86\xA9\x00\x01\x12\x4E\x88\x04\x37\x0D\x75\xE1\x41\x47\x01\x86\xAC\x00\x05\x74\xB5\x87\x02\x37\x77\x81\x54\x8B\x0C\xAF\x01\x05\xE9\xA1\x4F\xBF\x6D\x1D\x18\xAC\x43\x93\x01\x0C\xAE\x02\x04\xEA\xA6\x0F\x29\xB5\x9E\x5A\xFE\x25\x95\x01\x0C\xAD\x03\x04\xEB\xAF\x74\xB3\x08\x69\x62\x17\x01\x19", + "\xAC\x08\x00\xD5\xAF\xF9\x25\xDD\x18\x69\x29\x9F\x4F\xAB\xB1\x21\xB6\xAD\x40\x05\xC9\x1B\xEF\x3F\x04\x14\x57\xF1\xAE\x51\x1C\x95\x4B\xDD\xAE\x5F\x22\x77\xA0\x00\x3B\x5E\x72\x7B\x7B\xAE\xB7\x8D\x90\xA1\x54\x37\x0B\x19\xB0\x94\x00\x54\xAE\x86\x5F\x1F\xA9\xA1\x59\xC3\xA6\x01\x08\xBC\x90\x38\x35\xAD\xD3\x91\x0C\xAC\x06\x04\xEC\xA9\x10\x11\x70\x24\x2A\xA8\x50\x19\xAD\x0D\x00\xE5\xAE\x20\x06\x79\xB9\xBA\x61\xEA\x19\xAC\x1E\x01\xCD\xAF\x40\x05\xF3\xA8\xE9\x81\x07\x41\x03\x19\xAC\x21\x00\xD1\xAE\x40\x04\xF4\xA0\x52\xAC\x15\x59\x58\xA4\x00\x8E\xAF\xCA\xAF\x9B\xA0\x3C\x35\x0C\x19\xB0\xA6\x00\x2A\xAF\x01\x02\xD6\xAF\x4B\xAA\xE1\x39\x61\xA9\x01\x38\x5E\x80\x00\xBA\xAE\x9B\xAA\x80\x89\xC3\xAC\x02\x1F\xBD\x81\x5F\x96\x87\xB1\x99\x0C\xAF\x0B\x06\xF8\xA3\x54\xAC\x0E\x4D\x03\x19\xAC\x32\x00\xE6\xAD\xA4\x48\x5A\x3F\x0C\x19\xB0\xB5\x00\x52\xAF\x96\x4C\x96\x3D\x86\xA8\x07\x0B\x76\xAF\xBC\x83\x3B\xB4\x3E\x19\xAC\x1E\x00\xF6\xAA\xD4\x40\xAD\x35\x06\x19\x58\xBF\x00\xB1\xAE\xCE\xAC\x59\xAE\x5F\x27\x0D\x19\xB0\x81\x01\x5D\xAF\xB2\xAE", + "\xFA\x81\xA8\x31\x1B\x09\x61\xA5\x02\x23\x5F\x82\x02\x12\xAF\x9E\x2F\x36\x01\xC3\xA8\x04\x17\xBF\x81\x04\x17\xAE\xE0\x33\x84\x6F\xB8\x2B\x09\x00\x7F\xAA\xBF\x9D\x5C\xCA\x71\xDF\x01\x0C\xAF\x13\x06\xFF\xA0\x00\x03\xB9\xAF\x5F\x61\x01\x19\xAC\x29\x00\x03\xB1\xE5\xAF\x7E\x23\x07\x19\x58\xD5\x00\x05\xB1\xD1\xAE\x80\xA6\x5F\x25\x0E\x19\xB0\x99\x01\x19\xB0\xAB\xAF\xCC\xA8\xF9\x71\xC3\xAD\x05\x00\xC1\xB9\x5E\xA0\xAB\xD5\x6B\x0C\xAD\x18\x06\x04\xB0\x7C\xBB\x7D\xB1\x42\x6B\x01\x19\xAD\x32\x00\x03\xB4\xD1\xA4\x66\x2D\x07\x19\x58\xE8\x00\x0C\xB0\x49\xAD\x2C\x27\x1D\x09\x61\xAB\x03\x0C\x60\x98\xAD\xB1\x21\x78\x01\x86\xAE\x0D\x0C\x80\xBF\xBA\xA4\x59\x73\x01\x19\xAD\x38\x00\x03\xB3\xD4\xA0\x9E\x35\x07\x3C\x58\xAC\xB0\x40\x1D\x8B\x1B\xBB\x2F\x1E\x00\x77\xAA\x32\x8C\x39\x21\x6C\x81\xAF\x9E\x2C\x90\x1A\xCA\x16\x39\x5F\xB8\x55\x57\xB2\x1C\x01\x03\xBF\xAC\x6B\x45\x01\x0E\x85\xB1\x85\x05\x39\x68\xAB\xEF\x2D\x0A\x03\xC7\x68\x71\x28\x07\x09\xBF\x83\x04\x67\xB0\x7F\x82\x7B\x4B\x05\x03\x0D\xBC\x10\x1A\x03\x2E\x61\x82\x02\x70\xB1\x4E", + "\x94\x6B\x46\xE4\x63\x6E\x3C\x03\x3F\x5E\xF9\xB0\xFB\xAA\xE6\x43\x06\x04\x0E\xB0\x47\x3F\xC3\x81\x5B\xAF\x63\x84\xB1\xD0\x4E\x21\xB7\xD8\xA0\x70\x7F\x00\x09\x62\x83\x02\x85\x01\x45\xB1\xB3\xAB\x20\x31\x02\x0F\xC4\x99\xDF\x77\xB0\xEB\x97\xD9\xAD\x5F\x33\x04\x06\x89\xA7\x98\x12\x62\xD8\xAD\x68\x6D\x4E\xB0\x75\x77\x13\xBE\x6D\xA3\xC8\x27\x00\x22\xB1\x90\x00\x52\xB0\xB9\xA9\x54\x3D\x72\x63\xB7\x13\x02\x2A\xB1\xEA\xAD\x50\x37\x0A\x02\x14\xB6\x09\x10\xC5\xB0\x5B\xDA\x1B\xA2\xB1\x4C\x00\x2C\xB6\xDE\xAA\x20\x2F\x01\x22\x62\x9C\x01\x2C\xB0\x40\xB1\x8E\xA8\x12\x42\x8A\xA0\x05\x30\x62\x81\xAE\x09\x2C\x51\xB3\x28\x00\x13\xB0\x00\x02\xC6\xB0\x4D\x9D\x4D\x35\x00\x51\xB1\x29\x01\x18\xBC\x70\xA6\xC0\x22\x62\xA9\x01\xB0\xB1\xFC\xAF\xFB\x29\x07\x02\x8A\xAC\x05\x30\x62\x80\xB0\x7D\x33\x1D\x02\x28\xB7\x15\x04\x8D\xA7\xC0\xB1\x42\x3D\x00\xA2\xB1\x59\x00\x2C\xB6\x01\xB0\x9E\x3F\x01\x22\x62\xB6\x01\xB0\xB0\x0A\xB0\x78\x31\x08\x02\x8A\xB9\x05\x25\x63\xAF\xAE\x9D\x4D\x21\x02\x28\xB5\x17\x07\x8F\xB5\xB9\x83\x64\x45\x00\xA2\xB1\x60\x01", + "\x3F\xB3\xE7\xA0\x67\xA2\xC5\x85\x03\x03\xB2\x40\xAE\x3E\x4A\x28\xB1\x19\x00\x8B\xB4\xC1\xBD\x5C\x4B\x00\xA2\xB0\x66\x00\x2C\xB2\x07\xBE\x2F\x2D\x02\x22\x62\xCF\x01\xB0\xB0\x20\xB1\xA3\xAA\x14\xB2\x0D\x10\xC5\x86\x61\xBD\x2E\x51\x00\x51\xB1\x35\x00\x16\xBC\x84\xBD\xCB\x13\x01\x22\xB1\xD8\x00\x16\xB1\x85\x22\xB4\x10\xAD\x35\x02\x1F\xDC\x70\x92\x2B\xB2\x81\x00\xDD\xAA\xC2\x55\x86\xBE\x97\x31\x64\x94\x6C\xA9\x31\x31\x01\x4D\xB0\x54\xA4\xE5\x08\xE8\x7B\x64\xBD\x2E\x33\xB3\xE1\x1B\xBE\x3B\x0E\x0F\x71\x6C\xAE\x5C\x61\x9A\xB0\x95\x43\xA2\xB1\x2C\x22\x0C\xB9\x89\xB8\x5F\x4A\x65\xFE\x25\x74\x1C\x29\xB3\x40\x36\x0E\x0F\x94\xA4\xB3\x34\x39\x41\xB2\x42\x5D\x8F\x6E\x79\xAF\xCB\x19\x77\xB0\xD6\x3A\x01\x5A\xB2\xB1\x20\x3A\x1C\x53\xB3\xA9\x70\x96\xB4\x3B\x83\x5E\xCC\x43\x80\x00\x51\xB0\x37\x07\xF7\xAA\xE8\x0F\xE9\x48\xE7\x22\xB1\xDF\x00\xB6\xB0\xE4\xAD\xCB\x62\x8A\xA2\x07\x2C\x60\xED\xB2\x8C\x71\x8E\x6A\x28\xB6\x1C\x07\x97\xA7\xC4\xA2\x11\xA2\xB1\xEA\x01\xBE\xB0\x23\xB2\x19\x7A\x08\x02\xC5\xAE\x03\x02\xB3\x93\xB1\x99\x6A\x28", + "\xB2\x1E\x02\x97\xB2\xB6\x97\x39\xA2\xB1\xF5\x00\xC4\xB0\x28\xB4\x39\x40\x09\x02\xC5\xB9\x03\x12\xB3\xA5\xB1\x50\x36\x24\x02\x14\xBD\x0F\x18\xCC\xAB\x62\xCC\x43\x94\x00\x51\xB1\x00\x03\x8B\x4F\x7C\x38\xCB\x9E\xD3\x5B\x3C\xA2\xB1\x02\x00\x69\xB4\x21\x06\x9A\xA3\xA7\x57\xA9\x22\xB1\x09\x01\xD5\xB1\x42\x05\x35\xBA\x4E\x70\xD6\x1A\x02\x22\xB1\x0D\x01\x2D\x48\x98\x2C\x36\xB3\x8C\xA1\x07\x5C\x02\x22\xB1\x12\x00\xD9\xB2\x41\x04\x37\xB8\x8C\xA2\x09\xA2\x62\x96\x00\x5B\x48\x7B\x20\x6F\xB7\x19\xBF\x6E\x20\x05\x22\x62\x99\x00\xBA\xB2\xD6\xB1\x35\xB3\x20\x32\x0A\x02\xC5\x9E\x00\x42\xB3\x03\x02\xDE\xB2\x36\xB0\x3C\x34\x0A\x02\xC5\xA2\x00\x58\xB3\x02\x02\xDE\xB0\x38\xB6\x8D\x82\x8A\xA6\x01\x11\x67\xB3\xB3\xBD\xA5\x56\x64\x2A\x02\x14\xBB\x02\x00\xCF\x81\x04\x3C\xB3\xEC\xB1\xBE\x32\x2A\x02\x14\xBF\x02\x0E\xCF\x89\x3A\x20\x96\xBE\x9C\x51\xB3\x0C\x07\x3C\xB3\x9C\xBB\xC0\xA4\x59\x2E\x01\xA2\xB0\x1C\x00\x7F\xB1\x3B\xB2\x82\xAD\x53\x62\x62\xBD\x00\x03\xB5\xF0\xB0\x0A\xB6\x38\xA2\x8A\xA2\x02\x09\x68\xEF\xB3\x2E\xB0\x7F\x24\x2D\x02", + "\x14\xB7\x04\x16\xCF\xBC\x66\x8E\xB2\x83\x8E\x51\xB3\x12\x06\x42\xBD\x40\x81\xE4\x22\x62\xCF\x00\x1C\xB5\xAB\xAC\x06\x72\x14\xB3\x05\x01\xD1\x97\x2D\xA8\x67\xA2\xB1\x2B\x02\x89\xB2\x46\x50\xAD\x3E\x05\x22\x62\xDB\x00\x0F\xB4\x00\x02\xB0\x1C\x9E\xAF\x70\x82\xC5\xA0\x01\x49\xB3\x0C\x03\x19\xB7\x3E\xAF\x16\x62\x0C\x02\xC5\xA3\x01\x38\xB4\x9A\x51\xB9\xB0\xE1\x92\x14\xB6\x06\x16\xCF\xBA\x68\x8A\xAA\xAD\x64\x63\x02\x28\xB2\x0D\x06\xA4\xBE\xCB\xBD\x65\x48\x01\xA2\xB0\x37\x01\x93\xB3\x30\xB1\x0B\x2A\x06\x22\x62\xF2\x00\x53\xB5\xC4\xB3\xC8\x9A\x14\xB6\x07\x00\xD2\x86\x04\x47\xB4\x47\x61\xD5\x6A\x28\xB1\x0F\x09\xA5\xB3\xCC\x9B\x21\xA2\xB1\x7D\x01\x32\xB5\x66\xB3\x30\x92\x8A\xA1\x04\x2A\x69\x9F\xB3\x6F\x70\x51\xB1\x21\x07\x4D\xB1\x8B\xAC\x0E\x56\x03\x22\xB1\x89\x00\x3A\xB7\x2D\xB1\x21\x08\x0D\x02\xC5\x8D\x02\x74\xB4\xBC\xB0\x9E\x2A\x36\x02\x14\xB1\x09\x11\xD1\xA0\x69\x87\xA9\x8D\x70\x5A\xB0\x9D\xB5\x38\xBA\x20\x3E\x06\x22\x62\x9A\x01\x5E\xB5\x60\x1F\xFA\xAC\xCC\x20\x0E\x02\xC5\x9D\x02\x06\xB5\xD3\xB3\x50\x34\xE0\x6B\xDC", + "\x22\x0A\x14\xD3\x9B\x67\xFD\x32\xE4\x00\x51\xB2\x29\x04\x4E\xB3\x9E\xB6\x8D\x26\x03\x22\xB1\xAA\x00\x4C\xB6\x39\xB6\x5F\x28\x0E\x03\xC7\xB4\x69\xF1\xB3\x05\x22\x75\x01\x3A\xB4\x4E\xB2\x8F\xBD\xCB\x2C\x03\x22\xB1\xB7\x00\x55\xB4\x3E\xB7\xAF\xA2\x8A\xBC\x05\x3A\x6A\xFE\xB1\xA1\x34\x78\x01\x40\xB7\x57\xB4\x90\xB6\x27\x72\x03\x22\xB1\xC6\x00\x62\xB5\x42\xB3\xB2\xA2\x8A\xAB\x06\x34\x69\x98\xB4\xE0\x32\x7B\x03\x45\xB4\x4E\xB4\x91\xA4\xB3\x38\x03\x22\xB1\xD3\x00\x3A\xB6\x46\xB4\xCC\x2A\x0F\x02\xC5\x97\x03\x74\xB4\x1F\xB3\xF7\x2C\x3F\x02\x14\xBB\x0D\x14\xD3\xA5\x64\x85\x22\xFE\x00\xB8\xB1\x8C\xB4\xDB\x19\xEA\x0F\xB7\x0E\xDE\x0E\x95\xE9\x20\xCF\x26\x4C\x46\x36\x26\x00\x17\xDF\x1F\x61\xEC\x1D\x44\x2F\x79\xB5\x96\x7E\x5E\xB0\x5A\x25\x9D\x3A\x6B\xC3\x34\xFC\xB5\xBE\x2B\x46\x07\x5F\xBB\x5D\x21\xD8\xA4\x59\x32\x1E\x0C\xA6\xE6\x42\x09\x07\x7E\x38\x38\x24\x07\x11\x6A\xFE\x2E\xB0\xAC\x1D\xA0\xC3\xB6\x65\x4F\xB0\xA6\xBC\x2B\x37\xAD\x65\x2A\x01\x89\xB6\x2B\x1E\x3E\xB2\xF3\x1C\xB5\xAD\xCA\x25\x6F\x88\xA2\x8E\xB7\xC7\x1B\x55\x91", + "\xAA\x2E\x01\x1A\x6C\xB6\x1B\x22\xB6\x2A\xB6\xBF\x20\x06\x07\xB2\xAF\xC3\xA9\x6C\xDA\xB4\x79\x5C\x19\x01\xCB\xB2\xA3\x25\xB1\xBA\xDA\x06\x3D\xD0\x35\x34\x01\x99\xB5\x40\x05\x1F\x0F\xB2\xA6\xD3\xAD\xCA\x36\x00\x3A\xB6\x7E\x1F\x4B\x47\xF9\x22\xF3\x11\x7A\xB1\x42\x38\x00\x41\xB7\x02\x03\xD0\xB6\xE4\x1A\xC6\x36\x4A\x41\x6D\x89\x00\x4B\xB6\x54\x2F\x02\x9D\xA6\x31\xB4\xAD\x00\x11\x6D\x9F\x2C\x7B\xB4\x83\x02\x0F\x01\x68\xB1\x01\x17\xDA\x8D\x5E\x01\xB5\x28\x43\xA0\xB5\x05\x07\x25\x40\x66\x32\x79\x24\x4D\xC2\x00\x41\xB6\x0D\x02\xD7\xB6\xEF\x2C\xA8\xBC\xA9\x04\x01\x41\xB6\x1E\x01\x97\x42\x3D\x22\xE6\x1C\x9C\xBE\xF7\x41\x6D\xA1\x00\x64\xB6\xA6\xB7\x92\xA8\x5A\x38\x04\x01\xDA\xA6\x00\x6B\xB6\x86\x2F\x4F\xB5\x41\x24\xF6\x63\x6E\x2A\x01\x00\x6E\xB6\xB6\x55\x9D\x54\x30\x13\x01\x68\xBE\x02\x19\xDB\xA8\x5A\x59\xA0\x03\x32\x27\x01\xD0\xB3\x06\x07\xB8\xB2\x79\x30\x6A\xB6\x23\x50\x01\xA0\xB7\x0D\x05\x72\xBF\xF1\x15\xD5\x85\x44\x52\x00\x41\xB7\x1D\x02\xE3\xB7\xC3\x25\xFA\x9B\x4F\x81\x6D\xC0\x00\xA3\xB7\xC6\x2D\xEB\x9F\x16\x66\x05", + "\x01\xDA\x85\x01\x29\xB7\x7E\x2E\x3F\xAD\xAB\x60\x0B\x01\xB4\xAA\x02\x30\x6E\x86\x2F\x86\xAD\x06\x95\xD0\xB7\x09\x0C\xB9\xA7\x20\x83\x64\x5C\x00\x41\xB7\x29\x01\xEF\xB3\xD2\x9A\xDC\x81\xDA\x97\x01\x43\xB7\x86\x99\x4E\x4C\x18\x01\x68\xBB\x05\x08\xDE\x82\x04\x61\xB5\xE0\x32\x31\x01\xD0\xB7\x0B\x0E\xBC\xA1\x08\x27\x6B\xB6\x23\x64\x01\xA0\xB7\x18\x07\x76\xBC\xEF\x1F\x78\x2D\x6B\xBE\x3B\xF7\x36\xB8\x91\x00\x07\xFA\x24\xB0\xA8\xAA\x2C\x01\x06\xB6\x3D\x2F\xF1\xB4\xB5\x8D\x7C\xB2\x02\x68\xDF\xAF\x5F\x6A\xB7\xAD\x2E\xF6\xB7\xF3\x1C\x0F\x0E\xBE\xA0\xCF\x30\x6F\x95\x03\xF2\xB7\x81\x1C\x21\x05\x7E\xBD\x97\x26\x7A\x09\x6C\xD5\x64\x41\xB6\x34\x02\xDC\xB7\xED\x11\x87\xBD\x34\x4E\x02\x41\xB6\x6B\x01\x01\xB9\xD9\x1F\x49\xA1\x0E\x50\x04\x01\x6D\xEE\x00\x87\xB6\xA3\x1E\xC7\xB7\x16\x62\x09\x01\xDA\xB2\x01\x11\xB8\x23\xB7\x29\x3D\xD0\xB6\x0E\x08\xC1\xAA\xD9\xA4\x59\x16\x01\x41\xB6\x3D\x01\x07\xB8\x66\xBD\x2A\x78\x04\x01\x6D\xFE\x00\x0A\xB8\xAA\x1E\x63\xB5\x55\x6A\x09\x01\xDA\x81\x02\x23\xB8\x3E\xB7\x5B\x60\x27\x01\x68\xB5\x08\x10", + "\xE1\xAB\x69\xF9\x5C\x9E\x01\xA0\xB5\x22\x06\x86\xB0\xA7\xAD\x95\x60\x02\x41\xB6\x8D\x00\x1E\xB9\x9D\xB1\xCF\x52\x0A\x01\xDA\x91\x02\x42\xB8\x59\xB7\xC1\x85\xD0\xB5\x12\x02\xC4\xA0\xDB\xA1\x5B\x41\xB6\x99\x00\xEE\xB6\xD1\x1C\x6C\xA8\x0A\x01\xDA\x9E\x02\x42\xB8\x6D\xB6\xD5\x2A\x2A\x01\x68\xB2\x0A\x09\xE1\x8E\x3D\x3E\x87\xF6\x2D\xA0\xB5\x29\x02\x8A\xBF\xF1\x15\x8E\xAB\x52\xC1\xB6\xAA\x00\x21\xBA\xE0\xB6\x36\x20\x0B\x01\xDA\xAE\x02\x42\xB8\xA5\xB4\x05\x26\xFB\x6B\xDC\x22\x0B\x04\xE3\xAB\x6A\xE4\x2C\xB4\x01\xA0\xB7\x2D\x02\x88\xB7\xB9\xB7\x3B\x81\x6D\xBB\x01\x42\xB8\xCF\xB6\x6D\x20\x17\x01\xB4\xBF\x05\x36\x71\xBB\xB5\xF8\x8D\xA0\xB4\x31\x07\x90\xB0\xAC\xAC\x0E\x7C\x02\x41\xB6\xC9\x00\x46\xB9\xB1\xB6\x04\x71\xB4\xAE\x06\x12\x72\xCB\xB5\x9D\x4C\x60\x01\xD0\xB3\x1A\x02\xC4\xB0\xD6\xB1\x29\xC1\xB6\xD7\x00\x21\xB9\xB5\xB4\x70\x91\xB4\xBB\x06\x02\x71\xDB\xB5\x3D\x2E\x63\x01\xD0\xB7\x1B\x02\xC4\xB0\xDE\x8F\x69\xC1\xB6\xE3\x00\x21\xBB\xF5\xB2\x41\x2A\x0C\x01\xDA\xA7\x03\x5C\xB7\x6B\x1F\x84\x03\xF7\xB1\xE7\x81\xBE\xB6\xAF", + "\x24\x6F\xC8\x95\xFC\xB7\x82\x21\x2E\xB9\x5F\xB0\xAD\x3A\x06\x01\x73\xB6\x23\xC3\xB9\xDC\x1D\xFE\xB0\x92\x17\xCC\xAA\x90\x09\x73\xB0\x03\xCB\xB8\x57\x19\x33\xBF\x3C\x3F\xF1\x1F\xDF\xAD\xCA\x72\x01\x41\xB6\x76\x02\x17\xB9\xEF\x1F\xF1\x11\xD8\xBE\x4B\x74\x01\x41\xB7\x77\x03\x36\xBC\xEF\x1F\xF1\x17\xD8\xB7\xC2\x76\x01\x41\xB6\x79\x03\xE1\xB1\xF2\x13\xC1\xA0\xB8\x78\x03\x41\xB6\xF6\x01\x75\xB9\x06\xBA\x69\x91\xB4\xBA\x07\x32\x73\x9E\xB8\x3D\x2E\x7E\x01\xD0\xB6\x1F\x07\xCF\xA4\xE1\xB7\xC2\x7E\x01\x41\xB6\x01\x03\x4F\x45\xEA\xAE\xF8\x0B\xE1\xB7\xC2\x00\x00\x2A\x38\xC4\x25\x01\x03\xA0\xBF\x7C\x31\x7C\x14\x38\xFA\x75\x09\xBB\x8D\x00\x43\xBD\xF0\x18\x43\x69\xC5\x04\x00\x11\xBA\x3D\x03\x89\xBB\xE7\x1D\x69\xBD\x5C\xB8\xE8\x85\x05\x1A\xBA\xA1\x1E\x12\x9F\xBE\x38\x01\x0E\xD1\xA7\x0B\x20\x74\x85\xBA\x29\x9D\x7D\x3E\x02\x05\xA4\xBA\xAF\x27\xE9\x9C\x73\x8B\x6E\xAC\x42\x06\x00\x4B\xBE\xDE\x83\xD0\xA0\xB3\x11\x3E\x64\xA6\x0E\x01\x99\xB8\x42\xBE\xA5\xB4\xCE\xBD\xAA\xB9\xB9\x10\x00\x3A\xBA\x13\x03\x40\xBE\x1E\x21\xF9\x15\xDB\x87", + "\xA3\x3A\xBA\x29\x01\x9A\xB8\x45\xBB\x6F\xBB\xEF\x34\x00\x3A\x74\xAE\x00\x3C\xBA\xB3\x2F\xC7\x1B\x8D\xB2\x5C\x3A\xE9\xB2\x00\x51\xBA\x91\x1F\x38\xB8\x72\x2A\xA7\xB6\x03\x0A\xEA\x9B\x74\xDD\xAC\xFB\x3C\x0D\x02\x4E\xBB\x07\x08\xD5\xBF\x78\x3D\x71\xBC\x2A\x1B\x70\x44\xA5\x59\xBD\x8A\x96\x4F\x5E\x00\x3A\x74\xC3\x00\x5E\xBB\x90\xB8\x22\xB9\xCC\x6A\xD3\xA8\x02\x31\x75\xA8\xBA\x8D\xB9\x3C\x5E\x08\x02\xA7\xBD\x04\x17\xEB\xAF\x74\x81\x8C\xE1\x40\x12\x02\x4E\xBA\x0A\x0E\xD7\xBD\xE9\xBB\x2C\xEF\x2D\x26\x00\x9D\xBB\x15\x03\xAD\xB8\x74\xAC\x0D\x68\x00\x3A\xBA\x5B\x00\xC6\xBB\x1F\x9C\x35\x4A\x02\x1A\xE9\x9F\x01\x12\xBB\x07\x7A\x92\x52\x4E\xBB\x0C\x08\xD9\xBA\x86\x2B\xA4\x3A\xBA\x67\x01\xCE\xBA\xD9\xAA\x26\x5A\xD3\xAB\x03\x05\x76\x99\x35\xDE\xB7\x5C\x7E\x0A\x38\x2E\x9C\x22\x32\xB5\x11\x73\x86\x02\x38\x00\x15\x3B\xBD\xB3\x45\x2F\xF1\x07\x00\x2F\x76\xAA\x3F\xB2\xBA\x2B\x2D\xF0\x2F\xB6\xB2\x10\x08\x02\x39\x76\xF0\x2C\x1F\x1E\x24\x3E\x68\x57\xB7\xB4\x66\x26\x00\x1F\x3C\x07\xB5\x9D\x4C\x2C\x02\x0A\x3C\xB9\x66\xDB\xA8\xB5\x0A\x43", + "\xCB\xBB\xB1\x20\x04\x00\xDB\x1C\xB7\xB0\x13\x50\xEE\xBE\x4B\x42\xBB\x72\xBA\x09\x5E\x75\xBC\xCC\x28\x7C\x3F\x74\x08\xDB\x5B\xBB\x3D\x2F\xEE\xB9\xBB\x2C\xBA\xB0\x00\x1D\x02\x2A\x70\x5B\xB2\xD7\x03\xDA\xB8\x79\xB8\x0C\x07\xDE\xB1\x85\x22\x77\x82\x02\xD2\xBA\x72\x6D\x7B\xBE\x5F\x2F\xDE\xB5\x0E\x24\x77\xE6\x00\xF3\xBA\xC3\x85\x35\xB9\x15\x3B\x83\x79\x72\x91\x75\x8B\x00\xDD\xB8\x84\x7A\x4E\xBC\x0E\x0F\xDF\xA5\xE7\x8D\x9D\x3A\xBA\x78\x01\xD3\xB8\x80\xBF\xF2\xA6\xD1\x7A\xE9\xBD\x01\x0A\xBC\xF3\xB8\x1E\x5E\x4E\xBA\x10\x00\xE1\xB8\xE7\x9F\xBF\x3A\xBA\x87\x01\x0A\xBE\x3F\xBA\x23\xAA\xD3\xAC\x04\x05\x78\x86\xBA\x00\x6F\x3B\x02\x4E\xB8\x12\x0A\xE1\xB1\xE1\x80\xDC\x42\x70\xEB\x53\x12\xBF\x0D\xBC\x25\xAA\xD3\xBA\x04\x2A\x78\xBD\xB8\xB7\x61\x3E\x02\x4E\xBF\x13\x0F\xE2\xA3\xE2\xAD\xCA\x7F\x00\x3A\xBA\x52\x01\x8D\xB9\x89\xB2\x30\x3A\xE9\xA9\x02\x35\xBC\x4E\xB8\xDC\x2B\x20\x02\xA7\xBE\x0A\x03\xE8\x8D\x5B\x1F\x1E\x64\xA7\x42\x02\x4E\xBC\x16\x05\xE3\xB9\xE2\x88\x55\x07\x01\x3A\xBB\x5C\x03\x87\xBE\xE0\xA4\xE5\x5A\xE9\xBD\x02\x46", + "\xBC\x1F\x03\x32\xB9\x2A\x33\x11\x0A\xD3\xA3\x06\x35\x78\xD4\xBA\x3C\x2B\x46\x02\x4E\xB8\x19\x05\xE3\xBA\xEA\x94\xED\x3A\xBA\xCD\x00\x2C\xBD\x4E\x07\xE3\x10\xB9\xA1\xD5\x11\x02\x3A\xBA\xD3\x01\x1A\xBF\x59\xBA\xB5\x23\x09\x1A\xE9\x98\x03\x35\xBC\x82\xB8\x05\x25\x25\x02\xA7\xBD\x0D\x0A\xF3\x8D\x5F\x12\xAB\xA4\x7A\x9D\xBB\x38\x06\xCF\xB9\x19\x1F\x78\x2B\x6E\x80\x6E\x4F\x71\x71\x2D\x3A\x04\xD0\xB4\x1B\x1F\x78\x32\x6E\xB7\x61\x9B\x00\x9D\xBB\x3B\x04\xD1\xB9\x1D\x1F\x78\x39\x6E\xB3\x74\x3A\xBB\x7A\x01\x8D\xBE\x93\xB5\x10\x3F\x04\x3A\x74\xFA\x01\x35\xBD\x51\xBB\xFB\x29\x14\x0A\xD3\xBF\x07\x35\x78\xA8\xB9\xEF\x2F\x51\x02\x4E\xBC\x00\x07\x15\x59\xD4\x19\x79\x8C\x99\xD2\x7A\x9D\xB9\x02\x05\xD5\xB0\x66\x2B\xF0\x9D\x2D\xAC\x43\xA7\x00\x9D\xBA\x03\x05\xD5\xB3\x6B\x2D\x00\x3B\x77\xD0\x35\xA9\x00\x9D\xB8\x05\x05\xD5\xBF\x7C\x3E\xF5\xAE\x65\xAC\x43\xAB\x00\x9D\xB8\x06\x04\xD8\xB3\x12\x06\xF0\x90\x6B\x2D\x01\x3A\xBA\x0E\x00\xAD\xBD\xD9\xBC\xE0\xBD\x34\x6F\x02\x3A\xBA\x21\x01\x69\xBD\x4F\x01\xC2\xBC\x81\x41\xEA\x9A\x7B\xD7\x02", + "\x1F\x1F\xFF\x9A\xA7\x8A\xA7\xBB\x02\x1F\xF6\x9D\x06\x1F\x1E\x41\x9E\x32\x2D\x2D\x02\xA7\xB0\x03\x0C\xF6\x9B\x7B\xA0\xBC\xCA\x71\x2E\x73\xB8\x2C\x06\x06\xEE\xB8\x0D\x1F\x3C\x0F\xBA\x7D\x33\x5C\x02\x4E\xB9\x07\x05\xEF\xBD\x0E\x1F\x3C\x46\xB6\xD3\x90\x9D\xBA\x0F\x05\xDF\xBE\x20\x1F\x78\x08\x5F\xEF\x2F\xBD\x01\xB7\xB8\xC1\xBE\xD8\xBC\xAD\x9C\x13\xB5\x75\x8B\xBE\x1F\x1E\x1E\xBC\xBD\x3C\xAF\xB0\xF1\xB0\xE9\x92\x33\x83\xBB\xBC\xBC\x6A\xBE\xB2\x9D\x9B\x9A\xD3\xB8\x02\x15\x7C\x99\x6E\xB6\x44\x9D\xB9\x17\x06\xDD\xB0\xEE\xA0\xE3\x83\x64\x49\x01\x3A\xBB\x30\x01\xC6\xBF\xDD\xBB\x56\xBA\xD5\x60\x76\x9F\xBE\x03\x02\x30\xBE\x6A\x2D\x19\x0A\xD3\xAC\x03\x30\x7C\x82\x02\x66\xBC\xA4\x2B\x33\x02\xA7\xB1\x07\x0B\xF9\xA5\x7C\xFE\xAA\x03\x33\x68\x02\x4E\xBF\x0E\x07\xF3\xA1\x08\x33\x79\xC8\x2A\xD3\x00\x9D\xB8\x1F\x05\xE8\xB9\x31\x33\x75\x6B\xE1\x6B\x4F\x3E\xBF\x73\xBC\xA0\xBC\x8A\x58\xE1\xB1\xFA\xB6\x7B\xA3\x84\xEF\x2D\x6C\x02\x4E\xBD\x11\x06\xF5\xBE\xF7\xAA\x31\x80\x6E\xDB\x00\x9D\xBB\x24\x05\xEB\xB5\xF0\xA6\xAD\x9F\x0B\xBA\xBA\x99", + "\x00\xA6\xBC\xA7\xBE\x36\x2F\x0D\x1A\xE9\x9E\x02\x4C\xBE\xA2\xBC\xF0\x31\x38\x02\xA7\xB3\x0A\x0C\xFA\xA8\x7A\xE0\x33\xE3\x00\x9D\xB8\x2A\x04\xE9\xBE\xCA\xA5\x88\x25\x03\x3A\xBA\xAD\x00\xA6\xBF\x2C\xBC\xA7\x27\x0E\x1A\xE9\xB2\x02\x64\xBE\x32\x25\x9D\x00\x79\xB9\x1D\x0B\xDA\xB1\x85\x09\x7E\xC5\x02\xE4\xBB\x77\x00\x71\xBD\xE7\x2F\xF8\xA1\x0B\x24\x77\xF7\x01\x93\xBF\xF7\x2E\xF5\x2C\x46\xBD\x2A\x7F\x07\x3A\x74\xB8\x01\x24\xBF\xAD\x01\x80\xB8\x71\x44\xD5\x31\xE1\x61\x7E\x87\x02\xCE\xBD\x7D\x3F\x00\x05\xF4\xB6\x86\x04\xF8\x9B\x7E\xF9\xB2\x5A\x62\xD6\xBF\xD3\x26\xF5\xBC\xED\xA1\x8B\x72\x7E\xFE\x14\xB4\xBE\x0B\xBC\x78\x31\x01\x07\xFB\xA9\x56\x39\x7E\x9B\xBC\xCA\x71\x05\x01\xEF\xBC\x34\x87\xFA\xA1\x0D\x1F\x3C\x30\x83\xCC\x43\x06\x03\xF0\xB9\x20\x08\x0D\x1F\xFD\xA6\x78\xCA\x71\x0F\x01\xE5\xBC\x15\x1E\xF9\xBB\xE2\xB7\x85\x51\x00\x52\xBF\xE2\x00\xEA\xBC\x8C\xB8\xE0\x63\x01\x12\xFE\xA7\x03\x5A\xBF\x36\xBD\x7D\xA6\xF4\xBC\x1D\x00\xFE\xB2\xF8\xB0\x11\x52\xBF\xF1\x00\xF0\xBD\x90\xBF\xF9\x19\x01\x12\xFE\xB6\x03\x64\xBE\xAF\xBF", + "\x68\x9E\xF0\x5A\xFA\xBC\x0F\x00\xFF\x8E\x79\xB8\x2B\x1D\x00\xE9\xBD\x00\x06\x29\x4F\x7C\x31\xFF\xA9\x7F\x33\x5D\x90\x71\x71\x2D\x01\x06\x29\x43\x6B\x3E\xFF\x8D\x63\x29\x31\x21\x00\xE9\xBF\x02\x06\x29\x40\x66\x26\x00\xCD\xD7\x53\x5A\xD2\xBE\x08\x00\x03\xC5\x30\x0F\xF1\x19\xF9\x88\x90\x52\xBF\x15\x00\x02\xC0\x05\xC7\x8E\xBD\x73\x27\x01\x12\x7F\x9B\x00\x13\xC1\x93\x02\x59\xBF\xCA\x42\xFD\xA0\x01\x21\x80\xC1\x02\x9D\xB7\x59\x5F\x0A\x02\xFA\xB5\x02\x1A\x00\xE2\x80\xD3\xBE\x23\x3A\xE9\xBF\x0A\x06\x05\xC8\x02\xD8\xFA\xB4\xAB\x52\xBF\x31\x00\x1A\xC2\xE8\xBF\xEB\xBA\x8C\x71\x01\x12\x7F\xB7\x00\x3A\xC0\xD4\xBE\xD9\xBC\x39\x43\x03\x12\xFE\xBD\x00\x27\xC0\x3B\xC1\xC6\xBA\xD4\xA2\xFA\xB2\x04\x08\x02\xC2\x81\xC4\xB7\xF6\x49\x1B\x02\xF4\xBF\x08\x0E\x04\xC6\xFE\xA2\x68\x9D\x4D\x39\x00\xE9\xBC\x13\x05\x0A\xCC\x1B\x1F\x78\x3D\x7D\xB6\x23\x3B\x00\xE9\xBD\x14\x04\x0B\xCE\x00\xC3\xFC\xAA\x56\x20\x71\x03\xAD\x20\xC2\x42\x07\xE3\x1C\x00\x04\xEF\xBF\x00\x54\x3A\x70\x92\x08\x03\xC7\x19\x02\x04\xDE\xA5\x02\x14\x75\x33\xBB\x5D\x03\x8F", + "\x1E\x04\x04\xBC\xBD\x04\x17\x03\xF1\x42\x74\xC0\x2C\xBF\x70\x41\x15\x04\xAA\x3C\x5C\x7B\x03\xEF\x80\xFB\x3D\x56\x00\x42\xC1\x2C\x26\x07\x2A\xF8\xB0\xD6\x17\x01\x0A\xC1\xFE\x24\x46\xC0\xE4\xB8\x5A\x38\x05\x14\xEA\x28\x77\xA8\x03\x7A\xC0\xF2\xBB\x16\x06\x12\xC1\x0B\x34\x00\x3F\x7A\xFB\x3D\x5E\x00\xE9\xBC\x17\x04\x0B\xCE\x09\xC7\xF6\x9C\xA7\x52\xBF\x61\x00\x52\xC1\xEA\xBF\x93\x62\xFD\xA6\x03\x2A\x81\xAA\x03\x1F\x1F\x76\xBA\x32\x74\x0C\x02\xFD\xAC\x03\x2F\x82\xA5\xC1\x9E\xAE\x7B\x4A\x19\x02\xFA\xB2\x07\x17\x05\xE1\x7B\xF9\x37\xD2\xBE\x3C\x02\x2F\xC6\x0C\x81\x0E\x4A\x03\x12\x7F\xFE\x00\xAA\xC0\x78\xBD\x2C\x24\x0D\x02\xFD\xA3\x04\x03\x83\xEE\x67\xD7\x3A\xE9\xBD\x22\x07\x19\xC5\xD1\xB0\xD6\x30\x01\x52\xBF\x8F\x00\x6A\xC2\x40\x07\xE0\xB0\x9E\x32\x03\x12\x7F\x95\x01\xDA\xC1\x75\xA5\x7A\x3A\xFA\xBB\x09\x01\x07\xEA\x62\x0E\x9C\xD2\xBF\x50\x02\x39\xC3\xFD\xB3\xF0\x1D\xC5\x4B\x08\xCE\x42\x65\x2E\x5C\xC2\xFC\xBC\x78\x92\xFD\xAE\x05\x26\x83\xF7\xBF\xF3\xB6\xE9\xBC\x2D\x01\x19\xC4\xE5\xB9\x73\x7E\x01\x52\xBF\xB9\x00\x78\xC3", + "\x44\x02\xCB\xBE\xE0\x32\xFE\x80\x03\x66\xC1\x32\xBE\xA4\x2A\x20\x02\xFA\xB6\x0C\x06\x07\xD6\x80\xC8\x6C\xD2\xBE\x66\x02\x40\xC1\x26\x0C\xE6\xB9\x52\x92\x7F\xD3\x01\xE6\xC1\xA3\xBC\x6E\x28\x11\x02\xFD\xB9\x06\x26\x83\xF9\xBC\x3C\x2A\x45\x02\xF4\xBF\x1B\x03\x11\xCB\x0A\x1F\x3C\x25\xB7\x55\x64\xE9\xBE\x39\x05\x24\xC5\x16\x06\xF4\xA9\x62\x0E\x01\xD2\xBF\x76\x00\x4B\xC2\x2F\x0E\xE8\xA9\xC5\x10\x02\x52\xBF\xF4\x01\x99\xC3\x63\x06\xD2\xB9\x8A\x32\x04\x12\x7F\xFB\x01\xE6\xC1\xB5\xBE\x82\x24\x12\x0A\xFF\xBE\xC9\x28\x77\x14\xC2\x20\x87\x90\x66\xF4\xBF\x00\x06\x14\xDB\xB5\x03\x84\xD7\xC0\x62\x3C\xE9\xBD\x03\x05\x29\xC3\x6B\x32\x07\xCF\x6F\xE8\x3C\xD2\xBF\x09\x00\x55\xC7\x29\xC7\xEB\xB6\x27\x5C\x02\x52\xBF\x19\x01\xA6\xC1\xD9\x2E\x02\x0F\x09\xC1\x07\x5E\x02\x25\xC0\x4D\xC2\x30\x2C\x59\xC6\x14\xCA\xC4\x8C\x01\xE9\x85\x97\x02\xAB\xC0\xE3\x6E\xF4\xBA\x05\x0B\x15\xD4\x16\x31\x82\xA9\x31\xA4\x00\xE9\xBC\x0C\x05\x2E\xCD\x5B\x15\xFD\xB6\x93\x26\x01\xD2\xBE\x1B\x00\x5F\xC6\xA9\x1F\x0B\xD0\xD6\x28\x02\x52\xBF\x3C\x01\xC1\xC0\x13", + "\x08\xDD\xB1\xC5\x2C\x02\xEF\x85\xF6\xC2\xCA\xC0\x7F\x24\x2B\x03\x0A\xCA\x18\xD9\x1F\x37\x7B\xD5\x32\xD2\xBF\x26\x01\x65\xC4\x91\x0F\xEF\xBA\xF5\x12\x7F\xD3\x00\x9B\xC3\xB5\xC1\xBE\x6C\x23\x92\xFD\xB9\x02\x21\x86\x9F\x1E\x53\xB7\xBE\x32\x36\x75\x57\x37\x1A\xD3\xBE\xA6\x1B\xD2\xBF\x65\x01\xD6\xC1\xF6\xAD\x26\x92\xFD\xAB\x03\x22\x85\xF0\xC2\xDF\xAE\xCA\x68\x2F\xC2\x36\xC4\x7E\xBF\xC0\x41\x83\x8F\xC3\x7D\xC2\x93\xBE\x51\x92\xFA\xBD\x07\x17\x0D\xD0\x86\xAD\xBE\xCC\x42\x60\x02\xF4\xBC\x10\x0C\x1B\xD8\xBF\xA9\x62\x42\x01\xD2\xBE\x45\x01\x73\xC7\xFF\xA6\xCA\x32\xFE\x90\x02\x46\xC3\xC1\xC2\xA0\xBD\xA8\x36\x18\x02\xFD\xB7\x04\x13\x87\x8D\xB0\xA9\x30\x64\x02\xF4\xBD\x13\x0F\x1D\xC0\x09\xC2\x12\xD2\xBF\xA3\x00\xEC\xC0\x61\xC0\x06\xC9\x73\x92\xFE\xAA\x02\x6A\xC3\x8B\xC2\x1B\xC1\x15\x92\xFA\xB1\x0B\x10\x0F\xD6\x86\xBC\xC0\xB1\x20\x68\x02\xF4\xB8\x17\x06\x1F\xDC\x0C\xC3\x81\xB5\x9E\xD2\xBF\x5F\x03\x77\xC2\x28\xCC\x53\x34\x06\x12\x7F\xC5\x01\xDF\xC3\xB8\xBE\x5A\x9A\xFA\xBB\x0C\x1F\x0E\xF7\x7D\xFD\x32\xD8\x00\xE9\xBD\x34\x07", + "\x3B\xCF\x05\xCA\x90\x1A\x03\x52\xBF\xD7\x01\xEF\xC2\x19\xC0\xA9\x2C\x0D\x12\xFE\x9D\x03\x7D\xC3\x50\x3C\x01\x04\x79\xBE\x1B\x00\x07\xD1\x85\x21\x88\xD3\x27\xE4\xBA\x72\x02\x1F\xC1\x60\xAF\xF1\x03\x01\x24\x77\xEC\x01\x2B\xC4\x32\x2F\x89\xC2\x20\x04\x02\x04\xEF\xB4\x03\x31\xC4\x3D\x2F\x19\xC5\x40\x06\xCA\x30\xAD\x3C\x07\x38\x88\xEF\x2F\x3A\xC4\x00\x02\x09\x04\xBC\xB4\x00\x17\xC7\x78\x81\x9F\x08\x1F\x1E\xFA\x2F\x4C\x76\x48\xC4\xAD\x25\x0B\xEC\x86\x14\x00\xF7\x71\x86\xB4\x70\xC3\x20\x08\x01\x03\xFD\xBB\x7B\x16\x00\x51\xC5\x54\x1B\x94\xC2\x20\x05\x25\xC4\xA2\x90\x6B\x18\x00\x59\xC5\x68\x1B\x66\xC5\x4B\xC0\xFB\xB6\x27\x5A\x00\x61\xC4\x9C\xAF\x31\xC6\x5F\xC5\xD3\x4C\x01\x08\x13\xC3\x04\x7A\x01\x6A\xC4\xDD\xBD\x5F\x36\x03\x0E\x26\xD9\x11\x7B\x3B\x81\x02\x64\xC4\x5C\x95\x8A\x4D\x4E\xC9\x6A\x35\x0B\x60\x59\x79\xC4\x61\xB5\x7D\x3E\x08\x04\x4F\xCA\x20\x15\x0B\x73\x5A\x00\xC5\xBB\xAF\xC0\xB8\xA1\xC1\x02\x06\x28\xCC\x08\x08\x8A\xC2\xAF\x10\x52\x42\xC7\x05\x05\x51\xC2\xAF\x26\xF8\x9D\x74\x04\xC5\x1D\x00\x4A\xC5\xE7\x58\x35", + "\xCE\x66\x64\x14\xE3\x00\x1A\xC5\x54\xC5\x88\xBD\x2A\x34\x05\x04\x28\xC9\x01\x20\x8A\xDC\xC4\x1F\x1E\x76\xC0\x8F\x0C\x50\xCF\x02\x15\x0B\x65\x5D\x0F\xC5\x64\xA6\x18\x00\xA1\xC6\x06\x07\x2A\xD8\x13\xDF\x3C\x78\xC1\xAA\x36\x42\xC4\x0F\x06\x4F\xCE\x28\xDF\x78\x06\x75\xCC\x43\x34\x00\x42\xC5\x10\x06\x55\xCD\x2B\xD2\xBF\x8C\x87\x36\x00\x84\xC4\x24\x01\xAD\xC0\x00\x0F\x28\xC9\x08\xE5\x68\x04\xC5\x4E\x01\x65\xC7\xA3\xC7\x21\xC3\xF0\x1A\x01\x04\x8A\xD4\x00\xC4\xC5\x4A\xC4\x07\xC7\xFD\x2C\x03\x04\x14\xDB\x01\x52\xC5\x23\xC0\xB3\x50\xA1\xC1\x0C\x00\x2E\xCC\xEB\x9D\x9A\x40\x00\x84\xC5\x33\x01\xB6\xC3\x53\xCC\x1E\xCC\x0E\x42\x01\x04\xC5\x6E\x01\x75\xC5\xA8\xC2\x3E\xCC\x1C\x44\x02\x04\x8A\xF5\x00\xF2\xC4\x54\xC4\x7E\xC3\x69\x74\x28\xDC\x03\x39\x8B\xB6\xC5\xFF\xC3\x56\x64\x12\x04\x50\xC3\x08\x05\x17\xCA\x81\x9D\x4D\x4A\x00\x42\xC5\x22\x06\x60\xC3\xD9\xB2\xF8\x44\x8A\x8F\x01\x0C\xC7\xCC\xBB\xBE\x3E\x09\x04\x28\xD5\x04\x11\x8C\x9E\xBB\xA2\x52\x42\xC7\x26\x07\x62\xC3\xDA\xBB\xF7\x12\x01\x04\xC5\xA1\x01\x7F\xC4\x00\x03\x48\x21", + "\x1D\x04\xEF\x94\x01\x77\x71\x70\x92\x92\xC4\xF7\x24\xBC\xBA\x05\x0C\x12\xFE\x4B\x2A\xC6\xD9\x26\xF2\xBA\x18\x06\x65\xC4\x66\x30\x19\xF4\x88\xE4\xBB\x6A\x00\x9A\xC5\xCF\x2E\x66\xCB\x23\xC4\xEF\xB2\x01\x3A\xC6\xF0\x35\x8F\x1F\x90\xC6\x2B\xB0\x34\xC0\xCF\x3C\x8C\x89\x27\xE4\xBA\x41\x01\xD1\xC5\x2F\x3A\x01\x0E\x12\xD5\xB0\x04\xC5\xA8\x00\x5E\xC5\x42\x05\x69\xCC\x16\xCF\xB7\x37\xE4\x47\x8E\x52\xC6\x83\x00\xD5\xC4\x81\xBC\x1A\x4E\x04\x04\x8A\xB2\x01\xCB\xC5\xAD\xC4\x92\xB7\x16\x60\x09\x04\x14\xF8\x02\x61\xC6\x6B\xC5\x7A\x30\xA1\xC6\x17\x08\x36\xD2\x13\xC5\x44\x14\x01\x84\xC4\x62\x01\xDB\xC0\xF8\xB1\x0B\x36\x04\x04\x8A\xCA\x01\x59\xC7\x81\x02\xD8\xC1\x50\xC1\x0E\x58\x04\x04\x8A\xCF\x01\x73\xC7\xE7\xBE\xD4\x7C\x50\xC5\x0D\x01\x1C\xD5\x7F\x86\xA3\x84\xC5\x6D\x02\xE1\xC3\xFB\xBA\x8C\x7E\x04\x04\x8A\xE1\x01\x8B\xC7\xF0\xBC\xC0\x68\x14\x04\x28\xC7\x07\x11\x8E\xE6\xBF\xA2\x00\x42\xC5\x3B\x01\x72\xCA\x2A\xD1\x27\x04\x8A\xF3\x01\x22\xC7\xBD\xC4\xA2\xB1\x1C\x46\x0A\x04\x14\xFA\x03\x11\xC7\xB8\xC4\x7E\x08\xA1\xC0\x00\x01\x24", + "\x4C\xE4\x1D\x3F\x3E\xC5\xB3\x5C\x55\x00\xA1\xC5\x00\x0D\x3A\xC7\xBC\x3A\x8D\x84\xC2\x67\x80\x42\xC4\x03\x05\x76\xCE\x14\xD3\x1A\xD3\x75\xD5\x32\x84\xC4\x09\x00\xEF\xC3\xD6\x22\x3A\xC9\xDC\x89\xD6\x04\xC5\x18\x00\xDE\xC5\xD9\x2D\x78\xCD\xE6\xAC\x0E\x72\x02\x04\xC5\x1F\x01\xE1\xC7\xEB\xC7\xB6\x7E\x38\x64\x14\xE5\x00\x52\xC7\xBE\xC6\x73\xC7\x5B\x34\x50\xCB\x02\x0A\x1E\xD3\x8F\xF3\xBA\xCC\x42\x5C\x00\xA1\xC2\x06\x0E\x3D\xD9\x1E\xD6\x4B\x8D\x5D\x84\xC5\x1C\x01\xF9\xC2\x6B\xC5\x13\xD0\xD6\x3C\x02\x04\xC5\x40\x01\xF5\xC7\xED\xC1\x60\xC8\x4D\xA4\x14\xC7\x01\x58\xC7\xEC\xC6\xDF\xB5\xA8\x30\x18\x04\x28\xCD\x02\x38\x8F\xF3\xC7\x50\xC1\x4E\x4E\x30\x04\x50\xC3\x05\x1F\x1F\xC2\x68\x1F\x1E\x0F\xC4\xC5\x94\xA1\xC1\x0B\x06\x40\xC1\x08\x05\x8F\x95\xC4\x3C\x2A\x63\x00\xA1\xC7\x0B\x0D\x40\xC0\x00\x05\x8F\x9B\xC4\xB8\x2B\xA9\x70\xF7\x4A\x7E\xC4\x75\x3F\x78\x1F\x5F\x53\x5D\x28\xC6\x80\x37\xC7\x1A\x04\x04\xDE\xB0\x06\x0B\x8D\x85\x22\xE6\x2F\xCB\x34\x79\xBB\x38\x79\xB8\x96\x8D\x29\x90\x83\x02\x35\xC4\x68\x34\x38\x07\x84\xCE\x42\xDF", + "\x78\x3C\x88\x83\x59\x34\xC9\xF2\x2E\xD0\xC4\xBC\xB0\x0F\x19\x21\xFC\x54\x2F\xC8\xB1\x50\xF2\xB8\x3E\x06\x87\xCA\x5A\x3C\x00\x0E\x8D\x87\x72\xB3\x38\xC4\x24\x1B\x04\x77\xC0\x66\x26\x22\xD5\x8D\x86\x4C\x49\xC9\xD1\x38\x13\xC8\x7A\x21\x17\xD6\x27\x44\x00\x51\xC8\x8B\x63\x0A\xCA\x13\xCD\x4C\xCB\x43\x78\x22\xF6\xAD\x5A\xC8\x69\xC7\x81\x30\x02\x06\x8B\xC1\xF3\xA0\x23\xEE\x8D\xB6\x23\x0A\x00\x32\xC9\xF6\x6E\x8C\xC4\x37\xDE\x97\x0C\x00\x6A\xC8\xA0\x29\x29\xCA\xE0\x27\xF8\xB9\x8A\x2E\x00\x30\x91\xA6\x79\x6C\xC8\xC1\xC4\x62\x37\x8E\xC9\x09\x19\x23\xC7\x8E\xCA\x71\xED\x73\x71\x2F\x27\x06\x8F\xCC\x38\xDD\x04\xF7\x91\xA5\x01\x84\xC8\xC9\xC6\x32\x76\x02\x07\x47\xCB\x05\x09\x92\xE6\xBF\x18\x01\x3B\xC9\x2C\x01\x91\xCD\x39\xDA\x1A\xF7\x91\xB7\x01\x1C\xC9\x9D\x2C\x92\xBF\x02\xA7\x47\xDE\x05\x09\x92\xA9\xC7\x09\x02\x0F\x03\x1D\xCC\x18\x02\x47\xCB\xD9\x30\x8E\xA2\xA0\x77\xC9\x64\x01\x26\xCA\x69\x38\x3B\xC1\x07\x62\x00\x77\xC8\xD0\x01\x44\xCA\xB3\xC7\xF9\x14\x02\x17\x23\xD6\x03\x09\xC9\xD4\xC4\x86\x02\x09\x07\x8E\xCC\x0D\x0B\x25", + "\xDB\x91\xD9\xA5\x1D\x3B\x3B\xCB\x38\x01\x91\xCA\x11\xCF\x7E\x2A\x00\x77\xC8\xE9\x01\x44\xCA\x79\xC0\xA9\x2C\x02\x17\x23\xEF\x03\x3E\xC9\x27\xC3\x59\x5E\x0B\x07\x8E\xC6\x0F\x10\x26\xF4\x8B\xF9\x5C\x02\x75\x71\x2D\x3F\x06\x9A\xC0\xD8\xB9\x49\x77\x91\x84\x00\x47\x45\xBB\x2F\x1C\xCC\x7E\xC0\x70\x74\x01\x37\x91\x8B\x00\xE1\xC9\xA3\xC2\x29\xCA\x7F\xC7\x2C\xD7\x23\xD1\x00\x69\xC9\xBD\xC7\x75\xC9\x00\xCF\x89\x77\x47\xD7\x00\x30\x93\xBC\x2D\x08\xC8\xAB\x53\x1D\xCD\x03\x07\x4F\xD4\x22\xF0\x7A\xF9\x5C\x3C\x01\x3B\xCB\x08\x05\x9F\xC3\x4E\xDD\x0A\xDD\x9A\x09\x74\x7C\x30\x78\xC9\xD9\x2F\x49\x25\x32\xD0\xD6\x00\x01\x33\x39\x70\x92\x86\xCB\xCA\xC5\x87\x83\xCB\x27\x12\xF6\x1B\xAD\xC4\xE4\xBA\x27\x01\x45\xCA\x6F\x3F\xF1\x11\x21\xC8\x82\x9B\xCA\x5F\x36\x1B\xC8\x79\xBE\x0B\x00\x52\xC4\xB3\x12\x94\x83\x02\x43\xC6\xE1\x8D\x49\xCD\xE7\x27\x52\xC1\x22\xC0\x86\x2B\xCA\xEF\x2E\x0F\x03\x11\xCD\x12\x37\x47\xD0\x01\x30\x93\xE0\x2C\x32\xCB\x27\xC8\xED\x7F\x8E\xC5\x03\x17\x29\xCF\x64\x55\xC8\x9D\x4C\x14\x77\xB8\x2A\x07\x04\x50\xDE\x9D\x37", + "\x85\x80\x3C\x77\xC8\x20\x01\x51\xCC\x63\x21\x46\xC1\xA8\x77\x91\xC6\x00\x4B\xCB\xBD\x31\x61\xC3\xDF\x30\x08\x17\x23\xCC\x01\x51\xCA\xAB\x38\xC6\xC1\x85\x3F\x8E\xC2\x05\x1E\x29\xE1\x92\xF4\xC8\xD0\x34\x42\x03\x1D\xCF\x0A\x08\x55\xC2\xB8\x17\x86\xD0\x35\x86\x01\x3B\xC9\x17\x05\xAC\xC9\x53\xD2\xB7\x63\xE7\x77\xC8\x63\x00\xB6\xCA\xA5\xC1\x3D\x47\x47\xC9\x03\x32\x95\xA2\xBA\xF7\x7F\x3B\xCB\x1B\x07\xAE\xC9\xD2\xBA\xA9\x77\x91\xF5\x00\x7C\xCA\x17\x9D\x03\xBF\x8E\xCB\x07\x0A\x28\xFF\x94\xB9\xC3\xE7\x49\x3B\xCA\x20\x01\xB0\xCA\xE3\x93\xF2\x37\x91\x88\x01\x5E\xCA\xA3\xCA\x70\xC4\x39\x46\x09\x17\x23\xCD\x02\x06\xCB\x5F\xCA\x63\xC5\x9E\x9F\x8E\xC4\x09\x0C\x2C\xCE\x39\xE8\x3C\x77\xC8\x4D\x02\x67\xCE\x78\xCB\xEF\x3C\x04\x37\x91\xA0\x01\x98\xCA\xC9\xCA\x76\xC3\x88\x97\x47\xC7\x05\x23\x96\xC5\xC9\x03\x1E\x50\x03\x1D\xCD\x15\x03\x5A\xCB\x26\xD0\x5B\x77\xC8\xB3\x01\xD4\xC8\x53\xCD\x5D\xC9\xE7\x44\x05\x37\x91\xBA\x01\xBA\xCA\xA9\xCB\x35\xCC\xFA\x67\x47\xC1\x06\x01\x97\xD9\xCA\xFB\xC4\x32\x2E\x8F\x73\xDC\x28\x0C\x07\x2E\xE6\x95", + "\xE4\xC9\xCA\x70\x55\x03\x1D\xCF\x19\x03\x5A\xC4\x10\xEA\x56\x2C\x01\x77\xC9\x6A\x03\x68\xCA\x41\xCD\x4F\x97\x23\xDB\x03\x23\xCB\x09\xC8\x36\xBB\x1D\xC9\x1C\x03\x5A\xD0\x20\xEA\x56\x32\x01\x77\xC9\x73\x03\x68\xC8\x83\xCF\xFC\x14\x05\x37\x91\xED\x01\xCE\xCA\x2A\x25\x43\xCE\xDC\x80\x51\xD9\xDD\x23\x90\xE4\xBB\xBC\x00\x98\xC9\xF0\x30\xA3\xC0\xAD\x24\x06\x3A\x97\xC9\x37\x1D\xCA\xF2\xB8\x33\x07\xBF\xCF\xBC\x22\x29\xE7\x21\x84\xCC\xD5\x37\x1D\xC9\xD7\x88\xC1\xCB\xBD\x29\x12\xE9\x88\x8C\xCC\xE1\x37\x99\xCB\x40\x34\x1D\x07\x47\xD4\x07\x11\x96\x83\x02\x20\x00\x2B\xC4\x7C\x4F\x8E\xC9\x0F\x17\x30\xFF\x15\xC0\xCA\xD7\x71\x3B\xCA\x3F\x05\xAC\xC9\x61\xD5\xF6\xAF\x5B\x72\x01\xDF\xC8\xA8\x47\xAC\x2D\xC4\xC9\x0B\xC3\xC7\x77\x91\x8A\x00\x2A\xCC\x86\x00\x8B\xCD\xF4\xAC\x1A\x56\x07\x37\x91\x90\x00\x31\xCC\xE4\x26\x56\xCB\xDF\x38\x0F\x17\x23\xD6\x00\x50\x46\x60\x2D\x19\xCC\xDF\xC4\x35\x4A\x0F\x17\x23\xDB\x00\x39\xCC\x06\x02\x21\xCD\xA2\xC1\x6A\x97\x47\xC1\x01\x08\x99\x98\xCC\x9D\xC2\x68\x36\x3F\x07\x8E\xC7\x02\x0F\x32\xDF\x98\x84", + "\x98\xEE\xB5\x7E\x38\xE2\x25\x05\x06\x65\xC1\x08\x0A\x99\x8A\xC9\xB1\x20\x01\x02\x96\xCC\xBC\x1D\x65\xC0\x00\x1F\x99\xE6\xBF\x04\x01\x31\xCF\x04\x45\xCC\xCF\x65\xD5\x24\xED\x5B\x6A\xCC\x1B\x42\xA8\x45\xD9\x2F\xCB\xC4\x36\xA8\x00\x30\x99\xA9\x43\x6C\xCD\x5B\xC5\x2A\x32\x01\x07\x67\xDF\xA0\x00\x99\xB2\xCC\xA7\xC9\x25\x6D\x9F\xCA\x8C\x42\x67\xC0\x34\xDA\x96\xAD\x65\x0E\x01\x41\xCC\xA4\x31\xCF\xC9\xB0\x9E\x45\x4A\x9A\xDE\x00\x8C\xCC\x87\x95\x38\x42\x02\x0A\x68\xC4\x03\x05\x9A\xBA\xCC\xDB\xC4\xF0\x30\x05\x02\xD1\xCB\x06\x11\x34\xD9\x2C\xD7\xC4\x8A\xCD\x38\x02\xA7\xCB\x4D\x7F\x25\xCA\x34\xF7\x01\x17\xCD\x49\xCD\x68\xC9\x04\xA2\xD1\xCE\x07\x08\x35\xD0\x99\xC3\xCB\xB7\x60\x0E\x02\xA2\xCD\x10\x0E\x6A\xD7\x32\xDD\x93\xED\xBA\x8A\xCC\x46\x01\xAD\xCE\xCB\xCC\x13\xC2\x81\x8A\x9A\x93\x01\xA3\xCD\x07\x8D\x2A\x32\x04\x0A\x68\xD9\x04\x01\x9B\xC9\x96\x0A\x52\x45\xCF\x27\x07\xD8\xC1\x5E\xCA\x90\x26\x00\x0A\xCD\xA5\x01\x63\xCE\x79\xC8\xA9\x28\x02\x0A\x34\xEB\x02\x47\xCD\xEC\xCB\x81\x1E\x0A\x02\xD1\xC1\x0B\x1B\x35\xCE\xDE\x1E\xC8", + "\xE4\xBA\x16\x01\x3F\x38\x2E\x9D\x7E\x33\x28\xFB\x7B\x32\x00\xFD\x38\x8B\xCB\xB7\xC9\x80\x44\xDE\xBA\x01\x29\x9B\xB1\x21\xE5\xCC\x18\xC8\x79\xBA\x08\x0F\x6E\xDE\x97\x31\x9B\xB2\x39\xE4\xBA\x25\x01\xBD\xC9\xC0\xAA\x60\xDE\x18\xFB\x9B\xF6\x37\x0E\xCD\x4B\x8F\xBF\xCF\xFD\x24\x42\xC7\x0E\xDF\xD2\x7D\x39\xCC\x6A\x17\xC6\xB6\xC4\x77\x58\x70\xD1\x85\x1E\x94\x80\xC8\xD6\x91\x86\xCC\x2E\x3F\xE3\x1F\x4B\xCC\x0D\x65\x01\x12\xCE\xE8\x39\x8F\x1D\x5B\xC9\x1C\x46\x06\x18\x38\xDD\x80\x9F\x1E\x5F\xCC\x7D\x7A\xC7\xCF\xFD\x26\x03\x33\x2F\xE1\x83\x68\x00\x23\xCE\xF0\x31\xC9\xCE\xDC\xC1\x0E\x49\x03\x3D\x73\x17\xC1\x2B\xCF\x98\xC4\xB4\x34\x0D\x0F\x72\xDA\x81\x81\x98\xD4\x4E\x35\xCE\x7F\x25\xCC\xC8\xDF\xC3\xDE\x39\x39\xDD\x6E\x7D\xCD\x23\x6E\x9F\xCD\xCF\x2B\xE7\xC0\x3F\x24\xEF\xB8\x01\x42\xCE\xEF\x2F\x14\x02\x84\xC9\x54\x3B\x07\x0A\x34\xF8\x02\x65\xCC\x4A\xCE\x9D\xC8\x73\x45\x0F\x0A\x68\xDE\x05\x10\x9D\xA0\xCC\x2A\x60\x45\xCC\x31\x06\xDB\xC1\x75\xDC\x22\xEF\x5B\x01\x01\x8A\xCD\x65\x00\xD7\xCD\xA9\xCC\x1C\x43\x04\x0A\x9A\xD2\x01\x63", + "\xCF\x33\xC9\x52\x8A\xD1\xC9\x0D\x09\x3B\xED\x91\xE4\x2C\x87\x00\x45\xCC\x38\x07\xEA\xC1\x19\xC4\xB3\x09\x02\x0A\xCD\xE6\x00\xB7\xCE\x1E\xCF\x2F\x7A\x68\xCD\x07\x3A\x9D\xFF\xC8\x60\xA2\x45\xCC\x3D\x07\xEF\xC5\x48\xD4\xD8\x4A\x9A\xFB\x01\x84\xCE\x30\xCD\xEB\x72\xD1\xC2\x00\x12\x12\x65\x5D\x5D\xCE\xE2\x94\x68\x37\x24\x02\xD1\xC9\x00\x0E\x3C\xF9\x4F\x29\xC5\xA9\x31\x4A\x02\xA2\xC8\x02\x02\x25\x42\xBE\x10\x9E\x99\xA5\xEE\x48\x45\xCC\x06\x06\xF2\xC9\x10\x1F\x3C\xC1\x04\x20\xC9\xBB\x28\x45\xCF\x07\x02\x4A\x43\x6B\x26\x3D\xF9\x3D\xF0\x4F\x8A\xCD\x12\x01\xE7\xCF\xF2\xC7\x68\xD7\x85\x64\xEA\x63\x2D\x2D\x00\xD2\xCF\x89\x2F\x77\xCA\x7B\x6A\x34\xF4\x00\x3A\xCF\x1C\x39\x0A\xC0\xEC\x72\xD1\xCB\x03\x13\x3D\xE5\x9E\x95\xC2\xD0\x35\x51\x02\xA2\xCB\x08\x00\x7C\xDB\xDD\x21\x8B\xFB\x3D\xA5\x00\x45\xCE\x12\x05\xF9\xC8\x65\x29\x01\xD0\x6B\x27\x01\x8A\xCD\x28\x02\xF1\xCB\xF7\xCC\x5B\xCB\x11\x8A\x9A\xD9\x00\xDB\xCF\xE0\xCC\xAC\xC8\xE0\x6B\x0A\x0A\x34\xE1\x01\x61\xCF\xCE\xCF\xE4\xCB\x39\x8A\xD1\xC9\x06\x08\x3F\xD5\x9F\xD0\xCB\xB1\x21", + "\x57\x01\xA8\xCC\xFA\xC1\xB6\x3F\x78\x16\x97\xC8\x2A\xB1\x00\x45\xCC\x1E\x04\xFE\xCE\x7A\xDC\x2E\xC3\x1B\x8A\xCD\x7F\x00\xFE\xCD\x3E\xCE\x77\x7A\x68\xC6\x04\x02\xA0\xFF\xC9\xAD\x65\x5B\x02\xA2\xCD\x11\x07\x80\xC6\x28\xDD\x6C\x0A\xCD\x94\x00\xF7\xCE\x94\x0B\xE9\xCC\x1C\x5B\x05\x0A\x9A\x9C\x01\xAC\xCF\x15\x0E\x86\xC8\x05\x5A\x68\xC2\x05\x19\xA0\xB0\x0C\x58\xCF\x50\x37\x2F\x02\xD1\xC8\x0A\x14\x3F\xEB\x00\x47\xCA\xFB\x3D\x60\x02\xA2\xCF\x15\x06\x82\xC4\x3B\xF9\xB9\x43\x01\x8A\xCC\x5B\x01\x0B\xD2\xED\xCC\x53\x25\x06\x0A\x9A\xBD\x01\x33\xD1\xB7\xCD\xCF\x2F\x18\x0A\x75\xDF\x40\xF5\x18\x60\xCA\x02\x8C\x45\xCE\x32\x01\x07\xDB\x77\xD1\x65\x8A\x9A\xD1\x01\x44\xD0\xC0\xCE\xBF\x25\x19\x0A\x68\xD8\x06\x09\xA1\x85\xCF\x64\x2D\x67\x02\xA2\xCF\x1B\x0F\x84\xCA\x3C\xF6\x0A\xF8\xCE\x55\xD0\xF3\xBF\x34\x05\xEF\xC5\x85\xCE\x33\xC6\x2E\x02\xCF\x12\xD1\x13\xD0\x62\xCE\x9E\x47\x0D\x0A\x34\xFC\x03\x55\xD0\xA8\xCF\xF9\x16\xA2\xCB\x00\x00\x2E\x53\xB5\x22\xA1\xFD\xC1\xAD\x65\x6D\x00\xE5\xC8\x5C\x42\x7C\x2F\x43\xD0\x17\xF6\x49\xDD\x00\x45", + "\xCD\x04\x00\x5C\x45\x76\x36\x43\xCE\x87\x8D\x46\xA2\xCE\x3E\xD2\x06\xD5\x5C\x8A\x84\x4A\x3D\xF4\xA1\x83\xD1\xAB\xCB\x3C\x5F\x38\x02\xD1\xC7\x02\x02\x44\xE0\xA0\xD4\xC7\x9D\x4D\x72\x02\xA2\xCE\x05\x0E\x88\xDF\x41\xDA\x8F\xD3\x39\x8A\xCD\x1A\x03\x21\xD7\x11\xD0\x3E\xD9\x73\x69\x03\x0A\xCD\x3D\x01\x4D\xD2\x25\xD7\x7C\xC3\x90\x2B\x07\x0A\x9A\xC5\x00\xA2\xD1\x1F\x0D\xFB\xC3\xDF\x3D\x0E\x0A\x34\xCD\x01\x29\xD1\x44\x0D\x5E\xCF\xBE\x3F\x1D\x0A\x68\xD5\x02\x15\xA2\xAA\xD1\xEC\xC9\x3C\x5D\x3C\x02\xD1\xCC\x05\x17\x45\xF1\xA2\xC9\xC2\xCC\x43\x79\x02\xA2\xCB\x0C\x0E\x8B\xC9\x32\x03\xA0\xFB\x3D\xF5\x00\x45\xCE\x1A\x05\x18\xD3\x81\xC8\x40\xF7\xC2\x77\x01\xA1\xCC\x66\xD2\x1F\xD6\x7A\xB2\xFC\x3A\x3F\xF0\xA2\xCB\x0C\x36\x1E\xF2\xBB\x3E\x03\xDC\xC1\x0B\x3F\x92\x32\x18\x64\xBB\x01\x01\x90\x3A\xBA\xCB\xFF\x2C\x89\xD7\x67\x61\x74\x4C\x6B\x2E\x20\x7F\x1C\x79\xBA\x01\x07\x8E\xD1\x85\x29\xA3\xB7\x0C\xE4\xBB\x05\x01\x48\x3F\x12\xCF\x02\x14\x40\xED\x3F\xA1\x3A\x88\x26\x40\x00\x33\xD5\x1E\xD2\x75\xDF\xE9\xB8\xA3\xDC\x47\xFB\xD1\x10\xD0", + "\x73\x42\x02\x0F\x8F\xC5\x86\x17\xA3\xAE\x65\x28\xD0\xEC\xA9\x41\xD6\x20\x06\x09\x07\x48\xFC\xA3\xAD\xCC\xEF\x2C\x0B\x03\x42\xD5\x26\x2E\x90\xD3\x2A\xE1\x83\x18\x00\x13\xD2\x17\x89\x45\xD4\x18\xC7\x8E\x59\x48\xC1\x04\x2E\x01\x01\xD3\xBA\xCE\xCC\x36\x23\xD4\x72\x9B\x48\xD0\x83\xD6\x9A\x24\xD3\x5E\x02\x49\xD5\x1A\xCC\x8F\x44\x49\xC5\x03\x2B\xD2\xDB\xC1\x61\xCC\x49\xD5\x19\x00\x93\xC2\x07\xD0\x6B\x24\x00\x24\xD3\x6A\x01\x4D\xD7\x1C\xC0\xAD\x26\x01\x24\xA4\xDD\x01\x3B\xD2\x2F\xD1\x40\x00\x05\x04\x92\xC5\x07\x20\x8B\x07\x04\x0F\xD3\x79\xC0\x65\xBC\x24\xDE\x0E\x1B\x49\xE9\xA1\x82\x02\x2C\x00\x92\xD2\x3D\x01\x24\xD0\x87\xCD\xF5\x64\xA4\xFD\x01\x47\xD2\x86\x01\x52\xD4\xA9\xB1\x0E\x50\x01\x24\xA4\x86\x00\xB4\x46\xDB\x2D\x42\x03\x2B\xDF\x59\xC5\x58\x64\xA4\x8E\x00\x61\xD2\x41\x53\xA3\x0A\xF8\xC8\xB3\xA4\x49\xD6\x00\x69\xD2\x48\xD2\xE4\xCC\xC6\x54\x24\xDF\x01\x09\x4B\xC2\x5F\x64\xD2\xE0\xC2\x68\x34\x0E\x04\x24\xD7\x02\x16\x4B\xDA\xA5\xD6\xCF\xFB\x3C\x1D\x00\x49\xD7\x05\x00\x97\xDF\x4B\xDD\x9F\xB7\x61\x3C\x00\x92\xD0\x0E", + "\x05\x30\xD3\x96\xCE\x09\xE6\xA5\x24\xD2\x41\x00\xC6\xD3\x5A\xD2\xFD\xCF\x7E\x20\x02\x24\xA4\xCA\x00\x92\xD3\x20\x0E\x2C\xD6\x2E\x54\x92\xD3\x02\x3E\xA5\x8D\xD3\xB9\xD1\xD2\x8C\x49\xD3\x0B\x0F\x99\xD3\x4C\xF3\x93\xFE\x7D\x24\xD3\x31\x01\x69\xD2\x33\xD0\x15\xC3\xC8\x08\x01\x24\xD2\x6B\x01\xD5\xD2\xC7\x16\x0B\xC9\x8A\x2A\x02\x24\xA4\xF3\x00\xB2\xD3\x80\x00\x5E\xD1\xDB\xCA\x3A\x44\x49\xFB\x01\x19\xD3\xA1\x0C\x7B\xD0\x57\x84\x24\xD4\x08\x09\x4B\xE5\x5D\x31\x00\x1B\xD0\x7B\x48\x14\x04\x24\xDB\x08\x06\x4E\xCF\x19\x02\xD2\x79\x5C\x29\x00\x49\xD2\x12\x09\x9B\xD4\x32\x09\xA4\xAC\x7E\x24\xD2\x4D\x01\x75\xD0\x39\xD1\x51\xA1\xD5\x16\x01\x24\xD2\xA2\x01\xED\xD2\x45\xD4\x35\x48\x05\x04\x49\xEA\x02\x62\xD3\x1C\xD3\xE3\x50\x49\xD2\x16\x0E\x9C\xDD\x34\x00\xA1\xE1\x41\x5C\x00\x92\xD1\x2E\x00\x3D\xD7\x92\xC0\x05\xE4\xA4\xC1\x01\xF4\xD2\x96\xD1\x8F\x64\x24\xD9\x0C\x19\x4F\xF1\xA4\xD0\x35\x62\x00\x92\xD1\x34\x06\x3F\xD6\x93\xCE\xFB\x64\xA4\xD9\x01\x04\xD4\x9E\xD2\xF0\x8C\x24\xD1\x0E\x09\x50\xC2\xA5\x80\x00\x68\x00\x92\xD1\x3A\x00", + "\x38\xD1\x10\x1C\x4E\xDB\x7C\x81\x7F\x24\xD2\x79\x01\x82\xD7\x29\xD1\x10\x0C\x03\x24\xA4\xFA\x01\xED\xD2\x83\x02\x85\xD2\x92\xA0\x18\x44\x49\xC1\x00\x32\x47\xCB\x09\x11\xD4\x57\xD4\x35\x40\x07\x04\x49\xCA\x00\x28\xD4\x62\xD2\x11\xD4\xEF\xCB\xDF\x32\x07\x04\x49\xD2\x00\x30\xD4\x6A\xD2\x48\x2C\x5B\xD3\xDF\x34\x07\x04\x49\xDA\x00\x38\xD4\x07\x04\x15\xD4\x02\x66\xC1\x94\x92\xC3\x01\x38\xA8\xC2\x2F\x42\xD5\xBC\xD3\xBE\x38\x0F\x04\x92\xCB\x01\x07\xA9\xCF\xD3\x97\xD1\x50\x36\x1E\x04\x24\xD3\x03\x00\x52\xD0\xA9\x9D\xD1\xAD\x64\x3E\x00\x49\xD4\x07\x06\xA5\xCE\x4F\xE3\x9F\xCA\x71\xA4\x79\x71\x2D\x11\x05\x4B\xD2\xA3\xD4\x4C\xD7\xD6\x24\xD2\x4E\x00\x32\xD6\x8E\xD0\xFE\xCE\x2F\x22\x04\x24\xA4\xD7\x00\x4F\xD4\x2F\xD7\xC1\xC7\xDD\x24\x08\x04\x49\xDF\x01\x71\xD4\x65\xD5\xD3\xD2\xF8\x7C\x24\xD7\x06\x18\x53\xEB\xA9\x99\x9D\x03\x32\x44\x00\x49\xD7\x0D\x0E\xA7\xC1\x4E\xCE\xA3\x80\x6E\x8A\x00\x92\xD3\x1D\x05\x50\xD5\xA1\xDF\x78\x3C\xA6\x89\x02\xAC\x79\x71\x2F\x1F\x02\x4D\xD5\x6A\x1F\x78\x30\x00\x64\xBB\x8E\x01\x90\x38\x5C\x95\x4C", + "\x27\x40\x24\xEF\x94\x02\x62\xD1\xB1\x20\x2F\x3D\x9E\xD6\x37\xBD\x8E\xC8\xA3\x56\xAA\xE4\xBB\x9D\x01\x52\xD4\x99\x2D\x04\x2D\xA9\xD8\xF3\x33\xA3\xB1\x21\x35\x00\xE1\xD3\x2D\x61\x14\x04\x92\xC8\x04\x0C\xAA\xC1\x3E\xC9\xD3\x4E\x4F\x28\x04\x24\xD0\x09\x17\x55\xF1\xAA\xDE\xC4\xD0\xCE\x92\xD0\x26\x04\x52\xD0\xAF\x17\x4E\xF6\x93\x27\x01\x24\xD3\x50\x00\xB1\xD0\x57\xDD\x9D\xCC\x0E\x69\x02\x66\xD3\xCB\xD5\x5F\xD6\xA4\x9C\xBC\x74\x92\xD3\x05\x11\xAB\xBB\xCC\xE1\x41\x56\x00\x49\xD4\x17\x0E\xAB\xCF\x4F\xEC\x86\x2F\x01\x24\xD2\x62\x03\xB5\xD7\x58\x9B\xEF\x31\x05\x33\xA4\xE3\xD5\x6E\xCB\x7D\x3F\x2C\x04\x24\xD6\x0D\x08\x57\xDC\x74\xD9\x4A\x24\xD3\x6F\x02\xBB\xD0\x8E\x39\x8A\x37\x05\x24\xA4\xE8\x01\xF3\xD5\x80\x02\xF9\xB9\x17\x04\x92\xD1\x07\x39\xAB\x8E\x45\x93\x5D\x0F\xD4\x8E\xD1\x41\x02\xAD\xCA\x4A\xF4\x32\xA4\xD2\x04\x00\xDD\x46\x27\x0D\x60\xDD\x58\xC2\xD9\x24\xA4\x8D\x00\x0A\xD6\xF8\xBA\x0F\x19\xD0\xC6\x7A\xA4\x49\xD5\x00\x11\xD6\xFD\x0A\x86\xD7\x01\xC4\x55\x44\x97\xD8\x58\xCD\x23\x1A\xD6\x0F\xC1\x81\x3C\x49\xD0\x05\x0E", + "\xB1\xC7\x10\x20\xAC\xB9\xC9\x48\x14\x92\xD1\x0C\x06\x63\xD4\xB0\xD2\x4B\xE1\x83\x49\x01\x24\xD3\x1D\x01\xC9\xD3\x62\xD0\x89\xD7\xF8\x24\xA4\xC4\x00\x33\xD7\x30\x0C\x60\xD7\xB5\x44\x92\xCD\x02\x2C\xAC\xB4\xD6\x58\xD5\x5B\x63\x33\x07\x4D\xDF\xB3\xDA\x59\xDF\xA9\xB1\x21\xD1\x00\x92\xD1\x18\x05\x68\xD0\x6B\x0B\x45\xE7\xC2\x30\xD3\x4C\xD6\x8A\x3F\x66\xD1\x53\x54\x92\xD5\x03\x39\xAC\xCD\xD6\xA1\xD2\x65\x84\x49\xD6\x0F\x07\xB5\xD2\x5A\xC0\xA3\xBF\x61\x24\xD3\x43\x01\xD7\xD6\x7F\x27\x8C\xC4\x42\x7C\xAA\xE3\xD6\xC5\xD5\x43\xD6\x32\x75\x1B\x04\x92\xD9\x04\x28\xAD\xCC\xD5\x0E\xD1\x81\x33\x37\x00\x3C\xD1\xB5\xC9\x05\x72\xAA\x80\x6E\xD2\x79\xA0\x8E\xC7\xD2\xF8\x27\x80\x3D\x47\xED\xCA\x63\x01\x24\xD2\x5A\x03\xDE\xD4\x21\x0D\xB7\xDC\x1A\xFB\x0B\xDB\xD5\x6F\xD7\xC2\xD7\xD8\xC0\xE0\x67\x0E\x0E\x49\xC9\xAE\xAE\xD0\xAD\x65\x74\x00\x49\xD6\x19\x0F\xB8\xD4\x41\xEA\x56\x6B\x01\x24\xD3\x6B\x01\xE5\xD2\x07\xDF\x7E\x2D\x07\x24\xA4\xE0\x01\x83\xD6\x3B\x0E\xB7\xD5\x93\x57\xAF\xDB\x5C\xC5\xA1\xEF\x2F\xF1\x01\x7E\xD6\xE9\xD2\x09\xD7\x84", + "\xBF\x50\xEB\xAE\xD0\xD0\x5A\xB0\x92\xD3\x00\x00\x78\x4B\x4C\x0A\x5C\xF4\xAB\xBB\x3F\x24\xD2\x06\x00\xED\xD4\xA8\x06\xBB\xDA\x57\xC2\x7F\x16\xD6\xBB\xD7\x66\x11\xEF\xD0\x60\xD4\x13\x64\x49\xDE\x00\x41\xD7\x09\x05\xE1\xD4\xD9\xA5\x1F\x03\xB2\xC1\x5E\xC7\x08\x43\xD7\x1C\xD4\x36\x22\xCA\xD1\x78\xDC\xB7\xD4\x58\xEC\x86\x01\x00\xF6\x78\xC4\x25\x0E\x00\x79\xD4\xB8\xCD\x25\xD5\xCA\x59\xD7\x56\x42\xE7\xD5\xF7\xD5\xD1\xC3\x90\x25\x00\x20\xAF\xC8\x4C\xE2\xD6\xD1\xD4\x21\xD0\x60\x77\xBE\xD5\x1E\x5C\xAF\xEA\xD7\x89\xD1\x56\x65\x02\x05\x7D\xD9\x9D\x49\x5F\xC6\x04\x43\xD7\xB0\xCB\x8F\x00\xFD\xD2\x20\x08\x06\x16\x5F\xE3\x2F\x3B\xD6\x63\xB1\xFD\xD4\xB6\x5F\x7D\xD7\xBF\xCA\x35\xFB\x7B\x0F\x00\x02\xD8\x8B\x64\x01\xDF\x7F\xD7\xB4\xDE\x97\x11\x00\x09\xD8\x85\x01\x05\xDA\xDD\xD6\x4C\xDD\x97\x33\x00\x09\xB0\x8F\x01\x12\xD8\x1F\x1F\xD4\xD6\x9E\x45\x01\x09\x60\xD9\x02\x7E\xD7\x13\xD9\x39\xD7\x40\x37\x02\x09\xC0\xC2\x05\x20\xB0\x9A\xD8\x5F\xD7\x56\x65\x06\x01\x81\xDB\x0A\x07\x61\xC7\x1B\x65\xD6\x23\x4D\x04\xD8\x2D\x06\x85\xD3\xBC\xD3", + "\x36\xF8\x7F\x89\xD8\xBD\x00\x1A\xDA\xA3\xD1\x15\x3F\x01\x09\x60\xC6\x03\x19\xD8\xE9\x17\x8F\x1E\x0D\x04\xBC\xB1\x02\x16\xE7\x70\x25\xEA\x24\x13\x40\xF2\xBB\x09\x06\x9E\x7A\x6E\xD9\x01\x1F\x3C\x43\xD7\xE9\x62\x7B\x78\x73\x6D\x03\x2B\xF9\x04\xEF\xB0\x00\x52\xD8\x6E\x68\x5F\xC4\x79\xB9\x06\x06\xCF\x77\x04\xFB\x00\x77\xD6\xCA\x70\x1A\x01\x02\xD8\x1A\x0E\xC2\xDF\x62\xFE\xAD\xB7\x61\x36\x01\x04\xD9\x36\x05\x8C\xD0\x9D\xCD\x95\x78\x00\x09\xD8\xE2\x00\x20\xDA\x19\xDE\xEB\xC3\x90\x3A\x01\x09\xB0\xEC\x01\x72\xD8\xC8\xD4\x62\xD1\x81\xD6\x0F\x19\x63\xD6\xAE\xC8\x2A\x3E\x01\x04\xD9\xC7\xC4\xAC\x03\xC7\xDA\x13\xCE\x94\x89\xD8\x0A\x01\x1D\x47\x81\x05\x90\xD3\x64\xD6\x27\x42\x01\x09\xD8\x13\x01\x1D\x45\x82\x04\x91\xDB\x64\xD6\x27\x44\x01\x09\xD8\x1D\x00\x49\xDB\xE4\x39\xCA\xCB\xEF\x26\x02\x09\xB0\xA7\x00\x9A\xD9\xB1\x47\x5C\xCB\xDF\x38\x04\x09\x60\xF1\x00\x21\xD9\x96\x40\x4E\xC7\xC2\x79\x81\xDB\x03\x08\x65\xC0\x88\x22\xC5\x97\x53\x04\xD9\x11\x06\x95\xD9\xD0\x58\x3C\xD1\x92\x09\xD8\x4F\x01\x1D\x47\x82\x04\x92\xDD\x9B\xAC\x0D", + "\x50\x01\x09\xD8\x5A\x00\x5A\xDA\x62\xAA\xCF\xC0\xAD\x32\x02\x09\xB0\xE4\x00\x8A\xD9\x4D\xDB\x64\xC9\xCF\x54\x05\x09\x60\xED\x01\x3A\xD9\xCA\xD8\xE4\xC1\x9E\x5E\x0A\x09\xC0\xD8\x03\x02\xB3\x99\x26\x33\xD5\x70\x40\x16\x01\x81\xD2\x08\x17\x66\xFC\xB2\xA8\xD6\x51\x4D\x04\xD8\x23\x00\x9A\xD2\xCA\xD9\x34\xFD\x65\x5C\x00\x09\xD9\x4B\x02\x37\xDF\xF9\xC1\x0E\x5E\x02\x09\xB0\xA1\x01\xEB\xD9\x28\xD4\x73\x40\x0C\x0C\xC2\xC4\x67\xE9\xB2\x87\xD3\x00\x6E\x31\x01\x02\xDE\x16\x06\xCF\xCF\x65\xCD\xB0\xE0\x55\x09\xD9\x60\x01\x3F\xDD\x96\xD4\xC1\xC1\x58\x49\xB0\xCC\x01\x03\xDB\x61\xD8\x9B\xD4\xCC\x28\x06\x09\x60\xD7\x03\x71\xD9\x22\xD9\x50\x36\x1A\x01\x81\xD1\x0E\x10\x68\xCD\x8C\x9D\x4D\x6C\x01\x04\xDB\x3A\x06\xA2\xD2\x31\xCC\x50\x49\xB0\xF5\x01\x1C\xDA\x8C\xC7\xBE\x38\x0E\x09\xC0\xDF\x07\x21\xB4\x83\xD9\x19\x55\x04\xD9\x02\x07\x7D\x4B\x20\x0E\xC0\x1C\x7E\xB7\x61\x74\x01\x04\xD8\x05\x07\x7D\x47\x20\x0E\x69\xFB\x68\x80\x6E\x76\x00\x4C\xD8\x4D\xDC\x21\x06\xD3\xC8\x79\xA8\x6A\x09\xD8\x26\x01\xF7\x45\x82\x05\xA7\xDA\x44\xB9\x73\x7A", + "\x01\x09\xD8\x30\x00\xA1\xD8\x4F\xDA\x8F\xD0\x70\x7C\x03\x09\xB0\xBA\x00\x4A\xDB\x84\x00\x51\xDF\xBE\x9F\x6E\x3E\x03\x09\xB0\xC4\x00\x51\xDA\x91\x40\xB6\xD3\x7B\x99\xC0\xCE\x02\x3B\xB4\xD2\xDA\xA3\xD7\x4E\x4E\x20\x01\x81\xD7\x05\x19\x6A\xC3\x04\x53\xDA\xB3\x70\xEA\x41\x02\xD9\x0C\x06\xD6\xC2\x08\x28\xB5\x80\xBE\x64\x2C\x43\x01\x02\xDB\x0D\x0D\xD6\xCF\x0A\x63\xB2\xE1\x41\x88\x01\x04\xD9\x1D\x05\xAE\xD6\x3C\x4A\x65\xC9\x39\x89\xD8\x7F\x00\xBE\xD8\x5A\xDE\xFC\xBC\x08\x09\x60\xC9\x02\x02\xDB\xB6\xD9\x80\x65\x02\xDB\x12\x0C\xD2\xCB\x6A\xE3\xA1\x9D\x4D\x90\x01\x04\xDA\x27\x00\xB1\xDE\xD3\xB9\x60\x89\xB0\xA8\x01\x5F\xDA\xAD\xDB\x32\xDD\x55\x64\x09\x09\x60\xF1\x02\x0D\xDB\x60\xDB\xDA\xCC\xC0\x6E\x12\x09\xC0\xDC\x05\x14\xB6\xF1\xAA\x5B\x6A\x1F\xDB\x69\xDF\xAE\xA6\x02\x83\x63\xE0\xB6\x9A\xDB\xF1\xD6\x19\xB9\x02\xDB\x1B\x0B\xDA\xC4\xAC\xB8\x79\x09\xD8\xE5\x01\xDA\xDA\x62\xAB\xD6\x50\x0A\x09\x60\xEF\x03\x2F\xDB\x67\xDA\x03\xD9\x38\x42\x14\x09\xC0\xDA\x07\x00\xB7\xEE\xDA\x8E\xD3\x7D\x3C\x29\x01\x81\xD5\x00\x04\x9F\x6D\xB4", + "\xCE\xD6\xB4\x77\x04\xD8\x04\x06\xB9\xDE\xD8\xC7\xEC\x83\x64\x28\x01\x09\xD9\x0D\x00\xF9\x63\xA8\xD6\x7F\xD1\xE2\x09\xB0\xA5\x00\xDB\xDB\xEA\xDB\x45\xDE\xDE\x29\xC0\xCF\x01\x21\xB7\xA1\xDB\x80\xD5\x50\x36\x2B\x01\x81\xD9\x03\x07\x6F\xF0\xB6\x83\x6F\x89\x6B\x04\xDB\x10\x06\xBD\xD1\xDC\xD3\x64\xBB\x01\x89\xD8\x4D\x00\xEA\xD9\x42\x07\x4D\x24\x0F\x44\xEF\xB4\x02\x46\xD8\xB1\x20\xFE\xDB\x46\x44\xBC\xBA\x0B\x0C\x62\xE0\x84\x1F\x1E\x68\xDA\x50\x38\x16\xDE\x5F\x25\x01\x3D\x6F\xEC\x8A\x0B\xDC\x64\x2D\x06\xDF\x80\xDD\xBF\xCD\xC5\xD1\x85\x01\x01\x60\xD8\x97\x85\x04\xD8\x16\x04\xBE\xD4\x10\x59\x55\xFB\x72\x09\xD8\x62\x00\x0E\xDC\x9E\x75\x8D\xD9\x60\x89\x60\xEC\x01\x7A\xDB\x10\x28\x63\xD5\xA7\x4D\x19\x09\xC0\xD7\x03\x28\xB8\xEF\x63\x4C\xDA\x65\x73\x33\x04\x9B\xDF\xE2\xDD\x70\xFF\xB1\xB8\x2B\xD1\x01\x04\xD9\x23\x05\xC6\xD3\xE2\xC9\x4F\xE5\x18\x89\xD8\x98\x00\x11\xDC\x00\x07\xC2\xD2\x92\xCF\x68\xA5\xB0\xBC\xDC\x43\xDD\xB3\xC8\xD1\x39\x81\xDD\x0A\x08\x72\xC4\xB9\xE9\xD5\xF8\x45\x04\xD8\x2E\x06\xC9\xD7\xD7\xCC\x0D\x5B\x03\x09", + "\xD8\xC3\x00\x2A\xDC\x5E\xCC\x35\x4D\x0D\x09\x60\xCE\x03\x5A\xDC\x7D\xCA\x68\x76\x1A\xD8\xCC\xD2\x58\xCC\x0D\x61\x03\x09\xD8\xE4\x00\xF2\x65\x83\x07\xC9\xD6\xB0\xDD\x34\x63\x03\x09\xD8\xF0\x00\x32\xDD\xC3\xD5\x64\x49\xC0\xDB\x07\x02\xB9\xEC\xDC\xFF\xBE\x68\x37\x39\x04\xB9\xD7\x48\x4B\x73\xDE\xAF\xF6\x49\xE9\x01\x04\xD9\x04\x07\x90\x4B\x20\x18\x73\xE5\xA5\xDD\x6B\x09\xD8\x0E\x00\xA1\xDB\x6E\x4B\xA3\xC4\x88\x5F\xB2\xFD\xDC\x8C\xDC\x73\xDB\x76\xA9\x81\xD3\x03\x0B\x74\xE6\x82\x6C\xD9\x12\x63\x04\xDA\x0F\x06\xD2\xD9\xE2\xD2\x67\xE8\x0C\x89\xD8\x49\x00\x48\xDF\xA5\xD8\x9F\xDA\x8C\x75\x07\x09\xB0\xD5\x00\xA2\xDD\x4E\xDC\x29\xD4\x66\x8B\xD6\xC9\x75\xF0\xB8\x85\xDA\xB6\x23\x7C\x02\x33\xDE\xD5\xD6\xE3\xD6\x6E\xE1\x6A\x69\x7A\xE3\x2D\x3C\x00\xA7\xDF\xD5\xD1\xD1\xCC\x0E\x7D\x03\x09\xD8\x84\x01\x5D\xDD\xAD\xDB\xBC\xD9\x35\x97\x60\xC2\xBB\xBD\xDC\xE9\xDA\xE6\x41\x00\x04\xF3\x28\x38\x3A\x04\x07\xBB\xC9\xDC\x6A\xD6\xFB\x28\xB3\xDD\xFE\x8F\xEC\xC6\x74\xE8\xB4\xF6\x49\x05\x01\x69\xDF\xB3\x0C\xD6\xD1\x10\x05\xF3\x06\x04\x15\x30", + "\x9D\x46\x6D\xDC\x99\x2E\xDB\xD3\x10\x08\x02\x24\x77\xEE\x7A\x7E\x48\xDB\x20\x11\x00\xC3\xD6\x7F\x22\x77\xC9\x1D\x4F\xDD\xEB\xDD\x33\xDB\xE3\x86\xDD\xD3\x8C\x90\x77\xE4\xB8\xE8\xA5\xF4\xDD\x80\x02\x34\x04\xDB\xD0\x00\x11\x77\xF4\xB1\xA1\x35\x11\x01\x7C\xDC\x3B\x4C\xDF\xDE\xEF\xD4\xC4\x61\x83\x13\x00\x02\xDE\x75\x00\xC1\xDB\x3C\xDC\xC1\xC2\x78\xF6\x03\x0B\xDE\x3E\xDD\x77\x2E\x5D\x7C\x9D\x59\x4A\x4B\x10\x05\xBC\x8D\xD9\xE9\xAA\x81\xDD\x03\x01\x95\x4D\x20\x17\x78\xD5\xB2\xBF\x87\x02\xDF\x0C\x00\xC7\xDC\x10\x2C\xC9\xC1\x07\x5D\x00\x02\xDE\x25\x01\x91\xDD\x05\x2D\xCA\xD6\x4F\x5F\x00\x02\xBC\xB1\x00\x2A\xDE\x83\x02\xC7\xDE\x0A\xD6\xBF\x22\x78\xFD\x00\x31\xDE\x03\x03\x99\xDE\xF9\xBB\x04\x02\xF0\xC9\x02\x38\xBC\x82\x02\x33\xDF\x07\xD5\x5F\x7B\xDC\x25\x05\x09\x25\x5E\x07\x33\xDE\x64\xA7\x13\x02\xC0\xDA\x0C\x0F\xF3\xCD\x0A\x44\xB3\xFB\x3D\x29\x00\x81\xDE\x1B\x05\xE2\xD4\xF2\xDB\x6C\xF7\xC2\x2B\x00\x02\xDF\x3C\x02\xD1\xDD\xEA\xD2\xCD\xCD\x95\x6D\x00\x02\xDE\x86\x01\xA6\xDD\xBF\xD9\x9B\xDC\x1A\x4F\x01\x02\xBC\x92\x01\x62", + "\xDF\x99\xDC\x38\xD8\xD2\x22\xF0\xDE\x04\x1B\xBD\xAB\xDE\x92\xDC\xDB\x20\x61\x7B\xDC\x2B\x0A\x09\x7B\xD8\xBA\xD2\xA6\x02\xDF\x5B\x02\xDD\xDE\xD3\xDD\x2A\x77\x01\x02\xBC\xC3\x01\x6F\xDE\x99\xDE\x70\xDC\x35\x49\x03\x02\x78\xD0\x03\x01\xDF\x39\xDF\xE4\xD9\x38\x43\x07\x02\xF0\xDD\x06\x08\xBE\xC0\xDE\xD0\xDA\x7B\x49\x0F\x01\xE1\xDF\xF8\xCE\x7A\xCB\xB4\xD7\xAC\x02\xDF\x7B\x03\xDE\xDD\xD7\xD9\xE7\x41\x02\x02\xBC\x83\x00\xD6\x47\x8E\xDF\xC7\x1E\xFF\xCA\x20\x23\x02\x02\xBC\x8F\x00\xA1\xDE\xAE\xDD\xF2\xB7\xDD\x25\x04\x02\x78\xDB\x00\x29\xDF\x70\xDF\x13\xB5\xD7\x52\xE0\xD7\x02\x10\x7D\xC2\xBE\xF6\xDB\xA1\x35\x24\x02\xC0\xDB\x06\x06\x3D\x5E\x0E\x05\x01\x6C\xDD\x64\x2D\x25\x02\xC0\xD8\x08\x06\x3D\x4B\x10\x3F\xBE\xF2\xDD\xCA\x71\x26\x02\xC0\xDB\x09\x05\xFC\xCC\x08\x07\xBF\x86\xD7\x9D\x4D\x27\x02\xC0\xDE\x0A\x06\xFB\xC3\x08\x0F\xBF\x8B\xD7\x93\xAD\xA5\xDD\xF5\xDA\xA5\x21\xE3\xD1\x85\x13\x01\x52\xDE\xDB\xDF\x80\x03\xF5\xD8\xBE\x9E\xB5\x62\x78\xFA\x01\x61\xDF\xE2\x41\xAD\xD8\x81\x58\xEC\xDD\xFC\xDB\x95\x61\xB5\xCA\xA1\x02\xDF", + "\x48\x00\xFA\xDB\xFC\xDF\xF1\xD2\xEC\x02\xBC\x9D\x01\xF3\xDF\x92\xDD\x86\x5A\xE0\xD9\x0A\x19\x7F\xD8\x99\x98\x4E\x02\xDF\x5A\x02\xFF\xDD\xE1\xB8\xE2\x42\x78\xC1\x03\x03\xE0\x91\xCE\xDE\x56\xC0\xDD\x19\x08\x00\xFB\x15\xAF\xB8\x02\xDE\xD9\x01\xDE\xDE\xF3\xDB\x93\xC0\xAD\x27\x03\x02\xBC\xE6\x01\x0D\xE1\xD3\xCC\x7F\xBA\xE0\xD2\x0F\x0D\x7F\xF0\xBF\x56\xD7\xF6\x49\x35\x02\xC0\xDD\x1F\x02\x01\xEE\x7F\xE2\xB6\xCA\x71\x6D\x00\x81\xDE\x02\x00\xBD\x4D\x20\x14\x7F\xE1\xAC\x8C\x6E\x02\xDE\x0B\x00\x0B\xE3\x02\xEB\xBE\xCC\x0E\x71\x01\x02\xDE\x22\x00\xF4\x4A\xEF\xDE\x65\xDC\x1A\x53\x03\x02\xBC\xAF\x00\x33\xE0\x13\xE2\x32\x87\xDD\x25\x07\x02\x78\xFB\x00\x41\xE0\x1F\xE0\xBE\xDF\x2D\x67\x0E\x02\xF0\xC7\x02\x3A\xC0\xB4\xE0\x41\xD7\x13\xBE\xC0\xDC\x0A\x0F\x04\xE2\x82\xF9\x75\xAC\xA2\x02\xDF\x30\x01\x15\xE1\x09\xE7\x6B\xCB\xEA\x52\xBD\xDB\xE0\xD6\xDF\x0D\xD9\xA7\x4F\x0F\x02\xF0\xDB\x03\x08\xC1\xE1\xE0\x59\xD6\x8F\xAE\xC0\xDF\x10\x07\x06\xFC\x7E\xE9\xB0\xA9\x83\x02\xDF\x49\x01\x1B\xE2\xFC\xD0\xC3\xD6\x27\x45\x02\x02\xDE\x9F\x01\x39", + "\xE1\xFA\xD9\xDA\xD2\x6D\x62\x78\xEB\x02\x7A\xE0\x2E\xE1\x47\xD6\x28\x71\xEF\xD0\x06\xF2\x0D\x5F\x3C\x60\xDD\xB7\x4E\xCE\x2D\xBF\x75\x4E\x26\x05\xE9\x98\x5C\x5E\x4C\x6B\xE6\xDD\xD8\xDD\x38\x41\x12\x0F\x08\xF1\xE4\x40\xBF\x9B\x78\x02\xDE\x62\x00\x7A\x4B\x41\x0C\x81\x28\x7E\xF1\x42\x14\x01\x02\xDF\x67\x03\x26\xE0\x10\x47\xEF\xCA\xC6\x56\x02\x02\xDE\xDA\x00\x3D\xE1\x27\xE7\xDF\xDC\x1C\x58\x04\x17\xC0\xAA\xE1\xDD\xDE\x7F\x26\x26\x04\x03\xE0\x0B\xF7\x71\xCF\x3F\x1C\x01\x02\xDE\x7F\x01\x2D\xE4\x73\xDF\x15\x8A\x81\xE7\x98\x4D\x09\xAB\xE1\x71\x6C\x10\x82\xE0\xD5\x01\x1F\x85\xE6\x15\x41\xE1\x5E\x21\x1A\x46\xC0\xD9\x04\x06\x0C\xF5\x2F\x08\xC3\x81\x02\x70\xDB\xA2\x86\xC0\xDD\x05\x0D\x0C\xED\x10\x0F\xC3\x80\x79\x43\x44\x81\xDD\x0E\x05\x1A\xE4\x0A\xFB\x72\xD9\x52\x82\xDE\x45\x00\x6E\xE2\x7B\x40\x96\xDB\xEF\x2A\x05\x02\xBC\xD1\x00\xE2\xE0\xBE\x3D\x62\xD9\x1C\x4C\x0A\x02\x78\xDD\x01\x4D\xE1\xDE\x03\x6B\xE0\xD9\xA6\x15\x02\xF0\xCA\x03\x29\xC3\x84\x3D\x4F\xDE\x40\x9A\xC0\xDE\x0E\x0D\x0C\xFC\x84\xE0\xC0\x9D\x4D\xB2\x00\x81\xDD", + "\x20\x00\x1E\xED\x0D\xFD\x7A\xF6\x11\x82\xDE\x8E\x01\x7B\xE0\xCE\xBC\xEC\xD2\x4C\xA2\x78\xDA\x02\x0A\xE2\xFF\xAF\x46\xDD\x04\x72\xE0\xD6\x0A\x04\x88\xE3\xC3\xF1\xDE\x81\x90\x81\xDF\x2C\x00\x22\xE5\xE5\x97\x7B\xDD\x9A\x3C\x01\x02\xDF\x5F\x00\x47\xE7\x1A\xE6\x5B\xCF\x7E\x3E\x02\x02\xDE\xCB\x00\x8B\xE2\x3A\xE4\xD4\xD3\x9B\x82\x78\xD8\x03\x2A\xE2\xF8\xE1\x7F\xD8\x97\x92\xE0\xD5\x0E\x10\x89\xCB\xC4\xB0\xDD\xAC\x96\x0E\xE2\x4D\xE1\x22\xE7\xF9\xCF\xBF\x06\x03\x02\xDE\xFF\x01\x91\xE1\x77\xDC\xD9\x52\xF0\xCB\x00\x0C\x99\x56\xE1\xA3\xDF\x54\x32\x32\x02\xE0\xD7\x01\x07\x8A\xC5\xC4\xAB\xDF\x03\x32\x66\x02\xC0\xDB\x04\x0E\x14\xF7\x88\xF2\xBE\xF7\x92\x3F\xE1\xAA\xE3\x4A\xE1\x6E\xD5\x74\x86\x82\xCC\x99\x5E\x03\x07\x21\x7A\x44\x79\xBA\x1A\x00\x14\xF1\x12\x5F\x3C\x4E\x00\xE4\xBA\x6A\x01\x59\xE2\x41\x2C\x04\x17\x84\xDE\x35\x82\xDE\x48\x00\xAD\xE2\x06\x2E\xC3\xD3\x90\x38\x06\x13\xC1\xF2\xE2\x1F\x29\x52\xE1\x2C\x22\x1B\x02\xF0\xC0\x03\x1F\xC5\xAA\x47\x2A\xDD\x77\x2C\x37\x02\xE0\xDD\x06\x1F\x8B\xC8\x99\x31\xE1\x64\x2C\x6F\x02\xF9", + "\xDE\x30\xE3\x3B\x4C\x78\xDD\x9A\x55\x7B\xFD\x84\xC6\xE3\x5C\xE1\xE2\xD3\x87\x82\x78\xD4\x02\x78\xE2\x19\x41\xF7\xDF\x40\x34\x1C\x02\xF0\xC0\x05\x12\xC6\xF9\xE2\xE4\xD5\x70\x42\x39\x02\xE0\xDD\x0A\x1F\x8C\xD9\xC6\xFE\x97\x6C\xAA\x81\xDE\x2E\x06\x34\xE0\x00\x0D\x8B\xFF\xBF\xA1\x35\xEA\x00\x81\xDF\x31\x04\x35\xEE\x1A\xE4\x80\xF8\x55\x82\xDE\xD4\x00\xDA\xE0\x39\xE0\xBE\x42\xF0\xC1\x07\x3A\xC6\x96\xBE\x9D\x4C\x78\x02\xC0\xDE\x1D\x0C\x64\x5B\x0D\x35\xC6\xED\xDC\x27\xCC\x81\xDC\x3F\x07\x37\xE0\xF2\xB1\xDF\x42\xBC\x89\x00\x4B\x4F\x06\x07\x71\xE1\xCF\xDB\xEF\x36\x07\x04\xC3\xCB\x4E\xC6\xE3\x3F\xDD\xA7\x48\x1F\x03\x15\xEB\x3A\x5E\x07\x53\xE3\x87\xDC\x7A\x72\xC0\xD8\x06\x0E\x1D\xE0\x8C\xF5\xC0\xF9\x5C\xFC\x00\x9B\xDC\x76\xE6\x3C\xE1\xDB\xD2\xAD\x8B\xBF\xE5\xE3\x87\xE3\x9A\xD7\x40\x37\x59\x36\x80\x84\x33\x70\xC7\x8D\xE3\x4A\xE1\x65\x8B\xF6\x28\x71\x25\x06\x0B\x8F\xF1\xC7\xD1\xE0\xCA\x70\x02\x03\x7E\xE1\xD6\x5E\x1F\xF8\x8F\xEB\xBA\xCC\x43\x06\x01\x01\xE5\x42\x01\x10\x05\x20\xF3\x8C\xDD\xC1\xEF\x2D\x08\x00\x05\xE6\x32\x25", + "\x41\xE0\x1A\xF6\x75\xCC\x87\x0A\x00\x12\xE5\x81\x01\x27\x07\x3E\xEE\x20\xF0\x00\x8B\xD9\x19\xE4\x02\x02\x55\x00\x87\xE5\x42\xE4\xEC\xD6\x26\xA0\xC8\x81\x02\xB7\x01\x11\xE7\x69\xE1\xD9\xDF\xD3\xA7\x91\xFE\x26\x2A\xE4\xAD\xE2\xDA\xD0\xB4\x32\x02\x0E\x22\xF1\x06\x30\xC8\xE0\xE3\xD7\xDC\x00\xA2\x8B\xE6\x1B\x04\x21\xE1\x08\x3F\x49\x62\xE2\xD0\x34\x0B\x03\xF6\x28\x2E\x98\x16\xFF\x8F\xE1\x83\x1C\x00\xDB\x2E\xE6\x6B\x08\x37\xA5\xD0\x70\x7D\x00\x2E\xC8\xEC\x01\xD1\xE2\x86\x03\x92\xE7\xA6\xDA\x8C\x7F\x00\x2E\xC8\xF8\x01\x51\xE5\x84\x03\x94\xE6\xA7\xD4\x89\xAE\x91\xC4\x00\x25\x50\xDE\x03\x2D\xE5\x51\xDF\xC0\xAE\x22\xF1\x00\x20\xC9\xD2\xE4\x88\xE2\x6E\x3A\x8B\xE6\x03\x07\x26\xFA\x92\xCE\xC6\xEF\x2D\xF5\x7B\x71\x2F\x0A\x05\x4D\xE6\x10\x02\x93\xD9\x4C\xEE\x55\x2E\xE4\x1C\x01\x09\x55\x41\x06\x27\xF9\xEA\x70\xB5\x2E\xE4\x44\x00\x3A\xE7\x40\x05\x4F\xE8\xEF\xA5\x88\x2D\x00\x2E\xE4\x51\x00\x41\xE6\x40\x05\x4F\xE1\x0D\xE9\xEC\x2E\xC8\xDE\x00\x8A\xE5\x80\x01\x9F\xE4\x1B\xCD\x97\x31\x01\x2E\xC8\xEB\x00\x91\xE4\x00\x01\x9F\xE1\x35", + "\xC9\x60\x2E\x91\xF8\x01\x19\xE5\x7D\xE4\xF3\xBC\x7F\x7E\xFA\x60\x2A\xEB\x87\xEC\x86\x37\x00\x2E\xE4\x49\x01\x09\x53\x37\x0D\x27\xE4\x9B\xB9\x00\x2E\xE4\xA0\x01\x52\xE5\x65\xDF\x16\x6B\x03\x0E\x91\xED\x02\x7B\xE4\x68\xE4\xAB\xDC\xC0\x6D\x07\x0E\x22\xF9\x05\x2B\xCA\xB9\xE5\x06\xE2\x80\x6F\x0F\x06\x45\xE7\x0C\x12\x95\xE8\xB6\xBC\x3A\x2E\xE4\x6A\x02\xB1\xE4\xB5\xD9\x8F\xAE\x91\xE1\x03\x3F\xE5\x6E\xE4\x8C\xE0\x4F\x2D\x08\x0E\x22\xEF\x07\x0B\xCB\xB6\xDB\xC1\x4C\x17\xE4\x3F\x07\x5A\xEB\xDB\xD0\xD6\x09\x01\x2E\xE4\x09\x01\x2F\x51\x4C\x0D\x4F\xE8\x12\xD9\xE4\x6E\xC8\x97\x00\xE2\xE4\xA9\x09\x9F\xE7\xD0\xB9\xFC\xCE\x91\xE5\x00\x69\xE5\x49\x0B\x3E\xE7\xA3\xB8\xE0\x6F\x04\x0E\x91\xF3\x00\x70\xE5\xAC\xE4\x31\xE3\xBB\x29\x0A\x0E\x22\xE1\x02\x30\xCB\xE1\xE4\x43\xE3\x5B\x7A\x8B\xE6\x09\x0F\x2F\xE0\x96\xE5\xC8\xBC\x9B\x2E\xE5\x2D\x01\xC1\xE1\x5A\xEC\x22\xF4\x9D\xAE\xC8\xE8\x00\x0B\xE7\x3A\xE6\x8C\xE3\xDF\x39\x05\x0E\x91\xF5\x01\x11\xE6\x83\xE5\x1D\xDA\xC2\x4E\x45\xE2\x08\x18\x97\xDF\x69\x0E\xD5\xE4\xBB\x2E\x01\x92\xE1\x16\x22", + "\x05\x1F\x78\x14\x01\x23\xCA\x2E\xE4\x69\x4A\x5B\xE4\x4C\x5E\x22\xF0\x04\x18\xCC\x82\x02\x27\xE6\x4F\xE2\xBF\x22\x0C\x0E\x22\xFD\x04\x2F\xCC\x88\x49\x7A\xE2\x6D\x56\x8B\xE2\x15\x0E\x31\xE9\x08\x31\xCC\xAC\xE1\xCE\x64\x17\xE4\x2E\x05\x67\xE3\xA7\x29\x93\xEF\x5F\x68\x00\x2E\xE4\x63\x00\xD1\xE3\x20\x0F\x33\xF4\x31\xC1\xFE\x49\xE5\x4B\xE6\x98\xE6\xFA\xD8\xA3\xDE\x22\xE2\x07\x37\xCC\x80\x00\x4D\xE6\x8C\xDD\xA1\x35\x5A\xE1\x35\xF8\x99\xE1\xC6\xAC\xD4\x2E\xE5\x7E\x01\xD7\xE0\x6B\xEA\xFF\xD6\x27\x72\x01\x2E\xE4\x0B\x00\x32\x51\x4C\x09\x6B\xE0\xBB\xCF\xBF\x34\x01\x2E\xE4\x19\x00\xB5\xE6\x54\x0C\x6D\xE4\xF3\xCF\xBF\x36\x01\x2E\xE4\x27\x00\xB9\xE5\x52\x0C\x6E\xE6\xFE\xB8\x03\x2E\xC8\xB5\x00\x7A\xE7\xDD\x00\xDD\xE7\x41\xDA\x07\x0E\x91\xC3\x01\x7A\xE6\xBD\x02\xBA\xE4\xD9\xA4\x0F\x0E\x22\xF2\x02\x01\xCE\x96\x42\xF9\xE0\xD6\x42\x1F\x06\x45\xE0\x06\x1A\x9B\xDE\x07\x74\xE6\xBF\xC5\x3C\x5C\x20\x06\x45\xED\x06\x08\x9C\xD0\xCE\xA7\xE0\xB1\x20\x41\x02\x8B\xE4\x0F\x0F\x38\xFE\x99\xCC\xC4\xCF\x73\x2E\xE4\x45\x01\xE9\xE5\x68\xE7\x1E", + "\xED\x95\x46\x02\x2E\xE4\x98\x00\xCF\xE6\xE9\xE2\x5A\xEA\x5A\x28\x04\x2E\xC8\xA7\x01\xAB\xE6\xA6\xE6\x47\xE1\x1B\x3E\x22\xF5\x05\x39\xCE\xD2\xE6\xF9\xE2\x65\x70\x23\x06\x45\xE3\x0C\x12\x9D\xEC\xCE\x80\xE4\xB7\x74\x17\xE6\x34\x06\x78\xEA\x3B\xF2\x89\xEF\x5F\x10\x01\xCE\xE4\xE6\xE4\xF0\xE7\x41\xE3\x90\x32\x04\x2E\xC8\xF0\x01\xD2\xE6\xAF\xE6\x85\xE1\xCF\x54\x09\x09\x99\xFF\xCE\xDA\xE7\x1E\xE4\xAA\x6A\x8B\xE5\x01\x0E\x73\x62\x9C\xC9\xC5\xB2\x38\x2E\xE5\x0D\x01\xF9\xE7\x73\xED\x30\xF7\x85\x5A\x02\x2E\xE4\x29\x01\xF5\xE7\xEC\xE7\x2A\xE9\xE7\x5C\x04\x2E\xC8\xB7\x00\xF2\xE7\xE3\xE4\x8B\xB6\x67\x6E\x22\xE5\x02\x3E\xDC\x4F\x4A\x1F\x1F\xA3\x40\x10\x86\x45\xE4\x05\x1E\xB9\x6E\x3C\x08\x25\xCE\x46\xF2\xBA\x28\x03\xFB\x2A\x96\x83\x94\x21\x94\x64\xBB\xA6\x01\x91\xE6\xF7\x31\x80\xE4\xDE\xA7\x05\x29\xCC\xC7\x50\x2B\xE7\xBE\x31\x2A\x06\x45\xE5\x05\x19\x9F\xC6\x85\x74\xE2\x83\x6A\x17\xE7\x18\x06\x83\xE2\x10\x02\xA0\xDC\xC9\xEB\x7B\x2E\xE5\x38\x03\xFF\xE4\x21\x06\x42\xE3\x93\xF7\xC2\x2F\x01\x2E\xE4\x40\x03\x0A\xE9\x21\x0D\x42\xE2", + "\x14\x85\x09\xAE\xE4\x8F\x01\x19\xE9\x94\x4C\x82\xE0\xAD\x33\x05\x2E\xC8\x9E\x01\x3E\x6E\xE2\x9C\x9B\xBC\xBC\xB5\x0B\x12\xA0\xE4\xA0\x6F\xE4\x7A\x38\x58\xE6\x0E\xEF\x83\xE4\x19\xE1\xD5\x38\x02\x2E\xE4\xAF\x00\x12\xE8\x4C\x42\x33\xE1\xAA\x3A\x05\x2E\xC8\xBD\x01\x4B\xE9\x12\xEA\x92\xDE\x95\x9E\x22\xEC\x06\x19\xD1\xD3\xE8\xA8\xE2\xA3\x92\x8B\xE3\x1B\x0F\x45\xE2\x01\x6C\xBC\x99\xB9\x2E\xE4\x75\x01\x19\xED\x86\xE5\x37\xEC\x53\xAE\xC8\xF9\x01\x6B\xE9\xDD\xE3\x35\x9E\x45\xE8\x00\x07\x44\x7D\x06\x6C\xE8\x0F\xD4\x63\x03\xB9\xE7\x10\x5F\x1B\x0C\xA3\xE4\x4D\xC8\x01\x78\xE6\x3B\xE8\x0B\xE9\x72\xE6\x4F\x4A\x06\x2E\xC8\xB6\x00\x87\x51\xDD\x00\x1B\xE9\x73\xED\x2A\x6C\x06\x00\xCA\xFC\xE8\x83\xE8\xD0\xE6\xBF\x26\x19\x04\x40\xE2\xA4\xF4\xD0\xA7\xE7\x61\x70\x11\xEA\x25\xEB\x87\xED\x3A\xF7\x85\x52\x03\x2E\xE4\x72\x00\x48\xEB\x25\xEC\x76\xE0\xCE\x9C\x98\xDB\xD2\xCC\xE8\x43\xE1\xFB\x66\x8B\xE1\x12\x07\x4A\xFA\xA2\xFE\x2C\x2B\xC8\xB0\xE5\x43\x52\xCB\x1C\x8D\xE1\x8E\x25\xE6\xAE\xC8\xA1\x01\x87\x50\x21\xEB\x7E\xD9\xE2\x5E\x22\xE3\x05", + "\x39\xD2\x91\xE9\x1E\x25\x11\xC6\x8B\xE5\x14\x02\x4B\xE0\xA6\xDE\x2A\x64\xBB\xE0\x00\x17\xE6\x29\x05\x98\xE3\x4A\xF6\x5D\x24\x77\xE2\x01\xB7\xE6\x66\xE8\x27\xEE\x55\x19\x22\xCE\x91\xE8\x02\x52\xE9\xA8\xE9\xB0\x14\x79\xBE\x1C\x0E\x22\xE9\x05\x18\xD3\xAE\xE9\xC0\x5C\xF2\xB8\x3A\x03\x67\xEF\x4B\xED\xA6\xC5\x52\x64\xBB\xEA\x00\x17\xE4\x2B\x05\x9C\xE3\x4D\xE3\x08\x05\x67\x1A\x96\x2E\xE4\x57\x03\x37\xE8\x8C\xE6\xB7\x44\xEF\xAE\x03\x50\xE8\xEC\xE9\x6C\xE9\x04\x1C\x87\xCE\x22\xF1\x05\x33\xD3\xE6\xE8\xC1\xE7\x58\x22\x3C\x06\x45\xE2\x0B\x02\xA5\xED\xD3\xED\x87\xFB\x3C\x7A\x02\x8B\xE2\x18\x06\x50\xFA\xA7\xD2\x1C\xE4\xBB\xF6\x00\xE5\xE7\x21\x56\x1E\x2C\x46\xF0\xCB\x10\x6B\x78\x01\x2E\xE5\x6A\x01\x3E\xE8\x9C\xED\x74\x04\xEF\xBA\x03\x2E\xE4\xD7\x01\x8D\xE8\x3D\xEF\x0A\xE7\x0B\x7C\x07\x2E\xC8\xD9\x01\x0D\xEA\x8E\xEA\x40\x03\x11\x04\xDE\xBE\x07\x2E\xC8\xE9\x01\x22\xEA\x80\xEA\x31\x44\xBC\xB2\xC7\x08\x9C\x2B\x03\x31\xEA\x6C\xE9\x79\xE7\x6F\xAA\xC9\x08\x38\x2D\x07\x29\xD4\xA3\xEA\xE2\xA4\x8B\x70\x4F\xE8\xD5\x1D\x4A\xE0\xAA\xFA", + "\xA5\x64\xBB\xCE\x7D\x15\x8A\x04\x51\x60\xE1\x0E\x47\x00\x03\xD5\xBB\x02\x7B\x53\x3B\xEB\xF9\xE3\xDF\x39\x00\x0F\xAA\xF7\x61\x51\xEA\xC6\xE9\x8E\xD9\xB7\xA6\xAA\xE1\xCF\x38\xAA\xE6\xD3\xD7\xC2\x78\x62\xAE\xE9\xFA\x3E\xAB\xE7\x50\xF4\x46\xCD\x80\x62\xEA\xBB\x6D\xBD\x53\x6F\x07\x05\x38\x86\xBF\x1C\xA8\xD5\x90\x35\x7B\x53\xDD\x00\x5B\xED\x80\xBF\x6E\x33\x00\x2F\xD5\xE6\x00\x71\xEA\x60\x24\xB0\xD1\x1C\x45\x01\x0F\xAB\xF4\x01\x64\xEA\x03\x03\xB9\xEA\x0B\xE8\xE0\x67\x01\x0F\xAB\xC3\x02\x00\xEB\xA9\x20\xA3\xE6\xD1\xC7\xAD\xE2\x09\x08\xAC\xC1\x04\x02\xEB\x46\xEB\xDF\x87\x5B\xE9\x14\x0B\x97\x48\x9C\x10\xD6\xE5\xBB\xE4\xBB\x0E\x02\x92\x0C\xB9\x67\x59\xE2\xF7\x84\x6E\x6F\xEA\xA3\x00\xC7\xE8\x00\x07\xB2\xE9\xEE\xBD\xB9\x20\x00\x6F\xEA\xB2\x01\xBC\xE9\x42\x07\xB2\xE8\xFC\xBA\xEB\xAF\xD5\xC0\x01\xA2\xEB\xCB\xE9\xA1\xE6\x36\x24\x02\x0F\xAB\xCF\x03\x31\xEB\x65\xE7\x4E\x4E\x09\x07\xAD\xEE\x0D\x18\xAD\xEF\xC6\xA9\x76\x6F\xEB\x76\x02\x6F\xEE\x36\xE6\x4F\x4A\x01\x2F\xD5\xFC\x01\xC3\xEB\x04\xE1\x38\x44\x05\x0F\x56\xEB\x00\x11\xA9", + "\x3D\x03\x97\xEB\x07\xD6\x0B\x07\xAD\xEA\x01\x11\x52\x6B\xD5\x94\xE0\x2E\x79\xB7\xEA\x0A\x07\xB9\xEA\x57\xED\x8E\xE7\x9B\xEF\xEA\x39\x01\x28\x56\x5C\xEF\x1F\xEF\x6E\x34\x01\x2F\xD5\xC7\x00\xD6\xEB\xEE\xEB\x1D\xD7\x88\x7F\x56\xF7\x02\x1C\xD7\xAB\xEB\x98\xE9\x65\x7F\x5D\xEF\xBD\xE8\x2C\x72\x88\xD7\xF1\x6F\xEA\x75\x01\xF4\xE8\x7C\xEC\x94\xE8\x5B\x3C\x01\x2F\xD5\x85\x01\xF4\xEB\xC0\xEB\xEE\xE3\x20\x3C\xEE\x64\x13\x41\xD8\x89\xEB\xAF\xE8\x87\xC8\x68\xE9\x4A\x5E\xF2\x17\xAC\xF5\xD2\xFB\x3D\x42\x01\xB7\xE8\x29\x01\x4A\x56\x59\xFF\x78\x15\xBD\x7B\x3D\x44\x01\xB7\xEA\x29\x04\xC2\xEA\x5E\xFF\xB2\x64\x77\xC6\x00\x6F\xEA\x54\x00\x83\xED\xC3\xE6\xAA\x04\xEF\x88\x01\x6F\xEA\xA9\x01\x11\xEF\x7E\xEE\x99\xEB\xF0\x6F\xAB\xEA\x02\x2A\xEC\xF5\xEA\x56\x14\x79\xBB\xDE\x74\xF7\xD0\xB1\xC2\xD8\xE5\x16\x19\xCB\xB7\xE8\x2B\x06\xC6\xE8\x60\xE1\xA7\xE2\xA6\x6F\xEA\xAD\x00\x0E\xEF\x8A\xEF\x9C\xE5\xCC\xCF\xAB\xEF\x02\x42\xEC\x31\xEC\x83\x03\x3B\xE9\x36\x5F\x56\xF1\x05\x3C\xD8\x8F\xEB\x11\xBE\xF2\xBA\x15\x00\xB5\xE8\x64\xF7\xB1\xC9\x30\x64", + "\xBB\x58\x01\xB7\xE8\x2D\x07\xC9\xE3\x5A\xE0\x60\xC7\xA7\x6F\xEA\xB5\x00\xFD\xE9\x92\xEE\xFE\x7C\x1A\x5C\x02\x2F\xD5\xC5\x01\x62\xEC\x2B\xEF\x40\x00\xD3\x35\xF5\x6F\xAB\xD5\x03\x51\x54\xF6\x21\xCB\xEA\x45\xEB\xDF\x30\x06\x0F\xAB\xD8\x03\x55\xEC\x3D\xED\x8E\xE8\x80\xD7\xAD\xEA\x0D\x18\xB3\xD0\xD9\xCE\xE7\xE0\x32\x32\x03\x5B\xEC\x1B\x09\x66\xF9\xB3\xEB\xD4\xF7\xBB\x6F\xEA\x76\x02\x9F\xED\xCB\xE5\x0C\x24\xEF\xA8\x01\x6F\xEA\xEE\x01\x45\xEF\x65\xEA\xA7\xE3\x65\x2F\xAB\xF0\x03\x05\xED\x7F\xED\xED\xE5\xAB\x64\x0D\x0F\x56\xF5\x85\x19\x0E\x17\xEB\x3F\x30\xC0\x43\x66\xEE\x05\x3C\x54\xEC\x0D\x6F\x01\x6F\xEA\x0F\x01\x47\x55\x1E\x0F\xB2\xE4\xFA\xDC\xA9\x31\x01\x6F\xEA\x1E\x00\x55\xED\x34\x0F\xB2\xED\x6C\xCB\x80\x6F\xD5\xAD\x00\xB2\xED\xA9\x0B\x65\xEE\x86\xDF\xFC\x15\x03\x2F\xD5\xBC\x00\xB9\xEC\xE8\xEA\xC6\xE3\xDF\x37\xF0\x63\xC0\xB9\xDA\xBF\x03\x5C\x01\x21\xE8\xB4\x31\x0F\x03\x6A\xFE\x97\x34\x79\x4A\x4E\xE4\xBA\x3D\x02\x92\x0A\x2D\x9E\x05\x1F\x78\x09\xDB\x87\x3C\xCD\xEC\x32\x2D\xA8\xEC\x18\x54\xDE\xBF\x03\x19\xDB\xDA\x54", + "\x3C\xE8\xAA\xCB\x5B\xEB\x0B\x09\x6B\xEE\x79\x06\x61\x38\x5D\x49\xC7\xB7\xE8\x17\x05\xDC\xEC\x10\x0F\xC2\x06\x04\x61\x00\xE4\xBA\x42\x03\xB7\xEF\xFD\x2C\x2C\x32\x0A\x64\x77\x85\x01\xF3\xED\x40\xEF\xC7\x19\x0E\x04\xDE\xAE\xF8\x69\xBB\x8A\x24\x5E\x30\x26\xE6\x32\x70\x11\x0F\x56\xFD\x02\x39\xDA\xDE\x03\x01\xEE\x2A\xE5\x2C\x22\x11\x0F\x56\xEA\x03\x07\xDC\x8C\x02\x09\xEF\x13\xE8\x94\x9F\xAD\xE7\x07\x19\xB5\xFB\x06\x11\xEE\x83\xEA\x65\x72\x23\x07\xBF\xE6\x71\xF0\xB8\xCA\xD6\xFD\x32\x90\x01\xB7\xEB\x24\x05\xE3\xEC\x0B\x28\xA2\xDA\x66\x93\xEB\x24\xEF\x2E\x33\xD4\xE4\x2D\xA6\x64\xEF\xB8\xE5\xDC\xC5\xDC\xE0\x32\x4B\x03\x5B\xEC\x17\x09\x72\xE3\x08\x18\xDC\xF5\xDF\x0A\x33\xB7\xEA\x32\x05\xE6\xE2\x10\x17\xB9\xD0\x8A\xAF\x66\x76\xEC\x9E\xEE\x1D\x3F\x8C\xED\x02\x8F\xAB\xE6\x03\x42\xEE\x2E\x28\xBF\xDA\x59\xC7\xAD\xE4\x0F\x08\xBA\xFE\xDC\xE6\xBF\xA0\x01\xB7\xEA\x00\x07\x52\x50\x4B\x1E\xB9\xCF\xA8\xA2\x01\x6F\xEA\x08\x00\xD5\xE9\x8F\x0E\x73\xE4\x9B\x9B\xFC\x64\x7F\x5B\xEE\xA9\x0A\xCF\xE9\x7A\xD6\x0A\x17\xB5\xE1\xDD\xF6\x0B\x3E", + "\xEE\x46\xEB\x2D\x60\x15\x0F\x56\xFA\x01\x27\xDD\xBD\x03\x3E\xEE\x33\xB8\xC0\x6A\x15\x0F\x56\xE9\x02\x27\xDD\x97\xEE\xF1\xEA\x5F\x9D\x7B\xEF\xEE\xEE\x71\xFD\xA4\xF2\xDF\x6F\xEA\x65\x01\xB7\xED\xDF\xED\x3D\xEA\x8C\x70\x05\x3E\xD5\xFC\xEE\x2F\xEF\x54\xEA\x71\xA7\xAD\xE2\x08\x08\xBC\xEA\xDC\x89\x02\x67\x00\xFF\xD9\xBE\xED\x7B\xAE\x65\xE3\x2E\xAF\xD5\x90\x01\x82\xEF\xC4\xEC\x99\xEA\xB9\x8F\x56\xFF\x04\x19\xDE\x8F\xEF\x07\xE5\x3C\x5D\x2E\x07\xAD\xEE\x0A\x1F\xBC\xF6\xDC\x91\xDF\x60\x61\xB7\xE9\x2F\x06\xF4\xED\x73\xFA\x97\xDA\xEA\x6F\xEA\xCC\x00\xC7\xEF\xE9\xE9\x0D\xEA\x8C\x7F\x05\x3C\xD9\xB2\xEF\xAD\xEF\x37\xE0\xC0\x68\xE5\x70\xF7\x58\xBD\xC3\xDD\xAD\xD3\xA1\x35\x61\x03\x5B\xEE\x1E\x0E\x7B\xE9\xBA\xFC\xC1\xE4\x2C\xC5\x01\xB7\xE8\x01\x05\x71\x68\x77\xF8\x7D\xCC\x87\x47\x01\x6F\xEA\x09\x01\xE3\x65\x37\x01\x79\xE9\x08\x03\x62\x50\x35\xC9\x01\xC9\xED\x41\x26\x0C\x3F\x6F\xEC\x0E\x4A\x03\x6F\xEA\x21\x01\xC6\x66\xCB\x1C\xFB\xE2\xA2\xC9\xC5\x0C\x03\x6F\xEA\x22\x00\xF1\xEE\x30\x27\xE3\x1D\xEB\x97\x4B\xAF\xD5\xA3\x00\xEA\xEF", + "\x84\x00\xF9\xEC\xBD\x60\xAD\x30\x06\x2F\xD5\xA4\x00\xF1\xEE\x83\x03\xFC\xEB\xBE\x61\x3F\x6F\xAB\xE5\x00\x79\xEF\x68\x43\x8F\x1E\xC3\x8D\x55\x64\x0D\x0F\xAB\xE6\x00\x00\xF0\xFC\xD6\x8A\xCD\x2A\x36\x1A\x0F\x56\xE7\x01\x08\xE0\xAF\x97\x6C\xC1\x3F\x73\x5B\xE8\x05\x0F\x80\xF0\x50\xDF\x3C\x26\x8E\xFE\x24\x6D\x03\x5B\xE9\x05\x05\x81\xFB\xBF\xC1\x04\x10\xA8\xEA\x94\xED\xE9\x07\xF7\xE3\x15\x41\xAA\xAD\x1E\x03\x6F\xEA\x2B\x01\x11\xF1\xBD\x99\xCF\x50\x0E\x0F\xAB\xEC\x00\x2A\xF0\x77\xC5\x4E\x4E\x38\x07\xD6\xE0\x83\xFF\x77\xAC\xE2\x6F\xEA\x2E\x01\x1A\xF1\xC1\x9C\x35\x46\x0E\x0F\xAB\xEF\x00\x3A\xF0\x0B\x9E\x5D\x73\x5B\xE8\x06\x05\x81\xE9\x03\x19\xD0\xB1\xB5\x6F\xEB\x18\x01\xE3\x63\x64\x50\x42\xE1\x7C\xAF\xD5\xBE\x00\x4B\xF1\x95\x55\xCE\xE4\xCC\x2E\x0E\x0F\xAB\xCB\x01\x4C\xEF\x52\xF0\x13\xCF\x40\x30\x1E\x0F\x56\xF9\x02\x18\xE1\xD2\x56\x1F\xEE\x21\x7F\x5B\xEF\x0C\x0F\x85\xF2\x59\x66\xDC\xCC\x43\xF4\x00\xFC\xE9\x19\xF2\x67\x5B\x72\xFA\xAC\x86\xD6\xD1\xF0\x60\xF0\x98\xED\x5F\x30\x1F\x07\x79\xEB\xC3\xC2\xAD\x5B\xE8\x44\xCD\xB7", + "\xEA\x27\x06\x0E\xFA\xB4\x59\xAD\xEF\x5B\x7C\x01\x3A\xEC\x3E\xF2\xD6\x54\xE8\xE3\x90\x3E\x07\x2F\xD5\xBA\x01\x82\xF0\x23\xF2\x37\xE7\x20\x7D\xAD\x08\x9C\x08\x03\x09\xF1\x72\xE8\x7B\x4A\x00\x05\x11\xFC\x10\x16\x06\x10\xE2\xC0\xE3\xCE\x9E\x4A\xF1\x93\xA3\xFA\xE9\x85\xF7\x50\xFB\xD0\x1A\xF1\xCE\x1B\x4B\xF2\x77\xED\x24\x70\x8A\xFE\x78\x3F\x8F\x4C\xF0\xBA\xE4\x65\x72\x02\x05\x14\xFF\x19\x1F\x1F\x57\xAE\x5A\xE3\xF9\x38\x56\xF2\xBD\x8F\x7F\x48\xB8\x59\xBB\xCC\x87\x0E\x00\xB2\xF0\x29\x0C\x2D\xF5\x13\xFC\x2C\xFE\x45\x79\xE2\xB9\x00\xAE\xF0\x5E\xF0\x58\xBB\xD2\xC9\x8B\xE8\x02\x3B\xE2\xF1\xF0\x8A\xEE\xE6\x40\x05\x01\x17\xF6\x05\x07\xC6\xE6\xE1\x81\xEA\xFE\x24\x0B\x01\x2E\xF4\x0C\x01\x8C\xE8\xC6\xDB\xDE\x9D\x4D\x18\x01\x5C\xF3\x1C\x05\x1A\xFF\x8C\xE1\xBD\xED\xCA\x1A\x00\xB9\xF0\x41\x00\x37\xF4\x0D\xF8\x13\xE8\xEB\xB9\xE2\x91\x01\xE3\xF1\x3B\xF1\x4F\xE0\x3C\x3E\x01\x19\xC5\xE0\x02\x4E\xF1\xE4\xF0\xCE\xDD\xAB\x60\x04\x09\x8B\xEE\x05\x30\xE3\xEA\xF1\x7A\xD4\xE6\x41\xDA\x7B\xDC\x2C\x0B\x17\xC7\xFD\xE1\xC0\xEF\xCC\x42\x12\x01", + "\x2E\xF2\x19\x0E\x8F\xE3\xC4\xC7\xDF\x87\x3A\xB9\xF0\x6C\x01\x41\xF2\x11\xFC\x15\xE9\xD9\x79\xE2\xE6\x01\xE9\xF1\xFE\x55\xB8\xED\x23\x59\x8B\xF5\x07\x3F\x8F\x2E\x1E\x6B\x01\x89\xF0\x6B\x44\x05\x09\x8B\xF6\x07\x3F\x8F\x08\x27\x19\xF2\x74\xEC\xB4\x36\x05\x09\x8B\xF8\x07\x1F\xE4\x8C\x02\x7B\x3D\x9C\x4A\x15\xDD\x5B\x18\x8C\x87\x64\x68\x86\x9F\x26\x84\xD6\x96\xF1\x2C\x25\x5B\x2F\xFB\x04\x92\x2E\x3C\x2E\x1E\x3E\x01\x6E\x14\x73\x6B\x0F\x34\xC0\x4E\x03\xFA\xE4\xB9\x5C\x1F\x1E\x86\xF1\x38\x40\x08\x0F\x93\xFE\x97\x17\xDF\xFA\xEF\xE4\xBB\x20\x01\x51\xF4\xCC\x2C\x6F\xFA\xBC\xEC\x86\x42\x00\x4B\xF3\x9E\x2E\x1C\x05\x8C\xB4\xDE\xA3\x02\x39\xE2\x85\x22\x53\xF3\xA4\x3D\x1D\xC7\x2A\xFF\x88\x3F\x78\x3B\x01\x64\xBB\x47\x01\xA8\xF3\xFB\x2D\x0E\x07\x84\xF6\x8D\x08\x01\x39\xF1\xFA\x01\x53\xF2\x1C\x65\x09\xFE\x8B\x99\xC5\xC7\x00\x14\x46\x6A\x61\x29\xF1\xCF\x2C\x09\x09\x8B\xF4\x00\x14\x8C\x79\x60\x81\xE3\xC8\xB5\x2E\xF2\x04\x07\x97\xEB\xCB\xCD\xAB\xF9\x5C\x50\x01\x5C\xF0\x0C\x05\x2F\xF8\x08\x67\xC3\xD1\xA7\xB9\xF1\x3E\x00\xC2\xF1\x08", + "\x25\x0D\xF1\xAA\x34\x02\x39\xE2\xCC\x00\x70\xF2\xBF\xF3\x17\xA8\x11\xC9\x8B\xF9\x02\x0A\xE6\x9D\x61\x78\xF0\x7B\x48\x16\x01\x17\xF7\x06\x17\xCC\xC1\x77\x7E\xF0\x03\x32\xC2\x7F\xB5\x6E\x33\xFC\x0A\x64\xC4\xE1\x6A\x5C\x00\xB9\xF1\x41\x00\x69\xF4\x16\x6A\x74\xEA\x6E\xA7\xE3\xAB\xF3\x64\xF2\xD7\xC1\x8F\x61\x17\xFF\x09\x10\xCD\xE6\xCA\xF6\x49\x62\x01\x5C\xF1\x2B\x04\x62\x4A\x0C\x78\xAE\xD6\x23\xB9\xF1\xBC\x00\xDB\xF3\xAC\xE0\xE0\x66\x06\x03\xC8\xD1\xE6\x85\xF3\xA9\xF1\x58\x20\x1A\x01\x17\xF7\x0D\x1C\xCD\xD2\xE6\xEB\xEB\x77\x35\x87\xF2\x70\xF7\x58\xE1\xDD\x39\xC5\xF4\x03\x53\xF3\xBD\xF1\xFF\x35\x2E\xF2\x00\x02\xB0\x52\x87\x7C\xC0\xF9\x9B\xB9\xF1\x08\x01\x77\xF2\x1F\x63\x60\xE1\xD5\x32\x01\x39\xF1\x1F\x01\xF1\xF0\x5E\xF0\x1A\xF7\xFA\x79\xC5\xED\x00\x63\xF3\xBD\xF2\x96\xE2\xEB\x79\x17\xFC\x03\x10\xCF\xCF\xE7\xFA\x8B\xBB\x97\x5C\xF3\x12\x06\x3E\xF8\x9C\xF4\x9E\xD2\xA9\xB9\xF1\x5A\x00\xFE\xF3\x62\xF3\x1D\xFD\x97\x3C\x03\x39\xE2\xE9\x00\xEA\xF3\xFB\xF2\xB0\xCF\xC0\x39\x8B\xF7\x03\x09\xE8\xFD\xF3\x07\xE6\xCD\xE5\x2E\xF5", + "\x10\x0F\xA0\xE3\xD0\xED\xCF\xAD\xA8\xB9\xF1\x49\x01\x85\xF0\x33\xF7\x90\xEB\xB3\x79\xE2\xA1\x01\x1B\xF5\xCF\xF2\xF3\xE9\xCF\x56\x08\x19\xC5\xEF\x02\x02\xF4\x46\x62\x8D\xF1\xFA\x79\x17\xFE\x0B\x03\xCF\xEE\x3C\x6B\x25\x03\x20\xF2\xBA\x22\x02\x26\xF9\x2A\x7F\x78\x16\x62\x4C\x4F\x62\xF2\xF0\x31\x1E\x05\x2C\xF5\xC1\x79\xC5\xFF\x02\x63\xF3\xDE\x03\x1D\xF6\xCC\xE0\xA4\x79\x8B\xEC\x06\x00\xE9\x8C\x02\x42\xF4\xE8\xDC\x06\x81\x17\xF9\x0D\x01\xD1\xE4\xCB\x79\xF2\xA1\x34\x4C\x01\x2E\xF7\x1C\x0E\xA4\xE0\x00\x09\xE9\x86\xDE\x2F\x67\x8A\xF1\x95\xF7\x4A\xF4\xFE\xC3\xC8\x1C\x02\x39\xF1\x03\x01\x88\x56\x54\x0C\x4B\xF7\x27\xFF\xC8\x21\xE7\xE2\xF4\xF6\x0A\x32\xF6\x9F\xE5\x68\x69\x8B\xFE\x00\x28\xE9\xBB\x03\x6A\xF5\xD9\xEA\x82\x22\x14\x09\x8B\xEC\x01\x2F\xE9\xC8\xF4\xA0\xF3\x50\x34\x29\x01\x17\xFA\x03\x17\xD3\xC1\x41\x26\xF3\xCC\x42\x53\x01\x31\xF6\x4F\xF6\x10\x0A\xD3\xDC\xCA\x9E\x3D\xCC\xF0\x42\xF7\x40\x02\x4D\xF6\xFE\xAA\x05\x13\xE3\x8A\xF5\x02\x02\x35\xF7\x83\xD4\x15\x09\x8B\xF2\x03\x28\xE9\xBD\x03\x6A\xF5\x79\xE1\x2E\xF1\x10", + "\x00\xA9\xEF\xD2\xC3\xE7\x85\xEF\xB9\xF1\x47\x00\x9A\xF1\x48\xF4\x5E\xFB\x03\xB9\xE2\x9C\x01\x97\xF4\x3C\xF6\x24\xE8\x8F\xB9\x8B\xEB\x05\x1D\xEA\xD6\xF4\xB6\xF1\x6F\x9D\x2E\xF1\x17\x0F\xAA\xEA\xD3\xEB\xBD\xF6\x29\xB9\xF1\x63\x01\xAA\xF7\x4F\xFC\x5F\xEF\x7E\x3A\x02\x39\xF1\xD6\x01\x5A\xF5\x79\xF6\x91\xB9\x8B\xE4\x07\x02\xEB\xEC\xF3\x3D\x2E\x5F\x01\x2E\xF2\x1E\x0B\xAB\xE5\xD4\xC3\xBE\xF6\x49\xC0\x01\x5C\xF1\x00\x05\x62\x59\x47\x0A\xD3\xEC\xCB\xCC\x94\xB9\xF0\x08\x00\xB5\xF1\x9A\x0A\xA6\xF4\xB4\xF9\x2D\xE8\xF3\xDB\xF5\xA9\x0A\x9A\xF7\xD2\xB9\xA4\xB9\xC5\xEE\x00\x61\xF5\x70\xF5\x52\xEE\x3D\x48\x19\x04\x9F\xE8\xD7\xEA\xEA\xF9\xF1\x1D\xA5\x5C\xF2\x12\x06\x5D\xFC\xAB\xF7\xD0\xCA\xE3\x4C\x01\xB9\xF0\x2C\x00\xBD\xF6\x59\xFD\xA1\xE0\xCF\x0E\x03\x39\xF1\x66\x01\x7D\xF7\xA2\xF3\xD8\xE1\x0E\x50\x06\x39\xE2\xF4\x00\xE1\xF5\xDE\x00\x29\x35\x5E\xF1\x0E\x52\x06\x39\xE8\xFD\x32\x5F\xF2\x08\xF4\x6B\x43\x1A\x0F\xB0\xE5\x88\x11\xEC\x86\x02\x0B\xF7\xA8\x8D\xC5\xF4\x83\xA7\xFC\xA4\xEF\x95\x03\x1B\xF6\x2D\x68\x1E\xF7\x5F\x99\x35\xF1", + "\xAE\xFE\x0E\x3D\x01\x6C\xF2\xAD\x64\xE2\x7F\xB8\x28\x12\x05\xB2\xF4\xF1\x32\xE5\xEF\x2F\xDA\x01\x5C\xF1\x27\x02\x60\xFE\x05\x30\xD2\xCC\x87\x5C\x01\xAD\xF4\x9A\xF4\xFC\x41\x0C\xF6\x1B\x3E\x06\x33\xEA\xBA\xF6\x2E\x40\xC3\xF1\xAB\x60\x1C\x09\xAB\xE0\xDA\xE7\xEC\xCD\xE8\xCC\x42\x71\x01\x2E\xF5\x1A\x0D\xB2\xEA\xB7\x54\xD1\xDE\xAA\xB9\xF0\x71\x02\xD1\xF1\x33\xFA\xB0\x99\xC5\xF0\x03\x53\xF6\x61\xE8\xE6\x40\x3A\x01\x17\xFE\x0F\x18\xDA\xE3\x86\x9D\x4D\xEA\x01\x5C\xF0\x03\x03\x67\x5B\x1B\x07\xDA\xC4\xD7\x9D\x4D\xEC\x01\x5C\xF2\x06\x04\x6C\xFE\xB2\xF2\xCD\xEC\x86\x6E\x01\xB9\xF0\x14\x00\xDB\xF6\x69\xF8\x89\xFB\xC2\xF9\xE2\xB6\x00\x3B\x57\xDE\x02\xD9\xF0\x39\xE4\x9D\x39\xC5\xC5\x01\x73\xF6\xEE\x66\x42\xEB\x38\x71\x17\xF3\x05\x1B\x59\x66\xEC\xA5\xF5\x24\x69\x5C\xF0\x18\x01\x6F\xFD\xB6\xE1\x96\xCA\xE3\x78\x01\xB9\xF1\x37\x00\xE0\xF6\x25\x71\xAB\xEA\xA1\x79\xE2\xFD\x00\x93\xF7\x9A\xF6\xDF\xED\x98\x89\x8B\xEB\x04\x0C\xEE\xF4\xF6\x84\xEE\x18\x69\x2E\xF2\x13\x09\xB9\xFB\xD9\xF2\xC7\xA1\x35\x00\x00\x8A\x14\xE2\x20\x15\x05\xBA", + "\xE1\xDA\xC8\xEB\xEF\x2F\xD7\x7F\x71\x2E\x2D\x07\x73\xF1\xB8\xF2\xCF\xE4\x59\x04\x00\xAA\xF6\xA4\x24\xED\xF4\x72\xF0\x68\xFD\xCB\x06\x00\x39\xF7\x65\x17\xDD\xF6\xE6\xF6\x3F\xFC\x1C\x48\x00\x00\xEF\xEB\x23\xC2\xF6\xD3\xF6\xA6\xEF\x16\x6A\x00\x07\xDE\xF8\x36\x2D\xF7\x7B\xF7\x46\x9F\x4C\x76\x79\xF3\x10\x19\x60\x65\xED\xD3\xEA\xE1\x40\x07\x00\xF5\xF2\x37\x06\xBD\xED\xDC\xD0\xC5\xA1\x35\xDE\x7E\xBA\x2D\xF7\xF0\x74\xF0\xDF\xDB\xF7\x12\x00\x5B\xF7\x61\x2D\xF1\xF5\xED\xF5\x21\xF9\xE7\x54\x00\x28\xEF\xB8\x00\x19\x59\xDE\x02\x2C\x35\xCF\x34\xDE\xB6\x00\x14\x2C\x4C\x6B\xF3\xF6\xFD\xE4\x6B\x47\x02\x08\xBE\xE7\x02\x19\xB0\x2E\x1E\xF9\xF7\xFC\x68\x79\xB9\x03\x07\xBF\xF1\x85\x3D\x4B\x21\x4F\xE4\xBA\x0D\x01\x01\xFE\x5F\x27\xC0\xED\x9E\xC2\xBF\x68\xF7\x48\x01\xFF\xF4\xBF\x27\xE3\x13\x08\x19\xAC\xCB\xF0\x91\x38\x2A\xF5\x4E\x4E\x07\x00\x7D\xF9\x04\x12\xE0\xCB\xC8\xD3\xBA\xE4\xBA\x10\x03\x05\xFD\xE7\x20\x8C\x31\xD1\xCB\xB5\x14\x16\xFD\x75\x0A\xF8\x72\x6C\xBC\xB6\x02\x03\xE1\xEB\xD9\x7F\xBD\x4A\xD8\x17\xF8\x78\x33\x5E\x2B\x69\x64", + "\xEF\xA8\x00\x32\xF8\x7D\x32\x67\x30\xF9\xF4\x35\x49\x02\x18\xE1\xC5\x44\x07\x01\x1F\x1F\x07\xED\x47\x50\x7D\xFF\xC3\xFF\x78\x2C\xD4\xA4\x52\x44\xF8\xDB\x20\x10\xFD\xD1\xE3\x92\xE9\xE2\xCA\x48\x09\x01\x1F\x1F\x44\x3E\x0B\x7C\x62\x17\x09\xDA\xC6\x00\x46\x64\xBB\x33\x00\x2A\xFA\x58\x77\xE3\x10\xC5\xE4\xF6\x7E\xF0\xA2\x73\x19\xF8\x03\x30\xFA\xF2\x09\x0E\xC1\xFD\xCA\x5E\x81\xE4\xBB\x39\x01\x2F\xFA\x82\x25\x11\x03\xFA\xCD\x37\xEA\xF1\xF1\x75\x22\xF6\xD5\x2B\xFC\x7B\x00\xB9\xC1\x5E\x0E\x28\x63\x43\xF4\x6A\xA6\xF4\xF4\x16\x05\x8E\xFE\x46\x4F\xD9\xED\x63\xE8\xF7\x65\x00\xF5\xF4\xEF\x66\xD2\xB9\x94\xEF\xE3\xF7\xEB\x36\xF6\x79\x5C\x21\x00\xFA\xF3\x0E\x02\xC8\xFF\x49\x7C\xEC\x8A\x24\x44\x00\xF4\xF5\x20\x05\x91\xF0\x4A\x22\xDA\xF7\xC2\x46\x00\xE8\xF7\x47\x00\x25\xFA\x95\x2C\x98\xEC\x0E\x48\x01\x68\xF7\x9D\x00\x3E\xF8\x13\xFB\x32\xF1\x0E\x5A\xFF\x65\xBB\x1B\xF9\x77\xF9\xFA\xD1\x38\x44\x09\x08\xBE\xF8\x05\x28\xF2\xF9\xF4\xCC\x42\x27\x00\xFA\xF6\x18\x0F\xCA\xFF\xAD\xC0\xE6\xE8\xF7\xD4\x01\x5A\xFB\xD9\xF5\xD3\x68\xBE\xE2\x07", + "\x3A\xF2\xCA\xEB\x2C\x7E\xF4\xF4\x3C\x07\x97\xFE\x00\xE8\x04\xE8\xEF\xFE\x01\xF1\xF7\x3E\xFB\x63\xDA\xE7\x78\xBE\xED\x00\x18\xB1\x31\x0A\xA9\xF9\xDE\xC1\x38\x42\x0B\x08\xBE\xFB\x00\x0F\xF3\xC8\x0A\xD1\xF8\xEA\xE0\x7C\xD0\x7D\xF8\x02\x17\xE6\xD3\x15\x59\xF9\x1B\xD6\x50\xC0\xFA\xF7\x06\x0E\xCD\xFB\x0D\x20\xF3\xAF\xE0\xAC\x42\x30\x00\xFA\xF5\x08\x05\xCE\xEA\xE6\xD2\x9A\xAC\x43\x62\x00\xF4\xF7\x14\x06\x9B\xFD\x1B\x07\xE7\xCD\x8F\xAA\x94\xE8\xF6\x31\x01\x3B\xFB\x94\xFF\x69\xDC\x38\xE8\xEF\xF0\x00\xFB\xF9\x99\xEB\xEB\xF0\x3C\x37\x00\x83\xB7\x3E\x01\x74\xF9\xEE\xF9\x6B\xF3\x9D\x30\x7D\xFD\x08\x08\xE8\xFC\xF3\xF8\xF3\xF6\x48\x36\x00\xFA\xF4\x13\x0E\xD0\xE2\xE8\xC4\xEF\xF4\xA7\xE8\xF7\x55\x01\x45\xFB\x90\xF4\xA0\xE5\x88\x30\x01\x68\xF7\xBA\x01\x80\xF8\x47\xFA\x1E\xF6\x45\x88\xDF\xC8\x03\x22\xFA\x8E\xF8\xDD\xEE\x32\x74\x0E\x08\xBE\xF6\x06\x28\xF4\x95\xF9\x00\xF3\x05\xA8\xFA\xF4\x1C\x0F\xD2\xFC\xE4\xFD\xEB\xCB\x65\xE8\xF6\x79\x01\x4D\xFF\x9C\xF2\x08\xE8\x82\x28\xEF\x80\x00\x5E\x59\x68\x0B\x23\x01\x8E\xF8\x54\x3C\x03\x28", + "\xEF\x8F\x00\x41\xFA\xFB\x0B\x50\xF8\x8F\xFF\x45\x68\xDF\xDC\x00\x49\xFA\xDE\x03\xA5\xFA\x92\xF3\x20\x30\x08\x08\xDF\xE9\x00\x49\xFA\xBB\x02\xA9\xF8\xF6\xD9\x74\xE3\xCE\xF8\xEA\xF4\x91\x0F\xF9\x8D\x6D\x75\xFA\x57\xFE\x19\x46\xC9\xFC\x71\xB2\xF3\xE3\xFA\xCA\x21\x4E\xF9\x9E\x58\x11\x08\xBE\xE1\x03\x10\xF5\xDF\xFA\x72\xF1\x82\x22\x22\x00\x7D\xFE\x06\x08\xEB\xE5\x52\x54\xF6\x56\xC6\xF4\xF4\x1F\x06\xAE\xFF\x4A\x30\xE5\xD7\x39\xE8\xF7\x8A\x00\xBE\xF9\x40\x02\xAB\xFF\x9F\xDB\xF7\x10\x02\x68\xF7\x98\x00\xC1\xF8\x00\x04\xB0\xF5\xA0\xC2\x10\x68\xEF\xA6\x01\x8A\xFA\xC6\xFA\x82\xD1\x63\x68\xBE\xF4\x05\x11\xF6\xB7\xF3\x65\xA8\xF4\xF6\x30\x01\xA9\xFD\x1B\x12\xEC\xE4\x4D\x98\x01\xE8\xF7\x68\x03\x65\xFF\x53\xF2\xF5\x68\xDF\xDF\x03\x6F\xFA\x64\xFB\xE4\xF1\x46\x30\x7D\xFC\x0E\x1C\xEC\xF0\xF5\x8E\xF7\x2D\x82\xF4\xF7\x3E\x03\xB4\xF4\x9D\xE1\xD5\x20\x02\x68\xF7\x09\x00\x44\x59\x56\xFE\xBE\xE6\x19\xA8\xDF\xD7\x00\x08\x59\x9D\xFB\xEF\xF1\xA8\x98\x7D\xF6\x02\x1A\xED\xEF\xF6\xFD\xF9\xB4\x76\xF4\xF4\x0D\x06\xB8\xF9\xDA\xE6\x1F\xAF\x5B", + "\x28\x01\xE8\xF6\x21\x00\x70\xFF\xB8\xF8\x50\xED\x8D\xA8\xEF\xD1\x00\xD3\xFB\xE6\xF8\x49\xEA\x8E\x98\xBE\xE0\x03\x19\xF7\xE9\xFA\xE5\xF0\xD5\x2A\x2B\x00\x7D\xFF\x06\x1F\xEE\xF7\xF5\x9D\xFA\x6C\xB8\xF4\xF6\x1F\x04\xB9\xF0\xDE\xE4\xE9\xC0\xDC\x32\x01\xE8\xF6\x46\x00\x7B\xFF\xBC\xF0\xAF\xED\x95\x74\x02\x68\xF7\x9A\x01\xF9\xF9\x5F\xF9\xA6\xF6\x1D\xA8\xDF\xE8\x02\x7A\xFB\x83\xFB\x89\xE5\x4D\x90\x7D\xF6\x0B\x00\xF0\xCB\xF6\x84\xF6\x12\x7C\xF4\xF4\x31\x06\xBC\xF5\xE4\x31\xE2\xF8\x97\xA8\xF8\xB1\x20\x86\x26\xEC\x3C\xBC\xB1\x0C\x06\xE4\xC8\x55\x12\xFC\xED\xFA\x5A\x82\x85\xF8\xB7\x26\x8F\x3C\xCF\x64\x77\xC3\x01\x1B\xFD\xF0\x83\xC7\x18\xD2\x3D\x5F\xCE\xE2\xFC\x54\x13\x01\x1F\x1F\x4A\x00\x79\xBE\x18\x06\xE2\xEA\xAD\x2A\xF8\xDF\xEA\xEB\xF4\xF4\xF7\x34\x00\x91\x5E\xF2\x17\x98\x09\x04\x7D\x31\xD3\x5C\x8A\x16\x5A\x94\xC4\xF5\x56\xE9\x79\xB8\xF2\xB4\xFC\x71\x7D\x8F\x1C\x9B\xEA\xDD\x5D\xE2\xE8\xAA\x13\x64\x34\x29\x63\xE2\x1D\xFD\x2C\x23\x13\x0F\xF1\x19\x04\x24\x77\xD6\x01\x4A\xFD\x8C\x31\x93\xFC\xBC\xBA\x0D\x11\xF2\xE4\x59\x1D", + "\x01\x1F\x1E\x8D\x30\xB4\x36\x1B\x01\xE2\xE3\x78\x20\x64\x09\x02\x58\xFD\x86\x45\x97\xFF\x67\x03\xE5\xF2\x21\xD6\xF9\xBD\x2E\x28\x32\xAD\x05\x8A\xC3\xCC\xF1\x6F\x85\xF3\xE5\x8C\x67\xFC\xEF\x2E\x51\x03\xC7\x19\x14\x0B\xF8\xAC\xF3\xCB\x24\x9F\x1E\x5F\xFD\x7D\x3E\x3A\x06\xCE\xF1\x70\x9F\x78\x0C\xF9\xBC\x46\x7C\xFC\xC6\x87\xC7\x1F\xC8\xFB\xEF\x2C\x07\x01\xFA\x94\x87\x1F\x1F\x51\x00\x79\xBD\x1D\x07\xE8\xFC\x8A\x1F\x3C\x72\xFC\xD0\x34\x77\x01\xA3\xFD\x26\x3E\x1A\x91\xFC\x8D\xFA\xC3\xFC\x83\x86\x1E\xC9\xA3\xFE\x14\x0F\xF1\x05\xCA\x16\xBD\x45\xFC\xE8\x2D\x8F\x1F\x29\x04\xBC\xB3\x0F\x1A\xE2\xD4\x12\x9F\x1E\xAB\x00\x88\xE8\xA8\xFF\xF9\x19\xEA\xF1\x38\x02\x91\x8D\xFD\xAC\x01\x8F\x1C\x59\x36\xED\x50\xEB\xFD\xF4\xDE\xD4\xE8\xF7\xD5\x00\x20\xFF\x4A\x0F\xE3\x16\x95\x3D\x11\xCD\xFA\xAD\x01\xB2\xFC\xF2\xB9\x3F\x05\xD1\xFD\xEB\xFB\x24\xAD\xD4\xAD\xFA\xBA\xFC\x41\x0C\xAF\xFC\xA6\xE5\xAF\x04\x28\x81\xFB\x88\x47\xCD\xFD\x58\x21\x57\x30\xC6\xFD\x69\x42\x00\x35\x2B\x08\x27\xD7\x01\x64\xFE\xCA\x22\x31\x84\x24\xD5\x57\x30\x25\xB3\xFD", + "\x90\x8B\x75\xD1\xB4\xFE\xD3\x8F\xF1\x11\xF5\xED\x8E\x63\xFD\x78\xB8\x21\xFC\x79\xBC\x01\x07\xED\xEC\x08\x18\x03\x5A\xFD\x02\x02\xB5\x32\xBD\x0C\xBC\xBE\x00\x0D\xF7\xD2\x68\x9F\x1E\xBD\x00\xF2\xB8\x04\x06\xDE\xF0\x76\x9F\x78\x3C\x02\x64\xBB\x12\x00\x74\xFF\xF2\x8C\xA8\xF8\x5B\x33\x00\x3C\xFB\xF3\x17\x88\x58\xEF\x03\x2D\x00\x65\xFB\x2F\xA7\xF8\xD1\x4C\x89\xFE\xFF\x8E\x3F\xF9\x5F\x37\x02\x0E\xF0\xE1\x08\x33\x03\x06\xFC\x0B\xFE\x2D\xF0\xEE\x85\xE2\xFC\xEF\x00\x6B\x7B\x06\x19\xFE\x10\xD3\x81\x33\x06\x04\xE3\xFF\x00\x1E\xF8\xD1\xFC\xB6\xE1\x03\x1F\x0E\x00\xC7\xFD\x03\x06\xF2\xEA\x38\x1F\x3C\x7F\x32\xD0\x35\x0F\x02\xC0\xF8\xFA\x8A\xD6\xF3\xC7\xDC\xFC\xAB\x00\x60\x5A\x85\xFF\xD3\xF2\xAF\xBC\xF1\xF8\x01\x2D\xFC\x86\x02\x20\xFF\xD3\xD4\x78\x34\x04\x0C\xF1\xE6\x02\x3F\xFC\x83\x02\x41\xFE\xD6\xD7\x41\x3C\xE3\xF4\x05\x07\xFA\xC2\x04\x49\xFE\x6D\xE6\x95\xCC\xC7\xFA\x0C\x0E\xF4\xE8\x91\xED\xE6\xC5\xEB\x1C\xFE\x38\x01\xD5\xF9\x99\x61\x89\xFD\x34\x6C\x00\x1C\xFE\x7E\x01\xAD\xFC\xD4\xFC\x78\xDB\xEF\x2E\x01\x1C\xFC\x8C\x01\x60", + "\x5B\xDE\x03\xD8\xF9\x56\xCC\xF1\xFB\x04\x22\xFD\x82\xF7\x5A\xA0\x8E\xFD\x2A\x01\xE7\xF7\xF2\xF5\x4A\xE5\x93\x9C\xFE\xB6\x01\xB4\xFD\xDD\xF8\x3A\xF3\x90\x36\x01\x1C\xFC\xC5\x01\x6F\xFE\xF2\xD5\xA8\x30\x07\x0C\xF1\xF3\x06\x01\xFE\xEF\xF9\x57\x78\x8E\xFD\x38\x02\xEF\xFE\xF2\xFD\xD5\xE0\x1E\x9C\xFE\xF0\x01\xC3\xFC\x72\xFE\x9E\x4E\x03\x1C\xF8\xFE\x03\x12\xFF\xA4\xCD\xC3\x70\xC7\xFC\x01\x00\xE4\x4A\xFB\xCF\xEB\xB7\x91\x1C\xFF\x0D\x01\xE7\xFB\xEF\xF0\xD1\xFD\x34\x44\x01\x1C\xFE\x2A\x01\xD1\xFD\xE3\xFF\xA2\xFD\x2A\x66\x02\x1C\xFC\xB9\x00\xAA\xFE\xA0\xFE\xEB\xE9\x54\x38\x04\x1C\xF8\xC8\x01\x40\x5C\x1F\xFE\x75\xF4\xC2\xC4\xE3\xF6\x05\x18\xFD\xE4\xFE\xD0\xAE\xAB\xF8\x8E\xFC\x19\x06\xF7\xFB\xFA\xFF\xDE\xF1\xF2\x9C\xFE\x72\x00\xE2\xFE\xEC\xFF\xA6\xF5\x10\x30\x02\x1C\xFC\x80\x01\xCA\xFE\xA4\xFC\x82\xFD\xE4\x7C\xF1\xEE\x04\x31\xFE\xEF\x29\x04\xFF\xE7\x1C\x15\x04\xE3\xFD\x09\x00\x72\x5E\x07\x77\x32\x4C\xFA\xF0\x32\x15\x04\xE3\xFA\x0A\x1E\xFE\xCC\x04\x60\xFF\x53\xFB\xB2\x74\xC7\xFF\x16\x01\xFD\xF6\xA7\x08\xF2\xAD\x65\x5A\x01", + "\xBF\xFD\xFB\xFE\xE2\x00\xD6\xEA\xAD\x1C\x01\x05\xFF\xF3\xFE\x00\x00\xFA\xFE\x69\xED\x69\x5E\x02\x0A\xFE\xF9\xFF\xFB\x7F\xAD\x57\x74\x76\x1C\x7F\xEF\x00\xE6\x7F\x13\x07\x3B\x7F\xAD\x32\x62\x00\x1C\x7F\xFC\x00\x00\x80\x78\x7D\x03\x19\x64\x00\x1C\x7F\x0A\x00\x8A\x2E\x52\x05\x01\x80\xD0\x70\x5E\x21\x1C\x7F\x18\x00\x13\x80\x49\x05\x15\x80\xD8\x70\xF7\x29\x1C\x7F\x26\x00\x1A\x80\xBB\x01\x1C\x80\x87\x7A\x46\x2C\x1C\x7F\x34\x00\x21\x80\xE7\x7F\x5D\x7F\x72\x18\x1C\x7F\x42\x00\x28\x80\x07\x80\x75\x7B\xA1\x1A\x6E\x00\x1C\x7F\x50\x00\x1A\x80\xBD\x01\x1C\x80\x64\x53\x70\x00\x1C\x7F\x5F\x00\x2E\x80\x93\x41\x70\x7F\x03\x19\x72\x00\x1C\x7F\x6D\x00\x1A\x80\xDF\x7F\x88\x7B\xCC\x21\x74\x00\x1C\x7F\x7A\x00\x35\x80\x29\x80\xAB\x7A\x3D\x17\x76\x00\x1C\x7F\x89\x00\x3C\x80\xD8\x7F\x82\x7F\xCC\x21\x78\x00\x1C\x7F\x97\x00\x51\x80\xEE\x7F\x9B\x7B\xE9\x32\x1C\x7F\xA5\x00\x4A\x80\x2F\x80\xA1\x7B\xFE\x12\x7C\x00\x1C\x7F\xB4\x00\x58\x80\xF4\x7F\xA7\x7B\xCC\x21\x7E\x00\x1C\x7F\xC2\x00\x65\x80\xFA\x7F\x95\x77\xC2\x1A\x1C\x7F\xD0\x00\x5E\x80", + "\x3D\x80\xB6\x7B\x24\x7C\x1C\x7F\xDF\x00\x72\x80\x52\x80\xDE\x78\xB7\x30\x84\x00\x1C\x7F\xEE\x00\x78\x80\x59\x80\xAC\x7F\xB7\x30\x86\x00\x1C\x7F\xFD\x00\x7F\x80\x66\x80\xCB\x7B\x00\x37\x88\x00\x9B\x7F\xB9\x2E\x22\x80\xBA\x7F\xD9\x18\x1C\x7F\x1A\x00\x8C\x80\x4B\x80\xF5\x7D\xB7\x30\x8C\x00\x1C\x7F\x28\x00\x92\x80\x5F\x80\xC6\x7F\x57\x4E\x1C\x7F\x36\x00\x99\x80\x73\x80\xF4\x73\xAD\x32\x90\x00\x1C\x7F\x44\x00\x9F\x80\x79\x80\xFB\x73\x02\x22\x1C\x7F\x52\x00\xB9\x2E\xBD\x01\xB9\x00\x1F\x0F\xB5\x00\x9E\x6A\xDE\x7E\x93\x48\x1F\x0F\xAE\x80\xB6\x59\x33\x7F\xEB\x48\x1F\x0F\x1C\x80\xAA\x37\xB7\x80\xF1\x48\x2F\x7F\xE4\x5D\xAA\x40\x4A\x75\xA0\x40\x1F\x0F\x63\x7F\xEF\x16\x9D\x00\xBC\x80\x05\x11\xF9\x7E\xA5\x08\xE4\x5D\x9E\x00\xC7\x80\xB6\x11\xBE\x00\xD9\x7F\x03\x0F\x9F\x00\x1C\x7F\x61\x00\xB9\x2E\xDE\x01\xCF\x80\xE1\x7F\x7D\x19\xA1\x00\x1C\x7F\x6E\x00\xD5\x80\x3E\x08\x12\x7F\x05\x11\xA3\x00\x1C\x7F\x7B\x00\xA6\x80\xA2\x2E\xEF\x7F\xB7\x30\xA5\x00\x4F\x80\xE4\x80\x01\x01\xD7\x80\x21\x7F\xA1\x1A\xA7\x00\x56\x80\xEA\x80\x00\x00", + "\xEC\x80\xFC\x7F\xEF\x16\xB0\x40\xE3\x16\xA5\x00\xF1\x80\xF3\x80\x02\x01\xC1\x00\xE4\x5D\xAB\x00\xCD\x80\x0A\x12\xFA\x80\x65\x7A\x03\x19\xAC\x00\x1C\x7F\xB3\x00\xDD\x80\x40\x08\x08\x80\xAB\x54\x1C\x7F\xC0\x00\xF9\x80\x0E\x80\xCC\x4E\x1C\x7F\xCE\x00\x0D\x81\x59\x7B\x79\x2E\xB2\x00\x1C\x7F\xDC\x00\x12\x81\x5F\x7B\x13\x17\x1C\x7F\xEA\x00\x18\x81\xA7\x59\xE6\x46\x1C\x7F\xF8\x00\x1D\x81\xAE\x59\xD8\x1E\x1C\x7F\x06\x00\xA0\x2F\xBB\x01\x01\x81\x64\x7F\x94\x35\x1C\x7F\x14\x00\xA0\x2F\xBD\x01\x29\x81\x64\x53\xBC\x00\x1C\x7F\x23\x00\x27\x81\xDE\x80\xA4\x7D\xFE\x12\xBE\x00\x1C\x7F\x31\x00\xA0\x2F\xD6\x80\x45\x80\x0F\x47\x1C\x7F\x3E\x00\x2E\x81\x36\x81\xB0\x7D\x52\x4A\x1C\x7F\x4D\x00\x35\x81\x08\x81\x53\x80\xEC\x54\x1C\x7F\x5B\x00\x48\x81\x3C\x08\xBC\x7D\x91\x19\x1C\x7F\x69\x00\x42\x81\x49\x81\x60\x80\x64\x16\xC8\x00\x1C\x7F\x78\x00\x4E\x81\x4C\x08\xC3\x7A\x1D\x52\x1C\x7F\x86\x00\x5B\x81\xE5\x80\x03\x7D\x71\x49\x1C\x7F\x94\x00\x54\x81\x4F\x81\x74\x80\xEF\x17\xCE\x00\x1C\x7F\xA3\x00\x67\x81\x5C\x81\xBD\x7B\x05\x11\xD0\x00", + "\x1C\x7F\xB2\x00\x6E\x81\x62\x81\x81\x80\x00\x37\xD2\x00\x1C\x7F\xC1\x00\x75\x81\xEB\x80\xB3\x7F\xCC\x21\xC2\x40\xE3\x16\xD0\x00\x61\x81\x7D\x81\xB4\x77\x49\x4D\x1C\x7F\xDE\x00\x83\x81\xF2\x80\xD8\x7B\xAC\x21\xD8\x00\x1C\x7F\xEC\x00\x89\x81\x29\x81\xB5\x76\xAA\x15\xDA\x00\x1C\x7F\xFA\x00\x90\x81\x02\x7E\x05\x41\x1C\x7F\x08\x00\xE0\x2F\x28\x81\xD3\x7F\x03\x34\x1C\x7F\x16\x00\xE0\x2F\xBD\x01\xBF\x00\xD0\x80\x8C\x0C\x1C\x7F\x25\x00\xE0\x2F\xDE\x01\xA4\x81\xD8\x80\xA5\x17\x1C\x7F\x32\x00\xA9\x81\x52\x08\xDF\x80\xB6\x11\xE4\x00\x1C\x7F\x3F\x00\x9C\x81\xB1\x81\x1A\x7F\xAE\x44\x46\x81\xB7\x81\x54\x08\xF5\x7F\x48\x15\xE8\x00\x4C\x81\xBC\x81\x56\x08\x65\x7D\xCA\x38\xEA\x00\x52\x81\xC2\x81\x50\x08\x35\x7F\xB7\x30\xEC\x00\x1C\x7F\x77\x00\xB0\x81\xBD\x81\x71\x7D\xB6\x11\xEE\x00\x1C\x7F\x84\x00\xC8\x81\x9B\x35\x0E\x81\xCC\x21\xF0\x00\x1C\x7F\x92\x00\xD6\x81\x01\x01\xAB\x81\x50\x6E\xAC\x21\xF2\x00\x1C\x7F\xA0\x00\xDD\x81\x00\x00\xDF\x81\xEF\x6A\xE1\x20\xF4\x00\x1C\x7F\xAE\x00\xE5\x81\xE7\x81\xB7\x6B\xD5\x71\x1C\x7F\xBC\x00", + "\xED\x81\x2A\x80\x03\x19\xF8\x00\x1C\x7F\xCA\x00\xF3\x81\x30\x80\xCC\x21\xFA\x00\x1C\x7F\xD8\x00\xA2\x81\xB8\x81\x9E\x78\x7F\x78\x1C\x7F\xE7\x00\xF9\x81\xA3\x78\xAC\x21\xFE\x00\x1C\x7F\xF5\x00\xCF\x81\xC3\x81\xAA\x7D\x07\x5B\x63\x0C\x7F\x15\x23\x25\xA3\x81\xB0\x78\x06\x26\x0F\x82\xA4\x01\x23\x25\xBB\x01\xEE\x81\xE1\x71\xAC\x21\x04\x00\x15\x82\x4D\x13\x17\x82\x00\x82\xD9\x79\xD4\x4F\x1D\x82\x37\x06\x11\x82\x20\x82\xC3\x78\xAC\x21\x08\x00\x23\x82\x03\x01\x3C\x00\x1F\x82\xD0\x81\xC9\x78\x79\x2E\x0A\x00\x2A\x82\x7F\x22\x2D\x82\x0C\x82\xCE\x7D\xAE\x28\x32\x82\x75\x26\x25\x82\x2E\x82\x0A\x7D\x03\x19\xD9\x40\xE3\x16\x67\x00\x3A\x82\x35\x82\xDB\x7D\xCA\x38\x10\x00\x38\x82\xA2\x1A\x41\x82\xC9\x81\xE1\x7D\x48\x15\x12\x00\x46\x82\x85\x00\x48\x82\xD7\x81\xE8\x7D\x0A\x12\x14\x00\x46\x82\x94\x00\x34\x82\x49\x82\xEE\x7D\x8B\x64\x46\x82\xA2\x00\x56\x82\x50\x82\x94\x80\x00\x37\x18\x00\x46\x82\xB0\x00\x5C\x82\xDE\x81\x75\x70\x9D\x26\x1A\x00\x46\x82\xBE\x00\x63\x82\xE6\x81\x98\x81\x41\x41\x46\x82\xCC\x00\x6A\x82\x19\x82\x39\x72", + "\xEF\x16\x1E\x00\x46\x82\xDA\x00\x4F\x82\xAB\x2E\xAF\x80\x21\x7C\x63\x0C\x70\x49\xFC\x80\x68\x08\x2C\x7C\x63\x0C\xCC\x35\xAA\x1E\x42\x82\xAC\x21\x27\x00\x80\x82\x4C\x4A\x1F\x0F\x7D\x82\x5C\x34\x86\x82\xFE\x12\xC3\x00\x1F\x0F\x29\x81\x15\x24\x8B\x82\xA1\x35\x1F\x0F\x92\x19\xD0\x1A\x2A\x00\x91\x82\x84\x4B\xA8\x7E\xE4\x5D\x2B\x00\x46\x82\xE9\x00\x23\x25\x2E\x0F\x50\x13\x06\x01\x94\x82\x23\x24\x97\x82\xEF\x17\xA0\x82\x03\x01\xAD\x7E\x65\x7F\x46\x82\xEA\x00\x9E\x82\x98\x4C\x79\x82\x32\x29\x46\x82\x05\x11\xBB\x12\x6D\x09\xE4\x5D\x32\x00\xA4\x82\xE0\x19\xC8\x00\xA5\x81\x07\x14\x46\x82\xEB\x00\x23\x25\xDE\x01\xB8\x82\xAC\x81\xF0\x1E\x46\x82\xF8\x00\xBD\x82\x4A\x0A\xB2\x81\x0A\x12\x37\x00\x46\x82\x05\x00\x89\x30\xBB\x01\xBF\x82\x40\x73\x7E\x36\x46\x82\x13\x00\xCB\x82\xC5\x82\x7F\x79\xAD\x32\x3B\x00\x46\x82\x21\x00\xD2\x82\x53\x0A\x61\x7C\x03\x19\x3D\x00\x46\x82\x2F\x00\x89\x30\x2E\x0F\xCD\x82\xF4\x80\x03\x19\x3F\x00\x46\x82\x30\x00\xD9\x82\x5A\x0A\xCA\x81\x00\x37\x41\x00\x46\x82\x3E\x00\x89\x30\xBE\x82\x09\x81\x00\x37", + "\x43\x00\x46\x82\x4B\x00\xE8\x82\x5F\x0A\xD8\x81\x79\x2E\x45\x00\x46\x82\x59\x00\xF6\x82\x0D\x2C\x7E\x7D\x88\x53\x46\x82\x67\x00\xFD\x82\x01\x01\xE2\x82\x85\x7D\xE1\x20\xF4\x40\xD7\x36\x03\x83\x6A\x3B\x57\x7F\x9D\x26\x4B\x00\x46\x82\x83\x00\x0A\x83\x05\x83\xBE\x6B\x8A\x24\x46\x82\x91\x00\x11\x83\x98\x7D\xEF\x16\x4F\x00\x46\x82\x9F\x00\x89\x30\xBD\x01\x12\x83\xBD\x6C\xF6\x24\x51\x00\x46\x82\xAE\x00\x17\x83\x37\x81\x64\x16\x53\x00\x46\x82\xBC\x00\xEF\x82\xD3\x82\x76\x7F\xAE\x53\x46\x82\xC9\x00\x1D\x83\x2C\x83\x7C\x7F\x01\x30\x46\x82\xD8\x00\x25\x83\xB5\x7D\xCC\x21\x59\x00\x46\x82\xE6\x00\x37\x83\x21\x82\xCC\x21\x5B\x00\x46\x82\xF4\x00\x31\x83\xDA\x82\x8E\x7F\x36\x18\x46\x82\x03\x00\x76\x31\xCC\x82\x5D\x81\xD5\x36\x46\x82\x11\x00\x49\x83\x32\x83\x02\x01\xAF\x1E\xE0\x50\xB0\x82\xB5\x1C\x41\x7C\xE4\x5D\x63\x00\x46\x82\x1F\x00\x76\x31\xE1\x82\x16\x76\xB3\x2E\x01\x41\x30\x18\x5B\x83\x50\x83\x26\x28\xE4\x5D\x67\x00\x54\x83\x0A\x12\x1F\x83\xCD\x00\xE4\x5D\x69\x00\x66\x83\x3C\x15\x1F\x83\xD7\x00\xE4\x5D\x6B\x00\x6C\x83", + "\xAA\x15\x1F\x83\xCE\x00\xE4\x5D\x6D\x00\x72\x83\x48\x15\x1F\x83\xD4\x00\xE4\x5D\x6F\x00\x78\x83\x19\x64\xFB\x76\xE4\x5D\x71\x00\xD7\x82\x61\x83\x44\x83\x7B\x16\xE4\x5D\x08\x41\xE3\x16\x22\x00\x84\x83\xE9\x82\xA1\x0C\xE4\x5D\x75\x00\x7E\x83\xCF\x0F\x1F\x83\xAB\x18\x2A\x37\x46\x82\x23\x00\x8B\x83\xF7\x82\x05\x0C\xE4\x5D\x79\x00\x90\x83\x03\x0F\x1F\x83\x25\x71\x03\x0F\x7B\x00\x46\x82\x24\x00\x76\x31\x1E\x83\x9F\x7F\x90\x41\x46\x82\x33\x00\xA4\x83\x62\x83\x00\x00\x98\x7E\x52\x3D\x46\x82\x42\x00\x76\x31\x8E\x78\x1F\x0F\x73\x76\xE1\x20\x0F\x41\xE3\x16\x44\x00\x97\x83\xFE\x82\x8B\x07\xE4\x5D\x83\x00\x46\x82\x45\x00\xB9\x83\x04\x83\x8A\x6F\xA3\x27\x46\x82\x46\x00\xAA\x83\x85\x83\x03\x01\x47\x7C\x62\x37\x46\x82\x55\x00\xC0\x83\x0B\x83\x0F\x7D\xF6\x24\x89\x00\x46\x82\x56\x00\xCD\x83\x1F\x83\xDE\x7A\x7F\x39\x46\x82\x57\x00\xC6\x83\x8C\x83\x88\x80\xCA\x38\x8D\x00\x46\x82\x66\x00\x4F\x83\xC7\x83\xD2\x7B\xC5\x27\x46\x82\x74\x00\xE1\x83\xDB\x83\x11\x7A\x06\x3A\x46\x82\x82\x00\xE7\x83\x98\x83\xF6\x7A\xB1\x10\x93\x00\x46\x82", + "\x90\x00\xED\x83\xBA\x83\xA1\x80\xB7\x30\x95\x00\x46\x82\x9E\x00\xF4\x83\xC1\x83\x23\x7A\xAD\x32\x97\x00\x46\x82\xAC\x00\xDA\x83\x7B\x0A\x1F\x0F\xC9\x00\xE4\x5D\x99\x00\x9C\x83\xAF\x24\x1F\x0F\xCA\x00\xE4\x5D\x9B\x00\xB6\x82\x71\x49\x04\x84\xBF\x80\x08\x84\x96\x0A\x1F\x0F\x99\x19\x78\x1E\x0E\x84\x05\x11\x75\x83\x02\x77\xB1\x10\x9F\x00\x46\x82\xBB\x00\x76\x31\xDE\x01\x19\x84\x0A\x77\xFE\x12\xA1\x00\x46\x82\xC8\x00\x1F\x84\xAA\x0A\xC6\x82\x3C\x15\xA3\x00\x46\x82\xD5\x00\xFB\x83\xE6\x2F\xE6\x80\x00\x37\xA5\x00\x46\x82\xE3\x00\x2E\x84\x21\x84\x58\x7A\xC7\x6A\x46\x82\xF1\x00\x35\x84\xC4\x81\xB1\x10\xA9\x00\xB0\x82\x3B\x84\x48\x7B\x79\x2E\xAB\x00\x46\x82\x0D\x00\x41\x32\x20\x84\xF1\x82\xCA\x38\xAD\x00\x46\x82\x1A\x00\x41\x32\xBB\x01\x36\x84\xC9\x70\xD0\x1A\xAF\x00\x46\x82\x28\x00\x4D\x84\x28\x84\x13\x81\xAD\x32\xB1\x00\x46\x82\x36\x00\x55\x84\x32\x76\xB6\x7C\xAD\x32\xB3\x00\x46\x82\x44\x00\x5C\x84\xD4\x74\x8B\x78\xE0\x46\x46\x82\x52\x00\x63\x84\xB0\x0A\xF4\x81\x84\x57\x46\x82\x60\x00\x69\x84\xB2\x0A\x18\x83\x03\x19", + "\xB9\x00\x46\x82\x6E\x00\x41\x32\xBD\x01\x4F\x84\xA3\x63\xAC\x21\xBB\x00\x46\x82\x7D\x00\x6F\x84\xA8\x0A\x3E\x80\xA1\x1A\xBD\x00\x46\x82\x8B\x00\x46\x84\x56\x84\x2D\x83\xB1\x10\xBF\x00\x46\x82\x98\x00\x76\x84\x86\x84\x33\x83\xCC\x21\xC1\x00\x46\x82\xA7\x00\x7E\x84\x2F\x84\x4A\x81\xAD\x32\xC3\x00\x46\x82\xB5\x00\x93\x84\x78\x84\xA4\x65\x91\x25\x46\x82\xC3\x00\x8C\x84\x5D\x84\x56\x81\x3B\x68\x46\x82\xD2\x00\x9A\x84\x4B\x83\xB7\x30\xC9\x00\x46\x82\xE0\x00\xA6\x84\x63\x81\x05\x11\xCB\x00\x46\x82\xEE\x00\xA0\x84\x64\x84\xC8\x73\x4B\x68\x46\x82\xFD\x00\xB2\x84\x6A\x84\x70\x81\xB6\x11\xCF\x00\x46\x82\x0C\x00\x99\x32\x77\x84\xA8\x77\xEF\x16\xD1\x00\x46\x82\x1B\x00\xBF\x84\x8D\x84\x41\x75\xA7\x30\x46\x82\x2A\x00\x99\x32\x4E\x84\x8E\x80\x03\x19\xD5\x00\x46\x82\x38\x00\xCC\x84\xC7\x84\xC0\x7F\xAC\x21\xD7\x00\xC4\x83\xD3\x84\xA1\x84\x9B\x80\xAD\x32\xD9\x00\x46\x82\x54\x00\xD9\x84\xB3\x84\xE5\x7B\x44\x28\x46\x82\x62\x00\xE0\x84\xB9\x84\xEC\x7B\xAD\x32\xDD\x00\x46\x82\x70\x00\xC6\x84\xC1\x0A\x10\x84\x0D\x23\x63\x0C\x97\x60", + "\x55\x13\xEE\x84\x08\x34\x17\x84\xB6\x11\x52\x83\x53\x0B\xE4\x5D\xE3\x00\xF6\x84\x0A\x12\x9F\x19\xC7\x2F\x29\x62\xF1\x84\xB1\x10\xD3\x00\x1F\x0F\xFE\x84\x7E\x1F\xFC\x84\x05\x62\xB9\x82\xAF\x12\x46\x82\x7F\x00\x99\x32\xDE\x01\x7B\x83\xC0\x82\x0A\x12\xEA\x00\x46\x82\x8C\x00\x0D\x85\x63\x0B\x29\x84\xAA\x15\xEC\x00\x46\x82\x99\x00\xE6\x84\xA4\x41\x1F\x0F\xD6\x00\xF6\x74\x07\x85\xAA\x15\x0F\x85\xCE\x82\xB7\x30\xB5\x41\x0B\x42\x1C\x85\x01\x01\x23\x85\x37\x84\x9D\x26\xF1\x00\x98\x84\x28\x85\x00\x00\x2A\x85\x5D\x7A\xA1\x1A\xF3\x00\x9E\x84\x2F\x85\x31\x85\x02\x81\xA1\x1A\xF5\x00\x46\x82\xD1\x00\x15\x85\x38\x76\xD1\x81\x0A\x12\xF7\x00\x46\x82\xDE\x00\x36\x85\xF8\x82\xAD\x32\xF9\x00\x46\x82\xEC\x00\x44\x85\x57\x84\xB7\x30\xFB\x00\x46\x82\xFA\x00\x4A\x85\x19\x81\x03\x19\xFD\x00\x46\x82\x08\x00\xE5\x32\x52\x05\x37\x85\x6D\x74\x3F\x1A\x46\x82\x16\x00\x56\x85\x49\x05\x58\x85\xE6\x5F\x01\x00\x67\x0C\x88\x13\x24\x00\x5D\x85\xBB\x01\x58\x85\x0F\x6A\x03\x00\x62\x85\xFF\x0D\x5D\x85\xBD\x01\x58\x85\x64\x53\x05\x00\x6A\x85\xA6\x20", + "\x65\x85\x16\x85\x26\x83\x3D\x17\x07\x00\x71\x85\x75\x72\x5D\x85\x0E\x85\x3E\x81\xF2\x6B\x78\x85\xA3\x10\x6C\x85\x74\x85\x44\x81\x86\x43\x7E\x85\x02\x01\x6B\x00\x73\x85\x3E\x85\x38\x83\x79\x2E\x0D\x00\x84\x85\xE4\x32\x87\x85\x67\x0B\x50\x81\x80\x31\x8C\x85\x7E\x21\x80\x85\x88\x85\xC0\x64\x16\x20\x92\x85\x96\x00\x8E\x85\xDA\x74\x67\x80\xF5\x52\x92\x85\xA4\x00\x9A\x85\x1D\x85\xAD\x84\xF8\x19\x92\x85\xB2\x00\x94\x85\x8F\x85\x69\x81\xE0\x19\x17\x00\x92\x85\xC1\x00\xA6\x85\x9B\x85\x7A\x80\x00\x37\xC7\x41\x81\x81\xAD\x85\xA1\x85\x77\x81\xCA\x38\x1B\x00\x92\x85\xDF\x00\xB3\x85\x29\x85\x7E\x81\x79\x2E\x1D\x00\x92\x85\xEE\x00\xA0\x85\xBB\x85\x85\x81\xFE\x12\x1F\x00\x92\x85\xFC\x00\xC1\x85\x30\x85\x8B\x81\x30\x26\x92\x85\x0A\x00\xEA\x32\x57\x85\x65\x82\xEF\x16\x23\x00\x92\x85\x18\x00\xCE\x85\x5E\x85\x6C\x82\xCB\x31\x92\x85\x26\x00\xD5\x85\x66\x85\x9E\x81\x70\x72\x92\x85\x34\x00\xD5\x85\xBD\x01\x5A\x13\x41\x3C\xE4\x5D\x29\x00\x67\x0C\x3E\x4D\xEF\x84\xFB\x1E\x2A\x00\x67\x0C\x97\x60\x6F\x83\x1A\x84\xFE\x12\x2D\x00\x92\x85", + "\x43\x00\xD5\x85\xDE\x01\xEE\x85\x22\x84\x7D\x1D\x92\x85\x50\x00\xF4\x85\xBE\x0B\x17\x85\x48\x15\x31\x00\x92\x85\x5D\x00\xDB\x85\xFC\x85\xEF\x0B\x58\x7C\xE7\x85\xC8\x1C\x30\x84\x61\x6C\x92\x85\x6B\x00\x02\x86\xB9\x0B\xBE\x81\xB8\x15\x36\x00\x92\x85\x79\x00\x0C\x86\x2C\x76\xD3\x6A\xAC\x21\x38\x00\x92\x85\x87\x00\x13\x86\x61\x12\xEA\x82\xCA\x38\x3A\x00\x92\x85\x95\x00\xFB\x85\x0D\x86\x3F\x85\x11\x21\x92\x85\xA2\x00\x1A\x86\xB1\x0B\x45\x85\xB7\x30\x3E\x00\x92\x85\xB0\x00\x27\x86\xD3\x0B\xFF\x82\xB7\x30\x40\x00\x92\x85\xBE\x00\x2E\x86\xB8\x30\x80\x7A\x89\x7C\x92\x85\xCC\x00\x35\x86\xF6\x85\x1E\x81\xE1\x20\x44\x00\x92\x85\xDA\x00\x3B\x86\x6B\x84\x98\x50\x92\x85\xE8\x00\x42\x86\xFA\x81\x79\x2E\x48\x00\x92\x85\xF6\x00\xE1\x85\x03\x86\x01\x82\xDE\x49\x92\x85\x05\x00\x17\x33\xBB\x01\x3C\x86\x73\x6E\xAB\x7C\x92\x85\x13\x00\x17\x33\xF5\x85\x7C\x85\xB7\x30\x4E\x00\x92\x85\x20\x00\x17\x33\xBD\x01\x55\x86\xE1\x7C\xE1\x20\x50\x00\x92\x85\x2F\x00\x53\x86\x4E\x86\x31\x5F\xA9\x18\xE4\x41\x05\x19\x69\x86\x22\x86\x88\x7F\x9D\x26", + "\x54\x00\x92\x85\x4B\x00\x61\x86\x6A\x86\x27\x82\xF6\x24\x56\x00\x92\x85\x5A\x00\x6F\x86\x14\x86\x93\x7F\xC9\x5D\x92\x85\x68\x00\x7D\x86\x1B\x86\xA2\x85\x4D\x28\x92\x85\x76\x00\x76\x86\x70\x86\x3C\x82\xA7\x79\x92\x85\x85\x00\x89\x86\x7E\x86\xA5\x7F\xEC\x1B\x92\x85\x94\x00\x8F\x86\x84\x86\xB5\x85\x4B\x2A\x92\x85\xA3\x00\x95\x86\x28\x86\x51\x82\x67\x41\xA4\x85\x83\x86\x9C\x86\x58\x82\xA2\x2A\x92\x85\xC0\x00\xA0\x86\x2F\x86\x2A\x7D\xB1\x10\x66\x00\x92\x85\xCE\x00\xA6\x86\x36\x86\xFC\x7D\xB7\x30\x68\x00\x92\x85\xDC\x00\xAD\x86\x63\x86\x00\x00\xBC\x76\xB4\x0F\x92\x85\xEA\x00\xB4\x86\xDD\x85\xD1\x1D\x92\x85\xF8\x00\x9B\x86\xCC\x5F\xE1\x5E\xE4\x5D\x6E\x00\x06\x86\xDA\x4D\xE9\x85\x0C\x37\xEC\x85\x7B\x71\xDB\x82\xE6\x79\x92\x85\x07\x00\x0D\x24\x2E\x0F\xDB\x00\xC7\x86\xAC\x21\x74\x00\x67\x0C\x70\x49\xD1\x86\xE2\x51\xD1\x76\xC5\x86\x15\x4F\x1F\x0F\xDF\x00\xE4\x5D\x7B\x00\xDA\x86\x1A\x4F\x1F\x0F\xE1\x00\xE4\x5D\xF8\x41\xC1\x80\xCF\x0F\xDD\x00\xCB\x86\x53\x67\x92\x85\x08\x00\xCF\x86\x86\x0C\xD2\x86\xF6\x24\x7F\x00\xD5\x86", + "\xB1\x10\xAD\x19\x06\x01\xDD\x86\x2F\x30\xE0\x86\xEF\x17\xF6\x86\x3D\x7E\x17\x1C\x92\x85\x09\x00\xED\x86\x26\x27\xEF\x86\x25\x35\xF2\x86\xFE\x12\xE3\x86\x70\x0C\x98\x6A\xF8\x86\xE0\x19\xE2\x00\x1F\x0F\xDC\x00\xE4\x5D\x8F\x00\x08\x87\x7D\x19\xE3\x00\x09\x85\xCF\x10\xCC\x85\x0D\x24\xDE\x01\x11\x87\x10\x85\x3C\x15\x92\x00\x92\x85\x17\x00\x15\x87\x92\x0C\xFD\x85\xB8\x15\x94\x00\x92\x85\x24\x00\x0D\x24\xBB\x01\x17\x87\x24\x85\xA3\x6D\x92\x85\x32\x00\x24\x87\x1E\x87\xD4\x82\x79\x51\x92\x85\x40\x00\x2B\x87\x09\x01\x26\x87\xE3\x82\x80\x51\x92\x85\x4E\x00\x31\x87\xEB\x11\x1C\x86\xB1\x10\x9C\x00\x92\x85\x5C\x00\x1D\x87\x32\x87\x48\x84\x2D\x41\x92\x85\x69\x00\x38\x87\x03\x01\x33\x87\x50\x84\x40\x40\x92\x85\x77\x00\x45\x87\x02\x01\x47\x87\x16\x80\x86\x1E\x8D\x86\x4C\x87\x3B\x52\x37\x86\xAD\x32\xA4\x00\x92\x85\x93\x00\x52\x87\x00\x00\x4E\x87\x59\x85\x6E\x44\x92\x85\xA1\x00\x59\x87\x5B\x87\xE6\x5F\xA8\x00\x92\x85\xAF\x00\x60\x87\x71\x84\x67\x2A\x92\x85\xBD\x00\x0D\x24\xBD\x01\x5B\x87\x64\x53\xAC\x00\x39\x86\x66\x87\x75\x85", + "\xEF\x17\xAE\x00\x40\x86\x3F\x87\x39\x87\x0D\x82\x3D\x17\xB0\x00\x92\x85\xE7\x00\x6B\x87\x2C\x87\x82\x85\x3D\x17\xB2\x00\x4B\x86\x71\x87\x89\x85\xF6\x7D\x92\x85\x04\x00\xFE\x22\x25\x87\x90\x85\xA1\x1A\xB6\x00\x92\x85\x12\x00\xFE\x22\x6C\x87\xC2\x7D\x81\x1C\x92\x85\x21\x00\x88\x87\x7E\x87\x7F\x86\x8D\x2E\x67\x86\x95\x87\x40\x87\x85\x86\x3C\x15\xBC\x00\x92\x85\x3D\x00\x8F\x87\x96\x87\xD5\x7D\xAF\x33\x92\x85\x4C\x00\xA1\x87\x9B\x87\xAF\x85\xCA\x38\xC0\x00\x92\x85\x5B\x00\xA7\x87\x77\x87\x97\x86\x52\x4A\x92\x85\x6A\x00\xAE\x87\x46\x87\xBC\x85\xAD\x32\xC4\x00\x11\x86\x9A\x87\xAF\x87\xE1\x73\xAC\x21\xC6\x00\x18\x86\xBA\x87\xB5\x87\xA8\x86\xFE\x12\xC8\x00\x1F\x86\xC0\x87\x4D\x87\xD0\x85\xAC\x4A\x99\x86\xC6\x87\x53\x87\xCC\x7F\xB6\x11\xCC\x00\x92\x85\xB1\x00\xCB\x87\x5A\x87\xBC\x86\x55\x48\x92\x85\xBF\x00\xB4\x87\x02\x01\xB3\x19\xD4\x7E\x61\x38\xAB\x86\xFE\x22\x2E\x0F\xB9\x19\xFF\x84\xC8\x4A\x67\x0C\x6A\x49\xBF\x19\x4A\x3C\x4F\x7E\x0F\x87\x05\x11\x4B\x76\xC1\x87\x44\x1F\xE8\x87\xB6\x11\xCA\x19\xE1\x87\x03\x2F\xC9\x86", + "\xFE\x12\x92\x12\x09\x01\xEF\x87\x52\x1F\xED\x87\x11\x85\x01\x87\x82\x71\xF2\x87\x64\x16\x98\x12\xF0\x87\xD3\x30\xF8\x87\x3C\x15\xCF\x19\xFF\x87\x9D\x38\x01\x88\xAA\x15\xED\x00\xFA\x87\x4A\x28\x06\x88\x48\x15\xB4\x12\x04\x88\xF6\x24\xE2\x00\x0B\x88\xB8\x15\xBD\x1E\x0E\x88\x6E\x6E\x11\x88\xCF\x0F\xF0\x00\x1F\x0F\xD5\x19\x2A\x2F\x92\x85\x42\x3E\x1F\x0F\xDC\x19\xD0\x1A\xE6\x00\x16\x88\x03\x0F\xF3\x00\x1F\x0F\xF6\x00\xE4\x5D\xE7\x00\x22\x88\xC7\x0D\x6C\x60\xB3\x2E\xE8\x00\x92\x85\xCF\x00\xFE\x22\x88\x13\x24\x88\x4D\x13\xB3\x2E\xEA\x00\x92\x85\xD1\x00\xDE\x87\x10\x0E\x2B\x88\x1A\x4B\x92\x85\xD2\x00\x30\x88\x39\x88\x33\x88\x91\x7E\x92\x85\xD4\x00\x38\x88\x15\x0E\x1F\x0F\xF1\x00\x3C\x64\xE3\x87\x66\x58\x1F\x0F\xF5\x00\x36\x62\x29\x88\x8B\x13\x95\x57\xE4\x5D\xF5\x00\x4E\x88\x14\x12\x25\x88\x10\x75\x53\x88\x03\x01\x1F\x88\xCE\x0D\x97\x5F\x57\x88\x02\x01\xF9\x00\x6C\x0F\xB3\x2E\xF8\x00\x1C\x88\xB6\x11\xFB\x00\x1F\x0F\xFC\x00\x1E\x75\x5C\x88\xEF\x59\xC7\x5D\xDA\x68\x68\x88\x89\x0E\x3A\x88\xFB\x1E\xFC\x00\x92\x85\xD5\x00", + "\x3E\x88\xB3\x59\x1F\x0F\x1F\x00\xB3\x2E\xFE\x00\x92\x85\xD7\x00\x44\x88\x9F\x0E\x6E\x88\x5E\x4B\x28\x0B\x88\x13\xD8\x00\x73\x88\x7C\x88\x40\x88\xFB\x1E\x02\x00\x7F\x88\x01\x0C\x7B\x88\xC1\x0E\xE9\x86\x79\x2E\x04\x00\x87\x88\x24\x0C\x89\x88\xE9\x10\x1F\x0F\xFA\x00\x48\x75\x28\x0B\xFD\x3A\x7B\x17\xBA\x5C\xF1\x68\x28\x0B\xCC\x35\x97\x88\x5F\x5A\xEB\x7E\x9A\x88\xB1\x10\x01\x00\xFC\x10\x66\x88\x78\x31\x9F\x88\xFE\x12\x02\x00\xFC\x10\x64\x88\xD0\x1A\x0E\x00\xA5\x88\x64\x16\xA7\x88\x09\x0F\xB0\x2F\xAC\x88\x3D\x17\x03\x00\xFC\x10\x09\x00\xB3\x2E\x10\x00\x8E\x88\x64\x16\x05\x00\xFC\x10\x07\x00\xB3\x2E\x12\x00\xB1\x88\xEF\x17\xBA\x88\xB4\x0D\xE4\x5D\x13\x00\xB8\x88\xAB\x4F\x90\x88\x5D\x17\x56\x1A\xB3\x2E\x15\x00\xC5\x88\x5A\x0C\xC7\x88\xBB\x16\xBB\x88\xB3\x2E\x17\x00\xBF\x88\xE0\x19\xB6\x13\xB6\x0D\xE4\x5D\x18\x00\xCC\x88\x0F\x2F\xCE\x88\xD5\x88\x3F\x0F\xB3\x2E\x1A\x00\xD9\x88\xA3\x50\xCE\x88\xBC\x88\x7F\x0F\xB3\x2E\x1C\x00\x28\x0B\x6A\x49\xBC\x13\x44\x17\xB3\x2E\x20\x00\xD3\x88\x7D\x19\xE9\x88\xB8\x0D\x44\x6C\xE0\x88", + "\xE0\x00\xCE\x88\xEF\x88\x42\x0F\xB3\x2E\x23\x00\xE0\x88\xE1\x00\xCE\x88\xB5\x88\x1A\x16\xB3\x2E\x25\x00\xED\x88\x05\x11\xF0\x19\x3B\x01\xB3\x2E\x26\x00\xE0\x88\xA1\x15\xFC\x10\x12\x00\xB3\x2E\x28\x00\x00\x89\x2B\x18\xCD\x1E\xB3\x2E\x48\x42\xE6\x86\x03\x0F\x0E\x00\xFC\x10\xCC\x1E\x95\x82\x95\x88\x8E\x5F\xFC\x10\x0F\x00\xB3\x2E\x2F\x00\x0C\x89\x0A\x12\x1A\x89\xEF\x85\x64\x16\x30\x00\xE0\x88\xE2\x00\xFE\x22\xDE\x01\x1F\x89\xF7\x85\x3D\x17\x32\x00\xE0\x88\xEF\x00\x25\x89\x85\x01\xFC\x10\xE6\x5C\xE5\x64\xE0\x88\xFC\x00\xD2\x87\x27\x89\x5B\x7D\xFE\x12\x36\x00\xE0\x88\x0A\x00\xF9\x23\x10\x02\xFC\x10\x24\x5B\xCC\x21\x38\x00\xE0\x88\x18\x00\x3B\x89\x2E\x89\x28\x7F\x08\x22\xE0\x88\x26\x00\x43\x89\x27\x01\xFC\x10\xA5\x75\xDC\x62\xE0\x88\x34\x00\xF9\x23\x26\x89\xFC\x10\xAD\x75\xAD\x32\x3E\x00\xE0\x88\x41\x00\x49\x89\x41\x01\xFC\x10\x72\x7A\x3C\x15\x40\x00\xE0\x88\x4F\x00\x58\x89\x5B\x01\xFC\x10\x8D\x72\xE0\x19\x42\x00\xE0\x88\x5D\x00\x60\x89\x07\x01\xFC\x10\x94\x72\x05\x11\x44\x00\xE0\x88\x6B\x00\x68\x89\xA1\x01\xFC\x10", + "\x24\x80\x3C\x15\x46\x00\xE0\x88\x79\x00\x70\x89\xBC\x01\xFC\x10\xE6\x5F\x48\x00\xE0\x88\x87\x00\x78\x89\x35\x89\xC5\x7C\xA5\x7C\xE0\x88\x95\x00\xF9\x23\xBD\x01\x80\x89\x79\x84\x12\x3F\xE0\x88\xA4\x00\x7F\x89\xFC\x10\xD1\x6B\x4E\x00\xE0\x88\xB2\x00\x50\x89\x44\x89\x87\x84\xC4\x23\xE0\x88\xBF\x00\x85\x89\x93\x89\x8E\x84\xD1\x69\xE0\x88\xCE\x00\x8C\x89\x95\x84\xB7\x30\x69\x42\xE3\x16\xDC\x00\x9E\x89\x71\x86\xEF\x16\x56\x00\xE0\x88\xEA\x00\x98\x89\x4A\x89\x45\x83\x4B\x26\xE0\x88\xF9\x00\xA4\x89\x97\x87\xA1\x79\xE0\x88\x07\x00\xB4\x34\x3C\x89\x9C\x87\xF6\x7F\xE0\x88\x15\x00\xB4\x34\x86\x89\xFC\x10\xE5\x72\xB7\x30\x5E\x00\xE0\x88\x24\x00\xBB\x89\x99\x89\x91\x86\x03\x19\x60\x00\xE0\x88\x33\x00\xC3\x89\xAB\x89\xB0\x87\x64\x16\x62\x00\xE0\x88\x42\x00\xCA\x89\x59\x89\x9D\x86\xAA\x15\x64\x00\xE0\x88\x51\x00\xB5\x89\xC4\x89\x0B\x7A\xC2\x47\xE0\x88\x5F\x00\xD8\x89\xCB\x89\xE9\x83\xB0\x86\xE0\x88\x6D\x00\xDE\x89\xD2\x89\xEF\x83\x18\x2C\xE0\x88\x7B\x00\xE4\x89\x61\x89\xCD\x87\x0A\x12\x6C\x00\xE0\x88\x89\x00\xEA\x89\x69\x89", + "\xFD\x83\x43\x4A\xE0\x88\x97\x00\xD1\x89\x5D\x01\x14\x89\xB3\x2E\x70\x00\x17\x89\x0E\x6C\xFC\x10\xF5\x19\xF8\x2B\x1D\x89\x3C\x15\x09\x89\x3D\x01\xB3\x2E\x76\x00\x01\x8A\xAA\x15\x13\x00\xFC\x10\x23\x2F\x2A\x37\x06\x89\xF8\x19\xFC\x10\xD3\x1E\xCB\x76\x07\x8A\x48\x15\x16\x00\xFC\x10\x18\x00\xB3\x2E\x7A\x00\x12\x8A\xB8\x15\x14\x8A\x03\x89\xD0\x1A\x7B\x00\xE0\x88\xA6\x00\xB4\x34\x88\x13\x1B\x8A\xD6\x1E\xB3\x2E\x7D\x00\xE0\x88\xA8\x00\xB4\x34\xF6\x10\x23\x8A\x3A\x2B\xB3\x2E\x7F\x00\xE0\x88\xAB\x00\x29\x8A\x17\x01\xFC\x10\xB2\x2E\x4D\x37\xE0\x88\xAE\x00\x31\x8A\xD4\x02\xFC\x10\x6A\x77\x60\x3D\xE0\x88\xB1\x00\x38\x8A\xBD\x05\xFC\x10\x17\x76\xE1\x20\x85\x00\xE0\x88\xB4\x00\x3F\x8A\x4E\x0D\xFC\x10\xCB\x2E\x62\x37\xE0\x88\xB7\x00\x47\x8A\x4C\x04\xFC\x10\xD2\x2E\xB0\x27\xE0\x88\xBA\x00\x4E\x8A\xF9\x03\xFC\x10\xDA\x2E\xD0\x1A\x8B\x00\xE0\x88\xBD\x00\x55\x8A\x8C\x04\xFC\x10\x6D\x2F\xFB\x1E\x8D\x00\xE0\x88\xC0\x00\x5D\x8A\x2B\x8A\x9B\x35\xB3\x2E\x8F\x00\xE0\x88\xC3\x00\x65\x8A\xFC\x10\x78\x2F\xCC\x27\xE0\x88\xC6\x00\x6C\x8A", + "\xF5\x2E\xB3\x2E\x93\x00\xE0\x88\xC9\x00\x72\x8A\xFC\x2E\xD0\x1A\x95\x00\xE0\x88\xCC\x00\x78\x8A\xCF\x40\xEE\x24\xE0\x88\xCF\x00\x7E\x8A\x08\x2F\xB3\x2E\x99\x00\xE0\x88\xD2\x00\x83\x8A\x0F\x2F\xB3\x2E\x9B\x00\xE0\x88\xD5\x00\x89\x8A\x16\x2F\xB3\x2E\x9D\x00\xE0\x88\xD8\x00\x8F\x8A\x1D\x2F\xBA\x37\xE0\x88\xDB\x00\x8F\x8A\x0B\x8A\x07\x28\xE0\x88\xDE\x00\x8F\x8A\x29\x2F\x48\x3A\xF9\x88\x5D\x8A\x17\x00\x15\x8A\xB3\x2E\xA5\x00\x19\x8A\x31\x20\xFC\x10\x0C\x00\x93\x54\xE0\x88\xE4\x00\x21\x8A\xCB\x13\xD6\x20\xB3\x2E\xA8\x00\xE0\x88\xE6\x00\xA3\x8A\xFC\x10\x69\x00\xB1\x63\xE0\x88\xE9\x00\xB6\x8A\x4A\x2F\xD0\x1A\xAC\x00\xE0\x88\xEC\x00\xBC\x8A\x94\x89\xFF\x59\x2B\x89\xC2\x8A\x54\x2F\xB3\x2E\xB0\x00\xE0\x88\xF2\x00\xC6\x8A\x5B\x2F\xFF\x37\xE0\x88\xF5\x00\xCC\x8A\x61\x2F\x07\x3E\xE0\x88\xF8\x00\xD1\x8A\x67\x2F\x2F\x49\xE0\x88\xFB\x00\xD6\x8A\x60\x8A\x35\x49\xE0\x88\xFE\x00\xD6\x8A\x73\x2F\x12\x3E\xE0\x88\x01\x00\x80\x35\xF6\x10\xA4\x8A\xDF\x20\xB3\x2E\xBC\x00\xE0\x88\x04\x00\xE5\x8A\xB0\x8A\xA3\x4F\xB3\x2E\xBE\x00\xB3\x89", + "\xED\x8A\xB4\x02\xFC\x10\x82\x2F\x9A\x1C\x39\x89\xF3\x8A\x0F\x0A\xFC\x10\x9F\x83\x7A\x08\xE0\x88\x0D\x00\xF9\x8A\xC6\x13\x8B\x1E\xBB\x2E\xE0\x88\x10\x00\x00\x8B\x1F\x04\xFC\x10\x94\x2F\xFB\x1E\xC6\x00\xE0\x88\x13\x00\x06\x8B\x80\x04\xBD\x89\xB3\x2E\xC8\x00\xE0\x88\x16\x00\x0E\x8B\x70\x04\xFC\x10\x96\x8A\xFB\x1E\xCA\x00\xE0\x88\x19\x00\x15\x8B\xE7\x8A\x02\x02\xDB\x2E\xE0\x88\x1C\x00\x1D\x8B\xFC\x10\xA0\x8A\x3F\x47\xE0\x88\x1F\x00\x15\x8B\x16\x8A\x31\x01\xB3\x2E\xD0\x00\xE7\x88\xB1\x10\x10\x8A\x40\x8A\x67\x48\xA8\x8A\x03\x0F\x03\x1A\x1C\x8A\xFB\x1E\xD5\x00\xE0\x88\x22\x00\x80\x35\x2E\x0F\x35\x8B\xFA\x2C\xB3\x2E\xD7\x00\x0D\x8A\x0A\x12\xD1\x13\x98\x2E\x4B\x1F\xE0\x88\x23\x00\x3B\x8B\xD0\x13\xFC\x10\x76\x88\xD0\x1A\xDB\x00\x33\x8B\x82\x15\x8F\x1A\x82\x71\xC1\x89\x48\x8B\xB8\x13\xFC\x10\xE3\x53\xB7\x30\xDE\x00\xE0\x88\x25\x00\x53\x8B\x4E\x12\xFC\x10\xED\x77\x2C\x78\x47\x89\x5B\x8B\x03\x01\x1D\x00\xFC\x10\x69\x22\xC3\x35\xE0\x88\x27\x00\x61\x8B\x99\x16\x0A\x8A\xE4\x25\xE0\x88\x28\x00\x69\x8B\xF6\x46\xFC\x10\x03\x78", + "\x0E\x34\xE0\x88\x29\x00\x6F\x8B\x00\x00\x63\x8B\xD8\x4E\x83\x2C\xE0\x88\x2A\x00\x76\x8B\x78\x8B\xCA\x1D\x03\x19\xEA\x00\xE0\x88\x2B\x00\x7D\x8B\x14\x89\xCE\x19\xE0\x88\x2C\x00\x84\x8B\x25\x1B\xFB\x1E\xEE\x00\xE0\x88\x2D\x00\x89\x8B\xFD\x15\xFB\x1E\xF0\x00\xE0\x88\x2E\x00\x8F\x8B\x93\x1C\xE1\x20\xF2\x00\xE0\x88\x2F\x00\x95\x8B\x99\x1C\x09\x75\xE0\x88\x30\x00\x9B\x8B\x9F\x1C\x9A\x55\xE0\x88\x31\x00\xA0\x8B\xA5\x1C\x17\x75\xE0\x88\x32\x00\xA5\x8B\x32\x54\xB7\x30\xFA\x00\xC8\x89\x76\x8B\xD7\x13\x48\x12\xB3\x2E\xFC\x00\xFC\x89\x64\x16\x4B\x8B\x5C\x8B\x88\x23\x00\x0E\xCC\x35\x0A\x1A\xDB\x87\x06\x26\x00\x0E\x88\x13\x34\x00\x76\x8B\xBB\x8B\x06\x01\x3C\x7E\xE1\x20\x04\x00\xBE\x8B\x3E\x0C\xC1\x8B\xFC\x10\x2F\x7E\xFB\x1E\x06\x00\xC7\x8B\x9B\x0F\x76\x8B\xDD\x13\x58\x20\xB3\x2E\x08\x00\xB9\x8B\x4E\x1C\xFC\x10\x21\x00\xB3\x2E\x09\x00\xD5\x8B\x2D\x50\x3A\x8A\xB3\x2E\x0A\x00\xCE\x8B\x64\x16\x24\x00\xFB\x8A\xB3\x2E\x0C\x00\xE0\x8B\x3D\x17\xE2\x8B\xA8\x85\x7D\x19\x0E\x00\xE6\x8B\xE2\x1C\xFC\x10\x18\x1A\x42\x39\xDB\x8B\xE8\x1C", + "\xAA\x8A\xB3\x2E\x11\x00\xEC\x8B\x3E\x0E\x80\x35\x88\x13\x11\x1A\x84\x88\x07\x6F\xF6\x8B\x4D\x20\x76\x8B\xDB\x1E\x36\x8B\x7C\x75\xFD\x8B\x3A\x00\xF8\x8B\x67\x4D\x4A\x8B\xD1\x88\xFD\x8B\x3C\x00\x76\x8B\x28\x00\x50\x8B\x03\x19\x19\x00\xFD\x8B\x3D\x00\x0B\x8C\x55\x8B\x0A\x1D\xFD\x8B\x3E\x00\x12\x8C\x61\x22\x26\x6F\xFD\x8B\x3F\x00\x17\x8C\xBD\x18\x2D\x6F\xFD\x8B\x40\x00\x1C\x8C\xCB\x4E\xCC\x21\x21\x00\xFD\x8B\x41\x00\x21\x8C\xCB\x18\x60\x20\xFD\x8B\x42\x00\x27\x8C\x45\x1B\xFB\x1E\x25\x00\xFD\x8B\x43\x00\x2C\x8C\xD8\x18\xA6\x58\xFD\x8B\x44\x00\x32\x8C\x18\x78\x64\x16\x29\x00\xFD\x8B\x45\x00\x32\x8C\x20\x78\xB1\x10\x2B\x00\xFD\x8B\x46\x00\x32\x8C\x25\x78\x48\x15\x2D\x00\xFD\x8B\x47\x00\x32\x8C\x1B\x54\xBD\x58\xFD\x8B\x48\x00\x32\x8C\x21\x54\x0A\x12\xD4\x42\xE3\x16\x49\x00\x32\x8C\x26\x54\xB7\x30\x33\x00\xFD\x8B\x4A\x00\x32\x8C\x2C\x54\xCA\x38\x35\x00\xFD\x8B\x4B\x00\x32\x8C\xAB\x8B\x00\x37\x37\x00\xFD\x8B\x4C\x00\x76\x8B\xFA\x13\xB9\x14\xB3\x2E\x39\x00\x00\x0E\x3E\x41\x3C\x15\x2A\x00\xFC\x10\x25\x00\xB3\x2E\x43\x00", + "\x6B\x8C\x3F\x8C\xFC\x10\x6E\x8C\x8A\x24\xF1\x8B\x3D\x17\x2B\x00\xFC\x10\x6C\x74\xEF\x16\xE2\x42\xE3\x16\x4D\x00\x05\x8C\x30\x06\xFC\x10\xC4\x8B\xBE\x6C\xFD\x8B\x4F\x00\x81\x8C\x35\x06\xCA\x8B\xE4\x5D\x52\x00\xFD\x8B\x51\x00\x88\x8C\x98\x06\xFC\x10\x0C\x8C\xD0\x1A\x54\x00\x78\x8C\xEF\x17\x2D\x00\xFC\x10\x00\x8C\xF5\x26\x95\x8C\xE0\x19\x97\x8C\x80\x06\xB3\x2E\x56\x00\x9B\x8C\x7D\x19\x2E\x00\xFC\x10\x34\x00\xB3\x2E\x57\x00\xA1\x8C\x05\x11\xA3\x8C\x01\x8C\xE4\x69\xFD\x8B\x53\x00\x8F\x8C\xA6\x0B\x07\x8C\x97\x46\xFD\x8B\x55\x00\x76\x8B\x2F\x00\xF3\x8B\xD0\x1A\xE9\x42\x03\x56\xAF\x8C\xBA\x69\xB1\x8C\xA0\x60\xFD\x8B\x58\x00\x76\x8B\x30\x00\x0D\x8C\xA1\x1A\x60\x00\xFD\x8B\x59\x00\xC1\x8C\x13\x8C\x00\x6A\xFD\x8B\x5A\x00\xC8\x8C\x18\x8C\xAC\x21\x64\x00\xFD\x8B\x5B\x00\xCD\x8C\x1D\x8C\x9D\x26\x66\x00\xFD\x8B\x5C\x00\xD3\x8C\x22\x8C\x36\x4A\xFD\x8B\x5D\x00\xD9\x8C\x28\x8C\xCC\x21\x6A\x00\xFD\x8B\x5E\x00\xDE\x8C\x2D\x8C\x78\x21\xFD\x8B\x5F\x00\xE4\x8C\x33\x8C\x31\x80\xFD\x8B\x60\x00\xE9\x8C\x38\x8C\x3D\x17\x70\x00\xFD\x8B", + "\x61\x00\xE9\x8C\x3E\x8C\xFE\x12\x72\x00\xFD\x8B\x62\x00\xE9\x8C\x44\x8C\x22\x30\xFD\x8B\x63\x00\xE9\x8C\x4A\x8C\x3C\x15\x76\x00\xFD\x8B\x64\x00\xE9\x8C\x4F\x8C\x3C\x15\x78\x00\xFD\x8B\x65\x00\xE9\x8C\x55\x8C\x00\x37\x7A\x00\xFD\x8B\x66\x00\xE9\x8C\x5B\x8C\xB1\x10\x7C\x00\xFD\x8B\x67\x00\xE9\x8C\x61\x8C\x60\x6A\xFD\x8B\x68\x00\x76\x8B\x31\x00\x6F\x8C\xB3\x2E\x80\x00\x00\x0E\xEF\x8C\xA5\x06\x1E\x8D\x59\x8A\x21\x8D\xA1\x6A\xFC\x10\x1F\x1A\x5B\x1E\xA8\x8C\x72\x6F\x7B\x8C\xE4\x5D\x97\x00\xFD\x8B\x69\x00\xBB\x8C\x00\x00\x08\x14\x00\x11\x06\x84\xFD\x8B\x6B\x00\x32\x8D\x34\x8D\x61\x2E\x0C\x84\xFD\x8B\x6D\x00\x32\x8D\xA5\x8C\xEE\x0F\x91\x8A\x2B\x8D\x0A\x12\xE3\x1E\x8F\x06\xB3\x2E\x9E\x00\x43\x8D\x3C\x15\x45\x8D\x6B\x06\xB3\x2E\x9F\x00\x49\x8D\xAA\x15\x36\x00\xFC\x10\xAA\x8C\x40\x40\x4F\x8D\xE2\x1F\xFC\x10\xFA\x8B\x07\x28\xFD\x8B\x05\x11\x37\x00\xFC\x10\x51\x8D\xC9\x67\x5A\x8D\xB6\x11\x26\x1A\x09\x01\x58\x8D\x1D\x42\x60\x8D\x0A\x12\x62\x8D\xB9\x0E\xB3\x2E\xA7\x00\x66\x8D\x3C\x15\xCF\x58\x64\x8D\xAC\x21\xA9\x00\x6C\x8D", + "\x88\x4D\x5D\x8D\xB3\x2E\xAB\x00\x72\x8D\x48\x15\x99\x2F\x68\x8D\xD9\x6A\x55\x8D\xB8\x15\x89\x2F\x5C\x8D\xB4\x1E\x7C\x8D\x2C\x1A\x41\x8A\x6C\x3A\x77\x8D\xB8\x15\x42\x8A\x5D\x24\xB3\x2E\xB1\x00\x81\x8D\x03\x0F\x3F\x00\xFC\x10\x34\x1A\xFF\x37\x8B\x8D\x3E\x26\xFC\x10\x40\x00\xB3\x2E\xB3\x00\x91\x8D\xB2\x1E\xC3\x8C\xCC\x21\x11\x43\xE3\x16\x6F\x00\x76\x8B\x94\x8D\xDC\x35\x0F\x48\xFD\x8B\x70\x00\x9E\x8D\x5D\x8B\x60\x42\xFD\x8B\x71\x00\xA4\x8D\xEE\x53\xCC\x21\xBA\x00\xFD\x8B\x72\x00\xA9\x8D\xF3\x53\xAD\x32\xBC\x00\xFD\x8B\x73\x00\xAF\x8D\xF9\x53\xA7\x40\xFD\x8B\x74\x00\xB5\x8D\xFF\x53\xD0\x7A\xFD\x8B\x75\x00\xBA\x8D\x04\x54\xAD\x32\xC2\x00\xFD\x8B\x76\x00\xBF\x8D\x0A\x54\xB7\x87\xFD\x8B\x77\x00\xC5\x8D\xF5\x8C\x64\x16\xC6\x00\xFD\x8B\x78\x00\xC5\x8D\xFB\x8C\x91\x83\xFD\x8B\x79\x00\xC5\x8D\x00\x8D\x82\x44\xFD\x8B\x7A\x00\xC5\x8D\x06\x8D\xAA\x15\xCC\x00\xFD\x8B\x7B\x00\xC5\x8D\x0C\x8D\xBA\x4A\xFD\x8B\x7C\x00\xC5\x8D\x12\x8D\xFE\x12\xD0\x00\xFD\x8B\x7D\x00\xC5\x8D\x18\x8D\xB1\x10\xD2\x00\xFD\x8B\x7E\x00\x76\x8B\x11\x14", + "\x39\x21\xF7\x2E\x97\x8D\x06\x01\x8F\x8D\x6D\x75\xEA\x22\xFD\x8B\x7F\x00\x80\x35\xDE\x01\xF7\x8D\x74\x75\x03\x19\xD7\x00\xFD\x8B\x8C\x00\xFC\x8D\x0C\x01\xFE\x8D\x7A\x58\xF6\x24\xD9\x00\xFD\x8B\x99\x00\x80\x35\xBB\x01\x06\x8E\x81\x58\x79\x2E\xDB\x00\xFD\x8B\xA7\x00\x0C\x8E\x05\x8E\x3D\x89\x06\x23\xFD\x8B\xB5\x00\x14\x8E\xF3\x8D\x45\x89\x8A\x0C\xFD\x8B\xC3\x00\x1A\x8E\xF6\x8D\x4B\x89\x18\x41\xFD\x8B\xD1\x00\x04\x8E\x1B\x8E\xA4\x7C\x1E\x23\xFD\x8B\xDE\x00\x20\x8E\x03\x01\x0E\x8E\x69\x6D\xAC\x21\xE5\x00\xFD\x8B\xEC\x00\x2C\x8E\x02\x01\x2E\x8E\x63\x89\x7D\x19\xE7\x00\xFD\x8B\xFA\x00\x34\x8E\xDD\x6E\x6A\x89\xA9\x18\xE9\x00\xFD\x8B\x08\x00\xC7\x35\xB0\x04\x2E\x8E\x73\x89\x97\x6B\xFD\x8B\x16\x00\x43\x8E\x31\x05\x2E\x8E\xE6\x5F\x2B\x43\xE3\x16\x24\x00\x4A\x8E\x52\x05\x2E\x8E\x0F\x6A\xEF\x00\xFD\x8B\x32\x00\x51\x8E\x53\x05\x2E\x8E\x64\x53\xF1\x00\x25\x8C\x58\x8E\x0D\x8E\x8D\x89\x59\x23\x86\x8C\x58\x8E\xFD\x8D\xDD\x8B\xD0\x1A\xF5\x00\xD7\x8C\x58\x8E\xBD\x01\x2E\x8E\x72\x77\xCA\x38\xF7\x00\x37\x8D\x5E\x8E\x15\x8E\x9F\x89", + "\x00\x37\xF9\x00\xD3\x8D\x70\x8E\x27\x8E\x3E\x83\x79\x2E\x31\x43\xFD\x42\x69\x8E\x71\x8E\xA2\x84\xEF\x17\xFD\x00\xFD\x8B\x96\x00\x76\x8E\x21\x8E\x9C\x85\x9D\x5F\xFD\x8B\xA4\x00\x83\x8E\x2D\x8E\xE3\x8B\x88\x23\xE5\x0D\x88\x13\xB2\x00\x7C\x8E\x77\x8E\xA3\x87\x52\x31\x8D\x8E\x00\x15\x90\x8E\x84\x8E\xA9\x87\x56\x16\x94\x8E\x0B\x26\x96\x8E\x8A\x8E\x4A\x82\xB8\x15\x07\x00\x9A\x8E\xF5\x86\x9C\x8E\x35\x8E\xFC\x10\xE4\x7A\xB7\x30\x37\x43\x88\x51\x89\x8E\xA4\x8E\xC3\x85\x86\x43\xA1\x8E\xD9\x59\xAA\x8E\x3D\x8E\xC2\x87\x64\x16\x0D\x00\xAE\x8E\xB2\x01\xDB\x29\x5F\x8E\xAF\x86\xE8\x52\xB5\x8E\x78\x62\xB7\x8E\x7D\x8E\xE2\x84\xB7\x2F\xBB\x8E\x42\x62\xBD\x8E\x91\x8E\x66\x75\x1F\x20\xC1\x8E\x34\x00\xDB\x29\xBD\x01\x43\x00\xFC\x10\x3D\x00\xCA\x88\xE5\x0D\xFD\x3A\xF7\x1E\xDF\x6E\xDE\x88\xE5\x0D\xCC\x35\x45\x00\xF5\x8A\xB3\x2E\x1B\x00\xC1\x8E\x05\x11\xF6\x8A\x71\x2B\xB3\x2E\x1D\x00\xD4\x8E\x46\x22\x99\x8D\x79\x2E\x1E\x00\xC1\x8E\x43\x00\xDB\x29\x2E\x0F\x3B\x1A\xA0\x8D\xAC\x21\x20\x00\xC1\x8E\x44\x00\xE7\x8E\x8B\x10\xFC\x10\x4B\x00", + "\xB3\x2E\x22\x00\xE0\x8E\xFE\x12\xE9\x8E\xE4\x35\x53\x2D\xC1\x8E\x45\x00\xEF\x8E\x09\x01\xF7\x8E\xF4\x77\x2E\x8C\xC1\x8E\x46\x00\xFC\x8E\x99\x4B\x6B\x8B\xD0\x1A\x27\x00\xC1\x8E\x47\x00\x03\x8F\xE5\x6E\x71\x8B\x57\x26\xC1\x8E\x48\x00\x0A\x8F\xBD\x5D\xFC\x10\x81\x22\xB2\x58\xC1\x8E\x49\x00\x10\x8F\xBB\x36\xAA\x8A\xD5\x2F\xC1\x8E\x4A\x00\x17\x8F\x00\x00\xFE\x8E\xCD\x04\xE9\x31\xC1\x8E\x4B\x00\x1D\x8F\x1F\x8F\x1F\x78\xA9\x18\x31\x00\xC1\x8E\x4C\x00\x24\x8F\xEF\x1A\x4C\x53\xC1\x8E\x4D\x00\x2B\x8F\x2B\x78\x14\x44\xC1\x8E\x4E\x00\x30\x8F\x31\x78\x06\x18\xC1\x8E\x4F\x00\x35\x8F\x36\x78\x7E\x36\xC1\x8E\x50\x00\x3A\x8F\x3B\x78\xF6\x24\x3B\x00\xC1\x8E\x51\x00\x3F\x8F\x41\x78\x92\x6F\xC1\x8E\x52\x00\x1D\x8F\x49\x00\xE2\x8E\xAD\x32\x3F\x00\xC1\x8E\x53\x00\x4A\x8F\xC9\x8C\x65\x24\xC1\x8E\x54\x00\x51\x8F\xCE\x8C\xB2\x26\xC1\x8E\x55\x00\x56\x8F\xD4\x8C\xAC\x6F\xC1\x8E\x56\x00\x5B\x8F\xDA\x8C\x88\x53\xC1\x8E\x57\x00\x60\x8F\xDF\x8C\x79\x2E\x49\x00\xC1\x8E\x58\x00\x65\x8F\xE5\x8C\xAC\x21\x4B\x00\xC1\x8E\x59\x00\x6B\x8F\xEA\x8C", + "\xCC\x21\x4D\x00\xC1\x8E\x5A\x00\x71\x8F\x22\x8D\xE0\x19\x4F\x00\xC1\x8E\x5B\x00\x71\x8F\xCB\x8D\x20\x59\xC1\x8E\x5C\x00\x71\x8F\xD1\x8D\x03\x0F\x53\x00\xC1\x8E\x5D\x00\x71\x8F\xD6\x8D\x48\x15\x55\x00\xC1\x8E\x5E\x00\x71\x8F\xDB\x8D\x48\x15\x57\x00\xC1\x8E\x5F\x00\x71\x8F\xE1\x8D\xB1\x10\x59\x00\xC1\x8E\x60\x00\x71\x8F\xE6\x8D\x64\x16\x5B\x00\xC1\x8E\x61\x00\x71\x8F\xEC\x8D\xCE\x76\xC1\x8E\x62\x00\x1D\x8F\x4A\x00\xFC\x10\x46\x00\xB3\x2E\x5F\x00\xE5\x0D\x6A\x49\xF2\x8E\x67\x22\xB3\x2E\x63\x00\xF5\x8E\x74\x1D\xFC\x10\x4B\x8F\xE9\x29\xB1\x8F\x73\x79\xF1\x8E\x5E\x83\xB6\x8F\xEF\x17\x4D\x00\xFC\x10\x25\x8F\xD5\x8C\xBA\x8F\xE0\x19\x41\x1A\xE8\x8A\x15\x70\xDA\x8E\x98\x5B\x7B\x8C\xB3\x2E\x69\x00\xC0\x8F\xE1\x23\x4C\x8F\xB7\x30\x6A\x00\xC1\x8E\x63\x00\x1D\x8F\xFE\x1E\xEA\x8E\x11\x7D\xC1\x8E\x64\x00\xD1\x8F\xA5\x8D\x80\x21\xC1\x8E\x65\x00\xD7\x8F\xAA\x8D\xFA\x53\xC1\x8E\x66\x00\xDC\x8F\xB0\x8D\x56\x44\xC1\x8E\x67\x00\xE1\x8F\xB6\x8D\x30\x6D\xC1\x8E\x68\x00\xE6\x8F\xBB\x8D\x9D\x26\x76\x00\xC1\x8E\x69\x00\xEB\x8F\xC0\x8D", + "\xB7\x30\x78\x00\xC1\x8E\x6A\x00\xF1\x8F\xC6\x8D\xB7\x30\x7A\x00\xC1\x8E\x6B\x00\xF7\x8F\x7E\x8F\xEF\x17\x7C\x00\xC1\x8E\x6C\x00\xF7\x8F\x83\x8F\x32\x1F\xC1\x8E\x6D\x00\xF7\x8F\x89\x8F\x73\x35\xC1\x8E\x6E\x00\xF7\x8F\x8F\x8F\xB8\x15\x82\x00\xC1\x8E\x6F\x00\xF7\x8F\x95\x8F\x58\x36\xC1\x8E\x70\x00\xF7\x8F\x9B\x8F\xF0\x4B\xC1\x8E\x71\x00\xF7\x8F\xA1\x8F\xBD\x37\xC1\x8E\x72\x00\x1D\x8F\x52\x00\x2F\x89\xB3\x2E\x8A\x00\xCA\x8F\x05\x11\x53\x00\xFC\x10\x56\x00\xB3\x2E\x8B\x00\x27\x90\xB6\x11\x29\x90\x3E\x73\xB3\x2E\x8C\x00\x2E\x90\x0A\x12\x30\x90\x54\x26\xB3\x2E\x8D\x00\x34\x90\x47\x1A\xFC\x10\x55\x00\xB3\x2E\x8E\x00\x3A\x90\xEA\x24\x2A\x90\x68\x8A\x40\x90\x8A\x8F\xFC\x10\x58\x00\xB3\x2E\x90\x00\x44\x90\xE1\x25\xFC\x10\x57\x00\xB3\x2E\x91\x00\x4A\x90\xCF\x0F\x4D\x90\x4B\x26\xB3\x2E\x92\x00\x50\x90\x03\x0F\x47\x90\x5A\x72\x74\x8A\xE5\x0D\x2D\x79\x4A\x27\xFC\x10\x23\x90\xB6\x59\x56\x90\x2C\x74\xFC\x10\xD2\x8F\xF0\x27\x61\x90\xAB\x75\xFC\x10\x8F\x2F\xA5\x65\xC5\x8F\xE6\x1B\x2D\x8D\x78\x1E\xC1\x8E\x73\x00\x1D\x8F\x06\x1F", + "\x06\x01\x5C\x00\xBC\x6D\xE5\x0D\x97\x60\x5F\x00\xCC\x8F\x00\x37\xA3\x00\xC1\x8E\x74\x00\x1D\x8F\x78\x90\xD3\x8F\x9D\x26\xA5\x00\xC1\x8E\x75\x00\x7E\x90\xD8\x8F\xFB\x1E\xA7\x00\xC1\x8E\x76\x00\x85\x90\xDD\x8F\x2B\x42\xC1\x8E\x77\x00\x8B\x90\xE2\x8F\xE4\x67\xC1\x8E\x78\x00\x90\x90\xE7\x8F\x00\x37\xAD\x00\xC1\x8E\x79\x00\x95\x90\xEC\x8F\xEF\x16\xA2\x43\xE3\x16\x7A\x00\x9B\x90\xF2\x8F\xB6\x45\xC1\x8E\x7B\x00\xA1\x90\xF8\x8F\x00\x37\xB3\x00\xC1\x8E\x7C\x00\xA6\x90\xFE\x8F\xE0\x19\xB5\x00\xC1\x8E\x7D\x00\xA6\x90\x04\x90\x0A\x07\xC1\x8E\x7E\x00\xA6\x90\x09\x90\xCF\x0F\xB9\x00\xC1\x8E\x7F\x00\xA6\x90\x0E\x90\xCF\x0F\xBB\x00\xC1\x8E\x80\x00\xA6\x90\x14\x90\x64\x16\xA9\x43\xEB\x27\xA6\x90\x19\x90\xEF\x17\xBF\x00\xC1\x8E\x82\x00\xA6\x90\x1E\x90\x3D\x17\xC1\x00\xC1\x8E\x83\x00\x1D\x8F\x61\x00\x08\x8B\x2E\x28\xC1\x8E\x84\x00\xDB\x29\xDE\x01\xD5\x90\x18\x87\xB8\x4B\xC1\x8E\x91\x00\xDA\x90\x54\x1C\x2F\x89\xB6\x22\xC1\x8E\x9E\x00\xC3\x8E\xEF\x76\x3C\x90\x10\x1F\xC1\x8E\xAC\x00\xE7\x90\x03\x01\xDC\x90\xED\x80\xCC\x21\xAF\x43", + "\xE3\x16\xBA\x00\xED\x90\x02\x01\xEF\x90\x34\x87\xCE\x57\xC1\x8E\xC8\x00\xF5\x90\xE9\x4F\x72\x89\xB3\x2E\xCF\x00\x66\x90\xE8\x90\x41\x84\x7D\x49\xC1\x8E\xD6\x00\xE1\x90\x52\x21\x52\x89\x21\x55\xC1\x8E\xE3\x00\xFC\x90\xB5\x10\x5A\x89\xA9\x18\xD4\x00\xC1\x8E\xF1\x00\x0D\x91\xF7\x90\x4A\x7F\x5E\x4D\xDA\x8E\x14\x91\x3E\x8E\xF8\x40\xC1\x8E\x0D\x00\xFA\x35\xBB\x01\x15\x91\x8D\x7D\xAC\x21\xB5\x43\x6C\x17\x1E\x91\xE2\x90\x6E\x7B\xF6\x24\xDC\x00\xC1\x8E\x29\x00\x25\x91\x08\x91\x48\x86\xAD\x32\xDE\x00\xC1\x8E\x37\x00\xFA\x35\xBD\x01\x20\x91\x20\x83\x8F\x71\x01\x8F\x2C\x91\x02\x91\x06\x82\x0F\x88\x54\x8F\xFA\x35\xDB\x90\x65\x8E\x75\x2C\x9E\x8F\x33\x91\x26\x91\x7F\x87\xEF\x17\xE6\x00\x16\x90\x39\x91\xEE\x90\xFC\x10\xB3\x64\x03\x0F\xBB\x43\x06\x7D\x49\x91\xF6\x90\xB3\x8F\x25\x41\xC1\x8E\x8C\x00\x43\x91\x2D\x91\x7E\x8E\xE0\x19\xEC\x00\xC1\x8E\x9B\x00\x50\x91\xFD\x90\x85\x8E\xB7\x30\xEE\x00\xC1\x8E\xA9\x00\x5D\x91\x0E\x91\xB7\x89\x48\x15\xF0\x00\xC1\x8E\xB7\x00\x56\x91\x3A\x91\x8B\x86\x1F\x34\xC1\x8E\xC6\x00\x6B\x91\x4A\x91", + "\xBA\x84\x0A\x12\xF4\x00\xC1\x8E\xD5\x00\x71\x91\x51\x91\x9E\x8E\xCF\x0F\xF6\x00\xC1\x8E\xE4\x00\x78\x91\x5E\x91\xDC\x83\xB1\x10\xF8\x00\xC1\x8E\xF3\x00\x64\x91\x35\x91\xF7\x67\xB8\x15\xFA\x00\xC1\x8E\x01\x00\x65\x36\x1F\x91\xFC\x10\xAD\x76\xAA\x15\xFC\x00\xC1\x8E\x0F\x00\x8D\x91\x44\x91\xDB\x84\xFF\x5C\xC1\x8E\x1D\x00\x95\x91\x57\x91\xBF\x8E\xF6\x24\x04\x0E\xD2\x16\x2B\x00\x9B\x91\x6C\x91\xDE\x1E\xEB\x1C\x32\x0B\xDA\x6B\x65\x36\xBD\x01\x34\x14\xCB\x12\xB3\x2E\xC8\x43\x11\x89\xED\x76\xFE\x90\xCD\x2A\x32\x0B\xCC\x35\x63\x00\xD6\x90\xCD\x55\xA6\x91\x8B\x10\x65\x36\xDE\x01\xB4\x91\xDD\x90\x48\x15\x08\x00\xB7\x91\x21\x25\xB9\x91\x8E\x20\xE3\x90\xD0\x1A\x0A\x00\xBF\x91\xC4\x12\xA2\x91\xDF\x43\xE9\x90\x33\x39\xC6\x91\x82\x18\xC8\x91\x45\x37\x16\x8E\xAA\x88\xCC\x91\x50\x4F\xCE\x91\x46\x5F\xFC\x10\x9E\x75\x3D\x17\x10\x00\xD2\x91\xDB\x39\xD4\x91\x0D\x58\x22\x8E\x33\x72\xDA\x91\xA4\x3F\xC1\x91\xAB\x91\x23\x86\xAA\x15\x14\x00\xE0\x91\xA7\x00\xDC\x91\xBB\x91\xAA\x7C\xAC\x21\x16\x00\xE0\x91\xB5\x00\xE9\x91\x62\x89\xA9\x18", + "\x18\x00\xE0\x91\xC3\x00\xF0\x91\x5E\x84\xB7\x30\x1A\x00\xE0\x91\xD1\x00\xF6\x91\xBB\x7C\x64\x3E\xE0\x91\xDF\x00\xFC\x91\xC0\x7C\x6D\x5D\xE0\x91\xED\x00\x01\x92\x81\x89\xEB\x8E\xE0\x91\xFB\x00\xA8\x91\xC2\x91\xCB\x7C\x7C\x3E\xE0\x91\x0A\x00\x9A\x36\xB0\x04\xEA\x91\xD2\x7C\x84\x3E\xE0\x91\x18\x00\x11\x92\xCF\x04\x13\x92\xDA\x7C\x8C\x3E\xE0\x91\x25\x00\x18\x92\xD1\x04\x1A\x92\x64\x86\x8E\x5D\xE0\x91\x34\x00\x1F\x92\x49\x05\x21\x92\xE8\x7C\xC5\x75\xE0\x91\x42\x00\x26\x92\xBB\x01\x28\x92\xB7\x7A\x4B\x06\xE0\x91\x50\x00\x26\x92\xBD\x01\x28\x92\xF7\x7C\x4D\x50\xE0\x91\x5F\x00\x2D\x92\x0C\x92\x2F\x82\xAD\x32\x30\x00\xE0\x91\x6D\x00\x3B\x92\xE3\x91\x36\x82\xA1\x1A\x32\x00\xE0\x91\x7B\x00\x34\x92\x3C\x92\x6D\x91\x79\x2E\x34\x00\xE0\x91\x8A\x00\x49\x92\x43\x92\x43\x82\xB1\x10\x36\x00\xE0\x91\x99\x00\x50\x92\x63\x1C\x93\x8D\xA9\x18\x38\x00\xE0\x91\xA8\x00\x57\x92\xC9\x91\xD3\x89\x78\x8D\xE0\x91\xB7\x00\x42\x92\x58\x92\xAC\x8E\x3D\x17\x3C\x00\xE0\x91\xC5\x00\x64\x92\x5F\x92\x5E\x82\xCA\x38\x3E\x00\xE0\x91\xD3\x00\x6B\x92", + "\xCF\x91\xB9\x8E\x98\x4D\xE0\x91\xE1\x00\x72\x92\xD5\x91\xEC\x89\x3C\x15\x42\x00\xE0\x91\xEF\x00\x78\x92\xDD\x91\xF3\x89\x00\x37\x44\x00\xE0\x91\xFD\x00\x5E\x92\xDB\x60\xFC\x10\x28\x92\x5C\x1D\xB2\x91\xA2\x2A\xB0\x91\xC1\x26\x8B\x92\xFE\x12\x65\x00\xFC\x10\x55\x1A\x7C\x5B\x32\x0B\xFD\x3A\x6B\x1A\xA3\x91\xF6\x24\x4D\x00\x8F\x92\x64\x16\x67\x00\xB7\x8A\xB3\x2E\x4E\x00\xE0\x91\x05\x11\x9D\x92\xBD\x8A\xFB\x1E\x50\x00\xA1\x92\xB6\x11\xB8\x8A\x09\x01\x78\x1A\xC5\x6C\xA7\x92\x46\x2C\xFC\x10\x6C\x00\xB3\x2E\x54\x00\x9B\x92\x23\x2C\xB7\x8C\xF5\x26\xE0\x91\x0C\x00\xB1\x26\x88\x13\xAB\x92\x3E\x8B\x8E\x60\xE0\x91\x0E\x00\xB1\x26\x18\x79\xB5\x92\xE1\x20\x59\x00\xE0\x91\x0F\x00\xB9\x92\x0C\x01\x6B\x00\xBD\x8C\x12\x2E\xE0\x91\x11\x00\xC0\x92\x28\x79\xFC\x10\x6D\x00\xB3\x2E\x5D\x00\xB3\x92\xEF\x17\xB0\x92\xBC\x8B\xA1\x1A\x5E\x00\xE0\x91\x12\x00\xCE\x92\x87\x2C\x79\x90\xCA\x38\x60\x00\xE0\x91\x13\x00\xC7\x92\xDD\x92\xD7\x92\xCC\x21\x62\x00\xE0\x91\x15\x00\xDC\x92\x8E\x2C\x52\x8F\xD6\x48\xE0\x91\x16\x00\xE3\x92\xEB\x92\x57\x8F", + "\xD5\x8C\x16\x92\xF0\x92\xDC\x12\x64\x8B\xF9\x1B\xE0\x91\x1A\x00\xF5\x92\xA8\x2C\x05\x8F\xFB\x1E\x6A\x00\xE0\x91\x1C\x00\xFB\x92\xB0\x2C\x0C\x8F\x33\x67\xE0\x91\x1E\x00\x02\x93\xB8\x2C\x12\x8F\xD7\x1D\xE0\x91\x20\x00\x08\x93\xD1\x92\x79\x1C\xA1\x1A\x70\x00\xE0\x91\x22\x00\x0E\x93\x85\x8B\xE3\x1D\xE0\x91\x24\x00\x15\x93\x8A\x8B\xE1\x20\x74\x00\xE0\x91\x26\x00\x1A\x93\x90\x8B\x25\x2A\xE0\x91\x28\x00\x20\x93\x96\x8B\xBB\x4B\xE0\x91\x2A\x00\x25\x93\x9C\x8B\xC4\x4B\xE0\x91\x2C\x00\x2A\x93\xA1\x8B\xB4\x1A\xE0\x91\x2E\x00\x2F\x93\xA6\x8B\xFB\x1E\x7E\x00\xE0\x91\x30\x00\x34\x93\xCF\x90\x86\x35\xE0\x91\x32\x00\x08\x93\x86\x1A\xDD\x77\x79\x2E\x82\x00\x24\x92\x3F\x93\xEC\x92\x16\x35\xE0\x91\x36\x00\x45\x93\xF2\x92\x17\x1C\xE0\x91\x38\x00\x4A\x93\x5C\x8F\x81\x6A\xE0\x91\x3A\x00\x4F\x93\x61\x8F\xB7\x30\x8A\x00\xE0\x91\x3C\x00\x54\x93\x66\x8F\xAD\x32\x8C\x00\xE0\x91\x3E\x00\x5A\x93\x6C\x8F\xFE\x3F\xE0\x91\x40\x00\x60\x93\x72\x8F\x55\x54\x2B\x92\x65\x93\x78\x8F\x7D\x19\x92\x00\xE0\x91\x44\x00\x65\x93\xAD\x90\x7D\x19\x94\x00", + "\xE0\x91\x46\x00\x65\x93\xB3\x90\x0C\x69\xE0\x91\x48\x00\x65\x93\xB8\x90\x03\x0F\x98\x00\xE0\x91\x4A\x00\x65\x93\xBE\x90\x03\x0F\x9A\x00\xE0\x91\x4C\x00\x65\x93\xC4\x90\x3D\x17\x9C\x00\xE0\x91\x4E\x00\x65\x93\xC9\x90\x5F\x41\x32\x92\x65\x93\x3B\x93\xE0\x19\xA0\x00\xE0\x91\x52\x00\x08\x93\x52\x14\xFA\x77\xB3\x2E\xA2\x00\x32\x0B\x5C\x90\x82\x18\xFC\x10\x40\x93\xFB\x1E\xA9\x00\xD4\x92\xE0\x19\x58\x14\xFB\x86\x6B\x33\xE0\x91\x54\x00\xEA\x92\xC9\x2E\xFC\x10\xC9\x92\xBE\x8A\xA2\x93\x7D\x19\x42\x14\x16\x2B\xB3\x2E\xAD\x00\xAE\x93\x58\x79\xFC\x10\xBB\x92\xE1\x20\xAE\x00\xAD\x92\x0B\x30\xFC\x10\x95\x1A\x89\x35\xB4\x93\x8F\x18\x49\x8A\x89\x8D\xBA\x93\xAA\x15\x4A\x8A\x0E\x75\x9D\x26\xB3\x00\xE0\x91\x55\x00\xA9\x93\x02\x01\x60\x14\x88\x30\xB3\x2E\xB5\x00\x32\x0B\x97\x60\xA9\x1A\xB1\x8A\xD8\x1E\xC3\x93\x8C\x32\x50\x8A\xB3\x2E\xBA\x00\xD6\x93\xB8\x15\x51\x8A\x31\x5F\xE9\x8A\xBF\x93\x0A\x12\x7B\x00\xDE\x92\xB1\x10\xBD\x00\xE0\x91\x56\x00\xCB\x93\x0E\x33\x5A\x89\xB3\x2E\x1E\x44\xAE\x91\x26\x33\x46\x93\xD0\x7A\xE0\x91\x57\x00", + "\xE8\x93\x16\x33\x86\x90\xB4\x40\xE0\x91\x58\x00\xF3\x93\xE2\x93\x8C\x90\xB7\x30\xC4\x00\xE0\x91\x59\x00\xF9\x93\xFD\x92\x9E\x4A\xE0\x91\x5A\x00\x00\x94\xD2\x4E\x85\x2A\xE0\x91\x5B\x00\x05\x94\x73\x1C\xD3\x2E\xE0\x91\x5C\x00\x0A\x94\x46\x17\x51\x71\xE0\x91\x5D\x00\x0F\x94\x20\x8F\x12\x55\xE0\x91\x5E\x00\x14\x94\x26\x8F\xF5\x77\x39\x92\x19\x94\xAE\x5E\xC8\x4A\xE0\x91\x60\x00\x1D\x94\x7B\x93\x63\x0B\xE0\x91\x61\x00\x1D\x94\x81\x93\x95\x78\xE0\x91\x62\x00\x1D\x94\x87\x93\xEF\x17\xD8\x00\xE0\x91\x63\x00\x1D\x94\x8D\x93\x7D\x19\xDA\x00\xE0\x91\x64\x00\x1D\x94\x91\x93\x7D\x19\x5C\x45\xDC\x27\xF3\x93\xB5\x1A\x41\x93\x2F\x91\xE0\x91\x66\x00\x3D\x94\xEF\x93\x8F\x71\xE0\x91\x67\x00\x43\x94\x4B\x93\x73\x48\xE0\x91\x68\x00\x48\x94\x50\x93\x04\x4B\xE0\x91\x69\x00\x4D\x94\x55\x93\x00\x37\xE6\x00\xE0\x91\x6A\x00\x52\x94\x5B\x93\xB7\x30\xE8\x00\xE0\x91\x6B\x00\x58\x94\x61\x93\x60\x7B\xE0\x91\x6C\x00\x5E\x94\x66\x93\xAD\x32\xEC\x00\x40\x92\x63\x94\x6A\x93\x05\x11\xEE\x00\xE0\x91\x6E\x00\x63\x94\x70\x93\x05\x11\xF0\x00\xE0\x91", + "\x6F\x00\x63\x94\x76\x93\xB8\x0D\xE0\x91\x70\x00\x63\x94\x23\x94\x95\x57\xE0\x91\x71\x00\x63\x94\x28\x94\x6B\x45\xE3\x16\x72\x00\x63\x94\x2D\x94\xE0\x19\xF8\x00\xE0\x91\x73\x00\x63\x94\x33\x94\x05\x11\xFA\x00\xE0\x91\x74\x00\x63\x94\x39\x94\x05\x11\xFC\x00\xE0\x91\x75\x00\xF3\x93\x7D\x00\xFC\x10\xC3\x1A\x52\x66\xE0\x93\x3C\x15\x96\x94\xAB\x8C\xF6\x24\xFF\x00\xE0\x91\x76\x00\x08\x93\x9C\x94\x24\x8A\x88\x23\xD2\x0B\x6C\x58\xB1\x26\xF6\x10\xA3\x94\x2C\x8A\xE4\x2C\xA6\x94\x4F\x10\xA8\x94\x34\x1E\x33\x8A\xB3\x2E\x05\x00\xAD\x94\x67\x10\xAF\x94\xEA\x36\x40\x91\x4D\x75\xB4\x94\x06\x01\x81\x00\xB6\x94\xEE\x33\x83\x8D\xD0\x1A\x09\x00\xBA\x94\x35\x4E\xBD\x94\x2E\x39\xC1\x93\xAD\x23\xC2\x94\x10\x33\xC4\x94\x5E\x10\xD8\x93\x78\x31\xC8\x94\x07\x13\xCA\x94\xF0\x23\x57\x8A\xB0\x2F\xCE\x94\xD4\x39\xD0\x94\x2E\x20\x5F\x8A\xF4\x8B\xD4\x94\x90\x00\xD6\x94\xAA\x94\x67\x8A\xD0\x1A\x13\x00\xD4\x94\x93\x00\xDC\x94\x6D\x8A\xCA\x88\xD4\x94\x96\x00\xE3\x94\x73\x8A\x5F\x39\xD4\x94\x99\x00\xE8\x94\x79\x8A\xA1\x32\xD4\x94\x9C\x00\xED\x94", + "\x7F\x8A\x36\x2D\xD4\x94\x9F\x00\xF2\x94\x84\x8A\x6B\x39\xD4\x94\xA2\x00\xF7\x94\x8A\x8A\x31\x7F\xD4\x94\xA5\x00\xFC\x94\x90\x8A\x4B\x2D\xD4\x94\xA8\x00\x01\x95\x18\x8B\x23\x3B\xD4\x94\xAB\x00\x01\x95\x9B\x8A\xE1\x20\x25\x00\xD4\x94\xAE\x00\x01\x95\xFC\x88\xFB\x1E\x27\x00\xD4\x94\xB1\x00\x95\x94\x24\x8B\x0F\x89\xD4\x94\xB2\x00\xD6\x94\xBC\x1A\xB8\x18\x2A\x60\xD2\x0B\xF8\x7B\xC2\x92\x1B\x79\xD4\x94\xB5\x00\x08\x93\x1D\x95\xA0\x2E\x23\x79\xD4\x94\xB7\x00\x1C\x95\x9E\x92\x32\x29\xD4\x94\xBA\x00\x2C\x95\xA4\x92\x7C\x39\xD4\x94\xBD\x00\x31\x95\xC3\x8A\x3D\x17\x34\x00\xD4\x94\xC0\x00\x36\x95\xC7\x8A\xC4\x3E\xD4\x94\xC3\x00\x3C\x95\xCD\x8A\xFB\x1E\x38\x00\xD4\x94\xC6\x00\x41\x95\xD2\x8A\x81\x69\xD4\x94\xC9\x00\x47\x95\xD7\x8A\x40\x3B\xD4\x94\xCC\x00\x4C\x95\xDC\x8A\x01\x45\xD4\x94\xCF\x00\x4C\x95\xE1\x8A\xF6\x24\x40\x00\xD4\x94\xD2\x00\x4C\x95\x6E\x8A\x10\x76\xD4\x94\xD5\x00\x4C\x95\x7E\x2F\x18\x76\xD4\x94\xD8\x00\x4C\x95\xDC\x8E\xE1\x20\x46\x00\xD4\x94\xDB\x00\x4C\x95\xFC\x8A\xFD\x8E\xD4\x94\xDE\x00\x4C\x95\x69\x90", + "\xA5\x7C\xD4\x94\xE1\x00\x4C\x95\x09\x8B\xAB\x7C\xD4\x94\xE4\x00\x4C\x95\xBE\x89\x00\x37\x4E\x00\xD4\x94\xE7\x00\x4C\x95\x07\x95\xBE\x6C\xD4\x94\xEA\x00\x4C\x95\x0C\x95\xAC\x21\x52\x00\xD4\x94\xED\x00\x4C\x95\x12\x95\xE1\x20\x54\x00\xD4\x94\xF0\x00\xF3\x93\x27\x95\x02\x01\x25\x8B\xAC\x21\x56\x00\xD4\x94\xF1\x00\xD6\x94\x71\x14\xC8\x35\xB3\x2E\x58\x00\x20\x95\x7F\x35\xFC\x10\x79\x00\xB3\x2E\x59\x00\xD2\x0B\x6C\x8C\xAA\x15\x64\x14\x49\x1F\xAF\x8F\x9F\x95\xFE\x12\xA8\x95\xBE\x94\xE9\x29\xAB\x95\x64\x16\x82\x00\xFC\x10\xFA\x93\xB1\x24\xB0\x95\x24\x7C\xEA\x93\xD0\x1A\x66\x00\xB6\x95\xEF\x17\xCA\x1A\x3F\x94\xB7\x30\x67\x00\xD4\x94\xF4\x00\xF3\x93\xBD\x95\x06\x01\x85\x00\xC8\x8F\xBB\x95\xE0\x19\xC4\x95\xE4\x49\xFE\x92\xD4\x94\xF5\x00\xC3\x95\xF5\x93\xAC\x21\x6C\x00\xD4\x94\xF6\x00\xCF\x95\xFB\x93\x00\x37\x6E\x00\xD4\x94\xF7\x00\xD5\x95\x91\x90\xCA\x38\x70\x00\xD4\x94\xF8\x00\xDB\x95\x96\x90\x9F\x3F\xD4\x94\xF9\x00\xE1\x95\x9C\x90\x03\x19\x74\x00\xD4\x94\xFA\x00\xE6\x95\xA2\x90\xCA\x38\x76\x00\xD4\x94\xFB\x00\xEC\x95", + "\xA7\x90\xCA\x38\x78\x00\xD4\x94\xFC\x00\xF2\x95\x6F\x94\xB6\x11\x7A\x00\xD4\x94\xFD\x00\xF2\x95\x75\x94\xE3\x34\xD4\x94\xFE\x00\xF2\x95\x7A\x94\x75\x14\xD4\x94\xFF\x00\xF2\x95\x7F\x94\xB8\x18\xD4\x94\xF8\x4D\xDA\x35\xFC\x10\x84\x94\x7D\x19\x82\x00\xD4\x94\x01\x00\xA6\x36\x0D\x96\x80\x17\x61\x65\xD4\x94\x02\x00\x14\x96\xE2\x35\xFC\x10\x90\x94\xB6\x11\x86\x00\xD4\x94\x03\x00\x1A\x96\x9B\x36\xE3\x93\xFE\x12\x88\x00\xD4\x94\x04\x00\x22\x96\x06\x01\x84\x00\x44\x94\xD9\x18\xD4\x94\x05\x00\x29\x96\x35\x4E\xD0\x95\xF6\x24\x8C\x00\xD4\x94\x06\x00\x30\x96\xC6\x18\xF7\x92\x3D\x1E\xD4\x94\x07\x00\x37\x96\x6A\x26\x01\x94\x09\x33\xD4\x94\x08\x00\x3D\x96\x00\x00\x2B\x96\x06\x94\x9A\x59\xD4\x94\x09\x00\x43\x96\x45\x96\x0B\x94\x0A\x22\xD4\x94\x0A\x00\x4A\x96\x19\x8F\x5B\x1E\xD4\x94\x0B\x00\x50\x96\x97\x32\xAD\x70\xD4\x94\x0C\x00\x55\x96\x86\x1C\xB6\x59\xD4\x94\x0D\x00\x5A\x96\xB9\x16\xD0\x1A\x9C\x00\xD4\x94\x0E\x00\x5F\x96\x41\x16\x78\x1E\xD4\x94\x0F\x00\x65\x96\xEA\x64\x45\x33\xD4\x94\x10\x00\x6A\x96\xEE\x1D\xD4\x59\xD4\x94", + "\x11\x00\x6F\x96\x8A\x94\x74\x4A\xD4\x94\x12\x00\x6F\x96\x1D\x96\x79\x44\xD4\x94\x13\x00\x43\x96\xC6\x95\xB6\x37\xB2\x8A\xC8\x95\x7D\x19\x7F\x96\x44\x8B\xA0\x93\xD4\x94\x14\x00\xA6\x36\x88\x13\x84\x96\x28\x95\x15\x28\xD4\x94\x16\x00\xA6\x36\xF6\x10\x8B\x96\xA9\x2E\xCF\x5E\xD4\x94\x19\x00\x90\x96\x6C\x11\xB1\x94\x51\x84\xD4\x94\x1C\x00\x97\x96\x09\x01\x92\x96\xA7\x52\x1C\x28\xD4\x94\x1F\x00\x9D\x96\xC5\x95\xBF\x94\xEA\x6A\xD4\x94\x22\x00\xA4\x96\x90\x58\xC6\x94\x59\x25\xD4\x94\x25\x00\xAA\x96\x89\x43\xCC\x94\x60\x25\xD4\x94\x28\x00\xB0\x96\x01\x01\x9F\x96\x4D\x95\x66\x42\xD4\x94\x2B\x00\xB6\x96\x00\x00\xB8\x96\x52\x95\x3E\x2C\xD4\x94\x2E\x00\xBD\x96\xB8\x96\x57\x95\x9D\x26\xBD\x00\xD4\x94\x31\x00\xC4\x96\xE4\x94\x22\x1B\xD4\x94\x34\x00\xCB\x96\xE9\x94\x29\x68\xD4\x94\x37\x00\xD0\x96\xEE\x94\xE1\x20\xC3\x00\xD4\x94\x3A\x00\xD5\x96\xF3\x94\x9D\x26\xC5\x00\xD4\x94\x3D\x00\xDB\x96\xF8\x94\x0A\x1F\xD4\x94\x40\x00\xE1\x96\xFD\x94\x02\x46\xD4\x94\x43\x00\xE6\x96\x02\x95\x8B\x30\xD4\x94\x46\x00\xEB\x96\x82\x95\xF6\x24", + "\xCD\x00\xD4\x94\x49\x00\xEB\x96\x87\x95\xF6\x24\xCF\x00\xD4\x94\x4C\x00\xEB\x96\x8D\x95\xDB\x22\xD4\x94\x4F\x00\x7E\x96\x18\x95\xD0\x1A\xD3\x00\xD4\x94\x50\x00\xBD\x96\x90\x14\x80\x11\x4E\x5F\x82\x96\x05\x11\x08\x97\x9B\x01\xFD\x2E\xD4\x94\x53\x00\x89\x96\x76\x1E\xFC\x10\xE0\x1A\xF8\x40\xD4\x94\x55\x00\x07\x97\x2D\x95\x6E\x48\xD4\x94\x58\x00\x19\x97\x32\x95\x05\x41\xD4\x94\x5B\x00\x1E\x97\x37\x95\xEF\x17\xDE\x00\xD4\x94\x5E\x00\x23\x97\x3D\x95\xFB\x1E\xE0\x00\xD4\x94\x61\x00\x29\x97\x42\x95\x6D\x2C\xD4\x94\x64\x00\x2F\x97\x48\x95\xE1\x20\xDE\x45\x3F\x82\x34\x97\xB9\x96\x3C\x78\xD4\x94\x6A\x00\x39\x97\xC0\x96\x9D\x26\xE8\x00\xD4\x94\x6D\x00\x39\x97\xC6\x96\xEF\x16\xEA\x00\xD4\x94\x70\x00\x39\x97\x5D\x95\xE1\x20\xEC\x00\xD4\x94\x73\x00\x39\x97\x62\x95\xF0\x25\xD4\x94\x76\x00\x39\x97\x67\x95\xAC\x21\xF0\x00\xD4\x94\x79\x00\x39\x97\x6D\x95\xB6\x0D\xD4\x94\x7C\x00\x39\x97\x72\x95\xAC\x21\xF4\x00\xD4\x94\x7F\x00\x39\x97\x77\x95\x35\x66\xD4\x94\x82\x00\x39\x97\x7C\x95\x8F\x7B\xD4\x94\x85\x00\x39\x97\xF1\x96\x9D\x26", + "\xFA\x00\xD4\x94\x88\x00\x39\x97\xF7\x96\x9D\x26\xFC\x00\xD4\x94\x8B\x00\x39\x97\xFD\x96\xF6\x24\xFE\x00\xD4\x94\x8E\x00\x43\x96\x0D\x97\x94\x95\xB3\x2E\x82\x4D\xF2\x27\xBD\x96\x95\x14\x09\x97\xD0\x1A\x02\x00\x23\x47\x05\x11\xD2\x1A\x41\x10\xB3\x2E\x03\x00\x08\x0E\xA6\x95\x48\x15\x7E\x14\x23\x96\x78\x31\x8D\x97\xB6\x11\x96\x97\xA5\x96\xAA\x88\x99\x97\x0A\x12\x8A\x00\xFC\x10\xCA\x95\xAC\x21\xF0\x45\xED\x93\x06\x01\xA0\x97\x9E\x96\xB6\x88\x9E\x97\xAC\x39\x24\x96\x64\x16\x11\x00\x08\x0E\x88\x13\x92\x00\x43\x96\x8B\x00\xFC\x10\xD9\x1A\xDF\x94\xAA\x97\xB2\x39\x2C\x96\xDB\x44\xAF\x97\x3B\x3C\xB2\x97\x32\x96\x9D\x26\x16\x00\xBB\x97\x37\x7E\xBD\x97\xD6\x95\xCA\x38\x18\x00\xC1\x97\x61\x2E\xC3\x97\xDC\x95\xB1\x10\x1A\x00\xC7\x97\x03\x01\x96\x00\xC9\x97\xE2\x95\xB1\x10\x1C\x00\xCD\x97\x02\x01\x97\x00\xD0\x97\xE7\x95\xA1\x1A\xF7\x45\xE3\x16\x98\x00\xD7\x97\xED\x95\xB1\x10\x20\x00\xD4\x97\x45\x3F\xDD\x97\xF3\x95\xB1\x10\x22\x00\xE1\x97\xA4\x3F\xE3\x97\xF9\x95\x0A\x12\x24\x00\xE7\x97\x9B\x00\xE3\x97\xFF\x95\x01\x01\x26\x00", + "\xE7\x97\x9C\x00\xE3\x97\x04\x96\x03\x01\x28\x00\xE7\x97\x9D\x00\xE3\x97\x09\x96\xF1\x1C\xE7\x97\x9E\x00\xE3\x97\x0F\x96\x05\x11\x2C\x00\xE7\x97\x9F\x00\xE3\x97\x75\x96\x0A\x12\x2E\x00\xE7\x97\xA0\x00\xE3\x97\x7A\x96\x3C\x15\x30\x00\xE7\x97\xA1\x00\x43\x96\x8C\x00\xAC\x97\x29\x89\xE7\x97\xA2\x00\x12\x98\xB9\x97\xA1\x1A\x34\x00\xE7\x97\xA3\x00\x18\x98\x49\x94\xA1\x1A\x36\x00\xE7\x97\xA4\x00\x1E\x98\x4E\x94\x3F\x89\xE7\x97\xA5\x00\x24\x98\x53\x94\x1D\x86\xE7\x97\xA6\x00\x29\x98\x59\x94\x8E\x4D\xE7\x97\xA7\x00\x2E\x98\x5F\x94\xE2\x3E\xE7\x97\xA8\x00\x33\x98\x64\x94\x31\x86\xE7\x97\xA9\x00\x38\x98\x69\x94\xD8\x49\xE7\x97\xAA\x00\x38\x98\xEA\x97\x6E\x5B\xE7\x97\xAB\x00\x38\x98\xF0\x97\x74\x21\xE7\x97\xAC\x00\x38\x98\xF6\x97\xBD\x5D\xE7\x97\xAD\x00\x38\x98\xFC\x97\x7F\x22\xE7\x97\xAE\x00\x38\x98\x01\x98\x30\x16\xE7\x97\xAF\x00\x38\x98\x07\x98\x3C\x15\x4E\x00\xE7\x97\xB0\x00\x38\x98\x0D\x98\xAA\x15\x50\x00\xE7\x97\xB1\x00\x43\x96\xB5\x97\xA6\x25\xB3\x2E\x52\x00\xB7\x97\x48\x15\x68\x98\x0E\x97\xA8\x53\xE7\x97\xB2\x00", + "\x12\x97\xFC\x39\x14\x97\xB3\x2E\x55\x00\xE7\x97\xB4\x00\xBD\x96\x6E\x98\x93\x96\xFB\x1E\x57\x00\xE7\x97\xB7\x00\x7A\x98\x99\x96\x14\x73\xE7\x97\xBA\x00\x81\x98\x78\x87\xEF\x17\x5B\x00\xE7\x97\xBD\x00\x86\x98\x5A\x5B\xD2\x92\xE7\x97\xC0\x00\x8C\x98\x46\x31\xA9\x8F\xE7\x97\xC3\x00\x91\x98\x02\x01\xDD\x93\xE2\x3C\xE7\x97\xC6\x00\x96\x98\xC1\x34\xAF\x8F\xE7\x97\xC9\x00\x9C\x98\xAC\x45\x5E\x83\xE7\x97\xCC\x00\xA1\x98\x45\x97\x03\x19\x1A\x46\xE3\x16\xCF\x00\xA1\x98\x4B\x97\xD0\x2B\xE7\x97\xD2\x00\xA1\x98\x51\x97\xD7\x2B\xE7\x97\xD5\x00\xA1\x98\x56\x97\xF6\x24\x6D\x00\xE7\x97\xD8\x00\xA1\x98\x5C\x97\x8B\x2E\xE7\x97\xDB\x00\xA1\x98\x61\x97\xF6\x24\x71\x00\xE7\x97\xDE\x00\xA1\x98\x67\x97\xF2\x2B\xE7\x97\xE1\x00\xA1\x98\x6C\x97\xB1\x10\x21\x46\xE3\x16\xE4\x00\xA1\x98\x71\x97\xEF\x16\x77\x00\xE7\x97\xE7\x00\xA1\x98\x77\x97\xCA\x24\xE7\x97\xEA\x00\xA1\x98\x7D\x97\x0D\x57\xE7\x97\xED\x00\x67\x98\x02\x97\xFB\x1E\x7D\x00\xE7\x97\xEE\x00\xBD\x96\xAB\x14\x69\x98\x8E\x27\x6C\x98\x26\x1C\x22\x95\xF6\x24\x80\x00\xE7\x97\xF1\x00", + "\x73\x98\xC6\x20\x75\x98\x15\x1E\xE7\x97\xF3\x00\xE8\x98\x1A\x97\xD4\x21\xE7\x97\xF6\x00\xF9\x98\x1F\x97\xF6\x24\x86\x00\xE7\x97\xF9\x00\xFE\x98\x24\x97\x62\x44\xE7\x97\xFC\x00\x04\x99\x2A\x97\xF0\x3F\xE7\x97\xFF\x00\x09\x99\x30\x97\xF0\x21\xE7\x97\x02\x00\xB7\x37\xF6\x10\xE9\x98\x48\x10\x3E\x90\xE7\x97\x05\x00\x13\x99\x6E\x24\xD2\x94\xFB\x21\xE7\x97\x08\x00\x1A\x99\xC5\x10\xD8\x94\x4D\x1E\xE7\x97\x0B\x00\x20\x99\xF4\x98\x54\x08\xB3\x2E\x94\x00\xE7\x97\x0E\x00\x26\x99\xBC\x33\xCC\x96\xFB\x1E\x96\x00\xE7\x97\x11\x00\x2D\x99\x3F\x29\xFC\x10\xB2\x98\x6B\x54\xE7\x97\x14\x00\x34\x99\xA0\x14\xD7\x8E\xB6\x59\xE7\x97\x17\x00\x3B\x99\xAA\x14\x8B\x8E\xA5\x65\xE7\x97\x1A\x00\x41\x99\x15\x99\xE2\x96\x66\x61\xE7\x97\x1D\x00\x47\x99\x08\x8B\xBC\x6D\xE7\x97\x20\x00\x4D\x99\xE9\x8B\x05\x11\xA2\x00\xE7\x97\x23\x00\x52\x99\x57\x0C\xB3\x2E\xA4\x00\xE7\x97\x26\x00\x58\x99\x67\x01\x93\x54\xE7\x97\x29\x00\x5E\x99\xB0\x01\xB2\x8A\xE7\x97\x2C\x00\xB7\x37\x2E\x0F\x48\x99\x01\x01\x95\x95\x61\x40\xE7\x97\x2D\x00\x41\x99\xB0\x14\xEA\x98", + "\x67\x40\xEC\x98\xEF\x18\xA1\x95\xB2\x93\x93\x97\x11\x7E\xFC\x10\x13\x98\xD0\x1A\xB7\x00\x74\x99\x03\x0F\x99\x14\x74\x98\xD8\x1E\x7E\x99\x3E\x2F\x54\x3C\xB3\x2E\x40\x48\xA5\x97\x87\x3C\xFC\x10\xA7\x97\xA1\x33\x83\x99\x85\x99\xCE\x36\xB3\x2E\x4C\x48\x88\x99\x8E\x3C\xB4\x97\xE9\x8A\x8D\x99\x21\x4C\xFC\x10\x20\x1F\x74\x25\x0C\x99\xB6\x11\x99\x99\x61\x2E\xEB\x93\x08\x0E\x97\x60\xE7\x1A\x9D\x94\x02\x64\xE7\x97\x30\x00\x68\x99\x5D\x3C\xFC\x10\x9D\x00\xBB\x2E\x9B\x99\xC6\x46\xEE\x98\x0F\x52\xE7\x97\x31\x00\xA7\x99\xB4\x14\xA9\x99\x11\x8B\x96\x99\x8D\x3F\xFC\x10\x98\x00\xB3\x2E\x63\x49\xF0\x5A\xD3\x01\xFC\x10\x9A\x00\xFF\x90\xAC\x99\x3C\x15\xEE\x1A\x33\x01\xB3\x2E\xD1\x00\xB6\x99\x02\x01\xAA\x99\x39\x03\xF0\x2E\xC7\x99\x01\x01\x9E\x00\xAE\x99\x91\x17\xE7\x97\x32\x00\xB2\x99\x06\x01\xCE\x99\x09\x01\x0C\x1B\xE5\x57\xC1\x99\xAA\x15\xC7\x14\xA3\x99\x54\x2C\xE7\x97\x33\x00\xD3\x99\xC6\x14\xFC\x10\xD7\x99\xFB\x1E\x16\x4A\x92\x99\x49\x11\xFC\x10\xFE\x1A\xC5\x5C\xCC\x99\x9A\x43\xFC\x10\xA4\x00\xB3\x2E\x21\x4A\xBE\x95\xFD\x1A", + "\x98\x99\xB3\x2E\x2D\x4A\xF3\x5E\xE0\x99\x02\x01\x28\x1F\x50\x11\xB3\x2E\x39\x4A\xE6\x99\xA0\x3E\xED\x99\x1E\x2F\xD9\x99\x48\x15\xEE\x99\x5A\x03\x24\x2F\x08\x0E\x39\x44\x0A\x12\xA5\x00\xFF\x99\x3C\x23\x01\x9A\xB8\x15\xA6\x00\xF3\x99\x95\x1F\xE7\x97\x35\x00\xF7\x99\x01\x01\x0E\x9A\xF3\x04\xB3\x2E\xEF\x00\xEB\x99\xE3\x99\x41\x43\xB3\x2E\xF0\x00\xEB\x99\xA8\x00\x1C\x99\xA4\x1F\x0C\x9A\xCF\x0F\x1F\x9A\xCF\x06\x5C\x2F\x22\x9A\x03\x0F\x58\x8A\x82\x06\x62\x2F\xEB\x99\xAB\x00\xCF\x99\x9A\x55\xE7\x97\x36\x00\xB7\x37\x88\x13\x2D\x9A\x60\x7E\x60\x88\xE7\x97\x38\x00\x13\x9A\x00\x00\xD5\x14\x39\x06\xB3\x2E\xA1\x4A\xFD\x99\x3B\x9A\x85\x96\x6B\x28\xE7\x97\x39\x00\x32\x9A\x04\x05\xB4\x99\xD0\x1A\xFD\x00\xE7\x97\x3B\x00\x39\x9A\x13\x1B\x3C\x9A\x81\x23\xEB\x99\x4D\x9A\x41\x9A\xAC\x21\xC7\x06\xE3\x16\x3C\x00\x45\x9A\xDD\x14\x35\x9A\x8B\x97\x4C\x0C\x88\x13\x3E\x00\x39\x9A\xAE\x00\xFC\x10\xA9\x00\xAC\x91\x4C\x0C\x9C\x93\xFF\x44\xFC\x10\x34\x9A\xFF\x2C\x4C\x0C\xCC\x35\x3F\x97\xB5\x00\xE4\x8B\x69\x9A\x41\x46\x2E\x9A\xA1\x1A\x0D\x00", + "\x5B\x9A\x3E\x26\x57\x9A\xD9\x06\xE2\x99\xB0\x2F\x73\x9A\xA6\x20\x39\x9A\xE3\x14\x09\x01\xB4\x00\xF4\x8B\x6E\x9A\xFE\x12\x7C\x9A\x52\x9A\xF6\x24\x12\x00\x79\x9A\xF6\x8D\x75\x9A\x03\x01\x82\x9A\x03\x01\x1A\x9A\x4F\x62\x86\x9A\x39\x6F\x39\x9A\x19\x1B\x7D\x9A\xB3\x2E\xAF\x4A\xFD\x99\x91\x9A\x83\x9A\x9D\x26\x17\x00\x8E\x9A\x2A\x15\x88\x9A\x02\x01\x96\x9A\x8B\x9A\xB3\x2E\x19\x00\x9A\x9A\x01\x01\x47\x00\x39\x9A\x7E\x9A\xA1\x44\xD8\x8E\x63\x9A\xE3\x46\xFC\x10\x2F\x1F\xD0\x1A\x22\x00\x80\x9A\x60\x47\x70\x9A\xCC\x21\x23\x00\xA2\x9A\x1E\x8F\x39\x9A\xB6\x00\xFC\x10\xBC\x00\xFE\x88\xB4\x9A\x05\x11\xF7\x14\x97\x9A\x70\x72\xB4\x9A\x49\x00\x39\x9A\xBD\x9A\x49\x07\x0F\x89\xAF\x9A\x3D\x17\x1E\x1B\xF1\x99\xCA\x38\x2A\x00\xB4\x9A\x4A\x00\x39\x9A\xC8\x9A\xE5\x77\x24\x29\xB4\x9A\x4B\x00\xCE\x9A\xBE\x97\xEF\x16\x2E\x00\xB4\x9A\x4C\x00\xD4\x9A\xC4\x97\xB1\x10\x30\x00\xB4\x9A\x4D\x00\xDA\x9A\xCA\x97\xFE\x12\xBD\x4A\xB5\x52\xE0\x9A\xD1\x97\x68\x34\xB4\x9A\x4F\x00\xE5\x9A\xD8\x97\xC7\x62\xB4\x9A\x50\x00\xEA\x9A\xDE\x97\xFE\x12\x38\x00", + "\xB4\x9A\x51\x00\xEF\x9A\xE4\x97\xFE\x12\x3A\x00\xB4\x9A\x52\x00\xF5\x9A\x43\x98\xAA\x15\x3C\x00\xB4\x9A\x53\x00\xF5\x9A\x48\x98\x3E\x00\xB4\x9A\x54\x00\xF5\x9A\x4D\x98\x0C\x21\xB4\x9A\x55\x00\xF5\x9A\x52\x98\xDD\x6E\xB4\x9A\x56\x00\xF5\x9A\x57\x98\x90\x7C\xB4\x9A\x57\x00\xF5\x9A\x5C\x98\xAA\x15\x46\x00\xB4\x9A\x58\x00\xF5\x9A\x62\x98\x48\x15\x48\x00\xB4\x9A\x59\x00\x39\x9A\xBA\x00\xFC\x10\xB7\x00\xB3\x2E\x4A\x00\x4C\x0C\xC1\x48\xFC\x10\x22\x9B\xB3\x4D\xC6\x9A\xEF\x17\xB9\x9A\x18\x07\xB3\x2E\x50\x00\x2C\x9B\xE0\x19\xBD\x00\xFC\x10\xA7\x98\xA1\x1A\x51\x00\xBB\x9A\xB6\x11\xC6\x96\xC3\x00\xB3\x2E\x53\x00\x32\x9B\xC4\x49\xFC\x10\xC2\x00\xB1\x92\x3F\x9B\x05\x11\xC0\x00\xB1\x9A\x79\x2E\x55\x00\xB4\x9A\x5A\x00\x9C\x9A\xAB\x2E\xB8\x9A\xA6\x8C\xB4\x9A\x5C\x00\x39\x9A\x01\x15\x7E\x08\xA3\x95\x44\x9B\xB6\x11\x53\x9B\xBE\x9A\xA1\x79\xB4\x9A\x5D\x00\x4C\x9B\x00\x00\x58\x9B\xC4\x9A\xB8\x8C\xB4\x9A\x5F\x00\x39\x9A\x42\x9B\x40\x08\xB3\x2E\x5E\x00\x4C\x0C\x6A\x49\x3C\x9B\x68\x08\xB3\x2E\x62\x00\x56\x9B\xAC\x4B\x36\x99\xAF\x8F", + "\x39\x9B\x70\x9B\xEB\x1F\x5E\x83\x73\x9B\xB2\x4B\x17\x8B\xB3\x2E\x67\x00\x77\x9B\xAA\x15\xC6\x00\xFC\x10\x47\x1F\xFB\x1E\xD9\x4A\xC9\x9A\xBA\x12\x7F\x9B\xB3\x2E\x6B\x00\x7C\x9B\x79\x83\x14\x98\xEF\x17\x6D\x00\xB4\x9A\x60\x00\x39\x9A\xC8\x00\x19\x98\xCC\x21\x6F\x00\xB4\x9A\x61\x00\x8F\x9B\xD5\x9A\x03\x19\x71\x00\xB4\x9A\x62\x00\x96\x9B\xDB\x9A\xCC\x2F\xB4\x9A\x63\x00\x9C\x9B\xE1\x9A\x64\x16\x75\x00\xB4\x9A\x64\x00\xA1\x9B\xE6\x9A\x46\x32\xB4\x9A\x65\x00\xA7\x9B\xEB\x9A\x79\x2E\x79\x00\xB4\x9A\x66\x00\xAC\x9B\xF0\x9A\x64\x16\x7B\x00\xB4\x9A\x67\x00\xB2\x9B\xF6\x9A\x00\x34\xB4\x9A\x68\x00\xB8\x9B\xFC\x9A\x8E\x34\xB4\x9A\x69\x00\xB8\x9B\x48\x98\x81\x00\xB4\x9A\x6A\x00\xB8\x9B\x07\x9B\x10\x36\xB4\x9A\x6B\x00\xB8\x9B\x0C\x9B\xBE\x96\xB4\x9A\x6C\x00\xB8\x9B\x11\x9B\x3C\x15\x87\x00\xB4\x9A\x6D\x00\xB8\x9B\x16\x9B\x95\x97\xB4\x9A\x6E\x00\xB8\x9B\x1C\x9B\xB8\x15\x8B\x00\xB4\x9A\x6F\x00\x39\x9A\x09\x15\x18\x12\x38\x90\x6F\x9B\x3C\x15\xE3\x9B\x67\x0B\x3E\x90\xE6\x9B\xAA\x15\xE8\x9B\x61\x12\x68\x8A\xEB\x9B\x48\x15\xED\x9B", + "\xF5\x0B\x48\x90\xF0\x9B\xB8\x15\xF2\x9B\x15\x0C\x4E\x90\xF5\x9B\xCF\x0F\xCA\x00\xB5\x91\xFB\x1E\x92\x00\xB4\x9A\x70\x00\xB7\x37\xDE\x01\xFC\x9B\xBC\x91\x20\x87\xB4\x9A\x7D\x00\x02\x9C\x81\x0A\xC3\x91\x30\x99\xB4\x9A\x8A\x00\xB7\x37\xBB\x01\x04\x9C\x27\x87\x2F\x4C\xB4\x9A\x98\x00\x0F\x9C\x0A\x9C\x2D\x87\x00\x37\x9A\x00\xB4\x9A\xA6\x00\x16\x9C\xE4\x9B\x1C\x8E\x26\x11\xB4\x9A\xB4\x00\x1D\x9C\x7E\x0A\xDE\x91\x3E\x33\xB4\x9A\xC2\x00\x09\x9C\x1E\x9C\x28\x8E\xF6\x24\xA0\x00\xB4\x9A\xCF\x00\x23\x9C\x7B\x0A\x0F\x91\x86\x1E\xB4\x9A\xDD\x00\x30\x9C\x6C\x0A\xF1\x91\x8D\x1E\xB4\x9A\xEB\x00\x36\x9C\x71\x0A\x1A\x91\xA2\x51\xB4\x9A\xF9\x00\x3C\x9C\x78\x0A\x72\x89\xA9\x18\xA8\x00\xB4\x9A\x07\x00\xA3\x38\x10\x9C\x7A\x89\x51\x1C\xB4\x9A\x15\x00\x49\x9C\x17\x9C\xB3\x61\xEB\x37\xB4\x9A\x23\x00\xA3\x38\xBD\x01\x11\x9C\x7C\x7B\xEA\x6D\xB4\x9A\x32\x00\x4F\x9C\x2A\x9C\x14\x92\xF6\x24\xFA\x4A\xE3\x16\x40\x00\xA3\x38\x03\x9C\xB8\x94\xAC\x21\xB2\x00\xDE\x9A\x55\x9C\x50\x9C\x9A\x89\xF6\x7D\x50\x9B\x5C\x9C\x24\x9C\x72\x8E\xCA\x38\xB6\x00", + "\xC5\x9B\x6E\x9C\x31\x9C\x5A\x80\xFE\x12\xB8\x00\xB4\x9A\x78\x00\x69\x9C\x5D\x9C\x78\x86\x3B\x49\xB4\x9A\x87\x00\x74\x9C\x37\x9C\x5F\x91\x00\x37\xBC\x00\xB4\x9A\x95\x00\x81\x9C\x3D\x9C\x66\x91\xB8\x15\xBE\x00\xB4\x9A\xA3\x00\x7B\x9C\x6F\x9C\xB4\x84\xBE\x49\xB4\x9A\xB2\x00\x8F\x9C\x75\x9C\x98\x8E\x52\x4A\xB4\x9A\xC1\x00\x95\x9C\x82\x9C\xCC\x89\x84\x4B\xB4\x9A\xD0\x00\x9B\x9C\x89\x9C\x81\x91\xFE\x12\xC6\x00\xB4\x9A\xDF\x00\x88\x9C\x43\x9C\x66\x92\xEF\x17\xC8\x00\xB4\x9A\xED\x00\xA8\x9C\x57\x9C\x0B\x32\x19\x8B\xB4\x9A\xFB\x00\xAF\x9C\xFC\x10\x92\x81\x48\x15\x07\x4B\xE3\x16\x09\x00\x5C\x39\x31\x05\xB0\x9C\x22\x6D\x3F\x47\xB4\x9A\x17\x00\xBC\x9C\x52\x05\xBE\x9C\x72\x82\x19\x55\xB4\x9A\x25\x00\xC3\x9C\x53\x05\x30\x1B\xE9\x9B\xC8\x4A\xFA\x9B\x03\x0F\xCC\x9C\xEE\x9B\x03\x97\xCF\x9C\xAF\x24\xD6\x91\xF7\x2E\xD4\x9C\x09\x01\xD1\x9C\x11\x0C\x4E\x5F\xD8\x9C\xC2\x2A\xFC\x10\x29\x1B\x77\x38\x4C\x0C\xA7\x01\x05\x11\x3F\x1F\x4F\x13\x2C\x88\xE2\x9C\xCF\x3B\xDF\x9C\x3D\x9A\xE8\x9C\xC1\x1C\xEA\x9C\x33\x39\xEA\x0B\xE3\x9C\xCA\x4C", + "\xFC\x10\x37\x1B\x56\x4D\xEA\x0B\xCC\x35\xD1\x00\xFC\x10\xD0\x00\x00\x60\xF6\x9C\xED\x8D\xFC\x10\xF8\x9C\x22\x50\xFC\x9C\xB1\x35\xFC\x10\xD2\x00\xB3\x2E\x21\x00\x01\x9D\x64\x16\xD4\x00\xFC\x10\xD3\x00\xF3\x8E\x07\x9D\xFE\x4C\xFC\x10\xCE\x00\xF7\x88\x0D\x9D\x5E\x4D\xFC\x10\x3E\x1B\x37\x69\x12\x9D\xE0\x19\xD7\x00\xFC\x10\xD6\x00\xFE\x88\x17\x9D\x10\x62\xFC\x10\xE5\x9C\xFB\x1E\x26\x00\x1D\x9D\x05\x11\xD9\x00\xFC\x10\xD8\x00\xB3\x2E\x27\x00\x23\x9D\x9F\x17\xFC\x10\xCC\x00\x0A\x89\x2A\x9D\x0A\x12\x80\x9B\x5F\x0A\x0F\x89\x2F\x9D\x44\x4F\x85\x9B\x95\x82\xEA\x0B\xDC\x53\x71\x97\xC7\x00\xB3\x2E\x2C\x00\x34\x9D\x26\x78\xFC\x10\x7E\x9B\xD0\x1A\x2D\x00\x3E\x9D\x48\x15\xDF\x00\xE3\x98\xE1\x20\x2E\x00\x38\x9D\xB1\x10\x6C\x99\x00\x00\xE8\x00\xB3\x2E\x30\x00\x44\x9D\xB8\x15\xE2\x00\x8A\x9B\xE0\x19\x31\x4B\xF3\x5E\xCA\x9C\xCB\x51\x91\x9B\x79\x2E\x33\x00\x4A\x9D\x61\x06\x58\x9D\x90\x0C\x97\x9B\x95\x2D\x5D\x9D\xB9\x0E\x5F\x9D\xE2\x51\x39\x96\x1E\x2B\x63\x9D\xE3\x0B\x65\x9D\xF1\x51\x3F\x96\xF6\x24\x39\x00\x69\x9D\x02\x01\x38\x00", + "\x6B\x9D\xF9\x51\x04\x93\x29\x44\x70\x9D\x44\x14\x73\x9D\x14\x52\x0A\x93\x1A\x32\x77\x9D\x16\x2F\x79\x9D\x22\x52\x51\x96\x21\x32\x7D\x9D\x3B\x00\x7F\x9D\x29\x52\x16\x93\x65\x24\x7D\x9D\x3C\x00\x85\x9D\x53\x9D\x1B\x93\xAC\x21\x43\x00\x7D\x9D\x3D\x00\x8B\x9D\x2C\x8F\x55\x2B\x7D\x9D\x3E\x00\x92\x9D\x31\x8F\xB7\x30\x47\x00\x7D\x9D\x3F\x00\x97\x9D\x36\x8F\x03\x19\x49\x00\x7D\x9D\x40\x00\x9D\x9D\x3B\x8F\xB7\x30\x4B\x00\x7D\x9D\x41\x00\xA3\x9D\x40\x8F\x9D\x26\x4D\x00\x7D\x9D\x42\x00\xA9\x9D\x46\x8F\xD1\x6F\x7D\x9D\x43\x00\x85\x9D\xE3\x00\x54\x9D\xE1\x23\x7D\x9D\x44\x00\xB4\x9D\x5A\x9D\xB7\x50\x7D\x9D\x45\x00\xBA\x9D\x1F\x98\xBC\x4D\x7D\x9D\x46\x00\xBF\x9D\x25\x98\x79\x2E\x57\x00\x7D\x9D\x47\x00\xC4\x9D\x2A\x98\x96\x8F\x7D\x9D\x48\x00\xCA\x9D\x2F\x98\x22\x45\x7D\x9D\x49\x00\xCF\x9D\x34\x98\x03\x19\x46\x4B\xE3\x16\x4A\x00\xD4\x9D\x39\x98\x00\x37\x5F\x00\x7D\x9D\x4B\x00\xDA\x9D\x3E\x98\x0A\x12\x61\x00\x7D\x9D\x4C\x00\xDA\x9D\xBE\x9B\xB8\x15\x63\x00\x7D\x9D\x4D\x00\xDA\x9D\x48\x98\x65\x00\x7D\x9D\x4E\x00\xDA\x9D\xC8\x9B", + "\x67\x00\x7D\x9D\x4F\x00\xDA\x9D\xCD\x9B\x69\x00\x7D\x9D\x50\x00\xDA\x9D\xD2\x9B\xAA\x15\x4D\x4B\xE3\x16\x51\x00\xDA\x9D\xD8\x9B\x93\x2C\x7D\x9D\x52\x00\xDA\x9D\xDD\x9B\xBD\x24\x7D\x9D\x53\x00\x85\x9D\xE4\x00\xFC\x10\xE0\x00\xB3\x2E\x71\x00\xEA\x0B\xFD\x3A\xE5\x00\xFC\x10\x0C\x9E\x71\x41\x51\x9D\xCF\x0F\x16\x15\x9A\x0C\xB3\x2E\x77\x00\x17\x9E\x03\x0F\x4F\x1B\xEB\x11\xB3\x2E\x78\x00\x1D\x9E\xA5\x0C\xFC\x10\x8C\x9D\xFB\x1E\x54\x4B\xFD\x99\x4E\x1F\xD4\x93\xFB\x1E\x7A\x00\x7D\x9D\x54\x00\x85\x9D\x2A\x9E\x32\x2B\xB3\x2E\x7C\x00\x7D\x9D\x55\x00\x30\x9E\x82\x98\xBD\x21\x7D\x9D\x56\x00\x37\x9E\x87\x98\x97\x35\x7D\x9D\x57\x00\x3C\x9E\x8D\x98\x15\x1E\x7D\x9D\x58\x00\x41\x9E\x92\x98\x61\x65\x7D\x9D\x59\x00\x46\x9E\x97\x98\xB3\x2E\x86\x00\x7D\x9D\x5A\x00\x4B\x9E\x9D\x98\xE3\x39\x7D\x9D\x5B\x00\x51\x9E\xA2\x98\xE9\x21\x7D\x9D\x5C\x00\x56\x9E\x36\x9B\x50\x4E\x7D\x9D\x5D\x00\x56\x9E\xAD\x98\xFE\x3F\x7D\x9D\x5E\x00\x56\x9E\x37\x99\x90\x6D\x7D\x9D\x5F\x00\x56\x9E\xB7\x98\x9D\x26\x92\x00\x7D\x9D\x60\x00\x56\x9E\xBD\x98\x02\x01", + "\x94\x00\x7D\x9D\x61\x00\x56\x9E\xC2\x98\x65\x54\x7D\x9D\x62\x00\x56\x9E\xC8\x98\x5B\x35\x7D\x9D\x63\x00\x56\x9E\xCD\x98\xB2\x70\x7D\x9D\x64\x00\x56\x9E\xD3\x98\x5E\x7A\x7D\x9D\x65\x00\x56\x9E\xD9\x98\xAA\x3B\x7D\x9D\x66\x00\x56\x9E\x4C\x9D\xCD\x59\x7D\x9D\x67\x00\x85\x9D\xEB\x00\xFC\x10\xEA\x00\x99\x93\x23\x9E\xF2\x54\x96\x9E\xB3\x2E\xA3\x00\x99\x9E\xBF\x0C\x9B\x9E\x8D\x1E\x9E\x9E\xE2\x55\xA0\x9E\xD0\x67\xA2\x9E\x02\x01\x13\x11\xAE\x0C\x93\x54\xA6\x9E\x84\x56\xA4\x9E\x55\x3A\xAB\x9E\xF9\x0C\xAD\x9E\xAC\x21\xA8\x00\xAF\x9E\xF2\x00\xB1\x9E\x99\x45\xAF\x9E\x5D\x1B\xA9\x9E\xD0\x1A\xAA\x00\xAF\x9E\x2A\x11\xBA\x9E\x15\x28\xAF\x9E\x3F\x11\xBF\x9E\xEC\x70\xAF\x9E\xF6\x00\xB6\x9E\x9D\x26\xAD\x00\xAF\x9E\x55\x1F\x03\x01\x97\x9E\xB4\x1E\xAF\x9E\xF8\x00\x47\x9B\xAD\x32\xAF\x00\x7D\x9D\x68\x00\x85\x9D\xD0\x9E\x2B\x9E\x1C\x28\x7D\x9D\x69\x00\xCA\x9C\x88\x13\xD7\x9E\x32\x9E\x3D\x74\x7D\x9D\x6B\x00\xDC\x9E\x4C\x0E\x38\x9E\xAC\x21\xB5\x00\x7D\x9D\x6D\x00\xE3\x9E\x4A\x0E\x65\x9C\xCA\x45\x7D\x9D\x6F\x00\xEA\x9E\x64\x31\xA6\x96", + "\x66\x42\x7D\x9D\x71\x00\xF0\x9E\x58\x88\xAC\x96\xE1\x20\xBB\x00\x7D\x9D\x73\x00\xF6\x9E\x32\x59\xB2\x96\xE1\x20\xBD\x00\x7D\x9D\x75\x00\xFD\x9E\x73\x57\x20\x9A\xE1\x20\xBF\x00\x7D\x9D\x77\x00\x04\x9F\x00\x00\xDE\x9E\x5C\x19\xB3\x2E\xC1\x00\x7D\x9D\x79\x00\x0B\x9F\x0D\x9F\xDE\x94\xFB\x1E\xC3\x00\x7D\x9D\x7B\x00\x13\x9F\x2F\x99\x91\x25\x7D\x9D\x7D\x00\x1A\x9F\xD1\x96\xFB\x45\x7D\x9D\x7F\x00\x1F\x9F\xD6\x96\x83\x30\x7D\x9D\x81\x00\x24\x9F\xDC\x96\x17\x1F\x7D\x9D\x83\x00\x29\x9F\x49\x99\xA9\x42\x7D\x9D\x85\x00\x2E\x9F\xE7\x96\xD2\x22\x7D\x9D\x87\x00\x33\x9F\xEC\x96\x1E\x46\x7D\x9D\x89\x00\x38\x9F\x86\x9E\xA1\x1A\xD3\x00\x7D\x9D\x8B\x00\x38\x9F\x8B\x9E\xEA\x22\x7D\x9D\x8D\x00\x38\x9F\x90\x9E\x00\x8E\x7D\x9D\x8F\x00\x0B\x9F\x1B\x15\xDC\x99\x42\x52\x7D\x9D\x91\x00\x85\x9D\x4E\x9F\xA4\x94\x52\x1F\x7D\x9D\x92\x00\x4D\x9F\xFA\x98\x5C\x6E\x7D\x9D\x94\x00\x59\x9F\xFF\x98\x9D\x26\xDF\x00\x7D\x9D\x96\x00\x5E\x9F\x05\x99\x7D\x19\xE1\x00\x7D\x9D\x98\x00\x64\x9F\x0A\x99\x1E\x23\x7D\x9D\x9A\x00\x6A\x9F\x0F\x99\xFB\x42\x7D\x9D", + "\x9C\x00\x6F\x9F\x35\x97\x50\x28\x7D\x9D\x9E\x00\x74\x9F\x3A\x97\x80\x6E\x7D\x9D\xA0\x00\x79\x9F\x3F\x97\xEF\x16\xEB\x00\x7D\x9D\xA2\x00\x79\x9F\x5C\x9E\x15\x43\x7D\x9D\xA4\x00\x79\x9F\x61\x9E\x0B\x31\x7D\x9D\xA6\x00\x79\x9F\x66\x9E\xF4\x35\x7D\x9D\xA8\x00\x79\x9F\x6B\x9E\xFC\x35\x7D\x9D\xAA\x00\x79\x9F\x71\x9E\x01\x01\xF5\x00\x7D\x9D\xAC\x00\x79\x9F\x77\x9E\x53\x58\x7D\x9D\xAE\x00\x79\x9F\x7C\x9E\xEF\x16\xF9\x00\x7D\x9D\xB0\x00\x79\x9F\x81\x9E\x56\x59\x7D\x9D\xB2\x00\x79\x9F\x3E\x9F\xBE\x6E\x7D\x9D\xB4\x00\x79\x9F\x44\x9F\xCC\x21\xFF\x00\x7D\x9D\xB6\x00\x79\x9F\x49\x9F\xA1\x1A\x01\x00\x1C\x20\x88\x13\xB8\x00\x0B\x9F\xFB\x00\xFC\x10\xF9\x00\x91\x97\xBD\x9F\xB1\x10\xFC\x00\xFC\x10\xFE\x00\xB2\x94\xC5\x9F\x74\x47\x04\x11\xB3\x2E\x07\x00\xCB\x9F\x64\x16\xC9\x9F\xBA\x5C\xD9\x8B\xD0\x9F\x56\x17\xFC\x10\x6C\x1B\xAD\x23\x1C\x20\x97\x60\x04\x5D\x01\x01\xD2\x9F\xB6\x28\xD5\x9F\x02\x01\xBA\x00\x85\x9D\xDC\x9F\x6C\x10\xB6\x88\xE0\x9F\x01\x01\xBB\x00\x85\x9D\x02\x00\xE8\x1B\x6E\x15\x3D\x17\x12\x00\x1C\x20\x6A\x49\xEB\x9F", + "\x9A\x28\x93\x9A\xE7\x9F\x00\x00\xBC\x00\xEA\x9F\x25\x15\xB3\x2E\x18\x00\xF5\x9F\xBD\x00\x85\x9D\x03\x00\xEC\x9F\x11\x50\xF0\x9F\xF6\x15\xEC\x10\xDE\x9F\xE1\x20\x1E\x00\xF5\x9F\xBE\x00\xFE\x9F\xF9\x9F\x22\x50\xF5\x9F\xBF\x00\x85\x9D\x04\x00\x71\x1B\xED\x9F\x04\x67\xF5\x9F\x8D\x15\x04\xA0\xB3\x2E\x24\x00\xF5\x9F\xC0\x00\x0B\x9F\x5C\x1F\xD1\x0E\x04\x89\xF5\x9F\xC2\x00\x0B\x9F\x3A\x15\xBB\x13\x12\xA0\x2A\x67\x1C\x20\xCC\x5D\xEC\x10\x0A\x00\x24\xA0\x7D\x19\x29\x00\x26\xA0\xD1\x5D\x16\xA0\x95\x82\xF5\x9F\xC4\x00\x0B\x9F\x08\x00\x0B\xA0\xFB\x1E\x2C\x00\xF5\x9F\xC6\x00\x0B\x9F\x78\x1B\x23\xA0\x23\x79\x2D\xA0\xD7\x5D\x28\xA0\x2A\xA0\x05\x11\x2F\x00\x3E\xA0\xDC\x5D\x92\x1B\x41\xA0\xB6\x11\x30\x00\x02\xA0\xF6\x17\xEC\x10\x11\x00\x47\xA0\x0A\x12\x34\x00\x14\xA0\xD9\x17\xEC\x10\x16\x00\x4E\xA0\x3C\x15\x36\x00\x51\xA0\x0A\x12\x0D\x00\xEC\x10\x0C\x00\x55\xA0\xAA\x15\x38\x00\x1C\x20\x64\x9A\xDD\x01\x5B\xA0\xB3\x2E\x3F\x00\xF5\x9F\xC8\x00\x0B\x9F\x5A\xA0\xD8\x9E\x77\x53\xF5\x9F\xCA\x00\xCA\x9C\xF6\x10\x69\xA0\xDF\x9E\x6A\x24", + "\xF5\x9F\xCD\x00\x6E\xA0\x23\x01\xEC\x10\x34\x8A\x70\x24\xF5\x9F\xD0\x00\x75\xA0\x3D\x01\xEC\x10\x3B\x8A\xCA\x38\x47\x00\xF5\x9F\xD3\x00\x7C\xA0\x57\x01\xEC\x10\x87\x8D\xF6\x24\x15\x4C\x9C\x33\x84\xA0\x9D\x01\xEC\x10\xC5\x93\x6D\x8F\xF5\x9F\xD9\x00\x8B\xA0\xB8\x01\xEC\x10\x98\x98\x99\x92\xF5\x9F\xDC\x00\x92\xA0\x62\xA0\x8A\x41\xB3\x2E\x4F\x00\xF5\x9F\xDF\x00\x99\xA0\x0E\x02\xEC\x10\x7F\x9F\x03\x19\x51\x00\xF5\x9F\xE2\x00\xA0\xA0\x70\xA0\x50\x08\x3D\x9B\xF5\x9F\xE5\x00\xA8\xA0\xEC\x10\x8A\x9F\x5E\x3B\xF5\x9F\xE8\x00\xAE\xA0\x20\x9F\xAC\x21\x1C\x4C\xE3\x16\xEB\x00\xB4\xA0\x25\x9F\xF6\x24\x59\x00\xF5\x9F\xEE\x00\xBA\xA0\x2A\x9F\x03\x19\x5B\x00\xF5\x9F\xF1\x00\xC0\xA0\x2F\x9F\xD5\x50\xF5\x9F\xF4\x00\xC6\xA0\x34\x9F\xAC\x21\x5F\x00\xF5\x9F\xF7\x00\xCB\xA0\x39\x9F\xE2\x3C\xF5\x9F\xFA\x00\xD1\xA0\xAF\x9F\x79\x2E\x63\x00\xF5\x9F\xFD\x00\xD1\xA0\x1C\xA0\xB1\x24\xF5\x9F\x00\x00\x80\x39\x7E\x18\xEC\x10\xB4\x9F\x79\x2E\x67\x00\xF5\x9F\x01\x00\x80\x39\x6F\xA0\xEC\x10\xBA\x9F\xCC\x21\x69\x00\xF5\x9F\x04\x00\xE9\xA0\x58\x15", + "\x55\x01\x5D\xA0\x57\x2C\x60\xA0\x8E\x5F\x63\xA0\xE3\x1D\xF5\x9F\x07\x00\x80\x39\x88\x13\x0E\x00\xEC\x10\x15\x97\x3C\x6A\xF5\x9F\x09\x00\xF1\xA0\x25\x01\xEC\x10\xA9\x92\x49\x32\xF5\x9F\x0C\x00\x04\xA1\x3F\x01\x77\xA0\x21\x9E\xF5\x9F\x0F\x00\x0B\xA1\x59\x01\x7E\xA0\x17\x8A\xF5\x9F\x12\x00\x11\xA1\x9F\x01\x86\xA0\x33\x9E\xF5\x9F\x15\x00\x17\xA1\xBA\x01\x8D\xA0\xB3\x2E\x7E\x00\xF5\x9F\x18\x00\x1D\xA1\x04\x01\x94\xA0\x1F\x8D\xF5\x9F\x1B\x00\x24\xA1\xFE\xA0\x9B\xA0\x15\x1E\xF5\x9F\x1E\x00\x2A\xA1\xA2\xA0\xB3\x2E\x84\x00\xF5\x9F\x21\x00\x30\xA1\x28\x99\x68\x65\xF5\x9F\x24\x00\x36\xA1\xFD\x27\xB3\x2E\x88\x00\xF5\x9F\x27\x00\x3B\xA1\xAB\x4F\x25\x90\xF5\x9F\x2A\x00\x41\xA1\x02\x01\x94\x9F\x03\x19\x8C\x00\xF5\x9F\x2D\x00\x46\xA1\xDD\x72\x01\x33\xF5\x9F\x30\x00\x4D\xA1\xE5\x5D\x48\x90\xF5\x9F\x33\x00\x52\xA1\xA4\x9F\xD5\x73\xF5\x9F\x36\x00\x52\xA1\xAA\x9F\x3D\x17\x94\x00\xF5\x9F\x39\x00\x52\xA1\xD7\xA0\xAD\x32\x96\x00\xF5\x9F\x3C\x00\x52\xA1\xDD\xA0\x7D\x63\xF5\x9F\x3F\x00\xE1\xA0\xF2\xA0\x5F\x99\xB6\x59\xF5\x9F\x40\x00", + "\x52\xA1\xEC\xA0\xF5\x73\xF5\x9F\x43\x00\x24\xA1\x46\x15\x3B\x01\xF4\xA0\xB8\x15\x3F\x4C\xD4\x46\x7D\x1B\x4F\x9F\xA1\x1A\xA5\x00\xF5\x9F\x46\x00\xFC\xA0\x85\x01\xFF\xA0\x6A\x8D\xF5\x9F\x48\x00\x78\xA1\x06\xA1\xB3\x2E\xA9\x00\xF5\x9F\x4B\x00\x8B\xA1\x5F\x9F\xEF\x16\xAB\x00\xF5\x9F\x4E\x00\x91\xA1\x65\x9F\x05\x11\xAD\x00\xF5\x9F\x51\x00\x97\xA1\x6B\x9F\x3E\x42\xF5\x9F\x54\x00\x9D\xA1\x70\x9F\x45\x42\xF5\x9F\x57\x00\xA2\xA1\x75\x9F\x4C\x42\xF5\x9F\x5A\x00\xA7\xA1\x7A\x9F\xC3\x45\xF5\x9F\x5D\x00\xAC\xA1\xA3\xA0\x84\x57\xF5\x9F\x60\x00\xAC\xA1\x85\x9F\xAD\x32\xB9\x00\xF5\x9F\x63\x00\xAC\xA1\xB0\xA0\x03\x19\x4D\x4C\x23\x4C\xAC\xA1\x8F\x9F\x9A\x3A\xF5\x9F\x69\x00\xAC\xA1\x48\xA1\x22\x68\xF5\x9F\x6C\x00\xAC\xA1\x99\x9F\x5E\x9B\xF5\x9F\x6F\x00\xAC\xA1\x9F\x9F\x03\x19\xC3\x00\xF5\x9F\x72\x00\xAC\xA1\x58\xA1\xA1\x1A\xC5\x00\xF5\x9F\x75\x00\xAC\xA1\x5D\xA1\xEF\x17\xC7\x00\xF5\x9F\x78\x00\xAC\xA1\x63\xA1\xA8\x84\xF5\x9F\x7B\x00\xAC\xA1\xE4\xA0\xAD\x32\xCB\x00\xF5\x9F\x7E\x00\xAC\xA1\x74\xA1\xAD\x32\xCD\x00\xF5\x9F\x81\x00", + "\x24\xA1\x10\x00\xEC\x10\xA9\xA0\xAC\x21\xCF\x00\x44\xA0\x3D\x17\x4D\xA0\x29\x01\x7B\xA1\xCF\x0F\xD0\x00\xF9\xA1\xEF\x17\x12\x00\x5B\xA0\xFD\xA1\x03\x0F\xD1\x00\xF6\xA0\xBB\x19\xF8\xA0\x03\x2F\xF5\x9F\x84\x00\x85\xA1\x2D\x01\x87\xA1\xC5\x5C\xF5\x9F\x86\x00\x24\xA1\x02\xA2\x52\x2B\x11\x2F\xF5\x9F\x89\x00\x13\xA2\x0D\xA1\x5B\x7E\xF5\x9F\x8C\x00\x19\xA2\x3D\x9E\x7D\x19\xE0\x00\xF5\x9F\x8F\x00\x1E\xA2\x42\x9E\xA5\x38\xF5\x9F\x92\x00\x24\xA2\x47\x9E\x75\x2C\xF5\x9F\x95\x00\x29\xA2\x4C\x9E\x20\x88\xF5\x9F\x98\x00\x2E\xA2\x52\x9E\x83\x2C\xF5\x9F\x9B\x00\x33\xA2\x57\x9E\x7A\x7E\xF5\x9F\x9E\x00\x38\xA2\xB7\xA1\xCB\x81\xF5\x9F\xA1\x00\x38\xA2\xBD\xA1\xA1\x1A\xEE\x00\xF5\x9F\xA4\x00\x38\xA2\xC2\xA1\xC1\x5A\xF5\x9F\xA7\x00\x38\xA2\xC7\xA1\x1F\x34\xF5\x9F\xAA\x00\x38\xA2\xCC\xA1\xF4\x00\xF5\x9F\xAD\x00\x38\xA2\xD1\xA1\x24\x34\xF5\x9F\xB0\x00\x38\xA2\xD7\xA1\x43\x4B\xF5\x9F\xB3\x00\x38\xA2\xDD\xA1\xA4\x49\xF5\x9F\xB6\x00\x38\xA2\xE3\xA1\x00\x37\xFC\x00\xF5\x9F\xB9\x00\x38\xA2\x69\xA1\x07\x82\xF5\x9F\xBC\x00\x6D\xA1\x0E\xA2", + "\xA8\x2F\xD0\x1A\x16\x2F\x57\x48\x38\xA2\xEE\xA1\xB7\x30\x02\x00\x95\x12\xC0\x00\x24\xA1\x13\x00\x03\xA2\x91\x28\xE4\x0F\x61\xA0\xA8\x01\x09\xA2\xD3\x2A\x95\x12\xC3\x00\x0D\xA2\x6D\x15\x6A\xA0\xF6\x24\x0D\x00\x95\x12\xC5\x00\x7D\xA2\x8C\xA1\x0D\x20\x95\x12\xC8\x00\x8F\xA2\x92\xA1\x9F\x43\x95\x12\xCB\x00\x94\xA2\x98\xA1\xC1\x19\x95\x12\xCE\x00\x99\xA2\x9E\xA1\x9D\x26\x15\x00\x95\x12\xD1\x00\x9E\xA2\xA3\xA1\x12\x6F\x95\x12\xD4\x00\xA4\xA2\xA8\xA1\xE9\x55\x95\x12\xD7\x00\xA9\xA2\xAD\xA1\xEF\x16\x1B\x00\x95\x12\xDA\x00\xAE\xA2\xB2\xA1\xCC\x21\x1D\x00\x95\x12\xDD\x00\xAE\xA2\x3E\xA2\x8D\x58\x95\x12\xE0\x00\xAE\xA2\x43\xA2\x23\x8C\x95\x12\xE3\x00\xAE\xA2\x49\xA2\xB2\x9A\x95\x12\xE6\x00\xAE\xA2\x4E\xA2\x79\x2E\x25\x00\x95\x12\xE9\x00\xAE\xA2\xCC\xA1\x27\x00\x95\x12\xEC\x00\xAE\xA2\x58\xA2\x2D\x53\x95\x12\xEF\x00\xAE\xA2\x5D\xA2\x79\x2E\x2B\x00\x95\x12\xF2\x00\xAE\xA2\x62\xA2\x7D\x19\x2D\x00\x95\x12\xF5\x00\xAE\xA2\x67\xA2\xCA\x38\x83\x4C\xE3\x16\xF8\x00\xAE\xA2\x6D\xA2\xF6\x24\x31\x00\x95\x12\xFB\x00\x71\xA2\x89\xA2", + "\x1F\x8B\x7F\x26\x95\x12\xFC\x00\xAE\xA2\x78\xA2\x00\x37\x35\x00\x95\x12\xFF\x00\x24\xA1\x64\x1F\xF3\xA0\x40\x24\x81\xA2\x9D\x60\x84\xA2\x01\x45\x95\x12\x02\x00\xDC\x39\xE9\x54\x65\x01\x0F\xA2\x87\x39\x95\x12\x04\x00\x07\xA3\xE4\x9F\xAA\x01\x90\xA2\x10\x76\x95\x12\x07\x00\x0E\xA3\xF6\x10\xFE\xA2\x30\x2F\xB3\x2E\x44\x00\x95\x12\x0A\x00\x15\xA3\x13\x01\x13\xA1\x3D\x44\x95\x12\x0D\x00\x1D\xA3\x31\x01\x19\xA1\x7C\x5B\x95\x12\x10\x00\x23\xA3\x4B\x01\x1F\xA1\x0B\x3F\x95\x12\x13\x00\x29\xA3\x09\xA3\xA3\x18\xB3\x2E\x4C\x00\xE9\x12\x2F\xA3\x7A\x01\xEC\x10\x29\x9A\xE1\x20\x4E\x00\x95\x12\x19\x00\x35\xA3\x8F\x01\x31\xA1\xA2\x29\x95\x12\x1C\x00\x3D\xA3\x10\xA3\x37\xA1\x1E\x63\x95\x12\x1F\x00\x43\xA3\x17\xA3\xDE\x1E\xB1\x92\x95\x12\x22\x00\x49\xA3\xEC\x10\xC5\xA2\xD3\x6C\x95\x12\x25\x00\x4F\xA3\x09\x01\xCA\xA2\xB3\x5B\x95\x12\x28\x00\x55\xA3\x44\x92\x0D\x4A\x95\x12\x2B\x00\x5B\xA3\xD9\x52\xB3\x2E\x5C\x00\x95\x12\x2E\x00\x60\xA3\x47\x43\x67\x9B\x95\x12\x31\x00\x66\xA3\x6C\x50\xAB\x24\x95\x12\x34\x00\x6B\xA3\x54\x0C\x6D\x9B", + "\x95\x12\x37\x00\x70\xA3\xE8\xA1\xB7\x30\x64\x00\x95\x12\x3A\x00\x70\xA3\xF8\xA2\xCA\x38\x66\x00\x95\x12\x3D\x00\x43\xA3\x15\x00\xEC\x10\x14\xA2\xFB\x1E\xE0\x4D\xFD\x99\x54\xA0\xD1\x01\x04\xA2\x2B\x2B\x43\x10\x05\x11\x17\x00\x73\x5B\xD4\x0F\xBF\x15\xE1\x0F\x92\xA3\x93\xA3\x94\xA3\x95\xA3\x96\xA3\x97\xA3\x98\xA3\x99\xA3\x9A\xA3\x9B\xA3\x9C\xA3\x9D\xA3\x9E\xA3\x9F\xA3\xA0\xA3\xA1\xA3\xBE\x0F\xAD\x0F\xE9\x15\xA4\xA3\x7A\x5B\xF5\x71\xE2\x54\xD8\x0E\x88\x13\x9C\x88\xE3\x16\x0F\xA3\x0F\xA3\xE6\x1C\x41\x11\x0D\x16\x46\x57\x8A\x4D\xAE\xA3\x73\x5B\xB6\xA3\xB1\xA3\x2D\x11\xD7\x11\xB5\xA3\xB8\xA3\xB3\xA3\xB2\xA3\x4E\x57\xBA\xA3\x65\x17\x00\x00\xC6\x17\xC1\xA3\xC4\xA3\x03\x0F\xC5\xA3\x39\x15\xC6\xA3\xC9\xA3\xC8\xA3\xCB\xA3\x7E\xA1\xCC\xA3\x44\x17\xCA\xA3\xCD\xA3\xD1\xA3\xCF\xA3\xCE\xA3\x6F\x17\xD4\xA3\xE2\x64\xD2\xA3\xD5\xA3\xD8\xA3\xD7\xA3\xD3\xA3\xDA\xA3\xB6\x63\xD9\xA3\xDC\xA3\xE0\xA3\xDF\xA3\xE2\xA3\xDB\xA3\xE3\xA3\xDE\xA3\xE4\xA3\xE7\xA3\xE6\xA3\xE9\xA3\xC2\xA3\xD0\xA3\xE1\xA3\xE8\xA3\xEB\xA3\xD6\xA3\xEA\xA3\xC7\xA3", + "\xDD\xA3\xEF\xA3\xF3\xA3\xF2\xA3\xED\xA3\xF1\xA3\xEC\xA3\xE5\xA3\xF4\xA3\xF7\xA3\xFB\xA3\xFA\xA3\xF6\xA3\xFE\xA3\xF9\xA3\xEE\xA3\xFF\xA3\x02\xA4\x01\xA4\xF8\xA3\xF0\xA3\xFD\xA3\x04\xA4\x07\xA4\x03\xA4\x06\xA4\xF5\xA3\x05\xA4\x08\xA4\x0C\xA4\xFC\xA3\x0B\xA4\x0F\xA4\x13\xA4\x12\xA4\x15\xA4\x0E\xA4\x16\xA4\x0A\xA4\x17\xA4\x1A\xA4\x19\xA4\x1C\xA4\x0D\xA4\x1D\xA4\x11\xA4\x1B\xA4\x1E\xA4\x22\xA4\x20\xA4\x1F\xA4\x00\xA4\x25\xA4\x09\xA4\xC3\x49\x39\x6A\xE9\x10\xC2\x17\x2A\xA4\x12\x6B\xA5\x13\x03\x0F\x2C\xA4\x31\xA4\x30\xA4\x33\xA4\x2F\xA4\x35\xA4\x29\xA4\x07\x02\xCD\x08\xFF\x00\x38\xA4\x3B\xA4\x03\x0F\x38\xA4\x09\x02\x16\x06\xFF\x00\x3F\xA4\x42\xA4\x03\x0F\x43\xA4\x9A\x02\x16\x06\x47\xA4\x45\xA4\xC8\x03\x4C\x17\x0B\x02\xF4\x05\x4D\xA4\x4C\xA4\x4F\xA4\xD1\x17\x51\xA4\x50\x03\x4E\xA4\x52\xA4\x4A\xA4\x0D\x02\xD8\x18\x57\xA4\x59\xA4\x03\x0F\x5A\xA4\x9C\x02\xF5\x05\xF6\x05\xF6\x05\xFF\x00\xDE\x01\x5F\xA4\x62\xA4\x64\xA4\x03\x0F\x65\xA4\x52\x03\x63\xA4\x66\xA4\x6A\xA4\x68\xA4\x67\xA4\xCA\x03\x69\xA4\x68\xA4\xBB\x01\x49\x05", + "\x28\x36\x12\x89\x74\xA4\x8C\x03\x53\x05\x53\x05\xFF\x00\xBD\x01\x77\xA4\x7A\xA4\x7A\xA4\xBF\x01\xD5\x0F\x7E\xA4\x80\xA4\x03\x0F\x7E\xA4\xA5\x01\x34\x05\xFF\x00\x84\xA4\x87\xA4\x03\x0F\x84\xA4\xA7\x01\x35\x05\x35\x05\xFF\x00\x8B\xA4\x8F\xA4\x03\x0F\x90\xA4\x9D\x03\x36\x05\xEE\x1D\xA9\x01\x94\xA4\x96\xA4\xAB\x01\xB4\x16\x99\xA4\x03\x02\x06\x47\x9C\xA4\x9E\xA4\x03\x0F\x9C\xA4\x76\x15\x8B\x15\xA2\xA4\x8A\x15\xA5\xA4\x5E\x1C\x68\x13\x74\x19\x9A\x18\xD1\x0E\xA5\x05\x35\x93\x9D\x2F\xDF\x28\xC8\x0E\xCE\x1A\xCC\x62\xAF\xA4\x8E\x62\xB3\xA4\xF2\x1A\xB5\xA4\xAE\xA4\xB4\xA4\xB9\xA4\xB6\xA4\xBA\xA4\x5A\x63\x34\x8B\xC8\x0E\x6D\x31\x0E\x64\xBE\xA4\xDD\x0F\xC2\xA4\x53\x63\xC4\xA4\xBD\xA4\xC3\xA4\xC8\xA4\xC5\xA4\xC9\xA4\xC7\xA4\xCA\xA4\xCD\xA4\xCC\xA4\xCF\xA4\x7A\x63\xC6\xA4\x03\x01\xE5\x18\x5F\x4B\xD1\x0E\xD4\xA4\xD7\xA4\x1B\x1B\x20\x1B\x8D\x9D\xD6\x1D\xDA\xA4\x5B\x96\xDB\xA4\x5F\x94\x03\x36\xD1\x0E\x41\x19\xE1\xA4\x79\x8B\xF8\x8E\x4B\x93\x60\x1B\x77\x8B\x29\x7F\xEA\xA4\xE9\x53\xF6\x46\xEB\xA4\xF2\x92\xE9\xA4\xEC\xA4\xF0\xA4", + "\xEF\xA4\x7C\x19\x02\x17\xC8\x0E\xF4\xA4\xCA\x1B\xB9\x55\xC8\x0E\xF8\xA4\xFB\xA4\x03\x0F\xFC\xA4\x46\x13\xFD\xA4\x00\xA5\xFF\xA4\x32\x66\x03\x0F\x1F\x37\x6C\x10\x05\xA5\x66\x66\x04\xA5\x09\xA5\x03\xA5\x0B\xA5\xC8\x13\x0A\xA5\x0D\xA5\x0C\xA5\x49\x66\x0E\xA5\x11\xA5\x10\xA5\x18\x66\x12\xA5\x15\xA5\x14\xA5\x58\x12\xEA\x1B\xD1\x0E\xFD\x1B\xEF\x5A\x39\x18\x1A\xA5\x58\x20\x1F\xA5\xCD\x13\x21\xA5\xE3\x1B\x23\xA5\x19\xA5\x1E\xA5\x27\xA5\x20\xA5\x28\xA5\x22\xA5\x2A\xA5\x24\xA5\x2C\xA5\x26\xA5\x29\xA5\x30\xA5\x2B\xA5\x31\xA5\x2D\xA5\x33\xA5\x2F\xA5\x32\xA5\x37\xA5\x34\xA5\x38\xA5\x36\xA5\x39\xA5\x3C\xA5\x3B\xA5\x3E\xA5\x01\x01\x1C\xA5\x1C\xA5\x30\x1C\x08\x5D\xC8\x0E\x43\xA5\x46\xA5\x3B\x1C\x48\xA5\x0C\x01\x47\xA5\x41\x1C\x4C\xA5\xD8\x0E\x54\x1D\x01\x01\x4F\xA5\x00\x00\x51\xA5\x53\xA5\x03\x0F\x54\xA5\x4D\xA5\x57\x18\x03\x0F\xF7\x38\x6C\x10\x5A\xA5\x00\x00\x5C\xA5\x5E\xA5\x59\xA5\x03\x0F\xB9\x1C\x00\x00\xB9\x1C\xFF\x00\x62\xA5\x66\xA5\x61\xA5\x68\xA5\xE6\x13\x69\xA5\x63\x8D\x03\x0F\x5B\x1D\x08\x1D\x42\x62\x6D\xA5\x71\xA5", + "\xBA\x64\xF3\x17\x74\xA5\xD1\x0E\x27\x1D\x89\x13\x75\xA5\x3A\x1D\x03\x0F\xD3\x17\x61\x1B\xC8\x0E\x7C\xA5\x7C\xA5\x10\x0B\x28\x1D\xE0\x0E\x81\xA5\x84\xA5\x03\x0F\x85\xA5\x3E\x1A\x82\xA5\x3B\x16\x88\xA5\x87\xA5\x46\x1B\x8D\xA5\x06\x01\x8C\xA5\x8F\xA5\x86\xA5\x92\xA5\x8B\xA5\x93\xA5\x8E\xA5\x88\x06\x03\x0F\x79\x16\x5D\x0C\xA9\x7B\x98\xA5\x9C\xA5\x03\x1D\x97\xA5\x9E\xA5\xA6\x0B\x03\x0F\xF3\x0E\xFE\x0A\x09\x1D\x80\x1B\xD0\x0A\xA2\xA5\xA8\xA5\xA6\xA5\xAE\x32\x03\x0F\x91\x1D\xDE\x0D\xAB\xA5\x5A\x69\xAC\xA5\xB1\xA5\xB0\xA5\xB3\xA5\x63\x69\xB2\xA5\xB5\xA5\xB4\xA5\x20\x0E\xEE\x0F\xC8\x0E\xA2\x0E\xDF\x0D\xAF\x18\x2E\x49\xD8\x0E\x15\x0F\xC1\xA5\x03\x0F\xC2\xA5\xBE\xA5\x02\x0E\x33\x8D\xC8\x0E\xC6\xA5\xC9\xA5\x03\x0F\xCA\xA5\xB0\x0E\xCD\xA5\xDD\x1F\xCE\xA5\x56\x0F\xD0\xA5\x59\x0F\x69\x0F\xD1\x0E\x45\x0B\x9F\x91\x9B\x0F\x03\x0F\xEE\x0E\x34\x0E\x86\x97\x7D\x0C\xDD\xA5\xD8\xA5\xDE\xA5\xB9\x0E\xD9\xA5\xE2\xA5\xE0\xA5\x03\x01\xDB\xA5\xE6\xA5\xE3\xA5\xDF\xA5\xE9\xA5\xE1\xA5\xE4\xA5\xDC\x1F\xEA\xA5\xE5\xA5\xE8\xA5\xEB\xA5\xEE\xA5", + "\xED\xA5\xF1\xA5\xB0\x5D\x8D\x4B\xC8\x0E\xFB\x0E\x78\x10\x75\xA2\xD1\x0E\xF9\xA5\xFC\xA5\xD5\x62\xFE\xA5\x93\x1F\x03\x0F\xE4\x1F\xE1\x14\x19\x13\x01\xA6\x05\xA6\x00\xA6\x07\xA6\x63\x23\x06\xA6\xF4\x20\xA0\x47\xC8\x0E\x12\x21\x54\x14\x0C\xA6\x0C\x01\x0E\xA6\x12\xA6\x10\xA6\x0B\xA6\x11\xA6\x14\xA6\x06\x01\x13\xA6\x3C\x6D\x18\x16\xC8\x0E\xC7\x23\x4F\x21\x1B\xA6\x1A\xA6\x20\xA6\xFB\x6D\x03\x0F\xF0\x54\x6C\x10\x24\xA6\xC2\x2E\x23\xA6\x28\xA6\x0C\x01\x26\xA6\x74\x23\x43\x6E\xC8\x0E\x2C\xA6\x2F\xA6\x03\x0F\x30\xA6\x63\x4C\x2D\xA6\x33\xA6\x32\xA6\x23\x42\x34\xA6\x37\xA6\x36\xA6\xD6\x52\x38\xA6\x3B\xA6\x3A\xA6\x76\x56\x3C\xA6\x3F\xA6\x3E\xA6\x35\x8E\x33\x1A\xC8\x0E\x03\x5D\xDD\x6E\x44\xA6\x05\x8E\x48\xA6\x39\x21\x4A\xA6\xF6\x8D\x03\x0F\xAD\x5E\xD9\x20\xC8\x0E\x4F\xA6\xC1\x28\x4E\xA6\x54\xA6\x56\x21\x55\xA6\xE5\x10\x57\xA6\xDF\x6E\x59\xA6\x03\x01\x52\xA6\x5D\xA6\x03\x0F\x4E\x21\x4D\x21\xC8\x0E\x60\xA6\xFD\x6E\x03\x0F\x4D\x61\xE2\x6F\xC8\x0E\x66\xA6\xE2\x20\x03\x0F\x7D\x21\xC2\x21\xD1\x0E\x6C\xA6\x6C\xA6\xBC\x63\xA3\x9A", + "\xC8\x0E\x71\xA6\xAC\x63\x03\x0F\x74\xA6\x77\xA6\x03\x0F\x02\x29\x9C\x84\xE9\x10\x7A\xA6\x7D\xA6\x79\xA6\x7F\xA6\xAA\x3D\x7B\xA6\x38\x5F\x80\xA6\x02\x42\xB3\x0F", }; vl::glr::DecompressSerializedData(compressed, true, dataSolidRows, dataRows, dataBlock, dataRemain, outputStream); } @@ -41232,9 +41099,11 @@ namespace vl::workflow L"_Destructor", L"_ClassBody", L"_Class", + L"_EnumItemNumber", L"_EnumItemInt", - L"_EnumItemA", - L"_EnumItemB", + L"_EnumItemFlags", + L"_EnumItem", + L"_EnumItemWithFlags", L"_Enum", L"_StructMember", L"_Struct", @@ -41303,9 +41172,9 @@ namespace vl::workflow L"[44][_Type]< _Type @ \"[\" [ _Type ] \"]\" >", L"[45][_Type]< _Type @ \"^\" >", L"[46][_Type]< _Type @ \"{\" \"}\" >", - L"[47][_Type]<< \"(\" !_Type \")\" @ >>", - L"[48][_Type]<< \"(\" !_Type @ \")\" >>", - L"[49][_Type]<< \"(\" @ !_Type \")\" >>", + L"[47][_Type]", + L"[48][_Type]", + L"[49][_Type]", L"[50][_CtorFragment] BEGIN ", L"[51][_CtorFragment] END [ENDING]", L"[52][_CtorFragment]< _Expression @ [ \":\" _Expression ] >", @@ -41337,748 +41206,716 @@ namespace vl::workflow L"[78][_VirtualExpression]< \"new\" _Type \"(\" @ \"using\" _Expression \")\" >", L"[79][_VirtualExpression]< \"new\" _Type @ \"(\" \"using\" _Expression \")\" >", L"[80][_VirtualExpression]< FORMATSTRING @ >", - L"[81][_BeginBoundary] BEGIN ", - L"[82][_BeginBoundary] END [ENDING]", - L"[83][_BeginBoundary]\"(\" @", - L"[84][_BeginBoundary]\"[\" @", - L"[85][_EndBoundary] BEGIN ", - L"[86][_EndBoundary] END [ENDING]", - L"[87][_EndBoundary]\")\" @", - L"[88][_EndBoundary]\"]\" @", - L"[89][_SetTestingOperator] BEGIN ", - L"[90][_SetTestingOperator] END [ENDING]", - L"[91][_SetTestingOperator]\"in\" @", - L"[92][_SetTestingOperator]\"not\" \"in\" @", - L"[93][_SetTestingOperator]\"not\" @ \"in\"", - L"[94][_ExpPrimitive] BEGIN ", - L"[95][_ExpPrimitive] END [ENDING]", - L"[96][_ExpPrimitive]< \"::\" @ NAME >", - L"[97][_ExpPrimitive]< \"::\" NAME @ >", - L"[98][_ExpPrimitive]< \"[\" @ _Expression \"]\" >", - L"[99][_ExpPrimitive]< \"[\" _Expression \"]\" @ >", - L"[100][_ExpPrimitive]< \"[\" _Expression @ \"]\" >", - L"[101][_ExpPrimitive]< \"attach\" \"(\" @ _Expression \",\" _Expression \")\" >", - L"[102][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" @ _Expression \")\" >", - L"[103][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" _Expression \")\" @ >", - L"[104][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" _Expression @ \")\" >", - L"[105][_ExpPrimitive]< \"attach\" \"(\" _Expression @ \",\" _Expression \")\" >", - L"[106][_ExpPrimitive]< \"attach\" @ \"(\" _Expression \",\" _Expression \")\" >", - L"[107][_ExpPrimitive]< \"detach\" \"(\" @ _Expression \",\" _Expression \")\" >", - L"[108][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" @ _Expression \")\" >", - L"[109][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" _Expression \")\" @ >", - L"[110][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" _Expression @ \")\" >", - L"[111][_ExpPrimitive]< \"detach\" \"(\" _Expression @ \",\" _Expression \")\" >", - L"[112][_ExpPrimitive]< \"detach\" @ \"(\" _Expression \",\" _Expression \")\" >", - L"[113][_ExpPrimitive]< \"false\" @ >", - L"[114][_ExpPrimitive]< \"let\" @ _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" >", - L"[115][_ExpPrimitive]< \"let\" _LetVariable @ { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" >", - L"[116][_ExpPrimitive]< \"let\" _LetVariable { \",\" @ _LetVariable } \"in\" \"(\" _Expression \")\" >", - L"[117][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable @ } \"in\" \"(\" _Expression \")\" >", - L"[118][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" @ _Expression \")\" >", - L"[119][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" @ >", - L"[120][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression @ \")\" >", - L"[121][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" @ \"(\" _Expression \")\" >", - L"[122][_ExpPrimitive]< \"new\" @ _Type \"(\" { _Expression ; \",\" } \")\" >", - L"[123][_ExpPrimitive]< \"new\" @ _Type \"{\" { _Declaration } \"}\" >", - L"[124][_ExpPrimitive]< \"new\" _Type \"(\" @ { _Expression ; \",\" } \")\" >", - L"[125][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression ; \",\" @ } \")\" >", - L"[126][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression ; \",\" } \")\" @ >", - L"[127][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression @ ; \",\" } \")\" >", - L"[128][_ExpPrimitive]< \"new\" _Type \"{\" @ { _Declaration } \"}\" >", - L"[129][_ExpPrimitive]< \"new\" _Type \"{\" { _Declaration @ } \"}\" >", - L"[130][_ExpPrimitive]< \"new\" _Type \"{\" { _Declaration } \"}\" @ >", - L"[131][_ExpPrimitive]< \"new\" _Type @ \"(\" { _Expression ; \",\" } \")\" >", - L"[132][_ExpPrimitive]< \"new\" _Type @ \"{\" { _Declaration } \"}\" >", - L"[133][_ExpPrimitive]< \"null\" @ >", - L"[134][_ExpPrimitive]< \"range\" @ _BeginBoundary _Expression \",\" _Expression _EndBoundary >", - L"[135][_ExpPrimitive]< \"range\" _BeginBoundary @ _Expression \",\" _Expression _EndBoundary >", - L"[136][_ExpPrimitive]< \"range\" _BeginBoundary _Expression \",\" @ _Expression _EndBoundary >", - L"[137][_ExpPrimitive]< \"range\" _BeginBoundary _Expression \",\" _Expression @ _EndBoundary >", - L"[138][_ExpPrimitive]< \"range\" _BeginBoundary _Expression \",\" _Expression _EndBoundary @ >", - L"[139][_ExpPrimitive]< \"range\" _BeginBoundary _Expression @ \",\" _Expression _EndBoundary >", - L"[140][_ExpPrimitive]< \"this\" @ >", - L"[141][_ExpPrimitive]< \"true\" @ >", - L"[142][_ExpPrimitive]< \"type\" \"(\" @ _Expression \")\" >", - L"[143][_ExpPrimitive]< \"type\" \"(\" _Expression \")\" @ >", - L"[144][_ExpPrimitive]< \"type\" \"(\" _Expression @ \")\" >", - L"[145][_ExpPrimitive]< \"type\" @ \"(\" _Expression \")\" >", - L"[146][_ExpPrimitive]< \"typeof\" \"(\" @ _Type \")\" >", - L"[147][_ExpPrimitive]< \"typeof\" \"(\" _Type \")\" @ >", - L"[148][_ExpPrimitive]< \"typeof\" \"(\" _Type @ \")\" >", - L"[149][_ExpPrimitive]< \"typeof\" @ \"(\" _Type \")\" >", - L"[150][_ExpPrimitive]< \"{\" @ [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", - L"[151][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment @ } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", - L"[152][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" @ _CtorFragment } \";\" ) ] \"}\" >", - L"[153][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment @ } \";\" ) ] \"}\" >", - L"[154][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" @ >", - L"[155][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" @ ) ] \"}\" >", - L"[156][_ExpPrimitive]< \"{\" [ _CtorFragment @ ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", - L"[157][_ExpPrimitive]< FLOAT @ >", - L"[158][_ExpPrimitive]< INTEGER @ >", - L"[159][_ExpPrimitive]< NAME @ >", - L"[160][_ExpPrimitive]< ORDERED_NAME @ >", - L"[161][_ExpPrimitive]< STRING @ >", - L"[162][_ExpPrimitive]< _ExpPrimitive \"(\" @ [ _Expression { \",\" _Expression } ] \")\" >", - L"[163][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression @ { \",\" _Expression } ] \")\" >", - L"[164][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" @ _Expression } ] \")\" >", - L"[165][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" _Expression @ } ] \")\" >", - L"[166][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" _Expression } ] \")\" @ >", - L"[167][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" @ _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[168][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression @ [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[169][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" @ _Expression { \",\" _Expression } ] \")\" >", - L"[170][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression @ { \",\" _Expression } ] \")\" >", - L"[171][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" @ _Expression } ] \")\" >", - L"[172][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression @ } ] \")\" >", - L"[173][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" @ >", - L"[174][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" @ NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[175][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" @ _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[176][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression @ [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[177][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" @ _Expression { \",\" _Expression } ] \")\" >", - L"[178][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression @ { \",\" _Expression } ] \")\" >", - L"[179][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" @ _Expression } ] \")\" >", - L"[180][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression @ } ] \")\" >", - L"[181][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" @ >", - L"[182][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME @ \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[183][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" @ \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[184][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" @ \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[185][_ExpPrimitive]< _ExpPrimitive \".\" @ \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[186][_ExpPrimitive]< _ExpPrimitive \".\" @ \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[187][_ExpPrimitive]< _ExpPrimitive \".\" @ NAME >", - L"[188][_ExpPrimitive]< _ExpPrimitive \".\" NAME @ >", - L"[189][_ExpPrimitive]< _ExpPrimitive \"::\" @ NAME >", - L"[190][_ExpPrimitive]< _ExpPrimitive \"::\" NAME @ >", - L"[191][_ExpPrimitive]< _ExpPrimitive \"[\" @ _Expression \"]\" >", - L"[192][_ExpPrimitive]< _ExpPrimitive \"[\" _Expression \"]\" @ >", - L"[193][_ExpPrimitive]< _ExpPrimitive \"[\" _Expression @ \"]\" >", - L"[194][_ExpPrimitive]< _ExpPrimitive \"as\" \"*\" @ >", - L"[195][_ExpPrimitive]< _ExpPrimitive \"as\" @ \"*\" >", - L"[196][_ExpPrimitive]< _ExpPrimitive \"as\" @ _Type >", - L"[197][_ExpPrimitive]< _ExpPrimitive \"as\" _Type @ >", - L"[198][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" \"null\" @ >", - L"[199][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" @ \"null\" >", - L"[200][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" @ _Type >", - L"[201][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" _Type @ >", - L"[202][_ExpPrimitive]< _ExpPrimitive \"is\" \"null\" @ >", - L"[203][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"not\" \"null\" >", - L"[204][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"not\" _Type >", - L"[205][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"null\" >", - L"[206][_ExpPrimitive]< _ExpPrimitive \"is\" @ _Type >", - L"[207][_ExpPrimitive]< _ExpPrimitive \"is\" _Type @ >", - L"[208][_ExpPrimitive]< _ExpPrimitive \"of\" @ _Type >", - L"[209][_ExpPrimitive]< _ExpPrimitive \"of\" _Type @ >", - L"[210][_ExpPrimitive]< _ExpPrimitive @ \"(\" [ _Expression { \",\" _Expression } ] \")\" >", - L"[211][_ExpPrimitive]< _ExpPrimitive @ \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[212][_ExpPrimitive]< _ExpPrimitive @ \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", - L"[213][_ExpPrimitive]< _ExpPrimitive @ \".\" NAME >", - L"[214][_ExpPrimitive]< _ExpPrimitive @ \"::\" NAME >", - L"[215][_ExpPrimitive]< _ExpPrimitive @ \"[\" _Expression \"]\" >", - L"[216][_ExpPrimitive]< _ExpPrimitive @ \"as\" \"*\" >", - L"[217][_ExpPrimitive]< _ExpPrimitive @ \"as\" _Type >", - L"[218][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"not\" \"null\" >", - L"[219][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"not\" _Type >", - L"[220][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"null\" >", - L"[221][_ExpPrimitive]< _ExpPrimitive @ \"is\" _Type >", - L"[222][_ExpPrimitive]< _ExpPrimitive @ \"of\" _Type >", - L"[223][_ExpPrimitive]< _ExpPrimitive @ _SetTestingOperator _Expression >", - L"[224][_ExpPrimitive]< _ExpPrimitive _SetTestingOperator @ _Expression >", - L"[225][_ExpPrimitive]< _ExpPrimitive _SetTestingOperator _Expression @ >", - L"[226][_ExpPrimitive]< _Function @ >", - L"[227][_ExpPrimitive]<< !_VirtualExpression @ >>", - L"[228][_ExpPrimitive]<< \"(\" !_Expression \")\" @ >>", - L"[229][_ExpPrimitive]<< \"(\" !_Expression @ \")\" >>", - L"[230][_ExpPrimitive]<< \"(\" @ !_Expression \")\" >>", - L"[231][_Exp0] BEGIN ", - L"[232][_Exp0] END [ENDING]", - L"[233][_Exp0]< \"+\" @ _Exp0 >", - L"[234][_Exp0]< \"+\" _Exp0 @ >", - L"[235][_Exp0]< \"-\" @ _Exp0 >", - L"[236][_Exp0]< \"-\" _Exp0 @ >", - L"[237][_Exp0]< \"cast\" \"*\" @ _Exp0 >", - L"[238][_Exp0]< \"cast\" \"*\" _Exp0 @ >", - L"[239][_Exp0]< \"cast\" @ \"*\" _Exp0 >", - L"[240][_Exp0]< \"cast\" @ _Type _Exp0 >", - L"[241][_Exp0]< \"cast\" _Type @ _Exp0 >", - L"[242][_Exp0]< \"cast\" _Type _Exp0 @ >", - L"[243][_Exp0]< \"not\" @ _Exp0 >", - L"[244][_Exp0]< \"not\" _Exp0 @ >", - L"[245][_Exp0]<< !_ExpPrimitive @ >>", - L"[246][_Exp1] BEGIN ", - L"[247][_Exp1] END [ENDING]", - L"[248][_Exp1]< _Exp1 \"^\" @ _Exp0 >", - L"[249][_Exp1]< _Exp1 \"^\" _Exp0 @ >", - L"[250][_Exp1]< _Exp1 @ \"^\" _Exp0 >", - L"[251][_Exp1]<< !_Exp0 @ >>", - L"[252][_Exp2] BEGIN ", - L"[253][_Exp2] END [ENDING]", - L"[254][_Exp2]< _Exp2 \"%\" @ _Exp1 >", - L"[255][_Exp2]< _Exp2 \"%\" _Exp1 @ >", - L"[256][_Exp2]< _Exp2 \"*\" @ _Exp1 >", - L"[257][_Exp2]< _Exp2 \"*\" _Exp1 @ >", - L"[258][_Exp2]< _Exp2 \"/\" @ _Exp1 >", - L"[259][_Exp2]< _Exp2 \"/\" _Exp1 @ >", - L"[260][_Exp2]< _Exp2 @ \"%\" _Exp1 >", - L"[261][_Exp2]< _Exp2 @ \"*\" _Exp1 >", - L"[262][_Exp2]< _Exp2 @ \"/\" _Exp1 >", - L"[263][_Exp2]<< !_Exp1 @ >>", - L"[264][_Exp3] BEGIN ", - L"[265][_Exp3] END [ENDING]", - L"[266][_Exp3]< _Exp3 \"&\" @ _Exp2 >", - L"[267][_Exp3]< _Exp3 \"&\" _Exp2 @ >", - L"[268][_Exp3]< _Exp3 \"+\" @ _Exp2 >", - L"[269][_Exp3]< _Exp3 \"+\" _Exp2 @ >", - L"[270][_Exp3]< _Exp3 \"-\" @ _Exp2 >", - L"[271][_Exp3]< _Exp3 \"-\" _Exp2 @ >", - L"[272][_Exp3]< _Exp3 \"|\" @ _Exp2 >", - L"[273][_Exp3]< _Exp3 \"|\" _Exp2 @ >", - L"[274][_Exp3]< _Exp3 @ \"&\" _Exp2 >", - L"[275][_Exp3]< _Exp3 @ \"+\" _Exp2 >", - L"[276][_Exp3]< _Exp3 @ \"-\" _Exp2 >", - L"[277][_Exp3]< _Exp3 @ \"|\" _Exp2 >", - L"[278][_Exp3]<< !_Exp2 @ >>", - L"[279][_Exp4] BEGIN ", - L"[280][_Exp4] END [ENDING]", - L"[281][_Exp4]< _Exp4 \"shl\" @ _Exp3 >", - L"[282][_Exp4]< _Exp4 \"shl\" _Exp3 @ >", - L"[283][_Exp4]< _Exp4 \"shr\" @ _Exp3 >", - L"[284][_Exp4]< _Exp4 \"shr\" _Exp3 @ >", - L"[285][_Exp4]< _Exp4 @ \"shl\" _Exp3 >", - L"[286][_Exp4]< _Exp4 @ \"shr\" _Exp3 >", - L"[287][_Exp4]<< !_Exp3 @ >>", - L"[288][_Exp5] BEGIN ", - L"[289][_Exp5] END [ENDING]", - L"[290][_Exp5]< _Exp5 \"!=\" @ _Exp4 >", - L"[291][_Exp5]< _Exp5 \"!=\" _Exp4 @ >", - L"[292][_Exp5]< _Exp5 \"<\" @ _Exp4 >", - L"[293][_Exp5]< _Exp5 \"<\" _Exp4 @ >", - L"[294][_Exp5]< _Exp5 \"<=\" @ _Exp4 >", - L"[295][_Exp5]< _Exp5 \"<=\" _Exp4 @ >", - L"[296][_Exp5]< _Exp5 \"==\" @ _Exp4 >", - L"[297][_Exp5]< _Exp5 \"==\" _Exp4 @ >", - L"[298][_Exp5]< _Exp5 \">\" @ _Exp4 >", - L"[299][_Exp5]< _Exp5 \">\" _Exp4 @ >", - L"[300][_Exp5]< _Exp5 \">=\" @ _Exp4 >", - L"[301][_Exp5]< _Exp5 \">=\" _Exp4 @ >", - L"[302][_Exp5]< _Exp5 @ \"!=\" _Exp4 >", - L"[303][_Exp5]< _Exp5 @ \"<\" _Exp4 >", - L"[304][_Exp5]< _Exp5 @ \"<=\" _Exp4 >", - L"[305][_Exp5]< _Exp5 @ \"==\" _Exp4 >", - L"[306][_Exp5]< _Exp5 @ \">\" _Exp4 >", - L"[307][_Exp5]< _Exp5 @ \">=\" _Exp4 >", - L"[308][_Exp5]<< !_Exp4 @ >>", - L"[309][_Exp6] BEGIN ", - L"[310][_Exp6] END [ENDING]", - L"[311][_Exp6]< _Exp6 \"xor\" @ _Exp5 >", - L"[312][_Exp6]< _Exp6 \"xor\" _Exp5 @ >", - L"[313][_Exp6]< _Exp6 @ \"xor\" _Exp5 >", - L"[314][_Exp6]<< !_Exp5 @ >>", - L"[315][_Exp7] BEGIN ", - L"[316][_Exp7] END [ENDING]", - L"[317][_Exp7]< _Exp7 \"and\" @ _Exp6 >", - L"[318][_Exp7]< _Exp7 \"and\" _Exp6 @ >", - L"[319][_Exp7]< _Exp7 @ \"and\" _Exp6 >", - L"[320][_Exp7]<< !_Exp6 @ >>", - L"[321][_Exp8] BEGIN ", - L"[322][_Exp8] END [ENDING]", - L"[323][_Exp8]< _Exp8 \"or\" @ _Exp7 >", - L"[324][_Exp8]< _Exp8 \"or\" _Exp7 @ >", - L"[325][_Exp8]< _Exp8 @ \"or\" _Exp7 >", - L"[326][_Exp8]<< !_Exp7 @ >>", - L"[327][_Exp9] BEGIN ", - L"[328][_Exp9] END [ENDING]", - L"[329][_Exp9]< _Exp9 \"??\" @ _Exp8 >", - L"[330][_Exp9]< _Exp9 \"??\" _Exp8 @ >", - L"[331][_Exp9]< _Exp9 @ \"??\" _Exp8 >", - L"[332][_Exp9]<< !_Exp8 @ >>", - L"[333][_Exp10] BEGIN ", - L"[334][_Exp10] END [ENDING]", - L"[335][_Exp10]< _Exp9 \"?\" @ _Exp10 \":\" _Exp10 >", - L"[336][_Exp10]< _Exp9 \"?\" _Exp10 \":\" @ _Exp10 >", - L"[337][_Exp10]< _Exp9 \"?\" _Exp10 \":\" _Exp10 @ >", - L"[338][_Exp10]< _Exp9 \"?\" _Exp10 @ \":\" _Exp10 >", - L"[339][_Exp10]< _Exp9 @ \"?\" _Exp10 \":\" _Exp10 >", - L"[340][_Exp10]<< !_Exp9 @ >>", - L"[341][_Exp11] BEGIN ", - L"[342][_Exp11] END [ENDING]", - L"[343][_Exp11]< _Exp10 \"=\" @ _Exp11 >", - L"[344][_Exp11]< _Exp10 \"=\" _Exp11 @ >", - L"[345][_Exp11]< _Exp10 @ \"=\" _Exp11 >", - L"[346][_Exp11]<< !_Exp10 @ >>", - L"[347][_Expression] BEGIN ", - L"[348][_Expression] END [ENDING]", - L"[349][_Expression]<< !_Exp11 @ >>", - L"[350][_SwitchCase] BEGIN ", - L"[351][_SwitchCase] END [ENDING]", - L"[352][_SwitchCase]< \"case\" @ _Expression \":\" _Block >", - L"[353][_SwitchCase]< \"case\" _Expression \":\" @ _Block >", - L"[354][_SwitchCase]< \"case\" _Expression \":\" _Block @ >", - L"[355][_SwitchCase]< \"case\" _Expression @ \":\" _Block >", - L"[356][_Block] BEGIN ", - L"[357][_Block] END [ENDING]", - L"[358][_Block]< \"{\" @ { _Statement } [ NAME \":\" \";\" ] \"}\" >", - L"[359][_Block]< \"{\" { _Statement @ } [ NAME \":\" \";\" ] \"}\" >", - L"[360][_Block]< \"{\" { _Statement } [ NAME \":\" \";\" @ ] \"}\" >", - L"[361][_Block]< \"{\" { _Statement } [ NAME \":\" \";\" ] \"}\" @ >", - L"[362][_Block]< \"{\" { _Statement } [ NAME \":\" @ \";\" ] \"}\" >", - L"[363][_Block]< \"{\" { _Statement } [ NAME @ \":\" \";\" ] \"}\" >", - L"[364][_ElseStat] BEGIN ", - L"[365][_ElseStat] END [ENDING]", - L"[366][_ElseStat]<< !_Block @ >>", - L"[367][_ElseStat]<< !_If @ >>", - L"[368][_If] BEGIN ", - L"[369][_If] END [ENDING]", - L"[370][_If]< \"if\" \"(\" @ [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[371][_If]< \"if\" \"(\" [ \"var\" @ NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[372][_If]< \"if\" \"(\" [ \"var\" NAME \":\" @ _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[373][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" @ ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[374][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" @ _Block +[ \"else\" _ElseStat ] >", - L"[375][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" @ _ElseStat ] >", - L"[376][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat @ ] >", - L"[377][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block @ +[ \"else\" _ElseStat ] >", - L"[378][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression @ \")\" _Block +[ \"else\" _ElseStat ] >", - L"[379][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type @ \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[380][_If]< \"if\" \"(\" [ \"var\" NAME @ \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[381][_If]< \"if\" @ \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", - L"[382][_ForOperator] BEGIN ", - L"[383][_ForOperator] END [ENDING]", - L"[384][_ForOperator]\"in\" \"reversed\" @", - L"[385][_ForOperator]\"in\" @", - L"[386][_ForOperator]\"in\" @ \"reversed\"", - L"[387][_VirtualStatement] BEGIN ", - L"[388][_VirtualStatement] END [ENDING]", - L"[389][_VirtualStatement]< \"for\" \"(\" @ NAME _ForOperator _Expression \")\" _Block >", - L"[390][_VirtualStatement]< \"for\" \"(\" NAME @ _ForOperator _Expression \")\" _Block >", - L"[391][_VirtualStatement]< \"for\" \"(\" NAME _ForOperator @ _Expression \")\" _Block >", - L"[392][_VirtualStatement]< \"for\" \"(\" NAME _ForOperator _Expression \")\" @ _Block >", - L"[393][_VirtualStatement]< \"for\" \"(\" NAME _ForOperator _Expression \")\" _Block @ >", - L"[394][_VirtualStatement]< \"for\" \"(\" NAME _ForOperator _Expression @ \")\" _Block >", - L"[395][_VirtualStatement]< \"for\" @ \"(\" NAME _ForOperator _Expression \")\" _Block >", - L"[396][_VirtualStatement]< \"switch\" \"(\" @ _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", - L"[397][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" @ { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", - L"[398][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase @ } [ \"default\" \":\" _Block ] \"}\" >", - L"[399][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" @ _Block ] \"}\" >", - L"[400][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block @ ] \"}\" >", - L"[401][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" @ >", - L"[402][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" @ \":\" _Block ] \"}\" >", - L"[403][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" @ \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", - L"[404][_VirtualStatement]< \"switch\" \"(\" _Expression @ \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", - L"[405][_VirtualStatement]< \"switch\" @ \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", - L"[406][_CoStatement] BEGIN ", - L"[407][_CoStatement] END [ENDING]", - L"[408][_CoStatement]< \"$pause\" ( \";\" @ | _Block ) >", - L"[409][_CoStatement]< \"$pause\" ( \";\" | _Block @ ) >", - L"[410][_CoStatement]< \"$pause\" @ ( \";\" | _Block ) >", - L"[411][_CoStatement]< [ \"var\" @ NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", - L"[412][_CoStatement]< [ \"var\" NAME \"=\" @ ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", - L"[413][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR @ { _Expression ; \",\" } \";\" >", - L"[414][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" @ } \";\" >", - L"[415][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" @ >", - L"[416][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression @ ; \",\" } \";\" >", - L"[417][_CoStatement]< [ \"var\" NAME @ \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", - L"[418][_CoProvider] BEGIN ", - L"[419][_CoProvider] END [ENDING]", - L"[420][_CoProvider]< ( \"$\" @ | COROUTINE_OPERATOR ) _Block >", - L"[421][_CoProvider]< ( \"$\" | COROUTINE_OPERATOR ) _Block @ >", - L"[422][_CoProvider]< ( \"$\" | COROUTINE_OPERATOR @ ) _Block >", - L"[423][_StateSwitchHead] BEGIN ", - L"[424][_StateSwitchHead] END [ENDING]", - L"[425][_StateSwitchHead]< \"$switch\" \"(\" \")\" @ >", - L"[426][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \")\" @ >", - L"[427][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" \"return\" \")\" @ >", - L"[428][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" \"return\" @ \")\" >", - L"[429][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" @ \"return\" \")\" >", - L"[430][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" @ \")\" >", - L"[431][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" @ \",\" \"return\" \")\" >", - L"[432][_StateSwitchHead]< \"$switch\" \"(\" \"raise\" \")\" @ >", - L"[433][_StateSwitchHead]< \"$switch\" \"(\" \"raise\" @ \")\" >", - L"[434][_StateSwitchHead]< \"$switch\" \"(\" \"return\" \")\" @ >", - L"[435][_StateSwitchHead]< \"$switch\" \"(\" \"return\" @ \")\" >", - L"[436][_StateSwitchHead]< \"$switch\" \"(\" @ \")\" >", - L"[437][_StateSwitchHead]< \"$switch\" \"(\" @ \"continue\" \")\" >", - L"[438][_StateSwitchHead]< \"$switch\" \"(\" @ \"continue\" \",\" \"return\" \")\" >", - L"[439][_StateSwitchHead]< \"$switch\" \"(\" @ \"raise\" \")\" >", - L"[440][_StateSwitchHead]< \"$switch\" \"(\" @ \"return\" \")\" >", - L"[441][_StateSwitchHead]< \"$switch\" @ \"(\" \")\" >", - L"[442][_StateSwitchHead]< \"$switch\" @ \"(\" \"continue\" \")\" >", - L"[443][_StateSwitchHead]< \"$switch\" @ \"(\" \"continue\" \",\" \"return\" \")\" >", - L"[444][_StateSwitchHead]< \"$switch\" @ \"(\" \"raise\" \")\" >", - L"[445][_StateSwitchHead]< \"$switch\" @ \"(\" \"return\" \")\" >", - L"[446][_StateSwitchArgument] BEGIN ", - L"[447][_StateSwitchArgument] END [ENDING]", - L"[448][_StateSwitchArgument]< NAME @ >", - L"[449][_StateSwitchCase] BEGIN ", - L"[450][_StateSwitchCase] END [ENDING]", - L"[451][_StateSwitchCase]< \"case\" @ NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", - L"[452][_StateSwitchCase]< \"case\" NAME \"(\" @ [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", - L"[453][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument @ { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", - L"[454][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" @ _StateSwitchArgument } ] \")\" \":\" _Block >", - L"[455][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument @ } ] \")\" \":\" _Block >", - L"[456][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" @ _Block >", - L"[457][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block @ >", - L"[458][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" @ \":\" _Block >", - L"[459][_StateSwitchCase]< \"case\" NAME @ \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", - L"[460][_StateStatement] BEGIN ", - L"[461][_StateStatement] END [ENDING]", - L"[462][_StateStatement]< \"$goto_state\" @ NAME \"(\" { _Expression ; \",\" } \")\" \";\" >", - L"[463][_StateStatement]< \"$goto_state\" NAME \"(\" @ { _Expression ; \",\" } \")\" \";\" >", - L"[464][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" @ } \")\" \";\" >", - L"[465][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" } \")\" \";\" @ >", - L"[466][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" } \")\" @ \";\" >", - L"[467][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression @ ; \",\" } \")\" \";\" >", - L"[468][_StateStatement]< \"$goto_state\" NAME @ \"(\" { _Expression ; \",\" } \")\" \";\" >", - L"[469][_StateStatement]< \"$push_state\" @ NAME \"(\" { _Expression ; \",\" } \")\" \";\" >", - L"[470][_StateStatement]< \"$push_state\" NAME \"(\" @ { _Expression ; \",\" } \")\" \";\" >", - L"[471][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" @ } \")\" \";\" >", - L"[472][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" } \")\" \";\" @ >", - L"[473][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" } \")\" @ \";\" >", - L"[474][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression @ ; \",\" } \")\" \";\" >", - L"[475][_StateStatement]< \"$push_state\" NAME @ \"(\" { _Expression ; \",\" } \")\" \";\" >", - L"[476][_StateStatement]<< !_StateSwitchHead \"{\" @ { _StateSwitchCase } \"}\" >>", - L"[477][_StateStatement]<< !_StateSwitchHead \"{\" { _StateSwitchCase @ } \"}\" >>", - L"[478][_StateStatement]<< !_StateSwitchHead \"{\" { _StateSwitchCase } \"}\" @ >>", - L"[479][_StateStatement]<< !_StateSwitchHead @ \"{\" { _StateSwitchCase } \"}\" >>", - L"[480][_Statement] BEGIN ", - L"[481][_Statement] END [ENDING]", - L"[482][_Statement]< \"break\" \";\" @ >", - L"[483][_Statement]< \"break\" @ \";\" >", - L"[484][_Statement]< \"continue\" \";\" @ >", - L"[485][_Statement]< \"continue\" @ \";\" >", - L"[486][_Statement]< \"delete\" @ _Expression \";\" >", - L"[487][_Statement]< \"delete\" _Expression \";\" @ >", - L"[488][_Statement]< \"delete\" _Expression @ \";\" >", - L"[489][_Statement]< \"goto\" @ NAME \";\" >", - L"[490][_Statement]< \"goto\" NAME \";\" @ >", - L"[491][_Statement]< \"goto\" NAME @ \";\" >", - L"[492][_Statement]< \"raise\" @ [ _Expression ] \";\" >", - L"[493][_Statement]< \"raise\" [ _Expression @ ] \";\" >", - L"[494][_Statement]< \"raise\" [ _Expression ] \";\" @ >", - L"[495][_Statement]< \"return\" @ [ _Expression ] \";\" >", - L"[496][_Statement]< \"return\" [ _Expression @ ] \";\" >", - L"[497][_Statement]< \"return\" [ _Expression ] \";\" @ >", - L"[498][_Statement]< \"try\" @ _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", - L"[499][_Statement]< \"try\" _Block @ [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", - L"[500][_Statement]< \"try\" _Block [ \"catch\" \"(\" @ NAME \")\" _Block ] [ \"finally\" _Block ] >", - L"[501][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" @ _Block ] [ \"finally\" _Block ] >", - L"[502][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block @ ] [ \"finally\" _Block ] >", - L"[503][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" @ _Block ] >", - L"[504][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block @ ] >", - L"[505][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME @ \")\" _Block ] [ \"finally\" _Block ] >", - L"[506][_Statement]< \"try\" _Block [ \"catch\" @ \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", - L"[507][_Statement]< \"while\" \"(\" @ _Expression \")\" _Block >", - L"[508][_Statement]< \"while\" \"(\" _Expression \")\" @ _Block >", - L"[509][_Statement]< \"while\" \"(\" _Expression \")\" _Block @ >", - L"[510][_Statement]< \"while\" \"(\" _Expression @ \")\" _Block >", - L"[511][_Statement]< \"while\" @ \"(\" _Expression \")\" _Block >", - L"[512][_Statement]< _Expression \";\" @ >", - L"[513][_Statement]< _Expression @ \";\" >", - L"[514][_Statement]< _Variable @ >", - L"[515][_Statement]<< !_Block @ >>", - L"[516][_Statement]<< !_CoStatement @ >>", - L"[517][_Statement]<< !_If @ >>", - L"[518][_Statement]<< !_StateStatement @ >>", - L"[519][_Statement]<< !_VirtualStatement @ >>", - L"[520][_StateInput] BEGIN ", - L"[521][_StateInput] END [ENDING]", - L"[522][_StateInput]< \"$state_input\" @ NAME \"(\" { _FunctionArgument ; \",\" } \")\" \";\" >", - L"[523][_StateInput]< \"$state_input\" NAME \"(\" @ { _FunctionArgument ; \",\" } \")\" \";\" >", - L"[524][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" @ } \")\" \";\" >", - L"[525][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" } \")\" \";\" @ >", - L"[526][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" } \")\" @ \";\" >", - L"[527][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument @ ; \",\" } \")\" \";\" >", - L"[528][_StateInput]< \"$state_input\" NAME @ \"(\" { _FunctionArgument ; \",\" } \")\" \";\" >", - L"[529][_StateDecl] BEGIN ", - L"[530][_StateDecl] END [ENDING]", - L"[531][_StateDecl]< \"$state\" ( \"default\" @ | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", - L"[532][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" @ { _FunctionArgument ; \",\" } \")\" _Block >", - L"[533][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" @ } \")\" _Block >", - L"[534][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" @ _Block >", - L"[535][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block @ >", - L"[536][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument @ ; \",\" } \")\" _Block >", - L"[537][_StateDecl]< \"$state\" ( \"default\" | NAME @ ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", - L"[538][_StateDecl]< \"$state\" @ ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", - L"[539][_StateMachine] BEGIN ", - L"[540][_StateMachine] END [ENDING]", - L"[541][_StateMachine]< \"$state_machine\" \"{\" @ { ( _StateInput | _StateDecl ) } \"}\" >", - L"[542][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput @ | _StateDecl ) } \"}\" >", - L"[543][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput | _StateDecl ) } \"}\" @ >", - L"[544][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput | _StateDecl @ ) } \"}\" >", - L"[545][_StateMachine]< \"$state_machine\" @ \"{\" { ( _StateInput | _StateDecl ) } \"}\" >", - L"[546][_Attribute] BEGIN ", - L"[547][_Attribute] END [ENDING]", - L"[548][_Attribute]< \"@\" @ NAME \":\" NAME [ \"(\" _Expression \")\" ] >", - L"[549][_Attribute]< \"@\" NAME \":\" @ NAME [ \"(\" _Expression \")\" ] >", - L"[550][_Attribute]< \"@\" NAME \":\" NAME @ [ \"(\" _Expression \")\" ] >", - L"[551][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" @ _Expression \")\" ] >", - L"[552][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" _Expression \")\" @ ] >", - L"[553][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" _Expression @ \")\" ] >", - L"[554][_Attribute]< \"@\" NAME @ \":\" NAME [ \"(\" _Expression \")\" ] >", - L"[555][_Namespace] BEGIN ", - L"[556][_Namespace] END [ENDING]", - L"[557][_Namespace]< \"namespace\" @ NAME \"{\" { _Declaration } \"}\" >", - L"[558][_Namespace]< \"namespace\" NAME \"{\" @ { _Declaration } \"}\" >", - L"[559][_Namespace]< \"namespace\" NAME \"{\" { _Declaration @ } \"}\" >", - L"[560][_Namespace]< \"namespace\" NAME \"{\" { _Declaration } \"}\" @ >", - L"[561][_Namespace]< \"namespace\" NAME @ \"{\" { _Declaration } \"}\" >", - L"[562][_FunctionArgument] BEGIN ", - L"[563][_FunctionArgument] END [ENDING]", - L"[564][_FunctionArgument]< { _Attribute @ } NAME \":\" _Type >", - L"[565][_FunctionArgument]< { _Attribute } NAME \":\" @ _Type >", - L"[566][_FunctionArgument]< { _Attribute } NAME \":\" _Type @ >", - L"[567][_FunctionArgument]< { _Attribute } NAME @ \":\" _Type >", - L"[568][_FunctionArgumentList] BEGIN ", - L"[569][_FunctionArgumentList] END [ENDING]", - L"[570][_FunctionArgumentList]\"(\" @ { _FunctionArgument ; \",\" } \")\"", - L"[571][_FunctionArgumentList]\"(\" { _FunctionArgument ; \",\" @ } \")\"", - L"[572][_FunctionArgumentList]\"(\" { _FunctionArgument ; \",\" } \")\" @", - L"[573][_FunctionArgumentList]\"(\" { _FunctionArgument @ ; \",\" } \")\"", - L"[574][_FunctionStat] BEGIN ", - L"[575][_FunctionStat] END [ENDING]", - L"[576][_FunctionStat]<< !_Block @ >>", - L"[577][_FunctionStat]<< !_CoProvider @ >>", - L"[578][_FunctionBody] BEGIN ", - L"[579][_FunctionBody] END [ENDING]", - L"[580][_FunctionBody]\"(\" @ { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" )", - L"[581][_FunctionBody]\"(\" { _FunctionArgument ; \",\" @ } \")\" \":\" _Type ( _FunctionStat | \";\" )", - L"[582][_FunctionBody]\"(\" { _FunctionArgument ; \",\" } \")\" \":\" @ _Type ( _FunctionStat | \";\" )", - L"[583][_FunctionBody]\"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat @ | \";\" )", - L"[584][_FunctionBody]\"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" @ )", - L"[585][_FunctionBody]\"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type @ ( _FunctionStat | \";\" )", - L"[586][_FunctionBody]\"(\" { _FunctionArgument ; \",\" } \")\" @ \":\" _Type ( _FunctionStat | \";\" )", - L"[587][_FunctionBody]\"(\" { _FunctionArgument @ ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" )", - L"[588][_FunctionKind] BEGIN ", - L"[589][_FunctionKind] END [ENDING]", - L"[590][_FunctionKind]\"func\" @", - L"[591][_FunctionKind]\"override\" \"func\" @", - L"[592][_FunctionKind]\"override\" @ \"func\"", - L"[593][_FunctionKind]\"static\" \"func\" @", - L"[594][_FunctionKind]\"static\" @ \"func\"", - L"[595][_Function] BEGIN ", - L"[596][_Function] END [ENDING]", - L"[597][_Function]< _FunctionKind @ NAME _FunctionBody >", - L"[598][_Function]< _FunctionKind @ _FunctionBody >", - L"[599][_Function]< _FunctionKind NAME @ _FunctionBody >", - L"[600][_Function]< _FunctionKind NAME _FunctionBody @ >", - L"[601][_Function]< _FunctionKind _FunctionBody @ >", - L"[602][_Variable] BEGIN ", - L"[603][_Variable] END [ENDING]", - L"[604][_Variable]< \"var\" @ NAME [ \":\" _Type ] \"=\" _Expression \";\" >", - L"[605][_Variable]< \"var\" NAME @ [ \":\" _Type ] \"=\" _Expression \";\" >", - L"[606][_Variable]< \"var\" NAME [ \":\" @ _Type ] \"=\" _Expression \";\" >", - L"[607][_Variable]< \"var\" NAME [ \":\" _Type @ ] \"=\" _Expression \";\" >", - L"[608][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" @ _Expression \";\" >", - L"[609][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" _Expression \";\" @ >", - L"[610][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" _Expression @ \";\" >", - L"[611][_Event] BEGIN ", - L"[612][_Event] END [ENDING]", - L"[613][_Event]< \"event\" @ NAME \"(\" { _Type ; \",\" } \")\" \";\" >", - L"[614][_Event]< \"event\" NAME \"(\" @ { _Type ; \",\" } \")\" \";\" >", - L"[615][_Event]< \"event\" NAME \"(\" { _Type ; \",\" @ } \")\" \";\" >", - L"[616][_Event]< \"event\" NAME \"(\" { _Type ; \",\" } \")\" \";\" @ >", - L"[617][_Event]< \"event\" NAME \"(\" { _Type ; \",\" } \")\" @ \";\" >", - L"[618][_Event]< \"event\" NAME \"(\" { _Type @ ; \",\" } \")\" \";\" >", - L"[619][_Event]< \"event\" NAME @ \"(\" { _Type ; \",\" } \")\" \";\" >", - L"[620][_Property] BEGIN ", - L"[621][_Property] END [ENDING]", - L"[622][_Property]< \"prop\" @ NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[623][_Property]< \"prop\" NAME \":\" @ _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[624][_Property]< \"prop\" NAME \":\" _Type \"{\" @ NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[625][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME @ [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[626][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" @ NAME ] [ \":\" NAME ] \"}\" >", - L"[627][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME @ ] [ \":\" NAME ] \"}\" >", - L"[628][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" @ NAME ] \"}\" >", - L"[629][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME @ ] \"}\" >", - L"[630][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" @ >", - L"[631][_Property]< \"prop\" NAME \":\" _Type @ \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[632][_Property]< \"prop\" NAME @ \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", - L"[633][_StaticInit] BEGIN ", - L"[634][_StaticInit] END [ENDING]", - L"[635][_StaticInit]< \"static\" @ _Block >", - L"[636][_StaticInit]< \"static\" _Block @ >", - L"[637][_BaseConstructorCall] BEGIN ", - L"[638][_BaseConstructorCall] END [ENDING]", - L"[639][_BaseConstructorCall]< _Type \"(\" @ [ _Expression { \",\" _Expression } ] \")\" >", - L"[640][_BaseConstructorCall]< _Type \"(\" [ _Expression @ { \",\" _Expression } ] \")\" >", - L"[641][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" @ _Expression } ] \")\" >", - L"[642][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" _Expression @ } ] \")\" >", - L"[643][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" _Expression } ] \")\" @ >", - L"[644][_BaseConstructorCall]< _Type @ \"(\" [ _Expression { \",\" _Expression } ] \")\" >", - L"[645][_ConstructorType] BEGIN ", - L"[646][_ConstructorType] END [ENDING]", - L"[647][_ConstructorType]\"new\" \"*\" @", - L"[648][_ConstructorType]\"new\" @", - L"[649][_ConstructorType]\"new\" @ \"*\"", - L"[650][_Constructor] BEGIN ", - L"[651][_Constructor] END [ENDING]", - L"[652][_Constructor]< _ConstructorType \"(\" @ { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", - L"[653][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" @ } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", - L"[654][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" } \")\" @ [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", - L"[655][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" @ { _BaseConstructorCall ; \",\" } ] _Block >", - L"[656][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" @ } ] _Block >", - L"[657][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block @ >", - L"[658][_Constructor]< _ConstructorType \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall @ ; \",\" } ] _Block >", - L"[659][_Constructor]< _ConstructorType \"(\" { _FunctionArgument @ ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", - L"[660][_Constructor]< _ConstructorType @ \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", - L"[661][_Destructor] BEGIN ", - L"[662][_Destructor] END [ENDING]", - L"[663][_Destructor]< \"delete\" @ _Block >", - L"[664][_Destructor]< \"delete\" _Block @ >", - L"[665][_ClassBody] BEGIN ", - L"[666][_ClassBody] END [ENDING]", - L"[667][_ClassBody][ \":\" @ { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\"", - L"[668][_ClassBody][ \":\" { _Type ; \",\" @ } ] \"{\" { _Declaration } [ _StateMachine ] \"}\"", - L"[669][_ClassBody][ \":\" { _Type ; \",\" } ] \"{\" @ { _Declaration } [ _StateMachine ] \"}\"", - L"[670][_ClassBody][ \":\" { _Type ; \",\" } ] \"{\" { _Declaration @ } [ _StateMachine ] \"}\"", - L"[671][_ClassBody][ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine @ ] \"}\"", - L"[672][_ClassBody][ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" @", - L"[673][_ClassBody][ \":\" { _Type @ ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\"", - L"[674][_Class] BEGIN ", - L"[675][_Class] END [ENDING]", - L"[676][_Class]< \"class\" @ NAME _ClassBody >", - L"[677][_Class]< \"class\" NAME @ _ClassBody >", - L"[678][_Class]< \"class\" NAME _ClassBody @ >", - L"[679][_Class]< \"interface\" @ NAME \"*\" _ClassBody >", - L"[680][_Class]< \"interface\" @ NAME _ClassBody >", - L"[681][_Class]< \"interface\" NAME \"*\" @ _ClassBody >", - L"[682][_Class]< \"interface\" NAME \"*\" _ClassBody @ >", - L"[683][_Class]< \"interface\" NAME @ \"*\" _ClassBody >", - L"[684][_Class]< \"interface\" NAME @ _ClassBody >", - L"[685][_Class]< \"interface\" NAME _ClassBody @ >", - L"[686][_EnumItemInt] BEGIN ", - L"[687][_EnumItemInt] END [ENDING]", - L"[688][_EnumItemInt]< NAME @ >", - L"[689][_EnumItemA] BEGIN ", - L"[690][_EnumItemA] END [ENDING]", - L"[691][_EnumItemA]< { _Attribute @ } NAME \"=\" INTEGER \",\" >", - L"[692][_EnumItemA]< { _Attribute } NAME \"=\" @ INTEGER \",\" >", - L"[693][_EnumItemA]< { _Attribute } NAME \"=\" INTEGER \",\" @ >", - L"[694][_EnumItemA]< { _Attribute } NAME \"=\" INTEGER @ \",\" >", - L"[695][_EnumItemA]< { _Attribute } NAME @ \"=\" INTEGER \",\" >", - L"[696][_EnumItemB] BEGIN ", - L"[697][_EnumItemB] END [ENDING]", - L"[698][_EnumItemB]< { _Attribute @ } NAME \"=\" _EnumItemInt { \"|\" _EnumItemInt } \",\" >", - L"[699][_EnumItemB]< { _Attribute } NAME \"=\" @ _EnumItemInt { \"|\" _EnumItemInt } \",\" >", - L"[700][_EnumItemB]< { _Attribute } NAME \"=\" _EnumItemInt @ { \"|\" _EnumItemInt } \",\" >", - L"[701][_EnumItemB]< { _Attribute } NAME \"=\" _EnumItemInt { \"|\" @ _EnumItemInt } \",\" >", - L"[702][_EnumItemB]< { _Attribute } NAME \"=\" _EnumItemInt { \"|\" _EnumItemInt @ } \",\" >", - L"[703][_EnumItemB]< { _Attribute } NAME \"=\" _EnumItemInt { \"|\" _EnumItemInt } \",\" @ >", - L"[704][_EnumItemB]< { _Attribute } NAME @ \"=\" _EnumItemInt { \"|\" _EnumItemInt } \",\" >", - L"[705][_Enum] BEGIN ", - L"[706][_Enum] END [ENDING]", - L"[707][_Enum]< \"enum\" @ NAME \"{\" _EnumItemA { _EnumItemA } \"}\" >", - L"[708][_Enum]< \"enum\" NAME \"{\" @ _EnumItemA { _EnumItemA } \"}\" >", - L"[709][_Enum]< \"enum\" NAME \"{\" _EnumItemA @ { _EnumItemA } \"}\" >", - L"[710][_Enum]< \"enum\" NAME \"{\" _EnumItemA { _EnumItemA @ } \"}\" >", - L"[711][_Enum]< \"enum\" NAME \"{\" _EnumItemA { _EnumItemA } \"}\" @ >", - L"[712][_Enum]< \"enum\" NAME @ \"{\" _EnumItemA { _EnumItemA } \"}\" >", - L"[713][_Enum]< \"flagenum\" @ NAME \"{\" _EnumItemA { _EnumItemA } { _EnumItemB } \"}\" >", - L"[714][_Enum]< \"flagenum\" NAME \"{\" @ _EnumItemA { _EnumItemA } { _EnumItemB } \"}\" >", - L"[715][_Enum]< \"flagenum\" NAME \"{\" _EnumItemA @ { _EnumItemA } { _EnumItemB } \"}\" >", - L"[716][_Enum]< \"flagenum\" NAME \"{\" _EnumItemA { _EnumItemA @ } { _EnumItemB } \"}\" >", - L"[717][_Enum]< \"flagenum\" NAME \"{\" _EnumItemA { _EnumItemA } { _EnumItemB @ } \"}\" >", - L"[718][_Enum]< \"flagenum\" NAME \"{\" _EnumItemA { _EnumItemA } { _EnumItemB } \"}\" @ >", - L"[719][_Enum]< \"flagenum\" NAME @ \"{\" _EnumItemA { _EnumItemA } { _EnumItemB } \"}\" >", - L"[720][_StructMember] BEGIN ", - L"[721][_StructMember] END [ENDING]", - L"[722][_StructMember]< { _Attribute @ } NAME \":\" _Type \";\" >", - L"[723][_StructMember]< { _Attribute } NAME \":\" @ _Type \";\" >", - L"[724][_StructMember]< { _Attribute } NAME \":\" _Type \";\" @ >", - L"[725][_StructMember]< { _Attribute } NAME \":\" _Type @ \";\" >", - L"[726][_StructMember]< { _Attribute } NAME @ \":\" _Type \";\" >", - L"[727][_Struct] BEGIN ", - L"[728][_Struct] END [ENDING]", - L"[729][_Struct]< \"struct\" @ NAME \"{\" { _StructMember } \"}\" >", - L"[730][_Struct]< \"struct\" NAME \"{\" @ { _StructMember } \"}\" >", - L"[731][_Struct]< \"struct\" NAME \"{\" { _StructMember @ } \"}\" >", - L"[732][_Struct]< \"struct\" NAME \"{\" { _StructMember } \"}\" @ >", - L"[733][_Struct]< \"struct\" NAME @ \"{\" { _StructMember } \"}\" >", - L"[734][_APConfig] BEGIN ", - L"[735][_APConfig] END [ENDING]", - L"[736][_APConfig]\"{\" \"const\" \",\" \"not\" \"observe\" \"}\" @", - L"[737][_APConfig]\"{\" \"const\" \",\" \"not\" \"observe\" @ \"}\"", - L"[738][_APConfig]\"{\" \"const\" \",\" \"not\" @ \"observe\" \"}\"", - L"[739][_APConfig]\"{\" \"const\" \",\" @ \"not\" \"observe\" \"}\"", - L"[740][_APConfig]\"{\" \"const\" \"}\" @", - L"[741][_APConfig]\"{\" \"const\" @ \",\" \"not\" \"observe\" \"}\"", - L"[742][_APConfig]\"{\" \"const\" @ \"}\"", - L"[743][_APConfig]\"{\" \"not\" \"observe\" \"}\" @", - L"[744][_APConfig]\"{\" \"not\" \"observe\" @ \"}\"", - L"[745][_APConfig]\"{\" \"not\" @ \"observe\" \"}\"", - L"[746][_APConfig]\"{\" \"}\" @", - L"[747][_APConfig]\"{\" @ \"const\" \",\" \"not\" \"observe\" \"}\"", - L"[748][_APConfig]\"{\" @ \"const\" \"}\"", - L"[749][_APConfig]\"{\" @ \"not\" \"observe\" \"}\"", - L"[750][_APConfig]\"{\" @ \"}\"", - L"[751][_AutoPropertyKind] BEGIN ", - L"[752][_AutoPropertyKind] END [ENDING]", - L"[753][_AutoPropertyKind]\"override\" \"prop\" @", - L"[754][_AutoPropertyKind]\"override\" @ \"prop\"", - L"[755][_AutoPropertyKind]\"prop\" @", - L"[756][_AutoPropertyKind]\"static\" \"prop\" @", - L"[757][_AutoPropertyKind]\"static\" @ \"prop\"", - L"[758][_AutoProperty] BEGIN ", - L"[759][_AutoProperty] END [ENDING]", - L"[760][_AutoProperty]< _AutoPropertyKind @ NAME \":\" _Type [ \"=\" _Expression ] _APConfig >", - L"[761][_AutoProperty]< _AutoPropertyKind NAME \":\" @ _Type [ \"=\" _Expression ] _APConfig >", - L"[762][_AutoProperty]< _AutoPropertyKind NAME \":\" _Type @ [ \"=\" _Expression ] _APConfig >", - L"[763][_AutoProperty]< _AutoPropertyKind NAME \":\" _Type [ \"=\" @ _Expression ] _APConfig >", - L"[764][_AutoProperty]< _AutoPropertyKind NAME \":\" _Type [ \"=\" _Expression @ ] _APConfig >", - L"[765][_AutoProperty]< _AutoPropertyKind NAME \":\" _Type [ \"=\" _Expression ] _APConfig @ >", - L"[766][_AutoProperty]< _AutoPropertyKind NAME @ \":\" _Type [ \"=\" _Expression ] _APConfig >", - L"[767][_CastResultInterface] BEGIN ", - L"[768][_CastResultInterface] END [ENDING]", - L"[769][_CastResultInterface]< \"$interface\" @ NAME \":\" _Type \"<\" _Type \">\" \";\" >", - L"[770][_CastResultInterface]< \"$interface\" NAME \":\" @ _Type \"<\" _Type \">\" \";\" >", - L"[771][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" @ _Type \">\" \";\" >", - L"[772][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type \">\" \";\" @ >", - L"[773][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type \">\" @ \";\" >", - L"[774][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type @ \">\" \";\" >", - L"[775][_CastResultInterface]< \"$interface\" NAME \":\" _Type @ \"<\" _Type \">\" \";\" >", - L"[776][_CastResultInterface]< \"$interface\" NAME @ \":\" _Type \"<\" _Type \">\" \";\" >", - L"[777][_DeclarationCandidates] BEGIN ", - L"[778][_DeclarationCandidates] END [ENDING]", - L"[779][_DeclarationCandidates]<< !_AutoProperty @ >>", - L"[780][_DeclarationCandidates]<< !_CastResultInterface @ >>", - L"[781][_DeclarationCandidates]<< !_Class @ >>", - L"[782][_DeclarationCandidates]<< !_Constructor @ >>", - L"[783][_DeclarationCandidates]<< !_Destructor @ >>", - L"[784][_DeclarationCandidates]<< !_Enum @ >>", - L"[785][_DeclarationCandidates]<< !_Event @ >>", - L"[786][_DeclarationCandidates]<< !_Function @ >>", - L"[787][_DeclarationCandidates]<< !_Namespace @ >>", - L"[788][_DeclarationCandidates]<< !_Property @ >>", - L"[789][_DeclarationCandidates]<< !_StaticInit @ >>", - L"[790][_DeclarationCandidates]<< !_Struct @ >>", - L"[791][_DeclarationCandidates]<< !_Variable @ >>", - L"[792][_Declaration] BEGIN ", - L"[793][_Declaration] END [ENDING]", - L"[794][_Declaration]<< { _Attribute @ } !_DeclarationCandidates >>", - L"[795][_Declaration]<< { _Attribute } !_DeclarationCandidates @ >>", - L"[796][_UsingFragment] BEGIN ", - L"[797][_UsingFragment] END [ENDING]", - L"[798][_UsingFragment]< \"*\" @ >", - L"[799][_UsingFragment]< NAME @ >", - L"[800][_UsingItem] BEGIN ", - L"[801][_UsingItem] END [ENDING]", - L"[802][_UsingItem]< _UsingFragment @ { _UsingFragment } >", - L"[803][_UsingItem]< _UsingFragment { _UsingFragment @ } >", - L"[804][_UsingPath] BEGIN ", - L"[805][_UsingPath] END [ENDING]", - L"[806][_UsingPath]< \"using\" @ _UsingItem { \"::\" _UsingItem } \";\" >", - L"[807][_UsingPath]< \"using\" _UsingItem @ { \"::\" _UsingItem } \";\" >", - L"[808][_UsingPath]< \"using\" _UsingItem { \"::\" @ _UsingItem } \";\" >", - L"[809][_UsingPath]< \"using\" _UsingItem { \"::\" _UsingItem @ } \";\" >", - L"[810][_UsingPath]< \"using\" _UsingItem { \"::\" _UsingItem } \";\" @ >", - L"[811][_ModuleBody] BEGIN ", - L"[812][_ModuleBody] END [ENDING]", - L"[813][_ModuleBody]NAME \";\" @ { _UsingPath } { _Declaration }", - L"[814][_ModuleBody]NAME \";\" { _UsingPath @ } { _Declaration }", - L"[815][_ModuleBody]NAME \";\" { _UsingPath } { _Declaration @ }", - L"[816][_ModuleBody]NAME @ \";\" { _UsingPath } { _Declaration }", - L"[817][_Module] BEGIN ", - L"[818][_Module] END [ENDING]", - L"[819][_Module]< \"module\" @ _ModuleBody >", - L"[820][_Module]< \"module\" _ModuleBody @ >", - L"[821][_Module]< \"unit\" @ _ModuleBody >", - L"[822][_Module]< \"unit\" _ModuleBody @ >", + L"[81][_ExpPrimitive] BEGIN ", + L"[82][_ExpPrimitive] END [ENDING]", + L"[83][_ExpPrimitive]< \"::\" @ NAME >", + L"[84][_ExpPrimitive]< \"::\" NAME @ >", + L"[85][_ExpPrimitive]< \"[\" @ _Expression \"]\" >", + L"[86][_ExpPrimitive]< \"[\" _Expression \"]\" @ >", + L"[87][_ExpPrimitive]< \"[\" _Expression @ \"]\" >", + L"[88][_ExpPrimitive]< \"attach\" \"(\" @ _Expression \",\" _Expression \")\" >", + L"[89][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" @ _Expression \")\" >", + L"[90][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" _Expression \")\" @ >", + L"[91][_ExpPrimitive]< \"attach\" \"(\" _Expression \",\" _Expression @ \")\" >", + L"[92][_ExpPrimitive]< \"attach\" \"(\" _Expression @ \",\" _Expression \")\" >", + L"[93][_ExpPrimitive]< \"attach\" @ \"(\" _Expression \",\" _Expression \")\" >", + L"[94][_ExpPrimitive]< \"detach\" \"(\" @ _Expression \",\" _Expression \")\" >", + L"[95][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" @ _Expression \")\" >", + L"[96][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" _Expression \")\" @ >", + L"[97][_ExpPrimitive]< \"detach\" \"(\" _Expression \",\" _Expression @ \")\" >", + L"[98][_ExpPrimitive]< \"detach\" \"(\" _Expression @ \",\" _Expression \")\" >", + L"[99][_ExpPrimitive]< \"detach\" @ \"(\" _Expression \",\" _Expression \")\" >", + L"[100][_ExpPrimitive]< \"false\" @ >", + L"[101][_ExpPrimitive]< \"let\" @ _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" >", + L"[102][_ExpPrimitive]< \"let\" _LetVariable @ { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" >", + L"[103][_ExpPrimitive]< \"let\" _LetVariable { \",\" @ _LetVariable } \"in\" \"(\" _Expression \")\" >", + L"[104][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable @ } \"in\" \"(\" _Expression \")\" >", + L"[105][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" @ _Expression \")\" >", + L"[106][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression \")\" @ >", + L"[107][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" \"(\" _Expression @ \")\" >", + L"[108][_ExpPrimitive]< \"let\" _LetVariable { \",\" _LetVariable } \"in\" @ \"(\" _Expression \")\" >", + L"[109][_ExpPrimitive]< \"new\" _Type \"(\" @ { _Expression ; \",\" } \")\" >", + L"[110][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression ; \",\" @ } \")\" >", + L"[111][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression ; \",\" } \")\" @ >", + L"[112][_ExpPrimitive]< \"new\" _Type \"(\" { _Expression @ ; \",\" } \")\" >", + L"[113][_ExpPrimitive]< \"new\" _Type \"{\" @ { _Declaration } \"}\" >", + L"[114][_ExpPrimitive]< \"new\" _Type \"{\" { _Declaration @ } \"}\" >", + L"[115][_ExpPrimitive]< \"new\" _Type \"{\" { _Declaration } \"}\" @ >", + L"[116][_ExpPrimitive]< \"null\" @ >", + L"[117][_ExpPrimitive]< \"range\" ( \"(\" @ | \"[\" ) _Expression \",\" _Expression ( \")\" | \"]\" ) >", + L"[118][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" ) _Expression \",\" @ _Expression ( \")\" | \"]\" ) >", + L"[119][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" ) _Expression \",\" _Expression ( \")\" @ | \"]\" ) >", + L"[120][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" ) _Expression \",\" _Expression ( \")\" | \"]\" @ ) >", + L"[121][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" ) _Expression \",\" _Expression @ ( \")\" | \"]\" ) >", + L"[122][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" ) _Expression @ \",\" _Expression ( \")\" | \"]\" ) >", + L"[123][_ExpPrimitive]< \"range\" ( \"(\" | \"[\" @ ) _Expression \",\" _Expression ( \")\" | \"]\" ) >", + L"[124][_ExpPrimitive]< \"range\" @ ( \"(\" | \"[\" ) _Expression \",\" _Expression ( \")\" | \"]\" ) >", + L"[125][_ExpPrimitive]< \"this\" @ >", + L"[126][_ExpPrimitive]< \"true\" @ >", + L"[127][_ExpPrimitive]< \"type\" \"(\" @ _Expression \")\" >", + L"[128][_ExpPrimitive]< \"type\" \"(\" _Expression \")\" @ >", + L"[129][_ExpPrimitive]< \"type\" \"(\" _Expression @ \")\" >", + L"[130][_ExpPrimitive]< \"type\" @ \"(\" _Expression \")\" >", + L"[131][_ExpPrimitive]< \"typeof\" \"(\" @ _Type \")\" >", + L"[132][_ExpPrimitive]< \"typeof\" \"(\" _Type \")\" @ >", + L"[133][_ExpPrimitive]< \"typeof\" \"(\" _Type @ \")\" >", + L"[134][_ExpPrimitive]< \"typeof\" @ \"(\" _Type \")\" >", + L"[135][_ExpPrimitive]< \"{\" @ [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", + L"[136][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment @ } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", + L"[137][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" @ _CtorFragment } \";\" ) ] \"}\" >", + L"[138][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment @ } \";\" ) ] \"}\" >", + L"[139][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" @ >", + L"[140][_ExpPrimitive]< \"{\" [ _CtorFragment ( { _CtorFragment } | { \";\" _CtorFragment } \";\" @ ) ] \"}\" >", + L"[141][_ExpPrimitive]< \"{\" [ _CtorFragment @ ( { _CtorFragment } | { \";\" _CtorFragment } \";\" ) ] \"}\" >", + L"[142][_ExpPrimitive]< FLOAT @ >", + L"[143][_ExpPrimitive]< INTEGER @ >", + L"[144][_ExpPrimitive]< NAME @ >", + L"[145][_ExpPrimitive]< ORDERED_NAME @ >", + L"[146][_ExpPrimitive]< STRING @ >", + L"[147][_ExpPrimitive]< _ExpPrimitive \"(\" @ [ _Expression { \",\" _Expression } ] \")\" >", + L"[148][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression @ { \",\" _Expression } ] \")\" >", + L"[149][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" @ _Expression } ] \")\" >", + L"[150][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" _Expression @ } ] \")\" >", + L"[151][_ExpPrimitive]< _ExpPrimitive \"(\" [ _Expression { \",\" _Expression } ] \")\" @ >", + L"[152][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" @ _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[153][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression @ [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[154][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" @ _Expression { \",\" _Expression } ] \")\" >", + L"[155][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression @ { \",\" _Expression } ] \")\" >", + L"[156][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" @ _Expression } ] \")\" >", + L"[157][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression @ } ] \")\" >", + L"[158][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" @ >", + L"[159][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" @ NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[160][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" @ _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[161][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression @ [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[162][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" @ _Expression { \",\" _Expression } ] \")\" >", + L"[163][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression @ { \",\" _Expression } ] \")\" >", + L"[164][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" @ _Expression } ] \")\" >", + L"[165][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression @ } ] \")\" >", + L"[166][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" @ >", + L"[167][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" \"as\" NAME @ \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[168][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" @ \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[169][_ExpPrimitive]< _ExpPrimitive \".\" \"observe\" @ \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[170][_ExpPrimitive]< _ExpPrimitive \".\" @ \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[171][_ExpPrimitive]< _ExpPrimitive \".\" @ \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[172][_ExpPrimitive]< _ExpPrimitive \".\" @ NAME >", + L"[173][_ExpPrimitive]< _ExpPrimitive \".\" NAME @ >", + L"[174][_ExpPrimitive]< _ExpPrimitive \"::\" @ NAME >", + L"[175][_ExpPrimitive]< _ExpPrimitive \"::\" NAME @ >", + L"[176][_ExpPrimitive]< _ExpPrimitive \"[\" @ _Expression \"]\" >", + L"[177][_ExpPrimitive]< _ExpPrimitive \"[\" _Expression \"]\" @ >", + L"[178][_ExpPrimitive]< _ExpPrimitive \"[\" _Expression @ \"]\" >", + L"[179][_ExpPrimitive]< _ExpPrimitive \"as\" \"*\" @ >", + L"[180][_ExpPrimitive]< _ExpPrimitive \"as\" @ \"*\" >", + L"[181][_ExpPrimitive]< _ExpPrimitive \"as\" @ _Type >", + L"[182][_ExpPrimitive]< _ExpPrimitive \"as\" _Type @ >", + L"[183][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" \"null\" @ >", + L"[184][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" @ \"null\" >", + L"[185][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" @ _Type >", + L"[186][_ExpPrimitive]< _ExpPrimitive \"is\" \"not\" _Type @ >", + L"[187][_ExpPrimitive]< _ExpPrimitive \"is\" \"null\" @ >", + L"[188][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"not\" \"null\" >", + L"[189][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"not\" _Type >", + L"[190][_ExpPrimitive]< _ExpPrimitive \"is\" @ \"null\" >", + L"[191][_ExpPrimitive]< _ExpPrimitive \"is\" @ _Type >", + L"[192][_ExpPrimitive]< _ExpPrimitive \"is\" _Type @ >", + L"[193][_ExpPrimitive]< _ExpPrimitive \"of\" @ _Type >", + L"[194][_ExpPrimitive]< _ExpPrimitive \"of\" _Type @ >", + L"[195][_ExpPrimitive]< _ExpPrimitive ( \"in\" @ | \"not\" \"in\" ) _Expression >", + L"[196][_ExpPrimitive]< _ExpPrimitive ( \"in\" | \"not\" \"in\" ) _Expression @ >", + L"[197][_ExpPrimitive]< _ExpPrimitive ( \"in\" | \"not\" \"in\" @ ) _Expression >", + L"[198][_ExpPrimitive]< _ExpPrimitive ( \"in\" | \"not\" @ \"in\" ) _Expression >", + L"[199][_ExpPrimitive]< _ExpPrimitive @ \"(\" [ _Expression { \",\" _Expression } ] \")\" >", + L"[200][_ExpPrimitive]< _ExpPrimitive @ \".\" \"observe\" \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[201][_ExpPrimitive]< _ExpPrimitive @ \".\" \"observe\" \"as\" NAME \"(\" _Expression [ \"on\" _Expression { \",\" _Expression } ] \")\" >", + L"[202][_ExpPrimitive]< _ExpPrimitive @ \".\" NAME >", + L"[203][_ExpPrimitive]< _ExpPrimitive @ \"::\" NAME >", + L"[204][_ExpPrimitive]< _ExpPrimitive @ \"[\" _Expression \"]\" >", + L"[205][_ExpPrimitive]< _ExpPrimitive @ \"as\" \"*\" >", + L"[206][_ExpPrimitive]< _ExpPrimitive @ \"as\" _Type >", + L"[207][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"not\" \"null\" >", + L"[208][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"not\" _Type >", + L"[209][_ExpPrimitive]< _ExpPrimitive @ \"is\" \"null\" >", + L"[210][_ExpPrimitive]< _ExpPrimitive @ \"is\" _Type >", + L"[211][_ExpPrimitive]< _ExpPrimitive @ \"of\" _Type >", + L"[212][_ExpPrimitive]< _ExpPrimitive @ ( \"in\" | \"not\" \"in\" ) _Expression >", + L"[213][_ExpPrimitive]< _Function @ >", + L"[214][_ExpPrimitive]", + L"[215][_ExpPrimitive]", + L"[216][_ExpPrimitive]", + L"[217][_ExpPrimitive]", + L"[218][_ExpPrimitive]{{< \"new\" @ _Type \"(\" { _Expression ; \",\" } \")\" > ; < \"new\" @ _Type \"{\" { _Declaration } \"}\" >}}", + L"[219][_ExpPrimitive]{{< \"new\" _Type @ \"(\" { _Expression ; \",\" } \")\" > ; < \"new\" _Type @ \"{\" { _Declaration } \"}\" >}}", + L"[220][_Exp0] BEGIN ", + L"[221][_Exp0] END [ENDING]", + L"[222][_Exp0]< \"+\" @ _Exp0 >", + L"[223][_Exp0]< \"+\" _Exp0 @ >", + L"[224][_Exp0]< \"-\" @ _Exp0 >", + L"[225][_Exp0]< \"-\" _Exp0 @ >", + L"[226][_Exp0]< \"cast\" \"*\" @ _Exp0 >", + L"[227][_Exp0]< \"cast\" \"*\" _Exp0 @ >", + L"[228][_Exp0]< \"cast\" _Type @ _Exp0 >", + L"[229][_Exp0]< \"cast\" _Type _Exp0 @ >", + L"[230][_Exp0]< \"not\" @ _Exp0 >", + L"[231][_Exp0]< \"not\" _Exp0 @ >", + L"[232][_Exp0]", + L"[233][_Exp0]{{< \"cast\" @ \"*\" _Exp0 > ; < \"cast\" @ _Type _Exp0 >}}", + L"[234][_Exp1] BEGIN ", + L"[235][_Exp1] END [ENDING]", + L"[236][_Exp1]< _Exp1 \"^\" @ _Exp0 >", + L"[237][_Exp1]< _Exp1 \"^\" _Exp0 @ >", + L"[238][_Exp1]< _Exp1 @ \"^\" _Exp0 >", + L"[239][_Exp1]", + L"[240][_Exp2] BEGIN ", + L"[241][_Exp2] END [ENDING]", + L"[242][_Exp2]< _Exp2 \"%\" @ _Exp1 >", + L"[243][_Exp2]< _Exp2 \"%\" _Exp1 @ >", + L"[244][_Exp2]< _Exp2 \"*\" @ _Exp1 >", + L"[245][_Exp2]< _Exp2 \"*\" _Exp1 @ >", + L"[246][_Exp2]< _Exp2 \"/\" @ _Exp1 >", + L"[247][_Exp2]< _Exp2 \"/\" _Exp1 @ >", + L"[248][_Exp2]< _Exp2 @ \"%\" _Exp1 >", + L"[249][_Exp2]< _Exp2 @ \"*\" _Exp1 >", + L"[250][_Exp2]< _Exp2 @ \"/\" _Exp1 >", + L"[251][_Exp2]", + L"[252][_Exp3] BEGIN ", + L"[253][_Exp3] END [ENDING]", + L"[254][_Exp3]< _Exp3 \"&\" @ _Exp2 >", + L"[255][_Exp3]< _Exp3 \"&\" _Exp2 @ >", + L"[256][_Exp3]< _Exp3 \"+\" @ _Exp2 >", + L"[257][_Exp3]< _Exp3 \"+\" _Exp2 @ >", + L"[258][_Exp3]< _Exp3 \"-\" @ _Exp2 >", + L"[259][_Exp3]< _Exp3 \"-\" _Exp2 @ >", + L"[260][_Exp3]< _Exp3 \"|\" @ _Exp2 >", + L"[261][_Exp3]< _Exp3 \"|\" _Exp2 @ >", + L"[262][_Exp3]< _Exp3 @ \"&\" _Exp2 >", + L"[263][_Exp3]< _Exp3 @ \"+\" _Exp2 >", + L"[264][_Exp3]< _Exp3 @ \"-\" _Exp2 >", + L"[265][_Exp3]< _Exp3 @ \"|\" _Exp2 >", + L"[266][_Exp3]", + L"[267][_Exp4] BEGIN ", + L"[268][_Exp4] END [ENDING]", + L"[269][_Exp4]< _Exp4 \"shl\" @ _Exp3 >", + L"[270][_Exp4]< _Exp4 \"shl\" _Exp3 @ >", + L"[271][_Exp4]< _Exp4 \"shr\" @ _Exp3 >", + L"[272][_Exp4]< _Exp4 \"shr\" _Exp3 @ >", + L"[273][_Exp4]< _Exp4 @ \"shl\" _Exp3 >", + L"[274][_Exp4]< _Exp4 @ \"shr\" _Exp3 >", + L"[275][_Exp4]", + L"[276][_Exp5] BEGIN ", + L"[277][_Exp5] END [ENDING]", + L"[278][_Exp5]< _Exp5 \"!=\" @ _Exp4 >", + L"[279][_Exp5]< _Exp5 \"!=\" _Exp4 @ >", + L"[280][_Exp5]< _Exp5 \"<\" @ _Exp4 >", + L"[281][_Exp5]< _Exp5 \"<\" _Exp4 @ >", + L"[282][_Exp5]< _Exp5 \"<=\" @ _Exp4 >", + L"[283][_Exp5]< _Exp5 \"<=\" _Exp4 @ >", + L"[284][_Exp5]< _Exp5 \"==\" @ _Exp4 >", + L"[285][_Exp5]< _Exp5 \"==\" _Exp4 @ >", + L"[286][_Exp5]< _Exp5 \">\" @ _Exp4 >", + L"[287][_Exp5]< _Exp5 \">\" _Exp4 @ >", + L"[288][_Exp5]< _Exp5 \">=\" @ _Exp4 >", + L"[289][_Exp5]< _Exp5 \">=\" _Exp4 @ >", + L"[290][_Exp5]< _Exp5 @ \"!=\" _Exp4 >", + L"[291][_Exp5]< _Exp5 @ \"<\" _Exp4 >", + L"[292][_Exp5]< _Exp5 @ \"<=\" _Exp4 >", + L"[293][_Exp5]< _Exp5 @ \"==\" _Exp4 >", + L"[294][_Exp5]< _Exp5 @ \">\" _Exp4 >", + L"[295][_Exp5]< _Exp5 @ \">=\" _Exp4 >", + L"[296][_Exp5]", + L"[297][_Exp6] BEGIN ", + L"[298][_Exp6] END [ENDING]", + L"[299][_Exp6]< _Exp6 \"xor\" @ _Exp5 >", + L"[300][_Exp6]< _Exp6 \"xor\" _Exp5 @ >", + L"[301][_Exp6]< _Exp6 @ \"xor\" _Exp5 >", + L"[302][_Exp6]", + L"[303][_Exp7] BEGIN ", + L"[304][_Exp7] END [ENDING]", + L"[305][_Exp7]< _Exp7 \"and\" @ _Exp6 >", + L"[306][_Exp7]< _Exp7 \"and\" _Exp6 @ >", + L"[307][_Exp7]< _Exp7 @ \"and\" _Exp6 >", + L"[308][_Exp7]", + L"[309][_Exp8] BEGIN ", + L"[310][_Exp8] END [ENDING]", + L"[311][_Exp8]< _Exp8 \"or\" @ _Exp7 >", + L"[312][_Exp8]< _Exp8 \"or\" _Exp7 @ >", + L"[313][_Exp8]< _Exp8 @ \"or\" _Exp7 >", + L"[314][_Exp8]", + L"[315][_Exp9] BEGIN ", + L"[316][_Exp9] END [ENDING]", + L"[317][_Exp9]< _Exp9 \"??\" @ _Exp8 >", + L"[318][_Exp9]< _Exp9 \"??\" _Exp8 @ >", + L"[319][_Exp9]< _Exp9 @ \"??\" _Exp8 >", + L"[320][_Exp9]", + L"[321][_Exp10] BEGIN ", + L"[322][_Exp10] BEGIN [pm-lr]", + L"[323][_Exp10] END [ENDING]", + L"[324][_Exp10]< _Exp9 \"?\" @ _Exp10 \":\" _Exp10 >", + L"[325][_Exp10]< _Exp9 \"?\" _Exp10 \":\" @ _Exp10 >", + L"[326][_Exp10]< _Exp9 \"?\" _Exp10 \":\" _Exp10 @ >", + L"[327][_Exp10]< _Exp9 \"?\" _Exp10 @ \":\" _Exp10 >", + L"[328][_Exp10]< _Exp9 @ \"?\" _Exp10 \":\" _Exp10 >", + L"[329][_Exp11] BEGIN ", + L"[330][_Exp11] BEGIN [pm-lr]", + L"[331][_Exp11] END [ENDING]", + L"[332][_Exp11]< _Exp10 \"=\" @ _Exp11 >", + L"[333][_Exp11]< _Exp10 \"=\" _Exp11 @ >", + L"[334][_Exp11]< _Exp10 @ \"=\" _Exp11 >", + L"[335][_Expression] BEGIN ", + L"[336][_Expression] END [ENDING]", + L"[337][_Expression]", + L"[338][_SwitchCase] BEGIN ", + L"[339][_SwitchCase] END [ENDING]", + L"[340][_SwitchCase]< \"case\" @ _Expression \":\" _Block >", + L"[341][_SwitchCase]< \"case\" _Expression \":\" @ _Block >", + L"[342][_SwitchCase]< \"case\" _Expression \":\" _Block @ >", + L"[343][_SwitchCase]< \"case\" _Expression @ \":\" _Block >", + L"[344][_Block] BEGIN ", + L"[345][_Block] END [ENDING]", + L"[346][_Block]< \"{\" @ { _Statement } [ NAME \":\" \";\" ] \"}\" >", + L"[347][_Block]< \"{\" { _Statement @ } [ NAME \":\" \";\" ] \"}\" >", + L"[348][_Block]< \"{\" { _Statement } [ NAME \":\" \";\" @ ] \"}\" >", + L"[349][_Block]< \"{\" { _Statement } [ NAME \":\" \";\" ] \"}\" @ >", + L"[350][_Block]< \"{\" { _Statement } [ NAME \":\" @ \";\" ] \"}\" >", + L"[351][_Block]< \"{\" { _Statement } [ NAME @ \":\" \";\" ] \"}\" >", + L"[352][_ElseStat] BEGIN ", + L"[353][_ElseStat] END [ENDING]", + L"[354][_ElseStat]", + L"[355][_ElseStat]", + L"[356][_If] BEGIN ", + L"[357][_If] END [ENDING]", + L"[358][_If]< \"if\" \"(\" @ [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[359][_If]< \"if\" \"(\" [ \"var\" @ NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[360][_If]< \"if\" \"(\" [ \"var\" NAME \":\" @ _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[361][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" @ ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[362][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" @ _Block +[ \"else\" _ElseStat ] >", + L"[363][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" @ _ElseStat ] >", + L"[364][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat @ ] >", + L"[365][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block @ +[ \"else\" _ElseStat ] >", + L"[366][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression @ \")\" _Block +[ \"else\" _ElseStat ] >", + L"[367][_If]< \"if\" \"(\" [ \"var\" NAME \":\" _Type @ \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[368][_If]< \"if\" \"(\" [ \"var\" NAME @ \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[369][_If]< \"if\" @ \"(\" [ \"var\" NAME \":\" _Type \"=\" ] _Expression \")\" _Block +[ \"else\" _ElseStat ] >", + L"[370][_VirtualStatement] BEGIN ", + L"[371][_VirtualStatement] END [ENDING]", + L"[372][_VirtualStatement]< \"for\" \"(\" @ NAME ( \"in\" | \"in\" \"reversed\" ) _Expression \")\" _Block >", + L"[373][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" @ | \"in\" \"reversed\" ) _Expression \")\" _Block >", + L"[374][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" | \"in\" \"reversed\" ) _Expression \")\" @ _Block >", + L"[375][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" | \"in\" \"reversed\" ) _Expression \")\" _Block @ >", + L"[376][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" | \"in\" \"reversed\" ) _Expression @ \")\" _Block >", + L"[377][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" | \"in\" \"reversed\" @ ) _Expression \")\" _Block >", + L"[378][_VirtualStatement]< \"for\" \"(\" NAME ( \"in\" | \"in\" @ \"reversed\" ) _Expression \")\" _Block >", + L"[379][_VirtualStatement]< \"for\" \"(\" NAME @ ( \"in\" | \"in\" \"reversed\" ) _Expression \")\" _Block >", + L"[380][_VirtualStatement]< \"for\" @ \"(\" NAME ( \"in\" | \"in\" \"reversed\" ) _Expression \")\" _Block >", + L"[381][_VirtualStatement]< \"switch\" \"(\" @ _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", + L"[382][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" @ { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", + L"[383][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase @ } [ \"default\" \":\" _Block ] \"}\" >", + L"[384][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" @ _Block ] \"}\" >", + L"[385][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block @ ] \"}\" >", + L"[386][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" @ >", + L"[387][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" @ \":\" _Block ] \"}\" >", + L"[388][_VirtualStatement]< \"switch\" \"(\" _Expression \")\" @ \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", + L"[389][_VirtualStatement]< \"switch\" \"(\" _Expression @ \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", + L"[390][_VirtualStatement]< \"switch\" @ \"(\" _Expression \")\" \"{\" { _SwitchCase } [ \"default\" \":\" _Block ] \"}\" >", + L"[391][_CoStatement] BEGIN ", + L"[392][_CoStatement] END [ENDING]", + L"[393][_CoStatement]< \"$pause\" ( \";\" @ | _Block ) >", + L"[394][_CoStatement]< \"$pause\" ( \";\" | _Block @ ) >", + L"[395][_CoStatement]< \"$pause\" @ ( \";\" | _Block ) >", + L"[396][_CoStatement]< [ \"var\" @ NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", + L"[397][_CoStatement]< [ \"var\" NAME \"=\" @ ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", + L"[398][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR @ { _Expression ; \",\" } \";\" >", + L"[399][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" @ } \";\" >", + L"[400][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" @ >", + L"[401][_CoStatement]< [ \"var\" NAME \"=\" ] COROUTINE_OPERATOR { _Expression @ ; \",\" } \";\" >", + L"[402][_CoStatement]< [ \"var\" NAME @ \"=\" ] COROUTINE_OPERATOR { _Expression ; \",\" } \";\" >", + L"[403][_CoProvider] BEGIN ", + L"[404][_CoProvider] END [ENDING]", + L"[405][_CoProvider]< ( \"$\" @ | COROUTINE_OPERATOR ) _Block >", + L"[406][_CoProvider]< ( \"$\" | COROUTINE_OPERATOR ) _Block @ >", + L"[407][_CoProvider]< ( \"$\" | COROUTINE_OPERATOR @ ) _Block >", + L"[408][_StateSwitchHead] BEGIN ", + L"[409][_StateSwitchHead] END [ENDING]", + L"[410][_StateSwitchHead]< \"$switch\" \"(\" \")\" @ >", + L"[411][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \")\" @ >", + L"[412][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" \"return\" \")\" @ >", + L"[413][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" \"return\" @ \")\" >", + L"[414][_StateSwitchHead]< \"$switch\" \"(\" \"continue\" \",\" @ \"return\" \")\" >", + L"[415][_StateSwitchHead]< \"$switch\" \"(\" \"raise\" \")\" @ >", + L"[416][_StateSwitchHead]< \"$switch\" \"(\" \"raise\" @ \")\" >", + L"[417][_StateSwitchHead]< \"$switch\" \"(\" \"return\" \")\" @ >", + L"[418][_StateSwitchHead]< \"$switch\" \"(\" \"return\" @ \")\" >", + L"[419][_StateSwitchHead]{{< \"$switch\" \"(\" \"continue\" @ \")\" > ; < \"$switch\" \"(\" \"continue\" @ \",\" \"return\" \")\" >}}", + L"[420][_StateSwitchHead]{{< \"$switch\" \"(\" @ \")\" > ; < \"$switch\" \"(\" @ \"continue\" \")\" > ; < \"$switch\" \"(\" @ \"continue\" \",\" \"return\" \")\" > ; < \"$switch\" \"(\" @ \"raise\" \")\" > ; < \"$switch\" \"(\" @ \"return\" \")\" >}}", + L"[421][_StateSwitchHead]{{< \"$switch\" @ \"(\" \")\" > ; < \"$switch\" @ \"(\" \"continue\" \")\" > ; < \"$switch\" @ \"(\" \"continue\" \",\" \"return\" \")\" > ; < \"$switch\" @ \"(\" \"raise\" \")\" > ; < \"$switch\" @ \"(\" \"return\" \")\" >}}", + L"[422][_StateSwitchArgument] BEGIN ", + L"[423][_StateSwitchArgument] END [ENDING]", + L"[424][_StateSwitchArgument]< NAME @ >", + L"[425][_StateSwitchCase] BEGIN ", + L"[426][_StateSwitchCase] END [ENDING]", + L"[427][_StateSwitchCase]< \"case\" @ NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", + L"[428][_StateSwitchCase]< \"case\" NAME \"(\" @ [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", + L"[429][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument @ { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", + L"[430][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" @ _StateSwitchArgument } ] \")\" \":\" _Block >", + L"[431][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument @ } ] \")\" \":\" _Block >", + L"[432][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" @ _Block >", + L"[433][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block @ >", + L"[434][_StateSwitchCase]< \"case\" NAME \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" @ \":\" _Block >", + L"[435][_StateSwitchCase]< \"case\" NAME @ \"(\" [ _StateSwitchArgument { \",\" _StateSwitchArgument } ] \")\" \":\" _Block >", + L"[436][_StateStatement] BEGIN ", + L"[437][_StateStatement] END [ENDING]", + L"[438][_StateStatement]< \"$goto_state\" @ NAME \"(\" { _Expression ; \",\" } \")\" \";\" >", + L"[439][_StateStatement]< \"$goto_state\" NAME \"(\" @ { _Expression ; \",\" } \")\" \";\" >", + L"[440][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" @ } \")\" \";\" >", + L"[441][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" } \")\" \";\" @ >", + L"[442][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression ; \",\" } \")\" @ \";\" >", + L"[443][_StateStatement]< \"$goto_state\" NAME \"(\" { _Expression @ ; \",\" } \")\" \";\" >", + L"[444][_StateStatement]< \"$goto_state\" NAME @ \"(\" { _Expression ; \",\" } \")\" \";\" >", + L"[445][_StateStatement]< \"$push_state\" @ NAME \"(\" { _Expression ; \",\" } \")\" \";\" >", + L"[446][_StateStatement]< \"$push_state\" NAME \"(\" @ { _Expression ; \",\" } \")\" \";\" >", + L"[447][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" @ } \")\" \";\" >", + L"[448][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" } \")\" \";\" @ >", + L"[449][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression ; \",\" } \")\" @ \";\" >", + L"[450][_StateStatement]< \"$push_state\" NAME \"(\" { _Expression @ ; \",\" } \")\" \";\" >", + L"[451][_StateStatement]< \"$push_state\" NAME @ \"(\" { _Expression ; \",\" } \")\" \";\" >", + L"[452][_StateStatement]", + L"[453][_StateStatement]", + L"[454][_StateStatement]", + L"[455][_StateStatement]", + L"[456][_Statement] BEGIN ", + L"[457][_Statement] END [ENDING]", + L"[458][_Statement]< \"break\" \";\" @ >", + L"[459][_Statement]< \"break\" @ \";\" >", + L"[460][_Statement]< \"continue\" \";\" @ >", + L"[461][_Statement]< \"continue\" @ \";\" >", + L"[462][_Statement]< \"delete\" @ _Expression \";\" >", + L"[463][_Statement]< \"delete\" _Expression \";\" @ >", + L"[464][_Statement]< \"delete\" _Expression @ \";\" >", + L"[465][_Statement]< \"goto\" @ NAME \";\" >", + L"[466][_Statement]< \"goto\" NAME \";\" @ >", + L"[467][_Statement]< \"goto\" NAME @ \";\" >", + L"[468][_Statement]< \"raise\" @ [ _Expression ] \";\" >", + L"[469][_Statement]< \"raise\" [ _Expression @ ] \";\" >", + L"[470][_Statement]< \"raise\" [ _Expression ] \";\" @ >", + L"[471][_Statement]< \"return\" @ [ _Expression ] \";\" >", + L"[472][_Statement]< \"return\" [ _Expression @ ] \";\" >", + L"[473][_Statement]< \"return\" [ _Expression ] \";\" @ >", + L"[474][_Statement]< \"try\" @ _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", + L"[475][_Statement]< \"try\" _Block @ [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", + L"[476][_Statement]< \"try\" _Block [ \"catch\" \"(\" @ NAME \")\" _Block ] [ \"finally\" _Block ] >", + L"[477][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" @ _Block ] [ \"finally\" _Block ] >", + L"[478][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block @ ] [ \"finally\" _Block ] >", + L"[479][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" @ _Block ] >", + L"[480][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME \")\" _Block ] [ \"finally\" _Block @ ] >", + L"[481][_Statement]< \"try\" _Block [ \"catch\" \"(\" NAME @ \")\" _Block ] [ \"finally\" _Block ] >", + L"[482][_Statement]< \"try\" _Block [ \"catch\" @ \"(\" NAME \")\" _Block ] [ \"finally\" _Block ] >", + L"[483][_Statement]< \"while\" \"(\" @ _Expression \")\" _Block >", + L"[484][_Statement]< \"while\" \"(\" _Expression \")\" @ _Block >", + L"[485][_Statement]< \"while\" \"(\" _Expression \")\" _Block @ >", + L"[486][_Statement]< \"while\" \"(\" _Expression @ \")\" _Block >", + L"[487][_Statement]< \"while\" @ \"(\" _Expression \")\" _Block >", + L"[488][_Statement]< _Expression \";\" @ >", + L"[489][_Statement]< _Expression @ \";\" >", + L"[490][_Statement]< _Variable @ >", + L"[491][_Statement]", + L"[492][_Statement]", + L"[493][_Statement]", + L"[494][_Statement]", + L"[495][_Statement]", + L"[496][_StateInput] BEGIN ", + L"[497][_StateInput] END [ENDING]", + L"[498][_StateInput]< \"$state_input\" @ NAME \"(\" { _FunctionArgument ; \",\" } \")\" \";\" >", + L"[499][_StateInput]< \"$state_input\" NAME \"(\" @ { _FunctionArgument ; \",\" } \")\" \";\" >", + L"[500][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" @ } \")\" \";\" >", + L"[501][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" } \")\" \";\" @ >", + L"[502][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument ; \",\" } \")\" @ \";\" >", + L"[503][_StateInput]< \"$state_input\" NAME \"(\" { _FunctionArgument @ ; \",\" } \")\" \";\" >", + L"[504][_StateInput]< \"$state_input\" NAME @ \"(\" { _FunctionArgument ; \",\" } \")\" \";\" >", + L"[505][_StateDecl] BEGIN ", + L"[506][_StateDecl] END [ENDING]", + L"[507][_StateDecl]< \"$state\" ( \"default\" @ | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", + L"[508][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" @ { _FunctionArgument ; \",\" } \")\" _Block >", + L"[509][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" @ } \")\" _Block >", + L"[510][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" @ _Block >", + L"[511][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block @ >", + L"[512][_StateDecl]< \"$state\" ( \"default\" | NAME ) \"(\" { _FunctionArgument @ ; \",\" } \")\" _Block >", + L"[513][_StateDecl]< \"$state\" ( \"default\" | NAME @ ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", + L"[514][_StateDecl]< \"$state\" @ ( \"default\" | NAME ) \"(\" { _FunctionArgument ; \",\" } \")\" _Block >", + L"[515][_StateMachine] BEGIN ", + L"[516][_StateMachine] END [ENDING]", + L"[517][_StateMachine]< \"$state_machine\" \"{\" @ { ( _StateInput | _StateDecl ) } \"}\" >", + L"[518][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput @ | _StateDecl ) } \"}\" >", + L"[519][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput | _StateDecl ) } \"}\" @ >", + L"[520][_StateMachine]< \"$state_machine\" \"{\" { ( _StateInput | _StateDecl @ ) } \"}\" >", + L"[521][_StateMachine]< \"$state_machine\" @ \"{\" { ( _StateInput | _StateDecl ) } \"}\" >", + L"[522][_Attribute] BEGIN ", + L"[523][_Attribute] END [ENDING]", + L"[524][_Attribute]< \"@\" @ NAME \":\" NAME [ \"(\" _Expression \")\" ] >", + L"[525][_Attribute]< \"@\" NAME \":\" @ NAME [ \"(\" _Expression \")\" ] >", + L"[526][_Attribute]< \"@\" NAME \":\" NAME @ [ \"(\" _Expression \")\" ] >", + L"[527][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" @ _Expression \")\" ] >", + L"[528][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" _Expression \")\" @ ] >", + L"[529][_Attribute]< \"@\" NAME \":\" NAME [ \"(\" _Expression @ \")\" ] >", + L"[530][_Attribute]< \"@\" NAME @ \":\" NAME [ \"(\" _Expression \")\" ] >", + L"[531][_Namespace] BEGIN ", + L"[532][_Namespace] END [ENDING]", + L"[533][_Namespace]< \"namespace\" @ NAME \"{\" { _Declaration } \"}\" >", + L"[534][_Namespace]< \"namespace\" NAME \"{\" @ { _Declaration } \"}\" >", + L"[535][_Namespace]< \"namespace\" NAME \"{\" { _Declaration @ } \"}\" >", + L"[536][_Namespace]< \"namespace\" NAME \"{\" { _Declaration } \"}\" @ >", + L"[537][_Namespace]< \"namespace\" NAME @ \"{\" { _Declaration } \"}\" >", + L"[538][_FunctionArgument] BEGIN ", + L"[539][_FunctionArgument] END [ENDING]", + L"[540][_FunctionArgument]< { _Attribute @ } NAME \":\" _Type >", + L"[541][_FunctionArgument]< { _Attribute } NAME \":\" @ _Type >", + L"[542][_FunctionArgument]< { _Attribute } NAME \":\" _Type @ >", + L"[543][_FunctionArgument]< { _Attribute } NAME @ \":\" _Type >", + L"[544][_FunctionStat] BEGIN ", + L"[545][_FunctionStat] END [ENDING]", + L"[546][_FunctionStat]", + L"[547][_FunctionStat]", + L"[548][_Function] BEGIN ", + L"[549][_Function] END [ENDING]", + L"[550][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" @ { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[551][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" @ } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[552][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" @ _Type ( _FunctionStat | \";\" ) ) >", + L"[553][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat @ | \";\" ) ) >", + L"[554][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" @ ) ) >", + L"[555][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type @ ( _FunctionStat | \";\" ) ) >", + L"[556][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" @ \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[557][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument @ ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[558][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" @ { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[559][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" @ } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[560][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" @ _Type ( _FunctionStat | \";\" ) ) >", + L"[561][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat @ | \";\" ) ) >", + L"[562][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" @ ) ) >", + L"[563][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type @ ( _FunctionStat | \";\" ) ) >", + L"[564][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" @ \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[565][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument @ ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[566][_Function]< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" ) NAME @ ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >", + L"[567][_Function]{{< ( \"static\" \"func\" @ | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) > ; < ( \"static\" \"func\" @ | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >}}", + L"[568][_Function]{{< ( \"static\" \"func\" | \"override\" \"func\" @ | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) > ; < ( \"static\" \"func\" | \"override\" \"func\" @ | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >}}", + L"[569][_Function]{{< ( \"static\" \"func\" | \"override\" \"func\" | \"func\" @ ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) > ; < ( \"static\" \"func\" | \"override\" \"func\" | \"func\" @ ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >}}", + L"[570][_Function]{{< ( \"static\" \"func\" | \"override\" @ \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) > ; < ( \"static\" \"func\" | \"override\" @ \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >}}", + L"[571][_Function]{{< ( \"static\" @ \"func\" | \"override\" \"func\" | \"func\" ) ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) > ; < ( \"static\" @ \"func\" | \"override\" \"func\" | \"func\" ) NAME ( \"(\" { _FunctionArgument ; \",\" } \")\" \":\" _Type ( _FunctionStat | \";\" ) ) >}}", + L"[572][_Variable] BEGIN ", + L"[573][_Variable] END [ENDING]", + L"[574][_Variable]< \"var\" @ NAME [ \":\" _Type ] \"=\" _Expression \";\" >", + L"[575][_Variable]< \"var\" NAME @ [ \":\" _Type ] \"=\" _Expression \";\" >", + L"[576][_Variable]< \"var\" NAME [ \":\" @ _Type ] \"=\" _Expression \";\" >", + L"[577][_Variable]< \"var\" NAME [ \":\" _Type @ ] \"=\" _Expression \";\" >", + L"[578][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" @ _Expression \";\" >", + L"[579][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" _Expression \";\" @ >", + L"[580][_Variable]< \"var\" NAME [ \":\" _Type ] \"=\" _Expression @ \";\" >", + L"[581][_Event] BEGIN ", + L"[582][_Event] END [ENDING]", + L"[583][_Event]< \"event\" @ NAME \"(\" { _Type ; \",\" } \")\" \";\" >", + L"[584][_Event]< \"event\" NAME \"(\" @ { _Type ; \",\" } \")\" \";\" >", + L"[585][_Event]< \"event\" NAME \"(\" { _Type ; \",\" @ } \")\" \";\" >", + L"[586][_Event]< \"event\" NAME \"(\" { _Type ; \",\" } \")\" \";\" @ >", + L"[587][_Event]< \"event\" NAME \"(\" { _Type ; \",\" } \")\" @ \";\" >", + L"[588][_Event]< \"event\" NAME \"(\" { _Type @ ; \",\" } \")\" \";\" >", + L"[589][_Event]< \"event\" NAME @ \"(\" { _Type ; \",\" } \")\" \";\" >", + L"[590][_Property] BEGIN ", + L"[591][_Property] END [ENDING]", + L"[592][_Property]< \"prop\" @ NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[593][_Property]< \"prop\" NAME \":\" @ _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[594][_Property]< \"prop\" NAME \":\" _Type \"{\" @ NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[595][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME @ [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[596][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" @ NAME ] [ \":\" NAME ] \"}\" >", + L"[597][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME @ ] [ \":\" NAME ] \"}\" >", + L"[598][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" @ NAME ] \"}\" >", + L"[599][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME @ ] \"}\" >", + L"[600][_Property]< \"prop\" NAME \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" @ >", + L"[601][_Property]< \"prop\" NAME \":\" _Type @ \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[602][_Property]< \"prop\" NAME @ \":\" _Type \"{\" NAME [ \",\" NAME ] [ \":\" NAME ] \"}\" >", + L"[603][_StaticInit] BEGIN ", + L"[604][_StaticInit] END [ENDING]", + L"[605][_StaticInit]< \"static\" @ _Block >", + L"[606][_StaticInit]< \"static\" _Block @ >", + L"[607][_BaseConstructorCall] BEGIN ", + L"[608][_BaseConstructorCall] END [ENDING]", + L"[609][_BaseConstructorCall]< _Type \"(\" @ [ _Expression { \",\" _Expression } ] \")\" >", + L"[610][_BaseConstructorCall]< _Type \"(\" [ _Expression @ { \",\" _Expression } ] \")\" >", + L"[611][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" @ _Expression } ] \")\" >", + L"[612][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" _Expression @ } ] \")\" >", + L"[613][_BaseConstructorCall]< _Type \"(\" [ _Expression { \",\" _Expression } ] \")\" @ >", + L"[614][_BaseConstructorCall]< _Type @ \"(\" [ _Expression { \",\" _Expression } ] \")\" >", + L"[615][_Constructor] BEGIN ", + L"[616][_Constructor] END [ENDING]", + L"[617][_Constructor]< ( \"new\" @ | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[618][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" @ { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[619][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" @ } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[620][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" @ [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[621][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" @ { _BaseConstructorCall ; \",\" } ] _Block >", + L"[622][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" @ } ] _Block >", + L"[623][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block @ >", + L"[624][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall @ ; \",\" } ] _Block >", + L"[625][_Constructor]< ( \"new\" | \"new\" \"*\" ) \"(\" { _FunctionArgument @ ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[626][_Constructor]< ( \"new\" | \"new\" \"*\" @ ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[627][_Constructor]< ( \"new\" | \"new\" @ \"*\" ) \"(\" { _FunctionArgument ; \",\" } \")\" [ \":\" { _BaseConstructorCall ; \",\" } ] _Block >", + L"[628][_Destructor] BEGIN ", + L"[629][_Destructor] END [ENDING]", + L"[630][_Destructor]< \"delete\" @ _Block >", + L"[631][_Destructor]< \"delete\" _Block @ >", + L"[632][_Class] BEGIN ", + L"[633][_Class] END [ENDING]", + L"[634][_Class]< \"class\" @ NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[635][_Class]< \"class\" NAME ( [ \":\" @ { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[636][_Class]< \"class\" NAME ( [ \":\" { _Type ; \",\" @ } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[637][_Class]< \"class\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" @ { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[638][_Class]< \"class\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration @ } [ _StateMachine ] \"}\" ) >", + L"[639][_Class]< \"class\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine @ ] \"}\" ) >", + L"[640][_Class]< \"class\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" @ ) >", + L"[641][_Class]< \"class\" NAME ( [ \":\" { _Type @ ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[642][_Class]< \"class\" NAME @ ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[643][_Class]< \"interface\" NAME \"*\" ( [ \":\" @ { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[644][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type ; \",\" @ } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[645][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" @ { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[646][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration @ } [ _StateMachine ] \"}\" ) >", + L"[647][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine @ ] \"}\" ) >", + L"[648][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" @ ) >", + L"[649][_Class]< \"interface\" NAME \"*\" ( [ \":\" { _Type @ ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[650][_Class]< \"interface\" NAME \"*\" @ ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[651][_Class]< \"interface\" NAME ( [ \":\" @ { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[652][_Class]< \"interface\" NAME ( [ \":\" { _Type ; \",\" @ } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[653][_Class]< \"interface\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" @ { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[654][_Class]< \"interface\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration @ } [ _StateMachine ] \"}\" ) >", + L"[655][_Class]< \"interface\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine @ ] \"}\" ) >", + L"[656][_Class]< \"interface\" NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" @ ) >", + L"[657][_Class]< \"interface\" NAME ( [ \":\" { _Type @ ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >", + L"[658][_Class]{{< \"interface\" @ NAME \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) > ; < \"interface\" @ NAME ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >}}", + L"[659][_Class]{{< \"interface\" NAME @ \"*\" ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) > ; < \"interface\" NAME @ ( [ \":\" { _Type ; \",\" } ] \"{\" { _Declaration } [ _StateMachine ] \"}\" ) >}}", + L"[660][_EnumItemInt] BEGIN ", + L"[661][_EnumItemInt] END [ENDING]", + L"[662][_EnumItemInt]< NAME @ >", + L"[663][_EnumItem] BEGIN ", + L"[664][_EnumItem] END [ENDING]", + L"[665][_EnumItem]< { _Attribute @ } NAME \"=\" ( INTEGER ) \",\" >", + L"[666][_EnumItem]< { _Attribute } NAME \"=\" ( INTEGER ) \",\" @ >", + L"[667][_EnumItem]< { _Attribute } NAME \"=\" ( INTEGER @ ) \",\" >", + L"[668][_EnumItem]< { _Attribute } NAME \"=\" @ ( INTEGER ) \",\" >", + L"[669][_EnumItem]< { _Attribute } NAME @ \"=\" ( INTEGER ) \",\" >", + L"[670][_EnumItemWithFlags] BEGIN ", + L"[671][_EnumItemWithFlags] END [ENDING]", + L"[672][_EnumItemWithFlags]< { _Attribute @ } NAME \"=\" ( ( INTEGER ) | ( _EnumItemInt { \"|\" _EnumItemInt } ) ) \",\" >", + L"[673][_EnumItemWithFlags]< { _Attribute } NAME \"=\" ( ( INTEGER ) | ( _EnumItemInt @ { \"|\" _EnumItemInt } ) ) \",\" >", + L"[674][_EnumItemWithFlags]< { _Attribute } NAME \"=\" ( ( INTEGER ) | ( _EnumItemInt { \"|\" @ _EnumItemInt } ) ) \",\" >", + L"[675][_EnumItemWithFlags]< { _Attribute } NAME \"=\" ( ( INTEGER ) | ( _EnumItemInt { \"|\" _EnumItemInt @ } ) ) \",\" >", + L"[676][_EnumItemWithFlags]< { _Attribute } NAME \"=\" ( ( INTEGER ) | ( _EnumItemInt { \"|\" _EnumItemInt } ) ) \",\" @ >", + L"[677][_EnumItemWithFlags]< { _Attribute } NAME \"=\" ( ( INTEGER @ ) | ( _EnumItemInt { \"|\" _EnumItemInt } ) ) \",\" >", + L"[678][_EnumItemWithFlags]< { _Attribute } NAME \"=\" @ ( ( INTEGER ) | ( _EnumItemInt { \"|\" _EnumItemInt } ) ) \",\" >", + L"[679][_EnumItemWithFlags]< { _Attribute } NAME @ \"=\" ( ( INTEGER ) | ( _EnumItemInt { \"|\" _EnumItemInt } ) ) \",\" >", + L"[680][_Enum] BEGIN ", + L"[681][_Enum] END [ENDING]", + L"[682][_Enum]< \"enum\" @ NAME \"{\" _EnumItem { _EnumItem } \"}\" >", + L"[683][_Enum]< \"enum\" NAME \"{\" @ _EnumItem { _EnumItem } \"}\" >", + L"[684][_Enum]< \"enum\" NAME \"{\" _EnumItem @ { _EnumItem } \"}\" >", + L"[685][_Enum]< \"enum\" NAME \"{\" _EnumItem { _EnumItem @ } \"}\" >", + L"[686][_Enum]< \"enum\" NAME \"{\" _EnumItem { _EnumItem } \"}\" @ >", + L"[687][_Enum]< \"enum\" NAME @ \"{\" _EnumItem { _EnumItem } \"}\" >", + L"[688][_Enum]< \"flagenum\" @ NAME \"{\" _EnumItemWithFlags { _EnumItemWithFlags } \"}\" >", + L"[689][_Enum]< \"flagenum\" NAME \"{\" @ _EnumItemWithFlags { _EnumItemWithFlags } \"}\" >", + L"[690][_Enum]< \"flagenum\" NAME \"{\" _EnumItemWithFlags @ { _EnumItemWithFlags } \"}\" >", + L"[691][_Enum]< \"flagenum\" NAME \"{\" _EnumItemWithFlags { _EnumItemWithFlags @ } \"}\" >", + L"[692][_Enum]< \"flagenum\" NAME \"{\" _EnumItemWithFlags { _EnumItemWithFlags } \"}\" @ >", + L"[693][_Enum]< \"flagenum\" NAME @ \"{\" _EnumItemWithFlags { _EnumItemWithFlags } \"}\" >", + L"[694][_StructMember] BEGIN ", + L"[695][_StructMember] END [ENDING]", + L"[696][_StructMember]< { _Attribute @ } NAME \":\" _Type \";\" >", + L"[697][_StructMember]< { _Attribute } NAME \":\" @ _Type \";\" >", + L"[698][_StructMember]< { _Attribute } NAME \":\" _Type \";\" @ >", + L"[699][_StructMember]< { _Attribute } NAME \":\" _Type @ \";\" >", + L"[700][_StructMember]< { _Attribute } NAME @ \":\" _Type \";\" >", + L"[701][_Struct] BEGIN ", + L"[702][_Struct] END [ENDING]", + L"[703][_Struct]< \"struct\" @ NAME \"{\" { _StructMember } \"}\" >", + L"[704][_Struct]< \"struct\" NAME \"{\" @ { _StructMember } \"}\" >", + L"[705][_Struct]< \"struct\" NAME \"{\" { _StructMember @ } \"}\" >", + L"[706][_Struct]< \"struct\" NAME \"{\" { _StructMember } \"}\" @ >", + L"[707][_Struct]< \"struct\" NAME @ \"{\" { _StructMember } \"}\" >", + L"[708][_AutoProperty] BEGIN ", + L"[709][_AutoProperty] END [ENDING]", + L"[710][_AutoProperty]< ( \"static\" \"prop\" @ | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[711][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" @ | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[712][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" @ _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[713][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type @ [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[714][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" @ _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[715][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression @ ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[716][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" @ | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[717][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" @ | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[718][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" @ | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[719][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" @ ) >", + L"[720][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" @ \"}\" ) >", + L"[721][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" @ \"observe\" \"}\" ) >", + L"[722][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" @ \"not\" \"observe\" \"}\" ) >", + L"[723][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" @ \",\" \"not\" \"observe\" \"}\" ) >", + L"[724][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" @ \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[725][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" @ \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[726][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" @ \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[727][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" @ \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[728][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" @ \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[729][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" @ \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[730][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" @ \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[731][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME @ \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[732][_AutoProperty]< ( \"static\" \"prop\" | \"override\" \"prop\" | \"prop\" @ ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[733][_AutoProperty]< ( \"static\" \"prop\" | \"override\" @ \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[734][_AutoProperty]< ( \"static\" @ \"prop\" | \"override\" \"prop\" | \"prop\" ) NAME \":\" _Type [ \"=\" _Expression ] ( \"{\" \"}\" | \"{\" \"const\" \"}\" | \"{\" \"not\" \"observe\" \"}\" | \"{\" \"const\" \",\" \"not\" \"observe\" \"}\" ) >", + L"[735][_CastResultInterface] BEGIN ", + L"[736][_CastResultInterface] END [ENDING]", + L"[737][_CastResultInterface]< \"$interface\" @ NAME \":\" _Type \"<\" _Type \">\" \";\" >", + L"[738][_CastResultInterface]< \"$interface\" NAME \":\" @ _Type \"<\" _Type \">\" \";\" >", + L"[739][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" @ _Type \">\" \";\" >", + L"[740][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type \">\" \";\" @ >", + L"[741][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type \">\" @ \";\" >", + L"[742][_CastResultInterface]< \"$interface\" NAME \":\" _Type \"<\" _Type @ \">\" \";\" >", + L"[743][_CastResultInterface]< \"$interface\" NAME \":\" _Type @ \"<\" _Type \">\" \";\" >", + L"[744][_CastResultInterface]< \"$interface\" NAME @ \":\" _Type \"<\" _Type \">\" \";\" >", + L"[745][_DeclarationCandidates] BEGIN ", + L"[746][_DeclarationCandidates] END [ENDING]", + L"[747][_DeclarationCandidates]", + L"[748][_DeclarationCandidates]", + L"[749][_DeclarationCandidates]", + L"[750][_DeclarationCandidates]", + L"[751][_DeclarationCandidates]", + L"[752][_DeclarationCandidates]", + L"[753][_DeclarationCandidates]", + L"[754][_DeclarationCandidates]", + L"[755][_DeclarationCandidates]", + L"[756][_DeclarationCandidates]", + L"[757][_DeclarationCandidates]", + L"[758][_DeclarationCandidates]", + L"[759][_DeclarationCandidates]", + L"[760][_Declaration] BEGIN ", + L"[761][_Declaration] END [ENDING]", + L"[762][_Declaration]", + L"[763][_Declaration]", + L"[764][_UsingFragment] BEGIN ", + L"[765][_UsingFragment] END [ENDING]", + L"[766][_UsingFragment]< \"*\" @ >", + L"[767][_UsingFragment]< NAME @ >", + L"[768][_UsingItem] BEGIN ", + L"[769][_UsingItem] END [ENDING]", + L"[770][_UsingItem]< _UsingFragment @ { _UsingFragment } >", + L"[771][_UsingItem]< _UsingFragment { _UsingFragment @ } >", + L"[772][_UsingPath] BEGIN ", + L"[773][_UsingPath] END [ENDING]", + L"[774][_UsingPath]< \"using\" @ _UsingItem { \"::\" _UsingItem } \";\" >", + L"[775][_UsingPath]< \"using\" _UsingItem @ { \"::\" _UsingItem } \";\" >", + L"[776][_UsingPath]< \"using\" _UsingItem { \"::\" @ _UsingItem } \";\" >", + L"[777][_UsingPath]< \"using\" _UsingItem { \"::\" _UsingItem @ } \";\" >", + L"[778][_UsingPath]< \"using\" _UsingItem { \"::\" _UsingItem } \";\" @ >", + L"[779][_Module] BEGIN ", + L"[780][_Module] END [ENDING]", + L"[781][_Module]< \"module\" ( NAME \";\" @ { _UsingPath } { _Declaration } ) >", + L"[782][_Module]< \"module\" ( NAME \";\" { _UsingPath @ } { _Declaration } ) >", + L"[783][_Module]< \"module\" ( NAME \";\" { _UsingPath } { _Declaration @ } ) >", + L"[784][_Module]< \"module\" ( NAME @ \";\" { _UsingPath } { _Declaration } ) >", + L"[785][_Module]< \"module\" @ ( NAME \";\" { _UsingPath } { _Declaration } ) >", + L"[786][_Module]< \"unit\" ( NAME \";\" @ { _UsingPath } { _Declaration } ) >", + L"[787][_Module]< \"unit\" ( NAME \";\" { _UsingPath @ } { _Declaration } ) >", + L"[788][_Module]< \"unit\" ( NAME \";\" { _UsingPath } { _Declaration @ } ) >", + L"[789][_Module]< \"unit\" ( NAME @ \";\" { _UsingPath } { _Declaration } ) >", + L"[790][_Module]< \"unit\" @ ( NAME \";\" { _UsingPath } { _Declaration } ) >", }; return results[index]; } diff --git a/Import/VlppWorkflowCompiler.h b/Import/VlppWorkflowCompiler.h index 3bfa6faa..5d36b537 100644 --- a/Import/VlppWorkflowCompiler.h +++ b/Import/VlppWorkflowCompiler.h @@ -4653,74 +4653,76 @@ namespace vl::workflow _CtorFragment = 50, _LetVariable = 55, _VirtualExpression = 60, - _BeginBoundary = 81, - _EndBoundary = 85, - _SetTestingOperator = 89, - _ExpPrimitive = 94, - _Exp0 = 231, - _Exp1 = 246, - _Exp2 = 252, - _Exp3 = 264, - _Exp4 = 279, - _Exp5 = 288, - _Exp6 = 309, - _Exp7 = 315, - _Exp8 = 321, - _Exp9 = 327, - _Exp10 = 333, - _Exp11 = 341, - _Expression = 347, - _SwitchCase = 350, - _Block = 356, - _ElseStat = 364, - _If = 368, - _ForOperator = 382, - _VirtualStatement = 387, - _CoStatement = 406, - _CoProvider = 418, - _StateSwitchHead = 423, - _StateSwitchArgument = 446, - _StateSwitchCase = 449, - _StateStatement = 460, - _Statement = 480, - _StateInput = 520, - _StateDecl = 529, - _StateMachine = 539, - _Attribute = 546, - _Namespace = 555, - _FunctionArgument = 562, - _FunctionArgumentList = 568, - _FunctionStat = 574, - _FunctionBody = 578, - _FunctionKind = 588, - _Function = 595, - _Variable = 602, - _Event = 611, - _Property = 620, - _StaticInit = 633, - _BaseConstructorCall = 637, - _ConstructorType = 645, - _Constructor = 650, - _Destructor = 661, - _ClassBody = 665, - _Class = 674, - _EnumItemInt = 686, - _EnumItemA = 689, - _EnumItemB = 696, - _Enum = 705, - _StructMember = 720, - _Struct = 727, - _APConfig = 734, - _AutoPropertyKind = 751, - _AutoProperty = 758, - _CastResultInterface = 767, - _DeclarationCandidates = 777, - _Declaration = 792, - _UsingFragment = 796, - _UsingItem = 800, - _UsingPath = 804, - _ModuleBody = 811, - _Module = 817, + _BeginBoundary = -1, + _EndBoundary = -1, + _SetTestingOperator = -1, + _ExpPrimitive = 81, + _Exp0 = 220, + _Exp1 = 234, + _Exp2 = 240, + _Exp3 = 252, + _Exp4 = 267, + _Exp5 = 276, + _Exp6 = 297, + _Exp7 = 303, + _Exp8 = 309, + _Exp9 = 315, + _Exp10 = 321, + _Exp11 = 329, + _Expression = 335, + _SwitchCase = 338, + _Block = 344, + _ElseStat = 352, + _If = 356, + _ForOperator = -1, + _VirtualStatement = 370, + _CoStatement = 391, + _CoProvider = 403, + _StateSwitchHead = 408, + _StateSwitchArgument = 422, + _StateSwitchCase = 425, + _StateStatement = 436, + _Statement = 456, + _StateInput = 496, + _StateDecl = 505, + _StateMachine = 515, + _Attribute = 522, + _Namespace = 531, + _FunctionArgument = 538, + _FunctionArgumentList = -1, + _FunctionStat = 544, + _FunctionBody = -1, + _FunctionKind = -1, + _Function = 548, + _Variable = 572, + _Event = 581, + _Property = 590, + _StaticInit = 603, + _BaseConstructorCall = 607, + _ConstructorType = -1, + _Constructor = 615, + _Destructor = 628, + _ClassBody = -1, + _Class = 632, + _EnumItemNumber = -1, + _EnumItemInt = 660, + _EnumItemFlags = -1, + _EnumItem = 663, + _EnumItemWithFlags = 670, + _Enum = 680, + _StructMember = 694, + _Struct = 701, + _APConfig = -1, + _AutoPropertyKind = -1, + _AutoProperty = 708, + _CastResultInterface = 735, + _DeclarationCandidates = 745, + _Declaration = 760, + _UsingFragment = 764, + _UsingItem = 768, + _UsingPath = 772, + _ModuleBody = -1, + _Module = 779, }; const wchar_t* ParserRuleName(vl::vint index); diff --git a/Tools/Executables/GlrParserGen/Main.cpp b/Tools/Executables/GlrParserGen/Main.cpp index 5cf7fc35..ac2024bd 100644 --- a/Tools/Executables/GlrParserGen/Main.cpp +++ b/Tools/Executables/GlrParserGen/Main.cpp @@ -229,7 +229,7 @@ int main(int argc, char* argv[]) auto indexItem = regexNamespace.CaptureNames().IndexOf(L"item"); READ_ATTRIBUTE(global.name, config->rootElement, L"name", L"/Parser@name"); - READ_ELEMENT_ITEMS(global.includes, regexIncludes, config->rootElement, L"Includes", L"/Parser/Includes"); + READ_ELEMENT_ITEMS(global.astIncludes, regexIncludes, config->rootElement, L"Includes", L"/Parser/Includes"); READ_ELEMENT_ITEMS(global.cppNss, regexNamespace, config->rootElement, L"CppNamespace", L"/Parser/CppNamespace"); READ_ELEMENT(global.headerGuard, config->rootElement, L"HeaderGuard", L"/Parser/HeaderGuard"); { diff --git a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 index 6b0c048f..48dac479 100644 Binary files a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 and b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x64 differ diff --git a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x86 b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x86 index 7783c123..3ee35882 100644 Binary files a/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x86 and b/Tutorial/GacUI_HelloWorlds/UIRes/Xml.bin.x86 differ