TextEditor.cpp

//	TextEditor - A syntax highlighting text editor for Dear ImGui.
//	Copyright (c) 2024-2026 Johan A. Goossens. All rights reserved.
//
//	This work is licensed under the terms of the MIT license.
//	For a copy, see <https://opensource.org/licenses/MIT>.


//
//	Include files
//

#include <cstdint>
#include <cmath>

#ifndef IMGUI_DEFINE_MATH_OPERATORS
#define IMGUI_DEFINE_MATH_OPERATORS
#endif

#include "imgui.h"
#include "imgui_internal.h"

#include "TextEditor.h"


//
//	TextEditor::TextEditor
//

TextEditor::TextEditor() {
	SetPalette(defaultPalette);
}


//
//	TextEditor::setText
//

void TextEditor::setText(const std::string_view& text) {
	// load text into document and reset overlays
	document.setText(config, text);
	transactions.reset();
	cursors.clearAll();
	clearMarkers();
	clearSquiggles();
	resetScrolling();
}


//
//	TextEditor::render
//

bool TextEditor::render(const char* title, const ImVec2& size, ImGuiChildFlags childFlags, ImGuiWindowFlags windowFlags) {
	// track content state changes
	bool documentChanged = false;

	// special handling for first frame as we can't use SetNextWindowFocus during it
	if (!firstFrame) {
		// ensure editor has focus (if required)
		if (focusOnEditor) {
			ImGui::SetNextWindowFocus();
			focusOnEditor = false;
		}

	} else {
		firstFrame = false;
	}

	// start a new child window
	ImGui::SetNextWindowContentSize(totalSize);
	ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(0.0f, 0.0f));
	ImGui::PushStyleColor(ImGuiCol_ChildBg, ImGui::ColorConvertU32ToFloat4(palette.get(Color::background)));

	if (ImGui::BeginChild(title, size, childFlags, windowFlags)) {
		// perform last part of scrolling reset here (as it requires the correct Dear ImGui context)
		if (resetDearImGuiScrolling) {
			ImGui::SetScrollX(0.0f);
			ImGui::SetScrollY(0.0f);
			resetDearImGuiScrolling = false;
		}

		// get font information
		font = ImGui::GetFont();
		fontSize = ImGui::GetFontSize();
		auto& style = ImGui::GetStyle();
		fontScaleDpi = style.FontScaleDpi;
		glyphSize = ImVec2(ImGui::CalcTextSize("#").x, ImGui::GetTextLineHeightWithSpacing() * config.lineSpacing);

		// determine current position and visible size
		cursorScreenPos = ImGui::GetCursorScreenPos();
		visibleSize = ImGui::GetCurrentWindow()->InnerRect.GetSize();

		// determine horizontal offsets for line numbers, decorations and text
		if (config.showLineNumbers) {
			size_t digits = static_cast<size_t>(std::log10(static_cast<float>(document.size() + 1)) + 1.0f);
			lineNumberLeftOffset = config.leftMargin * glyphSize.x;
			lineNumberRightOffset = lineNumberLeftOffset + digits * glyphSize.x;

		} else {
			lineNumberLeftOffset = 0.0f;
			lineNumberRightOffset = 0.0f;
		}

		if (config.lineFolding) {
			foldIndicatorOffset = lineNumberLeftOffset;
			lineNumberLeftOffset += glyphSize.x;
			lineNumberRightOffset += glyphSize.x;
		}

		if (decoratorWidth) {
			decorationOffset = lineNumberRightOffset + config.decorationMargin * glyphSize.x;
			textLeftOffset = decorationOffset + (decoratorWidth + config.textMargin) * glyphSize.x;

		} else {
			decorationOffset = lineNumberRightOffset;
			textLeftOffset = decorationOffset + config.textMargin * glyphSize.x;
		}

		if (config.showMiniMap) {
			miniMapRowHeight = 3.0f * fontScaleDpi;
			miniMapColumnHeight = 2.0f * fontScaleDpi;
			miniMapColumnWidth = 1.0f * fontScaleDpi;

			if (config.miniMapColumns == 0.0f) {
				miniMapWidth = std::floor(
					(visibleSize.x - textLeftOffset) /
					(glyphSize.x + miniMapColumnWidth)) * miniMapColumnWidth;

			} else {
				miniMapWidth = config.miniMapColumns * miniMapColumnWidth;
			}

			textRightOffset = visibleSize.x - miniMapWidth;
			miniMapOffset = textRightOffset;

		} else {
			textRightOffset = visibleSize.x;
		}

		// determine number of columns at which text will wrap
		textSize = ImVec2(textRightOffset - textLeftOffset, visibleSize.y);
		config.wordWrapColumns = static_cast<size_t>(std::max(std::floor(textSize.x / glyphSize.x), 0.0f));

		// handle possible state changes caused by API calls before first frame or between frames
		updateState();
		handlePossibleScrolling();

		// handle keyboard inputs
		handleKeyboardInputs();
		documentChanged = updateState();

		// handle mouse inputs
		handleMouseInteractions();

		// determine visible row/column limits
		firstVisibleRow = static_cast<size_t>(std::floor(ImGui::GetScrollY() / glyphSize.y));
		lastVisibleRow = std::min(static_cast<size_t>(std::ceil((ImGui::GetScrollY() + textSize.y) / glyphSize.y)), typeSetter.getRowCount() - 1);
		firstVisibleColumn = static_cast<size_t>(std::floor(ImGui::GetScrollX() / glyphSize.x));
		lastVisibleColumn = static_cast<size_t>(std::ceil((ImGui::GetScrollX() + textSize.x) / glyphSize.x));

		// update color palette (if required)
		if (paletteAlpha != style.Alpha) {
			updatePalettes();
		}

		// determine width of cursor
#if IMGUI_VERSION_NUM >= 19290
		cursorWidth =  style.InputTextCursorSize;
#else
		cursorWidth = 1.0f * fontScaleDpi;
#endif

		// setup clipping over the text area
		auto drawList = ImGui::GetWindowDrawList();
		auto offset = ImGui::GetWindowPos().x;

		drawList->PushClipRect(
			ImVec2(offset + textLeftOffset - cursorWidth, drawList->GetClipRectMin().y),
			ImVec2(offset + textRightOffset + cursorWidth, drawList->GetClipRectMax().y),
			true);

		// render parts in the text area
		renderActiveBracketBackground();
		renderSelections();
		renderTextMarkers();
		renderMatchingBracketLines();
		renderSquiggles();
		renderText();
		renderCursorCarets();

		// end clipping
		drawList->PopClipRect();

		// render other parts
		renderLineNumberMarkers();
		renderLineNumbers();
		renderDecorations();
		renderFoldIndicators();
		renderMiniMap();
		renderScrollbarMiniMap();
		renderPanScrollIndicator();
		renderFindReplace();
		renderPopups();

		// handle scrolling caused by actions in this frame
		handlePossibleScrolling();

		// handle navigation cursor (if required)
		if (ImGui::GetIO().ConfigFlags & (ImGuiConfigFlags_NavEnableKeyboard | ImGuiConfigFlags_NavEnableGamepad)) {
			auto window = ImGui::GetCurrentWindow();

			if (ImGui::IsWindowFocused()) {
				// ImGui::BeginChildEx: we can enter a child if (A) it has navigable items or (B) it can be scrolled
				// as a result this editor will not get a navigation border if it doesn't have a vertical scrollbar
				// so we need to draw it ourselves in that case
				if (!window->ScrollbarY) {
					ImRect bb{ImGui::GetWindowPos(), ImGui::GetWindowPos() + ImGui::GetWindowSize()};
					bb.Expand(ImVec2(2.0f, 2.0f));

					window->ParentWindow->DrawList->AddRect(
						bb.Min,
						bb.Max,
						ImGui::GetColorU32(ImGuiCol_NavCursor),
						ImGui::GetStyle().FrameRounding,
						fontScaleDpi);
				}

			} else {
				// this voodoo is required to get a navigation cursor when the editor is not focussed
				// ImGui::InputTextEx: this is to ensure that EndChild() will display a navigation highlight so we can "enter" into it
				window->DC.NavLayersActiveMaskNext |= (1 << window->DC.NavLayerCurrent);
			}
		}
	}

	ImGui::EndChild();
	ImGui::PopStyleColor();
	ImGui::PopStyleVar();

	// handle change tracking if there is a callback in place
	if (delayedChangeCallback && delayedChangeDetected) {
		if (std::chrono::system_clock::now() > delayedChangeReportTime) {
			delayedChangeCallback();
			delayedChangeDetected = false;
		}
	}

	return documentChanged;
}


//
//	TextEditor::renderActiveBracketBackground
//

void TextEditor::renderActiveBracketBackground() {
	if (config.showMatchingBrackets && bracketeer.size()) {
		auto drawList = ImGui::GetWindowDrawList();

		// render active bracket pair
		auto active = bracketeer.getEnclosingBrackets(cursors.getMain().getInteractiveEnd());

		if (active != bracketeer.end() && active->visible) {
			if (document[active->start.line].foldingState != FoldingState::hidden) {
				auto startVis = docPos2VisPos(active->start);

				if (startVis.row >= firstVisibleRow && startVis.row <= lastVisibleRow) {
					auto x = cursorScreenPos.x + textLeftOffset + startVis.column * glyphSize.x;
					auto y = cursorScreenPos.y + startVis.row * glyphSize.y;

					drawList->AddRectFilled(
						ImVec2(x, y),
						ImVec2(x + glyphSize.x, y + glyphSize.y),
						palette.get(Color::matchingBracketBackground));
				}
			}

			if (document[active->end.line].foldingState != FoldingState::hidden) {
				auto endVis = docPos2VisPos(active->end);

				if (endVis.row >= firstVisibleRow && endVis.row <= lastVisibleRow) {
					auto x = cursorScreenPos.x + textLeftOffset + endVis.column * glyphSize.x;
					auto y = cursorScreenPos.y + endVis.row * glyphSize.y;

					drawList->AddRectFilled(
						ImVec2(x, y),
						ImVec2(x + glyphSize.x, y + glyphSize.y),
						palette.get(Color::matchingBracketBackground));
				}
			}
		}
	}
}


//
//	TextEditor::renderSelections
//

void TextEditor::renderSelections() {
	auto drawList = ImGui::GetWindowDrawList();

	// draw background for selections
	for (auto& cursor : cursors) {
		if (cursor.hasSelection()) {
			auto begin = cursor.getSelectionStart();
			auto end = cursor.getSelectionEnd();

			for (size_t i = begin.line; i <= end.line; i++) {
				const auto& line = document[i];

				if (line.foldingState != FoldingState::hidden) {
					if (line.rows == 1) {
						if (line.row >= firstVisibleRow && line.row <= lastVisibleRow) {
							auto lineLeft = DocPos(i, 0);
							auto lineRight =DocPos(i, line.size());
							auto docLeft = begin <= lineLeft ? lineLeft : begin;
							auto docRight = end > lineRight ? lineRight : end;
							auto visLeft = docPos2VisPos(docLeft);
							auto visRight = docPos2VisPos(docRight);

							auto x = cursorScreenPos.x + textLeftOffset;
							auto left = x + visLeft.column * glyphSize.x;
							auto right = x + visRight.column * glyphSize.x;
							auto y = cursorScreenPos.y + line.row * glyphSize.y;

							drawList->AddRectFilled(
								ImVec2(left, y),
								ImVec2(right, y + glyphSize.y),
								palette.get(Color::selection));
							}

					} else {
						for (size_t j = 0; j < line.rows; j++) {
							auto& section = line.sections->at(j);
							auto row = line.row + j;

							if (row >= firstVisibleRow && row <= lastVisibleRow) {
								auto sectionLeft = DocPos(i, section.startIndex);
								auto sectionRight = DocPos(i, section.endIndex);

								if (begin < sectionRight && end > sectionLeft) {
									auto visLeft = begin <= sectionLeft ? VisPos(row, 0) : docPos2VisPos(begin);
									auto visRight = end > sectionRight ? VisPos(row, section.columns) : docPos2VisPos(end);

									auto x = cursorScreenPos.x + textLeftOffset;
									auto left = x + visLeft.column * glyphSize.x;
									auto right = x + visRight.column * glyphSize.x;
									auto y = cursorScreenPos.y + row * glyphSize.y;

									drawList->AddRectFilled(
										ImVec2(left, y),
										ImVec2(right, y + glyphSize.y),
										palette.get(Color::selection));
								}
							}
						}
					}
				}
			}
		}
	}
}


//
//	TextEditor::renderTextMarkers
//

void TextEditor::renderTextMarkers() {
	if (markers.size()) {
		auto drawList = ImGui::GetWindowDrawList();

		for (size_t row = firstVisibleRow; row <= lastVisibleRow; row++) {
			auto markerIndex = document[typeSetter[row].line].marker;

			if (markerIndex) {
				const auto& marker = markers[markerIndex - 1];
				auto y = cursorScreenPos.y + row * glyphSize.y;

				if (((marker.textColor >> IM_COL32_A_SHIFT) & 0xFF) != 0) {
					auto left = cursorScreenPos.x + textLeftOffset;
					auto right = left + lastVisibleColumn * glyphSize.x;
					auto start = ImVec2(left, y);
					auto end = ImVec2(right, y + glyphSize.y);
					drawList->AddRectFilled(start, end, marker.textColor);

					if (marker.textTooltip.size() && ImGui::IsMouseHoveringRect(start, end)) {
						if (ImGui::BeginTooltip()) {
							ImGui::PushStyleColor(ImGuiCol_PopupBg, marker.textColor);
							ImGui::TextUnformatted(marker.textTooltip.c_str());
							ImGui::PopStyleColor();
							ImGui::EndTooltip();
						}
					}
				}
			}
		}
	}
}


//
//	TextEditor::renderMatchingBracketLines
//

void TextEditor::renderMatchingBracketLines() {
	if (config.showMatchingBrackets && bracketeer.size()) {
		auto active = bracketeer.getEnclosingBrackets(cursors.getMain().getInteractiveEnd());
		auto drawList = ImGui::GetWindowDrawList();

		// render bracket pair lines
		for (auto bracket = bracketeer.begin(); bracket < bracketeer.end(); bracket++) {
			if (bracket->visible && bracket->end.line - bracket->start.line > 1) {
				auto column = std::min(docPos2VisPos(bracket->start).column, docPos2VisPos(bracket->end).column);

				for (size_t i = bracket->start.line + 1; i < bracket->end.line; i++) {
					const auto& line = document[i];

					if (line.foldingState != FoldingState::hidden) {
						auto lineX = cursorScreenPos.x + textLeftOffset + column * glyphSize.x;
						auto startY = cursorScreenPos.y + line.row * glyphSize.y;
						auto endY = startY +  line.rows * glyphSize.y;

						auto color = palette.get(bracket == active ? Color::matchingBracketActive : Color::whitespace);
						drawList->AddLine(ImVec2(lineX, startY), ImVec2(lineX, endY), color);
					}
				}
			}
		}
	}
}

//
//	renderSquiggle
//

static inline void renderSquiggle(float left, float right, float top, float bottom, float thickness, ImU32 color, const char* tooltip) {
	auto drawList = ImGui::GetWindowDrawList();
	auto height = bottom - top;
	auto size = height * 0.2f;
	auto offset = top + height * 0.8f;
	ImVec2 point(left, offset);
	bool down = true;

	ImVec2 topLeft{left, top};
	ImVec2 bottomRight{right, bottom};
	drawList->PushClipRect(topLeft, bottomRight, true);

	while (point.x < right) {
		ImVec2 next{point.x + size, down ? offset + size : offset};
		drawList->AddLine(point, next, color, thickness);
		point = next;
		down = !down;
	}

	drawList->PopClipRect();

	if (*tooltip && ImGui::IsMouseHoveringRect(topLeft, bottomRight)) {
		if (ImGui::BeginTooltip()) {
			ImGui::TextUnformatted(tooltip);
			ImGui::EndTooltip();
		}
	}
}


//
//	TextEditor::renderSquiggles
//

void TextEditor::renderSquiggles() {
	if (squiggles.size()) {
		ImVec2 rowScreenPos = cursorScreenPos + ImVec2(textLeftOffset, firstVisibleRow * glyphSize.y);

		// only process all visible rows
		for (size_t i = firstVisibleRow; i <= lastVisibleRow; i++) {
			// determine visible boundaries for this row
			auto& line = document[typeSetter[i].line];
			size_t index;
			size_t column;
			size_t endColumn;

			if (config.wordWrap && line.sections) {
				const auto& section = line.sections->at(typeSetter[i].section);
				index = section.startIndex;
				column = section.indent;
				endColumn = section.columns;

			} else {
				index = 0;
				column = 0;
				endColumn = line.columns;
			}

			// setup squiggles
			bool inSquiggle = false;
			size_t squiggleIndex = 0;
			float squiggleLeft = 0.0f;
			float thickness = 1.2f * fontScaleDpi;

			// only process all visible columns
			while (column < endColumn && column <= lastVisibleColumn) {
				auto& glyph = line[index++];
				auto codepoint = glyph.codepoint;
				ImVec2 glyphPos(rowScreenPos.x + column * glyphSize.x, rowScreenPos.y);

				// handle squiggles
				if (glyph.squiggle) {
					auto nextIndex = glyph.squiggle - 1;

					if (inSquiggle) {
						if (squiggleIndex != nextIndex) {
							// render squiggle and start new one
							auto& squiggle = squiggles[squiggleIndex];
							renderSquiggle(squiggleLeft, glyphPos.x, glyphPos.y, glyphPos.y + glyphSize.y, thickness, squiggle.color, squiggle.tooltip.c_str());
							squiggleIndex = nextIndex;
							squiggleLeft = glyphPos.x;
						}

					} else {
						// start new squiggle
						inSquiggle = true;
						squiggleIndex = nextIndex;
						squiggleLeft = glyphPos.x;
					}

				} else if (inSquiggle) {
					// render squiggle
					auto& squiggle = squiggles[squiggleIndex];
					renderSquiggle(squiggleLeft, glyphPos.x, glyphPos.y, glyphPos.y + glyphSize.y, thickness, squiggle.color, squiggle.tooltip.c_str());
					inSquiggle = false;
				}

				// handle tabs
				if (codepoint == '\t') {
					column += config.tabSize - (column % config.tabSize);

				// handle regular glyphs
				} else {
					column++;
				}
			}

			if (inSquiggle) {
				// render last squiggle on line
				auto& squiggle = squiggles[squiggleIndex];
				auto glyphPos = cursorScreenPos + ImVec2(textLeftOffset + typeSetter[i].columns * glyphSize.x, i * glyphSize.y);
				renderSquiggle(squiggleLeft, glyphPos.x, glyphPos.y, glyphPos.y + glyphSize.y, thickness, squiggle.color, squiggle.tooltip.c_str());
			}

			rowScreenPos.y += glyphSize.y;
		}
	}
}


//
//	TextEditor::renderText
//

void TextEditor::renderText() {
	auto drawList = ImGui::GetWindowDrawList();
	ImVec2 rowScreenPos = cursorScreenPos + ImVec2(textLeftOffset, firstVisibleRow * glyphSize.y);
	auto firstRenderableColumn = (firstVisibleColumn / config.tabSize) * config.tabSize;

	// only process all visible rows
	for (size_t i = firstVisibleRow; i <= lastVisibleRow; i++) {
		// determine visible boundaries for this row
		auto& line = document[typeSetter[i].line];
		size_t index;
		size_t column;
		size_t endColumn;

		if (config.wordWrap && line.sections) {
			const auto& section = line.sections->at(typeSetter[i].section);
			index = section.startIndex;
			column = section.indent;
			endColumn = section.columns;

		} else {
			index = 0;
			column = 0;
			endColumn = line.columns;
		}

		// only process all visible columns
		while (column < endColumn && column <= lastVisibleColumn) {
			auto& glyph = line[index++];
			auto codepoint = glyph.codepoint;
			ImVec2 glyphPos(rowScreenPos.x + column * glyphSize.x, rowScreenPos.y);

			// handle tabs
			if (codepoint == '\t') {
				if (config.showTabs && column >= firstRenderableColumn) {
					const auto x1 = glyphPos.x + glyphSize.x * 0.3f;
					const auto y = glyphPos.y + fontSize * 0.5f;
					const auto x2 = glyphPos.x + glyphSize.x;

					ImVec2 p1, p2, p3, p4;
					p1 = ImVec2(x1, y);
					p2 = ImVec2(x2, y);
					p3 = ImVec2(x2 - fontSize * 0.16f, y - fontSize * 0.16f);
					p4 = ImVec2(x2 - fontSize * 0.16f, y + fontSize * 0.16f);

					drawList->AddLine(p1, p2, palette.get(Color::whitespace));
					drawList->AddLine(p2, p3, palette.get(Color::whitespace));
					drawList->AddLine(p2, p4, palette.get(Color::whitespace));
				}

				column += config.tabSize - (column % config.tabSize);

			// handle spaces
			} else if (codepoint == ' ') {
				if (config.showSpaces && column >= firstRenderableColumn) {
					const auto x = glyphPos.x + glyphSize.x * 0.5f;
					const auto y = glyphPos.y + fontSize * 0.5f;
					drawList->AddCircleFilled(ImVec2(x, y), 1.5f, palette.get(Color::whitespace), 4);
				}

				column++;

			// handle regular glyphs
			} else {
				if (column >= firstRenderableColumn) {
					font->RenderChar(drawList, fontSize, glyphPos, palette.get(glyph.color), codepoint);
				}

				column++;
			}
		}

		// draw ellipsis at the end of folded lines
		if (i == line.row + line.rows - 1) {
			if (line.foldingState == FoldingState::folded) {
				auto glyphPos = cursorScreenPos + ImVec2(textLeftOffset + typeSetter[i].columns * glyphSize.x, i * glyphSize.y);
				font->RenderChar(drawList, fontSize, glyphPos, palette.get(Color::text), font->EllipsisChar);
			}
		}

		rowScreenPos.y += glyphSize.y;
	}
}


//
//	TextEditor::renderCursorCarets
//

void TextEditor::renderCursorCarets() {
	if (config.caretsVisible && ImGui::IsWindowFocused()) {
		auto& io = ImGui::GetIO();
		cursorAnimationTimer += io.DeltaTime;

		auto drawList = ImGui::GetWindowDrawList();
		size_t cursorIndex = 0;

		for (auto& cursor : cursors) {
			auto docPos = cursor.getInteractiveEnd();

			if (document[docPos.line].foldingState != FoldingState::hidden) {
				auto pos = docPos2VisPos(docPos);

				if (pos.row >= firstVisibleRow && pos.row <= lastVisibleRow && pos.column >= firstVisibleColumn && pos.column <= lastVisibleColumn) {
					auto caretVisible = !io.ConfigInputTextCursorBlink || cursorAnimationTimer <= 0.0f || std::fmod(cursorAnimationTimer, 1.2f) <= 0.8f;
					auto x = cursorScreenPos.x + textLeftOffset + pos.column * glyphSize.x;
					auto y = cursorScreenPos.y + pos.row * glyphSize.y;

					// handle custom caret renderer
					if (customCaretCallback) {
						CustomCaret caret;
						caret.drawList = drawList;
						caret.glyphPos = ImVec2(x, y);
						caret.glyphSize = glyphSize;
						caret.caretVisible = caretVisible;
						caret.caretColor = palette.get(Color::cursor);
						caret.cursorIndex = cursorIndex;
						customCaretCallback(caret);

					} else if (caretVisible) {
						drawList->AddRectFilled(
							ImVec2(x - cursorWidth, y),
							ImVec2(x, y + glyphSize.y),
							palette.get(Color::cursor));
					}
				}
			}

			cursorIndex++;
		}
	}
}


//
//	TextEditor::renderLineNumberMarkers
//

void TextEditor::renderLineNumberMarkers() {
	if (markers.size()) {
		auto drawList = ImGui::GetWindowDrawList();

		for (size_t row = firstVisibleRow; row <= lastVisibleRow; row++) {
			auto markerIndex = document[typeSetter[row].line].marker;

			if (markerIndex) {
				const auto& marker = markers[markerIndex - 1];
				auto y = cursorScreenPos.y + row * glyphSize.y;

				if (((marker.lineNumberColor >> IM_COL32_A_SHIFT) & 0xFF) != 0) {
					auto left = cursorScreenPos.x + lineNumberLeftOffset;
					auto right = cursorScreenPos.x + lineNumberRightOffset;
					auto start = ImVec2(left, y);
					auto end = ImVec2(right, y + glyphSize.y);
					drawList->AddRectFilled(start, end, marker.lineNumberColor);

					if (marker.lineNumberTooltip.size() && ImGui::IsMouseHoveringRect(start, end)) {
						if (ImGui::BeginTooltip()) {
							ImGui::PushStyleColor(ImGuiCol_PopupBg, marker.lineNumberColor);
							ImGui::TextUnformatted(marker.lineNumberTooltip.c_str());
							ImGui::PopStyleColor();
							ImGui::EndTooltip();
						}
					}
				}
			}
		}
	}
}


//
//	TextEditor::renderLineNumbers
//

void TextEditor::renderLineNumbers() {
	if (config.showLineNumbers) {
		auto drawList = ImGui::GetWindowDrawList();
		auto curserRow = docPos2VisPos(cursors.getCurrent().getInteractiveEnd()).row;
		auto position = ImVec2(ImGui::GetWindowPos().x + lineNumberRightOffset, cursorScreenPos.y);

		for (size_t i = firstVisibleRow; i <= lastVisibleRow; i++) {
			if (typeSetter[i].section == 0) {
				auto lineNo = typeSetter[i].line + 1;
				auto width = static_cast<size_t>(std::log10(lineNo) + 1.0f) * glyphSize.x;
				auto foreground = (i == curserRow) ? Color::currentLineNumber : Color::lineNumber;
				auto number = std::to_string(lineNo);
				drawList->AddText(position + ImVec2(-width, i * glyphSize.y), palette.get(foreground), number.c_str());
			}
		}
	}
}


//
//	TextEditor::renderDecorations
//

void TextEditor::renderDecorations() {
	if (decoratorWidth && decoratorCallback) {
		auto position = ImVec2(ImGui::GetWindowPos().x + decorationOffset, cursorScreenPos.y + glyphSize.y * firstVisibleRow);
		auto widthInPixels = decoratorWidth * glyphSize.x;
		Decorator decorator{0, widthInPixels, glyphSize.y, glyphSize, nullptr};

		for (size_t i = firstVisibleRow; i <= lastVisibleRow; i++) {
			if (typeSetter[i].section == 0) {
				decorator.line = typeSetter[i].line;
				decorator.userData = document.getUserData(i);
				ImGui::SetCursorScreenPos(position);
				ImGui::PushID(static_cast<int>(i));
				decoratorCallback(decorator);
				ImGui::PopID();
				position.y += glyphSize.y;
			}
		}

		ImGui::SetCursorScreenPos(cursorScreenPos);
	}
}


//
//	TextEditor::renderFoldIndicators
//

void TextEditor::renderFoldIndicators() {
	if (config.lineFolding) {
		auto drawList = ImGui::GetWindowDrawList();
		auto color = palette.get(Color::lineNumber);
		auto hoveredColor = palette.get(Color::currentLineNumber);
		auto size = fontSize * 0.25f;

		for (size_t i = firstVisibleRow; i <= lastVisibleRow; i++) {
			auto& line = document[typeSetter[i].line];
			auto foldingState = line.foldingState;

			if (typeSetter[i].section == 0) {
				if (foldingState == FoldingState::foldable || foldingState == FoldingState::folded) {
					auto center = ImVec2(
						ImGui::GetWindowPos().x + foldIndicatorOffset,
						cursorScreenPos.y + glyphSize.y * i + fontSize / 2.0f);

					auto topLeft = center - ImVec2(glyphSize.x / 2.0f, fontSize / 2.0f);
					auto bottomRight = center + ImVec2(glyphSize.x / 2.0f, fontSize / 2.0f);
					auto isHovered = ImGui::IsMouseHoveringRect(topLeft, bottomRight);

					if (foldingState == FoldingState::foldable) {
						drawList->AddLine(
							ImVec2(center.x - size, center.y - size * 0.5f),
							ImVec2(center.x, center.y + size),
							isHovered ? hoveredColor : color);

						drawList->AddLine(
							ImVec2(center.x, center.y + size),
							ImVec2(center.x + size, center.y - size * 0.5f),
							isHovered ? hoveredColor : color);

					} else {
						drawList->AddLine(
							ImVec2(center.x - size * 0.5f, center.y - size),
							ImVec2(center.x + size, center.y),
							isHovered ? hoveredColor : color);

						drawList->AddLine(
							ImVec2(center.x + size, center.y),
							ImVec2(center.x - size * 0.5f, center.y + size),
							isHovered ? hoveredColor : color);
					}

					if (isHovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
						lineFold.toggleAtLine(document, typeSetter[i].line);
					}
				}
			}
		}

		ImGui::SetCursorScreenPos(cursorScreenPos);
	}
}


//
//	void TextEditor::renderMiniMap
//

void TextEditor::renderMiniMap() {
	if (config.showMiniMap) {
		// reset background colors
		for (auto& row : miniMap.rows) {
			row.color = 0;
		}

		// color cursor lines
		for (auto& cursor : cursors) {
			auto begin = cursor.getSelectionStart();
			auto end = cursor.getSelectionEnd();

			for (size_t i = begin.line; i <= end.line; i++) {
				const auto& line = document[i];

				if (line.foldingState != FoldingState::hidden) {
					for (size_t j = 0; j < line.rows; j++) {
						miniMap.rows[line.row + j].color = miniMapPalette.get(Color::selection);
					}
				}
			}
		}

		// color marker lines
		if (markers.size()) {
			for (size_t row = 0; row < typeSetter.getRowCount(); row++) {
				auto& line = document[typeSetter[row].line];

				if (line.marker) {
					auto color = markers[line.marker - 1].textColor;

					if (!color) {
						color = markers[line.marker - 1].lineNumberColor;
					}

					auto fColor = ImGui::ColorConvertU32ToFloat4(color);
					fColor.w *= miniMapAlpha;
					miniMap.rows[row].color = ImGui::ColorConvertFloat4ToU32(fColor);
				}
			}
		}

		// determine viewport information
		auto totalMiniMapRows = miniMap.rows.size();
		auto visibleMiniMapRows = (textSize.y / miniMapRowHeight);

		if (totalMiniMapRows < visibleMiniMapRows) {
			firstMiniMapRow = 0;
			lastMiniMapRow = miniMap.rows.size();

		} else {
			auto scrollRatio = ImGui::GetScrollY() / ImGui::GetScrollMaxY();
			firstMiniMapRow = static_cast<size_t>(scrollRatio * (totalMiniMapRows - visibleMiniMapRows));
			lastMiniMapRow = firstMiniMapRow + static_cast<size_t>(std::ceil(visibleMiniMapRows));
			lastMiniMapRow = std::min(lastMiniMapRow, totalMiniMapRows);
		}

		// process all visible minimap rows
		auto drawList = ImGui::GetWindowDrawList();
		auto pos = ImGui::GetWindowPos() + ImVec2(miniMapOffset, 0.0f);

		for (size_t i = firstMiniMapRow; i < lastMiniMapRow; i++) {
			auto& row = miniMap.rows[i];

			// render line background
			if (row.color) {
				drawList->AddRectFilled(
					pos,
					pos + ImVec2(miniMapWidth, miniMapRowHeight),
					row.color);
			}

			// render text sections
			for (auto& section : row.sections) {
				drawList->AddRectFilled(
					pos + ImVec2(section.start * miniMapColumnWidth, 0.0f),
					pos + ImVec2(section.end * miniMapColumnWidth, miniMapColumnHeight),
					miniMapPalette.get(section.color));
			}

			pos += ImVec2(0.0f, miniMapRowHeight);
		}

		// render viewport
		if (totalSize.y > textSize.y) {
			auto viewPortStart = (firstVisibleRow - firstMiniMapRow) * miniMapRowHeight;
			auto viewportHeight = (lastVisibleRow - firstVisibleRow) * miniMapRowHeight;
			auto ViewPortTopLeft = ImGui::GetWindowPos() + ImVec2(miniMapOffset, viewPortStart);
			auto viewPortBottomRight = ViewPortTopLeft + ImVec2(miniMapWidth, viewportHeight);

			auto fColor = ImGui::ColorConvertU32ToFloat4(palette.get(Color::text));
			fColor.w *= miniMapIsScrollbar ? miniMapViewPortActiveAlpha : miniMapViewPortAlpha;
			drawList->AddRectFilled(ViewPortTopLeft, viewPortBottomRight, ImGui::ColorConvertFloat4ToU32(fColor));
		}
	}
}


//
//	TextEditor::renderScrollbarMiniMap
//

void TextEditor::renderScrollbarMiniMap() {
	if (config.showScrollbarMiniMap) {
		// based on https://github.com/ocornut/imgui/issues/3114
		auto window = ImGui::GetCurrentWindow();

		if (window->ScrollbarY) {
			auto drawList = ImGui::GetWindowDrawList();
			auto rect = ImGui::GetWindowScrollbarRect(window, ImGuiAxis_Y);
			auto rowHeight = rect.GetHeight() / static_cast<float>(typeSetter.getRowCount());
			auto offset = (rect.Max.x - rect.Min.x) * 0.3f;
			auto left = rect.Min.x + offset;
			auto right = rect.Max.x - offset;

			drawList->PushClipRect(rect.Min, rect.Max, false);

			// render cursor locations
			for (auto& cursor : cursors) {
				auto begin = cursor.getSelectionStart();
				auto end = cursor.getSelectionEnd();

				for (size_t i = begin.line; i <= end.line; i++) {
					const auto& line = document[i];

					if (line.foldingState != FoldingState::hidden) {
						auto ly1 = std::round(rect.Min.y + line.row * rowHeight);
						auto ly2 = std::round(rect.Min.y + (line.row + line.rows) * rowHeight);

						drawList->AddRectFilled(
							ImVec2(left, ly1),
							ImVec2(right, ly2),
							palette.get(Color::selection));
					}
				}
			}

			// render marker locations
			if (markers.size()) {
				for (size_t row = 0; row < typeSetter.getRowCount(); row++) {
					auto& line = document[typeSetter[row].line];

					if (line.marker) {
						auto color = markers[line.marker - 1].textColor;

						if (!color) {
							color = markers[line.marker - 1].lineNumberColor;
						}

						auto ly = std::round(rect.Min.y + row * rowHeight);
						drawList->AddRectFilled(ImVec2(left, ly), ImVec2(right, ly + rowHeight), color);
					}
				}
			}

			drawList->PopClipRect();
		}
	}
}


//
//	TextEditor::renderPanScrollIndicator
//

void TextEditor::renderPanScrollIndicator() {
	if (config.showPanScrollIndicator && (panning || scrolling)) {
		auto drawList = ImGui::GetWindowDrawList();
		auto center = ImGui::GetWindowPos() + ImGui::GetWindowSize() / 2.0f;
		static constexpr int alpha = 160;
		drawList->AddCircleFilled(center, 20.0f, IM_COL32(255, 255, 255, alpha));
		drawList->AddCircle(center, 5.0f, IM_COL32(0, 0, 0, alpha), 0, 2.0f);

		drawList->AddTriangle(
			ImVec2(center.x - 15.0f, center.y),
			ImVec2(center.x - 8.0f, center.y - 4.0f),
			ImVec2(center.x - 8.0f, center.y + 4.0f),
			IM_COL32(0, 0, 0, alpha),
			2.0f);

		drawList->AddTriangle(
			ImVec2(center.x + 15.0f, center.y),
			ImVec2(center.x + 8.0f, center.y - 4.0f),
			ImVec2(center.x + 8.0f, center.y + 4.0f),
			IM_COL32(0, 0, 0, alpha),
			2.0f);

		drawList->AddTriangle(
			ImVec2(center.x, center.y - 15.0f),
			ImVec2(center.x - 4.0f, center.y - 8.0f),
			ImVec2(center.x + 4.0f, center.y - 8.0f),
			IM_COL32(0, 0, 0, alpha),
			2.0f);

		drawList->AddTriangle(
			ImVec2(center.x, center.y + 15.0f),
			ImVec2(center.x - 4.0f, center.y + 8.0f),
			ImVec2(center.x + 4.0f, center.y + 8.0f),
			IM_COL32(0, 0, 0, alpha),
			2.0f);
	}
}


//
//	TextEditor::renderPopups
//

void TextEditor::renderPopups() {
	PopupData popupData;
	popupData.pos = popupDocPos;
	popupData.userData = document.getUserData(popupDocPos.line);

	if (ImGui::BeginPopup("LineNumberContextMenu")) {
		if (lineNumberContextMenuCallback) {
			lineNumberContextMenuCallback(popupData);

		} else {
			ImGui::CloseCurrentPopup();
		}

		ImGui::EndPopup();
	}

	if (ImGui::BeginPopup("TextContextMenu")) {
		if (textContextMenuCallback) {
			textContextMenuCallback(popupData);

		} else {
			ImGui::CloseCurrentPopup();
		}

		ImGui::EndPopup();
	}

	if (ImGui::IsPopupOpen("TextHoverPopup")) {
		ImGui::SetNextWindowPos(popupWindowPos, ImGuiCond_Always, ImVec2(0.0f, 1.0f));

		if (ImGui::BeginPopup("TextHoverPopup", ImGuiWindowFlags_NoFocusOnAppearing)) {
			if (textHoverCallback) {
				ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
				textHoverCallback(popupData);

			} else {
				ImGui::CloseCurrentPopup();
			}

			ImGui::EndPopup();
		}
	}

	// render autocomplete popup
	if (autocomplete.render(document, cursors, typeSetter, config.language, textLeftOffset, glyphSize)) {
		// user picked a suggestion so insert it
		auto start = autocomplete.getStart();
		auto end = document.findWordEnd(start, true);
		auto replacement = autocomplete.getReplacement();
		replaceSectionText(start, end, replacement);
	}
}


//
//	TextEditor::updateState
//

bool TextEditor::updateState() {
	// this function gets called to handle possible changes caused by the API or user interactions
	// the overlays determine what they need to do to update their state (could be nothing)
	colorizer.update(config, document);
	bracketeer.update(config, document);
	lineFold.update(config, document, bracketeer);
	cursors.update(document);

	float unused;
	auto firstVisibleLineFraction = std::modf(ImGui::GetScrollY() / glyphSize.y, &unused);
	auto previousFirstLine = visPos2DocPos(VisPos(firstVisibleRow, 0)).line;

	if (typeSetter.update(config, document, lineFold)) {
		// see if we can scroll to preserve the first visible line
		// but we don't overrule an API scroll request
		if (scrollToLineNumber == invalidLine) {
			scrollToLine(previousFirstLine, Scroll::alignTop, firstVisibleLineFraction);
		}
	}

	miniMap.update(config, document, typeSetter);

	// handle possible delayed change callback
	if (document.isUpdated()) {
		if (delayedChangeCallback && !delayedChangeDetected) {
			delayedChangeDetected = true;
			delayedChangeReportTime = std::chrono::system_clock::now() + delayedChangeDelay;
		}
	}

	// compress marker and squiggle lists (if required)
	if (deletesHappened) {
		if (markers.size()) {
			compressMarkers();
		}

		if (squiggles.size()) {
			compressSquiggles();
		}

		deletesHappened = false;
	}

	// remember if document was changed this frame
	bool documentChanged = document.isUpdated();

	// reset overlay "dirty" flags
	document.resetUpdated();
	bracketeer.resetUpdated();
	lineFold.resetUpdated();
	typeSetter.resetUpdated();

	// get "new" total editor size in pixels
	auto width =
		textLeftOffset +
		typeSetter.getColumnCount() * glyphSize.x +
		cursorWidth +
		(config.showMiniMap ? miniMapWidth : 0.0f);

	auto height = typeSetter.getRowCount() * glyphSize.y;
	totalSize = ImVec2(width, height);

	return documentChanged;
}


//
//	TextEditor::handleKeyboardInputs
//

void TextEditor::handleKeyboardInputs() {
	if (ImGui::IsWindowFocused()) {
		auto& io = ImGui::GetIO();
		io.WantCaptureKeyboard = true;
		io.WantTextInput = true;
		auto macOS = io.ConfigMacOSXBehaviors;

		// ignore specific keys when autocomplete is active, they will be handled later
		if (autocomplete.isActive() && autocomplete.isSpecialKeyPressed()) {
			if (autocomplete.hasSuggestions()) {
				return;

			} else {
				// cancel autocomplete when special keys are used without any suggestions
				autocomplete.cancel();
			}
		}

		// cursor movements and selections
		if (ImGui::Shortcut(ImGuiKey_UpArrow, ImGuiInputFlags_Repeat)) { moveUp(1, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_UpArrow, ImGuiInputFlags_Repeat)) { moveUp(1, true); }
		else if (ImGui::Shortcut(ImGuiKey_DownArrow, ImGuiInputFlags_Repeat)) { moveDown(1, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_DownArrow, ImGuiInputFlags_Repeat)) { moveDown(1, true); }

		else if (ImGui::Shortcut((macOS ? ImGuiMod_Super : ImGuiMod_Alt) | ImGuiMod_Shift | ImGuiKey_LeftArrow)) { shrinkSelections(); }
		else if (ImGui::Shortcut((macOS ? ImGuiMod_Super : ImGuiMod_Alt) | ImGuiMod_Shift | ImGuiKey_RightArrow)) { growSelections(); }

		else if (ImGui::Shortcut(ImGuiKey_LeftArrow, ImGuiInputFlags_Repeat)) { moveLeft(false, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_LeftArrow, ImGuiInputFlags_Repeat)) { moveLeft(true, false); }
		else if (ImGui::Shortcut((macOS ? ImGuiMod_Alt : ImGuiMod_Ctrl) | ImGuiKey_LeftArrow, ImGuiInputFlags_Repeat)) { moveLeft(false, true); }
		else if (ImGui::Shortcut((macOS ? ImGuiMod_Alt : ImGuiMod_Ctrl) | ImGuiMod_Shift | ImGuiKey_LeftArrow, ImGuiInputFlags_Repeat)) { moveLeft(true, true); }

		else if (ImGui::Shortcut(ImGuiKey_RightArrow, ImGuiInputFlags_Repeat)) { moveRight(false, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_RightArrow, ImGuiInputFlags_Repeat)) { moveRight(true, false); }
		else if (ImGui::Shortcut((macOS ? ImGuiMod_Alt : ImGuiMod_Ctrl) | ImGuiKey_RightArrow, ImGuiInputFlags_Repeat)) { moveRight(false, true); }
		else if (ImGui::Shortcut((macOS ? ImGuiMod_Alt : ImGuiMod_Ctrl) | ImGuiMod_Shift | ImGuiKey_RightArrow, ImGuiInputFlags_Repeat)) { moveRight(true, true); }

		else if (ImGui::Shortcut(ImGuiKey_PageUp, ImGuiInputFlags_Repeat)) { moveUp(lastVisibleRow - firstVisibleRow - 2, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_PageUp, ImGuiInputFlags_Repeat)) { moveUp(lastVisibleRow - firstVisibleRow - 2, true); }
		else if (ImGui::Shortcut(ImGuiKey_PageDown, ImGuiInputFlags_Repeat)) { moveDown(lastVisibleRow - firstVisibleRow - 2, false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_PageDown, ImGuiInputFlags_Repeat)) { moveDown(lastVisibleRow - firstVisibleRow - 2, true); }

		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_UpArrow)) { moveToTop(false); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Home)) { moveToTop(false); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_UpArrow)) { moveToTop(true); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Home)) { moveToTop(true); }

		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_DownArrow)) { moveToBottom(false); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_End)) { moveToBottom(false); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_DownArrow)) { moveToBottom(true); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_End)) { moveToBottom(true); }

		else if (ImGui::Shortcut(ImGuiKey_Home)) { moveToStartOfLine(false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_Home)) { moveToStartOfLine(true); }

		else if (ImGui::Shortcut(ImGuiKey_End)) { moveToEndOfLine(false); }
		else if (ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_End)) { moveToEndOfLine(true); }

		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_A)) { selectAll(); }
		else if (cursors.currentCursorHasSelection() && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_D)) { addNextOccurrence(false); }
		else if (cursors.currentCursorHasSelection() && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Alt | ImGuiKey_D)) { addNextOccurrence(true); }
		else if (cursors.currentCursorHasSelection() && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Alt | ImGuiKey_L)) { addNextOccurrence(true); }
		else if (cursors.currentCursorHasSelection() && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_D)) { selectAllOccurrences(false); }
		else if (cursors.currentCursorHasSelection() && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Alt | ImGuiMod_Shift | ImGuiKey_D)) { selectAllOccurrences(true); }

		// clipboard operations
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_X)) { cut(); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Delete)) { cut(); }

		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_C)) { copy(); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Insert)) { copy(); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_V, ImGuiInputFlags_Repeat)) { paste(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Insert, ImGuiInputFlags_Repeat)) { paste(); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Z, ImGuiInputFlags_Repeat)) { undo(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_Z, ImGuiInputFlags_Repeat)) { redo(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Y, ImGuiInputFlags_Repeat)) { redo(); }

		// remove text
		else if (!config.readOnly && ImGui::Shortcut(ImGuiKey_Delete, ImGuiInputFlags_Repeat)) { handleDelete(false); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_Delete, ImGuiInputFlags_Repeat)) { handleDelete(true); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiKey_Backspace, ImGuiInputFlags_Repeat)) { handleBackspace(false); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_Backspace, ImGuiInputFlags_Repeat)) { handleBackspace(true); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_K)) { removeSelectedLines(); }

		// text manipulation
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_LeftBracket, ImGuiInputFlags_Repeat)) { deindentLines(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_RightBracket, ImGuiInputFlags_Repeat)) { indentLines(); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_UpArrow)) { moveUpLines(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Alt | ImGuiKey_DownArrow)) { moveDownLines(); }

		else if (!config.readOnly && config.language && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Slash)) { toggleComments(); }
		else if (!config.readOnly && config.language && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_L)) { toggleComments(); }

		// find/replace support
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_F)) {
			if (autocomplete.isActive()) {
				autocomplete.cancel();
				findCancelledAutocomplete = true;
			}

			openFindReplace();
		}

		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiMod_Shift | ImGuiKey_F)) { findAll(); }
		else if (ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_G, ImGuiInputFlags_Repeat)) { findNext(); }

		// autocomplete support
		else if (!config.readOnly && ImGui::Shortcut(autocomplete.getTriggerShortcut())) {
			// don't activate if we have multiple cursors active
			if (cursors.hasMultiple()) {
				// TODO: inform user

			} else {
				if (autocomplete.startShortcut(cursors)) {
					makeCursorVisible();
				}
			}
		}

		// change insert mode
		else if (ImGui::Shortcut(ImGuiKey_Insert)) { config.overwrite = !config.overwrite; }

		// handle new line
		else if (!config.readOnly && ImGui::Shortcut(ImGuiKey_Enter, ImGuiInputFlags_Repeat) ) { handleCharacter('\n'); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiKey_KeypadEnter, ImGuiInputFlags_Repeat)) { handleCharacter('\n'); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_Enter, ImGuiInputFlags_Repeat)) { insertLineBelow(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Ctrl | ImGuiKey_KeypadEnter, ImGuiInputFlags_Repeat)) { insertLineBelow(); }

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_Enter, ImGuiInputFlags_Repeat)) { insertLineAbove(); }
		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_KeypadEnter, ImGuiInputFlags_Repeat)) { insertLineAbove(); }

		// handle tabs
		else if (!config.readOnly && ImGui::Shortcut(ImGuiKey_Tab, ImGuiInputFlags_Repeat)) {
			if (cursors.anyHasSelection()) {
				indentLines();

			} else {
				handleCharacter('\t');
			}
		}

		else if (!config.readOnly && ImGui::Shortcut(ImGuiMod_Shift | ImGuiKey_Tab, ImGuiInputFlags_Repeat)) {
				deindentLines();
		}

		// handle escape key
		else if ((autocomplete.isActive() || findReplaceVisible || cursors.hasMultiple()) && ImGui::Shortcut(ImGuiKey_Escape)) {
			if (autocomplete.isActive()) {
				autocomplete.cancel();

			} else if (findReplaceVisible) {
				closeFindReplace();

			} else if (cursors.hasMultiple()) {
				cursors.clearAdditional();
			}
		}

		// handle regular text
		if (!io.InputQueueCharacters.empty()) {
			// ignore Ctrl inputs, but need to allow Alt+Ctrl as some keyboards (e.g. German) use AltGR (which is Alt+Ctrl) to input certain characters
			if (!(ImGui::IsKeyDown(ImGuiMod_Ctrl) && !ImGui::IsKeyDown(ImGuiMod_Alt)) && !config.readOnly) {
				for (auto i = 0; i < io.InputQueueCharacters.size(); i++) {
					auto character = io.InputQueueCharacters[i];

					if (character == '\n' || character >= 32) {
						handleCharacter(character);
					}
				}
			}

			io.InputQueueCharacters.resize(0);
		}

		// notify OS of text input position for advanced Input Method Editor (IME)
		// this is required for the SDL3 backend as it will not report text input events unless we do this
		// see https://github.com/ocornut/imgui/issues/8584 for details
		if (!config.readOnly) {
			auto context = ImGui::GetCurrentContext();
			context->PlatformImeData.WantVisible = true;
			context->PlatformImeData.WantTextInput = true;
			context->PlatformImeData.InputPos = ImVec2(cursorScreenPos.x - 1.0f, cursorScreenPos.y - context->FontSize);
			context->PlatformImeData.InputLineHeight = context->FontSize;
			context->PlatformImeData.ViewportId = ImGui::GetCurrentWindow()->Viewport->ID;
		}
	}
}


//
//	TextEditor::handleMouseInteractions
//

void TextEditor::handleMouseInteractions() {
	auto io = ImGui::GetIO();
	auto mousePos = ImGui::GetMousePos() - cursorScreenPos;
	auto absoluteMousePos = ImGui::GetMousePos() - ImGui::GetWindowPos();

	auto overLineNumbers =
		config.showLineNumbers &&
		(absoluteMousePos.x > lineNumberLeftOffset) &&
		(absoluteMousePos.x < lineNumberRightOffset);

	auto overText =
		mousePos.x - ImGui::GetScrollX() > textLeftOffset &&
		mousePos.x - ImGui::GetScrollX() < textRightOffset &&
		mousePos.y - ImGui::GetScrollY() >= 0 &&
		mousePos.y - ImGui::GetScrollY() < textSize.y;

	auto overMiniMap = config.showMiniMap && absoluteMousePos.x > miniMapOffset;

	DocPos glyphPos;
	DocPos cursorPos;

	typeSetter.screenPos2DocPos(
		document,
		ImVec2((mousePos.x - textLeftOffset) / glyphSize.x, mousePos.y / glyphSize.y),
		glyphPos,
		cursorPos);

	panning &= config.panMode && ImGui::IsMouseDown(ImGuiMouseButton_Middle);

	// handle middle mouse button panning
	if (panning && ImGui::IsMouseDragging(ImGuiMouseButton_Middle)) {
		auto windowSize = ImGui::GetWindowSize();
		auto mouseDelta = ImGui::GetMouseDragDelta(ImGuiMouseButton_Middle);
		float dragFactor = ImGui::GetIO().DeltaTime * 15.0f;
		ImVec2 autoPanMargin(glyphSize.x * 4.0f, glyphSize.y * 2.0f);

		if (absoluteMousePos.x < textLeftOffset + autoPanMargin.x) {
			mouseDelta.x = (absoluteMousePos.x - (textLeftOffset + autoPanMargin.x)) * dragFactor;

		} else if (absoluteMousePos.x > windowSize.x - autoPanMargin.x) {
			mouseDelta.x = (absoluteMousePos.x - (windowSize.x - autoPanMargin.x)) * dragFactor;
		}

		if (absoluteMousePos.y < autoPanMargin.y) {
			mouseDelta.y = (absoluteMousePos.y - autoPanMargin.y) * dragFactor;

		} else if (absoluteMousePos.y > windowSize.y - autoPanMargin.y) {
			mouseDelta.y = (absoluteMousePos.y - (windowSize.y - autoPanMargin.y)) * dragFactor;
		}

		ImGui::SetScrollX(ImGui::GetScrollX() - mouseDelta.x);
		ImGui::SetScrollY(ImGui::GetScrollY() - mouseDelta.y);
		ImGui::ResetMouseDragDelta(ImGuiMouseButton_Middle);

	// handle middle mouse button scrolling
	} else if (scrolling) {
		float deadzone = glyphSize.x;
		auto offset = scrollStart - absoluteMousePos;
		offset.x = (offset.x < 0.0f) ? std::min(offset.x + deadzone, 0.0f) : std::max(offset.x - deadzone, 0.0f);
		offset.y = (offset.y < 0.0f) ? std::min(offset.y + deadzone, 0.0f) : std::max(offset.y - deadzone, 0.0f);

		float scrollFactor = ImGui::GetIO().DeltaTime * 5.0f;
		offset *= scrollFactor;

		ImGui::SetScrollX(ImGui::GetScrollX() - offset.x);
		ImGui::SetScrollY(ImGui::GetScrollY() - offset.y);

		if (ImGui::IsMouseClicked(ImGuiMouseButton_Left) ||
			ImGui::IsMouseClicked(ImGuiMouseButton_Middle) ||
			ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {

			scrolling = false;
		}

	// handle left mouse button dragging
	} else if (ImGui::IsMouseDragging(ImGuiMouseButton_Left)) {
		// update selection with dragging left mouse button
		io.WantCaptureMouse = true;

		if (miniMapIsScrollbar) {
			auto localOffset = absoluteMousePos.y - miniMapScrollStart;
			auto documentOffset = localOffset * totalSize.y / textSize.y;
			auto scrollY = miniMapScrollY + documentOffset;
			scrollY = std::clamp(scrollY, 0.0f, totalSize.y - textSize.y);
			ImGui::SetScrollY(scrollY);

		} else if (selectingText && overLineNumbers) {
			auto& cursor = cursors.getCurrent();
			auto start = DocPos(cursorPos.line, 0);
			auto end = normalizePos(DocPos(cursorPos.line + 1, 0));
			cursor.update(cursor.getInteractiveEnd() < cursor.getInteractiveStart() ? start : end);
			makeCursorVisible();

		} else if (selectingText && overText) {
			cursors.updateCurrentCursor(cursorPos);
			makeCursorVisible();
		}

	// end minimap scroll (if required)
	} else if (ImGui::IsMouseReleased(ImGuiMouseButton_Left)) {
		miniMapIsScrollbar = false;
		selectingText = false;

	// ignore other interactions when the editor is not hovered
	} else if (ImGui::IsWindowHovered()) {
		// show text cursor if required
		if (ImGui::IsWindowFocused() && overText) {
			ImGui::SetMouseCursor(ImGuiMouseCursor_TextInput);
		}

		if (ImGui::IsMouseClicked(ImGuiMouseButton_Middle)) {
			// start panning/scrolling mode on middle mouse click
			if (config.panMode) {
				panning = true;

			} else {
				scrolling = true;
				scrollStart = absoluteMousePos;
			}

		} else if (ImGui::IsMouseClicked(ImGuiMouseButton_Right)) {
			// handle right clicks by setting up context menu (if required)
			if (overLineNumbers && lineNumberContextMenuCallback) {
				popupDocPos = glyphPos;
				ImGui::OpenPopup("LineNumberContextMenu");

			} else if (overText && textContextMenuCallback) {
				popupDocPos = glyphPos;
				ImGui::OpenPopup("TextContextMenu");
			}

		} else if (ImGui::IsMouseClicked(ImGuiMouseButton_Left)) {
			// handle left mouse button actions
			selectingText = overText || overLineNumbers;
			auto doubleClick = ImGui::IsMouseDoubleClicked(ImGuiMouseButton_Left);
			auto now = static_cast<float>(ImGui::GetTime());
			auto tripleClick = !doubleClick && lastClickTime != -1.0f && (now - lastClickTime) < io.MouseDoubleClickTime;
			lastClickTime = tripleClick ? -1.0f : now;

			if (tripleClick) {
				// left mouse button triple click
				if (overText) {
					auto start = document.getStartOfLine(cursorPos);
					auto end = normalizePos(DocPos(start.line + 1, 0));
					cursors.updateCurrentCursor(start, end);
				}

			} else if (doubleClick) {
				// left mouse button double click
				if (overText) {
					auto codepoint = document.getCodePoint(glyphPos);
					bool handled = false;

					// select bracketed section (if required)
					if (CodePoint::isBracketOpener(codepoint)) {
						auto brackets = bracketeer.getEnclosingBrackets(document.getRight(glyphPos));

						if (brackets != bracketeer.end()) {
							if (ImGui::IsKeyDown(ImGuiMod_Shift)) {
								cursors.setCursor(brackets->start, document.getRight(brackets->end));

							} else {
								cursors.setCursor(document.getRight(brackets->start), brackets->end);
							}

							handled = true;
						}

					} else if (CodePoint::isBracketCloser(codepoint)) {
						auto brackets = bracketeer.getEnclosingBrackets(glyphPos);

						if (brackets != bracketeer.end()) {
							cursors.setCursor(brackets->start, document.getRight(brackets->end));
							handled = true;
						}
					}

					// select "word" if it wasn't a bracketed section
					// run of whitespaces are considered "words" as are operator sequences
					if (!handled && !document.isEndOfLine(glyphPos)) {
						auto word = document.getWholeWord(glyphPos);

						if (word.start != word.end) {
							cursors.updateCurrentCursor(word.start, word.end);
						}
					}
				}

			} else {
				// left mouse button single click
				auto extendCursor = ImGui::IsKeyDown(ImGuiMod_Shift);

				auto addCursor = ImGui::GetIO().ConfigMacOSXBehaviors
					? ImGui::IsKeyDown(ImGuiMod_Alt) :
					ImGui::IsKeyDown(ImGuiMod_Ctrl);

				if (overLineNumbers) {
					// handle line number clicks
					auto start = DocPos(cursorPos.line, 0);
					auto end = normalizePos(DocPos(cursorPos.line + 1, 0));

					if (extendCursor) {
						auto& cursor = cursors.getCurrent();
						cursor.update(cursor.getInteractiveEnd() < cursor.getInteractiveStart() ? start : end);
						autocomplete.cancel();

					} else if (addCursor) {
						cursors.addCursor(start, end);
						autocomplete.cancel();

					} else {
						cursors.setCursor(start, end);
					}

					makeCursorVisible();

				} else if (overText) {
					// handle mouse clicks in text
					if (extendCursor) {
						cursors.growCurrentCursor(cursorPos);
						autocomplete.cancel();

					} else if (addCursor) {
						cursors.addCursor(cursorPos);
						autocomplete.cancel();

					} else {
						cursors.setCursor(cursorPos);
					}

					makeCursorVisible();

				} else if (overMiniMap) {
					if (ImGui::GetCurrentWindow()->ScrollbarY) {
						auto clickedRow = firstMiniMapRow + static_cast<size_t>(absoluteMousePos.y / miniMapRowHeight);

						if (clickedRow < firstVisibleRow || clickedRow > lastVisibleRow) {
							scrollToLine(visPos2DocPos(VisPos(clickedRow, 0)).line, Scroll::alignMiddle);

						} else {
							miniMapIsScrollbar = true;
							miniMapScrollStart = absoluteMousePos.y;
							miniMapScrollY = ImGui::GetScrollY();
						}
					}
				}
			}

		} else if (textHoverCallback && IsMousePosOverGlyph(ImGui::GetMousePos())) {
			// capture position for text hover popup
			popupDocPos = document.findWordStart(glyphPos, true);
			auto vizPos = docPos2VisPos(popupDocPos);

			popupWindowPos = ImVec2(
				vizPos.column * glyphSize.x + textLeftOffset + cursorScreenPos.x,
				vizPos.row * glyphSize.y + cursorScreenPos.y);

			// only open popup if required
			if (!ImGui::IsPopupOpen("TextHoverPopup")) {
				ImGui::OpenPopup("TextHoverPopup");
			}
		}

		// update cursors and reset vertical navigation if any button was pressed
		bool anyMouseDown = false;

		for (size_t i = 0; !anyMouseDown && i < static_cast<size_t>(ImGuiMouseButton_Middle); i++) {
			if (ImGui::IsMouseDown(static_cast<ImGuiMouseButton>(i))) {
				anyMouseDown = true;
			}
		}

		if (anyMouseDown) {
			cursors.update(document);
			navigatingVertically = false;
		}
	}
}


//
//	TextEditor::isDocPosVisible
//

bool TextEditor::isDocPosVisible(DocPos docPos) const {
	if (isLineHidden(docPos.line)) {
		return false;

	} else {
		auto visPos = docPos2VisPos(docPos);

		return
			visPos.row >= firstVisibleRow && visPos.row < lastVisibleRow &&
			visPos.column >= firstVisibleColumn && visPos.column < lastVisibleColumn;
	}
}


//
//	TextEditor::selectAll
//

void TextEditor::selectAll() {
	moveToTop(false);
	moveToBottom(true);
}


//
//	TextEditor::selectLine
//

void TextEditor::selectLine(size_t line) {
	moveTo(DocPos(line, 0), false);
	moveTo(normalizePos(DocPos(line + 1, 0)), true);
}


//
//	TextEditor::selectLines
//

void TextEditor::selectLines(size_t startLine, size_t endLine) {
	moveTo(DocPos(startLine, 0), false);
	moveTo(DocPos(endLine, 0), true);
}


//
//	TextEditor::selectRegion
//

void TextEditor::selectRegion(DocPos start, DocPos end) {
	if (end < start) {
		std::swap(start, end);
	}

	cursors.setCursor(start, end);
}


//
//	TextEditor::selectToBrackets
//

void TextEditor::selectToBrackets(bool includeBrackets) {
	for (auto& cursor : cursors) {
		auto bracket = bracketeer.getEnclosingBrackets(cursor.getSelectionStart());

		if (bracket != bracketeer.end()) {
			if (includeBrackets) {
				cursor.update(bracket->start, document.getRight(bracket->end));

			} else {
				cursor.update(document.getRight(bracket->start), bracket->end);
			}
		}
	}
}


//
//	TextEditor::growSelections
//

void TextEditor::growSelections() {
	for (auto& cursor : cursors) {
		if (cursor.hasSelection()) {
			auto start = cursor.getSelectionStart();
			auto end = cursor.getSelectionEnd();
			auto startCodePoint = document.getCodePoint(document.getLeft(start));
			auto endCodePoint = document.getCodePoint(end);

			if (CodePoint::isBracketOpener(startCodePoint) && endCodePoint == CodePoint::toPairCloser(startCodePoint)) {
				cursor.update(document.getLeft(start),document.getRight(end));

			} else {
				auto bracket = bracketeer.getEnclosingBrackets(start, end);

				if (bracket != bracketeer.end()) {
					cursor.update(document.getRight(bracket->start), bracket->end);
				}
			}

		} else {
			auto pos = cursor.getSelectionEnd();
			auto start = document.findWordStart(pos);
			auto end = document.findWordEnd(pos);
			cursor.update(start, end);
		}
	}
}


//
//	TextEditor::shrinkSelections
//

void TextEditor::shrinkSelections() {
	for (auto& cursor : cursors) {
		if (cursor.hasSelection()){
			auto start = cursor.getSelectionStart();
			auto end = cursor.getSelectionEnd();
			auto startCodePoint = document.getCodePoint(start);
			auto endCodePoint = document.getCodePoint(document.getLeft(end));

			if (CodePoint::isBracketOpener(startCodePoint) && endCodePoint == CodePoint::toPairCloser(startCodePoint)) {
				cursor.update(document.getRight(start),document.getLeft(end));

			} else {
				auto bracket = bracketeer.getInnerBrackets(start, end);

				if (bracket != bracketeer.end()) {
					cursor.update(bracket->start, document.getRight(bracket->end));
				}
			}
		}
	}
}


//
//	TextEditor::cut
//

void TextEditor::cut() {
	// copy selections to clipboard and remove them
	copy();
	auto transaction = startTransaction();
	deleteTextFromAllCursors(transaction);
	cursors.getCurrent().resetToStart();
	endTransaction(transaction);
}


//
//	TextEditor::copy
//

void TextEditor::copy() const {
	// copy all selections and put them on the clipboard
	// empty cursors copy the entire line
	std::string text;

	if (cursors.anyHasSelection()) {
		for (auto& cursor : cursors) {
			if (text.size()) {
				text += "\n";
			}

			if (cursor.hasSelection()) {
				text += document.getSectionText(cursor.getSelectionStart(), cursor.getSelectionEnd());

			} else {
				text += document.getLineText(cursor.getSelectionStart().line);
			}
		}

	} else {
		for (auto& cursor : cursors) {
			text += document.getLineText(cursor.getSelectionStart().line) + "\n";
		}
	}

	ImGui::SetClipboardText(text.c_str());
}


//
//	TextEditor::paste
//

void TextEditor::paste() {
	// ignore non-text clipboard content
	auto clipboard = ImGui::GetClipboardText();

	if (clipboard) {
		auto transaction = startTransaction();
		insertTextIntoAllCursors(transaction, clipboard);
		endTransaction(transaction);
	}
}


//
//	TextEditor::undo
//

void TextEditor::undo() {
	if (transactions.canUndo()) {
		transactions.undo(config, document, cursors);
		makeCursorVisible();
	}
}


//
//	TextEditor::redo
//

void TextEditor::redo() {
	if (transactions.canRedo()) {
		transactions.redo(config, document, cursors);
		makeCursorVisible();
	}
}


//
//	TextEditor::getCursorPosition
//

TextEditor::DocPos TextEditor::getCursorPosition(size_t cursor) const {
	cursor = std::min(cursor, cursors.size() - 1);
	return cursors[cursor].getInteractiveEnd();
}


//
//	TextEditor::getCursor
//

TextEditor::DocSelection TextEditor::getCursorSelection(size_t cursor) const {
	cursor = std::min(cursor, cursors.size() - 1);
	auto start = cursors[cursor].getSelectionStart();
	auto end = cursors[cursor].getSelectionEnd();
	return DocSelection(start, end);
}


//
//	TextEditor::isMousePosOverGlyph
//

bool TextEditor::isMousePosOverGlyph(const ImVec2& mousePos) const {
	if (firstFrame) {
		return false;

	} else {
		// convert mouse position to screen coordinates
		auto local = mousePos - cursorScreenPos;

		// ignore negative coordinates
		if (local.x < 0.0f || local.y < 0.0f) {
			return false;
		}

		// convert to visual position and check it
		VisPos visPos(static_cast<size_t>(local.y / glyphSize.y), static_cast<size_t>((local.x - textLeftOffset) / glyphSize.x));
		return typeSetter.isVisPosOverGlyph(visPos);
	}
}


//
//	TextEditor::isMousePosOverTextArea
//

bool TextEditor::isMousePosOverTextArea(const ImVec2& mousePos) const {
	if (firstFrame) {
		return false;

	} else {
		// convert mouse position to screen coordinates
		auto local = mousePos - cursorScreenPos;
		return local.x > textLeftOffset && local.x < textRightOffset && local.y >= 0 && local.y < textSize.y;
	}
}


//
//	TextEditor::getDocPosAtMousePos
//

TextEditor::DocPos TextEditor::getDocPosAtMousePos(const ImVec2& mousePos) const {
	if (firstFrame) {
		return DocPos();

	} else {
		// convert mouse position to screen coordinates
		auto local = mousePos - cursorScreenPos;

		// ignore negative coordinates
		if (local.y < 0.0f) {
			return DocPos(0, 0);

		} else if (local.x < 0.0f) {
			local.x = 0.0f;
		}

		// convert to document position
		VisPos visPos(static_cast<size_t>(local.y / glyphSize.y), static_cast<size_t>((local.x - textLeftOffset) / glyphSize.x));
		return visPos2DocPos(normalizePos(visPos));
	}
}


//
//	TextEditor::getWordAtMousePos
//

std::string TextEditor::getWordAtMousePos(const ImVec2& mousePos) const {
	if (IsMousePosOverGlyph(mousePos)) {
		// convert to document position
		DocPos docPos = getDocPosAtMousePos(mousePos);

		// Find word boundaries and extract text
		auto word = document.getWholeWord(docPos, true);
		return document.getSectionText(word.start, word.end);

	} else {
		return "";
	}
}


//
//	TextEditor::setCursor
//

void TextEditor::setCursor(DocPos pos) {
	ensureVisiblePos = normalizePos(pos);
	cursors.setCursor(ensureVisiblePos);

	if (config.lineFolding) {
		lineFold.unfoldAroundLine(document, ensureVisiblePos.line);
	}
}


//
//	TextEditor::scrollToLine
//

void TextEditor::scrollToLine(size_t line, Scroll alignment, float fraction) {
	ensureVisiblePos = DocPos(invalidLine, 0);
	scrollToLineNumber = std::min(line, document.size());
	scrollToAlignment = alignment;
	scrollToFraction = fraction;

	if (config.lineFolding) {
		lineFold.unfoldAroundLine(document, line);
	}
}


//
//	TextEditor::handlePossibleScrolling
//

void TextEditor::handlePossibleScrolling() {
	// apply scrolling (if needed)
	float scrollX = -1.0f;
	float scrollY = -1.0f;

	// do we need to make a certain position visible
	if (ensureVisiblePos.line != invalidLine) {
		if (lastVisibleRow == 0 && lastVisibleColumn == 0) {
			// this is a hack to handle a chicken and egg issue when the user called SetCursor before the first frame
			lastVisibleRow = std::min(static_cast<size_t>(std::ceil(textSize.y / glyphSize.y)), typeSetter.getRowCount() - 1);
			lastVisibleColumn = static_cast<size_t>(std::ceil(textSize.x / glyphSize.x));
		}

		auto pos = docPos2VisPos(ensureVisiblePos);

		if (pos.row <= firstVisibleRow + 1) {
			scrollY = std::max(0.0f, (pos.row - 2.0f) * glyphSize.y);

		} else if (pos.row >= lastVisibleRow - 1) {
			scrollY = std::max(0.0f, (pos.row + 2.0f) * glyphSize.y - textSize.y);
		}

		if (pos.column <= firstVisibleColumn + 1) {
			scrollX = std::max(0.0f, (pos.column - 2.0f) * glyphSize.x);

		} else if (pos.column >= lastVisibleColumn - 1) {
			scrollX = std::max(0.0f, (pos.column + 2.0f) * glyphSize.x - textSize.x);
		}

		ensureVisiblePos.line = invalidLine;
	}

	// scroll to specified line (if required)
	if (scrollToLineNumber != invalidLine) {
		auto row = static_cast<float>(docPos2VisPos(DocPos(scrollToLineNumber, 0)).row);
		auto visibleRows = textSize.y / glyphSize.y;
		scrollX = 0.0f;

		switch (scrollToAlignment) {
			case Scroll::alignTop:
				scrollY = (row + scrollToFraction) * glyphSize.y;
				break;

			case Scroll::alignMiddle:
				scrollY = std::max(0.0f, (row - visibleRows / 2.0f) * glyphSize.y);
				break;

			case Scroll::alignBottom:
				scrollY = std::max(0.0f, (row - (visibleRows - 1.0f)) * glyphSize.y);
				break;
		}

		scrollToLineNumber = invalidLine;
	}

	// set scroll (if required)
	if (scrollX >= 0.0f) {
		ImGui::SetScrollX(scrollX);
	}

	if (scrollY >= 0.0f) {
		ImGui::SetScrollY(scrollY);
	}
}


//
//	TextEditor::makeCursorVisible
//

void TextEditor::makeCursorVisible() {
	ensureVisiblePos = cursors.getCurrent().getInteractiveEnd();
	scrollToLineNumber = invalidLine;

	if (config.lineFolding) {
		lineFold.unfoldAroundLine(document, cursors.getCurrent().getInteractiveEnd().line);
	}

	resetCursorAnimationTimer();
}


//
//	TextEditor::resetScrolling
//

void TextEditor::resetScrolling() {
	// reset state related parameters
	ensureVisiblePos = DocPos(invalidLine, 0);
	scrollToLineNumber = invalidLine;
	firstVisibleRow = 0;
	lastVisibleRow = 0;
	firstVisibleColumn = 0;
	lastVisibleColumn = 0;
	resetCursorAnimationTimer();

	// we can't reset the Dear ImGui scrolling here as we don't necessarily have the right context
	// so we just set a flag and the render function will handle it
	resetDearImGuiScrolling = true;
}


//
//	TextEditor::addMarker
//

void TextEditor::addMarker(size_t line, ImU32 lineNumberColor, ImU32 textColor, const std::string_view& lineNumberTooltip, const std::string_view& textTooltip) {
	if (line < document.size()) {
		markers.emplace_back(lineNumberColor, textColor, lineNumberTooltip, textTooltip);
		document[line].marker = markers.size();
	}
}


//
//	TextEditor::clearMarkers
//

void TextEditor::clearMarkers() {
	for (auto& line : document) {
		line.marker = 0;
	}

	markers.clear();
}


//
//	TextEditor::compressMarkers
//

void TextEditor::compressMarkers() {
	if (markers.size()) {
		// references to current markers
		struct Reference {
			bool used = false;
			bool index = 0;
		};

		std::vector<Reference> references(markers.size());

		// determine markers still in use
		for (auto& line : document) {
			if (line.marker) {
				references[line.marker - 1].used = true;
			}
		}

		// reindex markers
		size_t index = 0;

		for (auto& reference : references) {
			if (reference.used) {
				reference.index = index++;
			}
		}

		// apply new index numbers to lines
		for (auto& line : document) {
			if (line.marker) {
				line.marker = references[line.marker - 1].index + 1;
			}
		}

		// remove unused markers
		size_t i = markers.size();

		do {
			i--;

			if (!references[i].used) {
				markers.erase(markers.begin() + i);
			}

		} while (i > 0);
	}
}


//
//	TextEditor::addSquiggle
//

void TextEditor::addSquiggle(DocPos start, DocPos end, size_t type, ImU32 color, const std::string_view& tooltip) {
	if (start < end) {
		squiggles.emplace_back(type, color, tooltip);
		auto index = squiggles.size();

		document.iterateGlyphs(start, end, [index](Glyph& glyph) {
			glyph.squiggle = index;
		});
	}
}


//
//	TextEditor::clearSquiggles
//

void TextEditor::clearSquiggles(size_t type) {
	for (auto& line : document) {
		for (auto& glyph : line) {
			if (glyph.squiggle) {
				if (squiggles[glyph.squiggle - 1].type == type) {
					glyph.squiggle = 0;
				}
			}
		}
	}

	compressSquiggles();
}


//
//	TextEditor::clearSquiggles
//

void TextEditor::clearSquiggles(DocPos start, DocPos end) {
	document.iterateGlyphs(start, end, [](Glyph& glyph) {
		glyph.squiggle = 0;
	});

	compressSquiggles();
}


//
//	TextEditor::clearSquiggles
//

void TextEditor::clearSquiggles() {
	for (auto& line : document) {
		for (auto& glyph : line) {
			glyph.squiggle = 0;
		}
	}

	squiggles.clear();
}


//
//	TextEditor::compressSquiggles
//

void TextEditor::compressSquiggles() {
	if (squiggles.size()) {
		// references to current squiggles;
		struct Reference {
			bool used = false;
			bool index = 0;
		};

		std::vector<Reference> references(squiggles.size());

		// determine squiggles still in use
		for (auto& line : document) {
			for (auto& glyph : line) {
				if (glyph.squiggle) {
					references[glyph.squiggle - 1].used = true;
				}
			}
		}

		// reindex squiggles
		size_t index = 0;

		for (auto& reference : references) {
			if (reference.used) {
				reference.index = index++;
			}
		}

		// apply new index numbers to glyphs
		for (auto& line : document) {
			for (auto& glyph : line) {
				if (glyph.squiggle) {
					glyph.squiggle = references[glyph.squiggle - 1].index + 1;
				}
			}
		}

		// remove unused squiggles
		size_t i = squiggles.size();

		do {
			i--;

			if (!references[i].used) {
				squiggles.erase(squiggles.begin() + i);
			}

		} while (i > 0);
	}
}


//
//	TextEditor::moveUp
//

void TextEditor::moveUp(size_t rows, bool select) {
	// these must be done with visual coordinates
	for (auto& cursor : cursors) {
		auto visPos = docPos2VisPos(cursor.getInteractiveEnd());

		if (navigatingVertically) {
			visPos.column = cursor.getPreferredColumn();

		} else {
			cursor.setPreferredColumn(visPos.column);
		}

		if (rows > visPos.row) {
			visPos.row = 0;

		} else {
			visPos.row -= rows;
		}

		visPos = normalizePos(visPos);
		cursor.update(visPos2DocPos(visPos), select);
	}

	makeCursorVisible();
	navigatingVertically = true;
}


//
//	TextEditor::moveDown
//

void TextEditor::moveDown(size_t rows, bool select) {
	// these must be done with visual coordinates
	for (auto& cursor : cursors) {
		auto visPos = docPos2VisPos(cursor.getInteractiveEnd());

		if (navigatingVertically) {
			visPos.column = cursor.getPreferredColumn();

		} else {
			cursor.setPreferredColumn(visPos.column);
		}

		visPos.row += rows;
		visPos = normalizePos(visPos);
		cursor.update(visPos2DocPos(visPos), select);
	}

	makeCursorVisible();
	navigatingVertically = true;
}


//
//	TextEditor::moveLeft
//

void TextEditor::moveLeft(bool select, bool wordMode) {
	for (auto& cursor : cursors) {
		if (cursor.hasSelection() && !select && !wordMode) {
			cursor.resetToStart();

		} else {
			cursor.update(document.getLeft(cursor.getInteractiveEnd(), wordMode), select);
		}
	}

	makeCursorVisible();
	navigatingVertically = false;
}


//
//	TextEditor::moveRight
//

void TextEditor::moveRight(bool select, bool wordMode) {
	for (auto& cursor : cursors) {
		if (cursor.hasSelection() && !select && !wordMode) {
			cursor.resetToEnd();

		} else {
			cursor.update(document.getRight(cursor.getInteractiveEnd(), wordMode), select);
		}
	}

	makeCursorVisible();
	navigatingVertically = false;
}


//
//	TextEditor::moveTo
//

void TextEditor::moveTo(DocPos coordinate, bool select) {
	cursors.clearAdditional();
	cursors.updateCurrentCursor(coordinate, select);
	makeCursorVisible();
	navigatingVertically = false;
}


//
//	TextEditor::handleCharacter
//

void TextEditor::handleCharacter(ImWchar character) {
	auto transaction = startTransaction(false);

	auto opener = character;
	auto isPaired = !config.overwrite && config.completePairedGlyphs && CodePoint::isPairOpener(opener);
	auto closer = CodePoint::toPairCloser(opener);

	// ignore input if it was the closing character for a pair that was automatically inserted
	if (completePairCloser) {
		if (completePairCloser == character && completePairLocation == cursors.getCurrent().getSelectionEnd()) {
			completePairCloser = 0;
			moveRight(false, false);
			return;
		}

		completePairCloser = 0;
	}

	if (cursors.anyHasSelection() && isPaired) {
		// encapsulate the current selections with the requested pairs
		for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
			if (cursor->hasSelection()) {
				auto start = cursor->getSelectionStart();
				auto end = cursor->getSelectionEnd();

				// insert the closing glyph
				char utf8[4];
				auto end1 = insertText(transaction, end, std::string_view(utf8, CodePoint::write(utf8, closer)));
				cursors.adjustForInsert(cursor, start, end1);

				// insert the opening glyph
				auto end2 = insertText(transaction, start, std::string_view(utf8, CodePoint::write(utf8, opener)));
				cursors.adjustForInsert(cursor, start, end2);

				// update old selection
				cursor->update(document.getRight(start), document.getRight(end));
			}
		}

	} else if (isPaired) {
		// insert the requested pair
		char utf8[8];
		auto size = CodePoint::write(utf8, opener);
		size += CodePoint::write(utf8 + size, closer);
		std::string_view pair(utf8, size);

		for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
			auto start = cursor->getSelectionStart();
			auto end = insertText(transaction, start, pair);
			cursors.adjustForInsert(cursor, start, end);
			cursor->update(document.getRight(start), false);
		}

		// remember the closer
		completePairCloser = closer;
		completePairLocation = cursors.getCurrent().getSelectionEnd();

	} else if (!config.overwrite && config.autoIndent && character == '\n') {
		// handle auto indent case
		autoIndentAllCursors(transaction);

	} else {
		// handle overwrite by deleting next glyph before insert
		if (config.overwrite) {
			for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
				if (!cursor->hasSelection()) {
					auto start = cursor->getSelectionStart();

					if (start != document.getEndOfLine(start)) {
						auto end = document.getRight(start);
						deleteText(transaction, start, end);
						cursors.adjustForDelete(cursor, start, end);
					}
				}
			}
		}

		// just insert a regular character
		char utf8[4];
		insertTextIntoAllCursors(transaction, std::string_view(utf8, CodePoint::write(utf8, character)));
	}

	endTransaction(transaction);

	if (CodePoint::isWord(character)) {
		if (!cursors.hasMultiple() && autocomplete.startTyping(cursors)) {
			makeCursorVisible();
		}
	}
}


//
//	TextEditor::handleBackspace
//

void TextEditor::handleBackspace(bool wordMode) {
	auto transaction = startTransaction(false);

	// remove selections or characters to the left of the cursor
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->hasSelection() ? cursor->getSelectionStart() : document.getLeft(cursor->getSelectionStart(), wordMode);
		auto end = cursor->getSelectionEnd();
		deleteText(transaction, start, end);
		cursor->update(start, false);
		cursors.adjustForDelete(cursor, start, end);
	}

	endTransaction(transaction);
}


//
//	TextEditor::handleDelete
//

void TextEditor::handleDelete(bool wordMode) {
	auto transaction = startTransaction(false);

	// remove selections or characters to the right of the cursor
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->getSelectionStart();
		auto end = cursor->hasSelection() ? cursor->getSelectionEnd() : document.getRight(cursor->getSelectionEnd(), wordMode);
		deleteText(transaction, start, end);
		cursor->update(start, false);
		cursors.adjustForDelete(cursor, start, end);
	}

	endTransaction(transaction);
}


//
//	TextEditor::removeSelectedLines
//

void TextEditor::removeSelectedLines() {
	auto transaction = startTransaction();

	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = document.getStartOfLine(cursor->getSelectionStart());
		auto end = cursor->getSelectionEnd();
		end = (end.index == 0) ? end : document.getNextLine(end);
		deleteText(transaction, start, end);
		cursor->update(start, false);
		cursors.adjustForDelete(cursor, start, end);
	}

	endTransaction(transaction);
}


//
//	TextEditor::insertLineAbove
//

void TextEditor::insertLineAbove() {
	auto transaction = startTransaction();

	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = document.getStartOfLine(cursor->getSelectionStart());
		auto end = insertText(transaction, start, "\n");
		cursor->update(start, false);
		cursors.adjustForInsert(cursor, start, end);
	}

	endTransaction(transaction);
}


//
//	TextEditor::insertLineBelow
//

void TextEditor::insertLineBelow() {
	auto transaction = startTransaction();

	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->getSelectionEnd();
		start = (start.index == 0) ? start : document.getNextLine(start);
		auto end = insertText(transaction, start, "\n");
		cursor->update(start, false);
		cursors.adjustForInsert(cursor, start, end);
	}

	endTransaction(transaction);
}


//
//	TextEditor::indentLines
//

void TextEditor::indentLines() {
	auto transaction = startTransaction();

	// process all cursors
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto cursorStart = cursor->getSelectionStart();
		auto cursorEnd = cursor->getSelectionEnd();

		// process all lines in this cursor
		for (auto line = cursorStart.line; line <= cursorEnd.line; line++) {
			if ((!cursor->hasSelection() || DocPos(line, 0) != cursorEnd) && document[line].size()) {
				auto insertStart = DocPos(line, 0);
				auto insertEnd = insertText(transaction, insertStart, "\t");
				cursors.adjustForInsert(cursor, insertStart, insertEnd, true);
			}
		}
	}

	endTransaction(transaction);
}


//
//	TextEditor::deindentLines
//

void TextEditor::deindentLines() {
	auto transaction = startTransaction();

	// process all cursors
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto cursorStart = cursor->getSelectionStart();
		auto cursorEnd = cursor->getSelectionEnd();

		for (auto line = cursorStart.line; line <= cursorEnd.line; line++) {
			if ((!cursor->hasSelection() || DocPos(line, 0) != cursorEnd) && document[line].size()) {
				// determine how many whitespaces are available at the start with a max of tabSize columns
				size_t column = 0;
				size_t index = 0;

				while (column < config.tabSize && index < document[line].size() && std::isblank(document[line][index].codepoint)) {
					column += document[line][index].codepoint == '\t' ? config.tabSize - (column % config.tabSize) : 1;
					index++;
				}

				// delete that whitespace (if required)
				DocPos deleteStart(line, 0);
				DocPos deleteEnd(line, index);

				if (deleteEnd != deleteStart) {
					deleteText(transaction, deleteStart, deleteEnd);
					cursors.adjustForDelete(cursor, deleteStart, deleteEnd, true);
				}
			}
		}
	}

	endTransaction(transaction);
}


//
//	Widget::moveUpLines
//

void TextEditor::moveUpLines() {
	// don't move up if first line is in one of the cursors
	if (cursors[0].getSelectionStart().line != 0) {
		auto transaction = startTransaction();

		for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
			auto start = cursor->getSelectionStart();
			auto end = cursor->getSelectionEnd();

			// delete existing lines
			auto deleteStart = document.getStartOfLine(start);
			auto deleteEnd = (end.index == 0) ? end : document.getNextLine(end);
			auto text = document.getSectionText(deleteStart, deleteEnd);
			deleteText(transaction, deleteStart, deleteEnd);
			cursors.adjustForDelete(cursor, deleteStart, deleteEnd);

			// insert text one line up
			DocPos insertStart(deleteStart.line - 1, 0);
			auto insertEnd = insertText(transaction, insertStart, text);
			cursors.adjustForInsert(cursor, insertStart, insertEnd);

			// update cursor
			cursor->update(start - DocPos(1, 0), end - DocPos(1, 0));
		}

		endTransaction(transaction);
	}
}


//
//	TextEditor::moveDownLines
//

void TextEditor::moveDownLines() {
	// don't move up if last line is in one of the cursors
	if (!document.isLastLine(cursors[cursors.size() - 1].getSelectionStart().line)) {
		auto transaction = startTransaction();

		for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
			auto start = cursor->getSelectionStart();
			auto end = cursor->getSelectionEnd();

			// delete existing lines
			auto deleteStart = document.getStartOfLine(start);
			auto deleteEnd = (end.index == 0) ? end : document.getNextLine(end);
			auto text = document.getSectionText(deleteStart, deleteEnd);
			deleteText(transaction, deleteStart, deleteEnd);
			cursors.adjustForDelete(cursor, deleteStart, deleteEnd);

			// insert text one line down
			auto insertStart = document.getNextLine(deleteStart);
			auto insertEnd = insertText(transaction, insertStart, text);
			cursors.adjustForInsert(cursor, insertStart, insertEnd);

			// update cursor
			cursor->update(start + DocPos(1, 0), end + DocPos(1, 0));
		}

		endTransaction(transaction);
	}
}


//
//	TextEditor::toggleComments
//

void TextEditor::toggleComments() {
	auto transaction = startTransaction();
	auto comment = config.language->singleLineComment;

	// process all cursors
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto cursorStart = cursor->getSelectionStart();
		auto cursorEnd = cursor->getSelectionEnd();

		// process all lines in this cursor
		for (auto line = cursorStart.line; line <= cursorEnd.line; line++) {
			if ((!cursor->hasSelection() || DocPos(line, 0) != cursorEnd) && document[line].size()) {
				// see if line starts with a comment (after possible leading whitespaces)
				size_t start = 0;
				size_t i = 0;

				while (start < document[line].size() && CodePoint::isWhiteSpace(document[line][start].codepoint)) {
					start++;
				}

				while (start + i < document[line].size() && i < comment.size() && document[line][start + i].codepoint == static_cast<ImWchar>(comment[i])) {
					i++;
				}

				if (i == comment.size()) {
					auto deleteStart = DocPos(line, start);
					auto endOfComment = start + i;

					if (endOfComment < document[line].size() - 1 && document[line][endOfComment].codepoint == ' ') {
						endOfComment++;
					}

					auto deleteEnd = DocPos(line, endOfComment);
					deleteText(transaction, deleteStart, deleteEnd);
					cursors.adjustForDelete(cursor, deleteStart, deleteEnd, true);

				} else {
					auto insertStart = DocPos(line, start);
					auto insertEnd = insertText(transaction, insertStart, comment + " ");
					cursors.adjustForInsert(cursor, insertStart, insertEnd, true);
				}
			}
		}
	}

	endTransaction(transaction);
}


//
//	TextEditor::filterSelections
//

void TextEditor::filterSelections(std::function<std::string(std::string_view)> filter) {
	auto transaction = startTransaction();

	// process all cursors
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->getSelectionStart();
		auto end = cursor->getSelectionEnd();

		// process all lines in this cursor
		for (auto line = start.line; line <= end.line; line++) {
			if (DocPos(line, 0) != end && document[line].size()) {
				// get original text and run it through filter
				auto before = document.getSectionText(start, end);
				std::string after = filter(before);

				// update selection if anything changed
				if (after != before) {
					deleteText(transaction, start, end);
					cursors.adjustForDelete(cursor, start, end);
					auto newEnd = insertText(transaction, start, after);
					cursor->update(start, newEnd);
					cursors.adjustForInsert(cursor, start, newEnd);
				}
			}
		}
	}

	endTransaction(transaction);
}


//
//	TextEditor::selectionToLowerCase
//

void TextEditor::selectionToLowerCase() {
	FilterSelections([](const std::string_view& text) {
		std::string result;
		auto end = text.end();
		auto i = text.begin();
		char utf8[4];

		while (i < end) {
			ImWchar codepoint;
			i = CodePoint::read(i, end, &codepoint);
			result.append(utf8, CodePoint::write(utf8, CodePoint::toLower(codepoint)));
		}

		return result;
	});
}


//
//	TextEditor::selectionToUpperCase
//

void TextEditor::selectionToUpperCase() {
	FilterSelections([](const std::string_view& text) {
		std::string result;
		auto end = text.end();
		auto i = text.begin();
		char utf8[4];

		while (i < end) {
			ImWchar codepoint;
			i = CodePoint::read(i, end, &codepoint);
			result.append(utf8, CodePoint::write(utf8, CodePoint::toUpper(codepoint)));
		}

		return result;
	});
}


//
//	TextEditor::stripTrailingWhitespaces
//

void TextEditor::stripTrailingWhitespaces() {
	auto transaction = startTransaction();

	// process all the lines
	for (size_t i = 0; i < document.size(); i++) {
		const auto& line = document[i];
		size_t lineSize = line.size();
		size_t whitespace = std::numeric_limits<size_t>::max();

		// look for first non-whitespace glyph at the end of the line
		if (lineSize) {
			bool done = false;

			for (auto index = lineSize - 1; !done; index--) {
				if (CodePoint::isWhiteSpace(line[index].codepoint)) {
					whitespace = index;

					if (index == 0) {
						done = true;
					}

				} else {
					done = true;
				}
			}
		}

		// remove whitespaces (if required)
		if (whitespace != std::numeric_limits<size_t>::max()) {
			deleteText(transaction, DocPos(i, whitespace), DocPos(i, lineSize));
		}
	}

	// update cursor if transaction wasn't empty
	if (endTransaction(transaction)) {
		cursors.setCursor(normalizePos(cursors.getCurrent().getSelectionEnd()));
	}
}


//
//	TextEditor::filterLines
//

void TextEditor::filterLines(std::function<std::string(std::string_view)> filter) {
	auto transaction = startTransaction();

	// process all the lines
	for (size_t i = 0; i < document.size(); i++) {
		// get original text and run it through filter
		auto before = document.getLineText(i);
		std::string after = filter(before);

		// update line if anything changed
		if (after != before) {
			auto start = DocPos(i, 0);
			auto end = document.getEndOfLine(start);
			deleteText(transaction, start, end);
			insertText(transaction, start, after);
		}
	}

	// update cursor if transaction wasn't empty
	if (endTransaction(transaction)) {
		cursors.setCursor(normalizePos(cursors.getCurrent().getSelectionEnd()));
	}
}


//
//	TextEditor::tabsToSpaces
//

void TextEditor::tabsToSpaces() {
	filterLines([this](const std::string_view& input) {
		std::string output;
		auto end = input.end();
		auto i = input.begin();
		size_t pos = 0;

		while (i < end) {
			ImWchar codepoint;
			i = CodePoint::read(i, end, &codepoint);

			if (codepoint == '\t') {
				auto spaces = config.tabSize - (pos % config.tabSize);
				output.append(spaces, ' ');
				pos += spaces;

			} else {
				char utf8[4];
				output.append(utf8, CodePoint::write(utf8, codepoint));
				pos++;
			}
		}

		return output;
	});
}


//
//	TextEditor::spacesToTabs
//

void TextEditor::spacesToTabs() {
	FilterLines([this](const std::string_view& input) {
		std::string output;
		auto end = input.end();
		auto i = input.begin();
		size_t pos = 0;
		size_t spaces = 0;

		while (i < end) {
			ImWchar codepoint;
			i = CodePoint::read(i, end, &codepoint);

			if (codepoint == ' ') {
				spaces++;

			} else {
				while (spaces) {
					auto spacesUntilNextTab = config.tabSize - (pos % config.tabSize);

					if (spacesUntilNextTab == 1) {
						output += ' ';
						pos++;
						spaces--;

					} else if (spaces >= spacesUntilNextTab) {
						output += '\t';
						pos += spacesUntilNextTab;
						spaces -= spacesUntilNextTab;

					} else if (codepoint != '\t')
						while (spaces) {
							output += ' ';
							pos++;
							spaces--;
						}

					else {
						spaces = 0;
					}
				}

				if (codepoint == '\t') {
					output += '\t';
					pos += config.tabSize - (pos % config.tabSize);

				} else {
					char utf8[4];
					output.append(utf8, CodePoint::write(utf8, codepoint));
					pos++;
				}
			}
		}

		return output;
	});
}


//
//	TextEditor::startTransaction
//

std::shared_ptr<TextEditor::Transaction> TextEditor::startTransaction(bool cancelsAutoComplete) {
	if (cancelsAutoComplete) {
		autocomplete.cancel();
	}

	std::shared_ptr<Transaction> transaction = Transactions::create();
	transaction->setBeforeState(cursors);
	return transaction;
}


//
//	TextEditor::endTransaction
//

bool TextEditor::endTransaction(std::shared_ptr<Transaction> transaction) {
	if (transaction->size() > 0) {
		cursors.update(document);
		transaction->setAfterState(cursors);
		transactions.add(transaction);
		return true;

	} else {
		return false;
	}
}


//
//	TextEditor::insertTextIntoAllCursors
//

void TextEditor::insertTextIntoAllCursors(std::shared_ptr<Transaction> transaction, const std::string_view& text) {
	// delete any selection content first
	deleteTextFromAllCursors(transaction);

	// insert the text
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->getSelectionStart();
		auto end = insertText(transaction, start, text);
		cursor->update(end, false);
		cursors.adjustForInsert(cursor, start, end);
	}
}


//
//	TextEditor::deleteTextFromAllCursors
//

void TextEditor::deleteTextFromAllCursors(std::shared_ptr<Transaction> transaction) {
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		if (cursor->hasSelection()) {
			auto start = cursor->getSelectionStart();
			auto end = cursor->getSelectionEnd();
			deleteText(transaction, start, end);
			cursor->update(start, false);
			cursors.adjustForDelete(cursor, start, end);
		}
	}
}


//
//	TextEditor::autoIndentAllCursors
//

void TextEditor::autoIndentAllCursors(std::shared_ptr<Transaction> transaction) {
	for (auto cursor = cursors.begin(); cursor < cursors.end(); cursor++) {
		auto start = cursor->getSelectionStart();

		// delete any selections
		if (cursor->hasSelection()) {
			auto end = cursor->getSelectionEnd();
			deleteText(transaction, start, end);
			cursors.adjustForDelete(cursor, start, end);
		}

		// get previous and next character
		auto index = start.index;
		auto& line = document[start.line];
		ImWchar previousChar = index > 0 ? line[index - 1].codepoint : 0;
		ImWchar nextChar = index < line.size() ? line[index].codepoint : 0;

		// remove extra whitespaces if required
		if (CodePoint::isWhiteSpace(nextChar)) {
			while (index < line.size() && CodePoint::isWhiteSpace(line[index].codepoint)) {
				index++;
			}

			auto end = DocPos(start.line, index);
			deleteText(transaction, start, end);
			cursors.adjustForDelete(cursor, start, end);
		}

		// determine whitespace at start of current line
		std::string whitespace;

		for (size_t i = 0; i < line.size() && CodePoint::isWhiteSpace(line[i].codepoint); i++) {
			char utf8[4];
			whitespace.append(utf8, CodePoint::write(utf8, line[i].codepoint));
		}

		// determine text to insert
		std::string insert = "\n" + whitespace;
		auto newCursorIndex = whitespace.size();

		// handle special cases
		if (previousChar == CodePoint::openCurlyBracket || previousChar == CodePoint::openSquareBracket) {
			// add to an existing block
			insert += "\t";
			newCursorIndex++;

			if ((previousChar == CodePoint::openCurlyBracket && nextChar == CodePoint::closeCurlyBracket) ||
				(previousChar == CodePoint::openSquareBracket && nextChar == CodePoint::closeSquareBracket)) {

				// open a new block
				insert += "\n" + whitespace;
			}
		}

		// insert new text
		auto end = insertText(transaction, start, insert);
		cursors.adjustForInsert(cursor, start, end);

		// set new cursor location
		cursor->update(DocPos(start.line + 1, newCursorIndex), false);
	}
}


//
//	TextEditor::insertText
//

TextEditor::DocPos TextEditor::insertText(std::shared_ptr<Transaction> transaction, DocPos start, const std::string_view& text) {
	// update document, add transaction and return position of end of insert
	// this function does not change the cursors
	auto end = document.insertText(config, start, text);
	transaction->addInsert(start, end, text);
	makeCursorVisible();
	return end;
}


//
//	TextEditor::deleteText
//

void TextEditor::deleteText(std::shared_ptr<Transaction> transaction, DocPos start, DocPos end) {
	// update document and add transaction
	// this function does not change the cursors
	auto text = document.getSectionText(start, end);
	document.deleteText(config, start, end);
	transaction->addDelete(start, end, text);
	makeCursorVisible();
	resetCursorAnimationTimer();
	deletesHappened = true;
}


//
//	TextEditor::SetLanguage
//

void TextEditor::SetLanguage(const Language* language) {
	config.language = language;

	if (languageChangeCallback) {
		languageChangeCallback();
	}
}


//
//	TextEditor::Cursor::grow
//

void TextEditor::Cursor::grow(DocPos position) {
	if (position < getSelectionStart()) {
		if (end > start) {
			std::swap(end, start);
		}

		end = position;
		updated = true;

	} else if (position > getSelectionEnd()) {
		if (end < start) {
			std::swap(end, start);
		}

		end = position;
		updated = true;
	}
}


//
//	TextEditor::Cursor::adjustCoordinateForInsert
//

TextEditor::DocPos TextEditor::Cursor::adjustCoordinateForInsert(DocPos position, DocPos insertStart, DocPos insertEnd) {
	if (position.line == insertStart.line) {
		position.index += insertEnd.index - insertStart.index;
	}

	position.line += insertEnd.line - insertStart.line;
	return position;
}


//
//	TextEditor::Cursor::adjustForInsert
//

void TextEditor::Cursor::adjustForInsert(DocPos insertStart, DocPos insertEnd) {
	start = adjustCoordinateForInsert(start, insertStart, insertEnd);
	end = adjustCoordinateForInsert(end, insertStart, insertEnd);
}


//
//	TextEditor::Cursor::adjustCoordinateForDelete
//

TextEditor::DocPos TextEditor::Cursor::adjustCoordinateForDelete(DocPos position, DocPos deleteStart, DocPos deleteEnd) {
	if (deleteStart.line == deleteEnd.line) {
		if (position.line == deleteEnd.line) {
			position.index -= deleteEnd.index - deleteStart.index;
		}

	} else {
		position.line -= deleteEnd.line - deleteStart.line;

		if (position.line == deleteEnd.line) {
			position.index -= deleteEnd.index;
		}
	}

	return position;
}


//
//	TextEditor::Cursor::adjustForDelete
//

void TextEditor::Cursor::adjustForDelete(DocPos deleteStart, DocPos deleteEnd) {
	start = adjustCoordinateForDelete(start, deleteStart, deleteEnd);
	end = adjustCoordinateForDelete(end, deleteStart, deleteEnd);
}


//
//	TextEditor::Cursor::ensureNotHidden
//

void TextEditor::Cursor::ensureNotHidden(const Document& document) {
	if (document[start.line].foldingState == FoldingState::hidden) {
		auto line = start.line - 1;

		while (document[line].foldingState == FoldingState::hidden) {
			line--;
		}

		start.line = line;
		start.index = document[line].size();
		updated = true;
	}

	if (document[end.line].foldingState == FoldingState::hidden) {
		auto line = end.line - 1;

		while (document[line].foldingState == FoldingState::hidden) {
			line--;
		}

		end.line = line;
		end.index = document[line].size();
		updated = true;
	}
}


//
//	TextEditor::Cursors::reset
//

void TextEditor::Cursors::reset() {
	clear();
	main = 0;
	current = 0;
}


//
//	TextEditor::Cursors::setCursor
//

void TextEditor::Cursors::setCursor(DocPos cursorStart, DocPos cursorEnd) {
	reset();
	emplace_back(cursorStart, cursorEnd);
	front().setMain(true);
	front().setCurrent(true);
}


//
//	TextEditor::Cursors::addCursor
//

void TextEditor::Cursors::addCursor(DocPos start, DocPos end) {
	at(current).setCurrent(false);
	emplace_back(start, end);
	back().setCurrent(true);
	current = size() - 1;
}


//
//	TextEditor::Cursors::anyHasSelection
//

bool TextEditor::Cursors::anyHasSelection() const {
	for (auto cursor = begin(); cursor < end(); cursor++) {
		if (cursor->hasSelection()) {
			return true;
		}
	}

	return false;
}


//
//	TextEditor::Cursors::allHaveSelection
//

bool TextEditor::Cursors::allHaveSelection() const {
	for (auto cursor = begin(); cursor < end(); cursor++) {
		if (!cursor->hasSelection()) {
			return false;
		}
	}

	return true;
}


//
//	TextEditor::Cursors::anyHasUpdate
//

bool TextEditor::Cursors::anyHasUpdate() const {
	for (auto cursor = begin(); cursor < end(); cursor++) {
		if (cursor->isUpdated()) {
			return true;
		}
	}

	return false;
}


//
//	TextEditor::Cursors::clearAll
//

void TextEditor::Cursors::clearAll() {
	reset();
	emplace_back(DocPos(0, 0));
	front().setMain(true);
	front().setCurrent(true);
}


//
//	TextEditor::Cursors::clearAdditional
//

void TextEditor::Cursors::clearAdditional(bool reset) {
	for (auto cursor = begin(); cursor < end();) {
		if (cursor->isMain()) {
			cursor++;

		} else {
			cursor = erase(cursor);
		}
	}

	main = 0;
	current = 0;
	front().setCurrent(true);

	if (reset) {
		front().resetToEnd();
	}
}


//
//	TextEditor::Cursors::clearUpdated
//

void TextEditor::Cursors::clearUpdated() {
	for (auto cursor = begin(); cursor < end(); cursor++) {
		cursor->setUpdated(false);
	}
}


//
//	TextEditor::Cursors::update
//

void TextEditor::Cursors::update(const Document& document) {
	// ensure cursors are not on hidden lines
	for (auto& cursor : *this) {
		cursor.ensureNotHidden(document);
	}

	if (anyHasUpdate()) {
		// reset update flags
		clearUpdated();

		//  only sort and potential merge when we have multiple cursors
		if (hasMultiple()) {
			// sort cursors
			std::sort(begin(), end(), [](Cursor& a, Cursor& b) {
				return a.getSelectionStart() < b.getSelectionStart();
			});

			// merge cursors
			for (auto cursor = rbegin(); cursor < rend() - 1;) {
				auto previous = cursor + 1;

				if (previous->getSelectionEnd() >= cursor->getSelectionEnd()) {
					if (cursor->isMain()) {
						previous->setMain(true);
					}

					if (cursor->isCurrent()) {
						previous->setCurrent(true);
					}

					erase((++cursor).base());

				} else if (previous->getSelectionEnd() > cursor->getSelectionStart()) {
					if (cursor->getInteractiveEnd() < cursor->getInteractiveStart()) {
						previous->update(cursor->getSelectionEnd(), previous->getSelectionStart());

					} else {
						previous->update(previous->getSelectionStart(), cursor->getSelectionEnd());
					}

					if (cursor->isMain()) {
						previous->setMain(true);
					}

					if (cursor->isCurrent()) {
						previous->setCurrent(true);
					}

					erase((++cursor).base());

				} else {
					cursor++;
				}
			}

			// find main and current cursor
			main = 0;
			current = 0;

			for (size_t c = 0; c < size(); c++) {
				if (at(c).isMain()) {
					main = c;

				} else if (at(c).isCurrent()) {
					current = c;
				}
			}
		}
	}
}


//
//	TextEditor::Cursors::adjustForInsert
//

void TextEditor::Cursors::adjustForInsert(iterator start, DocPos insertStart, DocPos insertEnd, bool includeCurrent) {
	auto first = includeCurrent ? start : start + 1;

	for (auto cursor = first; cursor < end(); cursor++) {
		cursor->adjustForInsert(insertStart, insertEnd);
	}
}


//
//	TextEditor::Cursors::adjustForDelete
//

void TextEditor::Cursors::adjustForDelete(iterator start, DocPos deleteStart, DocPos deleteEnd, bool includeCurrent) {
	auto first = includeCurrent ? start : start + 1;

	for (auto cursor = first; cursor < end(); cursor++) {
		cursor->adjustForDelete(deleteStart, deleteEnd);
	}
}


//
//	TextEditor::Document::setText
//

void TextEditor::Document::setText(const Config& config, const std::string_view& text) {
	// reset document
	clearDocument();
	appendLine();

	// process UTF-8 and generate lines of glyphs
	auto end = text.end();
	auto i = CodePoint::skipBOM(text.begin(), end);

	while (i < end) {
		ImWchar character;
		i = CodePoint::read(i, end, &character);

		if (character == '\n') {
			appendLine();

		} else if (config.insertSpacesOnTabs && character == '\t') {
			auto spaces = ((back().size() / config.tabSize) + 1) * config.tabSize - back().size();

			for (size_t s = 0; s < spaces; s++) {
				back().emplace_back(Glyph(' ', Color::text));
			}

		} else if (character != '\r') {
			back().emplace_back(Glyph(character, Color::text));
		}
	}

	// calculate line indents
	updateIndents(config, 0, size() - 1);
	updated = true;
}


//
//	TextEditor::Document::setText
//

void TextEditor::Document::setText(const Config& config, const std::vector<std::string_view>& text) {
	// reset document
	clearDocument();

	if (text.size()) {
		// process input UTF-8 and generate lines of glyphs
		for (const auto& line : text) {
			appendLine();
			auto i = line.begin();
			auto end = line.end();

			while (i < end) {
				ImWchar character;
				i = CodePoint::read(i, end, &character);

				if (config.insertSpacesOnTabs && character == '\t') {
					auto spaces = ((back().size() / config.tabSize) + 1) * config.tabSize - back().size();

					for (size_t s = 0; s < spaces; s++) {
						back().emplace_back(Glyph(' ', Color::text));
					}

				} else if (character != '\r') {
					back().emplace_back(Glyph(character, Color::text));
				}
			}
		}

	} else {
		appendLine();
	}

	// calculate line indents
	updateIndents(config, 0, size() - 1);
	updated = true;
}


//
//	TextEditor::Document::insertText
//

TextEditor::DocPos TextEditor::Document::insertText(const Config& config, DocPos start, const std::string_view& text) {
	auto line = begin() + start.line;
	auto index = start.index;
	auto lineNo = start.line;

	// process input as UTF-8
	auto endOfText = text.end();
	auto i = text.begin();

	// process all codepoints
	while (i < endOfText) {
		ImWchar character;
		i = CodePoint::read(i, endOfText, &character);

		if (character == '\n') {
			// split line
			insertLine(lineNo + 1);
			line = begin() + lineNo;
			auto nextLine = begin() + ++lineNo;

			for (auto j = line->begin() + index; j < line->end(); j++) {
				nextLine->push_back(*j);
			}

			line->erase(line->begin() + index, line->end());
			line = nextLine;
			index = 0;

		} else if (config.insertSpacesOnTabs && character == '\t') {
			auto spaces = ((index / config.tabSize) + 1) * config.tabSize - index;

			for (size_t s = 0; s < spaces; s++) {
				line->insert(line->begin() + (index++), Glyph(' ', Color::text));
			}

		} else if (character != '\r') {
			// insert next glyph
			line->insert(line->begin() + (index++), Glyph(character, Color::text));
		}
	}

	// determine end of insert
	auto end = DocPos(lineNo, index);

	// mark affected lines as changed
	for (auto j = start.line; j <= end.line; j++) {
		at(j).needsColorizing = true;
		at(j).needsTypeSetting = true;
	}

	// calculate line indents
	updateIndents(config, start.line, end.line);
	updated = true;
	return end;
}


//
//	TextEditor::Document::deleteText
//

void TextEditor::Document::deleteText(const Config& config, DocPos start, DocPos end) {
	auto& startLine = at(start.line);
	auto startIndex = start.index;
	auto& endLine = at(end.line);
	auto endIndex = end.index;

	// see if start and end are on the same line
	if (start.line == end.line) {
		startLine.erase(startLine.begin() + startIndex, startLine.begin() + endIndex);

	// start and end are on different lines
	} else {
		// remove end of first line
		startLine.erase(startLine.begin() + startIndex, startLine.end());

		// remove start of last line
		endLine.erase(endLine.begin(), endLine.begin() + endIndex);

		// join lines
		startLine.insert(startLine.end(), endLine.begin(), endLine.end());

		// delete lines
		deleteLines(start.line + 1, end.line);
	}

	// remove marker
	startLine.marker = 0;

	// mark line and document as changed
	at(start.line).needsColorizing = true;
	at(start.line).needsTypeSetting = true;

	// calculate line indents
	updateIndents(config, start.line, start.line);
	updated = true;
}


//
//	TextEditor::Document::getText
//

std::string TextEditor::Document::getText() const {
	// process all glyphs and generate UTF-8 output
	std::string text;
	char utf8[4];

	for (auto line = begin(); line < end(); line++) {
		for (auto glyph = line->begin(); glyph < line->end(); glyph++) {
			text.append(std::string_view(utf8, CodePoint::write(utf8, glyph->codepoint)));
		}

		if (line < end() - 1) {
			text += "\n";
		}
	}

	return text;
}


//
//	TextEditor::Document::getLineText
//

std::string TextEditor::Document::getLineText(size_t line) const {
	return getSectionText(DocPos(line, 0), DocPos(line, at(line).size()));
}


//
//	TextEditor::Document::getSectionText
//

std::string TextEditor::Document::getSectionText(DocPos start, DocPos end) const {
	std::string section;

	auto lineNo = start.line;
	auto index = start.index;
	char utf8[4];

	while (lineNo < end.line || index < end.index) {
		auto& line = at(lineNo);

		if (index < line.size()) {
			section.append(std::string_view(utf8, CodePoint::write(utf8, line[index].codepoint)));
			index++;

		} else {
			section += '\n';
			lineNo++;
			index = 0;
		}
	}

	return section;
}


//
//	TextEditor::Document::getCodePoint
//

ImWchar TextEditor::Document::getCodePoint(DocPos location) const {
	if (location.index < at(location.line).size()) {
		return at(location.line)[location.index].codepoint;

	} else {
		return IM_UNICODE_CODEPOINT_INVALID;
	}
}


//
//	TextEditor::Document::iterateGlyphs
//

void TextEditor::Document::iterateGlyphs(DocPos start, DocPos end, std::function<void(Glyph&)> callback) {
	if (start.line == end.line) {
		// start and end are on same line
		for (size_t i = start.index; i < end.index; i++) {
			callback(at(start.line)[i]);
		}

	} else {
		// process remainder of fist line
		auto last = at(start.line).size();

		for (size_t i = start.index; i < last; i++) {
			callback(at(start.line)[i]);
		}

		// process all full lines
		for (auto line = start.line + 1; line < end.line; line++) {
			last = at(line).size();

			for (size_t i = 0; i < last; i++) {
				callback(at(line)[i]);
			}
		}

		// process remainder on last line
		for (size_t i = 0; i < end.index; i++) {
			callback(at(end.line)[i]);
		}
	}
}


//
//	TextEditor::Document::getColor
//

TextEditor::Color TextEditor::Document::getColor(DocPos location)  const {
	if (location.index < at(location.line).size()) {
		return at(location.line)[location.index].color;

	} else {
		return Color::text;
	}
}


//
//	TextEditor::Document::getLeft
//

TextEditor::DocPos TextEditor::Document::getLeft(DocPos from, bool wordMode) const {
	if (wordMode) {
		// first move left by one glyph
		from = getLeft(from);

		// now skip all whitespaces
		from = findPreviousNonWhiteSpace(from, false);

		// find the start of the current word
		return findWordStart(from);

	} else {
		// calculate position of previous glyph (could be on previous line)
		if (from.index == 0) {
			return getLeftBeforeHiddenLines(from);

		} else {
			return DocPos(from.line, from.index - 1);
		}
	}
}


//
//	TextEditor::Document::getRight
//

TextEditor::DocPos TextEditor::Document::getRight(DocPos from, bool wordMode) const {
	if (wordMode) {
		// first move right by one glyph
		from = getRight(from);

		// now skip all whitespaces
		from = findNextNonWhiteSpace(from, false);

		// find the end of the current word
		return findWordEnd(from);

	} else {
		// calculate pos of next glyph (could be on next line)
		if (from.index == at(from.line).size()) {
			return getRightAfterHiddenLines(from);

		} else {
			return DocPos(from.line, from.index + 1);
		}
	}
}


//
//	TextEditor::Document::getTop
//

TextEditor::DocPos TextEditor::Document::getTop() const {
	return DocPos(0, 0);
}


//
//	TextEditor::Document::getBottom
//

TextEditor::DocPos TextEditor::Document::getBottom() const {
	auto lastLine = size() - 1;
	return DocPos(lastLine, at(lastLine).size());
}


//
//	TextEditor::Document::getStartOfLine
//

TextEditor::DocPos TextEditor::Document::getStartOfLine(DocPos from) const {
	return DocPos(from.line, 0);
}


//
//	TextEditor::Document::getEndOfLine
//

TextEditor::DocPos TextEditor::Document::getEndOfLine(DocPos from) const {
	return DocPos(from.line, at(from.line).size());
}


//
//	TextEditor::Document::findWordStart
//

TextEditor::DocPos TextEditor::Document::findWordStart(DocPos from, bool wordOnly) const {
	const auto& line = at(from.line);
	auto lineSize = line.size();

	if (from.index == 0 || lineSize == 0) {
		return from;

	} else {
		auto index = from.index;
		auto firstCharacter = line[index - 1].codepoint;

		if (!wordOnly && CodePoint::isWhiteSpace(firstCharacter)) {
			while (index > 0 && CodePoint::isWhiteSpace(line[index - 1].codepoint)) {
				index--;
			}

		} else if (CodePoint::isWord(firstCharacter)) {
			while (index > 0 && CodePoint::isWord(line[index - 1].codepoint)) {
				index--;
			}

		} else {
			while (!wordOnly && index > 0 && !CodePoint::isWord(line[index - 1].codepoint) && !CodePoint::isWhiteSpace(line[index - 1].codepoint)) {
				index--;
			}
		}

		return DocPos(from.line, index);
	}
}


//
//	TextEditor::Document::findWordEnd
//

TextEditor::DocPos TextEditor::Document::findWordEnd(DocPos from, bool wordOnly) const {
	const auto& line = at(from.line);
	auto index = from.index;
	auto size = line.size();

	if (index >= size) {
		return from;

	} else {
		auto firstCharacter = line[index].codepoint;

		if (!wordOnly && CodePoint::isWhiteSpace(firstCharacter)) {
			while (index < size && CodePoint::isWhiteSpace(line[index].codepoint)) {
				index++;
			}

		} else if (CodePoint::isWord(firstCharacter)) {
			while (index < size && CodePoint::isWord(line[index].codepoint)) {
				index++;
			}

		} else {
			while (!wordOnly && index < size && !CodePoint::isWord(line[index].codepoint) && !CodePoint::isWhiteSpace(line[index].codepoint)) {
				index++;
			}
		}
	}

	return DocPos(from.line, index);
}


//
//	TextEditor::Document::findText
//

bool TextEditor::Document::findText(DocPos from, const std::string_view& text, bool caseSensitive, bool wholeWord, DocPos& start, DocPos& end) const {
	// convert input string to vector of codepoints
	std::vector<ImWchar> search;
	auto endOfText = text.end();
	auto i = text.begin();

	while (i < endOfText) {
		ImWchar character;
		i = CodePoint::read(i, endOfText, &character);
		search.emplace_back(caseSensitive ? character : CodePoint::toLower(character));
	}

	// search document
	auto startLine = from.line;
	auto startIndex = from.index;
	auto searchLine = startLine;
	auto searchIndex = startIndex;

	do {
		auto line = searchLine;
		auto index = searchIndex;
		auto lineSize = at(line).size();
		bool done = false;
		size_t j = 0;

		while (!done && j < search.size()) {
			if (search[j] == '\n') {
				if (index == lineSize) {
					if (line == size() - 1) {
						done = true;

					} else {
						line++;
						index = 0;
						lineSize = at(line).size();
						j++;
					}

				} else {
					done = true;
				}

			} else {
				if (index == lineSize) {
					done = true;

				} else {
					auto ch = at(line)[index].codepoint;

					if (!caseSensitive) {
						ch = CodePoint::toLower(ch);
					}

					if (ch == search[j]) {
						index++;
						j++;

					} else {
						done = true;
					}
				}
			}
		}

		if (j == search.size()) {
			start = DocPos(searchLine, searchIndex);
			end = DocPos(line, index);

			if (!wholeWord || isWholeWord(start, end)) {
				return true;
			}
		}

		if (searchIndex == at(searchLine).size()) {
			searchLine = (searchLine == size() - 1) ? 0 : searchLine + 1;
			searchIndex = 0;

		} else {
			searchIndex++;
		}

	} while (searchLine != startLine || searchIndex != startIndex);

	return false;
}


//
//	TextEditor::Document::setUserData
//

void TextEditor::Document::setUserData(size_t line, void* data) {
	if (line < size()) {
		at(static_cast<size_t>(line)).userData = data;
	}
}


//
//	TextEditor::Document::getUserData
//

void* TextEditor::Document::getUserData(size_t line) const {
	if (line < size()) {
		return at(static_cast<size_t>(line)).userData;

	} else {
		return nullptr;
	}
}

//
//	TextEditor::Document::iterateUserData
//

void TextEditor::Document::iterateUserData(std::function<void(size_t line, void* data)> callback) const {
	for (size_t i = 0; i < size(); i++) {
		callback(i, at(i).userData);
	}
}


//
//	isIdentifier
//

static inline bool isIdentifier(TextEditor::Color color) {
	return
		color == TextEditor::Color::identifier ||
		color == TextEditor::Color::knownIdentifier;
}


//
//	TextEditor::Document::iterateIdentifiers
//

void TextEditor::Document::iterateIdentifiers(std::function<void(const std::string&)> callback) const {
	for (size_t i = 0; i < size(); i++) {
		auto p = at(i).begin();
		auto end = at(i).end();
		char utf8[4];

		while (p < end) {
			if (isIdentifier(p->color)) {
				std::string identifier;

				while (p < end && isIdentifier(p->color)) {
					identifier.append(std::string_view(utf8, CodePoint::write(utf8, p->codepoint)));
					p++;
				}

				callback(identifier);

			} else {
				p++;
			}
		}
	}
}


//
//	TextEditor::Document::isWordStart
//

bool TextEditor::Document::isWordStart(DocPos pos, bool wordOnly) const {
	auto& line = at(pos.line);

	if (isEndOfLine(pos)) {
		return false;

	} else if (isStartOfLine(pos)) {
		if (line.size() == 0) {
			return false;

		} else {
			return !wordOnly || CodePoint::isWord(line[0].codepoint);
		}

	} else {
		auto glyph1 = line[pos.index - 1].codepoint;
		auto glyph2 = line[pos.index].codepoint;

		if (wordOnly) {
			return !CodePoint::isWord(glyph1) && CodePoint::isWord(glyph2);

		} else if (CodePoint::isWord(glyph2)) {
			return !CodePoint::isWord(glyph1);

		} else if (CodePoint::isWhiteSpace(glyph2)) {
			return !CodePoint::isWhiteSpace(glyph1);

		} else {
			return CodePoint::isWord(glyph1) || CodePoint::isWhiteSpace(glyph1);
		}
	}
}


//
//	TextEditor::Document::isWordEnd
//

bool TextEditor::Document::isWordEnd(DocPos pos, bool wordOnly) const {
	auto& line = at(pos.line);

	if (isStartOfLine(pos)) {
		return false;

	} else if (isEndOfLine(pos)) {
		if (line.size() == 0) {
			return false;

		} else {
			return !wordOnly || CodePoint::isWord(line[line.size() - 1].codepoint);
		}

	} else {
		auto glyph1 = line[pos.index - 1].codepoint;
		auto glyph2 = line[pos.index].codepoint;

		if (wordOnly) {
			return CodePoint::isWord(glyph1) && !CodePoint::isWord(glyph2);

		} else if (CodePoint::isWord(glyph1)) {
			return !CodePoint::isWord(glyph2);

		} else if (CodePoint::isWhiteSpace(glyph1)) {
			return !CodePoint::isWhiteSpace(glyph2);

		} else {
			return CodePoint::isWord(glyph2) || CodePoint::isWhiteSpace(glyph2);
		}
	}
}


//
//	TextEditor::Document::isWholeWord
//

bool TextEditor::Document::isWholeWord(DocPos start, DocPos end, bool wordOnly) const {
	if (end <= start || start.line != end.line) {
		return false;

	} else {
		return isWordStart(start, wordOnly) && isWordEnd(end, wordOnly);
	}
}


//
//	TextEditor::Document::getWholeWord
//

TextEditor::DocSelection TextEditor::Document::getWholeWord(DocPos pos, bool wordOnly) const {
	if (wordOnly && !isStartOfLine(pos) && !isEndOfLine(pos) && !CodePoint::isWord(at(pos.line)[pos.index].codepoint)) {
		return DocSelection(pos, pos);

	} else if (isWordStart(pos, wordOnly)) {
		return DocSelection(pos, findWordEnd(pos, wordOnly));

	} else if (isWordEnd(pos, wordOnly)) {
		return DocSelection(findWordStart(pos, wordOnly), pos);

	} else {
		return DocSelection(findWordStart(pos, wordOnly), findWordEnd(pos, wordOnly));
	}
}


//
//	TextEditor::Document::findPreviousNonWhiteSpace
//

TextEditor::DocPos TextEditor::Document::findPreviousNonWhiteSpace(DocPos from, bool includeEndOfLine) const {
	bool done = false;

	while (!done) {
		const auto& line = at(from.line);
		auto index = from.index;

		while (!done && index > 0) {
			index--;

			if (!CodePoint::isWhiteSpace(line[index].codepoint)) {
				from.index = index;
				done = true;
			}
		}

		if (!done) {
			if (from.line == 0 || !includeEndOfLine) {
				from.index = 0;
				done = true;

			} else {
				from = getLeftBeforeHiddenLines(from);
			}
		}
	}

	return from;
}


//
//	TextEditor::Document::findNextNonWhiteSpace
//

TextEditor::DocPos TextEditor::Document::findNextNonWhiteSpace(DocPos from, bool includeEndOfLine) const {
	bool done = false;

	while (!done) {
		const auto& line = at(from.line);
		auto index = from.index;

		while (!done && index < line.size()) {
			if (CodePoint::isWhiteSpace(line[index].codepoint)) {
				index++;

			} else {
				from.index = index;
				done = true;
			}
		}

		if (!done) {
			if (from.line == size() || !includeEndOfLine) {
				from.index = line.size();
				done = true;

			} else {
				from = getRightAfterHiddenLines(from);
			}
		}
	}

	return from;
}


//
//	TextEditor::Document::normalizePos
//

TextEditor::DocPos TextEditor::Document::normalizePos(DocPos pos) const {
	if (pos.line >= size()) {
		return getBottom();

	} else if (pos.index > at(pos.line).size()) {
		return getEndOfLine(pos);

	} else {
		return pos;
	}
}


//
//	TextEditor::Document::getLeftBeforeHiddenLines
//

TextEditor::DocPos TextEditor::Document::getLeftBeforeHiddenLines(DocPos pos) const {
	if (pos.line == 0) {
		return pos;

	} else {
		auto line = pos.line - 1;

		while (line > 0 && at(line).foldingState == FoldingState::hidden) {
			line--;
		}

		return DocPos(line, at(line).size());
	}
}


//
//	TextEditor::Document::getRightAfterHiddenLines
//

TextEditor::DocPos TextEditor::Document::getRightAfterHiddenLines(DocPos pos) const {
	if (pos.line == size() - 1) {
		return pos;

	} else {
		auto line = pos.line + 1;

		while (line < size() - 1 && at(line).foldingState == FoldingState::hidden) {
			line++;
		}

		return DocPos(line, 0);
	}
}


//
//	TextEditor::Document::appendLine
//

void TextEditor::Document::appendLine() {
	auto& line = emplace_back();

	if (insertor) {
		line.userData = insertor(size() - 1);
	}
}


//
//	TextEditor::Document::insertLine
//

void TextEditor::Document::insertLine(size_t offset) {
	auto line = insert(begin() + offset, Line());

	if (insertor) {
		line->userData = insertor(offset);
	}
}


//
//	TextEditor::Document::deleteLines
//

void TextEditor::Document::deleteLines(size_t start, size_t end) {
	if (deletor) {
		for (auto i = start; i <= end; i++) {
			deletor(i, at(i).userData);
		}
	}

	erase(begin() + start, begin() + end + 1);
}


//
//	TextEditor::Document::clearDocument
//

void TextEditor::Document::clearDocument() {
	if (deletor) {
		for (size_t i = 0; i < size(); i++) {
			deletor(i, at(i).userData);
		}
	}

	clear();
}


//
//	TextEditor::Document::updateIndents
//

void TextEditor::Document::updateIndents(const Config& config, size_t start, size_t end) {
	for (size_t i = start; i <= end; i++) {
		auto& line = at(i);
		line.indent = 0;
		bool done = false;

		for (size_t j = 0; j < line.size() && !done; j++) {
			if (line[j].codepoint == ' ') {
				line.indent++;

			} else if (line[j].codepoint == '\t') {
				line.indent += config.tabSize - (line.indent % config.tabSize);

			} else {
				done = true;
			}
		}
	}
}


//
//	TextEditor::Transactions::reset
//

void TextEditor::Transactions::reset() {
	clear();
	undoIndex = 0;
	version = 0;
}


//
//	TextEditor::Transactions::add
//

void TextEditor::Transactions::add(std::shared_ptr<Transaction> transaction) {
	resize(undoIndex);
	push_back(transaction);
	undoIndex++;
	version++;

	if (callback) {
		std::vector<Change> changes;

		for (auto& action : *transaction) {
			auto& change = changes.emplace_back();
			change.insert = action.type == Action::Type::insertText;
			change.start = action.start;
			change.end = action.end;
			change.text = action.text;
		}

		callback(changes);
	}
}


//
//	TextEditor::Transactions::undo
//

void TextEditor::Transactions::undo(const Config& config, Document& document, Cursors& cursors) {
	auto transaction = at(--undoIndex);

	for (auto action = transaction->rbegin(); action < transaction->rend(); action++) {
		if (action->type == Action::Type::insertText) {
			document.deleteText(config, action->start, action->end);

		} else {
			document.insertText(config, action->start, action->text);
		}
	}

	cursors = transaction->getBeforeState();
	version++;

	if (callback) {
		std::vector<Change> changes;

		for (auto& action : *transaction) {
			auto& change = changes.emplace_back();
			change.insert = action.type == Action::Type::deleteText;
			change.start = action.start;
			change.end = action.end;
			change.text = action.text;
		}

		callback(changes);
	}
}


//
//	TextEditor::Transactions::redo
//

void TextEditor::Transactions::redo(const Config& config, Document& document, Cursors& cursors) {
	auto transaction = at(undoIndex++);

	for (auto action = transaction->begin(); action < transaction->end(); action++) {
		if (action->type == Action::Type::insertText) {
			document.insertText(config, action->start, action->text);

		} else {
			document.deleteText(config, action->start, action->end);
		}
	}

	cursors = transaction->getAfterState();
	version++;

	if (callback) {
		std::vector<Change> changes;

		for (auto& action : *transaction) {
			auto& change = changes.emplace_back();
			change.insert = action.type == Action::Type::insertText;
			change.start = action.start;
			change.end = action.end;
			change.text = action.text;
		}

		callback(changes);
	}
}


//
//	TextEditor::Colorizer::matches
//

bool TextEditor::Colorizer::matches(Line::iterator start, Line::iterator end, const std::string_view& text) {
	// see if text between iterators matches provided UTF-8 string
	auto i = text.begin();

	while (i < text.end()) {
		if (start == end) {
			return false;
		}

		ImWchar codepoint;
		i = CodePoint::read(i, text.end(), &codepoint);

		if ((start++)->codepoint != codepoint) {
			return false;
		}
	}

	return true;
}


//
//	TextEditor::Colorizer::updateLine
//

TextEditor::LineState TextEditor::Colorizer::updateLine(Line& line) {
	// initialize local variables
	auto state = line.state;
	auto nonWhiteSpace = false;
	auto glyph = line.begin();
	auto end = line.end();
	Iterator lineEnd(line.data() + line.size());

	// process all glyphs on this line
	while (glyph < end) {
		// start parsing glyphs
		auto start = glyph;
		Iterator tokenStart(&*glyph);

		if (state == LineState::inText) {
			// special handling for preprocessor lines
			if (!nonWhiteSpace && language->preprocess && glyph->codepoint != language->preprocess && !CodePoint::isWhiteSpace(glyph->codepoint)) {
				nonWhiteSpace = true;
			}

			// are we starting a multilevel, multiline comment
			if (language->commentLevelStart) {
				size_t level;
				Iterator tokenEnd = language->commentLevelStart(tokenStart, lineEnd, level);

				if (tokenEnd != tokenStart) {
					level = std::min(level, maxCommentLevel);
					state = commentLevelToLineState(level);
					auto size = tokenEnd - tokenStart;
					setColor(glyph, glyph + size, Color::comment);
					glyph += size;
				}
			}

			// are we starting a multilevel, multiline string
			if (glyph == start && language->stringLevelStart) {
				size_t level;
				Iterator tokenEnd = language->stringLevelStart(tokenStart, lineEnd, level);

				if (tokenEnd != tokenStart) {
					level = std::min(level, maxStringLevel);
					state = stringLevelToLineState(level);
					auto size = tokenEnd - tokenStart;
					setColor(glyph, glyph + size, Color::string);
					glyph += size;
				}
			}

			if (glyph == start) {
				// mark whitespace characters
				if (CodePoint::isWhiteSpace(glyph->codepoint)) {
					(glyph++)->color = Color::whitespace;

				// are we starting a multiline comment
				} else if (language->commentStart.size() && matches(glyph, end, language->commentStart)) {
					state = LineState::inComment;
					auto size = language->commentStart.size();
					setColor(glyph, glyph + size, Color::comment);
					glyph += size;

				// handle single line comments
				} else if (language->singleLineComment.size() && matches(glyph, end, language->singleLineComment)) {
					setColor(glyph, end, Color::comment);
					glyph = end;

				} else if (language->singleLineCommentAlt.size() && matches(glyph, end, language->singleLineCommentAlt)) {
					setColor(glyph, end, Color::comment);
					glyph = end;

				// are we starting a special string
				} else if (language->otherStringStart.size() && matches(glyph, end, language->otherStringStart)) {
					state = LineState::inOtherString;
					auto size = language->otherStringStart.size();
					setColor(glyph, glyph + size, Color::string);
					glyph += size;

				} else if (language->otherStringAltStart.size() && matches(glyph, end, language->otherStringAltStart)) {
					state = LineState::inOtherStringAlt;
					auto size = language->otherStringAltStart.size();
					setColor(glyph, glyph + size, Color::string);
					glyph += size;

				// are we starting a single quoted string
				} else if (language->hasSingleQuotedStrings && glyph->codepoint == CodePoint::singleQuote) {
					state = LineState::inSingleQuotedString;
					(glyph++)->color = Color::string;

				// are we starting a double quoted string
				} else if (language->hasDoubleQuotedStrings && glyph->codepoint == CodePoint::doubleQuote) {
					state = LineState::inDoubleQuotedString;
					(glyph++)->color = Color::string;

				// is this a preprocessor line
				} else if (language->preprocess && !nonWhiteSpace && glyph->codepoint == language->preprocess) {
					setColor(line.begin(), end, Color::preprocessor);
					glyph = end;
				}
			}

			if (glyph == start) {
				// nothing worked so far so it's time to do some tokenizing
				Color color;
				Iterator tokenEnd;

				// handle custom tokenizer (if we have one)
				if (language->customTokenizer&& (tokenEnd = language->customTokenizer(tokenStart, lineEnd, color)) != tokenStart) {
					auto size = tokenEnd - tokenStart;
					setColor(glyph, glyph + size, color);
					glyph += size;

				// do we have an identifier
				} else if (language->getIdentifier && (tokenEnd = language->getIdentifier(tokenStart, lineEnd)) != tokenStart) {
					// determine identifier text and color
					auto size = tokenEnd - tokenStart;
					std::string identifier;
					color = Color::identifier;

					for (auto i = tokenStart; i < tokenEnd; i++) {
						ImWchar codepoint = *i;

						if (!language->caseSensitive) {
							codepoint = CodePoint::toLower(codepoint);
						}

						char utf8[4];
						identifier.append(utf8, CodePoint::write(utf8, codepoint));
					}

					if (language->keywords.find(identifier) != language->keywords.end()) {
						color = Color::keyword;

					} else if (language->declarations.find(identifier) != language->declarations.end()) {
						color = Color::declaration;

					} else if (language->identifiers.find(identifier) != language->identifiers.end()) {
						color = Color::knownIdentifier;
					}

					// colorize identifier and move on
					setColor(glyph, glyph + size, color);
					glyph += size;

				// do we have a number
				} else if (language->getNumber && (tokenEnd = language->getNumber(tokenStart, lineEnd)) != tokenStart) {
					auto size = tokenEnd - tokenStart;
					setColor(glyph, glyph + size, Color::number);
					glyph += size;

				// is this punctuation
				} else if (language->isPunctuation && language->isPunctuation(glyph->codepoint)) {
					(glyph++)->color = Color::punctuation;

				} else {
					// I guess we don't know what this character is
					(glyph++)->color = Color::text;
				}
			}

		} else if (lineStateInComment(state)) {
			// stay in comment state until we see the end sequence
			auto size = language->commentEnd.size();

			if (size && matches(glyph, end, language->commentEnd)) {
				setColor(glyph, glyph + size, Color::comment);
				glyph += size;
				state = LineState::inText;

			} else if (language->commentLevelEnd) {
				size_t level;
				Iterator tokenEnd = language->commentLevelEnd(tokenStart, lineEnd, level);

				if (tokenEnd != tokenStart) {
					level = std::min(level, maxCommentLevel);

					if (state == commentLevelToLineState(level)) {
						size = tokenEnd - tokenStart;
						setColor(glyph, glyph + size, Color::comment);
						glyph += size;
						state = LineState::inText;
					}
				}
			}

			if (lineStateInComment(state)) {
				(glyph++)->color = Color::comment;
			}

		} else if (lineStateInStringLevel(state)) {
			// stay in string level until matching closing is detected
			size_t level;
			Iterator tokenEnd = language->stringLevelEnd(tokenStart, lineEnd, level);

			if (tokenEnd != tokenStart) {
				level = std::min(level, maxStringLevel);

				if (state == stringLevelToLineState(level)) {
					auto size = tokenEnd - tokenStart;
					setColor(glyph, glyph + size, Color::string);
					glyph += size;
					state = LineState::inText;

				} else {
					(glyph++)->color = Color::string;
				}

			} else {
				(glyph++)->color = Color::string;
			}

		} else if (state == LineState::inOtherString) {
			// stay in otherString state until we see the end sequence
			// skip escaped characters
			if (glyph->codepoint == language->stringEscape) {
				(glyph++)->color = Color::string;

				if (glyph < end) {
					(glyph++)->color = Color::string;
				}

			} else if (matches(glyph, end, language->otherStringEnd)) {
				auto size = language->otherStringEnd.size();
				setColor(glyph, glyph + size, Color::string);
				glyph += size;
				state = LineState::inText;

			} else {
				(glyph++)->color = Color::string;
			}

		} else if (state == LineState::inOtherStringAlt) {
			// stay in otherStringAlt state until we see the end sequence
			// skip escaped characters
			if (glyph->codepoint == language->stringEscape) {
				(glyph++)->color = Color::string;

				if (glyph < end) {
					(glyph++)->color = Color::string;
				}

			} else if (matches(glyph, end, language->otherStringAltEnd)) {
				auto size = language->otherStringAltEnd.size();
				setColor(glyph, glyph + size, Color::string);
				glyph += size;
				state = LineState::inText;

			} else {
				(glyph++)->color = Color::string;
			}

		} else if (state == LineState::inSingleQuotedString) {
			// stay in single quote state until we see an end
			// skip escaped characters
			if (glyph->codepoint == language->stringEscape) {
				(glyph++)->color = Color::string;

				if (glyph < end) {
					(glyph++)->color = Color::string;
				}

			} else if (glyph->codepoint == CodePoint::singleQuote) {
				(glyph++)->color = Color::string;
				state = LineState::inText;

			} else {
				(glyph++)->color = Color::string;
			}

		} else if (state == LineState::inDoubleQuotedString) {
			// stay in double quote state until we see an end
			// skip escaped characters
			if (glyph->codepoint == language->stringEscape) {
				(glyph++)->color = Color::string;

				if (glyph < end) {
					(glyph++)->color = Color::string;
				}

			} else if (glyph->codepoint == CodePoint::doubleQuote) {
				(glyph++)->color = Color::string;
				state = LineState::inText;

			} else {
				(glyph++)->color = Color::string;
			}
		}
	}

	return state;
}


//
//	TextEditor::Colorizer::update
//

bool TextEditor::Colorizer::update(const Config& config, Document& document) {
	// update all lines on configuration change
	bool configChanged = language != config.language;

	if (configChanged) {
		language = config.language;

		if (language) {
			for (auto line = document.begin(); line < document.end(); line++) {
				auto state = updateLine(*line);
				line->needsColorizing = false;
				auto next = line + 1;

				if (next < document.end()) {
					next->state = state;
				}
			}

		} else {
			for (auto line = document.begin(); line < document.end(); line++) {
				for (auto glyph = line->begin(); glyph < line->end(); glyph++) {
					glyph->color = Color::text;
				}

				line->state = LineState::inText;
				line->needsColorizing = false;
			}
		}

	// update changed lines when document is updated
	} else if (document.isUpdated()) {
		for (auto line = document.begin(); line < document.end(); line++) {
			if (line->needsColorizing) {
				if (language) {
					auto state = updateLine(*line);
					line->needsColorizing = false;
					auto next = line + 1;

					if (next < document.end() && next->state != state) {
						next->state = state;
						next->needsColorizing = true;
					}

				} else {
					for (auto glyph = line->begin(); glyph < line->end(); glyph++) {
						glyph->color = Color::text;
					}

					line->state = LineState::inText;
					line->needsColorizing = false;
				}
			}
		}
	}

	// return status
	return configChanged;
}


//
//	TextEditor::Bracketeer::update
//

void TextEditor::Bracketeer::update(const Config& config, Document& document) {
	// see if the configuration changed
	bool configChanged =
		showMatchingBrackets != config.showMatchingBrackets ||
		language != config.language;

	showMatchingBrackets = config.showMatchingBrackets;
	language = config.language;

	if (configChanged && !showMatchingBrackets) {
		// if configuration changed, clear the bracket pair list
		clear();

		// and reset glyph colors
		for (size_t line = 0; line < document.size(); line++) {
			for (size_t index = 0; index < document[line].size(); index++) {
				auto& glyph = document[line][index];

				if (glyph.color == Color::matchingBracketLevel1 ||
					glyph.color == Color::matchingBracketLevel2 ||
					glyph.color == Color::matchingBracketLevel3 ||
					glyph.color == Color::matchingBracketError) {

					glyph.color = Color::punctuation;
				}
			}
		}

	} else if (showMatchingBrackets && (configChanged || document.isUpdated())) {
		// if configuration or document changed, recalculate bracket pair list
		static const Color bracketColors[] = {
			Color::matchingBracketLevel1,
			Color::matchingBracketLevel2,
			Color::matchingBracketLevel3
		};

		// copy old list so we can see if things have changed
		auto previous = *this;

		// clear old list
		clear();
		std::vector<size_t> levels;
		size_t level = 0;

		// process all the glyphs
		for (size_t line = 0; line < document.size(); line++) {
			for (size_t index = 0; index < document[line].size(); index++) {
				auto& glyph = document[line][index];

				// handle a "bracket opener" that is not in a comment, string or preprocessor statement
				if (isBracketCandidate(glyph) && CodePoint::isBracketOpener(glyph.codepoint)) {
					// start a new level
					levels.emplace_back(size());
					emplace_back(glyph.codepoint, DocPos(line, index), static_cast<ImWchar>(0), DocPos(0, 0), level, true);
					glyph.color = bracketColors[level % 3];
					level++;

				// handle a "bracket closer" that is not in a comment, string or preprocessor statement
				} else if (isBracketCandidate(glyph) && CodePoint::isBracketCloser(glyph.codepoint)) {
					if (levels.size()) {
						auto& lastBracket = at(levels.back());
						levels.pop_back();
						level--;

						if (lastBracket.startChar == CodePoint::toPairOpener(glyph.codepoint)) {
							// handle matching bracket
							glyph.color = bracketColors[level % 3];
							lastBracket.endChar = glyph.codepoint;
							lastBracket.end = DocPos(line, index);

						} else {
							// no matching bracket, mark brackets as errors
							glyph.color = Color::matchingBracketError;
							document[lastBracket.start.line][lastBracket.start.index].color = Color::matchingBracketError;
							pop_back();
						}

					// this is a closer without an opener
					} else {
						glyph.color = Color::matchingBracketError;
					}
				}
			}
		}

		// handle levels left open and mark them as errors
		if (levels.size()) {
			for (auto i = levels.rbegin(); i < levels.rend(); i++) {
				const auto& start = at(*i).start;
				document[start.line][start.index].color = Color::matchingBracketError;
				erase(begin() + *i);
			}
		}

		// process invisible blocks for languages that are indentation based
		if (language && language->indentationForBlocks) {
			for (size_t i = 0; i < document.size(); i++) {
				if (document[i].size()) {
					auto currentIndent = document[i].indent;
					auto endLine = i;
					auto done = false;

					for (size_t j = i + 1; j < document.size() && !done; j++) {
						if (document[j].size()) {
							auto nextIndent = document[j].indent;

							if (nextIndent > currentIndent) {
								endLine = j;

							} else {
								done = true;
							}
						}
					}

					if (endLine > i) {
						emplace_back(DocPos(i, 0), DocPos(endLine, document[endLine].size()));
					}
				}
			}

			// sort visible and invisible blocks by block start
			std::sort(begin(), end(), [](const BracketPair& a, const BracketPair& b) {
				return a.start < b.start;
			});
		}

		updated = previous != *this;
	}
}


//
//	TextEditor::Bracketeer::getEnclosingBrackets
//

TextEditor::Bracketeer::const_iterator TextEditor::Bracketeer::getEnclosingBrackets(DocPos location) const {
	auto brackets = cend();
	bool done = false;

	for (auto i = cbegin(); !done && i < end(); i++) {
		// brackets are sorted so no need to go past specified location
		if (i->isAfter(location)) {
			done = true;
		}

		else if (i->isAround(location)) {
			// this could be what we're looking for
			brackets = i;
		}
	}

	return brackets;
}


//
//	TextEditor::Bracketeer::getEnclosingBrackets
//

TextEditor::Bracketeer::const_iterator TextEditor::Bracketeer::getEnclosingBrackets(DocPos first, DocPos last) const {
	auto brackets = cend();
	bool done = false;

	for (auto i = cbegin(); !done && i < end(); i++) {
		// brackets are sorted so no need to go past specified location
		if (i->isAfter(first)) {
			done = true;
		}

		else if (i->isAround(first) && i->isAround(last)) {
			// this could be what we're looking for
			brackets = i;
		}
	}

	return brackets;
}


//
//	TextEditor::Bracketeer::getInnerBrackets
//

TextEditor::Bracketeer::const_iterator TextEditor::Bracketeer::getInnerBrackets(DocPos first, DocPos last) const {
	auto brackets = cend();
	auto outer = getEnclosingBrackets(first, last);

	if (outer != end()) {
		bool done = false;

		for (auto i = outer + 1; i < end() && !done; i++) {
			if (i->level <= outer->level) {
				done = true;

			} else if (i->level == outer->level + 1 && i->start > first && i->end < last) {
				brackets = i;
				done = true;
			}
		}
	}

	return brackets;
}


//
//	latchButton
//

static bool latchButton(const char* label, bool* value, const ImVec2& size) {
	auto changed = false;
	const ImVec4* colors = ImGui::GetStyle().Colors;

	if (*value) {
		ImGui::PushStyleColor(ImGuiCol_Button, colors[ImGuiCol_ButtonActive]);
		ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors[ImGuiCol_ButtonActive]);
		ImGui::PushStyleColor(ImGuiCol_ButtonActive, colors[ImGuiCol_TableBorderLight]);

	} else {
		ImGui::PushStyleColor(ImGuiCol_Button, colors[ImGuiCol_TableBorderLight]);
		ImGui::PushStyleColor(ImGuiCol_ButtonHovered, colors[ImGuiCol_TableBorderLight]);
		ImGui::PushStyleColor(ImGuiCol_ButtonActive, colors[ImGuiCol_ButtonActive]);
	}

	ImGui::Button(label, size);

	if (ImGui::IsItemClicked(ImGuiMouseButton_Left)) {
		*value = !*value;
		changed = true;
	}

	ImGui::PopStyleColor(3);
	return changed;
}


//
//	inputString
//

static bool inputString(const char* label, std::string* value, ImGuiInputTextFlags flags=ImGuiInputTextFlags_None) {
	flags |=
		ImGuiInputTextFlags_NoUndoRedo |
		ImGuiInputTextFlags_CallbackResize;

	return ImGui::InputText(label, value->data(), value->capacity() + 1, flags, [](ImGuiInputTextCallbackData* data) {
		if (data->EventFlag == ImGuiInputTextFlags_CallbackResize) {
			std::string* value = static_cast<std::string*>(data->UserData);
			value->resize(data->BufTextLen);
			data->Buf = (char*) value->c_str();
		}

		return 0;
	}, value);
}


//
//	TextEditor::renderFindReplace
//

void TextEditor::renderFindReplace() {
	// render find/replace window (if required)
	if (findReplaceVisible) {
		// save current screen position
		auto currentScreenPosition = ImGui::GetCursorScreenPos();

		// calculate sizes
		ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(6.0f, 4.0f));
		const auto& style = ImGui::GetStyle();
		auto fieldWidth = 250.0f * ImGui::GetStyle().FontScaleDpi;

		auto button1Width = ImGui::CalcTextSize(findButtonLabel.c_str()).x + style.ItemSpacing.x * 2.0f;
		auto button2Width = ImGui::CalcTextSize(findAllButtonLabel.c_str()).x + style.ItemSpacing.x * 2.0f;
		auto optionWidth = ImGui::CalcTextSize("Aa").x + style.ItemSpacing.x * 2.0f;

		if (!config.readOnly) {
			button1Width = std::max(button1Width, ImGui::CalcTextSize(replaceButtonLabel.c_str()).x + style.ItemSpacing.x * 2.0f);
			button2Width = std::max(button2Width, ImGui::CalcTextSize(replaceAllButtonLabel.c_str()).x + style.ItemSpacing.x * 2.0f);
		}

		auto windowHeight =
			style.ChildBorderSize * 2.0f +
			style.WindowPadding.y * 2.0f +
			ImGui::GetFrameHeight() +
			(config.readOnly ? 0.0f : (style.ItemSpacing.y + ImGui::GetFrameHeight()));

		auto windowWidth =
			style.ChildBorderSize * 2.0f +
			style.WindowPadding.x * 2.0f +
			fieldWidth + style.ItemSpacing.x +
			button1Width + style.ItemSpacing.x +
			button2Width + style.ItemSpacing.x +
			optionWidth * 3.0f + style.ItemSpacing.x * 2.0f;

		// create window
		auto availableSpace =
			ImGui::GetWindowWidth() -
			(config.showMiniMap ? miniMapWidth : 0.0f) -
			(ImGui::GetCurrentWindow()->ScrollbarY ? ImGui::GetStyle().ScrollbarSize : 0.0f);

		ImGui::SetNextWindowPos(
			ImGui::GetWindowPos() +
			ImVec2(availableSpace - windowWidth - style.ItemSpacing.x, style.ItemSpacing.y * 2.0f));

		ImGui::SetNextWindowSize(ImVec2(windowWidth, windowHeight));
		ImGui::SetNextWindowBgAlpha(0.75f);

		ImGui::BeginChild("find-replace", ImVec2(windowWidth, windowHeight), ImGuiChildFlags_Borders);
		ImGui::SetNextItemWidth(fieldWidth);

		if (focusOnFind) {
			ImGui::SetKeyboardFocusHere();
			focusOnFind = false;

		} else if (findCancelledAutocomplete) {
			ImGui::SetKeyboardFocusHere();
			findCancelledAutocomplete = false;
		}

		if (inputString("###find", &findText, ImGuiInputTextFlags_AutoSelectAll)) {
			if (findText.size()) {
				selectFirstOccurrenceOf(findText, caseSensitiveFind, wholeWordFind);

			} else {
				cursors.clearAll();
			}
		}

		if (ImGui::IsItemDeactivated()) {
			if (ImGui::IsKeyPressed(ImGuiKey_Escape)) {
				closeFindReplace();

			} else if (ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter)) {
				focusOnEditor = true;
				focusOnFind = false;
			}
		}

		bool disableFindButtons = !findText.size();

		if (disableFindButtons) {
			ImGui::BeginDisabled();
		}

		ImGui::SameLine();

		if (ImGui::Button(findButtonLabel.c_str(), ImVec2(button1Width, 0.0f))) {
			find();
		}

		ImGui::SameLine();

		if (ImGui::Button(findAllButtonLabel.c_str(), ImVec2(button2Width, 0.0f))) {
			findAll();
		}

		if (disableFindButtons) {
			ImGui::EndDisabled();
		}

		ImGui::SameLine();

		if (latchButton("Aa", &caseSensitiveFind, ImVec2(optionWidth, 0.0f))) {
			find();
		}

		ImGui::SameLine();

		if (latchButton("[]", &wholeWordFind, ImVec2(optionWidth, 0.0f))) {
			find();
		}

		ImGui::SameLine();

		if (ImGui::Button("x", ImVec2(optionWidth, 0.0f))) {
			closeFindReplace();
		}

		if (!config.readOnly) {
			ImGui::SetNextItemWidth(fieldWidth);
			inputString("###replace", &replaceText);
			ImGui::SameLine();

			bool disableReplaceButtons = !findText.size() || !replaceText.size();

			if (disableReplaceButtons) {
				ImGui::BeginDisabled();
			}

			if (ImGui::Button(replaceButtonLabel.c_str(), ImVec2(button1Width, 0.0f))) {
				replace();
			}

			ImGui::SameLine();

			if (ImGui::Button(replaceAllButtonLabel.c_str(), ImVec2(button2Width, 0.0f))) {
				replaceAll();
			}

			if (disableReplaceButtons) {
				ImGui::EndDisabled();
			}
		}


		if (ImGui::IsWindowFocused() &&
			!disableFindButtons &&
			ImGui::IsKeyChordPressed(ImGuiMod_Ctrl | ImGuiKey_G)) {

			ImGui::SetWindowFocus(nullptr);
			find();
		}

		ImGui::EndChild();
		ImGui::PopStyleVar();
		ImGui::SetCursorScreenPos(currentScreenPosition);
	}
}


//
//	TextEditor::selectFirstOccurrenceOf
//

void TextEditor::selectFirstOccurrenceOf(const std::string_view& text, bool caseSensitive, bool wholeWord) {
	DocPos start, end;

	if (document.findText(DocPos(0, 0), text, caseSensitive, wholeWord, start, end)) {
		cursors.setCursor(start, end);
		makeCursorVisible();

	} else {
		cursors.clearAdditional(true);
	}
}


//
//	TextEditor::selectNextOccurrenceOf
//

void TextEditor::selectNextOccurrenceOf(const std::string_view& text, bool caseSensitive, bool wholeWord) {
	DocPos start, end;

	if (document.findText(cursors.getCurrent().getSelectionEnd(), text, caseSensitive, wholeWord, start, end)) {
		cursors.setCursor(start, end);
		makeCursorVisible();

	} else {
		cursors.clearAdditional(true);
	}
}


//
//	TextEditor::selectAllOccurrencesOf
//

void TextEditor::selectAllOccurrencesOf(const std::string_view& text, bool caseSensitive, bool wholeWord) {
	DocPos start, end;

	if (document.findText(DocPos(0, 0), text, caseSensitive, wholeWord, start, end)) {
		cursors.setCursor(start, end);
		bool done = false;

		while (!done) {
			DocPos nextStart, nextEnd;
			document.findText(cursors.getCurrent().getSelectionEnd(), text, caseSensitive, wholeWord, nextStart, nextEnd);

			if (nextStart == start && nextEnd == end) {
				done = true;

			} else {
				cursors.addCursor(nextStart, nextEnd);
			}
		}

	} else {
		cursors.clearAdditional(true);
	}
}


//
//	TextEditor::addNextOccurrence
//

void TextEditor::addNextOccurrence(bool wholeWord) {

	auto cursor = cursors.getCurrent();
	auto text = document.getSectionText(cursor.getSelectionStart(), cursor.getSelectionEnd());
	DocPos start, end;

	if (document.findText(cursor.getSelectionEnd(), text, true, wholeWord, start, end)) {
		cursors.addCursor(start, end);
	}
}


//
//	TextEditor::selectAllOccurrences
//

void TextEditor::selectAllOccurrences(bool wholeWord) {
	auto cursor = cursors.getCurrent();
	auto text = document.getSectionText(cursor.getSelectionStart(), cursor.getSelectionEnd());
	selectAllOccurrencesOf(text, true, wholeWord);
}


//
//	TextEditor::replaceTextInCurrentCursor
//

void TextEditor::replaceTextInCurrentCursor(const std::string_view& text) {
	auto transaction = startTransaction();

	// first delete old text
	auto cursor = cursors.getCurrentAsIterator();
	auto start = cursor->getSelectionStart();
	auto end = cursor->getSelectionEnd();
	deleteText(transaction, start, end);
	cursors.adjustForDelete(cursor, start, end);

	// now insert new text
	DocPos newEnd = insertText(transaction, start, text);
	cursor->update(newEnd, false);
	cursors.adjustForInsert(cursor, start, newEnd);

	endTransaction(transaction);
}


//
//	TextEditor::replaceTextInAllCursors
//

void TextEditor::replaceTextInAllCursors(const std::string_view& text) {
	auto transaction = startTransaction();
	insertTextIntoAllCursors(transaction, text);
	endTransaction(transaction);
}


//
//	TextEditor::replaceSectionText
//

void TextEditor::replaceSectionText(const DocPos& start, const DocPos& end, const std::string_view& text) {
	auto transaction = startTransaction();
	deleteText(transaction, start, end);
	auto newEnd = insertText(transaction, start, text);
	cursors.clearAdditional();
	cursors.getMain().update(newEnd, newEnd);
	endTransaction(transaction);
}


//
//	TextEditor::openFindReplace
//

void TextEditor::openFindReplace() {
	// get main cursor location
	auto cursor = cursors.getMain();

	// see if we have a current selection that's on one line
	if (cursor.hasSelection()) {
		if (cursor.getSelectionStart().line == cursor.getSelectionEnd().line) {
			// use it as the default search
			findText = document.getSectionText(cursor.getSelectionStart(), cursor.getSelectionEnd());
		}

	} else {
		// if cursor is inside a "real" word, use that as the default
		auto selection = document.getWholeWord(cursor.getSelectionStart(), true);

		if (selection.start != selection.end) {
			findText = document.getSectionText(selection.start, selection.end);
		}
	}

	findReplaceVisible = true;
	focusOnFind = true;
}


//
//	TextEditor::closeFindReplace
//

void TextEditor::closeFindReplace() {
	findReplaceVisible = false;
	focusOnEditor = true;
	focusOnFind = false;
}


//
//	TextEditor::find
//

void TextEditor::find() {
	if (findText.size()) {
		selectNextOccurrenceOf(findText, caseSensitiveFind, wholeWordFind);
		focusOnEditor = true;
		focusOnFind = false;
	}
}


//
//	TextEditor::findNext
//

void TextEditor::findNext() {
	if (findText.size()) {
		selectNextOccurrenceOf(findText, caseSensitiveFind, wholeWordFind);
		focusOnEditor = true;
		focusOnFind = false;
	}
}


//
//	TextEditor::findAll
//

void TextEditor::findAll() {
	if (findText.size()) {
		selectAllOccurrencesOf(findText, caseSensitiveFind, wholeWordFind);
		focusOnEditor = true;
		focusOnFind = false;
	}
}


//
//	TextEditor::replace
//

void TextEditor::replace() {
	if (findText.size()) {
		if (!cursors.anyHasSelection()) {
			selectNextOccurrenceOf(findText, caseSensitiveFind, wholeWordFind);
		}

		replaceTextInCurrentCursor(replaceText);
		selectNextOccurrenceOf(findText, caseSensitiveFind, wholeWordFind);
		focusOnEditor = true;
		focusOnFind = false;
	}
}


//
//	TextEditor::replaceAll
//

void TextEditor::replaceAll() {
	if (findText.size()) {
		selectAllOccurrencesOf(findText, caseSensitiveFind, wholeWordFind);
		replaceTextInAllCursors(replaceText);
		focusOnEditor = true;
		focusOnFind = false;
	}
}
//
//	TextEditor::MiniMap::update
//

bool TextEditor::MiniMap::update(const Config& config, const Document& document, const TypeSetter& typeSetter) {
	// update all lines on configuration change
	bool configChanged = showMiniMap != config.showMiniMap;

	if (configChanged) {
		showMiniMap = config.showMiniMap;
	}

	if (configChanged || typeSetter.isUpdated()) {
		// reset state
		auto rowCount = typeSetter.getRowCount();
		rows.clear();

		// process all rows
		for (size_t i = 0; i < rowCount; i++) {
			auto& line = document[typeSetter[i].line];

			if (line.foldingState != FoldingState::hidden) {
				size_t index;
				size_t column;
				size_t endColumn;

				// determine visible part of document line on row
				if (config.wordWrap && line.sections) {
					const auto& section = line.sections->at(typeSetter[i].section);
					index = section.startIndex;
					column = section.indent;
					endColumn = section.columns;

				} else {
					index = 0;
					column = 0;
					endColumn = line.columns;
				}

				// process line
				processLine(line, config, index, column, endColumn);
			}
		}
	}

	// return status
	return configChanged || typeSetter.isUpdated();
}


//
//	TextEditor::MiniMap::processLine
//

void TextEditor::MiniMap::processLine(
	const Line& line,
	const Config& config,
	size_t index,
	size_t column,
	size_t endColumn) {

	auto& row = rows.emplace_back();
	auto start = column;
	auto color = Color::background;

	// process all
	while (column < endColumn) {
		auto& glyph = line[index++];

		// detect end of section
		if (glyph.color != color) {
			if (column != start) {
				if (color != Color::whitespace) {
					row.sections.emplace_back(start, column, color);
				}

				start = column;
			}

			color = glyph.color;
		}

		// update column number
		column += (glyph.codepoint == '\t') ? (config.tabSize - (column % config.tabSize)) : 1;
	}

	// handle possible sections at the end of the row
	if (column != start && color != Color::whitespace) {
		row.sections.emplace_back(start, column, color);
	}
}


//
//	line break class types for codepoints
//

enum class LBC : char {
	ai,			// ambiguous (alphabetic or ideograph)
	ak,			// aksara
	al,			// alphabetic
	ap,			// aksara pre-base
	as,			// aksara start
	b2,			// break on either side (but not pair)
	ba,			// break after
	bb,			// break before
	bk,			// break (mandatory)
	cb,			// contingent break
	cj,			// conditional Japanese starter
	cl,			// closing punctuation
	cm,			// combining marks
	cp,			// closing parenthesis
	cr,			// carriage return
	eb,			// emoji base
	em,			// emoji modifier
	ex,			// exclamation/interrogation
	gl,			// glue
	h2,			// hangul lv
	h3,			// hangul lvt
	hh,			// unambiguous hyphen
	hl,			// hebrew letter
	hy,			// hyphen
	id,			// ideographic
	in,			// inseparable characters
	is,			// infix separator
	jl,			// hangul l jamo
	jt,			// hangul t jamo
	jv,			// hangul v jamo
	lf,			// line feed
	nl,			// next line
	ns,			// non-starters
	nu,			// numeric
	op,			// opening punctuation
	po,			// postfix
	pr,			// prefix
	qu,			// ambiguous quotation
	ri,			// regional indicator
	sa,			// complex context dependent (South East Asian)
	sg,			// surrogate (non-tailorable)
	sp,			// space
	sy,			// symbols allowing break after
	vf,			// virama final
	vi,			// virama
	wj,			// word joiner
	xx,			// unknown
	zw,			// zero-width space
	zwj,		// zero width joiner

	sot,		// pseudo class - start of text
	eot,		// pseudo class - end of text
	undefined	// pseudo value for undefined class
};


//
//	Table types
//

template <typename T>
struct LineBreakRange {
	T low;
	T high;
	LBC lbc;
};

using LineBreakRange16 = LineBreakRange<ImWchar16>;
using LineBreakRange32 = LineBreakRange<ImWchar32>;


//
//	lineBreak8
//

static LBC lineBreak8[] = {
	LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::ba, LBC::lf, LBC::bk, LBC::bk,
	LBC::cr, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm,
	LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::sp, LBC::ex, LBC::qu, LBC::al, LBC::pr, LBC::po, LBC::al,
	LBC::qu, LBC::op, LBC::cp, LBC::al, LBC::pr, LBC::is, LBC::hy, LBC::is, LBC::sy, LBC::nu, LBC::nu, LBC::nu, LBC::nu,
	LBC::nu, LBC::nu, LBC::nu, LBC::nu, LBC::nu, LBC::nu, LBC::is, LBC::is, LBC::al, LBC::al, LBC::al, LBC::ex, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::op, LBC::pr, LBC::cp, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::op, LBC::ba, LBC::cl, LBC::al, LBC::cm, LBC::cm, LBC::cm,
	LBC::cm, LBC::cm, LBC::cm, LBC::nl, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm,
	LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::cm,
	LBC::cm, LBC::cm, LBC::cm, LBC::cm, LBC::gl, LBC::op, LBC::po, LBC::pr, LBC::pr, LBC::pr, LBC::al, LBC::ai, LBC::ai,
	LBC::al, LBC::ai, LBC::qu, LBC::al, LBC::ba, LBC::al, LBC::al, LBC::po, LBC::pr, LBC::ai, LBC::ai, LBC::bb, LBC::al,
	LBC::ai, LBC::ai, LBC::ai, LBC::ai, LBC::ai, LBC::qu, LBC::ai, LBC::ai, LBC::ai, LBC::op, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::ai, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al,
	LBC::ai, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al, LBC::al
};


//
//	lineBreak16
//

static LineBreakRange16 lineBreak16[] = {
	{0x0000, 0x0008, LBC::cm}, {0x0009, 0x0009, LBC::ba}, {0x000a, 0x000a, LBC::lf}, {0x000b, 0x000c, LBC::bk},
	{0x000d, 0x000d, LBC::cr}, {0x000e, 0x001f, LBC::cm}, {0x0020, 0x0020, LBC::sp}, {0x0021, 0x0021, LBC::ex},
	{0x0022, 0x0022, LBC::qu}, {0x0023, 0x0023, LBC::al}, {0x0024, 0x0024, LBC::pr}, {0x0025, 0x0025, LBC::po},
	{0x0026, 0x0026, LBC::al}, {0x0027, 0x0027, LBC::qu}, {0x0028, 0x0028, LBC::op}, {0x0029, 0x0029, LBC::cp},
	{0x002a, 0x002a, LBC::al}, {0x002b, 0x002b, LBC::pr}, {0x002c, 0x002c, LBC::is}, {0x002d, 0x002d, LBC::hy},
	{0x002e, 0x002e, LBC::is}, {0x002f, 0x002f, LBC::sy}, {0x0030, 0x0039, LBC::nu}, {0x003a, 0x003b, LBC::is},
	{0x003c, 0x003e, LBC::al}, {0x003f, 0x003f, LBC::ex}, {0x0040, 0x005a, LBC::al}, {0x005b, 0x005b, LBC::op},
	{0x005c, 0x005c, LBC::pr}, {0x005d, 0x005d, LBC::cp}, {0x005e, 0x007a, LBC::al}, {0x007b, 0x007b, LBC::op},
	{0x007c, 0x007c, LBC::ba}, {0x007d, 0x007d, LBC::cl}, {0x007e, 0x007e, LBC::al}, {0x007f, 0x0084, LBC::cm},
	{0x0085, 0x0085, LBC::nl}, {0x0086, 0x009f, LBC::cm}, {0x00a0, 0x00a0, LBC::gl}, {0x00a1, 0x00a1, LBC::op},
	{0x00a2, 0x00a2, LBC::po}, {0x00a3, 0x00a5, LBC::pr}, {0x00a6, 0x00a6, LBC::al}, {0x00a7, 0x00a8, LBC::ai},
	{0x00a9, 0x00a9, LBC::al}, {0x00aa, 0x00aa, LBC::ai}, {0x00ab, 0x00ab, LBC::qu}, {0x00ac, 0x00ac, LBC::al},
	{0x00ad, 0x00ad, LBC::ba}, {0x00ae, 0x00af, LBC::al}, {0x00b0, 0x00b0, LBC::po}, {0x00b1, 0x00b1, LBC::pr},
	{0x00b2, 0x00b3, LBC::ai}, {0x00b4, 0x00b4, LBC::bb}, {0x00b5, 0x00b5, LBC::al}, {0x00b6, 0x00ba, LBC::ai},
	{0x00bb, 0x00bb, LBC::qu}, {0x00bc, 0x00be, LBC::ai}, {0x00bf, 0x00bf, LBC::op}, {0x00c0, 0x00d6, LBC::al},
	{0x00d7, 0x00d7, LBC::ai}, {0x00d8, 0x00f6, LBC::al}, {0x00f7, 0x00f7, LBC::ai}, {0x00f8, 0x02c6, LBC::al},
	{0x02c7, 0x02c7, LBC::ai}, {0x02c8, 0x02c8, LBC::bb}, {0x02c9, 0x02cb, LBC::ai}, {0x02cc, 0x02cc, LBC::bb},
	{0x02cd, 0x02cd, LBC::ai}, {0x02ce, 0x02cf, LBC::al}, {0x02d0, 0x02d0, LBC::ai}, {0x02d1, 0x02d7, LBC::al},
	{0x02d8, 0x02db, LBC::ai}, {0x02dc, 0x02dc, LBC::al}, {0x02dd, 0x02dd, LBC::ai}, {0x02de, 0x02de, LBC::al},
	{0x02df, 0x02df, LBC::bb}, {0x02e0, 0x02ff, LBC::al}, {0x0300, 0x035b, LBC::cm}, {0x035c, 0x0362, LBC::gl},
	{0x0363, 0x036f, LBC::cm}, {0x0370, 0x0377, LBC::al}, {0x037a, 0x037d, LBC::al}, {0x037e, 0x037e, LBC::is},
	{0x037f, 0x037f, LBC::al}, {0x0384, 0x038a, LBC::al}, {0x038c, 0x038c, LBC::al}, {0x038e, 0x03a1, LBC::al},
	{0x03a3, 0x0482, LBC::al}, {0x0483, 0x0489, LBC::cm}, {0x048a, 0x052f, LBC::al}, {0x0531, 0x0556, LBC::al},
	{0x0559, 0x0588, LBC::al}, {0x0589, 0x0589, LBC::is}, {0x058a, 0x058a, LBC::hh}, {0x058d, 0x058e, LBC::al},
	{0x058f, 0x058f, LBC::pr}, {0x0591, 0x05bd, LBC::cm}, {0x05be, 0x05be, LBC::hh}, {0x05bf, 0x05bf, LBC::cm},
	{0x05c0, 0x05c0, LBC::al}, {0x05c1, 0x05c2, LBC::cm}, {0x05c3, 0x05c3, LBC::al}, {0x05c4, 0x05c5, LBC::cm},
	{0x05c6, 0x05c6, LBC::ex}, {0x05c7, 0x05c7, LBC::cm}, {0x05d0, 0x05ea, LBC::hl}, {0x05ef, 0x05f2, LBC::hl},
	{0x05f3, 0x05f4, LBC::al}, {0x0600, 0x0605, LBC::nu}, {0x0606, 0x0608, LBC::al}, {0x0609, 0x060b, LBC::po},
	{0x060c, 0x060d, LBC::is}, {0x060e, 0x060f, LBC::al}, {0x0610, 0x061a, LBC::cm}, {0x061b, 0x061b, LBC::ex},
	{0x061c, 0x061c, LBC::cm}, {0x061d, 0x061f, LBC::ex}, {0x0620, 0x064a, LBC::al}, {0x064b, 0x065f, LBC::cm},
	{0x0660, 0x0669, LBC::nu}, {0x066a, 0x066a, LBC::po}, {0x066b, 0x066c, LBC::nu}, {0x066d, 0x066f, LBC::al},
	{0x0670, 0x0670, LBC::cm}, {0x0671, 0x06d3, LBC::al}, {0x06d4, 0x06d4, LBC::ex}, {0x06d5, 0x06d5, LBC::al},
	{0x06d6, 0x06dc, LBC::cm}, {0x06dd, 0x06dd, LBC::nu}, {0x06de, 0x06de, LBC::al}, {0x06df, 0x06e4, LBC::cm},
	{0x06e5, 0x06e6, LBC::al}, {0x06e7, 0x06e8, LBC::cm}, {0x06e9, 0x06e9, LBC::al}, {0x06ea, 0x06ed, LBC::cm},
	{0x06ee, 0x06ef, LBC::al}, {0x06f0, 0x06f9, LBC::nu}, {0x06fa, 0x070d, LBC::al}, {0x070f, 0x0710, LBC::al},
	{0x0711, 0x0711, LBC::cm}, {0x0712, 0x072f, LBC::al}, {0x0730, 0x074a, LBC::cm}, {0x074d, 0x07a5, LBC::al},
	{0x07a6, 0x07b0, LBC::cm}, {0x07b1, 0x07b1, LBC::al}, {0x07c0, 0x07c9, LBC::nu}, {0x07ca, 0x07ea, LBC::al},
	{0x07eb, 0x07f3, LBC::cm}, {0x07f4, 0x07f7, LBC::al}, {0x07f8, 0x07f8, LBC::is}, {0x07f9, 0x07f9, LBC::ex},
	{0x07fa, 0x07fa, LBC::al}, {0x07fd, 0x07fd, LBC::cm}, {0x07fe, 0x07ff, LBC::pr}, {0x0800, 0x0815, LBC::al},
	{0x0816, 0x0819, LBC::cm}, {0x081a, 0x081a, LBC::al}, {0x081b, 0x0823, LBC::cm}, {0x0824, 0x0824, LBC::al},
	{0x0825, 0x0827, LBC::cm}, {0x0828, 0x0828, LBC::al}, {0x0829, 0x082d, LBC::cm}, {0x0830, 0x083e, LBC::al},
	{0x0840, 0x0858, LBC::al}, {0x0859, 0x085b, LBC::cm}, {0x085e, 0x085e, LBC::al}, {0x0860, 0x086a, LBC::al},
	{0x0870, 0x088f, LBC::al}, {0x0890, 0x0891, LBC::nu}, {0x0897, 0x089f, LBC::cm}, {0x08a0, 0x08c9, LBC::al},
	{0x08ca, 0x08e1, LBC::cm}, {0x08e2, 0x08e2, LBC::nu}, {0x08e3, 0x0903, LBC::cm}, {0x0904, 0x0939, LBC::al},
	{0x093a, 0x093c, LBC::cm}, {0x093d, 0x093d, LBC::al}, {0x093e, 0x094f, LBC::cm}, {0x0950, 0x0950, LBC::al},
	{0x0951, 0x0957, LBC::cm}, {0x0958, 0x0961, LBC::al}, {0x0962, 0x0963, LBC::cm}, {0x0964, 0x0965, LBC::ba},
	{0x0966, 0x096f, LBC::nu}, {0x0970, 0x0980, LBC::al}, {0x0981, 0x0983, LBC::cm}, {0x0985, 0x098c, LBC::al},
	{0x098f, 0x0990, LBC::al}, {0x0993, 0x09a8, LBC::al}, {0x09aa, 0x09b0, LBC::al}, {0x09b2, 0x09b2, LBC::al},
	{0x09b6, 0x09b9, LBC::al}, {0x09bc, 0x09bc, LBC::cm}, {0x09bd, 0x09bd, LBC::al}, {0x09be, 0x09c4, LBC::cm},
	{0x09c7, 0x09c8, LBC::cm}, {0x09cb, 0x09cd, LBC::cm}, {0x09ce, 0x09ce, LBC::al}, {0x09d7, 0x09d7, LBC::cm},
	{0x09dc, 0x09dd, LBC::al}, {0x09df, 0x09e1, LBC::al}, {0x09e2, 0x09e3, LBC::cm}, {0x09e6, 0x09ef, LBC::nu},
	{0x09f0, 0x09f1, LBC::al}, {0x09f2, 0x09f3, LBC::po}, {0x09f4, 0x09f8, LBC::al}, {0x09f9, 0x09f9, LBC::po},
	{0x09fa, 0x09fa, LBC::al}, {0x09fb, 0x09fb, LBC::pr}, {0x09fc, 0x09fd, LBC::al}, {0x09fe, 0x09fe, LBC::cm},
	{0x0a01, 0x0a03, LBC::cm}, {0x0a05, 0x0a0a, LBC::al}, {0x0a0f, 0x0a10, LBC::al}, {0x0a13, 0x0a28, LBC::al},
	{0x0a2a, 0x0a30, LBC::al}, {0x0a32, 0x0a33, LBC::al}, {0x0a35, 0x0a36, LBC::al}, {0x0a38, 0x0a39, LBC::al},
	{0x0a3c, 0x0a3c, LBC::cm}, {0x0a3e, 0x0a42, LBC::cm}, {0x0a47, 0x0a48, LBC::cm}, {0x0a4b, 0x0a4d, LBC::cm},
	{0x0a51, 0x0a51, LBC::cm}, {0x0a59, 0x0a5c, LBC::al}, {0x0a5e, 0x0a5e, LBC::al}, {0x0a66, 0x0a6f, LBC::nu},
	{0x0a70, 0x0a71, LBC::cm}, {0x0a72, 0x0a74, LBC::al}, {0x0a75, 0x0a75, LBC::cm}, {0x0a76, 0x0a76, LBC::al},
	{0x0a81, 0x0a83, LBC::cm}, {0x0a85, 0x0a8d, LBC::al}, {0x0a8f, 0x0a91, LBC::al}, {0x0a93, 0x0aa8, LBC::al},
	{0x0aaa, 0x0ab0, LBC::al}, {0x0ab2, 0x0ab3, LBC::al}, {0x0ab5, 0x0ab9, LBC::al}, {0x0abc, 0x0abc, LBC::cm},
	{0x0abd, 0x0abd, LBC::al}, {0x0abe, 0x0ac5, LBC::cm}, {0x0ac7, 0x0ac9, LBC::cm}, {0x0acb, 0x0acd, LBC::cm},
	{0x0ad0, 0x0ad0, LBC::al}, {0x0ae0, 0x0ae1, LBC::al}, {0x0ae2, 0x0ae3, LBC::cm}, {0x0ae6, 0x0aef, LBC::nu},
	{0x0af0, 0x0af0, LBC::al}, {0x0af1, 0x0af1, LBC::pr}, {0x0af9, 0x0af9, LBC::al}, {0x0afa, 0x0aff, LBC::cm},
	{0x0b01, 0x0b03, LBC::cm}, {0x0b05, 0x0b0c, LBC::al}, {0x0b0f, 0x0b10, LBC::al}, {0x0b13, 0x0b28, LBC::al},
	{0x0b2a, 0x0b30, LBC::al}, {0x0b32, 0x0b33, LBC::al}, {0x0b35, 0x0b39, LBC::al}, {0x0b3c, 0x0b3c, LBC::cm},
	{0x0b3d, 0x0b3d, LBC::al}, {0x0b3e, 0x0b44, LBC::cm}, {0x0b47, 0x0b48, LBC::cm}, {0x0b4b, 0x0b4d, LBC::cm},
	{0x0b55, 0x0b57, LBC::cm}, {0x0b5c, 0x0b5d, LBC::al}, {0x0b5f, 0x0b61, LBC::al}, {0x0b62, 0x0b63, LBC::cm},
	{0x0b66, 0x0b6f, LBC::nu}, {0x0b70, 0x0b77, LBC::al}, {0x0b82, 0x0b82, LBC::cm}, {0x0b83, 0x0b83, LBC::al},
	{0x0b85, 0x0b8a, LBC::al}, {0x0b8e, 0x0b90, LBC::al}, {0x0b92, 0x0b95, LBC::al}, {0x0b99, 0x0b9a, LBC::al},
	{0x0b9c, 0x0b9c, LBC::al}, {0x0b9e, 0x0b9f, LBC::al}, {0x0ba3, 0x0ba4, LBC::al}, {0x0ba8, 0x0baa, LBC::al},
	{0x0bae, 0x0bb9, LBC::al}, {0x0bbe, 0x0bc2, LBC::cm}, {0x0bc6, 0x0bc8, LBC::cm}, {0x0bca, 0x0bcd, LBC::cm},
	{0x0bd0, 0x0bd0, LBC::al}, {0x0bd7, 0x0bd7, LBC::cm}, {0x0be6, 0x0bef, LBC::nu}, {0x0bf0, 0x0bf8, LBC::al},
	{0x0bf9, 0x0bf9, LBC::pr}, {0x0bfa, 0x0bfa, LBC::al}, {0x0c00, 0x0c04, LBC::cm}, {0x0c05, 0x0c0c, LBC::al},
	{0x0c0e, 0x0c10, LBC::al}, {0x0c12, 0x0c28, LBC::al}, {0x0c2a, 0x0c39, LBC::al}, {0x0c3c, 0x0c3c, LBC::cm},
	{0x0c3d, 0x0c3d, LBC::al}, {0x0c3e, 0x0c44, LBC::cm}, {0x0c46, 0x0c48, LBC::cm}, {0x0c4a, 0x0c4d, LBC::cm},
	{0x0c55, 0x0c56, LBC::cm}, {0x0c58, 0x0c5a, LBC::al}, {0x0c5c, 0x0c5d, LBC::al}, {0x0c60, 0x0c61, LBC::al},
	{0x0c62, 0x0c63, LBC::cm}, {0x0c66, 0x0c6f, LBC::nu}, {0x0c77, 0x0c77, LBC::bb}, {0x0c78, 0x0c80, LBC::al},
	{0x0c81, 0x0c83, LBC::cm}, {0x0c84, 0x0c84, LBC::bb}, {0x0c85, 0x0c8c, LBC::al}, {0x0c8e, 0x0c90, LBC::al},
	{0x0c92, 0x0ca8, LBC::al}, {0x0caa, 0x0cb3, LBC::al}, {0x0cb5, 0x0cb9, LBC::al}, {0x0cbc, 0x0cbc, LBC::cm},
	{0x0cbd, 0x0cbd, LBC::al}, {0x0cbe, 0x0cc4, LBC::cm}, {0x0cc6, 0x0cc8, LBC::cm}, {0x0cca, 0x0ccd, LBC::cm},
	{0x0cd5, 0x0cd6, LBC::cm}, {0x0cdc, 0x0cde, LBC::al}, {0x0ce0, 0x0ce1, LBC::al}, {0x0ce2, 0x0ce3, LBC::cm},
	{0x0ce6, 0x0cef, LBC::nu}, {0x0cf1, 0x0cf2, LBC::al}, {0x0cf3, 0x0cf3, LBC::cm}, {0x0d00, 0x0d03, LBC::cm},
	{0x0d04, 0x0d0c, LBC::al}, {0x0d0e, 0x0d10, LBC::al}, {0x0d12, 0x0d3a, LBC::al}, {0x0d3b, 0x0d3c, LBC::cm},
	{0x0d3d, 0x0d3d, LBC::al}, {0x0d3e, 0x0d44, LBC::cm}, {0x0d46, 0x0d48, LBC::cm}, {0x0d4a, 0x0d4d, LBC::cm},
	{0x0d4e, 0x0d4f, LBC::al}, {0x0d54, 0x0d56, LBC::al}, {0x0d57, 0x0d57, LBC::cm}, {0x0d58, 0x0d61, LBC::al},
	{0x0d62, 0x0d63, LBC::cm}, {0x0d66, 0x0d6f, LBC::nu}, {0x0d70, 0x0d78, LBC::al}, {0x0d79, 0x0d79, LBC::po},
	{0x0d7a, 0x0d7f, LBC::al}, {0x0d81, 0x0d83, LBC::cm}, {0x0d85, 0x0d96, LBC::al}, {0x0d9a, 0x0db1, LBC::al},
	{0x0db3, 0x0dbb, LBC::al}, {0x0dbd, 0x0dbd, LBC::al}, {0x0dc0, 0x0dc6, LBC::al}, {0x0dca, 0x0dca, LBC::cm},
	{0x0dcf, 0x0dd4, LBC::cm}, {0x0dd6, 0x0dd6, LBC::cm}, {0x0dd8, 0x0ddf, LBC::cm}, {0x0de6, 0x0def, LBC::nu},
	{0x0df2, 0x0df3, LBC::cm}, {0x0df4, 0x0df4, LBC::al}, {0x0e01, 0x0e3a, LBC::sa}, {0x0e3f, 0x0e3f, LBC::pr},
	{0x0e40, 0x0e4e, LBC::sa}, {0x0e4f, 0x0e4f, LBC::al}, {0x0e50, 0x0e59, LBC::nu}, {0x0e5a, 0x0e5b, LBC::ba},
	{0x0e81, 0x0e82, LBC::sa}, {0x0e84, 0x0e84, LBC::sa}, {0x0e86, 0x0e8a, LBC::sa}, {0x0e8c, 0x0ea3, LBC::sa},
	{0x0ea5, 0x0ea5, LBC::sa}, {0x0ea7, 0x0ebd, LBC::sa}, {0x0ec0, 0x0ec4, LBC::sa}, {0x0ec6, 0x0ec6, LBC::sa},
	{0x0ec8, 0x0ece, LBC::sa}, {0x0ed0, 0x0ed9, LBC::nu}, {0x0edc, 0x0edf, LBC::sa}, {0x0f00, 0x0f00, LBC::al},
	{0x0f01, 0x0f04, LBC::bb}, {0x0f05, 0x0f05, LBC::al}, {0x0f06, 0x0f07, LBC::bb}, {0x0f08, 0x0f08, LBC::gl},
	{0x0f09, 0x0f0a, LBC::bb}, {0x0f0b, 0x0f0b, LBC::ba}, {0x0f0c, 0x0f0c, LBC::gl}, {0x0f0d, 0x0f11, LBC::ex},
	{0x0f12, 0x0f12, LBC::gl}, {0x0f13, 0x0f13, LBC::al}, {0x0f14, 0x0f14, LBC::ex}, {0x0f15, 0x0f17, LBC::al},
	{0x0f18, 0x0f19, LBC::cm}, {0x0f1a, 0x0f1f, LBC::al}, {0x0f20, 0x0f29, LBC::nu}, {0x0f2a, 0x0f33, LBC::al},
	{0x0f34, 0x0f34, LBC::ba}, {0x0f35, 0x0f35, LBC::cm}, {0x0f36, 0x0f36, LBC::al}, {0x0f37, 0x0f37, LBC::cm},
	{0x0f38, 0x0f38, LBC::al}, {0x0f39, 0x0f39, LBC::cm}, {0x0f3a, 0x0f3a, LBC::op}, {0x0f3b, 0x0f3b, LBC::cl},
	{0x0f3c, 0x0f3c, LBC::op}, {0x0f3d, 0x0f3d, LBC::cl}, {0x0f3e, 0x0f3f, LBC::cm}, {0x0f40, 0x0f47, LBC::al},
	{0x0f49, 0x0f6c, LBC::al}, {0x0f71, 0x0f7e, LBC::cm}, {0x0f7f, 0x0f7f, LBC::ba}, {0x0f80, 0x0f84, LBC::cm},
	{0x0f85, 0x0f85, LBC::ba}, {0x0f86, 0x0f87, LBC::cm}, {0x0f88, 0x0f8c, LBC::al}, {0x0f8d, 0x0f97, LBC::cm},
	{0x0f99, 0x0fbc, LBC::cm}, {0x0fbe, 0x0fbf, LBC::ba}, {0x0fc0, 0x0fc5, LBC::al}, {0x0fc6, 0x0fc6, LBC::cm},
	{0x0fc7, 0x0fcc, LBC::al}, {0x0fce, 0x0fcf, LBC::al}, {0x0fd0, 0x0fd1, LBC::bb}, {0x0fd2, 0x0fd2, LBC::ba},
	{0x0fd3, 0x0fd3, LBC::bb}, {0x0fd4, 0x0fd8, LBC::al}, {0x0fd9, 0x0fda, LBC::gl}, {0x1000, 0x103f, LBC::sa},
	{0x1040, 0x1049, LBC::nu}, {0x104a, 0x104b, LBC::ba}, {0x104c, 0x104f, LBC::al}, {0x1050, 0x108f, LBC::sa},
	{0x1090, 0x1099, LBC::nu}, {0x109a, 0x109f, LBC::sa}, {0x10a0, 0x10c5, LBC::al}, {0x10c7, 0x10c7, LBC::al},
	{0x10cd, 0x10cd, LBC::al}, {0x10d0, 0x10ff, LBC::al}, {0x1100, 0x115f, LBC::jl}, {0x1160, 0x11a7, LBC::jv},
	{0x11a8, 0x11ff, LBC::jt}, {0x1200, 0x1248, LBC::al}, {0x124a, 0x124d, LBC::al}, {0x1250, 0x1256, LBC::al},
	{0x1258, 0x1258, LBC::al}, {0x125a, 0x125d, LBC::al}, {0x1260, 0x1288, LBC::al}, {0x128a, 0x128d, LBC::al},
	{0x1290, 0x12b0, LBC::al}, {0x12b2, 0x12b5, LBC::al}, {0x12b8, 0x12be, LBC::al}, {0x12c0, 0x12c0, LBC::al},
	{0x12c2, 0x12c5, LBC::al}, {0x12c8, 0x12d6, LBC::al}, {0x12d8, 0x1310, LBC::al}, {0x1312, 0x1315, LBC::al},
	{0x1318, 0x135a, LBC::al}, {0x135d, 0x135f, LBC::cm}, {0x1360, 0x1360, LBC::al}, {0x1361, 0x1361, LBC::ba},
	{0x1362, 0x137c, LBC::al}, {0x1380, 0x1399, LBC::al}, {0x13a0, 0x13f5, LBC::al}, {0x13f8, 0x13fd, LBC::al},
	{0x1400, 0x1400, LBC::hh}, {0x1401, 0x167f, LBC::al}, {0x1680, 0x1680, LBC::ba}, {0x1681, 0x169a, LBC::al},
	{0x169b, 0x169b, LBC::op}, {0x169c, 0x169c, LBC::cl}, {0x16a0, 0x16ea, LBC::al}, {0x16eb, 0x16ed, LBC::ba},
	{0x16ee, 0x16f8, LBC::al}, {0x1700, 0x1711, LBC::al}, {0x1712, 0x1715, LBC::cm}, {0x171f, 0x1731, LBC::al},
	{0x1732, 0x1734, LBC::cm}, {0x1735, 0x1736, LBC::ba}, {0x1740, 0x1751, LBC::al}, {0x1752, 0x1753, LBC::cm},
	{0x1760, 0x176c, LBC::al}, {0x176e, 0x1770, LBC::al}, {0x1772, 0x1773, LBC::cm}, {0x1780, 0x17d3, LBC::sa},
	{0x17d4, 0x17d5, LBC::ba}, {0x17d6, 0x17d6, LBC::ns}, {0x17d7, 0x17d7, LBC::sa}, {0x17d8, 0x17d8, LBC::ba},
	{0x17d9, 0x17d9, LBC::al}, {0x17da, 0x17da, LBC::ba}, {0x17db, 0x17db, LBC::pr}, {0x17dc, 0x17dd, LBC::sa},
	{0x17e0, 0x17e9, LBC::nu}, {0x17f0, 0x17f9, LBC::al}, {0x1800, 0x1801, LBC::al}, {0x1802, 0x1803, LBC::ex},
	{0x1804, 0x1805, LBC::ba}, {0x1806, 0x1806, LBC::bb}, {0x1807, 0x1807, LBC::al}, {0x1808, 0x1809, LBC::ex},
	{0x180a, 0x180a, LBC::al}, {0x180b, 0x180d, LBC::cm}, {0x180e, 0x180e, LBC::gl}, {0x180f, 0x180f, LBC::cm},
	{0x1810, 0x1819, LBC::nu}, {0x1820, 0x1878, LBC::al}, {0x1880, 0x1884, LBC::al}, {0x1885, 0x1886, LBC::cm},
	{0x1887, 0x18a8, LBC::al}, {0x18a9, 0x18a9, LBC::cm}, {0x18aa, 0x18aa, LBC::al}, {0x18b0, 0x18f5, LBC::al},
	{0x1900, 0x191e, LBC::al}, {0x1920, 0x192b, LBC::cm}, {0x1930, 0x193b, LBC::cm}, {0x1940, 0x1940, LBC::al},
	{0x1944, 0x1945, LBC::ex}, {0x1946, 0x194f, LBC::nu}, {0x1950, 0x196d, LBC::sa}, {0x1970, 0x1974, LBC::sa},
	{0x1980, 0x19ab, LBC::sa}, {0x19b0, 0x19c9, LBC::sa}, {0x19d0, 0x19da, LBC::nu}, {0x19de, 0x19df, LBC::sa},
	{0x19e0, 0x1a16, LBC::al}, {0x1a17, 0x1a1b, LBC::cm}, {0x1a1e, 0x1a1f, LBC::al}, {0x1a20, 0x1a5e, LBC::sa},
	{0x1a60, 0x1a7c, LBC::sa}, {0x1a7f, 0x1a7f, LBC::cm}, {0x1a80, 0x1a89, LBC::nu}, {0x1a90, 0x1a99, LBC::nu},
	{0x1aa0, 0x1aad, LBC::sa}, {0x1ab0, 0x1add, LBC::cm}, {0x1ae0, 0x1aea, LBC::cm}, {0x1aeb, 0x1aeb, LBC::gl},
	{0x1b00, 0x1b04, LBC::cm}, {0x1b05, 0x1b33, LBC::ak}, {0x1b34, 0x1b43, LBC::cm}, {0x1b44, 0x1b44, LBC::vi},
	{0x1b45, 0x1b4c, LBC::ak}, {0x1b4e, 0x1b4f, LBC::ba}, {0x1b50, 0x1b59, LBC::as}, {0x1b5a, 0x1b5b, LBC::ba},
	{0x1b5c, 0x1b5c, LBC::id}, {0x1b5d, 0x1b60, LBC::ba}, {0x1b61, 0x1b6a, LBC::id}, {0x1b6b, 0x1b73, LBC::cm},
	{0x1b74, 0x1b7c, LBC::id}, {0x1b7d, 0x1b7f, LBC::ba}, {0x1b80, 0x1b82, LBC::cm}, {0x1b83, 0x1ba0, LBC::al},
	{0x1ba1, 0x1bad, LBC::cm}, {0x1bae, 0x1baf, LBC::al}, {0x1bb0, 0x1bb9, LBC::nu}, {0x1bba, 0x1bbf, LBC::al},
	{0x1bc0, 0x1be5, LBC::as}, {0x1be6, 0x1bf1, LBC::cm}, {0x1bf2, 0x1bf3, LBC::vf}, {0x1bfc, 0x1c23, LBC::al},
	{0x1c24, 0x1c37, LBC::cm}, {0x1c3b, 0x1c3f, LBC::ba}, {0x1c40, 0x1c49, LBC::nu}, {0x1c4d, 0x1c4f, LBC::al},
	{0x1c50, 0x1c59, LBC::nu}, {0x1c5a, 0x1c7d, LBC::al}, {0x1c7e, 0x1c7f, LBC::ba}, {0x1c80, 0x1c8a, LBC::al},
	{0x1c90, 0x1cba, LBC::al}, {0x1cbd, 0x1cc7, LBC::al}, {0x1cd0, 0x1cd2, LBC::cm}, {0x1cd3, 0x1cd3, LBC::al},
	{0x1cd4, 0x1ce8, LBC::cm}, {0x1ce9, 0x1cec, LBC::al}, {0x1ced, 0x1ced, LBC::cm}, {0x1cee, 0x1cf3, LBC::al},
	{0x1cf4, 0x1cf4, LBC::cm}, {0x1cf5, 0x1cf6, LBC::al}, {0x1cf7, 0x1cf9, LBC::cm}, {0x1cfa, 0x1cfa, LBC::al},
	{0x1d00, 0x1dbf, LBC::al}, {0x1dc0, 0x1dcc, LBC::cm}, {0x1dcd, 0x1dcd, LBC::gl}, {0x1dce, 0x1dfb, LBC::cm},
	{0x1dfc, 0x1dfc, LBC::gl}, {0x1dfd, 0x1dff, LBC::cm}, {0x1e00, 0x1f15, LBC::al}, {0x1f18, 0x1f1d, LBC::al},
	{0x1f20, 0x1f45, LBC::al}, {0x1f48, 0x1f4d, LBC::al}, {0x1f50, 0x1f57, LBC::al}, {0x1f59, 0x1f59, LBC::al},
	{0x1f5b, 0x1f5b, LBC::al}, {0x1f5d, 0x1f5d, LBC::al}, {0x1f5f, 0x1f7d, LBC::al}, {0x1f80, 0x1fb4, LBC::al},
	{0x1fb6, 0x1fc4, LBC::al}, {0x1fc6, 0x1fd3, LBC::al}, {0x1fd6, 0x1fdb, LBC::al}, {0x1fdd, 0x1fef, LBC::al},
	{0x1ff2, 0x1ff4, LBC::al}, {0x1ff6, 0x1ffc, LBC::al}, {0x1ffd, 0x1ffd, LBC::bb}, {0x1ffe, 0x1ffe, LBC::al},
	{0x2000, 0x2006, LBC::ba}, {0x2007, 0x2007, LBC::gl}, {0x2008, 0x200a, LBC::ba}, {0x200b, 0x200b, LBC::zw},
	{0x200c, 0x200c, LBC::cm}, {0x200d, 0x200d, LBC::zwj}, {0x200e, 0x200f, LBC::cm}, {0x2010, 0x2010, LBC::hh},
	{0x2011, 0x2011, LBC::gl}, {0x2012, 0x2013, LBC::hh}, {0x2014, 0x2014, LBC::b2}, {0x2015, 0x2016, LBC::ai},
	{0x2017, 0x2017, LBC::al}, {0x2018, 0x2019, LBC::qu}, {0x201a, 0x201a, LBC::op}, {0x201b, 0x201d, LBC::qu},
	{0x201e, 0x201e, LBC::op}, {0x201f, 0x201f, LBC::qu}, {0x2020, 0x2021, LBC::ai}, {0x2022, 0x2023, LBC::al},
	{0x2024, 0x2026, LBC::in}, {0x2027, 0x2027, LBC::ba}, {0x2028, 0x2029, LBC::bk}, {0x202a, 0x202e, LBC::cm},
	{0x202f, 0x202f, LBC::gl}, {0x2030, 0x2037, LBC::po}, {0x2038, 0x2038, LBC::al}, {0x2039, 0x203a, LBC::qu},
	{0x203b, 0x203b, LBC::ai}, {0x203c, 0x203d, LBC::ns}, {0x203e, 0x2043, LBC::al}, {0x2044, 0x2044, LBC::is},
	{0x2045, 0x2045, LBC::op}, {0x2046, 0x2046, LBC::cl}, {0x2047, 0x2049, LBC::ns}, {0x204a, 0x2055, LBC::al},
	{0x2056, 0x2056, LBC::ba}, {0x2057, 0x2057, LBC::po}, {0x2058, 0x205b, LBC::ba}, {0x205c, 0x205c, LBC::al},
	{0x205d, 0x205f, LBC::ba}, {0x2060, 0x2060, LBC::wj}, {0x2061, 0x2064, LBC::al}, {0x2066, 0x206f, LBC::cm},
	{0x2070, 0x2071, LBC::al}, {0x2074, 0x2074, LBC::ai}, {0x2075, 0x207c, LBC::al}, {0x207d, 0x207d, LBC::op},
	{0x207e, 0x207e, LBC::cl}, {0x207f, 0x207f, LBC::ai}, {0x2080, 0x2080, LBC::al}, {0x2081, 0x2084, LBC::ai},
	{0x2085, 0x208c, LBC::al}, {0x208d, 0x208d, LBC::op}, {0x208e, 0x208e, LBC::cl}, {0x2090, 0x209c, LBC::al},
	{0x20a0, 0x20a6, LBC::pr}, {0x20a7, 0x20a7, LBC::po}, {0x20a8, 0x20b5, LBC::pr}, {0x20b6, 0x20b6, LBC::po},
	{0x20b7, 0x20ba, LBC::pr}, {0x20bb, 0x20bb, LBC::po}, {0x20bc, 0x20bd, LBC::pr}, {0x20be, 0x20be, LBC::po},
	{0x20bf, 0x20bf, LBC::pr}, {0x20c0, 0x20c0, LBC::po}, {0x20c1, 0x20cf, LBC::pr}, {0x20d0, 0x20f0, LBC::cm},
	{0x2100, 0x2102, LBC::al}, {0x2103, 0x2103, LBC::po}, {0x2104, 0x2104, LBC::al}, {0x2105, 0x2105, LBC::ai},
	{0x2106, 0x2108, LBC::al}, {0x2109, 0x2109, LBC::po}, {0x210a, 0x2112, LBC::al}, {0x2113, 0x2113, LBC::ai},
	{0x2114, 0x2115, LBC::al}, {0x2116, 0x2116, LBC::pr}, {0x2117, 0x2120, LBC::al}, {0x2121, 0x2122, LBC::ai},
	{0x2123, 0x212a, LBC::al}, {0x212b, 0x212b, LBC::ai}, {0x212c, 0x214f, LBC::al}, {0x2150, 0x215e, LBC::ai},
	{0x215f, 0x215f, LBC::al}, {0x2160, 0x216b, LBC::ai}, {0x216c, 0x216f, LBC::al}, {0x2170, 0x2179, LBC::ai},
	{0x217a, 0x2188, LBC::al}, {0x2189, 0x2189, LBC::ai}, {0x218a, 0x218b, LBC::al}, {0x2190, 0x2199, LBC::ai},
	{0x219a, 0x21d1, LBC::al}, {0x21d2, 0x21d2, LBC::ai}, {0x21d3, 0x21d3, LBC::al}, {0x21d4, 0x21d4, LBC::ai},
	{0x21d5, 0x21ff, LBC::al}, {0x2200, 0x2200, LBC::ai}, {0x2201, 0x2201, LBC::al}, {0x2202, 0x2203, LBC::ai},
	{0x2204, 0x2206, LBC::al}, {0x2207, 0x2208, LBC::ai}, {0x2209, 0x220a, LBC::al}, {0x220b, 0x220b, LBC::ai},
	{0x220c, 0x220e, LBC::al}, {0x220f, 0x220f, LBC::ai}, {0x2210, 0x2210, LBC::al}, {0x2211, 0x2211, LBC::ai},
	{0x2212, 0x2213, LBC::pr}, {0x2214, 0x2214, LBC::al}, {0x2215, 0x2215, LBC::ai}, {0x2216, 0x2219, LBC::al},
	{0x221a, 0x221a, LBC::ai}, {0x221b, 0x221c, LBC::al}, {0x221d, 0x2220, LBC::ai}, {0x2221, 0x2222, LBC::al},
	{0x2223, 0x2223, LBC::ai}, {0x2224, 0x2224, LBC::al}, {0x2225, 0x2225, LBC::ai}, {0x2226, 0x2226, LBC::al},
	{0x2227, 0x222c, LBC::ai}, {0x222d, 0x222d, LBC::al}, {0x222e, 0x222e, LBC::ai}, {0x222f, 0x2233, LBC::al},
	{0x2234, 0x2237, LBC::ai}, {0x2238, 0x223b, LBC::al}, {0x223c, 0x223d, LBC::ai}, {0x223e, 0x2247, LBC::al},
	{0x2248, 0x2248, LBC::ai}, {0x2249, 0x224b, LBC::al}, {0x224c, 0x224c, LBC::ai}, {0x224d, 0x2251, LBC::al},
	{0x2252, 0x2252, LBC::ai}, {0x2253, 0x225f, LBC::al}, {0x2260, 0x2261, LBC::ai}, {0x2262, 0x2263, LBC::al},
	{0x2264, 0x2267, LBC::ai}, {0x2268, 0x2269, LBC::al}, {0x226a, 0x226b, LBC::ai}, {0x226c, 0x226d, LBC::al},
	{0x226e, 0x226f, LBC::ai}, {0x2270, 0x2281, LBC::al}, {0x2282, 0x2283, LBC::ai}, {0x2284, 0x2285, LBC::al},
	{0x2286, 0x2287, LBC::ai}, {0x2288, 0x2294, LBC::al}, {0x2295, 0x2295, LBC::ai}, {0x2296, 0x2298, LBC::al},
	{0x2299, 0x2299, LBC::ai}, {0x229a, 0x22a4, LBC::al}, {0x22a5, 0x22a5, LBC::ai}, {0x22a6, 0x22be, LBC::al},
	{0x22bf, 0x22bf, LBC::ai}, {0x22c0, 0x22ee, LBC::al}, {0x22ef, 0x22ef, LBC::in}, {0x22f0, 0x2307, LBC::al},
	{0x2308, 0x2308, LBC::op}, {0x2309, 0x2309, LBC::cl}, {0x230a, 0x230a, LBC::op}, {0x230b, 0x230b, LBC::cl},
	{0x230c, 0x2311, LBC::al}, {0x2312, 0x2312, LBC::ai}, {0x2313, 0x2319, LBC::al}, {0x231a, 0x231b, LBC::id},
	{0x231c, 0x2328, LBC::al}, {0x2329, 0x2329, LBC::op}, {0x232a, 0x232a, LBC::cl}, {0x232b, 0x23ef, LBC::al},
	{0x23f0, 0x23f3, LBC::id}, {0x23f4, 0x2429, LBC::al}, {0x2440, 0x244a, LBC::al}, {0x2460, 0x24fe, LBC::ai},
	{0x24ff, 0x24ff, LBC::al}, {0x2500, 0x254b, LBC::ai}, {0x254c, 0x254f, LBC::al}, {0x2550, 0x2574, LBC::ai},
	{0x2575, 0x257f, LBC::al}, {0x2580, 0x258f, LBC::ai}, {0x2590, 0x2591, LBC::al}, {0x2592, 0x2595, LBC::ai},
	{0x2596, 0x259f, LBC::al}, {0x25a0, 0x25a1, LBC::ai}, {0x25a2, 0x25a2, LBC::al}, {0x25a3, 0x25a9, LBC::ai},
	{0x25aa, 0x25b1, LBC::al}, {0x25b2, 0x25b3, LBC::ai}, {0x25b4, 0x25b5, LBC::al}, {0x25b6, 0x25b7, LBC::ai},
	{0x25b8, 0x25bb, LBC::al}, {0x25bc, 0x25bd, LBC::ai}, {0x25be, 0x25bf, LBC::al}, {0x25c0, 0x25c1, LBC::ai},
	{0x25c2, 0x25c5, LBC::al}, {0x25c6, 0x25c8, LBC::ai}, {0x25c9, 0x25ca, LBC::al}, {0x25cb, 0x25cb, LBC::ai},
	{0x25cc, 0x25cd, LBC::al}, {0x25ce, 0x25d1, LBC::ai}, {0x25d2, 0x25e1, LBC::al}, {0x25e2, 0x25e5, LBC::ai},
	{0x25e6, 0x25ee, LBC::al}, {0x25ef, 0x25ef, LBC::ai}, {0x25f0, 0x25ff, LBC::al}, {0x2600, 0x2603, LBC::id},
	{0x2604, 0x2604, LBC::al}, {0x2605, 0x2606, LBC::ai}, {0x2607, 0x2608, LBC::al}, {0x2609, 0x2609, LBC::ai},
	{0x260a, 0x260d, LBC::al}, {0x260e, 0x260f, LBC::ai}, {0x2610, 0x2613, LBC::al}, {0x2614, 0x2615, LBC::id},
	{0x2616, 0x2617, LBC::ai}, {0x2618, 0x2618, LBC::id}, {0x2619, 0x2619, LBC::al}, {0x261a, 0x261c, LBC::id},
	{0x261d, 0x261d, LBC::eb}, {0x261e, 0x261f, LBC::id}, {0x2620, 0x2638, LBC::al}, {0x2639, 0x263b, LBC::id},
	{0x263c, 0x263f, LBC::al}, {0x2640, 0x2640, LBC::ai}, {0x2641, 0x2641, LBC::al}, {0x2642, 0x2642, LBC::ai},
	{0x2643, 0x265f, LBC::al}, {0x2660, 0x2661, LBC::ai}, {0x2662, 0x2662, LBC::al}, {0x2663, 0x2665, LBC::ai},
	{0x2666, 0x2666, LBC::al}, {0x2667, 0x2667, LBC::ai}, {0x2668, 0x2668, LBC::id}, {0x2669, 0x266a, LBC::ai},
	{0x266b, 0x266b, LBC::al}, {0x266c, 0x266d, LBC::ai}, {0x266e, 0x266e, LBC::al}, {0x266f, 0x266f, LBC::ai},
	{0x2670, 0x267e, LBC::al}, {0x267f, 0x267f, LBC::id}, {0x2680, 0x269d, LBC::al}, {0x269e, 0x269f, LBC::ai},
	{0x26a0, 0x26bc, LBC::al}, {0x26bd, 0x26c8, LBC::id}, {0x26c9, 0x26cc, LBC::ai}, {0x26cd, 0x26cd, LBC::id},
	{0x26ce, 0x26ce, LBC::al}, {0x26cf, 0x26d1, LBC::id}, {0x26d2, 0x26d2, LBC::ai}, {0x26d3, 0x26d4, LBC::id},
	{0x26d5, 0x26d7, LBC::ai}, {0x26d8, 0x26d9, LBC::id}, {0x26da, 0x26db, LBC::ai}, {0x26dc, 0x26dc, LBC::id},
	{0x26dd, 0x26de, LBC::ai}, {0x26df, 0x26e1, LBC::id}, {0x26e2, 0x26e2, LBC::al}, {0x26e3, 0x26e3, LBC::ai},
	{0x26e4, 0x26e7, LBC::al}, {0x26e8, 0x26e9, LBC::ai}, {0x26ea, 0x26ea, LBC::id}, {0x26eb, 0x26f0, LBC::ai},
	{0x26f1, 0x26f5, LBC::id}, {0x26f6, 0x26f6, LBC::ai}, {0x26f7, 0x26f8, LBC::id}, {0x26f9, 0x26f9, LBC::eb},
	{0x26fa, 0x26fa, LBC::id}, {0x26fb, 0x26fc, LBC::ai}, {0x26fd, 0x2704, LBC::id}, {0x2705, 0x2707, LBC::al},
	{0x2708, 0x2709, LBC::id}, {0x270a, 0x270d, LBC::eb}, {0x270e, 0x2756, LBC::al}, {0x2757, 0x2757, LBC::ai},
	{0x2758, 0x275a, LBC::al}, {0x275b, 0x2760, LBC::qu}, {0x2761, 0x2761, LBC::al}, {0x2762, 0x2763, LBC::ex},
	{0x2764, 0x2764, LBC::id}, {0x2765, 0x2767, LBC::al}, {0x2768, 0x2768, LBC::op}, {0x2769, 0x2769, LBC::cl},
	{0x276a, 0x276a, LBC::op}, {0x276b, 0x276b, LBC::cl}, {0x276c, 0x276c, LBC::op}, {0x276d, 0x276d, LBC::cl},
	{0x276e, 0x276e, LBC::op}, {0x276f, 0x276f, LBC::cl}, {0x2770, 0x2770, LBC::op}, {0x2771, 0x2771, LBC::cl},
	{0x2772, 0x2772, LBC::op}, {0x2773, 0x2773, LBC::cl}, {0x2774, 0x2774, LBC::op}, {0x2775, 0x2775, LBC::cl},
	{0x2776, 0x2793, LBC::ai}, {0x2794, 0x27c4, LBC::al}, {0x27c5, 0x27c5, LBC::op}, {0x27c6, 0x27c6, LBC::cl},
	{0x27c7, 0x27e5, LBC::al}, {0x27e6, 0x27e6, LBC::op}, {0x27e7, 0x27e7, LBC::cl}, {0x27e8, 0x27e8, LBC::op},
	{0x27e9, 0x27e9, LBC::cl}, {0x27ea, 0x27ea, LBC::op}, {0x27eb, 0x27eb, LBC::cl}, {0x27ec, 0x27ec, LBC::op},
	{0x27ed, 0x27ed, LBC::cl}, {0x27ee, 0x27ee, LBC::op}, {0x27ef, 0x27ef, LBC::cl}, {0x27f0, 0x27ff, LBC::al},
	{0x2800, 0x2800, LBC::ba}, {0x2801, 0x2982, LBC::al}, {0x2983, 0x2983, LBC::op}, {0x2984, 0x2984, LBC::cl},
	{0x2985, 0x2985, LBC::op}, {0x2986, 0x2986, LBC::cl}, {0x2987, 0x2987, LBC::op}, {0x2988, 0x2988, LBC::cl},
	{0x2989, 0x2989, LBC::op}, {0x298a, 0x298a, LBC::cl}, {0x298b, 0x298b, LBC::op}, {0x298c, 0x298c, LBC::cl},
	{0x298d, 0x298d, LBC::op}, {0x298e, 0x298e, LBC::cl}, {0x298f, 0x298f, LBC::op}, {0x2990, 0x2990, LBC::cl},
	{0x2991, 0x2991, LBC::op}, {0x2992, 0x2992, LBC::cl}, {0x2993, 0x2993, LBC::op}, {0x2994, 0x2994, LBC::cl},
	{0x2995, 0x2995, LBC::op}, {0x2996, 0x2996, LBC::cl}, {0x2997, 0x2997, LBC::op}, {0x2998, 0x2998, LBC::cl},
	{0x2999, 0x29d7, LBC::al}, {0x29d8, 0x29d8, LBC::op}, {0x29d9, 0x29d9, LBC::cl}, {0x29da, 0x29da, LBC::op},
	{0x29db, 0x29db, LBC::cl}, {0x29dc, 0x29fb, LBC::al}, {0x29fc, 0x29fc, LBC::op}, {0x29fd, 0x29fd, LBC::cl},
	{0x29fe, 0x2b54, LBC::al}, {0x2b55, 0x2b59, LBC::ai}, {0x2b5a, 0x2b73, LBC::al}, {0x2b76, 0x2cee, LBC::al},
	{0x2cef, 0x2cf1, LBC::cm}, {0x2cf2, 0x2cf3, LBC::al}, {0x2cf9, 0x2cf9, LBC::ex}, {0x2cfa, 0x2cfc, LBC::ba},
	{0x2cfd, 0x2cfd, LBC::al}, {0x2cfe, 0x2cfe, LBC::ex}, {0x2cff, 0x2cff, LBC::ba}, {0x2d00, 0x2d25, LBC::al},
	{0x2d27, 0x2d27, LBC::al}, {0x2d2d, 0x2d2d, LBC::al}, {0x2d30, 0x2d67, LBC::al}, {0x2d6f, 0x2d6f, LBC::al},
	{0x2d70, 0x2d70, LBC::ba}, {0x2d7f, 0x2d7f, LBC::cm}, {0x2d80, 0x2d96, LBC::al}, {0x2da0, 0x2da6, LBC::al},
	{0x2da8, 0x2dae, LBC::al}, {0x2db0, 0x2db6, LBC::al}, {0x2db8, 0x2dbe, LBC::al}, {0x2dc0, 0x2dc6, LBC::al},
	{0x2dc8, 0x2dce, LBC::al}, {0x2dd0, 0x2dd6, LBC::al}, {0x2dd8, 0x2dde, LBC::al}, {0x2de0, 0x2dff, LBC::cm},
	{0x2e00, 0x2e0d, LBC::qu}, {0x2e0e, 0x2e15, LBC::ba}, {0x2e16, 0x2e16, LBC::al}, {0x2e17, 0x2e17, LBC::hh},
	{0x2e18, 0x2e18, LBC::op}, {0x2e19, 0x2e19, LBC::ba}, {0x2e1a, 0x2e1b, LBC::al}, {0x2e1c, 0x2e1d, LBC::qu},
	{0x2e1e, 0x2e1f, LBC::al}, {0x2e20, 0x2e21, LBC::qu}, {0x2e22, 0x2e22, LBC::op}, {0x2e23, 0x2e23, LBC::cl},
	{0x2e24, 0x2e24, LBC::op}, {0x2e25, 0x2e25, LBC::cl}, {0x2e26, 0x2e26, LBC::op}, {0x2e27, 0x2e27, LBC::cl},
	{0x2e28, 0x2e28, LBC::op}, {0x2e29, 0x2e29, LBC::cl}, {0x2e2a, 0x2e2d, LBC::ba}, {0x2e2e, 0x2e2e, LBC::ex},
	{0x2e2f, 0x2e2f, LBC::al}, {0x2e30, 0x2e31, LBC::ba}, {0x2e32, 0x2e32, LBC::al}, {0x2e33, 0x2e34, LBC::ba},
	{0x2e35, 0x2e39, LBC::al}, {0x2e3a, 0x2e3b, LBC::b2}, {0x2e3c, 0x2e3e, LBC::ba}, {0x2e3f, 0x2e3f, LBC::al},
	{0x2e40, 0x2e40, LBC::hh}, {0x2e41, 0x2e41, LBC::ba}, {0x2e42, 0x2e42, LBC::op}, {0x2e43, 0x2e4a, LBC::ba},
	{0x2e4b, 0x2e4b, LBC::al}, {0x2e4c, 0x2e4c, LBC::ba}, {0x2e4d, 0x2e4d, LBC::al}, {0x2e4e, 0x2e4f, LBC::ba},
	{0x2e50, 0x2e52, LBC::al}, {0x2e53, 0x2e54, LBC::ex}, {0x2e55, 0x2e55, LBC::op}, {0x2e56, 0x2e56, LBC::cp},
	{0x2e57, 0x2e57, LBC::op}, {0x2e58, 0x2e58, LBC::cp}, {0x2e59, 0x2e59, LBC::op}, {0x2e5a, 0x2e5a, LBC::cp},
	{0x2e5b, 0x2e5b, LBC::op}, {0x2e5c, 0x2e5c, LBC::cp}, {0x2e5d, 0x2e5d, LBC::hh}, {0x2e80, 0x2e99, LBC::id},
	{0x2e9b, 0x2ef3, LBC::id}, {0x2f00, 0x2fd5, LBC::id}, {0x2ff0, 0x2fff, LBC::id}, {0x3000, 0x3000, LBC::ba},
	{0x3001, 0x3002, LBC::cl}, {0x3003, 0x3004, LBC::id}, {0x3005, 0x3005, LBC::ns}, {0x3006, 0x3007, LBC::id},
	{0x3008, 0x3008, LBC::op}, {0x3009, 0x3009, LBC::cl}, {0x300a, 0x300a, LBC::op}, {0x300b, 0x300b, LBC::cl},
	{0x300c, 0x300c, LBC::op}, {0x300d, 0x300d, LBC::cl}, {0x300e, 0x300e, LBC::op}, {0x300f, 0x300f, LBC::cl},
	{0x3010, 0x3010, LBC::op}, {0x3011, 0x3011, LBC::cl}, {0x3012, 0x3013, LBC::id}, {0x3014, 0x3014, LBC::op},
	{0x3015, 0x3015, LBC::cl}, {0x3016, 0x3016, LBC::op}, {0x3017, 0x3017, LBC::cl}, {0x3018, 0x3018, LBC::op},
	{0x3019, 0x3019, LBC::cl}, {0x301a, 0x301a, LBC::op}, {0x301b, 0x301b, LBC::cl}, {0x301c, 0x301c, LBC::ns},
	{0x301d, 0x301d, LBC::op}, {0x301e, 0x301f, LBC::cl}, {0x3020, 0x3029, LBC::id}, {0x302a, 0x302f, LBC::cm},
	{0x3030, 0x3034, LBC::id}, {0x3035, 0x3035, LBC::cm}, {0x3036, 0x303a, LBC::id}, {0x303b, 0x303c, LBC::ns},
	{0x303d, 0x303f, LBC::id}, {0x3041, 0x3041, LBC::cj}, {0x3042, 0x3042, LBC::id}, {0x3043, 0x3043, LBC::cj},
	{0x3044, 0x3044, LBC::id}, {0x3045, 0x3045, LBC::cj}, {0x3046, 0x3046, LBC::id}, {0x3047, 0x3047, LBC::cj},
	{0x3048, 0x3048, LBC::id}, {0x3049, 0x3049, LBC::cj}, {0x304a, 0x3062, LBC::id}, {0x3063, 0x3063, LBC::cj},
	{0x3064, 0x3082, LBC::id}, {0x3083, 0x3083, LBC::cj}, {0x3084, 0x3084, LBC::id}, {0x3085, 0x3085, LBC::cj},
	{0x3086, 0x3086, LBC::id}, {0x3087, 0x3087, LBC::cj}, {0x3088, 0x308d, LBC::id}, {0x308e, 0x308e, LBC::cj},
	{0x308f, 0x3094, LBC::id}, {0x3095, 0x3096, LBC::cj}, {0x3099, 0x309a, LBC::cm}, {0x309b, 0x309e, LBC::ns},
	{0x309f, 0x309f, LBC::id}, {0x30a0, 0x30a0, LBC::ns}, {0x30a1, 0x30a1, LBC::cj}, {0x30a2, 0x30a2, LBC::id},
	{0x30a3, 0x30a3, LBC::cj}, {0x30a4, 0x30a4, LBC::id}, {0x30a5, 0x30a5, LBC::cj}, {0x30a6, 0x30a6, LBC::id},
	{0x30a7, 0x30a7, LBC::cj}, {0x30a8, 0x30a8, LBC::id}, {0x30a9, 0x30a9, LBC::cj}, {0x30aa, 0x30c2, LBC::id},
	{0x30c3, 0x30c3, LBC::cj}, {0x30c4, 0x30e2, LBC::id}, {0x30e3, 0x30e3, LBC::cj}, {0x30e4, 0x30e4, LBC::id},
	{0x30e5, 0x30e5, LBC::cj}, {0x30e6, 0x30e6, LBC::id}, {0x30e7, 0x30e7, LBC::cj}, {0x30e8, 0x30ed, LBC::id},
	{0x30ee, 0x30ee, LBC::cj}, {0x30ef, 0x30f4, LBC::id}, {0x30f5, 0x30f6, LBC::cj}, {0x30f7, 0x30fa, LBC::id},
	{0x30fb, 0x30fb, LBC::ns}, {0x30fc, 0x30fc, LBC::cj}, {0x30fd, 0x30fe, LBC::ns}, {0x30ff, 0x30ff, LBC::id},
	{0x3105, 0x312f, LBC::id}, {0x3131, 0x318e, LBC::id}, {0x3190, 0x31e5, LBC::id}, {0x31ef, 0x31ef, LBC::id},
	{0x31f0, 0x31ff, LBC::cj}, {0x3200, 0x321e, LBC::id}, {0x3220, 0x3247, LBC::id}, {0x3248, 0x324f, LBC::ai},
	{0x3250, 0x4dbf, LBC::id}, {0x4dc0, 0x4dff, LBC::al}, {0x4e00, 0xa014, LBC::id}, {0xa015, 0xa015, LBC::ns},
	{0xa016, 0xa48c, LBC::id}, {0xa490, 0xa4c6, LBC::id}, {0xa4d0, 0xa4fd, LBC::al}, {0xa4fe, 0xa4ff, LBC::ba},
	{0xa500, 0xa60c, LBC::al}, {0xa60d, 0xa60d, LBC::ba}, {0xa60e, 0xa60e, LBC::ex}, {0xa60f, 0xa60f, LBC::ba},
	{0xa610, 0xa61f, LBC::al}, {0xa620, 0xa629, LBC::nu}, {0xa62a, 0xa62b, LBC::al}, {0xa640, 0xa66e, LBC::al},
	{0xa66f, 0xa672, LBC::cm}, {0xa673, 0xa673, LBC::al}, {0xa674, 0xa67d, LBC::cm}, {0xa67e, 0xa69d, LBC::al},
	{0xa69e, 0xa69f, LBC::cm}, {0xa6a0, 0xa6ef, LBC::al}, {0xa6f0, 0xa6f1, LBC::cm}, {0xa6f2, 0xa6f2, LBC::al},
	{0xa6f3, 0xa6f7, LBC::ba}, {0xa700, 0xa7dc, LBC::al}, {0xa7f1, 0xa801, LBC::al}, {0xa802, 0xa802, LBC::cm},
	{0xa803, 0xa805, LBC::al}, {0xa806, 0xa806, LBC::cm}, {0xa807, 0xa80a, LBC::al}, {0xa80b, 0xa80b, LBC::cm},
	{0xa80c, 0xa822, LBC::al}, {0xa823, 0xa827, LBC::cm}, {0xa828, 0xa82b, LBC::al}, {0xa82c, 0xa82c, LBC::cm},
	{0xa830, 0xa837, LBC::al}, {0xa838, 0xa838, LBC::po}, {0xa839, 0xa839, LBC::al}, {0xa840, 0xa873, LBC::al},
	{0xa874, 0xa875, LBC::bb}, {0xa876, 0xa877, LBC::ex}, {0xa880, 0xa881, LBC::cm}, {0xa882, 0xa8b3, LBC::al},
	{0xa8b4, 0xa8c5, LBC::cm}, {0xa8ce, 0xa8cf, LBC::ba}, {0xa8d0, 0xa8d9, LBC::nu}, {0xa8e0, 0xa8f1, LBC::cm},
	{0xa8f2, 0xa8fb, LBC::al}, {0xa8fc, 0xa8fc, LBC::bb}, {0xa8fd, 0xa8fe, LBC::al}, {0xa8ff, 0xa8ff, LBC::cm},
	{0xa900, 0xa909, LBC::nu}, {0xa90a, 0xa925, LBC::al}, {0xa926, 0xa92d, LBC::cm}, {0xa92e, 0xa92f, LBC::ba},
	{0xa930, 0xa946, LBC::al}, {0xa947, 0xa953, LBC::cm}, {0xa95f, 0xa95f, LBC::al}, {0xa960, 0xa97c, LBC::jl},
	{0xa980, 0xa983, LBC::cm}, {0xa984, 0xa9b2, LBC::ak}, {0xa9b3, 0xa9bf, LBC::cm}, {0xa9c0, 0xa9c0, LBC::vi},
	{0xa9c1, 0xa9c6, LBC::id}, {0xa9c7, 0xa9c9, LBC::ba}, {0xa9ca, 0xa9cd, LBC::id}, {0xa9cf, 0xa9cf, LBC::ba},
	{0xa9d0, 0xa9d9, LBC::as}, {0xa9de, 0xa9df, LBC::id}, {0xa9e0, 0xa9ef, LBC::sa}, {0xa9f0, 0xa9f9, LBC::nu},
	{0xa9fa, 0xa9fe, LBC::sa}, {0xaa00, 0xaa28, LBC::as}, {0xaa29, 0xaa36, LBC::cm}, {0xaa40, 0xaa42, LBC::ba},
	{0xaa43, 0xaa43, LBC::cm}, {0xaa44, 0xaa4b, LBC::ba}, {0xaa4c, 0xaa4d, LBC::cm}, {0xaa50, 0xaa59, LBC::as},
	{0xaa5c, 0xaa5c, LBC::id}, {0xaa5d, 0xaa5f, LBC::ba}, {0xaa60, 0xaac2, LBC::sa}, {0xaadb, 0xaadf, LBC::sa},
	{0xaae0, 0xaaea, LBC::al}, {0xaaeb, 0xaaef, LBC::cm}, {0xaaf0, 0xaaf1, LBC::ba}, {0xaaf2, 0xaaf4, LBC::al},
	{0xaaf5, 0xaaf6, LBC::cm}, {0xab01, 0xab06, LBC::al}, {0xab09, 0xab0e, LBC::al}, {0xab11, 0xab16, LBC::al},
	{0xab20, 0xab26, LBC::al}, {0xab28, 0xab2e, LBC::al}, {0xab30, 0xab6b, LBC::al}, {0xab70, 0xabe2, LBC::al},
	{0xabe3, 0xabea, LBC::cm}, {0xabeb, 0xabeb, LBC::ba}, {0xabec, 0xabed, LBC::cm}, {0xabf0, 0xabf9, LBC::nu},
	{0xac00, 0xac00, LBC::h2}, {0xac01, 0xac1b, LBC::h3}, {0xac1c, 0xac1c, LBC::h2}, {0xac1d, 0xac37, LBC::h3},
	{0xac38, 0xac38, LBC::h2}, {0xac39, 0xac53, LBC::h3}, {0xac54, 0xac54, LBC::h2}, {0xac55, 0xac6f, LBC::h3},
	{0xac70, 0xac70, LBC::h2}, {0xac71, 0xac8b, LBC::h3}, {0xac8c, 0xac8c, LBC::h2}, {0xac8d, 0xaca7, LBC::h3},
	{0xaca8, 0xaca8, LBC::h2}, {0xaca9, 0xacc3, LBC::h3}, {0xacc4, 0xacc4, LBC::h2}, {0xacc5, 0xacdf, LBC::h3},
	{0xace0, 0xace0, LBC::h2}, {0xace1, 0xacfb, LBC::h3}, {0xacfc, 0xacfc, LBC::h2}, {0xacfd, 0xad17, LBC::h3},
	{0xad18, 0xad18, LBC::h2}, {0xad19, 0xad33, LBC::h3}, {0xad34, 0xad34, LBC::h2}, {0xad35, 0xad4f, LBC::h3},
	{0xad50, 0xad50, LBC::h2}, {0xad51, 0xad6b, LBC::h3}, {0xad6c, 0xad6c, LBC::h2}, {0xad6d, 0xad87, LBC::h3},
	{0xad88, 0xad88, LBC::h2}, {0xad89, 0xada3, LBC::h3}, {0xada4, 0xada4, LBC::h2}, {0xada5, 0xadbf, LBC::h3},
	{0xadc0, 0xadc0, LBC::h2}, {0xadc1, 0xaddb, LBC::h3}, {0xaddc, 0xaddc, LBC::h2}, {0xaddd, 0xadf7, LBC::h3},
	{0xadf8, 0xadf8, LBC::h2}, {0xadf9, 0xae13, LBC::h3}, {0xae14, 0xae14, LBC::h2}, {0xae15, 0xae2f, LBC::h3},
	{0xae30, 0xae30, LBC::h2}, {0xae31, 0xae4b, LBC::h3}, {0xae4c, 0xae4c, LBC::h2}, {0xae4d, 0xae67, LBC::h3},
	{0xae68, 0xae68, LBC::h2}, {0xae69, 0xae83, LBC::h3}, {0xae84, 0xae84, LBC::h2}, {0xae85, 0xae9f, LBC::h3},
	{0xaea0, 0xaea0, LBC::h2}, {0xaea1, 0xaebb, LBC::h3}, {0xaebc, 0xaebc, LBC::h2}, {0xaebd, 0xaed7, LBC::h3},
	{0xaed8, 0xaed8, LBC::h2}, {0xaed9, 0xaef3, LBC::h3}, {0xaef4, 0xaef4, LBC::h2}, {0xaef5, 0xaf0f, LBC::h3},
	{0xaf10, 0xaf10, LBC::h2}, {0xaf11, 0xaf2b, LBC::h3}, {0xaf2c, 0xaf2c, LBC::h2}, {0xaf2d, 0xaf47, LBC::h3},
	{0xaf48, 0xaf48, LBC::h2}, {0xaf49, 0xaf63, LBC::h3}, {0xaf64, 0xaf64, LBC::h2}, {0xaf65, 0xaf7f, LBC::h3},
	{0xaf80, 0xaf80, LBC::h2}, {0xaf81, 0xaf9b, LBC::h3}, {0xaf9c, 0xaf9c, LBC::h2}, {0xaf9d, 0xafb7, LBC::h3},
	{0xafb8, 0xafb8, LBC::h2}, {0xafb9, 0xafd3, LBC::h3}, {0xafd4, 0xafd4, LBC::h2}, {0xafd5, 0xafef, LBC::h3},
	{0xaff0, 0xaff0, LBC::h2}, {0xaff1, 0xb00b, LBC::h3}, {0xb00c, 0xb00c, LBC::h2}, {0xb00d, 0xb027, LBC::h3},
	{0xb028, 0xb028, LBC::h2}, {0xb029, 0xb043, LBC::h3}, {0xb044, 0xb044, LBC::h2}, {0xb045, 0xb05f, LBC::h3},
	{0xb060, 0xb060, LBC::h2}, {0xb061, 0xb07b, LBC::h3}, {0xb07c, 0xb07c, LBC::h2}, {0xb07d, 0xb097, LBC::h3},
	{0xb098, 0xb098, LBC::h2}, {0xb099, 0xb0b3, LBC::h3}, {0xb0b4, 0xb0b4, LBC::h2}, {0xb0b5, 0xb0cf, LBC::h3},
	{0xb0d0, 0xb0d0, LBC::h2}, {0xb0d1, 0xb0eb, LBC::h3}, {0xb0ec, 0xb0ec, LBC::h2}, {0xb0ed, 0xb107, LBC::h3},
	{0xb108, 0xb108, LBC::h2}, {0xb109, 0xb123, LBC::h3}, {0xb124, 0xb124, LBC::h2}, {0xb125, 0xb13f, LBC::h3},
	{0xb140, 0xb140, LBC::h2}, {0xb141, 0xb15b, LBC::h3}, {0xb15c, 0xb15c, LBC::h2}, {0xb15d, 0xb177, LBC::h3},
	{0xb178, 0xb178, LBC::h2}, {0xb179, 0xb193, LBC::h3}, {0xb194, 0xb194, LBC::h2}, {0xb195, 0xb1af, LBC::h3},
	{0xb1b0, 0xb1b0, LBC::h2}, {0xb1b1, 0xb1cb, LBC::h3}, {0xb1cc, 0xb1cc, LBC::h2}, {0xb1cd, 0xb1e7, LBC::h3},
	{0xb1e8, 0xb1e8, LBC::h2}, {0xb1e9, 0xb203, LBC::h3}, {0xb204, 0xb204, LBC::h2}, {0xb205, 0xb21f, LBC::h3},
	{0xb220, 0xb220, LBC::h2}, {0xb221, 0xb23b, LBC::h3}, {0xb23c, 0xb23c, LBC::h2}, {0xb23d, 0xb257, LBC::h3},
	{0xb258, 0xb258, LBC::h2}, {0xb259, 0xb273, LBC::h3}, {0xb274, 0xb274, LBC::h2}, {0xb275, 0xb28f, LBC::h3},
	{0xb290, 0xb290, LBC::h2}, {0xb291, 0xb2ab, LBC::h3}, {0xb2ac, 0xb2ac, LBC::h2}, {0xb2ad, 0xb2c7, LBC::h3},
	{0xb2c8, 0xb2c8, LBC::h2}, {0xb2c9, 0xb2e3, LBC::h3}, {0xb2e4, 0xb2e4, LBC::h2}, {0xb2e5, 0xb2ff, LBC::h3},
	{0xb300, 0xb300, LBC::h2}, {0xb301, 0xb31b, LBC::h3}, {0xb31c, 0xb31c, LBC::h2}, {0xb31d, 0xb337, LBC::h3},
	{0xb338, 0xb338, LBC::h2}, {0xb339, 0xb353, LBC::h3}, {0xb354, 0xb354, LBC::h2}, {0xb355, 0xb36f, LBC::h3},
	{0xb370, 0xb370, LBC::h2}, {0xb371, 0xb38b, LBC::h3}, {0xb38c, 0xb38c, LBC::h2}, {0xb38d, 0xb3a7, LBC::h3},
	{0xb3a8, 0xb3a8, LBC::h2}, {0xb3a9, 0xb3c3, LBC::h3}, {0xb3c4, 0xb3c4, LBC::h2}, {0xb3c5, 0xb3df, LBC::h3},
	{0xb3e0, 0xb3e0, LBC::h2}, {0xb3e1, 0xb3fb, LBC::h3}, {0xb3fc, 0xb3fc, LBC::h2}, {0xb3fd, 0xb417, LBC::h3},
	{0xb418, 0xb418, LBC::h2}, {0xb419, 0xb433, LBC::h3}, {0xb434, 0xb434, LBC::h2}, {0xb435, 0xb44f, LBC::h3},
	{0xb450, 0xb450, LBC::h2}, {0xb451, 0xb46b, LBC::h3}, {0xb46c, 0xb46c, LBC::h2}, {0xb46d, 0xb487, LBC::h3},
	{0xb488, 0xb488, LBC::h2}, {0xb489, 0xb4a3, LBC::h3}, {0xb4a4, 0xb4a4, LBC::h2}, {0xb4a5, 0xb4bf, LBC::h3},
	{0xb4c0, 0xb4c0, LBC::h2}, {0xb4c1, 0xb4db, LBC::h3}, {0xb4dc, 0xb4dc, LBC::h2}, {0xb4dd, 0xb4f7, LBC::h3},
	{0xb4f8, 0xb4f8, LBC::h2}, {0xb4f9, 0xb513, LBC::h3}, {0xb514, 0xb514, LBC::h2}, {0xb515, 0xb52f, LBC::h3},
	{0xb530, 0xb530, LBC::h2}, {0xb531, 0xb54b, LBC::h3}, {0xb54c, 0xb54c, LBC::h2}, {0xb54d, 0xb567, LBC::h3},
	{0xb568, 0xb568, LBC::h2}, {0xb569, 0xb583, LBC::h3}, {0xb584, 0xb584, LBC::h2}, {0xb585, 0xb59f, LBC::h3},
	{0xb5a0, 0xb5a0, LBC::h2}, {0xb5a1, 0xb5bb, LBC::h3}, {0xb5bc, 0xb5bc, LBC::h2}, {0xb5bd, 0xb5d7, LBC::h3},
	{0xb5d8, 0xb5d8, LBC::h2}, {0xb5d9, 0xb5f3, LBC::h3}, {0xb5f4, 0xb5f4, LBC::h2}, {0xb5f5, 0xb60f, LBC::h3},
	{0xb610, 0xb610, LBC::h2}, {0xb611, 0xb62b, LBC::h3}, {0xb62c, 0xb62c, LBC::h2}, {0xb62d, 0xb647, LBC::h3},
	{0xb648, 0xb648, LBC::h2}, {0xb649, 0xb663, LBC::h3}, {0xb664, 0xb664, LBC::h2}, {0xb665, 0xb67f, LBC::h3},
	{0xb680, 0xb680, LBC::h2}, {0xb681, 0xb69b, LBC::h3}, {0xb69c, 0xb69c, LBC::h2}, {0xb69d, 0xb6b7, LBC::h3},
	{0xb6b8, 0xb6b8, LBC::h2}, {0xb6b9, 0xb6d3, LBC::h3}, {0xb6d4, 0xb6d4, LBC::h2}, {0xb6d5, 0xb6ef, LBC::h3},
	{0xb6f0, 0xb6f0, LBC::h2}, {0xb6f1, 0xb70b, LBC::h3}, {0xb70c, 0xb70c, LBC::h2}, {0xb70d, 0xb727, LBC::h3},
	{0xb728, 0xb728, LBC::h2}, {0xb729, 0xb743, LBC::h3}, {0xb744, 0xb744, LBC::h2}, {0xb745, 0xb75f, LBC::h3},
	{0xb760, 0xb760, LBC::h2}, {0xb761, 0xb77b, LBC::h3}, {0xb77c, 0xb77c, LBC::h2}, {0xb77d, 0xb797, LBC::h3},
	{0xb798, 0xb798, LBC::h2}, {0xb799, 0xb7b3, LBC::h3}, {0xb7b4, 0xb7b4, LBC::h2}, {0xb7b5, 0xb7cf, LBC::h3},
	{0xb7d0, 0xb7d0, LBC::h2}, {0xb7d1, 0xb7eb, LBC::h3}, {0xb7ec, 0xb7ec, LBC::h2}, {0xb7ed, 0xb807, LBC::h3},
	{0xb808, 0xb808, LBC::h2}, {0xb809, 0xb823, LBC::h3}, {0xb824, 0xb824, LBC::h2}, {0xb825, 0xb83f, LBC::h3},
	{0xb840, 0xb840, LBC::h2}, {0xb841, 0xb85b, LBC::h3}, {0xb85c, 0xb85c, LBC::h2}, {0xb85d, 0xb877, LBC::h3},
	{0xb878, 0xb878, LBC::h2}, {0xb879, 0xb893, LBC::h3}, {0xb894, 0xb894, LBC::h2}, {0xb895, 0xb8af, LBC::h3},
	{0xb8b0, 0xb8b0, LBC::h2}, {0xb8b1, 0xb8cb, LBC::h3}, {0xb8cc, 0xb8cc, LBC::h2}, {0xb8cd, 0xb8e7, LBC::h3},
	{0xb8e8, 0xb8e8, LBC::h2}, {0xb8e9, 0xb903, LBC::h3}, {0xb904, 0xb904, LBC::h2}, {0xb905, 0xb91f, LBC::h3},
	{0xb920, 0xb920, LBC::h2}, {0xb921, 0xb93b, LBC::h3}, {0xb93c, 0xb93c, LBC::h2}, {0xb93d, 0xb957, LBC::h3},
	{0xb958, 0xb958, LBC::h2}, {0xb959, 0xb973, LBC::h3}, {0xb974, 0xb974, LBC::h2}, {0xb975, 0xb98f, LBC::h3},
	{0xb990, 0xb990, LBC::h2}, {0xb991, 0xb9ab, LBC::h3}, {0xb9ac, 0xb9ac, LBC::h2}, {0xb9ad, 0xb9c7, LBC::h3},
	{0xb9c8, 0xb9c8, LBC::h2}, {0xb9c9, 0xb9e3, LBC::h3}, {0xb9e4, 0xb9e4, LBC::h2}, {0xb9e5, 0xb9ff, LBC::h3},
	{0xba00, 0xba00, LBC::h2}, {0xba01, 0xba1b, LBC::h3}, {0xba1c, 0xba1c, LBC::h2}, {0xba1d, 0xba37, LBC::h3},
	{0xba38, 0xba38, LBC::h2}, {0xba39, 0xba53, LBC::h3}, {0xba54, 0xba54, LBC::h2}, {0xba55, 0xba6f, LBC::h3},
	{0xba70, 0xba70, LBC::h2}, {0xba71, 0xba8b, LBC::h3}, {0xba8c, 0xba8c, LBC::h2}, {0xba8d, 0xbaa7, LBC::h3},
	{0xbaa8, 0xbaa8, LBC::h2}, {0xbaa9, 0xbac3, LBC::h3}, {0xbac4, 0xbac4, LBC::h2}, {0xbac5, 0xbadf, LBC::h3},
	{0xbae0, 0xbae0, LBC::h2}, {0xbae1, 0xbafb, LBC::h3}, {0xbafc, 0xbafc, LBC::h2}, {0xbafd, 0xbb17, LBC::h3},
	{0xbb18, 0xbb18, LBC::h2}, {0xbb19, 0xbb33, LBC::h3}, {0xbb34, 0xbb34, LBC::h2}, {0xbb35, 0xbb4f, LBC::h3},
	{0xbb50, 0xbb50, LBC::h2}, {0xbb51, 0xbb6b, LBC::h3}, {0xbb6c, 0xbb6c, LBC::h2}, {0xbb6d, 0xbb87, LBC::h3},
	{0xbb88, 0xbb88, LBC::h2}, {0xbb89, 0xbba3, LBC::h3}, {0xbba4, 0xbba4, LBC::h2}, {0xbba5, 0xbbbf, LBC::h3},
	{0xbbc0, 0xbbc0, LBC::h2}, {0xbbc1, 0xbbdb, LBC::h3}, {0xbbdc, 0xbbdc, LBC::h2}, {0xbbdd, 0xbbf7, LBC::h3},
	{0xbbf8, 0xbbf8, LBC::h2}, {0xbbf9, 0xbc13, LBC::h3}, {0xbc14, 0xbc14, LBC::h2}, {0xbc15, 0xbc2f, LBC::h3},
	{0xbc30, 0xbc30, LBC::h2}, {0xbc31, 0xbc4b, LBC::h3}, {0xbc4c, 0xbc4c, LBC::h2}, {0xbc4d, 0xbc67, LBC::h3},
	{0xbc68, 0xbc68, LBC::h2}, {0xbc69, 0xbc83, LBC::h3}, {0xbc84, 0xbc84, LBC::h2}, {0xbc85, 0xbc9f, LBC::h3},
	{0xbca0, 0xbca0, LBC::h2}, {0xbca1, 0xbcbb, LBC::h3}, {0xbcbc, 0xbcbc, LBC::h2}, {0xbcbd, 0xbcd7, LBC::h3},
	{0xbcd8, 0xbcd8, LBC::h2}, {0xbcd9, 0xbcf3, LBC::h3}, {0xbcf4, 0xbcf4, LBC::h2}, {0xbcf5, 0xbd0f, LBC::h3},
	{0xbd10, 0xbd10, LBC::h2}, {0xbd11, 0xbd2b, LBC::h3}, {0xbd2c, 0xbd2c, LBC::h2}, {0xbd2d, 0xbd47, LBC::h3},
	{0xbd48, 0xbd48, LBC::h2}, {0xbd49, 0xbd63, LBC::h3}, {0xbd64, 0xbd64, LBC::h2}, {0xbd65, 0xbd7f, LBC::h3},
	{0xbd80, 0xbd80, LBC::h2}, {0xbd81, 0xbd9b, LBC::h3}, {0xbd9c, 0xbd9c, LBC::h2}, {0xbd9d, 0xbdb7, LBC::h3},
	{0xbdb8, 0xbdb8, LBC::h2}, {0xbdb9, 0xbdd3, LBC::h3}, {0xbdd4, 0xbdd4, LBC::h2}, {0xbdd5, 0xbdef, LBC::h3},
	{0xbdf0, 0xbdf0, LBC::h2}, {0xbdf1, 0xbe0b, LBC::h3}, {0xbe0c, 0xbe0c, LBC::h2}, {0xbe0d, 0xbe27, LBC::h3},
	{0xbe28, 0xbe28, LBC::h2}, {0xbe29, 0xbe43, LBC::h3}, {0xbe44, 0xbe44, LBC::h2}, {0xbe45, 0xbe5f, LBC::h3},
	{0xbe60, 0xbe60, LBC::h2}, {0xbe61, 0xbe7b, LBC::h3}, {0xbe7c, 0xbe7c, LBC::h2}, {0xbe7d, 0xbe97, LBC::h3},
	{0xbe98, 0xbe98, LBC::h2}, {0xbe99, 0xbeb3, LBC::h3}, {0xbeb4, 0xbeb4, LBC::h2}, {0xbeb5, 0xbecf, LBC::h3},
	{0xbed0, 0xbed0, LBC::h2}, {0xbed1, 0xbeeb, LBC::h3}, {0xbeec, 0xbeec, LBC::h2}, {0xbeed, 0xbf07, LBC::h3},
	{0xbf08, 0xbf08, LBC::h2}, {0xbf09, 0xbf23, LBC::h3}, {0xbf24, 0xbf24, LBC::h2}, {0xbf25, 0xbf3f, LBC::h3},
	{0xbf40, 0xbf40, LBC::h2}, {0xbf41, 0xbf5b, LBC::h3}, {0xbf5c, 0xbf5c, LBC::h2}, {0xbf5d, 0xbf77, LBC::h3},
	{0xbf78, 0xbf78, LBC::h2}, {0xbf79, 0xbf93, LBC::h3}, {0xbf94, 0xbf94, LBC::h2}, {0xbf95, 0xbfaf, LBC::h3},
	{0xbfb0, 0xbfb0, LBC::h2}, {0xbfb1, 0xbfcb, LBC::h3}, {0xbfcc, 0xbfcc, LBC::h2}, {0xbfcd, 0xbfe7, LBC::h3},
	{0xbfe8, 0xbfe8, LBC::h2}, {0xbfe9, 0xc003, LBC::h3}, {0xc004, 0xc004, LBC::h2}, {0xc005, 0xc01f, LBC::h3},
	{0xc020, 0xc020, LBC::h2}, {0xc021, 0xc03b, LBC::h3}, {0xc03c, 0xc03c, LBC::h2}, {0xc03d, 0xc057, LBC::h3},
	{0xc058, 0xc058, LBC::h2}, {0xc059, 0xc073, LBC::h3}, {0xc074, 0xc074, LBC::h2}, {0xc075, 0xc08f, LBC::h3},
	{0xc090, 0xc090, LBC::h2}, {0xc091, 0xc0ab, LBC::h3}, {0xc0ac, 0xc0ac, LBC::h2}, {0xc0ad, 0xc0c7, LBC::h3},
	{0xc0c8, 0xc0c8, LBC::h2}, {0xc0c9, 0xc0e3, LBC::h3}, {0xc0e4, 0xc0e4, LBC::h2}, {0xc0e5, 0xc0ff, LBC::h3},
	{0xc100, 0xc100, LBC::h2}, {0xc101, 0xc11b, LBC::h3}, {0xc11c, 0xc11c, LBC::h2}, {0xc11d, 0xc137, LBC::h3},
	{0xc138, 0xc138, LBC::h2}, {0xc139, 0xc153, LBC::h3}, {0xc154, 0xc154, LBC::h2}, {0xc155, 0xc16f, LBC::h3},
	{0xc170, 0xc170, LBC::h2}, {0xc171, 0xc18b, LBC::h3}, {0xc18c, 0xc18c, LBC::h2}, {0xc18d, 0xc1a7, LBC::h3},
	{0xc1a8, 0xc1a8, LBC::h2}, {0xc1a9, 0xc1c3, LBC::h3}, {0xc1c4, 0xc1c4, LBC::h2}, {0xc1c5, 0xc1df, LBC::h3},
	{0xc1e0, 0xc1e0, LBC::h2}, {0xc1e1, 0xc1fb, LBC::h3}, {0xc1fc, 0xc1fc, LBC::h2}, {0xc1fd, 0xc217, LBC::h3},
	{0xc218, 0xc218, LBC::h2}, {0xc219, 0xc233, LBC::h3}, {0xc234, 0xc234, LBC::h2}, {0xc235, 0xc24f, LBC::h3},
	{0xc250, 0xc250, LBC::h2}, {0xc251, 0xc26b, LBC::h3}, {0xc26c, 0xc26c, LBC::h2}, {0xc26d, 0xc287, LBC::h3},
	{0xc288, 0xc288, LBC::h2}, {0xc289, 0xc2a3, LBC::h3}, {0xc2a4, 0xc2a4, LBC::h2}, {0xc2a5, 0xc2bf, LBC::h3},
	{0xc2c0, 0xc2c0, LBC::h2}, {0xc2c1, 0xc2db, LBC::h3}, {0xc2dc, 0xc2dc, LBC::h2}, {0xc2dd, 0xc2f7, LBC::h3},
	{0xc2f8, 0xc2f8, LBC::h2}, {0xc2f9, 0xc313, LBC::h3}, {0xc314, 0xc314, LBC::h2}, {0xc315, 0xc32f, LBC::h3},
	{0xc330, 0xc330, LBC::h2}, {0xc331, 0xc34b, LBC::h3}, {0xc34c, 0xc34c, LBC::h2}, {0xc34d, 0xc367, LBC::h3},
	{0xc368, 0xc368, LBC::h2}, {0xc369, 0xc383, LBC::h3}, {0xc384, 0xc384, LBC::h2}, {0xc385, 0xc39f, LBC::h3},
	{0xc3a0, 0xc3a0, LBC::h2}, {0xc3a1, 0xc3bb, LBC::h3}, {0xc3bc, 0xc3bc, LBC::h2}, {0xc3bd, 0xc3d7, LBC::h3},
	{0xc3d8, 0xc3d8, LBC::h2}, {0xc3d9, 0xc3f3, LBC::h3}, {0xc3f4, 0xc3f4, LBC::h2}, {0xc3f5, 0xc40f, LBC::h3},
	{0xc410, 0xc410, LBC::h2}, {0xc411, 0xc42b, LBC::h3}, {0xc42c, 0xc42c, LBC::h2}, {0xc42d, 0xc447, LBC::h3},
	{0xc448, 0xc448, LBC::h2}, {0xc449, 0xc463, LBC::h3}, {0xc464, 0xc464, LBC::h2}, {0xc465, 0xc47f, LBC::h3},
	{0xc480, 0xc480, LBC::h2}, {0xc481, 0xc49b, LBC::h3}, {0xc49c, 0xc49c, LBC::h2}, {0xc49d, 0xc4b7, LBC::h3},
	{0xc4b8, 0xc4b8, LBC::h2}, {0xc4b9, 0xc4d3, LBC::h3}, {0xc4d4, 0xc4d4, LBC::h2}, {0xc4d5, 0xc4ef, LBC::h3},
	{0xc4f0, 0xc4f0, LBC::h2}, {0xc4f1, 0xc50b, LBC::h3}, {0xc50c, 0xc50c, LBC::h2}, {0xc50d, 0xc527, LBC::h3},
	{0xc528, 0xc528, LBC::h2}, {0xc529, 0xc543, LBC::h3}, {0xc544, 0xc544, LBC::h2}, {0xc545, 0xc55f, LBC::h3},
	{0xc560, 0xc560, LBC::h2}, {0xc561, 0xc57b, LBC::h3}, {0xc57c, 0xc57c, LBC::h2}, {0xc57d, 0xc597, LBC::h3},
	{0xc598, 0xc598, LBC::h2}, {0xc599, 0xc5b3, LBC::h3}, {0xc5b4, 0xc5b4, LBC::h2}, {0xc5b5, 0xc5cf, LBC::h3},
	{0xc5d0, 0xc5d0, LBC::h2}, {0xc5d1, 0xc5eb, LBC::h3}, {0xc5ec, 0xc5ec, LBC::h2}, {0xc5ed, 0xc607, LBC::h3},
	{0xc608, 0xc608, LBC::h2}, {0xc609, 0xc623, LBC::h3}, {0xc624, 0xc624, LBC::h2}, {0xc625, 0xc63f, LBC::h3},
	{0xc640, 0xc640, LBC::h2}, {0xc641, 0xc65b, LBC::h3}, {0xc65c, 0xc65c, LBC::h2}, {0xc65d, 0xc677, LBC::h3},
	{0xc678, 0xc678, LBC::h2}, {0xc679, 0xc693, LBC::h3}, {0xc694, 0xc694, LBC::h2}, {0xc695, 0xc6af, LBC::h3},
	{0xc6b0, 0xc6b0, LBC::h2}, {0xc6b1, 0xc6cb, LBC::h3}, {0xc6cc, 0xc6cc, LBC::h2}, {0xc6cd, 0xc6e7, LBC::h3},
	{0xc6e8, 0xc6e8, LBC::h2}, {0xc6e9, 0xc703, LBC::h3}, {0xc704, 0xc704, LBC::h2}, {0xc705, 0xc71f, LBC::h3},
	{0xc720, 0xc720, LBC::h2}, {0xc721, 0xc73b, LBC::h3}, {0xc73c, 0xc73c, LBC::h2}, {0xc73d, 0xc757, LBC::h3},
	{0xc758, 0xc758, LBC::h2}, {0xc759, 0xc773, LBC::h3}, {0xc774, 0xc774, LBC::h2}, {0xc775, 0xc78f, LBC::h3},
	{0xc790, 0xc790, LBC::h2}, {0xc791, 0xc7ab, LBC::h3}, {0xc7ac, 0xc7ac, LBC::h2}, {0xc7ad, 0xc7c7, LBC::h3},
	{0xc7c8, 0xc7c8, LBC::h2}, {0xc7c9, 0xc7e3, LBC::h3}, {0xc7e4, 0xc7e4, LBC::h2}, {0xc7e5, 0xc7ff, LBC::h3},
	{0xc800, 0xc800, LBC::h2}, {0xc801, 0xc81b, LBC::h3}, {0xc81c, 0xc81c, LBC::h2}, {0xc81d, 0xc837, LBC::h3},
	{0xc838, 0xc838, LBC::h2}, {0xc839, 0xc853, LBC::h3}, {0xc854, 0xc854, LBC::h2}, {0xc855, 0xc86f, LBC::h3},
	{0xc870, 0xc870, LBC::h2}, {0xc871, 0xc88b, LBC::h3}, {0xc88c, 0xc88c, LBC::h2}, {0xc88d, 0xc8a7, LBC::h3},
	{0xc8a8, 0xc8a8, LBC::h2}, {0xc8a9, 0xc8c3, LBC::h3}, {0xc8c4, 0xc8c4, LBC::h2}, {0xc8c5, 0xc8df, LBC::h3},
	{0xc8e0, 0xc8e0, LBC::h2}, {0xc8e1, 0xc8fb, LBC::h3}, {0xc8fc, 0xc8fc, LBC::h2}, {0xc8fd, 0xc917, LBC::h3},
	{0xc918, 0xc918, LBC::h2}, {0xc919, 0xc933, LBC::h3}, {0xc934, 0xc934, LBC::h2}, {0xc935, 0xc94f, LBC::h3},
	{0xc950, 0xc950, LBC::h2}, {0xc951, 0xc96b, LBC::h3}, {0xc96c, 0xc96c, LBC::h2}, {0xc96d, 0xc987, LBC::h3},
	{0xc988, 0xc988, LBC::h2}, {0xc989, 0xc9a3, LBC::h3}, {0xc9a4, 0xc9a4, LBC::h2}, {0xc9a5, 0xc9bf, LBC::h3},
	{0xc9c0, 0xc9c0, LBC::h2}, {0xc9c1, 0xc9db, LBC::h3}, {0xc9dc, 0xc9dc, LBC::h2}, {0xc9dd, 0xc9f7, LBC::h3},
	{0xc9f8, 0xc9f8, LBC::h2}, {0xc9f9, 0xca13, LBC::h3}, {0xca14, 0xca14, LBC::h2}, {0xca15, 0xca2f, LBC::h3},
	{0xca30, 0xca30, LBC::h2}, {0xca31, 0xca4b, LBC::h3}, {0xca4c, 0xca4c, LBC::h2}, {0xca4d, 0xca67, LBC::h3},
	{0xca68, 0xca68, LBC::h2}, {0xca69, 0xca83, LBC::h3}, {0xca84, 0xca84, LBC::h2}, {0xca85, 0xca9f, LBC::h3},
	{0xcaa0, 0xcaa0, LBC::h2}, {0xcaa1, 0xcabb, LBC::h3}, {0xcabc, 0xcabc, LBC::h2}, {0xcabd, 0xcad7, LBC::h3},
	{0xcad8, 0xcad8, LBC::h2}, {0xcad9, 0xcaf3, LBC::h3}, {0xcaf4, 0xcaf4, LBC::h2}, {0xcaf5, 0xcb0f, LBC::h3},
	{0xcb10, 0xcb10, LBC::h2}, {0xcb11, 0xcb2b, LBC::h3}, {0xcb2c, 0xcb2c, LBC::h2}, {0xcb2d, 0xcb47, LBC::h3},
	{0xcb48, 0xcb48, LBC::h2}, {0xcb49, 0xcb63, LBC::h3}, {0xcb64, 0xcb64, LBC::h2}, {0xcb65, 0xcb7f, LBC::h3},
	{0xcb80, 0xcb80, LBC::h2}, {0xcb81, 0xcb9b, LBC::h3}, {0xcb9c, 0xcb9c, LBC::h2}, {0xcb9d, 0xcbb7, LBC::h3},
	{0xcbb8, 0xcbb8, LBC::h2}, {0xcbb9, 0xcbd3, LBC::h3}, {0xcbd4, 0xcbd4, LBC::h2}, {0xcbd5, 0xcbef, LBC::h3},
	{0xcbf0, 0xcbf0, LBC::h2}, {0xcbf1, 0xcc0b, LBC::h3}, {0xcc0c, 0xcc0c, LBC::h2}, {0xcc0d, 0xcc27, LBC::h3},
	{0xcc28, 0xcc28, LBC::h2}, {0xcc29, 0xcc43, LBC::h3}, {0xcc44, 0xcc44, LBC::h2}, {0xcc45, 0xcc5f, LBC::h3},
	{0xcc60, 0xcc60, LBC::h2}, {0xcc61, 0xcc7b, LBC::h3}, {0xcc7c, 0xcc7c, LBC::h2}, {0xcc7d, 0xcc97, LBC::h3},
	{0xcc98, 0xcc98, LBC::h2}, {0xcc99, 0xccb3, LBC::h3}, {0xccb4, 0xccb4, LBC::h2}, {0xccb5, 0xcccf, LBC::h3},
	{0xccd0, 0xccd0, LBC::h2}, {0xccd1, 0xcceb, LBC::h3}, {0xccec, 0xccec, LBC::h2}, {0xcced, 0xcd07, LBC::h3},
	{0xcd08, 0xcd08, LBC::h2}, {0xcd09, 0xcd23, LBC::h3}, {0xcd24, 0xcd24, LBC::h2}, {0xcd25, 0xcd3f, LBC::h3},
	{0xcd40, 0xcd40, LBC::h2}, {0xcd41, 0xcd5b, LBC::h3}, {0xcd5c, 0xcd5c, LBC::h2}, {0xcd5d, 0xcd77, LBC::h3},
	{0xcd78, 0xcd78, LBC::h2}, {0xcd79, 0xcd93, LBC::h3}, {0xcd94, 0xcd94, LBC::h2}, {0xcd95, 0xcdaf, LBC::h3},
	{0xcdb0, 0xcdb0, LBC::h2}, {0xcdb1, 0xcdcb, LBC::h3}, {0xcdcc, 0xcdcc, LBC::h2}, {0xcdcd, 0xcde7, LBC::h3},
	{0xcde8, 0xcde8, LBC::h2}, {0xcde9, 0xce03, LBC::h3}, {0xce04, 0xce04, LBC::h2}, {0xce05, 0xce1f, LBC::h3},
	{0xce20, 0xce20, LBC::h2}, {0xce21, 0xce3b, LBC::h3}, {0xce3c, 0xce3c, LBC::h2}, {0xce3d, 0xce57, LBC::h3},
	{0xce58, 0xce58, LBC::h2}, {0xce59, 0xce73, LBC::h3}, {0xce74, 0xce74, LBC::h2}, {0xce75, 0xce8f, LBC::h3},
	{0xce90, 0xce90, LBC::h2}, {0xce91, 0xceab, LBC::h3}, {0xceac, 0xceac, LBC::h2}, {0xcead, 0xcec7, LBC::h3},
	{0xcec8, 0xcec8, LBC::h2}, {0xcec9, 0xcee3, LBC::h3}, {0xcee4, 0xcee4, LBC::h2}, {0xcee5, 0xceff, LBC::h3},
	{0xcf00, 0xcf00, LBC::h2}, {0xcf01, 0xcf1b, LBC::h3}, {0xcf1c, 0xcf1c, LBC::h2}, {0xcf1d, 0xcf37, LBC::h3},
	{0xcf38, 0xcf38, LBC::h2}, {0xcf39, 0xcf53, LBC::h3}, {0xcf54, 0xcf54, LBC::h2}, {0xcf55, 0xcf6f, LBC::h3},
	{0xcf70, 0xcf70, LBC::h2}, {0xcf71, 0xcf8b, LBC::h3}, {0xcf8c, 0xcf8c, LBC::h2}, {0xcf8d, 0xcfa7, LBC::h3},
	{0xcfa8, 0xcfa8, LBC::h2}, {0xcfa9, 0xcfc3, LBC::h3}, {0xcfc4, 0xcfc4, LBC::h2}, {0xcfc5, 0xcfdf, LBC::h3},
	{0xcfe0, 0xcfe0, LBC::h2}, {0xcfe1, 0xcffb, LBC::h3}, {0xcffc, 0xcffc, LBC::h2}, {0xcffd, 0xd017, LBC::h3},
	{0xd018, 0xd018, LBC::h2}, {0xd019, 0xd033, LBC::h3}, {0xd034, 0xd034, LBC::h2}, {0xd035, 0xd04f, LBC::h3},
	{0xd050, 0xd050, LBC::h2}, {0xd051, 0xd06b, LBC::h3}, {0xd06c, 0xd06c, LBC::h2}, {0xd06d, 0xd087, LBC::h3},
	{0xd088, 0xd088, LBC::h2}, {0xd089, 0xd0a3, LBC::h3}, {0xd0a4, 0xd0a4, LBC::h2}, {0xd0a5, 0xd0bf, LBC::h3},
	{0xd0c0, 0xd0c0, LBC::h2}, {0xd0c1, 0xd0db, LBC::h3}, {0xd0dc, 0xd0dc, LBC::h2}, {0xd0dd, 0xd0f7, LBC::h3},
	{0xd0f8, 0xd0f8, LBC::h2}, {0xd0f9, 0xd113, LBC::h3}, {0xd114, 0xd114, LBC::h2}, {0xd115, 0xd12f, LBC::h3},
	{0xd130, 0xd130, LBC::h2}, {0xd131, 0xd14b, LBC::h3}, {0xd14c, 0xd14c, LBC::h2}, {0xd14d, 0xd167, LBC::h3},
	{0xd168, 0xd168, LBC::h2}, {0xd169, 0xd183, LBC::h3}, {0xd184, 0xd184, LBC::h2}, {0xd185, 0xd19f, LBC::h3},
	{0xd1a0, 0xd1a0, LBC::h2}, {0xd1a1, 0xd1bb, LBC::h3}, {0xd1bc, 0xd1bc, LBC::h2}, {0xd1bd, 0xd1d7, LBC::h3},
	{0xd1d8, 0xd1d8, LBC::h2}, {0xd1d9, 0xd1f3, LBC::h3}, {0xd1f4, 0xd1f4, LBC::h2}, {0xd1f5, 0xd20f, LBC::h3},
	{0xd210, 0xd210, LBC::h2}, {0xd211, 0xd22b, LBC::h3}, {0xd22c, 0xd22c, LBC::h2}, {0xd22d, 0xd247, LBC::h3},
	{0xd248, 0xd248, LBC::h2}, {0xd249, 0xd263, LBC::h3}, {0xd264, 0xd264, LBC::h2}, {0xd265, 0xd27f, LBC::h3},
	{0xd280, 0xd280, LBC::h2}, {0xd281, 0xd29b, LBC::h3}, {0xd29c, 0xd29c, LBC::h2}, {0xd29d, 0xd2b7, LBC::h3},
	{0xd2b8, 0xd2b8, LBC::h2}, {0xd2b9, 0xd2d3, LBC::h3}, {0xd2d4, 0xd2d4, LBC::h2}, {0xd2d5, 0xd2ef, LBC::h3},
	{0xd2f0, 0xd2f0, LBC::h2}, {0xd2f1, 0xd30b, LBC::h3}, {0xd30c, 0xd30c, LBC::h2}, {0xd30d, 0xd327, LBC::h3},
	{0xd328, 0xd328, LBC::h2}, {0xd329, 0xd343, LBC::h3}, {0xd344, 0xd344, LBC::h2}, {0xd345, 0xd35f, LBC::h3},
	{0xd360, 0xd360, LBC::h2}, {0xd361, 0xd37b, LBC::h3}, {0xd37c, 0xd37c, LBC::h2}, {0xd37d, 0xd397, LBC::h3},
	{0xd398, 0xd398, LBC::h2}, {0xd399, 0xd3b3, LBC::h3}, {0xd3b4, 0xd3b4, LBC::h2}, {0xd3b5, 0xd3cf, LBC::h3},
	{0xd3d0, 0xd3d0, LBC::h2}, {0xd3d1, 0xd3eb, LBC::h3}, {0xd3ec, 0xd3ec, LBC::h2}, {0xd3ed, 0xd407, LBC::h3},
	{0xd408, 0xd408, LBC::h2}, {0xd409, 0xd423, LBC::h3}, {0xd424, 0xd424, LBC::h2}, {0xd425, 0xd43f, LBC::h3},
	{0xd440, 0xd440, LBC::h2}, {0xd441, 0xd45b, LBC::h3}, {0xd45c, 0xd45c, LBC::h2}, {0xd45d, 0xd477, LBC::h3},
	{0xd478, 0xd478, LBC::h2}, {0xd479, 0xd493, LBC::h3}, {0xd494, 0xd494, LBC::h2}, {0xd495, 0xd4af, LBC::h3},
	{0xd4b0, 0xd4b0, LBC::h2}, {0xd4b1, 0xd4cb, LBC::h3}, {0xd4cc, 0xd4cc, LBC::h2}, {0xd4cd, 0xd4e7, LBC::h3},
	{0xd4e8, 0xd4e8, LBC::h2}, {0xd4e9, 0xd503, LBC::h3}, {0xd504, 0xd504, LBC::h2}, {0xd505, 0xd51f, LBC::h3},
	{0xd520, 0xd520, LBC::h2}, {0xd521, 0xd53b, LBC::h3}, {0xd53c, 0xd53c, LBC::h2}, {0xd53d, 0xd557, LBC::h3},
	{0xd558, 0xd558, LBC::h2}, {0xd559, 0xd573, LBC::h3}, {0xd574, 0xd574, LBC::h2}, {0xd575, 0xd58f, LBC::h3},
	{0xd590, 0xd590, LBC::h2}, {0xd591, 0xd5ab, LBC::h3}, {0xd5ac, 0xd5ac, LBC::h2}, {0xd5ad, 0xd5c7, LBC::h3},
	{0xd5c8, 0xd5c8, LBC::h2}, {0xd5c9, 0xd5e3, LBC::h3}, {0xd5e4, 0xd5e4, LBC::h2}, {0xd5e5, 0xd5ff, LBC::h3},
	{0xd600, 0xd600, LBC::h2}, {0xd601, 0xd61b, LBC::h3}, {0xd61c, 0xd61c, LBC::h2}, {0xd61d, 0xd637, LBC::h3},
	{0xd638, 0xd638, LBC::h2}, {0xd639, 0xd653, LBC::h3}, {0xd654, 0xd654, LBC::h2}, {0xd655, 0xd66f, LBC::h3},
	{0xd670, 0xd670, LBC::h2}, {0xd671, 0xd68b, LBC::h3}, {0xd68c, 0xd68c, LBC::h2}, {0xd68d, 0xd6a7, LBC::h3},
	{0xd6a8, 0xd6a8, LBC::h2}, {0xd6a9, 0xd6c3, LBC::h3}, {0xd6c4, 0xd6c4, LBC::h2}, {0xd6c5, 0xd6df, LBC::h3},
	{0xd6e0, 0xd6e0, LBC::h2}, {0xd6e1, 0xd6fb, LBC::h3}, {0xd6fc, 0xd6fc, LBC::h2}, {0xd6fd, 0xd717, LBC::h3},
	{0xd718, 0xd718, LBC::h2}, {0xd719, 0xd733, LBC::h3}, {0xd734, 0xd734, LBC::h2}, {0xd735, 0xd74f, LBC::h3},
	{0xd750, 0xd750, LBC::h2}, {0xd751, 0xd76b, LBC::h3}, {0xd76c, 0xd76c, LBC::h2}, {0xd76d, 0xd787, LBC::h3},
	{0xd788, 0xd788, LBC::h2}, {0xd789, 0xd7a3, LBC::h3}, {0xd7b0, 0xd7c6, LBC::jv}, {0xd7cb, 0xd7fb, LBC::jt},
	{0xd800, 0xdfff, LBC::sg}, {0xe000, 0xf8ff, LBC::xx}, {0xf900, 0xfaff, LBC::id}, {0xfb00, 0xfb06, LBC::al},
	{0xfb13, 0xfb17, LBC::al}, {0xfb1d, 0xfb1d, LBC::hl}, {0xfb1e, 0xfb1e, LBC::cm}, {0xfb1f, 0xfb28, LBC::hl},
	{0xfb29, 0xfb29, LBC::al}, {0xfb2a, 0xfb36, LBC::hl}, {0xfb38, 0xfb3c, LBC::hl}, {0xfb3e, 0xfb3e, LBC::hl},
	{0xfb40, 0xfb41, LBC::hl}, {0xfb43, 0xfb44, LBC::hl}, {0xfb46, 0xfb4f, LBC::hl}, {0xfb50, 0xfd3d, LBC::al},
	{0xfd3e, 0xfd3e, LBC::cl}, {0xfd3f, 0xfd3f, LBC::op}, {0xfd40, 0xfdcf, LBC::al}, {0xfdf0, 0xfdfb, LBC::al},
	{0xfdfc, 0xfdfc, LBC::po}, {0xfdfd, 0xfdff, LBC::al}, {0xfe00, 0xfe0f, LBC::cm}, {0xfe10, 0xfe12, LBC::cl},
	{0xfe13, 0xfe14, LBC::ns}, {0xfe15, 0xfe16, LBC::ex}, {0xfe17, 0xfe17, LBC::op}, {0xfe18, 0xfe18, LBC::cl},
	{0xfe19, 0xfe19, LBC::in}, {0xfe20, 0xfe20, LBC::gl}, {0xfe21, 0xfe21, LBC::cm}, {0xfe22, 0xfe22, LBC::gl},
	{0xfe23, 0xfe23, LBC::cm}, {0xfe24, 0xfe24, LBC::gl}, {0xfe25, 0xfe25, LBC::cm}, {0xfe26, 0xfe27, LBC::gl},
	{0xfe28, 0xfe28, LBC::cm}, {0xfe29, 0xfe29, LBC::gl}, {0xfe2a, 0xfe2a, LBC::cm}, {0xfe2b, 0xfe2b, LBC::gl},
	{0xfe2c, 0xfe2c, LBC::cm}, {0xfe2d, 0xfe2e, LBC::gl}, {0xfe2f, 0xfe2f, LBC::cm}, {0xfe30, 0xfe34, LBC::id},
	{0xfe35, 0xfe35, LBC::op}, {0xfe36, 0xfe36, LBC::cl}, {0xfe37, 0xfe37, LBC::op}, {0xfe38, 0xfe38, LBC::cl},
	{0xfe39, 0xfe39, LBC::op}, {0xfe3a, 0xfe3a, LBC::cl}, {0xfe3b, 0xfe3b, LBC::op}, {0xfe3c, 0xfe3c, LBC::cl},
	{0xfe3d, 0xfe3d, LBC::op}, {0xfe3e, 0xfe3e, LBC::cl}, {0xfe3f, 0xfe3f, LBC::op}, {0xfe40, 0xfe40, LBC::cl},
	{0xfe41, 0xfe41, LBC::op}, {0xfe42, 0xfe42, LBC::cl}, {0xfe43, 0xfe43, LBC::op}, {0xfe44, 0xfe44, LBC::cl},
	{0xfe45, 0xfe46, LBC::id}, {0xfe47, 0xfe47, LBC::op}, {0xfe48, 0xfe48, LBC::cl}, {0xfe49, 0xfe4f, LBC::id},
	{0xfe50, 0xfe50, LBC::cl}, {0xfe51, 0xfe51, LBC::id}, {0xfe52, 0xfe52, LBC::cl}, {0xfe54, 0xfe55, LBC::ns},
	{0xfe56, 0xfe57, LBC::ex}, {0xfe58, 0xfe58, LBC::id}, {0xfe59, 0xfe59, LBC::op}, {0xfe5a, 0xfe5a, LBC::cl},
	{0xfe5b, 0xfe5b, LBC::op}, {0xfe5c, 0xfe5c, LBC::cl}, {0xfe5d, 0xfe5d, LBC::op}, {0xfe5e, 0xfe5e, LBC::cl},
	{0xfe5f, 0xfe66, LBC::id}, {0xfe68, 0xfe68, LBC::id}, {0xfe69, 0xfe69, LBC::pr}, {0xfe6a, 0xfe6a, LBC::po},
	{0xfe6b, 0xfe6b, LBC::id}, {0xfe70, 0xfe74, LBC::al}, {0xfe76, 0xfefc, LBC::al}, {0xfeff, 0xfeff, LBC::wj},
	{0xff01, 0xff01, LBC::ex}, {0xff02, 0xff03, LBC::id}, {0xff04, 0xff04, LBC::pr}, {0xff05, 0xff05, LBC::po},
	{0xff06, 0xff07, LBC::id}, {0xff08, 0xff08, LBC::op}, {0xff09, 0xff09, LBC::cl}, {0xff0a, 0xff0b, LBC::id},
	{0xff0c, 0xff0c, LBC::cl}, {0xff0d, 0xff0d, LBC::id}, {0xff0e, 0xff0e, LBC::cl}, {0xff0f, 0xff19, LBC::id},
	{0xff1a, 0xff1b, LBC::ns}, {0xff1c, 0xff1e, LBC::id}, {0xff1f, 0xff1f, LBC::ex}, {0xff20, 0xff3a, LBC::id},
	{0xff3b, 0xff3b, LBC::op}, {0xff3c, 0xff3c, LBC::id}, {0xff3d, 0xff3d, LBC::cl}, {0xff3e, 0xff5a, LBC::id},
	{0xff5b, 0xff5b, LBC::op}, {0xff5c, 0xff5c, LBC::id}, {0xff5d, 0xff5d, LBC::cl}, {0xff5e, 0xff5e, LBC::id},
	{0xff5f, 0xff5f, LBC::op}, {0xff60, 0xff61, LBC::cl}, {0xff62, 0xff62, LBC::op}, {0xff63, 0xff64, LBC::cl},
	{0xff65, 0xff65, LBC::ns}, {0xff66, 0xff66, LBC::id}, {0xff67, 0xff70, LBC::cj}, {0xff71, 0xff9d, LBC::id},
	{0xff9e, 0xff9f, LBC::ns}, {0xffa0, 0xffbe, LBC::id}, {0xffc2, 0xffc7, LBC::id}, {0xffca, 0xffcf, LBC::id},
	{0xffd2, 0xffd7, LBC::id}, {0xffda, 0xffdc, LBC::id}, {0xffe0, 0xffe0, LBC::po}, {0xffe1, 0xffe1, LBC::pr},
	{0xffe2, 0xffe4, LBC::id}, {0xffe5, 0xffe6, LBC::pr}, {0xffe8, 0xffee, LBC::al}, {0xfff9, 0xfffb, LBC::cm},
	{0xfffc, 0xfffc, LBC::cb}, {0xfffd, 0xfffd, LBC::ai}
};


//
//	lineBreak32
//

#if defined(IMGUI_USE_WCHAR32)

static LineBreakRange32 lineBreak32[] = {
	{0x10000, 0x1000b, LBC::al}, {0x1000d, 0x10026, LBC::al}, {0x10028, 0x1003a, LBC::al}, {0x1003c, 0x1003d, LBC::al},
	{0x1003f, 0x1004d, LBC::al}, {0x10050, 0x1005d, LBC::al}, {0x10080, 0x100fa, LBC::al}, {0x10100, 0x10102, LBC::ba},
	{0x10107, 0x10133, LBC::al}, {0x10137, 0x1018e, LBC::al}, {0x10190, 0x1019c, LBC::al}, {0x101a0, 0x101a0, LBC::al},
	{0x101d0, 0x101fc, LBC::al}, {0x101fd, 0x101fd, LBC::cm}, {0x10280, 0x1029c, LBC::al}, {0x102a0, 0x102d0, LBC::al},
	{0x102e0, 0x102e0, LBC::cm}, {0x102e1, 0x102fb, LBC::al}, {0x10300, 0x10323, LBC::al}, {0x1032d, 0x1034a, LBC::al},
	{0x10350, 0x10375, LBC::al}, {0x10376, 0x1037a, LBC::cm}, {0x10380, 0x1039d, LBC::al}, {0x1039f, 0x1039f, LBC::ba},
	{0x103a0, 0x103c3, LBC::al}, {0x103c8, 0x103cf, LBC::al}, {0x103d0, 0x103d0, LBC::ba}, {0x103d1, 0x103d5, LBC::al},
	{0x10400, 0x1049d, LBC::al}, {0x104a0, 0x104a9, LBC::nu}, {0x104b0, 0x104d3, LBC::al}, {0x104d8, 0x104fb, LBC::al},
	{0x10500, 0x10527, LBC::al}, {0x10530, 0x10563, LBC::al}, {0x1056f, 0x1057a, LBC::al}, {0x1057c, 0x1058a, LBC::al},
	{0x1058c, 0x10592, LBC::al}, {0x10594, 0x10595, LBC::al}, {0x10597, 0x105a1, LBC::al}, {0x105a3, 0x105b1, LBC::al},
	{0x105b3, 0x105b9, LBC::al}, {0x105bb, 0x105bc, LBC::al}, {0x105c0, 0x105f3, LBC::al}, {0x10600, 0x10736, LBC::al},
	{0x10740, 0x10755, LBC::al}, {0x10760, 0x10767, LBC::al}, {0x10780, 0x10785, LBC::al}, {0x10787, 0x107b0, LBC::al},
	{0x107b2, 0x107ba, LBC::al}, {0x10800, 0x10805, LBC::al}, {0x10808, 0x10808, LBC::al}, {0x1080a, 0x10835, LBC::al},
	{0x10837, 0x10838, LBC::al}, {0x1083c, 0x1083c, LBC::al}, {0x1083f, 0x10855, LBC::al}, {0x10857, 0x10857, LBC::ba},
	{0x10858, 0x1089e, LBC::al}, {0x108a7, 0x108af, LBC::al}, {0x108e0, 0x108f2, LBC::al}, {0x108f4, 0x108f5, LBC::al},
	{0x108fb, 0x1091b, LBC::al}, {0x1091f, 0x1091f, LBC::ba}, {0x10920, 0x10939, LBC::al}, {0x1093f, 0x10959, LBC::al},
	{0x10980, 0x109b7, LBC::al}, {0x109bc, 0x109cf, LBC::al}, {0x109d2, 0x10a00, LBC::al}, {0x10a01, 0x10a03, LBC::cm},
	{0x10a05, 0x10a06, LBC::cm}, {0x10a0c, 0x10a0f, LBC::cm}, {0x10a10, 0x10a13, LBC::al}, {0x10a15, 0x10a17, LBC::al},
	{0x10a19, 0x10a35, LBC::al}, {0x10a38, 0x10a3a, LBC::cm}, {0x10a3f, 0x10a3f, LBC::cm}, {0x10a40, 0x10a48, LBC::al},
	{0x10a50, 0x10a57, LBC::ba}, {0x10a58, 0x10a58, LBC::al}, {0x10a60, 0x10a9f, LBC::al}, {0x10ac0, 0x10ae4, LBC::al},
	{0x10ae5, 0x10ae6, LBC::cm}, {0x10aeb, 0x10aef, LBC::al}, {0x10af0, 0x10af5, LBC::ba}, {0x10af6, 0x10af6, LBC::in},
	{0x10b00, 0x10b35, LBC::al}, {0x10b39, 0x10b3f, LBC::ba}, {0x10b40, 0x10b55, LBC::al}, {0x10b58, 0x10b72, LBC::al},
	{0x10b78, 0x10b91, LBC::al}, {0x10b99, 0x10b9c, LBC::al}, {0x10ba9, 0x10baf, LBC::al}, {0x10c00, 0x10c48, LBC::al},
	{0x10c80, 0x10cb2, LBC::al}, {0x10cc0, 0x10cf2, LBC::al}, {0x10cfa, 0x10d23, LBC::al}, {0x10d24, 0x10d27, LBC::cm},
	{0x10d30, 0x10d39, LBC::nu}, {0x10d40, 0x10d49, LBC::nu}, {0x10d4a, 0x10d65, LBC::al}, {0x10d69, 0x10d6d, LBC::cm},
	{0x10d6e, 0x10d6e, LBC::hh}, {0x10d6f, 0x10d85, LBC::al}, {0x10d8e, 0x10d8f, LBC::al}, {0x10e60, 0x10e7e, LBC::al},
	{0x10e80, 0x10ea9, LBC::al}, {0x10eab, 0x10eac, LBC::cm}, {0x10ead, 0x10ead, LBC::hh}, {0x10eb0, 0x10eb1, LBC::al},
	{0x10ec2, 0x10ec7, LBC::al}, {0x10ed0, 0x10ed0, LBC::ba}, {0x10ed1, 0x10ed8, LBC::al}, {0x10efa, 0x10eff, LBC::cm},
	{0x10f00, 0x10f27, LBC::al}, {0x10f30, 0x10f45, LBC::al}, {0x10f46, 0x10f50, LBC::cm}, {0x10f51, 0x10f59, LBC::al},
	{0x10f70, 0x10f81, LBC::al}, {0x10f82, 0x10f85, LBC::cm}, {0x10f86, 0x10f89, LBC::al}, {0x10fb0, 0x10fcb, LBC::al},
	{0x10fe0, 0x10ff6, LBC::al}, {0x11000, 0x11002, LBC::cm}, {0x11003, 0x11004, LBC::ap}, {0x11005, 0x11037, LBC::ak},
	{0x11038, 0x11045, LBC::cm}, {0x11046, 0x11046, LBC::vi}, {0x11047, 0x11048, LBC::ba}, {0x11049, 0x1104d, LBC::id},
	{0x11052, 0x11065, LBC::id}, {0x11066, 0x1106f, LBC::as}, {0x11070, 0x11070, LBC::cm}, {0x11071, 0x11072, LBC::ak},
	{0x11073, 0x11074, LBC::cm}, {0x11075, 0x11075, LBC::ak}, {0x1107f, 0x1107f, LBC::gl}, {0x11080, 0x11082, LBC::cm},
	{0x11083, 0x110af, LBC::al}, {0x110b0, 0x110ba, LBC::cm}, {0x110bb, 0x110bc, LBC::al}, {0x110bd, 0x110bd, LBC::nu},
	{0x110be, 0x110c1, LBC::ba}, {0x110c2, 0x110c2, LBC::cm}, {0x110cd, 0x110cd, LBC::nu}, {0x110d0, 0x110e8, LBC::al},
	{0x110f0, 0x110f9, LBC::nu}, {0x11100, 0x11102, LBC::cm}, {0x11103, 0x11126, LBC::al}, {0x11127, 0x11134, LBC::cm},
	{0x11136, 0x1113f, LBC::nu}, {0x11140, 0x11143, LBC::ba}, {0x11144, 0x11144, LBC::al}, {0x11145, 0x11146, LBC::cm},
	{0x11147, 0x11147, LBC::al}, {0x11150, 0x11172, LBC::al}, {0x11173, 0x11173, LBC::cm}, {0x11174, 0x11174, LBC::al},
	{0x11175, 0x11175, LBC::bb}, {0x11176, 0x11176, LBC::al}, {0x11180, 0x11182, LBC::cm}, {0x11183, 0x111b2, LBC::al},
	{0x111b3, 0x111c0, LBC::cm}, {0x111c1, 0x111c4, LBC::al}, {0x111c5, 0x111c6, LBC::ba}, {0x111c7, 0x111c7, LBC::al},
	{0x111c8, 0x111c8, LBC::ba}, {0x111c9, 0x111cc, LBC::cm}, {0x111cd, 0x111cd, LBC::al}, {0x111ce, 0x111cf, LBC::cm},
	{0x111d0, 0x111d9, LBC::nu}, {0x111da, 0x111da, LBC::al}, {0x111db, 0x111db, LBC::bb}, {0x111dc, 0x111dc, LBC::al},
	{0x111dd, 0x111df, LBC::ba}, {0x111e1, 0x111f4, LBC::al}, {0x11200, 0x11211, LBC::al}, {0x11213, 0x1122b, LBC::al},
	{0x1122c, 0x11237, LBC::cm}, {0x11238, 0x11239, LBC::ba}, {0x1123a, 0x1123a, LBC::al}, {0x1123b, 0x1123c, LBC::ba},
	{0x1123d, 0x1123d, LBC::al}, {0x1123e, 0x1123e, LBC::cm}, {0x1123f, 0x11240, LBC::al}, {0x11241, 0x11241, LBC::cm},
	{0x11280, 0x11286, LBC::al}, {0x11288, 0x11288, LBC::al}, {0x1128a, 0x1128d, LBC::al}, {0x1128f, 0x1129d, LBC::al},
	{0x1129f, 0x112a8, LBC::al}, {0x112a9, 0x112a9, LBC::ba}, {0x112b0, 0x112de, LBC::al}, {0x112df, 0x112ea, LBC::cm},
	{0x112f0, 0x112f9, LBC::nu}, {0x11300, 0x11303, LBC::cm}, {0x11305, 0x1130c, LBC::ak}, {0x1130f, 0x11310, LBC::ak},
	{0x11313, 0x11328, LBC::ak}, {0x1132a, 0x11330, LBC::ak}, {0x11332, 0x11333, LBC::ak}, {0x11335, 0x11339, LBC::ak},
	{0x1133b, 0x1133c, LBC::cm}, {0x1133d, 0x1133d, LBC::ba}, {0x1133e, 0x11344, LBC::cm}, {0x11347, 0x11348, LBC::cm},
	{0x1134b, 0x1134c, LBC::cm}, {0x1134d, 0x1134d, LBC::vi}, {0x11350, 0x11350, LBC::as}, {0x11357, 0x11357, LBC::cm},
	{0x1135d, 0x1135d, LBC::ba}, {0x1135e, 0x1135f, LBC::as}, {0x11360, 0x11361, LBC::ak}, {0x11362, 0x11363, LBC::cm},
	{0x11366, 0x1136c, LBC::cm}, {0x11370, 0x11374, LBC::cm}, {0x11380, 0x11389, LBC::as}, {0x1138b, 0x1138b, LBC::as},
	{0x1138e, 0x1138e, LBC::as}, {0x11390, 0x11391, LBC::as}, {0x11392, 0x113b5, LBC::ak}, {0x113b7, 0x113b7, LBC::id},
	{0x113b8, 0x113c0, LBC::cm}, {0x113c2, 0x113c2, LBC::cm}, {0x113c5, 0x113c5, LBC::cm}, {0x113c7, 0x113ca, LBC::cm},
	{0x113cc, 0x113cf, LBC::cm}, {0x113d0, 0x113d0, LBC::vi}, {0x113d1, 0x113d1, LBC::ap}, {0x113d2, 0x113d2, LBC::cm},
	{0x113d3, 0x113d5, LBC::id}, {0x113d7, 0x113d8, LBC::id}, {0x113e1, 0x113e2, LBC::cm}, {0x11400, 0x11434, LBC::al},
	{0x11435, 0x11446, LBC::cm}, {0x11447, 0x1144a, LBC::al}, {0x1144b, 0x1144e, LBC::ba}, {0x1144f, 0x1144f, LBC::al},
	{0x11450, 0x11459, LBC::nu}, {0x1145a, 0x1145b, LBC::ba}, {0x1145d, 0x1145d, LBC::al}, {0x1145e, 0x1145e, LBC::cm},
	{0x1145f, 0x11461, LBC::al}, {0x11480, 0x114af, LBC::al}, {0x114b0, 0x114c3, LBC::cm}, {0x114c4, 0x114c7, LBC::al},
	{0x114d0, 0x114d9, LBC::nu}, {0x11580, 0x115ae, LBC::al}, {0x115af, 0x115b5, LBC::cm}, {0x115b8, 0x115c0, LBC::cm},
	{0x115c1, 0x115c1, LBC::bb}, {0x115c2, 0x115c3, LBC::ba}, {0x115c4, 0x115c5, LBC::ex}, {0x115c6, 0x115c8, LBC::al},
	{0x115c9, 0x115d7, LBC::ba}, {0x115d8, 0x115db, LBC::al}, {0x115dc, 0x115dd, LBC::cm}, {0x11600, 0x1162f, LBC::al},
	{0x11630, 0x11640, LBC::cm}, {0x11641, 0x11642, LBC::ba}, {0x11643, 0x11644, LBC::al}, {0x11650, 0x11659, LBC::nu},
	{0x11660, 0x1166c, LBC::bb}, {0x11680, 0x116aa, LBC::al}, {0x116ab, 0x116b7, LBC::cm}, {0x116b8, 0x116b9, LBC::al},
	{0x116c0, 0x116c9, LBC::nu}, {0x116d0, 0x116e3, LBC::nu}, {0x11700, 0x1171a, LBC::sa}, {0x1171d, 0x1172b, LBC::sa},
	{0x11730, 0x11739, LBC::nu}, {0x1173a, 0x1173b, LBC::sa}, {0x1173c, 0x1173e, LBC::ba}, {0x1173f, 0x11746, LBC::sa},
	{0x11800, 0x1182b, LBC::al}, {0x1182c, 0x1183a, LBC::cm}, {0x1183b, 0x1183b, LBC::al}, {0x118a0, 0x118df, LBC::al},
	{0x118e0, 0x118e9, LBC::nu}, {0x118ea, 0x118f2, LBC::al}, {0x118ff, 0x118ff, LBC::al}, {0x11900, 0x11906, LBC::ak},
	{0x11909, 0x11909, LBC::ak}, {0x1190c, 0x11913, LBC::ak}, {0x11915, 0x11916, LBC::ak}, {0x11918, 0x1192f, LBC::ak},
	{0x11930, 0x11935, LBC::cm}, {0x11937, 0x11938, LBC::cm}, {0x1193b, 0x1193d, LBC::cm}, {0x1193e, 0x1193e, LBC::vi},
	{0x1193f, 0x1193f, LBC::ap}, {0x11940, 0x11940, LBC::cm}, {0x11941, 0x11941, LBC::ap}, {0x11942, 0x11943, LBC::cm},
	{0x11944, 0x11946, LBC::ba}, {0x11950, 0x11959, LBC::as}, {0x119a0, 0x119a7, LBC::al}, {0x119aa, 0x119d0, LBC::al},
	{0x119d1, 0x119d7, LBC::cm}, {0x119da, 0x119e0, LBC::cm}, {0x119e1, 0x119e1, LBC::al}, {0x119e2, 0x119e2, LBC::bb},
	{0x119e3, 0x119e3, LBC::al}, {0x119e4, 0x119e4, LBC::cm}, {0x11a00, 0x11a00, LBC::al}, {0x11a01, 0x11a0a, LBC::cm},
	{0x11a0b, 0x11a32, LBC::al}, {0x11a33, 0x11a39, LBC::cm}, {0x11a3a, 0x11a3a, LBC::al}, {0x11a3b, 0x11a3e, LBC::cm},
	{0x11a3f, 0x11a3f, LBC::bb}, {0x11a40, 0x11a40, LBC::al}, {0x11a41, 0x11a44, LBC::ba}, {0x11a45, 0x11a45, LBC::bb},
	{0x11a46, 0x11a46, LBC::al}, {0x11a47, 0x11a47, LBC::cm}, {0x11a50, 0x11a50, LBC::al}, {0x11a51, 0x11a5b, LBC::cm},
	{0x11a5c, 0x11a89, LBC::al}, {0x11a8a, 0x11a99, LBC::cm}, {0x11a9a, 0x11a9c, LBC::ba}, {0x11a9d, 0x11a9d, LBC::al},
	{0x11a9e, 0x11aa0, LBC::bb}, {0x11aa1, 0x11aa2, LBC::ba}, {0x11ab0, 0x11af8, LBC::al}, {0x11b00, 0x11b09, LBC::bb},
	{0x11b60, 0x11b67, LBC::cm}, {0x11bc0, 0x11be1, LBC::al}, {0x11bf0, 0x11bf9, LBC::nu}, {0x11c00, 0x11c08, LBC::al},
	{0x11c0a, 0x11c2e, LBC::al}, {0x11c2f, 0x11c36, LBC::cm}, {0x11c38, 0x11c3f, LBC::cm}, {0x11c40, 0x11c40, LBC::al},
	{0x11c41, 0x11c45, LBC::ba}, {0x11c50, 0x11c59, LBC::nu}, {0x11c5a, 0x11c6c, LBC::al}, {0x11c70, 0x11c70, LBC::bb},
	{0x11c71, 0x11c71, LBC::ex}, {0x11c72, 0x11c8f, LBC::al}, {0x11c92, 0x11ca7, LBC::cm}, {0x11ca9, 0x11cb6, LBC::cm},
	{0x11d00, 0x11d06, LBC::al}, {0x11d08, 0x11d09, LBC::al}, {0x11d0b, 0x11d30, LBC::al}, {0x11d31, 0x11d36, LBC::cm},
	{0x11d3a, 0x11d3a, LBC::cm}, {0x11d3c, 0x11d3d, LBC::cm}, {0x11d3f, 0x11d45, LBC::cm}, {0x11d46, 0x11d46, LBC::al},
	{0x11d47, 0x11d47, LBC::cm}, {0x11d50, 0x11d59, LBC::nu}, {0x11d60, 0x11d65, LBC::al}, {0x11d67, 0x11d68, LBC::al},
	{0x11d6a, 0x11d89, LBC::al}, {0x11d8a, 0x11d8e, LBC::cm}, {0x11d90, 0x11d91, LBC::cm}, {0x11d93, 0x11d97, LBC::cm},
	{0x11d98, 0x11d98, LBC::al}, {0x11da0, 0x11da9, LBC::nu}, {0x11db0, 0x11ddb, LBC::al}, {0x11de0, 0x11de9, LBC::nu},
	{0x11ee0, 0x11ef1, LBC::as}, {0x11ef2, 0x11ef2, LBC::ba}, {0x11ef3, 0x11ef6, LBC::cm}, {0x11ef7, 0x11ef8, LBC::ba},
	{0x11f00, 0x11f01, LBC::cm}, {0x11f02, 0x11f02, LBC::ap}, {0x11f03, 0x11f03, LBC::cm}, {0x11f04, 0x11f10, LBC::ak},
	{0x11f12, 0x11f33, LBC::ak}, {0x11f34, 0x11f3a, LBC::cm}, {0x11f3e, 0x11f41, LBC::cm}, {0x11f42, 0x11f42, LBC::vi},
	{0x11f43, 0x11f44, LBC::ba}, {0x11f45, 0x11f4f, LBC::id}, {0x11f50, 0x11f59, LBC::as}, {0x11f5a, 0x11f5a, LBC::cm},
	{0x11fb0, 0x11fb0, LBC::al}, {0x11fc0, 0x11fdc, LBC::al}, {0x11fdd, 0x11fe0, LBC::po}, {0x11fe1, 0x11ff1, LBC::al},
	{0x11fff, 0x11fff, LBC::ba}, {0x12000, 0x12399, LBC::al}, {0x12400, 0x1246e, LBC::al}, {0x12470, 0x12474, LBC::ba},
	{0x12480, 0x12543, LBC::al}, {0x12f90, 0x12ff2, LBC::al}, {0x13000, 0x13257, LBC::al}, {0x13258, 0x1325a, LBC::op},
	{0x1325b, 0x1325d, LBC::cl}, {0x1325e, 0x13281, LBC::al}, {0x13282, 0x13282, LBC::cl}, {0x13283, 0x13285, LBC::al},
	{0x13286, 0x13286, LBC::op}, {0x13287, 0x13287, LBC::cl}, {0x13288, 0x13288, LBC::op}, {0x13289, 0x13289, LBC::cl},
	{0x1328a, 0x13378, LBC::al}, {0x13379, 0x13379, LBC::op}, {0x1337a, 0x1337b, LBC::cl}, {0x1337c, 0x1342e, LBC::al},
	{0x1342f, 0x1342f, LBC::op}, {0x13430, 0x13436, LBC::gl}, {0x13437, 0x13437, LBC::op}, {0x13438, 0x13438, LBC::cl},
	{0x13439, 0x1343b, LBC::gl}, {0x1343c, 0x1343c, LBC::op}, {0x1343d, 0x1343d, LBC::cl}, {0x1343e, 0x1343e, LBC::op},
	{0x1343f, 0x1343f, LBC::cl}, {0x13440, 0x13440, LBC::cm}, {0x13441, 0x13446, LBC::al}, {0x13447, 0x13455, LBC::cm},
	{0x13460, 0x143fa, LBC::al}, {0x14400, 0x145cd, LBC::al}, {0x145ce, 0x145ce, LBC::op}, {0x145cf, 0x145cf, LBC::cl},
	{0x145d0, 0x14646, LBC::al}, {0x16100, 0x1611d, LBC::as}, {0x1611e, 0x1612f, LBC::cm}, {0x16130, 0x16139, LBC::as},
	{0x16800, 0x16a38, LBC::al}, {0x16a40, 0x16a5e, LBC::al}, {0x16a60, 0x16a69, LBC::nu}, {0x16a6e, 0x16a6f, LBC::ba},
	{0x16a70, 0x16abe, LBC::al}, {0x16ac0, 0x16ac9, LBC::nu}, {0x16ad0, 0x16aed, LBC::al}, {0x16af0, 0x16af4, LBC::cm},
	{0x16af5, 0x16af5, LBC::ba}, {0x16b00, 0x16b2f, LBC::al}, {0x16b30, 0x16b36, LBC::cm}, {0x16b37, 0x16b39, LBC::ba},
	{0x16b3a, 0x16b43, LBC::al}, {0x16b44, 0x16b44, LBC::ba}, {0x16b45, 0x16b45, LBC::al}, {0x16b50, 0x16b59, LBC::nu},
	{0x16b5b, 0x16b61, LBC::al}, {0x16b63, 0x16b77, LBC::al}, {0x16b7d, 0x16b8f, LBC::al}, {0x16d40, 0x16d6d, LBC::al},
	{0x16d6e, 0x16d6f, LBC::ba}, {0x16d70, 0x16d79, LBC::nu}, {0x16e40, 0x16e96, LBC::al}, {0x16e97, 0x16e98, LBC::ba},
	{0x16e99, 0x16e9a, LBC::al}, {0x16ea0, 0x16eb8, LBC::al}, {0x16ebb, 0x16ed3, LBC::al}, {0x16f00, 0x16f4a, LBC::al},
	{0x16f4f, 0x16f4f, LBC::cm}, {0x16f50, 0x16f50, LBC::al}, {0x16f51, 0x16f87, LBC::cm}, {0x16f8f, 0x16f92, LBC::cm},
	{0x16f93, 0x16f9f, LBC::al}, {0x16fe0, 0x16fe3, LBC::ns}, {0x16fe4, 0x16fe4, LBC::gl}, {0x16ff0, 0x16ff1, LBC::cm},
	{0x16ff2, 0x16ff3, LBC::ns}, {0x16ff4, 0x16ff6, LBC::id}, {0x17000, 0x18aff, LBC::id}, {0x18b00, 0x18cd5, LBC::al},
	{0x18cff, 0x18cff, LBC::al}, {0x18d00, 0x18d1e, LBC::id}, {0x18d80, 0x18df2, LBC::id}, {0x1aff0, 0x1aff3, LBC::al},
	{0x1aff5, 0x1affb, LBC::al}, {0x1affd, 0x1affe, LBC::al}, {0x1b000, 0x1b122, LBC::id}, {0x1b132, 0x1b132, LBC::cj},
	{0x1b150, 0x1b152, LBC::cj}, {0x1b155, 0x1b155, LBC::cj}, {0x1b164, 0x1b167, LBC::cj}, {0x1b170, 0x1b2fb, LBC::id},
	{0x1bc00, 0x1bc6a, LBC::al}, {0x1bc70, 0x1bc7c, LBC::al}, {0x1bc80, 0x1bc88, LBC::al}, {0x1bc90, 0x1bc99, LBC::al},
	{0x1bc9c, 0x1bc9c, LBC::al}, {0x1bc9d, 0x1bc9e, LBC::cm}, {0x1bc9f, 0x1bc9f, LBC::ba}, {0x1bca0, 0x1bca3, LBC::cm},
	{0x1cc00, 0x1ccef, LBC::al}, {0x1ccf0, 0x1ccf9, LBC::nu}, {0x1ccfa, 0x1ccfc, LBC::al}, {0x1cd00, 0x1ceb3, LBC::al},
	{0x1ceba, 0x1ced0, LBC::al}, {0x1cee0, 0x1cef0, LBC::al}, {0x1cf00, 0x1cf2d, LBC::cm}, {0x1cf30, 0x1cf46, LBC::cm},
	{0x1cf50, 0x1cfc3, LBC::al}, {0x1d000, 0x1d0f5, LBC::al}, {0x1d100, 0x1d126, LBC::al}, {0x1d129, 0x1d164, LBC::al},
	{0x1d165, 0x1d169, LBC::cm}, {0x1d16a, 0x1d16c, LBC::al}, {0x1d16d, 0x1d182, LBC::cm}, {0x1d183, 0x1d184, LBC::al},
	{0x1d185, 0x1d18b, LBC::cm}, {0x1d18c, 0x1d1a9, LBC::al}, {0x1d1aa, 0x1d1ad, LBC::cm}, {0x1d1ae, 0x1d1ea, LBC::al},
	{0x1d200, 0x1d241, LBC::al}, {0x1d242, 0x1d244, LBC::cm}, {0x1d245, 0x1d245, LBC::al}, {0x1d2c0, 0x1d2d3, LBC::al},
	{0x1d2e0, 0x1d2f3, LBC::al}, {0x1d300, 0x1d356, LBC::al}, {0x1d360, 0x1d378, LBC::al}, {0x1d400, 0x1d454, LBC::al},
	{0x1d456, 0x1d49c, LBC::al}, {0x1d49e, 0x1d49f, LBC::al}, {0x1d4a2, 0x1d4a2, LBC::al}, {0x1d4a5, 0x1d4a6, LBC::al},
	{0x1d4a9, 0x1d4ac, LBC::al}, {0x1d4ae, 0x1d4b9, LBC::al}, {0x1d4bb, 0x1d4bb, LBC::al}, {0x1d4bd, 0x1d4c3, LBC::al},
	{0x1d4c5, 0x1d505, LBC::al}, {0x1d507, 0x1d50a, LBC::al}, {0x1d50d, 0x1d514, LBC::al}, {0x1d516, 0x1d51c, LBC::al},
	{0x1d51e, 0x1d539, LBC::al}, {0x1d53b, 0x1d53e, LBC::al}, {0x1d540, 0x1d544, LBC::al}, {0x1d546, 0x1d546, LBC::al},
	{0x1d54a, 0x1d550, LBC::al}, {0x1d552, 0x1d6a5, LBC::al}, {0x1d6a8, 0x1d7cb, LBC::al}, {0x1d7ce, 0x1d7ff, LBC::nu},
	{0x1d800, 0x1d9ff, LBC::al}, {0x1da00, 0x1da36, LBC::cm}, {0x1da37, 0x1da3a, LBC::al}, {0x1da3b, 0x1da6c, LBC::cm},
	{0x1da6d, 0x1da74, LBC::al}, {0x1da75, 0x1da75, LBC::cm}, {0x1da76, 0x1da83, LBC::al}, {0x1da84, 0x1da84, LBC::cm},
	{0x1da85, 0x1da86, LBC::al}, {0x1da87, 0x1da8a, LBC::ba}, {0x1da8b, 0x1da8b, LBC::al}, {0x1da9b, 0x1da9f, LBC::cm},
	{0x1daa1, 0x1daaf, LBC::cm}, {0x1df00, 0x1df1e, LBC::al}, {0x1df25, 0x1df2a, LBC::al}, {0x1e000, 0x1e006, LBC::cm},
	{0x1e008, 0x1e018, LBC::cm}, {0x1e01b, 0x1e021, LBC::cm}, {0x1e023, 0x1e024, LBC::cm}, {0x1e026, 0x1e02a, LBC::cm},
	{0x1e030, 0x1e06d, LBC::al}, {0x1e08f, 0x1e08f, LBC::cm}, {0x1e100, 0x1e12c, LBC::al}, {0x1e130, 0x1e136, LBC::cm},
	{0x1e137, 0x1e13d, LBC::al}, {0x1e140, 0x1e149, LBC::nu}, {0x1e14e, 0x1e14f, LBC::al}, {0x1e290, 0x1e2ad, LBC::al},
	{0x1e2ae, 0x1e2ae, LBC::cm}, {0x1e2c0, 0x1e2eb, LBC::al}, {0x1e2ec, 0x1e2ef, LBC::cm}, {0x1e2f0, 0x1e2f9, LBC::nu},
	{0x1e2ff, 0x1e2ff, LBC::pr}, {0x1e4d0, 0x1e4eb, LBC::al}, {0x1e4ec, 0x1e4ef, LBC::cm}, {0x1e4f0, 0x1e4f9, LBC::nu},
	{0x1e5d0, 0x1e5ed, LBC::al}, {0x1e5ee, 0x1e5ef, LBC::cm}, {0x1e5f0, 0x1e5f0, LBC::al}, {0x1e5f1, 0x1e5fa, LBC::nu},
	{0x1e5ff, 0x1e5ff, LBC::al}, {0x1e6c0, 0x1e6de, LBC::al}, {0x1e6e0, 0x1e6e2, LBC::al}, {0x1e6e3, 0x1e6e3, LBC::cm},
	{0x1e6e4, 0x1e6e5, LBC::al}, {0x1e6e6, 0x1e6e6, LBC::cm}, {0x1e6e7, 0x1e6ed, LBC::al}, {0x1e6ee, 0x1e6ef, LBC::cm},
	{0x1e6f0, 0x1e6f4, LBC::al}, {0x1e6f5, 0x1e6f5, LBC::cm}, {0x1e6fe, 0x1e6ff, LBC::al}, {0x1e7e0, 0x1e7e6, LBC::al},
	{0x1e7e8, 0x1e7eb, LBC::al}, {0x1e7ed, 0x1e7ee, LBC::al}, {0x1e7f0, 0x1e7fe, LBC::al}, {0x1e800, 0x1e8c4, LBC::al},
	{0x1e8c7, 0x1e8cf, LBC::al}, {0x1e8d0, 0x1e8d6, LBC::cm}, {0x1e900, 0x1e943, LBC::al}, {0x1e944, 0x1e94a, LBC::cm},
	{0x1e94b, 0x1e94b, LBC::al}, {0x1e950, 0x1e959, LBC::nu}, {0x1e95e, 0x1e95f, LBC::op}, {0x1ec71, 0x1ecab, LBC::al},
	{0x1ecac, 0x1ecac, LBC::po}, {0x1ecad, 0x1ecaf, LBC::al}, {0x1ecb0, 0x1ecb0, LBC::po}, {0x1ecb1, 0x1ecb4, LBC::al},
	{0x1ed01, 0x1ed3d, LBC::al}, {0x1ee00, 0x1ee03, LBC::al}, {0x1ee05, 0x1ee1f, LBC::al}, {0x1ee21, 0x1ee22, LBC::al},
	{0x1ee24, 0x1ee24, LBC::al}, {0x1ee27, 0x1ee27, LBC::al}, {0x1ee29, 0x1ee32, LBC::al}, {0x1ee34, 0x1ee37, LBC::al},
	{0x1ee39, 0x1ee39, LBC::al}, {0x1ee3b, 0x1ee3b, LBC::al}, {0x1ee42, 0x1ee42, LBC::al}, {0x1ee47, 0x1ee47, LBC::al},
	{0x1ee49, 0x1ee49, LBC::al}, {0x1ee4b, 0x1ee4b, LBC::al}, {0x1ee4d, 0x1ee4f, LBC::al}, {0x1ee51, 0x1ee52, LBC::al},
	{0x1ee54, 0x1ee54, LBC::al}, {0x1ee57, 0x1ee57, LBC::al}, {0x1ee59, 0x1ee59, LBC::al}, {0x1ee5b, 0x1ee5b, LBC::al},
	{0x1ee5d, 0x1ee5d, LBC::al}, {0x1ee5f, 0x1ee5f, LBC::al}, {0x1ee61, 0x1ee62, LBC::al}, {0x1ee64, 0x1ee64, LBC::al},
	{0x1ee67, 0x1ee6a, LBC::al}, {0x1ee6c, 0x1ee72, LBC::al}, {0x1ee74, 0x1ee77, LBC::al}, {0x1ee79, 0x1ee7c, LBC::al},
	{0x1ee7e, 0x1ee7e, LBC::al}, {0x1ee80, 0x1ee89, LBC::al}, {0x1ee8b, 0x1ee9b, LBC::al}, {0x1eea1, 0x1eea3, LBC::al},
	{0x1eea5, 0x1eea9, LBC::al}, {0x1eeab, 0x1eebb, LBC::al}, {0x1eef0, 0x1eef1, LBC::al}, {0x1f000, 0x1f0ff, LBC::id},
	{0x1f100, 0x1f10c, LBC::ai}, {0x1f10d, 0x1f10f, LBC::al}, {0x1f110, 0x1f12d, LBC::ai}, {0x1f12e, 0x1f12f, LBC::al},
	{0x1f130, 0x1f169, LBC::ai}, {0x1f16a, 0x1f16f, LBC::al}, {0x1f170, 0x1f1ac, LBC::ai}, {0x1f1ad, 0x1f1ad, LBC::al},
	{0x1f1ae, 0x1f1e5, LBC::id}, {0x1f1e6, 0x1f1ff, LBC::ri}, {0x1f200, 0x1f384, LBC::id}, {0x1f385, 0x1f385, LBC::eb},
	{0x1f386, 0x1f39b, LBC::id}, {0x1f39c, 0x1f39d, LBC::al}, {0x1f39e, 0x1f3b4, LBC::id}, {0x1f3b5, 0x1f3b6, LBC::al},
	{0x1f3b7, 0x1f3bb, LBC::id}, {0x1f3bc, 0x1f3bc, LBC::al}, {0x1f3bd, 0x1f3c1, LBC::id}, {0x1f3c2, 0x1f3c4, LBC::eb},
	{0x1f3c5, 0x1f3c6, LBC::id}, {0x1f3c7, 0x1f3c7, LBC::eb}, {0x1f3c8, 0x1f3c9, LBC::id}, {0x1f3ca, 0x1f3cc, LBC::eb},
	{0x1f3cd, 0x1f3fa, LBC::id}, {0x1f3fb, 0x1f3ff, LBC::em}, {0x1f400, 0x1f441, LBC::id}, {0x1f442, 0x1f443, LBC::eb},
	{0x1f444, 0x1f445, LBC::id}, {0x1f446, 0x1f450, LBC::eb}, {0x1f451, 0x1f465, LBC::id}, {0x1f466, 0x1f478, LBC::eb},
	{0x1f479, 0x1f47b, LBC::id}, {0x1f47c, 0x1f47c, LBC::eb}, {0x1f47d, 0x1f480, LBC::id}, {0x1f481, 0x1f483, LBC::eb},
	{0x1f484, 0x1f484, LBC::id}, {0x1f485, 0x1f487, LBC::eb}, {0x1f488, 0x1f48e, LBC::id}, {0x1f48f, 0x1f48f, LBC::eb},
	{0x1f490, 0x1f490, LBC::id}, {0x1f491, 0x1f491, LBC::eb}, {0x1f492, 0x1f49f, LBC::id}, {0x1f4a0, 0x1f4a0, LBC::al},
	{0x1f4a1, 0x1f4a1, LBC::id}, {0x1f4a2, 0x1f4a2, LBC::al}, {0x1f4a3, 0x1f4a3, LBC::id}, {0x1f4a4, 0x1f4a4, LBC::al},
	{0x1f4a5, 0x1f4a9, LBC::id}, {0x1f4aa, 0x1f4aa, LBC::eb}, {0x1f4ab, 0x1f4ae, LBC::id}, {0x1f4af, 0x1f4af, LBC::al},
	{0x1f4b0, 0x1f4b0, LBC::id}, {0x1f4b1, 0x1f4b2, LBC::al}, {0x1f4b3, 0x1f4ff, LBC::id}, {0x1f500, 0x1f506, LBC::al},
	{0x1f507, 0x1f516, LBC::id}, {0x1f517, 0x1f524, LBC::al}, {0x1f525, 0x1f531, LBC::id}, {0x1f532, 0x1f549, LBC::al},
	{0x1f54a, 0x1f573, LBC::id}, {0x1f574, 0x1f575, LBC::eb}, {0x1f576, 0x1f579, LBC::id}, {0x1f57a, 0x1f57a, LBC::eb},
	{0x1f57b, 0x1f58f, LBC::id}, {0x1f590, 0x1f590, LBC::eb}, {0x1f591, 0x1f594, LBC::id}, {0x1f595, 0x1f596, LBC::eb},
	{0x1f597, 0x1f5d3, LBC::id}, {0x1f5d4, 0x1f5db, LBC::al}, {0x1f5dc, 0x1f5f3, LBC::id}, {0x1f5f4, 0x1f5f9, LBC::al},
	{0x1f5fa, 0x1f644, LBC::id}, {0x1f645, 0x1f647, LBC::eb}, {0x1f648, 0x1f64a, LBC::id}, {0x1f64b, 0x1f64f, LBC::eb},
	{0x1f650, 0x1f675, LBC::al}, {0x1f676, 0x1f678, LBC::qu}, {0x1f679, 0x1f67b, LBC::ns}, {0x1f67c, 0x1f67f, LBC::al},
	{0x1f680, 0x1f6a2, LBC::id}, {0x1f6a3, 0x1f6a3, LBC::eb}, {0x1f6a4, 0x1f6b3, LBC::id}, {0x1f6b4, 0x1f6b6, LBC::eb},
	{0x1f6b7, 0x1f6bf, LBC::id}, {0x1f6c0, 0x1f6c0, LBC::eb}, {0x1f6c1, 0x1f6cb, LBC::id}, {0x1f6cc, 0x1f6cc, LBC::eb},
	{0x1f6cd, 0x1f6ff, LBC::id}, {0x1f700, 0x1f773, LBC::al}, {0x1f774, 0x1f776, LBC::id}, {0x1f777, 0x1f77a, LBC::al},
	{0x1f77b, 0x1f77f, LBC::id}, {0x1f780, 0x1f7d4, LBC::al}, {0x1f7d5, 0x1f7ff, LBC::id}, {0x1f800, 0x1f80b, LBC::al},
	{0x1f810, 0x1f847, LBC::al}, {0x1f850, 0x1f859, LBC::al}, {0x1f860, 0x1f887, LBC::al}, {0x1f890, 0x1f8ad, LBC::al},
	{0x1f8b0, 0x1f8bb, LBC::al}, {0x1f8c0, 0x1f8c1, LBC::al}, {0x1f8d0, 0x1f8d8, LBC::al}, {0x1f900, 0x1f90b, LBC::al},
	{0x1f90c, 0x1f90c, LBC::eb}, {0x1f90d, 0x1f90e, LBC::id}, {0x1f90f, 0x1f90f, LBC::eb}, {0x1f910, 0x1f917, LBC::id},
	{0x1f918, 0x1f91f, LBC::eb}, {0x1f920, 0x1f925, LBC::id}, {0x1f926, 0x1f926, LBC::eb}, {0x1f927, 0x1f92f, LBC::id},
	{0x1f930, 0x1f939, LBC::eb}, {0x1f93a, 0x1f93b, LBC::id}, {0x1f93c, 0x1f93e, LBC::eb}, {0x1f93f, 0x1f976, LBC::id},
	{0x1f977, 0x1f977, LBC::eb}, {0x1f978, 0x1f9b4, LBC::id}, {0x1f9b5, 0x1f9b6, LBC::eb}, {0x1f9b7, 0x1f9b7, LBC::id},
	{0x1f9b8, 0x1f9b9, LBC::eb}, {0x1f9ba, 0x1f9ba, LBC::id}, {0x1f9bb, 0x1f9bb, LBC::eb}, {0x1f9bc, 0x1f9cc, LBC::id},
	{0x1f9cd, 0x1f9cf, LBC::eb}, {0x1f9d0, 0x1f9d0, LBC::id}, {0x1f9d1, 0x1f9dd, LBC::eb}, {0x1f9de, 0x1f9ff, LBC::id},
	{0x1fa00, 0x1fa57, LBC::al}, {0x1fa58, 0x1fac2, LBC::id}, {0x1fac3, 0x1fac5, LBC::eb}, {0x1fac6, 0x1faef, LBC::id},
	{0x1faf0, 0x1faf8, LBC::eb}, {0x1faf9, 0x1faff, LBC::id}, {0x1fb00, 0x1fb92, LBC::al}, {0x1fb94, 0x1fbef, LBC::al},
	{0x1fbf0, 0x1fbf9, LBC::nu}, {0x1fbfa, 0x1fbfa, LBC::al}, {0x1fc00, 0x1fffd, LBC::id}, {0x20000, 0x2fffd, LBC::id},
	{0x30000, 0x3fffd, LBC::id}, {0xe0001, 0xe0001, LBC::cm}, {0xe0020, 0xe007f, LBC::cm}, {0xe0100, 0xe01ef, LBC::cm},
	{0xf0000, 0xffffd, LBC::xx}, {0x100000, 0x10fffd, LBC::xx}
};

#endif


//
//	lineBreakRangeFind
//

template <typename T, typename C>
LBC lineBreakRangeFind(const T& table, C codepoint) {
	auto low = std::begin(table);
	auto high = std::end(table);

	while (low <= high) {
		auto mid = low + (high - low) / 2;

		if (codepoint >= mid->low && codepoint <= mid->high) {
			return mid->lbc;

		} else if (codepoint < mid->low) {
			high = mid - 1;

		} else {
			low = mid + 1;
		}
	}

	return LBC::undefined;
}


//
//	getLineBreakClass
//

static LBC getLineBreakClass(ImWchar codepoint) {
	LBC lbc;

	// handle simple 8-bit ASCII codepoints
	if (codepoint < 256) {
		return lineBreak8[codepoint];
	}

#if defined(IMGUI_USE_WCHAR32)
	if (codepoint >= 0x10000) {
		lbc = lineBreakRangeFind(lineBreak32, static_cast<char32_t>(codepoint));

	} else
#endif

	{
		lbc = lineBreakRangeFind(lineBreak16, static_cast<char16_t>(codepoint));
	}

	if (lbc == LBC::undefined) {
		if ((codepoint >= 0x3400 && codepoint <= 0x4DBF) ||
			(codepoint >= 0x4E00 && codepoint <= 0x9FFF) ||
			(codepoint >= 0xF900 && codepoint <= 0xFAFF)

#if defined(IMGUI_USE_WCHAR32)
			||
			(codepoint >= 0x20000 && codepoint <= 0x2FFFD) ||
			(codepoint >= 0x30000 && codepoint <= 0x3FFFD) ||

			(codepoint >= 0x1F000 && codepoint <= 0x1FAFF) ||
			(codepoint >= 0x1FC00 && codepoint <= 0x1FFFD)
#endif
		) {

			lbc = LBC::id;

		} else if (codepoint >= 0x20A0 && codepoint <= 0x20CF) {
			lbc = LBC::pr;

		} else {
			lbc = LBC::xx;
		}
	}

	// LB1: assign a line breaking class to each code point of the input
	// resolve AI, CB, CJ, SA, SG, and XX into other line breaking classes
	if (lbc == LBC::ai || lbc == LBC::sg || lbc == LBC::xx) {
		lbc = LBC::al;

	} else if (lbc == LBC::sa) {
		lbc = LBC::al;

	} else if (lbc == LBC::cj) {
		lbc = LBC::ns;
	}

	return lbc;
}


//
//	State machine status
//

static constexpr size_t invalidPos = std::numeric_limits<size_t>::max();
static constexpr ImWchar dotCircle = 0x25CC;

struct LineBreakGlyph {
	LineBreakGlyph() = default;
	LineBreakGlyph(ImWchar codepoint, LBC cls, size_t pos) : codepoint(codepoint), cls(cls), pos(pos) {}
	ImWchar codepoint = 0;
	LBC cls = LBC::sot;
	size_t pos = invalidPos;
	bool ignored = false;
};

struct LineBreakState {
	TextEditor::Glyph* glyphs;
	size_t size;
	LineBreakGlyph previous;
	LineBreakGlyph current;
	LineBreakGlyph next;
	bool spaces = false;
	bool lb8 = false;
	size_t ri = 0;

	// move to the next state
	inline void push(const LineBreakGlyph& step) {
		if (next.ignored) {
			current.pos = next.pos;

		} else {
			previous = current;
			current = next;
		}

		next = step;
	}

	// get the codepoint at specified location
	ImWchar getCodepoint(size_t pos) const {
		if (pos < size) {
			return glyphs[pos].codepoint;

		} else {
			return 0;
		}
	}

	// get the line break class at specified location
	LBC getClass(size_t pos) const {
		if (pos < size) {
			return getLineBreakClass(glyphs[pos].codepoint);

		} else {
			return LBC::eot;
		}
	}
};


//
//	Support functions
//

static inline bool isPf(ImWchar codepoint) {
	if (codepoint < 0x00bb) {
		return false;

	} else {
		static std::unordered_set<ImWchar> Pf = {
			0x00bb, 0x2019, 0x201d, 0x203a, 0x2e03, 0x2e05, 0x2e0a, 0x2e0d, 0x2e1d, 0x2e21
		};

		return Pf.find(codepoint) != Pf.end();
	}
}


static inline bool isPi(ImWchar codepoint) {
	if (codepoint < 0x00ab) {
		return false;

	} else {
		static std::unordered_set<ImWchar> Pi = {
			0x00ab, 0x2018, 0x201b, 0x201c, 0x201f, 0x2039, 0x2e02, 0x2e04, 0x2e09, 0x2e0c, 0x2e1c, 0x2e20
		};

		return Pi.find(codepoint) != Pi.end();
	}
}


static inline bool isAkCircleAs(const LineBreakGlyph& lbg) {
	return (lbg.cls == LBC::ak) || (lbg.codepoint == 0x25CC) || (lbg.cls == LBC::as);
}


//
//	Line break rules
//
//	Partly ported from on https://github.com/cto-af/linebreak
//

static inline TextEditor::BreakOption lb2(const LineBreakState& state) {
	// LB2: never break at the start of text
	// sot ×
	if (state.current.cls == LBC::sot && state.next.cls != LBC::eot) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb3(const LineBreakState& state) {
	// LB3: always break at the end of text
	// ! eot
	if (state.next.cls == LBC::eot) {
		return TextEditor::BreakOption::mustBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb4(const LineBreakState& state) {
	// LB4: always break after hard line breaks
	// BK !
	if (state.current.cls == LBC::bk) {
		return TextEditor::BreakOption::mustBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb5(const LineBreakState& state) {
	// LB5: treat CR followed by LF, as well as CR, LF, and NL as hard line breaks
	// CR × LF
	// CR !
	// LF !
	// NL !
	switch (state.current.cls) {
		case LBC::cr:
			if (state.next.cls == LBC::lf) {
				return TextEditor::BreakOption::noBreak;
			}

			return TextEditor::BreakOption::mustBreak;

		case LBC::lf:
		case LBC::nl:
			return TextEditor::BreakOption::mustBreak;

		default:
			return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb6(const LineBreakState& state) {
	// LB6: do not break before hard line breaks
	// × ( BK | CR | LF | NL )
	switch (state.next.cls) {
		case LBC::bk:
		case LBC::cr:
		case LBC::lf:
		case LBC::nl:
			return TextEditor::BreakOption::noBreak;

		default:
			return TextEditor::BreakOption::undefined;
	}
}

static inline TextEditor::BreakOption lbSpaceStop(LineBreakState& state) {
	// for rules that have "do not break within even with intervening spaces", such as LB15
	if (state.current.cls != LBC::ri) {
		state.ri = 0;
	}

	if (state.spaces) {
		if (state.next.cls != LBC::sp) {
			state.spaces = false;
		}

		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb7(const LineBreakState& state) {
	// LB7: do not break before spaces or zero width space
	// × ZW
	if (state.next.cls == LBC::zw) {
		return TextEditor::BreakOption::noBreak;
	}

	// × SP
	if (state.next.cls == LBC::sp) {
		switch (state.current.cls) {
			case LBC::zw: // see LB8
			case LBC::op: // see LB14
			case LBC::qu: // see LB15
			case LBC::cl: // see LB16
			case LBC::cp: // see LB16
			case LBC::b2: // see LB17
				break;

			default:
				return TextEditor::BreakOption::noBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb8(LineBreakState& state) {
	// LB8: break before any character following a zero-width space, even if one or more spaces intervene
	// ZW SP* ÷
	if (state.lb8) {
		state.lb8 = false;
		return TextEditor::BreakOption::allowBreak;

	} else if (state.current.cls == LBC::zw) {
		if (state.next.cls == LBC::sp) {
			state.lb8 = true;
			return TextEditor::BreakOption::noBreak;
		}

		return TextEditor::BreakOption::allowBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb8a(const LineBreakState& state) {
	// LB8a: do not break after a zero width joiner
	// ZWJ ×
	if (state.current.cls == LBC::zwj) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb9(LineBreakState& state) {
	// LB9: do not break a combining character sequence; treat it as if it has the
	// line breaking class of the base character in all of the following rules
	static const std::unordered_set<LBC> BKCRLFNLSPZW = {LBC::bk, LBC::cr, LBC::lf, LBC::nl, LBC::sp, LBC::zw};

	// treat X (CM | ZWJ)* as if it were X
	// where X is any line break class except BK, CR, LF, NL, SP, or ZW
	if (BKCRLFNLSPZW.find(state.current.cls) == BKCRLFNLSPZW.end() &&
		(state.next.cls == LBC::cm || state.next.cls == LBC::zwj)) {

		state.next.ignored = true;
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb10(LineBreakState& state) {
	// LB10: treat any remaining combining mark or ZWJ as AL
	if (state.current.cls == LBC::cm) {
		state.current.cls = LBC::al;
	}

	if (state.next.cls == LBC::cm) {
		state.next.cls = LBC::al;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb11(const LineBreakState& state) {
	// LB11: do not break before or after word joiner and related characters
	// × WJ
	// WJ ×
	if (state.next.cls == LBC::wj || state.current.cls == LBC::wj) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb12(const LineBreakState& state) {
	// LB12: do not break after NBSP and related characters
	// GL ×
	if (state.current.cls == LBC::gl) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb12a(const LineBreakState& state) {
	// LB12a: do not break before NBSP and related characters, except after spaces and hyphens
	// [^SP BA HY HH] × GL
	if (state.next.cls == LBC::gl) {
		switch (state.current.cls) {
			case LBC::sp:
			case LBC::ba:
			case LBC::hy:
			case LBC::hh:
				return TextEditor::BreakOption::undefined;

			default:
				return TextEditor::BreakOption::noBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb13(const LineBreakState& state) {
	// LB13: do not break before ‘]’ or ‘!’ or ‘;’ or ‘/’, even after spaces
	// × CL
	// × CP
	// × EX
	// × SY
	switch (state.next.cls) {
		case LBC::cl:
		case LBC::cp:
		case LBC::ex:
		case LBC::sy:
			return TextEditor::BreakOption::noBreak;

		default:
			return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb14(LineBreakState& state) {
	// LB14: do not break after ‘[’, even after spaces
	// OP SP* ×
	if (state.current.cls == LBC::op) {
		if (state.next.cls == LBC::sp) {
			state.spaces = true;
		}

		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb15a(LineBreakState& state) {
	// LB15a: do not break after an unresolved initial punctuation that lies at the start of the line,
	// after a space, after opening punctuation, or after an unresolved quotation mark, even after spaces
	static const std::unordered_set<LBC> sotBKCRLFNLOPQUGLSPZW = {
		LBC::sot, LBC::bk, LBC::cr, LBC::lf, LBC::nl, LBC::op, LBC::qu, LBC::gl, LBC::sp, LBC::zw
	};

	// (sot | BK | CR | LF | NL | OP | QU | GL | SP | ZW) [\p{Pi}&QU] SP* ×
	if (sotBKCRLFNLOPQUGLSPZW.find(state.previous.cls) != sotBKCRLFNLOPQUGLSPZW.end() &&
		isPi(state.current.codepoint) &&
		state.current.cls == LBC::qu) {

		state.spaces = true;
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb15b(const LineBreakState& state) {
	// LB15b: do not break before an unresolved final punctuation that lies at the end of the line,
	// before a space, before a prohibited break, or before an unresolved quotation mark, even after spaces
	static const std::unordered_set<LBC> SPGLWJCLQUCPEXISSYBKCRLFNLZW = {
		LBC::sp, LBC::gl, LBC::wj, LBC::cl, LBC::qu, LBC::cp, LBC::ex,
		LBC::is, LBC::sy, LBC::bk, LBC::cr, LBC::lf, LBC::nl, LBC::zw
	};

	// × [\p{Pf}&QU] ( SP | GL | WJ | CL | QU | CP | EX | IS | SY | BK | CR | LF | NL | ZW | eot)
	if (isPf(state.next.codepoint) && state.next.cls == LBC::qu) {
		auto after = state.getClass(state.next.pos + 1);

		if (after == LBC::eot) {
			return TextEditor::BreakOption::noBreak;
		}

		if (SPGLWJCLQUCPEXISSYBKCRLFNLZW.find(after) == SPGLWJCLQUCPEXISSYBKCRLFNLZW.end()) {
			return TextEditor::BreakOption::noBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb15c(const LineBreakState& state) {
	// LB15c: Break before a decimal mark that follows a space, for instance, in ‘subtract .5’
	// SP ÷ IS NU
	if ((state.current.cls == LBC::sp) && (state.next.cls == LBC::is)) {
		if (state.getClass(state.next.pos + 1) == LBC::nu) {
			return TextEditor::BreakOption::allowBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb15d(const LineBreakState& state) {
	// LB15d: otherwise, do not break before ‘;’, ‘,’, or ‘.’, even after spaces
	// × IS
	if (state.next.cls == LBC::is) {
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb16(LineBreakState& state) {
	// LB16: do not break between closing punctuation and a nonstarter (lb=NS), even with intervening space
	// (CL | CP) SP* × NS
	if ((state.current.cls == LBC::cl) || (state.current.cls == LBC::cp)) {
		auto pos = state.next.pos;
		LBC cls;

		do {
			cls = state.getClass(pos++);
		} while (cls == LBC::sp);

		if (state.getClass(pos) == LBC::ns) {
			if (state.next.cls == LBC::sp) {
				state.spaces = true;
			}

			return TextEditor::BreakOption::noBreak;
		}

		if (state.next.cls == LBC::sp) {
			return TextEditor::BreakOption::noBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb17(LineBreakState& state) {
	// LB17: do not break within ‘——’, even with intervening spaces
	// B2 SP* × B2
	if (state.current.cls == LBC::b2) {
		auto pos = state.next.pos;
		LBC cls;

		do {
			cls = state.getClass(pos++);
		} while (cls == LBC::sp);

		if (state.getClass(pos) == LBC::b2) {
			if (state.next.cls != LBC::sp) {
				return TextEditor::BreakOption::noBreak;
			}

			state.spaces = true;
			return TextEditor::BreakOption::noBreak;

		} else if (state.next.cls == LBC::sp) {
			return TextEditor::BreakOption::noBreak;
		}
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb18(const LineBreakState& state) {
	// LB18: Break after spaces
	// SP ÷
	if (state.current.cls == LBC::sp) {
		return TextEditor::BreakOption::allowBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}

static inline TextEditor::BreakOption lb19(const LineBreakState& state) {
	// LB19: do not break before non-initial unresolved quotation marks, such as ‘ ” ’ or ‘ " ’,
	// nor after non-final unresolved quotation marks, such as ‘ “ ’ ‘ " ’
	// × [ QU - \p{Pi} ]
	if ((state.next.cls == LBC::qu) && !isPi(state.next.codepoint)) {
		// Gc=Pi is initial punctuation
		return TextEditor::BreakOption::noBreak;
	}

	// [ QU - \p{Pf} ] ×
	if ((state.current.cls == LBC::qu) && !isPf(state.current.codepoint)) {
		// Gc=Pf is final punctuation
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb19a(const LineBreakState& state) {
	// LB19a: unless surrounded by East Asian characters, do not break either side
	// [^$EastAsian] × QU
	if (!TextEditor::CodePoint::isEastAsian(state.current.codepoint) && (state.next.cls == LBC::qu)) {
		return TextEditor::BreakOption::noBreak;
	}

	// × QU ( [^$EastAsian] | eot )
	if (state.next.cls == LBC::qu) {
		auto afterCodepoint = state.getCodepoint(state.next.pos + 1);
		auto afterCls = state.getClass(state.next.pos + 1);

		if (afterCls == LBC::eot || !TextEditor::CodePoint::isEastAsian(afterCodepoint)) {
			return TextEditor::BreakOption::noBreak;
		}
	}

	// QU × [^$EastAsian]
	if ((state.current.cls == LBC::qu) && !TextEditor::CodePoint::isEastAsian(state.next.codepoint)) {
		return TextEditor::BreakOption::noBreak;
	}

	// ( sot | [^$EastAsian] ) qu ×
	if ((state.previous.cls == LBC::sot || !TextEditor::CodePoint::isEastAsian(state.previous.codepoint)) && state.current.cls == LBC::qu) {
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb20(const LineBreakState& state) {
	// LB20: break before and after unresolved CB
	// ÷ CB
	// CB ÷
	if ((state.current.cls == LBC::cb) || (state.next.cls == LBC::cb)) {
		return TextEditor::BreakOption::allowBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb20a(const LineBreakState& state) {
	// LB20a: do not break after a word-initial hyphen
	static const std::unordered_set<LBC> sotBKCRLFNLSPZWCBGL = {
		LBC::sot, LBC::bk, LBC::cr, LBC::lf, LBC::nl, LBC::sp, LBC::zw, LBC::cb, LBC::gl
	};

	// ( sot | BK | CR | LF | NL | SP | ZW | CB | GL ) ( HY | HH ) × ( AL | HL )
	if (sotBKCRLFNLSPZWCBGL.find(state.previous.cls) != sotBKCRLFNLSPZWCBGL.end() &&
		((state.current.cls == LBC::hy) || (state.current.cls == LBC::hh)) &&
		((state.next.cls == LBC::al) || (state.next.cls == LBC::hl))) {

		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb21(const LineBreakState& state) {
	// LB21: do not break before hyphen-minus, other hyphens, fixed-width spaces, small kana, and other non-starters, or after acute accents
	// BB ×
	if (state.current.cls == LBC::bb) {
		return TextEditor::BreakOption::noBreak;
	}

	// × ( BA | HH | HY | NS )
	switch (state.next.cls) {
		case LBC::ba:
		case LBC::hh:
		case LBC::hy:
		case LBC::ns:
			return TextEditor::BreakOption::noBreak;

		default:
			return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb21a(const LineBreakState& state) {
	// LB21a: do not break after the hyphen in Hebrew + Hyphen + non-Hebrew
	// HL (HY | HH) × [^HL]
	if ((state.previous.cls == LBC::hl) &&
		(state.current.cls == LBC::hy || state.current.cls == LBC::hh) &&
		state.next.cls != LBC::hl) {

		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb21b(const LineBreakState& state) {
	// don’t break between Solidus and Hebrew letters
	// SY × HL
	if ((state.current.cls == LBC::sy) && (state.next.cls == LBC::hl)) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb22(const LineBreakState& state) {
	// do not break before ellipses
	// × IN
	if (state.next.cls == LBC::in) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb23(const LineBreakState& state) {
	// do not break between digits and letters
	switch (state.current.cls) {
		case LBC::al:
		case LBC::hl:
			// (AL | HL) × NU
			if (state.next.cls == LBC::nu) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		case LBC::nu:
			// NU × (AL | HL)
			if ((state.next.cls == LBC::al) || (state.next.cls == LBC::hl)) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		default:
			return TextEditor::BreakOption::undefined;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb23a(const LineBreakState& state) {
	// LB23a: do not break between numeric prefixes and ideographs, or between ideographs and numeric postfixes
	static const std::unordered_set<LBC> IDEBEM = {LBC::id, LBC::eb, LBC::em};

	// PR × (ID | EB | EM)
	if ((state.current.cls == LBC::pr) && IDEBEM.find(state.next.cls) != IDEBEM.end()) {
		return TextEditor::BreakOption::noBreak;
	}

	// (ID | EB | EM) × PO
	if ((state.next.cls == LBC::po) && IDEBEM.find(state.current.cls) != IDEBEM.end()) {
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb24(const LineBreakState& state) {
	// LB24: do not break between numeric prefix/postfix and letters, or between letters and prefix/postfix
	// (PR | PO) × (AL | HL)
	if ((state.current.cls == LBC::pr || state.current.cls == LBC::po) &&
		(state.next.cls == LBC::al || state.next.cls == LBC::hl)) {
		return TextEditor::BreakOption::noBreak;
	}

	// (AL | HL) × (PR | PO)
	if ((state.current.cls == LBC::al || state.current.cls == LBC::hl) &&
		(state.next.cls == LBC::pr || state.next.cls == LBC::po)) {
		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb25(const LineBreakState& state) {
	// LB25: do not break numbers
	// approach: find the end of a matching run, then no-break everything as we go past it
	static const std::unordered_set<LBC> POPR = {LBC::po, LBC::pr};
	static const std::unordered_set<LBC> CLCP = {LBC::cl, LBC::cp};

	// NU ( SY | IS )* CL × PO
	// NU ( SY | IS )* CP × PO
	// NU ( SY | IS )* CL × PR
	// NU ( SY | IS )* CP × PR
	// NU ( SY | IS )* × PO
	// NU ( SY | IS )* × PR
	// NU ( SY | IS )* × NU
	size_t pos = invalidPos;

	if (POPR.find(state.next.cls) != POPR.end()) {
		if (CLCP.find(state.current.cls) != CLCP.end()) {
			pos = state.previous.pos;

		} else {
			pos = state.current.pos;
		}

	} else if (state.next.cls == LBC::nu) {
		pos = state.current.pos;
	}

	// as specified, possible ReDoS because of the backtracking
	if (pos != invalidPos) {
		while (pos != invalidPos) {
			switch(state.getClass(pos)) {
				case LBC::sy:
				case LBC::is:
					break;

				case LBC::nu:
					return TextEditor::BreakOption::noBreak;

				default:
					pos = 0;
			}

			pos = pos == 0 ? invalidPos : pos - 1;
		}
	}

	// PO × OP NU
	// PO × OP IS NU
	// PO × NU
	// PR × OP NU
	// PR × OP IS NU
	// PR × NU
	if ((state.current.cls == LBC::po) || ((state.current.cls == LBC::pr))) {
		if (state.next.cls == LBC::op) {
			auto after = state.getClass(state.next.pos + 1);

			if (after != LBC::eot) {
				if (after == LBC::nu) {
					return TextEditor::BreakOption::noBreak;

				} else if (after == LBC::is) {
					auto afterAfter = state.getClass(state.next.pos + 2);

					if (afterAfter == LBC::nu) {
						return TextEditor::BreakOption::noBreak;
					}
				}
			}

		} else if (state.next.cls == LBC::nu) {
			return TextEditor::BreakOption::noBreak;
		}
	}

	// HY × NU
	if ((state.current.cls == LBC::hy) && (state.next.cls == LBC::nu)) {
		return TextEditor::BreakOption::noBreak;
	}

	// IS × NU
	if ((state.current.cls == LBC::is) && (state.next.cls == LBC::nu)) {
		return TextEditor::BreakOption::noBreak;
	}

		return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb26(const LineBreakState& state) {
	// LB26 do not break a Korean syllable
	static const std::unordered_set<LBC> JLJVH2H3 = {LBC::jl, LBC::jv, LBC::h2, LBC::h3};
	static const std::unordered_set<LBC> JVJT = {LBC::jv, LBC::jt};

	switch (state.current.cls) {
		case LBC::jl:
			// JL × (JL | JV | H2 | H3)
			if (JLJVH2H3.find(state.next.cls) != JLJVH2H3.end()) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		case LBC::jv:
		case LBC::h2:
			// (JV | H2) × (JV | JT)
			if (JVJT.find(state.next.cls) != JVJT.end()) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		case LBC::jt:
		case LBC::h3:
			// (JT | H3) × JT
			if (state.next.cls == LBC::jt) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		default:
			return TextEditor::BreakOption::undefined;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb27(const LineBreakState& state) {
	// LB27: treat a Korean Syllable Block the same as LBC::id
	static const std::unordered_set<LBC> JLJVJTH2H3 = {LBC::jl, LBC::jv, LBC::jt, LBC::h2, LBC::h3};

	switch (state.current.cls) {
		case LBC::jl:
		case LBC::jv:
		case LBC::jt:
		case LBC::h2:
		case LBC::h3:
			// (JL | JV | JT | H2 | H3) × PO
			if (state.next.cls == LBC::po) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		case LBC::pr:
			// PR × (JL | JV | JT | H2 | H3)
			if (JLJVJTH2H3.find(state.next.cls) != JLJVJTH2H3.end()) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		default:
			return TextEditor::BreakOption::undefined;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb28(const LineBreakState& state) {
	// LB28 do not break between alphabetics (“at”)
	// (AL | HL) × (AL | HL)
	if ((state.current.cls == LBC::al || state.current.cls == LBC::hl) &&
		(state.next.cls == LBC::al || state.next.cls == LBC::hl)) {

		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb28a(const LineBreakState& state) {
	// LB28a: do not break inside the orthographic syllables of Brahmic scripts
	// AP × (AK | [◌] | AS)
	if ((state.current.cls == LBC::ap) && isAkCircleAs(state.next)) {
		return TextEditor::BreakOption::noBreak;
	}

	// (AK | [◌] | AS) × (VF | VI)
	if (isAkCircleAs(state.current) && ((state.next.cls == LBC::vf) || (state.next.cls == LBC::vi))) {
		return TextEditor::BreakOption::noBreak;
	}

	// (AK | [◌] | AS) VI × (AK | [◌])
	if (isAkCircleAs(state.previous) &&
		state.current.cls == LBC::vi && (state.next.cls == LBC::ak || state.next.codepoint == dotCircle)) {

		return TextEditor::BreakOption::noBreak;
	}

	// (AK | [◌] | AS) × (AK | [◌] | AS) VF
	if (isAkCircleAs(state.current) &&
		isAkCircleAs(state.next) && (state.getClass(state.next.pos + 1) == LBC::vf)) {

		return TextEditor::BreakOption::noBreak;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb29(const LineBreakState& state) {
	// LB29: do not break between numeric punctuation and alphabetics (“e.g.”)
	// IS × (AL | HL)
	if (state.current.cls == LBC::is && (state.next.cls == LBC::al || state.next.cls == LBC::hl)) {
		return TextEditor::BreakOption::noBreak;

	} else {
		return TextEditor::BreakOption::undefined;
	}
}


static inline TextEditor::BreakOption lb30(const LineBreakState& state) {
	// LB30: do not break between letters, numbers, or ordinary symbols and opening or closing parentheses
	static const std::unordered_set<LBC> ALHLNU = {LBC::al, LBC::hl, LBC::nu};

	switch (state.current.cls) {
		case LBC::al:
		case LBC::hl:
		case LBC::nu:
			// (AL | HL | NU) × [OP-$EastAsian]
			if (state.next.cls == LBC::op && !TextEditor::CodePoint::isEastAsian(state.next.codepoint)) {
				return TextEditor::BreakOption::noBreak;
			}

			break;

		case LBC::cp:
			// [CP-$EastAsian] × (AL | HL | NU)
			if (!TextEditor::CodePoint::isEastAsian(state.current.codepoint) &&
				ALHLNU.find(state.next.cls) != ALHLNU.end()) {

				return TextEditor::BreakOption::noBreak;
			}

			break;

		default:
			return TextEditor::BreakOption::undefined;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb30a(LineBreakState& state) {
	// LB30a: break between two regional indicator symbols if and only if there are
	// an even number of regional indicators preceding the position of the break
	if (state.current.cls == LBC::ri) {
		if (state.next.cls == LBC::ri) {
			if (++state.ri % 2 != 0) {
				return TextEditor::BreakOption::noBreak;
			}
		}

	} else {
		state.ri = 0;
	}

	return TextEditor::BreakOption::undefined;
}


static inline TextEditor::BreakOption lb30b(const LineBreakState& state) {
	// LB30b: do not break between an emoji base (or potential emoji) and an emoji modifier
	// EB × EM
	if ((state.current.cls == LBC::eb) && (state.next.cls == LBC::em)) {
		return TextEditor::BreakOption::noBreak;
	}

#if defined(IMGUI_USE_WCHAR32)
	// [\p{Extended_Pictographic}&\p{Cn}] × EM
	// if (state.next.cls == LBC::em && (/^\p{ExtPict}$/u.test(state.cur.char))  && (/^\p{gc=Cn}$/u.test(state.cur.char))) {
	// 	return TextEditor::BreakOption::noBreak;
	// }
#endif

	return TextEditor::BreakOption::undefined;
}


#define RULE(r)														\
	result = r(state);												\
																	\
	if (result != TextEditor::BreakOption::undefined) {				\
		return result;												\
	}

#define RULE2(r)													\
	if (config.r) {													\
		RULE(r)														\
	}


static inline TextEditor::BreakOption applyRules(TextEditor::LineBreakConfig& config, LineBreakState& state) {
	TextEditor::BreakOption result;
	RULE2(lb2);
	RULE2(lb3);
	RULE2(lb4);
	RULE2(lb5);
	RULE2(lb6);
	RULE(lbSpaceStop);
	RULE2(lb7);
	RULE2(lb8);
	RULE2(lb8a);
	RULE2(lb9);
	RULE2(lb10);
	RULE2(lb11);
	RULE2(lb12);
	RULE2(lb12a);
	RULE2(lb13);
	RULE2(lb14);
	RULE2(lb15a);
	RULE2(lb15b);
	RULE2(lb15c);
	RULE2(lb15d);
	RULE2(lb16);
	RULE2(lb17);
	RULE2(lb18);
	RULE2(lb19);
	RULE2(lb19a);
	RULE2(lb20);
	RULE2(lb20a);
	RULE2(lb21a);
	RULE2(lb21);
	RULE2(lb21b);
	RULE2(lb22);
	RULE2(lb23);
	RULE2(lb23a);
	RULE2(lb24);
	RULE2(lb25);
	RULE2(lb26);
	RULE2(lb27);
	RULE2(lb28);
	RULE2(lb28a);
	RULE2(lb29);
	RULE2(lb30);
	RULE2(lb30a);
	RULE2(lb30b);

	// LB31: break everywhere else
	// ALL ÷
	// ÷ ALL
	return TextEditor::BreakOption::allowBreak;
}


//
//	TextEditor::LineBreak::classify
//

void TextEditor::LineBreak::classify(Line& line) {
	// handle easy cases
	auto size = line.size();

	if (size == 0) {
		return;

	} else if (size == 1) {
		line[0].breakOption = BreakOption::noBreak;
		return;
	}

	// handle different break modes
	if (config.useUnicodeAnnex14) {
		// setup state
		LineBreakState state;
		state.glyphs = &(*line.begin());
		state.size = size;

		for (size_t i = 0; i < size; i++) {
			const auto& glyph = line[i];
			state.push(LineBreakGlyph(glyph.codepoint, getLineBreakClass(glyph.codepoint), i));
			auto breakOption = applyRules(config, state);

			if (i) {
				line[i - 1].breakOption = breakOption;
			}
		}

	} else {
		// update break sets (if required)
		if (updateSets) {
			updateSet(breakAfter, config.breakAfter);
			updateSet(breakBefore, config.breakBefore);
			updateSets = false;
		}

		// process all glyphs in line
		for (size_t i = 0; i < size; i++) {
			if (breakAfter.find(line[i].codepoint) != breakAfter.end()) {
				line[i].breakOption = BreakOption::allowBreak;

			} else if (i && breakBefore.find(line[i].codepoint) != breakBefore.end()) {
				line[i - 1].breakOption = BreakOption::allowBreak;
				line[i].breakOption = BreakOption::noBreak;

			} else {
				line[i].breakOption = BreakOption::noBreak;
			}
		}
	}

	line[size - 1].breakOption = BreakOption::noBreak;
}


//
//	TextEditor::LineBreak::updateSet
//

void TextEditor::LineBreak::updateSet(std::unordered_set<ImWchar>& set, std::string_view text) {
	// process UTF-8 and generate lines of glyphs
	set.clear();
	auto end = text.end();
	auto i = CodePoint::skipBOM(text.begin(), end);

	while (i < end) {
		ImWchar character;
		i = CodePoint::read(i, end, &character);
		set.insert(character);
	}
}
//	TextEditor::LineFold::update
//

bool TextEditor::LineFold::update(const Config& config, Document& document, const Bracketeer& bracketeer) {
	// force update after previous (un)fold request
	if (forceUpdate) {
		forceUpdate = false;
		updated = true;
	}

	// see if configuration changed
	if (lineFolding != config.lineFolding) {
		lineFolding = config.lineFolding;

		if (!lineFolding) {
			// line folding is turned off, clear list and reset all lines
			clear();

			for (auto& line : document) {
				line.foldingState = FoldingState::visible;
			}
		}

		updated = true;
	}

	// see if bracket layout changed
	if (bracketeer.isUpdated()) {
		updated = true;
	}

	// (re)build list of folding opportunities (if feature is on and updates have occurred)
	if (lineFolding && updated) {
		std::unordered_set<size_t> previouslyFolded;
		clear();

		for (auto& bracketPair : bracketeer) {
			// brackets must at least be one line apart
			if (bracketPair.end.line - bracketPair.start.line >= 1) {
				// we preserve old folding state
				if (document[bracketPair.start.line].foldingState == FoldingState::folded) {
					previouslyFolded.insert(bracketPair.start.line);
				}

				// add to list
				emplace_back(bracketPair.start.line, bracketPair.end.line);
			}
		}

		// apply new folding state to lines in document
		for (auto& line : document) {
			line.foldingState = FoldingState::visible;
		}

		for (const auto& fold : *this) {
			if (previouslyFolded.find(fold.start) != previouslyFolded.end()) {
				document[fold.start].foldingState = FoldingState::folded;

				for (size_t i = fold.start + 1; i <= fold.end; i++) {
					document[i].foldingState = FoldingState::hidden;
				}

			} else if (document[fold.start].foldingState != FoldingState::hidden) {
				document[fold.start].foldingState = FoldingState::foldable;
			}
		}
	}

	return updated;
}


//
//	TextEditor::LineFold::foldAroundLine
//

void TextEditor::LineFold::foldAroundLine(Document& document, size_t line) {
	auto lineToFold = invalidLine;

	for (const auto& fold : *this) {
		if (line > fold.start && line <= fold.end) {
			if (document[fold.start].foldingState == FoldingState::foldable) {
				lineToFold = fold.start;
			}
		}
	}

	if (lineToFold != invalidLine) {
		document[line].foldingState = FoldingState::folded;
		forceUpdate = true;
	}
}


//
//	TextEditor::LineFold::unfoldAroundLine
//

void TextEditor::LineFold::unfoldAroundLine(Document& document, size_t line) {
	for (const auto& fold : *this) {
		if (line > fold.start && line <= fold.end) {
			if (document[fold.start].foldingState == FoldingState::folded) {
				document[fold.start].foldingState = FoldingState::foldable;
				forceUpdate = true;
			}
		}
	}
}


//
//	TextEditor::LineFold::toggleAtLine
//

void TextEditor::LineFold::toggleAtLine(Document& document, size_t lineNo) {
	auto& line = document[lineNo];
	auto state = line.foldingState;

	if (state == FoldingState::foldable) {
		line.foldingState = FoldingState::folded;

		for (const auto& fold : *this) {
			if (fold.start == lineNo) {
				for (size_t i = fold.start + 1; i <= fold.end; i++) {
					document[i].foldingState = FoldingState::hidden;
				}
			}
		}

		forceUpdate = true;

	} else if (state == FoldingState::folded) {
		line.foldingState = FoldingState::foldable;

		for (const auto& fold : *this) {
			if (fold.start == lineNo) {
				for (size_t i = fold.start + 1; i <= fold.end; i++) {
					document[i].foldingState = FoldingState::visible;
				}
			}
		}

		forceUpdate = true;
	}
}


//
//	TextEditor::LineFold::unfoldAll
//

void TextEditor::LineFold::unfoldAll(Document& document) {
	for (const auto& fold : *this) {
		if (document[fold.start].foldingState == FoldingState::folded) {
			document[fold.start].foldingState = FoldingState::foldable;
			forceUpdate = true;
		}
	}
}


//
//	TextEditor::TypeSetter::wrapLine
//

void TextEditor::TypeSetter::wrapLine(Line& line) {
	// there is always one visible row for a line
	line.rows = 1;

	// status for wrapped lines
	LineSections sections;

	// track breaks
	size_t lastBreakIndex = 0;
	size_t lastBreakableIndex = 0;
	size_t lastBreakableColumn = 0;
	size_t columns = 0;
	size_t indent = 0;

	// track first row indent
	bool isAtBeginning = true;
	bool isFirstRow = true;

	// process all glyphs on line
	size_t i = 0;
	size_t size = line.size();

	while (i < size) {
		// handle hard break
		if (line[i].breakOption == BreakOption::mustBreak) {
			// this can't happen in the editor as hard breaks have already been handled
			// code is however left here in case we want to reuse it somewhere else later
			line.rows++;
			sections.emplace_back(lastBreakIndex, i, columns, indent);

			columns = 0;
			indent = 0;
			isAtBeginning = true;
			isFirstRow = true;
			lastBreakIndex = i + 1;
			lastBreakableIndex = i + 1;

		} else {
			// get current codepoint
			auto codepoint = line[i].codepoint;

			// calculate first row indent (if required)
			if (isAtBeginning) {
				if (CodePoint::isWhiteSpace(codepoint)) {
					indent = (codepoint == '\t') ? ((indent / tabSize) + 1) * tabSize : indent + 1;

				} else {
					isAtBeginning = false;
				}
			}

			// update column count
			columns = (codepoint == '\t') ? ((columns / tabSize) + 1) * tabSize : columns + 1;

			if (columns < wordWrapColumns) {
				// we're not at the end of the row yet so we have to track any break options
				if (line[i].breakOption == BreakOption::allowBreak) {
					lastBreakableIndex = i + 1;
					lastBreakableColumn = columns;
				}

				i++;

			} else {
				// we have reached the end of the row
				if (lastBreakableIndex == lastBreakIndex) {
					// no breaks found, just truncate here
					lastBreakableIndex = i + 1;
					sections.emplace_back(lastBreakIndex, lastBreakableIndex, columns, isFirstRow ? 0 : indent);

				} else {
					// break at last breakable position
					sections.emplace_back(lastBreakIndex, lastBreakableIndex, lastBreakableColumn, isFirstRow ? 0 : indent);
				}

				i = lastBreakableIndex;

				// start a new row
				line.rows++;
				columns = indent;
				lastBreakIndex = lastBreakableIndex;
				lastBreakableColumn = indent;
				isFirstRow = false;
			}
		}
	}

	// did we end up with line wrapping?
	if (line.rows > 1) {
		// yes, save wrapping information
		sections.emplace_back(lastBreakIndex, size, columns, indent);
		line.sections = std::make_shared<LineSections>(sections);

		line.columns = 0;

		for (const auto& section : sections) {
			line.columns = std::max(line.columns, section.columns);
		}

	} else {
		// no wrapping
		line.sections = nullptr;
		line.columns = columns;
	}
}


//
//	TextEditor::TypeSetter::updateLine
//

void TextEditor::TypeSetter::updateLine(Line& line) {
	if (wordWrap) {
		// classify all line break opportunities in line
		lineBreak.classify(line);

		// determine number of rows required
		wrapLine(line);

	} else {
		// text is always 1 row high without wrapping
		line.rows = 1;

		// determine the maximum column number for this line
		line.columns = 0;

		for (const auto& glyph : line) {
			line.columns = (glyph.codepoint == '\t') ? ((line.columns / tabSize) + 1) * tabSize : line.columns + 1;
		}

		// reset multiline sections
		line.sections = nullptr;
	}

	line.needsTypeSetting = false;
}


//
//	TextEditor::TypeSetter::update
//

bool TextEditor::TypeSetter::update(const Config& config, Document& document, const LineFold& lineFold) {
	// see if the configuration changed
	bool configChanged =
		tabSize != config.tabSize ||
		wordWrap != config.wordWrap ||
		(wordWrap && wordWrapColumns != config.wordWrapColumns);

	// update all lines on configuration changes
	if (configChanged) {
		// capture relevant configuration so we can detect new changes later
		tabSize = config.tabSize;
		wordWrap = config.wordWrap;
		wordWrapColumns = config.wordWrapColumns;

		// update all the lines
		for (auto& line : document) {
			updateLine(line);
		}

	// update changed lines when document is updated
	} else if (document.isUpdated()) {
		for (auto& line : document) {
			if (line.needsTypeSetting) {
				updateLine(line);
			}
		}
	}

	// update overall state if something changed
	updated = configChanged || document.isUpdated() || lineFold.isUpdated();

	if (updated) {
		// reset state
		clear();
		totalRows = 0;
		totalColumns = 0;

		// process all document lines
		size_t lineNo = 0;

		for (auto& line : document) {
			// update line's row start
			// this is even required for hidden lines so their DocPos can be transformed into a VisPos
			line.row = totalRows;

			// skip hidden lines
			if (line.foldingState != FoldingState::hidden) {
				// update total rows and columns
				totalRows += line.rows;
				totalColumns = std::max(totalColumns, line.columns);

				// add row(s) and handle word wrapping (if required)
				if (line.sections) {
					for (size_t i = 0; i < line.rows; i++) {
						emplace_back(lineNo, i, line.sections->at(i).columns);
					}

				} else {
					emplace_back(lineNo, 0, line.columns);
				}
			}

			lineNo++;
		}
	}

	// update and return status
	return updated;
}


//
//	TextEditor::TypeSetter::docPos2VisPos
//

TextEditor::VisPos TextEditor::TypeSetter::docPos2VisPos(const Document& document, DocPos pos) const {
	if (size() == 0) {
		return VisPos(0, 0);
	}

	auto& line = document[pos.line];
	VisPos visPos(line.row, 0);

	if (line.foldingState == FoldingState::hidden) {
		// for hidden lines, we use the position of the ellipsis (end of folded line)
		visPos.column = at(line.row).columns;

	} else if (line.sections) {
		// for wrapped lines, find relevant section and handle tabs
		bool done = false;

		for (size_t i = 0; !done && i < line.sections->size(); i++) {
			auto& section = line.sections->at(i);

			if (pos.index >= section.startIndex && pos.index <= section.endIndex) {
				auto start = line.begin() + section.startIndex;
				auto end = line.begin() + pos.index;
				visPos.column = section.indent;

				for (auto glyph = start; glyph < end; glyph++) {
					visPos.column = (glyph->codepoint == '\t') ? ((visPos.column / tabSize) + 1) * tabSize : visPos.column + 1;
				}

				done = true;

			} else {
				visPos.row++;
			}
		}

	} else {
		// for non-wrapped lines, just handle tabs
		auto end = line.begin() + pos.index;

		for (auto glyph = line.begin(); glyph < end; glyph++) {
			visPos.column = (glyph->codepoint == '\t') ? ((visPos.column / tabSize) + 1) * tabSize : visPos.column + 1;
		}
	}

	return visPos;
}


//
//	TextEditor::TypeSetter::visPos2DocPos
//

TextEditor::DocPos TextEditor::TypeSetter::visPos2DocPos(const Document& document, VisPos pos) const {
	if (pos.row >= size()) {
		return DocPos(0, 0);
	}

	auto& row = at(pos.row);
	auto& line = document[row.line];

	DocPos docPos;
	docPos.line = row.line;

	size_t index;
	size_t leftColumn;
	size_t rightColumn;

	Line::const_iterator start;
	Line::const_iterator end;

	if (line.sections) {
		const auto& section = line.sections->at(row.section);
		index = section.startIndex;
		leftColumn = section.indent;
		rightColumn = section.indent;

		start = line.begin() + section.startIndex;
		end = line.begin() + section.endIndex;

	} else {
		index = 0;
		leftColumn = 0;
		rightColumn = 0;

		start = line.begin();
		end = line.end();
	}

	for (auto glyph = start; rightColumn < pos.column && glyph < end; glyph++) {
		leftColumn = rightColumn;
		rightColumn = (glyph->codepoint == '\t') ? ((rightColumn / tabSize) + 1) * tabSize : rightColumn + 1;
		index++;
	}

	if (rightColumn - leftColumn <= 1) {
		docPos.index = index;

	} else {
		auto leftDiff = pos.column - leftColumn;
		auto rightDiff = rightColumn - pos.column;
		docPos.index = leftDiff <= rightDiff ? index - 1 : index;
	}

	return docPos;
}


//
//	TextEditor::TypeSetter::screenPos2DocPos
//

void TextEditor::TypeSetter::screenPos2DocPos(const Document& document, ImVec2 screenPos, DocPos& glyphPos, DocPos& cursorPos) const {
	// the returned glyphPos addresses the glyph pointed to by the screenPos parameter
	// the returned cursorPos returns the closest cursor position (which can be at the start or the end of the glyph)
	size_t colNo = static_cast<size_t>(screenPos.x);
	size_t rowNo = static_cast<size_t>(screenPos.y);

	if (screenPos.y <= 0.0f) {
		glyphPos = DocPos(0, 0);
		cursorPos = glyphPos;

	} else if (rowNo >= totalRows) {
		glyphPos = document.getBottom();
		cursorPos = glyphPos;

	} else {
		auto& row = at(rowNo);
		auto& line = document[row.line];

		if (screenPos.x <= 0.0f) {
			glyphPos = DocPos(row.line, 0);
			cursorPos = glyphPos;

		} else if (colNo > row.columns) {
			if (line.sections) {
				const auto& section = line.sections->at(row.section);
				glyphPos = DocPos(row.line, section.endIndex);

			} else {
				glyphPos = document.getEndOfLine(DocPos(row.line, 0));
			}

			cursorPos = glyphPos;

		} else {
			size_t index;
			size_t leftColumn;
			size_t rightColumn;

			Line::const_iterator start;
			Line::const_iterator end;

			if (line.sections) {
				const auto& section = line.sections->at(row.section);
				index = section.startIndex;
				leftColumn = section.indent;
				rightColumn = section.indent;

				start = line.begin() + section.startIndex;
				end = line.begin() + section.endIndex;

			} else {
				index = 0;
				leftColumn = 0;
				rightColumn = 0;

				start = line.begin();
				end = line.end();

			}

			for (auto glyph = start; static_cast<float>(rightColumn) < screenPos.x && glyph < end; glyph++) {
				leftColumn = rightColumn;
				rightColumn = (glyph->codepoint == '\t') ? ((rightColumn / tabSize) + 1) * tabSize : rightColumn + 1;
				index++;
			}

			auto leftDiff = screenPos.x - static_cast<float>(leftColumn);
			auto rightDiff = static_cast<float>(rightColumn) - screenPos.x;

			glyphPos = DocPos(row.line, leftColumn == rightColumn ? index : index - 1);
			cursorPos = DocPos(row.line, leftDiff <= rightDiff ? index - 1 : index);
		}
	}
}


//
//	TextEditor::TypeSetter::normalizePos
//

TextEditor::VisPos TextEditor::TypeSetter::normalizePos(VisPos pos) const {
	if (totalRows == 0) {
		return VisPos(0, 0);

	} else if (pos.row >= totalRows) {
		auto lastRow = totalRows - 1;
		return VisPos(lastRow, at(lastRow).columns);

	} else if (pos.column > at(pos.row).columns) {
		return VisPos(pos.row, at(pos.row).columns);

	} else {
		return pos;
	}
}


//
//	TextEditor::TypeSetter::isVisPosOverGlyph
//

bool TextEditor::TypeSetter::isVisPosOverGlyph(VisPos pos) const {
	return pos.row < totalRows && pos.column <= at(pos.row).columns;
}


//
//	TextEditor::setAutoCompleteConfig
//

void TextEditor::AutoComplete::setConfig(const AutoCompleteConfig* config) {
	if (config) {
		configuration = *config;
		configured = true;

	} else {
		configured = false;
	}

	active = false;
}


//
//	TextEditor::AutoComplete::startTyping
//

bool TextEditor::AutoComplete::startTyping(Cursors& cursors) {
	if (!active && !requestActivation && configured && configuration.triggerOnTyping) {
		triggeredManually = false;
		start(cursors);
		return true;

	} else {
		return false;
	}
}


//
//	TextEditor::AutoComplete::startShortcut
//

bool TextEditor::AutoComplete::startShortcut(Cursors& cursors) {
	if (!active && !requestActivation && configured && configuration.triggerOnShortcut) {
		triggeredManually = true;
		start(cursors);
		return true;

	} else {
		return false;
	}
}


//
//	TextEditor::AutoComplete::cancel
//

void TextEditor::AutoComplete::cancel() {
	if (active) {
		requestDeactivation = true;
	}
}


//
//	renderSuggestion
//

static bool renderSuggestion(const std::string_view& suggestion, const std::string_view& searchTerm, float width, bool selected) {
	// custom widget to render an autocomplete suggestion in the style of Visual Studio Code
	auto glyphPos = ImGui::GetCursorScreenPos();
	auto size = ImVec2(width, ImGui::GetFrameHeightWithSpacing());
	auto clicked = ImGui::InvisibleButton("suggestion", size);

	auto drawList = ImGui::GetWindowDrawList();
	auto font = ImGui::GetFont();
	auto fontSize = ImGui::GetFontSize();
	auto glyphWidth = ImGui::CalcTextSize("#").x;

	// highlight selected item
	if (selected) {
		drawList->AddRectFilled(glyphPos, glyphPos + size, ImGui::GetColorU32(ImGuiCol_Header));
	}

	// process all UTF-8 glyphs in suggestion
	glyphPos += ImGui::GetStyle().FramePadding;
	auto suggestionEnd = suggestion.end();
	auto searchTermEnd = searchTerm.end();
	auto i = TextEditor::CodePoint::skipBOM(suggestion.begin(), suggestionEnd);
	auto j = TextEditor::CodePoint::skipBOM(searchTerm.begin(), searchTermEnd);

	while (i < suggestionEnd) {
		// get next glyph from suggestion
		ImWchar codepoint;
		i = TextEditor::CodePoint::read(i, suggestionEnd, &codepoint);

		// highlight glyph in suggestion that match search term
		auto color = ImGui::GetColorU32(ImGuiCol_Text);

		if (j < searchTermEnd) {
			ImWchar searchCodePoint;
			auto next = TextEditor::CodePoint::read(j, searchTermEnd, &searchCodePoint);

			if (TextEditor::CodePoint::toLower(searchCodePoint) == TextEditor::CodePoint::toLower(codepoint)) {
				color = ImGui::GetColorU32(ImGuiCol_TextLink);
				j = next;
			}
		}

		// render the glyph
		font->RenderChar(drawList, fontSize, glyphPos, color, codepoint);
		glyphPos.x += glyphWidth;
	}

	return clicked;
}


//
//	TextEditor::AutoComplete::render
//

bool TextEditor::AutoComplete::render(Document& document, Cursors& cursors, TypeSetter& typesetter, const Language* language, float textOffset, ImVec2 glyphSize) {
	// see if we need to activate autocomplete mode
	if (requestActivation) {
		// apply popup delay
		if (std::chrono::system_clock::now() > activationTime) {
			// reset activation flag
			requestActivation = false;

			// capture locations
			startLocation = document.findWordStart(currentLocation, true);

			// update the autocomplete state
			updateState(document, language);

			// handle cases where autocomplete request is ignored
			if(state.inComment && !configuration.triggerInComments) {
				return false;
			}

			if(state.inString && !configuration.triggerInStrings) {
				return false;
			}

			// get initial list of suggestions from the app
			refreshSuggestions();

			// show autocomplete popup window
			ImGui::OpenPopup("AutoCompleteContextMenu");
			active = true;
		}
	}

	// only continue if autocomplete is active
	if (!active) {
		return false;
	}

	// see if cursor moved since last time
	auto newLocation = cursors.getMain().getSelectionEnd();

	if (newLocation != currentLocation) {
		// see if we need to deactivate autocomplete because cursor is on new line
		if (newLocation.line != currentLocation.line) {
			requestDeactivation = true;

		} else {
			// see if cursor moved away from current word
			auto newStart = document.findWordStart(newLocation, true);

			if (newStart == startLocation) {
				currentLocation = newLocation;

				// we deactivate autocomplete if the current location is the start
				if (currentLocation == startLocation) {
					requestDeactivation = true;

				} else {
					updateState(document, language);
					refreshSuggestions();
				}

			} else {
				requestDeactivation = true;
			}
		}
	}

	// open popup window
	bool result = false;
	auto pos = typesetter.docPos2VisPos(document, currentLocation);

	ImGui::SetNextWindowPos(ImVec2(
		ImGui::GetCursorScreenPos().x + textOffset + pos.column * glyphSize.x,
		ImGui::GetCursorScreenPos().y + (pos.row + 1) * glyphSize.y));

	auto suggestions = state.suggestions.size();

	// an empty result while typing dismisses silently; only a manual trigger earns the "no suggestions" feedback
	if (suggestions == 0 && !state.suggestionsPromise && !triggeredManually) {
		requestDeactivation = true;
	}

	auto visibleSuggestions = (suggestions == 0) ? 1 : std::min(static_cast<size_t>(10), suggestions);
	const auto& style = ImGui::GetStyle();
	auto height = ImGui::GetFrameHeightWithSpacing() * visibleSuggestions + style.WindowPadding.y * 2.0f;
	ImGui::SetNextWindowSize(ImVec2(configuration.suggestionWidth * glyphSize.x, height));

	ImGuiWindowFlags flags =
		ImGuiWindowFlags_NoFocusOnAppearing |
		ImGuiWindowFlags_NoNav;

	if (ImGui::BeginPopup("AutoCompleteContextMenu", flags)) {
		if (ImGui::IsWindowAppearing()) {
			ImGui::BringWindowToDisplayFront(ImGui::GetCurrentWindow());
		}

		// deactivate popup (if requested)
		if (requestDeactivation) {
			ImGui::CloseCurrentPopup();
			requestDeactivation = false;
			active = false;

		} else {
			// do we have any suggestions
			if (suggestions) {
				auto items = state.suggestions.size();

				// apply arrow keys to selected suggestion
				if (ImGui::IsKeyPressed(ImGuiKey_UpArrow)) {
					if (currentSelection == 0) {
						currentSelection = items - 1;

					} else {
						currentSelection--;
					}

				} else if (ImGui::IsKeyPressed(ImGuiKey_DownArrow)) {
					if (currentSelection == items - 1) {
						currentSelection = 0;

					} else {
						currentSelection++;
					}

				// use selected suggestion if user hit tab of return
				} else if (ImGui::IsKeyPressed(ImGuiKey_Tab) || ImGui::IsKeyPressed(ImGuiKey_Enter) || ImGui::IsKeyPressed(ImGuiKey_KeypadEnter)) {
					requestDeactivation = true;
					result = true;

				} else if (configuration.autoInsertSingleSuggestions && triggeredManually && state.suggestions.size() == 1) {
					requestDeactivation = true;
					result = true;
				}

				// render suggestions
				for (size_t i = 0; i < items; i++) {
					// ensure unique ID
					ImGui::PushID(static_cast<int>(i));

					// scroll list to selected item (if required)
					auto selected = i == currentSelection;

					if (selected) {
						ImGui::SetScrollHereY(1.0f);
					}

					if (renderSuggestion(state.suggestions[i].c_str(), state.searchTerm, ImGui::GetContentRegionAvail().x, selected)) {
						// user clicked on a suggestion, use it
						currentSelection = i;
						requestDeactivation = true;
						result = true;
					}

					ImGui::PopID();
				}

			} else {
				ImGui::TextUnformatted(configuration.noSuggestionsLabel.c_str());
			}
		}

		ImGui::EndPopup();

	} else {
		requestDeactivation = false;
		active = false;
	}

	return result;
}


//
//	TextEditor::AutoComplete::setSuggestions
//

void TextEditor::AutoComplete::setSuggestions(const std::vector<std::string>& suggestions) {
	state.suggestions = suggestions;
	currentSelection = 0;
}


//
//	TextEditor::AutoComplete::isSpecialKeyPressed
//

bool TextEditor::AutoComplete::isSpecialKeyPressed() {
	for (auto key : {ImGuiKey_Tab, ImGuiKey_Enter, ImGuiKey_KeypadEnter, ImGuiKey_UpArrow, ImGuiKey_DownArrow}) {
		if (ImGui::IsKeyPressed(key)) {
			return true;
		}
	}

	return false;
}


//
//	TextEditor::AutoComplete::start
//

void TextEditor::AutoComplete::start(Cursors& cursors) {
	// request start of autocomplete mode (can't be done here as the Dear ImGui context might not be right)
	requestActivation = true;
	currentLocation = cursors.getMain().getSelectionEnd();
	activationTime = std::chrono::system_clock::now() + configuration.triggerDelay;
}


//
//	TextEditor::AutoComplete::updateState
//

void TextEditor::AutoComplete::updateState(Document& document, const Language* language) {
	state.searchTerm = document.getSectionText(startLocation, currentLocation);

	if (currentLocation.index == 0) {
		state.inIdentifier = false;
		state.inNumber = false;

		auto lineState = document[currentLocation.line].state;
		state.inComment = lineStateInComment(lineState);
		state.inString = lineStateInString(lineState);

	} else {
		auto color = document.getColor(document.getLeft(currentLocation));
		state.inIdentifier = color == Color::identifier || color == Color::knownIdentifier;
		state.inNumber = color == Color::number;
		state.inComment = color == Color::comment;
		state.inString = color == Color::string;
	}

	state.searchTermStart = startLocation;
	state.searchTermEnd = currentLocation;

	state.language = language;
	state.userData = configuration.userData;
}


//
//	TextEditor::AutoComplete::refreshSuggestions
//

void TextEditor::AutoComplete::refreshSuggestions() {
	// populate suggestion list through callback (or clear it if there is none)
	if (configuration.callback) {
		configuration.callback(state);

	} else {
		state.suggestions.clear();
	}

	currentSelection = 0;
}


//
//	Range table types
//

template <typename T>
struct Range {
	T low;
	T high;
};

using Range16 = Range<ImWchar16>;
using Range32 = Range<ImWchar32>;

template <typename T>
struct StrideRange {
	T low;
	T high;
	T stride;
};

using StrideRange16 = StrideRange<ImWchar16>;
using StrideRange32 = StrideRange<ImWchar32>;

template <typename T>
struct CaseRange {
	T low;
	T high;
	int32_t toUpper;
	int32_t toLower;
};

using CaseRange16 = CaseRange<char16_t>;
using CaseRange32 = CaseRange<char32_t>;


//
//	letters16
//

static StrideRange16 letters16[] = {
	{0x0041, 0x005a, 0x0001}, {0x0061, 0x007a, 0x0001}, {0x00aa, 0x00b5, 0x000b}, {0x00ba, 0x00c0, 0x0006},
	{0x00c1, 0x00d6, 0x0001}, {0x00d8, 0x00f6, 0x0001}, {0x00f8, 0x02c1, 0x0001}, {0x02c6, 0x02d1, 0x0001},
	{0x02e0, 0x02e4, 0x0001}, {0x02ec, 0x02ee, 0x0002}, {0x0370, 0x0374, 0x0001}, {0x0376, 0x0377, 0x0001},
	{0x037a, 0x037d, 0x0001}, {0x037f, 0x0386, 0x0007}, {0x0388, 0x038a, 0x0001}, {0x038c, 0x038e, 0x0002},
	{0x038f, 0x03a1, 0x0001}, {0x03a3, 0x03f5, 0x0001}, {0x03f7, 0x0481, 0x0001}, {0x048a, 0x052f, 0x0001},
	{0x0531, 0x0556, 0x0001}, {0x0559, 0x0560, 0x0007}, {0x0561, 0x0588, 0x0001}, {0x05d0, 0x05ea, 0x0001},
	{0x05ef, 0x05f2, 0x0001}, {0x0620, 0x064a, 0x0001}, {0x066e, 0x066f, 0x0001}, {0x0671, 0x06d3, 0x0001},
	{0x06d5, 0x06e5, 0x0010}, {0x06e6, 0x06ee, 0x0008}, {0x06ef, 0x06fa, 0x000b}, {0x06fb, 0x06fc, 0x0001},
	{0x06ff, 0x0710, 0x0011}, {0x0712, 0x072f, 0x0001}, {0x074d, 0x07a5, 0x0001}, {0x07b1, 0x07ca, 0x0019},
	{0x07cb, 0x07ea, 0x0001}, {0x07f4, 0x07f5, 0x0001}, {0x07fa, 0x0800, 0x0006}, {0x0801, 0x0815, 0x0001},
	{0x081a, 0x0824, 0x000a}, {0x0828, 0x0840, 0x0018}, {0x0841, 0x0858, 0x0001}, {0x0860, 0x086a, 0x0001},
	{0x0870, 0x0887, 0x0001}, {0x0889, 0x088f, 0x0001}, {0x08a0, 0x08c9, 0x0001}, {0x0904, 0x0939, 0x0001},
	{0x093d, 0x0950, 0x0013}, {0x0958, 0x0961, 0x0001}, {0x0971, 0x0980, 0x0001}, {0x0985, 0x098c, 0x0001},
	{0x098f, 0x0990, 0x0001}, {0x0993, 0x09a8, 0x0001}, {0x09aa, 0x09b0, 0x0001}, {0x09b2, 0x09b6, 0x0004},
	{0x09b7, 0x09b9, 0x0001}, {0x09bd, 0x09ce, 0x0011}, {0x09dc, 0x09dd, 0x0001}, {0x09df, 0x09e1, 0x0001},
	{0x09f0, 0x09f1, 0x0001}, {0x09fc, 0x0a05, 0x0009}, {0x0a06, 0x0a0a, 0x0001}, {0x0a0f, 0x0a10, 0x0001},
	{0x0a13, 0x0a28, 0x0001}, {0x0a2a, 0x0a30, 0x0001}, {0x0a32, 0x0a33, 0x0001}, {0x0a35, 0x0a36, 0x0001},
	{0x0a38, 0x0a39, 0x0001}, {0x0a59, 0x0a5c, 0x0001}, {0x0a5e, 0x0a72, 0x0014}, {0x0a73, 0x0a74, 0x0001},
	{0x0a85, 0x0a8d, 0x0001}, {0x0a8f, 0x0a91, 0x0001}, {0x0a93, 0x0aa8, 0x0001}, {0x0aaa, 0x0ab0, 0x0001},
	{0x0ab2, 0x0ab3, 0x0001}, {0x0ab5, 0x0ab9, 0x0001}, {0x0abd, 0x0ad0, 0x0013}, {0x0ae0, 0x0ae1, 0x0001},
	{0x0af9, 0x0b05, 0x000c}, {0x0b06, 0x0b0c, 0x0001}, {0x0b0f, 0x0b10, 0x0001}, {0x0b13, 0x0b28, 0x0001},
	{0x0b2a, 0x0b30, 0x0001}, {0x0b32, 0x0b33, 0x0001}, {0x0b35, 0x0b39, 0x0001}, {0x0b3d, 0x0b5c, 0x001f},
	{0x0b5d, 0x0b5f, 0x0002}, {0x0b60, 0x0b61, 0x0001}, {0x0b71, 0x0b83, 0x0012}, {0x0b85, 0x0b8a, 0x0001},
	{0x0b8e, 0x0b90, 0x0001}, {0x0b92, 0x0b95, 0x0001}, {0x0b99, 0x0b9a, 0x0001}, {0x0b9c, 0x0b9e, 0x0002},
	{0x0b9f, 0x0ba3, 0x0004}, {0x0ba4, 0x0ba8, 0x0004}, {0x0ba9, 0x0baa, 0x0001}, {0x0bae, 0x0bb9, 0x0001},
	{0x0bd0, 0x0c05, 0x0035}, {0x0c06, 0x0c0c, 0x0001}, {0x0c0e, 0x0c10, 0x0001}, {0x0c12, 0x0c28, 0x0001},
	{0x0c2a, 0x0c39, 0x0001}, {0x0c3d, 0x0c58, 0x001b}, {0x0c59, 0x0c5a, 0x0001}, {0x0c5c, 0x0c5d, 0x0001},
	{0x0c60, 0x0c61, 0x0001}, {0x0c80, 0x0c85, 0x0005}, {0x0c86, 0x0c8c, 0x0001}, {0x0c8e, 0x0c90, 0x0001},
	{0x0c92, 0x0ca8, 0x0001}, {0x0caa, 0x0cb3, 0x0001}, {0x0cb5, 0x0cb9, 0x0001}, {0x0cbd, 0x0cdc, 0x001f},
	{0x0cdd, 0x0cde, 0x0001}, {0x0ce0, 0x0ce1, 0x0001}, {0x0cf1, 0x0cf2, 0x0001}, {0x0d04, 0x0d0c, 0x0001},
	{0x0d0e, 0x0d10, 0x0001}, {0x0d12, 0x0d3a, 0x0001}, {0x0d3d, 0x0d4e, 0x0011}, {0x0d54, 0x0d56, 0x0001},
	{0x0d5f, 0x0d61, 0x0001}, {0x0d7a, 0x0d7f, 0x0001}, {0x0d85, 0x0d96, 0x0001}, {0x0d9a, 0x0db1, 0x0001},
	{0x0db3, 0x0dbb, 0x0001}, {0x0dbd, 0x0dc0, 0x0003}, {0x0dc1, 0x0dc6, 0x0001}, {0x0e01, 0x0e30, 0x0001},
	{0x0e32, 0x0e33, 0x0001}, {0x0e40, 0x0e46, 0x0001}, {0x0e81, 0x0e82, 0x0001}, {0x0e84, 0x0e86, 0x0002},
	{0x0e87, 0x0e8a, 0x0001}, {0x0e8c, 0x0ea3, 0x0001}, {0x0ea5, 0x0ea7, 0x0002}, {0x0ea8, 0x0eb0, 0x0001},
	{0x0eb2, 0x0eb3, 0x0001}, {0x0ebd, 0x0ec0, 0x0003}, {0x0ec1, 0x0ec4, 0x0001}, {0x0ec6, 0x0edc, 0x0016},
	{0x0edd, 0x0edf, 0x0001}, {0x0f00, 0x0f40, 0x0040}, {0x0f41, 0x0f47, 0x0001}, {0x0f49, 0x0f6c, 0x0001},
	{0x0f88, 0x0f8c, 0x0001}, {0x1000, 0x102a, 0x0001}, {0x103f, 0x1050, 0x0011}, {0x1051, 0x1055, 0x0001},
	{0x105a, 0x105d, 0x0001}, {0x1061, 0x1065, 0x0004}, {0x1066, 0x106e, 0x0008}, {0x106f, 0x1070, 0x0001},
	{0x1075, 0x1081, 0x0001}, {0x108e, 0x10a0, 0x0012}, {0x10a1, 0x10c5, 0x0001}, {0x10c7, 0x10cd, 0x0006},
	{0x10d0, 0x10fa, 0x0001}, {0x10fc, 0x1248, 0x0001}, {0x124a, 0x124d, 0x0001}, {0x1250, 0x1256, 0x0001},
	{0x1258, 0x125a, 0x0002}, {0x125b, 0x125d, 0x0001}, {0x1260, 0x1288, 0x0001}, {0x128a, 0x128d, 0x0001},
	{0x1290, 0x12b0, 0x0001}, {0x12b2, 0x12b5, 0x0001}, {0x12b8, 0x12be, 0x0001}, {0x12c0, 0x12c2, 0x0002},
	{0x12c3, 0x12c5, 0x0001}, {0x12c8, 0x12d6, 0x0001}, {0x12d8, 0x1310, 0x0001}, {0x1312, 0x1315, 0x0001},
	{0x1318, 0x135a, 0x0001}, {0x1380, 0x138f, 0x0001}, {0x13a0, 0x13f5, 0x0001}, {0x13f8, 0x13fd, 0x0001},
	{0x1401, 0x166c, 0x0001}, {0x166f, 0x167f, 0x0001}, {0x1681, 0x169a, 0x0001}, {0x16a0, 0x16ea, 0x0001},
	{0x16f1, 0x16f8, 0x0001}, {0x1700, 0x1711, 0x0001}, {0x171f, 0x1731, 0x0001}, {0x1740, 0x1751, 0x0001},
	{0x1760, 0x176c, 0x0001}, {0x176e, 0x1770, 0x0001}, {0x1780, 0x17b3, 0x0001}, {0x17d7, 0x17dc, 0x0005},
	{0x1820, 0x1878, 0x0001}, {0x1880, 0x1884, 0x0001}, {0x1887, 0x18a8, 0x0001}, {0x18aa, 0x18b0, 0x0006},
	{0x18b1, 0x18f5, 0x0001}, {0x1900, 0x191e, 0x0001}, {0x1950, 0x196d, 0x0001}, {0x1970, 0x1974, 0x0001},
	{0x1980, 0x19ab, 0x0001}, {0x19b0, 0x19c9, 0x0001}, {0x1a00, 0x1a16, 0x0001}, {0x1a20, 0x1a54, 0x0001},
	{0x1aa7, 0x1b05, 0x005e}, {0x1b06, 0x1b33, 0x0001}, {0x1b45, 0x1b4c, 0x0001}, {0x1b83, 0x1ba0, 0x0001},
	{0x1bae, 0x1baf, 0x0001}, {0x1bba, 0x1be5, 0x0001}, {0x1c00, 0x1c23, 0x0001}, {0x1c4d, 0x1c4f, 0x0001},
	{0x1c5a, 0x1c7d, 0x0001}, {0x1c80, 0x1c8a, 0x0001}, {0x1c90, 0x1cba, 0x0001}, {0x1cbd, 0x1cbf, 0x0001},
	{0x1ce9, 0x1cec, 0x0001}, {0x1cee, 0x1cf3, 0x0001}, {0x1cf5, 0x1cf6, 0x0001}, {0x1cfa, 0x1d00, 0x0006},
	{0x1d01, 0x1dbf, 0x0001}, {0x1e00, 0x1f15, 0x0001}, {0x1f18, 0x1f1d, 0x0001}, {0x1f20, 0x1f45, 0x0001},
	{0x1f48, 0x1f4d, 0x0001}, {0x1f50, 0x1f57, 0x0001}, {0x1f59, 0x1f5f, 0x0002}, {0x1f60, 0x1f7d, 0x0001},
	{0x1f80, 0x1fb4, 0x0001}, {0x1fb6, 0x1fbc, 0x0001}, {0x1fbe, 0x1fc2, 0x0004}, {0x1fc3, 0x1fc4, 0x0001},
	{0x1fc6, 0x1fcc, 0x0001}, {0x1fd0, 0x1fd3, 0x0001}, {0x1fd6, 0x1fdb, 0x0001}, {0x1fe0, 0x1fec, 0x0001},
	{0x1ff2, 0x1ff4, 0x0001}, {0x1ff6, 0x1ffc, 0x0001}, {0x2071, 0x207f, 0x000e}, {0x2090, 0x209c, 0x0001},
	{0x2102, 0x2107, 0x0005}, {0x210a, 0x2113, 0x0001}, {0x2115, 0x2119, 0x0004}, {0x211a, 0x211d, 0x0001},
	{0x2124, 0x212a, 0x0002}, {0x212b, 0x212d, 0x0001}, {0x212f, 0x2139, 0x0001}, {0x213c, 0x213f, 0x0001},
	{0x2145, 0x2149, 0x0001}, {0x214e, 0x2183, 0x0035}, {0x2184, 0x2c00, 0x0a7c}, {0x2c01, 0x2ce4, 0x0001},
	{0x2ceb, 0x2cee, 0x0001}, {0x2cf2, 0x2cf3, 0x0001}, {0x2d00, 0x2d25, 0x0001}, {0x2d27, 0x2d2d, 0x0006},
	{0x2d30, 0x2d67, 0x0001}, {0x2d6f, 0x2d80, 0x0011}, {0x2d81, 0x2d96, 0x0001}, {0x2da0, 0x2da6, 0x0001},
	{0x2da8, 0x2dae, 0x0001}, {0x2db0, 0x2db6, 0x0001}, {0x2db8, 0x2dbe, 0x0001}, {0x2dc0, 0x2dc6, 0x0001},
	{0x2dc8, 0x2dce, 0x0001}, {0x2dd0, 0x2dd6, 0x0001}, {0x2dd8, 0x2dde, 0x0001}, {0x2e2f, 0x3005, 0x01d6},
	{0x3006, 0x3031, 0x002b}, {0x3032, 0x3035, 0x0001}, {0x303b, 0x303c, 0x0001}, {0x3041, 0x3096, 0x0001},
	{0x309d, 0x309f, 0x0001}, {0x30a1, 0x30fa, 0x0001}, {0x30fc, 0x30ff, 0x0001}, {0x3105, 0x312f, 0x0001},
	{0x3131, 0x318e, 0x0001}, {0x31a0, 0x31bf, 0x0001}, {0x31f0, 0x31ff, 0x0001}, {0x3400, 0x4dbf, 0x19bf},
	{0x4e00, 0x9fff, 0x51ff}, {0xa000, 0xa48c, 0x0001}, {0xa4d0, 0xa4fd, 0x0001}, {0xa500, 0xa60c, 0x0001},
	{0xa610, 0xa61f, 0x0001}, {0xa62a, 0xa62b, 0x0001}, {0xa640, 0xa66e, 0x0001}, {0xa67f, 0xa69d, 0x0001},
	{0xa6a0, 0xa6e5, 0x0001}, {0xa717, 0xa71f, 0x0001}, {0xa722, 0xa788, 0x0001}, {0xa78b, 0xa7dc, 0x0001},
	{0xa7f1, 0xa801, 0x0001}, {0xa803, 0xa805, 0x0001}, {0xa807, 0xa80a, 0x0001}, {0xa80c, 0xa822, 0x0001},
	{0xa840, 0xa873, 0x0001}, {0xa882, 0xa8b3, 0x0001}, {0xa8f2, 0xa8f7, 0x0001}, {0xa8fb, 0xa8fd, 0x0002},
	{0xa8fe, 0xa90a, 0x000c}, {0xa90b, 0xa925, 0x0001}, {0xa930, 0xa946, 0x0001}, {0xa960, 0xa97c, 0x0001},
	{0xa984, 0xa9b2, 0x0001}, {0xa9cf, 0xa9e0, 0x0011}, {0xa9e1, 0xa9e4, 0x0001}, {0xa9e6, 0xa9ef, 0x0001},
	{0xa9fa, 0xa9fe, 0x0001}, {0xaa00, 0xaa28, 0x0001}, {0xaa40, 0xaa42, 0x0001}, {0xaa44, 0xaa4b, 0x0001},
	{0xaa60, 0xaa76, 0x0001}, {0xaa7a, 0xaa7e, 0x0004}, {0xaa7f, 0xaaaf, 0x0001}, {0xaab1, 0xaab5, 0x0004},
	{0xaab6, 0xaab9, 0x0003}, {0xaaba, 0xaabd, 0x0001}, {0xaac0, 0xaac2, 0x0002}, {0xaadb, 0xaadd, 0x0001},
	{0xaae0, 0xaaea, 0x0001}, {0xaaf2, 0xaaf4, 0x0001}, {0xab01, 0xab06, 0x0001}, {0xab09, 0xab0e, 0x0001},
	{0xab11, 0xab16, 0x0001}, {0xab20, 0xab26, 0x0001}, {0xab28, 0xab2e, 0x0001}, {0xab30, 0xab5a, 0x0001},
	{0xab5c, 0xab69, 0x0001}, {0xab70, 0xabe2, 0x0001}, {0xac00, 0xd7a3, 0x2ba3}, {0xd7b0, 0xd7c6, 0x0001},
	{0xd7cb, 0xd7fb, 0x0001}, {0xf900, 0xfa6d, 0x0001}, {0xfa70, 0xfad9, 0x0001}, {0xfb00, 0xfb06, 0x0001},
	{0xfb13, 0xfb17, 0x0001}, {0xfb1d, 0xfb1f, 0x0002}, {0xfb20, 0xfb28, 0x0001}, {0xfb2a, 0xfb36, 0x0001},
	{0xfb38, 0xfb3c, 0x0001}, {0xfb3e, 0xfb40, 0x0002}, {0xfb41, 0xfb43, 0x0002}, {0xfb44, 0xfb46, 0x0002},
	{0xfb47, 0xfbb1, 0x0001}, {0xfbd3, 0xfd3d, 0x0001}, {0xfd50, 0xfd8f, 0x0001}, {0xfd92, 0xfdc7, 0x0001},
	{0xfdf0, 0xfdfb, 0x0001}, {0xfe70, 0xfe74, 0x0001}, {0xfe76, 0xfefc, 0x0001}, {0xff21, 0xff3a, 0x0001},
	{0xff41, 0xff5a, 0x0001}, {0xff66, 0xffbe, 0x0001}, {0xffc2, 0xffc7, 0x0001}, {0xffca, 0xffcf, 0x0001},
	{0xffd2, 0xffd7, 0x0001}, {0xffda, 0xffdc, 0x0001}
};


//
//	letters32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 letters32[] = {
	{0x10000, 0x1000b, 0x0001}, {0x1000d, 0x10026, 0x0001}, {0x10028, 0x1003a, 0x0001}, {0x1003c, 0x1003d, 0x0001},
	{0x1003f, 0x1004d, 0x0001}, {0x10050, 0x1005d, 0x0001}, {0x10080, 0x100fa, 0x0001}, {0x10280, 0x1029c, 0x0001},
	{0x102a0, 0x102d0, 0x0001}, {0x10300, 0x1031f, 0x0001}, {0x1032d, 0x10340, 0x0001}, {0x10342, 0x10349, 0x0001},
	{0x10350, 0x10375, 0x0001}, {0x10380, 0x1039d, 0x0001}, {0x103a0, 0x103c3, 0x0001}, {0x103c8, 0x103cf, 0x0001},
	{0x10400, 0x1049d, 0x0001}, {0x104b0, 0x104d3, 0x0001}, {0x104d8, 0x104fb, 0x0001}, {0x10500, 0x10527, 0x0001},
	{0x10530, 0x10563, 0x0001}, {0x10570, 0x1057a, 0x0001}, {0x1057c, 0x1058a, 0x0001}, {0x1058c, 0x10592, 0x0001},
	{0x10594, 0x10595, 0x0001}, {0x10597, 0x105a1, 0x0001}, {0x105a3, 0x105b1, 0x0001}, {0x105b3, 0x105b9, 0x0001},
	{0x105bb, 0x105bc, 0x0001}, {0x105c0, 0x105f3, 0x0001}, {0x10600, 0x10736, 0x0001}, {0x10740, 0x10755, 0x0001},
	{0x10760, 0x10767, 0x0001}, {0x10780, 0x10785, 0x0001}, {0x10787, 0x107b0, 0x0001}, {0x107b2, 0x107ba, 0x0001},
	{0x10800, 0x10805, 0x0001}, {0x10808, 0x1080a, 0x0002}, {0x1080b, 0x10835, 0x0001}, {0x10837, 0x10838, 0x0001},
	{0x1083c, 0x1083f, 0x0003}, {0x10840, 0x10855, 0x0001}, {0x10860, 0x10876, 0x0001}, {0x10880, 0x1089e, 0x0001},
	{0x108e0, 0x108f2, 0x0001}, {0x108f4, 0x108f5, 0x0001}, {0x10900, 0x10915, 0x0001}, {0x10920, 0x10939, 0x0001},
	{0x10940, 0x10959, 0x0001}, {0x10980, 0x109b7, 0x0001}, {0x109be, 0x109bf, 0x0001}, {0x10a00, 0x10a10, 0x0010},
	{0x10a11, 0x10a13, 0x0001}, {0x10a15, 0x10a17, 0x0001}, {0x10a19, 0x10a35, 0x0001}, {0x10a60, 0x10a7c, 0x0001},
	{0x10a80, 0x10a9c, 0x0001}, {0x10ac0, 0x10ac7, 0x0001}, {0x10ac9, 0x10ae4, 0x0001}, {0x10b00, 0x10b35, 0x0001},
	{0x10b40, 0x10b55, 0x0001}, {0x10b60, 0x10b72, 0x0001}, {0x10b80, 0x10b91, 0x0001}, {0x10c00, 0x10c48, 0x0001},
	{0x10c80, 0x10cb2, 0x0001}, {0x10cc0, 0x10cf2, 0x0001}, {0x10d00, 0x10d23, 0x0001}, {0x10d4a, 0x10d65, 0x0001},
	{0x10d6f, 0x10d85, 0x0001}, {0x10e80, 0x10ea9, 0x0001}, {0x10eb0, 0x10eb1, 0x0001}, {0x10ec2, 0x10ec7, 0x0001},
	{0x10f00, 0x10f1c, 0x0001}, {0x10f27, 0x10f30, 0x0009}, {0x10f31, 0x10f45, 0x0001}, {0x10f70, 0x10f81, 0x0001},
	{0x10fb0, 0x10fc4, 0x0001}, {0x10fe0, 0x10ff6, 0x0001}, {0x11003, 0x11037, 0x0001}, {0x11071, 0x11072, 0x0001},
	{0x11075, 0x11083, 0x000e}, {0x11084, 0x110af, 0x0001}, {0x110d0, 0x110e8, 0x0001}, {0x11103, 0x11126, 0x0001},
	{0x11144, 0x11147, 0x0003}, {0x11150, 0x11172, 0x0001}, {0x11176, 0x11183, 0x000d}, {0x11184, 0x111b2, 0x0001},
	{0x111c1, 0x111c4, 0x0001}, {0x111da, 0x111dc, 0x0002}, {0x11200, 0x11211, 0x0001}, {0x11213, 0x1122b, 0x0001},
	{0x1123f, 0x11240, 0x0001}, {0x11280, 0x11286, 0x0001}, {0x11288, 0x1128a, 0x0002}, {0x1128b, 0x1128d, 0x0001},
	{0x1128f, 0x1129d, 0x0001}, {0x1129f, 0x112a8, 0x0001}, {0x112b0, 0x112de, 0x0001}, {0x11305, 0x1130c, 0x0001},
	{0x1130f, 0x11310, 0x0001}, {0x11313, 0x11328, 0x0001}, {0x1132a, 0x11330, 0x0001}, {0x11332, 0x11333, 0x0001},
	{0x11335, 0x11339, 0x0001}, {0x1133d, 0x11350, 0x0013}, {0x1135d, 0x11361, 0x0001}, {0x11380, 0x11389, 0x0001},
	{0x1138b, 0x1138e, 0x0003}, {0x11390, 0x113b5, 0x0001}, {0x113b7, 0x113d1, 0x001a}, {0x113d3, 0x11400, 0x002d},
	{0x11401, 0x11434, 0x0001}, {0x11447, 0x1144a, 0x0001}, {0x1145f, 0x11461, 0x0001}, {0x11480, 0x114af, 0x0001},
	{0x114c4, 0x114c5, 0x0001}, {0x114c7, 0x11580, 0x00b9}, {0x11581, 0x115ae, 0x0001}, {0x115d8, 0x115db, 0x0001},
	{0x11600, 0x1162f, 0x0001}, {0x11644, 0x11680, 0x003c}, {0x11681, 0x116aa, 0x0001}, {0x116b8, 0x11700, 0x0048},
	{0x11701, 0x1171a, 0x0001}, {0x11740, 0x11746, 0x0001}, {0x11800, 0x1182b, 0x0001}, {0x118a0, 0x118df, 0x0001},
	{0x118ff, 0x11906, 0x0001}, {0x11909, 0x1190c, 0x0003}, {0x1190d, 0x11913, 0x0001}, {0x11915, 0x11916, 0x0001},
	{0x11918, 0x1192f, 0x0001}, {0x1193f, 0x11941, 0x0002}, {0x119a0, 0x119a7, 0x0001}, {0x119aa, 0x119d0, 0x0001},
	{0x119e1, 0x119e3, 0x0002}, {0x11a00, 0x11a0b, 0x000b}, {0x11a0c, 0x11a32, 0x0001}, {0x11a3a, 0x11a50, 0x0016},
	{0x11a5c, 0x11a89, 0x0001}, {0x11a9d, 0x11ab0, 0x0013}, {0x11ab1, 0x11af8, 0x0001}, {0x11bc0, 0x11be0, 0x0001},
	{0x11c00, 0x11c08, 0x0001}, {0x11c0a, 0x11c2e, 0x0001}, {0x11c40, 0x11c72, 0x0032}, {0x11c73, 0x11c8f, 0x0001},
	{0x11d00, 0x11d06, 0x0001}, {0x11d08, 0x11d09, 0x0001}, {0x11d0b, 0x11d30, 0x0001}, {0x11d46, 0x11d60, 0x001a},
	{0x11d61, 0x11d65, 0x0001}, {0x11d67, 0x11d68, 0x0001}, {0x11d6a, 0x11d89, 0x0001}, {0x11d98, 0x11db0, 0x0018},
	{0x11db1, 0x11ddb, 0x0001}, {0x11ee0, 0x11ef2, 0x0001}, {0x11f02, 0x11f04, 0x0002}, {0x11f05, 0x11f10, 0x0001},
	{0x11f12, 0x11f33, 0x0001}, {0x11fb0, 0x12000, 0x0050}, {0x12001, 0x12399, 0x0001}, {0x12480, 0x12543, 0x0001},
	{0x12f90, 0x12ff0, 0x0001}, {0x13000, 0x1342f, 0x0001}, {0x13441, 0x13446, 0x0001}, {0x13460, 0x143fa, 0x0001},
	{0x14400, 0x14646, 0x0001}, {0x16100, 0x1611d, 0x0001}, {0x16800, 0x16a38, 0x0001}, {0x16a40, 0x16a5e, 0x0001},
	{0x16a70, 0x16abe, 0x0001}, {0x16ad0, 0x16aed, 0x0001}, {0x16b00, 0x16b2f, 0x0001}, {0x16b40, 0x16b43, 0x0001},
	{0x16b63, 0x16b77, 0x0001}, {0x16b7d, 0x16b8f, 0x0001}, {0x16d40, 0x16d6c, 0x0001}, {0x16e40, 0x16e7f, 0x0001},
	{0x16ea0, 0x16eb8, 0x0001}, {0x16ebb, 0x16ed3, 0x0001}, {0x16f00, 0x16f4a, 0x0001}, {0x16f50, 0x16f93, 0x0043},
	{0x16f94, 0x16f9f, 0x0001}, {0x16fe0, 0x16fe1, 0x0001}, {0x16fe3, 0x16ff2, 0x000f}, {0x16ff3, 0x17000, 0x000d},
	{0x187ff, 0x18cd5, 0x0001}, {0x18cff, 0x18d00, 0x0001}, {0x18d1e, 0x18d80, 0x0062}, {0x18d81, 0x18df2, 0x0001},
	{0x1aff0, 0x1aff3, 0x0001}, {0x1aff5, 0x1affb, 0x0001}, {0x1affd, 0x1affe, 0x0001}, {0x1b000, 0x1b122, 0x0001},
	{0x1b132, 0x1b150, 0x001e}, {0x1b151, 0x1b152, 0x0001}, {0x1b155, 0x1b164, 0x000f}, {0x1b165, 0x1b167, 0x0001},
	{0x1b170, 0x1b2fb, 0x0001}, {0x1bc00, 0x1bc6a, 0x0001}, {0x1bc70, 0x1bc7c, 0x0001}, {0x1bc80, 0x1bc88, 0x0001},
	{0x1bc90, 0x1bc99, 0x0001}, {0x1d400, 0x1d454, 0x0001}, {0x1d456, 0x1d49c, 0x0001}, {0x1d49e, 0x1d49f, 0x0001},
	{0x1d4a2, 0x1d4a5, 0x0003}, {0x1d4a6, 0x1d4a9, 0x0003}, {0x1d4aa, 0x1d4ac, 0x0001}, {0x1d4ae, 0x1d4b9, 0x0001},
	{0x1d4bb, 0x1d4bd, 0x0002}, {0x1d4be, 0x1d4c3, 0x0001}, {0x1d4c5, 0x1d505, 0x0001}, {0x1d507, 0x1d50a, 0x0001},
	{0x1d50d, 0x1d514, 0x0001}, {0x1d516, 0x1d51c, 0x0001}, {0x1d51e, 0x1d539, 0x0001}, {0x1d53b, 0x1d53e, 0x0001},
	{0x1d540, 0x1d544, 0x0001}, {0x1d546, 0x1d54a, 0x0004}, {0x1d54b, 0x1d550, 0x0001}, {0x1d552, 0x1d6a5, 0x0001},
	{0x1d6a8, 0x1d6c0, 0x0001}, {0x1d6c2, 0x1d6da, 0x0001}, {0x1d6dc, 0x1d6fa, 0x0001}, {0x1d6fc, 0x1d714, 0x0001},
	{0x1d716, 0x1d734, 0x0001}, {0x1d736, 0x1d74e, 0x0001}, {0x1d750, 0x1d76e, 0x0001}, {0x1d770, 0x1d788, 0x0001},
	{0x1d78a, 0x1d7a8, 0x0001}, {0x1d7aa, 0x1d7c2, 0x0001}, {0x1d7c4, 0x1d7cb, 0x0001}, {0x1df00, 0x1df1e, 0x0001},
	{0x1df25, 0x1df2a, 0x0001}, {0x1e030, 0x1e06d, 0x0001}, {0x1e100, 0x1e12c, 0x0001}, {0x1e137, 0x1e13d, 0x0001},
	{0x1e14e, 0x1e290, 0x0142}, {0x1e291, 0x1e2ad, 0x0001}, {0x1e2c0, 0x1e2eb, 0x0001}, {0x1e4d0, 0x1e4eb, 0x0001},
	{0x1e5d0, 0x1e5ed, 0x0001}, {0x1e5f0, 0x1e6c0, 0x00d0}, {0x1e6c1, 0x1e6de, 0x0001}, {0x1e6e0, 0x1e6e2, 0x0001},
	{0x1e6e4, 0x1e6e5, 0x0001}, {0x1e6e7, 0x1e6ed, 0x0001}, {0x1e6f0, 0x1e6f4, 0x0001}, {0x1e6fe, 0x1e6ff, 0x0001},
	{0x1e7e0, 0x1e7e6, 0x0001}, {0x1e7e8, 0x1e7eb, 0x0001}, {0x1e7ed, 0x1e7ee, 0x0001}, {0x1e7f0, 0x1e7fe, 0x0001},
	{0x1e800, 0x1e8c4, 0x0001}, {0x1e900, 0x1e943, 0x0001}, {0x1e94b, 0x1ee00, 0x04b5}, {0x1ee01, 0x1ee03, 0x0001},
	{0x1ee05, 0x1ee1f, 0x0001}, {0x1ee21, 0x1ee22, 0x0001}, {0x1ee24, 0x1ee27, 0x0003}, {0x1ee29, 0x1ee32, 0x0001},
	{0x1ee34, 0x1ee37, 0x0001}, {0x1ee39, 0x1ee3b, 0x0002}, {0x1ee42, 0x1ee47, 0x0005}, {0x1ee49, 0x1ee4d, 0x0002},
	{0x1ee4e, 0x1ee4f, 0x0001}, {0x1ee51, 0x1ee52, 0x0001}, {0x1ee54, 0x1ee57, 0x0003}, {0x1ee59, 0x1ee61, 0x0002},
	{0x1ee62, 0x1ee64, 0x0002}, {0x1ee67, 0x1ee6a, 0x0001}, {0x1ee6c, 0x1ee72, 0x0001}, {0x1ee74, 0x1ee77, 0x0001},
	{0x1ee79, 0x1ee7c, 0x0001}, {0x1ee7e, 0x1ee80, 0x0002}, {0x1ee81, 0x1ee89, 0x0001}, {0x1ee8b, 0x1ee9b, 0x0001},
	{0x1eea1, 0x1eea3, 0x0001}, {0x1eea5, 0x1eea9, 0x0001}, {0x1eeab, 0x1eebb, 0x0001}, {0x20000, 0x2a6df, 0xa6df},
	{0x2a700, 0x2b73f, 0x103f}, {0x2b740, 0x2b81d, 0x00dd}, {0x2b820, 0x2cead, 0x168d}, {0x2ceb0, 0x2ebe0, 0x1d30},
	{0x2ebf0, 0x2ee5d, 0x026d}, {0x2f800, 0x2fa1d, 0x0001}, {0x30000, 0x3134a, 0x134a}, {0x31350, 0x323af, 0x105f},
	{0x323b0, 0x33479, 0x10c9}
};

#endif


//
//	lower16
//

static StrideRange16 lower16[] = {
	{0x0061, 0x007a, 0x0001}, {0x00b5, 0x00df, 0x002a}, {0x00e0, 0x00f6, 0x0001}, {0x00f8, 0x00ff, 0x0001},
	{0x0101, 0x0137, 0x0002}, {0x0138, 0x0148, 0x0002}, {0x0149, 0x0177, 0x0002}, {0x017a, 0x017e, 0x0002},
	{0x017f, 0x0180, 0x0001}, {0x0183, 0x0185, 0x0002}, {0x0188, 0x018c, 0x0004}, {0x018d, 0x0192, 0x0005},
	{0x0195, 0x0199, 0x0004}, {0x019a, 0x019b, 0x0001}, {0x019e, 0x01a1, 0x0003}, {0x01a3, 0x01a5, 0x0002},
	{0x01a8, 0x01aa, 0x0002}, {0x01ab, 0x01ad, 0x0002}, {0x01b0, 0x01b4, 0x0004}, {0x01b6, 0x01b9, 0x0003},
	{0x01ba, 0x01bd, 0x0003}, {0x01be, 0x01bf, 0x0001}, {0x01c6, 0x01cc, 0x0003}, {0x01ce, 0x01dc, 0x0002},
	{0x01dd, 0x01ef, 0x0002}, {0x01f0, 0x01f3, 0x0003}, {0x01f5, 0x01f9, 0x0004}, {0x01fb, 0x0233, 0x0002},
	{0x0234, 0x0239, 0x0001}, {0x023c, 0x023f, 0x0003}, {0x0240, 0x0242, 0x0002}, {0x0247, 0x024f, 0x0002},
	{0x0250, 0x0293, 0x0001}, {0x0296, 0x02af, 0x0001}, {0x0371, 0x0373, 0x0002}, {0x0377, 0x037b, 0x0004},
	{0x037c, 0x037d, 0x0001}, {0x0390, 0x03ac, 0x001c}, {0x03ad, 0x03ce, 0x0001}, {0x03d0, 0x03d1, 0x0001},
	{0x03d5, 0x03d7, 0x0001}, {0x03d9, 0x03ef, 0x0002}, {0x03f0, 0x03f3, 0x0001}, {0x03f5, 0x03fb, 0x0003},
	{0x03fc, 0x0430, 0x0034}, {0x0431, 0x045f, 0x0001}, {0x0461, 0x0481, 0x0002}, {0x048b, 0x04bf, 0x0002},
	{0x04c2, 0x04ce, 0x0002}, {0x04cf, 0x052f, 0x0002}, {0x0560, 0x0588, 0x0001}, {0x10d0, 0x10fa, 0x0001},
	{0x10fd, 0x10ff, 0x0001}, {0x13f8, 0x13fd, 0x0001}, {0x1c80, 0x1c88, 0x0001}, {0x1c8a, 0x1d00, 0x0076},
	{0x1d01, 0x1d2b, 0x0001}, {0x1d6b, 0x1d77, 0x0001}, {0x1d79, 0x1d9a, 0x0001}, {0x1e01, 0x1e95, 0x0002},
	{0x1e96, 0x1e9d, 0x0001}, {0x1e9f, 0x1eff, 0x0002}, {0x1f00, 0x1f07, 0x0001}, {0x1f10, 0x1f15, 0x0001},
	{0x1f20, 0x1f27, 0x0001}, {0x1f30, 0x1f37, 0x0001}, {0x1f40, 0x1f45, 0x0001}, {0x1f50, 0x1f57, 0x0001},
	{0x1f60, 0x1f67, 0x0001}, {0x1f70, 0x1f7d, 0x0001}, {0x1f80, 0x1f87, 0x0001}, {0x1f90, 0x1f97, 0x0001},
	{0x1fa0, 0x1fa7, 0x0001}, {0x1fb0, 0x1fb4, 0x0001}, {0x1fb6, 0x1fb7, 0x0001}, {0x1fbe, 0x1fc2, 0x0004},
	{0x1fc3, 0x1fc4, 0x0001}, {0x1fc6, 0x1fc7, 0x0001}, {0x1fd0, 0x1fd3, 0x0001}, {0x1fd6, 0x1fd7, 0x0001},
	{0x1fe0, 0x1fe7, 0x0001}, {0x1ff2, 0x1ff4, 0x0001}, {0x1ff6, 0x1ff7, 0x0001}, {0x210a, 0x210e, 0x0004},
	{0x210f, 0x2113, 0x0004}, {0x212f, 0x2139, 0x0005}, {0x213c, 0x213d, 0x0001}, {0x2146, 0x2149, 0x0001},
	{0x214e, 0x2184, 0x0036}, {0x2c30, 0x2c5f, 0x0001}, {0x2c61, 0x2c65, 0x0004}, {0x2c66, 0x2c6c, 0x0002},
	{0x2c71, 0x2c73, 0x0002}, {0x2c74, 0x2c76, 0x0002}, {0x2c77, 0x2c7b, 0x0001}, {0x2c81, 0x2ce3, 0x0002},
	{0x2ce4, 0x2cec, 0x0008}, {0x2cee, 0x2cf3, 0x0005}, {0x2d00, 0x2d25, 0x0001}, {0x2d27, 0x2d2d, 0x0006},
	{0xa641, 0xa66d, 0x0002}, {0xa681, 0xa69b, 0x0002}, {0xa723, 0xa72f, 0x0002}, {0xa730, 0xa731, 0x0001},
	{0xa733, 0xa771, 0x0002}, {0xa772, 0xa778, 0x0001}, {0xa77a, 0xa77c, 0x0002}, {0xa77f, 0xa787, 0x0002},
	{0xa78c, 0xa78e, 0x0002}, {0xa791, 0xa793, 0x0002}, {0xa794, 0xa795, 0x0001}, {0xa797, 0xa7a9, 0x0002},
	{0xa7af, 0xa7b5, 0x0006}, {0xa7b7, 0xa7c3, 0x0002}, {0xa7c8, 0xa7ca, 0x0002}, {0xa7cd, 0xa7db, 0x0002},
	{0xa7f6, 0xa7fa, 0x0004}, {0xab30, 0xab5a, 0x0001}, {0xab60, 0xab68, 0x0001}, {0xab70, 0xabbf, 0x0001},
	{0xfb00, 0xfb06, 0x0001}, {0xfb13, 0xfb17, 0x0001}, {0xff41, 0xff5a, 0x0001}
};


//
//	lower32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 lower32[] = {
	{0x10428, 0x1044f, 0x0001}, {0x104d8, 0x104fb, 0x0001}, {0x10597, 0x105a1, 0x0001}, {0x105a3, 0x105b1, 0x0001},
	{0x105b3, 0x105b9, 0x0001}, {0x105bb, 0x105bc, 0x0001}, {0x10cc0, 0x10cf2, 0x0001}, {0x10d70, 0x10d85, 0x0001},
	{0x118c0, 0x118df, 0x0001}, {0x16e60, 0x16e7f, 0x0001}, {0x16ebb, 0x16ed3, 0x0001}, {0x1d41a, 0x1d433, 0x0001},
	{0x1d44e, 0x1d454, 0x0001}, {0x1d456, 0x1d467, 0x0001}, {0x1d482, 0x1d49b, 0x0001}, {0x1d4b6, 0x1d4b9, 0x0001},
	{0x1d4bb, 0x1d4bd, 0x0002}, {0x1d4be, 0x1d4c3, 0x0001}, {0x1d4c5, 0x1d4cf, 0x0001}, {0x1d4ea, 0x1d503, 0x0001},
	{0x1d51e, 0x1d537, 0x0001}, {0x1d552, 0x1d56b, 0x0001}, {0x1d586, 0x1d59f, 0x0001}, {0x1d5ba, 0x1d5d3, 0x0001},
	{0x1d5ee, 0x1d607, 0x0001}, {0x1d622, 0x1d63b, 0x0001}, {0x1d656, 0x1d66f, 0x0001}, {0x1d68a, 0x1d6a5, 0x0001},
	{0x1d6c2, 0x1d6da, 0x0001}, {0x1d6dc, 0x1d6e1, 0x0001}, {0x1d6fc, 0x1d714, 0x0001}, {0x1d716, 0x1d71b, 0x0001},
	{0x1d736, 0x1d74e, 0x0001}, {0x1d750, 0x1d755, 0x0001}, {0x1d770, 0x1d788, 0x0001}, {0x1d78a, 0x1d78f, 0x0001},
	{0x1d7aa, 0x1d7c2, 0x0001}, {0x1d7c4, 0x1d7c9, 0x0001}, {0x1d7cb, 0x1df00, 0x0735}, {0x1df01, 0x1df09, 0x0001},
	{0x1df0b, 0x1df1e, 0x0001}, {0x1df25, 0x1df2a, 0x0001}, {0x1e922, 0x1e943, 0x0001}
};

#endif


//
//	upper16
//

static StrideRange16 upper16[] = {
	{0x0041, 0x005a, 0x0001}, {0x00c0, 0x00d6, 0x0001}, {0x00d8, 0x00de, 0x0001}, {0x0100, 0x0136, 0x0002},
	{0x0139, 0x0147, 0x0002}, {0x014a, 0x0178, 0x0002}, {0x0179, 0x017d, 0x0002}, {0x0181, 0x0182, 0x0001},
	{0x0184, 0x0186, 0x0002}, {0x0187, 0x0189, 0x0002}, {0x018a, 0x018b, 0x0001}, {0x018e, 0x0191, 0x0001},
	{0x0193, 0x0194, 0x0001}, {0x0196, 0x0198, 0x0001}, {0x019c, 0x019d, 0x0001}, {0x019f, 0x01a0, 0x0001},
	{0x01a2, 0x01a6, 0x0002}, {0x01a7, 0x01a9, 0x0002}, {0x01ac, 0x01ae, 0x0002}, {0x01af, 0x01b1, 0x0002},
	{0x01b2, 0x01b3, 0x0001}, {0x01b5, 0x01b7, 0x0002}, {0x01b8, 0x01bc, 0x0004}, {0x01c4, 0x01cd, 0x0003},
	{0x01cf, 0x01db, 0x0002}, {0x01de, 0x01ee, 0x0002}, {0x01f1, 0x01f4, 0x0003}, {0x01f6, 0x01f8, 0x0001},
	{0x01fa, 0x0232, 0x0002}, {0x023a, 0x023b, 0x0001}, {0x023d, 0x023e, 0x0001}, {0x0241, 0x0243, 0x0002},
	{0x0244, 0x0246, 0x0001}, {0x0248, 0x024e, 0x0002}, {0x0370, 0x0372, 0x0002}, {0x0376, 0x037f, 0x0009},
	{0x0386, 0x0388, 0x0002}, {0x0389, 0x038a, 0x0001}, {0x038c, 0x038e, 0x0002}, {0x038f, 0x0391, 0x0002},
	{0x0392, 0x03a1, 0x0001}, {0x03a3, 0x03ab, 0x0001}, {0x03cf, 0x03d2, 0x0003}, {0x03d3, 0x03d4, 0x0001},
	{0x03d8, 0x03ee, 0x0002}, {0x03f4, 0x03f7, 0x0003}, {0x03f9, 0x03fa, 0x0001}, {0x03fd, 0x042f, 0x0001},
	{0x0460, 0x0480, 0x0002}, {0x048a, 0x04c0, 0x0002}, {0x04c1, 0x04cd, 0x0002}, {0x04d0, 0x052e, 0x0002},
	{0x0531, 0x0556, 0x0001}, {0x10a0, 0x10c5, 0x0001}, {0x10c7, 0x10cd, 0x0006}, {0x13a0, 0x13f5, 0x0001},
	{0x1c89, 0x1c90, 0x0007}, {0x1c91, 0x1cba, 0x0001}, {0x1cbd, 0x1cbf, 0x0001}, {0x1e00, 0x1e94, 0x0002},
	{0x1e9e, 0x1efe, 0x0002}, {0x1f08, 0x1f0f, 0x0001}, {0x1f18, 0x1f1d, 0x0001}, {0x1f28, 0x1f2f, 0x0001},
	{0x1f38, 0x1f3f, 0x0001}, {0x1f48, 0x1f4d, 0x0001}, {0x1f59, 0x1f5f, 0x0002}, {0x1f68, 0x1f6f, 0x0001},
	{0x1fb8, 0x1fbb, 0x0001}, {0x1fc8, 0x1fcb, 0x0001}, {0x1fd8, 0x1fdb, 0x0001}, {0x1fe8, 0x1fec, 0x0001},
	{0x1ff8, 0x1ffb, 0x0001}, {0x2102, 0x2107, 0x0005}, {0x210b, 0x210d, 0x0001}, {0x2110, 0x2112, 0x0001},
	{0x2115, 0x2119, 0x0004}, {0x211a, 0x211d, 0x0001}, {0x2124, 0x212a, 0x0002}, {0x212b, 0x212d, 0x0001},
	{0x2130, 0x2133, 0x0001}, {0x213e, 0x213f, 0x0001}, {0x2145, 0x2183, 0x003e}, {0x2c00, 0x2c2f, 0x0001},
	{0x2c60, 0x2c62, 0x0002}, {0x2c63, 0x2c64, 0x0001}, {0x2c67, 0x2c6d, 0x0002}, {0x2c6e, 0x2c70, 0x0001},
	{0x2c72, 0x2c75, 0x0003}, {0x2c7e, 0x2c80, 0x0001}, {0x2c82, 0x2ce2, 0x0002}, {0x2ceb, 0x2ced, 0x0002},
	{0x2cf2, 0xa640, 0x794e}, {0xa642, 0xa66c, 0x0002}, {0xa680, 0xa69a, 0x0002}, {0xa722, 0xa72e, 0x0002},
	{0xa732, 0xa76e, 0x0002}, {0xa779, 0xa77d, 0x0002}, {0xa77e, 0xa786, 0x0002}, {0xa78b, 0xa78d, 0x0002},
	{0xa790, 0xa792, 0x0002}, {0xa796, 0xa7aa, 0x0002}, {0xa7ab, 0xa7ae, 0x0001}, {0xa7b0, 0xa7b4, 0x0001},
	{0xa7b6, 0xa7c4, 0x0002}, {0xa7c5, 0xa7c7, 0x0001}, {0xa7c9, 0xa7cb, 0x0002}, {0xa7cc, 0xa7dc, 0x0002},
	{0xa7f5, 0xff21, 0x572c}, {0xff22, 0xff3a, 0x0001}
};


//
//	upper32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 upper32[] = {
	{0x10400, 0x10427, 0x0001}, {0x104b0, 0x104d3, 0x0001}, {0x10570, 0x1057a, 0x0001}, {0x1057c, 0x1058a, 0x0001},
	{0x1058c, 0x10592, 0x0001}, {0x10594, 0x10595, 0x0001}, {0x10c80, 0x10cb2, 0x0001}, {0x10d50, 0x10d65, 0x0001},
	{0x118a0, 0x118bf, 0x0001}, {0x16e40, 0x16e5f, 0x0001}, {0x16ea0, 0x16eb8, 0x0001}, {0x1d400, 0x1d419, 0x0001},
	{0x1d434, 0x1d44d, 0x0001}, {0x1d468, 0x1d481, 0x0001}, {0x1d49c, 0x1d49e, 0x0002}, {0x1d49f, 0x1d4a5, 0x0003},
	{0x1d4a6, 0x1d4a9, 0x0003}, {0x1d4aa, 0x1d4ac, 0x0001}, {0x1d4ae, 0x1d4b5, 0x0001}, {0x1d4d0, 0x1d4e9, 0x0001},
	{0x1d504, 0x1d505, 0x0001}, {0x1d507, 0x1d50a, 0x0001}, {0x1d50d, 0x1d514, 0x0001}, {0x1d516, 0x1d51c, 0x0001},
	{0x1d538, 0x1d539, 0x0001}, {0x1d53b, 0x1d53e, 0x0001}, {0x1d540, 0x1d544, 0x0001}, {0x1d546, 0x1d54a, 0x0004},
	{0x1d54b, 0x1d550, 0x0001}, {0x1d56c, 0x1d585, 0x0001}, {0x1d5a0, 0x1d5b9, 0x0001}, {0x1d5d4, 0x1d5ed, 0x0001},
	{0x1d608, 0x1d621, 0x0001}, {0x1d63c, 0x1d655, 0x0001}, {0x1d670, 0x1d689, 0x0001}, {0x1d6a8, 0x1d6c0, 0x0001},
	{0x1d6e2, 0x1d6fa, 0x0001}, {0x1d71c, 0x1d734, 0x0001}, {0x1d756, 0x1d76e, 0x0001}, {0x1d790, 0x1d7a8, 0x0001},
	{0x1d7ca, 0x1e900, 0x1136}, {0x1e901, 0x1e921, 0x0001}
};

#endif


//
//	numbers16
//

static StrideRange16 numbers16[] = {
	{0x0030, 0x0039, 0x0001}, {0x0660, 0x0669, 0x0001}, {0x06f0, 0x06f9, 0x0001}, {0x07c0, 0x07c9, 0x0001},
	{0x0966, 0x096f, 0x0001}, {0x09e6, 0x09ef, 0x0001}, {0x0a66, 0x0a6f, 0x0001}, {0x0ae6, 0x0aef, 0x0001},
	{0x0b66, 0x0b6f, 0x0001}, {0x0be6, 0x0bef, 0x0001}, {0x0c66, 0x0c6f, 0x0001}, {0x0ce6, 0x0cef, 0x0001},
	{0x0d66, 0x0d6f, 0x0001}, {0x0de6, 0x0def, 0x0001}, {0x0e50, 0x0e59, 0x0001}, {0x0ed0, 0x0ed9, 0x0001},
	{0x0f20, 0x0f29, 0x0001}, {0x1040, 0x1049, 0x0001}, {0x1090, 0x1099, 0x0001}, {0x17e0, 0x17e9, 0x0001},
	{0x1810, 0x1819, 0x0001}, {0x1946, 0x194f, 0x0001}, {0x19d0, 0x19d9, 0x0001}, {0x1a80, 0x1a89, 0x0001},
	{0x1a90, 0x1a99, 0x0001}, {0x1b50, 0x1b59, 0x0001}, {0x1bb0, 0x1bb9, 0x0001}, {0x1c40, 0x1c49, 0x0001},
	{0x1c50, 0x1c59, 0x0001}, {0xa620, 0xa629, 0x0001}, {0xa8d0, 0xa8d9, 0x0001}, {0xa900, 0xa909, 0x0001},
	{0xa9d0, 0xa9d9, 0x0001}, {0xa9f0, 0xa9f9, 0x0001}, {0xaa50, 0xaa59, 0x0001}, {0xabf0, 0xabf9, 0x0001},
	{0xff10, 0xff19, 0x0001}
};


//
//	numbers32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 numbers32[] = {
	{0x104a0, 0x104a9, 0x0001}, {0x10d30, 0x10d39, 0x0001}, {0x10d40, 0x10d49, 0x0001}, {0x11066, 0x1106f, 0x0001},
	{0x110f0, 0x110f9, 0x0001}, {0x11136, 0x1113f, 0x0001}, {0x111d0, 0x111d9, 0x0001}, {0x112f0, 0x112f9, 0x0001},
	{0x11450, 0x11459, 0x0001}, {0x114d0, 0x114d9, 0x0001}, {0x11650, 0x11659, 0x0001}, {0x116c0, 0x116c9, 0x0001},
	{0x116d0, 0x116e3, 0x0001}, {0x11730, 0x11739, 0x0001}, {0x118e0, 0x118e9, 0x0001}, {0x11950, 0x11959, 0x0001},
	{0x11bf0, 0x11bf9, 0x0001}, {0x11c50, 0x11c59, 0x0001}, {0x11d50, 0x11d59, 0x0001}, {0x11da0, 0x11da9, 0x0001},
	{0x11de0, 0x11de9, 0x0001}, {0x11f50, 0x11f59, 0x0001}, {0x16130, 0x16139, 0x0001}, {0x16a60, 0x16a69, 0x0001},
	{0x16ac0, 0x16ac9, 0x0001}, {0x16b50, 0x16b59, 0x0001}, {0x16d70, 0x16d79, 0x0001}, {0x1ccf0, 0x1ccf9, 0x0001},
	{0x1d7ce, 0x1d7ff, 0x0001}, {0x1e140, 0x1e149, 0x0001}, {0x1e2f0, 0x1e2f9, 0x0001}, {0x1e4f0, 0x1e4f9, 0x0001},
	{0x1e5f1, 0x1e5fa, 0x0001}, {0x1e950, 0x1e959, 0x0001}, {0x1fbf0, 0x1fbf9, 0x0001}
};

#endif


//
//	whitespace16
//

static StrideRange16 whitespace16[] = {
	{0x0009, 0x000d, 0x0001}, {0x0020, 0x0085, 0x0065}, {0x00a0, 0x1680, 0x15e0}, {0x2000, 0x200a, 0x0001},
	{0x2028, 0x2029, 0x0001}, {0x202f, 0x205f, 0x0030}, {0x3000, 0x3000, 0x0001}
};


//
//	xidStart16
//

static StrideRange16 xidStart16[] = {
	{0x0041, 0x005a, 0x0001}, {0x0061, 0x007a, 0x0001}, {0x00aa, 0x00b5, 0x000b}, {0x00ba, 0x00c0, 0x0006},
	{0x00c1, 0x00d6, 0x0001}, {0x00d8, 0x00f6, 0x0001}, {0x00f8, 0x02c1, 0x0001}, {0x02c6, 0x02d1, 0x0001},
	{0x02e0, 0x02e4, 0x0001}, {0x02ec, 0x02ee, 0x0002}, {0x0370, 0x0374, 0x0001}, {0x0376, 0x0377, 0x0001},
	{0x037b, 0x037d, 0x0001}, {0x037f, 0x0386, 0x0007}, {0x0388, 0x038a, 0x0001}, {0x038c, 0x038e, 0x0002},
	{0x038f, 0x03a1, 0x0001}, {0x03a3, 0x03f5, 0x0001}, {0x03f7, 0x0481, 0x0001}, {0x048a, 0x052f, 0x0001},
	{0x0531, 0x0556, 0x0001}, {0x0559, 0x0560, 0x0007}, {0x0561, 0x0588, 0x0001}, {0x05d0, 0x05ea, 0x0001},
	{0x05ef, 0x05f2, 0x0001}, {0x0620, 0x064a, 0x0001}, {0x066e, 0x066f, 0x0001}, {0x0671, 0x06d3, 0x0001},
	{0x06d5, 0x06e5, 0x0010}, {0x06e6, 0x06ee, 0x0008}, {0x06ef, 0x06fa, 0x000b}, {0x06fb, 0x06fc, 0x0001},
	{0x06ff, 0x0710, 0x0011}, {0x0712, 0x072f, 0x0001}, {0x074d, 0x07a5, 0x0001}, {0x07b1, 0x07ca, 0x0019},
	{0x07cb, 0x07ea, 0x0001}, {0x07f4, 0x07f5, 0x0001}, {0x07fa, 0x0800, 0x0006}, {0x0801, 0x0815, 0x0001},
	{0x081a, 0x0824, 0x000a}, {0x0828, 0x0840, 0x0018}, {0x0841, 0x0858, 0x0001}, {0x0860, 0x086a, 0x0001},
	{0x0870, 0x0887, 0x0001}, {0x0889, 0x088f, 0x0001}, {0x08a0, 0x08c9, 0x0001}, {0x0904, 0x0939, 0x0001},
	{0x093d, 0x0950, 0x0013}, {0x0958, 0x0961, 0x0001}, {0x0971, 0x0980, 0x0001}, {0x0985, 0x098c, 0x0001},
	{0x098f, 0x0990, 0x0001}, {0x0993, 0x09a8, 0x0001}, {0x09aa, 0x09b0, 0x0001}, {0x09b2, 0x09b6, 0x0004},
	{0x09b7, 0x09b9, 0x0001}, {0x09bd, 0x09ce, 0x0011}, {0x09dc, 0x09dd, 0x0001}, {0x09df, 0x09e1, 0x0001},
	{0x09f0, 0x09f1, 0x0001}, {0x09fc, 0x0a05, 0x0009}, {0x0a06, 0x0a0a, 0x0001}, {0x0a0f, 0x0a10, 0x0001},
	{0x0a13, 0x0a28, 0x0001}, {0x0a2a, 0x0a30, 0x0001}, {0x0a32, 0x0a33, 0x0001}, {0x0a35, 0x0a36, 0x0001},
	{0x0a38, 0x0a39, 0x0001}, {0x0a59, 0x0a5c, 0x0001}, {0x0a5e, 0x0a72, 0x0014}, {0x0a73, 0x0a74, 0x0001},
	{0x0a85, 0x0a8d, 0x0001}, {0x0a8f, 0x0a91, 0x0001}, {0x0a93, 0x0aa8, 0x0001}, {0x0aaa, 0x0ab0, 0x0001},
	{0x0ab2, 0x0ab3, 0x0001}, {0x0ab5, 0x0ab9, 0x0001}, {0x0abd, 0x0ad0, 0x0013}, {0x0ae0, 0x0ae1, 0x0001},
	{0x0af9, 0x0b05, 0x000c}, {0x0b06, 0x0b0c, 0x0001}, {0x0b0f, 0x0b10, 0x0001}, {0x0b13, 0x0b28, 0x0001},
	{0x0b2a, 0x0b30, 0x0001}, {0x0b32, 0x0b33, 0x0001}, {0x0b35, 0x0b39, 0x0001}, {0x0b3d, 0x0b5c, 0x001f},
	{0x0b5d, 0x0b5f, 0x0002}, {0x0b60, 0x0b61, 0x0001}, {0x0b71, 0x0b83, 0x0012}, {0x0b85, 0x0b8a, 0x0001},
	{0x0b8e, 0x0b90, 0x0001}, {0x0b92, 0x0b95, 0x0001}, {0x0b99, 0x0b9a, 0x0001}, {0x0b9c, 0x0b9e, 0x0002},
	{0x0b9f, 0x0ba3, 0x0004}, {0x0ba4, 0x0ba8, 0x0004}, {0x0ba9, 0x0baa, 0x0001}, {0x0bae, 0x0bb9, 0x0001},
	{0x0bd0, 0x0c05, 0x0035}, {0x0c06, 0x0c0c, 0x0001}, {0x0c0e, 0x0c10, 0x0001}, {0x0c12, 0x0c28, 0x0001},
	{0x0c2a, 0x0c39, 0x0001}, {0x0c3d, 0x0c58, 0x001b}, {0x0c59, 0x0c5a, 0x0001}, {0x0c5c, 0x0c5d, 0x0001},
	{0x0c60, 0x0c61, 0x0001}, {0x0c80, 0x0c85, 0x0005}, {0x0c86, 0x0c8c, 0x0001}, {0x0c8e, 0x0c90, 0x0001},
	{0x0c92, 0x0ca8, 0x0001}, {0x0caa, 0x0cb3, 0x0001}, {0x0cb5, 0x0cb9, 0x0001}, {0x0cbd, 0x0cdc, 0x001f},
	{0x0cdd, 0x0cde, 0x0001}, {0x0ce0, 0x0ce1, 0x0001}, {0x0cf1, 0x0cf2, 0x0001}, {0x0d04, 0x0d0c, 0x0001},
	{0x0d0e, 0x0d10, 0x0001}, {0x0d12, 0x0d3a, 0x0001}, {0x0d3d, 0x0d4e, 0x0011}, {0x0d54, 0x0d56, 0x0001},
	{0x0d5f, 0x0d61, 0x0001}, {0x0d7a, 0x0d7f, 0x0001}, {0x0d85, 0x0d96, 0x0001}, {0x0d9a, 0x0db1, 0x0001},
	{0x0db3, 0x0dbb, 0x0001}, {0x0dbd, 0x0dc0, 0x0003}, {0x0dc1, 0x0dc6, 0x0001}, {0x0e01, 0x0e30, 0x0001},
	{0x0e32, 0x0e40, 0x000e}, {0x0e41, 0x0e46, 0x0001}, {0x0e81, 0x0e82, 0x0001}, {0x0e84, 0x0e86, 0x0002},
	{0x0e87, 0x0e8a, 0x0001}, {0x0e8c, 0x0ea3, 0x0001}, {0x0ea5, 0x0ea7, 0x0002}, {0x0ea8, 0x0eb0, 0x0001},
	{0x0eb2, 0x0ebd, 0x000b}, {0x0ec0, 0x0ec4, 0x0001}, {0x0ec6, 0x0edc, 0x0016}, {0x0edd, 0x0edf, 0x0001},
	{0x0f00, 0x0f40, 0x0040}, {0x0f41, 0x0f47, 0x0001}, {0x0f49, 0x0f6c, 0x0001}, {0x0f88, 0x0f8c, 0x0001},
	{0x1000, 0x102a, 0x0001}, {0x103f, 0x1050, 0x0011}, {0x1051, 0x1055, 0x0001}, {0x105a, 0x105d, 0x0001},
	{0x1061, 0x1065, 0x0004}, {0x1066, 0x106e, 0x0008}, {0x106f, 0x1070, 0x0001}, {0x1075, 0x1081, 0x0001},
	{0x108e, 0x10a0, 0x0012}, {0x10a1, 0x10c5, 0x0001}, {0x10c7, 0x10cd, 0x0006}, {0x10d0, 0x10fa, 0x0001},
	{0x10fc, 0x1248, 0x0001}, {0x124a, 0x124d, 0x0001}, {0x1250, 0x1256, 0x0001}, {0x1258, 0x125a, 0x0002},
	{0x125b, 0x125d, 0x0001}, {0x1260, 0x1288, 0x0001}, {0x128a, 0x128d, 0x0001}, {0x1290, 0x12b0, 0x0001},
	{0x12b2, 0x12b5, 0x0001}, {0x12b8, 0x12be, 0x0001}, {0x12c0, 0x12c2, 0x0002}, {0x12c3, 0x12c5, 0x0001},
	{0x12c8, 0x12d6, 0x0001}, {0x12d8, 0x1310, 0x0001}, {0x1312, 0x1315, 0x0001}, {0x1318, 0x135a, 0x0001},
	{0x1380, 0x138f, 0x0001}, {0x13a0, 0x13f5, 0x0001}, {0x13f8, 0x13fd, 0x0001}, {0x1401, 0x166c, 0x0001},
	{0x166f, 0x167f, 0x0001}, {0x1681, 0x169a, 0x0001}, {0x16a0, 0x16ea, 0x0001}, {0x16ee, 0x16f8, 0x0001},
	{0x1700, 0x1711, 0x0001}, {0x171f, 0x1731, 0x0001}, {0x1740, 0x1751, 0x0001}, {0x1760, 0x176c, 0x0001},
	{0x176e, 0x1770, 0x0001}, {0x1780, 0x17b3, 0x0001}, {0x17d7, 0x17dc, 0x0005}, {0x1820, 0x1878, 0x0001},
	{0x1880, 0x18a8, 0x0001}, {0x18aa, 0x18b0, 0x0006}, {0x18b1, 0x18f5, 0x0001}, {0x1900, 0x191e, 0x0001},
	{0x1950, 0x196d, 0x0001}, {0x1970, 0x1974, 0x0001}, {0x1980, 0x19ab, 0x0001}, {0x19b0, 0x19c9, 0x0001},
	{0x1a00, 0x1a16, 0x0001}, {0x1a20, 0x1a54, 0x0001}, {0x1aa7, 0x1b05, 0x005e}, {0x1b06, 0x1b33, 0x0001},
	{0x1b45, 0x1b4c, 0x0001}, {0x1b83, 0x1ba0, 0x0001}, {0x1bae, 0x1baf, 0x0001}, {0x1bba, 0x1be5, 0x0001},
	{0x1c00, 0x1c23, 0x0001}, {0x1c4d, 0x1c4f, 0x0001}, {0x1c5a, 0x1c7d, 0x0001}, {0x1c80, 0x1c8a, 0x0001},
	{0x1c90, 0x1cba, 0x0001}, {0x1cbd, 0x1cbf, 0x0001}, {0x1ce9, 0x1cec, 0x0001}, {0x1cee, 0x1cf3, 0x0001},
	{0x1cf5, 0x1cf6, 0x0001}, {0x1cfa, 0x1d00, 0x0006}, {0x1d01, 0x1dbf, 0x0001}, {0x1e00, 0x1f15, 0x0001},
	{0x1f18, 0x1f1d, 0x0001}, {0x1f20, 0x1f45, 0x0001}, {0x1f48, 0x1f4d, 0x0001}, {0x1f50, 0x1f57, 0x0001},
	{0x1f59, 0x1f5f, 0x0002}, {0x1f60, 0x1f7d, 0x0001}, {0x1f80, 0x1fb4, 0x0001}, {0x1fb6, 0x1fbc, 0x0001},
	{0x1fbe, 0x1fc2, 0x0004}, {0x1fc3, 0x1fc4, 0x0001}, {0x1fc6, 0x1fcc, 0x0001}, {0x1fd0, 0x1fd3, 0x0001},
	{0x1fd6, 0x1fdb, 0x0001}, {0x1fe0, 0x1fec, 0x0001}, {0x1ff2, 0x1ff4, 0x0001}, {0x1ff6, 0x1ffc, 0x0001},
	{0x2071, 0x207f, 0x000e}, {0x2090, 0x209c, 0x0001}, {0x2102, 0x2107, 0x0005}, {0x210a, 0x2113, 0x0001},
	{0x2115, 0x2118, 0x0003}, {0x2119, 0x211d, 0x0001}, {0x2124, 0x212a, 0x0002}, {0x212b, 0x2139, 0x0001},
	{0x213c, 0x213f, 0x0001}, {0x2145, 0x2149, 0x0001}, {0x214e, 0x2160, 0x0012}, {0x2161, 0x2188, 0x0001},
	{0x2c00, 0x2ce4, 0x0001}, {0x2ceb, 0x2cee, 0x0001}, {0x2cf2, 0x2cf3, 0x0001}, {0x2d00, 0x2d25, 0x0001},
	{0x2d27, 0x2d2d, 0x0006}, {0x2d30, 0x2d67, 0x0001}, {0x2d6f, 0x2d80, 0x0011}, {0x2d81, 0x2d96, 0x0001},
	{0x2da0, 0x2da6, 0x0001}, {0x2da8, 0x2dae, 0x0001}, {0x2db0, 0x2db6, 0x0001}, {0x2db8, 0x2dbe, 0x0001},
	{0x2dc0, 0x2dc6, 0x0001}, {0x2dc8, 0x2dce, 0x0001}, {0x2dd0, 0x2dd6, 0x0001}, {0x2dd8, 0x2dde, 0x0001},
	{0x3005, 0x3007, 0x0001}, {0x3021, 0x3029, 0x0001}, {0x3031, 0x3035, 0x0001}, {0x3038, 0x303c, 0x0001},
	{0x3041, 0x3096, 0x0001}, {0x309d, 0x309f, 0x0001}, {0x30a1, 0x30fa, 0x0001}, {0x30fc, 0x30ff, 0x0001},
	{0x3105, 0x312f, 0x0001}, {0x3131, 0x318e, 0x0001}, {0x31a0, 0x31bf, 0x0001}, {0x31f0, 0x31ff, 0x0001},
	{0x3400, 0x4dbf, 0x0001}, {0x4e00, 0xa48c, 0x0001}, {0xa4d0, 0xa4fd, 0x0001}, {0xa500, 0xa60c, 0x0001},
	{0xa610, 0xa61f, 0x0001}, {0xa62a, 0xa62b, 0x0001}, {0xa640, 0xa66e, 0x0001}, {0xa67f, 0xa69d, 0x0001},
	{0xa6a0, 0xa6ef, 0x0001}, {0xa717, 0xa71f, 0x0001}, {0xa722, 0xa788, 0x0001}, {0xa78b, 0xa7dc, 0x0001},
	{0xa7f1, 0xa801, 0x0001}, {0xa803, 0xa805, 0x0001}, {0xa807, 0xa80a, 0x0001}, {0xa80c, 0xa822, 0x0001},
	{0xa840, 0xa873, 0x0001}, {0xa882, 0xa8b3, 0x0001}, {0xa8f2, 0xa8f7, 0x0001}, {0xa8fb, 0xa8fd, 0x0002},
	{0xa8fe, 0xa90a, 0x000c}, {0xa90b, 0xa925, 0x0001}, {0xa930, 0xa946, 0x0001}, {0xa960, 0xa97c, 0x0001},
	{0xa984, 0xa9b2, 0x0001}, {0xa9cf, 0xa9e0, 0x0011}, {0xa9e1, 0xa9e4, 0x0001}, {0xa9e6, 0xa9ef, 0x0001},
	{0xa9fa, 0xa9fe, 0x0001}, {0xaa00, 0xaa28, 0x0001}, {0xaa40, 0xaa42, 0x0001}, {0xaa44, 0xaa4b, 0x0001},
	{0xaa60, 0xaa76, 0x0001}, {0xaa7a, 0xaa7e, 0x0004}, {0xaa7f, 0xaaaf, 0x0001}, {0xaab1, 0xaab5, 0x0004},
	{0xaab6, 0xaab9, 0x0003}, {0xaaba, 0xaabd, 0x0001}, {0xaac0, 0xaac2, 0x0002}, {0xaadb, 0xaadd, 0x0001},
	{0xaae0, 0xaaea, 0x0001}, {0xaaf2, 0xaaf4, 0x0001}, {0xab01, 0xab06, 0x0001}, {0xab09, 0xab0e, 0x0001},
	{0xab11, 0xab16, 0x0001}, {0xab20, 0xab26, 0x0001}, {0xab28, 0xab2e, 0x0001}, {0xab30, 0xab5a, 0x0001},
	{0xab5c, 0xab69, 0x0001}, {0xab70, 0xabe2, 0x0001}, {0xac00, 0xd7a3, 0x0001}, {0xd7b0, 0xd7c6, 0x0001},
	{0xd7cb, 0xd7fb, 0x0001}, {0xf900, 0xfa6d, 0x0001}, {0xfa70, 0xfad9, 0x0001}, {0xfb00, 0xfb06, 0x0001},
	{0xfb13, 0xfb17, 0x0001}, {0xfb1d, 0xfb1f, 0x0002}, {0xfb20, 0xfb28, 0x0001}, {0xfb2a, 0xfb36, 0x0001},
	{0xfb38, 0xfb3c, 0x0001}, {0xfb3e, 0xfb40, 0x0002}, {0xfb41, 0xfb43, 0x0002}, {0xfb44, 0xfb46, 0x0002},
	{0xfb47, 0xfbb1, 0x0001}, {0xfbd3, 0xfc5d, 0x0001}, {0xfc64, 0xfd3d, 0x0001}, {0xfd50, 0xfd8f, 0x0001},
	{0xfd92, 0xfdc7, 0x0001}, {0xfdf0, 0xfdf9, 0x0001}, {0xfe71, 0xfe73, 0x0002}, {0xfe77, 0xfe7f, 0x0002},
	{0xfe80, 0xfefc, 0x0001}, {0xff21, 0xff3a, 0x0001}, {0xff41, 0xff5a, 0x0001}, {0xff66, 0xff9d, 0x0001},
	{0xffa0, 0xffbe, 0x0001}, {0xffc2, 0xffc7, 0x0001}, {0xffca, 0xffcf, 0x0001}, {0xffd2, 0xffd7, 0x0001},
	{0xffda, 0xffdc, 0x0001}
};


//
//	xidStart32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 xidStart32[] = {
	{0x10000, 0x1000b, 0x0001}, {0x1000d, 0x10026, 0x0001}, {0x10028, 0x1003a, 0x0001}, {0x1003c, 0x1003d, 0x0001},
	{0x1003f, 0x1004d, 0x0001}, {0x10050, 0x1005d, 0x0001}, {0x10080, 0x100fa, 0x0001}, {0x10140, 0x10174, 0x0001},
	{0x10280, 0x1029c, 0x0001}, {0x102a0, 0x102d0, 0x0001}, {0x10300, 0x1031f, 0x0001}, {0x1032d, 0x1034a, 0x0001},
	{0x10350, 0x10375, 0x0001}, {0x10380, 0x1039d, 0x0001}, {0x103a0, 0x103c3, 0x0001}, {0x103c8, 0x103cf, 0x0001},
	{0x103d1, 0x103d5, 0x0001}, {0x10400, 0x1049d, 0x0001}, {0x104b0, 0x104d3, 0x0001}, {0x104d8, 0x104fb, 0x0001},
	{0x10500, 0x10527, 0x0001}, {0x10530, 0x10563, 0x0001}, {0x10570, 0x1057a, 0x0001}, {0x1057c, 0x1058a, 0x0001},
	{0x1058c, 0x10592, 0x0001}, {0x10594, 0x10595, 0x0001}, {0x10597, 0x105a1, 0x0001}, {0x105a3, 0x105b1, 0x0001},
	{0x105b3, 0x105b9, 0x0001}, {0x105bb, 0x105bc, 0x0001}, {0x105c0, 0x105f3, 0x0001}, {0x10600, 0x10736, 0x0001},
	{0x10740, 0x10755, 0x0001}, {0x10760, 0x10767, 0x0001}, {0x10780, 0x10785, 0x0001}, {0x10787, 0x107b0, 0x0001},
	{0x107b2, 0x107ba, 0x0001}, {0x10800, 0x10805, 0x0001}, {0x10808, 0x1080a, 0x0002}, {0x1080b, 0x10835, 0x0001},
	{0x10837, 0x10838, 0x0001}, {0x1083c, 0x1083f, 0x0003}, {0x10840, 0x10855, 0x0001}, {0x10860, 0x10876, 0x0001},
	{0x10880, 0x1089e, 0x0001}, {0x108e0, 0x108f2, 0x0001}, {0x108f4, 0x108f5, 0x0001}, {0x10900, 0x10915, 0x0001},
	{0x10920, 0x10939, 0x0001}, {0x10940, 0x10959, 0x0001}, {0x10980, 0x109b7, 0x0001}, {0x109be, 0x109bf, 0x0001},
	{0x10a00, 0x10a10, 0x0010}, {0x10a11, 0x10a13, 0x0001}, {0x10a15, 0x10a17, 0x0001}, {0x10a19, 0x10a35, 0x0001},
	{0x10a60, 0x10a7c, 0x0001}, {0x10a80, 0x10a9c, 0x0001}, {0x10ac0, 0x10ac7, 0x0001}, {0x10ac9, 0x10ae4, 0x0001},
	{0x10b00, 0x10b35, 0x0001}, {0x10b40, 0x10b55, 0x0001}, {0x10b60, 0x10b72, 0x0001}, {0x10b80, 0x10b91, 0x0001},
	{0x10c00, 0x10c48, 0x0001}, {0x10c80, 0x10cb2, 0x0001}, {0x10cc0, 0x10cf2, 0x0001}, {0x10d00, 0x10d23, 0x0001},
	{0x10d4a, 0x10d65, 0x0001}, {0x10d6f, 0x10d85, 0x0001}, {0x10e80, 0x10ea9, 0x0001}, {0x10eb0, 0x10eb1, 0x0001},
	{0x10ec2, 0x10ec7, 0x0001}, {0x10f00, 0x10f1c, 0x0001}, {0x10f27, 0x10f30, 0x0009}, {0x10f31, 0x10f45, 0x0001},
	{0x10f70, 0x10f81, 0x0001}, {0x10fb0, 0x10fc4, 0x0001}, {0x10fe0, 0x10ff6, 0x0001}, {0x11003, 0x11037, 0x0001},
	{0x11071, 0x11072, 0x0001}, {0x11075, 0x11083, 0x000e}, {0x11084, 0x110af, 0x0001}, {0x110d0, 0x110e8, 0x0001},
	{0x11103, 0x11126, 0x0001}, {0x11144, 0x11147, 0x0003}, {0x11150, 0x11172, 0x0001}, {0x11176, 0x11183, 0x000d},
	{0x11184, 0x111b2, 0x0001}, {0x111c1, 0x111c4, 0x0001}, {0x111da, 0x111dc, 0x0002}, {0x11200, 0x11211, 0x0001},
	{0x11213, 0x1122b, 0x0001}, {0x1123f, 0x11240, 0x0001}, {0x11280, 0x11286, 0x0001}, {0x11288, 0x1128a, 0x0002},
	{0x1128b, 0x1128d, 0x0001}, {0x1128f, 0x1129d, 0x0001}, {0x1129f, 0x112a8, 0x0001}, {0x112b0, 0x112de, 0x0001},
	{0x11305, 0x1130c, 0x0001}, {0x1130f, 0x11310, 0x0001}, {0x11313, 0x11328, 0x0001}, {0x1132a, 0x11330, 0x0001},
	{0x11332, 0x11333, 0x0001}, {0x11335, 0x11339, 0x0001}, {0x1133d, 0x11350, 0x0013}, {0x1135d, 0x11361, 0x0001},
	{0x11380, 0x11389, 0x0001}, {0x1138b, 0x1138e, 0x0003}, {0x11390, 0x113b5, 0x0001}, {0x113b7, 0x113d1, 0x001a},
	{0x113d3, 0x11400, 0x002d}, {0x11401, 0x11434, 0x0001}, {0x11447, 0x1144a, 0x0001}, {0x1145f, 0x11461, 0x0001},
	{0x11480, 0x114af, 0x0001}, {0x114c4, 0x114c5, 0x0001}, {0x114c7, 0x11580, 0x00b9}, {0x11581, 0x115ae, 0x0001},
	{0x115d8, 0x115db, 0x0001}, {0x11600, 0x1162f, 0x0001}, {0x11644, 0x11680, 0x003c}, {0x11681, 0x116aa, 0x0001},
	{0x116b8, 0x11700, 0x0048}, {0x11701, 0x1171a, 0x0001}, {0x11740, 0x11746, 0x0001}, {0x11800, 0x1182b, 0x0001},
	{0x118a0, 0x118df, 0x0001}, {0x118ff, 0x11906, 0x0001}, {0x11909, 0x1190c, 0x0003}, {0x1190d, 0x11913, 0x0001},
	{0x11915, 0x11916, 0x0001}, {0x11918, 0x1192f, 0x0001}, {0x1193f, 0x11941, 0x0002}, {0x119a0, 0x119a7, 0x0001},
	{0x119aa, 0x119d0, 0x0001}, {0x119e1, 0x119e3, 0x0002}, {0x11a00, 0x11a0b, 0x000b}, {0x11a0c, 0x11a32, 0x0001},
	{0x11a3a, 0x11a50, 0x0016}, {0x11a5c, 0x11a89, 0x0001}, {0x11a9d, 0x11ab0, 0x0013}, {0x11ab1, 0x11af8, 0x0001},
	{0x11bc0, 0x11be0, 0x0001}, {0x11c00, 0x11c08, 0x0001}, {0x11c0a, 0x11c2e, 0x0001}, {0x11c40, 0x11c72, 0x0032},
	{0x11c73, 0x11c8f, 0x0001}, {0x11d00, 0x11d06, 0x0001}, {0x11d08, 0x11d09, 0x0001}, {0x11d0b, 0x11d30, 0x0001},
	{0x11d46, 0x11d60, 0x001a}, {0x11d61, 0x11d65, 0x0001}, {0x11d67, 0x11d68, 0x0001}, {0x11d6a, 0x11d89, 0x0001},
	{0x11d98, 0x11db0, 0x0018}, {0x11db1, 0x11ddb, 0x0001}, {0x11ee0, 0x11ef2, 0x0001}, {0x11f02, 0x11f04, 0x0002},
	{0x11f05, 0x11f10, 0x0001}, {0x11f12, 0x11f33, 0x0001}, {0x11fb0, 0x12000, 0x0050}, {0x12001, 0x12399, 0x0001},
	{0x12400, 0x1246e, 0x0001}, {0x12480, 0x12543, 0x0001}, {0x12f90, 0x12ff0, 0x0001}, {0x13000, 0x1342f, 0x0001},
	{0x13441, 0x13446, 0x0001}, {0x13460, 0x143fa, 0x0001}, {0x14400, 0x14646, 0x0001}, {0x16100, 0x1611d, 0x0001},
	{0x16800, 0x16a38, 0x0001}, {0x16a40, 0x16a5e, 0x0001}, {0x16a70, 0x16abe, 0x0001}, {0x16ad0, 0x16aed, 0x0001},
	{0x16b00, 0x16b2f, 0x0001}, {0x16b40, 0x16b43, 0x0001}, {0x16b63, 0x16b77, 0x0001}, {0x16b7d, 0x16b8f, 0x0001},
	{0x16d40, 0x16d6c, 0x0001}, {0x16e40, 0x16e7f, 0x0001}, {0x16ea0, 0x16eb8, 0x0001}, {0x16ebb, 0x16ed3, 0x0001},
	{0x16f00, 0x16f4a, 0x0001}, {0x16f50, 0x16f93, 0x0043}, {0x16f94, 0x16f9f, 0x0001}, {0x16fe0, 0x16fe1, 0x0001},
	{0x16fe3, 0x16ff2, 0x000f}, {0x16ff3, 0x16ff6, 0x0001}, {0x17000, 0x18cd5, 0x0001}, {0x18cff, 0x18d1e, 0x0001},
	{0x18d80, 0x18df2, 0x0001}, {0x1aff0, 0x1aff3, 0x0001}, {0x1aff5, 0x1affb, 0x0001}, {0x1affd, 0x1affe, 0x0001},
	{0x1b000, 0x1b122, 0x0001}, {0x1b132, 0x1b150, 0x001e}, {0x1b151, 0x1b152, 0x0001}, {0x1b155, 0x1b164, 0x000f},
	{0x1b165, 0x1b167, 0x0001}, {0x1b170, 0x1b2fb, 0x0001}, {0x1bc00, 0x1bc6a, 0x0001}, {0x1bc70, 0x1bc7c, 0x0001},
	{0x1bc80, 0x1bc88, 0x0001}, {0x1bc90, 0x1bc99, 0x0001}, {0x1d400, 0x1d454, 0x0001}, {0x1d456, 0x1d49c, 0x0001},
	{0x1d49e, 0x1d49f, 0x0001}, {0x1d4a2, 0x1d4a5, 0x0003}, {0x1d4a6, 0x1d4a9, 0x0003}, {0x1d4aa, 0x1d4ac, 0x0001},
	{0x1d4ae, 0x1d4b9, 0x0001}, {0x1d4bb, 0x1d4bd, 0x0002}, {0x1d4be, 0x1d4c3, 0x0001}, {0x1d4c5, 0x1d505, 0x0001},
	{0x1d507, 0x1d50a, 0x0001}, {0x1d50d, 0x1d514, 0x0001}, {0x1d516, 0x1d51c, 0x0001}, {0x1d51e, 0x1d539, 0x0001},
	{0x1d53b, 0x1d53e, 0x0001}, {0x1d540, 0x1d544, 0x0001}, {0x1d546, 0x1d54a, 0x0004}, {0x1d54b, 0x1d550, 0x0001},
	{0x1d552, 0x1d6a5, 0x0001}, {0x1d6a8, 0x1d6c0, 0x0001}, {0x1d6c2, 0x1d6da, 0x0001}, {0x1d6dc, 0x1d6fa, 0x0001},
	{0x1d6fc, 0x1d714, 0x0001}, {0x1d716, 0x1d734, 0x0001}, {0x1d736, 0x1d74e, 0x0001}, {0x1d750, 0x1d76e, 0x0001},
	{0x1d770, 0x1d788, 0x0001}, {0x1d78a, 0x1d7a8, 0x0001}, {0x1d7aa, 0x1d7c2, 0x0001}, {0x1d7c4, 0x1d7cb, 0x0001},
	{0x1df00, 0x1df1e, 0x0001}, {0x1df25, 0x1df2a, 0x0001}, {0x1e030, 0x1e06d, 0x0001}, {0x1e100, 0x1e12c, 0x0001},
	{0x1e137, 0x1e13d, 0x0001}, {0x1e14e, 0x1e290, 0x0142}, {0x1e291, 0x1e2ad, 0x0001}, {0x1e2c0, 0x1e2eb, 0x0001},
	{0x1e4d0, 0x1e4eb, 0x0001}, {0x1e5d0, 0x1e5ed, 0x0001}, {0x1e5f0, 0x1e6c0, 0x00d0}, {0x1e6c1, 0x1e6de, 0x0001},
	{0x1e6e0, 0x1e6e2, 0x0001}, {0x1e6e4, 0x1e6e5, 0x0001}, {0x1e6e7, 0x1e6ed, 0x0001}, {0x1e6f0, 0x1e6f4, 0x0001},
	{0x1e6fe, 0x1e6ff, 0x0001}, {0x1e7e0, 0x1e7e6, 0x0001}, {0x1e7e8, 0x1e7eb, 0x0001}, {0x1e7ed, 0x1e7ee, 0x0001},
	{0x1e7f0, 0x1e7fe, 0x0001}, {0x1e800, 0x1e8c4, 0x0001}, {0x1e900, 0x1e943, 0x0001}, {0x1e94b, 0x1ee00, 0x04b5},
	{0x1ee01, 0x1ee03, 0x0001}, {0x1ee05, 0x1ee1f, 0x0001}, {0x1ee21, 0x1ee22, 0x0001}, {0x1ee24, 0x1ee27, 0x0003},
	{0x1ee29, 0x1ee32, 0x0001}, {0x1ee34, 0x1ee37, 0x0001}, {0x1ee39, 0x1ee3b, 0x0002}, {0x1ee42, 0x1ee47, 0x0005},
	{0x1ee49, 0x1ee4d, 0x0002}, {0x1ee4e, 0x1ee4f, 0x0001}, {0x1ee51, 0x1ee52, 0x0001}, {0x1ee54, 0x1ee57, 0x0003},
	{0x1ee59, 0x1ee61, 0x0002}, {0x1ee62, 0x1ee64, 0x0002}, {0x1ee67, 0x1ee6a, 0x0001}, {0x1ee6c, 0x1ee72, 0x0001},
	{0x1ee74, 0x1ee77, 0x0001}, {0x1ee79, 0x1ee7c, 0x0001}, {0x1ee7e, 0x1ee80, 0x0002}, {0x1ee81, 0x1ee89, 0x0001},
	{0x1ee8b, 0x1ee9b, 0x0001}, {0x1eea1, 0x1eea3, 0x0001}, {0x1eea5, 0x1eea9, 0x0001}, {0x1eeab, 0x1eebb, 0x0001},
	{0x20000, 0x2a6df, 0x0001}, {0x2a700, 0x2b81d, 0x0001}, {0x2b820, 0x2cead, 0x0001}, {0x2ceb0, 0x2ebe0, 0x0001},
	{0x2ebf0, 0x2ee5d, 0x0001}, {0x2f800, 0x2fa1d, 0x0001}, {0x30000, 0x3134a, 0x0001}, {0x31350, 0x33479, 0x0001}
};

#endif


//
//	xidContinue16
//

static StrideRange16 xidContinue16[] = {
	{0x0030, 0x0039, 0x0001}, {0x0041, 0x005a, 0x0001}, {0x005f, 0x0061, 0x0002}, {0x0062, 0x007a, 0x0001},
	{0x00aa, 0x00b5, 0x000b}, {0x00b7, 0x00ba, 0x0003}, {0x00c0, 0x00d6, 0x0001}, {0x00d8, 0x00f6, 0x0001},
	{0x00f8, 0x02c1, 0x0001}, {0x02c6, 0x02d1, 0x0001}, {0x02e0, 0x02e4, 0x0001}, {0x02ec, 0x02ee, 0x0002},
	{0x0300, 0x0374, 0x0001}, {0x0376, 0x0377, 0x0001}, {0x037b, 0x037d, 0x0001}, {0x037f, 0x0386, 0x0007},
	{0x0387, 0x038a, 0x0001}, {0x038c, 0x038e, 0x0002}, {0x038f, 0x03a1, 0x0001}, {0x03a3, 0x03f5, 0x0001},
	{0x03f7, 0x0481, 0x0001}, {0x0483, 0x0487, 0x0001}, {0x048a, 0x052f, 0x0001}, {0x0531, 0x0556, 0x0001},
	{0x0559, 0x0560, 0x0007}, {0x0561, 0x0588, 0x0001}, {0x0591, 0x05bd, 0x0001}, {0x05bf, 0x05c1, 0x0002},
	{0x05c2, 0x05c4, 0x0002}, {0x05c5, 0x05c7, 0x0002}, {0x05d0, 0x05ea, 0x0001}, {0x05ef, 0x05f2, 0x0001},
	{0x0610, 0x061a, 0x0001}, {0x0620, 0x0669, 0x0001}, {0x066e, 0x06d3, 0x0001}, {0x06d5, 0x06dc, 0x0001},
	{0x06df, 0x06e8, 0x0001}, {0x06ea, 0x06fc, 0x0001}, {0x06ff, 0x0710, 0x0011}, {0x0711, 0x074a, 0x0001},
	{0x074d, 0x07b1, 0x0001}, {0x07c0, 0x07f5, 0x0001}, {0x07fa, 0x0800, 0x0003}, {0x0801, 0x082d, 0x0001},
	{0x0840, 0x085b, 0x0001}, {0x0860, 0x086a, 0x0001}, {0x0870, 0x0887, 0x0001}, {0x0889, 0x088f, 0x0001},
	{0x0897, 0x08e1, 0x0001}, {0x08e3, 0x0963, 0x0001}, {0x0966, 0x096f, 0x0001}, {0x0971, 0x0983, 0x0001},
	{0x0985, 0x098c, 0x0001}, {0x098f, 0x0990, 0x0001}, {0x0993, 0x09a8, 0x0001}, {0x09aa, 0x09b0, 0x0001},
	{0x09b2, 0x09b6, 0x0004}, {0x09b7, 0x09b9, 0x0001}, {0x09bc, 0x09c4, 0x0001}, {0x09c7, 0x09c8, 0x0001},
	{0x09cb, 0x09ce, 0x0001}, {0x09d7, 0x09dc, 0x0005}, {0x09dd, 0x09df, 0x0002}, {0x09e0, 0x09e3, 0x0001},
	{0x09e6, 0x09f1, 0x0001}, {0x09fc, 0x09fe, 0x0002}, {0x0a01, 0x0a03, 0x0001}, {0x0a05, 0x0a0a, 0x0001},
	{0x0a0f, 0x0a10, 0x0001}, {0x0a13, 0x0a28, 0x0001}, {0x0a2a, 0x0a30, 0x0001}, {0x0a32, 0x0a33, 0x0001},
	{0x0a35, 0x0a36, 0x0001}, {0x0a38, 0x0a39, 0x0001}, {0x0a3c, 0x0a3e, 0x0002}, {0x0a3f, 0x0a42, 0x0001},
	{0x0a47, 0x0a48, 0x0001}, {0x0a4b, 0x0a4d, 0x0001}, {0x0a51, 0x0a59, 0x0008}, {0x0a5a, 0x0a5c, 0x0001},
	{0x0a5e, 0x0a66, 0x0008}, {0x0a67, 0x0a75, 0x0001}, {0x0a81, 0x0a83, 0x0001}, {0x0a85, 0x0a8d, 0x0001},
	{0x0a8f, 0x0a91, 0x0001}, {0x0a93, 0x0aa8, 0x0001}, {0x0aaa, 0x0ab0, 0x0001}, {0x0ab2, 0x0ab3, 0x0001},
	{0x0ab5, 0x0ab9, 0x0001}, {0x0abc, 0x0ac5, 0x0001}, {0x0ac7, 0x0ac9, 0x0001}, {0x0acb, 0x0acd, 0x0001},
	{0x0ad0, 0x0ae0, 0x0010}, {0x0ae1, 0x0ae3, 0x0001}, {0x0ae6, 0x0aef, 0x0001}, {0x0af9, 0x0aff, 0x0001},
	{0x0b01, 0x0b03, 0x0001}, {0x0b05, 0x0b0c, 0x0001}, {0x0b0f, 0x0b10, 0x0001}, {0x0b13, 0x0b28, 0x0001},
	{0x0b2a, 0x0b30, 0x0001}, {0x0b32, 0x0b33, 0x0001}, {0x0b35, 0x0b39, 0x0001}, {0x0b3c, 0x0b44, 0x0001},
	{0x0b47, 0x0b48, 0x0001}, {0x0b4b, 0x0b4d, 0x0001}, {0x0b55, 0x0b57, 0x0001}, {0x0b5c, 0x0b5d, 0x0001},
	{0x0b5f, 0x0b63, 0x0001}, {0x0b66, 0x0b6f, 0x0001}, {0x0b71, 0x0b82, 0x0011}, {0x0b83, 0x0b85, 0x0002},
	{0x0b86, 0x0b8a, 0x0001}, {0x0b8e, 0x0b90, 0x0001}, {0x0b92, 0x0b95, 0x0001}, {0x0b99, 0x0b9a, 0x0001},
	{0x0b9c, 0x0b9e, 0x0002}, {0x0b9f, 0x0ba3, 0x0004}, {0x0ba4, 0x0ba8, 0x0004}, {0x0ba9, 0x0baa, 0x0001},
	{0x0bae, 0x0bb9, 0x0001}, {0x0bbe, 0x0bc2, 0x0001}, {0x0bc6, 0x0bc8, 0x0001}, {0x0bca, 0x0bcd, 0x0001},
	{0x0bd0, 0x0bd7, 0x0007}, {0x0be6, 0x0bef, 0x0001}, {0x0c00, 0x0c0c, 0x0001}, {0x0c0e, 0x0c10, 0x0001},
	{0x0c12, 0x0c28, 0x0001}, {0x0c2a, 0x0c39, 0x0001}, {0x0c3c, 0x0c44, 0x0001}, {0x0c46, 0x0c48, 0x0001},
	{0x0c4a, 0x0c4d, 0x0001}, {0x0c55, 0x0c56, 0x0001}, {0x0c58, 0x0c5a, 0x0001}, {0x0c5c, 0x0c5d, 0x0001},
	{0x0c60, 0x0c63, 0x0001}, {0x0c66, 0x0c6f, 0x0001}, {0x0c80, 0x0c83, 0x0001}, {0x0c85, 0x0c8c, 0x0001},
	{0x0c8e, 0x0c90, 0x0001}, {0x0c92, 0x0ca8, 0x0001}, {0x0caa, 0x0cb3, 0x0001}, {0x0cb5, 0x0cb9, 0x0001},
	{0x0cbc, 0x0cc4, 0x0001}, {0x0cc6, 0x0cc8, 0x0001}, {0x0cca, 0x0ccd, 0x0001}, {0x0cd5, 0x0cd6, 0x0001},
	{0x0cdc, 0x0cde, 0x0001}, {0x0ce0, 0x0ce3, 0x0001}, {0x0ce6, 0x0cef, 0x0001}, {0x0cf1, 0x0cf3, 0x0001},
	{0x0d00, 0x0d0c, 0x0001}, {0x0d0e, 0x0d10, 0x0001}, {0x0d12, 0x0d44, 0x0001}, {0x0d46, 0x0d48, 0x0001},
	{0x0d4a, 0x0d4e, 0x0001}, {0x0d54, 0x0d57, 0x0001}, {0x0d5f, 0x0d63, 0x0001}, {0x0d66, 0x0d6f, 0x0001},
	{0x0d7a, 0x0d7f, 0x0001}, {0x0d81, 0x0d83, 0x0001}, {0x0d85, 0x0d96, 0x0001}, {0x0d9a, 0x0db1, 0x0001},
	{0x0db3, 0x0dbb, 0x0001}, {0x0dbd, 0x0dc0, 0x0003}, {0x0dc1, 0x0dc6, 0x0001}, {0x0dca, 0x0dcf, 0x0005},
	{0x0dd0, 0x0dd4, 0x0001}, {0x0dd6, 0x0dd8, 0x0002}, {0x0dd9, 0x0ddf, 0x0001}, {0x0de6, 0x0def, 0x0001},
	{0x0df2, 0x0df3, 0x0001}, {0x0e01, 0x0e3a, 0x0001}, {0x0e40, 0x0e4e, 0x0001}, {0x0e50, 0x0e59, 0x0001},
	{0x0e81, 0x0e82, 0x0001}, {0x0e84, 0x0e86, 0x0002}, {0x0e87, 0x0e8a, 0x0001}, {0x0e8c, 0x0ea3, 0x0001},
	{0x0ea5, 0x0ea7, 0x0002}, {0x0ea8, 0x0ebd, 0x0001}, {0x0ec0, 0x0ec4, 0x0001}, {0x0ec6, 0x0ec8, 0x0002},
	{0x0ec9, 0x0ece, 0x0001}, {0x0ed0, 0x0ed9, 0x0001}, {0x0edc, 0x0edf, 0x0001}, {0x0f00, 0x0f18, 0x0018},
	{0x0f19, 0x0f20, 0x0007}, {0x0f21, 0x0f29, 0x0001}, {0x0f35, 0x0f39, 0x0002}, {0x0f3e, 0x0f47, 0x0001},
	{0x0f49, 0x0f6c, 0x0001}, {0x0f71, 0x0f84, 0x0001}, {0x0f86, 0x0f97, 0x0001}, {0x0f99, 0x0fbc, 0x0001},
	{0x0fc6, 0x1000, 0x003a}, {0x1001, 0x1049, 0x0001}, {0x1050, 0x109d, 0x0001}, {0x10a0, 0x10c5, 0x0001},
	{0x10c7, 0x10cd, 0x0006}, {0x10d0, 0x10fa, 0x0001}, {0x10fc, 0x1248, 0x0001}, {0x124a, 0x124d, 0x0001},
	{0x1250, 0x1256, 0x0001}, {0x1258, 0x125a, 0x0002}, {0x125b, 0x125d, 0x0001}, {0x1260, 0x1288, 0x0001},
	{0x128a, 0x128d, 0x0001}, {0x1290, 0x12b0, 0x0001}, {0x12b2, 0x12b5, 0x0001}, {0x12b8, 0x12be, 0x0001},
	{0x12c0, 0x12c2, 0x0002}, {0x12c3, 0x12c5, 0x0001}, {0x12c8, 0x12d6, 0x0001}, {0x12d8, 0x1310, 0x0001},
	{0x1312, 0x1315, 0x0001}, {0x1318, 0x135a, 0x0001}, {0x135d, 0x135f, 0x0001}, {0x1369, 0x1371, 0x0001},
	{0x1380, 0x138f, 0x0001}, {0x13a0, 0x13f5, 0x0001}, {0x13f8, 0x13fd, 0x0001}, {0x1401, 0x166c, 0x0001},
	{0x166f, 0x167f, 0x0001}, {0x1681, 0x169a, 0x0001}, {0x16a0, 0x16ea, 0x0001}, {0x16ee, 0x16f8, 0x0001},
	{0x1700, 0x1715, 0x0001}, {0x171f, 0x1734, 0x0001}, {0x1740, 0x1753, 0x0001}, {0x1760, 0x176c, 0x0001},
	{0x176e, 0x1770, 0x0001}, {0x1772, 0x1773, 0x0001}, {0x1780, 0x17d3, 0x0001}, {0x17d7, 0x17dc, 0x0005},
	{0x17dd, 0x17e0, 0x0003}, {0x17e1, 0x17e9, 0x0001}, {0x180b, 0x180d, 0x0001}, {0x180f, 0x1819, 0x0001},
	{0x1820, 0x1878, 0x0001}, {0x1880, 0x18aa, 0x0001}, {0x18b0, 0x18f5, 0x0001}, {0x1900, 0x191e, 0x0001},
	{0x1920, 0x192b, 0x0001}, {0x1930, 0x193b, 0x0001}, {0x1946, 0x196d, 0x0001}, {0x1970, 0x1974, 0x0001},
	{0x1980, 0x19ab, 0x0001}, {0x19b0, 0x19c9, 0x0001}, {0x19d0, 0x19da, 0x0001}, {0x1a00, 0x1a1b, 0x0001},
	{0x1a20, 0x1a5e, 0x0001}, {0x1a60, 0x1a7c, 0x0001}, {0x1a7f, 0x1a89, 0x0001}, {0x1a90, 0x1a99, 0x0001},
	{0x1aa7, 0x1ab0, 0x0009}, {0x1ab1, 0x1abd, 0x0001}, {0x1abf, 0x1add, 0x0001}, {0x1ae0, 0x1aeb, 0x0001},
	{0x1b00, 0x1b4c, 0x0001}, {0x1b50, 0x1b59, 0x0001}, {0x1b6b, 0x1b73, 0x0001}, {0x1b80, 0x1bf3, 0x0001},
	{0x1c00, 0x1c37, 0x0001}, {0x1c40, 0x1c49, 0x0001}, {0x1c4d, 0x1c7d, 0x0001}, {0x1c80, 0x1c8a, 0x0001},
	{0x1c90, 0x1cba, 0x0001}, {0x1cbd, 0x1cbf, 0x0001}, {0x1cd0, 0x1cd2, 0x0001}, {0x1cd4, 0x1cfa, 0x0001},
	{0x1d00, 0x1f15, 0x0001}, {0x1f18, 0x1f1d, 0x0001}, {0x1f20, 0x1f45, 0x0001}, {0x1f48, 0x1f4d, 0x0001},
	{0x1f50, 0x1f57, 0x0001}, {0x1f59, 0x1f5f, 0x0002}, {0x1f60, 0x1f7d, 0x0001}, {0x1f80, 0x1fb4, 0x0001},
	{0x1fb6, 0x1fbc, 0x0001}, {0x1fbe, 0x1fc2, 0x0004}, {0x1fc3, 0x1fc4, 0x0001}, {0x1fc6, 0x1fcc, 0x0001},
	{0x1fd0, 0x1fd3, 0x0001}, {0x1fd6, 0x1fdb, 0x0001}, {0x1fe0, 0x1fec, 0x0001}, {0x1ff2, 0x1ff4, 0x0001},
	{0x1ff6, 0x1ffc, 0x0001}, {0x200c, 0x200d, 0x0001}, {0x203f, 0x2040, 0x0001}, {0x2054, 0x2071, 0x001d},
	{0x207f, 0x2090, 0x0011}, {0x2091, 0x209c, 0x0001}, {0x20d0, 0x20dc, 0x0001}, {0x20e1, 0x20e5, 0x0004},
	{0x20e6, 0x20f0, 0x0001}, {0x2102, 0x2107, 0x0005}, {0x210a, 0x2113, 0x0001}, {0x2115, 0x2118, 0x0003},
	{0x2119, 0x211d, 0x0001}, {0x2124, 0x212a, 0x0002}, {0x212b, 0x2139, 0x0001}, {0x213c, 0x213f, 0x0001},
	{0x2145, 0x2149, 0x0001}, {0x214e, 0x2160, 0x0012}, {0x2161, 0x2188, 0x0001}, {0x2c00, 0x2ce4, 0x0001},
	{0x2ceb, 0x2cf3, 0x0001}, {0x2d00, 0x2d25, 0x0001}, {0x2d27, 0x2d2d, 0x0006}, {0x2d30, 0x2d67, 0x0001},
	{0x2d6f, 0x2d7f, 0x0010}, {0x2d80, 0x2d96, 0x0001}, {0x2da0, 0x2da6, 0x0001}, {0x2da8, 0x2dae, 0x0001},
	{0x2db0, 0x2db6, 0x0001}, {0x2db8, 0x2dbe, 0x0001}, {0x2dc0, 0x2dc6, 0x0001}, {0x2dc8, 0x2dce, 0x0001},
	{0x2dd0, 0x2dd6, 0x0001}, {0x2dd8, 0x2dde, 0x0001}, {0x2de0, 0x2dff, 0x0001}, {0x3005, 0x3007, 0x0001},
	{0x3021, 0x302f, 0x0001}, {0x3031, 0x3035, 0x0001}, {0x3038, 0x303c, 0x0001}, {0x3041, 0x3096, 0x0001},
	{0x3099, 0x309a, 0x0001}, {0x309d, 0x309f, 0x0001}, {0x30a1, 0x30ff, 0x0001}, {0x3105, 0x312f, 0x0001},
	{0x3131, 0x318e, 0x0001}, {0x31a0, 0x31bf, 0x0001}, {0x31f0, 0x31ff, 0x0001}, {0x3400, 0x4dbf, 0x0001},
	{0x4e00, 0xa48c, 0x0001}, {0xa4d0, 0xa4fd, 0x0001}, {0xa500, 0xa60c, 0x0001}, {0xa610, 0xa62b, 0x0001},
	{0xa640, 0xa66f, 0x0001}, {0xa674, 0xa67d, 0x0001}, {0xa67f, 0xa6f1, 0x0001}, {0xa717, 0xa71f, 0x0001},
	{0xa722, 0xa788, 0x0001}, {0xa78b, 0xa7dc, 0x0001}, {0xa7f1, 0xa827, 0x0001}, {0xa82c, 0xa840, 0x0014},
	{0xa841, 0xa873, 0x0001}, {0xa880, 0xa8c5, 0x0001}, {0xa8d0, 0xa8d9, 0x0001}, {0xa8e0, 0xa8f7, 0x0001},
	{0xa8fb, 0xa8fd, 0x0002}, {0xa8fe, 0xa92d, 0x0001}, {0xa930, 0xa953, 0x0001}, {0xa960, 0xa97c, 0x0001},
	{0xa980, 0xa9c0, 0x0001}, {0xa9cf, 0xa9d9, 0x0001}, {0xa9e0, 0xa9fe, 0x0001}, {0xaa00, 0xaa36, 0x0001},
	{0xaa40, 0xaa4d, 0x0001}, {0xaa50, 0xaa59, 0x0001}, {0xaa60, 0xaa76, 0x0001}, {0xaa7a, 0xaac2, 0x0001},
	{0xaadb, 0xaadd, 0x0001}, {0xaae0, 0xaaef, 0x0001}, {0xaaf2, 0xaaf6, 0x0001}, {0xab01, 0xab06, 0x0001},
	{0xab09, 0xab0e, 0x0001}, {0xab11, 0xab16, 0x0001}, {0xab20, 0xab26, 0x0001}, {0xab28, 0xab2e, 0x0001},
	{0xab30, 0xab5a, 0x0001}, {0xab5c, 0xab69, 0x0001}, {0xab70, 0xabea, 0x0001}, {0xabec, 0xabed, 0x0001},
	{0xabf0, 0xabf9, 0x0001}, {0xac00, 0xd7a3, 0x0001}, {0xd7b0, 0xd7c6, 0x0001}, {0xd7cb, 0xd7fb, 0x0001},
	{0xf900, 0xfa6d, 0x0001}, {0xfa70, 0xfad9, 0x0001}, {0xfb00, 0xfb06, 0x0001}, {0xfb13, 0xfb17, 0x0001},
	{0xfb1d, 0xfb28, 0x0001}, {0xfb2a, 0xfb36, 0x0001}, {0xfb38, 0xfb3c, 0x0001}, {0xfb3e, 0xfb40, 0x0002},
	{0xfb41, 0xfb43, 0x0002}, {0xfb44, 0xfb46, 0x0002}, {0xfb47, 0xfbb1, 0x0001}, {0xfbd3, 0xfc5d, 0x0001},
	{0xfc64, 0xfd3d, 0x0001}, {0xfd50, 0xfd8f, 0x0001}, {0xfd92, 0xfdc7, 0x0001}, {0xfdf0, 0xfdf9, 0x0001},
	{0xfe00, 0xfe0f, 0x0001}, {0xfe20, 0xfe2f, 0x0001}, {0xfe33, 0xfe34, 0x0001}, {0xfe4d, 0xfe4f, 0x0001},
	{0xfe71, 0xfe73, 0x0002}, {0xfe77, 0xfe7f, 0x0002}, {0xfe80, 0xfefc, 0x0001}, {0xff10, 0xff19, 0x0001},
	{0xff21, 0xff3a, 0x0001}, {0xff3f, 0xff41, 0x0002}, {0xff42, 0xff5a, 0x0001}, {0xff65, 0xffbe, 0x0001},
	{0xffc2, 0xffc7, 0x0001}, {0xffca, 0xffcf, 0x0001}, {0xffd2, 0xffd7, 0x0001}, {0xffda, 0xffdc, 0x0001}
};


//
//	xidContinue32
//

#if defined(IMGUI_USE_WCHAR32)

static StrideRange32 xidContinue32[] = {
	{0x10000, 0x1000b, 0x0001}, {0x1000d, 0x10026, 0x0001}, {0x10028, 0x1003a, 0x0001}, {0x1003c, 0x1003d, 0x0001},
	{0x1003f, 0x1004d, 0x0001}, {0x10050, 0x1005d, 0x0001}, {0x10080, 0x100fa, 0x0001}, {0x10140, 0x10174, 0x0001},
	{0x101fd, 0x10280, 0x0083}, {0x10281, 0x1029c, 0x0001}, {0x102a0, 0x102d0, 0x0001}, {0x102e0, 0x10300, 0x0020},
	{0x10301, 0x1031f, 0x0001}, {0x1032d, 0x1034a, 0x0001}, {0x10350, 0x1037a, 0x0001}, {0x10380, 0x1039d, 0x0001},
	{0x103a0, 0x103c3, 0x0001}, {0x103c8, 0x103cf, 0x0001}, {0x103d1, 0x103d5, 0x0001}, {0x10400, 0x1049d, 0x0001},
	{0x104a0, 0x104a9, 0x0001}, {0x104b0, 0x104d3, 0x0001}, {0x104d8, 0x104fb, 0x0001}, {0x10500, 0x10527, 0x0001},
	{0x10530, 0x10563, 0x0001}, {0x10570, 0x1057a, 0x0001}, {0x1057c, 0x1058a, 0x0001}, {0x1058c, 0x10592, 0x0001},
	{0x10594, 0x10595, 0x0001}, {0x10597, 0x105a1, 0x0001}, {0x105a3, 0x105b1, 0x0001}, {0x105b3, 0x105b9, 0x0001},
	{0x105bb, 0x105bc, 0x0001}, {0x105c0, 0x105f3, 0x0001}, {0x10600, 0x10736, 0x0001}, {0x10740, 0x10755, 0x0001},
	{0x10760, 0x10767, 0x0001}, {0x10780, 0x10785, 0x0001}, {0x10787, 0x107b0, 0x0001}, {0x107b2, 0x107ba, 0x0001},
	{0x10800, 0x10805, 0x0001}, {0x10808, 0x1080a, 0x0002}, {0x1080b, 0x10835, 0x0001}, {0x10837, 0x10838, 0x0001},
	{0x1083c, 0x1083f, 0x0003}, {0x10840, 0x10855, 0x0001}, {0x10860, 0x10876, 0x0001}, {0x10880, 0x1089e, 0x0001},
	{0x108e0, 0x108f2, 0x0001}, {0x108f4, 0x108f5, 0x0001}, {0x10900, 0x10915, 0x0001}, {0x10920, 0x10939, 0x0001},
	{0x10940, 0x10959, 0x0001}, {0x10980, 0x109b7, 0x0001}, {0x109be, 0x109bf, 0x0001}, {0x10a00, 0x10a03, 0x0001},
	{0x10a05, 0x10a06, 0x0001}, {0x10a0c, 0x10a13, 0x0001}, {0x10a15, 0x10a17, 0x0001}, {0x10a19, 0x10a35, 0x0001},
	{0x10a38, 0x10a3a, 0x0001}, {0x10a3f, 0x10a60, 0x0021}, {0x10a61, 0x10a7c, 0x0001}, {0x10a80, 0x10a9c, 0x0001},
	{0x10ac0, 0x10ac7, 0x0001}, {0x10ac9, 0x10ae6, 0x0001}, {0x10b00, 0x10b35, 0x0001}, {0x10b40, 0x10b55, 0x0001},
	{0x10b60, 0x10b72, 0x0001}, {0x10b80, 0x10b91, 0x0001}, {0x10c00, 0x10c48, 0x0001}, {0x10c80, 0x10cb2, 0x0001},
	{0x10cc0, 0x10cf2, 0x0001}, {0x10d00, 0x10d27, 0x0001}, {0x10d30, 0x10d39, 0x0001}, {0x10d40, 0x10d65, 0x0001},
	{0x10d69, 0x10d6d, 0x0001}, {0x10d6f, 0x10d85, 0x0001}, {0x10e80, 0x10ea9, 0x0001}, {0x10eab, 0x10eac, 0x0001},
	{0x10eb0, 0x10eb1, 0x0001}, {0x10ec2, 0x10ec7, 0x0001}, {0x10efa, 0x10f1c, 0x0001}, {0x10f27, 0x10f30, 0x0009},
	{0x10f31, 0x10f50, 0x0001}, {0x10f70, 0x10f85, 0x0001}, {0x10fb0, 0x10fc4, 0x0001}, {0x10fe0, 0x10ff6, 0x0001},
	{0x11000, 0x11046, 0x0001}, {0x11066, 0x11075, 0x0001}, {0x1107f, 0x110ba, 0x0001}, {0x110c2, 0x110d0, 0x000e},
	{0x110d1, 0x110e8, 0x0001}, {0x110f0, 0x110f9, 0x0001}, {0x11100, 0x11134, 0x0001}, {0x11136, 0x1113f, 0x0001},
	{0x11144, 0x11147, 0x0001}, {0x11150, 0x11173, 0x0001}, {0x11176, 0x11180, 0x000a}, {0x11181, 0x111c4, 0x0001},
	{0x111c9, 0x111cc, 0x0001}, {0x111ce, 0x111da, 0x0001}, {0x111dc, 0x11200, 0x0024}, {0x11201, 0x11211, 0x0001},
	{0x11213, 0x11237, 0x0001}, {0x1123e, 0x11241, 0x0001}, {0x11280, 0x11286, 0x0001}, {0x11288, 0x1128a, 0x0002},
	{0x1128b, 0x1128d, 0x0001}, {0x1128f, 0x1129d, 0x0001}, {0x1129f, 0x112a8, 0x0001}, {0x112b0, 0x112ea, 0x0001},
	{0x112f0, 0x112f9, 0x0001}, {0x11300, 0x11303, 0x0001}, {0x11305, 0x1130c, 0x0001}, {0x1130f, 0x11310, 0x0001},
	{0x11313, 0x11328, 0x0001}, {0x1132a, 0x11330, 0x0001}, {0x11332, 0x11333, 0x0001}, {0x11335, 0x11339, 0x0001},
	{0x1133b, 0x11344, 0x0001}, {0x11347, 0x11348, 0x0001}, {0x1134b, 0x1134d, 0x0001}, {0x11350, 0x11357, 0x0007},
	{0x1135d, 0x11363, 0x0001}, {0x11366, 0x1136c, 0x0001}, {0x11370, 0x11374, 0x0001}, {0x11380, 0x11389, 0x0001},
	{0x1138b, 0x1138e, 0x0003}, {0x11390, 0x113b5, 0x0001}, {0x113b7, 0x113c0, 0x0001}, {0x113c2, 0x113c5, 0x0003},
	{0x113c7, 0x113ca, 0x0001}, {0x113cc, 0x113d3, 0x0001}, {0x113e1, 0x113e2, 0x0001}, {0x11400, 0x1144a, 0x0001},
	{0x11450, 0x11459, 0x0001}, {0x1145e, 0x11461, 0x0001}, {0x11480, 0x114c5, 0x0001}, {0x114c7, 0x114d0, 0x0009},
	{0x114d1, 0x114d9, 0x0001}, {0x11580, 0x115b5, 0x0001}, {0x115b8, 0x115c0, 0x0001}, {0x115d8, 0x115dd, 0x0001},
	{0x11600, 0x11640, 0x0001}, {0x11644, 0x11650, 0x000c}, {0x11651, 0x11659, 0x0001}, {0x11680, 0x116b8, 0x0001},
	{0x116c0, 0x116c9, 0x0001}, {0x116d0, 0x116e3, 0x0001}, {0x11700, 0x1171a, 0x0001}, {0x1171d, 0x1172b, 0x0001},
	{0x11730, 0x11739, 0x0001}, {0x11740, 0x11746, 0x0001}, {0x11800, 0x1183a, 0x0001}, {0x118a0, 0x118e9, 0x0001},
	{0x118ff, 0x11906, 0x0001}, {0x11909, 0x1190c, 0x0003}, {0x1190d, 0x11913, 0x0001}, {0x11915, 0x11916, 0x0001},
	{0x11918, 0x11935, 0x0001}, {0x11937, 0x11938, 0x0001}, {0x1193b, 0x11943, 0x0001}, {0x11950, 0x11959, 0x0001},
	{0x119a0, 0x119a7, 0x0001}, {0x119aa, 0x119d7, 0x0001}, {0x119da, 0x119e1, 0x0001}, {0x119e3, 0x119e4, 0x0001},
	{0x11a00, 0x11a3e, 0x0001}, {0x11a47, 0x11a50, 0x0009}, {0x11a51, 0x11a99, 0x0001}, {0x11a9d, 0x11ab0, 0x0013},
	{0x11ab1, 0x11af8, 0x0001}, {0x11b60, 0x11b67, 0x0001}, {0x11bc0, 0x11be0, 0x0001}, {0x11bf0, 0x11bf9, 0x0001},
	{0x11c00, 0x11c08, 0x0001}, {0x11c0a, 0x11c36, 0x0001}, {0x11c38, 0x11c40, 0x0001}, {0x11c50, 0x11c59, 0x0001},
	{0x11c72, 0x11c8f, 0x0001}, {0x11c92, 0x11ca7, 0x0001}, {0x11ca9, 0x11cb6, 0x0001}, {0x11d00, 0x11d06, 0x0001},
	{0x11d08, 0x11d09, 0x0001}, {0x11d0b, 0x11d36, 0x0001}, {0x11d3a, 0x11d3c, 0x0002}, {0x11d3d, 0x11d3f, 0x0002},
	{0x11d40, 0x11d47, 0x0001}, {0x11d50, 0x11d59, 0x0001}, {0x11d60, 0x11d65, 0x0001}, {0x11d67, 0x11d68, 0x0001},
	{0x11d6a, 0x11d8e, 0x0001}, {0x11d90, 0x11d91, 0x0001}, {0x11d93, 0x11d98, 0x0001}, {0x11da0, 0x11da9, 0x0001},
	{0x11db0, 0x11ddb, 0x0001}, {0x11de0, 0x11de9, 0x0001}, {0x11ee0, 0x11ef6, 0x0001}, {0x11f00, 0x11f10, 0x0001},
	{0x11f12, 0x11f3a, 0x0001}, {0x11f3e, 0x11f42, 0x0001}, {0x11f50, 0x11f5a, 0x0001}, {0x11fb0, 0x12000, 0x0050},
	{0x12001, 0x12399, 0x0001}, {0x12400, 0x1246e, 0x0001}, {0x12480, 0x12543, 0x0001}, {0x12f90, 0x12ff0, 0x0001},
	{0x13000, 0x1342f, 0x0001}, {0x13440, 0x13455, 0x0001}, {0x13460, 0x143fa, 0x0001}, {0x14400, 0x14646, 0x0001},
	{0x16100, 0x16139, 0x0001}, {0x16800, 0x16a38, 0x0001}, {0x16a40, 0x16a5e, 0x0001}, {0x16a60, 0x16a69, 0x0001},
	{0x16a70, 0x16abe, 0x0001}, {0x16ac0, 0x16ac9, 0x0001}, {0x16ad0, 0x16aed, 0x0001}, {0x16af0, 0x16af4, 0x0001},
	{0x16b00, 0x16b36, 0x0001}, {0x16b40, 0x16b43, 0x0001}, {0x16b50, 0x16b59, 0x0001}, {0x16b63, 0x16b77, 0x0001},
	{0x16b7d, 0x16b8f, 0x0001}, {0x16d40, 0x16d6c, 0x0001}, {0x16d70, 0x16d79, 0x0001}, {0x16e40, 0x16e7f, 0x0001},
	{0x16ea0, 0x16eb8, 0x0001}, {0x16ebb, 0x16ed3, 0x0001}, {0x16f00, 0x16f4a, 0x0001}, {0x16f4f, 0x16f87, 0x0001},
	{0x16f8f, 0x16f9f, 0x0001}, {0x16fe0, 0x16fe1, 0x0001}, {0x16fe3, 0x16fe4, 0x0001}, {0x16ff0, 0x16ff6, 0x0001},
	{0x17000, 0x18cd5, 0x0001}, {0x18cff, 0x18d1e, 0x0001}, {0x18d80, 0x18df2, 0x0001}, {0x1aff0, 0x1aff3, 0x0001},
	{0x1aff5, 0x1affb, 0x0001}, {0x1affd, 0x1affe, 0x0001}, {0x1b000, 0x1b122, 0x0001}, {0x1b132, 0x1b150, 0x001e},
	{0x1b151, 0x1b152, 0x0001}, {0x1b155, 0x1b164, 0x000f}, {0x1b165, 0x1b167, 0x0001}, {0x1b170, 0x1b2fb, 0x0001},
	{0x1bc00, 0x1bc6a, 0x0001}, {0x1bc70, 0x1bc7c, 0x0001}, {0x1bc80, 0x1bc88, 0x0001}, {0x1bc90, 0x1bc99, 0x0001},
	{0x1bc9d, 0x1bc9e, 0x0001}, {0x1ccf0, 0x1ccf9, 0x0001}, {0x1cf00, 0x1cf2d, 0x0001}, {0x1cf30, 0x1cf46, 0x0001},
	{0x1d165, 0x1d169, 0x0001}, {0x1d16d, 0x1d172, 0x0001}, {0x1d17b, 0x1d182, 0x0001}, {0x1d185, 0x1d18b, 0x0001},
	{0x1d1aa, 0x1d1ad, 0x0001}, {0x1d242, 0x1d244, 0x0001}, {0x1d400, 0x1d454, 0x0001}, {0x1d456, 0x1d49c, 0x0001},
	{0x1d49e, 0x1d49f, 0x0001}, {0x1d4a2, 0x1d4a5, 0x0003}, {0x1d4a6, 0x1d4a9, 0x0003}, {0x1d4aa, 0x1d4ac, 0x0001},
	{0x1d4ae, 0x1d4b9, 0x0001}, {0x1d4bb, 0x1d4bd, 0x0002}, {0x1d4be, 0x1d4c3, 0x0001}, {0x1d4c5, 0x1d505, 0x0001},
	{0x1d507, 0x1d50a, 0x0001}, {0x1d50d, 0x1d514, 0x0001}, {0x1d516, 0x1d51c, 0x0001}, {0x1d51e, 0x1d539, 0x0001},
	{0x1d53b, 0x1d53e, 0x0001}, {0x1d540, 0x1d544, 0x0001}, {0x1d546, 0x1d54a, 0x0004}, {0x1d54b, 0x1d550, 0x0001},
	{0x1d552, 0x1d6a5, 0x0001}, {0x1d6a8, 0x1d6c0, 0x0001}, {0x1d6c2, 0x1d6da, 0x0001}, {0x1d6dc, 0x1d6fa, 0x0001},
	{0x1d6fc, 0x1d714, 0x0001}, {0x1d716, 0x1d734, 0x0001}, {0x1d736, 0x1d74e, 0x0001}, {0x1d750, 0x1d76e, 0x0001},
	{0x1d770, 0x1d788, 0x0001}, {0x1d78a, 0x1d7a8, 0x0001}, {0x1d7aa, 0x1d7c2, 0x0001}, {0x1d7c4, 0x1d7cb, 0x0001},
	{0x1d7ce, 0x1d7ff, 0x0001}, {0x1da00, 0x1da36, 0x0001}, {0x1da3b, 0x1da6c, 0x0001}, {0x1da75, 0x1da84, 0x000f},
	{0x1da9b, 0x1da9f, 0x0001}, {0x1daa1, 0x1daaf, 0x0001}, {0x1df00, 0x1df1e, 0x0001}, {0x1df25, 0x1df2a, 0x0001},
	{0x1e000, 0x1e006, 0x0001}, {0x1e008, 0x1e018, 0x0001}, {0x1e01b, 0x1e021, 0x0001}, {0x1e023, 0x1e024, 0x0001},
	{0x1e026, 0x1e02a, 0x0001}, {0x1e030, 0x1e06d, 0x0001}, {0x1e08f, 0x1e100, 0x0071}, {0x1e101, 0x1e12c, 0x0001},
	{0x1e130, 0x1e13d, 0x0001}, {0x1e140, 0x1e149, 0x0001}, {0x1e14e, 0x1e290, 0x0142}, {0x1e291, 0x1e2ae, 0x0001},
	{0x1e2c0, 0x1e2f9, 0x0001}, {0x1e4d0, 0x1e4f9, 0x0001}, {0x1e5d0, 0x1e5fa, 0x0001}, {0x1e6c0, 0x1e6de, 0x0001},
	{0x1e6e0, 0x1e6f5, 0x0001}, {0x1e6fe, 0x1e6ff, 0x0001}, {0x1e7e0, 0x1e7e6, 0x0001}, {0x1e7e8, 0x1e7eb, 0x0001},
	{0x1e7ed, 0x1e7ee, 0x0001}, {0x1e7f0, 0x1e7fe, 0x0001}, {0x1e800, 0x1e8c4, 0x0001}, {0x1e8d0, 0x1e8d6, 0x0001},
	{0x1e900, 0x1e94b, 0x0001}, {0x1e950, 0x1e959, 0x0001}, {0x1ee00, 0x1ee03, 0x0001}, {0x1ee05, 0x1ee1f, 0x0001},
	{0x1ee21, 0x1ee22, 0x0001}, {0x1ee24, 0x1ee27, 0x0003}, {0x1ee29, 0x1ee32, 0x0001}, {0x1ee34, 0x1ee37, 0x0001},
	{0x1ee39, 0x1ee3b, 0x0002}, {0x1ee42, 0x1ee47, 0x0005}, {0x1ee49, 0x1ee4d, 0x0002}, {0x1ee4e, 0x1ee4f, 0x0001},
	{0x1ee51, 0x1ee52, 0x0001}, {0x1ee54, 0x1ee57, 0x0003}, {0x1ee59, 0x1ee61, 0x0002}, {0x1ee62, 0x1ee64, 0x0002},
	{0x1ee67, 0x1ee6a, 0x0001}, {0x1ee6c, 0x1ee72, 0x0001}, {0x1ee74, 0x1ee77, 0x0001}, {0x1ee79, 0x1ee7c, 0x0001},
	{0x1ee7e, 0x1ee80, 0x0002}, {0x1ee81, 0x1ee89, 0x0001}, {0x1ee8b, 0x1ee9b, 0x0001}, {0x1eea1, 0x1eea3, 0x0001},
	{0x1eea5, 0x1eea9, 0x0001}, {0x1eeab, 0x1eebb, 0x0001}, {0x1fbf0, 0x1fbf9, 0x0001}, {0x20000, 0x2a6df, 0x0001},
	{0x2a700, 0x2b81d, 0x0001}, {0x2b820, 0x2cead, 0x0001}, {0x2ceb0, 0x2ebe0, 0x0001}, {0x2ebf0, 0x2ee5d, 0x0001},
	{0x2f800, 0x2fa1d, 0x0001}, {0x30000, 0x3134a, 0x0001}, {0x31350, 0x33479, 0x0001}, {0xe0100, 0xe01ef, 0x0001}
};

#endif


//
//	eastAsian16
//

static Range16 eastAsian16[] = {
	{0x1100, 0x115f}, {0x20a9, 0x20a9}, {0x231a, 0x231b}, {0x2329, 0x232a}, {0x23e9, 0x23ec}, {0x23f0, 0x23f0},
	{0x23f3, 0x23f3}, {0x25fd, 0x25fe}, {0x2614, 0x2615}, {0x2630, 0x2637}, {0x2648, 0x2653}, {0x267f, 0x267f},
	{0x268a, 0x268f}, {0x2693, 0x2693}, {0x26a1, 0x26a1}, {0x26aa, 0x26ab}, {0x26bd, 0x26be}, {0x26c4, 0x26c5},
	{0x26ce, 0x26ce}, {0x26d4, 0x26d4}, {0x26ea, 0x26ea}, {0x26f2, 0x26f3}, {0x26f5, 0x26f5}, {0x26fa, 0x26fa},
	{0x26fd, 0x26fd}, {0x2705, 0x2705}, {0x270a, 0x270b}, {0x2728, 0x2728}, {0x274c, 0x274c}, {0x274e, 0x274e},
	{0x2753, 0x2755}, {0x2757, 0x2757}, {0x2795, 0x2797}, {0x27b0, 0x27b0}, {0x27bf, 0x27bf}, {0x2b1b, 0x2b1c},
	{0x2b50, 0x2b50}, {0x2b55, 0x2b55}, {0x2e80, 0x2e99}, {0x2e9b, 0x2ef3}, {0x2f00, 0x2fd5}, {0x2ff0, 0x2fff},
	{0x3000, 0x3000}, {0x3001, 0x303e}, {0x3041, 0x3096}, {0x3099, 0x30ff}, {0x3105, 0x312f}, {0x3131, 0x318e},
	{0x3190, 0x31e5}, {0x31ef, 0x321e}, {0x3220, 0x3247}, {0x3250, 0xa48c}, {0xa490, 0xa4c6}, {0xa960, 0xa97c},
	{0xac00, 0xd7a3}, {0xf900, 0xfaff}, {0xfe10, 0xfe19}, {0xfe30, 0xfe52}, {0xfe54, 0xfe66}, {0xfe68, 0xfe6b},
	{0xff01, 0xff60}, {0xff61, 0xffbe}, {0xffc2, 0xffc7}, {0xffca, 0xffcf}, {0xffd2, 0xffd7}, {0xffda, 0xffdc},
	{0xffe0, 0xffe6}, {0xffe8, 0xffee}
};


//
//	eastAsian32
//

#if defined(IMGUI_USE_WCHAR32)

static Range32 eastAsian32[] = {
	{0x16fe0, 0x16fe4}, {0x16ff0, 0x16ff6}, {0x17000, 0x18cd5}, {0x18cff, 0x18d1e}, {0x18d80, 0x18df2}, {0x1aff0, 0x1aff3},
	{0x1aff5, 0x1affb}, {0x1affd, 0x1affe}, {0x1b000, 0x1b122}, {0x1b132, 0x1b132}, {0x1b150, 0x1b152}, {0x1b155, 0x1b155},
	{0x1b164, 0x1b167}, {0x1b170, 0x1b2fb}, {0x1d300, 0x1d356}, {0x1d360, 0x1d376}, {0x1f004, 0x1f004}, {0x1f0cf, 0x1f0cf},
	{0x1f18e, 0x1f18e}, {0x1f191, 0x1f19a}, {0x1f200, 0x1f202}, {0x1f210, 0x1f23b}, {0x1f240, 0x1f248}, {0x1f250, 0x1f251},
	{0x1f260, 0x1f265}, {0x1f300, 0x1f320}, {0x1f32d, 0x1f335}, {0x1f337, 0x1f37c}, {0x1f37e, 0x1f393}, {0x1f3a0, 0x1f3ca},
	{0x1f3cf, 0x1f3d3}, {0x1f3e0, 0x1f3f0}, {0x1f3f4, 0x1f3f4}, {0x1f3f8, 0x1f43e}, {0x1f440, 0x1f440}, {0x1f442, 0x1f4fc},
	{0x1f4ff, 0x1f53d}, {0x1f54b, 0x1f54e}, {0x1f550, 0x1f567}, {0x1f57a, 0x1f57a}, {0x1f595, 0x1f596}, {0x1f5a4, 0x1f5a4},
	{0x1f5fb, 0x1f64f}, {0x1f680, 0x1f6c5}, {0x1f6cc, 0x1f6cc}, {0x1f6d0, 0x1f6d2}, {0x1f6d5, 0x1f6d8}, {0x1f6dc, 0x1f6df},
	{0x1f6eb, 0x1f6ec}, {0x1f6f4, 0x1f6fc}, {0x1f7e0, 0x1f7eb}, {0x1f7f0, 0x1f7f0}, {0x1f90c, 0x1f93a}, {0x1f93c, 0x1f945},
	{0x1f947, 0x1f9ff}, {0x1fa70, 0x1fa7c}, {0x1fa80, 0x1fa8a}, {0x1fa8e, 0x1fac6}, {0x1fac8, 0x1fac8}, {0x1facd, 0x1fadc},
	{0x1fadf, 0x1faea}, {0x1faef, 0x1faf8}, {0x20000, 0x2fffd}, {0x30000, 0x3fffd}
};

#endif


//
//	case16
//

static CaseRange16 case16[] = {
	{0x0041, 0x005a,      0,     32}, {0x0061, 0x007a,    -32,      0}, {0x00b5, 0x00b5,    743,      0},
	{0x00c0, 0x00d6,      0,     32}, {0x00d8, 0x00de,      0,     32}, {0x00e0, 0x00f6,    -32,      0},
	{0x00f8, 0x00fe,    -32,      0}, {0x00ff, 0x00ff,    121,      0}, {0x0100, 0x0100,      0,      1},
	{0x0101, 0x0101,     -1,      0}, {0x0102, 0x0102,      0,      1}, {0x0103, 0x0103,     -1,      0},
	{0x0104, 0x0104,      0,      1}, {0x0105, 0x0105,     -1,      0}, {0x0106, 0x0106,      0,      1},
	{0x0107, 0x0107,     -1,      0}, {0x0108, 0x0108,      0,      1}, {0x0109, 0x0109,     -1,      0},
	{0x010a, 0x010a,      0,      1}, {0x010b, 0x010b,     -1,      0}, {0x010c, 0x010c,      0,      1},
	{0x010d, 0x010d,     -1,      0}, {0x010e, 0x010e,      0,      1}, {0x010f, 0x010f,     -1,      0},
	{0x0110, 0x0110,      0,      1}, {0x0111, 0x0111,     -1,      0}, {0x0112, 0x0112,      0,      1},
	{0x0113, 0x0113,     -1,      0}, {0x0114, 0x0114,      0,      1}, {0x0115, 0x0115,     -1,      0},
	{0x0116, 0x0116,      0,      1}, {0x0117, 0x0117,     -1,      0}, {0x0118, 0x0118,      0,      1},
	{0x0119, 0x0119,     -1,      0}, {0x011a, 0x011a,      0,      1}, {0x011b, 0x011b,     -1,      0},
	{0x011c, 0x011c,      0,      1}, {0x011d, 0x011d,     -1,      0}, {0x011e, 0x011e,      0,      1},
	{0x011f, 0x011f,     -1,      0}, {0x0120, 0x0120,      0,      1}, {0x0121, 0x0121,     -1,      0},
	{0x0122, 0x0122,      0,      1}, {0x0123, 0x0123,     -1,      0}, {0x0124, 0x0124,      0,      1},
	{0x0125, 0x0125,     -1,      0}, {0x0126, 0x0126,      0,      1}, {0x0127, 0x0127,     -1,      0},
	{0x0128, 0x0128,      0,      1}, {0x0129, 0x0129,     -1,      0}, {0x012a, 0x012a,      0,      1},
	{0x012b, 0x012b,     -1,      0}, {0x012c, 0x012c,      0,      1}, {0x012d, 0x012d,     -1,      0},
	{0x012e, 0x012e,      0,      1}, {0x012f, 0x012f,     -1,      0}, {0x0130, 0x0130,      0,   -199},
	{0x0131, 0x0131,   -232,      0}, {0x0132, 0x0132,      0,      1}, {0x0133, 0x0133,     -1,      0},
	{0x0134, 0x0134,      0,      1}, {0x0135, 0x0135,     -1,      0}, {0x0136, 0x0136,      0,      1},
	{0x0137, 0x0137,     -1,      0}, {0x0139, 0x0139,      0,      1}, {0x013a, 0x013a,     -1,      0},
	{0x013b, 0x013b,      0,      1}, {0x013c, 0x013c,     -1,      0}, {0x013d, 0x013d,      0,      1},
	{0x013e, 0x013e,     -1,      0}, {0x013f, 0x013f,      0,      1}, {0x0140, 0x0140,     -1,      0},
	{0x0141, 0x0141,      0,      1}, {0x0142, 0x0142,     -1,      0}, {0x0143, 0x0143,      0,      1},
	{0x0144, 0x0144,     -1,      0}, {0x0145, 0x0145,      0,      1}, {0x0146, 0x0146,     -1,      0},
	{0x0147, 0x0147,      0,      1}, {0x0148, 0x0148,     -1,      0}, {0x014a, 0x014a,      0,      1},
	{0x014b, 0x014b,     -1,      0}, {0x014c, 0x014c,      0,      1}, {0x014d, 0x014d,     -1,      0},
	{0x014e, 0x014e,      0,      1}, {0x014f, 0x014f,     -1,      0}, {0x0150, 0x0150,      0,      1},
	{0x0151, 0x0151,     -1,      0}, {0x0152, 0x0152,      0,      1}, {0x0153, 0x0153,     -1,      0},
	{0x0154, 0x0154,      0,      1}, {0x0155, 0x0155,     -1,      0}, {0x0156, 0x0156,      0,      1},
	{0x0157, 0x0157,     -1,      0}, {0x0158, 0x0158,      0,      1}, {0x0159, 0x0159,     -1,      0},
	{0x015a, 0x015a,      0,      1}, {0x015b, 0x015b,     -1,      0}, {0x015c, 0x015c,      0,      1},
	{0x015d, 0x015d,     -1,      0}, {0x015e, 0x015e,      0,      1}, {0x015f, 0x015f,     -1,      0},
	{0x0160, 0x0160,      0,      1}, {0x0161, 0x0161,     -1,      0}, {0x0162, 0x0162,      0,      1},
	{0x0163, 0x0163,     -1,      0}, {0x0164, 0x0164,      0,      1}, {0x0165, 0x0165,     -1,      0},
	{0x0166, 0x0166,      0,      1}, {0x0167, 0x0167,     -1,      0}, {0x0168, 0x0168,      0,      1},
	{0x0169, 0x0169,     -1,      0}, {0x016a, 0x016a,      0,      1}, {0x016b, 0x016b,     -1,      0},
	{0x016c, 0x016c,      0,      1}, {0x016d, 0x016d,     -1,      0}, {0x016e, 0x016e,      0,      1},
	{0x016f, 0x016f,     -1,      0}, {0x0170, 0x0170,      0,      1}, {0x0171, 0x0171,     -1,      0},
	{0x0172, 0x0172,      0,      1}, {0x0173, 0x0173,     -1,      0}, {0x0174, 0x0174,      0,      1},
	{0x0175, 0x0175,     -1,      0}, {0x0176, 0x0176,      0,      1}, {0x0177, 0x0177,     -1,      0},
	{0x0178, 0x0178,      0,   -121}, {0x0179, 0x0179,      0,      1}, {0x017a, 0x017a,     -1,      0},
	{0x017b, 0x017b,      0,      1}, {0x017c, 0x017c,     -1,      0}, {0x017d, 0x017d,      0,      1},
	{0x017e, 0x017e,     -1,      0}, {0x017f, 0x017f,   -300,      0}, {0x0180, 0x0180,    195,      0},
	{0x0181, 0x0181,      0,    210}, {0x0182, 0x0182,      0,      1}, {0x0183, 0x0183,     -1,      0},
	{0x0184, 0x0184,      0,      1}, {0x0185, 0x0185,     -1,      0}, {0x0186, 0x0186,      0,    206},
	{0x0187, 0x0187,      0,      1}, {0x0188, 0x0188,     -1,      0}, {0x0189, 0x018a,      0,    205},
	{0x018b, 0x018b,      0,      1}, {0x018c, 0x018c,     -1,      0}, {0x018e, 0x018e,      0,     79},
	{0x018f, 0x018f,      0,    202}, {0x0190, 0x0190,      0,    203}, {0x0191, 0x0191,      0,      1},
	{0x0192, 0x0192,     -1,      0}, {0x0193, 0x0193,      0,    205}, {0x0194, 0x0194,      0,    207},
	{0x0195, 0x0195,     97,      0}, {0x0196, 0x0196,      0,    211}, {0x0197, 0x0197,      0,    209},
	{0x0198, 0x0198,      0,      1}, {0x0199, 0x0199,     -1,      0}, {0x019a, 0x019a,    163,      0},
	{0x019b, 0x019b,  42561,      0}, {0x019c, 0x019c,      0,    211}, {0x019d, 0x019d,      0,    213},
	{0x019e, 0x019e,    130,      0}, {0x019f, 0x019f,      0,    214}, {0x01a0, 0x01a0,      0,      1},
	{0x01a1, 0x01a1,     -1,      0}, {0x01a2, 0x01a2,      0,      1}, {0x01a3, 0x01a3,     -1,      0},
	{0x01a4, 0x01a4,      0,      1}, {0x01a5, 0x01a5,     -1,      0}, {0x01a6, 0x01a6,      0,    218},
	{0x01a7, 0x01a7,      0,      1}, {0x01a8, 0x01a8,     -1,      0}, {0x01a9, 0x01a9,      0,    218},
	{0x01ac, 0x01ac,      0,      1}, {0x01ad, 0x01ad,     -1,      0}, {0x01ae, 0x01ae,      0,    218},
	{0x01af, 0x01af,      0,      1}, {0x01b0, 0x01b0,     -1,      0}, {0x01b1, 0x01b2,      0,    217},
	{0x01b3, 0x01b3,      0,      1}, {0x01b4, 0x01b4,     -1,      0}, {0x01b5, 0x01b5,      0,      1},
	{0x01b6, 0x01b6,     -1,      0}, {0x01b7, 0x01b7,      0,    219}, {0x01b8, 0x01b8,      0,      1},
	{0x01b9, 0x01b9,     -1,      0}, {0x01bc, 0x01bc,      0,      1}, {0x01bd, 0x01bd,     -1,      0},
	{0x01bf, 0x01bf,     56,      0}, {0x01c4, 0x01c4,      0,      2}, {0x01c6, 0x01c6,     -2,      0},
	{0x01c7, 0x01c7,      0,      2}, {0x01c9, 0x01c9,     -2,      0}, {0x01ca, 0x01ca,      0,      2},
	{0x01cc, 0x01cc,     -2,      0}, {0x01cd, 0x01cd,      0,      1}, {0x01ce, 0x01ce,     -1,      0},
	{0x01cf, 0x01cf,      0,      1}, {0x01d0, 0x01d0,     -1,      0}, {0x01d1, 0x01d1,      0,      1},
	{0x01d2, 0x01d2,     -1,      0}, {0x01d3, 0x01d3,      0,      1}, {0x01d4, 0x01d4,     -1,      0},
	{0x01d5, 0x01d5,      0,      1}, {0x01d6, 0x01d6,     -1,      0}, {0x01d7, 0x01d7,      0,      1},
	{0x01d8, 0x01d8,     -1,      0}, {0x01d9, 0x01d9,      0,      1}, {0x01da, 0x01da,     -1,      0},
	{0x01db, 0x01db,      0,      1}, {0x01dc, 0x01dc,     -1,      0}, {0x01dd, 0x01dd,    -79,      0},
	{0x01de, 0x01de,      0,      1}, {0x01df, 0x01df,     -1,      0}, {0x01e0, 0x01e0,      0,      1},
	{0x01e1, 0x01e1,     -1,      0}, {0x01e2, 0x01e2,      0,      1}, {0x01e3, 0x01e3,     -1,      0},
	{0x01e4, 0x01e4,      0,      1}, {0x01e5, 0x01e5,     -1,      0}, {0x01e6, 0x01e6,      0,      1},
	{0x01e7, 0x01e7,     -1,      0}, {0x01e8, 0x01e8,      0,      1}, {0x01e9, 0x01e9,     -1,      0},
	{0x01ea, 0x01ea,      0,      1}, {0x01eb, 0x01eb,     -1,      0}, {0x01ec, 0x01ec,      0,      1},
	{0x01ed, 0x01ed,     -1,      0}, {0x01ee, 0x01ee,      0,      1}, {0x01ef, 0x01ef,     -1,      0},
	{0x01f1, 0x01f1,      0,      2}, {0x01f3, 0x01f3,     -2,      0}, {0x01f4, 0x01f4,      0,      1},
	{0x01f5, 0x01f5,     -1,      0}, {0x01f6, 0x01f6,      0,    -97}, {0x01f7, 0x01f7,      0,    -56},
	{0x01f8, 0x01f8,      0,      1}, {0x01f9, 0x01f9,     -1,      0}, {0x01fa, 0x01fa,      0,      1},
	{0x01fb, 0x01fb,     -1,      0}, {0x01fc, 0x01fc,      0,      1}, {0x01fd, 0x01fd,     -1,      0},
	{0x01fe, 0x01fe,      0,      1}, {0x01ff, 0x01ff,     -1,      0}, {0x0200, 0x0200,      0,      1},
	{0x0201, 0x0201,     -1,      0}, {0x0202, 0x0202,      0,      1}, {0x0203, 0x0203,     -1,      0},
	{0x0204, 0x0204,      0,      1}, {0x0205, 0x0205,     -1,      0}, {0x0206, 0x0206,      0,      1},
	{0x0207, 0x0207,     -1,      0}, {0x0208, 0x0208,      0,      1}, {0x0209, 0x0209,     -1,      0},
	{0x020a, 0x020a,      0,      1}, {0x020b, 0x020b,     -1,      0}, {0x020c, 0x020c,      0,      1},
	{0x020d, 0x020d,     -1,      0}, {0x020e, 0x020e,      0,      1}, {0x020f, 0x020f,     -1,      0},
	{0x0210, 0x0210,      0,      1}, {0x0211, 0x0211,     -1,      0}, {0x0212, 0x0212,      0,      1},
	{0x0213, 0x0213,     -1,      0}, {0x0214, 0x0214,      0,      1}, {0x0215, 0x0215,     -1,      0},
	{0x0216, 0x0216,      0,      1}, {0x0217, 0x0217,     -1,      0}, {0x0218, 0x0218,      0,      1},
	{0x0219, 0x0219,     -1,      0}, {0x021a, 0x021a,      0,      1}, {0x021b, 0x021b,     -1,      0},
	{0x021c, 0x021c,      0,      1}, {0x021d, 0x021d,     -1,      0}, {0x021e, 0x021e,      0,      1},
	{0x021f, 0x021f,     -1,      0}, {0x0220, 0x0220,      0,   -130}, {0x0222, 0x0222,      0,      1},
	{0x0223, 0x0223,     -1,      0}, {0x0224, 0x0224,      0,      1}, {0x0225, 0x0225,     -1,      0},
	{0x0226, 0x0226,      0,      1}, {0x0227, 0x0227,     -1,      0}, {0x0228, 0x0228,      0,      1},
	{0x0229, 0x0229,     -1,      0}, {0x022a, 0x022a,      0,      1}, {0x022b, 0x022b,     -1,      0},
	{0x022c, 0x022c,      0,      1}, {0x022d, 0x022d,     -1,      0}, {0x022e, 0x022e,      0,      1},
	{0x022f, 0x022f,     -1,      0}, {0x0230, 0x0230,      0,      1}, {0x0231, 0x0231,     -1,      0},
	{0x0232, 0x0232,      0,      1}, {0x0233, 0x0233,     -1,      0}, {0x023a, 0x023a,      0,  10795},
	{0x023b, 0x023b,      0,      1}, {0x023c, 0x023c,     -1,      0}, {0x023d, 0x023d,      0,   -163},
	{0x023e, 0x023e,      0,  10792}, {0x023f, 0x0240,  10815,      0}, {0x0241, 0x0241,      0,      1},
	{0x0242, 0x0242,     -1,      0}, {0x0243, 0x0243,      0,   -195}, {0x0244, 0x0244,      0,     69},
	{0x0245, 0x0245,      0,     71}, {0x0246, 0x0246,      0,      1}, {0x0247, 0x0247,     -1,      0},
	{0x0248, 0x0248,      0,      1}, {0x0249, 0x0249,     -1,      0}, {0x024a, 0x024a,      0,      1},
	{0x024b, 0x024b,     -1,      0}, {0x024c, 0x024c,      0,      1}, {0x024d, 0x024d,     -1,      0},
	{0x024e, 0x024e,      0,      1}, {0x024f, 0x024f,     -1,      0}, {0x0250, 0x0250,  10783,      0},
	{0x0251, 0x0251,  10780,      0}, {0x0252, 0x0252,  10782,      0}, {0x0253, 0x0253,   -210,      0},
	{0x0254, 0x0254,   -206,      0}, {0x0256, 0x0257,   -205,      0}, {0x0259, 0x0259,   -202,      0},
	{0x025b, 0x025b,   -203,      0}, {0x025c, 0x025c,  42319,      0}, {0x0260, 0x0260,   -205,      0},
	{0x0261, 0x0261,  42315,      0}, {0x0263, 0x0263,   -207,      0}, {0x0264, 0x0264,  42343,      0},
	{0x0265, 0x0265,  42280,      0}, {0x0266, 0x0266,  42308,      0}, {0x0268, 0x0268,   -209,      0},
	{0x0269, 0x0269,   -211,      0}, {0x026a, 0x026a,  42308,      0}, {0x026b, 0x026b,  10743,      0},
	{0x026c, 0x026c,  42305,      0}, {0x026f, 0x026f,   -211,      0}, {0x0271, 0x0271,  10749,      0},
	{0x0272, 0x0272,   -213,      0}, {0x0275, 0x0275,   -214,      0}, {0x027d, 0x027d,  10727,      0},
	{0x0280, 0x0280,   -218,      0}, {0x0282, 0x0282,  42307,      0}, {0x0283, 0x0283,   -218,      0},
	{0x0287, 0x0287,  42282,      0}, {0x0288, 0x0288,   -218,      0}, {0x0289, 0x0289,    -69,      0},
	{0x028a, 0x028b,   -217,      0}, {0x028c, 0x028c,    -71,      0}, {0x0292, 0x0292,   -219,      0},
	{0x029d, 0x029d,  42261,      0}, {0x029e, 0x029e,  42258,      0}, {0x0370, 0x0370,      0,      1},
	{0x0371, 0x0371,     -1,      0}, {0x0372, 0x0372,      0,      1}, {0x0373, 0x0373,     -1,      0},
	{0x0376, 0x0376,      0,      1}, {0x0377, 0x0377,     -1,      0}, {0x037b, 0x037d,    130,      0},
	{0x037f, 0x037f,      0,    116}, {0x0386, 0x0386,      0,     38}, {0x0388, 0x038a,      0,     37},
	{0x038c, 0x038c,      0,     64}, {0x038e, 0x038f,      0,     63}, {0x0391, 0x03a1,      0,     32},
	{0x03a3, 0x03ab,      0,     32}, {0x03ac, 0x03ac,    -38,      0}, {0x03ad, 0x03af,    -37,      0},
	{0x03b1, 0x03c1,    -32,      0}, {0x03c2, 0x03c2,    -31,      0}, {0x03c3, 0x03cb,    -32,      0},
	{0x03cc, 0x03cc,    -64,      0}, {0x03cd, 0x03ce,    -63,      0}, {0x03cf, 0x03cf,      0,      8},
	{0x03d0, 0x03d0,    -62,      0}, {0x03d1, 0x03d1,    -57,      0}, {0x03d5, 0x03d5,    -47,      0},
	{0x03d6, 0x03d6,    -54,      0}, {0x03d7, 0x03d7,     -8,      0}, {0x03d8, 0x03d8,      0,      1},
	{0x03d9, 0x03d9,     -1,      0}, {0x03da, 0x03da,      0,      1}, {0x03db, 0x03db,     -1,      0},
	{0x03dc, 0x03dc,      0,      1}, {0x03dd, 0x03dd,     -1,      0}, {0x03de, 0x03de,      0,      1},
	{0x03df, 0x03df,     -1,      0}, {0x03e0, 0x03e0,      0,      1}, {0x03e1, 0x03e1,     -1,      0},
	{0x03e2, 0x03e2,      0,      1}, {0x03e3, 0x03e3,     -1,      0}, {0x03e4, 0x03e4,      0,      1},
	{0x03e5, 0x03e5,     -1,      0}, {0x03e6, 0x03e6,      0,      1}, {0x03e7, 0x03e7,     -1,      0},
	{0x03e8, 0x03e8,      0,      1}, {0x03e9, 0x03e9,     -1,      0}, {0x03ea, 0x03ea,      0,      1},
	{0x03eb, 0x03eb,     -1,      0}, {0x03ec, 0x03ec,      0,      1}, {0x03ed, 0x03ed,     -1,      0},
	{0x03ee, 0x03ee,      0,      1}, {0x03ef, 0x03ef,     -1,      0}, {0x03f0, 0x03f0,    -86,      0},
	{0x03f1, 0x03f1,    -80,      0}, {0x03f2, 0x03f2,      7,      0}, {0x03f3, 0x03f3,   -116,      0},
	{0x03f4, 0x03f4,      0,    -60}, {0x03f5, 0x03f5,    -96,      0}, {0x03f7, 0x03f7,      0,      1},
	{0x03f8, 0x03f8,     -1,      0}, {0x03f9, 0x03f9,      0,     -7}, {0x03fa, 0x03fa,      0,      1},
	{0x03fb, 0x03fb,     -1,      0}, {0x03fd, 0x03ff,      0,   -130}, {0x0400, 0x040f,      0,     80},
	{0x0410, 0x042f,      0,     32}, {0x0430, 0x044f,    -32,      0}, {0x0450, 0x045f,    -80,      0},
	{0x0460, 0x0460,      0,      1}, {0x0461, 0x0461,     -1,      0}, {0x0462, 0x0462,      0,      1},
	{0x0463, 0x0463,     -1,      0}, {0x0464, 0x0464,      0,      1}, {0x0465, 0x0465,     -1,      0},
	{0x0466, 0x0466,      0,      1}, {0x0467, 0x0467,     -1,      0}, {0x0468, 0x0468,      0,      1},
	{0x0469, 0x0469,     -1,      0}, {0x046a, 0x046a,      0,      1}, {0x046b, 0x046b,     -1,      0},
	{0x046c, 0x046c,      0,      1}, {0x046d, 0x046d,     -1,      0}, {0x046e, 0x046e,      0,      1},
	{0x046f, 0x046f,     -1,      0}, {0x0470, 0x0470,      0,      1}, {0x0471, 0x0471,     -1,      0},
	{0x0472, 0x0472,      0,      1}, {0x0473, 0x0473,     -1,      0}, {0x0474, 0x0474,      0,      1},
	{0x0475, 0x0475,     -1,      0}, {0x0476, 0x0476,      0,      1}, {0x0477, 0x0477,     -1,      0},
	{0x0478, 0x0478,      0,      1}, {0x0479, 0x0479,     -1,      0}, {0x047a, 0x047a,      0,      1},
	{0x047b, 0x047b,     -1,      0}, {0x047c, 0x047c,      0,      1}, {0x047d, 0x047d,     -1,      0},
	{0x047e, 0x047e,      0,      1}, {0x047f, 0x047f,     -1,      0}, {0x0480, 0x0480,      0,      1},
	{0x0481, 0x0481,     -1,      0}, {0x048a, 0x048a,      0,      1}, {0x048b, 0x048b,     -1,      0},
	{0x048c, 0x048c,      0,      1}, {0x048d, 0x048d,     -1,      0}, {0x048e, 0x048e,      0,      1},
	{0x048f, 0x048f,     -1,      0}, {0x0490, 0x0490,      0,      1}, {0x0491, 0x0491,     -1,      0},
	{0x0492, 0x0492,      0,      1}, {0x0493, 0x0493,     -1,      0}, {0x0494, 0x0494,      0,      1},
	{0x0495, 0x0495,     -1,      0}, {0x0496, 0x0496,      0,      1}, {0x0497, 0x0497,     -1,      0},
	{0x0498, 0x0498,      0,      1}, {0x0499, 0x0499,     -1,      0}, {0x049a, 0x049a,      0,      1},
	{0x049b, 0x049b,     -1,      0}, {0x049c, 0x049c,      0,      1}, {0x049d, 0x049d,     -1,      0},
	{0x049e, 0x049e,      0,      1}, {0x049f, 0x049f,     -1,      0}, {0x04a0, 0x04a0,      0,      1},
	{0x04a1, 0x04a1,     -1,      0}, {0x04a2, 0x04a2,      0,      1}, {0x04a3, 0x04a3,     -1,      0},
	{0x04a4, 0x04a4,      0,      1}, {0x04a5, 0x04a5,     -1,      0}, {0x04a6, 0x04a6,      0,      1},
	{0x04a7, 0x04a7,     -1,      0}, {0x04a8, 0x04a8,      0,      1}, {0x04a9, 0x04a9,     -1,      0},
	{0x04aa, 0x04aa,      0,      1}, {0x04ab, 0x04ab,     -1,      0}, {0x04ac, 0x04ac,      0,      1},
	{0x04ad, 0x04ad,     -1,      0}, {0x04ae, 0x04ae,      0,      1}, {0x04af, 0x04af,     -1,      0},
	{0x04b0, 0x04b0,      0,      1}, {0x04b1, 0x04b1,     -1,      0}, {0x04b2, 0x04b2,      0,      1},
	{0x04b3, 0x04b3,     -1,      0}, {0x04b4, 0x04b4,      0,      1}, {0x04b5, 0x04b5,     -1,      0},
	{0x04b6, 0x04b6,      0,      1}, {0x04b7, 0x04b7,     -1,      0}, {0x04b8, 0x04b8,      0,      1},
	{0x04b9, 0x04b9,     -1,      0}, {0x04ba, 0x04ba,      0,      1}, {0x04bb, 0x04bb,     -1,      0},
	{0x04bc, 0x04bc,      0,      1}, {0x04bd, 0x04bd,     -1,      0}, {0x04be, 0x04be,      0,      1},
	{0x04bf, 0x04bf,     -1,      0}, {0x04c0, 0x04c0,      0,     15}, {0x04c1, 0x04c1,      0,      1},
	{0x04c2, 0x04c2,     -1,      0}, {0x04c3, 0x04c3,      0,      1}, {0x04c4, 0x04c4,     -1,      0},
	{0x04c5, 0x04c5,      0,      1}, {0x04c6, 0x04c6,     -1,      0}, {0x04c7, 0x04c7,      0,      1},
	{0x04c8, 0x04c8,     -1,      0}, {0x04c9, 0x04c9,      0,      1}, {0x04ca, 0x04ca,     -1,      0},
	{0x04cb, 0x04cb,      0,      1}, {0x04cc, 0x04cc,     -1,      0}, {0x04cd, 0x04cd,      0,      1},
	{0x04ce, 0x04ce,     -1,      0}, {0x04cf, 0x04cf,    -15,      0}, {0x04d0, 0x04d0,      0,      1},
	{0x04d1, 0x04d1,     -1,      0}, {0x04d2, 0x04d2,      0,      1}, {0x04d3, 0x04d3,     -1,      0},
	{0x04d4, 0x04d4,      0,      1}, {0x04d5, 0x04d5,     -1,      0}, {0x04d6, 0x04d6,      0,      1},
	{0x04d7, 0x04d7,     -1,      0}, {0x04d8, 0x04d8,      0,      1}, {0x04d9, 0x04d9,     -1,      0},
	{0x04da, 0x04da,      0,      1}, {0x04db, 0x04db,     -1,      0}, {0x04dc, 0x04dc,      0,      1},
	{0x04dd, 0x04dd,     -1,      0}, {0x04de, 0x04de,      0,      1}, {0x04df, 0x04df,     -1,      0},
	{0x04e0, 0x04e0,      0,      1}, {0x04e1, 0x04e1,     -1,      0}, {0x04e2, 0x04e2,      0,      1},
	{0x04e3, 0x04e3,     -1,      0}, {0x04e4, 0x04e4,      0,      1}, {0x04e5, 0x04e5,     -1,      0},
	{0x04e6, 0x04e6,      0,      1}, {0x04e7, 0x04e7,     -1,      0}, {0x04e8, 0x04e8,      0,      1},
	{0x04e9, 0x04e9,     -1,      0}, {0x04ea, 0x04ea,      0,      1}, {0x04eb, 0x04eb,     -1,      0},
	{0x04ec, 0x04ec,      0,      1}, {0x04ed, 0x04ed,     -1,      0}, {0x04ee, 0x04ee,      0,      1},
	{0x04ef, 0x04ef,     -1,      0}, {0x04f0, 0x04f0,      0,      1}, {0x04f1, 0x04f1,     -1,      0},
	{0x04f2, 0x04f2,      0,      1}, {0x04f3, 0x04f3,     -1,      0}, {0x04f4, 0x04f4,      0,      1},
	{0x04f5, 0x04f5,     -1,      0}, {0x04f6, 0x04f6,      0,      1}, {0x04f7, 0x04f7,     -1,      0},
	{0x04f8, 0x04f8,      0,      1}, {0x04f9, 0x04f9,     -1,      0}, {0x04fa, 0x04fa,      0,      1},
	{0x04fb, 0x04fb,     -1,      0}, {0x04fc, 0x04fc,      0,      1}, {0x04fd, 0x04fd,     -1,      0},
	{0x04fe, 0x04fe,      0,      1}, {0x04ff, 0x04ff,     -1,      0}, {0x0500, 0x0500,      0,      1},
	{0x0501, 0x0501,     -1,      0}, {0x0502, 0x0502,      0,      1}, {0x0503, 0x0503,     -1,      0},
	{0x0504, 0x0504,      0,      1}, {0x0505, 0x0505,     -1,      0}, {0x0506, 0x0506,      0,      1},
	{0x0507, 0x0507,     -1,      0}, {0x0508, 0x0508,      0,      1}, {0x0509, 0x0509,     -1,      0},
	{0x050a, 0x050a,      0,      1}, {0x050b, 0x050b,     -1,      0}, {0x050c, 0x050c,      0,      1},
	{0x050d, 0x050d,     -1,      0}, {0x050e, 0x050e,      0,      1}, {0x050f, 0x050f,     -1,      0},
	{0x0510, 0x0510,      0,      1}, {0x0511, 0x0511,     -1,      0}, {0x0512, 0x0512,      0,      1},
	{0x0513, 0x0513,     -1,      0}, {0x0514, 0x0514,      0,      1}, {0x0515, 0x0515,     -1,      0},
	{0x0516, 0x0516,      0,      1}, {0x0517, 0x0517,     -1,      0}, {0x0518, 0x0518,      0,      1},
	{0x0519, 0x0519,     -1,      0}, {0x051a, 0x051a,      0,      1}, {0x051b, 0x051b,     -1,      0},
	{0x051c, 0x051c,      0,      1}, {0x051d, 0x051d,     -1,      0}, {0x051e, 0x051e,      0,      1},
	{0x051f, 0x051f,     -1,      0}, {0x0520, 0x0520,      0,      1}, {0x0521, 0x0521,     -1,      0},
	{0x0522, 0x0522,      0,      1}, {0x0523, 0x0523,     -1,      0}, {0x0524, 0x0524,      0,      1},
	{0x0525, 0x0525,     -1,      0}, {0x0526, 0x0526,      0,      1}, {0x0527, 0x0527,     -1,      0},
	{0x0528, 0x0528,      0,      1}, {0x0529, 0x0529,     -1,      0}, {0x052a, 0x052a,      0,      1},
	{0x052b, 0x052b,     -1,      0}, {0x052c, 0x052c,      0,      1}, {0x052d, 0x052d,     -1,      0},
	{0x052e, 0x052e,      0,      1}, {0x052f, 0x052f,     -1,      0}, {0x0531, 0x0556,      0,     48},
	{0x0561, 0x0586,    -48,      0}, {0x10a0, 0x10c5,      0,   7264}, {0x10c7, 0x10c7,      0,   7264},
	{0x10cd, 0x10cd,      0,   7264}, {0x10d0, 0x10fa,   3008,      0}, {0x10fd, 0x10ff,   3008,      0},
	{0x13a0, 0x13ef,      0,  38864}, {0x13f0, 0x13f5,      0,      8}, {0x13f8, 0x13fd,     -8,      0},
	{0x1c80, 0x1c80,  -6254,      0}, {0x1c81, 0x1c81,  -6253,      0}, {0x1c82, 0x1c82,  -6244,      0},
	{0x1c83, 0x1c84,  -6242,      0}, {0x1c85, 0x1c85,  -6243,      0}, {0x1c86, 0x1c86,  -6236,      0},
	{0x1c87, 0x1c87,  -6181,      0}, {0x1c88, 0x1c88,  35266,      0}, {0x1c89, 0x1c89,      0,      1},
	{0x1c8a, 0x1c8a,     -1,      0}, {0x1c90, 0x1cba,      0,  -3008}, {0x1cbd, 0x1cbf,      0,  -3008},
	{0x1d79, 0x1d79,  35332,      0}, {0x1d7d, 0x1d7d,   3814,      0}, {0x1d8e, 0x1d8e,  35384,      0},
	{0x1e00, 0x1e00,      0,      1}, {0x1e01, 0x1e01,     -1,      0}, {0x1e02, 0x1e02,      0,      1},
	{0x1e03, 0x1e03,     -1,      0}, {0x1e04, 0x1e04,      0,      1}, {0x1e05, 0x1e05,     -1,      0},
	{0x1e06, 0x1e06,      0,      1}, {0x1e07, 0x1e07,     -1,      0}, {0x1e08, 0x1e08,      0,      1},
	{0x1e09, 0x1e09,     -1,      0}, {0x1e0a, 0x1e0a,      0,      1}, {0x1e0b, 0x1e0b,     -1,      0},
	{0x1e0c, 0x1e0c,      0,      1}, {0x1e0d, 0x1e0d,     -1,      0}, {0x1e0e, 0x1e0e,      0,      1},
	{0x1e0f, 0x1e0f,     -1,      0}, {0x1e10, 0x1e10,      0,      1}, {0x1e11, 0x1e11,     -1,      0},
	{0x1e12, 0x1e12,      0,      1}, {0x1e13, 0x1e13,     -1,      0}, {0x1e14, 0x1e14,      0,      1},
	{0x1e15, 0x1e15,     -1,      0}, {0x1e16, 0x1e16,      0,      1}, {0x1e17, 0x1e17,     -1,      0},
	{0x1e18, 0x1e18,      0,      1}, {0x1e19, 0x1e19,     -1,      0}, {0x1e1a, 0x1e1a,      0,      1},
	{0x1e1b, 0x1e1b,     -1,      0}, {0x1e1c, 0x1e1c,      0,      1}, {0x1e1d, 0x1e1d,     -1,      0},
	{0x1e1e, 0x1e1e,      0,      1}, {0x1e1f, 0x1e1f,     -1,      0}, {0x1e20, 0x1e20,      0,      1},
	{0x1e21, 0x1e21,     -1,      0}, {0x1e22, 0x1e22,      0,      1}, {0x1e23, 0x1e23,     -1,      0},
	{0x1e24, 0x1e24,      0,      1}, {0x1e25, 0x1e25,     -1,      0}, {0x1e26, 0x1e26,      0,      1},
	{0x1e27, 0x1e27,     -1,      0}, {0x1e28, 0x1e28,      0,      1}, {0x1e29, 0x1e29,     -1,      0},
	{0x1e2a, 0x1e2a,      0,      1}, {0x1e2b, 0x1e2b,     -1,      0}, {0x1e2c, 0x1e2c,      0,      1},
	{0x1e2d, 0x1e2d,     -1,      0}, {0x1e2e, 0x1e2e,      0,      1}, {0x1e2f, 0x1e2f,     -1,      0},
	{0x1e30, 0x1e30,      0,      1}, {0x1e31, 0x1e31,     -1,      0}, {0x1e32, 0x1e32,      0,      1},
	{0x1e33, 0x1e33,     -1,      0}, {0x1e34, 0x1e34,      0,      1}, {0x1e35, 0x1e35,     -1,      0},
	{0x1e36, 0x1e36,      0,      1}, {0x1e37, 0x1e37,     -1,      0}, {0x1e38, 0x1e38,      0,      1},
	{0x1e39, 0x1e39,     -1,      0}, {0x1e3a, 0x1e3a,      0,      1}, {0x1e3b, 0x1e3b,     -1,      0},
	{0x1e3c, 0x1e3c,      0,      1}, {0x1e3d, 0x1e3d,     -1,      0}, {0x1e3e, 0x1e3e,      0,      1},
	{0x1e3f, 0x1e3f,     -1,      0}, {0x1e40, 0x1e40,      0,      1}, {0x1e41, 0x1e41,     -1,      0},
	{0x1e42, 0x1e42,      0,      1}, {0x1e43, 0x1e43,     -1,      0}, {0x1e44, 0x1e44,      0,      1},
	{0x1e45, 0x1e45,     -1,      0}, {0x1e46, 0x1e46,      0,      1}, {0x1e47, 0x1e47,     -1,      0},
	{0x1e48, 0x1e48,      0,      1}, {0x1e49, 0x1e49,     -1,      0}, {0x1e4a, 0x1e4a,      0,      1},
	{0x1e4b, 0x1e4b,     -1,      0}, {0x1e4c, 0x1e4c,      0,      1}, {0x1e4d, 0x1e4d,     -1,      0},
	{0x1e4e, 0x1e4e,      0,      1}, {0x1e4f, 0x1e4f,     -1,      0}, {0x1e50, 0x1e50,      0,      1},
	{0x1e51, 0x1e51,     -1,      0}, {0x1e52, 0x1e52,      0,      1}, {0x1e53, 0x1e53,     -1,      0},
	{0x1e54, 0x1e54,      0,      1}, {0x1e55, 0x1e55,     -1,      0}, {0x1e56, 0x1e56,      0,      1},
	{0x1e57, 0x1e57,     -1,      0}, {0x1e58, 0x1e58,      0,      1}, {0x1e59, 0x1e59,     -1,      0},
	{0x1e5a, 0x1e5a,      0,      1}, {0x1e5b, 0x1e5b,     -1,      0}, {0x1e5c, 0x1e5c,      0,      1},
	{0x1e5d, 0x1e5d,     -1,      0}, {0x1e5e, 0x1e5e,      0,      1}, {0x1e5f, 0x1e5f,     -1,      0},
	{0x1e60, 0x1e60,      0,      1}, {0x1e61, 0x1e61,     -1,      0}, {0x1e62, 0x1e62,      0,      1},
	{0x1e63, 0x1e63,     -1,      0}, {0x1e64, 0x1e64,      0,      1}, {0x1e65, 0x1e65,     -1,      0},
	{0x1e66, 0x1e66,      0,      1}, {0x1e67, 0x1e67,     -1,      0}, {0x1e68, 0x1e68,      0,      1},
	{0x1e69, 0x1e69,     -1,      0}, {0x1e6a, 0x1e6a,      0,      1}, {0x1e6b, 0x1e6b,     -1,      0},
	{0x1e6c, 0x1e6c,      0,      1}, {0x1e6d, 0x1e6d,     -1,      0}, {0x1e6e, 0x1e6e,      0,      1},
	{0x1e6f, 0x1e6f,     -1,      0}, {0x1e70, 0x1e70,      0,      1}, {0x1e71, 0x1e71,     -1,      0},
	{0x1e72, 0x1e72,      0,      1}, {0x1e73, 0x1e73,     -1,      0}, {0x1e74, 0x1e74,      0,      1},
	{0x1e75, 0x1e75,     -1,      0}, {0x1e76, 0x1e76,      0,      1}, {0x1e77, 0x1e77,     -1,      0},
	{0x1e78, 0x1e78,      0,      1}, {0x1e79, 0x1e79,     -1,      0}, {0x1e7a, 0x1e7a,      0,      1},
	{0x1e7b, 0x1e7b,     -1,      0}, {0x1e7c, 0x1e7c,      0,      1}, {0x1e7d, 0x1e7d,     -1,      0},
	{0x1e7e, 0x1e7e,      0,      1}, {0x1e7f, 0x1e7f,     -1,      0}, {0x1e80, 0x1e80,      0,      1},
	{0x1e81, 0x1e81,     -1,      0}, {0x1e82, 0x1e82,      0,      1}, {0x1e83, 0x1e83,     -1,      0},
	{0x1e84, 0x1e84,      0,      1}, {0x1e85, 0x1e85,     -1,      0}, {0x1e86, 0x1e86,      0,      1},
	{0x1e87, 0x1e87,     -1,      0}, {0x1e88, 0x1e88,      0,      1}, {0x1e89, 0x1e89,     -1,      0},
	{0x1e8a, 0x1e8a,      0,      1}, {0x1e8b, 0x1e8b,     -1,      0}, {0x1e8c, 0x1e8c,      0,      1},
	{0x1e8d, 0x1e8d,     -1,      0}, {0x1e8e, 0x1e8e,      0,      1}, {0x1e8f, 0x1e8f,     -1,      0},
	{0x1e90, 0x1e90,      0,      1}, {0x1e91, 0x1e91,     -1,      0}, {0x1e92, 0x1e92,      0,      1},
	{0x1e93, 0x1e93,     -1,      0}, {0x1e94, 0x1e94,      0,      1}, {0x1e95, 0x1e95,     -1,      0},
	{0x1e9b, 0x1e9b,    -59,      0}, {0x1e9e, 0x1e9e,      0,  -7615}, {0x1ea0, 0x1ea0,      0,      1},
	{0x1ea1, 0x1ea1,     -1,      0}, {0x1ea2, 0x1ea2,      0,      1}, {0x1ea3, 0x1ea3,     -1,      0},
	{0x1ea4, 0x1ea4,      0,      1}, {0x1ea5, 0x1ea5,     -1,      0}, {0x1ea6, 0x1ea6,      0,      1},
	{0x1ea7, 0x1ea7,     -1,      0}, {0x1ea8, 0x1ea8,      0,      1}, {0x1ea9, 0x1ea9,     -1,      0},
	{0x1eaa, 0x1eaa,      0,      1}, {0x1eab, 0x1eab,     -1,      0}, {0x1eac, 0x1eac,      0,      1},
	{0x1ead, 0x1ead,     -1,      0}, {0x1eae, 0x1eae,      0,      1}, {0x1eaf, 0x1eaf,     -1,      0},
	{0x1eb0, 0x1eb0,      0,      1}, {0x1eb1, 0x1eb1,     -1,      0}, {0x1eb2, 0x1eb2,      0,      1},
	{0x1eb3, 0x1eb3,     -1,      0}, {0x1eb4, 0x1eb4,      0,      1}, {0x1eb5, 0x1eb5,     -1,      0},
	{0x1eb6, 0x1eb6,      0,      1}, {0x1eb7, 0x1eb7,     -1,      0}, {0x1eb8, 0x1eb8,      0,      1},
	{0x1eb9, 0x1eb9,     -1,      0}, {0x1eba, 0x1eba,      0,      1}, {0x1ebb, 0x1ebb,     -1,      0},
	{0x1ebc, 0x1ebc,      0,      1}, {0x1ebd, 0x1ebd,     -1,      0}, {0x1ebe, 0x1ebe,      0,      1},
	{0x1ebf, 0x1ebf,     -1,      0}, {0x1ec0, 0x1ec0,      0,      1}, {0x1ec1, 0x1ec1,     -1,      0},
	{0x1ec2, 0x1ec2,      0,      1}, {0x1ec3, 0x1ec3,     -1,      0}, {0x1ec4, 0x1ec4,      0,      1},
	{0x1ec5, 0x1ec5,     -1,      0}, {0x1ec6, 0x1ec6,      0,      1}, {0x1ec7, 0x1ec7,     -1,      0},
	{0x1ec8, 0x1ec8,      0,      1}, {0x1ec9, 0x1ec9,     -1,      0}, {0x1eca, 0x1eca,      0,      1},
	{0x1ecb, 0x1ecb,     -1,      0}, {0x1ecc, 0x1ecc,      0,      1}, {0x1ecd, 0x1ecd,     -1,      0},
	{0x1ece, 0x1ece,      0,      1}, {0x1ecf, 0x1ecf,     -1,      0}, {0x1ed0, 0x1ed0,      0,      1},
	{0x1ed1, 0x1ed1,     -1,      0}, {0x1ed2, 0x1ed2,      0,      1}, {0x1ed3, 0x1ed3,     -1,      0},
	{0x1ed4, 0x1ed4,      0,      1}, {0x1ed5, 0x1ed5,     -1,      0}, {0x1ed6, 0x1ed6,      0,      1},
	{0x1ed7, 0x1ed7,     -1,      0}, {0x1ed8, 0x1ed8,      0,      1}, {0x1ed9, 0x1ed9,     -1,      0},
	{0x1eda, 0x1eda,      0,      1}, {0x1edb, 0x1edb,     -1,      0}, {0x1edc, 0x1edc,      0,      1},
	{0x1edd, 0x1edd,     -1,      0}, {0x1ede, 0x1ede,      0,      1}, {0x1edf, 0x1edf,     -1,      0},
	{0x1ee0, 0x1ee0,      0,      1}, {0x1ee1, 0x1ee1,     -1,      0}, {0x1ee2, 0x1ee2,      0,      1},
	{0x1ee3, 0x1ee3,     -1,      0}, {0x1ee4, 0x1ee4,      0,      1}, {0x1ee5, 0x1ee5,     -1,      0},
	{0x1ee6, 0x1ee6,      0,      1}, {0x1ee7, 0x1ee7,     -1,      0}, {0x1ee8, 0x1ee8,      0,      1},
	{0x1ee9, 0x1ee9,     -1,      0}, {0x1eea, 0x1eea,      0,      1}, {0x1eeb, 0x1eeb,     -1,      0},
	{0x1eec, 0x1eec,      0,      1}, {0x1eed, 0x1eed,     -1,      0}, {0x1eee, 0x1eee,      0,      1},
	{0x1eef, 0x1eef,     -1,      0}, {0x1ef0, 0x1ef0,      0,      1}, {0x1ef1, 0x1ef1,     -1,      0},
	{0x1ef2, 0x1ef2,      0,      1}, {0x1ef3, 0x1ef3,     -1,      0}, {0x1ef4, 0x1ef4,      0,      1},
	{0x1ef5, 0x1ef5,     -1,      0}, {0x1ef6, 0x1ef6,      0,      1}, {0x1ef7, 0x1ef7,     -1,      0},
	{0x1ef8, 0x1ef8,      0,      1}, {0x1ef9, 0x1ef9,     -1,      0}, {0x1efa, 0x1efa,      0,      1},
	{0x1efb, 0x1efb,     -1,      0}, {0x1efc, 0x1efc,      0,      1}, {0x1efd, 0x1efd,     -1,      0},
	{0x1efe, 0x1efe,      0,      1}, {0x1eff, 0x1eff,     -1,      0}, {0x1f00, 0x1f07,      8,      0},
	{0x1f08, 0x1f0f,      0,     -8}, {0x1f10, 0x1f15,      8,      0}, {0x1f18, 0x1f1d,      0,     -8},
	{0x1f20, 0x1f27,      8,      0}, {0x1f28, 0x1f2f,      0,     -8}, {0x1f30, 0x1f37,      8,      0},
	{0x1f38, 0x1f3f,      0,     -8}, {0x1f40, 0x1f45,      8,      0}, {0x1f48, 0x1f4d,      0,     -8},
	{0x1f51, 0x1f51,      8,      0}, {0x1f53, 0x1f53,      8,      0}, {0x1f55, 0x1f55,      8,      0},
	{0x1f57, 0x1f57,      8,      0}, {0x1f59, 0x1f59,      0,     -8}, {0x1f5b, 0x1f5b,      0,     -8},
	{0x1f5d, 0x1f5d,      0,     -8}, {0x1f5f, 0x1f5f,      0,     -8}, {0x1f60, 0x1f67,      8,      0},
	{0x1f68, 0x1f6f,      0,     -8}, {0x1f70, 0x1f71,     74,      0}, {0x1f72, 0x1f75,     86,      0},
	{0x1f76, 0x1f77,    100,      0}, {0x1f78, 0x1f79,    128,      0}, {0x1f7a, 0x1f7b,    112,      0},
	{0x1f7c, 0x1f7d,    126,      0}, {0x1f80, 0x1f87,      8,      0}, {0x1f90, 0x1f97,      8,      0},
	{0x1fa0, 0x1fa7,      8,      0}, {0x1fb0, 0x1fb1,      8,      0}, {0x1fb3, 0x1fb3,      9,      0},
	{0x1fb8, 0x1fb9,      0,     -8}, {0x1fba, 0x1fbb,      0,    -74}, {0x1fbe, 0x1fbe,  -7205,      0},
	{0x1fc3, 0x1fc3,      9,      0}, {0x1fc8, 0x1fcb,      0,    -86}, {0x1fd0, 0x1fd1,      8,      0},
	{0x1fd8, 0x1fd9,      0,     -8}, {0x1fda, 0x1fdb,      0,   -100}, {0x1fe0, 0x1fe1,      8,      0},
	{0x1fe5, 0x1fe5,      7,      0}, {0x1fe8, 0x1fe9,      0,     -8}, {0x1fea, 0x1feb,      0,   -112},
	{0x1fec, 0x1fec,      0,     -7}, {0x1ff3, 0x1ff3,      9,      0}, {0x1ff8, 0x1ff9,      0,   -128},
	{0x1ffa, 0x1ffb,      0,   -126}, {0x2126, 0x2126,      0,  -7517}, {0x212a, 0x212a,      0,  -8383},
	{0x212b, 0x212b,      0,  -8262}, {0x2132, 0x2132,      0,     28}, {0x214e, 0x214e,    -28,      0},
	{0x2183, 0x2183,      0,      1}, {0x2184, 0x2184,     -1,      0}, {0x2c00, 0x2c2f,      0,     48},
	{0x2c30, 0x2c5f,    -48,      0}, {0x2c60, 0x2c60,      0,      1}, {0x2c61, 0x2c61,     -1,      0},
	{0x2c62, 0x2c62,      0, -10743}, {0x2c63, 0x2c63,      0,  -3814}, {0x2c64, 0x2c64,      0, -10727},
	{0x2c65, 0x2c65, -10795,      0}, {0x2c66, 0x2c66, -10792,      0}, {0x2c67, 0x2c67,      0,      1},
	{0x2c68, 0x2c68,     -1,      0}, {0x2c69, 0x2c69,      0,      1}, {0x2c6a, 0x2c6a,     -1,      0},
	{0x2c6b, 0x2c6b,      0,      1}, {0x2c6c, 0x2c6c,     -1,      0}, {0x2c6d, 0x2c6d,      0, -10780},
	{0x2c6e, 0x2c6e,      0, -10749}, {0x2c6f, 0x2c6f,      0, -10783}, {0x2c70, 0x2c70,      0, -10782},
	{0x2c72, 0x2c72,      0,      1}, {0x2c73, 0x2c73,     -1,      0}, {0x2c75, 0x2c75,      0,      1},
	{0x2c76, 0x2c76,     -1,      0}, {0x2c7e, 0x2c7f,      0, -10815}, {0x2c80, 0x2c80,      0,      1},
	{0x2c81, 0x2c81,     -1,      0}, {0x2c82, 0x2c82,      0,      1}, {0x2c83, 0x2c83,     -1,      0},
	{0x2c84, 0x2c84,      0,      1}, {0x2c85, 0x2c85,     -1,      0}, {0x2c86, 0x2c86,      0,      1},
	{0x2c87, 0x2c87,     -1,      0}, {0x2c88, 0x2c88,      0,      1}, {0x2c89, 0x2c89,     -1,      0},
	{0x2c8a, 0x2c8a,      0,      1}, {0x2c8b, 0x2c8b,     -1,      0}, {0x2c8c, 0x2c8c,      0,      1},
	{0x2c8d, 0x2c8d,     -1,      0}, {0x2c8e, 0x2c8e,      0,      1}, {0x2c8f, 0x2c8f,     -1,      0},
	{0x2c90, 0x2c90,      0,      1}, {0x2c91, 0x2c91,     -1,      0}, {0x2c92, 0x2c92,      0,      1},
	{0x2c93, 0x2c93,     -1,      0}, {0x2c94, 0x2c94,      0,      1}, {0x2c95, 0x2c95,     -1,      0},
	{0x2c96, 0x2c96,      0,      1}, {0x2c97, 0x2c97,     -1,      0}, {0x2c98, 0x2c98,      0,      1},
	{0x2c99, 0x2c99,     -1,      0}, {0x2c9a, 0x2c9a,      0,      1}, {0x2c9b, 0x2c9b,     -1,      0},
	{0x2c9c, 0x2c9c,      0,      1}, {0x2c9d, 0x2c9d,     -1,      0}, {0x2c9e, 0x2c9e,      0,      1},
	{0x2c9f, 0x2c9f,     -1,      0}, {0x2ca0, 0x2ca0,      0,      1}, {0x2ca1, 0x2ca1,     -1,      0},
	{0x2ca2, 0x2ca2,      0,      1}, {0x2ca3, 0x2ca3,     -1,      0}, {0x2ca4, 0x2ca4,      0,      1},
	{0x2ca5, 0x2ca5,     -1,      0}, {0x2ca6, 0x2ca6,      0,      1}, {0x2ca7, 0x2ca7,     -1,      0},
	{0x2ca8, 0x2ca8,      0,      1}, {0x2ca9, 0x2ca9,     -1,      0}, {0x2caa, 0x2caa,      0,      1},
	{0x2cab, 0x2cab,     -1,      0}, {0x2cac, 0x2cac,      0,      1}, {0x2cad, 0x2cad,     -1,      0},
	{0x2cae, 0x2cae,      0,      1}, {0x2caf, 0x2caf,     -1,      0}, {0x2cb0, 0x2cb0,      0,      1},
	{0x2cb1, 0x2cb1,     -1,      0}, {0x2cb2, 0x2cb2,      0,      1}, {0x2cb3, 0x2cb3,     -1,      0},
	{0x2cb4, 0x2cb4,      0,      1}, {0x2cb5, 0x2cb5,     -1,      0}, {0x2cb6, 0x2cb6,      0,      1},
	{0x2cb7, 0x2cb7,     -1,      0}, {0x2cb8, 0x2cb8,      0,      1}, {0x2cb9, 0x2cb9,     -1,      0},
	{0x2cba, 0x2cba,      0,      1}, {0x2cbb, 0x2cbb,     -1,      0}, {0x2cbc, 0x2cbc,      0,      1},
	{0x2cbd, 0x2cbd,     -1,      0}, {0x2cbe, 0x2cbe,      0,      1}, {0x2cbf, 0x2cbf,     -1,      0},
	{0x2cc0, 0x2cc0,      0,      1}, {0x2cc1, 0x2cc1,     -1,      0}, {0x2cc2, 0x2cc2,      0,      1},
	{0x2cc3, 0x2cc3,     -1,      0}, {0x2cc4, 0x2cc4,      0,      1}, {0x2cc5, 0x2cc5,     -1,      0},
	{0x2cc6, 0x2cc6,      0,      1}, {0x2cc7, 0x2cc7,     -1,      0}, {0x2cc8, 0x2cc8,      0,      1},
	{0x2cc9, 0x2cc9,     -1,      0}, {0x2cca, 0x2cca,      0,      1}, {0x2ccb, 0x2ccb,     -1,      0},
	{0x2ccc, 0x2ccc,      0,      1}, {0x2ccd, 0x2ccd,     -1,      0}, {0x2cce, 0x2cce,      0,      1},
	{0x2ccf, 0x2ccf,     -1,      0}, {0x2cd0, 0x2cd0,      0,      1}, {0x2cd1, 0x2cd1,     -1,      0},
	{0x2cd2, 0x2cd2,      0,      1}, {0x2cd3, 0x2cd3,     -1,      0}, {0x2cd4, 0x2cd4,      0,      1},
	{0x2cd5, 0x2cd5,     -1,      0}, {0x2cd6, 0x2cd6,      0,      1}, {0x2cd7, 0x2cd7,     -1,      0},
	{0x2cd8, 0x2cd8,      0,      1}, {0x2cd9, 0x2cd9,     -1,      0}, {0x2cda, 0x2cda,      0,      1},
	{0x2cdb, 0x2cdb,     -1,      0}, {0x2cdc, 0x2cdc,      0,      1}, {0x2cdd, 0x2cdd,     -1,      0},
	{0x2cde, 0x2cde,      0,      1}, {0x2cdf, 0x2cdf,     -1,      0}, {0x2ce0, 0x2ce0,      0,      1},
	{0x2ce1, 0x2ce1,     -1,      0}, {0x2ce2, 0x2ce2,      0,      1}, {0x2ce3, 0x2ce3,     -1,      0},
	{0x2ceb, 0x2ceb,      0,      1}, {0x2cec, 0x2cec,     -1,      0}, {0x2ced, 0x2ced,      0,      1},
	{0x2cee, 0x2cee,     -1,      0}, {0x2cf2, 0x2cf2,      0,      1}, {0x2cf3, 0x2cf3,     -1,      0},
	{0x2d00, 0x2d25,  -7264,      0}, {0x2d27, 0x2d27,  -7264,      0}, {0x2d2d, 0x2d2d,  -7264,      0},
	{0xa640, 0xa640,      0,      1}, {0xa641, 0xa641,     -1,      0}, {0xa642, 0xa642,      0,      1},
	{0xa643, 0xa643,     -1,      0}, {0xa644, 0xa644,      0,      1}, {0xa645, 0xa645,     -1,      0},
	{0xa646, 0xa646,      0,      1}, {0xa647, 0xa647,     -1,      0}, {0xa648, 0xa648,      0,      1},
	{0xa649, 0xa649,     -1,      0}, {0xa64a, 0xa64a,      0,      1}, {0xa64b, 0xa64b,     -1,      0},
	{0xa64c, 0xa64c,      0,      1}, {0xa64d, 0xa64d,     -1,      0}, {0xa64e, 0xa64e,      0,      1},
	{0xa64f, 0xa64f,     -1,      0}, {0xa650, 0xa650,      0,      1}, {0xa651, 0xa651,     -1,      0},
	{0xa652, 0xa652,      0,      1}, {0xa653, 0xa653,     -1,      0}, {0xa654, 0xa654,      0,      1},
	{0xa655, 0xa655,     -1,      0}, {0xa656, 0xa656,      0,      1}, {0xa657, 0xa657,     -1,      0},
	{0xa658, 0xa658,      0,      1}, {0xa659, 0xa659,     -1,      0}, {0xa65a, 0xa65a,      0,      1},
	{0xa65b, 0xa65b,     -1,      0}, {0xa65c, 0xa65c,      0,      1}, {0xa65d, 0xa65d,     -1,      0},
	{0xa65e, 0xa65e,      0,      1}, {0xa65f, 0xa65f,     -1,      0}, {0xa660, 0xa660,      0,      1},
	{0xa661, 0xa661,     -1,      0}, {0xa662, 0xa662,      0,      1}, {0xa663, 0xa663,     -1,      0},
	{0xa664, 0xa664,      0,      1}, {0xa665, 0xa665,     -1,      0}, {0xa666, 0xa666,      0,      1},
	{0xa667, 0xa667,     -1,      0}, {0xa668, 0xa668,      0,      1}, {0xa669, 0xa669,     -1,      0},
	{0xa66a, 0xa66a,      0,      1}, {0xa66b, 0xa66b,     -1,      0}, {0xa66c, 0xa66c,      0,      1},
	{0xa66d, 0xa66d,     -1,      0}, {0xa680, 0xa680,      0,      1}, {0xa681, 0xa681,     -1,      0},
	{0xa682, 0xa682,      0,      1}, {0xa683, 0xa683,     -1,      0}, {0xa684, 0xa684,      0,      1},
	{0xa685, 0xa685,     -1,      0}, {0xa686, 0xa686,      0,      1}, {0xa687, 0xa687,     -1,      0},
	{0xa688, 0xa688,      0,      1}, {0xa689, 0xa689,     -1,      0}, {0xa68a, 0xa68a,      0,      1},
	{0xa68b, 0xa68b,     -1,      0}, {0xa68c, 0xa68c,      0,      1}, {0xa68d, 0xa68d,     -1,      0},
	{0xa68e, 0xa68e,      0,      1}, {0xa68f, 0xa68f,     -1,      0}, {0xa690, 0xa690,      0,      1},
	{0xa691, 0xa691,     -1,      0}, {0xa692, 0xa692,      0,      1}, {0xa693, 0xa693,     -1,      0},
	{0xa694, 0xa694,      0,      1}, {0xa695, 0xa695,     -1,      0}, {0xa696, 0xa696,      0,      1},
	{0xa697, 0xa697,     -1,      0}, {0xa698, 0xa698,      0,      1}, {0xa699, 0xa699,     -1,      0},
	{0xa69a, 0xa69a,      0,      1}, {0xa69b, 0xa69b,     -1,      0}, {0xa722, 0xa722,      0,      1},
	{0xa723, 0xa723,     -1,      0}, {0xa724, 0xa724,      0,      1}, {0xa725, 0xa725,     -1,      0},
	{0xa726, 0xa726,      0,      1}, {0xa727, 0xa727,     -1,      0}, {0xa728, 0xa728,      0,      1},
	{0xa729, 0xa729,     -1,      0}, {0xa72a, 0xa72a,      0,      1}, {0xa72b, 0xa72b,     -1,      0},
	{0xa72c, 0xa72c,      0,      1}, {0xa72d, 0xa72d,     -1,      0}, {0xa72e, 0xa72e,      0,      1},
	{0xa72f, 0xa72f,     -1,      0}, {0xa732, 0xa732,      0,      1}, {0xa733, 0xa733,     -1,      0},
	{0xa734, 0xa734,      0,      1}, {0xa735, 0xa735,     -1,      0}, {0xa736, 0xa736,      0,      1},
	{0xa737, 0xa737,     -1,      0}, {0xa738, 0xa738,      0,      1}, {0xa739, 0xa739,     -1,      0},
	{0xa73a, 0xa73a,      0,      1}, {0xa73b, 0xa73b,     -1,      0}, {0xa73c, 0xa73c,      0,      1},
	{0xa73d, 0xa73d,     -1,      0}, {0xa73e, 0xa73e,      0,      1}, {0xa73f, 0xa73f,     -1,      0},
	{0xa740, 0xa740,      0,      1}, {0xa741, 0xa741,     -1,      0}, {0xa742, 0xa742,      0,      1},
	{0xa743, 0xa743,     -1,      0}, {0xa744, 0xa744,      0,      1}, {0xa745, 0xa745,     -1,      0},
	{0xa746, 0xa746,      0,      1}, {0xa747, 0xa747,     -1,      0}, {0xa748, 0xa748,      0,      1},
	{0xa749, 0xa749,     -1,      0}, {0xa74a, 0xa74a,      0,      1}, {0xa74b, 0xa74b,     -1,      0},
	{0xa74c, 0xa74c,      0,      1}, {0xa74d, 0xa74d,     -1,      0}, {0xa74e, 0xa74e,      0,      1},
	{0xa74f, 0xa74f,     -1,      0}, {0xa750, 0xa750,      0,      1}, {0xa751, 0xa751,     -1,      0},
	{0xa752, 0xa752,      0,      1}, {0xa753, 0xa753,     -1,      0}, {0xa754, 0xa754,      0,      1},
	{0xa755, 0xa755,     -1,      0}, {0xa756, 0xa756,      0,      1}, {0xa757, 0xa757,     -1,      0},
	{0xa758, 0xa758,      0,      1}, {0xa759, 0xa759,     -1,      0}, {0xa75a, 0xa75a,      0,      1},
	{0xa75b, 0xa75b,     -1,      0}, {0xa75c, 0xa75c,      0,      1}, {0xa75d, 0xa75d,     -1,      0},
	{0xa75e, 0xa75e,      0,      1}, {0xa75f, 0xa75f,     -1,      0}, {0xa760, 0xa760,      0,      1},
	{0xa761, 0xa761,     -1,      0}, {0xa762, 0xa762,      0,      1}, {0xa763, 0xa763,     -1,      0},
	{0xa764, 0xa764,      0,      1}, {0xa765, 0xa765,     -1,      0}, {0xa766, 0xa766,      0,      1},
	{0xa767, 0xa767,     -1,      0}, {0xa768, 0xa768,      0,      1}, {0xa769, 0xa769,     -1,      0},
	{0xa76a, 0xa76a,      0,      1}, {0xa76b, 0xa76b,     -1,      0}, {0xa76c, 0xa76c,      0,      1},
	{0xa76d, 0xa76d,     -1,      0}, {0xa76e, 0xa76e,      0,      1}, {0xa76f, 0xa76f,     -1,      0},
	{0xa779, 0xa779,      0,      1}, {0xa77a, 0xa77a,     -1,      0}, {0xa77b, 0xa77b,      0,      1},
	{0xa77c, 0xa77c,     -1,      0}, {0xa77d, 0xa77d,      0, -35332}, {0xa77e, 0xa77e,      0,      1},
	{0xa77f, 0xa77f,     -1,      0}, {0xa780, 0xa780,      0,      1}, {0xa781, 0xa781,     -1,      0},
	{0xa782, 0xa782,      0,      1}, {0xa783, 0xa783,     -1,      0}, {0xa784, 0xa784,      0,      1},
	{0xa785, 0xa785,     -1,      0}, {0xa786, 0xa786,      0,      1}, {0xa787, 0xa787,     -1,      0},
	{0xa78b, 0xa78b,      0,      1}, {0xa78c, 0xa78c,     -1,      0}, {0xa78d, 0xa78d,      0, -42280},
	{0xa790, 0xa790,      0,      1}, {0xa791, 0xa791,     -1,      0}, {0xa792, 0xa792,      0,      1},
	{0xa793, 0xa793,     -1,      0}, {0xa794, 0xa794,     48,      0}, {0xa796, 0xa796,      0,      1},
	{0xa797, 0xa797,     -1,      0}, {0xa798, 0xa798,      0,      1}, {0xa799, 0xa799,     -1,      0},
	{0xa79a, 0xa79a,      0,      1}, {0xa79b, 0xa79b,     -1,      0}, {0xa79c, 0xa79c,      0,      1},
	{0xa79d, 0xa79d,     -1,      0}, {0xa79e, 0xa79e,      0,      1}, {0xa79f, 0xa79f,     -1,      0},
	{0xa7a0, 0xa7a0,      0,      1}, {0xa7a1, 0xa7a1,     -1,      0}, {0xa7a2, 0xa7a2,      0,      1},
	{0xa7a3, 0xa7a3,     -1,      0}, {0xa7a4, 0xa7a4,      0,      1}, {0xa7a5, 0xa7a5,     -1,      0},
	{0xa7a6, 0xa7a6,      0,      1}, {0xa7a7, 0xa7a7,     -1,      0}, {0xa7a8, 0xa7a8,      0,      1},
	{0xa7a9, 0xa7a9,     -1,      0}, {0xa7aa, 0xa7aa,      0, -42308}, {0xa7ab, 0xa7ab,      0, -42319},
	{0xa7ac, 0xa7ac,      0, -42315}, {0xa7ad, 0xa7ad,      0, -42305}, {0xa7ae, 0xa7ae,      0, -42308},
	{0xa7b0, 0xa7b0,      0, -42258}, {0xa7b1, 0xa7b1,      0, -42282}, {0xa7b2, 0xa7b2,      0, -42261},
	{0xa7b3, 0xa7b3,      0,    928}, {0xa7b4, 0xa7b4,      0,      1}, {0xa7b5, 0xa7b5,     -1,      0},
	{0xa7b6, 0xa7b6,      0,      1}, {0xa7b7, 0xa7b7,     -1,      0}, {0xa7b8, 0xa7b8,      0,      1},
	{0xa7b9, 0xa7b9,     -1,      0}, {0xa7ba, 0xa7ba,      0,      1}, {0xa7bb, 0xa7bb,     -1,      0},
	{0xa7bc, 0xa7bc,      0,      1}, {0xa7bd, 0xa7bd,     -1,      0}, {0xa7be, 0xa7be,      0,      1},
	{0xa7bf, 0xa7bf,     -1,      0}, {0xa7c0, 0xa7c0,      0,      1}, {0xa7c1, 0xa7c1,     -1,      0},
	{0xa7c2, 0xa7c2,      0,      1}, {0xa7c3, 0xa7c3,     -1,      0}, {0xa7c4, 0xa7c4,      0,    -48},
	{0xa7c5, 0xa7c5,      0, -42307}, {0xa7c6, 0xa7c6,      0, -35384}, {0xa7c7, 0xa7c7,      0,      1},
	{0xa7c8, 0xa7c8,     -1,      0}, {0xa7c9, 0xa7c9,      0,      1}, {0xa7ca, 0xa7ca,     -1,      0},
	{0xa7cb, 0xa7cb,      0, -42343}, {0xa7cc, 0xa7cc,      0,      1}, {0xa7cd, 0xa7cd,     -1,      0},
	{0xa7ce, 0xa7ce,      0,      1}, {0xa7cf, 0xa7cf,     -1,      0}, {0xa7d0, 0xa7d0,      0,      1},
	{0xa7d1, 0xa7d1,     -1,      0}, {0xa7d2, 0xa7d2,      0,      1}, {0xa7d3, 0xa7d3,     -1,      0},
	{0xa7d4, 0xa7d4,      0,      1}, {0xa7d5, 0xa7d5,     -1,      0}, {0xa7d6, 0xa7d6,      0,      1},
	{0xa7d7, 0xa7d7,     -1,      0}, {0xa7d8, 0xa7d8,      0,      1}, {0xa7d9, 0xa7d9,     -1,      0},
	{0xa7da, 0xa7da,      0,      1}, {0xa7db, 0xa7db,     -1,      0}, {0xa7dc, 0xa7dc,      0, -42561},
	{0xa7f5, 0xa7f5,      0,      1}, {0xa7f6, 0xa7f6,     -1,      0}, {0xab53, 0xab53,   -928,      0},
	{0xab70, 0xabbf, -38864,      0}, {0xff21, 0xff3a,      0,     32}, {0xff41, 0xff5a,    -32,      0}
};


//
//	case32
//

#if defined(IMGUI_USE_WCHAR32)

static CaseRange32 case32[] = {
	{0x10400, 0x10427,   0, 40}, {0x10428, 0x1044f, -40,  0}, {0x104b0, 0x104d3,   0, 40}, {0x104d8, 0x104fb, -40,  0},
	{0x10570, 0x1057a,   0, 39}, {0x1057c, 0x1058a,   0, 39}, {0x1058c, 0x10592,   0, 39}, {0x10594, 0x10595,   0, 39},
	{0x10597, 0x105a1, -39,  0}, {0x105a3, 0x105b1, -39,  0}, {0x105b3, 0x105b9, -39,  0}, {0x105bb, 0x105bc, -39,  0},
	{0x10c80, 0x10cb2,   0, 64}, {0x10cc0, 0x10cf2, -64,  0}, {0x10d50, 0x10d65,   0, 32}, {0x10d70, 0x10d85, -32,  0},
	{0x118a0, 0x118bf,   0, 32}, {0x118c0, 0x118df, -32,  0}, {0x16e40, 0x16e5f,   0, 32}, {0x16e60, 0x16e7f, -32,  0},
	{0x16ea0, 0x16eb8,   0, 27}, {0x16ebb, 0x16ed3, -27,  0}, {0x1e900, 0x1e921,   0, 34}, {0x1e922, 0x1e943, -34,  0}
};

#endif


//
//	Internal type conversions because "char" is signed
//

static inline ImWchar uch(char c) {
	return static_cast<ImWchar>(c);
}

static inline char sch(ImWchar i) {
	return static_cast<char>(i);
}


//
//	skipBOM
//

std::string_view::const_iterator TextEditor::CodePoint::skipBOM(std::string_view::const_iterator i, std::string_view::const_iterator end) {
	// skip Byte Order Mark (BOM) just in case there is one

	// Note: the standard states that:
	// Use of a BOM is neither required nor recommended for UTF-8
	static constexpr char bom1 = static_cast<char>(0xEF);
	static constexpr char bom2 = static_cast<char>(0xBB);
	static constexpr char bom3 = static_cast<char>(0xBF);
	return ((end - i) >= 3 && i[0] == bom1 && i[1] == bom2 && i[2] == bom3) ? i + 3 : i;
}


//
//	TextEditor::CodePoint::read
//

std::string_view::const_iterator TextEditor::CodePoint::read(std::string_view::const_iterator i, std::string_view::const_iterator end, ImWchar *codepoint) {
	// parse a UTF-8 sequence into a unicode codepoint and return updated iterator
	if (i < end && (uch(*i) & 0x80) == 0) {
		*codepoint = uch(*i);
		++i;

	} else if (i + 1 < end && (uch(*i) & 0xE0) == 0xC0) {
		*codepoint = ((uch(*i) & 0x1f) << 6) | (uch(*(i + 1)) & 0x3f);
		i += 2;

	} else if (i + 2 < end && (uch(*i) & 0xF0) == 0xE0) {
		*codepoint = ((uch(*i) & 0x0f) << 12) | ((uch(*(i + 1)) & 0x3f) << 6) | (uch(*(i + 2)) & 0x3f);
		i += 3;

	} else if (i + 3 < end && (uch(*i) & 0xF8) == 0xF0) {
#if defined(IMGUI_USE_WCHAR32)
		*codepoint = ((uch(*i) & 0x07) << 18) | ((uch(*(i + 1)) & 0x3f) << 12) | ((uch(*(i + 2)) & 0x3f) << 6) | (uch(*(i + 3)) & 0x3f);
#else
		*codepoint = IM_UNICODE_CODEPOINT_INVALID;
#endif
		i += 4;

	} else {
		*codepoint = IM_UNICODE_CODEPOINT_INVALID;
		++i;
	}

	return i;
}


//
//	TextEditor::CodePoint::write
//

size_t TextEditor::CodePoint::write(char* start, ImWchar codepoint) {
	// generate UTF-8 sequence from a unicode codepoint and return bytes written
	auto i = start;

	if (codepoint < 0x80) {
		*i++ = sch(codepoint);

	} else if (codepoint < 0x800) {
		*i++ = sch(0xc0 | ((codepoint >> 6) & 0x1f));
		*i++ = sch(0x80 | (codepoint & 0x3f));

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint < 0x10000) {
		*i++ = sch(0xe0 | ((codepoint >> 12) & 0x0f));
		*i++ = sch(0x80 | ((codepoint >> 6) & 0x3f));
		*i++ = sch(0x80 | (codepoint & 0x3f));

	} else if (codepoint >= 0x110000) {
		codepoint = IM_UNICODE_CODEPOINT_INVALID;
		*i++ = sch(0xe0 | ((codepoint >> 12) & 0x0f));
		*i++ = sch(0x80 | ((codepoint >> 6) & 0x3f));
		*i++ = sch(0x80 | (codepoint & 0x3f));

	} else {
		*i++ = sch(0xf0 | ((codepoint >> 18) & 0x07));
		*i++ = sch(0x80 | ((codepoint >> 12) & 0x3f));
		*i++ = sch(0x80 | ((codepoint >> 6) & 0x3f));
		*i++ = sch(0x80 | (codepoint & 0x3f));

#else
	} else {
		*i++ = sch(0xe0 | ((codepoint >> 12) & 0x0f));
		*i++ = sch(0x80 | ((codepoint >> 6) & 0x3f));
		*i++ = sch(0x80 | (codepoint & 0x3f));
#endif
	}

	return i - start;
}


//
//	rangeContains
//

template <typename T, typename C>
bool rangeContains(const T& table, C codepoint) {
	auto low = std::begin(table);
	auto high = std::end(table);

	while (low <= high) {
		auto mid = low + (high - low) / 2;

		if (codepoint >= mid->low && codepoint <= mid->high) {
			return (mid->stride == 1) || ((codepoint - mid->low) % mid->stride == 0);

		} else if (codepoint < mid->low) {
			high = mid - 1;

		} else {
			low = mid + 1;
		}
	}

	return false;
}


//
//	TextEditor::CodePoint::isLetter
//

bool TextEditor::CodePoint::isLetter(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return static_cast<unsigned>((codepoint | 32) - 'a') < 26;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(letters32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(letters16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isNumber
//

bool TextEditor::CodePoint::isNumber(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return static_cast<unsigned>(codepoint - '0') < 10;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(numbers32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(numbers16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isXidStart
//

bool TextEditor::CodePoint::isXidStart(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return codepoint == '_' || static_cast<unsigned>((codepoint | 32) - 'a') < 26;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(xidStart32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(xidStart16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isWhiteSpace
//

bool TextEditor::CodePoint::isWhiteSpace(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return codepoint == ' ' || static_cast<unsigned>(codepoint - '\t') < 5;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return false;
#endif

	} else {
		return rangeContains(whitespace16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isWord
//

bool TextEditor::CodePoint::isWord(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return
			(static_cast<unsigned>((codepoint | 32) - 'a') < 26) ||
			(static_cast<unsigned>(codepoint - '0') < 10) ||
			codepoint == '_';

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return
			rangeContains(letters32, static_cast<ImWchar32>(codepoint)) ||
			rangeContains(numbers32, static_cast<ImWchar32>(codepoint)) ||
			codepoint == '_';
#endif

	} else {
		return
			rangeContains(letters16, static_cast<ImWchar16>(codepoint)) ||
			rangeContains(numbers16, static_cast<ImWchar16>(codepoint)) ||
			codepoint == '_';
	}
}


//
//	TextEditor::CodePoint::isXidContinue
//

bool TextEditor::CodePoint::isXidContinue(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return codepoint == '_' || (static_cast<unsigned>((codepoint | 32) - 'a') < 26) || (static_cast<unsigned>(codepoint - '0') < 10);

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(xidContinue32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(xidContinue16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isLower
//

bool TextEditor::CodePoint::isLower(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return static_cast<unsigned>(codepoint - 'a') < 26;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(lower32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(lower16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	TextEditor::CodePoint::isUpper
//

bool TextEditor::CodePoint::isUpper(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return static_cast<unsigned>(codepoint - 'A') < 26;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return rangeContains(upper32, static_cast<ImWchar32>(codepoint));
#endif

	} else {
		return rangeContains(upper16, static_cast<ImWchar16>(codepoint));
	}
}


//
//	eastAsianRangeFind
//

template <typename T, typename C>
bool eastAsianRangeFind(const T& table, C codepoint) {
	auto low = std::begin(table);
	auto high = std::end(table);

	while (low <= high) {
		auto mid = low + (high - low) / 2;

		if (codepoint >= mid->low && codepoint <= mid->high) {
			return true;

		} else if (codepoint < mid->low) {
			high = mid - 1;

		} else {
			low = mid + 1;
		}
	}

	return false;
}


//
//	isEastAsian
//

bool TextEditor::CodePoint::isEastAsian(ImWchar codepoint) {
	// handle simple case
	if (codepoint < 0x1100) {
		return false;
	}

	bool result;

#if defined(IMGUI_USE_WCHAR32)
	if (codepoint >= 0x10000) {
		result = eastAsianRangeFind(eastAsian32, static_cast<char32_t>(codepoint));

	} else
#endif

	{
		result = eastAsianRangeFind(eastAsian16, static_cast<char16_t>(codepoint));
	}

	if (!result) {
		if ((codepoint >= 0x3400 && codepoint <= 0x4DBF) ||
			(codepoint >= 0x4E00 && codepoint <= 0x9FFF) ||
			(codepoint >= 0xF900 && codepoint <= 0xFAFF)

#if defined(IMGUI_USE_WCHAR32)
			||
			(codepoint >= 0x20000 && codepoint <= 0x2FFFD) ||
			(codepoint >= 0x30000 && codepoint <= 0x3FFFD)
#endif
		) {

			result = true;
		}
	}

	return result;
}


//
//	caseRangeFind
//

template <typename T, typename C>
const CaseRange<C>* caseRangeFind(const T& table, C codepoint) {
	auto low = std::begin(table);
	auto high = std::end(table);

	while (low <= high) {
		auto mid = low + (high - low) / 2;

		if (codepoint >= mid->low && codepoint <= mid->high) {
			return mid;

		} else if (codepoint < mid->low) {
			high = mid - 1;

		} else {
			low = mid + 1;
		}
	}

	return nullptr;
}


//
//	caseRangeToUpper
//

template <typename T, typename C>
C caseRangeToUpper(const T& table, C codepoint) {
	auto caseRange = caseRangeFind(table, codepoint);

	if (!caseRange || caseRange->toUpper == 0) {
		return codepoint;

	} else if (caseRange->toUpper == 0xffff) {
		return codepoint & ~0x1;

	} else {
		return static_cast<C>(static_cast<int32_t>(codepoint) + caseRange->toUpper);
	}
}


//
//	caseRangeToLower
//

template <typename T, typename C>
C caseRangeToLower(const T& table, C codepoint) {
	auto caseRange = caseRangeFind(table, codepoint);

	if (!caseRange || caseRange->toLower == 0) {
		return codepoint;

	} else if (caseRange->toLower == 0xffff) {
		return codepoint | 0x1;

	} else {
		return static_cast<C>(static_cast<int32_t>(codepoint) + caseRange->toLower);
	}
}


//
//	TextEditor::CodePoint::toUpper
//

ImWchar TextEditor::CodePoint::toUpper(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return (static_cast<unsigned>(codepoint - 'a') < 26) ? codepoint & 0x5f : codepoint;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return caseRangeToUpper(case32, static_cast<char32_t>(codepoint));
#endif

	} else {
		return caseRangeToUpper(case16, static_cast<char16_t>(codepoint));
	}
}


//
//	TextEditor::CodePoint::toLower
//

ImWchar TextEditor::CodePoint::toLower(ImWchar codepoint) {
	if (codepoint < 0x7f) {
		return (static_cast<unsigned>(codepoint - 'A') < 26) ? codepoint | 32 : codepoint;

#if defined(IMGUI_USE_WCHAR32)
	} else if (codepoint >= 0x10000) {
		return caseRangeToLower(case32, static_cast<char32_t>(codepoint));
#endif

	} else {
		return caseRangeToLower(case16, static_cast<char16_t>(codepoint));
	}
}


//
//	TextEditor::updatePalette
//

void TextEditor::updatePalettes() {
	// update palette with the current alpha from the Dear ImGui style
	for (size_t i = 0; i < static_cast<size_t>(Color::count); i++) {
		palette[i] = ImGui::GetColorU32(paletteBase[i]);
		miniMapPalette[i] = ImGui::GetColorU32(paletteBase[i], miniMapAlpha);
	}
}


//
//	Color palettes
//

const TextEditor::Palette& TextEditor::GetDarkPalette() {
	const static Palette palette = {{
		IM_COL32(224, 224, 224, 255),	// text
		IM_COL32(197, 134, 192, 255),	// keyword
		IM_COL32( 90, 179, 155, 255),	// declaration
		IM_COL32(181, 206, 168, 255),	// number
		IM_COL32(206, 145, 120, 255),	// string
		IM_COL32(255, 255, 153, 255),	// punctuation
		IM_COL32( 64, 192, 128, 255),	// preprocessor
		IM_COL32(156, 220, 254, 255),	// identifier
		IM_COL32( 79, 193, 255, 255),	// known identifier
		IM_COL32(106, 153,  85, 255),	// comment
		IM_COL32( 30,  30,  30, 255),	// background
		IM_COL32(224, 224, 224, 255),	// cursor
		IM_COL32( 32,  96, 160, 255),	// selection
		IM_COL32( 80,  80,  80, 255),	// whitespace
		IM_COL32( 70,  70,  70, 255),	// matchingBracketBackground
		IM_COL32(140, 140, 140, 255),	// matchingBracketActive
		IM_COL32(246, 222,  36, 255),	// matchingBracketLevel1
		IM_COL32( 66, 120, 198, 255),	// matchingBracketLevel2
		IM_COL32(213,  96, 213, 255),	// matchingBracketLevel3
		IM_COL32(198,   8,  32, 255),	// matchingBracketError
		IM_COL32(128, 128, 144, 255),	// line number
		IM_COL32(224, 224, 240, 255),	// current line number
	}};

	return palette;
}

const TextEditor::Palette& TextEditor::GetLightPalette() {
	const static Palette palette = {{
		IM_COL32( 64,  64,  64, 255),	// text
		IM_COL32( 170,  0, 220, 255),	// keyword
		IM_COL32( 65,   0, 255, 255),	// declaration
		IM_COL32( 40, 140,  90, 255),	// number
		IM_COL32(160,  32,  32, 255),	// string
		IM_COL32(  0,   0,   0, 255),	// punctuation
		IM_COL32( 96,  96,  64, 255),	// preprocessor
		IM_COL32( 64,  64,  64, 255),	// identifier
		IM_COL32( 16,  96,  96, 255),	// known identifier
		IM_COL32( 35, 135,   5, 255),	// comment
		IM_COL32(255, 255, 255, 255),	// background
		IM_COL32(  0,   0,   0, 255),	// cursor
		IM_COL32(  0,   0,  96,  64),	// selection
		IM_COL32(144, 144, 144, 144),	// whitespace
		IM_COL32(180, 180, 180, 144),	// matchingBracketBackground
		IM_COL32( 72,  72,  72, 255),	// matchingBracketActive
		IM_COL32( 70,   0, 250, 255),	// matchingBracketLevel1
		IM_COL32( 80, 160,  70, 255),	// matchingBracketLevel2
		IM_COL32(120,  60,  25, 255),	// matchingBracketLevel3
		IM_COL32(198,   8,  32, 255),	// matchingBracketError
		IM_COL32(  0,  80,  80, 255),	// line number
		IM_COL32(  0,   0,   0, 255),	// current line number
	}};

	return palette;
}

TextEditor::Palette TextEditor::defaultPalette = TextEditor::GetDarkPalette();


//
//	getCStyleIdentifier
//

static TextEditor::Iterator getCStyleIdentifier(TextEditor::Iterator start, TextEditor::Iterator end) {
	if (start < end && TextEditor::CodePoint::isXidStart(*start)) {
		++start;

		while (start < end && TextEditor::CodePoint::isXidContinue(*start)) {
			++start;
		}
	}

	return start;
}


//
//	getCStyleNumber
//

static TextEditor::Iterator getCStyleNumber(TextEditor::Iterator start, TextEditor::Iterator end) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	unsigned int yyaccept = 0;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy3;
		case '0': goto yy4;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy6;
		default:
			if (i >= end) goto yy82;
			goto yy1;
	}
yy1:
	++i;
yy2:
	{ return start; }
yy3:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		default: goto yy2;
	}
yy4:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy5;
		case 'B':
		case 'b': goto yy16;
		case 'X':
		case 'x': goto yy20;
		default: goto yy13;
	}
yy5:
	{ return i; }
yy6:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy10;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy6;
		case 'E':
		case 'e': goto yy17;
		case 'L': goto yy22;
		case 'U':
		case 'u': goto yy23;
		case 'l': goto yy24;
		default: goto yy7;
	}
yy7:
	{ return i; }
yy8:
	yyaccept = 2;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		case 'E':
		case 'e': goto yy25;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy26;
		default: goto yy9;
	}
yy9:
	{ return i; }
yy10:
	yyaccept = 3;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		case 'E':
		case 'e': goto yy27;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy28;
		default: goto yy11;
	}
yy11:
	{ return i; }
yy12:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
yy13:
	switch (yych) {
		case '.': goto yy10;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7': goto yy12;
		case '8':
		case '9': goto yy14;
		case 'E':
		case 'e': goto yy17;
		case 'L': goto yy18;
		case 'U':
		case 'u': goto yy19;
		case 'l': goto yy21;
		default: goto yy5;
	}
yy14:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy10;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy14;
		case 'E':
		case 'e': goto yy17;
		default: goto yy15;
	}
yy15:
	i = marker;
	switch (yyaccept) {
		case 0: goto yy5;
		case 1: goto yy7;
		case 2: goto yy9;
		case 3: goto yy11;
		default: goto yy40;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1': goto yy29;
		default: goto yy15;
	}
yy17:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy31;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy32;
		default: goto yy15;
	}
yy18:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy34;
		case 'U':
		case 'u': goto yy35;
		default: goto yy5;
	}
yy19:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy36;
		case 'l': goto yy37;
		default: goto yy5;
	}
yy20:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy38;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy39;
		default: goto yy15;
	}
yy21:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy35;
		case 'l': goto yy34;
		default: goto yy5;
	}
yy22:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy41;
		case 'U':
		case 'u': goto yy42;
		default: goto yy7;
	}
yy23:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy43;
		case 'l': goto yy44;
		default: goto yy7;
	}
yy24:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy42;
		case 'l': goto yy41;
		default: goto yy7;
	}
yy25:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy45;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy46;
		default: goto yy15;
	}
yy26:
	++i;
	goto yy9;
yy27:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy47;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy48;
		default: goto yy15;
	}
yy28:
	++i;
	goto yy11;
yy29:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1': goto yy29;
		case 'L': goto yy49;
		case 'U':
		case 'u': goto yy50;
		case 'l': goto yy51;
		default: goto yy30;
	}
yy30:
	{ return i; }
yy31:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy32;
		default: goto yy15;
	}
yy32:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy32;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy52;
		default: goto yy33;
	}
yy33:
	{ return i; }
yy34:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy35;
		default: goto yy5;
	}
yy35:
	++i;
	goto yy5;
yy36:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy35;
		default: goto yy5;
	}
yy37:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy35;
		default: goto yy5;
	}
yy38:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00:
		case 'P':
		case 'p': goto yy15;
		default: goto yy54;
	}
yy39:
	yyaccept = 4;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy55;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy39;
		case 'L': goto yy56;
		case 'P':
		case 'p': goto yy57;
		case 'U':
		case 'u': goto yy58;
		case 'l': goto yy59;
		default: goto yy40;
	}
yy40:
	{ return i; }
yy41:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy42;
		default: goto yy7;
	}
yy42:
	++i;
	goto yy7;
yy43:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy42;
		default: goto yy7;
	}
yy44:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy42;
		default: goto yy7;
	}
yy45:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy46;
		default: goto yy15;
	}
yy46:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy46;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy26;
		default: goto yy9;
	}
yy47:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy48;
		default: goto yy15;
	}
yy48:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy48;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy28;
		default: goto yy11;
	}
yy49:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy60;
		case 'U':
		case 'u': goto yy61;
		default: goto yy30;
	}
yy50:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy62;
		case 'l': goto yy63;
		default: goto yy30;
	}
yy51:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy61;
		case 'l': goto yy60;
		default: goto yy30;
	}
yy52:
	++i;
	goto yy33;
yy53:
	++i;
	yych = i < end ? *i : 0;
yy54:
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy53;
		case 'P':
		case 'p': goto yy64;
		default: goto yy15;
	}
yy55:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy15;
		case 'P':
		case 'p': goto yy65;
		default: goto yy54;
	}
yy56:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy66;
		case 'U':
		case 'u': goto yy67;
		default: goto yy40;
	}
yy57:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy68;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy69;
		default: goto yy15;
	}
yy58:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy71;
		case 'l': goto yy72;
		default: goto yy40;
	}
yy59:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy67;
		case 'l': goto yy66;
		default: goto yy40;
	}
yy60:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy61;
		default: goto yy30;
	}
yy61:
	++i;
	goto yy30;
yy62:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy61;
		default: goto yy30;
	}
yy63:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy61;
		default: goto yy30;
	}
yy64:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy73;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy74;
		default: goto yy15;
	}
yy65:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy76;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy77;
		default: goto yy15;
	}
yy66:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy67;
		default: goto yy40;
	}
yy67:
	++i;
	goto yy40;
yy68:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy69;
		default: goto yy15;
	}
yy69:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy69;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy79;
		default: goto yy70;
	}
yy70:
	{ return i; }
yy71:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy67;
		default: goto yy40;
	}
yy72:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy67;
		default: goto yy40;
	}
yy73:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy74;
		default: goto yy15;
	}
yy74:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy74;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy80;
		default: goto yy75;
	}
yy75:
	{ return i; }
yy76:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy77;
		default: goto yy15;
	}
yy77:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy77;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy81;
		default: goto yy78;
	}
yy78:
	{ return i; }
yy79:
	++i;
	goto yy70;
yy80:
	++i;
	goto yy75;
yy81:
	++i;
	goto yy78;
yy82:
	{ return start; }
}

}


//
//	isCStylePunctuation
//

static bool isCStylePunctuation(ImWchar character) {
	static const bool punctuation[128] = {
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false,  true, false, false, false,  true,  true, false,  true,  true,  true,  true,  true,  true,  true,  true,
		false, false, false, false, false, false, false, false, false, false,  true,  true,  true,  true,  true,  true,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false,  true, false,  true,  true, false,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false,  true,  true,  true,  true, false,
	};

	return character < 127 ? punctuation[character] : false;
}


//
//	TextEditor::Language::C
//

const TextEditor::Language* TextEditor::Language::C() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "C";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"break", "case", "continue", "default", "do", "else", "for", "goto", "if", "return", "sizeof",
			"switch", "while", "_Alignas", "_Alignof", "_Atomic", "_Bool", "_Complex", "_Generic",
			"_Imaginary", "_Noreturn", "_Static_assert", "_Thread_local"
		};

		static const char* const declarations[] = {
			"auto", "char", "const", "double", "enum", "extern", "float", "inline", "int", "long", "register",
			"restrict", "short", "signed", "static", "struct", "typedef", "union", "unsigned", "void", "volatile"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }
		for (auto& declaration : declarations) { language.declarations.insert(declaration); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	TextEditor::Language::Cpp
//

const TextEditor::Language* TextEditor::Language::Cpp() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "C++";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"alignas", "alignof", "and", "and_eq", "asm", "atomic_cancel", "atomic_commit", "atomic_noexcept",
			"bitand", "bitor", "break", "case", "catch", "compl", "const_cast", "continue", "default", "delete",
			"do", "dynamic_cast", "else", "explicit", "export", "extern", "false", "for", "goto", "if", "import",
			"new", "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq", "reinterpret_cast", "requires",
			"return", "sizeof", "static_assert", "static_cast", "switch", "synchronized", "this", "thread_local",
			"throw", "true", "try", "while", "xor", "xor_eq"
		};

		static const char* const declarations[] = {
			"auto", "bool", "char", "char8_t", "char16_t", "char32_t", "class", "concept", "const", "constexpr", "decltype",
			"double", "explicit", "export", "extern", "enum", "extern", "float", "friend", "inline", "int", "long",
			"module", "mutable", "namespace", "private", "protected", "public", "register", "restrict", "short",
			"signed", "static", "struct", "template", "typedef", "typeid", "typename", "union", "using", "unsigned",
			"virtual", "void", "volatile", "wchar_t"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }
		for (auto& declaration : declarations) { language.declarations.insert(declaration); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	getCsStyleNumber
//

static TextEditor::Iterator getCsStyleNumber(TextEditor::Iterator start, TextEditor::Iterator end) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	unsigned int yyaccept = 0;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy3;
		case '0': goto yy4;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy6;
		default:
			if (i >= end) goto yy49;
			goto yy1;
	}
yy1:
	++i;
yy2:
	{ return start; }
yy3:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		default: goto yy2;
	}
yy4:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy5;
		case 'B':
		case 'b': goto yy12;
		case 'X':
		case 'x': goto yy15;
		default: goto yy7;
	}
yy5:
	{ return i; }
yy6:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
yy7:
	switch (yych) {
		case '.': goto yy10;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy6;
		case 'L': goto yy13;
		case 'U':
		case 'u': goto yy14;
		case 'l': goto yy16;
		default: goto yy5;
	}
yy8:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy8;
		case 'E':
		case 'e': goto yy17;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy18;
		default: goto yy9;
	}
yy9:
	{ return i; }
yy10:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy19;
		default: goto yy11;
	}
yy11:
	i = marker;
	switch (yyaccept) {
		case 0: goto yy5;
		case 1: goto yy9;
		default: goto yy20;
	}
yy12:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1': goto yy21;
		default: goto yy11;
	}
yy13:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy23;
		case 'U':
		case 'u': goto yy24;
		default: goto yy5;
	}
yy14:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy25;
		case 'l': goto yy26;
		default: goto yy5;
	}
yy15:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy27;
		default: goto yy11;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy24;
		case 'l': goto yy23;
		default: goto yy5;
	}
yy17:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy29;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy30;
		default: goto yy11;
	}
yy18:
	++i;
	goto yy9;
yy19:
	yyaccept = 2;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy19;
		case 'E':
		case 'e': goto yy31;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy32;
		default: goto yy20;
	}
yy20:
	{ return i; }
yy21:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '_': goto yy21;
		case 'L': goto yy33;
		case 'U':
		case 'u': goto yy34;
		case 'l': goto yy35;
		default: goto yy22;
	}
yy22:
	{ return i; }
yy23:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy24;
		default: goto yy5;
	}
yy24:
	++i;
	goto yy5;
yy25:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy24;
		default: goto yy5;
	}
yy26:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy24;
		default: goto yy5;
	}
yy27:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case '_':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy27;
		case 'L': goto yy36;
		case 'U':
		case 'u': goto yy37;
		case 'l': goto yy38;
		default: goto yy28;
	}
yy28:
	{ return i; }
yy29:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy30;
		default: goto yy11;
	}
yy30:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy30;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy18;
		default: goto yy9;
	}
yy31:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy39;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy40;
		default: goto yy11;
	}
yy32:
	++i;
	goto yy20;
yy33:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy41;
		case 'U':
		case 'u': goto yy42;
		default: goto yy22;
	}
yy34:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy43;
		case 'l': goto yy44;
		default: goto yy22;
	}
yy35:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy42;
		case 'l': goto yy41;
		default: goto yy22;
	}
yy36:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy45;
		case 'U':
		case 'u': goto yy46;
		default: goto yy28;
	}
yy37:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy47;
		case 'l': goto yy48;
		default: goto yy28;
	}
yy38:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy46;
		case 'l': goto yy45;
		default: goto yy28;
	}
yy39:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy40;
		default: goto yy11;
	}
yy40:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy40;
		case 'F':
		case 'L':
		case 'f':
		case 'l': goto yy32;
		default: goto yy20;
	}
yy41:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy42;
		default: goto yy22;
	}
yy42:
	++i;
	goto yy22;
yy43:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy42;
		default: goto yy22;
	}
yy44:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy42;
		default: goto yy22;
	}
yy45:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'U':
		case 'u': goto yy46;
		default: goto yy28;
	}
yy46:
	++i;
	goto yy28;
yy47:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'L': goto yy46;
		default: goto yy28;
	}
yy48:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy46;
		default: goto yy28;
	}
yy49:
	{ return start; }
}

}


//
//	TextEditor::Language::Cs
//

const TextEditor::Language* TextEditor::Language::Cs() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "C#";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"abstract", "as", "base", "bool", "break", "byte", "case", "catch", "char", "checked", "class", "const", "continue",
			"decimal", "default", "delegate", "do", "double", "else", "enum", "event", "explicit", "extern", "false", "finally",
			"fixed", "float", "for", "foreach", "goto", "if", "implicit", "in", "in (generic modifier)", "int", "interface",
			"internal", "is", "lock", "long", "namespace", "new", "null", "object", "operator", "out", "override", "params",
			"private", "protected", "public", "readonly", "ref", "return", "sbyte", "sealed", "short", "sizeof", "stackalloc",
			"static", "string", "struct", "switch", "this", "throw", "true", "try", "typeof", "uint", "ulong", "unchecked",
			"unsafe", "ushort", "using", "using static", "void", "volatile", "while"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCsStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	TextEditor::Language::AngelScript
//

const TextEditor::Language* TextEditor::Language::AngelScript() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "AngelScript";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"and", "abstract", "auto", "bool", "break", "case", "cast", "class", "const", "continue", "default",
			"do", "double", "else", "enum", "false", "final", "float", "for", "from", "funcdef", "function", "get",
			"if", "import", "in", "inout", "int", "interface", "int8", "int16", "int32", "int64", "is", "mixin",
			"namespace", "not", "null", "or", "out", "override", "private", "protected", "return", "set", "shared",
			"super", "switch", "this ", "true", "typedef", "uint", "uint8", "uint16", "uint32", "uint64", "void",
			"while", "xor"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	getLuaStyleNumber
//

static TextEditor::Iterator getLuaStyleNumber(TextEditor::Iterator start, TextEditor::Iterator end) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	unsigned int yyaccept = 0;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy4;
		case '0': goto yy5;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy6;
		default:
			if (i >= end) goto yy1;
			goto yy2;
	}
yy1:
	{ return i; }
yy2:
	++i;
yy3:
	{ return start; }
yy4:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		default: goto yy3;
	}
yy5:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy1;
		case 'X':
		case 'x': goto yy10;
		default: goto yy7;
	}
yy6:
	++i;
	yych = i < end ? *i : 0;
yy7:
	switch (yych) {
		case '.': goto yy8;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy6;
		default: goto yy1;
	}
yy8:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		case 'E':
		case 'e': goto yy12;
		default: goto yy9;
	}
yy9:
	{ return i; }
yy10:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy13;
		default: goto yy11;
	}
yy11:
	i = marker;
	if (yyaccept == 0) goto yy1;
	else goto yy9;
yy12:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy15;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy16;
		default: goto yy11;
	}
yy13:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy17;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy13;
		case 'P':
		case 'p': goto yy18;
		default: goto yy14;
	}
yy14:
	{ return i; }
yy15:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy16;
		default: goto yy11;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy16;
		default: goto yy9;
	}
yy17:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy17;
		case 'P':
		case 'p': goto yy18;
		default: goto yy14;
	}
yy18:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy14;
		case '+':
		case '-': goto yy19;
		default: goto yy20;
	}
yy19:
	++i;
	yych = i < end ? *i : 0;
yy20:
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy19;
		default: goto yy14;
	}
}

}


//
//	isLuaStylePunctuation
//	[]{}!%#^&*()-+=~|<>?:/;,.
//

static bool isLuaStylePunctuation(ImWchar character) {
	static const bool punctuation[128] = {
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false,  true, false,  true, false,  true,  true, false,  true,  true,  true,  true,  true,  true,  true,  true,
		false, false, false, false, false, false, false, false, false, false,  true,  true,  true,  true,  true,  true,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false,  true, false,  true,  true, false,
		false, false, false, false, false, false, false, false, false, false, false, false, false, false, false, false,
		false, false, false, false, false, false, false, false, false, false, false,  true,  true,  true,  true, false,
	};

	return character < 127 ? punctuation[character] : false;
}


//
//	luaCommentLevelStart
//

static TextEditor::Iterator luaCommentLevelStart(TextEditor::Iterator start, TextEditor::Iterator end, size_t& level) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '-': goto yy24;
		default:
			if (i >= end) goto yy29;
			goto yy22;
	}
yy22:
	++i;
yy23:
	{ return start; }
yy24:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '-': goto yy25;
		default: goto yy23;
	}
yy25:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '[': goto yy27;
		default: goto yy26;
	}
yy26:
	i = marker;
	goto yy23;
yy27:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy27;
		case '[': goto yy28;
		default: goto yy26;
	}
yy28:
	++i;
	{
		level = i - start - 4;
		return i;
	}
yy29:
	{ return start; }
}

}


//
//	luaCommentLevelEnd
//

static TextEditor::Iterator luaCommentLevelEnd(TextEditor::Iterator start, TextEditor::Iterator end, size_t& level) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ']': goto yy33;
		default:
			if (i >= end) goto yy37;
			goto yy31;
	}
yy31:
	++i;
yy32:
	{ return start; }
yy33:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy34;
		case ']': goto yy36;
		default: goto yy32;
	}
yy34:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy34;
		case ']': goto yy36;
		default: goto yy35;
	}
yy35:
	i = marker;
	goto yy32;
yy36:
	++i;
	{
		level = i - start - 2;
		return i;
	}
yy37:
	{ return start; }
}

}


//
//	luaStringLevelStart
//

static TextEditor::Iterator luaStringLevelStart(TextEditor::Iterator start, TextEditor::Iterator end, size_t& level) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '[': goto yy41;
		default:
			if (i >= end) goto yy45;
			goto yy39;
	}
yy39:
	++i;
yy40:
	{ return start; }
yy41:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy42;
		case '[': goto yy44;
		default: goto yy40;
	}
yy42:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy42;
		case '[': goto yy44;
		default: goto yy43;
	}
yy43:
	i = marker;
	goto yy40;
yy44:
	++i;
	{
		level = i - start - 2;
		return i;
	}
yy45:
	{ return start; }
}

}


//
//	luaStringLevelEnd
//

static TextEditor::Iterator luaStringLevelEnd(TextEditor::Iterator start, TextEditor::Iterator end, size_t& level) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ']': goto yy49;
		default:
			if (i >= end) goto yy53;
			goto yy47;
	}
yy47:
	++i;
yy48:
	{ return start; }
yy49:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy50;
		case ']': goto yy52;
		default: goto yy48;
	}
yy50:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '=': goto yy50;
		case ']': goto yy52;
		default: goto yy51;
	}
yy51:
	i = marker;
	goto yy48;
yy52:
	++i;
	{
		level = i - start - 2;
		return i;
	}
yy53:
	{ return start; }
}

}


//
//	TextEditor::Language::Lua
//

const TextEditor::Language* TextEditor::Language::Lua() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "Lua";
		language.singleLineComment = "--";
		language.commentLevelStart = luaCommentLevelStart;
		language.commentLevelEnd = luaCommentLevelEnd;
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringLevelStart = luaStringLevelStart;
		language.stringLevelEnd = luaStringLevelEnd;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"and", "break", "do", "else", "elseif", "end", "false", "for", "function", "goto", "if", "in", "local", "nil",
			"not", "or", "repeat", "return", "then", "true", "until", "while"
		};

		static const char* const identifiers[] = {
			"_G", "_VERSION", "abs", "acos", "asin", "assert", "atan", "atan2", "byte", "ceil", "char", "clock", "close",
			"collectgarbage", "concat", "coroutine", "cos", "cosh", "cpath", "create", "date", "debug", "deg", "difftime",
			"dofile", "dump", "error", "execute", "exit", "exp", "find", "floor", "flush", "fmod", "format", "frexp", "getenv",
			"getfenv", "gethook", "getinfo", "getlocal", "getmetatable", "getregistry", "getupvalue", "gmatch", "gsub", "huge",
			"input", "insert", "io", "ipairs", "ldexp", "len", "lines", "load", "loaded", "loaders", "loadfile", "loadlib",
			"loadstring", "log", "log10", "lower", "match", "math", "max", "maxn", "min", "modf", "module", "next", "open",
			"os", "output", "package", "pairs", "path", "pcall", "pi", "popen", "pow", "preload", "print", "rad", "random",
			"randomseed", "rawequal", "rawget", "rawset", "read", "remove", "rename", "rep", "require", "resume", "reverse",
			"running", "seeall", "seek", "select", "setfenv", "sethook", "setlocal", "setlocale", "setmetatable", "setupvalue",
			"setvbuf", "sin", "sinh", "sort", "sqrt", "status", "stderr", "stdin", "stdout", "string", "sub", "table", "tan",
			"tanh", "time", "tmpfile", "tmpname", "tonumber", "tostring", "traceback", "type", "unpack", "upper", "wrap",
			"write", "xpcall", "yield"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }
		for (auto& identifier : identifiers) { language.identifiers.insert(identifier); }

		language.isPunctuation = isLuaStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getLuaStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	getPythonStyleNumber
//

static TextEditor::Iterator getPythonStyleNumber(TextEditor::Iterator start, TextEditor::Iterator end) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0': goto yy2;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy4;
		default:
			if (i >= end) goto yy18;
			goto yy1;
	}
yy1:
	++i;
	{ return start; }
yy2:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x00: goto yy3;
		case 'B':
		case 'b': goto yy9;
		case 'O':
		case 'o': goto yy11;
		case 'X':
		case 'x': goto yy12;
		default: goto yy5;
	}
yy3:
	{
		return i;
	}
yy4:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
yy5:
	switch (yych) {
		case '+':
		case '-':
		case 'E':
		case 'e': goto yy6;
		case '.': goto yy8;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy4;
		case 'J':
		case 'j': goto yy10;
		default: goto yy3;
	}
yy6:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy13;
		default: goto yy7;
	}
yy7:
	i = marker;
	goto yy3;
yy8:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy14;
		default: goto yy7;
	}
yy9:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '_': goto yy15;
		default: goto yy7;
	}
yy10:
	++i;
	goto yy3;
yy11:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '_': goto yy16;
		default: goto yy7;
	}
yy12:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case '_':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy17;
		default: goto yy7;
	}
yy13:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy13;
		case 'J':
		case 'j': goto yy10;
		default: goto yy3;
	}
yy14:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-':
		case 'E':
		case 'e': goto yy6;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case '_': goto yy14;
		case 'J':
		case 'j': goto yy10;
		default: goto yy3;
	}
yy15:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '_': goto yy15;
		default: goto yy3;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '_': goto yy16;
		default: goto yy3;
	}
yy17:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9':
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case '_':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f': goto yy17;
		default: goto yy3;
	}
yy18:
	{ return start; }
}

}


//
//	TextEditor::Language::Python
//

const TextEditor::Language* TextEditor::Language::Python() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "Python";
		language.singleLineComment = "#";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.otherStringStart = "\"\"\"";
		language.otherStringEnd = "\"\"\"";
		language.otherStringAltStart = "'''";
		language.otherStringAltEnd = "'''";
		language.stringEscape = '\\';
		language.indentationForBlocks = true;

		static const char* const keywords[] = {
			"False", "await", "else", "import", "pass", "None", "break", "except", "in", "raise", "True",
			"class", "finally", "is", "return", "and", "continue", "for", "lambda", "try", "as", "def",
			"from", "nonlocal", "while", "assert", "del", "global", "not", "with", "async", "elif",
			"if", "or", "yield"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getPythonStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	TextEditor::Language::Glsl
//

const TextEditor::Language* TextEditor::Language::Glsl() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "GLSL";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		// source: https://registry.khronos.org/OpenGL/specs/gl/GLSLangSpec.4.60.html
		static const char* const keywords[] = {
			"atomic_uint", "attribute", "bool", "break", "buffer", "bvec2", "bvec3", "bvec4", "case", "centroid",
			"coherent", "const", "continue", "default", "discard", "dmat2", "dmat2x2", "dmat2x3", "dmat2x4", "dmat3",
			"dmat3x2", "dmat3x3", "dmat3x4", "dmat4", "dmat4x2", "dmat4x3", "dmat4x4", "do", "double", "dvec2", "dvec3",
			"dvec4", "else", "false", "flat", "float", "for", "highp", "if", "iimage1D", "iimage1DArray", "iimage2D",
			"iimage2DArray", "iimage2DMS", "iimage2DMSArray", "iimage2DRect", "iimage3D", "iimageBuffer", "iimageCube",
			"iimageCubeArray", "image1D", "image1DArray", "image2D", "image2DArray", "image2DMS", "image2DMSArray",
			"image2DRect", "image3D", "imageBuffer", "imageCube", "imageCubeArray", "in", "inout", "int", "invariant",
			"isampler1D", "isampler1DArray", "isampler2D", "isampler2DArray", "isampler2DMS", "isampler2DMSArray",
			"isampler2DRect", "isampler3D", "isamplerBuffer", "isamplerCube", "isamplerCubeArray", "ivec2", "ivec3",
			"ivec4", "layout", "lowp", "mat2", "mat2x2", "mat2x3", "mat2x4", "mat3", "mat3x2", "mat3x3", "mat3x4",
			"mat4", "mat4x2", "mat4x3", "mat4x4", "mediump", "noperspective", "out", "patch", "precise", "precision",
			"readonly", "restrict", "return", "sample", "sampler1D", "sampler1DArray", "sampler1DArrayShadow",
			"sampler1DShadow", "sampler2D", "sampler2DArray", "sampler2DArrayShadow", "sampler2DMS", "sampler2DMSArray",
			"sampler2DRect", "sampler2DRectShadow", "sampler2DShadow", "sampler3D", "samplerBuffer", "samplerCube",
			"samplerCubeArray", "samplerCubeArrayShadow", "samplerCubeShadow", "shared", "smooth", "struct", "subroutine",
			"switch", "true", "uimage1D", "uimage1DArray", "uimage2D", "uimage2DArray", "uimage2DMS", "uimage2DMSArray",
			"uimage2DRect", "uimage3D", "uimageBuffer", "uimageCube", "uimageCubeArray", "uint", "uniform", "usampler1D",
			"usampler1DArray", "usampler2D", "usampler2DArray", "usampler2DMS", "usampler2DMSArray", "usampler2DRect",
			"usampler3D", "usamplerBuffer", "usamplerCube", "usamplerCubeArray", "uvec2", "uvec3", "uvec4", "varying",
			"vec2", "vec3", "vec4", "void", "volatile", "while", "writeonly"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}


//
//	TextEditor::Language::Hlsl
//

const TextEditor::Language* TextEditor::Language::Hlsl() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "HLSL";
		language.preprocess = '#';
		language.singleLineComment = "//";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"AppendStructuredBuffer", "asm", "asm_fragment", "BlendState", "bool", "break", "Buffer",
			"ByteAddressBuffer", "case", "cbuffer", "centroid", "class", "column_major", "compile",
			"compile_fragment", "CompileShader", "const", "continue", "ComputeShader", "ConsumeStructuredBuffer",
			"default", "DepthStencilState", "DepthStencilView", "discard", "do", "double", "DomainShader", "dword",
			"else", "export", "extern", "false", "float", "for", "fxgroup", "GeometryShader", "groupshared", "half",
			"Hullshader", "if", "in", "inline", "inout", "InputPatch", "int", "interface", "line", "lineadj",
			"linear", "LineStream", "matrix", "min16float", "min10float", "min16int", "min12int", "min16uint",
			"namespace", "nointerpolation", "noperspective", "NULL", "out", "OutputPatch", "packoffset",
			"pass", "pixelfragment", "PixelShader", "point", "PointStream", "precise", "RasterizerState",
			"RenderTargetView", "return", "register", "row_major", "RWBuffer", "RWByteAddressBuffer",
			"RWStructuredBuffer", "RWTexture1D", "RWTexture1DArray", "RWTexture2D", "RWTexture2DArray",
			"RWTexture3D", "sample", "sampler", "SamplerState", "SamplerComparisonState", "shared",
			"snorm", "stateblock", "stateblock_state", "static", "string", "struct", "switch", "StructuredBuffer",
			"tbuffer", "technique", "technique10", "technique11", "texture", "Texture1D", "Texture1DArray",
			"Texture2D", "Texture2DArray", "Texture2DMS", "Texture2DMSArray", "Texture3D", "TextureCube",
			"TextureCubeArray", "true", "typedef", "triangle", "triangleadj", "TriangleStream", "uint",
			"uniform", "unorm", "unsigned", "vector", "vertexfragment", "VertexShader", "void", "volatile", "while",
			"bool1", "bool2", "bool3", "bool4", "double1", "double2", "double3", "double4", "float1", "float2",
			"float3", "float4", "int1", "int2", "int3", "int4", "in", "out", "inout", "uint1", "uint2", "uint3",
			"uint4", "dword1", "dword2", "dword3", "dword4", "half1", "half2", "half3", "half4", "float1x1",
			"float2x1", "float3x1", "float4x1", "float1x2", "float2x2", "float3x2", "float4x2",
			"float1x3", "float2x3", "float3x3", "float4x3", "float1x4", "float2x4", "float3x4", "float4x4",
			"half1x1", "half2x1", "half3x1", "half4x1", "half1x2", "half2x2", "half3x2", "half4x2",
			"half1x3", "half2x3", "half3x3", "half4x3", "half1x4", "half2x4", "half3x4", "half4x4",
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}
//	tokenizeJson
//

static TextEditor::Iterator tokenizeJson(TextEditor::Iterator start, TextEditor::Iterator end, TextEditor::Color& color) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	unsigned int yyaccept = 0;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '"': goto yy3;
		case ',':
		case '[':
		case ']':
		case '{':
		case '}': goto yy4;
		case '-': goto yy5;
		case '0': goto yy6;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		case 'f': goto yy9;
		case 'n': goto yy10;
		case 't': goto yy11;
		default:
			if (i >= end) goto yy31;
			goto yy1;
	}
yy1:
	++i;
yy2:
	{ return start; }
yy3:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	if (yych <= 0x00) {
		if (i >= end) goto yy2;
		goto yy12;
	}
	goto yy13;
yy4:
	++i;
	{
		color = TextEditor::Color::punctuation;
		return i;
	}
yy5:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0': goto yy6;
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		default: goto yy2;
	}
yy6:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy16;
		case 'E':
		case 'e': goto yy18;
		default: goto yy7;
	}
yy7:
	{
		color = TextEditor::Color::number;
		return i;
	}
yy8:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy16;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy8;
		case 'E':
		case 'e': goto yy18;
		default: goto yy7;
	}
yy9:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'a': goto yy19;
		default: goto yy2;
	}
yy10:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'u': goto yy20;
		default: goto yy2;
	}
yy11:
	yyaccept = 0;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'r': goto yy21;
		default: goto yy2;
	}
yy12:
	++i;
	yych = i < end ? *i : 0;
yy13:
	switch (yych) {
		case '"': goto yy14;
		default:
			if (i >= end) goto yy17;
			goto yy12;
	}
yy14:
	yyaccept = 2;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x08:
		case '\t':
		case '\v':
		case '\f':
		case ' ': goto yy22;
		case ':': goto yy23;
		default: goto yy15;
	}
yy15:
	{
		color = TextEditor::Color::string;
		return i;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy24;
		default: goto yy17;
	}
yy17:
	i = marker;
	switch (yyaccept) {
		case 0: goto yy2;
		case 1: goto yy7;
		default: goto yy15;
	}
yy18:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '+':
		case '-': goto yy25;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy26;
		default: goto yy17;
	}
yy19:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy27;
		default: goto yy17;
	}
yy20:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy28;
		default: goto yy17;
	}
yy21:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'u': goto yy29;
		default: goto yy17;
	}
yy22:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 0x08:
		case '\t':
		case '\v':
		case '\f':
		case ' ': goto yy22;
		case ':': goto yy23;
		default: goto yy17;
	}
yy23:
	++i;
	{
		color = TextEditor::Color::identifier;
		return i;
	}
yy24:
	yyaccept = 1;
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy24;
		case 'E':
		case 'e': goto yy18;
		default: goto yy7;
	}
yy25:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy26;
		default: goto yy17;
	}
yy26:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy26;
		default: goto yy7;
	}
yy27:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 's': goto yy29;
		default: goto yy17;
	}
yy28:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'l': goto yy30;
		default: goto yy17;
	}
yy29:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'e': goto yy30;
		default: goto yy17;
	}
yy30:
	++i;
	{
		color = TextEditor::Color::knownIdentifier;
		return i;
	}
yy31:
	{ return start; }
}

}


//
//	TextEditor::Language::Json
//

const TextEditor::Language* TextEditor::Language::Json() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "JSON";

		static const char* const keywords[] = {
			"false", "null", "true"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.customTokenizer = tokenizeJson;
		initialized = true;
	}

	return &language;
}


//
//	tokenizeMarkdown
//

static TextEditor::Iterator tokenizeMarkdown(TextEditor::Iterator start, TextEditor::Iterator end, TextEditor::Color& color) {
	TextEditor::Iterator i = start;
	TextEditor::Iterator marker;


{
	ImWchar yych;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '!': goto yy3;
		case '#': goto yy4;
		case '*': goto yy6;
		case '+': goto yy7;
		case '-': goto yy8;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy10;
		case ':':
		case '|': goto yy11;
		case '<': goto yy12;
		case '[': goto yy13;
		case '`': goto yy14;
		case '~': goto yy15;
		default:
			if (i >= end) goto yy37;
			goto yy1;
	}
yy1:
	++i;
yy2:
	{ return start; }
yy3:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '[': goto yy16;
		default: goto yy2;
	}
yy4:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '\n': goto yy5;
		default:
			if (i >= end) goto yy5;
			goto yy4;
	}
yy5:
	{
		color = TextEditor::Color::declaration;
		return i;
	}
yy6:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ' ': goto yy11;
		case '*': goto yy20;
		default:
			if (i >= end) goto yy2;
			goto yy18;
	}
yy7:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ' ': goto yy11;
		default: goto yy2;
	}
yy8:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ' ': goto yy11;
		default: goto yy9;
	}
yy9:
	{
		color = TextEditor::Color::punctuation;
		return i;
	}
yy10:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy21;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy22;
		default: goto yy2;
	}
yy11:
	++i;
	goto yy9;
yy12:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z': goto yy23;
		default: goto yy2;
	}
yy13:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	if (yych <= 0x00) {
		if (i >= end) goto yy2;
		goto yy16;
	}
	goto yy17;
yy14:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	if (yych <= 0x00) {
		if (i >= end) goto yy2;
		goto yy25;
	}
	goto yy26;
yy15:
	++i;
	marker = i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '~': goto yy28;
		default: goto yy2;
	}
yy16:
	++i;
	yych = i < end ? *i : 0;
yy17:
	switch (yych) {
		case ']': goto yy24;
		default:
			if (i >= end) goto yy19;
			goto yy16;
	}
yy18:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ' ': goto yy19;
		case '*': goto yy29;
		default:
			if (i >= end) goto yy19;
			goto yy18;
	}
yy19:
	i = marker;
	goto yy2;
yy20:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '*': goto yy19;
		default:
			if (i >= end) goto yy19;
			goto yy30;
	}
yy21:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ' ': goto yy11;
		default: goto yy19;
	}
yy22:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '.': goto yy21;
		case '0':
		case '1':
		case '2':
		case '3':
		case '4':
		case '5':
		case '6':
		case '7':
		case '8':
		case '9': goto yy22;
		default: goto yy19;
	}
yy23:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '>': goto yy31;
		case 'A':
		case 'B':
		case 'C':
		case 'D':
		case 'E':
		case 'F':
		case 'G':
		case 'H':
		case 'I':
		case 'J':
		case 'K':
		case 'L':
		case 'M':
		case 'N':
		case 'O':
		case 'P':
		case 'Q':
		case 'R':
		case 'S':
		case 'T':
		case 'U':
		case 'V':
		case 'W':
		case 'X':
		case 'Y':
		case 'Z':
		case 'a':
		case 'b':
		case 'c':
		case 'd':
		case 'e':
		case 'f':
		case 'g':
		case 'h':
		case 'i':
		case 'j':
		case 'k':
		case 'l':
		case 'm':
		case 'n':
		case 'o':
		case 'p':
		case 'q':
		case 'r':
		case 's':
		case 't':
		case 'u':
		case 'v':
		case 'w':
		case 'x':
		case 'y':
		case 'z': goto yy23;
		default: goto yy19;
	}
yy24:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '(': goto yy32;
		default: goto yy19;
	}
yy25:
	++i;
	yych = i < end ? *i : 0;
yy26:
	switch (yych) {
		case '`': goto yy27;
		default:
			if (i >= end) goto yy19;
			goto yy25;
	}
yy27:
	++i;
	{
		color = TextEditor::Color::string;
		return i;
	}
yy28:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '~': goto yy19;
		default:
			if (i >= end) goto yy19;
			goto yy33;
	}
yy29:
	++i;
	{
		color = TextEditor::Color::number;
		return i;
	}
yy30:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '*': goto yy34;
		default:
			if (i >= end) goto yy19;
			goto yy30;
	}
yy31:
	++i;
	{
		color = TextEditor::Color::keyword;
		return i;
	}
yy32:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case ')': goto yy35;
		default:
			if (i >= end) goto yy19;
			goto yy32;
	}
yy33:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '~': goto yy36;
		default:
			if (i >= end) goto yy19;
			goto yy33;
	}
yy34:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '*': goto yy29;
		default: goto yy19;
	}
yy35:
	++i;
	{
		color = TextEditor::Color::identifier;
		return i;
	}
yy36:
	++i;
	yych = i < end ? *i : 0;
	switch (yych) {
		case '~': goto yy29;
		default: goto yy19;
	}
yy37:
	{ return start; }
}

}


//
//	TextEditor::Language::Markdown
//

const TextEditor::Language* TextEditor::Language::Markdown() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "Markdown";
		language.commentStart = "<!--";
		language.commentEnd = "-->";

		language.customTokenizer = tokenizeMarkdown;
		initialized = true;
	}

	return &language;
}


//
//	TextEditor::Language::Sql
//

const TextEditor::Language* TextEditor::Language::Sql() {
	static bool initialized = false;
	static TextEditor::Language language;

	if (!initialized) {
		language.name = "SQL";
		language.caseSensitive = false;
		language.singleLineComment = "--";
		language.commentStart = "/*";
		language.commentEnd = "*/";
		language.hasSingleQuotedStrings = true;
		language.hasDoubleQuotedStrings = true;
		language.stringEscape = '\\';

		static const char* const keywords[] = {
			"abs", "absent", "acos", "all", "allocate", "alter", "and", "any", "any_value", "are", "array", "array_agg",
			"array_max_cardinality", "as", "asensitive", "asin", "asymmetric", "at", "atan", "atomic", "authorization",
			"avg", "begin", "begin_frame", "begin_partition", "between", "bigint", "binary", "blob", "boolean", "both",
			"btrim", "by", "call", "called", "cardinality", "cascaded", "case", "cast", "ceil", "ceiling", "char",
			"character", "character_length", "char_length", "check", "classifier", "clob", "close", "coalesce", "collate",
			"collect", "column", "commit", "condition", "connect", "constraint", "contains", "convert", "copy", "corr",
			"corresponding", "cos", "cosh", "count", "covar_pop", "covar_samp", "create", "cross", "cube", "cume_dist",
			"current", "current_catalog", "current_date", "current_default_transform_group", "current_path", "current_role",
			"current_row", "current_schema", "current_time", "current_timestamp", "current_transform_group_for_type",
			"current_user", "cursor", "cycle", "date", "day", "deallocate", "dec", "decfloat", "decimal", "declare",
			"default", "define", "delete", "dense_rank", "deref", "describe", "deterministic", "disconnect", "distinct",
			"double", "drop", "dynamic", "each", "element", "else", "empty", "end", "end-exec", "end_frame", "end_partition",
			"equals", "escape", "every", "except", "exec", "execute", "exists", "exp", "external", "extract", "false", "fetch",
			"filter", "first_value", "float", "floor", "for", "foreign", "frame_row", "free", "from", "full", "function",
			"fusion", "get", "global", "grant", "greatest", "group", "grouping", "groups", "having", "hold", "hour",
			"identity", "in", "indicator", "initial", "inner", "inout", "insensitive", "insert", "int", "integer",
			"intersect", "intersection", "interval", "into", "is", "join", "json", "json_array", "json_arrayagg",
			"json_exists", "json_object", "json_objectagg", "json_query", "json_scalar", "json_serialize", "json_table",
			"json_table_primitive", "json_value", "lag", "language", "large", "last_value", "lateral", "lead", "leading",
			"least", "left", "like", "like_regex", "limit", "listagg", "ln", "local", "localtime", "localtimestamp", "log", "log10",
			"lower", "lpad", "ltrim", "match", "matches", "match_number", "match_recognize", "max", "member", "merge", "method",
			"min", "minute", "mod", "modifies", "module", "month", "multiset", "national", "natural", "nchar", "nclob", "new",
			"no", "none", "normalize", "not", "nth_value", "ntile", "null", "nullif", "numeric", "occurrences_regex",
			"octet_length", "of", "offset", "old", "omit", "on", "one", "only", "open", "or", "order", "out", "outer", "over",
			"overlaps", "overlay", "parameter", "partition", "pattern", "per", "percent", "percentile_cont", "percentile_disc",
			"percent_rank", "period", "portion", "position", "position_regex", "power", "precedes", "precision", "prepare", "primary",
			"procedure", "ptf", "range", "rank", "reads", "real", "recursive", "ref", "references", "referencing", "regr_avgx",
			"regr_avgy", "regr_count", "regr_intercept", "regr_r2", "regr_slope", "regr_sxx", "regr_sxy", "regr_syy", "release",
			"result", "return", "returns", "revoke", "right", "rollback", "rollup", "row", "rows", "row_number", "rpad", "running",
			"savepoint", "scope", "scroll", "search", "second", "seek", "select", "sensitive", "session_user", "set", "show", "similar",
			"sin", "sinh", "skip", "smallint", "some", "specific", "specifictype", "sql", "sqlexception", "sqlstate", "sqlwarning", "sqrt",
			"start", "static", "stddev_pop", "stddev_samp", "submultiset", "subset", "substring", "substring_regex", "succeeds",
			"sum", "symmetric", "system", "system_time", "system_user", "table", "tablesample", "tan", "tanh", "then", "time",
			"timestamp", "timezone_hour", "timezone_minute", "to", "trailing", "translate", "translate_regex", "translation",
			"treat", "trigger", "trim", "trim_array", "true", "truncate", "uescape", "union", "unique", "unknown", "unnest",
			"update", "upper", "user", "using", "value", "values", "value_of", "varbinary", "varchar", "varying", "var_pop",
			"var_samp", "versioning", "when", "whenever", "where", "width_bucket", "window", "with", "within", "without", "year"
		};

		for (auto& keyword : keywords) { language.keywords.insert(keyword); }

		language.isPunctuation = isCStylePunctuation;
		language.getIdentifier = getCStyleIdentifier;
		language.getNumber = getCStyleNumber;
		initialized = true;
	}

	return &language;
}