Update mruby api.

Signed-off-by: Syed Daanish <me@syedm.dev>

.clangd

@@ -2,6 +2,7 @@ CompileFlags:
   Add: [
     -I/home/syed/main/crib/include,
     -I/home/syed/main/crib/libs,
+    -I/home/syed/main/crib/libs/mruby/include,
     -std=c++23
   ]
   Remove: []

.gitmodules

@@ -2,7 +2,7 @@
 	path = libs/libgrapheme
 	url = git://git.suckless.org/libgrapheme
   ignore = dirty
-[submodule "libs/utfcpp"]
+[submodule "libs/mruby"]
-	path = libs/utfcpp
+	path = libs/mruby
-  url = https://github.com/nemtrif/utfcpp.git
+  url = https://github.com/mruby/mruby.git
   ignore = dirty

Makefile

@@ -9,27 +9,30 @@ TARGET_RELEASE := $(BIN_DIR)/crib
 PCH_DEBUG := $(OBJ_DIR)/debug/pch.h.gch
 PCH_RELEASE := $(OBJ_DIR)/release/pch.h.gch
 
+GENERATED_HEADER := $(INCLUDE_DIR)/scripting/ruby_compiled.h
+
 CCACHE := ccache
 CXX := $(CCACHE) clang++
+CC := $(CCACHE) musl-clang
 
 CFLAGS_DEBUG :=\
-	-std=c++23 -Wall -Wextra -Wno-c23-extensions \
+	-std=c++20 -Wall -Wextra \
-	-O0 -fno-inline -gsplit-dwarf\
+	-O0 -fno-inline -gsplit-dwarf \
-	-g -fno-omit-frame-pointer\
+	-g -fno-omit-frame-pointer \
 	-Wno-unused-command-line-argument \
-	-I./include -I./libs
+	-I./include -I./libs -I/home/syed/main/crib/libs/mruby/include
+# -fsanitize=address \
 
 CFLAGS_RELEASE :=\
-	-std=c++23 -O3 -march=native \
+	-static --target=x86_64-linux-musl \
-  -fno-rtti -fstrict-aliasing \
+	-std=c++20 -O3 -march=x86-64 -mtune=generic \
+  -fno-rtti \
 	-ffast-math -flto=thin \
-	-fvisibility=hidden -fuse-ld=lld \
+	-fvisibility=hidden \
 	-fomit-frame-pointer -DNDEBUG -s \
 	-mllvm -vectorize-loops \
-	-fno-unwind-tables -fno-asynchronous-unwind-tables\
 	-Wno-unused-command-line-argument \
-	-Wno-c23-extensions \
+	-I./include -I./libs -I/home/syed/main/crib/libs/mruby/include
-	-I./include -I./libs
 
 PCH_CFLAGS_DEBUG := $(CFLAGS_DEBUG) -x c++-header
 PCH_CFLAGS_RELEASE := $(CFLAGS_RELEASE) -x c++-header
@@ -39,9 +42,13 @@ UNICODE_SRC := $(wildcard libs/unicode_width/*.c)
 UNICODE_OBJ_DEBUG := $(patsubst libs/unicode_width/%.c,$(OBJ_DIR)/debug/unicode_width/%.o,$(UNICODE_SRC))
 UNICODE_OBJ_RELEASE := $(patsubst libs/unicode_width/%.c,$(OBJ_DIR)/release/unicode_width/%.o,$(UNICODE_SRC))
 
-LIBS := \
+LIBS_RELEASE := \
-	libs/libgrapheme/libgrapheme.a \
+	libs/libgrapheme/libgrapheme.a ./libs/mruby/build/host/lib/libmruby.a \
-	-Wl,-Bstatic -lpcre2-8 -lmruby -Wl,-Bdynamic -lmagic
+	-Wl,-Bstatic,--gc-sections -lpcre2-8
+
+LIBS_DEBUG := \
+	libs/libgrapheme/libgrapheme.a ./libs/mruby/build/host/lib/libmruby.a \
+	-Wl,-Bdynamic -lpcre2-8
 
 SRC := $(wildcard $(SRC_DIR)/**/*.cc) $(wildcard $(SRC_DIR)/*.cc)
 OBJ_DEBUG := $(patsubst $(SRC_DIR)/%.cc,$(OBJ_DIR)/debug/%.o,$(SRC))
@@ -58,6 +65,9 @@ test: $(TARGET_DEBUG)
 
 release: $(TARGET_RELEASE)
 
+$(GENERATED_HEADER): $(INCLUDE_DIR)/syntax/tokens.def $(INCLUDE_DIR)/scripting/libcrib.rb src/ruby_compile.sh
+	src/ruby_compile.sh
+
 $(PCH_DEBUG): $(INCLUDE_DIR)/pch.h
 	mkdir -p $(dir $@)
 	$(CXX) $(PCH_CFLAGS_DEBUG) -o $@ $<
@@ -68,27 +78,27 @@ $(PCH_RELEASE): $(INCLUDE_DIR)/pch.h
 
 $(TARGET_DEBUG): $(PCH_DEBUG) $(OBJ_DEBUG) $(UNICODE_OBJ_DEBUG)
 	mkdir -p $(BIN_DIR)
-	$(CXX) $(CFLAGS_DEBUG) -o $@ $(OBJ_DEBUG) $(UNICODE_OBJ_DEBUG) $(LIBS)
+	$(CXX) $(CFLAGS_DEBUG) -o $@ $(OBJ_DEBUG) $(UNICODE_OBJ_DEBUG) $(LIBS_DEBUG)
 
 $(TARGET_RELEASE): $(PCH_RELEASE) $(OBJ_RELEASE) $(UNICODE_OBJ_RELEASE)
 	mkdir -p $(BIN_DIR)
-	$(CXX) $(CFLAGS_RELEASE) -o $@ $(OBJ_RELEASE) $(UNICODE_OBJ_RELEASE) $(LIBS)
+	$(CXX) $(CFLAGS_RELEASE) -o $@ $(OBJ_RELEASE) $(UNICODE_OBJ_RELEASE) $(LIBS_RELEASE)
 
-$(OBJ_DIR)/debug/%.o: $(SRC_DIR)/%.cc $(PCH_DEBUG)
+$(OBJ_DIR)/debug/%.o: $(SRC_DIR)/%.cc $(PCH_DEBUG) $(GENERATED_HEADER)
 	mkdir -p $(dir $@)
 	$(CXX) $(CFLAGS_DEBUG) -include $(INCLUDE_DIR)/pch.h -MMD -MP -c $< -o $@
 
-$(OBJ_DIR)/release/%.o: $(SRC_DIR)/%.cc $(PCH_RELEASE)
+$(OBJ_DIR)/release/%.o: $(SRC_DIR)/%.cc $(PCH_RELEASE) $(GENERATED_HEADER)
 	mkdir -p $(dir $@)
 	$(CXX) $(CFLAGS_RELEASE) -include $(INCLUDE_DIR)/pch.h -MMD -MP -c $< -o $@
 
 $(OBJ_DIR)/debug/unicode_width/%.o: libs/unicode_width/%.c
 	mkdir -p $(dir $@)
-	$(CXX) $(CFLAGS_DEBUG) -MMD -MP -c $< -o $@
+	$(CC) -MMD -MP -c $< -o $@
 
 $(OBJ_DIR)/release/unicode_width/%.o: libs/unicode_width/%.c
 	mkdir -p $(dir $@)
-	$(CXX) $(CFLAGS_RELEASE) -MMD -MP -c $< -o $@
+	$(CC) -MMD -MP -c $< -o $@
 
 DEP_DEBUG += $(UNICODE_OBJ_DEBUG:.o=.d)
 DEP_RELEASE += $(UNICODE_OBJ_RELEASE:.o=.d)

README.md

@@ -20,9 +20,8 @@ Binary can be installed with the following command:
 curl https://syedm.dev/crib | sh
 ```
 
-It requires `libmagic` to be installed (most systems have it preinstalled).<br>
 Currently only for Linux.<br>
-*Tested with arch linux and ubuntu*<br>
+*Tested with arch linux and ubuntu and void*<br>
 
 ## Building
 
@@ -52,10 +51,10 @@ Make sure you have the following dependencies installed (apart from the standard
   #include <pcre2.h>
   ```
 
-* **libmagic**
+* **[mruby](https://github.com/mruby/mruby)**
-  Install it so that you can include it in your code (most *nix systems have it installed):
+  Install it via your package manager. Once installed, the header should be available as:
   ```cpp
-  #include <magic.h>
+  #include <mruby.h>
   ```
 
 It also uses `xclip` at runtime for copying/pasting *(TODO: make it os portable)*.
@@ -99,7 +98,7 @@ The following lsp's are added by default and can be installed anywhere in your `
 
 #### Compiler
 
-`clang++` should work fine but `c++23+` is required.<br>
+`g++` or `clang++` should work fine but `c++20+` is required.<br>
 Can remove `ccache` if you want from the makefile.<br>
 
 #### Compliling
@@ -145,7 +144,7 @@ TODO: add keybind information on how to set in `config/main.rb`
 - current line highlighting
 - all instances of current word under cursor highlighting
 
-#### syntax highlighting and filetype detection (using extention or libmagic) for:
+#### syntax highlighting and filetype detection for:
 - ruby
 <!-- TODO: -->
 <!-- - bash -->

TODO.md

@@ -4,12 +4,14 @@ Copyright 2025 Syed Daanish
 
 ##### BTW Check each lsp with each of the features implemented
 
-* Static link pcre2-8 and libmagic and add precompiled libmagic magic database for better file detection
+* Add ruby config for file detection (with `file` command by default)
+* [ ] Add mgems for most common things and a ruby library to allow combining true ruby with mruby
+      - Or revert to cruby and retry with manual linking . maybe it might work?
+* [ ] color alpha in ini files
+* [ ] Make warning before ctrl+q for saving
 * [ ] **LSP Bug:** Check why `fish-lsp` is behaving so off with completions filtering.
-* [ ] **Critical Crash:** Fix bug where closing immediately while LSP is still loading hangs and then segfaults (especially on slow ones like fish-lsp where quick edits and exit can hang).
 * [ ] **Line move:** fix the move line functions to work without the calculations from folds as folds are removed.
 * [ ] **Editor Indentation Fix:** - Main : merger indentation with the parser for more accurate results.
-    * [ ] Fix bug where enter at start of line with ending type crashes
     * [ ] Keep cache of language maps in engine to reduce lookup time.
     * [ ] In indents add function to support tab which indents if before any content and inserts a pure \t otherwise.
     * [ ] And backspace which undents if before any content.
@@ -29,7 +31,7 @@ Copyright 2025 Syed Daanish
 * Try to make all functions better now that folds have been purged
 * Cleanup syntax and renderer files
 
-* Add a thing called view which is a rect with speacial type editor . but otherwise a ruby or c++ view
+* **RN** Add a thing called view which is a rect with speacial type editor . but otherwise a ruby or c++ view
 * can be used for stuff like file manager/git manager/theme picker.
 * allow flushing functions in ruby to tell c++ to refresh keybinds/themes etc.
 * allow keybinds to be set in ruby

config/main.rb

@@ -1,7 +1,16 @@
+# Files can be insluded using Kernel#require_relative
+# but it can be called with binding as the second argument
+# skipping it will call it with global binding which is usually fine
+# Kernel#load can also be used
+
+require_relative "theme"
+
 # basic configuration
 # This can also be used to do speacail configs for different projects.
 # its ruby guys script whatever you want.
 
+# puts "Loading main config..."
+
 C.startup do
   puts "Starting crib..."
 end
@@ -10,67 +19,30 @@ C.shutdown do
   puts "Exiting crib..."
 end
 
-# this can be modified by the user during runtime through keybindings
+# TODO: to be done once a proper api for binding and window drawing is made
-# But i need to know how to ever read this value only when needed.
+#       The binds will be connected to either `editor` or windows where editor can
-# maybe i can write a function that notifies if theme maybe changed then reload
+#       only use a preset set of stuff to bind while teh windows are purely custom
-# It can also be scripted to load different theme formats into a hash usable by crib
+# # this part uses dsl bindings to define the bind function
-C.theme = {
+# # Hopefully extend to give more context/power to bindings
-  :default => { fg: 0xEEEEEE },
+# # but try to keep simple for performance
-  :shebang => { fg: 0x7DCFFF },
+# # for default keybindings
-  :error => { fg: 0xEF5168 },
+# C.bind [:normal, :select], :a => "insert_mode"
-  :comment => { fg: 0xAAAAAA, italic: true },
+# # for custom keybindings
-  :string => { fg: 0xAAD94C },
+# C.bind :select, [:x, :c] do
-  :escape => { fg: 0x7DCFFF },
+#   puts "cut"
-  :interpolation => { fg: 0x7DCFFF },
+# end
-  :regexp => { fg: 0xD2A6FF },
+# C.bind :jumper do
-  :number => { fg: 0xE6C08A },
+#   set [:x, :c] do
-  # rubocop:disable Lint/BooleanSymbol
+#     puts "jump to first bookmark"
-  :true => { fg: 0x7AE93C },
+#   end
-  :false => { fg: 0xEF5168 },
+# end
-  # rubocop:enable Lint/BooleanSymbol
+# # they can also be defined conditionally
-  :char => { fg: 0xFFAF70 },
+# # This code is just an example and doesnt actually work
-  :keyword => { fg: 0xFF8F40 },
+# if using_tmux?
-  :keywordoperator => { fg: 0xF07178 },
+#   bind :C-p do
-  :operator => { fg: 0xFFFFFF, italic: true },
+#     system("tmux select-pane -U")
-  :function => { fg: 0xFFAF70 },
+#   end
-  :type => { fg: 0xF07178 },
+# end
-  :constant => { fg: 0x7DCFFF },
-  :variableinstance => { fg: 0x95E6CB },
-  :variableglobal => { fg: 0xF07178 },
-  :annotation => { fg: 0x7DCFFF },
-  :directive => { fg: 0xFF8F40 },
-  :label => { fg: 0xD2A6FF },
-  :brace1 => { fg: 0xD2A6FF },
-  :brace2 => { fg: 0xFFAFAF },
-  :brace3 => { fg: 0xFFFF00 },
-  :brace4 => { fg: 0x0FFF0F },
-  :brace5 => { fg: 0xFF0F0F }
-}
-
-# # TODO: to be done once a proper api for binding and window drawing is made
-# #       The binds will be connected to either `editor` or windows where editor can
-# #       only use a preset set of stuff to bind while teh windows are purely custom
-# # # this part uses dsl bindings to define the bind function
-# # # Hopefully extend to give more context/power to bindings
-# # # but try to keep simple for performance
-# # # for default keybindings
-# # C.bind [:normal, :select], :a => "insert_mode"
-# # # for custom keybindings
-# # C.bind :select, [:x, :c] do
-# #   puts "cut"
-# # end
-# # C.bind :jumper do
-# #   set [:x, :c] do
-# #     puts "jump to first bookmark"
-# #   end
-# # end
-# # # they can also be defined conditionally
-# # # This code is just an example and doesnt actually work
-# # if using_tmux?
-# #   bind :C-p do
-# #     system("tmux select-pane -U")
-# #   end
-# # end
 
 # This can, for example, be modified by user bindings during runtime
 # TODO: dynamic registration to actually be implemented once keybinds and extentions are implemented
@@ -82,23 +54,22 @@ C.theme = {
 #   symbol: "󰴭 ",
 #   extensions: ["rb"],
 #   filenames: ["Gemfile"],
-#   mimetypes: ["text/x-ruby"],
 #   lsp: "solargraph"
 # }
 
 C.line_endings = :auto_unix # or :unix or :windows or :auto_windows
 
-# C.extra_highlights do |_line, _idx|
+C.extra_highlights do |_line, _idx|
-#   # the return can be an array of
+  # the return can be an array of
-#   # [fg, bg. flags, start, end]
+  # [fg, bg. flags, start, end]
-#   # where fg and bg are integers (using 24 bit color)
+  # where fg and bg are integers (using 24 bit color)
-#   # and flags is a bitmask of bold/underline/italic etc
+  # and flags is a bitmask of bold/underline/italic etc
-#   # and start and end are integers strictly inside the line
+  # and start and end are integers strictly inside the line
-#   return []
+  return []
-# end
+end
 
 # The highlighter will be aplied to the language as long as the langauge is defined in C.languages
-C.highlighters[:ruby_n] = {
+C.highlighters[:string] = {
   parser: ->(line, state, line_idx) {
     # the return value is a hash
     # it contains the state and the highlights

config/theme.rb

@@ -0,0 +1,36 @@
+# this can be modified by the user during runtime through keybindings
+# But i need to know how to ever read this value only when needed.
+# maybe i can write a function that notifies if theme maybe changed then reload
+# It can also be scripted to load different theme formats into a hash usable by crib
+C.theme = {
+  :default => { fg: 0xEEEEEE },
+  :shebang => { fg: 0x7DCFFF },
+  :error => { fg: 0xEF5168 },
+  :comment => { fg: 0xAAAAAA, italic: true },
+  :string => { fg: 0xAAD94C },
+  :escape => { fg: 0x7DCFFF },
+  :interpolation => { fg: 0x7DCFFF },
+  :regexp => { fg: 0xD2A6FF },
+  :number => { fg: 0xE6C08A },
+  # rubocop:disable Lint/BooleanSymbol
+  :true => { fg: 0x7AE93C },
+  :false => { fg: 0xEF5168 },
+  # rubocop:enable Lint/BooleanSymbol
+  :char => { fg: 0xFFAF70 },
+  :keyword => { fg: 0xFF8F40 },
+  :keywordoperator => { fg: 0xF07178 },
+  :operator => { fg: 0xFFFFFF, italic: true },
+  :function => { fg: 0xFFAF70 },
+  :type => { fg: 0xF07178 },
+  :constant => { fg: 0x7DCFFF },
+  :variableinstance => { fg: 0x95E6CB },
+  :variableglobal => { fg: 0xF07178 },
+  :annotation => { fg: 0x7DCFFF },
+  :directive => { fg: 0xFF8F40 },
+  :label => { fg: 0xD2A6FF },
+  :brace1 => { fg: 0xD2A6FF },
+  :brace2 => { fg: 0xFFAFAF },
+  :brace3 => { fg: 0xFFFF00 },
+  :brace4 => { fg: 0x0FFF0F },
+  :brace5 => { fg: 0xFF0F0F }
+}

include/editor/completions.h

@@ -27,9 +27,10 @@ struct CompletionSession {
   bool active = false;
   Coord hook;
   std::optional<std::string> prefix;
-  uint8_t select = 0;
+  uint32_t select = 0;
+  uint32_t scroll = 0;
   std::vector<CompletionItem> items;
-  std::vector<uint8_t> visible;
+  std::vector<uint32_t> visible;
   bool complete = true;
   std::optional<char> trigger_char;
   uint8_t trigger = 0;

include/editor/editor.h

@@ -17,11 +17,9 @@
 #define WORD 1
 #define LINE 2
 
-#define EXTRA_META 4
+#define EXTRA_META 2
 #define INDENT_WIDTH 2
 
-// autocomplete lua// Bracket closing / tab on enter
-
 struct Editor {
   std::string filename;
   std::string uri;
@@ -31,7 +29,7 @@ struct Editor {
   uint32_t cursor_preffered;
   Coord selection;
   bool selection_active;
-  bool unix_eol; // false for windows
+  bool unix_eol;
   int selection_type;
   Coord position;
   Coord size;

include/io/knot.h

@@ -115,8 +115,8 @@ LineIterator *begin_l_iter(Knot *root, uint32_t start_line);
 // Each subsequent call returns the next line as a null terminated string
 // `it` is the iterator returned from begin_l_iter
 // After getting the necessary lines free the iterator (no need to go upto
-// the end) returns null if there are no more lines All return strings
+// the end) returns null if there are no more lines
-// `must` be freed by the caller
+// The string must not be freed
 char *next_line(LineIterator *it, uint32_t *out_len);
 
 // Returns the previous line as a null terminated string

include/lsp/lsp.h

@@ -80,6 +80,7 @@ void lsp_worker();
 std::shared_ptr<LSPInstance> get_or_init_lsp(std::string lsp_id);
 void clean_lsp(std::shared_ptr<LSPInstance> lsp, std::string lsp_id);
 void close_lsp(std::string lsp_id);
+std::optional<json> read_lsp_message(int fd);
 
 void open_editor(std::shared_ptr<LSPInstance> lsp,
                  std::pair<Language, Editor *> entry);

include/main.h

@@ -2,6 +2,7 @@
 #define MAIN_H
 
 #include "pch.h"
+#include "ui/bar.h"
 
 #define NORMAL 0
 #define INSERT 1
@@ -13,5 +14,6 @@ extern std::atomic<bool> running;
 extern std::atomic<uint8_t> mode;
 extern std::vector<struct Editor *> editors;
 extern uint8_t current_editor;
+extern Bar bar;
 
 #endif

include/pch.h

@@ -4,12 +4,12 @@
 #define PCRE2_CODE_UNIT_WIDTH 8
 #define PCRE_WORKSPACE_SIZE 512
 
-#include <magic.h>
+#include "mruby.h"
-#include <mruby.h>
+#include "mruby/array.h"
-#include <mruby/array.h>
+#include "mruby/compile.h"
-#include <mruby/compile.h>
+#include "mruby/hash.h"
-#include <mruby/hash.h>
+#include "mruby/irep.h"
-#include <mruby/string.h>
+#include "mruby/string.h"
 #include <nlohmann/json.hpp>
 #include <pcre2.h>
 extern "C" {

include/scripting/decl.h

@@ -4,19 +4,50 @@
 #include "syntax/decl.h"
 #include "utils/utils.h"
 
+namespace fs = std::filesystem;
+
 extern std::unordered_map<std::string, std::pair<mrb_value, mrb_value>>
     custom_highlighters;
+extern mrb_state *mrb;
+extern fs::path ruby_config_path;
 
+struct BarLight {
+  uint32_t start;
+  uint32_t end;
+  Highlight highlight;
+};
+
+struct BarLine {
+  std::string line;
+  std::vector<BarLight> highlights;
+
+  Highlight get_highlight(uint32_t x) {
+    for (auto &hl : highlights) {
+      if (hl.start <= x && x <= hl.end)
+        return hl.highlight;
+    }
+    return {0xFFFFFF, 0, 0};
+  }
+};
+
+void setup_ruby_bindings(mrb_state *mrb, RClass *C_module);
 void ruby_start();
 void ruby_shutdown();
-void ruby_log(std::string msg);
+void ruby_copy(const char *text, size_t len);
+std::string ruby_paste();
+std::string ruby_file_detect(std::string filename);
 void load_theme();
 void load_languages_info();
 uint8_t read_line_endings();
 void load_custom_highlighters();
-mrb_value parse_custom(std::vector<Token> *tokens, mrb_value parser_block,
+bool custom_compare(mrb_value match_block, std::string state1,
-                       const char *line, uint32_t len, mrb_value state,
+                    std::string state2);
-                       uint32_t c_line);
+std::string parse_custom(std::vector<Token> *tokens, mrb_value parser_block,
-bool custom_compare(mrb_value match_block, mrb_value state1, mrb_value state2);
+                         const char *line, uint32_t len, std::string state,
+                         uint32_t c_line);
+BarLine bar_contents(uint8_t mode, std::string lang_name, uint32_t warnings,
+                     std::string lsp_name, std::string filename,
+                     std::string foldername, uint32_t line, uint32_t max_line,
+                     uint32_t width);
 
 #endif

include/scripting/libcrib.rb

@@ -1,3 +1,66 @@
+def command_exists?(cmd)
+  system("command -v #{cmd} > /dev/null 2>&1")
+end
+
+module Clipboard
+  @clip = ""
+  @os = :os_name_placed_here
+
+  class << self
+    def copy(text)
+      if @os == :windows
+        IO.popen("clip", "w") { |f| f.write(text) }
+      elsif @os == :mac
+        IO.popen("pbcopy", "w") { |f| f.write(text) }
+      elsif @os == :linux
+        if ENV["XDG_SESSION_TYPE"]&.downcase == "wayland" || ENV["WAYLAND_DISPLAY"]
+          if command_exists?("wl-copy")
+            IO.popen("wl-copy", "w") { |f| f.write(text) }
+          else
+            osc52_copy(text)
+          end
+        elsif ENV["XDG_SESSION_TYPE"]&.downcase == "x11" || ENV["DISPLAY"]
+          if command_exists?("xsel")
+            IO.popen("xsel --clipboard --input", "w") { |f| f.write(text) }
+          elsif command_exists?("xclip")
+            IO.popen("xclip -selection clipboard", "w") { |f| f.write(text) }
+          else
+            osc52_copy(text)
+          end
+        end
+      end
+      @clip = text
+    end
+    def paste
+      if @os == :windows
+        return `powershell -NoProfile -Command Get-Clipboard`
+      elsif @os == :mac
+        return `pbpaste`
+      elsif @os == :linux
+        if ENV["XDG_SESSION_TYPE"]&.downcase == "wayland" || ENV["WAYLAND_DISPLAY"]
+          if command_exists?("wl-copy")
+            return `wl-paste`
+          end
+        elsif ENV["XDG_SESSION_TYPE"]&.downcase == "x11" || ENV["DISPLAY"]
+          if command_exists?("xsel")
+            return `xsel --clipboard --output`
+          elsif command_exists?("xclip")
+            return `xclip -selection clipboard -o`
+          else
+            return @clip
+          end
+        end
+      end
+      return ""
+    end
+    def osc52_copy(text)
+      encoded = [text].pack("m0")
+      print "\e]52;c;#{encoded}\a"
+      text
+    end
+  end
+end
+
 module C
   @lsp_config = {
     "clangd" => [
@@ -36,256 +99,186 @@ module C
       color: 0x555555,
       symbol: " ",
       extensions: ["c"],
-      filenames: [],
-      mimetypes: ["text/x-c"],
       lsp: "clangd"
     },
     cpp: {
       color: 0x00599C,
       symbol: " ",
       extensions: ["cpp", "cc", "cxx"],
-      filenames: [],
-      mimetypes: ["text/x-cpp"],
       lsp: "clangd"
     },
     h: {
       color: 0xA8B9CC,
       symbol: " ",
       extensions: ["h", "hpp"],
-      filenames: [],
-      mimetypes: ["text/x-c-header"],
       lsp: "clangd"
     },
     css: {
       color: 0x36a3d9,
       symbol: " ",
       extensions: ["css"],
-      filenames: [],
-      mimetypes: ["text/css"],
       lsp: "vscode-css-language-server"
     },
     fish: {
       color: 0x4d5a5e,
       symbol: " ",
       extensions: ["fish"],
-      filenames: [],
-      mimetypes: ["application/x-fish"],
       lsp: "fish-lsp"
     },
     go: {
       color: 0x00add8,
       symbol: " ",
       extensions: ["go"],
-      filenames: [],
-      mimetypes: ["text/x-go"],
       lsp: "gopls"
     },
     gomod: {
       color: 0x00add8,
       symbol: " ",
       extensions: ["mod"],
-      filenames: [],
-      mimetypes: ["text/x-go-mod"],
       lsp: "gopls"
     },
     haskell: {
       color: 0xa074c4,
       symbol: " ",
       extensions: ["hs", "lhs"],
-      filenames: [],
-      mimetypes: ["text/x-haskell"],
       lsp: "haskell-language-server"
     },
     html: {
       color: 0xef8a91,
       symbol: " ",
       extensions: ["html", "htm"],
-      filenames: [],
-      mimetypes: ["text/html"],
       lsp: "emmet-language-server"
     },
     javascript: {
       color: 0xf0df8a,
       symbol: " ",
       extensions: ["js"],
-      filenames: [],
-      mimetypes: ["application/javascript"],
       lsp: "typescript-language-server"
     },
     typescript: {
       color: 0x36a3d9,
       symbol: " ",
       extensions: ["ts"],
-      filenames: [],
-      mimetypes: ["application/typescript"],
       lsp: "typescript-language-server"
     },
     json: {
       color: 0xcbcb41,
       symbol: "{}",
       extensions: ["json"],
-      filenames: [],
-      mimetypes: ["application/json"],
       lsp: "vscode-json-language-server"
     },
     jsonc: {
       color: 0xcbcb41,
       symbol: "{}",
       extensions: ["jsonc"],
-      filenames: [],
-      mimetypes: ["application/json"],
       lsp: "vscode-json-language-server"
     },
     erb: {
       color: 0x6e1516,
       symbol: " ",
       extensions: ["erb"],
-      filenames: [],
-      mimetypes: ["text/x-erb"],
       lsp: "ruby-lsp"
     },
     lua: {
       color: 0x36a3d9,
       symbol: "󰢱 ",
       extensions: ["lua"],
-      filenames: [],
-      mimetypes: ["text/x-lua"],
       lsp: "lua-language-server"
     },
     python: {
       color: 0x95e6cb,
       symbol: "󰌠 ",
       extensions: ["py"],
-      filenames: [],
-      mimetypes: ["text/x-python"],
       lsp: "pyright"
     },
     rust: {
       color: 0xdea584,
       symbol: "󱘗 ",
       extensions: ["rs"],
-      filenames: [],
-      mimetypes: ["text/x-rust"],
       lsp: "rust-analyzer"
     },
     php: {
       color: 0xa074c4,
       symbol: "󰌟 ",
       extensions: ["php"],
-      filenames: [],
-      mimetypes: ["application/x-php"],
       lsp: "intelephense"
     },
     markdown: {
       color: 0x36a3d9,
       symbol: " ",
       extensions: ["md", "markdown"],
-      filenames: [],
-      mimetypes: ["text/markdown"],
       lsp: "marksman"
     },
     nginx: {
       color: 0x6d8086,
       symbol: " ",
       extensions: ["conf"],
-      filenames: [],
-      mimetypes: ["text/nginx"],
       lsp: "nginx-language-server"
     },
     toml: {
       color: 0x36a3d9,
       symbol: " ",
       extensions: ["toml"],
-      filenames: [],
-      mimetypes: ["application/toml"],
       lsp: "taplo"
     },
     yaml: {
       color: 0x6d8086,
       symbol: " ",
       extensions: ["yml", "yaml"],
-      filenames: [],
-      mimetypes: ["text/yaml"],
       lsp: "yaml-language-server"
     },
     sql: {
       color: 0xdad8d8,
       symbol: " ",
       extensions: ["sql"],
-      filenames: [],
-      mimetypes: ["text/x-sql"],
       lsp: "sqls"
     },
     make: {
       color: 0x4e5c61,
       symbol: " ",
       extensions: ["Makefile", "makefile"],
-      filenames: [],
-      mimetypes: ["text/x-makefile"],
       lsp: "make-language-server"
     },
     gdscript: {
       color: 0x6d8086,
       symbol: " ",
-      extensions: ["gd"],
+      extensions: ["gd"]
-      filenames: [],
-      mimetypes: ["text/x-gdscript"],
-      lsp: nil
     },
     man: {
       color: 0xdad8d8,
       symbol: " ",
-      extensions: ["man"],
+      extensions: ["man"]
-      filenames: [],
-      mimetypes: ["application/x-troff-man"],
-      lsp: nil
     },
     diff: {
       color: 0xDD4C35,
       symbol: " ",
-      extensions: ["diff", "patch"],
+      extensions: ["diff", "patch"]
-      filenames: [],
-      mimetypes: ["text/x-diff"],
-      lsp: nil
     },
     gitattributes: {
       color: 0xF05032,
       symbol: " ",
-      extensions: ["gitattributes"],
+      extensions: ["gitattributes"]
-      filenames: [],
-      mimetypes: [],
-      lsp: nil
     },
     gitignore: {
       color: 0xF05032,
       symbol: " ",
-      extensions: ["gitignore"],
+      extensions: ["gitignore"]
-      filenames: [],
-      mimetypes: [],
-      lsp: nil
     },
     regex: {
       color: 0x9E9E9E,
       symbol: ".*",
-      extensions: ["regex"],
+      extensions: ["regex"]
-      filenames: [],
-      mimetypes: [],
-      lsp: nil
     },
     ini: {
       color: 0x6d8086,
       symbol: " ",
-      extensions: ["ini"],
+      extensions: ["ini"]
-      filenames: [],
-      mimetypes: [],
-      lsp: nil
     },
     ruby: {
       color: 0xff8087,
       symbol: "󰴭 ",
       extensions: ["rb"],
       filenames: ["Gemfile"],
-      mimetypes: ["text/x-ruby"],
       lsp: "solargraph"
     },
     bash: {
@@ -293,8 +286,12 @@ module C
       symbol: " ",
       extensions: ["sh"],
       filenames: ["bash_profile", "bashrc"],
-      mimetypes: ["text/x-sh"],
       lsp: "bash-language-server"
+    },
+    default: {
+      color: 0x6d8086,
+      symbol: "󰈚 ",
+      extensions: []
     }
   }
   @theme = {
@@ -307,10 +304,8 @@ module C
     :interpolation => { fg: 0x7DCFFF },
     :regexp => { fg: 0xD2A6FF },
     :number => { fg: 0xE6C08A },
-    # rubocop:disable Lint/BooleanSymbol
     :true => { fg: 0x7AE93C },
     :false => { fg: 0xEF5168 },
-    # rubocop:enable Lint/BooleanSymbol
     :char => { fg: 0xFFAF70 },
     :keyword => { fg: 0xFF8F40 },
     :keywordoperator => { fg: 0xF07178 },
@@ -333,14 +328,96 @@ module C
   @key_handlers = {}
   @key_binds = {}
   @highlighters = {}
-  @log_queue = []
   @b_startup = nil
   @b_shutdown = nil
+  @b_bar = proc do |info|
+    # mode, lang_name, warnings, lsp_name, filename, foldername, line, max_line, width
+    # puts info.inspect
+    mode_color = 0x82AAFF
+    mode_symbol = "  "
+    case info[:mode]
+    when :normal
+      mode_color = 0x82AAFF
+      mode_symbol = " "
+    when :insert
+      mode_color = 0xFF8F40
+      mode_symbol = "󱓧 "
+    when :select
+      mode_color = 0x9ADE7A
+      mode_symbol = "󱩧 "
+    when :runner
+      mode_color = 0xFFD700
+      mode_symbol = " "
+    when :jumper
+      mode_color = 0xF29CC3
+      mode_symbol = " "
+    end
+    lang_info = C.languages[info[:lang_name]]
+    if lang_info.nil?
+      lang_info = C.languages[:default]
+    end
+    filename = File.basename(info[:filename])
+    starting = " #{mode_symbol} #{info[:mode].to_s.upcase}  #{lang_info[:symbol]}#{filename}"
+    highlights = []
+    highlights << { fg: 0x0b0e14, bg: mode_color, flags: 1 << 1, start: 0, length: 10 }
+    highlights << { fg: mode_color, bg: 0x33363c, start: 10, length: 1 }
+    highlights << { fg: 0x33363c, bg: 0x24272d, start: 11, length: 1 }
+    highlights << { fg: lang_info[:color], bg: 0x24272d, start: 13, length: 2 }
+    highlights << { fg: 0xced4df, bg: 0x24272d, start: 15, length: filename.length }
+    highlights << { fg: 0x24272d, bg: 0x000000, start: 15 + filename.length, length: 1 }
+    next {
+      text: starting,
+      highlights: highlights
+    }
+  end
+  @b_copy = proc do |text|
+    Clipboard.copy(text)
+  end
+  @b_paste = proc do
+    next Clipboard.paste
+  end
+  @b_file_detect = proc do |filename|
+    type = :default
+    next type unless File.exist?(filename)
+    first_line = File.open(filename, &:readline).chomp
+    if first_line.start_with?("#!")
+      shebang = first_line[2..].downcase
+      type = case shebang
+             when /bash/, /sh/   then :bash
+             when /fish/         then :fish
+             when /python/       then :python
+             when /ruby/         then :ruby
+             when /lua/          then :lua
+             else :default
+             end
+      next type
+    end
+    next type if :os_name_placed_here != :linux || :os_name_placed_here != :mac
+    next type if !command_exists?("file")
+    mimetype = `file --mime-type -b #{filename}`.chomp
+    type = case mimetype
+           when /shellscript/ then :bash
+           when /ruby/        then :ruby
+           when /diff/        then :diff
+           when /html/        then :html
+           when /python/      then :python
+           when /javascript/  then :javascript
+           when /makefile/    then :makefile
+           when /-c$/         then :c
+           else :default
+           end
+    next type
+  end
 
   class << self
     attr_accessor :theme, :lsp_config, :languages,
                   :line_endings, :highlighters
-    attr_reader :b_startup, :b_shutdown, :b_extra_highlights
+    attr_reader :b_startup, :b_shutdown, :b_extra_highlights,
+                :b_bar, :b_copy, :b_paste, :b_file_detect
+
+    def bar=(&block)
+      @b_bar = block
+    end
 
     def startup(&block)
       @b_startup = block
@@ -350,15 +427,16 @@ module C
       @b_shutdown = block
     end
 
-    def queue_log(msg)
+    def copy(&block)
-      @log_queue << msg
+      @b_copy = block
     end
 
-    def log_all
+    def paste(&block)
-      @log_queue.each do |msg|
+      @b_paste = block
-        puts msg
+    end
-      end
+
-      @log_queue = []
+    def file_detect(&block)
+      @b_file_detect = block
     end
 
     def extra_highlights(&block)
@@ -397,4 +475,21 @@ module C
   end
 end
 
-at_exit { C.log_all }
+$LOADED ||= []
+
+module Kernel
+  def require_relative(path, bind = nil)
+    path += ".rb" unless path.end_with?(".rb")
+    path = File.expand_path(path, File.dirname(C.config_file))
+    return if $LOADED.include?(path)
+    $LOADED << path
+    code = File.read(path)
+    eval(code, bind || binding, path)
+  end
+  def load(path, bind = nil)
+    path += ".rb" unless path.end_with?(".rb")
+    path = File.expand_path(path, File.dirname(C.config_file))
+    $LOADED.delete(path)
+    require_relative(path, bind)
+  end
+end

include/scripting/ruby_compiled.h

@@ -0,0 +1,931 @@
+#pragma once
+constexpr unsigned char _tmp___crib_precompiled_mrb[] = {
+  0x52, 0x49, 0x54, 0x45, 0x30, 0x34, 0x30, 0x30, 0x00, 0x00, 0x2b, 0x6d,
+  0x4d, 0x41, 0x54, 0x5a, 0x30, 0x30, 0x30, 0x30, 0x49, 0x52, 0x45, 0x50,
+  0x00, 0x00, 0x29, 0xd9, 0x30, 0x34, 0x30, 0x30, 0x00, 0x00, 0x00, 0x86,
+  0x00, 0x01, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34,
+  0x11, 0x01, 0x68, 0x01, 0x00, 0x69, 0x01, 0x00, 0x6b, 0x01, 0x01, 0x01,
+  0x11, 0x01, 0x68, 0x01, 0x02, 0x69, 0x01, 0x02, 0x11, 0x01, 0x68, 0x01,
+  0x03, 0x69, 0x01, 0x03, 0x15, 0x01, 0x04, 0x27, 0x01, 0x00, 0x06, 0x52,
+  0x01, 0x00, 0x16, 0x01, 0x04, 0x11, 0x01, 0x68, 0x01, 0x05, 0x69, 0x01,
+  0x04, 0x3d, 0x01, 0x76, 0x00, 0x00, 0x00, 0x06, 0x00, 0x06, 0x54, 0x6f,
+  0x6b, 0x65, 0x6e, 0x73, 0x00, 0x00, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x61,
+  0x6e, 0x64, 0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x3f, 0x00, 0x00,
+  0x09, 0x43, 0x6c, 0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x00,
+  0x01, 0x43, 0x00, 0x00, 0x07, 0x24, 0x4c, 0x4f, 0x41, 0x44, 0x45, 0x44,
+  0x00, 0x00, 0x06, 0x4b, 0x65, 0x72, 0x6e, 0x65, 0x6c, 0x00, 0x00, 0x00,
+  0x03, 0xfc, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x01, 0x3b, 0x06, 0x01, 0x1e, 0x01, 0x00, 0x07, 0x01, 0x1e, 0x01, 0x01,
+  0x08, 0x01, 0x1e, 0x01, 0x02, 0x09, 0x01, 0x1e, 0x01, 0x03, 0x0a, 0x01,
+  0x1e, 0x01, 0x04, 0x0b, 0x01, 0x1e, 0x01, 0x05, 0x0c, 0x01, 0x1e, 0x01,
+  0x06, 0x0d, 0x01, 0x1e, 0x01, 0x07, 0x03, 0x01, 0x08, 0x1e, 0x01, 0x08,
+  0x03, 0x01, 0x09, 0x1e, 0x01, 0x09, 0x03, 0x01, 0x0a, 0x1e, 0x01, 0x0a,
+  0x03, 0x01, 0x0b, 0x1e, 0x01, 0x0b, 0x03, 0x01, 0x0c, 0x1e, 0x01, 0x0c,
+  0x03, 0x01, 0x0d, 0x1e, 0x01, 0x0d, 0x03, 0x01, 0x0e, 0x1e, 0x01, 0x0e,
+  0x03, 0x01, 0x0f, 0x1e, 0x01, 0x0f, 0x03, 0x01, 0x10, 0x1e, 0x01, 0x10,
+  0x03, 0x01, 0x11, 0x1e, 0x01, 0x11, 0x03, 0x01, 0x12, 0x1e, 0x01, 0x12,
+  0x03, 0x01, 0x13, 0x1e, 0x01, 0x13, 0x03, 0x01, 0x14, 0x1e, 0x01, 0x14,
+  0x03, 0x01, 0x15, 0x1e, 0x01, 0x15, 0x03, 0x01, 0x16, 0x1e, 0x01, 0x16,
+  0x03, 0x01, 0x17, 0x1e, 0x01, 0x17, 0x03, 0x01, 0x18, 0x1e, 0x01, 0x18,
+  0x03, 0x01, 0x19, 0x1e, 0x01, 0x19, 0x03, 0x01, 0x1a, 0x1e, 0x01, 0x1a,
+  0x03, 0x01, 0x1b, 0x1e, 0x01, 0x1b, 0x03, 0x01, 0x1c, 0x1e, 0x01, 0x1c,
+  0x03, 0x01, 0x1d, 0x1e, 0x01, 0x1d, 0x03, 0x01, 0x1e, 0x1e, 0x01, 0x1e,
+  0x03, 0x01, 0x1f, 0x1e, 0x01, 0x1f, 0x03, 0x01, 0x20, 0x1e, 0x01, 0x20,
+  0x03, 0x01, 0x21, 0x1e, 0x01, 0x21, 0x03, 0x01, 0x22, 0x1e, 0x01, 0x22,
+  0x03, 0x01, 0x23, 0x1e, 0x01, 0x23, 0x03, 0x01, 0x24, 0x1e, 0x01, 0x24,
+  0x03, 0x01, 0x25, 0x1e, 0x01, 0x25, 0x03, 0x01, 0x26, 0x1e, 0x01, 0x26,
+  0x03, 0x01, 0x27, 0x1e, 0x01, 0x27, 0x03, 0x01, 0x28, 0x1e, 0x01, 0x28,
+  0x03, 0x01, 0x29, 0x1e, 0x01, 0x29, 0x03, 0x01, 0x2a, 0x1e, 0x01, 0x2a,
+  0x03, 0x01, 0x2b, 0x1e, 0x01, 0x2b, 0x03, 0x01, 0x2c, 0x1e, 0x01, 0x2c,
+  0x03, 0x01, 0x2d, 0x1e, 0x01, 0x2d, 0x03, 0x01, 0x2e, 0x1e, 0x01, 0x2e,
+  0x03, 0x01, 0x2f, 0x1e, 0x01, 0x2f, 0x03, 0x01, 0x30, 0x1e, 0x01, 0x30,
+  0x03, 0x01, 0x31, 0x1e, 0x01, 0x31, 0x03, 0x01, 0x32, 0x1e, 0x01, 0x32,
+  0x03, 0x01, 0x33, 0x1e, 0x01, 0x33, 0x03, 0x01, 0x34, 0x1e, 0x01, 0x34,
+  0x30, 0x01, 0x35, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x06, 0x4b,
+  0x5f, 0x44, 0x41, 0x54, 0x41, 0x00, 0x00, 0x09, 0x4b, 0x5f, 0x53, 0x48,
+  0x45, 0x42, 0x41, 0x4e, 0x47, 0x00, 0x00, 0x09, 0x4b, 0x5f, 0x43, 0x4f,
+  0x4d, 0x4d, 0x45, 0x4e, 0x54, 0x00, 0x00, 0x07, 0x4b, 0x5f, 0x45, 0x52,
+  0x52, 0x4f, 0x52, 0x00, 0x00, 0x08, 0x4b, 0x5f, 0x53, 0x54, 0x52, 0x49,
+  0x4e, 0x47, 0x00, 0x00, 0x08, 0x4b, 0x5f, 0x45, 0x53, 0x43, 0x41, 0x50,
+  0x45, 0x00, 0x00, 0x0f, 0x4b, 0x5f, 0x49, 0x4e, 0x54, 0x45, 0x52, 0x50,
+  0x4f, 0x4c, 0x41, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x08, 0x4b, 0x5f,
+  0x52, 0x45, 0x47, 0x45, 0x58, 0x50, 0x00, 0x00, 0x08, 0x4b, 0x5f, 0x4e,
+  0x55, 0x4d, 0x42, 0x45, 0x52, 0x00, 0x00, 0x06, 0x4b, 0x5f, 0x54, 0x52,
+  0x55, 0x45, 0x00, 0x00, 0x07, 0x4b, 0x5f, 0x46, 0x41, 0x4c, 0x53, 0x45,
+  0x00, 0x00, 0x06, 0x4b, 0x5f, 0x43, 0x48, 0x41, 0x52, 0x00, 0x00, 0x09,
+  0x4b, 0x5f, 0x4b, 0x45, 0x59, 0x57, 0x4f, 0x52, 0x44, 0x00, 0x00, 0x11,
+  0x4b, 0x5f, 0x4b, 0x45, 0x59, 0x57, 0x4f, 0x52, 0x44, 0x4f, 0x50, 0x45,
+  0x52, 0x41, 0x54, 0x4f, 0x52, 0x00, 0x00, 0x0a, 0x4b, 0x5f, 0x4f, 0x50,
+  0x45, 0x52, 0x41, 0x54, 0x4f, 0x52, 0x00, 0x00, 0x0a, 0x4b, 0x5f, 0x46,
+  0x55, 0x4e, 0x43, 0x54, 0x49, 0x4f, 0x4e, 0x00, 0x00, 0x06, 0x4b, 0x5f,
+  0x54, 0x59, 0x50, 0x45, 0x00, 0x00, 0x0a, 0x4b, 0x5f, 0x43, 0x4f, 0x4e,
+  0x53, 0x54, 0x41, 0x4e, 0x54, 0x00, 0x00, 0x12, 0x4b, 0x5f, 0x56, 0x41,
+  0x52, 0x49, 0x41, 0x42, 0x4c, 0x45, 0x49, 0x4e, 0x53, 0x54, 0x41, 0x4e,
+  0x43, 0x45, 0x00, 0x00, 0x10, 0x4b, 0x5f, 0x56, 0x41, 0x52, 0x49, 0x41,
+  0x42, 0x4c, 0x45, 0x47, 0x4c, 0x4f, 0x42, 0x41, 0x4c, 0x00, 0x00, 0x0c,
+  0x4b, 0x5f, 0x41, 0x4e, 0x4e, 0x4f, 0x54, 0x41, 0x54, 0x49, 0x4f, 0x4e,
+  0x00, 0x00, 0x0b, 0x4b, 0x5f, 0x44, 0x49, 0x52, 0x45, 0x43, 0x54, 0x49,
+  0x56, 0x45, 0x00, 0x00, 0x07, 0x4b, 0x5f, 0x4c, 0x41, 0x42, 0x45, 0x4c,
+  0x00, 0x00, 0x08, 0x4b, 0x5f, 0x42, 0x52, 0x41, 0x43, 0x45, 0x31, 0x00,
+  0x00, 0x08, 0x4b, 0x5f, 0x42, 0x52, 0x41, 0x43, 0x45, 0x32, 0x00, 0x00,
+  0x08, 0x4b, 0x5f, 0x42, 0x52, 0x41, 0x43, 0x45, 0x33, 0x00, 0x00, 0x08,
+  0x4b, 0x5f, 0x42, 0x52, 0x41, 0x43, 0x45, 0x34, 0x00, 0x00, 0x08, 0x4b,
+  0x5f, 0x42, 0x52, 0x41, 0x43, 0x45, 0x35, 0x00, 0x00, 0x0a, 0x4b, 0x5f,
+  0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x31, 0x00, 0x00, 0x0a, 0x4b,
+  0x5f, 0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x32, 0x00, 0x00, 0x0a,
+  0x4b, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x33, 0x00, 0x00,
+  0x0a, 0x4b, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x34, 0x00,
+  0x00, 0x0a, 0x4b, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47, 0x35,
+  0x00, 0x00, 0x0a, 0x4b, 0x5f, 0x48, 0x45, 0x41, 0x44, 0x49, 0x4e, 0x47,
+  0x36, 0x00, 0x00, 0x0c, 0x4b, 0x5f, 0x42, 0x4c, 0x4f, 0x43, 0x4b, 0x51,
+  0x55, 0x4f, 0x54, 0x45, 0x00, 0x00, 0x06, 0x4b, 0x5f, 0x4c, 0x49, 0x53,
+  0x54, 0x00, 0x00, 0x0a, 0x4b, 0x5f, 0x4c, 0x49, 0x53, 0x54, 0x49, 0x54,
+  0x45, 0x4d, 0x00, 0x00, 0x06, 0x4b, 0x5f, 0x43, 0x4f, 0x44, 0x45, 0x00,
+  0x00, 0x0e, 0x4b, 0x5f, 0x4c, 0x41, 0x4e, 0x47, 0x55, 0x41, 0x47, 0x45,
+  0x4e, 0x41, 0x4d, 0x45, 0x00, 0x00, 0x0b, 0x4b, 0x5f, 0x4c, 0x49, 0x4e,
+  0x4b, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x00, 0x00, 0x0c, 0x4b, 0x5f, 0x49,
+  0x4d, 0x41, 0x47, 0x45, 0x4c, 0x41, 0x42, 0x45, 0x4c, 0x00, 0x00, 0x06,
+  0x4b, 0x5f, 0x4c, 0x49, 0x4e, 0x4b, 0x00, 0x00, 0x07, 0x4b, 0x5f, 0x54,
+  0x41, 0x42, 0x4c, 0x45, 0x00, 0x00, 0x0d, 0x4b, 0x5f, 0x54, 0x41, 0x42,
+  0x4c, 0x45, 0x48, 0x45, 0x41, 0x44, 0x45, 0x52, 0x00, 0x00, 0x08, 0x4b,
+  0x5f, 0x49, 0x54, 0x41, 0x4c, 0x49, 0x43, 0x00, 0x00, 0x06, 0x4b, 0x5f,
+  0x42, 0x4f, 0x4c, 0x44, 0x00, 0x00, 0x0b, 0x4b, 0x5f, 0x55, 0x4e, 0x44,
+  0x45, 0x52, 0x4c, 0x49, 0x4e, 0x45, 0x00, 0x00, 0x0f, 0x4b, 0x5f, 0x53,
+  0x54, 0x52, 0x49, 0x4b, 0x45, 0x54, 0x48, 0x52, 0x4f, 0x55, 0x47, 0x48,
+  0x00, 0x00, 0x10, 0x4b, 0x5f, 0x48, 0x4f, 0x52, 0x49, 0x58, 0x4f, 0x4e,
+  0x54, 0x41, 0x4c, 0x52, 0x55, 0x4c, 0x45, 0x00, 0x00, 0x05, 0x4b, 0x5f,
+  0x54, 0x41, 0x47, 0x00, 0x00, 0x0b, 0x4b, 0x5f, 0x41, 0x54, 0x54, 0x52,
+  0x49, 0x42, 0x55, 0x54, 0x45, 0x00, 0x00, 0x0b, 0x4b, 0x5f, 0x43, 0x48,
+  0x45, 0x43, 0x4b, 0x44, 0x4f, 0x4e, 0x45, 0x00, 0x00, 0x0e, 0x4b, 0x5f,
+  0x43, 0x48, 0x45, 0x43, 0x4b, 0x4e, 0x4f, 0x54, 0x44, 0x4f, 0x4e, 0x45,
+  0x00, 0x00, 0x06, 0x66, 0x72, 0x65, 0x65, 0x7a, 0x65, 0x00, 0x00, 0x00,
+  0x00, 0x58, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x17, 0x39, 0x04, 0x00, 0x00, 0x5c, 0x04, 0x00, 0x01, 0x05, 0x01,
+  0x5d, 0x04, 0x5c, 0x05, 0x01, 0x5d, 0x04, 0x2f, 0x03, 0x00, 0x01, 0x3d,
+  0x03, 0x00, 0x02, 0x00, 0x00, 0x0b, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e,
+  0x64, 0x20, 0x2d, 0x76, 0x20, 0x00, 0x00, 0x00, 0x11, 0x20, 0x3e, 0x20,
+  0x2f, 0x64, 0x65, 0x76, 0x2f, 0x6e, 0x75, 0x6c, 0x6c, 0x20, 0x32, 0x3e,
+  0x26, 0x31, 0x00, 0x00, 0x01, 0x00, 0x06, 0x73, 0x79, 0x73, 0x74, 0x65,
+  0x6d, 0x00, 0x00, 0x00, 0x00, 0x43, 0x00, 0x01, 0x00, 0x02, 0x00, 0x01,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x15, 0x5c, 0x01, 0x00, 0x1a, 0x01, 0x00,
+  0x10, 0x01, 0x01, 0x1a, 0x01, 0x02, 0x12, 0x01, 0x6f, 0x01, 0x69, 0x01,
+  0x00, 0x3d, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00,
+  0x05, 0x40, 0x63, 0x6c, 0x69, 0x70, 0x00, 0x00, 0x05, 0x6c, 0x69, 0x6e,
+  0x75, 0x78, 0x00, 0x00, 0x03, 0x40, 0x6f, 0x73, 0x00, 0x00, 0x00, 0x00,
+  0x3e, 0x00, 0x01, 0x00, 0x01, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0e, 0x6b, 0x01, 0x00, 0x00, 0x6b, 0x01, 0x01, 0x01, 0x6b, 0x01, 0x02,
+  0x02, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x04, 0x63, 0x6f, 0x70,
+  0x79, 0x00, 0x00, 0x05, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x0a,
+  0x6f, 0x73, 0x63, 0x35, 0x32, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00,
+  0x00, 0x02, 0x37, 0x00, 0x03, 0x00, 0x07, 0x00, 0x05, 0x00, 0x00, 0x00,
+  0x00, 0x01, 0x0f, 0x39, 0x04, 0x00, 0x00, 0x19, 0x03, 0x00, 0x10, 0x04,
+  0x01, 0x4d, 0x03, 0x28, 0x03, 0x00, 0x13, 0x1d, 0x03, 0x02, 0x5c, 0x04,
+  0x00, 0x5c, 0x05, 0x01, 0x62, 0x06, 0x00, 0x34, 0x03, 0x03, 0x02, 0x26,
+  0x00, 0xe4, 0x19, 0x03, 0x00, 0x10, 0x04, 0x04, 0x4d, 0x03, 0x28, 0x03,
+  0x00, 0x13, 0x1d, 0x03, 0x02, 0x5c, 0x04, 0x02, 0x5c, 0x05, 0x01, 0x62,
+  0x06, 0x01, 0x34, 0x03, 0x03, 0x02, 0x26, 0x00, 0xc5, 0x19, 0x03, 0x00,
+  0x10, 0x04, 0x05, 0x4d, 0x03, 0x28, 0x03, 0x00, 0xb9, 0x1d, 0x03, 0x06,
+  0x5c, 0x04, 0x03, 0x23, 0x03, 0x01, 0x04, 0x03, 0x29, 0x04, 0x00, 0x03,
+  0x33, 0x03, 0x07, 0x5c, 0x04, 0x04, 0x4d, 0x03, 0x27, 0x03, 0x00, 0x08,
+  0x1d, 0x03, 0x06, 0x5c, 0x04, 0x05, 0x23, 0x03, 0x28, 0x03, 0x00, 0x28,
+  0x5c, 0x04, 0x06, 0x2f, 0x03, 0x08, 0x01, 0x28, 0x03, 0x00, 0x13, 0x1d,
+  0x03, 0x02, 0x5c, 0x04, 0x06, 0x5c, 0x05, 0x01, 0x62, 0x06, 0x02, 0x34,
+  0x03, 0x03, 0x02, 0x26, 0x00, 0x07, 0x01, 0x04, 0x01, 0x2f, 0x03, 0x09,
+  0x01, 0x26, 0x00, 0x6a, 0x1d, 0x03, 0x06, 0x5c, 0x04, 0x03, 0x23, 0x03,
+  0x01, 0x04, 0x03, 0x29, 0x04, 0x00, 0x03, 0x33, 0x03, 0x07, 0x5c, 0x04,
+  0x07, 0x4d, 0x03, 0x27, 0x03, 0x00, 0x08, 0x1d, 0x03, 0x06, 0x5c, 0x04,
+  0x08, 0x23, 0x03, 0x28, 0x03, 0x00, 0x43, 0x5c, 0x04, 0x09, 0x2f, 0x03,
+  0x08, 0x01, 0x28, 0x03, 0x00, 0x13, 0x1d, 0x03, 0x02, 0x5c, 0x04, 0x0a,
+  0x5c, 0x05, 0x01, 0x62, 0x06, 0x03, 0x34, 0x03, 0x03, 0x02, 0x26, 0x00,
+  0x25, 0x5c, 0x04, 0x0b, 0x2f, 0x03, 0x08, 0x01, 0x28, 0x03, 0x00, 0x13,
+  0x1d, 0x03, 0x02, 0x5c, 0x04, 0x0c, 0x5c, 0x05, 0x01, 0x62, 0x06, 0x04,
+  0x34, 0x03, 0x03, 0x02, 0x26, 0x00, 0x07, 0x01, 0x04, 0x01, 0x2f, 0x03,
+  0x09, 0x01, 0x01, 0x03, 0x01, 0x1a, 0x03, 0x0a, 0x3d, 0x03, 0x00, 0x0d,
+  0x00, 0x00, 0x04, 0x63, 0x6c, 0x69, 0x70, 0x00, 0x00, 0x00, 0x01, 0x77,
+  0x00, 0x00, 0x00, 0x06, 0x70, 0x62, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00,
+  0x00, 0x10, 0x58, 0x44, 0x47, 0x5f, 0x53, 0x45, 0x53, 0x53, 0x49, 0x4f,
+  0x4e, 0x5f, 0x54, 0x59, 0x50, 0x45, 0x00, 0x00, 0x00, 0x07, 0x77, 0x61,
+  0x79, 0x6c, 0x61, 0x6e, 0x64, 0x00, 0x00, 0x00, 0x0f, 0x57, 0x41, 0x59,
+  0x4c, 0x41, 0x4e, 0x44, 0x5f, 0x44, 0x49, 0x53, 0x50, 0x4c, 0x41, 0x59,
+  0x00, 0x00, 0x00, 0x07, 0x77, 0x6c, 0x2d, 0x63, 0x6f, 0x70, 0x79, 0x00,
+  0x00, 0x00, 0x03, 0x78, 0x31, 0x31, 0x00, 0x00, 0x00, 0x07, 0x44, 0x49,
+  0x53, 0x50, 0x4c, 0x41, 0x59, 0x00, 0x00, 0x00, 0x04, 0x78, 0x73, 0x65,
+  0x6c, 0x00, 0x00, 0x00, 0x18, 0x78, 0x73, 0x65, 0x6c, 0x20, 0x2d, 0x2d,
+  0x63, 0x6c, 0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x20, 0x2d, 0x2d,
+  0x69, 0x6e, 0x70, 0x75, 0x74, 0x00, 0x00, 0x00, 0x05, 0x78, 0x63, 0x6c,
+  0x69, 0x70, 0x00, 0x00, 0x00, 0x1a, 0x78, 0x63, 0x6c, 0x69, 0x70, 0x20,
+  0x2d, 0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63,
+  0x6c, 0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x00, 0x0b, 0x00,
+  0x03, 0x40, 0x6f, 0x73, 0x00, 0x00, 0x07, 0x77, 0x69, 0x6e, 0x64, 0x6f,
+  0x77, 0x73, 0x00, 0x00, 0x02, 0x49, 0x4f, 0x00, 0x00, 0x05, 0x70, 0x6f,
+  0x70, 0x65, 0x6e, 0x00, 0x00, 0x03, 0x6d, 0x61, 0x63, 0x00, 0x00, 0x05,
+  0x6c, 0x69, 0x6e, 0x75, 0x78, 0x00, 0x00, 0x03, 0x45, 0x4e, 0x56, 0x00,
+  0x00, 0x08, 0x64, 0x6f, 0x77, 0x6e, 0x63, 0x61, 0x73, 0x65, 0x00, 0x00,
+  0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x65, 0x78, 0x69,
+  0x73, 0x74, 0x73, 0x3f, 0x00, 0x00, 0x0a, 0x6f, 0x73, 0x63, 0x35, 0x32,
+  0x5f, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00, 0x05, 0x40, 0x63, 0x6c, 0x69,
+  0x70, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x39, 0x04, 0x00, 0x00, 0x01, 0x03,
+  0x01, 0x21, 0x04, 0x01, 0x00, 0x32, 0x03, 0x00, 0x01, 0x3d, 0x03, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x05, 0x77, 0x72, 0x69, 0x74, 0x65, 0x00, 0x00,
+  0x00, 0x00, 0x2d, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x11, 0x39, 0x04, 0x00, 0x00, 0x01, 0x03, 0x01, 0x21, 0x04,
+  0x01, 0x00, 0x32, 0x03, 0x00, 0x01, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x05, 0x77, 0x72, 0x69, 0x74, 0x65, 0x00, 0x00, 0x00, 0x00, 0x2d,
+  0x00, 0x03, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
+  0x39, 0x04, 0x00, 0x00, 0x01, 0x03, 0x01, 0x21, 0x04, 0x01, 0x00, 0x32,
+  0x03, 0x00, 0x01, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x77,
+  0x72, 0x69, 0x74, 0x65, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x03, 0x00,
+  0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x39, 0x04, 0x00,
+  0x00, 0x01, 0x03, 0x01, 0x21, 0x04, 0x01, 0x00, 0x32, 0x03, 0x00, 0x01,
+  0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x77, 0x72, 0x69, 0x74,
+  0x65, 0x00, 0x00, 0x00, 0x00, 0x2d, 0x00, 0x03, 0x00, 0x06, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x39, 0x04, 0x00, 0x00, 0x01, 0x03,
+  0x01, 0x21, 0x04, 0x01, 0x00, 0x32, 0x03, 0x00, 0x01, 0x3d, 0x03, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x05, 0x77, 0x72, 0x69, 0x74, 0x65, 0x00, 0x00,
+  0x00, 0x02, 0x27, 0x00, 0x02, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0xdd, 0x39, 0x00, 0x00, 0x00, 0x19, 0x02, 0x00, 0x10, 0x03,
+  0x01, 0x4d, 0x02, 0x28, 0x02, 0x00, 0x0c, 0x5c, 0x03, 0x00, 0x2f, 0x02,
+  0x02, 0x01, 0x3d, 0x02, 0x26, 0x00, 0xbc, 0x19, 0x02, 0x00, 0x10, 0x03,
+  0x03, 0x4d, 0x02, 0x28, 0x02, 0x00, 0x0c, 0x5c, 0x03, 0x01, 0x2f, 0x02,
+  0x02, 0x01, 0x3d, 0x02, 0x26, 0x00, 0xa4, 0x19, 0x02, 0x00, 0x10, 0x03,
+  0x04, 0x4d, 0x02, 0x28, 0x02, 0x00, 0x98, 0x1d, 0x02, 0x05, 0x5c, 0x03,
+  0x02, 0x23, 0x02, 0x01, 0x03, 0x02, 0x29, 0x03, 0x00, 0x03, 0x33, 0x02,
+  0x06, 0x5c, 0x03, 0x03, 0x4d, 0x02, 0x27, 0x02, 0x00, 0x08, 0x1d, 0x02,
+  0x05, 0x5c, 0x03, 0x04, 0x23, 0x02, 0x28, 0x02, 0x00, 0x17, 0x5c, 0x03,
+  0x05, 0x2f, 0x02, 0x07, 0x01, 0x28, 0x02, 0x00, 0x09, 0x5c, 0x03, 0x06,
+  0x2f, 0x02, 0x02, 0x01, 0x3d, 0x02, 0x26, 0x00, 0x5a, 0x1d, 0x02, 0x05,
+  0x5c, 0x03, 0x02, 0x23, 0x02, 0x01, 0x03, 0x02, 0x29, 0x03, 0x00, 0x03,
+  0x33, 0x02, 0x06, 0x5c, 0x03, 0x07, 0x4d, 0x02, 0x27, 0x02, 0x00, 0x08,
+  0x1d, 0x02, 0x05, 0x5c, 0x03, 0x08, 0x23, 0x02, 0x28, 0x02, 0x00, 0x33,
+  0x5c, 0x03, 0x09, 0x2f, 0x02, 0x07, 0x01, 0x28, 0x02, 0x00, 0x0c, 0x5c,
+  0x03, 0x0a, 0x2f, 0x02, 0x02, 0x01, 0x3d, 0x02, 0x26, 0x00, 0x1c, 0x5c,
+  0x03, 0x0b, 0x2f, 0x02, 0x07, 0x01, 0x28, 0x02, 0x00, 0x0c, 0x5c, 0x03,
+  0x0c, 0x2f, 0x02, 0x02, 0x01, 0x3d, 0x02, 0x26, 0x00, 0x05, 0x19, 0x02,
+  0x08, 0x3d, 0x02, 0x5c, 0x02, 0x0d, 0x3d, 0x02, 0x00, 0x0e, 0x00, 0x00,
+  0x2c, 0x70, 0x6f, 0x77, 0x65, 0x72, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x20,
+  0x2d, 0x4e, 0x6f, 0x50, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x2d,
+  0x43, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x20, 0x47, 0x65, 0x74, 0x2d,
+  0x43, 0x6c, 0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x00, 0x00,
+  0x07, 0x70, 0x62, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x00, 0x10,
+  0x58, 0x44, 0x47, 0x5f, 0x53, 0x45, 0x53, 0x53, 0x49, 0x4f, 0x4e, 0x5f,
+  0x54, 0x59, 0x50, 0x45, 0x00, 0x00, 0x00, 0x07, 0x77, 0x61, 0x79, 0x6c,
+  0x61, 0x6e, 0x64, 0x00, 0x00, 0x00, 0x0f, 0x57, 0x41, 0x59, 0x4c, 0x41,
+  0x4e, 0x44, 0x5f, 0x44, 0x49, 0x53, 0x50, 0x4c, 0x41, 0x59, 0x00, 0x00,
+  0x00, 0x07, 0x77, 0x6c, 0x2d, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00, 0x00,
+  0x08, 0x77, 0x6c, 0x2d, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x00,
+  0x03, 0x78, 0x31, 0x31, 0x00, 0x00, 0x00, 0x07, 0x44, 0x49, 0x53, 0x50,
+  0x4c, 0x41, 0x59, 0x00, 0x00, 0x00, 0x04, 0x78, 0x73, 0x65, 0x6c, 0x00,
+  0x00, 0x00, 0x19, 0x78, 0x73, 0x65, 0x6c, 0x20, 0x2d, 0x2d, 0x63, 0x6c,
+  0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x20, 0x2d, 0x2d, 0x6f, 0x75,
+  0x74, 0x70, 0x75, 0x74, 0x00, 0x00, 0x00, 0x05, 0x78, 0x63, 0x6c, 0x69,
+  0x70, 0x00, 0x00, 0x00, 0x1d, 0x78, 0x63, 0x6c, 0x69, 0x70, 0x20, 0x2d,
+  0x73, 0x65, 0x6c, 0x65, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x63, 0x6c,
+  0x69, 0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x20, 0x2d, 0x6f, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x09, 0x00, 0x03, 0x40, 0x6f, 0x73, 0x00, 0x00,
+  0x07, 0x77, 0x69, 0x6e, 0x64, 0x6f, 0x77, 0x73, 0x00, 0x00, 0x01, 0x60,
+  0x00, 0x00, 0x03, 0x6d, 0x61, 0x63, 0x00, 0x00, 0x05, 0x6c, 0x69, 0x6e,
+  0x75, 0x78, 0x00, 0x00, 0x03, 0x45, 0x4e, 0x56, 0x00, 0x00, 0x08, 0x64,
+  0x6f, 0x77, 0x6e, 0x63, 0x61, 0x73, 0x65, 0x00, 0x00, 0x0f, 0x63, 0x6f,
+  0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f, 0x65, 0x78, 0x69, 0x73, 0x74, 0x73,
+  0x3f, 0x00, 0x00, 0x05, 0x40, 0x63, 0x6c, 0x69, 0x70, 0x00, 0x00, 0x00,
+  0x00, 0x60, 0x00, 0x04, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x27, 0x39, 0x04, 0x00, 0x00, 0x01, 0x04, 0x01, 0x52, 0x04, 0x01,
+  0x5c, 0x05, 0x00, 0x32, 0x04, 0x00, 0x01, 0x01, 0x03, 0x04, 0x5c, 0x05,
+  0x01, 0x01, 0x06, 0x03, 0x5d, 0x05, 0x5c, 0x06, 0x02, 0x5d, 0x05, 0x2f,
+  0x04, 0x01, 0x01, 0x3d, 0x01, 0x00, 0x03, 0x00, 0x00, 0x02, 0x6d, 0x30,
+  0x00, 0x00, 0x00, 0x07, 0x1b, 0x5d, 0x35, 0x32, 0x3b, 0x63, 0x3b, 0x00,
+  0x00, 0x00, 0x01, 0x07, 0x00, 0x00, 0x02, 0x00, 0x04, 0x70, 0x61, 0x63,
+  0x6b, 0x00, 0x00, 0x05, 0x70, 0x72, 0x69, 0x6e, 0x74, 0x00, 0x00, 0x00,
+  0x0f, 0xc7, 0x00, 0x01, 0x00, 0x4c, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+  0x07, 0xa8, 0x5c, 0x01, 0x00, 0x5c, 0x02, 0x01, 0x5c, 0x03, 0x02, 0x5c,
+  0x04, 0x03, 0x5c, 0x05, 0x04, 0x5c, 0x06, 0x05, 0x5c, 0x07, 0x06, 0x5c,
+  0x08, 0x07, 0x52, 0x02, 0x07, 0x5c, 0x03, 0x08, 0x52, 0x04, 0x00, 0x5c,
+  0x05, 0x09, 0x5c, 0x06, 0x0a, 0x52, 0x06, 0x01, 0x5c, 0x07, 0x0b, 0x5c,
+  0x08, 0x0c, 0x52, 0x08, 0x01, 0x5c, 0x09, 0x0d, 0x5c, 0x0a, 0x0e, 0x52,
+  0x0a, 0x01, 0x5c, 0x0b, 0x0f, 0x5c, 0x0c, 0x0e, 0x52, 0x0c, 0x01, 0x5c,
+  0x0d, 0x10, 0x5c, 0x0e, 0x0c, 0x52, 0x0e, 0x01, 0x5c, 0x0f, 0x11, 0x5c,
+  0x10, 0x12, 0x52, 0x10, 0x01, 0x5c, 0x11, 0x13, 0x5c, 0x12, 0x14, 0x52,
+  0x12, 0x01, 0x5c, 0x13, 0x15, 0x5c, 0x14, 0x0e, 0x52, 0x14, 0x01, 0x5c,
+  0x15, 0x16, 0x5c, 0x16, 0x0e, 0x52, 0x16, 0x01, 0x5c, 0x17, 0x17, 0x52,
+  0x18, 0x00, 0x5c, 0x19, 0x18, 0x5c, 0x1a, 0x0e, 0x52, 0x1a, 0x01, 0x5c,
+  0x1b, 0x19, 0x52, 0x1c, 0x00, 0x5c, 0x1d, 0x1a, 0x5c, 0x1e, 0x0e, 0x52,
+  0x1e, 0x01, 0x5c, 0x1f, 0x1b, 0x5c, 0x20, 0x1c, 0x52, 0x20, 0x01, 0x5c,
+  0x21, 0x1d, 0x52, 0x22, 0x00, 0x5c, 0x23, 0x1e, 0x5c, 0x24, 0x14, 0x5c,
+  0x25, 0x0a, 0x52, 0x24, 0x02, 0x5c, 0x25, 0x1f, 0x5c, 0x26, 0x0e, 0x52,
+  0x26, 0x01, 0x5c, 0x27, 0x20, 0x5c, 0x28, 0x12, 0x52, 0x28, 0x01, 0x5c,
+  0x29, 0x21, 0x52, 0x2a, 0x00, 0x5c, 0x2b, 0x22, 0x5c, 0x2c, 0x23, 0x5c,
+  0x2d, 0x24, 0x5c, 0x2e, 0x0a, 0x52, 0x2c, 0x03, 0x5e, 0x01, 0x16, 0x1a,
+  0x01, 0x00, 0x10, 0x01, 0x01, 0x10, 0x02, 0x02, 0x0f, 0x03, 0x00, 0x55,
+  0x55, 0x55, 0x10, 0x04, 0x03, 0x5c, 0x05, 0x25, 0x10, 0x06, 0x04, 0x5c,
+  0x07, 0x26, 0x52, 0x07, 0x01, 0x10, 0x08, 0x05, 0x5c, 0x09, 0x00, 0x5e,
+  0x02, 0x04, 0x10, 0x03, 0x06, 0x10, 0x04, 0x02, 0x0e, 0x05, 0x59, 0x9c,
+  0x10, 0x06, 0x03, 0x5c, 0x07, 0x27, 0x10, 0x08, 0x04, 0x5c, 0x09, 0x28,
+  0x5c, 0x0a, 0x29, 0x5c, 0x0b, 0x2a, 0x52, 0x09, 0x03, 0x10, 0x0a, 0x05,
+  0x5c, 0x0b, 0x00, 0x5e, 0x04, 0x04, 0x10, 0x05, 0x07, 0x10, 0x06, 0x02,
+  0x0f, 0x07, 0x00, 0xa8, 0xb9, 0xcc, 0x10, 0x08, 0x03, 0x5c, 0x09, 0x2b,
+  0x10, 0x0a, 0x04, 0x5c, 0x0b, 0x2c, 0x5c, 0x0c, 0x2d, 0x52, 0x0b, 0x02,
+  0x10, 0x0c, 0x05, 0x5c, 0x0d, 0x00, 0x5e, 0x06, 0x04, 0x10, 0x07, 0x08,
+  0x10, 0x08, 0x02, 0x0f, 0x09, 0x00, 0x36, 0xa3, 0xd9, 0x10, 0x0a, 0x03,
+  0x5c, 0x0b, 0x2e, 0x10, 0x0c, 0x04, 0x5c, 0x0d, 0x2f, 0x52, 0x0d, 0x01,
+  0x10, 0x0e, 0x05, 0x5c, 0x0f, 0x0d, 0x5e, 0x08, 0x04, 0x10, 0x09, 0x09,
+  0x10, 0x0a, 0x02, 0x0f, 0x0b, 0x00, 0x4d, 0x5a, 0x5e, 0x10, 0x0c, 0x03,
+  0x5c, 0x0d, 0x30, 0x10, 0x0e, 0x04, 0x5c, 0x0f, 0x31, 0x52, 0x0f, 0x01,
+  0x10, 0x10, 0x05, 0x5c, 0x11, 0x10, 0x5e, 0x0a, 0x04, 0x10, 0x0b, 0x0a,
+  0x10, 0x0c, 0x02, 0x0f, 0x0d, 0x00, 0x00, 0xad, 0xd8, 0x10, 0x0e, 0x03,
+  0x5c, 0x0f, 0x32, 0x10, 0x10, 0x04, 0x5c, 0x11, 0x33, 0x52, 0x11, 0x01,
+  0x10, 0x12, 0x05, 0x5c, 0x13, 0x11, 0x5e, 0x0c, 0x04, 0x10, 0x0d, 0x0b,
+  0x10, 0x0e, 0x02, 0x0f, 0x0f, 0x00, 0x00, 0xad, 0xd8, 0x10, 0x10, 0x03,
+  0x5c, 0x11, 0x32, 0x10, 0x12, 0x04, 0x5c, 0x13, 0x34, 0x52, 0x13, 0x01,
+  0x10, 0x14, 0x05, 0x5c, 0x15, 0x11, 0x5e, 0x0e, 0x04, 0x10, 0x0f, 0x0c,
+  0x10, 0x10, 0x02, 0x0f, 0x11, 0x00, 0xa0, 0x74, 0xc4, 0x10, 0x12, 0x03,
+  0x5c, 0x13, 0x35, 0x10, 0x14, 0x04, 0x5c, 0x15, 0x36, 0x5c, 0x16, 0x37,
+  0x52, 0x15, 0x02, 0x10, 0x16, 0x05, 0x5c, 0x17, 0x13, 0x5e, 0x10, 0x04,
+  0x10, 0x11, 0x0d, 0x10, 0x12, 0x02, 0x0f, 0x13, 0x00, 0xef, 0x8a, 0x91,
+  0x10, 0x14, 0x03, 0x5c, 0x15, 0x38, 0x10, 0x16, 0x04, 0x5c, 0x17, 0x39,
+  0x5c, 0x18, 0x3a, 0x52, 0x17, 0x02, 0x10, 0x18, 0x05, 0x5c, 0x19, 0x15,
+  0x5e, 0x12, 0x04, 0x10, 0x13, 0x0e, 0x10, 0x14, 0x02, 0x0f, 0x15, 0x00,
+  0xf0, 0xdf, 0x8a, 0x10, 0x16, 0x03, 0x5c, 0x17, 0x3b, 0x10, 0x18, 0x04,
+  0x5c, 0x19, 0x3c, 0x52, 0x19, 0x01, 0x10, 0x1a, 0x05, 0x5c, 0x1b, 0x16,
+  0x5e, 0x14, 0x04, 0x10, 0x15, 0x0f, 0x10, 0x16, 0x02, 0x0f, 0x17, 0x00,
+  0x36, 0xa3, 0xd9, 0x10, 0x18, 0x03, 0x5c, 0x19, 0x3d, 0x10, 0x1a, 0x04,
+  0x5c, 0x1b, 0x3e, 0x52, 0x1b, 0x01, 0x10, 0x1c, 0x05, 0x5c, 0x1d, 0x16,
+  0x5e, 0x16, 0x04, 0x10, 0x17, 0x10, 0x10, 0x18, 0x02, 0x0f, 0x19, 0x00,
+  0xcb, 0xcb, 0x41, 0x10, 0x1a, 0x03, 0x5c, 0x1b, 0x3f, 0x10, 0x1c, 0x04,
+  0x5c, 0x1d, 0x40, 0x52, 0x1d, 0x01, 0x10, 0x1e, 0x05, 0x5c, 0x1f, 0x0f,
+  0x5e, 0x18, 0x04, 0x10, 0x19, 0x11, 0x10, 0x1a, 0x02, 0x0f, 0x1b, 0x00,
+  0xcb, 0xcb, 0x41, 0x10, 0x1c, 0x03, 0x5c, 0x1d, 0x3f, 0x10, 0x1e, 0x04,
+  0x5c, 0x1f, 0x41, 0x52, 0x1f, 0x01, 0x10, 0x20, 0x05, 0x5c, 0x21, 0x0f,
+  0x5e, 0x1a, 0x04, 0x10, 0x1b, 0x12, 0x10, 0x1c, 0x02, 0x0f, 0x1d, 0x00,
+  0x6e, 0x15, 0x16, 0x10, 0x1e, 0x03, 0x5c, 0x1f, 0x38, 0x10, 0x20, 0x04,
+  0x5c, 0x21, 0x42, 0x52, 0x21, 0x01, 0x10, 0x22, 0x05, 0x5c, 0x23, 0x08,
+  0x5e, 0x1c, 0x04, 0x10, 0x1d, 0x13, 0x10, 0x1e, 0x02, 0x0f, 0x1f, 0x00,
+  0x36, 0xa3, 0xd9, 0x10, 0x20, 0x03, 0x5c, 0x21, 0x43, 0x10, 0x22, 0x04,
+  0x5c, 0x23, 0x44, 0x52, 0x23, 0x01, 0x10, 0x24, 0x05, 0x5c, 0x25, 0x17,
+  0x5e, 0x1e, 0x04, 0x10, 0x1f, 0x14, 0x10, 0x20, 0x02, 0x0f, 0x21, 0x00,
+  0x95, 0xe6, 0xcb, 0x10, 0x22, 0x03, 0x5c, 0x23, 0x45, 0x10, 0x24, 0x04,
+  0x5c, 0x25, 0x46, 0x52, 0x25, 0x01, 0x10, 0x26, 0x05, 0x5c, 0x27, 0x47,
+  0x5e, 0x20, 0x04, 0x10, 0x21, 0x15, 0x10, 0x22, 0x02, 0x0f, 0x23, 0x00,
+  0xde, 0xa5, 0x84, 0x10, 0x24, 0x03, 0x5c, 0x25, 0x48, 0x10, 0x26, 0x04,
+  0x5c, 0x27, 0x49, 0x52, 0x27, 0x01, 0x10, 0x28, 0x05, 0x5c, 0x29, 0x19,
+  0x5e, 0x22, 0x04, 0x10, 0x23, 0x16, 0x10, 0x24, 0x02, 0x0f, 0x25, 0x00,
+  0xa0, 0x74, 0xc4, 0x10, 0x26, 0x03, 0x5c, 0x27, 0x4a, 0x10, 0x28, 0x04,
+  0x5c, 0x29, 0x4b, 0x52, 0x29, 0x01, 0x10, 0x2a, 0x05, 0x5c, 0x2b, 0x1a,
+  0x5e, 0x24, 0x04, 0x10, 0x25, 0x17, 0x10, 0x26, 0x02, 0x0f, 0x27, 0x00,
+  0x36, 0xa3, 0xd9, 0x10, 0x28, 0x03, 0x5c, 0x29, 0x4c, 0x10, 0x2a, 0x04,
+  0x5c, 0x2b, 0x4d, 0x5c, 0x2c, 0x4e, 0x52, 0x2b, 0x02, 0x10, 0x2c, 0x05,
+  0x5c, 0x2d, 0x1b, 0x5e, 0x26, 0x04, 0x10, 0x27, 0x18, 0x10, 0x28, 0x02,
+  0x0f, 0x29, 0x00, 0x6d, 0x80, 0x86, 0x10, 0x2a, 0x03, 0x5c, 0x2b, 0x4f,
+  0x10, 0x2c, 0x04, 0x5c, 0x2d, 0x50, 0x52, 0x2d, 0x01, 0x10, 0x2e, 0x05,
+  0x5c, 0x2f, 0x1d, 0x5e, 0x28, 0x04, 0x10, 0x29, 0x19, 0x10, 0x2a, 0x02,
+  0x0f, 0x2b, 0x00, 0x36, 0xa3, 0xd9, 0x10, 0x2c, 0x03, 0x5c, 0x2d, 0x51,
+  0x10, 0x2e, 0x04, 0x5c, 0x2f, 0x52, 0x52, 0x2f, 0x01, 0x10, 0x30, 0x05,
+  0x5c, 0x31, 0x1e, 0x5e, 0x2a, 0x04, 0x10, 0x2b, 0x1a, 0x10, 0x2c, 0x02,
+  0x0f, 0x2d, 0x00, 0x6d, 0x80, 0x86, 0x10, 0x2e, 0x03, 0x5c, 0x2f, 0x4f,
+  0x10, 0x30, 0x04, 0x5c, 0x31, 0x53, 0x5c, 0x32, 0x54, 0x52, 0x31, 0x02,
+  0x10, 0x32, 0x05, 0x5c, 0x33, 0x1f, 0x5e, 0x2c, 0x04, 0x10, 0x2d, 0x1b,
+  0x10, 0x2e, 0x02, 0x0f, 0x2f, 0x00, 0xda, 0xd8, 0xd8, 0x10, 0x30, 0x03,
+  0x5c, 0x31, 0x55, 0x10, 0x32, 0x04, 0x5c, 0x33, 0x56, 0x52, 0x33, 0x01,
+  0x10, 0x34, 0x05, 0x5c, 0x35, 0x20, 0x5e, 0x2e, 0x04, 0x10, 0x2f, 0x1c,
+  0x10, 0x30, 0x02, 0x0f, 0x31, 0x00, 0x4e, 0x5c, 0x61, 0x10, 0x32, 0x03,
+  0x5c, 0x33, 0x57, 0x10, 0x34, 0x04, 0x5c, 0x35, 0x58, 0x5c, 0x36, 0x59,
+  0x52, 0x35, 0x02, 0x10, 0x36, 0x05, 0x5c, 0x37, 0x21, 0x5e, 0x30, 0x04,
+  0x10, 0x31, 0x1d, 0x10, 0x32, 0x02, 0x0f, 0x33, 0x00, 0x6d, 0x80, 0x86,
+  0x10, 0x34, 0x03, 0x5c, 0x35, 0x5a, 0x10, 0x36, 0x04, 0x5c, 0x37, 0x5b,
+  0x52, 0x37, 0x01, 0x5e, 0x32, 0x03, 0x10, 0x33, 0x1e, 0x10, 0x34, 0x02,
+  0x0f, 0x35, 0x00, 0xda, 0xd8, 0xd8, 0x10, 0x36, 0x03, 0x5c, 0x37, 0x5c,
+  0x10, 0x38, 0x04, 0x5c, 0x39, 0x5d, 0x52, 0x39, 0x01, 0x5e, 0x34, 0x03,
+  0x10, 0x35, 0x1f, 0x10, 0x36, 0x02, 0x0f, 0x37, 0x00, 0xdd, 0x4c, 0x35,
+  0x10, 0x38, 0x03, 0x5c, 0x39, 0x5e, 0x10, 0x3a, 0x04, 0x5c, 0x3b, 0x5f,
+  0x5c, 0x3c, 0x60, 0x52, 0x3b, 0x02, 0x5e, 0x36, 0x03, 0x10, 0x37, 0x20,
+  0x10, 0x38, 0x02, 0x0f, 0x39, 0x00, 0xf0, 0x50, 0x32, 0x10, 0x3a, 0x03,
+  0x5c, 0x3b, 0x61, 0x10, 0x3c, 0x04, 0x5c, 0x3d, 0x62, 0x52, 0x3d, 0x01,
+  0x5e, 0x38, 0x03, 0x10, 0x39, 0x21, 0x10, 0x3a, 0x02, 0x0f, 0x3b, 0x00,
+  0xf0, 0x50, 0x32, 0x10, 0x3c, 0x03, 0x5c, 0x3d, 0x61, 0x10, 0x3e, 0x04,
+  0x5c, 0x3f, 0x63, 0x52, 0x3f, 0x01, 0x5e, 0x3a, 0x03, 0x10, 0x3b, 0x22,
+  0x10, 0x3c, 0x02, 0x0f, 0x3d, 0x00, 0x9e, 0x9e, 0x9e, 0x10, 0x3e, 0x03,
+  0x5c, 0x3f, 0x64, 0x10, 0x40, 0x04, 0x5c, 0x41, 0x65, 0x52, 0x41, 0x01,
+  0x5e, 0x3c, 0x03, 0x10, 0x3d, 0x23, 0x10, 0x3e, 0x02, 0x0f, 0x3f, 0x00,
+  0x6d, 0x80, 0x86, 0x10, 0x40, 0x03, 0x5c, 0x41, 0x4f, 0x10, 0x42, 0x04,
+  0x5c, 0x43, 0x66, 0x52, 0x43, 0x01, 0x5e, 0x3e, 0x03, 0x10, 0x3f, 0x24,
+  0x10, 0x40, 0x02, 0x0f, 0x41, 0x00, 0xff, 0x80, 0x87, 0x10, 0x42, 0x03,
+  0x5c, 0x43, 0x67, 0x10, 0x44, 0x04, 0x5c, 0x45, 0x68, 0x52, 0x45, 0x01,
+  0x10, 0x46, 0x25, 0x5c, 0x47, 0x69, 0x52, 0x47, 0x01, 0x10, 0x48, 0x05,
+  0x5c, 0x49, 0x09, 0x5e, 0x40, 0x05, 0x10, 0x41, 0x26, 0x10, 0x42, 0x02,
+  0x0f, 0x43, 0x00, 0x4d, 0x5a, 0x5e, 0x10, 0x44, 0x03, 0x5c, 0x45, 0x6a,
+  0x10, 0x46, 0x04, 0x5c, 0x47, 0x6b, 0x52, 0x47, 0x01, 0x10, 0x48, 0x25,
+  0x5c, 0x49, 0x6c, 0x5c, 0x4a, 0x6d, 0x52, 0x49, 0x02, 0x10, 0x4a, 0x05,
+  0x5c, 0x4b, 0x0b, 0x5e, 0x42, 0x05, 0x10, 0x43, 0x27, 0x10, 0x44, 0x02,
+  0x0f, 0x45, 0x00, 0x6d, 0x80, 0x86, 0x10, 0x46, 0x03, 0x5c, 0x47, 0x6e,
+  0x10, 0x48, 0x04, 0x52, 0x49, 0x00, 0x5e, 0x44, 0x03, 0x5e, 0x01, 0x22,
+  0x1a, 0x01, 0x28, 0x10, 0x01, 0x27, 0x10, 0x02, 0x29, 0x0f, 0x03, 0x00,
+  0xee, 0xee, 0xee, 0x5e, 0x02, 0x01, 0x10, 0x03, 0x2a, 0x10, 0x04, 0x29,
+  0x0f, 0x05, 0x00, 0x7d, 0xcf, 0xff, 0x5e, 0x04, 0x01, 0x10, 0x05, 0x2b,
+  0x10, 0x06, 0x29, 0x0f, 0x07, 0x00, 0xef, 0x51, 0x68, 0x5e, 0x06, 0x01,
+  0x10, 0x07, 0x2c, 0x10, 0x08, 0x29, 0x0f, 0x09, 0x00, 0xaa, 0xaa, 0xaa,
+  0x10, 0x0a, 0x2d, 0x13, 0x0b, 0x5e, 0x08, 0x02, 0x10, 0x09, 0x2e, 0x10,
+  0x0a, 0x29, 0x0f, 0x0b, 0x00, 0xaa, 0xd9, 0x4c, 0x5e, 0x0a, 0x01, 0x10,
+  0x0b, 0x2f, 0x10, 0x0c, 0x29, 0x0f, 0x0d, 0x00, 0x7d, 0xcf, 0xff, 0x5e,
+  0x0c, 0x01, 0x10, 0x0d, 0x30, 0x10, 0x0e, 0x29, 0x0f, 0x0f, 0x00, 0x7d,
+  0xcf, 0xff, 0x5e, 0x0e, 0x01, 0x10, 0x0f, 0x31, 0x10, 0x10, 0x29, 0x0f,
+  0x11, 0x00, 0xd2, 0xa6, 0xff, 0x5e, 0x10, 0x01, 0x10, 0x11, 0x32, 0x10,
+  0x12, 0x29, 0x0f, 0x13, 0x00, 0xe6, 0xc0, 0x8a, 0x5e, 0x12, 0x01, 0x10,
+  0x13, 0x33, 0x10, 0x14, 0x29, 0x0f, 0x15, 0x00, 0x7a, 0xe9, 0x3c, 0x5e,
+  0x14, 0x01, 0x10, 0x15, 0x34, 0x10, 0x16, 0x29, 0x0f, 0x17, 0x00, 0xef,
+  0x51, 0x68, 0x5e, 0x16, 0x01, 0x10, 0x17, 0x35, 0x10, 0x18, 0x29, 0x0f,
+  0x19, 0x00, 0xff, 0xaf, 0x70, 0x5e, 0x18, 0x01, 0x10, 0x19, 0x36, 0x10,
+  0x1a, 0x29, 0x0f, 0x1b, 0x00, 0xff, 0x8f, 0x40, 0x5e, 0x1a, 0x01, 0x10,
+  0x1b, 0x37, 0x10, 0x1c, 0x29, 0x0f, 0x1d, 0x00, 0xf0, 0x71, 0x78, 0x5e,
+  0x1c, 0x01, 0x10, 0x1d, 0x38, 0x10, 0x1e, 0x29, 0x0f, 0x1f, 0x00, 0xff,
+  0xff, 0xff, 0x10, 0x20, 0x2d, 0x13, 0x21, 0x5e, 0x1e, 0x02, 0x10, 0x1f,
+  0x39, 0x10, 0x20, 0x29, 0x0f, 0x21, 0x00, 0xff, 0xaf, 0x70, 0x5e, 0x20,
+  0x01, 0x10, 0x21, 0x3a, 0x10, 0x22, 0x29, 0x0f, 0x23, 0x00, 0xf0, 0x71,
+  0x78, 0x5e, 0x22, 0x01, 0x10, 0x23, 0x3b, 0x10, 0x24, 0x29, 0x0f, 0x25,
+  0x00, 0x7d, 0xcf, 0xff, 0x5e, 0x24, 0x01, 0x10, 0x25, 0x3c, 0x10, 0x26,
+  0x29, 0x0f, 0x27, 0x00, 0x95, 0xe6, 0xcb, 0x5e, 0x26, 0x01, 0x10, 0x27,
+  0x3d, 0x10, 0x28, 0x29, 0x0f, 0x29, 0x00, 0xf0, 0x71, 0x78, 0x5e, 0x28,
+  0x01, 0x10, 0x29, 0x3e, 0x10, 0x2a, 0x29, 0x0f, 0x2b, 0x00, 0x7d, 0xcf,
+  0xff, 0x5e, 0x2a, 0x01, 0x10, 0x2b, 0x3f, 0x10, 0x2c, 0x29, 0x0f, 0x2d,
+  0x00, 0xff, 0x8f, 0x40, 0x5e, 0x2c, 0x01, 0x10, 0x2d, 0x40, 0x10, 0x2e,
+  0x29, 0x0f, 0x2f, 0x00, 0xd2, 0xa6, 0xff, 0x5e, 0x2e, 0x01, 0x10, 0x2f,
+  0x41, 0x10, 0x30, 0x29, 0x0f, 0x31, 0x00, 0xd2, 0xa6, 0xff, 0x5e, 0x30,
+  0x01, 0x10, 0x31, 0x42, 0x10, 0x32, 0x29, 0x0f, 0x33, 0x00, 0xff, 0xaf,
+  0xaf, 0x5e, 0x32, 0x01, 0x10, 0x33, 0x43, 0x10, 0x34, 0x29, 0x0f, 0x35,
+  0x00, 0xff, 0xff, 0x00, 0x5e, 0x34, 0x01, 0x10, 0x35, 0x44, 0x10, 0x36,
+  0x29, 0x0f, 0x37, 0x00, 0x0f, 0xff, 0x0f, 0x5e, 0x36, 0x01, 0x10, 0x37,
+  0x45, 0x10, 0x38, 0x29, 0x0f, 0x39, 0x00, 0xff, 0x0f, 0x0f, 0x5e, 0x38,
+  0x01, 0x5e, 0x01, 0x1c, 0x1a, 0x01, 0x46, 0x10, 0x01, 0x47, 0x1a, 0x01,
+  0x48, 0x5e, 0x01, 0x00, 0x1a, 0x01, 0x49, 0x5e, 0x01, 0x00, 0x1a, 0x01,
+  0x4a, 0x5e, 0x01, 0x00, 0x1a, 0x01, 0x4b, 0x11, 0x01, 0x1a, 0x01, 0x4c,
+  0x11, 0x01, 0x1a, 0x01, 0x4d, 0x62, 0x02, 0x00, 0x31, 0x01, 0x4e, 0x00,
+  0x1a, 0x01, 0x4f, 0x62, 0x02, 0x01, 0x31, 0x01, 0x4e, 0x00, 0x1a, 0x01,
+  0x50, 0x62, 0x02, 0x02, 0x31, 0x01, 0x4e, 0x00, 0x1a, 0x01, 0x51, 0x62,
+  0x02, 0x03, 0x31, 0x01, 0x4e, 0x00, 0x1a, 0x01, 0x52, 0x12, 0x01, 0x6f,
+  0x01, 0x69, 0x01, 0x04, 0x3d, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x06, 0x63,
+  0x6c, 0x61, 0x6e, 0x67, 0x64, 0x00, 0x00, 0x00, 0x12, 0x2d, 0x2d, 0x62,
+  0x61, 0x63, 0x6b, 0x67, 0x72, 0x6f, 0x75, 0x6e, 0x64, 0x2d, 0x69, 0x6e,
+  0x64, 0x65, 0x78, 0x00, 0x00, 0x00, 0x0c, 0x2d, 0x2d, 0x63, 0x6c, 0x61,
+  0x6e, 0x67, 0x2d, 0x74, 0x69, 0x64, 0x79, 0x00, 0x00, 0x00, 0x1b, 0x2d,
+  0x2d, 0x63, 0x6f, 0x6d, 0x70, 0x6c, 0x65, 0x74, 0x69, 0x6f, 0x6e, 0x2d,
+  0x73, 0x74, 0x79, 0x6c, 0x65, 0x3d, 0x64, 0x65, 0x74, 0x61, 0x69, 0x6c,
+  0x65, 0x64, 0x00, 0x00, 0x00, 0x18, 0x2d, 0x2d, 0x68, 0x65, 0x61, 0x64,
+  0x65, 0x72, 0x2d, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x69, 0x6f, 0x6e,
+  0x3d, 0x6e, 0x65, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x14, 0x2d, 0x2d,
+  0x70, 0x63, 0x68, 0x2d, 0x73, 0x74, 0x6f, 0x72, 0x61, 0x67, 0x65, 0x3d,
+  0x6d, 0x65, 0x6d, 0x6f, 0x72, 0x79, 0x00, 0x00, 0x00, 0x12, 0x2d, 0x2d,
+  0x6c, 0x69, 0x6d, 0x69, 0x74, 0x2d, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
+  0x73, 0x3d, 0x35, 0x30, 0x00, 0x00, 0x00, 0x0b, 0x2d, 0x2d, 0x6c, 0x6f,
+  0x67, 0x3d, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x00, 0x00, 0x00, 0x08, 0x72,
+  0x75, 0x62, 0x79, 0x2d, 0x6c, 0x73, 0x70, 0x00, 0x00, 0x00, 0x0a, 0x73,
+  0x6f, 0x6c, 0x61, 0x72, 0x67, 0x72, 0x61, 0x70, 0x68, 0x00, 0x00, 0x00,
+  0x05, 0x73, 0x74, 0x64, 0x69, 0x6f, 0x00, 0x00, 0x00, 0x14, 0x62, 0x61,
+  0x73, 0x68, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2d,
+  0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x05, 0x73, 0x74,
+  0x61, 0x72, 0x74, 0x00, 0x00, 0x00, 0x1a, 0x76, 0x73, 0x63, 0x6f, 0x64,
+  0x65, 0x2d, 0x63, 0x73, 0x73, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61,
+  0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00,
+  0x07, 0x2d, 0x2d, 0x73, 0x74, 0x64, 0x69, 0x6f, 0x00, 0x00, 0x00, 0x1b,
+  0x76, 0x73, 0x63, 0x6f, 0x64, 0x65, 0x2d, 0x6a, 0x73, 0x6f, 0x6e, 0x2d,
+  0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72,
+  0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x08, 0x66, 0x69, 0x73, 0x68, 0x2d,
+  0x6c, 0x73, 0x70, 0x00, 0x00, 0x00, 0x05, 0x67, 0x6f, 0x70, 0x6c, 0x73,
+  0x00, 0x00, 0x00, 0x05, 0x73, 0x65, 0x72, 0x76, 0x65, 0x00, 0x00, 0x00,
+  0x17, 0x68, 0x61, 0x73, 0x6b, 0x65, 0x6c, 0x6c, 0x2d, 0x6c, 0x61, 0x6e,
+  0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
+  0x00, 0x00, 0x00, 0x03, 0x6c, 0x73, 0x70, 0x00, 0x00, 0x00, 0x15, 0x65,
+  0x6d, 0x6d, 0x65, 0x74, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67,
+  0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x1a,
+  0x74, 0x79, 0x70, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x2d, 0x6c,
+  0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76,
+  0x65, 0x72, 0x00, 0x00, 0x00, 0x13, 0x6c, 0x75, 0x61, 0x2d, 0x6c, 0x61,
+  0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65,
+  0x72, 0x00, 0x00, 0x00, 0x12, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74,
+  0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00,
+  0x00, 0x00, 0x0d, 0x72, 0x75, 0x73, 0x74, 0x2d, 0x61, 0x6e, 0x61, 0x6c,
+  0x79, 0x7a, 0x65, 0x72, 0x00, 0x00, 0x00, 0x0c, 0x69, 0x6e, 0x74, 0x65,
+  0x6c, 0x65, 0x70, 0x68, 0x65, 0x6e, 0x73, 0x65, 0x00, 0x00, 0x00, 0x08,
+  0x6d, 0x61, 0x72, 0x6b, 0x73, 0x6d, 0x61, 0x6e, 0x00, 0x00, 0x00, 0x06,
+  0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x15, 0x6e, 0x67,
+  0x69, 0x6e, 0x78, 0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65,
+  0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x05, 0x74,
+  0x61, 0x70, 0x6c, 0x6f, 0x00, 0x00, 0x00, 0x14, 0x79, 0x61, 0x6d, 0x6c,
+  0x2d, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65,
+  0x72, 0x76, 0x65, 0x72, 0x00, 0x00, 0x00, 0x04, 0x73, 0x71, 0x6c, 0x73,
+  0x00, 0x00, 0x00, 0x14, 0x6d, 0x61, 0x6b, 0x65, 0x2d, 0x6c, 0x61, 0x6e,
+  0x67, 0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72,
+  0x00, 0x00, 0x00, 0x13, 0x73, 0x71, 0x6c, 0x2d, 0x6c, 0x61, 0x6e, 0x67,
+  0x75, 0x61, 0x67, 0x65, 0x2d, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x00,
+  0x00, 0x00, 0x02, 0x75, 0x70, 0x00, 0x00, 0x00, 0x08, 0x2d, 0x2d, 0x6d,
+  0x65, 0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x00, 0x04, 0xee, 0x98, 0x9e,
+  0x20, 0x00, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x00, 0x04, 0xee, 0x98,
+  0x9d, 0x20, 0x00, 0x00, 0x00, 0x03, 0x63, 0x70, 0x70, 0x00, 0x00, 0x00,
+  0x02, 0x63, 0x63, 0x00, 0x00, 0x00, 0x03, 0x63, 0x78, 0x78, 0x00, 0x00,
+  0x00, 0x04, 0xef, 0x83, 0xbd, 0x20, 0x00, 0x00, 0x00, 0x01, 0x68, 0x00,
+  0x00, 0x00, 0x03, 0x68, 0x70, 0x70, 0x00, 0x00, 0x00, 0x04, 0xee, 0x9a,
+  0xb8, 0x20, 0x00, 0x00, 0x00, 0x03, 0x63, 0x73, 0x73, 0x00, 0x00, 0x00,
+  0x04, 0xee, 0xb9, 0x81, 0x20, 0x00, 0x00, 0x00, 0x04, 0x66, 0x69, 0x73,
+  0x68, 0x00, 0x00, 0x00, 0x04, 0xee, 0x98, 0xa7, 0x20, 0x00, 0x00, 0x00,
+  0x02, 0x67, 0x6f, 0x00, 0x00, 0x00, 0x03, 0x6d, 0x6f, 0x64, 0x00, 0x00,
+  0x00, 0x04, 0xee, 0x9d, 0xb7, 0x20, 0x00, 0x00, 0x00, 0x02, 0x68, 0x73,
+  0x00, 0x00, 0x00, 0x03, 0x6c, 0x68, 0x73, 0x00, 0x00, 0x00, 0x04, 0xef,
+  0x84, 0xa1, 0x20, 0x00, 0x00, 0x00, 0x04, 0x68, 0x74, 0x6d, 0x6c, 0x00,
+  0x00, 0x00, 0x03, 0x68, 0x74, 0x6d, 0x00, 0x00, 0x00, 0x04, 0xef, 0x8b,
+  0xaf, 0x20, 0x00, 0x00, 0x00, 0x02, 0x6a, 0x73, 0x00, 0x00, 0x00, 0x04,
+  0xee, 0x9a, 0x9d, 0x20, 0x00, 0x00, 0x00, 0x02, 0x74, 0x73, 0x00, 0x00,
+  0x00, 0x02, 0x7b, 0x7d, 0x00, 0x00, 0x00, 0x04, 0x6a, 0x73, 0x6f, 0x6e,
+  0x00, 0x00, 0x00, 0x05, 0x6a, 0x73, 0x6f, 0x6e, 0x63, 0x00, 0x00, 0x00,
+  0x03, 0x65, 0x72, 0x62, 0x00, 0x00, 0x00, 0x05, 0xf3, 0xb0, 0xa2, 0xb1,
+  0x20, 0x00, 0x00, 0x00, 0x03, 0x6c, 0x75, 0x61, 0x00, 0x00, 0x00, 0x05,
+  0xf3, 0xb0, 0x8c, 0xa0, 0x20, 0x00, 0x00, 0x00, 0x02, 0x70, 0x79, 0x00,
+  0x00, 0x00, 0x07, 0x70, 0x79, 0x72, 0x69, 0x67, 0x68, 0x74, 0x00, 0x00,
+  0x00, 0x05, 0xf3, 0xb1, 0x98, 0x97, 0x20, 0x00, 0x00, 0x00, 0x02, 0x72,
+  0x73, 0x00, 0x00, 0x00, 0x05, 0xf3, 0xb0, 0x8c, 0x9f, 0x20, 0x00, 0x00,
+  0x00, 0x03, 0x70, 0x68, 0x70, 0x00, 0x00, 0x00, 0x04, 0xee, 0xba, 0xab,
+  0x20, 0x00, 0x00, 0x00, 0x02, 0x6d, 0x64, 0x00, 0x00, 0x00, 0x08, 0x6d,
+  0x61, 0x72, 0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00, 0x04, 0xee,
+  0x98, 0x95, 0x20, 0x00, 0x00, 0x00, 0x04, 0x63, 0x6f, 0x6e, 0x66, 0x00,
+  0x00, 0x00, 0x04, 0xee, 0x9a, 0xb2, 0x20, 0x00, 0x00, 0x00, 0x04, 0x74,
+  0x6f, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x03, 0x79, 0x6d, 0x6c, 0x00, 0x00,
+  0x00, 0x04, 0x79, 0x61, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x04, 0xee, 0x99,
+  0x8d, 0x20, 0x00, 0x00, 0x00, 0x03, 0x73, 0x71, 0x6c, 0x00, 0x00, 0x00,
+  0x04, 0xee, 0x99, 0xb3, 0x20, 0x00, 0x00, 0x00, 0x08, 0x4d, 0x61, 0x6b,
+  0x65, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x08, 0x6d, 0x61, 0x6b,
+  0x65, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x04, 0xee, 0x99, 0x9f,
+  0x20, 0x00, 0x00, 0x00, 0x02, 0x67, 0x64, 0x00, 0x00, 0x00, 0x04, 0xef,
+  0x80, 0xad, 0x20, 0x00, 0x00, 0x00, 0x03, 0x6d, 0x61, 0x6e, 0x00, 0x00,
+  0x00, 0x04, 0xee, 0x9c, 0xa8, 0x20, 0x00, 0x00, 0x00, 0x04, 0x64, 0x69,
+  0x66, 0x66, 0x00, 0x00, 0x00, 0x05, 0x70, 0x61, 0x74, 0x63, 0x68, 0x00,
+  0x00, 0x00, 0x04, 0xee, 0x99, 0x9d, 0x20, 0x00, 0x00, 0x00, 0x0d, 0x67,
+  0x69, 0x74, 0x61, 0x74, 0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73,
+  0x00, 0x00, 0x00, 0x09, 0x67, 0x69, 0x74, 0x69, 0x67, 0x6e, 0x6f, 0x72,
+  0x65, 0x00, 0x00, 0x00, 0x02, 0x2e, 0x2a, 0x00, 0x00, 0x00, 0x05, 0x72,
+  0x65, 0x67, 0x65, 0x78, 0x00, 0x00, 0x00, 0x03, 0x69, 0x6e, 0x69, 0x00,
+  0x00, 0x00, 0x05, 0xf3, 0xb0, 0xb4, 0xad, 0x20, 0x00, 0x00, 0x00, 0x02,
+  0x72, 0x62, 0x00, 0x00, 0x00, 0x07, 0x47, 0x65, 0x6d, 0x66, 0x69, 0x6c,
+  0x65, 0x00, 0x00, 0x00, 0x04, 0xee, 0xaf, 0x8a, 0x20, 0x00, 0x00, 0x00,
+  0x02, 0x73, 0x68, 0x00, 0x00, 0x00, 0x0c, 0x62, 0x61, 0x73, 0x68, 0x5f,
+  0x70, 0x72, 0x6f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00, 0x06, 0x62,
+  0x61, 0x73, 0x68, 0x72, 0x63, 0x00, 0x00, 0x00, 0x05, 0xf3, 0xb0, 0x88,
+  0x9a, 0x20, 0x00, 0x00, 0x53, 0x00, 0x0b, 0x40, 0x6c, 0x73, 0x70, 0x5f,
+  0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00,
+  0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x00, 0x06, 0x73, 0x79, 0x6d,
+  0x62, 0x6f, 0x6c, 0x00, 0x00, 0x0a, 0x65, 0x78, 0x74, 0x65, 0x6e, 0x73,
+  0x69, 0x6f, 0x6e, 0x73, 0x00, 0x00, 0x03, 0x6c, 0x73, 0x70, 0x00, 0x00,
+  0x03, 0x63, 0x70, 0x70, 0x00, 0x00, 0x01, 0x68, 0x00, 0x00, 0x03, 0x63,
+  0x73, 0x73, 0x00, 0x00, 0x04, 0x66, 0x69, 0x73, 0x68, 0x00, 0x00, 0x02,
+  0x67, 0x6f, 0x00, 0x00, 0x05, 0x67, 0x6f, 0x6d, 0x6f, 0x64, 0x00, 0x00,
+  0x07, 0x68, 0x61, 0x73, 0x6b, 0x65, 0x6c, 0x6c, 0x00, 0x00, 0x04, 0x68,
+  0x74, 0x6d, 0x6c, 0x00, 0x00, 0x0a, 0x6a, 0x61, 0x76, 0x61, 0x73, 0x63,
+  0x72, 0x69, 0x70, 0x74, 0x00, 0x00, 0x0a, 0x74, 0x79, 0x70, 0x65, 0x73,
+  0x63, 0x72, 0x69, 0x70, 0x74, 0x00, 0x00, 0x04, 0x6a, 0x73, 0x6f, 0x6e,
+  0x00, 0x00, 0x05, 0x6a, 0x73, 0x6f, 0x6e, 0x63, 0x00, 0x00, 0x03, 0x65,
+  0x72, 0x62, 0x00, 0x00, 0x03, 0x6c, 0x75, 0x61, 0x00, 0x00, 0x06, 0x70,
+  0x79, 0x74, 0x68, 0x6f, 0x6e, 0x00, 0x00, 0x04, 0x72, 0x75, 0x73, 0x74,
+  0x00, 0x00, 0x03, 0x70, 0x68, 0x70, 0x00, 0x00, 0x08, 0x6d, 0x61, 0x72,
+  0x6b, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x05, 0x6e, 0x67, 0x69, 0x6e,
+  0x78, 0x00, 0x00, 0x04, 0x74, 0x6f, 0x6d, 0x6c, 0x00, 0x00, 0x04, 0x79,
+  0x61, 0x6d, 0x6c, 0x00, 0x00, 0x03, 0x73, 0x71, 0x6c, 0x00, 0x00, 0x04,
+  0x6d, 0x61, 0x6b, 0x65, 0x00, 0x00, 0x08, 0x67, 0x64, 0x73, 0x63, 0x72,
+  0x69, 0x70, 0x74, 0x00, 0x00, 0x03, 0x6d, 0x61, 0x6e, 0x00, 0x00, 0x04,
+  0x64, 0x69, 0x66, 0x66, 0x00, 0x00, 0x0d, 0x67, 0x69, 0x74, 0x61, 0x74,
+  0x74, 0x72, 0x69, 0x62, 0x75, 0x74, 0x65, 0x73, 0x00, 0x00, 0x09, 0x67,
+  0x69, 0x74, 0x69, 0x67, 0x6e, 0x6f, 0x72, 0x65, 0x00, 0x00, 0x05, 0x72,
+  0x65, 0x67, 0x65, 0x78, 0x00, 0x00, 0x03, 0x69, 0x6e, 0x69, 0x00, 0x00,
+  0x04, 0x72, 0x75, 0x62, 0x79, 0x00, 0x00, 0x09, 0x66, 0x69, 0x6c, 0x65,
+  0x6e, 0x61, 0x6d, 0x65, 0x73, 0x00, 0x00, 0x04, 0x62, 0x61, 0x73, 0x68,
+  0x00, 0x00, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x00,
+  0x0a, 0x40, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x00,
+  0x00, 0x02, 0x66, 0x67, 0x00, 0x00, 0x07, 0x73, 0x68, 0x65, 0x62, 0x61,
+  0x6e, 0x67, 0x00, 0x00, 0x05, 0x65, 0x72, 0x72, 0x6f, 0x72, 0x00, 0x00,
+  0x07, 0x63, 0x6f, 0x6d, 0x6d, 0x65, 0x6e, 0x74, 0x00, 0x00, 0x06, 0x69,
+  0x74, 0x61, 0x6c, 0x69, 0x63, 0x00, 0x00, 0x06, 0x73, 0x74, 0x72, 0x69,
+  0x6e, 0x67, 0x00, 0x00, 0x06, 0x65, 0x73, 0x63, 0x61, 0x70, 0x65, 0x00,
+  0x00, 0x0d, 0x69, 0x6e, 0x74, 0x65, 0x72, 0x70, 0x6f, 0x6c, 0x61, 0x74,
+  0x69, 0x6f, 0x6e, 0x00, 0x00, 0x06, 0x72, 0x65, 0x67, 0x65, 0x78, 0x70,
+  0x00, 0x00, 0x06, 0x6e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x00, 0x00, 0x04,
+  0x74, 0x72, 0x75, 0x65, 0x00, 0x00, 0x05, 0x66, 0x61, 0x6c, 0x73, 0x65,
+  0x00, 0x00, 0x04, 0x63, 0x68, 0x61, 0x72, 0x00, 0x00, 0x07, 0x6b, 0x65,
+  0x79, 0x77, 0x6f, 0x72, 0x64, 0x00, 0x00, 0x0f, 0x6b, 0x65, 0x79, 0x77,
+  0x6f, 0x72, 0x64, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x00,
+  0x00, 0x08, 0x6f, 0x70, 0x65, 0x72, 0x61, 0x74, 0x6f, 0x72, 0x00, 0x00,
+  0x08, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x04,
+  0x74, 0x79, 0x70, 0x65, 0x00, 0x00, 0x08, 0x63, 0x6f, 0x6e, 0x73, 0x74,
+  0x61, 0x6e, 0x74, 0x00, 0x00, 0x10, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62,
+  0x6c, 0x65, 0x69, 0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x00, 0x00,
+  0x0e, 0x76, 0x61, 0x72, 0x69, 0x61, 0x62, 0x6c, 0x65, 0x67, 0x6c, 0x6f,
+  0x62, 0x61, 0x6c, 0x00, 0x00, 0x0a, 0x61, 0x6e, 0x6e, 0x6f, 0x74, 0x61,
+  0x74, 0x69, 0x6f, 0x6e, 0x00, 0x00, 0x09, 0x64, 0x69, 0x72, 0x65, 0x63,
+  0x74, 0x69, 0x76, 0x65, 0x00, 0x00, 0x05, 0x6c, 0x61, 0x62, 0x65, 0x6c,
+  0x00, 0x00, 0x06, 0x62, 0x72, 0x61, 0x63, 0x65, 0x31, 0x00, 0x00, 0x06,
+  0x62, 0x72, 0x61, 0x63, 0x65, 0x32, 0x00, 0x00, 0x06, 0x62, 0x72, 0x61,
+  0x63, 0x65, 0x33, 0x00, 0x00, 0x06, 0x62, 0x72, 0x61, 0x63, 0x65, 0x34,
+  0x00, 0x00, 0x06, 0x62, 0x72, 0x61, 0x63, 0x65, 0x35, 0x00, 0x00, 0x06,
+  0x40, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x09, 0x61, 0x75, 0x74,
+  0x6f, 0x5f, 0x75, 0x6e, 0x69, 0x78, 0x00, 0x00, 0x0d, 0x40, 0x6c, 0x69,
+  0x6e, 0x65, 0x5f, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x00, 0x00,
+  0x0d, 0x40, 0x6b, 0x65, 0x79, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c, 0x65,
+  0x72, 0x73, 0x00, 0x00, 0x0a, 0x40, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x69,
+  0x6e, 0x64, 0x73, 0x00, 0x00, 0x0d, 0x40, 0x68, 0x69, 0x67, 0x68, 0x6c,
+  0x69, 0x67, 0x68, 0x74, 0x65, 0x72, 0x73, 0x00, 0x00, 0x0a, 0x40, 0x62,
+  0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x00, 0x00, 0x0b, 0x40,
+  0x62, 0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00,
+  0x04, 0x70, 0x72, 0x6f, 0x63, 0x00, 0x00, 0x06, 0x40, 0x62, 0x5f, 0x62,
+  0x61, 0x72, 0x00, 0x00, 0x07, 0x40, 0x62, 0x5f, 0x63, 0x6f, 0x70, 0x79,
+  0x00, 0x00, 0x08, 0x40, 0x62, 0x5f, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00,
+  0x00, 0x0e, 0x40, 0x62, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65,
+  0x74, 0x65, 0x63, 0x74, 0x00, 0x00, 0x00, 0x03, 0x53, 0x00, 0x09, 0x00,
+  0x14, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x19, 0x39, 0x04, 0x00,
+  0x00, 0x0f, 0x03, 0x00, 0x82, 0xaa, 0xff, 0x5c, 0x04, 0x00, 0x01, 0x09,
+  0x01, 0x10, 0x0a, 0x00, 0x23, 0x09, 0x10, 0x0a, 0x01, 0x01, 0x0b, 0x09,
+  0x32, 0x0a, 0x02, 0x01, 0x28, 0x0a, 0x00, 0x0c, 0x0f, 0x03, 0x00, 0x82,
+  0xaa, 0xff, 0x5c, 0x04, 0x01, 0x26, 0x00, 0x68, 0x10, 0x0a, 0x03, 0x01,
+  0x0b, 0x09, 0x32, 0x0a, 0x02, 0x01, 0x28, 0x0a, 0x00, 0x0c, 0x0f, 0x03,
+  0x00, 0xff, 0x8f, 0x40, 0x5c, 0x04, 0x02, 0x26, 0x00, 0x4e, 0x10, 0x0a,
+  0x04, 0x01, 0x0b, 0x09, 0x32, 0x0a, 0x02, 0x01, 0x28, 0x0a, 0x00, 0x0c,
+  0x0f, 0x03, 0x00, 0x9a, 0xde, 0x7a, 0x5c, 0x04, 0x03, 0x26, 0x00, 0x34,
+  0x10, 0x0a, 0x05, 0x01, 0x0b, 0x09, 0x32, 0x0a, 0x02, 0x01, 0x28, 0x0a,
+  0x00, 0x0c, 0x0f, 0x03, 0x00, 0xff, 0xd7, 0x00, 0x5c, 0x04, 0x04, 0x26,
+  0x00, 0x1a, 0x10, 0x0a, 0x06, 0x01, 0x0b, 0x09, 0x32, 0x0a, 0x02, 0x01,
+  0x28, 0x0a, 0x00, 0x0c, 0x0f, 0x03, 0x00, 0xf2, 0x9c, 0xc3, 0x5c, 0x04,
+  0x05, 0x26, 0x00, 0x00, 0x1d, 0x09, 0x07, 0x33, 0x09, 0x08, 0x01, 0x0a,
+  0x01, 0x10, 0x0b, 0x09, 0x23, 0x0a, 0x23, 0x09, 0x01, 0x05, 0x09, 0x01,
+  0x09, 0x05, 0x29, 0x09, 0x00, 0x03, 0x26, 0x00, 0x0e, 0x1d, 0x09, 0x07,
+  0x33, 0x09, 0x08, 0x10, 0x0a, 0x0a, 0x23, 0x09, 0x01, 0x05, 0x09, 0x1d,
+  0x09, 0x0b, 0x01, 0x0a, 0x01, 0x10, 0x0b, 0x0c, 0x23, 0x0a, 0x32, 0x09,
+  0x0d, 0x01, 0x01, 0x06, 0x09, 0x5c, 0x09, 0x06, 0x01, 0x0a, 0x04, 0x5d,
+  0x09, 0x5c, 0x0a, 0x06, 0x5d, 0x09, 0x01, 0x0a, 0x01, 0x10, 0x0b, 0x00,
+  0x23, 0x0a, 0x33, 0x0a, 0x0e, 0x33, 0x0a, 0x0f, 0x5d, 0x09, 0x5c, 0x0a,
+  0x07, 0x5d, 0x09, 0x01, 0x0a, 0x05, 0x10, 0x0b, 0x10, 0x23, 0x0a, 0x5d,
+  0x09, 0x5c, 0x0a, 0x08, 0x5d, 0x09, 0x01, 0x0a, 0x06, 0x5d, 0x09, 0x5c,
+  0x0a, 0x09, 0x5d, 0x09, 0x01, 0x07, 0x09, 0x52, 0x08, 0x00, 0x01, 0x09,
+  0x08, 0x10, 0x0a, 0x11, 0x0f, 0x0b, 0x00, 0x0b, 0x0e, 0x14, 0x10, 0x0c,
+  0x12, 0x01, 0x0d, 0x03, 0x10, 0x0e, 0x13, 0x08, 0x0f, 0x10, 0x10, 0x14,
+  0x06, 0x11, 0x10, 0x12, 0x15, 0x03, 0x13, 0x0a, 0x5e, 0x0a, 0x05, 0x32,
+  0x09, 0x16, 0x01, 0x01, 0x09, 0x08, 0x10, 0x0a, 0x11, 0x01, 0x0b, 0x03,
+  0x10, 0x0c, 0x12, 0x0f, 0x0d, 0x00, 0x33, 0x36, 0x3c, 0x10, 0x0e, 0x14,
+  0x03, 0x0f, 0x0a, 0x10, 0x10, 0x15, 0x07, 0x11, 0x5e, 0x0a, 0x04, 0x32,
+  0x09, 0x16, 0x01, 0x01, 0x09, 0x08, 0x10, 0x0a, 0x11, 0x0f, 0x0b, 0x00,
+  0x33, 0x36, 0x3c, 0x10, 0x0c, 0x12, 0x0f, 0x0d, 0x00, 0x24, 0x27, 0x2d,
+  0x10, 0x0e, 0x14, 0x03, 0x0f, 0x0b, 0x10, 0x10, 0x15, 0x07, 0x11, 0x5e,
+  0x0a, 0x04, 0x32, 0x09, 0x16, 0x01, 0x01, 0x09, 0x08, 0x10, 0x0a, 0x11,
+  0x01, 0x0b, 0x05, 0x10, 0x0c, 0x17, 0x23, 0x0b, 0x10, 0x0c, 0x12, 0x0f,
+  0x0d, 0x00, 0x24, 0x27, 0x2d, 0x10, 0x0e, 0x14, 0x03, 0x0f, 0x0d, 0x10,
+  0x10, 0x15, 0x08, 0x11, 0x5e, 0x0a, 0x04, 0x32, 0x09, 0x16, 0x01, 0x01,
+  0x09, 0x08, 0x10, 0x0a, 0x11, 0x0f, 0x0b, 0x00, 0xce, 0xd4, 0xdf, 0x10,
+  0x0c, 0x12, 0x0f, 0x0d, 0x00, 0x24, 0x27, 0x2d, 0x10, 0x0e, 0x14, 0x03,
+  0x0f, 0x0f, 0x10, 0x10, 0x15, 0x01, 0x11, 0x06, 0x33, 0x11, 0x15, 0x5e,
+  0x0a, 0x04, 0x32, 0x09, 0x16, 0x01, 0x01, 0x09, 0x08, 0x10, 0x0a, 0x11,
+  0x0f, 0x0b, 0x00, 0x24, 0x27, 0x2d, 0x10, 0x0c, 0x12, 0x06, 0x0d, 0x10,
+  0x0e, 0x14, 0x03, 0x0f, 0x0f, 0x01, 0x10, 0x06, 0x33, 0x10, 0x15, 0x45,
+  0x0f, 0x10, 0x10, 0x15, 0x07, 0x11, 0x5e, 0x0a, 0x04, 0x32, 0x09, 0x16,
+  0x01, 0x10, 0x09, 0x18, 0x01, 0x0a, 0x07, 0x10, 0x0b, 0x19, 0x01, 0x0c,
+  0x08, 0x5e, 0x09, 0x02, 0x3d, 0x09, 0x00, 0x0a, 0x00, 0x00, 0x02, 0x20,
+  0x20, 0x00, 0x00, 0x00, 0x04, 0xee, 0x99, 0x8e, 0x20, 0x00, 0x00, 0x00,
+  0x05, 0xf3, 0xb1, 0x93, 0xa7, 0x20, 0x00, 0x00, 0x00, 0x05, 0xf3, 0xb1,
+  0xa9, 0xa7, 0x20, 0x00, 0x00, 0x00, 0x04, 0xef, 0x84, 0xa0, 0x20, 0x00,
+  0x00, 0x00, 0x04, 0xee, 0xba, 0xa2, 0x20, 0x00, 0x00, 0x00, 0x01, 0x20,
+  0x00, 0x00, 0x00, 0x08, 0x20, 0xee, 0x82, 0xb4, 0xee, 0x82, 0xb4, 0x20,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0xee, 0x82, 0xb4, 0x00,
+  0x00, 0x1a, 0x00, 0x04, 0x6d, 0x6f, 0x64, 0x65, 0x00, 0x00, 0x06, 0x6e,
+  0x6f, 0x72, 0x6d, 0x61, 0x6c, 0x00, 0x00, 0x03, 0x3d, 0x3d, 0x3d, 0x00,
+  0x00, 0x06, 0x69, 0x6e, 0x73, 0x65, 0x72, 0x74, 0x00, 0x00, 0x06, 0x73,
+  0x65, 0x6c, 0x65, 0x63, 0x74, 0x00, 0x00, 0x06, 0x72, 0x75, 0x6e, 0x6e,
+  0x65, 0x72, 0x00, 0x00, 0x06, 0x6a, 0x75, 0x6d, 0x70, 0x65, 0x72, 0x00,
+  0x00, 0x01, 0x43, 0x00, 0x00, 0x09, 0x6c, 0x61, 0x6e, 0x67, 0x75, 0x61,
+  0x67, 0x65, 0x73, 0x00, 0x00, 0x09, 0x6c, 0x61, 0x6e, 0x67, 0x5f, 0x6e,
+  0x61, 0x6d, 0x65, 0x00, 0x00, 0x07, 0x64, 0x65, 0x66, 0x61, 0x75, 0x6c,
+  0x74, 0x00, 0x00, 0x04, 0x46, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x08, 0x66,
+  0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x08, 0x62, 0x61,
+  0x73, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x04, 0x74, 0x6f, 0x5f,
+  0x73, 0x00, 0x00, 0x06, 0x75, 0x70, 0x63, 0x61, 0x73, 0x65, 0x00, 0x00,
+  0x06, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x00, 0x00, 0x02, 0x66, 0x67,
+  0x00, 0x00, 0x02, 0x62, 0x67, 0x00, 0x00, 0x05, 0x66, 0x6c, 0x61, 0x67,
+  0x73, 0x00, 0x00, 0x05, 0x73, 0x74, 0x61, 0x72, 0x74, 0x00, 0x00, 0x06,
+  0x6c, 0x65, 0x6e, 0x67, 0x74, 0x68, 0x00, 0x00, 0x02, 0x3c, 0x3c, 0x00,
+  0x00, 0x05, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x00, 0x04, 0x74, 0x65,
+  0x78, 0x74, 0x00, 0x00, 0x0a, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67,
+  0x68, 0x74, 0x73, 0x00, 0x00, 0x00, 0x00, 0x37, 0x00, 0x03, 0x00, 0x06,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x39, 0x04, 0x00, 0x00,
+  0x1d, 0x03, 0x00, 0x01, 0x04, 0x01, 0x32, 0x03, 0x01, 0x01, 0x3d, 0x03,
+  0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x43, 0x6c, 0x69, 0x70, 0x62, 0x6f,
+  0x61, 0x72, 0x64, 0x00, 0x00, 0x04, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00,
+  0x00, 0x00, 0x34, 0x00, 0x02, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x0c, 0x39, 0x00, 0x00, 0x00, 0x1d, 0x02, 0x00, 0x33, 0x02,
+  0x01, 0x3d, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x09, 0x43, 0x6c, 0x69,
+  0x70, 0x62, 0x6f, 0x61, 0x72, 0x64, 0x00, 0x00, 0x05, 0x70, 0x61, 0x73,
+  0x74, 0x65, 0x00, 0x00, 0x00, 0x03, 0x97, 0x00, 0x07, 0x00, 0x0b, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x1c, 0x39, 0x04, 0x00, 0x00, 0x10,
+  0x03, 0x00, 0x1d, 0x07, 0x01, 0x01, 0x08, 0x01, 0x32, 0x07, 0x02, 0x01,
+  0x27, 0x07, 0x00, 0x02, 0x3d, 0x03, 0x1d, 0x07, 0x01, 0x01, 0x08, 0x01,
+  0x10, 0x09, 0x03, 0x34, 0x07, 0x04, 0x01, 0x33, 0x07, 0x05, 0x01, 0x04,
+  0x07, 0x01, 0x07, 0x04, 0x5c, 0x08, 0x00, 0x32, 0x07, 0x06, 0x01, 0x28,
+  0x07, 0x00, 0xc7, 0x01, 0x07, 0x04, 0x08, 0x08, 0x11, 0x09, 0x64, 0x08,
+  0x23, 0x07, 0x33, 0x07, 0x07, 0x01, 0x05, 0x07, 0x01, 0x07, 0x05, 0x66,
+  0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x01, 0x32, 0x08, 0x09, 0x01, 0x01,
+  0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x27, 0x08, 0x00, 0x17, 0x66, 0x08,
+  0x1f, 0x08, 0x08, 0x5c, 0x09, 0x02, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09,
+  0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x0b,
+  0x26, 0x00, 0x7a, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x03, 0x32,
+  0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08,
+  0x00, 0x06, 0x10, 0x08, 0x0c, 0x26, 0x00, 0x5d, 0x66, 0x08, 0x1f, 0x08,
+  0x08, 0x5c, 0x09, 0x04, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32,
+  0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x0d, 0x26, 0x00,
+  0x40, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x05, 0x32, 0x08, 0x09,
+  0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06,
+  0x10, 0x08, 0x0e, 0x26, 0x00, 0x23, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c,
+  0x09, 0x06, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a,
+  0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x0f, 0x26, 0x00, 0x06, 0x10,
+  0x08, 0x00, 0x26, 0x00, 0x00, 0x01, 0x03, 0x08, 0x3d, 0x03, 0x5c, 0x08,
+  0x07, 0x2f, 0x07, 0x10, 0x01, 0x33, 0x07, 0x11, 0x28, 0x07, 0x00, 0x02,
+  0x3d, 0x03, 0x5c, 0x08, 0x08, 0x01, 0x09, 0x01, 0x5d, 0x08, 0x5c, 0x09,
+  0x09, 0x5d, 0x08, 0x2f, 0x07, 0x12, 0x01, 0x33, 0x07, 0x05, 0x01, 0x06,
+  0x07, 0x01, 0x07, 0x06, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x0a,
+  0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28,
+  0x08, 0x00, 0x06, 0x10, 0x08, 0x0b, 0x26, 0x00, 0xd1, 0x66, 0x08, 0x1f,
+  0x08, 0x08, 0x5c, 0x09, 0x05, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07,
+  0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x0e, 0x26,
+  0x00, 0xb4, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x0b, 0x32, 0x08,
+  0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00,
+  0x06, 0x10, 0x08, 0x13, 0x26, 0x00, 0x97, 0x66, 0x08, 0x1f, 0x08, 0x08,
+  0x5c, 0x09, 0x0c, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08,
+  0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x14, 0x26, 0x00, 0x7a,
+  0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x04, 0x32, 0x08, 0x09, 0x01,
+  0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10,
+  0x08, 0x0d, 0x26, 0x00, 0x5d, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09,
+  0x0d, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01,
+  0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x15, 0x26, 0x00, 0x40, 0x66, 0x08,
+  0x1f, 0x08, 0x08, 0x5c, 0x09, 0x0e, 0x32, 0x08, 0x09, 0x01, 0x01, 0x09,
+  0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08, 0x00, 0x06, 0x10, 0x08, 0x16,
+  0x26, 0x00, 0x23, 0x66, 0x08, 0x1f, 0x08, 0x08, 0x5c, 0x09, 0x0f, 0x32,
+  0x08, 0x09, 0x01, 0x01, 0x09, 0x07, 0x32, 0x08, 0x0a, 0x01, 0x28, 0x08,
+  0x00, 0x06, 0x10, 0x08, 0x17, 0x26, 0x00, 0x06, 0x10, 0x08, 0x00, 0x26,
+  0x00, 0x00, 0x01, 0x03, 0x08, 0x3d, 0x03, 0x00, 0x10, 0x00, 0x00, 0x02,
+  0x23, 0x21, 0x00, 0x00, 0x00, 0x04, 0x62, 0x61, 0x73, 0x68, 0x00, 0x00,
+  0x00, 0x02, 0x73, 0x68, 0x00, 0x00, 0x00, 0x04, 0x66, 0x69, 0x73, 0x68,
+  0x00, 0x00, 0x00, 0x06, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e, 0x00, 0x00,
+  0x00, 0x04, 0x72, 0x75, 0x62, 0x79, 0x00, 0x00, 0x00, 0x03, 0x6c, 0x75,
+  0x61, 0x00, 0x00, 0x00, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x00,
+  0x14, 0x66, 0x69, 0x6c, 0x65, 0x20, 0x2d, 0x2d, 0x6d, 0x69, 0x6d, 0x65,
+  0x2d, 0x74, 0x79, 0x70, 0x65, 0x20, 0x2d, 0x62, 0x20, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0b, 0x73, 0x68, 0x65, 0x6c, 0x6c, 0x73, 0x63,
+  0x72, 0x69, 0x70, 0x74, 0x00, 0x00, 0x00, 0x04, 0x64, 0x69, 0x66, 0x66,
+  0x00, 0x00, 0x00, 0x04, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x00, 0x00, 0x0a,
+  0x6a, 0x61, 0x76, 0x61, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x00, 0x00,
+  0x00, 0x08, 0x6d, 0x61, 0x6b, 0x65, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00,
+  0x00, 0x03, 0x2d, 0x63, 0x24, 0x00, 0x00, 0x18, 0x00, 0x07, 0x64, 0x65,
+  0x66, 0x61, 0x75, 0x6c, 0x74, 0x00, 0x00, 0x04, 0x46, 0x69, 0x6c, 0x65,
+  0x00, 0x00, 0x06, 0x65, 0x78, 0x69, 0x73, 0x74, 0x3f, 0x00, 0x00, 0x08,
+  0x72, 0x65, 0x61, 0x64, 0x6c, 0x69, 0x6e, 0x65, 0x00, 0x00, 0x04, 0x6f,
+  0x70, 0x65, 0x6e, 0x00, 0x00, 0x05, 0x63, 0x68, 0x6f, 0x6d, 0x70, 0x00,
+  0x00, 0x0b, 0x73, 0x74, 0x61, 0x72, 0x74, 0x5f, 0x77, 0x69, 0x74, 0x68,
+  0x3f, 0x00, 0x00, 0x08, 0x64, 0x6f, 0x77, 0x6e, 0x63, 0x61, 0x73, 0x65,
+  0x00, 0x00, 0x06, 0x52, 0x65, 0x67, 0x65, 0x78, 0x70, 0x00, 0x00, 0x07,
+  0x63, 0x6f, 0x6d, 0x70, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x03, 0x3d, 0x3d,
+  0x3d, 0x00, 0x00, 0x04, 0x62, 0x61, 0x73, 0x68, 0x00, 0x00, 0x04, 0x66,
+  0x69, 0x73, 0x68, 0x00, 0x00, 0x06, 0x70, 0x79, 0x74, 0x68, 0x6f, 0x6e,
+  0x00, 0x00, 0x04, 0x72, 0x75, 0x62, 0x79, 0x00, 0x00, 0x03, 0x6c, 0x75,
+  0x61, 0x00, 0x00, 0x0f, 0x63, 0x6f, 0x6d, 0x6d, 0x61, 0x6e, 0x64, 0x5f,
+  0x65, 0x78, 0x69, 0x73, 0x74, 0x73, 0x3f, 0x00, 0x00, 0x01, 0x21, 0x00,
+  0x00, 0x01, 0x60, 0x00, 0x00, 0x04, 0x64, 0x69, 0x66, 0x66, 0x00, 0x00,
+  0x04, 0x68, 0x74, 0x6d, 0x6c, 0x00, 0x00, 0x0a, 0x6a, 0x61, 0x76, 0x61,
+  0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x00, 0x00, 0x08, 0x6d, 0x61, 0x6b,
+  0x65, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x01, 0x63, 0x00, 0x00, 0x00,
+  0x01, 0x6b, 0x00, 0x01, 0x00, 0x0a, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x4e, 0x10, 0x02, 0x00, 0x10, 0x03, 0x01, 0x10, 0x04, 0x02, 0x10,
+  0x05, 0x03, 0x10, 0x06, 0x04, 0x2f, 0x01, 0x05, 0x05, 0x10, 0x02, 0x06,
+  0x10, 0x03, 0x07, 0x10, 0x04, 0x08, 0x10, 0x05, 0x09, 0x10, 0x06, 0x0a,
+  0x10, 0x07, 0x0b, 0x10, 0x08, 0x0c, 0x2f, 0x01, 0x0d, 0x07, 0x6b, 0x01,
+  0x0e, 0x00, 0x6b, 0x01, 0x0f, 0x01, 0x6b, 0x01, 0x10, 0x02, 0x6b, 0x01,
+  0x11, 0x03, 0x6b, 0x01, 0x12, 0x04, 0x6b, 0x01, 0x13, 0x05, 0x6b, 0x01,
+  0x14, 0x06, 0x6b, 0x01, 0x15, 0x07, 0x3d, 0x00, 0x00, 0x00, 0x00, 0x16,
+  0x00, 0x05, 0x74, 0x68, 0x65, 0x6d, 0x65, 0x00, 0x00, 0x0a, 0x6c, 0x73,
+  0x70, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x00, 0x00, 0x09, 0x6c,
+  0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65, 0x73, 0x00, 0x00, 0x0c, 0x6c,
+  0x69, 0x6e, 0x65, 0x5f, 0x65, 0x6e, 0x64, 0x69, 0x6e, 0x67, 0x73, 0x00,
+  0x00, 0x0c, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69, 0x67, 0x68, 0x74, 0x65,
+  0x72, 0x73, 0x00, 0x00, 0x0d, 0x61, 0x74, 0x74, 0x72, 0x5f, 0x61, 0x63,
+  0x63, 0x65, 0x73, 0x73, 0x6f, 0x72, 0x00, 0x00, 0x09, 0x62, 0x5f, 0x73,
+  0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x00, 0x00, 0x0a, 0x62, 0x5f, 0x73,
+  0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x12, 0x62, 0x5f,
+  0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x6c, 0x69,
+  0x67, 0x68, 0x74, 0x73, 0x00, 0x00, 0x05, 0x62, 0x5f, 0x62, 0x61, 0x72,
+  0x00, 0x00, 0x06, 0x62, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00, 0x07,
+  0x62, 0x5f, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x0d, 0x62, 0x5f,
+  0x66, 0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x00,
+  0x00, 0x0b, 0x61, 0x74, 0x74, 0x72, 0x5f, 0x72, 0x65, 0x61, 0x64, 0x65,
+  0x72, 0x00, 0x00, 0x04, 0x62, 0x61, 0x72, 0x3d, 0x00, 0x00, 0x07, 0x73,
+  0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x00, 0x00, 0x08, 0x73, 0x68, 0x75,
+  0x74, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x04, 0x63, 0x6f, 0x70, 0x79,
+  0x00, 0x00, 0x05, 0x70, 0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x0b, 0x66,
+  0x69, 0x6c, 0x65, 0x5f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x00, 0x00,
+  0x10, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x6c,
+  0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x00, 0x04, 0x62, 0x69, 0x6e, 0x64,
+  0x00, 0x00, 0x00, 0x00, 0x2c, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x0f, 0x39, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01,
+  0x01, 0x03, 0x02, 0x1a, 0x03, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01,
+  0x00, 0x06, 0x40, 0x62, 0x5f, 0x62, 0x61, 0x72, 0x00, 0x00, 0x00, 0x00,
+  0x30, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x39, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x1a,
+  0x03, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0a, 0x40, 0x62,
+  0x5f, 0x73, 0x74, 0x61, 0x72, 0x74, 0x75, 0x70, 0x00, 0x00, 0x00, 0x00,
+  0x31, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x39, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x1a,
+  0x03, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x0b, 0x40, 0x62,
+  0x5f, 0x73, 0x68, 0x75, 0x74, 0x64, 0x6f, 0x77, 0x6e, 0x00, 0x00, 0x00,
+  0x00, 0x2d, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x0f, 0x39, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02,
+  0x1a, 0x03, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x07, 0x40,
+  0x62, 0x5f, 0x63, 0x6f, 0x70, 0x79, 0x00, 0x00, 0x00, 0x00, 0x2e, 0x00,
+  0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x39,
+  0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x1a, 0x03, 0x00,
+  0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x08, 0x40, 0x62, 0x5f, 0x70,
+  0x61, 0x73, 0x74, 0x65, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00, 0x03, 0x00,
+  0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x39, 0x00, 0x00,
+  0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x1a, 0x03, 0x00, 0x3d, 0x03,
+  0x00, 0x00, 0x00, 0x01, 0x00, 0x0e, 0x40, 0x62, 0x5f, 0x66, 0x69, 0x6c,
+  0x65, 0x5f, 0x64, 0x65, 0x74, 0x65, 0x63, 0x74, 0x00, 0x00, 0x00, 0x00,
+  0x39, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x0f, 0x39, 0x00, 0x00, 0x01, 0x01, 0x02, 0x01, 0x01, 0x03, 0x02, 0x1a,
+  0x03, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x13, 0x40, 0x62,
+  0x5f, 0x65, 0x78, 0x74, 0x72, 0x61, 0x5f, 0x68, 0x69, 0x67, 0x68, 0x6c,
+  0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x00, 0x00, 0x01, 0x43, 0x00, 0x08,
+  0x00, 0x0b, 0x00, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc1, 0x39, 0x04,
+  0x40, 0x01, 0x26, 0x00, 0x06, 0x26, 0x00, 0x05, 0x26, 0x00, 0x04, 0x11,
+  0x02, 0x11, 0x03, 0x01, 0x05, 0x04, 0x01, 0x08, 0x01, 0x1d, 0x09, 0x00,
+  0x32, 0x08, 0x01, 0x01, 0x27, 0x08, 0x00, 0x07, 0x01, 0x08, 0x01, 0x53,
+  0x01, 0x08, 0x01, 0x01, 0x08, 0x02, 0x29, 0x08, 0x00, 0x03, 0x26, 0x00,
+  0x31, 0x12, 0x06, 0x1d, 0x08, 0x02, 0x33, 0x08, 0x03, 0x01, 0x07, 0x08,
+  0x01, 0x08, 0x07, 0x10, 0x09, 0x04, 0x62, 0x0a, 0x00, 0x34, 0x08, 0x05,
+  0x01, 0x30, 0x08, 0x06, 0x28, 0x08, 0x00, 0x0d, 0x01, 0x08, 0x07, 0x01,
+  0x09, 0x05, 0x34, 0x08, 0x07, 0x00, 0x26, 0x00, 0x02, 0x11, 0x08, 0x26,
+  0x00, 0x5b, 0x30, 0x08, 0x06, 0x28, 0x08, 0x00, 0x22, 0x01, 0x08, 0x02,
+  0x1d, 0x09, 0x00, 0x32, 0x08, 0x01, 0x01, 0x27, 0x08, 0x00, 0x07, 0x01,
+  0x08, 0x02, 0x53, 0x02, 0x08, 0x01, 0x01, 0x08, 0x01, 0x62, 0x09, 0x01,
+  0x34, 0x08, 0x08, 0x00, 0x26, 0x00, 0x32, 0x01, 0x08, 0x03, 0x1d, 0x09,
+  0x09, 0x32, 0x08, 0x01, 0x01, 0x28, 0x08, 0x00, 0x22, 0x01, 0x08, 0x02,
+  0x1d, 0x09, 0x00, 0x32, 0x08, 0x01, 0x01, 0x27, 0x08, 0x00, 0x07, 0x01,
+  0x08, 0x02, 0x53, 0x02, 0x08, 0x01, 0x01, 0x08, 0x01, 0x62, 0x09, 0x02,
+  0x34, 0x08, 0x08, 0x00, 0x26, 0x00, 0x02, 0x11, 0x08, 0x3d, 0x08, 0x00,
+  0x00, 0x00, 0x0a, 0x00, 0x05, 0x41, 0x72, 0x72, 0x61, 0x79, 0x00, 0x00,
+  0x05, 0x69, 0x73, 0x5f, 0x61, 0x3f, 0x00, 0x00, 0x06, 0x4f, 0x62, 0x6a,
+  0x65, 0x63, 0x74, 0x00, 0x00, 0x03, 0x6e, 0x65, 0x77, 0x00, 0x00, 0x03,
+  0x73, 0x65, 0x74, 0x00, 0x00, 0x17, 0x64, 0x65, 0x66, 0x69, 0x6e, 0x65,
+  0x5f, 0x73, 0x69, 0x6e, 0x67, 0x6c, 0x65, 0x74, 0x6f, 0x6e, 0x5f, 0x6d,
+  0x65, 0x74, 0x68, 0x6f, 0x64, 0x00, 0x00, 0x0c, 0x62, 0x6c, 0x6f, 0x63,
+  0x6b, 0x5f, 0x67, 0x69, 0x76, 0x65, 0x6e, 0x3f, 0x00, 0x00, 0x0d, 0x69,
+  0x6e, 0x73, 0x74, 0x61, 0x6e, 0x63, 0x65, 0x5f, 0x65, 0x78, 0x65, 0x63,
+  0x00, 0x00, 0x04, 0x65, 0x61, 0x63, 0x68, 0x00, 0x00, 0x06, 0x53, 0x74,
+  0x72, 0x69, 0x6e, 0x67, 0x00, 0x00, 0x00, 0x00, 0x41, 0x00, 0x05, 0x00,
+  0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x26, 0x39, 0x04, 0x20,
+  0x01, 0x26, 0x00, 0x03, 0x26, 0x00, 0x02, 0x11, 0x02, 0x01, 0x04, 0x03,
+  0x21, 0x05, 0x06, 0x00, 0x21, 0x06, 0x01, 0x00, 0x01, 0x07, 0x01, 0x01,
+  0x08, 0x02, 0x01, 0x09, 0x04, 0x34, 0x05, 0x00, 0x03, 0x3d, 0x05, 0x00,
+  0x00, 0x00, 0x01, 0x00, 0x04, 0x62, 0x69, 0x6e, 0x64, 0x00, 0x00, 0x00,
+  0x00, 0x2c, 0x00, 0x03, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x11, 0x39, 0x04, 0x00, 0x00, 0x21, 0x03, 0x02, 0x00, 0x62, 0x04,
+  0x00, 0x34, 0x03, 0x00, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00,
+  0x04, 0x65, 0x61, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x87, 0x00, 0x03,
+  0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x39, 0x04,
+  0x00, 0x00, 0x19, 0x03, 0x00, 0x21, 0x04, 0x01, 0x00, 0x23, 0x03, 0x27,
+  0x03, 0x00, 0x0f, 0x5e, 0x03, 0x00, 0x19, 0x04, 0x00, 0x21, 0x05, 0x01,
+  0x00, 0x01, 0x06, 0x03, 0x25, 0x04, 0x19, 0x03, 0x00, 0x21, 0x04, 0x01,
+  0x00, 0x23, 0x03, 0x01, 0x04, 0x01, 0x23, 0x03, 0x27, 0x03, 0x00, 0x14,
+  0x52, 0x03, 0x00, 0x19, 0x04, 0x00, 0x21, 0x05, 0x01, 0x00, 0x23, 0x04,
+  0x01, 0x05, 0x01, 0x01, 0x06, 0x03, 0x25, 0x04, 0x19, 0x03, 0x00, 0x21,
+  0x04, 0x01, 0x00, 0x23, 0x03, 0x01, 0x04, 0x01, 0x23, 0x03, 0x21, 0x04,
+  0x05, 0x01, 0x32, 0x03, 0x01, 0x01, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x02,
+  0x00, 0x0d, 0x40, 0x6b, 0x65, 0x79, 0x5f, 0x68, 0x61, 0x6e, 0x64, 0x6c,
+  0x65, 0x72, 0x73, 0x00, 0x00, 0x02, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00,
+  0x2c, 0x00, 0x03, 0x00, 0x05, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x11, 0x39, 0x04, 0x00, 0x00, 0x21, 0x03, 0x02, 0x00, 0x62, 0x04, 0x00,
+  0x34, 0x03, 0x00, 0x00, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04,
+  0x65, 0x61, 0x63, 0x68, 0x00, 0x00, 0x00, 0x00, 0x84, 0x00, 0x03, 0x00,
+  0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x39, 0x04, 0x00,
+  0x00, 0x19, 0x03, 0x00, 0x21, 0x04, 0x01, 0x00, 0x23, 0x03, 0x27, 0x03,
+  0x00, 0x0f, 0x5e, 0x03, 0x00, 0x19, 0x04, 0x00, 0x21, 0x05, 0x01, 0x00,
+  0x01, 0x06, 0x03, 0x25, 0x04, 0x19, 0x03, 0x00, 0x21, 0x04, 0x01, 0x00,
+  0x23, 0x03, 0x01, 0x04, 0x01, 0x23, 0x03, 0x27, 0x03, 0x00, 0x14, 0x52,
+  0x03, 0x00, 0x19, 0x04, 0x00, 0x21, 0x05, 0x01, 0x00, 0x23, 0x04, 0x01,
+  0x05, 0x01, 0x01, 0x06, 0x03, 0x25, 0x04, 0x19, 0x03, 0x00, 0x21, 0x04,
+  0x01, 0x00, 0x23, 0x03, 0x01, 0x04, 0x01, 0x23, 0x03, 0x21, 0x04, 0x03,
+  0x01, 0x32, 0x03, 0x01, 0x01, 0x3d, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00,
+  0x0a, 0x40, 0x6b, 0x65, 0x79, 0x5f, 0x62, 0x69, 0x6e, 0x64, 0x73, 0x00,
+  0x00, 0x02, 0x3c, 0x3c, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, 0x01, 0x00,
+  0x02, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x6b, 0x01, 0x00,
+  0x00, 0x6b, 0x01, 0x01, 0x01, 0x3d, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00,
+  0x10, 0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x6c,
+  0x61, 0x74, 0x69, 0x76, 0x65, 0x00, 0x00, 0x04, 0x6c, 0x6f, 0x61, 0x64,
+  0x00, 0x00, 0x00, 0x01, 0x05, 0x00, 0x05, 0x00, 0x0a, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x7b, 0x39, 0x04, 0x20, 0x00, 0x26, 0x00, 0x03,
+  0x26, 0x00, 0x02, 0x11, 0x02, 0x01, 0x05, 0x01, 0x5c, 0x06, 0x00, 0x32,
+  0x05, 0x00, 0x01, 0x27, 0x05, 0x00, 0x0b, 0x01, 0x05, 0x01, 0x5c, 0x06,
+  0x00, 0x45, 0x05, 0x01, 0x01, 0x05, 0x1d, 0x05, 0x01, 0x01, 0x06, 0x01,
+  0x1d, 0x07, 0x01, 0x1d, 0x08, 0x02, 0x33, 0x08, 0x03, 0x32, 0x07, 0x04,
+  0x01, 0x32, 0x05, 0x05, 0x02, 0x01, 0x01, 0x05, 0x15, 0x05, 0x06, 0x01,
+  0x06, 0x01, 0x32, 0x05, 0x07, 0x01, 0x28, 0x05, 0x00, 0x01, 0x40, 0x15,
+  0x05, 0x06, 0x01, 0x06, 0x01, 0x32, 0x05, 0x08, 0x01, 0x1d, 0x05, 0x01,
+  0x01, 0x06, 0x01, 0x32, 0x05, 0x09, 0x01, 0x01, 0x04, 0x05, 0x01, 0x06,
+  0x04, 0x01, 0x07, 0x02, 0x27, 0x07, 0x00, 0x03, 0x30, 0x07, 0x0a, 0x01,
+  0x08, 0x01, 0x2f, 0x05, 0x0b, 0x03, 0x3d, 0x05, 0x00, 0x01, 0x00, 0x00,
+  0x03, 0x2e, 0x72, 0x62, 0x00, 0x00, 0x0c, 0x00, 0x09, 0x65, 0x6e, 0x64,
+  0x5f, 0x77, 0x69, 0x74, 0x68, 0x3f, 0x00, 0x00, 0x04, 0x46, 0x69, 0x6c,
+  0x65, 0x00, 0x00, 0x01, 0x43, 0x00, 0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x66,
+  0x69, 0x67, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x07, 0x64, 0x69,
+  0x72, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x00, 0x0b, 0x65, 0x78, 0x70, 0x61,
+  0x6e, 0x64, 0x5f, 0x70, 0x61, 0x74, 0x68, 0x00, 0x00, 0x07, 0x24, 0x4c,
+  0x4f, 0x41, 0x44, 0x45, 0x44, 0x00, 0x00, 0x08, 0x69, 0x6e, 0x63, 0x6c,
+  0x75, 0x64, 0x65, 0x3f, 0x00, 0x00, 0x02, 0x3c, 0x3c, 0x00, 0x00, 0x04,
+  0x72, 0x65, 0x61, 0x64, 0x00, 0x00, 0x07, 0x62, 0x69, 0x6e, 0x64, 0x69,
+  0x6e, 0x67, 0x00, 0x00, 0x04, 0x65, 0x76, 0x61, 0x6c, 0x00, 0x00, 0x00,
+  0x00, 0xd3, 0x00, 0x04, 0x00, 0x09, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x55, 0x39, 0x04, 0x20, 0x00, 0x26, 0x00, 0x03, 0x26, 0x00, 0x02,
+  0x11, 0x02, 0x01, 0x04, 0x01, 0x5c, 0x05, 0x00, 0x32, 0x04, 0x00, 0x01,
+  0x27, 0x04, 0x00, 0x0b, 0x01, 0x04, 0x01, 0x5c, 0x05, 0x00, 0x45, 0x04,
+  0x01, 0x01, 0x04, 0x1d, 0x04, 0x01, 0x01, 0x05, 0x01, 0x1d, 0x06, 0x01,
+  0x1d, 0x07, 0x02, 0x33, 0x07, 0x03, 0x32, 0x06, 0x04, 0x01, 0x32, 0x04,
+  0x05, 0x02, 0x01, 0x01, 0x04, 0x15, 0x04, 0x06, 0x01, 0x05, 0x01, 0x32,
+  0x04, 0x07, 0x01, 0x01, 0x05, 0x01, 0x01, 0x06, 0x02, 0x2f, 0x04, 0x08,
+  0x02, 0x3d, 0x04, 0x00, 0x01, 0x00, 0x00, 0x03, 0x2e, 0x72, 0x62, 0x00,
+  0x00, 0x09, 0x00, 0x09, 0x65, 0x6e, 0x64, 0x5f, 0x77, 0x69, 0x74, 0x68,
+  0x3f, 0x00, 0x00, 0x04, 0x46, 0x69, 0x6c, 0x65, 0x00, 0x00, 0x01, 0x43,
+  0x00, 0x00, 0x0b, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x5f, 0x66, 0x69,
+  0x6c, 0x65, 0x00, 0x00, 0x07, 0x64, 0x69, 0x72, 0x6e, 0x61, 0x6d, 0x65,
+  0x00, 0x00, 0x0b, 0x65, 0x78, 0x70, 0x61, 0x6e, 0x64, 0x5f, 0x70, 0x61,
+  0x74, 0x68, 0x00, 0x00, 0x07, 0x24, 0x4c, 0x4f, 0x41, 0x44, 0x45, 0x44,
+  0x00, 0x00, 0x06, 0x64, 0x65, 0x6c, 0x65, 0x74, 0x65, 0x00, 0x00, 0x10,
+  0x72, 0x65, 0x71, 0x75, 0x69, 0x72, 0x65, 0x5f, 0x72, 0x65, 0x6c, 0x61,
+  0x74, 0x69, 0x76, 0x65, 0x00, 0x4c, 0x56, 0x41, 0x52, 0x00, 0x00, 0x01,
+  0x78, 0x00, 0x00, 0x00, 0x1d, 0x00, 0x03, 0x63, 0x6d, 0x64, 0x00, 0x04,
+  0x74, 0x65, 0x78, 0x74, 0x00, 0x01, 0x66, 0x00, 0x07, 0x65, 0x6e, 0x63,
+  0x6f, 0x64, 0x65, 0x64, 0x00, 0x04, 0x69, 0x6e, 0x66, 0x6f, 0x00, 0x0a,
+  0x6d, 0x6f, 0x64, 0x65, 0x5f, 0x63, 0x6f, 0x6c, 0x6f, 0x72, 0x00, 0x0b,
+  0x6d, 0x6f, 0x64, 0x65, 0x5f, 0x73, 0x79, 0x6d, 0x62, 0x6f, 0x6c, 0x00,
+  0x09, 0x6c, 0x61, 0x6e, 0x67, 0x5f, 0x69, 0x6e, 0x66, 0x6f, 0x00, 0x08,
+  0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x00, 0x08, 0x73, 0x74,
+  0x61, 0x72, 0x74, 0x69, 0x6e, 0x67, 0x00, 0x0a, 0x68, 0x69, 0x67, 0x68,
+  0x6c, 0x69, 0x67, 0x68, 0x74, 0x73, 0x00, 0x04, 0x74, 0x79, 0x70, 0x65,
+  0x00, 0x0a, 0x66, 0x69, 0x72, 0x73, 0x74, 0x5f, 0x6c, 0x69, 0x6e, 0x65,
+  0x00, 0x07, 0x73, 0x68, 0x65, 0x62, 0x61, 0x6e, 0x67, 0x00, 0x08, 0x6d,
+  0x69, 0x6d, 0x65, 0x74, 0x79, 0x70, 0x65, 0x00, 0x05, 0x62, 0x6c, 0x6f,
+  0x63, 0x6b, 0x00, 0x05, 0x6d, 0x6f, 0x64, 0x65, 0x73, 0x00, 0x04, 0x6b,
+  0x65, 0x79, 0x73, 0x00, 0x06, 0x61, 0x63, 0x74, 0x69, 0x6f, 0x6e, 0x00,
+  0x03, 0x61, 0x70, 0x70, 0x00, 0x03, 0x64, 0x73, 0x6c, 0x00, 0x01, 0x6b,
+  0x00, 0x03, 0x61, 0x63, 0x74, 0x00, 0x03, 0x62, 0x6c, 0x6b, 0x00, 0x04,
+  0x6d, 0x6f, 0x64, 0x65, 0x00, 0x03, 0x6b, 0x65, 0x79, 0x00, 0x04, 0x70,
+  0x61, 0x74, 0x68, 0x00, 0x04, 0x62, 0x69, 0x6e, 0x64, 0x00, 0x04, 0x63,
+  0x6f, 0x64, 0x65, 0x00, 0x00, 0xff, 0xff, 0x00, 0x01, 0xff, 0xff, 0x00,
+  0x02, 0xff, 0xff, 0x00, 0x02, 0xff, 0xff, 0x00, 0x02, 0xff, 0xff, 0x00,
+  0x02, 0xff, 0xff, 0x00, 0x02, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0xff,
+  0xff, 0x00, 0x03, 0x00, 0x04, 0xff, 0xff, 0x00, 0x05, 0x00, 0x06, 0x00,
+  0x07, 0x00, 0x08, 0x00, 0x09, 0x00, 0x0a, 0x00, 0x01, 0xff, 0xff, 0xff,
+  0xff, 0x00, 0x08, 0xff, 0xff, 0x00, 0x0b, 0x00, 0x0c, 0x00, 0x0d, 0x00,
+  0x0e, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00,
+  0x0f, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00, 0x0f, 0xff, 0xff, 0x00,
+  0x0f, 0xff, 0xff, 0x00, 0x0f, 0x00, 0x10, 0x00, 0x11, 0x00, 0x12, 0xff,
+  0xff, 0x00, 0x0f, 0x00, 0x13, 0x00, 0x14, 0x00, 0x15, 0x00, 0x16, 0xff,
+  0xff, 0x00, 0x17, 0x00, 0x18, 0xff, 0xff, 0x00, 0x19, 0xff, 0xff, 0x00,
+  0x18, 0xff, 0xff, 0x00, 0x19, 0xff, 0xff, 0x00, 0x1a, 0x00, 0x1b, 0xff,
+  0xff, 0x00, 0x1c, 0x00, 0x1a, 0x00, 0x1b, 0xff, 0xff, 0x45, 0x4e, 0x44,
+  0x00, 0x00, 0x00, 0x00, 0x08
+};
+constexpr unsigned int _tmp___crib_precompiled_mrb_len = 11117;

include/syntax/decl.h

@@ -3,6 +3,7 @@
 
 #include "io/knot.h"
 #include "io/sysio.h"
+#include "pch.h"
 #include "syntax/trie.h"
 
 struct Highlight {
@@ -26,21 +27,6 @@ const std::unordered_map<std::string, TokenKind> kind_map = {
 #undef ADD
 };
 
-constexpr const char tokens_def[] = "module Tokens\n"
-#define STRINGIFY_HELPER(x) #x
-#define STRINGIFY(x) STRINGIFY_HELPER(x)
-#define ADD(name) "  " #name " = " STRINGIFY(__COUNTER__) "\n"
-#include "syntax/tokens.def"
-#undef ADD
-#undef STRINGIFY
-#undef STRINGIFY_HELPER
-                                    "  freeze\n"
-                                    "end";
-
-constexpr const char crib_module[] = {
-#embed "libcrib.rb"
-    , '\0'};
-
 extern std::array<Highlight, TOKEN_KIND_COUNT> highlights;
 
 struct Token {
@@ -55,9 +41,4 @@ struct LineData {
   std::shared_ptr<void> out_state{nullptr};
 };
 
-struct CustomState {
-  mrb_value state;
-  CustomState(mrb_value s) : state(s) {}
-};
-
 #endif

include/syntax/langs.h

@@ -1,6 +1,7 @@
 #ifndef SYNTAX_LANGS_H
 #define SYNTAX_LANGS_H
 
+#include "scripting/decl.h"
 #include "syntax/decl.h"
 
 #define DEF_LANG(name)                                                         \

include/syntax/line_tree.h

@@ -5,17 +5,12 @@
 
 struct LineTree {
   void clear() {
-    std::unique_lock lock(mtx);
     clear_node(root);
     root = nullptr;
     stack_size = 0;
   }
-  void build(uint32_t x) {
+  void build(uint32_t x) { root = build_node(x); }
-    std::unique_lock lock(mtx);
-    root = build_node(x);
-  }
   LineData *at(uint32_t x) {
-    std::shared_lock lock(mtx);
     LineNode *n = root;
     while (n) {
       uint32_t left_size = n->left ? n->left->size : 0;
@@ -31,7 +26,6 @@ struct LineTree {
     return nullptr;
   }
   LineData *start_iter(uint32_t x) {
-    std::shared_lock lock(mtx);
     stack_size = 0;
     LineNode *n = root;
     while (n) {
@@ -52,7 +46,6 @@ struct LineTree {
   }
   void end_iter() { stack_size = 0; }
   LineData *next() {
-    std::shared_lock lock(mtx);
     while (stack_size) {
       auto &f = stack[stack_size - 1];
       LineNode *n = f.node;
@@ -73,21 +66,16 @@ struct LineTree {
     return nullptr;
   }
   void insert(uint32_t x, uint32_t y) {
-    std::unique_lock lock(mtx);
     if (x > subtree_size(root))
       x = subtree_size(root);
     root = insert_node(root, x, y);
   }
   void erase(uint32_t x, uint32_t y) {
-    std::unique_lock lock(mtx);
     if (x + y > subtree_size(root))
       x = subtree_size(root) - y;
     root = erase_node(root, x, y);
   }
-  uint32_t count() {
+  uint32_t count() { return subtree_size(root); }
-    std::shared_lock lock(mtx);
-    return subtree_size(root);
-  }
   ~LineTree() { clear(); }
 
 private:
@@ -117,7 +105,6 @@ private:
   LineNode *root = nullptr;
   Frame stack[32];
   std::atomic<uint8_t> stack_size = 0;
-  std::shared_mutex mtx;
   static constexpr uint32_t LEAF_TARGET = 256;
   LineTree::LineNode *erase_node(LineNode *n, uint32_t x, uint32_t y) {
     if (!n || y == 0)

include/syntax/parser.h

@@ -17,10 +17,8 @@ struct Parser {
   mrb_value parser_block = mrb_nil_value();
   mrb_value match_block = mrb_nil_value();
   bool is_custom{false};
-  std::atomic<uint32_t> scroll_max{UINT32_MAX - 2048};
+  std::atomic<uint32_t> scroll_max{0};
   std::atomic<bool> scroll_dirty{false};
-  std::mutex mutex;
-  std::mutex data_mutex;
   LineTree line_tree;
   UniqueQueue<uint32_t> dirty_lines;
 

include/ui/bar.h

@@ -8,9 +8,13 @@
 struct Bar {
   Coord screen;
   std::string command = "";
+  std::string log_line = "";
   uint32_t cursor = 0;
+  BarLine bar_line;
+  std::mutex mtx;
 
-  Bar(Coord screen) : screen(screen) {}
+  void init(Coord screen) { this->screen = screen; }
+  void work();
   void render();
   void handle(KeyEvent event);
   void log(std::string message);

include/utils/utils.h

@@ -102,7 +102,6 @@ struct Language {
   std::string name;
   std::string lsp_name;
   uint32_t color;
-  std::string symbol;
 };
 
 struct LSP {
@@ -112,7 +111,6 @@ struct LSP {
 
 extern std::unordered_map<std::string, Language> languages;
 extern std::unordered_map<std::string, std::string> language_extensions;
-extern std::unordered_map<std::string, std::string> language_mimetypes;
 extern std::unordered_map<std::string, LSP> lsps;
 
 #define MAX(a, b) ((a) > (b) ? (a) : (b))
@@ -155,12 +153,8 @@ std::string path_to_file_uri(const std::string &path_str);
 std::string filename_from_path(const std::string &path);
 std::string get_exe_dir();
 char *load_file(const char *path, uint32_t *out_len, bool *out_eol);
-char *detect_file_type(const char *filename);
 Language language_for_file(const char *filename);
 
-void copy_to_clipboard(const char *text, size_t len);
-char *get_from_clipboard(uint32_t *out_len);
-
 template <typename T>
 inline T *safe_get(std::map<uint16_t, T> &m, uint16_t key) {
   auto it = m.find(key);

installer.sh

@@ -4,21 +4,9 @@ set -eu
 
 install() {
   BINARY_NAME="crib"
-  VERSION="v0.0.1-alpha"
+  BIN_URL="https://git.syedm.dev/SyedM/crib/releases/download/v0.0.2-alpha/crib"
-  BIN_URL="https://git.syedm.dev/SyedM-dev/crib/releases/download/$VERSION/crib"
 
-  ldconfig -p | grep libmagic >/dev/null 2>&1
+  echo "Install or update locally (~/.local/bin) or globally (/usr/bin)? [l/g]"
-
-  if ! ldconfig -p | grep libmagic >/dev/null 2>&1; then
-    echo "Missing dependency: libmagic (part of \`file\` package)"
-    echo "Install them using your package manager:"
-    echo "Ubuntu/Debian: sudo apt install ruby libmagic1"
-    echo "Arch: sudo pacman -S file"
-    echo "Void: sudo xbps-install -Sy file"
-    exit 1
-  fi
-
-  echo "Install locally (~/.local/bin) or globally (/usr/bin)? [l/g]"
   read -r choice </dev/tty
   case "$choice" in
   l | L)

samples/ruby.rb

@@ -24,10 +24,10 @@ s wow
 々〆〤]/
 
 UNICORE = /
-    s
+s
-    {#{ss}}
+{#{ss}}
-    \C-s\u{10}
+\C-s\u{10}
-  /
+/
 
 UNINITCORE = %(
 
@@ -89,6 +89,7 @@ BASH
 
 puts multi
 
+
 # Arrays mixing everything
 mixed = [
   '🐍 Ruby + Python? sacrilege! 🐍',

src/editor/completions.cc

@@ -25,6 +25,23 @@ inline static std::string completion_prefix(Editor *editor) {
   return prefix;
 }
 
+inline static void completion_adjust_scroll(CompletionSession &s) {
+  if (s.visible.empty())
+    return;
+  int vi = -1;
+  for (size_t i = 0; i < s.visible.size(); i++)
+    if (s.visible[i] == s.select) {
+      vi = (int)i;
+      break;
+    }
+  if (vi < 0)
+    return;
+  if ((uint32_t)vi < s.scroll)
+    s.scroll = vi;
+  else if ((uint32_t)vi >= s.scroll + 8)
+    s.scroll = vi - 7;
+}
+
 void completion_filter(Editor *editor) {
   auto &session = editor->completion;
   std::string prefix = completion_prefix(editor);
@@ -44,6 +61,8 @@ void completion_filter(Editor *editor) {
                 session.select) == session.visible.end())
     session.select = session.visible[0];
   session.box.hidden = false;
+  session.scroll = 0;
+  completion_adjust_scroll(session);
   session.box.render_update();
 }
 
@@ -417,6 +436,7 @@ void complete_next(Editor *editor) {
     vi = (vi + 1) % s.visible.size();
   s.select = s.visible[vi];
   completion_resolve_doc(editor);
+  completion_adjust_scroll(editor->completion);
   editor->completion.box.render_update();
 }
 
@@ -431,6 +451,7 @@ void complete_prev(Editor *editor) {
     vi = (vi + s.visible.size() - 1) % s.visible.size();
   s.select = s.visible[vi];
   completion_resolve_doc(editor);
+  completion_adjust_scroll(editor->completion);
   editor->completion.box.render_update();
 }
 

src/editor/editor.cc

@@ -1,6 +1,7 @@
 #include "editor/editor.h"
 #include "editor/decl.h"
 #include "lsp/lsp.h"
+#include "main.h"
 #include "syntax/langs.h"
 #include "utils/utils.h"
 
@@ -77,6 +78,8 @@ void save_file(Editor *editor) {
   }
   out.close();
   free(str);
+  bar.log("Written " + std::to_string(char_count) + " bytes to " +
+          editor->filename);
   if (editor->lsp) {
     json save_msg = {{"jsonrpc", "2.0"},
                      {"method", "textDocument/didSave"},

src/editor/events.cc

@@ -232,6 +232,4 @@ void handle_editor_event(Editor *editor, KeyEvent event) {
   if (old_mode == mode || mode != INSERT)
     handle_completion(editor, event);
   ensure_scroll(editor);
-  if ((event.key_type == KEY_CHAR || event.key_type == KEY_PASTE) && event.c)
-    free(event.c);
 }

src/editor/helpers.cc

@@ -11,7 +11,7 @@ void cut(Editor *editor) {
   Coord start;
   uint32_t len;
   char *text = get_selection(editor, &len, &start);
-  copy_to_clipboard(text, len);
+  ruby_copy(text, len);
   len = count_clusters(text, len, 0, len);
   edit_erase(editor, start, len);
   free(text);
@@ -23,22 +23,20 @@ void copy(Editor *editor) {
     return;
   uint32_t len;
   char *text = get_selection(editor, &len, nullptr);
-  copy_to_clipboard(text, len);
+  ruby_copy(text, len);
   free(text);
   editor->selection_active = false;
 }
 
 void paste(Editor *editor) {
-  uint32_t len;
   if (mode == NORMAL) {
-    char *text = get_from_clipboard(&len);
+    std::string text = ruby_paste();
-    if (text) {
+    if (text.empty())
-      insert_str(editor, text, len);
+      return;
-      free(text);
+    insert_str(editor, (char *)text.c_str(), text.length());
-    }
   } else if (mode == SELECT) {
-    char *text = get_from_clipboard(&len);
+    std::string text = ruby_paste();
-    if (text) {
+    if (!text.empty()) {
       Coord start, end;
       selection_bounds(editor, &start, &end);
       uint32_t start_byte =
@@ -46,8 +44,7 @@ void paste(Editor *editor) {
       uint32_t end_byte =
           line_to_byte(editor->root, end.row, nullptr) + end.col;
       edit_erase(editor, start, end_byte - start_byte);
-      edit_insert(editor, editor->cursor, text, len);
+      edit_insert(editor, editor->cursor, (char *)text.c_str(), text.length());
-      free(text);
     }
     editor->selection_active = false;
   }

src/editor/indents.cc

@@ -218,16 +218,16 @@ void IndentationEngine::insert_new_line(Coord cursor) {
     if (is_end_full != kLangtoBlockEndsFull.end())
       for (auto end : is_end_full->second)
         if (end == trim(line)) {
-          cursor.col =
+          cursor.col = set_indent(
-              set_indent(cursor.row, (int64_t)indent_expected(cursor.row) - 1);
+              cursor.row, (int64_t)indent_expected(cursor.row) - (int64_t)1);
           end_matched = true;
           break;
         }
     if (!end_matched && is_end_start != kLangtoBlockEndsStart.end())
       for (auto end : is_end_start->second)
         if (starts_with(trim(line), end)) {
-          cursor.col =
+          cursor.col = set_indent(
-              set_indent(cursor.row, (int64_t)indent_expected(cursor.row) - 1);
+              cursor.row, (int64_t)indent_expected(cursor.row) - (int64_t)1);
           break;
         }
     lock.lock();
@@ -248,7 +248,7 @@ void IndentationEngine::insert_new_line(Coord cursor) {
   }
   std::string ending = trim(std::string(line + cursor.col, len - cursor.col));
   std::string before = trim(std::string(line, cursor.col));
-  uint32_t c_indent = indent_real(line, len);
+  int64_t c_indent = indent_real(line, len);
   if (!ending.empty()) {
     bool ending_valid = false;
     bool starting_valid = false;
@@ -271,14 +271,13 @@ void IndentationEngine::insert_new_line(Coord cursor) {
     if (is_end_set != kLangtoBlockStartsEnd.end())
       for (auto end : is_end_set->second)
         if (ends_with(before, end)) {
-          c_indent++;
           starting_valid = true;
           break;
         }
     if (!starting_valid && is_start_set != kLangtoBlockStartsStart.end())
       for (auto end : is_start_set->second)
         if (starts_with(before, end)) {
-          c_indent++;
+          starting_valid = true;
           break;
         }
     if (ending_valid && starting_valid)
@@ -305,11 +304,13 @@ void IndentationEngine::insert_new_line(Coord cursor) {
         c_indent++;
         break;
       }
+  if (c_indent < 0)
+    c_indent = 0;
   formatted = "\n" +
               (indent == 1 ? std::string(c_indent, '\t')
                            : std::string(c_indent * indent, ' ')) +
               ending;
-  Coord new_cursor = {cursor.row + 1, c_indent * indent};
+  Coord new_cursor = {cursor.row + 1, (uint32_t)c_indent * indent};
   edit_replace(editor, cursor, {cursor.row, len}, formatted.data(),
                formatted.size());
   editor->cursor = new_cursor;

src/editor/renderer.cc

@@ -11,7 +11,7 @@ void render_editor(Editor *editor) {
   uint32_t numlen =
       EXTRA_META + static_cast<int>(std::log10(editor->root->line_count + 1));
   uint32_t render_width = editor->size.col - numlen;
-  uint32_t render_x = editor->position.col + numlen;
+  uint32_t render_x = editor->position.col + numlen + 1;
   std::vector<std::pair<uint32_t, char>> v;
   for (size_t i = 0; i < 94; ++i)
     if (editor->hooks[i] != 0)
@@ -25,9 +25,6 @@ void render_editor(Editor *editor) {
   while (warn_it != editor->warnings.end() &&
          warn_it->line < editor->scroll.row)
     ++warn_it;
-  std::unique_lock<std::mutex> lock;
-  if (editor->parser)
-    lock = std::unique_lock<std::mutex>(editor->parser->mutex);
   LineData *line_data = nullptr;
   auto get_type = [&](uint32_t col) {
     if (!line_data)
@@ -146,16 +143,14 @@ void render_editor(Editor *editor) {
         update(editor->position.row + rendered_rows, editor->position.col, hook,
                0xAAAAAA, 0, 0);
         char buf[16];
-        int len =
+        int len = snprintf(buf, sizeof(buf), "%*u ", numlen, line_index + 1);
-            snprintf(buf, sizeof(buf), "%*u ", numlen - 3, line_index + 1);
         uint32_t num_color =
             editor->cursor.row == line_index ? 0xFFFFFF : 0x555555;
         for (int i = 0; i < len; i++)
-          update(editor->position.row + rendered_rows,
+          update(editor->position.row + rendered_rows, editor->position.col + i,
-                 editor->position.col + i + 2, (char[2]){buf[i], 0}, num_color,
+                 (char[2]){buf[i], 0}, num_color, 0, 0);
-                 0, 0);
       } else {
-        for (uint32_t i = 0; i < numlen; i++)
+        for (uint32_t i = 0; i < numlen + 1; i++)
           update(editor->position.row + rendered_rows, editor->position.col + i,
                  " ", 0, 0, 0);
       }
@@ -349,13 +344,12 @@ void render_editor(Editor *editor) {
       update(editor->position.row + rendered_rows, editor->position.col, hook,
              0xAAAAAA, 0, 0);
       char buf[16];
-      int len = snprintf(buf, sizeof(buf), "%*u ", numlen - 3, line_index + 1);
+      int len = snprintf(buf, sizeof(buf), "%*u ", numlen, line_index + 1);
       uint32_t num_color =
           editor->cursor.row == line_index ? 0xFFFFFF : 0x555555;
       for (int i = 0; i < len; i++)
-        update(editor->position.row + rendered_rows,
+        update(editor->position.row + rendered_rows, editor->position.col + i,
-               editor->position.col + i + 2, (char[2]){buf[i], 0}, num_color, 0,
+               (char[2]){buf[i], 0}, num_color, 0, 0);
-               0);
       if (editor->cursor.row == line_index) {
         cursor.row = editor->position.row + rendered_rows;
         cursor.col = render_x;
@@ -453,8 +447,6 @@ void render_editor(Editor *editor) {
     global_byte_offset += line_len + 1;
     line_index++;
   }
-  if (lock.owns_lock())
-    lock.unlock();
   while (rendered_rows < editor->size.row) {
     for (uint32_t col = 0; col < editor->size.col; col++)
       update(editor->position.row + rendered_rows, editor->position.col + col,

src/lsp/handlers.cc

@@ -1,4 +1,5 @@
 #include "lsp/lsp.h"
+#include "main.h"
 
 Queue<LSPOpenRequest> lsp_open_queue;
 

src/lsp/process.cc

@@ -155,40 +155,78 @@ std::shared_ptr<LSPInstance> get_or_init_lsp(std::string lsp_id) {
 }
 
 void close_lsp(std::string lsp_id) {
-  std::shared_lock active_lsps_lock(active_lsps_mtx);
+  std::shared_ptr<LSPInstance> lsp;
-  auto it = active_lsps.find(lsp_id);
+  {
-  if (it == active_lsps.end())
+    std::shared_lock lock(active_lsps_mtx);
+    auto it = active_lsps.find(lsp_id);
+    if (it == active_lsps.end())
+      return;
+    lsp = it->second;
+  }
+  if (!lsp || lsp->pid == -1 || lsp->exited)
     return;
-  std::shared_ptr<LSPInstance> lsp = it->second;
-  active_lsps_lock.unlock();
   lsp->exited = true;
   lsp->initialized = false;
-  LSPPending *shutdown_pending = new LSPPending();
+  auto send_raw = [&](const json &msg) {
-  shutdown_pending->method = "shutdown";
+    std::string payload = msg.dump();
-  shutdown_pending->callback = [lsp](Editor *, std::string, json) {
+    std::string header =
-    json exit = {{"jsonrpc", "2.0"}, {"method", "exit"}};
+        "Content-Length: " + std::to_string(payload.size()) + "\r\n\r\n";
-    lsp_send(lsp, exit, nullptr);
+    std::string out = header + payload;
+    const char *ptr = out.data();
+    size_t remaining = out.size();
+    while (remaining > 0) {
+      ssize_t n = write(lsp->stdin_fd, ptr, remaining);
+      if (n <= 0) {
+        if (errno == EINTR)
+          continue;
+        break;
+      }
+      ptr += n;
+      remaining -= n;
+    }
   };
-  json shutdown = {{"jsonrpc", "2.0"}, {"method", "shutdown"}};
+  json shutdown = {{"jsonrpc", "2.0"}, {"id", 1}, {"method", "shutdown"}};
-  lsp_send(lsp, shutdown, shutdown_pending);
+  send_raw(shutdown);
-  std::thread t([lsp, lsp_id] {
+  {
-    std::this_thread::sleep_for(100ms);
+    pollfd pfd{lsp->stdout_fd, POLLIN, 0};
-    std::unique_lock active_lsps_lock(active_lsps_mtx);
+    int timeout_ms = 300;
-    std::unique_lock lock(lsp->mtx);
+    if (poll(&pfd, 1, timeout_ms) > 0) {
-    if (lsp->pid != -1 && kill(lsp->pid, 0) == 0)
+      auto msg = read_lsp_message(lsp->stdout_fd);
-      kill(lsp->pid, SIGKILL);
+      (void)msg;
+    }
+  }
+  json exit_msg = {{"jsonrpc", "2.0"}, {"method", "exit"}};
+  send_raw(exit_msg);
+  const int max_wait_ms = 500;
+  int waited = 0;
+  while (waited < max_wait_ms) {
+    int status;
+    pid_t res = waitpid(lsp->pid, &status, WNOHANG);
+    if (res == lsp->pid)
+      break;
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    waited += 10;
+  }
+  if (kill(lsp->pid, 0) == 0) {
+    kill(lsp->pid, SIGKILL);
     waitpid(lsp->pid, nullptr, 0);
-    close(lsp->stdin_fd);
+  }
-    close(lsp->stdout_fd);
+  close(lsp->stdin_fd);
+  close(lsp->stdout_fd);
+  {
+    std::unique_lock lock(lsp->mtx);
     for (auto &kv : lsp->pending)
       delete kv.second;
-    for (auto &editor : lsp->editors) {
+    lsp->pending.clear();
-      std::unique_lock editor_lock(editor->lsp_mtx);
+  }
-      editor->lsp = nullptr;
+  for (auto &editor : lsp->editors) {
-    }
+    std::unique_lock editor_lock(editor->lsp_mtx);
+    editor->lsp = nullptr;
+  }
+  {
+    std::unique_lock lock(active_lsps_mtx);
     active_lsps.erase(lsp_id);
-  });
+  }
-  t.detach();
 }
 
 void clean_lsp(std::shared_ptr<LSPInstance> lsp, std::string lsp_id) {

src/lsp/workers.cc

@@ -16,7 +16,7 @@ void lsp_send(std::shared_ptr<LSPInstance> lsp, json message,
   lsp->outbox.push(message);
 }
 
-static std::optional<json> read_lsp_message(int fd) {
+std::optional<json> read_lsp_message(int fd) {
   std::string header;
   char c;
   while (true) {

src/main.cc

@@ -9,6 +9,7 @@
 std::atomic<bool> running{true};
 Queue<KeyEvent> event_queue;
 std::vector<Editor *> editors;
+Bar bar;
 
 uint8_t current_editor = 0;
 std::atomic<uint8_t> mode = NORMAL;
@@ -36,7 +37,30 @@ inline uint8_t index_of(Editor *ed) {
   return 0;
 }
 
-void input_listener(Bar bar) {
+int main(int argc, char *argv[]) {
+  ruby_start();
+  load_theme();
+  load_languages_info();
+  load_custom_highlighters();
+
+  Coord screen = start_screen();
+  const char *filename = (argc > 1) ? argv[1] : "";
+  uint8_t eol = read_line_endings();
+  Editor *editor =
+      new_editor(filename, {0, 0}, {screen.row - 2, screen.col}, eol);
+  bar.init(screen);
+
+  if (!editor) {
+    end_screen();
+    fprintf(stderr, "Failed to load editor\n");
+    return 1;
+  }
+
+  editors.push_back(editor);
+  current_editor = editors.size() - 1;
+
+  std::thread lsp_thread(background_lsp);
+
   while (running) {
     KeyEvent event = throttle(1ms, read_key);
     if (event.key_type == KEY_NONE)
@@ -53,7 +77,6 @@ void input_listener(Bar bar) {
         if (target) {
           if (event.mouse_state == PRESS)
             current_editor = index_of(target);
-
           event.mouse_x -= target->position.col;
           event.mouse_y -= target->position.row;
           handle_editor_event(target, event);
@@ -64,53 +87,15 @@ void input_listener(Bar bar) {
     } else {
       bar.handle(event);
     }
+    if ((event.key_type == KEY_CHAR || event.key_type == KEY_PASTE) && event.c)
+      free(event.c);
   render:
-    render_editor(editors[current_editor]);
+    throttle(4ms, editor_worker, editors[current_editor]);
+    bar.work();
     bar.render();
+    render_editor(editors[current_editor]);
     throttle(4ms, render);
   }
-}
-
-int main(int argc, char *argv[]) {
-  auto start = std::chrono::high_resolution_clock::now();
-
-  ruby_start();
-  load_theme();
-  load_languages_info();
-  load_custom_highlighters();
-
-  Coord screen = start_screen();
-  const char *filename = (argc > 1) ? argv[1] : "";
-
-  uint8_t eol = read_line_endings();
-
-  Editor *editor =
-      new_editor(filename, {0, 0}, {screen.row - 2, screen.col}, eol);
-  Bar bar(screen);
-
-  auto end = std::chrono::high_resolution_clock::now();
-  auto ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start)
-                .count();
-  ruby_log("[LOG] STARTUP_TIME: " + std::to_string(static_cast<long long>(ms)) +
-           "ms");
-
-  if (!editor) {
-    end_screen();
-    fprintf(stderr, "Failed to load editor\n");
-    return 1;
-  }
-
-  editors.push_back(editor);
-  current_editor = editors.size() - 1;
-
-  std::thread input_thread(input_listener, bar);
-  std::thread lsp_thread(background_lsp);
-
-  while (running)
-    throttle(16ms, editor_worker, editors[current_editor]);
-
-  if (input_thread.joinable())
-    input_thread.join();
 
   if (lsp_thread.joinable())
     lsp_thread.join();
@@ -120,16 +105,6 @@ int main(int argc, char *argv[]) {
   for (auto editor : editors)
     free_editor(editor);
 
-  std::unique_lock lk(active_lsps_mtx);
-  lk.unlock();
-  while (true) {
-    lk.lock();
-    if (active_lsps.empty())
-      break;
-    lk.unlock();
-    throttle(16ms, lsp_worker);
-  }
-
   ruby_shutdown();
 
   return 0;

src/ruby_compile.sh

@@ -0,0 +1,53 @@
+#!/usr/bin/env bash
+
+set -e
+
+SCRIPT_DIR="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
+INPUT="$SCRIPT_DIR/../include/syntax/tokens.def"
+TMP="/tmp/__crib_precompiled.rb"
+OUTPUT="/tmp/__crib_precompiled.mrb"
+
+echo "module Tokens" >"$TMP"
+
+counter=0
+
+while read -r line; do
+  if [[ $line =~ ADD\(([^\)]+)\) ]]; then
+    name="${BASH_REMATCH[1]}"
+    echo "  $name = $counter" >>"$TMP"
+    counter=$((counter + 1))
+  fi
+done <"$INPUT"
+
+OS="$(uname -s)"
+OS_TYPE="unknown"
+
+case "$OS" in
+Linux*)
+  OS_TYPE="linux"
+  ;;
+Darwin*)
+  OS_TYPE="mac"
+  ;;
+CYGWIN* | MINGW* | MSYS*)
+  OS_TYPE="windows"
+  ;;
+esac
+
+{
+  echo "  freeze"
+  echo "end"
+  echo
+  cat "$SCRIPT_DIR/../include/scripting/libcrib.rb" | sed "s/os_name_placed_here/$OS_TYPE/g"
+} >>"$TMP"
+
+"$SCRIPT_DIR/../libs/mruby/bin/mrbc" -o$OUTPUT $TMP
+
+{
+  echo "#pragma once"
+  xxd -i $OUTPUT | sed 's/^unsigned char /constexpr unsigned char /' |
+    sed 's/^unsigned int /constexpr unsigned int /'
+} >"$SCRIPT_DIR/../include/scripting/ruby_compiled.h"
+
+rm $TMP
+rm $OUTPUT

src/scripting/bindings.cc

@@ -0,0 +1,10 @@
+#include "scripting/decl.h"
+
+mrb_value get_config_file(mrb_state *mrb, mrb_value self) {
+  return mrb_str_new_cstr(mrb, ruby_config_path.string().c_str());
+}
+
+void setup_ruby_bindings(mrb_state *mrb, RClass *C_module) {
+  mrb_define_module_function(mrb, C_module, "config_file", get_config_file,
+                             MRB_ARGS_NONE());
+}

src/scripting/process.cc

@@ -1,4 +1,8 @@
+#include "io/sysio.h"
+#include "main.h"
+#include "pch.h"
 #include "scripting/decl.h"
+#include "scripting/ruby_compiled.h"
 #include "utils/utils.h"
 
 std::unordered_map<std::string, std::pair<mrb_value, mrb_value>>
@@ -17,21 +21,16 @@ struct R_ThemeEntry {
 struct R_Language {
   std::string name;
   uint32_t color = 0xFFFFFF;
-  std::string symbol;
   std::vector<std::string> extensions;
   std::vector<std::string> filenames;
-  std::vector<std::string> mimetypes;
   std::string lsp_command; // link to LSP by name
 };
 
 mrb_state *mrb = nullptr;
 RClass *C_module;
-std::mutex ruby_mutex;
+fs::path ruby_config_path;
-
-namespace fs = std::filesystem;
 
 void ruby_start() {
-  std::lock_guard lock(ruby_mutex);
   mrb = mrb_open();
   if (!mrb) {
     fprintf(stderr, "Failed to init mruby\n");
@@ -54,32 +53,283 @@ void ruby_start() {
   }
   candidates.emplace_back(exe_dir / "../config/main.rb");
   candidates.emplace_back(exe_dir / "../config/crib.rb");
-  mrb_load_string(mrb, crib_module);
+  mrb_load_irep(mrb, _tmp___crib_precompiled_mrb);
-  mrb_load_string(mrb, tokens_def);
+  C_module = mrb_module_get(mrb, "C");
+  setup_ruby_bindings(mrb, C_module);
   for (const auto &p : candidates) {
     if (fs::exists(p)) {
       FILE *f = fopen(p.string().c_str(), "r");
       if (f) {
+        ruby_config_path = p;
         mrb_load_file(mrb, f);
+        if (mrb->exc)
+          exit(1);
         fclose(f);
       }
       break;
     }
   }
-  C_module = mrb_module_get(mrb, "C");
   mrb_value mod_val = mrb_obj_value(C_module);
   mrb_value block = mrb_funcall(mrb, mod_val, "b_startup", 0);
-  mrb_funcall(mrb, block, "call", 0);
+  if (!mrb_nil_p(block))
+    mrb_funcall(mrb, block, "call", 0);
+  mrb_garbage_collect(mrb);
+}
+
+static mrb_value sym_fg;
+static mrb_value sym_bg;
+static mrb_value sym_flags;
+static mrb_value sym_start;
+static mrb_value sym_length;
+static mrb_value sym_mode;
+static mrb_value sym_lang_name;
+static mrb_value sym_filename;
+static mrb_value sym_width;
+static mrb_value sym_normal;
+static mrb_value sym_insert;
+static mrb_value sym_select;
+static mrb_value sym_runner;
+static mrb_value sym_jumper;
+
+inline void initialize_symbols() {
+  sym_fg = mrb_symbol_value(mrb_intern_cstr(mrb, "fg"));
+  sym_bg = mrb_symbol_value(mrb_intern_cstr(mrb, "bg"));
+  sym_flags = mrb_symbol_value(mrb_intern_cstr(mrb, "flags"));
+  sym_start = mrb_symbol_value(mrb_intern_cstr(mrb, "start"));
+  sym_length = mrb_symbol_value(mrb_intern_cstr(mrb, "length"));
+  sym_mode = mrb_symbol_value(mrb_intern_cstr(mrb, "mode"));
+  sym_lang_name = mrb_symbol_value(mrb_intern_cstr(mrb, "lang_name"));
+  sym_filename = mrb_symbol_value(mrb_intern_cstr(mrb, "filename"));
+  sym_width = mrb_symbol_value(mrb_intern_cstr(mrb, "width"));
+  sym_normal = mrb_symbol_value(mrb_intern_cstr(mrb, "normal"));
+  sym_insert = mrb_symbol_value(mrb_intern_cstr(mrb, "insert"));
+  sym_select = mrb_symbol_value(mrb_intern_cstr(mrb, "select"));
+  sym_runner = mrb_symbol_value(mrb_intern_cstr(mrb, "runner"));
+  sym_jumper = mrb_symbol_value(mrb_intern_cstr(mrb, "jumper"));
+}
+
+inline static std::vector<BarLight>
+convert_highlights(mrb_state *mrb, mrb_value highlights_val) {
+  std::vector<BarLight> result;
+  if (!mrb_array_p(highlights_val))
+    return result;
+  mrb_int len = RARRAY_LEN(highlights_val);
+  for (mrb_int i = 0; i < len; i++) {
+    mrb_value item = mrb_ary_ref(mrb, highlights_val, i);
+    if (!mrb_hash_p(item))
+      continue;
+    mrb_value fg_v = mrb_hash_get(mrb, item, sym_fg);
+    mrb_value bg_v = mrb_hash_get(mrb, item, sym_bg);
+    mrb_value flags_v = mrb_hash_get(mrb, item, sym_flags);
+    mrb_value start_v = mrb_hash_get(mrb, item, sym_start);
+    mrb_value length_v = mrb_hash_get(mrb, item, sym_length);
+    BarLight bl{};
+    if (!mrb_nil_p(fg_v))
+      bl.highlight.fg = (uint32_t)mrb_fixnum(fg_v);
+    if (!mrb_nil_p(bg_v))
+      bl.highlight.bg = (uint32_t)mrb_fixnum(bg_v);
+    if (!mrb_nil_p(flags_v))
+      bl.highlight.flags = (uint32_t)mrb_fixnum(flags_v);
+    uint32_t start = !mrb_nil_p(start_v) ? (uint32_t)mrb_fixnum(start_v) : 0;
+    uint32_t length = !mrb_nil_p(length_v) ? (uint32_t)mrb_fixnum(length_v) : 0;
+    bl.start = start;
+    bl.end = start + length;
+    result.push_back(bl);
+  }
+  return result;
+}
+
+BarLine bar_contents(uint8_t mode, std::string lang_name, uint32_t warnings,
+                     std::string lsp_name, std::string filename,
+                     std::string foldername, uint32_t line, uint32_t max_line,
+                     uint32_t width) {
+  BarLine bar_line;
+  static bool initialed = false;
+  if (!initialed) {
+    initialize_symbols();
+    initialed = true;
+  }
+  int ai = mrb_gc_arena_save(mrb);
+  mrb_value info = mrb_hash_new(mrb);
+  mrb_value key_mode = sym_mode;
+  mrb_value val_mode;
+  switch (mode) {
+  case NORMAL:
+    val_mode = sym_normal;
+    break;
+  case INSERT:
+    val_mode = sym_insert;
+    break;
+  case SELECT:
+    val_mode = sym_select;
+    break;
+  case RUNNER:
+    val_mode = sym_runner;
+    break;
+  case JUMPER:
+    val_mode = sym_jumper;
+    break;
+  }
+  mrb_hash_set(mrb, info, key_mode, val_mode);
+  mrb_value key_lang_name = sym_lang_name;
+  mrb_value val_lang_name =
+      mrb_symbol_value(mrb_intern_cstr(mrb, lang_name.c_str()));
+  mrb_hash_set(mrb, info, key_lang_name, val_lang_name);
+  mrb_value key_filename = sym_filename;
+  mrb_value val_filename =
+      mrb_str_new(mrb, filename.c_str(), filename.length());
+  mrb_hash_set(mrb, info, key_filename, val_filename);
+  mrb_value key_width = sym_width;
+  mrb_value val_width = mrb_fixnum_value(width);
+  mrb_hash_set(mrb, info, key_width, val_width);
+  mrb_value mod_val = mrb_obj_value(C_module);
+  mrb_value block = mrb_funcall(mrb, mod_val, "b_bar", 0);
+  mrb_value val_line = mrb_funcall(mrb, block, "call", 1, info);
+  if (mrb->exc) {
+    end_screen();
+    fputs("Error when executing Ruby code:\n", stderr);
+    mrb_print_error(mrb);
+    mrb_close(mrb);
+    exit(1);
+  }
+  mrb_value text_val = mrb_hash_get(
+      mrb, val_line, mrb_symbol_value(mrb_intern_cstr(mrb, "text")));
+  const char *ptr = RSTRING_PTR(text_val);
+  mrb_int len = RSTRING_LEN(text_val);
+  bar_line.line = std::string(ptr, len);
+  mrb_value highlights_val = mrb_hash_get(
+      mrb, val_line, mrb_symbol_value(mrb_intern_cstr(mrb, "highlights")));
+  bar_line.highlights = convert_highlights(mrb, highlights_val);
+  mrb_gc_arena_restore(mrb, ai);
+  return bar_line;
+}
+
+std::string serialize_value(mrb_state *mrb, mrb_value val) {
+  int ai = mrb_gc_arena_save(mrb);
+  mrb_value marshal_module = mrb_obj_value(mrb_module_get(mrb, "Marshal"));
+  mrb_value dumped = mrb_funcall(mrb, marshal_module, "dump", 1, val);
+  if (mrb->exc) {
+    end_screen();
+    fputs("Error when executing Ruby code:\n", stderr);
+    mrb_print_error(mrb);
+    mrb_close(mrb);
+    exit(1);
+  }
+  std::string bytes(RSTRING_PTR(dumped), RSTRING_LEN(dumped));
+  mrb_gc_arena_restore(mrb, ai);
+  return bytes;
+}
+
+mrb_value deserialize_value(mrb_state *mrb, std::string bytes) {
+  if (bytes.empty())
+    return mrb_nil_value();
+  mrb_value marshal_module = mrb_obj_value(mrb_module_get(mrb, "Marshal"));
+  mrb_value val = mrb_funcall(mrb, marshal_module, "load", 1,
+                              mrb_str_new(mrb, bytes.c_str(), bytes.length()));
+  if (mrb->exc) {
+    end_screen();
+    fputs("Error when executing Ruby code:\n", stderr);
+    mrb_print_error(mrb);
+    mrb_close(mrb);
+    exit(1);
+  }
+  return val;
+}
+
+void ruby_copy(const char *text, size_t len) {
+  int ai = mrb_gc_arena_save(mrb);
+  if (C_module == nullptr)
+    return;
+  mrb_value mod_val = mrb_obj_value(C_module);
+  mrb_value block = mrb_funcall(mrb, mod_val, "b_copy", 0);
+  if (!mrb_nil_p(block))
+    mrb_funcall(mrb, block, "call", 1, mrb_str_new(mrb, text, len));
+  if (mrb->exc) {
+    end_screen();
+    fputs("Error when executing Ruby code:\n", stderr);
+    mrb_print_error(mrb);
+    mrb_close(mrb);
+    exit(1);
+  }
+  mrb_gc_arena_restore(mrb, ai);
+}
+
+std::string ruby_file_detect(std::string filename) {
+  int ai = mrb_gc_arena_save(mrb);
+  if (C_module == nullptr)
+    return "";
+  mrb_value mod_val = mrb_obj_value(C_module);
+  mrb_value block = mrb_funcall(mrb, mod_val, "b_file_detect", 0);
+  if (mrb->exc) {
+    end_screen();
+    fputs("Error when executing Ruby code:\n", stderr);
+    mrb_print_error(mrb);
+    mrb_close(mrb);
+    exit(1);
+  }
+  if (!mrb_nil_p(block)) {
+    mrb_value val =
+        mrb_funcall(mrb, block, "call", 1,
+                    mrb_str_new(mrb, filename.c_str(), filename.length()));
+    if (mrb->exc) {
+      end_screen();
+      fputs("Error when executing Ruby code:\n", stderr);
+      mrb_print_error(mrb);
+      mrb_close(mrb);
+      exit(1);
+    }
+    mrb_value s_val = mrb_funcall(mrb, val, "to_s", 0);
+    if (mrb->exc) {
+      end_screen();
+      fputs("Error when executing Ruby code:\n", stderr);
+      mrb_print_error(mrb);
+      mrb_close(mrb);
+      exit(1);
+    }
+    if (mrb_string_p(s_val)) {
+      std::string result = std::string(RSTRING_PTR(s_val), RSTRING_LEN(s_val));
+      mrb_gc_arena_restore(mrb, ai);
+      return result;
+    }
+  }
+  mrb_gc_arena_restore(mrb, ai);
+  return "";
+}
+
+std::string ruby_paste() {
+  int ai = mrb_gc_arena_save(mrb);
+  if (C_module == nullptr)
+    return "";
+  mrb_value mod_val = mrb_obj_value(C_module);
+  mrb_value block = mrb_funcall(mrb, mod_val, "b_paste", 0);
+  if (!mrb_nil_p(block)) {
+    mrb_value val = mrb_funcall(mrb, block, "call", 0);
+    if (mrb->exc) {
+      end_screen();
+      fputs("Error when executing Ruby code:\n", stderr);
+      mrb_print_error(mrb);
+      mrb_close(mrb);
+      exit(1);
+    }
+    if (mrb_string_p(val)) {
+      std::string result = std::string(RSTRING_PTR(val), RSTRING_LEN(val));
+      mrb_gc_arena_restore(mrb, ai);
+      return result;
+    }
+    mrb_gc_arena_restore(mrb, ai);
+    return "";
+  }
+  mrb_gc_arena_restore(mrb, ai);
+  return "";
 }
 
 void ruby_shutdown() {
-  std::lock_guard lock(ruby_mutex);
   if (C_module == nullptr)
     return;
-  C_module = mrb_module_get(mrb, "C");
   mrb_value mod_val = mrb_obj_value(C_module);
   mrb_value block = mrb_funcall(mrb, mod_val, "b_shutdown", 0);
-  mrb_funcall(mrb, block, "call", 0);
+  if (!mrb_nil_p(block))
+    mrb_funcall(mrb, block, "call", 0);
   mrb_close(mrb);
   mrb = nullptr;
   C_module = nullptr;
@@ -98,15 +348,7 @@ std::vector<std::string> array_to_vector(mrb_value ary) {
   return result;
 }
 
-void ruby_log(std::string msg) {
-  std::lock_guard lock(ruby_mutex);
-  mrb_value str = mrb_str_new(mrb, msg.c_str(), msg.size());
-  mrb_value mod_val = mrb_obj_value(C_module);
-  mrb_funcall(mrb, mod_val, "queue_log", 1, str);
-}
-
 void load_custom_highlighters() {
-  std::lock_guard<std::mutex> lock(ruby_mutex);
   if (!C_module)
     return;
   mrb_value mod_val = mrb_obj_value((struct RObject *)C_module);
@@ -131,27 +373,36 @@ void load_custom_highlighters() {
         mrb_hash_get(mrb, val_hash, mrb_symbol_value(matcher_sym));
     custom_highlighters[key] = {parse_block, match_block};
   }
+  mrb_garbage_collect(mrb);
 }
 
-bool custom_compare(mrb_value match_block, mrb_value state1, mrb_value state2) {
+bool custom_compare(mrb_value match_block, std::string state1,
-  std::lock_guard<std::mutex> lock(ruby_mutex);
+                    std::string state2) {
+  if (state1.empty() || state2.empty())
+    return false;
+  int ai = mrb_gc_arena_save(mrb);
   if (mrb_type(match_block) != MRB_TT_PROC)
     return false;
-  mrb_value ret = mrb_funcall(mrb, match_block, "call", 2, state1, state2);
+  mrb_value ret =
-  return mrb_test(ret);
+      mrb_funcall(mrb, match_block, "call", 2, deserialize_value(mrb, state1),
+                  deserialize_value(mrb, state2));
+  bool result = mrb_test(ret);
+  mrb_gc_arena_restore(mrb, ai);
+  return result;
 }
 
-mrb_value parse_custom(std::vector<Token> *tokens, mrb_value parser_block,
+std::string parse_custom(std::vector<Token> *tokens, mrb_value parser_block,
-                       const char *line, uint32_t len, mrb_value state,
+                         const char *line, uint32_t len, std::string state,
-                       uint32_t c_line) {
+                         uint32_t c_line) {
-  std::lock_guard<std::mutex> lock(ruby_mutex);
+  int ai = mrb_gc_arena_save(mrb);
   tokens->clear();
   if (mrb_nil_p(parser_block))
-    return mrb_nil_value();
+    return "";
   mrb_value ruby_line = mrb_str_new(mrb, line, len);
   mrb_value line_idx = mrb_fixnum_value(c_line);
   mrb_value tokens_and_state_hash =
-      mrb_funcall(mrb, parser_block, "call", 3, ruby_line, state, line_idx);
+      mrb_funcall(mrb, parser_block, "call", 3, ruby_line,
+                  deserialize_value(mrb, state), line_idx);
   mrb_sym tokens_sym = mrb_intern_lit(mrb, "tokens");
   mrb_value tokens_rb =
       mrb_hash_get(mrb, tokens_and_state_hash, mrb_symbol_value(tokens_sym));
@@ -171,11 +422,16 @@ mrb_value parse_custom(std::vector<Token> *tokens, mrb_value parser_block,
     }
   }
   mrb_sym state_sym = mrb_intern_lit(mrb, "state");
-  return mrb_hash_get(mrb, tokens_and_state_hash, mrb_symbol_value(state_sym));
+  mrb_value state_rb =
+      mrb_hash_get(mrb, tokens_and_state_hash, mrb_symbol_value(state_sym));
+  std::string result;
+  if (mrb_type(state_rb) == MRB_TT_STRING)
+    result = std::string(RSTRING_PTR(state_rb), RSTRING_LEN(state_rb));
+  mrb_gc_arena_restore(mrb, ai);
+  return result;
 }
 
 static std::vector<R_ThemeEntry> read_theme() {
-  std::lock_guard<std::mutex> lock(ruby_mutex);
   std::vector<R_ThemeEntry> result;
   if (!C_module)
     return result;
@@ -221,6 +477,7 @@ static std::vector<R_ThemeEntry> read_theme() {
       entry.strikethrough = mrb_test(strikethrough);
     result.push_back(entry);
   }
+  mrb_garbage_collect(mrb);
   return result;
 }
 
@@ -289,6 +546,7 @@ std::vector<LSP> read_lsps() {
     std::vector<std::string> args = array_to_vector(args_array);
     result.push_back({cmd, args});
   }
+  mrb_garbage_collect(mrb);
   return result;
 }
 
@@ -314,32 +572,26 @@ std::vector<R_Language> read_languages() {
       lang.name = std::string(RSTRING_PTR(key), RSTRING_LEN(key));
     mrb_value fg = mrb_hash_get(mrb, val_hash,
                                 mrb_symbol_value(mrb_intern_lit(mrb, "color")));
-    mrb_value symbol = mrb_hash_get(
-        mrb, val_hash, mrb_symbol_value(mrb_intern_lit(mrb, "symbol")));
     mrb_value extensions = mrb_hash_get(
         mrb, val_hash, mrb_symbol_value(mrb_intern_lit(mrb, "extensions")));
     mrb_value filenames = mrb_hash_get(
         mrb, val_hash, mrb_symbol_value(mrb_intern_lit(mrb, "filenames")));
-    mrb_value mimetypes = mrb_hash_get(
-        mrb, val_hash, mrb_symbol_value(mrb_intern_lit(mrb, "mimetypes")));
     mrb_value lsp = mrb_hash_get(mrb, val_hash,
                                  mrb_symbol_value(mrb_intern_lit(mrb, "lsp")));
     if (!mrb_nil_p(fg))
       lang.color = (uint32_t)mrb_fixnum(fg);
-    if (!mrb_nil_p(symbol))
-      lang.symbol = std::string(RSTRING_PTR(symbol), RSTRING_LEN(symbol));
     lang.extensions = array_to_vector(extensions);
-    lang.filenames = array_to_vector(filenames);
+    if (!mrb_nil_p(filenames))
-    lang.mimetypes = array_to_vector(mimetypes);
+      lang.filenames = array_to_vector(filenames);
     if (!mrb_nil_p(lsp))
       lang.lsp_command = std::string(RSTRING_PTR(lsp), RSTRING_LEN(lsp));
     result.push_back(lang);
   }
+  mrb_garbage_collect(mrb);
   return result;
 }
 
 void load_languages_info() {
-  std::lock_guard lock(ruby_mutex);
   auto langs = read_languages();
   auto lsps_t = read_lsps();
   languages.clear();
@@ -348,22 +600,18 @@ void load_languages_info() {
     l.name = lang.name;
     l.color = lang.color;
     l.lsp_name = lang.lsp_command;
-    l.symbol = lang.symbol;
     languages[lang.name] = l;
     for (auto &ext : lang.extensions)
       language_extensions[ext] = lang.name;
     // TODO: seperate extensions and filenames
     for (auto &filename : lang.filenames)
       language_extensions[filename] = lang.name;
-    for (auto &mimetype : lang.mimetypes)
-      language_mimetypes[mimetype] = lang.name;
   }
   for (auto &lsp : lsps_t)
     lsps[lsp.command] = lsp;
 }
 
 uint8_t read_line_endings() {
-  std::lock_guard<std::mutex> lock(ruby_mutex);
   if (!C_module)
     return 1;
   mrb_value mod_val = mrb_obj_value((struct RObject *)C_module);

src/syntax/parser.cc

@@ -31,7 +31,6 @@ Parser::Parser(Editor *n_editor, std::string n_lang, uint32_t n_scroll_max) {
 
 void Parser::edit(uint32_t start_line, uint32_t old_end_line,
                   uint32_t inserted_rows) {
-  std::lock_guard lock(data_mutex);
   if (((int64_t)old_end_line - (int64_t)start_line) > 0)
     line_tree.erase(start_line, old_end_line - start_line);
   if (inserted_rows > 0)
@@ -45,143 +44,90 @@ void Parser::edit(uint32_t start_line, uint32_t old_end_line,
 void Parser::work() {
   if (!editor || !editor->root)
     return;
-  std::shared_lock k_lock(editor->knot_mtx);
+  std::vector<uint32_t> batch;
-  k_lock.unlock();
-  uint32_t capacity = 256;
-  char *text = (char *)calloc((capacity + 1), sizeof(char));
-  std::unique_lock lock_data(data_mutex);
-  lock_data.unlock();
-  std::unique_lock lock(mutex);
-  lock.unlock();
   uint32_t c_line;
-  while (dirty_lines.pop(c_line)) {
+  while (dirty_lines.pop(c_line))
-    if (!running.load(std::memory_order_relaxed)) {
+    batch.push_back(c_line);
-      free(text);
+  for (uint32_t c_line : batch) {
-      return;
+    if (!running.load(std::memory_order_relaxed))
-    }
+      break;
-    if (c_line > scroll_max + 40) {
+    uint32_t min_line = scroll_max > 50 ? scroll_max - 50 : 0;
+    uint32_t max_line = scroll_max + 10;
+    if (c_line < min_line || c_line > max_line) {
       dirty_lines.push(c_line);
       continue;
     }
-    if (scroll_max > 50 && c_line < scroll_max - 50) {
+    uint32_t scroll_snapshot = scroll_max;
-      dirty_lines.push(c_line);
+    std::shared_ptr<void> prev_state = nullptr;
-      continue;
+    uint32_t line_count;
-    }
+    line_count = line_tree.count();
-    uint32_t line_count = line_tree.count();
+    if (c_line > 0 && c_line < line_count)
-    lock_data.lock();
+      prev_state = line_tree.at(c_line - 1)->out_state;
-    std::shared_ptr<void> prev_state =
+    std::shared_lock k_lock(editor->knot_mtx);
-        (c_line > 0) && c_line < line_tree.count()
+    LineIterator *it = begin_l_iter(editor->root, c_line);
-            ? line_tree.at(c_line - 1)->out_state
+    uint32_t cur_line = c_line;
-            : nullptr;
+    while (cur_line < line_count) {
-    lock_data.unlock();
+      if (!running.load(std::memory_order_relaxed))
-    while (c_line < line_count) {
+        break;
-      if (!running.load(std::memory_order_relaxed)) {
+      if (scroll_snapshot != scroll_max) {
-        free(text);
+        dirty_lines.push(cur_line);
-        return;
+        break;
       }
-      if (scroll_dirty.exchange(false, std::memory_order_acq_rel)) {
+      if (cur_line < min_line || cur_line > max_line) {
-        dirty_lines.push(c_line);
+        dirty_lines.push(cur_line);
-        c_line = scroll_max < 50 ? 0 : scroll_max - 50;
+        break;
       }
-      k_lock.lock();
+      uint32_t len;
-      if (c_line > editor->root->line_count) {
+      char *line = next_line(it, &len);
-        k_lock.unlock();
+      if (!line)
-        continue;
+        break;
-      }
+      LineData *line_data = line_tree.at(cur_line);
-      uint32_t r_offset, r_len;
-      r_offset = line_to_byte(editor->root, c_line, &r_len);
-      if (r_len > capacity) {
-        capacity = r_len;
-        text = (char *)realloc(text, capacity + 1);
-        memset(text, 0, capacity + 1);
-      }
-      read_into(editor->root, r_offset, r_len, text);
-      k_lock.unlock();
-      if (c_line < scroll_max &&
-          ((scroll_max > 100 && c_line > scroll_max - 100) || c_line < 100))
-        lock.lock();
-      if (line_tree.count() < c_line) {
-        if (lock.owns_lock())
-          lock.unlock();
-        continue;
-      }
-      lock_data.lock();
-      LineData *line_data = line_tree.at(c_line);
       if (!line_data) {
-        lock_data.unlock();
+        cur_line++;
-        if (lock.owns_lock())
-          lock.unlock();
         continue;
       }
-      std::shared_ptr<void> new_state{nullptr};
+      std::shared_ptr<void> new_state;
       if (is_custom) {
-        mrb_value state = mrb_nil_value();
+        std::string state = "";
-        if (prev_state) {
+        if (prev_state)
-          std::shared_ptr<CustomState> state_ptr =
+          state = std::static_pointer_cast<std::string>(prev_state)->c_str();
-              std::static_pointer_cast<CustomState>(prev_state);
+        std::string out_state = parse_custom(&line_data->tokens, parser_block,
-          state = state_ptr->state;
+                                             line, len, state, cur_line);
-        }
+        new_state = std::make_shared<std::string>(out_state);
-        mrb_value out_state = parse_custom(&line_data->tokens, parser_block,
-                                           text, r_len, state, c_line);
-        std::shared_ptr<CustomState> out_state_ptr =
-            std::make_shared<CustomState>(out_state);
-        new_state = out_state_ptr;
       } else {
         new_state =
-            parse_func(&line_data->tokens, prev_state, text, r_len, c_line);
+            parse_func(&line_data->tokens, prev_state, line, len, cur_line);
       }
       line_data->in_state = prev_state;
       line_data->out_state = new_state;
-      if (!running.load(std::memory_order_relaxed)) {
+      bool done = false;
-        free(text);
+      if (cur_line + 1 < line_count) {
-        return;
+        LineData *next_line_data = line_tree.at(cur_line + 1);
+        if (next_line_data) {
+          if (is_custom) {
+            std::string a =
+                prev_state
+                    ? std::static_pointer_cast<std::string>(new_state)->c_str()
+                    : "";
+            std::string b = next_line_data->in_state
+                                ? std::static_pointer_cast<std::string>(
+                                      next_line_data->in_state)
+                                      ->c_str()
+                                : "";
+            done = custom_compare(match_block, a, b);
+          } else {
+            done = state_match_func(new_state, next_line_data->in_state);
+          }
+        }
       }
       prev_state = new_state;
-      c_line++;
+      cur_line++;
-      if (c_line < line_count && c_line > scroll_max + 50 && scroll_max < 50 &&
+      if (done)
-          c_line < scroll_max + 50) {
-        lock_data.unlock();
-        if (lock.owns_lock())
-          lock.unlock();
-        if (c_line > 0)
-          dirty_lines.push(c_line - 1);
-        dirty_lines.push(c_line);
         break;
-      }
-      if (c_line < line_count && (line_data = line_tree.at(c_line))) {
-        bool done = false;
-        if (is_custom) {
-          mrb_value in_state_v = mrb_nil_value();
-          if (prev_state)
-            in_state_v =
-                std::static_pointer_cast<CustomState>(prev_state)->state;
-          mrb_value out_state_v = mrb_nil_value();
-          if (line_data->in_state)
-            out_state_v =
-                std::static_pointer_cast<CustomState>(line_data->in_state)
-                    ->state;
-          done = custom_compare(match_block, in_state_v, out_state_v);
-        } else {
-          done = state_match_func(prev_state, line_data->in_state);
-        }
-        if (done) {
-          lock_data.unlock();
-          if (lock.owns_lock())
-            lock.unlock();
-          break;
-        }
-      }
-      lock_data.unlock();
-      if (lock.owns_lock())
-        lock.unlock();
-    }
-    if (!running.load(std::memory_order_relaxed)) {
-      free(text);
-      return;
     }
+    free(it->buffer);
+    free(it);
   }
-  free(text);
-  lock_data.lock();
 }
 
 void Parser::scroll(uint32_t line) {
@@ -190,7 +136,6 @@ void Parser::scroll(uint32_t line) {
     uint32_t c_line = line > 50 ? line - 50 : 0;
     if (c_line >= line_tree.count())
       return;
-    std::unique_lock lock_data(data_mutex);
     if (line_tree.at(c_line)->in_state || line_tree.at(c_line)->out_state)
       return;
     scroll_dirty = true;

src/ui/bar.cc

@@ -1,66 +1,59 @@
 #include "ui/bar.h"
 #include "io/sysio.h"
+#include "lsp/lsp.h"
 #include "main.h"
+#include "syntax/decl.h"
+
+void Bar::work() {
+  std::lock_guard<std::mutex> lock(mtx);
+  Editor *editor = editors[current_editor];
+  bar_line =
+      bar_contents(mode, editor->lang.name, editor->warnings.size(),
+                   editor->lsp ? editor->lsp->lsp->command : "",
+                   editor->filename, editor->filename, editor->cursor.row + 1,
+                   editor->root->line_count + 1, screen.col);
+}
+
+void Bar::log(std::string message) {
+  std::lock_guard<std::mutex> lock(mtx);
+  log_line = message;
+}
 
 void Bar::render() {
-  Editor *editor = editors[current_editor];
+  std::lock_guard<std::mutex> lock(mtx);
+  USING(LSPInstance);
   uint32_t row = screen.row - 2;
-  uint32_t col = 0;
   uint32_t width = screen.col;
-  UNUSED(width);
+  std::string &line = bar_line.line;
-  uint32_t color = 0;
+  uint32_t i = 0;
-  uint32_t black = 0x0b0e14;
+  uint32_t col = 0;
-  uint32_t grey = 0x33363c;
+  while (i < line.length()) {
-  uint32_t dark_grey = 0x24272d;
+    uint32_t cluster_len =
-  uint32_t name_color = 0xced4df;
+        grapheme_next_character_break_utf8(line.c_str() + i, line.length() - i);
-  uint32_t lang_color = editor->lang.color;
+    std::string cluster = line.substr(i, cluster_len);
-  const char *symbol = "󱓧 ";
+    int width = display_width(cluster.c_str(), cluster_len);
-  const char *name = "EDITOR";
+    Highlight highlight = bar_line.get_highlight(col);
-  switch (mode) {
+    update(row, col, cluster.c_str(), highlight.fg, highlight.bg,
-  case NORMAL:
+           highlight.flags);
-    color = 0x82AAFF;
+    col += width;
-    symbol = " ";
+    i += cluster_len;
-    name = "NORMAL";
+    for (int w = 1; w < width; w++)
-    break;
+      update(row, col - w, "\x1b", highlight.fg, highlight.bg, highlight.flags);
-  case INSERT:
-    color = 0xFF8F40;
-    symbol = "󱓧 ";
-    name = "INSERT";
-    break;
-  case SELECT:
-    color = 0x9ADE7A;
-    symbol = "󱩧 ";
-    name = "SELECT";
-    break;
-  case RUNNER:
-    color = 0xFFD700;
-    symbol = " ";
-    name = "RUNNER";
-    break;
-  case JUMPER:
-    color = 0xF29CC3;
-    symbol = " ";
-    name = "JUMPER";
-    break;
   }
-  update(row, col, " ", black, color, CF_BOLD);
+  while (col < width)
-  update(row, ++col, symbol, black, color, CF_BOLD);
+    update(row, col++, " ", 0, 0, 0);
-  update(row, ++col, "\x1b", black, color, CF_BOLD);
+  col = 0;
-  update(row, ++col, " ", black, color, CF_BOLD);
+  row++;
-  for (uint32_t i = 0; i < 6; i++)
+  if (mode == RUNNER) {
-    update(row, ++col, {name[i], 0}, black, color, CF_BOLD);
+    update(row, col++, ":", 0xFFFFFF, 0, 0);
-  update(row, ++col, " ", black, color, CF_BOLD);
+    for (char c : command)
-  update(row, ++col, "◗", color, grey, CF_BOLD);
+      update(row, col++, (char[2]){c, 0}, 0xFFFFFF, 0, 0);
-  update(row, ++col, "◗", grey, dark_grey, CF_BOLD);
+  } else {
-  update(row, ++col, " ", name_color, dark_grey, CF_BOLD);
+    for (char c : log_line)
-  update(row, ++col, editor->lang.symbol, lang_color, dark_grey, 0);
+      update(row, col++, (char[2]){c, 0}, 0xFFFFFF, 0, 0);
-  update(row, ++col, "\x1b", lang_color, dark_grey, 0);
+  }
-  update(row, ++col, " ", name_color, dark_grey, CF_BOLD);
+  while (col < width)
-  std::string filename = filename_from_path(editor->filename);
+    update(row, col++, " ", 0, 0, 0);
-  for (uint32_t i = 0; i < filename.length(); i++)
-    update(row, ++col, {filename[i], 0}, name_color, dark_grey, CF_BOLD);
-  update(row, ++col, " ", name_color, dark_grey, CF_BOLD);
-  update(row, ++col, "◗", dark_grey, 1, CF_BOLD);
 }
 
 void Bar::handle(KeyEvent event) {
@@ -68,11 +61,26 @@ void Bar::handle(KeyEvent event) {
     if (event.c[0] == 0x1B) {
       mode = NORMAL;
     } else if (event.c[0] == '\n' || event.c[0] == '\r') {
-      // execute command while stripping starting `[:;]`
+      command = trim(command);
+      if (command == "w") {
+        save_file(editors[current_editor]);
+      } else if (command == "q") {
+        running = false;
+      } else if (command == "wq") {
+        save_file(editors[current_editor]);
+        running = false;
+      }
       mode = NORMAL;
       command = "";
     } else if (isprint((unsigned char)(event.c[0]))) {
-    } else if (event.c[0] == 0x7F || event.c[0] == 0x08) { // backspace
+      command += event.c[0];
+    } else if (event.c[0] == 0x7F || event.c[0] == 0x08) {
+      if (command.length() > 0) {
+        command = command.substr(0, command.length() - 1);
+      } else {
+        mode = NORMAL;
+        command = "";
+      }
     }
   } else if (event.key_type == KEY_SPECIAL) {
     switch (event.special_key) {

src/ui/completionbox.cc

@@ -71,7 +71,9 @@ void CompletionBox::render_update() {
   uint32_t max_label_len = 0;
   uint32_t max_detail_len = 0;
   uint32_t max_kind_len = 0;
-  for (auto i : session->visible) {
+  for (uint32_t x = session->scroll;
+       x < session->scroll + 8 && x < session->visible.size(); x++) {
+    uint32_t i = session->visible[x];
     if (i >= session->items.size())
       continue;
     auto &item = session->items[i];
@@ -81,7 +83,9 @@ void CompletionBox::render_update() {
     max_kind_len =
         MAX(max_kind_len, (uint32_t)item_kind_name(item.kind).size());
   }
-  size.row = session->visible.size() + 2;
+  uint32_t total = session->visible.size();
+  uint32_t rows = MIN(total, 8);
+  size.row = rows + 2;
   size.col = 2 + 2 + max_label_len + 1 + max_detail_len + 2 + max_kind_len + 1;
   cells.assign(size.row * size.col, {" ", 0, 0, 0, 0, 0});
   auto set = [&](uint32_t r, uint32_t c, const char *text, uint32_t fg,
@@ -95,8 +99,10 @@ void CompletionBox::render_update() {
   for (uint32_t c = 1; c < size.col - 1; c++)
     set(0, c, "─", border_fg, 0, 0);
   set(0, size.col - 1, "┐", border_fg, 0, 0);
-  for (uint32_t row_idx = 0; row_idx < session->visible.size(); row_idx++) {
+  uint32_t start = session->scroll;
-    uint32_t r = row_idx + 1;
+  uint32_t end = MIN(start + 8, session->visible.size());
+  for (uint32_t row_idx = start; row_idx < end; row_idx++) {
+    uint32_t r = (row_idx - start) + 1;
     auto &item = session->items[session->visible[row_idx]];
     uint32_t bg = (session->visible[row_idx] == session->select) ? sel_bg : 1;
     uint32_t fg = 0xFFFFFF;
@@ -130,6 +136,12 @@ void CompletionBox::render_update() {
   for (uint32_t c = 1; c < size.col - 1; c++)
     set(bottom, c, "─", border_fg, 0, 0);
   set(bottom, size.col - 1, "┘", border_fg, 0, 0);
+  if (session->visible.size() > 8) {
+    std::string info = std::to_string(start + 1) + "-" + std::to_string(end) +
+                       "/" + std::to_string(session->visible.size());
+    for (size_t i = 0; i < info.size() && i < size.col - 2; i++)
+      set(bottom, 1 + i, (char[2]){info[i], 0}, border_fg, 0, 0);
+  }
 }
 
 void CompletionBox::render(Coord pos) {

src/utils/system.cc

@@ -1,8 +1,8 @@
+#include "scripting/decl.h"
 #include "utils/utils.h"
 
 std::unordered_map<std::string, Language> languages;
 std::unordered_map<std::string, std::string> language_extensions;
-std::unordered_map<std::string, std::string> language_mimetypes;
 std::unordered_map<std::string, LSP> lsps;
 
 void log(const char *fmt, ...) {
@@ -106,88 +106,18 @@ static std::string file_extension(const char *filename) {
   return ext;
 }
 
-char *detect_file_type(const char *filename) {
-  magic_t magic = magic_open(MAGIC_MIME_TYPE);
-  if (!magic)
-    return nullptr;
-  if (magic_load(magic, nullptr) != 0) {
-    magic_close(magic);
-    return nullptr;
-  }
-  const char *type = magic_file(magic, filename);
-  if (!type) {
-    magic_close(magic);
-    return nullptr;
-  }
-  char *result = strdup(type);
-  magic_close(magic);
-  return result;
-}
-
 Language language_for_file(const char *filename) {
   std::string ext = file_extension(filename);
-  std::string lang_name;
   if (!ext.empty()) {
     auto it = language_extensions.find(ext);
     if (it != language_extensions.end())
       return languages.find(it->second)->second;
   }
-  char *mime = detect_file_type(filename);
+  std::string lang_name = ruby_file_detect(filename);
-  if (mime) {
+  if (!lang_name.empty()) {
-    std::string mime_type(mime);
+    auto it = languages.find(lang_name);
-    free(mime);
+    if (it != languages.end())
-    auto it = language_mimetypes.find(mime_type);
+      return it->second;
-    if (it != language_mimetypes.end())
-      return languages.find(it->second)->second;
   }
   return Language{};
 }
-
-char *get_from_clipboard(uint32_t *out_len) {
-  FILE *pipe = popen("xclip -selection clipboard -o", "r");
-  if (!pipe) {
-    *out_len = 0;
-    return nullptr;
-  }
-  size_t capacity = 4096;
-  size_t length = 0;
-  char *buffer = (char *)malloc(capacity);
-  if (!buffer) {
-    pclose(pipe);
-    *out_len = 0;
-    return nullptr;
-  }
-  size_t n;
-  while ((n = fread(buffer + length, 1, capacity - length, pipe)) > 0) {
-    length += n;
-    if (length == capacity) {
-      capacity *= 2;
-      char *tmp = (char *)realloc(buffer, capacity);
-      if (!tmp) {
-        free(buffer);
-        pclose(pipe);
-        *out_len = 0;
-        return nullptr;
-      }
-      buffer = tmp;
-    }
-  }
-  pclose(pipe);
-  char *result = (char *)realloc(buffer, length + 1);
-  if (result) {
-    result[length] = '\0';
-    buffer = result;
-  } else {
-    buffer[length] = '\0';
-  }
-  *out_len = length;
-  return buffer;
-}
-
-void copy_to_clipboard(const char *text, size_t len) {
-  FILE *pipe = popen("xclip -selection clipboard", "w");
-  if (!pipe)
-    return;
-  fwrite(text, sizeof(char), len, pipe);
-  pclose(pipe);
-}

src/utils/unicode.cc

@@ -1,4 +1,3 @@
-#include "utfcpp/source/utf8.h"
 #include "utils/utils.h"
 
 int display_width(const char *str, size_t len) {
@@ -99,42 +98,48 @@ uint32_t count_clusters(const char *line, size_t len, size_t from, size_t to) {
   return count;
 }
 
-size_t utf8_offset_to_utf16(const char *utf8, size_t utf8_len,
+size_t utf8_offset_to_utf16(const char *s, size_t utf8_len, size_t byte_pos) {
-                            size_t byte_offset) {
+  if (byte_pos > utf8_len)
-  if (byte_offset > utf8_len)
+    return 0;
-    return byte_offset;
+  size_t utf16_units = 0;
-  const char *start = utf8;
+  size_t i = 0;
-  const char *mid = utf8 + byte_offset;
+  while (i < byte_pos) {
-  if (!utf8::is_valid(start, mid))
+    unsigned char c = s[i];
-    assert(0 && "invalid utf8");
+    if ((c & 0x80) == 0x00) {
-  size_t utf16_offset = 0;
+      i += 1;
-  for (auto it = start; it < mid;) {
+      utf16_units += 1;
-    uint32_t codepoint = utf8::next(it, mid);
+    } else if ((c & 0xE0) == 0xC0) {
-    if (codepoint <= 0xFFFF)
+      i += 2;
-      utf16_offset += 1;
+      utf16_units += 1;
-    else
+    } else if ((c & 0xF0) == 0xE0) {
-      utf16_offset += 2;
+      i += 3;
+      utf16_units += 1;
+    } else {
+      i += 4;
+      utf16_units += 2;
+    }
   }
-  return utf16_offset;
+  return utf16_units;
 }
 
-size_t utf16_offset_to_utf8(const char *utf8, size_t utf8_len,
+size_t utf16_offset_to_utf8(const char *s, size_t utf8_len, size_t utf16_pos) {
-                            size_t utf16_offset) {
+  size_t utf16_units = 0;
-  const char *start = utf8;
+  size_t i = 0;
-  const char *end = utf8 + utf8_len;
+  while (utf16_units < utf16_pos && i < utf8_len) {
-  const char *it = start;
+    unsigned char c = s[i];
-  size_t utf16_count = 0;
+    if ((c & 0x80) == 0x00) {
-  while (it < end) {
+      i += 1;
-    if (utf16_count >= utf16_offset)
+      utf16_units += 1;
-      break;
+    } else if ((c & 0xE0) == 0xC0) {
-    const char *prev = it;
+      i += 2;
-    uint32_t codepoint = utf8::next(it, end);
+      utf16_units += 1;
-    if (codepoint <= 0xFFFF)
+    } else if ((c & 0xF0) == 0xE0) {
-      utf16_count += 1;
+      i += 3;
-    else
+      utf16_units += 1;
-      utf16_count += 2;
+    } else {
-    if (utf16_count > utf16_offset)
+      i += 4;
-      return prev - start;
+      utf16_units += 2;
+    }
   }
-  return it - start;
+  return i;
 }