diff --git a/ChangeLog b/ChangeLog index 4fc4e065e92..c034a293004 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,7 @@ +2013-09-15 Jan Djärv + + * configure.ac: Add check for OSX 10.5, required for macfont.o. + 2013-09-09 Glenn Morris * configure.ac (LDFLAGS_NOCOMBRELOC): New variable. diff --git a/configure.ac b/configure.ac index 55e8a69b542..6deeb045273 100644 --- a/configure.ac +++ b/configure.ac @@ -1625,7 +1625,10 @@ fail; [AC_MSG_ERROR([`--with-ns' was specified, but the include files are missing or cannot be compiled.])]) - AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], + macfont_file="" + if test "${NS_IMPL_COCOA}" = "yes"; then + AC_MSG_CHECKING([for OSX 10.4 or newer]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], [ #ifdef MAC_OS_X_VERSION_MAX_ALLOWED #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1040 @@ -1637,13 +1640,33 @@ fail; ])], ns_osx_have_104=yes, ns_osx_have_104=no) + AC_MSG_RESULT([$ns_osx_have_104]) + + if test $ns_osx_have_104 = no; then + AC_MSG_ERROR([`OSX 10.4 or newer is required']); + fi + AC_MSG_CHECKING([for OSX 10.5 or newer]) + AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], + [ +#ifdef MAC_OS_X_VERSION_MAX_ALLOWED +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + ; /* OK */ +#else +#error "OSX 10.5 not found" +#endif +#endif + ])], + ns_osx_have_105=yes, + ns_osx_have_105=no) + AC_MSG_RESULT([$ns_osx_have_105]) + if test $ns_osx_have_105 = yes; then + macfont_file="macfont.o" + fi + fi AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include ], [NSInteger i;])], ns_have_nsinteger=yes, ns_have_nsinteger=no) - if test $ns_osx_have_104 = no; then - AC_MSG_ERROR([`OSX 10.4 or newer is required']); - fi if test $ns_have_nsinteger = yes; then AC_DEFINE(NS_HAVE_NSINTEGER, 1, [Define to 1 if `NSInteger' is defined.]) fi @@ -1679,7 +1702,8 @@ if test "${HAVE_NS}" = yes; then leimdir="\${ns_appresdir}/leim" INSTALL_ARCH_INDEP_EXTRA= fi - NS_OBJC_OBJ="nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o" + + NS_OBJC_OBJ="nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o $macfont_file" fi CFLAGS="$tmp_CFLAGS" CPPFLAGS="$tmp_CPPFLAGS" diff --git a/doc/lispref/display.texi b/doc/lispref/display.texi index 2e7d4f4c010..8ebf440c9fe 100644 --- a/doc/lispref/display.texi +++ b/doc/lispref/display.texi @@ -4190,8 +4190,8 @@ variables: @defvar left-margin-width This variable specifies the width of the left margin, in character -cell units. It is buffer-local in all buffers. A value of @code{nil} -means no left marginal area. +cell (a.k.a.@: ``column'') units. It is buffer-local in all buffers. +A value of @code{nil} means no left marginal area. @end defvar @defvar right-margin-width @@ -4209,17 +4209,16 @@ Thus, you can make changes take effect by calling @defun set-window-margins window left &optional right This function specifies the margin widths for window @var{window}, in -character cell (a.k.a.@: ``column''), units. The argument @var{left} -controls the left margin and @var{right} controls the right margin -(default @code{0}). +character cell units. The argument @var{left} controls the left +margin, and @var{right} controls the right margin (default @code{0}). @end defun @defun window-margins &optional window This function returns the width of the left and right margins of @var{window} as a cons cell of the form @w{@code{(@var{left} . @var{right})}}. If one of the two marginal areas does not exist, -its width is returned as @code{nil}; if none of the two margins exist, -the function returns @code{nil}. If @var{window} is @code{nil}, the +its width is returned as @code{nil}; if neither of the two margins exist, +the function returns @code{(nil)}. If @var{window} is @code{nil}, the selected window is used. @end defun diff --git a/doc/misc/ChangeLog b/doc/misc/ChangeLog index aa1e69891a2..4a52e2314ca 100644 --- a/doc/misc/ChangeLog +++ b/doc/misc/ChangeLog @@ -1,3 +1,7 @@ +2013-09-14 Glenn Morris + + * eshell.texi: Markup fixes. + 2013-09-11 Xue Fuqiao * ido.texi (Interactive Substring Matching): Use @key{RET} instead diff --git a/doc/misc/eshell.texi b/doc/misc/eshell.texi index 4604b262e72..bbe741a7a1d 100644 --- a/doc/misc/eshell.texi +++ b/doc/misc/eshell.texi @@ -353,7 +353,7 @@ sudo is an alias, defined as "*sudo $*" @vindex eshell-prefer-lisp-functions If you would prefer to use the built-in commands instead of the external -commands, set @var{eshell-prefer-lisp-functions} to @code{t}. +commands, set @code{eshell-prefer-lisp-functions} to @code{t}. Some of the built-in commands have different behaviour from their external counterparts, and some have no external counterpart. Most of @@ -515,7 +515,7 @@ Aliases are commands that expand to a longer input line. For example, with the command invocation @samp{alias ll ls -l}; with this defined, running @samp{ll foo} in Eshell will actually run @samp{ls -l foo}. Aliases defined (or deleted) by the @command{alias} command are -automatically written to the file named by @var{eshell-aliases-file}, +automatically written to the file named by @code{eshell-aliases-file}, which you can also edit directly (although you will have to manually reload it). @@ -539,7 +539,7 @@ by @code{!foo:n}. The history ring is loaded from a file at the start of every session, and written back to the file at the end of every session. The file path -is specified in @var{eshell-history-file-name}. Unlike other shells, +is specified in @code{eshell-history-file-name}. Unlike other shells, such as Bash, Eshell can not be configured to keep a history ring of a different size than that of the history file. @@ -721,11 +721,11 @@ terminal emulator. Programs that need a terminal to display output properly are referred to in this manual as ``visual commands,'' because they are not simply line-oriented. You must tell Eshell which commands are visual, by -adding them to @var{eshell-visual-commands}; for commands that are +adding them to @code{eshell-visual-commands}; for commands that are visual for only certain @emph{sub}-commands -- e.g. @samp{git log} but -not @samp{git status} -- use @var{eshell-visual-subcommands}; and for +not @samp{git status} -- use @code{eshell-visual-subcommands}; and for commands that are visual only when passed certain options, use -@var{eshell-visual-options}. +@code{eshell-visual-options}. @section Redirection Redirection is mostly the same in Eshell as it is in other command @@ -740,16 +740,16 @@ on the right-hand side, into which it inserts the output of the left-hand side. e.g., @samp{echo hello >>> #} inserts the string @code{"hello"} into the @code{*scratch*} buffer. -@var{eshell-virtual-targets} is a list of mappings of virtual device +@code{eshell-virtual-targets} is a list of mappings of virtual device names to functions. Eshell comes with two virtual devices: @file{/dev/kill}, which sends the text to the kill ring, and @file{/dev/clip}, which sends text to the clipboard. You can, of course, define your own virtual targets. They are defined -by adding a list of the form @code{("/dev/name" function mode)} to -@var{eshell-virtual-targets}. The first element is the device name; -@code{function} may be either a lambda or a function name. If -@code{mode} is nil, then the function is the output function; if it is +by adding a list of the form @samp{("/dev/name" @var{function} @var{mode})} to +@code{eshell-virtual-targets}. The first element is the device name; +@var{function} may be either a lambda or a function name. If +@var{mode} is nil, then the function is the output function; if it is non-nil, then the function is passed the redirection mode as a symbol--@code{overwrite} for @code{>}, @code{append} for @code{>>}, or @code{insert} for @code{>>>}--and the function is expected to return @@ -774,7 +774,7 @@ Eshell module.} You also need to load the following as shown: @example (eval-when-compile - (require 'cl) + (require 'cl-lib) (require 'esh-mode) (require 'eshell)) diff --git a/etc/ChangeLog b/etc/ChangeLog index bd5534d9446..5483d824da4 100644 --- a/etc/ChangeLog +++ b/etc/ChangeLog @@ -1,3 +1,7 @@ +2013-09-15 Jan Djärv + + * NEWS: Mention the macfont backend. + 2013-09-09 Glenn Morris * refcards/Makefile (PS_ENGLISH, PS_CZECH, PS_FRENCH, PS_GERMAN) diff --git a/etc/NEWS b/etc/NEWS index a5da8eaa893..7558fc53052 100644 --- a/etc/NEWS +++ b/etc/NEWS @@ -54,6 +54,11 @@ and zlib-format compressed data. ** Emacs for NS (OSX, GNUStep) can be built with ImageMagick support. pkg-config is required to find ImageMagick libraries. +** For OSX >= 10.5, the Core text based font backend from the Mac port is used. +For GNUStep and OSX 10.4 the old backend is used. +To use the old backend by default, do on the command line: +% defaults write org.gnu.Emacs FontBackend ns + * Startup Changes in Emacs 24.4 diff --git a/lisp/ChangeLog b/lisp/ChangeLog index ba3de9f4305..44a81ee32fc 100644 --- a/lisp/ChangeLog +++ b/lisp/ChangeLog @@ -1,3 +1,27 @@ +2013-09-15 Dmitry Gutov + + * progmodes/ruby-mode.el (ruby-operator-re): Consider line + continuation character an operator, as far as indentation is + concerned (Bug#15369). + +2013-09-15 Martin Rudalics + + * window.el (window--state-put-2): Don't process buffer state + when buffer doesn't exist any more (Bug#15382). + +2013-09-15 Glenn Morris + + * eshell/em-unix.el (eshell/rm): + Make -f ignore missing files. (Bug#15373) + + * eshell/esh-cmd.el (eshell--local-vars): New variable. (Bug#15372) + (eshell-rewrite-for-command): Add for loop vars to eshell--local-vars. + * eshell/esh-var.el (eshell-get-variable): Respect eshell--local-vars. + +2013-09-14 Glenn Morris + + * eshell/esh-var.el (eshell-variable-aliases-list): Fix doc typo. + 2013-09-13 Glenn Morris * dired-x.el (dired-guess-shell-alist-user): Doc fix. diff --git a/lisp/dired.el b/lisp/dired.el index 345e8d57113..27327352afb 100644 --- a/lisp/dired.el +++ b/lisp/dired.el @@ -4352,7 +4352,7 @@ instead. ;;;*** -;;;### (autoloads nil "dired-x" "dired-x.el" "11fd4a8afa32507cc32d4a04d852587f") +;;;### (autoloads nil "dired-x" "dired-x.el" "732d08c173295dd14a0736fa222f532a") ;;; Generated autoloads from dired-x.el (autoload 'dired-jump "dired-x" "\ diff --git a/lisp/erc/ChangeLog b/lisp/erc/ChangeLog index 70cab5af319..2c10f7fef22 100644 --- a/lisp/erc/ChangeLog +++ b/lisp/erc/ChangeLog @@ -1,3 +1,8 @@ +2013-09-14 Vivek Dasmohapatra + + * erc.el (erc-update-mode-line-buffer): + Handle absent topic. (Bug#15377) + 2013-09-13 Glenn Morris * erc-desktop-notifications.el (dbus-debug): Declare. diff --git a/lisp/erc/erc.el b/lisp/erc/erc.el index 0bfd21d6c3a..771b7016bcd 100644 --- a/lisp/erc/erc.el +++ b/lisp/erc/erc.el @@ -6189,7 +6189,7 @@ if `erc-away' is non-nil." ?m (erc-format-channel-modes) ?n (or (erc-current-nick) "") ?N (erc-format-network) - ?o (erc-controls-strip erc-channel-topic) + ?o (or (erc-controls-strip erc-channel-topic) "") ?p (erc-port-to-string erc-session-port) ?s (erc-format-target-and/or-server) ?S (erc-format-target-and/or-network) diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el index 52d2b4d2a2d..5792fe17506 100644 --- a/lisp/eshell/em-unix.el +++ b/lisp/eshell/em-unix.el @@ -284,18 +284,21 @@ Remove (unlink) the FILE(s).") entry))))) (eshell-funcalln 'unintern entry))) ((stringp entry) - (if (and (file-directory-p entry) - (not (file-symlink-p entry))) - (if (or em-recursive - eshell-rm-removes-directories) - (if (or em-preview - (not em-interactive) - (y-or-n-p - (format "rm: descend into directory `%s'? " - entry))) + ;; -f should silently ignore missing files (bug#15373). + (unless (and force-removal + (not (file-exists-p entry))) + (if (and (file-directory-p entry) + (not (file-symlink-p entry))) + (if (or em-recursive + eshell-rm-removes-directories) + (if (or em-preview + (not em-interactive) + (y-or-n-p + (format "rm: descend into directory `%s'? " + entry))) (eshell-remove-entries nil (list entry) t)) - (eshell-error (format "rm: %s: is a directory\n" entry))) - (eshell-remove-entries nil (list entry) t))))) + (eshell-error (format "rm: %s: is a directory\n" entry))) + (eshell-remove-entries nil (list entry) t)))))) (setq args (cdr args))) nil)) diff --git a/lisp/eshell/esh-cmd.el b/lisp/eshell/esh-cmd.el index cc4fdd15bda..75e0e1d27c8 100644 --- a/lisp/eshell/esh-cmd.el +++ b/lisp/eshell/esh-cmd.el @@ -473,6 +473,8 @@ the second is ignored." arg)) (defvar eshell-last-command-status) ;Define in esh-io.el. +(defvar eshell--local-vars nil + "List of locally bound vars that should take precedence over env-vars.") (defun eshell-rewrite-for-command (terms) "Rewrite a `for' command into its equivalent Eshell command form. @@ -495,7 +497,9 @@ implemented via rewriting, rather than as a function." (eshell-command-body '(nil)) (eshell-test-body '(nil))) (while (car for-items) - (let ((,(intern (cadr terms)) (car for-items))) + (let ((,(intern (cadr terms)) (car for-items)) + (eshell--local-vars (cons ',(intern (cadr terms)) + eshell--local-vars))) (eshell-protect ,(eshell-invokify-arg body t))) (setcar for-items (cadr for-items)) diff --git a/lisp/eshell/esh-var.el b/lisp/eshell/esh-var.el index f68b65dfd46..3121dadace2 100644 --- a/lisp/eshell/esh-var.el +++ b/lisp/eshell/esh-var.el @@ -184,9 +184,9 @@ if they are quoted with a backslash." indices))))) "This list provides aliasing for variable references. It is very similar in concept to what `eshell-user-aliases-list' does -for commands. Each member of this defines defines the name of a -command, and the Lisp value to return for that variable if it is -accessed via the syntax '$NAME'. +for commands. Each member of this defines the name of a command, +and the Lisp value to return for that variable if it is accessed +via the syntax '$NAME'. If the value is a function, that function will be called with two arguments: the list of the indices that was used in the reference, and @@ -502,6 +502,7 @@ Possible options are: (let ((sym (intern-soft var))) (if (and sym (boundp sym) (or eshell-prefer-lisp-variables + (memq sym eshell--local-vars) ; bug#15372 (not (getenv var)))) (symbol-value sym) (getenv var)))) diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el index 902616e3023..95206c15390 100644 --- a/lisp/progmodes/ruby-mode.el +++ b/lisp/progmodes/ruby-mode.el @@ -132,7 +132,7 @@ This should only be called after matching against `ruby-here-doc-beg-re'." ruby-block-end-re "\\|}\\|\\]\\)") "Regexp to match where the indentation gets shallower.") -(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]" +(defconst ruby-operator-re "[-,.+*/%&|^~=<>:]\\|\\\\$" "Regexp to match operators.") (defconst ruby-symbol-chars "a-zA-Z0-9_" diff --git a/lisp/window.el b/lisp/window.el index a111b3cb5b4..14e9f6bc128 100644 --- a/lisp/window.el +++ b/lisp/window.el @@ -4464,62 +4464,66 @@ value can be also stored on disk and read back in a new session." (set-window-parameter window (car parameter) (cdr parameter)))) ;; Process buffer related state. (when state - ;; We don't want to raise an error in case the buffer does not - ;; exist anymore, so we switch to a previous one and save the - ;; window with the intention of deleting it later if possible. (let ((buffer (get-buffer (car state)))) (if buffer - (set-window-buffer window buffer) + (with-current-buffer buffer + (set-window-buffer window buffer) + (set-window-hscroll window (cdr (assq 'hscroll state))) + (apply 'set-window-fringes + (cons window (cdr (assq 'fringes state)))) + (let ((margins (cdr (assq 'margins state)))) + (set-window-margins window (car margins) (cdr margins))) + (let ((scroll-bars (cdr (assq 'scroll-bars state)))) + (set-window-scroll-bars + window (car scroll-bars) (nth 2 scroll-bars) + (nth 3 scroll-bars))) + (set-window-vscroll window (cdr (assq 'vscroll state))) + ;; Adjust vertically. + (if (memq window-size-fixed '(t height)) + ;; A fixed height window, try to restore the + ;; original size. + (let ((delta (- (cdr (assq 'total-height item)) + (window-total-height window))) + window-size-fixed) + (when (window-resizable-p window delta) + (window-resize window delta))) + ;; Else check whether the window is not high enough. + (let* ((min-size (window-min-size window nil ignore)) + (delta (- min-size (window-total-size window)))) + (when (and (> delta 0) + (window-resizable-p window delta nil ignore)) + (window-resize window delta nil ignore)))) + ;; Adjust horizontally. + (if (memq window-size-fixed '(t width)) + ;; A fixed width window, try to restore the original + ;; size. + (let ((delta (- (cdr (assq 'total-width item)) + (window-total-width window))) + window-size-fixed) + (when (window-resizable-p window delta) + (window-resize window delta))) + ;; Else check whether the window is not wide enough. + (let* ((min-size (window-min-size window t ignore)) + (delta (- min-size (window-total-size window t)))) + (when (and (> delta 0) + (window-resizable-p window delta t ignore)) + (window-resize window delta t ignore)))) + ;; Set dedicated status. + (set-window-dedicated-p window (cdr (assq 'dedicated state))) + ;; Install positions (maybe we should do this after all + ;; windows have been created and sized). + (ignore-errors + (set-window-start window (cdr (assq 'start state))) + (set-window-point window (cdr (assq 'point state)))) + ;; Select window if it's the selected one. + (when (cdr (assq 'selected state)) + (select-window window))) + ;; We don't want to raise an error in case the buffer does + ;; not exist anymore, so we switch to a previous one and + ;; save the window with the intention of deleting it later + ;; if possible. (switch-to-prev-buffer window) - (push window window-state-put-stale-windows))) - (with-current-buffer (window-buffer window) - (set-window-hscroll window (cdr (assq 'hscroll state))) - (apply 'set-window-fringes - (cons window (cdr (assq 'fringes state)))) - (let ((margins (cdr (assq 'margins state)))) - (set-window-margins window (car margins) (cdr margins))) - (let ((scroll-bars (cdr (assq 'scroll-bars state)))) - (set-window-scroll-bars - window (car scroll-bars) (nth 2 scroll-bars) (nth 3 scroll-bars))) - (set-window-vscroll window (cdr (assq 'vscroll state))) - ;; Adjust vertically. - (if (memq window-size-fixed '(t height)) - ;; A fixed height window, try to restore the original size. - (let ((delta (- (cdr (assq 'total-height item)) - (window-total-height window))) - window-size-fixed) - (when (window-resizable-p window delta) - (window-resize window delta))) - ;; Else check whether the window is not high enough. - (let* ((min-size (window-min-size window nil ignore)) - (delta (- min-size (window-total-size window)))) - (when (and (> delta 0) - (window-resizable-p window delta nil ignore)) - (window-resize window delta nil ignore)))) - ;; Adjust horizontally. - (if (memq window-size-fixed '(t width)) - ;; A fixed width window, try to restore the original size. - (let ((delta (- (cdr (assq 'total-width item)) - (window-total-width window))) - window-size-fixed) - (when (window-resizable-p window delta) - (window-resize window delta))) - ;; Else check whether the window is not wide enough. - (let* ((min-size (window-min-size window t ignore)) - (delta (- min-size (window-total-size window t)))) - (when (and (> delta 0) - (window-resizable-p window delta t ignore)) - (window-resize window delta t ignore)))) - ;; Set dedicated status. - (set-window-dedicated-p window (cdr (assq 'dedicated state))) - ;; Install positions (maybe we should do this after all windows - ;; have been created and sized). - (ignore-errors - (set-window-start window (cdr (assq 'start state))) - (set-window-point window (cdr (assq 'point state)))) - ;; Select window if it's the selected one. - (when (cdr (assq 'selected state)) - (select-window window))))))) + (push window window-state-put-stale-windows))))))) (defun window-state-put (state &optional window ignore) "Put window state STATE into WINDOW. diff --git a/src/ChangeLog b/src/ChangeLog index 00f3fa8eccf..0050d949dd2 100644 --- a/src/ChangeLog +++ b/src/ChangeLog @@ -1,3 +1,69 @@ +2013-09-15 Jan Djärv + + * nsfns.m (Fx_create_frame): Fix font driver registration for + GNUStep. + + * font.c (syms_of_font): Check MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + for syms_of_macfont. + + * nsterm.m: Include macfont.h. + (ns_tmp_flags, ns_tmp_font): Remove. + (ns_compute_glyph_string_overhangs): Check for driver Qns. + (ns_draw_glyph_string): Use local variables instead of ns_tmp_flags, + ns_tmp_font. Call ns_draw_text_decoration here instead of nsfont.m. + (changeFont:): Fix code style. Check for font driver type when + getiing font. + + * nsterm.h (FONT_DESCENT, FONT_ASCENT): Define to (f)->ascent and + (f)->descent. + + * nsfont.m (ns_tmp_flags, ns_tmp_font): Remove. + (nsfont_open): Set font driver type. + Set font->ascent and font->descent. Figure out font instead of + ns_tmp_font, and flags instead of ns_tmp_flags. + Fix indentation. Remove call to ns_draw_text_decoration, + moved to nsterm. + + * nsfns.m: Include macfont.h. + (Fx_create_frame): Register macfont driver, make a better default font. + (Fns_popup_font_panel): Get font from macfont driver, if used. + + * macfont.m, macfont.h, maccuvs.h: New files. + + * font.h: Declare syms_of_macfont. + + * font.c (syms_of_font): Call syms_of_macfont. + + * Makefile.in (NS_OBJ, SOME_MACHINE_OBJECTS): Add macfont.o. + +2013-09-15 Dmitry Antipov + + Drop VERTICAL_SCROLL_BAR_WIDTH_TRIM. For X, it is zero since 1999, + and it is always zero for others, so I assume that this is an ancient + leftover which nobody will want to change any more. + * xterm.h, w32term.h, nsterm.h (VERTICAL_SCROLL_BAR_WIDTH_TRIM): Remove. + (VERTICAL_SCROLL_BAR_INSIDE_WIDTH): + * frame.c (x_set_scroll_bar_width): + * w32fns.c (w32_createscrollbar): + * w32term.c (w32_set_vertical_scroll_bar): + * xfns.c (x_set_scroll_bar_default_width): + * xterm.c (XTflash, x_scroll_bar_create, XTset_vertical_scroll_bar) + (x_scroll_bar_expose): Related users changed. + +2013-09-15 Dmitry Antipov + + * xterm.h (FRAME_X_SCREEN_NUMBER): Add comment. + (BLACK_PIX_DEFAULT, WHITE_PIX_DEFAULT): Use FRAME_X_SCREEN_NUMBER. + (SCROLL_BAR_X_WIDGET, SET_SCROLL_BAR_X_WIDGET) [USE_X_TOOLKIT]: + Define as such. + * frame.h (FRAME_SMALLEST_CHAR_WIDTH, FRAME_SMALLEST_FONT_HEIGHT): + Define once here... + * nsterm.h, w32term.h, xterm.h: ...and not here. + * w32term.h (SCROLL_BAR_X_WIDGET, SET_SCROLL_BAR_X_WIDGET): + Remove unused Xisms. + * xterm.c, xfns.c (toplevel): Remove #ifdef HAVE_X_WINDOWS because + these modules are never compiled otherwise. + 2013-09-14 Eli Zaretskii * buffer.c (syms_of_buffer) : diff --git a/src/Makefile.in b/src/Makefile.in index aa51108ffc2..3e45a5bfff8 100644 --- a/src/Makefile.in +++ b/src/Makefile.in @@ -272,7 +272,7 @@ MSDOS_OBJ = MSDOS_X_OBJ = NS_OBJ=@NS_OBJ@ -## nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o if HAVE_NS. +## nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o macfont.o if HAVE_NS. NS_OBJC_OBJ=@NS_OBJC_OBJ@ ## Only set if NS_IMPL_GNUSTEP. GNU_OBJC_CFLAGS=@GNU_OBJC_CFLAGS@ @@ -397,7 +397,7 @@ xwidget.o: xwidget.c xwidget.h SOME_MACHINE_OBJECTS = dosfns.o msdos.o \ xterm.o xfns.o xmenu.o xselect.o xrdb.o xsmfns.o fringe.o image.o \ fontset.o dbusbind.o cygw32.o \ - nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o \ + nsterm.o nsfns.o nsmenu.o nsselect.o nsimage.o nsfont.o macfont.o \ w32.o w32console.o w32fns.o w32heap.o w32inevt.o w32notify.o \ w32menu.o w32proc.o w32reg.o w32select.o w32term.o w32xfns.o \ w16select.o widget.o xfont.o ftfont.o xftfont.o ftxfont.o gtkutil.o \ diff --git a/src/font.c b/src/font.c index fb64f2d9071..cc832f9a88a 100644 --- a/src/font.c +++ b/src/font.c @@ -5199,6 +5199,9 @@ EMACS_FONT_LOG is set. Otherwise, it is set to t. */); #endif /* HAVE_NTGUI */ #ifdef HAVE_NS syms_of_nsfont (); +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + syms_of_macfont (); +#endif #endif /* HAVE_NS */ #endif /* HAVE_WINDOW_SYSTEM */ } diff --git a/src/font.h b/src/font.h index 3e0d97baaac..0ec56590916 100644 --- a/src/font.h +++ b/src/font.h @@ -825,6 +825,7 @@ extern void syms_of_w32font (void); extern Lisp_Object Qfontsize; extern struct font_driver nsfont_driver; extern void syms_of_nsfont (void); +extern void syms_of_macfont (void); #endif /* HAVE_NS */ #ifndef FONT_DEBUG diff --git a/src/frame.c b/src/frame.c index fde2a131548..8eabef55d1b 100644 --- a/src/frame.c +++ b/src/frame.c @@ -3369,9 +3369,6 @@ x_set_scroll_bar_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval) else if (RANGED_INTEGERP (1, arg, INT_MAX) && XFASTINT (arg) != FRAME_CONFIG_SCROLL_BAR_WIDTH (f)) { - if (XFASTINT (arg) <= 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM) - XSETINT (arg, 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM + 1); - FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = XFASTINT (arg); FRAME_CONFIG_SCROLL_BAR_COLS (f) = (XFASTINT (arg) + wid-1) / wid; if (FRAME_X_WINDOW (f)) diff --git a/src/frame.h b/src/frame.h index ea550f4a2fa..d8a6d380090 100644 --- a/src/frame.h +++ b/src/frame.h @@ -1131,6 +1131,15 @@ extern Lisp_Object selected_frame; (FRAME_PIXEL_Y_TO_LINE (f, ((height) \ - FRAME_INTERNAL_BORDER_WIDTH (f)))) +/* Value is the smallest width of any character in any font on frame F. */ + +#define FRAME_SMALLEST_CHAR_WIDTH(f) \ + FRAME_DISPLAY_INFO (f)->smallest_char_width + +/* Value is the smallest height of any font on frame F. */ + +#define FRAME_SMALLEST_FONT_HEIGHT(f) \ + FRAME_DISPLAY_INFO (f)->smallest_font_height /*********************************************************************** Frame Parameters diff --git a/src/macfont.h b/src/macfont.h new file mode 100644 index 00000000000..141d60bfb0a --- /dev/null +++ b/src/macfont.h @@ -0,0 +1,144 @@ +/* Interface definition for Mac OSX Core text font backend. + Copyright (C) 2009-2013 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs. If not, see . + +Original author: YAMAMOTO Mitsuharu +*/ + +/* Structure used by Mac `shape' functions for storing layout + information for each glyph. */ +struct mac_glyph_layout +{ + /* Range of indices of the characters composed into the group of + glyphs that share the cursor position with this glyph. The + members `location' and `length' are in UTF-16 indices. */ + CFRange comp_range; + + /* UTF-16 index in the source string for the first character + associated with this glyph. */ + CFIndex string_index; + + /* Horizontal and vertical adjustments of glyph position. The + coordinate space is that of Core Text. So, the `baseline_delta' + value is negative if the glyph should be placed below the + baseline. */ + CGFloat advance_delta, baseline_delta; + + /* Typographical width of the glyph. */ + CGFloat advance; + + /* Glyph ID of the glyph. */ + CGGlyph glyph_id; +}; + +typedef CTFontDescriptorRef FontDescriptorRef; +typedef CTFontRef FontRef; +typedef CTFontSymbolicTraits FontSymbolicTraits; +typedef CTCharacterCollection CharacterCollection; + +#define MAC_FONT_NAME_ATTRIBUTE kCTFontNameAttribute +#define MAC_FONT_FAMILY_NAME_ATTRIBUTE kCTFontFamilyNameAttribute +#define MAC_FONT_TRAITS_ATTRIBUTE kCTFontTraitsAttribute +#define MAC_FONT_SIZE_ATTRIBUTE kCTFontSizeAttribute +#define MAC_FONT_CASCADE_LIST_ATTRIBUTE kCTFontCascadeListAttribute +#define MAC_FONT_CHARACTER_SET_ATTRIBUTE kCTFontCharacterSetAttribute +#define MAC_FONT_LANGUAGES_ATTRIBUTE kCTFontLanguagesAttribute +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 +#define MAC_FONT_FORMAT_ATTRIBUTE kCTFontFormatAttribute +#else +#define MAC_FONT_FORMAT_ATTRIBUTE (CFSTR ("NSCTFontFormatAttribute")) +#endif +#define MAC_FONT_SYMBOLIC_TRAIT kCTFontSymbolicTrait +#define MAC_FONT_WEIGHT_TRAIT kCTFontWeightTrait +#define MAC_FONT_WIDTH_TRAIT kCTFontWidthTrait +#define MAC_FONT_SLANT_TRAIT kCTFontSlantTrait + +enum { + MAC_FONT_TRAIT_ITALIC = kCTFontItalicTrait, + MAC_FONT_TRAIT_BOLD = kCTFontBoldTrait, + MAC_FONT_TRAIT_MONO_SPACE = kCTFontMonoSpaceTrait, +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 + MAC_FONT_TRAIT_COLOR_GLYPHS = kCTFontColorGlyphsTrait +#else + MAC_FONT_TRAIT_COLOR_GLYPHS = (1 << 13) +#endif +}; + +enum { +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 + MAC_FONT_FORMAT_BITMAP = kCTFontFormatBitmap +#else + MAC_FONT_FORMAT_BITMAP = 5 +#endif +}; + +enum { + MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING = kCTIdentityMappingCharacterCollection, + MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1 = kCTAdobeJapan1CharacterCollection +}; + +#define mac_font_descriptor_create_with_attributes \ + CTFontDescriptorCreateWithAttributes +#define mac_font_descriptor_create_matching_font_descriptors \ + CTFontDescriptorCreateMatchingFontDescriptors +#define mac_font_descriptor_create_matching_font_descriptor \ + CTFontDescriptorCreateMatchingFontDescriptor +#define mac_font_descriptor_copy_attribute CTFontDescriptorCopyAttribute +#define mac_font_descriptor_supports_languages \ + mac_ctfont_descriptor_supports_languages +#define mac_font_create_with_name(name, size) \ + CTFontCreateWithName (name, size, NULL) +#define mac_font_get_size CTFontGetSize +#define mac_font_copy_family_name CTFontCopyFamilyName +#define mac_font_copy_character_set CTFontCopyCharacterSet +#define mac_font_get_glyphs_for_characters CTFontGetGlyphsForCharacters +#define mac_font_get_ascent CTFontGetAscent +#define mac_font_get_descent CTFontGetDescent +#define mac_font_get_leading CTFontGetLeading +#define mac_font_get_underline_position CTFontGetUnderlinePosition +#define mac_font_get_underline_thickness CTFontGetUnderlineThickness +#define mac_font_copy_graphics_font(font) CTFontCopyGraphicsFont (font, NULL) +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 +#define mac_font_copy_non_synthetic_table(font, table) \ + CTFontCopyTable (font, table, kCTFontTableOptionNoOptions) +#else +#define mac_font_copy_non_synthetic_table(font, table) \ + CTFontCopyTable (font, table, kCTFontTableOptionExcludeSynthetic) +#endif + +#define mac_font_create_preferred_family_for_attributes \ + mac_ctfont_create_preferred_family_for_attributes +#define mac_font_get_advance_width_for_glyph \ + mac_ctfont_get_advance_width_for_glyph +#define mac_font_get_bounding_rect_for_glyph \ + mac_ctfont_get_bounding_rect_for_glyph +#define mac_font_create_available_families mac_ctfont_create_available_families +#define mac_font_shape mac_ctfont_shape +#if USE_CT_GLYPH_INFO +#define mac_font_get_glyph_for_cid mac_ctfont_get_glyph_for_cid +#endif + +#define mac_nsctfont_copy_font_descriptor CTFontCopyFontDescriptor + +#define MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE \ + (CFSTR ("MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE")) + +typedef const struct _EmacsScreenFont *ScreenFontRef; /* opaque */ + +extern void mac_register_font_driver (struct frame *f); +extern void *macfont_get_nsctfont (struct font *font); + diff --git a/src/macfont.m b/src/macfont.m new file mode 100644 index 00000000000..2a6d219d059 --- /dev/null +++ b/src/macfont.m @@ -0,0 +1,3858 @@ +/* Font driver on Mac OSX Core text. + Copyright (C) 2009-2013 Free Software Foundation, Inc. + +This file is part of GNU Emacs. + +GNU Emacs is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +GNU Emacs is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GNU Emacs. If not, see . + +Original author: YAMAMOTO Mitsuharu +*/ + +#include + +#include "lisp.h" +#include "dispextern.h" +#include "frame.h" +#include "blockinput.h" +#include "character.h" +#include "charset.h" +#include "composite.h" +#include "fontset.h" +#include "font.h" +#include "nsgui.h" +#include "nsterm.h" +#include "macfont.h" +#include "macuvs.h" + +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + +#include + +static struct font_driver macfont_driver; + +/* Core Text, for Mac OS X 10.5 and later. */ +static Lisp_Object Qmac_ct; + +static double mac_ctfont_get_advance_width_for_glyph (CTFontRef, CGGlyph); +static CGRect mac_ctfont_get_bounding_rect_for_glyph (CTFontRef, CGGlyph); +static CFArrayRef mac_ctfont_create_available_families (void); +static Boolean mac_ctfont_equal_in_postscript_name (CTFontRef, CTFontRef); +static CTLineRef mac_ctfont_create_line_with_string_and_font (CFStringRef, + CTFontRef); +static CFComparisonResult mac_font_family_compare (const void *, + const void *, void *); +static Boolean mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef, + CFArrayRef); +static CFStringRef mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef); +static CFIndex mac_ctfont_shape (CTFontRef, CFStringRef, + struct mac_glyph_layout *, CFIndex); +#if USE_CT_GLYPH_INFO +static CGGlyph mac_ctfont_get_glyph_for_cid (CTFontRef, + CTCharacterCollection, + CGFontIndex); +#endif + +/* The font property key specifying the font design destination. The + value is an unsigned integer code: 0 for WYSIWIG, and 1 for Video + text. (See the documentation of X Logical Font Description + Conventions.) In the Mac font driver, 1 means the screen font is + used for calculating some glyph metrics. You can see the + difference with Monaco 8pt or 9pt, for example. */ +static Lisp_Object QCdestination; + +/* The boolean-valued font property key specifying the use of + leading. */ +static Lisp_Object QCminspace; + +struct macfont_metrics; + +/* The actual structure for Mac font that can be casted to struct font. */ + +struct macfont_info +{ + struct font font; + FontRef macfont; + CGFontRef cgfont; + ScreenFontRef screen_font; + struct macfont_cache *cache; + struct macfont_metrics **metrics; + short metrics_nrows; + unsigned synthetic_italic_p : 1; + unsigned synthetic_bold_p : 1; + unsigned spacing : 2; + unsigned antialias : 2; + unsigned color_bitmap_p : 1; +}; + +/* Values for the `spacing' member in `struct macfont_info'. */ + +enum + { + MACFONT_SPACING_PROPORTIONAL, + MACFONT_SPACING_MONO, + MACFONT_SPACING_SYNTHETIC_MONO, + }; + +/* Values for the `antialias' member in `struct macfont_info'. */ + +enum + { + MACFONT_ANTIALIAS_DEFAULT, + MACFONT_ANTIALIAS_OFF, + MACFONT_ANTIALIAS_ON, + }; + +enum {FONT_SLANT_SYNTHETIC_ITALIC = 200}; /* FC_SLANT_ITALIC + 100 */ +enum {FONT_WEIGHT_SYNTHETIC_BOLD = 200}; /* FC_WEIGHT_BOLD */ +enum {FONT_SPACING_SYNTHETIC_MONO = FONT_SPACING_MONO}; + +static const CGAffineTransform synthetic_italic_atfm = {1, 0, 0.25, 1, 0, 0}; +static const CGFloat synthetic_bold_factor = 0.024; + +static Boolean cfnumber_get_font_symbolic_traits_value (CFNumberRef, + FontSymbolicTraits *); +static void macfont_store_descriptor_attributes (FontDescriptorRef, + Lisp_Object); +static Lisp_Object macfont_descriptor_entity (FontDescriptorRef, + Lisp_Object, + FontSymbolicTraits); +static CFStringRef macfont_create_family_with_symbol (Lisp_Object); +static int macfont_glyph_extents (struct font *, CGGlyph, + struct font_metrics *, CGFloat *, int); +static CFMutableDictionaryRef macfont_create_attributes_with_spec (Lisp_Object); +static Boolean macfont_supports_charset_and_languages_p (FontDescriptorRef, + CFCharacterSetRef, + Lisp_Object, + CFArrayRef); +static CFIndex macfont_closest_traits_index (CFArrayRef, + FontSymbolicTraits); +static CFDataRef mac_font_copy_uvs_table (FontRef); +static void mac_font_get_glyphs_for_variants (CFDataRef, UTF32Char, + const UTF32Char [], + CGGlyph [], CFIndex); + +/* From CFData to a lisp string. Always returns a unibyte string. */ + +static Lisp_Object +cfdata_to_lisp (CFDataRef data) +{ + CFIndex len = CFDataGetLength (data); + Lisp_Object result = make_uninit_string (len); + + CFDataGetBytes (data, CFRangeMake (0, len), SDATA (result)); + + return result; +} + + + +/* From CFString to a lisp string. Returns a unibyte string + containing a UTF-8 byte sequence. */ + +static Lisp_Object +cfstring_to_lisp_nodecode (CFStringRef string) +{ + Lisp_Object result = Qnil; + CFDataRef data; + const char *s = CFStringGetCStringPtr (string, kCFStringEncodingUTF8); + + if (s) + { + CFIndex i, length = CFStringGetLength (string); + + for (i = 0; i < length; i++) + if (CFStringGetCharacterAtIndex (string, i) == 0) + break; + + if (i == length) + return make_unibyte_string (s, strlen (s)); + } + + data = CFStringCreateExternalRepresentation (NULL, string, + kCFStringEncodingUTF8, '?'); + if (data) + { + result = cfdata_to_lisp (data); + CFRelease (data); + } + + return result; +} + +/* Lisp string containing a UTF-8 byte sequence to CFString. Unlike + cfstring_create_with_utf8_cstring, this function preserves NUL + characters. */ + +static CFStringRef +cfstring_create_with_string_noencode (Lisp_Object s) +{ + CFStringRef string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s), + kCFStringEncodingUTF8, false); + + if (string == NULL) + /* Failed to interpret as UTF 8. Fall back on Mac Roman. */ + string = CFStringCreateWithBytes (NULL, SDATA (s), SBYTES (s), + kCFStringEncodingMacRoman, false); + + return string; +} + +static CGFloat +mac_screen_font_get_advance_width_for_glyph (ScreenFontRef font, CGGlyph glyph) +{ + NSSize advancement = [(NSFont *)font advancementForGlyph:glyph]; + + return advancement.width; +} + +static CGGlyph +mac_font_get_glyph_for_cid (FontRef font, CharacterCollection collection, + CGFontIndex cid) +{ +#if USE_CT_GLYPH_INFO + return mac_ctfont_get_glyph_for_cid ((CTFontRef) font, collection, cid); +#else + { + CGGlyph result = kCGFontIndexInvalid; + NSFont *nsFont = (NSFont *) font; + unichar characters[] = {0xfffd}; + NSString *string = + [NSString stringWithCharacters:characters + length:(sizeof (characters) + / sizeof (characters[0]))]; + NSGlyphInfo *glyphInfo = + [NSGlyphInfo glyphInfoWithCharacterIdentifier:cid + collection:collection + baseString:string]; + NSDictionary *attributes = + [NSDictionary dictionaryWithObjectsAndKeys:nsFont,NSFontAttributeName, + glyphInfo,NSGlyphInfoAttributeName,nil]; + NSTextStorage *textStorage = + [[NSTextStorage alloc] initWithString:string + attributes:attributes]; + NSLayoutManager *layoutManager = [[NSLayoutManager alloc] init]; + NSTextContainer *textContainer = [[NSTextContainer alloc] init]; + NSFont *fontInTextStorage; + + [layoutManager addTextContainer:textContainer]; + [textContainer release]; + [textStorage addLayoutManager:layoutManager]; + [layoutManager release]; + + /* Force layout. */ + (void) [layoutManager glyphRangeForTextContainer:textContainer]; + + fontInTextStorage = [textStorage attribute:NSFontAttributeName atIndex:0 + effectiveRange:NULL]; + if (fontInTextStorage == nsFont + || [[fontInTextStorage fontName] isEqualToString:[nsFont fontName]]) + { + NSGlyph glyph = [layoutManager glyphAtIndex:0]; + + if (glyph < [nsFont numberOfGlyphs]) + result = glyph; + } + + [textStorage release]; + + return result; + } +} +#endif + +static ScreenFontRef +mac_screen_font_create_with_name (CFStringRef name, CGFloat size) +{ + NSFont *result, *font; + + font = [NSFont fontWithName:((NSString *) name) size:size]; + result = [font screenFont]; + + return (ScreenFontRef)[result retain]; +} + + +static Boolean +mac_screen_font_get_metrics (ScreenFontRef font, CGFloat *ascent, + CGFloat *descent, CGFloat *leading) +{ + NSFont *nsFont = [(NSFont *)font printerFont]; + NSTextStorage *textStorage; + NSLayoutManager *layoutManager; + NSTextContainer *textContainer; + NSRect usedRect; + NSPoint spaceLocation; + CGFloat descender; + + textStorage = [[NSTextStorage alloc] initWithString:@" "]; + layoutManager = [[NSLayoutManager alloc] init]; + textContainer = [[NSTextContainer alloc] init]; + + [textStorage setFont:nsFont]; + [textContainer setLineFragmentPadding:0]; + [layoutManager setUsesScreenFonts:YES]; + + [layoutManager addTextContainer:textContainer]; + [textContainer release]; + [textStorage addLayoutManager:layoutManager]; + [layoutManager release]; + + if (!(textStorage && layoutManager && textContainer)) + { + [textStorage release]; + + return false; + } + + usedRect = [layoutManager lineFragmentUsedRectForGlyphAtIndex:0 + effectiveRange:NULL]; + spaceLocation = [layoutManager locationForGlyphAtIndex:0]; + [textStorage release]; + + *ascent = spaceLocation.y; + *descent = NSHeight (usedRect) - spaceLocation.y; + *leading = 0; + descender = [nsFont descender]; + if (- descender < *descent) + { + *leading = *descent + descender; + *descent = - descender; + } + + return true; +} + +static CFIndex +mac_font_shape_1 (NSFont *font, NSString *string, + struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len, + BOOL screen_font_p) +{ + NSUInteger i; + CFIndex result = 0; + NSTextStorage *textStorage; + NSLayoutManager *layoutManager; + NSTextContainer *textContainer; + NSUInteger stringLength; + NSPoint spaceLocation; + NSUInteger used, numberOfGlyphs; + + textStorage = [[NSTextStorage alloc] initWithString:string]; + layoutManager = [[NSLayoutManager alloc] init]; + textContainer = [[NSTextContainer alloc] init]; + + /* Append a trailing space to measure baseline position. */ + [textStorage appendAttributedString:([[[NSAttributedString alloc] + initWithString:@" "] autorelease])]; + [textStorage setFont:font]; + [textContainer setLineFragmentPadding:0]; + [layoutManager setUsesScreenFonts:screen_font_p]; + + [layoutManager addTextContainer:textContainer]; + [textContainer release]; + [textStorage addLayoutManager:layoutManager]; + [layoutManager release]; + + if (!(textStorage && layoutManager && textContainer)) + { + [textStorage release]; + + return 0; + } + + stringLength = [string length]; + + /* Force layout. */ + (void) [layoutManager glyphRangeForTextContainer:textContainer]; + + spaceLocation = [layoutManager locationForGlyphAtIndex:stringLength]; + + /* Remove the appended trailing space because otherwise it may + generate a wrong result for a right-to-left text. */ + [textStorage beginEditing]; + [textStorage deleteCharactersInRange:(NSMakeRange (stringLength, 1))]; + [textStorage endEditing]; + (void) [layoutManager glyphRangeForTextContainer:textContainer]; + + i = 0; + while (i < stringLength) + { + NSRange range; + NSFont *fontInTextStorage = + [textStorage attribute:NSFontAttributeName atIndex:i + longestEffectiveRange:&range + inRange:(NSMakeRange (0, stringLength))]; + + if (!(fontInTextStorage == font + || [[fontInTextStorage fontName] isEqualToString:[font fontName]])) + break; + i = NSMaxRange (range); + } + if (i < stringLength) + /* Make the test `used <= glyph_len' below fail if textStorage + contained some fonts other than the specified one. */ + used = glyph_len + 1; + else + { + NSRange range = NSMakeRange (0, stringLength); + + range = [layoutManager glyphRangeForCharacterRange:range + actualCharacterRange:NULL]; + numberOfGlyphs = NSMaxRange (range); + used = numberOfGlyphs; + for (i = 0; i < numberOfGlyphs; i++) + if ([layoutManager notShownAttributeForGlyphAtIndex:i]) + used--; + } + + if (0 < used && used <= glyph_len) + { + NSUInteger glyphIndex, prevGlyphIndex; + unsigned char bidiLevel; + NSUInteger *permutation; + NSRange compRange, range; + CGFloat totalAdvance; + + glyphIndex = 0; + while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex]) + glyphIndex++; + + /* For now we assume the direction is not changed within the + string. */ + [layoutManager getGlyphsInRange:(NSMakeRange (glyphIndex, 1)) + glyphs:NULL characterIndexes:NULL + glyphInscriptions:NULL elasticBits:NULL + bidiLevels:&bidiLevel]; + if (bidiLevel & 1) + permutation = xmalloc (sizeof (NSUInteger) * used); + else + permutation = NULL; + +#define RIGHT_TO_LEFT_P permutation + + /* Fill the `comp_range' member of struct mac_glyph_layout, and + setup a permutation for right-to-left text. */ + compRange = NSMakeRange (0, 0); + for (range = NSMakeRange (0, 0); NSMaxRange (range) < used; + range.length++) + { + struct mac_glyph_layout *gl = glyph_layouts + NSMaxRange (range); + NSUInteger characterIndex = + [layoutManager characterIndexForGlyphAtIndex:glyphIndex]; + + gl->string_index = characterIndex; + + if (characterIndex >= NSMaxRange (compRange)) + { + compRange.location = NSMaxRange (compRange); + do + { + NSRange characterRange = + [string + rangeOfComposedCharacterSequenceAtIndex:characterIndex]; + + compRange.length = + NSMaxRange (characterRange) - compRange.location; + [layoutManager glyphRangeForCharacterRange:compRange + actualCharacterRange:&characterRange]; + characterIndex = NSMaxRange (characterRange) - 1; + } + while (characterIndex >= NSMaxRange (compRange)); + + if (RIGHT_TO_LEFT_P) + for (i = 0; i < range.length; i++) + permutation[range.location + i] = NSMaxRange (range) - i - 1; + + range = NSMakeRange (NSMaxRange (range), 0); + } + + gl->comp_range.location = compRange.location; + gl->comp_range.length = compRange.length; + + while (++glyphIndex < numberOfGlyphs) + if (![layoutManager notShownAttributeForGlyphAtIndex:glyphIndex]) + break; + } + if (RIGHT_TO_LEFT_P) + for (i = 0; i < range.length; i++) + permutation[range.location + i] = NSMaxRange (range) - i - 1; + + /* Then fill the remaining members. */ + glyphIndex = prevGlyphIndex = 0; + while ([layoutManager notShownAttributeForGlyphAtIndex:glyphIndex]) + glyphIndex++; + + if (!RIGHT_TO_LEFT_P) + totalAdvance = 0; + else + { + NSUInteger nrects; + NSRect *glyphRects = + [layoutManager + rectArrayForGlyphRange:(NSMakeRange (0, numberOfGlyphs)) + withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0)) + inTextContainer:textContainer rectCount:&nrects]; + + totalAdvance = NSMaxX (glyphRects[0]); + } + + for (i = 0; i < used; i++) + { + struct mac_glyph_layout *gl; + NSPoint location; + NSUInteger nextGlyphIndex; + NSRange glyphRange; + NSRect *glyphRects; + NSUInteger nrects; + + if (!RIGHT_TO_LEFT_P) + gl = glyph_layouts + i; + else + { + NSUInteger dest = permutation[i]; + + gl = glyph_layouts + dest; + if (i < dest) + { + CFIndex tmp = gl->string_index; + + gl->string_index = glyph_layouts[i].string_index; + glyph_layouts[i].string_index = tmp; + } + } + gl->glyph_id = [layoutManager glyphAtIndex:glyphIndex]; + + location = [layoutManager locationForGlyphAtIndex:glyphIndex]; + gl->baseline_delta = spaceLocation.y - location.y; + + for (nextGlyphIndex = glyphIndex + 1; nextGlyphIndex < numberOfGlyphs; + nextGlyphIndex++) + if (![layoutManager + notShownAttributeForGlyphAtIndex:nextGlyphIndex]) + break; + + if (!RIGHT_TO_LEFT_P) + { + CGFloat maxX; + + if (prevGlyphIndex == 0) + glyphRange = NSMakeRange (0, nextGlyphIndex); + else + glyphRange = NSMakeRange (glyphIndex, + nextGlyphIndex - glyphIndex); + glyphRects = + [layoutManager + rectArrayForGlyphRange:glyphRange + withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0)) + inTextContainer:textContainer rectCount:&nrects]; + maxX = max (NSMaxX (glyphRects[0]), totalAdvance); + gl->advance_delta = location.x - totalAdvance; + gl->advance = maxX - totalAdvance; + totalAdvance = maxX; + } + else + { + CGFloat minX; + + if (nextGlyphIndex == numberOfGlyphs) + glyphRange = NSMakeRange (prevGlyphIndex, + numberOfGlyphs - prevGlyphIndex); + else + glyphRange = NSMakeRange (prevGlyphIndex, + glyphIndex + 1 - prevGlyphIndex); + glyphRects = + [layoutManager + rectArrayForGlyphRange:glyphRange + withinSelectedGlyphRange:(NSMakeRange (NSNotFound, 0)) + inTextContainer:textContainer rectCount:&nrects]; + minX = min (NSMinX (glyphRects[0]), totalAdvance); + gl->advance = totalAdvance - minX; + totalAdvance = minX; + gl->advance_delta = location.x - totalAdvance; + } + + prevGlyphIndex = glyphIndex + 1; + glyphIndex = nextGlyphIndex; + } + + if (RIGHT_TO_LEFT_P) + xfree (permutation); + +#undef RIGHT_TO_LEFT_P + + result = used; + } + [textStorage release]; + + return result; +} + +static CFIndex +mac_screen_font_shape (ScreenFontRef font, CFStringRef string, + struct mac_glyph_layout *glyph_layouts, + CFIndex glyph_len) +{ + return mac_font_shape_1 ([(NSFont *)font printerFont], + (NSString *) string, + glyph_layouts, glyph_len, YES); +} + +static CGColorRef +get_cgcolor(unsigned long idx, struct frame *f) +{ + NSColor *nsColor = ns_lookup_indexed_color (idx, f); + [nsColor set]; + CGColorSpaceRef colorSpace = [[nsColor colorSpace] CGColorSpace]; + NSInteger noc = [nsColor numberOfComponents]; + CGFloat *components = xmalloc (sizeof(CGFloat)*(1+noc)); + CGColorRef cgColor; + + [nsColor getComponents: components]; + cgColor = CGColorCreate (colorSpace, components); + xfree (components); + return cgColor; +} + +#define CG_SET_FILL_COLOR_WITH_GC_FOREGROUND(context, s) \ + CGContextSetFillColorWithColor (context, \ + get_cgcolor (NS_FACE_FOREGROUND (s->face), \ + s->f)) + +#define CG_SET_FILL_COLOR_WITH_GC_BACKGROUND(context, s) \ + CGContextSetFillColorWithColor (context, \ + get_cgcolor (NS_FACE_BACKGROUND (s->face), \ + s->f)) + +#define CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND(context, s) \ + CGContextSetStrokeColorWithColor (context, \ + get_cgcolor (NS_FACE_FOREGROUND (s->face),\ + s->f)) + + +/* Mac font driver. */ + +static struct +{ + /* registry name */ + const char *name; + /* characters to distinguish the charset from the others */ + int uniquifier[6]; + /* additional constraint by language */ + CFStringRef lang; + /* set on demand */ + CFCharacterSetRef cf_charset; + CFStringRef cf_charset_string; +} cf_charset_table[] = + { { "iso8859-1", { 0x00A0, 0x00A1, 0x00B4, 0x00BC, 0x00D0 } }, + { "iso8859-2", { 0x00A0, 0x010E }}, + { "iso8859-3", { 0x00A0, 0x0108 }}, + { "iso8859-4", { 0x00A0, 0x00AF, 0x0128, 0x0156, 0x02C7 }}, + { "iso8859-5", { 0x00A0, 0x0401 }}, + { "iso8859-6", { 0x00A0, 0x060C }}, + { "iso8859-7", { 0x00A0, 0x0384 }}, + { "iso8859-8", { 0x00A0, 0x05D0 }}, + { "iso8859-9", { 0x00A0, 0x00A1, 0x00BC, 0x011E }}, + { "iso8859-10", { 0x00A0, 0x00D0, 0x0128, 0x2015 }}, + { "iso8859-11", { 0x00A0, 0x0E01 }}, + { "iso8859-13", { 0x00A0, 0x201C }}, + { "iso8859-14", { 0x00A0, 0x0174 }}, + { "iso8859-15", { 0x00A0, 0x00A1, 0x00D0, 0x0152 }}, + { "iso8859-16", { 0x00A0, 0x0218}}, + { "gb2312.1980-0", { 0x4E13 }, CFSTR ("zh-Hans")}, + { "big5-0", { /* 0xF6B1 in ftfont.c */ 0xF7E5 }, CFSTR ("zh-Hant") }, + { "jisx0208.1983-0", { 0x4E55 }, CFSTR ("ja")}, + { "ksc5601.1987-0", { 0xAC00 }, CFSTR ("ko")}, + { "cns11643.1992-1", { 0xFE32 }, CFSTR ("zh-Hant")}, + { "cns11643.1992-2", { 0x4E33, 0x7934 }}, + { "cns11643.1992-3", { 0x201A9 }}, + { "cns11643.1992-4", { 0x20057 }}, + { "cns11643.1992-5", { 0x20000 }}, + { "cns11643.1992-6", { 0x20003 }}, + { "cns11643.1992-7", { 0x20055 }}, + { "gbk-0", { 0x4E06 }, CFSTR ("zh-Hans")}, + { "jisx0212.1990-0", { 0x4E44 }}, + { "jisx0213.2000-1", { 0xFA10 }, CFSTR ("ja")}, + { "jisx0213.2000-2", { 0xFA49 }}, + { "jisx0213.2004-1", { 0x20B9F }}, + { "viscii1.1-1", { 0x1EA0, 0x1EAE, 0x1ED2 }, CFSTR ("vi")}, + { "tis620.2529-1", { 0x0E01 }, CFSTR ("th")}, + { "windows-1251", { 0x0401, 0x0490 }, CFSTR ("ru")}, + { "koi8-r", { 0x0401, 0x2219 }, CFSTR ("ru")}, + { "mulelao-1", { 0x0E81 }, CFSTR ("lo")}, + { "unicode-sip", { 0x20000 }}, + { NULL } + }; + +static CGFloat macfont_antialias_threshold; + +void +macfont_update_antialias_threshold (void) +{ + int threshold; + Boolean valid_p; + + threshold = + CFPreferencesGetAppIntegerValue (CFSTR ("AppleAntiAliasingThreshold"), + kCFPreferencesCurrentApplication, + &valid_p); + if (valid_p) + macfont_antialias_threshold = threshold; +} + +static inline Lisp_Object +macfont_intern_prop_cfstring (CFStringRef cfstring) +{ + Lisp_Object string = cfstring_to_lisp_nodecode (cfstring); + + return font_intern_prop (SSDATA (string), SBYTES (string), 1); +} + +static inline CFIndex +macfont_store_utf32char_to_unichars (UTF32Char c, UniChar *unichars) +{ + if (c < 0x10000) + { + unichars[0] = c; + + return 1; + } + else + { + c -= 0x10000; + unichars[0] = (c >> 10) + 0xD800; + unichars[1] = (c & 0x3FF) + 0xDC00; + + return 2; + } +} + +static Boolean +cfnumber_get_font_symbolic_traits_value (CFNumberRef number, + FontSymbolicTraits *sym_traits) +{ + SInt64 sint64_value; + + /* Getting symbolic traits with kCFNumberSInt32Type is lossy on Mac + OS 10.6 when the value is greater than or equal to 1 << 31. */ + if (CFNumberGetValue (number, kCFNumberSInt64Type, &sint64_value)) + { + *sym_traits = (FontSymbolicTraits) sint64_value; + + return true; + } + + return false; +} + +static void +macfont_store_descriptor_attributes (FontDescriptorRef desc, + Lisp_Object spec_or_entity) +{ + CFStringRef str; + CFDictionaryRef dict; + CFNumberRef num; + CGFloat floatval; + + str = mac_font_descriptor_copy_attribute (desc, + MAC_FONT_FAMILY_NAME_ATTRIBUTE); + if (str) + { + ASET (spec_or_entity, FONT_FAMILY_INDEX, + macfont_intern_prop_cfstring (str)); + CFRelease (str); + } + dict = mac_font_descriptor_copy_attribute (desc, MAC_FONT_TRAITS_ATTRIBUTE); + if (dict) + { + struct { + enum font_property_index index; + CFStringRef trait; + CGPoint points[6]; + } numeric_traits[] = + {{FONT_WEIGHT_INDEX, MAC_FONT_WEIGHT_TRAIT, + {{-0.4, 50}, /* light */ + {-0.24, 87.5}, /* (semi-light + normal) / 2 */ + {0, 100}, /* normal */ + {0.24, 140}, /* (semi-bold + normal) / 2 */ + {0.4, 200}, /* bold */ + {CGFLOAT_MAX, CGFLOAT_MAX}}}, + {FONT_SLANT_INDEX, MAC_FONT_SLANT_TRAIT, + {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}, + {FONT_WIDTH_INDEX, MAC_FONT_WIDTH_TRAIT, + {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}}; + int i; + + for (i = 0; i < sizeof (numeric_traits) / sizeof (numeric_traits[0]); i++) + { + num = CFDictionaryGetValue (dict, numeric_traits[i].trait); + if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval)) + { + CGPoint *point = numeric_traits[i].points; + + while (point->x < floatval) + point++; + if (point == numeric_traits[i].points) + point++; + else if (point->x == CGFLOAT_MAX) + point--; + floatval = (point - 1)->y + ((floatval - (point - 1)->x) + * ((point->y - (point - 1)->y) + / (point->x - (point - 1)->x))); + FONT_SET_STYLE (spec_or_entity, numeric_traits[i].index, + make_number (lround (floatval))); + } + } + + num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT); + if (num) + { + FontSymbolicTraits sym_traits; + int spacing; + + cfnumber_get_font_symbolic_traits_value (num, &sym_traits); + spacing = (sym_traits & MAC_FONT_TRAIT_MONO_SPACE + ? FONT_SPACING_MONO : FONT_SPACING_PROPORTIONAL); + ASET (spec_or_entity, FONT_SPACING_INDEX, make_number (spacing)); + } + + CFRelease (dict); + } + num = mac_font_descriptor_copy_attribute (desc, MAC_FONT_SIZE_ATTRIBUTE); + if (num && CFNumberGetValue (num, kCFNumberCGFloatType, &floatval)) + ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (floatval)); + else + ASET (spec_or_entity, FONT_SIZE_INDEX, make_number (0)); + if (num) + CFRelease (num); +} + +static Lisp_Object +macfont_descriptor_entity (FontDescriptorRef desc, Lisp_Object extra, + FontSymbolicTraits synth_sym_traits) +{ + Lisp_Object entity; + CFDictionaryRef dict; + FontSymbolicTraits sym_traits = 0; + CFStringRef name; + + entity = font_make_entity (); + + ASET (entity, FONT_TYPE_INDEX, macfont_driver.type); + ASET (entity, FONT_REGISTRY_INDEX, Qiso10646_1); + + macfont_store_descriptor_attributes (desc, entity); + + dict = mac_font_descriptor_copy_attribute (desc, MAC_FONT_TRAITS_ATTRIBUTE); + if (dict) + { + CFNumberRef num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT); + + if (num) + cfnumber_get_font_symbolic_traits_value (num, &sym_traits); + CFRelease (dict); + } + if (EQ (AREF (entity, FONT_SIZE_INDEX), make_number (0))) + ASET (entity, FONT_AVGWIDTH_INDEX, make_number (0)); + ASET (entity, FONT_EXTRA_INDEX, Fcopy_sequence (extra)); + name = mac_font_descriptor_copy_attribute (desc, MAC_FONT_NAME_ATTRIBUTE); + font_put_extra (entity, QCfont_entity, + make_save_ptr_int ((void *) name, sym_traits)); + if (synth_sym_traits & MAC_FONT_TRAIT_ITALIC) + FONT_SET_STYLE (entity, FONT_SLANT_INDEX, + make_number (FONT_SLANT_SYNTHETIC_ITALIC)); + if (synth_sym_traits & MAC_FONT_TRAIT_BOLD) + FONT_SET_STYLE (entity, FONT_WEIGHT_INDEX, + make_number (FONT_WEIGHT_SYNTHETIC_BOLD)); + if (synth_sym_traits & MAC_FONT_TRAIT_MONO_SPACE) + ASET (entity, FONT_SPACING_INDEX, + make_number (FONT_SPACING_SYNTHETIC_MONO)); + + return entity; +} + +static CFStringRef +macfont_create_family_with_symbol (Lisp_Object symbol) +{ + static CFArrayRef families = NULL; + CFStringRef result = NULL, family_name; + int using_cache_p = 1; + CFComparatorFunction family_name_comparator; + + family_name = cfstring_create_with_string_noencode (SYMBOL_NAME (symbol)); + if (family_name == NULL) + return NULL; + +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + if (CTFontManagerCompareFontFamilyNames != NULL) +#endif + { + family_name_comparator = CTFontManagerCompareFontFamilyNames; + } +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + else /* CTFontManagerCompareFontFamilyNames == NULL */ +#endif +#endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 */ +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + { + family_name_comparator = mac_font_family_compare; + } +#endif + + if ((*family_name_comparator) (family_name, CFSTR ("LastResort"), NULL) + == kCFCompareEqualTo) + result = CFSTR ("LastResort"); + else + while (1) + { + CFIndex i, count; + + if (families == NULL) + { + families = mac_font_create_available_families (); + using_cache_p = 0; + if (families == NULL) + break; + } + + count = CFArrayGetCount (families); + i = CFArrayBSearchValues (families, CFRangeMake (0, count), + (const void *) family_name, + family_name_comparator, NULL); + if (i < count) + { + CFStringRef name = CFArrayGetValueAtIndex (families, i); + + if ((*family_name_comparator) (name, family_name, NULL) + == kCFCompareEqualTo) + result = CFRetain (name); + } + + if (result || !using_cache_p) + break; + else + { + CFRelease (families); + families = NULL; + } + } + + CFRelease (family_name); + + return result; +} + +#define WIDTH_FRAC_BITS (4) +#define WIDTH_FRAC_SCALE (2 * ((1 << (WIDTH_FRAC_BITS - 1)) - 1)) + +struct macfont_metrics +{ + unsigned char lbearing_low, rbearing_low; + signed lbearing_high : 4, rbearing_high : 4; + unsigned char ascent_low, descent_low; + signed ascent_high : 4, descent_high : 4; + + /* These two members are used for fixed-point representation of + glyph width. The `width_int' member is an integer that is + closest to the width. The `width_frac' member is the fractional + adjustment representing a value in [-.5, .5], multiplied by + WIDTH_FRAC_SCALE. For synthetic monospace fonts, they represent + the advance delta for centering instead of the glyph width. */ + signed width_frac : WIDTH_FRAC_BITS, width_int : 16 - WIDTH_FRAC_BITS; +}; + +#define METRICS_VALUE(metrics, member) \ + (((metrics)->member##_high << 8) | (metrics)->member##_low) +#define METRICS_SET_VALUE(metrics, member, value) \ + do {short tmp = (value); (metrics)->member##_low = tmp & 0xff; \ + (metrics)->member##_high = tmp >> 8;} while (0) + +enum metrics_status + { + METRICS_INVALID = -1, /* metrics entry is invalid */ + METRICS_WIDTH_VALID = -2 /* width is valid but others are invalid */ + }; + +#define METRICS_STATUS(metrics) \ + (METRICS_VALUE (metrics, ascent) + METRICS_VALUE (metrics, descent)) +#define METRICS_SET_STATUS(metrics, status) \ + do {METRICS_SET_VALUE (metrics, ascent, 0); \ + METRICS_SET_VALUE (metrics, descent, status);} while (0) + +#define METRICS_NCOLS_PER_ROW (128) +#define LCD_FONT_SMOOTHING_LEFT_MARGIN (0.396f) +#define LCD_FONT_SMOOTHING_RIGHT_MARGIN (0.396f) + +static int +macfont_glyph_extents (struct font *font, CGGlyph glyph, + struct font_metrics *metrics, CGFloat *advance_delta, + int force_integral_p) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + FontRef macfont = macfont_info->macfont; + int row, col; + struct macfont_metrics *cache; + int width; + + row = glyph / METRICS_NCOLS_PER_ROW; + col = glyph % METRICS_NCOLS_PER_ROW; + if (row >= macfont_info->metrics_nrows) + { + macfont_info->metrics = + xrealloc (macfont_info->metrics, + sizeof (struct macfont_metrics *) * (row + 1)); + memset (macfont_info->metrics + macfont_info->metrics_nrows, 0, + (sizeof (struct macfont_metrics *) + * (row + 1 - macfont_info->metrics_nrows))); + macfont_info->metrics_nrows = row + 1; + } + if (macfont_info->metrics[row] == NULL) + { + struct macfont_metrics *new; + int i; + + new = xmalloc (sizeof (struct macfont_metrics) * METRICS_NCOLS_PER_ROW); + for (i = 0; i < METRICS_NCOLS_PER_ROW; i++) + METRICS_SET_STATUS (new + i, METRICS_INVALID); + macfont_info->metrics[row] = new; + } + cache = macfont_info->metrics[row] + col; + + if (METRICS_STATUS (cache) == METRICS_INVALID) + { + CGFloat fwidth; + + if (macfont_info->screen_font) + fwidth = mac_screen_font_get_advance_width_for_glyph (macfont_info->screen_font, glyph); + else + fwidth = mac_font_get_advance_width_for_glyph (macfont, glyph); + + /* For synthetic mono fonts, cache->width_{int,frac} holds the + advance delta value. */ + if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO) + fwidth = (font->pixel_size - fwidth) / 2; + cache->width_int = lround (fwidth); + cache->width_frac = lround ((fwidth - cache->width_int) + * WIDTH_FRAC_SCALE); + METRICS_SET_STATUS (cache, METRICS_WIDTH_VALID); + } + if (macfont_info->spacing == MACFONT_SPACING_SYNTHETIC_MONO) + width = font->pixel_size; + else + width = cache->width_int; + + if (metrics) + { + if (METRICS_STATUS (cache) == METRICS_WIDTH_VALID) + { + CGRect bounds = mac_font_get_bounding_rect_for_glyph (macfont, glyph); + + if (macfont_info->synthetic_italic_p) + { + /* We assume the members a, b, c, and d in + synthetic_italic_atfm are non-negative. */ + bounds.origin = + CGPointApplyAffineTransform (bounds.origin, + synthetic_italic_atfm); + bounds.size = + CGSizeApplyAffineTransform (bounds.size, synthetic_italic_atfm); + } + if (macfont_info->synthetic_bold_p) + { + CGFloat d = + - synthetic_bold_factor * mac_font_get_size (macfont) / 2; + + bounds = CGRectInset (bounds, d, d); + } + switch (macfont_info->spacing) + { + case MACFONT_SPACING_PROPORTIONAL: + bounds.origin.x += - (cache->width_frac + / (CGFloat) (WIDTH_FRAC_SCALE * 2)); + break; + case MACFONT_SPACING_MONO: + break; + case MACFONT_SPACING_SYNTHETIC_MONO: + bounds.origin.x += (cache->width_int + + (cache->width_frac + / (CGFloat) WIDTH_FRAC_SCALE)); + break; + } + if (bounds.size.width > 0) + { + bounds.origin.x -= LCD_FONT_SMOOTHING_LEFT_MARGIN; + bounds.size.width += (LCD_FONT_SMOOTHING_LEFT_MARGIN + + LCD_FONT_SMOOTHING_RIGHT_MARGIN); + } + bounds = CGRectIntegral (bounds); + METRICS_SET_VALUE (cache, lbearing, CGRectGetMinX (bounds)); + METRICS_SET_VALUE (cache, rbearing, CGRectGetMaxX (bounds)); + METRICS_SET_VALUE (cache, ascent, CGRectGetMaxY (bounds)); + METRICS_SET_VALUE (cache, descent, -CGRectGetMinY (bounds)); + } + metrics->lbearing = METRICS_VALUE (cache, lbearing); + metrics->rbearing = METRICS_VALUE (cache, rbearing); + metrics->width = width; + metrics->ascent = METRICS_VALUE (cache, ascent); + metrics->descent = METRICS_VALUE (cache, descent); + } + + if (advance_delta) + { + switch (macfont_info->spacing) + { + case MACFONT_SPACING_PROPORTIONAL: + *advance_delta = (force_integral_p ? 0 + : - (cache->width_frac + / (CGFloat) (WIDTH_FRAC_SCALE * 2))); + break; + case MACFONT_SPACING_MONO: + *advance_delta = 0; + break; + case MACFONT_SPACING_SYNTHETIC_MONO: + *advance_delta = (force_integral_p ? cache->width_int + : (cache->width_int + + (cache->width_frac + / (CGFloat) WIDTH_FRAC_SCALE))); + break; + } + } + + return width; +} + +static CFMutableDictionaryRef macfont_cache_dictionary; + +/* Threshold used in row_nkeys_or_perm. This must be less than or + equal to the number of rows that are invalid as BMP (i.e., from + U+D800 to U+DFFF). */ +#define ROW_PERM_OFFSET (8) + +/* The number of glyphs that can be stored in a value for a single + entry of CFDictionary. */ +#define NGLYPHS_IN_VALUE (sizeof (void *) / sizeof (CGGlyph)) + +struct macfont_cache +{ + int reference_count; + CFCharacterSetRef cf_charset; + struct { + /* The cached glyph for a BMP character c is stored in + matrix[row_nkeys_or_perm[c / 256] - ROW_PERM_OFFSET][c % 256] + if row_nkeys_or_perm[c / 256] >= ROW_PERM_OFFSET. */ + unsigned char row_nkeys_or_perm[256]; + CGGlyph **matrix; + + /* Number of rows for which the BMP cache is allocated so far. + I.e., matrix[0] ... matrix[nrows - 1] are non-NULL. */ + int nrows; + + /* The cached glyph for a character c is stored as the (c % + NGLYPHS_IN_VALUE)-th CGGlyph block of a value for the key (c / + NGLYPHS_IN_VALUE). However, the glyph for a BMP characrer c is + not stored here if row_nkeys_or_perm[c / 256] >= + ROW_PERM_OFFSET. */ + CFMutableDictionaryRef dictionary; + } glyph; + + struct { + /* UVS (Unicode Variation Sequence) subtable data, which is of + type CFDataRef if available. NULL means it is not initialized + yet. kCFNull means the subtable is not found and there is no + suitable fallback table for this font. */ + CFTypeRef table; + + /* Character collection specifying the destination of the mapping + provided by `table' above. If `table' is obtained from the UVS + subtable in the font cmap table, then the value of this member + should be MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING. */ + CharacterCollection collection; + } uvs; +}; + +static struct macfont_cache *macfont_lookup_cache (CFStringRef); +static struct macfont_cache *macfont_retain_cache (struct macfont_cache *); +static void macfont_release_cache (struct macfont_cache *); +static CFCharacterSetRef macfont_get_cf_charset (struct font *); +static CFCharacterSetRef macfont_get_cf_charset_for_name (CFStringRef); +static CGGlyph macfont_get_glyph_for_character (struct font *, UTF32Char); +static CGGlyph macfont_get_glyph_for_cid (struct font *font, + CharacterCollection, CGFontIndex); +static CFDataRef macfont_get_uvs_table (struct font *, CharacterCollection *); + +static struct macfont_cache * +macfont_lookup_cache (CFStringRef key) +{ + struct macfont_cache *cache; + + if (macfont_cache_dictionary == NULL) + { + macfont_cache_dictionary = + CFDictionaryCreateMutable (NULL, 0, + &kCFTypeDictionaryKeyCallBacks, NULL); + cache = NULL; + } + else + cache = ((struct macfont_cache *) + CFDictionaryGetValue (macfont_cache_dictionary, key)); + + if (cache == NULL) + { + FontRef macfont = mac_font_create_with_name (key, 0); + + if (macfont) + { + cache = xzalloc (sizeof (struct macfont_cache)); + /* Treat the LastResort font as if it contained glyphs for + all characters. This may look too rough, but neither + CTFontCopyCharacterSet nor -[NSFont coveredCharacterSet] + for this font is correct for non-BMP characters on Mac OS + X 10.5, anyway. */ + if (CFStringCompare (key, CFSTR ("LastResort"), 0) + == kCFCompareEqualTo) + { + CFRange range = CFRangeMake (0, MAX_UNICODE_CHAR + 1); + + cache->cf_charset = + CFCharacterSetCreateWithCharactersInRange (NULL, range); + } + if (cache->cf_charset == NULL) + cache->cf_charset = mac_font_copy_character_set (macfont); + CFDictionaryAddValue (macfont_cache_dictionary, key, + (const void *) cache); + CFRelease (macfont); + } + } + + return cache; +} + +static struct macfont_cache * +macfont_retain_cache (struct macfont_cache *cache) +{ + cache->reference_count++; + + return cache; +} + +static void +macfont_release_cache (struct macfont_cache *cache) +{ + if (--cache->reference_count == 0) + { + int i; + + for (i = 0; i < cache->glyph.nrows; i++) + xfree (cache->glyph.matrix[i]); + xfree (cache->glyph.matrix); + if (cache->glyph.dictionary) + CFRelease (cache->glyph.dictionary); + memset (&cache->glyph, 0, sizeof (cache->glyph)); + if (cache->uvs.table) + CFRelease (cache->uvs.table); + memset (&cache->uvs, 0, sizeof (cache->uvs)); + } +} + +static CFCharacterSetRef +macfont_get_cf_charset (struct font *font) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + + return macfont_info->cache->cf_charset; +} + +static CFCharacterSetRef +macfont_get_cf_charset_for_name (CFStringRef name) +{ + struct macfont_cache *cache = macfont_lookup_cache (name); + + return cache->cf_charset; +} + +static CGGlyph +macfont_get_glyph_for_character (struct font *font, UTF32Char c) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + FontRef macfont = macfont_info->macfont; + struct macfont_cache *cache = macfont_info->cache; + + if (c < 0xD800 || (c > 0xDFFF && c < 0x10000)) + { + int row = c / 256; + int nkeys_or_perm = cache->glyph.row_nkeys_or_perm[row]; + + if (nkeys_or_perm < ROW_PERM_OFFSET) + { + UniChar unichars[256], ch; + CGGlyph *glyphs; + int i, len; + int nrows; +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + dispatch_queue_t queue; + dispatch_group_t group = NULL; +#else + int nkeys; +#endif + + if (row != 0) + { + CFMutableDictionaryRef dictionary; + uintptr_t key, value; + int nshifts; + CGGlyph glyph; + + if (cache->glyph.dictionary == NULL) + cache->glyph.dictionary = + CFDictionaryCreateMutable (NULL, 0, NULL, NULL); + dictionary = cache->glyph.dictionary; + key = c / NGLYPHS_IN_VALUE; + nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8); + value = ((uintptr_t) + CFDictionaryGetValue (dictionary, (const void *) key)); + glyph = (value >> nshifts); + if (glyph) + return glyph; + + if (nkeys_or_perm + 1 != ROW_PERM_OFFSET) + { + ch = c; + if (!mac_font_get_glyphs_for_characters (macfont, &ch, + &glyph, 1) + || glyph == 0) + glyph = kCGFontIndexInvalid; + + if (value == 0) + cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm + 1; + value |= ((uintptr_t) glyph << nshifts); + CFDictionarySetValue (dictionary, (const void *) key, + (const void *) value); + + return glyph; + } + +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + queue = + dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + group = dispatch_group_create (); + dispatch_group_async (group, queue, ^{ + int nkeys; + uintptr_t key; +#endif + nkeys = nkeys_or_perm; + for (key = row * (256 / NGLYPHS_IN_VALUE); ; key++) + if (CFDictionaryContainsKey (dictionary, + (const void *) key)) + { + CFDictionaryRemoveValue (dictionary, + (const void *) key); + if (--nkeys == 0) + break; + } +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + }); +#endif + } + + len = 0; + for (i = 0; i < 256; i++) + { + ch = row * 256 + i; + if (CFCharacterSetIsLongCharacterMember (cache->cf_charset, ch)) + unichars[len++] = ch; + } + + glyphs = xmalloc (sizeof (CGGlyph) * 256); + if (len > 0) + { + mac_font_get_glyphs_for_characters (macfont, unichars, + glyphs, len); + while (i > len) + { + int next = unichars[len - 1] % 256; + + while (--i > next) + glyphs[i] = kCGFontIndexInvalid; + + len--; + glyphs[i] = glyphs[len]; + if (len == 0) + break; + } + } + if (i > len) + while (i-- > 0) + glyphs[i] = kCGFontIndexInvalid; + + nrows = cache->glyph.nrows; + nkeys_or_perm = nrows + ROW_PERM_OFFSET; + cache->glyph.row_nkeys_or_perm[row] = nkeys_or_perm; + nrows++; + cache->glyph.matrix = xrealloc (cache->glyph.matrix, + sizeof (CGGlyph *) * nrows); + cache->glyph.matrix[nrows - 1] = glyphs; + cache->glyph.nrows = nrows; + +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + if (group) + { + dispatch_group_wait (group, DISPATCH_TIME_FOREVER); + dispatch_release (group); + } +#endif + } + + return cache->glyph.matrix[nkeys_or_perm - ROW_PERM_OFFSET][c % 256]; + } + else + { + uintptr_t key, value; + int nshifts; + CGGlyph glyph; + + if (cache->glyph.dictionary == NULL) + cache->glyph.dictionary = + CFDictionaryCreateMutable (NULL, 0, NULL, NULL); + key = c / NGLYPHS_IN_VALUE; + nshifts = ((c % NGLYPHS_IN_VALUE) * sizeof (CGGlyph) * 8); + value = (uintptr_t) CFDictionaryGetValue (cache->glyph.dictionary, + (const void *) key); + glyph = (value >> nshifts); + if (glyph == 0) + { + UniChar unichars[2]; + CGGlyph glyphs[2]; + CFIndex count = macfont_store_utf32char_to_unichars (c, unichars); + + if (mac_font_get_glyphs_for_characters (macfont, unichars, glyphs, + count)) + glyph = glyphs[0]; + if (glyph == 0) + glyph = kCGFontIndexInvalid; + + value |= ((uintptr_t) glyph << nshifts); + CFDictionarySetValue (cache->glyph.dictionary, + (const void *) key, (const void *) value); + } + + return glyph; + } +} + +static CGGlyph +macfont_get_glyph_for_cid (struct font *font, CharacterCollection collection, + CGFontIndex cid) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + FontRef macfont = macfont_info->macfont; + + /* Cache it? */ + return mac_font_get_glyph_for_cid (macfont, collection, cid); +} + +static CFDataRef +macfont_get_uvs_table (struct font *font, CharacterCollection *collection) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + FontRef macfont = macfont_info->macfont; + struct macfont_cache *cache = macfont_info->cache; + CFDataRef result = NULL; + + if (cache->uvs.table == NULL) + { + CFDataRef uvs_table = mac_font_copy_uvs_table (macfont); + CharacterCollection uvs_collection = + MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING; + + if (uvs_table == NULL + && mac_font_get_glyph_for_cid (macfont, + MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1, + 6480) != kCGFontIndexInvalid) + { + /* If the glyph for U+4E55 is accessible via its CID 6480, + then we use the Adobe-Japan1 UVS table, which maps a + variation sequence to a CID, as a fallback. */ + static CFDataRef mac_uvs_table_adobe_japan1 = NULL; + + if (mac_uvs_table_adobe_japan1 == NULL) + mac_uvs_table_adobe_japan1 = + CFDataCreateWithBytesNoCopy (NULL, + mac_uvs_table_adobe_japan1_bytes, + sizeof (mac_uvs_table_adobe_japan1_bytes), + kCFAllocatorNull); + if (mac_uvs_table_adobe_japan1) + { + uvs_table = CFRetain (mac_uvs_table_adobe_japan1); + uvs_collection = MAC_CHARACTER_COLLECTION_ADOBE_JAPAN1; + } + } + if (uvs_table == NULL) + cache->uvs.table = kCFNull; + else + cache->uvs.table = uvs_table; + cache->uvs.collection = uvs_collection; + } + + if (cache->uvs.table != kCFNull) + { + result = cache->uvs.table; + *collection = cache->uvs.collection; + } + + return result; +} + +static Lisp_Object macfont_get_cache (struct frame *); +static Lisp_Object macfont_list (struct frame *, Lisp_Object); +static Lisp_Object macfont_match (struct frame *, Lisp_Object); +static Lisp_Object macfont_list_family (struct frame *); +static void macfont_free_entity (Lisp_Object); +static Lisp_Object macfont_open (struct frame *, Lisp_Object, int); +static void macfont_close (struct frame *, struct font *); +static int macfont_has_char (Lisp_Object, int); +static unsigned macfont_encode_char (struct font *, int); +static int macfont_text_extents (struct font *, unsigned int *, int, + struct font_metrics *); +static int macfont_draw (struct glyph_string *, int, int, int, int, bool); +static Lisp_Object macfont_shape (Lisp_Object); +static int macfont_variation_glyphs (struct font *, int c, + unsigned variations[256]); +static void macfont_filter_properties (Lisp_Object, Lisp_Object); + +static struct font_driver macfont_driver = + { + LISP_INITIALLY_ZERO, /* Qmac_ct */ + 0, /* case insensitive */ + macfont_get_cache, + macfont_list, + macfont_match, + macfont_list_family, + macfont_free_entity, + macfont_open, + macfont_close, + NULL, /* prepare_face */ + NULL, /* done_face */ + macfont_has_char, + macfont_encode_char, + macfont_text_extents, + macfont_draw, + NULL, /* get_bitmap */ + NULL, /* free_bitmap */ + NULL, /* get_outline */ + NULL, /* free_outline */ + NULL, /* anchor_point */ + NULL, /* otf_capability */ + NULL, /* otf_drive */ + NULL, /* start_for_frame */ + NULL, /* end_for_frame */ + macfont_shape, + NULL, /* check */ + macfont_variation_glyphs, + macfont_filter_properties, + }; + +static Lisp_Object +macfont_get_cache (struct frame * f) +{ + Display_Info *dpyinfo = FRAME_DISPLAY_INFO (f); + + return (dpyinfo->name_list_element); +} + +static int +macfont_get_charset (Lisp_Object registry) +{ + char *str = SSDATA (SYMBOL_NAME (registry)); + char *re = alloca (SBYTES (SYMBOL_NAME (registry)) * 2 + 1); + Lisp_Object regexp; + int i, j; + + for (i = j = 0; i < SBYTES (SYMBOL_NAME (registry)); i++, j++) + { + if (str[i] == '.') + re[j++] = '\\'; + else if (str[i] == '*') + re[j++] = '.'; + re[j] = str[i]; + if (re[j] == '?') + re[j] = '.'; + } + re[j] = '\0'; + regexp = make_unibyte_string (re, j); + for (i = 0; cf_charset_table[i].name; i++) + if (fast_c_string_match_ignore_case + (regexp, cf_charset_table[i].name, + strlen (cf_charset_table[i].name)) >= 0) + break; + if (! cf_charset_table[i].name) + return -1; + if (! cf_charset_table[i].cf_charset) + { + int *uniquifier = cf_charset_table[i].uniquifier; + UniChar *unichars = alloca (sizeof (cf_charset_table[i].uniquifier)); + CFIndex count = 0; + CFStringRef string; + CFMutableCharacterSetRef charset = CFCharacterSetCreateMutable (NULL); + + if (! charset) + return -1; + for (j = 0; uniquifier[j]; j++) + { + count += macfont_store_utf32char_to_unichars (uniquifier[j], + unichars + count); + CFCharacterSetAddCharactersInRange (charset, + CFRangeMake (uniquifier[j], 1)); + } + + string = CFStringCreateWithCharacters (NULL, unichars, count); + if (! string) + { + CFRelease (charset); + return -1; + } + cf_charset_table[i].cf_charset = CFCharacterSetCreateCopy (NULL, + charset); + CFRelease (charset); + /* CFCharacterSetCreateWithCharactersInString does not handle + surrogate pairs properly as of Mac OS X 10.5. */ + cf_charset_table[i].cf_charset_string = string; + } + return i; +} + +struct OpenTypeSpec +{ + Lisp_Object script; + unsigned int script_tag, langsys_tag; + int nfeatures[2]; + unsigned int *features[2]; +}; + +#define OTF_SYM_TAG(SYM, TAG) \ + do { \ + unsigned char *p = SDATA (SYMBOL_NAME (SYM)); \ + TAG = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3]; \ + } while (0) + +#define OTF_TAG_STR(TAG, P) \ + do { \ + (P)[0] = (char) (TAG >> 24); \ + (P)[1] = (char) ((TAG >> 16) & 0xFF); \ + (P)[2] = (char) ((TAG >> 8) & 0xFF); \ + (P)[3] = (char) (TAG & 0xFF); \ + (P)[4] = '\0'; \ + } while (0) + +static struct OpenTypeSpec * +macfont_get_open_type_spec (Lisp_Object otf_spec) +{ + struct OpenTypeSpec *spec = xmalloc (sizeof *spec); + Lisp_Object val; + int i, j; + bool negative; + + if (! spec) + return NULL; + spec->script = XCAR (otf_spec); + if (! NILP (spec->script)) + { + OTF_SYM_TAG (spec->script, spec->script_tag); + val = assq_no_quit (spec->script, Votf_script_alist); + if (CONSP (val) && SYMBOLP (XCDR (val))) + spec->script = XCDR (val); + else + spec->script = Qnil; + } + else + spec->script_tag = 0x44464C54; /* "DFLT" */ + otf_spec = XCDR (otf_spec); + spec->langsys_tag = 0; + if (! NILP (otf_spec)) + { + val = XCAR (otf_spec); + if (! NILP (val)) + OTF_SYM_TAG (val, spec->langsys_tag); + otf_spec = XCDR (otf_spec); + } + spec->nfeatures[0] = spec->nfeatures[1] = 0; + for (i = 0; i < 2 && ! NILP (otf_spec); i++, otf_spec = XCDR (otf_spec)) + { + Lisp_Object len; + + val = XCAR (otf_spec); + if (NILP (val)) + continue; + len = Flength (val); + spec->features[i] = + (min (PTRDIFF_MAX, SIZE_MAX) / sizeof (int) < XINT (len) + ? 0 + : malloc (XINT (len) * sizeof *spec->features[i])); + if (! spec->features[i]) + { + if (i > 0 && spec->features[0]) + free (spec->features[0]); + free (spec); + return NULL; + } + for (j = 0, negative = 0; CONSP (val); val = XCDR (val)) + { + if (NILP (XCAR (val))) + negative = 1; + else + { + unsigned int tag; + + OTF_SYM_TAG (XCAR (val), tag); + spec->features[i][j++] = negative ? tag & 0x80000000 : tag; + } + } + spec->nfeatures[i] = j; + } + return spec; +} + +static CFMutableDictionaryRef +macfont_create_attributes_with_spec (Lisp_Object spec) +{ + Lisp_Object tmp, extra; + CFMutableArrayRef langarray = NULL; + CFCharacterSetRef charset = NULL; + CFStringRef charset_string = NULL; + CFMutableDictionaryRef attributes = NULL, traits = NULL; + Lisp_Object script = Qnil; + Lisp_Object registry; + int cf_charset_idx, i; + struct OpenTypeSpec *otspec = NULL; + struct { + enum font_property_index index; + CFStringRef trait; + CGPoint points[6]; + } numeric_traits[] = + {{FONT_WEIGHT_INDEX, MAC_FONT_WEIGHT_TRAIT, + {{-0.4, 50}, /* light */ + {-0.24, 87.5}, /* (semi-light + normal) / 2 */ + {0, 100}, /* normal */ + {0.24, 140}, /* (semi-bold + normal) / 2 */ + {0.4, 200}, /* bold */ + {CGFLOAT_MAX, CGFLOAT_MAX}}}, + {FONT_SLANT_INDEX, MAC_FONT_SLANT_TRAIT, + {{0, 100}, {0.1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}, + {FONT_WIDTH_INDEX, MAC_FONT_WIDTH_TRAIT, + {{0, 100}, {1, 200}, {CGFLOAT_MAX, CGFLOAT_MAX}}}}; + + registry = AREF (spec, FONT_REGISTRY_INDEX); + if (NILP (registry) + || EQ (registry, Qascii_0) + || EQ (registry, Qiso10646_1) + || EQ (registry, Qunicode_bmp)) + cf_charset_idx = -1; + else + { + CFStringRef lang; + + cf_charset_idx = macfont_get_charset (registry); + if (cf_charset_idx < 0) + goto err; + charset = cf_charset_table[cf_charset_idx].cf_charset; + charset_string = cf_charset_table[cf_charset_idx].cf_charset_string; + lang = cf_charset_table[cf_charset_idx].lang; + if (lang) + { + langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks); + if (! langarray) + goto err; + CFArrayAppendValue (langarray, lang); + } + } + + for (extra = AREF (spec, FONT_EXTRA_INDEX); + CONSP (extra); extra = XCDR (extra)) + { + Lisp_Object key, val; + + tmp = XCAR (extra); + key = XCAR (tmp), val = XCDR (tmp); + if (EQ (key, QClang)) + { + if (! langarray) + langarray = CFArrayCreateMutable (NULL, 0, &kCFTypeArrayCallBacks); + if (! langarray) + goto err; + if (SYMBOLP (val)) + val = list1 (val); + for (; CONSP (val); val = XCDR (val)) + if (SYMBOLP (XCAR (val))) + { + CFStringRef lang = + cfstring_create_with_string_noencode (SYMBOL_NAME + (XCAR (val))); + + if (lang == NULL) + goto err; + CFArrayAppendValue (langarray, lang); + CFRelease (lang); + } + } + else if (EQ (key, QCotf)) + { + otspec = macfont_get_open_type_spec (val); + if (! otspec) + goto err; + script = otspec->script; + } + else if (EQ (key, QCscript)) + script = val; + } + + if (! NILP (script) && ! charset) + { + Lisp_Object chars = assq_no_quit (script, Vscript_representative_chars); + + if (CONSP (chars) && CONSP (CDR (chars))) + { + CFMutableStringRef string = CFStringCreateMutable (NULL, 0); + CFMutableCharacterSetRef cs = CFCharacterSetCreateMutable (NULL); + + if (! string || !cs) + { + if (string) + CFRelease (string); + else if (cs) + CFRelease (cs); + goto err; + } + for (chars = XCDR (chars); CONSP (chars); chars = XCDR (chars)) + if (CHARACTERP (XCAR (chars))) + { + UniChar unichars[2]; + CFIndex count = + macfont_store_utf32char_to_unichars (XFASTINT (XCAR (chars)), + unichars); + CFRange range = CFRangeMake (XFASTINT (XCAR (chars)), 1); + + CFStringAppendCharacters (string, unichars, count); + CFCharacterSetAddCharactersInRange (cs, range); + } + charset = cs; + /* CFCharacterSetCreateWithCharactersInString does not + handle surrogate pairs properly as of Mac OS X 10.5. */ + charset_string = string; + } + } + + attributes = CFDictionaryCreateMutable (NULL, 0, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + if (! attributes) + goto err; + + tmp = AREF (spec, FONT_FAMILY_INDEX); + if (SYMBOLP (tmp) && ! NILP (tmp)) + { + CFStringRef family = macfont_create_family_with_symbol (tmp); + + if (! family) + goto err; + CFDictionaryAddValue (attributes, MAC_FONT_FAMILY_NAME_ATTRIBUTE, + family); + CFRelease (family); + } + + traits = CFDictionaryCreateMutable (NULL, 4, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + if (! traits) + goto err; + + for (i = 0; i < sizeof (numeric_traits) / sizeof (numeric_traits[0]); i++) + { + tmp = AREF (spec, numeric_traits[i].index); + if (INTEGERP (tmp)) + { + CGPoint *point = numeric_traits[i].points; + CGFloat floatval = (XINT (tmp) >> 8); // XXX + CFNumberRef num; + + while (point->y < floatval) + point++; + if (point == numeric_traits[i].points) + point++; + else if (point->y == CGFLOAT_MAX) + point--; + floatval = (point - 1)->x + ((floatval - (point - 1)->y) + * ((point->x - (point - 1)->x) + / (point->y - (point - 1)->y))); + if (floatval > 1.0) + floatval = 1.0; + else if (floatval < -1.0) + floatval = -1.0; + num = CFNumberCreate (NULL, kCFNumberCGFloatType, &floatval); + if (! num) + goto err; + CFDictionaryAddValue (traits, numeric_traits[i].trait, num); + CFRelease (num); + } + } + if (CFDictionaryGetCount (traits)) + CFDictionaryAddValue (attributes, MAC_FONT_TRAITS_ATTRIBUTE, traits); + + if (charset) + CFDictionaryAddValue (attributes, MAC_FONT_CHARACTER_SET_ATTRIBUTE, + charset); + if (charset_string) + CFDictionaryAddValue (attributes, MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE, + charset_string); + if (langarray) + CFDictionaryAddValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE, langarray); + + goto finish; + + err: + if (attributes) + { + CFRelease (attributes); + attributes = NULL; + } + + finish: + if (langarray) CFRelease (langarray); + if (charset && cf_charset_idx < 0) CFRelease (charset); + if (charset_string && cf_charset_idx < 0) CFRelease (charset_string); + if (traits) CFRelease (traits); + if (otspec) + { + if (otspec->nfeatures[0] > 0) + free (otspec->features[0]); + if (otspec->nfeatures[1] > 0) + free (otspec->features[1]); + free (otspec); + } + + return attributes; +} + +static Boolean +macfont_supports_charset_and_languages_p (FontDescriptorRef desc, + CFCharacterSetRef charset, + Lisp_Object chars, + CFArrayRef languages) +{ + Boolean result = true; + + if (charset || VECTORP (chars)) + { + CFCharacterSetRef desc_charset = + mac_font_descriptor_copy_attribute (desc, + MAC_FONT_CHARACTER_SET_ATTRIBUTE); + + if (desc_charset == NULL) + result = false; + else + { + if (charset) + result = CFCharacterSetIsSupersetOfSet (desc_charset, charset); + else /* VECTORP (chars) */ + { + ptrdiff_t j; + + for (j = 0; j < ASIZE (chars); j++) + if (TYPE_RANGED_INTEGERP (UTF32Char, AREF (chars, j)) + && CFCharacterSetIsLongCharacterMember (desc_charset, + XFASTINT (AREF (chars, j)))) + break; + if (j == ASIZE (chars)) + result = false; + } + CFRelease (desc_charset); + } + } + if (result && languages) + result = mac_font_descriptor_supports_languages (desc, languages); + + return result; +} + +static CFIndex +macfont_closest_traits_index (CFArrayRef traits_array, + FontSymbolicTraits target) +{ + CFIndex i, result = -1, count = CFArrayGetCount (traits_array); + int min_distance = (1 << 3); + + for (i = 0; i < count; i++) + { + FontSymbolicTraits traits, diff; + int distance = 0; + + traits = ((FontSymbolicTraits) (uintptr_t) + CFArrayGetValueAtIndex (traits_array, i)); + diff = (target ^ traits); + /* We prefer synthetic bold of italic to synthetic italic of + bold when both bold and italic are available but bold-italic + is not available. */ + if (diff & MAC_FONT_TRAIT_BOLD) + distance |= (1 << 0); + if (diff & MAC_FONT_TRAIT_ITALIC) + distance |= (1 << 1); + if (diff & MAC_FONT_TRAIT_MONO_SPACE) + distance |= (1 << 2); + if (distance < min_distance) + { + min_distance = distance; + result = i; + } + } + + return result; +} + +static Lisp_Object +macfont_list (struct frame *f, Lisp_Object spec) +{ + Lisp_Object val = Qnil, family, extra; + int i, n; + CFStringRef family_name = NULL; + CFMutableDictionaryRef attributes = NULL, traits; + Lisp_Object chars = Qnil; + int spacing = -1; + FontSymbolicTraits synth_sym_traits = 0; + CFArrayRef families; + CFIndex families_count; + CFCharacterSetRef charset = NULL; + CFArrayRef languages = NULL; + + block_input (); + + family = AREF (spec, FONT_FAMILY_INDEX); + if (! NILP (family)) + { + family_name = macfont_create_family_with_symbol (family); + if (family_name == NULL) + goto finish; + } + + attributes = macfont_create_attributes_with_spec (spec); + if (! attributes) + goto finish; + + charset = ((CFCharacterSetRef) + CFDictionaryGetValue (attributes, + MAC_FONT_CHARACTER_SET_ATTRIBUTE)); + if (charset) + { + CFRetain (charset); + CFDictionaryRemoveValue (attributes, MAC_FONT_CHARACTER_SET_ATTRIBUTE); + } + else + { + val = assq_no_quit (QCscript, AREF (spec, FONT_EXTRA_INDEX)); + if (! NILP (val)) + { + val = assq_no_quit (XCDR (val), Vscript_representative_chars); + if (CONSP (val) && VECTORP (XCDR (val))) + chars = XCDR (val); + } + val = Qnil; + } + + languages = ((CFArrayRef) + CFDictionaryGetValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE)); + if (languages) + { + CFRetain (languages); + CFDictionaryRemoveValue (attributes, MAC_FONT_LANGUAGES_ATTRIBUTE); + } + + if (INTEGERP (AREF (spec, FONT_SPACING_INDEX))) + spacing = XINT (AREF (spec, FONT_SPACING_INDEX)); + + traits = ((CFMutableDictionaryRef) + CFDictionaryGetValue (attributes, MAC_FONT_TRAITS_ATTRIBUTE)); + + n = FONT_SLANT_NUMERIC (spec); + if (n < 0 || n == FONT_SLANT_SYNTHETIC_ITALIC) + { + synth_sym_traits |= MAC_FONT_TRAIT_ITALIC; + if (traits) + CFDictionaryRemoveValue (traits, MAC_FONT_SLANT_TRAIT); + } + + n = FONT_WEIGHT_NUMERIC (spec); + if (n < 0 || n == FONT_WEIGHT_SYNTHETIC_BOLD) + { + synth_sym_traits |= MAC_FONT_TRAIT_BOLD; + if (traits) + CFDictionaryRemoveValue (traits, MAC_FONT_WEIGHT_TRAIT); + } + + if (languages + && (spacing < 0 || spacing == FONT_SPACING_SYNTHETIC_MONO)) + { + CFStringRef language = CFArrayGetValueAtIndex (languages, 0); + + if (CFStringHasPrefix (language, CFSTR ("ja")) + || CFStringHasPrefix (language, CFSTR ("ko")) + || CFStringHasPrefix (language, CFSTR ("zh"))) + synth_sym_traits |= MAC_FONT_TRAIT_MONO_SPACE; + } + + /* Create array of families. */ + if (family_name) + families = CFArrayCreate (NULL, (const void **) &family_name, + 1, &kCFTypeArrayCallBacks); + else + { + CFStringRef pref_family; + CFIndex families_count, pref_family_index = -1; + + families = mac_font_create_available_families (); + if (families == NULL) + goto err; + + families_count = CFArrayGetCount (families); + + /* Move preferred family to the front if exists. */ + pref_family = + mac_font_create_preferred_family_for_attributes (attributes); + if (pref_family) + { + pref_family_index = + CFArrayGetFirstIndexOfValue (families, + CFRangeMake (0, families_count), + pref_family); + CFRelease (pref_family); + } + if (pref_family_index > 0) + { + CFMutableArrayRef mutable_families = + CFArrayCreateMutable (NULL, families_count, &kCFTypeArrayCallBacks); + + if (mutable_families) + { + CFArrayAppendValue (mutable_families, + CFArrayGetValueAtIndex (families, + pref_family_index)); + CFArrayAppendArray (mutable_families, families, + CFRangeMake (0, pref_family_index)); + if (pref_family_index + 1 < families_count) + CFArrayAppendArray (mutable_families, families, + CFRangeMake (pref_family_index + 1, + families_count + - (pref_family_index + 1))); + CFRelease (families); + families = mutable_families; + } + } + } + + val = Qnil; + extra = AREF (spec, FONT_EXTRA_INDEX); + families_count = CFArrayGetCount (families); + for (i = 0; i < families_count; i++) + { + CFStringRef family_name = CFArrayGetValueAtIndex (families, i); + FontDescriptorRef pat_desc; + CFArrayRef descs; + CFIndex descs_count; + CFMutableArrayRef filtered_descs, traits_array; + Lisp_Object entity; + int j; + + CFDictionarySetValue (attributes, MAC_FONT_FAMILY_NAME_ATTRIBUTE, + family_name); + pat_desc = mac_font_descriptor_create_with_attributes (attributes); + if (! pat_desc) + goto err; + + /* CTFontDescriptorCreateMatchingFontDescriptors on Mac OS X + 10.7 returns NULL if pat_desc represents the LastResort font. + So we use CTFontDescriptorCreateMatchingFontDescriptor (no + trailing "s") for such a font. */ + if (CFStringCompare (family_name, CFSTR ("LastResort"), 0) + != kCFCompareEqualTo) + descs = mac_font_descriptor_create_matching_font_descriptors (pat_desc, + NULL); + else + { + FontDescriptorRef lr_desc = + mac_font_descriptor_create_matching_font_descriptor (pat_desc, + NULL); + if (lr_desc) + { + descs = CFArrayCreate (NULL, (const void **) &lr_desc, 1, + &kCFTypeArrayCallBacks); + CFRelease (lr_desc); + } + else + descs = NULL; + } + CFRelease (pat_desc); + if (! descs) + goto err; + + descs_count = CFArrayGetCount (descs); + if (descs_count == 0 + || !macfont_supports_charset_and_languages_p (CFArrayGetValueAtIndex (descs, 0), + charset, chars, + languages)) + { + CFRelease (descs); + continue; + } + + filtered_descs = + CFArrayCreateMutable (NULL, descs_count, &kCFTypeArrayCallBacks); + traits_array = CFArrayCreateMutable (NULL, descs_count, NULL); + for (j = 0; j < descs_count; j++) + { + FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j); + CFDictionaryRef dict; + CFNumberRef num; + FontSymbolicTraits sym_traits; + + dict = mac_font_descriptor_copy_attribute (desc, + MAC_FONT_TRAITS_ATTRIBUTE); + if (dict == NULL) + continue; + + num = CFDictionaryGetValue (dict, MAC_FONT_SYMBOLIC_TRAIT); + CFRelease (dict); + if (num == NULL + || !cfnumber_get_font_symbolic_traits_value (num, &sym_traits)) + continue; + + if (spacing >= 0 + && !(synth_sym_traits & MAC_FONT_TRAIT_MONO_SPACE) + && (((sym_traits & MAC_FONT_TRAIT_MONO_SPACE) != 0) + != (spacing >= FONT_SPACING_MONO))) + continue; + + /* Don't use a color bitmap font unless its family is + explicitly specified. */ + if ((sym_traits & MAC_FONT_TRAIT_COLOR_GLYPHS) && NILP (family)) + continue; + + if (j > 0 + && !macfont_supports_charset_and_languages_p (desc, charset, + chars, languages)) + continue; + + CFArrayAppendValue (filtered_descs, desc); + CFArrayAppendValue (traits_array, + (const void *) (uintptr_t) sym_traits); + } + + CFRelease (descs); + descs = filtered_descs; + descs_count = CFArrayGetCount (descs); + + for (j = 0; j < descs_count; j++) + { + FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, j); + FontSymbolicTraits sym_traits = + ((FontSymbolicTraits) (uintptr_t) + CFArrayGetValueAtIndex (traits_array, j)); + FontSymbolicTraits mask_min, mask_max, imask, bmask, mmask; + + mask_min = ((synth_sym_traits ^ sym_traits) + & (MAC_FONT_TRAIT_ITALIC | MAC_FONT_TRAIT_BOLD)); + if (FONT_SLANT_NUMERIC (spec) < 0) + mask_min &= ~MAC_FONT_TRAIT_ITALIC; + if (FONT_WEIGHT_NUMERIC (spec) < 0) + mask_min &= ~MAC_FONT_TRAIT_BOLD; + + mask_max = (synth_sym_traits & ~sym_traits); + /* Synthetic bold does not work for bitmap-only fonts on Mac + OS X 10.6. */ + if ((mask_min ^ mask_max) & MAC_FONT_TRAIT_BOLD) + { + CFNumberRef format = + mac_font_descriptor_copy_attribute (desc, + MAC_FONT_FORMAT_ATTRIBUTE); + + if (format) + { + uint32_t format_val; + + if (CFNumberGetValue (format, kCFNumberSInt32Type, + &format_val) + && format_val == MAC_FONT_FORMAT_BITMAP) + mask_max &= ~MAC_FONT_TRAIT_BOLD; + } + } + if (spacing >= 0) + mask_min |= (mask_max & MAC_FONT_TRAIT_MONO_SPACE); + + for (mmask = (mask_min & MAC_FONT_TRAIT_MONO_SPACE); + mmask <= (mask_max & MAC_FONT_TRAIT_MONO_SPACE); + mmask += MAC_FONT_TRAIT_MONO_SPACE) + for (bmask = (mask_min & MAC_FONT_TRAIT_BOLD); + bmask <= (mask_max & MAC_FONT_TRAIT_BOLD); + bmask += MAC_FONT_TRAIT_BOLD) + for (imask = (mask_min & MAC_FONT_TRAIT_ITALIC); + imask <= (mask_max & MAC_FONT_TRAIT_ITALIC); + imask += MAC_FONT_TRAIT_ITALIC) + { + FontSymbolicTraits synth = (imask | bmask | mmask); + + if (synth == 0 + || j == macfont_closest_traits_index (traits_array, + (sym_traits | synth))) + { + entity = macfont_descriptor_entity (desc, extra, synth); + if (! NILP (entity)) + val = Fcons (entity, val); + } + } + } + + CFRelease (traits_array); + CFRelease (descs); + } + + CFRelease (families); + val = Fnreverse (val); + goto finish; + err: + val = Qnil; + + finish: + FONT_ADD_LOG ("macfont-list", spec, val); + if (charset) CFRelease (charset); + if (languages) CFRelease (languages); + if (attributes) CFRelease (attributes); + if (family_name) CFRelease (family_name); + + unblock_input (); + + return val; +} + +static Lisp_Object +macfont_match (struct frame * frame, Lisp_Object spec) +{ + Lisp_Object entity = Qnil; + CFMutableDictionaryRef attributes; + FontDescriptorRef pat_desc = NULL, desc = NULL; + + block_input (); + + attributes = macfont_create_attributes_with_spec (spec); + if (attributes) + { + pat_desc = mac_font_descriptor_create_with_attributes (attributes); + CFRelease (attributes); + } + if (pat_desc) + { + desc = mac_font_descriptor_create_matching_font_descriptor (pat_desc, + NULL); + CFRelease (pat_desc); + } + if (desc) + { + entity = macfont_descriptor_entity (desc, AREF (spec, FONT_EXTRA_INDEX), + 0); + CFRelease (desc); + } + unblock_input (); + + FONT_ADD_LOG ("macfont-match", spec, entity); + return entity; +} + +static Lisp_Object +macfont_list_family (struct frame *frame) +{ + Lisp_Object list = Qnil; + CFArrayRef families; + + block_input (); + + families = mac_font_create_available_families (); + if (families) + { + CFIndex i, count = CFArrayGetCount (families); + + for (i = 0; i < count; i++) + list = Fcons (macfont_intern_prop_cfstring (CFArrayGetValueAtIndex (families, i)), list); + CFRelease (families); + } + + unblock_input (); + + return list; +} + +static void +macfont_free_entity (Lisp_Object entity) +{ + Lisp_Object val = assq_no_quit (QCfont_entity, + AREF (entity, FONT_EXTRA_INDEX)); + CFStringRef name = XSAVE_POINTER (XCDR (val), 0); + + block_input (); + CFRelease (name); + unblock_input (); +} + +static Lisp_Object +macfont_open (struct frame * f, Lisp_Object entity, int pixel_size) +{ + Lisp_Object val, font_object; + CFStringRef font_name; + struct macfont_info *macfont_info = NULL; + struct font *font; + int size; + FontRef macfont; + FontSymbolicTraits sym_traits; + char name[256]; + int len, i, total_width; + CGGlyph glyph; + CGFloat ascent, descent, leading; + + val = assq_no_quit (QCfont_entity, AREF (entity, FONT_EXTRA_INDEX)); + if (! CONSP (val) + || XTYPE (XCDR (val)) != Lisp_Misc + || XMISCTYPE (XCDR (val)) != Lisp_Misc_Save_Value) + return Qnil; + font_name = XSAVE_POINTER (XCDR (val), 0); + sym_traits = XSAVE_INTEGER (XCDR (val), 1); + + size = XINT (AREF (entity, FONT_SIZE_INDEX)); + if (size == 0) + size = pixel_size; + + block_input (); + macfont = mac_font_create_with_name (font_name, size); + if (macfont) + { + int fontsize = (int) [((NSFont *) macfont) pointSize]; + if (fontsize != size) size = fontsize; + } + unblock_input (); + if (! macfont) + return Qnil; + + font_object = font_make_object (VECSIZE (struct macfont_info), entity, size); + ASET (font_object, FONT_TYPE_INDEX, macfont_driver.type); + len = font_unparse_xlfd (entity, size, name, 256); + if (len > 0) + ASET (font_object, FONT_NAME_INDEX, make_string (name, len)); + len = font_unparse_fcname (entity, size, name, 256); + if (len > 0) + ASET (font_object, FONT_FULLNAME_INDEX, make_string (name, len)); + else + ASET (font_object, FONT_FULLNAME_INDEX, + AREF (font_object, FONT_NAME_INDEX)); + font = XFONT_OBJECT (font_object); + font->pixel_size = size; + font->driver = &macfont_driver; + font->encoding_charset = font->repertory_charset = -1; + + block_input (); + + macfont_info = (struct macfont_info *) font; + macfont_info->macfont = macfont; + macfont_info->cgfont = mac_font_copy_graphics_font (macfont); + + val = assq_no_quit (QCdestination, AREF (entity, FONT_EXTRA_INDEX)); + if (CONSP (val) && EQ (XCDR (val), make_number (1))) + macfont_info->screen_font = mac_screen_font_create_with_name (font_name, + size); + else + macfont_info->screen_font = NULL; + macfont_info->cache = macfont_lookup_cache (font_name); + macfont_retain_cache (macfont_info->cache); + macfont_info->metrics = NULL; + macfont_info->metrics_nrows = 0; + macfont_info->synthetic_italic_p = 0; + macfont_info->synthetic_bold_p = 0; + macfont_info->spacing = MACFONT_SPACING_PROPORTIONAL; + macfont_info->antialias = MACFONT_ANTIALIAS_DEFAULT; + if (!(sym_traits & MAC_FONT_TRAIT_ITALIC) + && FONT_SLANT_NUMERIC (entity) == FONT_SLANT_SYNTHETIC_ITALIC) + macfont_info->synthetic_italic_p = 1; + if (!(sym_traits & MAC_FONT_TRAIT_BOLD) + && FONT_WEIGHT_NUMERIC (entity) == FONT_WEIGHT_SYNTHETIC_BOLD) + macfont_info->synthetic_bold_p = 1; + if (sym_traits & MAC_FONT_TRAIT_MONO_SPACE) + macfont_info->spacing = MACFONT_SPACING_MONO; + else if (INTEGERP (AREF (entity, FONT_SPACING_INDEX)) + && (XINT (AREF (entity, FONT_SPACING_INDEX)) + == FONT_SPACING_SYNTHETIC_MONO)) + macfont_info->spacing = MACFONT_SPACING_SYNTHETIC_MONO; + if (macfont_info->synthetic_italic_p || macfont_info->synthetic_bold_p) + macfont_info->antialias = MACFONT_ANTIALIAS_ON; + else + { + val = assq_no_quit (QCantialias, AREF (entity, FONT_EXTRA_INDEX)); + if (CONSP (val)) + macfont_info->antialias = + NILP (XCDR (val)) ? MACFONT_ANTIALIAS_OFF : MACFONT_ANTIALIAS_ON; + } + macfont_info->color_bitmap_p = 0; + if (sym_traits & MAC_FONT_TRAIT_COLOR_GLYPHS) + macfont_info->color_bitmap_p = 1; + + glyph = macfont_get_glyph_for_character (font, ' '); + if (glyph != kCGFontIndexInvalid) + font->space_width = macfont_glyph_extents (font, glyph, NULL, NULL, 0); + else + /* dirty workaround */ + font->space_width = pixel_size; + + total_width = font->space_width; + for (i = 1; i < 95; i++) + { + glyph = macfont_get_glyph_for_character (font, ' ' + i); + if (glyph == kCGFontIndexInvalid) + break; + total_width += macfont_glyph_extents (font, glyph, NULL, NULL, 0); + } + if (i == 95) + font->average_width = total_width / 95; + else + font->average_width = font->space_width; /* XXX */ + + if (!(macfont_info->screen_font + && mac_screen_font_get_metrics (macfont_info->screen_font, + &ascent, &descent, &leading))) + { + CFStringRef family_name; + + ascent = mac_font_get_ascent (macfont); + descent = mac_font_get_descent (macfont); + leading = mac_font_get_leading (macfont); + /* AppKit and WebKit do some adjustment to the heights of + Courier, Helvetica, and Times. */ + family_name = mac_font_copy_family_name (macfont); + if (family_name) + { + if ((CFStringCompare (family_name, CFSTR ("Courier"), 0) + == kCFCompareEqualTo) + || (CFStringCompare (family_name, CFSTR ("Helvetica"), 0) + == kCFCompareEqualTo) + || (CFStringCompare (family_name, CFSTR ("Times"), 0) + == kCFCompareEqualTo)) + ascent += (ascent + descent) * .15f; + else if (CFStringHasPrefix (family_name, CFSTR ("Hiragino"))) + { + leading *= .25f; + ascent += leading; + } + CFRelease (family_name); + } + } + font->ascent = ascent + 0.5f; + val = assq_no_quit (QCminspace, AREF (entity, FONT_EXTRA_INDEX)); + if (CONSP (val) && !NILP (XCDR (val))) + font->descent = descent + 0.5f; + else + font->descent = descent + leading + 0.5f; + font->height = font->ascent + font->descent; + + font->underline_position = - mac_font_get_underline_position (macfont) + 0.5f; + font->underline_thickness = mac_font_get_underline_thickness (macfont) + 0.5f; + + unblock_input (); + + /* Unfortunately Xft doesn't provide a way to get minimum char + width. So, we use space_width instead. */ + font->min_width = font->max_width = font->space_width; /* XXX */ + + font->baseline_offset = 0; + font->relative_compose = 0; + font->default_ascent = 0; + font->vertical_centering = 0; + + return font_object; +} + +static void +macfont_close (struct frame * f, struct font *font) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + int i; + + block_input (); + CFRelease (macfont_info->macfont); + CGFontRelease (macfont_info->cgfont); + if (macfont_info->screen_font) + CFRelease (macfont_info->screen_font); + macfont_release_cache (macfont_info->cache); + for (i = 0; i < macfont_info->metrics_nrows; i++) + if (macfont_info->metrics[i]) + xfree (macfont_info->metrics[i]); + if (macfont_info->metrics) + xfree (macfont_info->metrics); + unblock_input (); +} + +static int +macfont_has_char (Lisp_Object font, int c) +{ + int result; + CFCharacterSetRef charset; + + block_input (); + if (FONT_ENTITY_P (font)) + { + Lisp_Object val; + CFStringRef name; + + val = assq_no_quit (QCfont_entity, AREF (font, FONT_EXTRA_INDEX)); + val = XCDR (val); + name = XSAVE_POINTER (val, 0); + charset = macfont_get_cf_charset_for_name (name); + } + else + charset = macfont_get_cf_charset (XFONT_OBJECT (font)); + + result = CFCharacterSetIsLongCharacterMember (charset, c); + unblock_input (); + + return result; +} + +static unsigned +macfont_encode_char (struct font *font, int c) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + CGGlyph glyph; + + block_input (); + glyph = macfont_get_glyph_for_character (font, c); + unblock_input (); + + return glyph != kCGFontIndexInvalid ? glyph : FONT_INVALID_CODE; +} + +static int +macfont_text_extents (struct font *font, unsigned int *code, int nglyphs, + struct font_metrics *metrics) +{ + int width, i; + + block_input (); + width = macfont_glyph_extents (font, code[0], metrics, NULL, 0); + for (i = 1; i < nglyphs; i++) + { + struct font_metrics m; + int w = macfont_glyph_extents (font, code[i], metrics ? &m : NULL, + NULL, 0); + + if (metrics) + { + if (width + m.lbearing < metrics->lbearing) + metrics->lbearing = width + m.lbearing; + if (width + m.rbearing > metrics->rbearing) + metrics->rbearing = width + m.rbearing; + if (m.ascent > metrics->ascent) + metrics->ascent = m.ascent; + if (m.descent > metrics->descent) + metrics->descent = m.descent; + } + width += w; + } + unblock_input (); + + if (metrics) + metrics->width = width; + + return width; +} + +static int +macfont_draw (struct glyph_string *s, int from, int to, int x, int y, + bool with_background) +{ + struct frame * f = s->f; + struct macfont_info *macfont_info = (struct macfont_info *) s->font; + FontRef macfont = macfont_info->macfont; + CGContextRef context; + BOOL isComposite = s->first_glyph->type == COMPOSITE_GLYPH; + int end = isComposite ? s->cmp_to : s->nchars; + int len = end - s->cmp_from; + int i; + + block_input (); + + context = [[NSGraphicsContext currentContext] graphicsPort]; + CGContextSaveGState (context); + +#if 0 + if (s->num_clips > 0) + { + CGRect clips[2]; + + for (i = 0; i < s->num_clips; i++) + clips[i] = mac_rect_make (f, s->clip[i].left, s->clip[i].top, + s->clip[i].right - s->clip[i].left, + s->clip[i].bottom - s->clip[i].top); + CGContextClipToRects (context, clips, s->num_clips); + } +#endif + + if (with_background) + { + CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context, s); + CGContextFillRect (context, + NSMakeRect (x, y, + s->width, FONT_HEIGHT (s->font))); + } + + if (macfont_info->cgfont) + { + CGGlyph *glyphs = alloca (sizeof (CGGlyph) * len); + CGPoint *positions = alloca (sizeof (CGPoint) * len); + CGFloat total_width = 0; + CGFloat font_size = mac_font_get_size (macfont); + CGAffineTransform atfm; + CGFloat advance_delta = 0; + int y_draw = -y-FONT_BASE (s->font); + int no_antialias_p = + (macfont_info->antialias == MACFONT_ANTIALIAS_OFF + || (macfont_info->antialias == MACFONT_ANTIALIAS_DEFAULT + && font_size <= macfont_antialias_threshold)); + + for (i = 0; i < len; i++) + { + int width; + + glyphs[i] = *(s->char2b + s->cmp_from + i); + width = (s->padding_p ? 1 + : macfont_glyph_extents (s->font, glyphs[i], + NULL, &advance_delta, + no_antialias_p)); + positions[i].x = total_width + advance_delta; + positions[i].y = 0; + total_width += width; + } + + CGContextScaleCTM (context, 1, -1); + CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context, s); + if (macfont_info->synthetic_italic_p) + atfm = synthetic_italic_atfm; + else + atfm = CGAffineTransformIdentity; + if (macfont_info->synthetic_bold_p) + { + CGContextSetTextDrawingMode (context, kCGTextFillStroke); + CGContextSetLineWidth (context, synthetic_bold_factor * font_size); + CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND (context, s); + } + if (no_antialias_p) + CGContextSetShouldAntialias (context, false); + + CGContextSetTextMatrix (context, atfm); + CGContextSetTextPosition (context, x, y_draw); + +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 + if (macfont_info->color_bitmap_p +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1070 + && CTFontDrawGlyphs != NULL +#endif + ) + { + if (len > 0) + { + CTFontDrawGlyphs (macfont, glyphs, positions, len, context); + } + } + else +#endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1070 */ + { + CGContextSetFont (context, macfont_info->cgfont); + CGContextSetFontSize (context, font_size); + CGContextShowGlyphsAtPositions (context, glyphs, positions, len); + } + } + + CGContextRestoreGState (context); + + unblock_input (); + + return len; +} + +Lisp_Object +macfont_shape (Lisp_Object lgstring) +{ + struct font *font; + struct macfont_info *macfont_info; + FontRef macfont; + ptrdiff_t glyph_len, len, i, j; + CFIndex nonbmp_len; + UniChar *unichars; + CFIndex *nonbmp_indices; + CFStringRef string; + CFIndex used = 0; + struct mac_glyph_layout *glyph_layouts; + + CHECK_FONT_GET_OBJECT (LGSTRING_FONT (lgstring), font); + macfont_info = (struct macfont_info *) font; + macfont = macfont_info->macfont; + + glyph_len = LGSTRING_GLYPH_LEN (lgstring); + nonbmp_len = 0; + for (i = 0; i < glyph_len; i++) + { + Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i); + + if (NILP (lglyph)) + break; + if (LGLYPH_CHAR (lglyph) >= 0x10000) + nonbmp_len++; + } + + len = i; + lint_assume (len <= TYPE_MAXIMUM (EMACS_INT) - 2); + + if (INT_MAX / 2 < len) + memory_full (SIZE_MAX); + + unichars = alloca (sizeof (UniChar) * (len + nonbmp_len)); + nonbmp_indices = alloca (sizeof (CFIndex) * (nonbmp_len + 1)); + for (i = j = 0; i < len; i++) + { + UTF32Char c = LGLYPH_CHAR (LGSTRING_GLYPH (lgstring, i)); + + if (macfont_store_utf32char_to_unichars (c, unichars + i + j) > 1) + { + nonbmp_indices[j] = i + j; + j++; + } + } + nonbmp_indices[j] = len + j; /* sentinel */ + + block_input (); + + string = CFStringCreateWithCharactersNoCopy (NULL, unichars, len + nonbmp_len, + kCFAllocatorNull); + if (string) + { + glyph_layouts = alloca (sizeof (struct mac_glyph_layout) * glyph_len); + if (macfont_info->screen_font) + used = mac_screen_font_shape (macfont_info->screen_font, string, + glyph_layouts, glyph_len); + else + used = mac_font_shape (macfont, string, glyph_layouts, glyph_len); + CFRelease (string); + } + + unblock_input (); + + if (used == 0) + return Qnil; + + block_input (); + + for (i = 0; i < used; i++) + { + Lisp_Object lglyph = LGSTRING_GLYPH (lgstring, i); + struct mac_glyph_layout *gl = glyph_layouts + i; + EMACS_INT from, to; + struct font_metrics metrics; + int xoff, yoff, wadjust; + + if (NILP (lglyph)) + { + lglyph = Fmake_vector (make_number (LGLYPH_SIZE), Qnil); + LGSTRING_SET_GLYPH (lgstring, i, lglyph); + } + + from = gl->comp_range.location; + /* Convert UTF-16 index to UTF-32. */ + j = 0; + while (nonbmp_indices[j] < from) + j++; + from -= j; + LGLYPH_SET_FROM (lglyph, from); + + to = gl->comp_range.location + gl->comp_range.length; + /* Convert UTF-16 index to UTF-32. */ + while (nonbmp_indices[j] < to) + j++; + to -= j; + LGLYPH_SET_TO (lglyph, to - 1); + + /* LGLYPH_CHAR is used in `describe-char' for checking whether + the composition is trivial. */ + { + UTF32Char c; + + if (unichars[gl->string_index] >= 0xD800 + && unichars[gl->string_index] < 0xDC00) + c = (((unichars[gl->string_index] - 0xD800) << 10) + + (unichars[gl->string_index + 1] - 0xDC00) + 0x10000); + else + c = unichars[gl->string_index]; + if (macfont_get_glyph_for_character (font, c) != gl->glyph_id) + c = 0; + LGLYPH_SET_CHAR (lglyph, c); + } + + { + unsigned long cc = gl->glyph_id; + LGLYPH_SET_CODE (lglyph, cc); + } + + macfont_glyph_extents (font, gl->glyph_id, &metrics, NULL, 0); + LGLYPH_SET_WIDTH (lglyph, metrics.width); + LGLYPH_SET_LBEARING (lglyph, metrics.lbearing); + LGLYPH_SET_RBEARING (lglyph, metrics.rbearing); + LGLYPH_SET_ASCENT (lglyph, metrics.ascent); + LGLYPH_SET_DESCENT (lglyph, metrics.descent); + + xoff = lround (gl->advance_delta); + yoff = lround (- gl->baseline_delta); + wadjust = lround (gl->advance); + if (xoff != 0 || yoff != 0 || wadjust != metrics.width) + { + Lisp_Object vec; + + vec = Fmake_vector (make_number (3), Qnil); + ASET (vec, 0, make_number (xoff)); + ASET (vec, 1, make_number (yoff)); + ASET (vec, 2, make_number (wadjust)); + LGLYPH_SET_ADJUSTMENT (lglyph, vec); + } + } + + unblock_input (); + + return make_number (used); +} + +/* Structures for the UVS subtable (format 14) in the cmap table. */ +typedef UInt8 UINT24[3]; + +#pragma pack(push, 1) +struct variation_selector_record +{ + UINT24 var_selector; + UInt32 default_uvs_offset, non_default_uvs_offset; +}; +struct uvs_table +{ + UInt16 format; + UInt32 length, num_var_selector_records; + struct variation_selector_record variation_selector_records[1]; +}; +#define SIZEOF_UVS_TABLE_HEADER \ + (sizeof (struct uvs_table) - sizeof (struct variation_selector_record)) + +struct unicode_value_range +{ + UINT24 start_unicode_value; + UInt8 additional_count; +}; +struct default_uvs_table { + UInt32 num_unicode_value_ranges; + struct unicode_value_range unicode_value_ranges[1]; +}; +#define SIZEOF_DEFAULT_UVS_TABLE_HEADER \ + (sizeof (struct default_uvs_table) - sizeof (struct unicode_value_range)) + +struct uvs_mapping +{ + UINT24 unicode_value; + UInt16 glyph_id; +}; +struct non_default_uvs_table +{ + UInt32 num_uvs_mappings; + struct uvs_mapping uvs_mappings[1]; +}; +#define SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER \ + (sizeof (struct non_default_uvs_table) - sizeof (struct uvs_mapping)) +#pragma pack(pop) + +/* Read big endian values. The argument LVAL must be an lvalue. */ +/* I suppose OSReadBigInt* takes care of unaligned data. At least, we + can find "... = OSReadBigInt32(cdb, 2);" followed by "... = + OSReadBigInt16(cdb, 7);" in a sample code by Apple. */ +#define BUINT8_VALUE(lval) (*((UInt8 *) &(lval))) +#define BUINT16_VALUE(lval) OSReadBigInt16 (&(lval), 0) +/* Succeeding one byte should also be accessible. */ +#define BUINT24_VALUE(lval) (OSReadBigInt32 (&(lval), 0) >> 8) +#define BUINT32_VALUE(lval) OSReadBigInt32 (&(lval), 0) + +/* Return UVS subtable for the specified FONT. If the subtable is not + found or ill-formated, then return NULL. */ + +static CFDataRef +mac_font_copy_uvs_table (FontRef font) +{ + CFDataRef cmap_table, uvs_table = NULL; + + cmap_table = mac_font_copy_non_synthetic_table (font, cmapFontTableTag); + if (cmap_table) + { + sfntCMapHeader *cmap = (sfntCMapHeader *) CFDataGetBytePtr (cmap_table); + struct uvs_table *uvs; + struct variation_selector_record *records; + UInt32 cmap_len, ntables, i, uvs_offset, uvs_len, nrecords; + +#if __LP64__ + if (CFDataGetLength (cmap_table) > UINT32_MAX) + goto finish; +#endif + + cmap_len = CFDataGetLength (cmap_table); + if (sizeof_sfntCMapHeader > cmap_len) + goto finish; + + ntables = BUINT16_VALUE (cmap->numTables); + if (ntables > ((cmap_len - sizeof_sfntCMapHeader) + / sizeof_sfntCMapEncoding)) + goto finish; + + for (i = 0; i < ntables; i++) + if ((BUINT16_VALUE (cmap->encoding[i].platformID) + == kFontUnicodePlatform) + && (BUINT16_VALUE (cmap->encoding[i].scriptID) + == 5)) /* kFontUnicodeV4_0VariationSequenceSemantics */ + { + uvs_offset = BUINT32_VALUE (cmap->encoding[i].offset); + break; + } + if (i == ntables + || uvs_offset > cmap_len + || SIZEOF_UVS_TABLE_HEADER > cmap_len - uvs_offset) + goto finish; + + uvs = (struct uvs_table *) ((UInt8 *) cmap + uvs_offset); + uvs_len = BUINT32_VALUE (uvs->length); + if (uvs_len > cmap_len - uvs_offset + || SIZEOF_UVS_TABLE_HEADER > uvs_len) + goto finish; + + if (BUINT16_VALUE (uvs->format) != 14) + goto finish; + + nrecords = BUINT32_VALUE (uvs->num_var_selector_records); + if (nrecords > ((uvs_len - SIZEOF_UVS_TABLE_HEADER) + / sizeof (struct variation_selector_record))) + goto finish; + + records = uvs->variation_selector_records; + for (i = 0; i < nrecords; i++) + { + UInt32 default_uvs_offset, non_default_uvs_offset; + + default_uvs_offset = BUINT32_VALUE (records[i].default_uvs_offset); + if (default_uvs_offset) + { + struct default_uvs_table *default_uvs; + UInt32 nranges; + + if (default_uvs_offset > uvs_len + || (SIZEOF_DEFAULT_UVS_TABLE_HEADER + > uvs_len - default_uvs_offset)) + goto finish; + + default_uvs = ((struct default_uvs_table *) + ((UInt8 *) uvs + default_uvs_offset)); + nranges = BUINT32_VALUE (default_uvs->num_unicode_value_ranges); + if (nranges > ((uvs_len - default_uvs_offset + - SIZEOF_DEFAULT_UVS_TABLE_HEADER) + / sizeof (struct unicode_value_range))) + goto finish; + /* Now 2 * nranges can't overflow, so we can safely use + `(lo + hi) / 2' instead of `lo + (hi - lo) / 2' in + mac_font_get_glyphs_for_variants. */ + } + + non_default_uvs_offset = + BUINT32_VALUE (records[i].non_default_uvs_offset); + if (non_default_uvs_offset) + { + struct non_default_uvs_table *non_default_uvs; + UInt32 nmappings; + + if (non_default_uvs_offset > uvs_len + || (SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER + > uvs_len - non_default_uvs_offset)) + goto finish; + + non_default_uvs = ((struct non_default_uvs_table *) + ((UInt8 *) uvs + non_default_uvs_offset)); + nmappings = BUINT32_VALUE (non_default_uvs->num_uvs_mappings); + if (nmappings > ((uvs_len - non_default_uvs_offset + - SIZEOF_NON_DEFAULT_UVS_TABLE_HEADER) + / sizeof (struct uvs_mapping))) + goto finish; + /* Now 2 * nmappings can't overflow, so we can safely + use `(lo + hi) / 2' instead of `lo + (hi - lo) / 2' + in mac_font_get_glyphs_for_variants. */ + } + } + + uvs_table = CFDataCreate (NULL, (UInt8 *) uvs, uvs_len); + + finish: + CFRelease (cmap_table); + } + + return uvs_table; +} + +/* Find an entry in the given UVS subtable UVS_TABLE for a variation + sequence consisting of the given base character C and each + variation selector SELECTORS[i] for 0 <= i < COUNT, and store the + result (explained below) into the corresponding GLYPHS[i]. If the + entry is found in the Default UVS Table, then the result is 0. If + the entry is found in the Non-Default UVS Table, then the result is + the associated glyph ID. Otherwise, kCGFontIndexInvalid. The + elements in SELECTORS must be sorted in strictly increasing + order. */ + +static void +mac_font_get_glyphs_for_variants (CFDataRef uvs_table, UTF32Char c, + const UTF32Char selectors[], CGGlyph glyphs[], + CFIndex count) +{ + struct uvs_table *uvs = (struct uvs_table *) CFDataGetBytePtr (uvs_table); + struct variation_selector_record *records = uvs->variation_selector_records; + CFIndex i; + UInt32 ir, nrecords; +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + dispatch_queue_t queue = + dispatch_get_global_queue (DISPATCH_QUEUE_PRIORITY_DEFAULT, 0); + dispatch_group_t group = dispatch_group_create (); +#endif + + nrecords = BUINT32_VALUE (uvs->num_var_selector_records); + i = 0; + ir = 0; + while (i < count && ir < nrecords) + { + UInt32 default_uvs_offset, non_default_uvs_offset; + + if (selectors[i] < BUINT24_VALUE (records[ir].var_selector)) + { + glyphs[i++] = kCGFontIndexInvalid; + continue; + } + else if (selectors[i] > BUINT24_VALUE (records[ir].var_selector)) + { + ir++; + continue; + } + + /* selectors[i] == BUINT24_VALUE (records[ir].var_selector) */ + default_uvs_offset = BUINT32_VALUE (records[ir].default_uvs_offset); + non_default_uvs_offset = + BUINT32_VALUE (records[ir].non_default_uvs_offset); +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + dispatch_group_async (group, queue, ^{ +#endif + glyphs[i] = kCGFontIndexInvalid; + + if (default_uvs_offset) + { + struct default_uvs_table *default_uvs = + (struct default_uvs_table *) ((UInt8 *) uvs + + default_uvs_offset); + struct unicode_value_range *ranges = + default_uvs->unicode_value_ranges; + UInt32 lo, hi; + + lo = 0; + hi = BUINT32_VALUE (default_uvs->num_unicode_value_ranges); + while (lo < hi) + { + UInt32 mid = (lo + hi) / 2; + + if (c < BUINT24_VALUE (ranges[mid].start_unicode_value)) + hi = mid; + else + lo = mid + 1; + } + if (hi > 0 + && (c <= (BUINT24_VALUE (ranges[hi - 1].start_unicode_value) + + BUINT8_VALUE (ranges[hi - 1].additional_count)))) + glyphs[i] = 0; + } + + if (glyphs[i] == kCGFontIndexInvalid && non_default_uvs_offset) + { + struct non_default_uvs_table *non_default_uvs = + (struct non_default_uvs_table *) ((UInt8 *) uvs + + non_default_uvs_offset); + struct uvs_mapping *mappings = non_default_uvs->uvs_mappings; + UInt32 lo, hi; + + lo = 0; + hi = BUINT32_VALUE (non_default_uvs->num_uvs_mappings); + while (lo < hi) + { + UInt32 mid = (lo + hi) / 2; + + if (c < BUINT24_VALUE (mappings[mid].unicode_value)) + hi = mid; + else + lo = mid + 1; + } + if (hi > 0 && + BUINT24_VALUE (mappings[hi - 1].unicode_value) == c) + glyphs[i] = BUINT16_VALUE (mappings[hi - 1].glyph_id); + } +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + }); +#endif + i++; + ir++; + } + while (i < count) + glyphs[i++] = kCGFontIndexInvalid; +#if MAC_OS_X_VERSION_MIN_REQUIRED >= 1060 + dispatch_group_wait (group, DISPATCH_TIME_FOREVER); + dispatch_release (group); +#endif +} + +static int +macfont_variation_glyphs (struct font *font, int c, unsigned variations[256]) +{ + CFDataRef uvs_table; + CharacterCollection uvs_collection; + int i, n = 0; + + block_input (); + uvs_table = macfont_get_uvs_table (font, &uvs_collection); + + if (uvs_table) + { + UTF32Char selectors[256]; + CGGlyph glyphs[256]; + + for (i = 0; i < 16; i++) + selectors[i] = 0xFE00 + i; + for (; i < 256; i++) + selectors[i] = 0xE0100 + (i - 16); + mac_font_get_glyphs_for_variants (uvs_table, c, selectors, glyphs, 256); + for (i = 0; i < 256; i++) + { + CGGlyph glyph = glyphs[i]; + + if (uvs_collection != MAC_CHARACTER_COLLECTION_IDENTITY_MAPPING + && glyph != kCGFontIndexInvalid) + glyph = macfont_get_glyph_for_cid (font, uvs_collection, glyph); + if (glyph == kCGFontIndexInvalid) + variations[i] = 0; + else + { + variations[i] = (glyph ? glyph + : macfont_get_glyph_for_character (font, c)); + n++; + } + } + } + unblock_input (); + + return n; +} + +static const char *const macfont_booleans[] = { + ":antialias", + ":minspace", + NULL, +}; + +static const char *const macfont_non_booleans[] = { + ":lang", + ":script", + ":destination", + NULL, +}; + +static void +macfont_filter_properties (Lisp_Object font, Lisp_Object alist) +{ + font_filter_properties (font, alist, macfont_booleans, macfont_non_booleans); +} + +static Boolean +mac_ctfont_descriptor_supports_languages (CTFontDescriptorRef descriptor, + CFArrayRef languages) +{ + Boolean result = true; + CFArrayRef desc_languages = + CTFontDescriptorCopyAttribute (descriptor, kCTFontLanguagesAttribute); + + if (desc_languages == NULL) + result = false; + else + { + CFIndex desc_languages_count, i, languages_count; + + desc_languages_count = CFArrayGetCount (desc_languages); + languages_count = CFArrayGetCount (languages); + for (i = 0; i < languages_count; i++) + if (!CFArrayContainsValue (desc_languages, + CFRangeMake (0, desc_languages_count), + CFArrayGetValueAtIndex (languages, i))) + { + result = false; + break; + } + CFRelease (desc_languages); + } + + return result; +} + +static CFStringRef +mac_ctfont_create_preferred_family_for_attributes (CFDictionaryRef attributes) +{ + CFStringRef result = NULL; + CFStringRef charset_string = + CFDictionaryGetValue (attributes, MAC_FONT_CHARACTER_SET_STRING_ATTRIBUTE); + CFIndex length; + + if (charset_string + && (length = CFStringGetLength (charset_string)) > 0) + { + CFAttributedStringRef attr_string = NULL; + CTLineRef ctline = NULL; + CFDictionaryRef attrs = + CFDictionaryCreate (NULL, NULL, NULL, 0, + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + + if (attrs) + { + attr_string = CFAttributedStringCreate (NULL, charset_string, attrs); + CFRelease (attrs); + } + if (attr_string) + { + ctline = CTLineCreateWithAttributedString (attr_string); + CFRelease (attr_string); + } + if (ctline) + { + CFArrayRef runs = CTLineGetGlyphRuns (ctline); + CFIndex i, nruns = CFArrayGetCount (runs); + CTFontRef font; + + for (i = 0; i < nruns; i++) + { + CTRunRef run = CFArrayGetValueAtIndex (runs, i); + CFDictionaryRef attributes = CTRunGetAttributes (run); + CTFontRef font_in_run; + + if (attributes == NULL) + break; + font_in_run = + CFDictionaryGetValue (attributes, kCTFontAttributeName); + if (font_in_run == NULL) + break; + if (i == 0) + font = font_in_run; + else if (!mac_ctfont_equal_in_postscript_name (font, font_in_run)) + break; + } + if (nruns > 0 && i == nruns) + result = CTFontCopyAttribute (font, kCTFontFamilyNameAttribute); + CFRelease (ctline); + } + } + + return result; +} + +static inline double +mac_ctfont_get_advance_width_for_glyph (CTFontRef font, CGGlyph glyph) +{ + return CTFontGetAdvancesForGlyphs (font, kCTFontDefaultOrientation, + &glyph, NULL, 1); +} + +static inline CGRect +mac_ctfont_get_bounding_rect_for_glyph (CTFontRef font, CGGlyph glyph) +{ + return CTFontGetBoundingRectsForGlyphs (font, kCTFontDefaultOrientation, + &glyph, NULL, 1); +} + +static CFArrayRef +mac_ctfont_create_available_families (void) +{ + CFMutableArrayRef families = NULL; + +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + if (CTFontManagerCopyAvailableFontFamilyNames != NULL) +#endif + { + CFArrayRef orig_families = CTFontManagerCopyAvailableFontFamilyNames (); + + if (orig_families) + { + CFIndex i, count = CFArrayGetCount (orig_families); + + families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks); + if (families) + for (i = 0; i < count; i++) + { + CFStringRef family = CFArrayGetValueAtIndex (orig_families, i); + + if (!CFStringHasPrefix (family, CFSTR (".")) + && (CTFontManagerCompareFontFamilyNames (family, + CFSTR ("LastResort"), + NULL) + != kCFCompareEqualTo)) + CFArrayAppendValue (families, family); + } + CFRelease (orig_families); + } + } +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + else /* CTFontManagerCopyAvailableFontFamilyNames == NULL */ +#endif +#endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1060 */ +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 + { + CTFontCollectionRef collection; + CFArrayRef descs = NULL; + + collection = CTFontCollectionCreateFromAvailableFonts (NULL); + if (collection) + { + descs = CTFontCollectionCreateMatchingFontDescriptors (collection); + CFRelease (collection); + } + if (descs) + { + CFIndex i, count = CFArrayGetCount (descs); + + families = CFArrayCreateMutable (NULL, count, &kCFTypeArrayCallBacks); + if (families) + for (i = 0; i < count; i++) + { + FontDescriptorRef desc = CFArrayGetValueAtIndex (descs, i); + CFStringRef name = + mac_font_descriptor_copy_attribute (desc, + MAC_FONT_FAMILY_NAME_ATTRIBUTE); + + if (name) + { + CFIndex p, limit = CFArrayGetCount (families); + + p = CFArrayBSearchValues (families, CFRangeMake (0, limit), + (const void *) name, + mac_font_family_compare, NULL); + if (p >= limit) + CFArrayAppendValue (families, name); + else if (mac_font_family_compare + (CFArrayGetValueAtIndex (families, p), + name, NULL) != kCFCompareEqualTo) + CFArrayInsertValueAtIndex (families, p, name); + CFRelease (name); + } + } + CFRelease (descs); + } + } +#endif + + return families; +} + +static Boolean +mac_ctfont_equal_in_postscript_name (CTFontRef font1, CTFontRef font2) +{ + Boolean result; + CFStringRef name1, name2; + + if (font1 == font2) + return true; + + result = false; + name1 = CTFontCopyPostScriptName (font1); + if (name1) + { + name2 = CTFontCopyPostScriptName (font2); + if (name2) + { + result = (CFStringCompare (name1, name2, 0) == kCFCompareEqualTo); + CFRelease (name2); + } + CFRelease (name1); + } + + return result; +} + +static CTLineRef +mac_ctfont_create_line_with_string_and_font (CFStringRef string, + CTFontRef macfont) +{ + CFStringRef keys[] = {kCTFontAttributeName, kCTKernAttributeName}; + CFTypeRef values[] = {NULL, NULL}; + CFDictionaryRef attributes = NULL; + CFAttributedStringRef attr_string = NULL; + CTLineRef ctline = NULL; + float float_zero = 0.0f; + + values[0] = macfont; + values[1] = CFNumberCreate (NULL, kCFNumberFloatType, &float_zero); + if (values[1]) + { + attributes = CFDictionaryCreate (NULL, (const void **) keys, + (const void **) values, + sizeof (keys) / sizeof (keys[0]), + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + CFRelease (values[1]); + } + if (attributes) + { + attr_string = CFAttributedStringCreate (NULL, string, attributes); + CFRelease (attributes); + } + if (attr_string) + { + ctline = CTLineCreateWithAttributedString (attr_string); + CFRelease (attr_string); + } + if (ctline) + { + /* Abandon if ctline contains some fonts other than the + specified one. */ + CFArrayRef runs = CTLineGetGlyphRuns (ctline); + CFIndex i, nruns = CFArrayGetCount (runs); + + for (i = 0; i < nruns; i++) + { + CTRunRef run = CFArrayGetValueAtIndex (runs, i); + CFDictionaryRef attributes = CTRunGetAttributes (run); + CTFontRef font_in_run; + + if (attributes == NULL) + break; + font_in_run = + CFDictionaryGetValue (attributes, kCTFontAttributeName); + if (font_in_run == NULL) + break; + if (!mac_ctfont_equal_in_postscript_name (macfont, font_in_run)) + break; + } + if (i < nruns) + { + CFRelease (ctline); + ctline = NULL; + } + } + + return ctline; +} + +CFIndex +mac_ctfont_shape (CTFontRef font, CFStringRef string, + struct mac_glyph_layout *glyph_layouts, CFIndex glyph_len) +{ + CFIndex used, result = 0; + CTLineRef ctline = mac_ctfont_create_line_with_string_and_font (string, font); + + if (ctline == NULL) + return 0; + + used = CTLineGetGlyphCount (ctline); + if (used <= glyph_len) + { + CFArrayRef ctruns = CTLineGetGlyphRuns (ctline); + CFIndex k, ctrun_count = CFArrayGetCount (ctruns); + CGFloat total_advance = 0; + CFIndex total_glyph_count = 0; + + for (k = 0; k < ctrun_count; k++) + { + CTRunRef ctrun = CFArrayGetValueAtIndex (ctruns, k); + CFIndex i, min_location, glyph_count = CTRunGetGlyphCount (ctrun); + struct mac_glyph_layout *glbuf = glyph_layouts + total_glyph_count; + CFRange string_range, comp_range, range; + CFIndex *permutation; + + if (CTRunGetStatus (ctrun) & kCTRunStatusRightToLeft) + permutation = xmalloc (sizeof (CFIndex) * glyph_count); + else + permutation = NULL; + +#define RIGHT_TO_LEFT_P permutation + + /* Now the `comp_range' member of struct mac_glyph_layout is + temporarily used as a work area such that: + glbuf[i].comp_range.location = + min {compRange[i + 1].location, ..., + compRange[glyph_count - 1].location, + maxRange (stringRangeForCTRun)} + glbuf[i].comp_range.length = maxRange (compRange[i]) + where compRange[i] is the range of composed characters + containing i-th glyph. */ + string_range = CTRunGetStringRange (ctrun); + min_location = string_range.location + string_range.length; + for (i = 0; i < glyph_count; i++) + { + struct mac_glyph_layout *gl = glbuf + glyph_count - i - 1; + CFIndex glyph_index; + CFRange rng; + + if (!RIGHT_TO_LEFT_P) + glyph_index = glyph_count - i - 1; + else + glyph_index = i; + CTRunGetStringIndices (ctrun, CFRangeMake (glyph_index, 1), + &gl->string_index); + rng = + CFStringGetRangeOfComposedCharactersAtIndex (string, + gl->string_index); + gl->comp_range.location = min_location; + gl->comp_range.length = rng.location + rng.length; + if (rng.location < min_location) + min_location = rng.location; + } + + /* Fill the `comp_range' member of struct mac_glyph_layout, + and setup a permutation for right-to-left text. */ + comp_range = CFRangeMake (string_range.location, 0); + range = CFRangeMake (0, 0); + while (1) + { + struct mac_glyph_layout *gl = + glbuf + range.location + range.length; + + if (gl->comp_range.length + > comp_range.location + comp_range.length) + comp_range.length = gl->comp_range.length - comp_range.location; + min_location = gl->comp_range.location; + range.length++; + + if (min_location >= comp_range.location + comp_range.length) + { + comp_range.length = min_location - comp_range.location; + for (i = 0; i < range.length; i++) + { + glbuf[range.location + i].comp_range = comp_range; + if (RIGHT_TO_LEFT_P) + permutation[range.location + i] = + range.location + range.length - i - 1; + } + + comp_range = CFRangeMake (min_location, 0); + range.location += range.length; + range.length = 0; + if (range.location == glyph_count) + break; + } + } + + /* Then fill the remaining members. */ + for (range = CFRangeMake (0, 1); range.location < glyph_count; + range.location++) + { + struct mac_glyph_layout *gl; + CGPoint position; + + if (!RIGHT_TO_LEFT_P) + gl = glbuf + range.location; + else + { + CFIndex src, dest; + + src = glyph_count - 1 - range.location; + dest = permutation[src]; + gl = glbuf + dest; + if (src < dest) + { + CFIndex tmp = gl->string_index; + + gl->string_index = glbuf[src].string_index; + glbuf[src].string_index = tmp; + } + } + CTRunGetGlyphs (ctrun, range, &gl->glyph_id); + + CTRunGetPositions (ctrun, range, &position); + gl->advance_delta = position.x - total_advance; + gl->baseline_delta = position.y; + gl->advance = (gl->advance_delta + + CTRunGetTypographicBounds (ctrun, range, + NULL, NULL, NULL)); + total_advance += gl->advance; + } + + if (RIGHT_TO_LEFT_P) + xfree (permutation); + +#undef RIGHT_TO_LEFT_P + + total_glyph_count += glyph_count; + } + + result = used; + } + CFRelease (ctline); + + return result; +} + +/* The function below seems to cause a memory leak for the CFString + created by CFStringCreateWithCharacters as of Mac OS X 10.5.8 and + 10.6.3. For now, we use the NSGlyphInfo version instead. */ +#if USE_CT_GLYPH_INFO +CGGlyph +mac_ctfont_get_glyph_for_cid (CTFontRef font, CTCharacterCollection collection, + CGFontIndex cid) +{ + CGGlyph result = kCGFontIndexInvalid; + UniChar characters[] = {0xfffd}; + CFStringRef string; + CFAttributedStringRef attr_string = NULL; + CTLineRef ctline = NULL; + + string = CFStringCreateWithCharacters (NULL, characters, + sizeof (characters) + / sizeof (characters[0])); + if (string) + { + CTGlyphInfoRef glyph_info = + CTGlyphInfoCreateWithCharacterIdentifier (cid, collection, string); + CFDictionaryRef attributes = NULL; + + if (glyph_info) + { + CFStringRef keys[] = {kCTFontAttributeName, + kCTGlyphInfoAttributeName}; + CFTypeRef values[] = {font, glyph_info}; + + attributes = CFDictionaryCreate (NULL, (const void **) keys, + (const void **) values, + sizeof (keys) / sizeof (keys[0]), + &kCFTypeDictionaryKeyCallBacks, + &kCFTypeDictionaryValueCallBacks); + CFRelease (glyph_info); + } + if (attributes) + { + attr_string = CFAttributedStringCreate (NULL, string, attributes); + CFRelease (attributes); + } + CFRelease (string); + } + if (attr_string) + { + ctline = CTLineCreateWithAttributedString (attr_string); + CFRelease (attr_string); + } + if (ctline) + { + CFArrayRef runs = CTLineGetGlyphRuns (ctline); + + if (CFArrayGetCount (runs) > 0) + { + CTRunRef run = CFArrayGetValueAtIndex (runs, 0); + CFDictionaryRef attributes = CTRunGetAttributes (run); + + if (attributes) + { + CTFontRef font_in_run = + CFDictionaryGetValue (attributes, kCTFontAttributeName); + + if (font_in_run + && mac_ctfont_equal_in_postscript_name (font_in_run, font)) + { + CTRunGetGlyphs (run, CFRangeMake (0, 1), &result); + if (result >= CTFontGetGlyphCount (font)) + result = kCGFontIndexInvalid; + } + } + } + CFRelease (ctline); + } + + return result; +} +#endif + +#if MAC_OS_X_VERSION_MIN_REQUIRED < 1060 +static inline int +mac_font_family_group (CFStringRef family) +{ + if (CFStringHasPrefix (family, CFSTR ("#"))) + return 2; + else + { + CFRange range; + + range = CFStringFind (family, CFSTR ("Apple"), + kCFCompareCaseInsensitive | kCFCompareAnchored); + if (range.location != kCFNotFound) + return 1; + + return 0; + } +} + +CFComparisonResult +mac_font_family_compare (const void *val1, const void *val2, void *context) +{ + CFStringRef family1 = (CFStringRef) val1, family2 = (CFStringRef) val2; + int group1, group2; + + group1 = mac_font_family_group (family1); + group2 = mac_font_family_group (family2); + if (group1 < group2) + return kCFCompareLessThan; + if (group1 > group2) + return kCFCompareGreaterThan; + return CFStringCompare (family1, family2, kCFCompareCaseInsensitive); +} +#endif /* MAC_OS_X_VERSION_MIN_REQUIRED < 1060 */ + +void * +macfont_get_nsctfont (struct font *font) +{ + struct macfont_info *macfont_info = (struct macfont_info *) font; + FontRef macfont = macfont_info->macfont; + + return (void *) macfont; +} + +void +mac_register_font_driver (struct frame *f) +{ + register_font_driver (&macfont_driver, f); +} + +#endif // MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + + +void +syms_of_macfont (void) +{ +#if MAC_OS_X_VERSION_MAX_ALLOWED >= 1050 + static struct font_driver mac_font_driver; + + DEFSYM (Qmac_ct, "mac-ct"); + macfont_driver.type = Qmac_ct; + register_font_driver (&macfont_driver, NULL); + + DEFSYM (QCdestination, ":destination"); + DEFSYM (QCminspace, ":minspace"); +#endif +} diff --git a/src/macuvs.h b/src/macuvs.h new file mode 100644 index 00000000000..20879888f9a --- /dev/null +++ b/src/macuvs.h @@ -0,0 +1,9215 @@ +/* UVS (Unicode Variation Sequence) table definitions. + +This file is part of GNU Emacs. */ + +/* This was generated from the Ideographic Variation Database file at + http://www.unicode.org/ivd/data/2012-03-02/IVD_Sequences.txt + using admin/mac/uvs.el in GNU Emacs, and distributed under + the Terms of Use in http://www.unicode.org/terms_of_use.html. */ +static const unsigned char mac_uvs_table_adobe_japan1_bytes[] = + { + 0x00, 0x0e, 0x00, 0x01, 0x1f, 0x9e, 0x00, 0x00, + 0x00, 0x0f, 0x0e, 0x01, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0xaf, 0x0e, 0x01, 0x01, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x04, 0x9a, + 0x0e, 0x01, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x1c, 0x31, 0x0e, 0x01, 0x03, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x1e, 0xb0, 0x0e, 0x01, + 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1f, + 0x09, 0x0e, 0x01, 0x05, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x1f, 0x2b, 0x0e, 0x01, 0x06, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x1f, 0x43, 0x0e, + 0x01, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, + 0x1f, 0x51, 0x0e, 0x01, 0x08, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x01, 0x1f, 0x5f, 0x0e, 0x01, 0x09, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1f, 0x68, + 0x0e, 0x01, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x01, 0x1f, 0x71, 0x0e, 0x01, 0x0b, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x01, 0x1f, 0x7a, 0x0e, 0x01, + 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x1f, + 0x83, 0x0e, 0x01, 0x0d, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x1f, 0x8c, 0x0e, 0x01, 0x0e, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x01, 0x1f, 0x95, 0x00, + 0x00, 0x33, 0xfb, 0x00, 0x34, 0x02, 0x35, 0x82, + 0x00, 0x34, 0x05, 0x3c, 0x1b, 0x00, 0x34, 0x06, + 0x43, 0x5a, 0x00, 0x34, 0x27, 0x36, 0x56, 0x00, + 0x34, 0x2c, 0x43, 0x5e, 0x00, 0x34, 0x2e, 0x37, + 0x88, 0x00, 0x34, 0x68, 0x36, 0xdf, 0x00, 0x34, + 0x6a, 0x43, 0x75, 0x00, 0x34, 0x88, 0x3c, 0x52, + 0x00, 0x34, 0x92, 0x43, 0x8e, 0x00, 0x34, 0xb5, + 0x41, 0x99, 0x00, 0x34, 0xbc, 0x43, 0x97, 0x00, + 0x34, 0xc1, 0x47, 0xd0, 0x00, 0x34, 0xc7, 0x43, + 0x9b, 0x00, 0x34, 0xdb, 0x3c, 0x41, 0x00, 0x35, + 0x1f, 0x36, 0x29, 0x00, 0x35, 0x3e, 0x37, 0x1e, + 0x00, 0x35, 0x5d, 0x43, 0xbd, 0x00, 0x35, 0x5e, + 0x43, 0xbe, 0x00, 0x35, 0x63, 0x43, 0xc0, 0x00, + 0x35, 0x6e, 0x43, 0xc4, 0x00, 0x35, 0xa6, 0x43, + 0xd9, 0x00, 0x35, 0xa8, 0x43, 0xdb, 0x00, 0x35, + 0xc5, 0x43, 0xe1, 0x00, 0x35, 0xda, 0x43, 0xea, + 0x00, 0x35, 0xde, 0x4e, 0x63, 0x00, 0x35, 0xf4, + 0x43, 0xf3, 0x00, 0x36, 0x05, 0x43, 0xfa, 0x00, + 0x36, 0x14, 0x4a, 0xbb, 0x00, 0x36, 0x4a, 0x44, + 0x21, 0x00, 0x36, 0x91, 0x44, 0x41, 0x00, 0x36, + 0x96, 0x44, 0x45, 0x00, 0x36, 0x99, 0x44, 0x43, + 0x00, 0x36, 0xcf, 0x44, 0x56, 0x00, 0x37, 0x61, + 0x44, 0x78, 0x00, 0x37, 0x62, 0x44, 0x79, 0x00, + 0x37, 0x6b, 0x44, 0x7d, 0x00, 0x37, 0x6c, 0x44, + 0x7c, 0x00, 0x37, 0x75, 0x44, 0x80, 0x00, 0x37, + 0x8d, 0x36, 0x1a, 0x00, 0x37, 0xc1, 0x44, 0x8e, + 0x00, 0x37, 0xe2, 0x37, 0x2b, 0x00, 0x37, 0xe8, + 0x44, 0xa2, 0x00, 0x37, 0xf4, 0x44, 0xa5, 0x00, + 0x37, 0xfd, 0x44, 0xa8, 0x00, 0x38, 0x00, 0x44, + 0xaa, 0x00, 0x38, 0x2f, 0x44, 0xb4, 0x00, 0x38, + 0x36, 0x44, 0xb5, 0x00, 0x38, 0x40, 0x44, 0xb6, + 0x00, 0x38, 0x5c, 0x44, 0xba, 0x00, 0x38, 0x61, + 0x44, 0xbc, 0x00, 0x38, 0xa1, 0x4e, 0xcb, 0x00, + 0x38, 0xad, 0x4a, 0xbc, 0x00, 0x38, 0xfa, 0x36, + 0x1c, 0x00, 0x39, 0x17, 0x44, 0xd9, 0x00, 0x39, + 0x1a, 0x44, 0xdc, 0x00, 0x39, 0x6f, 0x44, 0xeb, + 0x00, 0x39, 0xa4, 0x4e, 0x9a, 0x00, 0x39, 0xb8, + 0x4e, 0x9b, 0x00, 0x3a, 0x5c, 0x4e, 0x9f, 0x00, + 0x3a, 0x6e, 0x45, 0x31, 0x00, 0x3a, 0x73, 0x45, + 0x34, 0x00, 0x3a, 0x85, 0x4e, 0xae, 0x00, 0x3a, + 0xc4, 0x4e, 0xa7, 0x00, 0x3a, 0xcb, 0x4e, 0xa8, + 0x00, 0x3a, 0xd6, 0x45, 0x43, 0x00, 0x3a, 0xd7, + 0x45, 0x5e, 0x00, 0x3a, 0xea, 0x45, 0x4d, 0x00, + 0x3a, 0xf3, 0x3c, 0x40, 0x00, 0x3b, 0x0e, 0x45, + 0x58, 0x00, 0x3b, 0x1a, 0x45, 0x5c, 0x00, 0x3b, + 0x1c, 0x45, 0x5d, 0x00, 0x3b, 0x22, 0x3c, 0x49, + 0x00, 0x3b, 0x6d, 0x45, 0x8c, 0x00, 0x3b, 0x77, + 0x45, 0x85, 0x00, 0x3b, 0x87, 0x45, 0xa2, 0x00, + 0x3b, 0x88, 0x36, 0x8d, 0x00, 0x3b, 0x8d, 0x45, + 0xa4, 0x00, 0x3b, 0xa4, 0x45, 0xaa, 0x00, 0x3b, + 0xb6, 0x42, 0x0e, 0x00, 0x3b, 0xc3, 0x42, 0x0f, + 0x00, 0x3b, 0xcd, 0x45, 0xb8, 0x00, 0x3b, 0xf0, + 0x45, 0xc9, 0x00, 0x3b, 0xf3, 0x4e, 0xb7, 0x00, + 0x3c, 0x0f, 0x42, 0x17, 0x00, 0x3c, 0x26, 0x45, + 0xdf, 0x00, 0x3c, 0xc3, 0x45, 0xfc, 0x00, 0x3c, + 0xd2, 0x46, 0x01, 0x00, 0x3d, 0x11, 0x46, 0x25, + 0x00, 0x3d, 0x1e, 0x46, 0x30, 0x00, 0x3d, 0x31, + 0x4e, 0xbe, 0x00, 0x3d, 0x4e, 0x1d, 0xe7, 0x00, + 0x3d, 0x64, 0x46, 0x4a, 0x00, 0x3d, 0x9a, 0x46, + 0x58, 0x00, 0x3d, 0xc0, 0x46, 0x6a, 0x00, 0x3d, + 0xcc, 0x4a, 0xbd, 0x00, 0x3d, 0xd4, 0x46, 0x6f, + 0x00, 0x3e, 0x05, 0x46, 0x7b, 0x00, 0x3e, 0x3f, + 0x42, 0x48, 0x00, 0x3e, 0x40, 0x4e, 0xca, 0x00, + 0x3e, 0x60, 0x46, 0x8b, 0x00, 0x3e, 0x66, 0x46, + 0x8d, 0x00, 0x3e, 0x68, 0x46, 0x8e, 0x00, 0x3e, + 0x83, 0x46, 0x95, 0x00, 0x3e, 0x8a, 0x3c, 0x43, + 0x00, 0x3e, 0x94, 0x46, 0x9b, 0x00, 0x3e, 0xda, + 0x3c, 0x48, 0x00, 0x3f, 0x57, 0x46, 0xcb, 0x00, + 0x3f, 0x72, 0x42, 0x58, 0x00, 0x3f, 0x75, 0x46, + 0xd9, 0x00, 0x3f, 0x77, 0x46, 0xdb, 0x00, 0x3f, + 0xae, 0x46, 0xed, 0x00, 0x3f, 0xb1, 0x37, 0x54, + 0x00, 0x3f, 0xc9, 0x46, 0xf8, 0x00, 0x3f, 0xd7, + 0x46, 0xfd, 0x00, 0x3f, 0xdc, 0x4a, 0xbe, 0x00, + 0x40, 0x39, 0x47, 0x0f, 0x00, 0x40, 0x58, 0x47, + 0x16, 0x00, 0x40, 0x93, 0x3c, 0x4c, 0x00, 0x41, + 0x03, 0x3c, 0x4f, 0x00, 0x41, 0x05, 0x47, 0x3b, + 0x00, 0x41, 0x48, 0x47, 0x47, 0x00, 0x41, 0x4f, + 0x47, 0x4a, 0x00, 0x41, 0x63, 0x47, 0x4e, 0x00, + 0x41, 0xb4, 0x47, 0x5d, 0x00, 0x41, 0xbf, 0x47, + 0x60, 0x00, 0x41, 0xe6, 0x47, 0x6b, 0x00, 0x41, + 0xee, 0x47, 0x6f, 0x00, 0x41, 0xf3, 0x47, 0x6c, + 0x00, 0x42, 0x07, 0x47, 0x76, 0x00, 0x42, 0x0e, + 0x47, 0x79, 0x00, 0x42, 0x64, 0x37, 0x60, 0x00, + 0x42, 0x93, 0x3c, 0x50, 0x00, 0x42, 0xc6, 0x47, + 0x9f, 0x00, 0x42, 0xd6, 0x47, 0xaa, 0x00, 0x42, + 0xdd, 0x47, 0xae, 0x00, 0x43, 0x02, 0x47, 0xbc, + 0x00, 0x43, 0x2b, 0x47, 0xc9, 0x00, 0x43, 0x43, + 0x47, 0xcb, 0x00, 0x43, 0xee, 0x47, 0xf7, 0x00, + 0x43, 0xf0, 0x47, 0xfa, 0x00, 0x44, 0x08, 0x48, + 0x00, 0x00, 0x44, 0x0c, 0x3c, 0x42, 0x00, 0x44, + 0x17, 0x48, 0x02, 0x00, 0x44, 0x1c, 0x48, 0x03, + 0x00, 0x44, 0x22, 0x48, 0x05, 0x00, 0x44, 0x53, + 0x37, 0x73, 0x00, 0x44, 0x5b, 0x42, 0xa4, 0x00, + 0x44, 0x76, 0x48, 0x1c, 0x00, 0x44, 0x7a, 0x48, + 0x1d, 0x00, 0x44, 0x91, 0x48, 0x23, 0x00, 0x44, + 0xb3, 0x48, 0x3e, 0x00, 0x44, 0xbe, 0x48, 0x3c, + 0x00, 0x44, 0xd4, 0x48, 0x3d, 0x00, 0x45, 0x08, + 0x48, 0x5c, 0x00, 0x45, 0x0d, 0x48, 0x58, 0x00, + 0x45, 0x25, 0x37, 0x7e, 0x00, 0x45, 0x43, 0x48, + 0x6c, 0x00, 0x45, 0x7a, 0x3c, 0x4b, 0x00, 0x45, + 0x9d, 0x42, 0xd4, 0x00, 0x45, 0xb8, 0x48, 0xa0, + 0x00, 0x45, 0xbe, 0x4a, 0xbf, 0x00, 0x45, 0xe5, + 0x48, 0xba, 0x00, 0x45, 0xea, 0x42, 0xd9, 0x00, + 0x46, 0x0f, 0x48, 0xca, 0x00, 0x46, 0x10, 0x4a, + 0xc0, 0x00, 0x46, 0x41, 0x48, 0xd8, 0x00, 0x46, + 0x65, 0x3c, 0x4e, 0x00, 0x46, 0xa1, 0x48, 0xe9, + 0x00, 0x46, 0xae, 0x3c, 0x51, 0x00, 0x46, 0xaf, + 0x48, 0xed, 0x00, 0x47, 0x0c, 0x49, 0x02, 0x00, + 0x47, 0x1f, 0x4e, 0xfb, 0x00, 0x47, 0x64, 0x49, + 0x18, 0x00, 0x47, 0xe6, 0x37, 0x90, 0x00, 0x47, + 0xfd, 0x49, 0x24, 0x00, 0x48, 0x16, 0x49, 0x2e, + 0x00, 0x48, 0x1e, 0x4f, 0x01, 0x00, 0x48, 0x44, + 0x42, 0xf5, 0x00, 0x48, 0x4e, 0x49, 0x3a, 0x00, + 0x48, 0xb5, 0x49, 0x5b, 0x00, 0x49, 0xb0, 0x43, + 0x1f, 0x00, 0x49, 0xe7, 0x49, 0xd2, 0x00, 0x49, + 0xfa, 0x49, 0xd6, 0x00, 0x4a, 0x04, 0x49, 0xdb, + 0x00, 0x4a, 0x29, 0x49, 0xde, 0x00, 0x4a, 0xbc, + 0x49, 0xf6, 0x00, 0x4b, 0x38, 0x35, 0xdf, 0x00, + 0x4b, 0x3b, 0x4a, 0x0e, 0x00, 0x4b, 0x7e, 0x4a, + 0xc1, 0x00, 0x4b, 0xc2, 0x4a, 0x33, 0x00, 0x4b, + 0xca, 0x4a, 0x35, 0x00, 0x4b, 0xd2, 0x4a, 0x37, + 0x00, 0x4b, 0xe8, 0x3c, 0x46, 0x00, 0x4c, 0x17, + 0x43, 0x34, 0x00, 0x4c, 0x20, 0x4a, 0x48, 0x00, + 0x4c, 0x38, 0x4a, 0xc2, 0x00, 0x4c, 0xc4, 0x4a, + 0x84, 0x00, 0x4c, 0xd1, 0x4a, 0x87, 0x00, 0x4c, + 0xe1, 0x4a, 0xc3, 0x00, 0x4d, 0x07, 0x4a, 0x9b, + 0x00, 0x4d, 0x77, 0x4a, 0xab, 0x00, 0x4e, 0x00, + 0x04, 0xb0, 0x00, 0x4e, 0x01, 0x0b, 0xb8, 0x00, + 0x4e, 0x02, 0x43, 0x52, 0x00, 0x4e, 0x03, 0x08, + 0xe3, 0x00, 0x4e, 0x04, 0x37, 0xd8, 0x00, 0x4e, + 0x05, 0x37, 0xd9, 0x00, 0x4e, 0x07, 0x0e, 0xaa, + 0x00, 0x4e, 0x08, 0x09, 0xce, 0x00, 0x4e, 0x09, + 0x08, 0x7e, 0x00, 0x4e, 0x0a, 0x09, 0xcd, 0x00, + 0x4e, 0x0b, 0x05, 0x3c, 0x00, 0x4e, 0x0c, 0x4a, + 0xc4, 0x00, 0x4e, 0x0d, 0x0d, 0xc6, 0x00, 0x4e, + 0x0e, 0x0f, 0x29, 0x00, 0x4e, 0x0f, 0x43, 0x53, + 0x00, 0x4e, 0x10, 0x0f, 0xfb, 0x00, 0x4e, 0x11, + 0x04, 0xd1, 0x00, 0x4e, 0x12, 0x43, 0x54, 0x00, + 0x4e, 0x14, 0x05, 0xcc, 0x00, 0x4e, 0x15, 0x0f, + 0xfc, 0x00, 0x4e, 0x16, 0x0a, 0x48, 0x00, 0x4e, + 0x17, 0x10, 0xd7, 0x00, 0x4e, 0x18, 0x06, 0x70, + 0x00, 0x4e, 0x19, 0x0e, 0x0a, 0x00, 0x4e, 0x1e, + 0x09, 0xcf, 0x00, 0x4e, 0x1f, 0x37, 0xda, 0x00, + 0x4e, 0x21, 0x0f, 0x86, 0x00, 0x4e, 0x23, 0x4a, + 0xc5, 0x00, 0x4e, 0x24, 0x4a, 0xc6, 0x00, 0x4e, + 0x26, 0x0e, 0x12, 0x00, 0x4e, 0x28, 0x20, 0xb3, + 0x00, 0x4e, 0x29, 0x43, 0x55, 0x00, 0x4e, 0x2a, + 0x0f, 0xfd, 0x00, 0x4e, 0x2b, 0x37, 0xdb, 0x00, + 0x4e, 0x2c, 0x37, 0x4d, 0x00, 0x4e, 0x2d, 0x0b, + 0xa4, 0x00, 0x4e, 0x2e, 0x43, 0x56, 0x00, 0x4e, + 0x2f, 0x37, 0xdc, 0x00, 0x4e, 0x30, 0x37, 0xdd, + 0x00, 0x4e, 0x31, 0x0f, 0xfe, 0x00, 0x4e, 0x32, + 0x06, 0xf2, 0x00, 0x4e, 0x35, 0x52, 0x53, 0x00, + 0x4e, 0x36, 0x0f, 0xff, 0x00, 0x4e, 0x37, 0x36, + 0x9d, 0x00, 0x4e, 0x38, 0x06, 0x19, 0x00, 0x4e, + 0x39, 0x0b, 0x6e, 0x00, 0x4e, 0x3b, 0x09, 0x13, + 0x00, 0x4e, 0x3c, 0x10, 0x00, 0x00, 0x4e, 0x3f, + 0x10, 0x01, 0x00, 0x4e, 0x40, 0x37, 0xde, 0x00, + 0x4e, 0x41, 0x37, 0xdf, 0x00, 0x4e, 0x42, 0x10, + 0x02, 0x00, 0x4e, 0x43, 0x0c, 0xeb, 0x00, 0x4e, + 0x44, 0x37, 0xe0, 0x00, 0x4e, 0x45, 0x06, 0x71, + 0x00, 0x4e, 0x47, 0x43, 0x57, 0x00, 0x4e, 0x48, + 0x37, 0x2e, 0x00, 0x4e, 0x4b, 0x0c, 0xed, 0x00, + 0x4e, 0x4d, 0x0c, 0xbb, 0x00, 0x4e, 0x4e, 0x07, + 0x77, 0x00, 0x4e, 0x4f, 0x0e, 0x61, 0x00, 0x4e, + 0x51, 0x43, 0x59, 0x00, 0x4e, 0x55, 0x19, 0x50, + 0x00, 0x4e, 0x56, 0x10, 0x03, 0x00, 0x4e, 0x57, + 0x09, 0xd0, 0x00, 0x4e, 0x58, 0x10, 0x04, 0x00, + 0x4e, 0x59, 0x05, 0x35, 0x00, 0x4e, 0x5a, 0x37, + 0xe1, 0x00, 0x4e, 0x5c, 0x52, 0x54, 0x00, 0x4e, + 0x5d, 0x06, 0xdd, 0x00, 0x4e, 0x5e, 0x07, 0xa4, + 0x00, 0x4e, 0x5f, 0x0e, 0xf5, 0x00, 0x4e, 0x62, + 0x12, 0x33, 0x00, 0x4e, 0x63, 0x52, 0x55, 0x00, + 0x4e, 0x68, 0x52, 0x56, 0x00, 0x4e, 0x69, 0x43, + 0x5c, 0x00, 0x4e, 0x71, 0x0f, 0x5a, 0x00, 0x4e, + 0x73, 0x0c, 0xd5, 0x00, 0x4e, 0x74, 0x52, 0x57, + 0x00, 0x4e, 0x75, 0x52, 0x58, 0x00, 0x4e, 0x79, + 0x4a, 0xc7, 0x00, 0x4e, 0x7e, 0x05, 0xe1, 0x00, + 0x4e, 0x7f, 0x37, 0xe2, 0x00, 0x4e, 0x80, 0x06, + 0x4f, 0x00, 0x4e, 0x82, 0x10, 0x05, 0x00, 0x4e, + 0x85, 0x10, 0x06, 0x00, 0x4e, 0x86, 0x0f, 0x83, + 0x00, 0x4e, 0x88, 0x0f, 0x27, 0x00, 0x4e, 0x89, + 0x0a, 0xea, 0x00, 0x4e, 0x8a, 0x10, 0x08, 0x00, + 0x4e, 0x8b, 0x08, 0xc4, 0x00, 0x4e, 0x8c, 0x0c, + 0xcb, 0x00, 0x4e, 0x8d, 0x37, 0xe3, 0x00, 0x4e, + 0x8e, 0x10, 0x0b, 0x00, 0x4e, 0x91, 0x04, 0xe0, + 0x00, 0x4e, 0x92, 0x07, 0x93, 0x00, 0x4e, 0x94, + 0x07, 0x92, 0x00, 0x4e, 0x95, 0x04, 0xaa, 0x00, + 0x4e, 0x96, 0x37, 0xe4, 0x00, 0x4e, 0x97, 0x52, + 0x59, 0x00, 0x4e, 0x98, 0x0f, 0xf1, 0x00, 0x4e, + 0x99, 0x0f, 0xf0, 0x00, 0x4e, 0x9b, 0x08, 0x23, + 0x00, 0x4e, 0x9c, 0x04, 0x65, 0x00, 0x4e, 0x9d, + 0x43, 0x5d, 0x00, 0x4e, 0x9e, 0x10, 0x0c, 0x00, + 0x4e, 0x9f, 0x10, 0x0d, 0x00, 0x4e, 0xa0, 0x10, + 0x0e, 0x00, 0x4e, 0xa1, 0x0e, 0x62, 0x00, 0x4e, + 0xa2, 0x10, 0x0f, 0x00, 0x4e, 0xa4, 0x07, 0xa6, + 0x00, 0x4e, 0xa5, 0x04, 0xab, 0x00, 0x4e, 0xa6, + 0x0e, 0xa0, 0x00, 0x4e, 0xa8, 0x06, 0x96, 0x00, + 0x4e, 0xab, 0x06, 0x97, 0x00, 0x4e, 0xac, 0x06, + 0x98, 0x00, 0x4e, 0xad, 0x0b, 0xfe, 0x00, 0x4e, + 0xae, 0x0f, 0x84, 0x00, 0x4e, 0xaf, 0x52, 0x5a, + 0x00, 0x4e, 0xb0, 0x10, 0x10, 0x00, 0x4e, 0xb3, + 0x10, 0x11, 0x00, 0x4e, 0xb6, 0x10, 0x12, 0x00, + 0x4e, 0xb9, 0x37, 0xe5, 0x00, 0x4e, 0xba, 0x0a, + 0x13, 0x00, 0x4e, 0xbb, 0x36, 0x20, 0x00, 0x4e, + 0xbc, 0x43, 0x5f, 0x00, 0x4e, 0xc0, 0x09, 0x44, + 0x00, 0x4e, 0xc1, 0x0a, 0x14, 0x00, 0x4e, 0xc2, + 0x10, 0x17, 0x00, 0x4e, 0xc3, 0x43, 0x60, 0x00, + 0x4e, 0xc4, 0x10, 0x15, 0x00, 0x4e, 0xc6, 0x10, + 0x16, 0x00, 0x4e, 0xc7, 0x06, 0x72, 0x00, 0x4e, + 0xc8, 0x43, 0x61, 0x00, 0x4e, 0xca, 0x08, 0x13, + 0x00, 0x4e, 0xcb, 0x05, 0x70, 0x00, 0x4e, 0xcd, + 0x10, 0x14, 0x00, 0x4e, 0xce, 0x10, 0x13, 0x00, + 0x4e, 0xcf, 0x0d, 0xf9, 0x00, 0x4e, 0xd0, 0x37, + 0xe6, 0x00, 0x4e, 0xd4, 0x08, 0x94, 0x00, 0x4e, + 0xd5, 0x08, 0x93, 0x00, 0x4e, 0xd6, 0x0b, 0x1e, + 0x00, 0x4e, 0xd7, 0x10, 0x18, 0x00, 0x4e, 0xd8, + 0x0d, 0xc7, 0x00, 0x4e, 0xd9, 0x0a, 0x8b, 0x00, + 0x4e, 0xda, 0x43, 0x63, 0x00, 0x4e, 0xdb, 0x52, + 0x5b, 0x00, 0x4e, 0xdd, 0x02, 0x90, 0x00, 0x4e, + 0xde, 0x10, 0x19, 0x00, 0x4e, 0xdf, 0x10, 0x1b, + 0x00, 0x4e, 0xe0, 0x37, 0xe7, 0x00, 0x4e, 0xe1, + 0x20, 0xb4, 0x00, 0x4e, 0xe2, 0x52, 0x5c, 0x00, + 0x4e, 0xe3, 0x0b, 0x45, 0x00, 0x4e, 0xe4, 0x0f, + 0xa9, 0x00, 0x4e, 0xe5, 0x04, 0x8e, 0x00, 0x4e, + 0xe8, 0x52, 0x5d, 0x00, 0x4e, 0xeb, 0x43, 0x62, + 0x00, 0x4e, 0xed, 0x10, 0x1a, 0x00, 0x4e, 0xee, + 0x05, 0x3e, 0x00, 0x4e, 0xef, 0x52, 0x5e, 0x00, + 0x4e, 0xf0, 0x06, 0xbc, 0x00, 0x4e, 0xf1, 0x43, + 0x64, 0x00, 0x4e, 0xf2, 0x0b, 0xa5, 0x00, 0x4e, + 0xf3, 0x4a, 0xc8, 0x00, 0x4e, 0xf5, 0x43, 0x65, + 0x00, 0x4e, 0xf6, 0x07, 0x45, 0x00, 0x4e, 0xf7, + 0x10, 0x1c, 0x00, 0x4e, 0xfb, 0x0c, 0xda, 0x00, + 0x4e, 0xfc, 0x20, 0xb5, 0x00, 0x4e, 0xfd, 0x37, + 0xe8, 0x00, 0x4e, 0xfe, 0x52, 0x5f, 0x00, 0x4e, + 0xff, 0x37, 0xe9, 0x00, 0x4f, 0x00, 0x20, 0xb6, + 0x00, 0x4f, 0x01, 0x06, 0x27, 0x00, 0x4f, 0x02, + 0x52, 0x60, 0x00, 0x4f, 0x03, 0x20, 0xb7, 0x00, + 0x4f, 0x08, 0x52, 0x61, 0x00, 0x4f, 0x09, 0x10, + 0x1d, 0x00, 0x4f, 0x0a, 0x04, 0x8f, 0x00, 0x4f, + 0x0b, 0x37, 0xea, 0x00, 0x4f, 0x0c, 0x4a, 0xc9, + 0x00, 0x4f, 0x0d, 0x07, 0x94, 0x00, 0x4f, 0x0e, + 0x06, 0x28, 0x00, 0x4f, 0x0f, 0x0d, 0xec, 0x00, + 0x4f, 0x10, 0x0d, 0x46, 0x00, 0x4f, 0x11, 0x06, + 0x73, 0x00, 0x4f, 0x12, 0x52, 0x62, 0x00, 0x4f, + 0x15, 0x37, 0xeb, 0x00, 0x4f, 0x16, 0x43, 0x66, + 0x00, 0x4f, 0x17, 0x52, 0x63, 0x00, 0x4f, 0x19, + 0x4a, 0xca, 0x00, 0x4f, 0x1a, 0x05, 0x71, 0x00, + 0x4f, 0x1c, 0x10, 0x40, 0x00, 0x4f, 0x1d, 0x0c, + 0x3b, 0x00, 0x4f, 0x2b, 0x4a, 0xcb, 0x00, 0x4f, + 0x2e, 0x4a, 0xcc, 0x00, 0x4f, 0x2f, 0x0d, 0x22, + 0x00, 0x4f, 0x30, 0x10, 0x1f, 0x00, 0x4f, 0x31, + 0x4a, 0xcd, 0x00, 0x4f, 0x33, 0x52, 0x64, 0x00, + 0x4f, 0x34, 0x0d, 0x50, 0x00, 0x4f, 0x35, 0x52, + 0x65, 0x00, 0x4f, 0x36, 0x0f, 0xaa, 0x00, 0x4f, + 0x37, 0x43, 0x68, 0x00, 0x4f, 0x38, 0x09, 0xf3, + 0x00, 0x4f, 0x39, 0x20, 0xb8, 0x00, 0x4f, 0x3a, + 0x08, 0x95, 0x00, 0x4f, 0x3b, 0x37, 0xed, 0x00, + 0x4f, 0x3c, 0x08, 0xc5, 0x00, 0x4f, 0x3d, 0x05, + 0x40, 0x00, 0x4f, 0x3e, 0x43, 0x69, 0x00, 0x4f, + 0x40, 0x52, 0x66, 0x00, 0x4f, 0x42, 0x52, 0x67, + 0x00, 0x4f, 0x43, 0x0b, 0xed, 0x00, 0x4f, 0x46, + 0x0b, 0x60, 0x00, 0x4f, 0x47, 0x10, 0x23, 0x00, + 0x4f, 0x48, 0x41, 0x8b, 0x00, 0x4f, 0x49, 0x37, + 0xee, 0x00, 0x4f, 0x4b, 0x52, 0x68, 0x00, 0x4f, + 0x4c, 0x52, 0x69, 0x00, 0x4f, 0x4d, 0x04, 0x90, + 0x00, 0x4f, 0x4e, 0x0b, 0xff, 0x00, 0x4f, 0x4f, + 0x09, 0x45, 0x00, 0x4f, 0x50, 0x08, 0x24, 0x00, + 0x4f, 0x51, 0x0f, 0x0e, 0x00, 0x4f, 0x52, 0x52, + 0x6a, 0x00, 0x4f, 0x53, 0x0b, 0x2e, 0x00, 0x4f, + 0x54, 0x37, 0xef, 0x00, 0x4f, 0x55, 0x05, 0x3f, + 0x00, 0x4f, 0x56, 0x20, 0xb9, 0x00, 0x4f, 0x57, + 0x10, 0x22, 0x00, 0x4f, 0x58, 0x43, 0x6a, 0x00, + 0x4f, 0x59, 0x0f, 0x28, 0x00, 0x4f, 0x5a, 0x10, + 0x1e, 0x00, 0x4f, 0x5b, 0x10, 0x20, 0x00, 0x4f, + 0x5c, 0x08, 0x5e, 0x00, 0x4f, 0x5d, 0x10, 0x21, + 0x00, 0x4f, 0x5e, 0x11, 0xd3, 0x00, 0x4f, 0x5f, + 0x41, 0x8c, 0x00, 0x4f, 0x60, 0x37, 0xec, 0x00, + 0x4f, 0x63, 0x52, 0x6b, 0x00, 0x4f, 0x64, 0x43, + 0x67, 0x00, 0x4f, 0x69, 0x10, 0x29, 0x00, 0x4f, + 0x6a, 0x41, 0x8d, 0x00, 0x4f, 0x6c, 0x41, 0x8e, + 0x00, 0x4f, 0x6e, 0x52, 0x6c, 0x00, 0x4f, 0x6f, + 0x10, 0x2c, 0x00, 0x4f, 0x70, 0x10, 0x2a, 0x00, + 0x4f, 0x71, 0x52, 0x6d, 0x00, 0x4f, 0x73, 0x05, + 0x42, 0x00, 0x4f, 0x75, 0x0e, 0x0b, 0x00, 0x4f, + 0x76, 0x10, 0x24, 0x00, 0x4f, 0x77, 0x43, 0x6c, + 0x00, 0x4f, 0x78, 0x43, 0x6d, 0x00, 0x4f, 0x79, + 0x52, 0x6e, 0x00, 0x4f, 0x7a, 0x37, 0xf0, 0x00, + 0x4f, 0x7b, 0x10, 0x28, 0x00, 0x4f, 0x7c, 0x07, + 0xa7, 0x00, 0x4f, 0x7d, 0x37, 0xf1, 0x00, 0x4f, + 0x7e, 0x37, 0xf2, 0x00, 0x4f, 0x7f, 0x08, 0x96, + 0x00, 0x4f, 0x81, 0x52, 0x6f, 0x00, 0x4f, 0x82, + 0x43, 0x6e, 0x00, 0x4f, 0x83, 0x05, 0xe2, 0x00, + 0x4f, 0x84, 0x4a, 0xce, 0x00, 0x4f, 0x85, 0x43, + 0x6f, 0x00, 0x4f, 0x86, 0x10, 0x2d, 0x00, 0x4f, + 0x88, 0x10, 0x25, 0x00, 0x4f, 0x89, 0x52, 0x70, + 0x00, 0x4f, 0x8a, 0x20, 0xbb, 0x00, 0x4f, 0x8b, + 0x0f, 0xab, 0x00, 0x4f, 0x8c, 0x52, 0x71, 0x00, + 0x4f, 0x8d, 0x08, 0xc6, 0x00, 0x4f, 0x8e, 0x52, + 0x72, 0x00, 0x4f, 0x8f, 0x10, 0x26, 0x00, 0x4f, + 0x90, 0x52, 0x73, 0x00, 0x4f, 0x91, 0x10, 0x2b, + 0x00, 0x4f, 0x92, 0x20, 0xba, 0x00, 0x4f, 0x93, + 0x52, 0x74, 0x00, 0x4f, 0x94, 0x20, 0xbd, 0x00, + 0x4f, 0x96, 0x10, 0x2e, 0x00, 0x4f, 0x97, 0x37, + 0xf3, 0x00, 0x4f, 0x98, 0x10, 0x27, 0x00, 0x4f, + 0x99, 0x52, 0x75, 0x00, 0x4f, 0x9a, 0x20, 0xbc, + 0x00, 0x4f, 0x9b, 0x06, 0x99, 0x00, 0x4f, 0x9d, + 0x04, 0x91, 0x00, 0x4f, 0x9e, 0x4a, 0xcf, 0x00, + 0x4f, 0x9f, 0x52, 0x76, 0x00, 0x4f, 0xa0, 0x06, + 0x9a, 0x00, 0x4f, 0xa1, 0x05, 0x41, 0x00, 0x4f, + 0xab, 0x11, 0xd4, 0x00, 0x4f, 0xad, 0x0e, 0xa7, + 0x00, 0x4f, 0xae, 0x0d, 0xe0, 0x00, 0x4f, 0xaf, + 0x07, 0xa8, 0x00, 0x4f, 0xb2, 0x43, 0x71, 0x00, + 0x4f, 0xb5, 0x09, 0xf5, 0x00, 0x4f, 0xb6, 0x0f, + 0x7f, 0x00, 0x4f, 0xb7, 0x4a, 0xd0, 0x00, 0x4f, + 0xb9, 0x52, 0x77, 0x00, 0x4f, 0xbb, 0x52, 0x78, + 0x00, 0x4f, 0xbc, 0x52, 0x79, 0x00, 0x4f, 0xbd, + 0x52, 0x7a, 0x00, 0x4f, 0xbe, 0x37, 0xf4, 0x00, + 0x4f, 0xbf, 0x0e, 0x28, 0x00, 0x4f, 0xc0, 0x52, + 0x7b, 0x00, 0x4f, 0xc1, 0x52, 0x7c, 0x00, 0x4f, + 0xc2, 0x07, 0x0e, 0x00, 0x4f, 0xc3, 0x0b, 0x05, + 0x00, 0x4f, 0xc4, 0x05, 0x64, 0x00, 0x4f, 0xc5, + 0x43, 0x72, 0x00, 0x4f, 0xc6, 0x52, 0x7d, 0x00, + 0x4f, 0xc8, 0x52, 0x7e, 0x00, 0x4f, 0xc9, 0x20, + 0xac, 0x00, 0x4f, 0xca, 0x09, 0x5d, 0x00, 0x4f, + 0xcb, 0x43, 0x73, 0x00, 0x4f, 0xcc, 0x52, 0x7f, + 0x00, 0x4f, 0xcd, 0x20, 0xbe, 0x00, 0x4f, 0xce, + 0x10, 0x32, 0x00, 0x4f, 0xcf, 0x37, 0xf5, 0x00, + 0x4f, 0xd0, 0x10, 0x37, 0x00, 0x4f, 0xd1, 0x10, + 0x35, 0x00, 0x4f, 0xd2, 0x43, 0x74, 0x00, 0x4f, + 0xd3, 0x3c, 0x2f, 0x00, 0x4f, 0xd4, 0x10, 0x30, + 0x00, 0x4f, 0xd7, 0x0b, 0x0f, 0x00, 0x4f, 0xd8, + 0x10, 0x33, 0x00, 0x4f, 0xda, 0x10, 0x36, 0x00, + 0x4f, 0xdb, 0x10, 0x34, 0x00, 0x4f, 0xdc, 0x52, + 0x80, 0x00, 0x4f, 0xdd, 0x0e, 0x2d, 0x00, 0x4f, + 0xdf, 0x10, 0x31, 0x00, 0x4f, 0xe0, 0x1d, 0xec, + 0x00, 0x4f, 0xe1, 0x09, 0xf4, 0x00, 0x4f, 0xe2, + 0x52, 0x81, 0x00, 0x4f, 0xe3, 0x0e, 0xa1, 0x00, + 0x4f, 0xe4, 0x10, 0x38, 0x00, 0x4f, 0xe5, 0x10, + 0x39, 0x00, 0x4f, 0xe6, 0x43, 0x70, 0x00, 0x4f, + 0xee, 0x09, 0x2e, 0x00, 0x4f, 0xef, 0x10, 0x46, + 0x00, 0x4f, 0xf0, 0x52, 0x82, 0x00, 0x4f, 0xf1, + 0x35, 0xa3, 0x00, 0x4f, 0xf2, 0x43, 0x76, 0x00, + 0x4f, 0xf3, 0x0d, 0x06, 0x00, 0x4f, 0xf5, 0x0d, + 0xa8, 0x00, 0x4f, 0xf6, 0x10, 0x41, 0x00, 0x4f, + 0xf8, 0x0e, 0x40, 0x00, 0x4f, 0xfa, 0x05, 0x36, + 0x00, 0x4f, 0xfc, 0x52, 0x83, 0x00, 0x4f, 0xfd, + 0x37, 0xf6, 0x00, 0x4f, 0xfe, 0x10, 0x45, 0x00, + 0x4f, 0xff, 0x20, 0xc1, 0x00, 0x50, 0x00, 0x37, + 0xf7, 0x00, 0x50, 0x01, 0x37, 0xf8, 0x00, 0x50, + 0x02, 0x4f, 0x4b, 0x00, 0x50, 0x04, 0x4a, 0xd1, + 0x00, 0x50, 0x05, 0x10, 0x3f, 0x00, 0x50, 0x06, + 0x10, 0x48, 0x00, 0x50, 0x07, 0x52, 0x84, 0x00, + 0x50, 0x09, 0x0a, 0xd4, 0x00, 0x50, 0x0a, 0x52, + 0x85, 0x00, 0x50, 0x0b, 0x07, 0x78, 0x00, 0x50, + 0x0c, 0x4a, 0xd2, 0x00, 0x50, 0x0d, 0x0d, 0x12, + 0x00, 0x50, 0x0e, 0x41, 0x8f, 0x00, 0x50, 0x0f, + 0x16, 0x00, 0x00, 0x50, 0x10, 0x37, 0xf9, 0x00, + 0x50, 0x11, 0x10, 0x47, 0x00, 0x50, 0x12, 0x0c, + 0x57, 0x00, 0x50, 0x13, 0x43, 0x77, 0x00, 0x50, + 0x14, 0x10, 0x3c, 0x00, 0x50, 0x16, 0x07, 0xaa, + 0x00, 0x50, 0x17, 0x52, 0x86, 0x00, 0x50, 0x18, + 0x41, 0x90, 0x00, 0x50, 0x19, 0x07, 0xa9, 0x00, + 0x50, 0x1a, 0x10, 0x3a, 0x00, 0x50, 0x1b, 0x37, + 0xfa, 0x00, 0x50, 0x1c, 0x43, 0x78, 0x00, 0x50, + 0x1d, 0x52, 0x87, 0x00, 0x50, 0x1e, 0x20, 0xc2, + 0x00, 0x50, 0x1f, 0x09, 0x06, 0x00, 0x50, 0x21, + 0x10, 0x42, 0x00, 0x50, 0x22, 0x20, 0xc0, 0x00, + 0x50, 0x23, 0x0e, 0x3f, 0x00, 0x50, 0x24, 0x0b, + 0x8b, 0x00, 0x50, 0x25, 0x10, 0x3e, 0x00, 0x50, + 0x26, 0x07, 0x47, 0x00, 0x50, 0x27, 0x37, 0xfb, + 0x00, 0x50, 0x28, 0x10, 0x3b, 0x00, 0x50, 0x29, + 0x10, 0x43, 0x00, 0x50, 0x2a, 0x10, 0x3d, 0x00, + 0x50, 0x2b, 0x0f, 0x99, 0x00, 0x50, 0x2c, 0x10, + 0x44, 0x00, 0x50, 0x2d, 0x0f, 0xe7, 0x00, 0x50, + 0x2e, 0x37, 0xfc, 0x00, 0x50, 0x30, 0x52, 0x88, + 0x00, 0x50, 0x32, 0x52, 0x89, 0x00, 0x50, 0x33, + 0x52, 0x8a, 0x00, 0x50, 0x35, 0x52, 0x8b, 0x00, + 0x50, 0x36, 0x06, 0xde, 0x00, 0x50, 0x39, 0x07, + 0x46, 0x00, 0x50, 0x3b, 0x38, 0x00, 0x00, 0x50, + 0x40, 0x20, 0xbf, 0x00, 0x50, 0x41, 0x41, 0x91, + 0x00, 0x50, 0x42, 0x20, 0xc5, 0x00, 0x50, 0x43, + 0x10, 0x49, 0x00, 0x50, 0x45, 0x52, 0x8c, 0x00, + 0x50, 0x46, 0x20, 0xc3, 0x00, 0x50, 0x47, 0x10, + 0x4a, 0x00, 0x50, 0x48, 0x10, 0x4e, 0x00, 0x50, + 0x49, 0x04, 0x92, 0x00, 0x50, 0x4a, 0x52, 0x8d, + 0x00, 0x50, 0x4c, 0x4a, 0xd3, 0x00, 0x50, 0x4e, + 0x43, 0x79, 0x00, 0x50, 0x4f, 0x0e, 0x20, 0x00, + 0x50, 0x50, 0x10, 0x4d, 0x00, 0x50, 0x51, 0x52, + 0x8e, 0x00, 0x50, 0x52, 0x52, 0x8f, 0x00, 0x50, + 0x53, 0x43, 0x7a, 0x00, 0x50, 0x55, 0x10, 0x4c, + 0x00, 0x50, 0x56, 0x10, 0x50, 0x00, 0x50, 0x57, + 0x37, 0xfd, 0x00, 0x50, 0x59, 0x52, 0x90, 0x00, + 0x50, 0x5a, 0x10, 0x4f, 0x00, 0x50, 0x5c, 0x0c, + 0x00, 0x00, 0x50, 0x5f, 0x4a, 0xd4, 0x00, 0x50, + 0x60, 0x52, 0x91, 0x00, 0x50, 0x62, 0x4a, 0xd5, + 0x00, 0x50, 0x63, 0x43, 0x7b, 0x00, 0x50, 0x65, + 0x07, 0x48, 0x00, 0x50, 0x66, 0x37, 0xfe, 0x00, + 0x50, 0x67, 0x52, 0x92, 0x00, 0x50, 0x6a, 0x37, + 0xff, 0x00, 0x50, 0x6c, 0x10, 0x51, 0x00, 0x50, + 0x6d, 0x52, 0x93, 0x00, 0x50, 0x70, 0x20, 0xc4, + 0x00, 0x50, 0x71, 0x52, 0x94, 0x00, 0x50, 0x72, + 0x08, 0xf1, 0x00, 0x50, 0x74, 0x0b, 0x06, 0x00, + 0x50, 0x75, 0x0c, 0x01, 0x00, 0x50, 0x76, 0x06, + 0xee, 0x00, 0x50, 0x77, 0x4a, 0xd6, 0x00, 0x50, + 0x78, 0x10, 0x52, 0x00, 0x50, 0x7d, 0x06, 0x50, + 0x00, 0x50, 0x80, 0x10, 0x53, 0x00, 0x50, 0x81, + 0x52, 0x95, 0x00, 0x50, 0x83, 0x52, 0x96, 0x00, + 0x50, 0x84, 0x52, 0x97, 0x00, 0x50, 0x85, 0x10, + 0x55, 0x00, 0x50, 0x86, 0x52, 0x98, 0x00, 0x50, + 0x88, 0x43, 0x7d, 0x00, 0x50, 0x8a, 0x52, 0x99, + 0x00, 0x50, 0x8d, 0x0e, 0x63, 0x00, 0x50, 0x8e, + 0x4a, 0xd7, 0x00, 0x50, 0x8f, 0x38, 0x01, 0x00, + 0x50, 0x90, 0x52, 0x9a, 0x00, 0x50, 0x91, 0x07, + 0x3c, 0x00, 0x50, 0x92, 0x43, 0x7e, 0x00, 0x50, + 0x93, 0x43, 0x7f, 0x00, 0x50, 0x94, 0x20, 0xc6, + 0x00, 0x50, 0x95, 0x43, 0x80, 0x00, 0x50, 0x96, + 0x38, 0x02, 0x00, 0x50, 0x98, 0x08, 0x7f, 0x00, + 0x50, 0x99, 0x0d, 0x8b, 0x00, 0x50, 0x9a, 0x10, + 0x54, 0x00, 0x50, 0x9b, 0x52, 0x9b, 0x00, 0x50, + 0x9c, 0x38, 0x03, 0x00, 0x50, 0x9e, 0x4a, 0xd8, + 0x00, 0x50, 0x9f, 0x52, 0x9c, 0x00, 0x50, 0xa0, + 0x52, 0x9d, 0x00, 0x50, 0xa1, 0x52, 0x9e, 0x00, + 0x50, 0xa2, 0x4a, 0xd9, 0x00, 0x50, 0xa3, 0x43, + 0x7c, 0x00, 0x50, 0xaa, 0x43, 0x81, 0x00, 0x50, + 0xac, 0x08, 0x35, 0x00, 0x50, 0xad, 0x0f, 0x2d, + 0x00, 0x50, 0xaf, 0x52, 0x9f, 0x00, 0x50, 0xb0, + 0x52, 0xa0, 0x00, 0x50, 0xb1, 0x43, 0x83, 0x00, + 0x50, 0xb2, 0x10, 0x57, 0x00, 0x50, 0xb3, 0x10, + 0x5a, 0x00, 0x50, 0xb4, 0x10, 0x56, 0x00, 0x50, + 0xb5, 0x08, 0x34, 0x00, 0x50, 0xb7, 0x09, 0x87, + 0x00, 0x50, 0xb9, 0x52, 0xa1, 0x00, 0x50, 0xba, + 0x43, 0x84, 0x00, 0x50, 0xbb, 0x43, 0x85, 0x00, + 0x50, 0xbd, 0x52, 0xa2, 0x00, 0x50, 0xbe, 0x07, + 0x0f, 0x00, 0x50, 0xc0, 0x52, 0xa3, 0x00, 0x50, + 0xc2, 0x10, 0x5b, 0x00, 0x50, 0xc3, 0x4a, 0xda, + 0x00, 0x50, 0xc4, 0x43, 0x86, 0x00, 0x50, 0xc5, + 0x06, 0xc7, 0x00, 0x50, 0xc7, 0x43, 0x87, 0x00, + 0x50, 0xc9, 0x10, 0x58, 0x00, 0x50, 0xca, 0x10, + 0x59, 0x00, 0x50, 0xcc, 0x38, 0x04, 0x00, 0x50, + 0xcd, 0x0c, 0x87, 0x00, 0x50, 0xce, 0x43, 0x8a, + 0x00, 0x50, 0xcf, 0x0a, 0xfe, 0x00, 0x50, 0xd0, + 0x41, 0x93, 0x00, 0x50, 0xd1, 0x06, 0x9b, 0x00, + 0x50, 0xd3, 0x52, 0xa4, 0x00, 0x50, 0xd4, 0x43, + 0x8c, 0x00, 0x50, 0xd5, 0x0e, 0x7b, 0x00, 0x50, + 0xd6, 0x10, 0x5c, 0x00, 0x50, 0xd8, 0x20, 0xc8, + 0x00, 0x50, 0xd9, 0x3c, 0x30, 0x00, 0x50, 0xda, + 0x0f, 0x85, 0x00, 0x50, 0xdc, 0x52, 0xa5, 0x00, + 0x50, 0xdd, 0x52, 0xa6, 0x00, 0x50, 0xde, 0x10, + 0x5d, 0x00, 0x50, 0xdf, 0x52, 0xa7, 0x00, 0x50, + 0xe1, 0x43, 0x8d, 0x00, 0x50, 0xe2, 0x52, 0xa8, + 0x00, 0x50, 0xe3, 0x10, 0x60, 0x00, 0x50, 0xe4, + 0x52, 0xa9, 0x00, 0x50, 0xe5, 0x10, 0x5e, 0x00, + 0x50, 0xe6, 0x38, 0x05, 0x00, 0x50, 0xe7, 0x0a, + 0xd0, 0x00, 0x50, 0xe8, 0x4a, 0xdb, 0x00, 0x50, + 0xe9, 0x38, 0x06, 0x00, 0x50, 0xed, 0x10, 0x5f, + 0x00, 0x50, 0xee, 0x10, 0x61, 0x00, 0x50, 0xef, + 0x38, 0x07, 0x00, 0x50, 0xf0, 0x3c, 0x31, 0x00, + 0x50, 0xf1, 0x4a, 0xdc, 0x00, 0x50, 0xf2, 0x41, + 0x92, 0x00, 0x50, 0xf3, 0x43, 0x88, 0x00, 0x50, + 0xf4, 0x20, 0xc7, 0x00, 0x50, 0xf5, 0x10, 0x63, + 0x00, 0x50, 0xf6, 0x52, 0xaa, 0x00, 0x50, 0xf9, + 0x10, 0x62, 0x00, 0x50, 0xfa, 0x52, 0xab, 0x00, + 0x50, 0xfb, 0x0e, 0x18, 0x00, 0x50, 0xfe, 0x4a, + 0xdd, 0x00, 0x51, 0x00, 0x06, 0x51, 0x00, 0x51, + 0x01, 0x10, 0x65, 0x00, 0x51, 0x02, 0x10, 0x66, + 0x00, 0x51, 0x03, 0x41, 0x95, 0x00, 0x51, 0x04, + 0x05, 0x2f, 0x00, 0x51, 0x06, 0x41, 0x94, 0x00, + 0x51, 0x07, 0x4a, 0xde, 0x00, 0x51, 0x08, 0x38, + 0x08, 0x00, 0x51, 0x09, 0x10, 0x64, 0x00, 0x51, + 0x0b, 0x38, 0x09, 0x00, 0x51, 0x0c, 0x4a, 0xdf, + 0x00, 0x51, 0x0d, 0x4a, 0xe0, 0x00, 0x51, 0x0e, + 0x4a, 0xe1, 0x00, 0x51, 0x10, 0x38, 0x0a, 0x00, + 0x51, 0x12, 0x09, 0x20, 0x00, 0x51, 0x14, 0x10, + 0x69, 0x00, 0x51, 0x15, 0x10, 0x68, 0x00, 0x51, + 0x16, 0x10, 0x67, 0x00, 0x51, 0x17, 0x43, 0x90, + 0x00, 0x51, 0x18, 0x10, 0x2f, 0x00, 0x51, 0x19, + 0x52, 0xad, 0x00, 0x51, 0x1a, 0x10, 0x6a, 0x00, + 0x51, 0x1b, 0x38, 0x0b, 0x00, 0x51, 0x1c, 0x52, + 0xae, 0x00, 0x51, 0x1d, 0x52, 0xaf, 0x00, 0x51, + 0x1e, 0x38, 0x0c, 0x00, 0x51, 0x1f, 0x09, 0x88, + 0x00, 0x51, 0x21, 0x10, 0x6b, 0x00, 0x51, 0x23, + 0x52, 0xb0, 0x00, 0x51, 0x27, 0x52, 0xb1, 0x00, + 0x51, 0x28, 0x52, 0xb2, 0x00, 0x51, 0x2a, 0x0f, + 0x0f, 0x00, 0x51, 0x2c, 0x52, 0xb3, 0x00, 0x51, + 0x2d, 0x52, 0xb4, 0x00, 0x51, 0x2f, 0x52, 0xb5, + 0x00, 0x51, 0x31, 0x52, 0xb6, 0x00, 0x51, 0x32, + 0x0e, 0xe5, 0x00, 0x51, 0x33, 0x4a, 0xe2, 0x00, + 0x51, 0x34, 0x52, 0xb7, 0x00, 0x51, 0x35, 0x41, + 0x96, 0x00, 0x51, 0x37, 0x10, 0x6d, 0x00, 0x51, + 0x38, 0x4a, 0xe3, 0x00, 0x51, 0x39, 0x52, 0xb8, + 0x00, 0x51, 0x3a, 0x10, 0x6c, 0x00, 0x51, 0x3b, + 0x10, 0x6f, 0x00, 0x51, 0x3c, 0x10, 0x6e, 0x00, + 0x51, 0x3f, 0x10, 0x70, 0x00, 0x51, 0x40, 0x10, + 0x71, 0x00, 0x51, 0x41, 0x04, 0xb8, 0x00, 0x51, + 0x42, 0x52, 0xb9, 0x00, 0x51, 0x43, 0x07, 0x69, + 0x00, 0x51, 0x44, 0x07, 0x11, 0x00, 0x51, 0x45, + 0x09, 0x46, 0x00, 0x51, 0x46, 0x0b, 0xb9, 0x00, + 0x51, 0x47, 0x06, 0x9c, 0x00, 0x51, 0x48, 0x0a, + 0x8c, 0x00, 0x51, 0x49, 0x07, 0xab, 0x00, 0x51, + 0x4a, 0x20, 0xc9, 0x00, 0x51, 0x4b, 0x08, 0x00, + 0x00, 0x51, 0x4c, 0x10, 0x73, 0x00, 0x51, 0x4d, + 0x0e, 0xd4, 0x00, 0x51, 0x4e, 0x0c, 0x40, 0x00, + 0x51, 0x4f, 0x52, 0xba, 0x00, 0x51, 0x50, 0x08, + 0xc7, 0x00, 0x51, 0x52, 0x10, 0x72, 0x00, 0x51, + 0x53, 0x52, 0xbb, 0x00, 0x51, 0x54, 0x1e, 0x86, + 0x00, 0x51, 0x55, 0x41, 0x97, 0x00, 0x51, 0x57, + 0x41, 0x98, 0x00, 0x51, 0x58, 0x52, 0xbc, 0x00, + 0x51, 0x5a, 0x0c, 0x58, 0x00, 0x51, 0x5c, 0x05, + 0xd3, 0x00, 0x51, 0x5f, 0x38, 0x0d, 0x00, 0x51, + 0x60, 0x43, 0x92, 0x00, 0x51, 0x62, 0x10, 0x75, + 0x00, 0x51, 0x64, 0x20, 0xca, 0x00, 0x51, 0x65, + 0x0c, 0xd6, 0x00, 0x51, 0x66, 0x52, 0xbd, 0x00, + 0x51, 0x67, 0x36, 0x8e, 0x00, 0x51, 0x68, 0x0a, + 0xb6, 0x00, 0x51, 0x69, 0x10, 0x77, 0x00, 0x51, + 0x6a, 0x10, 0x78, 0x00, 0x51, 0x6b, 0x0d, 0x40, + 0x00, 0x51, 0x6c, 0x07, 0xac, 0x00, 0x51, 0x6d, + 0x0f, 0xe1, 0x00, 0x51, 0x6e, 0x10, 0x79, 0x00, + 0x51, 0x71, 0x06, 0x9e, 0x00, 0x51, 0x73, 0x43, + 0x94, 0x00, 0x51, 0x74, 0x4a, 0xe4, 0x00, 0x51, + 0x75, 0x0e, 0x0c, 0x00, 0x51, 0x76, 0x0b, 0x16, + 0x00, 0x51, 0x77, 0x06, 0xe9, 0x00, 0x51, 0x78, + 0x0c, 0x2f, 0x00, 0x51, 0x79, 0x37, 0x79, 0x00, + 0x51, 0x7b, 0x47, 0xd9, 0x00, 0x51, 0x7c, 0x07, + 0x49, 0x00, 0x51, 0x7e, 0x52, 0xbe, 0x00, 0x51, + 0x80, 0x10, 0x7a, 0x00, 0x51, 0x82, 0x10, 0x7b, + 0x00, 0x51, 0x83, 0x43, 0x95, 0x00, 0x51, 0x84, + 0x4a, 0xe5, 0x00, 0x51, 0x85, 0x0c, 0xba, 0x00, + 0x51, 0x86, 0x05, 0x01, 0x00, 0x51, 0x89, 0x10, + 0x7e, 0x00, 0x51, 0x8a, 0x08, 0x6d, 0x00, 0x51, + 0x8b, 0x43, 0x96, 0x00, 0x51, 0x8c, 0x10, 0x7d, + 0x00, 0x51, 0x8d, 0x4e, 0x5d, 0x00, 0x51, 0x8e, + 0x52, 0xbf, 0x00, 0x51, 0x8f, 0x10, 0x7f, 0x00, + 0x51, 0x90, 0x18, 0x5b, 0x00, 0x51, 0x91, 0x10, + 0x80, 0x00, 0x51, 0x92, 0x0e, 0x6f, 0x00, 0x51, + 0x93, 0x10, 0x81, 0x00, 0x51, 0x95, 0x1e, 0x88, + 0x00, 0x51, 0x96, 0x10, 0x83, 0x00, 0x51, 0x97, + 0x09, 0xd1, 0x00, 0x51, 0x98, 0x43, 0x98, 0x00, + 0x51, 0x99, 0x08, 0xf8, 0x00, 0x51, 0x9d, 0x20, + 0xcb, 0x00, 0x51, 0xa0, 0x05, 0xe3, 0x00, 0x51, + 0xa1, 0x38, 0x0e, 0x00, 0x51, 0xa2, 0x10, 0x86, + 0x00, 0x51, 0xa3, 0x43, 0x99, 0x00, 0x51, 0xa4, + 0x10, 0x84, 0x00, 0x51, 0xa5, 0x0e, 0xc9, 0x00, + 0x51, 0xa6, 0x10, 0x85, 0x00, 0x51, 0xa8, 0x0d, + 0xcc, 0x00, 0x51, 0xa9, 0x10, 0x87, 0x00, 0x51, + 0xaa, 0x10, 0x88, 0x00, 0x51, 0xab, 0x10, 0x89, + 0x00, 0x51, 0xac, 0x36, 0x82, 0x00, 0x51, 0xad, + 0x43, 0x9a, 0x00, 0x51, 0xb0, 0x10, 0x8d, 0x00, + 0x51, 0xb1, 0x10, 0x8b, 0x00, 0x51, 0xb2, 0x10, + 0x8c, 0x00, 0x51, 0xb3, 0x10, 0x8a, 0x00, 0x51, + 0xb4, 0x08, 0x53, 0x00, 0x51, 0xb5, 0x10, 0x8e, + 0x00, 0x51, 0xb6, 0x0e, 0xf6, 0x00, 0x51, 0xb7, + 0x0f, 0xac, 0x00, 0x51, 0xb8, 0x4a, 0xe6, 0x00, + 0x51, 0xba, 0x4a, 0xe7, 0x00, 0x51, 0xbc, 0x38, + 0x0f, 0x00, 0x51, 0xbd, 0x10, 0x8f, 0x00, 0x51, + 0xbe, 0x20, 0xcc, 0x00, 0x51, 0xbf, 0x52, 0xc0, + 0x00, 0x51, 0xc2, 0x52, 0xc1, 0x00, 0x51, 0xc3, + 0x3c, 0x32, 0x00, 0x51, 0xc4, 0x0a, 0x4c, 0x00, + 0x51, 0xc5, 0x10, 0x90, 0x00, 0x51, 0xc6, 0x09, + 0x64, 0x00, 0x51, 0xc8, 0x4a, 0xe8, 0x00, 0x51, + 0xc9, 0x10, 0x91, 0x00, 0x51, 0xca, 0x41, 0x9a, + 0x00, 0x51, 0xcb, 0x0b, 0xba, 0x00, 0x51, 0xcc, + 0x0f, 0x87, 0x00, 0x51, 0xcd, 0x0c, 0x5a, 0x00, + 0x51, 0xcf, 0x4a, 0xe9, 0x00, 0x51, 0xd1, 0x4a, + 0xea, 0x00, 0x51, 0xd2, 0x52, 0xc2, 0x00, 0x51, + 0xd3, 0x4a, 0xeb, 0x00, 0x51, 0xd4, 0x4a, 0xec, + 0x00, 0x51, 0xd5, 0x52, 0xc3, 0x00, 0x51, 0xd6, + 0x10, 0xda, 0x00, 0x51, 0xd8, 0x4a, 0xed, 0x00, + 0x51, 0xdb, 0x10, 0x92, 0x00, 0x51, 0xdc, 0x20, + 0x5c, 0x00, 0x51, 0xdd, 0x06, 0xbd, 0x00, 0x51, + 0xde, 0x4f, 0x4c, 0x00, 0x51, 0xdf, 0x4a, 0xee, + 0x00, 0x51, 0xe0, 0x10, 0x93, 0x00, 0x51, 0xe1, + 0x0e, 0x8c, 0x00, 0x51, 0xe2, 0x41, 0x9b, 0x00, + 0x51, 0xe5, 0x52, 0xc4, 0x00, 0x51, 0xe6, 0x09, + 0x72, 0x00, 0x51, 0xe7, 0x0b, 0x5c, 0x00, 0x51, + 0xe9, 0x10, 0x95, 0x00, 0x51, 0xea, 0x0c, 0xbc, + 0x00, 0x51, 0xec, 0x20, 0xcd, 0x00, 0x51, 0xed, + 0x10, 0x96, 0x00, 0x51, 0xee, 0x38, 0x11, 0x00, + 0x51, 0xf0, 0x10, 0x97, 0x00, 0x51, 0xf1, 0x05, + 0x8c, 0x00, 0x51, 0xf2, 0x52, 0xc5, 0x00, 0x51, + 0xf3, 0x43, 0x9d, 0x00, 0x51, 0xf4, 0x38, 0x12, + 0x00, 0x51, 0xf5, 0x10, 0x98, 0x00, 0x51, 0xf6, + 0x06, 0x9f, 0x00, 0x51, 0xf7, 0x52, 0xc6, 0x00, + 0x51, 0xf8, 0x0c, 0xa4, 0x00, 0x51, 0xf9, 0x05, + 0x1c, 0x00, 0x51, 0xfa, 0x09, 0x5a, 0x00, 0x51, + 0xfd, 0x0d, 0x35, 0x00, 0x51, 0xfe, 0x10, 0x99, + 0x00, 0x52, 0x00, 0x0c, 0x5b, 0x00, 0x52, 0x01, + 0x38, 0x13, 0x00, 0x52, 0x02, 0x38, 0x14, 0x00, + 0x52, 0x03, 0x0a, 0x15, 0x00, 0x52, 0x04, 0x10, + 0x9a, 0x00, 0x52, 0x05, 0x4a, 0xef, 0x00, 0x52, + 0x06, 0x0d, 0xfc, 0x00, 0x52, 0x07, 0x0a, 0x7e, + 0x00, 0x52, 0x08, 0x05, 0xde, 0x00, 0x52, 0x0a, + 0x05, 0xe5, 0x00, 0x52, 0x0b, 0x10, 0x9b, 0x00, + 0x52, 0x0e, 0x10, 0x9d, 0x00, 0x52, 0x11, 0x07, + 0x10, 0x00, 0x52, 0x12, 0x43, 0x9e, 0x00, 0x52, + 0x13, 0x38, 0x15, 0x00, 0x52, 0x14, 0x10, 0x9c, + 0x00, 0x52, 0x15, 0x20, 0xce, 0x00, 0x52, 0x16, + 0x43, 0x9f, 0x00, 0x52, 0x17, 0x0f, 0xbb, 0x00, + 0x52, 0x18, 0x52, 0xc7, 0x00, 0x52, 0x1d, 0x09, + 0x73, 0x00, 0x52, 0x22, 0x52, 0xc8, 0x00, 0x52, + 0x24, 0x0d, 0x51, 0x00, 0x52, 0x25, 0x0e, 0x1c, + 0x00, 0x52, 0x26, 0x4a, 0xf0, 0x00, 0x52, 0x27, + 0x10, 0x9e, 0x00, 0x52, 0x28, 0x4a, 0xf1, 0x00, + 0x52, 0x29, 0x0f, 0x62, 0x00, 0x52, 0x2a, 0x10, + 0x9f, 0x00, 0x52, 0x2b, 0x4a, 0xf2, 0x00, 0x52, + 0x2e, 0x10, 0xa0, 0x00, 0x52, 0x30, 0x0c, 0x78, + 0x00, 0x52, 0x31, 0x4a, 0xf3, 0x00, 0x52, 0x32, + 0x4a, 0xf4, 0x00, 0x52, 0x33, 0x10, 0xa1, 0x00, + 0x52, 0x35, 0x4a, 0xf5, 0x00, 0x52, 0x36, 0x0a, + 0x4d, 0x00, 0x52, 0x37, 0x08, 0x6e, 0x00, 0x52, + 0x38, 0x07, 0x4a, 0x00, 0x52, 0x39, 0x10, 0xa2, + 0x00, 0x52, 0x3a, 0x08, 0x97, 0x00, 0x52, 0x3b, + 0x08, 0x01, 0x00, 0x52, 0x3c, 0x4a, 0xf6, 0x00, + 0x52, 0x43, 0x0c, 0x02, 0x00, 0x52, 0x44, 0x10, + 0xa4, 0x00, 0x52, 0x45, 0x52, 0xc9, 0x00, 0x52, + 0x47, 0x0b, 0x07, 0x00, 0x52, 0x49, 0x38, 0x16, + 0x00, 0x52, 0x4a, 0x08, 0x5f, 0x00, 0x52, 0x4b, + 0x10, 0xa5, 0x00, 0x52, 0x4c, 0x10, 0xa6, 0x00, + 0x52, 0x4d, 0x0a, 0xb2, 0x00, 0x52, 0x4f, 0x10, + 0xa3, 0x00, 0x52, 0x54, 0x10, 0xa8, 0x00, 0x52, + 0x55, 0x43, 0xa1, 0x00, 0x52, 0x56, 0x0e, 0x64, + 0x00, 0x52, 0x57, 0x41, 0x9c, 0x00, 0x52, 0x58, + 0x52, 0xca, 0x00, 0x52, 0x5a, 0x4a, 0xf7, 0x00, + 0x52, 0x5b, 0x07, 0xf6, 0x00, 0x52, 0x5c, 0x43, + 0xa2, 0x00, 0x52, 0x5d, 0x1e, 0x5e, 0x00, 0x52, + 0x5e, 0x10, 0xa7, 0x00, 0x52, 0x5f, 0x52, 0xcb, + 0x00, 0x52, 0x60, 0x4a, 0xf8, 0x00, 0x52, 0x61, + 0x38, 0x17, 0x00, 0x52, 0x63, 0x07, 0x4b, 0x00, + 0x52, 0x64, 0x08, 0x4e, 0x00, 0x52, 0x65, 0x0d, + 0x23, 0x00, 0x52, 0x66, 0x38, 0x18, 0x00, 0x52, + 0x69, 0x10, 0xab, 0x00, 0x52, 0x6a, 0x10, 0xa9, + 0x00, 0x52, 0x6c, 0x43, 0xa3, 0x00, 0x52, 0x6e, + 0x4a, 0xf9, 0x00, 0x52, 0x6f, 0x0d, 0xed, 0x00, + 0x52, 0x70, 0x09, 0xd2, 0x00, 0x52, 0x71, 0x10, + 0xb2, 0x00, 0x52, 0x72, 0x35, 0x74, 0x00, 0x52, + 0x73, 0x10, 0xac, 0x00, 0x52, 0x74, 0x10, 0xaa, + 0x00, 0x52, 0x75, 0x0a, 0xd1, 0x00, 0x52, 0x77, + 0x43, 0xa4, 0x00, 0x52, 0x78, 0x4a, 0xfa, 0x00, + 0x52, 0x79, 0x4a, 0xfb, 0x00, 0x52, 0x7d, 0x10, + 0xae, 0x00, 0x52, 0x7f, 0x10, 0xad, 0x00, 0x52, + 0x80, 0x52, 0xcc, 0x00, 0x52, 0x82, 0x43, 0xa6, + 0x00, 0x52, 0x83, 0x05, 0xa2, 0x00, 0x52, 0x84, + 0x43, 0xa5, 0x00, 0x52, 0x85, 0x52, 0xcd, 0x00, + 0x52, 0x87, 0x07, 0x36, 0x00, 0x52, 0x88, 0x10, + 0xb3, 0x00, 0x52, 0x89, 0x0f, 0x75, 0x00, 0x52, + 0x8a, 0x4a, 0xfc, 0x00, 0x52, 0x8c, 0x4a, 0xfd, + 0x00, 0x52, 0x8d, 0x10, 0xaf, 0x00, 0x52, 0x91, + 0x10, 0xb4, 0x00, 0x52, 0x92, 0x10, 0xb1, 0x00, + 0x52, 0x93, 0x38, 0x19, 0x00, 0x52, 0x94, 0x10, + 0xb0, 0x00, 0x52, 0x95, 0x52, 0xce, 0x00, 0x52, + 0x96, 0x52, 0xcf, 0x00, 0x52, 0x97, 0x52, 0xd0, + 0x00, 0x52, 0x98, 0x43, 0xa8, 0x00, 0x52, 0x9a, + 0x52, 0xd1, 0x00, 0x52, 0x9b, 0x0f, 0x97, 0x00, + 0x52, 0x9c, 0x20, 0xcf, 0x00, 0x52, 0x9f, 0x07, + 0xad, 0x00, 0x52, 0xa0, 0x05, 0x43, 0x00, 0x52, + 0xa3, 0x0f, 0xbc, 0x00, 0x52, 0xa4, 0x43, 0xaa, + 0x00, 0x52, 0xa5, 0x52, 0xd2, 0x00, 0x52, 0xa6, + 0x20, 0xd0, 0x00, 0x52, 0xa7, 0x52, 0xd3, 0x00, + 0x52, 0xa9, 0x09, 0x7f, 0x00, 0x52, 0xaa, 0x0c, + 0x52, 0x00, 0x52, 0xab, 0x07, 0xf7, 0x00, 0x52, + 0xac, 0x10, 0xb7, 0x00, 0x52, 0xad, 0x10, 0xb8, + 0x00, 0x52, 0xaf, 0x21, 0x7d, 0x00, 0x52, 0xb0, + 0x52, 0xd4, 0x00, 0x52, 0xb1, 0x0f, 0xad, 0x00, + 0x52, 0xb4, 0x0f, 0xd1, 0x00, 0x52, 0xb5, 0x10, + 0xba, 0x00, 0x52, 0xb6, 0x52, 0xd5, 0x00, 0x52, + 0xb7, 0x52, 0xd6, 0x00, 0x52, 0xb8, 0x52, 0xd7, + 0x00, 0x52, 0xb9, 0x07, 0xae, 0x00, 0x52, 0xba, + 0x43, 0xab, 0x00, 0x52, 0xbb, 0x43, 0xac, 0x00, + 0x52, 0xbc, 0x10, 0xb9, 0x00, 0x52, 0xbd, 0x52, + 0xd8, 0x00, 0x52, 0xbe, 0x05, 0x8d, 0x00, 0x52, + 0xc0, 0x20, 0xd1, 0x00, 0x52, 0xc1, 0x10, 0xbb, + 0x00, 0x52, 0xc3, 0x0e, 0x84, 0x00, 0x52, 0xc4, + 0x52, 0xd9, 0x00, 0x52, 0xc5, 0x0b, 0xd8, 0x00, + 0x52, 0xc6, 0x52, 0xda, 0x00, 0x52, 0xc7, 0x0f, + 0x10, 0x00, 0x52, 0xc8, 0x38, 0x1a, 0x00, 0x52, + 0xc9, 0x34, 0x49, 0x00, 0x52, 0xca, 0x43, 0xad, + 0x00, 0x52, 0xcc, 0x41, 0x9d, 0x00, 0x52, 0xcd, + 0x10, 0xbc, 0x00, 0x52, 0xcf, 0x52, 0xdb, 0x00, + 0x52, 0xd0, 0x36, 0xe8, 0x00, 0x52, 0xd1, 0x43, + 0xae, 0x00, 0x52, 0xd2, 0x1b, 0xee, 0x00, 0x52, + 0xd4, 0x52, 0xdc, 0x00, 0x52, 0xd5, 0x0c, 0x88, + 0x00, 0x52, 0xd6, 0x41, 0x9e, 0x00, 0x52, 0xd7, + 0x10, 0xbd, 0x00, 0x52, 0xd8, 0x05, 0xe6, 0x00, + 0x52, 0xd9, 0x0e, 0xbf, 0x00, 0x52, 0xdb, 0x20, + 0xd2, 0x00, 0x52, 0xdc, 0x52, 0xdd, 0x00, 0x52, + 0xdd, 0x09, 0x89, 0x00, 0x52, 0xde, 0x10, 0xbe, + 0x00, 0x52, 0xdf, 0x0e, 0x37, 0x00, 0x52, 0xe0, + 0x10, 0xc2, 0x00, 0x52, 0xe1, 0x4a, 0xfe, 0x00, + 0x52, 0xe2, 0x0a, 0x4e, 0x00, 0x52, 0xe3, 0x10, + 0xbf, 0x00, 0x52, 0xe4, 0x06, 0xc8, 0x00, 0x52, + 0xe5, 0x52, 0xde, 0x00, 0x52, 0xe6, 0x10, 0xc0, + 0x00, 0x52, 0xe7, 0x05, 0xe7, 0x00, 0x52, 0xe8, + 0x52, 0xdf, 0x00, 0x52, 0xe9, 0x4a, 0xff, 0x00, + 0x52, 0xea, 0x52, 0xe0, 0x00, 0x52, 0xec, 0x52, + 0xe1, 0x00, 0x52, 0xf0, 0x38, 0x1b, 0x00, 0x52, + 0xf1, 0x4b, 0x00, 0x00, 0x52, 0xf2, 0x07, 0x04, + 0x00, 0x52, 0xf3, 0x10, 0xc3, 0x00, 0x52, 0xf4, + 0x52, 0xe2, 0x00, 0x52, 0xf5, 0x10, 0xc4, 0x00, + 0x52, 0xf6, 0x52, 0xe3, 0x00, 0x52, 0xf7, 0x43, + 0xb0, 0x00, 0x52, 0xf8, 0x10, 0xc5, 0x00, 0x52, + 0xf9, 0x10, 0xc6, 0x00, 0x52, 0xfa, 0x35, 0xef, + 0x00, 0x52, 0xfb, 0x41, 0x9f, 0x00, 0x52, 0xfe, + 0x07, 0xaf, 0x00, 0x52, 0xff, 0x0e, 0xea, 0x00, + 0x53, 0x00, 0x20, 0xd3, 0x00, 0x53, 0x01, 0x0e, + 0xf4, 0x00, 0x53, 0x02, 0x0c, 0xcf, 0x00, 0x53, + 0x03, 0x4b, 0x01, 0x00, 0x53, 0x05, 0x0e, 0x41, + 0x00, 0x53, 0x06, 0x10, 0xc7, 0x00, 0x53, 0x07, + 0x4f, 0x4d, 0x00, 0x53, 0x08, 0x10, 0xc8, 0x00, + 0x53, 0x0a, 0x38, 0x1c, 0x00, 0x53, 0x0b, 0x38, + 0x1d, 0x00, 0x53, 0x0c, 0x52, 0xe4, 0x00, 0x53, + 0x0d, 0x10, 0xca, 0x00, 0x53, 0x0f, 0x10, 0xcc, + 0x00, 0x53, 0x10, 0x10, 0xcb, 0x00, 0x53, 0x11, + 0x4b, 0x02, 0x00, 0x53, 0x13, 0x52, 0xe5, 0x00, + 0x53, 0x15, 0x10, 0xcd, 0x00, 0x53, 0x16, 0x05, + 0x3d, 0x00, 0x53, 0x17, 0x0e, 0x7a, 0x00, 0x53, + 0x18, 0x52, 0xe6, 0x00, 0x53, 0x19, 0x08, 0x6c, + 0x00, 0x53, 0x1a, 0x10, 0xce, 0x00, 0x53, 0x1b, + 0x52, 0xe7, 0x00, 0x53, 0x1c, 0x41, 0xa0, 0x00, + 0x53, 0x1d, 0x0a, 0xdb, 0x00, 0x53, 0x1e, 0x52, + 0xe8, 0x00, 0x53, 0x1f, 0x4b, 0x03, 0x00, 0x53, + 0x20, 0x09, 0x8a, 0x00, 0x53, 0x21, 0x06, 0xa1, + 0x00, 0x53, 0x23, 0x10, 0xcf, 0x00, 0x53, 0x24, + 0x20, 0xd5, 0x00, 0x53, 0x25, 0x52, 0xe9, 0x00, + 0x53, 0x27, 0x52, 0xea, 0x00, 0x53, 0x28, 0x52, + 0xeb, 0x00, 0x53, 0x29, 0x52, 0xec, 0x00, 0x53, + 0x2a, 0x0d, 0x6f, 0x00, 0x53, 0x2b, 0x52, 0xed, + 0x00, 0x53, 0x2c, 0x52, 0xee, 0x00, 0x53, 0x2d, + 0x4b, 0x04, 0x00, 0x53, 0x2f, 0x10, 0xd0, 0x00, + 0x53, 0x30, 0x52, 0xef, 0x00, 0x53, 0x31, 0x10, + 0xd1, 0x00, 0x53, 0x32, 0x4b, 0x05, 0x00, 0x53, + 0x33, 0x10, 0xd2, 0x00, 0x53, 0x35, 0x43, 0xb1, + 0x00, 0x53, 0x38, 0x10, 0xd3, 0x00, 0x53, 0x39, + 0x0d, 0x96, 0x00, 0x53, 0x3a, 0x06, 0xe0, 0x00, + 0x53, 0x3b, 0x04, 0xa9, 0x00, 0x53, 0x3c, 0x52, + 0xf0, 0x00, 0x53, 0x3d, 0x4b, 0x06, 0x00, 0x53, + 0x3e, 0x38, 0x1e, 0x00, 0x53, 0x3f, 0x0c, 0x97, + 0x00, 0x53, 0x40, 0x10, 0xd4, 0x00, 0x53, 0x41, + 0x09, 0x47, 0x00, 0x53, 0x42, 0x43, 0xb2, 0x00, + 0x53, 0x43, 0x0a, 0x8d, 0x00, 0x53, 0x45, 0x10, + 0xd6, 0x00, 0x53, 0x46, 0x10, 0xd5, 0x00, 0x53, + 0x47, 0x09, 0x8b, 0x00, 0x53, 0x48, 0x07, 0x95, + 0x00, 0x53, 0x49, 0x10, 0xd8, 0x00, 0x53, 0x4a, + 0x0d, 0x52, 0x00, 0x53, 0x4b, 0x38, 0x20, 0x00, + 0x53, 0x4c, 0x38, 0x1f, 0x00, 0x53, 0x4d, 0x10, + 0xd9, 0x00, 0x53, 0x51, 0x34, 0x42, 0x00, 0x53, + 0x52, 0x0b, 0x14, 0x00, 0x53, 0x53, 0x0b, 0x4e, + 0x00, 0x53, 0x54, 0x06, 0xa0, 0x00, 0x53, 0x57, + 0x0c, 0xc6, 0x00, 0x53, 0x58, 0x0b, 0x6f, 0x00, + 0x53, 0x59, 0x52, 0xf1, 0x00, 0x53, 0x5a, 0x0d, + 0x24, 0x00, 0x53, 0x5b, 0x52, 0xf2, 0x00, 0x53, + 0x5c, 0x0e, 0x7c, 0x00, 0x53, 0x5e, 0x10, 0xdb, + 0x00, 0x53, 0x60, 0x0a, 0x8e, 0x00, 0x53, 0x61, + 0x38, 0x21, 0x00, 0x53, 0x63, 0x41, 0xa1, 0x00, + 0x53, 0x65, 0x4b, 0x07, 0x00, 0x53, 0x66, 0x07, + 0x0b, 0x00, 0x53, 0x67, 0x43, 0xb5, 0x00, 0x53, + 0x69, 0x10, 0xdc, 0x00, 0x53, 0x6c, 0x38, 0x22, + 0x00, 0x53, 0x6d, 0x4b, 0x08, 0x00, 0x53, 0x6e, + 0x10, 0xdd, 0x00, 0x53, 0x6f, 0x04, 0xce, 0x00, + 0x53, 0x70, 0x04, 0xb9, 0x00, 0x53, 0x71, 0x06, + 0x29, 0x00, 0x53, 0x72, 0x20, 0xd6, 0x00, 0x53, + 0x73, 0x0b, 0x08, 0x00, 0x53, 0x74, 0x06, 0x6b, + 0x00, 0x53, 0x75, 0x0f, 0x5b, 0x00, 0x53, 0x77, + 0x10, 0xe0, 0x00, 0x53, 0x78, 0x05, 0x37, 0x00, + 0x53, 0x79, 0x4b, 0x09, 0x00, 0x53, 0x7a, 0x43, + 0xb6, 0x00, 0x53, 0x7b, 0x10, 0xdf, 0x00, 0x53, + 0x7d, 0x34, 0x35, 0x00, 0x53, 0x7e, 0x4b, 0x0a, + 0x00, 0x53, 0x7f, 0x35, 0x97, 0x00, 0x53, 0x82, + 0x10, 0xe1, 0x00, 0x53, 0x83, 0x52, 0xf4, 0x00, + 0x53, 0x84, 0x0e, 0xfd, 0x00, 0x53, 0x87, 0x52, + 0xf5, 0x00, 0x53, 0x88, 0x52, 0xf6, 0x00, 0x53, + 0x89, 0x37, 0xd0, 0x00, 0x53, 0x8e, 0x52, 0xf7, + 0x00, 0x53, 0x93, 0x20, 0xd7, 0x00, 0x53, 0x94, + 0x4b, 0x0b, 0x00, 0x53, 0x96, 0x10, 0xe2, 0x00, + 0x53, 0x98, 0x0f, 0x9a, 0x00, 0x53, 0x99, 0x4b, + 0x0c, 0x00, 0x53, 0x9a, 0x07, 0xb0, 0x00, 0x53, + 0x9d, 0x41, 0xa2, 0x00, 0x53, 0x9f, 0x07, 0x6a, + 0x00, 0x53, 0xa0, 0x10, 0xe3, 0x00, 0x53, 0xa1, + 0x52, 0xf8, 0x00, 0x53, 0xa4, 0x43, 0xb7, 0x00, + 0x53, 0xa5, 0x10, 0xe5, 0x00, 0x53, 0xa6, 0x10, + 0xe4, 0x00, 0x53, 0xa8, 0x0a, 0x25, 0x00, 0x53, + 0xa9, 0x04, 0xdb, 0x00, 0x53, 0xaa, 0x4b, 0x0d, + 0x00, 0x53, 0xab, 0x38, 0x23, 0x00, 0x53, 0xad, + 0x05, 0x00, 0x00, 0x53, 0xae, 0x10, 0xe6, 0x00, + 0x53, 0xaf, 0x4b, 0x0e, 0x00, 0x53, 0xb0, 0x10, + 0xe7, 0x00, 0x53, 0xb2, 0x20, 0xd8, 0x00, 0x53, + 0xb3, 0x07, 0x6b, 0x00, 0x53, 0xb4, 0x43, 0xb8, + 0x00, 0x53, 0xb5, 0x52, 0xf9, 0x00, 0x53, 0xb6, + 0x10, 0xe8, 0x00, 0x53, 0xb7, 0x43, 0xba, 0x00, + 0x53, 0xb8, 0x52, 0xfa, 0x00, 0x53, 0xba, 0x4b, + 0x0f, 0x00, 0x53, 0xbb, 0x06, 0x88, 0x00, 0x53, + 0xbd, 0x52, 0xfb, 0x00, 0x53, 0xc0, 0x43, 0xbb, + 0x00, 0x53, 0xc1, 0x4b, 0x10, 0x00, 0x53, 0xc2, + 0x08, 0x80, 0x00, 0x53, 0xc3, 0x10, 0xe9, 0x00, + 0x53, 0xc4, 0x4b, 0x11, 0x00, 0x53, 0xc5, 0x4b, + 0x12, 0x00, 0x53, 0xc8, 0x0e, 0xa2, 0x00, 0x53, + 0xc9, 0x08, 0x25, 0x00, 0x53, 0xca, 0x06, 0x74, + 0x00, 0x53, 0xcb, 0x0f, 0x11, 0x00, 0x53, 0xcc, + 0x0a, 0xd2, 0x00, 0x53, 0xcd, 0x0d, 0x53, 0x00, + 0x53, 0xce, 0x09, 0x29, 0x00, 0x53, 0xcf, 0x52, + 0xfc, 0x00, 0x53, 0xd2, 0x52, 0xfd, 0x00, 0x53, + 0xd3, 0x52, 0xfe, 0x00, 0x53, 0xd4, 0x09, 0x51, + 0x00, 0x53, 0xd5, 0x43, 0xbf, 0x00, 0x53, 0xd6, + 0x09, 0x14, 0x00, 0x53, 0xd7, 0x09, 0x21, 0x00, + 0x53, 0xd9, 0x09, 0x80, 0x00, 0x53, 0xda, 0x38, + 0x24, 0x00, 0x53, 0xdb, 0x0d, 0x54, 0x00, 0x53, + 0xdd, 0x20, 0xd9, 0x00, 0x53, 0xde, 0x52, 0xff, + 0x00, 0x53, 0xdf, 0x10, 0xec, 0x00, 0x53, 0xe0, + 0x4b, 0x13, 0x00, 0x53, 0xe1, 0x04, 0xe5, 0x00, + 0x53, 0xe2, 0x0a, 0xd3, 0x00, 0x53, 0xe3, 0x07, + 0xb1, 0x00, 0x53, 0xe4, 0x07, 0x79, 0x00, 0x53, + 0xe5, 0x06, 0xdf, 0x00, 0x53, 0xe6, 0x38, 0x25, + 0x00, 0x53, 0xe7, 0x53, 0x01, 0x00, 0x53, 0xe8, + 0x10, 0xf0, 0x00, 0x53, 0xe9, 0x0b, 0x5f, 0x00, + 0x53, 0xea, 0x0b, 0x5e, 0x00, 0x53, 0xeb, 0x06, + 0xa3, 0x00, 0x53, 0xec, 0x09, 0x8c, 0x00, 0x53, + 0xed, 0x10, 0xf1, 0x00, 0x53, 0xee, 0x10, 0xef, + 0x00, 0x53, 0xef, 0x05, 0x44, 0x00, 0x53, 0xf0, + 0x0b, 0x46, 0x00, 0x53, 0xf1, 0x08, 0xe4, 0x00, + 0x53, 0xf2, 0x08, 0x99, 0x00, 0x53, 0xf3, 0x04, + 0xc8, 0x00, 0x53, 0xf4, 0x43, 0xc1, 0x00, 0x53, + 0xf5, 0x38, 0x26, 0x00, 0x53, 0xf6, 0x05, 0xce, + 0x00, 0x53, 0xf7, 0x07, 0xf8, 0x00, 0x53, 0xf8, + 0x08, 0x98, 0x00, 0x53, 0xfa, 0x10, 0xf2, 0x00, + 0x54, 0x01, 0x10, 0xf3, 0x00, 0x54, 0x02, 0x53, + 0x02, 0x00, 0x54, 0x03, 0x06, 0x63, 0x00, 0x54, + 0x04, 0x05, 0xa4, 0x00, 0x54, 0x08, 0x07, 0xf9, + 0x00, 0x54, 0x09, 0x06, 0x62, 0x00, 0x54, 0x0a, + 0x0b, 0xfb, 0x00, 0x54, 0x0b, 0x04, 0xc7, 0x00, + 0x54, 0x0c, 0x0c, 0x89, 0x00, 0x54, 0x0d, 0x0e, + 0xca, 0x00, 0x54, 0x0e, 0x07, 0xb3, 0x00, 0x54, + 0x0f, 0x0f, 0x63, 0x00, 0x54, 0x10, 0x0c, 0x41, + 0x00, 0x54, 0x11, 0x07, 0xb2, 0x00, 0x54, 0x12, + 0x41, 0xa3, 0x00, 0x54, 0x13, 0x4b, 0x14, 0x00, + 0x54, 0x1a, 0x53, 0x03, 0x00, 0x54, 0x1b, 0x07, + 0x05, 0x00, 0x54, 0x1d, 0x10, 0xfc, 0x00, 0x54, + 0x1e, 0x36, 0x8c, 0x00, 0x54, 0x1f, 0x06, 0xdb, + 0x00, 0x54, 0x20, 0x0e, 0x78, 0x00, 0x54, 0x21, + 0x53, 0x04, 0x00, 0x54, 0x24, 0x43, 0xc2, 0x00, + 0x54, 0x26, 0x0d, 0x71, 0x00, 0x54, 0x27, 0x38, + 0x27, 0x00, 0x54, 0x28, 0x43, 0xc3, 0x00, 0x54, + 0x29, 0x10, 0xfb, 0x00, 0x54, 0x2a, 0x4b, 0x15, + 0x00, 0x54, 0x2b, 0x06, 0x1a, 0x00, 0x54, 0x2c, + 0x10, 0xf6, 0x00, 0x54, 0x2d, 0x10, 0xf7, 0x00, + 0x54, 0x2e, 0x10, 0xf9, 0x00, 0x54, 0x2f, 0x53, + 0x05, 0x00, 0x54, 0x31, 0x4b, 0x16, 0x00, 0x54, + 0x33, 0x35, 0xc0, 0x00, 0x54, 0x34, 0x4b, 0x17, + 0x00, 0x54, 0x35, 0x4b, 0x18, 0x00, 0x54, 0x36, + 0x10, 0xfa, 0x00, 0x54, 0x38, 0x06, 0x75, 0x00, + 0x54, 0x39, 0x0a, 0x27, 0x00, 0x54, 0x3b, 0x0d, + 0xfd, 0x00, 0x54, 0x3c, 0x10, 0xf8, 0x00, 0x54, + 0x3d, 0x10, 0xf4, 0x00, 0x54, 0x3e, 0x07, 0x97, + 0x00, 0x54, 0x3f, 0x35, 0xcf, 0x00, 0x54, 0x40, + 0x10, 0xf5, 0x00, 0x54, 0x42, 0x0f, 0xca, 0x00, + 0x54, 0x43, 0x43, 0xc5, 0x00, 0x54, 0x44, 0x53, + 0x06, 0x00, 0x54, 0x46, 0x0e, 0x42, 0x00, 0x54, + 0x47, 0x53, 0x07, 0x00, 0x54, 0x48, 0x0c, 0x04, + 0x00, 0x54, 0x49, 0x07, 0x96, 0x00, 0x54, 0x4a, + 0x08, 0x02, 0x00, 0x54, 0x4c, 0x4b, 0x19, 0x00, + 0x54, 0x4d, 0x38, 0x28, 0x00, 0x54, 0x4e, 0x10, + 0xfd, 0x00, 0x54, 0x4f, 0x53, 0x08, 0x00, 0x54, + 0x51, 0x0c, 0xb5, 0x00, 0x54, 0x55, 0x37, 0x23, + 0x00, 0x54, 0x5e, 0x53, 0x09, 0x00, 0x54, 0x5f, + 0x11, 0x01, 0x00, 0x54, 0x62, 0x43, 0xc6, 0x00, + 0x54, 0x64, 0x53, 0x0a, 0x00, 0x54, 0x66, 0x38, + 0x29, 0x00, 0x54, 0x67, 0x53, 0x0b, 0x00, 0x54, + 0x68, 0x35, 0xf7, 0x00, 0x54, 0x69, 0x53, 0x0c, + 0x00, 0x54, 0x6a, 0x09, 0x22, 0x00, 0x54, 0x6b, + 0x38, 0x2a, 0x00, 0x54, 0x6c, 0x43, 0xc7, 0x00, + 0x54, 0x6d, 0x53, 0x0d, 0x00, 0x54, 0x6e, 0x53, + 0x0e, 0x00, 0x54, 0x70, 0x11, 0x04, 0x00, 0x54, + 0x71, 0x11, 0x02, 0x00, 0x54, 0x73, 0x0e, 0xaf, + 0x00, 0x54, 0x74, 0x38, 0x2b, 0x00, 0x54, 0x75, + 0x10, 0xff, 0x00, 0x54, 0x76, 0x11, 0x08, 0x00, + 0x54, 0x77, 0x11, 0x03, 0x00, 0x54, 0x7b, 0x11, + 0x06, 0x00, 0x54, 0x7c, 0x07, 0x7a, 0x00, 0x54, + 0x7d, 0x0e, 0xcb, 0x00, 0x54, 0x7f, 0x41, 0xa4, + 0x00, 0x54, 0x80, 0x11, 0x07, 0x00, 0x54, 0x81, + 0x53, 0x0f, 0x00, 0x54, 0x83, 0x53, 0x10, 0x00, + 0x54, 0x84, 0x11, 0x09, 0x00, 0x54, 0x85, 0x53, + 0x11, 0x00, 0x54, 0x86, 0x11, 0x0b, 0x00, 0x54, + 0x88, 0x41, 0xa5, 0x00, 0x54, 0x89, 0x53, 0x12, + 0x00, 0x54, 0x8a, 0x20, 0xdc, 0x00, 0x54, 0x8b, + 0x08, 0x60, 0x00, 0x54, 0x8c, 0x0f, 0xe8, 0x00, + 0x54, 0x8d, 0x38, 0x2c, 0x00, 0x54, 0x8e, 0x11, + 0x00, 0x00, 0x54, 0x8f, 0x10, 0xfe, 0x00, 0x54, + 0x90, 0x11, 0x0a, 0x00, 0x54, 0x91, 0x53, 0x13, + 0x00, 0x54, 0x92, 0x11, 0x05, 0x00, 0x54, 0x95, + 0x43, 0xc8, 0x00, 0x54, 0x96, 0x38, 0x2d, 0x00, + 0x54, 0x9c, 0x20, 0xdb, 0x00, 0x54, 0x9f, 0x53, + 0x14, 0x00, 0x54, 0xa0, 0x43, 0xc9, 0x00, 0x54, + 0xa1, 0x38, 0x2e, 0x00, 0x54, 0xa2, 0x11, 0x0d, + 0x00, 0x54, 0xa4, 0x11, 0x16, 0x00, 0x54, 0xa5, + 0x11, 0x0f, 0x00, 0x54, 0xa6, 0x43, 0xca, 0x00, + 0x54, 0xa7, 0x4b, 0x1a, 0x00, 0x54, 0xa8, 0x11, + 0x13, 0x00, 0x54, 0xa9, 0x20, 0xdd, 0x00, 0x54, + 0xaa, 0x4b, 0x1b, 0x00, 0x54, 0xab, 0x11, 0x14, + 0x00, 0x54, 0xac, 0x11, 0x10, 0x00, 0x54, 0xad, + 0x38, 0x2f, 0x00, 0x54, 0xae, 0x43, 0xcb, 0x00, + 0x54, 0xaf, 0x11, 0x31, 0x00, 0x54, 0xb1, 0x4b, + 0x1c, 0x00, 0x54, 0xb2, 0x08, 0x59, 0x00, 0x54, + 0xb3, 0x05, 0x8f, 0x00, 0x54, 0xb7, 0x43, 0xcc, + 0x00, 0x54, 0xb8, 0x11, 0x0e, 0x00, 0x54, 0xb9, + 0x38, 0x30, 0x00, 0x54, 0xba, 0x43, 0xcd, 0x00, + 0x54, 0xbb, 0x4b, 0x1d, 0x00, 0x54, 0xbc, 0x11, + 0x18, 0x00, 0x54, 0xbd, 0x04, 0xba, 0x00, 0x54, + 0xbe, 0x11, 0x17, 0x00, 0x54, 0xbf, 0x38, 0x31, + 0x00, 0x54, 0xc0, 0x04, 0x69, 0x00, 0x54, 0xc1, + 0x0d, 0xbc, 0x00, 0x54, 0xc2, 0x11, 0x15, 0x00, + 0x54, 0xc3, 0x43, 0xce, 0x00, 0x54, 0xc4, 0x11, + 0x11, 0x00, 0x54, 0xc6, 0x38, 0x32, 0x00, 0x54, + 0xc7, 0x11, 0x0c, 0x00, 0x54, 0xc8, 0x11, 0x12, + 0x00, 0x54, 0xc9, 0x08, 0x38, 0x00, 0x54, 0xca, + 0x53, 0x15, 0x00, 0x54, 0xcd, 0x38, 0x33, 0x00, + 0x54, 0xce, 0x4b, 0x1e, 0x00, 0x54, 0xd8, 0x11, + 0x19, 0x00, 0x54, 0xe0, 0x53, 0x16, 0x00, 0x54, + 0xe1, 0x04, 0xbb, 0x00, 0x54, 0xe2, 0x11, 0x22, + 0x00, 0x54, 0xe5, 0x11, 0x1a, 0x00, 0x54, 0xe6, + 0x11, 0x1b, 0x00, 0x54, 0xe8, 0x09, 0x8d, 0x00, + 0x54, 0xe9, 0x0e, 0x97, 0x00, 0x54, 0xea, 0x4b, + 0x1f, 0x00, 0x54, 0xec, 0x43, 0xd0, 0x00, 0x54, + 0xed, 0x11, 0x20, 0x00, 0x54, 0xee, 0x11, 0x1f, + 0x00, 0x54, 0xef, 0x43, 0xd1, 0x00, 0x54, 0xf1, + 0x43, 0xd2, 0x00, 0x54, 0xf2, 0x0c, 0x29, 0x00, + 0x54, 0xf3, 0x43, 0xd3, 0x00, 0x54, 0xf6, 0x53, + 0x17, 0x00, 0x54, 0xfa, 0x11, 0x21, 0x00, 0x54, + 0xfc, 0x4b, 0x20, 0x00, 0x54, 0xfd, 0x11, 0x1e, + 0x00, 0x54, 0xfe, 0x53, 0x18, 0x00, 0x54, 0xff, + 0x20, 0xde, 0x00, 0x55, 0x00, 0x43, 0xd4, 0x00, + 0x55, 0x01, 0x43, 0xd5, 0x00, 0x55, 0x04, 0x04, + 0xd6, 0x00, 0x55, 0x05, 0x4b, 0x21, 0x00, 0x55, + 0x06, 0x08, 0x26, 0x00, 0x55, 0x07, 0x09, 0xf6, + 0x00, 0x55, 0x08, 0x4b, 0x22, 0x00, 0x55, 0x09, + 0x43, 0xd6, 0x00, 0x55, 0x0c, 0x53, 0x19, 0x00, + 0x55, 0x0d, 0x53, 0x1a, 0x00, 0x55, 0x0e, 0x38, + 0x34, 0x00, 0x55, 0x0f, 0x11, 0x1c, 0x00, 0x55, + 0x10, 0x0c, 0x5c, 0x00, 0x55, 0x14, 0x11, 0x1d, + 0x00, 0x55, 0x15, 0x4b, 0x23, 0x00, 0x55, 0x16, + 0x04, 0x66, 0x00, 0x55, 0x27, 0x4b, 0x24, 0x00, + 0x55, 0x2a, 0x4b, 0x25, 0x00, 0x55, 0x2b, 0x38, + 0x35, 0x00, 0x55, 0x2e, 0x11, 0x27, 0x00, 0x55, + 0x2f, 0x0f, 0x0d, 0x00, 0x55, 0x31, 0x09, 0x8f, + 0x00, 0x55, 0x32, 0x53, 0x1b, 0x00, 0x55, 0x33, + 0x11, 0x2d, 0x00, 0x55, 0x35, 0x38, 0x36, 0x00, + 0x55, 0x36, 0x4b, 0x26, 0x00, 0x55, 0x38, 0x11, + 0x2c, 0x00, 0x55, 0x39, 0x11, 0x23, 0x00, 0x55, + 0x3b, 0x53, 0x1c, 0x00, 0x55, 0x3c, 0x43, 0xd7, + 0x00, 0x55, 0x3d, 0x53, 0x1d, 0x00, 0x55, 0x3e, + 0x0b, 0x23, 0x00, 0x55, 0x40, 0x11, 0x24, 0x00, + 0x55, 0x41, 0x43, 0xd8, 0x00, 0x55, 0x44, 0x0b, + 0x4f, 0x00, 0x55, 0x45, 0x11, 0x29, 0x00, 0x55, + 0x46, 0x09, 0x8e, 0x00, 0x55, 0x47, 0x43, 0xda, + 0x00, 0x55, 0x49, 0x53, 0x1e, 0x00, 0x55, 0x4a, + 0x38, 0x37, 0x00, 0x55, 0x4c, 0x11, 0x26, 0x00, + 0x55, 0x4d, 0x53, 0x1f, 0x00, 0x55, 0x4f, 0x0e, + 0xf0, 0x00, 0x55, 0x50, 0x41, 0xa6, 0x00, 0x55, + 0x51, 0x4b, 0x27, 0x00, 0x55, 0x53, 0x07, 0x12, + 0x00, 0x55, 0x56, 0x11, 0x2a, 0x00, 0x55, 0x57, + 0x11, 0x2b, 0x00, 0x55, 0x58, 0x53, 0x20, 0x00, + 0x55, 0x5a, 0x53, 0x21, 0x00, 0x55, 0x5b, 0x53, + 0x22, 0x00, 0x55, 0x5c, 0x11, 0x28, 0x00, 0x55, + 0x5d, 0x11, 0x2e, 0x00, 0x55, 0x5e, 0x1d, 0xd1, + 0x00, 0x55, 0x60, 0x38, 0x38, 0x00, 0x55, 0x61, + 0x4f, 0x54, 0x00, 0x55, 0x63, 0x11, 0x25, 0x00, + 0x55, 0x64, 0x43, 0xdc, 0x00, 0x55, 0x66, 0x4b, + 0x28, 0x00, 0x55, 0x7b, 0x11, 0x34, 0x00, 0x55, + 0x7c, 0x11, 0x39, 0x00, 0x55, 0x7d, 0x43, 0xde, + 0x00, 0x55, 0x7e, 0x11, 0x35, 0x00, 0x55, 0x7f, + 0x53, 0x23, 0x00, 0x55, 0x80, 0x11, 0x30, 0x00, + 0x55, 0x81, 0x41, 0xa7, 0x00, 0x55, 0x82, 0x43, + 0xdf, 0x00, 0x55, 0x83, 0x11, 0x3a, 0x00, 0x55, + 0x84, 0x0a, 0xb3, 0x00, 0x55, 0x86, 0x20, 0xdf, + 0x00, 0x55, 0x87, 0x11, 0x3c, 0x00, 0x55, 0x88, + 0x38, 0x3a, 0x00, 0x55, 0x89, 0x07, 0xb4, 0x00, + 0x55, 0x8a, 0x11, 0x32, 0x00, 0x55, 0x8b, 0x0b, + 0xbb, 0x00, 0x55, 0x8e, 0x38, 0x3b, 0x00, 0x55, + 0x8f, 0x4b, 0x29, 0x00, 0x55, 0x91, 0x43, 0xe0, + 0x00, 0x55, 0x92, 0x4b, 0x2a, 0x00, 0x55, 0x93, + 0x53, 0x24, 0x00, 0x55, 0x94, 0x4b, 0x2b, 0x00, + 0x55, 0x97, 0x53, 0x25, 0x00, 0x55, 0x98, 0x11, + 0x36, 0x00, 0x55, 0x99, 0x11, 0x2f, 0x00, 0x55, + 0x9a, 0x05, 0xe9, 0x00, 0x55, 0x9c, 0x06, 0x2a, + 0x00, 0x55, 0x9d, 0x05, 0xc3, 0x00, 0x55, 0x9e, + 0x11, 0x37, 0x00, 0x55, 0x9f, 0x11, 0x33, 0x00, + 0x55, 0xa3, 0x53, 0x26, 0x00, 0x55, 0xa4, 0x4b, + 0x2c, 0x00, 0x55, 0xa7, 0x07, 0x4c, 0x00, 0x55, + 0xa8, 0x11, 0x3d, 0x00, 0x55, 0xa9, 0x11, 0x3b, + 0x00, 0x55, 0xaa, 0x0a, 0xd5, 0x00, 0x55, 0xab, + 0x06, 0x64, 0x00, 0x55, 0xac, 0x06, 0xa4, 0x00, + 0x55, 0xad, 0x41, 0xa8, 0x00, 0x55, 0xae, 0x11, + 0x38, 0x00, 0x55, 0xb0, 0x06, 0xec, 0x00, 0x55, + 0xb2, 0x4b, 0x2d, 0x00, 0x55, 0xb6, 0x04, 0xe6, + 0x00, 0x55, 0xbf, 0x43, 0xe5, 0x00, 0x55, 0xc1, + 0x53, 0x27, 0x00, 0x55, 0xc3, 0x4b, 0x2e, 0x00, + 0x55, 0xc4, 0x11, 0x41, 0x00, 0x55, 0xc5, 0x11, + 0x3f, 0x00, 0x55, 0xc6, 0x4b, 0x2f, 0x00, 0x55, + 0xc7, 0x11, 0x78, 0x00, 0x55, 0xc9, 0x43, 0xe6, + 0x00, 0x55, 0xcb, 0x53, 0x28, 0x00, 0x55, 0xcc, + 0x43, 0xe7, 0x00, 0x55, 0xce, 0x41, 0xa9, 0x00, + 0x55, 0xd1, 0x43, 0xe8, 0x00, 0x55, 0xd2, 0x43, + 0xe2, 0x00, 0x55, 0xd3, 0x4b, 0x30, 0x00, 0x55, + 0xd4, 0x11, 0x44, 0x00, 0x55, 0xd7, 0x53, 0x29, + 0x00, 0x55, 0xd8, 0x53, 0x2a, 0x00, 0x55, 0xda, + 0x11, 0x3e, 0x00, 0x55, 0xdb, 0x4b, 0x31, 0x00, + 0x55, 0xdc, 0x11, 0x42, 0x00, 0x55, 0xdd, 0x43, + 0xe9, 0x00, 0x55, 0xde, 0x53, 0x2b, 0x00, 0x55, + 0xdf, 0x11, 0x40, 0x00, 0x55, 0xe2, 0x43, 0xeb, + 0x00, 0x55, 0xe3, 0x08, 0x9a, 0x00, 0x55, 0xe4, + 0x11, 0x43, 0x00, 0x55, 0xe9, 0x43, 0xed, 0x00, + 0x55, 0xec, 0x4b, 0x32, 0x00, 0x55, 0xee, 0x4b, + 0x33, 0x00, 0x55, 0xf1, 0x4b, 0x34, 0x00, 0x55, + 0xf6, 0x4b, 0x35, 0x00, 0x55, 0xf7, 0x11, 0x46, + 0x00, 0x55, 0xf8, 0x4b, 0x36, 0x00, 0x55, 0xf9, + 0x11, 0x4b, 0x00, 0x55, 0xfd, 0x11, 0x49, 0x00, + 0x55, 0xfe, 0x11, 0x48, 0x00, 0x55, 0xff, 0x53, + 0x2c, 0x00, 0x56, 0x05, 0x4b, 0x37, 0x00, 0x56, + 0x06, 0x34, 0x36, 0x00, 0x56, 0x07, 0x43, 0xf0, + 0x00, 0x56, 0x08, 0x38, 0x3c, 0x00, 0x56, 0x09, + 0x05, 0x45, 0x00, 0x56, 0x0a, 0x53, 0x2e, 0x00, + 0x56, 0x0d, 0x4b, 0x38, 0x00, 0x56, 0x0e, 0x38, + 0x3d, 0x00, 0x56, 0x0f, 0x38, 0x3e, 0x00, 0x56, + 0x10, 0x43, 0xf1, 0x00, 0x56, 0x11, 0x4b, 0x39, + 0x00, 0x56, 0x12, 0x4b, 0x3a, 0x00, 0x56, 0x14, + 0x11, 0x45, 0x00, 0x56, 0x16, 0x11, 0x47, 0x00, + 0x56, 0x17, 0x09, 0x90, 0x00, 0x56, 0x18, 0x04, + 0xd5, 0x00, 0x56, 0x19, 0x53, 0x2f, 0x00, 0x56, + 0x1b, 0x11, 0x4a, 0x00, 0x56, 0x20, 0x3c, 0x1d, + 0x00, 0x56, 0x28, 0x43, 0xee, 0x00, 0x56, 0x29, + 0x05, 0x5e, 0x00, 0x56, 0x2c, 0x4b, 0x3b, 0x00, + 0x56, 0x2f, 0x11, 0x55, 0x00, 0x56, 0x30, 0x43, + 0xf2, 0x00, 0x56, 0x31, 0x09, 0xe4, 0x00, 0x56, + 0x32, 0x11, 0x51, 0x00, 0x56, 0x33, 0x53, 0x30, + 0x00, 0x56, 0x34, 0x11, 0x4f, 0x00, 0x56, 0x35, + 0x4b, 0x3c, 0x00, 0x56, 0x36, 0x11, 0x50, 0x00, + 0x56, 0x37, 0x38, 0x3f, 0x00, 0x56, 0x38, 0x11, + 0x52, 0x00, 0x56, 0x39, 0x4b, 0x3d, 0x00, 0x56, + 0x3b, 0x41, 0xaa, 0x00, 0x56, 0x3c, 0x53, 0x31, + 0x00, 0x56, 0x3d, 0x43, 0xf4, 0x00, 0x56, 0x3f, + 0x38, 0x40, 0x00, 0x56, 0x40, 0x43, 0xf5, 0x00, + 0x56, 0x41, 0x53, 0x32, 0x00, 0x56, 0x42, 0x04, + 0xdf, 0x00, 0x56, 0x43, 0x53, 0x33, 0x00, 0x56, + 0x44, 0x53, 0x34, 0x00, 0x56, 0x46, 0x53, 0x35, + 0x00, 0x56, 0x47, 0x43, 0xf6, 0x00, 0x56, 0x49, + 0x38, 0x41, 0x00, 0x56, 0x4b, 0x38, 0x42, 0x00, + 0x56, 0x4c, 0x0a, 0xbb, 0x00, 0x56, 0x4d, 0x4b, + 0x3e, 0x00, 0x56, 0x4e, 0x11, 0x4c, 0x00, 0x56, + 0x4f, 0x38, 0x43, 0x00, 0x56, 0x50, 0x11, 0x4d, + 0x00, 0x56, 0x53, 0x1f, 0x1b, 0x00, 0x56, 0x54, + 0x4b, 0x3f, 0x00, 0x56, 0x5b, 0x05, 0xd8, 0x00, + 0x56, 0x5e, 0x43, 0xf7, 0x00, 0x56, 0x60, 0x43, + 0xf8, 0x00, 0x56, 0x61, 0x53, 0x36, 0x00, 0x56, + 0x62, 0x53, 0x37, 0x00, 0x56, 0x63, 0x53, 0x38, + 0x00, 0x56, 0x64, 0x11, 0x54, 0x00, 0x56, 0x66, + 0x38, 0x44, 0x00, 0x56, 0x68, 0x06, 0x2b, 0x00, + 0x56, 0x69, 0x38, 0x45, 0x00, 0x56, 0x6a, 0x11, + 0x57, 0x00, 0x56, 0x6b, 0x11, 0x53, 0x00, 0x56, + 0x6c, 0x11, 0x56, 0x00, 0x56, 0x6d, 0x43, 0xf9, + 0x00, 0x56, 0x6f, 0x38, 0x46, 0x00, 0x56, 0x71, + 0x38, 0x47, 0x00, 0x56, 0x72, 0x38, 0x48, 0x00, + 0x56, 0x74, 0x0d, 0xfe, 0x00, 0x56, 0x75, 0x53, + 0x39, 0x00, 0x56, 0x76, 0x3c, 0x33, 0x00, 0x56, + 0x78, 0x0c, 0xad, 0x00, 0x56, 0x7a, 0x0d, 0x4c, + 0x00, 0x56, 0x80, 0x11, 0x59, 0x00, 0x56, 0x84, + 0x53, 0x3a, 0x00, 0x56, 0x85, 0x4b, 0x40, 0x00, + 0x56, 0x86, 0x11, 0x58, 0x00, 0x56, 0x87, 0x05, + 0xa3, 0x00, 0x56, 0x88, 0x43, 0xfb, 0x00, 0x56, + 0x8a, 0x11, 0x5a, 0x00, 0x56, 0x8b, 0x53, 0x3b, + 0x00, 0x56, 0x8c, 0x43, 0xfc, 0x00, 0x56, 0x8f, + 0x11, 0x5d, 0x00, 0x56, 0x94, 0x11, 0x5c, 0x00, + 0x56, 0x95, 0x38, 0x49, 0x00, 0x56, 0x99, 0x1d, + 0xe6, 0x00, 0x56, 0x9a, 0x38, 0x4a, 0x00, 0x56, + 0x9d, 0x43, 0xfd, 0x00, 0x56, 0x9e, 0x41, 0xab, + 0x00, 0x56, 0x9f, 0x4b, 0x41, 0x00, 0x56, 0xa0, + 0x11, 0x5b, 0x00, 0x56, 0xa2, 0x0c, 0xef, 0x00, + 0x56, 0xa5, 0x11, 0x5e, 0x00, 0x56, 0xa6, 0x4b, + 0x42, 0x00, 0x56, 0xa7, 0x53, 0x3c, 0x00, 0x56, + 0xa8, 0x43, 0xfe, 0x00, 0x56, 0xa9, 0x41, 0xac, + 0x00, 0x56, 0xab, 0x53, 0x3d, 0x00, 0x56, 0xac, + 0x38, 0x4b, 0x00, 0x56, 0xad, 0x38, 0x4c, 0x00, + 0x56, 0xae, 0x11, 0x5f, 0x00, 0x56, 0xb1, 0x38, + 0x4d, 0x00, 0x56, 0xb2, 0x43, 0xff, 0x00, 0x56, + 0xb3, 0x41, 0xad, 0x00, 0x56, 0xb4, 0x11, 0x61, + 0x00, 0x56, 0xb6, 0x11, 0x60, 0x00, 0x56, 0xb7, + 0x4b, 0x43, 0x00, 0x56, 0xbc, 0x11, 0x63, 0x00, + 0x56, 0xbe, 0x53, 0x3e, 0x00, 0x56, 0xc0, 0x11, + 0x66, 0x00, 0x56, 0xc1, 0x11, 0x64, 0x00, 0x56, + 0xc2, 0x11, 0x62, 0x00, 0x56, 0xc3, 0x11, 0x65, + 0x00, 0x56, 0xc5, 0x44, 0x00, 0x00, 0x56, 0xc8, + 0x11, 0x67, 0x00, 0x56, 0xc9, 0x38, 0x4e, 0x00, + 0x56, 0xca, 0x1e, 0x5a, 0x00, 0x56, 0xcb, 0x53, + 0x3f, 0x00, 0x56, 0xcc, 0x4b, 0x44, 0x00, 0x56, + 0xcd, 0x44, 0x01, 0x00, 0x56, 0xce, 0x11, 0x68, + 0x00, 0x56, 0xcf, 0x4b, 0x45, 0x00, 0x56, 0xd0, + 0x53, 0x40, 0x00, 0x56, 0xd1, 0x11, 0x69, 0x00, + 0x56, 0xd3, 0x11, 0x6a, 0x00, 0x56, 0xd7, 0x11, + 0x6b, 0x00, 0x56, 0xd8, 0x10, 0x7c, 0x00, 0x56, + 0xd9, 0x4b, 0x46, 0x00, 0x56, 0xda, 0x09, 0x28, + 0x00, 0x56, 0xdb, 0x08, 0x9b, 0x00, 0x56, 0xdc, + 0x53, 0x41, 0x00, 0x56, 0xdd, 0x38, 0x4f, 0x00, + 0x56, 0xde, 0x05, 0x73, 0x00, 0x56, 0xdf, 0x44, + 0x02, 0x00, 0x56, 0xe0, 0x04, 0xbc, 0x00, 0x56, + 0xe1, 0x4b, 0x47, 0x00, 0x56, 0xe3, 0x0b, 0x82, + 0x00, 0x56, 0xe4, 0x38, 0x50, 0x00, 0x56, 0xe5, + 0x53, 0x42, 0x00, 0x56, 0xe6, 0x53, 0x43, 0x00, + 0x56, 0xe7, 0x53, 0x44, 0x00, 0x56, 0xe8, 0x44, + 0x03, 0x00, 0x56, 0xeb, 0x4b, 0x48, 0x00, 0x56, + 0xed, 0x4b, 0x49, 0x00, 0x56, 0xee, 0x11, 0x6c, + 0x00, 0x56, 0xf0, 0x08, 0x14, 0x00, 0x56, 0xf1, + 0x4b, 0x4a, 0x00, 0x56, 0xf2, 0x04, 0x93, 0x00, + 0x56, 0xf3, 0x0a, 0x24, 0x00, 0x56, 0xf6, 0x44, + 0x04, 0x00, 0x56, 0xf7, 0x44, 0x05, 0x00, 0x56, + 0xf9, 0x11, 0x6d, 0x00, 0x56, 0xfa, 0x07, 0x7b, + 0x00, 0x56, 0xfd, 0x08, 0x03, 0x00, 0x56, 0xff, + 0x11, 0x6f, 0x00, 0x57, 0x00, 0x11, 0x6e, 0x00, + 0x57, 0x01, 0x53, 0x45, 0x00, 0x57, 0x02, 0x53, + 0x46, 0x00, 0x57, 0x03, 0x0e, 0x30, 0x00, 0x57, + 0x04, 0x11, 0x70, 0x00, 0x57, 0x07, 0x4b, 0x4b, + 0x00, 0x57, 0x08, 0x11, 0x72, 0x00, 0x57, 0x09, + 0x11, 0x71, 0x00, 0x57, 0x0a, 0x38, 0x51, 0x00, + 0x57, 0x0b, 0x11, 0x73, 0x00, 0x57, 0x0c, 0x4b, + 0x4c, 0x00, 0x57, 0x0d, 0x11, 0x74, 0x00, 0x57, + 0x0f, 0x07, 0x4d, 0x00, 0x57, 0x11, 0x53, 0x47, + 0x00, 0x57, 0x12, 0x05, 0x02, 0x00, 0x57, 0x13, + 0x11, 0x75, 0x00, 0x57, 0x15, 0x38, 0x52, 0x00, + 0x57, 0x16, 0x11, 0x77, 0x00, 0x57, 0x18, 0x11, + 0x76, 0x00, 0x57, 0x1a, 0x4b, 0x4d, 0x00, 0x57, + 0x1b, 0x4b, 0x4e, 0x00, 0x57, 0x1c, 0x11, 0x79, + 0x00, 0x57, 0x1d, 0x4b, 0x4f, 0x00, 0x57, 0x1f, + 0x0c, 0x54, 0x00, 0x57, 0x20, 0x53, 0x48, 0x00, + 0x57, 0x21, 0x36, 0x80, 0x00, 0x57, 0x22, 0x53, + 0x49, 0x00, 0x57, 0x23, 0x38, 0x53, 0x00, 0x57, + 0x24, 0x53, 0x4a, 0x00, 0x57, 0x25, 0x53, 0x4b, + 0x00, 0x57, 0x26, 0x11, 0x7a, 0x00, 0x57, 0x27, + 0x04, 0x79, 0x00, 0x57, 0x28, 0x08, 0x4f, 0x00, + 0x57, 0x29, 0x44, 0x08, 0x00, 0x57, 0x2a, 0x53, + 0x4c, 0x00, 0x57, 0x2c, 0x4b, 0x50, 0x00, 0x57, + 0x2d, 0x07, 0x13, 0x00, 0x57, 0x2e, 0x4b, 0x51, + 0x00, 0x57, 0x2f, 0x38, 0x54, 0x00, 0x57, 0x30, + 0x0b, 0x8d, 0x00, 0x57, 0x33, 0x38, 0x55, 0x00, + 0x57, 0x34, 0x38, 0x56, 0x00, 0x57, 0x37, 0x11, + 0x7b, 0x00, 0x57, 0x38, 0x11, 0x7c, 0x00, 0x57, + 0x3b, 0x11, 0x7e, 0x00, 0x57, 0x3d, 0x4b, 0x52, + 0x00, 0x57, 0x3e, 0x4b, 0x53, 0x00, 0x57, 0x3f, + 0x53, 0x4d, 0x00, 0x57, 0x40, 0x11, 0x7f, 0x00, + 0x57, 0x42, 0x08, 0x54, 0x00, 0x57, 0x45, 0x44, + 0x0a, 0x00, 0x57, 0x46, 0x44, 0x0b, 0x00, 0x57, + 0x47, 0x06, 0xc9, 0x00, 0x57, 0x4a, 0x0e, 0x65, + 0x00, 0x57, 0x4c, 0x38, 0x57, 0x00, 0x57, 0x4d, + 0x44, 0x0c, 0x00, 0x57, 0x4e, 0x11, 0x7d, 0x00, + 0x57, 0x4f, 0x11, 0x80, 0x00, 0x57, 0x50, 0x08, + 0x31, 0x00, 0x57, 0x51, 0x07, 0xb5, 0x00, 0x57, + 0x52, 0x53, 0x4e, 0x00, 0x57, 0x59, 0x20, 0xe0, + 0x00, 0x57, 0x5f, 0x4b, 0x54, 0x00, 0x57, 0x61, + 0x11, 0x84, 0x00, 0x57, 0x62, 0x53, 0x4f, 0x00, + 0x57, 0x64, 0x08, 0x15, 0x00, 0x57, 0x65, 0x20, + 0xe1, 0x00, 0x57, 0x66, 0x0b, 0x71, 0x00, 0x57, + 0x67, 0x53, 0x50, 0x00, 0x57, 0x68, 0x44, 0x0e, + 0x00, 0x57, 0x69, 0x11, 0x81, 0x00, 0x57, 0x6a, + 0x0b, 0xf6, 0x00, 0x57, 0x6b, 0x4b, 0x55, 0x00, + 0x57, 0x6d, 0x4b, 0x56, 0x00, 0x57, 0x6e, 0x53, + 0x51, 0x00, 0x57, 0x6f, 0x44, 0x0f, 0x00, 0x57, + 0x70, 0x38, 0x58, 0x00, 0x57, 0x71, 0x53, 0x52, + 0x00, 0x57, 0x73, 0x44, 0x10, 0x00, 0x57, 0x74, + 0x44, 0x11, 0x00, 0x57, 0x75, 0x44, 0x12, 0x00, + 0x57, 0x77, 0x41, 0xae, 0x00, 0x57, 0x79, 0x53, + 0x53, 0x00, 0x57, 0x7a, 0x4b, 0x57, 0x00, 0x57, + 0x7b, 0x44, 0x13, 0x00, 0x57, 0x7c, 0x41, 0xaf, + 0x00, 0x57, 0x7e, 0x53, 0x54, 0x00, 0x57, 0x7f, + 0x11, 0x85, 0x00, 0x57, 0x81, 0x53, 0x55, 0x00, + 0x57, 0x82, 0x0a, 0x28, 0x00, 0x57, 0x83, 0x4b, + 0x58, 0x00, 0x57, 0x88, 0x11, 0x83, 0x00, 0x57, + 0x89, 0x11, 0x86, 0x00, 0x57, 0x8b, 0x07, 0x15, + 0x00, 0x57, 0x8c, 0x38, 0x59, 0x00, 0x57, 0x93, + 0x11, 0x87, 0x00, 0x57, 0x94, 0x53, 0x56, 0x00, + 0x57, 0x95, 0x53, 0x5a, 0x00, 0x57, 0x97, 0x4b, + 0x59, 0x00, 0x57, 0x99, 0x53, 0x57, 0x00, 0x57, + 0x9a, 0x44, 0x16, 0x00, 0x57, 0x9c, 0x38, 0x5a, + 0x00, 0x57, 0x9d, 0x44, 0x17, 0x00, 0x57, 0x9e, + 0x44, 0x18, 0x00, 0x57, 0x9f, 0x53, 0x58, 0x00, + 0x57, 0xa0, 0x11, 0x88, 0x00, 0x57, 0xa1, 0x53, + 0x59, 0x00, 0x57, 0xa2, 0x07, 0xb6, 0x00, 0x57, + 0xa3, 0x05, 0x9e, 0x00, 0x57, 0xa4, 0x11, 0x8a, + 0x00, 0x57, 0xa7, 0x53, 0x5b, 0x00, 0x57, 0xa8, + 0x44, 0x19, 0x00, 0x57, 0xa9, 0x53, 0x5c, 0x00, + 0x57, 0xaa, 0x11, 0x8b, 0x00, 0x57, 0xac, 0x20, + 0xe2, 0x00, 0x57, 0xae, 0x4b, 0x5a, 0x00, 0x57, + 0xb0, 0x11, 0x8c, 0x00, 0x57, 0xb3, 0x11, 0x89, + 0x00, 0x57, 0xb8, 0x38, 0x5b, 0x00, 0x57, 0xbd, + 0x53, 0x5d, 0x00, 0x57, 0xc0, 0x11, 0x82, 0x00, + 0x57, 0xc3, 0x11, 0x8d, 0x00, 0x57, 0xc6, 0x11, + 0x8e, 0x00, 0x57, 0xc7, 0x20, 0xe4, 0x00, 0x57, + 0xc8, 0x20, 0xe3, 0x00, 0x57, 0xcb, 0x0e, 0x92, + 0x00, 0x57, 0xcc, 0x44, 0x1c, 0x00, 0x57, 0xce, + 0x36, 0x11, 0x00, 0x57, 0xcf, 0x41, 0xb1, 0x00, + 0x57, 0xd2, 0x11, 0x90, 0x00, 0x57, 0xd3, 0x11, + 0x91, 0x00, 0x57, 0xd4, 0x11, 0x8f, 0x00, 0x57, + 0xd5, 0x4b, 0x5b, 0x00, 0x57, 0xd6, 0x11, 0x93, + 0x00, 0x57, 0xd7, 0x44, 0x1a, 0x00, 0x57, 0xdc, + 0x0c, 0xee, 0x00, 0x57, 0xdd, 0x53, 0x5e, 0x00, + 0x57, 0xde, 0x44, 0x1f, 0x00, 0x57, 0xdf, 0x04, + 0xac, 0x00, 0x57, 0xe0, 0x0d, 0xc8, 0x00, 0x57, + 0xe1, 0x53, 0x63, 0x00, 0x57, 0xe3, 0x11, 0x94, + 0x00, 0x57, 0xe4, 0x41, 0xb2, 0x00, 0x57, 0xe6, + 0x38, 0x5c, 0x00, 0x57, 0xe7, 0x4b, 0x5c, 0x00, + 0x57, 0xe9, 0x53, 0x5f, 0x00, 0x57, 0xed, 0x38, + 0x5d, 0x00, 0x57, 0xf0, 0x44, 0x20, 0x00, 0x57, + 0xf4, 0x09, 0xe5, 0x00, 0x57, 0xf5, 0x38, 0x5e, + 0x00, 0x57, 0xf6, 0x38, 0x5f, 0x00, 0x57, 0xf7, + 0x08, 0xe5, 0x00, 0x57, 0xf8, 0x44, 0x22, 0x00, + 0x57, 0xf9, 0x0d, 0x13, 0x00, 0x57, 0xfa, 0x06, + 0x2c, 0x00, 0x57, 0xfb, 0x44, 0x23, 0x00, 0x57, + 0xfc, 0x08, 0x5b, 0x00, 0x57, 0xfd, 0x44, 0x24, + 0x00, 0x57, 0xfe, 0x53, 0x60, 0x00, 0x57, 0xff, + 0x38, 0x60, 0x00, 0x58, 0x00, 0x0e, 0x87, 0x00, + 0x58, 0x02, 0x0c, 0x8a, 0x00, 0x58, 0x03, 0x53, + 0x61, 0x00, 0x58, 0x04, 0x44, 0x25, 0x00, 0x58, + 0x05, 0x07, 0x4e, 0x00, 0x58, 0x06, 0x0b, 0x2f, + 0x00, 0x58, 0x08, 0x53, 0x62, 0x00, 0x58, 0x09, + 0x38, 0x61, 0x00, 0x58, 0x0a, 0x11, 0x92, 0x00, + 0x58, 0x0b, 0x11, 0x95, 0x00, 0x58, 0x0c, 0x53, + 0x64, 0x00, 0x58, 0x0d, 0x4b, 0x5d, 0x00, 0x58, + 0x15, 0x0b, 0x24, 0x00, 0x58, 0x19, 0x11, 0x96, + 0x00, 0x58, 0x1b, 0x53, 0x65, 0x00, 0x58, 0x1d, + 0x11, 0x97, 0x00, 0x58, 0x1e, 0x44, 0x26, 0x00, + 0x58, 0x1f, 0x53, 0x66, 0x00, 0x58, 0x20, 0x38, + 0x62, 0x00, 0x58, 0x21, 0x11, 0x99, 0x00, 0x58, + 0x24, 0x0c, 0x05, 0x00, 0x58, 0x26, 0x4b, 0x5e, + 0x00, 0x58, 0x27, 0x44, 0x27, 0x00, 0x58, 0x2a, + 0x05, 0xea, 0x00, 0x58, 0x2d, 0x53, 0x67, 0x00, + 0x58, 0x2f, 0x1d, 0x32, 0x00, 0x58, 0x30, 0x05, + 0x03, 0x00, 0x58, 0x31, 0x0e, 0x43, 0x00, 0x58, + 0x32, 0x38, 0x63, 0x00, 0x58, 0x34, 0x09, 0xd4, + 0x00, 0x58, 0x35, 0x0c, 0x42, 0x00, 0x58, 0x39, + 0x44, 0x28, 0x00, 0x58, 0x3a, 0x08, 0x56, 0x00, + 0x58, 0x3d, 0x11, 0x9f, 0x00, 0x58, 0x3f, 0x53, + 0x68, 0x00, 0x58, 0x40, 0x0e, 0x0d, 0x00, 0x58, + 0x41, 0x0f, 0xa5, 0x00, 0x58, 0x49, 0x44, 0x2a, + 0x00, 0x58, 0x4a, 0x05, 0x74, 0x00, 0x58, 0x4b, + 0x11, 0x9b, 0x00, 0x58, 0x4c, 0x44, 0x2b, 0x00, + 0x58, 0x4d, 0x4b, 0x5f, 0x00, 0x58, 0x4f, 0x4b, + 0x60, 0x00, 0x58, 0x50, 0x53, 0x69, 0x00, 0x58, + 0x51, 0x0a, 0xbc, 0x00, 0x58, 0x52, 0x11, 0x9e, + 0x00, 0x58, 0x54, 0x0c, 0x5d, 0x00, 0x58, 0x55, + 0x53, 0x6a, 0x00, 0x58, 0x57, 0x0c, 0x43, 0x00, + 0x58, 0x58, 0x0c, 0x5e, 0x00, 0x58, 0x59, 0x0d, + 0x4d, 0x00, 0x58, 0x5a, 0x0b, 0xe9, 0x00, 0x58, + 0x5e, 0x08, 0x39, 0x00, 0x58, 0x5f, 0x4b, 0x61, + 0x00, 0x58, 0x61, 0x1e, 0x47, 0x00, 0x58, 0x62, + 0x11, 0x9a, 0x00, 0x58, 0x64, 0x41, 0xb3, 0x00, + 0x58, 0x67, 0x44, 0x2c, 0x00, 0x58, 0x68, 0x53, + 0x6b, 0x00, 0x58, 0x69, 0x05, 0x18, 0x00, 0x58, + 0x6b, 0x0c, 0x30, 0x00, 0x58, 0x6d, 0x4b, 0x62, + 0x00, 0x58, 0x70, 0x11, 0x9c, 0x00, 0x58, 0x72, + 0x11, 0x98, 0x00, 0x58, 0x75, 0x0a, 0x16, 0x00, + 0x58, 0x78, 0x53, 0x6c, 0x00, 0x58, 0x79, 0x11, + 0xa0, 0x00, 0x58, 0x7c, 0x38, 0x64, 0x00, 0x58, + 0x7e, 0x09, 0x58, 0x00, 0x58, 0x7f, 0x4b, 0x63, + 0x00, 0x58, 0x80, 0x38, 0x65, 0x00, 0x58, 0x81, + 0x4b, 0x64, 0x00, 0x58, 0x83, 0x06, 0xa5, 0x00, + 0x58, 0x85, 0x11, 0xa1, 0x00, 0x58, 0x87, 0x53, + 0x6d, 0x00, 0x58, 0x88, 0x53, 0x6e, 0x00, 0x58, + 0x89, 0x41, 0xb4, 0x00, 0x58, 0x8a, 0x44, 0x2d, + 0x00, 0x58, 0x8b, 0x44, 0x2e, 0x00, 0x58, 0x8c, + 0x53, 0x6f, 0x00, 0x58, 0x8d, 0x44, 0x2f, 0x00, + 0x58, 0x8f, 0x44, 0x30, 0x00, 0x58, 0x90, 0x44, + 0x31, 0x00, 0x58, 0x93, 0x0e, 0x38, 0x00, 0x58, + 0x94, 0x44, 0x32, 0x00, 0x58, 0x96, 0x53, 0x70, + 0x00, 0x58, 0x97, 0x0a, 0xff, 0x00, 0x58, 0x98, + 0x4b, 0x65, 0x00, 0x58, 0x9c, 0x0b, 0xe2, 0x00, + 0x58, 0x9d, 0x44, 0x33, 0x00, 0x58, 0x9e, 0x20, + 0xe7, 0x00, 0x58, 0x9f, 0x11, 0xa3, 0x00, 0x58, + 0xa0, 0x53, 0x71, 0x00, 0x58, 0xa1, 0x53, 0x72, + 0x00, 0x58, 0xa2, 0x53, 0x73, 0x00, 0x58, 0xa6, + 0x53, 0x74, 0x00, 0x58, 0xa8, 0x34, 0x4b, 0x00, + 0x58, 0xa9, 0x38, 0x66, 0x00, 0x58, 0xaa, 0x44, + 0x34, 0x00, 0x58, 0xab, 0x11, 0xa4, 0x00, 0x58, + 0xae, 0x11, 0xa9, 0x00, 0x58, 0xb1, 0x44, 0x35, + 0x00, 0x58, 0xb2, 0x20, 0xe8, 0x00, 0x58, 0xb3, + 0x0d, 0xff, 0x00, 0x58, 0xb8, 0x11, 0xa8, 0x00, + 0x58, 0xb9, 0x11, 0xa2, 0x00, 0x58, 0xba, 0x11, + 0xa5, 0x00, 0x58, 0xbb, 0x11, 0xa7, 0x00, 0x58, + 0xbc, 0x4b, 0x66, 0x00, 0x58, 0xbe, 0x08, 0x16, + 0x00, 0x58, 0xc1, 0x0e, 0x19, 0x00, 0x58, 0xc2, + 0x53, 0x76, 0x00, 0x58, 0xc3, 0x44, 0x37, 0x00, + 0x58, 0xc4, 0x53, 0x75, 0x00, 0x58, 0xc5, 0x11, + 0xaa, 0x00, 0x58, 0xc7, 0x0b, 0x83, 0x00, 0x58, + 0xc8, 0x53, 0x77, 0x00, 0x58, 0xca, 0x05, 0x75, + 0x00, 0x58, 0xcc, 0x09, 0xd5, 0x00, 0x58, 0xcd, + 0x44, 0x38, 0x00, 0x58, 0xce, 0x38, 0x67, 0x00, + 0x58, 0xd0, 0x38, 0x68, 0x00, 0x58, 0xd1, 0x11, + 0xac, 0x00, 0x58, 0xd2, 0x41, 0xb6, 0x00, 0x58, + 0xd3, 0x11, 0xab, 0x00, 0x58, 0xd4, 0x38, 0x69, + 0x00, 0x58, 0xd5, 0x07, 0xfa, 0x00, 0x58, 0xd6, + 0x53, 0x78, 0x00, 0x58, 0xd7, 0x11, 0xad, 0x00, + 0x58, 0xd8, 0x11, 0xaf, 0x00, 0x58, 0xd9, 0x11, + 0xae, 0x00, 0x58, 0xda, 0x38, 0x6a, 0x00, 0x58, + 0xdc, 0x11, 0xb1, 0x00, 0x58, 0xdd, 0x53, 0x79, + 0x00, 0x58, 0xde, 0x11, 0xa6, 0x00, 0x58, 0xdf, + 0x11, 0xb3, 0x00, 0x58, 0xe0, 0x41, 0xb7, 0x00, + 0x58, 0xe1, 0x53, 0x7a, 0x00, 0x58, 0xe2, 0x44, + 0x39, 0x00, 0x58, 0xe4, 0x11, 0xb2, 0x00, 0x58, + 0xe5, 0x11, 0xb0, 0x00, 0x58, 0xe9, 0x38, 0x6b, + 0x00, 0x58, 0xeb, 0x08, 0x9c, 0x00, 0x58, 0xec, + 0x0a, 0x17, 0x00, 0x58, 0xee, 0x0a, 0xd6, 0x00, + 0x58, 0xef, 0x11, 0xb4, 0x00, 0x58, 0xf0, 0x0a, + 0x60, 0x00, 0x58, 0xf1, 0x04, 0xb1, 0x00, 0x58, + 0xf2, 0x0d, 0x1a, 0x00, 0x58, 0xf3, 0x44, 0x3a, + 0x00, 0x58, 0xf4, 0x44, 0x3b, 0x00, 0x58, 0xf7, + 0x0b, 0xf7, 0x00, 0x58, 0xf9, 0x11, 0xb6, 0x00, + 0x58, 0xfa, 0x11, 0xb5, 0x00, 0x58, 0xfb, 0x11, + 0xb7, 0x00, 0x58, 0xfc, 0x11, 0xb8, 0x00, 0x58, + 0xfd, 0x11, 0xb9, 0x00, 0x59, 0x02, 0x11, 0xba, + 0x00, 0x59, 0x05, 0x44, 0x3c, 0x00, 0x59, 0x06, + 0x44, 0x3d, 0x00, 0x59, 0x09, 0x0e, 0x21, 0x00, + 0x59, 0x0a, 0x11, 0xbb, 0x00, 0x59, 0x0b, 0x20, + 0xe9, 0x00, 0x59, 0x0c, 0x38, 0x6c, 0x00, 0x59, + 0x0d, 0x44, 0x3e, 0x00, 0x59, 0x0f, 0x05, 0x46, + 0x00, 0x59, 0x10, 0x11, 0xbc, 0x00, 0x59, 0x12, + 0x53, 0x7c, 0x00, 0x59, 0x13, 0x53, 0x7d, 0x00, + 0x59, 0x14, 0x44, 0x3f, 0x00, 0x59, 0x15, 0x0f, + 0x26, 0x00, 0x59, 0x16, 0x05, 0x8e, 0x00, 0x59, + 0x18, 0x10, 0xde, 0x00, 0x59, 0x19, 0x09, 0x52, + 0x00, 0x59, 0x1a, 0x0b, 0x1f, 0x00, 0x59, 0x1b, + 0x11, 0xbd, 0x00, 0x59, 0x1c, 0x0e, 0xf7, 0x00, + 0x59, 0x1d, 0x53, 0x7e, 0x00, 0x59, 0x1f, 0x4b, + 0x67, 0x00, 0x59, 0x21, 0x53, 0x7f, 0x00, 0x59, + 0x22, 0x0e, 0xc0, 0x00, 0x59, 0x23, 0x4b, 0x68, + 0x00, 0x59, 0x24, 0x38, 0x6d, 0x00, 0x59, 0x25, + 0x11, 0xbf, 0x00, 0x59, 0x27, 0x0b, 0x47, 0x00, + 0x59, 0x28, 0x53, 0x80, 0x00, 0x59, 0x29, 0x0c, + 0x31, 0x00, 0x59, 0x2a, 0x0b, 0x20, 0x00, 0x59, + 0x2b, 0x0d, 0xc9, 0x00, 0x59, 0x2c, 0x11, 0xc0, + 0x00, 0x59, 0x2d, 0x11, 0xc1, 0x00, 0x59, 0x2e, + 0x05, 0x1d, 0x00, 0x59, 0x2f, 0x38, 0x6e, 0x00, + 0x59, 0x30, 0x53, 0x81, 0x00, 0x59, 0x31, 0x08, + 0xe6, 0x00, 0x59, 0x32, 0x11, 0xc2, 0x00, 0x59, + 0x33, 0x53, 0x82, 0x00, 0x59, 0x35, 0x53, 0x83, + 0x00, 0x59, 0x36, 0x53, 0x84, 0x00, 0x59, 0x37, + 0x04, 0x94, 0x00, 0x59, 0x38, 0x11, 0xc3, 0x00, + 0x59, 0x39, 0x37, 0x25, 0x00, 0x59, 0x3d, 0x44, + 0x42, 0x00, 0x59, 0x3e, 0x11, 0xc4, 0x00, 0x59, + 0x3f, 0x53, 0x85, 0x00, 0x59, 0x43, 0x53, 0x86, + 0x00, 0x59, 0x44, 0x05, 0x04, 0x00, 0x59, 0x46, + 0x44, 0x44, 0x00, 0x59, 0x47, 0x06, 0x2d, 0x00, + 0x59, 0x48, 0x0c, 0xb8, 0x00, 0x59, 0x49, 0x0e, + 0x44, 0x00, 0x59, 0x4e, 0x11, 0xc8, 0x00, 0x59, + 0x4f, 0x0a, 0xd7, 0x00, 0x59, 0x50, 0x11, 0xc7, + 0x00, 0x59, 0x51, 0x07, 0x16, 0x00, 0x59, 0x52, + 0x53, 0x87, 0x00, 0x59, 0x53, 0x20, 0xea, 0x00, + 0x59, 0x54, 0x0e, 0x89, 0x00, 0x59, 0x55, 0x11, + 0xc6, 0x00, 0x59, 0x57, 0x0c, 0x5f, 0x00, 0x59, + 0x58, 0x11, 0xca, 0x00, 0x59, 0x59, 0x4b, 0x69, + 0x00, 0x59, 0x5a, 0x11, 0xc9, 0x00, 0x59, 0x5b, + 0x20, 0xeb, 0x00, 0x59, 0x5d, 0x20, 0xec, 0x00, + 0x59, 0x5e, 0x53, 0x88, 0x00, 0x59, 0x5f, 0x44, + 0x47, 0x00, 0x59, 0x60, 0x11, 0xcc, 0x00, 0x59, + 0x61, 0x38, 0x6f, 0x00, 0x59, 0x62, 0x11, 0xcb, + 0x00, 0x59, 0x63, 0x20, 0xed, 0x00, 0x59, 0x65, + 0x05, 0x1e, 0x00, 0x59, 0x67, 0x11, 0xcd, 0x00, + 0x59, 0x68, 0x09, 0x91, 0x00, 0x59, 0x69, 0x11, + 0xcf, 0x00, 0x59, 0x6a, 0x0b, 0x63, 0x00, 0x59, + 0x6b, 0x53, 0x89, 0x00, 0x59, 0x6c, 0x11, 0xce, + 0x00, 0x59, 0x6d, 0x38, 0x70, 0x00, 0x59, 0x6e, + 0x0e, 0x03, 0x00, 0x59, 0x6f, 0x53, 0x8a, 0x00, + 0x59, 0x72, 0x53, 0x8b, 0x00, 0x59, 0x73, 0x09, + 0x81, 0x00, 0x59, 0x74, 0x0c, 0x55, 0x00, 0x59, + 0x75, 0x44, 0x49, 0x00, 0x59, 0x76, 0x44, 0x4a, + 0x00, 0x59, 0x78, 0x11, 0xd0, 0x00, 0x59, 0x79, + 0x4b, 0x6a, 0x00, 0x59, 0x7b, 0x53, 0x8c, 0x00, + 0x59, 0x7c, 0x44, 0x4b, 0x00, 0x59, 0x7d, 0x07, + 0xb7, 0x00, 0x59, 0x81, 0x11, 0xd1, 0x00, 0x59, + 0x82, 0x0c, 0xd7, 0x00, 0x59, 0x83, 0x0d, 0x72, + 0x00, 0x59, 0x84, 0x0e, 0xdd, 0x00, 0x59, 0x8a, + 0x0c, 0xdb, 0x00, 0x59, 0x8b, 0x41, 0xb9, 0x00, + 0x59, 0x8c, 0x53, 0x8d, 0x00, 0x59, 0x8d, 0x11, + 0xda, 0x00, 0x59, 0x8e, 0x53, 0x8e, 0x00, 0x59, + 0x92, 0x41, 0xba, 0x00, 0x59, 0x93, 0x06, 0x52, + 0x00, 0x59, 0x95, 0x53, 0x8f, 0x00, 0x59, 0x96, + 0x0f, 0x2f, 0x00, 0x59, 0x97, 0x4b, 0x6b, 0x00, + 0x59, 0x99, 0x0e, 0xbb, 0x00, 0x59, 0x9b, 0x12, + 0x39, 0x00, 0x59, 0x9d, 0x11, 0xd2, 0x00, 0x59, + 0x9f, 0x44, 0x4c, 0x00, 0x59, 0xa3, 0x11, 0xd5, + 0x00, 0x59, 0xa4, 0x20, 0xee, 0x00, 0x59, 0xa5, + 0x0b, 0x25, 0x00, 0x59, 0xa7, 0x53, 0x90, 0x00, + 0x59, 0xa8, 0x0e, 0x66, 0x00, 0x59, 0xac, 0x0c, + 0x44, 0x00, 0x59, 0xad, 0x53, 0x91, 0x00, 0x59, + 0xae, 0x44, 0x4d, 0x00, 0x59, 0xaf, 0x4b, 0x6c, + 0x00, 0x59, 0xb0, 0x53, 0x92, 0x00, 0x59, 0xb2, + 0x11, 0xd6, 0x00, 0x59, 0xb3, 0x4b, 0x6d, 0x00, + 0x59, 0xb7, 0x53, 0x93, 0x00, 0x59, 0xb9, 0x0e, + 0x93, 0x00, 0x59, 0xba, 0x20, 0xef, 0x00, 0x59, + 0xbb, 0x08, 0x3a, 0x00, 0x59, 0xbc, 0x44, 0x4e, + 0x00, 0x59, 0xbe, 0x09, 0x92, 0x00, 0x59, 0xc1, + 0x53, 0x94, 0x00, 0x59, 0xc3, 0x41, 0xbb, 0x00, + 0x59, 0xc4, 0x53, 0x95, 0x00, 0x59, 0xc6, 0x11, + 0xd7, 0x00, 0x59, 0xc8, 0x44, 0x4f, 0x00, 0x59, + 0xc9, 0x08, 0x9e, 0x00, 0x59, 0xca, 0x38, 0x71, + 0x00, 0x59, 0xcb, 0x08, 0x9d, 0x00, 0x59, 0xcd, + 0x44, 0x50, 0x00, 0x59, 0xd0, 0x04, 0x7d, 0x00, + 0x59, 0xd1, 0x07, 0x7c, 0x00, 0x59, 0xd2, 0x38, + 0x72, 0x00, 0x59, 0xd3, 0x0a, 0x4f, 0x00, 0x59, + 0xd4, 0x04, 0x95, 0x00, 0x59, 0xd9, 0x11, 0xdb, + 0x00, 0x59, 0xda, 0x11, 0xdc, 0x00, 0x59, 0xdc, + 0x11, 0xd9, 0x00, 0x59, 0xdd, 0x38, 0x73, 0x00, + 0x59, 0xde, 0x44, 0x51, 0x00, 0x59, 0xdf, 0x4b, + 0x6e, 0x00, 0x59, 0xe3, 0x38, 0x74, 0x00, 0x59, + 0xe4, 0x38, 0x75, 0x00, 0x59, 0xe5, 0x04, 0xda, + 0x00, 0x59, 0xe6, 0x05, 0xeb, 0x00, 0x59, 0xe7, + 0x44, 0x52, 0x00, 0x59, 0xe8, 0x11, 0xd8, 0x00, + 0x59, 0xea, 0x0e, 0xd1, 0x00, 0x59, 0xeb, 0x0d, + 0xa3, 0x00, 0x59, 0xec, 0x36, 0xad, 0x00, 0x59, + 0xee, 0x44, 0x53, 0x00, 0x59, 0xef, 0x53, 0x96, + 0x00, 0x59, 0xf1, 0x4b, 0x6f, 0x00, 0x59, 0xf2, + 0x53, 0x97, 0x00, 0x59, 0xf4, 0x53, 0x98, 0x00, + 0x59, 0xf6, 0x04, 0x6c, 0x00, 0x59, 0xf7, 0x53, + 0x99, 0x00, 0x59, 0xf8, 0x4b, 0x70, 0x00, 0x59, + 0xfb, 0x04, 0xbd, 0x00, 0x59, 0xff, 0x08, 0x9f, + 0x00, 0x5a, 0x00, 0x53, 0x9a, 0x00, 0x5a, 0x01, + 0x04, 0x96, 0x00, 0x5a, 0x03, 0x04, 0x67, 0x00, + 0x5a, 0x04, 0x38, 0x76, 0x00, 0x5a, 0x09, 0x11, + 0xe1, 0x00, 0x5a, 0x0c, 0x38, 0x77, 0x00, 0x5a, + 0x0d, 0x44, 0x57, 0x00, 0x5a, 0x0e, 0x53, 0x9b, + 0x00, 0x5a, 0x11, 0x11, 0xdf, 0x00, 0x5a, 0x12, + 0x53, 0x9c, 0x00, 0x5a, 0x13, 0x41, 0xbc, 0x00, + 0x5a, 0x17, 0x44, 0x58, 0x00, 0x5a, 0x18, 0x0e, + 0xc8, 0x00, 0x5a, 0x1a, 0x11, 0xe2, 0x00, 0x5a, + 0x1b, 0x35, 0xc1, 0x00, 0x5a, 0x1c, 0x11, 0xe0, + 0x00, 0x5a, 0x1e, 0x53, 0x9d, 0x00, 0x5a, 0x1f, + 0x11, 0xde, 0x00, 0x5a, 0x20, 0x09, 0xf7, 0x00, + 0x5a, 0x23, 0x38, 0x78, 0x00, 0x5a, 0x24, 0x53, + 0x9e, 0x00, 0x5a, 0x25, 0x11, 0xdd, 0x00, 0x5a, + 0x27, 0x44, 0x59, 0x00, 0x5a, 0x28, 0x53, 0x9f, + 0x00, 0x5a, 0x29, 0x0e, 0x2a, 0x00, 0x5a, 0x2a, + 0x53, 0xa0, 0x00, 0x5a, 0x2d, 0x44, 0x5a, 0x00, + 0x5a, 0x2f, 0x07, 0x98, 0x00, 0x5a, 0x30, 0x53, + 0xa1, 0x00, 0x5a, 0x35, 0x11, 0xe6, 0x00, 0x5a, + 0x36, 0x11, 0xe7, 0x00, 0x5a, 0x3c, 0x09, 0x93, + 0x00, 0x5a, 0x40, 0x11, 0xe3, 0x00, 0x5a, 0x41, + 0x0f, 0xd2, 0x00, 0x5a, 0x44, 0x53, 0xa2, 0x00, + 0x5a, 0x45, 0x53, 0xa3, 0x00, 0x5a, 0x46, 0x0d, + 0x02, 0x00, 0x5a, 0x47, 0x38, 0x79, 0x00, 0x5a, + 0x48, 0x53, 0xa4, 0x00, 0x5a, 0x49, 0x11, 0xe5, + 0x00, 0x5a, 0x4c, 0x53, 0xa5, 0x00, 0x5a, 0x50, + 0x53, 0xa6, 0x00, 0x5a, 0x55, 0x38, 0x7a, 0x00, + 0x5a, 0x5a, 0x08, 0x17, 0x00, 0x5a, 0x5e, 0x53, + 0xa7, 0x00, 0x5a, 0x62, 0x11, 0xe8, 0x00, 0x5a, + 0x63, 0x38, 0x7b, 0x00, 0x5a, 0x65, 0x44, 0x5b, + 0x00, 0x5a, 0x66, 0x0d, 0xca, 0x00, 0x5a, 0x67, + 0x41, 0xbd, 0x00, 0x5a, 0x6a, 0x11, 0xe9, 0x00, + 0x5a, 0x6c, 0x11, 0xe4, 0x00, 0x5a, 0x6d, 0x38, + 0x7c, 0x00, 0x5a, 0x77, 0x41, 0xbe, 0x00, 0x5a, + 0x7a, 0x44, 0x5c, 0x00, 0x5a, 0x7b, 0x53, 0xa8, + 0x00, 0x5a, 0x7e, 0x38, 0x7d, 0x00, 0x5a, 0x7f, + 0x0e, 0xc7, 0x00, 0x5a, 0x84, 0x41, 0xbf, 0x00, + 0x5a, 0x8b, 0x44, 0x5d, 0x00, 0x5a, 0x90, 0x53, + 0xa9, 0x00, 0x5a, 0x92, 0x0d, 0x14, 0x00, 0x5a, + 0x93, 0x53, 0xaa, 0x00, 0x5a, 0x96, 0x53, 0xab, + 0x00, 0x5a, 0x99, 0x53, 0xac, 0x00, 0x5a, 0x9a, + 0x11, 0xea, 0x00, 0x5a, 0x9b, 0x0d, 0xa4, 0x00, + 0x5a, 0x9c, 0x44, 0x5e, 0x00, 0x5a, 0x9e, 0x38, + 0x7e, 0x00, 0x5a, 0x9f, 0x44, 0x5f, 0x00, 0x5a, + 0xa0, 0x44, 0x60, 0x00, 0x5a, 0xa2, 0x44, 0x61, + 0x00, 0x5a, 0xa7, 0x38, 0x7f, 0x00, 0x5a, 0xac, + 0x38, 0x80, 0x00, 0x5a, 0xb1, 0x44, 0x62, 0x00, + 0x5a, 0xb2, 0x4b, 0x71, 0x00, 0x5a, 0xb3, 0x38, + 0x81, 0x00, 0x5a, 0xb5, 0x44, 0x63, 0x00, 0x5a, + 0xb8, 0x4b, 0x72, 0x00, 0x5a, 0xba, 0x44, 0x64, + 0x00, 0x5a, 0xbb, 0x53, 0xad, 0x00, 0x5a, 0xbc, + 0x11, 0xeb, 0x00, 0x5a, 0xbd, 0x11, 0xef, 0x00, + 0x5a, 0xbe, 0x11, 0xec, 0x00, 0x5a, 0xbf, 0x44, + 0x65, 0x00, 0x5a, 0xc1, 0x05, 0x47, 0x00, 0x5a, + 0xc2, 0x11, 0xee, 0x00, 0x5a, 0xc4, 0x41, 0xc0, + 0x00, 0x5a, 0xc6, 0x53, 0xae, 0x00, 0x5a, 0xc8, + 0x53, 0xaf, 0x00, 0x5a, 0xc9, 0x08, 0xe7, 0x00, + 0x5a, 0xcb, 0x11, 0xed, 0x00, 0x5a, 0xcc, 0x07, + 0x4f, 0x00, 0x5a, 0xcf, 0x53, 0xb0, 0x00, 0x5a, + 0xd0, 0x11, 0xfb, 0x00, 0x5a, 0xd6, 0x11, 0xf4, + 0x00, 0x5a, 0xd7, 0x11, 0xf1, 0x00, 0x5a, 0xda, + 0x44, 0x66, 0x00, 0x5a, 0xdc, 0x44, 0x67, 0x00, + 0x5a, 0xe0, 0x38, 0x82, 0x00, 0x5a, 0xe1, 0x0b, + 0xa2, 0x00, 0x5a, 0xe3, 0x11, 0xf0, 0x00, 0x5a, + 0xe5, 0x44, 0x68, 0x00, 0x5a, 0xe6, 0x11, 0xf2, + 0x00, 0x5a, 0xe9, 0x11, 0xf3, 0x00, 0x5a, 0xea, + 0x4b, 0x73, 0x00, 0x5a, 0xee, 0x44, 0x6a, 0x00, + 0x5a, 0xf0, 0x44, 0x69, 0x00, 0x5a, 0xf5, 0x44, + 0x6b, 0x00, 0x5a, 0xf6, 0x4b, 0x74, 0x00, 0x5a, + 0xfa, 0x11, 0xf5, 0x00, 0x5a, 0xfb, 0x11, 0xf6, + 0x00, 0x5a, 0xfd, 0x53, 0xb1, 0x00, 0x5b, 0x00, + 0x38, 0x83, 0x00, 0x5b, 0x01, 0x53, 0xb2, 0x00, + 0x5b, 0x08, 0x44, 0x6c, 0x00, 0x5b, 0x09, 0x06, + 0x2e, 0x00, 0x5b, 0x0b, 0x11, 0xf8, 0x00, 0x5b, + 0x0c, 0x11, 0xf7, 0x00, 0x5b, 0x16, 0x11, 0xf9, + 0x00, 0x5b, 0x17, 0x44, 0x6d, 0x00, 0x5b, 0x19, + 0x38, 0x84, 0x00, 0x5b, 0x1b, 0x4b, 0x75, 0x00, + 0x5b, 0x1d, 0x4b, 0x76, 0x00, 0x5b, 0x21, 0x4b, + 0x77, 0x00, 0x5b, 0x22, 0x09, 0xd6, 0x00, 0x5b, + 0x25, 0x38, 0x85, 0x00, 0x5b, 0x2a, 0x11, 0xfc, + 0x00, 0x5b, 0x2c, 0x0b, 0xf8, 0x00, 0x5b, 0x2d, + 0x38, 0x86, 0x00, 0x5b, 0x30, 0x04, 0xe7, 0x00, + 0x5b, 0x32, 0x11, 0xfa, 0x00, 0x5b, 0x34, 0x44, + 0x6e, 0x00, 0x5b, 0x36, 0x11, 0xfd, 0x00, 0x5b, + 0x38, 0x4b, 0x78, 0x00, 0x5b, 0x3e, 0x11, 0xfe, + 0x00, 0x5b, 0x40, 0x12, 0x01, 0x00, 0x5b, 0x41, + 0x38, 0x87, 0x00, 0x5b, 0x43, 0x11, 0xff, 0x00, + 0x5b, 0x45, 0x12, 0x00, 0x00, 0x5b, 0x4b, 0x53, + 0xb3, 0x00, 0x5b, 0x4c, 0x44, 0x6f, 0x00, 0x5b, + 0x50, 0x08, 0xa0, 0x00, 0x5b, 0x51, 0x12, 0x02, + 0x00, 0x5b, 0x52, 0x44, 0x70, 0x00, 0x5b, 0x54, + 0x07, 0xb8, 0x00, 0x5b, 0x55, 0x12, 0x03, 0x00, + 0x5b, 0x56, 0x20, 0xf0, 0x00, 0x5b, 0x57, 0x08, + 0xc8, 0x00, 0x5b, 0x58, 0x0b, 0x18, 0x00, 0x5b, + 0x5a, 0x12, 0x04, 0x00, 0x5b, 0x5b, 0x12, 0x05, + 0x00, 0x5b, 0x5c, 0x08, 0xa8, 0x00, 0x5b, 0x5d, + 0x07, 0xb9, 0x00, 0x5b, 0x5e, 0x53, 0xb4, 0x00, + 0x5b, 0x5f, 0x0e, 0xde, 0x00, 0x5b, 0x63, 0x06, + 0x42, 0x00, 0x5b, 0x64, 0x07, 0x7d, 0x00, 0x5b, + 0x65, 0x12, 0x06, 0x00, 0x5b, 0x66, 0x05, 0xb6, + 0x00, 0x5b, 0x68, 0x44, 0x71, 0x00, 0x5b, 0x69, + 0x12, 0x07, 0x00, 0x5b, 0x6b, 0x0b, 0x19, 0x00, + 0x5b, 0x6e, 0x53, 0xb5, 0x00, 0x5b, 0x6f, 0x44, + 0x72, 0x00, 0x5b, 0x70, 0x12, 0x08, 0x00, 0x5b, + 0x71, 0x12, 0x30, 0x00, 0x5b, 0x73, 0x12, 0x09, + 0x00, 0x5b, 0x75, 0x12, 0x0a, 0x00, 0x5b, 0x76, + 0x37, 0x28, 0x00, 0x5b, 0x78, 0x12, 0x0b, 0x00, + 0x5b, 0x7a, 0x12, 0x0d, 0x00, 0x5b, 0x7c, 0x38, + 0x88, 0x00, 0x5b, 0x7d, 0x41, 0xc2, 0x00, 0x5b, + 0x7e, 0x38, 0x89, 0x00, 0x5b, 0x7f, 0x38, 0x8a, + 0x00, 0x5b, 0x80, 0x12, 0x0e, 0x00, 0x5b, 0x81, + 0x44, 0x73, 0x00, 0x5b, 0x82, 0x36, 0x10, 0x00, + 0x5b, 0x83, 0x12, 0x0f, 0x00, 0x5b, 0x84, 0x44, + 0x74, 0x00, 0x5b, 0x85, 0x0b, 0x50, 0x00, 0x5b, + 0x86, 0x53, 0xb6, 0x00, 0x5b, 0x87, 0x04, 0xc9, + 0x00, 0x5b, 0x88, 0x09, 0x15, 0x00, 0x5b, 0x89, + 0x04, 0x86, 0x00, 0x5b, 0x8a, 0x38, 0x8b, 0x00, + 0x5b, 0x8b, 0x0a, 0xd9, 0x00, 0x5b, 0x8c, 0x05, + 0xec, 0x00, 0x5b, 0x8d, 0x08, 0xe1, 0x00, 0x5b, + 0x8e, 0x53, 0xb7, 0x00, 0x5b, 0x8f, 0x07, 0xba, + 0x00, 0x5b, 0x90, 0x53, 0xb8, 0x00, 0x5b, 0x91, + 0x53, 0xb9, 0x00, 0x5b, 0x93, 0x41, 0xc3, 0x00, + 0x5b, 0x94, 0x53, 0xba, 0x00, 0x5b, 0x95, 0x0c, + 0x60, 0x00, 0x5b, 0x96, 0x44, 0x76, 0x00, 0x5b, + 0x97, 0x09, 0x2b, 0x00, 0x5b, 0x98, 0x05, 0xed, + 0x00, 0x5b, 0x99, 0x0b, 0xa6, 0x00, 0x5b, 0x9a, + 0x0c, 0x06, 0x00, 0x5b, 0x9b, 0x04, 0x7c, 0x00, + 0x5b, 0x9c, 0x06, 0x53, 0x00, 0x5b, 0x9d, 0x0e, + 0x45, 0x00, 0x5b, 0x9f, 0x08, 0xee, 0x00, 0x5b, + 0xa2, 0x06, 0x6c, 0x00, 0x5b, 0xa3, 0x0a, 0x8f, + 0x00, 0x5b, 0xa4, 0x08, 0xe8, 0x00, 0x5b, 0xa5, + 0x0f, 0x12, 0x00, 0x5b, 0xa6, 0x12, 0x10, 0x00, + 0x5b, 0xa8, 0x53, 0xbb, 0x00, 0x5b, 0xa9, 0x53, + 0xbc, 0x00, 0x5b, 0xac, 0x44, 0x77, 0x00, 0x5b, + 0xad, 0x53, 0xbd, 0x00, 0x5b, 0xae, 0x06, 0x76, + 0x00, 0x5b, 0xaf, 0x53, 0xbe, 0x00, 0x5b, 0xb0, + 0x08, 0x3b, 0x00, 0x5b, 0xb1, 0x53, 0xbf, 0x00, + 0x5b, 0xb2, 0x53, 0xc0, 0x00, 0x5b, 0xb3, 0x05, + 0x90, 0x00, 0x5b, 0xb4, 0x05, 0x05, 0x00, 0x5b, + 0xb5, 0x09, 0x94, 0x00, 0x5b, 0xb6, 0x05, 0x48, + 0x00, 0x5b, 0xb7, 0x4b, 0x79, 0x00, 0x5b, 0xb8, + 0x12, 0x11, 0x00, 0x5b, 0xb9, 0x0f, 0x30, 0x00, + 0x5b, 0xba, 0x53, 0xc1, 0x00, 0x5b, 0xbc, 0x53, + 0xc2, 0x00, 0x5b, 0xbf, 0x09, 0x53, 0x00, 0x5b, + 0xc0, 0x20, 0xf1, 0x00, 0x5b, 0xc1, 0x53, 0xc3, + 0x00, 0x5b, 0xc2, 0x09, 0x10, 0x00, 0x5b, 0xc3, + 0x12, 0x12, 0x00, 0x5b, 0xc4, 0x06, 0x2f, 0x00, + 0x5b, 0xc5, 0x0c, 0xaa, 0x00, 0x5b, 0xc6, 0x0e, + 0xb5, 0x00, 0x5b, 0xc7, 0x12, 0x13, 0x00, 0x5b, + 0xc9, 0x12, 0x14, 0x00, 0x5b, 0xcc, 0x0d, 0xcb, + 0x00, 0x5b, 0xcd, 0x53, 0xc4, 0x00, 0x5b, 0xce, + 0x44, 0x7a, 0x00, 0x5b, 0xcf, 0x53, 0xc5, 0x00, + 0x5b, 0xd0, 0x12, 0x16, 0x00, 0x5b, 0xd2, 0x05, + 0xe4, 0x00, 0x5b, 0xd3, 0x06, 0xef, 0x00, 0x5b, + 0xd4, 0x12, 0x15, 0x00, 0x5b, 0xd6, 0x44, 0x7b, + 0x00, 0x5b, 0xd7, 0x4b, 0x7a, 0x00, 0x5b, 0xd8, + 0x20, 0xf3, 0x00, 0x5b, 0xd9, 0x53, 0xc6, 0x00, + 0x5b, 0xda, 0x53, 0xc7, 0x00, 0x5b, 0xdb, 0x05, + 0xee, 0x00, 0x5b, 0xdd, 0x09, 0xf8, 0x00, 0x5b, + 0xde, 0x12, 0x1a, 0x00, 0x5b, 0xdf, 0x08, 0x6f, + 0x00, 0x5b, 0xe0, 0x4b, 0x7b, 0x00, 0x5b, 0xe1, + 0x05, 0x49, 0x00, 0x5b, 0xe2, 0x12, 0x19, 0x00, + 0x5b, 0xe4, 0x12, 0x17, 0x00, 0x5b, 0xe5, 0x12, + 0x1b, 0x00, 0x5b, 0xe6, 0x12, 0x18, 0x00, 0x5b, + 0xe7, 0x36, 0x93, 0x00, 0x5b, 0xe8, 0x14, 0x8e, + 0x00, 0x5b, 0xe9, 0x09, 0xf9, 0x00, 0x5b, 0xeb, + 0x12, 0x1c, 0x00, 0x5b, 0xec, 0x4f, 0x4e, 0x00, + 0x5b, 0xee, 0x0f, 0x88, 0x00, 0x5b, 0xef, 0x53, + 0xc8, 0x00, 0x5b, 0xf0, 0x12, 0x1d, 0x00, 0x5b, + 0xf1, 0x44, 0x7e, 0x00, 0x5b, 0xf3, 0x12, 0x1f, + 0x00, 0x5b, 0xf4, 0x53, 0xc9, 0x00, 0x5b, 0xf5, + 0x0b, 0xbc, 0x00, 0x5b, 0xf6, 0x12, 0x1e, 0x00, + 0x5b, 0xf8, 0x0a, 0x47, 0x00, 0x5b, 0xfa, 0x08, + 0xc9, 0x00, 0x5b, 0xfd, 0x44, 0x7f, 0x00, 0x5b, + 0xfe, 0x0b, 0x30, 0x00, 0x5b, 0xff, 0x09, 0x23, + 0x00, 0x5c, 0x01, 0x0d, 0xe7, 0x00, 0x5c, 0x02, + 0x0a, 0x90, 0x00, 0x5c, 0x03, 0x44, 0x81, 0x00, + 0x5c, 0x04, 0x08, 0xf9, 0x00, 0x5c, 0x05, 0x12, + 0x20, 0x00, 0x5c, 0x06, 0x36, 0x08, 0x00, 0x5c, + 0x07, 0x12, 0x21, 0x00, 0x5c, 0x08, 0x12, 0x22, + 0x00, 0x5c, 0x09, 0x04, 0x97, 0x00, 0x5c, 0x0a, + 0x0b, 0x1a, 0x00, 0x5c, 0x0b, 0x0a, 0x18, 0x00, + 0x5c, 0x0c, 0x53, 0xca, 0x00, 0x5c, 0x0d, 0x12, + 0x23, 0x00, 0x5c, 0x0e, 0x0c, 0x8b, 0x00, 0x5c, + 0x0f, 0x09, 0x96, 0x00, 0x5c, 0x11, 0x09, 0x97, + 0x00, 0x5c, 0x12, 0x41, 0xc4, 0x00, 0x5c, 0x13, + 0x12, 0x24, 0x00, 0x5c, 0x14, 0x37, 0x2a, 0x00, + 0x5c, 0x16, 0x0a, 0x91, 0x00, 0x5c, 0x17, 0x53, + 0xcb, 0x00, 0x5c, 0x19, 0x36, 0x0b, 0x00, 0x5c, + 0x1a, 0x09, 0x98, 0x00, 0x5c, 0x1e, 0x20, 0xf5, + 0x00, 0x5c, 0x1f, 0x4b, 0x7c, 0x00, 0x5c, 0x20, + 0x12, 0x25, 0x00, 0x5c, 0x22, 0x12, 0x26, 0x00, + 0x5c, 0x23, 0x38, 0x8c, 0x00, 0x5c, 0x24, 0x0e, + 0xec, 0x00, 0x5c, 0x26, 0x53, 0xcc, 0x00, 0x5c, + 0x28, 0x12, 0x27, 0x00, 0x5c, 0x29, 0x44, 0x82, + 0x00, 0x5c, 0x2a, 0x4b, 0x7d, 0x00, 0x5c, 0x2b, + 0x38, 0x8d, 0x00, 0x5c, 0x2c, 0x4b, 0x7e, 0x00, + 0x5c, 0x2d, 0x06, 0xbe, 0x00, 0x5c, 0x2e, 0x53, + 0xcd, 0x00, 0x5c, 0x30, 0x38, 0x8e, 0x00, 0x5c, + 0x31, 0x09, 0x2c, 0x00, 0x5c, 0x32, 0x53, 0xce, + 0x00, 0x5c, 0x35, 0x53, 0xcf, 0x00, 0x5c, 0x36, + 0x4b, 0x7f, 0x00, 0x5c, 0x38, 0x12, 0x28, 0x00, + 0x5c, 0x39, 0x12, 0x29, 0x00, 0x5c, 0x3a, 0x09, + 0x08, 0x00, 0x5c, 0x3b, 0x09, 0xf2, 0x00, 0x5c, + 0x3c, 0x0c, 0xcc, 0x00, 0x5c, 0x3d, 0x0a, 0x1a, + 0x00, 0x5c, 0x3e, 0x0d, 0x8c, 0x00, 0x5c, 0x3f, + 0x0c, 0xd8, 0x00, 0x5c, 0x40, 0x06, 0xc1, 0x00, + 0x5c, 0x41, 0x12, 0x2a, 0x00, 0x5c, 0x45, 0x06, + 0x89, 0x00, 0x5c, 0x46, 0x12, 0x2b, 0x00, 0x5c, + 0x48, 0x06, 0xf6, 0x00, 0x5c, 0x4a, 0x0c, 0xa7, + 0x00, 0x5c, 0x4b, 0x05, 0x30, 0x00, 0x5c, 0x4d, + 0x08, 0xa1, 0x00, 0x5c, 0x4e, 0x12, 0x2c, 0x00, + 0x5c, 0x4f, 0x12, 0x2f, 0x00, 0x5c, 0x50, 0x12, + 0x2e, 0x00, 0x5c, 0x51, 0x06, 0xf5, 0x00, 0x5c, + 0x53, 0x12, 0x2d, 0x00, 0x5c, 0x55, 0x0c, 0x32, + 0x00, 0x5c, 0x59, 0x4b, 0x80, 0x00, 0x5c, 0x5a, + 0x53, 0xd0, 0x00, 0x5c, 0x5b, 0x1e, 0x92, 0x00, + 0x5c, 0x5c, 0x4b, 0x81, 0x00, 0x5c, 0x5e, 0x0b, + 0x10, 0x00, 0x5c, 0x5f, 0x44, 0x84, 0x00, 0x5c, + 0x60, 0x0c, 0x45, 0x00, 0x5c, 0x61, 0x08, 0xf4, + 0x00, 0x5c, 0x62, 0x1e, 0x0d, 0x00, 0x5c, 0x63, + 0x38, 0x8f, 0x00, 0x5c, 0x64, 0x0a, 0xda, 0x00, + 0x5c, 0x65, 0x0f, 0x64, 0x00, 0x5c, 0x67, 0x44, + 0x85, 0x00, 0x5c, 0x68, 0x44, 0x86, 0x00, 0x5c, + 0x69, 0x38, 0x90, 0x00, 0x5c, 0x6c, 0x12, 0x31, + 0x00, 0x5c, 0x6d, 0x4b, 0x82, 0x00, 0x5c, 0x6e, + 0x41, 0xc5, 0x00, 0x5c, 0x6f, 0x0c, 0xae, 0x00, + 0x5c, 0x70, 0x44, 0x87, 0x00, 0x5c, 0x71, 0x08, + 0x81, 0x00, 0x5c, 0x74, 0x53, 0xd1, 0x00, 0x5c, + 0x75, 0x53, 0xd2, 0x00, 0x5c, 0x76, 0x12, 0x34, + 0x00, 0x5c, 0x79, 0x12, 0x35, 0x00, 0x5c, 0x7a, + 0x41, 0xc7, 0x00, 0x5c, 0x7b, 0x53, 0xd3, 0x00, + 0x5c, 0x7c, 0x38, 0x91, 0x00, 0x5c, 0x7d, 0x53, + 0xd4, 0x00, 0x5c, 0x87, 0x53, 0xd5, 0x00, 0x5c, + 0x88, 0x44, 0x8c, 0x00, 0x5c, 0x8a, 0x44, 0x8d, + 0x00, 0x5c, 0x8c, 0x12, 0x36, 0x00, 0x5c, 0x8f, + 0x41, 0xc8, 0x00, 0x5c, 0x90, 0x06, 0x30, 0x00, + 0x5c, 0x91, 0x12, 0x37, 0x00, 0x5c, 0x92, 0x53, + 0xd6, 0x00, 0x5c, 0x94, 0x12, 0x38, 0x00, 0x5c, + 0x9d, 0x53, 0xd7, 0x00, 0x5c, 0x9f, 0x41, 0xc9, + 0x00, 0x5c, 0xa0, 0x44, 0x91, 0x00, 0x5c, 0xa1, + 0x05, 0x2c, 0x00, 0x5c, 0xa2, 0x44, 0x92, 0x00, + 0x5c, 0xa3, 0x41, 0xca, 0x00, 0x5c, 0xa6, 0x20, + 0xf6, 0x00, 0x5c, 0xa7, 0x44, 0x93, 0x00, 0x5c, + 0xa8, 0x0a, 0xbd, 0x00, 0x5c, 0xa9, 0x06, 0x20, + 0x00, 0x5c, 0xaa, 0x41, 0xcb, 0x00, 0x5c, 0xab, + 0x12, 0x3a, 0x00, 0x5c, 0xac, 0x0e, 0xb4, 0x00, + 0x5c, 0xad, 0x44, 0x95, 0x00, 0x5c, 0xb1, 0x0b, + 0x32, 0x00, 0x5c, 0xb2, 0x53, 0xd8, 0x00, 0x5c, + 0xb3, 0x05, 0xb7, 0x00, 0x5c, 0xb4, 0x53, 0xd9, + 0x00, 0x5c, 0xb5, 0x44, 0x96, 0x00, 0x5c, 0xb6, + 0x12, 0x3c, 0x00, 0x5c, 0xb7, 0x12, 0x3e, 0x00, + 0x5c, 0xb8, 0x06, 0x1b, 0x00, 0x5c, 0xba, 0x20, + 0xf7, 0x00, 0x5c, 0xbb, 0x12, 0x3b, 0x00, 0x5c, + 0xbc, 0x12, 0x3d, 0x00, 0x5c, 0xbe, 0x12, 0x40, + 0x00, 0x5c, 0xc5, 0x12, 0x3f, 0x00, 0x5c, 0xc7, + 0x12, 0x41, 0x00, 0x5c, 0xc9, 0x44, 0x98, 0x00, + 0x5c, 0xcb, 0x38, 0x92, 0x00, 0x5c, 0xd0, 0x41, + 0xcc, 0x00, 0x5c, 0xd2, 0x38, 0x93, 0x00, 0x5c, + 0xd7, 0x53, 0xda, 0x00, 0x5c, 0xd9, 0x12, 0x42, + 0x00, 0x5c, 0xdd, 0x4b, 0x83, 0x00, 0x5c, 0xe0, + 0x0c, 0x95, 0x00, 0x5c, 0xe1, 0x06, 0xa6, 0x00, + 0x5c, 0xe6, 0x37, 0x2c, 0x00, 0x5c, 0xe8, 0x05, + 0x65, 0x00, 0x5c, 0xe9, 0x12, 0x43, 0x00, 0x5c, + 0xea, 0x12, 0x48, 0x00, 0x5c, 0xed, 0x12, 0x46, + 0x00, 0x5c, 0xee, 0x53, 0xdb, 0x00, 0x5c, 0xef, + 0x0e, 0x47, 0x00, 0x5c, 0xf0, 0x0e, 0x46, 0x00, + 0x5c, 0xf1, 0x53, 0xdc, 0x00, 0x5c, 0xf2, 0x53, + 0xdd, 0x00, 0x5c, 0xf4, 0x38, 0x94, 0x00, 0x5c, + 0xf5, 0x20, 0xf8, 0x00, 0x5c, 0xf6, 0x0c, 0x61, + 0x00, 0x5c, 0xfa, 0x12, 0x45, 0x00, 0x5c, 0xfb, + 0x09, 0x5e, 0x00, 0x5c, 0xfd, 0x12, 0x44, 0x00, + 0x5d, 0x01, 0x4b, 0x84, 0x00, 0x5d, 0x06, 0x44, + 0x9b, 0x00, 0x5d, 0x07, 0x0a, 0x38, 0x00, 0x5d, + 0x0b, 0x12, 0x49, 0x00, 0x5d, 0x0d, 0x41, 0xce, + 0x00, 0x5d, 0x0e, 0x08, 0x5a, 0x00, 0x5d, 0x10, + 0x44, 0x9c, 0x00, 0x5d, 0x11, 0x12, 0x4f, 0x00, + 0x5d, 0x12, 0x53, 0xde, 0x00, 0x5d, 0x14, 0x12, + 0x50, 0x00, 0x5d, 0x15, 0x12, 0x4a, 0x00, 0x5d, + 0x16, 0x05, 0x91, 0x00, 0x5d, 0x17, 0x12, 0x4b, + 0x00, 0x5d, 0x18, 0x12, 0x54, 0x00, 0x5d, 0x19, + 0x12, 0x53, 0x00, 0x5d, 0x1a, 0x12, 0x52, 0x00, + 0x5d, 0x1b, 0x12, 0x4e, 0x00, 0x5d, 0x1d, 0x44, + 0x9e, 0x00, 0x5d, 0x1f, 0x12, 0x4d, 0x00, 0x5d, + 0x20, 0x44, 0x9f, 0x00, 0x5d, 0x22, 0x12, 0x51, + 0x00, 0x5d, 0x23, 0x53, 0xdf, 0x00, 0x5d, 0x24, + 0x38, 0x95, 0x00, 0x5d, 0x26, 0x38, 0x96, 0x00, + 0x5d, 0x27, 0x20, 0xf9, 0x00, 0x5d, 0x29, 0x0e, + 0x48, 0x00, 0x5d, 0x2b, 0x44, 0x9d, 0x00, 0x5d, + 0x31, 0x44, 0xa0, 0x00, 0x5d, 0x34, 0x4b, 0x85, + 0x00, 0x5d, 0x39, 0x44, 0xa1, 0x00, 0x5d, 0x3d, + 0x4b, 0x86, 0x00, 0x5d, 0x3f, 0x53, 0xe0, 0x00, + 0x5d, 0x42, 0x20, 0xfc, 0x00, 0x5d, 0x43, 0x38, + 0x97, 0x00, 0x5d, 0x46, 0x38, 0x98, 0x00, 0x5d, + 0x47, 0x41, 0xcf, 0x00, 0x5d, 0x48, 0x53, 0xe1, + 0x00, 0x5d, 0x4a, 0x38, 0x99, 0x00, 0x5d, 0x4b, + 0x12, 0x58, 0x00, 0x5d, 0x4c, 0x12, 0x55, 0x00, + 0x5d, 0x4e, 0x12, 0x57, 0x00, 0x5d, 0x50, 0x0f, + 0x5c, 0x00, 0x5d, 0x51, 0x53, 0xe3, 0x00, 0x5d, + 0x52, 0x12, 0x56, 0x00, 0x5d, 0x53, 0x20, 0xfa, + 0x00, 0x5d, 0x55, 0x53, 0xe2, 0x00, 0x5d, 0x59, + 0x4b, 0x87, 0x00, 0x5d, 0x5c, 0x12, 0x4c, 0x00, + 0x5d, 0x5f, 0x53, 0xe4, 0x00, 0x5d, 0x60, 0x53, + 0xe5, 0x00, 0x5d, 0x61, 0x44, 0xa3, 0x00, 0x5d, + 0x62, 0x53, 0xe6, 0x00, 0x5d, 0x64, 0x53, 0xe7, + 0x00, 0x5d, 0x69, 0x0a, 0x39, 0x00, 0x5d, 0x6a, + 0x44, 0xa4, 0x00, 0x5d, 0x6c, 0x12, 0x59, 0x00, + 0x5d, 0x6d, 0x20, 0xfd, 0x00, 0x5d, 0x6f, 0x08, + 0x27, 0x00, 0x5d, 0x70, 0x44, 0xa6, 0x00, 0x5d, + 0x73, 0x12, 0x5a, 0x00, 0x5d, 0x76, 0x12, 0x5b, + 0x00, 0x5d, 0x79, 0x53, 0xe8, 0x00, 0x5d, 0x7a, + 0x53, 0xe9, 0x00, 0x5d, 0x7e, 0x4b, 0x88, 0x00, + 0x5d, 0x7f, 0x53, 0xea, 0x00, 0x5d, 0x81, 0x41, + 0xd0, 0x00, 0x5d, 0x82, 0x12, 0x5e, 0x00, 0x5d, + 0x83, 0x4b, 0x89, 0x00, 0x5d, 0x84, 0x12, 0x5d, + 0x00, 0x5d, 0x87, 0x12, 0x5c, 0x00, 0x5d, 0x88, + 0x44, 0xa9, 0x00, 0x5d, 0x8a, 0x53, 0xeb, 0x00, + 0x5d, 0x8b, 0x0c, 0x62, 0x00, 0x5d, 0x8c, 0x12, + 0x47, 0x00, 0x5d, 0x90, 0x12, 0x64, 0x00, 0x5d, + 0x92, 0x38, 0x9a, 0x00, 0x5d, 0x93, 0x53, 0xec, + 0x00, 0x5d, 0x94, 0x38, 0x9b, 0x00, 0x5d, 0x95, + 0x53, 0xed, 0x00, 0x5d, 0x97, 0x44, 0xab, 0x00, + 0x5d, 0x99, 0x38, 0x9c, 0x00, 0x5d, 0x9b, 0x53, + 0xee, 0x00, 0x5d, 0x9d, 0x12, 0x60, 0x00, 0x5d, + 0x9f, 0x53, 0xef, 0x00, 0x5d, 0xa0, 0x38, 0x9d, + 0x00, 0x5d, 0xa2, 0x12, 0x5f, 0x00, 0x5d, 0xa4, + 0x41, 0xd1, 0x00, 0x5d, 0xa7, 0x41, 0xd2, 0x00, + 0x5d, 0xab, 0x53, 0xf0, 0x00, 0x5d, 0xac, 0x12, + 0x61, 0x00, 0x5d, 0xae, 0x12, 0x62, 0x00, 0x5d, + 0xb0, 0x44, 0xac, 0x00, 0x5d, 0xb2, 0x3b, 0xa5, + 0x00, 0x5d, 0xb4, 0x44, 0xad, 0x00, 0x5d, 0xb7, + 0x12, 0x65, 0x00, 0x5d, 0xb8, 0x20, 0xfe, 0x00, + 0x5d, 0xb9, 0x20, 0xff, 0x00, 0x5d, 0xba, 0x0f, + 0xae, 0x00, 0x5d, 0xbc, 0x12, 0x66, 0x00, 0x5d, + 0xbd, 0x12, 0x63, 0x00, 0x5d, 0xc3, 0x53, 0xf1, + 0x00, 0x5d, 0xc7, 0x4b, 0x8a, 0x00, 0x5d, 0xc9, + 0x12, 0x67, 0x00, 0x5d, 0xcb, 0x41, 0xd3, 0x00, + 0x5d, 0xcc, 0x06, 0x1c, 0x00, 0x5d, 0xcd, 0x12, + 0x68, 0x00, 0x5d, 0xce, 0x53, 0xf2, 0x00, 0x5d, + 0xd0, 0x21, 0x00, 0x00, 0x5d, 0xd1, 0x44, 0xaf, + 0x00, 0x5d, 0xd2, 0x12, 0x6a, 0x00, 0x5d, 0xd3, + 0x12, 0x69, 0x00, 0x5d, 0xd6, 0x12, 0x6b, 0x00, + 0x5d, 0xd7, 0x44, 0xb0, 0x00, 0x5d, 0xd8, 0x38, + 0x9e, 0x00, 0x5d, 0xd9, 0x53, 0xf3, 0x00, 0x5d, + 0xdb, 0x12, 0x6c, 0x00, 0x5d, 0xdd, 0x0a, 0x92, + 0x00, 0x5d, 0xde, 0x09, 0x2d, 0x00, 0x5d, 0xe0, + 0x38, 0x9f, 0x00, 0x5d, 0xe1, 0x09, 0x6e, 0x00, + 0x5d, 0xe2, 0x34, 0x32, 0x00, 0x5d, 0xe3, 0x0a, + 0xe5, 0x00, 0x5d, 0xe4, 0x44, 0xb2, 0x00, 0x5d, + 0xe5, 0x07, 0xbb, 0x00, 0x5d, 0xe6, 0x08, 0x28, + 0x00, 0x5d, 0xe7, 0x07, 0xbc, 0x00, 0x5d, 0xe8, + 0x06, 0x8a, 0x00, 0x5d, 0xe9, 0x44, 0xb3, 0x00, + 0x5d, 0xeb, 0x12, 0x6d, 0x00, 0x5d, 0xee, 0x08, + 0x29, 0x00, 0x5d, 0xf1, 0x07, 0x7e, 0x00, 0x5d, + 0xf2, 0x12, 0x6e, 0x00, 0x5d, 0xf3, 0x0e, 0xb2, + 0x00, 0x5d, 0xf4, 0x0c, 0xf9, 0x00, 0x5d, 0xf5, + 0x12, 0x6f, 0x00, 0x5d, 0xf7, 0x07, 0xbd, 0x00, + 0x5d, 0xf8, 0x38, 0xa0, 0x00, 0x5d, 0xf9, 0x4b, + 0x8b, 0x00, 0x5d, 0xfb, 0x05, 0xe8, 0x00, 0x5d, + 0xfd, 0x1e, 0x36, 0x00, 0x5d, 0xfe, 0x06, 0xca, + 0x00, 0x5d, 0xff, 0x35, 0xe2, 0x00, 0x5e, 0x00, + 0x38, 0xa1, 0x00, 0x5e, 0x02, 0x08, 0xa2, 0x00, + 0x5e, 0x03, 0x0d, 0xcd, 0x00, 0x5e, 0x06, 0x0d, + 0x55, 0x00, 0x5e, 0x07, 0x53, 0xf4, 0x00, 0x5e, + 0x0b, 0x12, 0x70, 0x00, 0x5e, 0x0c, 0x06, 0x31, + 0x00, 0x5e, 0x0d, 0x53, 0xf5, 0x00, 0x5e, 0x11, + 0x12, 0x73, 0x00, 0x5e, 0x12, 0x38, 0xa2, 0x00, + 0x5e, 0x14, 0x38, 0xa3, 0x00, 0x5e, 0x15, 0x38, + 0xa4, 0x00, 0x5e, 0x16, 0x0b, 0xbd, 0x00, 0x5e, + 0x18, 0x38, 0xa5, 0x00, 0x5e, 0x19, 0x12, 0x72, + 0x00, 0x5e, 0x1a, 0x12, 0x71, 0x00, 0x5e, 0x1b, + 0x12, 0x74, 0x00, 0x5e, 0x1d, 0x0c, 0x07, 0x00, + 0x5e, 0x1f, 0x44, 0xb7, 0x00, 0x5e, 0x20, 0x53, + 0xf6, 0x00, 0x5e, 0x25, 0x0a, 0x29, 0x00, 0x5e, + 0x28, 0x4b, 0x8c, 0x00, 0x5e, 0x2b, 0x08, 0xa3, + 0x00, 0x5e, 0x2d, 0x0a, 0x6e, 0x00, 0x5e, 0x2e, + 0x38, 0xa6, 0x00, 0x5e, 0x2f, 0x0b, 0x33, 0x00, + 0x5e, 0x30, 0x06, 0x3c, 0x00, 0x5e, 0x32, 0x4b, + 0x8d, 0x00, 0x5e, 0x33, 0x0b, 0xbe, 0x00, 0x5e, + 0x35, 0x4b, 0x8e, 0x00, 0x5e, 0x36, 0x12, 0x75, + 0x00, 0x5e, 0x37, 0x12, 0x76, 0x00, 0x5e, 0x38, + 0x09, 0xd7, 0x00, 0x5e, 0x3d, 0x0e, 0x67, 0x00, + 0x5e, 0x3e, 0x44, 0xb8, 0x00, 0x5e, 0x40, 0x12, + 0x79, 0x00, 0x5e, 0x43, 0x12, 0x78, 0x00, 0x5e, + 0x44, 0x12, 0x77, 0x00, 0x5e, 0x45, 0x0d, 0xef, + 0x00, 0x5e, 0x47, 0x12, 0x80, 0x00, 0x5e, 0x49, + 0x44, 0xb9, 0x00, 0x5e, 0x4b, 0x53, 0xf7, 0x00, + 0x5e, 0x4c, 0x0e, 0x88, 0x00, 0x5e, 0x4e, 0x12, + 0x7a, 0x00, 0x5e, 0x50, 0x53, 0xf8, 0x00, 0x5e, + 0x51, 0x53, 0xf9, 0x00, 0x5e, 0x54, 0x12, 0x7c, + 0x00, 0x5e, 0x55, 0x0e, 0x99, 0x00, 0x5e, 0x56, + 0x44, 0xbb, 0x00, 0x5e, 0x57, 0x12, 0x7b, 0x00, + 0x5e, 0x58, 0x38, 0xa7, 0x00, 0x5e, 0x5b, 0x4b, + 0x8f, 0x00, 0x5e, 0x5c, 0x53, 0xfa, 0x00, 0x5e, + 0x5e, 0x41, 0xd4, 0x00, 0x5e, 0x5f, 0x12, 0x7d, + 0x00, 0x5e, 0x61, 0x0d, 0x3c, 0x00, 0x5e, 0x62, + 0x12, 0x7e, 0x00, 0x5e, 0x63, 0x0e, 0x0e, 0x00, + 0x5e, 0x64, 0x12, 0x7f, 0x00, 0x5e, 0x68, 0x4b, + 0x90, 0x00, 0x5e, 0x6a, 0x4b, 0x91, 0x00, 0x5e, + 0x6b, 0x38, 0xa8, 0x00, 0x5e, 0x6c, 0x38, 0xa9, + 0x00, 0x5e, 0x6d, 0x44, 0xbd, 0x00, 0x5e, 0x6e, + 0x44, 0xbe, 0x00, 0x5e, 0x70, 0x53, 0xfb, 0x00, + 0x5e, 0x72, 0x05, 0xef, 0x00, 0x5e, 0x73, 0x0e, + 0x0f, 0x00, 0x5e, 0x74, 0x0c, 0xe5, 0x00, 0x5e, + 0x75, 0x12, 0x81, 0x00, 0x5e, 0x76, 0x12, 0x82, + 0x00, 0x5e, 0x77, 0x4b, 0x92, 0x00, 0x5e, 0x78, + 0x07, 0xbe, 0x00, 0x5e, 0x79, 0x05, 0xf0, 0x00, + 0x5e, 0x7a, 0x12, 0x83, 0x00, 0x5e, 0x7b, 0x07, + 0x6c, 0x00, 0x5e, 0x7c, 0x0f, 0x2e, 0x00, 0x5e, + 0x7d, 0x0f, 0x13, 0x00, 0x5e, 0x7e, 0x06, 0x32, + 0x00, 0x5e, 0x7f, 0x12, 0x85, 0x00, 0x5e, 0x80, + 0x4b, 0x93, 0x00, 0x5e, 0x81, 0x0b, 0xbf, 0x00, + 0x5e, 0x83, 0x07, 0xbf, 0x00, 0x5e, 0x84, 0x09, + 0x99, 0x00, 0x5e, 0x87, 0x0d, 0x73, 0x00, 0x5e, + 0x8a, 0x09, 0x9a, 0x00, 0x5e, 0x8b, 0x4b, 0x94, + 0x00, 0x5e, 0x8e, 0x53, 0xfc, 0x00, 0x5e, 0x8f, + 0x09, 0x82, 0x00, 0x5e, 0x95, 0x0c, 0x08, 0x00, + 0x5e, 0x96, 0x0e, 0x49, 0x00, 0x5e, 0x97, 0x0c, + 0x33, 0x00, 0x5e, 0x99, 0x36, 0xb0, 0x00, 0x5e, + 0x9a, 0x07, 0xc0, 0x00, 0x5e, 0x9c, 0x0d, 0xce, + 0x00, 0x5e, 0xa0, 0x12, 0x86, 0x00, 0x5e, 0xa2, + 0x53, 0xfd, 0x00, 0x5e, 0xa4, 0x53, 0xfe, 0x00, + 0x5e, 0xa5, 0x44, 0xc0, 0x00, 0x5e, 0xa6, 0x0c, + 0x53, 0x00, 0x5e, 0xa7, 0x08, 0x32, 0x00, 0x5e, + 0xa8, 0x38, 0xaa, 0x00, 0x5e, 0xaa, 0x38, 0xab, + 0x00, 0x5e, 0xab, 0x07, 0x7f, 0x00, 0x5e, 0xac, + 0x44, 0xc1, 0x00, 0x5e, 0xad, 0x0c, 0x09, 0x00, + 0x5e, 0xb1, 0x53, 0xff, 0x00, 0x5e, 0xb3, 0x4b, + 0x95, 0x00, 0x5e, 0xb5, 0x04, 0x87, 0x00, 0x5e, + 0xb6, 0x09, 0x78, 0x00, 0x5e, 0xb7, 0x07, 0xc1, + 0x00, 0x5e, 0xb8, 0x0f, 0x31, 0x00, 0x5e, 0xb9, + 0x44, 0xc2, 0x00, 0x5e, 0xbd, 0x4b, 0x96, 0x00, + 0x5e, 0xbe, 0x38, 0xac, 0x00, 0x5e, 0xbf, 0x38, + 0xad, 0x00, 0x5e, 0xc1, 0x12, 0x87, 0x00, 0x5e, + 0xc2, 0x12, 0x88, 0x00, 0x5e, 0xc3, 0x0d, 0x07, + 0x00, 0x5e, 0xc6, 0x44, 0xc3, 0x00, 0x5e, 0xc8, + 0x12, 0x89, 0x00, 0x5e, 0xc9, 0x37, 0x0f, 0x00, + 0x5e, 0xca, 0x0f, 0xd3, 0x00, 0x5e, 0xcb, 0x3c, + 0x1e, 0x00, 0x5e, 0xcc, 0x54, 0x00, 0x00, 0x5e, + 0xce, 0x54, 0x01, 0x00, 0x5e, 0xcf, 0x12, 0x8b, + 0x00, 0x5e, 0xd0, 0x12, 0x8a, 0x00, 0x5e, 0xd1, + 0x4b, 0x97, 0x00, 0x5e, 0xd2, 0x38, 0xaf, 0x00, + 0x5e, 0xd3, 0x05, 0xa5, 0x00, 0x5e, 0xd4, 0x4b, + 0x98, 0x00, 0x5e, 0xd5, 0x4b, 0x99, 0x00, 0x5e, + 0xd6, 0x12, 0x8c, 0x00, 0x5e, 0xd9, 0x44, 0xc4, + 0x00, 0x5e, 0xda, 0x12, 0x8f, 0x00, 0x5e, 0xdb, + 0x12, 0x90, 0x00, 0x5e, 0xdc, 0x54, 0x02, 0x00, + 0x5e, 0xdd, 0x12, 0x8e, 0x00, 0x5e, 0xde, 0x54, + 0x03, 0x00, 0x5e, 0xdf, 0x0d, 0xb2, 0x00, 0x5e, + 0xe0, 0x09, 0x9b, 0x00, 0x5e, 0xe1, 0x12, 0x92, + 0x00, 0x5e, 0xe2, 0x12, 0x91, 0x00, 0x5e, 0xe3, + 0x12, 0x8d, 0x00, 0x5e, 0xe5, 0x54, 0x04, 0x00, + 0x5e, 0xe8, 0x12, 0x93, 0x00, 0x5e, 0xe9, 0x12, + 0x94, 0x00, 0x5e, 0xeb, 0x54, 0x05, 0x00, 0x5e, + 0xec, 0x12, 0x95, 0x00, 0x5e, 0xf0, 0x12, 0x98, + 0x00, 0x5e, 0xf1, 0x12, 0x96, 0x00, 0x5e, 0xf3, + 0x12, 0x97, 0x00, 0x5e, 0xf4, 0x12, 0x99, 0x00, + 0x5e, 0xf6, 0x05, 0x06, 0x00, 0x5e, 0xf7, 0x0c, + 0x0a, 0x00, 0x5e, 0xf8, 0x12, 0x9a, 0x00, 0x5e, + 0xf9, 0x41, 0xd5, 0x00, 0x5e, 0xfa, 0x07, 0x50, + 0x00, 0x5e, 0xfb, 0x05, 0x76, 0x00, 0x5e, 0xfc, + 0x0c, 0xec, 0x00, 0x5e, 0xfd, 0x44, 0xc6, 0x00, + 0x5e, 0xfe, 0x12, 0x9b, 0x00, 0x5e, 0xff, 0x0c, + 0xd3, 0x00, 0x5f, 0x00, 0x41, 0xd6, 0x00, 0x5f, + 0x01, 0x0e, 0x2b, 0x00, 0x5f, 0x02, 0x41, 0xd7, + 0x00, 0x5f, 0x03, 0x12, 0x9c, 0x00, 0x5f, 0x04, + 0x0f, 0xd4, 0x00, 0x5f, 0x06, 0x54, 0x06, 0x00, + 0x5f, 0x07, 0x38, 0xb0, 0x00, 0x5f, 0x08, 0x44, + 0xc7, 0x00, 0x5f, 0x09, 0x12, 0x9d, 0x00, 0x5f, + 0x0a, 0x0e, 0x10, 0x00, 0x5f, 0x0b, 0x12, 0xa0, + 0x00, 0x5f, 0x0c, 0x0f, 0xfa, 0x00, 0x5f, 0x0d, + 0x10, 0x0a, 0x00, 0x5f, 0x0e, 0x38, 0xb1, 0x00, + 0x5f, 0x0f, 0x08, 0xdc, 0x00, 0x5f, 0x10, 0x0c, + 0xcd, 0x00, 0x5f, 0x11, 0x12, 0xa1, 0x00, 0x5f, + 0x13, 0x06, 0x77, 0x00, 0x5f, 0x14, 0x0b, 0xc0, + 0x00, 0x5f, 0x15, 0x04, 0xbe, 0x00, 0x5f, 0x16, + 0x12, 0xa2, 0x00, 0x5f, 0x17, 0x0d, 0xf6, 0x00, + 0x5f, 0x18, 0x07, 0xc2, 0x00, 0x5f, 0x19, 0x54, + 0x07, 0x00, 0x5f, 0x1b, 0x0b, 0x8e, 0x00, 0x5f, + 0x1c, 0x38, 0xb2, 0x00, 0x5f, 0x1d, 0x38, 0xb3, + 0x00, 0x5f, 0x1e, 0x44, 0xc9, 0x00, 0x5f, 0x1f, + 0x0c, 0x0b, 0x00, 0x5f, 0x21, 0x21, 0x01, 0x00, + 0x5f, 0x22, 0x38, 0xb4, 0x00, 0x5f, 0x23, 0x41, + 0xd8, 0x00, 0x5f, 0x24, 0x54, 0x08, 0x00, 0x5f, + 0x25, 0x0e, 0xfb, 0x00, 0x5f, 0x26, 0x07, 0x6d, + 0x00, 0x5f, 0x27, 0x07, 0x80, 0x00, 0x5f, 0x28, + 0x38, 0xb5, 0x00, 0x5f, 0x29, 0x12, 0xa3, 0x00, + 0x5f, 0x2b, 0x54, 0x09, 0x00, 0x5f, 0x2c, 0x54, + 0x0a, 0x00, 0x5f, 0x2d, 0x12, 0xa4, 0x00, 0x5f, + 0x2e, 0x54, 0x0b, 0x00, 0x5f, 0x2f, 0x12, 0xaa, + 0x00, 0x5f, 0x30, 0x54, 0x0c, 0x00, 0x5f, 0x31, + 0x09, 0x11, 0x00, 0x5f, 0x34, 0x21, 0x02, 0x00, + 0x5f, 0x35, 0x0b, 0xc1, 0x00, 0x5f, 0x36, 0x38, + 0xb6, 0x00, 0x5f, 0x37, 0x06, 0xa7, 0x00, 0x5f, + 0x38, 0x12, 0xa5, 0x00, 0x5f, 0x3a, 0x35, 0x98, + 0x00, 0x5f, 0x3b, 0x38, 0xb7, 0x00, 0x5f, 0x3c, + 0x0d, 0x9d, 0x00, 0x5f, 0x3d, 0x41, 0xd9, 0x00, + 0x5f, 0x3e, 0x0b, 0x84, 0x00, 0x5f, 0x3f, 0x54, + 0x0d, 0x00, 0x5f, 0x40, 0x38, 0xb8, 0x00, 0x5f, + 0x41, 0x12, 0xa6, 0x00, 0x5f, 0x44, 0x54, 0x0e, + 0x00, 0x5f, 0x45, 0x20, 0xb2, 0x00, 0x5f, 0x47, + 0x44, 0xca, 0x00, 0x5f, 0x48, 0x12, 0xa7, 0x00, + 0x5f, 0x4a, 0x06, 0xa8, 0x00, 0x5f, 0x4c, 0x12, + 0xa8, 0x00, 0x5f, 0x4d, 0x4b, 0x9a, 0x00, 0x5f, + 0x4e, 0x12, 0xa9, 0x00, 0x5f, 0x50, 0x38, 0xb9, + 0x00, 0x5f, 0x51, 0x12, 0xab, 0x00, 0x5f, 0x53, + 0x0c, 0x70, 0x00, 0x5f, 0x54, 0x41, 0xda, 0x00, + 0x5f, 0x56, 0x12, 0xac, 0x00, 0x5f, 0x57, 0x12, + 0xad, 0x00, 0x5f, 0x58, 0x38, 0xba, 0x00, 0x5f, + 0x59, 0x12, 0xae, 0x00, 0x5f, 0x5b, 0x54, 0x0f, + 0x00, 0x5f, 0x5c, 0x12, 0x9f, 0x00, 0x5f, 0x5d, + 0x12, 0x9e, 0x00, 0x5f, 0x60, 0x54, 0x10, 0x00, + 0x5f, 0x61, 0x12, 0xaf, 0x00, 0x5f, 0x62, 0x07, + 0x17, 0x00, 0x5f, 0x63, 0x44, 0xcb, 0x00, 0x5f, + 0x64, 0x38, 0xbb, 0x00, 0x5f, 0x65, 0x36, 0xac, + 0x00, 0x5f, 0x66, 0x0d, 0x99, 0x00, 0x5f, 0x67, + 0x21, 0x03, 0x00, 0x5f, 0x69, 0x08, 0x3c, 0x00, + 0x5f, 0x6a, 0x0d, 0xa9, 0x00, 0x5f, 0x6b, 0x0b, + 0xc2, 0x00, 0x5f, 0x6c, 0x0d, 0xbd, 0x00, 0x5f, + 0x6d, 0x12, 0xb0, 0x00, 0x5f, 0x6f, 0x54, 0x11, + 0x00, 0x5f, 0x70, 0x09, 0x9c, 0x00, 0x5f, 0x71, + 0x04, 0xe8, 0x00, 0x5f, 0x72, 0x44, 0xcc, 0x00, + 0x5f, 0x73, 0x12, 0xb1, 0x00, 0x5f, 0x74, 0x54, + 0x12, 0x00, 0x5f, 0x75, 0x54, 0x13, 0x00, 0x5f, + 0x77, 0x12, 0xb2, 0x00, 0x5f, 0x78, 0x54, 0x14, + 0x00, 0x5f, 0x79, 0x0e, 0xfe, 0x00, 0x5f, 0x7a, + 0x54, 0x15, 0x00, 0x5f, 0x7c, 0x0d, 0x74, 0x00, + 0x5f, 0x7d, 0x41, 0xdb, 0x00, 0x5f, 0x7e, 0x44, + 0xcd, 0x00, 0x5f, 0x7f, 0x12, 0xb5, 0x00, 0x5f, + 0x80, 0x05, 0x1f, 0x00, 0x5f, 0x81, 0x0a, 0x50, + 0x00, 0x5f, 0x82, 0x12, 0xb4, 0x00, 0x5f, 0x83, + 0x12, 0xb3, 0x00, 0x5f, 0x84, 0x07, 0x18, 0x00, + 0x5f, 0x85, 0x0b, 0x34, 0x00, 0x5f, 0x87, 0x12, + 0xb9, 0x00, 0x5f, 0x88, 0x12, 0xb7, 0x00, 0x5f, + 0x89, 0x38, 0xbc, 0x00, 0x5f, 0x8a, 0x12, 0xb6, + 0x00, 0x5f, 0x8b, 0x0f, 0x6f, 0x00, 0x5f, 0x8c, + 0x07, 0x99, 0x00, 0x5f, 0x8d, 0x54, 0x16, 0x00, + 0x5f, 0x8f, 0x44, 0xce, 0x00, 0x5f, 0x90, 0x09, + 0x83, 0x00, 0x5f, 0x91, 0x12, 0xb8, 0x00, 0x5f, + 0x92, 0x0c, 0x46, 0x00, 0x5f, 0x93, 0x09, 0x48, + 0x00, 0x5f, 0x96, 0x54, 0x17, 0x00, 0x5f, 0x97, + 0x0c, 0x98, 0x00, 0x5f, 0x98, 0x12, 0xbc, 0x00, + 0x5f, 0x99, 0x12, 0xbb, 0x00, 0x5f, 0x9c, 0x38, + 0xbd, 0x00, 0x5f, 0x9d, 0x54, 0x18, 0x00, 0x5f, + 0x9e, 0x12, 0xba, 0x00, 0x5f, 0xa0, 0x12, 0xbd, + 0x00, 0x5f, 0xa1, 0x07, 0x9a, 0x00, 0x5f, 0xa2, + 0x44, 0xcf, 0x00, 0x5f, 0xa4, 0x38, 0xbf, 0x00, + 0x5f, 0xa7, 0x38, 0xbe, 0x00, 0x5f, 0xa8, 0x12, + 0xbe, 0x00, 0x5f, 0xa9, 0x0d, 0xee, 0x00, 0x5f, + 0xaa, 0x09, 0x65, 0x00, 0x5f, 0xab, 0x54, 0x19, + 0x00, 0x5f, 0xac, 0x4b, 0x9b, 0x00, 0x5f, 0xad, + 0x12, 0xbf, 0x00, 0x5f, 0xae, 0x0d, 0x8d, 0x00, + 0x5f, 0xaf, 0x38, 0xc0, 0x00, 0x5f, 0xb0, 0x54, + 0x1a, 0x00, 0x5f, 0xb1, 0x54, 0x1b, 0x00, 0x5f, + 0xb3, 0x0c, 0x99, 0x00, 0x5f, 0xb4, 0x0b, 0xc3, + 0x00, 0x5f, 0xb5, 0x34, 0x38, 0x00, 0x5f, 0xb7, + 0x21, 0x04, 0x00, 0x5f, 0xb8, 0x38, 0xc1, 0x00, + 0x5f, 0xb9, 0x0c, 0x2a, 0x00, 0x5f, 0xbc, 0x12, + 0xc0, 0x00, 0x5f, 0xbd, 0x06, 0x45, 0x00, 0x5f, + 0xc3, 0x09, 0xfa, 0x00, 0x5f, 0xc4, 0x38, 0xc2, + 0x00, 0x5f, 0xc5, 0x0d, 0x9e, 0x00, 0x5f, 0xc7, + 0x44, 0xd0, 0x00, 0x5f, 0xc8, 0x54, 0x1c, 0x00, + 0x5f, 0xc9, 0x38, 0xc3, 0x00, 0x5f, 0xcb, 0x44, + 0xd1, 0x00, 0x5f, 0xcc, 0x06, 0x33, 0x00, 0x5f, + 0xcd, 0x0c, 0xdc, 0x00, 0x5f, 0xd0, 0x54, 0x1d, + 0x00, 0x5f, 0xd1, 0x54, 0x1e, 0x00, 0x5f, 0xd2, + 0x44, 0xd2, 0x00, 0x5f, 0xd3, 0x44, 0xd3, 0x00, + 0x5f, 0xd4, 0x44, 0xd4, 0x00, 0x5f, 0xd6, 0x12, + 0xc1, 0x00, 0x5f, 0xd7, 0x08, 0xa4, 0x00, 0x5f, + 0xd8, 0x0e, 0x68, 0x00, 0x5f, 0xd9, 0x0e, 0x69, + 0x00, 0x5f, 0xdc, 0x05, 0x20, 0x00, 0x5f, 0xdd, + 0x12, 0xc6, 0x00, 0x5f, 0xde, 0x21, 0x05, 0x00, + 0x5f, 0xe0, 0x0b, 0xa7, 0x00, 0x5f, 0xe1, 0x38, + 0xc4, 0x00, 0x5f, 0xe2, 0x44, 0xd5, 0x00, 0x5f, + 0xe4, 0x12, 0xc3, 0x00, 0x5f, 0xe8, 0x54, 0x1f, + 0x00, 0x5f, 0xe9, 0x38, 0xc5, 0x00, 0x5f, 0xea, + 0x4b, 0x9c, 0x00, 0x5f, 0xeb, 0x05, 0x77, 0x00, + 0x5f, 0xec, 0x54, 0x20, 0x00, 0x5f, 0xed, 0x38, + 0xc6, 0x00, 0x5f, 0xee, 0x44, 0xd6, 0x00, 0x5f, + 0xef, 0x44, 0xd7, 0x00, 0x5f, 0xf0, 0x12, 0xf6, + 0x00, 0x5f, 0xf1, 0x12, 0xc5, 0x00, 0x5f, 0xf2, + 0x54, 0x21, 0x00, 0x5f, 0xf3, 0x44, 0xd8, 0x00, + 0x5f, 0xf5, 0x0c, 0xe6, 0x00, 0x5f, 0xf6, 0x54, + 0x22, 0x00, 0x5f, 0xf8, 0x12, 0xc4, 0x00, 0x5f, + 0xfa, 0x54, 0x23, 0x00, 0x5f, 0xfb, 0x12, 0xc2, + 0x00, 0x5f, 0xfc, 0x38, 0xc7, 0x00, 0x5f, 0xfd, + 0x08, 0x0c, 0x00, 0x5f, 0xff, 0x12, 0xc8, 0x00, + 0x60, 0x07, 0x4b, 0x9d, 0x00, 0x60, 0x0a, 0x54, + 0x24, 0x00, 0x60, 0x0d, 0x41, 0xdc, 0x00, 0x60, + 0x0e, 0x12, 0xce, 0x00, 0x60, 0x0f, 0x12, 0xd4, + 0x00, 0x60, 0x10, 0x12, 0xcc, 0x00, 0x60, 0x12, + 0x0c, 0x56, 0x00, 0x60, 0x13, 0x54, 0x25, 0x00, + 0x60, 0x14, 0x41, 0xdd, 0x00, 0x60, 0x15, 0x12, + 0xd1, 0x00, 0x60, 0x16, 0x0d, 0xcf, 0x00, 0x60, + 0x17, 0x38, 0xc8, 0x00, 0x60, 0x18, 0x41, 0xde, + 0x00, 0x60, 0x19, 0x12, 0xcb, 0x00, 0x60, 0x1a, + 0x38, 0xc9, 0x00, 0x60, 0x1b, 0x12, 0xd0, 0x00, + 0x60, 0x1c, 0x0f, 0xaf, 0x00, 0x60, 0x1d, 0x08, + 0xa5, 0x00, 0x60, 0x1f, 0x54, 0x26, 0x00, 0x60, + 0x20, 0x0b, 0x35, 0x00, 0x60, 0x21, 0x12, 0xc9, + 0x00, 0x60, 0x22, 0x44, 0xda, 0x00, 0x60, 0x24, + 0x44, 0xdb, 0x00, 0x60, 0x25, 0x06, 0x78, 0x00, + 0x60, 0x26, 0x12, 0xd3, 0x00, 0x60, 0x27, 0x0a, + 0x51, 0x00, 0x60, 0x28, 0x05, 0x07, 0x00, 0x60, + 0x29, 0x12, 0xcd, 0x00, 0x60, 0x2a, 0x05, 0x78, + 0x00, 0x60, 0x2b, 0x12, 0xd2, 0x00, 0x60, 0x2d, + 0x54, 0x27, 0x00, 0x60, 0x2f, 0x06, 0xa9, 0x00, + 0x60, 0x31, 0x12, 0xcf, 0x00, 0x60, 0x33, 0x38, + 0xca, 0x00, 0x60, 0x35, 0x41, 0xdf, 0x00, 0x60, + 0x3a, 0x12, 0xd5, 0x00, 0x60, 0x40, 0x54, 0x28, + 0x00, 0x60, 0x41, 0x12, 0xd7, 0x00, 0x60, 0x42, + 0x12, 0xe1, 0x00, 0x60, 0x43, 0x12, 0xdf, 0x00, + 0x60, 0x46, 0x12, 0xdc, 0x00, 0x60, 0x47, 0x41, + 0xe0, 0x00, 0x60, 0x48, 0x54, 0x29, 0x00, 0x60, + 0x49, 0x4b, 0x9e, 0x00, 0x60, 0x4a, 0x12, 0xdb, + 0x00, 0x60, 0x4b, 0x0f, 0xc0, 0x00, 0x60, 0x4c, + 0x44, 0xdd, 0x00, 0x60, 0x4d, 0x12, 0xdd, 0x00, + 0x60, 0x50, 0x06, 0xaa, 0x00, 0x60, 0x51, 0x54, + 0x2a, 0x00, 0x60, 0x52, 0x07, 0xc3, 0x00, 0x60, + 0x54, 0x4b, 0x9f, 0x00, 0x60, 0x55, 0x09, 0x84, + 0x00, 0x60, 0x56, 0x54, 0x2b, 0x00, 0x60, 0x57, + 0x54, 0x2c, 0x00, 0x60, 0x59, 0x12, 0xe4, 0x00, + 0x60, 0x5a, 0x12, 0xd6, 0x00, 0x60, 0x5d, 0x21, + 0x06, 0x00, 0x60, 0x5f, 0x12, 0xda, 0x00, 0x60, + 0x60, 0x12, 0xca, 0x00, 0x60, 0x61, 0x38, 0xcb, + 0x00, 0x60, 0x62, 0x05, 0x7a, 0x00, 0x60, 0x63, + 0x12, 0xde, 0x00, 0x60, 0x64, 0x12, 0xe0, 0x00, + 0x60, 0x65, 0x0b, 0x8f, 0x00, 0x60, 0x67, 0x4b, + 0xa0, 0x00, 0x60, 0x68, 0x08, 0x18, 0x00, 0x60, + 0x69, 0x05, 0x38, 0x00, 0x60, 0x6a, 0x12, 0xd8, + 0x00, 0x60, 0x6b, 0x12, 0xe3, 0x00, 0x60, 0x6c, + 0x12, 0xe2, 0x00, 0x60, 0x6d, 0x06, 0xab, 0x00, + 0x60, 0x6f, 0x0b, 0x09, 0x00, 0x60, 0x70, 0x05, + 0xc4, 0x00, 0x60, 0x71, 0x54, 0x2d, 0x00, 0x60, + 0x75, 0x07, 0x19, 0x00, 0x60, 0x77, 0x12, 0xd9, + 0x00, 0x60, 0x7e, 0x54, 0x2e, 0x00, 0x60, 0x7f, + 0x38, 0xcc, 0x00, 0x60, 0x81, 0x12, 0xe5, 0x00, + 0x60, 0x82, 0x54, 0x2f, 0x00, 0x60, 0x83, 0x12, + 0xe8, 0x00, 0x60, 0x84, 0x12, 0xea, 0x00, 0x60, + 0x85, 0x21, 0x07, 0x00, 0x60, 0x86, 0x54, 0x30, + 0x00, 0x60, 0x88, 0x54, 0x31, 0x00, 0x60, 0x89, + 0x08, 0xe9, 0x00, 0x60, 0x8a, 0x21, 0x08, 0x00, + 0x60, 0x8b, 0x12, 0xf0, 0x00, 0x60, 0x8c, 0x0c, + 0x0c, 0x00, 0x60, 0x8d, 0x12, 0xe6, 0x00, 0x60, + 0x8e, 0x54, 0x32, 0x00, 0x60, 0x91, 0x54, 0x33, + 0x00, 0x60, 0x92, 0x12, 0xee, 0x00, 0x60, 0x93, + 0x54, 0x34, 0x00, 0x60, 0x94, 0x34, 0x0e, 0x00, + 0x60, 0x95, 0x44, 0xde, 0x00, 0x60, 0x96, 0x12, + 0xec, 0x00, 0x60, 0x97, 0x12, 0xed, 0x00, 0x60, + 0x98, 0x54, 0x35, 0x00, 0x60, 0x9a, 0x12, 0xe9, + 0x00, 0x60, 0x9b, 0x12, 0xeb, 0x00, 0x60, 0x9d, + 0x41, 0xe1, 0x00, 0x60, 0x9e, 0x38, 0xcd, 0x00, + 0x60, 0x9f, 0x07, 0x9b, 0x00, 0x60, 0xa0, 0x0f, + 0x14, 0x00, 0x60, 0xa2, 0x54, 0x37, 0x00, 0x60, + 0xa3, 0x05, 0xf1, 0x00, 0x60, 0xa4, 0x38, 0xce, + 0x00, 0x60, 0xa5, 0x54, 0x38, 0x00, 0x60, 0xa6, + 0x04, 0xfb, 0x00, 0x60, 0xa7, 0x12, 0xef, 0x00, + 0x60, 0xa8, 0x44, 0xdf, 0x00, 0x60, 0xa9, 0x0c, + 0xf0, 0x00, 0x60, 0xaa, 0x04, 0x71, 0x00, 0x60, + 0xb0, 0x38, 0xcf, 0x00, 0x60, 0xb1, 0x44, 0xe1, + 0x00, 0x60, 0xb2, 0x0d, 0x75, 0x00, 0x60, 0xb3, + 0x12, 0xc7, 0x00, 0x60, 0xb4, 0x12, 0xf5, 0x00, + 0x60, 0xb5, 0x12, 0xf9, 0x00, 0x60, 0xb6, 0x0e, + 0xf1, 0x00, 0x60, 0xb7, 0x54, 0x39, 0x00, 0x60, + 0xb8, 0x12, 0xf2, 0x00, 0x60, 0xbb, 0x4b, 0xa1, + 0x00, 0x60, 0xbc, 0x0c, 0x63, 0x00, 0x60, 0xbd, + 0x12, 0xf7, 0x00, 0x60, 0xbe, 0x44, 0xe2, 0x00, + 0x60, 0xc2, 0x54, 0x3a, 0x00, 0x60, 0xc4, 0x4b, + 0xa2, 0x00, 0x60, 0xc5, 0x09, 0xd8, 0x00, 0x60, + 0xc6, 0x12, 0xf8, 0x00, 0x60, 0xc7, 0x0c, 0xaf, + 0x00, 0x60, 0xc8, 0x44, 0xe3, 0x00, 0x60, 0xc9, + 0x54, 0x3b, 0x00, 0x60, 0xca, 0x54, 0x3c, 0x00, + 0x60, 0xcb, 0x38, 0xd0, 0x00, 0x60, 0xce, 0x54, + 0x3d, 0x00, 0x60, 0xcf, 0x54, 0x3e, 0x00, 0x60, + 0xd1, 0x0f, 0xed, 0x00, 0x60, 0xd3, 0x12, 0xf4, + 0x00, 0x60, 0xd4, 0x41, 0xe2, 0x00, 0x60, 0xd5, + 0x21, 0x0a, 0x00, 0x60, 0xd8, 0x12, 0xfa, 0x00, + 0x60, 0xd9, 0x44, 0xe4, 0x00, 0x60, 0xda, 0x08, + 0x0d, 0x00, 0x60, 0xdb, 0x38, 0xd1, 0x00, 0x60, + 0xdc, 0x0a, 0x6f, 0x00, 0x60, 0xdd, 0x41, 0xe3, + 0x00, 0x60, 0xde, 0x21, 0x09, 0x00, 0x60, 0xdf, + 0x04, 0x98, 0x00, 0x60, 0xe0, 0x12, 0xf3, 0x00, + 0x60, 0xe1, 0x12, 0xf1, 0x00, 0x60, 0xe2, 0x54, + 0x3f, 0x00, 0x60, 0xe3, 0x0a, 0xdc, 0x00, 0x60, + 0xe5, 0x54, 0x40, 0x00, 0x60, 0xe7, 0x12, 0xe7, + 0x00, 0x60, 0xe8, 0x08, 0x82, 0x00, 0x60, 0xee, + 0x44, 0xe5, 0x00, 0x60, 0xf0, 0x0b, 0x26, 0x00, + 0x60, 0xf1, 0x13, 0x06, 0x00, 0x60, 0xf2, 0x21, + 0x0c, 0x00, 0x60, 0xf3, 0x0a, 0xdd, 0x00, 0x60, + 0xf4, 0x13, 0x01, 0x00, 0x60, 0xf5, 0x44, 0xe6, + 0x00, 0x60, 0xf6, 0x12, 0xfe, 0x00, 0x60, 0xf7, + 0x12, 0xff, 0x00, 0x60, 0xf8, 0x38, 0xd2, 0x00, + 0x60, 0xf9, 0x09, 0x12, 0x00, 0x60, 0xfa, 0x13, + 0x02, 0x00, 0x60, 0xfb, 0x13, 0x05, 0x00, 0x60, + 0xfc, 0x54, 0x41, 0x00, 0x60, 0xfd, 0x4b, 0xa3, + 0x00, 0x61, 0x00, 0x13, 0x00, 0x00, 0x61, 0x01, + 0x09, 0x2f, 0x00, 0x61, 0x02, 0x54, 0x42, 0x00, + 0x61, 0x03, 0x13, 0x03, 0x00, 0x61, 0x06, 0x12, + 0xfd, 0x00, 0x61, 0x07, 0x54, 0x43, 0x00, 0x61, + 0x08, 0x0f, 0x08, 0x00, 0x61, 0x09, 0x0f, 0x07, + 0x00, 0x61, 0x0a, 0x4b, 0xa4, 0x00, 0x61, 0x0c, + 0x54, 0x44, 0x00, 0x61, 0x0d, 0x13, 0x07, 0x00, + 0x61, 0x0e, 0x13, 0x08, 0x00, 0x61, 0x0f, 0x04, + 0x99, 0x00, 0x61, 0x10, 0x44, 0xe7, 0x00, 0x61, + 0x11, 0x21, 0x0d, 0x00, 0x61, 0x12, 0x38, 0xd3, + 0x00, 0x61, 0x13, 0x38, 0xd4, 0x00, 0x61, 0x14, + 0x38, 0xd5, 0x00, 0x61, 0x15, 0x12, 0xfc, 0x00, + 0x61, 0x16, 0x4b, 0xa5, 0x00, 0x61, 0x17, 0x54, + 0x45, 0x00, 0x61, 0x19, 0x44, 0xe8, 0x00, 0x61, + 0x1a, 0x06, 0xea, 0x00, 0x61, 0x1b, 0x04, 0x6a, + 0x00, 0x61, 0x1c, 0x38, 0xd6, 0x00, 0x61, 0x1e, + 0x44, 0xe9, 0x00, 0x61, 0x1f, 0x05, 0xf2, 0x00, + 0x61, 0x20, 0x21, 0x0b, 0x00, 0x61, 0x21, 0x13, + 0x04, 0x00, 0x61, 0x22, 0x54, 0x46, 0x00, 0x61, + 0x27, 0x13, 0x0c, 0x00, 0x61, 0x28, 0x13, 0x0b, + 0x00, 0x61, 0x2a, 0x4b, 0xa6, 0x00, 0x61, 0x2b, + 0x41, 0xe4, 0x00, 0x61, 0x2c, 0x13, 0x10, 0x00, + 0x61, 0x30, 0x21, 0x0f, 0x00, 0x61, 0x31, 0x54, + 0x47, 0x00, 0x61, 0x34, 0x13, 0x11, 0x00, 0x61, + 0x35, 0x54, 0x48, 0x00, 0x61, 0x36, 0x4b, 0xa7, + 0x00, 0x61, 0x37, 0x21, 0x0e, 0x00, 0x61, 0x39, + 0x54, 0x49, 0x00, 0x61, 0x3a, 0x44, 0xea, 0x00, + 0x61, 0x3c, 0x13, 0x0f, 0x00, 0x61, 0x3d, 0x13, + 0x12, 0x00, 0x61, 0x3e, 0x13, 0x0a, 0x00, 0x61, + 0x3f, 0x13, 0x0e, 0x00, 0x61, 0x41, 0x44, 0xec, + 0x00, 0x61, 0x42, 0x13, 0x13, 0x00, 0x61, 0x44, + 0x13, 0x14, 0x00, 0x61, 0x45, 0x54, 0x4a, 0x00, + 0x61, 0x46, 0x44, 0xed, 0x00, 0x61, 0x47, 0x13, + 0x09, 0x00, 0x61, 0x48, 0x08, 0xca, 0x00, 0x61, + 0x49, 0x54, 0x4b, 0x00, 0x61, 0x4a, 0x13, 0x0d, + 0x00, 0x61, 0x4b, 0x0b, 0x36, 0x00, 0x61, 0x4c, + 0x07, 0xc4, 0x00, 0x61, 0x4d, 0x12, 0xfb, 0x00, + 0x61, 0x4e, 0x09, 0xfb, 0x00, 0x61, 0x53, 0x13, + 0x21, 0x00, 0x61, 0x55, 0x0e, 0x39, 0x00, 0x61, + 0x58, 0x13, 0x17, 0x00, 0x61, 0x59, 0x13, 0x18, + 0x00, 0x61, 0x5a, 0x13, 0x19, 0x00, 0x61, 0x5d, + 0x13, 0x20, 0x00, 0x61, 0x5e, 0x4b, 0xa8, 0x00, + 0x61, 0x5f, 0x13, 0x1f, 0x00, 0x61, 0x60, 0x44, + 0xee, 0x00, 0x61, 0x62, 0x0e, 0xab, 0x00, 0x61, + 0x63, 0x05, 0xf3, 0x00, 0x61, 0x64, 0x4b, 0xa9, + 0x00, 0x61, 0x65, 0x13, 0x1d, 0x00, 0x61, 0x67, + 0x07, 0x1b, 0x00, 0x61, 0x68, 0x05, 0x92, 0x00, + 0x61, 0x6b, 0x13, 0x1a, 0x00, 0x61, 0x6c, 0x54, + 0x4c, 0x00, 0x61, 0x6e, 0x0f, 0x80, 0x00, 0x61, + 0x6f, 0x13, 0x1c, 0x00, 0x61, 0x70, 0x04, 0x9a, + 0x00, 0x61, 0x71, 0x13, 0x1e, 0x00, 0x61, 0x72, + 0x54, 0x4d, 0x00, 0x61, 0x73, 0x13, 0x15, 0x00, + 0x61, 0x74, 0x13, 0x1b, 0x00, 0x61, 0x75, 0x13, + 0x22, 0x00, 0x61, 0x76, 0x07, 0x1a, 0x00, 0x61, + 0x77, 0x13, 0x16, 0x00, 0x61, 0x78, 0x54, 0x4e, + 0x00, 0x61, 0x7b, 0x4b, 0xaa, 0x00, 0x61, 0x7c, + 0x38, 0xd7, 0x00, 0x61, 0x7d, 0x4b, 0xab, 0x00, + 0x61, 0x7e, 0x0f, 0x47, 0x00, 0x61, 0x7f, 0x4b, + 0xac, 0x00, 0x61, 0x80, 0x54, 0x4f, 0x00, 0x61, + 0x81, 0x54, 0x50, 0x00, 0x61, 0x82, 0x0f, 0x15, + 0x00, 0x61, 0x83, 0x54, 0x51, 0x00, 0x61, 0x84, + 0x54, 0x52, 0x00, 0x61, 0x87, 0x13, 0x25, 0x00, + 0x61, 0x8a, 0x13, 0x29, 0x00, 0x61, 0x8b, 0x54, + 0x53, 0x00, 0x61, 0x8d, 0x38, 0xd8, 0x00, 0x61, + 0x8e, 0x34, 0x33, 0x00, 0x61, 0x90, 0x0f, 0xc1, + 0x00, 0x61, 0x91, 0x13, 0x2a, 0x00, 0x61, 0x92, + 0x44, 0xf0, 0x00, 0x61, 0x93, 0x44, 0xf1, 0x00, + 0x61, 0x94, 0x13, 0x27, 0x00, 0x61, 0x96, 0x13, + 0x24, 0x00, 0x61, 0x97, 0x44, 0xf2, 0x00, 0x61, + 0x98, 0x21, 0x10, 0x00, 0x61, 0x99, 0x13, 0x23, + 0x00, 0x61, 0x9a, 0x13, 0x28, 0x00, 0x61, 0x9c, + 0x54, 0x54, 0x00, 0x61, 0x9d, 0x4b, 0xad, 0x00, + 0x61, 0x9f, 0x38, 0xd9, 0x00, 0x61, 0xa0, 0x54, + 0x55, 0x00, 0x61, 0xa4, 0x0e, 0x00, 0x00, 0x61, + 0xa5, 0x44, 0xf3, 0x00, 0x61, 0xa7, 0x0c, 0x8c, + 0x00, 0x61, 0xa8, 0x38, 0xda, 0x00, 0x61, 0xa9, + 0x07, 0x1c, 0x00, 0x61, 0xaa, 0x54, 0x56, 0x00, + 0x61, 0xab, 0x13, 0x2b, 0x00, 0x61, 0xac, 0x13, + 0x26, 0x00, 0x61, 0xad, 0x44, 0xf4, 0x00, 0x61, + 0xae, 0x13, 0x2c, 0x00, 0x61, 0xb2, 0x07, 0x51, + 0x00, 0x61, 0xb6, 0x05, 0x31, 0x00, 0x61, 0xb8, + 0x4b, 0xae, 0x00, 0x61, 0xb9, 0x41, 0xe6, 0x00, + 0x61, 0xba, 0x13, 0x34, 0x00, 0x61, 0xbc, 0x41, + 0xe5, 0x00, 0x61, 0xbe, 0x05, 0xf4, 0x00, 0x61, + 0xc0, 0x54, 0x57, 0x00, 0x61, 0xc1, 0x54, 0x58, + 0x00, 0x61, 0xc2, 0x38, 0xdb, 0x00, 0x61, 0xc3, + 0x13, 0x32, 0x00, 0x61, 0xc6, 0x13, 0x33, 0x00, + 0x61, 0xc7, 0x08, 0x19, 0x00, 0x61, 0xc8, 0x13, + 0x31, 0x00, 0x61, 0xc9, 0x13, 0x2f, 0x00, 0x61, + 0xca, 0x13, 0x2e, 0x00, 0x61, 0xcb, 0x13, 0x35, + 0x00, 0x61, 0xcc, 0x13, 0x2d, 0x00, 0x61, 0xcd, + 0x13, 0x37, 0x00, 0x61, 0xce, 0x54, 0x59, 0x00, + 0x61, 0xcf, 0x54, 0x5a, 0x00, 0x61, 0xd0, 0x05, + 0x7b, 0x00, 0x61, 0xd5, 0x44, 0xf6, 0x00, 0x61, + 0xdc, 0x4b, 0xaf, 0x00, 0x61, 0xdd, 0x44, 0xf7, + 0x00, 0x61, 0xde, 0x54, 0x5b, 0x00, 0x61, 0xdf, + 0x38, 0xdc, 0x00, 0x61, 0xe1, 0x54, 0x5c, 0x00, + 0x61, 0xe2, 0x4b, 0xb0, 0x00, 0x61, 0xe3, 0x13, + 0x39, 0x00, 0x61, 0xe5, 0x4b, 0xb1, 0x00, 0x61, + 0xe6, 0x13, 0x38, 0x00, 0x61, 0xe7, 0x54, 0x5d, + 0x00, 0x61, 0xe8, 0x4b, 0xb2, 0x00, 0x61, 0xe9, + 0x54, 0x5e, 0x00, 0x61, 0xec, 0x54, 0x5f, 0x00, + 0x61, 0xed, 0x54, 0x60, 0x00, 0x61, 0xef, 0x54, + 0x61, 0x00, 0x61, 0xf2, 0x0b, 0xc4, 0x00, 0x61, + 0xf4, 0x13, 0x3c, 0x00, 0x61, 0xf5, 0x44, 0xf8, + 0x00, 0x61, 0xf6, 0x13, 0x3a, 0x00, 0x61, 0xf7, + 0x13, 0x30, 0x00, 0x61, 0xf8, 0x07, 0x52, 0x00, + 0x61, 0xfa, 0x13, 0x3b, 0x00, 0x61, 0xfc, 0x13, + 0x3f, 0x00, 0x61, 0xfd, 0x13, 0x3e, 0x00, 0x61, + 0xfe, 0x13, 0x40, 0x00, 0x61, 0xff, 0x13, 0x3d, + 0x00, 0x62, 0x00, 0x13, 0x41, 0x00, 0x62, 0x01, + 0x54, 0x62, 0x00, 0x62, 0x03, 0x54, 0x63, 0x00, + 0x62, 0x04, 0x4b, 0xb3, 0x00, 0x62, 0x07, 0x4b, + 0xb4, 0x00, 0x62, 0x08, 0x13, 0x42, 0x00, 0x62, + 0x09, 0x13, 0x43, 0x00, 0x62, 0x0a, 0x0e, 0x3a, + 0x00, 0x62, 0x0c, 0x13, 0x45, 0x00, 0x62, 0x0d, + 0x13, 0x44, 0x00, 0x62, 0x0e, 0x09, 0x49, 0x00, + 0x62, 0x10, 0x0a, 0x52, 0x00, 0x62, 0x11, 0x05, + 0x66, 0x00, 0x62, 0x12, 0x05, 0x7c, 0x00, 0x62, + 0x13, 0x21, 0x11, 0x00, 0x62, 0x14, 0x13, 0x46, + 0x00, 0x62, 0x15, 0x38, 0xdd, 0x00, 0x62, 0x16, + 0x04, 0x83, 0x00, 0x62, 0x1a, 0x0a, 0x70, 0x00, + 0x62, 0x1b, 0x13, 0x47, 0x00, 0x62, 0x1c, 0x54, + 0x64, 0x00, 0x62, 0x1d, 0x1a, 0x64, 0x00, 0x62, + 0x1e, 0x13, 0x48, 0x00, 0x62, 0x1f, 0x07, 0x37, + 0x00, 0x62, 0x20, 0x54, 0x65, 0x00, 0x62, 0x21, + 0x13, 0x49, 0x00, 0x62, 0x22, 0x41, 0xe7, 0x00, + 0x62, 0x23, 0x44, 0xfa, 0x00, 0x62, 0x26, 0x0a, + 0x93, 0x00, 0x62, 0x27, 0x54, 0x66, 0x00, 0x62, + 0x29, 0x38, 0xde, 0x00, 0x62, 0x2a, 0x13, 0x4a, + 0x00, 0x62, 0x2b, 0x54, 0x67, 0x00, 0x62, 0x2e, + 0x13, 0x4b, 0x00, 0x62, 0x2f, 0x06, 0x54, 0x00, + 0x62, 0x30, 0x13, 0x4c, 0x00, 0x62, 0x31, 0x4b, + 0xb5, 0x00, 0x62, 0x32, 0x13, 0x4d, 0x00, 0x62, + 0x33, 0x13, 0x4e, 0x00, 0x62, 0x34, 0x0b, 0x37, + 0x00, 0x62, 0x36, 0x35, 0xbd, 0x00, 0x62, 0x38, + 0x07, 0x81, 0x00, 0x62, 0x39, 0x4b, 0xb6, 0x00, + 0x62, 0x3b, 0x0e, 0xed, 0x00, 0x62, 0x3d, 0x4b, + 0xb7, 0x00, 0x62, 0x3e, 0x34, 0x4e, 0x00, 0x62, + 0x3f, 0x0e, 0x6a, 0x00, 0x62, 0x40, 0x09, 0x74, + 0x00, 0x62, 0x41, 0x13, 0x4f, 0x00, 0x62, 0x42, + 0x54, 0x68, 0x00, 0x62, 0x43, 0x38, 0xdf, 0x00, + 0x62, 0x44, 0x54, 0x69, 0x00, 0x62, 0x46, 0x38, + 0xe0, 0x00, 0x62, 0x47, 0x0a, 0x94, 0x00, 0x62, + 0x48, 0x1b, 0x1a, 0x00, 0x62, 0x49, 0x0d, 0x76, + 0x00, 0x62, 0x4b, 0x09, 0x16, 0x00, 0x62, 0x4c, + 0x38, 0xe1, 0x00, 0x62, 0x4d, 0x08, 0x3d, 0x00, + 0x62, 0x4e, 0x13, 0x50, 0x00, 0x62, 0x50, 0x54, + 0x6a, 0x00, 0x62, 0x51, 0x38, 0xe2, 0x00, 0x62, + 0x52, 0x44, 0xfb, 0x00, 0x62, 0x53, 0x0b, 0x27, + 0x00, 0x62, 0x54, 0x54, 0x6b, 0x00, 0x62, 0x55, + 0x0d, 0xf7, 0x00, 0x62, 0x56, 0x38, 0xe3, 0x00, + 0x62, 0x58, 0x0b, 0x51, 0x00, 0x62, 0x5a, 0x41, + 0xe8, 0x00, 0x62, 0x5b, 0x13, 0x53, 0x00, 0x62, + 0x5c, 0x54, 0x6c, 0x00, 0x62, 0x5e, 0x13, 0x51, + 0x00, 0x62, 0x60, 0x13, 0x54, 0x00, 0x62, 0x61, + 0x44, 0xfc, 0x00, 0x62, 0x63, 0x13, 0x52, 0x00, + 0x62, 0x64, 0x44, 0xfd, 0x00, 0x62, 0x68, 0x13, + 0x55, 0x00, 0x62, 0x6d, 0x44, 0xff, 0x00, 0x62, + 0x6e, 0x0e, 0x01, 0x00, 0x62, 0x6f, 0x41, 0xe9, + 0x00, 0x62, 0x71, 0x04, 0x7b, 0x00, 0x62, 0x73, + 0x45, 0x00, 0x00, 0x62, 0x76, 0x0d, 0xd0, 0x00, + 0x62, 0x79, 0x0d, 0x77, 0x00, 0x62, 0x7a, 0x4b, + 0xb8, 0x00, 0x62, 0x7b, 0x44, 0xfe, 0x00, 0x62, + 0x7c, 0x13, 0x56, 0x00, 0x62, 0x7d, 0x54, 0x6d, + 0x00, 0x62, 0x7e, 0x13, 0x59, 0x00, 0x62, 0x7f, + 0x09, 0x9d, 0x00, 0x62, 0x80, 0x06, 0x55, 0x00, + 0x62, 0x82, 0x13, 0x57, 0x00, 0x62, 0x83, 0x13, + 0x5e, 0x00, 0x62, 0x84, 0x09, 0x9e, 0x00, 0x62, + 0x85, 0x35, 0xc5, 0x00, 0x62, 0x89, 0x13, 0x58, + 0x00, 0x62, 0x8a, 0x0c, 0xfa, 0x00, 0x62, 0x8d, + 0x54, 0x6e, 0x00, 0x62, 0x8e, 0x54, 0x6f, 0x00, + 0x62, 0x8f, 0x54, 0x70, 0x00, 0x62, 0x90, 0x4b, + 0xb9, 0x00, 0x62, 0x91, 0x0f, 0x48, 0x00, 0x62, + 0x92, 0x13, 0x5a, 0x00, 0x62, 0x93, 0x13, 0x5b, + 0x00, 0x62, 0x94, 0x13, 0x5f, 0x00, 0x62, 0x95, + 0x0c, 0x64, 0x00, 0x62, 0x96, 0x13, 0x5c, 0x00, + 0x62, 0x97, 0x07, 0xc5, 0x00, 0x62, 0x98, 0x0a, + 0x82, 0x00, 0x62, 0x99, 0x45, 0x01, 0x00, 0x62, + 0x9b, 0x13, 0x6d, 0x00, 0x62, 0x9c, 0x0d, 0x48, + 0x00, 0x62, 0x9e, 0x0b, 0x52, 0x00, 0x62, 0xa6, + 0x21, 0x12, 0x00, 0x62, 0xa8, 0x4b, 0xba, 0x00, + 0x62, 0xab, 0x0d, 0x78, 0x00, 0x62, 0xac, 0x13, + 0xb2, 0x00, 0x62, 0xb1, 0x0e, 0x4a, 0x00, 0x62, + 0xb3, 0x54, 0x71, 0x00, 0x62, 0xb5, 0x0c, 0x0d, + 0x00, 0x62, 0xb6, 0x54, 0x72, 0x00, 0x62, 0xb7, + 0x54, 0x73, 0x00, 0x62, 0xb9, 0x0e, 0xa3, 0x00, + 0x62, 0xba, 0x54, 0x74, 0x00, 0x62, 0xbb, 0x13, + 0x62, 0x00, 0x62, 0xbc, 0x05, 0x21, 0x00, 0x62, + 0xbd, 0x0b, 0xa8, 0x00, 0x62, 0xbe, 0x54, 0x75, + 0x00, 0x62, 0xbf, 0x54, 0x76, 0x00, 0x62, 0xc2, + 0x13, 0x6b, 0x00, 0x62, 0xc4, 0x38, 0xe4, 0x00, + 0x62, 0xc5, 0x0b, 0x72, 0x00, 0x62, 0xc6, 0x13, + 0x65, 0x00, 0x62, 0xc7, 0x13, 0x6c, 0x00, 0x62, + 0xc8, 0x13, 0x67, 0x00, 0x62, 0xc9, 0x13, 0x6e, + 0x00, 0x62, 0xca, 0x13, 0x6a, 0x00, 0x62, 0xcc, + 0x13, 0x69, 0x00, 0x62, 0xcd, 0x0d, 0x25, 0x00, + 0x62, 0xce, 0x54, 0x77, 0x00, 0x62, 0xcf, 0x13, + 0x63, 0x00, 0x62, 0xd0, 0x05, 0x7d, 0x00, 0x62, + 0xd1, 0x13, 0x61, 0x00, 0x62, 0xd2, 0x06, 0x8b, + 0x00, 0x62, 0xd3, 0x0b, 0x53, 0x00, 0x62, 0xd4, + 0x37, 0x31, 0x00, 0x62, 0xd5, 0x45, 0x02, 0x00, + 0x62, 0xd6, 0x41, 0xea, 0x00, 0x62, 0xd7, 0x13, + 0x60, 0x00, 0x62, 0xd8, 0x07, 0xc6, 0x00, 0x62, + 0xd9, 0x0a, 0x7f, 0x00, 0x62, 0xda, 0x4b, 0xbb, + 0x00, 0x62, 0xdb, 0x09, 0x9f, 0x00, 0x62, 0xdc, + 0x13, 0x68, 0x00, 0x62, 0xdd, 0x0d, 0x08, 0x00, + 0x62, 0xe0, 0x06, 0x8c, 0x00, 0x62, 0xe1, 0x05, + 0xa6, 0x00, 0x62, 0xea, 0x54, 0x78, 0x00, 0x62, + 0xec, 0x05, 0xc5, 0x00, 0x62, 0xed, 0x09, 0xe7, + 0x00, 0x62, 0xee, 0x13, 0x70, 0x00, 0x62, 0xef, + 0x13, 0x75, 0x00, 0x62, 0xf1, 0x13, 0x71, 0x00, + 0x62, 0xf2, 0x54, 0x79, 0x00, 0x62, 0xf3, 0x07, + 0x53, 0x00, 0x62, 0xf4, 0x4b, 0xbc, 0x00, 0x62, + 0xf5, 0x13, 0x76, 0x00, 0x62, 0xf6, 0x08, 0x70, + 0x00, 0x62, 0xf7, 0x07, 0xfb, 0x00, 0x62, 0xfc, + 0x38, 0xe5, 0x00, 0x62, 0xfd, 0x45, 0x04, 0x00, + 0x62, 0xfe, 0x09, 0x30, 0x00, 0x62, 0xff, 0x13, + 0x64, 0x00, 0x63, 0x01, 0x08, 0xcb, 0x00, 0x63, + 0x02, 0x13, 0x73, 0x00, 0x63, 0x03, 0x45, 0x05, + 0x00, 0x63, 0x04, 0x54, 0x7a, 0x00, 0x63, 0x07, + 0x08, 0xa6, 0x00, 0x63, 0x08, 0x13, 0x74, 0x00, + 0x63, 0x09, 0x04, 0x88, 0x00, 0x63, 0x0a, 0x38, + 0xe6, 0x00, 0x63, 0x0b, 0x54, 0x7b, 0x00, 0x63, + 0x0c, 0x13, 0x6f, 0x00, 0x63, 0x0d, 0x38, 0xe7, + 0x00, 0x63, 0x10, 0x45, 0x06, 0x00, 0x63, 0x11, + 0x0b, 0xc5, 0x00, 0x63, 0x13, 0x54, 0x7c, 0x00, + 0x63, 0x16, 0x4b, 0xbd, 0x00, 0x63, 0x18, 0x38, + 0xe8, 0x00, 0x63, 0x19, 0x06, 0x8d, 0x00, 0x63, + 0x1b, 0x37, 0x37, 0x00, 0x63, 0x1f, 0x06, 0xac, + 0x00, 0x63, 0x27, 0x13, 0x72, 0x00, 0x63, 0x28, + 0x04, 0x6b, 0x00, 0x63, 0x29, 0x54, 0x7d, 0x00, + 0x63, 0x2a, 0x4b, 0xbe, 0x00, 0x63, 0x2b, 0x08, + 0x33, 0x00, 0x63, 0x2d, 0x54, 0x7e, 0x00, 0x63, + 0x2f, 0x09, 0xfc, 0x00, 0x63, 0x32, 0x45, 0x09, + 0x00, 0x63, 0x35, 0x45, 0x0a, 0x00, 0x63, 0x36, + 0x4b, 0xbf, 0x00, 0x63, 0x39, 0x38, 0xe9, 0x00, + 0x63, 0x3a, 0x0c, 0x0e, 0x00, 0x63, 0x3b, 0x45, + 0x0b, 0x00, 0x63, 0x3c, 0x45, 0x0c, 0x00, 0x63, + 0x3d, 0x0d, 0x68, 0x00, 0x63, 0x3e, 0x13, 0x78, + 0x00, 0x63, 0x3f, 0x0a, 0xe0, 0x00, 0x63, 0x41, + 0x45, 0x0d, 0x00, 0x63, 0x42, 0x38, 0xea, 0x00, + 0x63, 0x43, 0x38, 0xeb, 0x00, 0x63, 0x44, 0x45, + 0x0e, 0x00, 0x63, 0x46, 0x4b, 0xc0, 0x00, 0x63, + 0x49, 0x0b, 0x0a, 0x00, 0x63, 0x4a, 0x54, 0x7f, + 0x00, 0x63, 0x4b, 0x4b, 0xc1, 0x00, 0x63, 0x4c, + 0x08, 0x79, 0x00, 0x63, 0x4d, 0x13, 0x79, 0x00, + 0x63, 0x4e, 0x45, 0x0f, 0x00, 0x63, 0x4f, 0x13, + 0x7b, 0x00, 0x63, 0x50, 0x13, 0x77, 0x00, 0x63, + 0x52, 0x54, 0x80, 0x00, 0x63, 0x53, 0x4b, 0xc2, + 0x00, 0x63, 0x54, 0x54, 0x81, 0x00, 0x63, 0x55, + 0x0e, 0x31, 0x00, 0x63, 0x57, 0x0b, 0xd9, 0x00, + 0x63, 0x58, 0x54, 0x82, 0x00, 0x63, 0x59, 0x45, + 0x11, 0x00, 0x63, 0x5b, 0x54, 0x83, 0x00, 0x63, + 0x5c, 0x0a, 0xde, 0x00, 0x63, 0x65, 0x38, 0xec, + 0x00, 0x63, 0x66, 0x54, 0x84, 0x00, 0x63, 0x67, + 0x0e, 0x4b, 0x00, 0x63, 0x68, 0x08, 0xfa, 0x00, + 0x63, 0x69, 0x13, 0x87, 0x00, 0x63, 0x6b, 0x13, + 0x86, 0x00, 0x63, 0x6c, 0x45, 0x14, 0x00, 0x63, + 0x6d, 0x54, 0x85, 0x00, 0x63, 0x6e, 0x0a, 0x3e, + 0x00, 0x63, 0x71, 0x4b, 0xc3, 0x00, 0x63, 0x72, + 0x07, 0x54, 0x00, 0x63, 0x74, 0x38, 0xed, 0x00, + 0x63, 0x75, 0x4b, 0xc4, 0x00, 0x63, 0x76, 0x13, + 0x80, 0x00, 0x63, 0x77, 0x09, 0xa1, 0x00, 0x63, + 0x78, 0x54, 0x86, 0x00, 0x63, 0x7a, 0x0c, 0xc0, + 0x00, 0x63, 0x7b, 0x0c, 0xe7, 0x00, 0x63, 0x7c, + 0x41, 0xeb, 0x00, 0x63, 0x7d, 0x38, 0xee, 0x00, + 0x63, 0x7f, 0x4b, 0xc5, 0x00, 0x63, 0x80, 0x13, + 0x7e, 0x00, 0x63, 0x82, 0x4b, 0xc6, 0x00, 0x63, + 0x83, 0x0a, 0xdf, 0x00, 0x63, 0x84, 0x38, 0xef, + 0x00, 0x63, 0x87, 0x38, 0xf0, 0x00, 0x63, 0x88, + 0x09, 0x24, 0x00, 0x63, 0x89, 0x13, 0x83, 0x00, + 0x63, 0x8a, 0x4b, 0xc7, 0x00, 0x63, 0x8c, 0x09, + 0xa0, 0x00, 0x63, 0x8e, 0x13, 0x7d, 0x00, 0x63, + 0x8f, 0x13, 0x82, 0x00, 0x63, 0x90, 0x38, 0xf1, + 0x00, 0x63, 0x92, 0x0d, 0x09, 0x00, 0x63, 0x94, + 0x45, 0x17, 0x00, 0x63, 0x95, 0x54, 0x87, 0x00, + 0x63, 0x96, 0x13, 0x7c, 0x00, 0x63, 0x98, 0x06, + 0xf7, 0x00, 0x63, 0x99, 0x45, 0x15, 0x00, 0x63, + 0x9a, 0x54, 0x88, 0x00, 0x63, 0x9b, 0x05, 0xbb, + 0x00, 0x63, 0x9e, 0x38, 0xf2, 0x00, 0x63, 0x9f, + 0x13, 0x84, 0x00, 0x63, 0xa0, 0x0f, 0x73, 0x00, + 0x63, 0xa1, 0x08, 0x3e, 0x00, 0x63, 0xa2, 0x0b, + 0x73, 0x00, 0x63, 0xa3, 0x13, 0x81, 0x00, 0x63, + 0xa4, 0x54, 0x89, 0x00, 0x63, 0xa5, 0x0a, 0x80, + 0x00, 0x63, 0xa6, 0x54, 0x8a, 0x00, 0x63, 0xa7, + 0x07, 0xc7, 0x00, 0x63, 0xa8, 0x0a, 0x2a, 0x00, + 0x63, 0xa9, 0x05, 0x08, 0x00, 0x63, 0xaa, 0x0a, + 0xbe, 0x00, 0x63, 0xab, 0x13, 0x7f, 0x00, 0x63, + 0xac, 0x06, 0x5f, 0x00, 0x63, 0xad, 0x54, 0x8b, + 0x00, 0x63, 0xae, 0x4b, 0xc8, 0x00, 0x63, 0xaf, + 0x4b, 0xc9, 0x00, 0x63, 0xb2, 0x07, 0x1d, 0x00, + 0x63, 0xb4, 0x0b, 0xeb, 0x00, 0x63, 0xb5, 0x13, + 0x85, 0x00, 0x63, 0xbb, 0x0a, 0xe1, 0x00, 0x63, + 0xbd, 0x45, 0x18, 0x00, 0x63, 0xbe, 0x13, 0x88, + 0x00, 0x63, 0xc0, 0x13, 0x8a, 0x00, 0x63, 0xc1, + 0x54, 0x8c, 0x00, 0x63, 0xc3, 0x0b, 0x17, 0x00, + 0x63, 0xc4, 0x13, 0x90, 0x00, 0x63, 0xc5, 0x54, + 0x8d, 0x00, 0x63, 0xc6, 0x13, 0x8b, 0x00, 0x63, + 0xc8, 0x54, 0x8e, 0x00, 0x63, 0xc9, 0x13, 0x8d, + 0x00, 0x63, 0xce, 0x54, 0x8f, 0x00, 0x63, 0xcf, + 0x0d, 0xb3, 0x00, 0x63, 0xd0, 0x0c, 0x0f, 0x00, + 0x63, 0xd1, 0x38, 0xf3, 0x00, 0x63, 0xd2, 0x13, + 0x8e, 0x00, 0x63, 0xd3, 0x54, 0x90, 0x00, 0x63, + 0xd4, 0x45, 0x19, 0x00, 0x63, 0xd5, 0x45, 0x1a, + 0x00, 0x63, 0xd6, 0x0f, 0x16, 0x00, 0x63, 0xda, + 0x0f, 0x32, 0x00, 0x63, 0xdb, 0x05, 0xf5, 0x00, + 0x63, 0xdc, 0x38, 0xf4, 0x00, 0x63, 0xe0, 0x45, + 0x1b, 0x00, 0x63, 0xe1, 0x04, 0x72, 0x00, 0x63, + 0xe3, 0x13, 0x8c, 0x00, 0x63, 0xe5, 0x41, 0xec, + 0x00, 0x63, 0xe9, 0x13, 0x89, 0x00, 0x63, 0xea, + 0x4b, 0xca, 0x00, 0x63, 0xeb, 0x45, 0x1c, 0x00, + 0x63, 0xec, 0x45, 0x1d, 0x00, 0x63, 0xed, 0x34, + 0x1c, 0x00, 0x63, 0xee, 0x06, 0x34, 0x00, 0x63, + 0xf2, 0x45, 0x1e, 0x00, 0x63, 0xf3, 0x54, 0x91, + 0x00, 0x63, 0xf4, 0x05, 0x09, 0x00, 0x63, 0xf5, + 0x21, 0x13, 0x00, 0x63, 0xf6, 0x13, 0x8f, 0x00, + 0x63, 0xf7, 0x36, 0x44, 0x00, 0x63, 0xf8, 0x4b, + 0xcb, 0x00, 0x63, 0xf9, 0x4b, 0xcc, 0x00, 0x63, + 0xfa, 0x0f, 0x33, 0x00, 0x64, 0x06, 0x13, 0x93, + 0x00, 0x64, 0x09, 0x38, 0xf5, 0x00, 0x64, 0x0a, + 0x54, 0x92, 0x00, 0x64, 0x0d, 0x0b, 0x1b, 0x00, + 0x64, 0x0f, 0x13, 0x9a, 0x00, 0x64, 0x10, 0x38, + 0xf6, 0x00, 0x64, 0x12, 0x4b, 0xcd, 0x00, 0x64, + 0x13, 0x13, 0x94, 0x00, 0x64, 0x14, 0x1e, 0x2c, + 0x00, 0x64, 0x16, 0x13, 0x91, 0x00, 0x64, 0x17, + 0x13, 0x98, 0x00, 0x64, 0x18, 0x4b, 0xce, 0x00, + 0x64, 0x1c, 0x13, 0x7a, 0x00, 0x64, 0x1e, 0x45, + 0x1f, 0x00, 0x64, 0x20, 0x4b, 0xcf, 0x00, 0x64, + 0x22, 0x38, 0xf7, 0x00, 0x64, 0x24, 0x4b, 0xd0, + 0x00, 0x64, 0x25, 0x45, 0x20, 0x00, 0x64, 0x26, + 0x13, 0x95, 0x00, 0x64, 0x28, 0x13, 0x99, 0x00, + 0x64, 0x29, 0x45, 0x21, 0x00, 0x64, 0x2a, 0x4b, + 0xd1, 0x00, 0x64, 0x2c, 0x0d, 0x56, 0x00, 0x64, + 0x2d, 0x0c, 0x65, 0x00, 0x64, 0x2f, 0x45, 0x22, + 0x00, 0x64, 0x30, 0x54, 0x93, 0x00, 0x64, 0x34, + 0x13, 0x92, 0x00, 0x64, 0x35, 0x4b, 0xd2, 0x00, + 0x64, 0x36, 0x13, 0x96, 0x00, 0x64, 0x3a, 0x07, + 0x1e, 0x00, 0x64, 0x3d, 0x4b, 0xd3, 0x00, 0x64, + 0x3e, 0x08, 0x61, 0x00, 0x64, 0x3f, 0x4b, 0xd4, + 0x00, 0x64, 0x42, 0x0a, 0x81, 0x00, 0x64, 0x4b, + 0x54, 0x94, 0x00, 0x64, 0x4e, 0x13, 0x9e, 0x00, + 0x64, 0x4f, 0x54, 0x95, 0x00, 0x64, 0x51, 0x1e, + 0x43, 0x00, 0x64, 0x52, 0x4b, 0xd5, 0x00, 0x64, + 0x53, 0x54, 0x96, 0x00, 0x64, 0x54, 0x38, 0xf8, + 0x00, 0x64, 0x58, 0x0c, 0x20, 0x00, 0x64, 0x5a, + 0x45, 0x23, 0x00, 0x64, 0x5b, 0x38, 0xf9, 0x00, + 0x64, 0x5c, 0x54, 0x97, 0x00, 0x64, 0x5d, 0x45, + 0x24, 0x00, 0x64, 0x5f, 0x4b, 0xd6, 0x00, 0x64, + 0x60, 0x21, 0x14, 0x00, 0x64, 0x61, 0x54, 0x98, + 0x00, 0x64, 0x63, 0x54, 0x99, 0x00, 0x64, 0x67, + 0x13, 0x9b, 0x00, 0x64, 0x69, 0x0e, 0x8e, 0x00, + 0x64, 0x6d, 0x38, 0xfa, 0x00, 0x64, 0x6f, 0x13, + 0x9c, 0x00, 0x64, 0x73, 0x45, 0x25, 0x00, 0x64, + 0x74, 0x4b, 0xd7, 0x00, 0x64, 0x76, 0x13, 0x9d, + 0x00, 0x64, 0x78, 0x0e, 0xda, 0x00, 0x64, 0x79, + 0x41, 0xed, 0x00, 0x64, 0x7a, 0x0a, 0x46, 0x00, + 0x64, 0x7b, 0x38, 0xfb, 0x00, 0x64, 0x7d, 0x45, + 0x26, 0x00, 0x64, 0x83, 0x07, 0x38, 0x00, 0x64, + 0x85, 0x54, 0x9a, 0x00, 0x64, 0x87, 0x45, 0x27, + 0x00, 0x64, 0x88, 0x13, 0xa4, 0x00, 0x64, 0x8f, + 0x54, 0x9b, 0x00, 0x64, 0x90, 0x4b, 0xd8, 0x00, + 0x64, 0x91, 0x45, 0x28, 0x00, 0x64, 0x92, 0x08, + 0x83, 0x00, 0x64, 0x93, 0x13, 0xa1, 0x00, 0x64, + 0x95, 0x13, 0xa0, 0x00, 0x64, 0x98, 0x4b, 0xd9, + 0x00, 0x64, 0x99, 0x4b, 0xda, 0x00, 0x64, 0x9a, + 0x0c, 0xe8, 0x00, 0x64, 0x9b, 0x54, 0x9c, 0x00, + 0x64, 0x9d, 0x21, 0x15, 0x00, 0x64, 0x9e, 0x0c, + 0x8d, 0x00, 0x64, 0x9f, 0x45, 0x29, 0x00, 0x64, + 0xa1, 0x54, 0x9d, 0x00, 0x64, 0xa3, 0x54, 0x9e, + 0x00, 0x64, 0xa4, 0x0c, 0x2b, 0x00, 0x64, 0xa5, + 0x13, 0xa2, 0x00, 0x64, 0xa6, 0x54, 0x9f, 0x00, + 0x64, 0xa8, 0x54, 0xa0, 0x00, 0x64, 0xa9, 0x13, + 0xa3, 0x00, 0x64, 0xab, 0x0d, 0xe1, 0x00, 0x64, + 0xac, 0x4b, 0xdb, 0x00, 0x64, 0xad, 0x0c, 0xfb, + 0x00, 0x64, 0xae, 0x08, 0x71, 0x00, 0x64, 0xb0, + 0x0a, 0x95, 0x00, 0x64, 0xb2, 0x0e, 0x7e, 0x00, + 0x64, 0xb3, 0x4b, 0xdc, 0x00, 0x64, 0xb9, 0x05, + 0xa7, 0x00, 0x64, 0xbb, 0x13, 0xaa, 0x00, 0x64, + 0xbc, 0x13, 0xa5, 0x00, 0x64, 0xbd, 0x54, 0xa1, + 0x00, 0x64, 0xbe, 0x38, 0xfc, 0x00, 0x64, 0xbf, + 0x38, 0xfd, 0x00, 0x64, 0xc1, 0x0f, 0x34, 0x00, + 0x64, 0xc2, 0x13, 0xac, 0x00, 0x64, 0xc4, 0x41, + 0xee, 0x00, 0x64, 0xc5, 0x13, 0xa8, 0x00, 0x64, + 0xc7, 0x13, 0xa9, 0x00, 0x64, 0xc9, 0x54, 0xa2, + 0x00, 0x64, 0xca, 0x34, 0x1d, 0x00, 0x64, 0xcb, + 0x45, 0x2a, 0x00, 0x64, 0xcc, 0x45, 0x2b, 0x00, + 0x64, 0xcd, 0x0a, 0xe2, 0x00, 0x64, 0xce, 0x21, + 0x16, 0x00, 0x64, 0xd0, 0x41, 0xef, 0x00, 0x64, + 0xd1, 0x54, 0xa3, 0x00, 0x64, 0xd2, 0x13, 0xa7, + 0x00, 0x64, 0xd4, 0x13, 0x66, 0x00, 0x64, 0xd5, + 0x45, 0x2c, 0x00, 0x64, 0xd7, 0x45, 0x2d, 0x00, + 0x64, 0xd8, 0x13, 0xab, 0x00, 0x64, 0xda, 0x13, + 0xa6, 0x00, 0x64, 0xe0, 0x13, 0xb0, 0x00, 0x64, + 0xe1, 0x13, 0xb1, 0x00, 0x64, 0xe2, 0x0c, 0x21, + 0x00, 0x64, 0xe3, 0x13, 0xb3, 0x00, 0x64, 0xe4, + 0x45, 0x2f, 0x00, 0x64, 0xe5, 0x38, 0xfe, 0x00, + 0x64, 0xe6, 0x08, 0x72, 0x00, 0x64, 0xe7, 0x13, + 0xae, 0x00, 0x64, 0xe9, 0x54, 0xa4, 0x00, 0x64, + 0xea, 0x54, 0xa5, 0x00, 0x64, 0xec, 0x06, 0x56, + 0x00, 0x64, 0xed, 0x4b, 0xdd, 0x00, 0x64, 0xef, + 0x13, 0xb4, 0x00, 0x64, 0xf0, 0x4b, 0xde, 0x00, + 0x64, 0xf1, 0x13, 0xad, 0x00, 0x64, 0xf2, 0x13, + 0xb8, 0x00, 0x64, 0xf4, 0x13, 0xb7, 0x00, 0x64, + 0xf5, 0x54, 0xa6, 0x00, 0x64, 0xf6, 0x13, 0xb6, + 0x00, 0x64, 0xf7, 0x38, 0xff, 0x00, 0x64, 0xfa, + 0x13, 0xb9, 0x00, 0x64, 0xfb, 0x39, 0x00, 0x00, + 0x64, 0xfd, 0x13, 0xbb, 0x00, 0x64, 0xfe, 0x09, + 0xd9, 0x00, 0x64, 0xff, 0x45, 0x30, 0x00, 0x65, + 0x00, 0x13, 0xba, 0x00, 0x65, 0x01, 0x54, 0xa7, + 0x00, 0x65, 0x04, 0x39, 0x01, 0x00, 0x65, 0x05, + 0x13, 0xbe, 0x00, 0x65, 0x08, 0x54, 0xa8, 0x00, + 0x65, 0x09, 0x54, 0xa9, 0x00, 0x65, 0x0a, 0x54, + 0xaa, 0x00, 0x65, 0x0f, 0x45, 0x32, 0x00, 0x65, + 0x13, 0x54, 0xab, 0x00, 0x65, 0x14, 0x45, 0x33, + 0x00, 0x65, 0x16, 0x39, 0x02, 0x00, 0x65, 0x18, + 0x13, 0xbc, 0x00, 0x65, 0x19, 0x39, 0x03, 0x00, + 0x65, 0x1b, 0x4b, 0xdf, 0x00, 0x65, 0x1c, 0x13, + 0xbd, 0x00, 0x65, 0x1d, 0x13, 0x97, 0x00, 0x65, + 0x1e, 0x45, 0x35, 0x00, 0x65, 0x1f, 0x4b, 0xe0, + 0x00, 0x65, 0x22, 0x1e, 0x97, 0x00, 0x65, 0x23, + 0x13, 0xc0, 0x00, 0x65, 0x24, 0x13, 0xbf, 0x00, + 0x65, 0x26, 0x54, 0xac, 0x00, 0x65, 0x29, 0x41, + 0xf0, 0x00, 0x65, 0x2a, 0x13, 0x9f, 0x00, 0x65, + 0x2b, 0x13, 0xc1, 0x00, 0x65, 0x2c, 0x13, 0xb5, + 0x00, 0x65, 0x2e, 0x4b, 0xe1, 0x00, 0x65, 0x2f, + 0x08, 0xa7, 0x00, 0x65, 0x31, 0x54, 0xad, 0x00, + 0x65, 0x32, 0x45, 0x36, 0x00, 0x65, 0x34, 0x13, + 0xc2, 0x00, 0x65, 0x35, 0x13, 0xc3, 0x00, 0x65, + 0x36, 0x13, 0xc5, 0x00, 0x65, 0x37, 0x13, 0xc4, + 0x00, 0x65, 0x38, 0x13, 0xc6, 0x00, 0x65, 0x39, + 0x05, 0x7e, 0x00, 0x65, 0x3a, 0x54, 0xae, 0x00, + 0x65, 0x3b, 0x07, 0xc8, 0x00, 0x65, 0x3c, 0x54, + 0xaf, 0x00, 0x65, 0x3d, 0x54, 0xb0, 0x00, 0x65, + 0x3e, 0x0e, 0x4c, 0x00, 0x65, 0x3f, 0x0a, 0x53, + 0x00, 0x65, 0x43, 0x54, 0xb1, 0x00, 0x65, 0x44, + 0x45, 0x37, 0x00, 0x65, 0x45, 0x07, 0x82, 0x00, + 0x65, 0x47, 0x39, 0x04, 0x00, 0x65, 0x48, 0x13, + 0xc8, 0x00, 0x65, 0x49, 0x4b, 0xe2, 0x00, 0x65, + 0x4d, 0x13, 0xcb, 0x00, 0x65, 0x4e, 0x21, 0x17, + 0x00, 0x65, 0x4f, 0x34, 0x45, 0x00, 0x65, 0x50, + 0x54, 0xb2, 0x00, 0x65, 0x51, 0x06, 0x79, 0x00, + 0x65, 0x52, 0x54, 0xb3, 0x00, 0x65, 0x54, 0x45, + 0x38, 0x00, 0x65, 0x55, 0x13, 0xca, 0x00, 0x65, + 0x56, 0x13, 0xc9, 0x00, 0x65, 0x57, 0x0d, 0x0a, + 0x00, 0x65, 0x58, 0x13, 0xcc, 0x00, 0x65, 0x59, + 0x06, 0xad, 0x00, 0x65, 0x5d, 0x13, 0xce, 0x00, + 0x65, 0x5e, 0x13, 0xcd, 0x00, 0x65, 0x5f, 0x54, + 0xb4, 0x00, 0x65, 0x60, 0x4b, 0xe3, 0x00, 0x65, + 0x62, 0x05, 0xf6, 0x00, 0x65, 0x63, 0x08, 0x84, + 0x00, 0x65, 0x66, 0x0c, 0xb0, 0x00, 0x65, 0x67, + 0x39, 0x05, 0x00, 0x65, 0x6b, 0x45, 0x39, 0x00, + 0x65, 0x6c, 0x07, 0x1f, 0x00, 0x65, 0x70, 0x0a, + 0x3a, 0x00, 0x65, 0x72, 0x13, 0xcf, 0x00, 0x65, + 0x74, 0x0a, 0x54, 0x00, 0x65, 0x75, 0x0c, 0x22, + 0x00, 0x65, 0x77, 0x0d, 0xd1, 0x00, 0x65, 0x78, + 0x13, 0xd0, 0x00, 0x65, 0x7a, 0x45, 0x3a, 0x00, + 0x65, 0x7d, 0x54, 0xb5, 0x00, 0x65, 0x81, 0x39, + 0x06, 0x00, 0x65, 0x82, 0x13, 0xd1, 0x00, 0x65, + 0x83, 0x13, 0xd2, 0x00, 0x65, 0x84, 0x45, 0x3b, + 0x00, 0x65, 0x85, 0x39, 0x07, 0x00, 0x65, 0x87, + 0x0e, 0x08, 0x00, 0x65, 0x88, 0x12, 0x0c, 0x00, + 0x65, 0x89, 0x0a, 0x6a, 0x00, 0x65, 0x8a, 0x45, + 0x3c, 0x00, 0x65, 0x8c, 0x0d, 0xbe, 0x00, 0x65, + 0x8e, 0x08, 0x48, 0x00, 0x65, 0x90, 0x0d, 0x79, + 0x00, 0x65, 0x91, 0x0d, 0x57, 0x00, 0x65, 0x92, + 0x4b, 0xe4, 0x00, 0x65, 0x95, 0x4b, 0xe5, 0x00, + 0x65, 0x97, 0x0c, 0x47, 0x00, 0x65, 0x98, 0x54, + 0xb6, 0x00, 0x65, 0x99, 0x0f, 0x89, 0x00, 0x65, + 0x9b, 0x13, 0xd4, 0x00, 0x65, 0x9c, 0x08, 0xfc, + 0x00, 0x65, 0x9d, 0x41, 0xf1, 0x00, 0x65, 0x9f, + 0x13, 0xd5, 0x00, 0x65, 0xa0, 0x54, 0xb7, 0x00, + 0x65, 0xa1, 0x04, 0x7a, 0x00, 0x65, 0xa3, 0x54, + 0xb8, 0x00, 0x65, 0xa4, 0x06, 0xcc, 0x00, 0x65, + 0xa5, 0x0a, 0x71, 0x00, 0x65, 0xa6, 0x54, 0xb9, + 0x00, 0x65, 0xa7, 0x0d, 0xd2, 0x00, 0x65, 0xab, + 0x13, 0xd6, 0x00, 0x65, 0xac, 0x08, 0x90, 0x00, + 0x65, 0xad, 0x0b, 0x85, 0x00, 0x65, 0xae, 0x54, + 0xba, 0x00, 0x65, 0xaf, 0x08, 0xa9, 0x00, 0x65, + 0xb0, 0x09, 0xfd, 0x00, 0x65, 0xb2, 0x45, 0x3d, + 0x00, 0x65, 0xb3, 0x54, 0xbb, 0x00, 0x65, 0xb4, + 0x4b, 0xe6, 0x00, 0x65, 0xb5, 0x45, 0x3e, 0x00, + 0x65, 0xb7, 0x13, 0xd7, 0x00, 0x65, 0xb8, 0x45, + 0x3f, 0x00, 0x65, 0xb9, 0x0e, 0x4d, 0x00, 0x65, + 0xbc, 0x05, 0x19, 0x00, 0x65, 0xbd, 0x08, 0xaa, + 0x00, 0x65, 0xbe, 0x4b, 0xe7, 0x00, 0x65, 0xbf, + 0x45, 0x40, 0x00, 0x65, 0xc1, 0x13, 0xda, 0x00, + 0x65, 0xc2, 0x39, 0x08, 0x00, 0x65, 0xc3, 0x13, + 0xd8, 0x00, 0x65, 0xc4, 0x13, 0xdb, 0x00, 0x65, + 0xc5, 0x0f, 0x81, 0x00, 0x65, 0xc6, 0x13, 0xd9, + 0x00, 0x65, 0xc8, 0x4b, 0xe8, 0x00, 0x65, 0xc9, + 0x45, 0x41, 0x00, 0x65, 0xcb, 0x0a, 0x9f, 0x00, + 0x65, 0xcc, 0x13, 0xdc, 0x00, 0x65, 0xce, 0x4b, + 0xe9, 0x00, 0x65, 0xcf, 0x0b, 0x12, 0x00, 0x65, + 0xd0, 0x4b, 0xea, 0x00, 0x65, 0xd2, 0x13, 0xdd, + 0x00, 0x65, 0xd4, 0x45, 0x42, 0x00, 0x65, 0xd6, + 0x54, 0xbc, 0x00, 0x65, 0xd7, 0x06, 0x36, 0x00, + 0x65, 0xd8, 0x54, 0xbd, 0x00, 0x65, 0xd9, 0x13, + 0xdf, 0x00, 0x65, 0xdb, 0x13, 0xde, 0x00, 0x65, + 0xdf, 0x4b, 0xeb, 0x00, 0x65, 0xe0, 0x13, 0xe0, + 0x00, 0x65, 0xe1, 0x13, 0xe1, 0x00, 0x65, 0xe2, + 0x34, 0x16, 0x00, 0x65, 0xe3, 0x35, 0x85, 0x00, + 0x65, 0xe5, 0x0c, 0xd4, 0x00, 0x65, 0xe6, 0x0b, + 0x74, 0x00, 0x65, 0xe7, 0x06, 0x86, 0x00, 0x65, + 0xe8, 0x08, 0xab, 0x00, 0x65, 0xe9, 0x0a, 0xe3, + 0x00, 0x65, 0xec, 0x09, 0x66, 0x00, 0x65, 0xed, + 0x04, 0x74, 0x00, 0x65, 0xf0, 0x39, 0x09, 0x00, + 0x65, 0xf1, 0x13, 0xe2, 0x00, 0x65, 0xf2, 0x39, + 0x0a, 0x00, 0x65, 0xf4, 0x54, 0xbf, 0x00, 0x65, + 0xf5, 0x54, 0xc0, 0x00, 0x65, 0xf9, 0x45, 0x44, + 0x00, 0x65, 0xfa, 0x05, 0x22, 0x00, 0x65, 0xfb, + 0x13, 0xe6, 0x00, 0x65, 0xfc, 0x45, 0x45, 0x00, + 0x65, 0xfe, 0x54, 0xc1, 0x00, 0x65, 0xff, 0x54, + 0xc2, 0x00, 0x66, 0x00, 0x21, 0x18, 0x00, 0x66, + 0x02, 0x07, 0xc9, 0x00, 0x66, 0x03, 0x13, 0xe5, + 0x00, 0x66, 0x04, 0x45, 0x46, 0x00, 0x66, 0x06, + 0x08, 0x1b, 0x00, 0x66, 0x07, 0x09, 0xa2, 0x00, + 0x66, 0x08, 0x45, 0x47, 0x00, 0x66, 0x09, 0x21, + 0x1a, 0x00, 0x66, 0x0a, 0x13, 0xe4, 0x00, 0x66, + 0x0c, 0x09, 0xa3, 0x00, 0x66, 0x0d, 0x54, 0xc3, + 0x00, 0x66, 0x0e, 0x0e, 0xcc, 0x00, 0x66, 0x0f, + 0x08, 0x1a, 0x00, 0x66, 0x11, 0x54, 0xc4, 0x00, + 0x66, 0x12, 0x54, 0xc5, 0x00, 0x66, 0x13, 0x04, + 0x9b, 0x00, 0x66, 0x14, 0x0a, 0x72, 0x00, 0x66, + 0x15, 0x21, 0x19, 0x00, 0x66, 0x16, 0x54, 0xc6, + 0x00, 0x66, 0x1c, 0x13, 0xeb, 0x00, 0x66, 0x1d, + 0x54, 0xc7, 0x00, 0x66, 0x1e, 0x4f, 0x50, 0x00, + 0x66, 0x1f, 0x0a, 0x55, 0x00, 0x66, 0x20, 0x04, + 0xe9, 0x00, 0x66, 0x21, 0x45, 0x48, 0x00, 0x66, + 0x22, 0x41, 0xf3, 0x00, 0x66, 0x23, 0x54, 0xc8, + 0x00, 0x66, 0x24, 0x21, 0x1d, 0x00, 0x66, 0x25, + 0x09, 0x5f, 0x00, 0x66, 0x26, 0x54, 0xc9, 0x00, + 0x66, 0x27, 0x0e, 0x94, 0x00, 0x66, 0x28, 0x08, + 0x62, 0x00, 0x66, 0x29, 0x54, 0xca, 0x00, 0x66, + 0x2a, 0x45, 0x49, 0x00, 0x66, 0x2b, 0x41, 0xf4, + 0x00, 0x66, 0x2c, 0x39, 0x0b, 0x00, 0x66, 0x2d, + 0x09, 0xa4, 0x00, 0x66, 0x2e, 0x21, 0x1b, 0x00, + 0x66, 0x2f, 0x0a, 0x4b, 0x00, 0x66, 0x30, 0x41, + 0xf5, 0x00, 0x66, 0x31, 0x20, 0xae, 0x00, 0x66, + 0x33, 0x41, 0xf6, 0x00, 0x66, 0x34, 0x13, 0xea, + 0x00, 0x66, 0x35, 0x13, 0xe8, 0x00, 0x66, 0x36, + 0x13, 0xe9, 0x00, 0x66, 0x37, 0x54, 0xcc, 0x00, + 0x66, 0x39, 0x54, 0xcb, 0x00, 0x66, 0x3a, 0x41, + 0xf2, 0x00, 0x66, 0x3b, 0x1e, 0x00, 0x00, 0x66, + 0x3c, 0x0b, 0xa9, 0x00, 0x66, 0x3f, 0x14, 0x09, + 0x00, 0x66, 0x40, 0x54, 0xcd, 0x00, 0x66, 0x41, + 0x13, 0xef, 0x00, 0x66, 0x42, 0x08, 0xcc, 0x00, + 0x66, 0x43, 0x07, 0xca, 0x00, 0x66, 0x44, 0x13, + 0xed, 0x00, 0x66, 0x45, 0x45, 0x4a, 0x00, 0x66, + 0x46, 0x54, 0xce, 0x00, 0x66, 0x48, 0x41, 0xf7, + 0x00, 0x66, 0x49, 0x13, 0xee, 0x00, 0x66, 0x4a, + 0x54, 0xcf, 0x00, 0x66, 0x4b, 0x09, 0xfe, 0x00, + 0x66, 0x4c, 0x39, 0x0c, 0x00, 0x66, 0x4e, 0x45, + 0x4c, 0x00, 0x66, 0x4f, 0x13, 0xec, 0x00, 0x66, + 0x51, 0x45, 0x4b, 0x00, 0x66, 0x52, 0x08, 0x7d, + 0x00, 0x66, 0x57, 0x21, 0x1f, 0x00, 0x66, 0x58, + 0x54, 0xd0, 0x00, 0x66, 0x59, 0x21, 0x20, 0x00, + 0x66, 0x5a, 0x34, 0x41, 0x00, 0x66, 0x5b, 0x39, + 0x0d, 0x00, 0x66, 0x5c, 0x39, 0x0e, 0x00, 0x66, + 0x5d, 0x13, 0xf1, 0x00, 0x66, 0x5e, 0x13, 0xf0, + 0x00, 0x66, 0x5f, 0x13, 0xf5, 0x00, 0x66, 0x60, + 0x54, 0xd1, 0x00, 0x66, 0x61, 0x39, 0x0f, 0x00, + 0x66, 0x62, 0x13, 0xf6, 0x00, 0x66, 0x63, 0x37, + 0x3a, 0x00, 0x66, 0x64, 0x13, 0xf2, 0x00, 0x66, + 0x65, 0x21, 0x1e, 0x00, 0x66, 0x66, 0x05, 0x80, + 0x00, 0x66, 0x67, 0x13, 0xf3, 0x00, 0x66, 0x68, + 0x13, 0xf4, 0x00, 0x66, 0x69, 0x0d, 0x69, 0x00, + 0x66, 0x6a, 0x45, 0x51, 0x00, 0x66, 0x6b, 0x39, + 0x10, 0x00, 0x66, 0x6c, 0x45, 0x52, 0x00, 0x66, + 0x6d, 0x45, 0x53, 0x00, 0x66, 0x6e, 0x0d, 0xd3, + 0x00, 0x66, 0x6f, 0x07, 0x20, 0x00, 0x66, 0x70, + 0x13, 0xf7, 0x00, 0x66, 0x73, 0x21, 0x22, 0x00, + 0x66, 0x74, 0x21, 0x21, 0x00, 0x66, 0x75, 0x54, + 0xd2, 0x00, 0x66, 0x76, 0x09, 0xa5, 0x00, 0x66, + 0x77, 0x41, 0xf9, 0x00, 0x66, 0x78, 0x41, 0xfa, + 0x00, 0x66, 0x79, 0x54, 0xd4, 0x00, 0x66, 0x7a, + 0x0b, 0x90, 0x00, 0x66, 0x7b, 0x45, 0x54, 0x00, + 0x66, 0x7c, 0x54, 0xd5, 0x00, 0x66, 0x7e, 0x4b, + 0xec, 0x00, 0x66, 0x7f, 0x54, 0xd3, 0x00, 0x66, + 0x80, 0x45, 0x55, 0x00, 0x66, 0x81, 0x06, 0xbf, + 0x00, 0x66, 0x83, 0x13, 0xf8, 0x00, 0x66, 0x84, + 0x13, 0xfc, 0x00, 0x66, 0x87, 0x05, 0x4b, 0x00, + 0x66, 0x88, 0x13, 0xf9, 0x00, 0x66, 0x89, 0x13, + 0xfb, 0x00, 0x66, 0x8b, 0x4b, 0xed, 0x00, 0x66, + 0x8c, 0x4b, 0xee, 0x00, 0x66, 0x8d, 0x41, 0xfb, + 0x00, 0x66, 0x8e, 0x13, 0xfa, 0x00, 0x66, 0x90, + 0x45, 0x56, 0x00, 0x66, 0x91, 0x09, 0x75, 0x00, + 0x66, 0x92, 0x45, 0x57, 0x00, 0x66, 0x96, 0x0b, + 0x86, 0x00, 0x66, 0x97, 0x04, 0x89, 0x00, 0x66, + 0x98, 0x13, 0xfd, 0x00, 0x66, 0x99, 0x21, 0x23, + 0x00, 0x66, 0x9a, 0x54, 0xd6, 0x00, 0x66, 0x9b, + 0x54, 0xd7, 0x00, 0x66, 0x9c, 0x54, 0xd8, 0x00, + 0x66, 0x9d, 0x13, 0xfe, 0x00, 0x66, 0x9f, 0x54, + 0xd9, 0x00, 0x66, 0xa0, 0x21, 0x24, 0x00, 0x66, + 0xa2, 0x0b, 0xc6, 0x00, 0x66, 0xa4, 0x39, 0x12, + 0x00, 0x66, 0xa6, 0x0f, 0xb9, 0x00, 0x66, 0xab, + 0x08, 0x91, 0x00, 0x66, 0xad, 0x45, 0x59, 0x00, + 0x66, 0xae, 0x0e, 0x3b, 0x00, 0x66, 0xb1, 0x45, + 0x5a, 0x00, 0x66, 0xb2, 0x21, 0x25, 0x00, 0x66, + 0xb3, 0x4b, 0xef, 0x00, 0x66, 0xb4, 0x0e, 0x6b, + 0x00, 0x66, 0xb5, 0x45, 0x5b, 0x00, 0x66, 0xb8, + 0x14, 0x05, 0x00, 0x66, 0xb9, 0x14, 0x00, 0x00, + 0x66, 0xbb, 0x41, 0xfc, 0x00, 0x66, 0xbc, 0x14, + 0x03, 0x00, 0x66, 0xbe, 0x14, 0x02, 0x00, 0x66, + 0xbf, 0x21, 0x26, 0x00, 0x66, 0xc0, 0x4b, 0xf0, + 0x00, 0x66, 0xc1, 0x13, 0xff, 0x00, 0x66, 0xc2, + 0x54, 0xdb, 0x00, 0x66, 0xc3, 0x54, 0xdc, 0x00, + 0x66, 0xc4, 0x14, 0x04, 0x00, 0x66, 0xc6, 0x34, + 0x55, 0x00, 0x66, 0xc7, 0x0c, 0xb6, 0x00, 0x66, + 0xc8, 0x39, 0x13, 0x00, 0x66, 0xc9, 0x14, 0x01, + 0x00, 0x66, 0xcc, 0x54, 0xdd, 0x00, 0x66, 0xce, + 0x54, 0xde, 0x00, 0x66, 0xcf, 0x4b, 0xf1, 0x00, + 0x66, 0xd4, 0x54, 0xdf, 0x00, 0x66, 0xd6, 0x14, + 0x06, 0x00, 0x66, 0xd9, 0x09, 0x76, 0x00, 0x66, + 0xda, 0x14, 0x07, 0x00, 0x66, 0xdb, 0x41, 0xfd, + 0x00, 0x66, 0xdc, 0x0f, 0x35, 0x00, 0x66, 0xdd, + 0x0d, 0x2e, 0x00, 0x66, 0xdf, 0x54, 0xe0, 0x00, + 0x66, 0xe0, 0x14, 0x08, 0x00, 0x66, 0xe6, 0x14, + 0x0a, 0x00, 0x66, 0xe8, 0x41, 0xfe, 0x00, 0x66, + 0xe9, 0x14, 0x0b, 0x00, 0x66, 0xeb, 0x54, 0xe1, + 0x00, 0x66, 0xec, 0x39, 0x14, 0x00, 0x66, 0xee, + 0x54, 0xe2, 0x00, 0x66, 0xf0, 0x14, 0x0c, 0x00, + 0x66, 0xf2, 0x06, 0xc2, 0x00, 0x66, 0xf3, 0x04, + 0xea, 0x00, 0x66, 0xf4, 0x07, 0xcb, 0x00, 0x66, + 0xf5, 0x14, 0x0d, 0x00, 0x66, 0xf7, 0x14, 0x0e, + 0x00, 0x66, 0xf8, 0x09, 0x7b, 0x00, 0x66, 0xf9, + 0x0a, 0xe4, 0x00, 0x66, 0xfa, 0x21, 0x27, 0x00, + 0x66, 0xfb, 0x20, 0xb1, 0x00, 0x66, 0xfc, 0x10, + 0xed, 0x00, 0x66, 0xfd, 0x0a, 0xc0, 0x00, 0x66, + 0xfe, 0x0a, 0xbf, 0x00, 0x66, 0xff, 0x0b, 0x38, + 0x00, 0x67, 0x00, 0x08, 0x37, 0x00, 0x67, 0x01, + 0x45, 0x5f, 0x00, 0x67, 0x03, 0x10, 0x4b, 0x00, + 0x67, 0x05, 0x39, 0x15, 0x00, 0x67, 0x07, 0x54, + 0xe3, 0x00, 0x67, 0x08, 0x07, 0x44, 0x00, 0x67, + 0x09, 0x0f, 0x17, 0x00, 0x67, 0x0b, 0x0e, 0x4e, + 0x00, 0x67, 0x0d, 0x0d, 0xf0, 0x00, 0x67, 0x0e, + 0x21, 0x28, 0x00, 0x67, 0x0f, 0x14, 0x0f, 0x00, + 0x67, 0x12, 0x45, 0x60, 0x00, 0x67, 0x13, 0x39, + 0x16, 0x00, 0x67, 0x14, 0x08, 0x63, 0x00, 0x67, + 0x15, 0x0b, 0xdb, 0x00, 0x67, 0x16, 0x14, 0x10, + 0x00, 0x67, 0x17, 0x4f, 0x51, 0x00, 0x67, 0x19, + 0x45, 0x62, 0x00, 0x67, 0x1b, 0x0e, 0x6c, 0x00, + 0x67, 0x1c, 0x54, 0xe4, 0x00, 0x67, 0x1d, 0x0b, + 0xc7, 0x00, 0x67, 0x1e, 0x14, 0x11, 0x00, 0x67, + 0x1f, 0x06, 0x38, 0x00, 0x67, 0x20, 0x54, 0xe5, + 0x00, 0x67, 0x22, 0x54, 0xe6, 0x00, 0x67, 0x25, + 0x4b, 0xf2, 0x00, 0x67, 0x26, 0x14, 0x12, 0x00, + 0x67, 0x27, 0x14, 0x13, 0x00, 0x67, 0x28, 0x0e, + 0xe6, 0x00, 0x67, 0x2a, 0x0e, 0xb0, 0x00, 0x67, + 0x2b, 0x0e, 0xa4, 0x00, 0x67, 0x2c, 0x0e, 0x8a, + 0x00, 0x67, 0x2d, 0x08, 0x73, 0x00, 0x67, 0x2e, + 0x14, 0x15, 0x00, 0x67, 0x31, 0x09, 0x17, 0x00, + 0x67, 0x33, 0x39, 0x17, 0x00, 0x67, 0x34, 0x0e, + 0x7f, 0x00, 0x67, 0x35, 0x4b, 0xf3, 0x00, 0x67, + 0x36, 0x14, 0x17, 0x00, 0x67, 0x37, 0x14, 0x1a, + 0x00, 0x67, 0x38, 0x14, 0x19, 0x00, 0x67, 0x3a, + 0x06, 0x35, 0x00, 0x67, 0x3d, 0x06, 0x7a, 0x00, + 0x67, 0x3e, 0x54, 0xe7, 0x00, 0x67, 0x3f, 0x14, + 0x16, 0x00, 0x67, 0x41, 0x14, 0x18, 0x00, 0x67, + 0x43, 0x35, 0xb7, 0x00, 0x67, 0x45, 0x54, 0xe8, + 0x00, 0x67, 0x46, 0x14, 0x1b, 0x00, 0x67, 0x47, + 0x41, 0xff, 0x00, 0x67, 0x48, 0x39, 0x18, 0x00, + 0x67, 0x49, 0x0a, 0x3f, 0x00, 0x67, 0x4c, 0x39, + 0x19, 0x00, 0x67, 0x4d, 0x45, 0x65, 0x00, 0x67, + 0x4e, 0x0f, 0x65, 0x00, 0x67, 0x4f, 0x04, 0x8d, + 0x00, 0x67, 0x50, 0x08, 0x50, 0x00, 0x67, 0x51, + 0x0b, 0x1c, 0x00, 0x67, 0x53, 0x09, 0x09, 0x00, + 0x67, 0x54, 0x45, 0x66, 0x00, 0x67, 0x55, 0x4b, + 0xf4, 0x00, 0x67, 0x56, 0x09, 0xdb, 0x00, 0x67, + 0x59, 0x14, 0x1e, 0x00, 0x67, 0x5c, 0x0c, 0x48, + 0x00, 0x67, 0x5d, 0x45, 0x67, 0x00, 0x67, 0x5e, + 0x14, 0x1c, 0x00, 0x67, 0x5f, 0x0b, 0x0b, 0x00, + 0x67, 0x60, 0x14, 0x1d, 0x00, 0x67, 0x61, 0x09, + 0xda, 0x00, 0x67, 0x62, 0x0e, 0xe9, 0x00, 0x67, + 0x63, 0x14, 0x1f, 0x00, 0x67, 0x64, 0x14, 0x20, + 0x00, 0x67, 0x65, 0x0f, 0x52, 0x00, 0x67, 0x66, + 0x21, 0x2a, 0x00, 0x67, 0x6a, 0x14, 0x25, 0x00, + 0x67, 0x6c, 0x54, 0xe9, 0x00, 0x67, 0x6d, 0x07, + 0xcc, 0x00, 0x67, 0x6e, 0x35, 0x71, 0x00, 0x67, + 0x6f, 0x0d, 0x0b, 0x00, 0x67, 0x70, 0x14, 0x22, + 0x00, 0x67, 0x71, 0x0c, 0x66, 0x00, 0x67, 0x72, + 0x13, 0xe3, 0x00, 0x67, 0x73, 0x13, 0xe7, 0x00, + 0x67, 0x74, 0x45, 0x6b, 0x00, 0x67, 0x75, 0x06, + 0x69, 0x00, 0x67, 0x76, 0x39, 0x1a, 0x00, 0x67, + 0x77, 0x0c, 0xfd, 0x00, 0x67, 0x7b, 0x39, 0x1b, + 0x00, 0x67, 0x7c, 0x14, 0x24, 0x00, 0x67, 0x7e, + 0x09, 0xa6, 0x00, 0x67, 0x7f, 0x0d, 0x58, 0x00, + 0x67, 0x80, 0x4b, 0xf5, 0x00, 0x67, 0x81, 0x42, + 0x00, 0x00, 0x67, 0x84, 0x54, 0xea, 0x00, 0x67, + 0x85, 0x14, 0x2a, 0x00, 0x67, 0x87, 0x0d, 0x8e, + 0x00, 0x67, 0x89, 0x14, 0x21, 0x00, 0x67, 0x8b, + 0x14, 0x27, 0x00, 0x67, 0x8c, 0x14, 0x26, 0x00, + 0x67, 0x8e, 0x54, 0xeb, 0x00, 0x67, 0x8f, 0x4b, + 0xf6, 0x00, 0x67, 0x90, 0x0a, 0x73, 0x00, 0x67, + 0x91, 0x4b, 0xf7, 0x00, 0x67, 0x92, 0x45, 0x6d, + 0x00, 0x67, 0x93, 0x42, 0x01, 0x00, 0x67, 0x95, + 0x0e, 0x9b, 0x00, 0x67, 0x96, 0x54, 0xec, 0x00, + 0x67, 0x97, 0x0f, 0x9b, 0x00, 0x67, 0x98, 0x42, + 0x02, 0x00, 0x67, 0x99, 0x54, 0xed, 0x00, 0x67, + 0x9a, 0x0e, 0x95, 0x00, 0x67, 0x9b, 0x42, 0x03, + 0x00, 0x67, 0x9c, 0x05, 0x4c, 0x00, 0x67, 0x9d, + 0x08, 0xac, 0x00, 0x67, 0xa0, 0x0f, 0xee, 0x00, + 0x67, 0xa1, 0x14, 0x29, 0x00, 0x67, 0xa2, 0x0a, + 0x3b, 0x00, 0x67, 0xa4, 0x4b, 0xf8, 0x00, 0x67, + 0xa6, 0x14, 0x28, 0x00, 0x67, 0xa9, 0x14, 0x23, + 0x00, 0x67, 0xaf, 0x07, 0x83, 0x00, 0x67, 0xb0, + 0x39, 0x1c, 0x00, 0x67, 0xb1, 0x4b, 0xf9, 0x00, + 0x67, 0xb2, 0x39, 0x1d, 0x00, 0x67, 0xb3, 0x14, + 0x2f, 0x00, 0x67, 0xb4, 0x14, 0x2d, 0x00, 0x67, + 0xb5, 0x4b, 0xfa, 0x00, 0x67, 0xb6, 0x05, 0x4d, + 0x00, 0x67, 0xb7, 0x14, 0x2b, 0x00, 0x67, 0xb8, + 0x14, 0x31, 0x00, 0x67, 0xb9, 0x14, 0x37, 0x00, + 0x67, 0xbb, 0x21, 0x2b, 0x00, 0x67, 0xbc, 0x54, + 0xee, 0x00, 0x67, 0xbd, 0x54, 0xef, 0x00, 0x67, + 0xbe, 0x4b, 0xfb, 0x00, 0x67, 0xc0, 0x21, 0x2d, + 0x00, 0x67, 0xc1, 0x0b, 0x28, 0x00, 0x67, 0xc2, + 0x54, 0xf0, 0x00, 0x67, 0xc3, 0x45, 0x71, 0x00, + 0x67, 0xc4, 0x0e, 0x11, 0x00, 0x67, 0xc5, 0x54, + 0xf1, 0x00, 0x67, 0xc6, 0x14, 0x39, 0x00, 0x67, + 0xc8, 0x45, 0x72, 0x00, 0x67, 0xc9, 0x54, 0xf2, + 0x00, 0x67, 0xca, 0x0d, 0x94, 0x00, 0x67, 0xce, + 0x14, 0x38, 0x00, 0x67, 0xcf, 0x0d, 0x26, 0x00, + 0x67, 0xd0, 0x0e, 0x6d, 0x00, 0x67, 0xd1, 0x05, + 0xf7, 0x00, 0x67, 0xd2, 0x45, 0x73, 0x00, 0x67, + 0xd3, 0x0a, 0x9b, 0x00, 0x67, 0xd4, 0x09, 0x4a, + 0x00, 0x67, 0xd7, 0x39, 0x1f, 0x00, 0x67, 0xd8, + 0x0b, 0xef, 0x00, 0x67, 0xd9, 0x39, 0x20, 0x00, + 0x67, 0xda, 0x0f, 0x18, 0x00, 0x67, 0xdb, 0x45, + 0x74, 0x00, 0x67, 0xdc, 0x54, 0xf3, 0x00, 0x67, + 0xdd, 0x14, 0x34, 0x00, 0x67, 0xde, 0x14, 0x33, + 0x00, 0x67, 0xe1, 0x54, 0xf4, 0x00, 0x67, 0xe2, + 0x14, 0x35, 0x00, 0x67, 0xe4, 0x14, 0x32, 0x00, + 0x67, 0xe6, 0x54, 0xf5, 0x00, 0x67, 0xe7, 0x14, + 0x3a, 0x00, 0x67, 0xe9, 0x14, 0x30, 0x00, 0x67, + 0xec, 0x14, 0x2e, 0x00, 0x67, 0xee, 0x14, 0x36, + 0x00, 0x67, 0xef, 0x14, 0x2c, 0x00, 0x67, 0xf0, + 0x39, 0x21, 0x00, 0x67, 0xf1, 0x0b, 0xaa, 0x00, + 0x67, 0xf2, 0x54, 0xf6, 0x00, 0x67, 0xf3, 0x0f, + 0x04, 0x00, 0x67, 0xf4, 0x08, 0xf2, 0x00, 0x67, + 0xf5, 0x08, 0x64, 0x00, 0x67, 0xf6, 0x54, 0xf7, + 0x00, 0x67, 0xf7, 0x45, 0x75, 0x00, 0x67, 0xf9, + 0x39, 0x1e, 0x00, 0x67, 0xfa, 0x1e, 0x9a, 0x00, + 0x67, 0xfb, 0x08, 0x2a, 0x00, 0x67, 0xfc, 0x42, + 0x04, 0x00, 0x67, 0xfe, 0x0e, 0x9d, 0x00, 0x67, + 0xff, 0x05, 0x9f, 0x00, 0x68, 0x01, 0x36, 0xf2, + 0x00, 0x68, 0x02, 0x0b, 0xea, 0x00, 0x68, 0x03, + 0x0c, 0xa2, 0x00, 0x68, 0x04, 0x04, 0xeb, 0x00, + 0x68, 0x05, 0x1e, 0x07, 0x00, 0x68, 0x10, 0x45, + 0x70, 0x00, 0x68, 0x13, 0x0a, 0x96, 0x00, 0x68, + 0x14, 0x54, 0xf8, 0x00, 0x68, 0x16, 0x0a, 0x58, + 0x00, 0x68, 0x17, 0x07, 0x00, 0x00, 0x68, 0x18, + 0x45, 0x79, 0x00, 0x68, 0x19, 0x54, 0xf9, 0x00, + 0x68, 0x1d, 0x42, 0x05, 0x00, 0x68, 0x1e, 0x14, + 0x3c, 0x00, 0x68, 0x1f, 0x45, 0x7a, 0x00, 0x68, + 0x21, 0x07, 0xcd, 0x00, 0x68, 0x22, 0x05, 0xda, + 0x00, 0x68, 0x27, 0x54, 0xfa, 0x00, 0x68, 0x28, + 0x4b, 0xfc, 0x00, 0x68, 0x29, 0x14, 0x3e, 0x00, + 0x68, 0x2a, 0x05, 0xd2, 0x00, 0x68, 0x2b, 0x14, + 0x44, 0x00, 0x68, 0x2c, 0x39, 0x22, 0x00, 0x68, + 0x2d, 0x45, 0x7b, 0x00, 0x68, 0x2f, 0x54, 0xfb, + 0x00, 0x68, 0x30, 0x39, 0x23, 0x00, 0x68, 0x31, + 0x39, 0x24, 0x00, 0x68, 0x32, 0x14, 0x41, 0x00, + 0x68, 0x33, 0x45, 0x7d, 0x00, 0x68, 0x34, 0x0a, + 0x97, 0x00, 0x68, 0x38, 0x05, 0xa9, 0x00, 0x68, + 0x39, 0x08, 0x1c, 0x00, 0x68, 0x3b, 0x45, 0x7e, + 0x00, 0x68, 0x3c, 0x05, 0xa8, 0x00, 0x68, 0x3d, + 0x08, 0x3f, 0x00, 0x68, 0x3e, 0x45, 0x7f, 0x00, + 0x68, 0x3f, 0x54, 0xfc, 0x00, 0x68, 0x40, 0x14, + 0x3f, 0x00, 0x68, 0x41, 0x07, 0x3b, 0x00, 0x68, + 0x42, 0x07, 0x21, 0x00, 0x68, 0x43, 0x0c, 0x67, + 0x00, 0x68, 0x44, 0x21, 0x2f, 0x00, 0x68, 0x45, + 0x45, 0x80, 0x00, 0x68, 0x46, 0x14, 0x3d, 0x00, + 0x68, 0x48, 0x04, 0x8a, 0x00, 0x68, 0x49, 0x45, + 0x81, 0x00, 0x68, 0x4a, 0x54, 0xfd, 0x00, 0x68, + 0x4c, 0x45, 0x82, 0x00, 0x68, 0x4d, 0x14, 0x40, + 0x00, 0x68, 0x4e, 0x14, 0x42, 0x00, 0x68, 0x50, + 0x06, 0xc5, 0x00, 0x68, 0x51, 0x07, 0x02, 0x00, + 0x68, 0x52, 0x37, 0xd3, 0x00, 0x68, 0x53, 0x05, + 0xf8, 0x00, 0x68, 0x54, 0x06, 0x65, 0x00, 0x68, + 0x55, 0x45, 0x83, 0x00, 0x68, 0x57, 0x45, 0x84, + 0x00, 0x68, 0x58, 0x54, 0xfe, 0x00, 0x68, 0x59, + 0x14, 0x45, 0x00, 0x68, 0x5b, 0x39, 0x25, 0x00, + 0x68, 0x5c, 0x08, 0x69, 0x00, 0x68, 0x5d, 0x0e, + 0x9f, 0x00, 0x68, 0x5f, 0x08, 0x85, 0x00, 0x68, + 0x63, 0x14, 0x46, 0x00, 0x68, 0x67, 0x0d, 0xa2, + 0x00, 0x68, 0x6b, 0x45, 0x86, 0x00, 0x68, 0x6e, + 0x45, 0x87, 0x00, 0x68, 0x6f, 0x54, 0xff, 0x00, + 0x68, 0x70, 0x55, 0x00, 0x00, 0x68, 0x71, 0x55, + 0x01, 0x00, 0x68, 0x72, 0x39, 0x26, 0x00, 0x68, + 0x74, 0x14, 0x52, 0x00, 0x68, 0x75, 0x39, 0x27, + 0x00, 0x68, 0x76, 0x05, 0x33, 0x00, 0x68, 0x77, + 0x14, 0x47, 0x00, 0x68, 0x79, 0x55, 0x02, 0x00, + 0x68, 0x7a, 0x39, 0x28, 0x00, 0x68, 0x7b, 0x55, + 0x03, 0x00, 0x68, 0x7c, 0x45, 0x88, 0x00, 0x68, + 0x7e, 0x14, 0x58, 0x00, 0x68, 0x7f, 0x14, 0x48, + 0x00, 0x68, 0x81, 0x0f, 0x8a, 0x00, 0x68, 0x82, + 0x45, 0x89, 0x00, 0x68, 0x83, 0x14, 0x4f, 0x00, + 0x68, 0x84, 0x39, 0x29, 0x00, 0x68, 0x85, 0x34, + 0x3f, 0x00, 0x68, 0x86, 0x4b, 0xfd, 0x00, 0x68, + 0x88, 0x55, 0x04, 0x00, 0x68, 0x8d, 0x14, 0x57, + 0x00, 0x68, 0x8e, 0x1e, 0x9c, 0x00, 0x68, 0x8f, + 0x14, 0x4a, 0x00, 0x68, 0x90, 0x45, 0x8a, 0x00, + 0x68, 0x93, 0x04, 0x78, 0x00, 0x68, 0x94, 0x14, + 0x4c, 0x00, 0x68, 0x96, 0x45, 0x8b, 0x00, 0x68, + 0x97, 0x07, 0xce, 0x00, 0x68, 0x98, 0x45, 0x8d, + 0x00, 0x68, 0x99, 0x45, 0x8e, 0x00, 0x68, 0x9a, + 0x45, 0x8f, 0x00, 0x68, 0x9b, 0x14, 0x4e, 0x00, + 0x68, 0x9c, 0x45, 0x90, 0x00, 0x68, 0x9d, 0x14, + 0x4d, 0x00, 0x68, 0x9f, 0x14, 0x49, 0x00, 0x68, + 0xa0, 0x14, 0x54, 0x00, 0x68, 0xa1, 0x55, 0x05, + 0x00, 0x68, 0xa2, 0x09, 0xa7, 0x00, 0x68, 0xa3, + 0x42, 0x06, 0x00, 0x68, 0xa5, 0x39, 0x2a, 0x00, + 0x68, 0xa6, 0x11, 0xbe, 0x00, 0x68, 0xa7, 0x07, + 0x9c, 0x00, 0x68, 0xa8, 0x0f, 0x66, 0x00, 0x68, + 0xa9, 0x55, 0x06, 0x00, 0x68, 0xaa, 0x45, 0x91, + 0x00, 0x68, 0xab, 0x45, 0x92, 0x00, 0x68, 0xad, + 0x14, 0x4b, 0x00, 0x68, 0xae, 0x55, 0x07, 0x00, + 0x68, 0xaf, 0x0c, 0x10, 0x00, 0x68, 0xb0, 0x05, + 0x81, 0x00, 0x68, 0xb1, 0x08, 0x1d, 0x00, 0x68, + 0xb2, 0x39, 0x2b, 0x00, 0x68, 0xb3, 0x14, 0x43, + 0x00, 0x68, 0xb4, 0x45, 0x93, 0x00, 0x68, 0xb5, + 0x14, 0x53, 0x00, 0x68, 0xb6, 0x05, 0xbf, 0x00, + 0x68, 0xb9, 0x14, 0x51, 0x00, 0x68, 0xba, 0x14, + 0x55, 0x00, 0x68, 0xbb, 0x45, 0x94, 0x00, 0x68, + 0xbc, 0x0c, 0x68, 0x00, 0x68, 0xc3, 0x45, 0x98, + 0x00, 0x68, 0xc4, 0x06, 0x3a, 0x00, 0x68, 0xc5, + 0x45, 0x99, 0x00, 0x68, 0xc6, 0x14, 0x73, 0x00, + 0x68, 0xc8, 0x20, 0xaf, 0x00, 0x68, 0xc9, 0x0e, + 0xd5, 0x00, 0x68, 0xca, 0x14, 0x5a, 0x00, 0x68, + 0xcb, 0x06, 0x39, 0x00, 0x68, 0xcc, 0x45, 0x9a, + 0x00, 0x68, 0xcd, 0x14, 0x61, 0x00, 0x68, 0xcf, + 0x21, 0x30, 0x00, 0x68, 0xd0, 0x39, 0x2c, 0x00, + 0x68, 0xd1, 0x55, 0x08, 0x00, 0x68, 0xd2, 0x0e, + 0x6e, 0x00, 0x68, 0xd3, 0x55, 0x09, 0x00, 0x68, + 0xd4, 0x14, 0x62, 0x00, 0x68, 0xd5, 0x14, 0x64, + 0x00, 0x68, 0xd6, 0x39, 0x2d, 0x00, 0x68, 0xd7, + 0x14, 0x68, 0x00, 0x68, 0xd8, 0x14, 0x5c, 0x00, + 0x68, 0xd9, 0x45, 0x9b, 0x00, 0x68, 0xda, 0x0b, + 0x68, 0x00, 0x68, 0xdc, 0x55, 0x0a, 0x00, 0x68, + 0xdd, 0x55, 0x0b, 0x00, 0x68, 0xdf, 0x0c, 0x69, + 0x00, 0x68, 0xe0, 0x14, 0x6c, 0x00, 0x68, 0xe1, + 0x14, 0x5f, 0x00, 0x68, 0xe3, 0x14, 0x69, 0x00, + 0x68, 0xe4, 0x45, 0x9c, 0x00, 0x68, 0xe5, 0x45, + 0x9d, 0x00, 0x68, 0xe7, 0x14, 0x63, 0x00, 0x68, + 0xe8, 0x39, 0x2e, 0x00, 0x68, 0xea, 0x55, 0x0c, + 0x00, 0x68, 0xeb, 0x4b, 0xfe, 0x00, 0x68, 0xec, + 0x45, 0x9e, 0x00, 0x68, 0xed, 0x39, 0x2f, 0x00, + 0x68, 0xee, 0x09, 0xff, 0x00, 0x68, 0xef, 0x14, + 0x6d, 0x00, 0x68, 0xf0, 0x39, 0x30, 0x00, 0x68, + 0xf1, 0x39, 0x31, 0x00, 0x68, 0xf2, 0x0a, 0x57, + 0x00, 0x68, 0xf5, 0x4b, 0xff, 0x00, 0x68, 0xf6, + 0x55, 0x0d, 0x00, 0x68, 0xf7, 0x45, 0x9f, 0x00, + 0x68, 0xf9, 0x14, 0x6b, 0x00, 0x68, 0xfa, 0x05, + 0xf9, 0x00, 0x68, 0xfb, 0x45, 0x95, 0x00, 0x68, + 0xfc, 0x39, 0x32, 0x00, 0x68, 0xfd, 0x55, 0x0e, + 0x00, 0x69, 0x00, 0x0f, 0xf6, 0x00, 0x69, 0x01, + 0x14, 0x59, 0x00, 0x69, 0x03, 0x45, 0xa0, 0x00, + 0x69, 0x04, 0x14, 0x67, 0x00, 0x69, 0x05, 0x04, + 0x9c, 0x00, 0x69, 0x06, 0x55, 0x0f, 0x00, 0x69, + 0x07, 0x45, 0xa1, 0x00, 0x69, 0x08, 0x14, 0x5b, + 0x00, 0x69, 0x09, 0x55, 0x10, 0x00, 0x69, 0x0a, + 0x42, 0x07, 0x00, 0x69, 0x0b, 0x0e, 0xc6, 0x00, + 0x69, 0x0c, 0x14, 0x60, 0x00, 0x69, 0x0d, 0x09, + 0xe8, 0x00, 0x69, 0x0e, 0x0b, 0xe3, 0x00, 0x69, + 0x0f, 0x14, 0x56, 0x00, 0x69, 0x10, 0x55, 0x11, + 0x00, 0x69, 0x11, 0x39, 0x33, 0x00, 0x69, 0x12, + 0x14, 0x66, 0x00, 0x69, 0x13, 0x39, 0x34, 0x00, + 0x69, 0x16, 0x55, 0x12, 0x00, 0x69, 0x17, 0x4c, + 0x00, 0x00, 0x69, 0x19, 0x0a, 0x40, 0x00, 0x69, + 0x1a, 0x14, 0x70, 0x00, 0x69, 0x1b, 0x05, 0xcf, + 0x00, 0x69, 0x1c, 0x07, 0x55, 0x00, 0x69, 0x21, + 0x14, 0x72, 0x00, 0x69, 0x22, 0x14, 0x5d, 0x00, + 0x69, 0x23, 0x14, 0x71, 0x00, 0x69, 0x25, 0x14, + 0x6a, 0x00, 0x69, 0x26, 0x14, 0x5e, 0x00, 0x69, + 0x28, 0x14, 0x6e, 0x00, 0x69, 0x2a, 0x14, 0x6f, + 0x00, 0x69, 0x30, 0x14, 0x80, 0x00, 0x69, 0x31, + 0x55, 0x13, 0x00, 0x69, 0x33, 0x4c, 0x01, 0x00, + 0x69, 0x34, 0x0c, 0xa6, 0x00, 0x69, 0x35, 0x39, + 0x35, 0x00, 0x69, 0x36, 0x14, 0x65, 0x00, 0x69, + 0x38, 0x4c, 0x02, 0x00, 0x69, 0x39, 0x14, 0x7c, + 0x00, 0x69, 0x3b, 0x39, 0x36, 0x00, 0x69, 0x3d, + 0x14, 0x7e, 0x00, 0x69, 0x3f, 0x0b, 0xf4, 0x00, + 0x69, 0x42, 0x42, 0x0a, 0x00, 0x69, 0x45, 0x55, + 0x14, 0x00, 0x69, 0x46, 0x45, 0xa5, 0x00, 0x69, + 0x49, 0x42, 0x08, 0x00, 0x69, 0x4a, 0x0f, 0x36, + 0x00, 0x69, 0x4e, 0x55, 0x15, 0x00, 0x69, 0x53, + 0x0d, 0xe8, 0x00, 0x69, 0x54, 0x14, 0x79, 0x00, + 0x69, 0x55, 0x0b, 0x2a, 0x00, 0x69, 0x57, 0x39, + 0x37, 0x00, 0x69, 0x59, 0x14, 0x7f, 0x00, 0x69, + 0x5a, 0x0a, 0xc1, 0x00, 0x69, 0x5b, 0x4c, 0x03, + 0x00, 0x69, 0x5c, 0x14, 0x76, 0x00, 0x69, 0x5d, + 0x14, 0x83, 0x00, 0x69, 0x5e, 0x14, 0x82, 0x00, + 0x69, 0x60, 0x0c, 0xc7, 0x00, 0x69, 0x61, 0x14, + 0x81, 0x00, 0x69, 0x62, 0x0c, 0xc2, 0x00, 0x69, + 0x63, 0x39, 0x38, 0x00, 0x69, 0x64, 0x42, 0x0b, + 0x00, 0x69, 0x65, 0x4c, 0x04, 0x00, 0x69, 0x66, + 0x55, 0x16, 0x00, 0x69, 0x68, 0x21, 0x32, 0x00, + 0x69, 0x69, 0x45, 0xa6, 0x00, 0x69, 0x6a, 0x14, + 0x85, 0x00, 0x69, 0x6b, 0x14, 0x78, 0x00, 0x69, + 0x6c, 0x45, 0xa7, 0x00, 0x69, 0x6d, 0x06, 0xc0, + 0x00, 0x69, 0x6e, 0x14, 0x7b, 0x00, 0x69, 0x6f, + 0x09, 0x67, 0x00, 0x69, 0x70, 0x55, 0x17, 0x00, + 0x69, 0x71, 0x55, 0x18, 0x00, 0x69, 0x72, 0x39, + 0x39, 0x00, 0x69, 0x73, 0x0d, 0x16, 0x00, 0x69, + 0x74, 0x14, 0x7d, 0x00, 0x69, 0x75, 0x06, 0xc3, + 0x00, 0x69, 0x77, 0x14, 0x75, 0x00, 0x69, 0x78, + 0x14, 0x77, 0x00, 0x69, 0x79, 0x14, 0x74, 0x00, + 0x69, 0x7a, 0x45, 0xa8, 0x00, 0x69, 0x7b, 0x55, + 0x19, 0x00, 0x69, 0x7c, 0x0f, 0xd6, 0x00, 0x69, + 0x7d, 0x05, 0xb8, 0x00, 0x69, 0x7e, 0x14, 0x7a, + 0x00, 0x69, 0x7f, 0x39, 0x3a, 0x00, 0x69, 0x80, + 0x39, 0x3b, 0x00, 0x69, 0x81, 0x14, 0x84, 0x00, + 0x69, 0x82, 0x05, 0x93, 0x00, 0x69, 0x86, 0x37, + 0x40, 0x00, 0x69, 0x8a, 0x08, 0x57, 0x00, 0x69, + 0x8d, 0x55, 0x1a, 0x00, 0x69, 0x8e, 0x04, 0xff, + 0x00, 0x69, 0x91, 0x14, 0x95, 0x00, 0x69, 0x92, + 0x45, 0xa9, 0x00, 0x69, 0x94, 0x0f, 0xd7, 0x00, + 0x69, 0x95, 0x14, 0x98, 0x00, 0x69, 0x96, 0x45, + 0xab, 0x00, 0x69, 0x98, 0x21, 0x34, 0x00, 0x69, + 0x9b, 0x0a, 0x00, 0x00, 0x69, 0x9c, 0x14, 0x97, + 0x00, 0x69, 0xa0, 0x14, 0x96, 0x00, 0x69, 0xa1, + 0x55, 0x1b, 0x00, 0x69, 0xa5, 0x42, 0x0c, 0x00, + 0x69, 0xa6, 0x39, 0x3c, 0x00, 0x69, 0xa7, 0x14, + 0x93, 0x00, 0x69, 0xa8, 0x4c, 0x05, 0x00, 0x69, + 0xab, 0x4c, 0x06, 0x00, 0x69, 0xad, 0x39, 0x3d, + 0x00, 0x69, 0xae, 0x14, 0x87, 0x00, 0x69, 0xaf, + 0x4c, 0x07, 0x00, 0x69, 0xb0, 0x45, 0xac, 0x00, + 0x69, 0xb1, 0x14, 0xa4, 0x00, 0x69, 0xb2, 0x14, + 0x86, 0x00, 0x69, 0xb4, 0x14, 0x99, 0x00, 0x69, + 0xb7, 0x39, 0x3e, 0x00, 0x69, 0xb8, 0x55, 0x1c, + 0x00, 0x69, 0xba, 0x45, 0xad, 0x00, 0x69, 0xbb, + 0x14, 0x91, 0x00, 0x69, 0xbc, 0x45, 0xae, 0x00, + 0x69, 0xbe, 0x14, 0x8c, 0x00, 0x69, 0xbf, 0x14, + 0x89, 0x00, 0x69, 0xc0, 0x45, 0xaf, 0x00, 0x69, + 0xc1, 0x14, 0x8a, 0x00, 0x69, 0xc3, 0x14, 0x92, + 0x00, 0x69, 0xc5, 0x55, 0x1d, 0x00, 0x69, 0xc7, + 0x1d, 0x33, 0x00, 0x69, 0xc8, 0x55, 0x1e, 0x00, + 0x69, 0xca, 0x14, 0x8f, 0x00, 0x69, 0xcb, 0x07, + 0xcf, 0x00, 0x69, 0xcc, 0x0b, 0xe4, 0x00, 0x69, + 0xcd, 0x0a, 0xe6, 0x00, 0x69, 0xce, 0x14, 0x8d, + 0x00, 0x69, 0xcf, 0x42, 0x0d, 0x00, 0x69, 0xd0, + 0x14, 0x88, 0x00, 0x69, 0xd1, 0x45, 0xb0, 0x00, + 0x69, 0xd3, 0x14, 0x8b, 0x00, 0x69, 0xd6, 0x39, + 0x3f, 0x00, 0x69, 0xd7, 0x39, 0x40, 0x00, 0x69, + 0xd8, 0x0f, 0x37, 0x00, 0x69, 0xd9, 0x0e, 0x98, + 0x00, 0x69, 0xdd, 0x14, 0x90, 0x00, 0x69, 0xde, + 0x14, 0x9a, 0x00, 0x69, 0xe2, 0x21, 0x35, 0x00, + 0x69, 0xe3, 0x45, 0xb4, 0x00, 0x69, 0xe5, 0x4c, + 0x08, 0x00, 0x69, 0xe7, 0x14, 0xa2, 0x00, 0x69, + 0xe8, 0x14, 0x9b, 0x00, 0x69, 0xe9, 0x42, 0x10, + 0x00, 0x69, 0xea, 0x34, 0x11, 0x00, 0x69, 0xeb, + 0x14, 0xa8, 0x00, 0x69, 0xed, 0x14, 0xa6, 0x00, + 0x69, 0xee, 0x45, 0xb5, 0x00, 0x69, 0xef, 0x45, + 0xb6, 0x00, 0x69, 0xf1, 0x4c, 0x09, 0x00, 0x69, + 0xf2, 0x14, 0xa1, 0x00, 0x69, 0xf3, 0x45, 0xb7, + 0x00, 0x69, 0xf4, 0x45, 0xb9, 0x00, 0x69, 0xf5, + 0x42, 0x11, 0x00, 0x69, 0xf6, 0x37, 0x3f, 0x00, + 0x69, 0xf9, 0x14, 0xa0, 0x00, 0x69, 0xfb, 0x0b, + 0xec, 0x00, 0x69, 0xfd, 0x0a, 0xe7, 0x00, 0x69, + 0xfe, 0x45, 0xba, 0x00, 0x69, 0xff, 0x14, 0x9e, + 0x00, 0x6a, 0x00, 0x55, 0x20, 0x00, 0x6a, 0x01, + 0x39, 0x41, 0x00, 0x6a, 0x02, 0x14, 0x9c, 0x00, + 0x6a, 0x03, 0x55, 0x21, 0x00, 0x6a, 0x05, 0x14, + 0xa3, 0x00, 0x6a, 0x0a, 0x14, 0xa9, 0x00, 0x6a, + 0x0b, 0x0d, 0x89, 0x00, 0x6a, 0x0c, 0x14, 0xaf, + 0x00, 0x6a, 0x0f, 0x39, 0x42, 0x00, 0x6a, 0x11, + 0x45, 0xbb, 0x00, 0x6a, 0x12, 0x14, 0xaa, 0x00, + 0x6a, 0x13, 0x14, 0xad, 0x00, 0x6a, 0x14, 0x14, + 0xa7, 0x00, 0x6a, 0x15, 0x39, 0x43, 0x00, 0x6a, + 0x17, 0x0b, 0xb2, 0x00, 0x6a, 0x19, 0x0d, 0xaa, + 0x00, 0x6a, 0x1a, 0x45, 0xbc, 0x00, 0x6a, 0x1b, + 0x14, 0x9d, 0x00, 0x6a, 0x1d, 0x45, 0xbd, 0x00, + 0x6a, 0x1e, 0x14, 0xa5, 0x00, 0x6a, 0x1f, 0x09, + 0xa8, 0x00, 0x6a, 0x20, 0x55, 0x22, 0x00, 0x6a, + 0x21, 0x0e, 0xdb, 0x00, 0x6a, 0x22, 0x14, 0xb9, + 0x00, 0x6a, 0x23, 0x14, 0xac, 0x00, 0x6a, 0x24, + 0x55, 0x23, 0x00, 0x6a, 0x28, 0x39, 0x44, 0x00, + 0x6a, 0x29, 0x07, 0x56, 0x00, 0x6a, 0x2a, 0x05, + 0x23, 0x00, 0x6a, 0x2b, 0x05, 0xbd, 0x00, 0x6a, + 0x2e, 0x14, 0x94, 0x00, 0x6a, 0x30, 0x21, 0x36, + 0x00, 0x6a, 0x32, 0x45, 0xbf, 0x00, 0x6a, 0x33, + 0x45, 0xc0, 0x00, 0x6a, 0x34, 0x39, 0x45, 0x00, + 0x6a, 0x35, 0x09, 0xa9, 0x00, 0x6a, 0x36, 0x14, + 0xb1, 0x00, 0x6a, 0x37, 0x55, 0x24, 0x00, 0x6a, + 0x38, 0x14, 0xb8, 0x00, 0x6a, 0x39, 0x09, 0x25, + 0x00, 0x6a, 0x3a, 0x05, 0xd0, 0x00, 0x6a, 0x3b, + 0x42, 0x13, 0x00, 0x6a, 0x3d, 0x0b, 0x6c, 0x00, + 0x6a, 0x3e, 0x39, 0x46, 0x00, 0x6a, 0x3f, 0x45, + 0xc1, 0x00, 0x6a, 0x44, 0x14, 0xae, 0x00, 0x6a, + 0x45, 0x39, 0x47, 0x00, 0x6a, 0x46, 0x21, 0x38, + 0x00, 0x6a, 0x47, 0x14, 0xb3, 0x00, 0x6a, 0x48, + 0x14, 0xb7, 0x00, 0x6a, 0x49, 0x45, 0xc2, 0x00, + 0x6a, 0x4a, 0x4c, 0x0a, 0x00, 0x6a, 0x4b, 0x06, + 0xae, 0x00, 0x6a, 0x4e, 0x45, 0xc4, 0x00, 0x6a, + 0x50, 0x39, 0x48, 0x00, 0x6a, 0x51, 0x39, 0x49, + 0x00, 0x6a, 0x52, 0x45, 0xc5, 0x00, 0x6a, 0x54, + 0x3c, 0x34, 0x00, 0x6a, 0x55, 0x4c, 0x0b, 0x00, + 0x6a, 0x56, 0x39, 0x4a, 0x00, 0x6a, 0x58, 0x06, + 0x66, 0x00, 0x6a, 0x59, 0x14, 0xb5, 0x00, 0x6a, + 0x5b, 0x39, 0x4b, 0x00, 0x6a, 0x5f, 0x06, 0x3b, + 0x00, 0x6a, 0x61, 0x0c, 0xa3, 0x00, 0x6a, 0x62, + 0x14, 0xb4, 0x00, 0x6a, 0x64, 0x45, 0xc6, 0x00, + 0x6a, 0x66, 0x14, 0xb6, 0x00, 0x6a, 0x67, 0x4c, + 0x0c, 0x00, 0x6a, 0x6a, 0x55, 0x26, 0x00, 0x6a, + 0x6b, 0x21, 0x37, 0x00, 0x6a, 0x71, 0x4c, 0x0d, + 0x00, 0x6a, 0x72, 0x14, 0xb0, 0x00, 0x6a, 0x73, + 0x21, 0x39, 0x00, 0x6a, 0x78, 0x14, 0xb2, 0x00, + 0x6a, 0x7a, 0x45, 0xc3, 0x00, 0x6a, 0x7e, 0x21, + 0x3a, 0x00, 0x6a, 0x7f, 0x05, 0xbe, 0x00, 0x6a, + 0x80, 0x0b, 0x87, 0x00, 0x6a, 0x81, 0x55, 0x27, + 0x00, 0x6a, 0x83, 0x39, 0x4c, 0x00, 0x6a, 0x84, + 0x14, 0xbd, 0x00, 0x6a, 0x86, 0x55, 0x28, 0x00, + 0x6a, 0x87, 0x55, 0x29, 0x00, 0x6a, 0x89, 0x39, + 0x4d, 0x00, 0x6a, 0x8b, 0x45, 0xc8, 0x00, 0x6a, + 0x8d, 0x14, 0xbb, 0x00, 0x6a, 0x8e, 0x07, 0x9d, + 0x00, 0x6a, 0x90, 0x14, 0xba, 0x00, 0x6a, 0x91, + 0x39, 0x4e, 0x00, 0x6a, 0x94, 0x42, 0x15, 0x00, + 0x6a, 0x97, 0x14, 0xc0, 0x00, 0x6a, 0x9b, 0x55, + 0x2a, 0x00, 0x6a, 0x9c, 0x14, 0x3b, 0x00, 0x6a, + 0x9d, 0x39, 0x4f, 0x00, 0x6a, 0x9e, 0x39, 0x50, + 0x00, 0x6a, 0x9f, 0x39, 0x51, 0x00, 0x6a, 0xa0, + 0x14, 0xbc, 0x00, 0x6a, 0xa1, 0x45, 0xca, 0x00, + 0x6a, 0xa2, 0x14, 0xbe, 0x00, 0x6a, 0xa3, 0x14, + 0xbf, 0x00, 0x6a, 0xa5, 0x42, 0x16, 0x00, 0x6a, + 0xaa, 0x14, 0xcb, 0x00, 0x6a, 0xab, 0x45, 0xcc, + 0x00, 0x6a, 0xac, 0x14, 0xc7, 0x00, 0x6a, 0xae, + 0x14, 0x50, 0x00, 0x6a, 0xaf, 0x4c, 0x0e, 0x00, + 0x6a, 0xb0, 0x55, 0x2b, 0x00, 0x6a, 0xb1, 0x55, + 0x2c, 0x00, 0x6a, 0xb3, 0x14, 0xc6, 0x00, 0x6a, + 0xb4, 0x55, 0x2d, 0x00, 0x6a, 0xb8, 0x14, 0xc5, + 0x00, 0x6a, 0xbb, 0x14, 0xc2, 0x00, 0x6a, 0xbd, + 0x45, 0xcd, 0x00, 0x6a, 0xbe, 0x55, 0x2e, 0x00, + 0x6a, 0xbf, 0x55, 0x2f, 0x00, 0x6a, 0xc1, 0x14, + 0xab, 0x00, 0x6a, 0xc2, 0x14, 0xc4, 0x00, 0x6a, + 0xc3, 0x14, 0xc3, 0x00, 0x6a, 0xc6, 0x45, 0xce, + 0x00, 0x6a, 0xc8, 0x4c, 0x0f, 0x00, 0x6a, 0xc9, + 0x4c, 0x10, 0x00, 0x6a, 0xcc, 0x55, 0x30, 0x00, + 0x6a, 0xd0, 0x45, 0xd0, 0x00, 0x6a, 0xd1, 0x14, + 0xc9, 0x00, 0x6a, 0xd3, 0x0f, 0xcc, 0x00, 0x6a, + 0xd4, 0x45, 0xcf, 0x00, 0x6a, 0xd5, 0x55, 0x31, + 0x00, 0x6a, 0xd6, 0x55, 0x32, 0x00, 0x6a, 0xda, + 0x14, 0xcc, 0x00, 0x6a, 0xdb, 0x1d, 0xf1, 0x00, + 0x6a, 0xdc, 0x39, 0x52, 0x00, 0x6a, 0xdd, 0x45, + 0xd1, 0x00, 0x6a, 0xde, 0x14, 0xc8, 0x00, 0x6a, + 0xdf, 0x14, 0xca, 0x00, 0x6a, 0xe2, 0x21, 0x3b, + 0x00, 0x6a, 0xe4, 0x21, 0x3c, 0x00, 0x6a, 0xe7, + 0x39, 0x53, 0x00, 0x6a, 0xe8, 0x0d, 0x3b, 0x00, + 0x6a, 0xea, 0x14, 0xcd, 0x00, 0x6a, 0xec, 0x39, + 0x54, 0x00, 0x6a, 0xf0, 0x55, 0x33, 0x00, 0x6a, + 0xf1, 0x45, 0xd4, 0x00, 0x6a, 0xf2, 0x45, 0xd5, + 0x00, 0x6a, 0xf3, 0x45, 0xd6, 0x00, 0x6a, 0xf8, + 0x4e, 0xb8, 0x00, 0x6a, 0xfa, 0x14, 0xd1, 0x00, + 0x6a, 0xfb, 0x14, 0xce, 0x00, 0x6a, 0xfc, 0x55, + 0x34, 0x00, 0x6a, 0xfd, 0x45, 0xd7, 0x00, 0x6b, + 0x02, 0x55, 0x35, 0x00, 0x6b, 0x03, 0x4c, 0x11, + 0x00, 0x6b, 0x04, 0x34, 0x50, 0x00, 0x6b, 0x05, + 0x14, 0xcf, 0x00, 0x6b, 0x06, 0x55, 0x36, 0x00, + 0x6b, 0x07, 0x55, 0x37, 0x00, 0x6b, 0x09, 0x55, + 0x38, 0x00, 0x6b, 0x0a, 0x14, 0x9f, 0x00, 0x6b, + 0x0b, 0x45, 0xd9, 0x00, 0x6b, 0x0f, 0x45, 0xda, + 0x00, 0x6b, 0x10, 0x45, 0xdb, 0x00, 0x6b, 0x11, + 0x45, 0xdc, 0x00, 0x6b, 0x12, 0x14, 0xd2, 0x00, + 0x6b, 0x16, 0x14, 0xd3, 0x00, 0x6b, 0x17, 0x45, + 0xde, 0x00, 0x6b, 0x1b, 0x42, 0x18, 0x00, 0x6b, + 0x1d, 0x04, 0xd7, 0x00, 0x6b, 0x1e, 0x39, 0x55, + 0x00, 0x6b, 0x1f, 0x14, 0xd5, 0x00, 0x6b, 0x20, + 0x07, 0x3d, 0x00, 0x6b, 0x21, 0x08, 0xcd, 0x00, + 0x6b, 0x23, 0x06, 0xcd, 0x00, 0x6b, 0x24, 0x39, + 0x56, 0x00, 0x6b, 0x27, 0x05, 0x24, 0x00, 0x6b, + 0x28, 0x55, 0x39, 0x00, 0x6b, 0x2b, 0x55, 0x3a, + 0x00, 0x6b, 0x2c, 0x42, 0x19, 0x00, 0x6b, 0x2f, + 0x45, 0xe0, 0x00, 0x6b, 0x32, 0x0f, 0x49, 0x00, + 0x6b, 0x35, 0x39, 0x57, 0x00, 0x6b, 0x36, 0x55, + 0x3b, 0x00, 0x6b, 0x37, 0x14, 0xd7, 0x00, 0x6b, + 0x38, 0x14, 0xd6, 0x00, 0x6b, 0x39, 0x14, 0xd9, + 0x00, 0x6b, 0x3a, 0x06, 0x57, 0x00, 0x6b, 0x3b, + 0x4c, 0x12, 0x00, 0x6b, 0x3d, 0x06, 0xce, 0x00, + 0x6b, 0x3e, 0x05, 0xfa, 0x00, 0x6b, 0x3f, 0x4c, + 0x13, 0x00, 0x6b, 0x43, 0x14, 0xdc, 0x00, 0x6b, + 0x46, 0x39, 0x58, 0x00, 0x6b, 0x47, 0x14, 0xdb, + 0x00, 0x6b, 0x49, 0x14, 0xdd, 0x00, 0x6b, 0x4a, + 0x45, 0xe1, 0x00, 0x6b, 0x4c, 0x05, 0x4e, 0x00, + 0x6b, 0x4d, 0x55, 0x3c, 0x00, 0x6b, 0x4e, 0x0b, + 0x75, 0x00, 0x6b, 0x50, 0x14, 0xde, 0x00, 0x6b, + 0x52, 0x55, 0x3d, 0x00, 0x6b, 0x53, 0x05, 0xfb, + 0x00, 0x6b, 0x54, 0x14, 0xe0, 0x00, 0x6b, 0x56, + 0x39, 0x59, 0x00, 0x6b, 0x58, 0x45, 0xe2, 0x00, + 0x6b, 0x59, 0x14, 0xdf, 0x00, 0x6b, 0x5b, 0x14, + 0xe1, 0x00, 0x6b, 0x5d, 0x55, 0x3e, 0x00, 0x6b, + 0x5f, 0x14, 0xe2, 0x00, 0x6b, 0x60, 0x39, 0x5a, + 0x00, 0x6b, 0x61, 0x14, 0xe3, 0x00, 0x6b, 0x62, + 0x08, 0xad, 0x00, 0x6b, 0x63, 0x0a, 0x59, 0x00, + 0x6b, 0x64, 0x08, 0x11, 0x00, 0x6b, 0x65, 0x34, + 0x4a, 0x00, 0x6b, 0x66, 0x0d, 0xe2, 0x00, 0x6b, + 0x67, 0x42, 0x1a, 0x00, 0x6b, 0x69, 0x0e, 0x32, + 0x00, 0x6b, 0x6a, 0x0f, 0xea, 0x00, 0x6b, 0x6b, + 0x55, 0x3f, 0x00, 0x6b, 0x6c, 0x45, 0xe3, 0x00, + 0x6b, 0x6e, 0x55, 0x40, 0x00, 0x6b, 0x6f, 0x08, + 0xc3, 0x00, 0x6b, 0x70, 0x55, 0x41, 0x00, 0x6b, + 0x72, 0x35, 0xd9, 0x00, 0x6b, 0x73, 0x08, 0x40, + 0x00, 0x6b, 0x74, 0x0f, 0xba, 0x00, 0x6b, 0x75, + 0x45, 0xe4, 0x00, 0x6b, 0x77, 0x34, 0x56, 0x00, + 0x6b, 0x78, 0x14, 0xe4, 0x00, 0x6b, 0x79, 0x14, + 0xe5, 0x00, 0x6b, 0x7a, 0x45, 0xe5, 0x00, 0x6b, + 0x7b, 0x08, 0xae, 0x00, 0x6b, 0x7d, 0x4c, 0x14, + 0x00, 0x6b, 0x7e, 0x4c, 0x15, 0x00, 0x6b, 0x7f, + 0x14, 0xe6, 0x00, 0x6b, 0x80, 0x14, 0xe7, 0x00, + 0x6b, 0x81, 0x45, 0xe6, 0x00, 0x6b, 0x82, 0x39, + 0x5b, 0x00, 0x6b, 0x83, 0x14, 0xe9, 0x00, 0x6b, + 0x84, 0x14, 0xe8, 0x00, 0x6b, 0x85, 0x55, 0x42, + 0x00, 0x6b, 0x86, 0x0e, 0x86, 0x00, 0x6b, 0x89, + 0x09, 0x68, 0x00, 0x6b, 0x8a, 0x09, 0x18, 0x00, + 0x6b, 0x8b, 0x08, 0x92, 0x00, 0x6b, 0x8d, 0x14, + 0xea, 0x00, 0x6b, 0x95, 0x14, 0xec, 0x00, 0x6b, + 0x96, 0x09, 0xe9, 0x00, 0x6b, 0x97, 0x55, 0x43, + 0x00, 0x6b, 0x98, 0x14, 0xeb, 0x00, 0x6b, 0x9b, + 0x45, 0xe7, 0x00, 0x6b, 0x9e, 0x14, 0xed, 0x00, + 0x6b, 0x9f, 0x55, 0x44, 0x00, 0x6b, 0xa0, 0x55, + 0x45, 0x00, 0x6b, 0xa2, 0x55, 0x46, 0x00, 0x6b, + 0xa3, 0x55, 0x47, 0x00, 0x6b, 0xa4, 0x14, 0xee, + 0x00, 0x6b, 0xa8, 0x55, 0x48, 0x00, 0x6b, 0xa9, + 0x42, 0x1b, 0x00, 0x6b, 0xaa, 0x14, 0xef, 0x00, + 0x6b, 0xab, 0x14, 0xf0, 0x00, 0x6b, 0xac, 0x55, + 0x49, 0x00, 0x6b, 0xad, 0x42, 0x1c, 0x00, 0x6b, + 0xae, 0x45, 0xe8, 0x00, 0x6b, 0xaf, 0x14, 0xf1, + 0x00, 0x6b, 0xb0, 0x4c, 0x16, 0x00, 0x6b, 0xb1, + 0x14, 0xf3, 0x00, 0x6b, 0xb2, 0x14, 0xf2, 0x00, + 0x6b, 0xb3, 0x14, 0xf4, 0x00, 0x6b, 0xb4, 0x05, + 0x25, 0x00, 0x6b, 0xb5, 0x0b, 0x88, 0x00, 0x6b, + 0xb7, 0x14, 0xf5, 0x00, 0x6b, 0xb8, 0x55, 0x4a, + 0x00, 0x6b, 0xb9, 0x55, 0x4b, 0x00, 0x6b, 0xba, + 0x34, 0x20, 0x00, 0x6b, 0xbb, 0x05, 0xaa, 0x00, + 0x6b, 0xbc, 0x14, 0xf6, 0x00, 0x6b, 0xbd, 0x45, + 0xea, 0x00, 0x6b, 0xbe, 0x39, 0x5c, 0x00, 0x6b, + 0xbf, 0x0c, 0x3c, 0x00, 0x6b, 0xc0, 0x11, 0x9d, + 0x00, 0x6b, 0xc3, 0x55, 0x4c, 0x00, 0x6b, 0xc4, + 0x55, 0x4d, 0x00, 0x6b, 0xc5, 0x06, 0x3d, 0x00, + 0x6b, 0xc6, 0x14, 0xf7, 0x00, 0x6b, 0xc7, 0x45, + 0xeb, 0x00, 0x6b, 0xc8, 0x45, 0xec, 0x00, 0x6b, + 0xc9, 0x45, 0xed, 0x00, 0x6b, 0xcb, 0x14, 0xf8, + 0x00, 0x6b, 0xcc, 0x37, 0x44, 0x00, 0x6b, 0xcd, + 0x0e, 0x3c, 0x00, 0x6b, 0xce, 0x0e, 0x96, 0x00, + 0x6b, 0xcf, 0x34, 0x4c, 0x00, 0x6b, 0xd2, 0x0c, + 0x9f, 0x00, 0x6b, 0xd3, 0x14, 0xf9, 0x00, 0x6b, + 0xd4, 0x0d, 0x7a, 0x00, 0x6b, 0xd6, 0x21, 0x3d, + 0x00, 0x6b, 0xd7, 0x42, 0x1d, 0x00, 0x6b, 0xd8, + 0x0d, 0x8f, 0x00, 0x6b, 0xda, 0x45, 0xee, 0x00, + 0x6b, 0xdb, 0x0e, 0xdf, 0x00, 0x6b, 0xdf, 0x14, + 0xfa, 0x00, 0x6b, 0xe1, 0x39, 0x5d, 0x00, 0x6b, + 0xe3, 0x55, 0x4e, 0x00, 0x6b, 0xe6, 0x45, 0xef, + 0x00, 0x6b, 0xe7, 0x45, 0xf0, 0x00, 0x6b, 0xeb, + 0x14, 0xfc, 0x00, 0x6b, 0xec, 0x14, 0xfb, 0x00, + 0x6b, 0xee, 0x45, 0xf1, 0x00, 0x6b, 0xef, 0x14, + 0xfe, 0x00, 0x6b, 0xf1, 0x39, 0x5e, 0x00, 0x6b, + 0xf3, 0x14, 0xfd, 0x00, 0x6b, 0xf7, 0x4c, 0x17, + 0x00, 0x6b, 0xf9, 0x4c, 0x18, 0x00, 0x6b, 0xff, + 0x42, 0x1e, 0x00, 0x6c, 0x02, 0x45, 0xf2, 0x00, + 0x6c, 0x04, 0x4c, 0x19, 0x00, 0x6c, 0x05, 0x42, + 0x1f, 0x00, 0x6c, 0x08, 0x15, 0x00, 0x00, 0x6c, + 0x09, 0x4c, 0x1a, 0x00, 0x6c, 0x0a, 0x45, 0xf3, + 0x00, 0x6c, 0x0d, 0x4c, 0x1b, 0x00, 0x6c, 0x0e, + 0x45, 0xf4, 0x00, 0x6c, 0x0f, 0x08, 0xaf, 0x00, + 0x6c, 0x10, 0x39, 0x5f, 0x00, 0x6c, 0x11, 0x0e, + 0xbd, 0x00, 0x6c, 0x12, 0x55, 0x4f, 0x00, 0x6c, + 0x13, 0x15, 0x01, 0x00, 0x6c, 0x14, 0x15, 0x02, + 0x00, 0x6c, 0x17, 0x06, 0x3e, 0x00, 0x6c, 0x19, + 0x55, 0x50, 0x00, 0x6c, 0x1b, 0x15, 0x03, 0x00, + 0x6c, 0x1f, 0x55, 0x51, 0x00, 0x6c, 0x23, 0x15, + 0x05, 0x00, 0x6c, 0x24, 0x15, 0x04, 0x00, 0x6c, + 0x26, 0x55, 0x52, 0x00, 0x6c, 0x27, 0x55, 0x53, + 0x00, 0x6c, 0x28, 0x55, 0x54, 0x00, 0x6c, 0x2c, + 0x4c, 0x1c, 0x00, 0x6c, 0x2e, 0x55, 0x55, 0x00, + 0x6c, 0x33, 0x39, 0x60, 0x00, 0x6c, 0x34, 0x0a, + 0x2b, 0x00, 0x6c, 0x35, 0x39, 0x61, 0x00, 0x6c, + 0x36, 0x45, 0xf5, 0x00, 0x6c, 0x37, 0x0d, 0xab, + 0x00, 0x6c, 0x38, 0x04, 0xec, 0x00, 0x6c, 0x3a, + 0x4f, 0x55, 0x00, 0x6c, 0x3b, 0x55, 0x56, 0x00, + 0x6c, 0x3e, 0x0d, 0x59, 0x00, 0x6c, 0x3f, 0x21, + 0x3e, 0x00, 0x6c, 0x40, 0x0c, 0x11, 0x00, 0x6c, + 0x41, 0x09, 0x4b, 0x00, 0x6c, 0x42, 0x06, 0x7b, + 0x00, 0x6c, 0x4a, 0x4c, 0x1d, 0x00, 0x6c, 0x4b, + 0x55, 0x57, 0x00, 0x6c, 0x4d, 0x45, 0xf7, 0x00, + 0x6c, 0x4e, 0x0d, 0x5a, 0x00, 0x6c, 0x4f, 0x55, + 0x58, 0x00, 0x6c, 0x50, 0x08, 0xda, 0x00, 0x6c, + 0x52, 0x4c, 0x1e, 0x00, 0x6c, 0x54, 0x4c, 0x1f, + 0x00, 0x6c, 0x55, 0x15, 0x07, 0x00, 0x6c, 0x57, + 0x05, 0xfc, 0x00, 0x6c, 0x59, 0x39, 0x63, 0x00, + 0x6c, 0x5a, 0x05, 0x1a, 0x00, 0x6c, 0x5b, 0x45, + 0xf8, 0x00, 0x6c, 0x5c, 0x21, 0x3f, 0x00, 0x6c, + 0x5d, 0x0c, 0xca, 0x00, 0x6c, 0x5e, 0x15, 0x06, + 0x00, 0x6c, 0x5f, 0x07, 0xd0, 0x00, 0x6c, 0x60, + 0x0b, 0x91, 0x00, 0x6c, 0x62, 0x15, 0x08, 0x00, + 0x6c, 0x67, 0x46, 0x0a, 0x00, 0x6c, 0x68, 0x15, + 0x10, 0x00, 0x6c, 0x6a, 0x15, 0x09, 0x00, 0x6c, + 0x6b, 0x55, 0x59, 0x00, 0x6c, 0x6d, 0x45, 0xf9, + 0x00, 0x6c, 0x6f, 0x21, 0x41, 0x00, 0x6c, 0x70, + 0x0b, 0x21, 0x00, 0x6c, 0x72, 0x06, 0x7c, 0x00, + 0x6c, 0x73, 0x15, 0x11, 0x00, 0x6c, 0x74, 0x42, + 0x20, 0x00, 0x6c, 0x76, 0x39, 0x64, 0x00, 0x6c, + 0x78, 0x55, 0x5a, 0x00, 0x6c, 0x79, 0x4c, 0x20, + 0x00, 0x6c, 0x7a, 0x07, 0x3e, 0x00, 0x6c, 0x7b, + 0x39, 0x65, 0x00, 0x6c, 0x7d, 0x06, 0x3f, 0x00, + 0x6c, 0x7e, 0x15, 0x0f, 0x00, 0x6c, 0x81, 0x15, + 0x0d, 0x00, 0x6c, 0x82, 0x15, 0x0a, 0x00, 0x6c, + 0x83, 0x0f, 0x4a, 0x00, 0x6c, 0x84, 0x45, 0xfa, + 0x00, 0x6c, 0x85, 0x39, 0x66, 0x00, 0x6c, 0x86, + 0x21, 0x40, 0x00, 0x6c, 0x87, 0x55, 0x5b, 0x00, + 0x6c, 0x88, 0x0b, 0xdc, 0x00, 0x6c, 0x89, 0x45, + 0xfb, 0x00, 0x6c, 0x8c, 0x0c, 0xb1, 0x00, 0x6c, + 0x8d, 0x15, 0x0b, 0x00, 0x6c, 0x90, 0x15, 0x13, + 0x00, 0x6c, 0x92, 0x15, 0x12, 0x00, 0x6c, 0x93, + 0x06, 0xf9, 0x00, 0x6c, 0x94, 0x45, 0xfd, 0x00, + 0x6c, 0x95, 0x39, 0x67, 0x00, 0x6c, 0x96, 0x05, + 0x2d, 0x00, 0x6c, 0x97, 0x45, 0xfe, 0x00, 0x6c, + 0x98, 0x42, 0x21, 0x00, 0x6c, 0x99, 0x08, 0x2b, + 0x00, 0x6c, 0x9a, 0x15, 0x0c, 0x00, 0x6c, 0x9b, + 0x15, 0x0e, 0x00, 0x6c, 0x9c, 0x39, 0x68, 0x00, + 0x6c, 0x9f, 0x55, 0x5c, 0x00, 0x6c, 0xa1, 0x0e, + 0x85, 0x00, 0x6c, 0xa2, 0x0b, 0x54, 0x00, 0x6c, + 0xaa, 0x37, 0x49, 0x00, 0x6c, 0xab, 0x0e, 0xa5, + 0x00, 0x6c, 0xac, 0x4c, 0x21, 0x00, 0x6c, 0xad, + 0x45, 0xff, 0x00, 0x6c, 0xae, 0x15, 0x1b, 0x00, + 0x6c, 0xb0, 0x55, 0x5d, 0x00, 0x6c, 0xb1, 0x15, + 0x1c, 0x00, 0x6c, 0xb2, 0x55, 0x5e, 0x00, 0x6c, + 0xb3, 0x05, 0x4f, 0x00, 0x6c, 0xb4, 0x4c, 0x22, + 0x00, 0x6c, 0xb8, 0x0d, 0xf8, 0x00, 0x6c, 0xb9, + 0x0f, 0x09, 0x00, 0x6c, 0xba, 0x15, 0x1e, 0x00, + 0x6c, 0xbb, 0x08, 0xcf, 0x00, 0x6c, 0xbc, 0x09, + 0xaa, 0x00, 0x6c, 0xbd, 0x15, 0x17, 0x00, 0x6c, + 0xbe, 0x15, 0x1d, 0x00, 0x6c, 0xbf, 0x35, 0x58, + 0x00, 0x6c, 0xc1, 0x06, 0xaf, 0x00, 0x6c, 0xc2, + 0x46, 0x00, 0x00, 0x6c, 0xc4, 0x15, 0x14, 0x00, + 0x6c, 0xc5, 0x15, 0x19, 0x00, 0x6c, 0xc6, 0x42, + 0x23, 0x00, 0x6c, 0xc9, 0x0a, 0x98, 0x00, 0x6c, + 0xca, 0x0d, 0x27, 0x00, 0x6c, 0xcc, 0x0d, 0x7b, + 0x00, 0x6c, 0xcd, 0x55, 0x5f, 0x00, 0x6c, 0xcf, + 0x55, 0x60, 0x00, 0x6c, 0xd0, 0x39, 0x69, 0x00, + 0x6c, 0xd1, 0x55, 0x61, 0x00, 0x6c, 0xd2, 0x4c, + 0x23, 0x00, 0x6c, 0xd3, 0x15, 0x16, 0x00, 0x6c, + 0xd4, 0x39, 0x6a, 0x00, 0x6c, 0xd5, 0x0e, 0x4f, + 0x00, 0x6c, 0xd6, 0x39, 0x6b, 0x00, 0x6c, 0xd7, + 0x15, 0x18, 0x00, 0x6c, 0xd9, 0x15, 0x21, 0x00, + 0x6c, 0xda, 0x21, 0x42, 0x00, 0x6c, 0xdb, 0x15, + 0x1f, 0x00, 0x6c, 0xdc, 0x46, 0x02, 0x00, 0x6c, + 0xdd, 0x15, 0x1a, 0x00, 0x6c, 0xe0, 0x39, 0x6c, + 0x00, 0x6c, 0xe1, 0x0e, 0x50, 0x00, 0x6c, 0xe2, + 0x0c, 0xfe, 0x00, 0x6c, 0xe3, 0x06, 0x7d, 0x00, + 0x6c, 0xe5, 0x0c, 0x1f, 0x00, 0x6c, 0xe7, 0x55, + 0x62, 0x00, 0x6c, 0xe8, 0x0b, 0xab, 0x00, 0x6c, + 0xe9, 0x46, 0x03, 0x00, 0x6c, 0xea, 0x15, 0x22, + 0x00, 0x6c, 0xeb, 0x39, 0x6d, 0x00, 0x6c, 0xec, + 0x39, 0x6e, 0x00, 0x6c, 0xed, 0x46, 0x04, 0x00, + 0x6c, 0xee, 0x39, 0x6f, 0x00, 0x6c, 0xef, 0x15, + 0x20, 0x00, 0x6c, 0xf0, 0x0b, 0x39, 0x00, 0x6c, + 0xf1, 0x15, 0x15, 0x00, 0x6c, 0xf2, 0x55, 0x63, + 0x00, 0x6c, 0xf3, 0x04, 0xed, 0x00, 0x6c, 0xf4, + 0x55, 0x64, 0x00, 0x6c, 0xfb, 0x42, 0x22, 0x00, + 0x6d, 0x00, 0x46, 0x06, 0x00, 0x6d, 0x01, 0x3c, + 0x35, 0x00, 0x6d, 0x04, 0x21, 0x43, 0x00, 0x6d, + 0x07, 0x55, 0x65, 0x00, 0x6d, 0x0a, 0x39, 0x70, + 0x00, 0x6d, 0x0b, 0x0f, 0x38, 0x00, 0x6d, 0x0c, + 0x15, 0x2d, 0x00, 0x6d, 0x0e, 0x39, 0x71, 0x00, + 0x6d, 0x0f, 0x55, 0x66, 0x00, 0x6d, 0x11, 0x39, + 0x72, 0x00, 0x6d, 0x12, 0x15, 0x2c, 0x00, 0x6d, + 0x13, 0x55, 0x67, 0x00, 0x6d, 0x17, 0x0a, 0x9a, + 0x00, 0x6d, 0x19, 0x15, 0x29, 0x00, 0x6d, 0x1a, + 0x55, 0x68, 0x00, 0x6d, 0x1b, 0x0f, 0x56, 0x00, + 0x6d, 0x1e, 0x0c, 0x8e, 0x00, 0x6d, 0x1f, 0x15, + 0x23, 0x00, 0x6d, 0x24, 0x46, 0x07, 0x00, 0x6d, + 0x25, 0x0b, 0xe1, 0x00, 0x6d, 0x26, 0x46, 0x08, + 0x00, 0x6d, 0x27, 0x46, 0x09, 0x00, 0x6d, 0x28, + 0x55, 0x69, 0x00, 0x6d, 0x29, 0x04, 0xee, 0x00, + 0x6d, 0x2a, 0x07, 0xd1, 0x00, 0x6d, 0x2b, 0x15, + 0x26, 0x00, 0x6d, 0x2e, 0x39, 0x73, 0x00, 0x6d, + 0x2f, 0x46, 0x0b, 0x00, 0x6d, 0x31, 0x42, 0x24, + 0x00, 0x6d, 0x32, 0x09, 0x31, 0x00, 0x6d, 0x33, + 0x15, 0x2b, 0x00, 0x6d, 0x34, 0x46, 0x1e, 0x00, + 0x6d, 0x35, 0x15, 0x2a, 0x00, 0x6d, 0x36, 0x15, + 0x25, 0x00, 0x6d, 0x38, 0x15, 0x28, 0x00, 0x6d, + 0x39, 0x42, 0x25, 0x00, 0x6d, 0x3b, 0x05, 0xc6, + 0x00, 0x6d, 0x3c, 0x46, 0x0c, 0x00, 0x6d, 0x3d, + 0x15, 0x27, 0x00, 0x6d, 0x3e, 0x0c, 0xff, 0x00, + 0x6d, 0x3f, 0x42, 0x26, 0x00, 0x6d, 0x41, 0x0f, + 0x76, 0x00, 0x6d, 0x44, 0x09, 0xdc, 0x00, 0x6d, + 0x45, 0x0a, 0x99, 0x00, 0x6d, 0x57, 0x39, 0x74, + 0x00, 0x6d, 0x58, 0x42, 0x27, 0x00, 0x6d, 0x59, + 0x15, 0x33, 0x00, 0x6d, 0x5a, 0x15, 0x31, 0x00, + 0x6d, 0x5b, 0x46, 0x0d, 0x00, 0x6d, 0x5c, 0x0d, + 0xbf, 0x00, 0x6d, 0x5e, 0x39, 0x75, 0x00, 0x6d, + 0x5f, 0x55, 0x6a, 0x00, 0x6d, 0x60, 0x46, 0x0e, + 0x00, 0x6d, 0x61, 0x4c, 0x24, 0x00, 0x6d, 0x63, + 0x15, 0x2e, 0x00, 0x6d, 0x64, 0x15, 0x30, 0x00, + 0x6d, 0x65, 0x39, 0x76, 0x00, 0x6d, 0x66, 0x04, + 0xdc, 0x00, 0x6d, 0x67, 0x55, 0x6b, 0x00, 0x6d, + 0x69, 0x07, 0xd2, 0x00, 0x6d, 0x6a, 0x0f, 0xd8, + 0x00, 0x6d, 0x6c, 0x05, 0x9b, 0x00, 0x6d, 0x6e, + 0x0d, 0xd4, 0x00, 0x6d, 0x6f, 0x21, 0x45, 0x00, + 0x6d, 0x70, 0x46, 0x0f, 0x00, 0x6d, 0x74, 0x0f, + 0x4b, 0x00, 0x6d, 0x77, 0x34, 0x0f, 0x00, 0x6d, + 0x78, 0x0a, 0x01, 0x00, 0x6d, 0x79, 0x15, 0x32, + 0x00, 0x6d, 0x7c, 0x4c, 0x25, 0x00, 0x6d, 0x80, + 0x46, 0x10, 0x00, 0x6d, 0x81, 0x46, 0x11, 0x00, + 0x6d, 0x82, 0x39, 0x77, 0x00, 0x6d, 0x85, 0x15, + 0x37, 0x00, 0x6d, 0x87, 0x21, 0x44, 0x00, 0x6d, + 0x88, 0x09, 0xab, 0x00, 0x6d, 0x89, 0x34, 0x2a, + 0x00, 0x6d, 0x8a, 0x46, 0x12, 0x00, 0x6d, 0x8c, + 0x0f, 0x1a, 0x00, 0x6d, 0x8d, 0x46, 0x13, 0x00, + 0x6d, 0x8e, 0x15, 0x34, 0x00, 0x6d, 0x91, 0x46, + 0x14, 0x00, 0x6d, 0x92, 0x55, 0x6c, 0x00, 0x6d, + 0x93, 0x15, 0x2f, 0x00, 0x6d, 0x94, 0x42, 0x28, + 0x00, 0x6d, 0x95, 0x15, 0x35, 0x00, 0x6d, 0x96, + 0x21, 0x46, 0x00, 0x6d, 0x97, 0x55, 0x6d, 0x00, + 0x6d, 0x98, 0x46, 0x15, 0x00, 0x6d, 0x99, 0x0f, + 0xa6, 0x00, 0x6d, 0x9b, 0x0c, 0x6d, 0x00, 0x6d, + 0x9c, 0x0c, 0x9a, 0x00, 0x6d, 0xaa, 0x42, 0x29, + 0x00, 0x6d, 0xab, 0x46, 0x1a, 0x00, 0x6d, 0xac, + 0x21, 0x47, 0x00, 0x6d, 0xae, 0x46, 0x1b, 0x00, + 0x6d, 0xaf, 0x05, 0x94, 0x00, 0x6d, 0xb2, 0x04, + 0xf7, 0x00, 0x6d, 0xb4, 0x46, 0x1c, 0x00, 0x6d, + 0xb5, 0x15, 0x3b, 0x00, 0x6d, 0xb7, 0x55, 0x6e, + 0x00, 0x6d, 0xb8, 0x15, 0x3e, 0x00, 0x6d, 0xb9, + 0x4c, 0x26, 0x00, 0x6d, 0xbc, 0x0f, 0x8b, 0x00, + 0x6d, 0xbd, 0x55, 0x6f, 0x00, 0x6d, 0xbf, 0x39, + 0x78, 0x00, 0x6d, 0xc0, 0x0f, 0x4e, 0x00, 0x6d, + 0xc2, 0x46, 0x1d, 0x00, 0x6d, 0xc4, 0x39, 0x79, + 0x00, 0x6d, 0xc5, 0x15, 0x45, 0x00, 0x6d, 0xc6, + 0x15, 0x3f, 0x00, 0x6d, 0xc7, 0x15, 0x3c, 0x00, + 0x6d, 0xc8, 0x46, 0x1f, 0x00, 0x6d, 0xca, 0x39, + 0x7a, 0x00, 0x6d, 0xcb, 0x0f, 0x9c, 0x00, 0x6d, + 0xcc, 0x15, 0x42, 0x00, 0x6d, 0xce, 0x46, 0x20, + 0x00, 0x6d, 0xcf, 0x21, 0x48, 0x00, 0x6d, 0xd0, + 0x3c, 0x36, 0x00, 0x6d, 0xd1, 0x09, 0x54, 0x00, + 0x6d, 0xd2, 0x15, 0x44, 0x00, 0x6d, 0xd5, 0x15, + 0x49, 0x00, 0x6d, 0xd6, 0x39, 0x7b, 0x00, 0x6d, + 0xd8, 0x0c, 0x6b, 0x00, 0x6d, 0xd9, 0x15, 0x47, + 0x00, 0x6d, 0xda, 0x34, 0x53, 0x00, 0x6d, 0xdb, + 0x42, 0x2a, 0x00, 0x6d, 0xdd, 0x42, 0x2b, 0x00, + 0x6d, 0xde, 0x15, 0x41, 0x00, 0x6d, 0xdf, 0x46, + 0x21, 0x00, 0x6d, 0xe0, 0x55, 0x70, 0x00, 0x6d, + 0xe1, 0x0b, 0x76, 0x00, 0x6d, 0xe2, 0x55, 0x71, + 0x00, 0x6d, 0xe4, 0x15, 0x48, 0x00, 0x6d, 0xe5, + 0x55, 0x72, 0x00, 0x6d, 0xe6, 0x15, 0x3d, 0x00, + 0x6d, 0xe8, 0x15, 0x43, 0x00, 0x6d, 0xe9, 0x39, + 0x7c, 0x00, 0x6d, 0xea, 0x15, 0x4a, 0x00, 0x6d, + 0xeb, 0x04, 0xc0, 0x00, 0x6d, 0xec, 0x15, 0x40, + 0x00, 0x6d, 0xee, 0x15, 0x4b, 0x00, 0x6d, 0xef, + 0x55, 0x73, 0x00, 0x6d, 0xf0, 0x4c, 0x27, 0x00, + 0x6d, 0xf1, 0x0a, 0x02, 0x00, 0x6d, 0xf2, 0x21, + 0x4a, 0x00, 0x6d, 0xf3, 0x09, 0x69, 0x00, 0x6d, + 0xf4, 0x55, 0x74, 0x00, 0x6d, 0xf5, 0x0d, 0xf5, + 0x00, 0x6d, 0xf6, 0x46, 0x22, 0x00, 0x6d, 0xf7, + 0x08, 0x1e, 0x00, 0x6d, 0xf8, 0x21, 0x49, 0x00, + 0x6d, 0xf9, 0x15, 0x38, 0x00, 0x6d, 0xfa, 0x15, + 0x46, 0x00, 0x6d, 0xfb, 0x0c, 0x34, 0x00, 0x6d, + 0xfc, 0x21, 0x4b, 0x00, 0x6e, 0x00, 0x55, 0x75, + 0x00, 0x6e, 0x04, 0x55, 0x76, 0x00, 0x6e, 0x05, + 0x0a, 0x5a, 0x00, 0x6e, 0x07, 0x05, 0xc7, 0x00, + 0x6e, 0x08, 0x08, 0x41, 0x00, 0x6e, 0x09, 0x09, + 0xac, 0x00, 0x6e, 0x0a, 0x15, 0x3a, 0x00, 0x6e, + 0x0b, 0x09, 0x4c, 0x00, 0x6e, 0x13, 0x07, 0x22, + 0x00, 0x6e, 0x15, 0x15, 0x39, 0x00, 0x6e, 0x17, + 0x37, 0x46, 0x00, 0x6e, 0x19, 0x15, 0x4f, 0x00, + 0x6e, 0x1a, 0x1e, 0x14, 0x00, 0x6e, 0x1b, 0x07, + 0x6e, 0x00, 0x6e, 0x1d, 0x15, 0x5e, 0x00, 0x6e, + 0x1e, 0x46, 0x24, 0x00, 0x6e, 0x1f, 0x15, 0x58, + 0x00, 0x6e, 0x20, 0x06, 0x8e, 0x00, 0x6e, 0x21, + 0x0c, 0x49, 0x00, 0x6e, 0x22, 0x39, 0x7d, 0x00, + 0x6e, 0x23, 0x15, 0x53, 0x00, 0x6e, 0x24, 0x15, + 0x5c, 0x00, 0x6e, 0x25, 0x04, 0x73, 0x00, 0x6e, + 0x26, 0x04, 0xd4, 0x00, 0x6e, 0x27, 0x21, 0x4e, + 0x00, 0x6e, 0x29, 0x05, 0x39, 0x00, 0x6e, 0x2b, + 0x15, 0x55, 0x00, 0x6e, 0x2c, 0x0b, 0x0c, 0x00, + 0x6e, 0x2d, 0x15, 0x4c, 0x00, 0x6e, 0x2e, 0x15, + 0x4e, 0x00, 0x6e, 0x2f, 0x07, 0xd3, 0x00, 0x6e, + 0x32, 0x46, 0x26, 0x00, 0x6e, 0x34, 0x34, 0x12, + 0x00, 0x6e, 0x36, 0x46, 0x23, 0x00, 0x6e, 0x38, + 0x15, 0x5f, 0x00, 0x6e, 0x39, 0x21, 0x4c, 0x00, + 0x6e, 0x3a, 0x15, 0x5a, 0x00, 0x6e, 0x3b, 0x55, + 0x77, 0x00, 0x6e, 0x3c, 0x21, 0x4f, 0x00, 0x6e, + 0x3e, 0x15, 0x52, 0x00, 0x6e, 0x42, 0x3c, 0x37, + 0x00, 0x6e, 0x43, 0x15, 0x59, 0x00, 0x6e, 0x44, + 0x42, 0x2c, 0x00, 0x6e, 0x45, 0x4c, 0x28, 0x00, + 0x6e, 0x48, 0x46, 0x27, 0x00, 0x6e, 0x49, 0x46, + 0x28, 0x00, 0x6e, 0x4a, 0x0e, 0xb7, 0x00, 0x6e, + 0x4b, 0x46, 0x29, 0x00, 0x6e, 0x4c, 0x46, 0x2a, + 0x00, 0x6e, 0x4d, 0x15, 0x57, 0x00, 0x6e, 0x4e, + 0x15, 0x5b, 0x00, 0x6e, 0x4f, 0x46, 0x2b, 0x00, + 0x6e, 0x51, 0x39, 0x7e, 0x00, 0x6e, 0x52, 0x55, + 0x78, 0x00, 0x6e, 0x53, 0x46, 0x2c, 0x00, 0x6e, + 0x54, 0x46, 0x2d, 0x00, 0x6e, 0x56, 0x07, 0x84, + 0x00, 0x6e, 0x57, 0x46, 0x2e, 0x00, 0x6e, 0x58, + 0x09, 0xad, 0x00, 0x6e, 0x5b, 0x0b, 0x77, 0x00, + 0x6e, 0x5c, 0x21, 0x4d, 0x00, 0x6e, 0x5d, 0x55, + 0x79, 0x00, 0x6e, 0x5e, 0x42, 0x2d, 0x00, 0x6e, + 0x5f, 0x15, 0x51, 0x00, 0x6e, 0x62, 0x55, 0x7a, + 0x00, 0x6e, 0x63, 0x46, 0x2f, 0x00, 0x6e, 0x67, + 0x0f, 0x19, 0x00, 0x6e, 0x68, 0x55, 0x7b, 0x00, + 0x6e, 0x6b, 0x15, 0x54, 0x00, 0x6e, 0x6e, 0x15, + 0x4d, 0x00, 0x6e, 0x6f, 0x0c, 0x6c, 0x00, 0x6e, + 0x72, 0x15, 0x50, 0x00, 0x6e, 0x73, 0x4c, 0x29, + 0x00, 0x6e, 0x76, 0x15, 0x56, 0x00, 0x6e, 0x7b, + 0x4c, 0x2a, 0x00, 0x6e, 0x7d, 0x4c, 0x2b, 0x00, + 0x6e, 0x7e, 0x0f, 0xf7, 0x00, 0x6e, 0x7f, 0x08, + 0xea, 0x00, 0x6e, 0x80, 0x0e, 0xac, 0x00, 0x6e, + 0x82, 0x15, 0x60, 0x00, 0x6e, 0x89, 0x4c, 0x2c, + 0x00, 0x6e, 0x8c, 0x0d, 0x42, 0x00, 0x6e, 0x8d, + 0x55, 0x7c, 0x00, 0x6e, 0x8f, 0x15, 0x6c, 0x00, + 0x6e, 0x90, 0x07, 0x6f, 0x00, 0x6e, 0x93, 0x46, + 0x31, 0x00, 0x6e, 0x96, 0x09, 0x6a, 0x00, 0x6e, + 0x98, 0x15, 0x62, 0x00, 0x6e, 0x99, 0x55, 0x7d, + 0x00, 0x6e, 0x9c, 0x0f, 0x77, 0x00, 0x6e, 0x9d, + 0x07, 0xd4, 0x00, 0x6e, 0x9f, 0x15, 0x6f, 0x00, + 0x6e, 0xa0, 0x55, 0x7e, 0x00, 0x6e, 0xa2, 0x04, + 0xb2, 0x00, 0x6e, 0xa5, 0x15, 0x6d, 0x00, 0x6e, + 0xa7, 0x46, 0x32, 0x00, 0x6e, 0xaa, 0x15, 0x61, + 0x00, 0x6e, 0xab, 0x34, 0x0c, 0x00, 0x6e, 0xad, + 0x55, 0x7f, 0x00, 0x6e, 0xae, 0x55, 0x80, 0x00, + 0x6e, 0xaf, 0x15, 0x67, 0x00, 0x6e, 0xb1, 0x42, + 0x2e, 0x00, 0x6e, 0xb2, 0x15, 0x69, 0x00, 0x6e, + 0xb3, 0x55, 0x81, 0x00, 0x6e, 0xb4, 0x46, 0x33, + 0x00, 0x6e, 0xb6, 0x0f, 0x39, 0x00, 0x6e, 0xb7, + 0x15, 0x64, 0x00, 0x6e, 0xba, 0x0c, 0x28, 0x00, + 0x6e, 0xbb, 0x55, 0x82, 0x00, 0x6e, 0xbc, 0x4c, + 0x2d, 0x00, 0x6e, 0xbd, 0x15, 0x66, 0x00, 0x6e, + 0xbf, 0x21, 0x50, 0x00, 0x6e, 0xc0, 0x55, 0x83, + 0x00, 0x6e, 0xc1, 0x42, 0x2f, 0x00, 0x6e, 0xc2, + 0x15, 0x6e, 0x00, 0x6e, 0xc3, 0x46, 0x34, 0x00, + 0x6e, 0xc4, 0x15, 0x68, 0x00, 0x6e, 0xc5, 0x0e, + 0xd3, 0x00, 0x6e, 0xc7, 0x39, 0x7f, 0x00, 0x6e, + 0xc8, 0x55, 0x84, 0x00, 0x6e, 0xc9, 0x15, 0x63, + 0x00, 0x6e, 0xca, 0x39, 0x80, 0x00, 0x6e, 0xcb, + 0x08, 0xce, 0x00, 0x6e, 0xcc, 0x15, 0x7b, 0x00, + 0x6e, 0xcd, 0x55, 0x85, 0x00, 0x6e, 0xce, 0x39, + 0x81, 0x00, 0x6e, 0xcf, 0x55, 0x86, 0x00, 0x6e, + 0xd1, 0x05, 0xc8, 0x00, 0x6e, 0xd3, 0x15, 0x65, + 0x00, 0x6e, 0xd4, 0x15, 0x6a, 0x00, 0x6e, 0xd5, + 0x15, 0x6b, 0x00, 0x6e, 0xd9, 0x3c, 0x38, 0x00, + 0x6e, 0xda, 0x4c, 0x2e, 0x00, 0x6e, 0xdb, 0x4c, + 0x2f, 0x00, 0x6e, 0xdd, 0x0b, 0x4c, 0x00, 0x6e, + 0xde, 0x0b, 0x3a, 0x00, 0x6e, 0xe6, 0x3c, 0x24, + 0x00, 0x6e, 0xeb, 0x46, 0x36, 0x00, 0x6e, 0xec, + 0x15, 0x73, 0x00, 0x6e, 0xed, 0x55, 0x87, 0x00, + 0x6e, 0xee, 0x55, 0x88, 0x00, 0x6e, 0xef, 0x15, + 0x79, 0x00, 0x6e, 0xf2, 0x15, 0x77, 0x00, 0x6e, + 0xf4, 0x0c, 0x23, 0x00, 0x6e, 0xf7, 0x15, 0x7e, + 0x00, 0x6e, 0xf8, 0x15, 0x74, 0x00, 0x6e, 0xf9, + 0x46, 0x37, 0x00, 0x6e, 0xfb, 0x46, 0x38, 0x00, + 0x6e, 0xfd, 0x39, 0x82, 0x00, 0x6e, 0xfe, 0x15, + 0x75, 0x00, 0x6e, 0xff, 0x15, 0x5d, 0x00, 0x6f, + 0x01, 0x06, 0x93, 0x00, 0x6f, 0x02, 0x0d, 0xac, + 0x00, 0x6f, 0x04, 0x55, 0x89, 0x00, 0x6f, 0x06, + 0x08, 0xeb, 0x00, 0x6f, 0x08, 0x55, 0x8a, 0x00, + 0x6f, 0x09, 0x08, 0x09, 0x00, 0x6f, 0x0a, 0x46, + 0x39, 0x00, 0x6f, 0x0c, 0x46, 0x3a, 0x00, 0x6f, + 0x0d, 0x55, 0x8b, 0x00, 0x6f, 0x0f, 0x0f, 0xd9, + 0x00, 0x6f, 0x10, 0x42, 0x30, 0x00, 0x6f, 0x11, + 0x15, 0x71, 0x00, 0x6f, 0x13, 0x15, 0x7d, 0x00, + 0x6f, 0x14, 0x05, 0x0b, 0x00, 0x6f, 0x15, 0x0a, + 0xe8, 0x00, 0x6f, 0x16, 0x55, 0x8c, 0x00, 0x6f, + 0x18, 0x46, 0x3b, 0x00, 0x6f, 0x1a, 0x39, 0x83, + 0x00, 0x6f, 0x1b, 0x55, 0x8d, 0x00, 0x6f, 0x20, + 0x0d, 0x2f, 0x00, 0x6f, 0x22, 0x05, 0xfd, 0x00, + 0x6f, 0x23, 0x1e, 0x81, 0x00, 0x6f, 0x25, 0x46, + 0x3c, 0x00, 0x6f, 0x26, 0x4c, 0x30, 0x00, 0x6f, + 0x29, 0x4c, 0x31, 0x00, 0x6f, 0x2a, 0x39, 0x84, + 0x00, 0x6f, 0x2b, 0x0e, 0xad, 0x00, 0x6f, 0x2c, + 0x0b, 0xee, 0x00, 0x6f, 0x2d, 0x55, 0x8f, 0x00, + 0x6f, 0x2f, 0x39, 0x85, 0x00, 0x6f, 0x30, 0x4c, + 0x32, 0x00, 0x6f, 0x31, 0x15, 0x78, 0x00, 0x6f, + 0x32, 0x15, 0x7a, 0x00, 0x6f, 0x33, 0x39, 0x86, + 0x00, 0x6f, 0x35, 0x46, 0x35, 0x00, 0x6f, 0x36, + 0x46, 0x3d, 0x00, 0x6f, 0x38, 0x0a, 0xb4, 0x00, + 0x6f, 0x3b, 0x55, 0x8e, 0x00, 0x6f, 0x3c, 0x46, + 0x3e, 0x00, 0x6f, 0x3e, 0x15, 0x7c, 0x00, 0x6f, + 0x3f, 0x15, 0x76, 0x00, 0x6f, 0x41, 0x15, 0x70, + 0x00, 0x6f, 0x45, 0x05, 0xff, 0x00, 0x6f, 0x4f, + 0x55, 0x90, 0x00, 0x6f, 0x51, 0x1e, 0x60, 0x00, + 0x6f, 0x52, 0x46, 0x40, 0x00, 0x6f, 0x53, 0x55, + 0x91, 0x00, 0x6f, 0x54, 0x07, 0x3f, 0x00, 0x6f, + 0x57, 0x46, 0x41, 0x00, 0x6f, 0x58, 0x15, 0x8a, + 0x00, 0x6f, 0x59, 0x42, 0x31, 0x00, 0x6f, 0x5a, + 0x39, 0x87, 0x00, 0x6f, 0x5b, 0x15, 0x85, 0x00, + 0x6f, 0x5c, 0x0a, 0x9c, 0x00, 0x6f, 0x5d, 0x55, + 0x92, 0x00, 0x6f, 0x5e, 0x39, 0x88, 0x00, 0x6f, + 0x5f, 0x05, 0xc1, 0x00, 0x6f, 0x60, 0x46, 0x42, + 0x00, 0x6f, 0x61, 0x42, 0x32, 0x00, 0x6f, 0x62, + 0x39, 0x89, 0x00, 0x6f, 0x64, 0x09, 0x6b, 0x00, + 0x6f, 0x66, 0x15, 0x8e, 0x00, 0x6f, 0x68, 0x46, + 0x43, 0x00, 0x6f, 0x6c, 0x55, 0x93, 0x00, 0x6f, + 0x6d, 0x15, 0x87, 0x00, 0x6f, 0x6e, 0x36, 0x6c, + 0x00, 0x6f, 0x6f, 0x15, 0x84, 0x00, 0x6f, 0x70, + 0x0b, 0xf5, 0x00, 0x6f, 0x74, 0x15, 0xa7, 0x00, + 0x6f, 0x78, 0x15, 0x81, 0x00, 0x6f, 0x7a, 0x15, + 0x80, 0x00, 0x6f, 0x7c, 0x15, 0x89, 0x00, 0x6f, + 0x7d, 0x39, 0x8a, 0x00, 0x6f, 0x7e, 0x42, 0x33, + 0x00, 0x6f, 0x80, 0x15, 0x83, 0x00, 0x6f, 0x81, + 0x15, 0x82, 0x00, 0x6f, 0x82, 0x15, 0x88, 0x00, + 0x6f, 0x83, 0x55, 0x94, 0x00, 0x6f, 0x84, 0x0a, + 0x45, 0x00, 0x6f, 0x86, 0x15, 0x7f, 0x00, 0x6f, + 0x87, 0x4c, 0x33, 0x00, 0x6f, 0x88, 0x21, 0x51, + 0x00, 0x6f, 0x8b, 0x39, 0x8b, 0x00, 0x6f, 0x8c, + 0x42, 0x34, 0x00, 0x6f, 0x8d, 0x39, 0x8c, 0x00, + 0x6f, 0x8e, 0x15, 0x8b, 0x00, 0x6f, 0x90, 0x46, + 0x44, 0x00, 0x6f, 0x91, 0x15, 0x8c, 0x00, 0x6f, + 0x92, 0x39, 0x8d, 0x00, 0x6f, 0x93, 0x55, 0x95, + 0x00, 0x6f, 0x94, 0x39, 0x8e, 0x00, 0x6f, 0x96, + 0x46, 0x45, 0x00, 0x6f, 0x97, 0x05, 0xfe, 0x00, + 0x6f, 0x98, 0x36, 0x3c, 0x00, 0x6f, 0x9a, 0x39, + 0x8f, 0x00, 0x6f, 0x9d, 0x4c, 0x34, 0x00, 0x6f, + 0x9f, 0x46, 0x47, 0x00, 0x6f, 0xa0, 0x42, 0x35, + 0x00, 0x6f, 0xa1, 0x15, 0x91, 0x00, 0x6f, 0xa3, + 0x15, 0x90, 0x00, 0x6f, 0xa4, 0x15, 0x92, 0x00, + 0x6f, 0xa5, 0x46, 0x48, 0x00, 0x6f, 0xa6, 0x55, + 0x96, 0x00, 0x6f, 0xa7, 0x39, 0x90, 0x00, 0x6f, + 0xa8, 0x39, 0x91, 0x00, 0x6f, 0xaa, 0x15, 0x95, + 0x00, 0x6f, 0xae, 0x4c, 0x35, 0x00, 0x6f, 0xaf, + 0x46, 0x49, 0x00, 0x6f, 0xb0, 0x55, 0x97, 0x00, + 0x6f, 0xb1, 0x0c, 0x3d, 0x00, 0x6f, 0xb3, 0x15, + 0x8f, 0x00, 0x6f, 0xb5, 0x21, 0x52, 0x00, 0x6f, + 0xb6, 0x39, 0x92, 0x00, 0x6f, 0xb7, 0x4c, 0x36, + 0x00, 0x6f, 0xb9, 0x15, 0x93, 0x00, 0x6f, 0xbc, + 0x42, 0x36, 0x00, 0x6f, 0xbe, 0x46, 0x46, 0x00, + 0x6f, 0xc0, 0x07, 0x39, 0x00, 0x6f, 0xc1, 0x0b, + 0x59, 0x00, 0x6f, 0xc2, 0x15, 0x8d, 0x00, 0x6f, + 0xc3, 0x0c, 0xf1, 0x00, 0x6f, 0xc5, 0x55, 0x98, + 0x00, 0x6f, 0xc6, 0x15, 0x94, 0x00, 0x6f, 0xc7, + 0x42, 0x37, 0x00, 0x6f, 0xc8, 0x46, 0x4b, 0x00, + 0x6f, 0xc9, 0x46, 0x4c, 0x00, 0x6f, 0xca, 0x42, + 0x38, 0x00, 0x6f, 0xd4, 0x15, 0x99, 0x00, 0x6f, + 0xd5, 0x15, 0x97, 0x00, 0x6f, 0xd8, 0x15, 0x9a, + 0x00, 0x6f, 0xda, 0x39, 0x93, 0x00, 0x6f, 0xdb, + 0x15, 0x9d, 0x00, 0x6f, 0xde, 0x39, 0x94, 0x00, + 0x6f, 0xdf, 0x15, 0x96, 0x00, 0x6f, 0xe0, 0x07, + 0xfc, 0x00, 0x6f, 0xe1, 0x0c, 0xde, 0x00, 0x6f, + 0xe4, 0x15, 0x36, 0x00, 0x6f, 0xe8, 0x55, 0x99, + 0x00, 0x6f, 0xe9, 0x46, 0x4d, 0x00, 0x6f, 0xeb, + 0x0f, 0x5e, 0x00, 0x6f, 0xec, 0x15, 0x98, 0x00, + 0x6f, 0xee, 0x15, 0x9c, 0x00, 0x6f, 0xef, 0x0b, + 0x55, 0x00, 0x6f, 0xf0, 0x42, 0x39, 0x00, 0x6f, + 0xf1, 0x15, 0x9b, 0x00, 0x6f, 0xf3, 0x15, 0x86, + 0x00, 0x6f, 0xf5, 0x21, 0x53, 0x00, 0x6f, 0xf6, + 0x1b, 0xa4, 0x00, 0x6f, 0xf9, 0x3c, 0x23, 0x00, + 0x6f, 0xfa, 0x15, 0xa0, 0x00, 0x6f, 0xfc, 0x46, + 0x4f, 0x00, 0x6f, 0xfd, 0x55, 0x9a, 0x00, 0x6f, + 0xfe, 0x15, 0xa4, 0x00, 0x70, 0x00, 0x46, 0x50, + 0x00, 0x70, 0x01, 0x15, 0xa2, 0x00, 0x70, 0x05, + 0x21, 0x54, 0x00, 0x70, 0x06, 0x1e, 0x50, 0x00, + 0x70, 0x07, 0x21, 0x55, 0x00, 0x70, 0x09, 0x15, + 0x9e, 0x00, 0x70, 0x0a, 0x46, 0x51, 0x00, 0x70, + 0x0b, 0x15, 0x9f, 0x00, 0x70, 0x0d, 0x4c, 0x37, + 0x00, 0x70, 0x0f, 0x15, 0xa3, 0x00, 0x70, 0x11, + 0x15, 0xa1, 0x00, 0x70, 0x15, 0x0d, 0xc0, 0x00, + 0x70, 0x17, 0x55, 0x9b, 0x00, 0x70, 0x18, 0x15, + 0xa9, 0x00, 0x70, 0x1a, 0x15, 0xa6, 0x00, 0x70, + 0x1b, 0x15, 0xa5, 0x00, 0x70, 0x1d, 0x15, 0xa8, + 0x00, 0x70, 0x1e, 0x0c, 0xac, 0x00, 0x70, 0x1f, + 0x15, 0xaa, 0x00, 0x70, 0x20, 0x4c, 0x38, 0x00, + 0x70, 0x23, 0x46, 0x52, 0x00, 0x70, 0x26, 0x0b, + 0xb3, 0x00, 0x70, 0x27, 0x0b, 0x4d, 0x00, 0x70, + 0x28, 0x21, 0x56, 0x00, 0x70, 0x2c, 0x0a, 0x49, + 0x00, 0x70, 0x2f, 0x55, 0x9c, 0x00, 0x70, 0x30, + 0x15, 0xab, 0x00, 0x70, 0x32, 0x15, 0xad, 0x00, + 0x70, 0x34, 0x55, 0x9d, 0x00, 0x70, 0x37, 0x55, + 0x9e, 0x00, 0x70, 0x39, 0x39, 0x96, 0x00, 0x70, + 0x3a, 0x46, 0x54, 0x00, 0x70, 0x3c, 0x39, 0x97, + 0x00, 0x70, 0x3e, 0x15, 0xac, 0x00, 0x70, 0x43, + 0x46, 0x55, 0x00, 0x70, 0x44, 0x55, 0x9f, 0x00, + 0x70, 0x47, 0x46, 0x56, 0x00, 0x70, 0x48, 0x55, + 0xa0, 0x00, 0x70, 0x49, 0x4c, 0x39, 0x00, 0x70, + 0x4a, 0x4f, 0x52, 0x00, 0x70, 0x4b, 0x46, 0x57, + 0x00, 0x70, 0x4c, 0x15, 0x72, 0x00, 0x70, 0x4e, + 0x42, 0x3a, 0x00, 0x70, 0x51, 0x15, 0xae, 0x00, + 0x70, 0x54, 0x39, 0x99, 0x00, 0x70, 0x55, 0x55, + 0xa1, 0x00, 0x70, 0x58, 0x0c, 0xbf, 0x00, 0x70, + 0x5d, 0x39, 0x9a, 0x00, 0x70, 0x5e, 0x39, 0x9b, + 0x00, 0x70, 0x63, 0x15, 0xaf, 0x00, 0x70, 0x64, + 0x39, 0x9c, 0x00, 0x70, 0x65, 0x46, 0x59, 0x00, + 0x70, 0x69, 0x46, 0x5a, 0x00, 0x70, 0x6b, 0x05, + 0x50, 0x00, 0x70, 0x6c, 0x39, 0x9d, 0x00, 0x70, + 0x6e, 0x46, 0x5b, 0x00, 0x70, 0x6f, 0x0c, 0x6e, + 0x00, 0x70, 0x70, 0x05, 0x83, 0x00, 0x70, 0x75, + 0x42, 0x3b, 0x00, 0x70, 0x76, 0x46, 0x5c, 0x00, + 0x70, 0x78, 0x06, 0x7e, 0x00, 0x70, 0x7c, 0x09, + 0x0a, 0x00, 0x70, 0x7d, 0x08, 0x42, 0x00, 0x70, + 0x7e, 0x39, 0x9e, 0x00, 0x70, 0x81, 0x39, 0x9f, + 0x00, 0x70, 0x85, 0x21, 0x57, 0x00, 0x70, 0x86, + 0x46, 0x5d, 0x00, 0x70, 0x89, 0x0f, 0xcd, 0x00, + 0x70, 0x8a, 0x0a, 0x2c, 0x00, 0x70, 0x8e, 0x05, + 0x0c, 0x00, 0x70, 0x92, 0x15, 0xb1, 0x00, 0x70, + 0x94, 0x55, 0xa2, 0x00, 0x70, 0x95, 0x39, 0xa0, + 0x00, 0x70, 0x96, 0x55, 0xa3, 0x00, 0x70, 0x97, + 0x46, 0x5e, 0x00, 0x70, 0x98, 0x4c, 0x3a, 0x00, + 0x70, 0x99, 0x15, 0xb0, 0x00, 0x70, 0x9b, 0x55, + 0xa4, 0x00, 0x70, 0x9f, 0x46, 0x60, 0x00, 0x70, + 0xa4, 0x42, 0x3c, 0x00, 0x70, 0xab, 0x21, 0x58, + 0x00, 0x70, 0xac, 0x15, 0xb4, 0x00, 0x70, 0xad, + 0x0b, 0x78, 0x00, 0x70, 0xae, 0x15, 0xb7, 0x00, + 0x70, 0xaf, 0x15, 0xb2, 0x00, 0x70, 0xb0, 0x4c, + 0x3b, 0x00, 0x70, 0xb1, 0x46, 0x61, 0x00, 0x70, + 0xb3, 0x15, 0xb6, 0x00, 0x70, 0xb4, 0x55, 0xa5, + 0x00, 0x70, 0xb7, 0x39, 0xa1, 0x00, 0x70, 0xb8, + 0x15, 0xb5, 0x00, 0x70, 0xb9, 0x0c, 0x3a, 0x00, + 0x70, 0xba, 0x04, 0x9d, 0x00, 0x70, 0xbb, 0x20, + 0xad, 0x00, 0x70, 0xc8, 0x0f, 0xbd, 0x00, 0x70, + 0xca, 0x46, 0x64, 0x00, 0x70, 0xcb, 0x15, 0xb9, + 0x00, 0x70, 0xcf, 0x04, 0xca, 0x00, 0x70, 0xd1, + 0x46, 0x65, 0x00, 0x70, 0xd3, 0x39, 0xa2, 0x00, + 0x70, 0xd4, 0x39, 0xa3, 0x00, 0x70, 0xd5, 0x4c, + 0x3c, 0x00, 0x70, 0xd6, 0x4c, 0x3d, 0x00, 0x70, + 0xd8, 0x39, 0xa4, 0x00, 0x70, 0xd9, 0x15, 0xbb, + 0x00, 0x70, 0xdc, 0x39, 0xa5, 0x00, 0x70, 0xdd, + 0x15, 0xba, 0x00, 0x70, 0xdf, 0x15, 0xb8, 0x00, + 0x70, 0xe4, 0x42, 0x3d, 0x00, 0x70, 0xec, 0x46, + 0x63, 0x00, 0x70, 0xf1, 0x15, 0xb3, 0x00, 0x70, + 0xf9, 0x0e, 0x51, 0x00, 0x70, 0xfa, 0x55, 0xa6, + 0x00, 0x70, 0xfd, 0x15, 0xbd, 0x00, 0x71, 0x03, + 0x46, 0x66, 0x00, 0x71, 0x04, 0x21, 0x5a, 0x00, + 0x71, 0x05, 0x55, 0xa7, 0x00, 0x71, 0x06, 0x46, + 0x67, 0x00, 0x71, 0x07, 0x39, 0xa6, 0x00, 0x71, + 0x08, 0x46, 0x68, 0x00, 0x71, 0x09, 0x15, 0xbc, + 0x00, 0x71, 0x0b, 0x55, 0xa8, 0x00, 0x71, 0x0c, + 0x46, 0x69, 0x00, 0x71, 0x0f, 0x21, 0x59, 0x00, + 0x71, 0x14, 0x05, 0x0d, 0x00, 0x71, 0x19, 0x15, + 0xbf, 0x00, 0x71, 0x1a, 0x0e, 0x02, 0x00, 0x71, + 0x1c, 0x15, 0xbe, 0x00, 0x71, 0x1e, 0x42, 0x3f, + 0x00, 0x71, 0x20, 0x39, 0xa7, 0x00, 0x71, 0x21, + 0x0e, 0xc1, 0x00, 0x71, 0x26, 0x09, 0xaf, 0x00, + 0x71, 0x2b, 0x42, 0x3e, 0x00, 0x71, 0x2d, 0x55, + 0xa9, 0x00, 0x71, 0x2e, 0x42, 0x40, 0x00, 0x71, + 0x2f, 0x46, 0x6b, 0x00, 0x71, 0x30, 0x1d, 0xdc, + 0x00, 0x71, 0x31, 0x39, 0xa8, 0x00, 0x71, 0x36, + 0x0a, 0xb5, 0x00, 0x71, 0x38, 0x55, 0xaa, 0x00, + 0x71, 0x3c, 0x09, 0xae, 0x00, 0x71, 0x41, 0x55, + 0xab, 0x00, 0x71, 0x45, 0x4c, 0x3e, 0x00, 0x71, + 0x46, 0x21, 0x5c, 0x00, 0x71, 0x47, 0x21, 0x5d, + 0x00, 0x71, 0x49, 0x1e, 0x82, 0x00, 0x71, 0x4a, + 0x39, 0xa9, 0x00, 0x71, 0x4b, 0x55, 0xac, 0x00, + 0x71, 0x4c, 0x15, 0xc5, 0x00, 0x71, 0x4e, 0x0a, + 0x9d, 0x00, 0x71, 0x50, 0x46, 0x6c, 0x00, 0x71, + 0x51, 0x42, 0x41, 0x00, 0x71, 0x52, 0x39, 0xaa, + 0x00, 0x71, 0x53, 0x46, 0x6d, 0x00, 0x71, 0x55, + 0x15, 0xc1, 0x00, 0x71, 0x56, 0x15, 0xc6, 0x00, + 0x71, 0x57, 0x55, 0xae, 0x00, 0x71, 0x59, 0x05, + 0x0e, 0x00, 0x71, 0x5a, 0x55, 0xaf, 0x00, 0x71, + 0x5c, 0x21, 0x5b, 0x00, 0x71, 0x5e, 0x46, 0x6e, + 0x00, 0x71, 0x60, 0x39, 0xab, 0x00, 0x71, 0x62, + 0x15, 0xc4, 0x00, 0x71, 0x64, 0x0d, 0x17, 0x00, + 0x71, 0x65, 0x15, 0xc0, 0x00, 0x71, 0x66, 0x15, + 0xc3, 0x00, 0x71, 0x67, 0x09, 0xb0, 0x00, 0x71, + 0x68, 0x42, 0x42, 0x00, 0x71, 0x69, 0x0d, 0x65, + 0x00, 0x71, 0x6c, 0x15, 0xc7, 0x00, 0x71, 0x6e, + 0x34, 0x23, 0x00, 0x71, 0x79, 0x39, 0xac, 0x00, + 0x71, 0x7d, 0x0a, 0x9e, 0x00, 0x71, 0x80, 0x46, + 0x71, 0x00, 0x71, 0x84, 0x15, 0xca, 0x00, 0x71, + 0x85, 0x42, 0x43, 0x00, 0x71, 0x87, 0x42, 0x44, + 0x00, 0x71, 0x88, 0x15, 0xc2, 0x00, 0x71, 0x8a, + 0x06, 0xfd, 0x00, 0x71, 0x8c, 0x55, 0xb0, 0x00, + 0x71, 0x8f, 0x15, 0xc8, 0x00, 0x71, 0x92, 0x39, + 0xad, 0x00, 0x71, 0x94, 0x0f, 0x3a, 0x00, 0x71, + 0x95, 0x15, 0xcb, 0x00, 0x71, 0x96, 0x46, 0x70, + 0x00, 0x71, 0x99, 0x20, 0x5d, 0x00, 0x71, 0x9a, + 0x55, 0xb1, 0x00, 0x71, 0x9b, 0x46, 0x72, 0x00, + 0x71, 0x9f, 0x09, 0x59, 0x00, 0x71, 0xa0, 0x46, + 0x73, 0x00, 0x71, 0xa2, 0x46, 0x74, 0x00, 0x71, + 0xa8, 0x15, 0xcc, 0x00, 0x71, 0xac, 0x15, 0xcd, + 0x00, 0x71, 0xae, 0x46, 0x75, 0x00, 0x71, 0xaf, + 0x46, 0x76, 0x00, 0x71, 0xb0, 0x55, 0xb2, 0x00, + 0x71, 0xb1, 0x0c, 0xe4, 0x00, 0x71, 0xb2, 0x4c, + 0x3f, 0x00, 0x71, 0xb3, 0x3c, 0x25, 0x00, 0x71, + 0xb9, 0x15, 0xcf, 0x00, 0x71, 0xba, 0x42, 0x45, + 0x00, 0x71, 0xbe, 0x15, 0xd0, 0x00, 0x71, 0xbf, + 0x55, 0xb3, 0x00, 0x71, 0xc0, 0x55, 0xb4, 0x00, + 0x71, 0xc1, 0x21, 0x5f, 0x00, 0x71, 0xc3, 0x0c, + 0xe9, 0x00, 0x71, 0xc4, 0x42, 0x46, 0x00, 0x71, + 0xc8, 0x0c, 0x6f, 0x00, 0x71, 0xc9, 0x15, 0xd2, + 0x00, 0x71, 0xcb, 0x39, 0xaf, 0x00, 0x71, 0xcc, + 0x55, 0xb5, 0x00, 0x71, 0xce, 0x15, 0xd4, 0x00, + 0x71, 0xd0, 0x0f, 0x9d, 0x00, 0x71, 0xd2, 0x15, + 0xd1, 0x00, 0x71, 0xd3, 0x39, 0xb0, 0x00, 0x71, + 0xd4, 0x15, 0xd3, 0x00, 0x71, 0xd5, 0x05, 0x0f, + 0x00, 0x71, 0xd6, 0x39, 0xb1, 0x00, 0x71, 0xd7, + 0x15, 0xce, 0x00, 0x71, 0xd9, 0x46, 0x78, 0x00, + 0x71, 0xda, 0x55, 0xb6, 0x00, 0x71, 0xdc, 0x46, + 0x79, 0x00, 0x71, 0xdf, 0x11, 0x4e, 0x00, 0x71, + 0xe0, 0x15, 0xd5, 0x00, 0x71, 0xe5, 0x0a, 0xe9, + 0x00, 0x71, 0xe6, 0x08, 0x86, 0x00, 0x71, 0xe7, + 0x15, 0xd7, 0x00, 0x71, 0xec, 0x15, 0xd6, 0x00, + 0x71, 0xed, 0x09, 0xea, 0x00, 0x71, 0xee, 0x10, + 0xee, 0x00, 0x71, 0xf4, 0x4c, 0x40, 0x00, 0x71, + 0xf5, 0x15, 0xd8, 0x00, 0x71, 0xf8, 0x55, 0xb7, + 0x00, 0x71, 0xf9, 0x15, 0xda, 0x00, 0x71, 0xfb, + 0x15, 0xc9, 0x00, 0x71, 0xfc, 0x15, 0xd9, 0x00, + 0x71, 0xfe, 0x21, 0x60, 0x00, 0x71, 0xff, 0x15, + 0xdb, 0x00, 0x72, 0x00, 0x39, 0xb2, 0x00, 0x72, + 0x06, 0x0d, 0x30, 0x00, 0x72, 0x07, 0x46, 0x7a, + 0x00, 0x72, 0x08, 0x55, 0xb8, 0x00, 0x72, 0x09, + 0x55, 0xb9, 0x00, 0x72, 0x0d, 0x15, 0xdc, 0x00, + 0x72, 0x10, 0x15, 0xdd, 0x00, 0x72, 0x13, 0x55, + 0xba, 0x00, 0x72, 0x15, 0x42, 0x47, 0x00, 0x72, + 0x17, 0x4c, 0x41, 0x00, 0x72, 0x1a, 0x55, 0xbb, + 0x00, 0x72, 0x1b, 0x15, 0xde, 0x00, 0x72, 0x1d, + 0x39, 0xb3, 0x00, 0x72, 0x1f, 0x4c, 0x42, 0x00, + 0x72, 0x24, 0x55, 0xbc, 0x00, 0x72, 0x28, 0x1e, + 0x9f, 0x00, 0x72, 0x2a, 0x0b, 0xfa, 0x00, 0x72, + 0x2b, 0x39, 0xb4, 0x00, 0x72, 0x2c, 0x15, 0xe1, + 0x00, 0x72, 0x2d, 0x15, 0xe0, 0x00, 0x72, 0x2f, + 0x55, 0xbd, 0x00, 0x72, 0x30, 0x15, 0xe2, 0x00, + 0x72, 0x32, 0x15, 0xe3, 0x00, 0x72, 0x34, 0x46, + 0x7c, 0x00, 0x72, 0x35, 0x35, 0xf1, 0x00, 0x72, + 0x36, 0x0d, 0xd5, 0x00, 0x72, 0x38, 0x39, 0xb5, + 0x00, 0x72, 0x39, 0x46, 0x7d, 0x00, 0x72, 0x3a, + 0x0e, 0xf8, 0x00, 0x72, 0x3b, 0x15, 0xe4, 0x00, + 0x72, 0x3c, 0x15, 0xe5, 0x00, 0x72, 0x3d, 0x0a, + 0xd8, 0x00, 0x72, 0x3e, 0x08, 0xd0, 0x00, 0x72, + 0x3f, 0x15, 0xe6, 0x00, 0x72, 0x40, 0x15, 0xe7, + 0x00, 0x72, 0x41, 0x39, 0xb6, 0x00, 0x72, 0x42, + 0x46, 0x7e, 0x00, 0x72, 0x43, 0x4c, 0x43, 0x00, + 0x72, 0x45, 0x55, 0xbe, 0x00, 0x72, 0x46, 0x15, + 0xe8, 0x00, 0x72, 0x47, 0x0e, 0x22, 0x00, 0x72, + 0x48, 0x0d, 0x5b, 0x00, 0x72, 0x4b, 0x15, 0xe9, + 0x00, 0x72, 0x4c, 0x0d, 0x0d, 0x00, 0x72, 0x4e, + 0x55, 0xbf, 0x00, 0x72, 0x4f, 0x4c, 0x44, 0x00, + 0x72, 0x50, 0x4c, 0x45, 0x00, 0x72, 0x52, 0x0b, + 0xc9, 0x00, 0x72, 0x53, 0x39, 0xb7, 0x00, 0x72, + 0x55, 0x39, 0xb8, 0x00, 0x72, 0x56, 0x39, 0xb9, + 0x00, 0x72, 0x57, 0x46, 0x7f, 0x00, 0x72, 0x58, + 0x15, 0xea, 0x00, 0x72, 0x59, 0x05, 0x67, 0x00, + 0x72, 0x5a, 0x4c, 0x46, 0x00, 0x72, 0x5b, 0x06, + 0x87, 0x00, 0x72, 0x5c, 0x39, 0xba, 0x00, 0x72, + 0x5d, 0x0e, 0xd2, 0x00, 0x72, 0x5e, 0x55, 0xc0, + 0x00, 0x72, 0x5f, 0x0e, 0xc2, 0x00, 0x72, 0x60, + 0x4c, 0x47, 0x00, 0x72, 0x61, 0x05, 0x34, 0x00, + 0x72, 0x62, 0x0f, 0xda, 0x00, 0x72, 0x63, 0x46, + 0x80, 0x00, 0x72, 0x67, 0x0e, 0x80, 0x00, 0x72, + 0x68, 0x4c, 0x48, 0x00, 0x72, 0x69, 0x0d, 0xfa, + 0x00, 0x72, 0x6b, 0x55, 0xc1, 0x00, 0x72, 0x6e, + 0x46, 0x82, 0x00, 0x72, 0x6f, 0x46, 0x83, 0x00, + 0x72, 0x71, 0x55, 0xc2, 0x00, 0x72, 0x72, 0x0a, + 0x5b, 0x00, 0x72, 0x74, 0x15, 0xeb, 0x00, 0x72, + 0x77, 0x4c, 0x49, 0x00, 0x72, 0x78, 0x46, 0x84, + 0x00, 0x72, 0x79, 0x0c, 0x9b, 0x00, 0x72, 0x7b, + 0x55, 0xc3, 0x00, 0x72, 0x7c, 0x55, 0xc4, 0x00, + 0x72, 0x7d, 0x07, 0x57, 0x00, 0x72, 0x7e, 0x15, + 0xec, 0x00, 0x72, 0x7f, 0x46, 0x85, 0x00, 0x72, + 0x80, 0x08, 0x44, 0x00, 0x72, 0x81, 0x15, 0xee, + 0x00, 0x72, 0x82, 0x15, 0xed, 0x00, 0x72, 0x84, + 0x4c, 0x4a, 0x00, 0x72, 0x87, 0x15, 0xef, 0x00, + 0x72, 0x89, 0x55, 0xc5, 0x00, 0x72, 0x8d, 0x39, + 0xbb, 0x00, 0x72, 0x8e, 0x46, 0x86, 0x00, 0x72, + 0x92, 0x15, 0xf0, 0x00, 0x72, 0x93, 0x55, 0xc6, + 0x00, 0x72, 0x96, 0x15, 0xf1, 0x00, 0x72, 0x9b, + 0x42, 0x49, 0x00, 0x72, 0xa0, 0x06, 0x58, 0x00, + 0x72, 0xa2, 0x15, 0xf2, 0x00, 0x72, 0xa7, 0x15, + 0xf3, 0x00, 0x72, 0xa8, 0x55, 0xc7, 0x00, 0x72, + 0xac, 0x07, 0x58, 0x00, 0x72, 0xad, 0x39, 0xbc, + 0x00, 0x72, 0xae, 0x46, 0x88, 0x00, 0x72, 0xaf, + 0x0d, 0x5c, 0x00, 0x72, 0xb0, 0x46, 0x89, 0x00, + 0x72, 0xb1, 0x21, 0x61, 0x00, 0x72, 0xb2, 0x15, + 0xf5, 0x00, 0x72, 0xb4, 0x39, 0xbd, 0x00, 0x72, + 0xb6, 0x09, 0xdd, 0x00, 0x72, 0xb9, 0x15, 0xf4, + 0x00, 0x72, 0xbe, 0x21, 0x62, 0x00, 0x72, 0xc0, + 0x34, 0x2b, 0x00, 0x72, 0xc1, 0x46, 0x8a, 0x00, + 0x72, 0xc2, 0x06, 0xb0, 0x00, 0x72, 0xc3, 0x15, + 0xf6, 0x00, 0x72, 0xc4, 0x15, 0xf8, 0x00, 0x72, + 0xc6, 0x15, 0xf7, 0x00, 0x72, 0xc7, 0x39, 0xbe, + 0x00, 0x72, 0xc9, 0x4c, 0x4b, 0x00, 0x72, 0xcc, + 0x46, 0x8c, 0x00, 0x72, 0xce, 0x15, 0xf9, 0x00, + 0x72, 0xd0, 0x07, 0x85, 0x00, 0x72, 0xd2, 0x15, + 0xfa, 0x00, 0x72, 0xd5, 0x55, 0xc8, 0x00, 0x72, + 0xd6, 0x55, 0xc9, 0x00, 0x72, 0xd7, 0x06, 0xe1, + 0x00, 0x72, 0xd8, 0x55, 0xca, 0x00, 0x72, 0xd9, + 0x0a, 0xc2, 0x00, 0x72, 0xdb, 0x08, 0x0f, 0x00, + 0x72, 0xdf, 0x55, 0xcb, 0x00, 0x72, 0xe0, 0x15, + 0xfc, 0x00, 0x72, 0xe1, 0x15, 0xfd, 0x00, 0x72, + 0xe2, 0x15, 0xfb, 0x00, 0x72, 0xe5, 0x4c, 0x4c, + 0x00, 0x72, 0xe9, 0x09, 0x19, 0x00, 0x72, 0xec, + 0x0c, 0xa0, 0x00, 0x72, 0xed, 0x06, 0xb1, 0x00, + 0x72, 0xf3, 0x46, 0x8f, 0x00, 0x72, 0xf4, 0x4c, + 0x4d, 0x00, 0x72, 0xf7, 0x15, 0xff, 0x00, 0x72, + 0xf8, 0x0b, 0x6a, 0x00, 0x72, 0xf9, 0x15, 0xfe, + 0x00, 0x72, 0xfa, 0x46, 0x90, 0x00, 0x72, 0xfb, + 0x39, 0xbf, 0x00, 0x72, 0xfc, 0x0f, 0xdb, 0x00, + 0x72, 0xfd, 0x0d, 0x18, 0x00, 0x72, 0xfe, 0x55, + 0xcc, 0x00, 0x73, 0x02, 0x4c, 0x4e, 0x00, 0x73, + 0x04, 0x39, 0xc0, 0x00, 0x73, 0x05, 0x39, 0xc1, + 0x00, 0x73, 0x07, 0x46, 0x91, 0x00, 0x73, 0x0a, + 0x16, 0x02, 0x00, 0x73, 0x0b, 0x4c, 0x4f, 0x00, + 0x73, 0x0d, 0x55, 0xcd, 0x00, 0x73, 0x12, 0x46, + 0x92, 0x00, 0x73, 0x13, 0x55, 0xce, 0x00, 0x73, + 0x16, 0x16, 0x04, 0x00, 0x73, 0x17, 0x16, 0x01, + 0x00, 0x73, 0x18, 0x46, 0x93, 0x00, 0x73, 0x19, + 0x46, 0x94, 0x00, 0x73, 0x1b, 0x0e, 0xe0, 0x00, + 0x73, 0x1c, 0x16, 0x03, 0x00, 0x73, 0x1d, 0x16, + 0x05, 0x00, 0x73, 0x1e, 0x4c, 0x50, 0x00, 0x73, + 0x1f, 0x0f, 0x8c, 0x00, 0x73, 0x22, 0x4c, 0x51, + 0x00, 0x73, 0x24, 0x21, 0x63, 0x00, 0x73, 0x25, + 0x16, 0x09, 0x00, 0x73, 0x27, 0x42, 0x4b, 0x00, + 0x73, 0x28, 0x39, 0xc2, 0x00, 0x73, 0x29, 0x16, + 0x08, 0x00, 0x73, 0x2a, 0x21, 0x64, 0x00, 0x73, + 0x2b, 0x0c, 0xe3, 0x00, 0x73, 0x2c, 0x46, 0x97, + 0x00, 0x73, 0x2e, 0x07, 0x59, 0x00, 0x73, 0x2f, + 0x16, 0x07, 0x00, 0x73, 0x31, 0x39, 0xc3, 0x00, + 0x73, 0x32, 0x55, 0xcf, 0x00, 0x73, 0x33, 0x46, + 0x98, 0x00, 0x73, 0x34, 0x16, 0x06, 0x00, 0x73, + 0x35, 0x55, 0xd0, 0x00, 0x73, 0x36, 0x0f, 0x1b, + 0x00, 0x73, 0x37, 0x0f, 0x1c, 0x00, 0x73, 0x39, + 0x46, 0x96, 0x00, 0x73, 0x3a, 0x4c, 0x52, 0x00, + 0x73, 0x3b, 0x4c, 0x53, 0x00, 0x73, 0x3d, 0x46, + 0x99, 0x00, 0x73, 0x3e, 0x16, 0x0a, 0x00, 0x73, + 0x3f, 0x05, 0x10, 0x00, 0x73, 0x43, 0x39, 0xc4, + 0x00, 0x73, 0x44, 0x08, 0x08, 0x00, 0x73, 0x45, + 0x08, 0xb0, 0x00, 0x73, 0x4d, 0x4c, 0x54, 0x00, + 0x73, 0x4e, 0x16, 0x0b, 0x00, 0x73, 0x4f, 0x16, + 0x0c, 0x00, 0x73, 0x50, 0x42, 0x4c, 0x00, 0x73, + 0x52, 0x46, 0x9a, 0x00, 0x73, 0x56, 0x55, 0xd1, + 0x00, 0x73, 0x57, 0x16, 0x0e, 0x00, 0x73, 0x58, + 0x4c, 0x55, 0x00, 0x73, 0x5d, 0x55, 0xd2, 0x00, + 0x73, 0x5e, 0x55, 0xd3, 0x00, 0x73, 0x5f, 0x55, + 0xd4, 0x00, 0x73, 0x60, 0x55, 0xd5, 0x00, 0x73, + 0x63, 0x09, 0x4d, 0x00, 0x73, 0x66, 0x42, 0x4d, + 0x00, 0x73, 0x67, 0x4c, 0x56, 0x00, 0x73, 0x68, + 0x16, 0x10, 0x00, 0x73, 0x69, 0x55, 0xd6, 0x00, + 0x73, 0x6a, 0x16, 0x0f, 0x00, 0x73, 0x6b, 0x46, + 0x9c, 0x00, 0x73, 0x6c, 0x39, 0xc5, 0x00, 0x73, + 0x6e, 0x46, 0x9e, 0x00, 0x73, 0x6f, 0x46, 0x9f, + 0x00, 0x73, 0x70, 0x16, 0x11, 0x00, 0x73, 0x71, + 0x46, 0xa0, 0x00, 0x73, 0x72, 0x05, 0xab, 0x00, + 0x73, 0x75, 0x16, 0x13, 0x00, 0x73, 0x77, 0x21, + 0x65, 0x00, 0x73, 0x78, 0x16, 0x12, 0x00, 0x73, + 0x79, 0x55, 0xd7, 0x00, 0x73, 0x7a, 0x16, 0x15, + 0x00, 0x73, 0x7b, 0x16, 0x14, 0x00, 0x73, 0x7c, + 0x39, 0xc6, 0x00, 0x73, 0x80, 0x55, 0xd8, 0x00, + 0x73, 0x81, 0x46, 0xa1, 0x00, 0x73, 0x83, 0x39, + 0xc7, 0x00, 0x73, 0x84, 0x07, 0x70, 0x00, 0x73, + 0x85, 0x39, 0xc8, 0x00, 0x73, 0x86, 0x39, 0xc9, + 0x00, 0x73, 0x87, 0x0f, 0x70, 0x00, 0x73, 0x89, + 0x06, 0xc4, 0x00, 0x73, 0x8a, 0x46, 0xa2, 0x00, + 0x73, 0x8b, 0x05, 0x26, 0x00, 0x73, 0x8e, 0x55, + 0xd9, 0x00, 0x73, 0x90, 0x55, 0xda, 0x00, 0x73, + 0x93, 0x55, 0xdb, 0x00, 0x73, 0x94, 0x46, 0xa3, + 0x00, 0x73, 0x95, 0x39, 0xca, 0x00, 0x73, 0x96, + 0x06, 0xe2, 0x00, 0x73, 0x97, 0x55, 0xdc, 0x00, + 0x73, 0x98, 0x46, 0xa4, 0x00, 0x73, 0x9c, 0x46, + 0xa5, 0x00, 0x73, 0x9e, 0x39, 0xcb, 0x00, 0x73, + 0x9f, 0x39, 0xcc, 0x00, 0x73, 0xa0, 0x39, 0xcd, + 0x00, 0x73, 0xa2, 0x42, 0x4e, 0x00, 0x73, 0xa5, + 0x46, 0xa6, 0x00, 0x73, 0xa6, 0x39, 0xce, 0x00, + 0x73, 0xa8, 0x3c, 0x3f, 0x00, 0x73, 0xa9, 0x06, + 0x1d, 0x00, 0x73, 0xaa, 0x55, 0xdd, 0x00, 0x73, + 0xab, 0x39, 0xcf, 0x00, 0x73, 0xad, 0x55, 0xde, + 0x00, 0x73, 0xb2, 0x0f, 0xb0, 0x00, 0x73, 0xb3, + 0x16, 0x17, 0x00, 0x73, 0xb5, 0x39, 0xd0, 0x00, + 0x73, 0xb7, 0x39, 0xd1, 0x00, 0x73, 0xb9, 0x46, + 0xa7, 0x00, 0x73, 0xba, 0x35, 0xea, 0x00, 0x73, + 0xbb, 0x16, 0x19, 0x00, 0x73, 0xbc, 0x39, 0xd2, + 0x00, 0x73, 0xbd, 0x21, 0x66, 0x00, 0x73, 0xbf, + 0x46, 0xa8, 0x00, 0x73, 0xc0, 0x16, 0x1a, 0x00, + 0x73, 0xc2, 0x05, 0x51, 0x00, 0x73, 0xc5, 0x46, + 0xa9, 0x00, 0x73, 0xc6, 0x55, 0xdf, 0x00, 0x73, + 0xc8, 0x16, 0x16, 0x00, 0x73, 0xc9, 0x21, 0x67, + 0x00, 0x73, 0xca, 0x08, 0x87, 0x00, 0x73, 0xcb, + 0x46, 0xaa, 0x00, 0x73, 0xcc, 0x55, 0xe0, 0x00, + 0x73, 0xcd, 0x0b, 0xdd, 0x00, 0x73, 0xce, 0x16, + 0x18, 0x00, 0x73, 0xcf, 0x39, 0xd3, 0x00, 0x73, + 0xd2, 0x21, 0x6a, 0x00, 0x73, 0xd3, 0x55, 0xe1, + 0x00, 0x73, 0xd6, 0x21, 0x68, 0x00, 0x73, 0xd9, + 0x39, 0xd4, 0x00, 0x73, 0xdd, 0x55, 0xe2, 0x00, + 0x73, 0xde, 0x16, 0x1d, 0x00, 0x73, 0xe0, 0x09, + 0x1a, 0x00, 0x73, 0xe1, 0x46, 0xab, 0x00, 0x73, + 0xe3, 0x21, 0x69, 0x00, 0x73, 0xe4, 0x3c, 0x39, + 0x00, 0x73, 0xe5, 0x16, 0x1b, 0x00, 0x73, 0xe6, + 0x55, 0xe3, 0x00, 0x73, 0xe7, 0x46, 0xac, 0x00, + 0x73, 0xe9, 0x39, 0xd5, 0x00, 0x73, 0xea, 0x07, + 0x14, 0x00, 0x73, 0xed, 0x0d, 0x5d, 0x00, 0x73, + 0xee, 0x16, 0x1c, 0x00, 0x73, 0xf1, 0x16, 0x37, + 0x00, 0x73, 0xf4, 0x39, 0xd6, 0x00, 0x73, 0xf5, + 0x21, 0x6c, 0x00, 0x73, 0xf7, 0x55, 0xe4, 0x00, + 0x73, 0xf8, 0x16, 0x22, 0x00, 0x73, 0xf9, 0x46, + 0xad, 0x00, 0x73, 0xfa, 0x46, 0xaf, 0x00, 0x73, + 0xfb, 0x55, 0xe5, 0x00, 0x73, 0xfd, 0x39, 0xd7, + 0x00, 0x73, 0xfe, 0x07, 0x71, 0x00, 0x73, 0xff, + 0x55, 0xe6, 0x00, 0x74, 0x00, 0x55, 0xe7, 0x00, + 0x74, 0x01, 0x46, 0xb0, 0x00, 0x74, 0x03, 0x06, + 0x7f, 0x00, 0x74, 0x04, 0x39, 0xd8, 0x00, 0x74, + 0x05, 0x16, 0x1f, 0x00, 0x74, 0x06, 0x0f, 0x67, + 0x00, 0x74, 0x07, 0x21, 0x6b, 0x00, 0x74, 0x09, + 0x0f, 0x78, 0x00, 0x74, 0x0a, 0x39, 0xd9, 0x00, + 0x74, 0x11, 0x55, 0xe8, 0x00, 0x74, 0x13, 0x46, + 0xae, 0x00, 0x74, 0x1a, 0x39, 0xda, 0x00, 0x74, + 0x1b, 0x39, 0xdb, 0x00, 0x74, 0x21, 0x3c, 0x3a, + 0x00, 0x74, 0x22, 0x1e, 0x34, 0x00, 0x74, 0x24, + 0x39, 0xdc, 0x00, 0x74, 0x25, 0x16, 0x21, 0x00, + 0x74, 0x26, 0x21, 0x6d, 0x00, 0x74, 0x28, 0x39, + 0xdd, 0x00, 0x74, 0x29, 0x21, 0x6f, 0x00, 0x74, + 0x2a, 0x21, 0x6e, 0x00, 0x74, 0x2b, 0x42, 0x4f, + 0x00, 0x74, 0x2c, 0x39, 0xde, 0x00, 0x74, 0x2d, + 0x55, 0xe9, 0x00, 0x74, 0x2e, 0x21, 0x70, 0x00, + 0x74, 0x2f, 0x39, 0xdf, 0x00, 0x74, 0x30, 0x39, + 0xe0, 0x00, 0x74, 0x31, 0x39, 0xe1, 0x00, 0x74, + 0x32, 0x16, 0x23, 0x00, 0x74, 0x33, 0x0f, 0x9e, + 0x00, 0x74, 0x34, 0x06, 0xcf, 0x00, 0x74, 0x35, + 0x0d, 0x90, 0x00, 0x74, 0x36, 0x0d, 0x00, 0x00, + 0x74, 0x39, 0x39, 0xe2, 0x00, 0x74, 0x3a, 0x16, + 0x24, 0x00, 0x74, 0x3f, 0x16, 0x26, 0x00, 0x74, + 0x40, 0x46, 0xb2, 0x00, 0x74, 0x41, 0x16, 0x29, + 0x00, 0x74, 0x43, 0x46, 0xb3, 0x00, 0x74, 0x44, + 0x39, 0xe3, 0x00, 0x74, 0x46, 0x42, 0x50, 0x00, + 0x74, 0x47, 0x39, 0xe4, 0x00, 0x74, 0x4b, 0x39, + 0xe5, 0x00, 0x74, 0x4d, 0x39, 0xe6, 0x00, 0x74, + 0x51, 0x39, 0xe7, 0x00, 0x74, 0x52, 0x46, 0xb4, + 0x00, 0x74, 0x53, 0x46, 0xb1, 0x00, 0x74, 0x55, + 0x16, 0x25, 0x00, 0x74, 0x57, 0x39, 0xe8, 0x00, + 0x74, 0x59, 0x16, 0x28, 0x00, 0x74, 0x5a, 0x07, + 0x9e, 0x00, 0x74, 0x5b, 0x04, 0xef, 0x00, 0x74, + 0x5c, 0x16, 0x2a, 0x00, 0x74, 0x5d, 0x46, 0xb5, + 0x00, 0x74, 0x5e, 0x0a, 0x36, 0x00, 0x74, 0x5f, + 0x16, 0x27, 0x00, 0x74, 0x60, 0x0f, 0xa4, 0x00, + 0x74, 0x62, 0x42, 0x51, 0x00, 0x74, 0x63, 0x16, + 0x2d, 0x00, 0x74, 0x64, 0x1d, 0x35, 0x00, 0x74, + 0x66, 0x39, 0xe9, 0x00, 0x74, 0x67, 0x55, 0xea, + 0x00, 0x74, 0x68, 0x55, 0xeb, 0x00, 0x74, 0x69, + 0x16, 0x2b, 0x00, 0x74, 0x6a, 0x16, 0x2e, 0x00, + 0x74, 0x6b, 0x39, 0xea, 0x00, 0x74, 0x6d, 0x42, + 0x52, 0x00, 0x74, 0x6e, 0x55, 0xec, 0x00, 0x74, + 0x6f, 0x16, 0x20, 0x00, 0x74, 0x70, 0x16, 0x2c, + 0x00, 0x74, 0x71, 0x39, 0xeb, 0x00, 0x74, 0x72, + 0x4c, 0x57, 0x00, 0x74, 0x73, 0x08, 0x2c, 0x00, + 0x74, 0x76, 0x16, 0x2f, 0x00, 0x74, 0x7e, 0x16, + 0x30, 0x00, 0x74, 0x80, 0x39, 0xec, 0x00, 0x74, + 0x81, 0x46, 0xb6, 0x00, 0x74, 0x83, 0x0f, 0x68, + 0x00, 0x74, 0x85, 0x39, 0xed, 0x00, 0x74, 0x86, + 0x39, 0xee, 0x00, 0x74, 0x87, 0x39, 0xef, 0x00, + 0x74, 0x88, 0x46, 0xb7, 0x00, 0x74, 0x89, 0x21, + 0x72, 0x00, 0x74, 0x8b, 0x16, 0x31, 0x00, 0x74, + 0x8f, 0x55, 0xed, 0x00, 0x74, 0x90, 0x39, 0xf0, + 0x00, 0x74, 0x91, 0x55, 0xee, 0x00, 0x74, 0x92, + 0x46, 0xb9, 0x00, 0x74, 0x97, 0x46, 0xba, 0x00, + 0x74, 0x98, 0x39, 0xf1, 0x00, 0x74, 0x99, 0x46, + 0xbb, 0x00, 0x74, 0x9a, 0x55, 0xef, 0x00, 0x74, + 0x9c, 0x39, 0xf2, 0x00, 0x74, 0x9e, 0x16, 0x32, + 0x00, 0x74, 0x9f, 0x21, 0x73, 0x00, 0x74, 0xa0, + 0x39, 0xf3, 0x00, 0x74, 0xa1, 0x46, 0xbc, 0x00, + 0x74, 0xa2, 0x16, 0x1e, 0x00, 0x74, 0xa3, 0x39, + 0xf4, 0x00, 0x74, 0xa5, 0x46, 0xbd, 0x00, 0x74, + 0xa6, 0x42, 0x53, 0x00, 0x74, 0xa7, 0x16, 0x33, + 0x00, 0x74, 0xa8, 0x39, 0xf5, 0x00, 0x74, 0xa9, + 0x42, 0x54, 0x00, 0x74, 0xaa, 0x46, 0xbe, 0x00, + 0x74, 0xab, 0x39, 0xf6, 0x00, 0x74, 0xae, 0x55, + 0xf0, 0x00, 0x74, 0xaf, 0x4c, 0x58, 0x00, 0x74, + 0xb0, 0x06, 0x00, 0x00, 0x74, 0xb1, 0x55, 0xf1, + 0x00, 0x74, 0xb2, 0x55, 0xf2, 0x00, 0x74, 0xb5, + 0x39, 0xf7, 0x00, 0x74, 0xb9, 0x46, 0xbf, 0x00, + 0x74, 0xba, 0x46, 0xc1, 0x00, 0x74, 0xbb, 0x46, + 0xc0, 0x00, 0x74, 0xbd, 0x08, 0xd1, 0x00, 0x74, + 0xbf, 0x39, 0xf8, 0x00, 0x74, 0xc8, 0x39, 0xf9, + 0x00, 0x74, 0xc9, 0x42, 0x55, 0x00, 0x74, 0xca, + 0x16, 0x34, 0x00, 0x74, 0xcc, 0x55, 0xf3, 0x00, + 0x74, 0xcf, 0x16, 0x35, 0x00, 0x74, 0xd0, 0x55, + 0xf4, 0x00, 0x74, 0xd3, 0x55, 0xf5, 0x00, 0x74, + 0xd4, 0x16, 0x36, 0x00, 0x74, 0xd6, 0x46, 0xc2, + 0x00, 0x74, 0xd8, 0x46, 0xc3, 0x00, 0x74, 0xda, + 0x39, 0xfa, 0x00, 0x74, 0xdb, 0x55, 0xf7, 0x00, + 0x74, 0xdc, 0x04, 0xdd, 0x00, 0x74, 0xde, 0x39, + 0xfb, 0x00, 0x74, 0xdf, 0x4c, 0x59, 0x00, 0x74, + 0xe0, 0x16, 0x38, 0x00, 0x74, 0xe2, 0x0d, 0xad, + 0x00, 0x74, 0xe3, 0x16, 0x39, 0x00, 0x74, 0xe4, + 0x4c, 0x5a, 0x00, 0x74, 0xe6, 0x05, 0xe0, 0x00, + 0x74, 0xe7, 0x16, 0x3a, 0x00, 0x74, 0xe8, 0x55, + 0xf8, 0x00, 0x74, 0xe9, 0x16, 0x3b, 0x00, 0x74, + 0xea, 0x55, 0xf9, 0x00, 0x74, 0xeb, 0x46, 0xc4, + 0x00, 0x74, 0xee, 0x16, 0x3c, 0x00, 0x74, 0xef, + 0x37, 0x50, 0x00, 0x74, 0xf0, 0x16, 0x3e, 0x00, + 0x74, 0xf1, 0x16, 0x3f, 0x00, 0x74, 0xf2, 0x16, + 0x3d, 0x00, 0x74, 0xf4, 0x4c, 0x5b, 0x00, 0x74, + 0xf6, 0x0d, 0xc5, 0x00, 0x74, 0xf7, 0x16, 0x41, + 0x00, 0x74, 0xf8, 0x16, 0x40, 0x00, 0x74, 0xfa, + 0x46, 0xc6, 0x00, 0x74, 0xfb, 0x4c, 0x5c, 0x00, + 0x74, 0xfc, 0x55, 0xfb, 0x00, 0x74, 0xff, 0x42, + 0x56, 0x00, 0x75, 0x01, 0x21, 0x74, 0x00, 0x75, + 0x03, 0x16, 0x43, 0x00, 0x75, 0x04, 0x16, 0x42, + 0x00, 0x75, 0x05, 0x16, 0x44, 0x00, 0x75, 0x06, + 0x55, 0xfc, 0x00, 0x75, 0x0c, 0x16, 0x45, 0x00, + 0x75, 0x0d, 0x16, 0x47, 0x00, 0x75, 0x0e, 0x16, + 0x46, 0x00, 0x75, 0x11, 0x08, 0x0b, 0x00, 0x75, + 0x12, 0x55, 0xfd, 0x00, 0x75, 0x13, 0x16, 0x49, + 0x00, 0x75, 0x15, 0x16, 0x48, 0x00, 0x75, 0x16, + 0x4c, 0x5d, 0x00, 0x75, 0x17, 0x42, 0x57, 0x00, + 0x75, 0x18, 0x06, 0x01, 0x00, 0x75, 0x1a, 0x0a, + 0x19, 0x00, 0x75, 0x1c, 0x0c, 0x36, 0x00, 0x75, + 0x1e, 0x16, 0x4a, 0x00, 0x75, 0x1f, 0x0a, 0x5c, + 0x00, 0x75, 0x20, 0x46, 0xc8, 0x00, 0x75, 0x21, + 0x4c, 0x5e, 0x00, 0x75, 0x22, 0x35, 0xde, 0x00, + 0x75, 0x23, 0x08, 0x88, 0x00, 0x75, 0x24, 0x46, + 0xc9, 0x00, 0x75, 0x25, 0x05, 0x1b, 0x00, 0x75, + 0x26, 0x16, 0x4b, 0x00, 0x75, 0x27, 0x55, 0xfe, + 0x00, 0x75, 0x28, 0x0f, 0x3b, 0x00, 0x75, 0x29, + 0x55, 0xff, 0x00, 0x75, 0x2a, 0x46, 0xca, 0x00, + 0x75, 0x2b, 0x0e, 0x33, 0x00, 0x75, 0x2c, 0x16, + 0x4c, 0x00, 0x75, 0x2f, 0x20, 0xf2, 0x00, 0x75, + 0x30, 0x0c, 0x3e, 0x00, 0x75, 0x31, 0x0f, 0x1d, + 0x00, 0x75, 0x32, 0x07, 0xd5, 0x00, 0x75, 0x33, + 0x0a, 0x03, 0x00, 0x75, 0x36, 0x56, 0x00, 0x00, + 0x75, 0x37, 0x0b, 0x89, 0x00, 0x75, 0x38, 0x10, + 0xc9, 0x00, 0x75, 0x39, 0x56, 0x01, 0x00, 0x75, + 0x3a, 0x0b, 0xca, 0x00, 0x75, 0x3b, 0x05, 0x68, + 0x00, 0x75, 0x3c, 0x16, 0x4d, 0x00, 0x75, 0x3d, + 0x46, 0xcd, 0x00, 0x75, 0x3e, 0x46, 0xce, 0x00, + 0x75, 0x3f, 0x4c, 0x5f, 0x00, 0x75, 0x40, 0x46, + 0xcf, 0x00, 0x75, 0x43, 0x56, 0x02, 0x00, 0x75, + 0x44, 0x16, 0x4e, 0x00, 0x75, 0x46, 0x16, 0x53, + 0x00, 0x75, 0x47, 0x56, 0x03, 0x00, 0x75, 0x48, + 0x46, 0xd0, 0x00, 0x75, 0x49, 0x16, 0x51, 0x00, + 0x75, 0x4a, 0x16, 0x50, 0x00, 0x75, 0x4b, 0x13, + 0xc7, 0x00, 0x75, 0x4c, 0x05, 0x84, 0x00, 0x75, + 0x4d, 0x16, 0x4f, 0x00, 0x75, 0x4e, 0x39, 0xfc, + 0x00, 0x75, 0x4f, 0x04, 0x9e, 0x00, 0x75, 0x50, + 0x46, 0xd1, 0x00, 0x75, 0x51, 0x0d, 0x3e, 0x00, + 0x75, 0x52, 0x46, 0xd2, 0x00, 0x75, 0x54, 0x0d, + 0x5e, 0x00, 0x75, 0x57, 0x56, 0x04, 0x00, 0x75, + 0x59, 0x0f, 0x79, 0x00, 0x75, 0x5a, 0x16, 0x54, + 0x00, 0x75, 0x5b, 0x16, 0x52, 0x00, 0x75, 0x5c, + 0x0b, 0x9a, 0x00, 0x75, 0x5d, 0x0a, 0x4a, 0x00, + 0x75, 0x5e, 0x4c, 0x60, 0x00, 0x75, 0x5f, 0x56, + 0x05, 0x00, 0x75, 0x60, 0x0d, 0x3f, 0x00, 0x75, + 0x61, 0x56, 0x06, 0x00, 0x75, 0x62, 0x0d, 0x9f, + 0x00, 0x75, 0x64, 0x16, 0x56, 0x00, 0x75, 0x65, + 0x0f, 0x74, 0x00, 0x75, 0x66, 0x07, 0x23, 0x00, + 0x75, 0x67, 0x16, 0x57, 0x00, 0x75, 0x69, 0x16, + 0x55, 0x00, 0x75, 0x6a, 0x0d, 0x6a, 0x00, 0x75, + 0x6b, 0x16, 0x58, 0x00, 0x75, 0x6c, 0x3c, 0x3b, + 0x00, 0x75, 0x6d, 0x16, 0x59, 0x00, 0x75, 0x6f, + 0x21, 0x75, 0x00, 0x75, 0x70, 0x04, 0x9f, 0x00, + 0x75, 0x71, 0x46, 0xd4, 0x00, 0x75, 0x72, 0x46, + 0xd3, 0x00, 0x75, 0x73, 0x09, 0xde, 0x00, 0x75, + 0x74, 0x16, 0x5e, 0x00, 0x75, 0x75, 0x37, 0x51, + 0x00, 0x75, 0x76, 0x16, 0x5b, 0x00, 0x75, 0x77, + 0x0c, 0xc5, 0x00, 0x75, 0x78, 0x16, 0x5a, 0x00, + 0x75, 0x79, 0x39, 0xfd, 0x00, 0x75, 0x7a, 0x46, + 0xd5, 0x00, 0x75, 0x7b, 0x56, 0x07, 0x00, 0x75, + 0x7c, 0x56, 0x08, 0x00, 0x75, 0x7d, 0x46, 0xd6, + 0x00, 0x75, 0x7e, 0x46, 0xd7, 0x00, 0x75, 0x7f, + 0x06, 0x40, 0x00, 0x75, 0x81, 0x39, 0xfe, 0x00, + 0x75, 0x82, 0x16, 0x61, 0x00, 0x75, 0x85, 0x56, + 0x09, 0x00, 0x75, 0x86, 0x16, 0x5c, 0x00, 0x75, + 0x87, 0x16, 0x5d, 0x00, 0x75, 0x89, 0x16, 0x60, + 0x00, 0x75, 0x8a, 0x16, 0x5f, 0x00, 0x75, 0x8b, + 0x0d, 0x97, 0x00, 0x75, 0x8c, 0x46, 0xd8, 0x00, + 0x75, 0x8e, 0x0a, 0xc4, 0x00, 0x75, 0x8f, 0x0a, + 0xc3, 0x00, 0x75, 0x90, 0x39, 0xff, 0x00, 0x75, + 0x91, 0x06, 0x59, 0x00, 0x75, 0x92, 0x3a, 0x00, + 0x00, 0x75, 0x93, 0x3a, 0x01, 0x00, 0x75, 0x94, + 0x16, 0x62, 0x00, 0x75, 0x95, 0x56, 0x0a, 0x00, + 0x75, 0x99, 0x4c, 0x61, 0x00, 0x75, 0x9a, 0x16, + 0x63, 0x00, 0x75, 0x9c, 0x56, 0x0b, 0x00, 0x75, + 0x9d, 0x16, 0x64, 0x00, 0x75, 0xa2, 0x46, 0xda, + 0x00, 0x75, 0xa3, 0x16, 0x66, 0x00, 0x75, 0xa4, + 0x4c, 0x62, 0x00, 0x75, 0xa5, 0x16, 0x65, 0x00, + 0x75, 0xab, 0x04, 0xf8, 0x00, 0x75, 0xb0, 0x46, + 0xdc, 0x00, 0x75, 0xb1, 0x16, 0x6e, 0x00, 0x75, + 0xb2, 0x0d, 0x7c, 0x00, 0x75, 0xb3, 0x16, 0x68, + 0x00, 0x75, 0xb4, 0x3a, 0x02, 0x00, 0x75, 0xb5, + 0x16, 0x6a, 0x00, 0x75, 0xb7, 0x46, 0xdd, 0x00, + 0x75, 0xb8, 0x16, 0x6c, 0x00, 0x75, 0xb9, 0x0a, + 0x04, 0x00, 0x75, 0xba, 0x56, 0x0c, 0x00, 0x75, + 0xbc, 0x16, 0x6d, 0x00, 0x75, 0xbd, 0x16, 0x6b, + 0x00, 0x75, 0xbe, 0x08, 0xec, 0x00, 0x75, 0xbf, + 0x46, 0xde, 0x00, 0x75, 0xc0, 0x46, 0xdf, 0x00, + 0x75, 0xc1, 0x4c, 0x63, 0x00, 0x75, 0xc2, 0x16, + 0x67, 0x00, 0x75, 0xc3, 0x16, 0x69, 0x00, 0x75, + 0xc4, 0x4c, 0x64, 0x00, 0x75, 0xc5, 0x0d, 0xb4, + 0x00, 0x75, 0xc6, 0x46, 0xe0, 0x00, 0x75, 0xc7, + 0x09, 0xb1, 0x00, 0x75, 0xca, 0x16, 0x70, 0x00, + 0x75, 0xcc, 0x4c, 0x65, 0x00, 0x75, 0xcd, 0x16, + 0x6f, 0x00, 0x75, 0xce, 0x42, 0x59, 0x00, 0x75, + 0xcf, 0x46, 0xe1, 0x00, 0x75, 0xd2, 0x16, 0x71, + 0x00, 0x75, 0xd3, 0x46, 0xe2, 0x00, 0x75, 0xd4, + 0x08, 0xd2, 0x00, 0x75, 0xd5, 0x08, 0x1f, 0x00, + 0x75, 0xd7, 0x4c, 0x66, 0x00, 0x75, 0xd8, 0x0c, + 0x71, 0x00, 0x75, 0xd9, 0x16, 0x72, 0x00, 0x75, + 0xdb, 0x0b, 0xe7, 0x00, 0x75, 0xdc, 0x4c, 0x67, + 0x00, 0x75, 0xdd, 0x46, 0xe3, 0x00, 0x75, 0xde, + 0x16, 0x74, 0x00, 0x75, 0xdf, 0x46, 0xe4, 0x00, + 0x75, 0xe0, 0x46, 0xe5, 0x00, 0x75, 0xe1, 0x4c, + 0x68, 0x00, 0x75, 0xe2, 0x0f, 0x69, 0x00, 0x75, + 0xe3, 0x16, 0x73, 0x00, 0x75, 0xe4, 0x3a, 0x03, + 0x00, 0x75, 0xe7, 0x46, 0xe6, 0x00, 0x75, 0xe9, + 0x0a, 0xeb, 0x00, 0x75, 0xec, 0x37, 0x52, 0x00, + 0x75, 0xee, 0x46, 0xe7, 0x00, 0x75, 0xef, 0x4c, + 0x69, 0x00, 0x75, 0xf0, 0x16, 0x79, 0x00, 0x75, + 0xf1, 0x46, 0xe8, 0x00, 0x75, 0xf2, 0x16, 0x7b, + 0x00, 0x75, 0xf3, 0x16, 0x7c, 0x00, 0x75, 0xf4, + 0x0b, 0x92, 0x00, 0x75, 0xf9, 0x3a, 0x04, 0x00, + 0x75, 0xfa, 0x16, 0x7a, 0x00, 0x75, 0xfc, 0x16, + 0x77, 0x00, 0x75, 0xfe, 0x16, 0x75, 0x00, 0x75, + 0xff, 0x16, 0x76, 0x00, 0x76, 0x00, 0x3a, 0x05, + 0x00, 0x76, 0x01, 0x16, 0x78, 0x00, 0x76, 0x02, + 0x42, 0x5a, 0x00, 0x76, 0x03, 0x46, 0xe9, 0x00, + 0x76, 0x04, 0x4c, 0x6a, 0x00, 0x76, 0x07, 0x46, + 0xeb, 0x00, 0x76, 0x08, 0x42, 0x5b, 0x00, 0x76, + 0x09, 0x16, 0x7f, 0x00, 0x76, 0x0a, 0x3a, 0x06, + 0x00, 0x76, 0x0b, 0x16, 0x7d, 0x00, 0x76, 0x0c, + 0x4c, 0x6b, 0x00, 0x76, 0x0d, 0x16, 0x7e, 0x00, + 0x76, 0x0f, 0x46, 0xec, 0x00, 0x76, 0x12, 0x56, + 0x0d, 0x00, 0x76, 0x13, 0x46, 0xef, 0x00, 0x76, + 0x15, 0x3a, 0x07, 0x00, 0x76, 0x16, 0x3a, 0x08, + 0x00, 0x76, 0x18, 0x46, 0xea, 0x00, 0x76, 0x19, + 0x3a, 0x09, 0x00, 0x76, 0x1b, 0x46, 0xf0, 0x00, + 0x76, 0x1c, 0x46, 0xf1, 0x00, 0x76, 0x1d, 0x4c, + 0x6c, 0x00, 0x76, 0x1e, 0x3a, 0x0a, 0x00, 0x76, + 0x1f, 0x16, 0x80, 0x00, 0x76, 0x20, 0x16, 0x82, + 0x00, 0x76, 0x21, 0x16, 0x83, 0x00, 0x76, 0x22, + 0x16, 0x84, 0x00, 0x76, 0x23, 0x56, 0x0e, 0x00, + 0x76, 0x24, 0x16, 0x85, 0x00, 0x76, 0x25, 0x46, + 0xf3, 0x00, 0x76, 0x26, 0x36, 0x45, 0x00, 0x76, + 0x27, 0x16, 0x81, 0x00, 0x76, 0x28, 0x46, 0xf4, + 0x00, 0x76, 0x29, 0x56, 0x0f, 0x00, 0x76, 0x2d, + 0x3a, 0x0b, 0x00, 0x76, 0x30, 0x16, 0x87, 0x00, + 0x76, 0x32, 0x4c, 0x6d, 0x00, 0x76, 0x33, 0x46, + 0xf6, 0x00, 0x76, 0x34, 0x16, 0x86, 0x00, 0x76, + 0x35, 0x3a, 0x0c, 0x00, 0x76, 0x38, 0x4c, 0x6e, + 0x00, 0x76, 0x39, 0x56, 0x10, 0x00, 0x76, 0x3a, + 0x56, 0x11, 0x00, 0x76, 0x3b, 0x16, 0x88, 0x00, + 0x76, 0x3c, 0x46, 0xf5, 0x00, 0x76, 0x40, 0x56, + 0x12, 0x00, 0x76, 0x41, 0x46, 0xf9, 0x00, 0x76, + 0x42, 0x0f, 0x8d, 0x00, 0x76, 0x43, 0x3a, 0x0d, + 0x00, 0x76, 0x44, 0x56, 0x13, 0x00, 0x76, 0x45, + 0x4c, 0x6f, 0x00, 0x76, 0x46, 0x16, 0x8b, 0x00, + 0x76, 0x47, 0x16, 0x89, 0x00, 0x76, 0x48, 0x16, + 0x8a, 0x00, 0x76, 0x49, 0x46, 0xfb, 0x00, 0x76, + 0x4a, 0x4c, 0x70, 0x00, 0x76, 0x4b, 0x3a, 0x0e, + 0x00, 0x76, 0x4c, 0x06, 0x1e, 0x00, 0x76, 0x4e, + 0x37, 0x53, 0x00, 0x76, 0x52, 0x0f, 0x0a, 0x00, + 0x76, 0x55, 0x46, 0xfc, 0x00, 0x76, 0x56, 0x0e, + 0x1a, 0x00, 0x76, 0x58, 0x16, 0x8d, 0x00, 0x76, + 0x59, 0x56, 0x14, 0x00, 0x76, 0x5c, 0x16, 0x8c, + 0x00, 0x76, 0x5f, 0x4c, 0x71, 0x00, 0x76, 0x61, + 0x16, 0x8e, 0x00, 0x76, 0x62, 0x16, 0x8f, 0x00, + 0x76, 0x64, 0x42, 0x5c, 0x00, 0x76, 0x65, 0x3a, + 0x0f, 0x00, 0x76, 0x67, 0x16, 0x93, 0x00, 0x76, + 0x68, 0x16, 0x90, 0x00, 0x76, 0x69, 0x16, 0x91, + 0x00, 0x76, 0x6a, 0x16, 0x92, 0x00, 0x76, 0x6c, + 0x16, 0x94, 0x00, 0x76, 0x6d, 0x3a, 0x10, 0x00, + 0x76, 0x6e, 0x46, 0xfe, 0x00, 0x76, 0x6f, 0x3a, + 0x11, 0x00, 0x76, 0x70, 0x16, 0x95, 0x00, 0x76, + 0x71, 0x3a, 0x12, 0x00, 0x76, 0x72, 0x16, 0x96, + 0x00, 0x76, 0x74, 0x3a, 0x13, 0x00, 0x76, 0x76, + 0x16, 0x97, 0x00, 0x76, 0x78, 0x16, 0x98, 0x00, + 0x76, 0x7a, 0x0d, 0x43, 0x00, 0x76, 0x7b, 0x0c, + 0x4a, 0x00, 0x76, 0x7c, 0x16, 0x99, 0x00, 0x76, + 0x7d, 0x0d, 0x28, 0x00, 0x76, 0x7e, 0x0d, 0xa6, + 0x00, 0x76, 0x80, 0x16, 0x9a, 0x00, 0x76, 0x81, + 0x42, 0x5d, 0x00, 0x76, 0x82, 0x21, 0x76, 0x00, + 0x76, 0x83, 0x16, 0x9b, 0x00, 0x76, 0x84, 0x0c, + 0x24, 0x00, 0x76, 0x85, 0x56, 0x15, 0x00, 0x76, + 0x86, 0x05, 0x85, 0x00, 0x76, 0x87, 0x07, 0xd6, + 0x00, 0x76, 0x88, 0x16, 0x9c, 0x00, 0x76, 0x8b, + 0x16, 0x9d, 0x00, 0x76, 0x8c, 0x56, 0x16, 0x00, + 0x76, 0x8d, 0x56, 0x17, 0x00, 0x76, 0x8e, 0x16, + 0x9e, 0x00, 0x76, 0x90, 0x08, 0x77, 0x00, 0x76, + 0x93, 0x16, 0xa0, 0x00, 0x76, 0x95, 0x46, 0xff, + 0x00, 0x76, 0x96, 0x16, 0x9f, 0x00, 0x76, 0x99, + 0x16, 0xa1, 0x00, 0x76, 0x9a, 0x16, 0xa2, 0x00, + 0x76, 0x9b, 0x21, 0x79, 0x00, 0x76, 0x9c, 0x21, + 0x77, 0x00, 0x76, 0x9d, 0x42, 0x5e, 0x00, 0x76, + 0x9e, 0x21, 0x78, 0x00, 0x76, 0x9f, 0x56, 0x18, + 0x00, 0x76, 0xa0, 0x47, 0x01, 0x00, 0x76, 0xa1, + 0x47, 0x00, 0x00, 0x76, 0xa2, 0x56, 0x19, 0x00, + 0x76, 0xa3, 0x56, 0x1a, 0x00, 0x76, 0xa4, 0x3a, + 0x14, 0x00, 0x76, 0xa5, 0x3a, 0x15, 0x00, 0x76, + 0xa6, 0x21, 0x7a, 0x00, 0x76, 0xa7, 0x47, 0x02, + 0x00, 0x76, 0xa8, 0x47, 0x03, 0x00, 0x76, 0xaa, + 0x42, 0x5f, 0x00, 0x76, 0xad, 0x4c, 0x72, 0x00, + 0x76, 0xae, 0x0d, 0x7d, 0x00, 0x76, 0xaf, 0x47, + 0x04, 0x00, 0x76, 0xb0, 0x16, 0xa3, 0x00, 0x76, + 0xb4, 0x16, 0xa4, 0x00, 0x76, 0xb6, 0x42, 0x60, + 0x00, 0x76, 0xb7, 0x1d, 0x1c, 0x00, 0x76, 0xb8, + 0x16, 0xa5, 0x00, 0x76, 0xb9, 0x16, 0xa6, 0x00, + 0x76, 0xba, 0x16, 0xa7, 0x00, 0x76, 0xbd, 0x4c, + 0x73, 0x00, 0x76, 0xbf, 0x08, 0x7c, 0x00, 0x76, + 0xc1, 0x56, 0x1b, 0x00, 0x76, 0xc2, 0x16, 0xa8, + 0x00, 0x76, 0xc3, 0x0d, 0x0c, 0x00, 0x76, 0xc5, + 0x3a, 0x16, 0x00, 0x76, 0xc6, 0x0e, 0x8d, 0x00, + 0x76, 0xc8, 0x04, 0xf0, 0x00, 0x76, 0xc9, 0x47, + 0x06, 0x00, 0x76, 0xca, 0x04, 0xf9, 0x00, 0x76, + 0xcb, 0x56, 0x1c, 0x00, 0x76, 0xcc, 0x3a, 0x17, + 0x00, 0x76, 0xcd, 0x16, 0xa9, 0x00, 0x76, 0xce, + 0x42, 0x61, 0x00, 0x76, 0xd2, 0x16, 0xab, 0x00, + 0x76, 0xd4, 0x42, 0x62, 0x00, 0x76, 0xd6, 0x16, + 0xaa, 0x00, 0x76, 0xd7, 0x0c, 0x6a, 0x00, 0x76, + 0xd9, 0x4c, 0x74, 0x00, 0x76, 0xdb, 0x0a, 0x5d, + 0x00, 0x76, 0xdc, 0x14, 0xd8, 0x00, 0x76, 0xde, + 0x16, 0xac, 0x00, 0x76, 0xdf, 0x0e, 0xcd, 0x00, + 0x76, 0xe0, 0x56, 0x1e, 0x00, 0x76, 0xe1, 0x16, + 0xad, 0x00, 0x76, 0xe3, 0x06, 0x02, 0x00, 0x76, + 0xe4, 0x0d, 0x6b, 0x00, 0x76, 0xe5, 0x16, 0xae, + 0x00, 0x76, 0xe6, 0x42, 0x63, 0x00, 0x76, 0xe7, + 0x16, 0xaf, 0x00, 0x76, 0xe8, 0x47, 0x08, 0x00, + 0x76, 0xea, 0x16, 0xb0, 0x00, 0x76, 0xeb, 0x4c, + 0x75, 0x00, 0x76, 0xec, 0x3a, 0x18, 0x00, 0x76, + 0xee, 0x0e, 0xe8, 0x00, 0x76, 0xf0, 0x4c, 0x76, + 0x00, 0x76, 0xf1, 0x42, 0x64, 0x00, 0x76, 0xf2, + 0x0e, 0xe1, 0x00, 0x76, 0xf4, 0x0b, 0xda, 0x00, + 0x76, 0xf6, 0x56, 0x1f, 0x00, 0x76, 0xf8, 0x0a, + 0xec, 0x00, 0x76, 0xf9, 0x4c, 0x77, 0x00, 0x76, + 0xfb, 0x16, 0xb2, 0x00, 0x76, 0xfc, 0x3a, 0x19, + 0x00, 0x76, 0xfe, 0x09, 0x6c, 0x00, 0x77, 0x00, + 0x4c, 0x78, 0x00, 0x77, 0x01, 0x09, 0xb2, 0x00, + 0x77, 0x04, 0x16, 0xb5, 0x00, 0x77, 0x06, 0x56, + 0x20, 0x00, 0x77, 0x07, 0x16, 0xb4, 0x00, 0x77, + 0x08, 0x16, 0xb3, 0x00, 0x77, 0x09, 0x0d, 0x91, + 0x00, 0x77, 0x0a, 0x42, 0x65, 0x00, 0x77, 0x0b, + 0x06, 0x03, 0x00, 0x77, 0x0c, 0x07, 0x5d, 0x00, + 0x77, 0x0e, 0x4c, 0x79, 0x00, 0x77, 0x12, 0x56, + 0x21, 0x00, 0x77, 0x14, 0x56, 0x22, 0x00, 0x77, + 0x15, 0x56, 0x23, 0x00, 0x77, 0x17, 0x47, 0x0a, + 0x00, 0x77, 0x19, 0x42, 0x66, 0x00, 0x77, 0x1a, + 0x47, 0x0b, 0x00, 0x77, 0x1b, 0x16, 0xbb, 0x00, + 0x77, 0x1c, 0x56, 0x24, 0x00, 0x77, 0x1e, 0x34, + 0x2d, 0x00, 0x77, 0x1f, 0x0a, 0x05, 0x00, 0x77, + 0x20, 0x0e, 0xbe, 0x00, 0x77, 0x22, 0x4c, 0x7a, + 0x00, 0x77, 0x24, 0x16, 0xb7, 0x00, 0x77, 0x25, + 0x16, 0xb9, 0x00, 0x77, 0x26, 0x16, 0xba, 0x00, + 0x77, 0x28, 0x4c, 0x7b, 0x00, 0x77, 0x29, 0x16, + 0xb6, 0x00, 0x77, 0x2d, 0x47, 0x0c, 0x00, 0x77, + 0x2e, 0x56, 0x25, 0x00, 0x77, 0x2f, 0x4c, 0x7c, + 0x00, 0x77, 0x34, 0x3a, 0x1a, 0x00, 0x77, 0x35, + 0x47, 0x0d, 0x00, 0x77, 0x36, 0x3a, 0x1b, 0x00, + 0x77, 0x37, 0x16, 0xbc, 0x00, 0x77, 0x38, 0x16, + 0xbd, 0x00, 0x77, 0x39, 0x4c, 0x7d, 0x00, 0x77, + 0x3a, 0x0b, 0xcb, 0x00, 0x77, 0x3c, 0x06, 0x1f, + 0x00, 0x77, 0x3d, 0x56, 0x26, 0x00, 0x77, 0x3e, + 0x4c, 0x7e, 0x00, 0x77, 0x40, 0x0b, 0xa3, 0x00, + 0x77, 0x42, 0x56, 0x27, 0x00, 0x77, 0x45, 0x4c, + 0x7f, 0x00, 0x77, 0x46, 0x21, 0x7c, 0x00, 0x77, + 0x47, 0x16, 0xbe, 0x00, 0x77, 0x4a, 0x4c, 0x80, + 0x00, 0x77, 0x4d, 0x42, 0x67, 0x00, 0x77, 0x4e, + 0x42, 0x68, 0x00, 0x77, 0x4f, 0x4c, 0x81, 0x00, + 0x77, 0x52, 0x56, 0x28, 0x00, 0x77, 0x56, 0x56, + 0x29, 0x00, 0x77, 0x57, 0x56, 0x2a, 0x00, 0x77, + 0x58, 0x47, 0x12, 0x00, 0x77, 0x5a, 0x16, 0xbf, + 0x00, 0x77, 0x5b, 0x16, 0xc2, 0x00, 0x77, 0x5c, + 0x3a, 0x1c, 0x00, 0x77, 0x5e, 0x4c, 0x82, 0x00, + 0x77, 0x5f, 0x3a, 0x1d, 0x00, 0x77, 0x60, 0x3a, + 0x1e, 0x00, 0x77, 0x61, 0x0a, 0x2d, 0x00, 0x77, + 0x62, 0x1e, 0xc5, 0x00, 0x77, 0x63, 0x0c, 0x9c, + 0x00, 0x77, 0x64, 0x4c, 0x83, 0x00, 0x77, 0x65, + 0x16, 0xc3, 0x00, 0x77, 0x66, 0x0e, 0x81, 0x00, + 0x77, 0x67, 0x4c, 0x84, 0x00, 0x77, 0x68, 0x16, + 0xc0, 0x00, 0x77, 0x6a, 0x37, 0x55, 0x00, 0x77, + 0x6b, 0x16, 0xc1, 0x00, 0x77, 0x6c, 0x4c, 0x85, + 0x00, 0x77, 0x70, 0x56, 0x2b, 0x00, 0x77, 0x72, + 0x3a, 0x1f, 0x00, 0x77, 0x73, 0x56, 0x2c, 0x00, + 0x77, 0x74, 0x56, 0x2d, 0x00, 0x77, 0x79, 0x16, + 0xc6, 0x00, 0x77, 0x7a, 0x42, 0x69, 0x00, 0x77, + 0x7c, 0x47, 0x14, 0x00, 0x77, 0x7d, 0x3a, 0x20, + 0x00, 0x77, 0x7e, 0x16, 0xc5, 0x00, 0x77, 0x7f, + 0x16, 0xc4, 0x00, 0x77, 0x80, 0x42, 0x6a, 0x00, + 0x77, 0x84, 0x4c, 0x86, 0x00, 0x77, 0x8b, 0x16, + 0xc8, 0x00, 0x77, 0x8c, 0x4c, 0x87, 0x00, 0x77, + 0x8d, 0x4c, 0x88, 0x00, 0x77, 0x8e, 0x16, 0xc7, + 0x00, 0x77, 0x91, 0x16, 0xc9, 0x00, 0x77, 0x94, + 0x42, 0x6b, 0x00, 0x77, 0x95, 0x3a, 0x21, 0x00, + 0x77, 0x96, 0x4c, 0x89, 0x00, 0x77, 0x9a, 0x47, + 0x17, 0x00, 0x77, 0x9e, 0x16, 0xcb, 0x00, 0x77, + 0x9f, 0x47, 0x18, 0x00, 0x77, 0xa0, 0x16, 0xca, + 0x00, 0x77, 0xa2, 0x47, 0x19, 0x00, 0x77, 0xa4, + 0x47, 0x1a, 0x00, 0x77, 0xa5, 0x0e, 0x1d, 0x00, + 0x77, 0xa7, 0x4c, 0x8a, 0x00, 0x77, 0xa9, 0x37, + 0x56, 0x00, 0x77, 0xaa, 0x3a, 0x22, 0x00, 0x77, + 0xac, 0x09, 0x60, 0x00, 0x77, 0xad, 0x0f, 0x8e, + 0x00, 0x77, 0xae, 0x56, 0x30, 0x00, 0x77, 0xaf, + 0x4c, 0x8b, 0x00, 0x77, 0xb0, 0x16, 0xcc, 0x00, + 0x77, 0xb1, 0x56, 0x31, 0x00, 0x77, 0xb3, 0x0c, + 0x8f, 0x00, 0x77, 0xb5, 0x56, 0x32, 0x00, 0x77, + 0xb6, 0x16, 0xcd, 0x00, 0x77, 0xb7, 0x4c, 0x8c, + 0x00, 0x77, 0xb9, 0x16, 0xce, 0x00, 0x77, 0xbb, + 0x16, 0xd2, 0x00, 0x77, 0xbc, 0x16, 0xd0, 0x00, + 0x77, 0xbd, 0x16, 0xd1, 0x00, 0x77, 0xbe, 0x4c, + 0x8d, 0x00, 0x77, 0xbf, 0x16, 0xcf, 0x00, 0x77, + 0xc3, 0x56, 0x33, 0x00, 0x77, 0xc7, 0x16, 0xd3, + 0x00, 0x77, 0xc9, 0x4c, 0x8e, 0x00, 0x77, 0xcd, + 0x16, 0xd4, 0x00, 0x77, 0xd1, 0x4c, 0x8f, 0x00, + 0x77, 0xd2, 0x56, 0x34, 0x00, 0x77, 0xd5, 0x56, + 0x35, 0x00, 0x77, 0xd7, 0x16, 0xd5, 0x00, 0x77, + 0xd9, 0x4c, 0x90, 0x00, 0x77, 0xda, 0x16, 0xd6, + 0x00, 0x77, 0xdb, 0x0e, 0xc3, 0x00, 0x77, 0xdc, + 0x16, 0xd7, 0x00, 0x77, 0xde, 0x47, 0x1b, 0x00, + 0x77, 0xdf, 0x47, 0x1c, 0x00, 0x77, 0xe0, 0x42, + 0x6c, 0x00, 0x77, 0xe2, 0x0e, 0xfc, 0x00, 0x77, + 0xe3, 0x16, 0xd8, 0x00, 0x77, 0xe4, 0x47, 0x1d, + 0x00, 0x77, 0xe5, 0x0b, 0x8c, 0x00, 0x77, 0xe6, + 0x3a, 0x23, 0x00, 0x77, 0xe7, 0x0d, 0x20, 0x00, + 0x77, 0xe9, 0x06, 0xe3, 0x00, 0x77, 0xea, 0x47, + 0x1e, 0x00, 0x77, 0xec, 0x47, 0x1f, 0x00, 0x77, + 0xed, 0x0b, 0x79, 0x00, 0x77, 0xee, 0x16, 0xd9, + 0x00, 0x77, 0xef, 0x06, 0xb2, 0x00, 0x77, 0xf0, + 0x3a, 0x24, 0x00, 0x77, 0xf1, 0x4c, 0x91, 0x00, + 0x77, 0xf3, 0x0a, 0x74, 0x00, 0x77, 0xf4, 0x3a, + 0x25, 0x00, 0x77, 0xf8, 0x56, 0x36, 0x00, 0x77, + 0xfb, 0x47, 0x20, 0x00, 0x77, 0xfc, 0x16, 0xda, + 0x00, 0x78, 0x02, 0x08, 0x2d, 0x00, 0x78, 0x05, + 0x47, 0x22, 0x00, 0x78, 0x06, 0x3a, 0x26, 0x00, + 0x78, 0x09, 0x47, 0x23, 0x00, 0x78, 0x0c, 0x16, + 0xdb, 0x00, 0x78, 0x0d, 0x47, 0x24, 0x00, 0x78, + 0x0e, 0x56, 0x37, 0x00, 0x78, 0x11, 0x56, 0x38, + 0x00, 0x78, 0x12, 0x16, 0xdc, 0x00, 0x78, 0x14, + 0x07, 0x5a, 0x00, 0x78, 0x15, 0x08, 0x45, 0x00, + 0x78, 0x19, 0x47, 0x25, 0x00, 0x78, 0x1d, 0x56, + 0x39, 0x00, 0x78, 0x20, 0x16, 0xde, 0x00, 0x78, + 0x21, 0x21, 0x7e, 0x00, 0x78, 0x22, 0x3a, 0x27, + 0x00, 0x78, 0x23, 0x56, 0x3a, 0x00, 0x78, 0x25, + 0x0c, 0x50, 0x00, 0x78, 0x26, 0x08, 0x46, 0x00, + 0x78, 0x27, 0x06, 0x68, 0x00, 0x78, 0x2c, 0x47, + 0x26, 0x00, 0x78, 0x2d, 0x3a, 0x28, 0x00, 0x78, + 0x2e, 0x3a, 0x29, 0x00, 0x78, 0x30, 0x3a, 0x2a, + 0x00, 0x78, 0x32, 0x0e, 0x52, 0x00, 0x78, 0x34, + 0x0d, 0x01, 0x00, 0x78, 0x35, 0x3a, 0x2b, 0x00, + 0x78, 0x37, 0x4c, 0x92, 0x00, 0x78, 0x3a, 0x0c, + 0x51, 0x00, 0x78, 0x3f, 0x07, 0xee, 0x00, 0x78, + 0x43, 0x42, 0x6e, 0x00, 0x78, 0x44, 0x56, 0x3b, + 0x00, 0x78, 0x45, 0x16, 0xe0, 0x00, 0x78, 0x47, + 0x47, 0x27, 0x00, 0x78, 0x48, 0x56, 0x3c, 0x00, + 0x78, 0x4c, 0x56, 0x3d, 0x00, 0x78, 0x4e, 0x21, + 0x7f, 0x00, 0x78, 0x4f, 0x34, 0x1e, 0x00, 0x78, + 0x51, 0x3c, 0x3c, 0x00, 0x78, 0x52, 0x56, 0x3e, + 0x00, 0x78, 0x5c, 0x4c, 0x93, 0x00, 0x78, 0x5d, + 0x09, 0xb3, 0x00, 0x78, 0x5e, 0x56, 0x3f, 0x00, + 0x78, 0x60, 0x56, 0x40, 0x00, 0x78, 0x61, 0x56, + 0x41, 0x00, 0x78, 0x63, 0x56, 0x42, 0x00, 0x78, + 0x64, 0x21, 0x80, 0x00, 0x78, 0x68, 0x3a, 0x2c, + 0x00, 0x78, 0x6a, 0x47, 0x28, 0x00, 0x78, 0x6b, + 0x0f, 0x7a, 0x00, 0x78, 0x6c, 0x07, 0xd7, 0x00, + 0x78, 0x6e, 0x42, 0x6f, 0x00, 0x78, 0x6f, 0x07, + 0x5b, 0x00, 0x78, 0x72, 0x0d, 0x37, 0x00, 0x78, + 0x74, 0x16, 0xe2, 0x00, 0x78, 0x7a, 0x21, 0x81, + 0x00, 0x78, 0x7c, 0x16, 0xe4, 0x00, 0x78, 0x7e, + 0x4c, 0x94, 0x00, 0x78, 0x81, 0x07, 0x9f, 0x00, + 0x78, 0x86, 0x16, 0xe3, 0x00, 0x78, 0x87, 0x0c, + 0x12, 0x00, 0x78, 0x8a, 0x47, 0x2a, 0x00, 0x78, + 0x8c, 0x16, 0xe6, 0x00, 0x78, 0x8d, 0x05, 0x95, + 0x00, 0x78, 0x8e, 0x16, 0xe1, 0x00, 0x78, 0x8f, + 0x56, 0x43, 0x00, 0x78, 0x91, 0x34, 0x43, 0x00, + 0x78, 0x93, 0x04, 0xd2, 0x00, 0x78, 0x94, 0x47, + 0x2b, 0x00, 0x78, 0x95, 0x08, 0x5c, 0x00, 0x78, + 0x97, 0x0f, 0xf8, 0x00, 0x78, 0x98, 0x4c, 0x95, + 0x00, 0x78, 0x9a, 0x16, 0xe5, 0x00, 0x78, 0x9d, + 0x47, 0x2d, 0x00, 0x78, 0x9e, 0x3a, 0x2d, 0x00, + 0x78, 0x9f, 0x47, 0x2e, 0x00, 0x78, 0xa1, 0x4c, + 0x96, 0x00, 0x78, 0xa3, 0x16, 0xe7, 0x00, 0x78, + 0xa4, 0x47, 0x2c, 0x00, 0x78, 0xa7, 0x0e, 0x1b, + 0x00, 0x78, 0xa8, 0x56, 0x44, 0x00, 0x78, 0xa9, + 0x0a, 0x7d, 0x00, 0x78, 0xaa, 0x16, 0xe9, 0x00, + 0x78, 0xac, 0x56, 0x45, 0x00, 0x78, 0xad, 0x42, + 0x72, 0x00, 0x78, 0xaf, 0x16, 0xea, 0x00, 0x78, + 0xb0, 0x42, 0x70, 0x00, 0x78, 0xb1, 0x4c, 0x97, + 0x00, 0x78, 0xb2, 0x56, 0x46, 0x00, 0x78, 0xb3, + 0x4c, 0x98, 0x00, 0x78, 0xb5, 0x16, 0xe8, 0x00, + 0x78, 0xba, 0x05, 0xac, 0x00, 0x78, 0xbb, 0x47, + 0x2f, 0x00, 0x78, 0xbc, 0x16, 0xf0, 0x00, 0x78, + 0xbd, 0x56, 0x47, 0x00, 0x78, 0xbe, 0x16, 0xef, + 0x00, 0x78, 0xbf, 0x56, 0x48, 0x00, 0x78, 0xc1, + 0x08, 0xd3, 0x00, 0x78, 0xc5, 0x16, 0xf1, 0x00, + 0x78, 0xc6, 0x16, 0xec, 0x00, 0x78, 0xc7, 0x56, + 0x49, 0x00, 0x78, 0xc8, 0x3a, 0x2e, 0x00, 0x78, + 0xc9, 0x4c, 0x99, 0x00, 0x78, 0xca, 0x16, 0xf2, + 0x00, 0x78, 0xcb, 0x16, 0xed, 0x00, 0x78, 0xcc, + 0x3a, 0x2f, 0x00, 0x78, 0xce, 0x3a, 0x30, 0x00, + 0x78, 0xd0, 0x0d, 0x6c, 0x00, 0x78, 0xd1, 0x16, + 0xeb, 0x00, 0x78, 0xd2, 0x56, 0x4a, 0x00, 0x78, + 0xd3, 0x4c, 0x9a, 0x00, 0x78, 0xd4, 0x16, 0xee, + 0x00, 0x78, 0xd5, 0x47, 0x30, 0x00, 0x78, 0xd6, + 0x56, 0x4b, 0x00, 0x78, 0xda, 0x16, 0xf5, 0x00, + 0x78, 0xdb, 0x56, 0x4c, 0x00, 0x78, 0xdf, 0x56, + 0x4d, 0x00, 0x78, 0xe0, 0x3a, 0x32, 0x00, 0x78, + 0xe1, 0x3a, 0x33, 0x00, 0x78, 0xe4, 0x3a, 0x31, + 0x00, 0x78, 0xe6, 0x47, 0x31, 0x00, 0x78, 0xe7, + 0x16, 0xf4, 0x00, 0x78, 0xe8, 0x0e, 0x8f, 0x00, + 0x78, 0xea, 0x56, 0x4e, 0x00, 0x78, 0xec, 0x16, + 0xf3, 0x00, 0x78, 0xef, 0x04, 0xaf, 0x00, 0x78, + 0xf2, 0x3a, 0x34, 0x00, 0x78, 0xf3, 0x56, 0x4f, + 0x00, 0x78, 0xf4, 0x16, 0xf7, 0x00, 0x78, 0xf6, + 0x56, 0x50, 0x00, 0x78, 0xf7, 0x3a, 0x35, 0x00, + 0x78, 0xf9, 0x47, 0x32, 0x00, 0x78, 0xfa, 0x47, + 0x33, 0x00, 0x78, 0xfb, 0x3a, 0x36, 0x00, 0x78, + 0xfd, 0x16, 0xf6, 0x00, 0x78, 0xfe, 0x47, 0x34, + 0x00, 0x78, 0xff, 0x56, 0x51, 0x00, 0x79, 0x00, + 0x42, 0x73, 0x00, 0x79, 0x01, 0x09, 0xb4, 0x00, + 0x79, 0x06, 0x56, 0x52, 0x00, 0x79, 0x07, 0x16, + 0xf8, 0x00, 0x79, 0x0c, 0x4c, 0x9b, 0x00, 0x79, + 0x0e, 0x0a, 0xc5, 0x00, 0x79, 0x10, 0x47, 0x36, + 0x00, 0x79, 0x11, 0x16, 0xfa, 0x00, 0x79, 0x12, + 0x16, 0xf9, 0x00, 0x79, 0x19, 0x16, 0xfb, 0x00, + 0x79, 0x1a, 0x56, 0x53, 0x00, 0x79, 0x1b, 0x47, + 0x37, 0x00, 0x79, 0x1c, 0x42, 0x74, 0x00, 0x79, + 0x1e, 0x56, 0x54, 0x00, 0x79, 0x1f, 0x4c, 0x9c, + 0x00, 0x79, 0x20, 0x56, 0x55, 0x00, 0x79, 0x25, + 0x47, 0x38, 0x00, 0x79, 0x26, 0x16, 0xdd, 0x00, + 0x79, 0x27, 0x4c, 0x9d, 0x00, 0x79, 0x28, 0x4c, + 0x9e, 0x00, 0x79, 0x29, 0x56, 0x56, 0x00, 0x79, + 0x2a, 0x16, 0xdf, 0x00, 0x79, 0x2b, 0x16, 0xfd, + 0x00, 0x79, 0x2c, 0x16, 0xfc, 0x00, 0x79, 0x2d, + 0x56, 0x57, 0x00, 0x79, 0x2e, 0x42, 0x75, 0x00, + 0x79, 0x30, 0x21, 0x82, 0x00, 0x79, 0x31, 0x3a, + 0x37, 0x00, 0x79, 0x34, 0x42, 0x76, 0x00, 0x79, + 0x35, 0x56, 0x58, 0x00, 0x79, 0x3a, 0x4a, 0xba, + 0x00, 0x79, 0x3b, 0x3a, 0x39, 0x00, 0x79, 0x3c, + 0x0f, 0xb1, 0x00, 0x79, 0x3d, 0x3a, 0x3a, 0x00, + 0x79, 0x3e, 0x08, 0xfe, 0x00, 0x79, 0x3f, 0x4c, + 0x9f, 0x00, 0x79, 0x40, 0x16, 0xfe, 0x00, 0x79, + 0x41, 0x07, 0x0d, 0x00, 0x79, 0x42, 0x4c, 0xa0, + 0x00, 0x79, 0x44, 0x56, 0x59, 0x00, 0x79, 0x45, + 0x3a, 0x3b, 0x00, 0x79, 0x46, 0x42, 0x77, 0x00, + 0x79, 0x47, 0x06, 0x5a, 0x00, 0x79, 0x48, 0x34, + 0x17, 0x00, 0x79, 0x49, 0x08, 0xb1, 0x00, 0x79, + 0x4a, 0x47, 0x39, 0x00, 0x79, 0x4b, 0x56, 0x5a, + 0x00, 0x79, 0x4f, 0x56, 0x5b, 0x00, 0x79, 0x50, + 0x34, 0x4f, 0x00, 0x79, 0x51, 0x56, 0x5c, 0x00, + 0x79, 0x53, 0x17, 0x04, 0x00, 0x79, 0x54, 0x4c, + 0xa1, 0x00, 0x79, 0x55, 0x17, 0x03, 0x00, 0x79, + 0x56, 0x0a, 0xc6, 0x00, 0x79, 0x57, 0x17, 0x00, + 0x00, 0x79, 0x58, 0x47, 0x3a, 0x00, 0x79, 0x5a, + 0x17, 0x02, 0x00, 0x79, 0x5b, 0x3a, 0x3c, 0x00, + 0x79, 0x5c, 0x3a, 0x3d, 0x00, 0x79, 0x5d, 0x34, + 0x27, 0x00, 0x79, 0x5e, 0x21, 0x84, 0x00, 0x79, + 0x5f, 0x17, 0x01, 0x00, 0x79, 0x60, 0x16, 0xff, + 0x00, 0x79, 0x62, 0x0c, 0xe0, 0x00, 0x79, 0x65, + 0x21, 0x85, 0x00, 0x79, 0x67, 0x47, 0x3c, 0x00, + 0x79, 0x68, 0x0d, 0xae, 0x00, 0x79, 0x69, 0x56, + 0x5d, 0x00, 0x79, 0x6b, 0x4c, 0xa2, 0x00, 0x79, + 0x6d, 0x08, 0x47, 0x00, 0x79, 0x72, 0x47, 0x3d, + 0x00, 0x79, 0x77, 0x0c, 0x72, 0x00, 0x79, 0x79, + 0x42, 0x78, 0x00, 0x79, 0x7a, 0x17, 0x05, 0x00, + 0x79, 0x7b, 0x56, 0x5e, 0x00, 0x79, 0x7c, 0x4c, + 0xa3, 0x00, 0x79, 0x7e, 0x56, 0x5f, 0x00, 0x79, + 0x7f, 0x17, 0x06, 0x00, 0x79, 0x80, 0x17, 0x1c, + 0x00, 0x79, 0x81, 0x06, 0xd0, 0x00, 0x79, 0x84, + 0x0f, 0xe3, 0x00, 0x79, 0x85, 0x0a, 0xb7, 0x00, + 0x79, 0x8a, 0x17, 0x07, 0x00, 0x79, 0x8b, 0x3a, + 0x3e, 0x00, 0x79, 0x8c, 0x56, 0x60, 0x00, 0x79, + 0x8d, 0x34, 0x0d, 0x00, 0x79, 0x8e, 0x0c, 0x13, + 0x00, 0x79, 0x8f, 0x0d, 0xf1, 0x00, 0x79, 0x91, + 0x56, 0x61, 0x00, 0x79, 0x93, 0x56, 0x62, 0x00, + 0x79, 0x94, 0x21, 0x86, 0x00, 0x79, 0x95, 0x47, + 0x3e, 0x00, 0x79, 0x96, 0x3a, 0x3f, 0x00, 0x79, + 0x98, 0x3a, 0x40, 0x00, 0x79, 0x9b, 0x21, 0x88, + 0x00, 0x79, 0x9c, 0x56, 0x63, 0x00, 0x79, 0x9d, + 0x17, 0x08, 0x00, 0x79, 0xa1, 0x47, 0x3f, 0x00, + 0x79, 0xa6, 0x06, 0x94, 0x00, 0x79, 0xa7, 0x17, + 0x09, 0x00, 0x79, 0xa8, 0x56, 0x64, 0x00, 0x79, + 0xa9, 0x47, 0x40, 0x00, 0x79, 0xaa, 0x17, 0x0b, + 0x00, 0x79, 0xab, 0x4c, 0xa4, 0x00, 0x79, 0xae, + 0x17, 0x0c, 0x00, 0x79, 0xaf, 0x56, 0x65, 0x00, + 0x79, 0xb0, 0x0c, 0xdf, 0x00, 0x79, 0xb1, 0x1e, + 0x4e, 0x00, 0x79, 0xb3, 0x17, 0x0d, 0x00, 0x79, + 0xb4, 0x47, 0x41, 0x00, 0x79, 0xb8, 0x3a, 0x41, + 0x00, 0x79, 0xb9, 0x17, 0x0e, 0x00, 0x79, 0xba, + 0x17, 0x0f, 0x00, 0x79, 0xbb, 0x3a, 0x42, 0x00, + 0x79, 0xbd, 0x06, 0xd1, 0x00, 0x79, 0xbe, 0x05, + 0x53, 0x00, 0x79, 0xbf, 0x0c, 0x9d, 0x00, 0x79, + 0xc0, 0x09, 0x32, 0x00, 0x79, 0xc1, 0x08, 0xb2, + 0x00, 0x79, 0xc2, 0x47, 0x42, 0x00, 0x79, 0xc4, + 0x4c, 0xa5, 0x00, 0x79, 0xc7, 0x47, 0x43, 0x00, + 0x79, 0xc8, 0x42, 0x79, 0x00, 0x79, 0xc9, 0x17, + 0x10, 0x00, 0x79, 0xca, 0x3a, 0x43, 0x00, 0x79, + 0xcb, 0x09, 0x33, 0x00, 0x79, 0xcc, 0x47, 0x44, + 0x00, 0x79, 0xcd, 0x47, 0x45, 0x00, 0x79, 0xcf, + 0x56, 0x66, 0x00, 0x79, 0xd1, 0x05, 0x4a, 0x00, + 0x79, 0xd2, 0x0d, 0xb5, 0x00, 0x79, 0xd4, 0x42, + 0x7b, 0x00, 0x79, 0xd5, 0x17, 0x11, 0x00, 0x79, + 0xd6, 0x47, 0x46, 0x00, 0x79, 0xd8, 0x0d, 0x7f, + 0x00, 0x79, 0xda, 0x3a, 0x44, 0x00, 0x79, 0xdd, + 0x56, 0x67, 0x00, 0x79, 0xde, 0x42, 0x7c, 0x00, + 0x79, 0xdf, 0x0a, 0xc7, 0x00, 0x79, 0xe0, 0x56, + 0x68, 0x00, 0x79, 0xe1, 0x17, 0x14, 0x00, 0x79, + 0xe2, 0x56, 0x69, 0x00, 0x79, 0xe3, 0x17, 0x15, + 0x00, 0x79, 0xe4, 0x0d, 0x1f, 0x00, 0x79, 0xe5, + 0x56, 0x6a, 0x00, 0x79, 0xe6, 0x0a, 0x07, 0x00, + 0x79, 0xe7, 0x17, 0x12, 0x00, 0x79, 0xe9, 0x0b, + 0x9f, 0x00, 0x79, 0xea, 0x4c, 0xa6, 0x00, 0x79, + 0xeb, 0x42, 0x7d, 0x00, 0x79, 0xec, 0x17, 0x13, + 0x00, 0x79, 0xed, 0x42, 0x7e, 0x00, 0x79, 0xf0, + 0x09, 0xb6, 0x00, 0x79, 0xf1, 0x56, 0x6b, 0x00, + 0x79, 0xf8, 0x56, 0x6c, 0x00, 0x79, 0xfb, 0x04, + 0xa0, 0x00, 0x79, 0xfc, 0x56, 0x6d, 0x00, 0x7a, + 0x00, 0x06, 0x43, 0x00, 0x7a, 0x02, 0x4c, 0xa7, + 0x00, 0x7a, 0x03, 0x3a, 0x45, 0x00, 0x7a, 0x05, + 0x36, 0x33, 0x00, 0x7a, 0x07, 0x56, 0x6e, 0x00, + 0x7a, 0x08, 0x17, 0x16, 0x00, 0x7a, 0x09, 0x3a, + 0x46, 0x00, 0x7a, 0x0a, 0x47, 0x4b, 0x00, 0x7a, + 0x0b, 0x0c, 0x14, 0x00, 0x7a, 0x0c, 0x4c, 0xa8, + 0x00, 0x7a, 0x0d, 0x17, 0x17, 0x00, 0x7a, 0x0e, + 0x0a, 0x6b, 0x00, 0x7a, 0x11, 0x3a, 0x47, 0x00, + 0x7a, 0x14, 0x0e, 0xb9, 0x00, 0x7a, 0x15, 0x47, + 0x4c, 0x00, 0x7a, 0x17, 0x0d, 0x95, 0x00, 0x7a, + 0x18, 0x17, 0x18, 0x00, 0x7a, 0x19, 0x17, 0x19, + 0x00, 0x7a, 0x1a, 0x0b, 0x93, 0x00, 0x7a, 0x1b, + 0x47, 0x4d, 0x00, 0x7a, 0x1c, 0x0f, 0x8f, 0x00, + 0x7a, 0x1e, 0x3a, 0x48, 0x00, 0x7a, 0x1f, 0x17, + 0x1b, 0x00, 0x7a, 0x20, 0x17, 0x1a, 0x00, 0x7a, + 0x21, 0x56, 0x6f, 0x00, 0x7a, 0x27, 0x56, 0x70, + 0x00, 0x7a, 0x2b, 0x56, 0x71, 0x00, 0x7a, 0x2d, + 0x3a, 0x49, 0x00, 0x7a, 0x2e, 0x09, 0x1b, 0x00, + 0x7a, 0x2f, 0x56, 0x72, 0x00, 0x7a, 0x30, 0x4c, + 0xa9, 0x00, 0x7a, 0x31, 0x17, 0x1d, 0x00, 0x7a, + 0x32, 0x04, 0xb4, 0x00, 0x7a, 0x34, 0x56, 0x73, + 0x00, 0x7a, 0x35, 0x56, 0x74, 0x00, 0x7a, 0x37, + 0x17, 0x20, 0x00, 0x7a, 0x38, 0x47, 0x4f, 0x00, + 0x7a, 0x39, 0x3a, 0x4a, 0x00, 0x7a, 0x3a, 0x4c, + 0xaa, 0x00, 0x7a, 0x3b, 0x17, 0x1e, 0x00, 0x7a, + 0x3c, 0x05, 0x54, 0x00, 0x7a, 0x3d, 0x07, 0x24, + 0x00, 0x7a, 0x3e, 0x17, 0x1f, 0x00, 0x7a, 0x3f, + 0x07, 0xd8, 0x00, 0x7a, 0x40, 0x34, 0x1f, 0x00, + 0x7a, 0x42, 0x0e, 0x36, 0x00, 0x7a, 0x43, 0x17, + 0x21, 0x00, 0x7a, 0x44, 0x4c, 0xab, 0x00, 0x7a, + 0x45, 0x3a, 0x4b, 0x00, 0x7a, 0x46, 0x0e, 0x82, + 0x00, 0x7a, 0x47, 0x47, 0x50, 0x00, 0x7a, 0x48, + 0x56, 0x75, 0x00, 0x7a, 0x49, 0x17, 0x23, 0x00, + 0x7a, 0x4c, 0x3a, 0x4c, 0x00, 0x7a, 0x4d, 0x0a, + 0x75, 0x00, 0x7a, 0x4e, 0x04, 0xf1, 0x00, 0x7a, + 0x4f, 0x05, 0x3a, 0x00, 0x7a, 0x50, 0x04, 0x70, + 0x00, 0x7a, 0x55, 0x56, 0x76, 0x00, 0x7a, 0x56, + 0x47, 0x51, 0x00, 0x7a, 0x57, 0x17, 0x22, 0x00, + 0x7a, 0x59, 0x47, 0x52, 0x00, 0x7a, 0x5c, 0x47, + 0x53, 0x00, 0x7a, 0x5d, 0x3a, 0x4d, 0x00, 0x7a, + 0x5f, 0x47, 0x54, 0x00, 0x7a, 0x60, 0x4f, 0x56, + 0x00, 0x7a, 0x61, 0x17, 0x24, 0x00, 0x7a, 0x62, + 0x17, 0x25, 0x00, 0x7a, 0x63, 0x09, 0xdf, 0x00, + 0x7a, 0x65, 0x56, 0x77, 0x00, 0x7a, 0x67, 0x47, + 0x55, 0x00, 0x7a, 0x69, 0x17, 0x26, 0x00, 0x7a, + 0x6a, 0x47, 0x56, 0x00, 0x7a, 0x6b, 0x05, 0xad, + 0x00, 0x7a, 0x6d, 0x3a, 0x4f, 0x00, 0x7a, 0x70, + 0x17, 0x28, 0x00, 0x7a, 0x74, 0x07, 0x40, 0x00, + 0x7a, 0x75, 0x47, 0x57, 0x00, 0x7a, 0x76, 0x06, + 0x80, 0x00, 0x7a, 0x78, 0x3a, 0x50, 0x00, 0x7a, + 0x79, 0x17, 0x29, 0x00, 0x7a, 0x7a, 0x06, 0xed, + 0x00, 0x7a, 0x7d, 0x17, 0x2a, 0x00, 0x7a, 0x7e, + 0x56, 0x78, 0x00, 0x7a, 0x7f, 0x0a, 0xa0, 0x00, + 0x7a, 0x80, 0x4c, 0xac, 0x00, 0x7a, 0x81, 0x0c, + 0xa5, 0x00, 0x7a, 0x82, 0x47, 0x58, 0x00, 0x7a, + 0x83, 0x0a, 0x84, 0x00, 0x7a, 0x84, 0x08, 0x65, + 0x00, 0x7a, 0x85, 0x42, 0x7f, 0x00, 0x7a, 0x86, + 0x4c, 0xad, 0x00, 0x7a, 0x88, 0x17, 0x2b, 0x00, + 0x7a, 0x8a, 0x47, 0x59, 0x00, 0x7a, 0x8b, 0x56, + 0x79, 0x00, 0x7a, 0x90, 0x47, 0x5a, 0x00, 0x7a, + 0x91, 0x56, 0x7a, 0x00, 0x7a, 0x92, 0x0b, 0xa0, + 0x00, 0x7a, 0x93, 0x0a, 0xed, 0x00, 0x7a, 0x94, + 0x4c, 0xae, 0x00, 0x7a, 0x95, 0x17, 0x2d, 0x00, + 0x7a, 0x96, 0x17, 0x2f, 0x00, 0x7a, 0x97, 0x17, + 0x2c, 0x00, 0x7a, 0x98, 0x17, 0x2e, 0x00, 0x7a, + 0x9e, 0x56, 0x7b, 0x00, 0x7a, 0x9f, 0x06, 0xf8, + 0x00, 0x7a, 0xa0, 0x3a, 0x51, 0x00, 0x7a, 0xa3, + 0x3a, 0x52, 0x00, 0x7a, 0xa9, 0x17, 0x30, 0x00, + 0x7a, 0xaa, 0x06, 0xfc, 0x00, 0x7a, 0xac, 0x47, + 0x5b, 0x00, 0x7a, 0xae, 0x06, 0x81, 0x00, 0x7a, + 0xaf, 0x0f, 0x3c, 0x00, 0x7a, 0xb0, 0x17, 0x32, + 0x00, 0x7a, 0xb3, 0x3a, 0x53, 0x00, 0x7a, 0xb5, + 0x4c, 0xaf, 0x00, 0x7a, 0xb6, 0x17, 0x33, 0x00, + 0x7a, 0xb9, 0x47, 0x5e, 0x00, 0x7a, 0xba, 0x04, + 0xd0, 0x00, 0x7a, 0xbb, 0x3a, 0x54, 0x00, 0x7a, + 0xbc, 0x3a, 0x55, 0x00, 0x7a, 0xbd, 0x4c, 0xb0, + 0x00, 0x7a, 0xbe, 0x47, 0x5f, 0x00, 0x7a, 0xbf, + 0x17, 0x36, 0x00, 0x7a, 0xc3, 0x05, 0xd4, 0x00, + 0x7a, 0xc4, 0x17, 0x35, 0x00, 0x7a, 0xc5, 0x17, + 0x34, 0x00, 0x7a, 0xc6, 0x3a, 0x56, 0x00, 0x7a, + 0xc7, 0x17, 0x38, 0x00, 0x7a, 0xc8, 0x17, 0x31, + 0x00, 0x7a, 0xc9, 0x56, 0x7c, 0x00, 0x7a, 0xca, + 0x17, 0x39, 0x00, 0x7a, 0xcb, 0x0f, 0x71, 0x00, + 0x7a, 0xcc, 0x47, 0x61, 0x00, 0x7a, 0xcd, 0x17, + 0x3a, 0x00, 0x7a, 0xce, 0x42, 0x81, 0x00, 0x7a, + 0xcf, 0x17, 0x3b, 0x00, 0x7a, 0xd1, 0x21, 0x89, + 0x00, 0x7a, 0xd2, 0x11, 0xc5, 0x00, 0x7a, 0xd3, + 0x17, 0x3d, 0x00, 0x7a, 0xd5, 0x17, 0x3c, 0x00, + 0x7a, 0xd9, 0x17, 0x3e, 0x00, 0x7a, 0xda, 0x17, + 0x3f, 0x00, 0x7a, 0xdb, 0x56, 0x7d, 0x00, 0x7a, + 0xdc, 0x0f, 0x7d, 0x00, 0x7a, 0xdd, 0x17, 0x40, + 0x00, 0x7a, 0xdf, 0x1c, 0x08, 0x00, 0x7a, 0xe0, + 0x09, 0xb7, 0x00, 0x7a, 0xe1, 0x17, 0x41, 0x00, + 0x7a, 0xe2, 0x17, 0x42, 0x00, 0x7a, 0xe3, 0x09, + 0x61, 0x00, 0x7a, 0xe5, 0x0c, 0x90, 0x00, 0x7a, + 0xe6, 0x17, 0x43, 0x00, 0x7a, 0xe7, 0x21, 0x8a, + 0x00, 0x7a, 0xe8, 0x47, 0x62, 0x00, 0x7a, 0xe9, + 0x56, 0x7e, 0x00, 0x7a, 0xea, 0x0b, 0x66, 0x00, + 0x7a, 0xeb, 0x21, 0x8c, 0x00, 0x7a, 0xec, 0x56, + 0x7f, 0x00, 0x7a, 0xed, 0x17, 0x44, 0x00, 0x7a, + 0xef, 0x0b, 0x7a, 0x00, 0x7a, 0xf0, 0x17, 0x45, + 0x00, 0x7a, 0xf1, 0x56, 0x80, 0x00, 0x7a, 0xf4, + 0x47, 0x63, 0x00, 0x7a, 0xf6, 0x06, 0x9d, 0x00, + 0x7a, 0xf8, 0x10, 0x76, 0x00, 0x7a, 0xf9, 0x0b, + 0x9b, 0x00, 0x7a, 0xfa, 0x08, 0xdf, 0x00, 0x7a, + 0xfb, 0x56, 0x81, 0x00, 0x7a, 0xfd, 0x42, 0x82, + 0x00, 0x7a, 0xfe, 0x4c, 0xb1, 0x00, 0x7a, 0xff, + 0x06, 0x04, 0x00, 0x7b, 0x02, 0x17, 0x46, 0x00, + 0x7b, 0x04, 0x17, 0x53, 0x00, 0x7b, 0x06, 0x17, + 0x49, 0x00, 0x7b, 0x07, 0x3a, 0x57, 0x00, 0x7b, + 0x08, 0x06, 0x82, 0x00, 0x7b, 0x0a, 0x17, 0x48, + 0x00, 0x7b, 0x0b, 0x17, 0x55, 0x00, 0x7b, 0x0f, + 0x17, 0x47, 0x00, 0x7b, 0x11, 0x09, 0xb8, 0x00, + 0x7b, 0x12, 0x42, 0x83, 0x00, 0x7b, 0x14, 0x3a, + 0x58, 0x00, 0x7b, 0x18, 0x17, 0x4b, 0x00, 0x7b, + 0x19, 0x17, 0x4c, 0x00, 0x7b, 0x1b, 0x0c, 0x25, + 0x00, 0x7b, 0x1e, 0x17, 0x4d, 0x00, 0x7b, 0x1f, + 0x56, 0x82, 0x00, 0x7b, 0x20, 0x05, 0xbc, 0x00, + 0x7b, 0x23, 0x56, 0x83, 0x00, 0x7b, 0x25, 0x0a, + 0x20, 0x00, 0x7b, 0x26, 0x0d, 0xd6, 0x00, 0x7b, + 0x27, 0x3a, 0x59, 0x00, 0x7b, 0x28, 0x17, 0x4f, + 0x00, 0x7b, 0x29, 0x56, 0x84, 0x00, 0x7b, 0x2a, + 0x47, 0x68, 0x00, 0x7b, 0x2b, 0x4c, 0xb2, 0x00, + 0x7b, 0x2c, 0x0b, 0x48, 0x00, 0x7b, 0x2d, 0x42, + 0x84, 0x00, 0x7b, 0x2e, 0x47, 0x69, 0x00, 0x7b, + 0x2f, 0x47, 0x6a, 0x00, 0x7b, 0x30, 0x56, 0x85, + 0x00, 0x7b, 0x31, 0x3a, 0x5a, 0x00, 0x7b, 0x33, + 0x17, 0x4a, 0x00, 0x7b, 0x34, 0x56, 0x86, 0x00, + 0x7b, 0x35, 0x17, 0x4e, 0x00, 0x7b, 0x36, 0x17, + 0x50, 0x00, 0x7b, 0x39, 0x08, 0x6b, 0x00, 0x7b, + 0x3b, 0x42, 0x85, 0x00, 0x7b, 0x3d, 0x47, 0x67, + 0x00, 0x7b, 0x3f, 0x56, 0x87, 0x00, 0x7b, 0x40, + 0x56, 0x88, 0x00, 0x7b, 0x41, 0x47, 0x6e, 0x00, + 0x7b, 0x45, 0x17, 0x57, 0x00, 0x7b, 0x46, 0x0d, + 0xa0, 0x00, 0x7b, 0x47, 0x3a, 0x5b, 0x00, 0x7b, + 0x48, 0x0d, 0x3a, 0x00, 0x7b, 0x49, 0x0c, 0x73, + 0x00, 0x7b, 0x4b, 0x06, 0xd2, 0x00, 0x7b, 0x4c, + 0x17, 0x56, 0x00, 0x7b, 0x4d, 0x17, 0x54, 0x00, + 0x7b, 0x4e, 0x3a, 0x5c, 0x00, 0x7b, 0x4f, 0x0d, + 0x49, 0x00, 0x7b, 0x50, 0x17, 0x51, 0x00, 0x7b, + 0x51, 0x0b, 0x9c, 0x00, 0x7b, 0x52, 0x0c, 0x75, + 0x00, 0x7b, 0x53, 0x37, 0x5d, 0x00, 0x7b, 0x54, + 0x0c, 0x74, 0x00, 0x7b, 0x55, 0x47, 0x70, 0x00, + 0x7b, 0x56, 0x08, 0x66, 0x00, 0x7b, 0x5d, 0x17, + 0x69, 0x00, 0x7b, 0x60, 0x3a, 0x5d, 0x00, 0x7b, + 0x64, 0x47, 0x72, 0x00, 0x7b, 0x65, 0x17, 0x59, + 0x00, 0x7b, 0x66, 0x47, 0x73, 0x00, 0x7b, 0x67, + 0x17, 0x5b, 0x00, 0x7b, 0x69, 0x3a, 0x5e, 0x00, + 0x7b, 0x6a, 0x56, 0x89, 0x00, 0x7b, 0x6c, 0x17, + 0x5e, 0x00, 0x7b, 0x6d, 0x3a, 0x5f, 0x00, 0x7b, + 0x6e, 0x17, 0x5f, 0x00, 0x7b, 0x6f, 0x42, 0x86, + 0x00, 0x7b, 0x70, 0x17, 0x5c, 0x00, 0x7b, 0x71, + 0x17, 0x5d, 0x00, 0x7b, 0x72, 0x3a, 0x60, 0x00, + 0x7b, 0x73, 0x47, 0x74, 0x00, 0x7b, 0x74, 0x17, + 0x5a, 0x00, 0x7b, 0x75, 0x17, 0x58, 0x00, 0x7b, + 0x77, 0x4c, 0xb3, 0x00, 0x7b, 0x79, 0x47, 0x71, + 0x00, 0x7b, 0x7a, 0x17, 0x52, 0x00, 0x7b, 0x7f, + 0x47, 0x6d, 0x00, 0x7b, 0x84, 0x56, 0x8a, 0x00, + 0x7b, 0x86, 0x0e, 0x1f, 0x00, 0x7b, 0x87, 0x05, + 0x55, 0x00, 0x7b, 0x89, 0x56, 0x8b, 0x00, 0x7b, + 0x8b, 0x17, 0x66, 0x00, 0x7b, 0x8d, 0x17, 0x63, + 0x00, 0x7b, 0x8e, 0x56, 0x8c, 0x00, 0x7b, 0x8f, + 0x17, 0x68, 0x00, 0x7b, 0x90, 0x47, 0x77, 0x00, + 0x7b, 0x91, 0x3a, 0x61, 0x00, 0x7b, 0x92, 0x17, + 0x67, 0x00, 0x7b, 0x94, 0x0d, 0x29, 0x00, 0x7b, + 0x95, 0x0e, 0xb3, 0x00, 0x7b, 0x96, 0x56, 0x8d, + 0x00, 0x7b, 0x97, 0x08, 0x89, 0x00, 0x7b, 0x98, + 0x17, 0x61, 0x00, 0x7b, 0x99, 0x17, 0x6a, 0x00, + 0x7b, 0x9a, 0x17, 0x65, 0x00, 0x7b, 0x9b, 0x47, + 0x78, 0x00, 0x7b, 0x9c, 0x17, 0x64, 0x00, 0x7b, + 0x9d, 0x17, 0x60, 0x00, 0x7b, 0x9e, 0x21, 0x8d, + 0x00, 0x7b, 0x9f, 0x17, 0x62, 0x00, 0x7b, 0xa0, + 0x4c, 0xb4, 0x00, 0x7b, 0xa1, 0x06, 0x05, 0x00, + 0x7b, 0xa5, 0x56, 0x8e, 0x00, 0x7b, 0xaa, 0x0b, + 0x7b, 0x00, 0x7b, 0xac, 0x4c, 0xb5, 0x00, 0x7b, + 0xad, 0x0a, 0xa1, 0x00, 0x7b, 0xaf, 0x3a, 0x62, + 0x00, 0x7b, 0xb0, 0x4c, 0xb6, 0x00, 0x7b, 0xb1, + 0x0d, 0x36, 0x00, 0x7b, 0xb2, 0x56, 0x8f, 0x00, + 0x7b, 0xb4, 0x17, 0x6f, 0x00, 0x7b, 0xb5, 0x47, + 0x7a, 0x00, 0x7b, 0xb6, 0x56, 0x90, 0x00, 0x7b, + 0xb8, 0x0d, 0x38, 0x00, 0x7b, 0xba, 0x56, 0x91, + 0x00, 0x7b, 0xbb, 0x56, 0x92, 0x00, 0x7b, 0xbc, + 0x47, 0x7b, 0x00, 0x7b, 0xbd, 0x56, 0x93, 0x00, + 0x7b, 0xc0, 0x0a, 0x85, 0x00, 0x7b, 0xc1, 0x17, + 0x6c, 0x00, 0x7b, 0xc2, 0x56, 0x94, 0x00, 0x7b, + 0xc4, 0x0d, 0x63, 0x00, 0x7b, 0xc5, 0x47, 0x7c, + 0x00, 0x7b, 0xc6, 0x17, 0x70, 0x00, 0x7b, 0xc7, + 0x0e, 0x23, 0x00, 0x7b, 0xc8, 0x56, 0x95, 0x00, + 0x7b, 0xc9, 0x0b, 0x99, 0x00, 0x7b, 0xca, 0x47, + 0x7d, 0x00, 0x7b, 0xcb, 0x17, 0x6b, 0x00, 0x7b, + 0xcc, 0x17, 0x6d, 0x00, 0x7b, 0xcf, 0x17, 0x6e, + 0x00, 0x7b, 0xd4, 0x47, 0x80, 0x00, 0x7b, 0xd6, + 0x47, 0x81, 0x00, 0x7b, 0xd7, 0x3a, 0x63, 0x00, + 0x7b, 0xd9, 0x3a, 0x64, 0x00, 0x7b, 0xda, 0x47, + 0x82, 0x00, 0x7b, 0xdb, 0x56, 0x96, 0x00, 0x7b, + 0xdd, 0x17, 0x71, 0x00, 0x7b, 0xe0, 0x08, 0xf0, + 0x00, 0x7b, 0xe4, 0x0c, 0x9e, 0x00, 0x7b, 0xe5, + 0x17, 0x76, 0x00, 0x7b, 0xe6, 0x17, 0x75, 0x00, + 0x7b, 0xe8, 0x4c, 0xb7, 0x00, 0x7b, 0xe9, 0x17, + 0x72, 0x00, 0x7b, 0xea, 0x47, 0x83, 0x00, 0x7b, + 0xed, 0x0f, 0xdc, 0x00, 0x7b, 0xf0, 0x47, 0x84, + 0x00, 0x7b, 0xf2, 0x4c, 0xb8, 0x00, 0x7b, 0xf3, + 0x17, 0x7b, 0x00, 0x7b, 0xf4, 0x56, 0x97, 0x00, + 0x7b, 0xf5, 0x56, 0x98, 0x00, 0x7b, 0xf6, 0x17, + 0x7f, 0x00, 0x7b, 0xf7, 0x17, 0x7c, 0x00, 0x7b, + 0xf8, 0x4c, 0xb9, 0x00, 0x7b, 0xf9, 0x56, 0x99, + 0x00, 0x7b, 0xfa, 0x56, 0x9a, 0x00, 0x7b, 0xfc, + 0x4c, 0xba, 0x00, 0x7b, 0xfe, 0x4c, 0xbb, 0x00, + 0x7c, 0x00, 0x17, 0x78, 0x00, 0x7c, 0x01, 0x42, + 0x87, 0x00, 0x7c, 0x02, 0x56, 0x9b, 0x00, 0x7c, + 0x03, 0x47, 0x85, 0x00, 0x7c, 0x04, 0x56, 0x9c, + 0x00, 0x7c, 0x06, 0x56, 0x9d, 0x00, 0x7c, 0x07, + 0x17, 0x79, 0x00, 0x7c, 0x09, 0x4c, 0xbc, 0x00, + 0x7c, 0x0b, 0x3a, 0x65, 0x00, 0x7c, 0x0c, 0x56, + 0x9e, 0x00, 0x7c, 0x0d, 0x17, 0x7e, 0x00, 0x7c, + 0x0e, 0x47, 0x86, 0x00, 0x7c, 0x0f, 0x3a, 0x66, + 0x00, 0x7c, 0x11, 0x17, 0x73, 0x00, 0x7c, 0x12, + 0x10, 0xea, 0x00, 0x7c, 0x13, 0x17, 0x7a, 0x00, + 0x7c, 0x14, 0x17, 0x74, 0x00, 0x7c, 0x17, 0x17, + 0x7d, 0x00, 0x7c, 0x19, 0x56, 0x9f, 0x00, 0x7c, + 0x1b, 0x56, 0xa0, 0x00, 0x7c, 0x1e, 0x1e, 0x3b, + 0x00, 0x7c, 0x1f, 0x17, 0x83, 0x00, 0x7c, 0x20, + 0x3a, 0x67, 0x00, 0x7c, 0x21, 0x06, 0x06, 0x00, + 0x7c, 0x23, 0x17, 0x80, 0x00, 0x7c, 0x25, 0x56, + 0xa1, 0x00, 0x7c, 0x26, 0x3a, 0x68, 0x00, 0x7c, + 0x27, 0x17, 0x81, 0x00, 0x7c, 0x28, 0x4c, 0xbd, + 0x00, 0x7c, 0x2a, 0x17, 0x82, 0x00, 0x7c, 0x2b, + 0x17, 0x85, 0x00, 0x7c, 0x2c, 0x56, 0xa2, 0x00, + 0x7c, 0x2f, 0x4c, 0xbe, 0x00, 0x7c, 0x31, 0x3a, + 0x69, 0x00, 0x7c, 0x33, 0x42, 0x88, 0x00, 0x7c, + 0x34, 0x56, 0xa3, 0x00, 0x7c, 0x36, 0x3a, 0x6a, + 0x00, 0x7c, 0x37, 0x17, 0x84, 0x00, 0x7c, 0x38, + 0x0d, 0x8a, 0x00, 0x7c, 0x39, 0x56, 0xa4, 0x00, + 0x7c, 0x3a, 0x56, 0xa5, 0x00, 0x7c, 0x3d, 0x17, + 0x86, 0x00, 0x7c, 0x3e, 0x0f, 0xc4, 0x00, 0x7c, + 0x3f, 0x0e, 0x3d, 0x00, 0x7c, 0x40, 0x17, 0x8b, + 0x00, 0x7c, 0x42, 0x4c, 0xbf, 0x00, 0x7c, 0x43, + 0x17, 0x88, 0x00, 0x7c, 0x45, 0x47, 0x87, 0x00, + 0x7c, 0x46, 0x56, 0xa6, 0x00, 0x7c, 0x4a, 0x47, + 0x88, 0x00, 0x7c, 0x4c, 0x17, 0x87, 0x00, 0x7c, + 0x4d, 0x0a, 0x76, 0x00, 0x7c, 0x4f, 0x17, 0x8a, + 0x00, 0x7c, 0x50, 0x17, 0x8c, 0x00, 0x7c, 0x51, + 0x3a, 0x6b, 0x00, 0x7c, 0x52, 0x4c, 0xc0, 0x00, + 0x7c, 0x53, 0x4c, 0xc1, 0x00, 0x7c, 0x54, 0x17, + 0x89, 0x00, 0x7c, 0x55, 0x56, 0xa7, 0x00, 0x7c, + 0x56, 0x17, 0x90, 0x00, 0x7c, 0x57, 0x47, 0x89, + 0x00, 0x7c, 0x58, 0x17, 0x8d, 0x00, 0x7c, 0x59, + 0x3a, 0x6c, 0x00, 0x7c, 0x5a, 0x56, 0xa8, 0x00, + 0x7c, 0x5b, 0x4c, 0xc2, 0x00, 0x7c, 0x5c, 0x4c, + 0xc3, 0x00, 0x7c, 0x5d, 0x4c, 0xc4, 0x00, 0x7c, + 0x5e, 0x47, 0x8a, 0x00, 0x7c, 0x5f, 0x17, 0x8e, + 0x00, 0x7c, 0x60, 0x17, 0x77, 0x00, 0x7c, 0x61, + 0x47, 0x8b, 0x00, 0x7c, 0x63, 0x56, 0xa9, 0x00, + 0x7c, 0x64, 0x17, 0x8f, 0x00, 0x7c, 0x65, 0x17, + 0x91, 0x00, 0x7c, 0x67, 0x3a, 0x6d, 0x00, 0x7c, + 0x69, 0x47, 0x8c, 0x00, 0x7c, 0x6c, 0x17, 0x92, + 0x00, 0x7c, 0x6d, 0x42, 0x8a, 0x00, 0x7c, 0x6e, + 0x3a, 0x6e, 0x00, 0x7c, 0x6f, 0x47, 0x8d, 0x00, + 0x7c, 0x70, 0x3a, 0x6f, 0x00, 0x7c, 0x72, 0x4c, + 0xc5, 0x00, 0x7c, 0x73, 0x0e, 0x16, 0x00, 0x7c, + 0x75, 0x17, 0x93, 0x00, 0x7c, 0x79, 0x42, 0x8b, + 0x00, 0x7c, 0x7b, 0x37, 0x0e, 0x00, 0x7c, 0x7c, + 0x56, 0xab, 0x00, 0x7c, 0x7d, 0x4c, 0xc6, 0x00, + 0x7c, 0x7e, 0x0e, 0xee, 0x00, 0x7c, 0x81, 0x06, + 0xc6, 0x00, 0x7c, 0x82, 0x06, 0xff, 0x00, 0x7c, + 0x83, 0x17, 0x94, 0x00, 0x7c, 0x86, 0x56, 0xac, + 0x00, 0x7c, 0x87, 0x4c, 0xc7, 0x00, 0x7c, 0x89, + 0x0e, 0x04, 0x00, 0x7c, 0x8b, 0x0a, 0x2e, 0x00, + 0x7c, 0x8d, 0x0e, 0xbc, 0x00, 0x7c, 0x8f, 0x42, + 0x8c, 0x00, 0x7c, 0x90, 0x17, 0x95, 0x00, 0x7c, + 0x92, 0x0f, 0x7b, 0x00, 0x7c, 0x94, 0x42, 0x8d, + 0x00, 0x7c, 0x95, 0x0d, 0x2a, 0x00, 0x7c, 0x97, + 0x0a, 0xc8, 0x00, 0x7c, 0x98, 0x0c, 0xea, 0x00, + 0x7c, 0x9b, 0x09, 0x57, 0x00, 0x7c, 0x9e, 0x4c, + 0xc8, 0x00, 0x7c, 0x9f, 0x04, 0x84, 0x00, 0x7c, + 0xa0, 0x42, 0x8e, 0x00, 0x7c, 0xa1, 0x17, 0x9a, + 0x00, 0x7c, 0xa2, 0x17, 0x98, 0x00, 0x7c, 0xa4, + 0x17, 0x96, 0x00, 0x7c, 0xa5, 0x05, 0xdd, 0x00, + 0x7c, 0xa6, 0x47, 0x91, 0x00, 0x7c, 0xa7, 0x09, + 0xb9, 0x00, 0x7c, 0xa8, 0x17, 0x9b, 0x00, 0x7c, + 0xab, 0x17, 0x99, 0x00, 0x7c, 0xad, 0x17, 0x97, + 0x00, 0x7c, 0xae, 0x17, 0x9f, 0x00, 0x7c, 0xb0, + 0x56, 0xad, 0x00, 0x7c, 0xb1, 0x17, 0x9e, 0x00, + 0x7c, 0xb2, 0x17, 0x9d, 0x00, 0x7c, 0xb3, 0x17, + 0x9c, 0x00, 0x7c, 0xb6, 0x47, 0x93, 0x00, 0x7c, + 0xb7, 0x47, 0x94, 0x00, 0x7c, 0xb9, 0x17, 0xa0, + 0x00, 0x7c, 0xba, 0x4c, 0xc9, 0x00, 0x7c, 0xbb, + 0x56, 0xae, 0x00, 0x7c, 0xbc, 0x3a, 0x70, 0x00, + 0x7c, 0xbd, 0x17, 0xa1, 0x00, 0x7c, 0xbe, 0x21, + 0x8e, 0x00, 0x7c, 0xbf, 0x3a, 0x71, 0x00, 0x7c, + 0xc0, 0x17, 0xa2, 0x00, 0x7c, 0xc2, 0x17, 0xa4, + 0x00, 0x7c, 0xc4, 0x47, 0x96, 0x00, 0x7c, 0xc5, + 0x17, 0xa3, 0x00, 0x7c, 0xc7, 0x4c, 0xca, 0x00, + 0x7c, 0xc8, 0x3a, 0x72, 0x00, 0x7c, 0xc9, 0x3a, + 0x73, 0x00, 0x7c, 0xca, 0x07, 0x86, 0x00, 0x7c, + 0xcd, 0x47, 0x98, 0x00, 0x7c, 0xce, 0x0a, 0xba, + 0x00, 0x7c, 0xcf, 0x56, 0xaf, 0x00, 0x7c, 0xd2, + 0x17, 0xa6, 0x00, 0x7c, 0xd3, 0x4c, 0xcb, 0x00, + 0x7c, 0xd4, 0x56, 0xb0, 0x00, 0x7c, 0xd5, 0x42, + 0x8f, 0x00, 0x7c, 0xd6, 0x36, 0x84, 0x00, 0x7c, + 0xd7, 0x3a, 0x74, 0x00, 0x7c, 0xd8, 0x17, 0xa5, + 0x00, 0x7c, 0xd9, 0x3a, 0x75, 0x00, 0x7c, 0xda, + 0x4c, 0xcc, 0x00, 0x7c, 0xdc, 0x17, 0xa7, 0x00, + 0x7c, 0xdd, 0x3a, 0x76, 0x00, 0x7c, 0xde, 0x0e, + 0x05, 0x00, 0x7c, 0xdf, 0x0a, 0xee, 0x00, 0x7c, + 0xe0, 0x07, 0xd9, 0x00, 0x7c, 0xe2, 0x17, 0xa8, + 0x00, 0x7c, 0xe6, 0x47, 0x9b, 0x00, 0x7c, 0xe7, + 0x0f, 0x90, 0x00, 0x7c, 0xe9, 0x56, 0xb1, 0x00, + 0x7c, 0xeb, 0x3a, 0x77, 0x00, 0x7c, 0xef, 0x17, + 0xaa, 0x00, 0x7c, 0xf2, 0x17, 0xab, 0x00, 0x7c, + 0xf4, 0x17, 0xac, 0x00, 0x7c, 0xf5, 0x47, 0x9d, + 0x00, 0x7c, 0xf6, 0x17, 0xad, 0x00, 0x7c, 0xf8, + 0x08, 0xb3, 0x00, 0x7c, 0xfa, 0x17, 0xae, 0x00, + 0x7c, 0xfb, 0x07, 0x25, 0x00, 0x7c, 0xfe, 0x06, + 0x84, 0x00, 0x7d, 0x00, 0x06, 0x44, 0x00, 0x7d, + 0x02, 0x17, 0xb0, 0x00, 0x7d, 0x03, 0x47, 0x9e, + 0x00, 0x7d, 0x04, 0x0e, 0xff, 0x00, 0x7d, 0x05, + 0x07, 0xda, 0x00, 0x7d, 0x06, 0x17, 0xaf, 0x00, + 0x7d, 0x07, 0x3a, 0x78, 0x00, 0x7d, 0x08, 0x3a, + 0x79, 0x00, 0x7d, 0x09, 0x3a, 0x7a, 0x00, 0x7d, + 0x0a, 0x17, 0xb3, 0x00, 0x7d, 0x0b, 0x0e, 0xf2, + 0x00, 0x7d, 0x0d, 0x0c, 0xf2, 0x00, 0x7d, 0x0f, + 0x56, 0xb2, 0x00, 0x7d, 0x10, 0x0d, 0xa5, 0x00, + 0x7d, 0x11, 0x56, 0xb3, 0x00, 0x7d, 0x12, 0x47, + 0xa0, 0x00, 0x7d, 0x13, 0x3a, 0x7b, 0x00, 0x7d, + 0x14, 0x09, 0x6d, 0x00, 0x7d, 0x15, 0x17, 0xb2, + 0x00, 0x7d, 0x16, 0x56, 0xb4, 0x00, 0x7d, 0x17, + 0x08, 0xff, 0x00, 0x7d, 0x18, 0x07, 0xdb, 0x00, + 0x7d, 0x19, 0x08, 0xb4, 0x00, 0x7d, 0x1a, 0x06, + 0x83, 0x00, 0x7d, 0x1b, 0x0e, 0x06, 0x00, 0x7d, + 0x1c, 0x17, 0xb1, 0x00, 0x7d, 0x1d, 0x3a, 0x7c, + 0x00, 0x7d, 0x1e, 0x47, 0xa1, 0x00, 0x7d, 0x20, + 0x0a, 0xc9, 0x00, 0x7d, 0x21, 0x0e, 0x70, 0x00, + 0x7d, 0x22, 0x08, 0x67, 0x00, 0x7d, 0x23, 0x3a, + 0x7d, 0x00, 0x7d, 0x26, 0x56, 0xb5, 0x00, 0x7d, + 0x2a, 0x56, 0xb6, 0x00, 0x7d, 0x2b, 0x08, 0xb5, + 0x00, 0x7d, 0x2c, 0x0b, 0xf9, 0x00, 0x7d, 0x2d, + 0x56, 0xb7, 0x00, 0x7d, 0x2e, 0x17, 0xb6, 0x00, + 0x7d, 0x2f, 0x0f, 0xa7, 0x00, 0x7d, 0x30, 0x08, + 0x49, 0x00, 0x7d, 0x31, 0x42, 0x90, 0x00, 0x7d, + 0x32, 0x17, 0xb7, 0x00, 0x7d, 0x33, 0x0a, 0x08, + 0x00, 0x7d, 0x35, 0x17, 0xb9, 0x00, 0x7d, 0x39, + 0x09, 0xba, 0x00, 0x7d, 0x3a, 0x08, 0x20, 0x00, + 0x7d, 0x3c, 0x4c, 0xcd, 0x00, 0x7d, 0x3d, 0x47, + 0xa4, 0x00, 0x7d, 0x3e, 0x47, 0xa5, 0x00, 0x7d, + 0x3f, 0x17, 0xb8, 0x00, 0x7d, 0x40, 0x47, 0xa6, + 0x00, 0x7d, 0x41, 0x3a, 0x7e, 0x00, 0x7d, 0x42, + 0x09, 0x34, 0x00, 0x7d, 0x43, 0x07, 0x72, 0x00, + 0x7d, 0x44, 0x0a, 0xca, 0x00, 0x7d, 0x45, 0x17, + 0xb4, 0x00, 0x7d, 0x46, 0x17, 0xba, 0x00, 0x7d, + 0x47, 0x47, 0xa7, 0x00, 0x7d, 0x48, 0x21, 0x8f, + 0x00, 0x7d, 0x4b, 0x17, 0xb5, 0x00, 0x7d, 0x4c, + 0x07, 0x26, 0x00, 0x7d, 0x4d, 0x4c, 0xce, 0x00, + 0x7d, 0x4e, 0x17, 0xbd, 0x00, 0x7d, 0x4f, 0x17, + 0xc1, 0x00, 0x7d, 0x50, 0x07, 0x41, 0x00, 0x7d, + 0x51, 0x56, 0xb8, 0x00, 0x7d, 0x53, 0x3a, 0x7f, + 0x00, 0x7d, 0x55, 0x36, 0x3a, 0x00, 0x7d, 0x56, + 0x17, 0xbc, 0x00, 0x7d, 0x57, 0x56, 0xb9, 0x00, + 0x7d, 0x59, 0x3a, 0x80, 0x00, 0x7d, 0x5a, 0x47, + 0xab, 0x00, 0x7d, 0x5b, 0x17, 0xc5, 0x00, 0x7d, + 0x5c, 0x42, 0x91, 0x00, 0x7d, 0x5d, 0x3a, 0x81, + 0x00, 0x7d, 0x5e, 0x07, 0xdc, 0x00, 0x7d, 0x61, + 0x0f, 0x57, 0x00, 0x7d, 0x62, 0x04, 0x80, 0x00, + 0x7d, 0x63, 0x17, 0xc2, 0x00, 0x7d, 0x65, 0x56, + 0xba, 0x00, 0x7d, 0x66, 0x06, 0x85, 0x00, 0x7d, + 0x67, 0x56, 0xbb, 0x00, 0x7d, 0x68, 0x17, 0xbf, + 0x00, 0x7d, 0x6a, 0x47, 0xac, 0x00, 0x7d, 0x6e, + 0x17, 0xc0, 0x00, 0x7d, 0x70, 0x47, 0xad, 0x00, + 0x7d, 0x71, 0x0c, 0x77, 0x00, 0x7d, 0x72, 0x17, + 0xbe, 0x00, 0x7d, 0x73, 0x17, 0xbb, 0x00, 0x7d, + 0x75, 0x05, 0x86, 0x00, 0x7d, 0x76, 0x0a, 0x88, + 0x00, 0x7d, 0x78, 0x56, 0xbc, 0x00, 0x7d, 0x79, + 0x07, 0x5c, 0x00, 0x7d, 0x7a, 0x3a, 0x82, 0x00, + 0x7d, 0x7b, 0x56, 0xbd, 0x00, 0x7d, 0x7d, 0x17, + 0xc7, 0x00, 0x7d, 0x7f, 0x47, 0xaf, 0x00, 0x7d, + 0x81, 0x56, 0xbe, 0x00, 0x7d, 0x82, 0x4c, 0xcf, + 0x00, 0x7d, 0x83, 0x42, 0x92, 0x00, 0x7d, 0x85, + 0x4c, 0xd0, 0x00, 0x7d, 0x86, 0x3a, 0x83, 0x00, + 0x7d, 0x88, 0x47, 0xb1, 0x00, 0x7d, 0x89, 0x17, + 0xc4, 0x00, 0x7d, 0x8b, 0x3a, 0x84, 0x00, 0x7d, + 0x8c, 0x3a, 0x85, 0x00, 0x7d, 0x8d, 0x4c, 0xd1, + 0x00, 0x7d, 0x8f, 0x17, 0xc6, 0x00, 0x7d, 0x91, + 0x4c, 0xd2, 0x00, 0x7d, 0x93, 0x17, 0xc3, 0x00, + 0x7d, 0x96, 0x56, 0xbf, 0x00, 0x7d, 0x97, 0x47, + 0xb2, 0x00, 0x7d, 0x99, 0x07, 0x27, 0x00, 0x7d, + 0x9a, 0x0b, 0x13, 0x00, 0x7d, 0x9b, 0x17, 0xc8, + 0x00, 0x7d, 0x9c, 0x0a, 0xf0, 0x00, 0x7d, 0x9d, + 0x47, 0xb4, 0x00, 0x7d, 0x9e, 0x4c, 0xd3, 0x00, + 0x7d, 0x9f, 0x17, 0xd5, 0x00, 0x7d, 0xa0, 0x21, + 0x92, 0x00, 0x7d, 0xa2, 0x17, 0xd1, 0x00, 0x7d, + 0xa3, 0x17, 0xcb, 0x00, 0x7d, 0xa6, 0x42, 0x93, + 0x00, 0x7d, 0xa7, 0x47, 0xb5, 0x00, 0x7d, 0xaa, + 0x47, 0xb6, 0x00, 0x7d, 0xab, 0x17, 0xcf, 0x00, + 0x7d, 0xac, 0x09, 0x26, 0x00, 0x7d, 0xad, 0x04, + 0xa1, 0x00, 0x7d, 0xae, 0x17, 0xca, 0x00, 0x7d, + 0xaf, 0x17, 0xd2, 0x00, 0x7d, 0xb0, 0x17, 0xd6, + 0x00, 0x7d, 0xb1, 0x07, 0xdd, 0x00, 0x7d, 0xb2, + 0x0e, 0xe2, 0x00, 0x7d, 0xb3, 0x4c, 0xd4, 0x00, + 0x7d, 0xb4, 0x0b, 0xf2, 0x00, 0x7d, 0xb5, 0x17, + 0xcc, 0x00, 0x7d, 0xb6, 0x47, 0xb7, 0x00, 0x7d, + 0xb7, 0x21, 0x91, 0x00, 0x7d, 0xb8, 0x17, 0xd4, + 0x00, 0x7d, 0xb9, 0x4c, 0xd5, 0x00, 0x7d, 0xba, + 0x17, 0xc9, 0x00, 0x7d, 0xbb, 0x0b, 0x7c, 0x00, + 0x7d, 0xbd, 0x17, 0xce, 0x00, 0x7d, 0xbe, 0x04, + 0x81, 0x00, 0x7d, 0xbf, 0x0e, 0xd6, 0x00, 0x7d, + 0xc0, 0x47, 0xb8, 0x00, 0x7d, 0xc2, 0x42, 0x94, + 0x00, 0x7d, 0xc3, 0x56, 0xc0, 0x00, 0x7d, 0xc4, + 0x56, 0xc1, 0x00, 0x7d, 0xc5, 0x56, 0xc2, 0x00, + 0x7d, 0xc6, 0x56, 0xc3, 0x00, 0x7d, 0xc7, 0x17, + 0xcd, 0x00, 0x7d, 0xca, 0x06, 0xd3, 0x00, 0x7d, + 0xcb, 0x0d, 0x80, 0x00, 0x7d, 0xcc, 0x3a, 0x86, + 0x00, 0x7d, 0xcd, 0x56, 0xc4, 0x00, 0x7d, 0xce, + 0x56, 0xc5, 0x00, 0x7d, 0xcf, 0x0a, 0xef, 0x00, + 0x7d, 0xd0, 0x4c, 0xd6, 0x00, 0x7d, 0xd1, 0x0f, + 0x98, 0x00, 0x7d, 0xd2, 0x09, 0x79, 0x00, 0x7d, + 0xd5, 0x17, 0xfd, 0x00, 0x7d, 0xd6, 0x21, 0x93, + 0x00, 0x7d, 0xd7, 0x47, 0xb9, 0x00, 0x7d, 0xd8, + 0x17, 0xd7, 0x00, 0x7d, 0xd9, 0x47, 0xba, 0x00, + 0x7d, 0xda, 0x0a, 0xa2, 0x00, 0x7d, 0xdc, 0x17, + 0xd3, 0x00, 0x7d, 0xdd, 0x17, 0xd8, 0x00, 0x7d, + 0xde, 0x17, 0xda, 0x00, 0x7d, 0xe0, 0x0c, 0x15, + 0x00, 0x7d, 0xe1, 0x17, 0xdd, 0x00, 0x7d, 0xe2, + 0x56, 0xc7, 0x00, 0x7d, 0xe3, 0x34, 0x0a, 0x00, + 0x7d, 0xe4, 0x17, 0xd9, 0x00, 0x7d, 0xe5, 0x4c, + 0xd7, 0x00, 0x7d, 0xe6, 0x47, 0xbb, 0x00, 0x7d, + 0xe8, 0x0e, 0x24, 0x00, 0x7d, 0xe9, 0x06, 0x07, + 0x00, 0x7d, 0xea, 0x56, 0xc8, 0x00, 0x7d, 0xeb, + 0x3a, 0x87, 0x00, 0x7d, 0xec, 0x0e, 0xd7, 0x00, + 0x7d, 0xed, 0x56, 0xc9, 0x00, 0x7d, 0xef, 0x04, + 0xa2, 0x00, 0x7d, 0xf1, 0x3a, 0x88, 0x00, 0x7d, + 0xf2, 0x17, 0xdc, 0x00, 0x7d, 0xf4, 0x34, 0x57, + 0x00, 0x7d, 0xf5, 0x4c, 0xd8, 0x00, 0x7d, 0xf6, + 0x4c, 0xd9, 0x00, 0x7d, 0xf9, 0x3a, 0x89, 0x00, + 0x7d, 0xfa, 0x56, 0xca, 0x00, 0x7d, 0xfb, 0x17, + 0xdb, 0x00, 0x7e, 0x00, 0x56, 0xc6, 0x00, 0x7e, + 0x01, 0x05, 0x11, 0x00, 0x7e, 0x04, 0x0c, 0xc4, + 0x00, 0x7e, 0x05, 0x17, 0xde, 0x00, 0x7e, 0x08, + 0x3a, 0x8a, 0x00, 0x7e, 0x09, 0x17, 0xe5, 0x00, + 0x7e, 0x0a, 0x17, 0xdf, 0x00, 0x7e, 0x0b, 0x17, + 0xe6, 0x00, 0x7e, 0x10, 0x47, 0xbf, 0x00, 0x7e, + 0x11, 0x3a, 0x8b, 0x00, 0x7e, 0x12, 0x17, 0xe2, + 0x00, 0x7e, 0x15, 0x3a, 0x8c, 0x00, 0x7e, 0x17, + 0x47, 0xc0, 0x00, 0x7e, 0x1b, 0x0d, 0x31, 0x00, + 0x7e, 0x1c, 0x56, 0xcb, 0x00, 0x7e, 0x1d, 0x47, + 0xc1, 0x00, 0x7e, 0x1e, 0x08, 0xf6, 0x00, 0x7e, + 0x1f, 0x17, 0xe4, 0x00, 0x7e, 0x20, 0x3a, 0x8d, + 0x00, 0x7e, 0x21, 0x17, 0xe1, 0x00, 0x7e, 0x22, + 0x17, 0xe7, 0x00, 0x7e, 0x23, 0x17, 0xe0, 0x00, + 0x7e, 0x26, 0x09, 0x4e, 0x00, 0x7e, 0x27, 0x47, + 0xc2, 0x00, 0x7e, 0x28, 0x42, 0x95, 0x00, 0x7e, + 0x2b, 0x0e, 0x53, 0x00, 0x7e, 0x2c, 0x47, 0xc3, + 0x00, 0x7e, 0x2d, 0x56, 0xcc, 0x00, 0x7e, 0x2e, + 0x09, 0x56, 0x00, 0x7e, 0x2f, 0x4c, 0xda, 0x00, + 0x7e, 0x31, 0x17, 0xe3, 0x00, 0x7e, 0x32, 0x17, + 0xef, 0x00, 0x7e, 0x33, 0x56, 0xcd, 0x00, 0x7e, + 0x35, 0x17, 0xeb, 0x00, 0x7e, 0x36, 0x4c, 0xdb, + 0x00, 0x7e, 0x37, 0x17, 0xee, 0x00, 0x7e, 0x39, + 0x17, 0xec, 0x00, 0x7e, 0x3a, 0x17, 0xf0, 0x00, + 0x7e, 0x3b, 0x17, 0xea, 0x00, 0x7e, 0x3d, 0x17, + 0xd0, 0x00, 0x7e, 0x3e, 0x0a, 0x77, 0x00, 0x7e, + 0x3f, 0x56, 0xce, 0x00, 0x7e, 0x41, 0x0d, 0x5f, + 0x00, 0x7e, 0x43, 0x17, 0xed, 0x00, 0x7e, 0x44, + 0x4c, 0xdc, 0x00, 0x7e, 0x45, 0x47, 0xc4, 0x00, + 0x7e, 0x46, 0x17, 0xe8, 0x00, 0x7e, 0x47, 0x3a, + 0x8e, 0x00, 0x7e, 0x48, 0x37, 0x67, 0x00, 0x7e, + 0x4a, 0x0a, 0xa3, 0x00, 0x7e, 0x4b, 0x07, 0x28, + 0x00, 0x7e, 0x4d, 0x09, 0x35, 0x00, 0x7e, 0x4e, + 0x56, 0xcf, 0x00, 0x7e, 0x50, 0x56, 0xd0, 0x00, + 0x7e, 0x52, 0x21, 0x94, 0x00, 0x7e, 0x54, 0x09, + 0xeb, 0x00, 0x7e, 0x55, 0x0a, 0xb8, 0x00, 0x7e, + 0x56, 0x17, 0xf3, 0x00, 0x7e, 0x58, 0x56, 0xd1, + 0x00, 0x7e, 0x59, 0x17, 0xf5, 0x00, 0x7e, 0x5a, + 0x17, 0xf6, 0x00, 0x7e, 0x5d, 0x17, 0xf2, 0x00, + 0x7e, 0x5e, 0x17, 0xf4, 0x00, 0x7e, 0x5f, 0x56, + 0xd2, 0x00, 0x7e, 0x61, 0x1e, 0x11, 0x00, 0x7e, + 0x62, 0x3a, 0x8f, 0x00, 0x7e, 0x65, 0x56, 0xd3, + 0x00, 0x7e, 0x66, 0x17, 0xe9, 0x00, 0x7e, 0x67, + 0x17, 0xf1, 0x00, 0x7e, 0x69, 0x17, 0xf9, 0x00, + 0x7e, 0x6a, 0x17, 0xf8, 0x00, 0x7e, 0x6b, 0x1d, + 0xf7, 0x00, 0x7e, 0x6d, 0x0e, 0xa8, 0x00, 0x7e, + 0x6e, 0x3a, 0x90, 0x00, 0x7e, 0x6f, 0x4c, 0xdd, + 0x00, 0x7e, 0x70, 0x07, 0x01, 0x00, 0x7e, 0x73, + 0x3a, 0x91, 0x00, 0x7e, 0x75, 0x47, 0xc5, 0x00, + 0x7e, 0x78, 0x4c, 0xde, 0x00, 0x7e, 0x79, 0x17, + 0xf7, 0x00, 0x7e, 0x7b, 0x17, 0xfb, 0x00, 0x7e, + 0x7c, 0x17, 0xfa, 0x00, 0x7e, 0x7d, 0x17, 0xfe, + 0x00, 0x7e, 0x7e, 0x47, 0xc6, 0x00, 0x7e, 0x7f, + 0x18, 0x00, 0x00, 0x7e, 0x81, 0x4c, 0xdf, 0x00, + 0x7e, 0x82, 0x08, 0x8a, 0x00, 0x7e, 0x83, 0x17, + 0xfc, 0x00, 0x7e, 0x86, 0x47, 0xc7, 0x00, 0x7e, + 0x87, 0x47, 0xc8, 0x00, 0x7e, 0x88, 0x18, 0x01, + 0x00, 0x7e, 0x89, 0x18, 0x02, 0x00, 0x7e, 0x8a, + 0x20, 0xa7, 0x00, 0x7e, 0x8c, 0x18, 0x03, 0x00, + 0x7e, 0x8d, 0x3a, 0x92, 0x00, 0x7e, 0x8e, 0x18, + 0x09, 0x00, 0x7e, 0x8f, 0x0c, 0x35, 0x00, 0x7e, + 0x90, 0x18, 0x05, 0x00, 0x7e, 0x91, 0x3a, 0x93, + 0x00, 0x7e, 0x92, 0x18, 0x04, 0x00, 0x7e, 0x93, + 0x18, 0x06, 0x00, 0x7e, 0x94, 0x18, 0x07, 0x00, + 0x7e, 0x95, 0x56, 0xd4, 0x00, 0x7e, 0x96, 0x18, + 0x08, 0x00, 0x7e, 0x98, 0x3a, 0x94, 0x00, 0x7e, + 0x9a, 0x47, 0xca, 0x00, 0x7e, 0x9b, 0x18, 0x0a, + 0x00, 0x7e, 0x9c, 0x18, 0x0b, 0x00, 0x7e, 0x9d, + 0x56, 0xd5, 0x00, 0x7e, 0x9e, 0x56, 0xd6, 0x00, + 0x7f, 0x36, 0x06, 0x08, 0x00, 0x7f, 0x38, 0x18, + 0x0c, 0x00, 0x7f, 0x3a, 0x18, 0x0d, 0x00, 0x7f, + 0x3b, 0x47, 0xcd, 0x00, 0x7f, 0x3c, 0x47, 0xcc, + 0x00, 0x7f, 0x3d, 0x4c, 0xe0, 0x00, 0x7f, 0x3e, + 0x47, 0xce, 0x00, 0x7f, 0x3f, 0x56, 0xd7, 0x00, + 0x7f, 0x43, 0x47, 0xcf, 0x00, 0x7f, 0x44, 0x3a, + 0x95, 0x00, 0x7f, 0x45, 0x18, 0x0e, 0x00, 0x7f, + 0x47, 0x21, 0x95, 0x00, 0x7f, 0x4c, 0x18, 0x0f, + 0x00, 0x7f, 0x4d, 0x18, 0x10, 0x00, 0x7f, 0x4e, + 0x18, 0x11, 0x00, 0x7f, 0x4f, 0x3a, 0x96, 0x00, + 0x7f, 0x50, 0x18, 0x12, 0x00, 0x7f, 0x51, 0x18, + 0x13, 0x00, 0x7f, 0x52, 0x3a, 0x97, 0x00, 0x7f, + 0x53, 0x3a, 0x98, 0x00, 0x7f, 0x54, 0x18, 0x15, + 0x00, 0x7f, 0x55, 0x18, 0x14, 0x00, 0x7f, 0x58, + 0x18, 0x16, 0x00, 0x7f, 0x5b, 0x4c, 0xe1, 0x00, + 0x7f, 0x5c, 0x56, 0xd8, 0x00, 0x7f, 0x5d, 0x4c, + 0xe2, 0x00, 0x7f, 0x5f, 0x18, 0x17, 0x00, 0x7f, + 0x60, 0x18, 0x18, 0x00, 0x7f, 0x61, 0x3a, 0x99, + 0x00, 0x7f, 0x63, 0x47, 0xd3, 0x00, 0x7f, 0x64, + 0x47, 0xd4, 0x00, 0x7f, 0x65, 0x4c, 0xe3, 0x00, + 0x7f, 0x66, 0x56, 0xd9, 0x00, 0x7f, 0x67, 0x18, + 0x1b, 0x00, 0x7f, 0x68, 0x18, 0x19, 0x00, 0x7f, + 0x69, 0x18, 0x1a, 0x00, 0x7f, 0x6a, 0x08, 0x51, + 0x00, 0x7f, 0x6b, 0x07, 0x29, 0x00, 0x7f, 0x6d, + 0x47, 0xd5, 0x00, 0x7f, 0x6e, 0x0b, 0x94, 0x00, + 0x7f, 0x70, 0x0d, 0x47, 0x00, 0x7f, 0x71, 0x4c, + 0xe4, 0x00, 0x7f, 0x72, 0x34, 0x29, 0x00, 0x7f, + 0x75, 0x0d, 0x03, 0x00, 0x7f, 0x77, 0x0d, 0x81, + 0x00, 0x7f, 0x78, 0x18, 0x1c, 0x00, 0x7f, 0x79, + 0x13, 0x36, 0x00, 0x7f, 0x7d, 0x47, 0xd6, 0x00, + 0x7f, 0x7e, 0x47, 0xd7, 0x00, 0x7f, 0x7f, 0x4c, + 0xe5, 0x00, 0x7f, 0x80, 0x4c, 0xe6, 0x00, 0x7f, + 0x82, 0x18, 0x1d, 0x00, 0x7f, 0x83, 0x18, 0x1f, + 0x00, 0x7f, 0x85, 0x0f, 0x4f, 0x00, 0x7f, 0x86, + 0x18, 0x1e, 0x00, 0x7f, 0x87, 0x18, 0x21, 0x00, + 0x7f, 0x88, 0x18, 0x20, 0x00, 0x7f, 0x8a, 0x36, + 0xfe, 0x00, 0x7f, 0x8b, 0x4c, 0xe7, 0x00, 0x7f, + 0x8c, 0x18, 0x22, 0x00, 0x7f, 0x8d, 0x56, 0xdb, + 0x00, 0x7f, 0x8e, 0x0d, 0x92, 0x00, 0x7f, 0x8f, + 0x56, 0xdc, 0x00, 0x7f, 0x90, 0x47, 0xd8, 0x00, + 0x7f, 0x91, 0x3a, 0x9a, 0x00, 0x7f, 0x94, 0x18, + 0x23, 0x00, 0x7f, 0x96, 0x47, 0xdb, 0x00, 0x7f, + 0x97, 0x42, 0x96, 0x00, 0x7f, 0x9a, 0x18, 0x26, + 0x00, 0x7f, 0x9c, 0x47, 0xdc, 0x00, 0x7f, 0x9d, + 0x18, 0x25, 0x00, 0x7f, 0x9e, 0x18, 0x24, 0x00, + 0x7f, 0xa1, 0x21, 0x96, 0x00, 0x7f, 0xa2, 0x4c, + 0xe8, 0x00, 0x7f, 0xa3, 0x18, 0x27, 0x00, 0x7f, + 0xa4, 0x07, 0x08, 0x00, 0x7f, 0xa6, 0x56, 0xdd, + 0x00, 0x7f, 0xa8, 0x0a, 0xa4, 0x00, 0x7f, 0xa9, + 0x06, 0x5b, 0x00, 0x7f, 0xaa, 0x56, 0xde, 0x00, + 0x7f, 0xad, 0x47, 0xdd, 0x00, 0x7f, 0xae, 0x18, + 0x2b, 0x00, 0x7f, 0xaf, 0x18, 0x28, 0x00, 0x7f, + 0xb2, 0x18, 0x29, 0x00, 0x7f, 0xb4, 0x56, 0xdf, + 0x00, 0x7f, 0xb6, 0x18, 0x2c, 0x00, 0x7f, 0xb8, + 0x18, 0x2d, 0x00, 0x7f, 0xb9, 0x18, 0x2a, 0x00, + 0x7f, 0xbc, 0x56, 0xe0, 0x00, 0x7f, 0xbd, 0x21, + 0x97, 0x00, 0x7f, 0xbf, 0x3a, 0x9b, 0x00, 0x7f, + 0xc0, 0x56, 0xe1, 0x00, 0x7f, 0xc1, 0x05, 0x27, + 0x00, 0x7f, 0xc3, 0x47, 0xdf, 0x00, 0x7f, 0xc5, + 0x18, 0x2f, 0x00, 0x7f, 0xc6, 0x18, 0x30, 0x00, + 0x7f, 0xc8, 0x56, 0xe2, 0x00, 0x7f, 0xca, 0x18, + 0x31, 0x00, 0x7f, 0xcc, 0x0f, 0x4c, 0x00, 0x7f, + 0xce, 0x3a, 0x9c, 0x00, 0x7f, 0xcf, 0x47, 0xe0, + 0x00, 0x7f, 0xd2, 0x09, 0x36, 0x00, 0x7f, 0xd4, + 0x18, 0x33, 0x00, 0x7f, 0xd5, 0x18, 0x32, 0x00, + 0x7f, 0xdb, 0x42, 0x97, 0x00, 0x7f, 0xdf, 0x3a, + 0x9d, 0x00, 0x7f, 0xe0, 0x0a, 0x2f, 0x00, 0x7f, + 0xe1, 0x18, 0x34, 0x00, 0x7f, 0xe3, 0x47, 0xe1, + 0x00, 0x7f, 0xe5, 0x3a, 0x9e, 0x00, 0x7f, 0xe6, + 0x18, 0x35, 0x00, 0x7f, 0xe8, 0x56, 0xe3, 0x00, + 0x7f, 0xe9, 0x18, 0x36, 0x00, 0x7f, 0xeb, 0x06, + 0x21, 0x00, 0x7f, 0xec, 0x3a, 0x9f, 0x00, 0x7f, + 0xee, 0x3a, 0xa0, 0x00, 0x7f, 0xef, 0x3a, 0xa1, + 0x00, 0x7f, 0xf0, 0x06, 0x09, 0x00, 0x7f, 0xf2, + 0x47, 0xe2, 0x00, 0x7f, 0xf3, 0x18, 0x37, 0x00, + 0x7f, 0xf9, 0x18, 0x38, 0x00, 0x7f, 0xfa, 0x3a, + 0xa2, 0x00, 0x7f, 0xfb, 0x0e, 0x8b, 0x00, 0x7f, + 0xfc, 0x0f, 0x4d, 0x00, 0x7f, 0xfd, 0x4c, 0xe9, + 0x00, 0x7f, 0xfe, 0x4c, 0xea, 0x00, 0x7f, 0xff, + 0x4c, 0xeb, 0x00, 0x80, 0x00, 0x0f, 0x3e, 0x00, + 0x80, 0x01, 0x0f, 0xdd, 0x00, 0x80, 0x02, 0x37, + 0x13, 0x00, 0x80, 0x03, 0x07, 0xdf, 0x00, 0x80, + 0x04, 0x18, 0x3b, 0x00, 0x80, 0x05, 0x09, 0x00, + 0x00, 0x80, 0x06, 0x18, 0x3a, 0x00, 0x80, 0x07, + 0x4c, 0xec, 0x00, 0x80, 0x08, 0x47, 0xe4, 0x00, + 0x80, 0x0a, 0x47, 0xe3, 0x00, 0x80, 0x0b, 0x18, + 0x3c, 0x00, 0x80, 0x0c, 0x08, 0xd5, 0x00, 0x80, + 0x0d, 0x4c, 0xed, 0x00, 0x80, 0x0e, 0x3a, 0xa3, + 0x00, 0x80, 0x0f, 0x56, 0xe4, 0x00, 0x80, 0x10, + 0x0b, 0x31, 0x00, 0x80, 0x11, 0x3a, 0xa4, 0x00, + 0x80, 0x12, 0x18, 0x3d, 0x00, 0x80, 0x13, 0x56, + 0xe5, 0x00, 0x80, 0x14, 0x3a, 0xa5, 0x00, 0x80, + 0x15, 0x07, 0xde, 0x00, 0x80, 0x16, 0x47, 0xe5, + 0x00, 0x80, 0x17, 0x0e, 0xe3, 0x00, 0x80, 0x18, + 0x18, 0x3e, 0x00, 0x80, 0x19, 0x18, 0x3f, 0x00, + 0x80, 0x1c, 0x18, 0x40, 0x00, 0x80, 0x1d, 0x56, + 0xe6, 0x00, 0x80, 0x1e, 0x4c, 0xee, 0x00, 0x80, + 0x1f, 0x56, 0xe7, 0x00, 0x80, 0x20, 0x56, 0xe8, + 0x00, 0x80, 0x21, 0x18, 0x41, 0x00, 0x80, 0x24, + 0x3a, 0xa6, 0x00, 0x80, 0x26, 0x3a, 0xa7, 0x00, + 0x80, 0x28, 0x18, 0x42, 0x00, 0x80, 0x2c, 0x47, + 0xe6, 0x00, 0x80, 0x2e, 0x56, 0xe9, 0x00, 0x80, + 0x30, 0x47, 0xe7, 0x00, 0x80, 0x33, 0x08, 0xd6, + 0x00, 0x80, 0x34, 0x56, 0xea, 0x00, 0x80, 0x35, + 0x42, 0x98, 0x00, 0x80, 0x36, 0x0e, 0xf9, 0x00, + 0x80, 0x37, 0x42, 0x99, 0x00, 0x80, 0x39, 0x4c, + 0xef, 0x00, 0x80, 0x3a, 0x3a, 0xa8, 0x00, 0x80, + 0x3b, 0x18, 0x44, 0x00, 0x80, 0x3c, 0x3a, 0xa9, + 0x00, 0x80, 0x3d, 0x0b, 0x7d, 0x00, 0x80, 0x3e, + 0x56, 0xeb, 0x00, 0x80, 0x3f, 0x18, 0x43, 0x00, + 0x80, 0x40, 0x56, 0xec, 0x00, 0x80, 0x43, 0x47, + 0xe8, 0x00, 0x80, 0x44, 0x56, 0xed, 0x00, 0x80, + 0x46, 0x18, 0x46, 0x00, 0x80, 0x4a, 0x18, 0x45, + 0x00, 0x80, 0x52, 0x18, 0x47, 0x00, 0x80, 0x56, + 0x0a, 0x5f, 0x00, 0x80, 0x58, 0x18, 0x48, 0x00, + 0x80, 0x5a, 0x18, 0x49, 0x00, 0x80, 0x5e, 0x0e, + 0x09, 0x00, 0x80, 0x5f, 0x18, 0x4a, 0x00, 0x80, + 0x60, 0x3a, 0xaa, 0x00, 0x80, 0x61, 0x0a, 0xf1, + 0x00, 0x80, 0x62, 0x18, 0x4b, 0x00, 0x80, 0x64, + 0x56, 0xee, 0x00, 0x80, 0x66, 0x47, 0xe9, 0x00, + 0x80, 0x68, 0x18, 0x4c, 0x00, 0x80, 0x6d, 0x56, + 0xef, 0x00, 0x80, 0x6f, 0x0f, 0xc6, 0x00, 0x80, + 0x70, 0x18, 0x4f, 0x00, 0x80, 0x71, 0x3a, 0xab, + 0x00, 0x80, 0x72, 0x18, 0x4e, 0x00, 0x80, 0x73, + 0x18, 0x4d, 0x00, 0x80, 0x74, 0x0b, 0xcc, 0x00, + 0x80, 0x75, 0x3a, 0xac, 0x00, 0x80, 0x76, 0x18, + 0x50, 0x00, 0x80, 0x77, 0x09, 0xec, 0x00, 0x80, + 0x79, 0x18, 0x51, 0x00, 0x80, 0x7b, 0x47, 0xea, + 0x00, 0x80, 0x7d, 0x18, 0x52, 0x00, 0x80, 0x7e, + 0x0f, 0xde, 0x00, 0x80, 0x7f, 0x18, 0x53, 0x00, + 0x80, 0x81, 0x56, 0xf0, 0x00, 0x80, 0x84, 0x18, + 0x54, 0x00, 0x80, 0x85, 0x18, 0x56, 0x00, 0x80, + 0x86, 0x18, 0x55, 0x00, 0x80, 0x87, 0x0d, 0x39, + 0x00, 0x80, 0x88, 0x4c, 0xf0, 0x00, 0x80, 0x89, + 0x0c, 0xd1, 0x00, 0x80, 0x8b, 0x0f, 0xe4, 0x00, + 0x80, 0x8c, 0x0d, 0x3d, 0x00, 0x80, 0x8e, 0x4c, + 0xf1, 0x00, 0x80, 0x93, 0x18, 0x58, 0x00, 0x80, + 0x96, 0x09, 0xbb, 0x00, 0x80, 0x98, 0x0d, 0x9c, + 0x00, 0x80, 0x99, 0x47, 0xeb, 0x00, 0x80, 0x9a, + 0x18, 0x59, 0x00, 0x80, 0x9b, 0x18, 0x57, 0x00, + 0x80, 0x9c, 0x47, 0xec, 0x00, 0x80, 0x9d, 0x06, + 0x0a, 0x00, 0x80, 0x9e, 0x3a, 0xad, 0x00, 0x80, + 0xa1, 0x07, 0x88, 0x00, 0x80, 0xa2, 0x08, 0xb6, + 0x00, 0x80, 0xa4, 0x47, 0xed, 0x00, 0x80, 0xa5, + 0x0d, 0x82, 0x00, 0x80, 0xa6, 0x3a, 0xae, 0x00, + 0x80, 0xa7, 0x47, 0xee, 0x00, 0x80, 0xa9, 0x07, + 0x5e, 0x00, 0x80, 0xaa, 0x0e, 0x71, 0x00, 0x80, + 0xab, 0x3a, 0xaf, 0x00, 0x80, 0xac, 0x18, 0x5c, + 0x00, 0x80, 0xad, 0x18, 0x5a, 0x00, 0x80, 0xaf, + 0x07, 0xe0, 0x00, 0x80, 0xb1, 0x07, 0xe1, 0x00, + 0x80, 0xb2, 0x04, 0xad, 0x00, 0x80, 0xb4, 0x08, + 0x58, 0x00, 0x80, 0xb8, 0x47, 0xef, 0x00, 0x80, + 0xb9, 0x56, 0xf1, 0x00, 0x80, 0xba, 0x0d, 0x0f, + 0x00, 0x80, 0xc3, 0x04, 0xa3, 0x00, 0x80, 0xc4, + 0x18, 0x61, 0x00, 0x80, 0xc5, 0x47, 0xf1, 0x00, + 0x80, 0xc6, 0x0b, 0x7e, 0x00, 0x80, 0xc8, 0x56, + 0xf2, 0x00, 0x80, 0xca, 0x42, 0x9a, 0x00, 0x80, + 0xcc, 0x0d, 0x0e, 0x00, 0x80, 0xcd, 0x56, 0xf3, + 0x00, 0x80, 0xce, 0x0b, 0x3b, 0x00, 0x80, 0xcf, + 0x4c, 0xf2, 0x00, 0x80, 0xd2, 0x56, 0xf4, 0x00, + 0x80, 0xd4, 0x4c, 0xf3, 0x00, 0x80, 0xd5, 0x47, + 0xf2, 0x00, 0x80, 0xd6, 0x18, 0x63, 0x00, 0x80, + 0xd7, 0x3a, 0xb0, 0x00, 0x80, 0xd8, 0x3a, 0xb1, + 0x00, 0x80, 0xd9, 0x18, 0x5f, 0x00, 0x80, 0xda, + 0x18, 0x62, 0x00, 0x80, 0xdb, 0x18, 0x5d, 0x00, + 0x80, 0xdd, 0x18, 0x60, 0x00, 0x80, 0xde, 0x0e, + 0x54, 0x00, 0x80, 0xe0, 0x42, 0x9b, 0x00, 0x80, + 0xe1, 0x07, 0x89, 0x00, 0x80, 0xe4, 0x04, 0xc1, + 0x00, 0x80, 0xe5, 0x18, 0x5e, 0x00, 0x80, 0xe6, + 0x47, 0xf3, 0x00, 0x80, 0xed, 0x4c, 0xf4, 0x00, + 0x80, 0xee, 0x56, 0xf5, 0x00, 0x80, 0xef, 0x18, + 0x65, 0x00, 0x80, 0xf0, 0x4c, 0xf5, 0x00, 0x80, + 0xf1, 0x18, 0x66, 0x00, 0x80, 0xf2, 0x56, 0xf6, + 0x00, 0x80, 0xf3, 0x42, 0x9c, 0x00, 0x80, 0xf4, + 0x0c, 0x91, 0x00, 0x80, 0xf5, 0x47, 0xf5, 0x00, + 0x80, 0xf6, 0x56, 0xf7, 0x00, 0x80, 0xf7, 0x4c, + 0xf6, 0x00, 0x80, 0xf8, 0x06, 0xb3, 0x00, 0x80, + 0xf9, 0x56, 0xf8, 0x00, 0x80, 0xfa, 0x4c, 0xf7, + 0x00, 0x80, 0xfb, 0x47, 0xf6, 0x00, 0x80, 0xfc, + 0x18, 0x71, 0x00, 0x80, 0xfd, 0x0c, 0xf3, 0x00, + 0x80, 0xfe, 0x4c, 0xf8, 0x00, 0x81, 0x02, 0x08, + 0xb7, 0x00, 0x81, 0x03, 0x4c, 0xf9, 0x00, 0x81, + 0x05, 0x06, 0xb4, 0x00, 0x81, 0x06, 0x0a, 0x6c, + 0x00, 0x81, 0x07, 0x0f, 0xec, 0x00, 0x81, 0x08, + 0x0e, 0xba, 0x00, 0x81, 0x09, 0x18, 0x64, 0x00, + 0x81, 0x0a, 0x0a, 0x78, 0x00, 0x81, 0x0b, 0x56, + 0xf9, 0x00, 0x81, 0x0d, 0x47, 0xf4, 0x00, 0x81, + 0x16, 0x3a, 0xb2, 0x00, 0x81, 0x17, 0x4c, 0xfa, + 0x00, 0x81, 0x18, 0x3a, 0xb3, 0x00, 0x81, 0x1a, + 0x06, 0x6d, 0x00, 0x81, 0x1b, 0x18, 0x67, 0x00, + 0x81, 0x1c, 0x56, 0xfa, 0x00, 0x81, 0x1e, 0x47, + 0xf9, 0x00, 0x81, 0x20, 0x56, 0xfb, 0x00, 0x81, + 0x23, 0x18, 0x69, 0x00, 0x81, 0x24, 0x47, 0xfb, + 0x00, 0x81, 0x27, 0x47, 0xfc, 0x00, 0x81, 0x29, + 0x18, 0x68, 0x00, 0x81, 0x2b, 0x36, 0x59, 0x00, + 0x81, 0x2c, 0x47, 0xfd, 0x00, 0x81, 0x2f, 0x18, + 0x6a, 0x00, 0x81, 0x30, 0x4c, 0xfb, 0x00, 0x81, + 0x31, 0x0b, 0x64, 0x00, 0x81, 0x33, 0x0c, 0xf4, + 0x00, 0x81, 0x35, 0x47, 0xf8, 0x00, 0x81, 0x39, + 0x0b, 0xcd, 0x00, 0x81, 0x3a, 0x3a, 0xb4, 0x00, + 0x81, 0x3c, 0x56, 0xfc, 0x00, 0x81, 0x3d, 0x47, + 0xff, 0x00, 0x81, 0x3e, 0x18, 0x6e, 0x00, 0x81, + 0x41, 0x37, 0x72, 0x00, 0x81, 0x45, 0x56, 0xfd, + 0x00, 0x81, 0x46, 0x18, 0x6d, 0x00, 0x81, 0x47, + 0x56, 0xfe, 0x00, 0x81, 0x4a, 0x3a, 0xb5, 0x00, + 0x81, 0x4b, 0x18, 0x6b, 0x00, 0x81, 0x4c, 0x3a, + 0xb6, 0x00, 0x81, 0x4e, 0x0a, 0x1b, 0x00, 0x81, + 0x50, 0x0d, 0xd7, 0x00, 0x81, 0x51, 0x18, 0x70, + 0x00, 0x81, 0x52, 0x56, 0xff, 0x00, 0x81, 0x53, + 0x18, 0x6f, 0x00, 0x81, 0x54, 0x07, 0xe2, 0x00, + 0x81, 0x55, 0x0f, 0xf9, 0x00, 0x81, 0x57, 0x4c, + 0xfc, 0x00, 0x81, 0x5f, 0x18, 0x80, 0x00, 0x81, + 0x60, 0x42, 0x9d, 0x00, 0x81, 0x61, 0x57, 0x00, + 0x00, 0x81, 0x65, 0x18, 0x74, 0x00, 0x81, 0x66, + 0x18, 0x75, 0x00, 0x81, 0x67, 0x42, 0x9e, 0x00, + 0x81, 0x68, 0x42, 0x9f, 0x00, 0x81, 0x69, 0x48, + 0x01, 0x00, 0x81, 0x6b, 0x09, 0x1c, 0x00, 0x81, + 0x6d, 0x42, 0xa0, 0x00, 0x81, 0x6e, 0x18, 0x73, + 0x00, 0x81, 0x6f, 0x4c, 0xfd, 0x00, 0x81, 0x70, + 0x08, 0x0a, 0x00, 0x81, 0x71, 0x18, 0x72, 0x00, + 0x81, 0x73, 0x4c, 0xfe, 0x00, 0x81, 0x74, 0x18, + 0x76, 0x00, 0x81, 0x77, 0x57, 0x01, 0x00, 0x81, + 0x78, 0x0b, 0xce, 0x00, 0x81, 0x79, 0x0d, 0xf2, + 0x00, 0x81, 0x7a, 0x0a, 0xa5, 0x00, 0x81, 0x7f, + 0x0b, 0x3c, 0x00, 0x81, 0x80, 0x18, 0x7a, 0x00, + 0x81, 0x81, 0x3a, 0xb7, 0x00, 0x81, 0x82, 0x18, + 0x7b, 0x00, 0x81, 0x83, 0x18, 0x77, 0x00, 0x81, + 0x84, 0x3a, 0xb8, 0x00, 0x81, 0x85, 0x48, 0x04, + 0x00, 0x81, 0x86, 0x57, 0x02, 0x00, 0x81, 0x88, + 0x18, 0x78, 0x00, 0x81, 0x8a, 0x18, 0x79, 0x00, + 0x81, 0x8b, 0x4c, 0xff, 0x00, 0x81, 0x8e, 0x57, + 0x03, 0x00, 0x81, 0x8f, 0x07, 0xe3, 0x00, 0x81, + 0x90, 0x4d, 0x00, 0x00, 0x81, 0x93, 0x18, 0x81, + 0x00, 0x81, 0x95, 0x18, 0x7d, 0x00, 0x81, 0x96, + 0x57, 0x04, 0x00, 0x81, 0x98, 0x48, 0x06, 0x00, + 0x81, 0x9a, 0x0d, 0xd8, 0x00, 0x81, 0x9b, 0x4d, + 0x01, 0x00, 0x81, 0x9c, 0x0e, 0x9a, 0x00, 0x81, + 0x9d, 0x0d, 0x9a, 0x00, 0x81, 0x9e, 0x4d, 0x02, + 0x00, 0x81, 0xa0, 0x18, 0x7c, 0x00, 0x81, 0xa2, + 0x57, 0x05, 0x00, 0x81, 0xa3, 0x18, 0x7f, 0x00, + 0x81, 0xa4, 0x18, 0x7e, 0x00, 0x81, 0xa8, 0x0e, + 0x72, 0x00, 0x81, 0xa9, 0x18, 0x82, 0x00, 0x81, + 0xae, 0x57, 0x06, 0x00, 0x81, 0xb0, 0x18, 0x83, + 0x00, 0x81, 0xb2, 0x48, 0x07, 0x00, 0x81, 0xb3, + 0x0a, 0xb9, 0x00, 0x81, 0xb4, 0x3a, 0xb9, 0x00, + 0x81, 0xb5, 0x18, 0x84, 0x00, 0x81, 0xb8, 0x18, + 0x86, 0x00, 0x81, 0xba, 0x18, 0x8a, 0x00, 0x81, + 0xbb, 0x42, 0xa1, 0x00, 0x81, 0xbd, 0x18, 0x87, + 0x00, 0x81, 0xbe, 0x18, 0x85, 0x00, 0x81, 0xbf, + 0x0c, 0xf5, 0x00, 0x81, 0xc0, 0x18, 0x88, 0x00, + 0x81, 0xc1, 0x48, 0x08, 0x00, 0x81, 0xc2, 0x18, + 0x89, 0x00, 0x81, 0xc3, 0x48, 0x09, 0x00, 0x81, + 0xc5, 0x57, 0x07, 0x00, 0x81, 0xc6, 0x05, 0x32, + 0x00, 0x81, 0xc8, 0x18, 0x90, 0x00, 0x81, 0xc9, + 0x18, 0x8b, 0x00, 0x81, 0xca, 0x42, 0xa2, 0x00, + 0x81, 0xcb, 0x4d, 0x03, 0x00, 0x81, 0xcd, 0x18, + 0x8c, 0x00, 0x81, 0xce, 0x57, 0x08, 0x00, 0x81, + 0xcf, 0x3a, 0xba, 0x00, 0x81, 0xd1, 0x18, 0x8d, + 0x00, 0x81, 0xd3, 0x0b, 0x01, 0x00, 0x81, 0xd5, + 0x4d, 0x04, 0x00, 0x81, 0xd6, 0x48, 0x0a, 0x00, + 0x81, 0xd7, 0x42, 0xa3, 0x00, 0x81, 0xd8, 0x18, + 0x8f, 0x00, 0x81, 0xd9, 0x18, 0x8e, 0x00, 0x81, + 0xda, 0x18, 0x91, 0x00, 0x81, 0xdb, 0x48, 0x0b, + 0x00, 0x81, 0xdd, 0x4d, 0x05, 0x00, 0x81, 0xde, + 0x4d, 0x06, 0x00, 0x81, 0xdf, 0x18, 0x92, 0x00, + 0x81, 0xe0, 0x18, 0x93, 0x00, 0x81, 0xe1, 0x4d, + 0x07, 0x00, 0x81, 0xe3, 0x0a, 0x09, 0x00, 0x81, + 0xe4, 0x48, 0x0d, 0x00, 0x81, 0xe5, 0x05, 0x69, + 0x00, 0x81, 0xe7, 0x18, 0x94, 0x00, 0x81, 0xe8, + 0x0f, 0x9f, 0x00, 0x81, 0xea, 0x08, 0xd7, 0x00, + 0x81, 0xeb, 0x57, 0x09, 0x00, 0x81, 0xec, 0x48, + 0x0f, 0x00, 0x81, 0xed, 0x09, 0x37, 0x00, 0x81, + 0xef, 0x4d, 0x08, 0x00, 0x81, 0xf0, 0x57, 0x0a, + 0x00, 0x81, 0xf1, 0x57, 0x0b, 0x00, 0x81, 0xf2, + 0x57, 0x0c, 0x00, 0x81, 0xf3, 0x08, 0xb8, 0x00, + 0x81, 0xf4, 0x0b, 0x95, 0x00, 0x81, 0xf5, 0x57, + 0x0d, 0x00, 0x81, 0xf6, 0x4d, 0x09, 0x00, 0x81, + 0xf8, 0x57, 0x0e, 0x00, 0x81, 0xf9, 0x3a, 0xbb, + 0x00, 0x81, 0xfa, 0x18, 0x95, 0x00, 0x81, 0xfb, + 0x18, 0x96, 0x00, 0x81, 0xfc, 0x04, 0xd3, 0x00, + 0x81, 0xfd, 0x48, 0x10, 0x00, 0x81, 0xfe, 0x18, + 0x97, 0x00, 0x81, 0xff, 0x48, 0x11, 0x00, 0x82, + 0x00, 0x4d, 0x0a, 0x00, 0x82, 0x01, 0x18, 0x98, + 0x00, 0x82, 0x02, 0x18, 0x99, 0x00, 0x82, 0x03, + 0x3a, 0xbc, 0x00, 0x82, 0x04, 0x48, 0x13, 0x00, + 0x82, 0x05, 0x18, 0x9a, 0x00, 0x82, 0x07, 0x18, + 0x9b, 0x00, 0x82, 0x08, 0x06, 0xb5, 0x00, 0x82, + 0x09, 0x13, 0xaf, 0x00, 0x82, 0x0a, 0x18, 0x9c, + 0x00, 0x82, 0x0b, 0x4d, 0x0b, 0x00, 0x82, 0x0c, + 0x0a, 0x89, 0x00, 0x82, 0x0d, 0x18, 0x9d, 0x00, + 0x82, 0x0e, 0x08, 0xf7, 0x00, 0x82, 0x0f, 0x57, + 0x10, 0x00, 0x82, 0x10, 0x18, 0x9e, 0x00, 0x82, + 0x12, 0x10, 0x09, 0x00, 0x82, 0x13, 0x4d, 0x0c, + 0x00, 0x82, 0x14, 0x4d, 0x0d, 0x00, 0x82, 0x16, + 0x18, 0x9f, 0x00, 0x82, 0x17, 0x0e, 0x2e, 0x00, + 0x82, 0x18, 0x06, 0x18, 0x00, 0x82, 0x19, 0x48, + 0x15, 0x00, 0x82, 0x1a, 0x4d, 0x0e, 0x00, 0x82, + 0x1b, 0x0a, 0xa6, 0x00, 0x82, 0x1c, 0x09, 0x62, + 0x00, 0x82, 0x1d, 0x57, 0x11, 0x00, 0x82, 0x1e, + 0x0d, 0xe3, 0x00, 0x82, 0x1f, 0x09, 0x38, 0x00, + 0x82, 0x21, 0x3a, 0xbd, 0x00, 0x82, 0x22, 0x48, + 0x16, 0x00, 0x82, 0x28, 0x57, 0x12, 0x00, 0x82, + 0x29, 0x18, 0xa0, 0x00, 0x82, 0x2a, 0x07, 0xe4, + 0x00, 0x82, 0x2b, 0x18, 0xa1, 0x00, 0x82, 0x2c, + 0x0d, 0x60, 0x00, 0x82, 0x2e, 0x18, 0xaf, 0x00, + 0x82, 0x32, 0x3a, 0xbe, 0x00, 0x82, 0x33, 0x18, + 0xa3, 0x00, 0x82, 0x34, 0x3a, 0xbf, 0x00, 0x82, + 0x35, 0x0b, 0x29, 0x00, 0x82, 0x36, 0x0d, 0x2b, + 0x00, 0x82, 0x37, 0x07, 0x73, 0x00, 0x82, 0x38, + 0x18, 0xa2, 0x00, 0x82, 0x39, 0x0a, 0xa7, 0x00, + 0x82, 0x3a, 0x4d, 0x0f, 0x00, 0x82, 0x3c, 0x48, + 0x18, 0x00, 0x82, 0x40, 0x18, 0xa4, 0x00, 0x82, + 0x43, 0x57, 0x13, 0x00, 0x82, 0x44, 0x4d, 0x10, + 0x00, 0x82, 0x45, 0x48, 0x1a, 0x00, 0x82, 0x46, + 0x3a, 0xc0, 0x00, 0x82, 0x47, 0x0c, 0x16, 0x00, + 0x82, 0x49, 0x48, 0x19, 0x00, 0x82, 0x4b, 0x3a, + 0xc1, 0x00, 0x82, 0x4e, 0x57, 0x14, 0x00, 0x82, + 0x4f, 0x3a, 0xc2, 0x00, 0x82, 0x51, 0x57, 0x15, + 0x00, 0x82, 0x56, 0x57, 0x16, 0x00, 0x82, 0x57, + 0x48, 0x1e, 0x00, 0x82, 0x58, 0x18, 0xa6, 0x00, + 0x82, 0x59, 0x18, 0xa5, 0x00, 0x82, 0x5a, 0x18, + 0xa8, 0x00, 0x82, 0x5c, 0x48, 0x20, 0x00, 0x82, + 0x5d, 0x18, 0xa7, 0x00, 0x82, 0x5f, 0x18, 0xa9, + 0x00, 0x82, 0x60, 0x42, 0xa5, 0x00, 0x82, 0x62, + 0x18, 0xab, 0x00, 0x82, 0x63, 0x48, 0x21, 0x00, + 0x82, 0x64, 0x18, 0xaa, 0x00, 0x82, 0x66, 0x06, + 0x0b, 0x00, 0x82, 0x67, 0x57, 0x17, 0x00, 0x82, + 0x68, 0x18, 0xac, 0x00, 0x82, 0x6a, 0x18, 0xad, + 0x00, 0x82, 0x6b, 0x18, 0xae, 0x00, 0x82, 0x6d, + 0x4d, 0x11, 0x00, 0x82, 0x6e, 0x08, 0x21, 0x00, + 0x82, 0x6f, 0x0f, 0x91, 0x00, 0x82, 0x71, 0x18, + 0xb0, 0x00, 0x82, 0x72, 0x09, 0xed, 0x00, 0x82, + 0x74, 0x42, 0xa6, 0x00, 0x82, 0x76, 0x05, 0x12, + 0x00, 0x82, 0x77, 0x18, 0xb1, 0x00, 0x82, 0x78, + 0x18, 0xb2, 0x00, 0x82, 0x79, 0x37, 0x75, 0x00, + 0x82, 0x7b, 0x57, 0x18, 0x00, 0x82, 0x7d, 0x48, + 0x24, 0x00, 0x82, 0x7e, 0x18, 0xb3, 0x00, 0x82, + 0x7f, 0x48, 0x25, 0x00, 0x82, 0x80, 0x57, 0x19, + 0x00, 0x82, 0x81, 0x57, 0x1a, 0x00, 0x82, 0x83, + 0x48, 0x26, 0x00, 0x82, 0x84, 0x4d, 0x12, 0x00, + 0x82, 0x87, 0x57, 0x1b, 0x00, 0x82, 0x89, 0x4d, + 0x13, 0x00, 0x82, 0x8a, 0x48, 0x27, 0x00, 0x82, + 0x8b, 0x04, 0xb6, 0x00, 0x82, 0x8d, 0x18, 0xb4, + 0x00, 0x82, 0x8e, 0x3a, 0xc3, 0x00, 0x82, 0x91, + 0x4d, 0x14, 0x00, 0x82, 0x92, 0x18, 0xb5, 0x00, + 0x82, 0x93, 0x48, 0x28, 0x00, 0x82, 0x94, 0x57, + 0x1c, 0x00, 0x82, 0x96, 0x57, 0x1d, 0x00, 0x82, + 0x98, 0x57, 0x1e, 0x00, 0x82, 0x99, 0x0d, 0xd9, + 0x00, 0x82, 0x9a, 0x57, 0x1f, 0x00, 0x82, 0x9b, + 0x57, 0x20, 0x00, 0x82, 0x9d, 0x08, 0xf3, 0x00, + 0x82, 0x9f, 0x18, 0xb7, 0x00, 0x82, 0xa0, 0x57, + 0x21, 0x00, 0x82, 0xa1, 0x42, 0xa8, 0x00, 0x82, + 0xa3, 0x42, 0xa9, 0x00, 0x82, 0xa4, 0x42, 0xaa, + 0x00, 0x82, 0xa5, 0x05, 0x87, 0x00, 0x82, 0xa6, + 0x04, 0x76, 0x00, 0x82, 0xa7, 0x48, 0x29, 0x00, + 0x82, 0xa8, 0x48, 0x2a, 0x00, 0x82, 0xa9, 0x42, + 0xab, 0x00, 0x82, 0xaa, 0x4d, 0x15, 0x00, 0x82, + 0xab, 0x18, 0xb6, 0x00, 0x82, 0xac, 0x18, 0xb9, + 0x00, 0x82, 0xad, 0x0d, 0x04, 0x00, 0x82, 0xae, + 0x3a, 0xc4, 0x00, 0x82, 0xaf, 0x0a, 0x0a, 0x00, + 0x82, 0xb0, 0x4d, 0x16, 0x00, 0x82, 0xb1, 0x05, + 0x56, 0x00, 0x82, 0xb2, 0x48, 0x2b, 0x00, 0x82, + 0xb3, 0x0e, 0x55, 0x00, 0x82, 0xb4, 0x48, 0x2c, + 0x00, 0x82, 0xb7, 0x3a, 0xc5, 0x00, 0x82, 0xb8, + 0x07, 0x33, 0x00, 0x82, 0xb9, 0x06, 0xd4, 0x00, + 0x82, 0xba, 0x48, 0x2d, 0x00, 0x82, 0xbb, 0x18, + 0xb8, 0x00, 0x82, 0xbc, 0x48, 0x2e, 0x00, 0x82, + 0xbd, 0x35, 0x66, 0x00, 0x82, 0xbe, 0x3a, 0xc6, + 0x00, 0x82, 0xbf, 0x42, 0xac, 0x00, 0x82, 0xc5, + 0x05, 0xdf, 0x00, 0x82, 0xc6, 0x3a, 0xc7, 0x00, + 0x82, 0xd0, 0x4d, 0x17, 0x00, 0x82, 0xd1, 0x05, + 0x13, 0x00, 0x82, 0xd2, 0x18, 0xbd, 0x00, 0x82, + 0xd3, 0x0f, 0xb2, 0x00, 0x82, 0xd4, 0x0b, 0x3d, + 0x00, 0x82, 0xd5, 0x42, 0xad, 0x00, 0x82, 0xd7, + 0x0d, 0xb6, 0x00, 0x82, 0xd9, 0x18, 0xc9, 0x00, + 0x82, 0xda, 0x57, 0x22, 0x00, 0x82, 0xdb, 0x05, + 0x57, 0x00, 0x82, 0xdc, 0x18, 0xc7, 0x00, 0x82, + 0xde, 0x18, 0xc5, 0x00, 0x82, 0xdf, 0x18, 0xbc, + 0x00, 0x82, 0xe0, 0x57, 0x23, 0x00, 0x82, 0xe1, + 0x18, 0xba, 0x00, 0x82, 0xe2, 0x48, 0x2f, 0x00, + 0x82, 0xe3, 0x18, 0xbb, 0x00, 0x82, 0xe4, 0x57, + 0x24, 0x00, 0x82, 0xe5, 0x09, 0x0f, 0x00, 0x82, + 0xe6, 0x06, 0xe4, 0x00, 0x82, 0xe7, 0x0b, 0xb5, + 0x00, 0x82, 0xe8, 0x48, 0x30, 0x00, 0x82, 0xea, + 0x4d, 0x18, 0x00, 0x82, 0xeb, 0x0c, 0xa9, 0x00, + 0x82, 0xed, 0x57, 0x25, 0x00, 0x82, 0xef, 0x4d, + 0x19, 0x00, 0x82, 0xf1, 0x04, 0xf3, 0x00, 0x82, + 0xf3, 0x18, 0xbf, 0x00, 0x82, 0xf4, 0x18, 0xbe, + 0x00, 0x82, 0xf6, 0x4d, 0x1a, 0x00, 0x82, 0xf7, + 0x48, 0x31, 0x00, 0x82, 0xf9, 0x18, 0xc4, 0x00, + 0x82, 0xfa, 0x18, 0xc0, 0x00, 0x82, 0xfb, 0x18, + 0xc3, 0x00, 0x82, 0xfd, 0x42, 0xae, 0x00, 0x82, + 0xfe, 0x3a, 0xc8, 0x00, 0x83, 0x00, 0x42, 0xaf, + 0x00, 0x83, 0x01, 0x21, 0x98, 0x00, 0x83, 0x02, + 0x0e, 0xdc, 0x00, 0x83, 0x03, 0x18, 0xc2, 0x00, + 0x83, 0x04, 0x05, 0x58, 0x00, 0x83, 0x05, 0x05, + 0xdb, 0x00, 0x83, 0x06, 0x18, 0xc6, 0x00, 0x83, + 0x07, 0x48, 0x32, 0x00, 0x83, 0x08, 0x48, 0x33, + 0x00, 0x83, 0x09, 0x18, 0xc8, 0x00, 0x83, 0x0a, + 0x57, 0x26, 0x00, 0x83, 0x0b, 0x57, 0x27, 0x00, + 0x83, 0x0c, 0x48, 0x34, 0x00, 0x83, 0x0e, 0x07, + 0x2a, 0x00, 0x83, 0x16, 0x18, 0xcc, 0x00, 0x83, + 0x17, 0x18, 0xd5, 0x00, 0x83, 0x18, 0x18, 0xd6, + 0x00, 0x83, 0x1b, 0x48, 0x36, 0x00, 0x83, 0x1c, + 0x04, 0x6f, 0x00, 0x83, 0x1d, 0x48, 0x37, 0x00, + 0x83, 0x1e, 0x57, 0x28, 0x00, 0x83, 0x1f, 0x57, + 0x29, 0x00, 0x83, 0x21, 0x57, 0x2a, 0x00, 0x83, + 0x22, 0x42, 0xb0, 0x00, 0x83, 0x23, 0x18, 0xdd, + 0x00, 0x83, 0x28, 0x04, 0xb5, 0x00, 0x83, 0x2b, + 0x18, 0xd4, 0x00, 0x83, 0x2c, 0x57, 0x2b, 0x00, + 0x83, 0x2d, 0x42, 0xb1, 0x00, 0x83, 0x2e, 0x57, + 0x2c, 0x00, 0x83, 0x2f, 0x18, 0xd3, 0x00, 0x83, + 0x30, 0x48, 0x38, 0x00, 0x83, 0x31, 0x18, 0xce, + 0x00, 0x83, 0x32, 0x18, 0xcd, 0x00, 0x83, 0x33, + 0x57, 0x2d, 0x00, 0x83, 0x34, 0x18, 0xcb, 0x00, + 0x83, 0x35, 0x18, 0xca, 0x00, 0x83, 0x36, 0x0b, + 0xa1, 0x00, 0x83, 0x37, 0x57, 0x2e, 0x00, 0x83, + 0x38, 0x0b, 0x5b, 0x00, 0x83, 0x39, 0x18, 0xd0, + 0x00, 0x83, 0x3a, 0x42, 0xb2, 0x00, 0x83, 0x3c, + 0x48, 0x39, 0x00, 0x83, 0x3d, 0x57, 0x2f, 0x00, + 0x83, 0x40, 0x18, 0xcf, 0x00, 0x83, 0x42, 0x57, + 0x30, 0x00, 0x83, 0x43, 0x3a, 0xc9, 0x00, 0x83, + 0x44, 0x48, 0x3a, 0x00, 0x83, 0x45, 0x18, 0xd2, + 0x00, 0x83, 0x46, 0x1d, 0xf8, 0x00, 0x83, 0x47, + 0x42, 0xb3, 0x00, 0x83, 0x49, 0x0a, 0xf2, 0x00, + 0x83, 0x4a, 0x07, 0x2b, 0x00, 0x83, 0x4d, 0x57, + 0x31, 0x00, 0x83, 0x4e, 0x57, 0x32, 0x00, 0x83, + 0x4f, 0x04, 0xe3, 0x00, 0x83, 0x50, 0x18, 0xd1, + 0x00, 0x83, 0x51, 0x3a, 0xca, 0x00, 0x83, 0x52, + 0x07, 0xe5, 0x00, 0x83, 0x53, 0x57, 0x3c, 0x00, + 0x83, 0x54, 0x48, 0x35, 0x00, 0x83, 0x55, 0x3a, + 0xcb, 0x00, 0x83, 0x56, 0x4d, 0x1b, 0x00, 0x83, + 0x57, 0x48, 0x3b, 0x00, 0x83, 0x58, 0x0a, 0xf3, + 0x00, 0x83, 0x5a, 0x37, 0x7a, 0x00, 0x83, 0x62, + 0x21, 0x99, 0x00, 0x83, 0x63, 0x45, 0x6f, 0x00, + 0x83, 0x70, 0x57, 0x33, 0x00, 0x83, 0x73, 0x18, + 0xe3, 0x00, 0x83, 0x75, 0x18, 0xe4, 0x00, 0x83, + 0x77, 0x05, 0x59, 0x00, 0x83, 0x78, 0x4d, 0x1c, + 0x00, 0x83, 0x7b, 0x05, 0x2e, 0x00, 0x83, 0x7c, + 0x18, 0xe1, 0x00, 0x83, 0x7d, 0x42, 0xb4, 0x00, + 0x83, 0x7f, 0x21, 0x9a, 0x00, 0x83, 0x80, 0x57, + 0x34, 0x00, 0x83, 0x82, 0x57, 0x35, 0x00, 0x83, + 0x84, 0x57, 0x36, 0x00, 0x83, 0x85, 0x18, 0xd7, + 0x00, 0x83, 0x86, 0x3a, 0xcc, 0x00, 0x83, 0x87, + 0x18, 0xdf, 0x00, 0x83, 0x89, 0x18, 0xe6, 0x00, + 0x83, 0x8a, 0x18, 0xe0, 0x00, 0x83, 0x8d, 0x3a, + 0xcd, 0x00, 0x83, 0x8e, 0x18, 0xde, 0x00, 0x83, + 0x92, 0x3a, 0xce, 0x00, 0x83, 0x93, 0x18, 0xc1, + 0x00, 0x83, 0x94, 0x48, 0x3f, 0x00, 0x83, 0x95, + 0x48, 0x40, 0x00, 0x83, 0x96, 0x18, 0xdc, 0x00, + 0x83, 0x98, 0x3a, 0xcf, 0x00, 0x83, 0x99, 0x57, + 0x37, 0x00, 0x83, 0x9a, 0x18, 0xd8, 0x00, 0x83, + 0x9b, 0x48, 0x41, 0x00, 0x83, 0x9c, 0x57, 0x38, + 0x00, 0x83, 0x9d, 0x48, 0x42, 0x00, 0x83, 0x9e, + 0x06, 0x0c, 0x00, 0x83, 0x9f, 0x18, 0xda, 0x00, + 0x83, 0xa0, 0x18, 0xe5, 0x00, 0x83, 0xa2, 0x18, + 0xdb, 0x00, 0x83, 0xa6, 0x57, 0x39, 0x00, 0x83, + 0xa7, 0x42, 0xb5, 0x00, 0x83, 0xa8, 0x18, 0xe7, + 0x00, 0x83, 0xa9, 0x3a, 0xd0, 0x00, 0x83, 0xaa, + 0x18, 0xd9, 0x00, 0x83, 0xab, 0x0d, 0x32, 0x00, + 0x83, 0xac, 0x57, 0x3a, 0x00, 0x83, 0xad, 0x57, + 0x3f, 0x00, 0x83, 0xb1, 0x0f, 0x53, 0x00, 0x83, + 0xb5, 0x18, 0xe2, 0x00, 0x83, 0xbd, 0x18, 0xf8, + 0x00, 0x83, 0xbe, 0x57, 0x3b, 0x00, 0x83, 0xbf, + 0x3a, 0xd1, 0x00, 0x83, 0xc0, 0x3a, 0xd2, 0x00, + 0x83, 0xc1, 0x18, 0xf0, 0x00, 0x83, 0xc5, 0x0a, + 0x41, 0x00, 0x83, 0xc7, 0x21, 0x9b, 0x00, 0x83, + 0xc9, 0x48, 0x43, 0x00, 0x83, 0xca, 0x06, 0x60, + 0x00, 0x83, 0xcc, 0x06, 0xd5, 0x00, 0x83, 0xce, + 0x18, 0xeb, 0x00, 0x83, 0xcf, 0x42, 0xb6, 0x00, + 0x83, 0xd0, 0x48, 0x44, 0x00, 0x83, 0xd1, 0x42, + 0xb7, 0x00, 0x83, 0xd3, 0x05, 0x5b, 0x00, 0x83, + 0xd4, 0x48, 0x45, 0x00, 0x83, 0xd6, 0x09, 0xbc, + 0x00, 0x83, 0xd8, 0x18, 0xee, 0x00, 0x83, 0xdc, + 0x08, 0x4a, 0x00, 0x83, 0xdd, 0x48, 0x46, 0x00, + 0x83, 0xdf, 0x0c, 0x4b, 0x00, 0x83, 0xe0, 0x18, + 0xf3, 0x00, 0x83, 0xe1, 0x42, 0xb8, 0x00, 0x83, + 0xe5, 0x48, 0x47, 0x00, 0x83, 0xe8, 0x57, 0x3d, + 0x00, 0x83, 0xe9, 0x0e, 0x3e, 0x00, 0x83, 0xea, + 0x3a, 0xd3, 0x00, 0x83, 0xeb, 0x18, 0xea, 0x00, + 0x83, 0xef, 0x05, 0x5a, 0x00, 0x83, 0xf0, 0x07, + 0x8a, 0x00, 0x83, 0xf1, 0x0d, 0x9b, 0x00, 0x83, + 0xf2, 0x18, 0xf4, 0x00, 0x83, 0xf4, 0x18, 0xe8, + 0x00, 0x83, 0xf6, 0x21, 0x9c, 0x00, 0x83, 0xf7, + 0x18, 0xf1, 0x00, 0x83, 0xf8, 0x4d, 0x1d, 0x00, + 0x83, 0xf9, 0x48, 0x48, 0x00, 0x83, 0xfb, 0x18, + 0xfb, 0x00, 0x83, 0xfc, 0x4d, 0x1e, 0x00, 0x83, + 0xfd, 0x18, 0xec, 0x00, 0x84, 0x01, 0x42, 0xb9, + 0x00, 0x84, 0x03, 0x18, 0xed, 0x00, 0x84, 0x04, + 0x0c, 0x92, 0x00, 0x84, 0x06, 0x42, 0xba, 0x00, + 0x84, 0x07, 0x18, 0xf2, 0x00, 0x84, 0x0a, 0x1e, + 0x7f, 0x00, 0x84, 0x0b, 0x18, 0xef, 0x00, 0x84, + 0x0c, 0x0e, 0x56, 0x00, 0x84, 0x0d, 0x18, 0xf5, + 0x00, 0x84, 0x0e, 0x04, 0xa4, 0x00, 0x84, 0x0f, + 0x3a, 0xd4, 0x00, 0x84, 0x11, 0x3a, 0xd5, 0x00, + 0x84, 0x13, 0x18, 0xe9, 0x00, 0x84, 0x15, 0x48, + 0x49, 0x00, 0x84, 0x17, 0x48, 0x4b, 0x00, 0x84, + 0x19, 0x57, 0x3e, 0x00, 0x84, 0x20, 0x18, 0xf7, + 0x00, 0x84, 0x22, 0x18, 0xf6, 0x00, 0x84, 0x29, + 0x0d, 0x21, 0x00, 0x84, 0x2a, 0x18, 0xfd, 0x00, + 0x84, 0x2c, 0x19, 0x08, 0x00, 0x84, 0x2f, 0x57, + 0x40, 0x00, 0x84, 0x31, 0x05, 0xdc, 0x00, 0x84, + 0x35, 0x19, 0x0b, 0x00, 0x84, 0x38, 0x18, 0xf9, + 0x00, 0x84, 0x39, 0x48, 0x4c, 0x00, 0x84, 0x3c, + 0x18, 0xfe, 0x00, 0x84, 0x3d, 0x0f, 0x58, 0x00, + 0x84, 0x45, 0x57, 0x41, 0x00, 0x84, 0x46, 0x19, + 0x07, 0x00, 0x84, 0x47, 0x57, 0x42, 0x00, 0x84, + 0x48, 0x21, 0x9d, 0x00, 0x84, 0x49, 0x0f, 0x3f, + 0x00, 0x84, 0x4a, 0x3a, 0xd6, 0x00, 0x84, 0x4d, + 0x57, 0x43, 0x00, 0x84, 0x4e, 0x0f, 0x72, 0x00, + 0x84, 0x4f, 0x48, 0x4d, 0x00, 0x84, 0x51, 0x48, + 0x4e, 0x00, 0x84, 0x52, 0x48, 0x4f, 0x00, 0x84, + 0x56, 0x57, 0x44, 0x00, 0x84, 0x57, 0x0b, 0xb6, + 0x00, 0x84, 0x58, 0x4d, 0x1f, 0x00, 0x84, 0x59, + 0x48, 0x50, 0x00, 0x84, 0x5a, 0x48, 0x51, 0x00, + 0x84, 0x5b, 0x05, 0xc9, 0x00, 0x84, 0x5c, 0x48, + 0x52, 0x00, 0x84, 0x5f, 0x42, 0xbb, 0x00, 0x84, + 0x60, 0x57, 0x46, 0x00, 0x84, 0x61, 0x0d, 0xe4, + 0x00, 0x84, 0x62, 0x19, 0x0d, 0x00, 0x84, 0x63, + 0x0c, 0x79, 0x00, 0x84, 0x64, 0x57, 0x47, 0x00, + 0x84, 0x65, 0x48, 0x54, 0x00, 0x84, 0x66, 0x04, + 0x75, 0x00, 0x84, 0x67, 0x57, 0x48, 0x00, 0x84, + 0x69, 0x19, 0x06, 0x00, 0x84, 0x6a, 0x57, 0x49, + 0x00, 0x84, 0x6b, 0x19, 0x02, 0x00, 0x84, 0x6c, + 0x0a, 0xf4, 0x00, 0x84, 0x6d, 0x18, 0xfc, 0x00, + 0x84, 0x6e, 0x19, 0x04, 0x00, 0x84, 0x6f, 0x19, + 0x09, 0x00, 0x84, 0x70, 0x42, 0xbc, 0x00, 0x84, + 0x71, 0x0c, 0xe2, 0x00, 0x84, 0x73, 0x42, 0xbd, + 0x00, 0x84, 0x74, 0x57, 0x4a, 0x00, 0x84, 0x75, + 0x04, 0x6e, 0x00, 0x84, 0x76, 0x3a, 0xd7, 0x00, + 0x84, 0x77, 0x19, 0x01, 0x00, 0x84, 0x78, 0x48, + 0x55, 0x00, 0x84, 0x79, 0x19, 0x0a, 0x00, 0x84, + 0x7a, 0x0d, 0xea, 0x00, 0x84, 0x7c, 0x48, 0x56, + 0x00, 0x84, 0x7d, 0x57, 0x4b, 0x00, 0x84, 0x81, + 0x48, 0x57, 0x00, 0x84, 0x82, 0x19, 0x05, 0x00, + 0x84, 0x84, 0x19, 0x00, 0x00, 0x84, 0x85, 0x42, + 0xbe, 0x00, 0x84, 0x8b, 0x09, 0xbd, 0x00, 0x84, + 0x90, 0x09, 0x39, 0x00, 0x84, 0x92, 0x57, 0x4c, + 0x00, 0x84, 0x93, 0x4d, 0x20, 0x00, 0x84, 0x94, + 0x08, 0xd8, 0x00, 0x84, 0x95, 0x57, 0x4d, 0x00, + 0x84, 0x97, 0x48, 0x59, 0x00, 0x84, 0x99, 0x0e, + 0xe4, 0x00, 0x84, 0x9c, 0x0d, 0xb9, 0x00, 0x84, + 0x9e, 0x42, 0xbf, 0x00, 0x84, 0x9f, 0x19, 0x10, + 0x00, 0x84, 0xa1, 0x19, 0x19, 0x00, 0x84, 0xa6, + 0x48, 0x5a, 0x00, 0x84, 0xa8, 0x3a, 0xd8, 0x00, + 0x84, 0xa9, 0x57, 0x4e, 0x00, 0x84, 0xaa, 0x57, + 0x4f, 0x00, 0x84, 0xad, 0x19, 0x03, 0x00, 0x84, + 0xaf, 0x3a, 0xd9, 0x00, 0x84, 0xb1, 0x4d, 0x21, + 0x00, 0x84, 0xb2, 0x05, 0xd5, 0x00, 0x84, 0xb4, + 0x21, 0x9e, 0x00, 0x84, 0xb8, 0x09, 0xe0, 0x00, + 0x84, 0xb9, 0x19, 0x0e, 0x00, 0x84, 0xba, 0x42, + 0xc0, 0x00, 0x84, 0xbb, 0x19, 0x13, 0x00, 0x84, + 0xbc, 0x0a, 0xf5, 0x00, 0x84, 0xbd, 0x4d, 0x22, + 0x00, 0x84, 0xbe, 0x48, 0x5b, 0x00, 0x84, 0xbf, + 0x19, 0x0f, 0x00, 0x84, 0xc0, 0x3a, 0xda, 0x00, + 0x84, 0xc1, 0x19, 0x16, 0x00, 0x84, 0xc2, 0x3a, + 0xdb, 0x00, 0x84, 0xc4, 0x0b, 0x9d, 0x00, 0x84, + 0xc6, 0x19, 0x17, 0x00, 0x84, 0xc7, 0x57, 0x50, + 0x00, 0x84, 0xc8, 0x57, 0x51, 0x00, 0x84, 0xc9, + 0x0f, 0x40, 0x00, 0x84, 0xca, 0x19, 0x0c, 0x00, + 0x84, 0xcb, 0x05, 0x96, 0x00, 0x84, 0xcc, 0x57, + 0x52, 0x00, 0x84, 0xcd, 0x19, 0x12, 0x00, 0x84, + 0xce, 0x48, 0x5d, 0x00, 0x84, 0xcf, 0x48, 0x5e, + 0x00, 0x84, 0xd0, 0x19, 0x15, 0x00, 0x84, 0xd1, + 0x0e, 0xb8, 0x00, 0x84, 0xd3, 0x48, 0x5f, 0x00, + 0x84, 0xd6, 0x19, 0x18, 0x00, 0x84, 0xd9, 0x19, + 0x11, 0x00, 0x84, 0xda, 0x19, 0x14, 0x00, 0x84, + 0xdc, 0x20, 0xab, 0x00, 0x84, 0xe7, 0x48, 0x61, + 0x00, 0x84, 0xea, 0x48, 0x62, 0x00, 0x84, 0xec, + 0x0e, 0x57, 0x00, 0x84, 0xee, 0x1e, 0x83, 0x00, + 0x84, 0xef, 0x48, 0x63, 0x00, 0x84, 0xf0, 0x3a, + 0xdc, 0x00, 0x84, 0xf1, 0x48, 0x64, 0x00, 0x84, + 0xf2, 0x57, 0x53, 0x00, 0x84, 0xf4, 0x19, 0x1c, + 0x00, 0x84, 0xf7, 0x57, 0x54, 0x00, 0x84, 0xfa, + 0x48, 0x65, 0x00, 0x84, 0xfb, 0x4d, 0x23, 0x00, + 0x84, 0xfc, 0x19, 0x23, 0x00, 0x84, 0xfd, 0x3a, + 0xdd, 0x00, 0x84, 0xff, 0x19, 0x1b, 0x00, 0x85, + 0x00, 0x08, 0xef, 0x00, 0x85, 0x02, 0x57, 0x55, + 0x00, 0x85, 0x03, 0x57, 0x56, 0x00, 0x85, 0x06, + 0x18, 0xfa, 0x00, 0x85, 0x07, 0x57, 0x57, 0x00, + 0x85, 0x0c, 0x3a, 0xde, 0x00, 0x85, 0x0e, 0x57, + 0x58, 0x00, 0x85, 0x10, 0x57, 0x59, 0x00, 0x85, + 0x11, 0x0e, 0x1e, 0x00, 0x85, 0x13, 0x0e, 0xae, + 0x00, 0x85, 0x14, 0x19, 0x22, 0x00, 0x85, 0x15, + 0x19, 0x21, 0x00, 0x85, 0x17, 0x19, 0x1d, 0x00, + 0x85, 0x18, 0x19, 0x1e, 0x00, 0x85, 0x1a, 0x04, + 0xd8, 0x00, 0x85, 0x1b, 0x48, 0x66, 0x00, 0x85, + 0x1c, 0x57, 0x5a, 0x00, 0x85, 0x1e, 0x42, 0xc3, + 0x00, 0x85, 0x1f, 0x19, 0x20, 0x00, 0x85, 0x21, + 0x19, 0x1a, 0x00, 0x85, 0x22, 0x57, 0x5b, 0x00, + 0x85, 0x23, 0x1e, 0x1a, 0x00, 0x85, 0x24, 0x48, + 0x67, 0x00, 0x85, 0x25, 0x48, 0x68, 0x00, 0x85, + 0x26, 0x0b, 0xf1, 0x00, 0x85, 0x27, 0x57, 0x5c, + 0x00, 0x85, 0x2a, 0x57, 0x5d, 0x00, 0x85, 0x2b, + 0x48, 0x69, 0x00, 0x85, 0x2c, 0x19, 0x1f, 0x00, + 0x85, 0x2d, 0x04, 0xc2, 0x00, 0x85, 0x2f, 0x42, + 0xc4, 0x00, 0x85, 0x32, 0x42, 0xc2, 0x00, 0x85, + 0x33, 0x57, 0x5e, 0x00, 0x85, 0x34, 0x3a, 0xdf, + 0x00, 0x85, 0x35, 0x0b, 0x02, 0x00, 0x85, 0x36, + 0x57, 0x5f, 0x00, 0x85, 0x3d, 0x0e, 0x13, 0x00, + 0x85, 0x3e, 0x1e, 0xb5, 0x00, 0x85, 0x3f, 0x57, + 0x60, 0x00, 0x85, 0x40, 0x19, 0x24, 0x00, 0x85, + 0x41, 0x19, 0x28, 0x00, 0x85, 0x43, 0x0d, 0x6d, + 0x00, 0x85, 0x46, 0x4d, 0x24, 0x00, 0x85, 0x48, + 0x19, 0x27, 0x00, 0x85, 0x49, 0x09, 0xbe, 0x00, + 0x85, 0x4a, 0x08, 0xf5, 0x00, 0x85, 0x4b, 0x19, + 0x2a, 0x00, 0x85, 0x4e, 0x06, 0xb6, 0x00, 0x85, + 0x4f, 0x48, 0x6a, 0x00, 0x85, 0x50, 0x57, 0x61, + 0x00, 0x85, 0x51, 0x48, 0x6d, 0x00, 0x85, 0x52, + 0x57, 0x62, 0x00, 0x85, 0x53, 0x21, 0x9f, 0x00, + 0x85, 0x55, 0x19, 0x2b, 0x00, 0x85, 0x56, 0x4d, + 0x25, 0x00, 0x85, 0x57, 0x0d, 0xeb, 0x00, 0x85, + 0x58, 0x19, 0x26, 0x00, 0x85, 0x59, 0x21, 0xa0, + 0x00, 0x85, 0x5a, 0x18, 0xff, 0x00, 0x85, 0x5c, + 0x57, 0x63, 0x00, 0x85, 0x5d, 0x4d, 0x26, 0x00, + 0x85, 0x5e, 0x3a, 0xe0, 0x00, 0x85, 0x5f, 0x57, + 0x65, 0x00, 0x85, 0x60, 0x57, 0x66, 0x00, 0x85, + 0x61, 0x48, 0x6e, 0x00, 0x85, 0x62, 0x48, 0x6f, + 0x00, 0x85, 0x63, 0x19, 0x25, 0x00, 0x85, 0x64, + 0x42, 0xc5, 0x00, 0x85, 0x68, 0x0f, 0xf5, 0x00, + 0x85, 0x69, 0x0c, 0x7a, 0x00, 0x85, 0x6a, 0x0d, + 0xe5, 0x00, 0x85, 0x6b, 0x21, 0xa1, 0x00, 0x85, + 0x6d, 0x19, 0x32, 0x00, 0x85, 0x6f, 0x48, 0x6b, + 0x00, 0x85, 0x77, 0x19, 0x38, 0x00, 0x85, 0x79, + 0x57, 0x67, 0x00, 0x85, 0x7a, 0x42, 0xc6, 0x00, + 0x85, 0x7b, 0x48, 0x71, 0x00, 0x85, 0x7d, 0x48, + 0x72, 0x00, 0x85, 0x7e, 0x19, 0x39, 0x00, 0x85, + 0x7f, 0x48, 0x73, 0x00, 0x85, 0x80, 0x19, 0x2c, + 0x00, 0x85, 0x81, 0x48, 0x74, 0x00, 0x85, 0x84, + 0x0d, 0x2c, 0x00, 0x85, 0x85, 0x4d, 0x27, 0x00, + 0x85, 0x86, 0x48, 0x75, 0x00, 0x85, 0x87, 0x19, + 0x36, 0x00, 0x85, 0x88, 0x19, 0x2e, 0x00, 0x85, + 0x89, 0x57, 0x68, 0x00, 0x85, 0x8a, 0x19, 0x30, + 0x00, 0x85, 0x8b, 0x57, 0x69, 0x00, 0x85, 0x8c, + 0x42, 0xc7, 0x00, 0x85, 0x8f, 0x3a, 0xe1, 0x00, + 0x85, 0x90, 0x19, 0x3a, 0x00, 0x85, 0x91, 0x19, + 0x2f, 0x00, 0x85, 0x93, 0x48, 0x76, 0x00, 0x85, + 0x94, 0x19, 0x33, 0x00, 0x85, 0x97, 0x05, 0x14, + 0x00, 0x85, 0x98, 0x4d, 0x28, 0x00, 0x85, 0x99, + 0x0c, 0xbd, 0x00, 0x85, 0x9b, 0x19, 0x34, 0x00, + 0x85, 0x9c, 0x19, 0x37, 0x00, 0x85, 0x9d, 0x48, + 0x77, 0x00, 0x85, 0x9f, 0x48, 0x78, 0x00, 0x85, + 0xa0, 0x57, 0x6a, 0x00, 0x85, 0xa2, 0x42, 0xc8, + 0x00, 0x85, 0xa4, 0x19, 0x2d, 0x00, 0x85, 0xa5, + 0x57, 0x6b, 0x00, 0x85, 0xa6, 0x0a, 0xa8, 0x00, + 0x85, 0xa7, 0x57, 0x6c, 0x00, 0x85, 0xa8, 0x19, + 0x31, 0x00, 0x85, 0xa9, 0x08, 0x75, 0x00, 0x85, + 0xaa, 0x0a, 0x0b, 0x00, 0x85, 0xab, 0x07, 0x06, + 0x00, 0x85, 0xac, 0x0f, 0x00, 0x00, 0x85, 0xad, + 0x3a, 0xe4, 0x00, 0x85, 0xae, 0x0f, 0x05, 0x00, + 0x85, 0xaf, 0x09, 0x7c, 0x00, 0x85, 0xb0, 0x21, + 0xa3, 0x00, 0x85, 0xb4, 0x57, 0x6d, 0x00, 0x85, + 0xb6, 0x57, 0x6e, 0x00, 0x85, 0xb7, 0x3a, 0xe2, + 0x00, 0x85, 0xb8, 0x57, 0x6f, 0x00, 0x85, 0xb9, + 0x19, 0x3e, 0x00, 0x85, 0xba, 0x19, 0x3c, 0x00, + 0x85, 0xbc, 0x48, 0x7c, 0x00, 0x85, 0xbd, 0x57, + 0x70, 0x00, 0x85, 0xbe, 0x57, 0x71, 0x00, 0x85, + 0xbf, 0x57, 0x72, 0x00, 0x85, 0xc1, 0x0f, 0xf4, + 0x00, 0x85, 0xc2, 0x57, 0x73, 0x00, 0x85, 0xc7, + 0x48, 0x7d, 0x00, 0x85, 0xc9, 0x19, 0x3b, 0x00, + 0x85, 0xca, 0x48, 0x7e, 0x00, 0x85, 0xcb, 0x42, + 0xc9, 0x00, 0x85, 0xcd, 0x0f, 0x5f, 0x00, 0x85, + 0xce, 0x3a, 0xe3, 0x00, 0x85, 0xcf, 0x19, 0x3d, + 0x00, 0x85, 0xd0, 0x19, 0x3f, 0x00, 0x85, 0xd5, + 0x19, 0x40, 0x00, 0x85, 0xd8, 0x48, 0x7f, 0x00, + 0x85, 0xd9, 0x48, 0x80, 0x00, 0x85, 0xda, 0x57, + 0x74, 0x00, 0x85, 0xdc, 0x19, 0x43, 0x00, 0x85, + 0xdd, 0x19, 0x41, 0x00, 0x85, 0xdf, 0x48, 0x81, + 0x00, 0x85, 0xe0, 0x57, 0x75, 0x00, 0x85, 0xe1, + 0x48, 0x82, 0x00, 0x85, 0xe4, 0x0c, 0x7b, 0x00, + 0x85, 0xe5, 0x19, 0x42, 0x00, 0x85, 0xe6, 0x48, + 0x83, 0x00, 0x85, 0xe8, 0x57, 0x76, 0x00, 0x85, + 0xe9, 0x0d, 0x61, 0x00, 0x85, 0xea, 0x19, 0x35, + 0x00, 0x85, 0xed, 0x42, 0xca, 0x00, 0x85, 0xf3, + 0x57, 0x77, 0x00, 0x85, 0xf4, 0x37, 0x80, 0x00, + 0x85, 0xf6, 0x48, 0x84, 0x00, 0x85, 0xf7, 0x09, + 0x7d, 0x00, 0x85, 0xf9, 0x19, 0x44, 0x00, 0x85, + 0xfa, 0x19, 0x49, 0x00, 0x85, 0xfb, 0x0a, 0xf6, + 0x00, 0x85, 0xfc, 0x57, 0x78, 0x00, 0x85, 0xfe, + 0x19, 0x48, 0x00, 0x85, 0xff, 0x42, 0xcb, 0x00, + 0x86, 0x00, 0x48, 0x85, 0x00, 0x86, 0x02, 0x19, + 0x29, 0x00, 0x86, 0x04, 0x42, 0xcc, 0x00, 0x86, + 0x05, 0x42, 0xcd, 0x00, 0x86, 0x06, 0x19, 0x4a, + 0x00, 0x86, 0x07, 0x0a, 0xcb, 0x00, 0x86, 0x0a, + 0x19, 0x45, 0x00, 0x86, 0x0b, 0x19, 0x47, 0x00, + 0x86, 0x0d, 0x57, 0x79, 0x00, 0x86, 0x0e, 0x57, + 0x7a, 0x00, 0x86, 0x10, 0x42, 0xce, 0x00, 0x86, + 0x11, 0x48, 0x86, 0x00, 0x86, 0x12, 0x3a, 0xe5, + 0x00, 0x86, 0x13, 0x19, 0x46, 0x00, 0x86, 0x16, + 0x14, 0xd0, 0x00, 0x86, 0x17, 0x14, 0xc1, 0x00, + 0x86, 0x18, 0x42, 0xd0, 0x00, 0x86, 0x19, 0x57, + 0x7b, 0x00, 0x86, 0x1a, 0x19, 0x4c, 0x00, 0x86, + 0x1b, 0x57, 0x7c, 0x00, 0x86, 0x1e, 0x48, 0x87, + 0x00, 0x86, 0x21, 0x48, 0x88, 0x00, 0x86, 0x22, + 0x19, 0x4b, 0x00, 0x86, 0x24, 0x48, 0x89, 0x00, + 0x86, 0x27, 0x48, 0x8a, 0x00, 0x86, 0x29, 0x3a, + 0xe6, 0x00, 0x86, 0x2d, 0x0f, 0x60, 0x00, 0x86, + 0x2f, 0x16, 0xb1, 0x00, 0x86, 0x30, 0x19, 0x4d, + 0x00, 0x86, 0x36, 0x57, 0x7d, 0x00, 0x86, 0x38, + 0x42, 0xd1, 0x00, 0x86, 0x39, 0x48, 0x8c, 0x00, + 0x86, 0x3a, 0x57, 0x7e, 0x00, 0x86, 0x3c, 0x48, + 0x8d, 0x00, 0x86, 0x3d, 0x57, 0x7f, 0x00, 0x86, + 0x3f, 0x19, 0x4e, 0x00, 0x86, 0x40, 0x48, 0x8f, + 0x00, 0x86, 0x41, 0x41, 0xb8, 0x00, 0x86, 0x42, + 0x4d, 0x29, 0x00, 0x86, 0x46, 0x4d, 0x2a, 0x00, + 0x86, 0x4d, 0x19, 0x4f, 0x00, 0x86, 0x4e, 0x07, + 0x8b, 0x00, 0x86, 0x50, 0x06, 0x6e, 0x00, 0x86, + 0x52, 0x3a, 0xe7, 0x00, 0x86, 0x53, 0x48, 0x90, + 0x00, 0x86, 0x54, 0x19, 0x51, 0x00, 0x86, 0x55, + 0x10, 0x94, 0x00, 0x86, 0x56, 0x48, 0x91, 0x00, + 0x86, 0x57, 0x42, 0xd2, 0x00, 0x86, 0x58, 0x57, + 0x80, 0x00, 0x86, 0x59, 0x57, 0x81, 0x00, 0x86, + 0x5a, 0x06, 0x8f, 0x00, 0x86, 0x5b, 0x34, 0x18, + 0x00, 0x86, 0x5c, 0x34, 0x52, 0x00, 0x86, 0x5d, + 0x57, 0x82, 0x00, 0x86, 0x5e, 0x06, 0xeb, 0x00, + 0x86, 0x5f, 0x19, 0x52, 0x00, 0x86, 0x60, 0x57, + 0x83, 0x00, 0x86, 0x61, 0x57, 0x84, 0x00, 0x86, + 0x62, 0x42, 0xd3, 0x00, 0x86, 0x63, 0x3a, 0xe8, + 0x00, 0x86, 0x64, 0x57, 0x85, 0x00, 0x86, 0x67, + 0x19, 0x53, 0x00, 0x86, 0x69, 0x57, 0x86, 0x00, + 0x86, 0x6b, 0x0b, 0xac, 0x00, 0x86, 0x6c, 0x3a, + 0xe9, 0x00, 0x86, 0x6f, 0x3a, 0xea, 0x00, 0x86, + 0x71, 0x19, 0x54, 0x00, 0x86, 0x75, 0x42, 0xd5, + 0x00, 0x86, 0x76, 0x57, 0x87, 0x00, 0x86, 0x77, + 0x48, 0x92, 0x00, 0x86, 0x79, 0x0c, 0xd2, 0x00, + 0x86, 0x7a, 0x3a, 0xeb, 0x00, 0x86, 0x7b, 0x04, + 0x7e, 0x00, 0x86, 0x7d, 0x37, 0x86, 0x00, 0x86, + 0x87, 0x48, 0x93, 0x00, 0x86, 0x88, 0x57, 0x99, + 0x00, 0x86, 0x89, 0x48, 0x94, 0x00, 0x86, 0x8a, + 0x05, 0x63, 0x00, 0x86, 0x8b, 0x19, 0x59, 0x00, + 0x86, 0x8c, 0x19, 0x5a, 0x00, 0x86, 0x8d, 0x3a, + 0xec, 0x00, 0x86, 0x91, 0x3a, 0xed, 0x00, 0x86, + 0x93, 0x19, 0x55, 0x00, 0x86, 0x95, 0x08, 0x8b, + 0x00, 0x86, 0x96, 0x57, 0x88, 0x00, 0x86, 0x98, + 0x3a, 0xee, 0x00, 0x86, 0x9a, 0x57, 0x89, 0x00, + 0x86, 0x9c, 0x48, 0x95, 0x00, 0x86, 0x9d, 0x48, + 0x96, 0x00, 0x86, 0xa1, 0x57, 0x8a, 0x00, 0x86, + 0xa3, 0x19, 0x56, 0x00, 0x86, 0xa4, 0x0c, 0xf8, + 0x00, 0x86, 0xa6, 0x57, 0x8b, 0x00, 0x86, 0xa7, + 0x3a, 0xef, 0x00, 0x86, 0xa8, 0x3a, 0xf0, 0x00, + 0x86, 0xa9, 0x19, 0x57, 0x00, 0x86, 0xaa, 0x19, + 0x58, 0x00, 0x86, 0xab, 0x19, 0x62, 0x00, 0x86, + 0xad, 0x57, 0x8c, 0x00, 0x86, 0xaf, 0x19, 0x5c, + 0x00, 0x86, 0xb0, 0x19, 0x5f, 0x00, 0x86, 0xb1, + 0x48, 0x97, 0x00, 0x86, 0xb3, 0x48, 0x98, 0x00, + 0x86, 0xb4, 0x57, 0x8d, 0x00, 0x86, 0xb5, 0x57, + 0x8e, 0x00, 0x86, 0xb6, 0x19, 0x5b, 0x00, 0x86, + 0xb7, 0x57, 0x8f, 0x00, 0x86, 0xb8, 0x42, 0xd6, + 0x00, 0x86, 0xb9, 0x57, 0x90, 0x00, 0x86, 0xbf, + 0x57, 0x91, 0x00, 0x86, 0xc0, 0x4d, 0x2b, 0x00, + 0x86, 0xc1, 0x48, 0x99, 0x00, 0x86, 0xc3, 0x48, + 0x9a, 0x00, 0x86, 0xc4, 0x19, 0x5d, 0x00, 0x86, + 0xc5, 0x57, 0x92, 0x00, 0x86, 0xc6, 0x19, 0x5e, + 0x00, 0x86, 0xc7, 0x09, 0x04, 0x00, 0x86, 0xc9, + 0x19, 0x60, 0x00, 0x86, 0xcb, 0x0b, 0x7f, 0x00, + 0x86, 0xcd, 0x07, 0x2c, 0x00, 0x86, 0xce, 0x05, + 0xa0, 0x00, 0x86, 0xd1, 0x48, 0x9b, 0x00, 0x86, + 0xd2, 0x57, 0x93, 0x00, 0x86, 0xd4, 0x19, 0x63, + 0x00, 0x86, 0xd5, 0x48, 0x9c, 0x00, 0x86, 0xd7, + 0x48, 0x9d, 0x00, 0x86, 0xd9, 0x05, 0x9d, 0x00, + 0x86, 0xda, 0x57, 0x94, 0x00, 0x86, 0xdb, 0x19, + 0x68, 0x00, 0x86, 0xdc, 0x57, 0x95, 0x00, 0x86, + 0xde, 0x19, 0x64, 0x00, 0x86, 0xdf, 0x19, 0x67, + 0x00, 0x86, 0xe0, 0x57, 0x96, 0x00, 0x86, 0xe3, + 0x48, 0x9e, 0x00, 0x86, 0xe4, 0x0d, 0x4e, 0x00, + 0x86, 0xe5, 0x57, 0x97, 0x00, 0x86, 0xe6, 0x48, + 0x9f, 0x00, 0x86, 0xe7, 0x57, 0x98, 0x00, 0x86, + 0xe9, 0x19, 0x65, 0x00, 0x86, 0xec, 0x19, 0x66, + 0x00, 0x86, 0xed, 0x0d, 0xba, 0x00, 0x86, 0xee, + 0x0d, 0x6e, 0x00, 0x86, 0xef, 0x19, 0x69, 0x00, + 0x86, 0xf8, 0x0b, 0x5d, 0x00, 0x86, 0xf9, 0x19, + 0x73, 0x00, 0x86, 0xfa, 0x3a, 0xf1, 0x00, 0x86, + 0xfb, 0x19, 0x6f, 0x00, 0x86, 0xfc, 0x42, 0xd7, + 0x00, 0x86, 0xfd, 0x3a, 0xf2, 0x00, 0x86, 0xfe, + 0x05, 0x6b, 0x00, 0x87, 0x00, 0x19, 0x6d, 0x00, + 0x87, 0x02, 0x0e, 0x58, 0x00, 0x87, 0x03, 0x19, + 0x6e, 0x00, 0x87, 0x04, 0x57, 0x9a, 0x00, 0x87, + 0x05, 0x48, 0xa1, 0x00, 0x87, 0x06, 0x19, 0x6b, + 0x00, 0x87, 0x07, 0x48, 0xa2, 0x00, 0x87, 0x08, + 0x19, 0x6c, 0x00, 0x87, 0x09, 0x19, 0x71, 0x00, + 0x87, 0x0a, 0x19, 0x74, 0x00, 0x87, 0x0b, 0x3a, + 0xf3, 0x00, 0x87, 0x0d, 0x19, 0x72, 0x00, 0x87, + 0x0e, 0x48, 0xa3, 0x00, 0x87, 0x0f, 0x57, 0x9b, + 0x00, 0x87, 0x10, 0x48, 0xa4, 0x00, 0x87, 0x11, + 0x19, 0x70, 0x00, 0x87, 0x12, 0x19, 0x6a, 0x00, + 0x87, 0x13, 0x3a, 0xf4, 0x00, 0x87, 0x14, 0x4d, + 0x2c, 0x00, 0x87, 0x18, 0x0b, 0x96, 0x00, 0x87, + 0x19, 0x3a, 0xf5, 0x00, 0x87, 0x1a, 0x19, 0x7b, + 0x00, 0x87, 0x1c, 0x0e, 0xb6, 0x00, 0x87, 0x1e, + 0x3a, 0xf6, 0x00, 0x87, 0x1f, 0x48, 0xa5, 0x00, + 0x87, 0x21, 0x48, 0xa6, 0x00, 0x87, 0x22, 0x4d, + 0x2d, 0x00, 0x87, 0x23, 0x48, 0xa7, 0x00, 0x87, + 0x25, 0x19, 0x79, 0x00, 0x87, 0x28, 0x3a, 0xf7, + 0x00, 0x87, 0x29, 0x19, 0x7a, 0x00, 0x87, 0x2e, + 0x4d, 0x2e, 0x00, 0x87, 0x2f, 0x57, 0x9c, 0x00, + 0x87, 0x31, 0x48, 0xa8, 0x00, 0x87, 0x32, 0x57, + 0x9d, 0x00, 0x87, 0x34, 0x19, 0x75, 0x00, 0x87, + 0x37, 0x19, 0x77, 0x00, 0x87, 0x39, 0x4d, 0x2f, + 0x00, 0x87, 0x3a, 0x48, 0xa9, 0x00, 0x87, 0x3b, + 0x19, 0x78, 0x00, 0x87, 0x3c, 0x57, 0x9e, 0x00, + 0x87, 0x3d, 0x57, 0x9f, 0x00, 0x87, 0x3e, 0x3a, + 0xf8, 0x00, 0x87, 0x3f, 0x19, 0x76, 0x00, 0x87, + 0x40, 0x48, 0xaa, 0x00, 0x87, 0x43, 0x48, 0xab, + 0x00, 0x87, 0x45, 0x57, 0xa0, 0x00, 0x87, 0x49, + 0x0a, 0x8a, 0x00, 0x87, 0x4b, 0x0f, 0xdf, 0x00, + 0x87, 0x4c, 0x19, 0x7f, 0x00, 0x87, 0x4d, 0x57, + 0xa1, 0x00, 0x87, 0x4e, 0x19, 0x80, 0x00, 0x87, + 0x51, 0x48, 0xac, 0x00, 0x87, 0x53, 0x19, 0x86, + 0x00, 0x87, 0x55, 0x09, 0xf0, 0x00, 0x87, 0x57, + 0x19, 0x82, 0x00, 0x87, 0x58, 0x48, 0xad, 0x00, + 0x87, 0x59, 0x19, 0x85, 0x00, 0x87, 0x5d, 0x4d, + 0x30, 0x00, 0x87, 0x5f, 0x19, 0x7d, 0x00, 0x87, + 0x60, 0x19, 0x7c, 0x00, 0x87, 0x61, 0x57, 0xa2, + 0x00, 0x87, 0x63, 0x19, 0x87, 0x00, 0x87, 0x64, + 0x48, 0xae, 0x00, 0x87, 0x65, 0x48, 0xaf, 0x00, + 0x87, 0x66, 0x05, 0x5c, 0x00, 0x87, 0x68, 0x19, + 0x83, 0x00, 0x87, 0x6a, 0x19, 0x88, 0x00, 0x87, + 0x6e, 0x19, 0x84, 0x00, 0x87, 0x6f, 0x57, 0xa3, + 0x00, 0x87, 0x71, 0x3a, 0xf9, 0x00, 0x87, 0x72, + 0x48, 0xb0, 0x00, 0x87, 0x74, 0x19, 0x81, 0x00, + 0x87, 0x76, 0x0b, 0xcf, 0x00, 0x87, 0x78, 0x19, + 0x7e, 0x00, 0x87, 0x7b, 0x4d, 0x31, 0x00, 0x87, + 0x7c, 0x48, 0xb1, 0x00, 0x87, 0x7f, 0x0d, 0x1e, + 0x00, 0x87, 0x82, 0x19, 0x8c, 0x00, 0x87, 0x83, + 0x57, 0xa4, 0x00, 0x87, 0x84, 0x57, 0xa5, 0x00, + 0x87, 0x85, 0x57, 0xa6, 0x00, 0x87, 0x86, 0x57, + 0xa7, 0x00, 0x87, 0x87, 0x42, 0xd8, 0x00, 0x87, + 0x88, 0x3a, 0xfa, 0x00, 0x87, 0x89, 0x48, 0xb5, + 0x00, 0x87, 0x8b, 0x48, 0xb6, 0x00, 0x87, 0x8c, + 0x4d, 0x32, 0x00, 0x87, 0x8d, 0x0f, 0x25, 0x00, + 0x87, 0x8e, 0x4d, 0x33, 0x00, 0x87, 0x90, 0x57, + 0xa8, 0x00, 0x87, 0x93, 0x48, 0xb7, 0x00, 0x87, + 0x95, 0x57, 0xa9, 0x00, 0x87, 0x97, 0x4d, 0x34, + 0x00, 0x87, 0x98, 0x4d, 0x35, 0x00, 0x87, 0x99, + 0x3a, 0xfb, 0x00, 0x87, 0x9e, 0x4d, 0x36, 0x00, + 0x87, 0x9f, 0x19, 0x8b, 0x00, 0x87, 0xa0, 0x48, + 0xb8, 0x00, 0x87, 0xa2, 0x19, 0x8a, 0x00, 0x87, + 0xa3, 0x4d, 0x37, 0x00, 0x87, 0xa7, 0x48, 0xb4, + 0x00, 0x87, 0xab, 0x19, 0x93, 0x00, 0x87, 0xac, + 0x3a, 0xfc, 0x00, 0x87, 0xad, 0x3a, 0xfd, 0x00, + 0x87, 0xae, 0x4d, 0x38, 0x00, 0x87, 0xaf, 0x19, + 0x8d, 0x00, 0x87, 0xb1, 0x57, 0xab, 0x00, 0x87, + 0xb3, 0x19, 0x95, 0x00, 0x87, 0xb5, 0x3a, 0xfe, + 0x00, 0x87, 0xba, 0x0f, 0x50, 0x00, 0x87, 0xbb, + 0x19, 0x98, 0x00, 0x87, 0xbd, 0x19, 0x8f, 0x00, + 0x87, 0xbe, 0x48, 0xbb, 0x00, 0x87, 0xbf, 0x4d, + 0x39, 0x00, 0x87, 0xc0, 0x19, 0x90, 0x00, 0x87, + 0xc1, 0x48, 0xbd, 0x00, 0x87, 0xc4, 0x19, 0x94, + 0x00, 0x87, 0xc6, 0x19, 0x97, 0x00, 0x87, 0xc7, + 0x19, 0x96, 0x00, 0x87, 0xc8, 0x57, 0xac, 0x00, + 0x87, 0xc9, 0x4d, 0x3a, 0x00, 0x87, 0xca, 0x57, + 0xad, 0x00, 0x87, 0xcb, 0x19, 0x8e, 0x00, 0x87, + 0xce, 0x48, 0xbe, 0x00, 0x87, 0xd0, 0x19, 0x91, + 0x00, 0x87, 0xd2, 0x19, 0xa2, 0x00, 0x87, 0xd5, + 0x57, 0xae, 0x00, 0x87, 0xd6, 0x3a, 0xff, 0x00, + 0x87, 0xd9, 0x57, 0xaf, 0x00, 0x87, 0xda, 0x4d, + 0x3b, 0x00, 0x87, 0xdc, 0x57, 0xb0, 0x00, 0x87, + 0xdf, 0x48, 0xbf, 0x00, 0x87, 0xe0, 0x19, 0x9b, + 0x00, 0x87, 0xe2, 0x57, 0xb1, 0x00, 0x87, 0xe3, + 0x48, 0xc1, 0x00, 0x87, 0xe4, 0x57, 0xb2, 0x00, + 0x87, 0xe5, 0x48, 0xc2, 0x00, 0x87, 0xe6, 0x48, + 0xc3, 0x00, 0x87, 0xea, 0x48, 0xc4, 0x00, 0x87, + 0xeb, 0x3b, 0x00, 0x00, 0x87, 0xec, 0x1e, 0x23, + 0x00, 0x87, 0xed, 0x3b, 0x01, 0x00, 0x87, 0xef, + 0x19, 0x99, 0x00, 0x87, 0xf1, 0x57, 0xb3, 0x00, + 0x87, 0xf2, 0x19, 0x9a, 0x00, 0x87, 0xf3, 0x57, + 0xb4, 0x00, 0x87, 0xf5, 0x3c, 0x3d, 0x00, 0x87, + 0xf6, 0x19, 0x9f, 0x00, 0x87, 0xf7, 0x19, 0xa0, + 0x00, 0x87, 0xf8, 0x57, 0xb5, 0x00, 0x87, 0xf9, + 0x05, 0x88, 0x00, 0x87, 0xfa, 0x57, 0xb6, 0x00, + 0x87, 0xfb, 0x06, 0x5c, 0x00, 0x87, 0xfe, 0x19, + 0x9e, 0x00, 0x87, 0xff, 0x57, 0xb7, 0x00, 0x88, + 0x01, 0x3b, 0x02, 0x00, 0x88, 0x03, 0x4f, 0x58, + 0x00, 0x88, 0x05, 0x19, 0x89, 0x00, 0x88, 0x06, + 0x3b, 0x04, 0x00, 0x88, 0x07, 0x21, 0xa6, 0x00, + 0x88, 0x09, 0x57, 0xb8, 0x00, 0x88, 0x0a, 0x42, + 0xda, 0x00, 0x88, 0x0b, 0x3b, 0x05, 0x00, 0x88, + 0x0d, 0x19, 0x9d, 0x00, 0x88, 0x0e, 0x19, 0xa1, + 0x00, 0x88, 0x0f, 0x19, 0x9c, 0x00, 0x88, 0x10, + 0x42, 0xdb, 0x00, 0x88, 0x11, 0x19, 0xa3, 0x00, + 0x88, 0x12, 0x57, 0xba, 0x00, 0x88, 0x13, 0x48, + 0xc5, 0x00, 0x88, 0x14, 0x3b, 0x06, 0x00, 0x88, + 0x15, 0x19, 0xa5, 0x00, 0x88, 0x16, 0x19, 0xa4, + 0x00, 0x88, 0x18, 0x4d, 0x3c, 0x00, 0x88, 0x19, + 0x57, 0xb9, 0x00, 0x88, 0x1a, 0x57, 0xbb, 0x00, + 0x88, 0x1b, 0x4d, 0x3d, 0x00, 0x88, 0x1c, 0x3b, + 0x07, 0x00, 0x88, 0x1e, 0x57, 0xbc, 0x00, 0x88, + 0x1f, 0x1e, 0x85, 0x00, 0x88, 0x21, 0x19, 0xa7, + 0x00, 0x88, 0x22, 0x19, 0xa6, 0x00, 0x88, 0x23, + 0x19, 0x61, 0x00, 0x88, 0x27, 0x19, 0xab, 0x00, + 0x88, 0x28, 0x48, 0xc6, 0x00, 0x88, 0x2d, 0x4d, + 0x3e, 0x00, 0x88, 0x2e, 0x48, 0xc7, 0x00, 0x88, + 0x30, 0x57, 0xbd, 0x00, 0x88, 0x31, 0x19, 0xa8, + 0x00, 0x88, 0x32, 0x48, 0xc8, 0x00, 0x88, 0x35, + 0x57, 0xbe, 0x00, 0x88, 0x36, 0x19, 0xa9, 0x00, + 0x88, 0x39, 0x19, 0xaa, 0x00, 0x88, 0x3a, 0x4d, + 0x3f, 0x00, 0x88, 0x3b, 0x19, 0xac, 0x00, 0x88, + 0x3c, 0x48, 0xc9, 0x00, 0x88, 0x40, 0x07, 0x42, + 0x00, 0x88, 0x41, 0x57, 0xbf, 0x00, 0x88, 0x42, + 0x19, 0xae, 0x00, 0x88, 0x43, 0x57, 0xc0, 0x00, + 0x88, 0x44, 0x19, 0xad, 0x00, 0x88, 0x45, 0x4d, + 0x40, 0x00, 0x88, 0x46, 0x09, 0x3a, 0x00, 0x88, + 0x48, 0x57, 0xc1, 0x00, 0x88, 0x49, 0x57, 0xc2, + 0x00, 0x88, 0x4a, 0x48, 0xcb, 0x00, 0x88, 0x4b, + 0x4d, 0x41, 0x00, 0x88, 0x4c, 0x07, 0xe6, 0x00, + 0x88, 0x4d, 0x15, 0x24, 0x00, 0x88, 0x4e, 0x4d, + 0x42, 0x00, 0x88, 0x51, 0x57, 0xc4, 0x00, 0x88, + 0x52, 0x19, 0xaf, 0x00, 0x88, 0x53, 0x09, 0x5b, + 0x00, 0x88, 0x55, 0x4d, 0x43, 0x00, 0x88, 0x56, + 0x3b, 0x08, 0x00, 0x88, 0x57, 0x05, 0x97, 0x00, + 0x88, 0x58, 0x48, 0xcc, 0x00, 0x88, 0x59, 0x19, + 0xb0, 0x00, 0x88, 0x5a, 0x4d, 0x44, 0x00, 0x88, + 0x5b, 0x04, 0xf4, 0x00, 0x88, 0x5c, 0x57, 0xc5, + 0x00, 0x88, 0x5d, 0x09, 0xbf, 0x00, 0x88, 0x5e, + 0x19, 0xb1, 0x00, 0x88, 0x5f, 0x3b, 0x09, 0x00, + 0x88, 0x60, 0x57, 0xc6, 0x00, 0x88, 0x61, 0x07, + 0xe7, 0x00, 0x88, 0x62, 0x19, 0xb2, 0x00, 0x88, + 0x63, 0x04, 0xa5, 0x00, 0x88, 0x64, 0x3b, 0x0a, + 0x00, 0x88, 0x68, 0x0d, 0xaf, 0x00, 0x88, 0x69, + 0x48, 0xcf, 0x00, 0x88, 0x6b, 0x19, 0xb3, 0x00, + 0x88, 0x6e, 0x4d, 0x45, 0x00, 0x88, 0x6f, 0x48, + 0xd1, 0x00, 0x88, 0x70, 0x0a, 0x30, 0x00, 0x88, + 0x71, 0x57, 0xc7, 0x00, 0x88, 0x72, 0x19, 0xba, + 0x00, 0x88, 0x75, 0x19, 0xb7, 0x00, 0x88, 0x77, + 0x0b, 0xad, 0x00, 0x88, 0x79, 0x57, 0xc8, 0x00, + 0x88, 0x7b, 0x57, 0xc9, 0x00, 0x88, 0x7d, 0x19, + 0xb8, 0x00, 0x88, 0x7e, 0x19, 0xb5, 0x00, 0x88, + 0x7f, 0x06, 0xd6, 0x00, 0x88, 0x80, 0x57, 0xca, + 0x00, 0x88, 0x81, 0x19, 0xb4, 0x00, 0x88, 0x82, + 0x19, 0xbb, 0x00, 0x88, 0x88, 0x07, 0x0c, 0x00, + 0x88, 0x8b, 0x0b, 0x3e, 0x00, 0x88, 0x8d, 0x19, + 0xc1, 0x00, 0x88, 0x92, 0x19, 0xbd, 0x00, 0x88, + 0x96, 0x0b, 0x15, 0x00, 0x88, 0x97, 0x19, 0xbc, + 0x00, 0x88, 0x98, 0x3b, 0x0b, 0x00, 0x88, 0x99, + 0x19, 0xbf, 0x00, 0x88, 0x9a, 0x4d, 0x46, 0x00, + 0x88, 0x9b, 0x4d, 0x47, 0x00, 0x88, 0x9c, 0x4d, + 0x48, 0x00, 0x88, 0x9e, 0x19, 0xb6, 0x00, 0x88, + 0x9f, 0x57, 0xcb, 0x00, 0x88, 0xa0, 0x48, 0xd2, + 0x00, 0x88, 0xa2, 0x19, 0xc0, 0x00, 0x88, 0xa4, + 0x19, 0xc2, 0x00, 0x88, 0xa8, 0x57, 0xcc, 0x00, + 0x88, 0xaa, 0x3b, 0x0c, 0x00, 0x88, 0xab, 0x0d, + 0x83, 0x00, 0x88, 0xae, 0x19, 0xbe, 0x00, 0x88, + 0xb0, 0x19, 0xc3, 0x00, 0x88, 0xb1, 0x19, 0xc5, + 0x00, 0x88, 0xb4, 0x07, 0x87, 0x00, 0x88, 0xb5, + 0x19, 0xb9, 0x00, 0x88, 0xb7, 0x04, 0x85, 0x00, + 0x88, 0xba, 0x57, 0xcd, 0x00, 0x88, 0xbc, 0x48, + 0xd3, 0x00, 0x88, 0xbd, 0x3b, 0x0d, 0x00, 0x88, + 0xbe, 0x3b, 0x0e, 0x00, 0x88, 0xbf, 0x19, 0xc4, + 0x00, 0x88, 0xc0, 0x48, 0xd4, 0x00, 0x88, 0xc1, + 0x08, 0x4b, 0x00, 0x88, 0xc2, 0x0f, 0xbe, 0x00, + 0x88, 0xc3, 0x19, 0xc6, 0x00, 0x88, 0xc4, 0x19, + 0xc7, 0x00, 0x88, 0xc5, 0x0a, 0xf7, 0x00, 0x88, + 0xc6, 0x37, 0x89, 0x00, 0x88, 0xca, 0x3b, 0x0f, + 0x00, 0x88, 0xcb, 0x57, 0xce, 0x00, 0x88, 0xcc, + 0x57, 0xcf, 0x00, 0x88, 0xcd, 0x4d, 0x49, 0x00, + 0x88, 0xce, 0x42, 0xdc, 0x00, 0x88, 0xcf, 0x0f, + 0x6a, 0x00, 0x88, 0xd1, 0x48, 0xd6, 0x00, 0x88, + 0xd2, 0x3b, 0x10, 0x00, 0x88, 0xd3, 0x48, 0xd7, + 0x00, 0x88, 0xd4, 0x19, 0xc8, 0x00, 0x88, 0xd5, + 0x0f, 0x1f, 0x00, 0x88, 0xd8, 0x19, 0xc9, 0x00, + 0x88, 0xd9, 0x19, 0xca, 0x00, 0x88, 0xdb, 0x3b, + 0x11, 0x00, 0x88, 0xdc, 0x0e, 0x34, 0x00, 0x88, + 0xdd, 0x19, 0xcb, 0x00, 0x88, 0xde, 0x57, 0xd0, + 0x00, 0x88, 0xdf, 0x08, 0x30, 0x00, 0x88, 0xe0, + 0x4d, 0x4a, 0x00, 0x88, 0xe1, 0x0f, 0x6b, 0x00, + 0x88, 0xe7, 0x57, 0xd1, 0x00, 0x88, 0xe8, 0x19, + 0xd0, 0x00, 0x88, 0xef, 0x4d, 0x4b, 0x00, 0x88, + 0xf0, 0x3b, 0x12, 0x00, 0x88, 0xf1, 0x3b, 0x13, + 0x00, 0x88, 0xf2, 0x19, 0xd1, 0x00, 0x88, 0xf3, + 0x09, 0xc0, 0x00, 0x88, 0xf4, 0x19, 0xcf, 0x00, + 0x88, 0xf5, 0x21, 0xa7, 0x00, 0x88, 0xf7, 0x57, + 0xd2, 0x00, 0x88, 0xf8, 0x0f, 0x51, 0x00, 0x88, + 0xf9, 0x19, 0xcc, 0x00, 0x88, 0xfc, 0x19, 0xce, + 0x00, 0x88, 0xfd, 0x0a, 0x61, 0x00, 0x88, 0xfe, + 0x0a, 0x44, 0x00, 0x89, 0x01, 0x48, 0xd9, 0x00, + 0x89, 0x02, 0x19, 0xcd, 0x00, 0x89, 0x04, 0x19, + 0xd2, 0x00, 0x89, 0x06, 0x3b, 0x14, 0x00, 0x89, + 0x07, 0x0d, 0xf3, 0x00, 0x89, 0x0a, 0x19, 0xd4, + 0x00, 0x89, 0x0c, 0x19, 0xd3, 0x00, 0x89, 0x0d, + 0x57, 0xd3, 0x00, 0x89, 0x0e, 0x4d, 0x4c, 0x00, + 0x89, 0x0f, 0x4d, 0x4d, 0x00, 0x89, 0x10, 0x05, + 0xca, 0x00, 0x89, 0x12, 0x0e, 0x59, 0x00, 0x89, + 0x13, 0x19, 0xd5, 0x00, 0x89, 0x15, 0x57, 0xd4, + 0x00, 0x89, 0x16, 0x57, 0xd5, 0x00, 0x89, 0x18, + 0x3b, 0x15, 0x00, 0x89, 0x19, 0x3b, 0x16, 0x00, + 0x89, 0x1a, 0x3b, 0x17, 0x00, 0x89, 0x1c, 0x20, + 0xa8, 0x00, 0x89, 0x1d, 0x19, 0xe1, 0x00, 0x89, + 0x1e, 0x19, 0xd7, 0x00, 0x89, 0x20, 0x57, 0xd6, + 0x00, 0x89, 0x25, 0x19, 0xd8, 0x00, 0x89, 0x26, + 0x4d, 0x4e, 0x00, 0x89, 0x27, 0x3b, 0x18, 0x00, + 0x89, 0x28, 0x57, 0xd7, 0x00, 0x89, 0x2a, 0x19, + 0xd9, 0x00, 0x89, 0x2b, 0x19, 0xda, 0x00, 0x89, + 0x30, 0x3b, 0x19, 0x00, 0x89, 0x31, 0x57, 0xd8, + 0x00, 0x89, 0x32, 0x42, 0xde, 0x00, 0x89, 0x35, + 0x4d, 0x4f, 0x00, 0x89, 0x36, 0x19, 0xde, 0x00, + 0x89, 0x37, 0x48, 0xdb, 0x00, 0x89, 0x38, 0x19, + 0xdf, 0x00, 0x89, 0x39, 0x42, 0xdf, 0x00, 0x89, + 0x3a, 0x57, 0xd9, 0x00, 0x89, 0x3b, 0x19, 0xdd, + 0x00, 0x89, 0x3e, 0x3b, 0x1a, 0x00, 0x89, 0x40, + 0x42, 0xe0, 0x00, 0x89, 0x41, 0x19, 0xdb, 0x00, + 0x89, 0x42, 0x48, 0xdd, 0x00, 0x89, 0x43, 0x19, + 0xd6, 0x00, 0x89, 0x44, 0x19, 0xdc, 0x00, 0x89, + 0x45, 0x48, 0xde, 0x00, 0x89, 0x46, 0x57, 0xda, + 0x00, 0x89, 0x49, 0x48, 0xdf, 0x00, 0x89, 0x4c, + 0x19, 0xe0, 0x00, 0x89, 0x4d, 0x1b, 0xd0, 0x00, + 0x89, 0x4f, 0x57, 0xdb, 0x00, 0x89, 0x52, 0x57, + 0xdc, 0x00, 0x89, 0x56, 0x05, 0x28, 0x00, 0x89, + 0x57, 0x57, 0xdd, 0x00, 0x89, 0x5a, 0x4d, 0x50, + 0x00, 0x89, 0x5b, 0x57, 0xde, 0x00, 0x89, 0x5c, + 0x4d, 0x51, 0x00, 0x89, 0x5e, 0x19, 0xe3, 0x00, + 0x89, 0x5f, 0x06, 0xd7, 0x00, 0x89, 0x60, 0x19, + 0xe2, 0x00, 0x89, 0x61, 0x57, 0xdf, 0x00, 0x89, + 0x62, 0x48, 0xe1, 0x00, 0x89, 0x63, 0x57, 0xe0, + 0x00, 0x89, 0x64, 0x19, 0xe5, 0x00, 0x89, 0x66, + 0x19, 0xe4, 0x00, 0x89, 0x6a, 0x19, 0xe7, 0x00, + 0x89, 0x6b, 0x4d, 0x52, 0x00, 0x89, 0x6d, 0x19, + 0xe6, 0x00, 0x89, 0x6e, 0x57, 0xe1, 0x00, 0x89, + 0x6f, 0x19, 0xe8, 0x00, 0x89, 0x70, 0x4d, 0x53, + 0x00, 0x89, 0x72, 0x09, 0x3b, 0x00, 0x89, 0x73, + 0x57, 0xe2, 0x00, 0x89, 0x74, 0x19, 0xe9, 0x00, + 0x89, 0x75, 0x57, 0xe3, 0x00, 0x89, 0x77, 0x19, + 0xea, 0x00, 0x89, 0x7a, 0x57, 0xe4, 0x00, 0x89, + 0x7b, 0x3b, 0x1b, 0x00, 0x89, 0x7c, 0x4d, 0x54, + 0x00, 0x89, 0x7d, 0x57, 0xe5, 0x00, 0x89, 0x7e, + 0x19, 0xeb, 0x00, 0x89, 0x7f, 0x0a, 0x62, 0x00, + 0x89, 0x80, 0x36, 0x2e, 0x00, 0x89, 0x81, 0x0f, + 0x41, 0x00, 0x89, 0x83, 0x19, 0xec, 0x00, 0x89, + 0x86, 0x0d, 0xf4, 0x00, 0x89, 0x87, 0x0c, 0xfc, + 0x00, 0x89, 0x88, 0x19, 0xed, 0x00, 0x89, 0x89, + 0x48, 0xe2, 0x00, 0x89, 0x8a, 0x19, 0xee, 0x00, + 0x89, 0x8b, 0x07, 0x5f, 0x00, 0x89, 0x8d, 0x57, + 0xe6, 0x00, 0x89, 0x8f, 0x06, 0x46, 0x00, 0x89, + 0x90, 0x48, 0xe3, 0x00, 0x89, 0x93, 0x19, 0xef, + 0x00, 0x89, 0x94, 0x42, 0xe1, 0x00, 0x89, 0x95, + 0x57, 0xe7, 0x00, 0x89, 0x96, 0x08, 0xb9, 0x00, + 0x89, 0x97, 0x0c, 0xf7, 0x00, 0x89, 0x98, 0x19, + 0xf0, 0x00, 0x89, 0x9a, 0x05, 0xae, 0x00, 0x89, + 0x9b, 0x57, 0xe8, 0x00, 0x89, 0x9c, 0x57, 0xe9, + 0x00, 0x89, 0x9f, 0x48, 0xe4, 0x00, 0x89, 0xa0, + 0x57, 0xea, 0x00, 0x89, 0xa1, 0x19, 0xf1, 0x00, + 0x89, 0xa5, 0x4d, 0x55, 0x00, 0x89, 0xa6, 0x19, + 0xf3, 0x00, 0x89, 0xa7, 0x0f, 0x61, 0x00, 0x89, + 0xa9, 0x19, 0xf2, 0x00, 0x89, 0xaa, 0x0a, 0x0c, + 0x00, 0x89, 0xac, 0x19, 0xf4, 0x00, 0x89, 0xaf, + 0x19, 0xf5, 0x00, 0x89, 0xb0, 0x48, 0xe5, 0x00, + 0x89, 0xb2, 0x19, 0xf6, 0x00, 0x89, 0xb3, 0x06, + 0x0d, 0x00, 0x89, 0xb4, 0x57, 0xeb, 0x00, 0x89, + 0xb5, 0x4d, 0x56, 0x00, 0x89, 0xb6, 0x57, 0xec, + 0x00, 0x89, 0xb7, 0x48, 0xe6, 0x00, 0x89, 0xba, + 0x19, 0xf7, 0x00, 0x89, 0xbc, 0x4d, 0x57, 0x00, + 0x89, 0xbd, 0x19, 0xf8, 0x00, 0x89, 0xbf, 0x19, + 0xf9, 0x00, 0x89, 0xc0, 0x19, 0xfa, 0x00, 0x89, + 0xd2, 0x35, 0x72, 0x00, 0x89, 0xd4, 0x3b, 0x1c, + 0x00, 0x89, 0xd5, 0x4d, 0x58, 0x00, 0x89, 0xd6, + 0x3b, 0x1d, 0x00, 0x89, 0xd7, 0x57, 0xed, 0x00, + 0x89, 0xd8, 0x48, 0xe7, 0x00, 0x89, 0xda, 0x19, + 0xfb, 0x00, 0x89, 0xdc, 0x19, 0xfc, 0x00, 0x89, + 0xdd, 0x19, 0xfd, 0x00, 0x89, 0xe3, 0x05, 0x72, + 0x00, 0x89, 0xe5, 0x3b, 0x1e, 0x00, 0x89, 0xe6, + 0x09, 0xee, 0x00, 0x89, 0xe7, 0x19, 0xfe, 0x00, + 0x89, 0xe9, 0x57, 0xee, 0x00, 0x89, 0xeb, 0x48, + 0xe8, 0x00, 0x89, 0xed, 0x57, 0xef, 0x00, 0x89, + 0xf1, 0x3b, 0x1f, 0x00, 0x89, 0xf3, 0x48, 0xea, + 0x00, 0x89, 0xf4, 0x19, 0xff, 0x00, 0x89, 0xf6, + 0x42, 0xe2, 0x00, 0x89, 0xf8, 0x1a, 0x00, 0x00, + 0x89, 0xf9, 0x57, 0xf0, 0x00, 0x89, 0xfd, 0x48, + 0xeb, 0x00, 0x89, 0xff, 0x48, 0xec, 0x00, 0x8a, + 0x00, 0x07, 0x74, 0x00, 0x8a, 0x01, 0x35, 0xbc, + 0x00, 0x8a, 0x02, 0x0c, 0x17, 0x00, 0x8a, 0x03, + 0x1a, 0x01, 0x00, 0x8a, 0x04, 0x57, 0xf1, 0x00, + 0x8a, 0x05, 0x57, 0xf2, 0x00, 0x8a, 0x07, 0x3b, + 0x20, 0x00, 0x8a, 0x08, 0x07, 0x2d, 0x00, 0x8a, + 0x0a, 0x0a, 0x1c, 0x00, 0x8a, 0x0c, 0x1a, 0x04, + 0x00, 0x8a, 0x0e, 0x0c, 0x7c, 0x00, 0x8a, 0x0f, + 0x3b, 0x21, 0x00, 0x8a, 0x10, 0x1a, 0x03, 0x00, + 0x8a, 0x11, 0x48, 0xee, 0x00, 0x8a, 0x12, 0x21, + 0xa8, 0x00, 0x8a, 0x13, 0x07, 0x07, 0x00, 0x8a, + 0x14, 0x48, 0xef, 0x00, 0x8a, 0x15, 0x3b, 0x22, + 0x00, 0x8a, 0x16, 0x1a, 0x02, 0x00, 0x8a, 0x17, + 0x0b, 0x57, 0x00, 0x8a, 0x18, 0x06, 0x47, 0x00, + 0x8a, 0x1b, 0x1a, 0x05, 0x00, 0x8a, 0x1d, 0x1a, + 0x06, 0x00, 0x8a, 0x1e, 0x57, 0xf3, 0x00, 0x8a, + 0x1f, 0x09, 0xc1, 0x00, 0x8a, 0x20, 0x57, 0xf4, + 0x00, 0x8a, 0x21, 0x48, 0xf1, 0x00, 0x8a, 0x22, + 0x3b, 0x23, 0x00, 0x8a, 0x23, 0x07, 0x43, 0x00, + 0x8a, 0x24, 0x57, 0xf5, 0x00, 0x8a, 0x25, 0x1a, + 0x07, 0x00, 0x8a, 0x26, 0x57, 0xf6, 0x00, 0x8a, + 0x2a, 0x0e, 0x5a, 0x00, 0x8a, 0x2b, 0x57, 0xf7, + 0x00, 0x8a, 0x2c, 0x57, 0xf8, 0x00, 0x8a, 0x2d, + 0x0a, 0x83, 0x00, 0x8a, 0x2f, 0x57, 0xf9, 0x00, + 0x8a, 0x31, 0x06, 0x90, 0x00, 0x8a, 0x33, 0x0f, + 0x01, 0x00, 0x8a, 0x34, 0x0a, 0xcc, 0x00, 0x8a, + 0x35, 0x48, 0xf2, 0x00, 0x8a, 0x36, 0x1a, 0x08, + 0x00, 0x8a, 0x37, 0x21, 0xa9, 0x00, 0x8a, 0x3a, + 0x0a, 0x0d, 0x00, 0x8a, 0x3b, 0x0b, 0xae, 0x00, + 0x8a, 0x3c, 0x09, 0xc2, 0x00, 0x8a, 0x3d, 0x57, + 0xfa, 0x00, 0x8a, 0x3e, 0x48, 0xf3, 0x00, 0x8a, + 0x40, 0x57, 0xfb, 0x00, 0x8a, 0x41, 0x1a, 0x09, + 0x00, 0x8a, 0x43, 0x57, 0xfc, 0x00, 0x8a, 0x45, + 0x48, 0xf4, 0x00, 0x8a, 0x46, 0x1a, 0x0c, 0x00, + 0x8a, 0x47, 0x42, 0xe3, 0x00, 0x8a, 0x48, 0x1a, + 0x0d, 0x00, 0x8a, 0x49, 0x4d, 0x59, 0x00, 0x8a, + 0x4d, 0x48, 0xf5, 0x00, 0x8a, 0x4e, 0x3b, 0x24, + 0x00, 0x8a, 0x50, 0x08, 0x2e, 0x00, 0x8a, 0x51, + 0x0b, 0x22, 0x00, 0x8a, 0x52, 0x1a, 0x0b, 0x00, + 0x8a, 0x53, 0x57, 0xfd, 0x00, 0x8a, 0x54, 0x09, + 0xc3, 0x00, 0x8a, 0x55, 0x0d, 0xb0, 0x00, 0x8a, + 0x56, 0x57, 0xfe, 0x00, 0x8a, 0x57, 0x4d, 0x5a, + 0x00, 0x8a, 0x58, 0x48, 0xf6, 0x00, 0x8a, 0x5b, + 0x1a, 0x0a, 0x00, 0x8a, 0x5c, 0x57, 0xff, 0x00, + 0x8a, 0x5d, 0x42, 0xe4, 0x00, 0x8a, 0x5e, 0x08, + 0xba, 0x00, 0x8a, 0x60, 0x04, 0xf5, 0x00, 0x8a, + 0x61, 0x42, 0xe5, 0x00, 0x8a, 0x62, 0x1a, 0x11, + 0x00, 0x8a, 0x63, 0x07, 0x2e, 0x00, 0x8a, 0x65, + 0x58, 0x00, 0x00, 0x8a, 0x66, 0x08, 0xbc, 0x00, + 0x8a, 0x67, 0x4d, 0x5b, 0x00, 0x8a, 0x69, 0x08, + 0xbb, 0x00, 0x8a, 0x6b, 0x0f, 0xf3, 0x00, 0x8a, + 0x6c, 0x1a, 0x10, 0x00, 0x8a, 0x6d, 0x1a, 0x0f, + 0x00, 0x8a, 0x6e, 0x0a, 0xa9, 0x00, 0x8a, 0x70, + 0x06, 0x67, 0x00, 0x8a, 0x71, 0x0f, 0xe9, 0x00, + 0x8a, 0x72, 0x05, 0x98, 0x00, 0x8a, 0x73, 0x09, + 0xc4, 0x00, 0x8a, 0x75, 0x42, 0xe6, 0x00, 0x8a, + 0x76, 0x58, 0x01, 0x00, 0x8a, 0x77, 0x58, 0x02, + 0x00, 0x8a, 0x79, 0x21, 0xaa, 0x00, 0x8a, 0x7a, + 0x58, 0x03, 0x00, 0x8a, 0x7b, 0x58, 0x04, 0x00, + 0x8a, 0x7c, 0x1a, 0x0e, 0x00, 0x8a, 0x7e, 0x4d, + 0x5c, 0x00, 0x8a, 0x7f, 0x3b, 0x25, 0x00, 0x8a, + 0x80, 0x58, 0x05, 0x00, 0x8a, 0x82, 0x1a, 0x13, + 0x00, 0x8a, 0x83, 0x58, 0x06, 0x00, 0x8a, 0x84, + 0x1a, 0x14, 0x00, 0x8a, 0x85, 0x1a, 0x12, 0x00, + 0x8a, 0x86, 0x4d, 0x5d, 0x00, 0x8a, 0x87, 0x07, + 0x8c, 0x00, 0x8a, 0x89, 0x0f, 0x2a, 0x00, 0x8a, + 0x8b, 0x58, 0x07, 0x00, 0x8a, 0x8c, 0x08, 0xbd, + 0x00, 0x8a, 0x8d, 0x0c, 0xdd, 0x00, 0x8a, 0x8f, + 0x58, 0x08, 0x00, 0x8a, 0x90, 0x48, 0xf8, 0x00, + 0x8a, 0x91, 0x1a, 0x17, 0x00, 0x8a, 0x92, 0x58, + 0x09, 0x00, 0x8a, 0x93, 0x0a, 0x64, 0x00, 0x8a, + 0x95, 0x0b, 0x80, 0x00, 0x8a, 0x96, 0x4d, 0x5e, + 0x00, 0x8a, 0x97, 0x58, 0x0a, 0x00, 0x8a, 0x98, + 0x0f, 0x20, 0x00, 0x8a, 0x99, 0x58, 0x0b, 0x00, + 0x8a, 0x9a, 0x1a, 0x1a, 0x00, 0x8a, 0x9e, 0x07, + 0xa0, 0x00, 0x8a, 0x9f, 0x58, 0x0c, 0x00, 0x8a, + 0xa0, 0x0a, 0x63, 0x00, 0x8a, 0xa1, 0x1a, 0x16, + 0x00, 0x8a, 0xa3, 0x1a, 0x1b, 0x00, 0x8a, 0xa4, + 0x07, 0xa1, 0x00, 0x8a, 0xa5, 0x1a, 0x18, 0x00, + 0x8a, 0xa6, 0x1a, 0x19, 0x00, 0x8a, 0xa7, 0x21, + 0xab, 0x00, 0x8a, 0xa8, 0x1a, 0x15, 0x00, 0x8a, + 0xa9, 0x58, 0x0d, 0x00, 0x8a, 0xaa, 0x36, 0x38, + 0x00, 0x8a, 0xac, 0x0a, 0x86, 0x00, 0x8a, 0xad, + 0x0c, 0xa1, 0x00, 0x8a, 0xae, 0x48, 0xf7, 0x00, + 0x8a, 0xaf, 0x58, 0x0e, 0x00, 0x8a, 0xb0, 0x0b, + 0x6d, 0x00, 0x8a, 0xb2, 0x05, 0x5d, 0x00, 0x8a, + 0xb3, 0x58, 0x0f, 0x00, 0x8a, 0xb6, 0x4d, 0x5f, + 0x00, 0x8a, 0xb7, 0x48, 0xf9, 0x00, 0x8a, 0xb9, + 0x0d, 0x84, 0x00, 0x8a, 0xbb, 0x58, 0x10, 0x00, + 0x8a, 0xbc, 0x06, 0x5d, 0x00, 0x8a, 0xbe, 0x21, + 0xac, 0x00, 0x8a, 0xbf, 0x0b, 0xd0, 0x00, 0x8a, + 0xc2, 0x1a, 0x1e, 0x00, 0x8a, 0xc3, 0x58, 0x11, + 0x00, 0x8a, 0xc4, 0x1a, 0x1c, 0x00, 0x8a, 0xc6, + 0x58, 0x12, 0x00, 0x8a, 0xc7, 0x0b, 0x8a, 0x00, + 0x8a, 0xc8, 0x58, 0x13, 0x00, 0x8a, 0xc9, 0x4d, + 0x60, 0x00, 0x8a, 0xca, 0x58, 0x14, 0x00, 0x8a, + 0xcb, 0x0a, 0x65, 0x00, 0x8a, 0xcc, 0x06, 0x0e, + 0x00, 0x8a, 0xcd, 0x1a, 0x1d, 0x00, 0x8a, 0xcf, + 0x0a, 0x21, 0x00, 0x8a, 0xd0, 0x42, 0xe7, 0x00, + 0x8a, 0xd1, 0x4d, 0x61, 0x00, 0x8a, 0xd2, 0x0f, + 0x92, 0x00, 0x8a, 0xd3, 0x58, 0x15, 0x00, 0x8a, + 0xd4, 0x58, 0x16, 0x00, 0x8a, 0xd5, 0x58, 0x17, + 0x00, 0x8a, 0xd6, 0x0f, 0xe6, 0x00, 0x8a, 0xd7, + 0x48, 0xfa, 0x00, 0x8a, 0xda, 0x1a, 0x1f, 0x00, + 0x8a, 0xdb, 0x1a, 0x2a, 0x00, 0x8a, 0xdc, 0x0b, + 0xd1, 0x00, 0x8a, 0xdd, 0x4d, 0x62, 0x00, 0x8a, + 0xde, 0x1a, 0x29, 0x00, 0x8a, 0xdf, 0x21, 0xad, + 0x00, 0x8a, 0xe0, 0x1a, 0x26, 0x00, 0x8a, 0xe1, + 0x1a, 0x2e, 0x00, 0x8a, 0xe2, 0x1a, 0x27, 0x00, + 0x8a, 0xe4, 0x1a, 0x23, 0x00, 0x8a, 0xe6, 0x0c, + 0x18, 0x00, 0x8a, 0xe7, 0x1a, 0x22, 0x00, 0x8a, + 0xeb, 0x1a, 0x20, 0x00, 0x8a, 0xec, 0x4d, 0x63, + 0x00, 0x8a, 0xed, 0x36, 0xf4, 0x00, 0x8a, 0xee, + 0x08, 0xbe, 0x00, 0x8a, 0xf0, 0x58, 0x18, 0x00, + 0x8a, 0xf1, 0x1a, 0x24, 0x00, 0x8a, 0xf3, 0x1a, + 0x21, 0x00, 0x8a, 0xf4, 0x3b, 0x26, 0x00, 0x8a, + 0xf5, 0x4d, 0x64, 0x00, 0x8a, 0xf6, 0x21, 0xaf, + 0x00, 0x8a, 0xf7, 0x1a, 0x28, 0x00, 0x8a, 0xf8, + 0x21, 0xae, 0x00, 0x8a, 0xfa, 0x07, 0x75, 0x00, + 0x8a, 0xfc, 0x48, 0xfb, 0x00, 0x8a, 0xfe, 0x0b, + 0x5a, 0x00, 0x8a, 0xff, 0x58, 0x19, 0x00, 0x8b, + 0x00, 0x0e, 0x73, 0x00, 0x8b, 0x01, 0x34, 0x09, + 0x00, 0x8b, 0x02, 0x04, 0xa6, 0x00, 0x8b, 0x04, + 0x0c, 0x7d, 0x00, 0x8b, 0x05, 0x48, 0xfe, 0x00, + 0x8b, 0x06, 0x4d, 0x65, 0x00, 0x8b, 0x07, 0x1a, + 0x2c, 0x00, 0x8b, 0x0a, 0x48, 0xfd, 0x00, 0x8b, + 0x0b, 0x58, 0x1a, 0x00, 0x8b, 0x0c, 0x1a, 0x2b, + 0x00, 0x8b, 0x0d, 0x48, 0xff, 0x00, 0x8b, 0x0e, + 0x0c, 0xbe, 0x00, 0x8b, 0x0f, 0x4d, 0x66, 0x00, + 0x8b, 0x10, 0x1a, 0x30, 0x00, 0x8b, 0x11, 0x4d, + 0x67, 0x00, 0x8b, 0x14, 0x1a, 0x25, 0x00, 0x8b, + 0x16, 0x1a, 0x2f, 0x00, 0x8b, 0x17, 0x1a, 0x31, + 0x00, 0x8b, 0x19, 0x07, 0x60, 0x00, 0x8b, 0x1a, + 0x1a, 0x2d, 0x00, 0x8b, 0x1b, 0x07, 0xe8, 0x00, + 0x8b, 0x1c, 0x49, 0x00, 0x00, 0x8b, 0x1d, 0x09, + 0x01, 0x00, 0x8b, 0x1e, 0x58, 0x1b, 0x00, 0x8b, + 0x1f, 0x3b, 0x27, 0x00, 0x8b, 0x20, 0x1a, 0x32, + 0x00, 0x8b, 0x21, 0x0f, 0x42, 0x00, 0x8b, 0x26, + 0x1a, 0x35, 0x00, 0x8b, 0x28, 0x1a, 0x38, 0x00, + 0x8b, 0x2b, 0x1a, 0x36, 0x00, 0x8b, 0x2c, 0x0d, + 0xa7, 0x00, 0x8b, 0x2d, 0x49, 0x01, 0x00, 0x8b, + 0x30, 0x58, 0x1c, 0x00, 0x8b, 0x33, 0x1a, 0x33, + 0x00, 0x8b, 0x37, 0x3b, 0x28, 0x00, 0x8b, 0x39, + 0x34, 0x1b, 0x00, 0x8b, 0x3c, 0x58, 0x1d, 0x00, + 0x8b, 0x3e, 0x1a, 0x37, 0x00, 0x8b, 0x41, 0x1a, + 0x39, 0x00, 0x8b, 0x42, 0x58, 0x1e, 0x00, 0x8b, + 0x43, 0x3b, 0x29, 0x00, 0x8b, 0x44, 0x3b, 0x2a, + 0x00, 0x8b, 0x45, 0x4d, 0x68, 0x00, 0x8b, 0x46, + 0x42, 0xe8, 0x00, 0x8b, 0x48, 0x58, 0x1f, 0x00, + 0x8b, 0x49, 0x1a, 0x3d, 0x00, 0x8b, 0x4c, 0x1a, + 0x3a, 0x00, 0x8b, 0x4d, 0x58, 0x20, 0x00, 0x8b, + 0x4e, 0x1a, 0x3c, 0x00, 0x8b, 0x4f, 0x1a, 0x3b, + 0x00, 0x8b, 0x51, 0x49, 0x03, 0x00, 0x8b, 0x52, + 0x4d, 0x69, 0x00, 0x8b, 0x53, 0x21, 0xb0, 0x00, + 0x8b, 0x54, 0x3b, 0x2b, 0x00, 0x8b, 0x56, 0x1a, + 0x3e, 0x00, 0x8b, 0x58, 0x08, 0xdd, 0x00, 0x8b, + 0x59, 0x42, 0xe9, 0x00, 0x8b, 0x5a, 0x1a, 0x40, + 0x00, 0x8b, 0x5b, 0x1a, 0x3f, 0x00, 0x8b, 0x5c, + 0x0d, 0xda, 0x00, 0x8b, 0x5e, 0x49, 0x04, 0x00, + 0x8b, 0x5f, 0x1a, 0x42, 0x00, 0x8b, 0x63, 0x58, + 0x21, 0x00, 0x8b, 0x66, 0x07, 0x2f, 0x00, 0x8b, + 0x69, 0x42, 0xea, 0x00, 0x8b, 0x6b, 0x1a, 0x41, + 0x00, 0x8b, 0x6c, 0x1a, 0x43, 0x00, 0x8b, 0x6d, + 0x4d, 0x6a, 0x00, 0x8b, 0x6f, 0x1a, 0x44, 0x00, + 0x8b, 0x70, 0x06, 0x5e, 0x00, 0x8b, 0x71, 0x18, + 0x2e, 0x00, 0x8b, 0x72, 0x09, 0xe1, 0x00, 0x8b, + 0x74, 0x1a, 0x45, 0x00, 0x8b, 0x76, 0x49, 0x05, + 0x00, 0x8b, 0x77, 0x07, 0xa2, 0x00, 0x8b, 0x78, + 0x4d, 0x6b, 0x00, 0x8b, 0x79, 0x58, 0x22, 0x00, + 0x8b, 0x7c, 0x4d, 0x6c, 0x00, 0x8b, 0x7d, 0x1a, + 0x46, 0x00, 0x8b, 0x7e, 0x4d, 0x6d, 0x00, 0x8b, + 0x7f, 0x21, 0xb1, 0x00, 0x8b, 0x80, 0x1a, 0x47, + 0x00, 0x8b, 0x81, 0x49, 0x06, 0x00, 0x8b, 0x83, + 0x08, 0x8c, 0x00, 0x8b, 0x84, 0x58, 0x23, 0x00, + 0x8b, 0x85, 0x4d, 0x6e, 0x00, 0x8b, 0x8a, 0x13, + 0xd3, 0x00, 0x8b, 0x8b, 0x49, 0x07, 0x00, 0x8b, + 0x8c, 0x1a, 0x48, 0x00, 0x8b, 0x8d, 0x58, 0x24, + 0x00, 0x8b, 0x8e, 0x1a, 0x49, 0x00, 0x8b, 0x8f, + 0x58, 0x25, 0x00, 0x8b, 0x90, 0x09, 0x3c, 0x00, + 0x8b, 0x92, 0x1a, 0x4a, 0x00, 0x8b, 0x93, 0x1a, + 0x4b, 0x00, 0x8b, 0x94, 0x49, 0x08, 0x00, 0x8b, + 0x95, 0x49, 0x09, 0x00, 0x8b, 0x96, 0x1a, 0x4c, + 0x00, 0x8b, 0x99, 0x1a, 0x4d, 0x00, 0x8b, 0x9a, + 0x1a, 0x4e, 0x00, 0x8b, 0x9c, 0x3b, 0x2c, 0x00, + 0x8b, 0x9d, 0x42, 0xeb, 0x00, 0x8b, 0x9e, 0x3b, + 0x2d, 0x00, 0x8b, 0x9f, 0x4d, 0x6f, 0x00, 0x8c, + 0x37, 0x0b, 0x69, 0x00, 0x8c, 0x38, 0x58, 0x26, + 0x00, 0x8c, 0x39, 0x49, 0x0a, 0x00, 0x8c, 0x3a, + 0x1a, 0x4f, 0x00, 0x8c, 0x3d, 0x49, 0x0c, 0x00, + 0x8c, 0x3e, 0x58, 0x27, 0x00, 0x8c, 0x3f, 0x1a, + 0x51, 0x00, 0x8c, 0x41, 0x1a, 0x50, 0x00, 0x8c, + 0x45, 0x49, 0x0f, 0x00, 0x8c, 0x46, 0x0c, 0x7e, + 0x00, 0x8c, 0x47, 0x3b, 0x2e, 0x00, 0x8c, 0x48, + 0x1a, 0x52, 0x00, 0x8c, 0x49, 0x42, 0xec, 0x00, + 0x8c, 0x4a, 0x0e, 0x5b, 0x00, 0x8c, 0x4b, 0x4d, + 0x70, 0x00, 0x8c, 0x4c, 0x1a, 0x53, 0x00, 0x8c, + 0x4e, 0x1a, 0x54, 0x00, 0x8c, 0x4f, 0x49, 0x10, + 0x00, 0x8c, 0x50, 0x1a, 0x55, 0x00, 0x8c, 0x51, + 0x58, 0x28, 0x00, 0x8c, 0x53, 0x4d, 0x71, 0x00, + 0x8c, 0x54, 0x3b, 0x2f, 0x00, 0x8c, 0x55, 0x1a, + 0x56, 0x00, 0x8c, 0x57, 0x49, 0x11, 0x00, 0x8c, + 0x58, 0x58, 0x29, 0x00, 0x8c, 0x59, 0x58, 0x2c, + 0x00, 0x8c, 0x5a, 0x0c, 0xb2, 0x00, 0x8c, 0x5b, + 0x58, 0x2a, 0x00, 0x8c, 0x5d, 0x58, 0x2b, 0x00, + 0x8c, 0x61, 0x09, 0xc5, 0x00, 0x8c, 0x62, 0x1a, + 0x57, 0x00, 0x8c, 0x63, 0x58, 0x2d, 0x00, 0x8c, + 0x64, 0x58, 0x2e, 0x00, 0x8c, 0x66, 0x58, 0x2f, + 0x00, 0x8c, 0x68, 0x42, 0xed, 0x00, 0x8c, 0x69, + 0x49, 0x12, 0x00, 0x8c, 0x6a, 0x07, 0xfd, 0x00, + 0x8c, 0x6b, 0x10, 0x07, 0x00, 0x8c, 0x6c, 0x1a, + 0x58, 0x00, 0x8c, 0x6d, 0x49, 0x13, 0x00, 0x8c, + 0x73, 0x3b, 0x30, 0x00, 0x8c, 0x75, 0x58, 0x30, + 0x00, 0x8c, 0x76, 0x58, 0x31, 0x00, 0x8c, 0x78, + 0x1a, 0x59, 0x00, 0x8c, 0x79, 0x0d, 0xb1, 0x00, + 0x8c, 0x7a, 0x1a, 0x5a, 0x00, 0x8c, 0x7b, 0x4d, + 0x72, 0x00, 0x8c, 0x7c, 0x1a, 0x62, 0x00, 0x8c, + 0x7e, 0x58, 0x32, 0x00, 0x8c, 0x82, 0x1a, 0x5b, + 0x00, 0x8c, 0x85, 0x1a, 0x5d, 0x00, 0x8c, 0x86, + 0x58, 0x33, 0x00, 0x8c, 0x87, 0x58, 0x34, 0x00, + 0x8c, 0x89, 0x1a, 0x5c, 0x00, 0x8c, 0x8a, 0x1a, + 0x5e, 0x00, 0x8c, 0x8b, 0x58, 0x35, 0x00, 0x8c, + 0x8c, 0x0e, 0x74, 0x00, 0x8c, 0x8d, 0x1a, 0x5f, + 0x00, 0x8c, 0x8e, 0x1a, 0x60, 0x00, 0x8c, 0x90, + 0x58, 0x36, 0x00, 0x8c, 0x92, 0x49, 0x16, 0x00, + 0x8c, 0x93, 0x49, 0x15, 0x00, 0x8c, 0x94, 0x1a, + 0x61, 0x00, 0x8c, 0x98, 0x1a, 0x63, 0x00, 0x8c, + 0x99, 0x49, 0x17, 0x00, 0x8c, 0x9b, 0x49, 0x19, + 0x00, 0x8c, 0x9c, 0x58, 0x38, 0x00, 0x8c, 0x9d, + 0x05, 0x8b, 0x00, 0x8c, 0x9e, 0x0c, 0x03, 0x00, + 0x8c, 0x9f, 0x35, 0x4c, 0x00, 0x8c, 0xa0, 0x0d, + 0xdb, 0x00, 0x8c, 0xa1, 0x08, 0x52, 0x00, 0x8c, + 0xa2, 0x07, 0xe9, 0x00, 0x8c, 0xa4, 0x3b, 0x31, + 0x00, 0x8c, 0xa7, 0x0d, 0xc1, 0x00, 0x8c, 0xa8, + 0x05, 0x5f, 0x00, 0x8c, 0xa9, 0x0d, 0x62, 0x00, + 0x8c, 0xaa, 0x1a, 0x66, 0x00, 0x8c, 0xab, 0x06, + 0x0f, 0x00, 0x8c, 0xac, 0x0a, 0x79, 0x00, 0x8c, + 0xad, 0x1a, 0x65, 0x00, 0x8c, 0xae, 0x1a, 0x6a, + 0x00, 0x8c, 0xaf, 0x0b, 0xb7, 0x00, 0x8c, 0xb0, + 0x0e, 0xef, 0x00, 0x8c, 0xb2, 0x1a, 0x68, 0x00, + 0x8c, 0xb3, 0x1a, 0x69, 0x00, 0x8c, 0xb4, 0x06, + 0x48, 0x00, 0x8c, 0xb6, 0x1a, 0x6b, 0x00, 0x8c, + 0xb7, 0x0d, 0x19, 0x00, 0x8c, 0xb8, 0x0b, 0x3f, + 0x00, 0x8c, 0xb9, 0x58, 0x39, 0x00, 0x8c, 0xba, + 0x4d, 0x73, 0x00, 0x8c, 0xbb, 0x0d, 0x85, 0x00, + 0x8c, 0xbc, 0x0c, 0x37, 0x00, 0x8c, 0xbd, 0x1a, + 0x67, 0x00, 0x8c, 0xbf, 0x0e, 0x75, 0x00, 0x8c, + 0xc0, 0x05, 0x6c, 0x00, 0x8c, 0xc1, 0x1a, 0x6d, + 0x00, 0x8c, 0xc2, 0x0f, 0xce, 0x00, 0x8c, 0xc3, + 0x0b, 0xde, 0x00, 0x8c, 0xc4, 0x0f, 0xeb, 0x00, + 0x8c, 0xc5, 0x4d, 0x74, 0x00, 0x8c, 0xc6, 0x58, + 0x3a, 0x00, 0x8c, 0xc7, 0x08, 0xbf, 0x00, 0x8c, + 0xc8, 0x1a, 0x6c, 0x00, 0x8c, 0xc9, 0x4d, 0x75, + 0x00, 0x8c, 0xca, 0x0b, 0x11, 0x00, 0x8c, 0xcb, + 0x58, 0x3b, 0x00, 0x8c, 0xcd, 0x1a, 0x7d, 0x00, + 0x8c, 0xce, 0x0a, 0xaa, 0x00, 0x8c, 0xcf, 0x58, + 0x3c, 0x00, 0x8c, 0xd1, 0x0c, 0xd0, 0x00, 0x8c, + 0xd2, 0x4d, 0x76, 0x00, 0x8c, 0xd3, 0x34, 0x44, + 0x00, 0x8c, 0xd5, 0x49, 0x1b, 0x00, 0x8c, 0xd6, + 0x49, 0x1a, 0x00, 0x8c, 0xd9, 0x3b, 0x32, 0x00, + 0x8c, 0xda, 0x1a, 0x70, 0x00, 0x8c, 0xdb, 0x08, + 0x8d, 0x00, 0x8c, 0xdc, 0x08, 0xc0, 0x00, 0x8c, + 0xdd, 0x58, 0x3d, 0x00, 0x8c, 0xde, 0x09, 0xc6, + 0x00, 0x8c, 0xe0, 0x0d, 0x1b, 0x00, 0x8c, 0xe1, + 0x3b, 0x33, 0x00, 0x8c, 0xe2, 0x07, 0x61, 0x00, + 0x8c, 0xe3, 0x1a, 0x6f, 0x00, 0x8c, 0xe4, 0x1a, + 0x6e, 0x00, 0x8c, 0xe6, 0x0d, 0xdc, 0x00, 0x8c, + 0xe8, 0x58, 0x3e, 0x00, 0x8c, 0xea, 0x08, 0xed, + 0x00, 0x8c, 0xec, 0x4d, 0x77, 0x00, 0x8c, 0xed, + 0x0c, 0x4c, 0x00, 0x8c, 0xef, 0x58, 0x3f, 0x00, + 0x8c, 0xf0, 0x21, 0xb2, 0x00, 0x8c, 0xf1, 0x49, + 0x1d, 0x00, 0x8c, 0xf2, 0x58, 0x40, 0x00, 0x8c, + 0xf4, 0x21, 0xb3, 0x00, 0x8c, 0xf5, 0x4d, 0x78, + 0x00, 0x8c, 0xf7, 0x4d, 0x79, 0x00, 0x8c, 0xf8, + 0x3b, 0x34, 0x00, 0x8c, 0xfa, 0x1a, 0x72, 0x00, + 0x8c, 0xfb, 0x1a, 0x73, 0x00, 0x8c, 0xfc, 0x07, + 0xea, 0x00, 0x8c, 0xfd, 0x1a, 0x71, 0x00, 0x8c, + 0xfe, 0x3b, 0x35, 0x00, 0x8c, 0xff, 0x58, 0x41, + 0x00, 0x8d, 0x01, 0x4d, 0x7a, 0x00, 0x8d, 0x03, + 0x4d, 0x7b, 0x00, 0x8d, 0x04, 0x1a, 0x74, 0x00, + 0x8d, 0x05, 0x1a, 0x75, 0x00, 0x8d, 0x07, 0x1a, + 0x77, 0x00, 0x8d, 0x08, 0x0b, 0x03, 0x00, 0x8d, + 0x09, 0x49, 0x1f, 0x00, 0x8d, 0x0a, 0x1a, 0x76, + 0x00, 0x8d, 0x0b, 0x06, 0x22, 0x00, 0x8d, 0x0d, + 0x1a, 0x79, 0x00, 0x8d, 0x0e, 0x49, 0x20, 0x00, + 0x8d, 0x0f, 0x1a, 0x78, 0x00, 0x8d, 0x10, 0x1a, + 0x7a, 0x00, 0x8d, 0x12, 0x21, 0xb4, 0x00, 0x8d, + 0x13, 0x1a, 0x7c, 0x00, 0x8d, 0x14, 0x1a, 0x7e, + 0x00, 0x8d, 0x16, 0x1a, 0x7f, 0x00, 0x8d, 0x17, + 0x4d, 0x7c, 0x00, 0x8d, 0x1b, 0x3b, 0x36, 0x00, + 0x8d, 0x1c, 0x4d, 0x7d, 0x00, 0x8d, 0x64, 0x0a, + 0x7a, 0x00, 0x8d, 0x65, 0x58, 0x42, 0x00, 0x8d, + 0x66, 0x08, 0xfb, 0x00, 0x8d, 0x67, 0x1a, 0x80, + 0x00, 0x8d, 0x69, 0x3b, 0x37, 0x00, 0x8d, 0x6b, + 0x05, 0xb0, 0x00, 0x8d, 0x6c, 0x3b, 0x38, 0x00, + 0x8d, 0x6d, 0x1a, 0x81, 0x00, 0x8d, 0x6e, 0x4d, + 0x7e, 0x00, 0x8d, 0x70, 0x0a, 0xf8, 0x00, 0x8d, + 0x71, 0x1a, 0x82, 0x00, 0x8d, 0x73, 0x1a, 0x83, + 0x00, 0x8d, 0x74, 0x0d, 0xdd, 0x00, 0x8d, 0x76, + 0x21, 0xb5, 0x00, 0x8d, 0x77, 0x06, 0x49, 0x00, + 0x8d, 0x7f, 0x58, 0x43, 0x00, 0x8d, 0x81, 0x1a, + 0x84, 0x00, 0x8d, 0x82, 0x58, 0x44, 0x00, 0x8d, + 0x84, 0x3b, 0x39, 0x00, 0x8d, 0x85, 0x0b, 0xd2, + 0x00, 0x8d, 0x88, 0x58, 0x45, 0x00, 0x8d, 0x8a, + 0x04, 0xfd, 0x00, 0x8d, 0x8d, 0x3b, 0x3a, 0x00, + 0x8d, 0x90, 0x58, 0x46, 0x00, 0x8d, 0x91, 0x4d, + 0x7f, 0x00, 0x8d, 0x95, 0x3b, 0x3b, 0x00, 0x8d, + 0x99, 0x1a, 0x85, 0x00, 0x8d, 0x9e, 0x58, 0x47, + 0x00, 0x8d, 0x9f, 0x4d, 0x80, 0x00, 0x8d, 0xa0, + 0x58, 0x48, 0x00, 0x8d, 0xa3, 0x09, 0x1d, 0x00, + 0x8d, 0xa6, 0x3b, 0x3c, 0x00, 0x8d, 0xa8, 0x0a, + 0x3c, 0x00, 0x8d, 0xab, 0x4d, 0x81, 0x00, 0x8d, + 0xac, 0x58, 0x49, 0x00, 0x8d, 0xaf, 0x42, 0xee, + 0x00, 0x8d, 0xb2, 0x4d, 0x82, 0x00, 0x8d, 0xb3, + 0x0b, 0x0d, 0x00, 0x8d, 0xb5, 0x58, 0x4a, 0x00, + 0x8d, 0xb7, 0x58, 0x4b, 0x00, 0x8d, 0xb9, 0x58, + 0x4c, 0x00, 0x8d, 0xba, 0x1a, 0x88, 0x00, 0x8d, + 0xbb, 0x58, 0x4d, 0x00, 0x8d, 0xbc, 0x58, 0x55, + 0x00, 0x8d, 0xbe, 0x1a, 0x87, 0x00, 0x8d, 0xc0, + 0x58, 0x4e, 0x00, 0x8d, 0xc2, 0x1a, 0x86, 0x00, + 0x8d, 0xc5, 0x58, 0x4f, 0x00, 0x8d, 0xc6, 0x3b, + 0x3d, 0x00, 0x8d, 0xc7, 0x58, 0x50, 0x00, 0x8d, + 0xc8, 0x49, 0x21, 0x00, 0x8d, 0xca, 0x58, 0x51, + 0x00, 0x8d, 0xcb, 0x1a, 0x8e, 0x00, 0x8d, 0xcc, + 0x1a, 0x8c, 0x00, 0x8d, 0xce, 0x3b, 0x3e, 0x00, + 0x8d, 0xcf, 0x1a, 0x89, 0x00, 0x8d, 0xd1, 0x42, + 0xef, 0x00, 0x8d, 0xd4, 0x58, 0x52, 0x00, 0x8d, + 0xd5, 0x4d, 0x83, 0x00, 0x8d, 0xd6, 0x1a, 0x8b, + 0x00, 0x8d, 0xd7, 0x42, 0xf0, 0x00, 0x8d, 0xd9, + 0x49, 0x22, 0x00, 0x8d, 0xda, 0x1a, 0x8a, 0x00, + 0x8d, 0xdb, 0x1a, 0x8d, 0x00, 0x8d, 0xdd, 0x06, + 0x91, 0x00, 0x8d, 0xdf, 0x1a, 0x91, 0x00, 0x8d, + 0xe1, 0x0a, 0x7b, 0x00, 0x8d, 0xe3, 0x1a, 0x92, + 0x00, 0x8d, 0xe4, 0x3b, 0x3f, 0x00, 0x8d, 0xe5, + 0x58, 0x53, 0x00, 0x8d, 0xe7, 0x4d, 0x84, 0x00, + 0x8d, 0xe8, 0x07, 0x8d, 0x00, 0x8d, 0xea, 0x1a, + 0x8f, 0x00, 0x8d, 0xeb, 0x1a, 0x90, 0x00, 0x8d, + 0xec, 0x3b, 0x40, 0x00, 0x8d, 0xef, 0x0f, 0xcf, + 0x00, 0x8d, 0xf0, 0x58, 0x54, 0x00, 0x8d, 0xf1, + 0x4d, 0x85, 0x00, 0x8d, 0xf2, 0x4d, 0x86, 0x00, + 0x8d, 0xf3, 0x0b, 0xd3, 0x00, 0x8d, 0xf4, 0x4d, + 0x87, 0x00, 0x8d, 0xf5, 0x0a, 0xab, 0x00, 0x8d, + 0xfc, 0x1a, 0x93, 0x00, 0x8d, 0xfd, 0x49, 0x25, + 0x00, 0x8d, 0xff, 0x1a, 0x96, 0x00, 0x8e, 0x01, + 0x4d, 0x88, 0x00, 0x8e, 0x04, 0x58, 0x56, 0x00, + 0x8e, 0x05, 0x58, 0x57, 0x00, 0x8e, 0x06, 0x49, + 0x26, 0x00, 0x8e, 0x08, 0x1a, 0x94, 0x00, 0x8e, + 0x09, 0x1a, 0x95, 0x00, 0x8e, 0x0a, 0x0f, 0x43, + 0x00, 0x8e, 0x0b, 0x4d, 0x89, 0x00, 0x8e, 0x0c, + 0x49, 0x23, 0x00, 0x8e, 0x0f, 0x0c, 0x7f, 0x00, + 0x8e, 0x10, 0x1a, 0x99, 0x00, 0x8e, 0x11, 0x58, + 0x58, 0x00, 0x8e, 0x14, 0x49, 0x28, 0x00, 0x8e, + 0x16, 0x49, 0x29, 0x00, 0x8e, 0x1d, 0x1a, 0x97, + 0x00, 0x8e, 0x1e, 0x1a, 0x98, 0x00, 0x8e, 0x1f, + 0x1a, 0x9a, 0x00, 0x8e, 0x20, 0x3b, 0x41, 0x00, + 0x8e, 0x21, 0x49, 0x2a, 0x00, 0x8e, 0x22, 0x49, + 0x2b, 0x00, 0x8e, 0x23, 0x42, 0xf1, 0x00, 0x8e, + 0x26, 0x4d, 0x8a, 0x00, 0x8e, 0x27, 0x49, 0x2c, + 0x00, 0x8e, 0x2a, 0x1a, 0xa8, 0x00, 0x8e, 0x30, + 0x1a, 0x9d, 0x00, 0x8e, 0x31, 0x4d, 0x8b, 0x00, + 0x8e, 0x33, 0x58, 0x59, 0x00, 0x8e, 0x34, 0x1a, + 0x9e, 0x00, 0x8e, 0x35, 0x1a, 0x9c, 0x00, 0x8e, + 0x36, 0x49, 0x2f, 0x00, 0x8e, 0x37, 0x58, 0x5a, + 0x00, 0x8e, 0x38, 0x58, 0x5b, 0x00, 0x8e, 0x39, + 0x49, 0x30, 0x00, 0x8e, 0x3d, 0x42, 0xf2, 0x00, + 0x8e, 0x40, 0x4d, 0x8c, 0x00, 0x8e, 0x41, 0x4d, + 0x8d, 0x00, 0x8e, 0x42, 0x1a, 0x9b, 0x00, 0x8e, + 0x44, 0x0c, 0x19, 0x00, 0x8e, 0x47, 0x1a, 0xa0, + 0x00, 0x8e, 0x48, 0x1a, 0xa4, 0x00, 0x8e, 0x49, + 0x1a, 0xa1, 0x00, 0x8e, 0x4a, 0x1a, 0x9f, 0x00, + 0x8e, 0x4b, 0x3b, 0x42, 0x00, 0x8e, 0x4c, 0x1a, + 0xa2, 0x00, 0x8e, 0x4d, 0x4d, 0x8e, 0x00, 0x8e, + 0x4e, 0x58, 0x5c, 0x00, 0x8e, 0x4f, 0x4d, 0x8f, + 0x00, 0x8e, 0x50, 0x1a, 0xa3, 0x00, 0x8e, 0x54, + 0x49, 0x31, 0x00, 0x8e, 0x55, 0x1a, 0xaa, 0x00, + 0x8e, 0x59, 0x1a, 0xa5, 0x00, 0x8e, 0x5b, 0x58, + 0x5d, 0x00, 0x8e, 0x5c, 0x4d, 0x90, 0x00, 0x8e, + 0x5d, 0x58, 0x5e, 0x00, 0x8e, 0x5e, 0x58, 0x5f, + 0x00, 0x8e, 0x5f, 0x0a, 0x7c, 0x00, 0x8e, 0x60, + 0x1a, 0xa7, 0x00, 0x8e, 0x61, 0x4d, 0x91, 0x00, + 0x8e, 0x62, 0x49, 0x32, 0x00, 0x8e, 0x63, 0x1a, + 0xa9, 0x00, 0x8e, 0x64, 0x1a, 0xa6, 0x00, 0x8e, + 0x69, 0x4d, 0x92, 0x00, 0x8e, 0x6c, 0x3b, 0x43, + 0x00, 0x8e, 0x6d, 0x49, 0x33, 0x00, 0x8e, 0x6f, + 0x49, 0x34, 0x00, 0x8e, 0x70, 0x3b, 0x44, 0x00, + 0x8e, 0x71, 0x4d, 0x93, 0x00, 0x8e, 0x72, 0x1a, + 0xac, 0x00, 0x8e, 0x74, 0x09, 0x3d, 0x00, 0x8e, + 0x75, 0x4d, 0x94, 0x00, 0x8e, 0x76, 0x1a, 0xab, + 0x00, 0x8e, 0x77, 0x4d, 0x95, 0x00, 0x8e, 0x79, + 0x58, 0x60, 0x00, 0x8e, 0x7a, 0x3b, 0x45, 0x00, + 0x8e, 0x7b, 0x42, 0xf3, 0x00, 0x8e, 0x7c, 0x1a, + 0xad, 0x00, 0x8e, 0x81, 0x1a, 0xae, 0x00, 0x8e, + 0x82, 0x58, 0x61, 0x00, 0x8e, 0x83, 0x58, 0x62, + 0x00, 0x8e, 0x84, 0x1a, 0xb1, 0x00, 0x8e, 0x85, + 0x1a, 0xb0, 0x00, 0x8e, 0x87, 0x1a, 0xaf, 0x00, + 0x8e, 0x89, 0x4d, 0x96, 0x00, 0x8e, 0x8a, 0x1a, + 0xb3, 0x00, 0x8e, 0x8b, 0x1a, 0xb2, 0x00, 0x8e, + 0x8d, 0x0f, 0x02, 0x00, 0x8e, 0x90, 0x4d, 0x97, + 0x00, 0x8e, 0x91, 0x1a, 0xb5, 0x00, 0x8e, 0x92, + 0x3b, 0x46, 0x00, 0x8e, 0x93, 0x1a, 0xb4, 0x00, + 0x8e, 0x94, 0x1a, 0xb6, 0x00, 0x8e, 0x95, 0x4d, + 0x98, 0x00, 0x8e, 0x98, 0x49, 0x35, 0x00, 0x8e, + 0x99, 0x1a, 0xb7, 0x00, 0x8e, 0x9a, 0x4d, 0x99, + 0x00, 0x8e, 0x9b, 0x58, 0x63, 0x00, 0x8e, 0x9d, + 0x58, 0x64, 0x00, 0x8e, 0x9e, 0x49, 0x36, 0x00, + 0x8e, 0xa1, 0x1a, 0xb9, 0x00, 0x8e, 0xa2, 0x58, + 0x65, 0x00, 0x8e, 0xa7, 0x4d, 0x9a, 0x00, 0x8e, + 0xa9, 0x4d, 0x9b, 0x00, 0x8e, 0xaa, 0x1a, 0xb8, + 0x00, 0x8e, 0xab, 0x0a, 0x0e, 0x00, 0x8e, 0xac, + 0x1a, 0xba, 0x00, 0x8e, 0xad, 0x4d, 0x9c, 0x00, + 0x8e, 0xae, 0x3b, 0x47, 0x00, 0x8e, 0xaf, 0x06, + 0xe5, 0x00, 0x8e, 0xb0, 0x1a, 0xbb, 0x00, 0x8e, + 0xb1, 0x1a, 0xbd, 0x00, 0x8e, 0xb3, 0x3b, 0x48, + 0x00, 0x8e, 0xb5, 0x49, 0x37, 0x00, 0x8e, 0xb6, + 0x37, 0x03, 0x00, 0x8e, 0xba, 0x58, 0x66, 0x00, + 0x8e, 0xbb, 0x49, 0x38, 0x00, 0x8e, 0xbe, 0x1a, + 0xbe, 0x00, 0x8e, 0xc0, 0x1d, 0xef, 0x00, 0x8e, + 0xc1, 0x58, 0x67, 0x00, 0x8e, 0xc3, 0x58, 0x68, + 0x00, 0x8e, 0xc4, 0x58, 0x69, 0x00, 0x8e, 0xc5, + 0x1a, 0xbf, 0x00, 0x8e, 0xc6, 0x1a, 0xbc, 0x00, + 0x8e, 0xc7, 0x58, 0x6a, 0x00, 0x8e, 0xc8, 0x1a, + 0xc0, 0x00, 0x8e, 0xca, 0x09, 0x02, 0x00, 0x8e, + 0xcb, 0x1a, 0xc1, 0x00, 0x8e, 0xcc, 0x06, 0x4a, + 0x00, 0x8e, 0xcd, 0x07, 0x09, 0x00, 0x8e, 0xcf, + 0x21, 0xb7, 0x00, 0x8e, 0xd1, 0x3b, 0x49, 0x00, + 0x8e, 0xd2, 0x07, 0x62, 0x00, 0x8e, 0xd4, 0x4e, + 0x62, 0x00, 0x8e, 0xdb, 0x1a, 0xc2, 0x00, 0x8e, + 0xdc, 0x58, 0x6b, 0x00, 0x8e, 0xdf, 0x0c, 0xc8, + 0x00, 0x8e, 0xe2, 0x0c, 0x38, 0x00, 0x8e, 0xe3, + 0x1a, 0xc3, 0x00, 0x8e, 0xe8, 0x4d, 0x9d, 0x00, + 0x8e, 0xeb, 0x1a, 0xc6, 0x00, 0x8e, 0xed, 0x58, + 0x6f, 0x00, 0x8e, 0xee, 0x58, 0x6c, 0x00, 0x8e, + 0xf0, 0x4d, 0x9e, 0x00, 0x8e, 0xf1, 0x58, 0x6d, + 0x00, 0x8e, 0xf7, 0x58, 0x6e, 0x00, 0x8e, 0xf8, + 0x08, 0xe0, 0x00, 0x8e, 0xf9, 0x3b, 0x4b, 0x00, + 0x8e, 0xfa, 0x42, 0xf6, 0x00, 0x8e, 0xfb, 0x1a, + 0xc5, 0x00, 0x8e, 0xfc, 0x1a, 0xc4, 0x00, 0x8e, + 0xfd, 0x07, 0x30, 0x00, 0x8e, 0xfe, 0x1a, 0xc7, + 0x00, 0x8f, 0x00, 0x49, 0x3c, 0x00, 0x8f, 0x02, + 0x58, 0x70, 0x00, 0x8f, 0x03, 0x05, 0xb1, 0x00, + 0x8f, 0x05, 0x1a, 0xc9, 0x00, 0x8f, 0x07, 0x4d, + 0x9f, 0x00, 0x8f, 0x08, 0x49, 0x3d, 0x00, 0x8f, + 0x09, 0x08, 0x4c, 0x00, 0x8f, 0x0a, 0x1a, 0xc8, + 0x00, 0x8f, 0x0c, 0x1a, 0xd1, 0x00, 0x8f, 0x0f, + 0x58, 0x71, 0x00, 0x8f, 0x10, 0x58, 0x72, 0x00, + 0x8f, 0x12, 0x1a, 0xcb, 0x00, 0x8f, 0x13, 0x1a, + 0xcd, 0x00, 0x8f, 0x14, 0x0e, 0x35, 0x00, 0x8f, + 0x15, 0x1a, 0xca, 0x00, 0x8f, 0x16, 0x58, 0x73, + 0x00, 0x8f, 0x17, 0x3b, 0x4c, 0x00, 0x8f, 0x18, + 0x4d, 0xa0, 0x00, 0x8f, 0x19, 0x1a, 0xcc, 0x00, + 0x8f, 0x1b, 0x1a, 0xd0, 0x00, 0x8f, 0x1c, 0x1a, + 0xce, 0x00, 0x8f, 0x1d, 0x06, 0x4b, 0x00, 0x8f, + 0x1e, 0x42, 0xf7, 0x00, 0x8f, 0x1f, 0x1a, 0xcf, + 0x00, 0x8f, 0x20, 0x58, 0x74, 0x00, 0x8f, 0x21, + 0x58, 0x75, 0x00, 0x8f, 0x23, 0x58, 0x76, 0x00, + 0x8f, 0x25, 0x4d, 0xa1, 0x00, 0x8f, 0x26, 0x1a, + 0xd2, 0x00, 0x8f, 0x27, 0x4d, 0xa2, 0x00, 0x8f, + 0x28, 0x58, 0x77, 0x00, 0x8f, 0x29, 0x0d, 0x10, + 0x00, 0x8f, 0x2a, 0x0f, 0xa0, 0x00, 0x8f, 0x2b, + 0x49, 0x3e, 0x00, 0x8f, 0x2c, 0x4d, 0xa3, 0x00, + 0x8f, 0x2d, 0x42, 0xf8, 0x00, 0x8f, 0x2e, 0x58, + 0x78, 0x00, 0x8f, 0x2f, 0x09, 0x3e, 0x00, 0x8f, + 0x33, 0x1a, 0xd3, 0x00, 0x8f, 0x34, 0x58, 0x79, + 0x00, 0x8f, 0x35, 0x4d, 0xa4, 0x00, 0x8f, 0x36, + 0x3b, 0x4d, 0x00, 0x8f, 0x37, 0x58, 0x7a, 0x00, + 0x8f, 0x38, 0x0f, 0x0c, 0x00, 0x8f, 0x39, 0x1a, + 0xd5, 0x00, 0x8f, 0x3a, 0x4d, 0xa5, 0x00, 0x8f, + 0x3b, 0x1a, 0xd4, 0x00, 0x8f, 0x3e, 0x1a, 0xd8, + 0x00, 0x8f, 0x3f, 0x0f, 0x2b, 0x00, 0x8f, 0x40, + 0x49, 0x3f, 0x00, 0x8f, 0x41, 0x58, 0x7b, 0x00, + 0x8f, 0x42, 0x1a, 0xd7, 0x00, 0x8f, 0x43, 0x4d, + 0xa6, 0x00, 0x8f, 0x44, 0x05, 0xcb, 0x00, 0x8f, + 0x45, 0x1a, 0xd6, 0x00, 0x8f, 0x46, 0x1a, 0xdb, + 0x00, 0x8f, 0x47, 0x4d, 0xa7, 0x00, 0x8f, 0x49, + 0x1a, 0xda, 0x00, 0x8f, 0x4a, 0x49, 0x40, 0x00, + 0x8f, 0x4c, 0x1a, 0xd9, 0x00, 0x8f, 0x4d, 0x0c, + 0x2c, 0x00, 0x8f, 0x4e, 0x1a, 0xdc, 0x00, 0x8f, + 0x4f, 0x58, 0x7c, 0x00, 0x8f, 0x51, 0x4d, 0xa8, + 0x00, 0x8f, 0x52, 0x58, 0x7d, 0x00, 0x8f, 0x53, + 0x58, 0x7e, 0x00, 0x8f, 0x54, 0x42, 0xf9, 0x00, + 0x8f, 0x55, 0x4d, 0xa9, 0x00, 0x8f, 0x57, 0x1a, + 0xdd, 0x00, 0x8f, 0x58, 0x49, 0x41, 0x00, 0x8f, + 0x5c, 0x1a, 0xde, 0x00, 0x8f, 0x5d, 0x58, 0x7f, + 0x00, 0x8f, 0x5e, 0x58, 0x80, 0x00, 0x8f, 0x5f, + 0x07, 0xfe, 0x00, 0x8f, 0x61, 0x06, 0xfb, 0x00, + 0x8f, 0x62, 0x1a, 0xdf, 0x00, 0x8f, 0x63, 0x1a, + 0xe0, 0x00, 0x8f, 0x64, 0x1a, 0xe1, 0x00, 0x8f, + 0x65, 0x58, 0x81, 0x00, 0x8f, 0x9b, 0x0a, 0x0f, + 0x00, 0x8f, 0x9c, 0x1a, 0xe2, 0x00, 0x8f, 0x9d, + 0x58, 0x82, 0x00, 0x8f, 0x9e, 0x08, 0xd9, 0x00, + 0x8f, 0x9f, 0x1a, 0xe3, 0x00, 0x8f, 0xa0, 0x4d, + 0xaa, 0x00, 0x8f, 0xa1, 0x4d, 0xab, 0x00, 0x8f, + 0xa2, 0x4d, 0xac, 0x00, 0x8f, 0xa3, 0x1a, 0xe4, + 0x00, 0x8f, 0xa4, 0x49, 0x43, 0x00, 0x8f, 0xa5, + 0x4d, 0xad, 0x00, 0x8f, 0xa6, 0x3b, 0x4e, 0x00, + 0x8f, 0xa7, 0x10, 0xb6, 0x00, 0x8f, 0xa8, 0x10, + 0xb5, 0x00, 0x8f, 0xad, 0x1a, 0xe5, 0x00, 0x8f, + 0xae, 0x17, 0xff, 0x00, 0x8f, 0xaf, 0x1a, 0xe6, + 0x00, 0x8f, 0xb0, 0x0b, 0x62, 0x00, 0x8f, 0xb1, + 0x09, 0xf1, 0x00, 0x8f, 0xb2, 0x0c, 0xf6, 0x00, + 0x8f, 0xb4, 0x49, 0x44, 0x00, 0x8f, 0xb5, 0x3b, + 0x4f, 0x00, 0x8f, 0xb6, 0x3b, 0x50, 0x00, 0x8f, + 0xb7, 0x1a, 0xe7, 0x00, 0x8f, 0xb8, 0x58, 0x83, + 0x00, 0x8f, 0xba, 0x0e, 0x25, 0x00, 0x8f, 0xbb, + 0x0b, 0xf0, 0x00, 0x8f, 0xbc, 0x08, 0x10, 0x00, + 0x8f, 0xbe, 0x58, 0x84, 0x00, 0x8f, 0xbf, 0x0b, + 0x67, 0x00, 0x8f, 0xc0, 0x58, 0x85, 0x00, 0x8f, + 0xc1, 0x49, 0x46, 0x00, 0x8f, 0xc2, 0x04, 0xcc, + 0x00, 0x8f, 0xc4, 0x0e, 0xa6, 0x00, 0x8f, 0xc5, + 0x0a, 0x1d, 0x00, 0x8f, 0xc6, 0x49, 0x47, 0x00, + 0x8f, 0xc8, 0x37, 0x99, 0x00, 0x8f, 0xca, 0x49, + 0x49, 0x00, 0x8f, 0xcb, 0x58, 0x86, 0x00, 0x8f, + 0xcd, 0x49, 0x4a, 0x00, 0x8f, 0xce, 0x07, 0x34, + 0x00, 0x8f, 0xd0, 0x58, 0x87, 0x00, 0x8f, 0xd1, + 0x06, 0xd9, 0x00, 0x8f, 0xd2, 0x58, 0x88, 0x00, + 0x8f, 0xd3, 0x49, 0x4b, 0x00, 0x8f, 0xd4, 0x0e, + 0x26, 0x00, 0x8f, 0xd5, 0x49, 0x4c, 0x00, 0x8f, + 0xda, 0x1a, 0xe8, 0x00, 0x8f, 0xe0, 0x3b, 0x52, + 0x00, 0x8f, 0xe2, 0x1a, 0xea, 0x00, 0x8f, 0xe3, + 0x58, 0x89, 0x00, 0x8f, 0xe4, 0x3b, 0x53, 0x00, + 0x8f, 0xe5, 0x1a, 0xe9, 0x00, 0x8f, 0xe6, 0x05, + 0x60, 0x00, 0x8f, 0xe8, 0x42, 0xfb, 0x00, 0x8f, + 0xe9, 0x0c, 0xce, 0x00, 0x8f, 0xea, 0x1a, 0xeb, + 0x00, 0x8f, 0xeb, 0x0d, 0x2d, 0x00, 0x8f, 0xed, + 0x0c, 0x2d, 0x00, 0x8f, 0xee, 0x42, 0xfc, 0x00, + 0x8f, 0xef, 0x1a, 0xec, 0x00, 0x8f, 0xf0, 0x09, + 0x5c, 0x00, 0x8f, 0xf1, 0x49, 0x4d, 0x00, 0x8f, + 0xf4, 0x1a, 0xee, 0x00, 0x8f, 0xf5, 0x49, 0x4e, + 0x00, 0x8f, 0xf6, 0x3b, 0x54, 0x00, 0x8f, 0xf7, + 0x0e, 0xce, 0x00, 0x8f, 0xf8, 0x1a, 0xfd, 0x00, + 0x8f, 0xf9, 0x1a, 0xf0, 0x00, 0x8f, 0xfa, 0x1a, + 0xf1, 0x00, 0x8f, 0xfb, 0x49, 0x4f, 0x00, 0x8f, + 0xfd, 0x0b, 0xe5, 0x00, 0x8f, 0xfe, 0x58, 0x8a, + 0x00, 0x90, 0x00, 0x0b, 0x40, 0x00, 0x90, 0x01, + 0x0a, 0xf9, 0x00, 0x90, 0x02, 0x3b, 0x55, 0x00, + 0x90, 0x03, 0x0c, 0x80, 0x00, 0x90, 0x04, 0x4d, + 0xae, 0x00, 0x90, 0x05, 0x1a, 0xef, 0x00, 0x90, + 0x06, 0x06, 0x6f, 0x00, 0x90, 0x08, 0x42, 0xfd, + 0x00, 0x90, 0x0b, 0x1a, 0xf8, 0x00, 0x90, 0x0c, + 0x49, 0x50, 0x00, 0x90, 0x0d, 0x1a, 0xf5, 0x00, + 0x90, 0x0e, 0x1b, 0x02, 0x00, 0x90, 0x0f, 0x0c, + 0x81, 0x00, 0x90, 0x10, 0x0b, 0x9e, 0x00, 0x90, + 0x11, 0x1a, 0xf2, 0x00, 0x90, 0x13, 0x0c, 0x1a, + 0x00, 0x90, 0x14, 0x0c, 0x4d, 0x00, 0x90, 0x15, + 0x1a, 0xf3, 0x00, 0x90, 0x16, 0x1a, 0xf7, 0x00, + 0x90, 0x17, 0x0a, 0x26, 0x00, 0x90, 0x18, 0x58, + 0x8b, 0x00, 0x90, 0x19, 0x0d, 0x1d, 0x00, 0x90, + 0x1a, 0x0b, 0xe8, 0x00, 0x90, 0x1b, 0x4d, 0xaf, + 0x00, 0x90, 0x1d, 0x0a, 0x66, 0x00, 0x90, 0x1e, + 0x1a, 0xf6, 0x00, 0x90, 0x1f, 0x0b, 0x0e, 0x00, + 0x90, 0x20, 0x0b, 0x04, 0x00, 0x90, 0x21, 0x1a, + 0xf4, 0x00, 0x90, 0x22, 0x04, 0x6d, 0x00, 0x90, + 0x23, 0x37, 0x11, 0x00, 0x90, 0x27, 0x1a, 0xf9, + 0x00, 0x90, 0x28, 0x58, 0x8c, 0x00, 0x90, 0x29, + 0x58, 0x8d, 0x00, 0x90, 0x2a, 0x58, 0x8e, 0x00, + 0x90, 0x2c, 0x3b, 0x56, 0x00, 0x90, 0x2d, 0x42, + 0xfe, 0x00, 0x90, 0x2e, 0x0b, 0x41, 0x00, 0x90, + 0x2f, 0x4d, 0xb0, 0x00, 0x90, 0x31, 0x09, 0x3f, + 0x00, 0x90, 0x32, 0x0a, 0x10, 0x00, 0x90, 0x33, + 0x58, 0x8f, 0x00, 0x90, 0x34, 0x58, 0x90, 0x00, + 0x90, 0x35, 0x1a, 0xfb, 0x00, 0x90, 0x36, 0x1a, + 0xfa, 0x00, 0x90, 0x37, 0x49, 0x51, 0x00, 0x90, + 0x38, 0x04, 0xb3, 0x00, 0x90, 0x39, 0x1a, 0xfc, + 0x00, 0x90, 0x3c, 0x0d, 0xa1, 0x00, 0x90, 0x3e, + 0x1b, 0x04, 0x00, 0x90, 0x3f, 0x58, 0x91, 0x00, + 0x90, 0x41, 0x0c, 0xb3, 0x00, 0x90, 0x42, 0x0a, + 0x31, 0x00, 0x90, 0x43, 0x49, 0x53, 0x00, 0x90, + 0x44, 0x3b, 0x57, 0x00, 0x90, 0x45, 0x0b, 0x97, + 0x00, 0x90, 0x47, 0x06, 0xf0, 0x00, 0x90, 0x49, + 0x1b, 0x03, 0x00, 0x90, 0x4a, 0x0f, 0x21, 0x00, + 0x90, 0x4b, 0x04, 0xe1, 0x00, 0x90, 0x4c, 0x4d, + 0xb1, 0x00, 0x90, 0x4d, 0x0e, 0x27, 0x00, 0x90, + 0x4e, 0x05, 0x61, 0x00, 0x90, 0x4f, 0x1a, 0xfe, + 0x00, 0x90, 0x50, 0x1a, 0xff, 0x00, 0x90, 0x51, + 0x1b, 0x00, 0x00, 0x90, 0x52, 0x1b, 0x01, 0x00, + 0x90, 0x53, 0x0c, 0x93, 0x00, 0x90, 0x54, 0x0b, + 0x61, 0x00, 0x90, 0x55, 0x04, 0xa7, 0x00, 0x90, + 0x56, 0x1b, 0x05, 0x00, 0x90, 0x58, 0x1b, 0x06, + 0x00, 0x90, 0x59, 0x1d, 0x34, 0x00, 0x90, 0x5b, + 0x4d, 0xb2, 0x00, 0x90, 0x5c, 0x0b, 0x1d, 0x00, + 0x90, 0x5d, 0x49, 0x54, 0x00, 0x90, 0x5e, 0x1b, + 0x07, 0x00, 0x90, 0x60, 0x05, 0x15, 0x00, 0x90, + 0x61, 0x0a, 0xce, 0x00, 0x90, 0x62, 0x58, 0x92, + 0x00, 0x90, 0x63, 0x07, 0x63, 0x00, 0x90, 0x65, + 0x0f, 0x44, 0x00, 0x90, 0x66, 0x58, 0x93, 0x00, + 0x90, 0x67, 0x21, 0xba, 0x00, 0x90, 0x68, 0x1b, + 0x08, 0x00, 0x90, 0x69, 0x0c, 0x26, 0x00, 0x90, + 0x6c, 0x58, 0x94, 0x00, 0x90, 0x6d, 0x0a, 0xfa, + 0x00, 0x90, 0x6e, 0x09, 0x03, 0x00, 0x90, 0x6f, + 0x1b, 0x09, 0x00, 0x90, 0x70, 0x4d, 0xb3, 0x00, + 0x90, 0x72, 0x1b, 0x0c, 0x00, 0x90, 0x74, 0x4d, + 0xb4, 0x00, 0x90, 0x75, 0x09, 0x6f, 0x00, 0x90, + 0x76, 0x1b, 0x0a, 0x00, 0x90, 0x77, 0x0a, 0xad, + 0x00, 0x90, 0x78, 0x0a, 0xac, 0x00, 0x90, 0x79, + 0x4d, 0xb5, 0x00, 0x90, 0x7a, 0x04, 0xa8, 0x00, + 0x90, 0x7c, 0x0f, 0x93, 0x00, 0x90, 0x7d, 0x1b, + 0x0e, 0x00, 0x90, 0x7f, 0x0d, 0x86, 0x00, 0x90, + 0x80, 0x1b, 0x10, 0x00, 0x90, 0x81, 0x1b, 0x0f, + 0x00, 0x90, 0x82, 0x1b, 0x0d, 0x00, 0x90, 0x83, + 0x17, 0x37, 0x00, 0x90, 0x84, 0x06, 0x10, 0x00, + 0x90, 0x85, 0x49, 0x57, 0x00, 0x90, 0x87, 0x1a, + 0xed, 0x00, 0x90, 0x88, 0x3b, 0x58, 0x00, 0x90, + 0x89, 0x1b, 0x12, 0x00, 0x90, 0x8a, 0x1b, 0x11, + 0x00, 0x90, 0x8b, 0x4d, 0xb6, 0x00, 0x90, 0x8c, + 0x49, 0x58, 0x00, 0x90, 0x8e, 0x58, 0x95, 0x00, + 0x90, 0x8f, 0x1b, 0x13, 0x00, 0x90, 0x90, 0x49, + 0x59, 0x00, 0x90, 0x91, 0x0f, 0x22, 0x00, 0x90, + 0x95, 0x3b, 0x59, 0x00, 0x90, 0x97, 0x42, 0xff, + 0x00, 0x90, 0x98, 0x4d, 0xb7, 0x00, 0x90, 0x99, + 0x3b, 0x5a, 0x00, 0x90, 0x9b, 0x3b, 0x5b, 0x00, + 0x90, 0xa0, 0x4d, 0xb8, 0x00, 0x90, 0xa1, 0x49, + 0x5a, 0x00, 0x90, 0xa2, 0x3b, 0x5c, 0x00, 0x90, + 0xa3, 0x0c, 0xb9, 0x00, 0x90, 0xa5, 0x58, 0x96, + 0x00, 0x90, 0xa6, 0x0e, 0x5c, 0x00, 0x90, 0xa8, + 0x1b, 0x14, 0x00, 0x90, 0xaa, 0x09, 0x05, 0x00, + 0x90, 0xaf, 0x1b, 0x15, 0x00, 0x90, 0xb0, 0x49, + 0x5c, 0x00, 0x90, 0xb1, 0x1b, 0x16, 0x00, 0x90, + 0xb2, 0x4d, 0xb9, 0x00, 0x90, 0xb3, 0x43, 0x00, + 0x00, 0x90, 0xb4, 0x3b, 0x5d, 0x00, 0x90, 0xb5, + 0x1b, 0x17, 0x00, 0x90, 0xb6, 0x49, 0x5d, 0x00, + 0x90, 0xb8, 0x0c, 0x1b, 0x00, 0x90, 0xbd, 0x4d, + 0xba, 0x00, 0x90, 0xbe, 0x43, 0x01, 0x00, 0x90, + 0xc1, 0x04, 0xae, 0x00, 0x90, 0xc3, 0x49, 0x5e, + 0x00, 0x90, 0xc4, 0x43, 0x02, 0x00, 0x90, 0xc5, + 0x43, 0x03, 0x00, 0x90, 0xc7, 0x43, 0x04, 0x00, + 0x90, 0xc8, 0x49, 0x5f, 0x00, 0x90, 0xc9, 0x4d, + 0xbb, 0x00, 0x90, 0xca, 0x07, 0xeb, 0x00, 0x90, + 0xcc, 0x58, 0x97, 0x00, 0x90, 0xce, 0x0f, 0xe0, + 0x00, 0x90, 0xd2, 0x58, 0x9c, 0x00, 0x90, 0xd5, + 0x58, 0x98, 0x00, 0x90, 0xd7, 0x3b, 0x5e, 0x00, + 0x90, 0xd8, 0x58, 0x99, 0x00, 0x90, 0xd9, 0x58, + 0x9a, 0x00, 0x90, 0xdb, 0x1b, 0x1b, 0x00, 0x90, + 0xdc, 0x49, 0x61, 0x00, 0x90, 0xdd, 0x3b, 0x5f, + 0x00, 0x90, 0xde, 0x21, 0xbb, 0x00, 0x90, 0xdf, + 0x49, 0x62, 0x00, 0x90, 0xe1, 0x07, 0x0a, 0x00, + 0x90, 0xe2, 0x1b, 0x18, 0x00, 0x90, 0xe4, 0x1b, + 0x19, 0x00, 0x90, 0xe5, 0x58, 0x9b, 0x00, 0x90, + 0xe8, 0x0d, 0xe6, 0x00, 0x90, 0xeb, 0x49, 0x67, + 0x00, 0x90, 0xed, 0x05, 0xb2, 0x00, 0x90, 0xef, + 0x43, 0x05, 0x00, 0x90, 0xf0, 0x4d, 0xbc, 0x00, + 0x90, 0xf2, 0x49, 0x65, 0x00, 0x90, 0xf4, 0x3b, + 0x60, 0x00, 0x90, 0xf5, 0x0f, 0x23, 0x00, 0x90, + 0xf6, 0x49, 0x64, 0x00, 0x90, 0xf7, 0x06, 0xb7, + 0x00, 0x90, 0xfd, 0x21, 0xbc, 0x00, 0x90, 0xfe, + 0x49, 0x68, 0x00, 0x90, 0xff, 0x49, 0x69, 0x00, + 0x91, 0x00, 0x49, 0x66, 0x00, 0x91, 0x02, 0x1b, + 0x1c, 0x00, 0x91, 0x04, 0x49, 0x6a, 0x00, 0x91, + 0x05, 0x4d, 0xbd, 0x00, 0x91, 0x06, 0x49, 0x6b, + 0x00, 0x91, 0x08, 0x58, 0x9d, 0x00, 0x91, 0x0d, + 0x58, 0x9e, 0x00, 0x91, 0x10, 0x58, 0x9f, 0x00, + 0x91, 0x12, 0x1b, 0x1d, 0x00, 0x91, 0x14, 0x43, + 0x06, 0x00, 0x91, 0x15, 0x21, 0xbd, 0x00, 0x91, + 0x16, 0x43, 0x07, 0x00, 0x91, 0x17, 0x3b, 0x61, + 0x00, 0x91, 0x18, 0x49, 0x6c, 0x00, 0x91, 0x19, + 0x1b, 0x1e, 0x00, 0x91, 0x1a, 0x58, 0xa0, 0x00, + 0x91, 0x1c, 0x3b, 0x62, 0x00, 0x91, 0x1e, 0x49, + 0x6d, 0x00, 0x91, 0x20, 0x58, 0xa1, 0x00, 0x91, + 0x22, 0x43, 0x08, 0x00, 0x91, 0x23, 0x43, 0x09, + 0x00, 0x91, 0x25, 0x4d, 0xbe, 0x00, 0x91, 0x27, + 0x21, 0xbe, 0x00, 0x91, 0x29, 0x58, 0xa2, 0x00, + 0x91, 0x2d, 0x0c, 0x1c, 0x00, 0x91, 0x2e, 0x58, + 0xa3, 0x00, 0x91, 0x2f, 0x43, 0x0a, 0x00, 0x91, + 0x30, 0x1b, 0x20, 0x00, 0x91, 0x31, 0x3b, 0x63, + 0x00, 0x91, 0x32, 0x1b, 0x1f, 0x00, 0x91, 0x34, + 0x43, 0x0b, 0x00, 0x91, 0x36, 0x58, 0xa4, 0x00, + 0x91, 0x37, 0x49, 0x6e, 0x00, 0x91, 0x39, 0x49, + 0x6f, 0x00, 0x91, 0x3a, 0x3b, 0x64, 0x00, 0x91, + 0x3c, 0x58, 0xa5, 0x00, 0x91, 0x3d, 0x3b, 0x65, + 0x00, 0x91, 0x43, 0x58, 0xa6, 0x00, 0x91, 0x46, + 0x49, 0x70, 0x00, 0x91, 0x47, 0x49, 0x71, 0x00, + 0x91, 0x48, 0x3b, 0x66, 0x00, 0x91, 0x49, 0x0c, + 0xab, 0x00, 0x91, 0x4a, 0x1b, 0x21, 0x00, 0x91, + 0x4b, 0x09, 0x40, 0x00, 0x91, 0x4c, 0x09, 0x0c, + 0x00, 0x91, 0x4d, 0x0d, 0x11, 0x00, 0x91, 0x4e, + 0x0b, 0xaf, 0x00, 0x91, 0x4f, 0x58, 0xa7, 0x00, + 0x91, 0x52, 0x09, 0x1e, 0x00, 0x91, 0x53, 0x58, + 0xa8, 0x00, 0x91, 0x54, 0x0a, 0x32, 0x00, 0x91, + 0x56, 0x1b, 0x22, 0x00, 0x91, 0x57, 0x49, 0x72, + 0x00, 0x91, 0x58, 0x1b, 0x23, 0x00, 0x91, 0x59, + 0x49, 0x73, 0x00, 0x91, 0x5a, 0x4d, 0xbf, 0x00, + 0x91, 0x5b, 0x3b, 0x67, 0x00, 0x91, 0x61, 0x3b, + 0x68, 0x00, 0x91, 0x62, 0x0a, 0x23, 0x00, 0x91, + 0x63, 0x1b, 0x24, 0x00, 0x91, 0x64, 0x3b, 0x69, + 0x00, 0x91, 0x65, 0x1b, 0x25, 0x00, 0x91, 0x67, + 0x4d, 0xc0, 0x00, 0x91, 0x69, 0x1b, 0x26, 0x00, + 0x91, 0x6a, 0x0f, 0x59, 0x00, 0x91, 0x6c, 0x09, + 0x41, 0x00, 0x91, 0x6d, 0x58, 0xa9, 0x00, 0x91, + 0x72, 0x1b, 0x28, 0x00, 0x91, 0x73, 0x1b, 0x27, + 0x00, 0x91, 0x74, 0x49, 0x74, 0x00, 0x91, 0x75, + 0x07, 0xec, 0x00, 0x91, 0x77, 0x08, 0x05, 0x00, + 0x91, 0x78, 0x08, 0x8e, 0x00, 0x91, 0x79, 0x49, + 0x75, 0x00, 0x91, 0x7a, 0x4d, 0xc1, 0x00, 0x91, + 0x7b, 0x58, 0xaa, 0x00, 0x91, 0x81, 0x58, 0xab, + 0x00, 0x91, 0x82, 0x1b, 0x2b, 0x00, 0x91, 0x83, + 0x43, 0x0c, 0x00, 0x91, 0x85, 0x49, 0x76, 0x00, + 0x91, 0x86, 0x58, 0xac, 0x00, 0x91, 0x87, 0x09, + 0x70, 0x00, 0x91, 0x89, 0x1b, 0x2a, 0x00, 0x91, + 0x8a, 0x4d, 0xc2, 0x00, 0x91, 0x8b, 0x1b, 0x29, + 0x00, 0x91, 0x8d, 0x0b, 0x49, 0x00, 0x91, 0x8e, + 0x3b, 0x6a, 0x00, 0x91, 0x90, 0x07, 0xa3, 0x00, + 0x91, 0x91, 0x4d, 0xc3, 0x00, 0x91, 0x92, 0x0a, + 0x67, 0x00, 0x91, 0x93, 0x58, 0xad, 0x00, 0x91, + 0x94, 0x58, 0xae, 0x00, 0x91, 0x95, 0x4d, 0xc4, + 0x00, 0x91, 0x97, 0x0d, 0x44, 0x00, 0x91, 0x98, + 0x58, 0xaf, 0x00, 0x91, 0x9c, 0x09, 0x43, 0x00, + 0x91, 0x9e, 0x3b, 0x6b, 0x00, 0x91, 0xa1, 0x58, + 0xb0, 0x00, 0x91, 0xa2, 0x1b, 0x2c, 0x00, 0x91, + 0xa4, 0x09, 0xc7, 0x00, 0x91, 0xa6, 0x58, 0xb1, + 0x00, 0x91, 0xa8, 0x3b, 0x6c, 0x00, 0x91, 0xaa, + 0x1b, 0x2f, 0x00, 0x91, 0xab, 0x1b, 0x2d, 0x00, + 0x91, 0xac, 0x1e, 0x1b, 0x00, 0x91, 0xad, 0x3b, + 0x6d, 0x00, 0x91, 0xae, 0x3b, 0x6e, 0x00, 0x91, + 0xaf, 0x1b, 0x2e, 0x00, 0x91, 0xb0, 0x4d, 0xc5, + 0x00, 0x91, 0xb1, 0x1e, 0x61, 0x00, 0x91, 0xb2, + 0x3b, 0x6f, 0x00, 0x91, 0xb3, 0x49, 0x77, 0x00, + 0x91, 0xb4, 0x1b, 0x31, 0x00, 0x91, 0xb5, 0x1b, + 0x30, 0x00, 0x91, 0xb6, 0x49, 0x78, 0x00, 0x91, + 0xb8, 0x09, 0xe2, 0x00, 0x91, 0xba, 0x1b, 0x32, + 0x00, 0x91, 0xbb, 0x4d, 0xc6, 0x00, 0x91, 0xbc, + 0x3b, 0x70, 0x00, 0x91, 0xbd, 0x4d, 0xc7, 0x00, + 0x91, 0xbf, 0x58, 0xb2, 0x00, 0x91, 0xc0, 0x1b, + 0x33, 0x00, 0x91, 0xc1, 0x1b, 0x34, 0x00, 0x91, + 0xc2, 0x4d, 0xc8, 0x00, 0x91, 0xc3, 0x49, 0x79, + 0x00, 0x91, 0xc4, 0x49, 0x7a, 0x00, 0x91, 0xc5, + 0x4d, 0xc9, 0x00, 0x91, 0xc6, 0x0d, 0x64, 0x00, + 0x91, 0xc7, 0x08, 0x43, 0x00, 0x91, 0xc8, 0x09, + 0x0d, 0x00, 0x91, 0xc9, 0x1b, 0x35, 0x00, 0x91, + 0xcb, 0x1b, 0x36, 0x00, 0x91, 0xcc, 0x0f, 0x6c, + 0x00, 0x91, 0xcd, 0x09, 0x4f, 0x00, 0x91, 0xce, + 0x0e, 0xfa, 0x00, 0x91, 0xcf, 0x0f, 0x94, 0x00, + 0x91, 0xd0, 0x1b, 0x37, 0x00, 0x91, 0xd1, 0x06, + 0xda, 0x00, 0x91, 0xd3, 0x58, 0xb3, 0x00, 0x91, + 0xd4, 0x58, 0xb4, 0x00, 0x91, 0xd6, 0x1b, 0x38, + 0x00, 0x91, 0xd7, 0x21, 0xc0, 0x00, 0x91, 0xd8, + 0x0c, 0x1d, 0x00, 0x91, 0xd9, 0x58, 0xb5, 0x00, + 0x91, 0xda, 0x21, 0xbf, 0x00, 0x91, 0xdb, 0x1b, + 0x3b, 0x00, 0x91, 0xdc, 0x05, 0xd6, 0x00, 0x91, + 0xdd, 0x0a, 0x11, 0x00, 0x91, 0xde, 0x21, 0xc1, + 0x00, 0x91, 0xdf, 0x1b, 0x39, 0x00, 0x91, 0xe1, + 0x1b, 0x3a, 0x00, 0x91, 0xe3, 0x0b, 0xfc, 0x00, + 0x91, 0xe4, 0x21, 0xc4, 0x00, 0x91, 0xe5, 0x21, + 0xc5, 0x00, 0x91, 0xe6, 0x0e, 0x83, 0x00, 0x91, + 0xe7, 0x06, 0xf4, 0x00, 0x91, 0xe9, 0x58, 0xb6, + 0x00, 0x91, 0xea, 0x58, 0xb7, 0x00, 0x91, 0xec, + 0x49, 0x7d, 0x00, 0x91, 0xed, 0x21, 0xc2, 0x00, + 0x91, 0xee, 0x21, 0xc3, 0x00, 0x91, 0xef, 0x58, + 0xb8, 0x00, 0x91, 0xf0, 0x3b, 0x71, 0x00, 0x91, + 0xf1, 0x43, 0x0d, 0x00, 0x91, 0xf5, 0x1b, 0x3d, + 0x00, 0x91, 0xf6, 0x1b, 0x3e, 0x00, 0x91, 0xf7, + 0x3b, 0x72, 0x00, 0x91, 0xf9, 0x58, 0xb9, 0x00, + 0x91, 0xfb, 0x3b, 0x73, 0x00, 0x91, 0xfc, 0x1b, + 0x3c, 0x00, 0x91, 0xfd, 0x58, 0xba, 0x00, 0x91, + 0xff, 0x1b, 0x40, 0x00, 0x92, 0x00, 0x4d, 0xca, + 0x00, 0x92, 0x01, 0x49, 0x7e, 0x00, 0x92, 0x04, + 0x58, 0xbb, 0x00, 0x92, 0x05, 0x58, 0xbc, 0x00, + 0x92, 0x06, 0x21, 0xc6, 0x00, 0x92, 0x07, 0x3b, + 0x74, 0x00, 0x92, 0x09, 0x4d, 0xcb, 0x00, 0x92, + 0x0a, 0x21, 0xc8, 0x00, 0x92, 0x0c, 0x58, 0xbd, + 0x00, 0x92, 0x0d, 0x0c, 0xb7, 0x00, 0x92, 0x0e, + 0x05, 0xa1, 0x00, 0x92, 0x10, 0x21, 0xc7, 0x00, + 0x92, 0x11, 0x1b, 0x44, 0x00, 0x92, 0x12, 0x58, + 0xbe, 0x00, 0x92, 0x13, 0x58, 0xbf, 0x00, 0x92, + 0x14, 0x1b, 0x41, 0x00, 0x92, 0x15, 0x1b, 0x43, + 0x00, 0x92, 0x16, 0x49, 0x7f, 0x00, 0x92, 0x17, + 0x49, 0x80, 0x00, 0x92, 0x18, 0x58, 0xc0, 0x00, + 0x92, 0x1c, 0x58, 0xc1, 0x00, 0x92, 0x1d, 0x58, + 0xc2, 0x00, 0x92, 0x1e, 0x1b, 0x3f, 0x00, 0x92, + 0x23, 0x4d, 0xcc, 0x00, 0x92, 0x24, 0x58, 0xc3, + 0x00, 0x92, 0x25, 0x58, 0xc4, 0x00, 0x92, 0x26, + 0x58, 0xc5, 0x00, 0x92, 0x28, 0x3b, 0x75, 0x00, + 0x92, 0x29, 0x1b, 0x8a, 0x00, 0x92, 0x2c, 0x1b, + 0x42, 0x00, 0x92, 0x2e, 0x58, 0xc6, 0x00, 0x92, + 0x2f, 0x58, 0xc7, 0x00, 0x92, 0x30, 0x58, 0xc8, + 0x00, 0x92, 0x33, 0x3b, 0x76, 0x00, 0x92, 0x34, + 0x0f, 0xb3, 0x00, 0x92, 0x35, 0x58, 0xc9, 0x00, + 0x92, 0x36, 0x58, 0xca, 0x00, 0x92, 0x37, 0x07, + 0x8e, 0x00, 0x92, 0x38, 0x3b, 0x77, 0x00, 0x92, + 0x39, 0x21, 0xcf, 0x00, 0x92, 0x3a, 0x21, 0xc9, + 0x00, 0x92, 0x3c, 0x21, 0xcb, 0x00, 0x92, 0x3e, + 0x58, 0xcb, 0x00, 0x92, 0x3f, 0x1b, 0x4c, 0x00, + 0x92, 0x40, 0x21, 0xca, 0x00, 0x92, 0x42, 0x49, + 0x82, 0x00, 0x92, 0x43, 0x3b, 0x78, 0x00, 0x92, + 0x44, 0x0c, 0x2e, 0x00, 0x92, 0x45, 0x1b, 0x47, + 0x00, 0x92, 0x46, 0x58, 0xcc, 0x00, 0x92, 0x47, + 0x3b, 0x79, 0x00, 0x92, 0x48, 0x1b, 0x4a, 0x00, + 0x92, 0x49, 0x1b, 0x48, 0x00, 0x92, 0x4a, 0x49, + 0x83, 0x00, 0x92, 0x4b, 0x1b, 0x4d, 0x00, 0x92, + 0x4d, 0x58, 0xcd, 0x00, 0x92, 0x4e, 0x21, 0xcc, + 0x00, 0x92, 0x4f, 0x3b, 0x7a, 0x00, 0x92, 0x50, + 0x1b, 0x4e, 0x00, 0x92, 0x51, 0x21, 0xce, 0x00, + 0x92, 0x56, 0x49, 0x84, 0x00, 0x92, 0x57, 0x1b, + 0x46, 0x00, 0x92, 0x58, 0x58, 0xce, 0x00, 0x92, + 0x59, 0x21, 0xcd, 0x00, 0x92, 0x5a, 0x1b, 0x53, + 0x00, 0x92, 0x5b, 0x05, 0x16, 0x00, 0x92, 0x5c, + 0x58, 0xcf, 0x00, 0x92, 0x5d, 0x58, 0xd0, 0x00, + 0x92, 0x5e, 0x1b, 0x45, 0x00, 0x92, 0x60, 0x3b, + 0x7b, 0x00, 0x92, 0x61, 0x49, 0x85, 0x00, 0x92, + 0x62, 0x0d, 0x41, 0x00, 0x92, 0x64, 0x1b, 0x49, + 0x00, 0x92, 0x65, 0x49, 0x86, 0x00, 0x92, 0x66, + 0x09, 0xc8, 0x00, 0x92, 0x67, 0x21, 0xd0, 0x00, + 0x92, 0x68, 0x49, 0x87, 0x00, 0x92, 0x69, 0x58, + 0xd1, 0x00, 0x92, 0x6e, 0x58, 0xd2, 0x00, 0x92, + 0x6f, 0x58, 0xd3, 0x00, 0x92, 0x70, 0x58, 0xd4, + 0x00, 0x92, 0x71, 0x07, 0xed, 0x00, 0x92, 0x75, + 0x58, 0xd5, 0x00, 0x92, 0x76, 0x4d, 0xcd, 0x00, + 0x92, 0x77, 0x21, 0xd2, 0x00, 0x92, 0x78, 0x21, + 0xd3, 0x00, 0x92, 0x79, 0x58, 0xd6, 0x00, 0x92, + 0x7b, 0x58, 0xd7, 0x00, 0x92, 0x7c, 0x49, 0x89, + 0x00, 0x92, 0x7d, 0x49, 0x8a, 0x00, 0x92, 0x7e, + 0x0e, 0x76, 0x00, 0x92, 0x7f, 0x49, 0x8b, 0x00, + 0x92, 0x80, 0x06, 0xdc, 0x00, 0x92, 0x83, 0x09, + 0x50, 0x00, 0x92, 0x85, 0x0c, 0x94, 0x00, 0x92, + 0x88, 0x20, 0xaa, 0x00, 0x92, 0x89, 0x49, 0x8c, + 0x00, 0x92, 0x8a, 0x58, 0xd8, 0x00, 0x92, 0x8d, + 0x49, 0x8d, 0x00, 0x92, 0x8e, 0x4d, 0xce, 0x00, + 0x92, 0x91, 0x0a, 0xaf, 0x00, 0x92, 0x92, 0x58, + 0xd9, 0x00, 0x92, 0x93, 0x1b, 0x51, 0x00, 0x92, + 0x95, 0x1b, 0x4b, 0x00, 0x92, 0x96, 0x1b, 0x50, + 0x00, 0x92, 0x97, 0x49, 0x8e, 0x00, 0x92, 0x98, + 0x0e, 0xcf, 0x00, 0x92, 0x99, 0x49, 0x8f, 0x00, + 0x92, 0x9a, 0x0b, 0xd4, 0x00, 0x92, 0x9b, 0x1b, + 0x52, 0x00, 0x92, 0x9c, 0x1b, 0x4f, 0x00, 0x92, + 0x9f, 0x49, 0x90, 0x00, 0x92, 0xa0, 0x58, 0xda, + 0x00, 0x92, 0xa4, 0x58, 0xdb, 0x00, 0x92, 0xa5, + 0x58, 0xdc, 0x00, 0x92, 0xa7, 0x21, 0xd1, 0x00, + 0x92, 0xa8, 0x58, 0xdd, 0x00, 0x92, 0xab, 0x49, + 0x91, 0x00, 0x92, 0xad, 0x0a, 0xae, 0x00, 0x92, + 0xaf, 0x4d, 0xcf, 0x00, 0x92, 0xb2, 0x49, 0x94, + 0x00, 0x92, 0xb3, 0x35, 0x54, 0x00, 0x92, 0xb6, + 0x58, 0xde, 0x00, 0x92, 0xb7, 0x1b, 0x56, 0x00, + 0x92, 0xb8, 0x58, 0xdf, 0x00, 0x92, 0xb9, 0x1b, + 0x55, 0x00, 0x92, 0xba, 0x58, 0xe0, 0x00, 0x92, + 0xbb, 0x4d, 0xd0, 0x00, 0x92, 0xbc, 0x4d, 0xd1, + 0x00, 0x92, 0xbd, 0x58, 0xe1, 0x00, 0x92, 0xbf, + 0x49, 0x95, 0x00, 0x92, 0xc0, 0x49, 0x96, 0x00, + 0x92, 0xc1, 0x4d, 0xd2, 0x00, 0x92, 0xc2, 0x3b, + 0x7c, 0x00, 0x92, 0xc3, 0x4d, 0xd3, 0x00, 0x92, + 0xc5, 0x4d, 0xd4, 0x00, 0x92, 0xc6, 0x49, 0x97, + 0x00, 0x92, 0xc7, 0x58, 0xe2, 0x00, 0x92, 0xc8, + 0x4d, 0xd5, 0x00, 0x92, 0xcb, 0x3b, 0x7d, 0x00, + 0x92, 0xcc, 0x3b, 0x7e, 0x00, 0x92, 0xcd, 0x58, + 0xe3, 0x00, 0x92, 0xce, 0x49, 0x98, 0x00, 0x92, + 0xcf, 0x1b, 0x54, 0x00, 0x92, 0xd0, 0x21, 0xd7, + 0x00, 0x92, 0xd2, 0x0e, 0x5d, 0x00, 0x92, 0xd3, + 0x21, 0xdb, 0x00, 0x92, 0xd5, 0x21, 0xd9, 0x00, + 0x92, 0xd7, 0x21, 0xd5, 0x00, 0x92, 0xd8, 0x58, + 0xe4, 0x00, 0x92, 0xd9, 0x21, 0xd6, 0x00, 0x92, + 0xdc, 0x58, 0xe5, 0x00, 0x92, 0xdd, 0x58, 0xe6, + 0x00, 0x92, 0xdf, 0x3b, 0x7f, 0x00, 0x92, 0xe0, + 0x21, 0xda, 0x00, 0x92, 0xe1, 0x58, 0xe7, 0x00, + 0x92, 0xe3, 0x58, 0xe8, 0x00, 0x92, 0xe4, 0x09, + 0x85, 0x00, 0x92, 0xe5, 0x49, 0x99, 0x00, 0x92, + 0xe7, 0x21, 0xd4, 0x00, 0x92, 0xe8, 0x58, 0xe9, + 0x00, 0x92, 0xe9, 0x1b, 0x57, 0x00, 0x92, 0xea, + 0x0e, 0x2f, 0x00, 0x92, 0xec, 0x58, 0xea, 0x00, + 0x92, 0xed, 0x04, 0xf6, 0x00, 0x92, 0xee, 0x58, + 0xeb, 0x00, 0x92, 0xf0, 0x58, 0xec, 0x00, 0x92, + 0xf2, 0x0d, 0xb8, 0x00, 0x92, 0xf3, 0x0b, 0xb0, + 0x00, 0x92, 0xf7, 0x49, 0x9d, 0x00, 0x92, 0xf8, + 0x06, 0x92, 0x00, 0x92, 0xf9, 0x20, 0xb0, 0x00, + 0x92, 0xfa, 0x1b, 0x59, 0x00, 0x92, 0xfb, 0x21, + 0xde, 0x00, 0x92, 0xfc, 0x07, 0xef, 0x00, 0x92, + 0xff, 0x21, 0xe1, 0x00, 0x93, 0x00, 0x58, 0xed, + 0x00, 0x93, 0x02, 0x21, 0xe3, 0x00, 0x93, 0x04, + 0x34, 0x5a, 0x00, 0x93, 0x06, 0x08, 0x7a, 0x00, + 0x93, 0x08, 0x58, 0xee, 0x00, 0x93, 0x0d, 0x3b, + 0x80, 0x00, 0x93, 0x0f, 0x1b, 0x58, 0x00, 0x93, + 0x10, 0x0a, 0x33, 0x00, 0x93, 0x11, 0x49, 0x9a, + 0x00, 0x93, 0x14, 0x4d, 0xd6, 0x00, 0x93, 0x15, + 0x3b, 0x81, 0x00, 0x93, 0x18, 0x0a, 0x34, 0x00, + 0x93, 0x19, 0x1b, 0x5c, 0x00, 0x93, 0x1a, 0x1b, + 0x5e, 0x00, 0x93, 0x1c, 0x58, 0xef, 0x00, 0x93, + 0x1d, 0x21, 0xe2, 0x00, 0x93, 0x1e, 0x21, 0xe0, + 0x00, 0x93, 0x1f, 0x3b, 0x82, 0x00, 0x93, 0x20, + 0x09, 0xe3, 0x00, 0x93, 0x21, 0x21, 0xdd, 0x00, + 0x93, 0x22, 0x1b, 0x5d, 0x00, 0x93, 0x23, 0x1b, + 0x5f, 0x00, 0x93, 0x24, 0x58, 0xf0, 0x00, 0x93, + 0x25, 0x21, 0xdc, 0x00, 0x93, 0x26, 0x06, 0xcb, + 0x00, 0x93, 0x27, 0x3b, 0x83, 0x00, 0x93, 0x28, + 0x0d, 0xb7, 0x00, 0x93, 0x29, 0x49, 0x9e, 0x00, + 0x93, 0x2a, 0x58, 0xf1, 0x00, 0x93, 0x2b, 0x09, + 0x0e, 0x00, 0x93, 0x2c, 0x0f, 0xc9, 0x00, 0x93, + 0x2e, 0x1b, 0x5b, 0x00, 0x93, 0x2f, 0x08, 0x68, + 0x00, 0x93, 0x32, 0x0f, 0xe5, 0x00, 0x93, 0x33, + 0x4d, 0xd7, 0x00, 0x93, 0x34, 0x58, 0xf2, 0x00, + 0x93, 0x35, 0x1b, 0x61, 0x00, 0x93, 0x36, 0x4d, + 0xd8, 0x00, 0x93, 0x37, 0x58, 0xf3, 0x00, 0x93, + 0x3a, 0x1b, 0x60, 0x00, 0x93, 0x3b, 0x1b, 0x62, + 0x00, 0x93, 0x44, 0x1b, 0x5a, 0x00, 0x93, 0x47, + 0x3b, 0x84, 0x00, 0x93, 0x48, 0x20, 0xa9, 0x00, + 0x93, 0x49, 0x43, 0x0e, 0x00, 0x93, 0x4a, 0x34, + 0x58, 0x00, 0x93, 0x4b, 0x0c, 0xc1, 0x00, 0x93, + 0x4d, 0x0c, 0x4f, 0x00, 0x93, 0x50, 0x58, 0xf4, + 0x00, 0x93, 0x51, 0x49, 0xa1, 0x00, 0x93, 0x52, + 0x3b, 0x85, 0x00, 0x93, 0x54, 0x0b, 0xf3, 0x00, + 0x93, 0x55, 0x58, 0xf5, 0x00, 0x93, 0x56, 0x1b, + 0x67, 0x00, 0x93, 0x57, 0x21, 0xe5, 0x00, 0x93, + 0x58, 0x4d, 0xd9, 0x00, 0x93, 0x5a, 0x49, 0xa2, + 0x00, 0x93, 0x5b, 0x0b, 0x81, 0x00, 0x93, 0x5c, + 0x1b, 0x63, 0x00, 0x93, 0x5e, 0x58, 0xf6, 0x00, + 0x93, 0x60, 0x1b, 0x64, 0x00, 0x93, 0x64, 0x43, + 0x0f, 0x00, 0x93, 0x65, 0x43, 0x10, 0x00, 0x93, + 0x67, 0x58, 0xf7, 0x00, 0x93, 0x69, 0x58, 0xf8, + 0x00, 0x93, 0x6a, 0x3b, 0x87, 0x00, 0x93, 0x6b, + 0x49, 0xa3, 0x00, 0x93, 0x6c, 0x07, 0x03, 0x00, + 0x93, 0x6d, 0x3b, 0x88, 0x00, 0x93, 0x6e, 0x1b, + 0x66, 0x00, 0x93, 0x6f, 0x58, 0xf9, 0x00, 0x93, + 0x70, 0x21, 0xe4, 0x00, 0x93, 0x71, 0x49, 0xa4, + 0x00, 0x93, 0x73, 0x49, 0xa5, 0x00, 0x93, 0x74, + 0x58, 0xfa, 0x00, 0x93, 0x75, 0x07, 0x64, 0x00, + 0x93, 0x76, 0x58, 0xfb, 0x00, 0x93, 0x7a, 0x58, + 0xfc, 0x00, 0x93, 0x7c, 0x1b, 0x65, 0x00, 0x93, + 0x7d, 0x58, 0xfd, 0x00, 0x93, 0x7e, 0x09, 0xc9, + 0x00, 0x93, 0x7f, 0x4d, 0xda, 0x00, 0x93, 0x80, + 0x58, 0xfe, 0x00, 0x93, 0x81, 0x58, 0xff, 0x00, + 0x93, 0x82, 0x4d, 0xdb, 0x00, 0x93, 0x88, 0x49, + 0xa9, 0x00, 0x93, 0x8a, 0x4d, 0xdc, 0x00, 0x93, + 0x8b, 0x49, 0xaa, 0x00, 0x93, 0x8c, 0x05, 0xd7, + 0x00, 0x93, 0x8d, 0x59, 0x00, 0x00, 0x93, 0x8f, + 0x49, 0xab, 0x00, 0x93, 0x92, 0x59, 0x01, 0x00, + 0x93, 0x94, 0x1b, 0x6b, 0x00, 0x93, 0x95, 0x59, + 0x02, 0x00, 0x93, 0x96, 0x08, 0x2f, 0x00, 0x93, + 0x97, 0x0a, 0xfb, 0x00, 0x93, 0x98, 0x59, 0x03, + 0x00, 0x93, 0x9a, 0x0b, 0xe6, 0x00, 0x93, 0x9b, + 0x3b, 0x89, 0x00, 0x93, 0x9e, 0x49, 0xac, 0x00, + 0x93, 0xa1, 0x49, 0xa6, 0x00, 0x93, 0xa3, 0x43, + 0x11, 0x00, 0x93, 0xa4, 0x21, 0xe6, 0x00, 0x93, + 0xa6, 0x59, 0x05, 0x00, 0x93, 0xa7, 0x05, 0x99, + 0x00, 0x93, 0xa8, 0x59, 0x06, 0x00, 0x93, 0xa9, + 0x3b, 0x8b, 0x00, 0x93, 0xab, 0x59, 0x07, 0x00, + 0x93, 0xac, 0x1b, 0x69, 0x00, 0x93, 0xad, 0x1b, + 0x6a, 0x00, 0x93, 0xae, 0x0b, 0xdf, 0x00, 0x93, + 0xb0, 0x1b, 0x68, 0x00, 0x93, 0xb4, 0x59, 0x08, + 0x00, 0x93, 0xb5, 0x59, 0x09, 0x00, 0x93, 0xb6, + 0x59, 0x0a, 0x00, 0x93, 0xb9, 0x1b, 0x6c, 0x00, + 0x93, 0xba, 0x3b, 0x8a, 0x00, 0x93, 0xbb, 0x4d, + 0xdd, 0x00, 0x93, 0xc1, 0x3b, 0x8c, 0x00, 0x93, + 0xc3, 0x1b, 0x72, 0x00, 0x93, 0xc4, 0x59, 0x0b, + 0x00, 0x93, 0xc5, 0x59, 0x0c, 0x00, 0x93, 0xc6, + 0x21, 0xe7, 0x00, 0x93, 0xc7, 0x49, 0xb1, 0x00, + 0x93, 0xc8, 0x1b, 0x75, 0x00, 0x93, 0xc9, 0x59, + 0x0d, 0x00, 0x93, 0xca, 0x3b, 0x8d, 0x00, 0x93, + 0xcb, 0x59, 0x0e, 0x00, 0x93, 0xcc, 0x4d, 0xde, + 0x00, 0x93, 0xcd, 0x59, 0x0f, 0x00, 0x93, 0xd0, + 0x1b, 0x74, 0x00, 0x93, 0xd1, 0x0c, 0x27, 0x00, + 0x93, 0xd3, 0x59, 0x10, 0x00, 0x93, 0xd6, 0x1b, + 0x6d, 0x00, 0x93, 0xd7, 0x1b, 0x6e, 0x00, 0x93, + 0xd8, 0x1b, 0x71, 0x00, 0x93, 0xd9, 0x59, 0x11, + 0x00, 0x93, 0xdc, 0x49, 0xb2, 0x00, 0x93, 0xdd, + 0x1b, 0x73, 0x00, 0x93, 0xde, 0x21, 0xe8, 0x00, + 0x93, 0xdf, 0x43, 0x12, 0x00, 0x93, 0xe1, 0x06, + 0xb8, 0x00, 0x93, 0xe2, 0x3b, 0x8e, 0x00, 0x93, + 0xe4, 0x1b, 0x76, 0x00, 0x93, 0xe5, 0x1b, 0x70, + 0x00, 0x93, 0xe6, 0x4d, 0xdf, 0x00, 0x93, 0xe7, + 0x49, 0xb3, 0x00, 0x93, 0xe8, 0x1b, 0x6f, 0x00, + 0x93, 0xf1, 0x49, 0xb0, 0x00, 0x93, 0xf5, 0x49, + 0xad, 0x00, 0x93, 0xf7, 0x59, 0x12, 0x00, 0x93, + 0xf8, 0x21, 0xe9, 0x00, 0x93, 0xf9, 0x4d, 0xe0, + 0x00, 0x93, 0xfa, 0x3b, 0x8f, 0x00, 0x93, 0xfb, + 0x49, 0xb7, 0x00, 0x93, 0xfd, 0x3b, 0x90, 0x00, + 0x94, 0x01, 0x59, 0x13, 0x00, 0x94, 0x02, 0x4d, + 0xe1, 0x00, 0x94, 0x03, 0x1b, 0x7a, 0x00, 0x94, + 0x04, 0x43, 0x13, 0x00, 0x94, 0x07, 0x1b, 0x7b, + 0x00, 0x94, 0x08, 0x59, 0x14, 0x00, 0x94, 0x09, + 0x49, 0xb4, 0x00, 0x94, 0x0d, 0x4d, 0xe2, 0x00, + 0x94, 0x0e, 0x4d, 0xe3, 0x00, 0x94, 0x0f, 0x3b, + 0x91, 0x00, 0x94, 0x10, 0x1b, 0x7c, 0x00, 0x94, + 0x13, 0x1b, 0x79, 0x00, 0x94, 0x14, 0x1b, 0x78, + 0x00, 0x94, 0x15, 0x59, 0x15, 0x00, 0x94, 0x16, + 0x49, 0xb5, 0x00, 0x94, 0x17, 0x49, 0xb6, 0x00, + 0x94, 0x18, 0x09, 0xca, 0x00, 0x94, 0x19, 0x0c, + 0x82, 0x00, 0x94, 0x1a, 0x1b, 0x77, 0x00, 0x94, + 0x1f, 0x59, 0x16, 0x00, 0x94, 0x21, 0x1b, 0x80, + 0x00, 0x94, 0x2b, 0x1b, 0x7e, 0x00, 0x94, 0x2e, + 0x4d, 0xe4, 0x00, 0x94, 0x2f, 0x59, 0x17, 0x00, + 0x94, 0x31, 0x21, 0xea, 0x00, 0x94, 0x32, 0x49, + 0xb8, 0x00, 0x94, 0x33, 0x43, 0x14, 0x00, 0x94, + 0x34, 0x3b, 0x92, 0x00, 0x94, 0x35, 0x1b, 0x7f, + 0x00, 0x94, 0x36, 0x1b, 0x7d, 0x00, 0x94, 0x38, + 0x0b, 0x58, 0x00, 0x94, 0x3a, 0x1b, 0x81, 0x00, + 0x94, 0x3b, 0x49, 0xb9, 0x00, 0x94, 0x3d, 0x59, + 0x18, 0x00, 0x94, 0x3f, 0x3b, 0x93, 0x00, 0x94, + 0x41, 0x1b, 0x82, 0x00, 0x94, 0x43, 0x59, 0x19, + 0x00, 0x94, 0x44, 0x1b, 0x84, 0x00, 0x94, 0x45, + 0x21, 0xeb, 0x00, 0x94, 0x48, 0x21, 0xec, 0x00, + 0x94, 0x4a, 0x43, 0x15, 0x00, 0x94, 0x4c, 0x4d, + 0xe5, 0x00, 0x94, 0x51, 0x06, 0x11, 0x00, 0x94, + 0x52, 0x1b, 0x83, 0x00, 0x94, 0x53, 0x0f, 0x06, + 0x00, 0x94, 0x55, 0x3b, 0x94, 0x00, 0x94, 0x59, + 0x59, 0x1a, 0x00, 0x94, 0x5a, 0x1b, 0x8f, 0x00, + 0x94, 0x5b, 0x1b, 0x85, 0x00, 0x94, 0x5c, 0x59, + 0x1b, 0x00, 0x94, 0x5e, 0x1b, 0x88, 0x00, 0x94, + 0x5f, 0x59, 0x1c, 0x00, 0x94, 0x60, 0x1b, 0x86, + 0x00, 0x94, 0x61, 0x59, 0x1d, 0x00, 0x94, 0x62, + 0x1b, 0x87, 0x00, 0x94, 0x63, 0x43, 0x16, 0x00, + 0x94, 0x68, 0x59, 0x1e, 0x00, 0x94, 0x6a, 0x1b, + 0x89, 0x00, 0x94, 0x6b, 0x3b, 0x95, 0x00, 0x94, + 0x6d, 0x49, 0xbc, 0x00, 0x94, 0x6e, 0x59, 0x1f, + 0x00, 0x94, 0x6f, 0x49, 0xbd, 0x00, 0x94, 0x70, + 0x1b, 0x8b, 0x00, 0x94, 0x71, 0x43, 0x17, 0x00, + 0x94, 0x72, 0x3b, 0x96, 0x00, 0x94, 0x75, 0x1b, + 0x8c, 0x00, 0x94, 0x77, 0x1b, 0x8d, 0x00, 0x94, + 0x7c, 0x1b, 0x90, 0x00, 0x94, 0x7d, 0x1b, 0x8e, + 0x00, 0x94, 0x7e, 0x1b, 0x91, 0x00, 0x94, 0x7f, + 0x1b, 0x93, 0x00, 0x94, 0x81, 0x1b, 0x92, 0x00, + 0x94, 0x83, 0x59, 0x21, 0x00, 0x94, 0x84, 0x59, + 0x20, 0x00, 0x95, 0x77, 0x0b, 0xd5, 0x00, 0x95, + 0x78, 0x3b, 0x97, 0x00, 0x95, 0x79, 0x49, 0xbe, + 0x00, 0x95, 0x7e, 0x59, 0x22, 0x00, 0x95, 0x80, + 0x0e, 0xf3, 0x00, 0x95, 0x82, 0x1b, 0x94, 0x00, + 0x95, 0x83, 0x0a, 0xb0, 0x00, 0x95, 0x84, 0x59, + 0x23, 0x00, 0x95, 0x86, 0x49, 0xbf, 0x00, 0x95, + 0x87, 0x1b, 0x95, 0x00, 0x95, 0x88, 0x4d, 0xe6, + 0x00, 0x95, 0x89, 0x0e, 0x14, 0x00, 0x95, 0x8a, + 0x1b, 0x96, 0x00, 0x95, 0x8b, 0x05, 0x89, 0x00, + 0x95, 0x8c, 0x49, 0xc0, 0x00, 0x95, 0x8d, 0x49, + 0xc1, 0x00, 0x95, 0x8e, 0x43, 0x18, 0x00, 0x95, + 0x8f, 0x04, 0xde, 0x00, 0x95, 0x91, 0x06, 0x13, + 0x00, 0x95, 0x92, 0x21, 0xed, 0x00, 0x95, 0x93, + 0x06, 0x12, 0x00, 0x95, 0x94, 0x1b, 0x97, 0x00, + 0x95, 0x96, 0x1b, 0x98, 0x00, 0x95, 0x98, 0x1b, + 0x99, 0x00, 0x95, 0x99, 0x1b, 0x9a, 0x00, 0x95, + 0x9d, 0x59, 0x24, 0x00, 0x95, 0x9e, 0x59, 0x25, + 0x00, 0x95, 0x9f, 0x43, 0x19, 0x00, 0x95, 0xa0, + 0x1b, 0x9b, 0x00, 0x95, 0xa1, 0x4d, 0xe7, 0x00, + 0x95, 0xa2, 0x06, 0x14, 0x00, 0x95, 0xa3, 0x05, + 0xb3, 0x00, 0x95, 0xa4, 0x07, 0xf0, 0x00, 0x95, + 0xa5, 0x0d, 0x4a, 0x00, 0x95, 0xa6, 0x3b, 0x98, + 0x00, 0x95, 0xa7, 0x1b, 0x9d, 0x00, 0x95, 0xa8, + 0x1b, 0x9c, 0x00, 0x95, 0xa9, 0x3b, 0x99, 0x00, + 0x95, 0xab, 0x4f, 0x59, 0x00, 0x95, 0xac, 0x43, + 0x1a, 0x00, 0x95, 0xad, 0x1b, 0x9e, 0x00, 0x95, + 0xb1, 0x35, 0x55, 0x00, 0x95, 0xb2, 0x04, 0xfe, + 0x00, 0x95, 0xb4, 0x3b, 0x9b, 0x00, 0x95, 0xb6, + 0x43, 0x1b, 0x00, 0x95, 0xb9, 0x1b, 0xa1, 0x00, + 0x95, 0xba, 0x59, 0x26, 0x00, 0x95, 0xbb, 0x1b, + 0xa0, 0x00, 0x95, 0xbc, 0x1b, 0x9f, 0x00, 0x95, + 0xbd, 0x3b, 0x9c, 0x00, 0x95, 0xbe, 0x1b, 0xa2, + 0x00, 0x95, 0xbf, 0x4d, 0xe8, 0x00, 0x95, 0xc3, + 0x1b, 0xa5, 0x00, 0x95, 0xc6, 0x4d, 0xe9, 0x00, + 0x95, 0xc7, 0x04, 0x8b, 0x00, 0x95, 0xc8, 0x49, + 0xc4, 0x00, 0x95, 0xc9, 0x4d, 0xea, 0x00, 0x95, + 0xca, 0x1b, 0xa3, 0x00, 0x95, 0xcb, 0x43, 0x1c, + 0x00, 0x95, 0xcc, 0x1b, 0xa7, 0x00, 0x95, 0xcd, + 0x1b, 0xa6, 0x00, 0x95, 0xd0, 0x43, 0x1d, 0x00, + 0x95, 0xd1, 0x4d, 0xeb, 0x00, 0x95, 0xd2, 0x4d, + 0xec, 0x00, 0x95, 0xd3, 0x43, 0x1e, 0x00, 0x95, + 0xd4, 0x1b, 0xa9, 0x00, 0x95, 0xd5, 0x1b, 0xa8, + 0x00, 0x95, 0xd6, 0x1b, 0xaa, 0x00, 0x95, 0xd8, + 0x0c, 0x86, 0x00, 0x95, 0xd9, 0x59, 0x27, 0x00, + 0x95, 0xda, 0x3b, 0x9d, 0x00, 0x95, 0xdc, 0x1b, + 0xab, 0x00, 0x95, 0xdd, 0x59, 0x28, 0x00, 0x95, + 0xde, 0x43, 0x20, 0x00, 0x95, 0xdf, 0x59, 0x29, + 0x00, 0x95, 0xe0, 0x4d, 0xed, 0x00, 0x95, 0xe1, + 0x1b, 0xac, 0x00, 0x95, 0xe2, 0x1b, 0xae, 0x00, + 0x95, 0xe4, 0x4d, 0xee, 0x00, 0x95, 0xe5, 0x1b, + 0xad, 0x00, 0x95, 0xe6, 0x4d, 0xef, 0x00, 0x95, + 0xe8, 0x36, 0xed, 0x00, 0x96, 0x1c, 0x0d, 0xde, + 0x00, 0x96, 0x1d, 0x3b, 0x9e, 0x00, 0x96, 0x1e, + 0x59, 0x2a, 0x00, 0x96, 0x21, 0x1b, 0xaf, 0x00, + 0x96, 0x22, 0x59, 0x2b, 0x00, 0x96, 0x24, 0x4d, + 0xf0, 0x00, 0x96, 0x25, 0x59, 0x2c, 0x00, 0x96, + 0x26, 0x59, 0x2d, 0x00, 0x96, 0x28, 0x1b, 0xb0, + 0x00, 0x96, 0x2a, 0x08, 0x55, 0x00, 0x96, 0x2c, + 0x49, 0xc7, 0x00, 0x96, 0x2e, 0x1b, 0xb1, 0x00, + 0x96, 0x2f, 0x1b, 0xb2, 0x00, 0x96, 0x31, 0x4d, + 0xf1, 0x00, 0x96, 0x32, 0x0e, 0x77, 0x00, 0x96, + 0x33, 0x49, 0xc8, 0x00, 0x96, 0x34, 0x49, 0xc9, + 0x00, 0x96, 0x37, 0x59, 0x2e, 0x00, 0x96, 0x38, + 0x4d, 0xf2, 0x00, 0x96, 0x39, 0x59, 0x2f, 0x00, + 0x96, 0x3a, 0x59, 0x30, 0x00, 0x96, 0x3b, 0x0a, + 0xcd, 0x00, 0x96, 0x3c, 0x49, 0xcb, 0x00, 0x96, + 0x3d, 0x4d, 0xf3, 0x00, 0x96, 0x3f, 0x04, 0x68, + 0x00, 0x96, 0x40, 0x0b, 0x2b, 0x00, 0x96, 0x41, + 0x3b, 0x9f, 0x00, 0x96, 0x42, 0x1b, 0xb3, 0x00, + 0x96, 0x44, 0x0d, 0xdf, 0x00, 0x96, 0x4b, 0x1b, + 0xb6, 0x00, 0x96, 0x4c, 0x1b, 0xb4, 0x00, 0x96, + 0x4d, 0x07, 0xf1, 0x00, 0x96, 0x4f, 0x1b, 0xb5, + 0x00, 0x96, 0x50, 0x07, 0x76, 0x00, 0x96, 0x52, + 0x59, 0x31, 0x00, 0x96, 0x54, 0x4d, 0xf4, 0x00, + 0x96, 0x56, 0x59, 0x32, 0x00, 0x96, 0x57, 0x59, + 0x33, 0x00, 0x96, 0x58, 0x3b, 0xa0, 0x00, 0x96, + 0x5b, 0x0e, 0x15, 0x00, 0x96, 0x5c, 0x1b, 0xb8, + 0x00, 0x96, 0x5d, 0x1b, 0xba, 0x00, 0x96, 0x5e, + 0x1b, 0xb9, 0x00, 0x96, 0x5f, 0x1b, 0xbb, 0x00, + 0x96, 0x61, 0x49, 0xcc, 0x00, 0x96, 0x62, 0x04, + 0xc3, 0x00, 0x96, 0x63, 0x0a, 0x1e, 0x00, 0x96, + 0x64, 0x09, 0x86, 0x00, 0x96, 0x65, 0x06, 0x15, + 0x00, 0x96, 0x66, 0x1b, 0xbc, 0x00, 0x96, 0x6a, + 0x0d, 0x1c, 0x00, 0x96, 0x6c, 0x1b, 0xbe, 0x00, + 0x96, 0x6e, 0x59, 0x34, 0x00, 0x96, 0x70, 0x04, + 0xc4, 0x00, 0x96, 0x72, 0x1b, 0xbd, 0x00, 0x96, + 0x73, 0x0b, 0xe0, 0x00, 0x96, 0x74, 0x4d, 0xf5, + 0x00, 0x96, 0x75, 0x0f, 0x95, 0x00, 0x96, 0x76, + 0x0c, 0x83, 0x00, 0x96, 0x77, 0x1b, 0xb7, 0x00, + 0x96, 0x78, 0x0f, 0x6e, 0x00, 0x96, 0x7a, 0x07, + 0x65, 0x00, 0x96, 0x7b, 0x4d, 0xf6, 0x00, 0x96, + 0x7c, 0x59, 0x35, 0x00, 0x96, 0x7d, 0x0f, 0x45, + 0x00, 0x96, 0x7e, 0x59, 0x36, 0x00, 0x96, 0x7f, + 0x4d, 0xf7, 0x00, 0x96, 0x81, 0x4d, 0xf8, 0x00, + 0x96, 0x82, 0x49, 0xce, 0x00, 0x96, 0x83, 0x4d, + 0xf9, 0x00, 0x96, 0x84, 0x3b, 0xa1, 0x00, 0x96, + 0x85, 0x06, 0xf1, 0x00, 0x96, 0x86, 0x0f, 0x7c, + 0x00, 0x96, 0x88, 0x06, 0xfe, 0x00, 0x96, 0x89, + 0x4d, 0xfa, 0x00, 0x96, 0x8a, 0x0b, 0x42, 0x00, + 0x96, 0x8b, 0x18, 0x6c, 0x00, 0x96, 0x8d, 0x1b, + 0xbf, 0x00, 0x96, 0x8e, 0x05, 0x8a, 0x00, 0x96, + 0x8f, 0x0a, 0x35, 0x00, 0x96, 0x91, 0x59, 0x37, + 0x00, 0x96, 0x94, 0x05, 0xb4, 0x00, 0x96, 0x95, + 0x1b, 0xc1, 0x00, 0x96, 0x96, 0x4d, 0xfb, 0x00, + 0x96, 0x97, 0x1b, 0xc2, 0x00, 0x96, 0x98, 0x1b, + 0xc0, 0x00, 0x96, 0x99, 0x07, 0x3a, 0x00, 0x96, + 0x9a, 0x49, 0xd0, 0x00, 0x96, 0x9b, 0x08, 0x4d, + 0x00, 0x96, 0x9c, 0x09, 0xcb, 0x00, 0x96, 0x9d, + 0x21, 0xf0, 0x00, 0x96, 0x9f, 0x59, 0x38, 0x00, + 0x96, 0xa0, 0x04, 0xc5, 0x00, 0x96, 0xa3, 0x0f, + 0xa1, 0x00, 0x96, 0xa4, 0x3b, 0xa2, 0x00, 0x96, + 0xa5, 0x43, 0x21, 0x00, 0x96, 0xa6, 0x59, 0x39, + 0x00, 0x96, 0xa7, 0x1b, 0xc4, 0x00, 0x96, 0xa8, + 0x1b, 0x0b, 0x00, 0x96, 0xa9, 0x3b, 0xa3, 0x00, + 0x96, 0xaa, 0x1b, 0xc3, 0x00, 0x96, 0xae, 0x4d, + 0xfc, 0x00, 0x96, 0xaf, 0x21, 0xf1, 0x00, 0x96, + 0xb0, 0x1b, 0xc7, 0x00, 0x96, 0xb1, 0x1b, 0xc5, + 0x00, 0x96, 0xb2, 0x1b, 0xc6, 0x00, 0x96, 0xb3, + 0x49, 0xd3, 0x00, 0x96, 0xb4, 0x1b, 0xc8, 0x00, + 0x96, 0xb6, 0x1b, 0xc9, 0x00, 0x96, 0xb7, 0x0f, + 0xb4, 0x00, 0x96, 0xb8, 0x1b, 0xca, 0x00, 0x96, + 0xb9, 0x1b, 0xcb, 0x00, 0x96, 0xba, 0x49, 0xd4, + 0x00, 0x96, 0xbb, 0x0a, 0x6d, 0x00, 0x96, 0xbc, + 0x0d, 0x4f, 0x00, 0x96, 0xbd, 0x49, 0xd5, 0x00, + 0x96, 0xc0, 0x0a, 0x43, 0x00, 0x96, 0xc1, 0x06, + 0x23, 0x00, 0x96, 0xc4, 0x0f, 0x24, 0x00, 0x96, + 0xc5, 0x05, 0x6d, 0x00, 0x96, 0xc6, 0x09, 0x42, + 0x00, 0x96, 0xc7, 0x07, 0x8f, 0x00, 0x96, 0xc9, + 0x1b, 0xce, 0x00, 0x96, 0xca, 0x59, 0x3a, 0x00, + 0x96, 0xcb, 0x1b, 0xcd, 0x00, 0x96, 0xcc, 0x08, + 0xc1, 0x00, 0x96, 0xcd, 0x1b, 0xcf, 0x00, 0x96, + 0xce, 0x1b, 0xcc, 0x00, 0x96, 0xd1, 0x08, 0x76, + 0x00, 0x96, 0xd2, 0x3b, 0xa4, 0x00, 0x96, 0xd5, + 0x1b, 0xd3, 0x00, 0x96, 0xd6, 0x19, 0x92, 0x00, + 0x96, 0xd8, 0x49, 0xd8, 0x00, 0x96, 0xd9, 0x10, + 0xeb, 0x00, 0x96, 0xda, 0x49, 0xd9, 0x00, 0x96, + 0xdb, 0x0a, 0x3d, 0x00, 0x96, 0xdc, 0x1b, 0xd1, + 0x00, 0x96, 0xdd, 0x49, 0xda, 0x00, 0x96, 0xde, + 0x3b, 0xa6, 0x00, 0x96, 0xdf, 0x59, 0x3c, 0x00, + 0x96, 0xe2, 0x0f, 0x6d, 0x00, 0x96, 0xe3, 0x34, + 0x3e, 0x00, 0x96, 0xe8, 0x04, 0xcd, 0x00, 0x96, + 0xe9, 0x3b, 0xa7, 0x00, 0x96, 0xea, 0x0a, 0x87, + 0x00, 0x96, 0xeb, 0x08, 0xe2, 0x00, 0x96, 0xef, + 0x43, 0x22, 0x00, 0x96, 0xf0, 0x0e, 0x07, 0x00, + 0x96, 0xf1, 0x3b, 0xa8, 0x00, 0x96, 0xf2, 0x04, + 0xe2, 0x00, 0x96, 0xf6, 0x0f, 0xb5, 0x00, 0x96, + 0xf7, 0x0f, 0x55, 0x00, 0x96, 0xf9, 0x1b, 0xd4, + 0x00, 0x96, 0xfa, 0x59, 0x3d, 0x00, 0x96, 0xfb, + 0x0c, 0x3f, 0x00, 0x97, 0x00, 0x09, 0x27, 0x00, + 0x97, 0x02, 0x3b, 0xa9, 0x00, 0x97, 0x03, 0x4d, + 0xfd, 0x00, 0x97, 0x04, 0x1b, 0xd5, 0x00, 0x97, + 0x05, 0x59, 0x3e, 0x00, 0x97, 0x06, 0x1b, 0xd6, + 0x00, 0x97, 0x07, 0x0a, 0x12, 0x00, 0x97, 0x08, + 0x1b, 0xd7, 0x00, 0x97, 0x09, 0x3b, 0xaa, 0x00, + 0x97, 0x0a, 0x0f, 0xb6, 0x00, 0x97, 0x0d, 0x1b, + 0xd2, 0x00, 0x97, 0x0e, 0x1b, 0xd9, 0x00, 0x97, + 0x0f, 0x1b, 0xdb, 0x00, 0x97, 0x11, 0x1b, 0xda, + 0x00, 0x97, 0x13, 0x1b, 0xd8, 0x00, 0x97, 0x14, + 0x49, 0xdc, 0x00, 0x97, 0x16, 0x1b, 0xdc, 0x00, + 0x97, 0x19, 0x1b, 0xdd, 0x00, 0x97, 0x1a, 0x59, + 0x3f, 0x00, 0x97, 0x1b, 0x4d, 0xfe, 0x00, 0x97, + 0x1c, 0x0a, 0xfc, 0x00, 0x97, 0x1d, 0x59, 0x40, + 0x00, 0x97, 0x1e, 0x05, 0x62, 0x00, 0x97, 0x21, + 0x4d, 0xff, 0x00, 0x97, 0x22, 0x4e, 0x00, 0x00, + 0x97, 0x23, 0x49, 0xdd, 0x00, 0x97, 0x24, 0x1b, + 0xde, 0x00, 0x97, 0x27, 0x0e, 0xc4, 0x00, 0x97, + 0x28, 0x4e, 0x01, 0x00, 0x97, 0x2a, 0x1b, 0xdf, + 0x00, 0x97, 0x30, 0x1b, 0xe0, 0x00, 0x97, 0x31, + 0x4e, 0x02, 0x00, 0x97, 0x32, 0x0f, 0xd0, 0x00, + 0x97, 0x33, 0x21, 0xf2, 0x00, 0x97, 0x36, 0x49, + 0xdf, 0x00, 0x97, 0x38, 0x14, 0x14, 0x00, 0x97, + 0x39, 0x1b, 0xe1, 0x00, 0x97, 0x3b, 0x21, 0xf3, + 0x00, 0x97, 0x3d, 0x1b, 0xe2, 0x00, 0x97, 0x3e, + 0x1b, 0xe3, 0x00, 0x97, 0x41, 0x49, 0xe0, 0x00, + 0x97, 0x42, 0x1b, 0xe7, 0x00, 0x97, 0x43, 0x21, + 0xf4, 0x00, 0x97, 0x44, 0x1b, 0xe4, 0x00, 0x97, + 0x46, 0x1b, 0xe5, 0x00, 0x97, 0x47, 0x49, 0xe1, + 0x00, 0x97, 0x48, 0x1b, 0xe6, 0x00, 0x97, 0x49, + 0x1b, 0xe8, 0x00, 0x97, 0x4a, 0x59, 0x42, 0x00, + 0x97, 0x4d, 0x21, 0xf5, 0x00, 0x97, 0x4e, 0x43, + 0x23, 0x00, 0x97, 0x4f, 0x21, 0xf6, 0x00, 0x97, + 0x51, 0x21, 0xf7, 0x00, 0x97, 0x52, 0x0a, 0x68, + 0x00, 0x97, 0x55, 0x4f, 0x5a, 0x00, 0x97, 0x56, + 0x0f, 0x03, 0x00, 0x97, 0x57, 0x49, 0xe2, 0x00, + 0x97, 0x58, 0x59, 0x43, 0x00, 0x97, 0x59, 0x0a, + 0x69, 0x00, 0x97, 0x5a, 0x3b, 0xab, 0x00, 0x97, + 0x5b, 0x49, 0xe3, 0x00, 0x97, 0x5c, 0x1b, 0xe9, + 0x00, 0x97, 0x5e, 0x0d, 0x87, 0x00, 0x97, 0x60, + 0x1b, 0xea, 0x00, 0x97, 0x61, 0x1d, 0x06, 0x00, + 0x97, 0x62, 0x0e, 0xd8, 0x00, 0x97, 0x63, 0x3b, + 0xac, 0x00, 0x97, 0x64, 0x1b, 0xeb, 0x00, 0x97, + 0x66, 0x1b, 0xec, 0x00, 0x97, 0x67, 0x4e, 0x03, + 0x00, 0x97, 0x68, 0x1b, 0xed, 0x00, 0x97, 0x69, + 0x05, 0xb5, 0x00, 0x97, 0x6a, 0x49, 0xe4, 0x00, + 0x97, 0x6b, 0x1b, 0xef, 0x00, 0x97, 0x6d, 0x0a, + 0x1f, 0x00, 0x97, 0x6e, 0x3b, 0xad, 0x00, 0x97, + 0x71, 0x1b, 0xf0, 0x00, 0x97, 0x73, 0x3b, 0xae, + 0x00, 0x97, 0x74, 0x06, 0xfa, 0x00, 0x97, 0x76, + 0x4e, 0x04, 0x00, 0x97, 0x77, 0x59, 0x44, 0x00, + 0x97, 0x78, 0x59, 0x45, 0x00, 0x97, 0x79, 0x1b, + 0xf1, 0x00, 0x97, 0x7a, 0x1b, 0xf5, 0x00, 0x97, + 0x7b, 0x59, 0x46, 0x00, 0x97, 0x7c, 0x1b, 0xf3, + 0x00, 0x97, 0x7d, 0x4e, 0x05, 0x00, 0x97, 0x7f, + 0x4e, 0x06, 0x00, 0x97, 0x80, 0x59, 0x47, 0x00, + 0x97, 0x81, 0x1b, 0xf4, 0x00, 0x97, 0x84, 0x05, + 0xd1, 0x00, 0x97, 0x85, 0x1b, 0xf2, 0x00, 0x97, + 0x86, 0x1b, 0xf6, 0x00, 0x97, 0x89, 0x59, 0x48, + 0x00, 0x97, 0x8b, 0x1b, 0xf7, 0x00, 0x97, 0x8d, + 0x04, 0x8c, 0x00, 0x97, 0x8f, 0x1b, 0xf8, 0x00, + 0x97, 0x90, 0x1b, 0xf9, 0x00, 0x97, 0x95, 0x43, + 0x24, 0x00, 0x97, 0x96, 0x49, 0xe7, 0x00, 0x97, + 0x97, 0x59, 0x49, 0x00, 0x97, 0x98, 0x09, 0xcc, + 0x00, 0x97, 0x99, 0x4e, 0x07, 0x00, 0x97, 0x9a, + 0x3b, 0xaf, 0x00, 0x97, 0x9c, 0x1b, 0xfa, 0x00, + 0x97, 0x9e, 0x49, 0xe8, 0x00, 0x97, 0x9f, 0x4e, + 0x08, 0x00, 0x97, 0xa0, 0x06, 0x61, 0x00, 0x97, + 0xa2, 0x3b, 0xb0, 0x00, 0x97, 0xa3, 0x1b, 0xfd, + 0x00, 0x97, 0xa6, 0x1b, 0xfc, 0x00, 0x97, 0xa8, + 0x1b, 0xfb, 0x00, 0x97, 0xab, 0x1a, 0x34, 0x00, + 0x97, 0xac, 0x4e, 0x09, 0x00, 0x97, 0xad, 0x0e, + 0x2c, 0x00, 0x97, 0xae, 0x43, 0x25, 0x00, 0x97, + 0xb1, 0x49, 0xe9, 0x00, 0x97, 0xb2, 0x49, 0xea, + 0x00, 0x97, 0xb3, 0x1b, 0xfe, 0x00, 0x97, 0xb4, + 0x1b, 0xff, 0x00, 0x97, 0xb5, 0x3b, 0xb1, 0x00, + 0x97, 0xb6, 0x3b, 0xb2, 0x00, 0x97, 0xb8, 0x59, + 0x4a, 0x00, 0x97, 0xb9, 0x4e, 0x0a, 0x00, 0x97, + 0xba, 0x43, 0x26, 0x00, 0x97, 0xbc, 0x59, 0x4b, + 0x00, 0x97, 0xbe, 0x49, 0xeb, 0x00, 0x97, 0xbf, + 0x59, 0x4c, 0x00, 0x97, 0xc1, 0x43, 0x27, 0x00, + 0x97, 0xc3, 0x1c, 0x00, 0x00, 0x97, 0xc4, 0x59, + 0x4d, 0x00, 0x97, 0xc5, 0x59, 0x4e, 0x00, 0x97, + 0xc6, 0x1c, 0x01, 0x00, 0x97, 0xc7, 0x59, 0x4f, + 0x00, 0x97, 0xc8, 0x1c, 0x02, 0x00, 0x97, 0xc9, + 0x43, 0x28, 0x00, 0x97, 0xca, 0x59, 0x50, 0x00, + 0x97, 0xcb, 0x1c, 0x03, 0x00, 0x97, 0xcc, 0x49, + 0xec, 0x00, 0x97, 0xcd, 0x4e, 0x0b, 0x00, 0x97, + 0xce, 0x59, 0x51, 0x00, 0x97, 0xd0, 0x59, 0x52, + 0x00, 0x97, 0xd1, 0x49, 0xed, 0x00, 0x97, 0xd3, + 0x06, 0x16, 0x00, 0x97, 0xd4, 0x49, 0xee, 0x00, + 0x97, 0xd7, 0x59, 0x53, 0x00, 0x97, 0xd8, 0x49, + 0xef, 0x00, 0x97, 0xd9, 0x3b, 0xb3, 0x00, 0x97, + 0xdb, 0x43, 0x29, 0x00, 0x97, 0xdc, 0x1c, 0x04, + 0x00, 0x97, 0xdd, 0x59, 0x54, 0x00, 0x97, 0xde, + 0x3b, 0xb4, 0x00, 0x97, 0xe0, 0x4e, 0x0c, 0x00, + 0x97, 0xe1, 0x49, 0xf0, 0x00, 0x97, 0xe4, 0x59, + 0x55, 0x00, 0x97, 0xed, 0x1c, 0x05, 0x00, 0x97, + 0xee, 0x0c, 0xd9, 0x00, 0x97, 0xef, 0x4e, 0x0d, + 0x00, 0x97, 0xf1, 0x49, 0xf1, 0x00, 0x97, 0xf2, + 0x1c, 0x07, 0x00, 0x97, 0xf3, 0x05, 0x3b, 0x00, + 0x97, 0xf4, 0x3b, 0xb5, 0x00, 0x97, 0xf5, 0x1c, + 0x0a, 0x00, 0x97, 0xf6, 0x1c, 0x09, 0x00, 0x97, + 0xf7, 0x59, 0x56, 0x00, 0x97, 0xf8, 0x59, 0x57, + 0x00, 0x97, 0xfa, 0x59, 0x58, 0x00, 0x97, 0xfb, + 0x04, 0xc6, 0x00, 0x97, 0xff, 0x06, 0xb9, 0x00, + 0x98, 0x01, 0x0e, 0x17, 0x00, 0x98, 0x02, 0x0b, + 0xd6, 0x00, 0x98, 0x03, 0x08, 0x12, 0x00, 0x98, + 0x04, 0x49, 0xf2, 0x00, 0x98, 0x05, 0x07, 0xf2, + 0x00, 0x98, 0x06, 0x09, 0x71, 0x00, 0x98, 0x07, + 0x4e, 0x0e, 0x00, 0x98, 0x08, 0x0a, 0x22, 0x00, + 0x98, 0x0a, 0x3b, 0xb6, 0x00, 0x98, 0x0c, 0x1c, + 0x0c, 0x00, 0x98, 0x0d, 0x49, 0xf3, 0x00, 0x98, + 0x0e, 0x3b, 0xb7, 0x00, 0x98, 0x0f, 0x1c, 0x0b, + 0x00, 0x98, 0x10, 0x0f, 0x2c, 0x00, 0x98, 0x11, + 0x06, 0x24, 0x00, 0x98, 0x12, 0x0d, 0x66, 0x00, + 0x98, 0x13, 0x0c, 0xb4, 0x00, 0x98, 0x14, 0x49, + 0xf4, 0x00, 0x98, 0x16, 0x49, 0xf5, 0x00, 0x98, + 0x17, 0x0a, 0x42, 0x00, 0x98, 0x18, 0x0f, 0x96, + 0x00, 0x98, 0x19, 0x59, 0x59, 0x00, 0x98, 0x1a, + 0x07, 0x31, 0x00, 0x98, 0x1c, 0x59, 0x5a, 0x00, + 0x98, 0x1e, 0x3b, 0xb8, 0x00, 0x98, 0x20, 0x59, + 0x5b, 0x00, 0x98, 0x21, 0x1c, 0x0f, 0x00, 0x98, + 0x23, 0x3b, 0xb9, 0x00, 0x98, 0x24, 0x1c, 0x0e, + 0x00, 0x98, 0x25, 0x49, 0xfa, 0x00, 0x98, 0x26, + 0x4e, 0x0f, 0x00, 0x98, 0x2b, 0x3b, 0xba, 0x00, + 0x98, 0x2c, 0x0e, 0x79, 0x00, 0x98, 0x2d, 0x0c, + 0x84, 0x00, 0x98, 0x2e, 0x4e, 0x10, 0x00, 0x98, + 0x2f, 0x59, 0x5c, 0x00, 0x98, 0x30, 0x1e, 0x73, + 0x00, 0x98, 0x32, 0x49, 0xf8, 0x00, 0x98, 0x33, + 0x49, 0xf9, 0x00, 0x98, 0x34, 0x04, 0xf2, 0x00, + 0x98, 0x35, 0x59, 0x5d, 0x00, 0x98, 0x37, 0x1c, + 0x10, 0x00, 0x98, 0x38, 0x1c, 0x0d, 0x00, 0x98, + 0x39, 0x37, 0xb3, 0x00, 0x98, 0x3b, 0x1e, 0x6c, + 0x00, 0x98, 0x3c, 0x0f, 0x54, 0x00, 0x98, 0x3d, + 0x1c, 0x11, 0x00, 0x98, 0x3e, 0x3b, 0xbb, 0x00, + 0x98, 0x44, 0x59, 0x5e, 0x00, 0x98, 0x46, 0x1c, + 0x12, 0x00, 0x98, 0x47, 0x49, 0xfb, 0x00, 0x98, + 0x4a, 0x59, 0x5f, 0x00, 0x98, 0x4b, 0x1c, 0x14, + 0x00, 0x98, 0x4c, 0x0b, 0x4a, 0x00, 0x98, 0x4d, + 0x05, 0xb9, 0x00, 0x98, 0x4e, 0x05, 0xba, 0x00, + 0x98, 0x4f, 0x1c, 0x13, 0x00, 0x98, 0x51, 0x59, + 0x60, 0x00, 0x98, 0x52, 0x3b, 0xbc, 0x00, 0x98, + 0x53, 0x3b, 0xbd, 0x00, 0x98, 0x54, 0x06, 0x25, + 0x00, 0x98, 0x55, 0x07, 0x66, 0x00, 0x98, 0x56, + 0x43, 0x2a, 0x00, 0x98, 0x57, 0x21, 0xf9, 0x00, + 0x98, 0x58, 0x06, 0x26, 0x00, 0x98, 0x59, 0x3b, + 0xbe, 0x00, 0x98, 0x5a, 0x1e, 0x48, 0x00, 0x98, + 0x5b, 0x0c, 0x39, 0x00, 0x98, 0x5e, 0x34, 0x54, + 0x00, 0x98, 0x62, 0x4e, 0x11, 0x00, 0x98, 0x63, + 0x4e, 0x12, 0x00, 0x98, 0x65, 0x21, 0xfa, 0x00, + 0x98, 0x66, 0x49, 0xfc, 0x00, 0x98, 0x67, 0x07, + 0x90, 0x00, 0x98, 0x6a, 0x59, 0x61, 0x00, 0x98, + 0x6b, 0x1c, 0x15, 0x00, 0x98, 0x6c, 0x3b, 0xbf, + 0x00, 0x98, 0x6f, 0x1c, 0x16, 0x00, 0x98, 0x70, + 0x1c, 0x17, 0x00, 0x98, 0x71, 0x1c, 0x18, 0x00, + 0x98, 0x73, 0x1c, 0x1a, 0x00, 0x98, 0x74, 0x1c, + 0x19, 0x00, 0x98, 0xa8, 0x0d, 0xe9, 0x00, 0x98, + 0xaa, 0x1c, 0x1b, 0x00, 0x98, 0xab, 0x49, 0xfd, + 0x00, 0x98, 0xad, 0x49, 0xfe, 0x00, 0x98, 0xae, + 0x59, 0x62, 0x00, 0x98, 0xaf, 0x1c, 0x1c, 0x00, + 0x98, 0xb0, 0x49, 0xff, 0x00, 0x98, 0xb1, 0x1c, + 0x1d, 0x00, 0x98, 0xb4, 0x4e, 0x13, 0x00, 0x98, + 0xb6, 0x1c, 0x1e, 0x00, 0x98, 0xb7, 0x4a, 0x01, + 0x00, 0x98, 0xb8, 0x3b, 0xc0, 0x00, 0x98, 0xba, + 0x3b, 0xc1, 0x00, 0x98, 0xbb, 0x4a, 0x02, 0x00, + 0x98, 0xbc, 0x4a, 0x03, 0x00, 0x98, 0xbf, 0x3b, + 0xc2, 0x00, 0x98, 0xc2, 0x4a, 0x04, 0x00, 0x98, + 0xc3, 0x1c, 0x20, 0x00, 0x98, 0xc4, 0x1c, 0x1f, + 0x00, 0x98, 0xc5, 0x4e, 0x14, 0x00, 0x98, 0xc6, + 0x1c, 0x21, 0x00, 0x98, 0xc7, 0x4a, 0x05, 0x00, + 0x98, 0xc8, 0x3b, 0xc3, 0x00, 0x98, 0xcb, 0x4a, + 0x06, 0x00, 0x98, 0xcc, 0x59, 0x63, 0x00, 0x98, + 0xdb, 0x0d, 0x88, 0x00, 0x98, 0xdc, 0x18, 0x39, + 0x00, 0x98, 0xdf, 0x09, 0xef, 0x00, 0x98, 0xe0, + 0x36, 0x18, 0x00, 0x98, 0xe1, 0x4a, 0x07, 0x00, + 0x98, 0xe2, 0x06, 0x4c, 0x00, 0x98, 0xe3, 0x4a, + 0x08, 0x00, 0x98, 0xe5, 0x3b, 0xc4, 0x00, 0x98, + 0xe6, 0x59, 0x64, 0x00, 0x98, 0xe7, 0x43, 0x2b, + 0x00, 0x98, 0xe9, 0x1c, 0x22, 0x00, 0x98, 0xea, + 0x4a, 0x09, 0x00, 0x98, 0xeb, 0x1c, 0x23, 0x00, + 0x98, 0xed, 0x10, 0xc1, 0x00, 0x98, 0xee, 0x14, + 0xda, 0x00, 0x98, 0xef, 0x21, 0xfb, 0x00, 0x98, + 0xf0, 0x4a, 0x0a, 0x00, 0x98, 0xf1, 0x4a, 0x0b, + 0x00, 0x98, 0xf2, 0x04, 0xbf, 0x00, 0x98, 0xf3, + 0x4a, 0x0c, 0x00, 0x98, 0xf4, 0x04, 0x7f, 0x00, + 0x98, 0xf6, 0x59, 0x65, 0x00, 0x98, 0xfc, 0x08, + 0xc2, 0x00, 0x98, 0xfd, 0x0e, 0x5e, 0x00, 0x98, + 0xfe, 0x09, 0xe6, 0x00, 0x99, 0x02, 0x4e, 0x15, + 0x00, 0x99, 0x03, 0x1c, 0x24, 0x00, 0x99, 0x05, + 0x0e, 0xeb, 0x00, 0x99, 0x07, 0x59, 0x66, 0x00, + 0x99, 0x08, 0x4a, 0x0d, 0x00, 0x99, 0x09, 0x1c, + 0x25, 0x00, 0x99, 0x0a, 0x0f, 0x46, 0x00, 0x99, + 0x0c, 0x04, 0xe4, 0x00, 0x99, 0x10, 0x08, 0x8f, + 0x00, 0x99, 0x11, 0x4e, 0x16, 0x00, 0x99, 0x12, + 0x1c, 0x26, 0x00, 0x99, 0x13, 0x05, 0x6e, 0x00, + 0x99, 0x14, 0x1c, 0x27, 0x00, 0x99, 0x15, 0x4e, + 0x17, 0x00, 0x99, 0x16, 0x4a, 0x10, 0x00, 0x99, + 0x17, 0x4a, 0x11, 0x00, 0x99, 0x18, 0x1c, 0x28, + 0x00, 0x99, 0x1a, 0x4a, 0x13, 0x00, 0x99, 0x1b, + 0x4a, 0x14, 0x00, 0x99, 0x1c, 0x4a, 0x15, 0x00, + 0x99, 0x1d, 0x1c, 0x2a, 0x00, 0x99, 0x1e, 0x1c, + 0x2b, 0x00, 0x99, 0x1f, 0x59, 0x67, 0x00, 0x99, + 0x20, 0x1c, 0x2d, 0x00, 0x99, 0x21, 0x1c, 0x29, + 0x00, 0x99, 0x22, 0x59, 0x68, 0x00, 0x99, 0x24, + 0x1c, 0x2c, 0x00, 0x99, 0x26, 0x59, 0x69, 0x00, + 0x99, 0x27, 0x21, 0xfd, 0x00, 0x99, 0x28, 0x06, + 0x17, 0x00, 0x99, 0x2b, 0x59, 0x6a, 0x00, 0x99, + 0x2c, 0x1c, 0x2e, 0x00, 0x99, 0x2e, 0x1c, 0x2f, + 0x00, 0x99, 0x31, 0x4a, 0x17, 0x00, 0x99, 0x32, + 0x3b, 0xc5, 0x00, 0x99, 0x33, 0x3b, 0xc6, 0x00, + 0x99, 0x34, 0x59, 0x6b, 0x00, 0x99, 0x35, 0x4e, + 0x18, 0x00, 0x99, 0x39, 0x59, 0x6c, 0x00, 0x99, + 0x3a, 0x4a, 0x18, 0x00, 0x99, 0x3b, 0x4a, 0x19, + 0x00, 0x99, 0x3c, 0x4a, 0x1a, 0x00, 0x99, 0x3d, + 0x1c, 0x30, 0x00, 0x99, 0x3e, 0x1c, 0x31, 0x00, + 0x99, 0x40, 0x3b, 0xc7, 0x00, 0x99, 0x41, 0x4a, + 0x1b, 0x00, 0x99, 0x42, 0x1c, 0x32, 0x00, 0x99, + 0x45, 0x1c, 0x34, 0x00, 0x99, 0x46, 0x4a, 0x1c, + 0x00, 0x99, 0x47, 0x59, 0x6d, 0x00, 0x99, 0x48, + 0x4e, 0x19, 0x00, 0x99, 0x49, 0x1c, 0x33, 0x00, + 0x99, 0x4b, 0x1c, 0x36, 0x00, 0x99, 0x4c, 0x1c, + 0x39, 0x00, 0x99, 0x4d, 0x3b, 0xc8, 0x00, 0x99, + 0x4e, 0x4a, 0x1d, 0x00, 0x99, 0x50, 0x1c, 0x35, + 0x00, 0x99, 0x51, 0x1c, 0x37, 0x00, 0x99, 0x52, + 0x1c, 0x38, 0x00, 0x99, 0x54, 0x4e, 0x1a, 0x00, + 0x99, 0x55, 0x1c, 0x3a, 0x00, 0x99, 0x57, 0x06, + 0xba, 0x00, 0x99, 0x58, 0x43, 0x2c, 0x00, 0x99, + 0x59, 0x59, 0x6e, 0x00, 0x99, 0x5b, 0x59, 0x6f, + 0x00, 0x99, 0x5c, 0x3b, 0xc9, 0x00, 0x99, 0x5e, + 0x4e, 0x1b, 0x00, 0x99, 0x5f, 0x3b, 0xca, 0x00, + 0x99, 0x60, 0x4a, 0x1e, 0x00, 0x99, 0x96, 0x09, + 0x1f, 0x00, 0x99, 0x97, 0x1c, 0x3b, 0x00, 0x99, + 0x98, 0x1c, 0x3c, 0x00, 0x99, 0x99, 0x07, 0xf3, + 0x00, 0x99, 0x9b, 0x59, 0x70, 0x00, 0x99, 0x9d, + 0x59, 0x71, 0x00, 0x99, 0x9e, 0x21, 0xff, 0x00, + 0x99, 0x9f, 0x59, 0x72, 0x00, 0x99, 0xa3, 0x4a, + 0x1f, 0x00, 0x99, 0xa5, 0x1c, 0x3d, 0x00, 0x99, + 0xa6, 0x4a, 0x20, 0x00, 0x99, 0xa8, 0x05, 0x9c, + 0x00, 0x99, 0xac, 0x0d, 0x05, 0x00, 0x99, 0xad, + 0x1c, 0x3e, 0x00, 0x99, 0xae, 0x1c, 0x3f, 0x00, + 0x99, 0xb0, 0x59, 0x73, 0x00, 0x99, 0xb1, 0x3b, + 0xcb, 0x00, 0x99, 0xb2, 0x59, 0x74, 0x00, 0x99, + 0xb3, 0x0b, 0x98, 0x00, 0x99, 0xb4, 0x0c, 0xc3, + 0x00, 0x99, 0xb5, 0x59, 0x75, 0x00, 0x99, 0xb9, + 0x3b, 0xcc, 0x00, 0x99, 0xba, 0x3b, 0xcd, 0x00, + 0x99, 0xbc, 0x1c, 0x40, 0x00, 0x99, 0xbd, 0x4a, + 0x21, 0x00, 0x99, 0xbf, 0x4a, 0x22, 0x00, 0x99, + 0xc1, 0x0d, 0x33, 0x00, 0x99, 0xc3, 0x4a, 0x23, + 0x00, 0x99, 0xc4, 0x0b, 0x2c, 0x00, 0x99, 0xc5, + 0x04, 0xfa, 0x00, 0x99, 0xc6, 0x06, 0xe6, 0x00, + 0x99, 0xc8, 0x06, 0xe7, 0x00, 0x99, 0xc9, 0x3b, + 0xce, 0x00, 0x99, 0xd0, 0x0b, 0xb1, 0x00, 0x99, + 0xd1, 0x1c, 0x45, 0x00, 0x99, 0xd2, 0x06, 0xe8, + 0x00, 0x99, 0xd3, 0x59, 0x76, 0x00, 0x99, 0xd4, + 0x4a, 0x24, 0x00, 0x99, 0xd5, 0x05, 0x6f, 0x00, + 0x99, 0xd8, 0x1c, 0x44, 0x00, 0x99, 0xd9, 0x4a, + 0x25, 0x00, 0x99, 0xda, 0x59, 0x77, 0x00, 0x99, + 0xdb, 0x1c, 0x42, 0x00, 0x99, 0xdc, 0x59, 0x78, + 0x00, 0x99, 0xdd, 0x1c, 0x43, 0x00, 0x99, 0xde, + 0x4a, 0x26, 0x00, 0x99, 0xdf, 0x1c, 0x41, 0x00, + 0x99, 0xe1, 0x4e, 0x1c, 0x00, 0x99, 0xe2, 0x1c, + 0x4f, 0x00, 0x99, 0xe7, 0x59, 0x79, 0x00, 0x99, + 0xea, 0x59, 0x7a, 0x00, 0x99, 0xeb, 0x59, 0x7b, + 0x00, 0x99, 0xec, 0x59, 0x7c, 0x00, 0x99, 0xed, + 0x1c, 0x46, 0x00, 0x99, 0xee, 0x1c, 0x47, 0x00, + 0x99, 0xf0, 0x4a, 0x28, 0x00, 0x99, 0xf1, 0x1c, + 0x48, 0x00, 0x99, 0xf2, 0x1c, 0x49, 0x00, 0x99, + 0xf4, 0x59, 0x7d, 0x00, 0x99, 0xf5, 0x59, 0x7e, + 0x00, 0x99, 0xf8, 0x1c, 0x4b, 0x00, 0x99, 0xf9, + 0x4a, 0x29, 0x00, 0x99, 0xfb, 0x1c, 0x4a, 0x00, + 0x99, 0xfc, 0x4a, 0x2a, 0x00, 0x99, 0xfd, 0x59, + 0x7f, 0x00, 0x99, 0xfe, 0x59, 0x80, 0x00, 0x99, + 0xff, 0x09, 0x63, 0x00, 0x9a, 0x01, 0x1c, 0x4c, + 0x00, 0x9a, 0x02, 0x3b, 0xcf, 0x00, 0x9a, 0x03, + 0x43, 0x2d, 0x00, 0x9a, 0x04, 0x59, 0x81, 0x00, + 0x9a, 0x05, 0x1c, 0x4e, 0x00, 0x9a, 0x08, 0x37, + 0xba, 0x00, 0x9a, 0x0a, 0x4a, 0x2b, 0x00, 0x9a, + 0x0b, 0x59, 0x82, 0x00, 0x9a, 0x0c, 0x4e, 0x1d, + 0x00, 0x9a, 0x0e, 0x06, 0x4d, 0x00, 0x9a, 0x0f, + 0x1c, 0x4d, 0x00, 0x9a, 0x10, 0x4e, 0x1e, 0x00, + 0x9a, 0x11, 0x4a, 0x2c, 0x00, 0x9a, 0x12, 0x0a, + 0xfd, 0x00, 0x9a, 0x13, 0x07, 0x67, 0x00, 0x9a, + 0x16, 0x3b, 0xd0, 0x00, 0x9a, 0x19, 0x1c, 0x50, + 0x00, 0x9a, 0x1a, 0x4a, 0x2d, 0x00, 0x9a, 0x1e, + 0x59, 0x83, 0x00, 0x9a, 0x20, 0x4a, 0x2e, 0x00, + 0x9a, 0x22, 0x59, 0x84, 0x00, 0x9a, 0x23, 0x4e, + 0x1f, 0x00, 0x9a, 0x24, 0x3b, 0xd1, 0x00, 0x9a, + 0x27, 0x3b, 0xd2, 0x00, 0x9a, 0x28, 0x0b, 0x2d, + 0x00, 0x9a, 0x2b, 0x1c, 0x51, 0x00, 0x9a, 0x2d, + 0x3b, 0xd3, 0x00, 0x9a, 0x2e, 0x3b, 0xd4, 0x00, + 0x9a, 0x30, 0x0c, 0x85, 0x00, 0x9a, 0x31, 0x4a, + 0x2f, 0x00, 0x9a, 0x33, 0x59, 0x85, 0x00, 0x9a, + 0x35, 0x59, 0x86, 0x00, 0x9a, 0x36, 0x3b, 0xd5, + 0x00, 0x9a, 0x37, 0x1c, 0x52, 0x00, 0x9a, 0x38, + 0x3b, 0xd6, 0x00, 0x9a, 0x3e, 0x1c, 0x57, 0x00, + 0x9a, 0x40, 0x1c, 0x55, 0x00, 0x9a, 0x41, 0x4e, + 0x20, 0x00, 0x9a, 0x42, 0x1c, 0x54, 0x00, 0x9a, + 0x43, 0x1c, 0x56, 0x00, 0x9a, 0x44, 0x4a, 0x30, + 0x00, 0x9a, 0x45, 0x1c, 0x53, 0x00, 0x9a, 0x47, + 0x59, 0x87, 0x00, 0x9a, 0x4a, 0x3b, 0xd7, 0x00, + 0x9a, 0x4b, 0x59, 0x89, 0x00, 0x9a, 0x4c, 0x4a, + 0x31, 0x00, 0x9a, 0x4d, 0x1c, 0x59, 0x00, 0x9a, + 0x4e, 0x22, 0x00, 0x00, 0x9a, 0x51, 0x4e, 0x21, + 0x00, 0x9a, 0x52, 0x1e, 0x2f, 0x00, 0x9a, 0x54, + 0x59, 0x8a, 0x00, 0x9a, 0x55, 0x1c, 0x58, 0x00, + 0x9a, 0x56, 0x3b, 0xd8, 0x00, 0x9a, 0x57, 0x1c, + 0x5b, 0x00, 0x9a, 0x58, 0x4a, 0x32, 0x00, 0x9a, + 0x5a, 0x06, 0xbb, 0x00, 0x9a, 0x5b, 0x1c, 0x5a, + 0x00, 0x9a, 0x5d, 0x59, 0x8b, 0x00, 0x9a, 0x5f, + 0x1c, 0x5c, 0x00, 0x9a, 0x62, 0x1c, 0x5d, 0x00, + 0x9a, 0x64, 0x1c, 0x5f, 0x00, 0x9a, 0x65, 0x1c, + 0x5e, 0x00, 0x9a, 0x69, 0x1c, 0x60, 0x00, 0x9a, + 0x6a, 0x1c, 0x62, 0x00, 0x9a, 0x6b, 0x1c, 0x61, + 0x00, 0x9a, 0xa8, 0x08, 0x0e, 0x00, 0x9a, 0xaa, + 0x59, 0x8c, 0x00, 0x9a, 0xac, 0x59, 0x8d, 0x00, + 0x9a, 0xad, 0x1c, 0x63, 0x00, 0x9a, 0xae, 0x59, + 0x8e, 0x00, 0x9a, 0xaf, 0x4a, 0x34, 0x00, 0x9a, + 0xb0, 0x1c, 0x64, 0x00, 0x9a, 0xb2, 0x59, 0x8f, + 0x00, 0x9a, 0xb4, 0x59, 0x90, 0x00, 0x9a, 0xb5, + 0x3b, 0xd9, 0x00, 0x9a, 0xb6, 0x3b, 0xda, 0x00, + 0x9a, 0xb7, 0x4a, 0x36, 0x00, 0x9a, 0xb8, 0x05, + 0x9a, 0x00, 0x9a, 0xb9, 0x4a, 0x38, 0x00, 0x9a, + 0xbb, 0x59, 0x91, 0x00, 0x9a, 0xbc, 0x1c, 0x65, + 0x00, 0x9a, 0xbd, 0x4e, 0x22, 0x00, 0x9a, 0xbe, + 0x4e, 0x23, 0x00, 0x9a, 0xbf, 0x59, 0x92, 0x00, + 0x9a, 0xc0, 0x1c, 0x66, 0x00, 0x9a, 0xc1, 0x43, + 0x2e, 0x00, 0x9a, 0xc3, 0x43, 0x2f, 0x00, 0x9a, + 0xc4, 0x0a, 0x37, 0x00, 0x9a, 0xc6, 0x4a, 0x3a, + 0x00, 0x9a, 0xc8, 0x59, 0x93, 0x00, 0x9a, 0xce, + 0x43, 0x30, 0x00, 0x9a, 0xcf, 0x1c, 0x67, 0x00, + 0x9a, 0xd0, 0x4a, 0x3b, 0x00, 0x9a, 0xd1, 0x1c, + 0x68, 0x00, 0x9a, 0xd2, 0x4a, 0x3c, 0x00, 0x9a, + 0xd3, 0x1c, 0x69, 0x00, 0x9a, 0xd4, 0x1c, 0x6a, + 0x00, 0x9a, 0xd5, 0x4a, 0x3d, 0x00, 0x9a, 0xd6, + 0x43, 0x31, 0x00, 0x9a, 0xd7, 0x59, 0x94, 0x00, + 0x9a, 0xd8, 0x07, 0xf4, 0x00, 0x9a, 0xd9, 0x22, + 0x01, 0x00, 0x9a, 0xdb, 0x59, 0x95, 0x00, 0x9a, + 0xdc, 0x22, 0x02, 0x00, 0x9a, 0xde, 0x1c, 0x6b, + 0x00, 0x9a, 0xdf, 0x1c, 0x6c, 0x00, 0x9a, 0xe0, + 0x4a, 0x3e, 0x00, 0x9a, 0xe2, 0x1c, 0x6d, 0x00, + 0x9a, 0xe3, 0x1c, 0x6e, 0x00, 0x9a, 0xe4, 0x59, + 0x96, 0x00, 0x9a, 0xe5, 0x4a, 0x3f, 0x00, 0x9a, + 0xe6, 0x1c, 0x6f, 0x00, 0x9a, 0xe7, 0x59, 0x97, + 0x00, 0x9a, 0xe9, 0x4a, 0x40, 0x00, 0x9a, 0xea, + 0x0d, 0x45, 0x00, 0x9a, 0xeb, 0x1c, 0x71, 0x00, + 0x9a, 0xec, 0x59, 0x98, 0x00, 0x9a, 0xed, 0x0d, + 0x98, 0x00, 0x9a, 0xee, 0x1c, 0x72, 0x00, 0x9a, + 0xef, 0x1c, 0x70, 0x00, 0x9a, 0xf1, 0x1c, 0x74, + 0x00, 0x9a, 0xf2, 0x59, 0x99, 0x00, 0x9a, 0xf3, + 0x59, 0x9a, 0x00, 0x9a, 0xf4, 0x1c, 0x73, 0x00, + 0x9a, 0xf5, 0x59, 0x9b, 0x00, 0x9a, 0xf7, 0x1c, + 0x75, 0x00, 0x9a, 0xf9, 0x3b, 0xdb, 0x00, 0x9a, + 0xfa, 0x59, 0x9c, 0x00, 0x9a, 0xfb, 0x1c, 0x76, + 0x00, 0x9a, 0xfd, 0x59, 0x9d, 0x00, 0x9a, 0xff, + 0x59, 0x9e, 0x00, 0x9b, 0x00, 0x59, 0x9f, 0x00, + 0x9b, 0x01, 0x4e, 0x24, 0x00, 0x9b, 0x02, 0x43, + 0x32, 0x00, 0x9b, 0x03, 0x3b, 0xdc, 0x00, 0x9b, + 0x04, 0x59, 0xa0, 0x00, 0x9b, 0x05, 0x59, 0xa1, + 0x00, 0x9b, 0x06, 0x1c, 0x77, 0x00, 0x9b, 0x08, + 0x43, 0x33, 0x00, 0x9b, 0x09, 0x4e, 0x25, 0x00, + 0x9b, 0x0b, 0x4e, 0x26, 0x00, 0x9b, 0x0c, 0x4a, + 0x41, 0x00, 0x9b, 0x0d, 0x4e, 0x27, 0x00, 0x9b, + 0x0e, 0x4e, 0x28, 0x00, 0x9b, 0x10, 0x4a, 0x42, + 0x00, 0x9b, 0x12, 0x4a, 0x43, 0x00, 0x9b, 0x16, + 0x4a, 0x44, 0x00, 0x9b, 0x18, 0x1c, 0x78, 0x00, + 0x9b, 0x19, 0x4e, 0x29, 0x00, 0x9b, 0x1a, 0x1c, + 0x79, 0x00, 0x9b, 0x1b, 0x59, 0xa2, 0x00, 0x9b, + 0x1c, 0x4a, 0x45, 0x00, 0x9b, 0x1d, 0x4f, 0x49, + 0x00, 0x9b, 0x1f, 0x1c, 0x7a, 0x00, 0x9b, 0x20, + 0x3b, 0xdd, 0x00, 0x9b, 0x22, 0x1c, 0x7b, 0x00, + 0x9b, 0x23, 0x1c, 0x7c, 0x00, 0x9b, 0x25, 0x1c, + 0x7d, 0x00, 0x9b, 0x26, 0x59, 0xa3, 0x00, 0x9b, + 0x27, 0x1c, 0x7e, 0x00, 0x9b, 0x28, 0x1c, 0x7f, + 0x00, 0x9b, 0x29, 0x1c, 0x80, 0x00, 0x9b, 0x2a, + 0x1c, 0x81, 0x00, 0x9b, 0x2b, 0x4a, 0x46, 0x00, + 0x9b, 0x2c, 0x4f, 0x4a, 0x00, 0x9b, 0x2d, 0x43, + 0x35, 0x00, 0x9b, 0x2e, 0x1c, 0x82, 0x00, 0x9b, + 0x2f, 0x1c, 0x83, 0x00, 0x9b, 0x31, 0x14, 0xd4, + 0x00, 0x9b, 0x32, 0x1c, 0x84, 0x00, 0x9b, 0x33, + 0x3b, 0xde, 0x00, 0x9b, 0x34, 0x3b, 0xdf, 0x00, + 0x9b, 0x35, 0x4e, 0x2a, 0x00, 0x9b, 0x37, 0x59, + 0xa5, 0x00, 0x9b, 0x39, 0x59, 0xa6, 0x00, 0x9b, + 0x3a, 0x59, 0xa7, 0x00, 0x9b, 0x3b, 0x17, 0xa9, + 0x00, 0x9b, 0x3c, 0x06, 0x4e, 0x00, 0x9b, 0x3d, + 0x4a, 0x47, 0x00, 0x9b, 0x41, 0x05, 0x7f, 0x00, + 0x9b, 0x42, 0x08, 0x22, 0x00, 0x9b, 0x43, 0x1c, + 0x86, 0x00, 0x9b, 0x44, 0x1c, 0x85, 0x00, 0x9b, + 0x45, 0x0e, 0xb1, 0x00, 0x9b, 0x48, 0x4e, 0x2b, + 0x00, 0x9b, 0x4b, 0x4a, 0x49, 0x00, 0x9b, 0x4c, + 0x59, 0xa8, 0x00, 0x9b, 0x4d, 0x1c, 0x88, 0x00, + 0x9b, 0x4e, 0x1c, 0x89, 0x00, 0x9b, 0x4f, 0x1c, + 0x87, 0x00, 0x9b, 0x51, 0x1c, 0x8a, 0x00, 0x9b, + 0x54, 0x0e, 0x90, 0x00, 0x9b, 0x55, 0x4e, 0x2c, + 0x00, 0x9b, 0x56, 0x59, 0xa9, 0x00, 0x9b, 0x57, + 0x59, 0xaa, 0x00, 0x9b, 0x58, 0x1c, 0x8b, 0x00, + 0x9b, 0x5a, 0x06, 0x95, 0x00, 0x9b, 0x5b, 0x59, + 0xab, 0x00, 0x9b, 0x5e, 0x43, 0x36, 0x00, 0x9b, + 0x61, 0x59, 0xac, 0x00, 0x9b, 0x63, 0x4a, 0x4a, + 0x00, 0x9b, 0x65, 0x4a, 0x4b, 0x00, 0x9b, 0x66, + 0x43, 0x37, 0x00, 0x9b, 0x68, 0x4e, 0x2d, 0x00, + 0x9b, 0x6a, 0x59, 0xad, 0x00, 0x9b, 0x6b, 0x4a, + 0x4c, 0x00, 0x9b, 0x6c, 0x4a, 0x4d, 0x00, 0x9b, + 0x6d, 0x59, 0xae, 0x00, 0x9b, 0x6e, 0x59, 0xaf, + 0x00, 0x9b, 0x6f, 0x0f, 0xcb, 0x00, 0x9b, 0x72, + 0x22, 0x04, 0x00, 0x9b, 0x73, 0x3b, 0xe0, 0x00, + 0x9b, 0x74, 0x1c, 0x8c, 0x00, 0x9b, 0x75, 0x22, + 0x03, 0x00, 0x9b, 0x76, 0x4a, 0x4e, 0x00, 0x9b, + 0x77, 0x4a, 0x4f, 0x00, 0x9b, 0x78, 0x59, 0xb0, + 0x00, 0x9b, 0x79, 0x3b, 0xe1, 0x00, 0x9b, 0x7f, + 0x59, 0xb1, 0x00, 0x9b, 0x80, 0x4e, 0x2e, 0x00, + 0x9b, 0x83, 0x1c, 0x8e, 0x00, 0x9b, 0x84, 0x43, + 0x38, 0x00, 0x9b, 0x85, 0x59, 0xb2, 0x00, 0x9b, + 0x86, 0x4e, 0x2f, 0x00, 0x9b, 0x87, 0x59, 0xb3, + 0x00, 0x9b, 0x89, 0x59, 0xb4, 0x00, 0x9b, 0x8a, + 0x43, 0x39, 0x00, 0x9b, 0x8b, 0x59, 0xb5, 0x00, + 0x9b, 0x8d, 0x59, 0xb6, 0x00, 0x9b, 0x8e, 0x04, + 0x82, 0x00, 0x9b, 0x8f, 0x22, 0x05, 0x00, 0x9b, + 0x90, 0x4e, 0x30, 0x00, 0x9b, 0x91, 0x1c, 0x8f, + 0x00, 0x9b, 0x92, 0x0d, 0xfb, 0x00, 0x9b, 0x93, + 0x1c, 0x8d, 0x00, 0x9b, 0x94, 0x59, 0xb7, 0x00, + 0x9b, 0x96, 0x1c, 0x90, 0x00, 0x9b, 0x97, 0x1c, + 0x91, 0x00, 0x9b, 0x9a, 0x59, 0xb8, 0x00, 0x9b, + 0x9d, 0x4e, 0x31, 0x00, 0x9b, 0x9e, 0x43, 0x3a, + 0x00, 0x9b, 0x9f, 0x1c, 0x92, 0x00, 0x9b, 0xa0, + 0x1c, 0x93, 0x00, 0x9b, 0xa6, 0x4a, 0x50, 0x00, + 0x9b, 0xa7, 0x3b, 0xe2, 0x00, 0x9b, 0xa8, 0x1c, + 0x94, 0x00, 0x9b, 0xa9, 0x59, 0xb9, 0x00, 0x9b, + 0xaa, 0x0e, 0x9c, 0x00, 0x9b, 0xab, 0x08, 0x7b, + 0x00, 0x9b, 0xac, 0x4a, 0x51, 0x00, 0x9b, 0xad, + 0x08, 0x6a, 0x00, 0x9b, 0xae, 0x0a, 0xb1, 0x00, + 0x9b, 0xb0, 0x4e, 0x32, 0x00, 0x9b, 0xb1, 0x22, + 0x06, 0x00, 0x9b, 0xb2, 0x4a, 0x53, 0x00, 0x9b, + 0xb4, 0x1c, 0x95, 0x00, 0x9b, 0xb7, 0x59, 0xba, + 0x00, 0x9b, 0xb8, 0x4a, 0x54, 0x00, 0x9b, 0xb9, + 0x1c, 0x98, 0x00, 0x9b, 0xbb, 0x22, 0x07, 0x00, + 0x9b, 0xbc, 0x59, 0xbb, 0x00, 0x9b, 0xbe, 0x4a, + 0x55, 0x00, 0x9b, 0xbf, 0x4e, 0x33, 0x00, 0x9b, + 0xc0, 0x1c, 0x96, 0x00, 0x9b, 0xc1, 0x3b, 0xe3, + 0x00, 0x9b, 0xc6, 0x1c, 0x99, 0x00, 0x9b, 0xc7, + 0x3b, 0xe4, 0x00, 0x9b, 0xc8, 0x4e, 0x34, 0x00, + 0x9b, 0xc9, 0x07, 0xa5, 0x00, 0x9b, 0xca, 0x1c, + 0x97, 0x00, 0x9b, 0xce, 0x43, 0x3b, 0x00, 0x9b, + 0xcf, 0x1c, 0x9a, 0x00, 0x9b, 0xd0, 0x59, 0xbc, + 0x00, 0x9b, 0xd1, 0x1c, 0x9b, 0x00, 0x9b, 0xd2, + 0x1c, 0x9c, 0x00, 0x9b, 0xd4, 0x1c, 0xa0, 0x00, + 0x9b, 0xd6, 0x08, 0x78, 0x00, 0x9b, 0xd7, 0x3b, + 0xe5, 0x00, 0x9b, 0xd8, 0x4a, 0x57, 0x00, 0x9b, + 0xdb, 0x0b, 0x44, 0x00, 0x9b, 0xdd, 0x4a, 0x58, + 0x00, 0x9b, 0xdf, 0x37, 0xbf, 0x00, 0x9b, 0xe1, + 0x1c, 0xa1, 0x00, 0x9b, 0xe2, 0x1c, 0x9e, 0x00, + 0x9b, 0xe3, 0x1c, 0x9d, 0x00, 0x9b, 0xe4, 0x1c, + 0x9f, 0x00, 0x9b, 0xe5, 0x43, 0x3c, 0x00, 0x9b, + 0xe7, 0x3b, 0xe6, 0x00, 0x9b, 0xe8, 0x07, 0x35, + 0x00, 0x9b, 0xea, 0x4a, 0x59, 0x00, 0x9b, 0xeb, + 0x3b, 0xe7, 0x00, 0x9b, 0xee, 0x4a, 0x5b, 0x00, + 0x9b, 0xef, 0x4a, 0x5a, 0x00, 0x9b, 0xf0, 0x1c, + 0xa5, 0x00, 0x9b, 0xf1, 0x1c, 0xa4, 0x00, 0x9b, + 0xf2, 0x1c, 0xa3, 0x00, 0x9b, 0xf3, 0x4a, 0x56, + 0x00, 0x9b, 0xf5, 0x04, 0x77, 0x00, 0x9b, 0xf7, + 0x3b, 0xe8, 0x00, 0x9b, 0xf8, 0x43, 0x3d, 0x00, + 0x9b, 0xf9, 0x59, 0xbd, 0x00, 0x9b, 0xfa, 0x3b, + 0xe9, 0x00, 0x9b, 0xfd, 0x3b, 0xea, 0x00, 0x9b, + 0xff, 0x4e, 0x35, 0x00, 0x9c, 0x00, 0x22, 0x08, + 0x00, 0x9c, 0x02, 0x4e, 0x36, 0x00, 0x9c, 0x04, + 0x1c, 0xaf, 0x00, 0x9c, 0x06, 0x1c, 0xab, 0x00, + 0x9c, 0x08, 0x1c, 0xac, 0x00, 0x9c, 0x09, 0x1c, + 0xa8, 0x00, 0x9c, 0x0a, 0x1c, 0xae, 0x00, 0x9c, + 0x0b, 0x3b, 0xeb, 0x00, 0x9c, 0x0c, 0x1c, 0xaa, + 0x00, 0x9c, 0x0d, 0x05, 0xc0, 0x00, 0x9c, 0x0f, + 0x59, 0xbe, 0x00, 0x9c, 0x10, 0x0f, 0xf2, 0x00, + 0x9c, 0x11, 0x59, 0xbf, 0x00, 0x9c, 0x12, 0x1c, + 0xad, 0x00, 0x9c, 0x13, 0x1c, 0xa9, 0x00, 0x9c, + 0x14, 0x1c, 0xa7, 0x00, 0x9c, 0x15, 0x1c, 0xa6, + 0x00, 0x9c, 0x16, 0x4a, 0x5f, 0x00, 0x9c, 0x18, + 0x4a, 0x60, 0x00, 0x9c, 0x19, 0x4a, 0x61, 0x00, + 0x9c, 0x1a, 0x4a, 0x62, 0x00, 0x9c, 0x1b, 0x1c, + 0xb1, 0x00, 0x9c, 0x1c, 0x4e, 0x37, 0x00, 0x9c, + 0x1d, 0x4a, 0x63, 0x00, 0x9c, 0x1e, 0x59, 0xc0, + 0x00, 0x9c, 0x21, 0x1c, 0xb4, 0x00, 0x9c, 0x22, + 0x4a, 0x64, 0x00, 0x9c, 0x23, 0x43, 0x3e, 0x00, + 0x9c, 0x24, 0x1c, 0xb3, 0x00, 0x9c, 0x25, 0x1c, + 0xb2, 0x00, 0x9c, 0x26, 0x59, 0xc1, 0x00, 0x9c, + 0x27, 0x3b, 0xec, 0x00, 0x9c, 0x28, 0x59, 0xc2, + 0x00, 0x9c, 0x29, 0x4a, 0x65, 0x00, 0x9c, 0x2a, + 0x3b, 0xed, 0x00, 0x9c, 0x2d, 0x0d, 0xbb, 0x00, + 0x9c, 0x2e, 0x1c, 0xb0, 0x00, 0x9c, 0x2f, 0x04, + 0xb7, 0x00, 0x9c, 0x30, 0x1c, 0xb5, 0x00, 0x9c, + 0x31, 0x4a, 0x67, 0x00, 0x9c, 0x32, 0x1c, 0xb7, + 0x00, 0x9c, 0x35, 0x4e, 0x38, 0x00, 0x9c, 0x36, + 0x3b, 0xee, 0x00, 0x9c, 0x37, 0x4a, 0x68, 0x00, + 0x9c, 0x39, 0x05, 0xcd, 0x00, 0x9c, 0x3a, 0x1c, + 0xa2, 0x00, 0x9c, 0x3b, 0x04, 0xd9, 0x00, 0x9c, + 0x3d, 0x59, 0xc3, 0x00, 0x9c, 0x3e, 0x1c, 0xb9, + 0x00, 0x9c, 0x41, 0x3b, 0xef, 0x00, 0x9c, 0x43, + 0x59, 0xc4, 0x00, 0x9c, 0x44, 0x4e, 0x39, 0x00, + 0x9c, 0x45, 0x4a, 0x69, 0x00, 0x9c, 0x46, 0x1c, + 0xb8, 0x00, 0x9c, 0x47, 0x1c, 0xb6, 0x00, 0x9c, + 0x48, 0x0b, 0x6b, 0x00, 0x9c, 0x49, 0x4a, 0x6c, + 0x00, 0x9c, 0x4a, 0x4a, 0x6d, 0x00, 0x9c, 0x4e, + 0x59, 0xc5, 0x00, 0x9c, 0x4f, 0x43, 0x3f, 0x00, + 0x9c, 0x50, 0x43, 0x40, 0x00, 0x9c, 0x52, 0x0e, + 0x9e, 0x00, 0x9c, 0x53, 0x3b, 0xf0, 0x00, 0x9c, + 0x54, 0x4a, 0x6f, 0x00, 0x9c, 0x56, 0x4e, 0x3a, + 0x00, 0x9c, 0x57, 0x0f, 0xa2, 0x00, 0x9c, 0x58, + 0x4a, 0x70, 0x00, 0x9c, 0x5a, 0x1c, 0xba, 0x00, + 0x9c, 0x5b, 0x4a, 0x71, 0x00, 0x9c, 0x5c, 0x4a, + 0x6a, 0x00, 0x9c, 0x5d, 0x4a, 0x72, 0x00, 0x9c, + 0x5e, 0x59, 0xc6, 0x00, 0x9c, 0x5f, 0x4a, 0x73, + 0x00, 0x9c, 0x60, 0x1c, 0xbb, 0x00, 0x9c, 0x61, + 0x4e, 0x3b, 0x00, 0x9c, 0x63, 0x3b, 0xf1, 0x00, + 0x9c, 0x65, 0x43, 0x41, 0x00, 0x9c, 0x67, 0x1c, + 0xbc, 0x00, 0x9c, 0x68, 0x4e, 0x3c, 0x00, 0x9c, + 0x69, 0x4a, 0x74, 0x00, 0x9c, 0x6a, 0x4a, 0x75, + 0x00, 0x9c, 0x6b, 0x4a, 0x76, 0x00, 0x9c, 0x6d, + 0x4a, 0x77, 0x00, 0x9c, 0x6e, 0x4a, 0x78, 0x00, + 0x9c, 0x70, 0x3b, 0xf2, 0x00, 0x9c, 0x72, 0x4a, + 0x79, 0x00, 0x9c, 0x75, 0x4a, 0x7a, 0x00, 0x9c, + 0x76, 0x1c, 0xbd, 0x00, 0x9c, 0x77, 0x3b, 0xf3, + 0x00, 0x9c, 0x78, 0x1c, 0xbe, 0x00, 0x9c, 0x7a, + 0x4a, 0x7b, 0x00, 0x9c, 0x7b, 0x59, 0xc7, 0x00, + 0x9c, 0xe5, 0x0b, 0xd7, 0x00, 0x9c, 0xe6, 0x4a, + 0x7c, 0x00, 0x9c, 0xe7, 0x1c, 0xbf, 0x00, 0x9c, + 0xe9, 0x0d, 0x4b, 0x00, 0x9c, 0xeb, 0x1c, 0xc4, + 0x00, 0x9c, 0xec, 0x1c, 0xc0, 0x00, 0x9c, 0xf0, + 0x1c, 0xc1, 0x00, 0x9c, 0xf2, 0x4a, 0x7d, 0x00, + 0x9c, 0xf3, 0x0e, 0x5f, 0x00, 0x9c, 0xf4, 0x0e, + 0xd0, 0x00, 0x9c, 0xf6, 0x0c, 0xa8, 0x00, 0x9c, + 0xf7, 0x59, 0xc8, 0x00, 0x9c, 0xf9, 0x59, 0xc9, + 0x00, 0x9d, 0x02, 0x3b, 0xf4, 0x00, 0x9d, 0x03, + 0x1c, 0xc5, 0x00, 0x9d, 0x06, 0x1c, 0xc6, 0x00, + 0x9d, 0x07, 0x0c, 0x96, 0x00, 0x9d, 0x08, 0x1c, + 0xc3, 0x00, 0x9d, 0x09, 0x1c, 0xc2, 0x00, 0x9d, + 0x0b, 0x4a, 0x7e, 0x00, 0x9d, 0x0e, 0x05, 0x2a, + 0x00, 0x9d, 0x11, 0x4a, 0x80, 0x00, 0x9d, 0x12, + 0x1c, 0xce, 0x00, 0x9d, 0x15, 0x1c, 0xcd, 0x00, + 0x9d, 0x17, 0x4a, 0x81, 0x00, 0x9d, 0x18, 0x4a, + 0x82, 0x00, 0x9d, 0x1b, 0x05, 0x17, 0x00, 0x9d, + 0x1c, 0x59, 0xca, 0x00, 0x9d, 0x1d, 0x43, 0x42, + 0x00, 0x9d, 0x1e, 0x43, 0x43, 0x00, 0x9d, 0x1f, + 0x1c, 0xcb, 0x00, 0x9d, 0x23, 0x1c, 0xca, 0x00, + 0x9d, 0x26, 0x1c, 0xc8, 0x00, 0x9d, 0x28, 0x05, + 0xd9, 0x00, 0x9d, 0x2a, 0x1c, 0xc7, 0x00, 0x9d, + 0x2b, 0x08, 0xde, 0x00, 0x9d, 0x2c, 0x05, 0x29, + 0x00, 0x9d, 0x2f, 0x59, 0xcb, 0x00, 0x9d, 0x30, + 0x4e, 0x3d, 0x00, 0x9d, 0x32, 0x4a, 0x86, 0x00, + 0x9d, 0x33, 0x59, 0xcc, 0x00, 0x9d, 0x34, 0x59, + 0xcd, 0x00, 0x9d, 0x3a, 0x59, 0xce, 0x00, 0x9d, + 0x3b, 0x07, 0xf5, 0x00, 0x9d, 0x3c, 0x59, 0xcf, + 0x00, 0x9d, 0x3d, 0x4e, 0x3e, 0x00, 0x9d, 0x3e, + 0x1c, 0xd1, 0x00, 0x9d, 0x3f, 0x1c, 0xd0, 0x00, + 0x9d, 0x41, 0x1c, 0xcf, 0x00, 0x9d, 0x42, 0x3b, + 0xf5, 0x00, 0x9d, 0x43, 0x43, 0x44, 0x00, 0x9d, + 0x44, 0x1c, 0xcc, 0x00, 0x9d, 0x45, 0x59, 0xd0, + 0x00, 0x9d, 0x46, 0x1c, 0xd2, 0x00, 0x9d, 0x47, + 0x3b, 0xf6, 0x00, 0x9d, 0x48, 0x1c, 0xd3, 0x00, + 0x9d, 0x4a, 0x4a, 0x88, 0x00, 0x9d, 0x50, 0x1c, + 0xd8, 0x00, 0x9d, 0x51, 0x1c, 0xd7, 0x00, 0x9d, + 0x52, 0x43, 0x45, 0x00, 0x9d, 0x53, 0x59, 0xd1, + 0x00, 0x9d, 0x54, 0x59, 0xd2, 0x00, 0x9d, 0x59, + 0x1c, 0xd9, 0x00, 0x9d, 0x5c, 0x04, 0xcf, 0x00, + 0x9d, 0x5d, 0x1c, 0xd4, 0x00, 0x9d, 0x5e, 0x1c, + 0xd5, 0x00, 0x9d, 0x5f, 0x4a, 0x89, 0x00, 0x9d, + 0x60, 0x08, 0x06, 0x00, 0x9d, 0x61, 0x0e, 0xc5, + 0x00, 0x9d, 0x62, 0x4a, 0x8a, 0x00, 0x9d, 0x63, + 0x3b, 0xf7, 0x00, 0x9d, 0x64, 0x1c, 0xd6, 0x00, + 0x9d, 0x65, 0x59, 0xd3, 0x00, 0x9d, 0x69, 0x3b, + 0xf8, 0x00, 0x9d, 0x6a, 0x4e, 0x3f, 0x00, 0x9d, + 0x6b, 0x22, 0x0a, 0x00, 0x9d, 0x6c, 0x0e, 0x60, + 0x00, 0x9d, 0x6f, 0x1c, 0xde, 0x00, 0x9d, 0x70, + 0x22, 0x09, 0x00, 0x9d, 0x72, 0x1c, 0xda, 0x00, + 0x9d, 0x73, 0x4a, 0x8d, 0x00, 0x9d, 0x76, 0x4a, + 0x8e, 0x00, 0x9d, 0x77, 0x4a, 0x8f, 0x00, 0x9d, + 0x7a, 0x1c, 0xdf, 0x00, 0x9d, 0x7b, 0x4e, 0x40, + 0x00, 0x9d, 0x7c, 0x3b, 0xf9, 0x00, 0x9d, 0x7e, + 0x3b, 0xfa, 0x00, 0x9d, 0x83, 0x59, 0xd4, 0x00, + 0x9d, 0x84, 0x4a, 0x90, 0x00, 0x9d, 0x86, 0x59, + 0xd5, 0x00, 0x9d, 0x87, 0x1c, 0xdc, 0x00, 0x9d, + 0x89, 0x1c, 0xdb, 0x00, 0x9d, 0x8a, 0x43, 0x46, + 0x00, 0x9d, 0x8d, 0x3b, 0xfb, 0x00, 0x9d, 0x8e, + 0x59, 0xd6, 0x00, 0x9d, 0x8f, 0x07, 0x32, 0x00, + 0x9d, 0x92, 0x59, 0xd7, 0x00, 0x9d, 0x93, 0x59, + 0xd8, 0x00, 0x9d, 0x95, 0x59, 0xd9, 0x00, 0x9d, + 0x96, 0x43, 0x47, 0x00, 0x9d, 0x97, 0x59, 0xda, + 0x00, 0x9d, 0x98, 0x59, 0xdb, 0x00, 0x9d, 0x99, + 0x4a, 0x91, 0x00, 0x9d, 0x9a, 0x1c, 0xe0, 0x00, + 0x9d, 0xa1, 0x4a, 0x92, 0x00, 0x9d, 0xa4, 0x1c, + 0xe1, 0x00, 0x9d, 0xa9, 0x1c, 0xe2, 0x00, 0x9d, + 0xaa, 0x59, 0xdc, 0x00, 0x9d, 0xab, 0x1c, 0xdd, + 0x00, 0x9d, 0xac, 0x43, 0x49, 0x00, 0x9d, 0xae, + 0x59, 0xdd, 0x00, 0x9d, 0xaf, 0x1c, 0xc9, 0x00, + 0x9d, 0xb1, 0x3b, 0xfc, 0x00, 0x9d, 0xb2, 0x1c, + 0xe3, 0x00, 0x9d, 0xb4, 0x22, 0x0b, 0x00, 0x9d, + 0xb5, 0x4a, 0x94, 0x00, 0x9d, 0xb8, 0x1c, 0xe7, + 0x00, 0x9d, 0xb9, 0x4a, 0x95, 0x00, 0x9d, 0xba, + 0x1c, 0xe8, 0x00, 0x9d, 0xbb, 0x1c, 0xe6, 0x00, + 0x9d, 0xbc, 0x43, 0x4a, 0x00, 0x9d, 0xbd, 0x4a, + 0x96, 0x00, 0x9d, 0xbf, 0x4a, 0x93, 0x00, 0x9d, + 0xc0, 0x43, 0x48, 0x00, 0x9d, 0xc1, 0x1c, 0xe5, + 0x00, 0x9d, 0xc2, 0x1c, 0xeb, 0x00, 0x9d, 0xc3, + 0x3b, 0xfd, 0x00, 0x9d, 0xc4, 0x1c, 0xe4, 0x00, + 0x9d, 0xc6, 0x1c, 0xe9, 0x00, 0x9d, 0xc7, 0x3b, + 0xfe, 0x00, 0x9d, 0xc9, 0x4a, 0x97, 0x00, 0x9d, + 0xca, 0x59, 0xdf, 0x00, 0x9d, 0xcf, 0x1c, 0xea, + 0x00, 0x9d, 0xd3, 0x1c, 0xed, 0x00, 0x9d, 0xd4, + 0x59, 0xe0, 0x00, 0x9d, 0xd5, 0x59, 0xe1, 0x00, + 0x9d, 0xd6, 0x3b, 0xff, 0x00, 0x9d, 0xd7, 0x1d, + 0xde, 0x00, 0x9d, 0xd9, 0x1c, 0xec, 0x00, 0x9d, + 0xda, 0x4a, 0x98, 0x00, 0x9d, 0xde, 0x59, 0xe2, + 0x00, 0x9d, 0xdf, 0x3c, 0x00, 0x00, 0x9d, 0xe0, + 0x4a, 0x99, 0x00, 0x9d, 0xe3, 0x4a, 0x9a, 0x00, + 0x9d, 0xe5, 0x4e, 0x41, 0x00, 0x9d, 0xe6, 0x1c, + 0xef, 0x00, 0x9d, 0xe7, 0x43, 0x4c, 0x00, 0x9d, + 0xe9, 0x4e, 0x42, 0x00, 0x9d, 0xeb, 0x3c, 0x01, + 0x00, 0x9d, 0xed, 0x1c, 0xf0, 0x00, 0x9d, 0xee, + 0x59, 0xe3, 0x00, 0x9d, 0xef, 0x1c, 0xf1, 0x00, + 0x9d, 0xf0, 0x59, 0xe4, 0x00, 0x9d, 0xf2, 0x0f, + 0xef, 0x00, 0x9d, 0xf3, 0x4e, 0x43, 0x00, 0x9d, + 0xf4, 0x3c, 0x02, 0x00, 0x9d, 0xf8, 0x1c, 0xee, + 0x00, 0x9d, 0xf9, 0x0b, 0x4b, 0x00, 0x9d, 0xfa, + 0x08, 0x5d, 0x00, 0x9d, 0xfd, 0x1c, 0xf2, 0x00, + 0x9d, 0xfe, 0x59, 0xe5, 0x00, 0x9e, 0x02, 0x4a, + 0x9d, 0x00, 0x9e, 0x07, 0x43, 0x4d, 0x00, 0x9e, + 0x0a, 0x4a, 0x9c, 0x00, 0x9e, 0x0d, 0x4a, 0x9e, + 0x00, 0x9e, 0x0e, 0x59, 0xe6, 0x00, 0x9e, 0x10, + 0x59, 0xe7, 0x00, 0x9e, 0x11, 0x59, 0xe8, 0x00, + 0x9e, 0x12, 0x59, 0xe9, 0x00, 0x9e, 0x15, 0x3c, + 0x03, 0x00, 0x9e, 0x16, 0x59, 0xea, 0x00, 0x9e, + 0x19, 0x22, 0x0c, 0x00, 0x9e, 0x1a, 0x1c, 0xf3, + 0x00, 0x9e, 0x1b, 0x1c, 0xf4, 0x00, 0x9e, 0x1c, + 0x4a, 0x9f, 0x00, 0x9e, 0x1d, 0x3c, 0x04, 0x00, + 0x9e, 0x1e, 0x1c, 0xf5, 0x00, 0x9e, 0x75, 0x1c, + 0xf6, 0x00, 0x9e, 0x78, 0x07, 0x68, 0x00, 0x9e, + 0x79, 0x1c, 0xf7, 0x00, 0x9e, 0x7a, 0x4e, 0x44, + 0x00, 0x9e, 0x7b, 0x4a, 0xa0, 0x00, 0x9e, 0x7c, + 0x1d, 0xfd, 0x00, 0x9e, 0x7d, 0x1c, 0xf8, 0x00, + 0x9e, 0x7f, 0x08, 0xdb, 0x00, 0x9e, 0x80, 0x4a, + 0xa2, 0x00, 0x9e, 0x81, 0x1c, 0xf9, 0x00, 0x9e, + 0x82, 0x4e, 0x45, 0x00, 0x9e, 0x83, 0x4e, 0x46, + 0x00, 0x9e, 0x84, 0x4e, 0x47, 0x00, 0x9e, 0x85, + 0x4a, 0xa3, 0x00, 0x9e, 0x87, 0x59, 0xeb, 0x00, + 0x9e, 0x88, 0x1c, 0xfa, 0x00, 0x9e, 0x8b, 0x1c, + 0xfb, 0x00, 0x9e, 0x8c, 0x1c, 0xfc, 0x00, 0x9e, + 0x8e, 0x59, 0xec, 0x00, 0x9e, 0x8f, 0x59, 0xed, + 0x00, 0x9e, 0x91, 0x1c, 0xff, 0x00, 0x9e, 0x92, + 0x1c, 0xfd, 0x00, 0x9e, 0x93, 0x0f, 0xe2, 0x00, + 0x9e, 0x95, 0x1c, 0xfe, 0x00, 0x9e, 0x96, 0x59, + 0xee, 0x00, 0x9e, 0x97, 0x0f, 0xb7, 0x00, 0x9e, + 0x98, 0x59, 0xef, 0x00, 0x9e, 0x9b, 0x4a, 0xa4, + 0x00, 0x9e, 0x9d, 0x1d, 0x00, 0x00, 0x9e, 0x9e, + 0x43, 0x4e, 0x00, 0x9e, 0x9f, 0x0f, 0xa3, 0x00, + 0x9e, 0xa4, 0x3c, 0x05, 0x00, 0x9e, 0xa5, 0x1d, + 0x01, 0x00, 0x9e, 0xa6, 0x0d, 0x34, 0x00, 0x9e, + 0xa8, 0x3c, 0x06, 0x00, 0x9e, 0xa9, 0x1d, 0x02, + 0x00, 0x9e, 0xaa, 0x1d, 0x04, 0x00, 0x9e, 0xac, + 0x3c, 0x07, 0x00, 0x9e, 0xad, 0x1d, 0x05, 0x00, + 0x9e, 0xae, 0x59, 0xf0, 0x00, 0x9e, 0xaf, 0x43, + 0x4f, 0x00, 0x9e, 0xb0, 0x4e, 0x48, 0x00, 0x9e, + 0xb3, 0x59, 0xf1, 0x00, 0x9e, 0xb4, 0x1e, 0x02, + 0x00, 0x9e, 0xb5, 0x1e, 0x75, 0x00, 0x9e, 0xb8, + 0x1d, 0x03, 0x00, 0x9e, 0xb9, 0x07, 0xff, 0x00, + 0x9e, 0xba, 0x0e, 0xd9, 0x00, 0x9e, 0xbb, 0x0e, + 0x91, 0x00, 0x9e, 0xbc, 0x12, 0x84, 0x00, 0x9e, + 0xbd, 0x4a, 0xa6, 0x00, 0x9e, 0xbe, 0x14, 0xff, + 0x00, 0x9e, 0xbf, 0x0e, 0xa9, 0x00, 0x9e, 0xc3, + 0x34, 0x0b, 0x00, 0x9e, 0xc4, 0x05, 0x2b, 0x00, + 0x9e, 0xc6, 0x59, 0xf2, 0x00, 0x9e, 0xc8, 0x59, + 0xf3, 0x00, 0x9e, 0xcb, 0x59, 0xf4, 0x00, 0x9e, + 0xcc, 0x1d, 0x07, 0x00, 0x9e, 0xcd, 0x06, 0x6a, + 0x00, 0x9e, 0xce, 0x1d, 0x08, 0x00, 0x9e, 0xcf, + 0x1d, 0x09, 0x00, 0x9e, 0xd0, 0x1d, 0x0a, 0x00, + 0x9e, 0xd1, 0x22, 0x0d, 0x00, 0x9e, 0xd2, 0x08, + 0x07, 0x00, 0x9e, 0xd4, 0x1d, 0x0b, 0x00, 0x9e, + 0xd5, 0x59, 0xf5, 0x00, 0x9e, 0xd8, 0x16, 0x0d, + 0x00, 0x9e, 0xd9, 0x0e, 0xe7, 0x00, 0x9e, 0xdb, + 0x0b, 0x43, 0x00, 0x9e, 0xdc, 0x1d, 0x0c, 0x00, + 0x9e, 0xdd, 0x1d, 0x0e, 0x00, 0x9e, 0xde, 0x1d, + 0x0d, 0x00, 0x9e, 0xdf, 0x4a, 0xa8, 0x00, 0x9e, + 0xe0, 0x1d, 0x0f, 0x00, 0x9e, 0xe4, 0x4e, 0x49, + 0x00, 0x9e, 0xe5, 0x1d, 0x10, 0x00, 0x9e, 0xe7, + 0x3c, 0x08, 0x00, 0x9e, 0xe8, 0x1d, 0x11, 0x00, + 0x9e, 0xec, 0x59, 0xf6, 0x00, 0x9e, 0xed, 0x59, + 0xf7, 0x00, 0x9e, 0xee, 0x3c, 0x09, 0x00, 0x9e, + 0xef, 0x1d, 0x12, 0x00, 0x9e, 0xf0, 0x4e, 0x4a, + 0x00, 0x9e, 0xf1, 0x59, 0xf8, 0x00, 0x9e, 0xf2, + 0x4e, 0x4b, 0x00, 0x9e, 0xf4, 0x1d, 0x13, 0x00, + 0x9e, 0xf5, 0x59, 0xf9, 0x00, 0x9e, 0xf6, 0x1d, + 0x14, 0x00, 0x9e, 0xf7, 0x1d, 0x15, 0x00, 0x9e, + 0xf8, 0x59, 0xfa, 0x00, 0x9e, 0xf9, 0x1d, 0x16, + 0x00, 0x9e, 0xfb, 0x1d, 0x17, 0x00, 0x9e, 0xfc, + 0x1d, 0x18, 0x00, 0x9e, 0xfd, 0x1d, 0x19, 0x00, + 0x9e, 0xff, 0x4a, 0xa9, 0x00, 0x9f, 0x02, 0x4a, + 0xaa, 0x00, 0x9f, 0x03, 0x4a, 0xac, 0x00, 0x9f, + 0x07, 0x1d, 0x1a, 0x00, 0x9f, 0x08, 0x1d, 0x1b, + 0x00, 0x9f, 0x09, 0x4e, 0x4c, 0x00, 0x9f, 0x0e, + 0x0c, 0x1e, 0x00, 0x9f, 0x0f, 0x4e, 0x4d, 0x00, + 0x9f, 0x10, 0x3c, 0x0a, 0x00, 0x9f, 0x11, 0x59, + 0xfb, 0x00, 0x9f, 0x12, 0x3c, 0x0b, 0x00, 0x9f, + 0x13, 0x07, 0x91, 0x00, 0x9f, 0x14, 0x4e, 0x4e, + 0x00, 0x9f, 0x15, 0x1d, 0x1d, 0x00, 0x9f, 0x16, + 0x59, 0xfc, 0x00, 0x9f, 0x17, 0x3c, 0x0c, 0x00, + 0x9f, 0x19, 0x3c, 0x0d, 0x00, 0x9f, 0x1a, 0x59, + 0xfd, 0x00, 0x9f, 0x1b, 0x4e, 0x4f, 0x00, 0x9f, + 0x1f, 0x59, 0xfe, 0x00, 0x9f, 0x20, 0x0a, 0xcf, + 0x00, 0x9f, 0x21, 0x1d, 0x1e, 0x00, 0x9f, 0x22, + 0x4e, 0x50, 0x00, 0x9f, 0x26, 0x4e, 0x51, 0x00, + 0x9f, 0x2a, 0x4e, 0x52, 0x00, 0x9f, 0x2b, 0x4e, + 0x53, 0x00, 0x9f, 0x2c, 0x1d, 0x1f, 0x00, 0x9f, + 0x2f, 0x3c, 0x0e, 0x00, 0x9f, 0x31, 0x59, 0xff, + 0x00, 0x9f, 0x32, 0x5a, 0x00, 0x00, 0x9f, 0x34, + 0x4e, 0x54, 0x00, 0x9f, 0x37, 0x3c, 0x0f, 0x00, + 0x9f, 0x39, 0x3c, 0x10, 0x00, 0x9f, 0x3a, 0x4a, + 0xad, 0x00, 0x9f, 0x3b, 0x0d, 0x93, 0x00, 0x9f, + 0x3c, 0x5a, 0x01, 0x00, 0x9f, 0x3d, 0x4a, 0xae, + 0x00, 0x9f, 0x3e, 0x1d, 0x20, 0x00, 0x9f, 0x3f, + 0x5a, 0x02, 0x00, 0x9f, 0x41, 0x3c, 0x11, 0x00, + 0x9f, 0x43, 0x5a, 0x03, 0x00, 0x9f, 0x44, 0x5a, + 0x04, 0x00, 0x9f, 0x45, 0x3c, 0x12, 0x00, 0x9f, + 0x46, 0x4a, 0xaf, 0x00, 0x9f, 0x47, 0x5a, 0x05, + 0x00, 0x9f, 0x4a, 0x1d, 0x21, 0x00, 0x9f, 0x4b, + 0x17, 0x0a, 0x00, 0x9f, 0x4e, 0x1a, 0x7b, 0x00, + 0x9f, 0x4f, 0x1c, 0x06, 0x00, 0x9f, 0x52, 0x1d, + 0x22, 0x00, 0x9f, 0x53, 0x4a, 0xb0, 0x00, 0x9f, + 0x54, 0x1d, 0x23, 0x00, 0x9f, 0x55, 0x4a, 0xb1, + 0x00, 0x9f, 0x56, 0x5a, 0x06, 0x00, 0x9f, 0x57, + 0x3c, 0x13, 0x00, 0x9f, 0x58, 0x4a, 0xb2, 0x00, + 0x9f, 0x5a, 0x4e, 0x55, 0x00, 0x9f, 0x5d, 0x4a, + 0xb4, 0x00, 0x9f, 0x5e, 0x5a, 0x07, 0x00, 0x9f, + 0x5f, 0x1d, 0x25, 0x00, 0x9f, 0x60, 0x1d, 0x26, + 0x00, 0x9f, 0x61, 0x1d, 0x27, 0x00, 0x9f, 0x62, + 0x0f, 0xb8, 0x00, 0x9f, 0x63, 0x1d, 0x24, 0x00, + 0x9f, 0x66, 0x1d, 0x28, 0x00, 0x9f, 0x67, 0x1d, + 0x29, 0x00, 0x9f, 0x68, 0x3c, 0x14, 0x00, 0x9f, + 0x69, 0x4a, 0xb6, 0x00, 0x9f, 0x6a, 0x1d, 0x2b, + 0x00, 0x9f, 0x6c, 0x1d, 0x2a, 0x00, 0x9f, 0x6d, + 0x4a, 0xb7, 0x00, 0x9f, 0x6e, 0x5a, 0x08, 0x00, + 0x9f, 0x6f, 0x4e, 0x56, 0x00, 0x9f, 0x70, 0x4a, + 0xb8, 0x00, 0x9f, 0x71, 0x3c, 0x15, 0x00, 0x9f, + 0x72, 0x1d, 0x2d, 0x00, 0x9f, 0x73, 0x5a, 0x09, + 0x00, 0x9f, 0x75, 0x3c, 0x16, 0x00, 0x9f, 0x76, + 0x1d, 0x2e, 0x00, 0x9f, 0x77, 0x1d, 0x2c, 0x00, + 0x9f, 0x7a, 0x5a, 0x0a, 0x00, 0x9f, 0x7d, 0x5a, + 0x0b, 0x00, 0x9f, 0x8d, 0x0f, 0x7e, 0x00, 0x9f, + 0x8f, 0x5a, 0x0c, 0x00, 0x9f, 0x90, 0x3c, 0x17, + 0x00, 0x9f, 0x91, 0x5a, 0x0d, 0x00, 0x9f, 0x92, + 0x5a, 0x0e, 0x00, 0x9f, 0x94, 0x3c, 0x18, 0x00, + 0x9f, 0x95, 0x1d, 0x2f, 0x00, 0x9f, 0x96, 0x5a, + 0x0f, 0x00, 0x9f, 0x97, 0x43, 0x50, 0x00, 0x9f, + 0x9c, 0x1d, 0x30, 0x00, 0x9f, 0x9d, 0x17, 0x27, + 0x00, 0x9f, 0x9e, 0x4e, 0x57, 0x00, 0x9f, 0xa0, + 0x1d, 0x31, 0x00, 0x9f, 0xa1, 0x5a, 0x10, 0x00, + 0x9f, 0xa2, 0x3c, 0x19, 0x00, 0x9f, 0xa3, 0x5a, + 0x11, 0x00, 0x9f, 0xa5, 0x4e, 0x58, 0x00, 0x9f, + 0xb4, 0x36, 0xe0, 0x00, 0x9f, 0xbc, 0x3c, 0x47, + 0x00, 0x9f, 0xbd, 0x3c, 0x45, 0x00, 0x9f, 0xbe, + 0x3c, 0x4a, 0x00, 0x9f, 0xbf, 0x4e, 0x64, 0x00, + 0x9f, 0xc0, 0x4e, 0x65, 0x00, 0x9f, 0xc1, 0x4e, + 0x66, 0x00, 0x9f, 0xc2, 0x4e, 0x67, 0x00, 0x9f, + 0xc4, 0x37, 0x09, 0x00, 0x9f, 0xc6, 0x37, 0x58, + 0x00, 0x9f, 0xcc, 0x4e, 0xbc, 0x00, 0xfa, 0x0e, + 0x20, 0xda, 0x00, 0xfa, 0x0f, 0x20, 0xe5, 0x00, + 0xfa, 0x11, 0x37, 0xd2, 0x00, 0xfa, 0x13, 0x21, + 0x31, 0x00, 0xfa, 0x14, 0x21, 0x33, 0x00, 0xfa, + 0x1f, 0x21, 0xa2, 0x00, 0xfa, 0x21, 0x21, 0xa5, + 0x00, 0xfa, 0x23, 0x21, 0xb6, 0x00, 0xfa, 0x24, + 0x49, 0x48, 0x00, 0xfa, 0x27, 0x21, 0xd8, 0x00, + 0xfa, 0x28, 0x21, 0xdf, 0x00, 0xfa, 0x29, 0x21, + 0xef, 0x02, 0x00, 0x0b, 0x36, 0x0f, 0x02, 0x00, + 0x89, 0x43, 0x51, 0x02, 0x00, 0x8a, 0x37, 0x1c, + 0x02, 0x00, 0xa2, 0x43, 0x58, 0x02, 0x00, 0xa4, + 0x43, 0x5b, 0x02, 0x00, 0xb0, 0x37, 0x81, 0x02, + 0x00, 0xf5, 0x4e, 0x59, 0x02, 0x01, 0x58, 0x4e, + 0x6b, 0x02, 0x01, 0xa2, 0x36, 0x21, 0x02, 0x02, + 0x13, 0x43, 0x6b, 0x02, 0x03, 0x2b, 0x43, 0x82, + 0x02, 0x03, 0x71, 0x43, 0x8b, 0x02, 0x03, 0x81, + 0x43, 0x89, 0x02, 0x03, 0xf9, 0x43, 0x8f, 0x02, + 0x04, 0x4a, 0x43, 0x91, 0x02, 0x05, 0x09, 0x43, + 0x93, 0x02, 0x05, 0x3f, 0x37, 0x6c, 0x02, 0x05, + 0xb1, 0x4e, 0x70, 0x02, 0x05, 0xd6, 0x43, 0x9c, + 0x02, 0x06, 0x11, 0x37, 0xd6, 0x02, 0x06, 0x28, + 0x37, 0x19, 0x02, 0x06, 0xec, 0x4e, 0x73, 0x02, + 0x07, 0x4f, 0x43, 0xa0, 0x02, 0x07, 0xc8, 0x4e, + 0xa0, 0x02, 0x08, 0x07, 0x43, 0xa7, 0x02, 0x08, + 0x3a, 0x43, 0xa9, 0x02, 0x08, 0xb9, 0x43, 0xaf, + 0x02, 0x09, 0x0e, 0x34, 0xd3, 0x02, 0x09, 0x7c, + 0x43, 0xb3, 0x02, 0x09, 0x84, 0x37, 0x1d, 0x02, + 0x09, 0x9d, 0x43, 0xb4, 0x02, 0x0a, 0x64, 0x35, + 0xbb, 0x02, 0x0a, 0xd3, 0x43, 0xb9, 0x02, 0x0b, + 0x1d, 0x43, 0xbc, 0x02, 0x0b, 0x9f, 0x35, 0xeb, + 0x02, 0x0b, 0xb7, 0x35, 0x8a, 0x02, 0x0d, 0x45, + 0x43, 0xcf, 0x02, 0x0d, 0x58, 0x4e, 0x7a, 0x02, + 0x0d, 0xe1, 0x43, 0xdd, 0x02, 0x0e, 0x64, 0x43, + 0xec, 0x02, 0x0e, 0x6d, 0x43, 0xe4, 0x02, 0x0e, + 0x95, 0x43, 0xe3, 0x02, 0x0f, 0x5f, 0x43, 0xef, + 0x02, 0x12, 0x01, 0x44, 0x06, 0x02, 0x12, 0x3d, + 0x36, 0x81, 0x02, 0x12, 0x55, 0x44, 0x07, 0x02, + 0x12, 0x74, 0x44, 0x0d, 0x02, 0x12, 0x7b, 0x44, + 0x09, 0x02, 0x12, 0xd7, 0x44, 0x15, 0x02, 0x12, + 0xe4, 0x44, 0x14, 0x02, 0x12, 0xfd, 0x44, 0x1b, + 0x02, 0x13, 0x1b, 0x41, 0xb0, 0x02, 0x13, 0x36, + 0x44, 0x1d, 0x02, 0x13, 0x44, 0x44, 0x1e, 0x02, + 0x13, 0xc4, 0x44, 0x29, 0x02, 0x14, 0x6d, 0x44, + 0x36, 0x02, 0x14, 0x6e, 0x41, 0xb5, 0x02, 0x15, + 0xd7, 0x44, 0x40, 0x02, 0x16, 0x47, 0x44, 0x48, + 0x02, 0x16, 0xb4, 0x41, 0xc6, 0x02, 0x17, 0x06, + 0x44, 0x54, 0x02, 0x17, 0x42, 0x44, 0x55, 0x02, + 0x18, 0xbd, 0x41, 0xc1, 0x02, 0x19, 0xc3, 0x44, + 0x75, 0x02, 0x1a, 0x1a, 0x1e, 0x91, 0x02, 0x1c, + 0x56, 0x44, 0x83, 0x02, 0x1d, 0x2d, 0x44, 0x88, + 0x02, 0x1d, 0x45, 0x44, 0x89, 0x02, 0x1d, 0x62, + 0x44, 0x8b, 0x02, 0x1d, 0x78, 0x44, 0x8a, 0x02, + 0x1d, 0x92, 0x44, 0x94, 0x02, 0x1d, 0x9c, 0x44, + 0x90, 0x02, 0x1d, 0xa1, 0x44, 0x8f, 0x02, 0x1d, + 0xb7, 0x44, 0x97, 0x02, 0x1d, 0xe0, 0x44, 0x99, + 0x02, 0x1e, 0x33, 0x44, 0x9a, 0x02, 0x1e, 0x34, + 0x41, 0xcd, 0x02, 0x1f, 0x1e, 0x44, 0xa7, 0x02, + 0x1f, 0x76, 0x44, 0xae, 0x02, 0x1f, 0xfa, 0x44, + 0xb1, 0x02, 0x21, 0x7b, 0x44, 0xbf, 0x02, 0x22, + 0x18, 0x4a, 0xa1, 0x02, 0x23, 0x1e, 0x44, 0xc5, + 0x02, 0x23, 0xad, 0x44, 0xc8, 0x02, 0x26, 0x09, + 0x3c, 0x53, 0x02, 0x26, 0xf3, 0x44, 0xe0, 0x02, + 0x28, 0x5b, 0x44, 0xef, 0x02, 0x28, 0xab, 0x44, + 0xf5, 0x02, 0x29, 0x8f, 0x44, 0xf9, 0x02, 0x2a, + 0xb8, 0x45, 0x03, 0x02, 0x2b, 0x46, 0x45, 0x10, + 0x02, 0x2b, 0x4f, 0x45, 0x07, 0x02, 0x2b, 0x50, + 0x45, 0x08, 0x02, 0x2b, 0xa6, 0x45, 0x13, 0x02, + 0x2c, 0x1d, 0x45, 0x12, 0x02, 0x2c, 0x24, 0x45, + 0x16, 0x02, 0x2d, 0xe1, 0x45, 0x2e, 0x02, 0x2e, + 0x42, 0x4e, 0x9c, 0x02, 0x2f, 0xeb, 0x4e, 0xa2, + 0x02, 0x31, 0xb6, 0x45, 0x50, 0x02, 0x31, 0xc3, + 0x45, 0x4e, 0x02, 0x31, 0xc4, 0x41, 0xf8, 0x02, + 0x31, 0xf5, 0x45, 0x4f, 0x02, 0x33, 0x72, 0x45, + 0x61, 0x02, 0x33, 0xcc, 0x37, 0x3c, 0x02, 0x33, + 0xd0, 0x45, 0x68, 0x02, 0x33, 0xd2, 0x45, 0x64, + 0x02, 0x33, 0xd3, 0x45, 0x63, 0x02, 0x33, 0xd5, + 0x45, 0x6a, 0x02, 0x33, 0xda, 0x45, 0x6c, 0x02, + 0x33, 0xdf, 0x45, 0x6e, 0x02, 0x33, 0xe4, 0x45, + 0x69, 0x02, 0x33, 0xfe, 0x3c, 0x3e, 0x02, 0x34, + 0x4a, 0x45, 0x76, 0x02, 0x34, 0x4b, 0x45, 0x78, + 0x02, 0x34, 0x51, 0x45, 0x77, 0x02, 0x34, 0x65, + 0x45, 0x7c, 0x02, 0x34, 0xe4, 0x45, 0x96, 0x02, + 0x35, 0x5a, 0x45, 0x97, 0x02, 0x35, 0x94, 0x45, + 0xa3, 0x02, 0x35, 0xc4, 0x42, 0x09, 0x02, 0x36, + 0x38, 0x45, 0xb3, 0x02, 0x36, 0x39, 0x45, 0xb1, + 0x02, 0x36, 0x3a, 0x3c, 0x21, 0x02, 0x36, 0x47, + 0x45, 0xb2, 0x02, 0x37, 0x0c, 0x45, 0xc7, 0x02, + 0x37, 0x1c, 0x45, 0xbe, 0x02, 0x37, 0x3f, 0x42, + 0x12, 0x02, 0x37, 0x63, 0x42, 0x14, 0x02, 0x37, + 0x64, 0x45, 0xcb, 0x02, 0x37, 0xe7, 0x45, 0xd3, + 0x02, 0x37, 0xf1, 0x4e, 0xb8, 0x02, 0x37, 0xff, + 0x45, 0xd2, 0x02, 0x38, 0x24, 0x45, 0xd8, 0x02, + 0x38, 0x3d, 0x45, 0xdd, 0x02, 0x3a, 0x98, 0x45, + 0xe9, 0x02, 0x3c, 0x7f, 0x45, 0xf6, 0x02, 0x3c, + 0xbe, 0x37, 0xd5, 0x02, 0x3c, 0xfe, 0x36, 0x50, + 0x02, 0x3d, 0x00, 0x46, 0x05, 0x02, 0x3d, 0x0e, + 0x47, 0xda, 0x02, 0x3d, 0x40, 0x46, 0x16, 0x02, + 0x3d, 0xd3, 0x46, 0x19, 0x02, 0x3d, 0xf9, 0x46, + 0x18, 0x02, 0x3d, 0xfa, 0x46, 0x17, 0x02, 0x3f, + 0x7e, 0x46, 0x3f, 0x02, 0x40, 0x4b, 0x4e, 0xc8, + 0x02, 0x40, 0x96, 0x46, 0x4e, 0x02, 0x41, 0x03, + 0x46, 0x53, 0x02, 0x41, 0xc6, 0x46, 0x5f, 0x02, + 0x41, 0xfe, 0x46, 0x62, 0x02, 0x42, 0xee, 0x37, + 0xca, 0x02, 0x43, 0xbc, 0x46, 0x77, 0x02, 0x43, + 0xd0, 0x1e, 0x9e, 0x02, 0x46, 0x29, 0x46, 0x81, + 0x02, 0x46, 0xa5, 0x46, 0x87, 0x02, 0x47, 0xf1, + 0x42, 0x4a, 0x02, 0x48, 0x96, 0x46, 0x9d, 0x02, + 0x4a, 0x4d, 0x46, 0xb8, 0x02, 0x4b, 0x56, 0x46, + 0xc5, 0x02, 0x4b, 0x6f, 0x46, 0xc7, 0x02, 0x4c, + 0x16, 0x46, 0xcc, 0x02, 0x4d, 0x14, 0x36, 0xab, + 0x02, 0x4e, 0x04, 0x4e, 0x5a, 0x02, 0x4e, 0x0e, + 0x46, 0xee, 0x02, 0x4e, 0x37, 0x46, 0xf2, 0x02, + 0x4e, 0x6a, 0x46, 0xf7, 0x02, 0x4e, 0x8b, 0x46, + 0xfa, 0x02, 0x4f, 0xf2, 0x4e, 0x5b, 0x02, 0x50, + 0x4a, 0x47, 0x05, 0x02, 0x50, 0x55, 0x47, 0x07, + 0x02, 0x51, 0x22, 0x47, 0x09, 0x02, 0x51, 0xa9, + 0x47, 0x0e, 0x02, 0x51, 0xcd, 0x47, 0x11, 0x02, + 0x51, 0xe5, 0x47, 0x10, 0x02, 0x52, 0x1e, 0x47, + 0x13, 0x02, 0x52, 0x4c, 0x47, 0x15, 0x02, 0x54, + 0x2e, 0x47, 0x21, 0x02, 0x54, 0x8e, 0x42, 0x6d, + 0x02, 0x54, 0xd9, 0x47, 0x29, 0x02, 0x55, 0x0e, + 0x42, 0x71, 0x02, 0x55, 0xa7, 0x47, 0x35, 0x02, + 0x56, 0x7f, 0x36, 0xfb, 0x02, 0x57, 0x71, 0x42, + 0x7a, 0x02, 0x57, 0xa9, 0x47, 0x48, 0x02, 0x57, + 0xb4, 0x47, 0x49, 0x02, 0x58, 0x74, 0x1d, 0xf6, + 0x02, 0x59, 0xc4, 0x42, 0x80, 0x02, 0x59, 0xcc, + 0x4e, 0x90, 0x02, 0x59, 0xd4, 0x47, 0x5c, 0x02, + 0x5a, 0xd7, 0x36, 0x62, 0x02, 0x5a, 0xe3, 0x47, + 0x65, 0x02, 0x5a, 0xe4, 0x47, 0x64, 0x02, 0x5a, + 0xf1, 0x47, 0x66, 0x02, 0x5b, 0xb2, 0x47, 0x75, + 0x02, 0x5c, 0x4b, 0x47, 0x7e, 0x02, 0x5c, 0x64, + 0x47, 0x7f, 0x02, 0x5d, 0xa1, 0x42, 0x89, 0x02, + 0x5e, 0x2e, 0x47, 0x8e, 0x02, 0x5e, 0x56, 0x47, + 0x8f, 0x02, 0x5e, 0x62, 0x47, 0x92, 0x02, 0x5e, + 0x65, 0x47, 0x90, 0x02, 0x5e, 0xc2, 0x47, 0x97, + 0x02, 0x5e, 0xd8, 0x47, 0x95, 0x02, 0x5e, 0xe8, + 0x47, 0x99, 0x02, 0x5f, 0x23, 0x47, 0x9a, 0x02, + 0x5f, 0x5c, 0x47, 0x9c, 0x02, 0x5f, 0xd4, 0x47, + 0xa3, 0x02, 0x5f, 0xe0, 0x47, 0xa2, 0x02, 0x5f, + 0xfb, 0x47, 0xa9, 0x02, 0x60, 0x0c, 0x47, 0xa8, + 0x02, 0x60, 0x17, 0x47, 0xb0, 0x02, 0x60, 0x60, + 0x47, 0xb3, 0x02, 0x60, 0xed, 0x47, 0xbd, 0x02, + 0x62, 0x22, 0x35, 0x7b, 0x02, 0x62, 0x6a, 0x37, + 0x6d, 0x02, 0x62, 0x70, 0x47, 0xd1, 0x02, 0x62, + 0x86, 0x47, 0xd2, 0x02, 0x63, 0x4c, 0x4f, 0x57, + 0x02, 0x64, 0x02, 0x47, 0xde, 0x02, 0x66, 0x7e, + 0x47, 0xf0, 0x02, 0x66, 0xb0, 0x37, 0x14, 0x02, + 0x67, 0x1d, 0x47, 0xfe, 0x02, 0x68, 0xdd, 0x48, + 0x0c, 0x02, 0x68, 0xea, 0x48, 0x0e, 0x02, 0x69, + 0x51, 0x35, 0x4e, 0x02, 0x69, 0x6f, 0x48, 0x12, + 0x02, 0x69, 0x99, 0x37, 0x36, 0x02, 0x69, 0xdd, + 0x48, 0x14, 0x02, 0x6a, 0x1e, 0x48, 0x17, 0x02, + 0x6a, 0x58, 0x48, 0x1b, 0x02, 0x6a, 0x8c, 0x48, + 0x1f, 0x02, 0x6a, 0xb7, 0x48, 0x22, 0x02, 0x6a, + 0xff, 0x42, 0xa7, 0x02, 0x6c, 0x29, 0x44, 0x46, + 0x02, 0x6c, 0x73, 0x48, 0x4a, 0x02, 0x6c, 0x9e, + 0x4e, 0xee, 0x02, 0x6c, 0xdd, 0x48, 0x53, 0x02, + 0x6e, 0x40, 0x42, 0xc1, 0x02, 0x6e, 0x65, 0x48, + 0x60, 0x02, 0x6f, 0x94, 0x48, 0x70, 0x02, 0x6f, + 0xf6, 0x48, 0x7a, 0x02, 0x6f, 0xf7, 0x48, 0x7b, + 0x02, 0x6f, 0xf8, 0x48, 0x79, 0x02, 0x70, 0xf4, + 0x42, 0xcf, 0x02, 0x71, 0x0d, 0x48, 0x8b, 0x02, + 0x71, 0x39, 0x48, 0x8e, 0x02, 0x73, 0xda, 0x48, + 0xb3, 0x02, 0x73, 0xdb, 0x48, 0xb2, 0x02, 0x73, + 0xfe, 0x48, 0xb9, 0x02, 0x74, 0x10, 0x48, 0xbc, + 0x02, 0x74, 0x49, 0x48, 0xc0, 0x02, 0x76, 0x14, + 0x48, 0xce, 0x02, 0x76, 0x15, 0x48, 0xcd, 0x02, + 0x76, 0x31, 0x48, 0xd0, 0x02, 0x76, 0x84, 0x42, + 0xdd, 0x02, 0x76, 0x93, 0x48, 0xd5, 0x02, 0x77, + 0x0e, 0x48, 0xda, 0x02, 0x77, 0x23, 0x48, 0xdc, + 0x02, 0x77, 0x52, 0x48, 0xe0, 0x02, 0x79, 0x85, + 0x48, 0xf0, 0x02, 0x79, 0xb4, 0x4e, 0xa5, 0x02, + 0x7a, 0x84, 0x48, 0xfc, 0x02, 0x7b, 0xb3, 0x49, + 0x0b, 0x02, 0x7b, 0xbe, 0x49, 0x0d, 0x02, 0x7b, + 0xc7, 0x49, 0x0e, 0x02, 0x7c, 0x3c, 0x4e, 0xfc, + 0x02, 0x7c, 0xb8, 0x49, 0x14, 0x02, 0x7d, 0x73, + 0x4e, 0x5c, 0x02, 0x7d, 0xa0, 0x49, 0x1c, 0x02, + 0x7e, 0x10, 0x49, 0x1e, 0x02, 0x7f, 0xb7, 0x36, + 0x4a, 0x02, 0x80, 0x8a, 0x49, 0x27, 0x02, 0x80, + 0xbb, 0x49, 0x2d, 0x02, 0x82, 0x77, 0x42, 0xf4, + 0x02, 0x82, 0x82, 0x49, 0x39, 0x02, 0x82, 0xf3, + 0x49, 0x3b, 0x02, 0x83, 0xcd, 0x42, 0xfa, 0x02, + 0x84, 0x0c, 0x49, 0x42, 0x02, 0x84, 0x55, 0x49, + 0x45, 0x02, 0x85, 0x6b, 0x49, 0x52, 0x02, 0x85, + 0xc8, 0x49, 0x55, 0x02, 0x85, 0xc9, 0x49, 0x56, + 0x02, 0x86, 0xd7, 0x49, 0x60, 0x02, 0x86, 0xfa, + 0x49, 0x63, 0x02, 0x89, 0x46, 0x49, 0x7c, 0x02, + 0x89, 0x49, 0x49, 0x7b, 0x02, 0x89, 0x6b, 0x49, + 0x81, 0x02, 0x89, 0x87, 0x37, 0xad, 0x02, 0x89, + 0x88, 0x49, 0x88, 0x02, 0x89, 0xba, 0x49, 0x92, + 0x02, 0x89, 0xbb, 0x49, 0x93, 0x02, 0x8a, 0x1e, + 0x49, 0x9b, 0x02, 0x8a, 0x29, 0x49, 0x9c, 0x02, + 0x8a, 0x43, 0x49, 0xa0, 0x02, 0x8a, 0x71, 0x49, + 0x9f, 0x02, 0x8a, 0x99, 0x49, 0xa7, 0x02, 0x8a, + 0xcd, 0x49, 0xa8, 0x02, 0x8a, 0xdd, 0x49, 0xaf, + 0x02, 0x8a, 0xe4, 0x49, 0xae, 0x02, 0x8b, 0xc1, + 0x49, 0xba, 0x02, 0x8b, 0xef, 0x49, 0xbb, 0x02, + 0x8c, 0xdd, 0x1d, 0xd9, 0x02, 0x8d, 0x10, 0x49, + 0xc2, 0x02, 0x8d, 0x71, 0x49, 0xc3, 0x02, 0x8d, + 0xfb, 0x49, 0xc5, 0x02, 0x8e, 0x17, 0x37, 0xb0, + 0x02, 0x8e, 0x1f, 0x49, 0xc6, 0x02, 0x8e, 0x36, + 0x49, 0xca, 0x02, 0x8e, 0x89, 0x49, 0xcd, 0x02, + 0x8e, 0xeb, 0x49, 0xcf, 0x02, 0x8e, 0xf6, 0x1d, + 0xf9, 0x02, 0x8f, 0x32, 0x49, 0xd1, 0x02, 0x8f, + 0xf8, 0x49, 0xd7, 0x02, 0x92, 0xa0, 0x49, 0xe5, + 0x02, 0x92, 0xb1, 0x49, 0xe6, 0x02, 0x94, 0x90, + 0x49, 0xf7, 0x02, 0x95, 0xcf, 0x4a, 0x00, 0x02, + 0x96, 0x7f, 0x36, 0x19, 0x02, 0x96, 0xf0, 0x4a, + 0x0f, 0x02, 0x97, 0x19, 0x4a, 0x12, 0x02, 0x97, + 0x50, 0x4a, 0x16, 0x02, 0x98, 0xc6, 0x4a, 0x27, + 0x02, 0x9a, 0x72, 0x4a, 0x39, 0x02, 0x9d, 0x4b, + 0x35, 0x95, 0x02, 0x9d, 0xdb, 0x4a, 0x52, 0x02, + 0x9e, 0x15, 0x4a, 0x5c, 0x02, 0x9e, 0x3d, 0x4f, + 0x5b, 0x02, 0x9e, 0x49, 0x4a, 0x5e, 0x02, 0x9e, + 0x8a, 0x4a, 0x5d, 0x02, 0x9e, 0xc4, 0x4a, 0x66, + 0x02, 0x9e, 0xdb, 0x4a, 0x6e, 0x02, 0x9e, 0xe9, + 0x4a, 0x6b, 0x02, 0x9f, 0xce, 0x4a, 0x7f, 0x02, + 0x9f, 0xd7, 0x4a, 0x7f, 0x02, 0xa0, 0x1a, 0x4a, + 0x85, 0x02, 0xa0, 0x2f, 0x4a, 0x83, 0x02, 0xa0, + 0x82, 0x4a, 0x8c, 0x02, 0xa0, 0xf9, 0x4a, 0x8b, + 0x02, 0xa1, 0x90, 0x43, 0x4b, 0x02, 0xa2, 0xb2, + 0x4e, 0x68, 0x02, 0xa3, 0x8c, 0x4a, 0xa5, 0x02, + 0xa4, 0x37, 0x4a, 0xa7, 0x02, 0xa5, 0xf1, 0x4a, + 0xb3, 0x02, 0xa6, 0x02, 0x4a, 0xb5, 0x02, 0xa6, + 0x1a, 0x4f, 0x5c, 0x02, 0xa6, 0xb2, 0x4a, 0xb9, + 0x02, 0xa9, 0xe6, 0x37, 0x41, 0x02, 0xb7, 0x46, + 0x35, 0xd4, 0x02, 0xb7, 0x51, 0x36, 0x2a, 0x02, + 0xb7, 0x53, 0x4e, 0x78, 0x02, 0xb7, 0x5a, 0x4e, + 0x80, 0x02, 0xb7, 0x5c, 0x4e, 0x81, 0x02, 0xb7, + 0x65, 0x4f, 0x17, 0x02, 0xb7, 0x76, 0x4e, 0x92, + 0x02, 0xb7, 0x77, 0x35, 0xd6, 0x02, 0xb7, 0x7c, + 0x4e, 0x9d, 0x02, 0xb7, 0x82, 0x4e, 0xad, 0x02, + 0xb7, 0x89, 0x36, 0xf0, 0x02, 0xb7, 0x8b, 0x4e, + 0xb5, 0x02, 0xb7, 0x8e, 0x35, 0x9c, 0x02, 0xb7, + 0x94, 0x4e, 0xb9, 0x02, 0xb7, 0xac, 0x4e, 0xd0, + 0x02, 0xb7, 0xaf, 0x4e, 0xd4, 0x02, 0xb7, 0xbd, + 0x37, 0x5e, 0x02, 0xb7, 0xc9, 0x4e, 0xe2, 0x02, + 0xb7, 0xcf, 0x4e, 0xe9, 0x02, 0xb7, 0xd2, 0x4e, + 0xec, 0x02, 0xb7, 0xd8, 0x35, 0x53, 0x02, 0xb7, + 0xf0, 0x4f, 0x10, 0x02, 0xb8, 0x0d, 0x4f, 0x20, + 0x02, 0xb8, 0x17, 0x4f, 0x24, 0x02, 0xb8, 0x1a, + 0x37, 0xc6, 0x00, 0x00, 0x04, 0xb7, 0x00, 0x34, + 0x02, 0x35, 0x81, 0x00, 0x4e, 0x08, 0x34, 0x97, + 0x00, 0x4e, 0x0e, 0x4e, 0x69, 0x00, 0x4e, 0x19, + 0x36, 0xb9, 0x00, 0x4e, 0x26, 0x4e, 0x6a, 0x00, + 0x4e, 0x30, 0x3c, 0x1a, 0x00, 0x4e, 0x39, 0x36, + 0x5a, 0x00, 0x4e, 0x3b, 0x35, 0xf4, 0x00, 0x4e, + 0x73, 0x36, 0x90, 0x00, 0x4e, 0xa1, 0x36, 0xcf, + 0x00, 0x4e, 0xa4, 0x34, 0x7f, 0x00, 0x4e, 0xca, + 0x35, 0xd4, 0x00, 0x4f, 0x34, 0x36, 0xa0, 0x00, + 0x4f, 0x4f, 0x35, 0xfc, 0x00, 0x4f, 0x60, 0x3c, + 0x1c, 0x00, 0x4f, 0x73, 0x4e, 0x6c, 0x00, 0x4f, + 0x75, 0x34, 0x47, 0x00, 0x4f, 0x7f, 0x34, 0x8a, + 0x00, 0x4f, 0xae, 0x34, 0x46, 0x00, 0x4f, 0xb5, + 0x36, 0x1b, 0x00, 0x4f, 0xbf, 0x34, 0xc2, 0x00, + 0x50, 0x24, 0x36, 0x5f, 0x00, 0x50, 0x26, 0x1d, + 0xfa, 0x00, 0x50, 0x49, 0x34, 0x61, 0x00, 0x50, + 0x4f, 0x36, 0xbe, 0x00, 0x50, 0x56, 0x4e, 0x6d, + 0x00, 0x50, 0x65, 0x34, 0x7b, 0x00, 0x50, 0x85, + 0x34, 0xd0, 0x00, 0x50, 0x91, 0x34, 0x79, 0x00, + 0x50, 0xc5, 0x1d, 0xee, 0x00, 0x50, 0xca, 0x1f, + 0x2e, 0x00, 0x50, 0xcf, 0x34, 0xa2, 0x00, 0x50, + 0xe7, 0x34, 0x30, 0x00, 0x50, 0xed, 0x4e, 0x6e, + 0x00, 0x50, 0xf2, 0x52, 0xac, 0x00, 0x51, 0x1a, + 0x37, 0x16, 0x00, 0x51, 0x32, 0x1e, 0x76, 0x00, + 0x51, 0x46, 0x34, 0xa5, 0x00, 0x51, 0x4d, 0x34, + 0x4d, 0x00, 0x51, 0x4e, 0x36, 0x7d, 0x00, 0x51, + 0x54, 0x10, 0x74, 0x00, 0x51, 0x68, 0x36, 0x42, + 0x00, 0x51, 0x6b, 0x4e, 0x6f, 0x00, 0x51, 0x6c, + 0x34, 0x80, 0x00, 0x51, 0x77, 0x35, 0xa5, 0x00, + 0x51, 0x7c, 0x35, 0xb4, 0x00, 0x51, 0x89, 0x1e, + 0x87, 0x00, 0x51, 0x8d, 0x08, 0x36, 0x00, 0x51, + 0x92, 0x36, 0xd6, 0x00, 0x51, 0x93, 0x34, 0xd1, + 0x00, 0x51, 0x95, 0x10, 0x82, 0x00, 0x51, 0xa4, + 0x1e, 0x89, 0x00, 0x51, 0xac, 0x0c, 0x59, 0x00, + 0x51, 0xb4, 0x34, 0x5c, 0x00, 0x51, 0xcb, 0x1e, + 0x3e, 0x00, 0x51, 0xdb, 0x34, 0xd2, 0x00, 0x51, + 0xde, 0x4f, 0x53, 0x00, 0x51, 0xe1, 0x36, 0xd9, + 0x00, 0x51, 0xfd, 0x4e, 0x72, 0x00, 0x52, 0x03, + 0x36, 0x22, 0x00, 0x52, 0x06, 0x34, 0xbb, 0x00, + 0x52, 0x24, 0x36, 0xa1, 0x00, 0x52, 0x38, 0x35, + 0xb5, 0x00, 0x52, 0x4a, 0x35, 0xdd, 0x00, 0x52, + 0x4d, 0x36, 0x41, 0x00, 0x52, 0x64, 0x4e, 0x74, + 0x00, 0x52, 0x71, 0x4e, 0x75, 0x00, 0x52, 0x72, + 0x05, 0xc2, 0x00, 0x52, 0x75, 0x1e, 0x2b, 0x00, + 0x52, 0x8d, 0x37, 0x1a, 0x00, 0x52, 0xc7, 0x36, + 0xf6, 0x00, 0x52, 0xc9, 0x0e, 0x29, 0x00, 0x52, + 0xd7, 0x37, 0x1b, 0x00, 0x52, 0xdd, 0x36, 0x05, + 0x00, 0x52, 0xe2, 0x36, 0x2a, 0x00, 0x52, 0xe4, + 0x34, 0x1a, 0x00, 0x52, 0xfa, 0x09, 0x07, 0x00, + 0x53, 0x00, 0x37, 0xcf, 0x00, 0x53, 0x05, 0x36, + 0xc3, 0x00, 0x53, 0x07, 0x20, 0xd4, 0x00, 0x53, + 0x15, 0x1f, 0x2f, 0x00, 0x53, 0x16, 0x35, 0x61, + 0x00, 0x53, 0x39, 0x36, 0xaa, 0x00, 0x53, 0x3f, + 0x4e, 0x77, 0x00, 0x53, 0x40, 0x34, 0xd4, 0x00, + 0x53, 0x4a, 0x36, 0xa2, 0x00, 0x53, 0x51, 0x0d, + 0x70, 0x00, 0x53, 0x5a, 0x36, 0x98, 0x00, 0x53, + 0x65, 0x52, 0xf3, 0x00, 0x53, 0x71, 0x35, 0x80, + 0x00, 0x53, 0x78, 0x35, 0x5f, 0x00, 0x53, 0x7f, + 0x06, 0xa2, 0x00, 0x53, 0xa9, 0x1d, 0xd8, 0x00, + 0x53, 0xc9, 0x4f, 0x39, 0x00, 0x53, 0xca, 0x35, + 0x8e, 0x00, 0x53, 0xce, 0x34, 0x8f, 0x00, 0x53, + 0xd7, 0x35, 0xf5, 0x00, 0x53, 0xdb, 0x1f, 0x2a, + 0x00, 0x53, 0xdf, 0x37, 0x1f, 0x00, 0x53, 0xe0, + 0x53, 0x00, 0x00, 0x53, 0xf1, 0x1e, 0x0c, 0x00, + 0x53, 0xf2, 0x34, 0x8b, 0x00, 0x54, 0x0f, 0x34, + 0xc9, 0x00, 0x54, 0x38, 0x35, 0x8f, 0x00, 0x54, + 0x40, 0x4e, 0x79, 0x00, 0x54, 0x48, 0x36, 0x76, + 0x00, 0x54, 0x68, 0x09, 0x2a, 0x00, 0x54, 0xac, + 0x4f, 0x35, 0x00, 0x54, 0xb2, 0x35, 0xdc, 0x00, + 0x54, 0xe8, 0x1e, 0x17, 0x00, 0x55, 0x10, 0x36, + 0x83, 0x00, 0x55, 0x33, 0x1e, 0x8b, 0x00, 0x55, + 0x39, 0x1e, 0x8a, 0x00, 0x55, 0x44, 0x1e, 0x32, + 0x00, 0x55, 0x46, 0x36, 0x06, 0x00, 0x55, 0x53, + 0x35, 0xaa, 0x00, 0x55, 0x61, 0x38, 0x39, 0x00, + 0x55, 0x84, 0x4e, 0x5e, 0x00, 0x55, 0x9c, 0x4e, + 0x7b, 0x00, 0x55, 0x9d, 0x1d, 0xe3, 0x00, 0x55, + 0xa9, 0x1f, 0x30, 0x00, 0x55, 0xab, 0x35, 0x8b, + 0x00, 0x55, 0xb0, 0x1d, 0xf0, 0x00, 0x55, 0xe4, + 0x1e, 0x8c, 0x00, 0x56, 0x05, 0x53, 0x2d, 0x00, + 0x56, 0x06, 0x0b, 0x70, 0x00, 0x56, 0x09, 0x4e, + 0x7d, 0x00, 0x56, 0x32, 0x1e, 0x8d, 0x00, 0x56, + 0x42, 0x1d, 0xda, 0x00, 0x56, 0x4c, 0x1e, 0x29, + 0x00, 0x56, 0x68, 0x34, 0x15, 0x00, 0x56, 0x74, + 0x34, 0xbc, 0x00, 0x56, 0x78, 0x1e, 0x52, 0x00, + 0x56, 0xa5, 0x1e, 0x8e, 0x00, 0x56, 0xae, 0x1f, + 0x31, 0x00, 0x56, 0xc0, 0x37, 0x24, 0x00, 0x56, + 0xc1, 0x34, 0xd7, 0x00, 0x56, 0xce, 0x4e, 0x82, + 0x00, 0x56, 0xee, 0x4e, 0x83, 0x00, 0x57, 0x0d, + 0x34, 0xd8, 0x00, 0x57, 0x47, 0x34, 0x78, 0x00, + 0x57, 0x6a, 0x36, 0x74, 0x00, 0x57, 0xce, 0x09, + 0xd3, 0x00, 0x57, 0xd6, 0x4e, 0x84, 0x00, 0x57, + 0xf4, 0x34, 0x98, 0x00, 0x58, 0x0b, 0x1e, 0x8f, + 0x00, 0x58, 0x19, 0x1f, 0x32, 0x00, 0x58, 0x35, + 0x1e, 0x49, 0x00, 0x58, 0x3d, 0x4e, 0x85, 0x00, + 0x58, 0x40, 0x34, 0x48, 0x00, 0x58, 0x58, 0x1e, + 0x4d, 0x00, 0x58, 0x59, 0x4e, 0x86, 0x00, 0x58, + 0x5a, 0x1e, 0x42, 0x00, 0x58, 0x9c, 0x36, 0x71, + 0x00, 0x58, 0xa8, 0x0e, 0x7d, 0x00, 0x58, 0xab, + 0x34, 0xd9, 0x00, 0x59, 0x06, 0x53, 0x7b, 0x00, + 0x59, 0x1b, 0x1f, 0x33, 0x00, 0x59, 0x27, 0x36, + 0x55, 0x00, 0x59, 0x4f, 0x4e, 0x87, 0x00, 0x59, + 0x51, 0x35, 0xab, 0x00, 0x59, 0x53, 0x37, 0xd1, + 0x00, 0x59, 0x60, 0x4e, 0x89, 0x00, 0x59, 0x62, + 0x4e, 0x8a, 0x00, 0x59, 0x73, 0x36, 0x04, 0x00, + 0x59, 0x84, 0x36, 0xe7, 0x00, 0x59, 0xa5, 0x36, + 0x4f, 0x00, 0x59, 0xc9, 0x34, 0x8c, 0x00, 0x59, + 0xda, 0x34, 0xda, 0x00, 0x59, 0xec, 0x36, 0xae, + 0x00, 0x59, 0xff, 0x35, 0xe0, 0x00, 0x5a, 0x1c, + 0x37, 0x26, 0x00, 0x5a, 0x29, 0x1e, 0x6f, 0x00, + 0x5a, 0x36, 0x34, 0xdb, 0x00, 0x5a, 0x66, 0x36, + 0xb2, 0x00, 0x5a, 0x9b, 0x1e, 0x68, 0x00, 0x5a, + 0xbe, 0x1e, 0x90, 0x00, 0x5a, 0xc2, 0x37, 0x27, + 0x00, 0x5a, 0xcc, 0x1d, 0xfb, 0x00, 0x5a, 0xda, + 0x4e, 0x8b, 0x00, 0x5b, 0x5a, 0x4e, 0x8c, 0x00, + 0x5b, 0x73, 0x4e, 0x8d, 0x00, 0x5b, 0x7c, 0x4e, + 0x8e, 0x00, 0x5b, 0xb3, 0x34, 0x6d, 0x00, 0x5b, + 0xb5, 0x36, 0x07, 0x00, 0x5b, 0xc3, 0x37, 0x29, + 0x00, 0x5b, 0xd2, 0x35, 0x78, 0x00, 0x5b, 0xdb, + 0x20, 0xf4, 0x00, 0x5b, 0xe7, 0x0c, 0xe1, 0x00, + 0x5b, 0xe8, 0x37, 0x42, 0x00, 0x5c, 0x06, 0x09, + 0x95, 0x00, 0x5c, 0x0a, 0x36, 0x4d, 0x00, 0x5c, + 0x0b, 0x36, 0x23, 0x00, 0x5c, 0x0e, 0x36, 0x8a, + 0x00, 0x5c, 0x0f, 0x36, 0x09, 0x00, 0x5c, 0x28, + 0x1f, 0x34, 0x00, 0x5c, 0x51, 0x1d, 0xf2, 0x00, + 0x5c, 0x60, 0x1e, 0x4a, 0x00, 0x5c, 0x64, 0x34, + 0x31, 0x00, 0x5c, 0x6e, 0x12, 0x32, 0x00, 0x5d, + 0x29, 0x36, 0xc4, 0x00, 0x5d, 0x4e, 0x34, 0xdd, + 0x00, 0x5d, 0x87, 0x34, 0xde, 0x00, 0x5d, 0xb2, + 0x3c, 0x2d, 0x00, 0x5d, 0xc9, 0x34, 0xdf, 0x00, + 0x5d, 0xcc, 0x34, 0x73, 0x00, 0x5d, 0xd3, 0x34, + 0xe0, 0x00, 0x5d, 0xe1, 0x35, 0xff, 0x00, 0x5d, + 0xe5, 0x35, 0xc3, 0x00, 0x5d, 0xe8, 0x35, 0x92, + 0x00, 0x5d, 0xf7, 0x1d, 0xff, 0x00, 0x5d, 0xfd, + 0x0b, 0x65, 0x00, 0x5e, 0x06, 0x36, 0xa3, 0x00, + 0x5e, 0x1d, 0x36, 0x77, 0x00, 0x5e, 0x30, 0x34, + 0x75, 0x00, 0x5e, 0x3d, 0x36, 0xd0, 0x00, 0x5e, + 0x43, 0x4e, 0x91, 0x00, 0x5e, 0x54, 0x37, 0x2d, + 0x00, 0x5e, 0x63, 0x36, 0xba, 0x00, 0x5e, 0x64, + 0x1e, 0x93, 0x00, 0x5e, 0x73, 0x36, 0xbb, 0x00, + 0x5e, 0x7e, 0x35, 0x84, 0x00, 0x5e, 0x96, 0x1e, + 0x70, 0x00, 0x5e, 0xa7, 0x4e, 0x92, 0x00, 0x5e, + 0xad, 0x34, 0xa9, 0x00, 0x5e, 0xc9, 0x0f, 0xbf, + 0x00, 0x5e, 0xca, 0x4f, 0x4f, 0x00, 0x5e, 0xcb, + 0x38, 0xae, 0x00, 0x5e, 0xcf, 0x1f, 0x36, 0x00, + 0x5e, 0xd0, 0x1f, 0x35, 0x00, 0x5e, 0xdf, 0x1e, + 0x6a, 0x00, 0x5e, 0xe0, 0x1e, 0x18, 0x00, 0x5e, + 0xe3, 0x37, 0x2f, 0x00, 0x5e, 0xf6, 0x34, 0x67, + 0x00, 0x5e, 0xf7, 0x34, 0xaa, 0x00, 0x5e, 0xfa, + 0x34, 0x7c, 0x00, 0x5e, 0xfb, 0x35, 0x69, 0x00, + 0x5f, 0x0a, 0x36, 0xbc, 0x00, 0x5f, 0x2d, 0x34, + 0xe1, 0x00, 0x5f, 0x31, 0x35, 0xf3, 0x00, 0x5f, + 0x38, 0x4e, 0x94, 0x00, 0x5f, 0x45, 0x37, 0xce, + 0x00, 0x5f, 0x50, 0x3c, 0x1f, 0x00, 0x5f, 0x62, + 0x4e, 0x5f, 0x00, 0x5f, 0x69, 0x35, 0xd7, 0x00, + 0x5f, 0x6b, 0x36, 0x68, 0x00, 0x5f, 0x80, 0x35, + 0x5d, 0x00, 0x5f, 0x98, 0x34, 0xe2, 0x00, 0x5f, + 0xa1, 0x4e, 0x95, 0x00, 0x5f, 0xae, 0x36, 0xa8, + 0x00, 0x5f, 0xb5, 0x36, 0x69, 0x00, 0x5f, 0xbd, + 0x1d, 0xea, 0x00, 0x5f, 0xcd, 0x36, 0x91, 0x00, + 0x5f, 0xd8, 0x36, 0xd1, 0x00, 0x5f, 0xd9, 0x36, + 0xd2, 0x00, 0x5f, 0xdd, 0x4e, 0x96, 0x00, 0x60, + 0x25, 0x35, 0x90, 0x00, 0x60, 0x50, 0x35, 0x99, + 0x00, 0x60, 0x62, 0x1d, 0xe0, 0x00, 0x60, 0x65, + 0x34, 0xa4, 0x00, 0x60, 0x75, 0x35, 0xac, 0x00, + 0x60, 0x94, 0x05, 0x79, 0x00, 0x60, 0x97, 0x1e, + 0x94, 0x00, 0x60, 0x9e, 0x54, 0x36, 0x00, 0x60, + 0xa4, 0x3c, 0x20, 0x00, 0x60, 0xb2, 0x34, 0xb3, + 0x00, 0x60, 0xc5, 0x36, 0x12, 0x00, 0x60, 0xd8, + 0x34, 0xe3, 0x00, 0x61, 0x08, 0x1e, 0x7a, 0x00, + 0x61, 0x09, 0x36, 0xf3, 0x00, 0x61, 0x0f, 0x35, + 0x47, 0x00, 0x61, 0x3d, 0x34, 0xe4, 0x00, 0x61, + 0x48, 0x4e, 0x60, 0x00, 0x61, 0x4c, 0x35, 0xc4, + 0x00, 0x61, 0x4e, 0x34, 0x2c, 0x00, 0x61, 0x62, + 0x4e, 0x97, 0x00, 0x61, 0x67, 0x1d, 0xf5, 0x00, + 0x61, 0x68, 0x34, 0x10, 0x00, 0x61, 0x8e, 0x0b, + 0x00, 0x00, 0x61, 0x90, 0x37, 0x10, 0x00, 0x61, + 0xa4, 0x34, 0xbd, 0x00, 0x61, 0xb2, 0x35, 0xb6, + 0x00, 0x61, 0xf2, 0x34, 0x39, 0x00, 0x61, 0xf8, + 0x4e, 0x99, 0x00, 0x61, 0xfe, 0x34, 0xe5, 0x00, + 0x62, 0x10, 0x36, 0x2b, 0x00, 0x62, 0x3b, 0x36, + 0xeb, 0x00, 0x62, 0x3f, 0x36, 0xd3, 0x00, 0x62, + 0x40, 0x36, 0x02, 0x00, 0x62, 0x41, 0x1f, 0x37, + 0x00, 0x62, 0x47, 0x36, 0x3b, 0x00, 0x62, 0x48, + 0x1e, 0xc2, 0x00, 0x62, 0x49, 0x1e, 0x63, 0x00, + 0x62, 0x68, 0x34, 0xe6, 0x00, 0x62, 0x71, 0x35, + 0x45, 0x00, 0x62, 0xb1, 0x36, 0xc5, 0x00, 0x62, + 0xcc, 0x37, 0x32, 0x00, 0x62, 0xcf, 0x34, 0xe7, + 0x00, 0x62, 0xd0, 0x1d, 0xe1, 0x00, 0x62, 0xd2, + 0x35, 0x93, 0x00, 0x62, 0xd4, 0x13, 0x5d, 0x00, + 0x62, 0xf3, 0x1f, 0x21, 0x00, 0x62, 0xf7, 0x34, + 0x88, 0x00, 0x63, 0x3a, 0x4f, 0x3e, 0x00, 0x63, + 0x3d, 0x1e, 0x62, 0x00, 0x63, 0x4c, 0x34, 0x5d, + 0x00, 0x63, 0x57, 0x1e, 0x3f, 0x00, 0x63, 0x67, + 0x34, 0xc3, 0x00, 0x63, 0x68, 0x35, 0xec, 0x00, + 0x63, 0x69, 0x1e, 0x95, 0x00, 0x63, 0x6e, 0x34, + 0x9d, 0x00, 0x63, 0x72, 0x1d, 0xfc, 0x00, 0x63, + 0x83, 0x36, 0x43, 0x00, 0x63, 0x88, 0x35, 0xf6, + 0x00, 0x63, 0x92, 0x34, 0xaf, 0x00, 0x63, 0xa1, + 0x35, 0xd8, 0x00, 0x63, 0xa7, 0x35, 0xc6, 0x00, + 0x63, 0xc3, 0x1f, 0x27, 0x00, 0x63, 0xc6, 0x37, + 0x34, 0x00, 0x63, 0xf4, 0x35, 0x57, 0x00, 0x64, + 0x06, 0x1e, 0x96, 0x00, 0x64, 0x0f, 0x34, 0xe9, + 0x00, 0x64, 0x1c, 0x37, 0x33, 0x00, 0x64, 0x28, + 0x37, 0x35, 0x00, 0x64, 0x42, 0x34, 0x9e, 0x00, + 0x64, 0x69, 0x36, 0xd7, 0x00, 0x64, 0x6f, 0x4f, + 0x28, 0x00, 0x64, 0x7a, 0x1e, 0x21, 0x00, 0x64, + 0xb0, 0x1e, 0x24, 0x00, 0x64, 0xe2, 0x1e, 0x45, + 0x00, 0x64, 0xf2, 0x34, 0xea, 0x00, 0x64, 0xf6, + 0x4e, 0x9e, 0x00, 0x65, 0x1d, 0x34, 0xe8, 0x00, + 0x65, 0x4f, 0x0d, 0xc4, 0x00, 0x65, 0x5d, 0x34, + 0xeb, 0x00, 0x65, 0x5e, 0x4e, 0xa1, 0x00, 0x65, + 0x62, 0x34, 0x71, 0x00, 0x65, 0x77, 0x36, 0xb3, + 0x00, 0x65, 0x83, 0x1e, 0x98, 0x00, 0x65, 0x87, + 0x4e, 0xa3, 0x00, 0x65, 0x89, 0x4e, 0xa4, 0x00, + 0x65, 0x8e, 0x4e, 0xa6, 0x00, 0x65, 0x90, 0x34, + 0xb5, 0x00, 0x65, 0x9c, 0x35, 0xed, 0x00, 0x65, + 0xa7, 0x4f, 0x41, 0x00, 0x65, 0xbc, 0x35, 0x5c, + 0x00, 0x65, 0xc5, 0x37, 0x08, 0x00, 0x65, 0xdf, + 0x54, 0xbe, 0x00, 0x65, 0xe1, 0x4e, 0xa9, 0x00, + 0x65, 0xe2, 0x06, 0x37, 0x00, 0x66, 0x0e, 0x36, + 0xe4, 0x00, 0x66, 0x1e, 0x21, 0x1c, 0x00, 0x66, + 0x5f, 0x34, 0xec, 0x00, 0x66, 0x66, 0x1d, 0xe2, + 0x00, 0x66, 0x67, 0x4e, 0xaa, 0x00, 0x66, 0x69, + 0x36, 0xa5, 0x00, 0x66, 0x6e, 0x4e, 0xab, 0x00, + 0x66, 0x74, 0x0a, 0x56, 0x00, 0x66, 0x77, 0x39, + 0x11, 0x00, 0x66, 0x81, 0x35, 0xa0, 0x00, 0x66, + 0x91, 0x34, 0x28, 0x00, 0x66, 0x96, 0x36, 0x5e, + 0x00, 0x66, 0x97, 0x35, 0x46, 0x00, 0x66, 0xb5, + 0x54, 0xda, 0x00, 0x66, 0xc1, 0x1f, 0x38, 0x00, + 0x66, 0xd9, 0x1e, 0x13, 0x00, 0x66, 0xdc, 0x36, + 0xfd, 0x00, 0x66, 0xf4, 0x34, 0x81, 0x00, 0x66, + 0xf5, 0x37, 0x3b, 0x00, 0x66, 0xf8, 0x36, 0x03, + 0x00, 0x66, 0xfb, 0x37, 0xcd, 0x00, 0x66, 0xfc, + 0x37, 0x20, 0x00, 0x67, 0x00, 0x4e, 0xaf, 0x00, + 0x67, 0x08, 0x35, 0xb2, 0x00, 0x67, 0x09, 0x36, + 0xf7, 0x00, 0x67, 0x0b, 0x36, 0xc6, 0x00, 0x67, + 0x0d, 0x36, 0xb7, 0x00, 0x67, 0x15, 0x36, 0x6f, + 0x00, 0x67, 0x17, 0x0f, 0xd5, 0x00, 0x67, 0x1b, + 0x36, 0xd4, 0x00, 0x67, 0x1d, 0x36, 0x6b, 0x00, + 0x67, 0x1f, 0x35, 0x86, 0x00, 0x67, 0x53, 0x1e, + 0x0f, 0x00, 0x67, 0x56, 0x4f, 0x3a, 0x00, 0x67, + 0x5e, 0x37, 0x3c, 0x00, 0x67, 0x61, 0x4e, 0xb0, + 0x00, 0x67, 0x7e, 0x34, 0x95, 0x00, 0x67, 0xa6, + 0x1e, 0x99, 0x00, 0x67, 0xa9, 0x34, 0xed, 0x00, + 0x67, 0xc4, 0x4e, 0xb1, 0x00, 0x67, 0xca, 0x1e, + 0x65, 0x00, 0x67, 0xd4, 0x34, 0x91, 0x00, 0x67, + 0xe7, 0x34, 0xee, 0x00, 0x67, 0xf1, 0x36, 0x65, + 0x00, 0x68, 0x01, 0x21, 0x2e, 0x00, 0x68, 0x02, + 0x4e, 0xb2, 0x00, 0x68, 0x13, 0x1e, 0x25, 0x00, + 0x68, 0x1f, 0x4e, 0x61, 0x00, 0x68, 0x21, 0x34, + 0x82, 0x00, 0x68, 0x43, 0x34, 0xac, 0x00, 0x68, + 0x52, 0x21, 0x2c, 0x00, 0x68, 0x5d, 0x34, 0xc5, + 0x00, 0x68, 0x7a, 0x36, 0xf0, 0x00, 0x68, 0x81, + 0x37, 0x09, 0x00, 0x68, 0x85, 0x0d, 0x15, 0x00, + 0x68, 0x8d, 0x37, 0x3e, 0x00, 0x68, 0x97, 0x4f, + 0x37, 0x00, 0x68, 0x9b, 0x1e, 0x9b, 0x00, 0x68, + 0x9d, 0x37, 0x3d, 0x00, 0x68, 0xa2, 0x1e, 0x19, + 0x00, 0x68, 0xc8, 0x37, 0xcc, 0x00, 0x68, 0xda, + 0x1e, 0x38, 0x00, 0x69, 0x0d, 0x34, 0x99, 0x00, + 0x69, 0x30, 0x34, 0xf0, 0x00, 0x69, 0x3d, 0x4e, + 0xb3, 0x00, 0x69, 0x5e, 0x4e, 0xb4, 0x00, 0x69, + 0x62, 0x1e, 0x58, 0x00, 0x69, 0x6b, 0x34, 0xef, + 0x00, 0x69, 0x6f, 0x34, 0x94, 0x00, 0x69, 0x82, + 0x34, 0x5b, 0x00, 0x69, 0x8a, 0x1e, 0x06, 0x00, + 0x69, 0x94, 0x1e, 0x84, 0x00, 0x69, 0xa7, 0x34, + 0xf1, 0x00, 0x69, 0xbb, 0x37, 0x43, 0x00, 0x69, + 0xc1, 0x35, 0x9a, 0x00, 0x69, 0xcb, 0x35, 0xc7, + 0x00, 0x69, 0xcc, 0x1e, 0x40, 0x00, 0x69, 0xd9, + 0x36, 0xdd, 0x00, 0x69, 0xea, 0x35, 0x6f, 0x00, + 0x69, 0xfe, 0x55, 0x1f, 0x00, 0x6a, 0x0b, 0x1e, + 0x64, 0x00, 0x6a, 0x3d, 0x1e, 0x3a, 0x00, 0x6a, + 0x44, 0x34, 0xf2, 0x00, 0x6a, 0x55, 0x55, 0x25, + 0x00, 0x6a, 0x5f, 0x35, 0x87, 0x00, 0x6a, 0x73, + 0x37, 0xd4, 0x00, 0x6a, 0x8e, 0x34, 0x7e, 0x00, + 0x6a, 0x90, 0x34, 0xf3, 0x00, 0x6a, 0x9c, 0x4e, + 0xb6, 0x00, 0x6a, 0xdb, 0x06, 0xf3, 0x00, 0x6b, + 0x04, 0x0f, 0x5d, 0x00, 0x6b, 0x1d, 0x1d, 0xd7, + 0x00, 0x6b, 0x21, 0x35, 0xe7, 0x00, 0x6b, 0x24, + 0x3c, 0x22, 0x00, 0x6b, 0x4e, 0x36, 0x5b, 0x00, + 0x6b, 0x96, 0x36, 0x16, 0x00, 0x6b, 0xba, 0x08, + 0x74, 0x00, 0x6b, 0xbb, 0x34, 0x70, 0x00, 0x6c, + 0x08, 0x1f, 0x39, 0x00, 0x6c, 0x13, 0x34, 0xf5, + 0x00, 0x6c, 0x38, 0x4e, 0xba, 0x00, 0x6c, 0x3a, + 0x39, 0x62, 0x00, 0x6c, 0x72, 0x1f, 0x1e, 0x00, + 0x6c, 0xaa, 0x37, 0x48, 0x00, 0x6c, 0xbf, 0x05, + 0x0a, 0x00, 0x6c, 0xe1, 0x1e, 0x71, 0x00, 0x6c, + 0xe8, 0x36, 0x66, 0x00, 0x6d, 0x3e, 0x34, 0xae, + 0x00, 0x6d, 0x69, 0x35, 0xc8, 0x00, 0x6d, 0x6e, + 0x36, 0xb4, 0x00, 0x6d, 0x77, 0x05, 0x82, 0x00, + 0x6d, 0x78, 0x36, 0x1d, 0x00, 0x6d, 0x88, 0x36, + 0x0c, 0x00, 0x6d, 0xe4, 0x4e, 0xbd, 0x00, 0x6d, + 0xeb, 0x1d, 0xd5, 0x00, 0x6d, 0xfb, 0x36, 0x7c, + 0x00, 0x6e, 0x08, 0x4e, 0xbf, 0x00, 0x6e, 0x1a, + 0x09, 0x77, 0x00, 0x6e, 0x23, 0x1f, 0x3a, 0x00, + 0x6e, 0x2f, 0x35, 0xc9, 0x00, 0x6e, 0x6e, 0x1e, + 0x9d, 0x00, 0x6e, 0x72, 0x4e, 0xc0, 0x00, 0x6e, + 0x7e, 0x34, 0xcf, 0x00, 0x6e, 0x9d, 0x1e, 0x01, + 0x00, 0x6e, 0xa2, 0x1d, 0xd3, 0x00, 0x6e, 0xba, + 0x1e, 0x46, 0x00, 0x6e, 0xcb, 0x35, 0xe9, 0x00, + 0x6e, 0xd5, 0x4e, 0xc2, 0x00, 0x6e, 0xdb, 0x4e, + 0xc3, 0x00, 0x6e, 0xec, 0x1f, 0x3b, 0x00, 0x6e, + 0xfe, 0x34, 0xf8, 0x00, 0x6f, 0x11, 0x34, 0xf7, + 0x00, 0x6f, 0x22, 0x34, 0x14, 0x00, 0x6f, 0x23, + 0x0f, 0xc2, 0x00, 0x6f, 0x3e, 0x34, 0xf9, 0x00, + 0x6f, 0x51, 0x36, 0x9e, 0x00, 0x6f, 0x54, 0x35, + 0xb0, 0x00, 0x6f, 0x5b, 0x4e, 0xc4, 0x00, 0x6f, + 0x64, 0x4e, 0xc6, 0x00, 0x6f, 0x6e, 0x0b, 0xc8, + 0x00, 0x6f, 0x74, 0x4e, 0xc7, 0x00, 0x6f, 0x98, + 0x37, 0x47, 0x00, 0x6f, 0xef, 0x1e, 0x33, 0x00, + 0x6f, 0xf9, 0x39, 0x95, 0x00, 0x70, 0x15, 0x1e, + 0x6b, 0x00, 0x70, 0x1b, 0x37, 0x4a, 0x00, 0x70, + 0x1e, 0x1e, 0x51, 0x00, 0x70, 0x26, 0x1e, 0x3d, + 0x00, 0x70, 0x27, 0x36, 0x57, 0x00, 0x70, 0x4a, + 0x39, 0x98, 0x00, 0x70, 0x58, 0x1e, 0x57, 0x00, + 0x70, 0x70, 0x35, 0x6a, 0x00, 0x70, 0x78, 0x4f, + 0x2e, 0x00, 0x70, 0x7c, 0x1e, 0x10, 0x00, 0x70, + 0xad, 0x36, 0x5c, 0x00, 0x71, 0x49, 0x0f, 0xc3, + 0x00, 0x71, 0x4e, 0x1e, 0x26, 0x00, 0x71, 0x52, + 0x55, 0xad, 0x00, 0x71, 0x59, 0x35, 0x59, 0x00, + 0x71, 0x62, 0x37, 0x4b, 0x00, 0x71, 0x6e, 0x08, + 0xfd, 0x00, 0x71, 0x7d, 0x1e, 0x27, 0x00, 0x71, + 0x94, 0x1e, 0x7d, 0x00, 0x71, 0xb3, 0x39, 0xae, + 0x00, 0x71, 0xd0, 0x37, 0x0a, 0x00, 0x71, 0xff, + 0x34, 0xfa, 0x00, 0x72, 0x28, 0x15, 0xdf, 0x00, + 0x72, 0x2b, 0x3c, 0x26, 0x00, 0x72, 0x35, 0x09, + 0x0b, 0x00, 0x72, 0x36, 0x34, 0xb9, 0x00, 0x72, + 0x3a, 0x4f, 0x46, 0x00, 0x72, 0x3b, 0x37, 0x4c, + 0x00, 0x72, 0x3e, 0x4e, 0xc9, 0x00, 0x72, 0x4c, + 0x1e, 0x5b, 0x00, 0x72, 0x59, 0x1f, 0x1d, 0x00, + 0x72, 0xe1, 0x4f, 0x36, 0x00, 0x73, 0x1c, 0x37, + 0x4e, 0x00, 0x73, 0x2a, 0x0b, 0xb4, 0x00, 0x73, + 0x36, 0x36, 0xf8, 0x00, 0x73, 0x37, 0x1e, 0x7c, + 0x00, 0x73, 0x87, 0x37, 0x05, 0x00, 0x73, 0x8b, + 0x35, 0xa1, 0x00, 0x73, 0xca, 0x1e, 0x0b, 0x00, + 0x73, 0xce, 0x1e, 0xa0, 0x00, 0x73, 0xe5, 0x34, + 0xfb, 0x00, 0x73, 0xed, 0x34, 0xb1, 0x00, 0x74, + 0x22, 0x0b, 0x56, 0x00, 0x74, 0x32, 0x34, 0xfc, + 0x00, 0x74, 0x5f, 0x34, 0xfd, 0x00, 0x74, 0x62, + 0x21, 0x71, 0x00, 0x74, 0xb0, 0x35, 0x79, 0x00, + 0x74, 0xbd, 0x4e, 0xcd, 0x00, 0x74, 0xca, 0x37, + 0x4f, 0x00, 0x74, 0xd8, 0x55, 0xf6, 0x00, 0x74, + 0xdc, 0x35, 0x50, 0x00, 0x74, 0xe0, 0x34, 0xfe, + 0x00, 0x74, 0xef, 0x55, 0xfa, 0x00, 0x75, 0x04, + 0x1e, 0xa1, 0x00, 0x75, 0x0c, 0x34, 0xff, 0x00, + 0x75, 0x0d, 0x1e, 0xa2, 0x00, 0x75, 0x11, 0x1e, + 0x04, 0x00, 0x75, 0x15, 0x1e, 0xa3, 0x00, 0x75, + 0x26, 0x4f, 0x3b, 0x00, 0x75, 0x54, 0x36, 0xa4, + 0x00, 0x75, 0x5d, 0x4e, 0xce, 0x00, 0x75, 0xbc, + 0x4e, 0xcf, 0x00, 0x75, 0xc5, 0x36, 0xb1, 0x00, + 0x76, 0x08, 0x4e, 0xd1, 0x00, 0x76, 0x26, 0x1e, + 0x2d, 0x00, 0x76, 0x52, 0x1e, 0x7b, 0x00, 0x76, + 0x64, 0x4e, 0xd2, 0x00, 0x76, 0x69, 0x4e, 0xd3, + 0x00, 0x76, 0x72, 0x35, 0x00, 0x00, 0x76, 0x84, + 0x36, 0x79, 0x00, 0x76, 0x93, 0x1e, 0xa4, 0x00, + 0x76, 0xc6, 0x34, 0xc4, 0x00, 0x76, 0xca, 0x21, + 0x7b, 0x00, 0x76, 0xd4, 0x56, 0x1d, 0x00, 0x76, + 0xdb, 0x36, 0x2c, 0x00, 0x76, 0xdf, 0x36, 0xe5, + 0x00, 0x76, 0xf2, 0x36, 0xe9, 0x00, 0x76, 0xf4, + 0x36, 0x6e, 0x00, 0x77, 0x1e, 0x16, 0xb8, 0x00, + 0x77, 0x1f, 0x36, 0x1e, 0x00, 0x77, 0x37, 0x4e, + 0xd5, 0x00, 0x77, 0x3a, 0x34, 0xa6, 0x00, 0x77, + 0x7e, 0x4e, 0xd6, 0x00, 0x77, 0x8d, 0x56, 0x2e, + 0x00, 0x77, 0xa2, 0x56, 0x2f, 0x00, 0x77, 0xa5, + 0x1e, 0x6e, 0x00, 0x77, 0xac, 0x34, 0x92, 0x00, + 0x77, 0xe9, 0x35, 0xa4, 0x00, 0x78, 0x32, 0x36, + 0xc7, 0x00, 0x78, 0x3a, 0x36, 0x7f, 0x00, 0x78, + 0x5d, 0x36, 0x0d, 0x00, 0x78, 0x6c, 0x34, 0x83, + 0x00, 0x78, 0x7c, 0x1e, 0xa5, 0x00, 0x78, 0x91, + 0x0d, 0x7e, 0x00, 0x78, 0xd4, 0x35, 0x02, 0x00, + 0x78, 0xe8, 0x36, 0xda, 0x00, 0x78, 0xef, 0x35, + 0x4b, 0x00, 0x79, 0x2a, 0x35, 0x01, 0x00, 0x79, + 0x34, 0x3a, 0x38, 0x00, 0x79, 0x3a, 0x08, 0xd4, + 0x00, 0x79, 0x3c, 0x21, 0x83, 0x00, 0x79, 0x3e, + 0x34, 0x24, 0x00, 0x79, 0x40, 0x37, 0x57, 0x00, + 0x79, 0x41, 0x1d, 0xf4, 0x00, 0x79, 0x47, 0x1d, + 0xeb, 0x00, 0x79, 0x48, 0x06, 0x41, 0x00, 0x79, + 0x49, 0x34, 0x21, 0x00, 0x79, 0x50, 0x0f, 0x1e, + 0x00, 0x79, 0x53, 0x37, 0x58, 0x00, 0x79, 0x56, + 0x34, 0x2f, 0x00, 0x79, 0x5d, 0x09, 0x55, 0x00, + 0x79, 0x5e, 0x0a, 0x06, 0x00, 0x79, 0x62, 0x1f, + 0x29, 0x00, 0x79, 0x65, 0x09, 0xb5, 0x00, 0x79, + 0x8d, 0x05, 0x52, 0x00, 0x79, 0x8e, 0x34, 0x3b, + 0x00, 0x79, 0x8f, 0x21, 0x87, 0x00, 0x79, 0xa7, + 0x4e, 0xd7, 0x00, 0x79, 0xae, 0x37, 0x5b, 0x00, + 0x79, 0xb0, 0x1e, 0x59, 0x00, 0x79, 0xb1, 0x4e, + 0xd8, 0x00, 0x79, 0xba, 0x35, 0x03, 0x00, 0x79, + 0xe4, 0x1e, 0x5d, 0x00, 0x7a, 0x0b, 0x36, 0x78, + 0x00, 0x7a, 0x17, 0x1e, 0x66, 0x00, 0x7a, 0x19, + 0x35, 0x04, 0x00, 0x7a, 0x31, 0x1e, 0xa6, 0x00, + 0x7a, 0x40, 0x08, 0x04, 0x00, 0x7a, 0x60, 0x3a, + 0x4e, 0x00, 0x7a, 0x74, 0x34, 0x7a, 0x00, 0x7a, + 0x7a, 0x35, 0xa7, 0x00, 0x7a, 0x7f, 0x1f, 0x25, + 0x00, 0x7a, 0x81, 0x34, 0x3d, 0x00, 0x7a, 0x95, + 0x35, 0x05, 0x00, 0x7a, 0x97, 0x1f, 0x3c, 0x00, + 0x7a, 0xae, 0x34, 0x77, 0x00, 0x7a, 0xbe, 0x4e, + 0xd9, 0x00, 0x7a, 0xc6, 0x3c, 0x27, 0x00, 0x7a, + 0xc8, 0x4f, 0x3d, 0x00, 0x7b, 0x08, 0x1f, 0x1f, + 0x00, 0x7b, 0x51, 0x36, 0x63, 0x00, 0x7b, 0x75, + 0x4f, 0x2a, 0x00, 0x7b, 0x99, 0x1e, 0xa8, 0x00, + 0x7b, 0xad, 0x1f, 0x26, 0x00, 0x7b, 0xb8, 0x1e, + 0x5f, 0x00, 0x7b, 0xc0, 0x34, 0x2e, 0x00, 0x7b, + 0xc7, 0x1f, 0x2b, 0x00, 0x7b, 0xc9, 0x36, 0x61, + 0x00, 0x7b, 0xdd, 0x1f, 0x3d, 0x00, 0x7b, 0xe0, + 0x4e, 0xda, 0x00, 0x7c, 0x14, 0x37, 0x5f, 0x00, + 0x7c, 0x3e, 0x1f, 0x2d, 0x00, 0x7c, 0x3f, 0x36, + 0xc2, 0x00, 0x7c, 0x4d, 0x36, 0x36, 0x00, 0x7c, + 0x50, 0x37, 0x61, 0x00, 0x7c, 0x58, 0x37, 0x62, + 0x00, 0x7c, 0x69, 0x56, 0xaa, 0x00, 0x7c, 0x7e, + 0x1e, 0x78, 0x00, 0x7c, 0x82, 0x4f, 0x30, 0x00, + 0x7c, 0x89, 0x34, 0xbe, 0x00, 0x7c, 0x90, 0x1e, + 0xa9, 0x00, 0x7c, 0xae, 0x1e, 0xaa, 0x00, 0x7c, + 0xbe, 0x0a, 0x5e, 0x00, 0x7c, 0xd6, 0x0c, 0x76, + 0x00, 0x7c, 0xf2, 0x35, 0x06, 0x00, 0x7d, 0x04, + 0x36, 0xee, 0x00, 0x7d, 0x09, 0x4e, 0xdc, 0x00, + 0x7d, 0x0b, 0x36, 0xec, 0x00, 0x7d, 0x0d, 0x36, + 0x94, 0x00, 0x7d, 0x1a, 0x35, 0x91, 0x00, 0x7d, + 0x1b, 0x34, 0xbf, 0x00, 0x7d, 0x42, 0x35, 0xf8, + 0x00, 0x7d, 0x46, 0x37, 0x63, 0x00, 0x7d, 0x5c, + 0x21, 0x90, 0x00, 0x7d, 0x5e, 0x34, 0x84, 0x00, + 0x7d, 0x63, 0x37, 0x64, 0x00, 0x7d, 0x73, 0x35, + 0x07, 0x00, 0x7d, 0x9b, 0x1e, 0xab, 0x00, 0x7d, + 0x9f, 0x1e, 0xad, 0x00, 0x7d, 0xae, 0x1e, 0xac, + 0x00, 0x7d, 0xb2, 0x4e, 0xdd, 0x00, 0x7d, 0xcb, + 0x34, 0xb6, 0x00, 0x7d, 0xcf, 0x34, 0xa0, 0x00, + 0x7d, 0xdd, 0x35, 0x08, 0x00, 0x7d, 0xe8, 0x36, + 0xbf, 0x00, 0x7d, 0xe9, 0x35, 0x7a, 0x00, 0x7d, + 0xef, 0x34, 0x62, 0x00, 0x7d, 0xf4, 0x0f, 0xc5, + 0x00, 0x7e, 0x09, 0x47, 0xbe, 0x00, 0x7e, 0x1b, + 0x36, 0x9b, 0x00, 0x7e, 0x22, 0x37, 0x65, 0x00, + 0x7e, 0x2b, 0x36, 0xc8, 0x00, 0x7e, 0x35, 0x35, + 0x09, 0x00, 0x7e, 0x41, 0x34, 0x40, 0x00, 0x7e, + 0x43, 0x37, 0x69, 0x00, 0x7e, 0x6d, 0x36, 0xe1, + 0x00, 0x7e, 0x8c, 0x37, 0x6a, 0x00, 0x7f, 0x3e, + 0x4e, 0xdf, 0x00, 0x7f, 0x50, 0x37, 0x6b, 0x00, + 0x7f, 0x61, 0x3c, 0x28, 0x00, 0x7f, 0x6a, 0x34, + 0x89, 0x00, 0x7f, 0x6e, 0x36, 0x60, 0x00, 0x7f, + 0x72, 0x09, 0x7a, 0x00, 0x7f, 0x80, 0x56, 0xda, + 0x00, 0x7f, 0x8a, 0x0f, 0x3d, 0x00, 0x7f, 0xa1, + 0x36, 0x3d, 0x00, 0x7f, 0xae, 0x35, 0x0a, 0x00, + 0x7f, 0xbd, 0x04, 0xcb, 0x00, 0x7f, 0xc1, 0x34, + 0x6a, 0x00, 0x7f, 0xc5, 0x37, 0x6f, 0x00, 0x7f, + 0xc6, 0x37, 0x70, 0x00, 0x7f, 0xcc, 0x37, 0x01, + 0x00, 0x7f, 0xd2, 0x35, 0xf9, 0x00, 0x7f, 0xd4, + 0x1e, 0xae, 0x00, 0x7f, 0xe0, 0x1e, 0x20, 0x00, + 0x7f, 0xe1, 0x35, 0x0b, 0x00, 0x7f, 0xe9, 0x1f, + 0x3e, 0x00, 0x7f, 0xeb, 0x1d, 0xe9, 0x00, 0x7f, + 0xf0, 0x1d, 0xe8, 0x00, 0x7f, 0xfb, 0x36, 0xd8, + 0x00, 0x7f, 0xfc, 0x34, 0xc8, 0x00, 0x80, 0x00, + 0x1e, 0x7e, 0x00, 0x80, 0x03, 0x34, 0x85, 0x00, + 0x80, 0x05, 0x34, 0x25, 0x00, 0x80, 0x12, 0x4e, + 0xe1, 0x00, 0x80, 0x15, 0x35, 0xca, 0x00, 0x80, + 0x17, 0x36, 0xea, 0x00, 0x80, 0x36, 0x34, 0xc7, + 0x00, 0x80, 0x56, 0x36, 0x2d, 0x00, 0x80, 0x5a, + 0x35, 0x0c, 0x00, 0x80, 0x5f, 0x35, 0x0d, 0x00, + 0x80, 0x61, 0x34, 0xa1, 0x00, 0x80, 0x6f, 0x34, + 0xcd, 0x00, 0x80, 0x70, 0x35, 0x0f, 0x00, 0x80, + 0x71, 0x3c, 0x29, 0x00, 0x80, 0x73, 0x35, 0x0e, + 0x00, 0x80, 0x74, 0x34, 0xa7, 0x00, 0x80, 0x76, + 0x35, 0x10, 0x00, 0x80, 0x77, 0x34, 0x9a, 0x00, + 0x80, 0x7e, 0x34, 0xce, 0x00, 0x80, 0x87, 0x36, + 0x9c, 0x00, 0x80, 0x89, 0x36, 0x8f, 0x00, 0x80, + 0x96, 0x36, 0x0e, 0x00, 0x80, 0x9e, 0x3c, 0x2a, + 0x00, 0x80, 0xa9, 0x35, 0xb8, 0x00, 0x80, 0xba, + 0x36, 0x97, 0x00, 0x80, 0xd6, 0x4e, 0xe3, 0x00, + 0x80, 0xde, 0x36, 0xc9, 0x00, 0x81, 0x06, 0x36, + 0x34, 0x00, 0x81, 0x08, 0x34, 0xc6, 0x00, 0x81, + 0x09, 0x4e, 0xe4, 0x00, 0x81, 0x29, 0x4e, 0xe5, + 0x00, 0x81, 0x53, 0x35, 0x11, 0x00, 0x81, 0x54, + 0x35, 0xcb, 0x00, 0x81, 0x70, 0x35, 0xd1, 0x00, + 0x81, 0x71, 0x4f, 0x33, 0x00, 0x81, 0x7f, 0x1e, + 0x30, 0x00, 0x81, 0x8a, 0x35, 0x12, 0x00, 0x81, + 0xb5, 0x35, 0x13, 0x00, 0x81, 0xcd, 0x35, 0x14, + 0x00, 0x81, 0xed, 0x34, 0x26, 0x00, 0x82, 0x00, + 0x57, 0x0f, 0x00, 0x82, 0x0c, 0x4e, 0xe6, 0x00, + 0x82, 0x18, 0x35, 0x7f, 0x00, 0x82, 0x1b, 0x4e, + 0xe7, 0x00, 0x82, 0x1c, 0x34, 0x93, 0x00, 0x82, + 0x1f, 0x35, 0xb3, 0x00, 0x82, 0x2e, 0x1e, 0xaf, + 0x00, 0x82, 0x39, 0x34, 0x9f, 0x00, 0x82, 0x40, + 0x4e, 0xe8, 0x00, 0x82, 0x47, 0x34, 0xab, 0x00, + 0x82, 0x58, 0x37, 0x74, 0x00, 0x82, 0x79, 0x37, + 0x77, 0x00, 0x82, 0x8d, 0x1e, 0xb0, 0x00, 0x82, + 0x92, 0x4f, 0x44, 0x00, 0x82, 0xa6, 0x1f, 0x19, + 0x00, 0x82, 0xb1, 0x35, 0x62, 0x00, 0x82, 0xbd, + 0x05, 0x6a, 0x00, 0x82, 0xc5, 0x35, 0x77, 0x00, + 0x82, 0xd2, 0x1e, 0xb1, 0x00, 0x82, 0xe3, 0x37, + 0x78, 0x00, 0x83, 0x23, 0x1e, 0xb2, 0x00, 0x83, + 0x28, 0x1f, 0x1a, 0x00, 0x83, 0x52, 0x35, 0xcc, + 0x00, 0x83, 0x75, 0x1e, 0xb3, 0x00, 0x83, 0xbd, + 0x37, 0x7c, 0x00, 0x83, 0xd3, 0x35, 0x63, 0x00, + 0x83, 0xd4, 0x4e, 0xea, 0x00, 0x83, 0xdc, 0x35, + 0xda, 0x00, 0x83, 0xdf, 0x1e, 0x4b, 0x00, 0x83, + 0xf2, 0x35, 0x15, 0x00, 0x84, 0x0c, 0x36, 0xca, + 0x00, 0x84, 0x0f, 0x4e, 0xeb, 0x00, 0x84, 0x20, + 0x37, 0x7b, 0x00, 0x84, 0x22, 0x1f, 0x3f, 0x00, + 0x84, 0x57, 0x34, 0x37, 0x00, 0x84, 0x5b, 0x1d, + 0xe4, 0x00, 0x84, 0x5c, 0x57, 0x45, 0x00, 0x84, + 0x7a, 0x34, 0xba, 0x00, 0x84, 0xea, 0x4e, 0xed, + 0x00, 0x84, 0xec, 0x1e, 0x72, 0x00, 0x84, 0xee, + 0x0f, 0xc7, 0x00, 0x84, 0xf4, 0x37, 0x7d, 0x00, + 0x85, 0x11, 0x36, 0xbd, 0x00, 0x85, 0x17, 0x1e, + 0xb4, 0x00, 0x85, 0x3d, 0x1e, 0x6d, 0x00, 0x85, + 0x43, 0x36, 0xa6, 0x00, 0x85, 0x51, 0x4e, 0xef, + 0x00, 0x85, 0x55, 0x35, 0x16, 0x00, 0x85, 0x5d, + 0x57, 0x64, 0x00, 0x85, 0x63, 0x4e, 0xf0, 0x00, + 0x85, 0x84, 0x36, 0x99, 0x00, 0x85, 0x87, 0x37, + 0x7f, 0x00, 0x85, 0xa9, 0x1e, 0x08, 0x00, 0x85, + 0xaf, 0x1e, 0x15, 0x00, 0x85, 0xcf, 0x4e, 0xf1, + 0x00, 0x85, 0xd5, 0x35, 0x17, 0x00, 0x85, 0xe4, + 0x36, 0x85, 0x00, 0x85, 0xf7, 0x1e, 0x16, 0x00, + 0x86, 0x12, 0x21, 0xa4, 0x00, 0x86, 0x2d, 0x37, + 0x04, 0x00, 0x86, 0x4e, 0x4e, 0xf2, 0x00, 0x86, + 0x50, 0x35, 0x8c, 0x00, 0x86, 0x54, 0x4f, 0x32, + 0x00, 0x86, 0x5c, 0x0f, 0x82, 0x00, 0x86, 0x5e, + 0x35, 0xa6, 0x00, 0x86, 0x62, 0x4e, 0xf3, 0x00, + 0x86, 0x8a, 0x4e, 0xf4, 0x00, 0x86, 0xdb, 0x34, + 0x5e, 0x00, 0x86, 0xf8, 0x1e, 0x35, 0x00, 0x87, + 0x03, 0x4f, 0x48, 0x00, 0x87, 0x1a, 0x35, 0x18, + 0x00, 0x87, 0x37, 0x37, 0x82, 0x00, 0x87, 0x3b, + 0x37, 0x83, 0x00, 0x87, 0x55, 0x1e, 0x1d, 0x00, + 0x87, 0x59, 0x1f, 0x40, 0x00, 0x87, 0x82, 0x1e, + 0xb6, 0x00, 0x87, 0xa3, 0x57, 0xaa, 0x00, 0x87, + 0xbd, 0x37, 0x85, 0x00, 0x87, 0xd2, 0x1e, 0xb7, + 0x00, 0x88, 0x03, 0x3b, 0x03, 0x00, 0x88, 0x05, + 0x37, 0x84, 0x00, 0x88, 0x0e, 0x1f, 0x41, 0x00, + 0x88, 0x36, 0x35, 0x19, 0x00, 0x88, 0x42, 0x4e, + 0xf5, 0x00, 0x88, 0x46, 0x35, 0xfa, 0x00, 0x88, + 0x4b, 0x57, 0xc3, 0x00, 0x88, 0x53, 0x35, 0xfd, + 0x00, 0x88, 0x5b, 0x34, 0x66, 0x00, 0x88, 0x5e, + 0x35, 0x53, 0x00, 0x88, 0x63, 0x35, 0x48, 0x00, + 0x88, 0x70, 0x36, 0x27, 0x00, 0x88, 0x77, 0x4e, + 0xf6, 0x00, 0x88, 0x9e, 0x35, 0x1a, 0x00, 0x88, + 0xd8, 0x35, 0x1b, 0x00, 0x88, 0xf4, 0x35, 0x1c, + 0x00, 0x89, 0x0a, 0x1e, 0xb8, 0x00, 0x89, 0x10, + 0x34, 0x13, 0x00, 0x89, 0x1c, 0x37, 0xcb, 0x00, + 0x89, 0x2b, 0x35, 0x1d, 0x00, 0x89, 0x3b, 0x35, + 0x1e, 0x00, 0x89, 0x41, 0x4e, 0xf7, 0x00, 0x89, + 0x56, 0x1d, 0xdd, 0x00, 0x89, 0x6a, 0x35, 0x1f, + 0x00, 0x89, 0x6f, 0x35, 0x20, 0x00, 0x89, 0x81, + 0x36, 0xff, 0x00, 0x89, 0x86, 0x36, 0xb8, 0x00, + 0x89, 0x87, 0x36, 0x95, 0x00, 0x89, 0x96, 0x34, + 0x22, 0x00, 0x89, 0xaa, 0x34, 0x9b, 0x00, 0x89, + 0xaf, 0x1e, 0xb9, 0x00, 0x89, 0xbd, 0x37, 0x8a, + 0x00, 0x89, 0xd2, 0x05, 0xaf, 0x00, 0x8a, 0x0a, + 0x36, 0x24, 0x00, 0x8a, 0x12, 0x37, 0xd7, 0x00, + 0x8a, 0x1d, 0x35, 0x21, 0x00, 0x8a, 0x1f, 0x34, + 0x96, 0x00, 0x8a, 0x3b, 0x1e, 0x3c, 0x00, 0x8a, + 0x55, 0x36, 0xaf, 0x00, 0x8a, 0x6e, 0x1e, 0x28, + 0x00, 0x8a, 0x8d, 0x36, 0x92, 0x00, 0x8a, 0x95, + 0x34, 0xa3, 0x00, 0x8a, 0xa0, 0x36, 0x2f, 0x00, + 0x8a, 0xa4, 0x35, 0xc2, 0x00, 0x8a, 0xb9, 0x34, + 0xb7, 0x00, 0x8a, 0xbf, 0x36, 0x6d, 0x00, 0x8a, + 0xcb, 0x36, 0x30, 0x00, 0x8a, 0xdb, 0x37, 0x8b, + 0x00, 0x8a, 0xde, 0x1e, 0xba, 0x00, 0x8a, 0xed, + 0x0f, 0x0b, 0x00, 0x8a, 0xee, 0x35, 0xe3, 0x00, + 0x8a, 0xf8, 0x09, 0x7e, 0x00, 0x8a, 0xfa, 0x1d, + 0xfe, 0x00, 0x8b, 0x01, 0x04, 0xfc, 0x00, 0x8b, + 0x04, 0x36, 0x86, 0x00, 0x8b, 0x0e, 0x1e, 0x56, + 0x00, 0x8b, 0x19, 0x35, 0xb9, 0x00, 0x8b, 0x1b, + 0x35, 0xcd, 0x00, 0x8b, 0x1d, 0x34, 0x8d, 0x00, + 0x8b, 0x2c, 0x1e, 0x69, 0x00, 0x8b, 0x39, 0x06, + 0xd8, 0x00, 0x8b, 0x3e, 0x37, 0x8c, 0x00, 0x8b, + 0x41, 0x1e, 0xbb, 0x00, 0x8b, 0x56, 0x4e, 0xf8, + 0x00, 0x8b, 0x5a, 0x37, 0x8d, 0x00, 0x8b, 0x5c, + 0x4e, 0xfa, 0x00, 0x8b, 0x7f, 0x52, 0x52, 0x00, + 0x8c, 0x6a, 0x4e, 0xfd, 0x00, 0x8c, 0x79, 0x4e, + 0xfe, 0x00, 0x8c, 0x9b, 0x58, 0x37, 0x00, 0x8c, + 0xa0, 0x36, 0xb5, 0x00, 0x8c, 0xa7, 0x34, 0xb8, + 0x00, 0x8c, 0xa8, 0x35, 0x64, 0x00, 0x8c, 0xab, + 0x34, 0x72, 0x00, 0x8c, 0xc7, 0x35, 0xe5, 0x00, + 0x8c, 0xca, 0x36, 0x4c, 0x00, 0x8c, 0xd3, 0x0d, + 0xc2, 0x00, 0x8c, 0xed, 0x1e, 0x4c, 0x00, 0x8c, + 0xfc, 0x34, 0x86, 0x00, 0x8d, 0x05, 0x35, 0x22, + 0x00, 0x8d, 0x08, 0x34, 0x34, 0x00, 0x8d, 0x0f, + 0x35, 0x23, 0x00, 0x8d, 0x67, 0x4f, 0x00, 0x00, + 0x8d, 0x70, 0x36, 0x46, 0x00, 0x8d, 0x73, 0x37, + 0x8e, 0x00, 0x8d, 0x77, 0x35, 0x88, 0x00, 0x8d, + 0x99, 0x37, 0x8f, 0x00, 0x8d, 0xda, 0x1e, 0xbc, + 0x00, 0x8d, 0xdd, 0x35, 0x94, 0x00, 0x8d, 0xf3, + 0x34, 0xa8, 0x00, 0x8e, 0x09, 0x1e, 0xbd, 0x00, + 0x8e, 0x34, 0x37, 0x91, 0x00, 0x8e, 0x4a, 0x37, + 0x92, 0x00, 0x8e, 0x8d, 0x36, 0xef, 0x00, 0x8e, + 0x91, 0x35, 0x25, 0x00, 0x8e, 0xa1, 0x35, 0x26, + 0x00, 0x8e, 0xcc, 0x34, 0x76, 0x00, 0x8e, 0xd4, + 0x3b, 0x4a, 0x00, 0x8f, 0x03, 0x4f, 0x02, 0x00, + 0x8f, 0x13, 0x1e, 0xbe, 0x00, 0x8f, 0x29, 0x34, + 0xb0, 0x00, 0x8f, 0x2f, 0x34, 0x90, 0x00, 0x8f, + 0x38, 0x36, 0xf5, 0x00, 0x8f, 0x44, 0x35, 0x75, + 0x00, 0x8f, 0xb6, 0x3c, 0x2b, 0x00, 0x8f, 0xbb, + 0x20, 0x4b, 0x00, 0x8f, 0xbc, 0x35, 0xd3, 0x00, + 0x8f, 0xbf, 0x1e, 0x37, 0x00, 0x8f, 0xc2, 0x1d, + 0xd6, 0x00, 0x8f, 0xc4, 0x1f, 0x2c, 0x00, 0x8f, + 0xc5, 0x36, 0x26, 0x00, 0x8f, 0xc6, 0x3b, 0x51, + 0x00, 0x8f, 0xce, 0x35, 0xae, 0x00, 0x8f, 0xd1, + 0x35, 0xa2, 0x00, 0x8f, 0xd4, 0x36, 0xc0, 0x00, + 0x8f, 0xe6, 0x1d, 0xdf, 0x00, 0x8f, 0xe9, 0x1e, + 0xc0, 0x00, 0x8f, 0xea, 0x1e, 0xbf, 0x00, 0x8f, + 0xeb, 0x36, 0x9a, 0x00, 0x8f, 0xed, 0x36, 0x7b, + 0x00, 0x8f, 0xef, 0x37, 0x93, 0x00, 0x8f, 0xf0, + 0x35, 0xfe, 0x00, 0x8f, 0xf6, 0x4f, 0x06, 0x00, + 0x8f, 0xf7, 0x36, 0xe6, 0x00, 0x8f, 0xfa, 0x37, + 0x95, 0x00, 0x8f, 0xfd, 0x36, 0x72, 0x00, 0x90, + 0x00, 0x36, 0x51, 0x00, 0x90, 0x01, 0x36, 0x47, + 0x00, 0x90, 0x03, 0x34, 0xad, 0x00, 0x90, 0x06, + 0x35, 0x8d, 0x00, 0x90, 0x0e, 0x35, 0x28, 0x00, + 0x90, 0x0f, 0x36, 0x88, 0x00, 0x90, 0x10, 0x36, + 0x64, 0x00, 0x90, 0x14, 0x36, 0x7e, 0x00, 0x90, + 0x17, 0x1e, 0x1f, 0x00, 0x90, 0x19, 0x1e, 0x5c, + 0x00, 0x90, 0x1a, 0x36, 0x73, 0x00, 0x90, 0x1d, + 0x1e, 0x22, 0x00, 0x90, 0x1e, 0x37, 0x96, 0x00, + 0x90, 0x1f, 0x36, 0x4b, 0x00, 0x90, 0x20, 0x36, + 0x49, 0x00, 0x90, 0x22, 0x20, 0x4a, 0x00, 0x90, + 0x23, 0x0f, 0xc8, 0x00, 0x90, 0x2e, 0x36, 0x52, + 0x00, 0x90, 0x31, 0x35, 0xfb, 0x00, 0x90, 0x32, + 0x36, 0x1f, 0x00, 0x90, 0x35, 0x37, 0x97, 0x00, + 0x90, 0x38, 0x34, 0x08, 0x00, 0x90, 0x39, 0x36, + 0x58, 0x00, 0x90, 0x3c, 0x1e, 0x67, 0x00, 0x90, + 0x41, 0x1e, 0x53, 0x00, 0x90, 0x42, 0x34, 0x9c, + 0x00, 0x90, 0x47, 0x35, 0xa8, 0x00, 0x90, 0x4a, + 0x36, 0xfc, 0x00, 0x90, 0x4b, 0x35, 0x51, 0x00, + 0x90, 0x4d, 0x36, 0xc1, 0x00, 0x90, 0x4e, 0x35, + 0x65, 0x00, 0x90, 0x50, 0x37, 0x98, 0x00, 0x90, + 0x52, 0x35, 0x27, 0x00, 0x90, 0x53, 0x36, 0x8b, + 0x00, 0x90, 0x54, 0x36, 0x58, 0x00, 0x90, 0x55, + 0x34, 0x63, 0x00, 0x90, 0x58, 0x1e, 0xc1, 0x00, + 0x90, 0x5c, 0x1e, 0x2e, 0x00, 0x90, 0x60, 0x35, + 0x5a, 0x00, 0x90, 0x61, 0x1e, 0x2a, 0x00, 0x90, + 0x63, 0x35, 0xba, 0x00, 0x90, 0x69, 0x36, 0x7a, + 0x00, 0x90, 0x6d, 0x36, 0x48, 0x00, 0x90, 0x6e, + 0x1e, 0x0e, 0x00, 0x90, 0x75, 0x36, 0x00, 0x00, + 0x90, 0x77, 0x36, 0x40, 0x00, 0x90, 0x78, 0x36, + 0x3f, 0x00, 0x90, 0x7a, 0x35, 0x4a, 0x00, 0x90, + 0x7c, 0x1e, 0x80, 0x00, 0x90, 0x7f, 0x36, 0xa7, + 0x00, 0x90, 0x81, 0x37, 0x9a, 0x00, 0x90, 0x83, + 0x37, 0x5c, 0x00, 0x90, 0x84, 0x35, 0x7c, 0x00, + 0x90, 0x87, 0x37, 0x94, 0x00, 0x90, 0x89, 0x34, + 0x5f, 0x00, 0x90, 0x8a, 0x37, 0x9b, 0x00, 0x90, + 0xa3, 0x1e, 0x55, 0x00, 0x90, 0xa6, 0x36, 0xcb, + 0x00, 0x90, 0xa8, 0x4f, 0x0b, 0x00, 0x90, 0xaa, + 0x34, 0x8e, 0x00, 0x90, 0xf7, 0x35, 0x9d, 0x00, + 0x90, 0xfd, 0x0c, 0x4e, 0x00, 0x91, 0x2d, 0x1e, + 0x44, 0x00, 0x91, 0x30, 0x35, 0x29, 0x00, 0x91, + 0x4b, 0x1e, 0x12, 0x00, 0x91, 0x4c, 0x35, 0xf2, + 0x00, 0x91, 0x4d, 0x4f, 0x0c, 0x00, 0x91, 0x56, + 0x35, 0x2a, 0x00, 0x91, 0x58, 0x35, 0x2b, 0x00, + 0x91, 0x65, 0x35, 0x2c, 0x00, 0x91, 0x72, 0x35, + 0x2e, 0x00, 0x91, 0x73, 0x35, 0x2d, 0x00, 0x91, + 0x77, 0x35, 0xd0, 0x00, 0x91, 0xa2, 0x35, 0x2f, + 0x00, 0x91, 0xaa, 0x35, 0x31, 0x00, 0x91, 0xaf, + 0x35, 0x30, 0x00, 0x91, 0xb1, 0x36, 0x9f, 0x00, + 0x91, 0xb4, 0x35, 0x32, 0x00, 0x91, 0xba, 0x35, + 0x33, 0x00, 0x91, 0xc1, 0x1e, 0xc3, 0x00, 0x91, + 0xc7, 0x1e, 0x05, 0x00, 0x91, 0xdc, 0x4f, 0x42, + 0x00, 0x91, 0xe3, 0x36, 0x75, 0x00, 0x91, 0xfc, + 0x3c, 0x2c, 0x00, 0x92, 0x37, 0x34, 0x7d, 0x00, + 0x92, 0x5b, 0x34, 0x69, 0x00, 0x92, 0xe9, 0x4f, + 0x0d, 0x00, 0x93, 0x06, 0x1e, 0x0a, 0x00, 0x93, + 0x35, 0x4f, 0x0e, 0x00, 0x93, 0x65, 0x3b, 0x86, + 0x00, 0x93, 0x75, 0x4f, 0x34, 0x00, 0x93, 0x8b, + 0x4f, 0x0f, 0x00, 0x93, 0x8c, 0x35, 0x76, 0x00, + 0x93, 0x96, 0x35, 0xd5, 0x00, 0x93, 0x9a, 0x1e, + 0x41, 0x00, 0x93, 0xa1, 0x59, 0x04, 0x00, 0x93, + 0xae, 0x34, 0x3a, 0x00, 0x93, 0xdd, 0x37, 0xae, + 0x00, 0x94, 0x3a, 0x4f, 0x10, 0x00, 0x94, 0x53, + 0x1e, 0x79, 0x00, 0x94, 0x77, 0x35, 0x34, 0x00, + 0x95, 0x92, 0x35, 0x7d, 0x00, 0x95, 0xab, 0x3b, + 0x9a, 0x00, 0x95, 0xbb, 0x1e, 0xc4, 0x00, 0x95, + 0xbc, 0x37, 0xaf, 0x00, 0x95, 0xcd, 0x4f, 0x11, + 0x00, 0x96, 0x2a, 0x4f, 0x12, 0x00, 0x96, 0x4d, + 0x34, 0x87, 0x00, 0x96, 0x86, 0x34, 0x51, 0x00, + 0x96, 0x8a, 0x36, 0x53, 0x00, 0x96, 0x94, 0x35, + 0x73, 0x00, 0x96, 0x98, 0x35, 0x35, 0x00, 0x96, + 0x99, 0x4f, 0x31, 0x00, 0x96, 0xa3, 0x34, 0xca, + 0x00, 0x96, 0xa7, 0x4f, 0x14, 0x00, 0x96, 0xb2, + 0x37, 0xb1, 0x00, 0x96, 0xbb, 0x36, 0x35, 0x00, + 0x96, 0xc5, 0x34, 0x6c, 0x00, 0x96, 0xc7, 0x35, + 0xbe, 0x00, 0x96, 0xd9, 0x34, 0xd5, 0x00, 0x96, + 0xda, 0x59, 0x3b, 0x00, 0x96, 0xe3, 0x0c, 0xc9, + 0x00, 0x96, 0xe8, 0x35, 0x4d, 0x00, 0x96, 0xea, + 0x36, 0x39, 0x00, 0x96, 0xf0, 0x34, 0xc0, 0x00, + 0x97, 0x21, 0x59, 0x41, 0x00, 0x97, 0x24, 0x1e, + 0xc6, 0x00, 0x97, 0x3d, 0x35, 0x36, 0x00, 0x97, + 0x55, 0x21, 0xf8, 0x00, 0x97, 0x56, 0x21, 0x8b, + 0x00, 0x97, 0x59, 0x37, 0xb2, 0x00, 0x97, 0x5c, + 0x36, 0x31, 0x00, 0x97, 0x60, 0x1e, 0xc7, 0x00, + 0x97, 0x6d, 0x1e, 0xc8, 0x00, 0x97, 0x71, 0x1e, + 0x1e, 0x00, 0x97, 0x74, 0x1d, 0xf3, 0x00, 0x97, + 0x84, 0x1d, 0xe5, 0x00, 0x97, 0x98, 0x1e, 0x1c, + 0x00, 0x97, 0xad, 0x4f, 0x43, 0x00, 0x97, 0xd3, + 0x35, 0x7e, 0x00, 0x97, 0xde, 0x3c, 0x2e, 0x00, + 0x97, 0xf3, 0x35, 0x60, 0x00, 0x97, 0xff, 0x34, + 0x19, 0x00, 0x98, 0x0c, 0x35, 0x39, 0x00, 0x98, + 0x11, 0x34, 0x74, 0x00, 0x98, 0x12, 0x34, 0xb2, + 0x00, 0x98, 0x13, 0x1e, 0x54, 0x00, 0x98, 0x24, + 0x1e, 0xc9, 0x00, 0x98, 0x3b, 0x0d, 0xc3, 0x00, + 0x98, 0x5e, 0x0f, 0xa8, 0x00, 0x98, 0x67, 0x35, + 0xbf, 0x00, 0x98, 0x73, 0x35, 0x3a, 0x00, 0x98, + 0xc3, 0x35, 0x3b, 0x00, 0x98, 0xdf, 0x36, 0x17, + 0x00, 0x98, 0xe2, 0x35, 0x89, 0x00, 0x98, 0xeb, + 0x37, 0xb4, 0x00, 0x98, 0xef, 0x0d, 0x67, 0x00, + 0x98, 0xf4, 0x1d, 0xd2, 0x00, 0x98, 0xfc, 0x21, + 0xfc, 0x00, 0x98, 0xfd, 0x36, 0xcd, 0x00, 0x98, + 0xfe, 0x36, 0x14, 0x00, 0x99, 0x03, 0x37, 0xb5, + 0x00, 0x99, 0x05, 0x1e, 0x77, 0x00, 0x99, 0x09, + 0x37, 0xb6, 0x00, 0x99, 0x0a, 0x37, 0x00, 0x00, + 0x99, 0x0c, 0x1d, 0xdb, 0x00, 0x99, 0x10, 0x1f, + 0x22, 0x00, 0x99, 0x13, 0x35, 0x68, 0x00, 0x99, + 0x21, 0x4f, 0x18, 0x00, 0x99, 0x28, 0x21, 0xfe, + 0x00, 0x99, 0x45, 0x37, 0xb7, 0x00, 0x99, 0x4b, + 0x37, 0xb9, 0x00, 0x99, 0x57, 0x1f, 0x20, 0x00, + 0x99, 0xc1, 0x4f, 0x40, 0x00, 0x99, 0xd0, 0x36, + 0x67, 0x00, 0x9a, 0x19, 0x1f, 0x43, 0x00, 0x9a, + 0x30, 0x36, 0x89, 0x00, 0x9a, 0x45, 0x35, 0x3c, + 0x00, 0x9a, 0x4a, 0x59, 0x88, 0x00, 0x9a, 0x5f, + 0x37, 0xbb, 0x00, 0x9a, 0x65, 0x37, 0xbc, 0x00, + 0x9a, 0xef, 0x37, 0xbd, 0x00, 0x9b, 0x18, 0x37, + 0xbe, 0x00, 0x9b, 0x2d, 0x34, 0x3c, 0x00, 0x9b, + 0x2e, 0x1e, 0xca, 0x00, 0x9b, 0x35, 0x59, 0xa4, + 0x00, 0x9b, 0x4d, 0x35, 0x3d, 0x00, 0x9b, 0x54, + 0x36, 0xdb, 0x00, 0x9b, 0x58, 0x35, 0x3e, 0x00, + 0x9b, 0x97, 0x1e, 0xcb, 0x00, 0x9b, 0xa8, 0x4f, + 0x1a, 0x00, 0x9b, 0xab, 0x4f, 0x38, 0x00, 0x9b, + 0xae, 0x4f, 0x1b, 0x00, 0x9b, 0xb9, 0x4f, 0x1c, + 0x00, 0x9b, 0xc6, 0x35, 0x3f, 0x00, 0x9b, 0xd6, + 0x1e, 0x09, 0x00, 0x9b, 0xdb, 0x36, 0x54, 0x00, + 0x9b, 0xe1, 0x35, 0x40, 0x00, 0x9b, 0xf1, 0x35, + 0x41, 0x00, 0x9b, 0xf2, 0x1e, 0xcc, 0x00, 0x9c, + 0x08, 0x4f, 0x1d, 0x00, 0x9c, 0x24, 0x4f, 0x1e, + 0x00, 0x9c, 0x2f, 0x1d, 0xd4, 0x00, 0x9c, 0x3b, + 0x4f, 0x1f, 0x00, 0x9c, 0x48, 0x1e, 0x39, 0x00, + 0x9c, 0x52, 0x1e, 0x74, 0x00, 0x9c, 0x57, 0x37, + 0x0c, 0x00, 0x9c, 0xe6, 0x4f, 0x21, 0x00, 0x9d, + 0x07, 0x1e, 0x4f, 0x00, 0x9d, 0x08, 0x37, 0xc1, + 0x00, 0x9d, 0x09, 0x37, 0xc0, 0x00, 0x9d, 0x48, + 0x35, 0x42, 0x00, 0x9d, 0x60, 0x1e, 0x03, 0x00, + 0x9d, 0x6c, 0x36, 0xce, 0x00, 0x9d, 0xb4, 0x0b, + 0xfd, 0x00, 0x9d, 0xbf, 0x59, 0xde, 0x00, 0x9d, + 0xc0, 0x4f, 0x22, 0x00, 0x9d, 0xc2, 0x4f, 0x23, + 0x00, 0x9d, 0xcf, 0x35, 0x43, 0x00, 0x9e, 0x97, + 0x34, 0xcc, 0x00, 0x9e, 0x9f, 0x34, 0xcb, 0x00, + 0x9e, 0xa5, 0x37, 0xc2, 0x00, 0x9e, 0xaa, 0x1e, + 0xcd, 0x00, 0x9e, 0xad, 0x1f, 0x44, 0x00, 0x9e, + 0xbb, 0x36, 0xdc, 0x00, 0x9e, 0xbf, 0x36, 0xe2, + 0x00, 0x9e, 0xcc, 0x37, 0xc3, 0x00, 0x9e, 0xdb, + 0x1e, 0x31, 0x00, 0x9f, 0x08, 0x35, 0x44, 0x00, + 0x9f, 0x3b, 0x36, 0xa9, 0x00, 0x9f, 0x4a, 0x37, + 0xc5, 0x00, 0x9f, 0x4b, 0x37, 0x5a, 0x00, 0x9f, + 0x4e, 0x35, 0x24, 0x00, 0x9f, 0x67, 0x37, 0xc7, + 0x00, 0x9f, 0x8d, 0x37, 0x06, 0x00, 0x9f, 0x9c, + 0x1e, 0xce, 0x00, 0x9f, 0x9d, 0x1e, 0xa7, 0x00, + 0xfa, 0x11, 0x20, 0xfb, 0x00, 0xfa, 0x24, 0x21, + 0xb8, 0x02, 0x35, 0xc4, 0x3c, 0x44, 0x02, 0x36, + 0x3a, 0x35, 0x9b, 0x02, 0x38, 0x3d, 0x4f, 0x26, + 0x02, 0x42, 0xee, 0x37, 0xc9, 0x02, 0x62, 0x70, + 0x37, 0x6e, 0x02, 0x9d, 0x4b, 0x35, 0x96, 0x02, + 0x9e, 0x3d, 0x3c, 0x4d, 0x02, 0xa6, 0x1a, 0x37, + 0xc8, 0x00, 0x00, 0x00, 0x7f, 0x00, 0x34, 0x02, + 0x35, 0x83, 0x00, 0x50, 0x91, 0x35, 0xaf, 0x00, + 0x50, 0xca, 0x37, 0x15, 0x00, 0x51, 0x54, 0x37, + 0x17, 0x00, 0x51, 0x95, 0x37, 0x18, 0x00, 0x51, + 0xb4, 0x35, 0xdb, 0x00, 0x51, 0xde, 0x38, 0x10, + 0x00, 0x52, 0x72, 0x4e, 0x76, 0x00, 0x53, 0x7f, + 0x1d, 0xed, 0x00, 0x53, 0xa9, 0x1f, 0x1c, 0x00, + 0x55, 0x33, 0x37, 0x21, 0x00, 0x55, 0xa9, 0x34, + 0xd6, 0x00, 0x55, 0xab, 0x4e, 0x7c, 0x00, 0x55, + 0xe4, 0x37, 0x22, 0x00, 0x56, 0xae, 0x4e, 0x7e, + 0x00, 0x57, 0xf4, 0x36, 0x13, 0x00, 0x58, 0x5a, + 0x20, 0xe6, 0x00, 0x59, 0x51, 0x4e, 0x88, 0x00, + 0x59, 0xff, 0x35, 0xe1, 0x00, 0x5a, 0xbe, 0x34, + 0xdc, 0x00, 0x5b, 0xb3, 0x35, 0x6b, 0x00, 0x5c, + 0x0a, 0x36, 0x4e, 0x00, 0x5c, 0x0f, 0x36, 0x0a, + 0x00, 0x5e, 0xca, 0x34, 0x59, 0x00, 0x5e, 0xe3, + 0x4e, 0x93, 0x00, 0x5e, 0xf6, 0x35, 0x56, 0x00, + 0x60, 0x62, 0x4f, 0x2d, 0x00, 0x60, 0x97, 0x37, + 0x30, 0x00, 0x61, 0x67, 0x35, 0xad, 0x00, 0x61, + 0x68, 0x34, 0x6e, 0x00, 0x61, 0xb2, 0x4e, 0x98, + 0x00, 0x61, 0xf2, 0x36, 0x6a, 0x00, 0x62, 0x49, + 0x34, 0xb4, 0x00, 0x66, 0x5f, 0x37, 0x38, 0x00, + 0x66, 0xc1, 0x4e, 0xac, 0x00, 0x67, 0x15, 0x36, + 0x70, 0x00, 0x67, 0x17, 0x21, 0x29, 0x00, 0x67, + 0x1b, 0x36, 0xd5, 0x00, 0x68, 0x5d, 0x36, 0xde, + 0x00, 0x68, 0x7a, 0x36, 0xf1, 0x00, 0x69, 0x0d, + 0x36, 0x15, 0x00, 0x69, 0x82, 0x34, 0x6f, 0x00, + 0x6a, 0xdb, 0x35, 0xa9, 0x00, 0x6b, 0x21, 0x35, + 0xe8, 0x00, 0x6c, 0x08, 0x34, 0xf4, 0x00, 0x6c, + 0xaa, 0x4e, 0xbb, 0x00, 0x6c, 0xbf, 0x34, 0x68, + 0x00, 0x6c, 0xe8, 0x32, 0x45, 0x00, 0x6d, 0x3e, + 0x36, 0x96, 0x00, 0x6e, 0x23, 0x34, 0xf6, 0x00, + 0x6e, 0xa2, 0x52, 0x4f, 0x00, 0x6e, 0xcb, 0x4e, + 0xc1, 0x00, 0x6f, 0x11, 0x37, 0x45, 0x00, 0x6f, + 0x5b, 0x4e, 0xc5, 0x00, 0x71, 0x7d, 0x1f, 0x24, + 0x00, 0x72, 0x35, 0x35, 0xf0, 0x00, 0x73, 0x36, + 0x36, 0xf9, 0x00, 0x73, 0x37, 0x36, 0xfa, 0x00, + 0x73, 0xca, 0x4e, 0xcc, 0x00, 0x75, 0x11, 0x35, + 0xd2, 0x00, 0x75, 0x15, 0x4f, 0x2b, 0x00, 0x79, + 0x53, 0x37, 0x59, 0x00, 0x7a, 0x74, 0x35, 0xb1, + 0x00, 0x7b, 0x08, 0x4f, 0x27, 0x00, 0x7b, 0xc0, + 0x36, 0x37, 0x00, 0x7c, 0x3e, 0x4f, 0x29, 0x00, + 0x7c, 0x50, 0x4e, 0xdb, 0x00, 0x7c, 0x7e, 0x4f, + 0x45, 0x00, 0x7d, 0xb2, 0x4e, 0xde, 0x00, 0x7e, + 0x22, 0x37, 0x66, 0x00, 0x7e, 0x35, 0x37, 0x68, + 0x00, 0x7f, 0xc1, 0x35, 0x5e, 0x00, 0x7f, 0xe1, + 0x4e, 0xe0, 0x00, 0x7f, 0xe9, 0x37, 0x71, 0x00, + 0x7f, 0xfc, 0x37, 0x02, 0x00, 0x81, 0x08, 0x36, + 0xe3, 0x00, 0x82, 0x39, 0x36, 0x3e, 0x00, 0x82, + 0x79, 0x37, 0x76, 0x00, 0x82, 0xbd, 0x34, 0x6b, + 0x00, 0x83, 0xdf, 0x1f, 0x28, 0x00, 0x85, 0x3d, + 0x34, 0xc1, 0x00, 0x86, 0x12, 0x52, 0x51, 0x00, + 0x87, 0xd2, 0x1f, 0x42, 0x00, 0x88, 0x05, 0x4f, + 0x47, 0x00, 0x88, 0x36, 0x37, 0x87, 0x00, 0x8a, + 0x0a, 0x36, 0x25, 0x00, 0x8a, 0x1d, 0x4f, 0x2c, + 0x00, 0x8a, 0x95, 0x36, 0x5d, 0x00, 0x8a, 0xee, + 0x35, 0xe4, 0x00, 0x8b, 0x56, 0x4e, 0xf9, 0x00, + 0x8c, 0xa0, 0x36, 0xb6, 0x00, 0x8c, 0xc7, 0x35, + 0xe6, 0x00, 0x8c, 0xca, 0x4e, 0xff, 0x00, 0x8c, + 0xfc, 0x35, 0xce, 0x00, 0x8f, 0x44, 0x4f, 0x03, + 0x00, 0x8f, 0xc5, 0x4f, 0x04, 0x00, 0x8f, 0xd4, + 0x4f, 0x05, 0x00, 0x90, 0x03, 0x36, 0x87, 0x00, + 0x90, 0x22, 0x34, 0x60, 0x00, 0x90, 0x38, 0x21, + 0xb9, 0x00, 0x90, 0x41, 0x4f, 0x3f, 0x00, 0x90, + 0x42, 0x36, 0x28, 0x00, 0x90, 0x55, 0x35, 0x49, + 0x00, 0x90, 0x75, 0x36, 0x01, 0x00, 0x90, 0x77, + 0x4f, 0x07, 0x00, 0x90, 0x89, 0x37, 0xa1, 0x00, + 0x90, 0x8a, 0x37, 0x9c, 0x00, 0x90, 0xa6, 0x36, + 0xcc, 0x00, 0x90, 0xaa, 0x35, 0xee, 0x00, 0x92, + 0x5b, 0x35, 0x5b, 0x00, 0x96, 0x86, 0x21, 0xee, + 0x00, 0x96, 0x98, 0x4f, 0x13, 0x00, 0x96, 0xa3, + 0x37, 0x0b, 0x00, 0x96, 0xc5, 0x35, 0x67, 0x00, + 0x97, 0x5c, 0x36, 0x32, 0x00, 0x97, 0x60, 0x35, + 0x37, 0x00, 0x97, 0x6d, 0x1f, 0x23, 0x00, 0x97, + 0x71, 0x35, 0x38, 0x00, 0x97, 0xff, 0x35, 0x9e, + 0x00, 0x98, 0xef, 0x4f, 0x25, 0x00, 0x99, 0x0c, + 0x34, 0x65, 0x00, 0x99, 0x45, 0x37, 0xb8, 0x00, + 0x99, 0x57, 0x35, 0x9f, 0x00, 0x9e, 0x9f, 0x37, + 0x0d, 0x00, 0x9f, 0x08, 0x37, 0xc4, 0x00, 0x9f, + 0x8d, 0x37, 0x07, 0x02, 0x36, 0x3a, 0x35, 0x9c, + 0x00, 0x00, 0x00, 0x11, 0x00, 0x51, 0xde, 0x4e, + 0x71, 0x00, 0x53, 0xa9, 0x34, 0x64, 0x00, 0x56, + 0xae, 0x4e, 0x7f, 0x00, 0x5b, 0xb3, 0x4e, 0x8f, + 0x00, 0x61, 0x68, 0x35, 0x6c, 0x00, 0x61, 0xf2, + 0x52, 0x50, 0x00, 0x66, 0x5f, 0x37, 0x39, 0x00, + 0x67, 0x17, 0x37, 0x12, 0x00, 0x69, 0x82, 0x35, + 0x70, 0x00, 0x75, 0x11, 0x4f, 0x3c, 0x00, 0x83, + 0xdf, 0x4e, 0xe9, 0x00, 0x90, 0x77, 0x4f, 0x08, + 0x00, 0x90, 0x89, 0x37, 0xa2, 0x00, 0x90, 0x8a, + 0x37, 0x9d, 0x00, 0x97, 0xff, 0x4f, 0x15, 0x00, + 0x99, 0x0c, 0x35, 0x52, 0x00, 0x99, 0x57, 0x4f, + 0x19, 0x00, 0x00, 0x00, 0x06, 0x00, 0x51, 0xde, + 0x21, 0x5e, 0x00, 0x53, 0xa9, 0x35, 0x4f, 0x00, + 0x61, 0x68, 0x35, 0x6d, 0x00, 0x90, 0x89, 0x37, + 0xa3, 0x00, 0x90, 0x8a, 0x37, 0x9e, 0x00, 0x97, + 0xff, 0x4f, 0x16, 0x00, 0x00, 0x00, 0x04, 0x00, + 0x53, 0xa9, 0x4f, 0x2f, 0x00, 0x61, 0x68, 0x35, + 0x6e, 0x00, 0x90, 0x89, 0x37, 0xa4, 0x00, 0x90, + 0x8a, 0x37, 0x9f, 0x00, 0x00, 0x00, 0x02, 0x00, + 0x90, 0x89, 0x37, 0xa5, 0x00, 0x90, 0x8a, 0x37, + 0xa0, 0x00, 0x00, 0x00, 0x02, 0x00, 0x90, 0x89, + 0x37, 0xa6, 0x00, 0x90, 0x8a, 0x4f, 0x0a, 0x00, + 0x00, 0x00, 0x01, 0x00, 0x90, 0x89, 0x37, 0xa7, + 0x00, 0x00, 0x00, 0x01, 0x00, 0x90, 0x89, 0x37, + 0xa8, 0x00, 0x00, 0x00, 0x01, 0x00, 0x90, 0x89, + 0x37, 0xa9, 0x00, 0x00, 0x00, 0x01, 0x00, 0x90, + 0x89, 0x37, 0xaa, 0x00, 0x00, 0x00, 0x01, 0x00, + 0x90, 0x89, 0x37, 0xab, 0x00, 0x00, 0x00, 0x01, + 0x00, 0x90, 0x89, 0x37, 0xac, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x90, 0x89, 0x4f, 0x09 + }; diff --git a/src/nsfns.m b/src/nsfns.m index 8eaf529ed04..574239873a0 100644 --- a/src/nsfns.m +++ b/src/nsfns.m @@ -46,6 +46,9 @@ Updated by Christian Limpach (chris@nice.ch) #ifdef NS_IMPL_COCOA #include +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 +#include "macfont.h" +#endif #endif #if 0 @@ -1171,7 +1174,16 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side } block_input (); + +#ifdef NS_IMPL_COCOA +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 + if (CTGetCoreTextVersion != NULL + && CTGetCoreTextVersion () >= kCTVersionNumber10_5) + mac_register_font_driver (f); +#endif +#endif register_font_driver (&nsfont_driver, f); + x_default_parameter (f, parms, Qfont_backend, Qnil, "fontBackend", "FontBackend", RES_TYPE_STRING); @@ -1181,8 +1193,13 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side x_default_parameter (f, parms, Qfontsize, make_number (0 /*(int)[font pointSize]*/), "fontSize", "FontSize", RES_TYPE_NUMBER); + // Remove ' Regular', not handled by backends. + char *fontname = xstrdup ([[font displayName] UTF8String]); + int len = strlen (fontname); + if (len > 8 && strcmp (fontname + len - 8, " Regular") == 0) + fontname[len-8] = '\0'; x_default_parameter (f, parms, Qfont, - build_string ([[font fontName] UTF8String]), + build_string (fontname), "font", "Font", RES_TYPE_STRING); } unblock_input (); @@ -1362,9 +1379,15 @@ Turn the input menu (an NSMenu) into a lisp list for tracking on lisp side { struct frame *f = decode_window_system_frame (frame); id fm = [NSFontManager sharedFontManager]; - - [fm setSelectedFont: ((struct nsfont_info *)f->output_data.ns->font)->nsfont - isMultiple: NO]; + struct font *font = f->output_data.ns->font; + NSFont *nsfont; + if (EQ (font->driver->type, Qns)) + nsfont = ((struct nsfont_info *)font)->nsfont; +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 + else + nsfont = (NSFont *) macfont_get_nsctfont (font); +#endif + [fm setSelectedFont: nsfont isMultiple: NO]; [fm orderFrontFontPanel: NSApp]; return Qnil; } diff --git a/src/nsfont.m b/src/nsfont.m index b61147d66c4..d9c8660f1cd 100644 --- a/src/nsfont.m +++ b/src/nsfont.m @@ -51,8 +51,6 @@ static Lisp_Object Qcondensed, Qexpanded; extern Lisp_Object Qappend; extern float ns_antialias_threshold; -extern int ns_tmp_flags; -extern struct nsfont_info *ns_tmp_font; /* font glyph and metrics caching functions, implemented at end */ @@ -798,6 +796,7 @@ when setting family in ns_spec_to_descriptor(). */ font_object = font_make_object (VECSIZE (struct nsfont_info), font_entity, pixel_size); + ASET (font_object, FONT_TYPE_INDEX, nsfont_driver.type); font_info = (struct nsfont_info *) XFONT_OBJECT (font_object); font = (struct font *) font_info; if (!font) @@ -871,10 +870,11 @@ when setting family in ns_spec_to_descriptor(). */ font_info->size = font->pixel_size; /* max bounds */ - font_info->max_bounds.ascent = lrint ([sfont ascender]); + font->ascent = font_info->max_bounds.ascent = lrint ([sfont ascender]); /* Descender is usually negative. Use floor to avoid clipping descenders. */ - font_info->max_bounds.descent = -lrint (floor(adjusted_descender)); + font->descent = + font_info->max_bounds.descent = -lrint (floor(adjusted_descender)); font_info->height = font_info->max_bounds.ascent + font_info->max_bounds.descent; font_info->max_bounds.width = lrint (font_info->width); @@ -1051,16 +1051,26 @@ is false when (FROM > 0 || TO < S->nchars). */ #endif struct face *face; NSRect r; - struct nsfont_info *font = ns_tmp_font; + struct nsfont_info *font; NSColor *col, *bgCol; unsigned short *t = s->char2b; - int i, len; + int i, len, flags; char isComposite = s->first_glyph->type == COMPOSITE_GLYPH; int end = isComposite ? s->cmp_to : s->nchars; block_input (); + + font = (struct nsfont_info *)s->face->font; + if (font == NULL) + font = (struct nsfont_info *)FRAME_FONT (s->f); + /* Select face based on input flags */ - switch (ns_tmp_flags) + flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR : + (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE : + (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND : + NS_DUMPGLYPH_NORMAL)); + + switch (flags) { case NS_DUMPGLYPH_CURSOR: face = s->face; @@ -1188,8 +1198,8 @@ is false when (FROM > 0 || TO < S->nchars). */ col = (NS_FACE_FOREGROUND (face) != 0 ? ns_lookup_indexed_color (NS_FACE_FOREGROUND (face), s->f) : FRAME_FOREGROUND_COLOR (s->f)); - /* FIXME: find another way to pass this */ - bgCol = (ns_tmp_flags != NS_DUMPGLYPH_FOREGROUND ? nil + + bgCol = (flags != NS_DUMPGLYPH_FOREGROUND ? nil : (NS_FACE_BACKGROUND (face) != 0 ? ns_lookup_indexed_color (NS_FACE_BACKGROUND (face), s->f) : FRAME_BACKGROUND_COLOR (s->f))); @@ -1264,22 +1274,19 @@ is false when (FROM > 0 || TO < S->nchars). */ CGContextSetTextPosition (gcontext, r.origin.x, r.origin.y); CGContextShowGlyphsWithAdvances (gcontext, s->char2b + s->cmp_from, - advances, len); + advances, len); if (face->overstrike) { CGContextSetTextPosition (gcontext, r.origin.x+0.5, r.origin.y); CGContextShowGlyphsWithAdvances (gcontext, s->char2b + s->cmp_from, - advances, len); + advances, len); } CGContextRestoreGState (gcontext); } #endif /* NS_IMPL_COCOA */ - /* Draw underline, overline, strike-through. */ - ns_draw_text_decoration (s, face, col, r.size.width, r.origin.x); - unblock_input (); return to-from; } diff --git a/src/nsterm.h b/src/nsterm.h index 487422b13db..1b5804b98b5 100644 --- a/src/nsterm.h +++ b/src/nsterm.h @@ -701,10 +701,8 @@ struct x_output #define FONT_WIDTH(f) ((f)->max_width) #define FONT_HEIGHT(f) ((f)->height) -/*#define FONT_BASE(f) ((f)->ascent) */ -#define FONT_BASE(f) (((struct nsfont_info *)f)->max_bounds.ascent) -/*#define FONT_DESCENT(f) ((f)->descent) */ -#define FONT_DESCENT(f) (((struct nsfont_info *)f)->max_bounds.descent) +#define FONT_BASE(f) ((f)->ascent) +#define FONT_DESCENT(f) ((f)->descent) #define FRAME_DEFAULT_FACE(f) FACE_FROM_ID (f, DEFAULT_FACE_ID) @@ -746,10 +744,6 @@ struct x_output #define FRAME_FONTSET(f) ((f)->output_data.ns->fontset) -#define FRAME_SMALLEST_CHAR_WIDTH(f) \ - (FRAME_DISPLAY_INFO (f)->smallest_char_width) -#define FRAME_SMALLEST_FONT_HEIGHT(f) \ - (FRAME_DISPLAY_INFO (f)->smallest_font_height) #define FRAME_BASELINE_OFFSET(f) ((f)->output_data.ns->baseline_offset) #define BLACK_PIX_DEFAULT(f) 0x000000 #define WHITE_PIX_DEFAULT(f) 0xFFFFFF @@ -904,8 +898,4 @@ extern char gnustep_base_version[]; /* version tracking */ ? (min) : (((x)>(max)) ? (max) : (x))) #define SCREENMAXBOUND(x) (IN_BOUND (-SCREENMAX, x, SCREENMAX)) -/* needed somewhere... */ -#define VERTICAL_SCROLL_BAR_WIDTH_TRIM (0) - - #endif /* HAVE_NS */ diff --git a/src/nsterm.m b/src/nsterm.m index 1dac6ba9fe4..2fc8a09c80f 100644 --- a/src/nsterm.m +++ b/src/nsterm.m @@ -64,6 +64,12 @@ Updated by Christian Limpach (chris@nice.ch) #include "process.h" #endif +#ifdef NS_IMPL_COCOA +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 +#include "macfont.h" +#endif +#endif + /* call tracing */ #if 0 int term_trace_num = 0; @@ -198,8 +204,6 @@ Updated by Christian Limpach (chris@nice.ch) #endif static BOOL gsaved = NO; static BOOL ns_fake_keydown = NO; -int ns_tmp_flags; /* FIXME */ -struct nsfont_info *ns_tmp_font; /* FIXME */ #ifdef NS_IMPL_COCOA static BOOL ns_menu_bar_is_hidden = NO; #endif @@ -2158,8 +2162,11 @@ Free a pool and temporary objects it refers to (callable from C) else { s->left_overhang = 0; - s->right_overhang = ((struct nsfont_info *)font)->ital ? - FONT_HEIGHT (font) * 0.2 : 0; + if (EQ (font->driver->type, Qns)) + s->right_overhang = ((struct nsfont_info *)font)->ital ? + FONT_HEIGHT (font) * 0.2 : 0; + else + s->right_overhang = 0; } } @@ -3133,8 +3140,10 @@ overwriting cursor (usually when cursor on a tab) */ { /* TODO (optimize): focus for box and contents draw */ NSRect r[2]; - int n; + int n, flags; char box_drawn_p = 0; + struct font *font = s->face->font; + if (! font) font = FRAME_FONT (s->f); NSTRACE (ns_draw_glyph_string); @@ -3201,13 +3210,10 @@ overwriting cursor (usually when cursor on a tab) */ ns_maybe_dumpglyphs_background (s, s->first_glyph->type == COMPOSITE_GLYPH); - ns_tmp_flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR : - (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE : - (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND : - NS_DUMPGLYPH_NORMAL)); - ns_tmp_font = (struct nsfont_info *)s->face->font; - if (ns_tmp_font == NULL) - ns_tmp_font = (struct nsfont_info *)FRAME_FONT (s->f); + flags = s->hl == DRAW_CURSOR ? NS_DUMPGLYPH_CURSOR : + (s->hl == DRAW_MOUSE_FACE ? NS_DUMPGLYPH_MOUSEFACE : + (s->for_overlaps ? NS_DUMPGLYPH_FOREGROUND : + NS_DUMPGLYPH_NORMAL)); if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR) { @@ -3216,10 +3222,21 @@ overwriting cursor (usually when cursor on a tab) */ NS_FACE_FOREGROUND (s->face) = tmp; } - ns_tmp_font->font.driver->draw + font->driver->draw (s, 0, s->nchars, s->x, s->y, - (ns_tmp_flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p) - || ns_tmp_flags == NS_DUMPGLYPH_MOUSEFACE); + (flags == NS_DUMPGLYPH_NORMAL && !s->background_filled_p) + || flags == NS_DUMPGLYPH_MOUSEFACE); + + { + NSColor *col = (NS_FACE_FOREGROUND (s->face) != 0 + ? ns_lookup_indexed_color (NS_FACE_FOREGROUND (s->face), + s->f) + : FRAME_FOREGROUND_COLOR (s->f)); + [col set]; + + /* Draw underline, overline, strike-through. */ + ns_draw_text_decoration (s, s->face, col, s->width, s->x); + } if (s->hl == DRAW_CURSOR && s->w->phys_cursor_type == FILLED_BOX_CURSOR) { @@ -3959,7 +3976,7 @@ static Lisp_Object ns_string_to_lispmod (const char *s) 0, /* define_fringe_bitmap */ /* FIXME: simplify ns_draw_fringe_bitmap */ 0, /* destroy_fringe_bitmap */ ns_compute_glyph_string_overhangs, - ns_draw_glyph_string, /* interface to nsfont.m */ + ns_draw_glyph_string, ns_define_frame_cursor, ns_clear_frame_area, ns_draw_window_cursor, @@ -4809,17 +4826,26 @@ - (void)dealloc /* called on font panel selection */ - (void)changeFont: (id)sender { - NSEvent *e =[[self window] currentEvent]; - struct face *face =FRAME_DEFAULT_FACE (emacsframe); + NSEvent *e = [[self window] currentEvent]; + struct face *face = FRAME_DEFAULT_FACE (emacsframe); + struct font *font = face->font; id newFont; CGFloat size; + NSFont *nsfont; NSTRACE (changeFont); + if (!emacs_event) return; - if ((newFont = [sender convertFont: - ((struct nsfont_info *)face->font)->nsfont])) + if (EQ (font->driver->type, Qns)) + nsfont = ((struct nsfont_info *)font)->nsfont; +#if MAC_OS_X_VERSION_MAX_ALLOWED >= MAC_OS_X_VERSION_10_5 + else + nsfont = (NSFont *) macfont_get_nsctfont (font); +#endif + + if ((newFont = [sender convertFont: nsfont])) { SET_FRAME_GARBAGED (emacsframe); /* now needed as of 2008/10 */ diff --git a/src/w32fns.c b/src/w32fns.c index 0e8b8ab5a5b..4cbbe1d5a80 100644 --- a/src/w32fns.c +++ b/src/w32fns.c @@ -1890,16 +1890,11 @@ w32_init_class (HINSTANCE hinst) static HWND w32_createscrollbar (struct frame *f, struct scroll_bar * bar) { - return (CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE, - /* Position and size of scroll bar. */ - XINT (bar->left) + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - XINT (bar->top), - XINT (bar->width) - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, - XINT (bar->height), - FRAME_W32_WINDOW (f), - NULL, - hinst, - NULL)); + return CreateWindow ("SCROLLBAR", "", SBS_VERT | WS_CHILD | WS_VISIBLE, + /* Position and size of scroll bar. */ + XINT (bar->left), XINT (bar->top), + XINT (bar->width), XINT (bar->height), + FRAME_W32_WINDOW (f), NULL, hinst, NULL); } static void diff --git a/src/w32term.c b/src/w32term.c index cb7327b21b7..af73e66d882 100644 --- a/src/w32term.c +++ b/src/w32term.c @@ -3866,8 +3866,7 @@ w32_set_vertical_scroll_bar (struct window *w, /* Make sure scroll bar is "visible" before moving, to ensure the area of the parent window now exposed will be refreshed. */ my_show_window (f, hwnd, SW_HIDE); - MoveWindow (hwnd, sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - top, sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, + MoveWindow (hwnd, sb_left, top, sb_width, max (height, 1), TRUE); si.cbSize = sizeof (si); diff --git a/src/w32term.h b/src/w32term.h index 5146fa8ef3a..1cbadadc84e 100644 --- a/src/w32term.h +++ b/src/w32term.h @@ -382,16 +382,6 @@ extern struct w32_output w32term_display; /* This is the `Display *' which frame F is on. */ #define FRAME_X_DISPLAY(f) (0) -/* Value is the smallest width of any character in any font on frame F. */ - -#define FRAME_SMALLEST_CHAR_WIDTH(F) \ - FRAME_DISPLAY_INFO(F)->smallest_char_width - -/* Value is the smallest height of any font on frame F. */ - -#define FRAME_SMALLEST_FONT_HEIGHT(F) \ - FRAME_DISPLAY_INFO(F)->smallest_font_height - #define FRAME_NORMAL_PLACEMENT(F) ((F)->output_data.w32->normal_placement) #define FRAME_PREV_FSMODE(F) ((F)->output_data.w32->prev_fsmode) @@ -483,21 +473,12 @@ struct scroll_bar { #define SET_SCROLL_BAR_W32_WINDOW(ptr, id) \ (SCROLL_BAR_UNPACK ((ptr)->w32_window_low, (ptr)->w32_window_high, (intptr_t) id)) -/* Extract the X widget of the scroll bar from a struct scroll_bar. */ -#define SCROLL_BAR_X_WIDGET(ptr) \ - ((Widget) SCROLL_BAR_PACK ((ptr)->x_widget_low, (ptr)->x_widget_high)) - -/* Store a widget id in a struct scroll_bar. */ -#define SET_SCROLL_BAR_X_WIDGET(ptr, w) \ - (SCROLL_BAR_UNPACK ((ptr)->x_widget_low, (ptr)->x_widget_high, (int) w)) - /* Return the inside width of a vertical scroll bar, given the outside width. */ #define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(f,width) \ ((width) \ - VERTICAL_SCROLL_BAR_LEFT_BORDER \ - - VERTICAL_SCROLL_BAR_RIGHT_BORDER \ - - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2) + - VERTICAL_SCROLL_BAR_RIGHT_BORDER) /* Return the length of the rectangle within which the top of the handle must stay. This isn't equivalent to the inside height, @@ -534,11 +515,6 @@ struct scroll_bar { /* Minimum lengths for scroll bar handles, in pixels. */ #define VERTICAL_SCROLL_BAR_MIN_HANDLE (vertical_scroll_bar_min_handle) -/* Trimming off a few pixels from each side prevents - text from glomming up against the scroll bar */ -#define VERTICAL_SCROLL_BAR_WIDTH_TRIM (0) - - struct frame; /* from frame.h */ extern void w32_fill_rect (struct frame *, HDC, COLORREF, RECT *); diff --git a/src/xfns.c b/src/xfns.c index ecd1ce7bc95..38aa5b3bbfe 100644 --- a/src/xfns.c +++ b/src/xfns.c @@ -42,8 +42,6 @@ along with GNU Emacs. If not, see . */ #include "termchar.h" #include "font.h" -#ifdef HAVE_X_WINDOWS - #include #include @@ -1470,9 +1468,8 @@ x_set_scroll_bar_default_width (struct frame *f) int minw = 16; #endif /* A minimum width of 14 doesn't look good for toolkit scroll bars. */ - int width = minw + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM; - FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid; - FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width; + FRAME_CONFIG_SCROLL_BAR_COLS (f) = (minw + wid - 1) / wid; + FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = minw; #else /* Make the actual width at least 14 pixels and a multiple of a character width. */ @@ -6186,5 +6183,3 @@ When using Gtk+ tooltips, the tooltip face is not used. */); defsubr (&Sx_select_font); #endif } - -#endif /* HAVE_X_WINDOWS */ diff --git a/src/xterm.c b/src/xterm.c index 45155bc2a65..9c410569b7a 100644 --- a/src/xterm.c +++ b/src/xterm.c @@ -23,8 +23,6 @@ along with GNU Emacs. If not, see . */ #include #include -#ifdef HAVE_X_WINDOWS - #include "lisp.h" #include "blockinput.h" #include "syssignal.h" @@ -3030,26 +3028,7 @@ XTflash (struct frame *f) /* These will be the left and right margins of the rectangles. */ int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f); int flash_right = FRAME_PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f); - - int width; - - /* Don't flash the area between a scroll bar and the frame - edge it is next to. */ - switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f)) - { - case vertical_scroll_bar_left: - flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM; - break; - - case vertical_scroll_bar_right: - flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM; - break; - - default: - break; - } - - width = flash_right - flash_left; + int width = flash_right - flash_left; /* If window is tall, flash top and bottom line. */ if (height > 3 * FRAME_LINE_HEIGHT (f)) @@ -5064,12 +5043,9 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height) window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), /* Position and size of scroll bar. */ - left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - top, - width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, - height, + left, top, width, height, /* Border width, depth, class, and visual. */ - 0, + 0, CopyFromParent, CopyFromParent, CopyFromParent, @@ -5104,19 +5080,11 @@ x_scroll_bar_create (struct window *w, int top, int left, int width, int height) #ifdef USE_TOOLKIT_SCROLL_BARS { #ifdef USE_GTK - xg_update_scrollbar_pos (f, - bar->x_window, - top, - left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, - max (height, 1)); + xg_update_scrollbar_pos (f, bar->x_window, top, + left,width, max (height, 1)); #else /* not USE_GTK */ Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar); - XtConfigureWidget (scroll_bar, - left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - top, - width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, - max (height, 1), 0); + XtConfigureWidget (scroll_bar, left, top, width, max (height, 1), 0); XtMapWidget (scroll_bar); #endif /* not USE_GTK */ } @@ -5364,33 +5332,15 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio left, top, width, height); } #ifdef USE_GTK - xg_update_scrollbar_pos (f, - bar->x_window, - top, - sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM *2, - max (height, 1)); + xg_update_scrollbar_pos (f, bar->x_window, top, + sb_left, sb_width, max (height, 1)); #else /* not USE_GTK */ XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar), - sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM, - top, - sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2, - max (height, 1), 0); + sb_left, top, sb_width, max (height, 1), 0); #endif /* not USE_GTK */ } #else /* not USE_TOOLKIT_SCROLL_BARS */ - /* Clear areas not covered by the scroll bar because of - VERTICAL_SCROLL_BAR_WIDTH_TRIM. */ - if (VERTICAL_SCROLL_BAR_WIDTH_TRIM) - { - x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), - left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM, height); - x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), - left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM, - top, VERTICAL_SCROLL_BAR_WIDTH_TRIM, height); - } - /* Clear areas not covered by the scroll bar because it's not as wide as the area reserved for it. This makes sure a previous mode line display is cleared after C-x 2 C-x 1, for @@ -5414,9 +5364,9 @@ XTset_vertical_scroll_bar (struct window *w, int portion, int whole, int positio { XWindowChanges wc; - wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM; + wc.x = sb_left; wc.y = top; - wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2; + wc.width = sb_width; wc.height = height; XConfigureWindow (FRAME_X_DISPLAY (f), bar->x_window, mask, &wc); @@ -5579,7 +5529,6 @@ x_scroll_bar_expose (struct scroll_bar *bar, XEvent *event) Window w = bar->x_window; struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window))); GC gc = f->output_data.x->normal_gc; - int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM; block_input (); @@ -5592,11 +5541,8 @@ x_scroll_bar_expose (struct scroll_bar *bar, XEvent *event) /* Draw a one-pixel border just inside the edges of the scroll bar. */ XDrawRectangle (FRAME_X_DISPLAY (f), w, gc, - /* x, y, width, height */ - 0, 0, - bar->width - 1 - width_trim - width_trim, - bar->height - 1); + 0, 0, bar->width - 1, bar->height - 1); /* Restore the foreground color of the GC if we changed it above. */ if (f->output_data.x->scroll_bar_foreground_pixel != -1) @@ -10883,5 +10829,3 @@ default is nil, which is the same as `super'. */); make_float (DEFAULT_REHASH_THRESHOLD), Qnil); } - -#endif /* HAVE_X_WINDOWS */ diff --git a/src/xterm.h b/src/xterm.h index 3c091b7afcd..2703c743292 100644 --- a/src/xterm.h +++ b/src/xterm.h @@ -78,10 +78,11 @@ typedef GtkWidget *xt_or_gtk_widget; #include "dispextern.h" #include "termhooks.h" -#define BLACK_PIX_DEFAULT(f) BlackPixel (FRAME_X_DISPLAY (f), \ - XScreenNumberOfScreen (FRAME_X_SCREEN (f))) -#define WHITE_PIX_DEFAULT(f) WhitePixel (FRAME_X_DISPLAY (f), \ - XScreenNumberOfScreen (FRAME_X_SCREEN (f))) +/* Black and white pixel values for the screen which frame F is on. */ +#define BLACK_PIX_DEFAULT(f) \ + BlackPixel (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f)) +#define WHITE_PIX_DEFAULT(f) \ + WhitePixel (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f)) #define FONT_WIDTH(f) ((f)->max_width) #define FONT_HEIGHT(f) ((f)->ascent + (f)->descent) @@ -707,6 +708,8 @@ enum /* This is the `Screen *' which frame F is on. */ #define FRAME_X_SCREEN(f) (FRAME_DISPLAY_INFO (f)->screen) + +/* This is the screen index number of screen which frame F is on. */ #define FRAME_X_SCREEN_NUMBER(f) XScreenNumberOfScreen (FRAME_X_SCREEN (f)) /* This is the Visual which frame F is on. */ @@ -731,16 +734,6 @@ enum #define FRAME_XIC_STYLE(f) ((f)->output_data.x->xic_style) #define FRAME_XIC_FONTSET(f) ((f)->output_data.x->xic_xfs) -/* Value is the smallest width of any character in any font on frame F. */ - -#define FRAME_SMALLEST_CHAR_WIDTH(F) \ - FRAME_DISPLAY_INFO(F)->smallest_char_width - -/* Value is the smallest height of any font on frame F. */ - -#define FRAME_SMALLEST_FONT_HEIGHT(F) \ - FRAME_DISPLAY_INFO(F)->smallest_font_height - /* X-specific scroll bar stuff. */ /* We represent scroll bars as lisp vectors. This allows us to place @@ -803,6 +796,7 @@ struct scroll_bar /* Turning a lisp vector value into a pointer to a struct scroll_bar. */ #define XSCROLL_BAR(vec) ((struct scroll_bar *) XVECTOR (vec)) +#ifdef USE_X_TOOLKIT /* Extract the X widget of the scroll bar from a struct scroll_bar. XtWindowToWidget should be fast enough since Xt uses a hash table @@ -819,14 +813,14 @@ struct scroll_bar ptr->x_window = window; \ } while (0) +#endif /* USE_X_TOOLKIT */ /* Return the inside width of a vertical scroll bar, given the outside width. */ #define VERTICAL_SCROLL_BAR_INSIDE_WIDTH(f, width) \ ((width) \ - VERTICAL_SCROLL_BAR_LEFT_BORDER \ - - VERTICAL_SCROLL_BAR_RIGHT_BORDER \ - - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2) + - VERTICAL_SCROLL_BAR_RIGHT_BORDER) /* Return the length of the rectangle within which the top of the handle must stay. This isn't equivalent to the inside height, @@ -863,11 +857,6 @@ struct scroll_bar /* Minimum lengths for scroll bar handles, in pixels. */ #define VERTICAL_SCROLL_BAR_MIN_HANDLE (5) -/* Trimming off a few pixels from each side prevents - text from glomming up against the scroll bar */ -#define VERTICAL_SCROLL_BAR_WIDTH_TRIM (0) - - /* If a struct input_event has a kind which is SELECTION_REQUEST_EVENT or SELECTION_CLEAR_EVENT, then its contents are really described by this structure. */ diff --git a/test/ChangeLog b/test/ChangeLog index 21b22425fb6..85119db69f2 100644 --- a/test/ChangeLog +++ b/test/ChangeLog @@ -1,3 +1,9 @@ +2013-09-15 Glenn Morris + + * automated/eshell.el (eshell-test/for-name-shadow-loop): + New test. (Bug#15372) + (eshell-test/for-loop, eshell-test/for-name-loop): Doc fix. + 2013-09-13 Glenn Morris * automated/eshell.el (with-temp-eshell): diff --git a/test/automated/eshell.el b/test/automated/eshell.el index b9eb31660f1..6f7a35371a6 100644 --- a/test/automated/eshell.el +++ b/test/automated/eshell.el @@ -75,17 +75,23 @@ (should (equal (eshell-test-command-result "(+ 1 2)") 3))) (ert-deftest eshell-test/for-loop () - "Test `eshell-command-result' with an elisp command." + "Test `eshell-command-result' with a for loop.." (let ((process-environment (cons "foo" process-environment))) (should (equal (eshell-test-command-result "for foo in 5 { echo $foo }") 5)))) (ert-deftest eshell-test/for-name-loop () ;Bug#15231 - "Test `eshell-command-result' with an elisp command." + "Test `eshell-command-result' with a for loop using `name'." (let ((process-environment (cons "name" process-environment))) (should (equal (eshell-test-command-result "for name in 3 { echo $name }") 3)))) +(ert-deftest eshell-test/for-name-shadow-loop () ; bug#15372 + "Test `eshell-command-result' with a for loop using an env-var." + (let ((process-environment (cons "name=env-value" process-environment))) + (should (equal (eshell-test-command-result + "for name in 3 { echo $name }") 3)))) + (ert-deftest eshell-test/lisp-command-args () "Test `eshell-command-result' with elisp and trailing args. Test that trailing arguments outside the S-expression are diff --git a/test/indent/ruby.rb b/test/indent/ruby.rb index af1bbb9d8ab..6c9b9775b48 100644 --- a/test/indent/ruby.rb +++ b/test/indent/ruby.rb @@ -71,3 +71,7 @@ def test2 (arg) if something == :== do_something end + +# Bug#15369 +MSG = 'Separate every 3 digits in the integer portion of a number' \ + 'with underscores(_).'